// Simple DotStar test code by David Selles
// Based heavily on (and often copying directly) David Johnson-Davies' code from Technoblogy
// http://www.technoblogy.com/show?1Y7J

// When talking to DotStar LEDs,
// The data consists of:

// A start frame of 32 '0' bits.
// A 32-bit frame for each LED, specifying the brightness and colour.
// An end frame of 32 '1' bits.
// The 32-bit frame for each LED consists of:

// Three '1' bits.
// Five bits specifying the brightness, MSB first.
// Eight bits specifying the blue component, MSB first.
// Eight bits specifying the green component, MSB first.
// Eight bits specifying the red component, MSB first.

#include <avr/io.h>

// Pin assignments
const int Clk = 7;
const int Data = 6;
const int Button = 5;

// Port Assignments
#define LED_port PORTA
#define LED_ins PINA
#define LED_direction DDRA

#define LEDs 4

volatile int ShowDisplay;

volatile int Count1 = 0;
volatile int Count2 = 0;

// Display buffer - sets the brightness and colour of the 4 RGB LEDs
// First [LEDs] is # of LEDs, second [4] is for R,G,B, and Brightness
uint8_t Display[LEDs][4];

// Software SPI **********************************************

void Write (uint8_t c) {
  int i=0x80;
  while (i) {   
    if (c & i) LED_port = LED_port | 1<<Data;  // set Data high
    else LED_port = LED_port & ~(1<<Data);     // set Data low
    LED_port = LED_port | 1<<Clk;                       // set Clk high
    i = i>>1;
    LED_port = LED_port & ~(1<<Clk);                       // set Clk low
  }     
}

void UpdateDisplay () {
  for (int d=0; d<4; d++) Write(0);      // Start frame
  for (int d=0; d<LEDs; d++) {
    Write(Display[d][0] | 0xE0);         // Brightness 0-31
    Write(Display[d][1]);                // Blue
    Write(Display[d][2]);                // Green
    Write(Display[d][3]);                // Red
  }
  Write(0xFF);                           // End frame
}

void ClearBuffer () {
  for (int d=0; d<LEDs; d++) {
    for (int c=0; c<4; c++) Display[d][c] = 0;
  }
}

void DisplayOff () {
  LED_direction = 1<<Clk | 1<<Data | 0<<Button;        // Make Button an input
  LED_port = 0<<Clk | 0<<Data | 1<<Button;       // Turn on Button pullup
  ShowDisplay = 0;
}

void DisplayOn () {
  LED_port = 0<<Clk | 0<<Data | 0<<Button;       // Turn off Button pullup
  LED_direction = 1<<Clk | 1<<Data | 1<<Button;        // Make Button an output low
  ShowDisplay = 1;
}



int main(void) {
   //
   // main function.
   //

   // initialize pins

   DisplayOff();


   // main loop

   while (1) {

        if (!(LED_ins & 1<<Button)) {         //test Button pin.

        // This code runs when Button is pressed. Just playing around here, nothing special.

            DisplayOn();
            ClearBuffer();

            for (int d=0; d<LEDs; d++) {
                Display[d][0] = 0b1;             // Brightness 0-31 31 = 0b11111
                Display[d][1] = ((Count1) % 0x100) / (d+1);               // Blue
                Display[d][2] = (Count2) % 0x100;              // Green
                Display[d][3] = ((Count1 / (d+1))) % 0x100;              // Red
            }
            Count1 ++;
            if (!((Count1 * 5) % 0x100)) {
                Count2 ++;
            }

            UpdateDisplay();
            DisplayOff();

        } else {
            /* To clear the display and turn off:
            DisplayOff();
            ClearBuffer();
            UpdateDisplay();
            */

           // This code runs when Button isn't pressed. Cycles through colors, blending them together, each pixel is offset.
           // Code seems to run kinda slow, likely from all the modulo math, but the code itself is concise.

            for (int d=0; d<LEDs; d++) {
                Display[d][0] = 0b111;             // Brightness 0-31 31 = 0b11111
                Display[d][1] = (Count1 % 0x100) * ((((Count2 + 2 + d) % 4) % 3) % 2) + 
                                (0xFF - (Count1 % 0x100)) * ((((Count2 + 1 + d) % 4) % 3) % 2);              // Blue
                Display[d][2] = (Count1 % 0x100) * ((((Count2 + 3 + d) % 4) % 3) % 2) + 
                                (0xFF - (Count1 % 0x100)) * ((((Count2 + 2 + d) % 4) % 3) % 2);;             // Green
                Display[d][3] = (Count1 % 0x100) * ((((Count2 + 4 + d) % 4) % 3) % 2) + 
                                (0xFF - (Count1 % 0x100)) * ((((Count2 + 3 + d) % 4) % 3) % 2);;              // Red
            }
            Count1 ++;
            if (!((Count1 * 1) % 0x100)) {
                Count2 ++;
            }

            UpdateDisplay();

        }
    }
}