Enabling Networked Sensors

Size: px

Start display at page:

Download "Enabling Networked Sensors"

Myles Parker
6 years ago
Views:

1 Politecnico di Milano Advanced Network Technologies Laboratory Enabling Networked Sensors A Primer on TinyOS

2 Ing. Matteo Cesana Office: DEI 3 Floor Room cesana@elet.polimi.it Phone:

3 Luca Borsani, Alessandro Redondi ANTLab: V.le delle Rimembranze di Lambrate, 8 3 Floor Room borsani@elet.polimi.it redondi@elet.polimi.it Phone:

4 Classes Objectives Giving you a flavor on TinyOS Stimulating your curiosity Providing you with basic tools to develop simple applications under TinyOS Classes time is limited -> Play with TinyOS on your own

5 Slides Sources MobySys 2003 Tutorial Other TinyOS

6 Agenda A Bit of Context on Wireless Sensor Networks (WSNs): Applications, Challenges, Sensor Platforms Designing OS for networked sensors Requirements and guidelines TinyOS Overview Architecture Basic Concepts

7 Agenda continued Playing with TinyOS Blink Application Using the Radio RadioCountToLeds Application

8 Politecnico di Milano Advanced Network Technologies Laboratory A Bit of Context on WSNs Technology, Applications and Sensor Nodes

9 log (people per computer) New Class of Computing Mainframe Minicomputer Workstation PC Laptop PDA year

10 Technology Push CMOS miniaturization Micro-sensors (MEMS, Materials, Circuits) acceleration, vibration, gyroscope, tilt, magnetic, heat, motion, pressure, temp, light, moisture, humidity, barometric chemical (CO, CO2, radon), biological, microradar,... actuators too (mirrors, motors, smart surfaces, micro-robots) Communication short range, low bit-rate, CMOS radios (1-10 mw) Power batteries remain primary storage (1,000 mw*s/mm 3 ), fuel cells 10x solar (10 mw/cm 2, 0.1 mw indoors), vibration (~uw/gm), flow 1 cm 3 battery => 1 year at 10 msgs/sec

11 Application Pull Monitoring Environments habitat monitoring, conservation biology,... Precision agriculture, land conservation,... built environment comfort & efficiency... alarms, security, surveillance, treaty verification... Monitoring Structures and Things structural response, condition-based maintenance disaster management urban terrain mapping & monitoring Interactive Environments manufacturing, asset tracking, fleet & franchise context aware computing, non-verbal communication assistance home/elder care CENS.ucla.edu

