Tooltron

      * Copyright 2009 Kevin Woo <kwoo@2ndt.com>
+     *
      ********/
     /** @file uart.c
     /** @file rs485_int.c
+     *
      *	@brief Implements UART functionality in hardware
+     *
      *	@author Kevin Woo (kwoo)
      */
     #include "uart.h"
     #include "rs485_int.h"
     #include <util/delay.h>
     #include <stdint.h>
     uint8_t received_byte;     //Byte received
     uint8_t byte_ready;        //New byte has been received
     void init_uart(uint16_t baud) {
     void rs485_init(uint16_t baud) {
     	// Set baud rate
     	UBRRH = (uint8_t)(baud>>8);
     	UBRRL = (uint8_t)baud;
-...
         // Initialize receive variables
         byte_ready = 0;
         received_byte = 0x0;
         // Set to receive mode
         rs485_toggle_transmit(TX_OFF);
+    }
     int8_t uart_get_byte(uint8_t *output_byte) {
     int8_t rs485_get_byte(uint8_t *output_byte) {
     	if (byte_ready) {
     		byte_ready = 0;
     		*output_byte = received_byte;
-...
+    	}
+    }
     void uart_send_byte(uint8_t data) {
     void rs485_send_byte(uint8_t data) {
     	//Waits until current transmit is done
         while (!(UCSRA & _BV(UDRE)));
         // Enable writes and send
     	uart_toggle_transmit(UART_TX_ON);
     	rs485_toggle_transmit(UART_TX_ON);
         UDR = data;
     	return;
+    }
     void uart_toggle_transmit(uint8_t state) {
     void rs485_toggle_transmit(uint8_t state) {
     	if (state == UART_TX_ON) {
     		PORTD |= TX_EN;
     	} else {
-...
     ISR(USART_TX_vect) {
         // Re-enable reads
         uart_toggle_transmit(UART_TX_OFF);
         rs485_toggle_transmit(UART_TX_OFF);
+    }

+     *
      ********/
     #include <util/delay.h>
     #include "uart.h"
     #include "rs485_int.h"
     #include <avr/interrupt.h>
     #include <avr/io.h>
     #include "tooltron.h"
     #include <tooltron.h>
     #include "timer.h"
     /***** Keypad definitions ******/
-...
     #define LED_YELLOW (_BV(PC4))
     #define LED_GREEN (_BV(PC3))
     #define ADDR 2
     /***** Global variables *****/
-...
       return;
+    }
     /**
      * @brief Sets the LED to the specified state
+     *
      * This sets LED which to the specified state. You can use this to set
      * multiple LEDs if you OR the LEDs desired into the which argument.
+     *
      * @param which The LEDs to set
      * @parma state The state ON or OFF to set to the LEDs to
      * @return void
      */
     void toggle_led(uint8_t which, uint8_t state) {
         if (state == ON) {
             LED_PORT &= ~(which);
         } else {
             LED_PORT |= (which);
+        }
+    }
     char get_button(void) {
     	char ret = ' ';
-...
       return ret;
+    }
     int main(void)
+    {
     typedef enum {
         req,
         press,
         send,
         rsp
     } state_t;
       char c;
       serial_init(BAUD9600);
     int main(void) {
         uint8_t mbuf[PROGD_PACKET_SIZE];
         uint8_t resp;
         uint8_t c;
         state_t state = req;
       rs485_init(BAUD9600);
       init_pins();
       init_timer();
       sei();
       while(1)
+      {
       while(1) {
         PORTC |= LED_RED | LED_GREEN | LED_YELLOW;
         //wait for key request from server
         while(serial_getchar()!=TT_GET_KEY);
           switch(state) {
               case req:
                   toggle_led(LED_RED|LED_GREEN|LED_YELLOW, OFF);
                   // Wait for a packet
                   resp = parse_packet(mbuf, ADDR);
         PORTC &=~LED_YELLOW;
         reset_timer();
         reset_timeout_flag();
         start_timer();
                   if (resp == TT_GET_KEY) {
                       toggle_led(LED_YELLOW, ON);
                       reset_timer();
                       reset_timeout_flag();
                       start_timer();
                       c = ' ';
                       state = press;
+                  }
                   break;
                 case press:
                     c = get_button();
         c = ' ';
         serial_disable_rx();
         while(c ==' ') {
             if (seconds > TIMEOUT_SECONDS) {
                 set_timeout_flag();
                 serial_putchar(TT_TIMEOUT);
                 serial_enable_rx();
                 break;
+            }
                     if (seconds > TIMEOUT_SECONDS) {
                         set_timeout_flag();
                         state = send;
                     } else if (c != ' ') {
                         state = send;
+                    }
             c = get_button();
             _delay_ms(100);
+        }
         serial_enable_rx();
                     break;
             case send:
                     if (timeoutflag == 1) {
                         send_packet(TT_TIMEOUT, ADDR);
                         state = req;
                     } else {
                         send_packet_data(TT_SEND_KEY, ADDR, &c, 1);
+                    }
                     state = rsp;
                     break;
             case rsp:
                     resp = parse_packet(mbuf, ADDR);
                     if (resp == TT_ACK
         if (timeout_flag == 0) {
             //respond with key pressed
             serial_putchar(c);
             uart_send_byte(c);
             //wait for response
             c=0;
             reset_timeout_flag();
             reset_timer();
             while(!c && seconds < TIMEOUT_SECONDS)
               c = serial_getchar_nb();
             while((uart_get_byte(&c) < 0) && (seconds < TIMEOUT_SECONDS));
             PORTC |= LED_YELLOW;

      * Copyright 2009 Kevin Woo <kwoo@2ndt.com>
+     *
      ********/
     /** @file uart.h
     /** @file rs485_int.h
+     *
      *	@brief Initializes UART functions using the UART hardware module
+     *
-...
      *         which msut be the value that is defined in the datasheet
      *         for any particular speed (ie: 51 -> 9600bps)
      **/
     void init_uart(uint16_t baud);
     void rs485_init(uint16_t baud);
     /** @brief Gets latest byte and returns it in output_byte. If the byte
      *         was already read, returns -1 otherwise it returns 0
      **/
     int8_t uart_get_byte(uint8_t *output_byte);
     int8_t rs485_get_byte(uint8_t *output_byte);
     /** @brief Sends a character array of size size. If we are currently
      *         transmitting it will block until the the current transmit
      *         is done.
      **/
     void uart_send_byte(uint8_t data);
     void uart_toggle_transmit(uint8_t state);
     void rs485_send_byte(uint8_t data);
     void rs485_toggle_transmit(uint8_t state);
     #endif

     #include <packet.h>
     /**
      * @brief Packet handler states
      * @param sd Looking for a start delimiter
      * @param src Looking for a source
      * @param dest Looking for a destination
      * @param comd Looking for a command
      * @param read Reading data payload
      * @param cs Calcualting the checksum and returning
      */
     typedef enum {
         sd,
         src,
         dest,
         comd,
         read,
         cs
     } state_t;
     /**
      * @brief Parses a tooltron packet
+     *
      * This is a state machine that parses the packet. It uses a software
      * counter to track timeout status. The timeout is not reset unless
      * a fully valid packet is found. It will fail if there is a timeout,
      * crc error, or any error in the packet. All data will be placed in
      * mbuf. Note that mbuf must be able to handle PROGD_PACKET_SIZE
      * bytes.
+     *
      * @pre mbuf is PROGD_PACKET_SIZE bytes large
      * @param mbuf Buffer to write the packet data payload to if there is one
      * @param addr The address of the sending node
      * @return the command received or TT_BAD on any error
      */
     char parse_packet(uint8_t *mbuf, uint8_t addr) {
       uint8_t r;        // Byte from the network
       uint8_t crc;      // Running checksum of the packet
       uint8_t cmd;      // The command received
       uint8_t pos;      // Position in the message buffer
       uint8_t lim;      // Max number of bytes to read into the message buf
       state_t state;    // State machine
       uint16_t count;
       r = 0;
       crc = 0;
       cmd = 0;
       pos = 0;
       lim = 0;
       state = sd;
       count = 0;
       while (1) {
         // Wait for the next byte
         while ((rs485_get_byte(&r)) < 0) {
             if (count >= MAX_TIMEOUT) {
                 return TT_BAD;
             } else {
                 count++;
+            }
+        }
         switch (state) {
             case sd:
                 if (r == DELIM) {
                     state = src;
+                }
                 break;
             case src:
                 if (r == DELIM) {
                     state = src;
                 } else {
                     crc = r;
                     state = dest;
+                }
                 break;
             case dest:
                 if (r == DELIM) {
                     state = src;
                 } else if (r == addr) {
                     crc ^= r;
                     state = comd;
                 } else {
                     state = sd;
+                }
                 break;
             case comd:
                 cmd = r;
                 crc ^= r;
                 if (r == DELIM) {
                     state = src;
                 } else if (r == TT_PROGM) {
                     lim = PROGM_PACKET_SIZE;
                     state = read;
                 } else if (r == TT_PROGD) {
                     lim = PROGD_PACKET_SIZE;
                     state = read;
                 } else if (r == TT_SEND_KEY) {
                     lim = SEND_KEY_PACKET_SIZE;
                     state = read;
                 } else {
                     state = cs;
+                }
                 break;
             case read:
                 mbuf[pos] = r;
                 crc ^= r;
                 pos++;
                 if (pos == lim) {
                     state = cs;
+                }
                 break;
             case cs:
                 if (r == crc) {
                     if (cmd == TT_RESET) {
                         reset();
+                    }
                     return cmd;
                 } else {
                     return TT_BAD;
+                }
                 break;
             default:
                 return TT_BAD;
+        }
+      }
+    }
     /**
      * @brief Sends a packet of type cmd onto the network
      * @param cmd The command to send
      * @param addr The address of the sending node
      */
     void send_packet(uint8_t cmd, uint8_t addr) {
         rs485_send_byte(DELIM);
         rs485_send_byte(addr);
         rs485_send_byte(SERVER);
         rs485_send_byte(cmd);
         rs485_send_byte(addr ^ SERVER ^ cmd);
+    }
     /**
      * @brief Sends a packet of type cmd onto the network
      * @param cmd The command to send
      * @param addr The address of the sending node
      * @param data Pointer to data
      * @param len Number of bytes to send
      */
     void send_packet_data(uint8_t cmd, uint8_t addr, uint8_t* data, uint8_t len) {
         uint8_t i;
         uint8_t crc = 0;
         rs485_send_byte(DELIM);
         rs485_send_byte(addr);
         rs485_send_byte(SERVER);
         rs485_send_byte(cmd);
         for (i = 0; i < len; i++) {
             crc  ^= data[i];
             rs485_send_byte(data[i]);
+        }
         rs485_send_byte(addr ^ SERVER ^ cmd ^ crc);
+    }

     #     Each directory must be seperated by a space.
     #     Use forward slashes for directory separators.
     #     For a directory that has spaces, enclose it in quotes.
     EXTRAINCDIRS = Y:/code/firefly_plus_lib
     #C:\WinAVR\include\fwr
     EXTRAINCDIRS = ../common
     # Compiler flag to set the C Standard level.

     #ifndef _PACKET_H_
     #define _PACKET_H_
     #include <tooltron.h>
     #include <avr/eeprom.h>
     #include "rs485_poll.h"
     #include "bootloader.h"
     /** @brief Max time to wait until we exit the packet handler */
     #define MAX_TIMEOUT 60000
     char parse_packet(uint8_t *mbuf, uint8_t addr);
     void send_packet(uint8_t cmd, uint8_t addr);
     void send_packet_data(uint8_t cmd, uint8_t addr, uint8_t* data, uint8_t len);
     #endif

Revision 211