/*---------------------------------------------------------------------------*/ PROCESS_THREAD(shell_power_process, ev, data) { static uint32_t last_cpu, last_lpm, last_transmit, last_listen; static uint32_t last_idle_transmit, last_idle_listen; struct power_msg msg; PROCESS_BEGIN(); energest_flush(); msg.len = 12; msg.cpu = energest_type_time(ENERGEST_TYPE_CPU) - last_cpu; msg.lpm = energest_type_time(ENERGEST_TYPE_LPM) - last_lpm; msg.transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT) - last_transmit; msg.listen = energest_type_time(ENERGEST_TYPE_LISTEN) - last_listen; msg.idle_transmit = compower_idle_activity.transmit - last_idle_transmit; msg.idle_listen = compower_idle_activity.listen - last_idle_listen; last_cpu = energest_type_time(ENERGEST_TYPE_CPU); last_lpm = energest_type_time(ENERGEST_TYPE_LPM); last_transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT); last_listen = energest_type_time(ENERGEST_TYPE_LISTEN); last_idle_listen = compower_idle_activity.listen; last_idle_transmit = compower_idle_activity.transmit; shell_output(&power_command, &msg, sizeof(msg), "", 0); PROCESS_END(); }
/*---------------------------------------------------------------------------*/ void simple_energest_step() { static uint16_t cnt; energest_flush(); curr_tx = energest_type_time(ENERGEST_TYPE_TRANSMIT); curr_rx = energest_type_time(ENERGEST_TYPE_LISTEN); curr_time = energest_type_time(ENERGEST_TYPE_CPU) + energest_type_time(ENERGEST_TYPE_LPM); delta_tx = curr_tx - last_tx; delta_rx = curr_rx - last_rx; delta_time = curr_time - last_time; last_tx = curr_tx; last_rx = curr_rx; last_time = curr_time; uint32_t fraction = (100ul*(delta_tx+delta_rx))/delta_time; LOG_NULL("Duty Cycle: [%u %u] %8lu +%8lu /%8lu (%lu %%)", node_id, cnt++, delta_tx, delta_rx, delta_time, fraction ); }
void etimer_interrupt(void) { /* HW timer bug fix: Interrupt handler called before TR==CCR. * Occurrs when timer state is toggled between STOP and CONT. */ while(TACTL & MC1 && TACCR1 - TAR == 1); /* Make sure interrupt time is future */ do { /* TACTL &= ~MC1;*/ TACCR1 += INTERVAL; /* TACTL |= MC1;*/ ++count; /* Make sure the CLOCK_CONF_SECOND is a power of two, to ensure that the modulo operation below becomes a logical and and not an expensive divide. Algorithm from Wikipedia: http://en.wikipedia.org/wiki/Power_of_two */ #if (CLOCK_CONF_SECOND & (CLOCK_CONF_SECOND - 1)) != 0 #error CLOCK_CONF_SECOND must be a power of two (i.e., 1, 2, 4, 8, 16, 32, 64, ...). #error Change CLOCK_CONF_SECOND in contiki-conf.h. #endif if(count % CLOCK_CONF_SECOND == 0) { ++seconds; energest_flush(); } } while((TACCR1 - TAR) > INTERVAL); last_tar = TAR; }
void print_total_energy() { uint32_t all_cpu, all_lpm, all_transmit, all_listen; uint32_t energy_consumed_node_cpu, energy_consumed_node_lpm, energy_consumed_node_rx, energy_consumed_node_tx; energest_flush(); all_cpu = energest_type_time(ENERGEST_TYPE_CPU); all_lpm = energest_type_time(ENERGEST_TYPE_LPM); all_transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT); all_listen = energest_type_time(ENERGEST_TYPE_LISTEN); energy_consumed_node_cpu = 3 * 2 * (all_cpu / RTIMER_ARCH_SECOND); printf("energy_consumed_node_cpu = %lu\n", energy_consumed_node_cpu); energy_consumed_node_lpm = 3 * (all_lpm / RTIMER_ARCH_SECOND) / 10 ; printf("energy_consumed_node_lpm = %lu\n", energy_consumed_node_lpm); energy_consumed_node_rx = 3 * 22 * (all_listen / RTIMER_ARCH_SECOND); printf("energy_consumed_node_rx = %lu\n",energy_consumed_node_rx); energy_consumed_node_tx = 3 * 20 * (all_transmit/RTIMER_ARCH_SECOND); printf("energy_consumed_node_tx = %lu\n",energy_consumed_node_tx); printf("Node' energy consumption: %u \n", get_total_energy_consumption()); }
/*---------------------------------------------------------------------------*/ void simple_energest_start() { energest_flush(); last_tx = energest_type_time(ENERGEST_TYPE_TRANSMIT); last_rx = energest_type_time(ENERGEST_TYPE_LISTEN); last_time = energest_type_time(ENERGEST_TYPE_CPU) + energest_type_time(ENERGEST_TYPE_LPM); process_start(&simple_energest_process, NULL); }
/*---------------------------------------------------------------------------*/ uint16_t get_total_energy_consumption() { uint32_t energy_consumed = 0; uint32_t cpu, lpm, transmit, listen; uint32_t time; energest_flush(); cpu = energest_type_time(ENERGEST_TYPE_CPU);// - last_cpu; lpm = energest_type_time(ENERGEST_TYPE_LPM);// - last_lmp; transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT);// - last_transmit; listen = energest_type_time(ENERGEST_TYPE_LISTEN);// - last_listen; time = cpu + lpm; energy_consumed = 3L * ((cpu/RTIMER_ARCH_SECOND) * 2 + (lpm/RTIMER_ARCH_SECOND) / 10 + (transmit/RTIMER_ARCH_SECOND) * 20 + (listen/RTIMER_ARCH_SECOND) * 22); if (energy_consumed == 0) { return 1; } // printf("Node's power consummed(mJ) : %lu\n", energy_consumed); // printf("radio-ontime %lu %%\n", (100*(transmit+listen))/time); return energy_consumed; }
/*---------------------------------------------------------------------------*/ static void sample_power_profile(struct power *p) { energest_flush(); p->lpm = energest_type_time(ENERGEST_TYPE_LPM); p->cpu = energest_type_time(ENERGEST_TYPE_CPU); p->rx = energest_type_time(ENERGEST_TYPE_LISTEN); p->tx = energest_type_time(ENERGEST_TYPE_TRANSMIT); }
/*---------------------------------------------------------------------------*/ void collect_view_construct_message(struct collect_view_data_msg *msg, const linkaddr_t *parent, uint16_t parent_etx, uint16_t current_rtmetric, uint16_t num_neighbors, uint16_t beacon_interval) { static unsigned long last_cpu, last_lpm, last_transmit, last_listen; unsigned long cpu, lpm, transmit, listen; msg->len = sizeof(struct collect_view_data_msg) / sizeof(uint16_t); msg->clock = clock_time(); #if TIMESYNCH_CONF_ENABLED msg->timesynch_time = timesynch_time(); #else /* TIMESYNCH_CONF_ENABLED */ msg->timesynch_time = 0; #endif /* TIMESYNCH_CONF_ENABLED */ energest_flush(); cpu = energest_type_time(ENERGEST_TYPE_CPU) - last_cpu; lpm = energest_type_time(ENERGEST_TYPE_LPM) - last_lpm; transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT) - last_transmit; listen = energest_type_time(ENERGEST_TYPE_LISTEN) - last_listen; /* Make sure that the values are within 16 bits. If they are larger, we scale them down to fit into 16 bits. */ while(cpu >= 65536ul || lpm >= 65536ul || transmit >= 65536ul || listen >= 65536ul) { cpu /= 2; lpm /= 2; transmit /= 2; listen /= 2; } msg->cpu = cpu; msg->lpm = lpm; msg->transmit = transmit; msg->listen = listen; last_cpu = energest_type_time(ENERGEST_TYPE_CPU); last_lpm = energest_type_time(ENERGEST_TYPE_LPM); last_transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT); last_listen = energest_type_time(ENERGEST_TYPE_LISTEN); memcpy(&msg->parent, &parent->u8[LINKADDR_SIZE - 2], 2); msg->parent_etx = parent_etx; msg->current_rtmetric = current_rtmetric; msg->num_neighbors = num_neighbors; msg->beacon_interval = beacon_interval; memset(msg->sensors, 0, sizeof(msg->sensors)); collect_view_arch_read_sensors(msg); }
void Contiki_SysTick_Handler(void) { ticks++; if((ticks % CLOCK_SECOND) == 0) { seconds++; energest_flush(); } if(etimer_pending()) { etimer_request_poll(); } }
/*---------------------------------------------------------------------------*/ void st_lib_sys_tick_handler(void) { ticks++; if((ticks % CLOCK_SECOND) == 0) { seconds++; energest_flush(); } HAL_IncTick(); if(etimer_pending()) { etimer_request_poll(); } }
/*---------------------------------------------------------------------------*/ ISR(TIMERA1, timera1) { ENERGEST_ON(ENERGEST_TYPE_IRQ); watchdog_start(); if(TAIV == 2) { /* HW timer bug fix: Interrupt handler called before TR==CCR. * Occurs when timer state is toggled between STOP and CONT. */ while(TACTL & MC1 && TACCR1 - TAR == 1); /* Make sure interrupt time is future */ do { TACCR1 += INTERVAL; ++count; /* Make sure the CLOCK_CONF_SECOND is a power of two, to ensure that the modulo operation below becomes a logical and and not an expensive divide. Algorithm from Wikipedia: http://en.wikipedia.org/wiki/Power_of_two */ #if (CLOCK_CONF_SECOND & (CLOCK_CONF_SECOND - 1)) != 0 #error CLOCK_CONF_SECOND must be a power of two (i.e., 1, 2, 4, 8, 16, 32, 64, ...). #error Change CLOCK_CONF_SECOND in contiki-conf.h. #endif if(count % CLOCK_CONF_SECOND == 0) { ++seconds; energest_flush(); } } while((TACCR1 - TAR) > INTERVAL); last_tar = TAR; if(etimer_pending() && (etimer_next_expiration_time() - count - 1) > MAX_TICKS) { etimer_request_poll(); LPM4_EXIT; } } /* if(process_nevents() >= 0) { LPM4_EXIT; }*/ watchdog_stop(); ENERGEST_OFF(ENERGEST_TYPE_IRQ); }
/*---------------------------------------------------------------------------*/ void _TC3_Handler(void)//void TCC0_Handler(void) { ENERGEST_ON(ENERGEST_TYPE_IRQ); ticks++; if((ticks % CLOCK_SECOND) == 0) { seconds++; energest_flush(); // printf("seconds, ticks %d\n", tc_get_count_value(&tc_instance)); } if(etimer_pending()) { etimer_request_poll(); } ENERGEST_OFF(ENERGEST_TYPE_IRQ); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(shell_energy_process, ev, data) { struct power_msg msg; PROCESS_BEGIN(); energest_flush(); msg.len = 12; msg.cpu = energest_type_time(ENERGEST_TYPE_CPU); msg.lpm = energest_type_time(ENERGEST_TYPE_LPM); msg.transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT); msg.listen = energest_type_time(ENERGEST_TYPE_LISTEN); msg.idle_transmit = compower_idle_activity.transmit; msg.idle_listen = compower_idle_activity.listen; shell_output(&energy_command, &msg, sizeof(msg), "", 0); PROCESS_END(); }
static void bacast_signed_message() { msg_header_t* header; uint8_t* data; packetbuf_clear(); header = ( msg_header_t* ) ( packetbuf_dataptr() ); data = ( uint8_t* ) ( header + 1 ); random_data ( data, MSG_LEN ); hton_uint16 ( &header->data_len, MSG_LEN ); static struct etimer nrg; energest_flush(); ENERGEST_ON ( ENERGEST_TYPE_LPM ); ENERGEST_ON ( ENERGEST_TYPE_TRANSMIT ); ENERGEST_ON ( ENERGEST_TYPE_LISTEN ); ENERGEST_ON ( ENERGEST_TYPE_CPU ); last.cpu = energest_type_time ( ENERGEST_TYPE_CPU )/RTIMER_SECOND; ENERGEST_OFF ( ENERGEST_TYPE_CPU ); last.lpm = energest_type_time ( ENERGEST_TYPE_LPM ); last.transmit = energest_type_time ( ENERGEST_TYPE_TRANSMIT ); last.listen = energest_type_time ( ENERGEST_TYPE_LISTEN ); ENERGEST_ON ( ENERGEST_TYPE_CPU ); ecdsa_sign ( data, MSG_LEN, header->r, header->s, prKey_alice ); diff.cpu = energest_type_time ( ENERGEST_TYPE_CPU ) - last.cpu; diff.lpm = energest_type_time ( ENERGEST_TYPE_LPM ) - last.lpm; diff.transmit = energest_type_time ( ENERGEST_TYPE_TRANSMIT ) - last.transmit; diff.listen = energest_type_time ( ENERGEST_TYPE_LISTEN ) - last.listen; ENERGEST_OFF ( ENERGEST_TYPE_CPU ); ENERGEST_OFF ( ENERGEST_TYPE_LPM ); ENERGEST_OFF ( ENERGEST_TYPE_TRANSMIT ); ENERGEST_OFF ( ENERGEST_TYPE_LISTEN ); packetbuf_set_datalen ( sizeof ( msg_header_t ) + MSG_LEN ); abc_send ( &abc ); printf ( "Clock ticks recorded by\nCPU = %ld \nLPM = %ld \nTRANSMITTER = %ld\nRECEIVER = %ld\n",diff.cpu, diff.lpm, diff.transmit, diff.listen ); }
void powertrace_print(char *str) { static uint32_t last_cpu, last_lpm, last_transmit, last_listen; static uint32_t last_idle_transmit, last_idle_listen; uint32_t cpu, lpm, transmit, listen; uint32_t all_cpu, all_lpm, all_transmit, all_listen; uint32_t idle_transmit, idle_listen; uint32_t all_idle_transmit, all_idle_listen; static uint32_t seqno; uint32_t time, all_time, radio, all_radio; struct powertrace_sniff_stats *s; energest_flush(); all_cpu = energest_type_time(ENERGEST_TYPE_CPU); all_lpm = energest_type_time(ENERGEST_TYPE_LPM); all_transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT); all_listen = energest_type_time(ENERGEST_TYPE_LISTEN); all_idle_transmit = compower_idle_activity.transmit; all_idle_listen = compower_idle_activity.listen; cpu = all_cpu - last_cpu; lpm = all_lpm - last_lpm; transmit = all_transmit - last_transmit; listen = all_listen - last_listen; idle_transmit = compower_idle_activity.transmit - last_idle_transmit; idle_listen = compower_idle_activity.listen - last_idle_listen; last_cpu = energest_type_time(ENERGEST_TYPE_CPU); last_lpm = energest_type_time(ENERGEST_TYPE_LPM); last_transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT); last_listen = energest_type_time(ENERGEST_TYPE_LISTEN); last_idle_listen = compower_idle_activity.listen; last_idle_transmit = compower_idle_activity.transmit; radio = transmit + listen; time = cpu + lpm; all_time = all_cpu + all_lpm; all_radio = energest_type_time(ENERGEST_TYPE_LISTEN) + energest_type_time(ENERGEST_TYPE_TRANSMIT); printf("%s %lu P %d.%d %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu (radio %d.%02d%% / %d.%02d%% tx %d.%02d%% / %d.%02d%% listen %d.%02d%% / %d.%02d%%)\n", str, clock_time(), rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], seqno, all_cpu, all_lpm, all_transmit, all_listen, all_idle_transmit, all_idle_listen, cpu, lpm, transmit, listen, idle_transmit, idle_listen, (int)((100L * (all_transmit + all_listen)) / all_time), (int)((10000L * (all_transmit + all_listen) / all_time) - (100L * (all_transmit + all_listen) / all_time) * 100), (int)((100L * (transmit + listen)) / time), (int)((10000L * (transmit + listen) / time) - (100L * (transmit + listen) / time) * 100), (int)((100L * all_transmit) / all_time), (int)((10000L * all_transmit) / all_time - (100L * all_transmit / all_time) * 100), (int)((100L * transmit) / time), (int)((10000L * transmit) / time - (100L * transmit / time) * 100), (int)((100L * all_listen) / all_time), (int)((10000L * all_listen) / all_time - (100L * all_listen / all_time) * 100), (int)((100L * listen) / time), (int)((10000L * listen) / time - (100L * listen / time) * 100)); seqno++; }
/*---------------------------------------------------------------------------*/ void powertrace_print(char *str) { static uint32_t last_cpu, last_lpm, last_transmit, last_listen; static uint32_t last_idle_transmit, last_idle_listen; uint32_t cpu, lpm, transmit, listen; uint32_t all_cpu, all_lpm, all_transmit, all_listen; uint32_t idle_transmit, idle_listen; uint32_t all_idle_transmit, all_idle_listen; static uint32_t seqno; uint32_t time, all_time, radio, all_radio; struct powertrace_sniff_stats *s; energest_flush(); printf("powertrace\n"); all_cpu = energest_type_time(ENERGEST_TYPE_CPU); all_lpm = energest_type_time(ENERGEST_TYPE_LPM); all_transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT); all_listen = energest_type_time(ENERGEST_TYPE_LISTEN); all_idle_transmit = compower_idle_activity.transmit; all_idle_listen = compower_idle_activity.listen; cpu = all_cpu - last_cpu; lpm = all_lpm - last_lpm; transmit = all_transmit - last_transmit; listen = all_listen - last_listen; idle_transmit = compower_idle_activity.transmit - last_idle_transmit; idle_listen = compower_idle_activity.listen - last_idle_listen; last_cpu = energest_type_time(ENERGEST_TYPE_CPU); last_lpm = energest_type_time(ENERGEST_TYPE_LPM); last_transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT); last_listen = energest_type_time(ENERGEST_TYPE_LISTEN); last_idle_listen = compower_idle_activity.listen; last_idle_transmit = compower_idle_activity.transmit; radio = transmit + listen; time = cpu + lpm; all_time = all_cpu + all_lpm; all_radio = energest_type_time(ENERGEST_TYPE_LISTEN) + energest_type_time(ENERGEST_TYPE_TRANSMIT); printf("%s %lu P %d.%d %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu (radio %d.%02d%% / %d.%02d%% tx %d.%02d%% / %d.%02d%% listen %d.%02d%% / %d.%02d%%)\n", str, clock_time(), rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], seqno, all_cpu, all_lpm, all_transmit, all_listen, all_idle_transmit, all_idle_listen, cpu, lpm, transmit, listen, idle_transmit, idle_listen, (int)((100L * (all_transmit + all_listen)) / all_time), (int)((10000L * (all_transmit + all_listen) / all_time) - (100L * (all_transmit + all_listen) / all_time) * 100), (int)((100L * (transmit + listen)) / time), (int)((10000L * (transmit + listen) / time) - (100L * (transmit + listen) / time) * 100), (int)((100L * all_transmit) / all_time), (int)((10000L * all_transmit) / all_time - (100L * all_transmit / all_time) * 100), (int)((100L * transmit) / time), (int)((10000L * transmit) / time - (100L * transmit / time) * 100), (int)((100L * all_listen) / all_time), (int)((10000L * all_listen) / all_time - (100L * all_listen / all_time) * 100), (int)((100L * listen) / time), (int)((10000L * listen) / time - (100L * listen / time) * 100)); for(s = list_head(stats_list); s != NULL; s = list_item_next(s)) { #if ! UIP_CONF_IPV6 printf("%s %lu SP %d.%d %lu %u %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu (channel %d radio %d.%02d%% / %d.%02d%%)\n", str, clock_time(), rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], seqno, s->channel, s->num_input, s->input_txtime, s->input_rxtime, s->input_txtime - s->last_input_txtime, s->input_rxtime - s->last_input_rxtime, s->num_output, s->output_txtime, s->output_rxtime, s->output_txtime - s->last_output_txtime, s->output_rxtime - s->last_output_rxtime, s->channel, (int)((100L * (s->input_rxtime + s->input_txtime + s->output_rxtime + s->output_txtime)) / all_radio), (int)((10000L * (s->input_rxtime + s->input_txtime + s->output_rxtime + s->output_txtime)) / all_radio), (int)((100L * (s->input_rxtime + s->input_txtime + s->output_rxtime + s->output_txtime - (s->last_input_rxtime + s->last_input_txtime + s->last_output_rxtime + s->last_output_txtime))) / radio), (int)((10000L * (s->input_rxtime + s->input_txtime + s->output_rxtime + s->output_txtime - (s->last_input_rxtime + s->last_input_txtime + s->last_output_rxtime + s->last_output_txtime))) / radio)); #else printf("%s %lu SP %d.%d %lu %u %u %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu (proto %u(%u) radio %d.%02d%% / %d.%02d%%)\n", str, clock_time(), rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], seqno, s->proto, s->channel, s->num_input, s->input_txtime, s->input_rxtime, s->input_txtime - s->last_input_txtime, s->input_rxtime - s->last_input_rxtime, s->num_output, s->output_txtime, s->output_rxtime, s->output_txtime - s->last_output_txtime, s->output_rxtime - s->last_output_rxtime, s->proto, s->channel, (int)((100L * (s->input_rxtime + s->input_txtime + s->output_rxtime + s->output_txtime)) / all_radio), (int)((10000L * (s->input_rxtime + s->input_txtime + s->output_rxtime + s->output_txtime)) / all_radio), (int)((100L * (s->input_rxtime + s->input_txtime + s->output_rxtime + s->output_txtime - (s->last_input_rxtime + s->last_input_txtime + s->last_output_rxtime + s->last_output_txtime))) / radio), (int)((10000L * (s->input_rxtime + s->input_txtime + s->output_rxtime + s->output_txtime - (s->last_input_rxtime + s->last_input_txtime + s->last_output_rxtime + s->last_output_txtime))) / radio)); #endif s->last_input_txtime = s->input_txtime; s->last_input_rxtime = s->input_rxtime; s->last_output_txtime = s->output_txtime; s->last_output_rxtime = s->output_rxtime; } seqno++; }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(shell_sendtest_process, ev, data) { static rimeaddr_t receiver; static unsigned long cpu, lpm, rx, tx; const char *nextptr; const char *args; char buf[40]; unsigned long cpu2, lpm2, rx2, tx2; PROCESS_BEGIN(); args = data; 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); args = nextptr; while(*args == ' ') { ++args; } filesize = shell_strtolong(args, &nextptr); if(nextptr == data || filesize == 0) { print_usage(); PROCESS_EXIT(); } args = nextptr; while(*args == ' ') { ++args; } packetsize = 64; packetsize = shell_strtolong(args, &nextptr); if(packetsize == 0) { print_usage(); PROCESS_EXIT(); } snprintf(buf, sizeof(buf), "%d.%d, %lu bytes, packetsize %lu", receiver.u8[0], receiver.u8[1], filesize, packetsize); shell_output_str(&sendtest_command, "Sending data to ", buf); bytecount = 0; download_complete = 0; start_time_rucb = clock_time(); rucb_send(&rucb, &receiver); energest_flush(); lpm = energest_type_time(ENERGEST_TYPE_LPM); cpu = energest_type_time(ENERGEST_TYPE_CPU); rx = energest_type_time(ENERGEST_TYPE_LISTEN); tx = energest_type_time(ENERGEST_TYPE_TRANSMIT); PROCESS_WAIT_UNTIL(download_complete); energest_flush(); lpm2 = energest_type_time(ENERGEST_TYPE_LPM); cpu2 = energest_type_time(ENERGEST_TYPE_CPU); rx2 = energest_type_time(ENERGEST_TYPE_LISTEN); tx2 = energest_type_time(ENERGEST_TYPE_TRANSMIT); sprintf(buf, "%d seconds, %lu bytes/second", (int)((end_time_rucb - start_time_rucb) / CLOCK_SECOND), CLOCK_SECOND * filesize / (end_time_rucb - start_time_rucb)); shell_output_str(&sendtest_command, "Completed in ", buf); sprintf(buf, "%lu/%d rx %lu/%d tx (seconds)", (rx2 - rx), RTIMER_ARCH_SECOND, (tx2 - tx), RTIMER_ARCH_SECOND); shell_output_str(&sendtest_command, "Radio total on time ", buf); sprintf(buf, "%lu/%lu = %lu%%", (rx2 - rx), (cpu2 + lpm2 - cpu - lpm), 100 * (rx2 - rx)/(cpu2 + lpm2 - cpu - lpm)); shell_output_str(&sendtest_command, "Radio rx duty cycle ", buf); sprintf(buf, "%lu/%lu = %lu%%", (tx2 - tx), (cpu2 + lpm2 - cpu - lpm), 100 * (tx2 - tx)/(cpu2 + lpm2 - cpu - lpm)); shell_output_str(&sendtest_command, "Radio tx duty cycle ", buf); PROCESS_END(); }
/*---------------------------------------------------------------------------*/ static PT_THREAD(ajax_call(struct httpd_state *s, char *ptr)) { static struct timer t; static int iter; static char buf[128]; static uint8_t numprinted; PSOCK_BEGIN(&s->sout); /*TODO:pick up time from ? parameter */ timer_set(&t, 2*CLOCK_SECOND); iter = 0; while(1) { iter++; #if CONTIKI_TARGET_SKY SENSORS_ACTIVATE(sht11_sensor); SENSORS_ACTIVATE(light_sensor); numprinted = snprintf(buf, sizeof(buf), "t(%d);h(%d);l1(%d);l2(%d);", sht11_sensor.value(SHT11_SENSOR_TEMP), sht11_sensor.value(SHT11_SENSOR_HUMIDITY), light_sensor.value(LIGHT_SENSOR_PHOTOSYNTHETIC), light_sensor.value(LIGHT_SENSOR_TOTAL_SOLAR)); SENSORS_DEACTIVATE(sht11_sensor); SENSORS_DEACTIVATE(light_sensor); #elif CONTIKI_TARGET_MB851 SENSORS_ACTIVATE(acc_sensor); numprinted = snprintf(buf, sizeof(buf),"t(%d);ax(%d);ay(%d);az(%d);", temperature_sensor.value(0), acc_sensor.value(ACC_X_AXIS), acc_sensor.value(ACC_Y_AXIS), acc_sensor.value(ACC_Z_AXIS)); SENSORS_DEACTIVATE(acc_sensor); #elif CONTIKI_TARGET_REDBEE_ECONOTAG { uint8_t c; adc_reading[8]=0; adc_init(); while (adc_reading[8]==0) adc_service(); adc_disable(); numprinted = snprintf(buf, sizeof(buf),"b(%u);adc(%u,%u,%u,%u,%u,%u,%u,%u);", 1200*0xfff/adc_reading[8],adc_reading[0],adc_reading[1],adc_reading[2],adc_reading[3],adc_reading[4],adc_reading[5],adc_reading[6],adc_reading[7]); } #elif CONTIKI_TARGET_MINIMAL_NET static uint16_t c0=0x3ff,c1=0x3ff,c2=0x3ff,c3=0x3ff,c4=0x3ff,c5=0x3ff,c6=0x3ff,c7=0x3ff; numprinted = snprintf(buf, sizeof(buf), "t(%d);b(%u);v(%u);",273+(rand()&0x3f),3300-iter/10,iter); numprinted += snprintf(buf+numprinted, sizeof(buf)-numprinted,"adc(%u,%u,%u,%u,%u,%u,%u,%u);",c0,c1,c2,c3,c4,c5,c6,c7); c0+=(rand()&0xf)-8; c1+=(rand()&0xf)-8; c2+=(rand()&0xf)-7; c3+=(rand()&0x1f)-15; c4+=(rand()&0x3)-1; c5+=(rand()&0xf)-8; c6+=(rand()&0xf)-8; c7+=(rand()&0xf)-8; if (iter==1) { static const char httpd_cgi_ajax11[] HTTPD_STRING_ATTR = "wt('Minimal-net "; static const char httpd_cgi_ajax12[] HTTPD_STRING_ATTR = "');"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax11); #if WEBSERVER_CONF_PRINTADDR /* Note address table is filled from the end down */ {int i; for (i=0; i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { numprinted += httpd_cgi_sprint_ip6(uip_ds6_if.addr_list[i].ipaddr, buf + numprinted); break; } } } #endif numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax12); } #elif CONTIKI_TARGET_AVR_ATMEGA128RFA1 { uint8_t i;int16_t tmp,bat; BATMON = 16; //give BATMON time to stabilize at highest range and lowest voltage /* Measure internal temperature sensor, see atmega128rfa1 datasheet */ /* This code disabled by default for safety. Selecting an internal reference will short it to anything connected to the AREF pin */ #if 1 ADCSRB|=1<<MUX5; //this bit buffered till ADMUX written to! ADMUX =0xc9; // Select internal 1.6 volt ref, temperature sensor ADC channel ADCSRA=0x85; //Enable ADC, not free running, interrupt disabled, clock divider 32 (250 KHz@ 8 MHz) // while ((ADCSRB&(1<<AVDDOK))==0); //wait for AVDD ok // while ((ADCSRB&(1<<REFOK))==0); //wait for ref ok ADCSRA|=1<<ADSC; //Start throwaway conversion while (ADCSRA&(1<<ADSC)); //Wait till done ADCSRA|=1<<ADSC; //Start another conversion while (ADCSRA&(1<<ADSC)); //Wait till done tmp=ADC; //Read adc tmp=11*tmp-2728+(tmp>>2); //Convert to celcius*10 (should be 11.3*h, approximate with 11.25*h) ADCSRA=0; //disable ADC ADMUX=0; //turn off internal vref #endif /* Bandgap can't be measured against supply voltage in this chip. */ /* Use BATMON register instead */ for ( i=16; i<31; i++) { BATMON = i; if ((BATMON&(1<<BATMON_OK))==0) break; } bat=2550-75*16-75+75*i; //-75 to take the floor of the 75 mv transition window static const char httpd_cgi_ajax10[] HTTPD_STRING_ATTR ="t(%u),b(%u);adc(%d,%d,%u,%u,%u,%u,%u,%lu);"; numprinted = httpd_snprintf(buf, sizeof(buf),httpd_cgi_ajax10,tmp,bat,iter,tmp,bat,sleepcount,OCR2A,0,clock_time(),clock_seconds()); if (iter==1) { static const char httpd_cgi_ajax11[] HTTPD_STRING_ATTR = "wt('128rfa1 ["; static const char httpd_cgi_ajax12[] HTTPD_STRING_ATTR = "]');"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax11); #if WEBSERVER_CONF_PRINTADDR /* Note address table is filled from the end down */ {int i; for (i=0; i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { numprinted += httpd_cgi_sprint_ip6(uip_ds6_if.addr_list[i].ipaddr, buf + numprinted); break; } } } #endif numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax12); } } #elif CONTIKI_TARGET_AVR_RAVEN { int16_t tmp,bat; #if 1 /* Usual way to get AVR supply voltage, measure 1.1v bandgap using Vcc as reference. * This connects the bandgap to the AREF pin, so enable only if there is no external AREF! * A capacitor may be connected to this pin to reduce reference noise. */ ADMUX =0x5E; //Select AVCC as reference, measure 1.1 volt bandgap reference. ADCSRA=0x87; //Enable ADC, not free running, interrupt disabled, clock divider 128 (62 KHz@ 8 MHz) ADCSRA|=1<<ADSC; //Start throwaway conversion while (ADCSRA&(1<<ADSC)); //Wait till done ADCSRA|=1<<ADSC; //Start another conversion while (ADCSRA&(1<<ADSC)); //Wait till done //bat=1126400UL/ADC; //Get supply voltage (factor nominally 1100*1024) bat=1198070UL/ADC; //My Raven ADCSRA=0; //disable ADC ADMUX=0; //turn off internal vref #else bat=3300; #endif tmp=420; static const char httpd_cgi_ajax10[] HTTPD_STRING_ATTR ="t(%u),b(%u);adc(%d,%d,%u,%u,%u,%u,%u,%lu);"; numprinted = httpd_snprintf(buf, sizeof(buf),httpd_cgi_ajax10,tmp,bat,iter,tmp,bat,sleepcount,OCR2A,0,clock_time(),clock_seconds()); if (iter<3) { static const char httpd_cgi_ajax11[] HTTPD_STRING_ATTR = "wt('Raven ["; static const char httpd_cgi_ajax12[] HTTPD_STRING_ATTR = "]');"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax11); #if WEBSERVER_CONF_PRINTADDR /* Note address table is filled from the end down */ {int i; for (i=0; i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { numprinted += httpd_cgi_sprint_ip6(uip_ds6_if.addr_list[i].ipaddr, buf + numprinted); break; } } } #endif numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax12); } } //#elif CONTIKI_TARGET_IS_SOMETHING_ELSE #else { static const char httpd_cgi_ajax10[] HTTPD_STRING_ATTR ="v(%u);"; numprinted = httpd_snprintf(buf, sizeof(buf),httpd_cgi_ajax10,iter); if (iter==1) { static const char httpd_cgi_ajax11[] HTTPD_STRING_ATTR = "wt('Contiki Ajax "; static const char httpd_cgi_ajax12[] HTTPD_STRING_ATTR = "');"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax11); #if WEBSERVER_CONF_PRINTADDR /* Note address table is filled from the end down */ {int i; for (i=0; i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { numprinted += httpd_cgi_sprint_ip6(uip_ds6_if.addr_list[i].ipaddr, buf + numprinted); break; } } } #endif numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax12); } } #endif #if CONTIKIMAC_CONF_COMPOWER #include "sys/compower.h" { //sl=compower_idle_activity.transmit/RTIMER_ARCH_SECOND; //sl=compower_idle_activity.listen/RTIMER_ARCH_SECOND; } #endif #if RIMESTATS_CONF_ON #include "net/rime/rimestats.h" static const char httpd_cgi_ajaxr1[] HTTPD_STRING_ATTR ="rime(%lu,%lu,%lu,%lu);"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajaxr1, rimestats.tx,rimestats.rx,rimestats.lltx-rimestats.tx,rimestats.llrx-rimestats.rx); #endif #if ENERGEST_CONF_ON { #if 1 /* Send on times in percent since last update. Handle 16 bit rtimer wraparound. */ /* Javascript must convert based on platform cpu, tx, rx power, e.g. 20ma*3v3=66mW*(% on time/100) */ static rtimer_clock_t last_send; rtimer_clock_t delta_time; static unsigned long last_cpu, last_lpm, last_listen, last_transmit; energest_flush(); delta_time=RTIMER_NOW()-last_send; if (RTIMER_CLOCK_LT(RTIMER_NOW(),last_send)) delta_time+=RTIMER_ARCH_SECOND; last_send=RTIMER_NOW(); static const char httpd_cgi_ajaxe1[] HTTPD_STRING_ATTR = "p(%lu,%lu,%lu,%lu);"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajaxe1, (100UL*(energest_total_time[ENERGEST_TYPE_CPU].current - last_cpu))/delta_time, (100UL*(energest_total_time[ENERGEST_TYPE_LPM].current - last_lpm))/delta_time, (100UL*(energest_total_time[ENERGEST_TYPE_TRANSMIT].current - last_transmit))/delta_time, (100UL*(energest_total_time[ENERGEST_TYPE_LISTEN].current - last_listen))/delta_time); last_cpu = energest_total_time[ENERGEST_TYPE_CPU].current; last_lpm = energest_total_time[ENERGEST_TYPE_LPM].current; last_transmit = energest_total_time[ENERGEST_TYPE_TRANSMIT].current; last_listen = energest_total_time[ENERGEST_TYPE_LISTEN].current; #endif #if 1 /* Send cumulative on times in percent*100 */ uint16_t cpp,txp,rxp; uint32_t sl,clockseconds=clock_seconds(); // energest_flush(); // sl=((10000UL*energest_total_time[ENERGEST_TYPE_CPU].current)/RTIMER_ARCH_SECOND)/clockseconds; sl=energest_total_time[ENERGEST_TYPE_CPU].current/RTIMER_ARCH_SECOND; cpp=(10000UL*sl)/clockseconds; // txp=((10000UL*energest_total_time[ENERGEST_TYPE_TRANSMIT].current)/RTIMER_ARCH_SECOND)/clockseconds; sl=energest_total_time[ENERGEST_TYPE_TRANSMIT].current/RTIMER_ARCH_SECOND; txp=(10000UL*sl)/clockseconds; // rxp=((10000UL*energest_total_time[ENERGEST_TYPE_LISTEN].current)/RTIMER_ARCH_SECOND)/clockseconds; sl=energest_total_time[ENERGEST_TYPE_LISTEN].current/RTIMER_ARCH_SECOND; rxp=(10000UL*sl)/clockseconds; static const char httpd_cgi_ajaxe2[] HTTPD_STRING_ATTR = "ener(%u,%u,%u);"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajaxe2,cpp,txp,rxp); #endif } #endif /* ENERGEST_CONF_ON */ PSOCK_SEND_STR(&s->sout, buf); timer_restart(&t); PSOCK_WAIT_UNTIL(&s->sout, timer_expired(&t)); } PSOCK_END(&s->sout); }
/*---------------------------------------------------------------------------*/ static unsigned short generate_sensor_readings(void *arg) { uint16_t numprinted; uint16_t days,h,m,s; unsigned long seconds=clock_seconds(); static const char httpd_cgi_sensor0[] HTTPD_STRING_ATTR = "[Updated %d seconds ago]<br><br>"; static const char httpd_cgi_sensor1[] HTTPD_STRING_ATTR = "<pre><em>Temperature:</em> %s\n"; static const char httpd_cgi_sensor2[] HTTPD_STRING_ATTR = "<em>Battery :</em> %s\n"; // static const char httpd_cgi_sensr12[] HTTPD_STRING_ATTR = "<em>Temperature:</em> %s <em>Battery:</em> %s<br>"; static const char httpd_cgi_sensor3[] HTTPD_STRING_ATTR = "<em>Uptime :</em> %02d:%02d:%02d\n"; static const char httpd_cgi_sensor3d[] HTTPD_STRING_ATTR = "<em>Uptime :</em> %u days %02u:%02u:%02u/n"; // static const char httpd_cgi_sensor4[] HTTPD_STRING_ATTR = "<em>Sleeping time :</em> %02d:%02d:%02d (%d%%)<br>"; numprinted=0; /* Generate temperature and voltage strings for each platform */ #if CONTIKI_TARGET_AVR_ATMEGA128RFA1 {uint8_t i; BATMON = 16; //give BATMON time to stabilize at highest range and lowest voltage /* Measure internal temperature sensor, see atmega128rfa1 datasheet */ /* This code disabled by default for safety. Selecting an internal reference will short it to anything connected to the AREF pin */ #if 0 ADCSRB|=1<<MUX5; //this bit buffered till ADMUX written to! ADMUX =0xc9; // Select internal 1.6 volt ref, temperature sensor ADC channel ADCSRA=0x85; //Enable ADC, not free running, interrupt disabled, clock divider 32 (250 KHz@ 8 MHz) // while ((ADCSRB&(1<<AVDDOK))==0); //wait for AVDD ok // while ((ADCSRB&(1<<REFOK))==0); //wait for ref ok ADCSRA|=1<<ADSC; //Start throwaway conversion while (ADCSRA&(1<<ADSC)); //Wait till done ADCSRA|=1<<ADSC; //Start another conversion while (ADCSRA&(1<<ADSC)); //Wait till done h=ADC; //Read adc h=11*h-2728+(h>>2); //Convert to celcius*10 (should be 11.3*h, approximate with 11.25*h) ADCSRA=0; //disable ADC ADMUX=0; //turn off internal vref m=h/10;s=h-10*m; static const char httpd_cgi_sensor1_printf[] HTTPD_STRING_ATTR = "%d.%d C"; httpd_snprintf(sensor_temperature,sizeof(sensor_temperature),httpd_cgi_sensor1_printf,m,s); #endif /* Bandgap can't be measured against supply voltage in this chip. */ /* Use BATMON register instead */ for ( i=16; i<31; i++) { BATMON = i; if ((BATMON&(1<<BATMON_OK))==0) break; } h=2550-75*16-75+75*i; //-75 to take the floor of the 75 mv transition window static const char httpd_cgi_sensor2_printf[] HTTPD_STRING_ATTR = "%u mv"; httpd_snprintf(sensor_extvoltage,sizeof(sensor_extvoltage),httpd_cgi_sensor2_printf,h); } #elif CONTIKI_TARGET_AVR_RAVEN { #if 1 /* Usual way to get AVR supply voltage, measure 1.1v bandgap using Vcc as reference. * This connects the bandgap to the AREF pin, so enable only if there is no external AREF! * A capacitor may be connected to this pin to reduce reference noise. */ ADMUX =0x5E; //Select AVCC as reference, measure 1.1 volt bandgap reference. ADCSRA=0x87; //Enable ADC, not free running, interrupt disabled, clock divider 128 (62 KHz@ 8 MHz) ADCSRA|=1<<ADSC; //Start throwaway conversion while (ADCSRA&(1<<ADSC)); //Wait till done ADCSRA|=1<<ADSC; //Start another conversion while (ADCSRA&(1<<ADSC)); //Wait till done //h=1126400UL/ADC; //Get supply voltage (factor nominally 1100*1024) h=1198070UL/ADC; //My Raven ADCSRA=0; //disable ADC ADMUX=0; //turn off internal vref static const char httpd_cgi_sensor2_printf[] HTTPD_STRING_ATTR = "%u mv"; httpd_snprintf(sensor_extvoltage,sizeof(sensor_extvoltage),httpd_cgi_sensor2_printf,h); #endif } #elif CONTIKI_TARGET_REDBEE_ECONOTAG //#include "adc.h" { uint8_t c; adc_reading[8]=0; adc_init(); while (adc_reading[8]==0) adc_service(); // for (c=0; c<NUM_ADC_CHAN; c++) printf("%u %04u\r\n", c, adc_reading[c]); adc_disable(); snprintf(sensor_extvoltage, sizeof(sensor_extvoltage),"%u mV",1200*0xfff/adc_reading[8]); static const char httpd_cgi_sensorv[] HTTPD_STRING_ATTR = "<em>ADC chans :</em> %u %u %u %u %u %u %u %u \n"; numprinted+=httpd_snprintf((char *)uip_appdata+numprinted, uip_mss()-numprinted, httpd_cgi_sensorv, adc_reading[0],adc_reading[1],adc_reading[2],adc_reading[3],adc_reading[4],adc_reading[5],adc_reading[6],adc_reading[7]); } #endif if (last_tempupdate) { numprinted =httpd_snprintf((char *)uip_appdata, uip_mss(), httpd_cgi_sensor0,(unsigned int) (seconds-last_tempupdate)); } numprinted+=httpd_snprintf((char *)uip_appdata+numprinted, uip_mss()-numprinted, httpd_cgi_sensor1, sensor_temperature); numprinted+=httpd_snprintf((char *)uip_appdata+numprinted, uip_mss()-numprinted, httpd_cgi_sensor2, sensor_extvoltage); // numprinted+=httpd_snprintf((char *)uip_appdata+numprinted, uip_mss()-numprinted, httpd_cgi_sensr12, sensor_temperature,sensor_extvoltage); #if RADIOSTATS /* Remember radioontime for display below - slow connection might make it report longer than cpu ontime! */ savedradioontime = radioontime; #endif h=seconds/3600;s=seconds-h*3600;m=s/60;s=s-m*60; days=h/24; if (days == 0) { numprinted+=httpd_snprintf((char *)uip_appdata + numprinted, uip_mss() - numprinted, httpd_cgi_sensor3, h,m,s); } else { h=h-days*24; numprinted+=httpd_snprintf((char *)uip_appdata + numprinted, uip_mss() - numprinted, httpd_cgi_sensor3d, days,h,m,s); } #if 0 if (sleepseconds) { uint8_t p1; p1=100UL*sleepseconds/seconds;h=sleepseconds/3600;s=sleepseconds-h*3600;m=s/60;s=s-m*60; numprinted+=httpd_snprintf((char *)uip_appdata + numprinted, uip_mss() - numprinted, httpd_cgi_sensor4, h,m,s,p1); } #endif #if ENERGEST_CONF_ON {uint8_t p1,p2; uint32_t sl; #if 0 /* Update all the timers to get current values */ for (p1=1;p1<ENERGEST_TYPE_MAX;p1++) { if (energest_current_mode[p1]) { ENERGEST_OFF(p1); ENERGEST_ON(p1); } } #else energest_flush(); #endif static const char httpd_cgi_sensor4[] HTTPD_STRING_ATTR = "<em>CPU time (ENERGEST):</em> %02u:%02u:%02u (%u.%02u%%)\n"; static const char httpd_cgi_sensor10[] HTTPD_STRING_ATTR = "<em>Radio (ENERGEST):</em> Tx %02u:%02u:%02u (%u.%02u%%) "; static const char httpd_cgi_sensor11[] HTTPD_STRING_ATTR = "Rx %02u:%02u:%02u (%u.%02u%%)\n"; sl=energest_total_time[ENERGEST_TYPE_CPU].current/RTIMER_ARCH_SECOND; h=(10000UL*sl)/seconds;p1=h/100;p2=h-p1*100;h=sl/3600;s=sl-h*3600;m=s/60;s=s-m*60; numprinted+=httpd_snprintf((char *)uip_appdata+numprinted, uip_mss()-numprinted, httpd_cgi_sensor4, h,m,s,p1,p2); sl=energest_total_time[ENERGEST_TYPE_TRANSMIT].current/RTIMER_ARCH_SECOND; h=(10000UL*sl)/seconds;p1=h/100;p2=h-p1*100;h=sl/3600;s=sl-h*3600;m=s/60;s=s-m*60; numprinted+=httpd_snprintf((char *)uip_appdata+numprinted, uip_mss()-numprinted, httpd_cgi_sensor10, h,m,s,p1,p2); sl=energest_total_time[ENERGEST_TYPE_LISTEN].current/RTIMER_ARCH_SECOND; h=(10000UL*sl)/seconds;p1=h/100;p2=h-p1*100;h=sl/3600;s=sl-h*3600;m=s/60;s=s-m*60; numprinted+=httpd_snprintf((char *)uip_appdata+numprinted, uip_mss()-numprinted, httpd_cgi_sensor11, h,m,s,p1,p2); } #endif /* ENERGEST_CONF_ON */ #if CONTIKIMAC_CONF_COMPOWER #include "sys/compower.h" {uint8_t p1,p2; // extern struct compower_activity current_packet; static const char httpd_cgi_sensor31[] HTTPD_STRING_ATTR = "<em>ContikiMAC (COMPOWER):</em> Tx %02u:%02u:%02u (%u.%02u%%) "; static const char httpd_cgi_sensor32[] HTTPD_STRING_ATTR = "Rx %02u:%02u:%02u (%u.%02u%%)\n"; s=compower_idle_activity.transmit/RTIMER_ARCH_SECOND; h=((10000UL*compower_idle_activity.transmit)/RTIMER_ARCH_SECOND)/seconds; p1=h/100;p2=h-p1*100;h=s/3600;s=s-h*3600;m=s/60;s=s-m*60; numprinted+=httpd_snprintf((char *)uip_appdata+numprinted, uip_mss()-numprinted, httpd_cgi_sensor31, h,m,s,p1,p2); s=compower_idle_activity.listen/RTIMER_ARCH_SECOND; h=((10000UL*compower_idle_activity.listen)/RTIMER_ARCH_SECOND)/seconds; p1=h/100;p2=h-p1*100;h=s/3600;s=s-h*3600;m=s/60;s=s-m*60; numprinted+=httpd_snprintf((char *)uip_appdata+numprinted, uip_mss()-numprinted, httpd_cgi_sensor32, h,m,s,p1,p2); } #endif #if RIMESTATS_CONF_ON #include "net/rime/rimestats.h" static const char httpd_cgi_sensor21[] HTTPD_STRING_ATTR = "<em>Packets (RIMESTATS):</em> Tx=%5lu Rx=%5lu TxL=%4lu RxL=%4lu\n"; numprinted+=httpd_snprintf((char *)uip_appdata+numprinted, uip_mss()-numprinted, httpd_cgi_sensor21, rimestats.tx,rimestats.rx,rimestats.lltx-rimestats.tx,rimestats.llrx-rimestats.rx); #endif static const char httpd_cgi_sensor99[] HTTPD_STRING_ATTR = "</pre>"; numprinted+=httpd_snprintf((char *)uip_appdata+numprinted, uip_mss()-numprinted, httpd_cgi_sensor99); return numprinted; }
/*---------------------------------------------------------------------------*/ static uint32_t thread_metric_rx(void) { energest_flush(); return energest_type_time(ENERGEST_TYPE_LISTEN); }
static uint32_t thread_metric_tx(void) { energest_flush(); return energest_type_time(ENERGEST_TYPE_TRANSMIT); }
/* * this function produce a string @buf in form of json data * example of buf: * * {'clk':%d,'syn':%d,'cpu':%d,'lpm':%d,'tras':%d,'lst':%d, * 'parent':%s,'etx':%d,'rt':%d,\'nbr':%d,'bea_itv':%d,'sen':%d} * */ void collectd_prepare_data() { uint16_t parent_etx; uint16_t rtmetric; uint16_t num_neighbors; uint16_t beacon_interval; rpl_parent_t *preferred_parent; uip_lladdr_t lladdr_parent; rpl_dag_t *dag; //copied from collect-view.c static unsigned long last_cpu, last_lpm, last_transmit, last_listen; unsigned long cpu, lpm, transmit, listen; u16_t clock, timesynch_time; clock = clock_time(); #if TIMESYNCH_CONF_ENABLED timesynch_time = timesynch_time(); #else /* TIMESYNCH_CONF_ENABLED */ timesynch_time = 0; #endif /* TIMESYNCH_CONF_ENABLED */ /*save to buf */ blen = 0; ADD("{'clk':%u,'syn':%u,", clock, timesynch_time); energest_flush(); cpu = energest_type_time(ENERGEST_TYPE_CPU) - last_cpu; lpm = energest_type_time(ENERGEST_TYPE_LPM) - last_lpm; transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT) - last_transmit; listen = energest_type_time(ENERGEST_TYPE_LISTEN) - last_listen; /* Make sure that the values are within 16 bits. If they are larger, we scale them down to fit into 16 bits. */ //TODO: why do i need to scale down to 16 bit? while(cpu >= 65536ul || lpm >= 65536ul || transmit >= 65536ul || listen >= 65536ul) { cpu /= 2; lpm /= 2; transmit /= 2; listen /= 2; } /* prepare for next calling */ last_cpu = energest_type_time(ENERGEST_TYPE_CPU); last_lpm = energest_type_time(ENERGEST_TYPE_LPM); last_transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT); last_listen = energest_type_time(ENERGEST_TYPE_LISTEN); /* save to buf */ ADD("'cpu':%u,'lpm':%u,'tras':%u,'lst':%u,", (u16_t)cpu, (u16_t)lpm, (u16_t)transmit, (u16_t)listen); /* initial value, if there's not any dag */ parent_etx = 0; rtmetric = 0; beacon_interval = 0; num_neighbors = 0; /* Let's suppose we have only one instance */ dag = rpl_get_any_dag(); if(dag != NULL) { preferred_parent = dag->preferred_parent; if(preferred_parent != NULL) { uip_ds6_nbr_t *nbr; nbr = uip_ds6_nbr_lookup(&preferred_parent->addr); if(nbr != NULL) { //PRINT6ADDR(&nbr->lladdr); memcpy(&lladdr_parent, &nbr->lladdr, sizeof(uip_lladdr_t)); parent_etx = neighbor_info_get_metric((rimeaddr_t *) &nbr->lladdr) / 2; } } rtmetric = dag->rank; beacon_interval = (uint16_t) ((2L << dag->instance->dio_intcurrent) / 1000); num_neighbors = RPL_PARENT_COUNT(dag); } char lladdr_parent_str[30]; u8_t lladdr_str_len; lladdr_str_len = lladdr_print(&lladdr_parent, lladdr_parent_str, 30); ADD("'parent':'%s',", lladdr_parent_str); ADD("'etx':%u,'rt':%u,'nbr':%u,'bea_itv':%u,", parent_etx, rtmetric, num_neighbors, beacon_interval); //collectd_arch_read_sensors(); #if CONTIKI_TARGET_SKY u8_t sensors[MAX_SENSORS_BUF_SIZE]; //PRINTF("oh,sky\n"); if (collect_view_arch_read_sensors(sensors, MAX_SENSORS_BUF_SIZE) >= 0) { ADD("'sen':'%s',", sensors); } #endif ADD("}"); }