Colony

  //usb_init();

  //usb_puts("USB initialized!\n\r");

  //usb_puts("Packet Group Registered!\n\r");

  int size;

  int i=0;

  short int robot_id, ir_value; 

  char ranges[] = {IR1,IR2,IR3,IR4,IR5}; 

      buf[i++] = (char)((robot_id>>8) & 255);

      buf[i++] = (char)(robot_id & 255);

      buf[i++] = (char)(wl_token_get_my_sensor_reading(robot_id));

    break;

    //usb_puts("Generating an IR packet.\n");

      //usb_puts("Distance :\t");

      //usb_puti(ir_value);

      //usb_puts("\n");

    //usb_puts("Packet Contents: ");

    /*for(i = 0; i<size;i++){

        //usb_puti(buf[i]);

    }*/

    break; 

  //usb_puts("Generating an IR packet.\n");

    //usb_puts("Distance :\t");

    //usb_puti(ir_value);

    //usb_puts("\n");

      I have no idea, unsupported.

  //usb_init();

  //usb_puts("USB initialized!\n\r");

  //usb_puts("Packet Group Registered!\n\r");

  int size;

  int i=0;

  short int robot_id, ir_value; 

  char ranges[] = {IR1,IR2,IR3,IR4,IR5}; 

      buf[i++] = (char)((robot_id>>8) & 255);

      buf[i++] = (char)(robot_id & 255);

      buf[i++] = (char)(wl_token_get_my_sensor_reading(robot_id));

    break;

    //usb_puts("Generating an IR packet.\n");

      //usb_puts("Distance :\t");

      //usb_puti(ir_value);

      //usb_puts("\n");

    //usb_puts("Packet Contents: ");

    /*for(i = 0; i<size;i++){

        //usb_puti(buf[i]);

    }*/

    break; 

  //usb_puts("Generating an IR packet.\n");

    //usb_puts("Distance :\t");

    //usb_puti(ir_value);

    //usb_puts("\n");

  analog_init(ADC_START);

#include "dragonfly_lib.h"

#include "data_response.h"

#include "smart_run_around_fsm.h"

int main(void){

  wl_init(); 

  data_response_init();

  wl_token_ring_register();

  wl_token_ring_join();

  run_around_init();

  while(1){

    run_around_FSM();

  }

  wl_terminate();

}

      I have no idea, unsupported.

#include "data_requests.h"

#include "queue.h"

typedef struct dataNode{

  long timeStamp;

  char type;

  union{

      BomNode* u_b;

      short* u_s;

      unsigned char* u_c;

  } data;

} Data;

/*

This is the game plan if anyone is interested.

Each robot will go for an unspecified amount of time,

accruing encoder, BOM, and IR data.  The IR and encoders

will be used to generate heat maps for each robot, starting

at the center, decreasing in certainty (i.e. the amount of

'color' put on during a time unit will be spread over a greater

area) over time according to the physical limitations of 

the measuring devices.

When the uncertainty gets too high, a new map will be allocated for

the robot.

The BOM data will be used to orient individual maps to one another.

Along with physical limitations on the size of the environment, and

hopefully some brainstorming to do with triangularization and what not,

the heat maps will become increasingly well oriented.

Finally, after a currently unspecified amount of time, the maps which have

been properly oriented (this could probably just be all of them due to the nature

of the heat maps,) will be summed up into one meta map! Metamap will undergo some

signal processing, probably in the form of a second order gradient, to get a map

of magnitudes, which we will try to further reduce to lines.  These lines are the

walls of the environment.

In time, it is possible that this "unspecfied amount of time" could become a continuous

computation, but I haven't put much thought into how this will scale.  It will almost 

definitely depend upon the chosen resolution of the heat map.

I do want people working with me, this should be a lot of fun,

I'm coming to accept the fact that I'm not a very good programmer,

but I think this is a solid method of doing SLAM.

*/

/** 

* @brief An array of maps.

*/

int*** map_array;

/** 

* @brief An array of short's indicating which robot each map belongs to.

*/

int* map_ids[];

Queue* dataQueue;

/*These functions simply add the data to the queue.*/

void bom_handler(BomNode** head);

void ir_handler(short** data);

void encoder_handler(unsigned char** data);

void slam_analyze();

void bom_analyze(BomNode* head);

void ir_analyze(short* data);

void encoder_analyze(unsigned char* data);

int main(void){

  data_requests_init(bom_handler,IR_handler,encoder_handler);

  dataQueue = queue_create();

  slam_analyze(); 

}

void slam_analyze(){

  Data* current_data;

  while(1){

    if(!queue_is_empty(dataQueue)){

      current_data = (Data*)queue_remove(dataQueue);

      switch(current_data->type){

      case(BOM_TYPE):

        bom_analyze(current_data->data.u_b);

        break;

      case(IR_TYPE):

        ir_analyze(current_data->data.u_s);

        break;

      case(ENCODER_TYPE):

        encoder_analyze(current_data->data.u_c);

        break;

      }

    }

  }

}

void bom_analyze(BomNode* head){

}

void ir_analyze(short* data){

}

void encoder_analyze(unsigned char* data){

}

/*The packet handling functions for data requests.*/

void bom_handler(BomNode** head){

  Data* newData = malloc(sizeof(Data));

  newData->data = (*head);

  //newData->robot_id = ?????

  //newData->time = 

  queue_add(dataQueue,(void*)(newData));

}

void ir_handler(short** data){

  //etc.

}

void encoder_handler(unsigned char** data){

}