Colony - /branches/wireless/code/projects/libwireless/xbee.c - Robotics Club

root / branches / wireless / code / projects / libwireless / xbee.c @ 1783

History | View | Annotate | Download (49.9 KB)

 /**
  * Copyright (c) 2009 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 xbee.c
  * @brief XBee Interface
+ *
  * Implementation of low level communication with the XBee in API mode.
+ *
  * @author Colony Project, CMU Robotics Club
  **/
 #include <lights.h>
 #include <string.h>
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include <time.h>
 #include <wl_defs.h>
 #include <wireless.h>
 #include <eeprom.h>
 #include "xbee.h"
 /* Internal Function Prototypes */
 /* I/O Functions */
 static int8_t xbee_send_string(uint8_t* c);
 int8_t xbee_putc(uint8_t c);
 int16_t xbee_getc(void);
 int8_t xbee_getc_nb(uint8_t *c);
 /* Command Mode Functions */
 static int8_t xbee_enter_command_mode(void);
 static int8_t xbee_exit_command_mode(void);
 static int8_t xbee_enter_api_mode(void);
 static int8_t xbee_enter_api_mode2(void);
 static int8_t xbee_exit_api_mode(void);
 static int8_t xbee_wait_for_string(uint8_t* s, uint16_t len);
 static int8_t xbee_wait_for_ok(void);
 /* API Mode Functions */
 //TODO: does this exist?  static int8_t xbee_handle_packet(uint8_t* packet, uint16_t len);
 static int8_t xbee_handle_at_command_response(uint16_t command, uint8_t status, uint8_t len);
 static void xbee_handle_status(uint8_t status);
 static int8_t xbee_verify_checksum(uint8_t* packet, uint16_t len);
 static uint8_t xbee_compute_checksum(uint8_t* packet, uint16_t len);
 static int8_t xbee_send_frame(uint8_t* buf, uint16_t len);
 int8_t xbee_send_read_at_command(uint8_t* command);
 static int8_t xbee_send_modify_at_command(uint8_t* command, uint8_t* value, uint8_t len);
 /* Buffer Manipulation Functions */
 int8_t xbee_basic_buf_add(uint8_t *ptr, uint8_t byte);
 uint8_t xbee_basic_buf_get(uint8_t *ptr);
 int8_t xbee_other_buf_add(uint8_t *ptr, uint8_t byte);
 //uint8_t xbee_other_buf_get(uint8_t *ptr);
 /* private functions */
 int8_t check_last_receive(uint16_t source,uint8_t framenum);
 inline uint8_t getStatus(uint8_t mask);
 inline void setStatus(uint8_t mask,uint8_t value);
 /*Global Variables*/
 // array for basic packets
 uint8_t xbee_basic_buf[PACKET_BUFFER_SIZE];
 // beginning of first packet in basic buffer
 uint8_t basic_buf_first = (PACKET_BUFFER_SIZE-1);
 // byte after end of last packet in basic buffer (only access < basic_buf_last)
 // aka, the first free byte in basic buffer
 uint8_t basic_buf_last = 0;
 // array for other packets
 uint8_t xbee_other_buf[PACKET_BUFFER_SIZE];
 // beginning of first packet in other buffer
 uint8_t other_buf_first = (PACKET_BUFFER_SIZE-1);
 // byte after end of last packet in other buffer (only access < other_buf_last)
 // aka, the first free byte in other buffer
 uint8_t other_buf_last = 0;
 // last few packet sources and frame nums
 #define NUM_LAST_PACKETS 10
 struct {
   uint16_t source;
   uint8_t framenum;
 } lastPacket[NUM_LAST_PACKETS];
 // xbee status
 #define XBEE_API_OFF 0x00
 #define XBEE_API_ON 0x10
 #define XBEE_API_ESCAPE 0x20
 #define XBEE_API_MASK 0x30
 #define XBEE_COMMAND_WAIT 0x80
 #define XBEE_COMMAND_RESPONSE 0xC0
 #define XBEE_COMMAND_NONE 0x00
 #define XBEE_COMMAND_MASK 0xC0
 #define XBEE_NOT_INITD 0xF0
 #define LAST_PACKET_MASK 0x0F
 uint8_t xbee_status = XBEE_NOT_INITD;
 // xbee command response (for PAN, channel, address, etc)
 static uint8_t xbee_command[8];
 // external ack handler (wireless_send.c)
 extern void ackhandle(uint8_t num,uint8_t val);
 // define escaped bytes in API mode 2
 #define ESCAPE_MARKER 0x7D
 #define ESCAPE_XOR 0x20
 #define ESCAPE1 0x7E
 #define ESCAPE2 0x7D
 #define ESCAPE3 0x11
 #define ESCAPE4 0x13
 /**@addtogroup xbee
  * @{ **/
 /*Function Implementations*/
 /**
  * Interrupt for the robot. Adds bytes received from the xbee
  * to the buffer.
  **/
 #ifndef FIREFLY
 #define PORT UDR1
 #define FLAG (UCSR1A & (1<<RXC1))
 ISR(USART1_RX_vect) {
 #else
 #define PORT UDR0
 #define FLAG (UCSR0A & (1<<RXC0))
 SIGNAL(SIG_USART0_RECV) {
 #endif
   // start of frame
   uint8_t apitype = PORT; // get frame start byte
   uint16_t i=0;
   uint16_t len=0;
   // check that we're in API mode
   if (getStatus(XBEE_API_MASK) == XBEE_API_OFF || apitype != XBEE_FRAME_START) {
     // not in API mode
     WL_DEBUG_PRINT_P("|api off branch");
     if (getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_WAIT) {
       // get rest of command and put in basic buf
       xbee_basic_buf[i] = apitype;
       if (xbee_basic_buf[i++] != '\r') {
         while(i < PACKET_BUFFER_SIZE) {
           if (FLAG) {
             xbee_basic_buf[i] = PORT;
             if (xbee_basic_buf[i] == '\r')
               break;
             i++;
+          }
+        }
+      }
       WL_DEBUG_PRINT_P("got packet, len=");
       WL_DEBUG_PRINT_INT(i);
       WL_DEBUG_PRINT_P("str=");
       WL_DEBUG_PRINT((char*)xbee_basic_buf);
       // signal handler that command response is done
       setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_RESPONSE);
+    }
     WL_DEBUG_PRINT_P("return\r\n");
     return;
+  }
   //WL_DEBUG_PRINT_P("|api on branch");
   // get length and type
   while(i<3) {
     if (FLAG) {
       if (i==0) {
         if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
             && apitype == ESCAPE_MARKER)
           apitype = PORT ^ ESCAPE_XOR;
         else {
           apitype = PORT;
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             continue; // get escaped character
+        }
         len |= apitype<<8; // get len hi byte
       } else if (i==1) {
         if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
             && apitype == ESCAPE_MARKER)
           apitype = PORT ^ ESCAPE_XOR;
         else {
           apitype = PORT;
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             continue; // get escaped character
+        }
         len |= apitype; // get len lo byte
       } else if (i==2) {
         if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
             && apitype == ESCAPE_MARKER)
           apitype = PORT ^ ESCAPE_XOR;
         else {
           apitype = PORT;
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             continue; // get escaped character
+        }
         // get api type
         break;
+      }
       i++;
