Colony

#include "stdlib.h"

#include "stdio.h"

#include "../lib/wireless.h"

#include "../lib/wl_error_group.h"

#include "../lib/wl_token_ring.h"

//#include "../lib/xbee.h"

#include <time.h>

int main()

{

	/*unsigned char buffer[128];

	xbee_lib_init(0x3331);

	printf("%i\n", xbee_get_address());

	struct timespec delay;

	delay.tv_sec = 0;

	delay.tv_nsec = 100000000;

	while (1)

	{

		int len = xbee_get_packet(buffer);

		if (len != -1)

		{

			int i;

			for (i = 0; i < len; i++)

				printf("%c", buffer[i]);

			printf("\n\r");

		}

		nanosleep(&delay, 0);

		wl_send_global_packet(1, 1, "CHECK", 3,

					0);

	}

	xbee_terminate();*/

	wl_init();

	printf("Wireless initialized.\n");

	wl_error_register();

	wl_token_ring_register();

	wl_token_ring_join();

	printf("Packet groups initialized.\n");

	struct timespec delay;

	delay.tv_sec = 0;

	delay.tv_nsec = 100000000;

	while (1)

	{

		//wl_error_send_string("s");

		wl_do();

		nanosleep(&delay, 0);

	}

	wl_terminate();

	return 0;

}

CC = gcc

CFLAGS = -Wall -g

all: test

