This lesson demonstrates a simple sensor application that takes light intensity readings (from the sensor board's photo sensor) and displays those readings on the LEDs. This is based on the Sense application, found in apps/Sense. This is a very simple application that reads a value from the light sensor and displays the lower 3 bits of the value on the LEDs. The application configuration is found in Sense.nc and the implementation module in SenseM.nc.

The SenseM.nc component

Let's first look at the top portion of SenseM.nc:

module SenseM {
  provides {
    interface StdControl;
  }
  uses {
    interface Timer;
    interface ADC;
    interface StdControl as ADCControl;
    interface Leds;
  }
}
// Implementation not shown ...

Like BlinkM, this component provides the StdControl interface and uses Timer and Leds. It also uses two more interfaces: ADC, which is used to access data from the analogue-to-digital converter, and StdControl, which is used to initialize the ADC component.

This application uses a new component, TimerC, in place of SingleTimer. The reason is that TimerC allows multiple instance of timers, while SingleTimer only provides a single one that only one component can use. We'll discuss more on Timer a bit later.

Note the line

  interface StdControl as ADCControl;

  interface StdControl as ADCControl;
  interface StdControl as SounderControl;

One related note: if you don't provide an interface instance name then the instance is named the same as the interface. That is, the line

  interface ADC;

  interface ADC as ADC;

Open the file apps/Sense/SenseM.nc.  You'll see the code simply calls ADC.getData() each time Timer.fired() is signaled. Likewise, when ADC.dataReady() is signaled, the internal function display() is invoked, which sets the LEDs to the low-order bits of the ADC value.

Notice the use of the function rcombine() in the implementation of StdControl.init().

  return rcombine(call ADCControl.init(), call Leds.init());

At this point you should be wondering, "how does the Sense application know that the ADC channel should access the light sensor?" This is exactly what the Sense.nc configuration wires up for us.

configuration Sense {
  // this module does not provide any interface
}
implementation
{
  components Main, SenseM, LedsC, TimerC, Photo;

  Main.StdControl -> SenseM;
  Main.StdControl -> TimerC;

  SenseM.ADC -> Photo;
  SenseM.ADCControl -> Photo;
  SenseM.Leds -> LedsC;
  SenseM.Timer -> TimerC.Timer[unique("Timer")];
}

Most of this should be familiar from Blink. We're wiring up the Main.StdControl to SenseM.StdControl, as before. The Leds wirings is also similar to Blink, and we'll discuss Timer in a minute. The wiring for the ADC is:

  SenseM.ADC -> Photo;
  SenseM.ADCControl -> Photo;

Remember that

  SenseM.ADC -> Photo;

  SenseM.ADC -> Photo.ADC;

  SenseM.ADControl -> Photo;

  SenseM.ADC -> Photo.ADCControl;

  SenseM.ADControl -> Photo;

  SenseM.ADControl -> Photo.StdControl;

Let's look at the line

  SenseM.Timer -> TimerC.Timer[unique("Timer")];

A parameterized interface allows a component to provide multiple instances of an interface that are parameterized by a runtime or compile-time value. Recall that it's possible for a component to provide multiple instances of an interface and to give them different names, e.g.,

  provides {
    interface StdControl as fooControl;
    interface StdControl as barControl;
  }

  provides interface Timer[uint8_t id];

In this case, we want TinyOS applications to create and use multiple timers, each of which can be managed independently. For example, an application component might need one timer to fire at a certain rate (say, once per second) to gather sensor readings, while another component might need the a timer to fire at a different rate to manage radio transmission. By wiring the Timer interface in each of these components to a separate instance of the Timer interface provided by TimerC, each component can effectively get its own "private" timer.

When we say TimerC.Timer[someval], we are specifying that BlinkM.Timer should be wired to the instance of the Timer interface specified by the value (someval) in the square brackets. This can be any 8-bit positive number. If we were to specify a particular value here, such as 38 or 42, we might accidentally conflict with the timer being used by another component (if that component used the same value in the brackets). So, we use the compile-time constant function unique(), which generates a unique 8-bit identifier from the string given as an argument. Here,

  unique("Timer")

  uniqueCount("Timer")

will count the number of uses of unique("Timer").
 

Running the Sense application

As before, just do a make mica install in the Sense directory to compile and install the application on your mote. You'll need a sensor board attached to the mote with a photo sensor. The Mica sensor board, for example, snaps into place via the 51 pin connector. The type of sensorboard is selected by the -board command line option to ncc. On the Mica mote, the default sensor board type is micasb. However, if you have an older ("basic") sensor board, you might need to pass in the -board basicsb option to ncc. To do this, edit the Makefile in the Sense directory and add the line SENSORBOARD=basicsb before the line that includes Makerules. The sensor boards supported by TinyOS are represented by the directory names in tos/sensorboards .

The operation of the photo sensor is a bit unusual. The ADC yields a 10-bit digitized sample of the photo sensor. What we would like is for the LEDs to be off when the node is in the light, and on when the node is in the dark. Here, we are looking at the upper three bits of this data coming from the ADC, and inverting the value. Note the line:

  display(7 - ((data >> 7) & 0x7));

Note that when running the application you may really have to cover up the photo sensor pretty well to get it to respond - we'll admit that this is not the best application to really see the photo sensor at work!
 

Exercises

Extend the capability of the application by chirping the sensor board's sounder when it is dark! The TinyOS component for the Sounder is located in tos/sensorboards/micasb/Sounder.nc and provides the StdControl interface. Modify SenseM.nc to add a StdControl as SounderControl, wiring it as appropriate in Sense.nc.  Remember to call init() to initialize the Sounder component. To make the sounder turn on from SenseM.nc, call SounderControl.start(). To turn off the sounder, call SounderControl.stop(). Be sure to test this new application many times to annoy everyone sitting around you.