Colony

/*

lights.h

Contains function prototypes, variables, and pins used by the Orbs and PWM

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

author: CMU Robotics Club, Colony Project

Change Log:

1.25.07 - KWoo

	Removed FF+ code. Cleaned up and commented all variables.

*/

#ifndef _LIGHTS_H_

#define _LIGHTS_H_

/***** Port and Pin Definitions ****/

//Orb Ports and Registers

#define ORB_PORT	PORTC

#define ORB_DDR		DDRC

//Orb Pins

#define ORB1_RED	0x00

#define ORB1_GREEN	0x01

#define ORB1_BLUE	0x02

#define ORB2_RED 	0x04

#define ORB2_GREEN 	0x05

#define ORB2_BLUE 	0x06

//ORB Colors

#define RED       0xE0

#define ORANGE    0xE4

#define YELLOW    0xE8

#define LIME      0x68

#define GREEN     0x1C

#define CYAN      0x1F

#define BLUE      0x03

#define PINK      0xA6 

#define PURPLE    0x41

#define MAGENTA   0xE3

#define WHITE     0xFE

#define ORB_OFF   0x00

#include <avr/interrupt.h>

#define ORB_RESET 1025

#define ORBPORT PORTC

#define ORBDDR DDRC

#define ORBMASK 0x77

/**** Function Prototypes ****/

//Enables counter and PWM for use with the orb.

void orb_init(void);

//Sets both orbs to a specified color 

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

//Sets Orb1 to the specified color

void orb1_set(unsigned char red_led, unsigned char green_led, unsigned char blue_led); 

//Sets Orb2 to the specified color

void orb2_set(unsigned char red_led, unsigned char green_led, unsigned char blue_led);

//Sets both orbs to the same color using a color name

void orb_set_color(int col);

//Sets orb1 to a color using a color name

void orb1_set_color(int col);

//Sets orb2 to a color using a color name

void orb2_set_color(int col);

//Turns off the PWM and thus the Orbs

void orb_disable(void);

//Turns on the PWM and thus the Orbs

void orb_enable(void);

//Runs through some colors

void orb_tester(void);

//Set just one channel

void orb_set_angle(int servo, int angle);

#endif

/*

	motor.c - Contains functions necessary for activating and driving the 

	H-bridge

	author: Robotics Club, Colony project

	much of this is taken from FWR's library, author: Tom Lauwers

*/

#include "motor.h"

/*

motor initialization

initializes both motors

*/

void motors_init( void ) {

	// Configure counter such that we use phase correct

	// PWM with 8-bit resolution

	PORTA &= 0x0F;

	DDRA |= 0xF0;

	DDRB |= 0x60;

	//timer 1A and 1B

	TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM10);

	TCCR1B = _BV(WGM12) | _BV(CS10);

//	TCCR1A = 0xA1;

//	TCCR1B = 0x04;

	OCR1AH=0;

	OCR1AL=0;

	OCR1BH=0;

	OCR1BL=0;

}

// The following functions set the motor direction and speed

void motor1_set(int direction, int speed) {

	if(direction == 0) {

	    // turn off PWM first if switching directions

		if((PORTA & 0x30) != 0x10)

		{

		  OCR1A = 0;

		}	

		PORTA = (PORTA & 0xCF) | 0x10;

//		PORTD |= 0x10;

//		PORTD &= 0xBF;

	}

	else {

	    // turn off PWM first if switching directions

		if((PORTA & 0x30) != 0x20)

		{

		  OCR1A = 0;

		}

		PORTA = (PORTA & 0xCF) | 0x20;

//		PORTD |= 0x40;

//		PORTD &= 0xEF;

	}

	// Set the timer to count up to speed, an 8-bit value

	OCR1AL = speed;

}

void motor2_set(int direction, int speed) {

	if(direction == 0) {

//		PORTD |= 0x20;

//		PORTD &= 0x7F;

	    // turn off PWM first if switching directions

		if((PORTA & 0xC0) != 0x80)

		{

		  OCR1B = 0;

		}		

		PORTA = (PORTA & 0x3F) | 0x80;

	}

	else {

//		PORTD |= 0x80;

//		PORTD &= 0xDF;

	    // turn off PWM first if switching directions

		if((PORTA & 0xC0) != 0x40)

		{

		  OCR1B = 0;

		}		

		PORTA = (PORTA & 0x3F) | 0x40;

	}

	OCR1BL = speed;

}

