Show page

Differences

This shows you the differences between two versions of the page.

--- iothings:laboratoare:lab1 [2021/10/12 19:16]
127.0.0.1 external edit
+++ iothings:laboratoare:lab1 [2022/03/06 18:00] (current)
cosmin.chenaru [Resurse]
@@ Line 1: / Line 1: @@
-====== Rețele de senzori wireless ======
+===== Laborator 01. Specificațiile plăcuței de dezvoltare ESP32 =====
-//"A network of possibly low-size and low-complex devices denoted as nodes
+Bine ați venit în laboratorul de Internet of Things!
-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)
+Laboratorul își propune să vă familiarizeze cu placuța de dezvoltare ESP32 de la Espressif.
-^ ^  MicaZ  ^  Tmote  ^  Sparrowv3  |
+{{:iothings:laboratoare:lab1-nodemcu-32s-38.jpg?300|}}
-| | {{ :iothings:wiki:micaz.jpg?nolink&200 |}} | {{ :iothings:wiki:telos.jpg?nolink&200 |}}  | {{ :iothings: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 |
+Un foarte bun ghid de utilizare pas ca pas a plăcuței este cel de aici:
-====== Simulatoare de WSN-uri - Avrora ======
+https://randomnerdtutorials.com/getting-started-with-esp32/
-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.
+Iar interfața de intrare-ieșire (pinout) este descrisă aici:
-===== Instalați Avrora =====
+https://randomnerdtutorials.com/esp32-pinout-reference-gpios
-Pentru a folosi Avrora trebuie să urmați pașii de mai jos:
-. Instalați-vă Java pe mașina unde lucrați, dacă nu este instalat deja.
+===== Exerciții =====
-. Descărcați arhiva zip cu {{:iothings:wiki:avrora.zip| avrora.jar}}
+=== Ex. 1. Iluminați intermitent LED-ul incorporporat pe plăcuță ===
-. Daca nu îl aveți deja pe mașina voastră, instalați avr-gcc.
+Deschideți exemplul "Blink" din Arduino IDE.
-. Avrora poate primi ca intrare fișiere scrise în Atmel assembler (.asm), GNU Assembler (.s) și fisiere convertite cu utilitarul avr-objdump (.od)
+{{:iothings:laboratoare:lab1-blink.jpg?600|}}
-. 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:
+Căutați pe Internet diagrama (pinout-ul) plăcuței de dezvoltare NodeMCU-32S pentru a afla PIN-ul la care este conectat LED-ul de pe plăcuță. Definiți constanta LED_BUILTIN folosind acel număr.
-<code>$ alias avrora='java -jar avrora.jar'</code>
-===== Prima simulare =====
-Pentru început, să luăm un program {{:iothings: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:
-<code>$ avr-gcc -o simple.elf -mmcu=atmega128 simple.c</code>
-Dacă nu aveți avr-gcc instalat, instalați-l:
-<code> $ sudo apt-get update
-$ sudo apt-get install gcc-avr avr-libc
-</code>
-In urma compilării vi s-a generat un fișier binar ELF. Pe acesta îl vom pasa mai departe dezasamblorului, folosind comanda:
-<code>$ avr-objdump -zhD simple.elf > simple.od</code>
-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:
 <code>
-$ avrora simple.od
+#define LED_BUILTIN ...
-Avrora [Beta 2.0.001] - (c) 2003-2007 UCLA Compilers Group
-Loading simple.od...OK
-=={ Simulation events }=======================================================
-Node          Time   Event
-------------------------------------------------------------------------------
-==============================================================================
-Simulated time: 416 cycles
 </code>
-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.
+=== Ex. 2. Scanați retelele Wireless din zona ===
-<code>
-$ 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
-</code>
-===== 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.
-<code>
-$ 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:00:00.000043  off off on
-  0:00:00.000043  on  off on
-  0:00:00.000043  on  on  on
-  0:00:00.000049  on  on  off
-  0:00:00.000049  off on  off
-  0:00:00.000049  off off off
-  0:00:00.977666  off off on
-  0:00:01.954229  off off off
-  0:00:02.930791  off off on
-  0:00:03.907354  off off off
-  0:00:04.883916  off off on
-  0:00:05.860479  off off off
-  0:00:06.837041  off off on
-  0:00:07.813604  off off off
-  0:00:08.790166  off off on
-  0:00:09.766729  off off off
-==============================================================================
-Simulated time: 73728000 cycles
-Time for simulation: 0.099 seconds
-Total throughput: 744.7273 mhz
-</code>
-===== 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:
-<hidden>
-<code>
-$ 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
-------------------------------------------------------------------------------
-x0000:        1               3 =   0.7211 %
-x0004-0x0088:        0  x34
-x008C-0x00A6:        1  x14         15 =   3.6057 %
-x00A8-0x00AA:        2  x2          10 =   2.4038 %
-x00AC-0x00B0:        3  x3          11 =   2.6442 %
-x00B2:        1               4 =   0.9615 %
-x00B6-0x00BA:        0  x2
-x00BE-0x00CC:        1  x8          15 =   3.6057 %
-x00CE-0x00DE:        5  x7          80 =  19.2307 %
-x00E0-0x00E8:        6  x5          47 =  11.2980 %
-x00EA:        1               1 =   0.2403 %
-x00EC-0x00FE:        0  x9
-x0100-0x0112:        5  x9          74 =  17.7884 %
-x0114:        1               1 =   0.2403 %
-x0116-0x013C:        5  x20        155 =  37.2596 %
-x013E-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 %
-</code>
-</hidden>
-==== Monitorizarea energiei ====
-Pentru monitorizarea consumului de energie, folosiți fișierul blink.od:
-<hidden>
-<code>
-$ 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
-</code>
-</hidden>
-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
-<code>avrora -colors=false -platform=mica2 -monitors=energy -battery=1 blink.od</code>
-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:
-<code>avrora -platform=atmega128rfa1ek1 -monitors=interrupts -seconds=2 rosu.od</code>
-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)
-  * {{:iothings:wiki:stk600-atmega128rfa1.pdf|Schematic-ul plăcii simulate}} (ATmega128rfa1-ek1)
-<hidden>
-<file c 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;
-}
-</file>
-<file makefile>
-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
-</file>
-</hidden>
-==== 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:
-<code>$ avrora -platform=atmega128rfa1ek1 -monitors=interrupts,serial -ports=0:0:2390 serial.od</code>
-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.
-<code>$ telnet 127.0.0.1 2390</code>
-<hidden>
-<file c 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;
-}
-</file>
-<file makefile>
-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
-</file>
-</hidden>
-===== 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:
-<code>% avrora -simulation=sensor-network -seconds=5.0 -nodecount=1,1 CntToRfm.od RfmToLeds.od</code>
+Încărcați exemplul "WiFiScan" din Arduino IDE.
-Putem să adaugăm simulării și un monitor pentru pachetele radio transmise și recepționate de către cele două noduri:
+{{:iothings:laboratoare:lab1-wifi-scanner.jpg?600|}}
-<code>% avrora -simulation=sensor-network -seconds=5.0 -nodecount=1,1 -monitors=packet CntToRfm.od RfmToLeds.od</code>
+Deschideți consola seriala pentru a vedea rezultatul scanării.
-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
+{{:iothings:laboratoare:lab1-serial-monitor.jpg?600|}}
-<file bash grid.top>
+=== Ex. 3. Anunțați prezența dispozitivului BLE (Bluetooth Low Energy) incorporat ===
-#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
-</file>
-Descărcați {{:iothings:wiki:net.zip|net.od}} și rulați simularea pentru topologia dată:
+Încărcați exemplul "SimpleBleDevice" si scrieți-l pe placuță. Instalați pe telefon o aplicație de scanat dispozitivele bluetooth (precum acest [[https://play.google.com/store/apps/details?id=com.macdom.ble.blescanner&hl=en&gl=US|BLE Scanner]]) si verificați că dispozitivul este văzut.
-<code>$ 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 </code>
+{{:iothings:laboratoare:lab1-ble-scanner.jpg?300|}}
+===== Resurse =====
+  * https://randomnerdtutorials.com/getting-started-with-esp32/
+  * https://randomnerdtutorials.com/esp32-pinout-reference-gpios
+  * https://play.google.com/store/apps/details?id=com.macdom.ble.blescanner&hl=en&gl=US