Colony

# 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../../../lib/include/libdragonfly -L../lib -L../../../lib/bin

#---------------- 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 = /dev/ttyUSB1

# 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

AVRDUDE_FLAGS += -D

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

}

#include "wireless.h"

#include "xbee.h"

#include <stdlib.h>

#include <stdio.h>

#include "wl_defs.h"

#ifndef ROBOT

#include <sys/time.h>

#include <signal.h>

#else

#include <time.h>

#ifndef FIREFLY

#include <bom.h>

#endif

#endif

/*Function Prototypes*/

void wl_do_timeout(void);

//Note: the actual frame sent has group as the first four bits and

//frame as the last four.

void wl_send_packet(char group, char type, char* data, int len,

					int dest, char options, char frame);

/*Data Members*/

//used to store incoming and outgoing packets

unsigned char wl_buf[128];

//1 if we have timed out since we last checked, 0 otherwise.

int wl_timeout = 0;

PacketGroupHandler* wl_packet_groups[WL_MAX_PACKET_GROUPS];

#ifndef ROBOT

#ifdef _POSIX_TIMERS

timer_t wl_timeout_timer;

#endif

//called when we time out, or receive interrupt

void sig_handler(int signo)

{

	switch (signo)

	{

		case SIGALRM:

			wl_timeout = 1;

			break;

		case SIGINT:

			wl_terminate();

			exit(1);

			break;

	}

	return;

}

#else 

//Alternate non posix code here.

#endif

/**

 * Initializes the wireless library. Must be called before any

 * other function.

 **/

void wl_init()

{

	int i;

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

		wl_packet_groups[i] = NULL;

	xbee_lib_init();

	//begin timeout timer

	#ifdef ROBOT

	#ifdef FIREFLY

	rtc_init(PRESCALE_DIV_128, 32, &wl_do_timeout);

	#else

	rtc_init(HALF_SECOND, &wl_do_timeout); 

	#endif

	#else

  #ifdef _POSIX_TIMERS 

  //create a timer to trigger every half second

	struct sigevent evp;

	evp.sigev_signo = SIGALRM;

	evp.sigev_notify = SIGEV_SIGNAL;

	if (timer_create(CLOCK_REALTIME, &evp, &wl_timeout_timer) == -1)

	{ 

		WL_DEBUG_PRINT("Error creating a timer.\r\n"); 

		exit(1); 

	}

  struct itimerspec wl_timeout_time;

	wl_timeout_time.it_interval.tv_sec = 0;

	wl_timeout_time.it_interval.tv_nsec = 500000000;

	wl_timeout_time.it_value.tv_sec = 0;

	wl_timeout_time.it_value.tv_nsec = 500000000;

	timer_settime(wl_timeout_timer, 0,

                        &wl_timeout_time, NULL);

  #else

  printf("Creating a non posix timer.\n"); 

  struct itimerval timer_val;

  struct timeval interval;

  interval.tv_sec = 0;

  interval.tv_usec = 500000;

  struct timeval first_time;

  first_time.tv_sec = 0;

  first_time.tv_usec = 500000;

  timer_val.it_interval = interval;

  timer_val.it_value = first_time;

  if(setitimer(ITIMER_REAL,&timer_val,NULL)==-1)

  {

		WL_DEBUG_PRINT("Error creating a timer.\r\n"); 

    perror("Failure's cause");

		exit(1); 

  }

  #endif

	struct sigaction wl_sig_act;

	wl_sig_act.sa_handler = (void *)sig_handler;

	wl_sig_act.sa_flags = 0;

	sigemptyset(&wl_sig_act.sa_mask);

	sigaction(SIGALRM, &wl_sig_act, 0);

	sigaction(SIGINT, &wl_sig_act, 0);

	#endif

}

/**

 * Uninitializes the wireless library.

 **/

void wl_terminate()

{

	#ifndef ROBOT

  #ifdef _POSIX_TIMERS	

  timer_delete(wl_timeout_timer);

  #endif

	#endif

	int i;

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

		if (wl_packet_groups[i] != NULL &&

			wl_packet_groups[i]->unregister != NULL)

			wl_packet_groups[i]->unregister();

	xbee_terminate();

}

/**

 * Set the PAN for the XBee to join.

 *

 * @param pan the new PAN

 *

 * @see wl_get_pan

 **/

void wl_set_pan(int pan)

{

	xbee_set_pan_id(pan);

}

/**

 * Get the PAN the XBee is currently part of.

 *

 * @return the PAN of the XBee

 *

 * @see wl_set_pan

 **/

int wl_get_pan(void)

{

	return xbee_get_pan_id();

}

