TinyOS Programming - PowerPoint PPT Presentation

Loading...

PPT – TinyOS Programming PowerPoint presentation | free to view - id: bc041-ZDc1Z



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

TinyOS Programming

Description:

Review. TinyOS (TOS) = application/binary image, ... Review. the Sensor stack: photo, and temperature sensing components. sits on top of ADC component ... – PowerPoint PPT presentation

Number of Views:139
Avg rating:3.0/5.0
Slides: 42
Provided by: radust7
Category:

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: TinyOS Programming


1
TinyOS Programming
  • by Radu Stoleru
  • CS 851 Presentation, Fall 2002

2
Outline
  • Review
  • Programming model
  • TinyOS 101 the BLINK example
  • Environment/Tools
  • nesC Programming Language
  • Demo
  • Issues/Comments
  • References

3
Review
  • 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

4
Review
  • TOS application graph of components
    scheduler
  • main
  • // component initialization
  • while(1)
  • while(more_tasks) schedule_task
  • sleep
  • // while
  • // main

5
Review
  • Scheduling
  • 2-level scheduling (events and tasks)
  • single shared stack, used by events and function
    calls
  • Tasks
  • are preemptable by events
  • may call commands
  • may signal events
  • not preempted by tasks
  • Events - lowest level events support by hardware
    interrupt
  • INTERRUPT(_output_compare2_)() // Hardware
    Timer Event Handler
  • TOS_SIGNAL_EVENT(CLOCK_FIRE_EVENT)() //
    Software event

6
Review
  • Hardware Abstraction
  • LED (pin numbering/HW wiring)
  • CLOCK (counter interrupt)
  • UART (baud rate control, transfer)
  • ADC (ADC interrupt handling)
  • RFM (abstracts bit level timing, RFM specific
    control logic)

7
Review
  • the Sensor stack
  • photo, and temperature sensing components
  • sits on top of ADC component
  • typical request data, wait for data event

8
Review
  • the Communication stack
  • building up from the RFM bit level
  • bit level abstracts away radio specifics
  • byte level radio component collects individual
    bits into bytes
  • packet level constructs packets from bytes
  • messaging layer interprets packets as messages

9
Review
  • Component interface
  • commands accepts (implemented)
  • commands uses
  • events accepts (implemented)
  • events uses
  • Component implementation
  • functions that implement interface
  • frame internal state
  • tasks concurrency control

10
Programming Model
  • Components
  • .comp specification
  • .C behaviour
  • .desc select and wire
  • specification
  • accepts commands
  • uses commands
  • signals events
  • handles events

comp2 .desc
application .desc
11
Programming Model
  • 4 kinds of components
  • .desc only (ex cnt_to_leds)
  • .C and .comp (ex CLOCK)
  • .desc and .comp (ex GENERIC_COMM)
  • .C, .comp and .desc (ex INT_TO_RFM)

12
Programming Model
  • (4th type) component interface (.comp)
    implementation (.c) wiring (.desc)
  • ltCompNamegt.comp
  • TOS_MODULE ltCompNamegt
  • ACCEPTS
  • // command_signatures
  • HANDLES
  • // event_signatures
  • USES
  • // command_signatures
  • SIGNALS
  • // event_signatures

13
Programming Model
  • ltCompNamegt.c
  • include "tos.h"
  • include ltCompNamegt.h"
  • define TOS_FRAME_TYPE
  • TOS_FRAME_BEGIN(lt CompName gt_frame)
  • // state declaration
  • TOS_FRAME_END(lt CompName gt_frame)
  • char TOS_COMMAND(ltcommand_name)()
  • // command implementation
  • char TOS_EVENT(ltevent_namegt)()
  • // event implementation

14
Programming Model
  • ltCompNamegt.desc
  • // Component Selection
  • INCLUDE
  • MAIN
  • ltCompNamegt
  • ltComp_Igt
  • ltComp_Jgt
  • // Wiring
  • ltCompNamegt.ltcommandgt ltComp_Igt.ltcommandgt
  • ltCompNamegt.lteventgt ltComp_Jgt.lteventgt

15
TOS 101 the Blink example
  • example app that handles the clock events to
    update LEDs like a counter

