/ - Diff - Colony - Robotics Club

Revision 1730

Added by David Schultz about 14 years ago

demos: fixing template lib folder

     /**
      * 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 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

     /**
      * @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_token_ring.c
      * @brief Token Ring Implementation
+     *
      * Implementation of the token ring packet group.
+     *
      * @author Brian Coltin, Colony Project, CMU Robotics Club
      **/
     #include <wl_token_ring.h>
     #include <stdlib.h>
     #include <wl_defs.h>
     #include <wireless.h>
     #include <sensor_matrix.h>
     #ifdef ROBOT
     #ifndef FIREFLY
     #include <bom.h>
     #endif
     #include <time.h>
     #endif
     //#define DEFAULT_SENSOR_MATRIX_SIZE 20
     /*Ring States*/
     #define NONMEMBER 0
     #define MEMBER 1
     #define JOINING 2
     #define ACCEPTED 3
     #define LEAVING 4
     /*Frame Types*/
     #define TOKEN_JOIN_ACCEPT_FRAME	1
     #define WL_TOKEN_PASS_FRAME	2
     /*Function Prototypes*/
     /*Wireless Library Prototypes*/
     static void wl_token_ring_timeout_handler(void);
     static void wl_token_ring_response_handler(int frame, int received);
     static void wl_token_ring_receive_handler(char type, int source, unsigned char* packet, int length);
     static void wl_token_ring_cleanup(void);
     /*Helper Functions*/
     static int wl_token_pass_token(void);
     static int get_token_distance(int robot1, int robot2);
     static void wl_token_get_token(void);
     /*Packet Handling Routines*/
     static void wl_token_pass_receive(int source);
     static void wl_token_sensor_matrix_receive(int source, unsigned char* sensorData, int sensorDataLength);
     static void wl_token_bom_on_receive(int source);
     static void wl_token_join_receive(int source);
     static void wl_token_join_accept_receive(int source);
     /*Global Variables*/
     //the robot we are waiting to say it has received the token. -1 if unspecified
     static int wl_token_next_robot = -1;
     //true if the robot should be in the token ring, 0 otherwise
     static int ringState = NONMEMBER;
     //the id of the robot who accepted us into the token ring, only used in ACCEPTED state
     static int acceptor = -1;
     //id of the robot we are accepting
     static int accepted = -1;
     //the counter for when we assume a robot is dead
     static int deathDelay = -1;
     //the counter for joining, before we form our own token ring
     static int joinDelay = -1;
     //current robot to check in the iterator
     static int iteratorCount = 0;
     // the amount of time a robot has had its BOM on for
     static int bom_on_count = 0;
     #ifndef ROBOT
     static void do_nothing(void) {}
     static int get_nothing(void) {return -1;}
     #endif
     #ifdef ROBOT
     #ifndef FIREFLY
     static void (*bom_on_function) (void) = bom_on;
     static void (*bom_off_function) (void) = bom_off;
     static int (*get_max_bom_function) (void) = get_max_bom;
     #else
     static void (*bom_on_function) (void) = do_nothing;
     static void (*bom_off_function) (void) = do_nothing;
     static int (*get_max_bom_function) (void) = get_nothing;
     #endif
     #else
     static void (*bom_on_function) (void) = do_nothing;
     static void (*bom_off_function) (void) = do_nothing;
     static int (*get_max_bom_function) (void) = get_nothing;
     #endif
     static PacketGroupHandler wl_token_ring_handler =
     	{WL_TOKEN_RING_GROUP, wl_token_ring_timeout_handler,
     		wl_token_ring_response_handler, wl_token_ring_receive_handler,
     		wl_token_ring_cleanup};
     /**
      * Causes the robot to join an existing token ring, or create one
      * if no token ring exists. The token ring uses global and robot to robot
      * packets, and does not rely on any PAN.
      **/
     int wl_token_ring_join()
+    {
     	WL_DEBUG_PRINT("Joining the token ring.\r\n");
     	ringState = JOINING;
     	joinDelay = DEATH_DELAY * 2;
     	if (wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_JOIN, NULL, 0, 0) != 0) {
     		return -1;
+    	}
     	return 0;
