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

Revision 1600

Added by David Schultz over 14 years ago

wireless: xbee update. still not finished, but the major changes are in here. Also added a function for microsecond delays to time.c

     static pthread_t* xbee_listen_thread;
     #endif
     // TODO: clarify buffers, what they're used for, etc
     // a buffer for data received from the XBee
     char arrival_buf[XBEE_BUFFER_SIZE];
     // location of last unread byte in buffer
     volatile int buffer_last = 0;
     // first unread byte in buffer
     volatile int buffer_first = 0;
     // old xbee buf
     static char xbee_buf[PACKET_BUFFER_SIZE];
     static int currentBufPos = 0;
     // array for basic packets
     static uint8_t xbee_basic_buf[PACKET_BUFFER_SIZE];
-...
     // aka, the first free byte in other buffer
     static uint8_t other_buf_last = 0;
     //XBee status
     static unsigned int xbee_panID = XBEE_PAN_DEFAULT;
     static unsigned int xbee_pending_panID = XBEE_PAN_DEFAULT;
     static int xbee_channel = XBEE_CHANNEL_DEFAULT;
     static int xbee_pending_channel = XBEE_CHANNEL_DEFAULT;
     static volatile unsigned int xbee_address = 0;
     // TODO: do we need these?
     static uint16_t xbee_panID = XBEE_PAN_DEFAULT;
     static uint8_t xbee_channel = XBEE_CHANNEL_DEFAULT;
     static uint16_t xbee_address = 0;
     // xbee status
     #define XBEE_API_OFF 0x0
     #define XBEE_API_ON 0x1
     #define XBEE_API_ESCAPE 0x2
     #define XBEE_NORMAL 0x00
     #define XBEE_COMMAND_WAIT 0x80
     #define XBEE_COMMAND_RESPONSE 0xC0
     static uint8_t xbee_status = XBEE_API_OFF|XBEE_NORMAL;
     // xbee command response (for PAN, channel, address, etc)
     static uint8_t xbee_command[4];
     // external ack handler (wireless_send.c)
     extern void ackhandle(uint8_t num,uint8_t val);
     /**@addtogroup xbee
      * @{ **/
     /*Function Implementations*/
     #ifdef ROBOT
-...
     	uint8_t apitype = PORT; // get frame start byte
       uint16_t i=0;
       uint16_t len=0;
       // check that we're in API mode
       if (xbee_status&0x03 == XBEE_API_OFF || apitype != XBEE_FRAME_START) {
         // not in API mode
         if (xbee_status&0xC0) == XBEE_COMMAND_WAIT) {
           // get rest of command and put in basic buf
           xbee_basic_buf[0] = 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;
+              }
+            }
+          }
           // signal handler that command response is done
           xbee_status |= XBEE_COMMAND_RESPONSE;
+        }
         return;
+      }
       // get length and type
       while(i<3) {
         if (FLAG) {
-...
       // do something based on the type
       i=1;
       switch(apitype) {
       case 0x88:
       case XBEE_FRAME_AT_COMMAND_RESPONSE:
         // AT command response
         if (xbee_status&0xC0 == XBEE_COMMAND_RESPONSE)
           return; // we're currently processing a command, so drop the incoming one
         uint16_t atcommand=0;
         uint8_t ptr=basic_buf_last;
         while(i<len) {
-...
               apitype = PORT; // get status
             else {
               // put the command response on the basic buf temporarily
               if (ptr == basic_buf_first) {
                 // buffer full
                 WL_DEBUG_PRINT("basic buffer full\r\n");
               if (xbee_basic_buf_add(&ptr,PORT) != 0)
                 break;
+              }
               xbee_basic_buf[ptr++]=PORT;
               if (ptr == PACKET_BUFFER_SIZE)
                 ptr = 0;
+            }
             i++;
+          }
+        }
         // handle AT command
         xbee_handle_at_command_response(atcommand,apitype,xbee_basic_buf+basic_buf_last,len-5);
+        }
         // handle AT command
         xbee_handle_at_command_response(atcommand,apitype,i-5); // TODO: rewrite function
         break;
       case 0x89:
       case XBEE_FRAME_TX_STATUS:
         // TX status
         uint8_t frameid=0;
         while(i<len) {
-...
+          }
+        }
         break;
       case 0x80:
       case XBEE_FRAME_RX_64:
         // receive a packet with 64bit address
         break; // not implemented yet
       case 0x81:
         break; // TODO: implement this (even if we don't use it)
       case XBEE_FRAME_RX_16:
         // receive a packet with 16bit address
         uint16_t source = 0;
         uint8_t framenum = 0;
