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 wireless.c

 * @brief Wireless Library Implementation

 *

 * Implementation of the wireless library.

 *

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

 **/

#include "wireless.h"

#include "xbee.h"

#include <stdlib.h>

#include <stdio.h>

#include "wl_defs.h"

#ifndef ROBOT

#include <sys/time.h>

#include <signal.h>

#else

#include <time.h>

#ifndef FIREFLY

#include <bom.h>

#endif

#endif

/*Function Prototypes*/

void wl_do_timeout(void);

//Note: the actual frame sent has group as the first four bits and

//frame as the last four.

void wl_send_packet(char group, char type, char* data, int len,

                    int dest, char options, char frame);

/*Data Members*/

//used to store incoming and outgoing packets

unsigned char wl_buf[128];

//1 if we have timed out since we last checked, 0 otherwise.

int wl_timeout = 0;

PacketGroupHandler* wl_packet_groups[WL_MAX_PACKET_GROUPS];

#ifndef ROBOT

//called when we time out, or receive interrupt

void sig_handler(int signo) {

  switch (signo)        {

  case SIGALRM:

    wl_timeout = 1;

    break;

  case SIGINT:

    wl_terminate();

    exit(1);

    break;

  }

  return;

}

#else

//called when the timer ticks

void timer_handler(void) {

  wl_timeout = 1;

}

#endif

/**

 * Initializes the wireless library. Must be called before any

 * other function.

 **/

int wl_init() {

  int i;

  for (i = 0; i < WL_MAX_PACKET_GROUPS; i++)

    wl_packet_groups[i] = NULL;

  if (xbee_lib_init() == -1) {

    return -1;

  }

  //begin timeout timer

#ifdef ROBOT

#ifdef FIREFLY

  rtc_init(PRESCALE_DIV_256, 32, &timer_handler);

#else

  rtc_init(HALF_SECOND, &timer_handler);

#endif

#else

  //create our timer

  struct itimerval timer_val;

  struct timeval interval;

  interval.tv_sec = 0;

  interval.tv_usec = 500000;

  struct timeval first_time;

  first_time.tv_sec = 0;

  first_time.tv_usec = 500000;

  timer_val.it_interval = interval;

  timer_val.it_value = first_time;

  if(setitimer(ITIMER_REAL,&timer_val,NULL)==-1) {

    WL_DEBUG_PRINT("Error creating a timer.\r\n");

    perror("Failure's cause");

    exit(1);

  }

  //create signal handler

  struct sigaction wl_sig_act;

  wl_sig_act.sa_handler = sig_handler;

  wl_sig_act.sa_flags = 0;

  sigemptyset(&wl_sig_act.sa_mask);

  sigaction(SIGALRM, &wl_sig_act, 0);

  sigaction(SIGINT, &wl_sig_act, 0);

#endif

  return 0;

}

/**

 * Uninitializes the wireless library.

 **/

void wl_terminate() {

  int i;

  for (i = 0; i < WL_MAX_PACKET_GROUPS; i++)

    if (wl_packet_groups[i] != NULL &&

        wl_packet_groups[i]->unregister != NULL)

      wl_packet_groups[i]->unregister();

  xbee_terminate();

}

/**

 * Set the PAN for the XBee to join.

 *

 * @param pan the new PAN

 *

 * @see wl_get_pan

 **/

void wl_set_pan(int pan) {

  xbee_set_pan_id(pan);

}

/**

 * Get the PAN the XBee is currently part of.

 *

 * @return the PAN of the XBee

 *

 * @see wl_set_pan

 **/

int wl_get_pan(void) {

  return xbee_get_pan_id();

}

/**

 * Set the channel the XBee is listening to.

 *

 * @param channel the new channel to join

 *

 * @see wl_get_channel

 **/

void wl_set_channel(int channel) {

  xbee_set_channel(channel);

}

/**

 * Get the channel the XBee is part of.

 *

 * @return the channel the XBee is part of

 *

 * @see wl_set_channel

 **/

int wl_get_channel(void) {

  return xbee_get_channel();

}

/**

 * Returns the 16-bit address of the XBee module.

 *

 * @return the 16-bit address of the XBee module.

 **/

int wl_get_xbee_id() {

  return xbee_get_address();

}

/**

 * Send a packet to a specific XBee without specifying a PAN.

 *

 * @param group the packet group

 * @param type the packet type

 * @param data the packet data

 * @param len the packet length in bytes

 * @param dest the 16-bit address of the XBee to send the packet to

 * @param frame the frame number to see with a TX_STATUS response

 **/

void wl_send_robot_to_robot_global_packet(char group, char type,

                                          char* data, int len, int dest, char frame) {

  wl_send_packet(group, type, data, len, dest,

                 XBEE_OPTIONS_BROADCAST_ALL_PANS, frame);

}

/**

 * Send a packet to a specific XBee in the same PAN.

 *

 * @param group the packet group

 * @param type the packet type

 * @param data the packet data

 * @param len the packet length in bytes

 * @param dest the 16-bit address of the XBee to send the packet to

 * @param frame the frame number to see with a TX_STATUS response

 **/

void wl_send_robot_to_robot_packet(char group, char type,

                                   char* data, int len, int dest, char frame) {

  wl_send_packet(group, type, data, len, dest, XBEE_OPTIONS_NONE,

                 frame);

}

