Colony

          int_tokens[0], int_tokens[1], int_tokens[2]);

  if (colonet_wl_send((short)pool_index, int_tokens[0], (ColonetMessageType)int_tokens[1], int_tokens[2], arguments)

      != 0) {

  }

  return 0;

  int num_robots;

  int* xbee_ids = colonet_get_xbee_ids(&num_robots);

  if (!connection_pool) {

    return -1;

  }

    }

  } else {

    printf("sending to specific robot.\n");

  }

  return 0;

  wl_token_iterator_begin();

  while (wl_token_iterator_has_next()) {

  }

  *numrobots = num_robots;

/**************************** Private functions ******************************/

static void timeout_handler() {

}

static void handle_response(int frame, int received) {

#define u_int32_t unsigned

/**

 * @brief Default constructor for ColonetServer

	make; ./ColonetServer

	../vision/vision.sh

	cd ../../libwireless/lib; make colonet

	@echo "---begin compilation---"

	@echo ""

	@echo "---create object files---"

/*Function Prototypes*/

/*Wireless Library Prototypes*/

/*Helper Functions*/

/*Packet Handling Routines*/

/*Global Variables*/

//the sensor matrix

//the robot we are waiting to say it has received the token. -1 if unspecified

//true if the robot should be in the token ring, 0 otherwise

//the id of the robot who accepted us into the token ring, only used in ACCEPTED state

//id of the robot we are accepting

//the counter for when we assume a robot is dead

//the counter for joining, before we form our own token ring

//current robot to check in the iterator

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

#ifdef ROBOT

#ifndef FIREFLY

#else

#endif

#else

#endif

		wl_token_ring_response_handler, wl_token_ring_receive_handler,

		wl_token_ring_cleanup};

 * Initialize the token ring packet group and register it with the

 * wireless library. The robot will not join a token ring.

 **/

{

	if (wl_get_xbee_id() > 0xFF)

	{

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

	}

	sensorMatrix = sensor_matrix_create();

	sensor_matrix_set_in_ring(sensorMatrix, wl_get_xbee_id(), 0);

	wl_register_packet_group(&wl_token_ring_handler);

}

/**

/**

 * Called approximately every quarter second by the wireless library.

 **/

