void coms_test()
{
   IF_SET set;
   uint8_t ifaces=0;
   comBuf *recvd;
   com_mode(IFACE_SERIAL, IF_LISTEN);

#ifdef PLATFORM_LINUX
   com_mode(IFACE_TERMINAL, IF_LISTEN);
#else
   com_mode(IFACE_RADIO, IF_LISTEN);
#endif

   
   while(1){
      IF_ZERO(&set);

    
      IF_SET(IFACE_SERIAL, &set);

#ifdef PLATFORM_LINUX
      IF_SET(IFACE_TERMINAL, &set);
#else
      IF_SET(IFACE_RADIO, &set);
#endif
      
      ifaces = com_select(&set,2000);
      
      if(IF_ISSET(IFACE_SERIAL, &set)){
	 printf("serial brought us back\n");
	 recvd = com_recv(IFACE_SERIAL);
	 com_free_buf(recvd);
      }
#ifdef PLATFORM_LINUX
      else if(IF_ISSET(IFACE_TERMINAL, &set)){
	 printf("terminal brought us back\n");
	 recvd = com_recv(IFACE_TERMINAL);
	 com_free_buf(recvd);
      }
#else
      else if(IF_ISSET(IFACE_RADIO, &set)){
	 printf("radio brought us back\n");
	 recvd = com_recv(IFACE_RADIO);

	 printf("[%C-%C]", recvd->data[0], recvd->data[recvd->size-1]);
	 com_free_buf(recvd);
      } 
#endif
      else {
	 printf("timed out, returned %d ifaces\n",ifaces);
      }
     
   }
}
示例#2
0
void recv_thread(void)
{
   while(1)
   {
      
      IF_SET set;
      IF_ZERO(&set);
      IF_SET(IFACE_RADIO, &set);

      if(com_select(&set, 1000))
      {
	 
	 comBuf* p = com_recv(IFACE_RADIO);
	 if (p && p->data[0] == PKT_DO_SENSE)
	 {
	    if (p->size != 5)
	       continue;

	    if (crc_compute(p->data, 3) != buf_extract_WORD(p->data, 3))
	       continue;

	    send_packet(PKT_REQUESTED_SENSE);
	 }
	 

	 com_free_buf(p);
      }
   }
   
   
   
}
void remote_control()
{
   uint8_t i;



   comBuf *recvd;
  
   com_mode(IFACE_SERIAL, IF_LISTEN); //tell the uart we want to listen
   while(1)
   {
/*      IF_ZERO(&set);                     //reset the set of interfaces
      IF_SET(IFACE_TERMINAL, &set);      //add stdin to set
      IF_SET(IFACE_SERIAL, &set);        //add serial to set
      IF_SET(IFACE_UDP, &set);           //become a server
      com_select(&set,COM_BLOCK);                //wait for a device to respond
*/    
      //     if(IF_ISSET(IFACE_SERIAL,&set)){      //something on serial line
//	 recvd = com_recv(IFACE_SERIAL);    //retrieve data from serial
      // com_send(IFACE_TERMINAL, recvd);   //send data to terminal
	 //TODO: forward traffic over the network
      // com_free_buf(recvd);             
      // fflush (stdout);                 //show the string incase no \n
	      
   // else if(IF_ISSET(IFACE_TERMINAL,&set)){//user typed something
   recvd = com_recv(IFACE_TERMINAL);   //get the data
   com_send(IFACE_UDP,recvd);
   com_free_buf(recvd);
	 // if(!command_parse(local_commands,recvd->data)){//local command?
	 // send_to_nymph(recvd->data); 
	 //}

   }
}
示例#4
0
void rtscts_sink_thread(){
   comBuf *recv_pkt;                     //give us a packet pointer
   com_mode(IFACE_RADIO, IF_LISTEN);

   printf("before entering the while loop\n");
   while(1)
   {
      recv_pkt = com_recv(IFACE_RADIO); //blocking recv a packet
      printf("Src = %C Seq = %C Type = %C Size = %C TS = %l TCNT = %C RSSI = %l\n",
	     recv_pkt->data[0],
	     recv_pkt->data[1],
	     recv_pkt->data[2],
	     recv_pkt->size,
	     recv_pkt->ts,
	     recv_pkt->tcnt,
	     recv_pkt->signal);
      if(recv_pkt->data[2] == RTS_TYPE) {
	 mos_thread_sleep(100);
	 send_cts(recv_pkt->data[0], recv_pkt->data[1], &ctrl_pkt);
	 printf("Send out CTS to %C\n", recv_pkt->data[0]);
      }
      com_free_buf(recv_pkt);             //free the recv'd packet to the pool
      mos_led_toggle(0);
      
   }
}
示例#5
0
// Send data (Commands) to URG and wait for reply
int urg_sendMessage(const char* command, int timeout, int* recv_n) {

  int send_size = urg_sendTag(command);
  int recv_size = send_size + 2 + 1 + 2;
  char buffer[LineLength];

  int n = com_recv(buffer, recv_size, timeout);
  *recv_n = n;

  if (n < recv_size) {
    // When received size not matched
    return -1;
  }

  if (strncmp(buffer, command, send_size -1)) {
    // When command not matched
    return -1;
  }

  // !!! If possible do calculate check-sum to verify data

  // Convert the received data to Hex and return data.
  char reply_str[3] = "00";
  reply_str[0] = buffer[send_size];
  reply_str[1] = buffer[send_size + 1];
  return strtol(reply_str, NULL, 16);
}
示例#6
0
void sink_thread(){
   comBuf *recv_pkt;                     //give us a packet pointer
   com_mode(IFACE_RADIO, IF_LISTEN);

   send_pkt.size =1;
   send_pkt.data[0] = 99;
   com_send(IFACE_RADIO, &send_pkt);
   
//   printf("before entering the while loop\n");
   
   while(1)
   {
      recv_pkt = com_recv(IFACE_RADIO); //blocking recv a packet
      printf("Src = %C Seq = %C Type = %C Size = %C TS = %l TCNT = %C RSSI = %l\n",
	     recv_pkt->data[0],
	     recv_pkt->data[1],
	     recv_pkt->data[2],
	     recv_pkt->size,
	     recv_pkt->ts,
	     recv_pkt->tcnt,
	     recv_pkt->signal);
      com_free_buf(recv_pkt);             //free the recv'd packet to the pool
      mos_led_toggle(0);
   }
}
示例#7
0
void sniffer() {
   comBuf *recv_pkt;
   com_mode(IFACE_RADIO, IF_LISTEN);
   while (1) {
      recv_pkt = com_recv(IFACE_RADIO);
      com_free_buf(recv_pkt);
      mos_led_toggle(2);
   }
}
void radio_poll()
{
   comBuf *recvdbuf;
   while(1) {
      recvdbuf = com_recv(IFACE_RADIO);
      mos_led_toggle(1);
      com_free_buf(recvdbuf);
   }
}
示例#9
0
void start (void)
{
    comBuf * ptr;

    //turn the radio and serial on
    com_mode(IFACE_RADIO, IF_LISTEN);
    com_mode(IFACE_SERIAL, IF_LISTEN);

    //change the radio power?
    //com_ioctl_IFACE_RADIO(CC1000_TX_POWER, 0x50);

    myID = mos_node_id_get();     //preset
    baseID = myID;                //I'm the base
    myParentID = 0;               //no parents
    myDTB = 0;                    //I am the base
    mySeqNo = 0;                  //start at 0

    //set timer functions
    sleep_timer.func = sleep_timer_callback;  

    //set timer times
    sleep_timer.msecs = TO_NEXT_SLEEP;
    sleep_timer.reset_to = 0;
 
    state = GO;

    //just to let us know it's on
    printf ("waiting for start signal\n");

    while (1)
    {
	ptr = com_recv(IFACE_SERIAL);
	if (strncmp(ptr->data, "startstartstartstartstartstartstart", 35) == 0)
	{
	    printf ("received start\n");  //this is for the python script
	    com_free_buf(ptr);
	    break;
	}
	else
	{
	    printf ("got %s\n", ptr->data);
            printf ("which not the start value.  Still waiting...\n");
	    com_free_buf(ptr);
	}
	
    }
    //kill the serial to save power
    com_mode(IFACE_SERIAL, IF_OFF);

    //start sleep alarm
    mos_alarm (&sleep_timer);

    mos_thread_new (send, 128, PRIORITY_NORMAL);
    mos_thread_new (recv, 128, PRIORITY_NORMAL);
}
示例#10
0
void rx_thread(void)
{
 
   
   while(1)
   {
      comBuf* p = com_recv(IFACE_RADIO);
      printf("[RX] received %d bytes\n", p->size);

      parse_packet(p);
      
      com_free_buf(p);
      
   }
}
示例#11
0
void start (void)
{
   uint8_t i;

   com_mode(IFACE_SERIAL, IF_LISTEN);

   while(1) {
      pkt = com_recv (IFACE_SERIAL);
      printf("Got packet, size=%d, data: ", pkt->size);
      for(i = 0; i < pkt->size; i++)
	 printf("%d ", pkt->data[i]);
      putchar('\n');
      com_free_buf(pkt);
   }
}
示例#12
0
void test_recv(void)
{
  comBuf to_send;
  str_to_packet(&to_send,"hi mom\n");
  com_send(IFACE_TERMINAL, &to_send);

  str_to_packet(&to_send,"type something to test (it should echo)\n");
  com_send(IFACE_TERMINAL, &to_send);

  packet = com_recv(IFACE_TERMINAL);
  if(packet != NULL)
    {
      com_send(IFACE_TERMINAL,packet);
      com_free_buf(packet);
    }
}
示例#13
0
void recv()
{
   mos_led_on(2);
   
   com_mode(IFACE_RADIO,IF_LISTEN);
   while(1)
   {
      recv_packet = com_recv(IFACE_RADIO);
      revent = (net_event_t *)recv_packet->data;
      if (revent->from==0)
      {
         mos_led_toggle(1);
         printf("\b");
      }
      else
         mos_led_toggle(2);
      com_free_buf(recv_packet);
   }
}
void receiver(){

   int i;
   comBuf *recv_pkt;
   printf("Radio to uart initialized....\n"); //hello
   com_mode(IFACE_RADIO, IF_LISTEN);
   while(1){
      mos_led_toggle(1);
      recv_pkt = com_recv(IFACE_RADIO); //blocking recv a packet

      //print out as a string.
      //printf("received [%d] bytes:%s\n",recv_pkt->size,recv_pkt->data);

      //print out as data
      printf("Packet[%C]:",recv_pkt->size);
      for(i=0;i<recv_pkt->size;i++)
	 printf("%C ",recv_pkt->data[i]);
      printf("\n");
      com_free_buf(recv_pkt);//free the packet back to the pool
   }
}
示例#15
0
void ack()
{
   com_mode(IFACE_RADIO,IF_LISTEN);
   while(1)
   {
      mos_led_toggle(2);
      recv_pkt = com_recv(IFACE_RADIO); //blocking recv a packet
      printf("r");
      
      event = (net_event_t *)recv_pkt->data;
      if(event->to == 0)
      { //packet meant for base-station..
            event->to = event->from;
            event->from = 0;
            recv_pkt->size=4;
            com_send (IFACE_RADIO, recv_pkt);
            
      }
      com_free_buf(recv_pkt);
   }
}
示例#16
0
// Read data (Reply) from URG until the termination 
int urg_readLine(char *buffer) {

  int i;
  for (i = 0; i < LineLength -1; ++i) {
    char recv_ch;
    int n =0;
		n= com_recv(&recv_ch, 1, Timeout);

    if (n <= 0) {
      if (i == 0)
	  {
		return -1;		// timeout
	  }
      break;
    }
    if ((recv_ch == '\r') || (recv_ch == '\n')) {
      break;
    }
    buffer[i] = recv_ch;
  }
  buffer[i] = '\0';

  return i;
}
示例#17
0
void receiver(){

  uint16_t i, size;
  uint16_t j,k;
  uint8_t new_val, old_val;
  uint8_t power;
  uint8_t frequency;
  uint8_t testnumber;
  uint8_t go=1;
  char dup='d';  //100 in ascii decimal
  char destroy='D';  //68 in ascii decimal
  char newfreqsig ='F';  //70 in ascii decimal
  uint8_t duplicate = 0;
  uint8_t value1;
  uint8_t value2;
  uint8_t value3;
  uint8_t n=0;
  uint8_t receiving =1;
  uint8_t endfrequency =31;//31;

  //declarations for new com layer
comBuf *packet;
comBuf outpacket;
comBuf *outpacket2;
//test number
testnumber=1;   
//change frequency
frequency=3;
//rf_set_freq(frequency);original
 cc1000_raw_ioctl(CC1000_FREQ, frequency);

//change power
power=255; 
 //rf_set_power(power);//origional
 cc1000_raw_ioctl(CC1000_TX_POWER, power);
 com_mode(IFACE_RADIO, IF_LISTEN);
 com_mode(IFACE_SERIAL, IF_LISTEN);
 
  mos_led_display(1);
  // printf("XXX");
  mos_led_display(2);
  
  //size = flooding_recv((char *)&data, NET_PORT);
  
  while(receiving==1){
    
    packet = com_recv(IFACE_RADIO);
    value1 = packet->data[0];

    mos_led_display(value1);
    com_free_buf(packet);
    
    outpacket.data[0] = value1;
    
    outpacket.size = 2;

    com_send(IFACE_SERIAL, &outpacket);
    com_free_buf(&outpacket);
  }

   
return;
}
示例#18
0
void recv()
{
    comBuf * recvBuf;
    wildfire_packet_t * wp;
    net_packet_t * np;
    uint16_t sample;
    comBuf * ptr;

    //header info
    printf("src\tseq\tp_dtb\ts_dtb\tlast\ttemp\thumid\tw_dir\tw_spd\tbat\n");



    while (1)
    {
	if (state == SLEEPNODE)
	{
	    
	    mos_thread_set_suspend_state(SUSPEND_STATE_SLEEP);  //power save mode
	    com_mode(IFACE_RADIO, IF_OFF);                      //kill radio
	    com_mode(IFACE_SERIAL, IF_OFF);                     //kill serial
	    mos_thread_sleep(SLEEP_INTERVAL - COM_RECV_TIMEOUT);
	    mos_thread_set_suspend_state(SUSPEND_STATE_IDLE);   //idle mode
	    com_mode(IFACE_SERIAL, IF_LISTEN);                  //turn serial on
	  
	    while (1)
	    {
		ptr = com_recv(IFACE_SERIAL);
		if (strncmp(ptr->data, "startstartstartstartstartstartstart", 35) == 0)
		{
		    printf ("got it\n");  //for the python script
		    com_free_buf(ptr);
		    break;
		}
		else
		    com_free_buf(ptr);
	    }
	    com_mode(IFACE_SERIAL, IF_OFF);  //kill the serial
	    com_mode(IFACE_RADIO, IF_LISTEN);//turn radio on

	    //set timer when to begin next sleep cycle
	    sleep_timer.msecs = TO_NEXT_SLEEP;
	    mos_alarm (&sleep_timer);
	    state = GO;
	    
            //print out battery
	    dev_open(DEV_MICA2_BATTERY);
	    dev_read(DEV_MICA2_BATTERY, &sample, sizeof(sample));
	    dev_close(DEV_MICA2_BATTERY);
	    printf("base battery = %d\n", sample);
	}


	//wait just 5 seconds to recv before timeout
	recvBuf = com_recv_timed(IFACE_RADIO, COM_RECV_TIMEOUT);

	if (recvBuf == NULL)
	{
	    //probably should do something here... don't really care, though.
	}
	else
	{
	    //pull off the net packet header to see what type it is.
	    np = (net_packet_t *)&(recvBuf->data[0]);
	 
	    if (np->type == DATA)
	    {
		wp = (wildfire_packet_t *)&(recvBuf->data[sizeof(net_packet_t)]);
		printf("%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n", np->src, np->seqno, np->pkt_dtb, np->sender_dtb, np->last_hop, wp->temp, wp->humidity, wp->wind_direction, wp->wind_speed, wp->battery);
	    }
	    else if (np->type == CONTROL)
	    {
		//we don't do anything with control packets
		//debug info:
		//printf ("received control packet\n");
		//printf("type\tsrc\tdest\tnext\tlast\tseq\tpktdtb\ts_dtb\n");
		//printf("%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n", np->type, np->src, np->dest, np->next_hop, np->last_hop, np->seqno, np->pkt_dtb, np->sender_dtb);
	    }
	    else
	    {
		//we don't care about other packets
		//debug info:
		//printf ("received a MOS packet not associated with our system\n");
		//INVALID PACKET!!!  -- We should never get here.
	    }
	    //printf ("freeing buffer\n");
	    com_free_buf(recvBuf);
	}
      
    }//end while

}//end recv
示例#19
0
static mos_file* reprogram_iface (uint8_t iface, uint32_t* mismatches)
{
   uint8_t j;
   uint16_t crc, crc_index;
   uint32_t addr;
   uint32_t image_size;
   uint16_t page_index;
   uint32_t image_index;

   uint8_t size = 0;
   uint8_t packet_size;

   send_byte_command (iface, ACK);
   recvd = com_recv (iface);

   if(recvd->data[0] == LOAD_IMAGE) {
      image_size = (uint32_t)*(uint16_t *)(&recvd->data[1]);
      com_free_buf (recvd);
   } else {
      com_free_buf (recvd);
      printf ("Didn't get LOAD_IMAGE\n");
      return 0;
   }
   
   // Find the next page after the last program image we wrote
   /*uint32_t start_page = (cb->start_addr + cb->byte_count + 
   		ATMEL_FLASH_PAGE_SIZE-1) / ATMEL_FLASH_PAGE_SIZE;
   addr = start_page * ATMEL_FLASH_PAGE_SIZE;
   if (!compare && addr + image_size < ATMEL_FLASH_SIZE) {
   		cb->start_addr = addr;
   } else if (!compare) {
   		// There is not enough room on flash to store this image,
   		// start again at 0
   		cb->start_addr = addr = 0;
   } else {
   		// We're only comparing, use the address already in the control block
   		addr = cb->start_addr;
   }*/
   
   mos_file* file = NULL;
   if (mismatches == NULL) {
   		file = mos_file_create("prg", image_size);
   		addr = 0;
   } else {
   		mismatches = 0;
   		file = mos_file_open("prg");
   		// file doesn't exist
		if (!file) return NULL;
   		// TODO check for matching file size
   		addr = file->start;
   }

   image_index = 0; //image index is how many bytes written from the image
                    //image size is the total number of bytes in the image
   send_byte_command(iface, LOAD_ACK);

   while(image_index < image_size) {
      mos_led_toggle (0);
      recvd = com_recv(iface);
      // don't send address for performance
      //addr = *(uint16_t *)(&recvd->data[0]);
      //addr = image_index;
      crc = *(uint16_t *)(&recvd->data[0]);
      com_free_buf (recvd);
      // Now get the data packets

      //page index is how many bytes from the current page we've received
      page_index = 0; //page size is the size of the pages in memory.
      
      while (page_index < PAGE_SIZE_BYTES) { //loop until we have a full page
	 recvd = com_recv(iface);
         for (j = 0; j < recvd->size; j++) { //loop through the packet
	    //copy packet into page buffer [at right index]
            pagebuf[page_index+j] = recvd->data[j];
         }

	 packet_size = recvd->size;
	 com_free_buf (recvd);
         page_index += packet_size;

	 //don't send page ack for performance
	 //PAGE ACK
	 //send_byte_command(PACKET_ACK);
	 
	 // If this is the last packet then we break out
         if(packet_size < COM_DATA_SIZE) {
            size = packet_size;
            break;
         }
      }
      // actually write the page
      //dev_ioctl(DEV_ATMEL_FLASH, DEV_SEEK, addr);
      if (mismatches == NULL) {
      	mos_file_write(pagebuf, file, addr, sizeof(pagebuf));
      	//dev_write(DEV_ATMEL_FLASH, pagebuf, sizeof(pagebuf));
      } else {
      	dev_ioctl(DEV_ATMEL_FLASH, DEV_SEEK, addr);
      	// Don't write, just compare the buffer with the page already in flash
      	if (atmel_flash_compare(pagebuf, sizeof(pagebuf)))
      		(*mismatches)++;
      }
      addr += sizeof(pagebuf);
      
      // find out the proper index to pass to crc_compute
      if (packet_size < COM_DATA_SIZE)
         crc_index = (uint16_t)(image_size - image_index);
      else
         crc_index = page_index;
      
      // perform the crc calculation and send off the result

      if (crc_compute (pagebuf, crc_index) != crc)
         send_byte_command (iface, CRC_ERROR);
      else
	 send_byte_command (iface, CRC_OK);
      
      // finally update the image index
      image_index += page_index;
   }
   send_byte_command (iface, IMAGE_ACK);

	// In case the flash driver is in buffered mode, flush the buffer
    dev_ioctl(DEV_ATMEL_FLASH, DEV_FLUSH);

   return file;
}