#include <mega32.h>
#include <stdio.h>
#include <delay.h>
#include "dflash.h"

#define begin {
#define end }

#define time1 1  

#define COUNT20 20		//1ms timer
#define COUNT10 10		//500us timer
#define COUNT30MS 30	//30ms timer

//define states for "blip detection" state machine
#define noblip 0
#define yesspace 1
#define done 2

//define types of spaces (inter-character = 0, short = 1, medium = 2)
#define shortspace 0
#define longspace 1
#define wordspace 2

//define types of marks
#define dot 0
#define dash 1

//define states for debounce state machine
#define NoPush 0
#define MaybePush 1
#define Pushed 2
#define MaybeNoPush 3

//define threshold for dots for different WPM
#define WPM10DOT 50
#define WPM15DOT 50
#define WPM20DOT 35
#define WPM25DOT 25
#define WPM30DOT 20
#define WPM35DOT 15
#define WPM40DOT 10

//define threshold for dashes for different WPM
#define WPM10DASH 170
#define WPM15DASH 170
#define WPM20DASH 125
#define WPM25DASH 100
#define WPM30DASH 80
#define WPM35DASH 70
#define WPM40DASH 60

//define threshold for inter-character gaps for different WPM
#define WPM10SHORT 150
#define WPM15SHORT 150
#define WPM20SHORT 100
#define WPM25SHORT 80
#define WPM30SHORT 70
#define WPM35SHORT 50
#define WPM40SHORT 50

//define threshold for short gaps for different WPM
#define WPM10LONG 1000
#define WPM15LONG 400
#define WPM20LONG 300
#define WPM25LONG 250
#define WPM30LONG 200
#define WPM35LONG 190
#define WPM40LONG 160

//define threshold for medium gaps for different WPM
#define WPM10WORD 1150
#define WPM15WORD 550
#define WPM20WORD 450
#define WPM25WORD 400
#define WPM30WORD 350
#define WPM35WORD 340
#define WPM40WORD 230

//define output threshold for timeouts for different WPM
#define WPM10TIMEOUT 1200
#define WPM15TIMEOUT 600
#define WPM20TIMEOUT 500
#define WPM25TIMEOUT 450
#define WPM30TIMEOUT 400
#define WPM35TIMEOUT 390
#define WPM40TIMEOUT 280

//define output duration of dots for different WPM
#define OUT_WPM10DOT 80
#define OUT_WPM15DOT 80
#define OUT_WPM20DOT 60
#define OUT_WPM25DOT 50
#define OUT_WPM30DOT 40
#define OUT_WPM35DOT 32
#define OUT_WPM40DOT 28

//define output duration of inter-character gaps for different WPM
#define OUT_WPM10SHORT 78//80
#define OUT_WPM15SHORT 78//80
#define OUT_WPM20SHORT 58//60
#define OUT_WPM25SHORT 46//48
#define OUT_WPM30SHORT 38//40
#define OUT_WPM35SHORT 30//32
#define OUT_WPM40SHORT 26//28

//define output duration of short gaps for different WPM
#define OUT_WPM10LONG 540
#define OUT_WPM15LONG 240
#define OUT_WPM20LONG 180
#define OUT_WPM25LONG 148
#define OUT_WPM30LONG 120
#define OUT_WPM35LONG 104
#define OUT_WPM40LONG 88

//define output duration of medium gaps for different WPM
//calculated by (actual medium gap - actual intercharacter gap)
#define OUT_WPM10WORD 1200
#define OUT_WPM15WORD 440
#define OUT_WPM20WORD 340
#define OUT_WPM25WORD 272
#define OUT_WPM30WORD 240
#define OUT_WPM35WORD 208
#define OUT_WPM40WORD 180

//Tree States
#define Start 100

#define E_Tree 101
#define T_Tree 102

#define I_Tree 103
#define A_Tree 104
#define N_Tree 105
#define M_Tree 106

#define S_Tree 107
#define U_Tree 108
#define R_Tree 109
#define W_Tree 110
#define D_Tree 111
#define K_Tree 112
#define G_Tree 113
#define O_Tree 114

#define H_Tree 115
#define V_Tree 116
#define F_Tree 117
#define UGer_Tree 118
#define L_Tree 119
#define AGer_Tree 120
#define P_Tree 121
#define J_Tree 122
#define B_Tree 123
#define X_Tree 124
#define C_Tree 125
#define Y_Tree 126
#define Z_Tree 127
#define Q_Tree 128
#define OGer_Tree 129
#define CH_Tree 130

#define Five_Tree 131
#define Four_Tree 132
#define SGer_Tree 133
#define Three_Tree 134
#define Eaccr_Tree 135
#define DGer_Tree 136
#define Two_Tree 137
#define Eaccl_Tree 138
#define Plus_Tree 139
#define BGer_Tree 140
#define Aacc_Tree 141
#define JGer_Tree 142
#define One_Tree 143
#define Six_Tree 144
#define Equal_Tree 145
#define Slash_Tree 146
#define CFre_Tree 147
#define Blank1_Tree 148
#define HGer_Tree 149
#define Seven_Tree 150
#define Blank2_Tree 151
#define GGer_Tree 152
#define NGer_Tree 153
#define Eight_Tree 154
#define Nine_Tree 155
#define Zero_Tree 156

#define Finished 157

//Speech states
#define Begin 200
#define CaseA 201
#define CaseABOUT 202
#define CaseALL 203
#define CaseAN 204
#define CaseAND 205
#define CaseARE 206
#define CaseAS 207
#define CaseAT 208
#define CaseB 209
#define CaseBE 210
#define CaseBEEN 211
#define CaseBUT 212
#define CaseBY 213
#define CaseC 214
#define CaseCA 215
#define CaseCALL 216
#define CaseCAN 217
#define CaseCO 218
#define CaseCOME 219
#define CaseCOULD 220
#define CaseD 221
#define CaseDAY 222
#define CaseDID 223
#define CaseDO 224
#define CaseDOWN 225
#define CaseE 226
#define CaseF 227
#define CaseFI 228
#define CaseFIND 229
#define CaseFIRST 230
#define CaseFOR 231
#define CaseFROM 232
#define CaseG 233
#define CaseH 234
#define CaseHA 235
#define CaseHAD 236
#define CaseHAS 237
#define CaseHAVE 238
#define CaseHE 239
#define CaseHER 240
#define CaseHI 241
#define CaseHIM 242
#define CaseHIS 243
#define CaseHO 244
#define CaseHOT 245
#define CaseHOW 246
#define CaseI 247
#define CaseIF 248
#define CaseIN 249
#define CaseIS 250
#define CaseIT 251
#define CaseK 252
#define CaseL 253
#define CaseLIKE 254
#define CaseLO 255
#define CaseLONG 256
#define CaseLOOK 257
#define CaseM 258
#define CaseMA 259
#define CaseMAKE 260
#define CaseMANY 261
#define CaseMAY 263
#define CaseMO 264
#define CaseMORE 265
#define CaseMOST 266
#define CaseMY 267
#define CaseN 268
#define CaseNO 269
#define CaseNOW 270
#define CaseNUMBER 271
#define CaseO 272
#define CaseOF 273
#define CaseON 274
#define CaseONE 275
#define CaseOR 276
#define CaseOTHER 277
#define CaseOUT 278
#define CaseOVER 279
#define CaseP 280
#define CaseS 281
#define CaseSA 282
#define CaseSAID 283
#define CaseSEE 284
#define CaseSHE 285
#define CaseSIDE 286
#define CaseSO 287
#define CaseSOME 288 
#define CaseSOUND 289
#define CaseT 290
#define CaseTH 291
#define CaseTHA 292
#define CaseTHAN 293
#define CaseTHAT 294
#define CaseTHE 295
#define CaseTHEIR 296
#define CaseTHEN 297
#define CaseTHEM 298
#define CaseTHERE 299
#define CaseTHESE 300
#define CaseTHEY 301
#define CaseTHI 302
#define CaseTHING 303
#define CaseTHIS 304
#define CaseTI 305
#define CaseTIME 306
#define CaseTO 307
#define CaseTWO 308
#define CaseU 309
#define CaseUP 310
#define CaseUSE 311
#define CaseW 312
#define CaseWA 313
#define CaseWAS 314
#define CaseWATER 315
#define CaseWAY 316
#define CaseWE 317
#define CaseWERE 318
#define CaseWH 319
#define CaseWHAT 320
#define CaseWHEN 321
#define CaseWHICH 322
#define CaseWHO 323
#define CaseWI 324
#define CaseWILL 325
#define CaseWITH 326
#define CaseWO 327
#define CaseWORD 328
#define CaseWOULD 329
#define CaseWRITE 330
#define CaseY 331
#define CaseYO 332
#define CaseYOU 333
#define CaseYOUR 334

