Tooltron

     /**
      * @file rs485_sw.c
      * @brief RS485 implementation using UART hardware module and no interrupts
+     *
      * This uses the AVR's UART hardware module but does polling rather than
      * interrupts to handle transmission and receiving. It assumes the use
      * of an external UART<->RS485 converter with the RXEN and TXEN pins tied
      * together.
+     *
      * @author Kevin Woo <kwoo@2ndt.com>
      **/
     /**
      * @brief Initializes the uart
      * @param baud The baudrate. Use the definitions in rs485_sw.h
      */
     void rs485_init(uint16_t baud) {
     	// Set baud rate
     	UBRRH = (uint8_t)(baud>>8);
     	UBRRL = (uint8_t)baud;
     	// Enable RX/TX
     	UCSRB = _BV(RXEN) | _BV(TXEN);
     	// Enable the TXEN pin as output
     	DDRD |= TX_EN;
         rs485_toggle_transmit(RS485_TX_OFF);
+    }
     /**
      * @brief Non-blocking receive
+     *
      * Receives a byte from the UART if one exists. If none exist the function
      * will return an error code immediately. If there is a byte to receive,
      * it will be placed in a passed in pointer and return.
+     *
      * @pre The RS485 TXEN line is not enabled
      * @param output_byte Byte to store the received message
      * @return 0 on success, negative if there is nothing to receive
      */
     int8_t rs485_get_byte(uint8_t *output_byte) {
         if (UCSRA & _BV(RXC)) {
             *output_byte = UDR;
             return 0;
         } else {
             return -1;
+        }
+    }
     /**
      * @brief Blocking send
+     *
      * Sends the byte in data onto the network. The function will block until
      * the transmit is complete so that the transmit enable line can be toggled
      * safely. It will wait until any current transmission completes before sending
      * and will wait until it completes before returning. The RS485 TX enable line
      * is automatically toggled by the function and should not be done so
      * outside the function.
+     *
      * @param data The byte to send
      */
     void rs485_send_byte(uint8_t data) {
     	//Waits until current transmit is done
         while (!(UCSRA & _BV(UDRE)));
         // Enable writes and send
     	rs485_toggle_transmit(RS485_TX_ON);
         UDR = data;
         // Waits until the transmit is done
         while(!(UCSRA & _BV(TXC)));
         rs485_toggle_transmit(RS485_TX_OFF);
         UCSRA |= _BV(TXC);
     	return;
+    }
     /**
      * @brief Toggles the RS485 TXEN line
+     *
      * This function should not be used outside of this file
+     *
      * @param state Whether to turn the pin on or off
      */
     void rs485_toggle_transmit(uint8_t state) {
     	if (state == RS485_TX_ON) {
     		PORTD |= TX_EN;
     	} else {
     		PORTD &= ~TX_EN;
+    	}
+    }

      * Copyright 2009 Kevin Woo <kwoo@2ndt.com>
+     *
      ********/
     /** @file uart.h
     /** @file rs485_sw.h
+     *
      *	@brief Initializes UART functions using the UART hardware module
      *	@brief Implements rs485 using the uart hardware module.
+     *
      *	See rs485_sw.c for more information
+     *
      *	@author Kevin Woo (kwoo)
      */
     #ifndef UART_H
     #define UART_H
     #ifndef _RS485_SW_H
     #define _RS485_SW_H
     #include <avr/io.h>
     #include <avr/interrupt.h>
     #include <stdint.h>
     /** **/
     #define UART_TX_OFF 0
     #define UART_TX_ON 1
     /** @brief RX Pin for the UART **/
     #define RS485_TX_OFF 0
     #define RS485_TX_ON 1
     /** @brief RX Pin for the RS485 */
     #define RX		_BV(PORTD0)
     /** @brief TX Pin for the RS485 */
     #define TX		_BV(PORTD1)
     /** @brief TX Enable Pin for the RS485 */
     #define TX_EN	_BV(PORTD5)
     /** @brief The most recently received byte **/
     extern uint8_t received_byte;
     /** @brief If the value in received_byte has been read or not **/
     extern uint8_t byte_ready;
     /** @brief Initializes the UART registers and sets it to the buad rate
      *         which msut be the value that is defined in the datasheet
      *         for any particular speed (ie: 51 -> 9600bps)
      **/
     void init_uart(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
      **/
     void uart_init(uint16_t baud);
     int8_t uart_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);
     static void uart_toggle_transmit(uint8_t state);
     #endif

     #include <avr/boot.h>
     #include <avr/wdt.h>
     #include <tooltron.h>
     #include "uart.h"
     #include "rs485_sw.h"
     #define ADDR    18
-...
         int16_t sword;
     } rjump_t;
     void init_uart(uint16_t baud) {
     	// Set baud rate
     	UBRRH = (uint8_t)(baud>>8);
     	UBRRL = (uint8_t)baud;
     	// Enable RX/TX
     	UCSRB = _BV(RXEN) | _BV(TXEN);
     	// Enable the TXEN pin as output
     	DDRD |= TX_EN;
         uart_toggle_transmit(UART_TX_OFF);
+    }
     int8_t uart_get_byte(uint8_t *output_byte) {
         if (UCSRA & _BV(RXC)) {
             *output_byte = UDR;
             return 0;
         } else {
             return -1;
+        }
+    }
     void uart_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);
         UDR = data;
         // Waits until the transmit is done
         while(!(UCSRA & _BV(TXC)));
         uart_toggle_transmit(UART_TX_OFF);
         UCSRA |= _BV(TXC);
     	return;
+    }
     void uart_toggle_transmit(uint8_t state) {
     	if (state == UART_TX_ON) {
     		PORTD |= TX_EN;
     	} else {
     		PORTD &= ~TX_EN;
+    	}
+    }
     char parse_packet(uint8_t *mbuf) {
       uint8_t r;        // Byte from the network
       uint8_t crc;      // Running checksum of the packet
-...
       while (1) {
         // Wait for the next byte
         while ((uart_get_byte(&r)) < 0) {
         while ((rs485_get_byte(&r)) < 0) {
             if (count >= MAX_TIMEOUT) {
                 return TT_BAD;
             } else {
-...
+    }
     void send_packet(uint8_t cmd) {
         uart_send_byte(DELIM);
         uart_send_byte(ADDR);
         uart_send_byte(SERVER);
         uart_send_byte(cmd);
         uart_send_byte(ACK_CRC ^ cmd);
         rs485_send_byte(DELIM);
         rs485_send_byte(ADDR);
         rs485_send_byte(SERVER);
         rs485_send_byte(cmd);
         rs485_send_byte(ACK_CRC ^ cmd);
+    }
     // SPM_PAGESIZE is set to 32 bytes
-...
       WDTCSR = 0;
       init_uart(51); //MAGIC NUMBER??
       rs485_init(51); //MAGIC NUMBER??
       //set LED pin as output
       LED_DDR |= 0x07;

Revision 184