//
//
// phil_hello.ftdi.44.echo.interrupt_T.c
//
// 115200 baud
//
// set lfuse to 0x5E for 20 MHz xtal. This divides clock by 8, giving 2.5 MHz clock frequency.
// The divider is set to /1 in the main program, running the chip at 20 MHz, just at the top
// of the specified range. The chip should receive 4.5-5.5 V in order to operate above 10 MHz.
//F. Phil Brooks III
// 10/23/19
// Harvard Chemistry and Chemical Biology

// Based on code by 
// Neil Gershenfeld
// 12/8/10
// (c) Massachusetts Institute of Technology 2010
// This work may be reproduced, modified, distributed,
// performed, and displayed for any purpose. Copyright is
// retained and must be preserved. The work is provided
// as is; no warranty is provided, and users accept all 
// liability.
//---------------------------------------------------------------------------------------------------
//#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <avr/io.h>
#include <avr/sleep.h>
#include <util/delay.h>
#include <avr/interrupt.h>

#define bit_delay_time 8.5 // bit delay for 115200 with overhead
#define bit_delay() _delay_us(bit_delay_time) // RS232 bit delay
#define half_bit_delay() _delay_us(bit_delay_time/2) // RS232 half bit delay

#define serial_pin_in (1 << PA0)
#define serial_pin_out (1 << PA1)
#define serial_interrupt (1 << PCIE0)
#define serial_interrupt_pin (1 << PCINT0)
#define serial_interrupt_flag (1 << PCIF0) //needed to clear flag

#define button_interrupt (1 << PCIE1)
#define button_interrupt_pin (1 << PCINT10)
#define button_interrupt_flag (1 << PCIF1)
#define button_pin (1 << PB2)



#define led_pin (1 << PA7)

#define max_buffer 120 //can be raised as long as it fits in chip memory. This is low for demonstration of buffer filling.
#define ADC_N 100 //number of readings to average.
volatile char buffer[max_buffer] = {0};
volatile int buffer_index = 0;
volatile uint8_t count = 0; //For repeating ADC. Max is 255. (unsigned)
volatile long t_acc = 0;
volatile char sleep_flag = 0; //must be volatile so it isn't optimized out of main().
void get_char(volatile unsigned char *pins, unsigned char pin, char *rxbyte) {
   // read character into rxbyte on pins pin
   //    assumes line driver (inverts bits)
   *rxbyte = 0;
   while (*pins & pin) {
      ;// wait for start bit
   }
   // delay to middle of first data bit
   //half_bit_delay(); //causes problems receiving o, w with fixed code. May have been legacy of bug.
   bit_delay();
   // unrolled loop to read data bits
   if (*pins & pin)
      *rxbyte |= (1 << 0);
   else
      *rxbyte |= (0 << 0);
   bit_delay();
   if (*pins & pin)
      *rxbyte |= (1 << 1);
   else
      *rxbyte |= (0 << 1);
   bit_delay();
   if (*pins & pin)
      *rxbyte |= (1 << 2);
   else
      *rxbyte |= (0 << 2);
   bit_delay();
   if (*pins & pin)
      *rxbyte |= (1 << 3);
   else
      *rxbyte |= (0 << 3);
   bit_delay();
   if (*pins & pin)
      *rxbyte |= (1 << 4);
   else
      *rxbyte |= (0 << 4);
   bit_delay();
   if (*pins & pin)
      *rxbyte |= (1 << 5);
   else
      *rxbyte |= (0 << 5);
   bit_delay();
   if (*pins & pin)
      *rxbyte |= (1 << 6);
   else
      *rxbyte |= (0 << 6);
   bit_delay();
   if (*pins & pin)
      *rxbyte |= (1 << 7);
   else
      *rxbyte |= (0 << 7);
   // wait for stop bit
   bit_delay();
   half_bit_delay();
   }

void put_char(volatile unsigned char *port, unsigned char pin, char txchar) {
   // send character in txchar on port pin
   //    assumes line driver (inverts bits)
   
   // start bit
   *port &= (~pin);
   bit_delay();
   //
   // unrolled loop to write data bits
   if (txchar & (1<<0))
      *port |= pin;
   else
      *port &= (~pin);
   bit_delay();
   if (txchar & (1<<1))
      *port |= pin;
   else
      *port &= (~pin);
   bit_delay();
   if (txchar & (1<<2))
      *port |= pin;
   else
      *port &= (~pin);
   bit_delay();
   if (txchar & (1<<3))
      *port |= pin;
   else
      *port &= (~pin);
   bit_delay();
   if (txchar & (1<<4))
      *port |= pin;
   else
      *port &= (~pin);
   bit_delay();
   if (txchar & (1<<5))
      *port |= pin;
   else
      *port &= (~pin);
   bit_delay();
   if (txchar & (1<<6))
      *port |= pin;
   else
      *port &= (~pin);
   bit_delay();
   if (txchar & (1<<7))
      *port |= pin;
   else
      *port &= (~pin);
   bit_delay();
   //
   // stop bit
   *port |= pin;
   bit_delay();
   }

void put_string(volatile unsigned char *port, unsigned char pin, char *str) {
   //
   // print a null-terminated string
   static int index;
   index = 0;
   do {
      put_char(port, pin, str[index]);
      ++index;
      } while (str[index] != 0);
   }
   
