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