/ - Diff - Colony - Robotics Club

trunk/code/lib/include/libdragonfly/i2c.h
54	54	void i2c_packet_rec (char i2c_byte);
55	55	void i2c_packet_sniff(char data);
56	56	#endif
	57

+    	}
     	m->size = DEFAULT_SENSOR_MATRIX_SIZE;
     	m->matrix = (int**)malloc(m->size * sizeof(int*));
     	if (!(m->matrix)) {
     	  WL_DEBUG_PRINT("Out of memory - allocating memory for matrix.\r\n");
     	  free(m);
     	  return NULL;
+    	}
     	m->joined = (int*)malloc(m->size * sizeof(int));
     	if (!(m->joined)) {
     	  WL_DEBUG_PRINT("Out of memory - allocating memory for joined.\r\n");
     	  free(m->matrix);
     	  free(m);
     	  return NULL;
+    	}
     	m->numJoined = 0;
     	if (!(m->matrix) || !(m->joined))
+    	{

     #include "analog.h"
     #include "serial.h"
     // Internal Function Prototypes
     //TODO: if this function is only used in this file, make it static
     void set_adc_mux(int which);
     /**
-...
      * @{
      **/
     //TODO: if these variables are only used in this file, make them static
     int adc_loop_running = 0;
     int adc_current_port = 0;
     adc_t an_val[11];
-...
+     *
      * @see analog8, analog10
      **/
     void analog_init(int start_conversion) {
     void analog_init(int start_conversion)
+    {
     	for (int i = 0; i < 11; i++) {
     		an_val[i].adc10 = 0;
     		an_val[i].adc8 = 0;

     #include "analog.h"
     //constants
     //TODO: for better readability, make all of these hex or decimal
     const int lookup[16] = {7,6,5,0xe,1,4,3,2,0xf,0,0xd,8,0xc,0xb,9,0xa};
     // internal function prototypes
     //TODO: if these are only used in this file, make them static
     void output_high(int which);
     void output_low(int which);
-...
      **/
     int get_max_bom(void) {
     	int max_bom_temp = 0;
     	//TODO: renamed a, i, and h to give them meaningful names
     	int a, i, j, h;
         h = 255;
-...
     void output_low(int which) {
     	digital_output(which, 0);
+    }

       dragonfly_init(ALL_ON);
       range_init();
       wl_init();
       wl_set_channel(0xD);
       wl_token_ring_register();
       wl_token_ring_join();
       data_response_init();
-...
       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");
+        }
+      }
+    }

     void handle_receive(char type, int source, unsigned char* packet, int length){
       char buf[MAX_PACKET_LENGTH];
       int size;
       int size, i;
       usb_puts("Got a packet!\n\r");
       switch(type){
       case BOM_TYPE:
         size = generate_bom_packet(&buf);
         wl_send_robot_to_robot_global_packet(DATA_REQUEST_GROUP,BOM_TYPE,buf,size,source,0);
       case IR_TYPE:
         size = generate_IR_packet(&buf);
         usb_puts("Generating an IR packet.\n");
         char ranges[] = {IR1,IR2,IR3,IR4,IR5};
         int i;
         short ir_value;
         for(i=0;i<5;i++){
           ir_value = (short)range_read_distance(ranges[i]);
           buf[2*i] = (char)((ir_value>>8)&255);
           buf[2*i+1] = (ir_value&255);
           usb_puts("Distance :\t");
           usb_puti(ir_value);
           usb_puts("\n");
+        }
         size = 10;
         usb_puts("Packet Contents: ");
         for(i = 0; i<size;i++){
             usb_puti(buf[i]);
             usb_putc(' ');
+        }
         wl_send_robot_to_robot_global_packet(DATA_REQUEST_GROUP,IR_TYPE,buf,size,source,0);
       case ENCODER_TYPE:
         break;
         //Not yet supported.
-...
     int generate_bom_packet(char** buf){
       short int i=0, robot_id;
       char bom_data;
       wl_token_iterator_begin();
       while(wl_token_iterator_has_next() && i<=96){
         robot_id = wl_token_iterator_next();
-...
+    }
     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;
       usb_puts("Generating an IR packet.\n");
       char ranges[] = {IR1,IR2,IR3,IR4,IR5};
       int i;
       short ir_value;
       for(i=0;i<5;i++){
         ir_value = (short)range_read_distance(ranges[i]);
         (*buf)[2*i] = (char)((ir_value>>8)&255);
         (*buf)[2*i+1] = (ir_value&255);
         usb_puts("Distance :\t");
         usb_puti(ir_value);
         usb_puts("\n");
+      }
       return 10;
+    }

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-A4001hyO
	17	AVRDUDE_PORT = /dev/cu.usbserial-A4001hAr
	18	#AVRDUDE_PORT = /dev/cu.usbserial-A4001hAr
18	19	#
19	20	#
20	21	###################################

     #include "wireless.h"
     #include "wl_token_ring.h"
     #include "pthread.h"
     #include "string.h"
     void IR_handler(unsigned char* data);
     void bom_handler(BomNode* head);
     void encoder_handler(unsigned char* data);
     void IR_handler(short** data);
     void bom_handler(BomNode** head);
     void encoder_handler(unsigned char** data);
     unsigned char bom_responded_flag;
     unsigned char ir_responded_flag;
     unsigned char encoder_responded_flag;
     void* wl_do_routine(void* arg){
     /*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");
       char* com_port = malloc(strlen("/dev/cu.usbserial-A4001hAN"));
       strcpy(com_port,"/dev/cu.usbserial-A4001hAN");
       wl_set_com_port(com_port);
       wl_init();
       wl_set_channel(0xD);
       wl_token_ring_register();
       data_requests_init(bom_handler,IR_handler,encoder_handler);
       int robot_id;
       bom_responded_flag = 0;
       ir_responded_flag = 0;
       encoder_responded_flag = 0;
       int test_count;
       int test_count,test_count2;
       wl_do_thread = malloc(sizeof(pthread_t));
       pthread_create(wl_do_thread,NULL,wl_do_routine,NULL);
       //wl_do_thread = malloc(sizeof(pthread_t));
       //pthread_create(wl_do_thread,NULL,wl_do_routine,NULL);
       while(1){
           printf(".");
           wl_token_iterator_begin();
           while(wl_token_iterator_has_next()){
             wl_do();
             robot_id = wl_token_iterator_next();
             bom_responded_flag = 0;
-...
             test_count=0;
             while(!(ir_responded_flag)&&(test_count++<20)){
               printf("Waiting on %i..\n",robot_id);
               usleep(5000000);
+            }
               for(test_count2=0;test_count2<1000;test_count2++){
                 wl_do();
                 usleep(500);
               } //100 ms Total.
             } //Waits for 2 seconds total.
     /*
             request_encoder_data(robot_id);
             while(!encoder_responded_flag){
-...
+            }
     */
+          }
           usleep(5000000);
           for(test_count=0;test_count<1000;test_count++){
             wl_do();
             usleep(5000); //1 Second total.
+          }
+      }
+    }
     void IR_handler(unsigned char* data){
     void IR_handler(short** data){
       char i = 0;
       printf("IR Callback occurred.\n");
       for(i=0;i<5;i++){
         printf("IR %i is %i\n",i+1,(int)data[i]);
         printf("IR%i is %i\n",i+1,(int)((*data)[i]));
+      }
       ir_responded_flag=1;
+    }
     void bom_handler(BomNode* head){
     void bom_handler(BomNode** head){
       bom_responded_flag=1;
+    }
     void encoder_handler(unsigned char* data){
     void encoder_handler(unsigned char** data){
       encoder_responded_flag=1;
+    }

     void receive_handle(char type, int source, unsigned char* packet, int length);
     void (*bom_handle)(BomNode* head);
     void (*IR_handle)(unsigned char* data);
     void (*encoder_handle)(unsigned char* data);
     void (*bom_handle)(BomNode** head);
     void (*IR_handle)(short** data);
     void (*encoder_handle)(unsigned char** data);
     void data_requests_init(void(*bom_data_handler)(BomNode* head),
                             void(*IR_data_handler)(unsigned char* data),
                             void(*encoder_data_handler)(unsigned char* data)){
     void data_requests_init(void(*bom_data_handler)(BomNode** head),
                             void(*IR_data_handler)(short** data),
                             void(*encoder_data_handler)(unsigned char** data)){
       bom_handle = bom_data_handler;
       IR_handle = IR_data_handler;
       encoder_handle = encoder_data_handler;
-...
       wl_send_robot_to_robot_global_packet(DATA_REQUEST_GROUP,ENCODER_TYPE,NULL,0,robot_id,0);
+    }
     void* pthread_handle(void* arg){
     /*void* pthread_handle(void* arg){
       RawData* data = (RawData*)arg;
       unsigned char* packet = data->packet;
       int length = data->length;
       char type = data->type;
       int i=0;
       BomNode* head;
       switch(type){
-...
           break;
         case IR_TYPE:
           /*An IR packet consists of just the 5 bytes representing the IR
           values, in order.*/
           if(length != 5){
               //The packet is incomplete... bail.
               break;
           An IR packet consists of just the 5 bytes representing the IR
           values, in order.
           if(length != 10) break;
           short data[10];
           for(i=0;i<5;i++){
             data[i] = ((short)packet[2*i]<<8)+((short)packet[2*i+1]);
+          }
           else{
             unsigned char data[5];
             for(i=0;i<5;i++){
               data[i] = packet[i];
           IR_handle(data);
           break;
         case ENCODER_TYPE:
           /*I have no idea, unsupported.
           break;
+      }
       free(data->packet);
       free(data);
       return NULL;
     }*/
     void receive_handle(char type, int source, unsigned char* packet, int length){
       int i=0;
       BomNode* head;
       printf("Packet contents: [ ");
       for(i=0;i<length;i++){
         printf("%i ",packet[i]);
+      }
       switch(type){
         case  BOM_TYPE:
           printf("I shouldn't be here during testing\n");
           head = malloc(sizeof(BomNode));
           BomNode* iter = head;
           while(i<length){
             iter->robot_id = ((short)packet[i]<<8) + ((short)packet[i+1]);
             i+=2;
             iter->value = packet[i++];
             if(i<length){
                 iter-> next = malloc(sizeof(BomNode));
                 iter = iter->next;
+            }
             IR_handle(data);
+          }
           bom_handle(head);
           break;
         case IR_TYPE:
           /*An IR packet consists of just the 10 bytes representing the IR
           values as shorts, in order.*/
           if(length != 10) break;
           short* data = malloc(5*sizeof(short));
           for(i=0;i<5;i++){
             data[i]=  ((((short)packet[2*i])<<8)&0xff00 ) | ( (short)(packet[2*i+1])&255);
+          }
           IR_handle(&data);
           break;
         case ENCODER_TYPE:
           /*I have no idea, unsupported.*/
           break;
+      }
       free(data->packet);
       free(data);
+    }
     void receive_handle(char type, int source, unsigned char* packet, int length){
     /*void receive_handle(char type, int source, unsigned char* packet, int length){
       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;
-...
       dr_thread = malloc(sizeof(pthread_t));
       pthread_create(dr_thread,NULL,pthread_handle,(void*)data);
+    }
     }*/

     } RawData;
     void data_requests_init(
                             void(*bom_data_handler)(BomNode* head),
                             void(*IR_data_handler)(unsigned char* data),
                             void(*encoder_data_handler)(unsigned char* data));
                             void(*bom_data_handler)(BomNode** head),
                             void(*IR_data_handler)(short** data),
                             void(*encoder_data_handler)(unsigned char** data));
     void request_bom_data(int robot_id);
     void request_IR_data(int robot_id);

Project

General

Profile

Colony

Revision 366