#define CaseHELLO 335
#define CaseBRUCE 336
#define CaseLAND 337
#define CaseWELCOME 338
#define CaseECE 339
#define CaseEACH 340

#define Done 350

//length of text buffer to be printed to Hyperterm
#define MAX_BUFFER 16 

//Speech define
#define size 528

void gets_int(void);        //starts getting a string from serial line
void puts_int(void);        //starts a send to serial line
void initialize(void);      //initialize timers and variable
void detect_blip(void);     //state machine to process signal and decipher between different components of Morse Code
void send_to_buffer(void);  //encodes received characters from RX ISR to strings of 0s and 1s and stores into @buffer
void debounce(void);		    //debounce buttons
void MorseChar(void);   	  //Morse Tree
void SpeechWord(void);      //Word waveform Selection FSM

flash char smpl20K[27] = {0, 30, 58, 82, 103, 117, 125, 127,
   121, 108, 90, 66, 39, 10, -20, -49, -75, -97, -113, -123,
  -127, -123, -113, -97, -75, -49, -20};   
  
//speech variables
unsigned char speech_ready;
//reconstruction differentials 
flash char PCMvalue[4] = {-78, -16, 16, 78};

unsigned int outI, tableI;      	//indexes
char cycle;  			//decode phase counter
char out, lastout;		//output values
char p1, p2, p3, p4;	//hold 4 differentials
char packed;			//byte containing 4 2-bit values	
unsigned char SpeechState;

char word[528];
unsigned int j, page;
//end speech variables

//output variables                    
unsigned char amp, count, time, timer1;
bit entry, rampdown, beeping;

unsigned char numspaces; 
unsigned char buffer[50][25];     //buffer to store bit-wise morse code
unsigned char buffer_length[50];  //buffer to store lengths of each morse code string
                       
unsigned char out_index, out_ptr;
unsigned char temp, note; 

int outdot, outword, outlong, outshort, timeout;  
//end output variables

//sampling variables
unsigned char MorseState, Let; //Morse Variables

unsigned char Ain, prevAin;
unsigned char blipstate, space, blip;                                   
unsigned char timer30, PushState, PushFlag, butpress, lastpress;
unsigned char smplcount;
bit blipready, l_ready, s_ready;                                        
int blipcount, spacecount;

int countdash, countdot, counttimeout, countword, countlong, countshort;

unsigned char w_index;  //write index
unsigned char i;
//end sampling variables

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

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



//**************SPEECH INTERRUPT*************
//This interrrupt uses timer0 on Overflow to decompress the waveform
//for each word and then outputs it to the PWM on PORTB.3
interrupt [TIM0_OVF] void voicegen(void)
begin
   	//compute next sample
	cycle = outI%4;
	if (cycle==0)      //do we need to unpack more data?
	begin
        	if (tableI<size)  //end of stored wave?
        	begin
        		//unpack a table entry
        		packed = word[tableI];
        	    p1 = (packed & 192)>>6;
           		p2 = (packed & 48)>>4;
        	    p3 = (packed & 12)>>2;
        	    p4 = (packed & 3); 
        	    tableI++ ; 
        	end //end unpack table entry 
 		//compute the output and send to PWM
     	out = lastout + PCMvalue[p1] - lastout>>4 ;
     	OCR0 = out;
     	lastout = out;
     	outI++;
 	end
 	else if (cycle==1)    //don't need to unpack yet--just ouput
 	begin
 		out = lastout + PCMvalue[p2] - lastout>>4 ;
     	OCR0 = out;
     	lastout = out;
     	outI++;
   end
  	else if (cycle==2)
  	begin
  		out = lastout + PCMvalue[p3] - lastout>>4 ;
     	OCR0 = out;
     	lastout = out;
     	outI++;  
    end
  	else if (cycle==3) 
  	begin
  		out = lastout + PCMvalue[p4] - lastout>>4 ;
     	OCR0 = out;
     	lastout = out;
     	outI++;
	end //next sample
	
	//at end, turn off TCCRO
	if (tableI==size) TCCR0 = 0b00001010;
end 

//**********************************************************
interrupt [TIM2_COMP] void timer2_compare(void)
begin 
  if (beeping)  //output sine wave for audio
	begin
	  temp = 128 + (smpl20K[note] >> amp);
	  PORTC = temp;
	  if (note++ == 27) note = 0; //when end of array is reached, reset index to 0
	end           //if not outputting sine wave output halfway value btwn 0 and 255 (to be AC coupled)
	else PORTC = 128;
	if (smplcount > 0) smplcount--;
	if (smplcount == 0) //run every 500us
	begin
		smplcount = COUNT10;
		//get the sample
 		Ain = (ADCH > 125) ? 1 : 0;
 		//start another conversion
 		ADCSR.6=1;
 		blipready = 1;
	end
	if (count > 0) count--;
	if (count == 0)   //run every 1ms
	begin
		count = COUNT20;
		if (timer1 > 0) timer1--;
		if (timer30 > 0) timer30--;         
	end                       
end 

//**********************************************************
//UART character-ready ISR
interrupt [USART_RXC] void uart_rec(void)
begin
	r_char=UDR;    //get a char
	//UDR=r_char;    //then print it
	r_ready = 1;
end

/**********************************************************/
//UART xmit-empty ISR
interrupt [USART_DRE] void uart_send(void)
begin
	t_char = t_buffer[++t_index];
	if (t_char == 0)
	begin
		UCSRB.5=0; //kill isr
		t_ready=1; //transmit done
		w_index = 0;  //reset write index of t_buffer
	end
	else	UDR = t_char ;     //send the char
end

