
L'ESP32 è il nuovo modulino prodotto da Espressif ed erede dell'ESP8266. Economico, studiato per l'IOT e dunque ricco di connettività (WiFi e BLE ), sta conquistando il mondo hobbistico e professionale. Purtroppo doversi studiare una nuova architettura non sempre è fattibile a causa di tempi ed effort. A tal proposito, Espressif viene incontro alle esigenze dei vari sviluppatori offrendo una soluzione "black box" già compilata.
Introduzione
La maggior parte degli articoli disponibili sul web propongono soluzioni in cui si utilizza direttamente la CPU dual core Xtensa disponibile a bordo dell'ESP32. Si tratta appunto di un uControllore dual core molto prestante, paragonabile indicativamente ad un ARM Cortex M7 come prestazioni. L’utilizzo diretto di una architettura così complessa richiede però tempo e dedizione: è necessario studiarsi le varie API disponibili nell’SDK Espressif, capire i limiti e le potenzialità offerte dall'ambiente preconfigurato e dall'RTOS ed infine individuare ed integrare eventuali moduli forniti dalla community.
Per risolvere questo possibile limite alla completa diffusione del modulo nel mercato, Espressif ha implementato una libreria che, mediante l’invio di comandi AT su UART (vedi Figura 1), consente il controllo esterno dell’ESP32 con un qualunque uControllore o uProcessore. Questa opzione amplia rapidamente la connettività su prodotti già esistenti e permette di sfruttare le proprie competenze su altri uController ed utilizzare dunque l'ESP32 come un modulo slave che invia informazioni tramite wifi o bluetooth. Un ulteriore vantaggio risiede nel fatto che il compilato coi comandi AT è mantenuto e corretto dalla stessa community di sviluppatori Espressif: ciò garantisce una affidabilità sicuramente superiore a quanto ottenibile da soli o con poche risorse a disposizione.

Figura 1: Esempio stilizzato di connessione UART tra uController ed ESP32
I comandi AT Hayes, dove AT è abbreviazione di ATTENTION, sono comandi nati nei modem fonici. Molti moduli radio, wireless e bluetooth, disponibili attualmente in commercio, possono venire pilotati esternamente in modalità "black box" da una sequenza di comandi AT compatibile. Integrare connettività, dunque, risulta estremamente semplice: è sufficiente inviare tramite UART un array di byte equivalente alla codifica ASCII del comando AT. Solitamente una breve sequenza di comandi consente di configurare e rendere funzionante il modulo. Al termine di questa configurazione, il modulo ESP32 diventa equivalente ad un gateway Wifi e/o Bluetooth e la seriale UART diventa il canale di invio e ricezione dei dati col mondo esterno.
Configurare l’ESP32 per i comandi AT
L’ESP32 non viene distribuita nativamente col codice per la gestione dei comandi AT a bordo. E’ necessario caricare in flash un apposito binario mantenuto direttamente da Espressif e facilmente scaricabile da Github. La gestione di tale binario da parte della ditta produttrice ne garantisce un certo livello in affidabilità e in robustezza del compilato a disposizione.
Di seguito vedremo come configurare rapidamente l’SDK su Windows e come caricare il binario in un modulino dotato di convertitore TTL-USB (un esempio di modulo plug&play è ESPertino).
- Cercate sul web: ESP-IDF Programming Guide
- Andate nella sezione: Setup Toolchain (Windows)
- De-zip l’archivio scaricato
- Avviate: mingw32.exe
- Nel tutorial standard non viene spiegata l’assenza di una libreria nell’SDK. La sua mancanza impedisce il corretto caricamente del binario. Digitate dunque il segue comando nel terminale: pip install pyyaml xlrd
- Digitate sul terminale: mkdir esp
- Digitate sul terminale: git clone --recursive https://github.com/espressif/esp32-at.git
- Aspettate che avvenga la copia del repository sul vostro pc
- Digitate: cd esp32-at
- Collegate il modulino ESP32 al PC
- Digitate sul terminale: make menuconfig
- Selezionate: serial flasher config
- Modificate "Default serial port" in base alla COM dedicata da Windows (vedi Figura 2)
- Salvate la configurazione ed uscite
- Digitate sul terminale: make flash
- Aspettate il termine della compilazione e del caricamento del binario nella memoria dell'ESP32

