//
//
// hello.ftdi.44.echo.c
//
// 115200 baud FTDI character echo, with flash string
//
// set lfuse to 0x7E for 20 MHz xtal
//
// Neil Gershenfeld
// 12/8/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/interrupt.h>
#include <avr/signature.h>
#include <avr/eeprom.h>
//#include <avr/pgmspace.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 serial_port PORTA
#define serial_direction DDRA
#define serial_pins PINA
#define serial_pin_in (1 << PA0)
#define serial_pin_out (1 << PA1)
#define serial_interrupt (1 << PCIE0)
#define serial_interrupt_pin (1 << PCINT0)

#define max_buffer 25

static char chr;
static char buffer[max_buffer] = {0};
static int index;

unsigned char nibble_to_hex(unsigned char b)
{
    unsigned char ret = b & 0x0f;
    if(ret>9)
        ret += ('A'-10);
    else
        ret += '0';
    return ret;
}

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_string(volatile unsigned char *port, unsigned char pin, char *str) {
    static int index;
    //
    // print a null-terminated string
    //
    // JWF !! Sending an empty string will fail !!
    index = 0;
    do {
        put_char(port, pin, str[index]);
        ++index;
    } while (str[index] != 0);
}

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

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

ISR(PCINT0_vect) {
    //
    // pin change interrupt handler
    //
    get_char_isr(&serial_pins, serial_pin_in, &chr);
    put_string_isr(&serial_port, serial_pin_out, "hello.ftdi.44.echo.interrupt.c: you typed \"");
    buffer[index++] = chr;
    if (index == (max_buffer-1))
        index = 0;
    put_string_isr(&serial_port, serial_pin_out, buffer);
    put_char_isr(&serial_port, serial_pin_out, '\"');
    put_char_isr(&serial_port, serial_pin_out, 10); // new line
}


int main(void) {
    int count;
    
    //
    // main
    //
    
    //
    // set clock divider to /1
    //
    // JWF already set in fuses
    CLKPR = (1 << CLKPCE);
    CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
    //
    // initialize output pins
    //
    set(serial_port, serial_pin_out);
    output(serial_direction, serial_pin_out);
    
    // Print out sig bytes so we can check what device type it is
    put_string(&serial_port, serial_pin_out, "Sig bytes ");
    put_char(&serial_port, serial_pin_out, nibble_to_hex(__signature[0]>>4));
    put_char(&serial_port, serial_pin_out, nibble_to_hex(__signature[0]&0x0f));
    put_char(&serial_port, serial_pin_out, nibble_to_hex(__signature[1]>>4));
    put_char(&serial_port, serial_pin_out, nibble_to_hex(__signature[1]&0x0f));
    put_char(&serial_port, serial_pin_out, nibble_to_hex(__signature[2]>>4));
    put_char(&serial_port, serial_pin_out, nibble_to_hex(__signature[2]&0x0f));
    put_char(&serial_port, serial_pin_out, 10);
  
    // eeprom values default to 0xff
    // Read a check byte magic number to see if we've got a completely blank eeprom
    count = eeprom_read_byte(0);
    put_string(&serial_port, serial_pin_out, "Boot Count ");
    put_char(&serial_port, serial_pin_out, nibble_to_hex(count>>4));
    put_char(&serial_port, serial_pin_out, nibble_to_hex(count&0x0f));
    put_char(&serial_port, serial_pin_out, 10);
    count++;
    eeprom_write_byte(0, count);
    
#if 0
    put_string(&serial_port, serial_pin_out, "JWF Start Non-ISR\r\n");
    //
    // main loop
    //
    index = 0;
    while (1) {
        get_char(&serial_pins, serial_pin_in, &chr);
        put_string(&serial_port, serial_pin_out, "hello.ftdi.44.echo.c: you typed \"");
        buffer[index++] = chr;
        if (index == (max_buffer-1))
            index = 0;
        put_string(&serial_port, serial_pin_out, buffer);
        put_char(&serial_port, serial_pin_out, '\"');
        put_char(&serial_port, serial_pin_out, 10); // new line
    }
#else
    //
    // set up pin change interrupt on input pin
    //
    set(GIMSK, serial_interrupt);
    set (PCMSK0, serial_interrupt_pin);
    sei();
    put_string(&serial_port, serial_pin_out, "JWF Start ISR\r\n");
    //
    // main loop
    //
    while (1) {
        //
        // wait for interrupt
        //
        ;
    }
#endif
}