16
TOS 101 the Blink example
  • blink.desc
  • include modules
  • MAIN
  • BLINK
  • CLOCK
  • LEDS
  • BLINKBLINK_INIT
    MAINMAIN_SUB_INIT
  • BLINKBLINK_START
    MAINMAIN_SUB_START
  • BLINKBLINK_LEDy_on
    LEDSYELLOW_LED_ON
  • BLINKBLINK_LEDy_off
    LEDSYELLOW_LED_OFF
  • BLINKBLINK_LEDr_on
    LEDSRED_LED_ON
  • BLINKBLINK_LEDr_off
    LEDSRED_LED_OFF
  • BLINKBLINK_LEDg_on
    LEDSGREEN_LED_ON
  • BLINKBLINK_LEDg_off
    LEDSGREEN_LED_OFF
  • BLINKBLINK_SUB_INIT
    CLOCKCLOCK_INIT
  • BLINKBLINK_CLOCK_EVENT CLOCKCLOCK_FIRE_EVENT

17
TOS 101 the Blink example
  • blink.comp
  • TOS_MODULE BLINK
  • ACCEPTS //commands
  • char BLINK_INIT(void)
  • char BLINK_START(void)
  • HANDLES // events
  • void BLINK_CLOCK_EVENT(void)
  • USES // commands
  • char BLINK_SUB_INIT(char interval, char scale)
  • char BLINK_LEDy_on() char
    BLINK_LEDy_off()
  • char BLINK_LEDr_on() char
    BLINK_LEDr_off()
  • char BLINK_LEDg_on() char
    BLINK_LEDg_off()
  • SIGNALS //events

18
TOS 101 the Blink example
  • blink.c
  • include "tos.h"
  • include "BLINK.h"
  • //Frame Declaration
  • define TOS_FRAME_TYPE BLINK_frame
  • TOS_FRAME_BEGIN(BLINK_frame)
  • char state
  • TOS_FRAME_END(BLINK_frame)
  • / BLINK_INIT Clear all the LEDs and initialize
    state /
  • char TOS_COMMAND(BLINK_INIT)()
  • TOS_CALL_COMMAND(BLINK_LEDr_off)()
    TOS_CALL_COMMAND(BLINK_LEDy_off)()
  • TOS_CALL_COMMAND(BLINK_LEDg_off)()
  • VAR(state)0
  • TOS_CALL_COMMAND(BLINK_SUB_INIT)(tick1ps)
  • return 1

19
TOS 101 the Blink example
  • blink.c (cont.)
  • / BLINK_START initialize clock component to
    generate periodic events. /
  • char TOS_COMMAND(BLINK_START)()
  • return 1
  • / Clock Event Handler Toggle the Red LED on
    each tick. /
  • void TOS_EVENT(BLINK_CLOCK_EVENT)()
  • char state VAR(state)
  • if (state 0)
  • VAR(state) 1
  • TOS_CALL_COMMAND(BLINK_LEDr_on)()
  • else
  • VAR(state) 0 TOS_CALL_COMMAND(BLINK_LEDr_off)
    ()

20
Environment/Tools
  • OS cygwin/Win2000 or gcc/Linux
  • Software atmel tools, java, perl

mote
Code download
mote-PC comms
programming board
21
Environment/Tools
22
Environment/Tools
  • download TOS distribution and Java JDK from
  • http//webs.cs.berkeley.edu/tos/dist-0.6.1/setup.e
    xe
  • http//java.sun.com/j2se/1.3/download.html
  • directory structure, after installation
  • c\avrgcc
  • \cygwin
  • \nest\apps cnt_to_leds, cnt_to_rfm, sense,
  • \docs connector.pdf, tossim.pdf,
  • \tools toscheck, inject, verify,
  • \tos shared/system components,

23
Environment/Tools
  • verify the software installation
  • c\nest\tools\toscheck.exe
  • verify the hardware is working
  • c\nest\apps\mica_hardware_verify\make mica
  • install the mote into the board. Red LED on.
  • c\nest\apps\mica_hardware_verify\make mica
    install.1
  • c\nest\apps\mica_hardware_verify\java
    hardware_check COM1

24
Environment/Tools
  • build your application
  • code your components (.comp .c files)
  • describe your aplication (.desc file)
  • change/run makefile (mote execution)
  • - set GROUP_ID
  • - make clean make mica make mica install.ltgt
  • change/run makefilePC (PC simulation)
  • - set GROUP_ID
  • - make clean make f makefilePC

