/**********************************************************
 * Joel Ong (jyo2), Frank Chen (flc23), Justin Leow (jl574)
 * ECE 4760 Final Project
 * Tutor
 * Friday Lab
 **********************************************************/

#include <string.h>
#include <math.h>
#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <stdlib.h>

#include "uart.h"
FILE uart_str = FDEV_SETUP_STREAM(uart_putchar, uart_getchar, _FDEV_SETUP_RW);

// Timeout values
#define t1 50
unsigned int t2;
#define t3 100
#define t4 200

// Debounce States
#define NoPush		0
#define MaybePush	1
#define Pushed		2
#define MaybeNoPush	3

// Modes
#define SongMode	0
#define ChordMode	1

// Limits
#define maxSongs	5
#define maxLength	100
#define maxChords	100

// Tasks
void debounce(void);
void update(void);
void read(void);
void process(void);

// Subroutines
void initialize(void);
void play(unsigned char);
void light(unsigned char,unsigned char);
void setTempo(void);
unsigned char getKey(void);

void getstr_int(void);	// Starts getting a string from serial line
void putstr_int(void);	// Starts a send to serial line

// Task scheduling timeout counters
volatile unsigned char time1;
volatile unsigned int time2;
volatile unsigned char time3;
volatile unsigned char time4;

// States
unsigned char debounceState;
unsigned char playState;
unsigned char mode;

// Variables
unsigned char song;
unsigned char pointer;
unsigned char chord;

// Preset Songs and Chords
unsigned char numSongs = 2;
char * songNames[maxSongs] = {"Happy Birthday", "Greensleeves"};
unsigned char tempo[maxSongs] = {60,45};
unsigned char length[maxSongs] = {25,32};
unsigned char library[maxSongs][maxLength] = {
	{0, 0,0,0, 4,4,4, 4,4,4, 0,0,0, 0,0,0, 4,3,3, 0,0,4, 0,0,0},
	{12,0,4,9, 12,12,2,2, 12,0,4,9, 12,2,12,12, 0,0,4,9, 12,12,2,2, 0,0,4,9, 12,2,12,12}
	};

unsigned char numChords = 14;
char * chordNames[maxChords] = {"C","D","E","F","G","A","B",
						"Cm","Dm","Em","Fm","Gm","Am","Bm"}; 
unsigned char chords[maxChords][6] =  {{5,3,2,0,1,0}, // 0 C major 
								{5,5,0,2,3,2}, // 1 D major
								{0,2,2,1,0,0}, // 2 E major
								{1,3,3,2,1,1}, // 3 F major
								{3,2,0,0,0,3}, // 4 G major
								{5,0,2,2,2,0}, // 5 A major
								{0,0,0,0,0,0}, // 6 B major

								{0,3,2,0,1,0}, // 7 C minor
								{5,5,0,2,3,1}, // 8 D minor
								{0,2,2,0,0,0}, // 9 E minor
								{1,3,3,1,1,1}, // 10 F minor
								{0,0,0,0,0,0}, // 11 G minor
								{5,0,2,2,1,0}, // 12 A minor
								{0,0,0,0,0,0}};// 13 B minor							  

// User Interface Variables
char command[16];			// Command entered
char arg1[20];				// Command argument 1
char arg2[10];				// Command argument 2
char newstr;				// task1-->task2 handshake

// RXC ISR variables
volatile unsigned char r_index;	//current string index
volatile char r_buffer[32];		//input string 
volatile unsigned char r_ready;	//flag for receive done
volatile char r_char;			//current character  

// TX ISR variables
volatile unsigned char t_index;	//current string index
volatile char t_buffer[512];	//output string 
volatile unsigned char t_ready;	//flag for transmit done
volatile char t_char;			//current character


/**********************************************************
 * Timer 0 Compare Match ISR
 **********************************************************/
ISR (TIMER0_COMPA_vect) {
	if (time1) time1--;
	if (time2) time2--;
	if (time3) time3--;
	if (time4) time4--;
}

/**********************************************************
 * UART character-ready ISR
 * builds a string and signals when the string is complete
 * supports backspace
 **********************************************************/
ISR (USART0_RX_vect) {
	r_char = UDR0 ;    //get a char
	UDR0 = r_char;    //then print it
	//build the input string
	if (r_char != '\r') {			// Is the input a <enter>?
		if (r_char == '\b')	{	// Is the input a backspace? 
			putchar(' ');	// erase the character on the screen
			putchar('\b');		// backup
			--r_index;		// wipe a character from the string
		}
		else   
 			r_buffer[r_index++] = r_char ; // add a character to the string
	}
	else {					// Human pressed <enter>
		putchar('\n');  			//use putchar to avoid overwrite
		r_buffer[r_index] = 0x00;   //zero terminate
		r_ready = 1;			//signal cmd processor
		UCSR0B ^= (1<<RXCIE0) ;   	//stop rec ISR -- clear rxc
	}
}

/**********************************************************
 * UART xmit-empty ISR
 **********************************************************/
