Colony

     #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 sensor_matrix.h
      * @brief Definitions for sensor matrices
+     *
      * Contains functions and declarations for using sensor matrices.
+     *
      * @author Brian Coltin, Colony Project, CMU Robotics Club
      **/
     #ifndef SENSOR_MATRIX_H
     #define SENSOR_MATRIX_H
     /**
      * @defgroup sensormatrix Sensor Matrix
      * @brief the robot sensor matrix
+     *
      * These functions and structures are used for localization
      * to determine the relative directions of robots.
+     *
      * @{
      **/
     #define MAXIMUM_XBEE_ID		0x10
     #define READING_UNKNOWN		0xFF
     /**
      * @struct SensorMatrix
+     *
      * A sensor matrix.
      **/
     //TODO: the order of member variables in this struct should be changed in case the compile packs the struct
     // In order to achieve the best packing, the variables should be listed in order of decreasing memory size.
     // Thus, pointers should be first, followed by int, followed by char.
     typedef struct
+    {
     	/**
     	 * The number of robots in the token ring.
     	 **/
     	int numJoined;
     	/**
     	 * The element representing a robot is true if that robot
     	 * is in the token ring and false otherwise.
     	 **/
     	unsigned char joined[MAXIMUM_XBEE_ID];
     	// on the bayboard, we don't include the matrix to save memory.
     #ifndef BAYBOARD
     	/**
     	 * The matrix. Each row represents the readings of one
     	 * robot.
     	 **/
     	unsigned char matrix[MAXIMUM_XBEE_ID][MAXIMUM_XBEE_ID];
     #endif
     } SensorMatrix;
     /**@brief Create a sensor matrix **/
     void sensor_matrix_create(void);
     /**@brief Set a reading in a sensor matrix **/
     void sensor_matrix_set_reading(int observer, int robot, int reading);
     /**@brief Get a reading in a sensor matrix **/
     int sensor_matrix_get_reading(int observer, int robot);
     /**@brief Set whether the robot is in the token ring **/
     void sensor_matrix_set_in_ring(int robot, int in);
     /**@brief Get whether the robot is in the sensor ring **/
     int sensor_matrix_get_in_ring(int robot);
     /**@brief Get the number of robots which have joined the token ring **/
     int sensor_matrix_get_joined(void);
     /**@brief Get the maximum size of the sensor matrix **/
     int sensor_matrix_get_size(void);
     /** @} **/ //end defgroup
     #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 wireless.h
      * @brief Contains definitions for the wireless library.
+     *
      * Contains functions for the wireless library.
+     *
      * @author Brian Coltin, Colony Project, CMU Robotics Club
      **/
     #ifndef WIRELESS_H
     #define WIRELESS_H
     //Note: If this is raised above 16, we will need to do
     //something about frame numbers for TX Status packets.
     /**
      * The maximum number of packet groups.
      **/
     //TODO: a PacketGroupHandler is at least 10 bytes (I don't know if function pointers are 2 bytes
     // or 4 bytes).  That means that in the c file, your array of packet groups is at least 160 bytes.
     // Normally that might be fine (the robot's avr chips have 4k SRAM), but austin's chip only has
     // 1k SRAM, so if this number can be reduced or if the size of the struct could be reduced, that would be a plus.
     #define WL_MAX_PACKET_GROUPS 16
     /**
      * @defgroup wireless Wireless
      * @brief Wireless definitions.
+     *
      * Contains functions and definitions for dealing with wireless functionality.<br><br>
+     *
      * The wireless library provides a modular method for dealing with
      * wireless packets, by allowing packet groups to be registered.
      * A packet group is a collection of packets which share a packet
      * group code. Each packet in the group also has a type. A packet
      * group code and type are sent with each packet. When a packet
      * with a group code registered in the wireless library is
      * received, the corresponding event handler is called. The
      * event handler uses the packet type and other information
      * stored in the packet to respond.<br><br>
+     *
      * This architecture allows different wireless functionality to be
      * defined and handled separately, making it simpler and more
      * efficient to take advantage of the XBee's wireless functionality.
+     *
      * @{
      **/
     /**
      * @struct PacketGroupHandler
      * A PacketGroupHandler represents a packet group, and is used to
      * register a packet group with the wireless library. It contains
      * handlers for various events which can occur related to a packet
      * group.
      **/
     //TODO: the order of member variables in this struct should be changed in case the compile packs the struct
     // In order to achieve the best packing, the variables should be listed in order of decreasing memory size.
     // Thus, pointers should be first, followed by int, followed by char.
     typedef struct