Figura 2: Esempio di porta COM su Windows 10
Il modulo ESP32 è pronto infine a ricevere comandi AT sulla UART1 (GPIO16 RXD, GPIO17 TXD, GPIO14 RTS, GPIO15 CTS). Ovviamente è possibile utilizzare in alternativa le altre due porte UART a disposizione (0 o 2) ma bisogna prestare attenzione alla seriale zero poiché viene utilizzata dall'SDK anche per log e debug e dunque è sfruttata da messaggi non inerenti ai soli comandi AT.
Conclusione e Spunti
Espressif ha redatto un Documento (.pdf) molto dettagliato dove vengono presentati tutti i comandi AT implementati. Allo stato attuale l'unico reale punto negativo riscontrato nella lista dei comandi è la mancanza del supporto al Bluetooth Classic (v2.1): sono previsti solamente comandi AT per la gestione del Wifi e del BLE. E' possibile comunque implementare ulteriori comandi, ma si perde la robustezza del codice fornito, testato e mantenuto dalla community.
Come nota finale è utile sottolineare l'interessante capitolo 9 del pdf precedentemente citato: "AT Commands Examples". In questa appendice della documentazione vengono utilizzati in cascata alcuni comandi per realizzare semplici progetti. Sono un ottimo punto di partenza poiché ricalcano alcune delle principali applicazioni realizzabili col modulo e possono comunque fungere da linea guida per stabilire quali comandi ed in che ordine inviarli per configurare correttamente il dispositivo.

