Architectures and Applications for Wireless Sensor Networks ( ) Node Programming

Size: px

Start display at page:

Download "Architectures and Applications for Wireless Sensor Networks ( ) Node Programming"

Colin Garrett
5 years ago
Views:

1 Architectures and Applications for Wireless Sensor Networks ( ) Node Programming Chaiporn Jaikaeo Department of Computer Engineering Kasetsart University

2 Outline Microcontroller programming Software development cycle Hardware abstraction Event-driven programming model Multithreaded programming model 2

3 Tmote Sky 3

4 Typical Development Process For microcontrollers with bootstrap loader (BSL) installed Source code (C/Assembly) Cross Compiler/Assembler Microcontroller flash memory Machine code Serial/USB Bootstrap Loader 4

5 Build a Simple Application Let's build a simple application Make mote output something What can be used as output? 5

6 Tmote Sky's Schematic Available on LMS 6

7 Example: Blinking Sky LED Task: turn the blue LED on/off repeatedly Idea Configure pin P5.6 for output Repeatedly set the pin logic level to 0 and 1 Add some delay before toggling pin level 7

8 Directory Structure Create a new folder sky-apps sky-apps blink.c Makefile 8

9 Code blink.c #include <msp430x16x.h> blink.c int main() Stop watchdog timer WDTCTL = WDTPW WDTHOLD; P5DIR = (1 << 6); for (;;) Make P5.6 output P5OUT = (1 << 6); Send logic 1 to P5.6 delay_cycles(500000l); P5OUT &= ~(1 << 6); Send logic 0 to P5.6 delay_cycles(500000l); return 0; 9

10 Compiling Make an ELF binary by running cross compiler $ msp430-gcc -mmcu=msp430f1611 -o blink.elf blink.c Extract machine code into ihex format $ msp430-objcopy --output-target=ihex blink.elf blink.hex 10

11 Uploading Machine Code Plug a Sky mote into a USB port and make sure it is recognized by the OS $ <contiki-dir>/tools/sky/mote-list-<os> Send the machine code to BSL $ <contiki-dir>/tools/sky/msp430-bsl-linux --telosb \ -c <serial-device> -r e I p blink.hex 11

12 Creating Makefile Makefile helps avoid repetitive typing CC=msp430-gcc CFLAGS=-mmcu=msp430f1611 OBJCOPY=msp430-objcopy CONTIKI=$(HOME)/src/contiki-dev PROJECT=blink Makefile all: $(PROJECT).hex upload: $(PROJECT).hex $(CONTIKI)/tools/sky/msp430-bsl-linux --telosb -c $(DEVICE) -r -e -I -p $< %.hex: %.elf $(OBJCOPY) --output-target=ihex $< %.elf: %.c $(CC) $(CFLAGS) -o $< Run make upload DEVICE=<serial-device> 12

13 Exercise: Blue Beacon Modify blink.c so that it repeatedly turns Blue LED on for ~0.1 second turns Blue LED off for ~1 second 13

14 Blink in Another Platform E.g., AVR microcontroller #include <avr/io.h> #include <util/delay.h> int main() DDRD = (1 << 5); // Make PD5 output while (1) PORTD = (1 << 5); // Send logic 1 to PD5 _delay_ms(1000); PORTD &= ~(1 << 5); // Send logic 0 to PD5 _delay_ms(1000); return 0; 14

15 Hardware Abstraction Tmote Sky API Implementation Tmote Sky Hardware 15

16 Contiki Directory Structure Create a new folder contiki-app contiki-apps blink.c Makefile 16

17 Blink with Contiki #include "contiki.h" #include "dev/leds.h" blink.c /* */ PROCESS(blink_process, "Blink Application"); AUTOSTART_PROCESSES(&blink_process); /* */ PROCESS_THREAD(blink_process, ev, data) PROCESS_BEGIN(); watchdog_stop(); for (;;) leds_off(leds_blue); clock_wait(clock_second/2); leds_on(leds_blue); clock_wait(clock_second/2); PROCESS_END(); 17

18 Contiki Makefile Makefile CONTIKI_WITH_RIME = 1 CONTIKI = <your-contiki-location> include $(CONTIKI)/Makefile.include Make sky the default platform $ make TARGET=sky savetarget Build and upload the application $ make blink.upload 18

