Tutorial:ZigBee

2019-10-08T08:26:53Z

Minghang: /* Useful parse scripts */

Tutorial:ZigBee

2019-10-08T08:16:48Z

Minghang: /* Batch burn of multiple network nodes */

This page shows the tutorial for experiments with ZigBee communications and the testbed.
[[File:Testbed.jpg|thumb|The ZigBee Testbed in B1-612, Main Building|link=]]

Useful links:
* [https://blog.csdn.net/leansmall/article/details/78703633 TinyOS intro (Chinese)]
* [https://blog.csdn.net/liuruiqun/article/details/45504035 Programming model of TinyOS (Chinese)]
* [http://tinyos.stanford.edu/tinyos-wiki/index.php/Main_Page TinyOS main site and official tutorials]

===The simplest example===
This example shows

1) how the event-driven programming works,

2) how to burn a program to a TelosB node.

for details you can see [http://tinyos.stanford.edu/tinyos-wiki/index.php/The_simplest_TinyOS_program simplest tinyos program]
----

1. Configuration file, SimpleAppC.nc
<nowiki>
configuration SimpleAppC{
}

implementation{
components SimpleC, MainC;
SimpleC.Boot -> MainC.Boot;
}</nowiki>
this file will link two components <code>SimpleC</code> and <code>MainC</code>

2. SimpleC.nc

<nowiki>module SimpleC{
uses interface Boot;
}

implementation{
event void Boot.booted() {
}
}</nowiki>

When system starts, it will call interface booted in <code>MainC</code>, but this interface is not implemented.

So <code>SimpleC</code> implements it.

<code>MainC</code> in nesC is just like main function in C.

In this example, it does nothing, so it is just like following code in C:
<nowiki>int main () {
return 0;
}</nowiki>

3. Makefile
<nowiki>
COMPONENT=SimpleAppC
include $(MAKERULES)</nowiki>

with <code>Makefile</code> we can compile the code by typing
<nowiki>make telosb</nowiki>

4. install

<nowiki>make telosb install bsl,/dev/ttyUSB0</nowiki>

===Measurement===
To measure various information from received packets.

Details is [http://tinyos.stanford.edu/tinyos-wiki/index.php/Mote-mote_radio_communication here]
====Code template====

ExampleC.nc
<nowiki>
// extract info upon receiving a packet.
event message_t* Receive.receive(message_t* bufPtr, void* payload, uint8_t len) {
if (len != sizeof(msg_t)) {
return bufPtr;
} else {
msg_t* msg = (msg_t*)payload;
// msg is the info, we can do something upon it.
// write your code with msg here, for example, we show it by led
call Leds.set(msg->counter);
return bufPtr;
}
}</nowiki>
====Payload====

ExampleC.nc
<nowiki>
// following code is the implementation
// to send a packet, we should create a packet at first.
message_t packet; // packet is a container of payload.
bool locked; // when it is sending a packet, sender is locked.
uint16_t counter = 0; // the payload in this example

event void Timer0.fired() {
msg_t *msg;
// important!!!
// variable declaration must be present before operation
// in this example, msg is present before `if (locked)'
if (locked) {
return;
}
msg = (msg_t*) call Packet.getPayload(&packet, sizeof(msg_t));
++counter;
// suppose msg contains payload `counter`
msg->counter = counter;
// if there is other payload in msg, do assignment.
// to send this packet
if (call AMSend.send(AM_BROADCAST_ADDR, &packet, sizeof(msg_t)) == SUCCESS) {
locked = TRUE;
// the packet is being sent
}
}</nowiki>

====Header====

ExampleC.h
<nowiki>
#ifndef EXAMPLE_H
#define EXAMPLE_H

typedef nx_struct example_msg {
nx_uint16_t counter;
} msg_t;

enum {
AM_MSG = 6, // mesage group
};
#endif</nowiki>

ExampleAppC.nc
<nowiki>#include "Example.h"
configuration ExampleAppC {}
implementation {
components MainC, ExampleC as App, LedsC;
components new AMSenderC(AM_MSG);
components new AMReceiverC(AM_MSG);
components new TimerMilliC() as Timer0;
components ActiveMessageC;

App.Boot -> MainC.Boot;

App.Receive -> AMReceiverC;
App.AMSend -> AMSenderC;
App.AMControl -> ActiveMessageC;
App.Leds -> LedsC;
App.Timer0 -> Timer0;
App.Packet -> AMSenderC;
}</nowiki>

ExampleC.nc
<nowiki>#include "Timer.h"
#include "Example.h"
module ExampleC @safe() {
uses {
interface Leds;
interface Boot;
interface Receive;
interface AMSend;
interface Timer<TMilli> as Timer0;
interface SplitControl as AMControl;
interface Packet;
}
}
implementation {
event void Boot.booted() {
call AMControl.start();
}

event void AMControl.startDone(error_t err) {
if (err == SUCCESS) {
call Timer0.startPeriodic(250);
} else {
call AMControl.start();
}
}
// ... see in other sections: code example, payload
}</nowiki>

====Footer====

ExampleC.nc
<nowiki>
// to unlock
event void AMSend.sendDone(message_t* bufPtr, error_t error) {
if (&packet == bufPtr) {
locked = FALSE;
}
}
event void AMControl.stopDone(error_t err) {
// do nothing
}</nowiki>

====Makefile====

<nowiki>COMPONENT=ExampleAppC
include $(MAKERULES)</nowiki>

====RSSI====
====Byte-level RSSI====

===Routing===

====Code template====
we can change '''ADDRESS''' to implement different protocols.
<nowiki>if (call AMSend.send(ADDRESS, &packet, sizeof(msg_t)) == SUCCESS) {
locked = TRUE;
// the packet is being sent
}</nowiki>

====Broadcast====
'''AM_BROADCAST_ADDR''' is a MACRO. Using this ADDRESS, a mote will boradcast the packet.
<nowiki>AM_BROADCAST_ADDR</nowiki>

====Unicast====
When load the binary to the mote, we can set the '''TOS_NODE_ID''', so we can set the '''ADDRESS''' to
a specific '''TOS_NODE_ID''', such as 1 to unicast a packet.
For exmaple, if we want to set '''TOS_NODE_ID = 1''' in /dev/ttyUSB2
<nowiki>make telosb install,1 bsl,/dev/ttyUSB2</nowiki>

====Anycast====

===Testbed usage===
====Data collection using USB cables====
1. Use Printf

Details is [http://tinyos.stanford.edu/tinyos-wiki/index.php/The_TinyOS_printf_Library here].

ExampleC.nc
<nowiki>#include "printf.h"
// in function, fell free to use printf()</nowiki>

ExampleAppC.nc
<nowiki>#define NEW_PRINTF_SEMANTICS
#include "printf.h"
...
implementation {
components PrintfC;
components SerialStartC;
...
}</nowiki>

Makefile

add following code
<nowiki>CFLAGS += -I$(TOSDIR)/lib/printf</nowiki>

Run

in our exvironments, type the following command:
<nowiki>java net.tinyos.tools.PrintfClient -comm serial@/dev/ttyUSB1:telosb</nowiki>

====Batch burn of multiple network nodes====
1. burn multiple nodes
<nowiki>usage: burn.py [-s] ids
burn.py -s 1 , node with TOS_NODE_ID = 1 will be burned
burn.py -s 5 3 2 , TOS_NODE_ID = 5, 3, 2 will be burned
burn.py 23 55 , TOS_NODE_ID from 23 to 55 will be burned</nowiki>

2. burn all nodes
<nowiki>all-burn</nowiki>

====Remote configuration via web====
====Multi-hop networks====
====Useful parse scripts====
1. bitmap.py

Say mote A sends 1000 packets, numbered from 1 ~ 1000,
then we want to know how many packets mote B receives,
and what there numbers are.

A bitmap is like "001100101010...", where "0" means B does
not receive the packet and "1" means B receives the packet.

<nowiki>#!/usr/bin/env python
def raw2bit(src_file, dest_file, total_bit):
"""
@brief get bitmap from raw data

@param src_file The source file path (raw data generated by tinyos printf function)
@param dest_file The destination file path (bitmap file as output)
@param total_bit The total bits of the package (size of bitmap)

@return
"""
with open(src_file,'rb') as fr:
fw = open(dest_file,'w')
line_1 = fr.readline().strip()#除去换行符号'\n'
receive = 0 #总的收包个数
count = 1 #上一个收到的包的序列号加1
if len(line_1) < 24:
pass #第一行的固定前缀有23个字符
else:
start = int(line_1[23:])
for i in range(start - 1):
fw.write('0')
fw.write('1')
receive += 1
count = start + 1
for line in fr:
for j in range(int(line) - count):
fw.write('0')
fw.write('1')
receive += 1
count = int(line) + 1
for k in range(total_bit - count + 1):
fw.write('0')
fw.close()
fr.close()
</nowiki>

Tutorial:ZigBee