ISR (USART0_UDRE_vect) {
	t_char = t_buffer[++t_index];
	if (t_char == 0) {			// end of string?
		UCSR0B ^= (1<<UDRIE0);	// kill isr -- clear tx enable
		t_ready = 1; 			// transmit done 
	}
	else
		UDR0 = t_char;			//send the char 
}

/**********************************************************
 * Entry Point and Task Scheduler Loop
 **********************************************************/
int main(void) {
	initialize();

	while(1) {
		if (!time1) { time1=t1; debounce(); }
		if (!time2) { time2=t2; update(); }
		if (!time3) { time3=t3; read(); }
		if (!time4) { time4=t4; process(); }
	}
}

/**********************************************************
 * Debounce Task
 **********************************************************/
void debounce(void) {
	unsigned char pressed = getKey();
	switch (debounceState) {
		case NoPush: 
			if (pressed)
				debounceState=MaybePush;
			else debounceState=NoPush;
			break;
		case MaybePush:
			if (pressed) {
				debounceState=Pushed;
				if (pressed==1)
					playState = 1;
				else if (pressed==2) {
					playState = 0;
					pointer = 0;
					PORTA=0;
					PORTB=0;
					PORTC=0;
				}
				else playState = 0;
			}
			else debounceState=NoPush;
			break;
		case Pushed:
			if (!pressed) debounceState=MaybeNoPush;
			break;
		case MaybeNoPush:
			if (pressed) debounceState=Pushed;
			else debounceState=NoPush;
			break;
	}
}

/**********************************************************
 * Update LEDs Task
 **********************************************************/
void update(void) {
	if (mode==SongMode && playState) {
		for (unsigned char str=0; str< 6; str++)
			light(str,chords[library[song][pointer]][str]);
		pointer++;
		if (pointer>length[song]) {
			playState = 0;
			pointer = 0;
		}
	}
	else if (mode==ChordMode) {
		for (unsigned char str=0; str< 6; str++)
			light(str,chords[chord][str]);
	}
}

/**********************************************************
 * Read Command Task
 **********************************************************/
void read(void) {
		//print and get another serial string
	if (r_ready) {
		// read string which is now ready
		sscanf((const char*)r_buffer,"%s %s %s", command , arg1, arg2);

		// set up procedure to get the next string input
		// and read it using receive ISR
		getstr_int();
		newstr = 1;	// signal task2 that a new string is ready
	}
}

//TODO: google avrlibc eeprom for writing to eeprom during runtime

/**********************************************************
 * Process Command Task
 **********************************************************/
void process(void) {
	// see if there is a message from task1 and if the last transmit is done
	if (t_ready && newstr) {
		if (!strcmp(command,"mapping")) {
			printf("\nCode \t LEDs \t Meaning \n\r"
				"0 \t none \t Strum Open String \n\r"
				"1 \t 1 \t First fret \n\r"
				"2 \t 2 \t Second fret \n\r"
				"3 \t 3 \t Third fret \n\r"
				"4 \t 4 \t Fourth fret \n\r"
				"5 \t all \t No Strum \n\r");
		} else if (!strcmp(command, "chords")) {
			printf("\nCHORDS\n\r");
			for (unsigned char i = 0; i<numChords; i++) {
				printf("%d. %s \t %d%d%d%d%d%d\n\r",i,chordNames[i],chords[i][0],
					chords[i][1],chords[i][2],chords[i][3],chords[i][4],chords[i][5]);
			}
		} else if (!strcmp(command, "library")) {
			printf("\nSONGS\n\r");
			for (unsigned char i = 0; i<numSongs; i++) {
				printf("%d. %s \t %d bpm\n\r",i,songNames[i],tempo[i]);
			}
		} else if (!strcmp(command, "playchord")) {
			unsigned int i;
			sscanf(arg1,"%d", &i);
			if (i<numChords) {
				mode = ChordMode;
				chord = arg1;
				printf("\nChord set to %s\n\r",chordNames[i]);
			}
			else	printf("\nSpecified chord does not exist.\n\r");
		} else if (!strcmp(command, "playsong")) {
			unsigned int i;
			sscanf(arg1,"%d", &i);
			if (i<numSongs) {
				mode = SongMode;
				song = i;
				setTempo();
				printf("\nSong set to %s\n\r",songNames[i]);
			}
			else	printf("\nSpecified song does not exist.\n\r");
		} else if (!strcmp(command, "addchord")) {
			if (numChords!=maxChords) {
				unsigned long i;
				sscanf(arg2,"%ld", &i);
				chordNames[numChords] = arg1;
				chords[numChords][0] = i/100000;
				chords[numChords][1] = i%100000/10000;
				chords[numChords][2] = i%10000/1000;
				chords[numChords][3] = i%1000/100;
				chords[numChords][4] = i%100/10;
				chords[numChords][5] = i%10;
				numChords++;				
				printf("\nThe following chord has been added: %s.\n\r",arg1);
			}
			else	printf("\nError: Maximum number of chords reached.\n\r");
		} else if (!strcmp(command, "addsong")) {
			if (numSongs!=maxSongs) {
				unsigned int t;
				sscanf(arg2,"%d", &t);
				tempo[numSongs] = t;
				songNames[numSongs] = arg1;

				// ***** TODO!! input song chords ***********
				// BUGGY

				numSongs++;
				printf("\nThe following song has been added: %s.\n\r",arg1);
			}
			else	printf("\nError: Maximum number of songs reached.\n\r");
		} else if (!strcmp(command, "help")) {		// List commands
			printf("\nCOMMANDS\n\r"
					"mapping\t\t\t\t\tLED-code mappings\n\r"
					"chords\t\t\t\t\tList chords\n\r"
					"library\t\t\t\t\tList song library\n\r"
					"playchord [chord]\t\t\tProgram chord\n\r"
					"playsong [song]\t\t\t\tProgram song\n\r"
					"addchord [name] [xxxxxx]\t\tAdd chord by LED codes\n\r"
					"addsong [name] [tempo] [chord0,...]\tAdd song by chord codes\n\r");
		} else
			printf("Unrecognized Command: %s \n\r", command);
		sprintf((char*)t_buffer,"\n>>");
		putstr_int();	// print it using transmit ISR
		newstr = 0;		// clear the string ready handshake from task 1
	}
}

