//Code is based on: http://www.technoblogy.com/show?1ONY
//Rewritten by Klaas-jan Winkel

#define DEBUGLEDPIN 13
#define DEBUGSPEED 15624
#define CHARLIESPEED 24

void setup() {
  pinMode(DEBUGLEDPIN, OUTPUT);
  configureInterupt();
}

void loop() {
  recalculateColorBrightnessLED();
  delay(200);
}

//*****************Interrupt code**********************************

//this will compile for Arduino UNO, Pro and older boards
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__)

void configureInterupt() {
  //TODO: The Arduino UNO version maybe is not running at the right frequency with these settings?
  //cli();
  noInterrupts();
  
  TCCR1A = 0; //set entire TCCR1A register to 0
  TCCR1B = 0; //same

  //set compare match register to desired timer count:
  OCR1A = CHARLIESPEED;
  //int timer1_counter = 34286;
  //TCNT1 = 34286;

  //turn on CTC Mode
  TCCR1B |= (1 << WGM12);
  //TCCR1B = 1<<WGM12 | 7<<CS10;

  //Set CS10 and CS12 bits for 1024 prescaler
  TCCR1B |= (1 << CS10);
  //TCCR1B |= (1 << CS12);

  //enable timer compare interrupt
  TIMSK1 |= (1 << OCIE1A);

  //enable timer overflow interrupt
  //TIMSK1 |= (1 << TOIE1);

  interrupts();
  //sei(); //enable global interrupts

  //digitalWrite(DEBUGLEDPIN, HIGH);  
}

//for ATTiny85
#elif defined(__AVR_ATtiny85__)

void configureInterupt() {
  // Set up Timer/Counter1 to multiplex the display
  
  TCCR1 = 1<<CTC1 | 7<<CS10;    // CTC mode; divide by 64
  OCR1C = CHARLIESPEED;         // Divide by 25 -> 5kHz
  TIMSK = TIMSK | 1<<OCIE1A;    // Enable compare interrupt
}

#endif


//Timer/Counter1 interrupt - multiplexes display