+    }
     /**
      * Causes the robot to leave the token ring. The robot stops
      * alerting others of its location, but continues storing the
      * locations of other robots.
      **/
     void wl_token_ring_leave()
+    {
     	ringState = LEAVING;
+    }
     /**
      * Initialize the token ring packet group and register it with the
      * wireless library. The robot will not join a token ring.
      **/
     int wl_token_ring_register()
+    {
     	if (wl_get_xbee_id() > 0xFF)
+    	{
     		//Note: if this becomes an issue (unlikely), we could limit sensor information
     		//to half a byte and use 12 bits for the id
     		WL_DEBUG_PRINT("XBee ID must be single byte for token ring, is ");
     		WL_DEBUG_PRINT_INT(wl_get_xbee_id());
     		WL_DEBUG_PRINT(".\r\n");
     		return -1;
+    	}
     	sensor_matrix_create();
     	//add ourselves to the sensor matrix
     	sensor_matrix_set_in_ring(wl_get_xbee_id(), 0);
     	wl_register_packet_group(&wl_token_ring_handler);
     	return 0;
+    }
     /**
      * Removes the packet group from the wireless library.
      **/
     void wl_token_ring_unregister()
+    {
     	wl_unregister_packet_group(&wl_token_ring_handler);
+    }
     /**
      * Sets the functions that are called when the BOM ought to be
      * turned on or off. This could be used for things such as
      * charging stations, which have multiple BOMs.
+     *
      * @param on_function the function to be called when the BOM
      * should be turned on
      * @param off_function the function to be called when the BOM
      * should be turned off
      * @param max_bom_function the function to be called when a
      * measurement of the maximum BOM reading is needed.
      **/
     void wl_token_ring_set_bom_functions(void (*on_function) (void),
     	void (*off_function) (void), int (*max_bom_function) (void))
+    {
     	bom_on_function = on_function;
     	bom_off_function = off_function;
     	get_max_bom_function = max_bom_function;
+    }
     /**
      * Called to cleanup the token ring packet group.
      **/
     static void wl_token_ring_cleanup()
+    {
+    }
     /**
      * Called approximately every quarter second by the wireless library.
      **/
     static void wl_token_ring_timeout_handler()
+    {
     	//someone is not responding, assume they are dead
     	if (deathDelay == 0)
+    	{
     		//pass the token to the next robot if we think someone has died
     		//also, declare that person dead, as long as it isn't us
     		if (wl_token_next_robot != wl_get_xbee_id())
+    		{
     			sensor_matrix_set_in_ring(wl_token_next_robot, 0);
     			WL_DEBUG_PRINT("Robot ");
     			WL_DEBUG_PRINT_INT(wl_token_next_robot);
     			WL_DEBUG_PRINT(" has died.\r\n");
     			wl_token_next_robot = -1;
     			deathDelay = DEATH_DELAY;
+    		}
     		// we may have been dropped from the ring when this is received
     		if (ringState == MEMBER) {
     			wl_token_pass_token();
+    		}
+    	}
     	//we must start our own token ring, no one is responding to us
     	if (joinDelay == 0)
+    	{
     		if (sensor_matrix_get_joined() == 0)
+    		{
     			WL_DEBUG_PRINT("Creating our own token ring, no robots seem to exist.\r\n");
     			sensor_matrix_set_in_ring(wl_get_xbee_id(), 1);
     			ringState = MEMBER;
     			//this will make us pass the token to ourself
     			//repeatedly, and other robots when they join
     			deathDelay = DEATH_DELAY;
     			wl_token_next_robot = wl_get_xbee_id();
+    		}
     		else
+    		{
     			WL_DEBUG_PRINT("Attempting to join the token ring again.\r\n");
     			//attempt to rejoin with a random delay
           //TODO: should we use the constant JOIN_DELAY ?
     			wl_token_ring_join();
     			joinDelay = rand() / (RAND_MAX / JOIN_DELAY) + 1;
+    		}
+    	}
     	if (deathDelay >= 0) {
     		deathDelay--;
+    	}
     	if (joinDelay >= 0) {
     		joinDelay--;
+    	}
     	if (bom_on_count >= 0) {
     		bom_on_count++;
+    	}
+    }
     /**
      * Called when the XBee tells us if a packet we sent has been received.
+     *
      * @param frame the frame number assigned when the packet was sent
      * @param received 1 if the packet was received, 0 otherwise
      **/
     static void wl_token_ring_response_handler(int frame, int received)
