1. Network Kernel Architectures and Implementation (01204423) Node Programming Chaiporn Jaikaeo chaiporn.j@ku.ac.th Department of Computer Engineering Kasetsart University

2. 2 Outline Microcontroller programming Microcontroller programming  Software development cycle Hardware platforms Hardware platforms  IWING-MRF  IWING-JN IWING's MoteLib IWING's MoteLib

3. 3 IWING-MRF Mote Radio transceiver 8-bit AVR Microcontroller USB Connector (for reprogramming and power) Analog/Digital sensor connectors External battery connector UART connectors Morakot Saravanee, Chaiporn Jaikaeo, 2010. Intelligent Wireless Network Group (IWING), KU

4. IWING-JN Mote Analog/Digital sensor connectors UART connectors Wireless microcontroller module with PCB antenna

5. 5 Microcontroller flash memory BSL Typical Development Process For microcontrollers with bootstrap loader (BSL) installed For microcontrollers with bootstrap loader (BSL) installed Source code (C/Asm) Cross Compiler/Assembler Machine code Serial/USB

6. 6 Build Simple App Let's build a simple application Let's build a simple application How to know whether our program is running? How to know whether our program is running?  Make mote output something  What can be used as output?

7. 7 IWING-MRF Schematic Available on course's homepage Available on course's homepage

8. 8 IWING-MRF – Blinking LED Task: turn a LED on and off repeatedly Task: turn a LED on and off repeatedly Idea Idea  Configure Port D's Pin 5 (PD5) for output  Repeatedly set the pin logic level to 0 and 1  Add some delay before toggling pin level

9. 9 IWING-MRF C Code – blink.c How to add delay? How to add delay? Can the code be made shorter? Can the code be made shorter? #include main() { DDRD |= (1 << 5); // Make PD5 output while (1) { // Set pin logic to low PORTD &= ~(1 << 5); // Add some delay // Set pin logic to high PORTD |= (1 << 5); }

10. 10 Compiling Make an ELF binary by running cross compiler Make an ELF binary by running cross compiler Note: blink.elf is not a Windows or Linux executable! Translate the object file into ihex format Translate the object file into ihex format $ avr-gcc -mmcu=atmega328p –o blink.elf blink.c $ avr-objcopy -j.text -j.data –O ihex blink.elf blink.hex

11. 11 Flashing Code Into Mote Plug mote into a USB port Plug mote into a USB port Activate boot-loader Activate boot-loader  Press and release RESET while holding USER/B.L. Make sure it is recognized by your PC Make sure it is recognized by your PC Invoke chip programmer Invoke chip programmer $ avrdude -p atmega328p -c usbasp -U flash:w:blink.hex $ lsusb Bus 003 Device 049: ID 16c0:05dc Bus 001 Device 003: ID 046d:c03d Logitech, Inc.

12. 12 IWING-MRF's Boot Loader

13. 13 Creating Makefile To compile To compile To download program to flash (will compile if needed) To download program to flash (will compile if needed) make make flash Tab character

14. 14 IWING's MoteLib Software Hardware Morakot Saravanee, Patra Poome, Chaiporn Jaikaeo, 2009. Intelligent Wireless Network Group (IWING), KU

15. 15 Hardware Abstraction IWING-MRF Hardware IWING-MRF API Implementation

16. 16 Hardware Abstraction IWING-JN Hardware IWING-JN API Implementation

17. 17 Mote and Network Emulator Virtual Mote

18. 18 Programming Model MoteLib provides event-based programming environment MoteLib provides event-based programming environment Idle loop Radio event handlerSensor event handlerTimer event handler Boot event handler Handled by MoteLib Handled by developer

19. 19 Example Turn red LED on and off repeatedly every 500 ms Turn red LED on and off repeatedly every 500 ms #include Timer t; void fired(Timer *t) { ledToggle(0); } void boot() { timerCreate(&t); timerStart(&t, TIMER_PERIODIC, 500, fired); }

20. 20 Example: Creating Makefile # Platform to build the code for PLATFORM = iwing-mrf # Required target without extension TARGET = blink # Include MoteLib's main make rules include $(MOTELIB_DIR)/Makerules

21. 21 Example: Build and Flash App Build your application Build your application Program the mote with Program the mote with make make flash

