IoT OSes: Contiki-NG Part 1. Luca Mottola

Transcription

1 IoT OSes: Contiki-NG Part 1 Luca Mottola luca.mottola@polimi.it

2 Road-map Goals: Acquire concepts Immediately put them in practice Our target platform is Contiki-NG We use Contiki-NG as an opportunity to study how given concepts play out in practice Both using simulations and real hardware!

3 Contiki-NG Fork of original Contiki Focuses on RFC-compliant IPv6 networking Modern 32-bit platforms while keeping compatibility with a few 16-bit older ones Mature: almost 15 years of development up to now (including original Contiki) Key features: Configurability, ease of porting to new platforms Efficient, configurable IPv6-based networking Event-driven kernel, protothread concurrency model atop Small memory footprint Used both in academia and industry

4 Concurrency

5 Existing Models: Multi-thread Similar to multi-threading in C/C++ A subset of traditional synchronization primitives available Not many embedded OSes provide it RIoT, Contiki through external library, Pros: Familiar to programmers Facilitates porting non-embedded code Cons: Heavy on memory: each thread requires its own stack Difficult to tune: hard to anticipate every thread s max stack size

6 Existing Models: Event-driven Non-blocking calls and (possibly asynchronous) callbacks Provided by many ARM mbed, Contiki, Zephyr, Apache MyNewt Pros: Facilitates implementing reactive code Memory-efficient: only one stack Cons: Difficult to program: code as state machines, no sequential semantics

7 Event-driven: Example // Sensor interface: sensor.h void sensor_read(void (*callback)(error_t, val_t)); #include sensor.h void my_sensor_read_done(error_t err, val_t value) { // if ((err == OK) { do_something(value); void foo() { // do something sensor_read(&my_sensor_read_done); // do something more Calls sensor_read() The corresponding sensor.c is provided by sensor-specific implementations Application Sensor Calls (*callback)() If callbacks are asynchronous, the execution is preempted unless in an atomic block

8 Existing Models: Protothreads Best of both worlds Maintain sequential semantics with a single stack Provided in Contiki and Contiki-NG #include "contiki.h" #include <stdio.h> PROCESS(test_proc, "Test process"); AUTOSTART_PROCESSES(&test_proc); PROCESS_THREAD(test_proc, ev, data) { PROCESS_BEGIN(); printf("hello, world!\n"); PROCESS_END(); We will see later where displayed