+    }
+  }
   // do something based on the type
   i=1;
   switch(apitype) {
   case XBEE_FRAME_AT_COMMAND_RESPONSE: {
     // AT command response
     if (getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_RESPONSE)
     {        WL_DEBUG_PRINT_P("ERROR: SOMETHING STRANGE HAS OCCURRED. THE ROBOT WILL SELF DESTRUCT IN 5 MINUTES!\r\n");//We better get rid of this sometime...
       return;} // we're currently processing a command, so drop the incoming one  ***** TODO: we need to read the whole length of the frame to do this right ****
     uint16_t atcommand=0;
     uint8_t ptr=basic_buf_last;
     uint8_t status=0;
     while(i<len) {
       if (FLAG) {
         if (i==1) {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR; // get frame id, and ignore
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
           apitype = PORT; // get frame id, but ignore it
         } else if (i==2) {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR;
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
           atcommand |= apitype<<8; // get command char1
         } else if (i==3) {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR;
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
           atcommand |= apitype; // get command char2
         } else if (i==4) {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR;
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
           status = apitype; // get status
         } else {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR;
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
           // put the command response on the basic buf temporarily
           if (xbee_basic_buf_add(&ptr,apitype) != 0)
             break;
+        }
         i++;
+      }
+    }
     // handle AT command
     WL_DEBUG_PRINT_P("|XBEE_FRAME_AT_COMMAND_RESPONSE");
     WL_DEBUG_PRINT_P("|i=");
     WL_DEBUG_PRINT_INT(i);
     WL_DEBUG_PRINT_P("|len=");
     WL_DEBUG_PRINT_INT(len);
     WL_DEBUG_PRINT_P("|status:");
     WL_DEBUG_PRINT_INT(status);
     WL_DEBUG_PRINT_P("|atcommand:");
     WL_DEBUG_PRINT_CHAR((uint8_t)(atcommand>>8));
     WL_DEBUG_PRINT_CHAR((uint8_t)(atcommand&0xFF));
     WL_DEBUG_PRINT_P("|first=");
     WL_DEBUG_PRINT_INT(basic_buf_first);
     WL_DEBUG_PRINT_P("|last=");
     WL_DEBUG_PRINT_INT(basic_buf_last);
     WL_DEBUG_PRINT_P("|buf=");
     uint8_t ptr2 = basic_buf_last;
     for(uint8_t j=0;j<(len-5);j++)
       WL_DEBUG_PRINT_HEX(xbee_basic_buf_get(&ptr2));
     WL_DEBUG_PRINT_P("|\r\n");
     xbee_handle_at_command_response(atcommand,status,len-5);
     break; }
   case XBEE_FRAME_STATUS: {
     // modem status
     while(1) {
       if (FLAG) {
         if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
             && apitype == ESCAPE_MARKER) {
           apitype = PORT ^ ESCAPE_XOR;
           break;
         } else {
           apitype = PORT;
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             continue; // get escaped character
           break;
+        }
+      }
+    }
     xbee_handle_status(apitype); // handle the modem status
     break; }
   case XBEE_FRAME_TX_STATUS: {
     // TX status
     uint8_t frame_id = 0;
     while(i<3) {
       if (FLAG) {
         if (i==1) {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR;
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
           frame_id = apitype;
         } else {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR;
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
           ackhandle(frame_id,apitype); // handle the status
           break;
+        }
         i++;
+      }
+    }
     WL_DEBUG_PRINT_P("|XBEE_FRAME_TX_STATUS framenum:");
     WL_DEBUG_PRINT_HEX(frame_id);
     WL_DEBUG_PRINT_P(",status=");
     WL_DEBUG_PRINT_HEX(apitype);
     break; }
   case XBEE_FRAME_RX_64: {
     // receive a packet with 64bit address
     WL_DEBUG_PRINT_P("|XBEE_FRAME_RX_64");
     break; } // TODO: implement this (even if we don't use it)
   case XBEE_FRAME_RX_16: {
     WL_DEBUG_PRINT_P("|B_last=");
     WL_DEBUG_PRINT_INT(basic_buf_last);
     // receive a packet with 16bit address
     uint16_t source = 0;
     uint8_t framenum = 0;
     uint8_t group = 0;
     uint8_t ptr=basic_buf_last;
     while(i<len) {
       if (FLAG) {
         WL_DEBUG_PRINT_P("|*i=");
         WL_DEBUG_PRINT_INT(i);
         WL_DEBUG_PRINT_P("|ptr=");
         WL_DEBUG_PRINT_INT(ptr);
         if (i==1) {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR; // get options, and ignore
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
           source |= apitype<<8; // get source hi byte
         } else if (i==2) {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR; // get options, and ignore
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
           source |= apitype; // get source lo byte
         } else if (i==3) {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR; // get RSSI, and ignore
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
         } else if (i==4) {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR; // get options, and ignore
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
         } else if (i==5) {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR;
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
           framenum = apitype; // get the frame number
 /*          if (check_last_receive(source,framenum) != WL_SUCCESS) {
             // we've already received this frame
             ptr = 0xFF; // signal to skip processing
             break;
+          }
 */      }
         else if (i==6) {
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR;
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
           group = apitype; // get group number
             WL_DEBUG_PRINT_P("|ptr2=");
             WL_DEBUG_PRINT_INT(ptr);
           if (group == 0) {
             WL_DEBUG_PRINT_P("|last1=");
             WL_DEBUG_PRINT_INT(basic_buf_last);
             WL_DEBUG_PRINT_P("|ptr1=");
             WL_DEBUG_PRINT_INT(ptr);
             ptr = basic_buf_last;
             WL_DEBUG_PRINT_P("|last2=");
             WL_DEBUG_PRINT_INT(basic_buf_last);
             WL_DEBUG_PRINT_P("|ptr2=");
             WL_DEBUG_PRINT_INT(ptr);
             if (xbee_basic_buf_add(&ptr,0x00) != 0) {
               WL_DEBUG_PRINT_P("failed to write to buffer1");
               break;
+            }
             WL_DEBUG_PRINT_P("|ptr3=");
             WL_DEBUG_PRINT_INT(ptr);
             // add source to basic buffer
             if (xbee_basic_buf_add(&ptr,(uint8_t)((source&0xFF00)>>8)) != 0) {
               WL_DEBUG_PRINT_P("failed to write to buffer2");
               break;
+            }
             WL_DEBUG_PRINT_P("|ptr4=");
             WL_DEBUG_PRINT_INT(ptr);
             if (xbee_basic_buf_add(&ptr,(uint8_t)(source&0x00FF)) != 0) {
               WL_DEBUG_PRINT_P("failed to write to buffer3");
               break;
+            }
             WL_DEBUG_PRINT_P("|ptr5=");
             WL_DEBUG_PRINT_INT(ptr);
           } else {
             ptr = other_buf_last;
             // add source and group to other buffer
             if (xbee_other_buf_add(&ptr,0x00) != 0) {
               WL_DEBUG_PRINT_P("failed to write to buffer3.5");
               break;
+            }
             if (xbee_other_buf_add(&ptr,group) != 0) {
               WL_DEBUG_PRINT_P("failed to write to buffer4");
               break;
+            }
             if (xbee_other_buf_add(&ptr,(uint8_t)((source&0xFF00)>>8)) != 0) {
               WL_DEBUG_PRINT_P("failed to write to buffer5");
               break;
+            }
             if (xbee_other_buf_add(&ptr,(uint8_t)(source&0x00FF)) != 0) {
               WL_DEBUG_PRINT_P("failed to write to buffer6");
               break;
+            }
+          }
+        }
         else {
           // put packet data on the correct buffer
           if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
               && apitype == ESCAPE_MARKER)
             apitype = PORT ^ ESCAPE_XOR;
           else {
             apitype = PORT;
             if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE
                 && apitype == ESCAPE_MARKER)
               continue; // get escaped character
+          }
           if (group == 0) {
             if (xbee_basic_buf_add(&ptr,apitype) != 0) {
               WL_DEBUG_PRINT_P("failed to write to buffer7");
               break;
+            }
           } else {
             if (xbee_other_buf_add(&ptr,apitype) != 0) {
               WL_DEBUG_PRINT_P("failed to write to buffer8");
               break;
+            }
+          }
+        }
         i++;
+      }
+    }
     WL_DEBUG_PRINT_P("before_last=");
     if (group == 0)
       WL_DEBUG_PRINT_INT(basic_buf_last);
     else
       WL_DEBUG_PRINT_INT(other_buf_last);
     if (ptr != 0xFF && i > 6) {
       if (group == 0) {
         xbee_basic_buf[basic_buf_last] = i-5; // set length
         basic_buf_last = ptr;
+      }
       else {
         xbee_other_buf[other_buf_last] = i-4; // set length  ** TODO: check this number
         // check if we have a high priority group
         /*for(;;)
           if (HIGH_PRIORITY) {
             // handle receive now
             ptr = 0xFF;
             break;
           }*/
         //if (ptr != 0xFF) {
           // handle receive later
           other_buf_last = ptr;
         //}
+      }
+    }
     WL_DEBUG_PRINT_P("|XBEE_FRAME_RX_16|len=");
     WL_DEBUG_PRINT_INT(len);
     WL_DEBUG_PRINT_P("|i=");
     WL_DEBUG_PRINT_INT(i);
     WL_DEBUG_PRINT_P("|source=");
     WL_DEBUG_PRINT_INT(source);
     WL_DEBUG_PRINT_P("|framenum=");
     WL_DEBUG_PRINT_INT(framenum);
     WL_DEBUG_PRINT_P("group=");
     WL_DEBUG_PRINT_INT(group);
     WL_DEBUG_PRINT_P("|ptr=");
     WL_DEBUG_PRINT_HEX(ptr);
     WL_DEBUG_PRINT_P("|first=");
     if (group == 0)
       WL_DEBUG_PRINT_INT(basic_buf_first);
     else
       WL_DEBUG_PRINT_INT(other_buf_first);
     WL_DEBUG_PRINT_P("|last=");
     if (group == 0)
       WL_DEBUG_PRINT_INT(basic_buf_last);
     else
       WL_DEBUG_PRINT_INT(other_buf_last);
     WL_DEBUG_PRINT_P("|buffer=");
     if (group == 0) {
       for(uint8_t i=0;i<ptr;i++)
         WL_DEBUG_PRINT_HEX(xbee_basic_buf[i]);
     } else {
       for(uint8_t i=0;i<ptr;i++)
         WL_DEBUG_PRINT_HEX(xbee_other_buf[i]);
+    }
     WL_DEBUG_PRINT_P("|\r\n");
     break; }
     default:
       WL_DEBUG_PRINT_P("|BAD APITYPE:");
       WL_DEBUG_PRINT_HEX(apitype);
       WL_DEBUG_PRINT_P("\r\n");
   } // end of switch statement
   while (1) {
     if (FLAG) {
       apitype = PORT; // get checksum, and ignore
       break;
+    }
+  }
   WL_DEBUG_PRINT_P("|interrupt - return\r\n");
 } // end of interrupt
 /* adds a byte to the basic buffer */
 int8_t xbee_basic_buf_add(uint8_t *ptr, uint8_t byte) {
   if (*ptr == basic_buf_first) {
     // buffer full
     WL_DEBUG_PRINT_P("basic buffer full\r\n");
     WL_DEBUG_PRINT_P("ptr=");
     WL_DEBUG_PRINT_INT(*ptr);
     WL_DEBUG_PRINT_P("|basic_buf_first=");
     WL_DEBUG_PRINT_INT(basic_buf_first);
     WL_DEBUG_PRINT_P("|basic_buf_last=");
     WL_DEBUG_PRINT_INT(basic_buf_last);
     WL_DEBUG_PRINT_P("\r\n");
     return -1;
+  }
   WL_DEBUG_PRINT_P("|add_ptr1=");
   WL_DEBUG_PRINT_INT(*ptr);
   xbee_basic_buf[(*ptr)++] = byte;
   if (*ptr == PACKET_BUFFER_SIZE)
     *ptr = 0;
   WL_DEBUG_PRINT_P("|add_ptr2=");
   WL_DEBUG_PRINT_INT(*ptr);
   return 0;
+}
 /* gets a byte from the basic buffer */
 uint8_t xbee_basic_buf_get(uint8_t *ptr) {
   uint8_t byte = xbee_basic_buf[(*ptr)++];
   if (*ptr == PACKET_BUFFER_SIZE)
     *ptr = 0;
   return byte;
+}
 /* adds a byte to the other buffer */
 int8_t xbee_other_buf_add(uint8_t *ptr, uint8_t byte) {
   if (*ptr == other_buf_first) {
     // buffer full
     WL_DEBUG_PRINT_P("other buffer full\r\n");
     return -1;
+  }
   xbee_other_buf[(*ptr)++] = byte;
   if (*ptr == PACKET_BUFFER_SIZE)
     *ptr = 0;
   return 0;
+}
 /* gets a byte from the other buffer */
 uint8_t xbee_other_buf_get(uint8_t *ptr) {
   uint8_t byte = xbee_other_buf[(*ptr)++];
   if (*ptr == PACKET_BUFFER_SIZE)
     *ptr = 0;
   return byte;
+}
 /**
  * Checks if packet is a duplicate
  **/
 int8_t check_last_receive(uint16_t source,uint8_t framenum) {
   uint8_t i=0;
   for(;i<NUM_LAST_PACKETS;i++) {
     if (lastPacket[i].source == source && lastPacket[i].framenum == framenum) {
       WL_DEBUG_PRINT_P("Duplicate Packet: LP.src=");
       WL_DEBUG_PRINT_INT(lastPacket[i].source);
       WL_DEBUG_PRINT_P("|GET.src=");
       WL_DEBUG_PRINT_INT(source);
       WL_DEBUG_PRINT_P("|LP.framenum=");
       WL_DEBUG_PRINT_INT(lastPacket[i].framenum);
       WL_DEBUG_PRINT_P("|GET.framenum=");
       WL_DEBUG_PRINT_INT(framenum);
       WL_DEBUG_PRINT_P("\r\n");
       return -1; // duplicate packet, so return error
+    }
+  }
   // save packet source and framenum
   i=getStatus(LAST_PACKET_MASK);
   lastPacket[i].source = source;
   lastPacket[i].framenum = framenum;
   if (++i>=NUM_LAST_PACKETS)
     i = 0;
   setStatus(LAST_PACKET_MASK,i);
   WL_DEBUG_PRINT_P("check last receive: LP.src=");
   WL_DEBUG_PRINT_INT(lastPacket[i].source);
   WL_DEBUG_PRINT_P("|GET.src=");
   WL_DEBUG_PRINT_INT(source);
   WL_DEBUG_PRINT_P("|LP.framenum=");
   WL_DEBUG_PRINT_INT(lastPacket[i].framenum);
   WL_DEBUG_PRINT_P("|GET.framenum=");
   WL_DEBUG_PRINT_INT(framenum);
   WL_DEBUG_PRINT_P("\r\n");
   return WL_SUCCESS;
+}
 /** status functions **/
 inline uint8_t getStatus(uint8_t mask) { return xbee_status&mask; }
 void setStatus(uint8_t mask,uint8_t value) { xbee_status = ((xbee_status&(~mask))|value); }
 /**
  * Initializes the XBee library so that other functions may be used.
  **/
 int8_t xbee_init() {
   WL_DEBUG_PRINT_P("in xbee_init\r\n");
   if(getStatus(XBEE_NOT_INITD) != XBEE_NOT_INITD) {
     return WL_ERROR_INIT_ALREADY_INITD;
+  }
   // set status
   setStatus(XBEE_NOT_INITD,XBEE_COMMAND_NONE);
   // clear last packet buffer
   int i=0;
   for(;i<NUM_LAST_PACKETS;i++)
     lastPacket[i].source = lastPacket[i].framenum = 0;
   // clear basic and other buffers
   //uint8_t j=0;
   i=0;
   while(i<PACKET_BUFFER_SIZE) { xbee_basic_buf[i++] = 0xFF; }
   i=0;
   while(i<PACKET_BUFFER_SIZE) { xbee_other_buf[i++] = 0xFF; }
   // Set startup baud rate of 9600
   // Set frame format: 8data, 1stop bit, asynchronous normal mode
   // Enable receiver and transmitter and the receiving interrupt
 #ifdef FIREFLY
   UBRR0H = 0x00;
   UBRR0L = 103;
   UCSR0A |= (1<<U2X0);
   UCSR0C |= (1<<UCSZ00) | (1<<UCSZ01);
   UCSR0B |= (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE);
 #else
   // Bayboard or robot
   UBRR1H = 0x00; // baud rate
   UBRR1L = 103;  // baud rate
   UCSR1A |= (1<<U2X1); // double transmit speed
   //Enable receiver and transmitter on USART1
   UCSR1B |= (1<<RXEN1)|(1<<TXEN1);
   // Set frame format: 8data, 1stop bit, asynchronous normal mode
   UCSR1C |= (1<<UCSZ10) | (1<<UCSZ11);
   UCSR1B |= (1<<RXCIE1);  // enable receive, transmit (1<<RXCIE)
 #endif
   sei();
   // enter command mode
   WL_DEBUG_PRINT_P("entering command mode\r\n");
   xbee_send_string((uint8_t*)"+++");
   xbee_wait_for_ok();
   WL_DEBUG_PRINT_P("entered command mode\r\n");
   // set baud on xbee
 #if (XBEE_BAUD == 115200)
   xbee_send_string((uint8_t*)"ATBD7\r");
 #elif (XBEE_BAUD == 57600)
   xbee_send_string((uint8_t*)"ATBD6\r");
 #elif (XBEE_BAUD == 38400)
   xbee_send_string((uint8_t*)"ATBD5\r");
 #elif (XBEE_BAUD == 19200)
   xbee_send_string((uint8_t*)"ATBD4\r");
 #elif (XBEE_BAUD == 9600)
   // already at this baud rate
   xbee_send_string((uint8_t*)"ATBD3\r\n");
 #else
   WL_DEBUG_PRINT_P("undefined baud rate\r\n");
   return WL_ERROR_BAUD;
 #endif
   // exit command mode
   xbee_wait_for_ok();
   WL_DEBUG_PRINT_P("got ok from baud reset\r\n");
   xbee_send_string((uint8_t*)"ATCN\r");
   xbee_wait_for_ok();
   WL_DEBUG_PRINT_P("got ok from exiting command mode\r\n");
   // set UART baud
 #ifdef FIREFLY
 #if (XBEE_BAUD == 115200)
   UBRR0H = 0x00;
   UBRR0L = 8;
 #elif (XBEE_BAUD == 57600)
   UBRR0H = 0x00;
   UBRR0L = 16;
 #elif (XBEE_BAUD == 38400)
   UBRR0H = 0x00;
   UBRR0L = 25;
 #elif (XBEE_BAUD == 19200)
   UBRR0H = 0x00;
   UBRR0L = 51;
 #elif (XBEE_BAUD == 9600)
   /* this is the default baud rate, so do nothing
   UBRR0H = 0x00;
   UBRR0L = 103;*/
 #else
   WL_DEBUG_PRINT_P("undefined baud rate\r\n");
   return WL_ERROR_BUAD;
 #endif
 #else // Bayboard or robot
 #if (XBEE_BAUD == 115200)
   UBRR1H = 0x00;
   UBRR1L = 8;
 #elif (XBEE_BAUD == 57600)
   UBRR1H = 0x00;
   UBRR1L = 16;
 #elif (XBEE_BAUD == 38400)
   UBRR1H = 0x00;
   UBRR1L = 25;
 #elif (XBEE_BAUD == 19200)
   UBRR1H = 0x00;
   UBRR1L = 51;
 #elif (XBEE_BAUD == 9600)
   /* this is the default baud rate, so do nothing
   UBRR1H = 0x00;
   UBRR1L = 103;*/
 #else
   WL_DEBUG_PRINT_P("undefined baud rate\r\n");
   return WL_ERROR_BUAD;
 #endif
 #endif
   // wait half second for the baud change to stabalize
   delay_ms(500);
   // enter command mode
   WL_DEBUG_PRINT_P("entering command mode 2\r\n");
   xbee_send_string((uint8_t*)"+++");
   xbee_wait_for_ok();
   WL_DEBUG_PRINT_P("entered command mode 2\r\n");
   if (xbee_enter_api_mode2() != 0) {
     WL_DEBUG_PRINT_P("can't enter api mode 2\r\n");
     return -1;
+  }
 #ifdef WL_DEBUG
   if (getStatus(XBEE_API_MASK) == XBEE_API_OFF) {
     WL_DEBUG_PRINT_P("|API OFF|");
   } else if (getStatus(XBEE_API_MASK) == XBEE_API_ON) {
     WL_DEBUG_PRINT_P("|API ON|");
   } else {
     WL_DEBUG_PRINT_P("|API ERROR|");
+  }
 #endif
   // set MY address
   uint8_t newmy = get_robotid();
   uint8_t newmyarr[2] = {0x00,newmy};
   if (newmy == 0xFF) {
     WL_DEBUG_PRINT_P("can't get MY address from EEPROM\r\n");
   } else {
     WL_DEBUG_PRINT_P("MY address from eeprom:");
     WL_DEBUG_PRINT_HEX(newmyarr[0]);
     WL_DEBUG_PRINT_HEX(newmyarr[1]);
     WL_DEBUG_PRINT_P("\r\n");
     setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_WAIT);
     if (xbee_send_modify_at_command((uint8_t*)"MY",newmyarr,2) != WL_SUCCESS) {
       WL_DEBUG_PRINT_P("setting MY address failed\r\n");
+    }
     // wait for up to 30 ms
     newmy = 0;
     while(getStatus(XBEE_COMMAND_MASK) != XBEE_COMMAND_RESPONSE && newmy++ < 10000) {
       delay_us(1); // wait 3us
+    }
     if (newmy < 1000 && xbee_command[0] == 'M' && xbee_command[1] == 'Y') {
       WL_DEBUG_PRINT_P("setting MY address successful\r\n");
     } else
       WL_DEBUG_PRINT_P("setting MY address failed\r\n");
     setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // reset status
+  }
   // get MY address
   uint16_t address = xbee_get_address();
   if (address == WL_ERROR_XBEE_COMMAND_16BIT) {
     WL_DEBUG_PRINT_P("getting MY address failed\r\n");
+  }
   WL_DEBUG_PRINT_P("MY address:");
   WL_DEBUG_PRINT_HEX((uint8_t)((address&0xFF00)>>8));
   WL_DEBUG_PRINT_HEX((uint8_t)(address&0x00FF));
   WL_DEBUG_PRINT_P("\r\n");
   // set PAN
   xbee_set_pan(0);
   return WL_SUCCESS;
