Colony

 **/

int motors_init( void ) {

    return ERROR_INIT_ALREADY_INITD;

  // Configure counter such that we use phase correct

 * @see motor_r_set, motors_init

 **/

int motor_l_set(int direction, int speed) {

    return ERROR_LIBRARY_NOT_INITD;

  if(direction == 0) {

    // turn off PWM first if switching directions

 * @see motor_l_set, motors_init

 **/

int motor_r_set(int direction, int speed) {

    return ERROR_LIBRARY_NOT_INITD;

  if(direction == 0) {

    //		PORTD |= 0x20;

 * @see motors_init

 **/

int motors_off( void ) {

    return ERROR_LIBRARY_NOT_INITD;

  OCR1AL = 0x0;

  OCR1BL = 0x0;

{

  int ret = 0;

    sei();

    // Set directionality of various IO pins

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

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

    if(config & ANALOG) {

    }

    if(config & COMM)

    {

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

    }

    if(config & BUZZER)

    {

    }

    if(config & ORB)

    {

    }

    if(config & BOM)

    {

        unsigned char bom_read = get_bom_type();

        if(bom_read == 0xFF) {

        }

            return ERROR_INIT_FAILED;

    }

    if (config & ENCODERS)

    {

    }

    // delay a bit for stability

    _delay_ms(1);

 **/

int i2c_init(char addr, fun_mrecv_t master_recv, fun_srecv_t slave_recv, fun_send_t slave_send) {

      return ERROR_INIT_ALREADY_INITD;

    master_recv_function = master_recv;

int i2c_send(char dest, char *data, unsigned int bytes) {

    int i;

      return ERROR_LIBRARY_NOT_INITD;

    /* adding data to be sent to ring buffers is not atomic,

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

        if(RING_BUFFER_FULL(i2c_write_buff)) {

            sei();

            return -1;

        }

 * @return 0 for success, nonzero for failure

 **/ 

int i2c_request(char dest) {

    if(RING_BUFFER_FULL(i2c_write_buff))

        return -1;

int xbee_init() {

  if(xbee_initd) {

    return ERROR_INIT_ALREADY_INITD;

  }

 **/

int xbee_putc(char c) {

    return ERROR_LIBRARY_NOT_INITD;

  // Wait until buffer is clear for sending

  loop_until_bit_is_set(UCSR1A, UDRE1);

int usb_puts(char *s) {

  char *t = s;

    return ERROR_LIBRARY_NOT_INITD;

  while (*t != 0) {

    usb_putc(*t);

int usb_puts_P (PGM_P s) {

    char buf;

      return ERROR_LIBRARY_NOT_INITD;

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

        usb_putc (buf);

 **/

int xbee_getc(void) {

    return -1;

  // Wait for the receive buffer to be filled

  loop_until_bit_is_set(UCSR1A, RXC1);

 * @see xbee_init, xbee_getc

 **/

int xbee_getc_nb(char *c) {

    return ERROR_LIBRARY_NOT_INITD;

  // check if the receive buffer is filled

  if (UCSR1A & _BV(RXC1)) {

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;

    }

**/

int spi_transfer(char bytes)

{

    spi_bytes = bytes;

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

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

  if(time_initd) {

    return ERROR_INIT_ALREADY_INITD;

  }

 * @see rtc_init, rtc_reset

 **/

int rtc_get(void) {

  return _rtc_val;

}

 *

 **/

int analog_init(int start_conversion) {

    return ERROR_INIT_ALREADY_INITD;

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

    an_val[i].adc10 = 0;

 * @see analog_stop_loop, analog_loop_status

 **/

int analog_start_loop(void) {

    return ERROR_LIBRARY_NOT_INITD;

  if(adc_loop_status != ADC_LOOP_RUNNING){

    //Start the conversion, enable ADC interrupt

 * @see analog_start_loop, analog_loop_status

 **/

int analog_stop_loop() {

    return ERROR_LIBRARY_NOT_INITD;

  //Signal to stop after the next conversion

  adc_sig_stop_loop = 1;

int encoders_init(void){

  int i;

    return ERROR_INIT_ALREADY_INITD;

  data_ready=0;

    return -1; //if spi was inited for something else, bail out

  encoder_buf_index = 0;

  left_data_buf = 0;

  right_data_buf= 0;

 *         the encoder.

 **/

int encoder_read(char encoder){

    return -2;

  if(encoder==LEFT) {

    return left_data;

 **/

int encoder_rst_dx(char encoder) {

    return ERROR_LIBRARY_NOT_INITD;

  if(encoder==LEFT)

    left_dx = 0;

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

*/

int encoder_rst_tc(void) {

    return ERROR_LIBRARY_NOT_INITD;

  timecount = 0;

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

*/

int encoder_wait(int n){

    return ERROR_LIBRARY_NOT_INITD;

  while(data_ready<n);

  data_ready=0;

int encoder_recv(char data){

  short int dx;

    return ERROR_LIBRARY_NOT_INITD;

  //Parse the encoder data, comes in over 5 bytes 16 bits per encoder,

  // second is offset by 1 bit.

#include "serial.h"

#include "analog.h"

//On the original BOM1.0, the emmitter angular order does not match the analog mux order

//so you need to iterate through the mux index in the following order if you want to get

//the detector readings in order:

 **/

int bom_init(char type) {

    bom_type = type;

    case RBOM:

        break;

    default:

      return -1;        

    //default:

    }

    int i;

    int loop_was_running = 0;

      return ERROR_LIBRARY_NOT_INITD;

    //Check analog loop status

 * see bom_refresh

 **/

int bom_get(int which) {

    return bom_val[which];

}

int bom_get_max(void) {

    int i, lowest_val, lowest_i;

      return -2;

    lowest_i = -1;

    lowest_val = 255;

    if(lowest_val < BOM_VALUE_THRESHOLD)

        return lowest_i;

        return -1;

}

/** 

    int i, max;

    long long mean = 0, sum = 0;

      return ERROR_LIBRARY_NOT_INITD;

    max = bom_get_max();

        {

            *dist = -1;

        }

        return -1;

    }

    /* Record values into an array */

    int i;

    unsigned int mask = 1<<(NUM_BOM_LEDS-1);

      return ERROR_LIBRARY_NOT_INITD;

    switch(bom_type) {

    case BOM10:

 **/

int bom_on(void)

{

    return ERROR_LIBRARY_NOT_INITD;

  switch(bom_type) {

  case BOM10:

  case RBOM:

	break;

  default:

    return -1;

  }

 **/

int bom_off(void)

{

    return ERROR_LIBRARY_NOT_INITD;

  switch(bom_type) {

  case BOM10:

 * and Status Register (MCUCSR).

 **/

void reset(void) {

  WDTCR &= 0xF8;

  WDTCR |= 0x08;

  _delay_ms(15);

 **/

int range_init(void)

{

    return ERROR_INIT_ALREADY_INITD;

  digital_output(_PIN_B4,0);

 * @see range_init

 **/

int range_read_distance(int range_id) {

    return -3;

  return linearize_distance(analog8(range_id));

}

#ifdef DRAGONFLY_DEBUG

#define DRAGONFLY_DEBUG_PRINT_INT(i) usb_puti(i)

#else

#define DRAGONFLY_DEBUG_PRINT(s)

#define DRAGONFLY_DEBUG_PRINT_INT(i)

#endif

#endif