/ - Diff - Colony - Robotics Club

     #include "hunter_prey.h"
     #include <dragonfly_lib.h>
     #define TAG_TIME 3
     #define TAG_RANGE 150
     /**** This file should not be edited! ****/
     /*
      * The criteria for tagging are the following:
      *   * The max bom is betweed 1 and 7
      *   * The front rangefinder reads less than TAG_RANGE
      *   * -1 values from the rangefinder are ignored
      *   * These conditions are met across TAG_TIME calls to this function
      */
     unsigned char hunter_prey_tagged(int max_bom, int frontRange) {
       static int onTarget = 0;
       if(max_bom < 7 && max_bom > 1 && frontRange > 0 && frontRange < TAG_RANGE) {
         if(onTarget == 0) {
           onTarget = TAG_TIME;
           usb_puts("On target!\n");
+        }
         else {
           if(--onTarget <= 0) {
     	onTarget = 0;
     	usb_puts("TAG!\n");
     	return 1;
+          }
+        }
+      }
       else{
         //don't reset onTarget because the robot got too close
         if(frontRange > 0)
           onTarget = 0;
+      }
       return 0;
+    }

     /*
      * Hunter-Prey main.c File - Implementation of Hunter-Prey behavior which
      * 		uses finite state machines to manage the behavior. A top level
      * 		state machine controls the high level behavior switches between
      * 		"hunter" and "prey" and manages the wireless communication. Two
      * 		additional state machines control the behavior of the robot when
      * 		it is in "prey" mode and when it is in "hunter" mode.
+     *
      * Author: John Sexton, Colony Project, CMU Robotics Club
      */
     #include <dragonfly_lib.h>
     #include <wl_basic.h>
     #include "hunter_prey.h"
     #include "encoders.h"
     #define WL_CHANNEL 					24
     #define BACK_THRESHOLD 			-1000
     #define TURN_DIST						1024
     #define IR_DIST_THRESHOLD		150
     #define WAIT_DELAY_MS				2000
     /* State Macros */
     /* Top Level FSM States */
     #define TOP_INIT						0
     #define TOP_HUNTER_HUNT			1
     #define TOP_HUNTER_TAG			2
     #define TOP_HUNTER_PURSUE		3
     #define TOP_PREY_AVOID			4
     #define TOP_HUNTER_WAIT			5
     #define TOP_ERROR						6
     /* Hunter FSM States */
     #define HUNTER_SPIRAL				0
     #define HUNTER_CHASE				1
     /* Prey FSM States */
     #define PREY_START_BACK			0
     #define PREY_BACKING				1
     #define PREY_TURN						2
     #define PREY_AVOID					3
     /* Function prototype declarations */
     int hunter_FSM(int, int, int);
     int prey_FSM(int);
     /* Variables used to receive packets */
     unsigned char* packet_data;
     int data_length;
     /*  Data buffer used to send packets */
     char send_buffer[2];
     int main(void)