/**

 * Set the channel the XBee is listening to.

 *

 * @param channel the new channel to join

 *

 * @see wl_get_channel

 **/

void wl_set_channel(int channel)

{

	xbee_set_channel(channel);

}

/**

 * Get the channel the XBee is part of.

 *

 * @return the channel the XBee is part of

 *

 * @see wl_set_channel

 **/

int wl_get_channel(void)

{

	return xbee_get_channel();

}

/**

 * Returns the 16-bit address of the XBee module.

 *

 * @return the 16-bit address of the XBee module.

 **/

unsigned int wl_get_xbee_id()

{

	return xbee_get_address();

}

/**

 * Send a packet to a specific XBee without specifying a PAN.

 *

 * @param group the packet group

 * @param type the packet type

 * @param data the packet data

 * @param len the packet length in bytes

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

 **/

void wl_send_robot_to_robot_global_packet(char group, char type,

		char* data, int len, int dest, char frame)

{

	wl_send_packet(group, type, data, len, dest,

			XBEE_OPTIONS_BROADCAST_ALL_PANS, frame);

}

/**

 * Send a packet to a specific XBee in the same PAN.

 *

 * @param group the packet group

 * @param type the packet type

 * @param data the packet data

 * @param len the packet length in bytes

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

 **/

void wl_send_robot_to_robot_packet(char group, char type,

		char* data, int len, int dest, char frame)

{

	wl_send_packet(group, type, data, len, dest, XBEE_OPTIONS_NONE,

			frame);

}

/**

 * Send a packet to all XBees in all PANs.

 *

 * @param group the packet group

 * @param type the packet type

 * @param data the packet data

 * @param len the packet length in bytes

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

 **/

void wl_send_global_packet(char group, char type,

		char* data, int len, char frame)

{

	wl_send_packet(group, type, data, len, XBEE_BROADCAST,

			XBEE_OPTIONS_BROADCAST_ALL_PANS, frame);

}

/**

 * Send a packet to all XBee's in the same PAN.

 *

 * @param group the packet group

 * @param type the packet type

 * @param data the packet data

 * @param len the packet length in bytes

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

 **/

void wl_send_pan_packet(char group, char type,

		char* data, int len, char frame)

{

	wl_send_packet(group, type, data, len, XBEE_BROADCAST, 

			XBEE_OPTIONS_NONE, frame);

}

/**

 * Send a packet.

 *

 * @param group the packet group

 * @param type the packet type

 * @param data the packet data

 * @param len the packet length in bytes

 * @param dest the destination of the packet

 * @param options the options for sending the packet

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

 **/

void wl_send_packet(char group, char type, char* data, int len,

					int dest, char options, char frame)

{

	char buf[128];

	int i;

	if (frame != 0)

		frame = (frame & 0x0F) | ((group & 0x0F) << 4);

	buf[0] = group;

	buf[1] = type;

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

		buf[2 + i] = data[i];

	xbee_send_packet(buf, len + 2, dest, options, frame);

}

/**

 * Register a packet group with the wireless library. The event

 * handlers in the packet group will be called whenever an

 * event dealing with the packet group's group code occurs.

 *

 * @param h the PacketGroupHandler to register

 **/

void wl_register_packet_group(PacketGroupHandler* h)

{

	if (h->groupCode >= WL_MAX_PACKET_GROUPS)

	{

		WL_DEBUG_PRINT("Packet group code too large.\r\n");

		return;

	}

	if (wl_packet_groups[h->groupCode] != NULL)

	{

		WL_DEBUG_PRINT("Packet group code already registered.\r\n");

		return;

	}

	wl_packet_groups[h->groupCode] = h;

}

/**

 * Unregister a packet group from the wireless library.

 * 

 * @param h the packet group to remove

 **/

void wl_unregister_packet_group(PacketGroupHandler* h)

{

	unsigned int groupCode = h->groupCode;

	PacketGroupHandler* p = wl_packet_groups[groupCode];

	if (p != NULL && p->unregister != NULL)

		p->unregister();

	wl_packet_groups[groupCode] = NULL;

}

/**

 * Called when the timer is triggered. This calls the timeout

 * handlers of all the registered packet groups.

 **/

void wl_do_timeout()

{

	int i;

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

		if (wl_packet_groups[i] != NULL &&

			wl_packet_groups[i]->timeout_handler != NULL)

			wl_packet_groups[i]->timeout_handler();

}

/**

 * Performs wireless library functionality. This function must

 * be called frequently for wireless to perform effectively.

 * This function will call timeout handlers, as well as

 * received packet and transmit status handlers.

 **/

void wl_do()