test: *.c ../lib/*.c 

	$(CC) $(CFLAGS) *.c -L../lib -o test -pthread -lrt -lwireless

clean:

	rm *.o test ../lib/*.o

#include <dragonfly_lib.h>

#include <wireless.h>

#include <wl_token_ring.h>

int main(void)

{

	dragonfly_init(ALL_ON);

	usb_puts("Start.\r\n");

	wl_init();

	usb_puts("Wireless initialized.\n");

	wl_token_ring_register();

	wl_token_ring_join();

	while (1)

		wl_do();

}

# Hey Emacs, this is a -*- makefile -*-

#----------------------------------------------------------------------------

# WinAVR Makefile Template written by Eric B. Weddington, J?rg Wunsch, et al.

#

# Released to the Public Domain

#

# Additional material for this makefile was written by:

# Peter Fleury

# Tim Henigan

# Colin O'Flynn

# Reiner Patommel

# Markus Pfaff

# Sander Pool

# Frederik Rouleau

#

#----------------------------------------------------------------------------

# On command line:

#

# make all = Make software.

#

# make clean = Clean out built project files.

#

# make coff = Convert ELF to AVR COFF.

#

# make extcoff = Convert ELF to AVR Extended COFF.

#

# make program = Download the hex file to the device, using avrdude.

#                Please customize the avrdude settings below first!

#

# make debug = Start either simulavr or avarice as specified for debugging, 

#              with avr-gdb or avr-insight as the front end for debugging.

#

# make filename.s = Just compile filename.c into the assembler code only.

#

# make filename.i = Create a preprocessed source file for use in submitting

#                   bug reports to the GCC project.

#

# To rebuild project do "make clean" then "make all".

#----------------------------------------------------------------------------

#if you want your code to work on the Firefly++ and not Firefly+

#then add the -DFFPP line to CDEFS

COLONYROOT = y:

CDEFS = 

#-DFFPP

# MCU name

MCU = atmega128

# Processor frequency.

#     This will define a symbol, F_CPU, in all source code files equal to the 

#     processor frequency. You can then use this symbol in your source code to 

#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done

#     automatically to create a 32-bit value in your source code.

F_CPU = 8000000

# Output format. (can be srec, ihex, binary)

FORMAT = ihex

# Target file name (without extension).

TARGET = main

# List C source files here. (C dependencies are automatically generated.)

SRC = $(wildcard *.c)

#$(TARGET).c 

# List Assembler source files here.

#     Make them always end in a capital .S.  Files ending in a lowercase .s

#     will not be considered source files but generated files (assembler

#     output from the compiler), and will be deleted upon "make clean"!

#     Even though the DOS/Win* filesystem matches both .s and .S the same,

#     it will preserve the spelling of the filenames, and gcc itself does

#     care about how the name is spelled on its command-line.

ASRC = 

# Optimization level, can be [0, 1, 2, 3, s]. 

#     0 = turn off optimization. s = optimize for size.

#     (Note: 3 is not always the best optimization level. See avr-libc FAQ.)

OPT = s

# Debugging format.

#     Native formats for AVR-GCC's -g are dwarf-2 [default] or stabs.

#     AVR Studio 4.10 requires dwarf-2.

#     AVR [Extended] COFF format requires stabs, plus an avr-objcopy run.

DEBUG =

# List any extra directories to look for include files here.

#     Each directory must be seperated by a space.

#     Use forward slashes for directory separators.

#     For a directory that has spaces, enclose it in quotes.

EXTRAINCDIRS = $(COLONYROOT)/code/firefly_plus_lib

#C:\WinAVR\include\fwr

# Compiler flag to set the C Standard level.

#     c89   = "ANSI" C

#     gnu89 = c89 plus GCC extensions

#     c99   = ISO C99 standard (not yet fully implemented)

#     gnu99 = c99 plus GCC extensions

CSTANDARD = -std=gnu99

# Place -D or -U options here

CDEFS += -DF_CPU=$(F_CPU)UL 

CDEFS += -DFFP

# Place -I options here

CINCS = -I../lib -I../../libs_general/libdragonfly -L../lib -L../../libs_general/libdragonfly

#---------------- Compiler Options ----------------

#  -g*:          generate debugging information

#  -O*:          optimization level

#  -f...:        tuning, see GCC manual and avr-libc documentation

#  -Wall...:     warning level

#  -Wa,...:      tell GCC to pass this to the assembler.

#    -adhlns...: create assembler listing

CFLAGS = -g$(DEBUG)

CFLAGS += $(CDEFS) $(CINCS)

CFLAGS += -O$(OPT)

CFLAGS += -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums

CFLAGS += -Wall -Wstrict-prototypes

CFLAGS += -Wa,-adhlns=$(<:.c=.lst)

CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))

CFLAGS += $(CSTANDARD)

CFLAGS += -DROBOT

#---------------- Assembler Options ----------------

#  -Wa,...:   tell GCC to pass this to the assembler.

#  -ahlms:    create listing

#  -gstabs:   have the assembler create line number information; note that

#             for use in COFF files, additional information about filenames

#             and function names needs to be present in the assembler source

#             files -- see avr-libc docs [FIXME: not yet described there]

ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs 

#---------------- Library Options ----------------

# Minimalistic printf version

PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min

# Floating point printf version (requires MATH_LIB = -lm below)

PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt

# If this is left blank, then it will use the Standard printf version.

PRINTF_LIB = 

#PRINTF_LIB = $(PRINTF_LIB_MIN)

#PRINTF_LIB = $(PRINTF_LIB_FLOAT)

# Minimalistic scanf version

SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min

# Floating point + %[ scanf version (requires MATH_LIB = -lm below)

SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt

# If this is left blank, then it will use the Standard scanf version.

SCANF_LIB = 

#SCANF_LIB = $(SCANF_LIB_MIN)

#SCANF_LIB = $(SCANF_LIB_FLOAT)

MATH_LIB = -lm

#---------------- External Memory Options ----------------

# 64 KB of external RAM, starting after internal RAM (ATmega128!),

# used for variables (.data/.bss) and heap (malloc()).

#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff

# 64 KB of external RAM, starting after internal RAM (ATmega128!),

# only used for heap (malloc()).

#EXTMEMOPTS = -Wl,--defsym=__heap_start=0x801100,--defsym=__heap_end=0x80ffff

EXTMEMOPTS =

#---------------- Linker Options ----------------

#  -Wl,...:     tell GCC to pass this to linker.

#    -Map:      create map file

#    --cref:    add cross reference to  map file

LDFLAGS = -Wl,-Map=$(TARGET).map,--cref

LDFLAGS += $(EXTMEMOPTS)

LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)

LDFLAGS += -lwireless -ldragonfly

#---------------- Programming Options (avrdude) ----------------

# Programming hardware: alf avr910 avrisp bascom bsd 

# dt006 pavr picoweb pony-stk200 sp12 stk200 stk500

#

# Type: avrdude -c ?

# to get a full listing.

#

AVRDUDE_PROGRAMMER = avrisp

# com1 = serial port. Use lpt1 to connect to parallel port.

AVRDUDE_PORT = com4

# programmer connected to serial device

AVRDUDE_WRITE_FLASH = -b 57600 -U flash:w:$(TARGET).hex

#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

# Uncomment the following if you want avrdude's erase cycle counter.

# Note that this counter needs to be initialized first using -Yn,

# see avrdude manual.

#AVRDUDE_ERASE_COUNTER = -y

# Uncomment the following if you do /not/ wish a verification to be

# performed after programming the device.

#AVRDUDE_NO_VERIFY = -V

# Increase verbosity level.  Please use this when submitting bug

# reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude> 

# to submit bug reports.

#AVRDUDE_VERBOSE = -v -v

AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)

AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)

AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)

AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)

#don't check for device signature

AVRDUDE_FLAGS += -F

#---------------- Debugging Options ----------------

# For simulavr only - target MCU frequency.

DEBUG_MFREQ = $(F_CPU)

# Set the DEBUG_UI to either gdb or insight.

# DEBUG_UI = gdb

DEBUG_UI = insight

# Set the debugging back-end to either avarice, simulavr.

DEBUG_BACKEND = avarice

#DEBUG_BACKEND = simulavr

# GDB Init Filename.

GDBINIT_FILE = __avr_gdbinit

# When using avarice settings for the JTAG

JTAG_DEV = /dev/com1

# Debugging port used to communicate between GDB / avarice / simulavr.

DEBUG_PORT = 4242

# Debugging host used to communicate between GDB / avarice / simulavr, normally

#     just set to localhost unless doing some sort of crazy debugging when 

#     avarice is running on a different computer.

DEBUG_HOST = localhost

#============================================================================

# Define programs and commands.

SHELL = sh

CC = avr-gcc

OBJCOPY = avr-objcopy

OBJDUMP = avr-objdump

SIZE = avr-size

NM = avr-nm

AVRDUDE = avrdude

REMOVE = rm -f

REMOVEDIR = rm -rf

COPY = cp

WINSHELL = cmd

# Define Messages

# English

MSG_ERRORS_NONE = Errors: none

MSG_BEGIN = -------- begin --------

MSG_END = --------  end  --------

MSG_SIZE_BEFORE = Size before: 

MSG_SIZE_AFTER = Size after:

MSG_COFF = Converting to AVR COFF:

MSG_EXTENDED_COFF = Converting to AVR Extended COFF:

MSG_FLASH = Creating load file for Flash:

MSG_EEPROM = Creating load file for EEPROM:

MSG_EXTENDED_LISTING = Creating Extended Listing:

MSG_SYMBOL_TABLE = Creating Symbol Table:

MSG_LINKING = Linking:

MSG_COMPILING = Compiling:

MSG_ASSEMBLING = Assembling:

MSG_CLEANING = Cleaning project:

# Define all object files.

OBJ = $(SRC:.c=.o) $(ASRC:.S=.o) 

# Define all listing files.

LST = $(SRC:.c=.lst) $(ASRC:.S=.lst) 

# Compiler flags to generate dependency files.

GENDEPFLAGS = -MD -MP -MF .dep/$(@F).d

# Combine all necessary flags and optional flags.

# Add target processor to flags.

ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)

ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)

# Default target.

all: begin gccversion sizebefore build sizeafter end

build: elf hex eep lss sym

elf: $(TARGET).elf

hex: $(TARGET).hex

eep: $(TARGET).eep

lss: $(TARGET).lss 

sym: $(TARGET).sym

# Eye candy.

# AVR Studio 3.x does not check make's exit code but relies on

# the following magic strings to be generated by the compile job.

begin:

	@echo

	@echo $(MSG_BEGIN)

end:

	@echo $(MSG_END)

	@echo

# Display size of file.

HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex

ELFSIZE = $(SIZE) -A $(TARGET).elf

AVRMEM = avr-mem.sh $(TARGET).elf $(MCU)

sizebefore:

	@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); \

	$(AVRMEM) 2>/dev/null; echo; fi

sizeafter:

	@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); \

	$(AVRMEM) 2>/dev/null; echo; fi

# Display compiler version information.

gccversion : 

	@$(CC) --version

# Program the device.  

program: $(TARGET).hex $(TARGET).eep

	$(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM)

# Generate avr-gdb config/init file which does the following:

#     define the reset signal, load the target file, connect to target, and set 

#     a breakpoint at main().

gdb-config: 

	@$(REMOVE) $(GDBINIT_FILE)

	@echo define reset >> $(GDBINIT_FILE)

	@echo SIGNAL SIGHUP >> $(GDBINIT_FILE)

	@echo end >> $(GDBINIT_FILE)

	@echo file $(TARGET).elf >> $(GDBINIT_FILE)

	@echo target remote $(DEBUG_HOST):$(DEBUG_PORT)  >> $(GDBINIT_FILE)

ifeq ($(DEBUG_BACKEND),simulavr)

	@echo load  >> $(GDBINIT_FILE)

endif	

	@echo break main >> $(GDBINIT_FILE)

debug: gdb-config $(TARGET).elf

ifeq ($(DEBUG_BACKEND), avarice)

	@echo Starting AVaRICE - Press enter when "waiting to connect" message displays.

	@$(WINSHELL) /c start avarice --jtag $(JTAG_DEV) --erase --program --file \

	$(TARGET).elf $(DEBUG_HOST):$(DEBUG_PORT)

	@$(WINSHELL) /c pause

else

	@$(WINSHELL) /c start simulavr --gdbserver --device $(MCU) --clock-freq \

	$(DEBUG_MFREQ) --port $(DEBUG_PORT)

endif

	@$(WINSHELL) /c start avr-$(DEBUG_UI) --command=$(GDBINIT_FILE)

# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.

COFFCONVERT=$(OBJCOPY) --debugging \

--change-section-address .data-0x800000 \

--change-section-address .bss-0x800000 \

--change-section-address .noinit-0x800000 \

--change-section-address .eeprom-0x810000 

coff: $(TARGET).elf

	@echo

	@echo $(MSG_COFF) $(TARGET).cof

	$(COFFCONVERT) -O coff-avr $< $(TARGET).cof

extcoff: $(TARGET).elf

	@echo

	@echo $(MSG_EXTENDED_COFF) $(TARGET).cof

	$(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof

# Create final output files (.hex, .eep) from ELF output file.

%.hex: %.elf

	@echo

	@echo $(MSG_FLASH) $@

	$(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@

%.eep: %.elf

	@echo

	@echo $(MSG_EEPROM) $@

	-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \

	--change-section-lma .eeprom=0 -O $(FORMAT) $< $@

# Create extended listing file from ELF output file.

%.lss: %.elf

	@echo

	@echo $(MSG_EXTENDED_LISTING) $@

	$(OBJDUMP) -h -S $< > $@

# Create a symbol table from ELF output file.

%.sym: %.elf

	@echo

	@echo $(MSG_SYMBOL_TABLE) $@

	$(NM) -n $< > $@

# Link: create ELF output file from object files.

.SECONDARY : $(TARGET).elf

.PRECIOUS : $(OBJ)

%.elf: $(OBJ)

	@echo

	@echo $(MSG_LINKING) $@

	$(CC) $(ALL_CFLAGS) $^ --output $@ $(LDFLAGS)

# Compile: create object files from C source files.

%.o : %.c

	@echo

	@echo $(MSG_COMPILING) $<

	$(CC) -c $(ALL_CFLAGS) $< -o $@ 

# Compile: create assembler files from C source files.

%.s : %.c

	$(CC) -S $(ALL_CFLAGS) $< -o $@

# Assemble: create object files from assembler source files.

%.o : %.S

	@echo

	@echo $(MSG_ASSEMBLING) $<

	$(CC) -c $(ALL_ASFLAGS) $< -o $@

# Create preprocessed source for use in sending a bug report.

%.i : %.c

	$(CC) -E -mmcu=$(MCU) -I. $(CFLAGS) $< -o $@ 

# Target: clean project.

clean: begin clean_list end

clean_list :

	@echo

	@echo $(MSG_CLEANING)

	$(REMOVE) $(TARGET).hex

	$(REMOVE) $(TARGET).eep

	$(REMOVE) $(TARGET).cof

	$(REMOVE) $(TARGET).elf

	$(REMOVE) $(TARGET).map

	$(REMOVE) $(TARGET).sym

	$(REMOVE) $(TARGET).lss

	$(REMOVE) $(OBJ)

	$(REMOVE) $(LST)

	$(REMOVE) $(SRC:.c=.s)

	$(REMOVE) $(SRC:.c=.d)

	$(REMOVEDIR) .dep

# Include the dependency files.

-include $(shell mkdir .dep 2>/dev/null) $(wildcard .dep/*)

# Listing of phony targets.

.PHONY : all begin finish end sizebefore sizeafter gccversion \

build elf hex eep lss sym coff extcoff \

clean clean_list program debug gdb-config

#include <wl_token_ring.h>

#include <stdlib.h>

#include <stdio.h>

#include <wl_defs.h>

#include <wireless.h>

#include <sensor_matrix.h>

#include <queue.h>

#ifdef ROBOT

#include <bom.h>

#include <time.h>

#endif

#define DEFAULT_SENSOR_MATRIX_SIZE 20

//TODO: idea: if the xbee can handle many packets at once, we could have everyone

//send their BOM reading for a particular robot right after getting it.

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

/*Function Prototypes*/

