/*********************************************
This program was produced by the
CodeWizardAVR V1.0.1.5d Standard
Automatic Program Generator
© Copyright 1998-2001
Pavel Haiduc, HP InfoTech S.R.L.
http://infotech.ir.ro
e-mail:dhptechn@ir.ro , hpinfotech@mail.com

Project : 
Version : 
Date    : 4/12/2001
Author  : License #1                      
Company : Cornell University Ithaca NY USA
Comments: 


Chip type           : AT90S8515
Clock frequency     : 4.000000 MHz
Memory model        : Small
Internal SRAM size  : 512
External SRAM size  : 0
Data Stack size     : 128
*********************************************/

#include <90s8515.h>
#include <delay.h>    
#include <stdio.h> 
#include <stdlib.h>
#define ir_repeat 3
#define carrier_on 0x40
#define carrier_off 0xC0
#define maxkeys 30

//state machine variables
#define reset 0
#define countkey 1
#define pressed 2
#define released 3
#define countrel 4
#define stillrel 5

/* Use an 1x16 alphanumeric LCD connected
   to PORTC as follows:
   
  [LCD]   [AT90S8515 DIP40]
   1 GND- 20 GND
   2 +5V- 40 VCC
   3 VLC 10k trimpot wiper (trimpot ends go to +5 and gnd) 
   4 RS - 21 PC0
   5 RD - 22 PC1
   6 EN - 23 PC2
  14 BUSY -  PC3
  11 D4 - 25 PC4
  12 D5 - 26 PC5
  13 D6 - 27 PC6
  14 D7 - 28 PC7 
*/
  
#asm
    .equ __lcd_port=0x15
#endasm
#include <c:\windows\desktop\final\lcd_mult.h> // LCD driver routines 

//define keypad button numbers
#define stop 1
#define pause 2
#define play 3
#define source1 4
#define rew 5
#define ff 6
#define mute 7
#define source2 8
#define prev 9
#define next 10
#define disp 11
#define source3 12
#define rec 13
#define pwr 14
#define source4 15
#define one 16
#define two 17
#define three 18
#define volup 19
#define four 20
#define five 21
#define six 22
#define voldn 23
#define seven 24
#define eight 25
#define nine 26
#define shuffle 27
#define ten 28
#define repeat 29
#define cont 30          

#define reload 256-78           

//LCD display constants
#define mute_display 1
#define pause_display 2 
#define record_display 3
// Declare your global variables here

//The keypad lookup table
flash unsigned char keytbl [30] = {0xee, 0xde, 0xbe, 0x7e,
									0xed, 0xdd, 0xbd, 0x7d,
									0xeb, 0xdb, 0xbb, 0x7b,
									0xd7, 0xb7, 0x77,
									0xe6, 0xc6, 0xa6, 0x66,
									0xe5, 0xc5, 0xa5, 0x65,
									0xe3, 0xc3, 0xa3, 0x63,
									0xc7, 0xa7, 0x67};            

//the CD IR-command table			
flash int cdtbl [30] = {0x8B8, 0x8B9, 0x8B2, 0x0,
						0x8B3, 0x8b4, 0x0, 0x0,
						0x8B0, 0x8B1, 0x0, 0x0,
						0x8BE, 0x895, 0x0,
						0x880, 0x881, 0x882, 0x0,
						0x883, 0x884, 0x885, 0x0,
						0x886, 0x887, 0x888, 0x8B5,
						0x8A0, 0x8AC, 0x89D};    
  						
//the MiniDisc command table
flash int mdtbl [30] = {0x7A8, 0x7A9, 0x7AA, 0x0,
						0x7AB, 0x7AC, 0x0, 0x0,
						0x7A0, 0x7A1, 0x798, 0x0,
						0x7AD, 0x795, 0x0,
						0x780, 0x781, 0x782, 0x0,
						0x783, 0x784, 0x785, 0x0,
						0x786, 0x787, 0x788, 0x79E,
			   			0x789, 0x7A6, 0x79D};	
			   			
//the winamp command table
flash char winamptbl [30] = {'v', 'c', 'x', '-',
							 'g', 'h', 'm', '-',
							 'z', 'b', 't', '-',
							 '-', 'f', '-',
							 '-', '-', '-', 'p',
							 '-', '-', '-', 'l',
							 '-', '-', '-', 's',
							 '-', 'r', '-'};
							 
//Setup the UART
/* quartz crystal frequency [Hz] */
#define xtal 4000000L
/* Baud rate */
#define baud 9600

//The Winamp title buffer
char lcd_buffer[80];     
 
//buffer array index
unsigned char index=0;						

//the keypad port read
unsigned char key;

//the debounce state machine run flag
unsigned char run=0;

//the length of the title received from Winamp
unsigned char string_len=0;

