/ - Diff - Colony - Robotics Club

     #ifndef __SPI_H__
     #define __SPI_H__
     #include<dragonfly_lib.h>
     #define DOUBLE_SCK 1
     #define SPR0_BIT 1
-...
     * @param spi_fun_recv_t The function that handles SPI data, byte for byte.
     * @param spi_fun_recv_complete_t  Called on a completed transmission - typically for cleaning up.
     */
     void spi_init (spi_fun_recv_t, spi_fun_recv_complete_t);
     int spi_init (spi_fun_recv_t, spi_fun_recv_complete_t);
     /**
     * @brief Initialize SPI transfer.
+    *
     * @param char The number of bytes to transfer.
     */
     void spi_transfer (char);
     int spi_transfer (char);
     /**@}**/ //end group

     #ifndef _TIME_H_
     #define _TIME_H_
     #include <dragonfly_lib.h>
     /*	Predefined times for prescale_opt in time.c.
     	To make you own, know that a pulse is 1/16th of a second. You cannot get less than this. To get more, you need
     	to know how many 16ths of a second are in the time you want. (Time_desired * 16 = prescaler_opt)
-...
     /** @brief Delay execution for the specified time **/
     void delay_ms(int ms) ;
     /** @brief Enable the realtime clock **/
     void rtc_init(int prescale_opt, void (*rtc_func)(void));
     int rtc_init(int prescale_opt, void (*rtc_func)(void));
     /** @brief Reset the counter of the realtime clock **/
     void rtc_reset(void);
     /** @brief Get the value of the realtime clock. **/

     #ifndef _MOTOR_H
     #define _MOTOR_H
     #include <dragonfly_lib.h>
     #include <avr/io.h>
     /**
      * @addtogroup motors
-...
     #define BACKWARD 0
     /** @brief Initialize the motors **/
     void motors_init(void);
     int motors_init(void);
     /** @brief Set speed and direction of motor1
      *  @deprecated use the left motor function instead. it's more intuitive and easier to read.**/
     void motor1_set(int direction, int speed);
     int motor1_set(int direction, int speed);
     /** @brief Set speed and direction of motor2
      *  @deprecated use the right motor function instead. it's more intuitive and easier to read.**/
     void motor2_set(int direction, int speed);
     int motor2_set(int direction, int speed);
     /** @brief Set speed and direction of left motor **/
     void motor_l_set(int direction, int speed);
     int motor_l_set(int direction, int speed);
     /** @brief Set speed and direction of right motor **/
     void motor_r_set(int direction, int speed);
     int motor_r_set(int direction, int speed);
     /** @brief Turn the motors off **/
     void motors_off(void);
     int motors_off(void);
     /**@}**/ // end addtogroup

     /** @brief Initialize analog ports. Will start running a loop
         if start_conversion is ADC_START.**/
     void analog_init(int start_conversion);
     int analog_init(int start_conversion);
     /** @brief starts the analog loop. Doesn't do anything if the loop is already running. **/
     void analog_start_loop(void);
     int analog_start_loop(void);
     /** @brief Stops the analog loop. Doesn't do anything if the loop is already stopped. **/
     void analog_stop_loop(void);
     int analog_stop_loop(void);
     /** @brief Returns the status of the analog loop. **/
     int analog_loop_status(void);
     /** @brief Returns an 8-bit analog value from the look up table. Use this instead of analog_get8. **/

     #define MagINCn _BV(1)
     #define MagDECn _BV(0)
     #ifdef BUFFER_SIZE
     #error BUFFER_SIZE already defined!
     #endif
     /** @brief Buffer size **/
     #define BUFFER_SIZE 46
     #define ERR_VEL 1024
     /** @brief Initialize encoders. **/
     void encoders_init(void);
     int encoders_init(void);
     /** @brief Read instantaneous encoder value. **/
     int encoder_read(char encoder);