// Just turns off both motors

void motors_off( void ) {

	OCR1AL = 0x0;

	OCR1BL = 0x0;

}

/**

 * Eugene Marinelli

 * 4/5/07

 *

 * Robot wireless relay - dragonfly edition

 */

#include "dragonfly_lib.h"

#include <stdio.h>

#include <string.h>

int main(void)

{

  orb_init();

  orb_enable();

  usb_init();

  xbee_init();

  // orb_set_color(GREEN);

  orb_set_color(GREEN);

  //UCSR0B |= _BV(RXCIE);

  UCSR1B |= _BV(RXCIE);

  sei();

  while (1) {

    xbee_putc(usb_getc());

    orb_set_color(YELLOW);

  }

  return 0;

}

ISR(USART1_RX_vect)

{

  //char buf = UDR1;

  usb_putc(UDR1);

  //orb_set_color(RED);

}

/*

	motor.h - Contains the function prototypes for controlling motors

	author:  Tom Lauwers

*/

#ifndef _MOTOR_H

#define _MOTOR_H

#include <avr/io.h>

#define FORWARD 1

#define BACKWARD 0

// Function descriptions can be found in motor.c

void motors_init(void);

void motor1_set(int direction, int speed);

void motor2_set(int direction, int speed);

void motors_off(void);

#endif

#include <dragonfly_lib.h>

/* init_dragonfly - Initializes functions based on configuration parameters

   examples:

   init_dragonfly (0, 0, 0); - just initialize the digital IO (buttons, potentiometer)

   init_dragonfly (ANALOG | SERIAL | BUZZER, C0_C1_ANALOG, BAUD115200); 

   Initialize ADC and set C0 and C1 as analog inputs.  Initialize serial and set baud rate

   to 115200 bps.  Initialize the buzzer.

   init_dragonfly (MOTORS | ORB, 0, 0);

   Initialize motor driving and the color fading abilities of the ORB. */

void dragonfly_init(int config) 

{

	// Set directionality of various IO pins

	DDRG &= ~(_BV(PING0)|_BV(PING1));

	PORTG |= _BV(PING0)|_BV(PING1);

	if(config & ANALOG) {

		analog_init();

	}

	if(config & COMM) {

    //Defaults to 115200. Check serial.h for more information.

    sei();

    usb_init();

    xbee_init();

	}

	if(config & BUZZER) {

    sei();

		buzzer_init();

	}

	if(config & ORB) {

    sei();

		orb_init();

	}

	if(config & MOTORS) {

		motors_init();

	}

	if(config & SERVOS) {

		sei();

    //Servos not yet implemented

    //servo_init();

	}

	if(config & LCD) {

		lcd_init();

	}

	if(config & (SERVOS | ORB)) {

    sei();

    orb_init();

    //Servos not yet implemented

	}

	// delay a bit for stability

	_delay_ms(1);

}

void adc_gain_test(void);

void analog_test(void);

void batt_test(void);

void button_test(void);

void buzzer_test(void);

void dio_test(void);

void general_test(void);

void i2c_test(void);

void lcd_test(void);

void motor_test(void);

void orb_test(void);

void pullup_test(void);

void ranger_test(void);

void reset_test(void);

void ring_buffer_tester(void);

void rtc_test(void);

void rtc_test_pulse(void);

void serial_test(void);

void servo_orb_test(void);

void wl_receive_test(void);

void wl_send_test(void);

void wl_send_packet_test(void);

void move_test(void);

void move_test(void){

  range_init();

  motors_init();

  analog_init();

  while(1){

    move_avoid(200,0,50 );

  }

}  

void general_test(){

	int i;

	dragonfly_init(MOTORS|BUZZER|ORB|USB);

	while(1){

		if(button1_read()){

			for(i=0;i<17;i++){

				buzzer_set_val(i);

				delay_ms(100);

			}

			buzzer_off();

			motor1_set(1, 255);

			motor2_set(1, 255);

			delay_ms(3000);

			motor1_set(1, 200);

			delay_ms(1000);

			motor1_set(0, 255);

			motor2_set(0, 255);

			delay_ms(3000);

			motors_off();

		}

		if(button2_read()){

			orb_enable();

			orb1_set_color(RED);

			delay_ms(500);

			orb2_set_color(GREEN);

			delay_ms(500);

			orb1_set_color(YELLOW);

			delay_ms(500);

			orb2_set_color(CYAN);

			delay_ms(500);

			orb1_set_color(WHITE);

			delay_ms(500);

			orb2_set_color(WHITE);

			delay_ms(500);

			orb_disable();

		}

	}

}

