void uart0_dispatch_message(uint8_t* msg){ if(msg[0] == UART_LED_GREEN_COMMAND){ if(msg[1]) leds_on(LEDS_GREEN); else leds_off(LEDS_GREEN); } else if(msg[0] == UART_LED_RED_COMMAND){ if(msg[1]) leds_on(LEDS_RED); else leds_off(LEDS_RED); } else if(msg[0] == UART_RAMP_NUM_PACKAGES){ packetbuf_copyfrom(msg, 1); broadcast_send(&broadcast); printf("Asking for number of packages...\n"); } else if(msg[0] == UART_RAMP_SEPARATE_PACKAGE){ packetbuf_copyfrom(msg, 1); broadcast_send(&broadcast); printf("Separating Package...\n"); } else if(msg[0] == UART_RAMP_RELEASE_PACKAGE){ packetbuf_copyfrom(msg, 1); broadcast_send(&broadcast); printf("Release Package...\n"); } else if(msg[0] == UART_RAMP_RELEASE_AND_SEPARATE_PACKAGE){ packetbuf_copyfrom(msg, 1); broadcast_send(&broadcast); printf("Release and Separate Package...\n"); } }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(shell_broadcast_process, ev, data) { struct shell_input *input; int len; struct collect_msg *msg; PROCESS_BEGIN(); 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);*/ broadcast_send(&broadcast); } } PROCESS_END(); }
/* init and react on button press */ PROCESS_THREAD(button_process, ev, data) { PROCESS_BEGIN(); SENSORS_ACTIVATE(button_sensor); shell_sdr_init(); broadcast_open(&broadcast_connection, 129, &broadcast_callback); process_start(&spam_process, NULL); static int dummy = 0; while(1) { leds_off(LEDS_ALL); // wait for button press PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor); packetbuf_copyfrom(&dummy, sizeof(int)); broadcast_send(&broadcast_connection); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ int ipolite_send(struct ipolite_conn *c, clock_time_t interval, uint8_t hdrsize) { if(c->q != NULL) { /* If we are already about to send a packet, we cancel the old one. */ PRINTF("%d.%d: ipolite_send: cancel old send\n", rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1]); queuebuf_free(c->q); } c->dups = 0; c->hdrsize = hdrsize; if(interval == 0) { PRINTF("%d.%d: ipolite_send: interval 0\n", rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1]); if(broadcast_send(&c->c)) { if(c->cb->sent) { c->cb->sent(c); } return 1; } } else { c->q = queuebuf_new_from_packetbuf(); if(c->q != NULL) { ctimer_set(&c->t, interval / 2 + (random_rand() % (interval / 2)), send, c); return 1; } PRINTF("%d.%d: ipolite_send: could not allocate queue buffer\n", rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1]); } return 0; }
static void send_page(struct deluge_object *obj, unsigned pagenum) { unsigned char buf[S_PAGE]; struct deluge_msg_packet pkt; unsigned char *cp; pkt.cmd = DELUGE_CMD_PACKET; pkt.pagenum = pagenum; pkt.version = obj->pages[pagenum].version; pkt.packetnum = 0; pkt.object_id = obj->object_id; pkt.crc = 0; read_page(obj, pagenum, buf); /* Divide the page into packets and send them one at a time. */ for(cp = buf; cp + S_PKT <= (unsigned char *)&buf[S_PAGE]; cp += S_PKT) { if(obj->tx_set & (1 << pkt.packetnum)) { pkt.crc = crc16_data(cp, S_PKT, 0); memcpy(pkt.payload, cp, S_PKT); packetbuf_copyfrom(&pkt, sizeof(pkt)); broadcast_send(&deluge_broadcast); } pkt.packetnum++; } obj->tx_set = 0; }
/** * send the broadcast list to the neighbor */ void send_br_list(struct broadcast_conn *broadcastConn){ Br_msg_list *br_msg_list; Br_msg_list *remove; if(list_length(broadcast_list)>0){ for(br_msg_list = list_head(broadcast_list);br_msg_list!=NULL;){ packetbuf_copyfrom(&br_msg_list->broadcast_msg,sizeof(Broadcast_msg)); printf("[BC] @%d @%u.%u base station@%u.%u\n", clock_seconds(),rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1], br_msg_list->broadcast_msg.base_station.u8[0],br_msg_list->broadcast_msg.base_station.u8[1]); broadcast_send(broadcastConn); packetbuf_clear(); print_br_list(); remove = br_msg_list; br_msg_list = br_msg_list->next; if(local_node.sen_type == BASE_STATION && (remove->broadcast_msg.msg_type==SUBSCRIBE|| remove->broadcast_msg.msg_type==UNSUBSCRIBE)){ }else if(remove!=NULL&&list_length(broadcast_list)>1){ list_remove(broadcast_list,remove); memb_free(&broadcast_list_memb, remove); printf("[DELET-BR-MSG] msg sub_type %u msg_type %u br list length %u\n",remove->broadcast_msg.subscribe_type, remove->broadcast_msg.msg_type,list_length(broadcast_list)); remove = NULL; break; } } } }
/* * Thread para enviar uma mensagem de controle * avisando que permanece conectado a cada 30 * segundos */ void *broadcast_alive(void *data) { time_t last_update; char *aliveMessage = makeJSONControl(0); // Cria a mensagem de controle para avisar que esta conectado time(&last_update); // Obtem o tempo atual // Enquanto o programa estiver ativo while(isRunning()) { // Se o tempo atual for menor que o tempo anterior if( (time(NULL) - last_update) >= 30) { broadcast_send(aliveMessage); // Envia a mensagem para todos os contatos time(&last_update); // Altera o tempo anterior para o tempo atual } sleep(1); } free(aliveMessage); // Libera a memória pthread_exit(0); // Finaliza a thread }
/*---------------------------------------------------------------------------*/ static void send_adv(void *ptr) { struct announcement_msg *adata; struct announcement *a; packetbuf_clear(); adata = packetbuf_dataptr(); adata->num = 0; for(a = announcement_list(); a != NULL && a->has_value; a = list_item_next(a)) { adata->data[adata->num].id = a->id; adata->data[adata->num].value = a->value; adata->num++; } packetbuf_set_datalen(ANNOUNCEMENT_MSG_HEADERLEN + sizeof(struct announcement_data) * adata->num); PRINTF("%d.%d: sending neighbor advertisement with %d announcements\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], adata->num); if(adata->num > 0) { /* Send the packet only if it contains more than zero announcements. */ broadcast_send(&c.c); } PRINTF("%d.%d: sending neighbor advertisement with val %d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], c.val); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(blindnode_bcast_rec, ev, data) { static struct etimer et; static uint8_t n; int i; PROCESS_EXITHANDLER(broadcast_close(&broadcast)); PROCESS_BEGIN(); printf("Reading Chip ID: 0x%02x\n", CHIPID); /* Read our chip ID. If we are not cc2431, bail out */ if(CHIPID != CC2431_CHIP_ID) { printf("Hardware does not have a location engine. Exiting.\n"); PROCESS_EXIT(); } /* OK, we are cc2431. Do stuff */ n = 0; /* Initalise our structs and parameters */ memset(ref_coords, 0, sizeof(struct refcoords) * MAX_REF_NODES); memset(¶meters, 0, sizeof(struct meas_params)); /* * Just hard-coding measurement parameters here. * Ideally, this should be part of a calibration mechanism */ parameters.alpha=SAMPLE_ALPHA; parameters.x_min=0; parameters.x_delta=255; parameters.y_min=0; parameters.y_delta=255; set_imaginary_ref_nodes(); broadcast_open(&broadcast, 129, &broadcast_call); while(1) { etimer_set(&et, CLOCK_SECOND); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); /* * With the hard-coded parameters and locations, we will calculate * for all possible values of n [0 , 31] */ parameters.n=n; calculate(); n++; if(n==32) { n=0; } /* Send our calculated location to some monitoring node */ packetbuf_copyfrom(&coords, 2*sizeof(uint8_t)); broadcast_send(&broadcast); } PROCESS_END(); }
/* * Envia uma mensagem de controle avisando a * desconexão para todos os contatos da lista */ void broadcast_dead() { char *deadMessage = makeJSONControl(1); // Cria a mensagem de controle para avisar desconexão broadcast_send(deadMessage); // Envia a mensagem para todos os contatos free(deadMessage); // Libera a memória }
/*---------------------------------------------------------------------------*/ int unicast_send(struct unicast_conn *c, const rimeaddr_t *receiver) { PRINTF("%d.%d: unicast_send to %d.%d\n", rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1], receiver->u8[0], receiver->u8[1]); packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, receiver); return broadcast_send(&c->c); }
/*---------------------------------------------------------------------------*/ static void recv_broadcast(struct broadcast_conn *c, const rimeaddr_t *from) { process_incoming_packet(); if(is_sender) { } else if(construct_reply(from)) { broadcast_send(&broadcast); } }
PROCESS_THREAD(nodetest_process, ev, data) { uint16_t tmp; char tempstr[32]; uint32_t adc = 0; const uint8_t gain = 32; static struct etimer et; PROCESS_BEGIN(); broadcast_open(&broadcast, 129, &broadcast_call); printf("Initiating stcn75\r\n"); stcn75_init(); lmp_init(); lmp_setup(); while(1) { /* Delay 2-4 seconds */ etimer_set(&et, CLOCK_SECOND * 2 + random_rand() % (CLOCK_SECOND * 2)); //etimer_set(&et, CLOCK_SECOND); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); //Reading ic temp stcn75_read(&tmp); //Reading probe temp if(lmp_read_data(ADC_DONE, 1) == 0xFF){ printf("ADC data NOT Avlaiable\r\n"); }else { adc = lmp_read_data(ADC_DOUT, 3); } //Converting ic tmp and RAWadc/gain data to string adc = adc/gain; adc = adc << 8; adc |= tmp; snprintf(tempstr, sizeof(tempstr), "%d", adc); //Transmitting string packetbuf_copyfrom(tempstr, strlen(tempstr)+1); broadcast_send(&broadcast); printf("broadcast message sent, data: %s\n\r",tempstr); // playing with RADIO settings... // printf("power: %d\r\n",rf230_get_txpower()); //printf("return: %d\r\n",rf230_cw_on()); //rf230_cw_off(); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ static void send(void *ptr) { struct trickle_conn *c = ptr; if (c->q != NULL) { queuebuf_to_packetbuf(c->q); broadcast_send(&c->c); } else { PRINTF("%d.%d: trickle send but c->q == NULL\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1]); } }
void broadcast_unsubscription(struct subscription_item *si) { struct unsubscribe_message *msg; packetbuf_clear(); packetbuf_set_attr(PACKETBUF_ATTR_PACKET_TYPE, MWARE_MSG_UNSUB); packetbuf_set_datalen(sizeof(struct unsubscribe_message)); msg = packetbuf_dataptr(); memcpy(&msg->id, &si->id, sizeof(struct identifier)); if (broadcast_send(&connection)) { subscription_update_last_shout(si); } }
/*---------------------------------------------------------------------------*/ static void send(void *ptr) { struct stbroadcast_conn *c = ptr; /* DEBUGF(3, "stbroadcast: send()\n");*/ queuebuf_to_packetbuf(c->buf); broadcast_send(&c->c); ctimer_reset(&c->t); if(c->u->sent != NULL) { c->u->sent(c); } }
PROCESS_THREAD(shell_broadcast_hi_process, ev, data) { static struct etimer etimer; // PROCESS_EXITHANDLER(broadcast_close(&broadcast);) // PROCESS_EXITHANDLER(mesh_close(&mesh); broadcast_close(&broadcast);) PROCESS_BEGIN(); static int8_t counter = 0; static uint8_t fail_count = 0; mesh_open(&mesh, 132, &callbacks); broadcast_open(&broadcast, 129, &broadcast_call); while(1) { counter++; leds_on(LEDS_ALL); etimer_set(&etimer, 3 * CLOCK_SECOND); PROCESS_WAIT_UNTIL(etimer_expired(&etimer)); leds_off(LEDS_ALL); etimer_set(&etimer, random_rand() % 5 * CLOCK_SECOND + random_rand() % 100 * CLOCK_SECOND / 100); PROCESS_WAIT_UNTIL(etimer_expired(&etimer)); packetbuf_copyfrom("Hello", 6); broadcast_send(&broadcast); etimer_set(&etimer, random_rand() % 5 * CLOCK_SECOND + random_rand() % 100 * CLOCK_SECOND / 100); PROCESS_WAIT_UNTIL(etimer_expired(&etimer)); char message[6] = "Hello"; rimeaddr_t addr; packetbuf_copyfrom(message, sizeof(message)); addr.u8[0] = 62; addr.u8[1] = 41; uint8_t mesh_sent = 0; mesh_sent = mesh_send(&mesh, &addr); if (mesh_sent == 0) { fail_count++; if (counter == 10 && fail_count >= 4) { mesh_open(&mesh, 132, &callbacks); counter = 0; fail_count = 0; } else if (counter == 10) counter = 0; } } PROCESS_END(); }
void xy_shutting_down() { log_info(globals->log, SHUTTING_DOWN_MSG); broadcast_send(SHUTTING_DOWN_MSG); // Invoke cleanup functions in reverse. const char *fmt = "invoking shutdown hook: %s"; for (int i = (hook_ct - 1); i >= 0; i--) { char *msg = malloc(strlen(fmt) + strlen(hooks[i].name)); sprintf(msg, fmt, hooks[i].name); log_info(globals->log, msg); free(msg); hooks[i].hook(); } }
void broadcast_publication(struct subscription_item *si) { struct publish_message *msg; packetbuf_clear(); packetbuf_set_attr(PACKETBUF_ATTR_PACKET_TYPE, MWARE_MSG_PUB); packetbuf_set_datalen(sizeof(struct publish_message)); msg = packetbuf_dataptr(); memcpy(&msg->id, &si->id,sizeof(struct identifier)); rimeaddr_copy(&msg->next_hop, &si->next_hop); msg->data = si->data; msg->node_count = si->node_count; if (broadcast_send(&connection)) { subscription_print(si, "bp"); } }
/*---------------------------------------------------------------------------*/ static void send_adv(void *ptr) { struct neighbor_discovery_conn *c = ptr; struct adv_msg *hdr; packetbuf_clear(); packetbuf_set_datalen(sizeof(struct adv_msg)); hdr = packetbuf_dataptr(); hdr->val = c->val; broadcast_send(&c->c); if(c->u->sent) { c->u->sent(c); } PRINTF("%d.%d: sending neighbor advertisement with val %d\n", rimeaddr_node_addr.u8[RIMEADDR_SIZE-2], rimeaddr_node_addr.u8[RIMEADDR_SIZE-1], c->val); }
/*---------------------------------------------------------------------------*/ static void send(void *ptr) { struct ipolite_conn *c = ptr; PRINTF("%d.%d: ipolite: send queuebuf %p\n", linkaddr_node_addr.u8[0],linkaddr_node_addr.u8[1], c->q); if(c->q != NULL) { queuebuf_to_packetbuf(c->q); queuebuf_free(c->q); c->q = NULL; broadcast_send(&c->c); if(c->cb->sent) { c->cb->sent(c); } } }
static uint8_t wireless_send_frame(uint8_t *payload, uint8_t payload_length) { uint8_t ret = 0; uint8_t rf_mode = RF_TX_MODE; if(!payload) { return FALSE; } //printf("wireless_send_frame>[%d]%s", payload_length, payload); nrf24l01_driver.ioctl(IOCTL_SET_MODE, &rf_mode, 1); packetbuf_copyfrom(payload, payload_length); ret = broadcast_send(&bc); rf_mode = RF_RX_MODE; //switch to rx mode nrf24l01_driver.ioctl(IOCTL_SET_MODE, &rf_mode, 1); return ret; }
static void advertise_summary(struct deluge_object *obj) { struct deluge_msg_summary summary; if(recv_adv >= CONST_K) { ctimer_stop(&summary_timer); return; } summary.cmd = DELUGE_CMD_SUMMARY; summary.version = obj->update_version; summary.highest_available = highest_available_page(obj); summary.object_id = obj->object_id; PRINTF("Advertising summary for object id %u: version=%u, available=%u\n", (unsigned)obj->object_id, summary.version, summary.highest_available); packetbuf_copyfrom(&summary, sizeof(summary)); broadcast_send(&deluge_broadcast); }
static void recv_broadcast(struct broadcast_conn *c, const linkaddr_t *from) { struct broadcast *received_msg; received_msg = packetbuf_dataptr(); struct broadcast br_msg; if(received_msg->type == BROADCAST_TYPE_DISCOVERY) { if(received_msg->data != address_base) { address_base = received_msg->data; printf("base station addr: %d\n",address_base); printf("actuator: broadcast to neighbors\n"); br_msg.type = BROADCAST_TYPE_DISCOVERY; br_msg.data = address_base; packetbuf_copyfrom(&br_msg, sizeof(br_msg)); broadcast_send(&broadcast); broadcast_close(&broadcast); } } }
PROCESS_THREAD(shell_bc_send_process, ev, data) { uint16_t channel; long channel_long; const char *next; 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(&bc_send_command, "channel has to be in range [1-65535]", ""); PROCESS_EXIT(); } channel = (uint16_t) channel_long; snprintf(buf, sizeof(buf), "%d", channel); msg_size = strlen(next); if(msg_size == 0){ shell_output_str(&bc_send_command, "bc_send usage:", bc_send_command.description); PROCESS_EXIT(); } memcpy(msg_buf, next, msg_size); packetbuf_copyfrom(&msg_buf, msg_size); struct broadcast_entry *e = NULL; for(e = list_head(broadcast_list); e != NULL; e = e->next){ if(e->channel == channel){ broadcast_send(&e->c); shell_output_str(&bc_send_command, "sent broadcast message on channel: ", buf); PROCESS_EXIT(); } } shell_output_str(&bc_send_command, "bc_send error: channel not open, use bc_open <channel> before trying to send",""); PROCESS_END(); }
PROCESS_THREAD(sendBeaconTask, ev, data){ PROCESS_BEGIN(); while(1) { static uint32_t eval; PROCESS_WAIT_EVENT(); //wait here until an even occurs pmesg(200, "%s :: %s :: Line #%d\n", __FILE__, __func__, __LINE__); // Store the local backpressure level to the backpressure field beaconHdr -> bcpBackpressure = list_length(send_stack) + sendQeOccupied + virtualQueueSize; beaconHdr -> type = beaconType; // NO_SNOOP: low power sleep interval // #ifdef LOW_POWER_LISTENING // // Call LowPowerListening.setRxSleepInterval(&beaconMsgBuffer, LPL_SLEEP_INTERVAL_MS); // call LowPowerListening.setRemoteWakeupInterval(&beaconMsgBuffer, LPL_SLEEP_INTERVAL_MS); // #endif rimeaddr_copy(&(beaconMsgBuffer.from), &rimeaddr_node_addr); packetbuf_clear(); packetbuf_set_datalen(sizeof(bcp_beacon_header_t)); packetbuf_copyfrom(&beaconMsgBuffer, sizeof(bcp_beacon_header_t)); eval = broadcast_send(&broadcast); //Success if (eval != 0) { pmesg(200, "DEBUG: Beacon successfully called BeaconSend.send(). Eval = %d\n", eval); } else { // NO_SNOOP: add beacon type beaconType = NORMAL_BEACON; process_post(&sendBeaconTask, NULL, NULL); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(cc1200_demo_process, ev, data) { PROCESS_EXITHANDLER(broadcast_close(&bc)) PROCESS_BEGIN(); broadcast_open(&bc, BROADCAST_CHANNEL, &bc_rx); etimer_set(&et, LOOP_INTERVAL); while(1) { PROCESS_YIELD(); if(ev == PROCESS_EVENT_TIMER) { printf("Broadcast --> %u\n", counter); leds_toggle(LEDS_RED); packetbuf_copyfrom(&counter, sizeof(counter)); broadcast_send(&bc); counter++; etimer_set(&et, LOOP_INTERVAL); } } PROCESS_END(); }
static void send_profile(struct deluge_object *obj) { struct deluge_msg_profile *msg; unsigned char buf[sizeof(*msg) + OBJECT_PAGE_COUNT(*obj)]; int i; if(broadcast_profile && recv_adv < CONST_K) { broadcast_profile = 0; msg = (struct deluge_msg_profile *)buf; msg->cmd = DELUGE_CMD_PROFILE; msg->version = obj->version; msg->npages = OBJECT_PAGE_COUNT(*obj); msg->object_id = obj->object_id; for(i = 0; i < msg->npages; i++) { msg->version_vector[i] = obj->pages[i].version; } packetbuf_copyfrom(buf, sizeof(buf)); broadcast_send(&deluge_broadcast); } }
PROCESS_THREAD(cc26xx_demo_process, ev, data) { PROCESS_EXITHANDLER(broadcast_close(&bc)) PROCESS_BEGIN(); gpio_relay_init(); relay_all_clear(); counter = 0; broadcast_open(&bc, BROADCAST_CHANNEL, &bc_rx); etimer_set(&et, CLOCK_SECOND); while(1) { PROCESS_YIELD(); if(ev == PROCESS_EVENT_TIMER) { leds_on(LEDS_PERIODIC); etimer_set(&et, CLOCK_SECOND*5); rtimer_set(&rt, RTIMER_NOW() + LEDS_OFF_HYSTERISIS, 1, rt_callback, NULL); counter = Get_ADC_reading(); packetbuf_copyfrom(&counter, sizeof(counter)); broadcast_send(&bc); // printf("adc data value : %d \r\n",counter); } watchdog_periodic(); } PROCESS_END(); }
/* periodic broadcast light sensor data */ PROCESS_THREAD(spam_process, ev, data) { PROCESS_BEGIN(); SENSORS_ACTIVATE(light_sensor); // init leds_off(LEDS_ALL); int light_val = 0; while(1) { // wait a bit static struct etimer et; etimer_set(&et, 1 * CLOCK_SECOND / 2); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); // send packet light_val = light_sensor.value(LIGHT_SENSOR_PHOTOSYNTHETIC); packetbuf_copyfrom(&light_val, sizeof(int)); broadcast_send(&broadcast_connection); } SENSORS_DEACTIVATE(light_sensor); PROCESS_END(); }