WSN Wiki

User Tools

Site Tools

You are here: Wireless Sensor Networks » Rețele de senzori wireless
lab1

This is an old revision of the document!

Table of Contents

Rețele de senzori wireless

“A network of possibly low-size and low-complex devices denoted as nodes that can sense the environment and communicate the information gathered from the monitored eld (e.g. an area or volume) through wireless links; the data is forwarded, possibily via multiple hops relaying, to a sink (sometimes denoted as controller or monitor) that can use it locally, or is connected to other networks (e.g. the Internet) through a gateway. The nodes can be stationary or moving. They can be aware of their location or not. They can be homogenous or not.” (Sensor networks: Evolution, opportunities, and challenges, 2003)

MicaZ Tmote Sparrowv3
CPU Atmega1281 16Mhz MSP430 8MIPS Atmega128RFA1 16MHz
Memory 128KB program memory, 8KB RAM, 512KB serial flash 48KB program flash, 10KB RAM, 1024KB serial flash 128KB program flash, 32KB RAM
Bandwidth 250kbps 250kbps 2Mbps
Programming TinyOS,SOS Contiki, TinyOS, SOS C

Simulatoare de WSN-uri - Avrora

Avrora este o colecție de tool-uri de simulare și analiză pentru programe scris pentru microcontrollerul AVR și în special pentru nodurile senzoriale Mica2. Avrora conține un framework flexibil pentru simularea și analiza programelor scrise în limbaj de asamblare, punând la dispoziție un API ușor de folosit și infrastructura necesară pentru experimentarea, profilingul și analiza rețelelor senzoriale.

Instalați Avrora

Pentru a folosi Avrora trebuie să urmați pașii de mai jos:

1. Instalați-vă Java pe mașina unde lucrați, dacă nu este instalat deja.

2. Descărcați arhiva zip cu avrora.jar

3. Daca nu îl aveți deja pe mașina voastră, instalați avr-gcc.

4. Avrora poate primi ca intrare fișiere scrise în Atmel assembler (.asm), GNU Assembler (.s) și fisiere convertite cu utilitarul avr-objdump (.od)

5. Avrora rulează în linia de comandă. Pentru a invoca Avrora trebuie să rulați comanda java cu optiunea -jar urmată de locația fișierului JAR. Rularea fără opțiuni va duce la listarea meniului help. Este indicat să vă faceți un alias după comandă, în felul următor: 

$ alias avrora='java -jar avrora.jar'

Prima simulare

Pentru început, să luăm un program simplu și să-l simulăm.

Avrora nu contine si un dezasamblor, deci nu poate încărca direct cod mașină. Dacă programul vostru este scris în orice alt limbaj decât assembler, trebuie să compilați codul și apoi să folosiți utilitarul avr-objdump pentru fișierul binar pentru a obține cod scris în assembler care poate fi interpretat de Avrora.

Primul pas este sa compilați programul de mai sus: 

$ avr-gcc -o simple.elf -mmcu=atmega128 simple.c

Dacă nu aveți avr-gcc instalat, instalați-l: 

 $ sudo apt-get update
$ sudo apt-get install gcc-avr avr-libc

In urma compilării vi s-a generat un fișier binar ELF. Pe acesta îl vom pasa mai departe dezasamblorului, folosind comanda: 

$ avr-objdump -zhD simple.elf > simple.od

Opțiunile specifică programului să dezasambleze și zero-urile din fișier (zero este codul operației NOP), printează informațiile din header și să dezasambleze fiecare secțiune în parte.

După acest pas ați obținut fișierul simple.od. Incercați să-l simulați, rezultatul trebuie să fie ceva asemănător cu output-ul de mai jos: 

$ avrora simple.od 
Avrora [Beta 2.0.001] - (c) 2003-2007 UCLA Compilers Group

Loading simple.od...OK
=={ Simulation events }=======================================================
Node          Time   Event
------------------------------------------------------------------------------
==============================================================================
Simulated time: 416 cycles

Pentru acest exemplu simplu, Avrora vă poate calcula numărul de cicli executați, vă arată timpul necesar pentru simularea programului și throughput-ul total. 

$ avrora -throughput=true simple.od 
Avrora [Beta 2.0.001] - (c) 2003-2007 UCLA Compilers Group

Loading simple.od...OK
=={ Simulation events }=======================================================
Node          Time   Event
------------------------------------------------------------------------------
==============================================================================
Simulated time: 416 cycles
Time for simulation: 0.047 seconds
Total throughput: 0.008851063 mhz

Simularea unei platforme

