Questa piccola schedina di appena 3,5×2,5 cm ospita a bordo un microcontrollore ESP32 equipaggiato con 4 MB di flash per i firmware, un processore ESP32-S2FN4R2 con clock a 240Mhz, 2MB di SRAM ,un interfaccia WiFi a 2,4Ghz e BlueTooth e ben 27 GPIO settabili .
PIN OUT
Tutti i pin GPIO possono essere programmati come ADC, DAC, I2C, SPI, UART.
La programmazione può essere eseguita tramite linguaggi :
Arduino IDE
MicroPython
CircuitPython
Programmazione tramite Arduino IDE
La programmazione tramite ide Arduino e’ possibile caricando le librerie per la gestione schede (sulle impostazioni dell’ide) inserendo il link :
Selezionando poi nel menu Strumenti->Scheda->ESP32 Arduino->ESP32S2 Dev Module
Collegando la scheda non vedremo accendersi nessun led e la porta non comparira’ nell’elenco del menu Strumenti->porta come se la scheda non venisse riconosciuta.
A questo punto e’ necessario premere, sulla scheda, contemporaneamente i tasti RESET e D per alcuni secondi, poi rilasciare il tasto RESET mantenendo premuto per alcuni secondi il tasto D, ora la porta USB verrà riconosciuta con il nome /dev/ttyACM0.
Adesso possiamo lanciare la compilazione e il caricamento del firmware. Alla fine del caricamento l’ide ci dara’ un errore di reset e ci invitera’ a eseguire un reset hardware della scheda, lanciando cosi il FW caricato. Questo errore e’ stato risolto sulle nuove versioni della scheda.
ATTENZIONE ! Purtroppo non e’ possibile usare la porta USB come uscita seriale, in quanto l’ESP32 quando e’ in modalita’ “running”, non gestisce la USB integrata, pertanto se abbiamo necessita di eseguire il debug o comunque usare delle comunicazioni seriali, dobbiamo attivare una UART convertendola in RS232 o RS485, tramite interfacce UART->RSxxx a 3,3V collegate a due GPIO o tramite translatori di livelli a delle interfaccie TTL->RSxxx
Alimentazione del Modulo
L’alimentazione del modulo può avvenire tramite la porta USB oppure tramite il piedino VBUS, l’alimentazione tramite VBUS deve essere compresa tra 3,3 e 6Vdc massimo.
Attenzione gli ingressi vanno sempre pilotati a 3,3 massimo altrimenti si rischia la “frittura” del chip
Letture ingressi analogici
La lettura analogia degli ingressi non e’ lineare da 0 a 3,3V ma si può raggiungere una buona linearità delle letture nell’intervallo 0.10 -2.50Vdc, pertanto per una lettura precisa di tensioni superiori a 2,5Vdc e’ consigliabile l’uso di un partitore di tensione con resistenze di precisione.
L’esp32-s2 ha i convertitori AD a 13 bit pertanto la lettura dei pin restituira’ valori da 0 a 8192
Modulo estremamente piccolo di dimensioni (2,4×1,6 cm) ma eccezionale per applicativi IOT, equipaggiato con un processore 32bit a 160Mhz e un modulo WiFI 2,4Ghz capace di trasmettere fino a 25dBm. unico ‘neo’ ha solo un ingresso analogico con tensioni in ingresso da 0 a 1 volt (0-1024). I consumi sono molto ridotti si parla di 70mA in trasmissione (con picchi di 500mA), 20mA con modulo wifi in stand-by, fino a 0,02mA in modalita’ sleep. Come tutta la famiglia ESP l’alimentazione e tutti gli ingressi/uscite, e’ a 3,3Vdc.
Utilizzo.
Non perdiamo troppo tempo con le caratteristiche, volendo le possiamo approfondire leggendo il data sheet che potete scaricare al link in fondo alla pagina, ma passiamo a vedere come utilizzare il modulo nei circuiti.
Innanzi tutto dobbiamo sapere che per far funzionare il modulo nelle varie modalita’, flashing, upload-firmware e normal use, e’ necessario fornire i giusti segnali ad alcuni piedini che sono:
RST reset PIN1
EN/CH_PD enable PIN3
GPIO0 ingresso 0 PIN18
GPIO15 ingresso 15 PIN 16
Ne caso dell’utilizzo normale (normal use) del modulo i suddetti pin dovranno essere collegati come da schema.
Caricamento firmware con IDE arduino
Per caricare i firmware utilizzando l’IDE di arduino, possiamo sfruttare un semplicissimo ed economico adattatore USB->TTL, collegando i pin come evidenziato nello schema qui sotto.
Vediamo di seguito come impostare l’ide di arduino per caricare il firmware
E’ buona norma non utilizzare l’eventuale uscita di alimentazione del convertitore USB->TTL per alimentare il modulo durante la programmazione, in quanto potrebbe non fornire abbastanza corrente per l’operazione, ma e’ preferibile fornire l’alimentazione al modulo tramite una fonte esterna, anche perche’ se il modulo non andasse in scaricamento del firmware e’ necessario disalimentare e rialimentare senza scollegare la porta USB.
In questo articolo vediamo come far comunicare questi due microcontrollori sfruttando il bus I2C.
La famiglia ESP lavora a 3,3V mentre la famiglia Arduino usa i 5V, questa differenza rende complicata la comunicazione tra i due microcontrollori se non andiamo a interporre un adattatore di livelli sulla UART. Il protocollo I2Cpuo’ lavorare sia a 3,3 che a 5V pertanto useremo questo BUS per la comunicazione tra i due microcontrollori.
img1
– SCHEMA ELETTRICO –
Nel caso che vedremo andremmo a settare l‘esp32 come Master mentre l’arduino nano verrà impostato come slave. Il protocollo I2C prevede che il master “interroghi” ogni singolo slave e attenda la sua risposta.
L’img1 mostra il semplicissimo schema di collegamento tra le due schede. Per il progetto useremo i pin di default I2C per entrambi ( pin21,22 per ESP e pin A4,A5) che corrispondono rispettivamente SDA linea dati e SCL clock di sincronismo. Il protocollo prevede che il bus abbia la linea SDA a livello logico alto che viene abbassato al momento della comunicazione, il master generera’ il clock (SCL). I due dispositivi devono avere in comune la massa GND.
La comunicazione tra i due device puo avvenire in due modi, nel primo il master invia una richiesta di n byte allo slave senza specificare nulla e lo slave risponde con le istruzioni contenute nella funzione specificata in .onRequest(funzione). Mentre nel secondo caso, il master invia prima dei dati allo slave il quale li elabora tramite la funzione richiamata da .onReceive(funzione) poi il master richiede i dati allo slave.
Vediamo nel dettaglio i due casi con l’ausilio di schemi e codici di esempio.
1° caso
Il master invia una richiesta di nbyte dati allo slave tramite la funzione wire.requestFrom(indirizzo, nbyte) allo slave indirizzo e poi si mette in ascolto per la risposta. Lo slave attiva la funzione onRequest() e risponde al master
– Codice –
Vediamo il codice da inserire nel master:
//ESP32 - I2C master
#include "Wire.h" //libreria I2C
void setup(){
Serial.begin(9600);Wire.begin(); //senza valori significa che e' master
}void loop(){Serial.println("Avvio trasmissione...");
//contatta lo slave con indirizzo 0x1
Wire.requestFrom(1,12); //invio richiesta e mi aspetto 12 byte di risposta
while(Wire.available()){
//stampo i dati provenienti dal bus
char c = Wire.read();
Serial.print(c);
}
Serial.println("\n Ricezione completata.");
delay(2000);
}
e il codice dello slave:
//arduino nano I2C slave
#include "Wire.h" //libreria I2C
int LED = 13;
int roger = 0;
void setup() {
pinMode(LED,OUTPUT);
Wire.begin(1); //inizializzo il BUS e assegno indirizzo 1
Wire.onRequest(richiestaRicevuta); //imposto la funzione da eseguire su chiamata dal master
}
//funzione richiamata su ricezione dal master
void richiestaRicevuta(){
digitalWrite(LED, HIGH); // accendo il led on board
Wire.write("HELLO WORLD!"); //invio la risposta sul bus i2c
roger = 1; // setto il roger a 1
}
void loop() {
if(roger){
int ritardo = 1000*roger; //calcolo il tempo di accensione
delay(ritardo);
digitalWrite(LED, LOW); // spengo il led on board
roger = 0; // resetto il roger
}
}
I commenti inseriti nel codice sono sufficienti a capire come lavora. In pratica il Master(esp32) invia sul bus I2C una richiesta allo Slave con indirizzo 1 (arduino nano), il quale arrivata la chiamata, risponde al Master con il messaggio “HELLO WORLD!”. Il master a questo punto rimane in ascolto e riceve i 12 byte che aveva richiesto allo slave stampando i caratteri in ordine di arrivo.
2° caso
In questo caso il master invia prima dei dati verso lo slave, lo slave attiva la funzione onReceive() ed elabora i dati inviati dal master e termina. Subito dopo il master invia una richiesta dati e lo slave attiva la funzione onRequest().
Il codice da inserire nel master
//ESP32 - I2C master
#include "Wire.h" //libreria I2C
String msg ="ita";
void setup(){
Serial.begin(9600);
Wire.begin(); //senza valori significa che e' master
}
void loop() {
Serial.print("richiesto messaggio in : ");
Serial.println(msg);
//inizia la trasmissione verso lo slave 1
Wire.beginTransmission(1);
if(msg == "ita"){
Wire.write("ita");
msg="eng";
} else {
Wire.write("eng");
msg = "ita";
}
//termina la trasmissione
Wire.endTransmission();
//richiede i dati allo slave
Wire.requestFrom(1, 3);
while(Wire.available()){
char rx = Wire.read();
Serial.print(rx);
}
Serial.println();
delay(1000);
}
e questo e il codice dello slave
//arduino nano I2C slave
#include "Wire.h" //libreria I2C
int LED = 13;
int roger = 0;
String rx;
void setup() {
Serial.begin(9600);
pinMode(LED,OUTPUT);
Wire.begin(1); //inizializzo il BUS e assegno indirizzo 1
Wire.onRequest(datiRichiesti); //imposto la funzione da eseguire su richiesta dati dal master
Wire.onReceive(datiRicevuti); //imposto la funzione da eseguire su invio dati dal master
}
void loop() {
delay(100);
}
void datiRicevuti(int howMany){
digitalWrite(LED, HIGH); //accendo led onboard per segnalare la ricezione della richiesta
//ricevo i dati e li inserisco in un array di caratteri
char rxbuff[3];
int i = 0;
while(Wire.available()){
rxbuff[i]=Wire.read();
i++;
}
//converto l'arrey di caratteri in una stringa
rx = String(rxbuff);
delay(500);
digitalWrite(LED, LOW); //spengo il led onboard
}
void datiRichiesti(){
if(rx == "ita"){
Wire.write("ITA");
} else {
Wire.write("ENG");
}
}
Anche in questo caso i commenti al codice sono abbastanza chiari ma vediamo lo scopo dell’esempio e il flusso delle informazioni.
Il master richiede allo slave il messaggio alternativamente in lingua italiana o ingelse. Per far cio il master invia allo slave il codice della lingua del messaggio tramite la la sequenza .beginTrasmission() -> .write() -> .endTrasmission() lo slave si accorge che il master gli ha inviato dei dati e quindi innesca la funzione specificata tramite .onReceive(), riceve i dati con .read() e li imagazzina in una variabile globale chiamata rx. A questo punto il master invia una richiesta di dati allo slave il quale prima di inviagliela verifica in che lingua deve rispondere.
Conclusioni
Il bus i2c e’ molto comodo per le comunicazioni tra microprocessori, sensori e altre periferiche che si trovano vicine, infatti il bus non può superare i 2mt altrimenti potrebbero esserci problemi di affidabilità, d’altronde e’ stato studiato per lo scambio di dati su dispositivi alloggiati sulla stessa scheda. Per comunicazioni ad alto raggio ci sono altri bus ( rs485, canbus etc etc)
Per poter programmare questi microcontrollori con l’ IDE di Arduino e’ necessario caricare tramite la gestione delle schede la libreria corretta. Aggiungiamo il percorso per caricare il modulo gestore .
File->impostazioni
aggiungiamo le seguenti rige nel campo “URL aggiuntive per il gestore schede”
http://arduino.esp8266.com/stable/package_esp8266com_index.json (per la esp12)
https:///dl.espressif.com/dl/package_esp32_index.json (per la esp32)
Se volessimo inserirle entrambi lo possiamo fare separando le due stringe con una virgola oppure cliccando sull’icona
e inserendo una sotto l’altra le stringhe
Clicchiamo su OK e riavviamo l’ide.
Troveremo un nuovo elenco di schede disponibili alla scelta sotto il menu Strumenti->Scheda.
Ora siamo pronti per programmarla tramite l’IDE di arduino.
Questo modulo fa parte della famiglia ESP e’ leggermente diverso dall’ESP8266. Sia come piedinatura che come caratteristiche tecniche leggermente superiori, ma per questo cercate in giro su internet i datasheet.
Se montato su una DEV-BOARD e’ programmabile con il tool di arduino tramite USB.
E’ un ottima alternativa all’ESP8266 anche a livello di costo sui siti cinesi si trvano dei moduli montati su develop board a prezzi stracciati. Unica accortezza bisogna collegare un condensatore elettrolitico da 10uF tra il piedino EN e massa altrimenti a ogni tentativo di programmazione il processore si riavvia.
piedinatura
Modelli di DEVELOP-BOARD
Equipaggiati con questo modulo possiamo trovare diverse Develop Board che si differiscono per piedinatura, io ho usato la DEVKITC 38 pins.
Si differenzia per il numero di pin disponibili all’esterno e la loro disposizione pertanto non possono essere pin-to-pin compatibili ma il modulo core rimane lo stesso. La DEVboard puo essere alimentata a 5 V sul pin Vin oppure da USB . ATTENZIONE i segnali in input non possono superare i 3,3 V causa arrostimento del chip.
Di seguito potete scaricare il data sheet completo
Non tutti i pin possono essere usati nello stesso modo, nella tabella sotto vediamo in che modo possono essere usati.
GPIO
INPUT
OUTPUT
NOTE
0
CON PULL-UP
SI
Emette segnale PWM al Boot
1
TX pin
SI
Uscita seriale debug al boot
2
SI
SI
legato al led on board
3
SI
RX pin
HIGH al boot
4
SI
SI
5
SI
SI
Emette segnale PWM al Boot
6
NO
NO
connesso alla flash SPI integrata(SCK/CLK)
7
NO
NO
connesso alla flash SPI integrata(SDO/SD0)
8
NO
NO
connesso alla flash SPI integrata(SDI/SD1)
9
NO
NO
connesso alla flash SPI integrata(SHD/SD2)
10
NO
NO
connesso alla flash SPI integrata(SWP/SD3)
11
NO
NO
connesso alla flash SPI integrata(CSC/CMD)
12
SI
SI
Se messo a 3,3V blocca il boot
13
SI
SI
14
SI
SI
15
SI
SI
16
SI
SI
17
SI
SI
18
SI
SI
19
SI
SI
20
SI
SI
21
SI
SI
22
SI
SI
23
SI
SI
24
SI
SI
25
SI
SI
26
SI
SI
27
SI
SI
28
SI
SI
29
SI
SI
30
SI
SI
31
SI
SI
32
SI
SI
33
SI
SI
34
SI
NO
Solo ingresso
35
SI
NO
Solo ingresso
36
SI
NO
Solo ingresso
37
SI
NO
Solo ingresso
38
SI
NO
Solo ingresso
39
SI
NO
Solo ingresso
tabella ingressi uscite
-Pin in solo ingresso
I GPIO dal34 al 36 sono utilizzabili solamente in ingresso, se vengono configurati come output non si riescono a pilotare. Non sono forniti di resistenze di pull interne quindi vanno usate quelle esterne.
-SPI flash interna
Sui GPIO 6 -11 e’ connessa la memoria FLASH interna e vengono messi a disposizione all’esterno tramite i pin relativi, e’ bene NON utilizzare questi pin lasciandoli liberi.
-Pin CAPACITIVI
i GPIO 0-2-4-12-13-14-15-27-32-33 sono dei pin utilizzabili sia in ingresso che in uscita, se usati in ingresso hanno la particolarita’ che possono gestire il TOUCH , cioe’ sono in grado di sentire il tocco del dito sostituendo cosi il pulsante meccanico.
-Convertitori Analogico/Digitale
Tutti i GPIO configurabili come ingressi, hanno la funzione di convertitori analogici digitali con risoluzione di 12bits. sono divisi in due gruppi, ADC1 e ADC2, gli ingressi sono divisi cosi:
ADC1 (GPIO 36,37,38,39,32,33,34,35)
ADC2 (GPIO 4,0,2,15,13,12,14,27,25,26) ADC non utilizzabili se si usa il WIFI.
I canali ADC hanno risoluzione 12 bits pertanto la scala di valori sara’ 0 – 4095, il range va da 0V a 3,3V. Questo significa che hanno una risoluzione di 0.8mV. I converitori pero’ non sono completamente lineari in tutta la loro escursione, in particolare nella zona bassa e quella alta, pertanto e’ consigliabile non usarlo con tensioni inferiori a 0.20V o superiori di 3.00V non essendo affidabili
-Convertitori Digitali/Analogici
E’ fornito di due convertitori D/A a 8 bit 0-254 converte il valore digitale in una tensione analogia con un range 0- 3,3 con risoluzione di circa 13mV
DAC1 GPIO 25
DAC2 GPIO 26
-Ingressi RTC WakeUp
Ci sono alcuni ingressi che possono essere usati per portare il processore dallo stato di SLEEP (funzione che abbatte il consumo energetico cofigurabile)al funzionamento normale. Questi sono i pin associabili alla funzione RTC wakeup:
RTC_GPIO0 (GPIO36)
RTC_GPIO3 (GPIO39)
RTC_GPIO4 (GPIO34)
RTC_GPIO5 (GPIO35)
RTC_GPIO6 (GPIO25)
RTC_GPIO7 (GPIO26)
RTC_GPIO8 (GPIO33)
RTC_GPIO9 (GPIO32)
RTC_GPIO10 (GPIO4)
RTC_GPIO11 (GPIO0)
RTC_GPIO12 (GPIO2)
RTC_GPIO13 (GPIO15)
RTC_GPIO14 (GPIO13)
RTC_GPIO15 (GPIO12)
RTC_GPIO16 (GPIO14)
RTC_GPIO17 (GPIO27)
RTC_GPIO0 (GPIO36)
RTC_GPIO3 (GPIO39)
RTC_GPIO4 (GPIO34)
RTC_GPIO5 (GPIO35)
RTC_GPIO6 (GPIO25)
RTC_GPIO7 (GPIO26)
RTC_GPIO8 (GPIO33)
RTC_GPIO9 (GPIO32)
RTC_GPIO10 (GPIO4)
RTC_GPIO11 (GPIO0)
RTC_GPIO12 (GPIO2)
RTC_GPIO13 (GPIO15)
RTC_GPIO14 (GPIO13)
RTC_GPIO15 (GPIO12)
RTC_GPIO16 (GPIO14)
RTC_GPIO17 (GPIO27)
-Uscite PWM
Si possono usare tutte le uscite GPIO (all’infuori dei GPIO 34 e 39) per generare segnali PWM diversi per ogni pin sia in frequenza che in dutycicle. per utilizzarli bisogna configurare, tramite il linguaggio scelto per la programmazione, i seguenti parametri per ogni GPIO :
Frequenza del segnale;
Duty cycle;
canale PWM ;
GPIO di uscita del segnale .
-I2C
L’ ESP32 puo gestire due canali I2C e possono essere usati tutti i pin GPIO come segnali SDA e SCL, Quando si usa l’ESP32 con l’IDE di Arduino i pin di default sono SDA GPIO21 – SCL GPIO22
Se si vuole utilizzare pin diversi usando la libreria wire.h dobbiamo utilizzare il comando seguente per assegnare i pin:
Wire.begin(pinSDA, pinSCL);
-SPI
La scheda ha due canali SPI chiamati V e H, non ci sono differenze tra i due canali escluso che sono disponibili su pin diversi. L’uso del bus SPI con ESP32 e’ impostato di default sui pin:
SPI
MOSI
MISO
CLK
CS
VSPI
GPIO23
GPIO19
GPIO18
GPIO5
HSPI
GPIO13
GPIO12
GPIO14
GPIO15
-INTERRUPTS
Tutti i pin GPIO in ingresso, possono essere configurati come ITERRUPT esterni
-STRAPPING PINS
Questi pin sono utilizzati per impostare l’ESP32 in modalita’ boot o flashing.
GPIO 0
GPIO 2
GPIO 4
GPIO 5 (deve essere HIGH durante boot)
GPIO 12 (deve essere LOW durante boot)
GPIO 15 (deve essere HIGH durante boot)
Se si usano le DEV BOARD con l’intrerfaccia USB integrata possiamo anche non preoccuparci dello stato di questi pin per la programmazione del BOOT o durante la fase di programmazione del firmware, in quanto l’ IDE di programmazione imposta in automatico questi pin in base al tipo di programmazione da effettuare (boot o flashing).
Se usiamo questi PIN collegandoli a dispositivi esterni, potremmo avere qualche difficolta’ di caricamento del firmware o del boot, in questo caso e’ necessario scollegare l’ESP32 dalla scheda programmarla e poi rimetterla al suo posto. Dopo il reset o il flashing questi pin lavorano normalmente.
-PIN allo stato alto al boot
Alcuni GPIO al momento dell’avvio o del reset si porteranno allo stato alto o genereranno un uscita PWM , se a questi gpio sono collegate apparecchiature esterne come ad esempio LED, RELE’ , sensori etc. etc. questi dispositivi potranno generare anomalie durante la fase di avvio o reset.
GPIO 1
GPIO 3
GPIO 5
GPIO 6 to GPIO 11 (connessi al ESP32 SPI della memoria flash integrata – si raccomanda di non usare questi pin).
GPIO 14
GPIO 15
-Enable (pin EN)
Questo pin abilita il regolatore 3,3V integrato, e’ mantenuto normalmente alto , se collegato a massa disabilita il regolatore 3,3V spegnendo la CPU, puo essere usato per riavviare la CPU con un pulsante , normalmente va collegato a GND con un condensatore di 10uF.
-GPIO dati tecnici
Gli ingressi/uscita hanno una tensione massima di 3,3V allo stato alto e possono fornire un massimo di 40mA.
riferimenti
Questo articolo e’ una traduzione parziale dell’ articolo seguente
Analizzando il codice, si nota che viene settato il GPIO 16 in modalita’ uscita “pinMode (16, OUTPUT);” poi si gestisce l’uscita con il comando digitalWrite come al solito .
Collegando un led con il positivo al piedino corrspondente D0 e tramite una resistenza a massa si otterrà il lampeggio del led stesso
Allo stesso modo di procede alla lettura degli ingressi e a tutte le normali funzioni dei piedini come fosse una arduino.
Misuriamo l’ingresso analogico
L’unico ingersso analogico che mette a disposizione questa scheda e’ marchato A0, la sua lettura è identica alla lettura di una arduino . Di seguito un breve codice di esempio.
