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.

int 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

 **/

int wl_send_global_packet(char group, char type, char* data, int len, char frame)

{

        return 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

 **/

int 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];

        return 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