Scopriamo i mille risvolti applicativi di uno dei più utilizzati moduli WiFi con una scheda di prototipazione che può ospitare e gestire sensori e attuatori sperimentabili con firmware di test da noi scritti appositamente. Prima puntata.
I moduli basati sul SoC ESP32 della Espressif sono molto apprezzati dai progettisti di applicazioni connesse tramite interfaccia wireless WiFi e per questo da anni li vediamo utilizzati e li utilizziamo anche noi in vari progetti. Proprio per la loro importanza e per la grande richiesta da parte degli sviluppatori e degli sperimentatori, abbiamo pensato di realizzare una demoboard che consenta di creare firmware sia per testare una vasta gamma di sensori, sia di imparare a programmare per l’ESP32 e creare applicazioni connesse, prime fra tutte quelle nell’ambito dell’Internet of Things.
La scheda che utilizzeremo ha come “core” un modulo basato wireless su ESP32 e dispone poi di tutta una serie di header (connettori) per innestarvi svariate breakout board e moduli che ne costituiscono le periferiche, ovvero sensori di pressione, ultravioletti, qualità dell’aria, fulmini, gesture ed un lettore RFID compatibile NFC. A completare la scheda c’è un’interfaccia utente formata da un display OLED, una serie di pulsanti e dei LED, tutti configurabili per ottenere una specifica modalità di interfacciamento.
Vediamo subito di cosa si tratta, analizzando nel dettaglio la scheda, prima di passare alla descrizione dello schema elettrico corrispondente.
La scheda
La nostra demoboard è basata sulla Board con ESP32 (cod. YB555 commercializzata da www.futurashop.it), dotata di connettore MicroUSB che viene utilizzato per la programmazione, ma allo stesso tempo può fornire alimentazione a tutta la demoboard, a patto che la corrente richiesta non sia superiore a un certo valore, erogabile dalla board ESP32. In alternativa, può essere fornita alimentazione 12V al plug di alimentazione PWR, quindi sarà il regolatore U2 della demoboard (cod. MP1584ENDCDC) ad ottenere i 5V per tutto il resto del circuito. Nella Fig. 1 trovate la pin-out del modulo ESP32 in questione.
Sulla nostra demoboard possono essere alloggiati i seguenti moduli:
- Sensore qualità aria cod. SGP30CO2 (U3)
- Sensore fulmini cod. FT1324M (U4)
- Gesture cod. APDS9960BOUT (U5)
- Sensore UVB cod. GYLM8511 (U6)
- Sensore pressione cod. BMP280 (U7)
- Lettore NFC/RFID cod. PN532 (U8)
- Display OLED 0,96” cod. OLED096C oppure cod. OLEDGVSCSD (OLED1)
- Relé 5V (RL1)
- LED rosso (LD1)
- Led verde (LD2)
- 5 pulsanti (P1, P2, P3, P4, P5)
- BreadBoard
- Possibilità di collegamento dispositivi SPI 3.3V (SPI)
- Possibilità di collegamento di altri dispositivi I²C 3,3V (I²C)
Connettori aggiuntivi e periferiche esterne
Oltre a quanto già previsto sopra, è possibile connettere altri dispositivi sfruttando i pin liberi della board ESP32. I pin senza alcuna connessione sono D1/TX0, D2, D3/RX0, D34 oltre ai pin SPI che non sono utilizzati per il collegamento ad alcuna breakout board.
Per quanto riguarda i connettori pensati per la connessione a breakout board e sensori esterni alla scheda, abbiamo previsto questi elementi:
- Sensore torbidità (trasparenza) dei liquidi cod. TORBISENS (CNU9)
- Sensore PIR cod. PIRMOD / cod. MINIPIRMOD (CNU10)
- Servo motore, ad esempio cod. SERVO206 (CNU11)
Tutti i codici riportati tra parentesi si riferiscono ai prodotti presenti sul sito www.futurashop.it, per una più rapida identificazione. Diamo comunque uno sguardo allo schema elettrico della board, riportato al completo nella pagina qui accanto.
Schema elettrico
Il circuito, come vedete, è centrato sulla board ESP32 che è siglata U1 e che riceve l’alimentazione principale attraverso il piedino Vin; il suo regolatore interno fornisce 3,3V stabilizzati che alimentano le schede di interfaccia applicabili alla demoboard alimentabili con tale tensione, ossia a tutti quelli ospitabili on-board eccetto U6.
Il contatto Vin dell’U1 è alimentato con i 5V che l’alimentatore principale ricava dalla tensione d’ingresso applicata al jack DC di alimentazione PWR; la tensione d’ingresso viene dapprima filtrata dai condensatori C1 e C2 e poi ridotta a 5V dal regolatore U2, che è un modulo DC/DC step-down MP1584ENDCDC, capace di erogare 3A di corrente su 5V stabilizzati: abbastanza per far funzionare tutti i moduli breakout board supportati dalla nostra scheda demo.
I 5V di uscita (filtrati adeguatamente da C3, C4 e C11 per abbattere i residui di commutazione del modulo switching) vanno ad alimentare i moduli funzionanti a tale tensione (modulo UVB) e i connettori per servo (CNU11) PIR (CNU10) e sensore di torbidità esterno (CNU9), nonché la bobina del relé, che viene commutata dal transistor NPN T1, dietro comando della linea di I/O D32 del modulo ESP32. Del RL1 (la cui bobina è stata dotata di diodo in antiparallelo per proteggere la giunzione di collettore del T1 all’interdizione) rendiamo disponibili i tre contatti dello scambio, in modo da gestire vari tipi di utilizzatore e varie condizioni operative; il relé è una periferica attuatrice associabile ad esempio al superamento di certe soglie di rilevamento da parte dei sensori, ovvero alle funzionalità di lettura del modulo RFID/NFC.
Display OLED e comunicazione I²C
Il display a bordo scheda è un piccolo OLED interfacciabile tramite I²C-Bus più volte utilizzato nei nostri progetti per la sua versatilità, per il basso costo e per la disponibilità di librerie Arduino dedicate alla sua gestione. Si tratta dell’OLED096C commercializzato dalla Futura Elettronica: Modulo con display OLED (Organic Light Emitting Diode) 128×64 pixel di colore blu, interfaccia I²C, controller grafico SSD1306, angolo di visione circa 180°, compatibile Arduino.
La libreria prevista per il controller grafico ha una struttura modulare e alcuni moduli possono essere esclusi dalla compilazione per ridurre l’utilizzo di spazio nella Flash memory. Richiede pochissima RAM e supporta, oltre alla comunicazione I²C-Bus, anche la SPI: nel primo caso si esegue un’implementazione software (libreria Wire, AVR Twi, Linux i2c-dev) e nel secondo un’implementazione SPI a 4 fili (libreria Arduino SPI, AVR Spi, modulo AVR USI).
Il controller permette di realizzare funzioni grafiche primitive (linee, rettangoli, pixel, bitmap) e stampa del testo (utilizzando caratteri di dimensioni diverse, è possibile utilizzare GLCD Font Creator per creare nuovi caratteri).
La gestione del display avviene da parte del modulo U1, mediante il bus I²C comune ad altre unità di bordo come i moduli U3 (sensore di qualità dell’aria) U4 (rilevatore di fulmini) U5 (rilevatore di gesture) U7 (sensore di pressione) U8 (modulo RFID/NFC) e riportato all’esterno tramite il connettore siglato I2C, per interfacciare la demoboard con unità esterne. Nello schema elettrico potete notare che l’alimentazione dell’OLED1 avviene tramite due jumper a tre vie che vanno disposti l’uno complementarmente all’altro; lo scopo è consentire di montare le varie versioni esistenti in commercio, che possono avere i pin di alimentazione + e – (1 e 2) invertiti; quindi se il pin 1 è il positivo, chiuderete il jumper J1 su +3V3 e il J2 su GND, mentre se è il negativo, farete il contrario (J1 su GND e J2 su +3V3).
Bus SPI, LED e pulsanti
Il nostro modulo ESP32 implementa anche un bus SPI a 4 fili (MISO, MOSI, SCK e CS) utile per interfacciare la demoboard a dispositivi SPI (in questo caso si utilizza il connettore omonimo) e sensori vari; a riguardo va detto che malgrado il sensore on-board U4 supporti la comunicazione bivalente SPI/I²C-Bus, abbiamo preferito interfacciarlo all’U1 tramite l’I²C-Bus già descritto, che fa capo alle linee D21/SDA e D22/SCL dell’ESP32. Invece il bus SPI completo fa capo alle linee di I/O D13 (MOSI) D12 (MISO) D14 (SCK) e D15 (CS-Chip Select) dell’ESP32 e sul relativo connettore riportiamo anche GND e alimentazione +3,3 volt.
Oltre ai connettori e ai moduli sinora descritti, la demoboard riporta due LED multifunzione pilotati dalle linee D25 e D26 del modulo U1 (nella comunicazione USB servono a indicare la commutazione del canale dati) gestibili da firmware in base all’applicazione desiderata; a completare il circuito abbiamo previsto cinque pulsanti unipolari normalmente aperti utilizzabili ad esempio per impostare dei valori, delle soglie, ovvero per gestire menu a display, non a caso i tasti hanno associate queste funzioni:
- P1 = OK
- P2 = UP
- P3 = DOWN
- P4 = LEFT
- P5 = RIGHT
E la loro disposizione sul circuito stampato ricalca un po’ quella di un classico joypad. Se intendete utilizzare i pulsanti per altre funzioni, potete farlo tranquillamente (modificando l’esempio firmware che verrà proposto di volta in volta tra gli esempi) e rinominarli in base alle vostre esigenze.
A completare la demoboard abbiamo inserito una piccola breadboard a 170 contatti posizionata centralmente, utilizzabile sia per cablare breakout board utilizzando jumper Arduino e i contatti o connettori SIL dei moduli on-board, sia per collegare componenti attivi e passivi a specifiche parti del circuito, con cui fare piccoli circuiti.
Realizzazione pratica
Bene, a questo punto abbiamo descritto la scheda demo, possiamo passare alla parte costruttiva: la realizzazione della demoboard inizierà dal circuito stampato a doppia faccia sul quale prenderanno posto tutti i componenti necessari, i quali, per rendere il progetto più accessibile ai maker, sono a montataggio THT ossia a foro passante o tradizionale, se preferite. Quindi è possibile, dopo aver ottenuto il circuito stampato, realizzare la scheda con un minimo di attrezzatura, che si limita a un saldatore per elettronica, del filo di lega saldante e un tronchesino per tagliare gli avanzi dei terminali dei componenti.
Una volta preparata la basetta per fotoincisione (ovvero dopo averla ottenuta dal servizio di realizzazione PCB offerto da Futura Elettronica, alla pagina web del sito https://futuranet.it/prodotto/servizio-realizzazione-pcb/ partendo dalle due tracce lato rame scaricabili dal nostro sito web www.elettronicain.it), potete passare al montaggio vero e proprio.
Iniziate posizionando e saldando i componenti a più basso profilo, quindi resistenze, LED, condensatori non polarizzati, pin-strip e strip femmina per le connessioni e per i moduli che saranno ospitati a bordo, poi i LED, i pulsanti e i condensatori elettrolitici, infine il jack di alimentazione. Montate poi la breadboard, che va semplicemente incollata, nella posizione indicata dal piano di montaggio, con del biadesivo perché non ha piedini o reofori. Per i componenti polarizzati (semiconduttori ed elettrolitici) dovete rispettare scrupolosamente il verso d’inserimento indicato nel piano di montaggio che trovate in queste pagine.
Non dimenticate di prestare attenzione alla polarità dei contatti di alimentazione del display OLED e di impostare di conseguenza (come già spiegato qualche paragrafo indietro) i relativi jumper J1 e J2 per applicare l’alimentazione con la polarità corretta.
Per alimentare la scheda è necessario fare uso di una fonte (non necessariamente stabilizzata) di alimentazione che eroghi una tensione di 8÷12 volt in continua ed una corrente di almeno 1A (in realtà la corrente dipende da quanti e quali moduli monterete).
Ricordiamo che sebbene nelle foto in queste pagine vedete la demoboard completa, in realtà non serve montarvi tutti i moduli ma, di volta in volta, quelli con cui dovrete lavorare; resta inteso che due devono sempre essere presenti: il DC/DC (U2) e chiaramente l’U1, vale a dire il modulo contenente il SoC ESP32.
Elenco Componenti:
C1, C4, C6, C8, C10, C11:
100 nF ceramico
C2, C3, C5, C7, C9: 100 µ
16 VL elettrolitico
D1: 1N4148
LD1: LED 5 mm rosso
LD2: LED 5 mm verde
P1, P2, P3, P4, P5: Microswitch
R1, R2: 330 ohm
R5: 6,8 kohm
R6: 3,3 kohm
R3: 4,7 kohm
R4: 10 kohm
RL1: Relè 5V 1 scambio
T1: BC547
U1: Breakout ESP32-WROOM-32
U2: Modulo Step-Down 5V/3A
U3: Modulo qualità aria SGP30
U4: Sensore fulmini AS3935
U5: Modulo Gesture PDS-9960
U6: Modulo sensore UVB
U7: Modulo sensore pressione
U8: Modulo NFC/RFID
OLED1: Display OLED 0.96”
Varie:
- Pin strip maschio 2 vie passo 2.54mm (4 pz.)
- Pin strip maschio 3 vie passo 2.54mm (5 pz.)
- Pin strip maschio 4 vie passo 2.54mm (1 pz.)
- Pin strip maschio 6 vie passo 2.54mm (3 pz.)
- Pin strip maschio 7 vie passo 2.54mm (1 pz.)
- Pin strip maschio 15 vie passo 2.54mm (2 pz.)
- Pin strip femmina 2 vie passo 2.54mm (4 pz.)
- Pin strip femmina 4 vie passo 2.54mm (2 pz.)
- Pin strip femmina 5 vie passo 2.54mm (1 pz.)
- Pin strip femmina 6 vie passo 2.54mm (2 pz.)
- Pin strip femmina 7 vie passo 2.54mm (1 pz.)
- Pin strip femmina 15 vie passo 2.54mm (2 pz.)
- Pin strip femmina 4 vie passo 2.54mm 90° (1 pz.)
- Jumper (2 pz.)
- Morsetto 3 vie passo
5 mm
- Breadboard 170
contatti
- Plug alimentazione
- Circuito stampato S1632 (140x110 mm)Preparazione IDE Arduino
Quando avete completato la vostra demoboard a livello hardware, potete concentrarvi sugli aspetti software, che riguardano la creazione delle applicazioni e la programmazione del modulo ESP32.
Come prima cosa sarà necessario installare la board ESP32 in modo che possa poi essere programmata dall’IDE. Per farlo dovete aprire l’IDE, quindi dal menu “File > Impostazioni” inserire la stringa https://dl.espressif.com/dl/package_esp32_index.json nella casella URL aggiuntive per il Gestore schede (Fig. 2).
Fatto ciò, dal menu “Strumenti > Scheda” dovete impartire il comando “Gestore Schede” e selezionare la vostra scheda ESP32, ovvero digitare ESP32 nella casella di testo in alto e procedere con l’installazione del pacchetto board ESP32 by Espressif Systems (Fig. 3).
Ora, sempre dal menu “Strumenti > Scheda > Gestore Schede” scegliere la board “DOIT ESP32 DEVKIT V1” come mostrato in Fig. 4.
Tutto è pronto per la programmazione, pertanto da questo punto in poi si potrà scrivere il codice necessario per la gestione della breakout board d’interesse. A tal proposito abbiamo già reso disponibili una serie di Sketch di esempio per ogni breakout, pertanto avrete sempre disponibile una base di partenza che semplifica senz’altro lo sviluppo ad hoc del codice. Le cartelle con gli sketch scaricabili dal nostro sito www.elettronicain.it sono quelle proposte nello screenshot di Fig. 5. Nella cartelle di ogni singolo esempio si troverà disponibile la libreria ad esso abbinata, qualora il codice lo renda necessario. Inoltre, sempre in ogni cartella sarà disponibile il file “info.txt” che spiega in breve lo scopo dell’esempio.
Quasi per tutti gli esempi sarà necessario avere montato il modulo display OLED da 0,96”; a tal proposito ricordiamo che a bordo scheda è possibile utilizzare sia i display OLED con la pinout GND/VCC/SCL/SDA, come pure quelli aventi una piedinatura del tipo VCC/GND/SCL/SDA, semplicemente andando a configurare i due jumper J1 (per il pin 1) e J2 (per il pin 2) in modo da portare sul pin 1 o 2 del display la GND piuttosto che VCC a seconda del display installato.
Prima applicazione: sensore acqua
Questo esempio applicativo consiste nella lettura del valore di “torbidità” dell’acqua mediante lo specifico sensore collegabile allo strip CN9.
Questo connettore può anche essere utilizzato per leggere una tensione massima di 5V, in quanto vi è un partitore all’ingresso che ne abbassa la tensione ad un massimo di 3,3V; tale riduzione diventa necessaria perché l’ingresso corrispondente dell’ESP32 sopporta una tensione ordinaria di 3,3V ed una massima di 5V, oltre cui il modulo ESP32 viene danneggiato.
Il sensore utilizzato è il 9145-TORBISENS reperibile sul sito www.futuranet.it (Fig. 6) e consta di un elemento sensore vero e proprio, da immergere parzialmente nell’acqua di cui si vuole rilevare la limpidezza o torbidità, ed una scheda di condizionamento del segnale e interfaccia, che fornirà un’informazione digitale o analogica e che dovrete collegare al connettore CNU9.
Il sensore è in grado di rilevare le particelle sospese nell’acqua (o altro liquido, purché non aggressivo chimico o solvente) misurando la trasmissione della luce e la velocità di dispersione che cambia con la quantità totale di solidi sospesi (TSS) in acqua. All’aumentare del TTS (Total Suspended Solids), il livello di torbidità liquida aumenta. Dispone di uscita analogica e digitale.
Per l’uso di questo sensore è bene ricordare che va immersa la sola parte in plastica trasparente con le due “punte” perché la parte superiore della sonda (quella dove si collega il cavetto) non è a tenuta d’acqua. La temperatura dei liquidi in cui il sensore può essere immerso deve essere compresa fra +5°C e +90°C: tenetene conto nell’utilizzo.
Una volta introdotta nell’acqua la parte sensibile, il sensore fornisce il relativo valore in un tempo dell’ordine dei 500 ms. Se l’uscita è impostata come analogica, fornisce una tensione da 0 a 4,5 V inversamente proporzionale alla torbidità del liquido; se invece è impostata come digitale, la soglia di torbidità si può regolare tramite l’apposito trimmer sulla scheda d’interfaccia (0=torbido; 1=limpido).
Lo sketch che vi proponiamo di caricare per utilizzare il sensore di torbidità dell’acqua è quello che vedete proposto nel Listato 1.
Listato 1
/**************************************************************************
This is an example for our Monochrome OLEDs based on SSD1306 drivers
This example is for a 128x64 pixel display using I2C to communicate
3 pins are required to interface (two I2C and one reset).
Adafruit invests time and resources providing this open
source code, please support Adafruit and open-source
hardware by purchasing products from Adafruit!
Written by Limor Fried/Ladyada for Adafruit Industries,
with contributions from the open source community.
BSD license, check license.txt for more information
All text above, and the splash screen below must be
included in any redistribution.
**************************************************************************/
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED displdfsfdfsfdsfdsfdsfdsay height, in pixels
// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
// The pins for I2C are defined by the Wire-library.
// On an arduino UNO: A4(SDA), A5(SCL)
// On an arduino MEGA 2560: 20(SDA), 21(SCL)
// On an arduino LEONARDO: 2(SDA), 3(SCL), ...
#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
#define NUMFLAKES 10 // Number of snowflakes in the animation example
#define LOGO_HEIGHT 16
#define LOGO_WIDTH 16
const int Sens = 33;
void setup()
{
Serial.begin(9600);
// SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
Serial.println(F(“SSD1306 allocation failed”));
for(;;); // Don’t proceed, loop forever
}
// Show initial display buffer contents on the screen --
// the library initializes this with an Adafruit splash screen.
display.display();
delay(2000); // Pause for 2 seconds
// Clear the buffer
display.clearDisplay();
display.setTextSize(2); // Draw 2X-scale text
display.setTextColor(SSD1306_WHITE);
display.setCursor(5, 0);
display.print(“** Test **”);
display.setCursor(20, 30);
display.print(“ Analog “);
// Show the display buffer on the screen. You MUST call display() after
// drawing commands to make them visible on screen!
display.display();
delay(2000);
// display.display() is NOT necessary after every single drawing command,
// unless that’s what you want...rather, you can batch up a bunch of
// drawing operations and then update the screen all at once by calling
// display.display(). These examples demonstrate both approaches...
/*
// Invert and restore display, pausing in-between
display.invertDisplay(true);
delay(1000);
display.invertDisplay(false);
delay(1000);
*/
pinMode(Sens,INPUT);
}
void loop()
{
int val_adc = 0;
float val_tens;
String txt_msg;
val_adc=analogRead(Sens);
val_tens = float(500)/float(4096);
val_tens = float(val_tens) * float(val_adc);
val_tens = float(val_tens) / float(100);
txt_msg=””;
txt_msg = String(val_tens,4) + “V”;
Serial.println(txt_msg);
OLED_Message(“5V max for CNU9-OUT”,txt_msg);
delay(500);
}
void OLED_Message(String text_display1, String text_display2)
{
int lunghezza = 0;
display.clearDisplay();
display.setTextSize(1); // Draw 2X-scale text
display.setTextColor(SSD1306_WHITE);
display.setCursor(0, 20);
lunghezza = text_display1.length();
lunghezza=21-lunghezza;
lunghezza=lunghezza/2;
for (int i=0;i<lunghezza;i=i+1)
{
display.print(“ “);
}
display.print(text_display1);
display.setCursor(0, 40);
lunghezza = text_display2.length();
lunghezza=21-lunghezza;
lunghezza=lunghezza/2;
for (int i=0;i<lunghezza;i=i+1)
{
display.print(“ “);
}
display.print(text_display2);
display.display();
}Quanto al collegamento tra sensore, scheda d’interfaccia in dotazione e demoboard, vale lo schema di cablaggio proposto nella Fig. 7; nell’immagine, i colori dei fili sono rosso per il +5V, nero per la massa (GND) e blu per il segnale.
Conclusioni
Bene, con questo primo esempio di utilizzo terminiamo la panoramica sulla demoboard ESP32; nella prossima puntata vi proporremo nuovi sketch e nuove applicazioni che coinvolgeranno sia i sensori e i moduli on-board, sia moduli collegabili esternamente mediante i connettori laterali.
La demoboard proposta in queste pagine nasce per sviluppare e prototipare applicazioni “connesse” che sfruttano l’interfaccia Wireless WiFi per pubblicare o trasferire dati relativi ai sensori e lettori presenti a bordo o collegati esternamente tramite le connessioni di cui dispone; gli stessi parametri possono essere parzialmente gestiti e visualizzati, in funzione di monitor, dal display OLED di bordo.
La ricca dotazione di sensori rende la scheda candidata ideale allo sviluppo e la prototipazione di applicazioni nel campo dell’IoT proprio in virtù della funzione di bridge tra dati dei sensori e Internet o connessione wireless locale. Con qualche riga di codice in più è anche possibile eseguire un minimo di Edge Computing in modo da aggregare i dati di più sensori per risparmiare banda nella trasmissione verso la Rete.
