Colony

/*

Wireless

Eugene Marinelli

(See .h for details)

*/

/* Includes */

#include <firefly+_lib.h>

#include <string.h>

#include <avr/interrupt.h>

#include "wireless.h"

/* Constants */

#define PREFIX0 'R'

#define PREFIX1 'C'

//wl_buf positions

#define WL_SRC_LOC 2

#define WL_DEST_LOC 3

#define WL_DATA_START 4

#define WL_TIMEOUT 4

#define WL_TIMEOUT_INITIAL 4

/* Globals */

static WL_Packet latest_packet;

static WL_Packet tmp_packet;

static char new_message; //set to 1 if there is a new message, else 0

static char listener_addr; //address that the robot is listening on

static int message_length; //length of the messages sent/received

//static unsigned char wl_to_flag;

//static unsigned int wl_to_count;

//static unsigned int wl_to_max;

/* Internal function headers */

static void wl_timeout_handler(void);

/* External function definitions */

int wl_init(int msg_len, char listener_address){

  if(msg_len > WL_MSG_MAX_LEN){

    printf("Error: %s: message length must be less than %d\n", __FUNCTION__, 

           WL_MSG_MAX_LEN);

    return -1;

  }

  message_length = msg_len;

  listener_addr = listener_address;

  rtc_init(PRESCALE_DIV_128, 64, &wl_timeout_handler); 

  /* executes the function about every 1/4 sec */

  //wl_to_flag = 0;

  //wl_to_count = 0; 

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

  sei();

  new_message = 0;

  memset(&latest_packet, 0, sizeof(WL_Packet));

  return 0;

}

int wl_send(char* msg, char dest){

  int i = 0;

  WL_Packet packet;

  if(strlen(msg) > WL_MSG_MAX_LEN){

    printf("Error: %s: message is too long\n", __FUNCTION__);

    return -1;

  }

  wl_create_packet(msg, listener_addr, dest, &packet);

  serial_putchar(packet.prefix[0]);

  serial_putchar(packet.prefix[1]);

  serial_putchar(packet.src);

  serial_putchar(packet.dest);

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

    serial_putchar(packet.msg[i]);

  }

  serial_putchar(packet.checksum);

  return 0;

}

int wl_recv(char* msgbuf, char* src, char* dest){

  if(!new_message){

    return 0; //no new message

  }

  strcpy(msgbuf, latest_packet.msg);

  *src = latest_packet.src;

  *dest = latest_packet.dest;

  new_message = 0;

  return strlen(msgbuf);

}

char wl_get_checksum(WL_Packet* packet){

  char checksum = 0;

  int i;

  checksum += packet->src;

  checksum += packet->dest;

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

    checksum += packet->msg[i];

  }

  return checksum;

}

int wl_create_packet(char* msg, char src, char dest, WL_Packet* packet){

  packet->prefix[0] = 'R';

  packet->prefix[1] = 'C';

  packet->src = src;

  packet->dest = dest;

  memset(packet->msg, 0, message_length);

  strcpy(packet->msg, msg);

  packet->checksum = wl_get_checksum(packet);

  return 0;

}

/* Internal function definitions */

//use on new avr-libc

//ISR(USART0_RX_vect)

SIGNAL(SIG_USART0_RECV){

  char wl_input = UDR0;

  static unsigned int wl_index = 0;

  static unsigned char wl_chksum = 0;

  if(wl_index == 0){

    //first packet? - check chksum to make sure we're not beginning

    if(wl_input == PREFIX0) {

      wl_to_count = 0; //at this point we're not timing out

      wl_index = 1;

    }

  }else if(wl_index == 1){

    if(wl_input != PREFIX1){

      wl_index = 0;

    }else{

      wl_index = WL_SRC_LOC;

    }

  }else if(wl_index == WL_SRC_LOC){

    tmp_packet.src = wl_input;

    wl_index = WL_DEST_LOC;

  }else if(wl_index == WL_DEST_LOC){

    tmp_packet.dest = wl_input;

    wl_index = WL_DATA_START;

  }else if(wl_index < WL_DATA_START + message_length){

    //getting the rest of the packet

    tmp_packet.msg[wl_index-WL_DATA_START] = wl_input;

    wl_index++;

  }else if(wl_index == WL_DATA_START + message_length){

    //we are at checksum location

    tmp_packet.checksum = wl_input;

    wl_chksum = wl_get_checksum(&tmp_packet);

    if(tmp_packet.checksum == wl_chksum) {

      //checksum is correct

      memcpy(&latest_packet, &tmp_packet, sizeof(WL_Packet));

      new_message = 1;

    } else { //chksum failed

      serial1_putchar('F');

      lcd_putchar('F');

      printf("checksum failed - was %d, should have been %d\n", wl_input, 

             wl_chksum);

    }

    wl_index = 0;

  }

}

/*

  \fn wl_timeout_handler

  Handles the timeout case.

  A time out occurs about every 1/4 second.  This function is called each time 

  one occurs. In the case where a robot first turns on, it will wait for a long

  time before declaring itself the leader.  Otherwise, if enough time-outs 

  occur in a row, wl_to_flag will be set to 1.  This will cause a timeout 

  packet to be sent next time around

*/

static void wl_timeout_handler( void ) {

  //increment the total number of wireless time-outs

  wl_to_count++;

  static int wl_first_to_count =  0;

  static int first_time = 1;

  //first time time out routine - listen for a long time

  if(first_time) {

    if(wl_to_count > WL_TIMEOUT_INITIAL) {

      //increment the counter for first timeouts

      wl_first_to_count++;

      //you don't actually want to send out a packet 

      //-- you would confuse other robots

      wl_to_flag = 0;

      wl_to_count = 0;

    }

    first_time = 0;

  } else {

    //not the first time - regular time out routine

    //if you have enough timeouts

    if(wl_to_count > WL_TIMEOUT) {

      //lcd_putchar('z');

      //change the time-out flag to 1

      wl_to_flag = 1;

      wl_to_count = 0;

    }

  }

}