//control variable to run the winamp lcd titler     
unsigned char title_lcd=0;

//the 500msec counter for LCD scrolling
unsigned char title_count=0;

//the current IR instruction to be transmitted
int ir_data;

//the current uart instruction to be transmitted
char uart_data;                  

//IR code transmission mask
unsigned int mask;   

//decoded keypad button number
unsigned char butnum;      

//the code of the current active audio source
unsigned char active=source1;         

//the debounce state machine state variable
unsigned char keycheck_state=reset;

//keypad state machine variables
unsigned char oldbutnum, count; 

//the LCD scrolling index
unsigned char display_index=0;

//flag for reserving the LCD for displaying cuurent commands
unsigned char Lcd_override=0;
unsigned char old_Lcd_override=0;

//timer 0 overflow index
interrupt [TIM0_OVF] timer0_ovf(void){
	//reload the register
	TCNT0=reload;
	//run the debounce state machine
	run=1;

	//run the LCD scroller every 500msec
	if (title_count==100)
	{
		title_lcd=1;
		title_count=0;
	}
	else
		title_count++;
	
}

//the UART receive interrupt
interrupt [UART_RXC] void uart_rec(void){
	unsigned char i;
	//limit the size of the input string
	if (index<64){
	 	lcd_buffer[index]=UDR;    //get a char
 		index++;         
	 	display_index=0;  
	 	string_len=0;
		//if the received character ends transmission
		if (lcd_buffer[index-1]=='\r'){
 			string_len=index;
 			index=0;
			//print the title to the LCD
			title_lcd=1;
 			//padding title with spaces for easy viewing
 			for(i=string_len-1;i<(string_len+16);i++)
 			{
 				lcd_buffer[i]=' ';
			}
 		}
 		
 	}	
}
             
//keypad check routine  
void keycheck (void)
{
	//read in the keys, 1 nibble at a time
	key=0;
	DDRA=0x0f;
	PORTA = 0xf0;                                             
	delay_us(5);
	key = PINA;
	DDRA=0xf0;
	PORTA = 0x0f;
	delay_us(5);
	key = key|PINA;

	//check the keypad table, if found, it is valid
	if (key!=0){
		for(butnum=0;butnum<maxkeys;butnum++){
				if(keytbl[butnum]==key){
				break;
			}
		}
		if (butnum==maxkeys){
			butnum=0;
		} else {
			butnum++;
		}   
	}
} 
 
//IR transmission scheme
void IR_SEND (int ir_code){
	unsigned char i, j;
	TCNT1=0;          

	for(i=1;i<ir_repeat;i++)
    {
		//set the command mask
		mask=0x1; 
		//reset timer 1 for accurate interrupts
		TCNT1=0;          
		//Send start signal 4T on, T off
		TCCR1A=carrier_on;
		delay_us(2400);
		TCCR1A=carrier_off;
		delay_us(600);  
		//send the IR code itself
    	for (j=0;j<12;j++)
    	{     	 
   			TCNT1=0;   
			//Transmit T on
           	TCCR1A = carrier_on;
	      	delay_us(600);
      		if((ir_code&mask)!=0){
				//Transmit another T on
    	  		delay_us(600);
      		}
			//Transmit T off
      		TCCR1A = carrier_off;
    	 	delay_us(600);
			//move the command mask to transmit the next bit
   			mask = mask<<1;
		}
		//wait 24 msec between transmissons
		delay_ms(24);
   	
	}
}         

//transmit the Winamp command character
void UART_SEND (char uart_code){
	putchar(uart_code);
}