+    {
         /* Initialize dragonfly board */
         dragonfly_init(ALL_ON);
     		xbee_init();
     		encoders_init();
         /* Initialize the basic wireless library */
         wl_basic_init_default();
         /* Set the XBee channel to assigned channel */
         wl_set_channel(WL_CHANNEL);
         /* ****** CODE HERE ******* */
     		/* Initialize state machines */
     		int state = TOP_INIT;
     		int hunter_state = HUNTER_SPIRAL;
     		int prey_state = PREY_AVOID;
     		int frontIR = 0;
     		int maxBOM = 0;
     		int robotID = get_robotid();
     		int oldTime = 0, curTime = 0;
     		while (1) {
     			/* Check if we've received a wireless packet */
     			packet_data = wl_basic_do_default(&data_length);
     			/* Top level state machines */
     			switch(state) {
     				case TOP_INIT:
     					orbs_set_color(RED, GREEN);
     					delay_ms(500);
     					orbs_set_color(GREEN, RED);
     					delay_ms(500);
     					/* Allow user to pick the starting behavior */
     					if (button1_read()) {
     						state = TOP_PREY_AVOID;
     						prey_state = PREY_AVOID;
     					} else {
     						state = TOP_HUNTER_HUNT;
     						hunter_state = HUNTER_SPIRAL;
+    					}
     					break;
     				case TOP_HUNTER_HUNT:
     					orbs_set_color(RED, RED);
     					if (packet_data && data_length == 2
     							&& packet_data[0] == HUNTER_PREY_ACTION_ACK) {
     						/* If we've received an ACK, we need to wait */
     						state = TOP_HUNTER_WAIT;
     					} else {
     						/* Record some sensor readings and check if we can TAG */
     						bom_refresh(BOM_ALL);
     						frontIR = range_read_distance(IR2);
     						maxBOM = get_max_bom();
     						if (hunter_prey_tagged(maxBOM, frontIR)) {
     							state = TOP_HUNTER_TAG;
     						} else {
     							/* If we haven't tagged, then enter hunter FSM */
     							hunter_state = hunter_FSM(hunter_state, maxBOM, frontIR);
+    						}
+    					}
     					break;
     				case TOP_HUNTER_TAG:
     					orbs_set_color(RED, PURPLE);
     					if (packet_data && data_length == 2
     							&& packet_data[0] == HUNTER_PREY_ACTION_ACK) {
     						/* If we've received an ACK, then someone beat us to the TAG and
      						 * we need to wait. */
     						state = TOP_HUNTER_WAIT;
     					} else {
     						/* Prepare and send the TAG packet */
     						send_buffer[0] = HUNTER_PREY_ACTION_TAG;
     						send_buffer[1] = robotID;
     						wl_basic_send_global_packet(42, send_buffer, 2);
     						/* Record the time so we don't spam a TAG message on the network */
     						oldTime = rtc_get();
     						state = TOP_HUNTER_PURSUE;
+    					}
     					break;
     				case TOP_HUNTER_PURSUE:
     					orbs_set_color(RED, BLUE);
     					curTime = rtc_get();
     					if (packet_data && data_length == 2
     							&& packet_data[0] == HUNTER_PREY_ACTION_ACK) {
     						/* Check if we've received a new wireless packet */
     						if (packet_data[1] == robotID) {
     							/* We've been ACKed, so we can now become the prey */
     							state = TOP_PREY_AVOID;
     							prey_state = PREY_START_BACK;
     						} else {
     							/* If we get an ACK with a different robotID, then someone beat us
     							 * to the TAG, so we must wait */
     							state = TOP_HUNTER_WAIT;
+    						}
     					} else if (curTime - oldTime > 1) {
     						/* If 1 second has ellapsed, return to normal hunting state (we can
     						 * TAG again now) */
     						state = TOP_HUNTER_HUNT;
     					} else if (oldTime > curTime) {
     						/* If for some reason the timer overflows, or the wireless library
     						 * (which is also using the same timer) resets the timer,
     						 * reinitialize the timer so that we don't wait too long for the
     						 * timer to catch back up. */
     						oldTime = curTime;
     					} else {
     						/* If no other behavioral changes need to be made, then continue
     						 * with the hunter FSM where we left off */
     						bom_refresh(BOM_ALL);
     						frontIR = range_read_distance(IR2);
     						maxBOM = get_max_bom();
     						hunter_state = hunter_FSM(hunter_state, maxBOM, frontIR);
+    					}
     					break;
     				case TOP_PREY_AVOID:
     					orbs_set_color(GREEN, GREEN);
     					if (packet_data && data_length == 2
     							&& packet_data[0] == HUNTER_PREY_ACTION_TAG) {
     						/* Check if we've received a TAG yet. If so then send an ACK back */
     						send_buffer[0] = HUNTER_PREY_ACTION_ACK;
     						send_buffer[1] = packet_data[1];
     						wl_basic_send_global_packet(42, send_buffer, 2);
     						state = TOP_HUNTER_WAIT;
     					} else {
     						/* If we haven't received a TAG yet, continue with prey FSM */
     						bom_on();
     						prey_state = prey_FSM(prey_state);
+    					}
     					break;
     				case TOP_HUNTER_WAIT:
     					/* Set orb colors and wait to give the prey the 5 second head start */
     					orbs_set_color(BLUE, BLUE);
     					bom_off();
     					motors_off();
     					delay_ms(WAIT_DELAY_MS);
     					state = TOP_HUNTER_HUNT;
     					hunter_state = HUNTER_SPIRAL;
     					break;
     				case TOP_ERROR:
     				default:
     					orbs_set_color(PURPLE, PURPLE);
     					state = TOP_ERROR;
     					while(1);
     					break;
+    			}
+    		}
         /* ****** END HERE ******* */
         while(1);
         return 0;
+    }
     /*
      * prey_FSM - Prey finite state machine which starts by backing away, turning,
      * 		and then running and avoiding obstacles.
+     *
      * Arguments:
      * 	prey_state - Current prey state.
+     *
      * returns - The new state of the prey state machine.
      */
     int prey_FSM(int prey_state) {
     	/* Variable to store the front rangefinder readings */
     	int rangeVals[3] = {0, 0, 0};
     	switch (prey_state) {
     		case PREY_START_BACK:
     			motor_l_set(BACKWARD, 255);
     			motor_r_set(BACKWARD, 255);
     			encoder_rst_dx(LEFT);
     			encoder_rst_dx(RIGHT);
     			return PREY_BACKING;
     			break;
     		case PREY_BACKING:
     			if (encoder_get_x(LEFT) < BACK_THRESHOLD
     											|| encoder_get_x(RIGHT) < BACK_THRESHOLD) {
     				motor_l_set(BACKWARD, 255);
     				motor_r_set(FORWARD, 255);
     				encoder_rst_dx(LEFT);
     				encoder_rst_dx(RIGHT);
     				return PREY_TURN;
     			} else {
     				return PREY_BACKING;
+    			}
     			break;
     		case PREY_TURN:
     			if (encoder_get_x(LEFT) < -TURN_DIST
     											|| encoder_get_x(RIGHT) > TURN_DIST) {
     				return PREY_AVOID;
     			} else {
     				return PREY_TURN;
+    			}
     			break;
     		case PREY_AVOID:
     			rangeVals[0] = range_read_distance(IR1);
     			rangeVals[1] = range_read_distance(IR2);
     			rangeVals[2] = range_read_distance(IR3);
     			/* Drive away if we detect obstacles using the rangefinders */
     			if (rangeVals[1] > 0 && rangeVals[1] < IR_DIST_THRESHOLD) {
     				if (rangeVals[0] < rangeVals[2]) {
     					motor_l_set(FORWARD, 255);
     					motor_r_set(BACKWARD, 255);
     				} else {
     					motor_l_set(BACKWARD, 255);
     					motor_r_set(FORWARD, 255);
+    				}
     				return PREY_AVOID;
     			} else if (rangeVals[0] > 0 && rangeVals[0] < IR_DIST_THRESHOLD) {
     				motor_l_set(FORWARD, 255);
     				motor_r_set(FORWARD, 170);
     				return PREY_AVOID;
     			} else if (rangeVals[2] > 0 && rangeVals[2] < IR_DIST_THRESHOLD) {
     				motor_l_set(FORWARD, 170);
     				motor_r_set(FORWARD, 255);
     				return PREY_AVOID;
     			} else {
     				motor_l_set(FORWARD, 255);
     				motor_r_set(FORWARD, 255);
     				return PREY_AVOID;
+    			}
     			break;
     		default:
     			return PREY_AVOID;
     			break;
+    	}
     	return prey_state;
+    }
     /*
      * hunter_FSM - Hunter finite state machine which defaults to spiraling
      * 		outwards until the BOM can locate the prey. Once the BOM locates
      * 		the prey, chase the prey as fast as possible.
+     *
      * Arguments:
      * 	hunter_state - Current hunter state.
      * 	maxBOM - Current maximum BOM value.
      * 	frontIR - Current front IR rangefinder reading value.
+     *
      * returns - The new state of the hunter state machine.
      */
     int hunter_FSM(int hunter_state, int maxBOM, int frontIR) {
     	switch(hunter_state) {
     		case HUNTER_SPIRAL:
     			if (maxBOM != -1) {
     				return HUNTER_CHASE;
     			} else {
     				motor_l_set(FORWARD, 170);
     				motor_r_set(FORWARD, 190);
     				return HUNTER_SPIRAL;
+    			}
     			break;
     		case HUNTER_CHASE:
     			if (maxBOM == -1) {
     				return HUNTER_CHASE;
     			} else if (maxBOM == 4) {
     				motor_l_set(FORWARD, 255);
     				motor_r_set(FORWARD, 255);
     				return HUNTER_CHASE;
     			} else if (maxBOM == 3) {
     				motor_l_set(FORWARD, 255);
     				motor_r_set(FORWARD, 240);
     				return HUNTER_CHASE;
     			} else if (maxBOM == 5) {
     				motor_l_set(FORWARD, 240);
     				motor_r_set(FORWARD, 255);
     				return HUNTER_CHASE;
     			} else if (maxBOM < 3) {
     				motor_l_set(FORWARD, 255);
     				motor_r_set(FORWARD, 170);
     				return HUNTER_CHASE;
     			} else if (maxBOM > 5 && maxBOM <= 8) {
     				motor_l_set(FORWARD, 170);
     				motor_r_set(FORWARD, 255);
     				return HUNTER_CHASE;
     			} else if (maxBOM > 8 && maxBOM < 12) {
     				motor_l_set(BACKWARD, 255);
     				motor_r_set(FORWARD, 255);
     				return HUNTER_CHASE;
     			} else {
     				motor_l_set(FORWARD, 255);
     				motor_r_set(BACKWARD, 255);
     				return HUNTER_CHASE;
+    			}
     			break;
     		default:
     			return HUNTER_SPIRAL;
     			break;
+    	}
     	return hunter_state;
+    }

     #ifndef _HUNTER_PREY_H
     #define _HUNTER_PREY_H
     #include <inttypes.h>
     /**** This file should not be edited! ****/
     /*
      * The packet structure is 2 bytes
      * byte 0 is the action, which is one of the values below
      * byte 1 is the robot id
      */
     #define HUNTER_PREY_ACTION_TAG 'T'
     #define HUNTER_PREY_ACTION_ACK 'A'
     unsigned char hunter_prey_tagged(int max_bom, int front_rangefinder);
     #endif

     # this is a local makefile
     # Relative path to the root directory (containing lib directory)
     ifndef COLONYROOT
     COLONYROOT := ..
     # Target file name (without extension).
     TARGET = main
     # Uncomment this to use the wireless library
     USE_WIRELESS = 1
     # com1 = serial port. Use lpt1 to connect to parallel port.
     AVRDUDE_PORT = $(shell if uname -s |grep -i w32 >/dev/null; then echo 'COM4:'; else echo '/dev/ttyUSB0'; fi)
     else
     COLONYROOT := ../$(COLONYROOT)
     endif
     include $(COLONYROOT)/Makefile

     /**
      * 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 bom.h
      * @brief Definitions for using the BOM
+     *
      * This file contains definitions for using the Bearing and
      * Orientation Module (BOM).
+     *
      * @author Colony Project, CMU Robotics Club
+     *
      **/
     #ifndef _BOM_H
     #define _BOM_H
     /**
      * @addtogroup bom
      * @{
      **/
     /** @brief Include all elements in the 16-bit bitfield **/
     #define BOM_ALL 0xFFFF
     /** @brief Original BOM - No Range, No Individual LED control **/
     #define BOM10     0
     /** @brief BOM 1.5 - No Range, Individual LED control **/
     #define BOM15   1
     /** @brief RBOM - Range, Individual LED control **/
     #define RBOM    2
     /** @brief Struct for storing x and y component vector data. Used by bom_get_vector() functions **/
     typedef struct vector {
     	int x;
     	int y;
     } Vector;
     /** @brief Initialize the bom according to bom type **/
     void 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);
     /** @brief Gets the bom reading from bom_val[which].  Call bom_refresh beforehand to read new bom values. **/
     int bom_get(int which);
     /** @brief Compares all the values in bom_val[] and returns the index to the highest value element. **/
     int bom_get_max(void);
     /** @brief Computes the net resultant BOM IR vector. **/
     int bom_get_vector(Vector*, int*);
     /** @brief Computes the normalized net resultant BOM IR vector. **/
     int bom_get_norm_vector(Vector*, int*);
     /** @brief Print snapshot of BOM intensity histogram over USB connection **/
     int bom_print_usb(int*);
     /** @brief Computes the weighted average of all the bom readings to estimate the position and distance of another robot. **/
     int bom_get_max10(int *dist);
     /** @brief Enables the selected bom leds on a BOM1.5 **/
     void 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);
     /** @brief Turns off all bom leds. **/
     void bom_off(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 rangefinder.h
      * @brief Contains rangefinder declarations and functions
+     *
      * Contains functions and definitions for the use of
      * IR rangefinders.
+     *
      * @author Colony Project, CMU Robotics Club
      **/
     #ifndef _RANGEFINDER_H_
     #define _RANGEFINDER_H_
     /**
      * @addtogroup rangefinder
      * @{
      **/
     /** @brief IR Rangefinder 1 **/
     #define IR1 6
     /** @brief IR Rangefinder 2 **/
     #define IR2 5
     /** @brief IR Rangefinder 3 **/
     #define IR3 4
     /** @brief IR Rangefinder 4 **/
     #define IR4 3
     /** @brief IR Rangefinder 5 **/
     #define IR5 2
     /** @brief smallest meaningful rangefinder reading (logarithmic scale) **/
     #define MIN_IR_ADC8 27
     /** @brief largest meaningful rangefinder reading (logarithmic scale) **/
     #define MAX_IR_ADC8 98
     /** @brief Initialize the rangefinders **/
     void 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 **/
     int linearize_distance(int value);
     /** @} **/ //end addtogroup
     #endif

     /**
      * @file spi.h
      * @brief Definitions for SPI
      * @author Colony Project, CMU Robotics Club
      **/
     /**
      * @addtogroup spi
      * @{
      **/
     #ifndef __SPI_H__
     #define __SPI_H__
     #define DOUBLE_SCK 1
     #define SPR0_BIT 1
     #define MASTER 1
     #define SLAVE 0
     #define MOSI _BV(PB2)
     #define MISO _BV(PB3)
     #define SS   _BV(PB0)
     #define SCLK _BV(PB1)
     typedef void (*spi_fun_recv_t)(char);
     typedef void (*spi_fun_recv_complete_t)(void);
     /**
     * @brief Initialize SPI
+    *
     * @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);
     /**
     * @brief Initialize SPI transfer.
+    *
     * @param char The number of bytes to transfer.
     */
     void spi_transfer (char);
     /**@}**/ //end group
     #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.h
      * @brief Contains time-related functions and definitions
+     *
      * Contains functions and definitions for dealing with time,
      * namely delay_ms and the realtime clock.
+     *
      * @author Colony Project, CMU Robotics Club
      **/
     #ifndef _TIME_H_
     #define _TIME_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)
     */
     /**
      * @addtogroup time
      * @{
      **/
     /** @brief A sixteenth of a second **/
     #define SIXTEENTH_SECOND 1
     /** @brief An eighth of a second **/
     #define EIGTH_SECOND 2
     /** @brief A quarter of a second **/
     #define QUARTER_SECOND 4
     /** @brief Half of a second **/
     #define HALF_SECOND	8
     /** @brief One second **/
     #define SECOND 16
     /** @brief Two seconds **/
     #define TWO_SECOND 32
     /** @brief Four seconds **/
     #define FOUR_SECOND 64
     /** @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));
     /** @brief Reset the counter of the realtime clock **/
     void rtc_reset(void);
     /** @brief Get the value of the realtime clock. **/
     int rtc_get(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 motor.h
      * @brief Contains definitions for controlling the motors
+     *
      * Contains definitions and functions for controlling
      * the motors.
+     *
      * @author Colony Project, CMU Robotics Club
      * Based on Tom Lauwer's Firefly Library
      **/
     #ifndef _MOTOR_H
     #define _MOTOR_H
     #include <avr/io.h>
     /**
      * @addtogroup motors
      * @{
      **/
     /** @brief make the motors go forwards **/
     #define FORWARD 1
     /** @brief make the motors go backwards **/
     #define BACKWARD 0
     /** @brief Initialize the motors **/
     void 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);
     /** @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);
     /** @brief Set speed and direction of left motor **/
     void motor_l_set(int direction, int speed);
     /** @brief Set speed and direction of right motor **/
     void motor_r_set(int direction, int speed);
     /** @brief Turn the motors off **/
     void motors_off(void);
     /**@}**/ // end addtogroup
     #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 analog.h
      * @brief Contains functions and definitions for using the ADC
+     *
      * Contains definitions and function prototypes for using the
      * ADC to detect analog signals on pins AN0 - AN7.
      * AN6 and AN7 are used for the wheel and battery.
      * The pins labeled E6 and E7 are external interrupt pins and are not related
      * to analog.
      * @author Colony Project, CMU Robotics Club, based on firefly
      * originally taken from fwr analog file (author: Tom Lauwers)
      * loop code written by Kevin Woo and James Kong
      */
     #ifndef _ANALOG_H
     #define _ANALOG_H
     #include <inttypes.h>
     /**
      * @addtogroup analog
      * @{
      **/
     /** @brief Analog port 0 **/
     #define AN0 0x00
     /** @brief Analog port 1 **/
     #define AN1 0x01
     /** @brief Analog port 2 **/
     #define AN2 0x02
     /** @brief Analog port 3 **/
     #define AN3 0x03
     /** @brief Analog port 4 **/
     #define AN4 0x04
     /** @brief Analog port 5 **/
     #define AN5 0x05
     /** @brief Analog port 6 **/
     #define AN6 0x06
     /** @brief Analog port 7 **/
     #define AN7 0x07
     /** @brief Analog port 8 **/
     #define AN8 0x08
     /** @brief Analog port 9 **/
     #define AN9 0x09
     /** @brief Analog port 10 **/
     #define AN10 0x0A
     /** @brief Analog port 11 **/
     #define AN11 0x0B
     /** @brief Analog port 12 **/
     #define AN12 0x0C
     /** @brief Analog port 13 **/
     #define AN13 0x0D
     /** @brief Analog port 14 **/
     #define AN14 0x0E
     /** @brief Analog port 15 **/
     #define AN15 0x0F
     /** @brief BOM_PORT analog port for BOM **/
     #define BOM_PORT AN0
     /** @brief EXT_MUX analog port **/
     #define EXT_MUX AN7
     /** @brief Analog port for the wheel **/
     #define WHEEL_PORT AN10
     /** @brief Analog port for the battery voltage detector **/
     #define BATT_PORT  AN11
     /** @brief Analog loop status. ADC conversion running. **/
     #define ADC_LOOP_RUNNING 1
     /** @brief Analog loop status.  No ADC conversion running.**/
     #define ADC_LOOP_STOPPED 0
     /** @brief Analog init parameter. Start the analog loop. **/
     #define ADC_START 1
     /** @brief Analog init parameter. Don't start the analog loop. **/
     #define ADC_STOP  0
     #define ADMUX_OPT 0x60
     /** @brief Struct to hold the value of a particular analog port **/
     typedef struct {
       uint8_t adc8;
       uint16_t adc10;
     } adc_t;
     /** @brief Initialize analog ports. Will start running a loop
         if start_conversion is ADC_START.**/
     void 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);
     /** @brief Stops the analog loop. Doesn't do anything if the loop is already stopped. **/
     void 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. **/
     unsigned int analog8(int which);
     /** @brief Returns an 10-bit analog value from the look up table. Use this instead of analog_get10. **/
     unsigned int analog10(int which);
     /** @brief Read the position of the wheel. **/
     int wheel(void);
     /** @brief Read an 8-bit number from an analog port. Loop must be stopped for this to work. **/
     unsigned int analog_get8(int which);
     /** @brief Read a 10-bit number from an analog port. Loop must be stopped for this to work. **/
     unsigned int analog_get10(int which);
     /**@}**/ //end group
     #endif

     /**
+     *
      * @file encoders.h
      * @brief Contains functions for reading encoder values.
+     *
      * Contains high and low level functions for reading encoders
      * including reading out total distance covered, and
      * eventually velocity.
+     *
      * @author Colony Project, CMU Robotics Club
     */
     /**
      * @addtogroup encoders
      * @{
      **/
     #ifndef __ENCODERS_H__
     #define __ENCODERS_H__
     #ifndef LEFT
     	/** @brief Left wheel **/
     	#define LEFT 0
     #endif
     #ifndef RIGHT
     	/** @brief Right wheel **/
     	#define RIGHT 1
     #endif
     /** @brief Max value of valid encoder reading. **/
     #define ENCODER_MAX 1024
     /** @brief Magnet misaligned - likely distance from encoder problem. **/
     #define ENCODER_MAGNET_FAILURE 1025
     /** @brief Encoder misaligned - likely on XY plane. **/
     #define ENCODER_MISALIGNED 1027
     /** @brief Not enough time has passed - encoders not initialized in hardware. **/
     #define ENCODER_DATA_NOT_READY 1026
     /** @brief delay_ms argument after a full read is complete **/
     #define ENCODER_DELAY 20
     //Data invalid flags (hardware failure):
     #define OCF _BV(4)
     #define COF _BV(3)
     //Data invalid alarm (May be invalid):
     #define LIN _BV(2)
     #define MagINCn _BV(1)
     #define MagDECn _BV(0)
     /** @brief Buffer size **/
     #define BUFFER_SIZE 46
     #define ERR_VEL 1024
     /** @brief Initialize encoders. **/
     void encoders_init(void);
     /** @brief Read instantaneous encoder value. **/
     int encoder_read(char encoder);
     /** @brief Get total distance traveled.
      *  @note  Simply calls encoder_get_dx.
      **/
     int encoder_get_x(char encoder);
     /** @brief Get instantaneous velocity. **/
     int encoder_get_v(char encoder);
     /** @brief Get total distance traveled. **/
     int encoder_get_dx(char encoder);
     /** @brief Reset distance counter. **/
     void 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);
     /** @brief Waits for the next n encoder reading, then returns. **/
     void encoder_wait( int nReadings );
     /**@}**/ //end group
     #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 dragonfly_lib.h
      * @brief Contains other include files
