/*---------------------------------------------------------------------------*/ 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 ); }
/*---------------------------------------------------------------------------*/ 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; }
/*---------------------------------------------------------------------------*/ 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); }
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 lwb_update_ctrl_energest() { // This function should be called after Glossy finishes for schedules, stream requests and // stream acknowledgements #if LWB_CONTROL_DC lwb_context.en_control += (energest_type_time(ENERGEST_TYPE_LISTEN) - lwb_context.en_rx) + (energest_type_time(ENERGEST_TYPE_TRANSMIT) - lwb_context.en_tx); #endif // LWB_CONTROL_DC }
void lwb_save_ctrl_energest() { // This function should be called before starting Glossy for schedules, stream requests and // stream acknowledgements #if LWB_CONTROL_DC lwb_context.en_rx = energest_type_time(ENERGEST_TYPE_LISTEN); lwb_context.en_tx = energest_type_time(ENERGEST_TYPE_TRANSMIT); #endif // LWB_CONTROL_DC }
PROCESS_THREAD(glossy_print_stats_process, ev, data) { PROCESS_BEGIN(); while(1) { PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL); // Print statistics only if Glossy is not still bootstrapping. if (!GLOSSY_IS_BOOTSTRAPPING()) { if (get_rx_cnt()) { // Packet received at least once. // Increment number of successfully received packets. packets_received++; // Compute latency during last Glossy phase. rtimer_clock_t lat = get_t_first_rx_l() - get_t_ref_l(); // Add last latency to sum of latencies. sum_latency += lat; // Convert latency to microseconds. latency = (unsigned long)(lat) * 1e6 / RTIMER_SECOND; // Print information about last packet and related latency. printf("Glossy received %u time%s: seq_no %lu, latency %lu.%03lu ms\n", get_rx_cnt(), (get_rx_cnt() > 1) ? "s" : "", glossy_data.seq_no, latency / 1000, latency % 1000); } else { // Packet not received. // Increment number of missed packets. packets_missed++; // Print failed reception. printf("Glossy NOT received\n"); } #if GLOSSY_DEBUG // printf("skew %ld ppm\n", (long)(period_skew * 1e6) / GLOSSY_PERIOD); printf("high_T_irq %u, rx_timeout %u, bad_length %u, bad_header %u, bad_crc %u\n", high_T_irq, rx_timeout, bad_length, bad_header, bad_crc); #endif /* GLOSSY_DEBUG */ // Compute current average reliability. unsigned long avg_rel = packets_received * 1e5 / (packets_received + packets_missed); // Print information about average reliability. printf("average reliability %3lu.%03lu %% ", avg_rel / 1000, avg_rel % 1000); printf("(missed %lu out of %lu packets)\n", packets_missed, packets_received + packets_missed); #if ENERGEST_CONF_ON // Compute average radio-on time, in microseconds. unsigned long avg_radio_on = (unsigned long)GLOSSY_PERIOD * 1e6 / RTIMER_SECOND * (energest_type_time(ENERGEST_TYPE_LISTEN) + energest_type_time(ENERGEST_TYPE_TRANSMIT)) / (energest_type_time(ENERGEST_TYPE_CPU) + energest_type_time(ENERGEST_TYPE_LPM)); // Print information about average radio-on time. printf("average radio-on time %lu.%03lu ms\n", avg_radio_on / 1000, avg_radio_on % 1000); #endif /* ENERGEST_CONF_ON */ // Compute average latency, in microseconds. unsigned long avg_latency = sum_latency * 1e6 / (RTIMER_SECOND * packets_received); // Print information about average latency. printf("average latency %lu.%03lu ms\n", avg_latency / 1000, avg_latency % 1000); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ 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); }
/*---------------------------------------------------------------------------*/ 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 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); }
static PT_THREAD(sensorscall(struct httpd_state *s, char *ptr)) { static struct timer t; static int i; static char buf[100]; static unsigned long last_cpu, last_lpm, last_listen, last_transmit; PSOCK_BEGIN(&s->sout); timer_set(&t, CLOCK_SECOND); i = 0; /* while(1)*/ { /* timer_restart(&t); PSOCK_WAIT_UNTIL(&s->sout, timer_expired(&t));*/ #if CONTIKI_TARGET_SKY SENSORS_ACTIVATE(sht11_sensor); SENSORS_ACTIVATE(light_sensor); 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); #else /* CONTIKI_TARGET_SKY */ snprintf(buf, sizeof(buf), "t(%d);h(%d);l1(%d);l2(%d);", 0, 0, 0, 0); #endif /* CONTIKI_TARGET_SKY */ PSOCK_SEND_STR(&s->sout, buf); /* timer_restart(&t); PSOCK_WAIT_UNTIL(&s->sout, timer_expired(&t));*/ snprintf(buf, sizeof(buf), "p(%lu,%lu,%lu,%lu);i(%d);", energest_type_time(ENERGEST_TYPE_CPU) - last_cpu, energest_type_time(ENERGEST_TYPE_LPM) - last_lpm, energest_type_time(ENERGEST_TYPE_TRANSMIT) - last_transmit, energest_type_time(ENERGEST_TYPE_LISTEN) - last_listen, i++); 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); PSOCK_SEND_STR(&s->sout, buf); } PSOCK_END(&s->sout); }
/*---------------------------------------------------------------------------*/ 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 abc_recv ( struct abc_conn *c ) { mst_t *rcv_msg; uint8_t decrypted[MSG_LEN]; int j, i; rcv_msg = packetbuf_dataptr(); printf("\nmessage received\n"); for(i = 0; i < rcv_msg->len; i++) { printf ( "%u:", rcv_msg->dat[i]); } printf("\n"); ENERGEST_OFF ( ENERGEST_TYPE_CPU ); ENERGEST_OFF ( ENERGEST_TYPE_LPM ); ENERGEST_OFF ( ENERGEST_TYPE_TRANSMIT ); ENERGEST_OFF ( ENERGEST_TYPE_LISTEN ); ENERGEST_ON ( ENERGEST_TYPE_CPU ); ENERGEST_ON ( ENERGEST_TYPE_LPM ); ENERGEST_ON ( ENERGEST_TYPE_TRANSMIT ); ENERGEST_ON ( ENERGEST_TYPE_LISTEN ); 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.cpu = energest_type_time ( ENERGEST_TYPE_CPU ); j = ecc_decrypt(decrypted, MSG_LEN, rcv_msg->dat, rcv_msg->len, 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; if ( j > 0 ) { printf ( "\nDecrypted data\n" ); for ( i =0; i < MSG_LEN; i++ ) { printf ( "%u:", decrypted[i] ); } printf ( "\n" ); printf ( "Clock ticks recorded by\nCPU = %ld \nLPM = %ld \nTRANSMITTER = %ld\nRECEIVER = %ld\n",diff.cpu, diff.lpm, diff.transmit, diff.listen ); } else { printf("couldn't decrypt\n"); } }
/*---------------------------------------------------------------------------*/ static PT_THREAD(sensorscall(struct httpd_state *s, char *ptr)) { static struct timer t; static int i; static char buf[100]; static unsigned long last_cpu, last_lpm, last_listen, last_transmit; PSOCK_BEGIN(&s->sout); timer_set(&t, CLOCK_SECOND); SENSORS_ACTIVATE(acc_sensor); 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); PSOCK_SEND_STR(&s->sout, buf); snprintf(buf, sizeof(buf), "p(%lu,%lu,%lu,%lu);v(%d);", energest_type_time(ENERGEST_TYPE_CPU) - last_cpu, energest_type_time(ENERGEST_TYPE_LPM) - last_lpm, energest_type_time(ENERGEST_TYPE_TRANSMIT) - last_transmit, energest_type_time(ENERGEST_TYPE_LISTEN) - last_listen, i++); 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); PSOCK_SEND_STR(&s->sout, buf); PSOCK_END(&s->sout); }
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 ); }
/*---------------------------------------------------------------------------*/ 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(); }
/*--------------------------------------------------------------------------*/ int main(int argc, char **argv) { /* * Initalize hardware. */ msp430_cpu_init(); clock_init(); leds_init(); leds_on(LEDS_RED); uart1_init(BAUD2UBR(115200)); /* Must come before first printf */ leds_on(LEDS_GREEN); /* xmem_init(); */ rtimer_init(); lcd_init(); watchdog_init(); PRINTF(CONTIKI_VERSION_STRING "\n"); /* PRINTF("Compiled at %s, %s\n", __TIME__, __DATE__);*/ /* * Hardware initialization done! */ leds_on(LEDS_RED); /* Restore node id if such has been stored in external mem */ #ifdef NODEID node_id = NODEID; #ifdef BURN_NODEID node_id_burn(node_id); node_id_restore(); /* also configures node_mac[] */ #endif /* BURN_NODEID */ #else node_id_restore(); /* also configures node_mac[] */ #endif /* NODE_ID */ /* for setting "hardcoded" IEEE 802.15.4 MAC addresses */ #ifdef MAC_1 { uint8_t ieee[] = { MAC_1, MAC_2, MAC_3, MAC_4, MAC_5, MAC_6, MAC_7, MAC_8 }; memcpy(node_mac, ieee, sizeof(uip_lladdr.addr)); } #endif /* * Initialize Contiki and our processes. */ process_init(); process_start(&etimer_process, NULL); ctimer_init(); set_rime_addr(); random_init(node_id); NETSTACK_RADIO.init(); #if CC11xx_CC1101 || CC11xx_CC1120 printf("Starting up cc11xx radio at channel %d\n", RF_CHANNEL); cc11xx_channel_set(RF_CHANNEL); #endif /* CC11xx_CC1101 || CC11xx_CC1120 */ #if CONFIGURE_CC2420 || CONFIGURE_CC2520 { uint8_t longaddr[8]; uint16_t shortaddr; shortaddr = (rimeaddr_node_addr.u8[0] << 8) + rimeaddr_node_addr.u8[1]; memset(longaddr, 0, sizeof(longaddr)); rimeaddr_copy((rimeaddr_t *)&longaddr, &rimeaddr_node_addr); printf("MAC %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", longaddr[0], longaddr[1], longaddr[2], longaddr[3], longaddr[4], longaddr[5], longaddr[6], longaddr[7]); #if CONFIGURE_CC2420 cc2420_set_pan_addr(IEEE802154_PANID, shortaddr, longaddr); #endif /* CONFIGURE_CC2420 */ #if CONFIGURE_CC2520 cc2520_set_pan_addr(IEEE802154_PANID, shortaddr, longaddr); #endif /* CONFIGURE_CC2520 */ } #if CONFIGURE_CC2420 cc2420_set_channel(RF_CHANNEL); #endif /* CONFIGURE_CC2420 */ #if CONFIGURE_CC2520 cc2520_set_channel(RF_CHANNEL); #endif /* CONFIGURE_CC2520 */ #endif /* CONFIGURE_CC2420 || CONFIGURE_CC2520 */ NETSTACK_RADIO.on(); leds_off(LEDS_ALL); if(node_id > 0) { PRINTF("Node id %u.\n", node_id); } else { PRINTF("Node id not set.\n"); } #if WITH_UIP6 memcpy(&uip_lladdr.addr, node_mac, sizeof(uip_lladdr.addr)); /* Setup nullmac-like MAC for 802.15.4 */ queuebuf_init(); netstack_init(); printf("%s/%s %lu %u\n", NETSTACK_RDC.name, NETSTACK_MAC.name, CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0 ? 1: NETSTACK_RDC.channel_check_interval()), RF_CHANNEL); process_start(&tcpip_process, NULL); printf("IPv6 "); { uip_ds6_addr_t *lladdr; int i; lladdr = uip_ds6_get_link_local(-1); for(i = 0; i < 7; ++i) { printf("%02x%02x:", lladdr->ipaddr.u8[i * 2], lladdr->ipaddr.u8[i * 2 + 1]); } printf("%02x%02x\n", lladdr->ipaddr.u8[14], lladdr->ipaddr.u8[15]); } if(1) { uip_ipaddr_t ipaddr; int i; uip_ip6addr(&ipaddr, 0xfc00, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_TENTATIVE); printf("Tentative global IPv6 address "); for(i = 0; i < 7; ++i) { printf("%02x%02x:", ipaddr.u8[i * 2], ipaddr.u8[i * 2 + 1]); } printf("%02x%02x\n", ipaddr.u8[7 * 2], ipaddr.u8[7 * 2 + 1]); } #else /* WITH_UIP6 */ netstack_init(); printf("%s %lu %u\n", NETSTACK_RDC.name, CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0? 1: NETSTACK_RDC.channel_check_interval()), RF_CHANNEL); #endif /* WITH_UIP6 */ #if !WITH_UIP6 uart1_set_input(serial_line_input_byte); serial_line_init(); #endif #ifdef NETSTACK_AES_H #ifndef NETSTACK_AES_KEY #error Please define NETSTACK_AES_KEY! #endif /* NETSTACK_AES_KEY */ { const uint8_t key[] = NETSTACK_AES_KEY; netstack_aes_set_key(key); } /*printf("AES encryption is enabled: '%s'\n", NETSTACK_AES_KEY);*/ printf("AES encryption is enabled\n"); #else /* NETSTACK_AES_H */ printf("Warning: AES encryption is disabled\n"); #endif /* NETSTACK_AES_H */ #if TIMESYNCH_CONF_ENABLED timesynch_init(); timesynch_set_authority_level(rimeaddr_node_addr.u8[0]); #endif /* TIMESYNCH_CONF_ENABLED */ #if CC11xx_CC1101 || CC11xx_CC1120 printf("cc11xx radio at channel %d\n", RF_CHANNEL); cc11xx_channel_set(RF_CHANNEL); #endif /* CC11xx_CC1101 || CC11xx_CC1120 */ #if CONFIGURE_CC2420 { uint8_t longaddr[8]; uint16_t shortaddr; shortaddr = (rimeaddr_node_addr.u8[0] << 8) + rimeaddr_node_addr.u8[1]; memset(longaddr, 0, sizeof(longaddr)); rimeaddr_copy((rimeaddr_t *)&longaddr, &rimeaddr_node_addr); printf("MAC %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", longaddr[0], longaddr[1], longaddr[2], longaddr[3], longaddr[4], longaddr[5], longaddr[6], longaddr[7]); cc2420_set_pan_addr(IEEE802154_PANID, shortaddr, longaddr); } cc2420_set_channel(RF_CHANNEL); #endif /* CONFIGURE_CC2420 */ NETSTACK_RADIO.on(); /* process_start(&sensors_process, NULL); SENSORS_ACTIVATE(button_sensor);*/ energest_init(); ENERGEST_ON(ENERGEST_TYPE_CPU); simple_rpl_init(); watchdog_start(); print_processes(autostart_processes); autostart_start(autostart_processes); duty_cycle_scroller_start(CLOCK_SECOND * 2); #if IP64_CONF_UIP_FALLBACK_INTERFACE_SLIP && WITH_SLIP /* Start the SLIP */ printf("Initiating SLIP: my IP is 172.16.0.2...\n"); slip_arch_init(0); { uip_ip4addr_t ipv4addr, netmask; uip_ipaddr(&ipv4addr, 172, 16, 0, 2); uip_ipaddr(&netmask, 255, 255, 255, 0); ip64_set_ipv4_address(&ipv4addr, &netmask); } uart1_set_input(slip_input_byte); #endif /* IP64_CONF_UIP_FALLBACK_INTERFACE_SLIP */ /* * This is the scheduler loop. */ while(1) { int r; do { /* Reset watchdog. */ watchdog_periodic(); r = process_run(); } while(r > 0); /* * Idle processing. */ int s = splhigh(); /* Disable interrupts. */ /* uart1_active is for avoiding LPM3 when still sending or receiving */ if(process_nevents() != 0 || uart1_active()) { splx(s); /* Re-enable interrupts. */ } else { static unsigned long irq_energest = 0; /* Re-enable interrupts and go to sleep atomically. */ ENERGEST_OFF(ENERGEST_TYPE_CPU); ENERGEST_ON(ENERGEST_TYPE_LPM); /* We only want to measure the processing done in IRQs when we are asleep, so we discard the processing time done when we were awake. */ energest_type_set(ENERGEST_TYPE_IRQ, irq_energest); watchdog_stop(); _BIS_SR(GIE | SCG0 | SCG1 | CPUOFF); /* LPM3 sleep. This statement will block until the CPU is woken up by an interrupt that sets the wake up flag. */ /* We get the current processing time for interrupts that was done during the LPM and store it for next time around. */ dint(); irq_energest = energest_type_time(ENERGEST_TYPE_IRQ); eint(); watchdog_start(); ENERGEST_OFF(ENERGEST_TYPE_LPM); ENERGEST_ON(ENERGEST_TYPE_CPU); } } }
/*--------------------------------------------------------------------------*/ int main(int argc, char **argv) { /* * Initalize hardware. */ msp430_cpu_init(); clock_init(); leds_init(); leds_on(LEDS_RED); uart1_init(BAUD2UBR(115200)); /* Must come before first printf */ #if NETSTACK_CONF_WITH_IPV4 slip_arch_init(BAUD2UBR(115200)); #endif /* NETSTACK_CONF_WITH_IPV4 */ leds_on(LEDS_GREEN); /* xmem_init(); */ rtimer_init(); lcd_init(); PRINTF(CONTIKI_VERSION_STRING "\n"); /* * Hardware initialization done! */ leds_on(LEDS_RED); /* Restore node id if such has been stored in external mem */ // node_id_restore(); #ifdef NODEID node_id = NODEID; #ifdef BURN_NODEID flash_setup(); flash_clear(0x1800); flash_write(0x1800, node_id); flash_done(); #endif /* BURN_NODEID */ #endif /* NODE_ID */ if(node_id == 0) { node_id = *((unsigned short *)0x1800); } memset(node_mac, 0, sizeof(node_mac)); node_mac[6] = node_id >> 8; node_mac[7] = node_id & 0xff; /* for setting "hardcoded" IEEE 802.15.4 MAC addresses */ #ifdef MAC_1 { uint8_t ieee[] = { MAC_1, MAC_2, MAC_3, MAC_4, MAC_5, MAC_6, MAC_7, MAC_8 }; memcpy(node_mac, ieee, sizeof(uip_lladdr.addr)); } #endif /* * Initialize Contiki and our processes. */ process_init(); process_start(&etimer_process, NULL); ctimer_init(); set_rime_addr(); cc2420_init(); { uint8_t longaddr[8]; uint16_t shortaddr; shortaddr = (linkaddr_node_addr.u8[0] << 8) + linkaddr_node_addr.u8[1]; memset(longaddr, 0, sizeof(longaddr)); linkaddr_copy((linkaddr_t *)&longaddr, &linkaddr_node_addr); printf("MAC %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", longaddr[0], longaddr[1], longaddr[2], longaddr[3], longaddr[4], longaddr[5], longaddr[6], longaddr[7]); cc2420_set_pan_addr(IEEE802154_PANID, shortaddr, longaddr); } leds_off(LEDS_ALL); if(node_id > 0) { PRINTF("Node id %u.\n", node_id); } else { PRINTF("Node id not set.\n"); } #if NETSTACK_CONF_WITH_IPV6 memcpy(&uip_lladdr.addr, node_mac, sizeof(uip_lladdr.addr)); /* Setup nullmac-like MAC for 802.15.4 */ queuebuf_init(); NETSTACK_RDC.init(); NETSTACK_MAC.init(); NETSTACK_NETWORK.init(); printf("%s %lu %u\n", NETSTACK_RDC.name, CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0 ? 1: NETSTACK_RDC.channel_check_interval()), CC2420_CONF_CHANNEL); process_start(&tcpip_process, NULL); printf("IPv6 "); { uip_ds6_addr_t *lladdr; int i; lladdr = uip_ds6_get_link_local(-1); for(i = 0; i < 7; ++i) { printf("%02x%02x:", lladdr->ipaddr.u8[i * 2], lladdr->ipaddr.u8[i * 2 + 1]); } printf("%02x%02x\n", lladdr->ipaddr.u8[14], lladdr->ipaddr.u8[15]); } if(!UIP_CONF_IPV6_RPL) { uip_ipaddr_t ipaddr; int i; uip_ip6addr(&ipaddr, UIP_DS6_DEFAULT_PREFIX, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_TENTATIVE); printf("Tentative global IPv6 address "); for(i = 0; i < 7; ++i) { printf("%02x%02x:", ipaddr.u8[i * 2], ipaddr.u8[i * 2 + 1]); } printf("%02x%02x\n", ipaddr.u8[7 * 2], ipaddr.u8[7 * 2 + 1]); } #else /* NETSTACK_CONF_WITH_IPV6 */ NETSTACK_RDC.init(); NETSTACK_MAC.init(); NETSTACK_NETWORK.init(); printf("%s %lu %u\n", NETSTACK_RDC.name, CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0? 1: NETSTACK_RDC.channel_check_interval()), CC2420_CONF_CHANNEL); #endif /* NETSTACK_CONF_WITH_IPV6 */ #if !NETSTACK_CONF_WITH_IPV6 uart1_set_input(serial_line_input_byte); serial_line_init(); #endif #if TIMESYNCH_CONF_ENABLED timesynch_init(); timesynch_set_authority_level(linkaddr_node_addr.u8[0]); #endif /* TIMESYNCH_CONF_ENABLED */ /* process_start(&sensors_process, NULL); SENSORS_ACTIVATE(button_sensor);*/ energest_init(); ENERGEST_ON(ENERGEST_TYPE_CPU); print_processes(autostart_processes); autostart_start(autostart_processes); duty_cycle_scroller_start(CLOCK_SECOND * 2); /* * This is the scheduler loop. */ watchdog_start(); watchdog_stop(); /* Stop the wdt... */ while(1) { int r; do { /* Reset watchdog. */ watchdog_periodic(); r = process_run(); } while(r > 0); /* * Idle processing. */ int s = splhigh(); /* Disable interrupts. */ /* uart1_active is for avoiding LPM3 when still sending or receiving */ if(process_nevents() != 0 || uart1_active()) { splx(s); /* Re-enable interrupts. */ } else { static unsigned long irq_energest = 0; /* Re-enable interrupts and go to sleep atomically. */ ENERGEST_SWITCH(ENERGEST_TYPE_CPU, ENERGEST_TYPE_LPM); /* We only want to measure the processing done in IRQs when we are asleep, so we discard the processing time done when we were awake. */ energest_type_set(ENERGEST_TYPE_IRQ, irq_energest); watchdog_stop(); _BIS_SR(GIE | SCG0 | SCG1 | CPUOFF); /* LPM3 sleep. This statement will block until the CPU is woken up by an interrupt that sets the wake up flag. */ /* We get the current processing time for interrupts that was done during the LPM and store it for next time around. */ dint(); irq_energest = energest_type_time(ENERGEST_TYPE_IRQ); eint(); watchdog_start(); ENERGEST_SWITCH(ENERGEST_TYPE_LPM, ENERGEST_TYPE_CPU); } } }
/*---------------------------------------------------------------------------*/ int main(int argc, char **argv) { /* * Initalize hardware. */ msp430_cpu_init(); clock_init(); leds_init(); leds_on(LEDS_RED); clock_wait(100); uart0_init(BAUD2UBR(UART0_BAUD_RATE)); /* Must come before first printf */ #if NETSTACK_CONF_WITH_IPV4 slip_arch_init(BAUD2UBR(UART0_BAUD_RATE)); #endif /* NETSTACK_CONF_WITH_IPV4 */ xmem_init(); rtimer_init(); /* * Hardware initialization done! */ /* Restore node id if such has been stored in external mem */ node_id_restore(); /* If no MAC address was burned, we use the node id or the Z1 product ID */ if(!(node_mac[0] | node_mac[1] | node_mac[2] | node_mac[3] | node_mac[4] | node_mac[5] | node_mac[6] | node_mac[7])) { #ifdef SERIALNUM if(!node_id) { PRINTF("Node id is not set, using Z1 product ID\n"); node_id = SERIALNUM; } #endif node_mac[0] = 0xc1; /* Hardcoded for Z1 */ node_mac[1] = 0x0c; /* Hardcoded for Revision C */ node_mac[2] = 0x00; /* Hardcoded to arbitrary even number so that the 802.15.4 MAC address is compatible with an Ethernet MAC address - byte 0 (byte 2 in the DS ID) */ node_mac[3] = 0x00; /* Hardcoded */ node_mac[4] = 0x00; /* Hardcoded */ node_mac[5] = 0x00; /* Hardcoded */ node_mac[6] = node_id >> 8; node_mac[7] = node_id & 0xff; } /* Overwrite node MAC if desired at compile time */ #ifdef MACID #warning "***** CHANGING DEFAULT MAC *****" node_mac[0] = 0xc1; /* Hardcoded for Z1 */ node_mac[1] = 0x0c; /* Hardcoded for Revision C */ node_mac[2] = 0x00; /* Hardcoded to arbitrary even number so that the 802.15.4 MAC address is compatible with an Ethernet MAC address - byte 0 (byte 2 in the DS ID) */ node_mac[3] = 0x00; /* Hardcoded */ node_mac[4] = 0x00; /* Hardcoded */ node_mac[5] = 0x00; /* Hardcoded */ node_mac[6] = MACID >> 8; node_mac[7] = MACID & 0xff; #endif #ifdef IEEE_802154_MAC_ADDRESS /* for setting "hardcoded" IEEE 802.15.4 MAC addresses */ { uint8_t ieee[] = IEEE_802154_MAC_ADDRESS; memcpy(node_mac, ieee, sizeof(uip_lladdr.addr)); node_mac[7] = node_id & 0xff; } #endif /* IEEE_802154_MAC_ADDRESS */ /* * Initialize Contiki and our processes. */ random_init(node_mac[6] + node_mac[7]); process_init(); process_start(&etimer_process, NULL); ctimer_init(); init_platform(); set_rime_addr(); cc2420_init(); SENSORS_ACTIVATE(adxl345); { uint8_t longaddr[8]; uint16_t shortaddr; shortaddr = (linkaddr_node_addr.u8[0] << 8) + linkaddr_node_addr.u8[1]; memset(longaddr, 0, sizeof(longaddr)); linkaddr_copy((linkaddr_t *)&longaddr, &linkaddr_node_addr); printf("MAC %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x ", longaddr[0], longaddr[1], longaddr[2], longaddr[3], longaddr[4], longaddr[5], longaddr[6], longaddr[7]); cc2420_set_pan_addr(IEEE802154_PANID, shortaddr, longaddr); } leds_off(LEDS_ALL); #ifdef SERIALNUM PRINTF("Ref ID: %u\n", SERIALNUM); #endif PRINTF(CONTIKI_VERSION_STRING " started. "); if(node_id) { PRINTF("Node id is set to %u.\n", node_id); } else { PRINTF("Node id not set\n"); } #if NETSTACK_CONF_WITH_IPV6 memcpy(&uip_lladdr.addr, node_mac, sizeof(uip_lladdr.addr)); /* Setup nullmac-like MAC for 802.15.4 */ /* sicslowpan_init(sicslowmac_init(&cc2420_driver)); */ /* printf(" %s channel %u\n", sicslowmac_driver.name, CC2420_CONF_CHANNEL); */ /* Setup X-MAC for 802.15.4 */ queuebuf_init(); netstack_init(); // NETSTACK_RDC.init(); // NETSTACK_MAC.init(); // NETSTACK_LLSEC.init(); // NETSTACK_NETWORK.init(); printf("%s %s %s, channel check rate %lu Hz, radio channel %u\n", NETSTACK_LLSEC.name, NETSTACK_MAC.name, NETSTACK_RDC.name, CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0 ? 1 : NETSTACK_RDC.channel_check_interval()), CC2420_CONF_CHANNEL); process_start(&tcpip_process, NULL); printf("Tentative link-local IPv6 address "); { uip_ds6_addr_t *lladdr; int i; lladdr = uip_ds6_get_link_local(-1); for(i = 0; i < 7; ++i) { printf("%02x%02x:", lladdr->ipaddr.u8[i * 2], lladdr->ipaddr.u8[i * 2 + 1]); } printf("%02x%02x\n", lladdr->ipaddr.u8[14], lladdr->ipaddr.u8[15]); } if(!UIP_CONF_IPV6_RPL) { uip_ipaddr_t ipaddr; int i; uip_ip6addr(&ipaddr, UIP_DS6_DEFAULT_PREFIX, 0, 0, 0, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_TENTATIVE); printf("Tentative global IPv6 address "); for(i = 0; i < 7; ++i) { printf("%02x%02x:", ipaddr.u8[i * 2], ipaddr.u8[i * 2 + 1]); } printf("%02x%02x\n", ipaddr.u8[7 * 2], ipaddr.u8[7 * 2 + 1]); } #else /* NETSTACK_CONF_WITH_IPV6 */ netstack_init(); //NETSTACK_RDC.init(); //NETSTACK_MAC.init(); //NETSTACK_LLSEC.init(); //NETSTACK_NETWORK.init(); printf("%s %s %s, channel check rate %lu Hz, radio channel %u\n", NETSTACK_LLSEC.name, NETSTACK_MAC.name, NETSTACK_RDC.name, CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0 ? 1 : NETSTACK_RDC.channel_check_interval()), CC2420_CONF_CHANNEL); #endif /* NETSTACK_CONF_WITH_IPV6 */ #if !NETSTACK_CONF_WITH_IPV4 && !NETSTACK_CONF_WITH_IPV6 uart0_set_input(serial_line_input_byte); serial_line_init(); #endif leds_off(LEDS_GREEN); #if TIMESYNCH_CONF_ENABLED timesynch_init(); timesynch_set_authority_level(linkaddr_node_addr.u8[0]); #endif /* TIMESYNCH_CONF_ENABLED */ #if NETSTACK_CONF_WITH_IPV4 process_start(&tcpip_process, NULL); process_start(&uip_fw_process, NULL); /* Start IP output */ process_start(&slip_process, NULL); slip_set_input_callback(set_gateway); { uip_ipaddr_t hostaddr, netmask; uip_init(); uip_ipaddr(&hostaddr, 172, 16, linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1]); uip_ipaddr(&netmask, 255, 255, 0, 0); uip_ipaddr_copy(&meshif.ipaddr, &hostaddr); uip_sethostaddr(&hostaddr); uip_setnetmask(&netmask); uip_over_mesh_set_net(&hostaddr, &netmask); /* uip_fw_register(&slipif);*/ uip_over_mesh_set_gateway_netif(&slipif); uip_fw_default(&meshif); uip_over_mesh_init(UIP_OVER_MESH_CHANNEL); printf("uIP started with IP address %d.%d.%d.%d\n", uip_ipaddr_to_quad(&hostaddr)); } #endif /* NETSTACK_CONF_WITH_IPV4 */ energest_init(); ENERGEST_ON(ENERGEST_TYPE_CPU); print_processes(autostart_processes); autostart_start(autostart_processes); /* * This is the scheduler loop. */ #if DCOSYNCH_CONF_ENABLED timer_set(&mgt_timer, DCOSYNCH_PERIOD * CLOCK_SECOND); #endif watchdog_start(); /* watchdog_stop();*/ while(1) { int r; do { /* Reset watchdog. */ watchdog_periodic(); r = process_run(); } while(r > 0); /* * Idle processing. */ int s = splhigh(); /* Disable interrupts. */ /* uart0_active is for avoiding LPM3 when still sending or receiving */ if(process_nevents() != 0 || uart0_active()) { splx(s); /* Re-enable interrupts. */ } else { static unsigned long irq_energest = 0; #if DCOSYNCH_CONF_ENABLED /* before going down to sleep possibly do some management */ if(timer_expired(&mgt_timer)) { timer_reset(&mgt_timer); msp430_sync_dco(); } #endif /* Re-enable interrupts and go to sleep atomically. */ ENERGEST_SWITCH(ENERGEST_TYPE_CPU, ENERGEST_TYPE_LPM); /* We only want to measure the processing done in IRQs when we are asleep, so we discard the processing time done when we were awake. */ energest_type_set(ENERGEST_TYPE_IRQ, irq_energest); watchdog_stop(); _BIS_SR(GIE | SCG0 | SCG1 | CPUOFF); /* LPM3 sleep. This statement will block until the CPU is woken up by an interrupt that sets the wake up flag. */ /* We get the current processing time for interrupts that was done during the LPM and store it for next time around. */ dint(); irq_energest = energest_type_time(ENERGEST_TYPE_IRQ); eint(); watchdog_start(); ENERGEST_SWITCH(ENERGEST_TYPE_LPM, ENERGEST_TYPE_CPU); } } return 0; }
int main(void) { #if WITH_SD int r; #endif /* WITH_SD */ msp430_cpu_init(); watchdog_stop(); /* Platform-specific initialization. */ msb_ports_init(); adc_init(); clock_init(); rtimer_init(); sht11_init(); leds_init(); leds_on(LEDS_ALL); irq_init(); process_init(); /* serial interface */ rs232_set_input(serial_line_input_byte); rs232_init(); serial_line_init(); uart_lock(UART_MODE_RS232); uart_unlock(UART_MODE_RS232); #if WITH_UIP slip_arch_init(BAUD2UBR(115200)); #endif #if WITH_SD r = sd_initialize(); if(r < 0) { printf("Failed to initialize the SD driver: %s\n", sd_error_string(r)); } else { sd_offset_t capacity; printf("The SD driver was successfully initialized\n"); capacity = sd_get_capacity(); if(capacity < 0) { printf("Failed to get the SD card capacity: %s\n", sd_error_string(r)); } else { printf("SD card capacity: %u MB\n", (unsigned)(capacity / (1024UL * 1024))); } } #endif /* System services */ process_start(&etimer_process, NULL); ctimer_init(); node_id_restore(); init_net(); energest_init(); #if PROFILE_CONF_ON profile_init(); #endif /* PROFILE_CONF_ON */ leds_off(LEDS_ALL); printf(CONTIKI_VERSION_STRING " started. Node id %u, using %s.\n", node_id, rime_mac->name); autostart_start(autostart_processes); /* * This is the scheduler loop. */ ENERGEST_ON(ENERGEST_TYPE_CPU); while (1) { int r; #if PROFILE_CONF_ON profile_episode_start(); #endif /* PROFILE_CONF_ON */ do { /* Reset watchdog. */ watchdog_periodic(); r = process_run(); } while(r > 0); #if PROFILE_CONF_ON profile_episode_end(); #endif /* PROFILE_CONF_ON */ /* * Idle processing. */ int s = splhigh(); /* Disable interrupts. */ if (process_nevents() != 0) { splx(s); /* Re-enable interrupts. */ } else { static unsigned long irq_energest = 0; /* Re-enable interrupts and go to sleep atomically. */ ENERGEST_OFF(ENERGEST_TYPE_CPU); ENERGEST_ON(ENERGEST_TYPE_LPM); /* * We only want to measure the processing done in IRQs when we * are asleep, so we discard the processing time done when we * were awake. */ energest_type_set(ENERGEST_TYPE_IRQ, irq_energest); if (uart_edge) { _BIC_SR(LPM1_bits + GIE); } else { _BIS_SR(LPM1_bits + GIE); } /* * We get the current processing time for interrupts that was * done during the LPM and store it for next time around. */ dint(); irq_energest = energest_type_time(ENERGEST_TYPE_IRQ); eint(); ENERGEST_OFF(ENERGEST_TYPE_LPM); ENERGEST_ON(ENERGEST_TYPE_CPU); #if PROFILE_CONF_ON profile_clear_timestamps(); #endif /* PROFILE_CONF_ON */ } } return 0; }
/*---------------------------------------------------------------------------*/ static int send_packet(void) { if (!xmac_is_on) { return 1; } struct { struct xmac_hdr hdr; } strobe, ack; volatile int len = 0; rtimer_clock_t t, t0; got_data_ack = 0; #if WITH_RANDOM_WAIT_BEFORE_SEND { rtimer_clock_t t = RTIMER_NOW() + (random_rand() % (xmac_config.on_time * 4)); while(RTIMER_CLOCK_LT(RTIMER_NOW(), t)); } #endif /* WITH_RANDOM_WAIT_BEFORE_SEND */ #if WITH_CHANNEL_CHECK /* Check if there are other strobes in the air. */ waiting_for_packet = 1; on(); t0 = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + xmac_config.strobe_wait_time * 2)) { len = radio->read(&strobe.hdr, sizeof(strobe.hdr)); if(len > 0) { someone_is_sending = 1; } } waiting_for_packet = 0; while(someone_is_sending); #endif /* WITH_CHANNEL_CHECK */ /* By setting we_are_sending to one, we ensure that the rtimer powercycle interrupt do not interfere with us sending the packet. */ we_are_sending = 1; off(); /* Create the X-MAC header for the data packet. We cannot do this in-place in the packet buffer, because we cannot be sure of the alignment of the header in the packet buffer. */ struct xmac_hdr hdr; hdr.type = TYPE_DATA; rimeaddr_copy(&hdr.sender, &rimeaddr_node_addr); rimeaddr_copy(&hdr.receiver, packetbuf_addr(PACKETBUF_ADDR_RECEIVER)); int is_broadcast = 0; if (rimeaddr_cmp(&hdr.receiver, &rimeaddr_null)) { is_broadcast = 1; } /* Copy the X-MAC header to the header portion of the packet buffer. */ packetbuf_hdralloc(sizeof(struct xmac_hdr)); memcpy(packetbuf_hdrptr(), &hdr, sizeof(struct xmac_hdr)); packetbuf_compact(); watchdog_stop(); /* Construct the strobe packet. */ strobe.hdr.type = TYPE_STROBE; rimeaddr_copy(&strobe.hdr.sender, &rimeaddr_node_addr); rimeaddr_copy(&strobe.hdr.receiver, packetbuf_addr(PACKETBUF_ADDR_RECEIVER)); /* Turn on the radio to listen for the strobe ACK. */ if (!is_broadcast) { on(); } #if EXCLUDE_TRICKLE_ENERGY unsigned long energest_listen = 0; unsigned long energest_transmit = 0; if (is_broadcast) { energest_listen = energest_type_time(ENERGEST_TYPE_LISTEN); energest_transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT); } #endif /* EXCLUDE_TRICKLE_ENERGY */ /* Send strobes until the receiver replies with an ACK */ int strobes = 0; int got_strobe_ack = 0; int interferred = 0; rtimer_clock_t strobe_wait_time; t0 = RTIMER_NOW(); for (strobes = 0; got_strobe_ack == 0 && interferred == 0 && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + xmac_config.strobe_time); strobes++) { if (is_broadcast){ /* Send the data packet. */ radio->send(packetbuf_hdrptr(), packetbuf_totlen()); strobe_wait_time = xmac_config.strobe_wait_time; } else { /* Send the strobe packet. */ radio->send((const uint8_t *) &strobe, sizeof(struct xmac_hdr)); strobe_wait_time = xmac_config.strobe_wait_time; } t = RTIMER_NOW(); while (got_strobe_ack == 0 && interferred == 0 && RTIMER_CLOCK_LT(RTIMER_NOW(), t + strobe_wait_time)) { /* See if we got an ACK */ if (!is_broadcast) { len = radio->read((uint8_t *) &ack, sizeof(struct xmac_hdr)); if (len > 0) { if ( ack.hdr.type == TYPE_STROBE_ACK && rimeaddr_cmp(&ack.hdr.sender, &rimeaddr_node_addr) && rimeaddr_cmp(&ack.hdr.receiver, &rimeaddr_node_addr)) { /* We got an ACK from the receiver, so we can immediately send the packet. */ got_strobe_ack = 1; }// else if (ack.hdr.type != TYPE_DATA_ACK) { /* We got a STROBE or a DATA packet, so we immediately stop strobing. */ // interferred = 1; //} } } } } if (!is_broadcast) { handshakes_total++; if (got_strobe_ack) { handshakes_succ++; } // update the handshake counters if (handshakes_total >= HANDSHAKES_RESET_PERIOD) { handshakes_total >>= 1; handshakes_succ >>= 1; }
/*---------------------------------------------------------------------------*/ 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++; }
cc2420_set_channel(RF_CHANNEL); } /*---------------------------------------------------------------------------*/ PROCESS_THREAD(output_process, ev, data) { static struct etimer et, et2; PROCESS_EXITHANDLER(abc_close(&abc);) PROCESS_BEGIN(); etimer_set(&et, 5*CLOCK_SECOND); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); /* Energy time init */ 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); abc_open(&abc, 128, &abc_call); if (node_id == SINK_ID) { while(1) { PROCESS_YIELD(); printf("I'm a sink. I'm doing nothing..."); } } etimer_set(&et, UPDATE_TICKS);
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(unicast_sender_process, ev, data) { static struct etimer periodic_timer; static struct etimer send_timer; uip_ipaddr_t *addr; PROCESS_BEGIN(); SENSORS_ACTIVATE(button_sensor); // SENSORS_ACTIVATE(light_sensor); servreg_hack_init(); set_global_address(); simple_udp_register(&unicast_connection, UDP_PORT, NULL, UDP_PORT, receiver); rx_start_duration = energest_type_time(ENERGEST_TYPE_LISTEN); //etimer_set(&periodic_timer, SEND_INTERVAL); while(1) { // PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&periodic_timer)); PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor); // etimer_reset(&periodic_timer); etimer_set(&send_timer, SEND_TIME); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&send_timer)); addr = servreg_hack_lookup(SERVICE_ID); if(addr != NULL) { static unsigned int button_number; char buf[50]; if(button_number == 0) { button_number = 1; leds_toggle(LEDS_ALL); } else { button_number = 0; leds_toggle(LEDS_ALL); } printf("Sending unicast to "); uip_debug_ipaddr_print(addr); printf("\n"); //sprintf(buf, "Occupancy Detector: %d, Luminaire Illuminance: %d", button_number, LUMINAIRE_ILLUMINANCE); sprintf(buf, "Occupancy Detector: %d, Luminous Intensity: %d", button_number, /*(int)(random() % 180 + 320 )*/ 1500 ); simple_udp_sendto(&unicast_connection, buf, strlen(buf) + 1, addr); // printf("energy rx: %lu\n", energest_type_time(ENERGEST_TYPE_LISTEN) - rx_start_duration); //printf("energy tx: %lu\n", energest_type_time(ENERGEST_TYPE_TRANSMIT) - rx_start_duration); //printf("cpu: %lu\n", energest_type_time(ENERGEST_TYPE_CPU) - rx_start_duration); //printf("lpm: %lu\n", energest_type_time(ENERGEST_TYPE_LPM) - rx_start_duration); } else { printf("Service %d not found\n", SERVICE_ID); } } PROCESS_END(); }
static uint32_t thread_metric_tx(void) { energest_flush(); return energest_type_time(ENERGEST_TYPE_TRANSMIT); }
/*---------------------------------------------------------------------------*/ static uint32_t thread_metric_rx(void) { energest_flush(); return energest_type_time(ENERGEST_TYPE_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++; }
/* * 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("}"); }
/*---------------------------------------------------------------------------*/ int main(int argc, char **argv) { /* * Initalize hardware. */ msp430_cpu_init(); clock_init(); leds_init(); leds_on(LEDS_RED); clock_wait(2); uart1_init(115200); /* Must come before first printf */ #if WITH_UIP slip_arch_init(115200); #endif /* WITH_UIP */ clock_wait(1); leds_on(LEDS_GREEN); //ds2411_init(); /* XXX hack: Fix it so that the 802.15.4 MAC address is compatible with an Ethernet MAC address - byte 0 (byte 2 in the DS ID) cannot be odd. */ //ds2411_id[2] &= 0xfe; leds_on(LEDS_BLUE); //xmem_init(); leds_off(LEDS_RED); rtimer_init(); /* * Hardware initialization done! */ node_id = NODE_ID; /* Restore node id if such has been stored in external mem */ //node_id_restore(); /* for setting "hardcoded" IEEE 802.15.4 MAC addresses */ #ifdef IEEE_802154_MAC_ADDRESS { uint8_t ieee[] = IEEE_802154_MAC_ADDRESS; //memcpy(ds2411_id, ieee, sizeof(uip_lladdr.addr)); //ds2411_id[7] = node_id & 0xff; } #endif //random_init(ds2411_id[0] + node_id); leds_off(LEDS_BLUE); /* * Initialize Contiki and our processes. */ process_init(); process_start(&etimer_process, NULL); ctimer_init(); init_platform(); set_rime_addr(); cc2520_init(); { uint8_t longaddr[8]; uint16_t shortaddr; shortaddr = (rimeaddr_node_addr.u8[0] << 8) + rimeaddr_node_addr.u8[1]; memset(longaddr, 0, sizeof(longaddr)); rimeaddr_copy((rimeaddr_t *)&longaddr, &rimeaddr_node_addr); printf("MAC %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x ", longaddr[0], longaddr[1], longaddr[2], longaddr[3], longaddr[4], longaddr[5], longaddr[6], longaddr[7]); cc2520_set_pan_addr(IEEE802154_PANID, shortaddr, longaddr); } cc2520_set_channel(RF_CHANNEL); printf(CONTIKI_VERSION_STRING " started. "); if(node_id > 0) { printf("Node id is set to %u.\n", node_id); } else { printf("Node id is not set.\n"); } #if WITH_UIP6 /* memcpy(&uip_lladdr.addr, ds2411_id, sizeof(uip_lladdr.addr)); */ memcpy(&uip_lladdr.addr, rimeaddr_node_addr.u8, UIP_LLADDR_LEN > RIMEADDR_SIZE ? RIMEADDR_SIZE : UIP_LLADDR_LEN); /* Setup nullmac-like MAC for 802.15.4 */ /* sicslowpan_init(sicslowmac_init(&cc2520_driver)); */ /* printf(" %s channel %u\n", sicslowmac_driver.name, RF_CHANNEL); */ /* Setup X-MAC for 802.15.4 */ queuebuf_init(); NETSTACK_RDC.init(); NETSTACK_MAC.init(); NETSTACK_NETWORK.init(); printf("%s %s, channel check rate %lu Hz, radio channel %u\n", NETSTACK_MAC.name, NETSTACK_RDC.name, CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0 ? 1: NETSTACK_RDC.channel_check_interval()), RF_CHANNEL); process_start(&tcpip_process, NULL); printf("Tentative link-local IPv6 address "); { uip_ds6_addr_t *lladdr; int i; lladdr = uip_ds6_get_link_local(-1); for(i = 0; i < 7; ++i) { printf("%02x%02x:", lladdr->ipaddr.u8[i * 2], lladdr->ipaddr.u8[i * 2 + 1]); } printf("%02x%02x\n", lladdr->ipaddr.u8[14], lladdr->ipaddr.u8[15]); } if(!UIP_CONF_IPV6_RPL) { uip_ipaddr_t ipaddr; int i; 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_TENTATIVE); printf("Tentative global IPv6 address "); for(i = 0; i < 7; ++i) { printf("%02x%02x:", ipaddr.u8[i * 2], ipaddr.u8[i * 2 + 1]); } printf("%02x%02x\n", ipaddr.u8[7 * 2], ipaddr.u8[7 * 2 + 1]); } #else /* WITH_UIP6 */ NETSTACK_RDC.init(); NETSTACK_MAC.init(); NETSTACK_NETWORK.init(); printf("%s %s, channel check rate %lu Hz, radio channel %u\n", NETSTACK_MAC.name, NETSTACK_RDC.name, CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0? 1: NETSTACK_RDC.channel_check_interval()), RF_CHANNEL); #endif /* WITH_UIP6 */ #if !WITH_UIP && !WITH_UIP6 uart1_set_input(serial_line_input_byte); serial_line_init(); #endif leds_off(LEDS_GREEN); #if TIMESYNCH_CONF_ENABLED timesynch_init(); timesynch_set_authority_level((rimeaddr_node_addr.u8[0] << 4) + 16); #endif /* TIMESYNCH_CONF_ENABLED */ #if WITH_UIP process_start(&tcpip_process, NULL); process_start(&uip_fw_process, NULL); /* Start IP output */ process_start(&slip_process, NULL); slip_set_input_callback(set_gateway); { uip_ipaddr_t hostaddr, netmask; uip_init(); uip_ipaddr(&hostaddr, 172,16, rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1]); uip_ipaddr(&netmask, 255,255,0,0); uip_ipaddr_copy(&meshif.ipaddr, &hostaddr); uip_sethostaddr(&hostaddr); uip_setnetmask(&netmask); uip_over_mesh_set_net(&hostaddr, &netmask); /* uip_fw_register(&slipif);*/ uip_over_mesh_set_gateway_netif(&slipif); uip_fw_default(&meshif); uip_over_mesh_init(UIP_OVER_MESH_CHANNEL); printf("uIP started with IP address %d.%d.%d.%d\n", uip_ipaddr_to_quad(&hostaddr)); } #endif /* WITH_UIP */ energest_init(); ENERGEST_ON(ENERGEST_TYPE_CPU); watchdog_start(); /* Stop the watchdog */ watchdog_stop(); #if !PROCESS_CONF_NO_PROCESS_NAMES print_processes(autostart_processes); #else /* !PROCESS_CONF_NO_PROCESS_NAMES */ putchar('\n'); /* include putchar() */ #endif /* !PROCESS_CONF_NO_PROCESS_NAMES */ autostart_start(autostart_processes); /* * This is the scheduler loop. */ while(1) { int r; do { /* Reset watchdog. */ watchdog_periodic(); r = process_run(); } while(r > 0); /* * Idle processing. */ int s = splhigh(); /* Disable interrupts. */ /* uart1_active is for avoiding LPM3 when still sending or receiving */ if(process_nevents() != 0 || uart1_active()) { splx(s); /* Re-enable interrupts. */ } else { static unsigned long irq_energest = 0; /* Re-enable interrupts and go to sleep atomically. */ ENERGEST_OFF(ENERGEST_TYPE_CPU); ENERGEST_ON(ENERGEST_TYPE_LPM); /* We only want to measure the processing done in IRQs when we are asleep, so we discard the processing time done when we were awake. */ energest_type_set(ENERGEST_TYPE_IRQ, irq_energest); watchdog_stop(); _BIS_SR(GIE | SCG0 | SCG1 | CPUOFF); /* LPM3 sleep. This statement will block until the CPU is woken up by an interrupt that sets the wake up flag. */ /* We get the current processing time for interrupts that was done during the LPM and store it for next time around. */ dint(); irq_energest = energest_type_time(ENERGEST_TYPE_IRQ); eint(); watchdog_start(); ENERGEST_OFF(ENERGEST_TYPE_LPM); ENERGEST_ON(ENERGEST_TYPE_CPU); } } }
/*--------------------------------------------------------------------------*/ int main(int argc, char **argv) { /* * Initalize hardware. */ msp430_cpu_init(); clock_init(); uart_init(9600); /* Must come before first printf */ /* xmem_init(); */ PRINTF("iWatch 0.10 build at " __TIME__ " " __DATE__ "\n"); UCSCTL8 &= ~BIT2; /* * Hardware initialization done! */ /* * Initialize Contiki and our processes. */ process_init(); process_start(&etimer_process, NULL); rtimer_init(); ctimer_init(); energest_init(); ENERGEST_ON(ENERGEST_TYPE_CPU); backlight_init(); battery_init(); SPI_FLASH_Init(); if (system_testing()) { clock_time_t t; backlight_on(200, 0); t = clock_seconds(); // sleep 1 while(clock_seconds() - t <= 3); printf("$$OK BACKLIGHT\n"); t = clock_seconds(); while(clock_seconds() - t <= 3); backlight_on(0, 0); motor_on(200, 0); // sleep 1s t = clock_seconds(); while(clock_seconds() - t <= 3); printf("$$OK MOTOR\n"); t = clock_seconds(); while(clock_seconds() - t <= 3); motor_on(0, 0); #if PRODUCT_W001 I2C_Init(); codec_init(); codec_bypass(1); // sleep 1s t = clock_seconds(); while(clock_seconds() - t <= 3); printf("$$OK MIC\n"); // sleep 1s t = clock_seconds(); while(clock_seconds() - t <= 3); codec_bypass(0); codec_shutdown(); #endif } int reason = CheckUpgrade(); window_init(reason); button_init(); rtc_init(); CFSFontWrapperLoad(); system_init(); // check system status and do factor reset if needed I2C_Init(); //codec_init(); //ant_init(); bluetooth_init(); #ifdef PRODUCT_W004 //bmx_init(); #else mpu6050_init(); #endif // check the button status if (button_snapshot() & (1 << BUTTON_UP)) { clock_time_t t; // delay 1 second // button up is pressed, we will set emerging flag motor_on(200, CLOCK_SECOND * 2); t = clock_seconds(); while(clock_seconds() - t <= 1); if (button_snapshot() & (1 << BUTTON_UP)) system_setemerging(); motor_on(0, 0); } if (!system_retail()) { bluetooth_discoverable(1); } #if PRODUCT_W001 if (system_testing()) ant_init(MODE_HRM); #endif system_restore(); // protocol_init(); // protocol_start(1); process_start(&system_process, NULL); /* * This is the scheduler loop. */ msp430_dco_required = 0; /* check firmware update */ if (reason == 0xff) { printf("Start Upgrade\n"); Upgrade(); // never return if sucessfully upgrade } watchdog_start(); while(1) { int r; do { /* Reset watchdog. */ watchdog_periodic(); r = process_run(); } while(r > 0); /* * Idle processing. */ int s = splhigh(); /* Disable interrupts. */ /* uart1_active is for avoiding LPM3 when still sending or receiving */ if(process_nevents() != 0) { splx(s); /* Re-enable interrupts. */ } else { static unsigned long irq_energest = 0; /* Re-enable interrupts and go to sleep atomically. */ ENERGEST_OFF(ENERGEST_TYPE_CPU); ENERGEST_ON(ENERGEST_TYPE_LPM); /* We only want to measure the processing done in IRQs when we are asleep, so we discard the processing time done when we were awake. */ energest_type_set(ENERGEST_TYPE_IRQ, irq_energest); watchdog_stop(); if (shutdown_mode) { system_shutdown(1); // never return LPM4; } if (msp430_dco_required) { __low_power_mode_0(); } else { __low_power_mode_3(); } /* We get the current processing time for interrupts that was done during the LPM and store it for next time around. */ __disable_interrupt(); irq_energest = energest_type_time(ENERGEST_TYPE_IRQ); __enable_interrupt(); watchdog_start(); ENERGEST_OFF(ENERGEST_TYPE_LPM); ENERGEST_ON(ENERGEST_TYPE_CPU); } } }