+}
 /**
  * Call when finished using the XBee library.
  **/
 int8_t xbee_terminate()
+{
   int ret=xbee_exit_api_mode();
   if (ret != WL_SUCCESS) {
     WL_DEBUG_PRINT_P("xbee termination failed\r\n");
     WL_DEBUG_PRINT_INT(ret);
     WL_DEBUG_PRINT_P("|\r\n");
     return WL_ERROR_TERMINATION_FAILED;
+  }
   delay_ms(1000);
   // reset baud to defaults
   xbee_enter_command_mode();
   xbee_send_string((uint8_t*)"ATBD 3\r");
   xbee_wait_for_ok();
   xbee_exit_command_mode();
   UBRR1H = 0x00;
   UBRR1L = 103;
   setStatus(XBEE_NOT_INITD,XBEE_NOT_INITD); // clean initd status
   return WL_SUCCESS;
+}
 /**
  * Sends a character to the XBee.
+ *
  * @param c the byte to send
  * @return 0 for success, nonzero for failure
  **/
 int8_t xbee_putc(uint8_t c) {
   // Wait until buffer is clear for sending
   // Then load buffer with your character
 #ifdef FIREFLY
   loop_until_bit_is_set(UCSR0A, UDRE0);
   UDR0 = c;
 #else
   loop_until_bit_is_set(UCSR1A, UDRE1);
   UDR1 = c;
 #endif
   return WL_SUCCESS;
+}
 /**
  * Returns the first byte in the buffer received from xbee.
  * This function blocks execution until a character has been
  * received. xbee_init must be called before this function
  * may be used.
+ *
  * @return the first character in the xbee buffer, -1 on error
+ *
  * @see xbee_init, xbee_getc_nb
  **/
 int16_t xbee_getc(void) {
   // Wait for the receive buffer to be filled
   // Then read the receive buffer
 #ifdef FIREFLY
   loop_until_bit_is_set(UCSR0A, RXC0);
   return UDR0;
 #else
   loop_until_bit_is_set(UCSR1A, RXC1);
   return UDR1;
 #endif
+}
 /**
  * Non blocking version of xbee_getc. If a byte is present in the buffer,
  * it is returned, otherwise -1 is returned immediately. xbee_init
  * must be called before this function can be used.
+ *
  * @param c The received byte. This will be set if a byte has been received.
+ *
  * @return -1 If no byte is available, 0 otherwise, positive for error
+ *
  * @see xbee_getc
  **/
 int8_t xbee_getc_nb(uint8_t *c) {
   // check if the receive buffer is filled
 #ifdef FIREFLY
   if (UCSR0A & (1<<RXC0)) {
     (*c) = UDR0;
 #else
   if (UCSR1A & (1<<RXC1)) {
     (*c) = UDR1;
 #endif
     return WL_SUCCESS;
+  }
   return -1; // Return empty
+}
 /**
  * Send byte to the xbee in API mode.
+ *
  * @param byte the byte to be sent
  **/
 int8_t xbee_sendc(uint8_t byte) {
   if (getStatus(XBEE_API_MASK) == XBEE_API_ESCAPE &&
       (byte == ESCAPE1 || byte == ESCAPE2 || byte == ESCAPE3 || byte == ESCAPE4))
     byte ^= ESCAPE_XOR;
 #ifdef FIREFLY
   loop_until_bit_is_set(UCSR0A, UDRE0);
   UDR0 = byte;
 #else
   loop_until_bit_is_set(UCSR1A, UDRE1);
   UDR1 = byte;
 #endif
   return WL_SUCCESS;
+}
 /**
  * Send a buffer buf of size bytes to the XBee in API mode
+ *
  * @param buf the buffer of data to send
  * @param size the number of bytes to send
  **/
 int8_t xbee_send(uint8_t* buf, uint16_t size)
+{
   uint16_t i=0; // check if we need this variable
   while(i<size) {
     if (xbee_sendc(buf[i++]) != WL_SUCCESS)
       return WL_ERROR_SEND;
+  }
   return WL_SUCCESS;
+}
 /**
  * Sends a string direct to the XBee.
+ *
  * @param c the string to send to the XBEE
  **/
 static int8_t xbee_send_string(uint8_t* c)
+{
   uint16_t size = strlen((char*)c);
   uint16_t i=0; // check if we need this variable
   while(i<size) {
     if (xbee_putc(c[i++]) != WL_SUCCESS)
       return WL_ERROR_SEND;
+  }
   return WL_SUCCESS;
+}
 /**
  * Enter into command mode.
  **/
 static int8_t xbee_enter_command_mode(void)
+{
   if (xbee_send_string((uint8_t*)"+++") != WL_SUCCESS) {
     return WL_ERROR_XBEE_COMMAND;
+  }
   WL_DEBUG_PRINT_P("sent command +++|");
   if (xbee_wait_for_ok() != WL_SUCCESS) {
     return WL_ERROR_XBEE_COMMAND;
+  }
   WL_DEBUG_PRINT_P("got OK\r\n");
   return WL_SUCCESS;
+}
 /**
  * Exit from command mode.
  **/
 static int8_t xbee_exit_command_mode()
+{
   if (xbee_send_string((uint8_t*)"ATCN\r") != 0) {
     return WL_ERROR_SEND;
+  }
   if (xbee_wait_for_ok() != WL_SUCCESS) {
     WL_DEBUG_PRINT_P("failed to exit command mode\r\n");
     return WL_ERROR_SEND;
+  }
   return WL_SUCCESS;
+}
 /**
  * Enter API mode.
  **/
 static int8_t xbee_enter_api_mode(void) {
   if (xbee_send_string((uint8_t*)"ATAP 1\r") != 0) {
     return WL_ERROR_SEND;
+  }
   if (xbee_wait_for_ok() != WL_SUCCESS) {
     WL_DEBUG_PRINT_P("failed to enter API mode\r\n");
     return WL_ERROR_SEND;
+  }
   if (xbee_exit_command_mode() != WL_SUCCESS) {
     WL_DEBUG_PRINT_P("failed to enter API mode\r\n");
     return WL_ERROR_SEND;
+  }
   WL_DEBUG_PRINT_P("got OK after entering API mode\r\n");
   setStatus(XBEE_API_MASK,XBEE_API_ON); // set status
   return WL_SUCCESS;
+}
 /**
  * Enter API mode 2.
  **/
 static int8_t xbee_enter_api_mode2(void) {
   if (xbee_send_string((uint8_t*)"ATAP 2\r") != 0) {
     return WL_ERROR_SEND;
+  }
   if (xbee_wait_for_ok() != WL_SUCCESS) {
     WL_DEBUG_PRINT_P("failed to enter API mode2\r\n");
     return WL_ERROR_SEND;
+  }
   if (xbee_exit_command_mode() != WL_SUCCESS) {
     WL_DEBUG_PRINT_P("failed to enter API mode2\r\n");
     return WL_ERROR_SEND;
+  }
   WL_DEBUG_PRINT_P("got OK after entering API mode2\r\n");
   setStatus(XBEE_API_MASK,XBEE_API_ESCAPE); // set status
   return WL_SUCCESS;
+}
 /**
  * Exit API mode.
  **/
 static int8_t xbee_exit_api_mode()
+{
   if (getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_WAIT
     || getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_RESPONSE)
     return WL_ERROR_XBEE_COMMAND; // can't do command right now
   WL_DEBUG_PRINT_P("now exiting API mode\r\n");
   int16_t i=0;
   // change status to command wait
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_WAIT);
   if (xbee_send_modify_at_command((uint8_t*)"AP",(uint8_t*)(&i),1) != WL_SUCCESS) { // send command
     WL_DEBUG_PRINT_P("error sending AP 0 command\r\n");
     setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // reset status
     return WL_ERROR_XBEE_COMMAND;
+  }
   // wait for up to 30 ms
   while(getStatus(XBEE_COMMAND_MASK) != XBEE_COMMAND_RESPONSE && i++ < 10000) {
     delay_us(1); // wait 3us
+  }
   if (i < 1000 && xbee_command[0] == 'A' && xbee_command[1] == 'P') {
     WL_DEBUG_PRINT_P("done exiting API mode\r\n");
     i = WL_SUCCESS;
   } else {
     WL_DEBUG_PRINT_P("failed to exit API mode\r\n");
     i = WL_ERROR_XBEE_COMMAND; // set error code
+  }
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // reset status
   setStatus(XBEE_API_MASK,XBEE_API_OFF);
   return (int8_t)i; // return
+}
 /**
  * Wait until the string "OK\r" is received from the XBee.
  **/
 static int8_t xbee_wait_for_ok()
