1. Peek into TinyOS Programs Vinod Kulathumani

2. 2 Basics Application consists of one or more components assembled, or wired A component provides and uses interfaces. Interfaces are bidirectional:  they specify a set of commands  and a set of events For a component to call the commands in an interface, it must implement the events of that interface. A single component may use or provide multiple interfaces and multiple instances of the same interface. Signature - The set of interfaces a component provides + set of interfaces that a component uses

3. 3 Components Two types of components in nesC  modules and configurations Modules provide the implementations of one or more interfaces Configurations are used to assemble other components together  connect interfaces used by components to interfaces provided by others Every nesC application described by a top-level configuration

4. 4 Convention Header File abc.h Interface abc.nc Configuration abcAppC.nc Module [Public] abcC.nc Module [Private] abcP.nc

5. 5 HelloAppC Configuration configuration HelloAppC { } implementation { }

6. 6 HelloAppC Configuration configuration HelloAppC { } implementation { components HelloC; }

7. 7 HelloC Module module HelloC { } implementation { }

8. 8 HelloC Module module HelloC { uses { interface Boot; interface Leds; } implementation { }

9. 9 HelloC Module module HelloC { uses { interface Boot; interface Leds; } implementation { }

10. 10 Boot Interface interface Boot { event void booted(); }

11. 11 HelloC Module module HelloC { uses { interface Boot; interface Leds; } implementation { event void Boot.booted() { } USE an interface, CAPTURE all of its events!

12. 12 Leds Interface interface Leds { command void led0On(); command void led0Off(); command void led0Toggle(); … command void set(uint8_t val); }

13. 13 HelloC Module module HelloC { uses { interface Boot; interface Leds; } implementation { event void Boot.booted() { call Leds.led0On(); }

14. 14 HelloAppC Configuration configuration HelloAppC { } implementation { components HelloC, MainC, LedsC; // USES -> PROVIDES HelloC.Boot -> MainC.Boot; HelloC.Leds -> LedsC; }

15. 15 Hello Application

16. 16 Example 2: Blink Configuration – BlinkAppC.nc Module – BlinkC.nc

17. 17 Configuration configuration BlinkAppC { } implementation { }

18. 18 Implementation module BlinkC { } implementation { }

19. 19 Configuration components list configuration BlinkAppC { } implementation { components MainC, BlinkC, LedsC; components new TimerMilliC() as Timer0; components new TimerMilliC() as Timer1; components new TimerMilliC() as Timer2; }

20. 20 Module provides / uses Module BlinkC{ uses interface Timer as Timer0; uses interface Timer as Timer1; uses interface Timer as Timer2; uses interface Leds; uses interface Boot; } implementation { // implementation code omitted }

21. 21 Module provides / uses Module BlinkC{ uses interface Timer as Timer0; uses interface Timer as Timer1; uses interface Timer as Timer2; uses interface Leds; uses interface Boot; } implementation { event void Boot.booted() { call Timer0.start(); …. } event Timer0.fired() { … } event Timer1.fired() { … }

22. 22 Configuration wiring configuration BlinkAppC { } implementation { components MainC, BlinkC, LedsC; components new TimerMilliC() as Timer0; components new TimerMilliC() as Timer1; components new TimerMilliC() as Timer2; BlinkC.Boot -> MainC.Boot; BlinkC.Timer0 -> Timer0; BlinkC.Timer1 -> Timer1; BlinkC.Timer2 -> Timer2; BlinkC.Leds -> LedsC; }

23. 23 Sensing example configuration SenseAppC { } implementation { components SenseC, MainC, LedsC, new TimerMilliC() as TimerSensor, new DemoSensorC() as Sensor; }

24. 24 Sensing module SenseC { uses { interface Boot; interface Leds; interface Timer as TimerSensor; interface Read as SensorRead; }

25. 25 Sensing implementation { event void boot.booted { call TimerSensor.startPeriodic(SAMPLING_FREQUENCY); } event void TimerTemp.fired() { call SensorRead.read(); } event void SensorRead.readDone(error_t result, uint16_t data) { if (result == SUCCESS) {Call leds.led0Toggle(); } }

26. 26 Sensing example configuration SenseAppC { } implementation { components SenseC, MainC, LedsC, new TimerMilliC() as TimerSensor, new DemoSensorC() as Sensor; SenseC.Boot -> MainC; SenseC.Leds -> LedsC; SenseC.TimerSensor -> TimerSensor; SenseC.SensorRead -> Sensor; }

27. 27 Radio Stacks Radio Hardware Transmit / Receive / Init CSMA / Acknowledgements ActiveMessage Message Queue Your Application Receive SplitControl AMSend

28. 28 Main Radio Interfaces SplitControl  Provided by ActiveMessageC AMSend  Provided by AMSenderC Receive  Provided by AMReceiverC

29. 29 Main Serial Interfaces SplitControl  Provided by SerialActiveMessageC AMSend  Provided by SerialAMSenderC Receive  Provided by SerialAMReceiverC

30. 30 Setting up the Radio: Configuration configuration MyRadioAppC { } implementation { components MyRadioC, MainC, ActiveMessageC, new AMSenderC(0) as Send0, // send an AM type 0 message new AMReceiverC(0) as Receive0; // receive an AM type 0 }

31. 31 Setting up the Radio: Module module MyRadioC { uses { interface Boot; interface SplitControl; interface AMSend; interface Receive; } implementation { }

32. 32 Turn on the Radio event void Boot.booted() { call SplitControl.start(); } event void SplitControl.startDone(error_t error) { post sendMsg(); } event void SplitControl.stopDone(error_t error) { }

33. 33 Setting up the Radio: Configuration configuration MyRadioAppC { } implementation { components MyRadioC, MainC, ActiveMessageC, new AMSenderC(0) as Send0, // send an AM type 0 message new AMReceiverC(0) as Receive0; // receive an AM type 0 MyRadioC.Boot -> MainC; MyRadioC.SplitControl -> ActiveMessageC; MyRadioC.AMSend -> Send0; MyRadioC.Receiver -> Receive0; }

34. 34 Payloads A message consists of:  Header  Payload  Optional Footer

35. 35 message_t typedef nx_struct message_t { nx_uint8_t header[sizeof(message_header_t)]; nx_uint8_t data[TOSH_DATA_LENGTH]; nx_uint8_t footer[sizeof(message_footer_t)]; nx_uint8_t metadata[sizeof(message_metadata_t)]; } message_t;

36. 36 Payloads : Use Network Types (MyPayload.h) typedef nx_struct MyPayload { nx_uint8_t count; } MyPayload;

37. 37 Send Messages message_t myMsg; bool sending=false; task void sendMsg() { MyPayload *payload = (MyPayload *)call ASMSend.getPayload(&myMsg); payload->count = (myCount++); if (sending==false) { error_t p; p = call AMSend.send(AM_BROADCAST_ADDR, myMsg, 0); If (p==SUCCESS) sending=true; else post sendMsg(); } event void AMSend.sendDone(message_t *msg, error_t error) { sending=false; }

38. 38 Receive a Message event message_t *Receive.receive(message_t *msg, void *payload, uint8_t length) { MyPayload* pkt = (MyPayload *)payload; uint8_t ct = pkt->count; call Leds.led0Toggle(); return msg; }

39. 39 RealMainP module RealMainP { provides interface Boot; uses { interface Scheduler; interface Init as PlatformInit; interface Init as SoftwareInit; } } Implementation{ // platform initialization stuff call SoftwareInit.init() signal Boot.booted(); // call scheduler task loop }

40. 40 SoftwareInit in RealMainP Suppose user writes module RandomIntC  provides an interface Init  should be initialized before use (to generate seed)  what if application developer forgets Instead write a configuration RandomC around RandomIntC Module RandomC { provides interface Init; } Implementation RandomC{ components MainC, RandomIntC; MainC.SoftwareInit -> RandomIntc.Init; }

41. 41 SoftwareInit in RealMainP So far we didn’t care in our examples  All our examples were applications  Did not provide interface  Interior components that provide interface may need Init MainC.SoftwareInit may be wired to many Inits  Each will be called in sequence

42. 42 References TinyOS Tutorials – www.tinyos.netwww.tinyos.net David Moss TinyOS 2 tutorial