12 WSNs: Potentials and Challenges Potentials Cost viability Flexibility Short time-to-deployment (can be built with off-the-shelf technology) Numbers (# nodes >> # people) Challenges at different layers Energy Efficient protocols design Self configurability or planning Robustness Coverage & Connectivity OS Design

13 Sensor Hardware Location Finding System Mobilizer Sensor ADC Processor Memory Transceiver Power Unit ANTENNA

14 Sensor Motes Timeline WeC Smart Rock Rene Experimentation Mica Open Experimental Platform Mica2Dot IMote MicaZ Telos Integrated Platform Stargate 2.0 & IMote Dot Scale Spec Mote on a chip Mica2 Stargate Epic

MICAz Platform Microprocessor: Atmel ATmega128L 7.

15 MICAz Platform Microprocessor: Atmel ATmega128L MHz clock 128 kb of Flash for program memory 4 kb of SRAM for data and variables 2 UARTs (Universal Asynchronous Receive and Transmit) Serial Port Interface (SPI) bus Dedicated hardware I2C bus Radio: Chipcon s CC2420 (IEEE ) 250 kbit/s External serial flash memory: 512 Kb xbow estimates > samples 51-pin expansion connector Eight 10-bit analog I/O 21 general purpose digital I/O User interface: 3 programmable LEDs Powered by two AA batteries 1850 mah capacity Antenna MMCX connector Logger Flash ATMega128L controller Analog I/O Digital I/O Freq. Tunable Radio 51-Pin Expansion Connector LEDs

Signals (ADC1-ADC6) On/Off Control I 2 C Bus Interrupt Microphone

16 Rich Sensor board Mica PINS Tone PHOTO SOUNDER Intr Mic Signal TEMP MICROPHONE Y Axis X Axis Gain Adjustment MAGNETOMETER ACCELEROMETER ADC Signals (ADC1-ADC6) On/Off Control I 2 C Bus Interrupt Microphone Sounder Magnetometer 1.25 in Temperature Sensor Light Sensor 2.25 in Accelerometer

17 Politecnico di Milano Advanced Network Technologies Laboratory Designing OS for networked sensors Requirements and guidelines

18 Traditional Architectures User System Application Application Network Stack Threads Transport Network Address Space Files Data Link Physical Layer Drivers Well established layers of abstractions Strict boundaries Ample resources Well attended Routers

19 Kernel Based Architectures Application 1 Application 2 Application 1 NFS I/O Monolithic kernel Micro-kernel VM I/O Scheduler IPC Scheduler VM HW HW Problems Large memory & storage requirement Unnecessary and overkill functionality Address space isolation, complex I/O subsystem, UI Relative high system overhead, e.g, context switch Require complex and power consuming hardware support

20 General-Purpose OS? MANY functionalities & programming APIs Protection between untrusted applications and kernel Overhead for crossing kernel/user boundary & interrupt handling Multi-threaded architecture Large number of threads large memory Context switch overhead I/O model Blocking I/O: waste memory on blocked threads Polling: waste CPU cycles and power Need a new OS architecture!

21 Sensor OS Requirements Small footprint Low system overhead Low power consumption Application-oriented design Flexibility in supporting multiple applications Solutions: Contiki SoS 6LowPAN TinyOS

22 Politecnico di Milano Advanced Network Technologies Laboratory TinyOS is an open-source operating system designed for wireless embedded sensor networks

23 TinyOS Overview Event-driven architecture OS operations are triggered by hardware interrupt (asynchronous management) Single shared stack No kernel/user space differentiation Main (includes Scheduler) Application (User Components) Actuating Sensing Communication Communication Hardware Abstractions

24 TinyOS Architecture Overview Scheduler TinyOS Application Component Application Component Application Component I/O COMM.. NO Kernel - Direct hardware manipulation NO Process management - Only one process on the fly NO Virtual memory -Single linear physical address space NO Dynamic memory allocation - Assigned at compile time NO Software signal or exception - Function call

25 TinyOS Ingredients TinyOS is not an OS in traditional sense Provides a programming framework to build application-specific OS instances Programming Framework made of: Scheduler (always there) Components Interfaces

26 Tiny OS Concepts Scheduler + Graph of Components constrained two-level scheduling model: tasks + events StdControl Timer provides Timer Component A component specifies a set of interfaces by which it is connected to other components provides a set of interfaces to others uses a set of interfaces provided by others Interfaces are bi-directional include commands and events Constrained Storage Model frame per component, shared stack, no heap Clock.nc Clock interface Clock { uses command result_t setrate(char interval, char scale); } StdControl.nc interface StdControl { command result_t init(); } event result_t fire(); command result_t start(); command result_t stop();

27 Event implementation Event is independent of FIFO scheduler. Lowest level events are supported directly by Hardware interrupt Software events propagate from lower level to upper level through function call

28 TASKS provide concurrency internal to a component longer running operations are preempted by events able to perform operations beyond event context may call commands may signal events not preempted by tasks {... post TskName();... } task void TskName {... }

$dataready(uint16_t data) { putdata(data); post processdata(); return SUCCESS; } task void processdata() { int16_t i, sum=0; } for (i=0; i maxdata; i++) sum += (rdata[i] 7); display(sum shiftdata);$

29 Typical application use of tasks event driven data acquisition schedule task to do computational portion event result_t sensor.dataready(uint16_t data) { putdata(data); post processdata(); return SUCCESS; } task void processdata() { int16_t i, sum=0; } for (i=0; i maxdata; i++) sum += (rdata[i] 7); display(sum shiftdata); 128 Hz sampling rate simple FIR filter dynamic software tuning for centering the magnetometer signal (1208 bytes) digital control of analog, not DSP ADC (196 bytes)

30 Tasks - Examples transmit packet send command schedules task to calculate CRC task initiated byte-level data pump events keep the pump flowing receive packet receive event schedules task to check CRC task signals packet ready if OK byte-level tx/rx task scheduled to encode/decode each complete byte must take less time that byte data transfer

31 TOS Execution Model commands request action ack/nack at every boundary call cmd or post task events notify occurrence HW intrpt at lowest level may signal events call cmds post tasks Tasks provide logical concurrency preempted by events Migration of HW/SW boundary bit byte packet application comp data processing message-event driven active message Radio Packet Radio byte RFM event-driven packet-pump crc event-driven byte-pump encode/decode event-driven bit-pump

32 An Example Application application sensing application routing Routing Layer messaging Messaging Layer packet Radio Packet byte Radio byte (MAC) photo Temp SW bit RFM clocks ADC i2c HW

33 Event-Driven Sensor Access Pattern command result_t StdControl.start() { return call Timer.start(TIMER_REPEAT, 200); } SENSE event result_t Timer.fired() { return call sensor.getdata(); } Timer Photo LED event result_t sensor.dataready(uint16_t data) { display(data) return SUCCESS; } clock event handler initiates data collection sensor signals data ready event data event handler calls output command device sleeps or handles other activity while waiting conservative send/ack at component boundary

34 events TinyOS Scheduling Tasks do computations Non-preemptive FIFO scheduling Bounded number of pending tasks Events handle concurrent dataflows Interrupts trigger lowest level events Events preempt tasks, tasks do not Events can signal events, call commands, or post tasks Preempt POST Tasks FIFO commands commands Hardware Interrupts Time

35 TinyOS Scheduling Event and Task Tasks cannot preempt other tasks Single shared stack Used by both interrupts and function calls Simple FIFO scheduler Events can preempt a task Events can preempt each other When idle, scheduler shuts down the node except for clock

36 Politecnico di Milano Advanced Network Technologies Laboratory Playing with TinyOS Componets, Event Handler and Wiring

37 Programming TinyOS TinyOS is written in a C dialect nesc Provides syntax for TinyOS concurrency and storage model commands, events, tasks local frame variable Static memory allocation No function pointers Applications are too! just additional components composed with the OS components

38 Components Modules (pippoc.nc files) provide code that implements one or more interfaces and internal behavior Configuration (pippoapp.nc files) link together components to yield new component Headers (pippo.h files) Define parameters Interface logically related set of commands and events StdControl.nc interface StdControl { command result_t init(); command result_t start(); command result_t stop(); } Clock.nc interface Clock { command result_t setrate(char interval, char scale); event result_t fire(); }

39 Applications in TinyOS Configurations: Used to configure applications Used to wire components through interfaces Modules Used to implement components, call commands, events, and tasks.

40 Example: Blink Application Operation: the application keeps three timers at.25 [Hz],.5 [Hz] and 1 [Hz], upon timer expiration a LED is toggled. It implements a counter form 0 to 7 every two seconds. Application Files: BlinkAppC.nc, configuration BlinkC.nc, module

41 BlinkC.nc #include "Timer.h" module BlinkC { uses interface Timer<TMilli> as Timer0; uses interface Timer<TMilli> as Timer1; uses interface Timer<TMilli> as Timer2; uses interface Leds; uses interface Boot; } implementation { event void Boot.booted() { call Timer0.startPeriodic( 250 ); call Timer1.startPeriodic( 500 ); call Timer2.startPeriodic( 1000 ); } event void Timer0.fired() { call Leds.led0Toggle(); } } event void Timer1.fired() { call Leds.led1Toggle(); } event void Timer2.fired() { call Leds.led2Toggle(); } Used Interfaces Timer Initialization Events of timer expiry Note: no interfaces provided to other components No commands defined No tasks needed

42 BlinkAppC.nc configuration BlinkAppC { } implementation { List of components implementing Blink applications components MainC, BlinkC, LedsC; components new TimerMilliC() as Timer0; components new TimerMilliC() as Timer1; components new TimerMilliC() as Timer2; BlinkC -> MainC.Boot; BlinkC.Timer0 -> Timer0; BlinkC.Timer1 -> Timer1; BlinkC.Timer2 -> Timer2; BlinkC.Leds -> LedsC; } Components Wiring

43 Blink Interfaces, Events and Commands BLINK BOOT LEDS TIMER 0 TIMER 1 TIMER 2 Booted Toggle Fired Fired Fired BLINKC MAINC LEDSC TIMER 0 TIMER 1 TIMER 2

44 Blink Application - Demo TinyOS v2.1 already (and properly) installed (refer to for installations guides) TinyOS Runs on different Platforms: Linux (Red Hat, Ubuntu, Xubuntu, Debian) Windows (through CygWin) Where to find it TinyOS Toolchain How to compile it on MICAz A look at the makefile Compiling commands Casting onto motes

45 Politecnico di Milano Advanced Network Technologies Laboratory Using the Radio Creating/Sending/Receiving/Manipulating Messages

46 Active Message Every message contains the name of an event handler Sender Name a handler Request Transmission Done - completion signal Receiver The corresponding event handler invoked

47 General Idea SENDER Fill Message Specify Destination Pass Message to OS Wait For FeedBack RECEIVER OS Stores MEssage OS Specify Msg Reception Pass Message to Applications

48 Message Buffer Abstraction In tos/types/messages.h 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_header_t)]; nx_uint8_t metadata[sizeof(message_metadata_t)]; } message_t; Header, footer, metadata are implemented by the specific link layer (radio module + platform) Data is handled by the application

