Guide · 9 min di lettura

ESP32 servo Wi-Fi: controllare un servo dal telefono con slider

Servo con ESP32 via Wi-Fi: libreria ESP32Servo, slider web con fetch, scelta del pin, alimentazione e massa comune, niente tremolii e versione pan-tilt.

Il modo più divertente per usare un servo con l'ESP32 via Wi-Fi è farlo girare in tempo reale con uno slider sul telefono: fai scorrere il dito e il servo ti segue, senza installare nessuna app. In questa guida trasformiamo l'ESP32 in un server web, inviamo all'ESP32 il valore dello slider della pagina aperta nel browser con il comando JavaScript fetch e portiamo il servo a quell'angolo con la libreria ESP32Servo.

Oltre al codice spieghiamo nel dettaglio la parte hardware, perché la maggior parte dei progetti con servo e Wi-Fi fallisce per colpa dell'alimentazione e non del software: il servo trema, l'ESP32 si riavvia o la connessione cade. Vedrai passo passo quale pin scegliere, come alimentare il servo, perché la massa comune è obbligatoria, come evitare i tremolii e, alla fine, come costruire un meccanismo pan-tilt con due servo.

Micro servo SG90
Micro servo SG90: ruota da 0 a 180 gradi, si alimenta a 4,8–6 V e si posiziona in base alla larghezza dell'impulso di un segnale PWM a 50 Hz.

Come funziona: dallo slider al servo

  1. Il browser del telefono apre l'indirizzo IP dell'ESP32, che risponde con una piccola pagina HTML con uno slider.
  2. Mentre muovi lo slider, il JavaScript della pagina invia l'angolo con fetch a un indirizzo come /set?angle=120; la pagina non si ricarica.
  3. Il server web dell'ESP32 riceve la richiesta, legge l'angolo e lo limita all'intervallo 0–180.
  4. La libreria ESP32Servo converte l'angolo in larghezza d'impulso: circa 500 µs per 0 gradi e 2400 µs per 180 gradi, inviati 50 volte al secondo.
  5. La scheda di controllo dentro il servo legge l'impulso, porta il motore a quell'angolo e lo mantiene lì.

Come funziona un servo e il legame tra larghezza d'impulso e angolo li abbiamo spiegati in dettaglio in Cos'è un servomotore? Qui ti basta sapere questo: sull'ESP32 la libreria Servo standard di Arduino non funziona, perché l'ESP32 genera il PWM con un hardware diverso (LEDC). Per questo usiamo la libreria ESP32Servo, che offre gli stessi comandi attach() e write() ed è compatibile con i core ESP32 2.x e 3.x.

Materiale necessario

  • Una scheda di sviluppo ESP32 (DevKit, NodeMCU-32S o simile)
  • Un servo SG90 o MG90S (per il pan-tilt due servo e una staffa pan-tilt)
  • Un alimentatore esterno da 5 V: un adattatore da almeno 2 A o un portabatterie per 4 pile AA
  • Un condensatore elettrolitico da 470–1000 µF (almeno 10 V)
  • Breadboard e cavetti jumper
  • Il pacchetto schede ESP32 installato nell'IDE Arduino e la libreria ESP32Servo installata dal Gestore librerie

Scelta del pin: a quale GPIO collegare il servo?

Quasi tutti i pin di uscita dell'ESP32 possono generare PWM, ma non tutti vanno bene allo stesso modo per un servo. Alcuni emettono brevi segnali durante l'avvio e fanno scattare il servo a ogni accensione; altri sono solo ingressi. Trovi la piedinatura completa della tua scheda nello strumento Pinout:

PinPer il servoPerché
GPIO 13, 25, 26, 27, 32, 33ConsigliatiSilenziosi all'avvio, ognuno può generare PWM (LEDC)
GPIO 4, 16, 17, 18, 19, 21, 22, 23AdattiPin di uso generale sicuri; lasciali liberi se usi I2C (21, 22) o SPI (18, 19, 23)
GPIO 2, 5, 12, 14, 15Da evitarePin di avvio (strapping) o con PWM all'avvio; il servo può scattare o la scheda non partire
GPIO 34–39Non utilizzabiliSolo ingressi, non possono generare PWM
GPIO 6–11Non utilizzabiliCollegati alla memoria flash interna
GPIO 1 e 3Non utilizzabiliLinea seriale dell'USB (TX, RX)

