/* Light Lab - see http://www.technoblogy.com/show?5DCO

   David Johnson-Davies - www.technoblogy.com - 14th January 2026
   AVR128DB28 @ 24 MHz, Bootloader Serial Port: "USART0 (default pins)"
   
   CC BY 4.0
   Licensed under a Creative Commons Attribution 4.0 International license: 
   http://creativecommons.org/licenses/by/4.0/
*/

#include <Wire.h>
#include <SPI.h>
#include <EEPROM.h>

// Fixed-point arithmetic  **********************************************

typedef int16_t Fixed; // Fixed point, 8.8 bits

// Fixed-point constants

const Fixed zero      = 0x000;
const Fixed sixth     = 0x02b;
const Fixed quarter   = 0x040;
const Fixed third     = 0x055;
const Fixed half      = 0x080;
const Fixed twothirds = 0x0ab;
const Fixed one       = 0x100;

Fixed Gamma[257];                                              // gamma lookup table

// Pattern typedefs  **********************************************

const int PATTERNS = 22;
typedef Fixed (*fn_ptr_type)(uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c);

typedef const struct {
  fn_ptr_type patfn;
  const char *title1, *title2;
  const char *label1, *label2, *label3;
  bool twoway;
} pattern_t;

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

const int LEDTYPES = 3;
enum rgb { red, green, blue };

typedef const struct {
  const char *label;
  bool neopixel;
  uint8_t order[3];
} led_type_t;

led_type_t LEDtype[LEDTYPES] = {
  { "DotStar ", false, { blue, green, red }},
  { "Neo GRB",  true, { green, red, blue }},
  { "Neo RGB",  true, { red, green, blue }}
};

struct {
  uint8_t flag     = 0;       // Check for blank EEPROM
  int     leds     = 20;      // Number of LEDs: 20 to 160
  uint8_t led_type = 0;       // Index in array LEDtype[LEDTYPES]
  bool    neopixel = true;    // Type: false = DotStar, true = NeoPixel
  uint8_t bright   = 0;       // Global brightness: 0 (min) to 4 (max)
  uint8_t pattern  = 1;       // Current pattern
} State;

// NeoPixel (WS2812) Driver **********************************************

const int MaxLEDs = 160;
union { uint8_t col[MaxLEDs][3]; uint8_t out[MaxLEDs*3]; } Buffer;
volatile int BufPtr;

void ConfigureNeoPixel () {
  // Configure Timer/Counter Type A to generate two waveforms
  PORTMUX.TCAROUTEA = PORTMUX_TCA0_PORTF_gc;              // WO0, WO1 to PF0, PF1
  TCA0.SINGLE.CTRLD = 0;                                  // Normal mode
  PORTF.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 (PF0) is 333.33ns
  TCA0.SINGLE.CMP1 = 17-1;                                // WO1 (PF1) is 708.33ns

  // Configure SPI0 in client mode
  PORTA.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_ENABLE_bm;                          // Enable, no output on PC3

  CCL.CTRLA = CCL_ENABLE_bm;                              // Enable CCL last

  // Use Events to copy the MISO output to LUT1 IN2
  EVSYS.CHANNEL0 = EVSYS_CHANNEL0_PORTA_PIN5_gc;          // Link PA5 ...
  EVSYS.USERCCLLUT1A = EVSYS_USER_CHANNEL0_gc;            // ... to LUT1 EVENTA

  // Use Events to copy PD6 to PA7 (SS)
  PORTMUX.EVSYSROUTEA = PORTMUX_EVOUTA_ALT1_gc;           // EVOUTA on PA7
  EVSYS.CHANNEL2 = EVSYS_CHANNEL2_PORTD_PIN6_gc;          // Link PD6 ...
  EVSYS.USEREVSYSEVOUTA = EVSYS_USER_CHANNEL2_gc;         // ... and PA7

  // Use Events to move LUT1 OUT to PC2
  EVSYS.CHANNEL1 = EVSYS_CHANNEL1_CCL_LUT1_gc;            // Link LUT1 OUT ...
  EVSYS.USEREVSYSEVOUTC = EVSYS_USER_CHANNEL1_gc;         // ... to PC2
  
  // Pins
  PORTD.OUTSET = PIN6_bm;
  PORTD.DIRSET = PIN6_bm;                                 // PD6 EN output high
}

