//
// hello.LCD.44.c
//
// LCD hello-world
//
// set lfuse to 0x7E for 20 MHz xtal
//
// Neil Gershenfeld
// 11/14/10
//
// (c) Massachusetts Institute of Technology 2010
// Permission granted for experimental and personal use;
// license for commercial sale available from MIT.
//

#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <stdio.h>
#include <stdlib.h>

#define output(directions,pin) (directions |= pin) // set port direction for output
#define set(port,pin) (port |= pin) // set port pin
#define clear(port,pin) (port &= (~pin)) // clear port pin
#define pin_test(pins,pin) (pins & pin) // test for port pin
#define bit_test(byte,bit) (byte & (1 << bit)) // test for bit set

#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 char_delay() _delay_ms(10) // char delay


#define LCD_port PORTA
#define LCD_direction DDRA
#define DB7 (1 << PA0)
#define DB6 (1 << PA1)
#define DB5 (1 << PA2)
#define DB4 (1 << PA3)
#define E (1 << PA4)
#define RS (1 << PA5)

#define long_delay() _delay_ms(1000) // delay before redraw
#define lcd_delay() _delay_ms(10) // delay between commands
#define strobe_delay() _delay_us(1) // delay for strobe

#define serial_in_port PORTA
#define serial_in_direction DDRA
#define serial_in_pins PINA
#define serial_out_port PORTB
#define serial_out_direction DDRB
#define serial_out_pins PINB
#define serial_in_pin (1 << PA7)
#define serial_out_pin (1 << PB2)

#define max_buffer 15

//
// lcd_putchar
//    put character in lcdbyte
//
void lcd_putchar(char lcdbyte) {
   //
   // set RS for data
   // 
   set(LCD_port, RS);
   //
   // output high nibble
   //
   if bit_test(lcdbyte, 7)
      set(LCD_port, DB7);
   else
      clear(LCD_port, DB7);
   if bit_test(lcdbyte, 6)
      set(LCD_port, DB6);
   else
      clear(LCD_port, DB6);
   if bit_test(lcdbyte, 5)
      set(LCD_port, DB5);
   else
      clear(LCD_port, DB5);
   if bit_test(lcdbyte, 4)
      set(LCD_port, DB4);
   else
      clear(LCD_port, DB4);
   //
   // strobe E
   //
   strobe_delay();
   set(LCD_port, E);
   strobe_delay();
   clear(LCD_port, E);
   //
   // wait
   //
   lcd_delay();
   //
   // output low nibble
   //
   if bit_test(lcdbyte, 3)
      set(LCD_port, DB7);
   else
      clear(LCD_port, DB7);
   if bit_test(lcdbyte, 2)
      set(LCD_port, DB6);
   else
      clear(LCD_port, DB6);
   if bit_test(lcdbyte, 1)
      set(LCD_port, DB5);
   else
      clear(LCD_port, DB5);
   if bit_test(lcdbyte, 0)
      set(LCD_port, DB4);
   else
      clear(LCD_port, DB4);
   //
   // strobe E
   //
   strobe_delay();
   set(LCD_port, E);
   strobe_delay();
   clear(LCD_port, E);
   //
   // wait and return
   //
   lcd_delay();
   }
//
// lcd_putcmd
//    put command in lcdbyte
//
void lcd_putcmd(char lcdbyte) {
   //
   // clear RS for command
   // 
   clear(LCD_port, RS);
   //
   // output command bits
   //
   PORTA = lcdbyte;
   //
   // strobe E
   //
   strobe_delay();
   set(LCD_port, E);
   strobe_delay();
   clear(LCD_port, E);
   //
   // wait and return
   //
   lcd_delay();
   }
//
// lcd_putstring
//    put a null-terminated string in flash
//
void lcd_putstring(PGM_P message) {
   static uint8_t index;
   static char chr;
   index = 0;
   while (1) {
      chr = pgm_read_byte(&(message[index]));
      if (chr == 0)
         return;
      lcd_putchar(chr);
      ++index;
      }
   }

void lcd_putstring2(char *message) {
   static uint8_t index;
   static char chr;
   index = 0;
   while (1) {
      chr = message[index];
      if (chr == 0)
         return;
      lcd_putchar(chr);
      ++index;
      }
   }

void lcd_clearstring(char *message) {
   static uint8_t index;
   static char chr;
   index = 0;
   while (1) {
      chr = message[index];
      if (chr == 0)
         return;
      message[index] = 0;
      ++index;
      }
   }

void lcd_clonestring(char *source, char *dest) {
   static uint8_t index;
   static char chr;
   index = 0;
   while (1) {
      chr = source[index];
      if (chr == 0)
         return;
      dest[index] = chr;
      ++index;
      }
   }

//
// lcd_init
//    initialize the LCD
//
void lcd_init() {
   //
   // power-up delay
   //
   lcd_delay();
   //
   // initialization sequence
   //
   lcd_putcmd(DB5+DB4);
   lcd_putcmd(DB5+DB4);
   lcd_putcmd(DB5+DB4);
   //
   // 4-bit interface
   //
   lcd_putcmd(DB5);
   //
   // two lines, 5x7 font
   //
   lcd_putcmd(DB5);
   lcd_putcmd(DB7);
   //
   // display on
   //
   lcd_putcmd(0);
   lcd_putcmd(DB7+DB6+DB5);
   //
   // entry mode
   //
   lcd_putcmd(0);
   lcd_putcmd(DB6+DB5);
   }

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 (pin_test(*pins,pin))
      //
      // wait for start bit
      //
      ;
   //
   // delay to middle of first data bit
   //
   half_bit_delay();
   bit_delay();
   //
   // unrolled loop to read data bits
   //
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 0);
   else
      *rxbyte |= (0 << 0);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 1);
   else
      *rxbyte |= (0 << 1);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 2);
   else
      *rxbyte |= (0 << 2);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 3);
   else
      *rxbyte |= (0 << 3);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 4);
   else
      *rxbyte |= (0 << 4);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 5);
   else
      *rxbyte |= (0 << 5);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 6);
   else
      *rxbyte |= (0 << 6);
   bit_delay();
   if pin_test(*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
   //
   clear(*port,pin);
   bit_delay();
   //
   // unrolled loop to write data bits
   //
   if bit_test(txchar,0)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,1)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,2)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,3)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,4)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,5)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,6)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,7)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   //
   // stop bit
   //
   set(*port,pin);
   bit_delay();
   //
   // char delay
   //
   bit_delay();
   }