Grazie per l’articolo.
Gli AT command sono davvero molto utili ma è davero un peccato non sfruttare a pieno il potenziale hardware di questo modulo.
Non ho mai avuto modo di usare le API fornite dall’sdk ma immagino che con RTOS si possano usare per applicazioni dove c’è bisogno di un’elevata velocità nell’esecuzione di alcune operazioni. Se posso azzardare un paragone, usare Arduino + esp32 è come avere un impianto HI-Fi da migliaglia d’euro completo di ampli e lettore multimediale ad alta definizione di suono ma usarlo sull’entrata aux con musica mp3. L’unica differenza è che nel nostro caso costa meno l’Esp32 che Arduino.
Dai anche un’occhiata agli articoli “ESPertino” 😉
Secondo voi è possibile usare questi comandi per realizzare un’applicazione che mi permetta utilizzare espertino come un access point? In particolare vorrei poter far passare lo stream o almeno delle foto fatte con una WiFi camera..
Si. Dai un’occhiata anche a questo https://it.emcelettronica.com/monitoraggio-della-temperatura-con-espertino-in-wifi-con-consultazione-su-internet
Nell’esempio suggerito mi pare di capire che Espertino sia il client, che misura la temperatura e la invia ad un access point.
Io vorrei usare espertino come access point a cui si collega la WiFi camera come client, o meglio la cam si dovrebbe collegare tramite WiFi e passare i dati su internet, ma non ho letto in dettaglio forse mi sbaglio..
E’ possibile usare i comandi AT con ESPertino ?
se si, dove posso trovare qualche esempio di utilizzo?
grazie
Ciao Piero, sul blog si trovano molti articoli pratici su ESPertino. Prova a dare un’occhiata a questo link: https://it.emcelettronica.com/page/2?s=espertino.
Grazie per la risposta, ho già visto parecchi articoli/progetti ma non ho trovato niente che faccia utilizzo dei comandi AT con ESPertino. Quello che vorrei fare è usare lo smartphone per mandare comandi ad espertino e ricevere dallo stesso una risposta usando wi.fi del router di casa.
Ho già fatta la app che mi consente di accendere/spegnere un led di espertino, dove c’è collegato un DHT22 che dovrebbe restituire i valori letti per essere visualizzati sempre nella stessa app.
Il sensore funziona correttamente a detta del monitor seriale dell’ide arduino, quello che mi manca è trasmettere i due valori alla app senza l’appoggio di pagine internet ma direttamente allo smartphone con l’uso dei comandi AT che ho visto utilizzare sul libro di Elektor : “Android app development” di Dogan Ibrahim che però usa Arduino con un ESP-01 connessi in seriale.
O forse c’è un altro metodo magari più semplice per trasmettere una stringa da espertino alla app.
Grazie ho risolto col protocollo UDP, ora espertino comunica con lo smartphone sia in ricezione che trasmissione
Ciao Piero, sarei interessato a vedere la parte del codice che descrive la connessione diretta tra Espertino e cellulare. Potresti postarla? Secondo te è fattibile anche da Iphone? Grazie
Penso sia fattibile anche per Iphone ma non mi chiedere di più perché sono alle prime armi con la realizzazione di app per smartphone, sicuramente sul blog di B4A trovi quanto necessario.
Posto integralmente il listato
/****************************************************************
* ESP32 REMOTE LED CONTROL
* ========================
*
* In this project an LED is connected to port pin GPIO23 of the
* ESP32 DevKitC development board. This LED is controlled by
* commands sendt from an Android mobile phone. Valid commands are
* ON and OFF to turn the LED ON and OFF respectively.
*
* File: ESP32LED
* Date: June, 2018
* Author: Dogan Ibrahim
*
* 30/09/2019
* 02/12/2019
* modificato per ESPertino
* 15/01/2020 aggiunto sensore DHT22
* /****************************************************************
* TEMPERATURE AND HUMIDITY
* ========================
* In this project a DHT11 type temperature and humidity sensor
* is connected to port pin 7 of the Arduino Uno. The program
* reads the ambient temperature and humidity and sends to the
* Android every second which is displayed on the Android. The
* data is sent over teh local Wi-Fi link using the UDP protocol
*
* File: DHT11
* Date: June, 2018
* Author: Dogan Ibrahim
***************************************************************/
// Example testing sketch for various DHT humidity/temperature sensors
// Written by ladyada, public domain
/***************************************************************/
#include “WiFi.h”
#include
#include “DHT.h”
#define DHTPIN 2 // what pin we’re connected to
//#define LED 23 // LED at port GPIO23
//#define RL2 12 // Rele at pin12
#define LED 13 // LED at pin13
#define DHTTYPE DHT22 // DHT 22 (AM2302)
// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
// Initialize DHT sensor for normal 16mhz Arduino
//DHT dht(DHTPIN, DHTTYPE);
// NOTE: For working with a faster chip, like an Arduino Due or Teensy, you
// might need to increase the threshold for cycle counts considered a 1 or 0.
// You can do this by passing a 3rd parameter for this threshold. It’s a bit
// of fiddling to find the right value, but in general the faster the CPU the
// higher the value. The default for a 16mhz AVR is a value of 6. For an
// Arduino Due that runs at 84mhz a value of 30 works.
// Example to initialize DHT sensor for Arduino Due:
DHT dht(DHTPIN, DHTTYPE, 30);
//———-Variabili——
// float volt,temperatura,media;
int ledPin = 5; // 6 per Arduino 5 per Espertino
WiFiUDP udp;
const int Port = 2000; // UDP port number
char Packet[80];
//
// Local Wi-Fi name and password
//
const char* ssid = “nome della linea”;
const char* password = “password del router”;
//char* host = “www.miosito.me”;
//
// This function connects the ESP32 to the local Wi-Fi router
//
void Connect_WiFi()
{
WiFi.begin(ssid, password);
Serial.print(“Wait for WiFi… “);
Serial.println();
while(WiFi.status() != WL_CONNECTED)
{
Serial.print(“.”);
delay(500);
}
Serial.print(“Wifi collegato, l’IP di ESPertino e’:”);
Serial.println(WiFi.localIP());
Serial.println();
Serial.print(“availableMemory : “);
Serial.println(availableMemory ());
Serial.println(“—————————“);
}
//——————————————————–
// Settaggio flag per stampa su seriale di dati per debug
//——————————————————–
boolean OnDebug = false;
//
// The Setup routine
//
void setup()
{
pinMode(LED, OUTPUT); // Configure as output
digitalWrite(LED, HIGH); // LED OFF at beginning
Serial.begin(9600);
Serial.println();
Serial.println(“DHTxx test!”);
Serial.println(“—————————“);
Connect_WiFi(); // Connect to Wi-Fi
udp.begin(Port);
dht.begin();
}
//
// Main program loop. Read the command from the received packet
// and then control the LED accordingly. Valid commands are ON
// and OFF
//
void loop()
{
int PacketSize = udp.parsePacket();
if(PacketSize)
{
udp.read(Packet, PacketSize);
if(Packet[0] == ‘O’ && Packet[1] == ‘N’)
digitalWrite(LED, LOW);
else if (Packet[0] == ‘O’ && Packet[1] == ‘F’ && Packet[2] == ‘F’)
digitalWrite(LED, HIGH);
}
// Wait a few seconds between measurements.
//delay(2000);
// Reading temperature or humidity takes about 250 milliseconds!
// Sensor readings may also be up to 2 seconds ‘old’ (its a very slow sensor)
float h = dht.readHumidity();
// Read temperature as Celsius
float t = dht.readTemperature();
// Read temperature as Fahrenheit
// float f = dht.readTemperature(true);
// Check if any reads failed and exit early (to try again).
if (isnan(h) || isnan(t)) {
Serial.println(“Failed to read from DHT sensor!”);
return;
}
Serial.print(“Humidity: “);
Serial.print(h);
Serial.print(” %\t”);
Serial.print(“Temperature: “);
Serial.print(t);
Serial.println(” *C “);
//————————————————————-
// Espertino trasmette i valori letti allo smartphone
//————————————————————-
String MyData = String(t,2) + ” C ,” + String(h,2) + ” %”;
udp.beginPacket(“192.168.1.6”, Port); //ip del mio smartphone
udp.print(MyData);
udp.endPacket();
delay(1000);
/***************************************************************/
// this function will return the number of bytes currently free in RAM
// written by David A. Mellis
// based on code by Rob Faludi http://www.faludi.com
int availableMemory() {
int size = 1024; // Use 2048 with ATmega328
byte *buf;
while ((buf = (byte *) malloc(–size)) == NULL);
free(buf);
return size;
Buon divertimento
La formattazione del testo lascia a desiderare, forse dovevo cambiare formato
Grazie Piero, proverò ad utilizzare parte del codice, la cosa che mi piace poco è che si utilizzi un IP statico per la connessione, più pratico, ma di certo meno sicuro. Spero di trovare le info che mi servono per l’app lato iphone.
Un’altra cosa che farò è eseguire meno letture del DHT perché ritengo che non servano, forse appesantiscono soltanto il funzionamento.
L’espertino l’hai alimentato da rete o con batteria? io volevo utilizzarlo per monitorare una serra senza dover per forza andarci tutti i giorni e quindi dimensionerei una batteria per il suo utilizzo. Hai mica fatto una misura di consumo del sistema scheda+sensori? Ancora grazie 😉
Al momento non ho ancora fatto misure di corrente anche perché ho intenzione di testare un BMP280 della Bosh e fare poi un confronto prestazioni/consumo. Ciao