Alimentazione del servo e massa comune

Un SG90 a riposo assorbe circa 10 mA, ma appena si mette in moto o mentre regge un carico la corrente sale a 500–700 mA. L'ESP32, a sua volta, assorbe picchi di circa 250 mA quando trasmette via Wi-Fi. Se alimenti entrambi dalla stessa linea USB debole, la tensione crolla e l'ESP32 si riavvia con il messaggio "Brownout detector was triggered". La soluzione è alimentare il servo con una sorgente da 5 V separata e unire le masse dei due circuiti:

Filo del servoCollegamentoNota
Marrone o nero (GND)Negativo dell'alimentatore esterno e pin GND dell'ESP32La massa comune è obbligatoria: è il riferimento del segnale
Rosso (V+)Alimentatore esterno da 5 V (4,8–6 V)Mai sul pin 3V3 dell'ESP32
Arancione o giallo (segnale)GPIO 13Un segnale a 3,3 V basta per SG90 e MG90S
Non dimenticare la massa comune. Il segnale del servo è una tensione misurata rispetto alla massa dell'ESP32. Se non colleghi il negativo dell'alimentatore esterno al pin GND dell'ESP32, il servo si muove a caso o non risponde affatto. E non alimentare mai il servo dal pin 3V3 dell'ESP32: il regolatore della scheda non regge quella corrente e l'ESP32 continua a riavviarsi.
ConfigurazioneAlimentazione consigliataNota
1 SG90, prova senza caricoPin 5V (VIN) della scheda ESP32, dall'USBSolo per prove brevi; con il Wi-Fi possono comparire brownout
2 SG90 (pan-tilt)Alimentatore da 5 V e almeno 2 AAggiungi un condensatore da 470–1000 µF sull'alimentazione
1–2 MG996R5–6 V, almeno 3 ALa corrente di stallo può arrivare a 2,5 A per servo
Progetto portatile4 pile AA (alcaline, 6 V)Le ricaricabili NiMH danno 4,8 V, che bastano lo stesso

Passo 1: primo test con ESP32Servo

Prima di passare al Wi-Fi, assicurati che servo e alimentazione funzionino bene. Cerca ESP32Servo nel Gestore librerie, installa quella di Kevin Harrington e John K. Bennett e poi carica lo sketch qui sotto. Il servo dovrebbe andare avanti e indietro lentamente tra 0 e 180 gradi; se non lo fa, il problema è nei collegamenti o nell'alimentazione, non nel software.

C++ (Arduino IDE)
1#include <ESP32Servo.h>
2
3const int SERVO_PIN = 13;                  // açılışta sessiz, güvenli pin / quiet at boot, safe pin
4Servo servo;
5
6void setup() {
7  servo.setPeriodHertz(50);                // standart servo 50 Hz / standard servo, 50 Hz
8  servo.attach(SERVO_PIN, 500, 2400);      // 0° = 500 µs, 180° = 2400 µs (SG90)
9}
10
11void loop() {
12  for (int a = 0; a <= 180; a += 2) {      // 0 → 180°
13    servo.write(a);
14    delay(15);
15  }
16  for (int a = 180; a >= 0; a -= 2) {      // 180 → 0°
17    servo.write(a);
18    delay(15);
19  }
20}
I due numeri della riga attach(pin, 500, 2400) sono le larghezze d'impulso di 0 e 180 gradi, in microsecondi. La maggior parte dei cloni dell'SG90 lavora in questo intervallo. Se il servo ronza agli estremi o arriva al suo fine corsa meccanico, restringi l'intervallo (per esempio 600 e 2300) oppure tieni l'angolo tra 5 e 175 gradi.

Passo 2: controllare il servo con uno slider sulla pagina web

Ora passiamo al progetto vero e proprio. Lo sketch qui sotto collega l'ESP32 alla rete di casa, serve una pagina con uno slider e scrive sul servo l'angolo che arriva all'indirizzo /set. La pagina HTML sta dentro il codice come testo grezzo (raw string), quindi non devi caricare nessun file a parte. Inserisci nome e password del tuo Wi-Fi, carica lo sketch e apri nel browser del telefono l'indirizzo IP mostrato nel Monitor seriale.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* WIFI_SSID = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifren / your Wi-Fi password
7const int SERVO_PIN = 13;
8
9WebServer server(80);
10Servo servo;
11int currentAngle = 90;                    // açılışta ortada / centred at start
12
13// Telefonda açılan sayfa / page opened on the phone
14const char PAGE[] PROGMEM = R"rawliteral(
15<!DOCTYPE html><html><head><meta charset="utf-8">
16<meta name="viewport" content="width=device-width,initial-scale=1">
17<title>ESP32 Servo</title>
18<style>
19body{font-family:sans-serif;text-align:center;margin-top:40px}
20input{width:85%;height:40px}
21#v{font-size:56px;font-weight:bold}
22</style></head><body>
23<h2>ESP32 Servo</h2>
24<p><span id="v">%ANGLE%</span>°</p>
25<input type="range" id="s" min="0" max="180" value="%ANGLE%">
26<script>
27const s = document.getElementById('s');
28const v = document.getElementById('v');
29let last = 0, timer = null;
30function send() {
31  fetch('/set?angle=' + s.value);          // açıyı gönder / send the angle
32  last = Date.now();
33}
34s.addEventListener('input', () => {
35  v.textContent = s.value;
36  clearTimeout(timer);
37  if (Date.now() - last > 100) send();     // en fazla 10 istek/sn / at most 10 requests/s
38  else timer = setTimeout(send, 100);      // son değer mutlaka gider / the last value always goes out
39});
40</script></body></html>
41)rawliteral";
42
43void handleRoot() {
44  String html = PAGE;
45  html.replace("%ANGLE%", String(currentAngle));   // slider doğru yerde başlar / slider starts at the right spot
46  server.send(200, "text/html", html);
47}
48
49void handleSet() {
50  if (!server.hasArg("angle")) {
51    server.send(400, "text/plain", "angle?");
52    return;
53  }
54  int angle = constrain(server.arg("angle").toInt(), 0, 180);   // güvenli aralık / safe range
55  if (angle != currentAngle) {             // aynı açıyı tekrar yazma / don't rewrite the same angle
56    servo.write(angle);
57    currentAngle = angle;
58  }
59  server.send(200, "text/plain", String(currentAngle));
60}
61
62void setup() {
63  Serial.begin(115200);
64  servo.setPeriodHertz(50);
65  servo.attach(SERVO_PIN, 500, 2400);
66  servo.write(currentAngle);
67
68  WiFi.mode(WIFI_STA);
69  WiFi.begin(WIFI_SSID, WIFI_PASS);
70  while (WiFi.status() != WL_CONNECTED) {  // bağlanana kadar bekle / wait until connected
71    delay(500);
72    Serial.print(".");
73  }
74  Serial.println();
75  Serial.print("IP: ");
76  Serial.println(WiFi.localIP());          // bu adresi telefonda aç / open this address on your phone
77
78  server.on("/", handleRoot);
79  server.on("/set", handleSet);
80  server.begin();
81}
82
83void loop() {
84  server.handleClient();
85}

Il codice ha due punti chiave. Primo: il JavaScript non invia una richiesta a ogni minimo movimento dello slider; aspetta almeno 100 ms tra una richiesta e l'altra e, quando sollevi il dito, invia sempre l'ultimo valore. Uno slider può generare 60 eventi al secondo; inviarli tutti intasa il server web dell'ESP32 e fa muovere il servo a scatti. Secondo: lato server, constrain() limita l'angolo a 0–180, così anche se qualcuno scrive un valore sbagliato nella barra degli indirizzi il servo non viene forzato.

A ogni apertura della pagina il segnaposto %ANGLE% viene sostituito con l'angolo attuale del servo, quindi lo slider parte nella posizione giusta anche dopo aver chiuso e riaperto il browser. Possono collegarsi più telefoni contemporaneamente; vale l'ultimo angolo inviato. Se vuoi un'interfaccia in tempo reale che si aggiorni subito su tutti i telefoni, passa al metodo di ESP32 Async Web Server e WebSocket.

Niente router? L'ESP32 crea la sua rete Wi-Fi

Se userai il progetto a una fiera della scienza, in giardino o in un posto senza rete di casa, fai lavorare l'ESP32 in modalità access point (AP). In setup() sostituisci le righe WiFi.mode e WiFi.begin e il ciclo che aspetta la connessione con le righe qui sotto; poi basta collegare il telefono alla rete ESP32-Servo e aprire 192.168.4.1 nel browser:

C++ (Arduino IDE)
1// Router yoksa: ESP32 kendi ağını kurar / No router: the ESP32 creates its own network
2WiFi.softAP("ESP32-Servo", "12345678");    // şifre en az 8 karakter / password, at least 8 characters
3Serial.print("IP: ");
4Serial.println(WiFi.softAPIP());           // genellikle 192.168.4.1 / usually 192.168.4.1

Come evitare i tremolii del servo

  • Alimentazione separata e massa comune: la causa numero uno dei tremolii è un'alimentazione debole; alimenta il servo con una sorgente da 5 V di almeno 2 A e unisci le masse.
  • Condensatore: metti un condensatore elettrolitico da 470–1000 µF sui fili di alimentazione, vicino al servo; attenua il calo di tensione all'avvio. Puoi decifrare le sigle dei condensatori con lo strumento codice dei condensatori.
  • Limita le richieste: non inviare ogni evento dello slider; il limite di 100 ms nel codice alleggerisce sia la rete sia il servo.
  • Non riscrivere lo stesso angolo: il controllo if (angle != currentAngle) nel codice evita scritture inutili.
  • L'intervallo d'impulso giusto: se il servo ronza agli estremi, sta spingendo contro il fine corsa; restringi l'intervallo di attach() o i limiti dell'angolo.
  • Filo di segnale corto: con cavi più lunghi di 30 cm, porta segnale e GND affiancati, meglio se intrecciati.
  • Ultima risorsa, detach(): se chiami detach() quando il servo ha raggiunto la posizione, il segnale si interrompe e il tremolio sparisce, ma il servo non tiene più il carico.

Se il problema continua, guarda Servo che trema: cause e soluzioni, dove analizziamo con misure tutte le cause del tremolio. Se usi le pile, puoi stimare in anticipo quanto dureranno con il calcolatore di autonomia della batteria.

Passo 3: versione pan-tilt con due servo

Un meccanismo pan-tilt ha due servo: quello in basso ruota in orizzontale (pan), quello in alto in verticale (tilt). Montaci sopra una videocamera, un laser o un sensore a ultrasuoni e avrai un occhio orientabile a distanza. Collega il servo pan a GPIO 13 e il servo tilt a GPIO 27, e alimentali entrambi con lo stesso alimentatore esterno da 5 V. Questa versione porta due novità: la pagina ha due slider e i servo, invece di saltare di colpo al nuovo angolo, avanzano di un grado ogni 10 ms fino a raggiungerlo. Così il movimento è più fluido ed eviti che i due servo assorbano molta corrente nello stesso istante.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* WIFI_SSID = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifren / your Wi-Fi password
7const int PAN_PIN = 13;                   // yatay servo / pan servo
8const int TILT_PIN = 27;                  // dikey servo / tilt servo
9
10WebServer server(80);
11Servo pan, tilt;
12int panTarget = 90, tiltTarget = 90;      // hedef açılar / target angles
13int panNow = 90, tiltNow = 90;            // anlık açılar / current angles
14unsigned long lastStep = 0;
15
16const char PAGE[] PROGMEM = R"rawliteral(
17<!DOCTYPE html><html><head><meta charset="utf-8">
18<meta name="viewport" content="width=device-width,initial-scale=1">
19<title>ESP32 Pan-Tilt</title>
20<style>body{font-family:sans-serif;text-align:center}input{width:85%;height:40px}</style>
21</head><body>
22<h2>ESP32 Pan-Tilt</h2>
23<p>Pan: <b id="pv">%PAN%</b>°</p>
24<input type="range" id="pan" min="0" max="180" value="%PAN%">
25<p>Tilt: <b id="tv">%TILT%</b>°</p>
26<input type="range" id="tilt" min="20" max="160" value="%TILT%">
27<script>
28const pan = document.getElementById('pan');
29const tilt = document.getElementById('tilt');
30let last = 0, timer = null;
31function send() {
32  fetch('/set?pan=' + pan.value + '&tilt=' + tilt.value);   // iki açı tek istekte / both angles in one request
33  last = Date.now();
34}
35function changed() {
36  document.getElementById('pv').textContent = pan.value;
37  document.getElementById('tv').textContent = tilt.value;
38  clearTimeout(timer);
39  if (Date.now() - last > 100) send();
40  else timer = setTimeout(send, 100);
41}
42pan.addEventListener('input', changed);
43tilt.addEventListener('input', changed);
44</script></body></html>
45)rawliteral";
46
47void handleRoot() {
48  String html = PAGE;
49  html.replace("%PAN%", String(panTarget));
50  html.replace("%TILT%", String(tiltTarget));
51  server.send(200, "text/html", html);
52}
53
54void handleSet() {
55  if (server.hasArg("pan"))  panTarget  = constrain(server.arg("pan").toInt(), 0, 180);
56  if (server.hasArg("tilt")) tiltTarget = constrain(server.arg("tilt").toInt(), 20, 160);   // braket sınırı / bracket limit
57  server.send(200, "text/plain", "OK");
58}
59
60// Her 10 ms'de hedefe 1 derece yaklaş: yumuşak hareket, düşük akım
61// Step 1 degree toward the target every 10 ms: smooth motion, lower current peaks
62void moveSmoothly() {
63  if (millis() - lastStep < 10) return;
64  lastStep = millis();
65  if (panNow != panTarget) {
66    panNow += (panTarget > panNow) ? 1 : -1;
67    pan.write(panNow);
68  }
69  if (tiltNow != tiltTarget) {
70    tiltNow += (tiltTarget > tiltNow) ? 1 : -1;
71    tilt.write(tiltNow);
72  }
73}
74
75void setup() {
76  Serial.begin(115200);
77  pan.setPeriodHertz(50);
78  tilt.setPeriodHertz(50);
79  pan.attach(PAN_PIN, 500, 2400);
80  tilt.attach(TILT_PIN, 500, 2400);
81  pan.write(panNow);
82  tilt.write(tiltNow);
83
84  WiFi.mode(WIFI_STA);
85  WiFi.begin(WIFI_SSID, WIFI_PASS);
86  while (WiFi.status() != WL_CONNECTED) {
87    delay(500);
88    Serial.print(".");
89  }
90  Serial.println();
91  Serial.print("IP: ");
92  Serial.println(WiFi.localIP());
93
94  server.on("/", handleRoot);
95  server.on("/set", handleSet);
96  server.begin();
97}
98
99void loop() {
100  server.handleClient();                   // istekleri işle / handle requests
101  moveSmoothly();                          // servoları hedefe taşı / move the servos toward their targets
102}

L'asse tilt è limitato a 20–160 gradi perché, nella maggior parte delle staffe pan-tilt in plastica, il servo superiore urta la base agli estremi. Sul tuo montaggio porta piano il servo verso gli estremi, annota l'angolo appena prima dell'urto e regola di conseguenza sia i valori min e max dello slider sia i limiti di constrain() nel codice. Se ti servono più servo, passare dai pin dell'ESP32 a una scheda driver per servo PCA9685 a 16 canali semplifica molto collegamenti e alimentazione.

Errori comuni e come risolverli

  • Il servo non si muove per niente: le masse non sono collegate, il servo è sul 3V3 o il filo di segnale è su uno dei pin solo ingresso GPIO 34–39.
  • L'ESP32 si riavvia quando il servo si muove: l'alimentazione non basta; alimenta il servo con una sorgente da 5 V separata e aggiungi un condensatore.
  • Errore "This library only supports boards with an AVR...": la libreria Servo di Arduino non supporta l'ESP32; usa #include <ESP32Servo.h>.
  • La pagina non si apre: telefono ed ESP32 non sono sulla stessa rete, il telefono è passato ai dati mobili o la rete è a 5 GHz; l'ESP32 si collega solo a reti a 2,4 GHz. Per altri problemi di connessione guarda L'ESP32 non si collega al Wi-Fi.
  • Il servo segue lo slider in ritardo: si accumulano troppe richieste; mantieni il limite di 100 ms del JavaScript o alzalo a 150 ms.
  • Il servo scatta a ogni accensione: il segnale è su un pin che emette PWM all'avvio (GPIO 2, 5, 12, 14, 15); spostalo su GPIO 13, 25–27 o 32–33.

Controllare un servo dal telefono con uno slider è la base di molti progetti: bracci robotici, telecamere orientabili, serrature smart e sportelli che si aprono a distanza. Se passi a un servo più potente, fai il calcolo dell'alimentazione con Servomotore MG996R. Nell'app BlueGrays trovi passo passo, con schema di collegamento e codice, il controllo di un servo con potenziometro sull'ESP32, la serratura RFID con servo e i progetti di server web con l'ESP32.