//this will compile for Arduino UNO, Pro and older boards
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__)
ISR (TIMER1_COMPA_vect) {
//for ATTiny85
#elif defined(__AVR_ATtiny85__)  
ISR(TIM1_COMPA_vect) {
#endif

  processNextRGBLED();
}


//*****************LED aanstuur code**********************************

volatile int brightnessPerLED[4] = { 0x000, 0x000, 0x000, 0x000 };

void recalculateColorBrightnessLED() { //called by loop at certain frequency
  static int Step = 0;

  for (int i=0; i<4; i++) {
    brightnessPerLED[i] = green(Step + i*12)<<8 | blue(Step + i*12)<<4 | red(Step + i*12);
  }
  Step++;
}

//convenient bit/hex/dec conversion table: https://mobilediscoveries.com/wp-content/uploads/2018/07/hex-to-decimal-chart-fa3f8b032f1df211cfa5a226b973f0e8.jpg
//legenda: 8 bits = byte = char, 4 bits = nibble, 16 bits = int / example: 00001111: first nibble = 1111, second nibble = 0000
//for bit masking see: https://en.wikipedia.org/wiki/Mask_(computing)#Common_bitmask_functions

//these AND masks are defined as bytes (=char data type) but also work on 16 bit int values, because:  B00000011 =  B0000000000000011
#define KEEPONLY_FIRST_TWO_BITS_ANDMASK B00000011 //HEX 0x03 DEC 3
#define KEEPONLY_FIRST_6BITS_ANDMASK B00111111 //HEX 0x3F
#define KEEPONLY_FIRST_NIBBLE_ANDMASK B00001111 //HEX 0x0F
#define KEEPONLY_SECOND_NIBBLE_ANDMASK B11110000 //HEX 0xF0
#define KEEPONLY_FIRST_THREE_BITS_ANDMASK B00000111//HEX 0x07

void processNextRGBLED() { //called by interrupt at certain frequency
  //digitalWrite(DEBUGLEDPIN, digitalRead(DEBUGLEDPIN) ^ 1); 

  
  /*this variable keeps the current state of this function
  this variable is encoded as follows: 
        87 65 43 21
  bits: 00 00 00 00
        ^^unused
           ^^ ^^currentbrightness nibble (max 16 values) <--TODO: what is this, brightness regulation by frequency??
                 ^^lednr (max 4 values)
                 
  by incrementing this state first the code loops through all 4 leds: bits 1 and 2
  in the first time looping through these for leds currentbrightness remains 0
  when state is incrementing after the 4th led, currentbrightness becomes 1, and again the loop goes through all 4 leds
  */
  static int cycledstate = 0;


  //get the previous led nr out of the current state (first two bits)
  int previousled = getLEDNrFromState(cycledstate);


  /* 
   lednr  1<<lednr   ~
   00    000          111
   01    010          010
   10    100          011
   11    110          001
  */  
  //TODO: does this select or turn off a row??
  DDRB = DDRB & ~(1<<(previousled));

  //update state
  //The maximum value of 4 bits is 16, of 5 bits its 32 and so of 6 bits its 64 values maximum
  //increment cycledstate with 1, when cycledstate reaches 111111 (=64) incrementing it with 1 causes cycledstate to be set back to 000000 (zero) starting the cycledstate over again
  cycledstate = (cycledstate + 1) & KEEPONLY_FIRST_6BITS_ANDMASK;   // 64 cycledstates

  //currentled: which RGB led we are currently processing (0..3)
  //get the current led nr out of the current state (first two bits)
  int currentled = getLEDNrFromState(cycledstate);

  //currentbrightness: values 0 to 15 determine which max brightness we are currently processing
  int currentbrightness = getCurrentbrightnessFromState(cycledstate);
  
  //the last 4 bits of this 16bit int are not used (only the first 3 nibbles)
  //TODO: THE NAME MIGHT BE WRONG? though currentled suggests that these are the values of 1 led.. messing with the values suggests that these are the values per color??
  int rbg = brightnessPerLED[currentled];
  
  int redBrightness = getFirstNibble(rbg);
  int blueBrightness = getSecondNibble(rbg);
  int greenBrightness = getThirdNibble(rbg);

  //this part does the charlieplexing bit: https://en.wikipedia.org/wiki/Charlieplexing

  /*
   * Only colors that need to be of the current or larger brightness will be turned on,example: currentbrightness < redBrightness
   * Colors that should be less bright will be skipped until currentbrightness becomes 0 again. This way these leds stay off longer and appear darker.
   * Colors that are larger or equal to currentbrightness will stay on and appear brighter.
   * 
   * The current RGB led has 4 pins: ground, green, blue and red which can be numbered as follows:
   * 
   * pin:   4321
   * color: xGBR
   * 
   * These are set using the result (0 or 1) of a boolean equation: currentbrightness < redBrightness, are shifted to the right pin and combined using | (or):
   * */
  int fourPinValues = 
              (currentbrightness < redBrightness) 
              | (currentbrightness < blueBrightness)<<1 
              | (currentbrightness < greenBrightness)<<2;

  /*
  default mask: 00000111
  currentled mask (the second nibble is not used?)
  00=0       0000 0111
  01=1       0000 1110
  10=2       0001 1100
  11=3       0011 1000
  */
  int fourPinMask = KEEPONLY_FIRST_THREE_BITS_ANDMASK <<currentled;


  /*
  How to determine which LED has to be lit can be determined using this matrix:

      0   1   2   3
  0   x   R0  B0  G0
  1   R1  x   B1  G1
  2   R2  B2  x   G2
  3   R3  B3  G3  x

  */
  
  //TODO: if the second nibble is not used, then this int should be and-masked with 0000 1111, otherwise it sets more pins then just the 4 as these are set using OR
  //TODO: is 
  fourPinValues = fourPinValues + (fourPinValues & fourPinMask);

  //set the calculated values to the ports
  
  //port b is an 8-bit port: https://web.ics.purdue.edu/~jricha14/Port_Stuff/PortB_general.htm
  //we are just using the first 4 bits/first nibble of the port, so always keep the second nibble untouched by masking it with: & KEEPONLY_SECOND_NIBBLE_ANDMASK

  //set the pins to input (0) or output (1)
  //the second line (PORTB) will only write high (5v) and low(0v) values to the pins that have been set to output
  //the pins that are set to input here are turned off = high impendance = third state
  DDRB = (DDRB & KEEPONLY_SECOND_NIBBLE_ANDMASK) | fourPinValues;

  //set values to the first 4 bits = set the first 4 pins to high (1) or low (0) at once by using an OR mask
  PORTB = (PORTB & KEEPONLY_SECOND_NIBBLE_ANDMASK) | fourPinValues;

  //TODO: does this select or turn on a row??
  DDRB = DDRB | 1<<currentled;
}


//*****************Helper functies**********************************
int red (int x) {
  int y = x % 48;
  if (y > 15) y = 31 - y;
  return max(y, 0);
}

int green (int x) { return red(x + 32); }
int blue (int x) { return red(x + 64); }

int getFirstNibble(int x) {
   return x & KEEPONLY_FIRST_NIBBLE_ANDMASK;
}

int getSecondNibble(int x) {
  //shift the second nibble into the first position
  return x>>4 & KEEPONLY_FIRST_NIBBLE_ANDMASK;;
}


int getThirdNibble(int x) {
  //shift the third nibble into the first position
  return x>>8 & KEEPONLY_FIRST_NIBBLE_ANDMASK;
}

int getCurrentbrightnessFromState(int astate) {
  //shift the third nibble into the first position
  return astate>>2;
}

int getLEDNrFromState(int astate) {
  return astate & KEEPONLY_FIRST_TWO_BITS_ANDMASK;
}