Shanghai Jiao Tong University-October 2016 TinyOS 2.1 Yanan Xu Shanghai Jiao Tong University-October 2016 1 1

What is TinyOS, NesC, Telosb TinyOS is an operating system for low power, embedded, wireless device Provide multiple components for user Only install necessary components to chip NesC is a programming language used in TinyOS Define components Wire components Telosb is a typical device we used Provide radio, leds, sensors etc on chip 2 2 2

Telosb device Reset Button USB Connector Internal Antenna LEDs 3 3 3

Programming Environment Install VirtualBox Start VirtualBox File -> import Virtual Applicance -> choose the system image Start

Programming Environment This is a virtual machine with Ubuntu OS User name: wcu Pass word: nosecurity Tiny OS programming environment has been set up in this machine

How to copy files Connect one USB disk to your computer Devices-> USB->USB disk

How to copy files Connect one USB disk to your computer Devices-> USB->USB disk USB disk appears

Tiny OS Places->computer->Filesystem->opt->tinyos- 2.x examples document Interfaces and libs

Example 1: Apps/Blink Convention used in the TinyOS source tree Blink is composed of two components: a module, called "BlinkC.nc", and a configuration, called "BlinkAppC.nc". Convention used in the TinyOS source tree File Name File Type Foo.nc Interface Foo.h Header File FooC.nc Public Module FooP.nc Private Module FooAppC.nc Configuration

Run Blink Run Blink demo Connect a mote to your computer VirtualBox: Devices->USB-> Telos

Run Blink Run Blink demo Connect a mote to your computer VirtualBox: Devices->USB-> Telos Open a terminal, Change the shell working directory to /opt/tinyos-2.x/apps/Blink/ Check mote : motelist Install program: make telosb install /dev/ttyUSB0

BlinkC.nc: a module BlinkC.nc BlinkAppC.nc

BlinkC.nc: a module

BlinkC.nc: a module Commands Events We can call commands provided by existing modules But we need to write codes for the Events function Events Events are triggered by some events, e.g. package arrives, timeout

BlinkC.nc: a module What do we need for letting a led light blink several times? Program entrance Led light Timer

Component : Module Modules are components that have variables and executable code Modules use interfaces Modules provide interfaces (not shown in the example) Use interface rename Excutable code

BlinkAppC.nc: a configuration Configurations are components that wire (->) other components together Some components system defined, some user defined A.B->C.B means: component A uses interface B, component C provides interface B Component A can call command of interface B, but must implement event of B Interface B implement its commands, provide event (like interrupt) for component who use it A.B->C.B is equivalent to: A.B->C, A->C.B, C<-A.B, C.B<-A B.B is a terrible but correct format. Remember former B is component, latter B is interface

Component : configuration User defined component Configuration wires BlinkC with other components (TimerMilliC, MainC, LedsC) BlinkC.Timer0->Timer0.Timer0 is correct but confusing Terrible rename A.B->C.B BlinkC Leds provides uses Timer0 Boot MainC TimerMilliC (Timer0)m LedsCm

Singletons and Generics Singleton components are unique: they exist in a global namespace Generics are instantiated: each instantiation is a new, independent copy configuration BlinkC { … } implementation { components new TimerC(); components BlinkC; BlinkC.Timer -> TimerC; } 19 19 19

Interfaces details Collections of related functions Define how components connect Interfaces are bi-directional: for A->B Commands are from A to B (implemented by B) Events are from B to A (implemented by A) Can have parameters (types) interface Timer<tag> { command void startOneShot(uint32_t period); command void startPeriodic(uint32_t period); event void fired(); } 20 20 20

Implementation of BlinkC.nc Use Boot Implement event booted Use Timer Call command startPeriodic Implement event fired Use Leds Call command led0Toggle()

Example 2: Mote-mote radio communication create a simple application that increments a counter, displays the counter's three least significant bits on the three LEDs, sends a message with the counter value over the radio. 

Interfaces Boot: start the device Timer: for timing SplitControl: start the radio AMSend: send a packet Receive: receive a packet Package: store the data Leds: turn on the LEDs or turn off the LEDs

Mote-mote radio communication We implement this application with two steps Implement Blink application A timer changes count variable Turn on or turn off the LEDs according to the count variable Add Radio communication part A mote send packets, and put the value of count in the packets A mote receive packets, get the count value, and turn on or turn off the LEDs according to the count

Step 1: Reimplementing Blink Four files

Reimplementing Blink File: BlinkToRadioC.nc #include <Timer.h> #include "BlinkToRadio.h" module BlinkToRadioC { uses interface Boot; uses interface Leds; uses interface Timer<TMilli> as Timer0; }

