Colony

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file motor.c

 * @brief Motors

 *

 * Implementation of functions for controlling the motors.

 *

 * @author Colony Project, CMU Robotics Club

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

 **/

#include "dragonfly_defs.h"

#include "motor.h"

/**

 * @defgroup motors Motors

 * @brief Functions for controlling the motors.

 * Functions for controlling the motors. Found in motor.h.

 * @{

 **/

unsigned char motors_initd=0;

/**

 * Initializes both motors so that they can be used with future

 * calls to motor1_set and motor2_set.

 *

 * @return 0 if init succesfull, an error code otherwise

 *

 * @see motors_off, motor1_set, motor2_set

 **/

int motors_init( void ) {

  if(motors_initd)

    return ERROR_INIT_ALREADY_INITD;

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

  motors_initd=1;

  return 0;

}

/**

 * Sets the speed and direction of the left motor.

 * motors_init must be called before this function can be used.

 *

 * @param direction Either FORWARD or BACKWARD to set the direction of rotation.

 * @param speed The speed the motor will run at, in the range 0-255.

 * 

 * @return 0 if init succesfull, an error code otherwise

 *

 * @see motor_r_set, motors_init

 **/

int motor_l_set(int direction, int speed) {

  if(!motors_initd)

    return ERROR_LIBRARY_NOT_INITD;

  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;

  return 0;

}

/**

 * Sets the speed and direction of the right motor.

 * motors_init must be called before this function can be used.

 *

 * @param direction Either FORWARD or BACKWARD to set the direction of rotation.

 * @param speed The speed the motor will run at, in the range 0-255.

 *

 * @return 0 if init succesfull, an error code otherwise

 *

 * @see motor_l_set, motors_init

 **/

int motor_r_set(int direction, int speed) {

  if(!motors_initd)

    return ERROR_LIBRARY_NOT_INITD;

  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;

  return 0;

}

/**

 * Sets the speed and direction of motor1.

 * motors_init must be called before this function can be used.

 *

 * @param direction Either FORWARD or BACKWARD to set the direction of rotation.

 * @param speed The speed the motor will run at, in the range 0-255.

 *

 * @return 0 if init succesfull, an error code otherwise

 *

 * @see motor2_set, motors_init

 **/

int motor1_set(int direction, int speed) {

  return motor_l_set(direction, speed);

}

/**

 * Sets the speed and direction of motor2.

 * motors_init must be called before this function can be used.

 *

 * @param direction Either FORWARD or BACKWARD to set the direction of rotation.

 * @param speed The speed the motor will run at, in the range 0-255.

 *

 * @return 0 if init succesfull, an error code otherwise

 *

 * @see motor2_set, motors_init

 **/

int motor2_set(int direction, int speed) {

  return motor_r_set(direction, speed);

}

/**

 * Turns off both motors.

 *

 * @return 0 if init succesfull, an error code otherwise

 *

 * @see motors_init

 **/

int motors_off( void ) {

  if(!motors_initd)

    return ERROR_LIBRARY_NOT_INITD;

  OCR1AL = 0x0;

  OCR1BL = 0x0;

  return 0;

}

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

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file motor.h

 * @brief Contains definitions for controlling the motors

 *

 * Contains definitions and functions for controlling

 * the motors.

 *

 * @author Colony Project, CMU Robotics Club

 * Based on Tom Lauwer's Firefly Library

 **/

#ifndef _MOTOR_H

#define _MOTOR_H

#include <avr/io.h>

/**

 * @addtogroup motors

 * @{

 **/

/** @brief make the motors go forwards **/

#define FORWARD 1

/** @brief make the motors go backwards **/

#define BACKWARD 0

/** @brief Initialize the motors **/

int motors_init(void);

/** @brief Set speed and direction of motor1 

 *  @deprecated use the left motor function instead. it's more intuitive and easier to read.**/

int motor1_set(int direction, int speed);

