This book provides an in-depth introduction to writing nesC code for the TinyOS 2.0 operating system.

While it goes into greater depth than the TinyOS tutorials on this subject, there are several topics that are

outside its scope, such as the structure and implementation of radio stacks or existing TinyOS libraries. It

focuses on how to write nesC code, and explains the concepts and reasons behind many of the nesC and

TinyOS design decisions. If you are interested in a brief introduction to TinyOS programming, then you

should probably start with the tutorials. If you’re interested in details on particular TinyOS subsystems you

should probably consult TEPs (TinyOS Enhancement Proposals), which detail the corresponding design

considerations, interfaces, and components. Both of these can be found in the doc/html directory of a

TinyOS distribution.

While some of the contents of this book are useful for 1.x versions of TinyOS, they do have several

differences from TinyOS 2.0 which can lead to different programming practices. If in doubt, referring to the

TEP on the subject is probably the best bet, as TEPs often discuss in detail the differences between 1.x and

2.0.

For someone who has experience with C or C++, writing simple nesC programs is fairly straightforward:

all you need to do is implement one or two modules and wire them together. The difficulty (and intellectual

challenge) comes when building larger applications. The code inside TinyOS modules is fairly analogous to

C coding, but configurations – which stitch together components – are not.

This book is a first attempt to explain how nesC relates to and differs from other C dialects, stepping

through how the differences lead to very different coding styles and approaches. As a starting point, this

book assumes that

1. you know C, C++, or Java reasonably well, understand pointers and that

2. you have taken an undergraduate level operating systems class (or equivalent) and know about concurrency,

interrupts and preemption.

Of course, this book is as much a description of nesC as it is an argument for a particular way of using

the language to achieve software engineering goals. In this respect, it is the product of thousands of hours of

work by many people, as they learned and explored the use of the language. In particular, Cory Sharp, Kevin

Klues, and Vlado Handziski have always pushed the boundaries of nesC programming in order to better

understand which practices lead to the simplest, most efficient, and robust code. In particular, Chapter 10 is

an edited version of a paper we wrote together, while using structs as a compile-time checking mechanism

in interfaces (as Timer does) is an approach invented by Cory.

This book is divided into four parts. The first part, Chapters 1–2, gives a high-level overview of TinyOS

and the nesC language. The second part, Chapters 3–7 goes into nesC and TinyOS at a level sufficient

for writing applications. The third part, not included in this online version of the text, goes into more

advanced TinyOS and nesC programming, as is sometimes needed when writing new low-level systems or

high performance applications. The book ends with an appendix summarizing the basic application-level

TinyOS APIs.