Un exemplu ceva mai greu este blink.od. Acesta este un dump al unui program TinyOS care face să clipească led-ul roșu de pe nodul Mica o dată pe secundă. Pentru a simula bine acest exemplu trebuie să specificăm platforma pe care vrem sa rulăm codul, pentru a avea toate device-urile hardware conectate. 

$ avrora -seconds=10 -report-seconds -platform=mica2 -throughput=true blink.od 
Avrora [Beta 2.0.001] - (c) 2003-2007 UCLA Compilers Group

Loading blink.od...OK
=={ Simulation events }=======================================================
Node          Time   Event
------------------------------------------------------------------------------
   0  0:00:00.000043  off off on  
   0  0:00:00.000043  on  off on  
   0  0:00:00.000043  on  on  on  
   0  0:00:00.000049  on  on  off 
   0  0:00:00.000049  off on  off 
   0  0:00:00.000049  off off off 
   0  0:00:00.977666  off off on  
   0  0:00:01.954229  off off off 
   0  0:00:02.930791  off off on  
   0  0:00:03.907354  off off off 
   0  0:00:04.883916  off off on  
   0  0:00:05.860479  off off off 
   0  0:00:06.837041  off off on  
   0  0:00:07.813604  off off off 
   0  0:00:08.790166  off off on  
   0  0:00:09.766729  off off off 
==============================================================================
Simulated time: 73728000 cycles
Time for simulation: 0.099 seconds
Total throughput: 744.7273 mhz

Monitorizare și profiling

O componentă importantă a Avrora o reprezintă monitorizarea. Cu ajutorul acesteia puteți să faceți profiling aplicației voastre, puteți să monitorizați numărul și tipul de întreruperi declanșate în timpul rulării codului vostru, să vizualizați accesele la memorie, apelurile la rutine, modul de lucru al procesorului (cât timp a stat în sleep, idle sau cât a fost activ) și, cel mai important, puteți să estimați foarte exact consumul de energie al platformei voastre în timpul rulării unui program.

Monitorizarea se face prin adăugarea opțiunii -monitors la linia de comanda, opțiunile fiind: profiling, memory, energy, sleep, interrupts și calls.

De exemplu, vrem să facem profiling pentru programul simple.od:

Click to display ⇲

Click to hide ⇱ 

$ avrora -monitors=profile -instr-classes simple.od 
Avrora [Beta 2.0.001] - (c) 2003-2007 UCLA Compilers Group

Loading simple.od...OK
=={ Simulation events }=======================================================
Node          Time   Event
------------------------------------------------------------------------------
==============================================================================
Simulated time: 416 cycles
=={ Profiling results for node 0 }============================================
       Address     Count  Run     Cycles     Cumulative
------------------------------------------------------------------------------
        0x0000:        1               3 =   0.7211 %
 0x0004-0x0088:        0  x34   
 0x008C-0x00A6:        1  x14         15 =   3.6057 %
 0x00A8-0x00AA:        2  x2          10 =   2.4038 %
 0x00AC-0x00B0:        3  x3          11 =   2.6442 %
        0x00B2:        1               4 =   0.9615 %
 0x00B6-0x00BA:        0  x2    
 0x00BE-0x00CC:        1  x8          15 =   3.6057 %
 0x00CE-0x00DE:        5  x7          80 =  19.2307 %
 0x00E0-0x00E8:        6  x5          47 =  11.2980 %
        0x00EA:        1               1 =   0.2403 %
 0x00EC-0x00FE:        0  x9    
 0x0100-0x0112:        5  x9          74 =  17.7884 %
        0x0114:        1               1 =   0.2403 %
 0x0116-0x013C:        5  x20        155 =  37.2596 %
 0x013E-0x0144:        0  x4    
=={ Profiling Results by Instruction Type }===================================
 Instruction      Count    Cycles   Percent
------------------------------------------------------------------------------
         ldd:        32        64   15.3846 %
         std:        22        44   10.5769 %
         pop:        20        40    9.6153 %
         add:        25        25    6.0096 %
         adc:        25        25    6.0096 %
        call:         6        24    5.7692 %
        push:        12        24    5.7692 %
         ret:         5        20    4.8076 %
       rcall:         6        18    4.3269 %
          in:        12        12    2.8846 %
        brlt:         6        11    2.6442 %
        adiw:         5        10    2.4038 %
         sts:         5        10    2.4038 %
         lds:         5        10    2.4038 %
         cpc:         9         9    2.1634 %
         cpi:         9         9    2.1634 %
        sbrc:         5         9    2.1634 %
         ldi:         8         8    1.9230 %
         eor:         6         6    1.4423 %
        elpm:         2         6    1.4423 %
        brne:         3         5    1.2019 %
        movw:         5         5    1.2019 %
         mov:         5         5    1.2019 %
          st:         2         4    0.9615 %
        rjmp:         2         4    0.9615 %
         out:         4         4    0.9615 %
         jmp:         1         3    0.7211 %
         com:         1         1    0.2403 %
       break:         1         1    0.2403 %

