Colony

#define LEAVING 4

/*Frame Types*/

/*Function Prototypes*/

static void wl_token_get_token(void);

/*Packet Handling Routines*/

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;

// the amount of time a robot has had its BOM on for

static int bom_on_count = 0;

static void do_nothing(void) {}

static int get_nothing(void) {return -1;}

#ifdef ROBOT

#ifndef FIREFLY

		return -1;

	}

	//add ourselves to the sensor matrix

	wl_register_packet_group(&wl_token_ring_handler);

// it reduces code size or not should be done to be sure.

static void wl_token_ring_cleanup()

{

}

/**

		//also, declare that person dead, as long as it isn't us

		if (wl_token_next_robot != wl_get_xbee_id())

		{

			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)

	{

		{

			WL_DEBUG_PRINT("Creating our own token ring, no robots seem to exist.\r\n");

			ringState = MEMBER;

			//this will make us pass the token to ourself

			//repeatedly, and other robots when they join

	switch (type)

	{

		case WL_TOKEN_PASS:

			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 -1;

// it reduces code size or not should be done to be sure.

int wl_token_get_robots_in_ring(void)

{

}

/**

// it reduces code size or not should be done to be sure.

int wl_token_is_robot_in_ring(int robot)

{

}

/**

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

		i++;

	}

  //TODO: if you do the above comment, then you can compare this to the variable also

		i = -1;

	}

  // 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++;

		iteratorCount++;

	}

  //TODO: if you do the above comment, then you can compare this to the variable also

		iteratorCount = -1;

	}

// it reduces code size or not should be done to be sure.

int wl_token_get_num_robots(void)

{

}

/**

// it reduces code size or not should be done to be sure.

int wl_token_get_matrix_size(void)

{

}

/**

 * 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

 */

{

	int i, j;

	bom_on_count = -1;

	deathDelay = -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)

  // 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 == source) {

			continue;

				accepted = -1;

				WL_DEBUG_PRINT("Someone accepted the robot we did.\r\n");

			}

						sensorData[2 * j + 1]);

			j++;

		}

		else

		{

			{

				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");

			}

			if (i == wl_get_xbee_id() && ringState == MEMBER)

			//the person who accepted us is dead... let's ask again

			if (i == acceptor)

			{

				ringState = NONMEMBER;

				acceptor = -1;

				wl_token_ring_join();

			}

		}

	}

	deathDelay = get_token_distance(wl_get_xbee_id(), nextRobot) * DEATH_DELAY;

}

/**

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

			curr = 0;

		if (curr == robot2)

			break;

			count++;

		curr++;

	}

 **/

static int wl_token_pass_token()

{

	int i = wl_get_xbee_id() + 1;

	if (accepted == -1)

	{

		while (1)

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

				i = 0;

			}

			{

				nextRobot = (char)i;

				break;

	{

		WL_DEBUG_PRINT("Accepting new robot, sending it the token.\r\n");

		//add a new robot to the token ring

		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

		{

			j++;

		}

	}

	WL_DEBUG_PRINT("Passing the token to robot ");

	WL_DEBUG_PRINT(".\r\n");

		return -1;

	wl_token_next_robot = nextRobot;

	deathDelay = DEATH_DELAY;

	return 0;

}

	bom_on_count = 0;

		source, get_max_bom_function());

}

	WL_DEBUG_PRINT("We have the token.\r\n");

	if (ringState == ACCEPTED)

	{

		WL_DEBUG_PRINT("Now a member of the token ring.\r\n");

		ringState = MEMBER;

		joinDelay = -1;

	if (ringState == LEAVING || ringState == NONMEMBER)

	{

		if (ringState == NONMEMBER)

		{

			WL_DEBUG_PRINT("We should have left the token ring, but didn't.\r\n");

	#endif

	bom_off_function();

	{

		WL_DEBUG_PRINT("Removed from sensor matrix while flashing BOM.\r\n");

		return;

	while (1)

	{

		if (i < 0)

		//we must send a join acceptance

		if (i == wl_get_xbee_id())

			break;

		//another robot will handle it

			return;

		i--;

	WL_DEBUG_PRINT(" into the token ring.\r\n");

	// the token ring has not started yet

		wl_token_pass_token();

}

	acceptor = source;

	//add ourselves to the token ring

}