/**
* the sensor node subscribed will send the data to the base station via the next hop according to the routing table
*/
void publish(struct runicast_conn *runicast){
Ru_msg_list *ru_msg_list;
Rt_table *chosen_route;
if(list_length(runicast_list)>0){
for(ru_msg_list = list_head(runicast_list);ru_msg_list!=NULL;){
chosen_route = find_best_route();
current_route = chosen_route;
if(current_route!=NULL){
packetbuf_copyfrom(&ru_msg_list->runicast_msg, sizeof(Runicast_msg));
printf("[RU] @%d-@%u.%u->@%u.%u\n", clock_seconds(),rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1],
chosen_route->rt_entry.next_hop.u8[0],chosen_route->rt_entry.next_hop.u8[1]);
runicast_send(runicast,&chosen_route->rt_entry.next_hop,MAX_RETRANSMISSIONS);
packetbuf_clear();
Ru_msg_list *to_remove;
to_remove = ru_msg_list;
ru_msg_list = ru_msg_list->next;
// if(ru_send_success == true){
// list_remove(runicast_list,to_remove);
// memb_free(&runicast_list_memb,to_remove);
// printf("[DELET-RU-MSG]\n");
// }
}else{
printf("[ERRO] current route is none");
}
}
}
remove_all_runicast_entry();
}
static void
recv_ctrl(struct runicast_conn *c, const rimeaddr_t *from, uint8_t seqno)
{
static uint8_t last_seqno = -1;
struct stats s;
struct ctrl_msg *msg = packetbuf_dataptr();
if(last_seqno == seqno) {
return;
}
last_seqno = seqno;
switch(msg->command) {
case CTRL_COMMAND_STATS:
msg->command = CTRL_COMMAND_STATS_REPLY;
finalize_stats(&stats);
memcpy_misaligned(&msg->stats, &stats, sizeof(stats));
packetbuf_set_datalen(sizeof(struct ctrl_msg));
runicast_send(c, from, MAX_RETRIES);
break;
case CTRL_COMMAND_STATS_REPLY:
memcpy_misaligned(&s, &msg->stats, sizeof(stats));
print_remote_stats(&s);
process_post(&shell_netperf_process, CONTINUE_EVENT, NULL);
break;
case CTRL_COMMAND_CLEAR:
clear_stats();
break;
}
}
PROCESS_THREAD(shell_sendfile_process, ev, data)
{
const char *nextptr;
static rimeaddr_t addr;
int len;
char buf[32];
PROCESS_BEGIN();
/* Parse node addr */
addr.u8[0] = shell_strtolong(data, &nextptr);
if(nextptr == data || *nextptr != '.') {
printf("sendfile <node addr> <filename>: need node address\n");
PROCESS_EXIT();
}
++nextptr;
addr.u8[1] = shell_strtolong(nextptr, &nextptr);
printf("\nnode address: %d.%d\n", addr.u8[0], addr.u8[1]);
while(nextptr[0] == ' ') nextptr++;
len = strlen(nextptr);
//snprintf(buf, sizeof(buf), "%d.%d", addr.u8[0], addr.u8[1]);
if(len > MAX_FILENAME_SIZE) {
snprintf(buf, sizeof(buf), "%d", len);
printf("filename too large: ", buf);
PROCESS_EXIT();
}
sendfile_filename = nextptr;
printf("filename: %s\n", sendfile_filename);
sprintf(filenameOriginatorSent.name, "%s", sendfile_filename);
filenameOriginatorSent.originator = node_id;
packetbuf_copyfrom(&filenameOriginatorSent, sizeof(filenameOriginatorSent));
runicast_send(&runicastSendCommand, &addr, MAX_RETRANSMISSIONS);
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
static void
received(struct runicast_conn *uc, const rimeaddr_t *from, uint8_t seqno)
{
struct rmh_conn *c = (struct rmh_conn *)uc;
struct data_hdr *msg = packetbuf_dataptr();
rimeaddr_t *nexthop;
PRINTF("data_packet_received from %d.%d towards %d.%d len %d\n",
from->u8[0], from->u8[1],
msg->dest.u8[0], msg->dest.u8[1],
packetbuf_datalen());
if(rimeaddr_cmp(&msg->dest, &rimeaddr_node_addr)) {
PRINTF("for us!\n");
packetbuf_hdrreduce(sizeof(struct data_hdr));
if(c->cb->recv) {
c->cb->recv(c, &msg->originator, msg->hops);
}
} else {
nexthop = NULL;
if(c->cb->forward) {
nexthop = c->cb->forward(c, &msg->originator,
&msg->dest, from, msg->hops);
}
if(nexthop) {
PRINTF("forwarding to %d.%d\n", nexthop->u8[0], nexthop->u8[1]);
msg->hops++;
runicast_send(&c->c, nexthop, c->num_rexmit);
}
}
}
/*---------------------------------------------------------------------------*/
int
rmh_send(struct rmh_conn *c, rimeaddr_t *to, uint8_t num_rexmit, uint8_t max_hops)
{
rimeaddr_t *nexthop;
struct data_hdr *hdr;
c->num_rexmit = num_rexmit;
if(c->cb->forward == NULL) {
return 0;
}
nexthop = c->cb->forward(c, &rimeaddr_node_addr, to, NULL, 0);
if(nexthop == NULL) {
PRINTF("rmh_send: no route\n");
return 0;
} else {
PRINTF("rmh_send: sending data\n");
if(packetbuf_hdralloc(sizeof(struct data_hdr))) {
hdr = packetbuf_hdrptr();
rimeaddr_copy(&hdr->dest, to);
rimeaddr_copy(&hdr->originator, &rimeaddr_node_addr);
hdr->hops = 1;
hdr->max_rexmits = num_rexmit;
runicast_send(&c->c, nexthop, num_rexmit);
}
return 1;
}
}
/* this function has been defined to be called when a unicast is being received */
static void recv_runicast(struct runicast_conn *c, rimeaddr_t *from, uint8_t seqno)
{
printf("runicast message received from %d.%d, seqno %d\n", from->u8[0], from->u8[1], seqno);
/* from the packet we have just received, read the data and write it into the
* struct tmReceived we have declared and instantiated above (line 26)
*/
packetbuf_copyto(&tmReceived);
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);
leds_on(LEDS_BLUE);
ctimer_set(&ledTimer, CLOCK_SECOND / 8, timerCallback_turnOffLeds, NULL);
// If the packet received is not ours, send it back to the originator
if(tmReceived.originator != node_id) {
packetbuf_copyfrom(&tmReceived, sizeof(tmSent));
runicast_send(&runicast, &addr, MAX_RETRANSMISSIONS);
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);
}
}
void sendToRoomLightNode(unsigned char* c, int bytes)
{
unsigned char* buffer;
char bufferLength = setBuffer(&buffer, c, bytes, HT_NODE_HIGH, RL_NODE_HIGH);
packetbuf_copyfrom(buffer, bufferLength);
runicast_send(&cuRunicastConnection, ¢ralNodeAddress, MAX_RETRANSMISSIONS);
free(buffer);
}
/**
* publish a single message
*/
void single_publish(struct runicast_conn *runicast,Runicast_msg runicast_msg){
packetbuf_copyfrom(&runicast_msg, sizeof(Runicast_msg));
printf("[RU] timestamp @%d seqno %d last hop address %u.%u\n", runicast_msg.timestamp,runicast_msg.seqno,runicast_msg.last_hop.u8[0],runicast_msg.last_hop.u8[1]);
runicast_send(runicast,&find_best_route()->rt_entry.next_hop,MAX_RETRANSMISSIONS);
packetbuf_clear();
}
int transmit_runicast(char *message, uint8_t addr_one)
{
rimeaddr_t recv;
packetbuf_copyfrom(message, strlen(message));
recv.u8[0] = addr_one;
recv.u8[1] = 0;
packetbuf_copyfrom(message, strlen(message));
return runicast_send(&runicast, &recv, MAX_RETRANSMISSIONS);
}
/*---------------------------------------------------------------------------*/
static void
send_queued_packet(void)
{
struct queuebuf *q;
struct neighbor *n;
struct packetqueue_item *i;
struct collect_conn *c;
i = packetqueue_first(&forwarding_queue);
if(i == NULL) {
PRINTF("%d.%d: nothing on queue\n",
rimeaddr_node_addr.u8[RIMEADDR_SIZE-2], rimeaddr_node_addr.u8[RIMEADDR_SIZE-1]);
/* No packet on the queue, so there is nothing for us to send. */
return;
}
c = packetqueue_ptr(i);
if(c == NULL) {
/* c should not be NULL, but we check it just to be sure. */
PRINTF("%d.%d: queue, c == NULL!\n",
rimeaddr_node_addr.u8[RIMEADDR_SIZE-2], rimeaddr_node_addr.u8[RIMEADDR_SIZE-1]);
return;
}
if(c->forwarding) {
/* If we are currently forwarding a packet, we wait until the
packet is forwarded and try again then. */
PRINTF("%d.%d: queue, c is forwarding\n",
rimeaddr_node_addr.u8[RIMEADDR_SIZE-2], rimeaddr_node_addr.u8[RIMEADDR_SIZE-1]);
return;
}
q = packetqueue_queuebuf(i);
if(q != NULL) {
PRINTF("%d.%d: queue, q is on queue\n",
rimeaddr_node_addr.u8[RIMEADDR_SIZE-2], rimeaddr_node_addr.u8[RIMEADDR_SIZE-1]);
queuebuf_to_packetbuf(q);
n = neighbor_best();
/* Don't send to the neighbor if it is the same neighbor that sent
us the packet. */
if(n != NULL && !rimeaddr_cmp(&n->addr, packetbuf_addr(PACKETBUF_ADDR_SENDER))) {
#if CONTIKI_TARGET_NETSIM
ether_set_line(n->addr.u8[0], n->addr.u8[1]);
#endif /* CONTIKI_TARGET_NETSIM */
PRINTF("%d.%d: sending packet to %d.%d\n",
rimeaddr_node_addr.u8[RIMEADDR_SIZE-2], rimeaddr_node_addr.u8[RIMEADDR_SIZE-1],
n->addr.u8[RIMEADDR_SIZE-2], n->addr.u8[RIMEADDR_SIZE-1]);
c->forwarding = 1;
runicast_send(&c->runicast_conn, &n->addr, packetbuf_attr(PACKETBUF_ATTR_MAX_REXMIT));
} else {
PRINTF("%d.%d: did not find any neighbor to forward to\n",
rimeaddr_node_addr.u8[RIMEADDR_SIZE-2], rimeaddr_node_addr.u8[RIMEADDR_SIZE-1]);
}
}
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(shell_download_process, ev, data)
{
const char *nextptr;
static rimeaddr_t addr;
int len;
char buf[32];
PROCESS_BEGIN();
/* Parse node addr */
addr.u8[0] = shell_strtolong(data, &nextptr);
if(nextptr == data || *nextptr != '.') {
shell_output_str(&download_command,
"download <node addr> <filename>: need node address", "");
PROCESS_EXIT();
}
++nextptr;
addr.u8[1] = shell_strtolong(nextptr, &nextptr);
/* Get the length of the file, excluding a terminating NUL character. */
while(nextptr[0] == ' ') {
nextptr++;
}
len = strlen(nextptr);
/*snprintf(buf, sizeof(buf), "%d.%d", addr.u8[0], addr.u8[1]);*/
/*shell_output_str(&download_command, "Downloading from: ", buf);*/
if(len > PACKETBUF_SIZE - 32) {
snprintf(buf, sizeof(buf), "%d", len);
shell_output_str(&download_command, "filename too large: ", buf);
PROCESS_EXIT();
}
/*shell_output_str(&download_command, "Downloading file: ", nextptr);*/
/* Send file request */
downloading = 1;
rucb_open(&rucb, RUCB_CHANNEL, &rucb_call);
packetbuf_clear();
*((uint8_t *)packetbuf_dataptr()) = ++req_seq_counter;
memcpy(((char *)packetbuf_dataptr()) + 1, nextptr, len + 1);
packetbuf_set_datalen(len + 2);
PRINTF("requesting '%s'\n", nextptr);
runicast_send(&runicast, &addr, MAX_RETRANSMISSIONS);
/* Wait for download to finish */
leds_on(LEDS_BLUE);
PROCESS_WAIT_UNTIL(!runicast_is_transmitting(&runicast) && !downloading);
leds_off(LEDS_BLUE);
rucb_close(&rucb);
/*shell_output_str(&download_command, "Done!", "");*/
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
int
rucb_send(struct rucb_conn *c, const rimeaddr_t *receiver)
{
c->chunk = 0;
read_data(c);
rimeaddr_copy(&c->receiver, receiver);
rimeaddr_copy(&c->sender, &rimeaddr_node_addr);
runicast_send(&c->c, receiver, MAX_TRANSMISSIONS);
return 0;
}
/*---------------------------------------------------------------------------*/
static void
send_ctrl_command(const rimeaddr_t *to, uint8_t command)
{
struct ctrl_msg *msg;
packetbuf_clear();
packetbuf_set_datalen(sizeof(struct ctrl_msg));
msg = packetbuf_dataptr();
msg->command = command;
runicast_send(&ctrl, to, MAX_RETRIES);
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(shell_runicast_process, ev, data)
{
struct shell_input *input;
static rimeaddr_t receiver;
int len;
const char *nextptr;
struct collect_msg *msg;
char buf[30];
PROCESS_BEGIN();
receiver.u8[0] = shell_strtolong(data, &nextptr);
if(nextptr == data || *nextptr != '.') {
shell_output_str(&runicast_command,
"runicast <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(&runicast_command, "Sending runicast 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 < PACKETBUF_SIZE) {
packetbuf_clear();
packetbuf_set_datalen(len + COLLECT_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);*/
runicast_send(&ruc, &receiver, 4);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(unicast_test_process, ev, data)
{
PROCESS_BEGIN();
puts("unicast test start");
runicast_open(&runicast, 144, &runicast_callbacks);
/* Receiver node: do nothing */
if(linkaddr_node_addr.u8[0] == RX_ADDR1 &&
linkaddr_node_addr.u8[1] == RX_ADDR2) {
puts("wait forever");
}
while(1) {
static struct etimer et;
static int seqno;
etimer_set(&et, CLOCK_SECOND * 5);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
if(linkaddr_node_addr.u8[0] == RX_ADDR1 &&
linkaddr_node_addr.u8[1] == RX_ADDR2) {
puts("tick...");
continue;
}
if(!runicast_is_transmitting(&runicast)) {
static char buffer[100] = "hello";
linkaddr_t recv;
memset(&recv, 0, LINKADDR_SIZE);
packetbuf_copyfrom(buffer, sizeof(buffer));
recv.u8[0] = RX_ADDR1;
recv.u8[1] = RX_ADDR2;
printf("%u.%u: sending runicast to address %u.%u\n",
linkaddr_node_addr.u8[0],
linkaddr_node_addr.u8[1],
recv.u8[0],
recv.u8[1]);
packetbuf_set_attr(PACKETBUF_ATTR_PACKET_ID, ++seqno);
runicast_send(&runicast, &recv, MAX_RETRANSMISSIONS);
}
}
PROCESS_END();
}
static void
recv_runicast(struct runicast_conn *c, const rimeaddr_t *from, uint8_t seqno)
{
printf("[RECV] runicast\n");
Runicast_msg *runicast_msg;
runicast_msg = packetbuf_dataptr();
//
// if(local_node.sen_type!=BASE_STATION){
//add_to_RU_list(*runicast_msg);
// Runicast_msg temp;
// memcpy(&temp,runicast_msg, sizeof(Runicast_msg));
// single_publish(&runicast,temp);
packetbuf_copyfrom(runicast_msg, sizeof(Runicast_msg));
printf("[RU] timestamp @%d seqno %u last hop address %u.%u\n", runicast_msg->timestamp,runicast_msg->seqno,runicast_msg->last_hop.u8[0],runicast_msg->last_hop.u8[1]);
runicast_send(&runicast,&find_best_route()->rt_entry.next_hop,MAX_RETRANSMISSIONS);
packetbuf_clear();
}
/*---------------------------------------------------------------------------*/
static void
acked(struct runicast_conn *ruc, const rimeaddr_t *to, uint8_t retransmissions)
{
struct rucb_conn *c = (struct rucb_conn *)ruc;
int len;
PRINTF("%d.%d: rucb acked\n",
rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1]);
c->chunk++;
len = read_data(c);
if(len == 0 && c->last_size == 0) {
/* Nothing more to do */
return;
}
if(len >= 0) {
runicast_send(&c->c, &c->receiver, MAX_TRANSMISSIONS);
c->last_size = len;
}
}
/**
* subscribe node will assemble the data according to the conditions
*/
void assemble_data(){
uint8_t value = random_rand()%10;
assemble_total+=value;
assemble_count++;
if(value>max){
max = value;
}
if(assemble_count>= local_node.assemble_count){
Runicast_msg runicast_msg;
runicast_msg.native_sen_type = local_node.sen_type;
runicast_msg.seqno = clct_data_seqno;
//runicast_msg.timestamp = CLOCK_SECOND;
if(local_node.condition == MAX){
runicast_msg.value = max;
}else if(local_node.condition == AVERAGE ){
runicast_msg.value = (assemble_total)/(assemble_count);
}
rimeaddr_copy(&runicast_msg.last_hop,&rimeaddr_node_addr);
rimeaddr_copy(&runicast_msg.source,&rimeaddr_node_addr);
//add_to_RU_list(runicast_msg);
if(!runicast_is_transmitting(&runicast)){
printf("[PUBLISH] publish data value->%u seqno %u\n",runicast_msg.value,runicast_msg.seqno);
//single_publish(&runicast,runicast_msg);
printf("[RU] timestamp %d seqno %u last hop address %u.%u\n", runicast_msg.timestamp,runicast_msg.seqno,runicast_msg.last_hop.u8[0],runicast_msg.last_hop.u8[1]);
packetbuf_copyfrom(&runicast_msg, sizeof(Runicast_msg));
runicast_send(&runicast,&find_best_route()->rt_entry.next_hop,MAX_RETRANSMISSIONS);
packetbuf_clear();
}
if(clct_data_seqno>254){
clct_data_seqno = 0;
}
clct_data_seqno++;
assemble_count = 0;
assemble_total = 0.0f;
max = 0.0f;
}
}
static void recv_runicast(struct runicast_conn *c, rimeaddr_t *from, uint8_t seqno)
{
printf("runicast message received from %d.%d, seqno %d\n", from->u8[0], from->u8[1], seqno);
packetbuf_copyto(&filenameOriginatorRecv);
printf("originator: %u\n", filenameOriginatorRecv.originator);
printf("filename: %s\n", filenameOriginatorRecv.name);
// request file from initiator
rucb_open(&rucb, RUCB_CHANNEL, &rucb_call);
packetbuf_clear();
*((uint8_t *)packetbuf_dataptr()) = ++req_seq_counter;
memcpy(((char *)packetbuf_dataptr()) + 1, filenameOriginatorRecv.name, strlen(filenameOriginatorRecv.name)+1);
packetbuf_set_datalen(strlen(filenameOriginatorRecv.name) + 2);
rimeaddr_t addr;
addr.u8[0] = filenameOriginatorRecv.originator;
addr.u8[1] = 0;
filename_download = filenameOriginatorRecv.name;
fd = cfs_open(filename_download, CFS_WRITE );
runicast_send(&runicast, &addr, MAX_RETRANSMISSIONS);
downloading = 1;
process_start(&download_and_execute_process, NULL);
}
PROCESS_THREAD(shell_ruc_send_process, ev, data)
{
uint16_t channel;
long channel_long;
const char *next;
linkaddr_t target;
long rime_long;
char buf[6];
char msg_buf[128];
size_t msg_size;
PROCESS_BEGIN();
channel_long = shell_strtolong((char *)data, &next);
if(channel_long <= 0 || channel_long > 65535){
shell_output_str(&ruc_send_command, "channel has to be in range [1-65535]", "");
PROCESS_EXIT();
}
channel = (uint16_t) channel_long;
snprintf(buf, sizeof(buf), "%d", channel);
rime_long = shell_strtolong(next, &next);
if(rime_long < 0 || rime_long > 255){
shell_output_str(&ruc_send_command, "rimeaddress[0] has to be in range [0-255]","");
PROCESS_EXIT();
}
if(*next != '.'){
shell_output_str(&ruc_send_command, "wrong target address format, need u8[0].u8[1]","");
PROCESS_EXIT();
}
target.u8[0] = (uint8_t) rime_long;
++next;
rime_long = shell_strtolong(next, &next);
if(rime_long < 0 || rime_long > 255){
shell_output_str(&ruc_send_command, "rimeaddress[1] has to be in range [0-255]","");
PROCESS_EXIT();
}
target.u8[1] = (uint8_t) rime_long;
while(*next == ' '){
next++;
}
msg_size = strlen(next);
if(msg_size == 0){
shell_output_str(&ruc_send_command, "ruc_send usage:", ruc_send_command.description);
PROCESS_EXIT();
}
memcpy(msg_buf, next, msg_size);
packetbuf_copyfrom(&msg_buf, msg_size);
struct runicast_entry *e = NULL;
for(e = list_head(runicast_list); e != NULL; e = e->next){
if(e->channel == channel){
runicast_send(&e->c, &target,3);
shell_output_str(&ruc_send_command, "sent reliable unicast message on channel: ", buf);
PROCESS_EXIT();
}
}
shell_output_str(&ruc_send_command, "ruc_send error: channel not open, use ruc_open <channel> before trying to send","");
PROCESS_END();
}