void device_redisplay(void)
{
	switch(active){
		case(source1):{
			lcd_clear();
			lcd_putsf("Sony MiniDisc");
			lcd_putsf("MiniDisc");	
			break;
		}
		case(source2):{
			lcd_clear();
			lcd_putsf("Sony CD");
			break;
		}
		case(source3):{
			lcd_clear();
			lcd_putsf("PC Winamp");
			lcd_putsf("C Winamp");
			break;
		}
		case(source4):{
			lcd_clear();
			lcd_putsf("Auxillary");  
			lcd_putsf("uxillary");
			break;
		}
	}//switch(active)
}//device_redisplay
			
		
//
void EX_COMMAND(void){
  	if (butnum==0){
	}
	//Activate input1
	else if (butnum==source1){ 
  		active=source1;
		device_redisplay();
		//mute off
		PORTD.2=0;
		//turn off mute display on input change
		if (Lcd_override==mute_display)
		{
			Lcd_override=0;
		}
		//muxes select input1
		PORTD.3=0;
		PORTD.4=0;
	}
	//Activate input 2
	else if (butnum==source2){
		active=source2;
		device_redisplay();
		//mute off
		PORTD.2=0;
		//turn off mute display on input change
		if (Lcd_override==mute_display)
		{
			Lcd_override=0;
		}
		//muxes select input 2
		PORTD.3=1;
		PORTD.4=0;
	}
	//Activate input 3
	else if (butnum==source3){ 
		active=source3;
		device_redisplay();
		//mute off
		PORTD.2=0;
		//turn off mute display on input change
		if (Lcd_override==mute_display)
		{
			Lcd_override=0;
		}
		//muxes select input 3
		PORTD.3=0;
		PORTD.4=1;
	}
	//Activate input 4
	else if (butnum==source4){
		active=source4;
		device_redisplay();
		//mute off
		PORTD.2=0;
		//turn off mute display on input change
		if (Lcd_override==mute_display)
		{
			Lcd_override=0;
		}
		
		//muxes select input 4
		PORTD.3=1;
		PORTD.4=1;
	}else if (butnum==mute){  
		//toggle the mute bit
		PORTD=PORTD^0x04;
		//set flag for muting display on LCD
		if (Lcd_override==mute_display)
		{
			//if a double mute exists, clear the last one
			if(old_Lcd_override==mute_display)
			{
				Lcd_override = 0;
			}
			else
			{	
				//otherwise, restore the previous instruction before mute was first pressed
				Lcd_override=old_Lcd_override;
				old_Lcd_override=0;
			}
		}
		else
		{
			if(old_Lcd_override==mute_display)
			{
				//turn off a mute that occured before the current LCD display instruction
				old_Lcd_override = 0;
			}
			//turn on a mute for the "first" time
			else
			{
				old_Lcd_override = Lcd_override;
				Lcd_override = mute_display;
			}
		}
		//if the last instruction is a mute that is cancelled, redisplay the current device
		if(Lcd_override==0)
		{
			device_redisplay();
		}
	}
	else{
		//set flag for pause display on LCD
		if(butnum==pause)
		{
			if (Lcd_override==pause_display)
			{
				//if a double pause exists, clear the last one
				if(old_Lcd_override==pause_display)
				{
					Lcd_override = 0;
				}
				//otherwise, restore the previous instruction before pause was first pressed
				else
				{	
					Lcd_override=old_Lcd_override;
			 		old_Lcd_override=0;
			 	}	
			}
			else
			{
				if(old_Lcd_override==pause_display)
				{
					//turn off a pause that occured before the current LCD display instruction
					old_Lcd_override = 0;
				}
			    else
				{	
					//turn on pause
					old_Lcd_override = Lcd_override;
					Lcd_override = pause_display;
				}
			}
			//if the last instruction is a pause that is cancelled, redisplay the current device
			if(Lcd_override==0)
			{
				device_redisplay();
			}
		}//if(butnum==pause)

		if(butnum==stop)
		{
			//stop pauses with the press of a stop for any device
			if(Lcd_override==pause_display)
			{
				Lcd_override=old_Lcd_override;
				old_Lcd_override=0;
			}
			//stop a pause that occured previous to the current instruction
			if(old_Lcd_override==pause_display)
			{
				old_Lcd_override=0;
			}
			if(Lcd_override==0)
			{
		 		device_redisplay();
			}
		}//if(butnum==stop)
			
		if (active==source1) {
				//get and transmit the appropriate IR command
				if (butnum==rec)
				{
					Lcd_override=record_display;
					//record does not need to preserve any of the previous states
					old_Lcd_override = 0;
				}
				//a stop in the minidisc will turn off any record or record then pause combination
				if (butnum==stop) 
				{
					//record is stopped
					if(Lcd_override==record_display)
					{
						Lcd_override = 0;
					}
					//check instruction after a record
					else if (old_Lcd_override==record_display)
					{
						//preserve a mute after a record
						if(Lcd_override==mute_display)
						{
							old_Lcd_override=0;
							Lcd_override=mute_display;
						}
						//do not preserve a pause after a record
						else if(Lcd_override==pause_display)
						{
							old_Lcd_override=0;
							Lcd_override=0;
						}
					}
				}
				//if the last instruction is a record that is cancelled, redisplay the current device
				if(Lcd_override==0)
				{
		 			device_redisplay();
				}
				ir_data=mdtbl[butnum-1];
  				IR_SEND(ir_data); 
  		} 
  		else if (active==source2){
				//get and transmit the appropriate IR command
  				ir_data=cdtbl[butnum-1];
  				IR_SEND(ir_data);
  		} 
  		else if (active==source3){
				//get and transmit the appropriate UART command
  				uart_data=winamptbl[butnum-1];
  				UART_SEND(uart_data);
  				//Setup source 3
  		} 
  		else if (active==source4){
  				//Setup source 4
				//Passive input
  		}
      
	}  
}