/*Wireless Library Prototypes*/

void wl_token_ring_timeout_handler(void);

void wl_token_ring_response_handler(int frame, int received);

void wl_token_ring_receive_handler(char type, int source, unsigned char* packet,

							int length);

void wl_token_ring_cleanup(void);

/*Helper Functions*/

void wl_token_pass_token(void);

int get_token_distance(int robot1, int robot2);

void wl_token_get_token(void);

/*Packet Handling Routines*/

void wl_token_pass_receive(int source, char nextRobot, unsigned char* sensorData, int sensorDataLength);

void wl_token_interrupt_request_receive(int source, int robot);

void wl_token_interrupt_pass_receive(int source, int robot);

void wl_token_bom_on_receive(int source);

void wl_token_join_receive(int source);

void wl_token_join_accept_receive(int source);

/*Global Variables*/

//the sensor matrix

SensorMatrix* sensorMatrix;

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

int wl_token_next_robot = -1;

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

int ringState = NONMEMBER;

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

int acceptor = -1;

//id of the robot we are accepting

int accepted = -1;

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

int deathDelay = -1;

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

int joinDelay = -1;

//queue containing ids of interruption requests

Queue* interrupting = NULL;

#ifdef ROBOT

void (*bom_on_function) (void) = bom_on;

void (*bom_off_function) (void) = bom_off;