+    {
     	/**
     	 * The group code for this packet group. This number
     	 * must be unique. The maximum number of packet groups
     	 * is defined by WL_MAX_PACKET_GROUPS.
     	 **/
       //TODO: if this number must be less than or equal to WL_MAX_PACKET_GROUPS, don't you only need
       // one byte for it and it can be made an unsigned char?
     	unsigned int groupCode;
     	/**
     	 * Called every half second (not in interrupt,
     	 * but in wl_do).
     	 **/
     	void (*timeout_handler) (void);
     	/**
     	 * Called when a transmit status packet is received
     	 * from the XBee where the first four bits of the frame
     	 * are  the group code.
+    	 *
     	 * @param frame the last four bits of the frame
     	 * @param received is true if we received an ack, 0 if
     	 * we did not.
     	 **/
     	void (*handle_response) (int frame, int received);
     	/**
     	 * Called when we receive a packet from this group.
+    	 *
     	 * @param type the packet type
     	 * @param source the 16-bit address of the XBee this
     	 * packet was sent from
     	 * @param packet the packet received
     	 * @param length the length of the packet
     	 **/
     	void (*handle_receive) (char type, int source, unsigned char* packet, int length);
     	/**
     	 * Called for any cleanup when the network is turned off.
     	 **/
     	void (*unregister) (void);
     } PacketGroupHandler;
     /**@brief Initialize the wireless library **/
     int wl_init(void);
     /**@brief Uninitialize the wireless library **/
     void wl_terminate(void);
     /**@brief Perform wireless library functionality **/
     void wl_do(void);
     /**@brief Register a packet group with the wireless library **/
     void wl_register_packet_group(PacketGroupHandler* h);
     /**@brief Unregister a packet group with the wireless library **/
     void wl_unregister_packet_group(PacketGroupHandler* h);
     /**@brief Send a packet to a specific robot in any PAN **/
     int wl_send_robot_to_robot_global_packet(char group, char type, char* data, int len, int dest, char frame);
     /**@brief Send a packet to a specific robot in our PAN **/
     int wl_send_robot_to_robot_packet(char group, char type, char* data, int len, int dest, char frame);
     /**@brief Send a packet to all robots **/
     int wl_send_global_packet(char group, char type, char* data, int len, char frame);
     /**@brief Send a packet to all robots in our PAN **/
     void wl_send_pan_packet(char group, char type, char* data, int len, char frame);
     /**@brief Set the PAN we are using **/
     int wl_set_pan(int pan);
     /**@brief Get the PAN we are using **/
     int wl_get_pan(void);
     /**@brief Set the channel we are using **/
     int wl_set_channel(int channel);
     /**@brief Get the channel we are using **/
     int wl_get_channel(void);
     /**@brief Get the 16-bit address of the XBee module **/
     int wl_get_xbee_id(void);
     /**@brief Set the com port on a computer, undefined on the robot.**/
     void wl_set_com_port(char* port);
     /** @} **/ // end defgroup
     #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 wl_token_ring.h
      * @brief Declarations for the token ring packet group
+     *
      * Contains declarations for the token ring packet group.