-...
     /** @brief Get total distance traveled. **/
     int encoder_get_dx(char encoder);
     /** @brief Reset distance counter. **/
     void encoder_rst_dx(char encoder);
     int encoder_rst_dx(char encoder);
     /** @brief Get time count: The number of encoder reads that have occurred. **/
     int encoder_get_tc(void);
     /** @brief Reset the time count. **/
     void encoder_rst_tc(void);
     int encoder_rst_tc(void);
     /** @brief Waits for the next n encoder reading, then returns. **/
     void encoder_wait( int nReadings );
     int encoder_wait( int nReadings );
     /**@}**/ //end group

      * @{
      **/
     //return value definitions
     #define ERROR_INIT_FAILED 1
     #define ERROR_INIT_ALREADY_INITD 2
     #define ERROR_LIBRARY_NOT_INITD 3
     // Configuration definitions
     /** @brief Initialize analog **/
     #define ANALOG 0x01

     /** @brief Initialize the bom according to bom type **/
     void bom_init(char type);
     int bom_init(char type);
     /** @brief Refresh bom_val[] with new values from analog8.  analog_init and bom_init must be called for this to work. **/
     void bom_refresh(int bit_field);
     int bom_refresh(int bit_field);
     /** @brief Gets the bom reading from bom_val[which].  Call bom_refresh beforehand to read new bom values. **/
     int bom_get(int which);
-...
     int bom_get_max10(int *dist);
     /** @brief Enables the selected bom leds on a BOM1.5 **/
     void bom_set_leds(int bit_field);
     int bom_set_leds(int bit_field);
     /** @brief (DEPRECATED) Gets and compares all bom values.  Returns the index to the highest value element since last refresh. **/
     int get_max_bom(void);
     /** @brief Turns on all BOM leds, or turns on enabled leds on a BOM1.5. **/
     void bom_on(void);
     int bom_on(void);
     /** @brief Turns off all bom leds. **/
     void bom_off(void);
     int bom_off(void);
     /** @} **/

     #ifndef _SERIAL_H
     #define _SERIAL_H
     #include <dragonfly_lib.h>
     #include <inttypes.h>
     #include <avr/pgmspace.h>
-...
     #endif
     /** @brief Initialize the USB **/
     void usb_init(void);
     int usb_init(void);
     /** @brief Print a character to USB **/
     int usb_putc(char c);
     /** @brief Read a character from USB **/
-...
     /** @brief Print a string to USB **/
     int usb_puts(char *s);
     /** @brief Print a string from program space to USB **/
     void usb_puts_P (PGM_P s);
     int usb_puts_P (PGM_P s);
     /** @brief Print an integer to USB **/
     int usb_puti(int value);
     /** @brief Determine a hexadecimal digit **/
     uint8_t hex_digit (uint8_t value);
     /** @brief Print a fixed width hexadecimal representation to USB **/
     void usb_puth16 (uint16_t value);
     int usb_puth16 (uint16_t value);
     /** @brief Print a fixed width hexadecimal representation to USB **/
     void usb_puth8(uint8_t value);
     int usb_puth8(uint8_t value);
     /** @brief Alias for usb_puth16 **/
     static inline void usb_puth (uint16_t value) { usb_puth16 (value); };
-...
     #endif
     /** @brief Initialize the XBee **/
     void xbee_init(void);
     int xbee_init(void);
     /** @brief Print a character to the XBee **/
     int xbee_putc(char c);
     /** @brief Read a character from the XBee **/

     #ifndef _RANGEFINDER_H_
     #define _RANGEFINDER_H_
     #include <dragonfly_lib.h>
     /**
      * @addtogroup rangefinder
      * @{
-...
     #define MAX_IR_ADC8 133
     /** @brief Initialize the rangefinders **/
     void range_init(void);
     int range_init(void);
     /** @brief Read the distance from a rangefinder **/
     int range_read_distance(int range_id);
     /** @brief Convert logarithmic-scale distance readings to a linear scale **/

     /**
      * @file eeprom.h
      * @brief handles eeprom storage for persistent data
+     *
      * Contains functions and definitions for reading and writing to eeprom
+     *
      * @author Colony Project, Brad Neuman
      */
      #ifndef _EEPROM_H_
      #define _EEPROM_H_
      #define EEPROM_ROBOT_ID_ADDR 0x10
      #define EEPROM_BOM_TYPE_ADDR 0x14
      /** @brief store a byte to eeproem
       *  @return 0 if success, nonzero on failure
       */
      int eeprom_put_byte(unsigned int addr, unsigned char byte);
      /** @brief reads a byte from eeprom
+      *
       *  Pass it thge address and a pointer to a byte where the byte at the
       *  address will be stored
+      *
       *  @return 0 if successful (byte is set to the eeprom value at addr),
       *  nonzero if there was a problem
        */
      int eeprom_get_byte(unsigned int addr, unsigned char *byte);
      /** @brief get stored robot ID
+      *
       *  checks that EEPROM has been programed with an ID and returns it
+      *
       *  @return the robot id, if it is stored. If it returns 0xFF it is probably invalid
       */
      unsigned char get_robotid(void);
        /** @brief get stored robot ID
+      *
       * checks that EEPROM has been programed with an BOM type and returns it
+      *
       *  @return the robot bom type as defined in bom.h, if it is stored. If it returns 0xFF it is probably invalid
       */
      unsigned char get_bom_type(void);
      #endif

         delay_ms(3000);
     	//while(1){;}
         motors_off();
         return 0;
+    }
-...
     left >154 forward
     right >150 forward
     both >152 backward
     */
     */

         int i;  // index
         int sensor[5] = {IR4, IR3, IR2, IR1, IR5};
         int color[5] = {RED, ORANGE, YELLOW, GREEN, BLUE};
         int ret;
         // flash orbs BLUE 3 times
         for (i = 0; i < 3; i++) {
-...
     	orb2_set_color(color[i]);
     	// wait for sensor interaction
     	while (range_read_distance(sensor[i]) == -1)
     	while ((ret = range_read_distance(sensor[i])) == -1) {
     	    // stay RED until IR4 sees something
     	    orb1_set_color(RED);
     	    if(ret == -3) { //library not init'd
     	      while(1) {
     		orb2_set_color(GREEN);
     		orb1_set_color(RED);
     		delay_ms(250);
     		orb1_set_color(GREEN);
     		orb2_set_color(RED);
     		delay_ms(250);
+    	      }
+    	    }
+    	}
     	orb1_set_color(GREEN);
     	delay_ms(TEST_TIME);

     #define RUN_TEST(f) extern int f(void); f();
     int main(void) {
       RUN_TEST(testinits);
       dragonfly_init(ALL_ON);
       while (1) {
         // RUN_TEST(testusb);
         //RUN_TEST(testusb);
         // RUN_TEST(testanalog);
         // RUN_TEST(testeeprom);
         //RUN_TEST(testeeprom);
         // RUN_TEST(testencoders);
         // RUN_TEST(testlcd);
         // RUN_TEST(testlights);
         // RUN_TEST(testmotors);
         // RUN_TEST(testrangefinder);
         //RUN_TEST(testlights);
         //RUN_TEST(testmotors);
         RUN_TEST(testrangefinder);
         // RUN_TEST(testtokenring);
         // RUN_TEST(testwireless);
         RUN_TEST(testxbee);
         //RUN_TEST(testxbee);
         delay_ms(1000);
+      }

         delay8.tv_sec = 2;
         delay8.tv_nsec = 800000000;
         wl_set_com_port("/dev/ttyUSB0");
         wl_set_com_port("/dev/ttyUSB1");
         // set up wireless
         wl_basic_init_default();
         wl_set_channel(channel);

      * @{
      **/
     unsigned char motors_initd=0;
     /**
      * Initializes both motors so that they can be used with future
      * calls to motor1_set and motor2_set.
+     *
      * @return 0 if init succesfull, an error code otherwise
+     *
      * @see motors_off, motor1_set, motor2_set
      **/
     void motors_init( void ) {
     int motors_init( void ) {
       if(motors_initd)
         return ERROR_INIT_ALREADY_INITD;
       // Configure counter such that we use phase correct
       // PWM with 8-bit resolution
       PORTA &= 0x0F;
-...
       OCR1AL=0;
       OCR1BH=0;
       OCR1BL=0;
       motors_initd=1;
       return 0;
+    }
     /**
-...
      * @param direction Either FORWARD or BACKWARD to set the direction of rotation.
      * @param speed The speed the motor will run at, in the range 0-255.
+     *
      * @return 0 if init succesfull, an error code otherwise
+     *
      * @see motor_r_set, motors_init
      **/
     void motor_l_set(int direction, int speed) {
     int motor_l_set(int direction, int speed) {
       if(!motors_initd)
         return ERROR_LIBRARY_NOT_INITD;
       if(direction == 0) {
         // turn off PWM first if switching directions
-...
       // Set the timer to count up to speed, an 8-bit value
       OCR1AL = speed;
       return 0;
+    }
     /**
-...
      * @param direction Either FORWARD or BACKWARD to set the direction of rotation.
      * @param speed The speed the motor will run at, in the range 0-255.
+     *
      * @return 0 if init succesfull, an error code otherwise
+     *
      * @see motor_l_set, motors_init
      **/
     void motor_r_set(int direction, int speed) {
     int motor_r_set(int direction, int speed) {
       if(!motors_initd)
         return ERROR_LIBRARY_NOT_INITD;
       if(direction == 0) {
         //		PORTD |= 0x20;
         //		PORTD &= 0x7F;
-...
         PORTA = (PORTA & 0x3F) | 0x40;
+      }
       OCR1BL = speed;
       return 0;
+    }
     /**
-...
      * @param direction Either FORWARD or BACKWARD to set the direction of rotation.
      * @param speed The speed the motor will run at, in the range 0-255.
+     *
      * @return 0 if init succesfull, an error code otherwise
+     *
      * @see motor2_set, motors_init
      **/
     void motor1_set(int direction, int speed) {
     	motor_l_set(direction, speed);
     int motor1_set(int direction, int speed) {
       return motor_l_set(direction, speed);
+    }
     /**
-...
      * @param direction Either FORWARD or BACKWARD to set the direction of rotation.
      * @param speed The speed the motor will run at, in the range 0-255.
+     *
      * @return 0 if init succesfull, an error code otherwise
+     *
      * @see motor2_set, motors_init
      **/
     void motor2_set(int direction, int speed) {
     	motor_r_set(direction, speed);
     int motor2_set(int direction, int speed) {
       return motor_r_set(direction, speed);
+    }
     /**
      * Turns off both motors.
+     *
      * @return 0 if init succesfull, an error code otherwise
+     *
      * @see motors_init
      **/
     void motors_off( void ) {
     int motors_off( void ) {
       if(!motors_initd)
         return ERROR_LIBRARY_NOT_INITD;
       OCR1AL = 0x0;
       OCR1BL = 0x0;
       return 0;
+    }
     /**@}**///end defgroup

     #ifndef _MOTOR_H
     #define _MOTOR_H
     #include <dragonfly_lib.h>
     #include <avr/io.h>
     /**
      * @addtogroup motors
-...
     #define BACKWARD 0
     /** @brief Initialize the motors **/
     void motors_init(void);
     int motors_init(void);
     /** @brief Set speed and direction of motor1
      *  @deprecated use the left motor function instead. it's more intuitive and easier to read.**/
     void motor1_set(int direction, int speed);
     int motor1_set(int direction, int speed);
     /** @brief Set speed and direction of motor2
      *  @deprecated use the right motor function instead. it's more intuitive and easier to read.**/
     void motor2_set(int direction, int speed);
     int motor2_set(int direction, int speed);
     /** @brief Set speed and direction of left motor **/
     void motor_l_set(int direction, int speed);
     int motor_l_set(int direction, int speed);
     /** @brief Set speed and direction of right motor **/
     void motor_r_set(int direction, int speed);
     int motor_r_set(int direction, int speed);
     /** @brief Turn the motors off **/
     void motors_off(void);
     int motors_off(void);
     /**@}**/ // end addtogroup

     #include "i2c.h"
     #include "ring_buffer.h"
     //NOTE: this is here just to provide colony error codes, it can be safely removed
     // for use in another project
     #include <dragonfly_lib.h>
     /**
      * @defgroup i2c I2C
+     *
-...
      */
     #define I2C_BIT_RATE_DIVIDER 0x0C
     unsigned char i2c_initd=0;
     static int start_flag;
     static fun_mrecv_t master_recv_function;
-...
      * @return 0 for success, nonzero for failure
      **/
     int i2c_init(char addr, fun_mrecv_t master_recv, fun_srecv_t slave_recv, fun_send_t slave_send) {
         if(i2c_initd)
           return ERROR_INIT_ALREADY_INITD;
         master_recv_function = master_recv;
         slave_recv_function = slave_recv;
         slave_send_function = slave_send;
-...
          * global messages to be accepted */
         TWAR = (addr << 1) | 1;
         i2c_initd = 1;
         return 0;
+    }
-...
     int i2c_send(char dest, char *data, unsigned int bytes) {
         int i;
         if(!i2c_initd)
           return ERROR_LIBRARY_NOT_INITD;
         /* adding data to be sent to ring buffers is not atomic,
          * so disable interrupts */
         cli();
-...
      * @return 0 for success, nonzero for failure
      **/
     int i2c_request(char dest) {
         if(!i2c_initd)
           return ERROR_LIBRARY_NOT_INITD;
         if(RING_BUFFER_FULL(i2c_write_buff))
             return -1;

     #include <avr/io.h>
     #include "serial.h"
     unsigned char usb_initd=0;
     unsigned char xbee_initd=0;
     #ifdef USE_STDIO
     #include <stdio.h>
-...
      * This must be called before any other usb function
      * may be used.
      **/
     void usb_init() {
     int usb_init() {
       //Set baud rate
       // - 115200 (both wired and wireless) is UBRR=8, U2X=1
       // - 9600 is U2X =1, UBRR = 107.
       if(usb_initd) {
         return ERROR_INIT_ALREADY_INITD;
+      }
     #if (USB_BAUD == 115200)
       UBRR0H = 0x00;
       UBRR0L = 8;
-...
       UBRR0L = 103;
       UCSR0A |= _BV(U2X0);
     #else //Baud rate is defined in the header file, we should not get here
       return;
       return 0;
     #endif
       /*Enable receiver and transmitter */
-...
       /* Open the stdio stream corresponding to this port */
       usb_fd = fdevopen(usb_putc, usb_getc);
     #endif
       usb_initd = 1;
       return 0;
+    }
     /**
-...
      * This must be called before any other xbee function
      * may be used.
      **/
     void xbee_init() {
     int xbee_init() {
       if(xbee_initd) {
         return ERROR_INIT_ALREADY_INITD;
+      }
       //Set baud rate
       // - 115200 (both wired and wireless) is UBRR=8, U2X=1
       // - 9600 is U2X =1, UBRR = 107.
-...
       UBRR1L = 103;
       UCSR1A |= _BV(U2X1);
     #else //Baud rate is defined in the header file, we should not get here
       return;
       return 0;
     #endif
       //Enable receiver and transmitter
-...
       /* Open the stdio stream corresponding to this port */
       xbee_fd = fdevopen(xbee_putc, xbee_getc);
     #endif
       xbee_initd = 1;
       return 0;
+    }
     /**
-...
      * @return 0 for success, nonzero for failure
      **/
     int usb_putc(char c) {
       if(!usb_initd)
         return ERROR_LIBRARY_NOT_INITD;
       // Wait until buffer is clear for sending
       loop_until_bit_is_set(UCSR0A, UDRE0);
-...
      * @return 0 for success, nonzero for failure
      **/
     int xbee_putc(char c) {
       if(!xbee_initd)
         return ERROR_LIBRARY_NOT_INITD;
       // Wait until buffer is clear for sending
       loop_until_bit_is_set(UCSR1A, UDRE1);
-...
      **/
     int usb_puts(char *s) {
       char *t = s;
       if(!usb_initd)
         return ERROR_LIBRARY_NOT_INITD;
       while (*t != 0) {
         usb_putc(*t);
         t++;
-...
      * Sends a sequence of characters from program space over USB.
+     *
      * @param s the string to send
+     *
      * @return 0 if init succesfull, an error code otherwise
      **/
     void usb_puts_P (PGM_P s) {
     int usb_puts_P (PGM_P s) {
         char buf;
         if(!usb_initd)
           return ERROR_LIBRARY_NOT_INITD;
         while (memcpy_P (&buf, s, sizeof (char)), buf!=0) {
             usb_putc (buf);
             s++;
+        }
         return 0;
+    }
-...
      * This function blocks execution until a character has been received.
      * xbee_init must be called before this function may be used.
+     *
      * @return the first character in the usb buffer
      * @return the first character in the usb buffer, -1 on error
+     *
      * @see usb_init, usb_getc_nb
      **/
     int usb_getc(void) {
       if(!usb_initd)
         return -1;
       // Wait for the receive buffer to be filled
       loop_until_bit_is_set(UCSR0A, RXC0);
-...
      * received. xbee_init must be called before this function
      * may be used.
+     *
      * @return the first character in the xbee buffer
      * @return the first character in the xbee buffer, -1 on error
+     *
      * @see xbee_init, xbee_getc_nb
      **/
     int xbee_getc(void) {
       if(!usb_initd)
         return -1;
       // Wait for the receive buffer to be filled
       loop_until_bit_is_set(UCSR1A, RXC1);
-...
      * @param c the received character. This will be set if a character has
      * been received.
+     *
      * @return -1 if no character is available, 0 otherwise
      * @return -1 if no character is available, 0 otherwise, positive for error
+     *
      * @see usb_init, usb_getc
      **/
     int usb_getc_nb(char *c) {
       if(!usb_initd)
         return ERROR_LIBRARY_NOT_INITD;
       // check if the receive buffer is filled
       if (UCSR0A & _BV(RXC0)) {
         // Read the receive buffer
-...
      * @param c the received character. This will be set if a character has
      * been received.
+     *
      * @return -1 if no character is available, 0 otherwise
      * @return -1 if no character is available, 0 otherwise, positive for error
+     *
      * @see xbee_init, xbee_getc
      **/
     int xbee_getc_nb(char *c) {
       if(!xbee_initd)
         return ERROR_LIBRARY_NOT_INITD;
       // check if the receive buffer is filled
       if (UCSR1A & _BV(RXC1)) {
         // Read the receive buffer
-...
     int usb_puti(int value ) {
       unsigned char usb_data[6]={'0','0','0','0','0','0' }, position=sizeof(usb_data), radix=10;
       if(!usb_initd)
         return ERROR_LIBRARY_NOT_INITD;
       /* convert int to ascii  */
       if(value<0) {
         usb_putc('-');
-...
      * @param value the value to print
+     *
      * @see usb_init, usb_puti, usb_puts, usb_puth8, hex_digit
+     *
      * @return 0 if init succesfull, an error code otherwise
      **/
     void usb_puth16 (uint16_t value)
     int usb_puth16 (uint16_t value)
+    {
         if(!usb_initd)
           return ERROR_LIBRARY_NOT_INITD;
         usb_putc (hex_digit((value >>12)&0xF));
         usb_putc (hex_digit((value >>8 )&0xF));
         usb_putc (hex_digit((value >>4 )&0xF));
         usb_putc (hex_digit( value      &0xF));
         return 0;
+    }
     /**
-...
      * @param value the value to print
+     *
      * @see usb_init, usb_puti, usb_puts, usb_puth16, hex_digit
+     *
      * @return 0 if init succesfull, an error code otherwise
      **/
     void usb_puth8(uint8_t value)
     int usb_puth8(uint8_t value)
+    {
         if(!usb_initd)
           return ERROR_LIBRARY_NOT_INITD;
         usb_putc (hex_digit ((value)>>4 &0xF));
         usb_putc (hex_digit ( value     &0xF));
         return 0;
+    }

      * @{
      **/
     //return value definitions
     #define ERROR_INIT_FAILED 1
     #define ERROR_INIT_ALREADY_INITD 2
     #define ERROR_LIBRARY_NOT_INITD 3
     // Configuration definitions
     /** @brief Initialize analog **/
     #define ANALOG 0x01

     #ifndef _SERIAL_H
     #define _SERIAL_H
     #include <dragonfly_lib.h>
     #include <inttypes.h>
     #include <avr/pgmspace.h>
-...
     #endif
     /** @brief Initialize the USB **/
     void usb_init(void);
     int usb_init(void);
     /** @brief Print a character to USB **/
     int usb_putc(char c);
     /** @brief Read a character from USB **/
-...
     /** @brief Print a string to USB **/
     int usb_puts(char *s);
     /** @brief Print a string from program space to USB **/
     void usb_puts_P (PGM_P s);
     int usb_puts_P (PGM_P s);
     /** @brief Print an integer to USB **/
     int usb_puti(int value);
     /** @brief Determine a hexadecimal digit **/
     uint8_t hex_digit (uint8_t value);
     /** @brief Print a fixed width hexadecimal representation to USB **/
     void usb_puth16 (uint16_t value);
     int usb_puth16 (uint16_t value);
     /** @brief Print a fixed width hexadecimal representation to USB **/
     void usb_puth8(uint8_t value);
     int usb_puth8(uint8_t value);
     /** @brief Alias for usb_puth16 **/
     static inline void usb_puth (uint16_t value) { usb_puth16 (value); };
-...
     #endif
     /** @brief Initialize the XBee **/
     void xbee_init(void);
     int xbee_init(void);
     /** @brief Print a character to the XBee **/
     int xbee_putc(char c);
     /** @brief Read a character from the XBee **/

     /**
      * @file eeprom.c
      * @brief handles eeprom storage for persistent data
+     *
      * Contains functions and definitions for reading and writing to eeprom
+     *
      * @author Colony Project, Brad Neuman
      */
     #include <avr/io.h>
     #include "eeprom.h"
     /** @brief store a byte to eeproem
      *  @return 0 if success, nonzero on failure
      */
     int eeprom_put_byte(unsigned int uiAddress, unsigned char ucData) {
         /* Wait for completion of previous write */
         while(EECR & (1<<EEWE));
-...
         return 0;
+    }
     /** @brief reads a byte from eeprom
+     *
      *  Pass it thge address and a pointer to a byte where the byte at the
      *  address will be stored
+     *
      *  @return 0 if successful (byte is set to the eeprom value at addr),
      *  nonzero if there was a problem
      */
     int eeprom_get_byte(unsigned int uiAddress, unsigned char *byte) {
         /* Wait for completion of previous write */
         while(EECR & (1<<EEWE));
-...
         return 0;
+    }
     /** @brief get stored robot ID
+     *
      *  checks that EEPROM has been programed with an ID and returns it
+     *
      *  @return the robot id, if it is stored. If it returns 0xFF it is probably invalid
      */
     unsigned char get_robotid(void) {
         unsigned char c0, c1, c2;
-...
             return 0xFF;
+    }
     /** @brief get stored robot ID
+     *
      * checks that EEPROM has been programed with an BOM type and returns it
+     *
      *  @return the robot bom type as defined in bom.h, if it is stored. If it returns 0xFF it is probably invalid
      */
     unsigned char get_bom_type(void) {
         unsigned char c0, c1, c2, c3;

     #include <avr/interrupt.h>
     #include "spi.h"
     unsigned char spi_initd=0;
     static volatile char spi_bytes; /* number of bytes to read */
     static spi_fun_recv_t spi_recv_func; /* byte handler */
-...
+    *
     * @param recv_func The function to be called for each byte of data received.
     * @param recv_complete_func  The function to be called at the end of a complete transmission.
+    *
     * @return 0 if init succesfull, an error code otherwise
     */
     void spi_init (spi_fun_recv_t recv_func, spi_fun_recv_complete_t recv_complete_func)
     int spi_init (spi_fun_recv_t recv_func, spi_fun_recv_complete_t recv_complete_func)
+    {
         if(spi_initd) {
           return ERROR_INIT_ALREADY_INITD;
+        }
         /*  Enable Interrupt, Enable SPI Module, MSB First, Master Mode, Clock div = 64 */
         SPCR = _BV(SPE) | _BV(SPIE) /*| _BV(DORD)*/ | _BV(MSTR) | _BV(SPR1) | _BV(SPR0);
         SPSR = _BV(SPI2X);
-...
         spi_recv_complete_func = recv_complete_func;
         spi_bytes = 0;
         //usb_puts("\tspi.c Debug: SPI INITIALIZED\n");
         spi_initd=1;
         return 0;
+    }
     /**
-...
+    *
     * @param bytes The number of bytes to be transferred.
     **/
     void spi_transfer(char bytes)
     int spi_transfer(char bytes)
+    {
         if(!spi_initd)
           return ERROR_LIBRARY_NOT_INITD;
         spi_bytes = bytes;
         PORTB &= ~SS; /* Set SS low to initiate transmission */
         SPDR = 0xff; /* Initiate data transmision */
         return 0;
+    }
     ISR(SIG_SPI)

     /**
      * @file eeprom.h
      * @brief handles eeprom storage for persistent data
+     *
      * Contains functions and definitions for reading and writing to eeprom
+     *
      * @author Colony Project, Brad Neuman
      */
      #ifndef _EEPROM_H_
      #define _EEPROM_H_
      #define EEPROM_ROBOT_ID_ADDR 0x10
      #define EEPROM_BOM_TYPE_ADDR 0x14
      /** @brief store a byte to eeproem
       *  @return 0 if success, nonzero on failure
       */
      int eeprom_put_byte(unsigned int addr, unsigned char byte);
      /** @brief reads a byte from eeprom
+      *
       *  Pass it thge address and a pointer to a byte where the byte at the
       *  address will be stored
+      *
       *  @return 0 if successful (byte is set to the eeprom value at addr),
       *  nonzero if there was a problem
        */
      int eeprom_get_byte(unsigned int addr, unsigned char *byte);
      /** @brief get stored robot ID
+      *
       *  checks that EEPROM has been programed with an ID and returns it
+      *
       *  @return the robot id, if it is stored. If it returns 0xFF it is probably invalid
       */
      unsigned char get_robotid(void);
        /** @brief get stored robot ID
+      *
       * checks that EEPROM has been programed with an BOM type and returns it
+      *
       *  @return the robot bom type as defined in bom.h, if it is stored. If it returns 0xFF it is probably invalid
       */
      unsigned char get_bom_type(void);
      #endif

     /**
      * Copyright (c) 2007 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
      * restriction, including without limitation the rights to use,
      * copy, modify, merge, publish, distribute, sublicense, and/or sell
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
     /**
      * @file time.c
      * @brief Timer code
+     *
      * Implementation of functions for timers.
+     *
      * @author Colony Project, CMU Robotics Club
      **/
     /*
       time.c
       anything that requires a delay
       mostly delay_ms
       author: Robotics Club, Colony Project
       Change Log:
 .5.07 - Kevin
       Aaron fixed the orb/servo code and made them use timer3 but compare registers B and C. He hard set the prescaler
       to 8 so the RTC broke. Changed it so that we use a 8 prescaler which sets the compare match at 1/16th of a second.
       You now count how many 16ths of a second you want until you trigger your actual interrupt. Works. Changed defines
       for time so you can still call rtc_init with a scale but now it is defined in terms of actual time like second, quarter_second
       etc. Read that section in the time.h file for more information. Tested and works, though the clock drifts more than
       it used to
 .30.07 - Kevin
       Modified the clock to run on timer3 on the Dragonfly. Works with decent accuracy. Using a prescaler of 256
       the timer counts up to a precomputer value which will trigger an interrupt and reset the timer. Multiples of
 change it by that multiple. Refer to the time.h file for all possible prescalers.
       The interrupt will call a specified function _rtc_func every pulse.
       All of it has been tested and it works.
     */
     #include <avr/interrupt.h>
     #include <util/delay.h>
     #include "time.h"
     /**
      * Copyright (c) 2007 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
      * restriction, including without limitation the rights to use,
      * copy, modify, merge, publish, distribute, sublicense, and/or sell
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
     /**
      * @file time.c
      * @brief Timer code
+     *
      * Implementation of functions for timers.
+     *
      * @author Colony Project, CMU Robotics Club
      **/
     /*
       time.c
       anything that requires a delay
       mostly delay_ms
       author: Robotics Club, Colony Project
       Change Log:
 .5.07 - Kevin
       Aaron fixed the orb/servo code and made them use timer3 but compare registers B and C. He hard set the prescaler
       to 8 so the RTC broke. Changed it so that we use a 8 prescaler which sets the compare match at 1/16th of a second.
       You now count how many 16ths of a second you want until you trigger your actual interrupt. Works. Changed defines
       for time so you can still call rtc_init with a scale but now it is defined in terms of actual time like second, quarter_second
       etc. Read that section in the time.h file for more information. Tested and works, though the clock drifts more than
       it used to
 .30.07 - Kevin
       Modified the clock to run on timer3 on the Dragonfly. Works with decent accuracy. Using a prescaler of 256
       the timer counts up to a precomputer value which will trigger an interrupt and reset the timer. Multiples of
 change it by that multiple. Refer to the time.h file for all possible prescalers.
       The interrupt will call a specified function _rtc_func every pulse.
       All of it has been tested and it works.
     */
     #include <avr/interrupt.h>
     #include <util/delay.h>
     #include "time.h"
     /* Calculate how many cycles to delay for to get 1 ms. Based on F_CPU which should be defined by the makefile */
     #ifdef F_CPU
     #define WAIT_CYCLES ((F_CPU / 1000) / 10)
     #else
     #define WAIT_CYCLES (8000 / 10)
     #endif
     static volatile int _rtc_val = 0;
     static volatile int _rtc_pulse = 0;
     static volatile int _rtc_scale = 32;	//Defaults to 1 Second per pulse
     static void (*_rtc_f)(void) = 0;
     /**
      * @defgroup time Time
      * @brief Time functions
+     *
      * Functions dealing with time.
+     *
      * @{
      **/
     /**
      * Delays for the specified number of milliseconds.
     unsigned char time_initd = 0;
     static volatile int _rtc_val = 0;
     static volatile int _rtc_pulse = 0;
     static volatile int _rtc_scale = 32;	//Defaults to 1 Second per pulse
     static void (*_rtc_f)(void) = 0;
     /**
      * @defgroup time Time
      * @brief Time functions
+     *
      * Functions dealing with time.
+     *
      * @{
      **/
     /**
      * Delays for the specified number of milliseconds.
      * It depends on F_CPU to be defined in order to calculate how many cycles
      * it should delay. If it is not defined, a default clock of 8MHz is assumed.
+     *
      * We use _delay_loop_2 which will run assembly instructions that should be
      * 4 cycles long. Optimizations must be enabled for this to be true.
      * That function is called to ensure around 1ms per execution. To generate
      * multiple ms we run a for loop of how many milliseconds are desired.
      * multiple ms we run a for loop of how many milliseconds are desired.
+     *
      * The error should be just the skew on the oscillator as the formula to
      * calculate delay cycles should always be a whole number. The is some skew
      * in practice though it is unavoidable. Delaying for less than 1s should make
      * the error negligable.
+     *
      * @param ms the number of milliseconds to delay for
      **/
+     *
      * @param ms the number of milliseconds to delay for
      **/
     void delay_ms(int ms) {
         for (; ms > 0; ms--) {
             _delay_loop_2(WAIT_CYCLES);
+        }
+    }
     /* 	Prescales defined in time.h. SECOND will give you 1 second.
     	More scales are defined in the time.h file.
     	rtc_func is the address to a function that you want called every clock tick. */
     /**
      * Initializes the real time clock. Prescales are defined in time.h.
      * For example, SECOND will give 1 second. The specified function is
      * called every clock tick. For the real time clock to activate,
      * interrupts must be enabled. (through sei() )
+     *
      * @param prescale_opt the period with which the timer is triggered
      * @param rtc_func the function called when the timer is triggered
+     *
      * @see rtc_get, rtc_reset
+     *
      **/
     void rtc_init(int prescale_opt, void (*rtc_func)(void)) {
       //Clear timer register for Timer 3
       TCNT3 = 0;
       /* 	This sets the Waveform Generation Module to CTC (Clear Timer on Compare) Mode (100)
     	See page135 in Atmega128 Docs for more modes and explanations */
       TCCR3B |= _BV(WGM32);
       /* 	This sets the prescaler for the system clock (8MHz) ie: divides the clock by some number.
     	Currently set to a prescaler of 8 because that is what the orb and servos use (they are on this timer as well)
     	See page137 in Atemga128 Docs for all the available prescalers */
       TCCR3B |= _BV(CS31);
       /* 	Sets the two regsiters that we compare against. So the timer counts up to this number and
     	then resets back to 0 and calls the compare match interrupt.
 x10^6 / 8 = 1/16 Second. All values are based off of this number. Do not change it unless you
     	are l337*/
       OCR3A = 0xF424;
       /* 	Enable Output Compare A Interrupt. When OCR3A is met by the timer TCNT3 this interrupt will be
     	triggerd. (See page140 in Atmega128 Docs for more information */
       ETIMSK |= _BV(OCIE3A);
       /*	Store the pointer to the function to be used in the interrupt */
       _rtc_f = rtc_func;
       /*	Store how many 1/16ths of a second you want to let by before triggering an interrupt */
       _rtc_scale = prescale_opt;
+    }
     /**
      * Returns the time elapsed in seconds since the last call to
      * rtc_init or rtc_reset.
+     *
      * @return the number of seconds since the last call to rtc_init or rtc_reset
+     *
      * @see rtc_init, rtc_reset
      **/
     int rtc_get(void) {
       return _rtc_val;
+    }
     /**
      * Resets the real time clock counter to 0.
+     *
      * @see rtc_init, rtc_get
      **/
     void rtc_reset(void) {
       _rtc_val = 0;
+    }
     /** @} **/ //end defgroup
     /*	Called every pulse. Function in _rtc_f is called every _rtc_scale and also the counter is updated.
     	Bascially, since the pulse is hard set at 1/16s  you want to count how many 16ths of a second have passed
     	and when it reaches the amount of time you want, execute the code. */
     SIGNAL(TIMER3_COMPA_vect) {
       if (_rtc_pulse ==  _rtc_scale) {
         //Increment the real time clock counter
         _rtc_val++;
         //Calls the function tied to the real time clock if defined
         if(_rtc_f != 0)
           _rtc_f();
         //Resets the pulse until the next scale is matched
         _rtc_pulse = 0;
+      }
       //Updates the amount of pulses seen since the last scale match
       _rtc_pulse++;
+    }
     /* 	Prescales defined in time.h. SECOND will give you 1 second.
     	More scales are defined in the time.h file.
     	rtc_func is the address to a function that you want called every clock tick. */
     /**
      * Initializes the real time clock. Prescales are defined in time.h.
      * For example, SECOND will give 1 second. The specified function is
      * called every clock tick. For the real time clock to activate,
      * interrupts must be enabled. (through sei() )
+     *
      * @param prescale_opt the period with which the timer is triggered
      * @param rtc_func the function called when the timer is triggered
+     *
      * @return 0 if init succesfull, an error code otherwise
+     *
      * @see rtc_get, rtc_reset
+     *
      **/
     int rtc_init(int prescale_opt, void (*rtc_func)(void)) {
       if(time_initd) {
         return ERROR_INIT_ALREADY_INITD;
+      }
       //Clear timer register for Timer 3
       TCNT3 = 0;

Project

General

Profile

Colony

Revision 1461