int (*get_max_bom_function) (void) = get_max_bom;

#else

void do_nothing(void) {}

int get_nothing(void) {return -1;}

void (*bom_on_function) (void) = do_nothing;

void (*bom_off_function) (void) = do_nothing;

int (*get_max_bom_function) (void) = get_nothing;

#endif

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

/**

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

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

 **/

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

	}

	sensorMatrix = sensor_matrix_create();

	interrupting = queue_create();

	//add ourselves to the sensor matrix

	sensor_matrix_set_in_ring(sensorMatrix, wl_get_xbee_id(), 0);

	wl_register_packet_group(&wl_token_ring_handler);

}

/**

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

 **/

void wl_token_ring_cleanup()

{

	sensor_matrix_destroy(sensorMatrix);

	queue_destroy(interrupting);

}

/**

 * Called approximately every quarter second by the wireless library.

 **/

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(sensorMatrix, 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_pass_token();

	}

	//we must start our own token ring, no one is responding to us

	if (joinDelay == 0)

	{

		if (sensor_matrix_get_joined(sensorMatrix) == 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);

			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

			wl_token_ring_join();

			joinDelay = rand() / (RAND_MAX / JOIN_DELAY) + 1;

		}

	}

	if (deathDelay >= 0)

		deathDelay--;

	if (joinDelay >= 0)

		joinDelay--;

}

