//
// hello.BIKE.44.c
//
// BIKE_ACCELEROMETER
//
// set lfuse to 0x7E for 20 MHz xtal
//

// Nicole Wang
// 12.16.12
// 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.
//

// Awesome resource: http://www.avrfreaks.net/index.php?name=PNphpBB2&file=printview&t=56429&start=0

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

#include <stdlib.h>
#include <stdio.h>
// #include "lcd.h"
// >> usr/local/CrossPack-AVR-20120217/avr/include
#include <avr/interrupt.h>

#define F_CPU 20000000

#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 100 // bit delay for 9600 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 LED_port PORTB
#define LED_direction DDRB
#define LED_pin_out (1<<PB2)

#define serial_port PORTA
#define serial_direction DDRA
#define serial_pin_out (1<<PA5)

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

// Storage variables.
float radius = 13.5; // Tire radius in inches.
long timer = 0; // Time between one full rotation (in ms).
float mph = 0.00;
float circumference;

// void setup(void);

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();
}

//
// 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;
   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;
      }
   }

//
// 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);
   }

int main(void) {

//    setup();
//    uint8_t rand_num = 0; // random number from prng seeded w/ shake_count
   
   
   
   //
   // main
   //
   static uint16_t val, val_lo, val_hi;
   char buffer[10]; // Output of ITOA function.
   //
   // set clock divider to /1
   //
   CLKPR = (1 << CLKPCE);
   CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
   
   // Timer code.
   TCCR1B |= ((1 << CS10) | (1 << CS12)); // Set up time at FCPU/1024.
   TCNT1 = 0;
   
   // Initialize output pins.
   set(serial_port, serial_pin_out);
   output(serial_direction, serial_pin_out);
   
   //
   // Initialize LED pins.
   //
   set(LED_port, LED_pin_out);
   output(LED_direction, LED_pin_out);
   
   // Initialize A/D.
   // Set the ADC reference voltage (controlled by the REFS bits in the ADMUX register
   // and the following sets the reference voltage to []).
   ADMUX = (0 << REFS1) | (0 << REFS0) // Vcc ref
      | (0 << ADLAR) // Right align ADC value.
      // Highest 8 bits in ADCH register with the rest in the ADCL.
      // ADCH readings gives an 8-bit value that represents the 0 to 5 volt measurement from 0 to 255.
      | 7; // ADC7
   // Set the prescalar for the ADC (set the ADPS bits in the ADCSRA register).
   ADCSRA = (1 << ADEN) // To enable ADC.
      | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); // Prescaler /128 to 156250Hz.
   
   // ADC has a resolution of 10 bits split across two 8-bit registers, ADCH and ADCL.
   // 
   
   //
   // 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();
   
   int count = 0;
   int sw = 0;
   int track[5];
   int count_track = 0;
   
   circumference = 2*3.14*radius;

   
   //
   // main loop
   //
   while (1) {
   
      //
      // send framing
      //
//       put_char(&serial_port, serial_pin_out, 1);
//       char_delay();
//       put_char(&serial_port, serial_pin_out, 2);
//       char_delay();
//       put_char(&serial_port, serial_pin_out, 3);
//       char_delay();
//       put_char(&serial_port, serial_pin_out, 4);
//       char_delay();
      //
      // initiate conversion
      //
      ADCSRA |= (1 << ADSC);
      //
      // wait for completion
      //
//       while (ADCSRA & (1 << ADSC))
//          ;
      while((!ADCSRA)&(1<<ADIF)); 
         ADCSRA|=(1<<ADIF);
         
      //
      // send result
      //
//       val_lo = ADCL;
//       put_char(&serial_port, serial_pin_out, val_lo);
//       char_delay();
//       val_hi = ADCH;
//       put_char(&serial_port, serial_pin_out, val_hi);
//       char_delay();
      
      val = ADC;
      char_delay();
//       if (val > 128) {
//          set(LED_port, LED_pin_out);
//       } else {
//          clear(LED_port, LED_pin_out);
//       }


      count++;
      if (val > 511 || val < 506) {

         if (sw == 0) {
            timer = count;
            track[count_track] = timer;
            count_track++;
            if (count_track >=5) {
               count_track = 0;
               sw = 1;
            }
            count = 0;
         }
         else {
            sw = 0;
         }
      }

      
      // 
      // go to zero position
      //
      lcd_putcmd(0);
      lcd_putcmd(DB5);
      //
      // print first line from flash
      //
      static char line1[] PROGMEM = "Current Speed: "; // "Hello to";
      lcd_putstring((PGM_P) line1);
      
      //
      // move to second line
      //
      lcd_putcmd(DB7+DB6);
      lcd_putcmd(0);
      //
      // print second line from flash
      //

//       sprintf(buffer, "%d", val);
//       lcd_putstring2(buffer);


      // 20MHz / 1024 = 19531.25Hz >> 0.0000512 seconds >> 0.0512 ms
      // At 35 mph, the bike travels at ~616 inches/second or ~7.25 
      // revolutions per second.
      int sum = 0;
      int avgCount = 0;
      int i;
      for (i = 0; i<sizeof(track); i++) {
      
      // hello.BIKE.44.c:474:7: error: 'for' loop initial declarations are only allowed in C99 mode
      // hello.BIKE.44.c:474:7: note: use option -std=c99 or -std=gnu99 to compile your code
       
         sum += track[i];
      }
      avgCount = sum / sizeof(track);
      
      sprintf(buffer, "%d", avgCount);
      lcd_putstring2(buffer);

      //
      // pause
      //
      long_delay();
      //
      // clear display
      //
      lcd_putcmd(0);
      lcd_putcmd(DB4);
      }
   }