22. 22 MoteLib API Residing in $(MOTELIB_DIR)/include Residing in $(MOTELIB_DIR)/include  motelib/system.h  motelib/led.h  motelib/timer.h  motelib/button.h  motelib/sensor.h  motelib/actor.h  motelib/radio.h  motelib/uart.h Complete API documentation can be found here Complete API documentation can be found here  http://www.cpe.ku.ac.th/~cpj/motelib/ http://www.cpe.ku.ac.th/~cpj/motelib/

23. 23 System API ( motelib/system.h ) Provides boot() function signature Provides boot() function signature Provides various function declarations for node ID and network ID inquiry Provides various function declarations for node ID and network ID inquiry Should be included in every MoteLib application Should be included in every MoteLib application

24. 24 LED API ( motelib/led.h ) Turn LED#2 on Turn LED#2 on Turn LED#1 off Turn LED#1 off Toggle LED#0 Toggle LED#0 Use LEDs to display binary value Use LEDs to display binary value ledSet(2,1); ledSet(1,0); ledToggle(0); ledSetValue(5);

25. 25 Timer API ( motelib/timer.h ) Define and initialize a timer Define and initialize a timer Start the timer with 1-second timeout; trigger only once; call function fired when triggered Start the timer with 1-second timeout; trigger only once; call function fired when triggered Start the timer with 1-second timeout; trigger periodically Start the timer with 1-second timeout; trigger periodically Timer t; timerCreate(&t); timerStart(&t, TIMER_ONESHOT, 1000, fired); timerStart(&t, TIMER_PERIODIC, 1000, fired);