void reset_test() {

    dragonfly_init(ORB|SERIAL);

    delay_ms(1000);

    usb_puti((int)DDRE);

    orb_set_color(RED);

    delay_ms(1000);

    orb_set_color(GREEN);

    delay_ms(1000);

    DDRE |= 0x80;

    reset();

    /*

    alternate implelmentation using external interrupts

    maintains register values on reset

    sei();

    EIMSK |= 0x80;

    EICRB |= 0xC0;

    DDRE |= 0x80;

    PORTE &= 0x7F;

    PORTE |= 0x80;

    */

    /*

    should not reach here

    */

    orb_set_color(BLUE);

    delay_ms(1000);

}

void ring_buffer_tester (void) {

	dragonfly_init(ALL_ON & ~ORB);

	orb_disable();

	RING_BUFFER_NEW(ring_buffer, 12, int, buffer);

	RING_BUFFER_INIT(buffer, 12);

	RING_BUFFER_CLEAR(buffer);

	for(int i=0;i<10;i++)

		RING_BUFFER_ADD(buffer, 0);

	int x;

	for(int i = 0; i < 100; i++) {

		RING_BUFFER_REMOVE(buffer, x);

		RING_BUFFER_ADD(buffer, i);

		usb_puti(i-x);

		usb_putc(' ');

	}

	usb_puts("\n\rfull? " );

	usb_puti(RING_BUFFER_FULL(buffer));

	while(!RING_BUFFER_FULL(buffer))

		RING_BUFFER_ADD(buffer, 0);

	usb_puts("\n\rfilling... full? " );

	usb_puti(RING_BUFFER_FULL(buffer));

	usb_puts("\n\rempty? " );

	usb_puti(RING_BUFFER_EMPTY(buffer));

	usb_puts("\n\rclearing... empty? ");

	RING_BUFFER_CLEAR(buffer);

	usb_puti(RING_BUFFER_EMPTY(buffer));

	usb_puts("\n\r");

}

#define WL_BAUD BAUD115200

//serial -- XBEE

//serial1 -- USB

void wl_send_test(void) {

	int i;

	usb_init();		//WIRED

	xbee_init();	//WIRELESS

	orb_init();

	sei();

	while(1) {

		for(i = 32; i <= 126; i++) {

			if(i%4) {

				orb1_set(255, 0, 0);

			}

			else {

				orb1_set(0,0,0);

			}

			usb_putc(i);		//wired

			xbee_putc(i);		//wireless

			delay_ms(100);

		}

	}

	return;

}

void wl_send_packet_test(void) {

	int i;

	usb_init();		//WIRED

	xbee_init();	//WIRELESS

	orb_init();

	sei();

	while(1) {

		for(i = 65; i <= 122; i++) {

			usb_putc(i);		//wired

			xbee_putc(i);		//wireless

      //delay_ms(100);

		}

    delay_ms(1000);

	}

	return;

}

volatile char c;

volatile char haveNew = 0;

void wl_receive_test(void) {

	usb_init();

	xbee_init();

	orb_init();

	c = '.';

  xbee_putc('r');

	UCSR1B |= _BV(RXCIE);

	UCSR0B |= _BV(RXCIE);

	sei();

	orb1_set(255, 0, 0);		//blue

	while(1)	 {

		if(haveNew) {

			xbee_putc(c);

			haveNew = 0;

		}

	}

	orb1_set(0, 0, 255);		//green

	while(1);

}

/*

ISR(USART1_RX_vect) {

	c = UDR1;

	haveNew = 1;

}

ISR(USART0_RX_vect) {

	c = UDR0;

	haveNew = 1;

}

*/

void buzzer_test(void)

{

	sei();

	buzzer_init();

	unsigned int i = 0;

	while(1) {

		buzzer_set_val(i);

		if (i == 20) {

			i = 0;

			delay_ms(250);

		} else {

			i++;

		}

		delay_ms(100);

	}

}

void adc_gain_test(void)

{

  analog_init();

  lcd_init();

  while(1)

  {

    lcd_putint(ADCH);

    delay_ms(100);

    lcd_clear_screen();

  }

}