{

	if (wl_timeout)

	{

		wl_do_timeout();

		wl_timeout = 0;

	}

	int len = xbee_get_packet(wl_buf);

	if (len < 0)//no packet received

		return;

	if (wl_buf[0] == XBEE_TX_STATUS)

	{

		if (len != 3)

		{

			WL_DEBUG_PRINT("Transmit Status packet should be of length 3.\r\n");

			return;

		}

		//the first four bits are the packet group

		//this only works with under 16 groups

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

		int success = 0;

		if (wl_buf[2] == 0)

			success = 1;

		else

		{

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

			if (wl_buf[2] == 2)

				WL_DEBUG_PRINT("CCA Failure\r\n");

			if (wl_buf[2] == 3)

				WL_DEBUG_PRINT("Purged\r\n");

		}

		if (wl_packet_groups[group] != NULL &&

					wl_packet_groups[group]->handle_response != NULL)

			wl_packet_groups[group]->handle_response(

					(int)wl_buf[1] & 0x0F, success);

		return;

	}

	if (wl_buf[0] == XBEE_RX)

	{

		if (len < 7)

		{

			WL_DEBUG_PRINT("Packet is too small.\r\n");

			return;

		}

		int source = ((int)wl_buf[1] << 8) + ((int)wl_buf[2]);

		/*

		//unused for now

		int signalStrength = wl_buf[3];

		//1 for Address broadcast, 2 for PAN broadcast

		int options = wl_buf[4];

		*/

		int group = wl_buf[5];

		int type = wl_buf[6];

		int packetLen = len - 7;

		if (wl_packet_groups[group] != NULL

				&& wl_packet_groups[group]->handle_receive != NULL)

			wl_packet_groups[group]->handle_receive(type, source, 

				wl_buf + 7, packetLen);

		return;

	}

	WL_DEBUG_PRINT("Unexpected packet received from XBee.\r\n");

	return;

}

#include <stdlib.h>

#include <stdio.h>

#include <wl_defs.h>

#include "sensor_matrix.h"

#define DEFAULT_SENSOR_MATRIX_SIZE 20

/*Sensor Matrix Functions*/

void sensor_matrix_expand(SensorMatrix* m, int nextSize);

/**

 * Initializes the sensor matrix.

 *

 * @return the newly created sensor matrix

 **/

SensorMatrix* sensor_matrix_create()

{

	SensorMatrix* m;

	int i;

	m = 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 = malloc(m->size * sizeof(int*));

	m->joined = malloc(m->size * sizeof(int));

	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, unsigned int id)

{

	int i;

	if (id >= m->size)

		sensor_matrix_expand(m, id + 1);

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

		return;

	m->matrix[id] = 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, unsigned 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

void sensor_matrix_expand(SensorMatrix* m, int nextSize)

{

	int i, j;

	WL_DEBUG_PRINT("Expanding sensor matrix.\r\n");

	int** tempMatrix = 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)

		{

			tempMatrix[i] = 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 = malloc(nextSize * sizeof(int));

	if (!tempJoined)

	{

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

		return;

	}

	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)

{

	if (robot >= m->size || observer >= m->size || m->matrix[observer] == NULL)

		sensor_matrix_add_robot(m, observer);

	m->matrix[observer][robot] = 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)

{

	if (observer >= m->size || robot >= m->size)

		return -1;

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

{

	if (robot >= m->size)

		sensor_matrix_expand(m, robot + 1);

	if (in == 1)

		sensor_matrix_add_robot(m, robot);

	if (in == 1 && m->joined[robot] == 0)

		m->numJoined++;

	if (in == 0 && m->joined[robot] == 1)

		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

 *

 * @return 1 if the robot is in the token ring, 0 otherwise

 **/

int sensor_matrix_get_in_ring(SensorMatrix* m, int robot)

{

	if (robot >= m->size)

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

}

/**

 * Returns the number of robots which have joined the

 * token ring.

 *

 * @param m the sensor matrix

 *

 * @return the number of robots in the token ring

 **/

int sensor_matrix_get_joined(SensorMatrix* m)

{

	return m->numJoined;

}

#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

#ifndef FIREFLY

#include <bom.h>

#endif

#include <time.h>

#endif

#define DEFAULT_SENSOR_MATRIX_SIZE 20

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

//current robot to check in the iterator

int iteratorCount = 0;

void do_nothing(void) {}

int get_nothing(void) {return -1;}

#ifdef ROBOT

#ifndef FIREFLY

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 (*bom_on_function) (void) = do_nothing;

void (*bom_off_function) (void) = do_nothing;

int (*get_max_bom_function) (void) = get_nothing;

#endif

#else

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

		}

		// we may have been dropped from the ring when this is received

		if (ringState == MEMBER)

			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;