/ - Diff - Colony - Robotics Club

     #ifndef ROBOT
     void xbee_set_com_port(char* port){
       //printf("Port being passed is %s\n",port);
       xbee_com_port = malloc(strlen(port));
       xbee_com_port = (char *) malloc(strlen(port));
       strcpy(xbee_com_port,port);
+    }
     #endif

     #include <dragonfly_lib.h>
     #include <wireless.h>
     #include <wl_token_ring.h>
     #define TEST_CODE 12
     void  handle_receive(char type, int source, unsigned char *packet, int length);
     int main(void){
       PacketGroupHandler pgh;
       pgh.groupCode=12;
       wl_init();
      PacketGroupHandler pgh;
       pgh.groupCode=TEST_CODE;
       pgh.timeout_handler=NULL;
       pgh.handle_response=NULL;
       pgh.handle_receive=handle_receive;
-...
       wl_register_packet_group(&pgh);
       wl_token_ring_register();
       wl_token_ring_join();
       while(1){
         wl_do();
+      }

     #include <stdio.h>
     #include <unistd.h>
     #include "wireless.h"
     #include "wl_token_ring.h"
     #define TEST_CODE 12
     void handle_receive(char type, int source, unsigned char* packet, int length);
     unsigned char bom_responded_flag;
     unsigned char response_flag;
     int main(void){
       wl_set_com_port("/dev/cu.usbserial-A1000Qu6");
       wl_init();
       PacketGroupHandler* pgh = malloc(sizeof(PacketGroupHandler));
       pgh->groupCode=12;
       pgh->timeout_handler=NULL;
       pgh->handle_response=NULL;
       pgh->handle_receive=handle_receive;
       pgh->unregister=NULL;
       wl_register_packet_group(pgh);
       int i;
       wl_token_ring_register();
       int i,robot_id;
       response_flag=0;
       wl_token_iterator_begin();
       while(1){
         wl_send_robot_to_robot_global_packet (12, 0, NULL, 0, 9, 0);
         printf("Sending robot to robot global packet.\n");
         for(i=0;i<1000;i++){
         while(wl_token_iterator_has_next()){
           wl_do();
           robot_id = wl_token_iterator_next();
           wl_send_robot_to_robot_global_packet (12, 0, NULL, 0, robot_id, 0);
           printf("Sent robot to robot global packet.\n");
           while(response_flag==0){
              wl_do();
              usleep(100);
              if(i>5000){
                 printf("Response timed out\n");
                 break;
+             }
+          }
           response_flag =0;
+        }
+      }
       return -1;
+    }
     void handle_receive(char type, int source, unsigned char* packet, int length){
         printf("Received the callback!\n");
         printf("Received a callback from %i!\n",source);
         response_flag=1;
+    }

     void main(void){
       dragonfly_init(ALL_ON);
       range_init();
       wl_init();
       wl_token_ring_register();
       wl_token_ring_join();
       data_request_init();
       data_response_init();
       char* ranges = {IR1,IR2,IR3,IR4,IR5};
       char i;
       while(1){
         wl_do();
         usb_puts("IR Data\n\r");
         for(i=0;i<5;i++){
           usb_puts("IR ");
           usb_puti(i);
           usb_puts(": ");
           usb_puti(range_read_distance(ranges[i]));
           usb_puts("\n\r");
+        }
+      }
+    }

     #include "dragonfly_lib.h"
     #include "wl_token_ring.h"
     #include "wireless.h"
     #include "serial.h"
     PacketGroupHandler pgh;
     void handle_receive(char type, int source, unsigned char* packet, int length);
-...
     int generate_bom_packet(char** buf);
     int generate_IR_packet(char** buf);
     void data_request_init(void){
     void data_response_init(void){
       usb_init();
       usb_puts("USB initialized!\n\r");
       range_init();
       pgh.groupCode=DATA_REQUEST_GROUP;
       pgh.timeout_handler = NULL;
       pgh.handle_response = NULL;
       pgh.handle_receive = handle_receive;
       pgh.unregister = NULL;
       wl_register_packet_group(&pgh);
       usb_puts("Packet Group Registered!\n\r");
+    }
     void handle_receive(char type, int source, unsigned char* packet, int length){
       char buf[MAX_PACKET_LENGTH];
       int size;
       usb_puts("Got a packet!\n\r");
       switch(type){
       case BOM_TYPE:
         size = generate_bom_packet(&buf);
         wl_send_robot_to_robot_packet(DATA_REQUEST_GROUP,BOM_TYPE,buf,size,source,0);
         wl_send_robot_to_robot_global_packet(DATA_REQUEST_GROUP,BOM_TYPE,buf,size,source,0);
       case IR_TYPE:
         size = generate_IR_packet(&buf);
         wl_send_robot_to_robot_packet(DATA_REQUEST_GROUP,IR_TYPE,buf,size,source,0);
         wl_send_robot_to_robot_global_packet(DATA_REQUEST_GROUP,IR_TYPE,buf,size,source,0);
       case ENCODER_TYPE:
         break;
         //Not yet supported.
-...
       short int i=0, robot_id;
       char bom_data;
       wl_token_iterator_begin();
       while(wl_token_iterator_has_next() && i<=99){
       while(wl_token_iterator_has_next() && i<=96){
         robot_id = wl_token_iterator_next();
         (*buf)[i++] = (char)((robot_id>>8) & 0xFF);
         (*buf)[i++] = (char)(robot_id & 0xFF);
-...
     int generate_IR_packet(char** buf){
       *buf[0] = range_read_distance(IR1);
       delay_ms(20);
       *buf[1] = range_read_distance(IR2);
       delay_ms(20);
       *buf[2] = range_read_distance(IR3);
       delay_ms(20);
       *buf[3] = range_read_distance(IR4);
       delay_ms(20);
       *buf[4] = range_read_distance(IR5);
       char i;
       return 5;
+    }

branches/slam/code/projects/colonet/DataRequests/robot/Makefile
14	14	USE_WIRELESS = 1
15	15
16	16	# com1 = serial port. Use lpt1 to connect to parallel port.
17		AVRDUDE_PORT = /dev/cu.usbserial-A4001hAU
	17	AVRDUDE_PORT = /dev/cu.usbserial-A4001hyO
18	18	#
19	19	#
20	20	###################################

     #ifndef _DATA_RESPONSE_H
     #define _DATA_REQUESTS_H
     #define DATA_REQUEST_GROUP 23
     #define DATA_REQUEST_GROUP 7
     #define BOM_TYPE 0
     #define IR_TYPE 1
     #define ENCODER_TYPE 2
-...
     /* This requires the wireless library
     and the token ring to already be initialized.*/
     void data_request_init(void);
     void data_response_init(void);
     #endif

     #include "data_requests.h"
     #include "wireless.h"
     #include "wl_token_ring.h"
     #include "pthread.h"
     void IR_handler(unsigned char* data);
     void bom_handler(BomNode* head);
-...
     unsigned char bom_responded_flag;
     unsigned char ir_responded_flag;
     unsigned char encoder_responded_flag;
     void* wl_do_routine(void* arg){
       while(1){
          wl_do();
+      }
+    }
     pthread_t* wl_do_thread;
     int main(void){
       wl_set_com_port("/dev/cu.usbserial-A1000Qu6");
       wl_init();
-...
       ir_responded_flag = 0;
       encoder_responded_flag = 0;
       int test_count;
       wl_do_thread = malloc(sizeof(pthread_t));
       pthread_create(wl_do_thread,NULL,wl_do_routine,NULL);
       while(1){
           wl_do();
           printf(".");
           wl_token_iterator_begin();
           while(wl_token_iterator_has_next()){
-...
             request_IR_data(robot_id);
             test_count=0;
             while(!(ir_responded_flag)&&(test_count++<20)){
               wl_do();
               printf("Waiting on %i..\n",robot_id);
               usleep(500000);
               usleep(5000000);
+            }
     /*
             request_encoder_data(robot_id);
-...
+            }
     */
+          }
           usleep(500000);
           usleep(5000000);
+      }
+    }

     #include <stdio.h>
     #include <pthread.h>
     #include "../../../libwireless/lib/wireless.h"
     #include <string.h>
     PacketGroupHandler pgh;
     pthread_t* dr_thread;
-...
+    }
     void* pthread_handle(void* arg){
       RawData* data = (RawData*)arg;
       unsigned char* packet = data->packet;
       int length = data->length;
-...
         case IR_TYPE:
           /*An IR packet consists of just the 5 bytes representing the IR
           values, in order.*/
           if(length != 4){
           if(length != 5){
               //The packet is incomplete... bail.
               break;
+          }
           else{
             unsigned char data[4];
             for(i=0;i<4;i++){
             unsigned char data[5];
             for(i=0;i<5;i++){
               data[i] = packet[i];
+            }
             IR_handle(data);
-...
           /*I have no idea, unsupported.*/
           break;
+      }
       free(data->packet);
       free(data);
+    }
     void receive_handle(char type, int source, unsigned char* packet, int length){
       RawData data;
       data.packet=packet;
       data.source=source;
       data.length=length;
       data.type=type;
       pthread_create(dr_thread,NULL,pthread_handle,(void*)&data);
       RawData* data = malloc(sizeof(RawData));
       if(!data){
         return;
+      }
       unsigned char* newPacket = malloc(length);
       memcpy(newPacket, packet,length);
       data->packet=newPacket;
       data->source=source;
       data->length=length;
       data->type=type;
       dr_thread = malloc(sizeof(pthread_t));
       pthread_create(dr_thread,NULL,pthread_handle,(void*)data);
+    }

Project

General

Profile

Colony

Revision 294