//**********************************************************
//Entry point and task scheduler loop
void main(void)
begin
  initialize();
  //main task scheduler loop -- never exits!
  while(1)
  begin
  	if (blipready) 
  	begin
  	    detect_blip();
  	end
    if (l_ready)  //dot or dash encountered and ready to be processed
    begin
        l_ready = 0;
        MorseChar();
    end
    if (s_ready)  //space encountered
    begin
        s_ready = 0;
        if (space == shortspace); //do nothing
        else if (space == longspace) 
        begin                       
          t_buffer[w_index] = Let;
          w_index++;             
          SpeechWord();
          Let = ' ';
          MorseState = Start;  
        end
        else //word
        begin                 
          t_buffer[w_index] = Let;
          w_index++;
          t_buffer[w_index] = ' ';
          w_index++;
          for (i = w_index; i < MAX_BUFFER; i++) t_buffer[i] = 0; //zero rest of t_buffer
          puts_int();    
          SpeechWord();          
          Let = ' ';
          MorseState = Start;

          //read/store word in array corresponding to the page from SpeechWord()
          
          GetPageToBufferDF(page, 0);
          delay_us(75);
          GetPageToBufferDF(page+1, 1);
          delay_us(75);               
            
          for (j = 0; j < 528; j++)
          begin
            if (j < 264)
            begin
                word[j]=ReadBufferDF(j, 0);
            end
            else 
            begin      
                word[j]=ReadBufferDF(j-264, 1);
            end
           
          end
          
          //reset speak state
          SpeechState = Begin; 
          //reset page
          page = 200;
          //set up PWM
          TCNT0 = 0;
          OCR0 = 128; 
          TCCR0 = 0b01101010 ; 
                   	
          //init the output indexes
          outI = 0; 
          tableI = 0; 
          //init the ouptut value
          lastout = 128; 
          speech_ready = 1;   
        end   
    end
    if (r_ready)  //character received from ISR
    begin              
      r_ready = 0;
      if (r_index == 50)
      begin
        r_index = 0;
      end  
      send_to_buffer();  
      r_index++;
    end
    if (timer1 == 0)
    begin                
      timer1 = time1;
      if (timeout > 0) timeout--;  
      else if ((entry == 1) && ((numspaces > 0))) //run first time before ramping up and numspaces > 0
      begin
        if (buffer[out_index][out_ptr] == '0')  //this row is all zeros = medium gap 
        begin
          if (++out_index == 50) 
          begin
            out_index = 0;
          end
          timeout = outword;
          beeping = 0;
          numspaces--;  //word finished - decrement numspaces
        end
        else
        begin 
          entry = 0;       
          beeping = 1;             
          if (buffer[out_index][++out_ptr] == '0') rampdown = 1;
          else rampdown = 0;
          amp = 4; 
          time++;
        end
      end
      else if ((numspaces > 0)) //run as long as numspaces > 0
      begin
        time++;       
        //ramp up signal
        if (time == 1) amp = 3;
        if (time == 2) amp = 2;
        if (time == 3) amp = 1;
        if (time == 4) amp = 0; 
        if (rampdown) //ramp down signal
        begin 
          if (time == outdot + 2) amp = 1;
          if (time == outdot + 3) amp = 2;
          if (time == outdot + 4) amp = 3;
          if (time == outdot + 5)
          begin
            entry = 1;
            time = 0;
            timeout = outshort; 
            if (++out_ptr == buffer_length[out_index])
            begin
              if (++out_index == 50) 
              begin
                out_index = 0;
              end
              timeout = outlong;
              out_ptr = 0;
            end              
            beeping = 0;
          end   
        end
        else  //if dash, then don't ramp down yet
        begin
          if (time == outdot + 2)
          begin
            time = 5;     //skip
            entry = 0;    //ramp up
            timeout = 5;  //stage
            if (buffer[out_index][++out_ptr] == '0') rampdown = 1;  //detect if ramp down on next cycle
            else rampdown = 0;
          end
        end  
      end
      else
      begin
        entry = 1;
        time = 0;         
        beeping = 0;
      end
    end
    if (speech_ready)
    begin
        if (TCCR0 > 0);
        else
        begin                
            speech_ready = 0;
            TCCR0 = 0b01101010 ;
        end  
    end  
    if (timer30 == 0)
    begin
    	timer30 = COUNT30MS;
    	debounce();
    end
  end
end

//**********************************************************
//Convert character received (r_char) from RX ISR into strings of 0's and 1's and store into @buffer
//Store length of string into @buffer_length
//Increment @numspaces if r_char is space or return (to enable output)
//10 = dot + intercharacter gap
//1110 = dash + intercharacter gap
//00000 = medium gap
void send_to_buffer(void)
begin
  switch (r_char)
  begin      
    case 'a': case 'A': sprintf(buffer[r_index], "101110"); buffer_length[r_index] = 6; break;
    case 'b': case 'B': sprintf(buffer[r_index], "1110101010"); buffer_length[r_index] = 10; break;
    case 'c': case 'C': sprintf(buffer[r_index], "111010111010"); buffer_length[r_index] = 12; break;
    case 'd': case 'D': sprintf(buffer[r_index], "11101010"); buffer_length[r_index] = 8; break;
    case 'e': case 'E': sprintf(buffer[r_index], "10"); buffer_length[r_index] = 2; break;
    case 'f': case 'F': sprintf(buffer[r_index], "1010111010"); buffer_length[r_index] = 10; break;
    case 'g': case 'G': sprintf(buffer[r_index], "1110111010"); buffer_length[r_index] = 10; break;
    case 'h': case 'H': sprintf(buffer[r_index], "10101010"); buffer_length[r_index] = 8; break;
    case 'i': case 'I': sprintf(buffer[r_index], "1010"); buffer_length[r_index] = 4; break;
    case 'j': case 'J': sprintf(buffer[r_index], "10111011101110"); buffer_length[r_index] = 14; break;
    case 'k': case 'K': sprintf(buffer[r_index], "1110101110"); buffer_length[r_index] = 10; break;
    case 'l': case 'L': sprintf(buffer[r_index], "1011101010"); buffer_length[r_index] = 10; break;
    case 'm': case 'M': sprintf(buffer[r_index], "11101110"); buffer_length[r_index] = 8; break;
    case 'n': case 'N': sprintf(buffer[r_index], "111010"); buffer_length[r_index] = 6; break;
    case 'o': case 'O': sprintf(buffer[r_index], "111011101110"); buffer_length[r_index] = 12; break;
    case 'p': case 'P': sprintf(buffer[r_index], "101110111010"); buffer_length[r_index] = 12; break;
    case 'q': case 'Q': sprintf(buffer[r_index], "11101110101110"); buffer_length[r_index] = 14; break;
    case 'r': case 'R': sprintf(buffer[r_index], "10111010"); buffer_length[r_index] = 8; break;
    case 's': case 'S': sprintf(buffer[r_index], "101010"); buffer_length[r_index] = 6; break;
    case 't': case 'T': sprintf(buffer[r_index], "1110"); buffer_length[r_index] = 4; break;
    case 'u': case 'U': sprintf(buffer[r_index], "10101110"); buffer_length[r_index] = 8; break;
    case 'v': case 'V': sprintf(buffer[r_index], "1010101110"); buffer_length[r_index] = 10; break;
    case 'w': case 'W': sprintf(buffer[r_index], "1011101110"); buffer_length[r_index] = 10; break;
    case 'x': case 'X': sprintf(buffer[r_index], "111010101110"); buffer_length[r_index] = 12; break;
    case 'y': case 'Y': sprintf(buffer[r_index], "11101011101110"); buffer_length[r_index] = 14; break;
    case 'z': case 'Z': sprintf(buffer[r_index], "111011101010"); buffer_length[r_index] = 12; break;
    case '0': sprintf(buffer[r_index], "11101110111011101110"); buffer_length[r_index] = 20; break;
    case '1': sprintf(buffer[r_index], "101110111011101110"); buffer_length[r_index] = 18; break;
    case '2': sprintf(buffer[r_index], "1010111011101110"); buffer_length[r_index] = 16; break;
    case '3': sprintf(buffer[r_index], "10101011101110"); buffer_length[r_index] = 14; break;
    case '4': sprintf(buffer[r_index], "101010101110"); buffer_length[r_index] = 12; break;
    case '5': sprintf(buffer[r_index], "1010101010"); buffer_length[r_index] = 10; break;
    case '6': sprintf(buffer[r_index], "111010101010"); buffer_length[r_index] = 12; break;
    case '7': sprintf(buffer[r_index], "11101110101010"); buffer_length[r_index] = 14; break;
    case '8': sprintf(buffer[r_index], "1110111011101010"); buffer_length[r_index] = 16; break;
    case '9': sprintf(buffer[r_index], "111011101110111010"); buffer_length[r_index] = 18; break;
    case '+': sprintf(buffer[r_index], "10111010111010"); buffer_length[r_index] = 14; break;
    case '.': sprintf(buffer[r_index], "101110101110101110"); buffer_length[r_index] = 18; break;
    case ',': sprintf(buffer[r_index], "11101110101011101110"); buffer_length[r_index] = 20; break;
    case ':': sprintf(buffer[r_index], "111011101110101010"); buffer_length[r_index] = 18; break;
    case '(': case ')': sprintf(buffer[r_index], "11101011101110101110"); buffer_length[r_index] = 20; break;
    case '-': sprintf(buffer[r_index], "1110101010101110"); buffer_length[r_index] = 16; break;
    case '/': sprintf(buffer[r_index], "11101010111010"); buffer_length[r_index] = 14; break;
    case '=': sprintf(buffer[r_index], "11101010101110"); buffer_length[r_index] = 14; break;
    case '?': sprintf(buffer[r_index], "1010111011101010"); buffer_length[r_index] = 16; break;
    case '_': sprintf(buffer[r_index], "101011101110101110"); buffer_length[r_index] = 18; break;
    case 34: sprintf(buffer[r_index], "1011101010111010"); buffer_length[r_index] = 16; break;
    case 39: sprintf(buffer[r_index], "10111011101110111010"); buffer_length[r_index] = 20; break;
    case '@': sprintf(buffer[r_index], "101110111010111010"); buffer_length[r_index] = 18; break;
    case ';': sprintf(buffer[r_index], "111010111010111010"); buffer_length[r_index] = 18; break;
    case '!': sprintf(buffer[r_index], "11101011101011101110"); buffer_length[r_index] = 20; break;
    case ' ': sprintf(buffer[r_index], "0"); buffer_length[r_index] = 5; numspaces++; break;    //increment numspaces to enable output    
    case '\r': sprintf(buffer[r_index], "0"); buffer_length[r_index] = 5; numspaces++; break;   //increment numspaces to enable output    
    default: r_index--; break;
  end 