void put_flash_string(volatile unsigned char *port, unsigned char pin, PGM_P str) {
   //
   // print a null-terminated string from flash
   //
   static char chr;
   static int index;
   index = 0;
   do {
      chr = pgm_read_byte(&(str[index]));
      put_char(port, pin, chr);
      ++index;
      } while (chr != 0);
   }

void put_ram_string(volatile unsigned char *port, unsigned char pin, char *str) {
   //
   // print a null-terminated string from SRAM
   //
   static int index;
   index = 0;
   do {
      put_char(port, pin, str[index]);
      ++index;
      } while (str[index] != 0);
   }


int main(void) {
   static char chr;
   static char chr_before;
   static char line1[max_buffer] = {0};
   static char line2[max_buffer] = {0};
   static char op[1] = {0};
   static int index;
   static int line;
   static int decimal;

   static int line1_num;
   static int line2_num;
   static int ans_num;
   static char ans[max_buffer] = {0};

   //
   // main
   //
   // set clock divider to /1
   //
   CLKPR = (1 << CLKPCE);
   CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
   //
   // initialize LCD pins
   //
   clear(LCD_port, DB7);
   output(LCD_direction, DB7);
   clear(LCD_port, DB6);
   output(LCD_direction, DB6);
   clear(LCD_port, DB5);
   output(LCD_direction, DB5);
   clear(LCD_port, DB4);
   output(LCD_direction, DB4);
   clear(LCD_port, E);
   output(LCD_direction, E);
   clear(LCD_port, RS);
   output(LCD_direction, RS);
   //
   // initialize LCD
   //
   lcd_init();

   lcd_putcmd(0);
   lcd_putcmd(DB4);

   // 
   // go to zero position
   //
   lcd_putcmd(0);
   lcd_putcmd(DB5);

   set(serial_out_port, serial_out_pin);
   output(serial_out_direction, serial_out_pin);
   index = 0;

   line = 1;
   decimal = 0;
   chr_before = '.';
   //
   // main loop
   //
   while (1) {


      get_char(&serial_in_pins, serial_in_pin, &chr);

      if (line == 2 && index > 0 && chr == '=') {
            lcd_putchar(chr);

            line1_num = strtod(line1, (char **) NULL);//atof(line1);		
            line2_num = strtod(line2, (char **) NULL);//atof(line2);

            if (op[0] == '+')
               ans_num =  line1_num + line2_num;   
            if (op[0] == '-')
               ans_num =  line1_num - line2_num;   
            if (op[0] == 'x')
               ans_num =  line1_num * line2_num; 
            if (op[0] == '/')
               ans_num =  line1_num / line2_num; 

	    sprintf(ans, "%d", ans_num);

            lcd_putcmd(0);
            lcd_putcmd(DB4);
        
            lcd_putcmd(0);
            lcd_putcmd(DB5);

     	    lcd_putstring2(ans);
	    
            lcd_clonestring(&ans, &line1);

         }

      if (line == 1 && index > 0 && (chr == '+' || chr == '-' || chr == 'x' || chr == '/')) {
            lcd_putchar(chr);

            op[0] = chr;
            line = 2;
            index = 0;
            decimal = 0;
            lcd_putcmd(DB7+DB6);
            lcd_putcmd(0);
         }

      if (index < max_buffer - 1 && (chr == '1' || chr == '2' || chr == '3' || chr == '4' || chr == '5' || chr == '6' || chr == '7' || chr == '8' || chr == '9' || chr == '0' || chr == '.')) {

         lcd_putchar(chr);

         if (chr == '.' && decimal == 1) {
            lcd_clearstring(&line1);
            lcd_clearstring(&line2);
            op[0] = 0;
            line = 1;
            index = 0;
            decimal = 0;
            lcd_putcmd(0);
            lcd_putcmd(DB4);
        
            lcd_putcmd(0);
            lcd_putcmd(DB5);

            }

         else {

            if ((chr == '.' && decimal == 1) || chr_before == '=') {
               lcd_clearstring(&line1);
               lcd_clearstring(&line2);
               op[0] = 0;
               line = 1;
               index = 0;
               decimal = 0;
               lcd_putcmd(0);
               lcd_putcmd(DB4);
        
               lcd_putcmd(0);
               lcd_putcmd(DB5);

               lcd_putchar(chr);
               }

            if (chr == '.')
               decimal = 1;

            if (line == 1) {
               line1[index++] = chr;
               }
            else {
               line2[index++] = chr;
               }

            }
         
         }

         put_ram_string(&serial_out_port, serial_out_pin, line1);
         put_char(&serial_out_port, serial_out_pin, '(');
         put_ram_string(&serial_out_port, serial_out_pin, op);
         put_char(&serial_out_port, serial_out_pin, ')');
         put_ram_string(&serial_out_port, serial_out_pin, line2);
         put_char(&serial_out_port, serial_out_pin, 10); // new line

         chr_before = chr;

      }
   }