Internship at Sentilla. Chris Merlin March 08 - June 08

Transcription

1 Internship at Sentilla Chris Merlin March 08 - June 08

2 Overview The Sentilla Co. and The Product The smallest platform to carry a JVM Particularities of Coding in Java Application Engineering

3 Sentilla Formerly Moteiv (2003) o Moteiv was focused on hardware (products: tmote-sky, tmote-invent, etc.) o Moteiv used TinyOS Sentilla (2007) now oriented toward software o Adopted Java Simple programming language 6 million Java programmers in the world Small team Venture-backed Company: Onset, Claremont Creek

4 The Sentilla Product: Sentilla Work Focus of Sentilla: to provide Software for quick Pervasive Computing deployments using Java IDE (Sentilla Work): Lets programmers write Java Code Comes with help and tutorials Allows to burn motes with firmware Has to be understood as Windows of WSN: Provides APIs, Drivers, libraries Client can run Java applets to interface with Internet or other elements of computer Manages applications Users write applications for their needs

5 Firmware / MAC MAC: Part of firmware: cannot be changed MAC is Low-Power-Listening scheme: value of LPL interval fixed, but can be chosen to be one of 3 values Passphrase for data encryption: slows communications by factor of 3-4 Communication channel fixed makes subnetwork

6 Overview The Sentilla Co. and The Product The smallest platform to carry a JVM Particularities of Coding in Java Application Engineering

7 The JVM Core based on Ti MSP430 o 16bit, 8MHz CPU o 48K flash on CPU o 10K RAM o 1MB external flash Runs a Java Virtual Machine Now CLDC 1.0 compliant