-...
               if (group == 0) {
                 ptr = basic_buf_last+1;
                 // add source to buffer
                 if (ptr == basic_buf_first) {
                   // buffer full
                   WL_DEBUG_PRINT("basic buffer full\r\n");
                 if (xbee_basic_buf_add(&ptr,(uint8_t)((source&0xFF00)>>8)) != 0)
                   break;
+                }
                 xbee_basic_buf[ptr++] = (uint8_t)((source&0xFF00)>>8);
                 if (ptr == PACKET_BUFFER_SIZE)
                   ptr = 0;
                 if (ptr == basic_buf_first) {
                   // buffer full
                   WL_DEBUG_PRINT("basic buffer full\r\n");
                 if (xbee_basic_buf_add(&ptr,(uint8_t)(source&0x00FF)) != 0)
                   break;
+                }
                 xbee_basic_buf[ptr++] = (uint8_t)(source&0x00FF);
                 if (ptr == PACKET_BUFFER_SIZE)
                   ptr = 0;
               } else {
                 ptr = other_buf_last+1;
                 // add source and group to buffer
                 if (ptr == other_buf_first) {
                   // buffer full
                   WL_DEBUG_PRINT("other buffer full\r\n");
                 // add source and group to buffer
                 if (xbee_other_buf_add(&ptr,group) != 0)
                   break;
+                }
                 xbee_other_buf[ptr++] = group;
                 if (ptr == PACKET_BUFFER_SIZE)
                   ptr = 0;
                 if (ptr == other_buf_first) {
                   // buffer full
                   WL_DEBUG_PRINT("other buffer full\r\n");
                 if (xbee_other_buf_add(&ptr,(uint8_t)((source&0xFF00)>>8)) != 0)
                   break;
+                }
                 xbee_other_buf[ptr++] = (uint8_t)((source&0xFF00)>>8);
                 if (ptr == PACKET_BUFFER_SIZE)
                   ptr = 0;
                 if (ptr == other_buf_first) {
                   // buffer full
                   WL_DEBUG_PRINT("other buffer full\r\n");
                 if (xbee_other_buf_add(&ptr,(uint8_t)(source&0x00FF)) != 0)
                   break;
+                }
                 xbee_other_buf[ptr++] = (uint8_t)(source&0x00FF);
                 if (ptr == PACKET_BUFFER_SIZE)
                   ptr = 0;
+              }
+            }
             else {
             else { // TODO: handle escaped characters supported by APIv2
               // put packet data on the correct buffer
               if (group == 0) {
                 if (ptr == basic_buf_first) {
                   // buffer full
                   WL_DEBUG_PRINT("basic buffer full\r\n");
                   break;
+                }
                 xbee_basic_buf[ptr++]=PORT;
                 if (ptr == PACKET_BUFFER_SIZE)
                   ptr = 0;
               } else {
                 if (ptr == other_buf_first) {
                   // buffer full
                   WL_DEBUG_PRINT("other buffer full\r\n");
                   break;
+                }
                 xbee_other_buf[ptr++]=PORT;
                 if (ptr == PACKET_BUFFER_SIZE)
                   ptr = 0;
+              }
               if (group == 0 && xbee_basic_buf_add(&ptr,PORT) != 0)
                 break;
               else if (xbee_other_buf_add(&ptr,PORT) != 0)
                 break;
+            }
             i++;
+          }
+        }
         if (ptr != 0xFF) {
         if (ptr != 0xFF && i > 6) {
           if (group == 0) {
             xbee_basic_buf[basic_buf_last] = i-6; // set length
             basic_buf_last = ptr;
-...
+          }
+        }
         break;
       } // end of switch statement
       while (1) {
         if (FLAG) {
           apitype = PORT; // get checksum, and ignore
           break;
+        }
+      }
     } // end of interrupt
-...
     #endif
     /* 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("basic buffer full\r\n");
         return -1;
+      }
       xbee_basic_buf[(*ptr)++] = byte);
       if (*ptr == PACKET_BUFFER_SIZE)
         *ptr = 0;
       return 0;
+    }
     /* 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("other buffer full\r\n");
         return -1;
+      }
       xbee_other_buf[(*ptr)++] = byte;
       if (ptr == PACKET_BUFFER_SIZE)
         *ptr = 0;
       return 0;
+    }
     /**
      * Initializes the XBee library so that other functions may be used.
      **/
     int xbee_lib_init()
     int8_t xbee_lib_init()
+    {
       // do serial.c xbee init     TODO: merge this into xbee.c
       if (xbee_init() != 0) {
         usb_puts("xbee_init error");
         return -1;
         return WL_ERROR_INIT_FAILED;
+      }
     	WL_DEBUG_PRINT("in xbee_init\n");
-...
     	WL_DEBUG_PRINT("Left command mode.\r\n");
       // get MY address
       // get baud rate
     	if (xbee_send_read_at_command("BD")) {
         WL_DEBUG_PRINT("can't send BD command\r\n");
     		return -1;
-...
      * @param buf the buffer of data to send
      * @param size the number of bytes to send
      **/
     static int xbee_send(char* buf, int size)
     static int8_t xbee_send(uint8_t* buf, uint16_t size)
+    {
     #ifdef ROBOT
     	int i;
     	for (i = 0; i < size; i++) {
     		xbee_putc(buf[i]);
+    	}
     	while(--size > 0)
     		if (xbee_putc(buf[i]) != WL_SUCCESS)
           return WL_ERROR_SEND;
+    	}
       if (xbee_putc(buf[0]) != WL_SUCCESS)
         return WL_ERROR_SEND;
     	return 0;
     #else
     	int ret = write(xbee_stream, buf, size);
     	//success
     	if (ret == size)
     		return 0;
     	if (ret == -1)
+    	{
     		//interrupted by system signal, probably timer interrupt.
     		//just try again
     		if (errno == 4)
+    		{
     			return xbee_send(buf, size);
+    		}
     		WL_DEBUG_PRINT("Failed to write to xbee\r\n");
     		return -1;
+    	}
     	//write was interrupted after writing ret bytes
     	return xbee_send(buf + ret, size - ret);
     #endif
     	return WL_SUCCESS;
+    }
     /**
-...
+     *
      * @param c the string to send to the XBEE
      **/
     static int xbee_send_string(char* c)
     static int8_t xbee_send_string(unsigned char* c)
+    {
     	return xbee_send(c, strlen(c));
+    }
     #ifndef ROBOT
     static int xbee_read(char* buf, int size)
+    {
     	if (read(xbee_stream, buf, size) == -1) {
     		WL_DEBUG_PRINT("Failed to read from xbee.\r\n");
     		return -1;
+    	}
     	return 0;
+    }
     #endif
     /**
      * Enter into command mode.
      **/
     static int xbee_enter_command_mode()
     static int8_t xbee_enter_command_mode()
+    {
     	if (xbee_send_string("+++") != 0) {
     		return -1;
-...
     /**
      * Exit from command mode.
      **/
     static int xbee_exit_command_mode()
     static int8_t xbee_exit_command_mode()
+    {
     	if (xbee_send_string("ATCN\r") != 0) {
     		return -1;
-...
     		return -1;
+    	}
     	xbee_wait_for_ok();
       xbee_status = (xbee_status&0xFC)|XBEE_API_ON;
     	return 0;
+    }
     /**
      * Enter API mode 2.
      **/
     static int xbee_enter_api_mode2()
+    {
     	if (xbee_send_string("ATAP 2\r") != 0) {
     		return -1;
+    	}
     	xbee_wait_for_ok();
       xbee_status = (xbee_status&0xFC)|XBEE_API_ESCAPE;
     	return 0;
+    }
     /**
      * Exit API mode.
      **/
     static int xbee_exit_api_mode()
-...
     	if (xbee_send_modify_at_command("AP","0") != 0) {
     		return -1;
+    	}
       xbee_status = (xbee_status&0xFC)|XBEE_API_OFF;
     	return 0;
+    }
-...
      * @param s the string to receive
      * @param len the length of the string
      **/
     static int xbee_wait_for_string(char* s, int len)
     static int8_t xbee_wait_for_string(char* s, int len)
+    {
     	char* curr = s;
       unsigned int i=0;
     	while (curr - s < len) {
         WL_DEBUG_PRINT("waiting for string\r\n");
     		// check if buffer is empty
     		if (buffer_last != buffer_first) {
     			char c = arrival_buf[buffer_first++];
     			if (buffer_first == XBEE_BUFFER_SIZE) {
     				buffer_first = 0;
+    			}
           WL_DEBUG_PRINT("buffer char|");
           WL_DEBUG_PRINT_CHAR(c);
           WL_DEBUG_PRINT("|\r\n");
       uint8_t i=0;
       if (xbee_status&0x03 == XBEE_API_OFF) {
         // wait until the response is received (only wait 1 second)
         while(xbee_status&0xC0 != 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("Bad response when waiting for string ");
           WL_DEBUG_PRINT(s);
           WL_DEBUG_PRINT("\r\n");
           return -1;
+        }
+      }
     			if (c == *curr) {
     				curr++;
     			} else {
     #ifndef ROBOT
     			  //return -1; // Computer is less forgiving.
     			  curr = s;
     #else
     			  curr = s;
     #endif
+    			}
     		} // else buffer is empty.
     #ifndef ROBOT
     		usleep(100);
     #endif
+    	}
       if (i >= 10000)
         return -1;
     	return 0;
+    }
     /**
      * Delay until we receive a command response.
      * (either OK\r or some actual value)
+     *
      * 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(char* s, int len) {
       uint8_t i=0;
       if (xbee_status&0x03 == XBEE_API_OFF) {
         // wait until the response is received (only wait 1 second)
         while(xbee_status&0xC0 != XBEE_COMMAND_RESPONSE && i++ < 1000) {
           delay_us(1);
+        }
         // check response
         if (i >= 1000)
           return -1;
         } else {
           i=strcspn(xbee_basic_buf,"\r");
           if (i<PACKET_BUFFER_SIZE) {
             memcpy(s,xbee_basic_buf,i);
             return 0;
+          }
           else
             return -1;
+        }
+      }
       // TODO: do something for API mode
       return 0;
+    }
     /**
      * Verifies that the packets checksum is correct.
      * (If the checksum is correct, the sum of the bytes
      * is 0xFF.)
-...
      * @return the checksum of the packet, which will
      * become the last byte sent in the packet
      **/
     char xbee_compute_checksum(char* buf, int len)
     char xbee_compute_checksum(uint8_t* buf, uint16_t len)
+    {
     	int i;
     	unsigned char sum = 0;
     	for (i = 0; i < len; i++)
     		sum += (unsigned char)buf[i];
     	uint8_t sum = 0;
     	while(--len > 0) {
     		sum += buf[len];
+      }
       sum += buf[0];
     	return 0xFF - sum;
+    }
-...
      * @param len the size in bytes of the packet data
+     *
      **/
     static int xbee_send_frame(char* buf, int len)
     static int8_t xbee_send_frame(uint8_t* buf, uint16_t len)
+    {
     	char prefix[3];
     	uint8_t prefix[3];
     	prefix[0] = XBEE_FRAME_START;
     	prefix[1] = (len & 0xFF00) >> 8;
     	prefix[2] = len & 0xFF;
     	char checksum = xbee_compute_checksum(buf, len);
     	prefix[2] = len & 0x00FF;
     	uint8_t checksum = xbee_compute_checksum(buf, len);
     	if (xbee_send(prefix, 3) != 0) {
     		return -1;
     		return WL_ERROR_SEND;
+    	}
     	if (xbee_send(buf, len) != 0) {
     		return -1;
     		return WL_ERROR_SEND;
+    	}
     	if (xbee_send(&checksum, 1) != 0) {
     		return -1;
     		return WL_ERROR_SEND;
+    	}
     	return 0;
     	return WL_SUCCESS;
+    }
     /**
-...
      * use ID to read the PAN ID and MY to return the XBee ID.
      * See the XBee reference guide for a complete listing.
      **/
     int xbee_send_read_at_command(char* command)
     int8_t xbee_send_read_at_command(uint8_t* command)
+    {
     	return xbee_send_modify_at_command(command, NULL);
     	return xbee_send_modify_at_command(command, NULL, 0);
+    }
     /**
-...
      * @param value the value to pass as a parameter
      * (or NULL if there is no parameter)
      **/
     static int xbee_send_modify_at_command(char* command, char* value)
     static int8_t xbee_send_modify_at_command(uint8_t* command, uint8_t* value, uint8_t len)
+    {
     	char buf[16];
     	int i;
     	uint8_t buf[12];
     	buf[0] = XBEE_FRAME_AT_COMMAND;
     	buf[1] = 1;
     	buf[2] = command[0];
     	buf[3] = command[1];
     	int valueLen = 0;
     	if (value != NULL)
+    	{
     		valueLen = strlen(value);
     		if (valueLen > 8)
     		if (len > 8)
+    		{
     			WL_DEBUG_PRINT("AT Command too large.\r\n");
     			return -1;
     			return WL_ERROR_ARGUMENT;
+    		}
     		for (i = 0; i < valueLen; i++) {
     			buf[4 + i] = value[i];
+    		}
         memcpy(buf+4,value,len);
+    	}
     	return xbee_send_frame(buf, 4 + valueLen);
     	return xbee_send_frame(buf, 4 + len);
+    }
     /**
-...
+    }
     /**
      * Attempts to handle the packet if it is dealt with
      * by the library.
      * We will handle the following packet types:
      *    Modem Status
      *    AT Command Response
+     *
      * @param packet the packet to handle
      * @param len the length of the packet
+     *
      * @return 1 if we have handled the packet, 0 otherwise
      */
     static int xbee_handle_packet(char* packet, int len)
+    {
     	char command[3] = {1, 2, 3};
     	if (len <= 0) //this should not happend
+    	{
     		WL_DEBUG_PRINT("Non-positive packet length.\r\n");
     		return 0;
+    	}
     	switch ((unsigned char)packet[0]) //packet type
+    	{
     		case XBEE_FRAME_STATUS:
     			xbee_handle_status(packet[1]);
     			return 1;
     		case XBEE_FRAME_AT_COMMAND_RESPONSE:
     			command[0] = packet[2];
     			command[1] = packet[3];
     			command[2] = 0;
     			if (xbee_handle_at_command_response(command, packet[4], packet + 5, len - 5) != 0)
             return -1;
           else
             return 1;
+    	}
     	return 0;
+    }
     /**
      * Sets the personal area network id.
+     *
      * @param id the new personal area network (PAN) id
      **/
     int xbee_set_pan_id(int id)
     int8_t xbee_set_pan_id(uint16_t id)
+    {
     	char s[3];
     	if (xbee_status&0xC0 == XBEE_COMMAND_WAIT
         || xbee_status&0xC0 == XBEE_COMMAND_RESPONSE)
         return WL_ERROR_XBEE_COMMAND; // can't do command right now
       int16_t i=0;
       // change status to command wait
       xbee_status = (xbee_status&0x3F)|XBEE_COMMAND_WAIT;
       xbee_send_modify_at_command("ID",id); // send command to set the channel
       // wait for up to 30 ms
       while(xbee_status&0xC0 != XBEE_COMMAND_RESPONSE && i++ < 10000) {
         delay_us(1); // wait 3us
+      }
       if (i < 1000 && xbee_command[0] == 'O' && xbee_command[1] == 'K') {
         i = WL_SUCCESS;
       else
         i = WL_ERROR_XBEE_COMMAND; // set error code
       xbee_status = xbee_status&0x3F; // reset status
     	return (int8_t)i; // return
     	/* old version
       char s[3];
     	s[0] = (id >> 8) & 0xFF;
     	s[1] = id & 0xFF;
     	s[2] = 0;
     	xbee_pending_panID = id;
     	return xbee_send_modify_at_command("ID", s);
     	return xbee_send_modify_at_command("ID", s); */
+    }
     /**
-...
      * @return the personal area network id, or
      * XBEE_PAN_DEFAULT if it has not yet been set.
      **/
     unsigned int xbee_get_pan_id()
     uint16_t xbee_get_pan_id()
+    {
     	return xbee_panID;
       if (xbee_status&0xC0 == XBEE_COMMAND_WAIT
         || xbee_status&0xC0 == XBEE_COMMAND_RESPONSE)
         return WL_ERROR_XBEE_COMMAND_16BIT; // can't do command right now
       uint16_t i=0;
       // change status to command wait
       xbee_status = (xbee_status&0x3F)|XBEE_COMMAND_WAIT;
       xbee_send_read_at_command("ID"); // send command to get the PAN
       // wait for up to 30 ms
       while(xbee_status&0xC0 != 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]; // get PAN
       else
         i = WL_ERROR_XBEE_COMMAND_16BIT; // set error code
       xbee_status = xbee_status&0x3F; // reset status
     	return i; // return
+    }
     /**
-...
+     *
      * @see xbee_get_channel
      **/
     int xbee_set_channel(int channel)
     int8_t xbee_set_channel(uint8_t channel)
+    {
     	if (channel < 0x0B || channel > 0x1A)
+    	{
-...
     		return -1;
+    	}
     	char s[3];
     	s[0] = channel & 0xFF;
     	s[1] = 0;
     	xbee_pending_channel = channel;
     	return xbee_send_modify_at_command("CH", s);
     	if (xbee_status&0xC0 == XBEE_COMMAND_WAIT
         || xbee_status&0xC0 == XBEE_COMMAND_RESPONSE)
         return WL_ERROR_XBEE_COMMAND; // can't do command right now
       int16_t i=0;
       // change status to command wait
       xbee_status = (xbee_status&0x3F)|XBEE_COMMAND_WAIT;
       xbee_send_modify_at_command("CH",channel); // send command to set the channel
       // wait for up to 30 ms
       while(xbee_status&0xC0 != XBEE_COMMAND_RESPONSE && i++ < 10000) {
         delay_us(1); // wait 3us
+      }
       if (i < 1000 && xbee_command[0] == 'O' && xbee_command[1] == 'K') {
         i = WL_SUCCESS;
       else
         i = WL_ERROR_XBEE_COMMAND; // set error code
       xbee_status = xbee_status&0x3F; // reset status
     	return (int8_t)i; // return
+    }
     /**
-...
+     *
      * @see xbee_set_channel
      **/
     int xbee_get_channel(void)
     int8_t xbee_get_channel(void)
+    {
     	return xbee_channel;
       if (xbee_status&0xC0 == XBEE_COMMAND_WAIT
         || xbee_status&0xC0 == XBEE_COMMAND_RESPONSE)
         return WL_ERROR_XBEE_COMMAND; // can't do command right now
       int16_t i=0;
       // change status to command wait
       xbee_status = (xbee_status&0x3F)|XBEE_COMMAND_WAIT;
       xbee_send_read_at_command("ID"); // send command to get the channel
       // wait for up to 30 ms
       while(xbee_status&0xC0 != XBEE_COMMAND_RESPONSE && i++ < 10000) {
         delay_us(1); // wait 3us
+      }
       if (i < 1000 && xbee_command[0] == 'C' && xbee_command[1] == 'H') {
         i = xbee_command[2]; // get channel
       else
         i = WL_ERROR_XBEE_COMMAND; // set error code
       xbee_status = xbee_status&0x3F; // reset status
     	return i; // return
+    }
     /**
-...
+     *
      * @return the 16-bit address of the XBee.
      **/
     unsigned int xbee_get_address()
     uint16_t xbee_get_address()
+    {
     	return xbee_address;
       if (xbee_status&0xC0 == XBEE_COMMAND_WAIT
         || xbee_status&0xC0 == XBEE_COMMAND_RESPONSE)
         return WL_ERROR_XBEE_COMMAND_16BIT; // can't do command right now
       uint16_t i=0;
       // change status to command wait
       xbee_status = (xbee_status&0x3F)|XBEE_COMMAND_WAIT;
       xbee_send_read_at_command("MY"); // send command to get the address
       // wait for up to 30 ms
       while(xbee_status&0xC0 != 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]; // get address
       else
         i = WL_ERROR_XBEE_COMMAND_16BIT; // set error code
       xbee_status = xbee_status&0x3F; // reset status
     	return i; // return
+    }
     #ifndef ROBOT
     void xbee_set_com_port(char* port)
+    {
     	xbee_com_port = port;
+    }
     #endif
     /**@} **/ // end xbee group

Also available in: Unified diff

Project

General

Profile

Colony

Revision 1600