+    {
     	if (!received)
+    	{
     		WL_DEBUG_PRINT("FAILED.\r\n");
+    	}
+    }
     /**
      * Called when we recieve a token ring packet.
      * @param type the type of the packet
      * @param source the id of the robot who sent the packet
      * @param packet the data in the packet
      * @param length the length of the packet in bytes
      **/
     static void wl_token_ring_receive_handler(char type, int source, unsigned char* packet, int length)
+    {
     	switch (type)
+    	{
     		case WL_TOKEN_PASS:
     			wl_token_pass_receive(source);
     			break;
     		case WL_TOKEN_SENSOR_MATRIX:
     			wl_token_sensor_matrix_receive(source, packet, length);
     			break;
     		case WL_TOKEN_BOM_ON:
     			//add the robot to the sensor matrix if it is not already there
     			wl_token_bom_on_receive(source);
     			break;
     		case WL_TOKEN_JOIN:
     			wl_token_join_receive(source);
     			break;
     		case WL_TOKEN_JOIN_ACCEPT:
     			wl_token_join_accept_receive(source);
     			break;
     		default:
     			WL_DEBUG_PRINT("Unimplemented token ring packet received.\r\n");
     			break;
+    	}
+    }
     /**
      * Returns the BOM reading robot source has for robot dest.
+     *
      * @param source the robot that made the BOM reading
      * @param dest the robot whose relative location is returned
+     *
      * @return a BOM reading from robot source to robot dest,
      * in the range 0-15, or -1 if it is unknown
      **/
     int wl_token_get_sensor_reading(int source, int dest)
+    {
     	if (wl_token_is_robot_in_ring(dest) &&
     			(source == wl_get_xbee_id() || wl_token_is_robot_in_ring(source))) {
     		return sensor_matrix_get_reading(source, dest);
+    	}
     	return -1;
+    }
     /**
      * Returns the BOM reading we have for robot dest.
+     *
      * @param dest the robot whose relative location is returned
+     *
      * @return a BOM reading from us to robot dest, in the range
      * 0-15, or -1 if it is unkown
      **/
     int wl_token_get_my_sensor_reading(int dest)
+    {
     	return wl_token_get_sensor_reading(wl_get_xbee_id(), dest);
+    }
     /**
      * Returns the number of robots in the token ring.
+     *
      * @return the number of robots in the token ring
      **/
     int wl_token_get_robots_in_ring(void)
+    {
     	return sensor_matrix_get_joined();
+    }
     /**
      * Returns true if the specified robot is in the token ring, false
      * otherwise.
+     *
      * @param robot the robot to check for whether it is in the token ring
      * @return nonzero if the robot is in the token ring, zero otherwise
      **/
     int wl_token_is_robot_in_ring(int robot)
+    {
     	return sensor_matrix_get_in_ring(robot);
+    }
     /**
      * Begins iterating through the robots in the token ring.
+     *
      * @see wl_token_iterator_has_next, wl_token_iterator_next
      **/
     void wl_token_iterator_begin(void)
+    {
     	int i = 0;
       //TODO: the compiler may or may not optimize this such that my comment is useless:
       // instead of calling sensor_matrix_get_size every iteration of the while loop and incurring
       // the overhead of a function call each iteration, call it only once before the loop and store
       // the value in a variable and check against that variable in the loop condition
     	while (!sensor_matrix_get_in_ring(i) && i < sensor_matrix_get_size()) {
     		i++;
+    	}
       //TODO: if you do the above comment, then you can compare this to the variable also
     	if (i == sensor_matrix_get_size()) {
     		i = -1;
+    	}
     	iteratorCount = i;
+    }
     /**
      * Returns true if there are more robots in the token ring
      * to iterate through, and false otherwise.
+     *
      * @return nonzero if there are more robots to iterate through,
      * zero otherwise
+     *
      * @see wl_token_iterator_begin, wl_token_iterator_next
      **/
     int wl_token_iterator_has_next(void)
+    {
     	return iteratorCount != -1;
+    }
     /**
      * Returns the next robot ID in the token ring.
+     *
      * @return the next robot ID in the token ring, or -1 if none exists
+     *
      * @see wl_token_iterator_begin, wl_token_iterator_has_next
      **/
     int wl_token_iterator_next(void)
+    {
     	int result = iteratorCount;
     	if (result < 0) {
     		return result;
+    	}
       //TODO: the compiler may or may not optimize this such that my comment is useless:
       // instead of calling sensor_matrix_get_size every iteration of the while loop and incurring
       // the overhead of a function call each iteration, call it only once before the loop and store
       // the value in a variable and check against that variable in the loop condition
     	iteratorCount++;
     	while (!sensor_matrix_get_in_ring(iteratorCount)
     		&& iteratorCount < sensor_matrix_get_size()) {
     		iteratorCount++;
+    	}
       //TODO: if you do the above comment, then you can compare this to the variable also
     	if (iteratorCount == sensor_matrix_get_size()) {
     		iteratorCount = -1;
+    	}
     	return result;
+    }
     /**
      * Returns the number of robots currently in the token ring.
+     *
      * @return the number of robots in the token ring
      **/
     int wl_token_get_num_robots(void)
+    {
     	return sensor_matrix_get_joined();
+    }
     /**
      * Returns the number of robots in the sensor matrix.
+     *
      * @return the number of robots in the sensor matrix
      **/
     int wl_token_get_matrix_size(void)
+    {
     	return sensor_matrix_get_size();
+    }
     /**
      * This method is called when we receive a token pass packet.
+     *
      * @param source the robot who passed the token to us.
      **/
     static void wl_token_pass_receive(int source)
+    {
     	WL_DEBUG_PRINT("Received token from ");
     	WL_DEBUG_PRINT_INT(source);
     	WL_DEBUG_PRINT(", expected ");
     	WL_DEBUG_PRINT_INT(wl_token_next_robot);
     	WL_DEBUG_PRINT(".\n");
     	// this prevents two tokens from being passed around at a time (second clause is in case we are joining)
     	if ((source != wl_token_next_robot && wl_get_xbee_id() != wl_token_next_robot) && bom_on_count <= DEATH_DELAY / 2 &&
     		ringState != ACCEPTED)
+    	{
     		WL_DEBUG_PRINT("Received token pass when a robot should not have died yet.\n");
     		WL_DEBUG_PRINT("There are probably two tokens going around, packet ignored.\n");
     		return;
+    	}
     	bom_on_count = -1;
     	deathDelay = -1;
     	sensor_matrix_set_in_ring(source, 1);
     	wl_token_get_token();
+    }
     /**
      * This method is called when we receive a token pass packet.
      * @param source is the robot it came from
      * @param nextRobot is the robot the token was passed to
      * @param sensorData a char with an id followed by a char with the sensor
      *		reading for that robot, repeated for sensorDataLength bytes
      * @param sensorDataLength the length in bytes of sensorData
      */
     static void wl_token_sensor_matrix_receive(int source, unsigned char* sensorData, int sensorDataLength)