Monitorizarea energiei

Pentru monitorizarea consumului de energie, folosiți fișierul blink.od:

Click to display ⇲

Click to hide ⇱ 

$ avrora -colors=false -platform=mica2 -monitors=energy -seconds=2 blink.od
Avrora [Beta 2.0.001] - (c) 2003-2007 UCLA Compilers Group

Loading blink.od...OK
=={ Simulation events }=======================================================
Node          Time   Event
------------------------------------------------------------------------------
==============================================================================
Simulated time: 14745600 cycles
=={ Energy consumption results for node 0 }===================================
Node lifetime: 14745600 cycles,  2.0 seconds

CPU: 0.02006729955957031 Joule
   Active: 1.3436311360677082E-5 Joule, 4364 cycles
   Idle: 0.020053863248209635 Joule, 14741236 cycles
   ADC Noise Reduction: 0.0 Joule, 0 cycles
   Power Down: 0.0 Joule, 0 cycles
   Power Save: 0.0 Joule, 0 cycles
   RESERVED 1: 0.0 Joule, 0 cycles
   RESERVED 2: 0.0 Joule, 0 cycles
   Standby: 0.0 Joule, 0 cycles
   Extended Standby: 0.0 Joule, 0 cycles

Yellow: 4.117838541666667E-8 Joule
   off: 0.0 Joule, 14745554 cycles
   on: 4.117838541666667E-8 Joule, 46 cycles

Green: 4.117838541666667E-8 Joule
   off: 0.0 Joule, 14745554 cycles
   on: 4.117838541666667E-8 Joule, 46 cycles

Red: 0.006445356363932292 Joule
   off: 0.0 Joule, 7545551 cycles
   on: 0.006445356363932292 Joule, 7200049 cycles

Radio: 0.0 Joule
   Power Off:            : 0.0 Joule, 14745600 cycles

SensorBoard: 0.0042 Joule
   on:  : 0.0042 Joule, 14745600 cycles

flash: 1.1999999999999999E-5 Joule
   standby: 1.1999999999999999E-5 Joule, 14745600 cycles
   read: 0.0 Joule, 0 cycles
   write: 0.0 Joule, 0 cycles
   load: 0.0 Joule, 0 cycles

Opțiunea -seconds oprește simularea după numărul specificat de secunde. Pentru a simula și mai bine un nod senzorial, există opțiunea -battery care specifică energia totală a nodului în Jouli. Incercați exemplul anterior împreună cu comanda -battery=1 

avrora -colors=false -platform=mica2 -monitors=energy -battery=1 blink.od

Cât timp funcționeaza nodul cu un singur Joule de energie?

Monitorizarea Întreruperilor

Avrora poate să monitorizeze toate întreruperile declanșate pe platforma simulată. Completați fișierul rosu.c astfel încât timer0 să declanșeze o întrerupere la overflow cu o perioadă de clk/1024. Vom folosi de data aceasta o platformă cu același procesor ca senzorii Sparrowv3. În corpul întreruperii faceți să clipească ledul roșu. După compilare și dezasamblare rulați: 

avrora -platform=atmega128rfa1ek1 -monitors=interrupts -seconds=2 rosu.od

Hints:

  • Datasheet-ul pentru Atmega128RFA1 îl găsiți pe desktop
    • zonele de interes sunt Timer0/Register Description, în special regiștrii TCCR0B și TIMSK0
    • Pentru aprinderea LED-urilor, consultați capitolul “Ports as digital I/O” din datasheet (14.2.3)
  • Schematic-ul plăcii simulate (ATmega128rfa1-ek1)

Click to display ⇲

Click to hide ⇱

rosu.c
#include <avr/io.h>
#include <avr/interrupt.h>
 
void initTimer0(void)
{
	//interrupt on overflow, prescaler clk/1024
}
ISR(TIMER0_OVF_vect )
{
	//faceti ledul ROSU sa clipeasca
}
 
int main(void) 
{
	PORTE=0xff;
	DDRE=0xff;
 
	initTimer0();
	sei();
 
	while(1);
	return 0;
}
PROGRAM=rosu
 
all: $(PROGRAM).hex $(PROGRAM).od
 
$(PROGRAM).elf: $(PROGRAM).c 
	avr-gcc -mmcu=atmega128rfa1 -Wall -g  -o $@ $^ -Os 
 
