System Architecture Directions for Networked Sensors

System Architecture Directions for Networked Sensors Authors: Jason Hill, Robert Szewczyk, Alec Woo, Seth Hollar, David Culler and KristoferPister Adapted from Professor Kinicki’s CS4516 slides Presentation by Evan Frenn

Overview Problem & Motivation Mote Characteristics Hardware… Updated TinyOS (circa 2000) Evaluation TinyOS… Updated Related Work… Updated Conclusion

Introduction Problem  Lack of exploration into system architecture for networked sensors (circa 2000) Motivation Moore’s Law  Possibility of embedded networked sensors Driving example  1 in2 device

Mote Characteristics Low power consumption Software must efficiently use resources to conserve power Concurrency-intensive Coupled with limited physical parallelism  Importance of context switching Diversity of Design and Usage System should not be application specific Robust Operation Addressed?

Hardware… Updated MEMSIC Lotus (2011) ARM Cortex M3 32 bit Processor 10 – 100 MHz 64KB SRAM, 512KB Flash, 64MB Serial Flash Multicolor LEDs

Solution Introduction TinyOS TinyOS Working Group (Academics + Industry) Version covered: v0.43 Latest stable release: 2.1.2 (August 2012) Averages 35,000 downloads per year Application are written in nesC Event-based Concurrency Model vsStack-based Threaded Model  Advantages? Two-level scheduling HW events + Tasks

TinyOS Design Components Hardware abstraction Synthetic hardware High level software component Four parts: Command handlers Event handlers A fixed-size frame Tasks

Commands Frame Statically allocated Event Handlers Handles hardware interrupts Can modify its own frame, schedule tasks, signal higher level events or lower level commands Small immediate job to perform

Commands Commands Non-blocking requests to lower level components Deposit parameters into lower level frame Conditionally schedule a task Must provide feedback to its caller Small immediate job to perform

Commands Tasks Perform main execution function Atomic with respect to other tasks Can call lower level commands/higher level events and schedule other tasks Run to completion  Single stack Task Scheduler Simple FIFO scheduler Allows for system sleep

Evaluation Small Physical Size In relation to? HW dependent C runtime lib

Evaluation Cont. Concurrency-intensive Software costs Bank switching Efficient modularity Physical parallelism Usage diversity

TinyOS… Updated nesC Dialect of C Aims to reduce RAM size and race conditions Module Each component has a module Provide application code Implements events, commands, tasks Configuration Each application has a configuration Fit components together(wiring) 3 nesC files  Module, Configuration, and Interface

nesC Interfaces Each component provides and uses an interface Interfaces ~= Headers Interface’s user calls commands of the interface’s provider Provider signals event to the interface’s user

Interfaces cont. Interface example: interface Timer { command void startPeriodic (uint32_t interval); event void fired ( ); … }

Module Example module TestModuleC{ uses interface Boot; uses interface Timer; } implementation { event void Boot.booted ( ) { call Timer.startPeriodic(5); } event void Timer.fired(){ //Do something! } }

Module Example cont. module TimerC{ provides interface Timer; } implementation { command void startPeriodic(uint32_t interval){ //do something } }

Configuration Example configuration TestModuleApp{ } implementation { components MainC, TimerC, TestModuleC; TestModule.Boot -> MainC.Boot; TestModuleC.fired-> TimerC.fired; }

Related Work… Updated Conticki OS Competitor to TinyOS Developed in 2003 by Adam Dunkels Last stable release: July 17, 2012 Designed for “Internet of Things” Uses protothreads as apposed to event model Includes TCP/IP stack  Focus on low power networking stack

Conclusion Did they address robust operation? Build robust system that leads to reliable distributed applications? Show their system was efficient with respect to power consumption? Show their system was generic?

Thank You!

System Architecture Directions for Networked Sensors