25
Environment/Tools
  • simulate your application (on PC)
  • c\nest\apps\blink\binpc\main opts lt nodesgt
  • inject packets into the network
  • c\nest\tools\net\tinyos\tossim\java
    NetworkInjector
  • visualize network traffic
  • c\nest\tools\net\tinyos\tossim\java TossimGUI
  • use static routes
  • edit c\nest\apps\router\router\cells.txt
  • c\nest\tools\tos\pc\binpc\main r static lt
    nodesgt

26
Environment/Tools
  • SerialForwarder multiple clients communicate
    with a base station mote
  • c\nest\tools\net\tools\SerialForwarder\java
    SerialForward -no-gui -port 9001 source serial
    -comm COM2 -packetsize 15

27
nesC Programming Language
  • Goals
  • pragmatic low-level language for programming
    motes
  • intermediate language for future high-level
    languages

28
nesC Programming Language
  • Components
  • implementation
  • - module C behaviour
  • configurationselect and wire
  • interfaces
  • provides interface
  • requires interface

comp3
comp1 module
comp4
comp2 configuration
application configuration
29
nesC Programming Language
  • 2 kinds of components
  • configuration was .desc and .comp
  • module was .C and .comp

30
nesC Programming Language
  • Connect configurations
  • configuration app
  • implementation
  • uses c1, c2, c3
  • c1 -gt c2 // implicit interface sel.
  • c2.out -gt c3.triangle
  • c3 lt- c2.side
  • Partial configurations
  • component c2c3
  • provides interface triangle t1
  • implementation
  • uses c2, c3
  • t1 -gt c2.in
  • c2.out -gt c3.triangle
  • c3 lt- c2.side

31
nesC Programming Language
  • modules
  • module C1
  • requires interface triangle
  • implementation ...
  • module C2
  • provides interface triangle in
  • requires
  • interface triangle out
  • interface rectangle side
  • implementation ...
  • module C3
  • provides interface triangle
  • provides interface rectangle
  • implementation ...

32
nesC Blink example
  • blink.td (configuration)
  • configuration Blink
  • implementation
  • uses Main, BlinkM, Clock, Leds
  • Main.SimpleInit -gt BlinkM.SimpleInit
  • BlinkM.Clock -gt Clock
  • BlinkM.Leds -gt Leds

33
nesC Blink example
  • blinkM.td (module)
  • module BlinkM
  • provides
  • interface SimpleInit
  • requires
  • interface Clock
  • interface Leds
  • implementation
  • bool state
  • command result_t SimpleInit.init()
  • stateFALSE return SUCCESS
  • ...

34
nesC Blink example
  • blinkM.td (module)
  • ...
  • command result_t SimpleInit.start()
  • return call Clock.setRate(128, 6)
  • event result_t Clock.fire()
  • state !state
  • if(state) call Leds.redOn()
  • else call Leds.redOff()

35
nesC Programming Language
  • nesc1 takes a component and
  • checks nesC errors
  • checks (most) C errors
  • generates one C-file for the application
  • avr-gcc compiles nesc1 output
  • generated code has line directives, so clean
    error messages

36
nesC Programming Language
37
nesC Programming Language
  • nesC much nicer to use than TinyOS
  • no more obscure C compiler warnings/errors
  • no more obscure bugs due to typos
  • produces smaller code than TinyOS
  • get rid of the macros for frames, commands,
    events
  • eliminate wiring error through type checking
  • simplify wiring by using interfaces
  • increase modularity by separation of interfaces
    and modules

38
Demo
  • one mote running
  • cnt_to_led
  • two motes running
  • cnt_to_rfm_and_led
  • rfm_to_led

39
Issues/Comments
  • Programming perspective (TOS)
  • no memory protection -gt easy to corrupt/crash the
    system
  • not much compile time error type checking.
  • heavy use of macros
  • a lot of shaky perl code
  • not much code optimization
  • no support for common idioms FSM-like programs,
    atomicity

40
Issues/Comments
  • System perspective
  • simplistic FIFO scheduling -gt no real-time
    guarantees
  • bounded number of pending tasks
  • no process management -gt resource allocation
    problematic, e.g. shared resources
  • software level bit manipulation. HW
    implementation can provide speed-up and power
    saving

41
References
  • http//today.cs.berkeley.edu/tos/
  • http//webs.cs.berkeley.edu/retreat-6-02
  • C. Lu Berkeley Motes and TinyOS, CS851
    Presentation, 2001
  • T. He Get Started with TinyOS, CS851
    Presentation, 2001
About PowerShow.com