/**************************************************************************
 * USB Controlled RGB LED lights
 *
 * The light bar has two operating modes: control and fade.
 * In control mode, each color (rgb) is specified, and the light bar will stay
 * at one color.  In fade mode, the lights will randomly cycle through colors.
 *
 * MCU: ATmega168
 *
 * Red		OCR0A	Pin12 PD6
 * Green	OCR1A	Pin15 PB1
 * Blue		OCR1B	Pin16 PB2
 *
 **************************************************************************/

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <stdlib.h>			// for rand()

#include "usbdrv.h"

/**************************************************************************/
// USB control messages (same as PC software)
#define RED		0
#define GREEN	1
#define BLUE	2
#define FADE	3

// define PWM color pins
#define R_PWM	OCR0A
#define G_PWM	OCR1A
#define B_PWM	OCR1B

// delay used in fade mode (in ms)
#define fade_delay	25

#define F_CPU	16000000L

/**************************** prototypes **********************************/
void init_PWM(void);
int rnd_seed(int seed);
USB_PUBLIC uchar usbFunctionSetup(uchar data[8]);

/******************************* main *************************************/
// flag for fade mode
// declared out here so it's global
volatile int fade = 1;

// buffers to hold color info from interrupt
int R_buf = 0;
int G_buf = 0;
int B_buf = 0;

/* LED brightness does not increase linearly with PWM duty cycle.
 * The following lookup table is used to approximate linearity.
 * (also called in ISR, so it needs to be global too)
 */

int lookup[256] = {
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
	0x01, 0x01, 0x01, 0x01,	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,	0x02, 0x02, 0x03, 0x03,
	0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05,
	0x05, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09,
	0x0A, 0x0A, 0x0B, 0x0B,	0x0C, 0x0C, 0x0D, 0x0D, 0x0E, 0x0F, 0x0F, 0x10,
	0x11, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,	0x18, 0x19, 0x1A, 0x1B,
	0x1C, 0x1D, 0x1F, 0x20, 0x21, 0x23, 0x24, 0x26, 0x27, 0x29, 0x2B, 0x2C,
	0x2E, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3A, 0x3C, 0x3E, 0x40, 0x43, 0x45,
	0x47, 0x4A, 0x4C, 0x4F,	0x51, 0x54, 0x57, 0x59, 0x5C, 0x5F, 0x62, 0x64,
	0x67, 0x6A, 0x6D, 0x70, 0x73, 0x76, 0x79, 0x7C,	0x7F, 0x82, 0x85, 0x88,
	0x8B, 0x8E, 0x91, 0x94, 0x97, 0x9A, 0x9C, 0x9F, 0xA2, 0xA5, 0xA7, 0xAA,
	0xAD, 0xAF, 0xB2, 0xB4, 0xB7, 0xB9, 0xBB, 0xBE, 0xC0, 0xC2, 0xC4, 0xC6,
	0xC8, 0xCA, 0xCC, 0xCE,	0xD0, 0xD2, 0xD3, 0xD5, 0xD7, 0xD8, 0xDA, 0xDB,
	0xDD, 0xDE, 0xDF, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5,	0xE6, 0xE7, 0xE8, 0xE9,
	0xEA, 0xEB, 0xEC, 0xED, 0xED, 0xEE, 0xEF, 0xEF, 0xF0, 0xF1, 0xF1, 0xF2,
	0xF2, 0xF3, 0xF3, 0xF4, 0xF4, 0xF5, 0xF5, 0xF6, 0xF6, 0xF6, 0xF7, 0xF7,
	0xF7, 0xF8, 0xF8, 0xF8,	0xF9, 0xF9, 0xF9, 0xF9, 0xFA, 0xFA, 0xFA, 0xFA,
	0xFA, 0xFB, 0xFB, 0xFB, 0xFB, 0xFB, 0xFB, 0xFC,	0xFC, 0xFC, 0xFC, 0xFC,
	0xFC, 0xFC, 0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD,
	0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
	0xFE, 0xFE, 0xFF, 0xFF
};