void ranger_test( void )

{

	lcd_init();

	while(1) {

		lcd_clear_screen();

		lcd_putint(linearize_distance(read_distance(PIN_C0)));

		delay_ms(100);

	}

}

void button_test ( void) 

{

    dragonfly_init(ALL_ON);

    move(200,0);

	while(1) {

		if(button1_read()) {

			//lcd_putchar('1');

			usb_putc('1');

		} else if(button2_read()) {

			//lcd_putchar('2');

			usb_putc('2');

		}

	}

}

void motor_test (void) {

	motors_init();

	//led_init();

	//motor1_set(1, 255);

	//motor2_set(1, 255);

	move(200,0);

	delay_ms(5000);

	//motor1_set(0, 200);

	move(200,100);

	delay_ms(5000);

	//motor2_set(0, 170);

	move(200,0);

	delay_ms(5000);

	motors_off();

	//LED USER NO LONGER EXISTS

	//led_user(1);

	while(1);

}

void orb_test( void ) {

	int orbs[12] = { ORB_OFF, RED, ORANGE, YELLOW, LIME, GREEN, CYAN, BLUE, PINK, PURPLE, MAGENTA, WHITE };

	int orb_select = 0;

	lcd_init();

	orb_init();

	sei();

	orb2_set(254, 253, 252);

	orb1_set(251, 250, 249);

	while(1) {

		orb_set_color(orbs[orb_select]);

		/*orb_set1(251, 250, 249);

		delay_ms(2000);

		orb_set1(255, 1,2);

		delay_ms(1000);

		orb_set1(1, 255, 2);

		delay_ms(1000);

		orb_set1(1, 2, 255);

		*/

		delay_ms(3000);

		orb_select++;

		if(orb_select == 13) {

			orb_disable();

			delay_ms(2000);

			orb_enable();

			orb_select = 0;

		}

	/*

		for (int i = 0; i < 256; i++) {

			for (int j = 0; j < 256; j++) {

				for (int k = 0; k < 256; k++) {

					orb_set(i, j, k);

				}

			}

		}

	*/

	}

	return;

}

void servo_orb_test( void ) {

//	int orbs[13] = { ORB_OFF, RED, ORANGE, YELLOW, LIME, GREEN, CYAN, BLUE, PURPLE, PINK, PURPLE, MAGENTA, WHITE };

	int orb_select = 0;

	orb_init();

	sei();

	orb_set_angle(1,250);

	orb_set_angle(2,250);

	orb_set_angle(4,0);

	orb_set_angle(5,0);

	orb_set_angle(6,0);

	while(1) {

		//orb_set_color(orbs[orb_select]);

		orb_set_angle(0,orb_select+1);

	//	orb_set_angle(1,orb_select+1);

	//	orb_set_angle(2,orb_select+1);

		delay_ms(50);

		orb_select++;

		if(orb_select == 255) {

			orb_select = 0;

		}

	/*

		for (int i = 0; i < 256; i++) {

			for (int j = 0; j < 256; j++) {

				for (int k = 0; k < 256; k++) {

					orb_set(i, j, k);

				}

			}

		}

	*/

	}

	return;

}

void lcd_test(void) {

	int i, j;

	lcd_init();

	for(i = 32,j = 1; i <= 126; i++) {

		lcd_putchar(i);

		delay_ms(250);

        if(j > 50) {

            lcd_clear_screen();

            j = 0;

        }

        j++;

	}

	return;

}

void serial_test( void ) {

	int i;

	usb_init();

	for(i = 32; i <= 126; i++) {

		usb_putc(i);

		delay_ms(250);

	}

	return;

}

void pullup_test()

{

	lcd_init();

	lcd_putstr("pullup test");

	delay_ms(100);

	digital_pull_up(PIN_A4);

	digital_pull_up(PIN_A5);

	digital_pull_up(PIN_A6);

	digital_pull_up(PIN_A7);

	while(1){

		lcd_clear_screen();

		if(!digital_input(PIN_A4))

			lcd_putchar('0');

		else

			lcd_putchar(' ');

		if(!digital_input(PIN_A5))

			lcd_putchar('1');

		else

			lcd_putchar(' ');

		if(!digital_input(PIN_A6))

			lcd_putchar('2');

		else

			lcd_putchar(' ');

		if(!digital_input(PIN_A7))

			lcd_putchar('3');

		else

			lcd_putchar(' ');

		delay_ms(100);

	}

}

