IOT Made Simple: giocare con ESP32 su Arduino IDE

Esploriamo in questo tutorial, ESP32, la fantastica scheda di sviluppo più recente per uso IoT. Questa scheda, sviluppata da Espressif, dovrebbe essere il successore del NodeMCU, a causa del suo prezzo basso e delle grandi caratteristiche.

Ma è anche importante sottolineare che NON TUTTE le librerie o le funzioni a cui sei abituato a lavorare con ESP8266 e / o Arduino sono ancora funzionanti su questa nuova scheda. Probabilmente questo avverrà presto, quindi controllalo regolarmente sulla pagina web del forum ESP 32.

Qui impareremo come programmare ESP32 su Arduino IDE, esplorando le sue funzioni e librerie più comuni, indicando alcune importanti differenze e nuove funzionalità introdotte con questo fantastico chip.

In breve, esploreremo:

  • Uscita digitale: lampeggiante di un LED
  • Ingresso digitale: lettura di un sensore touch
  • Ingresso analogico: lettura di una tensione variabile da un potenziometro
  • Uscita analogica: controllo della luminosità del LED
  • Uscita analogica: controllo di una posizione servo
  • Lettura dei dati di temperatura / umidità con un sensore digitale
  • Connessione a Internet e ora locale
  • Ricezione di dati da una semplice pagina Web locale, accensione / spegnimento di un LED
  • Trasmissione dei dati a una semplice pagina Web locale

Passaggio 1: Caratteristiche principali dell'ESP32

L'ESP32 è una scheda da meno di $ 10 con grandi vantaggi rispetto a schede IoT simili sul mercato.