end

//**********************************************************
//Debounce buttons hooked up to PORTA[1..7]
//Adapted from Professor Bruce Land's debounce code for single button
//http://instruct1.cit.cornell.edu/courses/ee476/PgmOrg/debounce.c
void debounce(void)
begin
  butpress = (~PINA) >> 1;
  switch (PushState)
  begin
     case NoPush: 
        if (butpress != 0x00) 
        begin
        	PushState=MaybePush;
        	lastpress = butpress;
        end
        else PushState=NoPush;
        break;
     case MaybePush:
        if (butpress == lastpress) 
        begin
          PushState=Pushed;
          if (butpress == 0x01)	//10 WPM
          begin
            putsf("\n\rSTATUS: 10 WPM\n\r");
       			countdot = WPM10DOT;
       			countdash = WPM10DASH;
       			countshort = WPM10SHORT;
       			countlong = WPM10LONG;
       			countword = WPM10WORD;
       			counttimeout = WPM10TIMEOUT;
       			outdot = OUT_WPM10DOT;
       			outshort = OUT_WPM10SHORT;
       			outlong = OUT_WPM10LONG;
       			outword = OUT_WPM10WORD;
          end
          else if (butpress == 0x02)	//15 WPM
          begin
            putsf("\n\rSTATUS: 15 WPM\n\r");
       			countdot = WPM15DOT;
       			countdash = WPM15DASH;
       			countshort = WPM15SHORT;
       			countlong = WPM15LONG;
       			countword = WPM15WORD;
       			counttimeout = WPM15TIMEOUT;	
       			outdot = OUT_WPM15DOT;
       			outshort = OUT_WPM15SHORT;
       			outlong = OUT_WPM15LONG;
       			outword = OUT_WPM15WORD;
          end
          else if (butpress == 0x04)	//20 WPM
          begin
            putsf("\n\rSTATUS: 20 WPM\n\r");
       			countdot = WPM20DOT;
       			countdash = WPM20DASH;
       			countshort = WPM20SHORT;
       			countlong = WPM20LONG;
       			countword = WPM20WORD;
       			counttimeout = WPM20TIMEOUT;
       			outdot = OUT_WPM20DOT;
       			outshort = OUT_WPM20SHORT;
       			outlong = OUT_WPM20LONG;
       			outword = OUT_WPM20WORD;
          end
          else if (butpress == 0x08)	//25 WPM
          begin              
            putsf("\n\rSTATUS: 25 WPM\n\r");
            countdot = WPM25DOT;
            countdash = WPM25DASH;
            countshort = WPM25SHORT;
            countlong = WPM25LONG;
            countword = WPM25WORD;
            counttimeout = WPM25TIMEOUT;
            outdot = OUT_WPM25DOT;
            outshort = OUT_WPM25SHORT;
            outlong = OUT_WPM25LONG;
            outword = OUT_WPM25WORD;
          end
          else if (butpress == 0x10)	//30 WPM
          begin
            putsf("\n\rSTATUS: 30 WPM\n\r");
       			countdot = WPM30DOT;
       			countdash = WPM30DASH;
       			countshort = WPM30SHORT;
       			countlong = WPM30LONG;
       			countword = WPM30WORD;
       			counttimeout = WPM30TIMEOUT;
       			outdot = OUT_WPM30DOT;
       			outshort = OUT_WPM30SHORT;
       			outlong = OUT_WPM30LONG;
       			outword = OUT_WPM30WORD;
          end
          else if (butpress == 0x20)	//35 WPM
          begin                     
            putsf("\n\rSTATUS: 35 WPM\n\r");
       			countdot = WPM35DOT;
       			countdash = WPM35DASH;
       			countshort = WPM35SHORT;
       			countlong = WPM35LONG;
       			countword = WPM35WORD;
       			counttimeout = WPM35TIMEOUT;
       			outdot = OUT_WPM35DOT;
       			outshort = OUT_WPM35SHORT;
       			outlong = OUT_WPM35LONG;
       			outword = OUT_WPM35WORD;
          end
          else if (butpress == 0x40)	//40 WPM
          begin                       
            putsf("\n\rSTATUS: 40 WPM\n\r");
       			countdot = WPM40DOT;
       			countdash = WPM40DASH;
       			countshort = WPM40SHORT;
       			countlong = WPM40LONG;
       			countword = WPM40WORD;
       			counttimeout = WPM40TIMEOUT;
       			outdot = OUT_WPM40DOT;
       			outshort = OUT_WPM40SHORT;
       			outlong = OUT_WPM40LONG;
       			outword = OUT_WPM40WORD;
          end
          else;
          PushFlag=1;
        end
        else PushState=NoPush;
        break;
     case Pushed:  
        if (butpress == lastpress) PushState=Pushed; 
        else PushState=MaybeNoPush;    
        break;
     case MaybeNoPush:
        if (butpress == lastpress) PushState=Pushed; 
        else 
        begin
           butpress = 0x00;
           lastpress = 0x00;
           PushState=NoPush;
           PushFlag=0;
        end    
        break;
  end
end

//**********************************************************
//Processes values from ADC
//Determines whether incoming signal is a dot, dash, intercharacter gap, short gap or medium gap
//Counts falling edges and matches them to defined threshold values for dots and dashes
//Counts number of consecutive cycles without rising or falling edges and matches them to threshold values for spaces
void detect_blip(void)
begin
	blipready = 0;
	switch (blipstate)
    begin
    	case noblip:
            if (Ain >= prevAin) //rising edge or no change
            begin
            	spacecount++;
            	blipstate = yesspace;
            end
            else blipcount++;   //falling edge
    		break;
        case yesspace:
        	if (Ain >= prevAin) //rising edge or no change
            begin
                spacecount++;
                if ((blipcount > 0) && (spacecount > 10))
                begin                                     
                    if (blipcount > countdash)
                    begin           
                        l_ready = 1;
                        blip = dash;
                    end
                    else if (blipcount > countdot)
                    begin
                        l_ready = 1;
                        blip = dot;
                       end
                    else l_ready = 0;
                    blipcount = 0;
                end
                if (spacecount > counttimeout)  //timed out = end of transmission
                begin                  
                	s_ready = 1;
                    space = wordspace;
                    spacecount = 0;
                	blipstate = done;
                end
            end
            else  //falling edge
            begin
            	if (spacecount > countshort)
                begin
                	s_ready = 1;
                    if (spacecount > countword) space = wordspace;  //medium space
                    else if (spacecount > countlong) space = longspace; //short space
                    else space = shortspace;  //intercharacter gap
                end
            	spacecount = 0;
            	blipcount++;
            	blipstate = noblip;
            end
        	break;
		case done:
        	if (Ain == 0) //audio detected
        	begin                 
        	    blipcount++;      
        	    blipstate = noblip;
        	end
            break;
        default: break;
    end                
    prevAin = Ain;
end

//**********************************************************
//Traverse Morse Code tree in MorseTree.png depending on whether
//sound is dot or dash or space
void MorseChar(void)
begin

  switch(MorseState)
  begin
    case Start: 
      if (blip==dot)
      begin
       Let = 'E';
       MorseState = E_Tree;
      end
      else
      begin
       Let = 'T';
       MorseState = T_Tree;
      end
      break;

    case E_Tree:
      if (blip==dot)
      begin
       Let = 'I';
       MorseState = I_Tree;
      end
      else
      begin
       Let = 'A';
       MorseState = A_Tree; 
      end
      break;

    case T_Tree:
      if (blip==dot)
      begin
       Let = 'N';
       MorseState = N_Tree;
      end
      else
      begin
       Let = 'M';
       MorseState = M_Tree;
      end
      break;

    case I_Tree:
      if (blip==dot)
      begin
       Let = 'S';
       MorseState = S_Tree;
      end
      else
      begin
       Let = 'U';
       MorseState = U_Tree;
      end
      break;

    case A_Tree:
      if (blip==dot)
      begin
       Let = 'R';
       MorseState = R_Tree;
      end
      else
      begin
       Let = 'W'; 
       MorseState = W_Tree;
      end
      break;

    case N_Tree:
      if (blip==dot)
      begin
       Let = 'D';
       MorseState = D_Tree;
      end
      else
      begin
       Let = 'K';
       MorseState = K_Tree;
      end
      break;

    case M_Tree:
      if (blip==dot)
      begin
       Let = 'G';
       MorseState = G_Tree;
      end
      else
      begin
       Let = 'O';
       MorseState = O_Tree;
      end
      break;

    case S_Tree:
      if (blip==dot)
      begin
       Let = 'H';
       MorseState = H_Tree;
      end
      else
      begin
       Let = 'V';
       MorseState = V_Tree;
      end
      break;

    case U_Tree:
      if (blip==dot)
      begin
       Let = 'F';
       MorseState = F_Tree;
      end
      else
      begin
       Let = ' ';
       MorseState = UGer_Tree;
      end
      break;

    case R_Tree:
      if (blip==dot)
      begin
       Let = 'L';
       MorseState = L_Tree;
      end
      else
      begin
       Let = (char) 196;
       MorseState = AGer_Tree;
      end
      break;

    case W_Tree:
      if (blip==dot)
      begin
       Let = 'P';
       MorseState = P_Tree;
      end
      else
      begin
       Let = 'J';
       MorseState = J_Tree;
      end
      break;

    case D_Tree:
      if (blip==dot)
      begin
       Let = 'B';
       MorseState = B_Tree;
      end
      else
      begin
       Let = 'X';
       MorseState = X_Tree;
      end
      break;

    case K_Tree:
      if (blip==dot)      
      begin
       Let = 'C';
       MorseState = C_Tree;
      end
      else
      begin
       Let = 'Y';
       MorseState = Y_Tree;
      end
      break;

    case G_Tree:
      if (blip==dot)
      begin
       Let = 'Z';
       MorseState = Z_Tree;
      end
      else
      begin
       Let = 'Q';
       MorseState = Q_Tree;
      end
      break;

    case O_Tree:
      if (blip==dot)
      begin
       Let = (char) 214;
       MorseState = OGer_Tree;
      end
      else
      begin
       Let = ' ';
       MorseState = CH_Tree;
      end
      break;

    case H_Tree:
      if (blip==dot)
       begin
        Let = '5';
        MorseState = Finished;
       end
     else
      begin
       Let = '4';
       MorseState = Finished;
      end
     break;

    case V_Tree:
      if (blip==dot)
      begin
         Let = ' ';
         MorseState = Finished;
      end
      else
      begin
         Let = '3';
         MorseState = Finished;
      end
      break;

    case F_Tree:
      if (blip==dot)
      begin
         Let = (char) 201;
         MorseState = Finished;
      end
      break;

    case UGer_Tree:
      if (blip==dot)
      begin
       Let = (char) 208;
       MorseState = DGer_Tree;
      end
      else
      begin
         Let = '2';
         MorseState = Finished;
      end
      break;

    case L_Tree:
      if (blip==dash)
      begin
       Let = (char) 200;
       MorseState = Eaccl_Tree;
      end
      break;

    case AGer_Tree:
      if (blip==dot)
      begin
       Let = '+';
       MorseState = Plus_Tree;
      end
      break;

    case P_Tree:
      if (blip==dot)
      begin
         Let = (char) 222;
         MorseState = Finished;
      end
      else
      begin
         Let = (char) 192;
         MorseState = Aacc_Tree;
      end
      break;

    case J_Tree:
      if (blip==dot)
      begin
         Let = ' ';
         MorseState = Finished;
      end
      else
      begin
       Let = '1';
       MorseState = One_Tree;
      end
      break;

    case B_Tree:
      if (blip==dot)
      begin
       Let = '6';
       MorseState = Six_Tree;
      end
      else
      begin
       Let = '=';
       MorseState = Finished;
      end
      break;

    case X_Tree:
      if (blip==dot)
      begin
         Let = '/';
         MorseState = Finished;
      end
      break;

    case C_Tree:
      if (blip==dot)
      begin
         Let = (char) 199;
         MorseState = Finished;
      end
      else
      begin
       Let = ' ';
       MorseState = Blank1_Tree;
      end
      break;

    case Y_Tree:
      if (blip==dot)
      begin
       Let = ' ';
       MorseState = HGer_Tree;
      end
      break;

    case Z_Tree:
      if (blip==dot)
      begin
         Let = '7';
         MorseState = Finished;
      end
      else
      begin
       Let = ' ';
       MorseState = Blank2_Tree;
      end
      break;

    case Q_Tree:
      if (blip==dot)
      begin
         Let = ' ';
         MorseState = Finished;
      end
      else
      begin
         Let = (char) 209;
         MorseState = Finished;
      end
      break;

   case OGer_Tree:
      if (blip==dot)
      begin
         Let = '8';
         MorseState = Eight_Tree;
      end
      break;

    case CH_Tree:
      if (blip==dot)
      begin
         Let = '9';
         MorseState = Finished;
      end
      else
      begin
         Let = '0';
         MorseState = Finished;
      end
      break;
 
    case DGer_Tree:
      if (blip==dot)
      begin
         Let = '?';
         MorseState = Finished;
      end
      else
      begin
        Let = '_';
        MorseState = Finished;
      end
      break;

    case Eaccl_Tree:
      if (blip==dot)
      begin
        Let = (char) 34;
        MorseState = Finished;
      end
      break;

    case Plus_Tree:
      if (blip==dash)
      begin
        Let = '.';
        MorseState = Finished;
      end
      break;

    case Aacc_Tree:
      if (blip==dot)
      begin
        Let = (char) 64;
        MorseState = Finished;
      end
      break;

    case One_Tree:
      if (blip==dot)
      begin
        Let = (char) 39;
        MorseState = Finished;
      end
      break;

    case Six_Tree:
      if (blip==dash)
      begin
        Let = '-';
        MorseState = Finished;
      end
      break;

    case Blank1_Tree:
      if (blip==dot)
      begin
        Let = ';';
        MorseState = Finished;
      end
      else
      begin 
       Let = '!';
       MorseState = Finished;
      end
      break;

    case HGer_Tree:
      if (blip==dash)
      begin
       Let = (char) 40;
       MorseState = Finished;
      end
      break;

    case Blank2_Tree:
      if (blip==dash)
      begin
       Let = ',';
       MorseState = Finished;
      end
      break;

    case Eight_Tree:
      if (blip==dot)
      begin
        Let = ':';
        MorseState = Finished;
      end
      break;
      
    case Finished:
      break;
      
    default:
      break;
  
  end