+     *
      * @author Brian Coltin, Colony Project, CMU Robotics Club
      **/
     #ifndef WL_TOKEN_RING_H
     #define WL_TOKEN_RING_H
     /**
      * @defgroup tokenring Token Ring
      * @brief Wireless library token ring implementation
+     *
      * This packet group is used to form a token ring, which
      * keeps track of the relative directions of the robots
      * from one another.
+     *
      * @{
      **/
     /**@brief Register the token ring group with the wireless library.**/
     int wl_token_ring_register(void);
     /**@brief Unregister the token ring group with the wirelss library.**/
     void wl_token_ring_unregister(void);
     /**@brief Set the functions called to turn the bom on and off.**/
     void wl_token_ring_set_bom_functions(void (*on_function) (void), void (*off_function) (void),
       int (*max_bom_function) (void));
     /**@brief Join the token ring **/
     int wl_token_ring_join(void);
     /**@brief Leave the token ring **/
     void wl_token_ring_leave(void);
     /**@brief Return the number of robots in the token ring **/
     int wl_token_get_robots_in_ring(void);
     /**@brief Return whether a given robot is in the token ring **/
     int wl_token_is_robot_in_ring(int robot);
     /**@brief Begin iterating through robots in the token ring **/
     void wl_token_iterator_begin(void);
     /**@brief Returns whether there are more robots to iterate through **/
     int wl_token_iterator_has_next(void);
     /**@brief Returns the ID of the next robot in the token ring **/
     int wl_token_iterator_next(void);
     /**@brief Return the latest BOM reading between two robots **/
     int wl_token_get_sensor_reading(int source, int dest);
     /**@brief Return the latest BOM reading between us and another robot **/
     int wl_token_get_my_sensor_reading(int dest);
     /**@brief Return the number of robots in the sensor matrix.*/
     int wl_token_get_num_robots(void);
     /**@brief Return the number of non-null elements in the sensor matrix*/
     int wl_token_get_matrix_size(void);
     /** @} **/ //end token ring group
     #endif

     /**
      * @file wl_basic.h
      * @brief High Level Wireless Packet Sending-Receiving Functions
+     *
      * Abstracted wireless functionality for sending and receiving packets
+     *
      * @author Christopher Mar, Colony Project, CMU Robotics Club
      **/
     /**
      * @defgroup wl_basic Wireless Basic
      * @brief Wireless abstraction for easily sending and receing packets.
+     *
      * A high level abstraction of the wireless library.
+     *
      * This will allow you to easily send and receive packets.
+     *
      * @{
      **/
     #ifndef WL_BASIC_H
     #define WL_BASIC_H
     #include "wireless.h"
     /** @brief default wireless group for basic sending and receiving packets **/
     #define WL_BASIC_GROUP 8
     /** @brief PacketGroupHandler struct for Basic Group **/
     PacketGroupHandler wl_basic_group_handler;
     /**
      * @brief struct that contains relevant packet information
      **/
     struct PacketInfo {
         char new_flag;
         char type;
         int source;
         unsigned char* data;
         int length;
     };
     /**
      * @brief current packet information, correct after wl_basic_do()
      **/
     struct PacketInfo current_packet;
     /** @brief init wireless for Basic Group **/
     int wl_basic_init( void (*handle_receive) (char type, int source, unsigned char* packet, int length) );
     /** @brief init wireless for Basic Group with default packet handling **/
     int wl_basic_init_default( void );
     /** @brief internal function to register a packet handler function **/
     void wl_basic_register_handler( void (*handle_receive) (char type, int source, unsigned char* packet, int length) );
     /** @brief send a packet to a single robot in Basic Group **/
     void wl_basic_send_robot_packet( char type, char* data, int len, int dest );
     /** @brief send a packet to all robots in Basic Group **/
     void wl_basic_send_global_packet( char type, char* data, int len );
     /** @brief internal default packet handler if none is specified on init **/
     void wl_basic_packet_receive_handler( char type, int source, unsigned char* packet, int length );
     /** @brief wrapper for wl_do() to return packet data buffer **/
     unsigned char* wl_basic_do_default( int *length );
     /** @} **/ // end defgroup
     #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 wl_defs.h
      * @brief Definitions for Wireless
+     *
      * Contains definitions for wireless packet groups, packet types,
      * debugging information, etc.
+     *
      * @author Brian Coltin, Colony Project, CMU Robotics Club
      **/
     #ifndef WL_DEFS_H
     #define WL_DEFS_H
     //comment out this line if using a computer hooked up to an xbee
     //#define ROBOT
     //uncomment this line for debug information
     //#define WL_DEBUG
     // Packet Groups and Types
     // Error group
     #define WL_ERROR_GROUP 1
     #define WL_ERROR_STRING_TYPE 1
     // Token Ring group
     #define WL_TOKEN_RING_GROUP 2
     #define WL_TOKEN_PASS 1
     #define WL_TOKEN_SENSOR_MATRIX 2
     #define WL_TOKEN_BOM_ON 3
     #define WL_TOKEN_JOIN 4
     #define WL_TOKEN_JOIN_ACCEPT 5
     // timing constants
     #ifndef FIREFLY
     #define BOM_DELAY 100
     #else
     #define BOM_DELAY 200
     #endif
     #define DEATH_DELAY 4
     #define JOIN_DELAY 8
     #ifdef WL_DEBUG
     #ifdef ROBOT
     #include <serial.h>
     #endif
     #ifdef ROBOT
     #define WL_DEBUG_PRINT( s ) usb_puts( s )
     #else
     #define WL_DEBUG_PRINT( s ) printf( s )
     #endif
     #ifdef ROBOT
     #define WL_DEBUG_PRINT_INT( i ) usb_puti(i)
     #else
     #define WL_DEBUG_PRINT_INT( i ) printf("%i", i)
     #endif
     #else
     #define WL_DEBUG_PRINT( s )
     #define WL_DEBUG_PRINT_INT( i )
     #endif
     #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 xbee.h
      * @brief Contains definitions for using the XBee