+    {
     	int i, j;
     	char nextRobot;
     	bom_on_count = -1;
     	deathDelay = -1;
     	sensor_matrix_set_in_ring(source, 1);
     	//with this packet, we are passed the id of the next robot in the ring
     	//and the sensor matrix, a list of id and sensor reading pairs (two bytes for both)
     	j = 0;
       //TODO: the compiler may or may not optimize this such that my comment is useless:
       // instead of calling sensor_matrix_get_size every iteration of the while loop and incurring
       // the overhead of a function call each iteration, call it only once before the loop and store
       // the value in a variable and check against that variable in the loop condition
     	for (i = 0; i < sensor_matrix_get_size(); i++)
+    	{
     		if (i == source) {
     			continue;
+    		}
     		//set the sensor information we receive
     		if (j < sensorDataLength / 2 && sensorData[2 * j] == i)
+    		{
     			//the robot we were going to accept has already been accepted
     			if (accepted == i)
+    			{
     				accepted = -1;
     				WL_DEBUG_PRINT("Someone accepted the robot we did.\r\n");
+    			}
     			sensor_matrix_set_reading(source, i,
     						sensorData[2 * j + 1]);
     			if (!sensor_matrix_get_in_ring(i))
+    			{
     				WL_DEBUG_PRINT("Robot ");
     				WL_DEBUG_PRINT_INT(i);
     				WL_DEBUG_PRINT(" has been added to the sensor matrix of robot ");
     				WL_DEBUG_PRINT_INT(wl_get_xbee_id());
     				WL_DEBUG_PRINT(" due to a packet from robot ");
     				WL_DEBUG_PRINT_INT(source);
     				WL_DEBUG_PRINT(".\r\n");
+    			}
     			sensor_matrix_set_in_ring(i, 1);
     			j++;
+    		}
     		else
+    		{
     			if (sensor_matrix_get_in_ring(i))
+    			{
     				WL_DEBUG_PRINT("Robot ");
     				WL_DEBUG_PRINT_INT(i);
     				WL_DEBUG_PRINT(" has been removed from the sensor matrix of robot ");
     				WL_DEBUG_PRINT_INT(wl_get_xbee_id());
     				WL_DEBUG_PRINT(" due to a packet from robot ");
     				WL_DEBUG_PRINT_INT(source);
     				WL_DEBUG_PRINT(".\r\n");
     				sensor_matrix_set_in_ring(i, 0);
+    			}
     			if (i == wl_get_xbee_id() && ringState == MEMBER)
+    			{
     				ringState = NONMEMBER;
     				wl_token_ring_join();
     				WL_DEBUG_PRINT("We have been removed from the ring ");
     				WL_DEBUG_PRINT("and are rejoining.\r\n");
+    			}
     			//the person who accepted us is dead... let's ask again
     			if (i == acceptor)
+    			{
     				sensor_matrix_set_in_ring(wl_get_xbee_id(), 0);
     				ringState = NONMEMBER;
     				acceptor = -1;
     				wl_token_ring_join();
+    			}
+    		}
+    	}
     	// get the next robot in the token ring
     	i = source + 1;
     	while (1)
+    	{
     		if (i == sensor_matrix_get_size()) {
     			i = 0;
+    		}
     		if (sensor_matrix_get_in_ring(i) || i == source)
+    		{
     			nextRobot = (char)i;
     			break;
+    		}
     		i++;
+    	}
     	if (nextRobot != wl_get_xbee_id())
     		wl_token_next_robot = nextRobot;
     	deathDelay = get_token_distance(wl_get_xbee_id(), nextRobot) * DEATH_DELAY;
     	if (sensor_matrix_get_joined() == 0 && ringState == JOINING)
     		wl_send_robot_to_robot_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_PASS, NULL, 0, nextRobot, WL_TOKEN_PASS_FRAME);
+    }
     /**
      * Gets the distance in the token ring between two robots.
+     *
      * @param robot1 the first robot
      * @param robot2 the second robot
+     *
      * @return the number of passes before the token is expected
      * to reach robot2 from robot1
      **/
     static int get_token_distance(int robot1, int robot2)
+    {
     	int curr = robot1 + 1;
     	int count = 1;
     	while (1)
+    	{
         //TODO: the compiler may or may not optimize this such that my comment is useless:
         // instead of calling sensor_matrix_get_size every iteration of the while loop and incurring
         // the overhead of a function call each iteration, call it only once before the loop and store
         // the value in a variable and check against that variable in the loop condition
     		if (curr == sensor_matrix_get_size())
     			curr = 0;
     		if (curr == robot2)
     			break;
     		if (sensor_matrix_get_in_ring(curr))
     			count++;
     		curr++;
+    	}
     	return count;
+    }
     /**
      * Passes the token to the next robot in the token ring.
      **/
     static int wl_token_pass_token()