+{
   //delay_ms(1000);
   //return WL_SUCCESS;
   return xbee_wait_for_string((uint8_t*)"OK", 2);
+}
 /**
  * Delay until the specified string is received from
  * the XBee.
+ *
  * Only works when not in API mode
+ *
  * @param s the string to receive
  * @param len the length of the string
  **/
 static int8_t xbee_wait_for_string(uint8_t* s, uint16_t len)
+{
   uint8_t i=0;
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_WAIT); // set status flag
   if (getStatus(XBEE_API_MASK) == XBEE_API_OFF) {
     // wait until the response is received (only wait 1 second)
     while(getStatus(XBEE_COMMAND_MASK) != XBEE_COMMAND_RESPONSE && i++ < 1000) {
       delay_us(1);
+    }
     // check response
     if (i >= 1000 || memcmp(s,xbee_basic_buf,len) != 0) {
       // bad response
       WL_DEBUG_PRINT_P("Bad response when waiting for string ");
       WL_DEBUG_PRINT((char*)s);
       WL_DEBUG_PRINT_P("\r\n");
       return -1;
+    }
     setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // clear status
+  }
   WL_DEBUG_PRINT_P("done waiting for string.\r\n");
   return 0;
+}
 /**
  * Delay until we receive a command response.
  * Then copy the response to S and set the len
+ *
  * Only works when not in API mode
+ *
  * @param s the string to store the response in
  * @param len the length of the string
  */
 static int8_t xbee_wait_for_response(uint8_t* s, int16_t len) {
   uint8_t i=0;
   if (getStatus(XBEE_API_MASK) == XBEE_API_OFF) {
     // wait until the response is received (only wait 1 second)
     while(getStatus(XBEE_COMMAND_MASK) != XBEE_COMMAND_RESPONSE && i++ < 1000) {
       delay_us(1);
+    }
     // check response
     if (i >= 1000) {
       return -1;
     } else {
       i=strcspn((char*)xbee_basic_buf,"\r");
       if (i<PACKET_BUFFER_SIZE) {
         memcpy(s,xbee_basic_buf,i);
         len = i;
         setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // clear response
         return 0;
+      }
       else
         return -1;
+    }
+  }
   // TODO: do something for API mode
   return 0;
+}
 /**  TODO: since we don't use this, do we need it?
+ *
  * Verifies that the packets checksum is correct.
  * (If the checksum is correct, the sum of the bytes
  * is 0xFF.)
+ *
  * @param packet the packet received. This includes the first
  * three bytes, which are header information from the XBee.
+ *
  * @param len The length of the packet received from the XBee
+ *
  * @return 0 if the checksum is incorrect, nonzero
  * otherwise
  **/
 int8_t xbee_verify_checksum(uint8_t* packet, uint16_t len)