/**

 * 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

 **/

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

 **/

void wl_token_ring_receive_handler(char type, int source, unsigned char* packet,

							int length)

{

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

			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_INTERRUPT_REQUEST:

			wl_token_interrupt_request_receive(source, packet[0]);

			break;

		case WL_TOKEN_INTERRUPT_PASS:

			wl_token_interrupt_pass_receive(source, packet[0]);

			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;

	}

}

/**

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

 **/

void wl_token_ring_join()

{

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

	ringState = JOINING;

	joinDelay = JOIN_DELAY;

	wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_JOIN,

		NULL, 0, 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;

}

/**

 * Requests that the specified robot be given the token and

 * allowed to flash its BOM. After its BOM is flashed, the

 * token will return to the robot who sent it.

 *

 * @param robot the ID of the robot which should flash its BOM

 **/

void wl_token_request(int robot)

{

	char buf[1];

	buf[0] = robot;

	wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_INTERRUPT_REQUEST,

		buf, 1, 0);

}

/**

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

{

	return sensor_matrix_get_reading(sensorMatrix, source, dest);

}

/**

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

}

/**

 * 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

 */

void wl_token_pass_receive(int source, char nextRobot, unsigned char* sensorData, int sensorDataLength)

{

	int i, j;

	deathDelay = -1;

	WL_DEBUG_PRINT("Received the token, next robot is ");

	WL_DEBUG_PRINT_INT((int)nextRobot);

	WL_DEBUG_PRINT(" \r\n");

	sensor_matrix_set_in_ring(sensorMatrix, 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++)

	{

		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(sensorMatrix, source, i,

						sensorData[2 * j + 1]);

			sensor_matrix_set_in_ring(sensorMatrix, i, 1);

			j++;

		}

		else

		{

			if (sensor_matrix_get_in_ring(sensorMatrix, 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(sensorMatrix, i, 0);

			}

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

			{

				sensor_matrix_set_in_ring(sensorMatrix,

						wl_get_xbee_id(), 1);

				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(sensorMatrix,

						wl_get_xbee_id(), 1);

				ringState = NONMEMBER;

				acceptor = -1;

				wl_token_ring_join();

			}

		}

	}

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

}