+     *
      * Include this file for all the functionality of libdragonfly.
+     *
      * @author Colony Project, CMU Robotics Club
      **/
     #ifndef _DRAGONFLY_LIB_H_
     #define _DRAGONFLY_LIB_H_
     /**
      * @addtogroup dragonfly
      * @{
      **/
     // Configuration definitions
     /** @brief Initialize analog **/
     #define ANALOG 0x01
     /** @brief Initialize serial communications **/
     #define SERIAL 0x02
     /** @brief Initialize USB communications **/
     #define USB    0x02
     /** @brief Initialize communications **/
     #define COMM   0x02
     /** @brief Initialize the orb **/
     #define ORB    0x04
     /** @brief Initialize the motors **/
     #define MOTORS 0x08
     /** @brief Initialize I2C **/
     #define I2C    0x20
     /** @brief Initialize the buzzer **/
     #define BUZZER 0x40
     /** @brief Initialize the LCD screen **/
     #define LCD    0x80
     /** @brief Initialize the rangefinders **/
     #define RANGE  0x0100
     /** @brief Initialize the BOM **/
     #define BOM  0x0200
     /** @brief Initilize encoders **/
     #define ENCODERS 0x400
     /** @brief Initialize everything  **/
     #define ALL_ON 0x07FF
     /** @brief Initialize the board **/
     void dragonfly_init(int config);
     /** @} **/ //end addtogroup
     #include <inttypes.h>
     #include <avr/io.h>
     #include <avr/interrupt.h>
     #include <util/delay.h>
     #include <util/twi.h>
     // This file is included from the libdragonfly directory because it seems to be
     // missing from the AVR libc distribution.
     #include "atomic.h"
     #include "analog.h"
     #include "dio.h"
     #include "time.h"
     #include "lcd.h"
     #include "lights.h"
     #include "motor.h"
     #include "serial.h"
     #include "buzzer.h"
     #include "rangefinder.h"
     #include "bom.h"
     #include "encoders.h"
     #include "move.h"
     #include "reset.h"
     #include "math.h"
     #include "eeprom.h"
     #include <stddef.h>
     #include <stdbool.h>
     /** @brief shortcut for ATOMIC_BLOCK(ATOMIC_RESTORESTATE) **/
     #define SYNC ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
     /** @brief atomically grab a lock if it is free, return otherwise **/
     #define REQUIRE_LOCK_OR_RETURN(LOCK) do { SYNC { if (LOCK) return; LOCK=1; } } while (0)
     /** @brief atomically release a lock **/
     #define RELEASE_LOCK(LOCK) do { LOCK=0; } while (0)
     #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 serial.h
      * @brief Contains declarations for serial input and output
