Programming Abstractionsin

Wireless Sensor Networks

Professor Jack StankovicDepartment of Computer

ScienceUniversity of Virginia

ImportanceImportance

• Raise the level of abstraction• Move out of the domain of HW and

embedded systems programmer• Amplify the applications addressed –

programmed by domain experts• More reliable

• One of the most important areas of research to make WSN widely used

ContextContext

System DevelopmentEnvironment

Analysis/Tools

Use of SystemSQL/Queries

Actual Programming

Programming ModelsProgramming Models

• Environmental (domain specific, tracking, monitoring, …)– EnviroSuite

• Data/Database Centric - Queries– SQL, TinyBD, Cougar– Statistical and range queries

• Middleware APIs and Services– Group Management, Token machine language

(Regiment), Milan (QoS based), Agilla– Support for other models

• Components• Database• Event • Agent

Programming ModelsProgramming Models

• Components– nesC

• Virtual Machines– Mate

• Functional Macro-programming– Regiment (regions, streams)

• (Mobile) Scripts– SensorWare

• Extend TCL interpreter with support for commands such as query, send, wait, replicate, …

• Provides execution environment for Scripts

• Events– Publish/subscribe– DSWare, SNEDL, Impala

Programming ModelsProgramming Models

• Model Driven• Swarm computing• Java• Linux

Program What?Program What?

• Low level protocols (MAC, routing, …)

• Middleware services• Application• Use of system

– Queries

Blurs

Sensor/Actuator/CommunicationSensor/Actuator/Communication

HeterogeneousHomogeneous

Resource management, team formation, networking, aggregation, …

Severe constraints power, memory, bandwidth, cpu, cost, ...

ReliabilityReliability

• Make an unreliable platform reliable!!

• HW (motes) are/will be very reliable

• Environment/wireless communication will not be reliable

AbstractionsAbstractions

• Program as a whole – not individual nodes

• Hide details (which ones, expose what)– Single node decisions– Asynchrony– Race conditions– False alarms– Retries– Physical details (e.g., location, sensor characteristics,

…)– Faults– Scale– Storage locations

Other QuestionsOther Questions

• How to disseminate programs– Flooding, viral programs, gossip

protocols

• Efficient on small, embedded, real-time devices

• Long-lived systems – Disseminate again– Disseminate pieces of executable

Environmental Paradigm

Environmental Paradigm

• Current Paradigms– Single node abstractions– Explicit interactions between nodes– Read sensor data; fuse data; move data– Set actuators

• Environmental Paradigm– Reflect the physical world directly– Virtual world of entities (fire, people, vehicles,

pesticide, velocity, location, areas, …)

EnviroSuiteEnviroSuite

• Way to think– Events – measurable environmental activities– Events mapped to programming objects– Computation is attached to these objects

• Report location, compute velocity, …

• Library provides protocols for sensor data processing, object maintenance, inter-object coordination, aggregation mechanisms, etc.

personevent

Base Station

vehicleevent

object type: VEHICLE object ID: vehicle01

method:report location to thebase station every 5seconds

attribute: location

object type: PERSON object ID: person01

method:turn on a nearby micro-phone if current locationis less than 1 mile awayfrom the base station

attribute: location

mapping

EnviroSuite

EnviroSuiteEnviroSuite

