====== 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 | | | {{ :wiki:micaz.jpg?nolink&200 |}} | {{ :wiki:telos.jpg?nolink&200 |}} | {{ :wiki:sparrow.png?nolink&200 |}} | | 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 {{:wiki:avrora.zip| 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 {{:wiki:simple.c.zip|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 {{http://compilers.cs.ucla.edu/avrora/demo/simple.od|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 {{http://compilers.cs.ucla.edu/avrora/demo/blink.od|blink.od}}. Acesta este un dump al unui program TinyOS care face să clipească led-ul roșu de pe nodul {{https://www.eol.ucar.edu/rtf/facilities/isa/internal/CrossBow/DataSheets/mica2.pdf|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: $ 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: $ 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 [[http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-8266-MCU_Wireless-ATmega128RFA1_Datasheet.pdf|aici]] * 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) * {{:wiki:stk600-atmega128rfa1.pdf|Schematic-ul plăcii simulate}} (ATmega128rfa1-ek1) #include #include 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 #include #include #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 {{http://compilers.cs.ucla.edu/avrora/demo/CntToRfm.od|CntToRfm.od}} și {{http://compilers.cs.ucla.edu/avrora/demo/RfmToLeds.od|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 #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 {{:wiki:net.zip|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