TinyOS Tutorial

Jianping Wang(merge several tutorials found online)

TinyOS• TinyOS is an open source operation system

designed for wireless embedded sensor network. It is not a operation for general purpose.

Official website: http://www.tinyos.net/• It features a component-based architecture which

enables rapid development while minimizing code size.

• Supported platforms include Linux RedHat9.0, Windows 2000/XP with Cygwin.

TinyOS versions• 1.0 (Oct 2002)• 1.1 (Sep 2003)• 1.1.1 (Nov 2003) add a new routing module MintRoute,

a new ADC interface.• 1.1.3 (Jan 2004) add B-Mac, a new MAC layer w/

CSMA with collision, etc.• 1.1.4 (Feb 2004) add Tython, which is a TOSSIM (a

TinyOS simulator) scripting environment.• 1.1.5 (Mar 2004) make improvements and bugs fixes to

Tython.• 1.1.6 (May 2004) support PageEEPROM component, a

new make system, for PC platform.• 1.1.7 (July 2004) supports MicaZ and Telos.• 1.1.8 (Oct 2004) support TinyOS network programming

components: Delug, NetProg and TOSBoot.

Serial-line communication in TinyOS• The protocol is based on the PPP in HDLC-like framing

described in RFC-1662.• Components:

• FramerM – provides core framing protocol• FramerAcm – implements ACK processing for inbound packets• UARTFramedPacket – A configuration component incorporating

FrameM and FrameAckM• Applications

• TOBase (apps/TOBase) – simple bridge between serial and wireless chanels

• TransparentBase (apps/TransparentBase) – bridge identical to TOBase but doesn’t check group ID

• GenericBase (apps/GenericBase) – legacy bridge w/o framing or flow control

• Host Tools• net.tinyos.packet.PacketSource (Interface)• Net.tinyos.packet.PhoenixSource (Class)• Net.tinyos.SerialForwarder (Application)

Different platforms need different solutions

Capabili

tie

s

Size, Power Consumption, Cost

MICA Mote

MK - II

StarGate

Spec

Software: atmel tools, java, perl

Highly constrained (memory, cpu, storage, power)

Solutions: TinyOS,…

Environment/Tools

2.25 in

1.25 in

Microphone

AccelerometerLightSensor

TemperatureSensor

Sounder Magnetometer

Environment/Tools

• download TOS distribution and Java JDK from:– http://www.tinyos.net/download.html

• directory structure, after installation:– c:\tinyos\cygwin – installation directory– \opt\tiny-1.x\contrib\xbow\apps {cnt_to_leds, cnt_to_rfm,

sense, …}– \opt\tiny-1.x\docs {connector.pdf, tossim.pdf, …}– \opt\tiny-1.x\tools {toscheck, inject, verify, …}– \opt\tiny-1.x\tos {shared/system components, …}

Environment/Tools

• verify the software installation:– ~\tools\toscheck.exe

• verify the hardware is working:– ~\apps\mica_hardware_verify\make mica– install the mote into the board. Red LED on.– ~\apps\mica_hardware_verify\make mica install.1– ~\apps\mica_hardware_verify\java hardware_check COM1

• TinyOS 1.0 libraries and components are written in an extension of C, called nesC

• Applications are too!– just additional components composed with the

OS components• Provides syntax for TinyOS concurrency and storage

model– commands, events, tasks– local frame variable

• Rich Compositional Support– separation of definition and linkage– robustness through narrow interfaces and reuse– interpositioning

Programming TinyOs

• A TinyOS application consists of one or more components.

• A component provides and uses interfaces.– A interface defines a set of functions called

commands.• There are two types of components in nesC:

– Modules. It implements application code.– Configurations. It assemble other components

together, called wiring.

TinyOs Components (1)

TinyOs Components (2)

• Component interface:– commands accepts (implemented)– commands uses– events accepts (implemented)– events uses

• Component implementation– functions that implement interface– frame: internal state– tasks: concurrency control

Internal Tasks

Messaging Component

Internal State

Commands Events

• 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

• Interface methods are the external namespace of the component

Timer Component

StdControl Timer

Clock

provides

uses

provides

interface StdControl;

interface Timer:

uses

interface Clock

TinyOs Components (3)

• TinyOS executes only one program consisting of a set of components.

• Two type threads:– Task– Hardware event handler

• Tasks are scheduled to executed and put into a single queue. A task doesn’t preempt another task.

• Hardware event handlers are executed in response to a hardware interrupt. They may preempt the execution of a task and other hardware handler.

– The events and commands executed as part of a hardware event handler must be declared as async.

TinyOs Concurrency Model

Issues/Comments

• System perspective:– simplistic FIFO scheduling -> no real-time guarantees – bounded number of pending tasks– no “process” management -> resource allocation

problematic, e.g. shared resources– software level “bit manipulation”. HW implementation

can provide speed-up and power saving

5/5/2003 MobiSys Tutorial, San Francisco 15

TinyOS Application• TinyOS (TOS) = application/binary image, executable on an TinyOS (TOS) = application/binary image, executable on an

ATmega processorATmega processor• event-driven architectureevent-driven architecture• single-shared stacksingle-shared stack• no kernel, no process management, no memory management, no kernel, no process management, no memory management,

no virtual memoryno virtual memory• 2-level scheduling2-level scheduling• simple FIFO scheduler, part of the mainsimple FIFO scheduler, part of the main

Application = Graph of Components

RFM

Radio byte

Radio Packet

UART

Serial Packet

ADC

Temp photo

Active Messages

clocks

bit

by

tep

ac

ke

t

Route map router sensor appln

ap

pli

ca

tio

n

HW

SWExample: ad hoc, multi-hop routing of photo sensor readings

3450 B code 226 B data

Graph of cooperatingstate machines on shared stack

Application = Graph of Components+Scheduler

• TOS application = graph of components + scheduler

CommunicationActuating Sensing Communication

Application (User Components)

Main (includes Scheduler)

Hardware Abstractions

• main {

// component initialization

while(1) {

while(more_tasks) schedule_task;

sleep;

} // while

} // main

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

RFM

Radio byte

Radio Packet

bit

by

tep

ac

ke

t

event-driven bit-pump

event-driven byte-pump

event-driven packet-pump

message-event driven

active message

application comp

encode/decode

crc

data processing

Dynamics of Events and Threads

bit event filtered at byte layer

bit event => end of byte =>

end of packet => end of msg send

thread posted to start

send next message

radio takes clock events to detect recv

Event-Driven Sensor Access Pattern

• 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

command result_t StdControl.start() {

return call Timer.start(TIMER_REPEAT, 200);

}

event result_t Timer.fired() {

return call sensor.getData();

}

event result_t sensor.dataReady(uint16_t data) {

display(data)

return SUCCESS;

}

SENSE

Timer Photo LED

TinyOS Commands and Events{... status = call CmdName(args)...}

command CmdName(args) {...return status;}

{... status = signal EvtName(args)...}

event EvtName)(args) {...return status;}

TinyOS Execution Contexts

• Events generated by interrupts preempt tasks• Tasks do not preempt tasks• Both essential process state transitions

Hardware

Interrupts

eve

nts

commands

Tasks

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 {...}