ISR(SPI0_INT_vect) {
  if (BufPtr < State.leds*3) {                            // More data to write?
    SPI0.DATA = Buffer.out[BufPtr++];                     // Output byte, clears flag
  } else if (SPI0.INTFLAGS & SPI_TXCIF_bm) {              // Shift register empty?
    PORTD.OUTSET = PIN6_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
  PORTD.OUTCLR = PIN6_bm;                                 // EN low to start output
  TCA0.SINGLE.CTRLA |= TCA_SINGLE_ENABLE_bm;              // Start Timer/Counter
}

// DotStar (APA102 or SK9822) Driver **********************************************

void ConfigureDotStar () {
  pinMode(PIN_PC3, OUTPUT);                               // SPI1 SS pin
  SPI.swap(SPI1_SWAP_DEFAULT);
  SPI.begin();
}

void StartDotStar () {
  for (int i=0; i<4; i++) SPI.transfer(0);                // Start frame
}

void TransferDotStar (int p, uint8_t bright) {
  SPI.transfer(bright + 0xE0);                            // Brightness 31 max
  SPI.transfer(Buffer.col[p][0]);
  SPI.transfer(Buffer.col[p][1]);
  SPI.transfer(Buffer.col[p][2]);
}

void EndDotStar () {
  for (int i=0; i<8; i++) {
    SPI.transfer(0xff);                                   // End frame at least LEDs/2 bits of '1'
  }
}

// I2C OLED display **********************************************

int const address = 60;
int const commands = 0x00;
int const onecommand = 0x80;
int const data = 0x40;
int const onedata = 0xC0;

// Character set - stored in program memory
const uint8_t CharMap[][6] PROGMEM = {
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 
{ 0x00, 0x00, 0x5F, 0x00, 0x00, 0x00 }, 
{ 0x00, 0x07, 0x00, 0x07, 0x00, 0x00 }, 
{ 0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00 }, 
{ 0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00 }, 
{ 0x23, 0x13, 0x08, 0x64, 0x62, 0x00 }, 
{ 0x36, 0x49, 0x56, 0x20, 0x50, 0x00 }, 
{ 0x00, 0x08, 0x07, 0x03, 0x00, 0x00 }, 
{ 0x00, 0x1C, 0x22, 0x41, 0x00, 0x00 }, 
{ 0x00, 0x41, 0x22, 0x1C, 0x00, 0x00 }, 
{ 0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00 }, 
{ 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00 }, 
{ 0x00, 0x80, 0x70, 0x30, 0x00, 0x00 }, 
{ 0x08, 0x08, 0x08, 0x08, 0x08, 0x00 }, 
{ 0x00, 0x00, 0x60, 0x60, 0x00, 0x00 }, 
{ 0x20, 0x10, 0x08, 0x04, 0x02, 0x00 }, 
{ 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00 }, 
{ 0x00, 0x42, 0x7F, 0x40, 0x00, 0x00 }, 
{ 0x72, 0x49, 0x49, 0x49, 0x46, 0x00 }, 
{ 0x21, 0x41, 0x49, 0x4D, 0x33, 0x00 }, 
{ 0x18, 0x14, 0x12, 0x7F, 0x10, 0x00 }, 
{ 0x27, 0x45, 0x45, 0x45, 0x39, 0x00 }, 
{ 0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00 }, 
{ 0x41, 0x21, 0x11, 0x09, 0x07, 0x00 }, 
{ 0x36, 0x49, 0x49, 0x49, 0x36, 0x00 }, 
{ 0x46, 0x49, 0x49, 0x29, 0x1E, 0x00 }, 
{ 0x00, 0x36, 0x36, 0x00, 0x00, 0x00 }, 
{ 0x00, 0x56, 0x36, 0x00, 0x00, 0x00 }, 
{ 0x00, 0x08, 0x14, 0x22, 0x41, 0x00 }, 
{ 0x14, 0x14, 0x14, 0x14, 0x14, 0x00 }, 
{ 0x00, 0x41, 0x22, 0x14, 0x08, 0x00 }, 
{ 0x02, 0x01, 0x59, 0x09, 0x06, 0x00 }, 
{ 0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00 }, 
{ 0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00 }, 
{ 0x7F, 0x49, 0x49, 0x49, 0x36, 0x00 }, 
{ 0x3E, 0x41, 0x41, 0x41, 0x22, 0x00 }, 
{ 0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00 }, 
{ 0x7F, 0x49, 0x49, 0x49, 0x41, 0x00 }, 
{ 0x7F, 0x09, 0x09, 0x09, 0x01, 0x00 }, 
{ 0x3E, 0x41, 0x41, 0x51, 0x73, 0x00 }, 
{ 0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00 }, 
{ 0x00, 0x41, 0x7F, 0x41, 0x00, 0x00 }, 
{ 0x20, 0x40, 0x41, 0x3F, 0x01, 0x00 }, 
{ 0x7F, 0x08, 0x14, 0x22, 0x41, 0x00 }, 
{ 0x7F, 0x40, 0x40, 0x40, 0x40, 0x00 }, 
{ 0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00 }, 
{ 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00 }, 
{ 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00 }, 
{ 0x7F, 0x09, 0x09, 0x09, 0x06, 0x00 }, 
{ 0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00 }, 
{ 0x7F, 0x09, 0x19, 0x29, 0x46, 0x00 }, 
{ 0x26, 0x49, 0x49, 0x49, 0x32, 0x00 }, 
{ 0x03, 0x01, 0x7F, 0x01, 0x03, 0x00 }, 
{ 0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00 }, 
{ 0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00 }, 
{ 0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00 }, 
{ 0x63, 0x14, 0x08, 0x14, 0x63, 0x00 }, 
{ 0x03, 0x04, 0x78, 0x04, 0x03, 0x00 }, 
{ 0x61, 0x59, 0x49, 0x4D, 0x43, 0x00 }, 
{ 0x00, 0x7F, 0x41, 0x41, 0x41, 0x00 }, 
{ 0x02, 0x04, 0x08, 0x10, 0x20, 0x00 }, 
{ 0x00, 0x41, 0x41, 0x41, 0x7F, 0x00 }, 
{ 0x04, 0x02, 0x01, 0x02, 0x04, 0x00 },
{ 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0 },
{ 0x00, 0x03, 0x07, 0x08, 0x00, 0x00 }, 
{ 0x20, 0x54, 0x54, 0x78, 0x40, 0x00 }, 
{ 0x7F, 0x28, 0x44, 0x44, 0x38, 0x00 }, 
{ 0x38, 0x44, 0x44, 0x44, 0x28, 0x00 }, 
{ 0x38, 0x44, 0x44, 0x28, 0x7F, 0x00 }, 
{ 0x38, 0x54, 0x54, 0x54, 0x18, 0x00 }, 
{ 0x00, 0x08, 0x7E, 0x09, 0x02, 0x00 }, 
{ 0x18, 0xA4, 0xA4, 0x9C, 0x78, 0x00 }, 
{ 0x7F, 0x08, 0x04, 0x04, 0x78, 0x00 }, 
{ 0x00, 0x44, 0x7D, 0x40, 0x00, 0x00 }, 
{ 0x20, 0x40, 0x40, 0x3D, 0x00, 0x00 }, 
{ 0x7F, 0x10, 0x28, 0x44, 0x00, 0x00 }, 
{ 0x00, 0x41, 0x7F, 0x40, 0x00, 0x00 }, 
{ 0x7C, 0x04, 0x78, 0x04, 0x78, 0x00 }, 
{ 0x7C, 0x08, 0x04, 0x04, 0x78, 0x00 }, 
{ 0x38, 0x44, 0x44, 0x44, 0x38, 0x00 }, 
{ 0xFC, 0x18, 0x24, 0x24, 0x18, 0x00 }, 
{ 0x18, 0x24, 0x24, 0x18, 0xFC, 0x00 }, 
{ 0x7C, 0x08, 0x04, 0x04, 0x08, 0x00 }, 
{ 0x48, 0x54, 0x54, 0x54, 0x24, 0x00 }, 
{ 0x04, 0x04, 0x3F, 0x44, 0x24, 0x00 }, 
{ 0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00 }, 
{ 0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00 }, 
{ 0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00 }, 
{ 0x44, 0x28, 0x10, 0x28, 0x44, 0x00 }, 
{ 0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00 }, 
{ 0x44, 0x64, 0x54, 0x4C, 0x44, 0x00 }, 
{ 0x00, 0x08, 0x36, 0x41, 0x00, 0x00 }, 
{ 0x00, 0x00, 0x77, 0x00, 0x00, 0x00 }, 
{ 0x00, 0x41, 0x36, 0x08, 0x00, 0x00 }, 
{ 0x02, 0x01, 0x02, 0x04, 0x02, 0x00 }, 
{ 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F }, // 7F
};
  
void InitDisplay () {
  Wire.beginTransmission(address);
  Wire.write(commands);
  Wire.write(0x20); Wire.write(0x00); // Horizontal addressing mode
  Wire.write(0xA1);                   // Flip horizontal
  Wire.write(0xC8);                   // Flip vertical
  Wire.write(0xD3); Wire.write(0);    // Reset scroll
  Wire.endTransmission();
}

bool Display;

void DisplayOn (bool on) {
  Display = on;
  Wire.beginTransmission(address);
  Wire.write(commands);
  Wire.write(0xAE + on);
  Wire.endTransmission();
}

void DisplayArea (int row1, int row2, int col1, int col2) {
  Wire.beginTransmission(address);
  Wire.write(commands);
  Wire.write(0x21); Wire.write(col1); Wire.write(col2);   // Column range
  Wire.write(0x22); Wire.write(row1); Wire.write(row2);   // Page range
  Wire.endTransmission();
}

void ClearDisplay () {
  DisplayArea(0, 7, 0, 127);
  for (int p = 0 ; p < 8; p++) {
    for (int q = 0 ; q < 8; q++) {
      Wire.beginTransmission(address);
      Wire.write(data);
      for (int i = 0 ; i < 16; i++) Wire.write(0);
      Wire.endTransmission();
    }
  }
}

// Plots a character; line = 0 to 7; column = 0 to 20
void PlotChar (uint8_t c, int line, int column) {
  column = column*6;
  DisplayArea(line, line, column, column+5);
  Wire.beginTransmission(address);
  Wire.write(data);
  for (uint8_t col = 0 ; col < 6; col++) {
    Wire.write(pgm_read_byte(&CharMap[c-32][col]));
  }
  Wire.endTransmission();
}

// Plot an integer from -999 to 999 in a field 4 wide.
void PlotInt (int n, int line, int column) {
  bool lead = false, sign = false;
  for (int d=100; d>0; d = d/10) {
    char j = (abs(n)/d) % 10;
    if (j!=0 || lead || d==1) {
      if (!sign) PlotChar((n < 0) ? '-' : ' ', line, column++);
      sign = true;
      PlotChar(j + '0', line, column++); lead = true; }
    else PlotChar(' ', line, column++);
  }
}

// Draw scroll bar for pattern n (0 to PATTERNS-1)
void PlotScrollBar (int n) {
  int width = 62/PATTERNS;
  int from = width*n, to = width*(n+1)+1;
  DisplayArea(0, 7, 126, 127);
  Wire.beginTransmission(address);
  Wire.write(data);
  int len = to - from + 1;
  uint64_t bar;
  if (n == 64) bar = (uint64_t)~0;
  else bar = (((uint64_t)1<<len)-1)<<from;
  for (int line=0; line<8; line++) {
    uint8_t part = (uint8_t)(bar & 0xff);
    Wire.write(part); Wire.write(part);
    bar = bar >> (uint64_t)8;
  }
  Wire.endTransmission();
}

// Controls **********************************************

uint8_t control[3];
const int Samples = 4;
const int Up = 4;
const int Down = 5;

void ButtonsOn () {
  // PD4 (Up), PD5 (Down) inputs with pullups
  PORTD.PIN4CTRL = PORT_PULLUPEN_bm | PORT_ISC_FALLING_gc;
  PORTD.PIN5CTRL = PORT_PULLUPEN_bm | PORT_ISC_FALLING_gc;
}

int PatternChange = 0;

ISR(PORTD_PORT_vect) {
  bool displayChange = false;
  uint8_t flags = PORTD.INTFLAGS;
  if (flags & 1<<Up) PatternChange = -1;
  if (flags & 1<<Down) PatternChange = +1;
  // Wait 255 cycles once buttons released for debounce
  int count = 0;
  while (count < 255) {
    count++;
    if ((PORTD.IN & 1<<Up) == 0 && (PORTD.IN & 1<<Down) == 0) { displayChange = true; PatternChange = 0; }
    if ((PORTD.IN & 1<<Up) == 0 || (PORTD.IN & 1<<Down) == 0) count = 0;
  }
  if (displayChange) DisplayOn(!Display);
  PORTD.INTFLAGS = 1<<Up | 1<<Down;                       // Clear interrupt flags
}

uint8_t Average (uint8_t i) {
  return (analogRead(13+i) + analogRead(13+i) + 1) >> 3;
}

// Reads the next control into control[i] and displays percentage
void ReadControls (pattern_t p) {
  static uint8_t i;
  i = (i + 1) % 3;
  int v = Average(i);
  if (abs(v - control[i]) > 2) {
    uint16_t percent = (v*101+50)/256;
    if (i == 0 && p.twoway) percent = percent - 50;
    PlotInt(percent, 7, i*8-i/2);
    PlotChar('%', 7, 4+i*8-i/2);
    control[i] = v;
  }
}

void InitialControls (pattern_t p) {
  for (int i=0; i<3; i++) {
    uint16_t percent = control[i]*101/256;
    if (i == 0 && p.twoway) percent = percent - 50;
    PlotInt(percent, 7, i*8-i/2);
    PlotChar('%', 7, 4+i*8-i/2);
  }
}

// Settings screen **********************************************

const int LEDLENGTHS = 14;
const int LEDlength[LEDLENGTHS] = {20, 30, 36, 40, 50, 60, 64, 72, 100, 120, 128, 144, 150, MaxLEDs};    // Add more if you want
const char *BrightOption[5]   = {" 6%", "12%", "25%", "50%", "Max"};

void DoSettings () {
  int val, v;
  ClearDisplay();
  PrintString((char*)"Settings", 0, (22-8)/2);
  PrintString((char*)"Press UP to exit", 4, 2);
  Labels((char*)"Type", (char*)"LEDs", (char*)"Bright");
  do {
    val = Average(0);
    v = (val*LEDTYPES)/256;                              // Option number
    PrintString((char*)LEDtype[v].label, 7, 0);
    State.neopixel = LEDtype[v].neopixel;
    State.led_type = v;
    
    val = Average(1);
    v = (val*LEDLENGTHS)/256;                            // Option number
    PlotInt(LEDlength[v], 7, 9);
    State.leds = LEDlength[v]; 

    val = Average(2);
    v = (val*5)/256;                                     // Option number
    PrintString((char*)BrightOption[v], 7, 17);
    State.bright = v;
  } while ((PORTD.IN & 1<<Up) != 0);
  EEPROM.put(0, State);                                   // Save state
  CCP = CCP_IOREG_gc; WDT.CTRLA = PERIOD_8CLK_gc;         // System reset after 8ms
  delay(100);
}

// User interface **********************************************

void Status () {
  int v = (analogRead(ADC_VDDIO2DIV10) * 10) / 31;          // Voltage to LEDs
  PrintString((char*)LEDtype[State.led_type].label, 0, 0);
  PlotInt(State.leds, 0, 8);
  PrintString((char*)BrightOption[State.bright], 0, 13);
  PlotChar(v/10 + '0', 0, 17); PlotChar('.', 0, 18);        // Print voltage
  PlotChar(v%10 + '0', 0, 19); PlotChar('V', 0, 20);
}

void PrintString (const char *string, int line, int column) {
  while (*string) { PlotChar(*string++, line, column++); }
}

void Title (const char *string, const char *string2) {
  PrintString((char*)string, 2, (22-strlen(string))/2);
  PrintString((char*)string2, 3, (22-strlen(string2))/2);
}

void Labels (const char *string1, const char *string2, const char *string3) {
  PrintString((char*)string1, 6, (7-strlen(string1))/2);
  PrintString((char*)string2, 6, 8+(7-strlen(string2))/2);
  PrintString((char*)string3, 6, 15+(7-strlen(string3))/2);
}

void UpdateDisplay (int pattern, pattern_t p) {
  ClearDisplay();
  InitialControls(p);
  Status();
  PlotScrollBar(pattern);
  Title(p.title1, p.title2);
  Labels(p.label1, p.label2, p.label3);
}

// Pattern utilities **********************************************

Fixed fmul (Fixed x, Fixed y) {
  if (x>181 || x<-181 || y>181 || y<-181) return ((int32_t)x * (int32_t)y) >> 8;
  else return (x * y) >> 8;
}

Fixed fdiv (Fixed x, Fixed y) {
  if (x>127 || x<-127) return ((int32_t)x << 8) / y;
  else return (x << 8) / y;
}

Fixed fract (Fixed a) {
  if (a >= 0) return a & 0xff; else return 0x100 - (a & 0xff);
}

Fixed clamp (Fixed v, Fixed lo, Fixed hi) {
  return (v<lo) ? lo : (v>hi) ? hi : v;
}

Fixed d (Fixed m, Fixed n) { return abs(fract(m - n + half) - half); }

Fixed tri (Fixed x) { return 2 * abs(half - (fract (half + x))); }

Fixed squ (Fixed x) { return fmul(x, x); }

Fixed hsv (Fixed g, Fixed h, Fixed s, Fixed v) {
  return fmul(2 * (one - 3 * fmul(d(g, h), s)), v);
}

bool tstbit (uint64_t pat, int k) { return ((pat>>k) & (uint64_t)1); }
uint64_t setbit (uint64_t pat, int k) { return pat | (uint64_t)1<<k; }
uint64_t clrbit (uint64_t pat, int k) { return pat & ~((uint64_t)1<<k); }

// Pattern functions **********************************************

pattern_t Pattern[PATTERNS] = {
  { static_rgb_pattern, "Static RGB Display", "", "Red", "Green", "Blue", false },
  { static_hsv_pattern, "Static HSV Display", "", "Hue", "Satn.", "Value", false },
  { waves_pattern, "Colour Waves", "from one end", "Speed", "Satn.", "Value", true },
  { circles_pattern, "Colour Circles", "from the centre", "Speed", "Satn.", "Value", true },
  { circle_bands_pattern, "Circular Bands", "from the centre", "Speed", "Hue", "Satn.", true },
  { cylon_pattern, "Cylon", "oscillating peak", "Speed", "Width", "Hue", false },
  { twin_peaks_pattern, "Twin Peaks", "2 oscillating peaks", "Speed", "Hue1", "Hue2", false },
  { pendulums_pattern, "Pendulums", "6 bouncing peaks", "Speed", "Width1", "Width2", false },
  { theatre_lights_pattern, "Theatre Lights", "one LED at a time", "Speed", "Hue", "Satn.", true },
  { theatre_lights2_pattern, "Theatre Lights 2", "all LEDs on", "Speed", "Hue", "Satn.", true },
  { coloured_bands_pattern, "Coloured Bands", "smooth moving bands", "Speed", "Bands", "Hue", true },
  { rainbow_bands_pattern, "Rainbow Bands", "smooth moving bands", "Speed", "Bands", "Hue", true },
  { fireworks_pattern, "Fireworks", "3 peaks that fade", "Speed", "Hue", "Satn.", false },
  { sparkle_pattern, "Sparkling Lights", "of different colours", "Speed", "Delay", "Satn.", false },
  { twinkle_pattern, "Twinkling Lights", "on a background", "Speed", "Hue", "Value", false },
  { beats_pattern, "Beating Peaks", "3 independent peaks", "SpeedR", "SpeedG", "SpeedB", false },
  { computer_pattern, "Computer Display", "of binary lights", "Speed", "Bands", "Value", false },
  { snakes_pattern, "Snakes", "in random sequences", "Speed", "Hue", "Satn.", false },
  { fireflies_pattern, "Fireflies", "fly around at random", "Speed", "Hue", "Satn.", false },
  { snowstorm_pattern, "Snowstorm", "fills up at random", "Speed", "Hue", "Satn.", false },
  { matrix_circles_pattern, "Matrix Circles", "for 8x8 matrix", "Speed", "Satn.", "Value", true },
  { matrix_message_pattern, "Matrix Message", "for 8x8 matrix", "Speed", "Colours", "Satn.", false },
};

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter" // To avoid unused parameter warnings for patterns

Fixed static_rgb_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  return (g == zero) ? a : (g == third) ? b : c;
}

