// INTERRUPT-DRIVEN serial code 
// Fully interrupt driven, asynch UART communication  
// Mega644 version    
             
#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdio.h>

//set up the debugging utility ASSERT
#define __ASSERT_USE_STDERR
#include <assert.h>
#include "uart.h"
// UART file descriptor
// putchar and getchar are in uart.c
FILE uart_str = FDEV_SETUP_STREAM(uart_putchar, uart_getchar, _FDEV_SETUP_RW);
              
//timeout values for each task
#define t1 100  
#define t2 200  

//I like these definitions
#define begin {
#define end   }

//the  subroutines
void task1(void);  		// Waits for a string and sets a flag
void task2(void);		// Prints the system time and string from task1 
void getstr_int(void);	// Starts getting a string from serial line
void putstr_int(void);	// Starts a send to serial line
void initialize(void); 	// All the usual mcu stuff 
          
volatile int time1, time2	;	// task scheduling timeout counters
volatile long time;				// system time
unsigned int v;					// number entered by human
char newstr ;					// task1-->task2 handshake
	
// RXC ISR variables								
volatile char r_index;  //current string index
volatile char r_buffer[16];	//input string 
volatile char r_ready;  //flag for receive done
volatile char r_char;  //current character  

// TX ISR variables								
volatile char t_index;  //current string index
volatile char t_buffer[16];	//output string 
volatile char t_ready;  //flag for transmit done
volatile char t_char;  //current character
    
//**********************************************************
//timer 0 overflow ISR
ISR (TIMER0_COMPA_vect)
begin
   // increment system time in mSec
   time++;
  //Decrement the times if they are not already zero
  if (time1>0)	--time1;
  if (time2>0) 	--time2;
end  

//**********************************************************
// UART character-ready ISR
// builds a sting and signals when the string is complete
// supports backspace

ISR (USART0_RX_vect)
begin
	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>?
	begin 
		if (r_char == '\b')	// Is the input a backspace? 
		begin
			putchar(' '); 	// erase the character on the screen
			putchar('\b');	// backup
			--r_index ;		// wipe a character from the string
		end
		else   
 			r_buffer[r_index++] = r_char ; // add a character to the string
	end
	else 					// Human pressed <enter>
	begin
		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
	end
end

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

//**********************************************************       
//Entry point and task scheduler loop
int main(void)
begin  
  initialize();
  
  //main task scheduler loop -- never exits!
  while(1)
  begin     
    if (time1==0){time1=t1;	task1(); }
    if (time2==0){time2=t2;	task2(); }
  end   
end  
  
//**********************************************************          
//Task 1   input a string and print it
void task1(void) 
begin 
  //print ad get another serial string      
  if (r_ready)    
  begin
  	// read string which is now ready
	sscanf(r_buffer,"%d",&v);
	// set up procedure to get the next string input
	// and read it using receive ISR
 	getstr_int();
	// signal task2 that a new string is ready
	newstr = 1;     
  end     
end  
 
//********************************************************** 
//Task 2  print the meaasge and system time in seconds
void task2(void) 
begin
  // see if there is a message from task1 and if the last transmit is done
  if (t_ready && newstr)
     begin
	   // make a string of system time (sec) and number from task 1
       sprintf(t_buffer,"%ld %d\n\r",time/1000, v) ; 
	   // print it using transmit ISR 
       putstr_int();
	   // clear the string ready handshake from task 1 
       newstr = 0;
     end
end  
  
//********************************************************** 
// 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) 
begin
  r_ready=0;	// mark string as not ready
  r_index=0;	// reset index
  // turn on receive ISR
  UCSR0B |= (1<<RXCIE0) ;
end

//********************************************************** 
// 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) 
begin
  t_ready=0;	// mark transmitter as busy
  t_index=0;	// reset index
  // see if there is actually a string
  if (t_buffer[0]>0) 
  begin
  	// if so, send one chararcter
  	putchar(t_buffer[0]);
	// and turn on transmit (UDR empty) ISR
  	UCSR0B |= (1<<UDRIE0) ;
 end 
end

//********************************************************** 
//Set it all up
void initialize(void)
begin
   
  // init the UART -- uart_init() is in uart.c
  uart_init();
  stdout = stdin = stderr = &uart_str;
  fprintf(stdout,"Starting ISR UART demo...\n\r"); 
         
  // set up timer 0     
  OCR0A = 249;	   			// clear after 250 counts
  TIMSK0 = (1<<OCIE0A) ;	//turn on timer 0 cmp-match ISR 

  // turn on timer 0 clear on match
  TCCR0A = (1<<WGM01) ;
  // timer 0 prescalar to 64 
  TCCR0B = 3 ;	
  
  // init the task timers
  time1=t1;
  time2=t2;    
  
  // initialize the USRT handshake flags
  r_ready=0; // initially, there is no input ready
  t_ready=1; // initially, the transmitter is ready
     
  // crank up the ISRs
  // but note that UART ISRs are enabled when reading/writing
  sei(); 
   
  // get the first string from the human
  getstr_int();

end