end


//**********************************************************
//This function contains a state machine similar to MorseChar().
//It compares inputted words to stored wav-files and if there is 
//a match, then sets the page (to read from Flash read). If the
//word is not recognizes then it outputs a beep (from QUIET.h)
void SpeechWord()
begin

  //unsigned char sound;

  switch(SpeechState)
  begin
  
    case Begin:
      if (Let=='A') 
      begin
        page = 0;
        SpeechState=CaseA;
      end
      else if (Let=='B') 
      begin
        SpeechState=CaseB;
      end
      else if (Let=='C') SpeechState=CaseC;
      else if (Let=='D') SpeechState=CaseD;
      else if (Let=='E') SpeechState=CaseE;
      else if (Let=='F') SpeechState=CaseF;
      else if (Let=='G')
      begin
        page=50;
        SpeechState=CaseG;
      end
      else if (Let=='H') SpeechState=CaseH;
      else if (Let=='I')
      begin
         page = 70;
         SpeechState=CaseI;
      end
      else if (Let=='K')
      begin
        page=80;
        SpeechState=CaseK;
      end
      else if (Let=='L') SpeechState=CaseL;
      else if (Let=='M') SpeechState=CaseM;
      else if (Let=='N') SpeechState=CaseN;
      else if (Let=='O') SpeechState=CaseO;
      else if (Let=='P')
      begin
        page=120;
        SpeechState=CaseP;
      end
      else if (Let=='S') SpeechState=CaseS;
      else if (Let=='T') SpeechState=CaseT;
      else if (Let=='U') SpeechState=CaseU;
      else if (Let=='W') SpeechState=CaseW;
      else if (Let=='Y') SpeechState=CaseY;
      break;
   
   case CaseA:
      if (Let=='B')
      begin
          page = 2;
          SpeechState=CaseABOUT;
      end
      else if (Let=='L')
      begin
          page = 4;
          SpeechState=CaseALL;
      end
      else if (Let=='N')
      begin
          page = 6;
          SpeechState=CaseAN;
      end
      else if (Let=='R')
      begin
          page = 10;
          SpeechState=CaseARE;
      end
      else if (Let=='S')
      begin
          page = 12;
          SpeechState=CaseAS;
      end
      else if (Let=='T')
      begin
          page = 14;
          SpeechState=CaseAT;
      end
      break;
      
   case CaseABOUT:
      SpeechState=Done;
      break;
      
   case CaseALL:
      SpeechState=Done;
      break;
   
    case CaseAN:
      if (Let=='D')
      begin
          page = 8;
          SpeechState=CaseAND;
      end
      else SpeechState=Done;
      break;
  
   case CaseAND:
      SpeechState=Done;
      break;
   
   case CaseARE:
      SpeechState=Done;
      break;
   
   case CaseAS:
      SpeechState=Done;
      break;

   case CaseAT:
      SpeechState=Done;
      break;
  
   case CaseB:
      if (Let=='E')
      begin
        page=16;
        SpeechState=CaseBE;
      end
      else if (Let=='R')
      begin
        page=204;
        SpeechState=CaseBRUCE;
      end
      else if (Let=='U')
      begin
        page=20;
        SpeechState=CaseBUT;
      end
      else if (Let=='Y')
      begin
        page=22;
        SpeechState=CaseBY;
      end
      break;
   
   case CaseBE:
      if (Let=='E')
      begin
        page = 18;
        SpeechState = CaseBEEN;
      end
      else SpeechState = Done;
      break;

   case CaseBEEN:
      SpeechState=Done;

   case CaseBRUCE:
      SpeechState=Done;
      break;

   case CaseBUT:
      SpeechState=Done;
      break;

   case CaseBY:
      SpeechState=Done;
      break;

   case CaseC:
      if (Let=='A') SpeechState=CaseCA;
      else if (Let=='O') SpeechState=CaseCO;
      break;

   case CaseCA:
      if (Let=='L')
      begin
        page=24;
        SpeechState=CaseCALL;
      end
      else if (Let=='N')
      begin
        page=26;
        SpeechState=CaseCAN;
      end
      break;

   case CaseCALL:
      SpeechState=Done;
   
   case CaseCAN:
      SpeechState=Done;
      break;

   case CaseCO:
      if (Let=='M')
      begin
        page=28;
        SpeechState=CaseCOME;
      end
      else if (Let=='U')
      begin
        page=30;
        SpeechState=CaseCOULD;
      end
      break;

   case CaseCOME:
      SpeechState=Done;

   case CaseCOULD:
      SpeechState=Done;
      break;
  
   case CaseD:
      if (Let=='A')
      begin
        page=32;
        SpeechState=CaseDAY;
      end
      else if (Let=='I')
      begin
        page=34;
        SpeechState=CaseDID;
      end
      else if (Let=='O')
      begin
        page=36;
        SpeechState=CaseDO;
      end
      break;

   case CaseDAY:
      SpeechState=Done;
      break;

   case CaseDID:
      SpeechState=Done;
      break;

   case CaseDO:
      if (Let=='W')
      begin
        page=38;
        SpeechState=CaseDOWN;
      end
      break;

   case CaseDOWN:
      SpeechState=Done;
      break;

   case CaseE:
      if (Let=='A')
      begin
        page=40;
        SpeechState=CaseEACH;
      end
      if (Let=='C')
      begin
        page=210;
        SpeechState=CaseECE;
      end

      SpeechState=Done;
      break;

   case CaseEACH:
      SpeechState=Done;
      break;

   case CaseECE:
      SpeechState=Done;
      break;

   case CaseF:
      if (Let=='I') SpeechState=CaseFI;
      else if (Let=='O')
      begin
        page=46;
        SpeechState=CaseFOR;
      end
      else if (Let=='R')
      begin
        page=48;
        SpeechState=CaseFROM;
      end
      break;

   case CaseFI:
      if (Let=='N')
      begin
        page=42;
        SpeechState=CaseFIND;
      end
      else if (Let=='R')
      begin
        page=44;
        SpeechState=CaseFIRST;
      end
      break;

   case CaseFIND:
      SpeechState=Done;
      break;

   case CaseFIRST:
      SpeechState=Done;
      break;

   case CaseFOR:
      SpeechState=Done;
      break;

   case CaseFROM:
      SpeechState=Done;
      break;

   case CaseG:
      SpeechState=Done;
      break;

   case CaseH:
      if (Let=='A') SpeechState=CaseHA;
      else if (Let=='E')
      begin
         page=58;
         SpeechState=CaseHE;
      end
      else if (Let=='I') SpeechState=CaseHI;
      else if (Let=='O') SpeechState=CaseHO;
      else SpeechState=Done;
      break;

   case CaseHA:
      if (Let=='D')
      begin
          page = 52;
          SpeechState=CaseHAD;
      end 
      else if (Let=='S')
      begin
          page = 54;
          SpeechState=CaseHAS;
      end
      else if (Let=='V')
      begin
          page = 56;
          SpeechState=CaseHAVE;
      end
      else SpeechState=Done;      
      break;

   case CaseHAD:
      SpeechState=Done;
      break;

   case CaseHAS:
      SpeechState=Done;
      break;

   case CaseHAVE:
      SpeechState=Done;
      break;

   case CaseHE:
      if (Let=='R')
      begin
          page = 60;
          SpeechState=CaseHER;
      end
      else if (Let=='L')
      begin
	  page = 202;
	  SpeechState=CaseHELLO;
      end    
      else SpeechState=Done;
      break;

   case CaseHER:
      SpeechState=Done;
      break;

   case CaseHELLO:
      SpeechState=Done;
      break;

   case CaseHI:
      if (Let=='M')
      begin
          page = 62;
          SpeechState=CaseHIM;
      end
      else if (Let=='S')
      begin
          page = 64;
          SpeechState=CaseHIS;
      end
      break;

   case CaseHIM:
      SpeechState=Done;
      break;

   case CaseHIS:
      SpeechState=Done;
      break;

   case CaseHO:
      if (Let=='T')
      begin
          page = 66;
          SpeechState=CaseHOT;
      end
      else if (Let=='W')
      begin
          page = 68;
          SpeechState=CaseHOW;
      end 
      break;

   case CaseHOT:
      SpeechState=Done;
      break;

   case CaseHOW:
      SpeechState=Done;
      break;

   case CaseI:
      if (Let=='F')
      begin 
         page=72;
         SpeechState=CaseIF;
      end
      else if (Let=='N') 
      begin 
         page=74;
         SpeechState=CaseIN;
      end
      else if (Let=='S')
      begin 
         page=76;
         SpeechState=CaseIS;
      end
      else if (Let=='T')
      begin 
         page=78;
         SpeechState=CaseIT;
      end
      else SpeechState = Done;

      break;

   case CaseIF:
      SpeechState=Done;
      break;

   case CaseIN:
      SpeechState=Done;
      break;
      
   case CaseIS:
      SpeechState=Done;
      break;

   case CaseIT:
      SpeechState=Done;
      break;
      
   case CaseK:
      SpeechState=Done;
      break;

   case CaseL:
      if (Let=='A')
      begin
        page=206;
        SpeechState=CaseLAND;
      end
      else if (Let=='I')
      begin
        page=82;
        SpeechState=CaseLIKE;
      end
      else if (Let=='O') SpeechState=CaseLO;
      break;
            
   case CaseLAND:
      SpeechState=Done;
      break;

   case CaseLIKE:
      SpeechState=Done;
      break;

   case CaseLO:
      if (Let=='N')
      begin
        page=84;
        SpeechState=CaseLONG;
      end
      else if (Let=='O')
      begin
        page=86;
        SpeechState=CaseLOOK;
      end
      break;

   case CaseLONG:
      SpeechState=Done;
      break;

   case CaseLOOK:
      SpeechState=Done;
      break;

   case CaseM:
      if (Let=='A') SpeechState=CaseMA;
      else if (Let=='O') SpeechState=CaseMO;
      else if (Let=='Y')
      begin
        page=98;
        SpeechState=CaseMY;
      end
      break;

   case CaseMA:
      if (Let=='K')
      begin
        page=88;
        SpeechState=CaseMAKE;
      end
      else if (Let=='N')
      begin
        page=90;
        SpeechState=CaseMANY;
      end
      else if (Let=='Y')
      begin
        page=92;
        SpeechState=CaseMAY;
      end
      break;

   case CaseMAKE:
      SpeechState=Done;
      break;

   case CaseMANY:
      SpeechState=Done;
      break;

   case CaseMAY:
      SpeechState=Done;
      break;

   case CaseMO:
      if (Let=='R')
      begin
        page=94;
        SpeechState=CaseMORE;
      end
      else if (Let=='S')
      begin
        page=96;
        SpeechState=CaseMOST;
      end
      break;

   case CaseMORE:
      SpeechState=Done;
      break;

   case CaseMOST:
      SpeechState=Done;
      break;

   case CaseMY:
      page = 98;  //My-wave from flash
      SpeechState=Done;
      break;

   case CaseN:
      if (Let=='O')
      begin
        page=100;
        SpeechState=CaseNO;
      end
      else if (Let=='U')
      begin
        page=104;
        SpeechState=CaseNUMBER;
      end
      break;

   case CaseNO:
      if (Let=='W')
      begin
        page=102;
        SpeechState=CaseNOW;
      end
      else SpeechState=Done;
      break;

   case CaseNOW:
      SpeechState=Done;
      break;

   case CaseNUMBER:
      SpeechState=Done;
      break;

   case CaseO:
      if (Let=='F')
      begin
        page=106;
        SpeechState=CaseOF;
      end
      else if (Let=='N')
      begin
        page=108;
        SpeechState=CaseON;
      end
      else if (Let=='R')
      begin
        page=112;
        SpeechState=CaseOR;
      end
      else if (Let=='T')
      begin
        page=114;
        SpeechState=CaseOTHER;
      end
      else if (Let=='U')
      begin
        page=116;
        SpeechState=CaseOUT;
      end
      else if (Let=='V')
      begin
        page=118;
        SpeechState=CaseOVER;
      end
      break;

   case CaseOF:
      page = 106;  //Of-wave from flash
      SpeechState=Done;
      break;

   case CaseON:
      if (Let=='E')
      begin
        page=110;
        SpeechState=CaseONE;
      end
      else SpeechState=Done;
      break;

   case CaseONE:
      SpeechState=Done;
      break;

   case CaseOR:
      SpeechState=Done;
      break;

   case CaseOTHER:
      SpeechState=Done;
      break;

   case CaseOUT:
      SpeechState=Done;
      break;

   case CaseOVER:
      SpeechState=Done;
      break;

   case CaseP:
      SpeechState=Done;
      break;

   case CaseS:
      if (Let=='A')
      begin
        page=122;
        SpeechState=CaseSAID;
      end
      else if (Let=='E')
      begin
        page=124;
        SpeechState=CaseSEE;
      end
      else if (Let=='H')
      begin
        page=126;
        SpeechState=CaseSHE;
      end
      else if (Let=='I')
      begin
        page=128;
        SpeechState=CaseSIDE;
      end
      else if (Let=='O')
      begin
        page=130;
        SpeechState=CaseSO;
      end
      break;

   case CaseSAID:
      SpeechState=Done;
      break;

   case CaseSEE:
      SpeechState=Done;
      break;

   case CaseSHE:
      SpeechState=Done;
      break;

   case CaseSIDE:
      SpeechState=Done;
      break;

   case CaseSO:
      if (Let=='M')
      begin
        page=132;
        SpeechState=CaseSOME;
      end
      else if (Let=='U')
      begin
        page=134;
        SpeechState=CaseSOUND;  
      end
      else SpeechState=Done;
      break;

   case CaseSOME:
      SpeechState=Done;
      break;

   case CaseSOUND:
      SpeechState=Done;
      break;

   case CaseT:
      if (Let=='H') SpeechState=CaseTH;
      else if (Let=='I')
      begin
        page=158;
        SpeechState=CaseTIME;
      end
      else if (Let=='O')
      begin
        page=160;
        SpeechState=CaseTO;
      end
      else if (Let=='W')
      begin
        page=162;
        SpeechState=CaseTWO;
      end
      break;

   case CaseTH:
      if (Let=='A') SpeechState=CaseTHA;
      else if (Let=='E')
      begin
        page=140;
        SpeechState=CaseTHE;
      end
      else if (Let=='I') SpeechState=CaseTHI;
      break;

   case CaseTHA:
      if (Let=='N')
      begin
        page=136;
        SpeechState=CaseTHAN;
      end
      else if (Let=='T')
      begin
        page=138;
        SpeechState=CaseTHAT;
      end
      break;

   case CaseTHAN:
      page = 136;  //Than-wave from flash
      SpeechState=Done;
      break;

   case CaseTHAT:
      page = 138;  //That-wave from flash
      SpeechState=Done;
      break;

   case CaseTHE:
      if (Let=='I')
      begin
        page=142;
        SpeechState=CaseTHEIR;
      end
      else if (Let=='M')
      begin
        page=144;
        SpeechState=CaseTHEM;
      end
      else if (Let=='N')
      begin
        page=146;
        SpeechState=CaseTHEN;
      end
      else if (Let=='R')
      begin
        page=148;
        SpeechState=CaseTHERE;
      end
      else if (Let=='S')
      begin
        page=150;
        SpeechState=CaseTHESE;
      end
      else if (Let=='Y')
      begin
        page=152;
        SpeechState=CaseTHEY;
      end
      else SpeechState=Done;
      break;

   case CaseTHEIR:
      SpeechState=Done;
      break;

   case CaseTHEM:
      SpeechState=Done;
      break;

   case CaseTHEN:
      SpeechState=Done;
      break;

   case CaseTHERE:
      SpeechState=Done;
      break;

   case CaseTHESE:
      SpeechState=Done;
      break;

   case CaseTHEY:
      SpeechState=Done;
      break;

   case CaseTHI:
      if (Let=='N')
      begin
        page=154;
        SpeechState=CaseTHING;
      end
      else if (Let=='S')
      begin
        page=156;
        SpeechState=CaseTHIS;
      end
      break;

   case CaseTHING:
      SpeechState=Done;
      break;

   case CaseTHIS:
      SpeechState=Done;
      break;

   case CaseTIME:
      SpeechState=Done;
      break;

   case CaseTO:
      SpeechState=Done;
      break;

   case CaseTWO:
      SpeechState=Done;
      break;

   case CaseU:
      if (Let=='P')
      begin
        page=164;
        SpeechState=CaseUP;
      end
      else if (Let=='S')
      begin
        page=166;
        SpeechState=CaseUSE;
      end
      break;

   case CaseUP:
      SpeechState=Done;
      break;

   case CaseUSE:
      SpeechState=Done;
      break;

   case CaseW:
      if (Let=='A') SpeechState=CaseWA;
      else if (Let=='E')
      begin
        page=174;
        SpeechState=CaseWE;
      end
      else if (Let=='H') SpeechState=CaseWH;
      else if (Let=='I') SpeechState=CaseWI;
      else if (Let=='O') SpeechState=CaseWO;
      else if (Let=='R')
      begin
        page=194;
        SpeechState=CaseWRITE;
      end
      break;

   case CaseWA:
      if (Let=='S')
      begin
        page=168;
        SpeechState=CaseWAS;
      end
      else if (Let=='T')
      begin
        page=170;
        SpeechState=CaseWATER;
      end
      else if (Let=='Y')
      begin
        page=172;
        SpeechState=CaseWAY;
      end
      break;

   case CaseWAS:
      SpeechState=Done;
      break;

   case CaseWATER:
      SpeechState=Done;
      break;

   case CaseWAY:
      SpeechState=Done;
      break;

   case CaseWE:
      if (Let=='R')
      begin
        page=176;
        SpeechState=CaseWERE;
      end
      else if (Let=='L')
      begin
        page=208;
        SpeechState=CaseWELCOME;
      end
      else SpeechState=Done;
      break;

   case CaseWERE:
      SpeechState=Done;
      break;

   case CaseWELCOME:
      SpeechState=Done;
      break;

   case CaseWH:
      if (Let=='A')
      begin
        page=178;
        SpeechState=CaseWHAT;
      end
      else if (Let=='E')
      begin
        page=180;
        SpeechState=CaseWHEN;
      end
      else if (Let=='I')
      begin
        page=182;
        SpeechState=CaseWHICH;
      end
      else if (Let=='O')
      begin
        page=184;
        SpeechState=CaseWHO;
      end
      break;

   case CaseWHAT:
      SpeechState=Done;
      break;

   case CaseWHEN:
      SpeechState=Done;
      break;

   case CaseWHICH:
      SpeechState=Done;
      break;

   case CaseWHO:
      SpeechState=Done;
      break;

   case CaseWI:
      if (Let=='L')
      begin
        page=186;
        SpeechState=CaseWILL;
      end
      else if (Let=='T')
      begin
        page=188;
        SpeechState=CaseWITH;
      end
      break;

   case CaseWILL:
      SpeechState=Done;
      break;

   case CaseWITH:
      SpeechState=Done;
      break;

   case CaseWO:
      if (Let=='R')
      begin
        page=190;
        SpeechState=CaseWORD;
      end
      else if (Let=='U')
      begin
        page=192;
        SpeechState=CaseWOULD;
      end
      break;

   case CaseWORD:
      SpeechState=Done;
      break;

   case CaseWOULD:
      SpeechState=Done;
      break;

   case CaseWRITE:
      SpeechState=Done;
      break;

   case CaseY:
      if (Let=='O') SpeechState=CaseYO;
      break;

   case CaseYO:
      if (Let=='U')
      begin
        page=196;
        SpeechState=CaseYOU;
      end
      break;

   case CaseYOU:
      if (Let=='R')
      begin
        page=198;
        SpeechState=CaseYOU;
      end
      else SpeechState=Done;
      break;

   case CaseYOUR:
      SpeechState=Done;
      break;

   case Done:
      break;
      
    default:
      break;
  
  end