+    {
     	char nextRobot = 0xFF;
     	int i = wl_get_xbee_id() + 1;
     	char buf[2 * sensor_matrix_get_size()];
     	if (accepted == -1)
+    	{
     		while (1)
+    		{
           //TODO: the compiler may or may not optimize this such that my comment is useless:
           // instead of calling sensor_matrix_get_size every iteration of the while loop and incurring
           // the overhead of a function call each iteration, call it only once before the loop and store
           // the value in a variable and check against that variable in the loop condition
     			if (i == sensor_matrix_get_size()) {
     				i = 0;
+    			}
     			if (sensor_matrix_get_in_ring(i))
+    			{
     				nextRobot = (char)i;
     				break;
+    			}
     			i++;
+    		}
+    	}
     	else
+    	{
     		WL_DEBUG_PRINT("Accepting new robot, sending it the token.\r\n");
     		//add a new robot to the token ring
     		sensor_matrix_set_in_ring(accepted, 1);
     		nextRobot = accepted;
     		accepted = -1;
+    	}
     	int j = 0;
       //TODO: the compiler may or may not optimize this such that my comment is useless:
       // instead of calling sensor_matrix_get_size every iteration of the while loop and incurring
       // the overhead of a function call each iteration, call it only once before the loop and store
       // the value in a variable and check against that variable in the loop condition
     	for (i = 0; i < sensor_matrix_get_size(); i++) {
     		if (sensor_matrix_get_in_ring(i) && i != wl_get_xbee_id())
+    		{
     			buf[2*j] = i;
     			buf[2*j + 1] = sensor_matrix_get_reading(wl_get_xbee_id(), i);
     			j++;
+    		}
+    	}
     	int packetSize = 2 * j * sizeof(char);
     	WL_DEBUG_PRINT("Passing the token to robot ");
     	WL_DEBUG_PRINT_INT(nextRobot);
     	WL_DEBUG_PRINT(".\r\n");
     	if (wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_SENSOR_MATRIX, buf, packetSize, 0) != 0)
     		return -1;
     	if (wl_send_robot_to_robot_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_PASS, NULL, 0, nextRobot, WL_TOKEN_PASS_FRAME))
     		return -1;
     	wl_token_next_robot = nextRobot;
     	deathDelay = DEATH_DELAY;
     	return 0;
+    }
     /**
      * Called when a packet is received stating that another robot has turned
      * its BOM on. Our BOM is then read, and the data is added to the sensor
      * matrix.
+     *
      * @param source the robot whose BOM is on
      **/
     static void wl_token_bom_on_receive(int source)
+    {
     	int max;
     	WL_DEBUG_PRINT("Robot ");
     	WL_DEBUG_PRINT_INT(source);
     	WL_DEBUG_PRINT(" has flashed its bom.\r\n");
     	bom_on_count = 0;
     	max = get_max_bom_function();
     	sensor_matrix_set_reading(wl_get_xbee_id(),
     		source, max);
     	WL_DEBUG_PRINT("Max: ");
     	WL_DEBUG_PRINT_INT(max);
     	WL_DEBUG_PRINT("\n\n");
+    }
     /**
      * This method is called when we receive the token. Upon receiving
      * the token, we must send a BOM_ON packet, flash the BOM, and send
      * the token to the next robot.
+     *
      * If there is a pending request for the token, this is processed first.
      **/
     static void wl_token_get_token()
+    {
     	WL_DEBUG_PRINT("We have the token.\r\n");
     	if (ringState == ACCEPTED)
+    	{
     		sensor_matrix_set_in_ring(wl_get_xbee_id(), 1);
     		WL_DEBUG_PRINT("Now a member of the token ring.\r\n");
     		ringState = MEMBER;
     		joinDelay = -1;
+    	}
     	if (ringState == LEAVING || ringState == NONMEMBER)
+    	{
     		sensor_matrix_set_in_ring(wl_get_xbee_id(), 0);
     		if (ringState == NONMEMBER)
+    		{
     			WL_DEBUG_PRINT("We should have left the token ring, but didn't.\r\n");
+    		}
     		return;
+    	}
     	WL_DEBUG_PRINT("Our BOM has been flashed.\r\n");
     	wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_BOM_ON, NULL, 0, 0);
     	bom_on_function();
     	#ifdef ROBOT
     	delay_ms(BOM_DELAY);
     	#endif
     	bom_off_function();
     	if (!sensor_matrix_get_in_ring(wl_get_xbee_id()))
+    	{
     		WL_DEBUG_PRINT("Removed from sensor matrix while flashing BOM.\r\n");
     		return;
+    	}
     	wl_token_pass_token();
+    }
     /**
      * Called when a request to join the token ring is received.
      * If we are the robot preceding the requester in the ring,
      * we respond with a JOIN_ACCEPT packet and pass the token to
      * this robot when we receive the token.
+     *
      * @param source the robot who requested to join
      **/
     static void wl_token_join_receive(int source)
