/ - Diff - Colony - Robotics Club

Revision 1604

Added by David Schultz over 14 years ago

wireless: software retransmit done. serial functions moved to xbee.c

     #endif
     #ifdef USE_STDIO
     #include <stdio.h>
     /**
      * For use with fprintf() and related stdio functions
      **/
     FILE *xbee_fd;
     #endif
     uint8_t xbee_initd=0;
     /**
      * Initializes communication over the XBee.
      * This must be called before any other xbee function
      * may be used.
      **/
     int xbee_init() {
       if(xbee_initd) {
         return ERROR_INIT_ALREADY_INITD;
+      }
       //Set baud rate
       // - 115200 (both wired and wireless) is UBRR=8, U2X=1
       // - 9600 is U2X =1, UBRR = 107.
     #if (XBEE_BAUD == 115200)
       UBRR1H = 0x00;
       UBRR1L = 8;
       UCSR1A |= _BV(U2X1);
     #elif (XBEE_BAUD == 9600)
       UBRR1H = 0x00;
       UBRR1L = 103;
       UCSR1A |= _BV(U2X1);
     #else //Baud rate is defined in the header file, we should not get here
       return 0;
     #endif
       //Enable receiver and transmitter
       UCSR1B |= (1<<RXEN1)|(1<<TXEN1);
       // Set frame format: 8data, 1stop bit, asynchronous normal mode
       UCSR1C |= (1<<UCSZ10) | (1<<UCSZ11);
       // if we have enabled the stdio stuff, then we init it here
     #ifdef USE_STDIO
       /* Open the stdio stream corresponding to this port */
       xbee_fd = fdevopen(xbee_putc, xbee_getc);
     #endif
       xbee_initd = 1;
       return 0;
+    }
     /**@brief The port to use the XBee from on the computer. **/
     #ifndef ROBOT
     #define XBEE_PORT_DEFAULT "/dev/ttyUSB1"
     #endif
     /**@brief Set the com port on a computer, undefined on the robot**/
     void xbee_set_com_port(char* port);
     #define XBEE_GET_PACKET_TIMEOUT 1000
     #ifndef ROBOT

     /**@brief init_flag when library has been initialized **/
     #define INIT_YES UINT8_C(1)
     /**@brief numer of reliable sending retries **/
     #define NUM_RETRIES UINT8_C(3)
     /**@} **/ // end defines group
     /**

     // aka, the first free byte in other buffer
     static uint8_t other_buf_last = 0;
     // xbee status
     #define XBEE_API_OFF 0x0
     #define XBEE_API_ON 0x1
-...
     #define XBEE_NORMAL 0x00
     #define XBEE_COMMAND_WAIT 0x80
     #define XBEE_COMMAND_RESPONSE 0xC0
     #define XBEE_INITD 0x08
     static uint8_t xbee_status = XBEE_API_OFF|XBEE_NORMAL;
     // xbee command response (for PAN, channel, address, etc)
-...
     } // 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) {
-...
     /**
      * Initializes the XBee library so that other functions may be used.
      **/
     int8_t xbee_lib_init()
     int8_t xbee_init()
+    {
       // do serial.c xbee init     TODO: merge this into xbee.c
       if (xbee_init() != 0) {
         usb_puts("xbee_init error");
         return WL_ERROR_INIT_FAILED;
     	WL_DEBUG_PRINT("in xbee_init\n");
       if(xbee_status&0x08 == XBEE_INITD) {
         return WL_ERROR_INIT_ALREADY_INITD;
+      }
     	WL_DEBUG_PRINT("in xbee_init\n");
     	//enable the receiving interrupt
       // 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
     	UCSR0B |= _BV(RXCIE) | _BV(RXEN);
       UCSR0A |= (1<<U2X0);
       UBRR0H = 0x00;
       UBRR0L = 103;
       UCSR0C |= (1<<UCSZ00) | (1<<UCSZ01);
     	UCSR0B |= (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE0);
     #else
     #ifdef BAYBOARD
     	UCSR1B |= _BV(RXCIE1);
     #else
     	UCSR1B |= _BV(RXCIE);
       // Bayboard or robot
       UCSR1A |= (1<<U2X1);
       UBRR1H = 0x00;
       UBRR1L = 103;
       UCSR1C |= (1<<UCSZ10) | (1<<UCSZ11);
     	UCSR1B |= (1<<RXEN1) | (1<<TXEN1) | (1<<RXCIE1);
     #endif
     #endif
     	sei();
     	WL_DEBUG_PRINT("Entering command mode.\r\n");
-...
       WL_DEBUG_PRINT("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("undefined baud rate\r\n");
       return WL_ERROR_BUAD;
     #endif
     #else // Bayboard or robot
     #if (XBEE_BAUD == 115200)
       UBRR1H = 0x00;
       UBRR1L = 8;
       UCSR1A |= _BV(U2X1);
     #elif (XBEE_BAUD == 57600)
       UBRR1H = 0x00;
       UBRR1L = 16;
       UCSR1A |= _BV(U2X1);
     #elif (XBEE_BAUD == 38400)
       UBRR1H = 0x00;
       UBRR1L = 25;
       UCSR1A |= _BV(U2X1);
     #elif (XBEE_BAUD == 19200)
       UBRR1H = 0x00;
       UBRR1L = 51;
       UCSR1A |= _BV(U2X1);
     #elif (XBEE_BAUD == 9600)
       /* this is the default baud rate, so do nothing
       UBRR1H = 0x00;
       UBRR1L = 103;
       UCSR1A |= _BV(U2X1);*/
       UBRR1L = 103;*/
     #else
       WL_DEBUG_PRINT("undefined baud rate\r\n");
       return WL_ERROR_BUAD;
     #endif
     #endif
       delay_ms(50);
       // enter command mode
-...
       // TODO: we should set the MY address to the robot address from eeprom
       // set status
       xbee_status |= XBEE_INITD;
     	return WL_SUCCESS;
+    }
     /**
      * Call when finished using the XBee library.
      **/
     void xbee_terminate()
     int8_t xbee_terminate()
+    {
       xbee_exit_api_mode();
       if (xbee_exit_api_mode() != WL_SUCCESS) {
         WL_DEBUG_PRINT("xbee termination failed\r\n");
         return WL_ERROR_TERMINATION_FAILED;
+      }
       xbee_status = xbee_status&0xF7; // 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
      **/
     int xbee_putc(char c) {
       if(!(xbee_status&XBEE_INITD))
         return WL_ERROR_LIBRARY_NOT_INITD;
       // 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) {
       if(!(xbee_status&XBEE_INITD))
         return WL_ERROR_LIBRARY_NOT_INITD;
       // 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) {
       if(!(xbee_status&XBEE_INITD))
         return WL_ERROR_LIBRARY_NOT_INITD;
       // 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 a buffer buf of size bytes to the XBee.
+     *
      * @param buf the buffer of data to send
-...
     static int8_t xbee_exit_command_mode()
+    {
     	if (xbee_send_string("ATCN\r") != 0) {
     		return -1;
     		return WL_ERROR_SEND;
+    	}
     	xbee_wait_for_ok();
     	return 0;
     	return WL_SUCCESS;
+    }
     /**
      * Enter API mode.
      **/
     static int xbee_enter_api_mode()
     static int8_t xbee_enter_api_mode()
+    {
     	if (xbee_send_string("ATAP 1\r") != 0) {
     		return -1;
     		return WL_ERROR_SEND;
+    	}
     	xbee_wait_for_ok();
       xbee_status = (xbee_status&0xFC)|XBEE_API_ON;
     	return 0;
     	return WL_SUCCESS;
+    }
     /**
      * Enter API mode 2.
      **/
     static int xbee_enter_api_mode2()
     static int8_t xbee_enter_api_mode2()
+    {
     	if (xbee_send_string("ATAP 2\r") != 0) {
     		return -1;
     		return WL_ERROR_SEND;
+    	}
     	xbee_wait_for_ok();
       xbee_status = (xbee_status&0xFC)|XBEE_API_ESCAPE;
     	return 0;
     	return WL_SUCCESS;
+    }
     /**
      * Exit API mode.
      **/
     static int xbee_exit_api_mode()
     static int8_t xbee_exit_api_mode()
+    {
     	if (xbee_send_modify_at_command("AP","0") != 0) {
     		return -1;
+    	}
     	if (xbee_status&0xC0 == XBEE_COMMAND_WAIT
         || xbee_status&0xC0 == XBEE_COMMAND_RESPONSE)
         return WL_ERROR_XBEE_COMMAND; // can't do command right now
       xbee_status = (xbee_status&0xFC)|XBEE_API_OFF;
     	return 0;
       int16_t i=0;
       // change status to command wait
       xbee_status = (xbee_status&0x3F)|XBEE_COMMAND_WAIT;
       xbee_send_modify_at_command("AP","0",1); // send command
       // 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] == 'A' && xbee_command[1] == 'P') {
         i = WL_SUCCESS;
       else
         i = WL_ERROR_XBEE_COMMAND; // set error code
       xbee_status = (xbee_status&0x3C)|XBEE_API_OFF; // reset status
     	return (int8_t)i; // return
+    }
     /**
-...
     /**
      * Delay until the specified string is received from
      * the XBee. Discards all other XBee data.
      * the XBee.
+     *
      * ********* Robot often hangs here ****************
      * Only works when not in API mode
+     *
      * @param s the string to receive
      * @param len the length of the string
-...
      * @return the checksum of the packet, which will
      * become the last byte sent in the packet
      **/
     char xbee_compute_checksum(uint8_t* buf, uint16_t len)
     uint8_t xbee_compute_checksum(uint8_t* buf, uint16_t len)
+    {
     	uint8_t sum = 0;
     	while(--len > 0) {
-...
+    }
     /**
      * 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
      **/
     static 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];
+    }
     /**
      * 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
+     *
      **/
     static int8_t xbee_send_header(uint8_t type, uint16_t len)
+    {
       //packet prefix
       if (xbee_putc(XBEE_FRAME_START) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_putc((uint8_t)((len & 0xFF00) >> 8)) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_putc((uint8_t)(len & 0x00FF)) != WL_SUCCESS)
         return WL_ERROR_SEND;
     	if (xbee_send(buf, len) != WL_SUCCESS)
     		return WL_ERROR_SEND;
     	if (xbee_putc(checksum) != 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.
-...
      **/
     static int8_t xbee_send_frame(uint8_t* buf, uint16_t len)
+    {
     	uint8_t prefix[3];
     	prefix[0] = XBEE_FRAME_START;
     	prefix[1] = (len & 0xFF00) >> 8;
     	prefix[2] = len & 0x00FF;
     	uint8_t checksum = xbee_compute_checksum(buf, len);
       //packet prefix
       if (xbee_putc(XBEE_FRAME_START) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_putc((uint8_t)((len & 0xFF00) >> 8)) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_putc((uint8_t)(len & 0x00FF)) != WL_SUCCESS)
         return WL_ERROR_SEND;
     	if (xbee_send(prefix, 3) != 0) {
     	if (xbee_send(buf, len) != WL_SUCCESS)
     		return WL_ERROR_SEND;
+    	}
     	if (xbee_send(buf, len) != 0) {
     	if (xbee_putc(checksum) != WL_SUCCESS)
     		return WL_ERROR_SEND;
+    	}
     	if (xbee_send(&checksum, 1) != 0) {
     		return WL_ERROR_SEND;
+    	}
     	return WL_SUCCESS;
+    }
-...
      * the XBee alerts us as to whether or not our message
      * was received.
      **/
     int xbee_send_packet(char* packet, int len, int dest, char options, char frame)
     int8_t xbee_send_packet(uint8_t* packet, uint8_t len, uint16_t dest, uint8_t options, uint8_t frame)
+    {
     	char buf[5];
     	char prefix[3];
     	int i;
     	unsigned char checksum = 0;
     	uint8_t sum = XBEE_FRAME_TX_REQUEST_16;
       uint8_t i = 0;
     	if (len > 100)
+    	{
     		WL_DEBUG_PRINT("Packet is too large.\r\n");
     		return -1;
     		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;
     	//data for sending request
     	buf[0] = XBEE_FRAME_TX_REQUEST_16;
     	buf[1] = frame;
     	buf[2] = (dest >> 8) & 0xFF;
     	buf[3] = dest & 0xFF;
     	buf[4] = options;
     	//packet prefix
       if (xbee_putc(XBEE_FRAME_START) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_putc(0x00) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_putc(len+5) != WL_SUCCESS)
         return WL_ERROR_SEND;
     	//send header for TX request
       if (xbee_putc(XBEE_FRAME_TX_REQUEST_16) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_putc(frame) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_putc((uint8_t)((dest&0xFF00) >> 8)) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_putc((uint8_t)(dest&0x00FF)) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_putc(options) != WL_SUCCESS)
         return WL_ERROR_SEND;
     	//packet prefix, do this here so we don't need an extra buffer
     	prefix[0] = XBEE_FRAME_START;
     	prefix[1] = ((5 + len) & 0xFF00) >> 8;
     	prefix[2] = (5 + len) & 0xFF;
       // send packet
     	if (xbee_send(packet, len) != WL_SUCCESS)
     		return WL_ERROR_SEND;
     	for (i = 0; i < 5; i++)
     		checksum += (unsigned char)buf[i];
     	for (i = 0; i < len; i++)
     		checksum += (unsigned char)packet[i];
     	checksum = 0xFF - checksum;
       // send checksum
     	if (xbee_putc(sum) != WL_SUCCESS)
     		return WL_ERROR_SEND;
     	if (xbee_send(prefix, 3) != 0) {
     		return -1;
+    	}
     	if (xbee_send(buf, 5) != 0) {
     		return -1;
+    	}
     	if (xbee_send(packet, len) != 0) {
     		return -1;
+    	}
     	if (xbee_send((char*)&checksum, 1) != 0) {
     		return -1;
+    	}
     	return 0;
     	return WL_SUCCESS;
+    }
     /**

     /**
      * Definition for wireless library send packet structure
      * byte 1: length of packet
      * byte 1: length of packet (from frame number to end of data)
      * byte 2: frame number
      * byte 3: group code
      * bytes 4-n: data
      * (byte n+1: num retries - only saved locally in sending buffer)
      * bytes 3-n: data (dest, options, frame number, group code, packet)
      * byte n+1: num retries
+     *
      * Definition for ack buffer
      * 2 bit system: 0=still sending
-...
     uint8_t send_buf[PACKET_BUFFER_SIZE]; // sending buffer for retries
     uint8_t send_buf_first = 0; // first byte of data on buffer
     uint8_t send_buf_last = 0; // next free byte on buffer
     uint8_t send_buf_num_packets = 0; // number of packets in sending buffer
     /* private function prototypes */
     void setack(uint8_t num,uint8_t val);
     void ackhandle(uint8_t num,uint8_t val);
     int8_t send_buf_add(uint8_t *ptr, uint8_t byte)
     uint8_t send_buf_get(uint8_t *ptr);
     // the send functions
     /**
-...
      * @return positive packet number for tracking acks, or error code (TBD)
      **/
     int16_t wl_send(uint8_t *data, uint8_t length, uint8_t group, uint8_t scope, uint16_t dest, uint8_t mode) {
       uint8_t packet[length+2];
       uint8_t options = XBEE_OPTIONS_NONE;
       int16_t ret_val = (int16_t)nextframe;
       uint8_t packet[6];
       // build packet
       // build packet header
       packet[0] = nextframe;
       packet[1] = group;
       memcpy(packet+2,data,length);
       packet[1] = (dest&0xFF00)>>8;
       packet[2] = dest&0x00FF;
       packet[3] = XBEE_OPTIONS_NONE;
       packet[4] = nextframe;
       packet[5] = group;
       // set scope
       if (scope == GLOBAL)
         options &= XBEE_OPTIONS_BROADCAST_ALL_PANS;
         packet[3] &= XBEE_OPTIONS_BROADCAST_ALL_PANS;
       else if (scope != PAN) {
         WL_DEBUG_PRINT("Error - bad scope in core send function\r\n");
         return WL_ERROR_SCOPE;
+      }
       // set mode
       if (mode == FAST) {
         options &= XBEE_OPTIONS_DISABLE_RESPONSE;
         ret_val = 0;
         packet[3] &= XBEE_OPTIONS_DISABLE_RESPONSE;
       } else if (mode != RELIABLE) {
         WL_DEBUG_PRINT("Error - bad mode in core send function\r\n");
         return WL_ERROR_MODE;
+      }
       // do checksum
       group = XBEE_FRAME_TX_REQUEST_16;
       xbee_checksum_add(packet,6,&group);
       xbee_checksum_add(data,length,&group);
       group = 0xFF-group;
       // send the packet
       if (xbee_send_packet(packet,length,dest,options,(uint_8)ret_val) != 0) {
         WL_DEBUG_PRINT("Error sending packet from core send function\r\n");
       if (xbee_send_header(XBEE_FRAME_TX_REQUEST_16,length+7) != WL_SUCCESS) {
         WL_DEBUG_PRINT("1Error sending packet from core send function\r\n");
         return WL_ERROR_SEND;
+      }
       if (xbee_putc(XBEE_FRAME_TX_REQUEST_16) != WL_SUCCESS) {
         WL_DEBUG_PRINT("2Error sending packet from core send function\r\n");
         return WL_ERROR_SEND;
+      }
       if (xbee_send(packet,6) != WL_SUCCESS) {
         WL_DEBUG_PRINT("3Error sending packet from core send function\r\n");
         return WL_ERROR_SEND;
+      }
       if (xbee_send(data,length) != WL_SUCCESS) {
         WL_DEBUG_PRINT("4Error sending packet from core send function\r\n");
         return WL_ERROR_SEND;
+      }
       if (xbee_putc(group) != WL_SUCCESS) {
         WL_DEBUG_PRINT("5Error sending packet from core send function\r\n");
         return WL_ERROR_SEND;
+      }
       // save in ack system
       if (mode == FAST) {
         setack(nextframe,ACK_OK); // assume the send was successful
       } else if (mode == RELIABLE) {
         setack(nextframe,SENDING); // set status to SENDING
         // TODO: save packet on sending buffer
         /* if (buffer full) {
         // save packet on sending buffer
         scope = send_buf_last; // use as ptr to send buffer
         if (send_buf_add(&scope,length+6) != WL_SUCCESS) { // add length
           WL_DEBUG_PRINT("Error: sending buffer full\r\n");
           return WL_ERROR_SENDING_BUFFER_FULL
         } */
           return WL_ERROR_SENDING_BUFFER_FULL;
+        }
         for(mode=0;mode<6;mode++) { // add header
           if (send_buf_add(&scope,packet[mode]) != WL_SUCCESS) {
             WL_DEBUG_PRINT("Error: sending buffer full\r\n");
             return WL_ERROR_SENDING_BUFFER_FULL;
+          }
+        }
         for(mode=0;mode<length;mode++) { // add data
           if (send_buf_add(&scope,data[mode]) != WL_SUCCESS) {
             WL_DEBUG_PRINT("Error: sending buffer full\r\n");
             return WL_ERROR_SENDING_BUFFER_FULL;
+          }
+        }
         if (send_buf_add(&scope,0) != WL_SUCCESS) { // add num retries=0
           WL_DEBUG_PRINT("Error: sending buffer full\r\n");
           return WL_ERROR_SENDING_BUFFER_FULL;
+        }
         send_buf_last = scope;
         send_buf_num_packets++;
+      }
       // increment frame number
-...
     /* ack handler */
     void ackhandle(uint8_t num,uint8_t val) {
       uint8_t len;
       switch(val) {
       case 0:
         // success
         setack(num,ACK_OK); // set status code
         // TODO: remove from sending buffer
         // remove from buffer
         val = send_buf_first;
         if (send_buf_num_packets == 0)
           return;
         while (1) {
           len = send_buf_get(&val);
           if (send_buf_get(&val) != num) {
             // not the correct packet, so continue
             val += len;
             if (val >= PACKET_BUFFER_SIZE)
               val -= PACKET_BUFFER_SIZE;
             if (val == send_buf_last) {
               // reached end of bufer, so assume not present
               return;
+            }
           } else {
             // remove packet
             num = val+len;
             val = (val<2)?PACKET_BUFFER_SIZE+val-2:val-2;
             if (num >= PACKET_BUFFER_SIZE)
               num -= PACKET_BUFFER_SIZE;
             while(num != send_buf_last) {
               if (send_buf_add(&val,send_buf_get(&num)) != WL_SUCCESS)
                 return; // error
+            }
             send_buf_last = val; // set new end of buffer
             return;
+          }
+        }
         break;
       case 1:
         // no ack
         // TODO: check resend attempts
         setack(num,ACK_FAILURE);
         break;
         // check resend attempts
         val = send_buf_first;
         if (send_buf_num_packets == 0)
           return;
         while (1) {
           len = send_buf_get(&val);
           if (send_buf_get(&val) != num) {
             // not the correct packet, so continue
             val += len;
             if (val >= PACKET_BUFFER_SIZE)
               val -= PACKET_BUFFER_SIZE;
             if (val == send_buf_last) {
               // reached end of bufer, so assume not present
               setack(num,ACK_FAILURE); // mark as failed send
               return;
+            }
           } else {
             // check attempts on packet
             num = val+len-1; // set to end of packet
             if (num >= PACKET_BUFFER_SIZE)
               num -= PACKET_BUFFER_SIZE;
             if (send_buf[num] < NUM_RETRIES) {
               val = (val<2)?PACKET_BUFFER_SIZE+val-2:val-2; // set to start of this packet
               // retry sending
               send_buf[num]++; // increment retries
               val = (val==0)?PACKET_BUFFER_SIZE-1:val-1; // go back one byte
               if (xbee_send_header(XBEE_FRAME_TX_REQUEST_16,len+1) != WL_SUCCESS) {
                 WL_DEBUG_PRINT("Error sending packet from ackhandle function\r\n");
                 return;
+              }
               len = XBEE_FRAME_TX_REQUEST_16;
               while(val!=num) {
                 // compute checksum
                 len += send_buf[val];
                 if (xbee_putc(send_buf_get(&val)) != WL_SUCCESS) { // send  byte
                   WL_DEBUG_PRINT("Error sending packet from ackhandle function\r\n");
                   return;
+                }
+              }
               len = 0xFF - len;
               if (xbee_putc(len) != WL_SUCCESS) { // send
                 WL_DEBUG_PRINT("Error sending packet from ackhandle function\r\n");
                 return;
+              }
               return;
             } else {
               // done sending, mark as failed send
               val = (val==0)?PACKET_BUFFER_SIZE-1:val-1; // set to frame num
               setack(send_buf[val],ACK_FAILURE);
               val = (val==0)?PACKET_BUFFER_SIZE-1:val-1; // set to start of this packet
               // remove packet
               while(num != send_buf_last) {
                 if (send_buf_add(&val,send_buf_get(&num)) != WL_SUCCESS)
                   return; // error
+              }
               return;
+            }
+          }
+        }
         break; // shouldn't get here, but just in case
       case 2:
         // CCA failure
         // TODO: check resend attempts
         setack(num,CCA_FAILURE);
         break;
         // check resend attempts
         val = send_buf_first;
         if (send_buf_num_packets == 0)
           return;
         while (1) {
           len = send_buf_get(&val);
           if (send_buf_get(&val) != num) {
             // not the correct packet, so continue
             val += len;
             if (val >= PACKET_BUFFER_SIZE)
               val -= PACKET_BUFFER_SIZE;
             if (val == send_buf_last) {
               // reached end of bufer, so assume not present
               setack(num,CCA_FAILURE); // mark as failed send
               return;
+            }
           } else {
             // check attempts on packet
             num = val+len-1; // set to end of packet
             if (num >= PACKET_BUFFER_SIZE)
               num -= PACKET_BUFFER_SIZE;
             if (send_buf[num] < NUM_RETRIES) {
               val = (val<2)?PACKET_BUFFER_SIZE+val-2:val-2; // set to start of this packet
               // retry sending
               send_buf[num]++; // increment retries
               val = (val==0)?PACKET_BUFFER_SIZE-1:val-1; // go back one byte
               if (xbee_send_header(XBEE_FRAME_TX_REQUEST_16,len+1) != WL_SUCCESS) {
                 WL_DEBUG_PRINT("Error sending packet from ackhandle function\r\n");
                 return;
+              }
               len = XBEE_FRAME_TX_REQUEST_16;
               while(val!=num) {
                 // compute checksum
                 len += send_buf[val];
                 if (xbee_putc(send_buf_get(&val)) != WL_SUCCESS) { // send  byte
                   WL_DEBUG_PRINT("Error sending packet from ackhandle function\r\n");
                   return;
+                }
+              }
               len = 0xFF - len;
               if (xbee_putc(len) != WL_SUCCESS) { // send
                 WL_DEBUG_PRINT("Error sending packet from ackhandle function\r\n");
                 return;
+              }
               return;
             } else {
               // done sending, mark as failed send
               val = (val==0)?PACKET_BUFFER_SIZE-1:val-1; // set to frame num
               setack(send_buf[val],CCA_FAILURE);
               val = (val==0)?PACKET_BUFFER_SIZE-1:val-1; // set to start of this packet
               // remove packet
               while(num != send_buf_last) {
                 if (send_buf_add(&val,send_buf_get(&num)) != WL_SUCCESS)
                   return; // error
+              }
               return;
+            }
+          }
+        }
         break; // shouldn't get here, but just in case
+      }
+    }
     /* adds a byte to the send buffer */
     int8_t send_buf_add(uint8_t *ptr, uint8_t byte) {
       if (*ptr == send_buf_first) {
         // buffer full
         WL_DEBUG_PRINT("send buffer full\r\n");
         return WL_ERROR_SENDING_BUFFER_FULL;
+      }
       send_buf[(*ptr)++] = byte);
       if (*ptr == PACKET_BUFFER_SIZE)
         *ptr = 0;
       return WL_SUCCESS;
+    }
     /* gets a byte from the send buffer */
     uint8_t send_buf_get(uint8_t *ptr) {
       uint8_t byte = xbee_basic_buf[(*ptr)++];
       if (*ptr == PACKET_BUFFER_SIZE)
         *ptr = 0;
       return byte;
+    }

     /**@} */ // end error group
     // TODO: is this a good size?
     /*Buffer sizes*/
     #define PACKET_BUFFER_SIZE	128
     /**@} */ // end wireless group
     #ifdef WL_DEBUG

      /**@defgroup xbee_const xbee constants
       * @brief These are constants used for the xbee module.
       * @{ **/
     // TODO: move constants to xbee.h so they can be used publicly
     /**@brief The port to use the XBee from on the computer. **/
     #ifndef ROBOT
     #define XBEE_PORT_DEFAULT "/dev/ttyUSB1"
     #ifndef XBEE_BAUD
     /** @brief The XBee baud rate **/
     #define XBEE_BAUD 115200
     #endif
     /**@name xbee options
-...
     /** @} **/
     // TODO: is this a good size?
     /*Buffer sizes*/
     #define XBEE_BUFFER_SIZE	128
     #define PACKET_BUFFER_SIZE	108
     /**@} **/ // end const group
     /**
-...
     // TODO: convert all int references to int16_t syntax (see stdint.h)
     /**@brief Initialize the XBee library **/
     int xbee_lib_init(void);
     int8_t xbee_init(void);
     /**@brief Uninitialize the XBee library **/
     void xbee_terminate(void);
     int8_t xbee_terminate(void);
     /**@brief Send a byte to the xbee **/
     int8_t xbee_putc(uint8_t c);
     /**@brief Read a byte form the xbee **/
     int16_t xbee_getc(void);
     /**@brief Read a byte from the xbee (nonblocking) **/
     int8_t xbee_getc_nb(uint8_t *c);
     /**@brief Send an array of bytes to the xbee **/
     int8_t xbee_send(uint8_t* buf, uint16_t size);
     /**@brief Add a buffer to the checksum value **/
     int8_t xbee_checksum_add(uint8_t *buf, uint8_t len, uint8_t* sum);
     /**@brief Send a frame header to the xbee **/
     int8_t xbee_send_header(uint8_t type, uint16_t len);
     /**@brief Send a packet to the XBee **/
     int xbee_send_packet(char* packet, int len, int dest, char options, char frame);
     int8_t xbee_send_packet(uint8_t* packet, uint8_t len, uint16_t dest, uint8_t options, uint8_t frame);
     /**@brief Set the PAN ID for the XBee **/
     int xbee_set_pan_id(int id);
     int16_t xbee_set_pan_id(int id);
     /**@brief Get the XBee's PAN ID **/
     unsigned int xbee_get_pan_id(void);
     uint16_t xbee_get_pan_id(void);
     /**@brief Set the channel the XBee is currently using **/
     int xbee_set_channel(int channel);
     int8_t xbee_set_channel(int channel);
     /**@brief Get the channel the XBee is currently using **/
     int xbee_get_channel(void);
     int8_t xbee_get_channel(void);
     /**@brief Get the XBee's 16-bit address **/
     unsigned int xbee_get_address(void);
     /**@brief Set the com port on a computer, undefined on the robot**/
     void xbee_set_com_port(char* port);
     uint16_t xbee_get_address(void);
     /**@brief Reset XBee **/
     int xbee_reset(void);
     int8_t xbee_reset(void); // TODO: implement this function
     /**@} **/ //end xbee_funcs group

         // reset packet handler array
         memset(wl_packet_handlers, sizeof(PacketGroupHandler)*MAX_PACKET_GROUPS, 0);
         // TODO need pass termination error from lower level functions
         xbee_terminate();
         // if(TERMINATE FAILS) {
         //     return WL_ERROR_TERMINATION_FAILED
         // }
         if(xbee_terminate() != WL_SUCCESS) {
             return WL_ERROR_TERMINATION_FAILED
+        }
         return WL_SUCCESS;
+    }
-...
             return WL_ERROR_LIBRARY_NOT_INITD;
+        }
         // packet group number exceeds available packets groups
         if(group >= MAX_PACKET_GROUPS) {
         // packet group number exceeds available packets groups
         // or packet group handler already exists
         if(group >= MAX_PACKET_GROUPS || group == 0
             || wl_packet_handlers[group].FUNC != NULL) {
             return WL_ERROR_FAILED_REGISTRATION;
+        }
         // packet group handler already exists, user needs to unregister first
         if(wl_packet_handlers[group].FUNC != NULL) {
             return WL_ERROR_FAILED_REGISTRATION;
+        }
         // save packet handler function pointer and priority
         wl_packet_handlers[group].FUNC = FUNC;

     #include "serial.h"
     unsigned char usb_initd=0;
     unsigned char xbee_initd=0;
     #ifdef USE_STDIO
-...
      **/
     FILE *usb_fd;
     /**
      * For use with fprintf() and related stdio functions
      **/
     FILE *xbee_fd;
     #endif
     /**
-...
+    }
     /**
      * Initializes communication over the XBee.
      * This must be called before any other xbee function
      * may be used.
      **/
     int xbee_init() {
       if(xbee_initd) {
         return ERROR_INIT_ALREADY_INITD;
+      }
       //Set baud rate
       // - 115200 (both wired and wireless) is UBRR=8, U2X=1
       // - 9600 is U2X =1, UBRR = 107.
     #if (XBEE_BAUD == 115200)
       UBRR1H = 0x00;
       UBRR1L = 8;
       UCSR1A |= _BV(U2X1);
     #elif (XBEE_BAUD == 9600)
       UBRR1H = 0x00;
       UBRR1L = 103;
       UCSR1A |= _BV(U2X1);
     #else //Baud rate is defined in the header file, we should not get here
       return 0;
     #endif
       //Enable receiver and transmitter
       UCSR1B |= (1<<RXEN1)|(1<<TXEN1);
       // Set frame format: 8data, 1stop bit, asynchronous normal mode
       UCSR1C |= (1<<UCSZ10) | (1<<UCSZ11);
       // if we have enabled the stdio stuff, then we init it here
     #ifdef USE_STDIO
       /* Open the stdio stream corresponding to this port */
       xbee_fd = fdevopen(xbee_putc, xbee_getc);
     #endif
       xbee_initd = 1;
       return 0;
+    }
     /**
      * Sends a character over USB.
+     *
-...
+    }
     /**
      * Sends a character to the XBee.
+     *
      * @param c the character to send
      * @return 0 for success, nonzero for failure
      **/
     int xbee_putc(char c) {
       if(!xbee_initd)
         return ERROR_LIBRARY_NOT_INITD;
       // Wait until buffer is clear for sending
       loop_until_bit_is_set(UCSR1A, UDRE1);
       // Load buffer with your character
       UDR1 = c;
       return 0;
+    }
     /**
      * Sends a sequence of characters over USB.
+     *
      * @param s the string to send
-...
+    }
     /**
      * Returns the first character in the buffer received from USB.
      * 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
      **/
     int xbee_getc(void) {
       if(!usb_initd)
         return -1;
       // Wait for the receive buffer to be filled
       loop_until_bit_is_set(UCSR1A, RXC1);
       // Read the receive buffer
       return UDR1;
+    }
     /**
      * Non blocking version of usb_getc. If a character is present in the buffer,
      * it is returned, otherwise -1 is returned immediately. usb_init must be
      * called before this function can be used.
-...
+      }
+    }
     /**
      * Non blocking version of xbee_getc. If a character 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 character. This will be set if a character has
      * been received.
+     *
      * @return -1 if no character is available, 0 otherwise, positive for error
+     *
      * @see xbee_init, xbee_getc
      **/
     int xbee_getc_nb(char *c) {
       if(!xbee_initd)
         return ERROR_LIBRARY_NOT_INITD;
       // check if the receive buffer is filled
       if (UCSR1A & _BV(RXC1)) {
         // Read the receive buffer
         (*c) = UDR1;
         return 0;
       } else {
         // Return empty
         return -1;
+      }
+    }
     /*
       prints an int to serial

     /** @brief Print a fixed width hexadecimal representation to USB **/
     int usb_puth8(uint8_t value);
     /** @brief Alias for usb_puth16 **/
     static inline void usb_puth (uint16_t value) { usb_puth16 (value); };
     static inline void usb_puth(uint16_t value) { usb_puth16 (value); };
     /** @} **/ //end addtogroup
     /**
      * @defgroup xbee XBee Input / Output
      * @brief Functions for XBee input / output
+     *
      * Low level functions for XBee input and output.
+     *
      * @{
      **/
     // if no baud rate is defined for usb, default is set here
     // if no baud rate is defined for xbee, default is set here
     #ifndef XBEE_BAUD
     /** @brief the XBee baud rate **/
     #define XBEE_BAUD 9600
     #endif
     /** @brief Initialize the XBee **/
     int xbee_init(void);
     /** @brief Print a character to the XBee **/
     int xbee_putc(char c);
     /** @brief Read a character from the XBee **/
     int xbee_getc(void);
     /** @brief Read a character from the XBee without blocking **/
     int xbee_getc_nb(char *c);
     /** @} **/ //end addtogroup
     #endif

Also available in: Unified diff

Project

General

Profile

Colony

Revision 1604