Colony - / - Diff - Robotics Club

Revision 1784

     /**
      * 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);
+    }

     # Doxyfile 1.4.6
     # This file describes the settings to be used by the documentation system
     # doxygen (www.doxygen.org) for a project
+    #
     # All text after a hash (#) is considered a comment and will be ignored
     # The format is:
     #       TAG = value [value, ...]
     # For lists items can also be appended using:
     #       TAG += value [value, ...]
     # Values that contain spaces should be placed between quotes (" ")
     #---------------------------------------------------------------------------
     # Project related configuration options
     #---------------------------------------------------------------------------
     # The PROJECT_NAME tag is a single word (or a sequence of words surrounded
     # by quotes) that should identify the project.
     PROJECT_NAME           = libwireless
     # The PROJECT_NUMBER tag can be used to enter a project or revision number.
     # This could be handy for archiving the generated documentation or
     # if some version control system is used.
     PROJECT_NUMBER         = 1.0
     # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
     # base path where the generated documentation will be put.
     # If a relative path is entered, it will be relative to the location
     # where doxygen was started. If left blank the current directory will be used.
     OUTPUT_DIRECTORY       = docs
     # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
     # 4096 sub-directories (in 2 levels) under the output directory of each output
     # format and will distribute the generated files over these directories.
     # Enabling this option can be useful when feeding doxygen a huge amount of
     # source files, where putting all generated files in the same directory would
     # otherwise cause performance problems for the file system.
     CREATE_SUBDIRS         = NO
     # The OUTPUT_LANGUAGE tag is used to specify the language in which all
     # documentation generated by doxygen is written. Doxygen will use this
     # information to generate all constant output in the proper language.
     # The default language is English, other supported languages are:
     # Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish,
     # Dutch, Finnish, French, German, Greek, Hungarian, Italian, Japanese,
     # Japanese-en (Japanese with English messages), Korean, Korean-en, Norwegian,
     # Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish,
     # Swedish, and Ukrainian.
     OUTPUT_LANGUAGE        = English
     # This tag can be used to specify the encoding used in the generated output.
     # The encoding is not always determined by the language that is chosen,
     # but also whether or not the output is meant for Windows or non-Windows users.
     # In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES
     # forces the Windows encoding (this is the default for the Windows binary),
     # whereas setting the tag to NO uses a Unix-style encoding (the default for
     # all platforms other than Windows).
     USE_WINDOWS_ENCODING   = NO
     # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
     # include brief member descriptions after the members that are listed in
     # the file and class documentation (similar to JavaDoc).
     # Set to NO to disable this.
     BRIEF_MEMBER_DESC      = YES
     # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
     # the brief description of a member or function before the detailed description.
     # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
     # brief descriptions will be completely suppressed.
     REPEAT_BRIEF           = YES
     # This tag implements a quasi-intelligent brief description abbreviator
     # that is used to form the text in various listings. Each string
     # in this list, if found as the leading text of the brief description, will be
     # stripped from the text and the result after processing the whole list, is
     # used as the annotated text. Otherwise, the brief description is used as-is.
     # If left blank, the following values are used ("$name" is automatically
     # replaced with the name of the entity): "The $name class" "The $name widget"
     # "The $name file" "is" "provides" "specifies" "contains"
     # "represents" "a" "an" "the"
     ABBREVIATE_BRIEF       =
     # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
     # Doxygen will generate a detailed section even if there is only a brief
     # description.
     ALWAYS_DETAILED_SEC    = NO
     # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
     # inherited members of a class in the documentation of that class as if those
     # members were ordinary class members. Constructors, destructors and assignment
     # operators of the base classes will not be shown.
     INLINE_INHERITED_MEMB  = NO
     # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
     # path before files name in the file list and in the header files. If set
     # to NO the shortest path that makes the file name unique will be used.
     FULL_PATH_NAMES        = YES
     # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
     # can be used to strip a user-defined part of the path. Stripping is
     # only done if one of the specified strings matches the left-hand part of
     # the path. The tag can be used to show relative paths in the file list.
     # If left blank the directory from which doxygen is run is used as the
     # path to strip.
     STRIP_FROM_PATH        =
     # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
     # the path mentioned in the documentation of a class, which tells
     # the reader which header file to include in order to use a class.
     # If left blank only the name of the header file containing the class
     # definition is used. Otherwise one should specify the include paths that
     # are normally passed to the compiler using the -I flag.
     STRIP_FROM_INC_PATH    =
     # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
     # (but less readable) file names. This can be useful is your file systems
     # doesn't support long names like on DOS, Mac, or CD-ROM.
     SHORT_NAMES            = NO
     # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
     # will interpret the first line (until the first dot) of a JavaDoc-style
     # comment as the brief description. If set to NO, the JavaDoc
     # comments will behave just like the Qt-style comments (thus requiring an
     # explicit @brief command for a brief description.
     JAVADOC_AUTOBRIEF      = NO
     # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
     # treat a multi-line C++ special comment block (i.e. a block of //! or ///
     # comments) as a brief description. This used to be the default behaviour.
     # The new default is to treat a multi-line C++ comment block as a detailed
     # description. Set this tag to YES if you prefer the old behaviour instead.
     MULTILINE_CPP_IS_BRIEF = NO
     # If the DETAILS_AT_TOP tag is set to YES then Doxygen
     # will output the detailed description near the top, like JavaDoc.
     # If set to NO, the detailed description appears after the member
     # documentation.
     DETAILS_AT_TOP         = NO
     # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
     # member inherits the documentation from any documented member that it
     # re-implements.
     INHERIT_DOCS           = YES
     # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
     # a new page for each member. If set to NO, the documentation of a member will
     # be part of the file/class/namespace that contains it.
     SEPARATE_MEMBER_PAGES  = NO
     # The TAB_SIZE tag can be used to set the number of spaces in a tab.
     # Doxygen uses this value to replace tabs by spaces in code fragments.
     TAB_SIZE               = 8
     # This tag can be used to specify a number of aliases that acts
     # as commands in the documentation. An alias has the form "name=value".
     # For example adding "sideeffect=\par Side Effects:\n" will allow you to
     # put the command \sideeffect (or @sideeffect) in the documentation, which
     # will result in a user-defined paragraph with heading "Side Effects:".
     # You can put \n's in the value part of an alias to insert newlines.
     ALIASES                =
     # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
     # sources only. Doxygen will then generate output that is more tailored for C.
     # For instance, some of the names that are used will be different. The list
     # of all members will be omitted, etc.
     OPTIMIZE_OUTPUT_FOR_C  = YES
     # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
     # sources only. Doxygen will then generate output that is more tailored for Java.
     # For instance, namespaces will be presented as packages, qualified scopes
     # will look different, etc.
     OPTIMIZE_OUTPUT_JAVA   = NO
     # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want to
     # include (a tag file for) the STL sources as input, then you should
     # set this tag to YES in order to let doxygen match functions declarations and
     # definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
     # func(std::string) {}). This also make the inheritance and collaboration
     # diagrams that involve STL classes more complete and accurate.
     BUILTIN_STL_SUPPORT    = NO
     # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
     # tag is set to YES, then doxygen will reuse the documentation of the first
     # member in the group (if any) for the other members of the group. By default
     # all members of a group must be documented explicitly.
     DISTRIBUTE_GROUP_DOC   = NO
     # Set the SUBGROUPING tag to YES (the default) to allow class member groups of
     # the same type (for instance a group of public functions) to be put as a
     # subgroup of that type (e.g. under the Public Functions section). Set it to
     # NO to prevent subgrouping. Alternatively, this can be done per class using
     # the \nosubgrouping command.
     SUBGROUPING            = YES
     #---------------------------------------------------------------------------
     # Build related configuration options
     #---------------------------------------------------------------------------
     # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
     # documentation are documented, even if no documentation was available.
     # Private class members and static file members will be hidden unless
     # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
     EXTRACT_ALL            = NO
     # If the EXTRACT_PRIVATE tag is set to YES all private members of a class
     # will be included in the documentation.
     EXTRACT_PRIVATE        = NO
     # If the EXTRACT_STATIC tag is set to YES all static members of a file
     # will be included in the documentation.
     EXTRACT_STATIC         = NO
     # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
     # defined locally in source files will be included in the documentation.
     # If set to NO only classes defined in header files are included.
     EXTRACT_LOCAL_CLASSES  = YES
     # This flag is only useful for Objective-C code. When set to YES local
     # methods, which are defined in the implementation section but not in
     # the interface are included in the documentation.
     # If set to NO (the default) only methods in the interface are included.
     EXTRACT_LOCAL_METHODS  = NO
     # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
     # undocumented members of documented classes, files or namespaces.
     # If set to NO (the default) these members will be included in the
     # various overviews, but no documentation section is generated.
     # This option has no effect if EXTRACT_ALL is enabled.
     HIDE_UNDOC_MEMBERS     = NO
     # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
     # undocumented classes that are normally visible in the class hierarchy.
     # If set to NO (the default) these classes will be included in the various
     # overviews. This option has no effect if EXTRACT_ALL is enabled.
     HIDE_UNDOC_CLASSES     = NO
     # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
     # friend (class|struct|union) declarations.
     # If set to NO (the default) these declarations will be included in the
     # documentation.
     HIDE_FRIEND_COMPOUNDS  = NO
     # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
     # documentation blocks found inside the body of a function.
     # If set to NO (the default) these blocks will be appended to the
     # function's detailed documentation block.
     HIDE_IN_BODY_DOCS      = NO
     # The INTERNAL_DOCS tag determines if documentation
     # that is typed after a \internal command is included. If the tag is set
     # to NO (the default) then the documentation will be excluded.
     # Set it to YES to include the internal documentation.
     INTERNAL_DOCS          = NO
     # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
     # file names in lower-case letters. If set to YES upper-case letters are also
     # allowed. This is useful if you have classes or files whose names only differ
     # in case and if your file system supports case sensitive file names. Windows
     # and Mac users are advised to set this option to NO.
     CASE_SENSE_NAMES       = YES
     # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
     # will show members with their full class and namespace scopes in the
     # documentation. If set to YES the scope will be hidden.
     HIDE_SCOPE_NAMES       = NO
     # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
     # will put a list of the files that are included by a file in the documentation
     # of that file.
     SHOW_INCLUDE_FILES     = YES
     # If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
     # is inserted in the documentation for inline members.
     INLINE_INFO            = YES
     # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
     # will sort the (detailed) documentation of file and class members
     # alphabetically by member name. If set to NO the members will appear in
     # declaration order.
     SORT_MEMBER_DOCS       = YES
     # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
     # brief documentation of file, namespace and class members alphabetically
     # by member name. If set to NO (the default) the members will appear in
     # declaration order.
     SORT_BRIEF_DOCS        = NO
     # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
     # sorted by fully-qualified names, including namespaces. If set to
     # NO (the default), the class list will be sorted only by class name,
     # not including the namespace part.
     # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
     # Note: This option applies only to the class list, not to the
     # alphabetical list.
     SORT_BY_SCOPE_NAME     = NO
     # The GENERATE_TODOLIST tag can be used to enable (YES) or
     # disable (NO) the todo list. This list is created by putting \todo
     # commands in the documentation.
     GENERATE_TODOLIST      = YES
     # The GENERATE_TESTLIST tag can be used to enable (YES) or
     # disable (NO) the test list. This list is created by putting \test
     # commands in the documentation.
     GENERATE_TESTLIST      = YES
     # The GENERATE_BUGLIST tag can be used to enable (YES) or
     # disable (NO) the bug list. This list is created by putting \bug
     # commands in the documentation.
     GENERATE_BUGLIST       = YES
     # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
     # disable (NO) the deprecated list. This list is created by putting
     # \deprecated commands in the documentation.
     GENERATE_DEPRECATEDLIST= YES
     # The ENABLED_SECTIONS tag can be used to enable conditional
     # documentation sections, marked by \if sectionname ... \endif.
     ENABLED_SECTIONS       =
     # The MAX_INITIALIZER_LINES tag determines the maximum number of lines
     # the initial value of a variable or define consists of for it to appear in
     # the documentation. If the initializer consists of more lines than specified
     # here it will be hidden. Use a value of 0 to hide initializers completely.
     # The appearance of the initializer of individual variables and defines in the
     # documentation can be controlled using \showinitializer or \hideinitializer
     # command in the documentation regardless of this setting.
     MAX_INITIALIZER_LINES  = 30
     # Set the SHOW_USED_FILES tag to NO to disable the list of files generated
     # at the bottom of the documentation of classes and structs. If set to YES the
     # list will mention the files that were used to generate the documentation.
     SHOW_USED_FILES        = YES
     # If the sources in your project are distributed over multiple directories
     # then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
     # in the documentation. The default is NO.
     SHOW_DIRECTORIES       = NO
     # The FILE_VERSION_FILTER tag can be used to specify a program or script that
     # doxygen should invoke to get the current version for each file (typically from the
     # version control system). Doxygen will invoke the program by executing (via
     # popen()) the command <command> <input-file>, where <command> is the value of
     # the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
     # provided by doxygen. Whatever the program writes to standard output
     # is used as the file version. See the manual for examples.
     FILE_VERSION_FILTER    =
     #---------------------------------------------------------------------------
     # configuration options related to warning and progress messages
     #---------------------------------------------------------------------------
     # The QUIET tag can be used to turn on/off the messages that are generated
     # by doxygen. Possible values are YES and NO. If left blank NO is used.
     QUIET                  = NO
     # The WARNINGS tag can be used to turn on/off the warning messages that are
     # generated by doxygen. Possible values are YES and NO. If left blank
     # NO is used.
     WARNINGS               = YES
     # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
     # for undocumented members. If EXTRACT_ALL is set to YES then this flag will
     # automatically be disabled.
     WARN_IF_UNDOCUMENTED   = YES
     # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
     # potential errors in the documentation, such as not documenting some
     # parameters in a documented function, or documenting parameters that
     # don't exist or using markup commands wrongly.
     WARN_IF_DOC_ERROR      = YES
     # This WARN_NO_PARAMDOC option can be abled to get warnings for
     # functions that are documented, but have no documentation for their parameters
     # or return value. If set to NO (the default) doxygen will only warn about
     # wrong or incomplete parameter documentation, but not about the absence of
     # documentation.
     WARN_NO_PARAMDOC       = NO
     # The WARN_FORMAT tag determines the format of the warning messages that
     # doxygen can produce. The string should contain the $file, $line, and $text
     # tags, which will be replaced by the file and line number from which the
     # warning originated and the warning text. Optionally the format may contain
     # $version, which will be replaced by the version of the file (if it could
     # be obtained via FILE_VERSION_FILTER)
     WARN_FORMAT            = "$file:$line: $text"
     # The WARN_LOGFILE tag can be used to specify a file to which warning
     # and error messages should be written. If left blank the output is written
     # to stderr.
     WARN_LOGFILE           =
     #---------------------------------------------------------------------------
     # configuration options related to the input files
     #---------------------------------------------------------------------------
     # The INPUT tag can be used to specify the files and/or directories that contain
     # documented source files. You may enter file names like "myfile.cpp" or
     # directories like "/usr/src/myproject". Separate the files or directories
     # with spaces.
     INPUT                  =
     # If the value of the INPUT tag contains directories, you can use the
     # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
     # and *.h) to filter out the source-files in the directories. If left
     # blank the following patterns are tested:
     # *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
     # *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py
     FILE_PATTERNS          =
     # The RECURSIVE tag can be used to turn specify whether or not subdirectories
     # should be searched for input files as well. Possible values are YES and NO.
     # If left blank NO is used.
     RECURSIVE              = NO
     # The EXCLUDE tag can be used to specify files and/or directories that should
     # excluded from the INPUT source files. This way you can easily exclude a
     # subdirectory from a directory tree whose root is specified with the INPUT tag.
     EXCLUDE                =
     # The EXCLUDE_SYMLINKS tag can be used select whether or not files or
     # directories that are symbolic links (a Unix filesystem feature) are excluded
     # from the input.
     EXCLUDE_SYMLINKS       = NO
     # If the value of the INPUT tag contains directories, you can use the
     # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
     # certain files from those directories. Note that the wildcards are matched
     # against the file with absolute path, so to exclude all test directories
     # for example use the pattern */test/*
     EXCLUDE_PATTERNS       =
     # The EXAMPLE_PATH tag can be used to specify one or more files or
     # directories that contain example code fragments that are included (see
     # the \include command).
     EXAMPLE_PATH           =
     # If the value of the EXAMPLE_PATH tag contains directories, you can use the
     # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
     # and *.h) to filter out the source-files in the directories. If left
     # blank all files are included.
     EXAMPLE_PATTERNS       =
     # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
     # searched for input files to be used with the \include or \dontinclude
     # commands irrespective of the value of the RECURSIVE tag.
     # Possible values are YES and NO. If left blank NO is used.
     EXAMPLE_RECURSIVE      = NO
     # The IMAGE_PATH tag can be used to specify one or more files or
     # directories that contain image that are included in the documentation (see
     # the \image command).
     IMAGE_PATH             =
     # The INPUT_FILTER tag can be used to specify a program that doxygen should
     # invoke to filter for each input file. Doxygen will invoke the filter program
     # by executing (via popen()) the command <filter> <input-file>, where <filter>
     # is the value of the INPUT_FILTER tag, and <input-file> is the name of an
     # input file. Doxygen will then use the output that the filter program writes
     # to standard output.  If FILTER_PATTERNS is specified, this tag will be
     # ignored.
     INPUT_FILTER           =
     # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
     # basis.  Doxygen will compare the file name with each pattern and apply the
     # filter if there is a match.  The filters are a list of the form:
     # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
     # info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER
     # is applied to all files.
     FILTER_PATTERNS        =
     # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
     # INPUT_FILTER) will be used to filter the input files when producing source
     # files to browse (i.e. when SOURCE_BROWSER is set to YES).
     FILTER_SOURCE_FILES    = NO
     #---------------------------------------------------------------------------
     # configuration options related to source browsing
     #---------------------------------------------------------------------------
     # If the SOURCE_BROWSER tag is set to YES then a list of source files will
     # be generated. Documented entities will be cross-referenced with these sources.
     # Note: To get rid of all source code in the generated output, make sure also
     # VERBATIM_HEADERS is set to NO.
     SOURCE_BROWSER         = NO
     # Setting the INLINE_SOURCES tag to YES will include the body
     # of functions and classes directly in the documentation.
     INLINE_SOURCES         = NO
     # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
     # doxygen to hide any special comment blocks from generated source code
     # fragments. Normal C and C++ comments will always remain visible.
     STRIP_CODE_COMMENTS    = YES
     # If the REFERENCED_BY_RELATION tag is set to YES (the default)
     # then for each documented function all documented
     # functions referencing it will be listed.
     REFERENCED_BY_RELATION = YES
     # If the REFERENCES_RELATION tag is set to YES (the default)
     # then for each documented function all documented entities
     # called/used by that function will be listed.
     REFERENCES_RELATION    = YES
     # If the USE_HTAGS tag is set to YES then the references to source code
     # will point to the HTML generated by the htags(1) tool instead of doxygen
     # built-in source browser. The htags tool is part of GNU's global source
     # tagging system (see http://www.gnu.org/software/global/global.html). You
     # will need version 4.8.6 or higher.
     USE_HTAGS              = NO
     # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
     # will generate a verbatim copy of the header file for each class for
     # which an include is specified. Set to NO to disable this.
     VERBATIM_HEADERS       = YES
     #---------------------------------------------------------------------------
     # configuration options related to the alphabetical class index
     #---------------------------------------------------------------------------
     # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
     # of all compounds will be generated. Enable this if the project
     # contains a lot of classes, structs, unions or interfaces.
     ALPHABETICAL_INDEX     = NO
     # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
     # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
     # in which this list will be split (can be a number in the range [1..20])
     COLS_IN_ALPHA_INDEX    = 5
     # In case all classes in a project start with a common prefix, all
     # classes will be put under the same header in the alphabetical index.
     # The IGNORE_PREFIX tag can be used to specify one or more prefixes that
     # should be ignored while generating the index headers.
     IGNORE_PREFIX          =
     #---------------------------------------------------------------------------
     # configuration options related to the HTML output
     #---------------------------------------------------------------------------
     # If the GENERATE_HTML tag is set to YES (the default) Doxygen will
     # generate HTML output.
     GENERATE_HTML          = YES
     # The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
     # If a relative path is entered the value of OUTPUT_DIRECTORY will be
     # put in front of it. If left blank `html' will be used as the default path.

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

Also available in: Unified diff