void batt_test()

{

	lcd_init();

  usb_init();

	analog_init();

	while(1){

    usb_puti(battery8());

    usb_putc(' ');

		delay_ms(10000);

	}

}

void analog_test(void){

  //int i;

  analog_init();

  usb_init();

  range_init();

  usb_puts(" information:\n");

  while(1){

    printAllBoms();

    /*for(i=0;i<16;i++){

      digital_output(MONK0,i&1);

      digital_output(MONK1, (i>>1)&1);

      digital_output(MONK2, (i>>2)&1);

      digital_output(MONK3, (i>>3)&1);

      usb_puts("Bom ");

      usb_puti(i);

      usb_puts(": ");

      usb_puti(analog8(MONKI));

      usb_puts("\n\r");

    }*/

    /*for(i=1;i<8;i++){

      usb_puts("Analog Ext ");

      usb_puti(i);

      usb_puts(":  ");

      usb_puti(analog8(i));

      usb_puts("\n\r");

    }

    usb_puts("IR1 val: ");

    usb_puti(read_distance(IR1));

    usb_puts("\n\rIR2 val: ");

    usb_puti(read_distance(IR2));

    usb_puts("\n\rIR3 val: ");

    usb_puti(read_distance(IR3));

    usb_puts("\n\rIR4 val: ");

    usb_puti(read_distance(IR4));

    usb_puts("\n\rIR5 val: ");

    usb_puti(read_distance(IR5));

    */

    delay_ms(2000);

  }

}

void dio_test()

{

	while(1)

	{

		digital_output(_PIN_E5,1);

		delay_ms(1000);

		digital_output(_PIN_E5,0);

		delay_ms(1000);

	}

}

void rtc_test_pulse() {

	usb_putc('s');

}

void rtc_test() {

	sei();

	usb_init();

	usb_putc('a');

	rtc_init(HALF_SECOND, &rtc_test_pulse);

}

#define RECEIVE 1

#define MY_ADDR (RECEIVE == 1 ? 0x01 : 0x02)

#define TARGET_ADDR (RECEIVE == 1 ? 0x02 : 0x01)

void i2c_test() {

  char c = 0;

  char i = 0;

  sei();

  i2c_init(MY_ADDR);

  usb_init();

  usb_putc('5');

  delay_ms(1000);

  while(1) {

    if (RECEIVE) {

      while(c != 'z') {

        if(!i2c_getc(&c)) {

          usb_putc(c);

          usb_putc(' ');

        }

      }

    } else {

    while(i < 26) {

      if(!i2c_putc(TARGET_ADDR, i + 0x61))

        i++;

      }

    }

    delay_ms(1000);

    if (!RECEIVE) {

      while(c != 'z') {

        if(!i2c_getc(&c)) {

          usb_putc(c);

          usb_putc(' ');

        }

      }

    } else {

      while(i < 26) {

        if(!i2c_putc(TARGET_ADDR, i + 0x61))

          i++;

      }

    }

    c = 0;

    i = 0;

  }

  while(1);

}

/* I2C.c

*/

#include <avr/interrupt.h>

#include <util/twi.h>

#include "i2c.h"

#include "ring_buffer.h"

static int start_flag;

RING_BUFFER_NEW(i2c_buffer, 64, char, i2c_write_buff, i2c_addr_buff, i2c_read_buff);

void i2c_init(char address) {

	// Enable I2C and turn on the interrupt

  //TWCR = 0;

  /* initialize the buffers */

  RING_BUFFER_CLEAR(i2c_write_buff);

  RING_BUFFER_CLEAR(i2c_addr_buff);

  RING_BUFFER_CLEAR(i2c_read_buff);

	TWCR =  (_BV(TWEA) | _BV(TWEN) | _BV(TWIE));

  //Set bit rate 12 = 100kbit/s

  TWBR = 0x0C;

	TWAR = (address << 1);	//0b0000001 address, 0 for global commands to be off

  //usb_putint(TWAR);

  //i2cTXFlag = 0;

  //i2cRXFlag = 0;

}

char i2c_putc(char dest, char data) {

  if(RING_BUFFER_FULL(i2c_write_buff))

    return -1;

  cli();

  RING_BUFFER_ADD(i2c_write_buff, data);

  RING_BUFFER_ADD(i2c_addr_buff, dest << 1);

  sei();

	//Start bit

  if(!start_flag) {

    start_flag = 1;

    TWCR |= _BV(TWSTA);

    TWCR |= _BV(TWINT);

  }

  return 0;

}