+{
   uint8_t sum = 0;
   while(--len > 0) {
     sum += packet[len];
+  }
   sum += packet[0];
   return (sum == 0xFF);
+}
 /**
  * Returns the checksum of the given packet.
+ *
  * @param buf the data for the packet to send
  * @param len the length of the packet in bytes
+ *
  * @return the checksum of the packet, which will
  * become the last byte sent in the packet
  **/
 uint8_t xbee_compute_checksum(uint8_t* buf, uint16_t len)
+{
   uint8_t sum = 0;
   while(--len > 0) {
     sum += buf[len];
+  }
   sum += buf[0];
   return 0xFF - sum;
+}
 /**
  * Adds buf to the previous checksum total
+ *
  * @param buf a byte buffer to add to the checksum
  * @param len the length of the buffer
  * @param sum the previous sum
+ *
  * @return error code
  **/
 int8_t xbee_checksum_add(uint8_t *buf, uint8_t len, uint8_t* sum) {
   if (buf == NULL || sum == NULL)
     return WL_ERROR_ARGUMENT;
   while(--len > 0) {
     *sum += buf[len];
+  }
   *sum += buf[0];
   return WL_SUCCESS;
+}
 /**
  * Sends header information. Header information includes
  * XBEE_FRAME_START and the packet length, as two bytes.
+ *
  * @param type the packet type
  * @param len the size in bytes of the packet data
+ *
  **/
 int8_t xbee_send_header(uint16_t len)