/**

 * Send a packet to all XBees in all PANs.

 *

 * @param group the packet group

 * @param type the packet type

 * @param data the packet data

 * @param len the packet length in bytes

 * @param frame the frame number to see with a TX_STATUS response

 **/

void wl_send_global_packet(char group, char type,

                           char* data, int len, char frame) {

  wl_send_packet(group, type, data, len, XBEE_BROADCAST,

                 XBEE_OPTIONS_BROADCAST_ALL_PANS, frame);

}

/**

 * Send a packet to all XBee's in the same PAN.

 *

 * @param group the packet group

 * @param type the packet type

 * @param data the packet data

 * @param len the packet length in bytes

 * @param frame the frame number to see with a TX_STATUS response

 **/

void wl_send_pan_packet(char group, char type,

                        char* data, int len, char frame) {

  wl_send_packet(group, type, data, len, XBEE_BROADCAST,

                 XBEE_OPTIONS_NONE, frame);

}

/**

 * Send a packet.

 *

 * @param group the packet group

 * @param type the packet type

 * @param data the packet data

 * @param len the packet length in bytes

 * @param dest the destination of the packet

 * @param options the options for sending the packet

 * @param frame the frame number to see with a TX_STATUS response

 **/

void wl_send_packet(char group, char type, char* data, int len,

                    int dest, char options, char frame) {

  char buf[128];

  int i;

  if (frame != 0)

    frame = (frame & 0x0F) | ((group & 0x0F) << 4);

  buf[0] = group;

  buf[1] = type;

  for (i = 0; i < len; i++)

    buf[2 + i] = data[i];

  xbee_send_packet(buf, len + 2, dest, options, frame);

}

/**

 * Register a packet group with the wireless library. The event

 * handlers in the packet group will be called whenever an

 * event dealing with the packet group's group code occurs.

 *

 * @param h the PacketGroupHandler to register

 **/

void wl_register_packet_group(PacketGroupHandler* h) {

  if (h->groupCode >= WL_MAX_PACKET_GROUPS) {

    WL_DEBUG_PRINT("Packet group code too large.\r\n");

    return;

  }

  if (wl_packet_groups[h->groupCode] != NULL) {

    WL_DEBUG_PRINT("Packet group code already registered.\r\n");

    return;

  }

  wl_packet_groups[h->groupCode] = h;

}

/**

 * Unregister a packet group from the wireless library.

 *

 * @param h the packet group to remove

 **/

void wl_unregister_packet_group(PacketGroupHandler* h) {

  unsigned int groupCode = h->groupCode;

  PacketGroupHandler* p = wl_packet_groups[groupCode];

  if (p != NULL && p->unregister != NULL)

    p->unregister();

  wl_packet_groups[groupCode] = NULL;

}

/**

 * Called when the timer is triggered. This calls the timeout

 * handlers of all the registered packet groups.

 **/

void wl_do_timeout() {

  int i;

  for (i = 0; i < WL_MAX_PACKET_GROUPS; i++)

    if (wl_packet_groups[i] != NULL &&

        wl_packet_groups[i]->timeout_handler != NULL)

      wl_packet_groups[i]->timeout_handler();

}

/**

 * Performs wireless library functionality. This function must

 * be called frequently for wireless to perform effectively.

 * This function will call timeout handlers, as well as

 * received packet and transmit status handlers.

 **/

void wl_do() {

  if (wl_timeout) {

    wl_do_timeout();

    wl_timeout = 0;

  }

  int len = xbee_get_packet(wl_buf);

  if (len < 0)//no packet received

    return;

  if (wl_buf[0] == XBEE_TX_STATUS) {

    if (len != 3) {

      WL_DEBUG_PRINT("Transmit Status packet should be of length 3.\r\n");

      return;

    }

    //the first four bits are the packet group

    //this only works with under 16 groups

    int group = (int)(wl_buf[1] >> 4);

    int success = 0;

    if (wl_buf[2] == 0)

      success = 1;

    else {

      WL_DEBUG_PRINT("No response received.\r\n");

      if (wl_buf[2] == 2) {

        WL_DEBUG_PRINT("CCA Failure\r\n");

      }

      if (wl_buf[2] == 3) {

        WL_DEBUG_PRINT("Purged\r\n");

      }

    }

    if (wl_packet_groups[group] != NULL &&

        wl_packet_groups[group]->handle_response != NULL)

      wl_packet_groups[group]->handle_response(

                                               (int)wl_buf[1] & 0x0F, success);

    return;

  }

  if (wl_buf[0] == XBEE_RX) {

    if (len < 7) {

      WL_DEBUG_PRINT("Packet is too small.\r\n");

      return;

    }

    int source = ((int)wl_buf[1] << 8) + ((int)wl_buf[2]);

    /*

    //unused for now

    int signalStrength = wl_buf[3];

    //1 for Address broadcast, 2 for PAN broadcast

    int options = wl_buf[4];

    */

    int group = wl_buf[5];

    int type = wl_buf[6];

    int packetLen = len - 7;

    if (wl_packet_groups[group] != NULL

        && wl_packet_groups[group]->handle_receive != NULL)

      wl_packet_groups[group]->handle_receive(type, source,

                                              wl_buf + 7, packetLen);

    return;

  }

  WL_DEBUG_PRINT("Unexpected packet received from XBee.\r\n");

  return;

}

#ifndef ROBOT

void wl_set_com_port(char* port) {

  xbee_set_com_port(port);

}

#endif