/* IR NeoPixel Controller - see http://www.technoblogy.com/show?5H4W

   David Johnson-Davies - www.technoblogy.com - 2nd June 2026
   AVR64DD14 @ 24 MHz (internal oscillator; BOD disabled; PF6 input)
   
   CC BY 4.0
   Licensed under a Creative Commons Attribution 4.0 International license: 
   http://creativecommons.org/licenses/by/4.0/
*/

#include <EEPROM.h>

#define RGB     // Options: RGB, GRB, RGBW, GRBW

// NeoPixel data **********************************************

const int NumPixels = 9;                                  // Number of LEDs

#if defined(RGB) || defined(GRB)
const int Channels = 3;
#else
const int Channels = 4;
#endif

union { 
  uint8_t col[NumPixels][Channels]; 
  uint8_t out[NumPixels*Channels]; 
} Buffer;                                                  // Display buffer

volatile int BufPtr;
enum colour { RED, GRN, BLU, WHI };                       // Channel numbers
enum control { HUE, SATN, VALUE };                        // HSV numbers

#if defined(RGB) || defined(RGBW)                         // Order of NeoPixels
uint8_t Order[] = { RED, GRN, BLU, WHI };                 // White optional
#else
uint8_t Order[] = { GRN, RED, BLU, WHI };                 // White optional
#endif

// Save state in EEPROM **********************************************

const int Version = 2;

struct {
  uint8_t flag = NumPixels;                               // Check if changed
  uint8_t Control[NumPixels+1][3];                        // Control values
  uint8_t LED = 1;                                        // 1 to 9 or 0 = all
  bool Animate = false;                                   // Changing display
  bool On = true;                                         // Switch LEDs on/off
} State;

volatile int SaveInterval = 10;                           // Save every 10 secs

// IR Remote **********************************************

// Values for Adafruit IR remote
const uint16_t IRAddress = 0xbf00;
enum keycode { VOLM = 0x00,  PLAY = 0x01,  VOLP = 0x02,
               SETUP = 0x04, UP = 0x05,    STOP = 0x06,
               LEFT = 0x08,  ENTER = 0x09, RIGHT = 0x0a,
               ZERO = 0x0c,  DOWN = 0x0d,  RETURN = 0x0e,
               ONE = 0x10,   TWO = 0x11,   THREE = 0x12,
               FOUR = 0x14,  FIVE = 0x15,  SIX = 0x16,
               SEVEN = 0x18, EIGHT = 0x19, NINE = 0x1a };

const int IRpin = PIN_PF6;
volatile uint8_t Ticks;
volatile int8_t NextBit;                                   // Next bit to receive

uint8_t KeyNumber (uint8_t keycode) {                      // Convert key to number
  uint8_t base = keycode - 16;
  uint8_t jump = base / 4;
  return base - jump + 1;
}

void Error (bool on) {
  if (on) PORTC.OUTSET = PIN2_bm; else PORTC.OUTCLR = PIN2_bm;
} 

void ProcessCode (uint32_t code, bool repeat) {
  uint16_t address = code & 0xffff;
  uint8_t key = code >> 16 & 0xff;
  uint8_t id = code >> 24 & 0xff;
  
  if (address != IRAddress) return;                        // Check for remote
  uint8_t n = State.LED;
  
  switch (key) {
    case UP:    if (State.Control[n][VALUE] <= 253) State.Control[n][VALUE]+=2;
                else Error(true); break;                                             // UP increases brightness
    case DOWN:  if (State.Control[n][VALUE] >= 2) State.Control[n][VALUE]-=2; 
                else Error(true); break;                                             // DOWN reduces brightness
    case RIGHT: State.Control[n][HUE] = State.Control[n][HUE] + 1; break;            // RIGHT increases hue
    case LEFT:  State.Control[n][HUE] = State.Control[n][HUE] - 1; break;            // LEFT reduces hue
    case VOLP:  if (State.Control[n][SATN] <= 253) State.Control[n][SATN]+=2;
                else Error(true); break;                                             // VOLP increases saturation
    case VOLM:  if (State.Control[n][SATN] >= 2) State.Control[n][SATN]-=2;
                else Error(true); break;                                             // VOLM reduces saturation
    case STOP:  if (!repeat) State.On = !State.On; break;                            // STOP toggles all on/off
    case ZERO:  State.LED = 0; break;                                                // 0 controls all LEDs
    case ONE ... NINE: State.LED = KeyNumber(key); break;                            // 1 to 9 selects an LED
    case PLAY:  if (!repeat) State.Animate = !State.Animate; break;                  // Toggle animation
  }
}

void ConfigureIRReceiver () {
  // Configure Timer/Counter TCB0 to time in units of 112.5us
  TCB0.CCMP = 2700-1;                                     // 112.5us
  TCB0.CTRLA = TCB_CLKSEL_DIV1_gc | TCB_ENABLE_bm;        // Divide timer by 1
  TCB0.CTRLB = 0;                                         // Periodic Interrupt mode
  TCB0.INTCTRL = TCB_CAPT_bm;                             // Overflow interrupt

  // Set up pin-change interrupt on IRpin
  PORTF.PIN6CTRL = PORT_PULLUPEN_bm | PORT_ISC_FALLING_gc;// Interrupt falling edge
  NextBit = -1;                                           // Wait for AGC start pulse
}