Fixed static_hsv_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  return hsv(g, a, b, c);
}

Fixed waves_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  return hsv(g, x + t, b, c);
}

Fixed circles_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  return hsv(g, squ(2 * (x - half)) + t, b, c);
}

Fixed circle_bands_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  return hsv(g, b, c, fract(squ(2 * (x - half)) + t));
}

Fixed cylon_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  Fixed x2 = fmul(one - b, tri(fract(t)));
  return hsv(g, c, one, tri(clamp(fdiv(x - x2, b), zero, one)));
}

Fixed twin_peaks_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  return hsv(g, b, one, tri(clamp(fract(x + t), zero, half) * 2)) +
    hsv(g, c, one, tri(clamp(fract(one - x + t), zero, half) * 2));
}

Fixed pendulums_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  return tri(clamp(fdiv((x - fmul((one - b), tri(fract(t + g)))), b), zero, one)) +
   tri(clamp(fdiv((x - fmul((one - c), tri(fract(t + g + sixth)))), c), zero, one));
}

Fixed theatre_lights_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  return hsv(g, b, c, (((n + t/4) % 3) == 0) * one);
}

Fixed theatre_lights2_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  return hsv(g, (b + one * ((n + t/4) % 3)) / 3, c, one);
}

Fixed coloured_bands_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  return hsv(g, c, one, tri((fmul(x,b+16) + t)*8));
}