//debounce the button press
void debounce(void){
switch(keycheck_state){

			//reset state
			case (reset):{  
				//read in the keypad
				keycheck();
				if(butnum!=0)
				{
					//valid button pressed
					oldbutnum = butnum;
					count=0;
					keycheck_state=countkey;
				}
				break;
			}//reset
			case (countkey):{
				//wait 30 msec
				if (count=6)
				{
					keycheck_state=pressed;
				}
				else 
				{
					count++;
				}
				break;
			}//countkey
			case(pressed):{
				//read in the keypad
				keycheck();   
				if(butnum==oldbutnum)
				{
					//button is pressed,execute instruction
					TCCR1A=carrier_off;
					EX_COMMAND();					
					keycheck_state=released;
				}//if
				else
				{
					//button has not been pressed correctly
					keycheck_state=reset;
				}
				break;
			}//pressed
			case(released):{
				//read in the keypad
				keycheck();
				//button released
				if(butnum==0)
				{
					keycheck_state=countrel;
					count=0;
				}
				//continue transmitting for ff, rew, vol+, vol-
				else if (butnum==5 | butnum==6 | butnum==19 | butnum==23){
					EX_COMMAND();
				}
				break;
			}//released
			case(countrel):{
				//wait 30 msec
				if(count==6)
				{
					keycheck_state=stillrel;
				}
				else
				{
					count++;
				}  
				break;
			}//countrel
			case(stillrel):{
				//read in the keypad
				keycheck();
				//button officially released
				if (butnum==0)
				{
					keycheck_state=reset;
				}
				//button not released
				else
				{
					keycheck_state=released;
					count=0;
				}
				break;
			}//stillrel
		}//switch(keycheck_state)
}   

//scrolling LCD titler
void title(unsigned char input_index){
	unsigned char put1[8];
	unsigned char put2[8];      
	unsigned char i;
	//create the left 8 characters
	for (i=0; i<8; i++){
		put1[i]=lcd_buffer[input_index+i];
	}
	//create the right 8 characters
 	for (i=0;i<8; i++){
		put2[i]=lcd_buffer[input_index+i+8];
	}       
	//clear the lcd
	_lcd_write_data(1);
	//write the left 8 characters
	lcd_gotoxy(0,0);
	lcd_puts(put1);
	//write the right 8 characters
	lcd_gotoxy(0,1);
	lcd_puts(put2);
}
	
	
	

void main(void)
{
// Declare your local variables here
unsigned char count_lcd_flash = 1;
// Input/Output Ports initialization
// Port A
DDRA=0x00;
PORTA=0x00;

// Port B
DDRB=0xFF;
PORTB=0x00;

// Port C
DDRC=0xFF;
PORTC=0xFF;

// Port D
DDRD=0xFF;
PORTD=0x01;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Output Compare
// OC0 output: Disconnected
TCCR0=0x04;
TCNT0=reload;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 4000.000 kHz
// Mode: Output Compare
// OC1A output: Toggle
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
TCCR1A=0x40;
TCCR1B=0x09;
TCNT1H=0x00;
TCNT1L=0x00;
OCR1AH=0x00;
OCR1AL=0x31;
OCR1BH=0x00;
OCR1BL=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
GIMSK=0x00;
MCUCR=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x02;
           
// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;

//Setup the UART
/* initialize the UART's baud rate */
UBRR=xtal/16/baud-1;

/* initialize the UART control register
   RX & TX enabled, no interrupts, 8 data bits */
UCR=0x98;                      

// initialize the LCD for 16 char wide
lcd_init(16); 
//clear it
lcd_clear(); 

lcd_putsf("Initiali");
lcd_gotoxy(0,1);
lcd_putsf("zing....");
delay_ms(1000);
lcd_clear();
device_redisplay();



#asm("sei")

while (1) { 
	//runs the keypad debounce state machine
	if (run==1){
		run=0;
		debounce();
	}     
	//display useful commands to the LCD
	if((title_lcd==1)&&(Lcd_override!=0))
	{
		title_lcd=0;
		//run counter to flash useful commands
		if(count_lcd_flash==1)
		{
			lcd_clear();
			count_lcd_flash=0;
		}
		else if(Lcd_override==pause_display)
		{
			count_lcd_flash=1;
			lcd_clear();
			lcd_putsf("Paused");
		}
		else if(Lcd_override==mute_display)
		{
			count_lcd_flash=1;
			lcd_clear();
			lcd_putsf("Mute");
		}
		else if(Lcd_override==record_display)
		{
			count_lcd_flash=1;
			lcd_clear();
			lcd_putsf("Record");
		}
	}	
	//runs the LCD title scroller
	if (active==source3){
		if ((title_lcd==1)&&(string_len!=0)&&(Lcd_override==0)){
			title_lcd=0;
			title(display_index); 
			display_index++;
			if (display_index>=string_len-1)
			{
				display_index=0;
			}
		}
 	}	
}
}