/** @brief Set speed and direction of motor2 

 *  @deprecated use the right motor function instead. it's more intuitive and easier to read.**/

int motor2_set(int direction, int speed);

/** @brief Set speed and direction of left motor **/

int motor_l_set(int direction, int speed);

/** @brief Set speed and direction of right motor **/

int motor_r_set(int direction, int speed);

/** @brief Turn the motors off **/

int motors_off(void);

/**@}**/ // end addtogroup

#endif

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file serial.c

 * @brief Serial Input and Output

 *

 * Implementation of functions for serial input and output.

 *

 * @author Colony Project, CMU Robotics Club

 **/

#include <avr/io.h>

#include "dragonfly_defs.h"

#include "serial.h"

unsigned char usb_initd=0;

unsigned char xbee_initd=0;

#ifdef USE_STDIO

#include <stdio.h>

/**

 * For use with fprintf() and related stdio functions

 **/

FILE *usb_fd;

/**

 * For use with fprintf() and related stdio functions

 **/

FILE *xbee_fd;

#endif

/**

 * Initializes communication over the USB serial port.

 * This must be called before any other usb function

 * may be used.

 **/

int usb_init() {

  //Set baud rate

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

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

  if(usb_initd) {

    return ERROR_INIT_ALREADY_INITD;

  }

#if (USB_BAUD == 115200)

  UBRR0H = 0x00;

  UBRR0L = 8;

  UCSR0A |= _BV(U2X0);

#elif (USB_BAUD == 9600)

  UBRR0H = 0x00;

  UBRR0L = 103;

  UCSR0A |= _BV(U2X0);

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

  return 0;

#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

  usb_initd = 1;

  return 0;

}

/**

 * Initializes communication over the XBee.

 * This must be called before any other xbee function

 * may be used.

 **/

int xbee_init() {

  if(xbee_initd) {

    return ERROR_INIT_ALREADY_INITD;

  }

  //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 = 103;

  UCSR1A |= _BV(U2X1);

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

  return 0;

#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

  xbee_initd = 1;

  return 0;

}

/**

 * Sends a character over USB.

 *

 * @param c the character to send

 * @return 0 for success, nonzero for failure

 **/

int usb_putc(char c) {

  if(!usb_initd)

    return ERROR_LIBRARY_NOT_INITD;

  // Wait until buffer is clear for sending

  loop_until_bit_is_set(UCSR0A, UDRE0);

  // Load buffer with your character

  UDR0 = c;

  return 0;

}

/**

 * Sends a character to the XBee.

 *

 * @param c the character to send

 * @return 0 for success, nonzero for failure

 **/

int xbee_putc(char c) {

  if(!xbee_initd)

    return ERROR_LIBRARY_NOT_INITD;

  // Wait until buffer is clear for sending

  loop_until_bit_is_set(UCSR1A, UDRE1);

  // Load buffer with your character

  UDR1 = c;

  return 0;

}

/**

 * Sends a sequence of characters over USB.

 *

 * @param s the string to send

 * @return 0 for success, nonzero for failure

 **/

int usb_puts(char *s) {

  char *t = s;

  if(!usb_initd)

    return ERROR_LIBRARY_NOT_INITD;

  while (*t != 0) {

    usb_putc(*t);

    t++;

  }

  return 0;

}

/**

 * Sends a sequence of characters from program space over USB.

 *

 * @param s the string to send

 *

 * @return 0 if init succesfull, an error code otherwise

 **/

int usb_puts_P (PGM_P s) {

    char buf;

    if(!usb_initd)

      return ERROR_LIBRARY_NOT_INITD;

    while (memcpy_P (&buf, s, sizeof (char)), buf!=0) {

        usb_putc (buf);

        s++;

    }

    return 0;

}

/**

 * Returns the first character in the buffer received from USB.

 * This function blocks execution until a character has been received.

 * xbee_init must be called before this function may be used.

 * 

 * @return the first character in the usb buffer, -1 on error

 *

 * @see usb_init, usb_getc_nb

 **/