Fixed rainbow_bands_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  Fixed band = tri((fmul(x,b+16) + t)*8);
  return hsv(g, (band + c*2/3), one, band);
}

Fixed fireworks_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  return hsv(g, b, c, fmul((one-fract(t+quarter)), tri(clamp(x, zero, half) * 2))) +
    hsv(g, b + third, c, fmul((one-fract(t)), tri(clamp(x-quarter, zero, half) * 2))) +
    hsv(g, b + twothirds, c, fmul((one-fract(t+third)), tri(clamp(x-half, zero, half) * 2)));
}

Fixed sparkle_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  Fixed q = State.leds;
  return hsv(g, n * 317 + 13, c, (abs(t + (t == 0)) % (157 + (7 + q * x / one * 13) % q) <= b) * one);
}

Fixed twinkle_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  Fixed q = State.leds;
  return ((t + (t == 0)) % (157 + (7 + q * x / one * 13) % q) == 0) * one + hsv(g, b, one, c);
}

Fixed beats_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  static int32_t elapsed2, elapsed3;
  if (n == 0 && g == zero) { elapsed2 = elapsed2 + b; elapsed3 = elapsed3 + c; }
  Fixed t2 = elapsed2 / 50, t3 = elapsed3 / 50;
  return (g == 0) ? fmul(tri(clamp(fdiv(x, half), zero, one)), tri(fract(t))) : 
    (g == third) ? fmul(tri(clamp(fdiv((x - quarter), half), zero, one)), tri(fract(t2))) : 
    fmul(tri(clamp(fdiv((x - half), half), zero, one)), tri(fract(t3)));
}

