/ - Diff - Colony - Robotics Club

trunk/code/projects/colonet/lib/colonet_wireless/colonet_wireless.cpp
96	96	1 + PACKET_DATA_LEN, 0);
97	97	} else {
98	98	wl_send_robot_to_robot_packet(COLONET_PACKET_GROUP_ID, (char)msg_type,
99		pkt_buffer, 1 + PACKET_DATA_LEN, dest, 0);
	99	pkt_buffer, 1 + PACKET_DATA_LEN, dest,
	100	COLONET_RESPONSE_PACKET_FRAME_ID);
100	101	}
101	102	}
102	103

      * @brief Colonet library for DRAGONFLY colony robots
+     *
      * @author Eugene Marinelli
      * @date 4/17/07
+     *
      * @date 10/10/07
+     *
      * @bug Handler registration not tested
      * @bug Request reponding not implemented - only accepts commands.
      */
     #include <assert.h>
     #include <dragonfly_lib.h>
     #include <string.h>
     #include <wireless.h>
     #include "colonet_dragonfly.h"
     typedef struct {
-...
     static void packet_string_to_struct(ColonetRobotServerPacket* dest_pkt,
                                         char* pkt_buf);
     static unsigned int two_bytes_to_int(char high, char low);
     static void colonet_handle_receive(char type, int source,
                                        unsigned char* packet, int length);
     static PacketGroupHandler colonet_pgh;
     /* Public functions */
     int colonet_handle_message(unsigned char robot_id, char* pkt_buf) {
     int colonet_init() {
       colonet_pgh.groupCode = COLONET_PACKET_GROUP_ID;
       colonet_pgh.timeout_handler = NULL;
       colonet_pgh.handle_response = NULL;
       colonet_pgh.handle_receive = colonet_handle_receive;
       colonet_pgh.unregister = NULL;
       // TODO this should return an error if wl_init has not been called yet.
       wl_register_packet_group(&colonet_pgh);
       return 0;
+    }
     /* Private functions */
     /** @brief Handles colonet packets.  Should be called by parse_buffer
      * when it is determined that a colonet message has been received.
+     *
      * @param robot_id The robot id
      * @param pkt_buf The packet buffer (e.g. wl_buf)
+     *
      * @return -1 on error (invalid msgId), 0 on success
      */
     void colonet_handle_receive(char type, int source, unsigned char* packet,
                                 int length) {
       ColonetRobotServerPacket pkt;
       unsigned char* args; //up to 7 char args
       unsigned int int_args[3]; //up to 3 int (2-byte) args
       packet_string_to_struct(&pkt, pkt_buf);
       printf("received message from %d of length %d\n", source, length);
       if (pkt.msg_dest != GLOBAL_DEST && pkt.msg_dest != robot_id) {
         //message not intended for us
         return 1;
+      }
       assert(length == sizeof(ColonetRobotServerPacket));
       packet_string_to_struct(&pkt, packet);
       args = pkt.data;
       int_args[0] = two_bytes_to_int(args[0], args[1]);
       int_args[1] = two_bytes_to_int(args[2], args[3]);
       int_args[2] = two_bytes_to_int(args[4], args[5]);
       if(pkt.msg_type == COLONET_REQUEST){
       if (type == COLONET_REQUEST) {
         /* TODO - send back data! */
         switch(pkt.msg_code){
         switch (pkt.msg_code) {
           //Sharp
         case READ_DISTANCE:
           break;
-...
         case DETECT_BUMP:
           break;
+        }
       }else if(pkt.msg_type == COLONET_COMMAND){
         if(pkt.msg_code >= USER_DEFINED_MSG_ID_START &&
       } else if (type == COLONET_COMMAND) {
         if(pkt.msg_code >= USER_DEFINED_MSG_ID_START &&
            pkt.msg_code <= USER_DEFINED_MSG_ID_END){
           if (user_handlers[pkt.msg_code - USER_DEFINED_MSG_ID_START].handler) {
             /* Call the user's handler function if it the function's address
              * is non-zero (has been set) */
             user_handlers[pkt.msg_code - USER_DEFINED_MSG_ID_START].handler();
+          }
           return 0;
+        }
         switch(pkt.msg_code){
         default:
           printf("%s: Error - message code %d not implemented\n", __FUNCTION__,
                  pkt.msg_code);
           return -1;
           break;
           //Buzzer
-...
         case BUZZER_OFF:
           buzzer_off();
           break;
           //LCD
         case LCD_INIT:
           lcd_init();
           break;
         case LCD_CLEAR_SCREEN:
           lcd_clear_screen();
           break;
         case LCD_PUTBYTE:
           lcd_putbyte(args[0]);
           break;
         case LCD_PUTCHAR:
           lcd_putchar((char)args[0]);
           break;
         case LCD_PUTSTR:
           lcd_putstr((char*)args);
           break;
         case LCD_GOTOXY:
           lcd_gotoxy(int_args[0], int_args[1]);
           break;
         case LCD_PUTINT:
           lcd_putint(int_args[0]);
           break;
         case ORB_INIT:
           orb_init();
           break;
-...
           /*
         case MOVE:
           break;
           */
-...
         case BOM_OFF:
           bom_off();
           break;
         case OUTPUT_HIGH:
           output_high(int_args[0]);
           break;
         case OUTPUT_LOW:
           output_low(int_args[0]);
           break;
           //Dio
         case DIGITAL_OUTPUT:
           digital_output(int_args[0], int_args[1]);
           break;
+        }
       }else{
       } else {
         printf("%s: Error: Invalid colonet message type", __FUNCTION__);
         return -1;
+      }
       return 0;
+    }
     /* colonet_add_message
      * Adds a user-defined message
      */
     int colonet_add_message(unsigned char msgId, void (*handler)(void))
+    {
     int colonet_add_message(unsigned char msgId, void (*handler)(void)) {
       if(msgId < USER_DEFINED_MSG_ID_START || msgId > USER_DEFINED_MSG_ID_END){
         return -1;
+      }
-...
       return 0;
+    }
     /* Private functions */
     static void packet_string_to_struct(ColonetRobotServerPacket* dest_pkt,
                                         char* pkt_buf) {
       int i;
       printf("\npacket:");
       for(i = 0; i < 16; i++){
         printf("%d ", pkt_buf[i]);
+      }
       printf("\n");
       dest_pkt->prefix[0] = pkt_buf[0];
       dest_pkt->prefix[1] = pkt_buf[1];
       dest_pkt->token_src = pkt_buf[2];
       dest_pkt->token_dest = pkt_buf[3];
       dest_pkt->msg_dest = pkt_buf[4];
       dest_pkt->msg_type = pkt_buf[5];
       dest_pkt->msg_code = pkt_buf[6];
       for(i = 0; i < PACKET_DATA_LEN; i++){
         dest_pkt->data[i] = pkt_buf[7+i];
+      }
       dest_pkt->num_robots = pkt_buf[PACKET_SIZE-2];
       dest_pkt->checksum = pkt_buf[PACKET_SIZE-1];
       memcpy(dest_pkt, pkt_buf, sizeof(ColonetRobotServerPacket));
+    }
     /* two_bytes_to_int(char a, char b)
      * Returns int of form [high][low]
      */
     static unsigned int two_bytes_to_int(char high, char low)
+    {
     static unsigned int two_bytes_to_int(char high, char low) {
       return (((unsigned int)high)<<8) + (unsigned int)low;
+    }

     CC = avr-gcc
     CFLAGS = -Wall -Wshadow -Wextra -g -mmcu=$(MCU)
     INCLUDES = -I../../../xfly_lib -I../
     INCLUDES = -I../../../xfly_lib -I../ -I../../../libwireless/lib -I../../../../lib/include/libdragonfly
     all: colonet_dragonfly.o

      */
     #ifndef COLONET_DRAGONFLY_H_
     #define COLONET_DRAGONFLYH_
     #define COLONET_DRAGONFLY_H_
     #include <colonet_defs.h>
     /** @brief Handles colonet packets.  Should be called by parse_buffer
      * when it is determined that a colonet message has been received.
+     *
      * @param robot_id The robot id
      * @param pkt_buf The packet buffer (e.g. wl_buf)
+     *
      * @return -1 on error (invalid msgId), 0 on success
     /**
      */
     int colonet_handle_message(unsigned char robot_id, char* packet);
     int colonet_init(void);
     /** @brief Registers a new colonet message handler function.  If a message
      * with msgId is received, then handler will be called.
+     *
+     *
      * @param msgId The message id of the handler to be registered.  Must be
      * between USER_DEFINED_MSG_ID_START and USER_DEFINED_MSG_ID_END
      * @param handler The function to be called if a colonet packet with message
      * id msgId is received
+     *
+     *
      * @return -1 on error (invalid msgId), 0 on success
      */
     int colonet_add_message(unsigned char msgId, void (*handler)(void));

     // PacketGroup id for wireless library.
     #define COLONET_PACKET_GROUP_ID 8
     #define COLONET_RESPONSE_PACKET_FRAME_ID COLONET_PACKET_GROUP_ID
     // Message types
     typedef enum {COLONET_COMMAND, COLONET_REQUEST,
-...
     //Packet properties
     #define PACKET_DATA_LEN 7
     #define PACKET_SIZE 16
     #define WL_DEFAULT_PAN 3332
-...
     // Message dests
     #define GLOBAL_DEST 200
     #define MAX_NUM_ROBOTS 7
     //#define MAX_NUM_ROBOTS 7
     #define COLONET_SERVER_RESPONSE_ADDR 201
     #define USER_DEFINED_MSG_ID_START 0xF0
-...
     #define USER_DEFINED_MSG_TOTAL 0x0F
     /* This is the packet structure of the data buffer sent from the colonet
      * wireless library to the . */
      * wireless library to the robots and from the robots to the colonet wireless
      * library. */
     typedef struct {
       int client_id; // ID number of the client sending the packet.
       unsigned char msg_code; // Specific instruction for the robot -- see below.

trunk/code/projects/libwireless/lib/wireless.h
125	125	unsigned int wl_get_xbee_id(void);
126	126
127	127	/ @} / // end defgroup
128

Project

General

Profile

Colony

Revision 149