26. 26 Timer API (cont'd) Defining callback Defining callback void fired(Timer *t) { // do something }

27. 27 Button API ( motelib/button.h ) Set handler to monitor button event Set handler to monitor button event  Usually called in boot() Handler example Handler example buttonSetHandler(handler); void handler(ButtonStatus s) { if (s == BUTTON_PRESSED) // do something if (s == BUTTON_RELEASED) // do something }

28. 28 Programming Practice button-count.c button-count.c  Counts how many times the USER button has been pressed  Then shows the number (only 3 LSBs) on the LEDs  Count to 7 and wrap around to 0

29. 29 Sensor API ( motelib/sensor.h ) Read digital input from input#0 Read digital input from input#0 Request analog reading (asynchronous) from input#3 Request analog reading (asynchronous) from input#3 uint16_t x = sensorReadDigital(SENSOR_0); sensorRequestAnalog(SENSOR_3, dataReady); : void dataReady(uint16_t value) { // value stores sensor reading }

30. 30 Actor API ( motelib/actor.h ) Activate output #2 (set logic to High) Activate output #2 (set logic to High) Deactivate output #3 (set logic to Low) Deactivate output #3 (set logic to Low) actorSetState(ACTOR_2,1); actorSetState(ACTOR_3,0);

31. 31 Measures light and temperature Measures light and temperature Sensor Board Sensor Power Supply Light Sensor Temperature Sensor

32. IWING-MRF Schematic 32

33. 33 IWING-JN Schematic

34. 34 Sensor Reading Procedure Step 1: Turn on sensor power Step 1: Turn on sensor power Step 2: Request analog reading Step 2: Request analog reading Step 3: Wait until value is available Step 3: Wait until value is available Step 4: Turn off sensor power Step 4: Turn off sensor power

35. Split-Phase Operations Request Data Blocking SensorController Synchronous Operation Asynchronous Operation SensorController Request Ready Ack Read Data

36. 36 Example: sense-light.c Every 100 ms, measure light and display the value on LEDs Every 100 ms, measure light and display the value on LEDs  Light value is in range 0 – 1023  Need to scale down to 0 – 7

37. 37 Example #include Timer t; void readDone(uint16_t value); void readLight(Timer *t); void boot() { timerCreate(&t); timerStart(&t, TIMER_PERIODIC, 100, readLight); } void readLight(Timer *t) { actorSetState(ACTOR_0, 1); sensorRequestAnalog(SENSOR_1, readDone); } void readDone(uint16_t value) { ledSetValue(value/128); actorSetState(ACTOR_0, 0); }

38. 38 Programming Practice Modify sense-light.c so that light is sampled 4 times in each measurement Modify sense-light.c so that light is sampled 4 times in each measurement  Average value is displayed on LEDs

39. 39 Creating a Reading Task Event-based code can be difficult to read and maintain Event-based code can be difficult to read and maintain Idea Idea  Make a reading task that runs forever  Other tasks can also be added to run concurrently Start timer Wait until timer expired Create timer Turn on sensors Request reading Wait until data ready Complete 4 samples? Compute and display average Turn off sensors

40. 40 Synchronous Operations MoteLib provides various checks to support synchronous operation MoteLib provides various checks to support synchronous operation E.g., E.g.,  timerExpired(t)  Determines whether timer t has already expired  Only works for one-shot timer  sensorAnalogWaiting(s)  Returns true if the system still waits for sensor s  sensorAnalogResult(s)  Returns the most recent value of sensor s

41. 41 First Attempt #include Timer t; void readLightTask(); void boot() { readLightTask(); } void readLightTask() { uint8_t i; uint16_t sum = 0; timerCreate(&t); while (1) { timerStart(&t, TIMER_ONESHOT, 100, NULL); while (!timerExpired(&t)) ; actorSetState(ACTOR_0, 1); for (i = 0; i < 4; i++) { sensorRequestAnalog(SENSOR_1, NULL); while (sensorAnalogWaiting(SENSOR_1)) ; sum += sensorAnalogResult(SENSOR_1); } ledSetValue(sum/4/128); actorSetState(ACTOR_0, 0); } Will this work?

42. Problem with Event-based Model Threads: sequential code flowEvents: unstructured code flow Very much like programming with GOTOs 42

43. Events Require One Stack Four event handlers, one stack Four event handlers, one stack Eventhandler 1Eventhandler 2Eventhandler 3 Stack is reused for every event handler Eventhandler 4 43

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

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

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

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

48. 48 Programming Model MoteLib's Idle loop Task 2 Event handler2 Task 1 Event handler1 Handled by MoteLib Handled by developer call return call return continue yield yield continue

49. 49 Implementation Details How to ask MoteLib to call our tasks? How to ask MoteLib to call our tasks?  MoteLib provides setLoopRoutine(), allowing a function to be called every idle loop How to have a task yield and correctly come back to where it left? How to have a task yield and correctly come back to where it left? void myroutine() { // something to be executed continuously } void boot() { : setLoopRoutine(myroutine); }

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

51. 51 Duff's Device Invented to optimize data transfer by means of loop unwinding Invented to optimize data transfer by means of loop unwinding Switch cases are used like GOTO labels 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); }

52. 52 Protothreads Invented by Adam Dunkels and Oliver Schmidt 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 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 Heavily inspired by Duff's Device and Simon Tatham's Coroutines in CCoroutines in CCoroutines in C See See  http://dunkels.com/adam/pt/expansion.html http://dunkels.com/adam/pt/expansion.html

53. Protothreads Protothreads require only one stack Protothreads require only one stack E.g, four protothreads, each with its own stack E.g, four protothreads, each with its own stack Events require one stack Protothread 1 Protothread 2Protothread 3Protothread 4 Just like events 53

54. Six-line implementation Protothreads implemented using the C switch statement Protothreads implemented using the C switch statement Heavily inspired by Duff's Device and Simon Tatham's Coroutines in C Heavily inspired by Duff's Device and Simon Tatham's Coroutines in CCoroutines in CCoroutines 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 if(!(c)) return 0 #define PT_END(pt) } pt->lc = 0; return 1 54

55. 55 Revised sense-light.c ////////////////////////////// PT_THREAD(readLightTask(struct pt *pt)) { static uint8_t i; static uint16_t sum = 0; PT_BEGIN(pt); timerCreate(&t); while (1) { timerStart(&t, TIMER_ONESHOT, 100, NULL); PT_WAIT_UNTIL(pt, timerExpired(&t)); actorSetState(ACTOR_0, 1); for (i = 0; i < 4; i++) { sensorRequestAnalog(SENSOR_1, NULL); PT_WAIT_WHILE(pt, sensorAnalogWaiting(SENSOR_1)); sum += sensorAnalogResult(SENSOR_1); } ledSetValue(sum/4/128); actorSetState(ACTOR_0, 0); } PT_END(pt); } #include struct pt readLight_pt; PT_THREAD(readLightTask(struct pt *pt)); Timer t; ////////////////////////////// void scheduleTasks() { readLightTask(&readLight_pt); } ////////////////////////////// void boot() { setLoopRoutine(scheduleTasks); }

56. 56 Protothreads Limitations Local variables must be manually preserved 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 switch-case statements are not allowed switch-case statements are not allowed Cannot take advantage of multi-processing Cannot take advantage of multi-processing