Fixed computer_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  return (((uint16_t)(t) >> n % (b * 12 / one + 4)) & 1) * c;
}

Fixed snakes_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  const int patlen = (State.leds + 7)/8;
  static uint8_t pat[MaxLEDs/8];
  static uint8_t ledshift = 0;
  static Fixed t0;
  if (n == 0 && g == 0 && (t*20)/one != t0) {
    t0 = (t*20)/one;
    ledshift = (ledshift + 1) % State.leds;
    uint8_t previousbit = random(2);
    for (int m=0; m<patlen; m++) {
        uint8_t topbit = pat[m] >> 7; 
        pat[m] = (pat[m] << 1) | previousbit;
        previousbit = topbit;
    }
  }
  uint8_t on = (pat[n/8]>>(n & 7)) & 1;
  Fixed hue = ((n - ledshift + State.leds)%6)*sixth;
  return hsv(g, hue+b, c, on * one);
}

Fixed fireflies_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  static uint64_t pat = 0x0101010101010101; // 8 fireflies
  static Fixed t0;
  static uint8_t fly;
  if (n == 0 && g == zero) {
    fly = 0;
    if ((t*20)/one != t0) {
      t0 = (t*20)/one;
      int i = -1;
      for (int m=1; m<=8; m++) {
        i++; while (!tstbit(pat, i)) i++; // Skip unlit
        int k = (i + random(2) * 2 - 1); // next or previous
        if (k >= 0 && k <= 63 && !tstbit(pat, k)) {
          pat = setbit(pat, k); pat = clrbit(pat, i); i=k; }
      }
    }
  }
  uint8_t on = tstbit(pat, n % 64);
  if (on && (g == 0)) fly++;
  return hsv(g, fly % 6 * sixth + b, c, on * one);
}