+     *
      * Contains definitions for interfacing with the
      * XBee module, from either a robot or a computer.
      * To use a robot, define ROBOT in wl_defs.h, and
      * to use a computer, don't define ROBOT.
+     *
      * @author Brian Coltin, Colony Project, CMU Robotics Club
      **/
     #ifndef XBEE_H
     #define XBEE_H
     /**
      * The port to use the XBee from on the computer.
      * Also, a backup port if the other is used.
      **/
     #ifndef ROBOT
     #define XBEE_PORT_DEFAULT "/dev/ttyUSB1"
     #endif
     /**
      * @defgroup xbee XBee
      * @brief Interface with the XBee module
+     *
      * Interface with the XBee module.
+     *
      * @{
      **/
     /*Definitions*/
     /**@brief Unset PAN, uses XBee default **/
     #define XBEE_PAN_DEFAULT 0xFFFF
     /**@brief Unset channel, uses XBee default **/
     #define XBEE_CHANNEL_DEFAULT 0
     /**@brief Broadcast to all robots in the PAN **/
     #define XBEE_BROADCAST 0xFFFF
     /**@brief No special options **/
     #define XBEE_OPTIONS_NONE 0x00
     /**@brief Do not receive a TX_STATUS message from this packet **/
     #define XBEE_OPTIONS_DISABLE_RESPONSE 0x01
     /**@brief Send the packet to all PANS **/
     #define XBEE_OPTIONS_BROADCAST_ALL_PANS 0x04
     /**@brief A transmit status packet **/
     #define XBEE_TX_STATUS 0x89
     /**@brief A packet received from another XBee **/
     #define XBEE_RX 0x81
     /**@brief Initialize the XBee library **/
     int xbee_lib_init(void);
     /**@brief Uninitialize the XBee library **/
     void xbee_terminate(void);
     /**@brief Get a packet from the XBee **/
     int xbee_get_packet(unsigned char* packet);
     /**@brief Send a packet to the XBee **/
     int xbee_send_packet(char* packet, int len, int dest, char options, char frame);
     /**@brief Set the PAN ID for the XBee **/
     int xbee_set_pan_id(int id);
     /**@brief Get the XBee's PAN ID **/
     unsigned int xbee_get_pan_id(void);
     /**@brief Set the channel the XBee is currently using **/
     int xbee_set_channel(int channel);
     /**@brief Get the channel the XBee is currently using **/
     int xbee_get_channel(void);
     /**@brief Get the XBee's 16-bit address **/
     unsigned int xbee_get_address(void);
     /**@brief Set the com port on a computer, undefined on the robot**/
     void xbee_set_com_port(char* port);
     /**@brief Reset XBee **/
     int xbee_reset(void);
     /**@}**/ //end defgroup
     #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 queue.h
      * @brief A queue implementation
+     *
      * Implements a queue, a first in, first out data structure.
+     *
      * @author Brian Coltin, Colony Project, CMU Robotics Club
      **/
     #ifndef WIRELESS_QUEUE_H
     #define WIRELESS_QUEUE_H
     #ifndef ROBOT
     #include <pthread.h>
     #endif
     struct node_def;
     /**
      * @defgroup queue Queue
      * @brief A queue implementation
+     *
      * A queue implementation.
+     *
      * @{
      **/
     /**
      * @struct Queue
      * Represents a queue, a first in, first out data structure.
      **/
     typedef struct
