DIMS Foundry - TINY Platform // Standard

Introduction
The TINY DIMS platform is based on tinyOS and Atmel-based motes, available, for instance from Crossbow or MoteIV.

The vision behind this "tiny" platform stems from the "SmartDust" projects, conducted at the California University at Berkeley. The vision can be put rather simply;

Tiny Intelligent Sensors - everywhere!
The sensors should be complete computers, gathering data on everything like light, temperature, humidity, acceleration etc.
They should be able to form ad-hoc networks and send data to where its needed.
They should be able to run years on batteries - or be able to "extract" power from their environment and run almost indefinately.

Some visions on applications of such technology is expressed in books from the author Vernor Vinge. Like Harry Goldstein expresses in an article in June 2004 IEEE Spectrum;

-"In the cool toys category, some of the most compelling and detailed scenarios have come from Vernor Vinge, a science fiction author and former computer science professor at San Diego State University.

[..]Vinge's sensor planet of 2020 teems with billions of wireless ultrawideband communications nodes connected to countless pinhead-size cameras, microphones, motion detectors, and biometric and other sensors to form a fine-grained mesh of networks that cover every square millimeter of the globe. Equipped with full-color, see-through displays that cover each pupil like a contact lens and clothing that senses muscle twitches, people will exploit an immensely sophisticated successor of today's Internet. They'll be able to immerse themselves in gripping gaming environments, silently communicate with friends just by tensing their muscles, and hunt down information about other people.

In the next 30 years, Vinge believes, we will reach a point where the combination of powerful processors, limitless data-storage capacity, ubiquitous sensor networks, and deeply embedded user interfaces will create a bond between human and machine "so intimate that users may reasonably be considered superhumanly intelligent."

In todays technology - what could be typical applications of sensor technology? Weel, we think that there are lost of possibilities.

Sensor-net can help you make:

a network of water and electricity meters, that can use one another to get their results to where they are needed.
sensors can be applied to production facilities and machines and monitor their condition
motes spread out on fields, for instance wine-fields, could measure and report on micro-climates
building janitor can monitor the state of a building
biologists can monitor animals and their environment by using motes... ON the animals
you can monitor traffic, roads, velocity... etc. - in a new and cheap way!

This page in the DIMS Foundry will give you some starting-points on how to proceed onwards in the exciting world of intelligent, wireless sensors.

The hardware platform

Intelligent, wireless sensors are sometimes called "motes" (ie. stemming from the "SmartDust" project). We define the mote hardware platform as a platform which has an implementation of the open source operating-system tinyOS available. Mainly, Crossbow and moteIV provides commercially available platforms.

Crossbow, a company that can count Cisco and Intel amongst it's investors, offers, amongst others, the Mica2 and Mica2Dot motes.

The Mica2Dot is the smallest of the two, and sports the following features:

868/916, 433MHz or 315 Mhz multichannel transceiver
ATmel ATmega128L based.
Integrated ADC,DAC
TinyOS Support
On Board Temperature Sensor, Battery Monitor and LED
Quarter sized (25mm)

The Mica2 boast more LEDs (3 instead of 1), AA battery compatibility and a 51pin expansion connector with support for I2C and SPI.

moteIV, a relatively new company, offers the tMote sky.
The tMote has the following properties:

250kbs 2.4Ghz IEEE 802.15.4 Chipcon Wireless Transceiver
8MHz Texas Instruments MSP430 microcontroller (10k RAM, 48 Flash)
Integrated ADC,DAC
Onboard antenna with 50m range indoors, 125m range outdoors
Programming and data collection via integrated USB connector
TinyOS Support

The software platform
Motes (at least the platforms we concern ourselves with in these pages) run TinyOS. At TinyOS.net, the operating system is described like this:

"TinyOS is an open-source operating system designed for wireless embedded sensor networks. It features a component-based architecture which enables rapid innovation and implementation while minimizing code size as required by the severe memory constraints inherent in sensor networks. "

TinyOS was developed at UC Berkeley - and is Open Source. It's a compact and efficient OS, that supports R&D on motes very well. You program TinyOS app's with NesC (see later).

The overall architecture of TinyOS is simple:

Compared to many other operating systems, TinyOS has:

No Core (direct hardware manipulation)
No Process handling (only one proces)
No Virtual memory (only one linear physical addressspace)
No Dynamic memory allocation (everything is taken care oif at compile time)

TinyOS consists of less than 200 components of which half are actual code components - the rest are so-called configurations that "wire" code together.

TinyOS is coded in "NesC". To paraphrase "The HitchHikers Guide To The Galaxy": NesC code is somewhat, but totally, unlike ordinary C. Actually, syntax is very much like C - but NesC employs a somewhat intricate component model, where components are assembled (and reused) into application by wireing them together with "configurations". A small example of some NesC code (a configuration) is given below together with a graphical representation of the application that is wired together:

Links to software
A development environment for TinyOS version 1.1.x for windows can be downloaded here. The more than 160Mb download for windows contains TinyOS

TinyOS Tools
NesC
Cygwin
Support Tools
Java 1.4 JDK & Java COMM 2.0
Graphviz
AVR Tools
- avr-binutils 2.13.2.1
- avr-libc 20030512cvs
- avr-gcc 3.3-tinyos
- avarice 2.0.20030825cvs
- avr-insight cvs-pre6.0-tinyos

This is a complete set of tools to generate and test (even simulate) TinyOS and NesC applications. A description of some of the parts is given below:

Cygwin consists of a library that implements the POSIX system call API in terms of Win32 system calls, a GNU development toolchain (such as GCC and GDB) to allow basic software development tasks, and some application programs equivalent to common programs on the UNIX system.
Graphviz is a package of open source tools initiated by AT&T Research Labs that render graphs specified in DOT Language scrips. It also provides libraries for software applications to use the tools. This tools is used to document nesC programs.
AVaRICE: AVaRICE is a program which interfaces the GNU Debugger GDB with the AVR JTAG ICE available from Atmel.
Avr-Binutils is a collection of binary utilities, including avr-ar (for creating, modifying and extracting from archives), avr-as (a family of GNU assemblers), avr-ld (the GNU linker), avr-nm (for listing symbols from object files), avr-objcopy (for copying and translating object files), avr-objdump (for displaying information from object files), avr-ranlib (for generating an index for the contents of an archive), avr-size (for listing the section sizes of an object or archive file), avr-strings (for listing printable strings from files), avr-strip (for discarding symbols), and avr-addr2line (for converting addresses to file and line). This package is for cross-development of AVR programs.
AVR-GCC: gcc compiled for the AVR platform with TinyOS patches. Original source came from the GNU ftp site; the tarball name was modified to reflect the AVR platform and TinyOS mods.
AVR-Insight: This package includes gdb and insight, a graphical user interface to GDB written in Tcl/Tk originally by Red Hat and Cygnus.This version has been tweaked for use with TinyOS.
AVR Libc is a Free Software project whose goal is to provide a high quality C library for use with GCC on Atmel AVR microcontrollers. Together, avr-binutils, avr-gcc, and avr-libc form the heart of the Free Software toolchain for the Atmel AVR microcontrollers.
NesC: nesC is a compiler for a new language (based on C) designed to support the TinyOS project
Tiny-os tools: These are compiled tools for tinyos. The source for the tools is found in the tinyos package.
Tiny-os: ...because size DOES matter.

How to get started
If you use crossbow Mica2 or MicaDots, ensure you have a mote programmer to program your motes. Tellos motes can be connected directly to your PC thru the USB connector.

After using the easy TinyOS windows-installer, it is advisable to verify the system installation - and the hardware you are going to experiment with. These steps are also explained in the more-or-less official TinyOS tutorial. The script "toscheck" checks the TinyOS installation on your windows pc. It should not report any errors (besides a confirmed bug with the java classpath. That warning is probably safe to ignore...). The TinyOS tutorial also describes how to check the hardware (including RF features) with some supplied pieces of nesC software.

Remember (this Information is not directly available in the somewhat dated tutorial) to your mote to a legal radio frequency.

868.0 - 868.6 MHz (Europe)
902.0 - 928.0 MHz (America)
2400.0 - 2483.5 MHz (Global)

This can be done, by adding the flag

CFLAGS += -DCC1K_DEF_FREQ=868260396

(of course you should set the correct freqency) in the makelocal file in your tinyos installation under cygwin (/opt/tinyos-1.x/tools/make).

Now, you can start going thru the tutorial.

Demo application
Here at DELTA we offer you an extra demo application for you to try out on your motes... the Howler

This application uses the so-called "sounder" on the Mica2 motes most standard sensor-board. The application registers low light - and beeps thru the sounder, while sending a message to any motes that care listen... It illustrates how easy it is to reuse software components in new configurations. The application uses the following components:

Main (for the TinyOs scheduler)
HowlerM (our actual code)
LedsC (wrapper for hardware – leds)
TimerC (timer)
DemoSensorC as Sensor (wrapper for the PhotoSensor)
Sounder (Wrapper for beeper)
GenericComm as Comm (Generic active message platform)

The wiring is illustrated below:

If you are interested in honing your nesC skills, now would be a good time to try to implement this your self.

Here is a link to our source-code: The Howler.

How to contribute or learn more
Participate at www.tinyos.net - or send us a mail!

Go to DIMS Foundry frontpage.