Componenti · 9 min di lettura

Wemos D1 mini pinout: D0–D8 e GPIO, pin A0, shield e deep sleep

Pinout del Wemos D1 mini (ESP8266): corrispondenza D0–D8 e GPIO, pin critici all'avvio, limite di 3,2 V su A0, shield relè, DHT e OLED e deep sleep con D0–RST.

Il Wemos D1 mini porta il chip Wi-Fi ESP8266 su una schedina di 34 × 26 mm che si programma direttamente via USB e si espande con shield impilabili: per questo è una delle mini schede di sviluppo più diffuse in assoluto. È piccolo, economico e compatibile con l'Arduino IDE, quindi è la prima scelta per sensori Wi-Fi, prese smart e controller per strisce LED. Il problema è che le sigle D0–D8 stampate sulla scheda non sono i numeri GPIO, e alcuni pin, se usati male, impediscono alla scheda perfino di avviarsi: per questo la prima cosa da avere sotto mano è il pinout del Wemos D1 mini.

In questa guida trovi tutto il pinout del Wemos D1 mini in un'unica tabella, con il GPIO di ogni pin. Con codice di esempio vediamo quali pin sono critici all'avvio (boot), perché l'ingresso analogico A0 si ferma a 3,2 V, quali pin usano gli shield relè, DHT e OLED e perché per il deep sleep bisogna collegare D0 a RST. Alla fine diamo un'occhiata veloce ai fratelli con ESP32.

Scheda di sviluppo Wemos D1 mini ESP8266
Wemos D1 mini: modulo ESP-12 (ESP8266, 4 MB di flash), convertitore USB-seriale CH340, pulsante RESET e due file da 8 pin.

Cos'è il Wemos D1 mini? Caratteristiche tecniche

Il D1 mini è stato progettato da Wemos (oggi LOLIN) e, visto che lo schema è aperto, è stato clonato da moltissimi produttori. Nel modulo ESP-12 con schermatura metallica ci sono il processore ESP8266EX e 4 MB di flash; sulla scheda trovi in più un convertitore USB-seriale, un regolatore che porta i 5 V a 3,3 V e il pulsante RESET. Le versioni più diffuse sono la v3 con micro-USB e la v4 con USB-C; la disposizione dei pin è la stessa su tutte.

CaratteristicaValore
ChipESP8266EX, 32 bit, 80/160 MHz
Flash4 MB (D1 mini Pro: 16 MB)
RAM80 KB di memoria dati (circa 40–50 KB liberi con il Wi-Fi attivo)
Wi-Fi802.11 b/g/n, solo 2,4 GHz
Pin digitali11 (D0–D8, TX, RX)
Ingresso analogico1 (A0, 0–3,2 V, 10 bit)
Livello logico3,3 V (alimentazione da USB o dal pin 5V)
Chip USB-serialeQuasi sempre CH340
Dimensioni34,2 × 25,6 mm

Pinout del Wemos D1 mini: D0–D8 e i GPIO corrispondenti

L'errore più comune è scrivere nel codice la sigla della scheda come se fosse un numero. Se nell'Arduino IDE scrivi pinMode(4, OUTPUT), la scheda non usa D4 ma il GPIO 4, cioè D2. Nel codice usa le costanti come D4 (sono definite se hai selezionato la scheda D1 mini) oppure il numero GPIO della tabella. Puoi vedere la mappa della tua scheda anche con lo strumento Pinout.

