Tiny OS

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.
Programming TinyOs
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
TinyOs Components (1)
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.
Component interface:
commands accepts (implemented)
commands uses
events accepts (implemented)
Messaging Component
events uses
Internal State
Component implementation
Internal Tasks
functions that implement interface

frame: internal state
tasks: concurrency control 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
provides
StdControl Timer
provides
interfaceStdControl;
Timer Component
interfaceTimer:
uses
interfaceClock Clock
uses
TinyOs Concurrency Model
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 doesnt 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 Application
TinyOS (TOS) = application/binary image, executable on an
ATmega processor
event-driven architecture
single-shared stack
no kernel, no process management, no memory management,
no virtual memory
2-level scheduling
simple FIFO scheduler, part of the main
5/5/2003 MobiSys Tutorial, San Francisco 7

Application = Graph of Components
application
Route map router sensor appln
Active Messages
packet
Radio Packet Serial Packet Temp photo

SW
Example: ad hoc, multi-hop
routing of photo sensor
UART HW readings
byte
Radio byte ADC
3450 B code
clocks
226 B data
bit
RFM
Graph of cooperating
state machines
on shared stack
Application = Graph of
Components+Scheduler
TOS application = graph of components +
scheduler
main {
// component initialization
while(1) { Main (includes Scheduler)
while(more_tasks)
schedule_task; Application (User Components)
sleep;
} // while
Actuating Sensing Communication
} // main Communication
Hardware Abstractions
TOS Execution Model
commands request action
application comp data processing
ack/nack at every boundary
call cmd or post task message-event driven
events notify occurrence active message
HW intrpt at lowest level event-driven packet-pump
may signal events
packet
Radio Packet crc
call cmds
event-driven byte-pump
post tasks
Radio byte
byte
Tasks provide logical concurrency encode/decode
preempted by events event-driven bit-pump

RFM
bit
TinyOS Commands and Events
{
...
status = call CmdName(args)
...
}
command CmdName(args) {
...
event EvtName)(args) { return status;
... }
return status;
}
{
...
status = signal EvtName(args)
...
}
TinyOS Execution Contexts
Tasks
events
commands
Interrupts
Hardware Events generated by interrupts preempt tasks

Tasks do not preempt tasks
Both essential process state transitions
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
{ task void TskName {
... ...
post TskName(); }
...
}

Tiny OS

Uploaded by

Copyright:

Available Formats

Tiny OS

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tiny OS

Uploaded by

Copyright:

Available Formats

TinyOS

TinyOS is an open source operation system

A TinyOS application consists of one or more

functions that implement interface

5/5/2003 MobiSys Tutorial, San Francisco 7

Route map router sensor appln

Radio Packet Serial Packet Temp photo

Radio byte ADC

HW intrpt at lowest level event-driven packet-pump

may signal events

preempted by events event-driven bit-pump

Hardware Events generated by interrupts preempt tasks

You might also like