end
     

//**********************************************************
//non-blocking keyboard check initializes ISR-driven
//receive. This routine merely sets up the ISR, which then
//does all the work of getting a command.
void gets_int(void)
begin
  r_ready=0;
  r_index=0;
  UCSRB.7=1;
end
          
//**********************************************************
//nonblocking print: initializes ISR-driven
//transmit. This routine merely sets up the ISR, then
//send one character, The ISR does all the work.
void puts_int(void)
begin
  t_ready=0;
  t_index=0;
  if (t_buffer[0]>0)
  begin
  	putchar(t_buffer[0]);
  	UCSRB.5=1;
 end
end

//**********************************************************
//Set it all up
void initialize(void)
begin
    
  //output
  DDRC = 0xff;
  
  //Speech setup pin3 on portb
  DDRB.3=1;
  DDRB.1=1;
  DFlashInit();
   
  //input
  DDRA = 0x00;
  
  //init the output indexes
  outI = 0; 
  tableI = 0; 
  //init the ouptut value
  lastout = 128; 
  
  //set timer0 (overflow) and timer2 (compare)
  TIMSK = 0x81 ;    
  TCCR2 = 0b00001010 ;
  TCNT0 = 0; 
  OCR0 = 128;
  TCCR0 = 0 ;   
  
  OCR2 = 99;            //20 kHz

  //serial setup to enable communication between MCU and PC
  UCSRB = 0x18 ;
  UBRRL = 103 ;
  putsf("\r\n\rStarting...\r\nSTATUS: 20 WPM\n\r");
                     
  count = COUNT20;                 
                 
  r_ready=0;
  t_ready=1;  
  
  r_index=0;
  out_index=0;
  out_ptr = 0; 
  
  timer1 = time1;
  
  entry = 1;    
  rampdown = 0;
  amp = 0;
  
  beeping = 1;
  note = 0; 
  temp = 0;              
  
  //init the A to D converter
  //channel zero/ left adj /EXTERNAL Aref
  //!!!CONNECT Aref jumper!!!!
  ADMUX = 0b00100000;
  //enable ADC and set prescaler to 1/8*16MHz=2,000,000
  //and clear interupt enable
  //and start a conversion
  ADCSR = 0b11000011;

  l_ready = 0;
  s_ready = 0;
  space = shortspace;
  blipcount = 0;
  blipstate = done;
  blipready = 0;
  w_index = 0;    
  spacecount = 0;
  
  speech_ready = 0;
                 
  countdot = WPM20DOT;
  countdash = WPM20DASH;
  countshort = WPM20SHORT;
  countlong = WPM20LONG;
  countword = WPM20WORD;
  counttimeout = WPM20TIMEOUT;
  outdot = OUT_WPM20DOT;
  outshort = OUT_WPM20SHORT;
  outlong = OUT_WPM20LONG;
  outword = OUT_WPM20WORD;  
  
  timer30 = COUNT30MS;        
  
  PushState = NoPush;
  PushFlag = 0;
  butpress = 0x00;
  lastpress = 0x00;
  
  MorseState = Start;
  Let = ' ';             
  
  SpeechState = Begin;
  page = 200; //initialize to silence  
  
  //crank up the ISRs
  #asm
  	sei
  #endasm

  gets_int();
end