SiglaGPIOFunzione specialeNote d'uso
TXGPIO 1UART TX (Monitor seriale)All'avvio invia dati; lascialo libero se usi Serial
RXGPIO 3UART RXHIGH all'avvio; lascialo libero se usi Serial
D0GPIO 16Risveglio dal deep sleep (collegato a RST)Niente PWM, interrupt né I2C; HIGH all'avvio
D1GPIO 5I2C SCLSicuro; pin predefinito dello shield relè
D2GPIO 4I2C SDASicuro
D3GPIO 0FLASH, pull-up da 10 kΩSe è LOW all'avvio, la scheda entra in modalità programmazione
D4GPIO 2LED integrato (logica invertita), pull-up da 10 kΩSe è LOW all'avvio, la scheda non parte; pin dello shield DHT
D5GPIO 14SPI SCKSicuro
D6GPIO 12SPI MISOSicuro
D7GPIO 13SPI MOSISicuro
D8GPIO 15SPI CS, pull-down da 10 kΩSe è HIGH all'avvio, la scheda non parte; CS dello shield SD
A0ADC0Ingresso analogico0–3,2 V; partitore 220 kΩ / 100 kΩ sulla scheda
RST-Reset (attivo LOW)Si collega a D0 per il deep sleep
3V3-Uscita 3,3 VAlimenta da qui i sensori
5V-5 V dell'USB / ingresso 5 V esternoCon l'USB collegato è un'uscita, altrimenti un ingresso di alimentazione
G-GNDMassa comune
All'accensione D3 (GPIO 0) e D4 (GPIO 2) devono essere HIGH e D8 (GPIO 15) LOW. Un pulsante su D3 premuto all'accensione, un modulo che porta D4 a LOW o un sensore che mette D8 a HIGH bloccano l'avvio: il LED blu resta spento, il Monitor seriale mostra caratteri senza senso e il tuo codice non parte mai. Usa questi tre pin solo con circuiti che non alterano il loro livello di avvio.

In breve, i pin che puoi usare tranquillamente per qualsiasi cosa sono D1, D2, D5, D6 e D7. D0 va bene per uscite semplici e per il risveglio dal deep sleep, ma non ha PWM né interrupt. D3 e D4 vanno bene per pulsanti (purché non siano premuti all'avvio) e LED. Tutti i pin tranne D0 hanno una resistenza di pull-up interna (INPUT_PULLUP); D0 ha solo un pull-down interno. Con la versione 3.x del core ESP8266, analogWrite() lavora di default su 0–255 a 1 kHz. Ogni pin eroga al massimo circa 12 mA, quindi per relè, motori o strisce LED lunghe usa un transistor o un driver.

Installare il Wemos D1 mini nell'Arduino IDE

  1. In File > Impostazioni aggiungi http://arduino.esp8266.com/stable/package_esp8266com_index.json nel campo "URL aggiuntive per il Gestore schede"; se ci sono altri indirizzi, separali con una virgola.
  2. Cerca esp8266 nel Gestore schede e installa il pacchetto di ESP8266 Community.
  3. Scegli LOLIN(WEMOS) D1 R2 & mini in Strumenti > Scheda > ESP8266 Boards.
  4. Se la porta non compare, installa il driver CH340 e usa un cavo USB dati, non uno solo di ricarica.
  5. Se il caricamento a 921600 fallisce, abbassa Upload Speed a 115200.

Primo sketch: far lampeggiare il LED integrato

Il piccolo LED blu sul modulo ESP-12 è collegato al GPIO 2 (D4) e funziona a logica invertita: si accende quando il pin è LOW e si spegne quando è HIGH. LED_BUILTIN per il D1 mini vale 2, quindi il codice qui sotto funziona senza modifiche:

C++ (Arduino IDE)
1// D1 mini dahili LED: D4 = GPIO 2, LOW'da yanar / onboard LED: D4 = GPIO 2, lights on LOW
2void setup() {
3  pinMode(LED_BUILTIN, OUTPUT);     // LED_BUILTIN = 2 (D4)
4}
5
6void loop() {
7  digitalWrite(LED_BUILTIN, LOW);   // LED yanar (ters mantık) / LED on (inverted logic)
8  delay(500);
9  digitalWrite(LED_BUILTIN, HIGH);  // LED söner / LED off
10  delay(500);
11}
Nel codice digitalWrite(D4, LOW) e digitalWrite(2, LOW) fanno la stessa cosa, mentre digitalWrite(4, LOW) pilota D2. Le costanti D esistono solo se in Strumenti > Scheda hai selezionato il D1 mini. Il NodeMCU usa la stessa corrispondenza tra sigle e GPIO del D1 mini, perciò gli sketch passano da una scheda all'altra senza cambiare nulla.

L'ingresso analogico A0: il limite di 3,2 V e la misura di tensione

L'unico convertitore analogico-digitale (ADC) dell'ESP8266 in realtà misura solo 0–1,0 V con 10 bit (0–1023). Il D1 mini mette dietro il pin A0 un partitore di tensione da 220 kΩ e 100 kΩ: all'ADC arriva Vin × 100 / (220 + 100), quindi 3,2 V su A0 arrivano al chip come 1,0 V. Per questo la formula per convertire il valore grezzo in volt è V = grezzo × 3,2 / 1023. Per misurare tensioni più alte aggiungi una resistenza in serie prima di A0: con altri 100 kΩ il ramo superiore del partitore diventa 320 kΩ e il fondo scala sale a 1,0 × (320 + 100) / 100 = 4,2 V, proprio la tensione di una cella agli ioni di litio carica. Puoi calcolare altri rapporti con lo strumento Partitore di tensione.

Tensione su A0Arriva al chipanalogRead() (circa)
0 V0 V0
1,0 V0,31 V320
1,65 V0,52 V527
3,2 V1,0 V1023
3,3 V1,03 V1023 (saturo)
C++ (Arduino IDE)
1// A0: kartta 220k/100k bölücü, 0–3,2 V → 0–1023 / on-board 220k/100k divider, 0–3.2 V → 0–1023
2const float FULL_SCALE = 3.2;      // ek 100 kΩ seri dirençle 4.2 olur / 4.2 with an extra 100 kΩ in series
3
4void setup() {
5  Serial.begin(115200);
6}
7
8void loop() {
9  long sum = 0;
10  for (int i = 0; i < 16; i++) {   // 16 ölçümün ortalaması / average of 16 readings
11    sum += analogRead(A0);
12    delay(10);                     // Wi-Fi'ye zaman bırak / leave time for Wi-Fi
13  }
14  float raw = sum / 16.0;
15  float volts = raw * FULL_SCALE / 1023.0;
16  Serial.print("A0 ham / raw: ");
17  Serial.print(raw, 0);
18  Serial.print("  gerilim / voltage: ");
19  Serial.print(volts, 2);
20  Serial.println(" V");
21  delay(1000);
22}
Non dare ad A0 più di 3,3 V; collegare direttamente l'uscita di un sensore a 5 V falsa la misura e alla lunga può danneggiare il chip. Chiamare analogRead() in un ciclo senza pause con il Wi-Fi attivo può far cadere la connessione, quindi aspetta almeno qualche millisecondo tra una lettura e l'altra. Inoltre, se nel codice c'è ADC_MODE(ADC_VCC), A0 viene disattivato e l'ADC legge la tensione di alimentazione della scheda.

Gli shield del Wemos D1 mini: relè, DHT, OLED e altri

Il punto forte del D1 mini sono gli shield dello stesso formato, che grazie ai connettori femmina si innestano direttamente sopra o sotto la scheda. Niente saldature né cavetti; però, visto che ogni shield usa un pin fisso, devi controllare che gli shield impilati non condividano pin. Ecco i più comuni e i pin che usano:

ShieldPin usatoNota
Shield relèD1 (GPIO 5)Contatti di solito da 10 A / 250 V AC; va in conflitto con l'SCL dell'I2C
Shield DHT (DHT11 o DHT22 Pro)D4 (GPIO 2)Stesso pin del LED integrato; il sensore risente del calore della scheda
Shield SHT30D1, D2 (I2C)Più preciso di un DHT; indirizzo I2C 0x45
Shield OLED 0,66"D1 (SCL), D2 (SDA)64×48 pixel, driver SSD1306, indirizzo 0x3C
Shield Micro SDD5, D6, D7, D8 (CS)SPI; D8 deve restare LOW all'avvio
Shield batteriaNessun pinRicarica una LiPo e alimenta la scheda dal pin 5V

La tabella mostra la trappola principale: lo shield relè usa di default D1, che è anche la linea di clock dell'I2C. Se impili il relè con lo shield OLED o SHT30, nessuno dei due funziona bene. Alcune versioni dello shield relè permettono di cambiare pin con un ponticello a saldare sul retro; se la tua no, collega il relè con un cavetto a uno dei pin D5–D7. Se innesti lo shield DHT direttamente sulla scheda, il calore dell'ESP8266 gli fa segnare 1–3 °C in più; allontana il sensore con una base doppia (dual base) o un cavo corto. Il codice seguente usa insieme lo shield DHT e lo shield relè come semplice termostato per una ventola:

C++ (Arduino IDE)
1#include <DHT.h>
2
3const uint8_t DHT_PIN = 2;       // D4 = GPIO 2 (DHT shield)
4const uint8_t RELAY_PIN = 5;     // D1 = GPIO 5 (röle shield / relay shield)
5const float ON_ABOVE = 28.0;     // bunun üstünde fan açılır / fan on above this
6const float OFF_BELOW = 26.5;    // bunun altında kapanır (histerezis) / off below this (hysteresis)
7
8DHT dht(DHT_PIN, DHT11);         // DHT Pro shield için DHT22 / DHT22 for the DHT Pro shield
9bool fanOn = false;
10
11void setup() {
12  Serial.begin(115200);
13  pinMode(RELAY_PIN, OUTPUT);
14  digitalWrite(RELAY_PIN, LOW);  // röle kapalı başlasın / start with the relay off
15  dht.begin();
16}
17
18void loop() {
19  float t = dht.readTemperature();
20  if (!isnan(t)) {                                // hatalı ölçümü atla / skip failed readings
21    if (!fanOn && t > ON_ABOVE) fanOn = true;
22    if (fanOn && t < OFF_BELOW) fanOn = false;
23    digitalWrite(RELAY_PIN, fanOn ? HIGH : LOW);  // HIGH = röle çeker / HIGH = relay on
24    Serial.print(t, 1);
25    Serial.println(fanOn ? " C  fan ON" : " C  fan OFF");
26  }
27  delay(2000);
28}

Le due soglie nel codice (accensione a 28 °C, spegnimento a 26,5 °C) creano un'isteresi: con una sola soglia il relè scatterebbe ogni secondo mentre la temperatura oscilla tra 28,0 e 28,1, consumando relè e ventola. Per collegare un relè in sicurezza leggi Cos'è un modulo relè?. Lo shield OLED è un minuscolo display SSD1306 da 64×48 pixel; la libreria standard Adafruit SSD1306 non supporta questa dimensione, quindi la strada più semplice è la libreria U8g2. L'esempio mostra la tensione su A0 come numero e come barra:

C++ (Arduino IDE)
1#include <Wire.h>
2#include <U8g2lib.h>
3
4// 0,66" OLED shield: 64×48, I2C D1 (SCL) / D2 (SDA) / 0.66" OLED shield: 64×48, I2C on D1/D2
5U8G2_SSD1306_64X48_ER_F_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
6
7void setup() {
8  oled.begin();
9}
10
11void loop() {
12  float volts = analogRead(A0) * 3.2 / 1023.0;      // A0 → volt
13  oled.clearBuffer();
14  oled.setFont(u8g2_font_6x10_tf);
15  oled.drawStr(0, 10, "D1 mini");
16  oled.setCursor(0, 28);
17  oled.print(volts, 2);
18  oled.print(" V");
19  oled.drawFrame(0, 36, 64, 10);                    // çubuk çerçevesi / bar frame
20  oled.drawBox(2, 38, (int)(volts / 3.2 * 60), 6);  // gerilim çubuğu / voltage bar
21  oled.sendBuffer();
22  delay(500);
23}

Deep sleep: il ponticello D0–RST e il funzionamento a batteria

In deep sleep l'ESP8266 spegne completamente processore e Wi-Fi; resta acceso solo il suo timer RTC interno. Allo scadere del tempo, l'RTC porta per un attimo il GPIO 16 (D0) a LOW. Se D0 è collegato al pin RST, questo impulso resetta il chip e il codice riparte da setup(). Senza il ponticello la scheda non si risveglia mai. Visto che il risveglio è un riavvio, le variabili normali si perdono; i dati piccoli, come un contatore di letture, puoi salvarli nei 512 byte di memoria utente dell'RTC. Un singolo sonno dura al massimo circa 3,5 ore; per pause più lunghe rimetti a dormire la scheda più volte di seguito.

StatoAssorbimento indicativo
Invio dati via Wi-Fi70–170 mA
Wi-Fi connesso, a riposo (modem sleep)15–20 mA
Light sleepCirca 1 mA
Deep sleep (solo il chip ESP8266)Circa 20 µA
Deep sleep (intera scheda D1 mini)80–200 µA (per il regolatore e il chip USB-seriale)
C++ (Arduino IDE)
1// D0 (GPIO 16) ile RST arasına kablo tak / wire D0 (GPIO 16) to RST
2const uint64_t SLEEP_US = 10ULL * 60 * 1000000;   // 10 dakika, mikrosaniye / 10 minutes in µs
3
4void setup() {
5  Serial.begin(115200);
6  delay(100);
7  float volts = analogRead(A0) * 3.2 / 1023.0;     // ölç / measure
8  Serial.print("A0: ");
9  Serial.print(volts, 2);
10  Serial.println(" V");
11  // Wi-Fi ile gönderim burada yapılır / send the reading over Wi-Fi here
12  Serial.println("10 dk uyku / sleeping 10 min");
13  ESP.deepSleep(SLEEP_US);                         // uyanınca setup() baştan başlar / wakes up into setup()
14}
15
16void loop() {
17  // buraya hiç gelinmez / never reached
18}

L'autonomia si stima con un calcolo veloce. Supponiamo che la scheda si svegli ogni 10 minuti, assorba in media 80 mA per 5 secondi mentre invia i dati e dorma a 0,15 mA per i restanti 595 secondi. Ogni ciclo consuma 5 × 80 = 400 mAs più 595 × 0,15 ≈ 89 mAs; in totale 489 mAs, cioè una media di 0,82 mA su 600 secondi. Una batteria 18650 da 2000 mAh dura quindi 2000 / 0,82 ≈ 2440 ore, circa 100 giorni. Fai il conto con i tuoi valori nello strumento Durata della batteria, e trovi l'equivalente per l'ESP32 in ESP32 Deep Sleep.

Con il ponticello D0–RST inserito, su alcune schede il caricamento del codice non va a buon fine; se succede, togli il filo per il tempo dell'upload. Al posto di un filo diretto, una resistenza da 470 Ω–1 kΩ o un diodo Schottky (catodo verso D0) fa funzionare senza problemi il pulsante RESET e il caricamento automatico. Mentre usi il deep sleep, non usare D0 per nient'altro.

Wemos D1 mini, NodeMCU o D1 mini ESP32?

SchedaChipPunto di forzaQuando sceglierla?
Wemos D1 miniESP8266Piccolissima, sistema di shieldPiccoli sensori Wi-Fi, progetti con shield
NodeMCU V3ESP8266Più grande, pin serigrafatiPrototipi comodi su breadboard
D1 mini ESP32 (MiniKit)ESP32-WROOM-32Piedinatura D1 mini + fila interna aggiuntivaBluetooth, più canali ADC e più memoria
LOLIN S2 mini / C3 miniESP32-S2 / ESP32-C3Formato D1 mini, compatibile con gli shieldUSB nativa (S2), BLE e bassi consumi (C3)

Sulle schede D1 mini ESP32 le file di pin esterne corrispondono agli shield del D1 mini, quindi puoi innestare così come sono lo shield relè o OLED. Sull'ESP32 però le sigle D corrispondono ad altri GPIO; i pin I2C, per esempio, sono D1 = GPIO 22 e D2 = GPIO 21. Nel codice usa WiFi.h al posto di ESP8266WiFi.h e adatta i numeri dei pin alla mappa della scheda. La versione ESP32 legge gli ingressi analogici a 12 bit (0–4095), ha il Bluetooth e molta più memoria. Se non sai quale scegliere, confronta Cos'è l'ESP32? con NodeMCU ESP8266.

Idee di progetto con il Wemos D1 mini

  • Termometro Wi-Fi a batteria: Con uno shield SHT30 o DHT, lo shield batteria e il deep sleep, invia una lettura ogni 10 minuti.
  • Presa smart: Accendi una lampada dal telefono con lo shield relè; per un cablaggio sicuro leggi la guida al modulo relè.
  • Controller per strisce LED: Installa WLED e comanda una striscia WS2812B dal telefono.
  • Sensore porta: Invia una notifica quando la porta si apre con un reed switch.
  • Mini display da scrivania: Mostra ora, meteo o piccoli grafici sullo shield OLED, come su un display OLED più grande.
  • Sensore per la casa smart: Invia i valori a Home Assistant via MQTT.

Errori comuni e soluzioni

SintomoCausa probabileSoluzione
La porta non compareManca il driver CH340 o il cavo è solo di ricaricaInstalla il driver, usa un cavo dati
Risponde il pin sbagliatoNel codice c'è 4 invece di D4Usa le costanti D o il GPIO della tabella
La scheda non si avvia, il codice non parteUn circuito su D3, D4 o D8 altera il livello di avvioSposta il circuito su pin sicuri (D1, D2, D5–D7)
Il Wi-Fi cade spessoanalogRead() chiamato senza pause o alimentazione deboleMetti una pausa tra le letture, usa un buon alimentatore da 5 V
Non si risveglia dal deep sleepD0 non è collegato a RSTCollega D0 a RST con un filo, una resistenza o un diodo
Relè e OLED insieme non funzionanoUsano entrambi D1Cambia il pin del relè o collegalo con un cavetto a un altro pin
Il LED funziona al contrarioIl LED integrato si accende con LOWInverti la logica: LOW = acceso, HIGH = spento
Se la scheda continua a riavviarsi, apri il Monitor seriale a 74880 baud. Il bootloader dell'ESP8266 a questa velocità stampa le righe "rst cause" e "boot mode"; rst cause:2, per esempio, indica il pulsante RESET o un risveglio dal deep sleep, mentre rst cause:4 un reset del watchdog, e così trovi in fretta l'origine del problema.

Con le sue dimensioni minime, il sistema di shield e il Wi-Fi, il Wemos D1 mini è uno degli ingressi più facili alla domotica e ai progetti con sensori. Se tieni a mente la tabella dei pin e le regole di avvio, quasi ogni esempio per ESP8266 funziona al primo colpo. Nell'app BlueGrays trovi schemi e codice passo passo nei progetti ESP (LED lampeggiante, connessione Wi-Fi, web server, OTA e deep sleep), e puoi provarli anche sul D1 mini adattando i numeri dei pin con questa tabella.

Domande frequenti

A quale GPIO corrisponde D4 sul Wemos D1 mini?

D4 corrisponde al GPIO 2, a cui è collegato anche il LED blu integrato. Nel codice puoi scrivere pinMode(D4, OUTPUT) oppure pinMode(2, OUTPUT), mentre pinMode(4, OUTPUT) seleziona D2. Il LED funziona a logica invertita, quindi si accende con LOW.

Il Wemos D1 mini funziona a 5 V?

Sì, la scheda si può alimentare a 5 V dall'USB o dal pin 5V; il regolatore a bordo li porta a 3,3 V. I pin GPIO però lavorano con logica a 3,3 V: i sensori con uscita a 5 V vanno collegati tramite un partitore di tensione o un convertitore di livello.

Quanti volt legge il pin A0 del Wemos D1 mini?

Grazie al partitore da 220 kΩ / 100 kΩ sulla scheda, il pin A0 legge 0–3,2 V come 0–1023. Il chip ESP8266 da solo misura appena 0–1,0 V. Aggiungendo una resistenza da 100 kΩ in serie prima di A0 la portata sale a 4,2 V, sufficiente per leggere una batteria agli ioni di litio.

Perché il Wemos D1 mini non si risveglia dal deep sleep?

Per svegliarsi l'ESP8266 ha bisogno dell'impulso di reset che l'RTC invia su D0 (GPIO 16). Se non colleghi D0 a RST con un filo, una resistenza da 470 Ω–1 kΩ o un diodo Schottky, la scheda resta addormentata. Controlla anche di aver indicato il tempo in microsecondi.

Che differenza c'è tra Wemos D1 mini e NodeMCU?

Entrambi usano lo stesso chip ESP8266 e le sigle D0–D8 corrispondono agli stessi GPIO, quindi gli sketch funzionano senza modifiche. Il D1 mini è molto più piccolo e supporta gli shield impilabili, mentre il NodeMCU è più grande e più comodo su breadboard.

Il Wemos D1 mini ha il Bluetooth?

No, l'ESP8266 supporta solo il Wi-Fi. Se ti serve il Bluetooth usa un D1 mini ESP32 o la LOLIN C3 mini con ESP32-C3, che hanno lo stesso formato e funzionano anche con gli shield del D1 mini.

Vedi tutti i progetti
LED Lampeggiante con ESP32
ES-1Principiante

LED Lampeggiante con ESP32

Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

4.7(37)
108
Lampeggio del LED interno dell'ESP32
ES-4Principiante

Lampeggio del LED interno dell'ESP32

Far lampeggiare il LED blu integrato nell'ESP32 DevKit V1. Non sono necessari componenti esterni! Il primo progetto da provare quando si acquista un ESP32. Il GPIO 2 è collegato al LED interno.

4.8(29)
54
Connessione Wi-Fi STA con ESP32 (con display LCD)
ES-25Avanzato

Connessione Wi-Fi STA con ESP32 (con display LCD)

In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

4.4(21)
38
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)