+    {
     	WL_DEBUG_PRINT("Received joining request from robot ");
     	WL_DEBUG_PRINT_INT(source);
     	WL_DEBUG_PRINT(".\r\n");
     	//we cannot accept the request if we are not a member
     	if (ringState != MEMBER)
     		return;
     	//if they didn't get our response, see if we should respond again
     	if (accepted == source)
     		accepted = -1;
     	//we can only accept one request at a time
     	if (accepted != -1)
     		return;
     	//check if we are the preceding robot in the token ring
     	int i = source - 1;
     	while (1)
+    	{
     		if (i < 0)
     			i = sensor_matrix_get_size() - 1;
     		//we must send a join acceptance
     		if (i == wl_get_xbee_id())
     			break;
     		//another robot will handle it
     		if (sensor_matrix_get_in_ring(i))
     			return;
     		i--;
+    	}
     	accepted = source;
     	wl_send_robot_to_robot_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_JOIN_ACCEPT,
     		NULL, 0, source, TOKEN_JOIN_ACCEPT_FRAME);
     	WL_DEBUG_PRINT("Accepting robot ");
     	WL_DEBUG_PRINT_INT(source);
     	WL_DEBUG_PRINT(" into the token ring.\r\n");
     	// the token ring has not started yet
     	if (sensor_matrix_get_joined() == 1)
     		wl_token_pass_token();
+    }
     /**
      * Called when we receive a JOIN_ACCEPT packet in attempting to join
      * the token ring.
      * Our attempt to join the ring is stopped, and we wait for the token.
+     *
      * @param source the robot who accepted us
      **/
     static void wl_token_join_accept_receive(int source)
+    {
     	WL_DEBUG_PRINT("Accepted into the token ring by robot ");
     	WL_DEBUG_PRINT_INT(source);
     	WL_DEBUG_PRINT(".\r\n");
     	joinDelay = JOIN_DELAY;
     	ringState = ACCEPTED;
     	acceptor = source;
     	//add ourselves to the token ring
     	sensor_matrix_set_in_ring(wl_get_xbee_id(), 1);
+    }

     /**
      * 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 wireless group for sending error packets.
+     *
      * @author Brian Coltin, Colony Project, CMU Robotics Club
      **/
     #include "wl_error_group.h"
     #include "wireless.h"
     #include "wl_defs.h"
     #include <string.h>
     void wl_error_response_receive(int frame, int received);
     void wl_error_handle_receive(char type, int source, unsigned char* packet,
     							int length);
     PacketGroupHandler wl_error_handler =
     		{WL_ERROR_GROUP, NULL,
     		wl_error_response_receive, wl_error_handle_receive, NULL};
     void wl_error_response_receive(int frame, int received)
+    {
     	WL_DEBUG_PRINT("Response received.\r\n");
     	if (!received)
+    	{
     		WL_DEBUG_PRINT("FAILED.\r\n");
+    	}
+    }
     /**
      * Register this packet group with the wireless library.
      * This function must be called before any other wl_error
      * function.
      **/
     void wl_error_register(void)
+    {
     	wl_register_packet_group(&wl_error_handler);
+    }
     /**
      * Unregister this packet group with the wireless library.
      * This function must be called after wl_error_register.
+     *
      * @see wl_error_register
      **/
     void wl_error_unregister(void)
+    {
     	wl_unregister_packet_group(&wl_error_handler);
+    }
     /**
      * Handles receiving an error packet.
+     *
      * @param type the packet type
      * @param source the 16-bit address of the packet's sender
      * @param packet the packet data
      * @param length the length in bytes of the packet
      **/
     void wl_error_handle_receive(char type, int source, unsigned char* packet,
     							int length)
+    {
     	switch (type)
+    	{
     		case WL_ERROR_STRING_TYPE:
     			if (packet[length - 1] != 0)
+    			{
     				WL_DEBUG_PRINT(
     					"Error packet string should be null terminated.\r\n");
     				break;
+    			}
     			WL_DEBUG_PRINT("Error packet received from robot ");
     			WL_DEBUG_PRINT_INT(source);
     			WL_DEBUG_PRINT(":\r\n");
     			WL_DEBUG_PRINT((char*)packet);
     			WL_DEBUG_PRINT("\r\n");
     			break;
     		default:
     			WL_DEBUG_PRINT("Error packet of unknown type received.\r\n");
     			break;
+    	}
+    }
     /**
      * Send an error message as a string.
+     *
      * @param str the error message to send
      **/
     void wl_error_send_string(char* str)