$(PROGRAM).hex: $(PROGRAM).elf
	avr-objcopy  -j .text -j .data -O ihex  $(PROGRAM).elf $(PROGRAM).hex
	avr-size $(PROGRAM).elf
 
$(PROGRAM).od : $(PROGRAM).elf
	avr-objdump -zhD $^ > $@
 
clean:
 
	rm -rf $(PROGRAM).elf $(PROGRAM).hex

Monitorizarea Interfeței Seriale

Avrora poate să emuleze o conexiune serială între platforma simulata și calculatorul gazdă. Prin adăugarea opțiunii -serial, simularea așteaptă conectarea unui program la portul 2390 de pe localhost apoi rulează simularea. Completați fișierul serial.c astfel încât interfața usart0 să facă echo la toate caracterele primite. Dupa compilare, rulați: 

$ avrora -platform=atmega128rfa1ek1 -monitors=interrupts,serial -ports=0:0:2390 serial.od

Comanda descrisă mai sus cere ca portul uart de pe nodul 0 să fie forwardat către portul 2390 de pe calculatorul gazdă. Deschideți altă consolă și conectați-vă prin telnet la portul 2390, apoi scrieți ceva în consolă (urmat de un newline) și vedeți dacă vi se returnează caracterele trimise. 

$ telnet 127.0.0.1 2390

Click to display ⇲

Click to hide ⇱

serial.c
#include <avr/io.h>
#include <avr/interrupt.h>
 
#define F_CPU            16000000UL
#define UART_BAUD_RATE      9600L      /* 9600 baud */
#define UART_BAUD_SELECT (F_CPU/(16*UART_BAUD_RATE)-1)
 
void initUart(void)
 {
	// initializati USART 0, cu intrerupere la terminarea receptiei 
 
	// parametrii sunt baud rate dat de UART_BAUD_SELECT, 0 biti de
	// paritate, un bit de stop si 8 biti de date
 }
/********************************************************************
Semnal USART0
*/
ISR(USART0_RX_vect)
{
	//returnati caracterul primit
}
 
int main(void) 
{
 
	initUart();
	sei();
 
	while(1){};
	return 0;
}
PROGRAM=serial
 
all: $(PROGRAM).hex $(PROGRAM).od
 
$(PROGRAM).elf: $(PROGRAM).c 
	avr-gcc -mmcu=atmega128rfa1 -Wall -g  -o $@ $^ -Os 
 
$(PROGRAM).hex: $(PROGRAM).elf
	avr-objcopy  -j .text -j .data -O ihex  $(PROGRAM).elf $(PROGRAM).hex
	avr-size $(PROGRAM).elf
 
$(PROGRAM).od : $(PROGRAM).elf
	avr-objdump -zhD $^ > $@
 
clean:
 
	rm -rf $(PROGRAM).elf $(PROGRAM).hex

Simularea unei rețele de senzori

Ca să simulați o rețea de noduri trebuie să specificați opțiunea -simulation=sensor-network și să furnizați fișiere .od pentru fiecare nod din rețea. Descărcați CntToRfm.od și RfmToLeds.od și rulați-le cu opțiunile: 

% avrora -simulation=sensor-network -seconds=5.0 -nodecount=1,1 CntToRfm.od RfmToLeds.od

Putem să adaugăm simulării și un monitor pentru pachetele radio transmise și recepționate de către cele două noduri: 

% avrora -simulation=sensor-network -seconds=5.0 -nodecount=1,1 -monitors=packet CntToRfm.od RfmToLeds.od

Pentru simularea unei rețele de mari dimensiuni puteți specifica amplasamentul nodurilor printr-un fișier ce contine topologia rețelei. Salvați exemplul de mai jos ca grid.top

grid.top
#simple topology specification 
#syntax: nodeName x y z       
#nodeName: any string without space
#coordinates: integer values
#negative coordinates are welcome
node0 0 0 0
node1 10 0 0
node2 15 0 0
node3 20 0 0
node4 25 0 0
node5 40 0 0

Descărcați net.od și rulați simularea pentru topologia dată: 

$ avrora -action=simulate -simulation=sensor-network -stagger-start=500000 -platform=mica2 -nodecount=6 -monitors=energy,energy-profile,packet -topology=static -topology-file=grid.top net.od
lab1.1384713576.txt.gz · Last modified: 2013/11/17 20:39 by dan.tudose

Page Tools

Except where otherwise noted, content on this wiki is licensed under the following license: CC Attribution-Noncommercial 4.0 International
CC Attribution-Noncommercial 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki