Il Seeed Studio XIAO ESP32-S3 è una piccola scheda microcontrollore progettata per applicazioni embedded e IoT. Fa parte della serie XIAO, che si concentra su schede con fattore di forma molto ridotto ma con elevate capacità di elaborazione. La scheda misura solo circa 21 × 17,8 mm, rendendola adatta a progetti con spazio limitato.
Si basa sul chip ESP32-S3 con un processore dual-core Xtensa LX7 che può arrivare fino a 240 MHz. La scheda include Wi-Fi integrato e Bluetooth Low Energy, permettendo la comunicazione wireless senza hardware aggiuntivo. Offre inoltre memoria flash e PSRAM integrate, supportando applicazioni avanzate come AI edge e elaborazione dati.
La gestione dell’alimentazione è una caratteristica importante di questa scheda. Supporta la ricarica della batteria e offre modalità a basso consumo per progetti energeticamente efficienti. Questo la rende adatta a progetti portatili e alimentati a batteria.
In questo tutorial imparerai come programmare la XIAO ESP32-S3 usando l’Arduino IDE.
Dove Acquistare
Puoi acquistare la XIAO ESP32-S3 su Seeed Studio o Amazon. Ti servirà anche un cavo USB-C, se non ne possiedi già uno. Potrebbe essere necessario anche un piccolo dissipatore, nel caso tu esegua calcoli intensivi sulla scheda.
XIAO ESP32-S3
Cavo USB C
Piccolo dissipatore 9×9 mm
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Caratteristiche della scheda XIAO ESP32-S3
La XIAO ESP32-S3 è costruita attorno al sistema su chip ESP32-S3R8. Utilizza un processore dual-core Xtensa LX7 con architettura a 32 bit. La CPU può funzionare fino a 240 MHz. La foto qui sotto mostra il fronte e il retro della scheda:
Il chip offre 8 MB di memoria flash e 8 MB di PSRAM. Questa memoria estesa consente l’esecuzione di firmware più complessi e supporta il buffering per applicazioni ad alta intensità di dati come l’elaborazione audio o immagini.
L’ESP32-S3 include anche supporto hardware per istruzioni vettoriali. Questo migliora le prestazioni per l’elaborazione del segnale e l’inferenza di reti neurali.
Connettività Wireless
La scheda integra un completo sottosistema Wi-Fi a 2,4 GHz. Supporta gli standard IEEE 802.11 b/g/n per la comunicazione di rete. La radio Wi-Fi è integrata nel chip e non richiede componenti esterni, a parte un’antenna per una migliore ricezione. L’immagine sotto mostra la XIAO ESP32-S3 con l’antenna esterna collegata.
Supporta anche Bluetooth Low Energy 5.0. Questo permette comunicazioni a basso consumo con sensori, smartphone e altri dispositivi BLE. Il chip può operare anche in modalità Bluetooth Mesh per reti IoT distribuite.
GPIO e Interfacce Periferiche
La XIAO ESP32-S3 espone molteplici interfacce digitali e analogiche. Offre fino a 11 pin GPIO con capacità PWM. Include anche fino a 9 canali ADC per ingressi analogici. L’immagine seguente mostra il pinout della XIAO ESP32-S3:
La scheda supporta protocolli di comunicazione comuni come UART, I2C e SPI. L’ESP32-S3 utilizza una matrice GPIO flessibile che permette di mappare la maggior parte delle funzioni periferiche su pin differenti.
Sono disponibili pin dedicati per la comunicazione I2C con segnali SDA e SCL. I segnali SPI includono clock, MOSI e MISO. UART è disponibile per comunicazione seriale e debug.
Altre caratteristiche includono un LED utente e un LED di stato carica. Sono presenti anche pulsanti di reset e boot per il controllo del firmware e il flashing.
USB e Integrazione di Sistema
L’ESP32-S3 include supporto USB nativo. La scheda XIAO utilizza un connettore USB-C per alimentazione, programmazione e trasferimento dati. L’interfaccia USB è collegata direttamente al microcontrollore e non richiede un convertitore USB-seriale esterno.
Il chip supporta la funzionalità USB OTG, che gli permette di agire sia come dispositivo USB sia come host USB. Questa caratteristica abilita applicazioni come dispositivi USB HID o registrazione dati su memorie esterne.
Gestione dell’Alimentazione
La scheda supporta sia alimentazione USB sia a batteria. Un circuito di ricarica integrato permette di caricare una batteria al litio da 3,7 V. Questo consente il funzionamento autonomo senza hardware di gestione energetica esterno.
La tensione di funzionamento tipica è 3,3 V. Il regolatore onboard fornisce alimentazione stabile per il microcontrollore e le periferiche.
L’ESP32-S3 supporta diverse modalità di risparmio energetico, tra cui modem sleep, light sleep e deep sleep. La tabella seguente mostra il consumo di corrente dell’ESP32-S3 nelle varie modalità:
| Modalità | Corrente Tipica (Chip) | Unità | Descrizione |
|---|---|---|---|
| Modem Sleep | ~10.5 – 90 | mA | CPU attiva, Wi-Fi disabilitato |
| Light Sleep | ~240 – 750 | µA | CPU in pausa, memoria mantenuta |
| Deep Sleep | ~7 – 25 | µA | RTC attivo, gran parte del sistema spento |
Questi valori rappresentano il solo chip ESP32-S3. La scheda XIAO ESP32-S3 consumerà tipicamente un po’ più corrente a causa dell’hardware onboard.
Specifiche Tecniche
La tabella seguente riassume le caratteristiche tecniche della XIAO ESP32-S3:
| Parametro | Specifiche |
|---|---|
| Microcontrollore | ESP32-S3R8 (Xtensa LX7 dual-core) |
| Frequenza CPU | Fino a 240 MHz |
| Architettura | 32-bit |
| Memoria Flash | 8 MB |
| PSRAM | 8 MB |
| Wireless | Wi-Fi 802.11 b/g/n, Bluetooth LE 5.0 |
| USB | USB-C, USB OTG nativo |
| Pin GPIO | Fino a 11 |
| Canali ADC | Fino a 9 |
| Interfacce di Comunicazione | UART, I2C, SPI |
| Tensione di Funzionamento | 3.3 V |
| Alimentazione | USB-C o batteria LiPo 3.7 V |
| Caratteristiche di Alimentazione | Ricarica batteria, supporto deep sleep |
| Dimensioni | ~21 × 17.8 mm |
| Caratteristiche Aggiuntive | LED utente, LED carica, pulsanti reset e boot |
Confronto tra XIAO ESP32-S3 e altre schede ESP32 popolari
L’ecosistema ESP32 è cresciuto molto e scegliere la scheda giusta può essere complicato. La tabella seguente confronta le opzioni più popolari, inclusa la compatta serie XIAO e le classiche schede ESP32.
| Caratteristica | XIAO ESP32-S3 | XIAO ESP32-S3 Plus | XIAO ESP32-S3 Sense | ESP32-C5 | ESP32 DevKit | ESP32-CAM |
|---|---|---|---|---|---|---|
| MCU | ESP32-S3 | ESP32-S3 | ESP32-S3 | ESP32-C5 | ESP32 | ESP32 |
| CPU | Dual-core LX7 | Dual-core LX7 | Dual-core LX7 | RISC-V | Dual-core LX6 | Dual-core LX6 |
| Velocità di Clock | 240 MHz | 240 MHz | 240 MHz | 240 MHz | 240 MHz | 240 MHz |
| Accelerazione AI | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ |
| PSRAM | 8 MB | Fino a 8MB+ | 8 MB | ❌ | Opzionale | 4 MB |
| Flash | 8–16 MB | Fino a 16MB+ | 8–16 MB | Esterno | 4–16 MB | 4 MB |
| Wi-Fi | 2.4 GHz | 2.4 GHz | 2.4 GHz | Wi-Fi 6 (2.4 + 5 GHz) | 2.4 GHz | 2.4 GHz |
| Bluetooth | BLE 5 | BLE 5 | BLE 5 | BLE 5.3 | Classic + BLE | Classic + BLE |
| USB | USB nativo | USB nativo | USB nativo | Dipende dalla scheda | Chip UART | No |
| Fotocamera | ❌ | ❌ | ✅ | ❌ | ❌ | ✅ |
| Microfono | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
| Fattore di Forma | Ultra compatto | Compatto | Compatto + espansione | Variabile | Grande | Modulo |
| GPIO | Limitati | Moderati | Limitati | Moderati | Alti | Molto limitati |
| Caso d’Uso Migliore | IoT compatto | Progetti di espansione | AI / Visione | IoT Wi-Fi 6 | Prototipazione generale | Streaming con fotocamera |
Quale scheda scegliere?
- XIAO ESP32-S3: Miglior equilibrio tra dimensioni, prestazioni e funzionalità per la maggior parte dei progetti IoT.
- XIAO ESP32-S3 Plus: Buona scelta se servono più opzioni di espansione e flessibilità.
- XIAO ESP32-S3 Sense: Ideale per progetti AI, fotocamera e audio (riconoscimento facciale, rilevamento oggetti).
- ESP32-C5: Migliore per applicazioni wireless moderne con supporto Wi-Fi 6 e 5 GHz.
- ESP32 DevKit: Perfetto per principianti e prototipazione su breadboard con massimo accesso ai GPIO.
- ESP32-CAM: Opzione economica per semplici progetti di streaming con fotocamera, ma più limitata.
Uno dei vantaggi meno considerati dell’ESP32-S3 è la sua capacità USB nativa. A differenza delle classiche schede ESP32, che usano un chip UART esterno per la comunicazione, l’S3 può interfacciarsi direttamente via USB. Questo abilita funzionalità potenti come USB HID (per far agire la scheda come tastiera o mouse) e comunicazione seriale CDC nativa senza hardware aggiuntivo.
Nota anche l’importanza della PSRAM per applicazioni che gestiscono flussi di dati grandi o continui, come elaborazione audio, acquisizione video e carichi AI. Questi casi d’uso superano rapidamente la limitata SRAM interna dei microcontrollori tipici. In pratica, la PSRAM spesso fa la differenza tra un progetto che funziona a malapena e uno che gira affidabilmente.
Se inizi un nuovo progetto nel 2026, la famiglia ESP32-S3 è generalmente la scelta migliore grazie al supporto USB nativo e all’accelerazione AI. Le classiche schede ESP32 sono ancora utili, ma principalmente per progetti a basso costo o legacy che non richiedono le nuove funzionalità dell’ESP32-S3.
Installa ESP32 Core
Se vuoi usare l’Arduino IDE per programmare la scheda, devi prima installare l’ESP32 Core per abilitare il supporto alle schede ESP32 nell’IDE. Apri il Arduino IDE e segui i passaggi indicati di seguito. Se hai problemi, puoi trovare istruzioni più dettagliate nel nostro tutorial Install ESP32 core in Arduino IDE.
URL aggiuntivi per il Boards Manager
Apri prima la finestra Preferenze selezionando “Preferences…” dal menu “File”:
Si aprirà la finestra Preferenze mostrata sotto. Nella scheda Settings troverai una casella di testo in basso etichettata “Additional boards manager URLs”:
In questo campo incolla il seguente URL: “https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json“
Questo permetterà all’Arduino IDE di sapere dove trovare le librerie core ESP32. Ora installeremo effettivamente le librerie core ESP32 usando il Boards Manager.
Boards Manager
Apri il BOARDS MANAGER cliccando sull’icona della scheda nella barra laterale dell’Arduino IDE:
Vedrai apparire il BOARDS MANAGER a destra della barra laterale. Digita “ESP32” nel campo di ricerca in alto e dovresti vedere due tipi di schede ESP32; le “Arduino ESP32 Boards” e le schede “esp32 by Espressif”. Vogliamo le librerie esp32 di Espressif. Clicca su INSTALL e attendi il completamento del download e installazione.
Una volta installato, il tuo Boards Manager dovrebbe apparire così, anche se la versione effettiva (qui 3.3.7) potrebbe essere diversa.
Nel passo successivo ti mostro come selezionare la scheda ESP32 per la XIAO ESP32-S3.
Seleziona scheda XIAO_ESP32S3
Puoi selezionare una scheda dal menu a tendina sotto la barra dei menu: nell’esempio sotto è selezionata una Arduino Uno, per esempio:
Cliccando sul nome della scheda attualmente selezionata (Arduino Uno), si aprirà la finestra di selezione scheda. Nel campo di ricerca digita “xiao s3” e seleziona “XIAO_ESP32S3” come mostrato sotto:
Se la scheda è collegata al PC via USB, dovresti poter selezionare anche la porta COM. Nello screenshot sopra è COM13, ma nel tuo caso potrebbe essere un’altra porta COM.
Esempi di Codice
In questa sezione ti fornirò alcuni esempi di codice per provare le principali funzionalità della XIAO ESP32-S3.
Trova pin I2C e SPI
Il primo esempio stampa le interfacce I2C e SPI, necessarie per collegare molti sensori e display:
void print(const char* name, int pin) {
Serial.print(name);
Serial.println(pin);
}
void setup() {
Serial.begin(115200);
delay(2000);
print("LED: ", LED_BUILTIN);
print("SDA: ", SDA);
print("SCL: ", SCL);
print("SS: ", SS);
print("MOSI: ", MOSI);
print("MISO: ", MISO);
print("SCK: ", SCK);
}
void loop() { }
Puoi usare questo codice anche per altre schede supportate dall’Arduino IDE. Per maggiori informazioni vedi il Find I2C and SPI default pins tutorial. Per la XIAO ESP32-S3 questo codice stampa:
LED: 21 SDA: 5 SCL: 6 SS: 44 MOSI: 9 MISO: 8 SCK: 7
Lampeggia LED onboard
Questo è il comune esempio Blink. Accende e spegne il LED onboard per un secondo. Il LED onboard della XIAO ESP32-S3 è collegato a GPIO21 ma è invertito. LOW significa LED acceso, HIGH LED spento. Puoi vedere questo nell’esempio di codice sotto:
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
Serial.println("Off");
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
Serial.println("On");
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Lettura & Scrittura GPIO
Nei seguenti esempi molto brevi, leggiamo e scriviamo sui GPIO. Per specificare i pin nel codice puoi usare il numero GPIO x o il numero Dx. Per esempio, secondo il pinout, D3 o GPIO4 identificano lo stesso pin e nel codice puoi usare uno o l’altro. I due esempi di codice seguenti sono identici e impostano GPIO4 a HIGH:
digitalWrite(D3, HIGH); // D3 == GPIO4
digitalWrite(4, HIGH); // D3 == GPIO4
Se vuoi leggere segnali analogici puoi usare le costanti predefinite Ax. Per esempio, il codice seguente legge un ingresso analogico da A3, che è lo stesso pin GPIO4:
int val = analogRead(A3); // A3 == GPIO4
int val = analogRead(4); // A3 == GPIO4
I valori analogici variano da 0 a 4095, equivalenti a una tensione in ingresso tra 0 e 3.3V.
Ingresso Touch
Questo esempio mostra come usare i pin touch capacitivi della XIAO ESP32-S3 per rilevare tocchi. Se tocchi il primo pin (D0) della scheda, il LED integrato si accende. Potrebbe essere necessario regolare la soglia di rilevamento.
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
int value = touchRead(T1);
Serial.println(value);
if (value > 30000) {
digitalWrite(LED_BUILTIN, LOW);
} else {
digitalWrite(LED_BUILTIN, HIGH);
}
delay(200);
}
HID per Controllo Volume
L’ESP32-S3 supporta USB HID (Human Interface Device), quindi puoi controllare dispositivi del computer come tastiera o volume con l’ESP32 collegato. Negli esempi seguenti usiamo gli ingressi touch T1 e T2 per aumentare o diminuire il volume del computer:
#include "USB.h"
#include "USBHIDConsumerControl.h"
USBHIDConsumerControl UCC;
#define TOUCH_THRESHOLD 30000
bool upPressed() {
return touchRead(T1) > TOUCH_THRESHOLD;
}
bool downPressed() {
return touchRead(T2) > TOUCH_THRESHOLD;
}
void setup() {
USB.begin();
UCC.begin();
}
void loop() {
if (upPressed()) {
UCC.press(CONSUMER_CONTROL_VOLUME_INCREMENT);
UCC.release();
}
if (downPressed()) {
UCC.press(CONSUMER_CONTROL_VOLUME_DECREMENT);
UCC.release();
}
delay(100);
}
Invece degli ingressi touch, ovviamente potresti collegare anche pulsanti. Ma con gli ingressi touch basta inserire i cavi nel primo (D0) e secondo (D1) pin per provare il codice del controllo volume.
Vedi la arduino-esp32 libreria per altri esempi HID. Fai attenzione usando l’ESP32 come HID, perché puoi facilmente disabilitare il mouse o inondare il computer di tasti, rendendolo inutilizzabile mentre l’ESP32 è collegato.
Nota anche che la scheda non può essere flashata mentre HID è attivo. Scomparirà come dispositivo USB nell’Arduino IDE. Per riportare la scheda in modalità flash devi:
- Premere e tenere premuto il pulsante BOOT (B)
- Tenendo premuto BOOT (B), premere e rilasciare RESET (R)
- Rilasciare il pulsante BOOT (B)
Poiché i pulsanti BOOT (B) e RESET (R) sull’ESP32-S3 sono piccoli, questa operazione può essere piuttosto difficile.
Wi-Fi
L’esempio seguente mostra come connettere la XIAO ESP32 a una rete Wi-Fi. Funzionerà anche senza antenna esterna se sei vicino al router Wi-Fi, ma per una migliore portata è consigliato installare l’antenna.
#include <WiFi.h>
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
Serial.print("Connecting");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nConnected");
Serial.println(WiFi.localIP());
}
void loop() {
}
Webserver
Puoi estendere l’esempio Wi-Fi precedente e costruire facilmente un semplice Webserver. Il codice seguente crea un webserver, stampa l’indirizzo IP a cui serve e mostra il testo “Hello from XIAO ESP32-S3!” nella pagina root:
#include <WiFi.h>
#include <WebServer.h>
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";
WebServer server(80);
void handleRoot() {
server.send(200, "text/plain", "Hello from XIAO ESP32-S3!");
}
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println(WiFi.localIP());
server.on("/", handleRoot);
server.begin();
}
void loop() {
server.handleClient();
}
Carica il codice sul tuo ESP32-S3, apri il Monitor Seriale e copia l’indirizzo IP stampato (es. “192.168.1.160”) nella barra degli indirizzi del browser. Dovresti vedere apparire il messaggio:
Scanner Wi-Fi
Se vuoi scansionare la tua rete Wi-Fi locale per rilevare le reti disponibili, ecco un esempio di codice:
#include "WiFi.h"
void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
WiFi.disconnect();
delay(100);
}
void loop() {
Serial.println("scan start");
int n = WiFi.scanNetworks();
Serial.println("scan done");
if (n == 0) {
Serial.println("no networks found");
} else {
Serial.print(n);
Serial.println(" networks found");
for (int i = 0; i < n; ++i) {
Serial.print(i + 1);
Serial.print(": ");
Serial.print(WiFi.SSID(i));
Serial.print(" (");
Serial.print(WiFi.RSSI(i));
Serial.print(")");
Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN) ? " " : "*");
}
delay(10);
}
Serial.println("");
delay(5000);
}
Puoi iniziare senza antenna Wi-Fi collegata e troverai solo le reti più forti. Se colleghi l’antenna probabilmente scoprirai più reti. Per esempio, senza antenna ricevo un segnale debole (-77 dB) e solo una rete:
scan start scan done 1 networks found 1: maetasus (-77)*
Appena collego l’antenna, vengono rilevate più reti e la potenza del segnale della mia rete locale (maetasus) passa da -77 dB a -35 dB:
scan start scan done 5 networks found 1: maetasus (-35)* 2: FRITZ!Box 5590 DQ (-75)* 3: WLAN-762918 (-81)* 4: portthru (-83) 5: WLAN-579476 (-91)*
Bluetooth
Questo esempio mostra come creare un semplice server Bluetooth Low Energy (BLE).
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
void setup() {
Serial.begin(115200);
BLEDevice::init("XIAO-ESP32-S3");
BLEServer *pServer = BLEDevice::createServer();
BLEDevice::getAdvertising()->start();
Serial.println("BLE server started");
}
void loop() {
}
Puoi verificare se il server è attivo usando uno scanner BLE sul tuo telefono. Opzioni comuni sono nRF Connect o LightBlue. Se avvii una scansione, vedrai apparire “XIAO-ESP32-S3”.
Sensore di Pressione e Temperatura (BME280) via I2C
Questo esempio mostra come collegare un sensore via I2C alla XIAO ESP32-S3. Useremo il BME280 in questo esempio. Per maggiori informazioni su questo sensore vedi i tutorial How To Use BME280 Pressure Sensor With Arduino e Weather Station on e-Paper Display.
L’interfaccia I2C della XIAO ESP32-S3 è sui pin 5 (SDA) e 6 (SCL). Lo schema di collegamento sotto mostra come connettere il BME280 alla XIAO ESP32-S3.
Il codice seguente mostra come leggere pressione, temperatura, umidità e altitudine dal sensore BME280 e stampare le misure sul Monitor Seriale:
#include "Adafruit_BME280.h"
#define SEALEVELPRESSURE_HPA 1013.25
#define BME280_ADDRESS 0x76
Adafruit_BME280 bme;
void setup() {
Serial.begin(11520);
while(!Serial);
if (!bme.begin(BME280_ADDRESS)) {
Serial.println("Can't find BME280!");
while(1) delay(10);
}
}
void loop() {
Serial.print("Temperature in degC = ");
Serial.println(bme.readTemperature());
Serial.print("Pressure in hPa = ");
Serial.println(bme.readPressure() / 100.0F);
Serial.print("Altitude in m = ");
Serial.println(bme.readAltitude(SEALEVELPRESSURE_HPA));
Serial.print("Humidity in %RH = ");
Serial.println(bme.readHumidity());
Serial.println();
delay(5000);
}
Se tutto è cablato correttamente, dovresti vedere dati simili all’output sotto:
Temperature in degC = 22.93 Pressure in hPa = 1000.40 Altitude in m = 107.53 Humidity in %RH = 34.61
OLED via I2C
Nel codice esempio usiamo ancora l’interfaccia I2C ma colleghiamo un display OLED alla XIAO ESP32-S3. Come prima usiamo i pin 5 (SDA) e 6 (SCL) per I2C. L’immagine sotto mostra il collegamento necessario con l’OLED:
Ecco il codice. Scrive semplicemente il testo “make” sul display. Nota che dovrai prima installare la Adafruit_SSD1306 library.
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
void setup() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(4);
oled.setTextColor(WHITE);
}
void loop() {
oled.clearDisplay();
oled.setCursor(20, 16);
oled.print("make");
oled.display();
delay(1000);
}
Display E-Paper su SPI
Nel prossimo esempio controlleremo un display E-Paper tramite l’interfaccia SPI della XIAO ESP32-S3. I pin hardware SPI per la XIAO ESP32-S3 sono 8 (MISO), 9 (MOSI), 44 (CS/SS) e 7 (SCK). Gli altri pin sono liberi di scelta.
Lo schema di collegamento sotto mostra come connettere un 4.2″ e-Paper Display ai pin SPI:
Di seguito una tabella con tutti i collegamenti per comodità. Nota che puoi alimentare il display con 3.3V o 5V ma le linee dati SPI devono essere a 3.3V! Per sicurezza usa 3.3V per l’alimentazione.
| Display e-Paper | XIAO ESP32-S3 |
|---|---|
| CS/SS | GPIO44 |
| CLK/SCL/SCK | GPIO7 |
| SDA/DIN/MOSI | GPIO9 |
| BUSY | GPIO1 |
| RES/RST | GPIO2 |
| DC | GPIO3 |
| VCC | 3.3V |
| GND | G |
Prima di poter disegnare sul display e-Paper dovrai installare la GxEPD2 libreria, che fornisce il driver grafico per il display E-Paper. Il codice esempio sotto usa la libreria per stampare il testo “Makerguides” sul display:
#include "GxEPD2_BW.h"
// hardware SPI
// #define MISO 8
// #define MOSI 9
// #define SCK 7
#define CS 44
#define DC 3
#define RST 2
#define BUSY 1
GxEPD2_BW<GxEPD2_420_GDEY042T81, GxEPD2_420_GDEY042T81::HEIGHT>
epd(GxEPD2_420_GDEY042T81(CS, DC, RST, BUSY));
void setup() {
epd.init(115200, true, 50, false);
epd.setRotation(1);
epd.setTextColor(GxEPD_BLACK);
epd.setTextSize(2);
epd.setFullWindow();
epd.fillScreen(GxEPD_WHITE);
epd.setCursor(90, 190);
epd.print("Makerguides");
epd.display();
epd.hibernate();
}
void loop() {}
Se vuoi realizzare qualcosa di più interessante dai un’occhiata ai tutorial Monthly Calendar on E-Paper Display o Analog Clock on e-Paper Display.
Deep Sleep
Il codice seguente dimostra come usare la modalità deep-sleep con l’ESP32-S3. Ogni 10 secondi mette l’ESP32-S3 in deep-sleep per 5 secondi e poi lo riattiva:
#define uS_TO_S_FACTOR 1000000ULL
#define TIME_TO_SLEEP 5
void setup() {
Serial.begin(115200);
Serial.println("Awake...");
delay(10000);
Serial.println("Going to sleep...");
esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
esp_deep_sleep_start();
}
void loop() {}
Fai attenzione se aumenti il periodo di deep-sleep. Durante il deep-sleep la scheda si disconnette dall’USB e non puoi flashare nuovo software. Per riportare la scheda in modalità flash devi:
- Premere e tenere premuto il pulsante BOOT (B)
- Tenendo premuto BOOT, premere e rilasciare RESET (R)
- Rilasciare il pulsante BOOT
Aggiornamento OTA (Over The Air)
In questo ultimo esempio ti mostro come eseguire un aggiornamento Over The Air (OTA) del codice sulla XIAO ESP32-S3. Questo ha il vantaggio di non dover collegare l’ESP32 per flashare nuovo codice.
#include <WiFi.h>
#include <ArduinoOTA.h>
const char* wifi_ssid = "YOUR_SSID";
const char* wifi_pwd = "YOUR_PASSWORD";
const char* ota_pwd = "1234";
const char* ota_name = "my-xiao-esp32-s3";
void setup() {
WiFi.begin(wifi_ssid, wifi_pwd);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}
ArduinoOTA.setHostname(ota_name);
ArduinoOTA.setPassword(ota_pwd);
ArduinoOTA.begin();
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
ArduinoOTA.handle();
// Main code
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
L’ESP32 apparirà sotto Tools -> Ports -> Network Ports con il nome host “my-xiao-esp32-s3”. Se flashi su quell’host, l’Arduino IDE chiederà una password (“1234”) e poi caricherà il nuovo codice via Wi-Fi. Ovviamente dovresti scegliere una password migliore di “1234” ; )
Nel codice esempio il programma principale è il semplice Blink. Cambia il delay, flasha il nuovo codice e verifica se la frequenza di lampeggio è cambiata per testare l’aggiornamento OTA.
Conclusioni
Questo post ti ha mostrato come iniziare con il Seeed Studio XIAO ESP32-S3. Seeed Studio fornisce ulteriori informazioni nel suo Wiki.
Nota che esiste una versione XIAO ESP32-S3-Plus con più Flash (16MB) e pin GPIO. C’è anche la XIAO-ESP32-S3-Sense, che include fotocamera e microfono. Se vuoi registrare audio o trasmettere video scegli la XIAO-ESP32-S3-Sense. Se ti serve più memoria o IO, opta per la XIAO ESP32-S3-Plus.
Se hai domande sentiti libero di lasciarle nella sezione commenti.
Buon divertimento con il tinkering 😉
