/ - Diff - Colony - Robotics Club

Revision 793

Updated bay board wireless library... Doesn't work at all.

     #include <bayboard_lib.h>
     #include <wireless.h>
     #include <wl_token_ring.h>
     #include <xbee.h>
     #include <ctype.h>
     void test_bom_on (void)
     int main(int argc, char** argv)
+    {
     	set_orb(0,200,0);
     	delay_ms(50);
+    }
     void test_bom_off(void)
+    {
     	set_orb(200,0,200);
     	delay_ms(50);
+    }
     int test_nothing(void)
+    {
     	return -1;
+    }
     void do_nothing (void) {
+    }
     int main(void)
+    {
     	bayboard_init(ALL_ON);
     	//xbee_lib_init();
     	set_orb(200,0,0);
     	usb_puts("Start.\n");
     	set_orb(0, 0, 200);
     	wl_init();
     	if(wl_token_ring_register() < 0) {
     	  set_orb(200,0,0);
     	  return -1;
+    	}
     	if(wl_token_ring_join() < 0) {
     	  set_orb(200,0,0);
     	  return -1;
+    	}
     	set_orb(0,200,0);
     	usb_puts("== start ==\n");
     	delay_ms(200);
     	//bom_init(0);
       //int c;
       //char buf[20];
     	while (1) {
     	  wl_do();
+    	}
     	set_orb(0, 200, 0);
     	/*if (wl_token_ring_register() < 0)
     		usb_puts("Failed to register token ring.\n");
     	if (wl_token_ring_join() < 0)
     		usb_puts("Failed to join token ring.\n");*/
     	usb_puts("Wireless initialized.\n");
     	//while (1)
     	//	wl_do();
     	return 0;
+    }

branches/autonomous_recharging/code/projects/libwireless/bayboardTest/Makefile
14	14	USE_WIRELESS = 1
15	15
16	16	# com1 = serial port. Use lpt1 to connect to parallel port.
17		AVRDUDE_PORT = /dev/ttyUSB0
	17	AVRDUDE_PORT = /dev/ttyUSB1
18	18	#
19	19	#
20	20	###################################

     #include <sensor_matrix.h>
     #ifdef ROBOT
     	#ifndef FIREFLY
     		#ifdef BAYBOARD
     			#include <lbom.h>
     		#else
     			#include <bom.h>
     		#endif
     	#endif
     #ifndef FIREFLY
     #include <bom.h>
     #endif
     #include <time.h>
     #endif
     //TODO: why is this in both this file and sensor_matrix.c?  If it is needed in both places,
     // put it in sensor_matrix.h.  This file already includes sensor_matrix.h
     #define DEFAULT_SENSOR_MATRIX_SIZE 20
     /*Ring States*/
-...
     #define LEAVING 4
     /*Frame Types*/
     #define TOKEN_JOIN_ACCEPT_FRAME 1
     #define TOKEN_JOIN_ACCEPT_FRAME	1
     #define WL_TOKEN_PASS_FRAME	2
     /*Function Prototypes*/
-...
     static void wl_token_get_token(void);
     /*Packet Handling Routines*/
     static void wl_token_pass_receive(int source, char nextRobot, unsigned char* sensorData, int sensorDataLength);
     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 sensor matrix
     static SensorMatrix* sensorMatrix;
     //the robot we are waiting to say it has received the token. -1 if unspecified
     static int wl_token_next_robot = -1;
-...
     // 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
     #ifdef BAYBOARD
     static void (*bom_on_function) (void) = bom_on;
     static void (*bom_off_function) (void) = bom_off;
     static int (*get_max_bom_function) (void) = get_nothing;
     #else
     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;
     #endif
     #else
     static void (*bom_on_function) (void) = do_nothing;
     static void (*bom_off_function) (void) = do_nothing;
-...
     #endif
     static PacketGroupHandler wl_token_ring_handler =
     	{wl_token_ring_timeout_handler,
     	{WL_TOKEN_RING_GROUP, wl_token_ring_timeout_handler,
     		wl_token_ring_response_handler, wl_token_ring_receive_handler,
        wl_token_ring_cleanup, WL_TOKEN_RING_GROUP};
     		wl_token_ring_cleanup};
     /**
      * Causes the robot to join an existing token ring, or create one
-...
      * alerting others of its location, but continues storing the
      * locations of other robots.
      **/
     //TODO: this function is so simple, it *may* be beneficial to inline this function.  testing of if
     // it reduces code size or not should be done to be sure.
     void wl_token_ring_leave()
+    {
     	ringState = LEAVING;
-...
     		return -1;
+    	}
     	sensorMatrix = sensor_matrix_create();
     	sensor_matrix_create();
     	//add ourselves to the sensor matrix
     	sensor_matrix_set_in_ring(sensorMatrix, wl_get_xbee_id(), 0);
     	sensor_matrix_set_in_ring(wl_get_xbee_id(), 0);
     	wl_register_packet_group(&wl_token_ring_handler);