19 Exercise: Contiki Blue Beacon Create a new app beacon.c that repeatedly turns Blue LED on for ~0.1 second turns Blue LED off for ~1 second 19

20 Event-Driven Programming Model Most WSN OS frameworks provide eventbased programming environment Boot event handler Idle loop Sensor event handler Timer event handler Radio event handler Handled by Kernel Handled by developer 20

21 Blink Event-Driven Version #include "contiki.h" #include "dev/leds.h" blink-evt.c /* */ PROCESS(blink_process, "Blink Application"); AUTOSTART_PROCESSES(&blink_process); /* */ static struct ctimer timer; static void callback(void *ptr) leds_toggle(leds_blue); ctimer_reset(&timer); PROCESS_THREAD(blink_process, ev, data) PROCESS_BEGIN(); ctimer_set(&timer, CLOCK_SECOND/2, callback, NULL); PROCESS_END(); 21

22 Exercise: Event-Based Beacon Create a new event-based app beacon-event.c that repeatedly turns Blue LED on for ~0.1 second turns Blue LED off for ~1 second 22

23 Exercise: Double Beacons Write a new Contiki application that turns Blue LED on for 0.1 second and off for 1 second And at the same time, turns Red LED on for 0.1 second and off for 0.75 second First, try it with the event-based model Name it double-beacons-event.c 23

24 Double Beacons Event-Based Process and variable declarations #include "contiki.h" #include "dev/leds.h" double-beacons-evt.c /* */ PROCESS(double_beacon_process, "Double Beacons Application"); AUTOSTART_PROCESSES(&double_beacon_process); /* */ enum STATE_ON, STATE_OFF ; int state_blue, state_red; static struct ctimer timer_blue, timer_red; 24

25 Double Beacons Event-Based Blue's callback static void callback_blue(void *ptr) double-beacons-evt.c if (state_blue == STATE_ON) leds_off(leds_blue); state_blue = STATE_OFF; ctimer_set(&timer_blue, CLOCK_SECOND, callback_blue, NULL); else if (state_blue == STATE_OFF) leds_on(leds_blue); state_blue = STATE_ON; ctimer_set(&timer_blue, CLOCK_SECOND*0.1, callback_blue, NULL); 25

26 Double Beacons Event-Based Red's callback static void callback_red(void *ptr) double-beacons-evt.c if (state_red == STATE_ON) leds_off(leds_red); state_red = STATE_OFF; ctimer_set(&timer_red, CLOCK_SECOND*0.75, callback_red, NULL); else if (state_red == STATE_OFF) leds_on(leds_red); state_red = STATE_ON; ctimer_set(&timer_red, CLOCK_SECOND*0.1, callback_red, NULL); 26

27 Double Beacons Event-Based Main process PROCESS_THREAD(double_beacon_process, ev, data) PROCESS_BEGIN(); double-beacons-evt.c state_blue = STATE_OFF; state_red = STATE_OFF; callback_blue(null); callback_red(null); PROCESS_END(); 27

28 Exercise: Sequential Beacons Rewrite the Double Beacons application in a sequential style Name it double-beacons-seq.c 28

29 Problem with Event-Driven Model Events: unstructured code flow Threads: sequential code flow 29

30 Double Beacons Multi-process? #include "contiki.h" double-beacons-seq.c #include "dev/leds.h" /* */ PROCESS(beacon_blue_process, "Beacon Blue Application"); PROCESS(beacon_red_process, "Beacon Red Application"); AUTOSTART_PROCESSES(&beacon_blue_process,&beacon_red_process); /* */ PROCESS_THREAD( beacon_blue_process, ev, data) PROCESS_BEGIN(); watchdog_stop(); for (;;) leds_on(leds_blue); clock_wait(clock_second/10); leds_off(leds_blue); clock_wait(clock_second); PROCESS_THREAD( beacon_red_process, ev, data) PROCESS_BEGIN(); watchdog_stop(); for (;;) leds_on(leds_red); clock_wait(clock_second/10); leds_off(leds_red); clock_wait(clock_second*0.75); PROCESS_END(); PROCESS_END(); 30

31 Events Require One Stack Four event handlers, one stack Stack is reused for every event handler Eventhandler

32 Problem with Multithreading Four threads, each with its own stack Thread 1 Thread 2 Thread 3 Thread 4 32