8 Advantages of Java Object-Oriented programming language: o Particularly well adapted to wireless sensor nodes o Allows to instantiate different objects depending on the mote ID public static void motemain() { long id = [...]; if (id == mote1_id) new app1(); else new app2(); now, code for sender and receiver can be clearly separated

9 (...2) Advantages of Java import com.sentilla.io.*; import com.sentilla.system.*; import javax.measure.*; public class SensorApp { public static class SensorMessage implements Serializable { nx_uint16_t interval; /* Samping period. */ Compact programming language public long address; public Measurable<Temperature> value; public static void motemain() { Sensor<Temperature> temp = SensorDriver.create( mcutemp, Temperature.class); Sender sender = SenderDriver.create( collect ); SensorMessage msg = new SensorMessage(); msg.address = PropertyDriver.open("mac64").readLong(); while (true) { msg.value = temp.read(); if (msg.value.doublevalue(si.celsius) > (double)50) { sender.send( msg ); try { Thread.sleep(1000); catch (Exception e) { e.printstacktrace() #ifndef MULTIHOP_OSCILLOSCOPE_H #define MULTIHOP_OSCILLOSCOPE_H enum { /* Number of readings per message. If you increase this, you may have to increase the message_t size. */ NREADINGS = 5, DEFAULT_INTERVAL = 1024, AM_OSCILLOSCOPE = 0x93 ; typedef nx_struct oscilloscope { nx_uint16_t version; /* Version of the interval. */ nx_uint16_t id; /* Mote id of sending mote. */ nx_uint16_t count; /* The readings are samples count * NREADINGS onwards */ nx_uint16_t readings[nreadings]; oscilloscope_t; #endif configuration MultihopOscilloscopeAppC { implementation { components MainC, MultihopOscilloscopeC, LedsC, new TimerMilliC(), new DemoSensorC() as Sensor; MultihopOscilloscopeC.Boot -> MainC; MultihopOscilloscopeC.Timer -> TimerMilliC; MultihopOscilloscopeC.Read -> Sensor; MultihopOscilloscopeC.Leds -> LedsC; components CollectionC as Collector, // Collection layer ActiveMessageC, // AM layer new CollectionSenderC(AM_OSCILLOSCOPE), // Sends multihop RF SerialActiveMessageC, // Serial messaging new SerialAMSenderC(AM_OSCILLOSCOPE); // Sends to the serial port MultihopOscilloscopeC.RadioControl -> ActiveMessageC; MultihopOscilloscopeC.SerialControl -> SerialActiveMessageC; MultihopOscilloscopeC.RoutingControl -> Collector; MultihopOscilloscopeC.Send -> CollectionSenderC; MultihopOscilloscopeC.SerialSend -> SerialAMSenderC.AMSend; MultihopOscilloscopeC.Snoop -> Collector.Snoop[AM_OSCILLOSCOPE]; MultihopOscilloscopeC.Receive -> Collector.Receive[AM_OSCILLOSCOPE]; MultihopOscilloscopeC.RootControl -> Collector; components new PoolC(message_t, 10) as UARTMessagePoolP, new QueueC(message_t*, 10) as UARTQueueP; MultihopOscilloscopeC.UARTMessagePool -> UARTMessagePoolP; MultihopOscilloscopeC.UARTQueue -> UARTQueueP; #include "Timer.h" #include "MultihopOscilloscope.h" module MultihopOscilloscopeC { uses { // Interfaces for initialization: interface Boot; interface SplitControl as RadioControl; interface SplitControl as SerialControl; interface StdControl as RoutingControl; // Interfaces for communication, multihop and serial: interface Send; interface Receive as Snoop; interface Receive; interface AMSend as SerialSend; interface CollectionPacket; interface RootControl; interface Queue<message_t *> as UARTQueue; interface Pool<message_t> as UARTMessagePool; // Miscalleny: interface Timer<TMilli>; interface Read<uint16_t>; interface Leds; implementation { task void uartsendtask(); static void starttimer(); static void fatal_problem(); static void report_problem(); static void report_sent(); static void report_received(); uint8_t uartlen; message_t sendbuf; message_t uartbuf; bool sendbusy=false, uartbusy=false; oscilloscope_t local; uint8_t reading; /* 0 to NREADINGS */ bool suppress_count_change; event void Boot.booted() { local.interval = DEFAULT_INTERVAL; local.id = TOS_NODE_ID; local.version = 0; // Beginning our initialization phases: if (call RadioControl.start()!= SUCCESS) fatal_problem(); if (call RoutingControl.start()!= SUCCESS) fatal_problem(); event void RadioControl.startDone(error_t error) { if (error!= SUCCESS) fatal_problem(); if (sizeof(local) > call Send.maxPayloadLength()) fatal_problem(); if (call SerialControl.start()!= SUCCESS) fatal_problem(); event void SerialControl.startDone(error_t error) { if (error!= SUCCESS) fatal_problem(); // This is how to set yourself as a root to the collection layer: if (local.id % 500 == 0) call RootControl.setRoot(); starttimer(); static void starttimer() { if (call Timer.isRunning()) call Timer.stop(); call Timer.startPeriodic(local.interval); reading = 0; event void RadioControl.stopDone(error_t error) { event void SerialControl.stopDone(error_t error) { event message_t* Receive.receive(message_t* msg, void *payload, uint8_t len) { oscilloscope_t* in = (oscilloscope_t*)payload; oscilloscope_t* out; if (uartbusy == FALSE) { out = (oscilloscope_t*)call SerialSend.getPayload(&uartbuf); if (len!= sizeof(oscilloscope_t)) { return msg; else { memcpy(out, in, sizeof(oscilloscope_t)); uartlen = sizeof(oscilloscope_t); post uartsendtask(); else { // The UART is busy; queue up messages and service them when the // UART becomes free. message_t *newmsg = call UARTMessagePool.get(); if (newmsg == NULL) { // drop the message on the floor if we run out of queue space. report_problem(); return msg; //Prepare message to be sent over the uart out = (oscilloscope_t*)call SerialSend.getPayload(newmsg); memcpy(out, in, sizeof(oscilloscope_t)); if (call UARTQueue.enqueue(newmsg)!= SUCCESS) { call UARTMessagePool.put(newmsg); fatal_problem(); return msg; return msg; task void uartsendtask() { if (call SerialSend.send(0xffff, &uartbuf, uartlen)!= SUCCESS) { report_problem(); else { uartbusy = TRUE; event void SerialSend.sendDone(message_t *msg, error_t error) { uartbusy = FALSE; if (call UARTQueue.empty() == FALSE) { message_t *queuemsg = call UARTQueue.dequeue(); if (queuemsg == NULL) { fatal_problem(); return; memcpy(&uartbuf, queuemsg, sizeof(message_t)); if (call UARTMessagePool.put(queuemsg)!= SUCCESS) { fatal_problem(); return; post uartsendtask(); event message_t* Snoop.receive(message_t* msg, void* payload, uint8_t len) { oscilloscope_t *omsg = payload; report_received(); // If we receive a newer version, update our interval. if (omsg->version > local.version) { local.version = omsg->version; local.interval = omsg->interval; starttimer(); // If we hear from a future count, jump ahead but suppress our own // change. if (omsg->count > local.count) { local.count = omsg->count; suppress_count_change = TRUE; return msg; event void Timer.fired() { if (reading == NREADINGS) { if (!sendbusy) { oscilloscope_t *o = (oscilloscope_t *)call Send.getPayload(&sendbuf); memcpy(o, &local, sizeof(local)); if (call Send.send(&sendbuf, sizeof(local)) == SUCCESS) sendbusy = TRUE; else report_problem(); reading = 0; /* Part 2 of cheap "time sync": increment our count if we didn't jump ahead. */ if (!suppress_count_change) local.count++; suppress_count_change = FALSE; if (call Read.read()!= SUCCESS) fatal_problem(); event void Send.sendDone(message_t* msg, error_t error) { if (error == SUCCESS) report_sent(); else report_problem(); sendbusy = FALSE; event void Read.readDone(error_t result, uint16_t data) { if (result!= SUCCESS) { data = 0xffff; report_problem(); local.readings[reading++] = data; // Use LEDs to report various status issues. static void fatal_problem() { call Leds.led0On(); call Leds.led1On(); call Leds.led2On(); call Timer.stop(); static void report_problem() { call Leds.led0Toggle(); static void report_sent() { call Leds.led1Toggle(); static void report_received() { call Leds.led2Toggle();

10 (...3) Advantages of Java Dynamic memory allocation o Garbage collector o Supported Objects: Strings Arrays of variable size Native code still used for interfacing with hardware Multi-threading 6,000,000+ Java Programmers in the World (200,000 TinyOS)

11 Disadvantages of Java Slower than native code (4 orders of magnitude) I measured 17ms to toggle LEDs! JVM takes a large part of the available resources Forces to use swapping: slow

12 Overview The Sentilla Co. and The Product The smallest platform to carry a JVM Particularities of Coding in Java Application Engineering

13 Driver Instantiation Since OO programming language, every layer of the stack becomes an Object To send a packet: instantiate a SenderDriver as such: public class Message Implements Serializable { public float data; Sender sender = SenderDriver.create( local ); Message msg = new Message(); sender.send(msg); Instantiate Receiver, Sender, Leds, messages, DigitalPins, VoltageAdc, etc.

14 Interrupts Java offers a relatively simple way to handle events/interrupts Need to instantiate an InterruptPin (for instance) Two solutions: Invoke blocking calls: the thread hangs until specified timeout or event completed pin.block().wait(timeout); Blocking call stops thread may need to create other threads for rest of program If loop cannot be stopped, keep checking whether event has happened or not pin.isdone();

15 ( 2) Interrupts Receiver has a blocking call: can specify timeout after which thread continues if no packet received (ACKs) InterruptPin s can specify rising / falling edge, or either Go hand-in-hand with atomicity concerns

16 Atomicity Handled very differently than in TinyOS x.x No tasks No synchronous or asynchronous events No events Use of lock (a mutex): Declare an Object that will be your mutex Enter a Synchronized block; locks mutex The code within Synchronized blocks over the same mutex is mutually exclusive At end of block, release mutex (convention)

17 Sample Code public class LeftMonitorThread extends Thread{ public LeftMonitorThread(){ msg.countin = 0; msg.countout = 0; public void run(){ int direction; while(true){ direction = 0; leftbeam.edge(false, true); synchronized(lock){ lasttimelefttripped = ava.lang.system.currenttimemillis(); lock.notifyall(); Thread.sleep(100); if (!leftbeam.read()){ synchronized(lock){ lasttimelefttripped = 0; lock.notifyall(); If other beam broken less than 700ms ago: person else{ synchronized(lock){ if (lasttimelefttripped - lasttimerighttripped < 700){ msg.countout++; lasttimelefttripped = 0; direction = -1; lock.notifyall(); displayleds(direction, (short)2, (direction == 0? false : true)); Probably was nothing (a fly)

18 Tricks and Customs Coding in Java for extremely small platforms unusual Same ideas apply as when first cell phones appeared and were running Java Do not keep re-instantiating / Reuse objects Take allocations out of loop Have as many blocking commands as possible Avoid loop that keeps checking status (keeps CPU in sleep mode) Threads are expensive (2) Keep number of classes low to reduce look-up Use fewer LEDs (3mA per LED) / blink them Avoid frequent packets Use raw values whenever possible (for accelerometer, etc.)

19 Debugging Java throws Exceptions when normal flow of execution is interrupted Exceptions are propagated and appear on console The JCreate has 8LEDs Problem: native code cannot be debugged without help of JTag

20 Overview The Sentilla Co. and The Product The smallest platform to carry a JVM Particularities of Coding in Java Application Engineering

21 Application Engineering Consists in a team of 3 engineers The team is the service side of the business model Writing applications for the office to showcase Developing applications for conferences Providing services for customer s specific needs (energy scavenging, deployment challenges, etc.) Developed JCreate as a prototyping platform: Has a MSP430 based core Has an accelerometer 8 LEDs 2 AAA batteries

22 The JCreate Accelerometer 3-axis accelerometer built in JCreate Formerly, only 1 channel of ADC could be sampled before return statement Code for multiple channel samples: o Sequential mode o Channels to sample placed in array of variable size (in TinyOS!) o Values returned in buffer of variable size For 3 read operations, time went from 30ms to 10ms

23 Java Accelerometer Driver Instantiates ADC pins (constructor argument is pin number), allocates memory Starts the Accelerometer chip Sets sensitivity Keeps track of monitored axis Gets raw values (4B int) x is raw value Voltage = x >> 20 (or division by )

24 Applications: POV Persistence of Vision Display a sentence onto mote s LEDs by moving JCreate back and forth Accelerometer starts display sequence according to hand position

25 Java One Keynote Count people in and out of rooms Emitter: o 2 IR beams sent by emitter (9V individual power) o 36KHz and 56kHz to discriminate between beams o Brought power from 3.5W to 1.75W Receiver: o Mote powers and reads two IR receivers o Depending on which beam cut first: direction of person walking known o Uses interrupt pins: CPU waits for interrupt (sleeps) => low energy use

26 ( 2) Java One Keynote Monitor humidity, light and temperature Use of collect protocol Many-to-one Routing over several hops Every node sends its data Buggy protocol Information reported to website: data displayed over time

27 Questions and Answers