9 Protothreads: Handling Events Protothreads process incoming events A timer expiring, a packet received They are scheduled cooperatively Individual protothreads decide when to release the MCU PROCESS_THREAD(test, ev, data) { static struct etimer et; PROCESS_BEGIN(); etimer_set(&et, CLOCK_SECOND); /* Trigger a 1s timer */ for(;;) { PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); printf("hello, world!\n");= etimer_set(&et, CLOCK_SECOND); PROCESS_END(); Set a new timer, triggering the next event for this protothread Every time the protothread resumes, this condition is checked

10

11 Exercise Add a counter to hello-world-events so that the timer stops when it reaches a threshold

12 Protothreads: Implementation Uses local continuations as result of macro expansion When set, allow one to tag specific places in the code When resumed, allow the execution to restart from within the code Use of macros spares the need for a dedicated preprocessor

13 Protothreads: Implementation PROCESS_THREAD(test, ev, data) { static struct etimer et; PROCESS_BEGIN(); etimer_set(&et, CLOCK_SECOND); for(;;) { PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); printf("hello, world!\n");= etimer_set(&et, CLOCK_SECOND); PROCESS_END(); static char test (struct pt* pt, event_t ev, void* data) { static struct etimer et; switch(pt->lc) { case 0: etimer_set(&et, CLOCK_SECOND); for(;;) { pt->lc = 15; case 15: if (!(etimer_expired(&et)) { return 0; printf("hello, world!\n"); etimer_set(&et, CLOCK_SECOND) pt->lc = 0; return 2; What really happens when resuming: The protothread function is called again, and starts over A switch statement reads the value of pt->lc The execution jumps to the case: corresponding to where the execution yielded Therefore, local variables need to be static, or they get re-initialized every time the protothread resumes No free lunches: they consume memory also when the protothread is not executing! Do not use switch inside protothreads, or you will mess things up

14 Protothreads: APIs PROCESS_PAUSE(): releases control, rescheduled immediately PROCESS_YIELD(): releases control, wait for next event process_poll(&process_name): polls another protothread PROCESS_EXIT(): stops a protothread process_exit(&process_name): kills another protothread

15 Contiki-NG Timers timer: require to manually check if timers have expired etimer: generates events when timers expire, useful with protothreads stimer: like etimer for longer periods ctimer: allows one to schedule function executions in time rtimer: preempts currently running functions with given callbacks As a result, provides predictable timer semantics

16 Networking

17 Routing: RPL (1) Creates a tree-shaped topology rooted at the node with direct Internet access Destination-Oriented Directed Acyclic Graph (DODAG) Naturally supports many-to-one communication Packets called DODAG Information Objects (DIO) disseminated downwards from the root Carry information on what objective function to use to select the parent in the tree Every node has a preferred parent and might have multiple backup parents

18 Routing: RPL (2) Objective functions in Contiki-NG OF0: looks for a good-enough potential parent and a back-up one; simple but might be inefficient and yield unstable routes MRHOF: looks for the minimum rank among potential parents and applies histerisis to avoid flipping between parents; more efficient provided good connectivity

19 Routing: RPL (3) To support one-to-many and one-toone communication, every node advertises itself upwards with Destination Advertisement Objects (DAO) In storing mode, every intermediate node builds local routes for downstream nodes Allows routes to shortcut paths at the first common parent Might be heavy on memory In non-storing mode, only the root stores downstream routes Point-to-point routes necessarily stretch up to the route The root typically has memory

20 UDP over RPL: API struct simple_udp_connection { struct simple_udp_connection *next; uip_ipaddr_t remote_addr; uint16_t remote_port, local_port; simple_udp_callback receive_callback; struct uip_udp_conn *udp_conn; struct process *client_process; ; Represents a UDP connection Executed for incoming packets typedef void (* simple_udp_callback) (struct simple_udp_connection *c, const uip_ipaddr_t *source_addr, uint16_t source_port, const uip_ipaddr_t *dest_addr, uint16_t dest_port, const uint8_t *data, uint16_t datalen); Receive callback signature

21 UDP over RPL: API Initializes UDP layer void simple_udp_init(void); Setup a UDP connection int simple_udp_register(struct simple_udp_connection *c, uint16_t local_port, uip_ipaddr_t *remote_addr, uint16_t remote_port, simple_udp_callback receive_callback); int simple_udp_sendto(struct simple_udp_connection *c, const void *data, uint16_t datalen, const uip_ipaddr_t *to); Send a packet to a specific destination, if the UDP connection is setup with NULL as remote-addr

22 UDP over RPL: Example No remote address simple_udp_register(&udp_conn, UDP_CLIENT_PORT, NULL, UDP_SERVER_PORT, udp_rx_callback); etimer_set(&periodic_timer, random_rand() % SEND_INTERVAL); while(1) { PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&periodic_timer)); if(rpl_is_reachable()) { rpl_dag_t *dag = rpl_get_any_dag(); if(dag!= NULL) { /* Only a sanity check. */ LOG_INFO("Sending request %u to ", count); LOG_INFO_6ADDR(&dag->dag_id); LOG_INFO_("\n"); simple_udp_sendto(&udp_conn, &count, sizeof(count), &dag->dag_id); count++; else { LOG_INFO("Not reachable yet %p\n", rpl_get_any_dag()); Send to the DODAG root Send the value of count

23

24 Exercise Modify udp-server and udp-client so that two nodes ping-pong for a certain number of times If a packet is lost, one of the two restarts from scratch

25 Homework Check on the Contiki wiki: Build system: Logging system: