Lab 3

1

Lab 3

Objectives Case study: “Hello world” program on motes Write you first program on mote

2

First Steps in TinyOS and nesC ProgrammingTimer Application: MyApp

Application directory contents Do and Dissect

Configuration Wiring

Module StdControl Timer Leds

3

First Steps in TinyOS Programming

What files needed in an application directory?

How to use the Timer and LED components?

How to compile and download an application to a Mote?

Application: MyApp in /MoteWorks/apps/tutorials/lesson_1/

4

About MyApp

This timer application uses one of the timers on the ATmega128L Mote. The timer will be set to fire continuously

every second and the Mote red LED will toggle on and off to show this visually.

So why go through the trouble of this program? This is TinyOS’ version of “Hello World” To help you learn TinyOS and nesC

programming methods

5

/** * This configuration shows how to use the Timer and LED components**/ configuration MyApp {}implementation { components Main, MyAppM, TimerC, LedsC; Main.StdControl -> TimerC.StdControl; Main.StdControl -> MyAppM.StdControl; MyAppM.Timer -> TimerC.Timer[unique("Timer")]; MyAppM.Leds -> LedsC.Leds;}

The MoteWorks/apps/tutorials/lesson_1/MyApp

MyApp.nc configuration

Specifying the INTERFACE

Specifying the IMPLEMENTATION TimerC LedsC

Main

MyApp_Timer

MyApp

StdControl

StdControl

Timer Leds

LedsTimerStdControl

6

Lab Outline

1. Enter/review all necessary code and auxiliary files

2. Build (compile) and download the application3. Take a closer look at the code and auxiliary files

You need One MICA Mote: standard editions of MICA2 (MPR4x0)

or MICAz (MPR2400). One gateway/programming board: MIB510, MIB520, or

MIB600 and the associated hardware (cables, power supply) for each

A Windows PC with MoteWorks installed

7

MyApp Application Review

The application folder (directory) is where all your top-level application code and associated files will be stored.

Navigate to the directory /MoteWorks/apps/tutorials/lesson_1

8

Seven Common Files in an Application Directory

1. Makefile2. Makefile.component3. Top-level application configuration written in

nesC4. Top-level application module written in nesC5. sensorboardsApp.h file (not seen here, but

typical for applications using sensors and GPIO)6. appFeatures.h (optional)7. README (optional, but highly recommended)

9

MyApp Application: Makefile

include Makefile.componentinclude $(TOSROOT)/apps/MakeXbowlocalinclude $(MAKERULES)

10

MyApp – Makefile.component

This file describes the top level application component, MyApp, and the name of the sensorboard we are going to use.

The sensorboard reference tells the compiler we want to use the nesC components for accessing the sensor devices on that board. The collection of those components is also known

as a “driver”

COMPONENT=MyAppSENSORBOARD=mts310

11

First Steps in TinyOS and nesC Programming

Application: MyApp Application directory

contents Do and Dissect


Module StdControl interface Timer interface

12

MyApp – Top Level Configuration

We might have comments Application name The list of components Wiring

/** * <Some comments about the top-level application>**/ configuration <Application_Name> {}implementation { components <comma separated listed of components>; <User.Interface -> Provider.Interface>;}

13


What is Main? /** * This configuration shows how to use the Timer and LED components**/ configuration MyApp {}implementation { components Main, MyAppM, TimerC, LedsC; Main.StdControl -> TimerC.StdControl; Main.StdControl -> MyAppM.StdControl; MyAppM.Timer -> TimerC.Timer[unique("Timer")]; MyAppM.Leds -> LedsC.Leds;}

14

Main – the scheduler for TinyOS

A TinyOS application = configuration (wiring) of new and existing components + the component Main.

Main, the scheduler, runs the tasks created by those components.

A TinyOS top-level application must have the Main component in its configuration.

15

Main cont’d

Main is a component that is executed first in a TinyOS application.

The command Main.StdControl.init()is the first command executed in TinyOS followed by Main.StdControl.start().

StdControl is a common interface used to initialize, start, and stop TinyOS components.

configuration Main { uses interface StdControl;}implementation{ components RealMain, PotC, HPLInit;

StdControl = RealMain.StdControl; RealMain.hardwareInit -> HPLInit; RealMain.Pot -> PotC;}

16


Why does the component TimerC provide a unique Timer?

/** * This configuration shows how to use the Timer and LED components**/ configuration MyApp {}implementation { components Main, MyAppM, TimerC, LedsC; Main.StdControl -> TimerC.StdControl; Main.StdControl -> MyAppM.StdControl; MyAppM.Timer -> TimerC.Timer[unique("Timer")]; MyAppM.Leds -> LedsC.Leds;}

17

Parameterized Interfaces (1 of 2)

There may be multiple users of a component One Timer component but many users with

different event time requirements When a Timer “fires” which component should be

signaled?

TinyOS handle this using parameterized interfaces Multiple instantiations of a component’s Interface Parameter specifies the specific instance

18

Parameterized Interfaces (2 of 2)

A parameterized interface allows a component to provide multiple instances of an interface

Parameterization (or indexing) is set by a compile-time value

provides interface Timer[uint8_t id];

Total number of instances permitted may be limited by implementation

19

nesC Concepts – Unique Instances

To make sure your instance parameter is not used by someone else, use unique(“astring”) Generates an 8-bit identifier from the string given as

an argument. Multiple components using

timer[unique(“Timer”)]

are each guaranteed to get a signal associated with their specific timer settings.

All components must use the same “astring” In our app ”Timer” is used as the astring

20

First Steps in TinyOS and nesC Programming

Application: MyApp Application directory

contents Do and Dissect


Module StdControl interface Timer interface

21

MyApp – Top Level Module

The application’s module is located in MoteWorks/apps/tutorial/lesson_1/MyAppM.nc The function of this code is to start a

timer and toggle the red LED on the Mote.

22


/** * This module shows how to use the Timer and LED components**/ module MyAppM { provides { interface StdControl; } uses { interface Timer; interface Leds; }}

The MyAppM module provides the interface StdControl.

To provide an interface means that MyAppM must implement that interface.

As explained earlier, this is necessary to get the MyApp component initialized and started.

The first part of the code states that this is a module called MyAppM and declares the interfaces which are prefaced by the keywords provides and uses.

1 of 3

23


/** * This module shows how to use the Timer and LED components**/ module MyAppM { provides { interface StdControl; } uses { interface Timer; interface Leds; }}

In many nesC applications, it is common to call a function periodically.

Done by means of a timer.

We also want to use one of the LEDs, so we use an interface to the LED

The name for the interface for a timer is, conveniently enough Timer.

The name for the interface for an LED is Leds.

1 of 3

24

nesC Interface – The StdControl Interface (review)

The StdControl interface (like the component Main) must always be implemented at the top-level application. The StdControl interface provides the basic functionality for

the TinyOS application to be initialized, started and stopped.

StdControl is like a power switch to turn on and off components Also does boot time initialization

StdControl should not be used for continuous processing Use a timer instead

25

StdControl Interface Details

In /MoteWorks/tos/interfaces/StdControl.nc

StdControl defines three commands: init(),start(), and stop().

init() is called when a component is first initialized start() is called to execute a component stop() is called when a components is stopped. init() can

be called multiple times but will never be called after either start() or stop() is called.

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

26

Mote About the Timer Interface

interface Timer { command result_t start(char type, uint32_t interval); command result_t stop(); event result_t fired();

Here we see that Timer interface defines two commands

start() and stop() commands

and one event fired() event

What is “result_t”? It is the data type for the status value returned by a

command or event. This status value is either SUCCESS or FAIL.

27

Mote About the Timer Interface (cont’d)


The start() command is used to specify the type of the timer and the interval at which the timer will expire.

The unit of the interval argument is millisecond.

The valid types of timers TIMER_ONE_SHOT

Ends after the specified interval

TIMER_REPEAT Goes on and on until it is stopped by the stop() command.

28

MyApp – Timer interface (cont’d)


How does an application know that its timer has expired? When it receives an event.

What is an event? A signal from the implementation of an interface that

something has occurred. In this case, the fired() event is signaled when the time

interval has passed.This is an example of a bi-directional interface

An interface can both provide commands that can be called by users of the interface, and signal events of call handlers implemented by the user.

Remember: A module that uses an interface must implement the events that this interface uses.

29

MyApp – Top Level Moduleimplementation { /** * Initialize the components. * * @return Always returns <code>SUCCESS</code> **/ command result_t StdControl.init() { call Leds.init(); return SUCCESS; } /** * Start things up. This just sets the rate for the clock

* component. * * @return Always returns <code>SUCCESS</code> **/ command result_t StdControl.start() { // Start a repeating timer that fires every 1000ms return call Timer.start(TIMER_REPEAT, 1000); }

The MyAppM module implements the StdControl.init(), StdControl.start(), and StdControl.stop() commands, since it provides the StdControl interface.

1 of 6

30



The init() command in the implemented StdControl interface simply initializes the Leds subcomponent (by calling Leds.init()).

2 of 6

31



The start() command invokes Timer.start() to create a repeat timer (“TIMER_REPEAT”) that expires every 1000 msec.

3 of 6

32

MyApp – Top Level Module/** * Halt execution of the application. * This just disables the clock component. * * @return Always returns <code>SUCCESS</code> **/ command result_t StdControl.stop() { return call Timer.stop(); }

/** * Toggle the red LED in response to the <code>Timer.fired</code> * event. * * @return Always returns <code>SUCCESS</code> **/ event result_t Timer.fired() { call Leds.redToggle(); return SUCCESS; }}

stop() terminates the timer.

4 of 6

33

MyApp – Top Level Module/** * Halt execution of the application. * This just disables the clock component. * * @return Always returns <code>SUCCESS</code> **/ command result_t StdControl.stop() { return call Timer.stop(); }


The Timer.fired() event is implemented. This is necessary since MyAppM must implement any event from an interface it uses..

5 of 6

34

MyApp_Timer – Top Level Module/** * Halt execution of the application. * This just disables the clock component. * * @return Always returns <code>SUCCESS</code> **/ command result_t StdControl.stop() { return call Timer.stop(); }


Each time Timer.fired() event is triggered, the Leds.redToggle() toggles the red LED.

6 of 6

35

MyAppM.nc – Key Lessons

The heart of most TinyOS applications is Timer.fired()

Compare to C where main() contains a while loop

A while loop in StdControl.init() would freeze the system and block all tasks

The proper way to centralize processing in TinyOS is to start a repeat timer (with REPEAT_TIMER) and implement logic in Timer.fired().

36

First Steps in TinyOS and nesC ProgrammingApplication: MyApp

Application directory contents Do and Dissect


Module StdControl Timer

Programming with Programmer’s Notepad

37

Compiling and Flashing the Mote

1. Now that you have reviewed all the application files, you can proceed with the compilation and flashing of the Mote You need to be in the .nc of the app file you want to

compile and program before you can execute shell commands from Programmer’s Notepad.

2. Attach one Mote to a Programmer/Gateway Board One of MIB510, MIB520, MIB600 One of MICAz, MICA2

3. Compile your application: Select Tools > make mica2 (or make micaz or make

mica2dot) The “Output” section of the Programmers Notepad will

print the compiling results.

38

39

MyApp – Compiling and Flashing the Mote

4. Flash your Mote: Select Tools > shell In the command line type

make <platform> install,<n>

mica2, ormicaz, ormica2dot

40

Vocabulary

ApplicationComponentModuleConfigurationInterfaceMakefileMakefile.componentnesCTinyOSProvidesUsesimplementation

CommandEventCall Return – SUCCESS, FAILMakeStdControl – init(), start(), stop()TimerMLeds interfaceLedsCTimer interface -- TIMER_REPEAT, TIMER_ONE_SHOTdocs

41

What you need to do?

Review the slides and source code carefully. Make sure you understand.

Work on Lab 3 Due 2/24, 1pm

Date post:	12-Jan-2016
Category:	Documents
Upload:	marlo
View:	38 times
Download:	0 times

Lab 3

Documents