event-object VEHICLE { object_creation_condition = ferrous object && background sound object_resolution = 6; // minimal distance between // two events object_function = report.Location; object_function = report.Speed;}

ferrous object && background sound

This statement is supported by drivers in a library:

Level of Knowledge Required

Level of Knowledge Required

• Ferrous object– Which signal processing module?– What parameter specifications need to

be made?

– We are programming in an application that interacts with the environment – how divorced from that fact can the programmer be?

Routing Protocol - SPEEDRouting Protocol - SPEED

E2E Di stance

j

FS

iD

Actual Speed

Speed todestination(Set Point )

E2E Delay is bound by E2E Distance/Speed SetPoint

USES VELOCITY

Expose Velocity

Radio Irregularity Radio Irregularity

DOI = Degree of Irregularity

DOI = 0.05 DOI = 0.2

Do NotExpose

Data/Database CentricData/Database Centric

• Query Processing Architectures (SQL-based)– Process the queries– Route the queries– Retrieve information efficiently (in time and

with low energy costs)

• Storage Architectures– How/where to store collected data from

sensors– In-network storage

• At local node• Data centric – name the data and hash to a location• Multi-resolution (hierarchies)

Example of QueryExample of Query

• Retrieve, every 30 seconds, the rainfall level if it is greater than 50 mm

SELECT R.Sensor.getRainfallLevel()FROM RFSensors RWHERE R.Sensor.getRainfallLevel() > 50AND $every(30);

Many other extensions to query capabilityincluding statistical and range based queries

Content Dissemination - Caching

Content Dissemination - Caching

Information source(Aperiodic updates)

Data replicas(Placement?)

Receivers(Refresh Rate,Accuracy)

Goal: Find the optimal communication path to send sensory data from a monitored source to multiple (mobile) sinks such that energy usage is minimized.

Middleware APIsMiddleware APIs

• Group Management– Create– Terminate– Merge– Join/Leave– Assign function

• Track target• Classify target• Map temperature region

– Consensus

Group ManagementGroup Management

IR Camera

Group ManagementGroup Management

IR Camera

Examples: Tracking and

Map Regions

Examples: Tracking and

Map Regions

Base Station

Group Management - APIGroup Management - API

– Create_Group(name,function,criterion,atleast,accuracy) - implicit and explicit

– Destroy_Group(name)– Join()– Leave()– Merge()– Move_COG()– Expand() -- to gain sensing confidence– Shrink() -- to save power– Commit(grp_ID) - to synchronize group re-

configurations

Other ServicesOther Services

• Naming• Directory• Location• Monitor• Configure• …

QuestionQuestion

• How general/specific should a middleware service be?

Function of severity of resource constraints

Severe

Careful interoperabilityExactly what is needed and no more!

ExcessCapacity

More general servicesUseable by many

Functional Macro-Programming (Regiment)

Functional Macro-Programming (Regiment)

• Apply function to data from a stream• Aggregate samples from a stream• Filter stream• Define/Disseminate Events from a

area (region)

AreaBaseStationAbstract

Regions

Streams

Regiment (cont.)Regiment (cont.)

• Set frequency• Fidelity• Contour finding• Combine regions• Anchors (leaders for a region)

• Functional Language

RegimentRegiment

• Abstractions– Streams, Spaces, Events, Anchors

(leader for a region), When (time)– Regions – group of nodes with some

relationship to each other• Like the function for a group in previous

middleware slides• Ex. – all nodes within k radio hops of node N• Ex. – all nodes whose proximity sensor

records a hit

Token Machine Language (TML)Token Machine Language (TML)

• Kind of middleware to support Regiment PL

• Regiment– Compiler transforms a macro-program

written in functional style into an efficient nodal program based on a token machine

– Token machine is an intermediate language (target) for Regiment

TMLTML

NODE

Token Handlers –Atomic Tasks

Token from Network

Name of Token HandlerDataGenerate

Tokens

Components - nesCComponents - nesC

• Underlying execution model (TinyOS)– Tasks and Events– Split phase operation

• Modules– Component Specification – Interfaces– Component Implementation

• Configurations– Wiring Diagrams

Tasks and EventsTasks and Events

• Tasks– Deferred computation– Non-preemptable by other tasks– Scheduled FCFS from task queue

• Events– Execution of an interrupt handler– Runs to completion– Can preempt tasks and can be

preempted by other events

Application ExampleApplication Example

RFM

Radio byte

i2c

Tempphoto

Messaging Layer

clocksbit

byte

packet Radio Packet

Routing Layer

sensing applicationapplication

HW

SW

ADC

messaging

routing

UART Packet

UART byte

Components - nesCComponents - nesC

• The nesC model:– Interfaces:

• uses• provides

– Components:• modules• configurations

• Application:= graph of components

Component A

Component B

ComponentD

Component C

Application

configurationconfigurationComponent

E

ComponentF

EnviroTrack on top ofnesC

InterfacesInterfaces

• Examples of interfaces:

interface StdControl { command result_t init (); command result_t start (); command result_t stop ();}

interface Timer { command result_t start (char type, uint32_t

interval); command result_t stop (); event result_t fired ();}

interface SendMsg { command result_t send (uint16_t

addr, uint8_t len, TOS_MsgPtr

p); event result_t sendDone ();}

interface ReceiveMsg { event TOS_MsgPtr receive (TOS_MsgPtr

m);}

StdControl.nc Timer.nc

ReceiveMsg.ncSendMsg.nc

ModulesModules

• Implements a component’s specification with C code:

module MyCompM { provides interface X; provides interface Y; uses interface Z;}implementation {…// C code}

MyCompM.nc

ModulesModules

• Posting Tasks:

module BlinkM {…}implementation {… task void processing () { if(state) call Leds.redOn(); else call Leds.redOff(); }

event result_t Timer.fired () { state = !state; post processing(); return SUCCESS; }…} BlinkM.nc

Configuration ExampleConfiguration Example

• Blink application• Wiring Example

configuration BlinkC { }

implementation { components Main, BlinkM, ClockC,

LedsC;

Main.StdControl->BlinkM.StdControl; BlinkM.Clock->ClockC; BlinkM.Leds->LedsC;}

ClockC LedsC

Main

BlinkC

BlinkM

BlinkC.nc

Future?Future?

• Different component models?

• nesC components are “low level” with a fair amount of syntax

• Envirosuite, Mate, etc. do build on top of nesC

Mate – Virtual Machine Mate – Virtual Machine

TinyOS

Mate VM(interprets)

24 Instruction ProgramsEach instructionexecutes as task(slow)

Code capsules

Code CapsulesCode Capsules

• One capsule = 24 instructions• Fits into single TOS packet

– Energy efficient

• Atomic reception• Code Capsule

– Type and version information– Types: send, receive, timer, subroutine

• Larger programs – use several capsules

ValueValue

• Re-programmability– Re-task a network

• Parameter adjustment

• Self-replication– One of the special instructions on the

VM is forward (which supports a viral-like infection of the entire network)

• Incremental addition of new nodes

Propagation ExamplePropagation Example

Node Enters the NetworkNode Enters the Network

Instruction SetInstruction Set

One byte per instruction Three classes: basic, s-type, x-type

•basic: arithmatic, halting, LED operation•s-type: messaging system•x-type: pushc, blez

8 instructions reserved for users to define Instruction polymorphism

•Example: add(data, message, sensing)

User Defined Instructions User Defined Instructions

TinyOS

Mate VM(interprets)

24 Instruction Programs

Code capsules InstructionsUnderstood byMate

User defined

1 2 3 4

1 3

3

1

- Sound alarm

- Write to flash

Mate ArchitectureMate Architecture

0 1 2 3

Subroutines

Clo

ck

Sen

d

Receiv

e

Events

gets/sets

0 1 2 3

Subroutines

Clo

ck

Sen

d

Receiv

e

Events

gets/sets

Co

de

OperandStack

ReturnStack

PC

Co

de

OperandStack

ReturnStack

PC

Stack based architecture Operand stack Return address stack

Three events/execution contexts:•Clock timer•Message reception•Message send

Code Example(1)Code Example(1)

• Display Counter to LEDgets # Push heap variable on stackpushc 1 # Push 1 on stackadd # Pop twice, add, push resultcopy # Copy top of stacksets # Pop, set heappushc 7 # Push 0x0007 onto stackand # Take bottom 3 bits of valueputled # Pop, set LEDs to bit patternhalt #

Code Example(2)Code Example(2)

• Sense and Sendpushc 1 # Light is sensor 1sense # Push light reading on stackpushm # Push message buffer on stackclear # Clear message bufferadd # Append reading to buffersend # Send message using built-inhalt # ad-hoc routing system

TinyOS Sense and Send

TinyOS Sense and Sendevent result_t Timer.fired() {

if (state == IDLE && call Photo.sense()) {state = SENSE;}return SUCCESS;

}event result_t Photo.dataReady(uint16_t data) {

if (state == SENSE) {packet->reading = data;if (call SendMsg.send(packet, sizeof(DataBuf)) {

state = SENDING;} else {state = IDLE;}

}return SUCCESS;

}event result_t SendMsg.sendDone(TOS_MsgPtr msg) {

if (state == SENDING) {state = IDLE;}return SUCCESS;

}

Component BreakdownComponent Breakdown

• 7286 bytes code, 603 bytes RAM

QuestionsQuestions

• What should a programmer see?– New language– New middleware– Services– Components– Abstracts models– All the above– None of the above

QuestionsQuestions

• What would have made your life easier in doing the programming assignments?

• What makes it easier to get the system to work?– Debugging tools

• Initially (in programming environment)• On real platform

IdeasIdeas

• Move code to node – executes on middleware, VM, interpreter

• Domain specific (good or bad?)• Regions/Streams• Expose/Hide?

– Performance– Physical systems

• Disseminate

SummarySummary

• Very active area– It must be

• Solutions can have large impact– Applications programmers rather than

system experts

• Standard?– Analogy to real-time computing and

programming languages?• WSN-Java?

Final QuestionFinal Question

• Will there be GP WSNs (and how might that affect the programming abstractions)?