In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

4.8(16)
26
ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
ES-33Avanzato
Premium

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)

La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.

4.3(10)
16
Aggiornamento OTA dell'ESP32 — Installazione wireless del firmware (con display LCD)
ES-30Avanzato
Premium

Aggiornamento OTA dell'ESP32 — Installazione wireless del firmware (con display LCD)

Imparerai a caricare un nuovo firmware sull'ESP32 via Wi-Fi, senza cavo USB. Con la libreria ArduinoOTA l'ESP32 diventa visibile in rete e compare automaticamente come bluegrays-ota nella scheda "Network port" dell'Arduino IDE. Il primo caricamento avviene via USB, poi tutti gli aggiornamenti sono wireless: una funzione fondamentale per i dispositivi installati sul campo.

4.6(14)
22
ESP32 mDNS: accesso al dispositivo tramite bluegrays-esp.local (con schermo LCD)
ES-29Avanzato
Premium

ESP32 mDNS: accesso al dispositivo tramite bluegrays-esp.local (con schermo LCD)

Aggiungiamo all'ESP32 un servizio mDNS (Multicast DNS), così lo raggiungi con un nome host leggibile come bluegrays-esp.local invece che con un indirizzo IP. Anche se l'IP assegnato dal DHCP cambia, il dispositivo risponde sempre allo stesso nome. Un piccolo server web sulla scheda ti permette di controllare il LED dal browser all'indirizzo http://bluegrays-esp.local/.

4.8(14)
23
Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
ES-37Avanzato
Premium

Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)

Con un ESP32, un sensore di movimento PIR, un sensore di luce LDR e un modulo relè trasformiamo il corridoio, il bagno o la dispensa di casa in un'illuminazione smart. Se l'ambiente è già luminoso, la luce non si accende nemmeno con il movimento, così di giorno non spreca energia. La luce resta accesa 30 secondi e il tempo si allunga in automatico finché il movimento continua.

4.3(6)
11