Sensor Network Application Development ZIGBEE CONCEPTS 2

Transcription

1 Sensor Network Application Development ZIGBEE CONCEPTS 2 Cruise Summerschool Johannes Kepler University November 5-7, 2007, Linz / Austria Dipl.-Ing. riener@pervasive.jku.at

2 Overview Structure of this lesson ZigBee-Application development Development of ZigBee programs - Base Station with Message Queue - File / Component Overview - Source Code Fragments Sensor Network Application Development // ZigBee Concepts 2 // < 2 >

3 File / Component Overview makefile module: CounterM.nc Implements a simple counter that is incremented every second and then propagated with the CounterComm interface configuration: Counter.nc interface: CounterComm.nc CounterCommC provides the functionality to send a message with a counter value to a base station. Messages are first sent to node 0, and from there forwarded to the serial port configuration: CounterCommC.nc module: CounterCommM.nc header: CounterMsg.h Sensor Network Application Development // ZigBee Concepts 2 // < 3 >

4 Source Code: Header files //Message containing a counter value typedef struct CounterMsg uint16_t counter; //counter value uint16_t source; //source node id CounterMsg; //Message ID enum AM_COUNTERMSG = 10 ; header: CounterMsg.h //Other constants enum BASE_NODE_ADDRESS = 0 // node with id=0 is the base node ; Sensor Network Application Development // ZigBee Concepts 2 // < 4 >

5 Source Code: Counter Application interface: CounterComm.nc interface CounterComm //Send a CounterMsg to the PC //(through the base node if necessary) // counter: the counter value command result_t sendcounter(uint16_t counter); Sensor Network Application Development // ZigBee Concepts 2 // < 5 >

6 Source Code: Counter Application // Counter: Increases the local counter every second and // sends the new value through CounterComm configuration Counter configuration: Counter.nc implementation components Main, CounterM, CounterCommC, TimerC; Main.StdControl -> TimerC; // Order of execution Main.StdControl -> CounterCommC; // not guaranteed! Main.StdControl -> CounterM; CounterM.Timer -> TimerC.Timer[unique("Timer")]; CounterM.CounterComm -> CounterCommC; Sensor Network Application Development // ZigBee Concepts 2 // < 6 >

7 Bindings between components interface StdControl: init() start() stop() (1) In the actual example: "main" calls 3 StdControl-Functions TimerC.StdControl Main.StdControl CounterCommC.StdControl CounterM.StdControl (2) A better solution: "main" calls CounterM.StdControl. CounterM manually calls TimerC and CounterCommC (init/start/stop) Main.StdControl CounterM.StdControl StdControl as TimerControl StdControl as CommControl Sensor Network Application Development // ZigBee Concepts 2 // < 7 > TimerC.StdControl CounterCommC.StdControl

8 Source Code: Counter Implementation Sensor Network Application Development // ZigBee Concepts 2 // < 8 > module: CounterM.nc module CounterM provides interface StdControl; //cmd: init,start,stop uses interface Timer; interface CounterComm; implementation uint16_t counter; //local counter value command result_t StdControl.init() //initialize the counter counter = 0; return SUCCESS;...

9 Source Code: Counter Implementation module: CounterM.nc command result_t StdControl.start() //Start the component return call Timer.start(TIMER_REPEAT, 1000); command result_t StdControl.stop() //Stop the component return call Timer.stop(); event result_t Timer.fired() // Timer fired event // handler: count call CounterComm.sendCounter(++counter); return SUCCESS; Sensor Network Application Development // ZigBee Concepts 2 // < 9 >

10 Source Code: CounterComm Configuration // CounterCommC: Provides the CounterComm interface. includes CounterMsg; configuration CounterCommC provides interface StdControl; //init(), start(), stop() provides interface CounterComm; //sendcounter(val) implementation components CounterCommM, GenericComm; StdControl = CounterCommM.StdControl; // Direct connection! CounterComm = CounterCommM.CounterComm; CounterCommM.CommControl -> GenericComm.StdControl; CounterCommM.SendMsg -> GenericComm.SendMsg[AM_COUNTERMSG]; CounterCommM.ReceiveMsg -> GenericComm.ReceiveMsg[AM_COUNTERMSG]; Sensor Network Application Development // ZigBee Concepts 2 // < 10 > configuration: CounterCommC.nc SendMsg() in CounterCommM is a call SendMsg[AM_COUNTERMSG] from GenericComm

11 Source Code: CounterComm Implementation (1) includes CounterMsg; module: CounterCommM.nc module CounterCommM provides interface StdControl; //init(),start(),stop() interface CounterComm; //sendcounter(val) uses interface StdControl as CommControl; //CommControl is used interface SendMsg; //as StdControl interface ReceiveMsg; Sensor Network Application Development // ZigBee Concepts 2 // < 11 >

12 Source Code: CounterComm Implementation (2) implementation enum QUEUE_SIZE = 5 ; module: CounterCommM.nc //...set to TRUE when packet delivery is in progress bool sending; // message queue buffer TOS_Msg msgqueue[queue_size]; // index of first message and current queue length uint8_t firstmsg, cursize; task void senddata(); //declaration, implementation: later //we can already use this command... Sensor Network Application Development // ZigBee Concepts 2 // < 12 >

