static void recv_uc(struct unicast_conn *c, const rimeaddr_t *from) { printf("unicast message received from %x.%x: '%s'\n", from->u8[0], from->u8[1], (char *) packetbuf_dataptr()); sprintf(buff_, NET_TEST_CFG_REQUEST_MSG, rec_count); printf("packet: %s\n buff: %s\n",(char *) packetbuf_dataptr(), buff_); if(strcmp((char *) packetbuf_dataptr(), buff_) == 0){ static rimeaddr_t addr; addr.u8[0] = 2 & 0xFF; addr.u8[1] = 0 >> 8; static int8_t idx = 0; char buff_[30] = {'\0'}; sprintf(buff_, NET_TEST_CFG_REQUEST_MSG, rec_count); packetbuf_copyfrom(buff_ , NET_TEST_CFG_REQUEST_MSG_LEN); unicast_send(&uc, &addr); printf("send: %s\n",buff_); rec_count++; TEST_PASS(); } // check if done if (rec_count == 10) { rec_count=0; } }
int main (int argc, char *argv[]){ if (argc != 2){ printf("put pid #\n"); exit(1); } char input[100]; int temp; while(1){ memset(input, 0, 100); if (argv[2] == "1"){ unicast_receive(2, input); continue; } fgets(input, 100,stdin); input[strcspn(input, "\n")] = 0; if (strncmp(input, "exit", 4) == 0) break; else if (strncmp(input, "send", 4) == 0){ unicast_send(atoi(&input[5]), &input[7]); } else printf("invalid command\n"); } return 0; }
/* This function is called whenever a broadcast message is received. */ static void broadcast_recv(struct broadcast_conn *c, const rimeaddr_t *from) { struct broadcast_message *m; struct unicast_message sMsg; struct RTC_time t, t_now; rimeaddr_t *add; struct sensor_data tk; m = (struct broadcast_message *)packetbuf_dataptr(); t = m->time; if(id==0&&status==0) { rimeaddr_copy(&nmaddr, from); sMsg.type = INIT_REQ; sMsg.time = t; sMsg.numSampl = 20; strcpy(sMsg.name, "Dust sensor\0"); packetbuf_copyfrom(&sMsg, sizeof(struct unicast_message)); RTC_getTime(&t_now); unicast_send(&unicast, &nmaddr); broadcast_close(&broadcast); status = 1; return; } if(m->type == 1) { t = m->time; } }
/*---------------------------------------------------------------------------*/ static void send_rrep(struct route_discovery_conn *c, const linkaddr_t *dest) { struct rrep_hdr *rrepmsg; struct route_entry *rt; linkaddr_t saved_dest; linkaddr_copy(&saved_dest, dest); packetbuf_clear(); dest = &saved_dest; rrepmsg = packetbuf_dataptr(); packetbuf_set_datalen(sizeof(struct rrep_hdr)); rrepmsg->hops = 0; linkaddr_copy(&rrepmsg->dest, dest); linkaddr_copy(&rrepmsg->originator, &linkaddr_node_addr); rt = route_lookup(dest); if(rt != NULL) { PRINTF("%d.%d: send_rrep to %d.%d via %d.%d\n", linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1], dest->u8[0],dest->u8[1], rt->nexthop.u8[0],rt->nexthop.u8[1]); unicast_send(&c->rrepconn, &rt->nexthop); } else { PRINTF("%d.%d: no route for rrep to %d.%d\n", linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1], dest->u8[0],dest->u8[1]); } }
static void send_request(void *arg) { struct deluge_object *obj; struct deluge_msg_request request; obj = (struct deluge_object *)arg; request.cmd = DELUGE_CMD_REQUEST; request.pagenum = obj->current_rx_page; request.version = obj->pages[request.pagenum].version; request.request_set = ~obj->pages[obj->current_rx_page].packet_set; request.object_id = obj->object_id; PRINTF("Sending request for page %d, version %u, request_set %u\n", request.pagenum, request.version, request.request_set); packetbuf_copyfrom(&request, sizeof(request)); unicast_send(&deluge_uc, &obj->summary_from); /* Deluge R.2 */ if(++obj->nrequests == CONST_LAMBDA) { /* XXX check rate here too. */ obj->nrequests = 0; transition(DELUGE_STATE_MAINTAIN); } else { ctimer_reset(&rx_timer); } }
/*---------------------------------------------------------------------------*/ int stunicast_send_stubborn(struct stunicast_conn *c, const rimeaddr_t *receiver, clock_time_t rxmittime) { if(c->buf != NULL) { queuebuf_free(c->buf); } c->buf = queuebuf_new_from_packetbuf(); if(c->buf == NULL) { return 0; } rimeaddr_copy(&c->receiver, receiver); ctimer_set(&c->t, rxmittime, send, c); PRINTF("%d.%d: stunicast_send_stubborn to %d.%d\n", rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1], c->receiver.u8[0],c->receiver.u8[1]); unicast_send(&c->c, &c->receiver); /* if(c->u->sent != NULL) { c->u->sent(c); }*/ return 1; }
static void recv_uc(struct unicast_conn *c, const linkaddr_t *from) { printf("unicast message received from %x.%x: '%s'\n", from->u8[0], from->u8[1], (char *)packetbuf_dataptr()); sprintf(buff_, NET_TEST_CFG_REQUEST_MSG, rec_count); printf("packet: %s\n buff: %s\n", (char *)packetbuf_dataptr(), buff_); if(strcmp((char *)packetbuf_dataptr(), buff_) == 0) { static linkaddr_t addr; addr.u16 = UIP_HTONS(CANDIDATE_LINK_ADDR); static int8_t idx = 0; char buff_[30] = { '\0' }; sprintf(buff_, NET_TEST_CFG_REQUEST_MSG, rec_count); packetbuf_copyfrom(buff_, NET_TEST_CFG_REQUEST_MSG_LEN); unicast_send(&uc, &addr); printf("send: %s\n", buff_); rec_count++; } /* check if done */ if(rec_count == 10) { rec_count = 0; } }
/*---------------------------------------------------------------------------*/ static void send_data(linkaddr_t *next) { PRINTF("uip-over-mesh: %d.%d: send_data with len %d\n", linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1], packetbuf_totlen()); unicast_send(&dataconn, next); }
/*---------------------------------------------------------------------------*/ int stunicast_send(struct stunicast_conn *c, const rimeaddr_t *receiver) { PRINTF("%d.%d: stunicast_send to %d.%d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], receiver->u8[0], receiver->u8[1]); return unicast_send(&c->c, receiver); }
/*---------------------------------------------------------------------------*/ static void rrep_packet_received(struct unicast_conn *uc, const rimeaddr_t *from) { struct rrep_hdr *msg = packetbuf_dataptr(); struct route_entry *rt; rimeaddr_t dest; struct route_discovery_conn *c = (struct route_discovery_conn *) ((char *)uc - offsetof(struct route_discovery_conn, rrepconn)); PRINTF("%d.%d: rrep_packet_received from %d.%d towards %d.%d len %d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], from->u8[0],from->u8[1], msg->dest.u8[0],msg->dest.u8[1], packetbuf_datalen()); PRINTF("from %d.%d hops %d rssi %d lqi %d\n", from->u8[0], from->u8[1], msg->hops, packetbuf_attr(PACKETBUF_ATTR_RSSI), packetbuf_attr(PACKETBUF_ATTR_LINK_QUALITY)); insert_route(&msg->originator, from, msg->hops); if(rimeaddr_cmp(&msg->dest, &rimeaddr_node_addr)) { PRINTF("rrep for us!\n"); rrep_pending = 0; ctimer_stop(&c->t); if(c->cb->new_route) { rimeaddr_t originator; /* If the callback modifies the packet, the originator address will be lost. Therefore, we need to copy it into a local variable before calling the callback. */ rimeaddr_copy(&originator, &msg->originator); c->cb->new_route(c, &originator); } } else { rimeaddr_copy(&dest, &msg->dest); rt = route_lookup(&msg->dest); if(rt != NULL) { PRINTF("forwarding to %d.%d\n", rt->nexthop.u8[0], rt->nexthop.u8[1]); msg->hops++; unicast_send(&c->rrepconn, &rt->nexthop); } else { PRINTF("%d.%d: no route to %d.%d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], msg->dest.u8[0], msg->dest.u8[1]); } } }
static void alarmCallback() { static struct RTC_time t_now; static struct unicast_message *tmp, sMsg; static struct sensor_data sens_data; static uint16_t samplingDelay = 280; static uint16_t delay = 40; // ADC requires minimum 20 us of sampling time. static uint16_t sleepDelay = 9680; static uint16_t avg; static uint8_t count = 0; if(count==0) RTC_getTime(&t_now); int len; uint8_t i, numSampl = 20; static uint16_t v = 0, v1; ioPins_configurePin(8, USEGPIO, OUTPUT, NOPULLUP, HYSTERESIS_OFF); ioPins_configurePin(7, USEGPIO, OUTPUT, NOPULLUP, HYSTERESIS_OFF); ioPins_setValue(8, 1); ioPins_setValue(7, 1); avg = 0; for(i=0;i<numSampl;i++) { ioPins_setValue(8, 0); clock_delay_usec(samplingDelay); v = ioPins_getValue(16); avg+=v; clock_delay_usec(delay); ioPins_setValue(8, 1); clock_delay_usec(sleepDelay); } sens_data.lraw[count] = avg&0xFF; sens_data.hraw[count] = (avg&0xFF00)>>8; if(count==59) { sMsg.id = id; sMsg.type = DATA_REQ; sMsg.time = t_now; strcpy(sMsg.name, "Dust sensor\0"); sMsg.data = sens_data; sMsg.numSampl = numSampl; packetbuf_copyfrom(&sMsg, sizeof(struct unicast_message)); unicast_send(&unicast, &nmaddr); count = 0; } else { count++; } }
static void unicast_ack(const rimeaddr_t *ackto, char *no) { char ack[20]; sprintf(ack, "Ack%s", no); packetbuf_copyfrom(ack, 20); unicast_send(&uc, ackto); unicast_prr(2); printf("Base Station: Acknowledgment sent \n"); }
int transmit_unicast(char *message, uint8_t addr_one) { rimeaddr_t addr; packetbuf_copyfrom(message, strlen(message)); addr.u8[0] = addr_one; addr.u8[1] = 0; if (!rimeaddr_cmp(&addr, &rimeaddr_node_addr)) return unicast_send(&uc, &addr); else return 0; }
/*---------------------------------------------------------------------------*/ static void recv_unicast(struct unicast_conn *c, const rimeaddr_t *from) { process_incoming_packet(); if(is_sender) { struct datapath_msg *msg = packetbuf_dataptr(); if(msg->datapath_command == DATAPATH_COMMAND_ECHO_REPLY) { process_post(&shell_netperf_process, CONTINUE_EVENT, NULL); } } else if(construct_reply(from)) { unicast_send(&unicast, from); } }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(example_unicast_process, ev, data) { static int i = 0; static struct etimer et; PROCESS_EXITHANDLER(unicast_close(&uc)); PROCESS_BEGIN(); unicast_open(&uc, 128, &unicast_callbacks); printf("rimeaddr_node_addr = [%u, %u]\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1]); /* Put receiver node in listening mode */ if (rimeaddr_node_addr.u8[0] == receiver_node_rime_addr[0] && rimeaddr_node_addr.u8[1] == receiver_node_rime_addr[1]) { /* * Exit process * Received messages handled by 'recv_uc(...)' */ printf("Receiver node listening\n"); } else { /* Sending messages */ printf("Write a character on serial link to send message\n"); PROCESS_WAIT_EVENT_UNTIL(ev == serial_line_event_message); etimer_set(&et, 1 * CLOCK_SECOND); while (1) { char msg[64]; int len; rimeaddr_t addr; PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); len = 1 + sprintf(msg, "hello world #%u", i); i++; packetbuf_copyfrom(msg, len); addr.u8[0] = receiver_node_rime_addr[0]; addr.u8[1] = receiver_node_rime_addr[1]; unicast_send(&uc, &addr); printf("unicast message sent [%i bytes]\n", len); etimer_reset(&et); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(shell_unicast_send_process, ev, data) { struct shell_input *input; static linkaddr_t receiver; int len; const char *nextptr; struct unicast_msg *msg; PROCESS_BEGIN(); receiver.u8[0] = shell_strtolong(data, &nextptr); if(nextptr == data || *nextptr != '.') { shell_output_str(&unicast_send_command, "unicast <receiver>: recevier must be specified", ""); PROCESS_EXIT(); } ++nextptr; receiver.u8[1] = shell_strtolong(nextptr, &nextptr); /* snprintf(buf, sizeof(buf), "%d.%d", receiver.u8[0], receiver.u8[1]); shell_output_str(&unicast_send_command, "Sending unicast packets to ", buf);*/ while(1) { PROCESS_WAIT_EVENT_UNTIL(ev == shell_event_input); input = data; len = input->len1 + input->len2; if(len == 0) { PROCESS_EXIT(); } if(len < MAX_DATALEN) { packetbuf_clear(); packetbuf_set_datalen(len + UNICAST_MSG_HDRSIZE); msg = packetbuf_dataptr(); memcpy(msg->data, input->data1, input->len1); memcpy(msg->data + input->len1, input->data2, input->len2); #if TIMESYNCH_CONF_ENABLED msg->timestamp = timesynch_time(); #else msg->timestamp = 0; #endif /* printf("Sending %d bytes\n", len);*/ unicast_send(&uc, &receiver); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(shell_sendcmd_process, ev, data) { struct cmd_msg *msg; int len; linkaddr_t addr; const char *nextptr; char buf[32]; PROCESS_BEGIN(); addr.u8[0] = shell_strtolong(data, &nextptr); if(nextptr == data || *nextptr != '.') { shell_output_str(&sendcmd_command, "sendcmd <node addr>: receiver must be specified", ""); PROCESS_EXIT(); } ++nextptr; addr.u8[1] = shell_strtolong(nextptr, &nextptr); snprintf(buf, sizeof(buf), "%d.%d", addr.u8[0], addr.u8[1]); shell_output_str(&sendcmd_command, "Sending command to ", buf); /* Get the length of the command line, excluding a terminating NUL character. */ len = strlen((char *)nextptr); /* Check the length of the command line to see that it is small enough to fit in a packet. We count with 32 bytes of header, which may be a little too much, but at least we are on the safe side. */ if(len > PACKETBUF_SIZE - 32) { snprintf(buf, sizeof(buf), "%d", len); shell_output_str(&sendcmd_command, "command line too large: ", buf); PROCESS_EXIT(); } packetbuf_clear(); msg = packetbuf_dataptr(); packetbuf_set_datalen(len + 1 + CMDMSG_HDR_SIZE); strcpy(msg->sendcmd, nextptr); /* Terminate the string with a NUL character. */ msg->sendcmd[len] = 0; msg->crc = crc16_data((unsigned char *)msg->sendcmd, len, 0); /* printf("sendcmd sending '%s'\n", msg->sendcmd);*/ unicast_send(&uc, &addr); PROCESS_END(); }
/*---------------------------------------------------------------------------*/ static void send(void *ptr) { struct stunicast_conn *c = ptr; PRINTF("%d.%d: stunicast: resend to %d.%d\n", rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1], c->receiver.u8[0], c->receiver.u8[1]); if(c->buf) { queuebuf_to_packetbuf(c->buf); unicast_send(&c->c, &c->receiver); stunicast_set_timer(c, CLOCK_SECOND); } /* if(c->u->sent != NULL) { c->u->sent(c); }*/ }
static void startReading() { struct unicast_message msg, *tmp; rimeaddr_t *add; struct RTC_time time; while(1) { msg.id = id; msg.type = DATA_REQ; RTC_getTime(&time); msg.time = time; packetbuf_copyfrom(&msg, sizeof(struct unicast_message)); unicast_send(&unicast, &nmaddr); clock_delay_msec(1000); } }
static void send(uint16_t intensity,enum pkt_type type,uint16_t seqno,rimeaddr_t sink_addr) { static uint8_t out_buf[128]; struct pkt_format *pkt; uint16_t i; /* Pad the output buffer with the actual packet we're sending. */ for (i=0;i<config.payload_len;i+=sizeof(struct pkt_format)) { pkt = (struct pkt_format *) (out_buf + i); pkt->type = type; pkt->seqno = seqno; pkt->sensor_readings=intensity; memcpy(&pkt->src, &rimeaddr_node_addr, sizeof(rimeaddr_t)); //memcpy(&pkt->dest, dest, sizeof(rimeaddr_t)); } packetbuf_copyfrom(out_buf, config.payload_len); unicast_send(&uc,&sink_addr); }
static void unicast_msgsend() { rimeaddr_t addr; char seq[20]; sprintf(seq, "Sender Check %d", i); packetbuf_copyfrom(seq, 20); addr.u8[0] = 3; addr.u8[1] = 0; if(!rimeaddr_cmp(&addr, &rimeaddr_node_addr)) { unicast_send(&uc, &addr); unicast_prr(1); printf("Sender: Packet Sent\n"); i++; } }
/* This function is called for every incoming unicast packet. */ static void recv_uc(struct unicast_conn *c, const linkaddr_t *from) { struct unicast_message *msg; /* Grab the pointer to the incoming data. */ msg = packetbuf_dataptr(); /* We have two message types, UNICAST_TYPE_PING and UNICAST_TYPE_PONG. If we receive a UNICAST_TYPE_PING message, we print out a message and return a UNICAST_TYPE_PONG. */ if(msg->type == UNICAST_TYPE_PING) { printf("unicast ping received from %d.%d\n", from->u8[0], from->u8[1]); msg->type = UNICAST_TYPE_PONG; packetbuf_copyfrom(msg, sizeof(struct unicast_message)); /* Send it back to where it came from. */ unicast_send(c, from); } }
// Timer timeout callback static void ctimer1_callback(void *ptr) { leds_on(LEDS_GREEN); struct message msg; msg.seqno = count++; packetbuf_clear(); packetbuf_copyfrom(&msg, sizeof(struct message)); rimeaddr_t addr; addr.u8[0] = RECEIVER; addr.u8[1] = 0; unicast_send(&uc, &addr); printf("Sending message %ld to %d.0\n",msg.seqno,RECEIVER); if(count >= total_to_be_sent){ count = 0; } else{ ctimer_set(&timer1, PACKETS_TIME, ctimer1_callback, NULL); } leds_off(LEDS_GREEN); }
/*---------------------------------------------------------------------------*/ void data_packet_received(struct unicast_conn *uc, rimeaddr_t *from) { struct multihop_conn *c = (struct multihop_conn *)uc; rimeaddr_t *nexthop; rimeaddr_t sender, receiver; /* Copy the packet attributes to avoid them being overwritten or cleared by an application program that uses the packet buffer for its own needs. */ rimeaddr_copy(&sender, packetbuf_addr(PACKETBUF_ADDR_ESENDER)); rimeaddr_copy(&receiver, packetbuf_addr(PACKETBUF_ADDR_ERECEIVER)); PRINTF("data_packet_received from %d.%d towards %d.%d len %d\n", from->u8[0], from->u8[1], packetbuf_addr(PACKETBUF_ADDR_ERECEIVER)->u8[0], packetbuf_addr(PACKETBUF_ADDR_ERECEIVER)->u8[1], packetbuf_datalen()); if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_ERECEIVER), &rimeaddr_node_addr)) { PRINTF("for us!\n"); if(c->cb->recv) { c->cb->recv(c, &sender, from, packetbuf_attr(PACKETBUF_ATTR_HOPS)); } } else { nexthop = NULL; if(c->cb->forward) { nexthop = c->cb->forward(c, &sender, &receiver, from, packetbuf_attr(PACKETBUF_ATTR_HOPS)); packetbuf_set_attr(PACKETBUF_ATTR_HOPS, packetbuf_attr(PACKETBUF_ATTR_HOPS) + 1); } if(nexthop) { PRINTF("forwarding to %d.%d\n", nexthop->u8[0], nexthop->u8[1]); unicast_send(&c->c, nexthop); } } }
PROCESS_THREAD(send_process, ev, data) { static struct etimer et; linkaddr_t addr; PROCESS_BEGIN(); unicast_open(&uc, 128, &unicast_call); while(1){ etimer_set(&et, CLOCK_SECOND); PROCESS_WAIT_UNTIL(etimer_expired(&et)); leds_toggle(LEDS_BLUE); packetbuf_copyfrom("hellohellohellohellohello", 30); addr.u8[0] = 1; addr.u8[1] = 0; printf("unicast sending\n"); unicast_send(&uc, &addr); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ int multihop_send(struct multihop_conn *c, const rimeaddr_t *to) { rimeaddr_t *nexthop; if(c->cb->forward == NULL) { return 0; } packetbuf_compact(); packetbuf_set_addr(PACKETBUF_ADDR_ERECEIVER, to); packetbuf_set_addr(PACKETBUF_ADDR_ESENDER, &rimeaddr_node_addr); packetbuf_set_attr(PACKETBUF_ATTR_HOPS, 1); nexthop = c->cb->forward(c, &rimeaddr_node_addr, to, NULL, 0); if(nexthop == NULL) { PRINTF("multihop_send: no route\n"); return 0; } else { PRINTF("multihop_send: sending data towards %d.%d\n", nexthop->u8[0], nexthop->u8[1]); unicast_send(&c->c, nexthop); return 1; } }
/* this function has been defined to be called when a unicast is being received */ static void recv_uc(struct unicast_conn *c, const rimeaddr_t *from) { // Round-trip time, will be decremented later clock_time_t rtt = clock_time(); printf("unicast message received from %d.%d\n", from->u8[0], from->u8[1]); /* turn on blue led */ leds_on(LEDS_BLUE); /* set the timer "leds_off_timer" to 1/8 second */ ctimer_set(&leds_off_timer_send, CLOCK_SECOND / 8, timerCallback_turnOffLeds, NULL); /* from the packet we have just received, read the data and write it into the * struct tmReceived we have declared and instantiated above (line 16) */ packetbuf_copyto(&tmReceived); /* print the contents of the received packet */ printf("time received = %d clock ticks", (uint16_t)tmReceived.time); printf(" = %d secs ", (uint16_t)tmReceived.time / CLOCK_SECOND); printf("%d millis ", (1000L * ((uint16_t)tmReceived.time % CLOCK_SECOND)) / CLOCK_SECOND); printf("originator = %d\n", tmReceived.originator); // If the packet received is not ours, send it back to the originator if(tmReceived.originator != node_id) { packetbuf_copyfrom(&tmReceived, sizeof(tmSent)); if(!rimeaddr_cmp(&addr, &rimeaddr_node_addr)) { /* when calling unicast_send, we have to specify the address as the second argument (a pointer to the defined rimeaddr_t struct) */ unicast_send(&uc, &addr); } printf("sending packet to %u\n", addr.u8[0]); } else { // Our packet has completed a round-trip rtt -= tmReceived.time; printf("RTT = %d ms\n", (1000L * ((uint16_t)rtt % CLOCK_SECOND)) / CLOCK_SECOND); } }
PROCESS_THREAD(rime_unicast_sender, ev, data) { PROCESS_EXITHANDLER(unicast_close(&uc)); PROCESS_BEGIN(); leds_init(); leds_off(LEDS_ALL); SENSORS_ACTIVATE(button_sensor);//activate button unicast_open(&uc, 290, &unicast_callbacks); // channel = 122 while(1) { static struct etimer et; rimeaddr_t addr; PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor); //etimer_set(&et, CLOCK_SECOND); //PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); packetbuf_copyfrom(SECRET, 15); // String + Length to be send //packetbuf_copyfrom("ekhais8ca6Aej0", 15); // String + Length to be send addr.u8[0] = 0x28; // Address of receiving Node addr.u8[1] = 0x1; if(!rimeaddr_cmp(&addr, &rimeaddr_node_addr)) { printf("Message sent\n"); // debug message unicast_send(&uc, &addr); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(shell_netperf_process, ev, data) { static struct etimer e; static rimeaddr_t receiver; const char *nextptr; const char *args; static char recvstr[40]; static int i, num_packets; static uint8_t do_broadcast, do_unicast, do_pingpong, do_stream_pingpong; PROCESS_BEGIN(); current_type = TYPE_NONE; do_broadcast = do_unicast = do_pingpong = do_stream_pingpong = 0; args = data; /* Parse the -bups options */ while(*args == '-') { ++args; while(*args != ' ' && *args != 0) { if(*args == 'b') { do_broadcast = 1; } if(*args == 'u') { do_unicast = 1; } if(*args == 'p') { do_pingpong = 1; } if(*args == 's') { do_stream_pingpong = 1; } ++args; } while(*args == ' ') { args++; } } /* Parse the receiver address */ receiver.u8[0] = shell_strtolong(args, &nextptr); if(nextptr == data || *nextptr != '.') { print_usage(); PROCESS_EXIT(); } args = nextptr + 1; receiver.u8[1] = shell_strtolong(args, &nextptr); /* Store the receiver address as a string since we need to print it out later. */ snprintf(recvstr, sizeof(recvstr), "%d.%d", receiver.u8[0], receiver.u8[1]); /* Parse the number of packets to send */ args = nextptr; while(*args == ' ') { ++args; } num_packets = shell_strtolong(args, &nextptr); if(nextptr == data || num_packets == 0) { print_usage(); PROCESS_EXIT(); } /* Send broadcast packets, if requested */ if(do_broadcast) { current_type = TYPE_BROADCAST; shell_output_str(&netperf_command, "-------- Broadcast --------", ""); shell_output_str(&netperf_command, "Contacting ", recvstr); send_ctrl_command(&receiver, CTRL_COMMAND_CLEAR); PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT); shell_output_str(&netperf_command, "Measuring broadcast performance to ", recvstr); setup_sending(&receiver, num_packets); for(i = 0; i < num_packets; ++i) { if(construct_next_packet()) { broadcast_send(&broadcast); stats.sent++; } PROCESS_PAUSE(); } shell_output_str(&netperf_command, "Requesting statistics from ", recvstr); send_ctrl_command(&receiver, CTRL_COMMAND_STATS); PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT); /* Wait for reply */ PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT); finalize_stats(&stats); print_local_stats(&stats); } if(do_unicast) { current_type = TYPE_UNICAST; shell_output_str(&netperf_command, "-------- Unicast one-way --------", ""); shell_output_str(&netperf_command, "Contacting ", recvstr); send_ctrl_command(&receiver, CTRL_COMMAND_CLEAR); PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT); shell_output_str(&netperf_command, "Measuring unicast performance to ", recvstr); setup_sending(&receiver, num_packets); for(i = 0; i < num_packets; ++i) { if(construct_next_packet()) { unicast_send(&unicast, &receiver); stats.sent++; } PROCESS_PAUSE(); } shell_output_str(&netperf_command, "Requesting statistics from ", recvstr); send_ctrl_command(&receiver, CTRL_COMMAND_STATS); PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT); /* Wait for reply */ PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT); finalize_stats(&stats); print_local_stats(&stats); } if(do_pingpong) { current_type = TYPE_UNICAST_PINGPONG; shell_output_str(&netperf_command, "-------- Unicast ping-pong--------", ""); shell_output_str(&netperf_command, "Contacting ", recvstr); send_ctrl_command(&receiver, CTRL_COMMAND_CLEAR); PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT); shell_output_str(&netperf_command, "Measuring two-way unicast performance to ", recvstr); setup_sending(&receiver, num_packets); for(i = 0; i < num_packets; ++i) { if(construct_next_echo()) { unicast_send(&unicast, &receiver); stats.sent++; } etimer_set(&e, CLOCK_SECOND); PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT || etimer_expired(&e)); } shell_output_str(&netperf_command, "Requesting statistics from ", recvstr); send_ctrl_command(&receiver, CTRL_COMMAND_STATS); PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT); /* Wait for reply */ PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT); finalize_stats(&stats); print_local_stats(&stats); } if(do_stream_pingpong) { current_type = TYPE_UNICAST_STREAM; shell_output_str(&netperf_command, "-------- Unicast stream ping-pong--------", ""); shell_output_str(&netperf_command, "Contacting ", recvstr); send_ctrl_command(&receiver, CTRL_COMMAND_CLEAR); PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT); shell_output_str(&netperf_command, "Measuring two-way unicast stream performance to ", recvstr); setup_sending(&receiver, num_packets); for(i = 0; i < num_packets; ++i) { if(construct_next_stream_echo()) { unicast_send(&unicast, &receiver); stats.sent++; } etimer_set(&e, CLOCK_SECOND); PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT || etimer_expired(&e)); } shell_output_str(&netperf_command, "Requesting statistics from ", recvstr); send_ctrl_command(&receiver, CTRL_COMMAND_STATS); PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT); /* Wait for reply */ PROCESS_YIELD_UNTIL(ev == CONTINUE_EVENT); finalize_stats(&stats); print_local_stats(&stats); } shell_output_str(&netperf_command, "Done", ""); PROCESS_END(); }
/*---------------------------------------------------------------------------*/ void multihop_resend(struct multihop_conn *c, const rimeaddr_t *nexthop) { unicast_send(&c->c, nexthop); }