/*---------------------------------------------------------------------------*/ void rpl_schedule_dao(rpl_instance_t *instance) { clock_time_t expiration_time; expiration_time = etimer_expiration_time(&instance->dao_timer.etimer); if(!etimer_expired(&instance->dao_timer.etimer)) { PRINTF("RPL: DAO timer already scheduled\n"); } else { expiration_time = RPL_DAO_LATENCY / 2 + (random_rand() % (RPL_DAO_LATENCY)); PRINTF("RPL: Scheduling DAO timer %u ticks in the future\n", (unsigned)expiration_time); ctimer_set(&instance->dao_timer, expiration_time, handle_dao_timer, instance); } }
PROCESS_THREAD(hello_world_process, ev, data) { static struct etimer et; PROCESS_BEGIN(); while (1) { printf("Hello world\n"); FLASH_LED(LEDS_BLUE); FLASH_LED(LEDS_GREEN); etimer_set(&et, 3*CLOCK_SECOND); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(timesync_master_process, ev, data) { static struct etimer et; PROCESS_BEGIN(); timesynch_set_authority_level(0); PT_INIT(&pt); // wait until network is synchronized etimer_set(&et, SYNCH_PERIOD); PROCESS_WAIT_UNTIL(etimer_expired(&et)); rtimer_set(&rt, timesynch_time_to_rtimer(0), 0, (rtimer_callback_t)rtimer_task, NULL); PROCESS_END(); }
PROCESS_THREAD(shell_round_robin_start_process, ev, data) { PROCESS_BEGIN(); if (rimeaddr_node_addr.u8[0] == FIRST_NODE) { static struct etimer etimer0; uint8_t next_node = FIRST_NODE + 1; etimer_set(&etimer0, CLOCK_SECOND/FREQUENCY); leds_on(LEDS_ALL); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&etimer0)); transmit_unicast("Hello", next_node); leds_off(LEDS_ALL); } PROCESS_END(); }
PROCESS_THREAD(test_phidgets_process, ev, data) { static struct etimer et; static int values[SAMPLES]; /* Buffer of SAMPLES latest values. */ static int sample = 0; /* Index of current sample in buffer. */ static int i, v; static long avg; PROCESS_BEGIN(); SENSORS_ACTIVATE(phidgets); for (;;) { etimer_set(&et, CLOCK_SECOND / 2); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); /* * In the code below implements a Simple Moving Average filter. */ sample = (sample + 1) % SAMPLES; /* Wrap around in buffer. */ v = phidgets.value(PHIDGET3V_1); /* Get new value from sensor. */ values[sample] = v; /* Calculate average of the SAMPLES latest values. */ avg = 0; for (i = 0; i < SAMPLES; i++) avg += values[i]; avg /= SAMPLES; /* See if our newest value is off by more than DELTA from the average */ if (abs(v - avg) > DELTA) leds_on(LEDS_RED); else leds_off(LEDS_RED); printf("v: %4d, avg: %4ld\n", v, avg); } PROCESS_END(); }
/*-----------------------------------------------------------------------------------*/ PROCESS_THREAD(rest_engine_process, ev, data, buf) { PROCESS_BEGIN(); /* pause to let REST server finish adding resources. */ PROCESS_PAUSE(); /* initialize the PERIODIC_RESOURCE timers, which will be handled by this process. */ periodic_resource_t *periodic_resource = NULL; for(periodic_resource = (periodic_resource_t *)list_head(restful_periodic_services); periodic_resource; periodic_resource = periodic_resource->next) { if(periodic_resource->periodic_handler && periodic_resource->period) { PRINTF("Periodic: Set timer for /%s to %lu\n", periodic_resource->resource->url, periodic_resource->period); etimer_set(&periodic_resource->periodic_timer, periodic_resource->period, &rest_engine_process); } } while(1) { PROCESS_WAIT_EVENT(); if(ev == PROCESS_EVENT_TIMER) { for(periodic_resource = (periodic_resource_t *)list_head(restful_periodic_services); periodic_resource; periodic_resource = periodic_resource->next) { if(periodic_resource->period && etimer_expired(&periodic_resource->periodic_timer)) { PRINTF("Periodic: etimer expired for /%s (period: %lu)\n", periodic_resource->resource->url, periodic_resource->period); /* Call the periodic_handler function, which was checked during adding to list. */ (periodic_resource->periodic_handler)(); etimer_reset(&periodic_resource->periodic_timer); } } } } PROCESS_END(); }
PROCESS_THREAD(blink_process, ev, data) { PROCESS_POLLHANDLER(); PROCESS_EXITHANDLER(); PROCESS_BEGIN(); while(1) { leds_toggle(LEDS_RED); if(adc > 0) { time = (CLOCK_SECOND*adc)/1024; } else { time = CLOCK_SECOND/64; } if(time == 0) { time = 1; } etimer_set(&etb, time); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&etb)); } PROCESS_END(); }
PROCESS_THREAD(snd_process, ev, data){ static struct etimer et; static struct simple_udp_connection broadcast_connection; static uip_ipaddr_t mcast_allnodes_address; PROCESS_BEGIN(); etimer_set(&et, CLOCK_SECOND*HOW_MUCH_TIME); set_address(); simple_udp_register(&broadcast_connection, UDP_PORT, NULL,UDP_PORT, callback_function); mcast_allnodes_address=get_multicast_all_nodes_addr(); while(1){//A broadcast message is sent periodically PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); simple_udp_sendto(&broadcast_connection, "Hello", 5, (const uip_ipaddr_t*)&mcast_allnodes_address); etimer_reset(&et); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(simple_udp_ping_process, ev, data) { static struct etimer et; int i; PROCESS_BEGIN(); for(i = 0; i < MAX_DESTINATIONS; i++) { pingconns[i].in_use = 0; } simple_udp_register(&ping_connection, UDP_PORT, NULL, UDP_PORT, receiver); while(1) { #define PERIOD (3*CLOCK_SECOND) etimer_set(&et, PERIOD); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); for(i = 0; i < MAX_DESTINATIONS; i++) { if (pingconns[i].in_use && pingconns[i].waiting) { struct pingconn_t* pingconn = &pingconns[i]; pingconn->waiting = 0; /* Send ping */ #if DEBUG printf("Sending ping to "); uip_debug_ipaddr_print(&pingconn->host); printf("\n"); #endif simple_udp_sendto(&ping_connection, "ping", DATALEN, &pingconn->host); pingconn->echo_time = RTIMER_NOW(); pingconn->echo_time2 = clock_time(); pingconn->sent = 1; pingconn->replied = 0; break; } } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(shell_sample_stats_process, ev, data) { static uint16_t data_sam[NUM_SAM]; uint16_t sum = 0; uint16_t sqsum = 0; static struct etimer etimer; PROCESS_BEGIN(); // Gather NUM_SAM samples over 1 second of time sensor_init(); printf("Gathering data... "); for(counter = 0;counter < NUM_SAM;counter++) { // Get data for no change analysis. etimer_set(&etimer, CLOCK_SECOND / NUM_SAM); PROCESS_WAIT_UNTIL(etimer_expired(&etimer)); data_sam[counter] = sensor_read(); } printf("done!\n"); sensor_uinit(); // Sum the no change data sum = 0; for(counter = 0;counter < NUM_SAM;counter++) { sum = sum + data_sam[counter]; } sample_mean = 0; printf("sum = %d\n",sum); sample_mean = sum/NUM_SAM; printf("sample_mean = %d\n",sample_mean); // Caclulate sample_std_dev sqsum = 0; for(counter = 0;counter < NUM_SAM;counter++) { sqsum = sqsum + mypow2(abs_sub(data_sam[counter], sample_mean)); } sample_std_dev = 0; sample_std_dev = sqsum/NUM_SAM; sample_std_dev = mysqrt(sample_std_dev); printf("std_dev = %d\n",sample_std_dev); PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(trickle_protocol_process, ev, data) { PROCESS_BEGIN(); PRINTF("Trickle protocol started\n"); uip_create_linklocal_allnodes_mcast(&ipaddr); /* Store for later */ trickle_conn = udp_new(NULL, UIP_HTONS(TRICKLE_PROTO_PORT), NULL); udp_bind(trickle_conn, UIP_HTONS(TRICKLE_PROTO_PORT)); PRINTF("Connection: local/remote port %u/%u\n", UIP_HTONS(trickle_conn->lport), UIP_HTONS(trickle_conn->rport)); token = 0; trickle_timer_config(&tt, IMIN, IMAX, REDUNDANCY_CONST); trickle_timer_set(&tt, trickle_tx, &tt); /* * At this point trickle is started and is running the first interval. All * nodes 'agree' that token == 0. This will change when one of them randomly * decides to generate a new one */ etimer_set(&et, NEW_TOKEN_INTERVAL); while(1) { PROCESS_YIELD(); if(ev == tcpip_event) { tcpip_handler(); } else if(etimer_expired(&et)) { /* Periodically (and randomly) generate a new token. This will trigger * a trickle inconsistency */ if((random_rand() % NEW_TOKEN_PROB) == 0) { token++; PRINTF("At %lu: Generating a new token 0x%02x\n", (unsigned long)clock_time(), token); trickle_timer_reset_event(&tt); } etimer_set(&et, NEW_TOKEN_INTERVAL); } } PROCESS_END(); }
PROCESS_THREAD(sender_process, ev, data) { static struct etimer periodic; static struct ctimer backoff_timer; PROCESS_BEGIN(); // PROCESS_PAUSE(); set_global_address(); PRINTF("The sender process begins.\n"); print_local_addresses(); /* new connection with remote host */ sender_conn = udp_new(NULL, UIP_HTONS(UDP_SINK_PORT), NULL); if(sender_conn == NULL) { PRINTF("No UDP connection available, exiting the process!\n"); PROCESS_EXIT(); } udp_bind(sender_conn, UIP_HTONS(UDP_SENDER_PORT)); PRINTF("Created a connection with the server "); PRINT6ADDR(&sender_conn->ripaddr); PRINTF(" local/remote port %u/%u\n", UIP_HTONS(sender_conn->lport), UIP_HTONS(sender_conn->rport)); etimer_set(&periodic, SEND_INTERVAL * CLOCK_SECOND); while(1) { PROCESS_YIELD(); if(ev == tcpip_event) tcpip_handler(); if(etimer_expired(&periodic)) { etimer_reset(&periodic); ctimer_set(&backoff_timer, RANDWAIT * CLOCK_SECOND, send_packet, NULL); } } PROCESS_END(); }
PROCESS_THREAD(prng_test_process, ev, data) { static unsigned char seed[SEEDLEN]; PROCESS_BEGIN(); lpm_set_max_pm(LPM_PM0); etimer_set(&et, WAIT_TIME); for (;;) { PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); etimer_restart(&et); leds_on(LEDS_ALL); RfRnd(seed, sizeof(seed)); leds_off(LEDS_ALL); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ static char counter_pthread(void *ptr) { struct data *f = ptr; PT_BEGIN(&f->pt); f->counter = 0; etimer_set(&f->et, CLOCK_SECOND); printf("Start thread\r\n"); while(1) { PT_WAIT_UNTIL(&f->pt,f->active && etimer_expired(&f->et)); printf("Counter %d\r\n",f->counter++); etimer_reset(&f->et); } printf("End thread\r\n"); PT_END(&f->pt); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(ipv6_process, ev, data) { PROCESS_BEGIN(); // Set the local address uip_ip6addr(&my_addr, 0, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&my_addr, &uip_lladdr); uip_ds6_addr_add(&my_addr, 0, ADDR_MANUAL); // Setup the destination address uiplib_ipaddrconv(RECEIVER_ADDR, &dest_addr); // Add a "neighbor" for our custom route // Setup the default broadcast route uiplib_ipaddrconv(ADDR_ALL_ROUTERS, &bcast_ipaddr); uip_ds6_nbr_add(&bcast_ipaddr, &bcast_lladdr, 0, NBR_REACHABLE); uip_ds6_route_add(&dest_addr, 128, &bcast_ipaddr); // Setup a udp "connection" client_conn = udp_new(&dest_addr, UIP_HTONS(RECEIVER_PORT), NULL); if (client_conn == NULL) { // Too many udp connections // not sure how to exit...stupid contiki } udp_bind(client_conn, UIP_HTONS(3001)); etimer_set(&periodic_timer, 10*CLOCK_SECOND); while(1) { PROCESS_YIELD(); if (etimer_expired(&periodic_timer)) { send_handler(ev, data); etimer_restart(&periodic_timer); } else if (ev == tcpip_event) { recv_handler(); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(udp_client_process, ev, data) { static struct etimer et; uip_ipaddr_t ipaddr; PROCESS_BEGIN(); PRINTF("UDP client process started\n"); #if UIP_CONF_ROUTER set_global_address(); #endif print_local_addresses(); set_connection_address(&ipaddr); /* new connection with remote host */ client_conn = udp_new(&ipaddr, UIP_HTONS(3000), NULL); udp_bind(client_conn, UIP_HTONS(3001)); PRINTF("Created a connection with the server "); PRINT6ADDR(&client_conn->ripaddr); PRINTF(" local/remote port %u/%u\n", UIP_HTONS(client_conn->lport), UIP_HTONS(client_conn->rport)); etimer_set(&et, SEND_INTERVAL); while(1) { PROCESS_YIELD(); if(etimer_expired(&et)) { timeout_handler(); etimer_restart(&et); } else if(ev == tcpip_event) { tcpip_handler(); } } PROCESS_END(); }
//---------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////// // main // // main function // // Configures device simulator and HRM TX channel. // // \return: This function does not return. //////////////////////////////////////////////////////////////////////////// PROCESS_THREAD(ant_process, ev, data) { static struct etimer timer; static UCHAR* pucRxBuffer; PROCESS_BEGIN(); // wait about 500ms for ant module to start etimer_set(&timer, CLOCK_SECOND/2); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&timer)); ANT_Reset(); // Main loop while(TRUE) { pucRxBuffer = ANTInterface_Transaction(); // Check if any data has been recieved from serial if(pucRxBuffer) { ANTPLUS_EVENT_RETURN stEventStruct; if (mode == MODE_HRM) { HRMRX_ChannelEvent(pucRxBuffer, &stEventStruct); ProcessANTHRMRXEvents(&stEventStruct); } else if (mode == MODE_CBSC) { CBSCRX_ChannelEvent(pucRxBuffer, &stEventStruct); ProcessANTCBSCRXEvents(&stEventStruct); } ProcessAntEvents(pucRxBuffer); ANTInterface_Complete(); // Release the serial buffer continue; } PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL); } PROCESS_END(); }
PROCESS_THREAD(udp_server_process, ev, data) { PROCESS_BEGIN(); static uip_ipaddr_t ipaddr; rpl_dag_t *dag; int i; uint8_t state; static struct etimer timer; static struct simple_udp_connection connection; static int packet = 0; uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF); //uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); //dag = rpl_set_root(RPL_DEFAULT_INSTANCE, (uip_ip6addr_t*) &ipaddr); //rpl_set_prefix(dag, &ipaddr, 64); simple_udp_register(&connection, UDP_PORT-1, NULL, UDP_PORT, receiver); printf("IPv6 addresses: "); for(i = 0; i < UIP_DS6_ADDR_NB; i++) { state = uip_ds6_if.addr_list[i].state; if(uip_ds6_if.addr_list[i].isused && (state == ADDR_TENTATIVE || state == ADDR_PREFERRED)) { uip_debug_ipaddr_print( &uip_ds6_if.addr_list[i].ipaddr); printf("\n"); } } printf("UDP server started\n"); etimer_set(&timer, CLOCK_SECOND >> 1); while(1) { PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&timer)); etimer_restart(&timer); leds_toggle(LEDS_GREEN); } PROCESS_END(); }
/* -------------------------------------------------------------------- */ PROCESS_THREAD(test_process, ev, data) { static struct etimer timer; static struct packet_s packet; PROCESS_BEGIN(); rime_sniffer_add(&print_sniffer); if(node_id == 1) { printf("Receiving...\n"); /* receiver */ for(;;) { PROCESS_YIELD(); } } else { printf("Sending...\n"); /* sender */ etimer_set(&timer, CLOCK_SECOND); for(;;) { PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&timer)); leds_on(LEDS_ALL); /* send to radio */ NETSTACK_RADIO.send(&packet, sizeof(packet)); packet.number++; if(packet.number >= 100) { packet.number = 0; etimer_set(&timer, SEND_PERIOD * 10); printf("100 packets sent\n"); } else { etimer_set(&timer, SEND_PERIOD); } leds_off(LEDS_ALL); } } PROCESS_END(); }
PROCESS_THREAD(sd_test, event, data) { static unsigned long iter; static unsigned long offset; char buf[BUF_SIZE]; static struct etimer et; int r, buflen; PROCESS_BEGIN(); etimer_set(&et, CLOCK_SECOND / 16); offset = 0; for(iter = 1;; iter++) { PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); memset(buf, 0, sizeof(buf)); buflen = sprintf(buf, "(%ld) Testing the SD card (%ld)", iter, iter); if((iter & 7) == 0) { offset = random_rand() & 0xffff; } else { offset += random_rand() & 0xff; } r = sd_write(offset, buf, buflen + 1); if(r > 0) { memset(buf, 0, sizeof(buf)); r = sd_read(offset, buf, buflen + 1); if(r > 0) { printf("read %s (offset %lu)\n", buf, offset); } else { printf("read error: %d (%s)\n", r, sd_error_string(r)); } } else { printf("write error: %d (%s)\n", r, sd_error_string(r)); } etimer_restart(&et); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(native_rdc_process, ev, data) { PROCESS_BEGIN(); static struct etimer et; do { slip_reboot(); while(!radio_mac_addr_ready) { etimer_set(&et, CLOCK_SECOND); slip_request_mac(); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); } //Set radio channel slip_set_rf_channel(nvm_data.channel); radio_ready = 1; PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL); } while(1); PROCESS_END(); }
static void tls_handler(process_event_t ev, process_data_t data){ if (ev == tls_event){ if (tls_connected()){ //raven_lcd_show_text("conn"); connection = (Connection*)data; //TLS_Write(connection, "1", 1); //etimer_set(&et, CLOCK_CONF_SECOND); } /*else if (tls_newdata()){ tls_appdata[5] = 0; TLS_Write(connection, "1", 1); }*/ } else if (ev == PROCESS_EVENT_TIMER){ if (etimer_expired(&et)){ tls_write(connection, "1",1); etimer_set(&et, CLOCK_CONF_SECOND); } } }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(udp_client_process, ev, data) { static struct etimer periodic; static struct ctimer backoff_timer; PROCESS_BEGIN(); PROCESS_PAUSE(); powertrace_start(CLOCK_SECOND * 2); PRINTF("UDP client process started\n"); /*create new connection with remote server*/ client_conn = udp_new(NULL, UIP_HTONS(UDP_SERVER_PORT), NULL); if(client_conn == NULL) { PRINTF("No UDP connection available, exiting the process!\n"); PROCESS_EXIT(); } udp_bind(client_conn, UIP_HTONS(UDP_CLIENT_PORT)); PRINTF("Created a connection with the server "); PRINT6ADDR(&client_conn->ripaddr); PRINTF(" local/remote port %u/%u \n", UIP_HTONS(client_conn->lport),UIP_HTONS(client_conn->rport)); etimer_set(&periodic, SEND_INTERVAL); while(1) { PROCESS_YIELD(); if(ev == tcpip_event) { tcpip_handler(); } if(etimer_expired(&periodic)){ etimer_reset(&periodic); ctimer_set(&backoff_timer, SEND_TIME, send_packet, NULL); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(remote_tsl2563_process, ev, data) { PROCESS_BEGIN(); static uint16_t light; /* Use Contiki's sensor macro to enable the sensor */ SENSORS_ACTIVATE(tsl2563); /* Default integration time is 402ms with 1x gain, use the below call to * change the gain and timming, see tsl2563.h for more options */ /* tsl2563.configure(TSL2563_TIMMING_CFG, TSL2563_G16X_402MS); */ /* Register the interrupt handler */ TSL2563_REGISTER_INT(light_interrupt_callback); /* Enable the interrupt source for values over the threshold. The sensor * compares against the value of CH0, one way to find out the required * threshold for a given lux quantity is to enable the DEBUG flag and see * the CH0 value for a given measurement. The other is to reverse the * calculations done in the calculate_lux() function. The below value roughly * represents a 2500 lux threshold, same as pointing a flashlight directly */ tsl2563.configure(TSL2563_INT_OVER, 0x15B8); /* And periodically poll the sensor */ while(1) { etimer_set(&et, SENSOR_READ_INTERVAL); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); light = tsl2563.value(TSL2563_VAL_READ); if(light != TSL2563_ERROR) { printf("Light = %u\n", (uint16_t)light); } else { printf("Error, enable the DEBUG flag in the tsl2563 driver for info, "); printf("or check if the sensor is properly connected\n"); PROCESS_EXIT(); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(UDP_ping_process, ev, data) { static uip_ipaddr_t serveraddr; static struct uip_udp_conn *udpconn; static struct etimer et; PROCESS_BEGIN(); /* Create the remote connection */ uiplib_ipaddrconv(remote, &serveraddr); udpconn = udp_new(&serveraddr, uip_htons(remote_port), NULL); while (1) { /* Send a packet every INTERVAL */ etimer_set(&et, INTERVAL); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); uip_udp_packet_send(udpconn, "Hello world !!!", 16); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(powertrace_process, ev, data) { static struct etimer periodic; clock_time_t *period; PROCESS_BEGIN(); period = data; if(period == NULL) { PROCESS_EXIT(); } etimer_set(&periodic, *period); while(1) { PROCESS_WAIT_UNTIL(etimer_expired(&periodic)); etimer_reset(&periodic); powertrace_print(""); } PROCESS_END(); }
/** * updates periodically energy harvested by solar panel */ PROCESS_THREAD(consumptionrate_solarpanel_process, ev, data) { PROCESS_BEGIN(); // timer for updating solar calculation periodically static struct etimer timer_update_solar; etimer_set(&timer_update_solar, CLOCK_SECOND * 60 / SPEEDMULTIPLIER); // update loop while(1) { PROCESS_WAIT_UNTIL(etimer_expired(&timer_update_solar)); // calculate energy flow & save fpint fp_capacity = solarpanel_capacity(60); fp_solar_energy = fpint_add(fp_solar_energy, fp_capacity); // restart timer etimer_reset(&timer_update_solar); } PROCESS_END(); }
PROCESS_THREAD(test, ev, data) { static struct etimer et; PROCESS_BEGIN(); printf("rimeaddr_node_addr = [%u, %u]\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1]); while(1) { test_msg(); printf("\n"); printf("*************************************************************************"); printf("\n"); etimer_set(&et,5*CLOCK_SECOND); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(example_mlst_node_process, ev, data) { static struct etimer et; PROCESS_BEGIN(); //Initialize the mlst-network. Has to be done to open ports, etc. mlst_init(); eamlst_set_energy_state(ENERGY_STATE); while(1) { mlst_print_state(); rsunicast_print_state(); etimer_set(&et, CLOCK_SECOND * 4 * getRandomFloat(0.5,1.0)); //uint8_t data[7]; //mlst_send(&data, sizeof(data)); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); } PROCESS_END(); }
PROCESS_THREAD(shell_round_robin_blink_process, ev, data) { PROCESS_BEGIN(); static struct etimer etimer; static uint8_t my_node; my_node = rimeaddr_node_addr.u8[0]; static uint8_t next_node; next_node = my_node + 1; if (my_node == LAST_NODE) next_node = FIRST_NODE; etimer_set(&etimer, CLOCK_SECOND/FREQUENCY); leds_on(LEDS_ALL); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&etimer)); transmit_unicast("Hello", next_node); leds_off(LEDS_ALL); PROCESS_END(); }