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

Revision 1601

Added by David Schultz over 14 years ago

wireless: more xbee.c updates

      * @author Colony Project, CMU Robotics Club
      **/
     #include "xbee.h"
     #include "wl_defs.h"
     #include <string.h>
     #include <avr/interrupt.h>
     #include <time.h>
     // TODO: separate robot and computer code into two xbee.c files
     #ifndef ROBOT
     #include <fcntl.h>
     #include <unistd.h>
     #include <pthread.h>
     #include <errno.h>
     #include <termios.h>
     #else
     #include <serial.h> // TODO: integrate serial xbee functions into this file
     #include <avr/interrupt.h>
     #include "wl_defs.h"
     #include "xbee.h"
     #endif
     // TODO: do we really need stdio and stdlib in the robot code?
     #include <stdio.h>
     #include <stdlib.h>
     #include <string.h>
     /* Internal Function Prototypes */
     /*Internal Function Prototypes*/
     // TODO: convert all int references to int16_t syntax (see stdint.h)
     /*I/O Functions*/
     static int xbee_send(char* buf, int size);
     static int xbee_send_string(char* c);
     /* I/O Functions */
     static int8_t xbee_send(uint8_t* buf, uint16_t size);
     static int8_t xbee_send_string(unsigned char* c);
     #ifndef ROBOT
     static int xbee_read(char* buf, int size);
     #endif
     /*Command Mode Functions
      * Called during initialization.
      */
     /* Command Mode Functions */
     static int xbee_enter_command_mode(void);
     static int xbee_exit_command_mode(void);
     static int xbee_enter_api_mode(void);
-...
     static int xbee_wait_for_string(char* s, int len);
     static int xbee_wait_for_ok(void);
     /*API Mode Functions*/
     static int xbee_handle_packet(char* packet, int len);
     static int xbee_handle_at_command_response(char* command, char result, char* extra, int extraLen);
     /* API Mode Functions */
     static int xbee_handle_packet(uint8_t* packet, uint16_t len);
     static int xbee_handle_at_command_response(uint16_t command, uint8_t result, uint8_t len);
     static int xbee_handle_at_command_response(uint16_t command, uint8_t result, uint8_t len);
     static void xbee_handle_status(char status);
     static int xbee_verify_checksum(char* packet, int len);
     static char xbee_compute_checksum(char* packet, int len);
-...
     int xbee_send_read_at_command(char* command);
     static int xbee_send_modify_at_command(char* command, char* value);
     /*Global Variables*/
     /* 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);
     #ifndef ROBOT
     static char* xbee_com_port = XBEE_PORT_DEFAULT;
     static int xbee_stream;
     static pthread_t* xbee_listen_thread;
     #endif
     /*Global Variables*/
     // array for basic packets
     static uint8_t xbee_basic_buf[PACKET_BUFFER_SIZE];
-...
     static uint8_t other_buf_last = 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
-...
     // external ack handler (wireless_send.c)
     extern void ackhandle(uint8_t num,uint8_t val);
     /**@addtogroup xbee
      * @{ **/
     /*Function Implementations*/
     #ifdef ROBOT
     /**
      * Interrupt for the robot. Adds bytes received from the xbee
      * to the buffer.
-...
+            }
+          }
           // signal handler that command response is done
           xbee_status |= XBEE_COMMAND_RESPONSE;
           xbee_status = (xbee_status&0x3F)|XBEE_COMMAND_RESPONSE;
+        }
         return;
+      }
-...
+      }
     } // end of interrupt
     #else
     // Computer code
     /**
      * Thread that listens to the xbee.
      **/
     static void* listen_to_xbee(void* x)
+    {
     	char c;
     	while (1)
+    	{
     		if (xbee_read(&c, 1) != 0) {
     			WL_DEBUG_PRINT("xbee_read failed.\n");
     			return NULL;
+    		}
     		arrival_buf[buffer_last] = c;
     		int t = buffer_last + 1;
     		if (t == XBEE_BUFFER_SIZE)
     			t = 0;
     		if (t == buffer_first)
+    		{
     			WL_DEBUG_PRINT("Out of space in buffer.\n");
+    		}
     		buffer_last = t;
     		usleep(1000);
+    	}
     	return NULL;
+    }
     #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) {
-...
         *ptr = 0;
       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) {
-...
+      }
     	WL_DEBUG_PRINT("in xbee_init\n");
     #ifdef ROBOT
     	//enable the receiving interrupt
     #ifdef FIREFLY
-...
     #endif
     #endif
     	sei();
     #else
     	xbee_stream = open(xbee_com_port, O_RDWR);
     	if (xbee_stream == -1/* || lockf(xbee_stream, F_TEST, 0) != 0*/)
+    	{
     		WL_DEBUG_PRINT("Failed to open connection to XBee on port ");
     		WL_DEBUG_PRINT_INT(xbee_com_port);
     		WL_DEBUG_PRINT(".\n");
     		return -1;
     	} else {
     	  WL_DEBUG_PRINT("Successfully opened connection to XBee on port ");
     		WL_DEBUG_PRINT_INT(xbee_com_port);
     		WL_DEBUG_PRINT(".\n");
+    	}
     	// set baud rate, etc. correctly
     	struct termios options;
     	tcgetattr(xbee_stream, &options);
     	cfsetispeed(&options, B9600);
     	cfsetospeed(&options, B9600);
     	options.c_iflag &= ~ICRNL;
     	options.c_oflag &= ~OCRNL;
     	options.c_cflag |= (CLOCAL | CREAD);
     	options.c_cflag &= ~PARENB;
     	options.c_cflag &= ~CSTOPB;
     	options.c_cflag &= ~CSIZE;
     	options.c_cflag |= CS8;
     	options.c_lflag &= ~ICANON;
     	options.c_cc[VMIN] = 1;
     	options.c_cc[VTIME] = 50;
     	if (tcsetattr(xbee_stream, TCSANOW, &options))
+    	{
     		WL_DEBUG_PRINT("Error setting attributes.\n");
     		return -1;
+    	}
     	xbee_listen_thread = (pthread_t*)malloc(sizeof(pthread_t));
     	if (xbee_listen_thread == NULL)
+    	{
     		WL_DEBUG_PRINT("Malloc failed.\n");
     		return -1;
+    	}
     	int ret = pthread_create(xbee_listen_thread, NULL, listen_to_xbee, NULL);
     	if (ret)
+    	{
     		WL_DEBUG_PRINT("Failed to create listener thread.\n");
     		return -1;
+    	}
     #endif
     	WL_DEBUG_PRINT("Entering command mode.\r\n");
     	if (xbee_enter_command_mode() != 0) {
         usb_puts("error entering command mode\r\n");
     		return -1;
+    	}
     	WL_DEBUG_PRINT("Entered command mode.\r\n");
       // reset baud rate
-...
       WL_DEBUG_PRINT("\r\n");
       // set baud on xbee
     //#if (XBEE_BAUD == 250000)
     #if (XBEE_BAUD == 115200)
       xbee_send_string("ATBD7\r\n");
       xbee_send_string("ATBD7\r");
     #elif (XBEE_BAUD == 57600)
       xbee_send_string("ATBD6\r\n");
       xbee_send_string("ATBD6\r");
     #elif (XBEE_BAUD == 38400)
       xbee_send_string("ATBD5\r\n");
       xbee_send_string("ATBD5\r");
     #elif (XBEE_BAUD == 19200)
       xbee_send_string("ATBD4\r\n");
       xbee_send_string("ATBD4\r");
     #elif (XBEE_BAUD == 9600)
       // already at this baud rate
       //xbee_send_string("ATBD3\r\n");
     #else
       WL_DEBUG_PRINT("undefined baud rate\r\n");
       return WL_ERROR_BAUD;
     #endif
       // exit command mode
       xbee_wait_for_ok();
       WL_DEBUG_PRINT("got ok from baud reset\r\n");
       xbee_send_string("ATCN\r\n");
       xbee_send_string("ATCN\r");
       xbee_wait_for_ok();
       WL_DEBUG_PRINT("got ok from exiting command mode\r\n");
       // set UART baud
     #if (XBEE_BAUD == 250000)
     #if (XBEE_BAUD == 115200)
       UBRR1H = 0x00;
       UBRR1L = 3;
       UCSR1A |= _BV(U2X1);
     #elif (XBEE_BAUD == 115200)
       UBRR1H = 0x00;
       UBRR1L = 8;
       UCSR1A |= _BV(U2X1);
     #elif (XBEE_BAUD == 57600)
-...
       UBRR1H = 0x00;
       UBRR1L = 103;
       UCSR1A |= _BV(U2X1);*/
     #else //Baud rate is defined in the header file, we should not get here
       return 0;
     #else
       WL_DEBUG_PRINT("undefined baud rate\r\n");
       return WL_ERROR_BUAD;
     #endif
       delay_ms(50);
-...
     	WL_DEBUG_PRINT("Left command mode.\r\n");
       // get baud rate
     	if (xbee_send_read_at_command("BD")) {
         WL_DEBUG_PRINT("can't send BD command\r\n");
     		return -1;
+    	}
     	WL_DEBUG_PRINT("Getting ATBD rate.\n");
       // TODO: we should set the MY address to the robot address from eeprom
       // get MY address
     	if (xbee_send_read_at_command("MY")) {
         WL_DEBUG_PRINT("can't send my command\r\n");
     		return -1;
+    	}
     	WL_DEBUG_PRINT("Getting ATMY address.\n");
     #ifndef ROBOT
     	int i;
     	for (i = 0; xbee_address == 0 && i < XBEE_GET_PACKET_TIMEOUT; i++) {
     	  ret = xbee_get_packet(NULL);
     	  usleep(1000);
     /* 	  if (ret == -1) { */
     /* 	    WL_DEBUG_PRINT("xbee_get_packet(NULL) failed.\n"); */
     /* 	    return -1; */
     /* 	  } */
+    	}
     #else
     	//wait to return until the address is set
       //TODO: this shouldn't wait indefinitely.  There should be some sort of reasonable timeout
       // so if the address is never set right, an error can be returned instead of having the
       // robot hang forever
     	while (xbee_address == 0) {
     	  xbee_get_packet(NULL);
+    	}
     #endif
     	WL_DEBUG_PRINT("Got ATMY address.\n");
     #ifndef ROBOT
     	if (i == XBEE_GET_PACKET_TIMEOUT) { // We timed-out.
     	  WL_DEBUG_PRINT("xbee_get_packet timed out.\n");
     	  return -1;
     	} else {
     	  return 0;
+    	}
     #else
     	return 0;
     #endif
     	return WL_SUCCESS;
+    }
     /**
      * Call when finished using the XBee library. This releases
      * all sued resources.
      * Call when finished using the XBee library.
      **/
     void xbee_terminate()
+    {
     	#ifndef ROBOT
     	pthread_cancel(*xbee_listen_thread);
         pthread_join(*xbee_listen_thread, NULL);
     	free(xbee_listen_thread);
     	lockf(xbee_stream, F_ULOCK, 0);
     	close(xbee_stream);
       #else
       xbee_exit_api_mode();
     	#endif
+    }
     /**
-...
      **/
     static int8_t xbee_enter_command_mode()
