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);
}
