Colony

/*

lights.h

most of this is shamelessly copied from FWR's orb.h (Tom Lauwers and Steven Shamlian)

author: CMU Robotics Club, Colony Project

*/

#ifndef _LIGHTS_H_

#define _LIGHTS_H_

//user LED

#define USERLED PING2

//ORB

#define RED       0xE0

#define ORANGE    0xE8

#define YELLOW    0xFC

#define LIME      0x7C

#define GREEN     0x1C

#define CYAN      0x1F

#define BLUE      0x03

#define PINK      0x63

#define PURPLE    0x23

#define MAGENTA   0xE3

#define WHITE     0xFF

#define ORB_OFF   0x00

//LEDs are on bank E

#define REDLED   PE3

#define GREENLED PE4

#define BLUELED  PE5

//?

#define COUNT_START 0x8000

//user LED

void led_init( void );

void led_user(int value);

// For function descriptions see orb.c 

void orb_init(void);

void orb_set(unsigned int red_led, unsigned int green_led, unsigned int blue_led); 

void orb_set_color(int col);

void orb_disable(void);

void orb_enable(void);

void orb_set_dio(int red, int green, int blue);

#endif

/**

 * @file wireless.h

 * @brief Contains definitions for the wireless library.

 *

 * Contains functions for the wireless library.

 *

 * @author Brian Coltin, Colony Project, CMU Robotics Club

 **/

//Note: If this is raised above 16, we will need to do

//something about frame numbers for TX Status packets.

/**

 * The maximum number of packet groups.

 **/

#define WL_MAX_PACKET_GROUPS 16

/**

 * @defgroup wireless Wireless

 * @brief Wireless definitions.

 *

 * Contains functions and definitions for dealing with wireless functionality.<br><br>

 *

 * The wireless library provides a modular method for dealing with 

 * wireless packets, by allowing packet groups to be registered.

 * A packet group is a collection of packets which share a packet

 * group code. Each packet in the group also has a type. A packet 

 * group code and type are sent with each packet. When a packet

 * with a group code registered in the wireless library is 

 * received, the corresponding event handler is called. The

 * event handler uses the packet type and other information

 * stored in the packet to respond.<br><br>

 *

 * This architecture allows different wireless functionality to be

 * defined and handled separately, making it simpler and more

 * efficient to take advantage of the XBee's wireless functionality.

 *

 * @{

 **/

/**

 * @struct PacketGroupHandler

 * A PacketGroupHandler represents a packet group, and is used to 

 * register a packet group with the wireless library. It contains

 * handlers for various events which can occur related to a packet

 * group.

 **/

typedef struct

{

	/**

	 * The group code for this packet group. This number

	 * must be unique. The maximum number of packet groups

	 * is defined by WL_MAX_PACKET_GROUPS.

	 **/

	unsigned int groupCode;

	/**

	 * Called every half second (not in interrupt,

	 * but in wl_do).

	 **/

	void (*timeout_handler) (void);

	/**

	 * Called when a transmit status packet is received

	 * from the XBee where the first four bits of the frame

	 * are  the group code.

	 *

	 * @param frame the last four bits of the frame

	 * @param received is true if we received an ack, 0 if

	 * we did not.

	 **/

	void (*handle_response) (int frame, int received);

	/**

	 * Called when we receive a packet from this group.

	 *

	 * @param type the packet type

	 * @param source the 16-bit address of the XBee this

	 * packet was sent from

	 * @param packet the packet received

	 * @param length the length of the packet

	 **/

	void (*handle_receive) (char type, int source, unsigned char* packet,

							int length);

	/**

	 * Called for any cleanup when the network is turned off.

	 **/

	void (*unregister) (void);

} PacketGroupHandler;

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

void wl_init(void);

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

void wl_terminate(void);

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

void wl_do(void);

/**@brief Register a packet group with the wireless library **/

void wl_register_packet_group(PacketGroupHandler* h);

/**@brief Unregister a packet group with the wireless library **/

void wl_unregister_packet_group(PacketGroupHandler* h);

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