Domande frequenti

Come si controlla un servomotore con l'ESP32?

Installa la libreria ESP32Servo, collega il filo di segnale del servo a un pin sicuro come GPIO 13, avvialo con servo.attach(13, 500, 2400) e poi usa servo.write(angolo). Alimenta il servo con una sorgente esterna da 5 V invece che dall'ESP32 e unisci le masse.

Perché Servo.h non funziona sull'ESP32?

La libreria Servo standard di Arduino è scritta per processori come AVR e SAMD e non conosce l'hardware PWM dell'ESP32 (LEDC). La libreria ESP32Servo offre gli stessi comandi e funziona sui core ESP32 2.x e 3.x.

Il segnale a 3,3 V dell'ESP32 basta per un servo?

La maggior parte dei servo più diffusi, come SG90, MG90S e MG996R, riconosce senza problemi un segnale a 3,3 V. Il problema è quasi sempre l'alimentazione, non il segnale: il filo rosso del servo deve andare a una sorgente da 5–6 V che fornisca corrente sufficiente.

Quanti servo si possono collegare a un ESP32?

L'unità LEDC dell'ESP32 classico ha 16 canali PWM, quindi in teoria puoi pilotare fino a 16 servo. In pratica finiscono prima i pin adatti o l'alimentazione; oltre i quattro servo, una scheda driver PCA9685 in I2C è una soluzione più pulita.

Si può controllare un servo con l'ESP32 senza router?

Sì. In modalità access point con WiFi.softAP() l'ESP32 crea la propria rete Wi-Fi. Colleghi il telefono a quella rete, apri 192.168.4.1 nel browser e usi la stessa pagina con lo slider.

Perché il mio servo collegato all'ESP32 trema?

Le cause più comuni sono un'alimentazione insufficiente, la mancanza di massa comune e troppi comandi al secondo. Alimenta il servo con una sorgente da 5 V separata, aggiungi un condensatore da 470–1000 µF e limita le richieste della pagina web a una ogni 100 ms.

Vedi tutti i progetti
Servomotore ESP32 (controllo tramite potenziometro)
ES-16Intermedio
Premium

Servomotore ESP32 (controllo tramite potenziometro)

In questo progetto controlliamo un servomotore SG90 tramite un potenziometro. Regoliamo l'angolo del servomotore mappando il valore analogico letto dal potenziometro su un intervallo compreso tra 0 e 180 gradi. La libreria ESP32Servo genera segnali per servomotori sui GPIO adatti dell'ESP32 che possono funzionare come uscite; in questo progetto si utilizza GPIO 18. Si tratta di un metodo di controllo fondamentale per bracci robotici, gimbal per telecamere e meccanismi di porte automatiche.

4.3(29)
42
Serratura RFID ESP32 (RC522 + servomotore + OLED + cicalino + LED)
ES-35Avanzato
Premium

Serratura RFID ESP32 (RC522 + servomotore + OLED + cicalino + LED)

Costruiamo una serratura smart con ESP32, modulo RFID RC522, servo SG90, display OLED SSD1306, buzzer attivo e 2 LED. Quando passi una tessera, il suo UID viene confrontato con quelle autorizzate definite nel codice; se corrisponde, il servo apre (LED verde + 2 bip brevi) e richiude dopo 5 secondi. Con una tessera sconosciuta si accende il LED rosso, suonano 3 bip rapidi e l'OLED mostra l'UID.

4.8(9)
16
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
Contatore WebSocket ESP32 (2 pulsanti + LCD + Web in tempo reale)
ES-28Avanzato
Premium

Contatore WebSocket ESP32 (2 pulsanti + LCD + Web in tempo reale)

In questo progetto due pulsanti collegati all'ESP32 (GPIO 5 incrementa, GPIO 4 decrementa) modificano un contatore. Il valore si aggiorna all'istante su un display LCD I2C 16x2 e, grazie al supporto WebSocket di ESPAsyncWebServer, in tutti i browser collegati senza ricaricare la pagina. Al posto del polling HTTP si usa un'unica connessione persistente e l'ESP32 invia il nuovo valore a tutti con ws.textAll().

4.5(14)
23
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
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
Servocomando con joystick
AR-60Intermedio
Premium

Servocomando con joystick

Comanda due motori con un joystick, proprio come se girassi una telecamera di sicurezza.

4.7(42)
58