{

	//someone is not responding, assume they are dead

	if (deathDelay == 0)

 * @param frame the frame number assigned when the packet was sent

 * @param received 1 if the packet was received, 0 otherwise

 **/

{

	if (!received)

	{

 * @param packet the data in the packet

 * @param length the length of the packet in bytes

 **/

{

	switch (type)

	{

int wl_token_get_sensor_reading(int source, int dest)

{

	if (wl_token_is_robot_in_ring(dest) &&

		return sensor_matrix_get_reading(sensorMatrix, source, dest);

	return -1;

}

 *		reading for that robot, repeated for sensorDataLength bytes

 * @param sensorDataLength the length in bytes of sensorData

 */

{

	int i, j;

void wl_token_iterator_begin(void)

{

	int i = 0;

		i++;

		i = -1;

	iteratorCount = i;

}

int wl_token_iterator_next(void)

{

	int result = iteratorCount;

		return result;

	iteratorCount++;

		iteratorCount++;

		iteratorCount = -1;

	return result;

}

} PacketGroupHandler;

/**@brief Initialize the wireless library **/

/**@brief Uninitialize the wireless library **/

void wl_terminate(void);

/**@brief Perform wireless library functionality **/

void wl_unregister_packet_group(PacketGroupHandler* h);

/**@brief Send a packet to a specific robot in any PAN **/

/**@brief Send a packet to a specific robot in our PAN **/

/**@brief Send a packet to all robots **/

int wl_send_global_packet(char group, char type, char* data, int len, char frame);

/**@brief Send a packet to all robots in our PAN **/

/**@brief Set the PAN we are using **/

/**@brief Get the PAN we are using **/

int wl_get_pan(void);

/**@brief Set the channel we are using **/

/**@brief Get the channel we are using **/

int wl_get_channel(void);

/**@brief Get the 16-bit address of the XBee module **/

/*I/O Functions*/

static int xbee_send(char* buf, int size);

#ifndef ROBOT

#endif

/*Command Mode Functions

 * Called during initialization.

 */

static void xbee_wait_for_string(char* s, int len);

static void xbee_wait_for_ok(void);

/*API Mode Functions*/

/*Global Variables*/

//used to store packets as they are read

//XBee status

/*Function Implementations*/

#else

/**

 * Thread that listens to the xbee.

 **/

{

	char c;

	while (1)

	{

		arrival_buf[buffer_last] = c;

		int t = buffer_last + 1;

		if (t == XBEE_BUFFER_SIZE)

		usleep(1000);

	}

}

#endif

	}

#endif

	//wait to return until the address is set

	while (xbee_address == 0) xbee_get_packet(NULL);

 * @param buf the buffer of data to send

 * @param size the number of bytes to send

 **/

{

	int i;

		xbee_putc(buf[i]);

	int ret = write(xbee_stream, buf, size);

	//success

	if (ret == size)

	}

	//write was interrupted after writing ret bytes

}

/**

 *

 * @param c the string to send to the XBEE

 **/

{

}

#ifndef ROBOT

{

		printf("Failed to read from xbee.\r\n");

}

#endif

/**

 * Enter into command mode.

 **/

{

	xbee_wait_for_ok();

}

/**

 * Exit from command mode.

 **/

{

	xbee_wait_for_ok();

}

/**

 * Enter API mode.

 **/

{

	xbee_wait_for_ok();

}

/**

 * Exit API mode. (warning - does not check for response)

 **/

{

}

/**

 * @param len the size in bytes of the packet data

 *

 **/

{

	char prefix[3];

	prefix[0] = XBEE_FRAME_START;

	prefix[1] = (len & 0xFF00) >> 8;

	prefix[2] = len & 0xFF;

	char checksum = xbee_compute_checksum(buf, len);

}

/**

 * use ID to read the PAN ID and MY to return the XBee ID.

 * See the XBee reference guide for a complete listing.

 **/

{

}

/**

 * @param value the value to pass as a parameter

 * (or NULL if there is no parameter)

 **/

{

	char buf[16];

	int i;

		if (valueLen > 8)

		{

			WL_DEBUG_PRINT("AT Command too large.\r\n");

		}

			buf[4 + i] = value[i];

	}

}

/**

			// check if buffer is empty

			if (buffer_first == buffer_last)

				return -1;

		}

		xbee_buf[0] = XBEE_FRAME_START;

		currentBufPos++;

	}

	int len = -1;

		len = (int)xbee_buf[2] + ((int)xbee_buf[1] << 8);

	while (len == -1 //packet length has not been read yet

	{

		if (currentBufPos == 3)

		{

				return -1;

			}

		}

		// check if buffer is empty

			return -1;

		xbee_buf[currentBufPos++] = arrival_buf[buffer_first++];

			buffer_first = 0;

	}

	currentBufPos = 0;

	}

	//we will take care of the packet

		return -1;

		return -1;

	int i;

		dest[i - 3] = xbee_buf[i];

	return len;

}

 * @param extra the hex value of the requested register

 * @param extraLen the length in bytes of extra

 **/

{

	if (result == 1)

	{

	if (command[0] == 'M' && command[1] == 'Y' && extraLen != 0)

	{

		xbee_address = 0;

		int i;

			xbee_address = (xbee_address << 8) + extra[i];

		WL_DEBUG_PRINT("XBee address is ");

		WL_DEBUG_PRINT_INT(xbee_address);

 *

 * @return 1 if we have handled the packet, 0 otherwise

 */

{

	char command[3] = {1, 2, 3};

	if (len <= 0) //this should not happend

			command[0] = packet[2];

			command[1] = packet[3];

			command[2] = 0;

			return 1;

	}

	return 0;

 *

 * @param id the new personal area network (PAN) id

 **/

{

	char s[3];

	s[0] = (id >> 8) & 0xFF;

	s[1] = id & 0xFF;

	s[2] = 0;

	xbee_pending_panID = id;

}

/**

 *

 * @see xbee_get_channel

 **/

{

	if (channel < 0x0B || channel > 0x1A)

	{

		WL_DEBUG_PRINT("Channel out of range.\r\n");

	}

	char s[3];

	s[0] = channel & 0xFF;

	s[1] = 0;

	xbee_pending_channel = channel;

}

/**

 **/

/**@brief Register the token ring group with the wireless library.**/

/**@brief Unregister the token ring group with the wirelss library.**/

void wl_token_ring_unregister(void);

/**@brief Set the functions called to turn the bom on and off.**/

#define XBEE_RX 0x81

/**@brief Initialize the XBee library **/

/**@brief Uninitialize the XBee library **/

void xbee_terminate(void);

/**@brief Get a packet from the XBee **/

/**@brief Send a packet to the XBee **/

int xbee_send_packet(char* packet, int len, int dest, char options, char frame);

/**@brief Set the PAN ID for the XBee **/

/**@brief Get the XBee's PAN ID **/

unsigned int xbee_get_pan_id(void);

/**@brief Set the channel the XBee is currently using **/

/**@brief Get the channel the XBee is currently using **/

int xbee_get_channel(void);

/**@brief Get the XBee's 16-bit address **/

/**

 * 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

 * 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

#define DEFAULT_SENSOR_MATRIX_SIZE 20

/*Sensor Matrix Functions*/

/**

 * Initializes the sensor matrix.

{

	SensorMatrix* m;

	int i;

	m = (SensorMatrix*)malloc(sizeof(SensorMatrix));

	if (!m)

	{

		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;

/**

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

		sensor_matrix_expand(m, id + 1);

		return;

	m->matrix[id] = (int*)malloc(m->size * sizeof(int));

	if (!(m->matrix[id]))

	{

		return;

	}

			m->matrix[i][id] = -1;

}

/**

		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;

}

 * @param size the new size of the sensor matrix

 **/

//Note: this has probably not been tested, hopefully it works

{

	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;

	}

	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)

				WL_DEBUG_PRINT("Out of memory - expand matrix 2.\r\n");

				return;

			}

				tempMatrix[i][j] = m->matrix[i][j];

				tempMatrix[i][j] = -1;

			free(m->matrix[i]);

		}

	free(m->matrix);

	m->matrix = tempMatrix;

	m->size = nextSize;

		WL_DEBUG_PRINT("Out of memory - expand matrix 3.\r\n");

		return;

	}

		tempJoined[i] = m->joined[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

 */

void sensor_matrix_set_reading(SensorMatrix* m, int observer, int robot, int reading)

{

		sensor_matrix_add_robot(m, observer);

	m->matrix[observer][robot] = reading;

}

 **/

int sensor_matrix_get_reading(SensorMatrix* m, int observer, int robot)

{

		return -1;

	return m->matrix[observer][robot];

}

 **/

void sensor_matrix_set_in_ring(SensorMatrix* m, int robot, int in)

{

		sensor_matrix_expand(m, robot + 1);

		sensor_matrix_add_robot(m, robot);

		m->numJoined++;

		m->numJoined--;

	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

 *

 **/

int sensor_matrix_get_in_ring(SensorMatrix* m, int robot)

{

		return -1;

	return m->joined[robot];

}

 * Returns the size of the sensor matrix.

 *

 * @param m the sensor matrix

 * @return the size of the sensor matrix

 **/

int sensor_matrix_get_size(SensorMatrix* m)

{

	return m->numJoined;

}

 *

 * @see wl_get_pan

 **/

{

}

/**

 *

 * @see wl_get_channel

 **/

{

}

/**

 * @param dest the 16-bit address of the XBee to send the packet to

 * @param frame the frame number to see with a TX_STATUS response

 **/

{

}

/**

 * @param dest the 16-bit address of the XBee to send the packet to

 * @param frame the frame number to see with a TX_STATUS response

 **/

{

}

/**

		//this only works with under 16 groups

		int group = (int)(wl_buf[1] >> 4);

		int success = 0;

			success = 1;

		else

		{

			WL_DEBUG_PRINT("No response received.\r\n");