/*
2008 - robert:aT:spitzenpfeil_d*t:org
*/

#define __spi_clock 13   // SCK - hardware SPI
#define __spi_latch 10
#define __spi_data 11    // MOSI - hardware SPI
#define __spi_data_in 12 // MISO - hardware SPI (unused)
#define __display_enable 9
#define __button 7
#define __led 4
#define __rows 8
#define __max_row __rows-1
#define __leds_per_row 8
#define __max_led __leds_per_row-1
#define __brightness_levels 28 // 0...15 above 32 is bad for ISR
#define __max_brightness __brightness_levels-1
#define __fade_delay 4

#define __TIMER1_MAX 0xFFFF // 16 bit CTR
#define __TIMER1_CNT 0x0130 // 32 levels --> 0x0130; 38 --> 0x0157 (flicker)
#include <avr/interrupt.h>   
#include <avr/io.h>

byte brightness_red[__leds_per_row][__rows]; 
byte brightness_green[__leds_per_row][__rows];
byte brightness_blue[__leds_per_row][__rows]; 

ISR(TIMER1_OVF_vect) {
  TCNT1 = __TIMER1_MAX - __TIMER1_CNT;
  byte cycle;
  
  digitalWrite(__display_enable,LOW); // enable display inside ISR
  
  for(cycle = 0; cycle < __max_brightness; cycle++) {
    byte led;
    byte row = B00000000;    // row: current source. on when (1)
    byte red;    // current sinker when on (0)
    byte green;  // current sinker when on (0)
    byte blue;   // current sinker when on (0)

    for(row = 0; row <= __max_row; row++) {
      
      red = B11111111;    // off
      green = B11111111;  // off
      blue = B11111111;   // off
      
      for(led = 0; led <= __max_led; led++) {
        if(cycle < brightness_red[row][led]) {
          red &= ~(1<<led);
        }
        if(cycle < brightness_green[row][led]) {
          green &= ~(1<<led);
        }
        if(cycle < brightness_blue[row][led]) {
          blue &= ~(1<<led);
        }
      }

      digitalWrite(__spi_latch,LOW);
      spi_transfer(B00000001<<row);	// if you use the old schematic, this row goes after: spi_transfer(red); !
      spi_transfer(blue);
      spi_transfer(green);
      spi_transfer(red);
      digitalWrite(__spi_latch,HIGH);
      digitalWrite(__spi_latch,LOW);
    }
  }
  digitalWrite(__display_enable,HIGH);    // disable display outside ISR
}

void setup(void) {
  Serial.begin(4800);
  pinMode(__spi_clock,OUTPUT);
  pinMode(__spi_latch,OUTPUT);
  pinMode(__spi_data,OUTPUT);
  pinMode(__spi_data_in,INPUT);
  pinMode(__display_enable,OUTPUT);
  pinMode(__led,OUTPUT);
  digitalWrite(__spi_latch,LOW);
  digitalWrite(__spi_data,LOW);
  digitalWrite(__spi_clock,LOW);
  setup_hardware_spi();
  setup_timer1_ovf();
  set_matrix_rgb(0,0,0);
  blink_led(50);
  Serial.flush();	// very important for resyncing after device reset !
}


void loop(void) {
  static byte buffer[6];
  static byte ctr = 0;

  if ( Serial.available() ) {
    //stop_timer1();
    if ( Serial.read() == 1 ) {  /* start byte */
      while ( ctr <= 5 ) { /* read 6 bytes, last = stop byte: CMD1, CMD2, RED, GREEN, BLUE, STOP */
        if ( Serial.available() ) {
          buffer[ctr] = Serial.read();
          ctr++;
          toggle_led();
        }
      }
      if (buffer[5] == 1) { /* stop bit = stop byte */
        ctr = 0;
        switch(buffer[0]) {
          case 0x00:
            set_matrix_rgb(0,0,0);
          break;
          case 0x01:
            set_matrix_rgb(buffer[1],buffer[2],buffer[3]);
          break;
          case 0x02:
            set_row_rgb(buffer[1],buffer[2],buffer[3],buffer[4]);
          break;
          case 0x03:
            set_tbar_rgb(buffer[1],buffer[2],buffer[3],buffer[4]);
          break;
          default:
          break;
        }
      }
      else { /* invalid */ }
    }
  }
  clear_buffer(buffer);
  //start_timer1();
}


void clear_buffer(byte * buffer) {
  byte ctr;
  for(ctr = 0; ctr <= 4; ctr++) {
    buffer[ctr] = 0;
  }
}


