/ - Diff - Colony - Robotics Club

Revision 732

Added by Brian Coltin about 16 years ago

New stuff works, fixed bugs, removed malloc.

     /*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;
-...
     		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);
-...
      **/
     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
-...
     			wl_token_pass_receive(source);
     			break;
     		case WL_TOKEN_SENSOR_MATRIX:
     			if (length < 1)
+    			{
     				WL_DEBUG_PRINT("Malformed Token Pass packet received.\r\n");
     				return;
+    			}
     			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;
-...
      **/
     int wl_token_get_robots_in_ring(void)
+    {
     	return sensor_matrix_get_joined(sensorMatrix);
     	return sensor_matrix_get_joined();
+    }
     /**
-...
      **/
     int wl_token_is_robot_in_ring(int robot)
+    {
     	return sensor_matrix_get_in_ring(sensorMatrix, robot);
     	return sensor_matrix_get_in_ring(robot);
+    }
     /**
-...
+    {
     	int i = 0;
     	while (!sensor_matrix_get_in_ring(sensorMatrix, i) && i < sensor_matrix_get_size(sensorMatrix)) {
     	while (!sensor_matrix_get_in_ring(i) && i < sensor_matrix_get_size()) {
     		i++;
+    	}
     	if (i == sensor_matrix_get_size(sensorMatrix)) {
     	if (i == sensor_matrix_get_size()) {
     		i = -1;
+    	}
-...
+    	}
     	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)) {
     	if (iteratorCount == sensor_matrix_get_size()) {
     		iteratorCount = -1;
+    	}
-...
      **/
     int wl_token_get_num_robots(void)
+    {
     	return sensor_matrix_get_joined(sensorMatrix);
     	return sensor_matrix_get_joined();
+    }
     /**
-...
      **/
     int wl_token_get_matrix_size(void)
+    {
     	return sensor_matrix_get_size(sensorMatrix);
     	return sensor_matrix_get_size();
+    }
     /**
-...
      **/
     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 && bom_on_count <= DEATH_DELAY / 2 &&
     	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");
-...
+    	}
     	bom_on_count = -1;
     	deathDelay = -1;
     	sensor_matrix_set_in_ring(sensorMatrix, source, 1);
     	sensor_matrix_set_in_ring(source, 1);
     	wl_token_get_token();
+    }
-...
     	i = source + 1;
     	while (1)
+    	{
     		if (i == sensor_matrix_get_size(sensorMatrix)) {
     		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;
-...
     	bom_on_count = -1;
     	deathDelay = -1;
     	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++)
     	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();
-...
     	deathDelay = get_token_distance(wl_get_xbee_id(), nextRobot) * DEATH_DELAY;
     	if (sensor_matrix_get_size(sensorMatrix) == 0 && ringState == JOINING)
     		wl_send_robot_to_robot_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_PASS, NULL, 0, nextRobot, WL_TOKEN_PASS_FRAME);
     	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))
     		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++;
+    	}
-...
+    {
     	char nextRobot = 0xFF;
     	int i = wl_get_xbee_id() + 1;
     	char buf[2 * sensor_matrix_get_size()];
     	WL_DEBUG_PRINT("PASSING\n");
     	if (accepted == -1)
+    	{
     		while (1)
+    		{
     			if (i == sensor_matrix_get_size(sensorMatrix)) {
     			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;
+    	}
     	WL_DEBUG_PRINT("2\n");
     	//we don't include ourself
     	int packetSize = 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;
+    	}
     	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())
     	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(sensorMatrix, wl_get_xbee_id(), i);
     			buf[2*j + 1] = sensor_matrix_get_reading(wl_get_xbee_id(), i);
     			j++;
+    		}
+    	}
     	int packetSize = 2 * sensor_matrix_get_size() * sizeof(char);
     	WL_DEBUG_PRINT("Passing the token to robot ");
     	WL_DEBUG_PRINT_INT(nextRobot);
     	WL_DEBUG_PRINT(".\r\n");
-...
     		free(buf);
     		return -1;