int main (void){

	DDRB |= (1<<PB1);		// PB1 as output
	DDRB |= (1<<PB2);		// PB1 as output
	DDRD |= (1<<PD6);		// PD6 as output

	usbInit();		// required by VUSB
	init_PWM();		// initialize PWM

	wdt_enable(WDTO_1S);	// enable 1s watchdog timer

	// counters for loops
	int i,j;

	// force enumeration: disconnect, wait 1/2s, reconnect
	usbDeviceDisconnect();
	for(i=0; i<250; i++){
		wdt_reset();	// keep watchdog happy
		_delay_ms(2);
	}
	usbDeviceConnect();

	// enable interrupts
	sei();

	// three arrays to hold the LED color info
	float currentColor[3] = {0,0,0};
	float nextColor[3] = {0,0,0};
	float increment[3] = {0,0,0};

	// create a random seed from the ADC, then seed the rand() function
	int seed = 0;
	seed = rnd_seed(seed);
	srand(seed);

	while(1){

		wdt_reset();	// keep watchdog happy
		usbPoll();		// needs to be called every 50ms
		_delay_ms(fade_delay);

		for (i=0; i<3; i++){
			// randomly choose new colors
			nextColor[i] = rand() & 0xff;
			// set the incremental change value for all three colors
			increment[i] = (nextColor[i] - currentColor[i]) / 256;
		}

		// loop to slowly change colors
		for (i=0; i<256; i++){

			if(!fade){
				R_PWM = R_buf;
				G_PWM = G_buf;
				B_PWM = B_buf;
				break;
			}

			// assign color info to PWM
			R_PWM = lookup[(int)currentColor[0]];
			G_PWM = lookup[(int)currentColor[1]];
			B_PWM = lookup[(int)currentColor[2]];

			// increment current color
			for (j=0; j<3; j++){
				currentColor[j] += increment[j];
			}
			
			wdt_reset();	// keep watchdog happy
			usbPoll();		// needs to be called every 50ms
			_delay_ms(fade_delay);
		}	// end fade

	} // end while
	
	return 1;	// should never get here
} // end main

/*************************************************************************/
void init_PWM(void){

	TCCR0A |= (1<<COM0A1);				// clear OC0A on compare
	TCCR0A |= (1<<WGM00);				// phase correct PWM mode

	TCCR0B |= (1<<CS00);				// no clock prescaler

	TCCR1A |= (1<<COM1A1);				// clear OC1A on compare
	TCCR1A |= (1<<COM1B1);				// clear OC1B on compare
	TCCR1A |= (1<<WGM10);				// phase correct PWM mode, 8 bit

	TCCR1B |= (1<<CS10);				// no clock prescaler

}	// end init_PWM()

/*************************************************************************/
int rnd_seed(int seed){

	// ADC needs a clockrate of 50-200kHz.  With a system clock of 16MHz,
	// we need a prescaler of 80-320, so we use 128
	ADCSRA |= (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0);		//set prescaler to 128
	ADCSRA |= (1<<ADEN); 				//enable the ADC

	// ADMUX by default uses channel ADC0 on pin 23
	ADMUX |= (1<<REFS0);				//AVcc pin as reference voltage

	//start conversion
	ADCSRA |= (1<<ADSC);
	//wait until the hardware clears the flag
	while (ADCSRA & (1<<ADSC))
		{;}
	// read the lowest byte of data
	unsigned char byte1 = ADCL;

	//start conversion
	ADCSRA |= (1<<ADSC);
	//wait until the hardware clears the flag
	while (ADCSRA & (1<<ADSC))
		{;}
	// read the lowest byte of data
	unsigned char byte2 = ADCL;

	// create the seed by merging the two random bytes
	seed = (byte1<<8) | byte2;

	//disable ADC
	ADCSRA &= (0<<ADEN);
	// remove power from ADC
	PRR |= (1<<PRADC);

	return seed;
}	// end rnd_seed

/*************************************************************************/
USB_PUBLIC uchar usbFunctionSetup(uchar data[8]){
	usbRequest_t *rq = (void *)data;	// cast data to right type

	switch(rq->bRequest){
	case RED:
		R_buf = lookup[ (int)rq->wValue.bytes[0] ];
		fade = 0;						// clear fade flag
		return 0;

	case GREEN:
		G_buf = lookup[ (int)rq->wValue.bytes[0] ];
		fade = 0;						// clear fade flag
		return 0;

	case BLUE:
		B_buf = lookup[ (int)rq->wValue.bytes[0] ];
		fade = 0;						// clear fade flag
		return 0;

	case FADE:
		fade = 1;						// set fade flag
		return 0;
	}

	return 0;	// should never get here
}	// end usbFunctionSetup()