+    {
     	if (xbee_send_string("+++") != 0) {
     		return -1;
     	if (xbee_send_string("+++") != WL_SUCCESS) {
     		return WL_ERROR_XBEE_COMMAND;
+    	}
     	if (xbee_wait_for_ok() != 0) {
     	  return -1;
     	if (xbee_wait_for_ok() != WL_SUCCESS) {
     	  return WL_ERROR_XBEE_COMMAND;
+    	}
     	  return 0;
     	return WL_SUCCESS;
+    }
     /**
-...
           WL_DEBUG_PRINT("\r\n");
           return -1;
+        }
         // clear response
         xbee_status = xbee_status&0x3F;
+      }
     	return 0;
-...
           i=strcspn(xbee_basic_buf,"\r");
           if (i<PACKET_BUFFER_SIZE) {
             memcpy(s,xbee_basic_buf,i);
             xbee_status = xbee_status&0x3F; // clear response
             return 0;
+          }
           else
-...
       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.)
-...
      * @return 0 if the checksum is incorrect, nonzero
      * otherwise
      **/
     int xbee_verify_checksum(char* packet, int len)
     uint8_t xbee_verify_checksum(uint8_t* packet, uint16_t len)
+    {
     	unsigned char sum = 0;
     	int i;
     	for (i = 3; i < len; i++)
     		sum += (unsigned char)packet[i];
     	return sum == 0xFF;
     	uint8_t sum = 0;
     	while(--len > 0) {
     		sum += packet[len];
+      }
       sum += packet[0];
     	return (sum == 0xFF);
+    }
     /**
-...
+    }
     /**
      * Reads a packet received from the XBee. This function
      * is non-blocking. The resulting packet is stored in dest.
      * Only returns transmission response packets and
      * received packets. The returned packet does not include
      * header information or the checksum. This method also
      * handles special packets dealt with by the XBee library,
      * and so should be called frequently while the XBee is in
      * use.<br><br>
+     *
      * The first byte of the packet will be either
      * XBEE_TX_STATUS or XBEE_RX to indicated
      * a response to a sent message or a received message,
      * respectively.<br><br>
+     *
      * For a status response packet:<br>
      * The first byte will be XBEE_TX_STATUS.<br>
      * The second byte will be the frame number.<br>
      * The third byte will be the result. 0 indicates success,
      * and nonzero indicates that an error ocurred in
      * transmitting the packet.<br><br>
+     *
      * For a received packet:<br>
      * The first byte will be XBEE_RX.<br>
      * The second and third bytes will be the 16-bit
      * address of the packet's sender.<br>
      * The fourth byte is the signal strength.<br>
      * The fifth byte is 1 if the packet were sent to
      * a specific address, and 2 if it is a broadcast packet.<br><br>
+     *
      * @param dest set to the packet data
      * @return the length of the packet, or -1 if no packet
      * is available
      **/
     int xbee_get_packet(unsigned char* dest)
+    {
          int ret;
     	//start reading a packet with XBEE_FRAME_START
     	if (currentBufPos == 0)
+    	{
     		do
+    		{
     			if (buffer_first == XBEE_BUFFER_SIZE)
     				buffer_first = 0;
     			// check if buffer is empty
     			if (buffer_first == buffer_last) {
             WL_DEBUG_PRINT("buffer empty\r\n");
     				return -1;
+    			}
     		} while (arrival_buf[buffer_first++] != XBEE_FRAME_START);
     		if (buffer_first == XBEE_BUFFER_SIZE) {
     			buffer_first = 0;
+    		}
     		xbee_buf[0] = XBEE_FRAME_START;
     		currentBufPos++;
+    	}
     	int len = -1;
     	if (currentBufPos >= 3) {
     		len = (int)xbee_buf[2] + ((int)xbee_buf[1] << 8);
+    	}
     	while (len == -1 //packet length has not been read yet
     		|| currentBufPos < len + 4)
+    	{
     		if (currentBufPos == 3)
+    		{
     			len = (int)xbee_buf[2] + ((int)xbee_buf[1] << 8);
     			if (len > 120)
+    			{
     				WL_DEBUG_PRINT("Packet too large. Probably error in XBee transmission.\r\n");
     				currentBufPos = 0;
     				return -1;
+    			}
+    		}
     		// check if buffer is empty
     		if (buffer_first == buffer_last) {
           WL_DEBUG_PRINT("Buffer empty 2\r\n");
     			return -1;
+    		}
     		xbee_buf[currentBufPos++] = arrival_buf[buffer_first++];
     		if (buffer_first == XBEE_BUFFER_SIZE) {
     			buffer_first = 0;
+    		}
+    	}
     	currentBufPos = 0;
     	if (!xbee_verify_checksum(xbee_buf, len + 4))
+    	{
     		WL_DEBUG_PRINT("XBee checksum failed.\r\n");
     		return -1;
+    	}
     	//we will take care of the packet
     	ret = xbee_handle_packet(xbee_buf+3, len);
     	if (ret == 1) {
     		return 3;
     	} else if (ret == -1) {
         WL_DEBUG_PRINT("xbee_handle_packet returned -1\r\n");
         return -2;
+      }
     	if (dest == NULL) {
         WL_DEBUG_PRINT("dest buffer is null\r\n");
     		return -1;
+    	}
     	int i;
     	for (i = 3; i < len + 3; i++) {
     		dest[i - 3] = xbee_buf[i];
+    	}
     	return len;
+    }
     /**
      * Handles modem status packets.
+     *
      * @param status the type of status packet received.
-...
      * 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 extra the hex value of the requested register
      * @param extraLen the length in bytes of extra
      * @param len the length in bytes of extra
      **/
     static int xbee_handle_at_command_response(char* command, char result, char* extra, int extraLen)
     static int8_t xbee_handle_at_command_response(uint16_t command, uint8_t result, uint8_t len)
+    {
     	if (result == 1)
+    	{
-...
           WL_DEBUG_PRINT("Invalid Parameter\r\n");
           break;
+        }
         return -1;
         return WL_SUCCESS;
+    	}
     	WL_DEBUG_PRINT("AT");
     	WL_DEBUG_PRINT(command);
     	WL_DEBUG_PRINT(" command was successful.\r\n");
     	if (command[0] == 'I' && command[1] == 'D')
+    	{
     		xbee_panID = xbee_pending_panID;
     		WL_DEBUG_PRINT("PAN ID set to ");
     		WL_DEBUG_PRINT_INT(xbee_panID);
     		WL_DEBUG_PRINT(".\r\n");
     		return 0;
+    	}
     	if (command[0] == 'C' && command[1] == 'H')
+    	{
     		xbee_channel = xbee_pending_channel;
     		WL_DEBUG_PRINT("Channel set to ");
     		WL_DEBUG_PRINT_INT(xbee_channel);
     		WL_DEBUG_PRINT(".\r\n");
     		return 0;
+    	}
       if (command[0] == 'N' && command[1] == 'D')
+    	{
     		WL_DEBUG_PRINT("ND - extra=");
         WL_DEBUG_PRINT(extra);
     		WL_DEBUG_PRINT("\r\n");
     		return 0;
+    	}
       // 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
         // copy command to handler
         xbee_command[0] = (command&0xFF00)>>8;
         xbee_command[1] = command&0x00FF;
         result = basic_buf_last;
         for(command=2;command<len+2;command++)
           xbee_command[command] = xbee_basic_buf_get(&result);
         break;
       default:
         WL_DEBUG_PRINT("unknown AT command");
+      }
        if (command[0] == 'B' && command[1] == 'D')
+    	{
     		WL_DEBUG_PRINT("BD - extra=");
         WL_DEBUG_PRINT(extra);
     		WL_DEBUG_PRINT("\r\n");
     		return 0;
+    	}
       // signal handler that command response is done
       xbee_status = (xbee_status&0x3F)|XBEE_COMMAND_RESPONSE;
     	if (command[0] == 'M' && command[1] == 'Y' && extraLen != 0)
+    	{
     		xbee_address = 0;
     		int i;
     		for (i = 0; i < extraLen; i++) {
     			xbee_address = (xbee_address << 8) + extra[i];
+    		}
     		WL_DEBUG_PRINT("XBee address is ");
     		WL_DEBUG_PRINT_INT(xbee_address);
     		WL_DEBUG_PRINT(".\r\n");
     		if (xbee_address == 0)
+    		{
     			WL_DEBUG_PRINT("XBee 16-bit address must be set using ATMY.\r\n");
     			#ifndef ROBOT
     			exit(0);
     			#endif
+    		}
+    	}
       return 0;
       return WL_SUCCESS;
+    }
     /**
-...
         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 the 16-bit address of the XBee.
      **/
     uint16_t xbee_get_address()
     uint16_t xbee_get_address(void)
+    {
       if (xbee_status&0xC0 == XBEE_COMMAND_WAIT
         || xbee_status&0xC0 == XBEE_COMMAND_RESPONSE)

Also available in: Unified diff

Project

General

Profile

Colony

Revision 1601