PROCESS_THREAD(flexibity_buzzer, ev, data) { PROCESS_BEGIN(); SENSORS_ACTIVATE(button_sensor); SENSORS_ACTIVATE(battery_sensor); /* PWM for buzzer */ pwm_init_stopped(TMR3, 1500, 10000); #ifdef WITH_COAP PRINTF("COAP Server\n"); #else PRINTF("HTTP Server\n"); #endif rest_init(); #if DEBUG rest_activate_resource(&resource_mem); #endif rest_activate_resource(&resource_buzzer); rest_activate_resource(&resource_pwr); rest_activate_resource(&resource_led); rest_activate_resource(&resource_button); rest_activate_resource(&resource_id); rest_activate_resource(&resource_discover); PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(shell_sense_process, ev, data) { struct sense_msg msg; PROCESS_BEGIN(); SENSORS_ACTIVATE(light_sensor); SENSORS_ACTIVATE(battery_sensor); SENSORS_ACTIVATE(sht11_sensor); msg.len = 7; 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 */ msg.light1 = light_sensor.value(LIGHT_SENSOR_PHOTOSYNTHETIC); msg.light2 = light_sensor.value(LIGHT_SENSOR_TOTAL_SOLAR); msg.temp = sht11_sensor.value(SHT11_SENSOR_TEMP); msg.humidity = sht11_sensor.value(SHT11_SENSOR_HUMIDITY); msg.rssi = do_rssi(); msg.voltage = battery_sensor.value(0); msg.rssi = do_rssi(); SENSORS_DEACTIVATE(light_sensor); SENSORS_DEACTIVATE(battery_sensor); SENSORS_DEACTIVATE(sht11_sensor); shell_output(&sense_command, &msg, sizeof(msg), "", 0); PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(web_sense_process, ev, data) { static struct etimer timer; PROCESS_BEGIN(); sensors_pos = 0; etimer_set(&timer, CLOCK_SECOND * 2); #if CONTIKI_TARGET_SKY SENSORS_ACTIVATE(light_sensor); SENSORS_ACTIVATE(sht11_sensor); #endif while(1) { PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&timer)); etimer_reset(&timer); #if CONTIKI_TARGET_SKY light1[sensors_pos] = get_light();; temperature[sensors_pos] = get_temp(); sensors_pos = (sensors_pos + 1) % HISTORY; #endif } PROCESS_END(); }
PROCESS_THREAD(default_app_process, ev, data) { PROCESS_BEGIN(); SENSORS_ACTIVATE(acc_sensor); SENSORS_ACTIVATE(gyro_sensor); SENSORS_ACTIVATE(pressure_sensor); etimer_set(&timer, CLOCK_SECOND * 0.05); while (1) { PROCESS_YIELD(); etimer_set(&timer, CLOCK_SECOND); printf("X_ACC=%d, Y_ACC=%d, Z_ACC=%d\n", acc_sensor.value(ACC_X), acc_sensor.value(ACC_Y), acc_sensor.value(ACC_Z)); printf("X_AS=%d, Y_AS=%d, Z_AS=%d\n", gyro_sensor.value(X_AS), gyro_sensor.value(Y_AS), gyro_sensor.value(Z_AS)); // printf("PRESS=%u, TEMP=%d\n\n", pressure_sensor.value(PRESS), pressure_sensor.value(TEMP)); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(test_button_process, ev, data) { /* static struct etimer et; */ PROCESS_BEGIN(); SENSORS_ACTIVATE(phidgets); SENSORS_ACTIVATE(button_sensor); while(1) { printf("Please press the User Button\n"); PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor); leds_toggle(LEDS_GREEN); printf("Phidget 5V 1:%d\n", phidgets.value(PHIDGET5V_1)); printf("Phidget 5V 2:%d\n", phidgets.value(PHIDGET5V_2)); printf("Phidget 3V 1:%d\n", phidgets.value(PHIDGET3V_1)); printf("Phidget 3V 2:%d\n", phidgets.value(PHIDGET3V_2)); if(phidgets.value(PHIDGET3V_1) < 100) { leds_on(LEDS_RED); } else { leds_off(LEDS_RED); } } PROCESS_END(); }
PROCESS_THREAD(udp_plug_process, ev, data) { static struct etimer et; PROCESS_BEGIN(); PRINTF("UDP server started\r\n"); #if DEV_BOARD leds_on(LEDS_RED | LEDS_GREEN); SENSORS_ACTIVATE(button_sensor); #else leds_on(LEDS_GREEN); #ifdef HAS_PIR_SENSOR pir_state = PIR_DISPATCH; etimer_set(&pir_timer, PIR_INIT_TIME); #endif #endif #if HAS_TEMP_SENSOR start_temp_conv(); #endif #if HAS_LIGHT_SENSOR light_sensor_init(); #endif udp_conn = udp_new(NULL, UIP_HTONS(0), NULL); udp_bind(udp_conn, UIP_HTONS(PLUG_PORT)); PRINTF("listening on udp port %u\r\n",UIP_HTONS(udp_conn->lport)); etimer_set(&et, SEND_INTERVAL); while(1) { PROCESS_YIELD(); if(etimer_expired(&et)) { timeout_handler(); etimer_restart(&et); } #ifdef HAS_PIR_SENSOR if((pir_state == PIR_DISPATCH)&&(etimer_expired(&pir_timer))) { SENSORS_ACTIVATE(button_sensor); pir_state = PIR_READY; } #endif if(ev == tcpip_event) { PRINTF("Calling tcpip_Handler\r\n"); tcpip_handler(); } if (ev == sensors_event && data == &button_sensor) { #ifndef DEV_BOARD handle_pir_event(); #endif PRINTF("Button Pressed\r\n"); } } PROCESS_END(); }
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(http_example_process, ev, data) { static struct etimer et; PROCESS_BEGIN(); SENSORS_ACTIVATE(sht25); ubidots_init(&http_example_process, headers); while(1) { PROCESS_YIELD(); if(ev == ubidots_event_established || (ev == PROCESS_EVENT_TIMER && data == &et)) { leds_on(LEDS_GREEN); post_collection(); } else if(ev == ubidots_event_post_sent) { leds_off(LEDS_GREEN); etimer_set(&et, POST_PERIOD); } // else if(ev == ubidots_event_post_reply_received) { // print_reply((ubidots_reply_part_t *)data); // } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(acc_process, ev, data) { static struct etimer etimer; PROCESS_BEGIN(); printf("Starting measuring acceleration\r\n"); boardPrintStringDescription(); SENSORS_ACTIVATE(acc_sensor); // Enable High Range. //acc_sensor.configure(ACC_RANGE, ACC_HIGH_RANGE); // Enable High Pass Filter. //acc_sensor.configure(ACC_HPF, ACC_1HZ); while(1) { etimer_set(&etimer, CLOCK_SECOND/2); PROCESS_WAIT_UNTIL(etimer_expired(&etimer)); printf("(X,Y,Z): (%d,%d,%d) mg \r",acc_sensor.value(ACC_X_AXIS),acc_sensor.value(ACC_Y_AXIS),acc_sensor.value(ACC_Z_AXIS)); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(udp_server_process, ev, data) { // uint16_t ipaddr=(uint16_t) IP_TRANS128; //#if UIP_CONF_ROUTER uip_ipaddr_t ipaddr;//=IP_TRANS128; uip_ip6addr(&ipaddr,0xfe80,0,0,0,0x2001,0x22ff,0xfe33,0x4455); //#endif /* UIP_CONF_ROUTER */ PROCESS_BEGIN(); SENSORS_ACTIVATE(button_sensor);//activate button leds_init(); leds_off(LEDS_ALL); simple_udp_register(&udp_connection, UDP_PORT, NULL, UDP_PORT, receiver); while(1) { // printf("bla1"); PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor); // PROCESS_YIELD(); send_data(&ipaddr); } PROCESS_END(); }
PROCESS_THREAD(knot_controller_process, ev, data) { static struct etimer clean; PROCESS_BEGIN(); SENSORS_ACTIVATE(button_sensor); etimer_set(&clean,TIMER_INTERVAL); while (1){ PROCESS_WAIT_EVENT(); if (ev == tcpip_event && uip_newdata()) { network_handler(ev, data); } else if ((ev == PROCESS_EVENT_TIMER)){ if (data == &clean) { cleaner(); etimer_set(&clean,TIMER_INTERVAL); } } else if (ev == KNOT_EVENT_CONNECT){ create_channel((ServiceRecord *)data); } else if(ev == KNOT_EVENT_COMMAND){ send_actuator_command(*((int *)data)); } } PROCESS_END(); }
/* Light sensor */ static void config_light() { light_sensor.configure(LIGHT_SENSOR_SOURCE, ISL29020_LIGHT__AMBIENT); light_sensor.configure(LIGHT_SENSOR_RESOLUTION, ISL29020_RESOLUTION__16bit); light_sensor.configure(LIGHT_SENSOR_RANGE, ISL29020_RANGE__1000lux); SENSORS_ACTIVATE(light_sensor); }
static void config_gyr() { gyr_sensor.configure(GYR_SENSOR_DATARATE, L3G4200D_800HZ); gyr_freq = 800; gyr_sensor.configure(GYR_SENSOR_SCALE, L3G4200D_250DPS); SENSORS_ACTIVATE(gyr_sensor); }
PROCESS_THREAD(rest_server_example, ev, data) { PROCESS_BEGIN(); PRINTF("Starting Erbium Example Server\n"); PRINTF("uIP buffer: %u\n", UIP_BUFSIZE); PRINTF("LL header: %u\n", UIP_LLH_LEN); PRINTF("IP+UDP header: %u\n", UIP_IPUDPH_LEN); PRINTF("REST max chunk: %u\n", REST_MAX_CHUNK_SIZE); /* if static routes are used rather than RPL */ #if !UIP_CONF_IPV6_RPL && !defined (CONTIKI_TARGET_MINIMAL_NET) && !defined (CONTIKI_TARGET_NATIVE) set_global_address(); configure_routing(); #endif /* Initialize the OSD Hardware. */ hw_init(); /* Initialize the REST engine. */ rest_init_engine(); /* Activate the application-specific resources. */ rest_activate_resource(&resource_info); SENSORS_ACTIVATE(t4_servo_sensor); rest_activate_resource(&resource_t4_servo); /* Define application-specific events here. */ while(1) { PROCESS_WAIT_EVENT(); } PROCESS_END(); }
PROCESS_THREAD(temp_sensor_process, ev, data) { PROCESS_BEGIN(); static struct etimer et; static uint64_t temperature; static uint64_t val; printf("starting Sensor Example\n"); while(1) { etimer_set(&et,CLOCK_SECOND*3); SENSORS_ACTIVATE(temp_sensor); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); temperature = (temp_sensor.value(TEMP_SENSOR)); printf("temperature is %lu\n",temperature); etimer_reset(&et); SENSORS_DEACTIVATE(temp_sensor); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(remote_relay_process, ev, data) { PROCESS_BEGIN(); SENSORS_ACTIVATE(relay); /* Activate the relay and wait for 5 seconds */ relay.value(RELAY_ON); etimer_set(&et, CLOCK_SECOND * 5); printf("\nRelay: switch should be ON --> %u\n", relay.status(SENSORS_ACTIVE)); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); /* Now turn off and wait 5 seconds more */ relay.value(RELAY_OFF); etimer_set(&et, CLOCK_SECOND * 5); printf("Relay: switch should be OFF --> %u\n\n", relay.status(SENSORS_ACTIVE)); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); /* Let it spin and toggle each second */ while(1) { etimer_set(&et, CLOCK_SECOND); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); relay.value(RELAY_TOGGLE); printf("Relay: switch is now --> %u\n", relay.status(SENSORS_ACTIVE)); } PROCESS_END(); }
void sensorsPowerUp(){ button_sensor.configure(SENSORS_HW_INIT, 0); temperature_sensor.configure(SENSORS_HW_INIT, 0); acc_sensor.configure(SENSORS_HW_INIT, 0); if(sensors_status & BUTTON_STATUS_ACTIVE){ SENSORS_ACTIVATE(button_sensor); } if(sensors_status & TEMP_STATUS_ACTIVE){ SENSORS_ACTIVATE(temperature_sensor); } if(sensors_status & ACC_STATUS_ACTIVE){ SENSORS_ACTIVATE(acc_sensor); } }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(sky_shell_process, ev, data) { PROCESS_BEGIN(); serial_shell_init(); shell_blink_init(); shell_file_init(); shell_coffee_init(); shell_ps_init(); shell_reboot_init(); shell_rime_init(); /* shell_rime_debug_init();*/ shell_rime_netcmd_init(); /* shell_rime_ping_init(); */ shell_rime_neighbors_init(); shell_rime_sendcmd_init(); /* shell_rime_sniff_init();*/ shell_rime_unicast_init(); /*shell_sky_init();*/ shell_text_init(); shell_time_init(); SENSORS_ACTIVATE(acc_sensor); shell_register_command(&acc_command); shell_register_command(&poke_command); shell_register_command(&peek_command); shell_register_command(&leds_command); PROCESS_END(); }
PROCESS_THREAD(rest_server_example, ev, data) { PROCESS_BEGIN(); #ifdef WITH_COAP PRINTF("COAP Server\n"); #else PRINTF("HTTP Server\n"); #endif rest_init(); #if defined (PLATFORM_HAS_LIGHT) SENSORS_ACTIVATE(light_sensor); rest_activate_resource(&resource_light); #endif #if defined (PLATFORM_HAS_LEDS) rest_activate_resource(&resource_led); rest_activate_resource(&resource_toggle); #endif /*defined (PLATFORM_HAS_LEDS)*/ rest_activate_resource(&resource_helloworld); rest_activate_resource(&resource_discover); PROCESS_END(); }
PROCESS_THREAD(sniffer_process, ev, data) { static struct etimer et; leds_off(LEDS_ALL); /* turn off LEDs */ SENSORS_ACTIVATE(button_sensor); /* turn on button sensor */ PROCESS_EXITHANDLER(broadcast_close(&bc)); PROCESS_BEGIN(); broadcast_open(&bc, SNIFFER_CHANNEL, &broadcast_call); process_start(&wait_process, NULL); /* Start wait process. This will end the main process when a button sensor event is posted */ while(1) /* Infinite loop */ { etimer_set(&et, CLOCK_SECOND * 2 * PERIOD); /* Wait 4 seconds per loop for a receive event */ PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); #if DEBUG printf("Loop\n"); #endif } SENSORS_DEACTIVATE(button_sensor); /* Deactivate sensor when we're done */ PROCESS_END(); }
/* init and react on button press */ PROCESS_THREAD(button_process, ev, data) { PROCESS_BEGIN(); SENSORS_ACTIVATE(button_sensor); shell_sdr_init(); broadcast_open(&broadcast_connection, 129, &broadcast_callback); process_start(&spam_process, NULL); static int dummy = 0; while(1) { leds_off(LEDS_ALL); // wait for button press PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor); packetbuf_copyfrom(&dummy, sizeof(int)); broadcast_send(&broadcast_connection); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(remote_bmp085_process, ev, data) { PROCESS_BEGIN(); static uint16_t pressure; static int16_t temperature; /* Use Contiki's sensor macro to enable the sensor */ SENSORS_ACTIVATE(bmp085); /* And periodically poll the sensor */ while(1) { etimer_set(&et, SENSOR_READ_INTERVAL); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); pressure = bmp085.value(BMP085_READ_PRESSURE); temperature = bmp085.value(BMP085_READ_TEMP); if((pressure != BMP085_ERROR) && (temperature != BMP085_ERROR)) { printf("Pressure = %u.%u(hPa), ", pressure / 10, pressure % 10); printf("Temperature = %d.%u(ºC)\n", temperature / 10, temperature % 10); } else { printf("Error, enable the DEBUG flag in the BMP085 driver for info, "); printf("or check if the sensor is properly connected\n"); PROCESS_EXIT(); } } PROCESS_END(); }
static void config_mag() { mag_sensor.configure(ACC_MAG_SENSOR_DATARATE, LSM303DLHC_MAG_RATE_220HZ); mag_freq = 220; mag_sensor.configure(ACC_MAG_SENSOR_SCALE, LSM303DLHC_MAG_SCALE_1_3GAUSS); mag_sensor.configure(ACC_MAG_SENSOR_MODE, LSM303DLHC_MAG_MODE_CONTINUOUS); SENSORS_ACTIVATE(mag_sensor); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(borderest_process, ev, data) { static struct etimer et; PROCESS_BEGIN(); /* While waiting for the prefix to be sent through the SLIP connection, the future * border router can join an existing DAG as a parent or child, or acquire a default * router that will later take precedence over the SLIP fallback interface. * Prevent that by turning the radio off until we are initialized as a DAG root. */ prefix_set = 0; NETSTACK_MAC.off(0); PROCESS_PAUSE(); SENSORS_ACTIVATE(button_sensor); PRINTF("RPL-Border router started\n"); #if 0 /* The border router runs with a 100% duty cycle in order to ensure high packet reception rates. Note if the MAC RDC is not turned off now, aggressive power management of the cpu will interfere with establishing the SLIP connection */ NETSTACK_MAC.off(1); #endif /* Request prefix until it has been received */ while(!prefix_set) { etimer_set(&et, CLOCK_SECOND); request_prefix(); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); } /* Now turn the radio on, but disable radio duty cycling. * Since we are the DAG root, reception delays would constrain mesh throughbut. */ NETSTACK_MAC.off(1); #if DEBUG || 1 print_local_addresses(); #endif rest_init_engine(); activate_coap_resources(); leds_init(); while(1) { PROCESS_YIELD(); if (ev == sensors_event && data == &button_sensor) { PRINTF("Initiating global repair\n"); rpl_repair_root(RPL_DEFAULT_INSTANCE); leds_toggle(LEDS_ALL); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(node_process, ev, data) { static struct etimer et; PROCESS_BEGIN(); /* 3 possible roles: * - role_6ln: simple node, will join any network, secured or not * - role_6dg: DAG root, will advertise (unsecured) beacons * */ static int is_coordinator = 0; static enum { role_6ln, role_6dr } node_role; node_role = role_6ln; #if CONFIG_VIA_BUTTON { #define CONFIG_WAIT_TIME 10 SENSORS_ACTIVATE(button_sensor); etimer_set(&et, CLOCK_SECOND * CONFIG_WAIT_TIME); while(!etimer_expired(&et)) { printf("Init: current role: %s. Will start in %u seconds.\n", node_role == role_6ln ? "6ln" : "6dr", CONFIG_WAIT_TIME); PROCESS_WAIT_EVENT_UNTIL(((ev == sensors_event) && (data == &button_sensor) && button_sensor.value(0) > 0) || etimer_expired(&et)); if(ev == sensors_event && data == &button_sensor && button_sensor.value(0) > 0) { node_role = (node_role + 1) % 2; etimer_restart(&et); } } } #endif /* CONFIG_VIA_BUTTON */ printf("Init: node starting with role %s\n", node_role == role_6ln ? "6ln" : "6dr"); is_coordinator = node_role > role_6ln; if(is_coordinator) { uip_ipaddr_t prefix; uip_ip6addr(&prefix, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); rpl_tools_init(&prefix); } else { rpl_tools_init(NULL); } /* Print out routing tables every minute */ etimer_set(&et, CLOCK_SECOND * 60); while(1) { print_network_status(); PROCESS_YIELD_UNTIL(etimer_expired(&et)); etimer_reset(&et); } PROCESS_END(); }
static void config_acc() { acc_sensor.configure(ACC_MAG_SENSOR_DATARATE, LSM303DLHC_ACC_RATE_1344HZ_N_5376HZ_LP); acc_freq = 1344; acc_sensor.configure(ACC_MAG_SENSOR_SCALE, LSM303DLHC_ACC_SCALE_2G); acc_sensor.configure(ACC_MAG_SENSOR_MODE, LSM303DLHC_ACC_UPDATE_ON_READ); SENSORS_ACTIVATE(acc_sensor); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(border_router_process, ev, data) { #ifdef PREFIX_DISC static struct etimer et; #endif rpl_dag_t *dag; PROCESS_BEGIN(); prefix_set = 0; PROCESS_PAUSE(); SENSORS_ACTIVATE(button_sensor); PRINTF("RPL-Border router started\n"); /* The border router runs with a 100% duty cycle in order to ensure high packet reception rates. Note if the MAC RDC is not turned off now, aggressive power management of the cpu will interfere with establishing the SLIP connection */ NETSTACK_MAC.off(1); #ifndef PREFIX_DISC if (!uiplib_ipaddrconv("aaaa::", &prefix)) goto err; #else /* Request prefix until it has been received */ while(!prefix_set) { etimer_set(&et, CLOCK_SECOND); request_prefix(); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); } #endif dag = rpl_set_root(RPL_DEFAULT_INSTANCE,(uip_ip6addr_t *)dag_id); if(dag != NULL) { rpl_set_prefix(dag, &prefix, 64); PRINTF("created a new RPL dag\n"); } #if DEBUG || 1 print_local_addresses(); #endif while(1) { PROCESS_YIELD(); if (ev == sensors_event && data == &button_sensor) { PRINTF("Initiating global repair\n"); rpl_repair_root(RPL_DEFAULT_INSTANCE); } } err: PRINTF("Shutting down\n"); PROCESS_END(); }
/*---------------------------------------------------------------------------*/ 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); //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, Luminaire Illuminance: %d", button_number, (int)(410 )); simple_udp_sendto(&unicast_connection, buf, strlen(buf) + 1, addr); } else { printf("Service %d not found\n", SERVICE_ID); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(udp_server_process, ev, data) { uip_ipaddr_t ipaddr; struct uip_ds6_addr *root_if; PROCESS_BEGIN(); PROCESS_PAUSE(); SENSORS_ACTIVATE(button_sensor); PRINTF("UDP server started\n"); #if UIP_CONF_ROUTER uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 1); /* uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); */ uip_ds6_addr_add(&ipaddr, 0, ADDR_MANUAL); root_if = uip_ds6_addr_lookup(&ipaddr); if(root_if != NULL) { rpl_dag_t *dag; rpl_set_root((uip_ip6addr_t *)&ipaddr); dag = rpl_get_dag(RPL_ANY_INSTANCE); uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); rpl_set_prefix(dag, &ipaddr, 64); PRINTF("created a new RPL dag\n"); } else { PRINTF("failed to create a new RPL DAG\n"); } #endif /* UIP_CONF_ROUTER */ print_local_addresses(); /* The data sink runs with a 100% duty cycle in order to ensure high packet reception rates. */ NETSTACK_RDC.off(1); server_conn = udp_new(NULL, UIP_HTONS(UDP_CLIENT_PORT), NULL); udp_bind(server_conn, UIP_HTONS(UDP_SERVER_PORT)); PRINTF("Created a server connection with remote address "); PRINT6ADDR(&server_conn->ripaddr); PRINTF(" local/remote port %u/%u\n", UIP_HTONS(server_conn->lport), UIP_HTONS(server_conn->rport)); while(1) { PROCESS_YIELD(); if(ev == tcpip_event) { tcpip_handler(); } else if (ev == sensors_event && data == &button_sensor) { PRINTF("Initiaing global repair\n"); rpl_repair_dag(rpl_get_dag(RPL_ANY_INSTANCE)); } } PROCESS_END(); }
/*----------------------------------------------------------------------------*/ PROCESS_THREAD(tres_process, ev, data) { PROCESS_BEGIN(); srand(node_id); rest_init_engine(); tres_init(); SENSORS_ACTIVATE(light_sensor); rest_activate_periodic_resource(&periodic_resource_light); rplinfo_activate_resources(); static coap_packet_t request[1]; /* This way the packet can be treated as pointer as usual. */ SERVER_NODE(&server_ipaddr); /* receives all CoAP messages */ coap_receiver_init(); int wait_time = getRandUint(MAX_WAITING); int base_wait = BASE_WAITING; static int g_time=0; static char content[12]; etimer_set(&et, (wait_time + base_wait) * CLOCK_SECOND); while(1) { PROCESS_YIELD(); if (etimer_expired(&et)) break; } etimer_reset(&et); etimer_set(&et, TOGGLE_INTERVAL * CLOCK_SECOND); while(1) { PROCESS_YIELD(); if (etimer_expired(&et)) { coap_init_message(request, COAP_TYPE_NON, COAP_POST, 0 ); coap_set_header_uri_path(request, service_urls[1]); coap_set_payload(request, content, snprintf(content, sizeof(content), "%d", g_time++)); coap_transaction_t *transaction; request->mid = coap_get_mid(); if ((transaction = coap_new_transaction(request->mid, &server_ipaddr, REMOTE_PORT))) { transaction->packet_len = coap_serialize_message(request, transaction->packet); coap_send_transaction(transaction); } etimer_reset(&et); } } /* while (1) */ PROCESS_END(); }