+    	}
     	if (wl_send_robot_to_robot_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_PASS, NULL, 0, nextRobot, WL_TOKEN_PASS_FRAME))
     	if (wl_send_robot_to_robot_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_PASS, NULL, 0, nextRobot, WL_TOKEN_PASS_FRAME))
+    	{
     		free(buf);
     		return -1;
-...
     	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
+     *
-...
     typedef struct
+    {
     	/**
     	 * The size of the sensor matrix.
     	**/
     	int size;
     	 * 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.
     	 **/
     	int* joined;
     	/**
     	 * The number of robots in the token ring.
     	 **/
     	int numJoined;
     	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
     // TODO: is this a good size?
     #define XBEE_BUFFER_SIZE	256
     #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[128];
     static char xbee_buf[PACKET_BUFFER_SIZE];
     static int currentBufPos = 0;
     //XBee status
-...
     	while (1)
+    	{
     		if (xbee_read(&c, 1) != 0) {
     			fprintf(stderr, "xbee_read failed.\n");
     			WL_DEBUG_PRINT("xbee_read failed.\n");
     			return NULL;
+    		}
-...
      **/
     int xbee_lib_init()
+    {
     	arrival_buf[0] = 'A';
     	arrival_buf[1] = 'A';
     	arrival_buf[2] = 'A';
     	#ifdef ROBOT
     	//enable the receiving interrupt
-...
+    }
     /**
      * 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.
      **/
     static void xbee_wait_for_ok()

     #include "sensor_matrix.h"
     #define DEFAULT_SENSOR_MATRIX_SIZE 20
     // the global sensor matrix
     SensorMatrix m;
     /*Sensor Matrix Functions*/
     static void sensor_matrix_expand(SensorMatrix* m, int nextSize);
     /**
      * Initializes the sensor matrix.
+     *
      * @return the newly created sensor matrix
      **/
     SensorMatrix* sensor_matrix_create()
     void sensor_matrix_create()
+    {
     	SensorMatrix* m;
     	int i;
     	m = (SensorMatrix*)malloc(sizeof(SensorMatrix));
     	if (!m)
+    	{
     		WL_DEBUG_PRINT("Out of memory - create sensor matrix.\r\n");
     		return NULL;
+    	}
     	m->size = DEFAULT_SENSOR_MATRIX_SIZE;
     	m->matrix = (int**)malloc(m->size * sizeof(int*));
     	if (!(m->matrix)) {
     	  WL_DEBUG_PRINT("Out of memory - allocating memory for matrix.\r\n");
     	  free(m);
     	  return NULL;
+    	}
     	m->joined = (int*)malloc(m->size * sizeof(int));
     	if (!(m->joined)) {
     	  WL_DEBUG_PRINT("Out of memory - allocating memory for joined.\r\n");
     	  free(m->matrix);
     	  free(m);
     	  return NULL;
+    	}
     	m->numJoined = 0;
     	if (!(m->matrix) || !(m->joined))
+    	{
     		WL_DEBUG_PRINT("Out of memory - create sensor matrix 2.\r\n");
     		return NULL;
+    	}
     	for (i = 0; i < m->size; i++)
+    	{
     		m->matrix[i] = NULL;
     		m->joined[i] = 0;
+    	}
     	return m;
+    }
     /**
      * Deletes and frees memory from the sensor matrix.
+     *
      * @param m the sensor matrix to delete
      **/
     void sensor_matrix_destroy(SensorMatrix* m)
+    {
     	int i;
     	for (i = 0; i < m->size; i++)
     		if (m->matrix[i] != NULL)
     			free(m->matrix[i]);
     	free(m->matrix);
     	free(m->joined);
     	free(m);
+    }
     /**
      * Adds robot with XBee id id to the sensor matrix.
+     *
      * @param m the sensor matrix
      * @param id the XBee ID of the robot to add
      **/
     void sensor_matrix_add_robot(SensorMatrix* m, int id)
+    {
     	int i;
     	if (id >= m->size) {
     		sensor_matrix_expand(m, id + 1);
+    	}
     	if (m->matrix[id] != NULL) {
     		return;
+    	}
     	m->matrix[id] = (int*)malloc(m->size * sizeof(int));
     	if (!(m->matrix[id]))
+    	{
     		WL_DEBUG_PRINT("Out of memory - add robot.\r\n");
     		return;
+    	}
     	for (i = 0; i < m->size; i++) {
     		if (m->matrix[i] != NULL) {
     			m->matrix[i][id] = -1;
+    		}
+    	}
+    }
     /**
      * Removes robot with id from the sensor matrix, and removes
      * all sensor information regarding the robot.
+     *
      * @param m the sensor matrix
      * @param id the XBee ID of the robot to remove
      **/
     void sensor_matrix_remove_robot(SensorMatrix* m, int id)
+    {
     	int i;
     	if (id >= m->size || m->matrix[id] == NULL)
+    	{
     		WL_DEBUG_PRINT("Removing robot not added to matrix.\r\n");
     		return;
+    	}
     	free(m->matrix[id]);
     	m->matrix[id] = NULL;
     	for (i = 0 ; i < m->size; i++)
     		if (m->matrix[i] != NULL)
     			m->matrix[i][id] = -1;
     	m->joined[id] = 0;
+    }
     /**
      * Expands the size of the sensor matrix if an id number we attempt
      * to add is too large.
+     *
      * @param m the sensor matrix to expand
      * @param size the new size of the sensor matrix
      **/
     //Note: this has probably not been tested, hopefully it works
     static void sensor_matrix_expand(SensorMatrix* m, int nextSize)
+    {
     	int i, j;
     	WL_DEBUG_PRINT("Expanding sensor matrix.\r\n");
     	int** tempMatrix = (int**)malloc(nextSize * sizeof(int*));
     	if (!tempMatrix)
+    	{
     		WL_DEBUG_PRINT("Out of memory - expand matrix.\r\n");
     		return;
+    	}
     	m.numJoined = 0;
     	for (i = 0; i < nextSize; i++)
     		tempMatrix[i] = NULL;
     	//copy over old sensor data
     	for (i = 0; i < m->size; i++)
     		if (m->matrix[i] != NULL)
+    		{
     		  tempMatrix[i] = (int *)malloc(nextSize * sizeof(int));
     			if (!tempMatrix[i])
+    			{
     				WL_DEBUG_PRINT("Out of memory - expand matrix 2.\r\n");
     				return;
+    			}
     			for (j = 0; j < m->size; j++) {
     				tempMatrix[i][j] = m->matrix[i][j];
+    			}
     			for (j = m->size; j < nextSize; j++) {
     				tempMatrix[i][j] = -1;
+    			}
     			free(m->matrix[i]);
+    		}
     	free(m->matrix);
     	m->matrix = tempMatrix;
     	m->size = nextSize;
     	//expand the size of joined
     	int* tempJoined = (int *)malloc(nextSize * sizeof(int));
     	if (!tempJoined)
     	for (i = 0; i < MAXIMUM_XBEE_ID; i++)
+    	{
     		WL_DEBUG_PRINT("Out of memory - expand matrix 3.\r\n");
     		return;
     		m.joined[i] = 0;
     		for (j = 0; j < MAXIMUM_XBEE_ID; j++)
     			m.matrix[i][j] = READING_UNKNOWN;
+    	}
     	for (i = 0; i < m->size; i++) {
     		tempJoined[i] = m->joined[i];
+    	}
     	for (i = m->size; i < nextSize; i++) {
     		tempJoined[i] = 0;
+    	}
     	free(m->joined);
     	m->joined = tempJoined;
+    }
     /**
      * Sets the sensor reading for robot robot to reading.
+     *
      * @param m the sensor matrix to set the reading for
      * @param observer the id of the robot who made the reading
      * @param robot the id of the robot who the reading is for
      * @param reading the BOM reading from observer to robot
      */
     void sensor_matrix_set_reading(SensorMatrix* m, int observer, int robot, int reading)
     void sensor_matrix_set_reading(int observer, int robot, int reading)
+    {
     	if (robot >= m->size || observer >= m->size || m->matrix[observer] == NULL) {
     		sensor_matrix_add_robot(m, observer);
     	if (robot >= MAXIMUM_XBEE_ID || observer >= MAXIMUM_XBEE_ID)
+    	{
     		WL_DEBUG_PRINT("ID too large.");
     		return;
+    	}
     	m->matrix[observer][robot] = reading;
     	m.matrix[observer][robot] = (unsigned char)reading;
+    }
     /**
      * Gets the sensor reading for a robot to another robot.
+     *
      * @param m the sensor matrix
      * @param observer the robot whose reading we check
      * @param robot the robot who we are checking the reading to
+     *
      * @return the observer's BOM reading for robot
      **/
     int sensor_matrix_get_reading(SensorMatrix* m, int observer, int robot)
     int sensor_matrix_get_reading(int observer, int robot)
+    {
     	if (observer >= m->size || robot >= m->size) {
     	if (observer >= MAXIMUM_XBEE_ID || robot >= MAXIMUM_XBEE_ID)
     		return -1;
+    	}
     	return m->matrix[observer][robot];
     	return (int)m.matrix[observer][robot];
+    }
     /**
      * Sets whether or not the given robot is part of the token ring.
+     *
      * @param m the sensor matrix
      * @param robot the robot to set as a member / nonmember of the token ring
      * @param in 1 if the robot is in the token ring, 0 otherwise
      **/
     void sensor_matrix_set_in_ring(SensorMatrix* m, int robot, int in)
     void sensor_matrix_set_in_ring(int robot, int in)
+    {
     	if (robot >= m->size) {
     		sensor_matrix_expand(m, robot + 1);
     	if (robot >= MAXIMUM_XBEE_ID)
+    	{
     		WL_DEBUG_PRINT("ID too large.");
     		return;
+    	}
     	if (in == 1) {
     		sensor_matrix_add_robot(m, robot);
+    	}
     	if (in == 1 && m.joined[robot] == 0)
     		m.numJoined++;
     	if (in == 1 && m->joined[robot] == 0) {
     		m->numJoined++;
+    	}
     	if (in == 0 && m.joined[robot])
     		m.numJoined--;
     	if (in == 0 && m->joined[robot] == 1) {
     		m->numJoined--;
+    	}
     	m->joined[robot] = in;
     	m.joined[robot] = in;
+    }
     /**
      * Checks if the given robot is in the token ring.
+     *
      * @param m the sensor matrix
      * @param robot the ID of the robot to check
+     *
      * @return 1 if the robot is in the token ring, 0 otherwise
      **/
     int sensor_matrix_get_in_ring(SensorMatrix* m, int robot)
     int sensor_matrix_get_in_ring(int robot)
+    {
     	if (robot >= m->size) {
     	if (robot >= MAXIMUM_XBEE_ID)
     		return -1;
+    	}
     	return m->joined[robot];
     	return m.joined[robot];
+    }
     /**
      * Returns the size of the sensor matrix.
      * Returns the number of robots which have joined the
      * token ring.
+     *
      * @param m the sensor matrix
+     *
      * @return the size of the sensor matrix
      * @return the number of robots in the token ring
      **/
     int sensor_matrix_get_size(SensorMatrix* m)
     int sensor_matrix_get_joined(void)
+    {
     	return m->size;
     	return m.numJoined;
+    }
     /**
      * Returns the number of robots which have joined the
      * token ring.
      * Returns the maximum XBee id of a robot which can be stored
      * in the sensor matrix.
+     *
      * @param m the sensor matrix
+     *
      * @return the number of robots in the token ring
      * @return the maximum number of robots which can be stored
      **/
     int sensor_matrix_get_joined(SensorMatrix* m)
     inline int sensor_matrix_get_size(void)
+    {
     	return m->numJoined;
     	return MAXIMUM_XBEE_ID;
+    }

Also available in: Unified diff

Project

General

Profile

Colony

Revision 732