+{
   //packet prefix
   if (xbee_putc(XBEE_FRAME_START) != WL_SUCCESS)
     return WL_ERROR_SEND;
   if (xbee_sendc((uint8_t)((len&0xFF00)>>8)) != WL_SUCCESS)
     return WL_ERROR_SEND;
   if (xbee_sendc((uint8_t)(len&0x00FF)) != WL_SUCCESS)
     return WL_ERROR_SEND;
   return WL_SUCCESS;
+}
 /**
  * Adds header information and checksum to the given
  * packet and sends it. Header information includes
  * XBEE_FRAME_START and the packet length, as two bytes.
+ *
  * @param buf the packet data
  * @param len the size in bytes of the packet data
+ *
  **/
 static int8_t xbee_send_frame(uint8_t* buf, uint16_t len)
+{
   uint8_t checksum = xbee_compute_checksum(buf, len);
   // send header
   if (xbee_send_header(len) != WL_SUCCESS)
     return WL_ERROR_SEND;
   // send body
   if (xbee_send(buf, len) != WL_SUCCESS)
     return WL_ERROR_SEND;
   // send checksum
   if (xbee_sendc(checksum) != WL_SUCCESS)
     return WL_ERROR_SEND;
   return WL_SUCCESS;
+}
 /**
  * Sends an AT command to read a parameter.
+ *
  * @param command the AT command to send. For exmaple,
  * use ID to read the PAN ID and MY to return the XBee ID.
  * See the XBee reference guide for a complete listing.
  **/
 int8_t xbee_send_read_at_command(uint8_t* command)