/**

 * 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

 **/

int get_token_distance(int robot1, int robot2)

{

	int curr = robot1 + 1;

	int count = 1;

	while (1)

	{

		if (curr == sensor_matrix_get_size(sensorMatrix))

			curr = 0;

		if (curr == robot2)

			break;

		if (sensor_matrix_get_in_ring(sensorMatrix, curr))

			count++;

		curr++;

	}

	return count;

}

/**

 * Passes the token to the next robot in the token ring.

 **/

void wl_token_pass_token()

{

	char nextRobot;

	int i = wl_get_xbee_id() + 1;

	if (accepted == -1)

	{

		while (1)

		{

			if (i == sensor_matrix_get_size(sensorMatrix))

				i = 0;

			if (sensor_matrix_get_in_ring(sensorMatrix, 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(sensorMatrix, 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");

		return;

	}

	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())

		{

			buf[2*j + 1] = i;

			buf[2*j + 2] = sensor_matrix_get_reading(sensorMatrix, wl_get_xbee_id(), i);

			j++;

		}

	WL_DEBUG_PRINT("Passing the token to robot ");

	WL_DEBUG_PRINT_INT(buf[0]);

	WL_DEBUG_PRINT(".\r\n");

	wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_PASS,

		buf, packetSize, 3);

	wl_token_next_robot = nextRobot;

	deathDelay = DEATH_DELAY;

	free(buf);

}

/**

 * 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

 **/

void wl_token_bom_on_receive(int source)

{

	WL_DEBUG_PRINT("Robot ");

	WL_DEBUG_PRINT_INT(source);

	WL_DEBUG_PRINT(" has flashed its bom.\r\n");

	sensor_matrix_set_reading(sensorMatrix, wl_get_xbee_id(), 

		source, get_max_bom_function());

}

/**

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

 **/

void wl_token_get_token()

{

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

	if (ringState == ACCEPTED)

	{

		sensor_matrix_set_in_ring(sensorMatrix,

			wl_get_xbee_id(), 1);

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

		ringState = MEMBER;

	}

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

	{

		sensor_matrix_set_in_ring(sensorMatrix, wl_get_xbee_id(), 0);

		if (ringState == NONMEMBER)

		{

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

		}

	}

	//check for interruption requests

	if (queue_size(interrupting) > 0)

	{

		char buf[1];

		buf[0] = (char)(int)queue_remove(interrupting);

		//in case this robot has requested multiple times

		queue_remove_all(interrupting, (void*)(int)buf[0]);

		wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_INTERRUPT_PASS,

			buf, 1, 0);

		deathDelay = DEATH_DELAY;

		wl_token_next_robot = buf[0];

		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(sensorMatrix, wl_get_xbee_id()))

	{

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

	}

	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

 **/

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(sensorMatrix) - 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))

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

	joinDelay = -1;

	// the token ring has not started yet

	if (sensor_matrix_get_joined(sensorMatrix) == 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

 **/

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

	ringState = ACCEPTED;

	acceptor = source;

	//add ourselves to the token ring

	sensor_matrix_set_in_ring(sensorMatrix, wl_get_xbee_id(), 1);

}

