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

Revision 1604

Added by David Schultz over 14 years ago

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

     // 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;
+    }
     /**

Also available in: Unified diff

Project

General

Profile

Colony

Revision 1604