+     *
      * Contains definitions for serial input and output.
+     *
      * @author Colony Project, CMU Robotics Club
      * Based on Tom Lauwer's Firefly Library
+     *
      **/
     /*
       serial.h - Contains definitions and function prototypes for the RS232 serial port
       author(s): pkv
       Directions:
       Call the initialization function for the serial port you wish to use.  Then, use
       either the provided functions or the stdio functions (fprintf, etc) to read and
       write characters to the serial ports.
       UART Mapping:
       usb_*() -> UART0
       xbee_*() -> UART1
       Options: (Add the following defines to your code to configure this library)
       #define USB_BAUD { 115200 | 9600 } <= pick ONE value from in here
       #define XBEE_BAUD { 115200 | 9600 } <= pick ONE value from in here
       #define USE_STDIO
       Note: If you enable USE_STDIO, the first init function that is called will
       automatically be linked to stdin, stdout, and stderr.  To use the baud rate
       commands, add something like the following to your code:
       #define FOO_BAUD 9600
       **UNLESS YOU KNOW WHAT YOU ARE DOING, PLEASE DO NOT CHANGE THIS FILE**
       Many, many other people use this file in their code.  If you change it, you will
       probably break all of their nice code.  You should not need to change anything in
       here, except to accomodate new hardware.
     */
     #ifndef _SERIAL_H
     #define _SERIAL_H
     #include <inttypes.h>
     #include <avr/pgmspace.h>
     /**
      * @defgroup usb USB Input / Output
      * @brief Functions for USB input / output
+     *
      * Low level functions for USB input and output.
+     *
      * @{
      **/
     // if no baud rate is defined for usb, default is set here
     #ifndef USB_BAUD
     /** @brief the USB baud rate **/
     #define USB_BAUD 115200
     #endif
     /** @brief Initialize the USB **/
     void usb_init(void);
     /** @brief Print a character to USB **/
     int usb_putc(char c);
     /** @brief Read a character from USB **/
     int usb_getc(void);
     /** @brief Read a character from USB without blocking **/
     int usb_getc_nb(char *c);
     /** @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);
     /** @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);
     /** @brief Print a fixed width hexadecimal representation to USB **/
     void usb_puth8(uint8_t value);
     /** @brief Alias for usb_puth16 **/
     static inline void usb_puth (uint16_t value) { usb_puth16 (value); };
     /** @} **/ //end addtogroup
     /**
      * @defgroup xbee XBee Input / Output
      * @brief Functions for XBee input / output
+     *
      * Low level functions for XBee input and output.
+     *
      * @{
      **/
     // if no baud rate is defined for usb, default is set here
     // if no baud rate is defined for xbee, default is set here
     #ifndef XBEE_BAUD
     /** @brief the XBee baud rate **/
     #define XBEE_BAUD 9600
     #endif
     /** @brief Initialize the XBee **/
     void xbee_init(void);
     /** @brief Print a character to the XBee **/
     int xbee_putc(char c);
     /** @brief Read a character from the XBee **/
     int xbee_getc(void);
     /** @brief Read a character from the XBee without blocking **/
     int xbee_getc_nb(char *c);
     /** @} **/ //end addtogroup
     #endif

     /**
      * @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 dragonfly_def.h
      * @brief Contains definitions for dragonfly library
+     *
      * Should be included in all dragonfly library source files.
      * Does not need to be included by user programs.
+     *
      * @author Colony Project, CMU Robotics Club
      **/
     #ifndef _DRAGONFLY_DEFS_H_
     #define _DRAGONFLY_DEFS_H_
     /**
      * @addtogroup dragonfly
      * @{
      **/
     //return value definitions
     /** @brief Error code for init failure **/
     #define ERROR_INIT_FAILED 1
     /** @brief Error code for duplicate init calls **/
     #define ERROR_INIT_ALREADY_INITD 2
     /** @brief Error code for not calling init **/
     #define ERROR_LIBRARY_NOT_INITD 3
     // Configuration definitions
     /** @brief Initialize analog **/
     #define ANALOG 0x01
     /** @brief Initialize serial communications **/
     #define SERIAL 0x02
     /** @brief Initialize USB communications **/
     #define USB    0x02
     /** @brief Initialize communications **/
     #define COMM   0x02
     /** @brief Initialize the orb **/

Project

General

Profile

Colony

Revision 1692