+{
   return xbee_send_modify_at_command(command, NULL, 0);
+}
 /**
  * Sends the given AT command.
+ *
  * @param command the AT command to send (e.g., MY, ID)
  * @param value the value to pass as a parameter
  * (or NULL if there is no parameter)
  **/
 static int8_t xbee_send_modify_at_command(uint8_t* command, uint8_t* value, uint8_t len)
+{
   uint8_t buf[12];
   buf[0] = XBEE_FRAME_AT_COMMAND;
   buf[1] = 1;
   buf[2] = command[0];
   buf[3] = command[1];
   if (value != NULL)
+  {
     if (len > 8)
+    {
       WL_DEBUG_PRINT_P("AT Command too large.\r\n");
       return WL_ERROR_ARGUMENT;
+    }
     memcpy(buf+4,value,len);
+  }
   return xbee_send_frame(buf, 4 + len);
+}
 /**
  * Send the specified packet.
+ *
  * @param packet the packet data to send
  * @param len the number of bytes in the packet
+ *
  * @param dest the ID of the XBee to send the packet to,
  * or XBEE_BROADCAST to send the message to all robots
  * in the PAN.
+ *
  * @param options a combination of the flags
  * XBEE_OPTIONS_NONE, XBEE_OPTIONS_DISABLE_RESPONSE and
  * XBEE_OPTIONS_BROADCAST_ALL_PANS
+ *
  * @param frame the frame number to associate this packet
  * with. This will be used to identify the response when
  * the XBee alerts us as to whether or not our message
  * was received.
  **/
 int8_t xbee_send_packet(uint8_t* packet, uint8_t len, uint16_t dest, uint8_t options, uint8_t frame)
+{
   uint8_t sum = XBEE_FRAME_TX_REQUEST_16;
   uint8_t i = 0;
   if (len > 100)
+  {
     WL_DEBUG_PRINT_P("Packet is too large.\r\n");
     return WL_ERROR_ARGUMENT;
+  }
   // calculate checksum
   for(;i<len;i++)
     sum += packet[len];
   sum += frame;
   sum += (dest&0xFF00) >> 8;
   sum += dest&0x00FF;
   sum += options;
   sum = 0xFF - sum;
   //packet prefix
   if (xbee_putc(XBEE_FRAME_START) != WL_SUCCESS)
     return WL_ERROR_SEND;
   if (xbee_sendc(0x00) != WL_SUCCESS)
     return WL_ERROR_SEND;
   if (xbee_sendc(len+5) != WL_SUCCESS)
     return WL_ERROR_SEND;
   //send header for TX request
   if (xbee_sendc(XBEE_FRAME_TX_REQUEST_16) != WL_SUCCESS)
     return WL_ERROR_SEND;
   if (xbee_sendc(frame) != WL_SUCCESS)
     return WL_ERROR_SEND;
   if (xbee_sendc((uint8_t)((dest&0xFF00) >> 8)) != WL_SUCCESS)
     return WL_ERROR_SEND;
   if (xbee_sendc((uint8_t)(dest&0x00FF)) != WL_SUCCESS)
     return WL_ERROR_SEND;
   if (xbee_sendc(options) != WL_SUCCESS)
     return WL_ERROR_SEND;
   // send packet
   if (xbee_send(packet, len) != WL_SUCCESS)
     return WL_ERROR_SEND;
   // send checksum
   if (xbee_sendc(sum) != WL_SUCCESS)
     return WL_ERROR_SEND;
   return WL_SUCCESS;
+}
 /**
  * Handles modem status packets.
+ *
  * @param status the type of status packet received.
  **/
 void xbee_handle_status(uint8_t status)
+{
   switch (status)
+  {
     case 0:
       WL_DEBUG_PRINT_P("XBee hardware reset.\r\n");
       break;
     case 1:
       WL_DEBUG_PRINT_P("Watchdog timer reset.\r\n");
       break;
     case 2:
       WL_DEBUG_PRINT_P("Associated.\r\n");
       break;
     case 3:
       WL_DEBUG_PRINT_P("Disassociated.\r\n");
       break;
     case 4:
       WL_DEBUG_PRINT_P("Synchronization lost.\r\n");
       break;
     case 5:
       WL_DEBUG_PRINT_P("Coordinator realignment.\r\n");
       break;
     case 6:
       WL_DEBUG_PRINT_P("Coordinator started.\r\n");
       break;
+  }
+}
 /**
  * Handles AT command response packets.
  * @param command the two character AT command, e.g. MY or ID
  * @param result 0 for success, 1 for an error
  * @param len the length in bytes of extra
  **/
 static int8_t xbee_handle_at_command_response(uint16_t command, uint8_t status, uint8_t len)
+{
   WL_DEBUG_PRINT_P("HANDLE AT COMMAND\r\n");
   if (status != 0)
+  {
     WL_DEBUG_PRINT_P("Error with AT");
     WL_DEBUG_PRINT((char*)command);
     WL_DEBUG_PRINT_P(" packet. Result = ");
     switch(status) {
     case 1:
       WL_DEBUG_PRINT_P("ERROR\r\n");
       break;
     case 2:
       WL_DEBUG_PRINT_P("Invalid Command\r\n");
       break;
     case 3:
       WL_DEBUG_PRINT_P("Invalid Parameter\r\n");
       break;
+    }
     return WL_SUCCESS;
+  }
   WL_DEBUG_PRINT_P("AT");
   WL_DEBUG_PRINT_CHAR((uint8_t)(command>>8));
   WL_DEBUG_PRINT_CHAR((uint8_t)(command));
   WL_DEBUG_PRINT_P(" command is being handled\r\n");
   // TODO: program more command responses here (ND, etc)
   switch(command) {
   case ('I'<<8)+'D': // PAN
   case ('C'<<8)+'H': // channel
   case ('M'<<8)+'Y': // address
   case ('A'<<8)+'P': // api mode
     // copy command to handler
     xbee_command[0] = (command&0xFF00)>>8;
     xbee_command[1] = command&0x00FF;
     uint8_t ptr = basic_buf_last;
     for(command=2;command<len+2;command++) {
       xbee_command[command] = xbee_basic_buf_get(&ptr);
       if (xbee_command[command] == '\r')
         break; // done with command
       WL_DEBUG_PRINT_HEX(xbee_command[command]);
+    }
     xbee_command[command] = '\0';
     WL_DEBUG_PRINT_P("len=");
     WL_DEBUG_PRINT_INT(len);
     WL_DEBUG_PRINT_P("ID,CH,or MY command result:");
     WL_DEBUG_PRINT((char*)xbee_command);
     WL_DEBUG_PRINT_P("\r\n");
     break;
   default:
     WL_DEBUG_PRINT_P("unknown AT command");
+  }
   // signal handler that command response is done
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_RESPONSE);
   return WL_SUCCESS;