char i2c_getc(char * c) {

  if(RING_BUFFER_EMPTY(i2c_read_buff))

    return -1;

  else

    RING_BUFFER_REMOVE(i2c_read_buff, *c);

  return 0;

}

ISR(TWI_vect) {

  static char data_to_send;

  static char addr_to_send = -1;

  char addr, statusCode;

    //Get status code (only upper 5 bits)

    statusCode = (TWSR & 0xF8);

  switch (statusCode) {

    //Start sent successfully

    case TW_START:

    case TW_REP_START:

      //Send address and write

      //ring_buffer will not be empty

      RING_BUFFER_REMOVE(i2c_addr_buff, addr_to_send);

      RING_BUFFER_REMOVE(i2c_write_buff, data_to_send);

      TWDR = addr_to_send; /* first send the address */

      /* we will send the data next time around */

      //Turn off start bits

      TWCR &= ~_BV(TWSTA);

      break;

    //Address sent successfully

    case TW_MT_SLA_ACK:

      //Send byte

      TWDR = data_to_send;

      break;

    //Packet complete, close line

    case TW_MT_DATA_ACK:

      if(!RING_BUFFER_EMPTY(i2c_write_buff)) {

        RING_BUFFER_PEEK(i2c_addr_buff, addr);

        if(addr == addr_to_send) {

          RING_BUFFER_REMOVE(i2c_addr_buff, addr);

          RING_BUFFER_REMOVE(i2c_write_buff, TWDR);

          break;

        }

        else { /* no more bytes to this addr, bytes to send to new addr */

          /* doing the start signal again */

          TWCR |= _BV(TWSTA);

          break;

        }

      }

      /* there are no bytes to send */

      TWCR |= _BV(TWSTO);

      start_flag = 0;

      break;

    case TW_SR_SLA_ACK:

      break;

    case TW_SR_DATA_ACK:

      if(!RING_BUFFER_FULL(i2c_read_buff))

        RING_BUFFER_ADD(i2c_read_buff, TWDR);

      break;

    case TW_SR_STOP:

      break;

  }

  TWCR |= _BV(TWINT);

}

/*

	serial.c - Functions for using the RS232 serial port

	authors: Robotics Club, Colony Project, pkv

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

*/

#include <avr/io.h>

#include <stdio.h>

#include "serial.h"

/* usb_init() - sets up AVR for communication over the usb serial port */

void usb_init() {

  //Set baud rate

  // - 115200 (both wired and wireless) is UBRR=8, U2X=1

  // - 9600 is U2X =1, UBRR = 107.

	#if (USB_BAUD == 115200)

    UBRR0H = 0x00;

    UBRR0L = 8;

    UCSR0A |= _BV(U2X0);

  #elif (USB_BAUD == 9600)

    UBRR0H = 0x00;

    UBRR0L = 107;

    UCSR0A |= _BV(U2X0);

  #else //Baud rate is defined in the header file, we should not get here

    return;

  #endif

  /*Enable receiver and transmitter */

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

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

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

  // if we have enabled the stdio stuff, then we init it here

  #ifdef USE_STDIO

    /* Open the stdio stream corresponding to this port */

    usb_fd = fdevopen(usb_putc, usb_getc);

  #endif

}

/* xbee_init() - sets up AVR for communication over the xbee serial port */

void xbee_init() {

  //Set baud rate

  // - 115200 (both wired and wireless) is UBRR=8, U2X=1

  // - 9600 is U2X =1, UBRR = 107.

	#if (XBEE_BAUD == 115200)

    UBRR1H = 0x00;

    UBRR1L = 8;

    UCSR1A |= _BV(U2X1);

  #elif (XBEE_BAUD == 9600)

    UBRR1H = 0x00;

    UBRR1L = 107;

    UCSR1A |= _BV(U2X1);

  #else //Baud rate is defined in the header file, we should not get here

    return;

  #endif

	//Enable receiver and transmitter

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

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

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

  // if we have enabled the stdio stuff, then we init it here

  #ifdef USE_STDIO

    /* Open the stdio stream corresponding to this port */

    xbee_fd = fdevopen(xbee_putc, xbee_getc);

  #endif

}

/* usb_putc(c) - waits until the usb serial tx buffer is clear, then 

  puts the character c into the buffer */

int usb_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;

}

/* xbee_putc(c) - waits until the xbee serial tx buffer is clear, then 

  puts the character c into the buffer */

int xbee_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;

}

/* usb_puts(c) - writes each character from the string to the usb */

int usb_puts(char *s)

{

	char *t = s;

	while (*t != 0)

	{

		usb_putc(*t);

		t++;

	}

  return 0;

}

/* usb_getc() - waits until the usb serial rx buffer is not empty, then 

  returns the first character in the buffer */

int usb_getc(void)

{

  // Wait for the receive buffer to be filled

  loop_until_bit_is_set(UCSR0A, RXC0);

	// Read the receive buffer

	return UDR0;

}

/* xbee_getc() - waits until the xbee serial rx buffer is not empty, then 

  returns the first character in the buffer */

int xbee_getc(void)

{

	// Wait for the receive buffer to be filled

    loop_until_bit_is_set(UCSR1A, RXC1);

	// Read the receive buffer

	return UDR1;

}

/* usb_getc_nb(*c) - checks if the usb serial rx buffer is empty or not:

  -If it is empty, c is unchanged and -1 is returned.  

  -If is not empty, the first character in the buffer is loaded into c,

    and 0 is returned */

int usb_getc_nb(char *c)

{

	// check if the receive buffer is filled

  if (UCSR0A & _BV(RXC0)) {

    // Read the receive buffer

    (*c) = UDR0;

    return 0;

  }

  else {

    // Return empty

    return -1;

	}

}

/* xbee_getc_nb(*c) - checks if the xbee serial rx buffer is empty or not:

  -If it is empty, c is unchanged and -1 is returned.  

  -If is not empty, the first character in the buffer is loaded into c,

    and 0 is returned */

int xbee_getc_nb(char *c)

{

	// check if the receive buffer is filled

  if (UCSR1A & _BV(RXC1)) {

    // Read the receive buffer

    (*c) = UDR1;

    return 0;

  }

  else {

    // Return empty

    return -1;

	}

}

/*

prints an int to serial

code adapted from Chris Efstathiou's code (hendrix@otenet.gr)

uses usb_putc

*/

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;

}

/*

dragonfly_lib.h

author: CMU Robotics Club, Colony project

much of this is adapted from the firefly library (author: Tom Lauwers)

*/

#ifndef _DRAGONFLY_LIB_H_

#define _DRAGONFLY_LIB_H_

// Configuration definitions

#define ANALOG 0x01

#define SERIAL 0x02

#define USB    0x02

#define COMM   0x02

#define ORB    0x04

#define MOTORS 0x08

#define SERVOS 0x10

#define I2C    0x20

#define BUZZER 0x40

#define LCD	   0x80

#define ALL_ON 0xFF

// initializes the board with the functions specified by config

void dragonfly_init(int config);

#include <inttypes.h>

#include <stdio.h>

#include <stdlib.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

#include <util/twi.h>

#include <analog.h>

#include <dio.h>

#include <time.h>

#include <lcd.h>

#include <lights.h>

#include <motor.h>

#include <serial.h>

#include <buzzer.h>

#include <servo.h>

#include <rangefinder.h>

#include <bom.h>

#include <move.h>

#include <i2c.h>

#include <ring_buffer.h>

#include <reset.h>

#include <math.h>

#endif

/*

  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 )

{

//NOTE: This is mostly handled by buzzer_Set_val for now

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

//	DDRB |= _BV(DDB7);

	//Fast PWM Mode, Clear OCR0 on compare match and set at bottom, clock/64

//	TCCR2 = _BV(COM20) | _BV(WGM21)  | _BV(CS22);

}

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

{ 

	TCCR2 = _BV(COM20) | _BV(WGM21)  | _BV(CS22);

	DDRB |= _BV(DDB7);

  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 &= 0xBF;

}

#ifndef _I2C_H_

#define _I2C_H_

void i2c_init(char address);

char i2c_putc(char dest, char data);

char i2c_getc(char * c);

#endif

/*

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

  author(s): pkv

  Directions:

  Call the initialization function for the serial port you wish to use.  Then, use

  either the provided functions or the stdio functions (fprintf, etc) to read and

  write characters to the serial ports.

  UART Mapping:

    usb_*() -> UART0

    xbee_*() -> UART1