Colony

#include "wireless.h"

#include "xbee.h"

#include <stdlib.h>

#include <stdio.h>

#include "wl_defs.h"

#ifndef ROBOT

#include <time.h>

#include <signal.h>

#else

#include <time.h>

#include <bom.h>

#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

timer_t wl_timeout_timer;

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

}

#endif

/**

 * Initializes the wireless library. Must be called before any

 * other function.

 **/

void wl_init()

{

        int i;

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

                wl_packet_groups[i] = NULL;

        xbee_lib_init(WL_DEFAULT_PAN);

        //begin timeout timer

        #ifdef ROBOT

        rtc_init(HALF_SECOND, &wl_do_timeout); 

        #else

        //create a timer to trigger every half second

        struct sigevent evp;

        evp.sigev_signo = SIGALRM;

        evp.sigev_notify = SIGEV_SIGNAL;

        if (timer_create(CLOCK_REALTIME, &evp, &wl_timeout_timer) == -1)

        { 

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

                exit(1); 

        }

        struct sigaction wl_sig_act;

        wl_sig_act.sa_handler = (void *)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);

        struct itimerspec wl_timeout_time;

        wl_timeout_time.it_interval.tv_sec = 0;

        wl_timeout_time.it_interval.tv_nsec = 500000000;

        wl_timeout_time.it_value.tv_sec = 0;

        wl_timeout_time.it_value.tv_nsec = 500000000;

        timer_settime(wl_timeout_timer, 0,

                        &wl_timeout_time, NULL);

        #endif

}

/**

 * Uninitializes the wireless library.

 **/

void wl_terminate()

{

        #ifndef ROBOT

        timer_delete(wl_timeout_timer);

        #endif

        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();

}

/**

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

 *

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

 **/

unsigned 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;

}