/**

 * Called when we receive a packet passing the token and interrupting

 * the token ring.

 * If the token has been passed to us, we flash our BOM

 * and pass it back.

 *

 * @param source the robot who sent the interrupt packet

 * @param robot the robot the token has been passed to

 **/

void wl_token_interrupt_pass_receive(int source, int robot)

{

	if (wl_get_xbee_id() != robot)

	{

		queue_remove_all(interrupting, (void*)robot);

		wl_token_next_robot = robot;

		deathDelay = DEATH_DELAY + rand() / (RAND_MAX / (2 * DEATH_DELAY));

		return;

	}

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

	//we don't include ourself, only if we are in the ring

	int packetSize = 1 + 2 * (sensor_matrix_get_joined(sensorMatrix) - 1);

	if (!sensor_matrix_get_in_ring(sensorMatrix, wl_get_xbee_id()))

		packetSize += 2;

	char* buf = (char*)malloc(packetSize * sizeof(char));

	if (!buf)

	{

		WL_DEBUG_PRINT("Out of memory - pass_receive.\r\n");

		return;

	}

	//return the token to where we got it from

	buf[0] = source;

	int i = 0, 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())

		{

			buf[2*j + 1] = i;

			buf[2*j + 2] = sensor_matrix_get_reading(sensorMatrix, wl_get_xbee_id(), i);

			j++;

		}

	wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_PASS,

		buf, packetSize, 0);

	wl_token_next_robot = source;

	deathDelay = DEATH_DELAY;

	free(buf);

}

/**

 * Called when we receive a request to interrupt the token ring.

 * We add the robot to our list of interrupt requests,

 * and will send the token to this robot when we next receive the

 * token, unless someone else does so first.

 *

 * @param source the robot requesting interruption

 * @param robt the robot requested to interrupt the token ring

 **/

void wl_token_interrupt_request_receive(int source, int robot)

{

	queue_add(interrupting, (void*)robot);

}

# 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