ISR(PCINT0_vect) {
   //
   // pin change interrupt handler
   //
   static char chr;
   get_char(&PINA, serial_pin_in, &chr);
/*
   put_string(&PORTA, serial_pin_out, "hello.ftdi.44.echo.interrupt.c: you typed \"");
   buffer[buffer_index++] = chr;
   if (buffer_index == (max_buffer-1)) { //last char is always null (necessary for put_string).
	  PORTA |= led_pin; //turn on LED if buffer is full.
      buffer_index = 0;
   }
   put_string(&PORTA, serial_pin_out, (char *)buffer);
   put_char(&PORTA, serial_pin_out, '\"');
   put_char(&PORTA, serial_pin_out, 10); // new line
   */
   if (chr == 'T') {
	   MCUCR |= (1 << SM0); //ADC noise reduction mode. 
	   sleep_flag = 1;	//set sleep flag for main loop to catch.
   }
   GIFR = serial_interrupt_flag; //clear pending serial interrupts caused by data transmission.
}
ISR(INT0_vect) {
	//button press interrupt handler
	/*
	//clear buffer
	for (int i = 0; i < max_buffer; i++) {
		buffer[i]= 0;
	}
	//send cleared message
	put_string(&PORTA, serial_pin_out, "Buffer Cleared\n");
	buffer_index = 0; //reset buffer index.
	PORTA &= (~led_pin); //turn off LED
	*/

	PORTA |= led_pin;
	
	MCUCR |= (1 << SM0); //ADC noise reduction mode. 
	sleep_flag = 1;	//set sleep flag for main loop to catch.
	GIFR = (1 << INTF0); //clear button interrupt flag 
	//(catches bouncing, but not release of button, since 
	// user release of button is much slower than this interrupt handler.
}
ISR(ADC_vect) {
	static char T[16]="";
	//ADC conversion complete interrupt handler
	//read ADC in correct order.
	MCUCR &= ~(1 << SE); //disable sleep (recommended to prevent accidental sleep)
	static int t;
    t = ADCL;//must read low register first, then high.
	t |= (ADCH<<8);
	t_acc += t;
	//Start next conversion if not at ADC_N yet
	if (++count < ADC_N) {
		//ADCSRA |= (1<<ADSC); //start ADC conversion (single conversion mode)
		//GIFR = serial_interrupt_flag;
	    //GIMSK &= ~((1 << INT0) | (1 << PCIE0) | (1 << PCIE1));
		//PORTA &= ~(led_pin);
		MCUCR |= (1 << SM0); //Set ADC noise reduction mode.
		sleep_flag = 1;	//set sleep flag for main program.
		//Entering sleep from interrupt handler has the potential to set up recursive interrupts.
		//Recursion on a microcontroller is dangerous. Don't use it if you don't have to.
		
	}
	else {
	    //turn off LED
		
		put_string(&PORTA, serial_pin_out, "Temperature: ");
		//This is tricky. Naively using *1.8 takes up a lot (20%) of memory as the compiler implements software floating point.
		t_acc = (((t_acc/10-276*(ADC_N/10))*18)+32*ADC_N)/(ADC_N);
		//sprintf(T, "%d", t); //Takes up ~30% of program space. itoa is much smaller.
		ltoa(t_acc, T, 10);
		
		put_string(&PORTA, serial_pin_out, T);
		put_char(&PORTA, serial_pin_out, 10); 
		
		t_acc = 0;
		count = 0;
	}	
}

int main(void) {
   //
   // main
   //
   // set clock divider to /1: Operate at 20 MHz
   //
   CLKPR = (1 << CLKPCE);
   CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
   //
   // initialize output pins
   //
   PORTA |= serial_pin_out;
   PORTA &= (~led_pin); //make sure LED is off.
  
   DDRA |= serial_pin_out;
   DDRA |= led_pin; //make LED pin an output able to source current.
   //
   // set up pin change interrupt on input pin
   //
   GIMSK |= serial_interrupt;
   GIMSK |= (1 << INT0); //enable INT0 external interrupts
   PCMSK0 |= serial_interrupt_pin;
   MCUCR |= (1 << ISC01); //set external interrupt for falling edge on INT0 pin
   PORTB |= (1 << PB2); //turn on pull-up resistor
   
   PRR &= (~(1<<PRADC)); //Make sure ADC is not turned off by power reduction mode;
   ADCSRA |= (1<<ADIE); //enable ADC conversion complete interrupt
   ADCSRA |= ((1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)); //set prescaler to /128 to give 156 kHz clk_adc (can't operate over 1 MHz. 50-200kHz for high res).
   ADCSRA |= (1<<ADEN); //enable ADC
   ADMUX = ((1<<REFS1)|(1<<MUX5)|(1<<MUX1)); //enable temperature sensor with internal 1.1V ref.
   
   sei();
   //
   // main loop
   while (1) {
	   if (sleep_flag == 1) {
		   sleep_flag = 0;
		   PORTA &= (~led_pin); 
		   MCUCR |= (1 << SE); //sleep enable
		   sleep_cpu(); //start sleep (mode is set by function that sets flag).
	   }
    }
}