Questa scheda ha un doppio microprocessore che aiuta molto, perché quando un processore gestisce la comunicazione, l'altro è responsabile del controllo I / O, ad esempio. Questa funzione eviterà alcuni problemi che si verificano con ESP8266, in cui l'unica CPU deve smettere di controllare gli I / O quando viene gestita con Comm. Inoltre, ESP32 ha integrato WIFI, BLUETOOTH, DAC, diversi ADC (non solo uno come ESP8266), sensori tattili capacitivi, ecc. (Dai un'occhiata allo schema a blocchi sopra). E la buona notizia è che il consumo di energia è quasi lo stesso di ESP8266.

Di seguito un grafico che può mostrarci le sue caratteristiche principali e le differenze rispetto a ESP8266:

Indichiamo le sue proprietà principali in maggiori dettagli:

Caratteristiche principali:

  • Microcontroller Tensilica LX6 dual core da 240 MHz con 600 DMIPS
  • SRAM integrata da 520 KB
  • Ricetrasmettitore Wi-Fi HT40 802.11 b / g / n integrato, banda base, stack e LwIP
  • Bluetooth dual mode integrato (classico e BLE)
  • Flash da 16 MB, mappato in memoria nello spazio del codice della CPU
  • Tensione di funzionamento da 2, 3 V a 3, 6 V.
  • Da -40 ° C a + 125 ° C temperatura di funzionamento
  • Antenna PCB integrata / Connettore IPEX per antenna esterna

sensori:

  • Amplificatore analogico a bassissimo rumore
  • Sensore Hall
  • 10x interfacce tattili capacitive
  • Oscillatore a cristallo 32 kHz

34 x GPIO:

  • 3 x UART, incluso il controllo del flusso hardware
  • 3 x SPI
  • 2 x I2S
  • 18 x canali di ingresso ADC
  • 2 x DAC
  • 2 x I2C
  • Ingresso / uscita PWM / timer disponibili su ogni pin GPIO
  • Interfaccia di debug OpenOCD con buffer TRAX da 32 kB
  • SDIO master / slave 50 MHz
  • Supporta flash SPI esterno fino a 16 MB
  • Supporto interfaccia SD-card

Relativo alla sicurezza:

  • WEP, WPA / WPA2 PSK / Enterprise
  • Crittografia accelerata hardware: AES / SHA2 / Crittografia a curva ellittica / RSA-4096

Prestazione:

  • Supporta sniffer, Station, SoftAP e modalità diretta Wi-Fi
  • Velocità dati massima di 150 HT40, 72 HT20, 54 e 11
  • Potenza di trasmissione massima di 19, 5, 16, 5, 15, 5
  • Sensibilità minima del ricevitore di -97 dBm
  • Velocità effettiva UDP di 135 Mbps
  • Consumo energetico di 5 μA in modalità Deep-sleep

Passaggio 2: BoM - distinta base

  • Kit di sviluppo ESP32: scheda di sviluppo ESP32 (US $ 8, 52)
  • Micro Servo: TowerPro SG90 9G Mini Servo (US $ 3, 80)
  • Sensore di temperatura / umidità DHT22 / AM2302 Sensore di temperatura e umidità digitale (US $ 9, 99)
  • GUIDATO
  • 2 resistori: 330 ohm e 10K ohm
  • Potenziometro: 10K ohm
  • Protoboards

Passaggio 3: installazione IDE Arduino ESP32

Useremo l'IDE di Arduino per programmare il nostro ESP32, come facciamo con la famiglia ESP8266.

Installa driver:

È importante aver installato sul tuo computer il driver da USB a UART CP210x aggiornato. Inserisci in questo link: usb-to-uart-bridge-vcp-drivers e installa il driver corretto per il tuo sistema operativo.

Installa libreria:

La novità qui è che Expressif stesso nel suo GitHub ci fornirà le indicazioni corrette per l'installazione della libreria: arduino-esp32. Segui le istruzioni per il tuo sistema operativo. Nel mio caso (MacOS), l'installazione è molto semplice:

Apri Terminale ed esegui il seguente comando (copia-> incolla e premi invio):

 mkdir -p ~ / Documents / Arduino / hardware / espressif && \ cd ~ / Documents / Arduino / hardware / espressif && \ git clone //github.com/espressif/arduino-esp32.git esp32 && \ cd esp32 / tools / && \ python get.py 

Dopodiché, riavvia Arduino IDE ed è fatto! È necessario visualizzare più schede nel menu "STRUMENTI". Seleziona l'appropriato per te. In generale, il MODULO DEV "generico" ESP32 funziona bene.

Quando apri l'IDE di Arduino per la prima volta, noterai che la velocità di upload predefinita è 921.600 baud. Ciò può provocare instabilità in stile barocco. Modificalo in 115.200 baud !

Step 4: Hello World! Lampeggiante di un LED

Come al solito, la prima cosa da fare quando iniziamo a esplorare un nuovo HW è far lampeggiare un LED.

Vai al menu Esempi nell'IDE e apri lo schizzo Blink.

ESP32 DevKit ha un LED incorporato collegato al suo GPIO 02. È importante verificare se " LED_BUILTIN " viene riconosciuto automaticamente da IDE. In caso contrario, è necessario aggiungere per codificare la riga:

 int LED_BUILTIN = 2; 
Ogni scheda ESP32 ha un LED interno collegato a un GPIO diverso
 / * ESP 32 Lampeggiante Accende un LED per un secondo, quindi si spegne per un secondo, ripetutamente. L'ESP32 ha un LED blu interno su D2 (GPIO 02) * / int LED_BUILTIN = 2; void setup () {pinMode (LED_BUILTIN, OUTPUT); } void loop () {digitalWrite (LED_BUILTIN, HIGH); // accende il LED (ALTO è il livello di tensione) ritardo (1000); // aspetta un secondo digitalWrite (LED_BUILTIN, LOW); // spegni il LED rendendo il ritardo di BASSA tensione (1000); // aspetta un secondo} 

Sotto il LED interno lampeggiante (notare la luce blu) insieme a uno esterno collegato a GPIO 2:

Esistono diverse schede con diverse pin map sul mercato. Il diagramma sopra mostra la scheda che sto usando. Puoi trovarlo qui: / ESP32-Development-Board

Perfetto! Quindi, DigitalWrite () funziona perfettamente, allo stesso modo con ESP8266 e Arduino. A proposito, DigitalRead () funziona anche allo stesso modo per leggere un ingresso digitale, come ad esempio un pulsante.

Passaggio 5: il sensore a sfioramento

Passiamo a una nuova fantastica funzionalità, il Touch Sensor !

L'ESP32 ha 10 sensori tattili capacitivi interni. Puoi usarlo come pulsanti per esempio.

Questi sensori sono collegati con diversi GPIO:

  • T0: GPIO 4
  • T1: GPIO 0
  • T2: GPIO 2
  • T3: GPIO 15
  • T4: GPIO 13
  • T5: GPIO 12
  • T6: GPIO 14
  • T7: GPIO 27
  • T8: GPIO 33
  • T9: GPIO 32

Per leggerli è necessario utilizzare la funzione: touchRead (Touch Pin #);

Ad esempio, per leggere Touch Sensor 0 (T0), devi fare qualcosa del tipo:

 valore int = touchRead (4); 

Creiamo un codice, dove se tocchiamo il sensore T0 (GPIO4), il LED si accenderà.

Utilizzare il monitor seriale per verificare i valori letti dal sensore e regolare correttamente il codice.

Di seguito il codice completo:

 / ************************************************* **** * ESP32 Touch Test e LED Ctrl * Touch pin ==> Touch0 è T0 che si trova su GPIO 4 (D4). * LED pin ==> D2 * * MJRoBot.org 6Sept17 ************************************* **************** / #define TOUTCH_PIN T0 // ESP32 Pin D4 #define LED_PIN 2 int touch_value = 100; void setup () {Serial.begin (115200); ritardo (1000); // dammi il tempo di visualizzare il monitor seriale Serial.println ("ESP32 Touch Test"); pinMode (LED_PIN, OUTPUT); digitalWrite (LED_PIN, LOW); } void loop () {touch_value = touchRead (TOUTCH_PIN); Serial.println (touch_value); // ottieni valore usando T0 if (touch_value <50) {digitalWrite (LED_PIN, HIGH); } else {digitalWrite (LED_PIN, LOW); } ritardo (1000); } 

E sotto ESP32 funziona:

Passaggio 6: ingresso analogico

Ora proviamo come inserire segnali di valore analogici.

Esistono in totale canali di ingresso ADC a 18 x 12 bit, rispetto a solo 1 X 10 bit ADC su NodeMCU.

Canale GPC ADC

  • GPIO 0 ==> ADC2_CH1
  • GPIO 2 ==> ADC2_CH2
  • GPIO 4 ==> ADC2_CH0
  • GPIO 12 => ADC2_CH5
  • GPIO 13 => ADC2_CH4
  • GPIO 14 => ADC2_CH6
  • GPIO 15 => ADC2_CH3
  • GPIO 25 => ADC2_CH8
  • GPIO 26 => ADC2_CH9
  • GPIO 27 => ADC2_CH7
  • GPIO 32 => ADC1_CH4
  • GPIO 33 => ADC1_CH5
  • GPIO 34 => ADC1_CH6
  • GPIO 35 => ADC1_CH7
  • GPIO 36 => ADC1_CH0
  • GPIO 37 => ADC1_CH1
  • GPIO 38 => ADC1_CH2
  • GPIO 39 => ADC1_CH3

Per leggere l'ingresso analogico, avrai lo stesso che hai fatto con Arduino e ESP8266:

 int analog_value = analogRead (36); 

È molto importante notare che, gli ADC ESP32 hanno 12 bit di risoluzione (rispetto a 10 bit su ESP8266 e Arduino), quindi la gamma totale di ADC che legge va a 4.095 (invece 1.027 su Arduinos e ESP8266) quando viene applicato un massimo di 3, 3 V a i suoi input.

Per l'ingresso, usiamo un potenziometro da 10 K ohm, collegandolo da 3, 3 V e GND. Usiamo il suo output variabile come input per i pin ADC ESP32. Il diagramma sopra mostra il potenziometro collegato a GPIO 36 che è il canale 0. ADC1. Prova anche altri ingressi sulla tua scheda.

Esegui il codice semplice di seguito:

 / ************************************************* ***** * Test ingresso analogico ESP32 * Ingresso analogico: ADC_1_0 pin ==> GPIO36 (VP). * * MJRoBot.org 6Sept17 ********************************************** ********* / // Ingresso analogico #define ANALOG_PIN_0 36 int valore_analogo = 0; void setup () {Serial.begin (115200); ritardo (1000); // dammi il tempo di visualizzare il monitor seriale Serial.println ("ESP32 Analog IN Test"); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); ritardo (500); } 

Ruota il tuo potenziometro e osserva sul monitor seriale IDE le misurazioni che vanno da zero a 4.095.

Passaggio 7: oscuramento di un LED: uscita analogica mediante PWM

Se vogliamo "Dimmerare un LED" su ESP8266 o un Arduino, possiamo semplicemente usare un comando come analogWrite (), che varierà il valore PWM del suo output, simulando un valore analogico. Sfortunatamente, non abbiamo ancora sviluppato questo tipo di comando per ESP32 su Arduino IDE. ma la buona notizia è che tutti e 36 i GPIO ESP32 hanno una funzionalità PWM, il che è fantastico! Solo noi dobbiamo usare un codice più complesso per raggiungere lo stesso risultato.

Quindi, programmiamo uno di quei GPIO con un segnale di uscita PWM.

Puoi trovare un ottimo tutorial nei dettagli su come funziona PWM a questo link: esp32-arduino-led-pwm-fading.

La prima cosa da pensare a un segnale PWM da generare è la sua frequenza. Useremo un valore di 5000 Hz, che funziona perfettamente con il LED. Dobbiamo anche specificare il canale PWM LED e la risoluzione del duty cycle PWM, in bit. Possiamo scegliere un canale da 0 a 15 e una risoluzione compresa tra 1 e 16 bit. Useremo il canale 0 e una risoluzione di 8 bit.

 int freq = 5000; int ledChannel = 0; int risoluzione = 8; 

Usiamo GPIO2, dove abbiamo collegato il nostro LED esterno (e quello interno).

 #define LED_PIN 2 

Tali parametri devono essere definiti durante la fase setup (), utilizzando le funzioni seguenti:

 void setup () {ledcSetup (ledChannel, freq, risoluzione); ledcAttachPin (LED_PIN, ledChannel); } 

Per accendere il LED con una luminosità specifica, dobbiamo definire il "duty cycle".

Ad esempio, per spegnere il LED, il duty cycle deve essere zero e la funzione ledcWrite (ledChannel, dutyCycle) utilizzata per inviare il valore attraverso un canale PWM specifico:

 int dutyCycle = 0; ledcWrite (ledChannel, dutyCycle); 

Valori diversi della variabile dutyCycle accenderanno il LED con luminosità diversa. questa variabile, dutyCycle, varierà da 0 a 255, una volta che la risoluzione utilizzata è di 8 bit.

Possiamo usare il potenziometro (collegato alla variabile analog_value ) per impostare manualmente la variabile dutyCycle, ma una volta che il loro intervallo di valori è diverso, usiamo una funzione della mappa per abbinare input e output:

 dutyCycle = map (valore_analogo, 0, 4095, 0, 255); 

Di seguito il codice completo:

 ************************************************** *** * Test ingresso / uscita analogico ESP32 * Ingresso analogico: ADC_1_0 pin ==> GPIO36 (VP). * Pin LED PWM ==> GPIO 02 * * MJRoBot.org 6Sept17 ************************************ ****************** / // Ingresso analogico #define ANALOG_PIN_0 36 int valore_analogo = 0; // PMW LED #define LED_PIN 2 int freq = 5000; int ledChannel = 0; int risoluzione = 8; int dutyCycle = 0; void setup () {Serial.begin (115200); ritardo (1000); // dammi il tempo di visualizzare il monitor seriale Serial.println ("Test IN / OUT analogico ESP32"); ledcSetup (ledChannel, freq, risoluzione); ledcAttachPin (LED_PIN, ledChannel); ledcWrite (ledChannel, dutyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); dutyCycle = map (valore_analogo, 0, 4095, 0, 255); ledcWrite (ledChannel, dutyCycle); ritardo (500); } 

Questo è tutto!

Passaggio 8: servocomando

Controlliamo un servomotore utilizzando la funzionalità PWM del nostro ESP32. Il codice sarà sostanzialmente lo stesso utilizzato per controllare la luminosità del LED.

Innanzitutto, è importante ricordare che la frequenza di funzionamento con un Micro Servo è 50Hz, quindi è necessario modificare il parametro di frequenza su 50 (anziché 5.000 utilizzati con LED). Dobbiamo anche specificare il canale PWM LED e la risoluzione del duty cycle PWM, in bit. Useremo di nuovo il canale 0 e una risoluzione di 8 bit.

 int freq = 50; int channel = 0; int risoluzione = 8; 

Il Servo sarà collegato a GPIO 5 (vedi schema elettrico sopra).

 #define SERVO_PIN 5 

Come per i LED, questi parametri devono essere definiti durante la fase di installazione (), utilizzando le funzioni seguenti:

 void setup () {ledcSetup (canale, frequenza, risoluzione); ledcAttachPin (SERVO_PIN, canale); } 

Per posizionare il servo su un angolo specifico, è necessario definire il "duty cycle" (vedere lo schema sopra).

Ad esempio, per posizionare il servo di circa 90 gradi, il duty cycle deve essere di circa 21 e la funzione ledcWrite (ledChannel, dutyCycle) deve essere utilizzata per inviare il valore attraverso il canale PWM:

 int dutyCycle = 21; ledcWrite (channel, dutyCycle); 

Valori diversi della variabile dutyCycle posizioneranno il servo con angoli diversi. Questa variabile, dutyCycle, dovrebbe variare da 10 a 32 (questo intervallo è stato ottenuto manualmente).

Come nel caso del LED, il potenziometro (collegato alla variabile analog_value ) può essere utilizzato per impostare manualmente la variabile dutyCycle e, quindi, cambiando la posizione del servo. Una volta che i loro intervalli di valori sono diversi, utilizziamo una funzione mappa per abbinare input e output:

 dutyCycle = map (valore_analogo, 0, 4095, 10, 33); 

Di seguito il codice completo:

 / ************************************************* **** * Servocomando ESP32 * Ingresso analogico: ADC_1_0 pin ==> GPIO36 (VP). * Pin PWM SERVO ==> GPIO 05 * * MJRoBot.org 6Sept17 ************************************* ****************** / // Ingresso analogico #define ANALOG_PIN_0 36 int valore_analogo = 0; // PMW SERVO #define SERVO_PIN 5 int freq = 50; int channel = 0; int risoluzione = 8; int dutyCycle = 21; void setup () {Serial.begin (115200); ritardo (1000); // dammi il tempo di visualizzare il monitor seriale Serial.println ("ESP32 Servo Control"); ledcSetup (canale, frequenza, risoluzione); ledcAttachPin (SERVO_PIN, canale); ledcWrite (channel, dutyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.print (analog_value); Serial.print ("Duty Cycle ==>"); Serial.println (dutycycle); dutyCycle = map (valore_analogo, 0, 4095, 10, 33); ledcWrite (channel, dutyCycle); ritardo (50); } 

Ora possiamo lavorare con il sensore ultrasonico sopra il servo e costruire un radar IoT !. Ma questo sarà un altro tutorial! ;-)

Passaggio 9: Connessione a Internet: Timestamp locale

Dopo aver testato alcune delle funzionalità GPIO digitali / analogiche e di input / output, connettiamo il nostro ESP32 su Internet!

Con la famiglia ESP8266 stavamo usando la libreria esp8266wifi.h per questo. Con ESP32, la libreria da utilizzare sarà:

Un esempio molto semplice sarebbe programmare la nostra scheda per catturare da Internet l'ora locale. Questa è un'ottima funzionalità da avere a portata di mano sui progetti. Il codice seguente lo farà per noi:

 / ************************************************* ************* * Timestamp locale con ESP32 * Sviluppato da Marcelo Rovai - 8 settembre 2017 ********************** **************************************** / #include #include #include #define NTP_OFFSET -3 * 60 * 60 // In secondi #define NTP_INTERVAL 60 * 1000 // In millisecondi #define NTP_ADDRESS "europe.pool.ntp.org" WiFiUDP ntpUDP; NTPClient timeClient (ntpUDP, NTP_ADDRESS, NTP_OFFSET, NTP_INTERVAL); void setup () {Serial.begin (115200); timeClient.begin (); } 

È possibile visualizzare sul monitor seriale l'ora locale da timbrare.

Passaggio 10: server WiFi semplice

Ora proviamo il nostro ESP32 come un semplice server WiFi.

  • Apri il menu ESEMPI sul tuo IDE Arduino e ottieni lo schizzo ESP32 WiFi / SimpleWiFiServer.ino:

A proposito di questo programma:

LED del server Web WiFi lampeggiante

  • Creato per Arduino il 25 novembre 2012 da Tom Igoe
  • Portato per sparkfun esp32 il 31.01.2017 da Jan Hendrik Berlin

Un semplice server Web che consente di far lampeggiare un LED tramite il Web. Questo schizzo stampa l'indirizzo IP della tua rete WiFi ESP32 sul monitor seriale. Da lì, puoi aprire quell'indirizzo in un browser Web per accendere e spegnere il LED sul pin 5.

Se l'indirizzo IP della scheda è ad esempio 10.0.1.40 :

  • //10.0.1.40/H accende il LED
  • //10.0.1.40/L

    spegne il LED

Questo esempio è scritto per una rete che utilizza la crittografia WPA. Per WEP o WPA, modifica la chiamata Wifi.begin () di conseguenza.

Circuito: LED collegato al pin 5

Quindi, usiamo il programma senza modifiche significative. Cambia il pin LED esterno in GPIO5

Ovviamente, se si preferisce cambiare il codice per GPIO2 senza cambiare l'HW.

Innanzitutto, inserisci le credenziali di rete:

 const char * ssid = "yourssid"; const char * password = "yourpasswd"; 

E caricalo sul tuo ESP32.

La prima cosa che vedrai sul tuo monitor seriale saranno le informazioni che il tuo ESP32 è collegato e qual è il suo indirizzo IP:

 WiFi connesso. Indirizzo IP: 10.0.1.40 

Apri il tuo browser preferito, digitando questo indirizzo IP. Otterrai una pagina Web come quella sopra. Lì puoi accendere o spegnere il LED da remoto.

Step 11: DHT 22 - Lettura della temperatura e dell'umidità

Un sensore molto utile da utilizzare nei progetti IoT è il DHT 11 o 22. Sono molto economici e facili da includere nei progetti.

Innanzitutto, è necessario che la libreria Adafrut sia installata sul proprio IDE. Vai al loro GitHub e scarica la versione aggiornata di questa libreria: DHT-sensor-library

Decomprimi il file, rinominalo in DHT e sposta la cartella completa nella directory della tua libreria Arduino

Quando ho usato per la prima volta ho ricevuto un messaggio:

errore irreversibile: Adafruit_Sensor.h: nessun file o directory

Dopo alcuni scavi, ho scoperto che è necessario installare anche la libreria di sensori unificati Adafruit . Quindi, l'ho fatto da Arduino IDE Library Manager (vedi foto sopra). Dopodiché, tutto ha funzionato bene, proprio come facciamo con Arduino e NodeMCU.

Facciamo alcuni test con questo sensore. Seguire lo schema elettrico sopra e installare il DHT22 come mostrato (guardando il sensore con la "griglia" rivolta verso di sé, contare le 4 gambe da sinistra a destra):

  1. Pin VCC ==> 3.3V
  2. Pin Data ==> GPIO 23
  3. N / C
  4. PIN GND ==> GND

Inoltre, collegare una resistenza da 10K ohm tra VCC e Data.

Questo è tutto!

È possibile utilizzare lo schizzo di esempio "DHT tester.ino" che è incluso nella libreria o fare il proprio.

Ho scritto un semplice codice per testare il sensore come mostrato di seguito:

 / ************************************************* **** * Lettura DHT ESP32 * Ingresso DHT: ==> GPIO23. * * MJRoBot.org 9Sept17 ********************************************** ********* / / * DHT * / #include "DHT.h" #define DHTPIN 23 #define DHTTYPE DHT22 DHT dht (DHTPIN, DHTTYPE); float localHum = 0; float localTemp = 0; void setup () {Serial.begin (115200); ritardo (1000); // dammi il tempo di visualizzare il monitor seriale Serial.println (""); Serial.println ("Temperatura e umidità DHT ESP32"); Serial.println ( ""); dht.begin (); } void loop () {getDHT (); Serial.print ("Temp: ==>"); Serial.print (localTemp); Serial.print ("Hum ==>"); Serial.println (localHum); ritardo (2000); } / ************************************************** *** * Ottieni dati Temp / Hum interni ****************************************** ************ / void getDHT () {float tempIni = localTemp; float humIni = localHum; localTemp = dht.readTemperature (); localHum = dht.readHumidity (); if (isnan (localHum) || isnan (localTemp)) // Controlla se le letture non sono riuscite ed esce presto (per riprovare). {localTemp = tempIni; localHum = humIni; ritorno; }} 

Puoi vedere il risultato sopra PrintScreen di Serial Monitor.

Passaggio 12: invio e ricezione di dati da una pagina Web locale

Rivedere ciò che abbiamo trattato finora in questo tutorial:

  • Uscita digitale: lampeggiante di un LED
  • Ingresso digitale: lettura di un sensore touch
  • Ingresso analogico: lettura di una tensione variabile da un potenziometro
  • Uscita analogica: controllo della luminosità del LED
  • Uscita analogica: controllo di una posizione servo
  • Lettura dei dati di temperatura / umidità con un sensore digitale
  • Connessione a Internet e ora locale
  • Creazione di una semplice pagina Web per accendere / spegnere un LED (ricezione dei dati)

Ci rendiamo conto che dobbiamo ancora provare a inviare dati a una pagina Web. Facciamolo!

Prenderemo i dati generati dal nostro sensore DHT e il valore analogico fornito dal potenziometro e li invieremo alla pagina web creata per controllare i LED.

Ho iniziato dal codice SimpleWiFiServer utilizzato nel passaggio 10 e ho aggiunto le righe di codice pertinenti per ottenere i dati potenziometro e DHT.

Nota che ho spostato indietro il LED su GPIO 2, come puoi vedere nello schema elettrico.

Scarica il codice completo dal mio GitHub: ESP32_WiFi_Server_Sending_Receiving_Data.ino

Nota che ho organizzato meglio il codice e ora il loop () è solo:

 void loop () {analog_value = analogRead (ANALOG_PIN_0); getDHT (); WiFiLocalWebPageCtrl (); } 

La novità qui è la funzione "WiFiLocalWebPageCtrl ()". Ma questa è esattamente la funzione setup () originale utilizzata su SimpleWebServer. Ciò che ho incluso in questa funzione è ciò che dovrebbe apparire nella pagina Web (vedere la schermata di stampa sopra per la pagina Web).

 // il contenuto della risposta HTTP segue l'intestazione: // WiFiLocalWebPageCtrl (); client.print ("La temperatura ora è:"); client.print (localTemp); client.print ("oC 
"); client.print (" Humidity now is: "); client.print (localHum); client.print ("%
"); client.print ("
"); client.print (" Analog Data: "); client.print (analog_value); client.print ("
"); client.print ("
"); client.print (" Fai clic qui per accendere il LED.
"); client.print (" Fai clic qui per spegnere il LED.
");
Si noti che la temperatura, l'umidità e i valori analogici verranno aggiornati ogni volta che si fa clic sui collegamenti utilizzati per il controllo LED o quando si aggiorna la pagina.

Passaggio 13: conclusione

Potremmo andare avanti all'infinito, ma non avremmo mai coperto tutte le funzioni o potenzialità di ESP32. C'è ancora molto da esplorare con questo fantastico dispositivo IoT e nel mio prossimo tutorial imparerai come aggiungere un display OLED sul tuo ESP32:

Display ESP32 e OLED: Internet Clock - DHT22

Torneremo presto con i nuovi tutorial ESP32!

Come sempre, spero che questo progetto possa aiutare gli altri a trovare la loro strada nel fantastico mondo dell'elettronica, della robotica e dell'IoT!

Visitate il mio GitHub per i file aggiornati: riproduzione con ESP32 e Arduino IDE

Per altri progetti, visita il mio blog: MJRoBot.org

Saluti dal sud del mondo!

Ci vediamo al mio prossimo istruttore!

Grazie,

Marcelo

Articoli Correlati