+    {
     	/**
     	 * The head of the queue, the next item to be removed.
     	 **/
     	struct node_def* head;
     	/**
     	 * The tail of the queue, the last item added.
     	 **/
     	struct node_def* tail;
     	/**
     	 * The number of elements in the queue.
     	 **/
     	int size;
     #ifndef ROBOT
     	pthread_mutex_t lock;
     #endif
     } Queue;
     /** @brief Create a new queue **/
     Queue* queue_create(void);
     /** @brief Destroy a queue **/
     void queue_destroy(Queue* q);
     /** @brief Add an element to a queue **/
     int queue_add(Queue* q, void* item);
     /** @brief Remove an element from a queue **/
     void* queue_remove(Queue* q);
     /** @brief Remove all instances of a given element from a queue **/
     void queue_remove_all(Queue* q, void* item);
     /** @brief Get the size of a queue **/
     int queue_size(Queue* q);
     /** @brief Check if the queue is empty **/
     int queue_is_empty(Queue* q);
     /** @} **/
     #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 wl_error_group.h
      * @brief Error Packets
+     *
      * A packet group for sending error packets.
+     *
      * @author Brian Coltin, Colony Project, CMU Robotics Club
      **/
     #ifndef WL_ERROR_GROUP_H
     #define WL_ERROR_GROUP_H
     /**
      * @file wl_error_group.h
      * @brief A packet group for error messages.
+     *
      * A packet group for sending and receiving error
      * messages.
+     *
      * @author Brian Coltin, Colony Project, CMU Robotics Club
      **/
     /**
      * @defgroup wlerror Error Packets
      * @brief Functions for sending and receiving error packets
+     *
      * Functions for sending and receiving error packets.
+     *
      * @{
      **/
     /**@brief Register this packet group with the wireless library **/
     void wl_error_register(void);
     /**@brief Unregister this packet group with the wireless library **/
     void wl_error_unregister(void);
     /**@brief Send a string in an error packet **/
     void wl_error_send_string(char* str);
     /** @} **/ // end defgroup
     #endif

     // FIXME remove
     typedef unsigned char uint8_t;
     /**
      * 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 lights.h
      * @brief Contains declarations for managing the orbs.
+     *
      * Contains declarations for using the orbs and PWM.
+     *
      * @author Colony Project, CMU Robotics Club
      * Based on Firefly Library, by Tom Lauwers and Steven Shamlian
      **/
     #ifndef _LIGHTS_H_
     #define _LIGHTS_H_
     /**
      * @addtogroup orbs
      * @{
      **/
     /**
      * Quick start: call orb_init_pwm or orb_init_binary, depending on which mode you want to use. Call orb*set or
      * orb*set_color to set the orbs.
+     *
      * The orbs have two modes of operation: PWM mode and binary mode. In PWM mode, a pwm signal is generated by a hardware
      * timer and the orbs can be set to a value of 0 through 255. In binary mode, the orbs can only be turned on or off and
      * a value of 0 means "off" and any other value means "on". The mode can be chosen on initialization and can be changed
      * at runtime using the orb_set_mode function.
+     *
      * Operation (PWM mode): On timer overflow, all LEDs with a value>0 are turned on and the output compare value for the
      * first LED is loaded. On compare match, the corresponding LED is turned off and the next output compare value is
      * loaded. All masks are precomputed and sorted by time when setting the values.
+     *
      * The data structure (pwm_t) containing the PWM times and masks is triple buffered. This is because the buffer the ISR
      * is reading from may only be modified on timer overflow before the next PWM sequence is started, because otherwise the
      * next OCR value might be sed to a value smaller than the current timer value, resulting in the remaining channels not
      * being turned off in that PWM period (flash to on). When using two buffers, the page flip can only occur on a timer
      * overflow for the same reason. So after writing a buffer and marking it for page flip, neither of the buffers could be
      * modified because the front buffer is read by the ISR and the back buffer could be switched at any time. So the
      * calling thread would have to be delayed by up to one full PWM period (8ms in the current implementation, but
      * 20ms-50ms would be a reasonable value to expect here). To avoid this, triple buffering is used.
+     *
      * The code for applying the orbs is fairly optimized. See the apply_orbs function for some time measurements and
      * further nodes.
+     *
      * The PWM frequency is 120Hz (8ms period time). The next lower frequency (determined by the prescaler) is 30 Hz which
      * is too slow (orbs flicker).
+     *
      * The orbs code is thread safe, which means that the functions may be called from another interrupt handler. If there
      * are multiple concurrent calls to the orb*set* functions, one of them is ignored and the orbs are never left in an
      * inconsistent state. For example, if the orbs are set to green by the main thread and to red by an interrupt handler,
      * the resulting color will be either red or green, but never yellow.
      * Thread safety is achieved by grabbing a lock at the beginning of all functions that modify the orb code and releasing
      * the lock at the end. If the lock is already taken, the function just returns doing nothing.
+     *
      * Some performance measurements:
      *   - Time for setting new orb values (PWM mode):       35us-72us (depending on the degree to which the array is
      *                                                                  already in the correct order)
      *   - Time for setting new orb values (binary mode):        5.5us
+     *
      *   - Interrupt time (PWM mode only):                         8us (overflow)
      *                                                            10us (output compare)
      *                                                             6us (last output compare)
      *                                                            30us (output compare, all value equal)
+     *
      *   - Maximum total interrupt time per period:               64us
      *   - Maximum CPU usage for interrupts (PWM mode only):     <0.8%
+     *
      *   - Maximum contiguous synchronized block:                 30us (output compare interrupt, all values equal)
+     *
      * There are some potential optimizations left. See the source code for more information.
+     *
      * A note on robustness: if the output compare interrupt is disabled for too long, either due to a long ISR or a long
      * synchronized code block, the orbs will flicker to brighter values for being turned off too late. With software PWM,
      * there's nothing at all to be done about that. The problem can be alleviated by using a lower PWM frequency, but then
      * the orbs will start flickering all the time due to the low update frequency.
      * Some measurements: with 100us synchronized blocks, the flickering is accepptably low. Longer synchronized blocks
      * mean more flickering. At 1ms synchronized blocks, the flickering is quite bad, especially for low orb values. Note
      * that orb value 0 never flickers at all because the corresponding channels are not turned on at all.
      * Test code (note the _delay_us restrictions!)
      *   orb_set (1,1,1); while (1) { SYNC { for (uint8_t m=0; m<10; ++m) { _delay_us(10); } } }
      **/
     /** @} **/ //end addtogroup
     /**
      * @addtogroup orbs
      * @{
      **/
     // ***** Predefined colors *****
     /** @brief Red **/
     #define RED       0xE0
     /** @brief Orange **/
     #define ORANGE    0xE4
     /** @brief Yellow **/
     #define YELLOW    0xE8
     /** @brief Lime **/
     #define LIME      0x68
     /** @brief Green **/
     #define GREEN     0x1C
     /** @brief Cyan **/
     #define CYAN      0x1F
     /** @brief Blue **/
     #define BLUE      0x03
     /** @brief Pink **/
     #define PINK      0xA6
     /** @brief Purple **/
     #define PURPLE    0x41
     /** @brief Magenta **/
     #define MAGENTA   0xE3
     /** @brief White **/
     #define WHITE     0xFE
     /** @brief Turn the orb off **/
     #define ORB_OFF   0x00
     // ***** Initialization *****
     /** @brief Enables the orbs in default mode **/
     void orb_init(void);
     /** @brief Enables the orbs in binary mode **/
     void orb_init_binary (void);
     /** @brief Enables the orbs in PWM mode **/
     void orb_init_pwm (void);
     // ***** Mode setting *****
     /** Specification of the orb mode **/
     typedef uint8_t orb_mode_t;
     /** @brief PWM mode **/
     #define orb_mode_pwm 0
     /** @brief Binary mode **/
     #define orb_mode_binary 1
     /** @brief Switches the orbs to the specified mode **/
     void orb_set_mode (orb_mode_t mode);
     /** @brief Disables the orb timer, but does not change the mode **/
     void orb_disable_timer (void);
     /** @brief Enables the orb timer, but does not change the mode **/
     void orb_enable_timer (void);
     // ***** Setting RGB colors *****
     /** @brief set the specified orb to a specified color
     * 	@deprecated This function indexes from 0 instead of 1 **/
     void orb_n_set (uint8_t num, uint8_t red, uint8_t green, uint8_t blue);
     /** @brief Set both orbs to a specified color **/
     void orb_set(uint8_t red, uint8_t green, uint8_t blue);
     /** @brief Set orb1 to a specified color **/
     void orb1_set(uint8_t red_led, uint8_t green_led, uint8_t blue_led);
     /** @brief Set orb2 to a specified color **/
     void orb2_set(uint8_t red_led, uint8_t green_led, uint8_t blue_led);
     void orbs_set (uint8_t red1, uint8_t green1, uint8_t blue1, uint8_t red2, uint8_t green2, uint8_t blue2);

Revision 1692