Fixed snowstorm_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  bool on = (t % one > ((n + t / one) * 317 + 37) % one);
  return hsv(g, n * 317 + 37 + b, c, on * one);
}

Fixed matrix_circles_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  uint8_t nx = n/8, ny = n%8;
  return hsv(g, squ(nx * half / 4 - 112) + squ(ny * half / 4 - 112) + t, b, c);
}

Fixed matrix_message_pattern (uint8_t n, Fixed g, Fixed t, Fixed x, Fixed a, Fixed b, Fixed c) {
  uint8_t nx = n/8, ny = n%8;
  const char message[] = "Happy Birthday Zoe! ";
  const uint8_t len = strlen(message);
  uint8_t let = (abs(t/4)+nx)/6%len;
  bool on = (pgm_read_byte(&CharMap[message[let]-32][(abs(t/4)+nx)%6])>>(7 - ny)) & 1;
  return hsv(g, let*b*6/len, c, on * one);
}

#pragma GCC diagnostic pop

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

void PatternChanged () {
  if (PatternChange != 0) {
    State.pattern = (State.pattern + PatternChange + PATTERNS) % PATTERNS;
    UpdateDisplay(State.pattern, Pattern[State.pattern]);   // Update display
    EEPROM.put(0, State);                                   // Save state to EEPROM
    PatternChange = 0;
  }
}