/**********************************************************
 *  Decode and returns button number of pressed button
 **********************************************************/
unsigned char getKey(void) {
	if (PIND & 0x08)
		return 1;
	else if (PIND & 0x10)
		return 2;
	else if (PIND & 0x20)
		return 3;
	else return 0;
}

/**********************************************************
 * Light up appropriate LEDs for fret state
 **********************************************************/
void light(unsigned char str, unsigned char fret) {
	switch (str) {
		case 0:
			if (!fret) PORTB &= 0xf0;
			else if (fret==5) PORTB |= 0x0f;
			else PORTB = (PORTB & 0xf0) | (0x01 << (fret-1));
			break;
		case 1:
			if (!fret) PORTB &= 0x0f;
			else if (fret==5) PORTB |= 0xf0;
			else PORTB = (PORTB & 0x0f) | (0x10 << (fret-1));
			break;
		case 2:
			if (!fret) PORTA &= 0xf0;
			else if (fret==5) PORTA |= 0x0f;
			else PORTA = (PORTA & 0xf0) | (0x01 << (fret-1));
			break;
		case 3:
			if (!fret) PORTA &= 0x0f;
			else if (fret==5) PORTA |= 0xf0;
			else PORTA = (PORTA & 0x0f) | (0x10 << (fret-1));
			break;
		case 4:
			if (!fret) PORTC &= 0xf0;
			else if (fret==5) PORTC |= 0x0f;
			else PORTC = (PORTC & 0xf0) | (0x01 << (fret-1));
			break;
		case 5:
			if (!fret) PORTC &= 0x0f;
			else if (fret==5) PORTC |= 0xf0;
			else PORTC = (PORTC & 0x0f) | (0x10 << (fret-1));
			break;
	}
}

/**********************************************************
 * Set Tempo
 **********************************************************/
void setTempo(void) {
	t2 = 60000/tempo[song];
}


/**********************************************************
 * Non-blocking keyboard input: initializes ISR-driven receive.
 * This routine merely sets up the ISR, which then
 * does all the work of getting a command.
 **********************************************************/
void getstr_int(void) {
	r_ready=0;	// mark string as not ready
	r_index=0;	// reset index
	// turn on receive ISR
	UCSR0B |= (1<<RXCIE0);
}

/**********************************************************
 * Nonblocking print: initializes ISR-driven transmit. 
 * This routine merely sets up the ISR, then
 * sends one character, The ISR does all the work.   
 **********************************************************/ 
void putstr_int(void) {
	t_ready=0;	// mark transmitter as busy
	t_index=0;	// reset index
	// see if there is actually a string
	if (t_buffer[0]>0) {
		// if so, send one chararcter
		putchar(t_buffer[0]);
		// and turn on transmit (UDR empty) ISR
		UCSR0B |= (1<<UDRIE0);
	}
}

/**********************************************************
 * Set up MCU and initialize variables
 **********************************************************/
void initialize(void) {

	// Init the UART
	uart_init();
	stdout = stdin = stderr = &uart_str;
	fprintf(stdout,"Starting ISR UART demo...\n\r>>");

	// Timer 0 - 1 kHz
	OCR0A = 249;			// clear after 250 counts
	TIMSK0 = (1<<OCIE0A);	//turn on timer 0 cmp-match ISR
	TCCR0A = (1<<WGM01);	// turn on timer 0 clear on match
	TCCR0B = 3;				// timer 0 prescalar to 64

	// Ports
	DDRA = 0xff;
	DDRB = 0xff;
	DDRC = 0xff;
	//DDRD = 0x00;
	PORTA = 0x00;
	PORTB = 0x00;
	PORTC = 0x00;
	
	// Calculate timeout value t2 to match beat frequency
	setTempo();
	
	// Task timers
	time1 = t1;
	time2 = t2;
	time3 = t3;
	time4 = t4;


	// Initialize the USRT handshake flags
	r_ready=0; // initially, there is no input ready
	t_ready=1; // initially, the transmitter is ready

	sei();			// Crank up ISRs

	getstr_int();	// get the first string from the human
}