void wl_send_robot_to_robot_global_packet(char group, char type,

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

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

void wl_send_robot_to_robot_packet(char group, char type,

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

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

void wl_send_global_packet(char group, char type,

		char* data, int len, char frame);

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

void wl_send_pan_packet(char group, char type,

		char* data, int len, char frame);

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

void wl_set_pan(int pan);

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

int wl_get_pan(void);

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

void wl_set_channel(int channel);

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

int wl_get_channel(void);

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

unsigned int wl_get_xbee_id(void);

/** @} **/ // end defgroup

/*Plug the molex for each BOM in with the BLACK wire to the

io pin and the red wire to the positive channel going down

the middle of the PINA/E/I2C block*/

#define LINEAR_BOM_PIN0 PIN_AN0

#define LINEAR_BOM_PIN1 PIN_AN1

#define LINEAR_BOM_PIN2 PIN_AN2

#define LINEAR_BOM_PIN3 PIN_AN3

#define lbom_set(which) \

    digital_output(LINEAR_BOM_PIN0 + which, 0)

#define lbom_off() \

    digital_output(LINEAR_BOM_PIN0, 1); \

    digital_output(LINEAR_BOM_PIN1, 1); \

    digital_output(LINEAR_BOM_PIN2, 1); \

    digital_output(LINEAR_BOM_PIN3, 1);

/*

	serial.c - Functions for using the RS232 serial port

	author: Robotics Club, Colony Project

	much code taken from FWR's library, author: Tom Lauwers

	general note - serial -> uart

				   serial1 -> uart1

		this is done for clarity purposes

*/

#include <avr/io.h>

#include <stdio.h>

#include "serial.h"

//setup uart0 (serial)

void xbee_init(unsigned int ubrr)

{

	/*Set baud rate - baud rates under 4800bps unsupported */

	UBRR0H = 0x00;

	UBRR0L = (unsigned char)ubrr;

	/*Enable receiver and transmitter */

	UCSR0B |= (1<<RXEN0)|(1<<TXEN0);

	/* Set frame format: 8data, 1stop bit, asynchronous normal mode */

	UCSR0C |= (1<<UCSZ00) | (1<<UCSZ01);

}

// uart_putchar - Low-level function which puts a value into the 

// Tx buffer for transmission. 

int xbee_putc(char c)

{

	// Wait until buffer is clear for sending

    loop_until_bit_is_set(UCSR0A, UDRE0);

	// Load buffer with your character

    UDR0 = c;

    return 0;

}

int xbee_puts(char *s)

{

        char *t = s;

        while (*t != 0)

        {

                xbee_putc(*t);

                t++;

        }

  return 0;

}

int xbee_puti(int value ) {

	unsigned char usb_data[6]={'0','0','0','0','0','0' }, position=sizeof(usb_data), radix=10; 

        /* convert int to ascii  */ 

        if(value<0) { xbee_putc('-'); value=-value; }    

        do { position--; *(usb_data+position)=(value%radix)+'0'; value/=radix;  } while(value); 

        /* start displaying the number */

        for(;position<=(sizeof(usb_data)-1);position++)

          {

            xbee_putc(usb_data[position]);

          }

	return 0;

}

// uart_getchar - Low-level function which waits for the Rx buffer

// to be filled, and then reads one character out of it.

// Note that this function blocks on read - it will wait until

// something fills the Rx buffer.

int xbee_getc(void)

{

	char c;

	// Wait for the receive buffer to be filled

    loop_until_bit_is_set(UCSR0A, RXC0);

	// Read the receive buffer

    c = UDR0;

	return c;

}

// uart_getchar_nb - Low-level function which checks if the Rx buffer

// is filled, and then reads one character out of it.

// This is a non blocking version uart_getchar

int xbee_getc_nb(void)

{

	char c;

	// Wait for the receive buffer to be filled

    //loop_until_bit_is_set(UCSR0A, RXC0);

	if (UCSR0A & _BV(RXC0)){

		// Read the receive buffer

		c = UDR0;

		return c;

	}

	return 0;

}

//setup uart1 (serial1)

void usb_init( unsigned int ubrr)

{

	/*Set baud rate - baud rates under 4800bps unsupported */

	UBRR1H = 0x00;

	UBRR1L = (unsigned char)ubrr;

	/*Enable receiver and transmitter */

	UCSR1B |= (1<<RXEN1)|(1<<TXEN1);

	/* Set frame format: 8data, 1stop bit, asynchronous normal mode */

	UCSR1C |= (1<<UCSZ10) | (1<<UCSZ11);

}

//put to uart1 (serial1)

int usb_putc(char c)

{

	// Wait until buffer is clear for sending

    loop_until_bit_is_set(UCSR1A, UDRE1);

	// Load buffer with your character

    UDR1 = c;

    return 0;

}

int usb_puts(char *s)

{

        char *t = s;

        while (*t != 0)

        {

                usb_putc(*t);

                t++;

        }

  return 0;

}

int usb_puti(int value ) {

	unsigned char usb_data[6]={'0','0','0','0','0','0' }, position=sizeof(usb_data), radix=10; 

        /* convert int to ascii  */ 

        if(value<0) { usb_putc('-'); value=-value; }    

        do { position--; *(usb_data+position)=(value%radix)+'0'; value/=radix;  } while(value); 

        /* start displaying the number */

        for(;position<=(sizeof(usb_data)-1);position++)

          {

            usb_putc(usb_data[position]);

          }

	return 0;

}

//get from uart1 (serial1)

int usb_getc(void)

{

	char c;

	// Wait for the receive buffer to be filled

    loop_until_bit_is_set(UCSR1A, RXC1);

	// Read the receive buffer

    c = UDR1;

	return c;

}

//get from uart1 non-block

int usb_getc_nb(void)

{

	char c;

	// Wait for the receive buffer to be filled

    //loop_until_bit_is_set(UCSR1A, RXC1);

	if (UCSR1A & _BV(RXC1)){

		// Read the receive buffer

		c = UDR1;

		return c;

	}

	return 0;

}

/*

	buzzer.c - Contains the functions necessary for running the buzzer

	author: Robotics Club, Colony Project

	much taken from FWR's firefly library (author: Tom Lauwers)

*/

#include <avr/io.h>

#include "buzzer.h"

#include "time.h"

/*

initializes buffer

this function must be called before the buzzer can be used

*/

void buzzer_init( void )

{

	// Set pin D7 to output - D7 is buzzer pin

	DDRB |= 0x80;

	// Set to Fast PWM mode, toggle the OC0A pin (D6) on output compare

	// matches, and select a clock prescalar of 64 for the counter.

	// Counter FREQ = 8000000/64 = 125000

	//01011000

	TCCR2 = 0x1B;

	OCR2=100;

  buzzer_off();

}

// Set the buzzer value - takes a value from 0-255

// Higher values are lower frequency.  Take a look at 

// the buzzer frequency table to see how a given value

// correlates to a frequency.

void buzzer_set_val(unsigned int buzz_value)

{ 

	OCR2 = buzz_value;

}

// Set the buzzer frequency - takes any value and tries to find the nearest buzzer frequency

void buzzer_set_freq(unsigned int buzz_freq)

{

	int buzz_value;

	buzz_value = 62500/buzz_freq - 1;

	if(buzz_value > 255)

		buzz_value = 255;

	else if(buzz_value < 0)

		buzz_value = 0;

	buzzer_set_val(buzz_value);

}

// Chirps the buzzer for a number of milliseconds

void buzzer_chirp(unsigned int ms, unsigned int buzz_freq) 

{	

	buzzer_set_freq(buzz_freq);

	delay_ms(ms);

	buzzer_off();

}

// Disables timer0 clock counting, turning off the buzzer

void buzzer_off() 

{

	// Disable clock, to halt counter

	TCCR2 &= 0xF8;

	// Set buzzer pin low in case it's high

	PORTB &= 0x7F;

}

#include "xbee.h"

#include "wl_defs.h"

#ifndef ROBOT

#include <fcntl.h>

#include <unistd.h>

#include <pthread.h>

#include <errno.h>

#else

#include <serial.h>

#include <avr/interrupt.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <queue.h>

#define XBEE_FRAME_START 0x7E

/*Frame Types*/

#define XBEE_FRAME_STATUS 0x8A

#define XBEE_FRAME_AT_COMMAND 0x08

#define XBEE_FRAME_AT_COMMAND_RESPONSE 0x88

#define XBEE_FRAME_TX_REQUEST_64 0x00

#define XBEE_FRAME_TX_REQUEST_16 0x01

#define XBEE_FRAME_TX_STATUS XBEE_TX_STATUS

#define XBEE_FRAME_RX_64 0x80

#define XBEE_FRAME_RX_16 XBEE_RX

/*Internal Function Prototypes*/

/*I/O Functions*/

void xbee_send(char* buf, int size);

void xbee_send_string(char* c);

#ifndef ROBOT

void xbee_read(char* buf, int size);

#endif

/*Command Mode Functions

 * Called during initialization.

 */

void xbee_enter_command_mode(void);

void xbee_exit_command_mode(void);

void xbee_enter_api_mode(void);

void xbee_wait_for_string(char* s, int len);

void xbee_wait_for_ok(void);

/*API Mode Functions*/

int xbee_handle_packet(char* packet, int len);

void xbee_handle_at_command_response(char* command, char result,

	char* extra, int extraLen);

void xbee_handle_status(char status);

int xbee_verify_checksum(char* packet, int len);

char xbee_compute_checksum(char* packet, int len);

void xbee_send_frame(char* buf, int len);

void xbee_send_read_at_command(char* command);

void xbee_send_modify_at_command(char* command, char* value);

/*Global Variables*/

#ifndef ROBOT

int xbee_stream;

pthread_t* xbee_listen_thread;

#endif

Queue* xbee_queue;

//used to store packets as they are read

char xbee_buf[128];

int currentBufPos = 0;

//XBee status

unsigned int xbee_panID = XBEE_PAN_DEFAULT;

unsigned int xbee_pending_panID = XBEE_PAN_DEFAULT;

int xbee_channel = XBEE_CHANNEL_DEFAULT;

int xbee_pending_channel = XBEE_CHANNEL_DEFAULT;

unsigned int xbee_address = 0;

/*Function Implementations*/

#ifdef ROBOT

/**

 * Interrupt for the robot. Adds bytes received from the xbee

 * to the queue.

 **/

#ifndef FIREFLY

ISR(USART1_RX_vect)

{

	char c = UDR1;

	queue_add(xbee_queue, (void*)(int)c);

}

#else

SIGNAL(SIG_USART0_RECV)

{

	char c = UDR0;

	queue_add(xbee_queue, (void*)(int)c);

}

#endif

#else

/**

 * Thread that listens to the xbee.

 **/

void* listen_to_xbee(void* x)

{

	char c;

	while (1)

	{

		xbee_read(&c, 1);

		queue_add(xbee_queue, (void*)(int)c);

	}

	return 0;

}

#endif

/**

 * Initializes the XBee library so that other functions may be used.

 *

 * @param pan_id the PAN to join initially. Use XBEE_PAN_DEFAULT

 * to leave the PAN as it is initially.

 **/

void xbee_lib_init(void)

{

	xbee_queue = queue_create();

	#ifdef ROBOT

	//enable the receiving interrupt

	#ifdef FIREFLY

	UCSR0B |= _BV(RXCIE) | _BV(RXEN);

	#else

	UCSR1B |= _BV(RXCIE);

	#endif

	sei();

	#else

	xbee_stream = open("/dev/ttyUSB0", O_RDWR);

	if (xbee_stream == -1 || lockf(xbee_stream, F_TEST, 0) != 0)

		xbee_stream = open("/dev/ttyUSB1", O_RDWR);

	if (xbee_stream == -1 || lockf(xbee_stream, F_TEST, 0) != 0)

	{

		printf("Failed to open connection to XBee.\r\n");

		exit(0);

	}

	lockf(xbee_stream, F_LOCK, 0);

	xbee_listen_thread =

		(pthread_t*)malloc(sizeof(pthread_t));

	int ret = pthread_create(xbee_listen_thread, NULL, 

		listen_to_xbee, NULL);

	if (ret)

	{

		printf("Failed to create listener thread.\r\n");

		exit(0);

	}

	#endif

	xbee_enter_command_mode();

	xbee_enter_api_mode();

	xbee_exit_command_mode();

	xbee_send_read_at_command("MY");

	//wait to return until the address is set

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

}

/**

 * Call when finished using the XBee library. This releases

 * all sued resources.

 **/

void xbee_terminate()

{

	#ifndef ROBOT

	pthread_cancel(*xbee_listen_thread);

	free(xbee_listen_thread);

	lockf(xbee_stream, F_ULOCK, 0);

	close(xbee_stream);

	#endif

	queue_destroy(xbee_queue);

}

/**

 * Send a buffer buf of size bytes to the XBee.

 * 

 * @param buf the buffer of data to send

 * @param size the number of bytes to send

 **/

void xbee_send(char* buf, int size)

{

	#ifdef ROBOT

	int i;

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

		xbee_putc(buf[i]);

	#else

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

	//success

	if (ret == size)

		return;

	if (ret == -1)

	{

		//interrupted by system signal, probably timer interrupt.

		//just try again

		if (errno == 4)

		{

			xbee_send(buf, size);

			return;

		}

		printf("Failed to write to xbee, error %i.\r\n", errno);

		return;

	}

	//write was interrupted after writing ret bytes

	xbee_send(buf + ret, size - ret);

	#endif

}

/**

 * Sends a string to the XBee.

 *

 * @param c the string to send to the XBEE

 **/

void xbee_send_string(char* c)

{

	xbee_send(c, strlen(c));

}

#ifndef ROBOT

void xbee_read(char* buf, int size)

{

	if (read(xbee_stream, buf, size) == -1)

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

}

#endif

/**

 * Enter into command mode.

 **/

void xbee_enter_command_mode()

{

	xbee_send_string("+++");

	xbee_wait_for_ok();

}

/**

 * Exit from command mode.

 **/

void xbee_exit_command_mode()

{

	xbee_send_string("ATCN\r");

	xbee_wait_for_ok();

}

/**

 * Enter API mode.

 **/

void xbee_enter_api_mode()

{

	xbee_send_string("ATAP 1\r");

	xbee_wait_for_ok();

}

/**

 * Wait until the string "OK\r" is received from the XBee.

 **/

void xbee_wait_for_ok()

{

	xbee_wait_for_string("OK\r", 3);

}

/**

 * Delay until the specified string is received from

 * the XBee. Discards all other XBee data.

 *

 * @param s the string to receive

 * @param len the length of the string

 **/

void xbee_wait_for_string(char* s, int len)

{

	char* curr = s;

	while (curr - s < len)

	{

		if (queue_is_empty(xbee_queue))

			continue;

		char c = (char)(int)queue_remove(xbee_queue);

		if (c == *curr)

			curr++;

		else

			curr = s;

	}

}

/**

 * Verifies that the packets checksum is correct.

 * (If the checksum is correct, the sum of the bytes

 * is 0xFF.)

 *

 * @param packet the packet received. This includes the first

 * three bytes, which are header information from the XBee.

 *

 * @param len The length of the packet received from the XBee

 *

 * @return 0 if the checksum is incorrect, nonzero

 * otherwise

 **/

int xbee_verify_checksum(char* packet, int len)

{

	unsigned char sum = 0;

	int i;

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

		sum += (unsigned char)packet[i];

	return sum == 0xFF;

}

/**

 * Returns the checksum of the given packet.

 *

 * @param buf the data for the packet to send

 * @param len the length of the packet in bytes

 *

 * @return the checksum of the packet, which will

 * become the last byte sent in the packet

 **/

char xbee_compute_checksum(char* buf, int len)

{

	int i;

	unsigned char sum = 0;

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

		sum += (unsigned char)buf[i];

	return 0xFF - sum;

}

/**

 * Adds header information and checksum to the given

 * packet and sends it. Header information includes

 * XBEE_FRAME_START and the packet length, as two bytes.

 *

 * @param buf the packet data

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

 *

 **/

void xbee_send_frame(char* buf, int len)

{

	char prefix[3];

	prefix[0] = XBEE_FRAME_START;

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

	prefix[2] = len & 0xFF;

	char checksum = xbee_compute_checksum(buf, len);

	xbee_send(prefix, 3);

	xbee_send(buf, len);

	xbee_send(&checksum, 1);

}

/**

 * Sends an AT command to read a parameter.

 *

 * @param command the AT command to send. For exmaple,

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

 * See the XBee reference guide for a complete listing.

 **/

void xbee_send_read_at_command(char* command)

{

	xbee_send_modify_at_command(command, NULL);

}

/**

 * Sends the given AT command.

 *

 * @param command the AT command to send (e.g., MY, ID)

 * @param value the value to pass as a parameter

 * (or NULL if there is no parameter)

 **/

void xbee_send_modify_at_command(char* command, char* value)

{

	char buf[16];

	int i;

	buf[0] = XBEE_FRAME_AT_COMMAND;

	buf[1] = 1;

	buf[2] = command[0];

	buf[3] = command[1];

	int valueLen = 0;

	if (value != NULL)

	{

		valueLen = strlen(value);

		if (valueLen > 8)

		{

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

			return;

		}

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

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

	}

	xbee_send_frame(buf, 4 + valueLen);

}

/**

 * Send the specified packet.

 * 

 * @param packet the packet data to send

 * @param len the number of bytes in the packet

 * 

 * @param dest the ID of the XBee to send the packet to,

 * or XBEE_BROADCAST to send the message to all robots

 * in the PAN.

 * 

 * @param options a combination of the flags

 * XBEE_OPTIONS_NONE, XBEE_OPTIONS_DISABLE_RESPONSE and 

 * XBEE_OPTIONS_BROADCAST_ALL_PANS

 *

 * @param frame the frame number to associate this packet

 * with. This will be used to identify the response when

 * the XBee alerts us as to whether or not our message

 * was received.

 **/

void xbee_send_packet(char* packet, int len, int dest,

	char options, char frame)

{

	char buf[5];

	char prefix[3];

	int i;

	unsigned char checksum = 0;

	if (len > 100)

	{

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

		return;

	}

	//data for sending request

	buf[0] = XBEE_FRAME_TX_REQUEST_16;

	buf[1] = frame;

	buf[2] = (dest >> 8) & 0xFF;

	buf[3] = dest & 0xFF;

	buf[4] = options;

	//packet prefix, do this here so we don't need an extra buffer

	prefix[0] = XBEE_FRAME_START;

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

	prefix[2] = (5 + len) & 0xFF;

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

		checksum += (unsigned char)buf[i];

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

		checksum += (unsigned char)packet[i];

	checksum = 0xFF - checksum;

	xbee_send(prefix, 3);

	xbee_send(buf, 5);

	xbee_send(packet, len);

	xbee_send((char*)&checksum, 1);

}

/**

 * Reads a packet received from the XBee. This function

 * is non-blocking. The resulting packet is stored in dest.

 * Only returns transmission response packets and

 * received packets. The returned packet does not include

 * header information or the checksum. This method also

 * handles special packets dealt with by the XBee library,

 * and so should be called frequently while the XBee is in

 * use.<br><br>

 *

 * The first byte of the packet will be either

 * XBEE_TX_STATUS or XBEE_RX to indicated

 * a response to a sent message or a received message, 

 * respectively.<br><br>

 *

 * For a status response packet:<br>

 * The first byte will be XBEE_TX_STATUS.<br>

 * The second byte will be the frame number.<br>

 * The third byte will be the result. 0 indicates success,

 * and nonzero indicates that an error ocurred in 

 * transmitting the packet.<br><br>

 *

 * For a received packet:<br>

 * The first byte will be XBEE_RX.<br>

 * The second and third bytes will be the 16-bit

 * address of the packet's sender.<br>

 * The fourth byte is the signal strength.<br>

 * The fifth byte is 1 if the packet were sent to

 * a specific address, and 2 if it is a broadcast packet.<br><br>

 * 

 * @param dest set to the packet data

 * @return the length of the packet, or -1 if no packet

 * is available

 **/

int xbee_get_packet(unsigned char* dest)

{

	//start reading a packet with XBEE_FRAME_START

	if (currentBufPos == 0)

	{

		do

			if (queue_is_empty(xbee_queue))

				return -1;

		while ((char)(int)queue_remove(xbee_queue) != XBEE_FRAME_START);

		xbee_buf[0] = XBEE_FRAME_START;

		currentBufPos++;

	}

	int len = -1;

	if (currentBufPos >= 3)

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

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

			|| currentBufPos < len + 4)

	{

		if (currentBufPos == 3)

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

		if (queue_is_empty(xbee_queue))

			return -1;

		xbee_buf[currentBufPos++] = (char)(int)queue_remove(xbee_queue);

	}

	currentBufPos = 0;

	if (!xbee_verify_checksum(xbee_buf, len + 4))

	{

		WL_DEBUG_PRINT("XBee checksum failed.\r\n");

		return -1;

	}

	//we will take care of the packet

	if (xbee_handle_packet(xbee_buf + 3, len))

		return -1;

	if (dest == NULL)

		return -1;

	int i;

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

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

	return len;

}

/**

 * Handles modem status packets.

 *

 * @param status the type of status packet received.

 **/

void xbee_handle_status(char status)

{

	switch (status)

	{

		case 0:

			WL_DEBUG_PRINT("XBee hardware reset.\r\n");

			break;

		case 1:

			WL_DEBUG_PRINT("Watchdog timer reset.\r\n");

			break;

		case 2:

			WL_DEBUG_PRINT("Associated.\r\n");

			break;

		case 3:

			WL_DEBUG_PRINT("Disassociated.\r\n");

			break;

		case 4:

			WL_DEBUG_PRINT("Synchronization lost.\r\n");

			break;

		case 5:

			WL_DEBUG_PRINT("Coordinator realignment.\r\n");

			break;

		case 6:

			WL_DEBUG_PRINT("Coordinator started.\r\n");

			break;

	}

}

/**

 * Handles AT command response packets.

 * @param command the two character AT command, e.g. MY or ID

 * @param result 0 for success, 1 for an error

 * @param extra the hex value of the requested register

 * @param extraLen the length in bytes of extra

 **/

void xbee_handle_at_command_response(char* command, char result,

	char* extra, int extraLen)

{

	if (result == 1)

	{

		WL_DEBUG_PRINT("Error with AT");

		WL_DEBUG_PRINT(command);

		WL_DEBUG_PRINT(" packet.\r\n");

	}

	WL_DEBUG_PRINT("AT");

	WL_DEBUG_PRINT(command);

	WL_DEBUG_PRINT(" command was successful.\r\n");

	if (command[0] == 'I' && command[1] == 'D')

	{

		xbee_panID = xbee_pending_panID;

		WL_DEBUG_PRINT("PAN ID set to ");

		WL_DEBUG_PRINT_INT(xbee_panID);

		WL_DEBUG_PRINT(".\r\n");

		return;

	}

	if (command[0] == 'C' && command[1] == 'H')

	{

		xbee_channel = xbee_pending_channel;

		WL_DEBUG_PRINT("Channel set to ");

		WL_DEBUG_PRINT_INT(xbee_channel);

		WL_DEBUG_PRINT(".\r\n");

		return;

	}

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

	{

		xbee_address = 0;

		int i;

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

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

		WL_DEBUG_PRINT("XBee address is ");

		WL_DEBUG_PRINT_INT(xbee_address);

		WL_DEBUG_PRINT(".\r\n");

		if (xbee_address == 0)

		{

			WL_DEBUG_PRINT("XBee 16-bit address must be set using ATMY.\r\n");

			exit(0);

		}

	}

}

/**

 * Attempts to handle the packet if it is dealt with

 * by the library.

 * We will handle the following packet types:

 *    Modem Status

 *    AT Command Response

 *

 * @param packet the packet to handle

 * @param len the length of the packet

 * 

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

 */

int xbee_handle_packet(char* packet, int len)

{

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

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

	{

		WL_DEBUG_PRINT("Non-positive packet length.\r\n");

		return 0;

	}

	switch ((unsigned char)packet[0]) //packet type

	{

		case XBEE_FRAME_STATUS:

			xbee_handle_status(packet[1]);

			return 1;

		case XBEE_FRAME_AT_COMMAND_RESPONSE:

			command[0] = packet[2];

			command[1] = packet[3];

			command[2] = 0;

			xbee_handle_at_command_response(command,

				packet[4], packet + 5, len - 5);

			return 1;

	}

	return 0;

}

/**

 * Sets the personal area network id.

 *

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

 **/

void xbee_set_pan_id(int id)

{

	char s[3];

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

	s[1] = id & 0xFF;

	s[2] = 0;

	xbee_pending_panID = id;

	xbee_send_modify_at_command("ID", s);

}

/**

 * Get the PAN ID for the XBee.

 * 

 * @return the personal area network id, or

 * XBEE_PAN_DEFAULT if it has not yet been set.

 **/

unsigned int xbee_get_pan_id()

{

	return xbee_panID;

}

/**

 * Set the channel the XBee is using.

 *

 * @param channel the channel the XBee will not use, 

 * between 0x0B and 0x1A

 *

 * @see xbee_get_channel

 **/

void xbee_set_channel(int channel)

{

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

	{

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

		return;

	}

	char s[3];

	s[0] = channel & 0xFF;

	s[1] = 0;

	xbee_pending_channel = channel;

	xbee_send_modify_at_command("CH", s);

}

/**

 * Returns the channel which the XBee is currently using.

 *

 * @return the channel the XBee is using

 *

 * @see xbee_set_channel

 **/

int xbee_get_channel(void)

{

	return xbee_channel;

}

/**

 * Get the 16-bit address of the XBee.

 * This is used to specify who to send messages to

 * and who messages are from.

 *

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

 **/

unsigned int xbee_get_address()

{

	return xbee_address;

}

/*

	serial.h - Contains definitions and function prototypes for the RS232 serial port

*/

#ifndef _SERIAL_H

#define _SERIAL_H

// Tested baud rates

#define BAUD9600    103

#define BAUD115200  8  //Warning--3.5% error

// Untested baud rates that might be right --aaron

#define BAUD1M	     0

#define BAUD500K     1

#define BAUD250K     3

#define BAUD230400   3   //Warning--8.5% error

#define BAUD76800    12

#define BAUD57600    16  //Warning--2.1% error

#define BAUD38400    25

#define BAUD28800    34

#define BAUD19200    51

#define BAUD14400    68

#define BAUD4800     207

#define BAUD2400     416  //Might not work, since it needs some high bits set

// Function descriptions are available in serial.c

//zigbee

void xbee_init( unsigned int ubrr);

int xbee_putc(char c);

int xbee_puts(char *s);

int xbee_getc(void);

int xbee_getc_nb(void);

int xbee_puti(int x);

//db9

void usb_init( unsigned int ubrr);

int usb_putc(char c);

int usb_getc(void);

int usb_getc_nb(void);

int usb_puts(char *s);

int usb_puti(int x);

#endif

/*

	buzzer.h - Contains function prototypes for running the buzzer

	author: Robotics Club, Colony Project

*/

#ifndef _BUZZER_H_

#define _BUZZER_H_

//Musical note definitions

//Source: http://www.answers.com/topic/piano-key-frequencies

#define	C4	260 //Middle C

#define	C4s	277 //C sharp

#define	D4	294

#define	D4s	311

#define	E4	330

#define	F4	349

#define	F4s	370

#define	G4	392

#define	G4s	415

#define	A4	440

#define	A4s	466

#define	B4	494

#define	C5	523

// Function descriptions can be found in buzzer.c

void buzzer_init(void);

void buzzer_set_val(unsigned int buzz_value);

void buzzer_set_freq(unsigned int buzz_freq);

void buzzer_chirp(unsigned int ms, unsigned int buzz_freq);

void buzzer_off(void); 

#endif

/**

 * @file xbee.h

 * @brief Contains definitions for using the XBee

 *

 * Contains definitions for interfacing with the 

 * XBee module, from either a robot or a computer.

 * To use a robot, define ROBOT in wl_defs.h, and

 * to use a computer, don't define ROBOT.

 *

 * @author Brian Coltin, Colony Project, CMU Robotics Club

 **/

/**

 * @defgroup xbee XBee

 * @brief Interface with the XBee module

 *

 * Interface with the XBee module.

 *

 * @{

 **/

/*Definitions*/

/**@brief Unset PAN, uses XBee default **/

#define XBEE_PAN_DEFAULT 0xFFFF

/**@brief Unset channel, uses XBee default **/

#define XBEE_CHANNEL_DEFAULT 0

/**@brief Broadcast to all robots in the PAN **/

#define XBEE_BROADCAST 0xFFFF

/**@brief No special options **/

#define XBEE_OPTIONS_NONE 0x00

/**@brief Do not receive a TX_STATUS message from this packet **/

#define XBEE_OPTIONS_DISABLE_RESPONSE 0x01

/**@brief Send the packet to all PANS **/

#define XBEE_OPTIONS_BROADCAST_ALL_PANS 0x04

/**@brief A transmit status packet **/

#define XBEE_TX_STATUS 0x89

/**@brief A packet received from another XBee **/

#define XBEE_RX 0x81

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

void xbee_lib_init(void);

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

void xbee_terminate(void);

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

int xbee_get_packet(unsigned char* packet);

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

void xbee_send_packet(char* packet, int len, int dest,

	char options, char frame);

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

void xbee_set_pan_id(int id);

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

unsigned int xbee_get_pan_id(void);

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

void xbee_set_channel(int channel);

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

int xbee_get_channel(void);

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

unsigned int xbee_get_address(void);

/**@}**/ //end defgroup

# 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".

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

# 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 = 16000000

# 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 = 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 -DROBOT -DFIREFLY

# Place -I options here

CINCS =