void setup () {
  if (EEPROM.read(0) == 0) EEPROM.get(0, State);            // Only read if valid data
  analogRead(ADC_VDDIO2DIV10);                              // Read supply voltage
  PORTD.PIN4CTRL = PORT_PULLUPEN_bm;
  PORTD.PIN5CTRL = PORT_PULLUPEN_bm;
  PORTD.DIRSET = PIN7_bm;                                   // PD7 Error output low
  for (int n=0; n<=256; n++) Gamma[n] = pow((float)n/256.0, 2.2) * 255;
  if (State.neopixel) ConfigureNeoPixel(); else ConfigureDotStar();
  Wire.begin();
  delay(500);
  InitDisplay();
  ClearDisplay();
  DisplayOn(true);
  PrintString((char*)"Light Lab", 2, (22-9)/2);             // Welcome screen
  delay(1500);
  if ((PORTD.IN & 1<<Down) == 0) DoSettings();
  UpdateDisplay(State.pattern, Pattern[State.pattern]);
  ButtonsOn();                                              // Turn on button interrupts
}

uint16_t refresh () {
  static int32_t elapsed;                                   // Elapsed update count
  uint32_t timer = millis();
  const uint8_t *rgb = LEDtype[State.led_type].order;       // Order of R, G, and B
  uint8_t bright = 0, dim = 16;                             // Global brightness
  PatternChanged();                                         // Has pattern changed?
  uint8_t patno = State.pattern % PATTERNS;
  if (State.neopixel) dim = 1<<(4-State.bright);            // Global brightness
    else { dim = 1; bright = (1<<State.bright) - 1; }
  if (State.neopixel) StartNeoPixel();
    else StartDotStar();                                    // Start transfers
  ReadControls(Pattern[patno]);
  Fixed a = control[0], b = control[1], c = control[2];
  if (Pattern[patno].twoway) elapsed = elapsed + a - half;
    else elapsed = elapsed + a;
  Fixed t = elapsed / 50;                                   // One second
  
  for (uint8_t n=0; n<State.leds; n++) {                    // For every LED
    uint8_t *Out = Buffer.col[n];
    Fixed x = (n * one + half) / State.leds;
    if (State.neopixel) while (BufPtr <= n*3);              // Wait until output
    for (int k=0; k<3; k++) {                               // For each RGB channel
      Fixed g = k * one / 3;                                // RGB channel hue
      
      Fixed value = Pattern[patno].patfn(n,g,t,x,a,b,c);    // Evaluate the pattern
      
      Out[rgb[k]] = Gamma[clamp(value, zero, one)]/dim;     // Output the value
    }
    if (!State.neopixel) TransferDotStar(n, bright);        // Output DotStar LED
  }
  if (!State.neopixel) EndDotStar();
  
  uint16_t time = millis() - timer;
  if (time >= 25) PORTD.OUTSET = PIN7_bm;
    else PORTD.OUTCLR = PIN7_bm;                            // Error light

  while (millis() - timer < 20);                            // Wait until 20ms tick
  return time;
}

void loop () {
  refresh();
}