int usb_getc(void) {

  if(!usb_initd)

    return -1;

  // Wait for the receive buffer to be filled

  loop_until_bit_is_set(UCSR0A, RXC0);

  // Read the receive buffer

  return UDR0;

}

/**

 * Returns the first character in the buffer received from USB.

 * This function blocks execution until a character has been

 * received. xbee_init must be called before this function

 * may be used.

 * 

 * @return the first character in the xbee buffer, -1 on error

 * 

 * @see xbee_init, xbee_getc_nb

 **/

int xbee_getc(void) {

  if(!usb_initd)

    return -1;

  // Wait for the receive buffer to be filled

  loop_until_bit_is_set(UCSR1A, RXC1);

  // Read the receive buffer

  return UDR1;

}

/**

 * Non blocking version of usb_getc. If a character is present in the buffer,

 * it is returned, otherwise -1 is returned immediately. usb_init must be

 * called before this function can be used.

 *

 * @param c the received character. This will be set if a character has

 * been received.

 * 

 * @return -1 if no character is available, 0 otherwise, positive for error

 * 

 * @see usb_init, usb_getc

 **/

int usb_getc_nb(char *c) {

  if(!usb_initd)

    return ERROR_LIBRARY_NOT_INITD;

  // check if the receive buffer is filled

  if (UCSR0A & _BV(RXC0)) {

    // Read the receive buffer

    (*c) = UDR0;

    return 0;

  } else {

    // Return empty

    return -1;

  }

}

/**

 * Non blocking version of xbee_getc. If a character is present in the buffer,

 * it is returned, otherwise -1 is returned immediately. xbee_init

 * must be called before this function can be used.

 *

 * @param c the received character. This will be set if a character has

 * been received.

 * 

 * @return -1 if no character is available, 0 otherwise, positive for error

 *

 * @see xbee_init, xbee_getc

 **/

int xbee_getc_nb(char *c) {

  if(!xbee_initd)

    return ERROR_LIBRARY_NOT_INITD;

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

*/

/**

 * Prints an integer, converted to ASCII, to usb. usb_init must be called

 * before this function can be used.

 *

 * @param value the integer to print

 * 

 * @return 0 if successful, nonzero otherwise

 *

 * @see usb_init, usb_putc

 **/

int usb_puti(int value ) {

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

  if(!usb_initd)

    return ERROR_LIBRARY_NOT_INITD;

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

}

/**

 * Determines a hexadecimal digit in ASCII code.

 *

 * @param value the value of the digit (0<=value<=15)

 * 

 * @return the hexadecimal digit in ASCII code, or '?'

 * if the input is invalid.

 **/

uint8_t hex_digit (uint8_t value)

{

    if (value>15) return '?';

    // Postcondition: 0<=x<=15

    return "0123456789ABCDEF"[value];

}

/**

 * Prints a fixed width hexadecimal representation of an unsigned

 * 16 bit integer in ASCII code to USB.

 * usb_init must be called before this function can be used.

 *

 * @param value the value to print

 * 

 * @see usb_init, usb_puti, usb_puts, usb_puth8, hex_digit

 *

 * @return 0 if init succesfull, an error code otherwise

 **/

int usb_puth16 (uint16_t value)

{

    if(!usb_initd)

      return ERROR_LIBRARY_NOT_INITD;

    usb_putc (hex_digit((value >>12)&0xF));

    usb_putc (hex_digit((value >>8 )&0xF));

    usb_putc (hex_digit((value >>4 )&0xF));

    usb_putc (hex_digit( value      &0xF));

    return 0;

}

/**

 * Prints a fixed width hexadecimal representation of an unsigned

 * 8 bit integer in ASCII code to USB.

 * usb_init must be called before this function can be used.

 *

 * @param value the value to print

 * 

 * @see usb_init, usb_puti, usb_puts, usb_puth16, hex_digit

 *

 * @return 0 if init succesfull, an error code otherwise

 **/

int usb_puth8(uint8_t value)

{

    if(!usb_initd)

      return ERROR_LIBRARY_NOT_INITD;

    usb_putc (hex_digit ((value)>>4 &0xF));

    usb_putc (hex_digit ( value     &0xF));

    return 0;

}

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file dragonfly_lib.h

 * @brief Contains other include files

 * 

 * Include this file for all the functionality of libdragonfly.

 *

 * @author Colony Project, CMU Robotics Club

 **/

#ifndef _DRAGONFLY_LIB_H_

#define _DRAGONFLY_LIB_H_

/**

 * @addtogroup dragonfly

 * @{

 **/

/** @brief Initialize the board **/

void dragonfly_init(int config);

/** @} **/ //end addtogroup

#include <inttypes.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

#include <util/twi.h>

// This file is included from the libdragonfly directory because it seems to be

// missing from the AVR libc distribution.

#include "atomic.h"

#include "dragonfly_defs.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 "rangefinder.h"

#include "bom.h"

#include "encoders.h"

#include "move.h"

#include "reset.h"

#include "math.h"

#include "eeprom.h"

#include <stddef.h>

#include <stdbool.h>

#endif

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file serial.h

 * @brief Contains declarations for serial input and output

 *

 * Contains definitions for serial input and output.

 *

 * @author Colony Project, CMU Robotics Club

 * Based on Tom Lauwer's Firefly Library

 *

 **/

/*

  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

  Options: (Add the following defines to your code to configure this library)

  #define USB_BAUD { 115200 | 9600 } <= pick ONE value from in here

  #define XBEE_BAUD { 115200 | 9600 } <= pick ONE value from in here

  #define USE_STDIO

  Note: If you enable USE_STDIO, the first init function that is called will 

  automatically be linked to stdin, stdout, and stderr.  To use the baud rate 

  commands, add something like the following to your code:

  #define FOO_BAUD 9600

  **UNLESS YOU KNOW WHAT YOU ARE DOING, PLEASE DO NOT CHANGE THIS FILE**

  Many, many other people use this file in their code.  If you change it, you will

  probably break all of their nice code.  You should not need to change anything in

  here, except to accomodate new hardware.

*/

#ifndef _SERIAL_H

#define _SERIAL_H

#include <inttypes.h>

#include <avr/pgmspace.h>

/**

 * @defgroup usb USB Input / Output

 * @brief Functions for USB input / output

 *

 * Low level functions for USB input and output.

 *

 * @{

 **/

// if no baud rate is defined for usb, default is set here

#ifndef USB_BAUD

/** @brief the USB baud rate **/

#define USB_BAUD 115200

#endif

/** @brief Initialize the USB **/

int usb_init(void);

/** @brief Print a character to USB **/

int usb_putc(char c);

/** @brief Read a character from USB **/

int usb_getc(void);

/** @brief Read a character from USB without blocking **/

int usb_getc_nb(char *c);

/** @brief Print a string to USB **/

int usb_puts(char *s);

/** @brief Print a string from program space to USB **/

int usb_puts_P (PGM_P s);

/** @brief Print an integer to USB **/

int usb_puti(int value);

/** @brief Determine a hexadecimal digit **/

uint8_t hex_digit (uint8_t value);

/** @brief Print a fixed width hexadecimal representation to USB **/

int usb_puth16 (uint16_t value);

/** @brief Print a fixed width hexadecimal representation to USB **/

int usb_puth8(uint8_t value);

/** @brief Alias for usb_puth16 **/

static inline void usb_puth (uint16_t value) { usb_puth16 (value); };

/** @} **/ //end addtogroup

/**

 * @defgroup xbee XBee Input / Output

 * @brief Functions for XBee input / output

 *

 * Low level functions for XBee input and output.

 *

 * @{

 **/

// if no baud rate is defined for usb, default is set here

// if no baud rate is defined for xbee, default is set here

#ifndef XBEE_BAUD

/** @brief the XBee baud rate **/

#define XBEE_BAUD 9600

#endif

/** @brief Initialize the XBee **/

int xbee_init(void);

/** @brief Print a character to the XBee **/

int xbee_putc(char c);

/** @brief Read a character from the XBee **/

int xbee_getc(void);

/** @brief Read a character from the XBee without blocking **/

int xbee_getc_nb(char *c);

/** @} **/ //end addtogroup

#endif

/**

 * @file spi.c

 * @brief Basic SPI module to handle encoders

 * @author Colony Project, CMU Robotics Club

 *	Need to move spi.h include into dragonfly_lib.h when stable

 **/

#include <avr/interrupt.h>

#include "dragonfly_defs.h"

#include "spi.h"

unsigned char spi_initd=0;

static volatile char spi_bytes; /* number of bytes to read */

static spi_fun_recv_t spi_recv_func; /* byte handler */

static spi_fun_recv_complete_t spi_recv_complete_func; /*transmission completion handler */

/** 

* @brief Initialize SPI hardware for communication.

* 

* @param recv_func The function to be called for each byte of data received.

* @param recv_complete_func  The function to be called at the end of a complete transmission.

*

* @return 0 if init succesfull, an error code otherwise

*/

int spi_init (spi_fun_recv_t recv_func, spi_fun_recv_complete_t recv_complete_func)

{

    if(spi_initd) {

      return ERROR_INIT_ALREADY_INITD;

    }

    /*  Enable Interrupt, Enable SPI Module, MSB First, Master Mode, Clock div = 64 */

    SPCR = _BV(SPE) | _BV(SPIE) /*| _BV(DORD)*/ | _BV(MSTR) | _BV(SPR1) | _BV(SPR0);

    SPSR = _BV(SPI2X); 

    /* Set SCLK, SS, MOSI as outputs. MISO as input */

    DDRB |= MOSI | SCLK | SS;

    DDRB &= ~MISO;

    /* Keep SS high until transmit */

    PORTB |= SS;

    /* set function to be executed when we receive a byte */

    spi_recv_func = recv_func;

    spi_recv_complete_func = recv_complete_func;

    spi_bytes = 0;

    //usb_puts("\tspi.c Debug: SPI INITIALIZED\n");

    spi_initd=1;

    return 0;

}

/** 

* @brief Transfer a given byte to slave and receive a byte 

* 

* @param bytes The number of bytes to be transferred.

**/

int spi_transfer(char bytes)

{

    if(!spi_initd)

      return ERROR_LIBRARY_NOT_INITD;

    spi_bytes = bytes;

    PORTB &= ~SS; /* Set SS low to initiate transmission */

    SPDR = 0xff; /* Initiate data transmision */

    return 0;

}

ISR(SIG_SPI) 

{

	//usb_puts("Interrupt");

    /* only handle intterupt when we are expecting data */

    if(spi_bytes > 0){

	/* process byte */

	spi_recv_func(SPDR);

	/* if we've read all the bytes, set SS high to end transmission,

	 * otherwise get the next byte  */

	if(--spi_bytes == 0){

		//usb_puts("Read all bytes\r\n");

		PORTB |= SS;

		if(spi_recv_complete_func)

			spi_recv_complete_func();

	}else {

		//usb_puts("There are this many bytes left: "); usb_puti(spi_bytes);usb_puts("\r\n");

		SPDR = 0xff;

	}

    }

}		

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file time.c

 * @brief Timer code

 *

 * Implementation of functions for timers.

 *

 * @author Colony Project, CMU Robotics Club

 **/

/*

  time.c

  anything that requires a delay

  mostly delay_ms

  author: Robotics Club, Colony Project

  Change Log:

  2.5.07 - Kevin

  Aaron fixed the orb/servo code and made them use timer3 but compare registers B and C. He hard set the prescaler

  to 8 so the RTC broke. Changed it so that we use a 8 prescaler which sets the compare match at 1/16th of a second.

  You now count how many 16ths of a second you want until you trigger your actual interrupt. Works. Changed defines

  for time so you can still call rtc_init with a scale but now it is defined in terms of actual time like second, quarter_second

  etc. Read that section in the time.h file for more information. Tested and works, though the clock drifts more than

  it used to

  1.30.07 - Kevin

  Modified the clock to run on timer3 on the Dragonfly. Works with decent accuracy. Using a prescaler of 256

  the timer counts up to a precomputer value which will trigger an interrupt and reset the timer. Multiples of

  256 change it by that multiple. Refer to the time.h file for all possible prescalers.

  The interrupt will call a specified function _rtc_func every pulse.

  All of it has been tested and it works.

*/

#include <avr/interrupt.h>

#include <util/delay.h>

#include "dragonfly_defs.h"

#include "time.h"

/* Calculate how many cycles to delay for to get 1 ms. Based on F_CPU which should be defined by the makefile */

#ifdef F_CPU

#define WAIT_CYCLES ((F_CPU / 1000) / 10)

#else

#define WAIT_CYCLES (8000 / 10)

#endif

unsigned char time_initd = 0;

static volatile int _rtc_val = 0;

static volatile int _rtc_pulse = 0;

static volatile int _rtc_scale = 32;	//Defaults to 1 Second per pulse

static void (*_rtc_f)(void) = 0;

/**

 * @defgroup time Time

 * @brief Time functions

 * 

 * Functions dealing with time.

 * 

 * @{

 **/

/**

 * Delays for the specified number of milliseconds.

 * It depends on F_CPU to be defined in order to calculate how many cycles

 * it should delay. If it is not defined, a default clock of 8MHz is assumed.

 * 

 * We use _delay_loop_2 which will run assembly instructions that should be

 * 4 cycles long. Optimizations must be enabled for this to be true.

 * That function is called to ensure around 1ms per execution. To generate

 * multiple ms we run a for loop of how many milliseconds are desired.

 *

 * The error should be just the skew on the oscillator as the formula to 

 * calculate delay cycles should always be a whole number. The is some skew

 * in practice though it is unavoidable. Delaying for less than 1s should make

 * the error negligable.

 *

 * @param ms the number of milliseconds to delay for

 **/

void delay_ms(int ms) {

    for (; ms > 0; ms--) {

        _delay_loop_2(WAIT_CYCLES);

    }

}

/* 	Prescales defined in time.h. SECOND will give you 1 second.

	More scales are defined in the time.h file.

	rtc_func is the address to a function that you want called every clock tick. */

/**

 * Initializes the real time clock. Prescales are defined in time.h.

 * For example, SECOND will give 1 second. The specified function is

 * called every clock tick. For the real time clock to activate,

 * interrupts must be enabled. (through sei() )

 *

 * @param prescale_opt the period with which the timer is triggered

 * @param rtc_func the function called when the timer is triggered

 *

 * @return 0 if init succesfull, an error code otherwise

 *

 * @see rtc_get, rtc_reset

 *

 **/

int rtc_init(int prescale_opt, void (*rtc_func)(void)) {

  if(time_initd) {

    return ERROR_INIT_ALREADY_INITD;

  }

  //Clear timer register for Timer 3

  TCNT3 = 0;

  /* 	This sets the Waveform Generation Module to CTC (Clear Timer on Compare) Mode (100)

	See page135 in Atmega128 Docs for more modes and explanations */

  TCCR3B |= _BV(WGM32);

  /* 	This sets the prescaler for the system clock (8MHz) ie: divides the clock by some number.

	Currently set to a prescaler of 8 because that is what the orb and servos use (they are on this timer as well)

	See page137 in Atemga128 Docs for all the available prescalers */

  TCCR3B |= _BV(CS31);

  /* 	Sets the two regsiters that we compare against. So the timer counts up to this number and

	then resets back to 0 and calls the compare match interrupt.

	8x10^6 / 8 = 1/16 Second. All values are based off of this number. Do not change it unless you

	are l337*/

  OCR3A = 0xF424;	

  /* 	Enable Output Compare A Interrupt. When OCR3A is met by the timer TCNT3 this interrupt will be

	triggerd. (See page140 in Atmega128 Docs for more information */

  ETIMSK |= _BV(OCIE3A);

  /*	Store the pointer to the function to be used in the interrupt */

  _rtc_f = rtc_func;

  /*	Store how many 1/16ths of a second you want to let by before triggering an interrupt */

  _rtc_scale = prescale_opt;

  time_initd = 1;

  return 0;

}

/**

 * Returns the time elapsed in seconds since the last call to

 * rtc_init or rtc_reset.

 *

 * @return the number of seconds since the last call to rtc_init or rtc_reset

 *

 * @see rtc_init, rtc_reset

 **/

int rtc_get(void) {

  return _rtc_val;

}

/**

 * Resets the real time clock counter to 0.

 *

 * @see rtc_init, rtc_get

 **/

void rtc_reset(void) {

  _rtc_val = 0;

}

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

/*	Called every pulse. Function in _rtc_f is called every _rtc_scale and also the counter is updated.

	Bascially, since the pulse is hard set at 1/16s  you want to count how many 16ths of a second have passed

	and when it reaches the amount of time you want, execute the code. */

SIGNAL(TIMER3_COMPA_vect) {

  if (_rtc_pulse ==  _rtc_scale) {

    //Increment the real time clock counter

    _rtc_val++;

    //Calls the function tied to the real time clock if defined

    if(_rtc_f != 0)

      _rtc_f();

    //Resets the pulse until the next scale is matched

    _rtc_pulse = 0;

  }	

  //Updates the amount of pulses seen since the last scale match

  _rtc_pulse++;

}

/**

 * @file spi.h

 * @brief Definitions for SPI

 * @author Colony Project, CMU Robotics Club

 **/

/**

 * @addtogroup spi

 * @{

 **/

#ifndef __SPI_H__

#define __SPI_H__

#define DOUBLE_SCK 1

#define SPR0_BIT 1

#define MASTER 1

#define SLAVE 0

#define MOSI _BV(PB2)

#define MISO _BV(PB3)

#define SS   _BV(PB0)

#define SCLK _BV(PB1)

typedef int (*spi_fun_recv_t)(char);

typedef void (*spi_fun_recv_complete_t)(void);

/** 

* @brief Initialize SPI

* 

* @param spi_fun_recv_t The function that handles SPI data, byte for byte.

* @param spi_fun_recv_complete_t  Called on a completed transmission - typically for cleaning up.

*/

int spi_init (spi_fun_recv_t, spi_fun_recv_complete_t);

/** 

* @brief Initialize SPI transfer.

* 

* @param char The number of bytes to transfer.

*/

int spi_transfer (char);

/**@}**/ //end group

#endif

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file analog.c

 * @brief Analog input and output

 *

 * Contains functions for manipulating the ADC on the Dragonfly board.

 * 

 * @author Colony Project, CMU Robotics Club

 * originally taken from fwr analog file (author: Tom Lauwers)

 * loop code written by Kevin Woo and James Kong

 **/

#include <util/delay.h>

#include <avr/interrupt.h>

#include "dragonfly_defs.h"

#include "serial.h"

#include "analog.h"

// Internal Function Prototypes

void set_adc_mux(int which);

/**

 * @defgroup analog Analog

 * Functions for manipulation the ADC on the dragonfly board.

 * All definitions may be found in analog.h.

 *

 * @{

 **/

unsigned char analog_initd=0;

volatile int adc_loop_status = ADC_LOOP_STOPPED;

volatile int adc_sig_stop_loop = 0;

volatile int adc_current_port = 0;

volatile adc_t an_val[11];

/**

 * Initializes the ADC.

 * Call analog_init before reading from the analog ports.

 *

 * @return returns 0 on success, nonzero on error

 *

 * @see analog8, analog10, analog_get8, analog_get10

 *

 * @bug First conversion takes a performance penalty of

 * 25 vs. 13 ADC clock cycles of successive conversions.

 * Analog_init should run a dummy conversion to pre-empt

 * this.

 *

 * For good 10-bit precision, ACD clock must be between

 * 50kHz and 200kHz. Currently, ADC clock is fixed at

 * 125kHz using 1/64prescalar. However, most code uses

 * 8-bit precision which can work at ADC clock speeds

 * higher than 200kHz. Experimental tests needed to

 * determine highest clock speed for accurate 8-bit ADC.

 *

 **/

int analog_init(int start_conversion) {

  if(analog_initd)

    return ERROR_INIT_ALREADY_INITD;

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

    an_val[i].adc10 = 0;

    an_val[i].adc8 = 0;

  }

  // ADMUX register

  // Bit 7,6 - Set voltage reference to AVcc (0b01)

  // Bit 5 - ADLAR set to simplify moving from register

  // Bit 4 - X

  // Bit 3:0 - Sets the current channel

  // Initializes to read from AN1 first (AN0 is reservered for the BOM)

  ADMUX = 0;

  ADMUX |= ADMUX_OPT | _BV(MUX0);

  // ADC Status Register A

  // Bit 7 - ADEN is set (enables analog)

  // Bit 6 - Start conversion bit is set (must be done once for free-running mode)

  // Bit 5 - Enable Auto Trigger (for free running mode) NOT DOING THIS RIGHT NOW

  // Bit 4 - ADC interrupt flag, 0

  // Bit 3 - Enable ADC Interrupt (required to run free-running mode)

  // Bits 2-0 - Set to create a clock divisor of 128, to make ADC clock = 8,000,000/64 = 125kHz

  ADCSRA = 0;

  ADCSRA |= _BV(ADEN) | _BV(ADPS2) | _BV(ADPS1) | _BV(ADPS0);

  // Set external mux lines to outputs

  DDRG |= 0x1C;

  // Set up first port for conversions

  set_adc_mux(0x00);

  adc_current_port = AN1;

  //Start the conversion loop if requested

  if (start_conversion)

    analog_start_loop();

  //Conversion loop disabled by default

  analog_initd=1;

  return 0;

}	

/**

 * Returns the 8-bit analog conversion of which from

 * the lookup table. If the requested port is the BOM_PORT

 * you will get an automatic 0 since the BOM_PORT is not

 * read in the loop and not stored. If you need that port

 * you should use the functions in bom.c. There is an analog_get8

 * function which for instant lookups but should be avoided unless

 * you know what you're doing.

 *

 * @param which the port that you want to read

 *

 * @bug may cause a seg fault if which is a larger value

 * than exists in an_val table. Not sure if we should fix

 * this or not since it would add overhead.

 *

 * @return 8-bit analog value for the which port requested

 *

 * @see analog10, analog_get8, analog_get10

 **/

unsigned int analog8(int which) {

	if (which == BOM_PORT) {

		return 0;

	} else {

		return an_val[which - 1].adc8;

	}

}

/**

 * Returns the 10-bit analog conversion of which from

 * the lookup table. If the requested port is the BOM_PORT

 * you will get an automatic 0 since the BOM_PORT is not

 * read in the loop and not stored. If you need that port

 * you should use the functions in bom.c. There is an analog_get10

 * function which for instant lookups but should be avoided unless

 * you know what you are doing.

 *

 * @param which the port that you want to read

 *

 * @bug may cause a seg fault if which is a larger value