33 Emulating Concurrency Previous example wouldn't work because of the blocking while-loop Other parts of the system will be unresponsive Must return to kernel inside of the whileloops During kernel's idle loop, keep jumping into the while-loops 33

34 Coroutines Generalized subroutines Allow multiple entry points for suspending and resuming execution at certain locations Can be used to implement: Cooperative multitasking Actor model of concurrency 34

35 Subroutines vs. Coroutines Subroutines are a special case of coroutines. --Donald Knuth Fundamental Algorithms. The Art of Computer Programming Routine 1 Routine 2 Routine 1 Routine 2 call yield yield return return yield call yield Subroutines Coroutines 35

36 Programming Model call call return Event handler1 Kernel's Idle loop return continue Event handler2 continue yield yield Task 1 Task 2 Handled by Kernel Handled by developer 36

37 Implementing Continuation Each coroutine must be able to continue from where it last yielded continue Routine 1 Main Loop yield continue yield 37

38 Implementing Continuation Use computed goto statement Non-standard, supported by GCC Use switch..case, Duff's device style 38

39 Duff's Device Invented to optimize data transfer by means of loop unwinding Switch cases are used like GOTO labels do *to = *from++; while(--count > 0); register n = (count + 7) / 8; switch(count % 8) case 0: do *to = *from++; case 7: *to = *from++; case 6: *to = *from++; case 5: *to = *from++; case 4: *to = *from++; case 3: *to = *from++; case 2: *to = *from++; case 1: *to = *from++; while(--n > 0); 39

40 Protothreads Invented by Adam Dunkels and Oliver Schmidt Used in the Contiki OS Provides light-weight mechanism for concurrent programming using standard C macros and switch-case statements Heavily inspired by Duff's Device and Simon Tatham's Coroutines in C See 40

41 Protothreads Protothreads require only one stack E.g, four protothreads, each with its own stack Just like events Events require one stack Protothread

42 Six-line implementation Protothreads implemented using the C switch statement Heavily inspired by Duff's Device and Simon Tatham's Coroutines in C struct pt unsigned short lc; ; #define PT_INIT(pt) pt->lc = 0 #define PT_BEGIN(pt) switch(pt->lc) case 0: #define PT_EXIT(pt) pt->lc = 0; return 2 #define PT_WAIT_UNTIL(pt, c) pt->lc = LINE ; case LINE : \ if(!(c)) return 0 #define PT_END(pt) pt->lc = 0; return 1 42

43 Double Beacons Protothreads Setup and declarations #include "contiki.h" double-beacons-pt.c #include "dev/leds.h" /* */ PROCESS(beacon_blue_process, "Beacon Blue Application"); PROCESS(beacon_red_process, "Beacon Red Application"); AUTOSTART_PROCESSES(&beacon_blue_process,&beacon_red_process); /* */ 43

44 Double Beacons Protothreads Blue beacon process PROCESS_THREAD(beacon_red_process, ev, data) static struct etimer et; PROCESS_BEGIN(); double-beacons-pt.c for (;;) leds_off(leds_red); etimer_set(&et,clock_second*0.75); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); leds_on(leds_red); etimer_set(&et,clock_second*0.1); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); PROCESS_END(); 44

45 Double Beacons Protothreads Red beacon process PROCESS_THREAD(beacon_blue_process, ev, data) static struct etimer et; PROCESS_BEGIN(); double-beacons-pt.c for (;;) leds_off(leds_blue); etimer_set(&et,clock_second); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); leds_on(leds_blue); etimer_set(&et,clock_second*0.1); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); PROCESS_END(); 45

46 Protothreads Limitations Local variables must be manually preserved Local variables are created on stack They are destroyed when function returns So they should be stored in an explicit state object Or declared static, if reentrancy is not required Cannot take advantage of multi-processing switch-case statements are not allowed There is also a 'goto' implementation of PT 46

Introduction to Contiki Kristof Van Laerhoven, Embedded Systems, Uni Freiburg

Introduction to Contiki Kristof Van Laerhoven, Embedded Systems, Uni Freiburg Kristof Van Laerhoven, Embedded Systems, Uni Freiburg kristof@ese.uni-freiburg.de Contiki Operating System ê memory-efficient: 2 kb RAM, 40 kb ROM typically* ê provides IP support (its uipv6 stack is IPv6