// Timer/Counter TCB interrupt - counts in units of 112.5us
ISR(TCB0_INT_vect) {
  TCB0.INTFLAGS = TCB_CAPT_bm;                            // Clear interrupt flag
  if (Ticks < 255) Ticks++;
}

// Counts in units of 112.5us
const int ZeroBit = 10;                                   // 10 * 112.5us = 1.125ms
const int OneBit  = 20;                                   // 20 * 112.5us = 2.25ms
const int RepeatPulse = 100;                              // 100 * 112.5us = 11.25ms
const int AGCPulse = 120;                                 // 120 * 112.5us = 13.5ms

// Interrupt service routine - called on every falling edge of IRpin
ISR (PORTF_PORT_vect) {
  static uint32_t RecdData;
  // Waiting for AGC pulse and gap
  int Time = Ticks;
  if (NextBit == -1) {                                    // Waiting for AGC pulse
    if ((Time > AGCPulse-10) && (Time <= AGCPulse+10)) {  // Got AGC pulse
      RecdData = 0; NextBit = 0;
    } else if ((Time > RepeatPulse-10) && (Time <= RepeatPulse+10)) {
      ProcessCode(RecdData, true);                        // Repeat code
    }
  } else {                                                // Data bit
    if ((Time > OneBit+5) || (Time == 255)) NextBit = -1; // Fail - restart
    else {
      if (Time > OneBit-5) {                              // Bit = '1'
        RecdData = RecdData | ((unsigned long) 1<<NextBit);
      }
      NextBit++;
      if (NextBit == 32) {                                // Got complete code
        ProcessCode(RecdData, false);                     // Normal code                     
        NextBit = -1;                                     // Go back to waiting
      }
    }
  }
  Ticks = 0;                                              // Clear counter
  PORTF.INTFLAGS = PIN6_bm;                               // Clear interrupt flag
}

// NeoPixel Driver **********************************************

void ConfigureNeoPixel () {
  // Configure Timer/Counter Type A to generate two waveforms
  PORTMUX.TCAROUTEA = PORTMUX_TCA0_PORTA_gc;              // Clear routing
  TCA0.SINGLE.CTRLD = 0;                                  // Normal mode
  PORTA.DIRSET = PIN0_bm | PIN1_bm;                       // WO0 and WO1 outputs
  TCA0.SINGLE.CTRLA = TCA_SINGLE_CLKSEL_DIV1_gc;          // Clock divided by 1
  TCA0.SINGLE.CTRLB = TCA_SINGLE_WGMODE_SINGLESLOPE_gc    // Single-slope PWM ...
    | TCA_SINGLE_CMP0EN_bm | TCA_SINGLE_CMP1EN_bm;        // waveform on WO0 and WO1
  TCA0.SINGLE.PER = 30-1;                                 // Period is 1250ns
  TCA0.SINGLE.CMP0 = 8-1;                                 // WO0 (PA0) is 333.33ns
  TCA0.SINGLE.CMP1 = 17-1;                                // WO1 (PA1) is 708.33ns

  // Configure SPI0 in client mode
  CPUINT.LVL1VEC = 20;                                    // Give SPI0_INT priority
  PORTMUX.SPIROUTEA = PORTMUX_SPI0_ALT4_gc;               // PD4, PD5, PD6, PD7
  PORTD.DIRSET = PIN5_bm;                                 // MISO output
  SPI0.CTRLB = SPI_BUFEN_bm | SPI_BUFWR_bm                // Buffer mode ...
    | SPI_MODE_0_gc;                                      // transfer mode 0
  SPI0.CTRLA = SPI_ENABLE_bm;                             // Enable in client mode

  // Use CCL to make a gate between TCA0 WO0, TCA0 WO1, and MISO
  CCL.LUT1CTRLB = CCL_INSEL0_TCA0_gc | CCL_INSEL1_TCA0_gc;// TCA0 WO0 and WO1
  CCL.LUT1CTRLC = CCL_INSEL2_EVENTA_gc;                   // LUT1 EVENTA
  CCL.TRUTH1 = 0b11001010;
  CCL.LUT1CTRLA = CCL_OUTEN_bm | CCL_ENABLE_bm;           // Enable, output on PC3

  CCL.CTRLA = CCL_ENABLE_bm;                              // Enable CCL last

  // Use Events to copy the MISO output to LUT1 IN2
  EVSYS.CHANNEL2 = EVSYS_CHANNEL2_PORTD_PIN5_gc;          // Link PD5 ...
  EVSYS.USERCCLLUT1A = EVSYS_USER_CHANNEL2_gc;            // ... to LUT1 EVENTA

  // Use Events to copy PC1 to PD7
  PORTMUX.EVSYSROUTEA = PORTMUX_EVOUTD_ALT1_gc;           // EVOUTD on PD7
  EVSYS.CHANNEL3 = EVSYS_CHANNEL3_PORTC_PIN1_gc;          // Link PC1 ...
  EVSYS.USEREVSYSEVOUTD = EVSYS_USER_CHANNEL3_gc;         // ... and PD7

  // Pins
  PORTC.OUTSET = PIN1_bm;
  PORTC.DIRSET = PIN1_bm;                                 // PC1 EN output high
}

ISR(SPI0_INT_vect) {
  if (BufPtr < NumPixels*Channels) {                      // More data to write?
    SPI0.DATA = Buffer.out[BufPtr++];                     // Output byte, clears flag
  } else if (SPI0.INTFLAGS & SPI_TXCIF_bm) {              // Shift register empty?
    PORTC.OUTSET = PIN1_bm;                               // Take EN high to stop SPI
    TCA0.SINGLE.CMP0 = 0;                                 // WO0 constant low signal
    TCA0.SINGLE.CMP1 = 0;                                 // WO1 constant low signal
    SPI0.INTFLAGS = SPI_TXCIF_bm;                         // Clear flag
    SPI0.INTCTRL = 0;                                     // Disable interrupts
  } else {
    SPI0.INTFLAGS = SPI_DREIF_bm;                         // Clear flag
    SPI0.INTCTRL = SPI0.INTCTRL &~SPI_DREIE_bm;           // Disable DREIF interrupt
  }
}

void StartNeoPixel () {
  BufPtr = 0;
  SPI0.DATA = Buffer.out[BufPtr++];                       // Initial data
  SPI0.DATA = Buffer.out[BufPtr++];                       // Initial data
  SPI0.INTCTRL = SPI_DREIE_bm | SPI_TXCIE_bm;             // Enable interrupts
  TCA0.SINGLE.CTRLA &= ~TCA_SINGLE_ENABLE_bm;             // Stop Timer/Counter
  TCA0.SINGLE.CMP0 = 8-1;                                 // WO0 (PA0) is 333.33ns
  TCA0.SINGLE.CMP1 = 17-1;                                // WO1 (PA1) is 708.33ns
  TCA0.SINGLE.CNT = 0;                                    // Clear Timer/Counter
  PORTC.OUTCLR = PIN1_bm;                                 // EN low to start output
  TCA0.SINGLE.CTRLA |= TCA_SINGLE_ENABLE_bm;              // Start Timer/Counter
}

// Utilities **********************************************

// Fractional part of x
float fract (float a) { return a - floorf(a); }

// Clamp to 0.0 to 1.0
float clamp (float v) { return (v<0.0) ? 0.0 : (v>1.0) ? 1.0 : v; }

// Triangle function
float tri (float m) { return 2.0 * fabsf(fract(m + 0.5) - 0.5); }

float hsv (int k, float h, float s, float v) {
#if defined(RGB) || defined(GRB)                          // 3 channels
  return clamp(2.0 - (3.0 * tri(h - k/3.0))) * v * s + v * (1 - s);
#else                                                     // 4 channels
  if (k == 3) return v * (1 - s);                         // White channel
  else return clamp(2.0 - (3.0 * tri(h - k/3.0))) * v * s;
#endif
}

// Setup and main loop **********************************************

void ResetState () {
  for (int n=0; n<NumPixels+1; n++) {                     // First time
    State.Control[n][HUE]   = 0;                          // Red
    State.Control[n][SATN]  = 255;                        // Maximum saturation
    State.Control[n][VALUE] = 0;                          // All LEDs initially off
    State.LED = 1;
    State.Animate = false;
    State.On = true;
  }
}

void setup () {
  if (EEPROM.read(0) == NumPixels) EEPROM.get(0, State);  // Only read if valid
  else ResetState();
  ConfigureNeoPixel();
  ConfigureIRReceiver();
  PORTC.DIRSET = PIN2_bm;                                 // PC2 Error output
}

unsigned long Start = millis();

void Refresh () {
  unsigned long t = millis();
  static float z = 0.0;
  if (State.Animate) z = z + 0.0001;
  StartNeoPixel();                                        // Runs under interrupt

  for (uint8_t n=0; n<NumPixels; n++) {                   // For every LED
    uint8_t *Out = Buffer.col[n];
    uint8_t *Ctrl;
    if (State.LED == 0)
      Ctrl = State.Control[0]; else Ctrl = State.Control[n+1];
    float h = Ctrl[HUE]/255.0 + z, s = Ctrl[SATN]/255.0, v = Ctrl[VALUE]/255.0;

    while (BufPtr <= n*Channels);                         // Wait until output
    for (int k=0; k<Channels; k++) {                      // For each channel
      float value = hsv(k, h, s, v);                      // Evaluate the pattern     
      Out[Order[k]] = 255 * value * State.On;             // Output the value
    }
  }

  if (millis() - Start > SaveInterval*1000) {
    EEPROM.put(0, State);                                 // Save settings
    Start = millis();
  }
  
  if (millis()-t >= 25) Error(true); else Error (false);  // Error light
  
  while (millis() - t < 20);                              // Wait until 20ms tick
}

void loop() {
  Refresh();
}