-...
     /**
      * Removes the packet group from the wireless library.
      **/
     //TODO: this function is so simple, it *may* be beneficial to inline this function.  testing of if
     // it reduces code size or not should be done to be sure.
     void wl_token_ring_unregister()
+    {
     	wl_unregister_packet_group(&wl_token_ring_handler);
-...
     /**
      * Called to cleanup the token ring packet group.
      **/
     //TODO: this function is so simple, it *may* be beneficial to inline this function.  testing of if
     // it reduces code size or not should be done to be sure.
     static void wl_token_ring_cleanup()
+    {
     	sensor_matrix_destroy(sensorMatrix);
+    }
     /**
-...
     		//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(sensorMatrix, wl_token_next_robot, 0);
     			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");
-...
     	//we must start our own token ring, no one is responding to us
     	if (joinDelay == 0)
+    	{
     		if (sensor_matrix_get_joined(sensorMatrix) == 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(sensorMatrix, wl_get_xbee_id(), 1);
     			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
-...
     	switch (type)
+    	{
     		case WL_TOKEN_PASS:
     			if (length < 1)
+    			{
     				WL_DEBUG_PRINT("Malformed Token Pass packet received.\r\n");
     				return;
+    			}
     			wl_token_pass_receive(source, packet[0], packet + 1, length - 1);
     			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);
-...
+    {
     	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(sensorMatrix, source, dest);
     		return sensor_matrix_get_reading(source, dest);
+    	}
     	return -1;
-...
      * @return a BOM reading from us to robot dest, in the range
      * 0-15, or -1 if it is unkown
      **/
     //TODO: this function is so simple, it *may* be beneficial to inline this function.  testing of if
     // it reduces code size or not should be done to be sure.
     int wl_token_get_my_sensor_reading(int dest)
+    {
     	return wl_token_get_sensor_reading(wl_get_xbee_id(), dest);
-...
+     *
      * @return the number of robots in the token ring
      **/
     //TODO: this function is so simple, it *may* be beneficial to inline this function.  testing of if
     // it reduces code size or not should be done to be sure.
     int wl_token_get_robots_in_ring(void)
+    {
     	return sensor_matrix_get_joined(sensorMatrix);
     	return sensor_matrix_get_joined();
+    }
     /**
-...
      * @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
      **/
     //TODO: this function is so simple, it *may* be beneficial to inline this function.  testing of if
     // it reduces code size or not should be done to be sure.
     int wl_token_is_robot_in_ring(int robot)
+    {
     	return sensor_matrix_get_in_ring(sensorMatrix, robot);
     	return sensor_matrix_get_in_ring(robot);
+    }
     /**
-...
     void wl_token_iterator_begin(void)
+    {
     	int i = 0;
     	while (!sensor_matrix_get_in_ring(sensorMatrix, i) && i < sensor_matrix_get_size(sensorMatrix)) {
       //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++;
+    	}
     	if (i == sensor_matrix_get_size(sensorMatrix)) {
       //TODO: if you do the above comment, then you can compare this to the variable also
     	if (i == sensor_matrix_get_size()) {
     		i = -1;
+    	}
-...
+     *
      * @see wl_token_iterator_begin, wl_token_iterator_next
      **/
     //TODO: this function is so simple, it *may* be beneficial to inline this function.  testing of if
     // it reduces code size or not should be done to be sure.
     int wl_token_iterator_has_next(void)
+    {
     	return iteratorCount != -1;
-...
     		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(sensorMatrix, iteratorCount)
     		&& iteratorCount < sensor_matrix_get_size(sensorMatrix)) {
     	while (!sensor_matrix_get_in_ring(iteratorCount)
     		&& iteratorCount < sensor_matrix_get_size()) {
     		iteratorCount++;
+    	}
     	if (iteratorCount == sensor_matrix_get_size(sensorMatrix)) {
       //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 the number of robots in the token ring
      **/
     //TODO: this function is so simple, it *may* be beneficial to inline this function.  testing of if
     // it reduces code size or not should be done to be sure.
     int wl_token_get_num_robots(void)
+    {
     	return sensor_matrix_get_joined(sensorMatrix);
     	return sensor_matrix_get_joined();
+    }
     /**
-...
+     *
      * @return the number of robots in the sensor matrix
      **/
     //TODO: this function is so simple, it *may* be beneficial to inline this function.  testing of if
     // it reduces code size or not should be done to be sure.
     int wl_token_get_matrix_size(void)
+    {
     	return sensor_matrix_get_size(sensorMatrix);
     	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_pass_receive(int source, char nextRobot, unsigned char* sensorData, int sensorDataLength)
     static void wl_token_sensor_matrix_receive(int source, unsigned char* sensorData, int sensorDataLength)
+    {
     	int i, j;
     	char nextRobot;
     	// 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 && 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;
     	WL_DEBUG_PRINT("Received the token from robot");
     	WL_DEBUG_PRINT_INT(source);
     	WL_DEBUG_PRINT(", next robot is ");
     	WL_DEBUG_PRINT_INT((int)nextRobot);
     	WL_DEBUG_PRINT(" \r\n");
     	sensor_matrix_set_in_ring(sensorMatrix, source, 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;
     	for (i = 0; i < sensor_matrix_get_size(sensorMatrix); i++)
       //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;
-...
     				accepted = -1;
     				WL_DEBUG_PRINT("Someone accepted the robot we did.\r\n");
+    			}
     			sensor_matrix_set_reading(sensorMatrix, source, i,
     			sensor_matrix_set_reading(source, i,
     						sensorData[2 * j + 1]);
     			sensor_matrix_set_in_ring(sensorMatrix, i, 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(sensorMatrix, i))
     			if (sensor_matrix_get_in_ring(i))
+    			{
     				WL_DEBUG_PRINT("Robot ");
     				WL_DEBUG_PRINT_INT(i);
-...
     				WL_DEBUG_PRINT(" due to a packet from robot ");
     				WL_DEBUG_PRINT_INT(source);
     				WL_DEBUG_PRINT(".\r\n");
     				sensor_matrix_set_in_ring(sensorMatrix, i, 0);
     				sensor_matrix_set_in_ring(i, 0);
+    			}
     			if (i == wl_get_xbee_id() && ringState == MEMBER)
-...
     			//the person who accepted us is dead... let's ask again
     			if (i == acceptor)
+    			{
     				sensor_matrix_set_in_ring(sensorMatrix,
     						wl_get_xbee_id(), 1);
     				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;
+    		}
     	wl_token_next_robot = nextRobot;
     		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;
     	//we have the token
     	if (wl_token_next_robot == wl_get_xbee_id()) {
     		wl_token_get_token();
+    	}
     	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);
+    }
     /**
-...
     	int count = 1;
     	while (1)
+    	{
     		if (curr == sensor_matrix_get_size(sensorMatrix))
         //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(sensorMatrix, curr))
     		if (sensor_matrix_get_in_ring(curr))
     			count++;
     		curr++;
+    	}
-...
      **/
     static int wl_token_pass_token()
+    {
     	char nextRobot;
     	char nextRobot = 0xFF;
     	int i = wl_get_xbee_id() + 1;
     	char buf[2 * sensor_matrix_get_size()];
     	if (accepted == -1)
+    	{
     		while (1)
+    		{
     			if (i == sensor_matrix_get_size(sensorMatrix)) {
           //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(sensorMatrix, i))
     			if (sensor_matrix_get_in_ring(i))
+    			{
     				nextRobot = (char)i;
     				break;
-...
+    	{
     		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(sensorMatrix, accepted, 1);
     		sensor_matrix_set_in_ring(accepted, 1);
     		nextRobot = accepted;
     		accepted = -1;
+    	}
     	//we don't include ourself
     	int packetSize = 1 + 2 * (sensor_matrix_get_joined(sensorMatrix) - 1);
     	char* buf = (char*)malloc(packetSize * sizeof(char));
     	if (!buf)
+    	{
     		WL_DEBUG_PRINT_INT(packetSize);
     		WL_DEBUG_PRINT("Out of memory - pass token.\r\n");
     		free(buf);
     		return -1;
+    	}
     	buf[0] = nextRobot;
     	int j = 0;
     	for (i = 0; i < sensor_matrix_get_size(sensorMatrix); i++) {
     		if (sensor_matrix_get_in_ring(sensorMatrix, i) && i != wl_get_xbee_id())
       //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 + 1] = i;
     			buf[2*j + 2] = sensor_matrix_get_reading(sensorMatrix, wl_get_xbee_id(), i);
     			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(buf[0]);
     	WL_DEBUG_PRINT_INT(nextRobot);
     	WL_DEBUG_PRINT(".\r\n");
     	if (wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_PASS, buf, packetSize, 3) != 0) {
     		free(buf);
     	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;
     	free(buf);
     	return 0;
+    }
-...
     	bom_on_count = 0;
     	sensor_matrix_set_reading(sensorMatrix, wl_get_xbee_id(),
     	sensor_matrix_set_reading(wl_get_xbee_id(),
     		source, get_max_bom_function());
+    }
-...
     	WL_DEBUG_PRINT("We have the token.\r\n");
     	if (ringState == ACCEPTED)
+    	{
     		sensor_matrix_set_in_ring(sensorMatrix, wl_get_xbee_id(), 1);
     		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(sensorMatrix, wl_get_xbee_id(), 0);
     		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");
-...
     	#endif
     	bom_off_function();
     	if (!sensor_matrix_get_in_ring(sensorMatrix, wl_get_xbee_id()))
     	if (!sensor_matrix_get_in_ring(wl_get_xbee_id()))
+    	{
     		WL_DEBUG_PRINT("Removed from sensor matrix while flashing BOM.\r\n");
     		return;
-...
     	while (1)
+    	{
     		if (i < 0)
     			i = sensor_matrix_get_size(sensorMatrix) - 1;
     			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(sensorMatrix, i))
     		if (sensor_matrix_get_in_ring(i))
     			return;
     		i--;
+    	}
-...
     	WL_DEBUG_PRINT(" into the token ring.\r\n");
     	// the token ring has not started yet
     	if (sensor_matrix_get_joined(sensorMatrix) == 1)
     	if (sensor_matrix_get_joined() == 1)
     		wl_token_pass_token();
+    }
-...
     	acceptor = source;
     	//add ourselves to the token ring
     	sensor_matrix_set_in_ring(sensorMatrix, wl_get_xbee_id(), 1);
     	sensor_matrix_set_in_ring(wl_get_xbee_id(), 1);
+    }

      * @{
      **/
     #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 matrix. Each row represents the readings of one
     	 * robot.
     	 **/
     	int** matrix;
     	unsigned char matrix[MAXIMUM_XBEE_ID][MAXIMUM_XBEE_ID];
     	/**
     	 * The element representing a robot is true if that robot
     	 * is in the token ring and false otherwise.
     	 **/
     	char* joined;
     	/**
     	 * The number of robots in the token ring.
     	 **/
     	int numJoined;
     	/**
     	 * The size of the sensor matrix.
     	**/
     	int size;
     	unsigned char joined[MAXIMUM_XBEE_ID];
     } SensorMatrix;
     /**@brief Create a sensor matrix **/
     SensorMatrix* sensor_matrix_create(void);
     /**@brief Destroy a sensor matrix **/
     void sensor_matrix_destroy(SensorMatrix* m);
     /**@brief Add a robot to a sensor matrix **/
     void sensor_matrix_add_robot(SensorMatrix* m, int id);
     /**@brief Remove a robot from a sensor matrix **/
     void sensor_matrix_remove_robot(SensorMatrix* m, int id);
     void sensor_matrix_create(void);
     /**@brief Set a reading in a sensor matrix **/
     void sensor_matrix_set_reading(SensorMatrix* m, int observer, int robot, int reading);
     void sensor_matrix_set_reading(int observer, int robot, int reading);
     /**@brief Get a reading in a sensor matrix **/
     int sensor_matrix_get_reading(SensorMatrix* m, int observer, int robot);
     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(SensorMatrix* m, int robot, int in);
     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(SensorMatrix* m, int robot);
     /**@brief Get the size of the sensor matrix **/
     int sensor_matrix_get_size(SensorMatrix* m);
     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(SensorMatrix* m);
     int sensor_matrix_get_joined(void);
     /**@brief Get the maximum size of the sensor matrix **/
     int sensor_matrix_get_size(void);
     /** @} **/ //end defgroup
     #endif

     /**
      * The maximum number of packet groups.
      **/
     #define WL_MAX_PACKET_GROUPS 4
     //TODO: a PacketGroupHandler is at least 10 bytes (I don't know if function pointers are 2 bytes
     // or 4 bytes).  That means that in the c file, your array of packet groups is at least 160 bytes.
     // Normally that might be fine (the robot's avr chips have 4k SRAM), but austin's chip only has
     // 1k SRAM, so if this number can be reduced or if the size of the struct could be reduced, that would be a plus.
     #define WL_MAX_PACKET_GROUPS 16
     /**
      * @defgroup wireless Wireless
-...
      * handlers for various events which can occur related to a packet
      * group.
      **/
     //TODO: the order of member variables in this struct should be changed in case the compile packs the struct
     // In order to achieve the best packing, the variables should be listed in order of decreasing memory size.
     // Thus, pointers should be first, followed by int, followed by char.
     typedef struct
+    {
     	/**
     	 * The group code for this packet group. This number
     	 * must be unique. The maximum number of packet groups
     	 * is defined by WL_MAX_PACKET_GROUPS.
     	 **/
       //TODO: if this number must be less than or equal to WL_MAX_PACKET_GROUPS, don't you only need
       // one byte for it and it can be made an unsigned char?
     	unsigned int groupCode;
     	/**
     	 * Called every half second (not in interrupt,
     	 * but in wl_do).
     	 **/
-...
     	 **/
     	void (*unregister) (void);
     	/**
     	 * The group code for this packet group. This number
     	 * must be unique. The maximum number of packet groups
     	 * is defined by WL_MAX_PACKET_GROUPS.
     	 **/
     	unsigned int groupCode;
     } PacketGroupHandler;
     /**@brief Initialize the wireless library **/

     #include <serial.h>
     #include <avr/interrupt.h>
     #include <ctype.h>
     #endif
     #include <stdio.h>
-...
     static int xbee_send_modify_at_command(char* command, char* value);
     /*Global Variables*/
     #define MAX_XBEE_FRAME_SIZE 32
     #ifndef ROBOT
     static char* xbee_com_port = XBEE_PORT_DEFAULT;
     static int xbee_stream;
-...
     // TODO: is this a good size?
     #define XBEE_BUFFER_SIZE	128
     #define PACKET_BUFFER_SIZE	108
     // a buffer for data received from the XBee
     char arrival_buf[XBEE_BUFFER_SIZE];
     // location of last unread byte in buffer
-...
     //used to store packets as they are read
     static char xbee_buf[MAX_XBEE_FRAME_SIZE];
     static char xbee_buf[PACKET_BUFFER_SIZE];
     static int currentBufPos = 0;
     //XBee status
-...
     static int xbee_pending_channel = XBEE_CHANNEL_DEFAULT;
     static volatile unsigned int xbee_address = 0;
     #ifndef ROBOT
     void printHex(char * s, int len) {
       int i;
       for (i = 0; i < len; i++) {
         printf("0x%x ", (int)(s[i]));
+      }
       printf("\n");
+    }
     #endif
     /*Function Implementations*/
     #ifdef ROBOT
-...
      * Interrupt for the robot. Adds bytes received from the xbee
      * to the buffer.
      **/
     #ifdef FIREFLY
     SIGNAL(SIG_USART0_RECV)
+    {
       usb_puts("In USART0 interrupt\n");
     	char c = UDR0;
     	arrival_buf[buffer_last] = c;
     	int t = buffer_last + 1;
     	if (t == XBEE_BUFFER_SIZE)
     		t = 0;
     	if (t == buffer_first)
+        {
           WL_DEBUG_PRINT("Out of space in buffer.\n");
+        }
     	buffer_last = t;
+    }
     #else
     #ifdef BAYBOARD
     #ifndef FIREFLY
     ISR(USART1_RX_vect)
+    {
     	char c = UDR1;
     	/*
         char buf[30];
         char buf2[5];
     	  buf2[0] = '\\';
     	  if (c == '\b') {
         buf2[1] = 'b';
         buf2[2] = '\0';
+    	  }
     	  else if (c == '\n') {
         buf2[1] = 'n';
         buf2[2] = '\0';
+    	  }
     	  else if (c == '\r') {
         buf2[1] = 'r';
         buf2[2] = '\0';
+    	  }
     	  else if (c == '\t') {
         buf2[1] = 't';
         buf2[2] = '\0';
+    	  }
     	  else if (!isprint(c)) {
         sprintf(buf2, "0x%.2x", c);
+    	  }
     	  else {
         buf2[0] = c;
         buf2[1] = '\0';
+    	  }
         sprintf(buf, "In USART1 interrupt [%s]\n", buf2);
         usb_puts(buf);
     	*/
     	arrival_buf[buffer_last] = c;
     	int t = buffer_last + 1;
     	if (t == XBEE_BUFFER_SIZE)
     		t = 0;
     	if (t == buffer_first)
+        {
           WL_DEBUG_PRINT("Out of space in buffer.\n");
+        }
+    	{
     		WL_DEBUG_PRINT("\nOut of space in buffer.\n");
+    	}
     	buffer_last = t;
+    }
     #else
     ISR(USART1_RX_vect)
     SIGNAL(SIG_USART0_RECV)
+    {
     	char c = UDR1;
     	char c = UDR0;
     	arrival_buf[buffer_last] = c;
     	int t = buffer_last + 1;
     	if (t == XBEE_BUFFER_SIZE)
     		t = 0;
     	if (t == buffer_first)
+        {
           WL_DEBUG_PRINT("Out of space in buffer.\n");
+        }
+    	{
     		WL_DEBUG_PRINT("Out of space in buffer.\n");
+    	}
     	buffer_last = t;
+    }
     #endif
     #endif
     #else
-...
+    {
     	char c;
     	while (1)
+        {
           if (xbee_read(&c, 1) != 0) {
             fprintf(stderr, "xbee_read failed.\n");
             return NULL;
+          }
+    	{
     		if (xbee_read(&c, 1) != 0) {
     			WL_DEBUG_PRINT("xbee_read failed.\n");
     			return NULL;
+    		}
           //DEBUGGING PRINT
           //printf("interrupt: %c (%d)\n", c, (int)c);
           arrival_buf[buffer_last] = c;
           int t = buffer_last + 1;
           if (t == XBEE_BUFFER_SIZE)
             t = 0;
           if (t == buffer_first)
+            {
               WL_DEBUG_PRINT("Out of space in buffer.\n");
+            }
           buffer_last = t;
     		arrival_buf[buffer_last] = c;
     		int t = buffer_last + 1;
     		if (t == XBEE_BUFFER_SIZE)
     			t = 0;
     		if (t == buffer_first)
+    		{
     			WL_DEBUG_PRINT("Out of space in buffer.\n");
+    		}
     		buffer_last = t;
           usleep(1000);
+        }
     		usleep(1000);
+    	}
     	return NULL;
+    }
-...
      **/
     int xbee_lib_init()
+    {
     	arrival_buf[0] = 'A';
     	arrival_buf[1] = 'A';
     	arrival_buf[2] = 'A';
     	WL_DEBUG_PRINT("in xbee_init\n");
     #ifdef ROBOT
     	//enable the receiving interrupt
-...
     	UCSR0B |= _BV(RXCIE) | _BV(RXEN);
     #else
     #ifdef BAYBOARD
     	UCSR1B |= _BV(RXCIE0);
     	UCSR1B |= _BV(RXCIE1);
     #else
     	UCSR1B |= _BV(RXCIE);
     #endif
     #endif
     	sei();
     #else
     	printf("Connecting to port %s.\n", xbee_com_port);
     	xbee_stream = open(xbee_com_port, O_RDWR);
     	if (xbee_stream == -1/* || lockf(xbee_stream, F_TEST, 0) != 0*/)
+        {
           printf("Failed to open connection to XBee on port %s\r\n", xbee_com_port);
           return -1;
         } else {
     	  printf("Successfully opened connection to XBee on port %s\r\n", xbee_com_port);
+    	{
     		WL_DEBUG_PRINT("Failed to open connection to XBee on port ");
     		WL_DEBUG_PRINT_INT(xbee_com_port);
     		WL_DEBUG_PRINT(".\n");
     		return -1;
     	} else {
     	  WL_DEBUG_PRINT("Successfully opened connection to XBee on port ");
     		WL_DEBUG_PRINT_INT(xbee_com_port);
     		WL_DEBUG_PRINT(".\n");
+    	}
     	// set baud rate, etc. correctly
-...
     	options.c_cc[VTIME] = 50;
     	if (tcsetattr(xbee_stream, TCSANOW, &options))
+        {
           fprintf(stderr, "Error setting attributes.\n");
           return -1;
         } else {
     	  //printf("Successfully set termios attributes.\n");
+    	{
     		WL_DEBUG_PRINT("Error setting attributes.\n");
     		return -1;
+    	}
     	//lockf(xbee_stream, F_LOCK, 0);
     	xbee_listen_thread = (pthread_t*)malloc(sizeof(pthread_t));
     	if (xbee_listen_thread == NULL)
+        {
           fprintf(stderr, "%s: Malloc failed.\n", __FUNCTION__);
           return -1;
+        }
+    	{
     		WL_DEBUG_PRINT("Malloc failed.\n");
     		return -1;
+    	}
     	int ret = pthread_create(xbee_listen_thread, NULL, listen_to_xbee, NULL);
     	if (ret)
+        {
           fprintf(stderr, "Failed to create listener thread.\r\n");
           return -1;
         } else {
     	  //printf("Successfully created listener thread.\n");
+    	{
     		WL_DEBUG_PRINT("Failed to create listener thread.\n");
     		return -1;
+    	}
     #endif
     	//DEBUGGING PRINT
     	//printf("about to call xbee_enter_command_mode\n");
     	WL_DEBUG_PRINT("Entering command mode.\n");
     	if (xbee_enter_command_mode() != 0) {
     #ifndef ROBOT
     	  printf("Error returned from xbee_enter_command_mode\n");
     #endif
     		return -1;
+    	}
     	//DEBUGGING PRINT
     	//printf("about to call xbee_enter_api_mode\n");
     	WL_DEBUG_PRINT("Entered command mode.\n");
     	if (xbee_enter_api_mode() != 0) {
     #ifndef ROBOT
     	  printf("Error returned from xbee_enter_api_mode\n");
     #endif
     		return -1;
+    	}
     	//DEBUGGING PRINT
     	//printf("about to call xbee_exit_command_mode\n");
     	WL_DEBUG_PRINT("Entered api mode.\n");
     	if (xbee_exit_command_mode() != 0) {
     #ifndef ROBOT
     	  printf("Error returned from xbee_exit_command_mode\n");
     #endif
     		return -1;
+    	}
     	//DEBUGGING PRINT
     	//printf("about to call xbee_send_read_at_command\n");
     	WL_DEBUG_PRINT("Left command mode.\n");
     	if (xbee_send_read_at_command("MY")) {
     #ifndef ROBOT
     	  printf("Error returned from xbee_send_read_at_command\n");
     #endif
     		return -1;
+    	}
     	WL_DEBUG_PRINT("Getting ATMY address.\n");
     #ifndef ROBOT
     	//printf("About to enter while loop to get xbee_address.\n");
     	int i;
     	for (i = 0; xbee_address == 0 && i < XBEE_GET_PACKET_TIMEOUT; i++) {
     	  ret = xbee_get_packet(NULL);
-...
     	  usleep(1000);
     	  if (ret == -1) {
           //printf("xbee_get_packet(NULL) failed.\n");
           return -1;
     	    WL_DEBUG_PRINT("xbee_get_packet(NULL) failed.\n");
     	    return -1;
+    	  }
+    	}
     	//	printf("After exiting while loop to get xbee_address.\n");
     #else
     	//wait to return until the address is set
       //TODO: this shouldn't wait indefinitely.  There should be some sort of reasonable timeout
       // so if the address is never set right, an error can be returned instead of having the
       // robot hang forever
     	while (xbee_address == 0) {
     	  xbee_get_packet(NULL);
+    	}
     #endif
     	WL_DEBUG_PRINT("Got ATMY address.\n");
     #ifndef ROBOT
     	if (i == XBEE_GET_PACKET_TIMEOUT) { // We timed-out.
     	  printf("xbee_get_packet timed out.\n");
     	  WL_DEBUG_PRINT("xbee_get_packet timed out.\n");
     	  return -1;
     	} else {
     	  return 0;
-...
      **/
     void xbee_terminate()
+    {
     #ifndef ROBOT
     	#ifndef ROBOT
     	pthread_cancel(*xbee_listen_thread);
     	free(xbee_listen_thread);
     	lockf(xbee_stream, F_ULOCK, 0);
     	close(xbee_stream);
     #endif
     	#endif
+    }
     /**
-...
     	return 0;
     #else
     	//DEBUGGING PRINT
     	//printf("in xbee_send ");
     	//printHex(buf, size);
     	int ret = write(xbee_stream, buf, size);
     	//success
     	if (ret == size)
     		return 0;
     	if (ret == -1)
+        {
           //interrupted by system signal, probably timer interrupt.
           //just try again
           if (errno == 4)
+            {
               return xbee_send(buf, size);
+            }
           printf("Failed to write to xbee, error %i.\r\n", errno);
           return -1;
+        }
+    	{
     		//interrupted by system signal, probably timer interrupt.
     		//just try again
     		if (errno == 4)
+    		{
     			return xbee_send(buf, size);
+    		}
     		WL_DEBUG_PRINT("Failed to write to xbee\r\n");
     		return -1;
+    	}
     	//write was interrupted after writing ret bytes
     	return xbee_send(buf + ret, size - ret);
-...
+     *
      * @param c the string to send to the XBEE
      **/
     //TODO: this function is so simple, it *may* be beneficial to inline this function.  testing of if
     // it reduces code size or not should be done to be sure.
     static int xbee_send_string(char* c)
+    {
     	return xbee_send(c, strlen(c));
-...
     static int xbee_read(char* buf, int size)
+    {
     	if (read(xbee_stream, buf, size) == -1) {
     		printf("Failed to read from xbee.\r\n");
     		WL_DEBUG_PRINT("Failed to read from xbee.\r\n");
     		return -1;
+    	}
-...
     		return -1;
+    	}
     #ifndef ROBOT
     	//	printf("In xbee_enter_command_mode about to call xbee_wait_for_ok()\n");
     #endif
     	if (xbee_wait_for_ok() != 0) {
     #ifndef ROBOT
     	  printf("xbee_wait_for_ok failed.\n");
     #endif
     	  return -1;
     	} else {
+    	}
     	  return 0;
+    	}
+    }
     /**
-...
+    }
     /**
      * Exit API mode. (warning - does not check for response)
      **/
     static int xbee_exit_api_mode()
+    {
     	return xbee_send_string("ATAP 0\r");
+    }
     /**
      * Wait until the string "OK\r" is received from the XBee.
      **/
     //TODO: this function is so simple, it *may* be beneficial to inline this function.  testing of if
     // it reduces code size or not should be done to be sure.
     static int xbee_wait_for_ok()
+    {
       //DEBUGGING PRINT
       //printf("\tin xbee_wait_for_ok\n");
     	return xbee_wait_for_string("OK\r", 3);
+    }
-...
      **/
     static int xbee_wait_for_string(char* s, int len)
+    {
       //DEBUGGING PRINT
       //printf("\t in xbee_wait_for_string\n");
     #ifndef ROBOT
       //printf("In xbee_wait_for_string.\n");
     #endif
     	char* curr = s;
     	while (curr - s < len) {
     		// check if buffer is empty
     		if (buffer_last != buffer_first) {
     #ifdef ROBOT
     		  cli();
     #endif
     			char c = arrival_buf[buffer_first++];
     			usb_putc(c);
     			usb_putc('\n');
     			if (buffer_first == XBEE_BUFFER_SIZE) {
     				buffer_first = 0;
+    			}
     #ifdef ROBOT
     			sei();
     #endif
     			//DEBUGGING PRINT
     			//printf("\t\t c is %c (%d)\n", c, (int)c);
     			if (c == *curr) {
     				curr++;
-...
      **/
     static int xbee_send_frame(char* buf, int len)
+    {
     	//printf("in %s and len is %d\n", __FUNCTION__, len);
     	char prefix[3];
     	prefix[0] = XBEE_FRAME_START;
     	prefix[1] = (len & 0xFF00) >> 8;
-...
      * use ID to read the PAN ID and MY to return the XBee ID.
      * See the XBee reference guide for a complete listing.
      **/
     //TODO: this function is so simple, it *may* be beneficial to inline this function.  testing of if
     // it reduces code size or not should be done to be sure.
     static int xbee_send_read_at_command(char* command)
+    {
     	return xbee_send_modify_at_command(command, NULL);
-...
      **/
     static int xbee_send_modify_at_command(char* command, char* value)
+    {
     	//printf("in %s with command %s and value %s\n", __FUNCTION__, command, value);
     	char buf[16];
     	int i;
-...
     	buf[3] = command[1];
     	int valueLen = 0;
     	if (value != NULL)
+        {
           valueLen = strlen(value);
           if (valueLen > 8)
+            {
               WL_DEBUG_PRINT("AT Command too large.\r\n");
               return -1;
+            }
+    	{
     		valueLen = strlen(value);
     		if (valueLen > 8)
+    		{
     			WL_DEBUG_PRINT("AT Command too large.\r\n");
     			return -1;
+    		}
           for (i = 0; i < valueLen; i++) {
             buf[4 + i] = value[i];
+          }
+        }
     		for (i = 0; i < valueLen; i++) {
     			buf[4 + i] = value[i];
+    		}
+    	}
     	return xbee_send_frame(buf, 4 + valueLen);
+    }
-...
     	unsigned char checksum = 0;
     	if (len > 100)
+        {
           WL_DEBUG_PRINT("Packet is too large.\r\n");
           return -1;
+        }
+    	{
     		WL_DEBUG_PRINT("Packet is too large.\r\n");
     		return -1;
+    	}
     	//data for sending request
     	buf[0] = XBEE_FRAME_TX_REQUEST_16;
-...
+    {
     	//start reading a packet with XBEE_FRAME_START
     	if (currentBufPos == 0)
+        {
     #ifdef ROBOT
           cli();
     #endif
           do
+            {
               if (buffer_first == XBEE_BUFFER_SIZE)
                 buffer_first = 0;
               // check if buffer is empty
               if (buffer_first == buffer_last) {
     #ifdef ROBOT
                 sei();
     #endif
                 return 0;
+              }
             } while (arrival_buf[buffer_first++] != XBEE_FRAME_START);
+    	{
     		do
+    		{
     			if (buffer_first == XBEE_BUFFER_SIZE)
     				buffer_first = 0;
     			// check if buffer is empty
     			if (buffer_first == buffer_last) {
     				return 0;
+    			}
     		} while (arrival_buf[buffer_first++] != XBEE_FRAME_START);
           if (buffer_first == XBEE_BUFFER_SIZE) {
             buffer_first = 0;
+          }
     #ifdef ROBOT
           sei();
     #endif
           xbee_buf[0] = XBEE_FRAME_START;
           currentBufPos++;
+        }
     		if (buffer_first == XBEE_BUFFER_SIZE) {
     			buffer_first = 0;
+    		}
     		xbee_buf[0] = XBEE_FRAME_START;
     		currentBufPos++;
+    	}
     	int len = -1;
     	if (currentBufPos >= 3) {
-...
+    	}
     	while (len == -1 //packet length has not been read yet
              || currentBufPos < len + 4)
+        {
           if (currentBufPos == 3)
+            {
               len = (int)xbee_buf[2] + ((int)xbee_buf[1] << 8);
               if (len > 120)
+                {
                   WL_DEBUG_PRINT("Packet too large. Probably error in XBee transmission.\n");
                   currentBufPos = 0;
                   return -1;
+                }
+            }
     		|| currentBufPos < len + 4)
+    	{
     		if (currentBufPos == 3)
+    		{
     			len = (int)xbee_buf[2] + ((int)xbee_buf[1] << 8);
     			if (len > 120)
+    			{
     				WL_DEBUG_PRINT("Packet too large. Probably error in XBee transmission.\n");
     				currentBufPos = 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 793