+    {
     	wl_send_global_packet(WL_ERROR_GROUP, WL_ERROR_STRING_TYPE,
     		str, strlen(str) + 1, 1);
+    }

     /**
      * 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

     /**
      * 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.c
      * @brief Wireless Library Implementation
+     *
      * Implementation of the wireless library.
+     *
      * @author Brian Coltin, Colony Project, CMU Robotics Club
      **/
     #include "wireless.h"
     #include "xbee.h"
     #include <stddef.h>
     #ifdef WL_DEBUG
     #include <stdio.h>
     #endif
     #include "wl_defs.h"
     #ifndef ROBOT
     	#include <sys/time.h>
     	#include <signal.h>
     #else
     	#include <time.h>
     	#include <bom.h>
     #endif
     /*Function Prototypes*/
     static void wl_do_timeout(void);
     //Note: the actual frame sent has group as the first four bits and
     //frame as the last four.
     static int wl_send_packet(char group, char type, char* data, int len, int dest, char options, char frame);
     /*Data Members*/
     //used to store incoming and outgoing packets
     //TODO: does this need to be 128?  can it be smaller to save memory?
     //TODO: this shouldn't be hardcoded as 128.  it should be a define.
     static unsigned char wl_buf[128];
     //1 if we have timed out since we last checked, 0 otherwise.
     static int wl_timeout = 0;
     static PacketGroupHandler* wl_packet_groups[WL_MAX_PACKET_GROUPS];
     #ifndef ROBOT
     //called when we time out, or receive interrupt
     static void sig_handler(int signo)
+    {
     	switch (signo)
+    	{
     		case SIGALRM:
     			wl_timeout = 1;
     			break;
     		case SIGINT:
     			wl_terminate();
     			exit(1);
     			break;
+    	}
     	return;
+    }
     #else
     //called when the timer ticks
     static void timer_handler(void)
+    {
     	wl_timeout = 1;
+    }
     #endif
     /**
      * Initializes the wireless library. Must be called before any
      * other function.
+     *
      * @param wl_port File descriptor for wireless port, or NULL for default.
      **/
     int wl_init()
+    {
     	int i;
       //TODO: using memset here instead of this loop, *might* be less instructions and *might* reduce code size but not sure
     	for (i = 0; i < WL_MAX_PACKET_GROUPS; i++)
     		wl_packet_groups[i] = NULL;
     	if (xbee_lib_init() == -1) {
     		return -1;
+    	}
     	//begin timeout timer
     #ifdef ROBOT
     #ifdef FIREFLY
     	rtc_init(PRESCALE_DIV_256, 32, &timer_handler);
     #else
     	//TODO: FIX THIS
     	#ifdef BAYBOARD
     	rtc_init(10 * HALF_SECOND, &timer_handler);
     	#else
     	rtc_init(HALF_SECOND, &timer_handler);
     	#endif
     #endif
     #else
     	//create our timer
     	struct itimerval timer_val;
     	struct timeval interval;
     	interval.tv_sec = 0;
     	interval.tv_usec = 500000;
     	struct timeval first_time;
     	first_time.tv_sec = 0;
     	first_time.tv_usec = 500000;
     	timer_val.it_interval = interval;
     	timer_val.it_value = first_time;
     	if(setitimer(ITIMER_REAL,&timer_val,NULL)==-1)
+    	{
     		WL_DEBUG_PRINT("Error creating a timer.\r\n");
     		perror("Failure's cause");
     		exit(1);
+    	}
     	//create signal handler
     	struct sigaction wl_sig_act;
     	wl_sig_act.sa_handler = sig_handler;
     	wl_sig_act.sa_flags = 0;
     	sigemptyset(&wl_sig_act.sa_mask);
     	sigaction(SIGALRM, &wl_sig_act, 0);

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Project

General

Profile

Colony

Revision 1730