13 Source Code: CounterComm Implementation (3) module: CounterCommM.nc //Add a new message to the send queue and post sendtask result_t enqueuemsg(tos_msgptr m) uint8_t idx; // chancel on full queue if (cursize >= QUEUE_SIZE) return FAIL; // add message to queue idx = (firstmsg+cursize) % QUEUE_SIZE; dbg(dbg_usr1,"enqueuing message type %i\n",(int)m->type); msgqueue[idx] = *m; cursize++; //no transmission in progress? --> start delivery if (!sending) post senddata(); return SUCCESS; Sensor Network Application Development // ZigBee Concepts 2 // < 13 >

14 Source Code: CounterComm Implementation (3a) Special target adresses and basic message header in AM.h (AM...Active Message) header: AM.h enum TOS_BCAST_ADDR = 0xffff, TOS_UART_ADDR = 0x007e, ; typedef struct TOS_Msg // The following fields are // transmitted/received on the radio. uint16_t addr; uint8_t type; uint8_t group; uint8_t length; int8_t data[tosh_data_length]; uint16_t crc; //... TOS_Msg; Structure of TOS messages 2 byte address 1 byte message type 1 byte group id 1 byte data length payload ( bytes) 2 byte cyclic redundancy check typedef TOS_Msg *TOS_MsgPtr; //... Sensor Network Application Development // ZigBee Concepts 2 // < 14 >

15 Source Code: CounterComm Implementation (4) module: CounterCommM.nc // remove message from Qu, post senddata if Qu isn't empty result_t dequeuemsg() // whenever a msg is dequeued, it means the transmission // of this msg was just finished -> reset sending flag sending = FALSE; //chancel if the queue is empty if (cursize == 0) return FAIL; //remove top message from queue dbg(dbg_usr1, "dequeuing message type %i\n", (int)msgqueue[firstmsg].type); firstmsg = (firstmsg+1) % QUEUE_SIZE; cursize--; //if queue is not empty, send next message if (cursize!= 0) post senddata(); return SUCCESS; Sensor Network Application Development // ZigBee Concepts 2 // < 15 >

16 Source Code: CounterComm Implementation (5) module: CounterCommM.nc //Initialize the component command result_t StdControl.init() sending = FALSE; firstmsg = 0; cursize = 0; return call CommControl.init(); //Start the component command result_t StdControl.start() return call CommControl.start(); //Stop the component command result_t StdControl.stop() return call CommControl.stop(); is a StdControl-component! Sensor Network Application Development // ZigBee Concepts 2 // < 16 >

17 Source Code: CounterComm Implementation (5) module: CounterCommM.nc //Incoming CounterMsg: If BASENODE forward packets to uart event TOS_MsgPtr ReceiveMsg.receive(TOS_MsgPtr m) if (TOS_LOCAL_ADDRESS == BASE_NODE_ADDRESS) m->addr = TOS_UART_ADDR; enqueuemsg(m); dbg(dbg_usr1,"base: relaying msg from radio 2 UART\n"); return m; // radio msg send event handler: dequeue msg, ignore error event result_t SendMsg.sendDone(TOS_MsgPtr msg,result_t succ) dequeuemsg(); return succ; Sensor Network Application Development // ZigBee Concepts 2 // < 17 >

18 Source Code: CounterComm Implementation (4) module: CounterCommM.nc task void senddata() // task: send next message in queue //cancel if already transmitting or msg queue is empty if (sending (cursize == 0)) return; sending = TRUE; dbg(dbg_usr1, "sending next msg in queue: type %i, target %i\n",(int)msgqueue[firstmsg].type, (int)msgqueue[firstmsg].addr); if (msgqueue[firstmsg].type == AM_COUNTERMSG) // send next msg in queue if it is a CounterMsg call SendMsg.send(msgQueue[firstMsg].addr, msgqueue[firstmsg].length, &msgqueue[firstmsg]); else // remove msg, if it is of unknown type dequeuemsg(); Sensor Network Application Development // ZigBee Concepts 2 // < 18 >

19 Source Code: CounterComm Implementation (5) module: CounterCommM.nc //Send a CounterMsg to the PC (CounterComm implementation) command result_t CounterComm.sendCounter(uint16_t counter) TOS_Msg m; //standard zigbee message as defined in AM.h CounterMsg *m_data = (CounterMsg *)&m.data; //set message target if (TOS_LOCAL_ADDRESS == BASE_NODE_ADDRESS) m.addr = TOS_UART_ADDR; else m.addr = BASE_NODE_ADDRESS; m.type = AM_COUNTERMSG; // set message type m.length = sizeof(countermsg); // set message data size m_data->counter = counter; // fill message data part m_data->source = TOS_LOCAL_ADDRESS; //provide node id; // zigbee message format knows no node id-field return enqueuemsg(&m); //add message to send-queue Sensor Network Application Development // ZigBee Concepts 2 // < 19 >

20 Priority Queue Simplify implementation Using C-functions memcpy/memmove from stdlib Moving a number of packets simultaneously forward/backward void* memcpy(void* s, const void* ct, size_t n) Copies n characters from ct to s and returns s s may be corrupted if objects overlap void* memmove(void* s, const void* ct, size_t n) Copies n characters from ct to s and returns s s will not be corrupted if objects overlap Sensor Network Application Development // ZigBee Concepts 2 // < 20 >

21 Sensor Network Application Development ZIGBEE CONCEPTS 2 Cruise Summerschool Johannes Kepler University November 5-7, 2007, Linz / Austria Dipl.-Ing.