byte spi_transfer(byte data)
{
  SPDR = data;                    // Start the transmission
  while (!(SPSR & (1<<SPIF)))     // Wait the end of the transmission
  {
  };
  return SPDR;                    // return the received byte, we don't need that
}

void set_led_red(byte row, byte led, byte red) {
  if( (row > __max_row) || (led > __max_led) ) { return; }
  brightness_red[row][led] = red;
}

void set_led_green(byte row, byte led, byte green) {
  if( (row > __max_row) || (led > __max_led) ) { return; }
  brightness_green[row][led] = green;
}

void set_led_blue(byte row, byte led, byte blue) {
  if( (row > __max_row) || (led > __max_led) ) { return; }
  brightness_blue[row][led] = blue;
}

void set_led_rgb(byte row, byte led, byte red, byte green, byte blue) {
  set_led_red(row,led,red);
  set_led_green(row,led,green);
  set_led_blue(row,led,blue);
}

void set_row_rgb(byte row, byte red, byte green, byte blue) {
  byte ctr1;
  for(ctr1 = 0; ctr1 <= __max_led; ctr1++) {
      set_led_rgb(row,ctr1,red,green,blue);
  }
}

void set_tbar_rgb(byte toprow, byte red, byte green, byte blue) {
  byte ctr1;
  set_matrix_rgb(0,0,0);
  for(ctr1 = 0; ctr1 <= toprow; ctr1++) {
      set_row_rgb(ctr1,red,green,blue);
  }
}

void set_matrix_rgb(byte red, byte green, byte blue) {
  byte ctr1;
  byte ctr2;
  for(ctr2 = 0; ctr2 <= __max_row; ctr2++) {
    for(ctr1 = 0; ctr1 <= __max_led; ctr1++) {
      set_led_rgb(ctr2,ctr1,red,green,blue);
    }
  }
}

void setup_hardware_spi(void) {
  byte clr;
  // spi prescaler: 
  // SPI2X SPR1 SPR0
  //   0     0     0    fosc/4
  //   0     0     1    fosc/16
  //   0     1     0    fosc/64
  //   0     1     1    fosc/128
  //   1     0     0    fosc/2
  //   1     0     1    fosc/8
  //   1     1     0    fosc/32
  //   1     1     1    fosc/64
  SPCR |= ( (1<<SPE) | (1<<MSTR) ); // enable SPI as master
  //SPCR |= ( (1<<SPR1) ); // set prescaler bits
  SPCR &= ~ ( (1<<SPR1) | (1<<SPR0) ); // clear prescaler bits
  clr=SPSR; // clear SPI status reg
  clr=SPDR; // clear SPI data reg
  //SPSR |= (1<<SPI2X); // set prescaler bits
  SPSR &= ~(1<<SPI2X); // clear prescaler bits
}

void setup_timer1_ovf(void) {
  // Arduino runs at 16 Mhz...
  // Timer1 (16bit) Settings:
  // prescaler (frequency divider) values:   CS12    CS11   CS10
  //                                           0       0      0    stopped
  //                                           0       0      1      /1  
  //                                           0       1      0      /8  
  //                                           0       1      1      /64
  //                                           1       0      0      /256 
  //                                           1       0      1      /1024
  //                                           1       1      0      external clock on T1 pin, falling edge
  //                                           1       1      1      external clock on T1 pin, rising edge
  //
  TCCR1B &= ~ ( (1<<CS11) );
  TCCR1B |= ( (1<<CS12) | (1<<CS10) );      
  //normal mode
  TCCR1B &= ~ ( (1<<WGM13) | (1<<WGM12) );
  TCCR1A &= ~ ( (1<<WGM11) | (1<<WGM10) );
  //Timer1 Overflow Interrupt Enable  
  TIMSK1 |= (1<<TOIE1);
  TCNT1 = __TIMER1_MAX - __TIMER1_CNT;
}

void start_timer1(void) {
  TIMSK1 |= (1<<TOIE1);  
}

void stop_timer1(void) {
  TIMSK1 &= ~(1<<TOIE1);
}

void blink_led(byte blinks) {
  byte ctr;
  for(ctr = 0; ctr < blinks; ctr++) { 
    digitalWrite(__led,HIGH);
    delay(5);
    digitalWrite(__led,LOW);
    delay(5);
  }
}

void toggle_led() {
  static int led_status;
  digitalWrite(__led,led_status);
  led_status = !led_status;
}