49 Header and Metadata typedef nx_struct cc2420_header_t { nxle_uint8_t length; nxle_uint16_t fcf; nxle_uint8_t dsn; nxle_uint16_t destpan; nxle_uint16_t dest; nxle_uint16_t src; nxle_uint8_t network; // optionally included with 6LowPAN layer nxle_uint8_t type; } cc2420_header_t; typedef nx_struct cc2420_metadata_t { nx_uint8_t tx_power; nx_uint8_t rssi; nx_uint8_t lqi; nx_bool crc; nx_bool ack; nx_uint16_t time; } cc2420_metadata_t;

50 Interfaces Components above the basic data-link layer MUST always access packet fields through interfaces (in /tos/interfaces/). AMPacket Packet Send AMSend Receive Manipulate Packets Send Packets Receive Packets

51 Sender Component AMSenderC generic configuration AMSenderC(am_id_t AMId) { provides { interface AMSend; interface Packet; interface AMPacket; interface PacketAcknowledgements as Acks; } }

52 Receiver Component generic configuration AMReceiverC(am_id_t t) { provides{ interface Receive; interface Packet; interface AMPacket; } }

53 An Example - RadioCountToLeds Create an application that counts over a timer and broadcast the counter in a wireless packet. What do we need? Header File: to define message structure (RadioCountToLeds.h) Module component: to implement interfaces (RadioCountToLedsC.nc) Configuration component: to define the program graph, and the relationship among components (RadioCountToLedsAppC.nc)

54 Message Structure Message structure in file: RadioCountToLeds.h typedef nx_struct radio_count_msg_t { nx_uint16_t counter; #counter value } radio_count_msg_t; enum { AM_RADIO_COUNT_MSG= 6, TIMER_PERIOD_MILLI = 250 };

55 Module Component 1. Specify the interfaces to be used 2. Define support variables 3. Initialize and start the radio 4. Implement the core of the application 5. Implement all the events of the used interfaces

56 Module Component Define the interfaces to be used: module RadioCountToLedsC { uses interface Packet; uses interface AMSend; uses interface Receive; uses interface SplitControl as AMControl; } Define some variables: implementation { message_t packet; bool loked;... } Packet Manipulation Interfaces Local Variables Control interface

57 Initialize and Start the Radio event void Boot.booted() { call AMControl.start(); } Events to report Interface Operation event void AMControl.startDone(error_t err) { if (err == SUCCESS) { call MilliTimer.startPeriodic(TIMER_PERIOD_MILLI ); } else { call AMControl.start(); } } event void AMControl.stopDone(error_t err) { }

58 Implement the Application Logic event void MilliTimer.fired() {... if (!locked) { Creates and Set Packet radio_count_msg_t* rcm = (radio_count_msg_t*)call Packet.getPayload(&packet, sizeof(radio_count_msg_t)); rcm->counter = counter; } if (call AMSend.send(AM_BROADCAST_ADDR, &packet, sizeof(radio_count_msg_t)) == SUCCESS) { } locked= TRUE; } Send Packet

59 Implement Events of Used Interfaces event void AMSend.sendDone(message_t* msg, error_t error) { if (&packet == msg) { loked = FALSE; } } Must implement the events referred to all the interfaces of used components.

60 Configuration File implementation {... components ActiveMessageC; components new AMSenderC(AM_RADIO_COUNT_MSG);... App.Packet -> AMSenderC; App.AMSend -> AMSenderC; App.AMControl -> ActiveMessageC; }

61 And What About Receiving? We need a Receive interface We need to implement an event Receive handler event message_t* Receive.receive(message_t* msg, void* payload, uint8_t len) { if (len == sizeof(radio_count_msg_t)) { radio_count_msg_t* rcm= (radio_count_msg_t*)payload; call Leds.set(rcm->counter); } return msg; } We need to modify the configuration component implementation {... components new AMReceiverC(AM_RADIO_COUNT_MSG);... } implementation {... App.Receive -> AMReceiverC; }

62 RadioCountToLeds - Demo Let s have a look at the files Let s see how it works Let s try to turn off a device

63 and Let s go home!

Politecnico di Milano Advanced Network Technologies Laboratory. Internet of Things. TinyOS Programming and TOSSIM (and Cooja)

Politecnico di Milano Advanced Network Technologies Laboratory Internet of Things TinyOS Programming and TOSSIM (and Cooja) 19 March 2018 Agenda Playing with TinyOS Programming and components Blink Application