+}
 /**
  * Sets the personal area network id.
+ *
  * @param id the new personal area network (PAN) id
  **/
 int8_t xbee_set_pan(uint16_t id)
+{
   if (getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_WAIT
     || getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_RESPONSE)
     return WL_ERROR_XBEE_COMMAND; // can't do command right now
   uint8_t arr[2] = {(id&0xFF00)>>8,(id&0x00FF)};
   WL_DEBUG_PRINT_P("setting PAN address:");
   WL_DEBUG_PRINT_HEX(arr[0]);
   WL_DEBUG_PRINT_HEX(arr[1]);
   WL_DEBUG_PRINT_P("\r\n");
   // change status to command wait
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_WAIT);
   xbee_send_modify_at_command((uint8_t*)"ID",arr,2); // send command to set the channel
   // wait for up to 30 ms
   uint16_t i=0;
   while(getStatus(XBEE_COMMAND_MASK) != XBEE_COMMAND_RESPONSE && i++ < 10000) {
     delay_us(1); // wait 3us
+  }
   if (i < 1000 && xbee_command[0] == 'I' && xbee_command[1] == 'D')
     i = WL_SUCCESS;
   else
     i = WL_ERROR_XBEE_COMMAND; // set error code
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // reset status
   return (int8_t)i; // return
+}
 /**
  * Get the PAN ID for the XBee.
+ *
  * @return the personal area network id, or
  * XBEE_PAN_DEFAULT if it has not yet been set.
  **/
 uint16_t xbee_get_pan()
+{
   if (getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_WAIT
     || getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_RESPONSE)
     return WL_ERROR_XBEE_COMMAND_16BIT; // can't do command right now
   uint16_t i=0;
   // change status to command wait
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_WAIT);
   xbee_send_read_at_command((uint8_t*)"ID"); // send command to get the PAN
   // wait for up to 30 ms
   while(getStatus(XBEE_COMMAND_MASK) != XBEE_COMMAND_RESPONSE && i++ < 10000) {
     delay_us(1); // wait 3us
+  }
   if (i < 1000 && xbee_command[0] == 'I' && xbee_command[1] == 'D')
     i = (xbee_command[2]<<8)|xbee_command[3]; // do ntoh16 coversion
   else
     i = WL_ERROR_XBEE_COMMAND_16BIT; // set error code
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // reset status
   WL_DEBUG_PRINT_P("got PAN address:");
   WL_DEBUG_PRINT_HEX((i&0xFF00)>>8);
   WL_DEBUG_PRINT_HEX((i&0x00FF));
   WL_DEBUG_PRINT_P("\r\n");
   return i; // return
+}
 /**
  * Set the channel the XBee is using.
+ *
  * @param channel the channel the XBee will not use,
  * between 0x0B and 0x1A
+ *
  * @see xbee_get_channel
  **/
 int8_t xbee_set_channel(uint8_t channel)
+{
   if (channel < 0x0B || channel > 0x1A)
+  {
     WL_DEBUG_PRINT_P("Channel out of range.\r\n");
     return WL_ERROR_ARGUMENT;
+  }
   if (getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_WAIT
     || getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_RESPONSE)
     return WL_ERROR_XBEE_COMMAND; // can't do command right now
   WL_DEBUG_PRINT_P("setting channel:");
   WL_DEBUG_PRINT_HEX(channel);
   WL_DEBUG_PRINT_P("\r\n");
   int16_t i=0;
   // change status to command wait
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_WAIT);
   xbee_send_modify_at_command((uint8_t*)"CH",&channel,1); // send command to set the channel
   // wait for up to 30 ms
   while(getStatus(XBEE_COMMAND_MASK) != XBEE_COMMAND_RESPONSE && i++ < 10000) {
     delay_us(1); // wait 3us
+  }
   if (i < 1000 && xbee_command[0] == 'C' && xbee_command[1] == 'H')
     i = WL_SUCCESS;
   else
     i = WL_ERROR_XBEE_COMMAND; // set error code
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // reset status
   return (int8_t)i; // return
+}
 /**
  * Returns the channel which the XBee is currently using.
+ *
  * @return the channel the XBee is using
+ *
  * @see xbee_set_channel
  **/
 int8_t xbee_get_channel(void)
+{
   if (getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_WAIT
     || getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_RESPONSE)
     return WL_ERROR_XBEE_COMMAND; // can't do command right now
   int16_t i=0;
   // change status to command wait
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_WAIT);
   xbee_send_read_at_command((uint8_t*)"CH"); // send command to get the channel
   // wait for up to 30 ms
   while(getStatus(XBEE_COMMAND_MASK) != XBEE_COMMAND_RESPONSE && i++ < 10000) {
     delay_us(1); // wait 3us
+  }
   if (i < 1000 && xbee_command[0] == 'C' && xbee_command[1] == 'H')
     i = (int8_t)xbee_command[2]; // get channel
   else
     i = WL_ERROR_XBEE_COMMAND; // set error code
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // reset status
   WL_DEBUG_PRINT_P("got channel:");
   WL_DEBUG_PRINT_HEX((uint8_t)i);
   WL_DEBUG_PRINT_P("\r\n");
   return i; // return
+}
 /**
  * Get the 16-bit address of the XBee.
  * This is used to specify who to send messages to
  * and who messages are from.
+ *
  * @return the 16-bit address of the XBee.
  **/
 uint16_t xbee_get_address(void)
+{
   if (getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_WAIT
     || getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_RESPONSE)
     return WL_ERROR_XBEE_COMMAND_16BIT; // can't do command right now
   uint16_t i=0;
   // change status to command wait
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_WAIT);
   xbee_send_read_at_command((uint8_t*)"MY"); // send command to get the address
   // wait for up to 30 ms
   while(getStatus(XBEE_COMMAND_MASK) != XBEE_COMMAND_RESPONSE && i++ < 10000) {
     delay_us(1); // wait 3us
+  }
   if (i < 1000 && xbee_command[0] == 'M' && xbee_command[1] == 'Y') {
     i = (xbee_command[2]<<8)|xbee_command[3]; // do ntoh16 coversion
   } else
     i = WL_ERROR_XBEE_COMMAND_16BIT; // set error code
   setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // reset status
   WL_DEBUG_PRINT_P("got MY address:");
   WL_DEBUG_PRINT_HEX((i&0xFF00)>>8);
   WL_DEBUG_PRINT_HEX((i&0x00FF));
   WL_DEBUG_PRINT_P("\r\n");
   return i; // return
+}
 /**@} **/ // end xbee group