Reimplementing Blink File: BlinkToRadioC.nc implementation { uint16_t counter = 0; event void Boot.booted() { call Timer0.startPeriodic(TIMER_PERIOD_MILLI); } event void Timer0.fired() { counter++; call Leds.set(counter);

Reimplementing Blink File: BlinkToRadioAppC.nc #include <Timer.h> #include "BlinkToRadio.h" configuration BlinkToRadioAppC { } implementation { components MainC; components LedsC; components BlinkToRadioC as App; components new TimerMilliC() as Timer0; App.Boot -> MainC; App.Leds -> LedsC; App.Timer0 -> Timer0;

Reimplementing Blink File: BlinkToRadio.h #ifndef BLINKTORADIO_H #define BLINKTORADIO_H enum { TIMER_PERIOD_MILLI = 250 }; #endif

Reimplementing Blink File: Makefile COMPONENT=BlinkToRadioAppC Make telosb install /dev/ttyUSB0 Result: telosb will set the LEDs to the counter COMPONENT=BlinkToRadioAppC include $(MAKERULES)

Step 2: add radio communication Procedure of Sending a message Start device Control.start() Check if start success Define a packet, get the pointer of its PayLoad Packet.getPayload(&packet, user_message_size) Fill the payload Send the packet AMSend.send(destination, &packet, size) Procedure of receiving a message Receive packets with Receive.receive event Get the payload of the packet Set the LEDs to the counter number just received with Leds.set

Add Radio communication part File: BlinkToRadio.h Comment out and add ... enum { AM_BLINKTORADIO = 6, TIMER_PERIOD_MILLI = 250 };

Add Radio communication part File: BlinkToRadioC.nc add module BlinkToRadioC { ... uses interface Packet; uses interface AMSend; uses interface SplitControl as AMControl; uses interface Receive; }

Add Radio communication part File: BlinkToRadioC.nc add implementation { bool busy = FALSE; message_t pkt; ... }

Add Radio communication part File: BlinkToRadioC.nc Comment out and add event void Boot.booted() { //call Timer0.startPeriodic(TIMER_PERIOD_MILLI); call AMControl.start(); }

Add Radio communication part File: BlinkToRadioC.nc Comment out and add event void AMControl.startDone(error_t err) { if (err == SUCCESS) { call Timer0.startPeriodic(TIMER_PERIOD_MILLI); } else { call AMControl.start(); event void AMControl.stopDone(error_t err) {}

Add Radio communication part File: BlinkToRadioC.nc Comment out and add event void Timer0.fired() { counter++; //call Leds.set(counter); if (!busy) { BlinkToRadioMsg* btrpkt = (BlinkToRadioMsg*)(call Packet.getPayload(&pkt, sizeof (BlinkToRadioMsg))); btrpkt->nodeid = TOS_NODE_ID; btrpkt->counter = counter; if (call AMSend.send(AM_BROADCAST_ADDR, &pkt, sizeof(BlinkToRadioMsg)) == SUCCESS) { busy = TRUE; }

Add Radio communication part File: BlinkToRadioC.nc Comment out and add event void AMSend.sendDone(message_t* msg, error_t error) { if (&pkt == msg) { busy = FALSE; }

Add Radio communication part File: BlinkToRadioC.nc Comment out and add event message_t* Receive.receive(message_t* msg, void* payload, uint8_t len) { if (len == sizeof(BlinkToRadioMsg)) { BlinkToRadioMsg* btrpkt = (BlinkToRadioMsg*)payload; call Leds.set(btrpkt->counter); } return msg;

Add Radio communication part File: BlinkToRadioAppC.nc Comment out and add implementation { ... components ActiveMessageC; components new AMSenderC(AM_BLINKTORADIO); components new AMReceiverC(AM_BLINKTORADIO); }

Add Radio communication part File: BlinkToRadioAppC.nc Comment out and add implementation { ... App.Packet -> AMSenderC; App.AMSend -> AMSenderC; App.AMControl -> ActiveMessageC; App.Receive -> AMReceiverC; }

Test the application! $ motelist $ make telosb install, 1 /dev/ttyUSB0 $ make telosb reinstall, 2 /dev/ttyUSB0

Assignment 2 Mote-mote radio communication One mote as master node, others as slave node Show how many motes communicate with the master node Use the LEDs to show the number of motes

Grading scheme Sensor nodes can communicate with each other. 20% When a node connect to the master node, LEDs should be set to old number plus one. 40% When a node is shut down, LEDs should be set to old number minus one. 40% Code quality. 10%

Submission Face to face demo Codes Report Deadline November 18, Friday

Reference http://tinyos.stanford.edu/tinyos- wiki/index.php/TinyOS_Tutorials https://people.eecs.berkeley.edu/~culler /papers/ai-tinyos.pdf

THE END