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 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 = 1;	//Defaults to 1/32 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++;

}

/**

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

  if(usb_initd) {

    return ERROR_INIT_ALREADY_INITD;

  }

  //Set baud rate

#if (USB_BAUD == 250000)

  UBRR0H = 0x00;

  UBRR0L = 3;

  UCSR0A |= _BV(U2X0);

#elif (USB_BAUD == 115200)

  UBRR0H = 0x00;

  UBRR0L = 8;

  UCSR0A |= _BV(U2X0);

#elif (USB_BAUD == 57600)

  UBRR0H = 0x00;

  UBRR0L = 16;

  UCSR0A |= _BV(U2X0);

#elif (USB_BAUD == 28800)

  UBRR0H = 0x00;

  UBRR0L = 34;

  UCSR0A |= _BV(U2X0);

#elif (USB_BAUD == 14400)

  UBRR0H = 0x00;

  UBRR0L = 68;

  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 default baud rate to 9600

  UBRR1H = 0x00;

  UBRR1L = 103;

  UCSR1A |= _BV(U2X1);

  //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 dio.h

 * @brief Definitions for digital input / output

 *

 * This file contains definitions and functions for dealing

 * with digital input and output.

 *

 * @author Colony Project, CMU Robotics Club

 * Based on Tom Lauwer's Firefly Library

 **/

#ifndef _DIO_H

#define _DIO_H

/*

  these are ALL the pins

  don't use unless you know what you're doing

*/

/*

  DIO pins on new dragonfly boards are shown below:

  -----------------------------------------------

  | _PIN_E6 | _PIN_E7 | _PIN_D2 | _PIN_D3 | VCC |

  -----------------------------------------------

  | _PIN_E2 | _PIN_E3 | _PIN_E4 | _PIN_E5 | GND |

  -----------------------------------------------

*/

/** @brief Port A **/

#define _PORT_A 1

/** @brief Port B **/

#define _PORT_B 2

/** @brief Port C **/

#define _PORT_C 3

/** @brief Port D **/

#define _PORT_D 4

/** @brief Port E **/

#define _PORT_E 5

/** @brief Port F **/

#define _PORT_F 6

/** @brief Port G **/

#define _PORT_G 7

/** @brief Pin A0 **/

#define _PIN_A0 8

/** @brief Pin A1 **/

#define _PIN_A1 9

/** @brief Pin A2 **/

#define _PIN_A2 10

/** @brief Pin A3 **/

#define _PIN_A3 11

/** @brief Pin A4 **/

#define _PIN_A4 12

/** @brief Pin A5 **/

#define _PIN_A5 13

/** @brief Pin A6 **/

#define _PIN_A6 14 

/** @brief Pin A7 **/

#define _PIN_A7 15

/** @brief Pin B0 **/

#define _PIN_B0 16

/** @brief Pin B1 **/

#define _PIN_B1 17

/** @brief Pin B2 **/

#define _PIN_B2 18

/** @brief Pin B3 **/

#define _PIN_B3 19

/** @brief Pin B4 **/

#define _PIN_B4 20

/** @brief Pin B5 **/

#define _PIN_B5 21

/** @brief Pin B6 **/

#define _PIN_B6 22

/** @brief Pin B7 **/

#define _PIN_B7 23

/** @brief Pin C0 **/

#define _PIN_C0 24

/** @brief Pin C1 **/

#define _PIN_C1 25

/** @brief Pin C2 **/

#define _PIN_C2 26

/** @brief Pin C3 **/

#define _PIN_C3 27

/** @brief Pin C4 **/

#define _PIN_C4 28

/** @brief Pin C5 **/

#define _PIN_C5 29

/** @brief Pin C6 **/

#define _PIN_C6 30

/** @brief Pin C7 **/

#define _PIN_C7 31

/** @brief Pin D0 **/

#define _PIN_D0 32  // pin DIO6 on new dragonfly boards

/** @brief Pin D1 **/

#define _PIN_D1 33  // pin DIO7

/** @brief Pin D2 **/

#define _PIN_D2 34

/** @brief Pin D3 **/

#define _PIN_D3 35

/** @brief Pin D4 **/

#define _PIN_D4 36

/** @brief Pin D5 **/

#define _PIN_D5 37

/** @brief Pin D6 **/

#define _PIN_D6 38

/** @brief Pin D7 **/

#define _PIN_D7 39

/** @brief Pin E0 **/

#define _PIN_E0 40

/** @brief Pin E1 **/

#define _PIN_E1 41

/** @brief Pin E2 **/

#define _PIN_E2 42  // pin DIO0

/** @brief Pin E3 **/

#define _PIN_E3 43  // pin DIO1

/** @brief Pin E4 **/

#define _PIN_E4 44  // pin DIO2

/** @brief Pin E5 **/

#define _PIN_E5 45  // pin DIO3

/** @brief Pin E6 **/

#define _PIN_E6 46  // pin DIO4

/** @brief Pin E7 **/

#define _PIN_E7 47  // pin DIO5

/** @brief Pin F0 **/

#define _PIN_F0 48

/** @brief Pin F1 **/

#define _PIN_F1 49

/** @brief Pin F2 **/

#define _PIN_F2 50

/** @brief Pin F3 **/

#define _PIN_F3 51

/** @brief Pin F4 **/

#define _PIN_F4 52

/** @brief Pin F5 **/

#define _PIN_F5 53

/** @brief Pin F6 **/

#define _PIN_F6 54

/** @brief Pin F7 **/

#define _PIN_F7 55

/** @brief Pin G0 **/

#define _PIN_G0 56

/** @brief Pin WR **/

#define _PIN_WR 56

/** @brief Pin G1 **/

#define _PIN_G1 57

/** @brief Pin RD **/

#define _PIN_RD 57

/** @brief Pin G2 **/

#define _PIN_G2 58

/** @brief Pin ALE **/

#define _PIN_ALE 58

/** @brief Pin G3 **/

#define _PIN_G3 59

/** @brief Pin TOSC2 **/

#define _PIN_TOSC2 59

/** @brief Pin G4 **/

#define _PIN_G4 60

/** @brief Pin TOSC1 **/

#define _PIN_TOSC1 60

//#define _PIN_G5 61

//#define _PIN_G6 62

//#define _PIN_G7 63

/*

  These are the header pins (the ones you can connect things to)

  Feel free to use these

*/

/**

 * @addtogroup dio

 * @{

 **/

/** @brief Pin A0 **/

#define PIN_A0 8

/** @brief Pin A1 **/

#define PIN_A1 9

/** @brief Pin A2 **/

#define PIN_A2 10

/** @brief Pin A3 **/

#define PIN_A3 11

/** @brief Pin A4 **/

#define PIN_A4 12

/** @brief Pin A5 **/

#define PIN_A5 13

/** @brief Pin A6 **/

#define PIN_A6 14 

/** @brief Pin A7 **/

#define PIN_A7 15

/** @brief Pin SS **/

#define PIN_SS 16

/** @brief Pin SCK **/

#define PIN_SCK 17

/** @brief Pin MOSI **/

#define PIN_MOSI 18

/** @brief Pin MISO **/

#define PIN_MISO 19

/** @brief LCD Command Pin **/

#define PIN_LCD_COMMAND 20

/** @brief Pin C0 **/

#define PIN_C0 24

/** @brief Pin C1 **/

#define PIN_C1 25

/** @brief Pin C2 **/

#define PIN_C2 26

/** @brief Pin C3 **/

#define PIN_C3 27

/** @brief Pin C4 **/

#define PIN_C4 28

/** @brief Pin C5 **/

#define PIN_C5 29

/** @brief Pin C6 **/

#define PIN_C6 30

/** @brief Pin C7 **/

#define PIN_C7 31

/** @brief Pin SCL **/

#define PIN_SCL 32

/** @brief Pin SDA **/

#define PIN_SDA 33

/** @brief Pin RX0 **/

#define PIN_RX0 40

/** @brief Pin TX0 **/

#define PIN_TX0 41

/** @brief LCD Reset Pin **/

#define PIN_LCD_RESET 42

/** @brief Pin E6 **/

#define PIN_E6 46

/** @brief Pin EXT_DIO1 **/

#define PIN_EXT_DIO1 46

/** @brief Pin E7 **/

#define PIN_E7 47

/** @brief Pin EXT_DIO2 **/

#define PIN_EXT_DIO2 48

/** @brief Pin AN0 **/

#define PIN_AN0 48

/** @brief Pin ADC0 **/

#define PIN_ADC0 48

/** @brief Pin AN1 **/

#define PIN_AN1 49

/** @brief Pin ADC1 **/

#define PIN_ADC1 49

/** @brief Pin AN2 **/

#define PIN_AN2 50

/** @brief Pin ADC2 **/

#define PIN_ADC2 50

/** @brief Pin AN3 **/

#define PIN_AN3 51

/** @brief Pin ADC3 **/

#define PIN_ADC3 51

/** @brief Pin AN4 **/

#define PIN_AN4 52

/** @brief Pin ADC4 **/

#define PIN_ADC4 52

/** @brief Pin AN5 **/

#define PIN_AN5 53

/** @brief Pin ADC5 **/

#define PIN_ADC5 53

/** @brief Pin AN6 **/

#define PIN_AN6 54

/** @brief Pin ADC6 **/

#define PIN_ADC6 54

/** @brief Pin AN7 **/

#define PIN_AN7 55

/** @brief Pin ADC7 **/

#define PIN_ADC7 55

/** @brief Wheel Pin **/

#define PIN_WHEEL 54

/** @brief Battery Voltage Monitor Pin **/

#define PIN_BATT 55

/** @brief button1 Pin **/

#define PIN_BTN1 56

/** @brief button2 Pin **/

#define PIN_BTN2 57

/** @brief LED1 Pin **/

#define PIN_LED1 58

/* Buttons */

/** @brief Button Pin **/

#define PIN_BTN PING

/** @brief button2 Pin **/

#define BTN2 PING1

/** @brief button1 Pin **/

#define BTN1 PING0

/** @brief Read a portpin. **/

int digital_input(int);

/** @brief Output to a portpin. **/

void digital_output(int bit, int val);

/** @brief Pullup a portpin. **/

void digital_pull_up(int);

/** @brief Check if button1 is pressed. **/

int button1_read( void );

/** @brief Check if button1 is clicked. **/

int button1_click( void );

/** @brief Wait until button1 is pressed. **/

void button1_wait( void );

/** @brief Check if button2 is pressed. **/

int button2_read( void );

/** @brief Check if button2 is clicked. **/

int button2_click( void );

/** @brief Wait until button2 is pressed. **/

void button2_wait( 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 time.h

 * @brief Contains time-related functions and definitions

 *

 * Contains functions and definitions for dealing with time,

 * namely delay_ms and the realtime clock.

 *

 * @author Colony Project, CMU Robotics Club

 **/

#ifndef _TIME_H_

#define _TIME_H_

/*	Predefined times for prescale_opt in time.c.

	To make you own, know that a pulse is 1/16th of a second. You cannot get less than this. To get more, you need

	to know how many 16ths of a second are in the time you want. (Time_desired * 16 = prescaler_opt)

*/

/**

 * @addtogroup time

 * @{

 **/

/** @brief A sixteenth of a second **/

#define SIXTEENTH_SECOND 1

/** @brief An eighth of a second **/

#define EIGTH_SECOND 2

/** @brief A quarter of a second **/

#define QUARTER_SECOND 4

/** @brief Half of a second **/

#define HALF_SECOND	8

/** @brief One second **/

#define SECOND 16

/** @brief Two seconds **/

#define TWO_SECOND 32

/** @brief Four seconds **/

#define FOUR_SECOND 64

/** @brief Delay execution for the specified time **/

void delay_ms(int ms) ;

/** @brief Enable the realtime clock **/

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

/** @brief Reset the counter of the realtime clock **/

void rtc_reset(void);

/** @brief Get the value of the realtime clock. **/

int rtc_get(void);

/** @} **/

#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 xbee.c

 * @brief XBee Interface

 *

 * Implementation of low level communication with the XBee in API mode.

 *

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

 **/

#include "xbee.h"

#include "wl_defs.h"

#include "time.h"

//#define ROBOT

//#define WL_DEBUG

//#define WL_DEBUG_PRINT( s ) usb_puts( s )

//#define WL_DEBUG_PRINT_INT( i ) usb_puti(i)

#ifndef ROBOT

#include <fcntl.h>

#include <unistd.h>

#include <pthread.h>

#include <errno.h>

#include <termios.h>

#else

#include "serial.h" ////////////////////////

#include <avr/interrupt.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define XBEE_FRAME_START 0x7E

#define XBEE_GET_PACKET_TIMEOUT 1000

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

static int xbee_send(char* buf, int size);

static int xbee_send_string(char* c);

#ifndef ROBOT

static int xbee_read(char* buf, int size);

#endif

/*Command Mode Functions

 * Called during initialization.

 */

static int xbee_enter_command_mode(void);

static int xbee_exit_command_mode(void);

static int xbee_enter_api_mode(void);

static int xbee_exit_api_mode(void);

static int xbee_wait_for_string(char* s, int len);

static int xbee_wait_for_ok(void);

/*API Mode Functions*/

static int xbee_handle_packet(char* packet, int len);

static int xbee_handle_at_command_response(char* command, char result, char* extra, int extraLen);

static void xbee_handle_status(char status);

static int xbee_verify_checksum(char* packet, int len);

static char xbee_compute_checksum(char* packet, int len);

static int xbee_send_frame(char* buf, int len);

int xbee_send_read_at_command(char* command);

static int xbee_send_modify_at_command(char* command, char* value);

/*Global Variables*/

#ifndef ROBOT

static char* xbee_com_port = XBEE_PORT_DEFAULT;

static int xbee_stream;

static pthread_t* xbee_listen_thread;

#endif

// TODO: is this a good size?

#define XBEE_BUFFER_SIZE	128

#define PACKET_BUFFER_SIZE	108

// a buffer for data received from the XBee

char arrival_buf[XBEE_BUFFER_SIZE];

// location of last unread byte in buffer

volatile int buffer_last = 0;

// first unread byte in buffer

volatile int buffer_first = 0;

//used to store packets as they are read

static char xbee_buf[PACKET_BUFFER_SIZE];

static int currentBufPos = 0;

//XBee status

static unsigned int xbee_panID = XBEE_PAN_DEFAULT;

static unsigned int xbee_pending_panID = XBEE_PAN_DEFAULT;

static int xbee_channel = XBEE_CHANNEL_DEFAULT;

static int xbee_pending_channel = XBEE_CHANNEL_DEFAULT;

static volatile unsigned int xbee_address = 0;

/*Function Implementations*/

#ifdef ROBOT

/**

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

 * to the buffer.

 **/

#ifndef FIREFLY

ISR(USART1_RX_vect)

{

	char c = UDR1;

	arrival_buf[buffer_last] = c;

	int t = buffer_last + 1;

	if (t == XBEE_BUFFER_SIZE)

		t = 0;

	if (t == buffer_first)

	{

		WL_DEBUG_PRINT("\nOut of space in buffer.\n");

	}

	buffer_last = t;

}

#else

SIGNAL(SIG_USART0_RECV)

{

	char c = UDR0;

	arrival_buf[buffer_last] = c;

	int t = buffer_last + 1;

	if (t == XBEE_BUFFER_SIZE)

		t = 0;

	if (t == buffer_first)

	{

		WL_DEBUG_PRINT("Out of space in buffer.\n");

	}

	buffer_last = t;

}

#endif

#else

// Computer code

/**

 * Thread that listens to the xbee.

 **/

static void* listen_to_xbee(void* x)

{

	char c;

	while (1)

	{

		if (xbee_read(&c, 1) != 0) {

			WL_DEBUG_PRINT("xbee_read failed.\n");

			return NULL;

		}

		arrival_buf[buffer_last] = c;

		int t = buffer_last + 1;

		if (t == XBEE_BUFFER_SIZE)

			t = 0;

		if (t == buffer_first)

		{

			WL_DEBUG_PRINT("Out of space in buffer.\n");

		}

		buffer_last = t;

		usleep(1000);

	}

	return NULL;

}

#endif

/**

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

 **/

int xbee_lib_init()

{

  if (xbee_init() != 0) {

    usb_puts("xbee_init error");

    return -1;

  }

	WL_DEBUG_PRINT("in xbee_init\n");

#ifdef ROBOT

	//enable the receiving interrupt

#ifdef FIREFLY

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

#else

#ifdef BAYBOARD

	UCSR1B |= _BV(RXCIE1);

#else

	UCSR1B |= _BV(RXCIE);

#endif

#endif

	sei();

#else

	xbee_stream = open(xbee_com_port, O_RDWR);

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

	{

		WL_DEBUG_PRINT("Failed to open connection to XBee on port ");

		WL_DEBUG_PRINT_INT(xbee_com_port);

		WL_DEBUG_PRINT(".\n");

		return -1;

	} else {

	  WL_DEBUG_PRINT("Successfully opened connection to XBee on port ");

		WL_DEBUG_PRINT_INT(xbee_com_port);

		WL_DEBUG_PRINT(".\n");

	}

	// set baud rate, etc. correctly

	struct termios options;

	tcgetattr(xbee_stream, &options);

	cfsetispeed(&options, B9600);

	cfsetospeed(&options, B9600);

	options.c_iflag &= ~ICRNL;

	options.c_oflag &= ~OCRNL;

	options.c_cflag |= (CLOCAL | CREAD);

	options.c_cflag &= ~PARENB;

	options.c_cflag &= ~CSTOPB;

	options.c_cflag &= ~CSIZE;

	options.c_cflag |= CS8;

	options.c_lflag &= ~ICANON;

	options.c_cc[VMIN] = 1;

	options.c_cc[VTIME] = 50;

	if (tcsetattr(xbee_stream, TCSANOW, &options))

	{

		WL_DEBUG_PRINT("Error setting attributes.\n");

		return -1;

	}

	xbee_listen_thread = (pthread_t*)malloc(sizeof(pthread_t));

	if (xbee_listen_thread == NULL)

	{

		WL_DEBUG_PRINT("Malloc failed.\n");

		return -1;

	}

	int ret = pthread_create(xbee_listen_thread, NULL, listen_to_xbee, NULL);

	if (ret)

	{

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

		return -1;

	}

#endif

	WL_DEBUG_PRINT("Entering command mode.\r\n");

	if (xbee_enter_command_mode() != 0) {

    usb_puts("error entering command mode\r\n");

		return -1;

	}

	WL_DEBUG_PRINT("Entered command mode.\r\n");

  // reset baud rate

  usb_puts("Resetting Baud to ");

  usb_puts(XBEE_BAUD_STR);

  usb_puts("\r\n");

  // set baud on xbee

#if (XBEE_BAUD == 115200)

  xbee_send_string("ATBD7\r");

#end if  

  // exit command mode

  xbee_wait_for_ok();

  xbee_send_string("ATCN\r");

  xbee_wait_for_ok();

  // set UART baud

#if (XBEE_BAUD == 250000)

  UBRR1H = 0x00;

  UBRR1L = 3;

  UCSR1A |= _BV(U2X1);

#elif (XBEE_BAUD == 115200)

  UBRR1H = 0x00;

  UBRR1L = 8;

  UCSR1A |= _BV(U2X1);

#elif (XBEE_BAUD == 57600)

  if (xbee_send_modify_at_command("BD","6")) {

		return -1;

	}

  UBRR1H = 0x00;

  UBRR1L = 16;

  UCSR1A |= _BV(U2X1);

#elif (XBEE_BAUD == 38400)

  if (xbee_send_modify_at_command("BD","5")) {

		return -1;

	}

  UBRR1H = 0x00;

  UBRR1L = 25;

  UCSR1A |= _BV(U2X1);

#elif (XBEE_BAUD == 19200)

  if (xbee_send_modify_at_command("BD","4")) {

		return -1;

	}

  UBRR1H = 0x00;

  UBRR1L = 51;

  UCSR1A |= _BV(U2X1);

#elif (XBEE_BAUD == 9600)

  /* this is the default baud rate, so do nothing

  if (xbee_send_modify_at_command("BD","3")) {

		return -1;

	}

  UBRR1H = 0x00;

  UBRR1L = 103;

  UCSR1A |= _BV(U2X1);*/

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

  return 0;

#endif

  // enter command mode

  if (xbee_enter_command_mode() != 0) {

    usb_puts("error entering command mode after baud set\r\n");

		return -1;

	}

  if (xbee_enter_api_mode() != 0) {

    usb_puts("can't enter api mode\r\n");

		return -1;

	}

	WL_DEBUG_PRINT("Entered api mode.\r\n");

	if (xbee_exit_command_mode() != 0) {

    usb_puts("can't exit command mode\r\n");

	  return -1;

	}

	WL_DEBUG_PRINT("Left command mode.\r\n");

  // get MY address

	if (xbee_send_read_at_command("BD")) {

    usb_puts("can't send BD command\r\n");

		return -1;

	}

	WL_DEBUG_PRINT("Getting ATBD rate.\n");

  // get MY address

	if (xbee_send_read_at_command("MY")) {

    usb_puts("can't send my command\r\n");

		return -1;

	}

	WL_DEBUG_PRINT("Getting ATMY address.\n");

#ifndef ROBOT

	int i;

	for (i = 0; xbee_address == 0 && i < XBEE_GET_PACKET_TIMEOUT; i++) {

	  ret = xbee_get_packet(NULL);

	  usleep(1000);

/* 	  if (ret == -1) { */

/* 	    WL_DEBUG_PRINT("xbee_get_packet(NULL) failed.\n"); */

/* 	    return -1; */

/* 	  } */

	}

#else

	//wait to return until the address is set

  //TODO: this shouldn't wait indefinitely.  There should be some sort of reasonable timeout

  // so if the address is never set right, an error can be returned instead of having the

  // robot hang forever

	while (xbee_address == 0) {