Guide · 10 min di lettura

Macchina WiFi ESP32: guidala col joystick dallo smartphone

Macchina WiFi ESP32 guidata dal browser dello smartphone: rete softAP, joystick web, L298N con PWM, lista componenti con costi e stop se il segnale cade.

Una macchina WiFi ESP32 è una macchinina robot che guidi con una pagina joystick nel browser dello smartphone, senza installare nessuna app. L'ESP32 crea la propria rete WiFi (softAP), il telefono si collega e, appena scrivi 192.168.4.1 nel browser, compare un joystick. Mentre muovi il dito, l'ESP32 accelera, frena e fa girare due motoriduttori in PWM tramite un driver a ponte H L298N. Non servono router, internet o abbinamento Bluetooth, e funziona allo stesso modo su Android e iPhone.

In questa guida costruiamo la macchina dall'inizio alla fine: lista dei componenti e costo indicativo, tabella dei collegamenti ESP32–L298N, un primo sketch che prova i motori senza WiFi, lo sketch principale che incorpora la pagina joystick nell'ESP32 e come la posizione del joystick diventa la velocità delle due ruote. Aggiungiamo anche una sicurezza che quasi tutti gli esempi dimenticano: se la connessione cade, la macchina si ferma da sola entro mezzo secondo. Il codice compila con le versioni 2.x e 3.x del core ESP32 per Arduino.

ESP32
ESP32
L298N
L298N
TT motor
TT motor
18650 Li-ion
18650 Li-ion

Come funziona una macchina WiFi con ESP32?

Il sistema ha quattro parti. L'ESP32 è il cervello e anche un piccolo web server: invia allo smartphone la pagina del joystick e poi esegue i comandi "motore sinistro a questa velocità, motore destro a quest'altra" che arrivano dieci volte al secondo. Il L298N è un doppio ponte H; trasforma i deboli segnali a 3,3 V dell'ESP32 nella corrente richiesta dai motori. Due motoriduttori gialli TT fanno girare le ruote; non c'è sterzo, la macchina curva grazie alla differenza di velocità tra le due ruote (trazione differenziale). Due batterie 18650 alimentano i motori e, tramite il regolatore a 5 V del modulo L298N, anche l'ESP32. In modalità softAP l'ESP32 si comporta come un router e si assegna sempre l'indirizzo 192.168.4.1, quindi puoi guidare la macchina in giardino, a scuola o ovunque senza router.

WiFi softAP (questa guida)WiFi di casa (STA)Bluetooth (HC-05 o BT classico)
Serve un router?NoSìNo
App sullo smartphoneNon serve, basta il browserNon serve, basta il browserServe un'app terminale Bluetooth
Compatibile con iPhoneSìSìNo (iOS non supporta la seriale su Bluetooth classico)
Portata all'apertoCirca 30–50 mQuanto la copertura del routerCirca 10–20 m
Ritardo dei comandiCirca 20–50 ms20–100 ms secondo il traffico di reteCirca 20–40 ms

Lista componenti e costi

ComponenteQ.tàPrezzo indicativo (USD)Nota
ESP32 DevKit V1 (30 o 38 pin)14–7I GPIO usati ci sono su entrambe le schede
Modulo driver motori L298N12–42 A per canale; pilota due motori separatamente
Kit telaio macchinina robot 2WD18–15Di solito con 2 motori TT, 2 ruote, ruota pivottante e interruttore
Batteria Li-ion 1865026–12Celle di marca da almeno 5 A di scarica
Portabatterie 2 × 18650 (in serie)11–2Il modello con interruttore semplifica i collegamenti
Caricabatterie 1865013–10Che carichi ogni cella separatamente
Cavi jumper (femmina-femmina, maschio-femmina)10+1–3Tra ESP32 e L298N
Condensatori 470 µF / 16 V e 100 nF1 + 2Meno di 1Contro i cali di tensione e i disturbi dei motori
Totale25–5015–25 se hai già batterie e caricabatterie

I prezzi sono valori tipici dei negozi di elettronica online e cambiano secondo il paese, la spedizione e il cambio; in euro si resta più o meno sulle stesse cifre. Le voci più pesanti sono il telaio e le batterie. Non risparmiare sulle batterie: le celle molto economiche con scritto "9900 mAh" sono quasi sempre false, la loro tensione crolla all'avvio dei motori e l'ESP32 si riavvia. Se hai già un kit di macchinina robot per Arduino, ti basta comprare un ESP32; telaio, motori e L298N restano uguali. Spieghiamo come scegliere le celle in Batteria Li-ion 18650.

Collegamenti: ESP32, L298N e motori

L298NESP32Descrizione
ENAGPIO 25Velocità motore sinistro (PWM); togli il jumper ENA
IN1GPIO 26Senso di rotazione motore sinistro
IN2GPIO 27Senso di rotazione motore sinistro
ENBGPIO 33Velocità motore destro (PWM); togli il jumper ENB
IN3GPIO 18Senso di rotazione motore destro
IN4GPIO 19Senso di rotazione motore destro
+12V (VS)–Positivo del pacco 2×18650 (dopo l'interruttore)
GNDGNDNegativo delle batterie e GND dell'ESP32; la massa comune è obbligatoria
+5VVIN (5V)Alimenta l'ESP32 dal regolatore del L298N finché il jumper 5V-EN è inserito
OUT1 / OUT2–Motore sinistro
OUT3 / OUT4–Motore destro

Gli ingressi logici del L298N considerano HIGH qualsiasi tensione sopra 2,3 V, quindi le uscite a 3,3 V dell'ESP32 si collegano direttamente, senza convertitore di livello. A piena carica il pacco dà 8,4 V; il L298N ne perde 1,5–3 V e ai motori arrivano 5–6 V, proprio l'intervallo ideale dei motori TT. Il regolatore 78M05 del modulo ricava 5 V dallo stesso pacco e alimenta l'ESP32 dal pin VIN. Nemmeno la scelta dei pin è casuale: i GPIO 0, 2, 12 e 15 sono pin di strapping che decidono la modalità di avvio, i 6–11 sono riservati alla memoria flash e i 34–39 sono solo ingressi. 25, 26, 27, 33, 18 e 19 sono uscite sicure presenti sulle schede a 30 e a 38 pin. Spieghiamo perché la massa deve essere comune in GND e massa comune.

Finché l'ESP32 è collegato all'USB, stacca il filo +5V del L298N da VIN oppure spegni l'interruttore delle batterie; due sorgenti a 5 V insieme possono rimandare corrente nella porta USB del computer su alcune schede. Non collegare mai il positivo delle batterie direttamente all'ESP32: 8,4 V sul pin 3V3 distruggono subito la scheda e 8,4 V su VIN surriscaldano il regolatore AMS1117 della scheda.

Montaggio passo passo

  1. Nel Gestore schede dell'Arduino IDE installa esp32 by Espressif Systems e scegli la scheda ESP32 Dev Module.
  2. Avvita i motori al telaio e collega i loro fili ai morsetti OUT1-OUT2 (sinistro) e OUT3-OUT4 (destro) del L298N.
  3. Togli i jumper ENA ed ENB dal L298N; lascia inserito il jumper 5V-EN.
  4. Collega i sei fili di segnale della tabella e la massa comune con cavi jumper femmina-femmina.
  5. Appoggia la macchina su una scatola con le ruote sollevate; carica lo sketch di prova dei motori e controlla i sensi di rotazione.
  6. Carica lo sketch principale, apri il Monitor seriale a 115200 baud e annota l'indirizzo che compare.
  7. Nelle impostazioni WiFi dello smartphone collegati alla rete BlueGrays-Car con la password 12345678 e scrivi 192.168.4.1 nel browser.
  8. Spingi piano il joystick; se le ruote girano nel verso giusto, appoggia la macchina a terra e guida.

Prima prova i motori

Prima di passare al codice WiFi, verifica i collegamenti con questo breve sketch. Tiene ENA ed ENB sempre a HIGH, quindi i motori girano alla massima velocità: un secondo avanti, poi indietro, poi sul posto a sinistra e a destra. Se al comando di avanzare una ruota gira all'indietro, non toccare il codice: inverti i due fili di quel motore sul L298N. Se non gira nessun motore, controlla l'interruttore delle batterie, la massa comune e i fili di ENA ed ENB.

C++ (Arduino IDE)
1// L298N bağlantı testi (Wi-Fi yok) / L298N wiring test (no Wi-Fi)
2// Sol motor / left motor: ENA=25, IN1=26, IN2=27 — Sağ motor / right motor: ENB=33, IN3=18, IN4=19
3const int ENA = 25, IN1 = 26, IN2 = 27;
4const int ENB = 33, IN3 = 18, IN4 = 19;
5
6void wheels(int l1, int l2, int r1, int r2) {
7  digitalWrite(IN1, l1); digitalWrite(IN2, l2);
8  digitalWrite(IN3, r1); digitalWrite(IN4, r2);
9}
10
11void setup() {
12  int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
13  for (int p : pins) pinMode(p, OUTPUT);
14  digitalWrite(ENA, HIGH);                 // tam hız, PWM yok / full speed, no PWM
15  digitalWrite(ENB, HIGH);
16  wheels(LOW, LOW, LOW, LOW);
17  delay(3000);                             // tekerlekleri havaya kaldır / lift the wheels
18}
19
20void loop() {
21  wheels(HIGH, LOW, HIGH, LOW); delay(1000);   // ileri / forward
22  wheels(LOW, LOW, LOW, LOW);   delay(500);    // dur / stop
23  wheels(LOW, HIGH, LOW, HIGH); delay(1000);   // geri / backward
24  wheels(LOW, LOW, LOW, LOW);   delay(500);
25  wheels(LOW, HIGH, HIGH, LOW); delay(700);    // yerinde sola / spin left
26  wheels(HIGH, LOW, LOW, HIGH); delay(700);    // yerinde sağa / spin right
27  wheels(LOW, LOW, LOW, LOW);   delay(2000);
28}

Sketch principale: una macchina che crea la sua rete WiFi (softAP)

Nello sketch principale la pagina del joystick è incorporata nell'ESP32 come un unico testo HTML, CSS e JavaScript. Non devi caricare file a parte né installare librerie: si usano solo WiFi e WebServer, già inclusi nel pacchetto ESP32. Con la pagina aperta, il browser invia ogni 100 ms una piccola richiesta come /d?l=60&r=-60; l'ESP32 legge i due numeri, li applica ai motori e annota l'istante del comando.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* AP_SSID = "BlueGrays-Car";      // telefonda görünecek ağ adı / network name on the phone
5const char* AP_PASS = "12345678";           // en az 8 karakter / at least 8 characters
6
7// Sol motor / left motor: ENA=25, IN1=26, IN2=27 — Sağ motor / right motor: ENB=33, IN3=18, IN4=19
8const int ENA = 25, IN1 = 26, IN2 = 27;
9const int ENB = 33, IN3 = 18, IN4 = 19;
10
11const int PWM_FREQ = 1000;                  // Hz
12const int PWM_RES = 8;                      // 8 bit: 0-255
13const int MIN_DUTY = 90;                    // motorun kıpırdadığı en düşük değer / lowest duty that moves the motor
14const unsigned long FAILSAFE_MS = 500;      // bu süre komut gelmezse dur / stop if no command for this long
15
16WebServer server(80);
17unsigned long lastCmd = 0;
18
19const char PAGE[] PROGMEM = R"rawliteral(
20<!DOCTYPE html><html><head><meta charset="utf-8">
21<meta name="viewport" content="width=device-width,initial-scale=1,user-scalable=no">
22<title>BlueGrays Car</title>
23<style>
24body{margin:0;background:#0f172a;color:#e2e8f0;font-family:sans-serif;text-align:center;touch-action:none;user-select:none}
25#pad{width:260px;height:260px;margin:24px auto;border-radius:50%;background:#1e293b;position:relative}
26#knob{width:90px;height:90px;border-radius:50%;background:#38bdf8;position:absolute;left:85px;top:85px}
27input{width:220px}
28</style></head><body>
29<h3>BlueGrays Wi-Fi Car</h3>
30<div id="pad"><div id="knob"></div></div>
31<p>Max <input id="sp" type="range" min="30" max="100" value="80"></p>
32<p id="st">0 / 0</p>
33<script>
34const pad=document.getElementById('pad'),knob=document.getElementById('knob'),R=85;
35let x=0,y=0,busy=false,drag=false;
36function put(dx,dy){knob.style.left=(85+dx)+'px';knob.style.top=(85+dy)+'px';}
37function move(e){const b=pad.getBoundingClientRect(),t=e.touches?e.touches[0]:e;
38 let dx=t.clientX-b.left-130,dy=t.clientY-b.top-130,d=Math.hypot(dx,dy);
39 if(d>R){dx*=R/d;dy*=R/d;}
40 put(dx,dy);x=Math.round(dx/R*100);y=Math.round(-dy/R*100);e.preventDefault();}
41function end(){drag=false;x=0;y=0;put(0,0);}
42pad.addEventListener('touchstart',move,{passive:false});
43pad.addEventListener('touchmove',move,{passive:false});
44pad.addEventListener('touchend',end);
45pad.addEventListener('mousedown',e=>{drag=true;move(e);});
46document.addEventListener('mousemove',e=>{if(drag)move(e);});
47document.addEventListener('mouseup',end);
48setInterval(()=>{if(busy)return;busy=true;
49 const s=document.getElementById('sp').value/100;
50 const l=Math.round(Math.max(-100,Math.min(100,y+x))*s);
51 const r=Math.round(Math.max(-100,Math.min(100,y-x))*s);
52 document.getElementById('st').textContent=l+' / '+r;
53 fetch('/d?l='+l+'&r='+r).catch(()=>{}).finally(()=>{busy=false;});},100);
54</script></body></html>
55)rawliteral";
56
57void setMotor(int pwmPin, int channel, int inA, int inB, int speed) {   // speed: -100 … 100
58  speed = constrain(speed, -100, 100);
59  digitalWrite(inA, speed > 0);
60  digitalWrite(inB, speed < 0);
61  int duty = (speed == 0) ? 0 : map(abs(speed), 1, 100, MIN_DUTY, 255);
62#if ESP_ARDUINO_VERSION_MAJOR >= 3
63  ledcWrite(pwmPin, duty);                  // 3.x: pin numarasıyla / by pin number
64#else
65  ledcWrite(channel, duty);                 // 2.x: kanal numarasıyla / by channel number
66#endif
67}
68
69void drive(int left, int right) {
70  setMotor(ENA, 0, IN1, IN2, left);
71  setMotor(ENB, 1, IN3, IN4, right);
72}
73
74void handleDrive() {
75  drive(server.arg("l").toInt(), server.arg("r").toInt());
76  lastCmd = millis();
77  server.send(200, "text/plain", "ok");
78}
79
80void setup() {
81  Serial.begin(115200);
82  int pins[] = {IN1, IN2, IN3, IN4};
83  for (int p : pins) pinMode(p, OUTPUT);
84#if ESP_ARDUINO_VERSION_MAJOR >= 3
85  ledcAttach(ENA, PWM_FREQ, PWM_RES);
86  ledcAttach(ENB, PWM_FREQ, PWM_RES);
87#else
88  ledcSetup(0, PWM_FREQ, PWM_RES); ledcAttachPin(ENA, 0);
89  ledcSetup(1, PWM_FREQ, PWM_RES); ledcAttachPin(ENB, 1);
90#endif
91  drive(0, 0);
92
93  WiFi.softAP(AP_SSID, AP_PASS);            // kendi Wi-Fi ağını kurar / creates its own Wi-Fi network
94  Serial.print("Adres / address: http://");
95  Serial.println(WiFi.softAPIP());          // 192.168.4.1
96
97  server.on("/", []() { server.send(200, "text/html", PAGE); });
98  server.on("/d", handleDrive);
99  server.begin();
100}
101
102void loop() {
103  server.handleClient();
104  if (millis() - lastCmd > FAILSAFE_MS) drive(0, 0);   // bağlantı koptu: dur / link lost: stop
105}
RigaCosa fa
WiFi.softAP(AP_SSID, AP_PASS)Trasforma l'ESP32 in un access point; la password deve avere almeno 8 caratteri, altrimenti la rete non si crea
PAGE[] = R"rawliteral(…)rawliteral"L'intera pagina del joystick; essendo una stringa grezza non devi fare l'escape delle virgolette
server.on("/d", handleDrive)Legge i valori l e r (-100 … 100) inviati dal browser e li passa ai motori
map(abs(speed), 1, 100, MIN_DUTY, 255)Fa partire anche la velocità più bassa dal minimo valore PWM che muove il motore
ledcAttach / ledcSetup + ledcAttachPinConfigura il PWM secondo la versione del core (3.x / 2.x)
millis() - lastCmd > FAILSAFE_MSFerma entrambi i motori se per 500 ms non arriva nessun comando

Come si trasforma il joystick in velocità dei motori?

Il joystick della pagina misura la posizione del dito rispetto al centro come x (sinistra-destra) e y (avanti-indietro), da -100 a 100. Un semplice miscelatore chiamato guida a carro armato dà la velocità di ogni ruota: sinistra = y + x, destra = y − x. Se il risultato supera ±100 viene limitato e poi moltiplicato per la percentuale di velocità massima del cursore. Sull'ESP32 questa percentuale diventa un valore PWM. Qui c'è un trucco piccolo ma importante: i motori TT ronzano ma non girano sotto un valore PWM di circa 80–90. Per questo il codice non distribuisce 1–100 su 0–255, ma su MIN_DUTY–255; per esempio il 50 % di velocità vale map(50, 1, 100, 90, 255) = 171. Se la tua macchina non si muove affatto a bassa velocità, alza MIN_DUTY di 10 in 10; se scatta appena sfiori il joystick, abbassalo.

Joystick (x, y)SinistraDestraCosa fa la macchina
(0, 100)100100Avanti a tutta velocità
(0, -100)-100-100Indietro a tutta velocità
(100, 0)100-100Gira sul posto verso destra
(-100, 0)-100100Gira sul posto verso sinistra
(50, 100)10050Avanza curvando dolcemente a destra
(0, 0)00Si ferma

Velocità in PWM: differenze tra core ESP32 2.x e 3.x

Sull'ESP32 il PWM è generato da un blocco hardware chiamato LEDC. Il codice usa 1 kHz e 8 bit di risoluzione, quindi il duty cycle va da 0 a 255. I transistor bipolari del L298N commutano lentamente: salire oltre qualche kHz non rende il motore più veloce, scalda solo di più il driver, e il leggero fischio a 1 kHz è normale. Con la versione 3.0 del core ESP32 per Arduino le funzioni PWM sono cambiate: la vecchia coppia ledcSetup(canale, frequenza, risoluzione) e ledcAttachPin(pin, canale) è stata sostituita da un'unica ledcAttach(pin, frequenza, risoluzione), e ledcWrite ora vuole il numero del pin invece del canale. Le righe #if ESP_ARDUINO_VERSION_MAJOR >= 3 del codice scelgono la funzione giusta qualunque versione tu abbia. Le basi del PWM sono in Cos'è il PWM.

Fermare la macchina se la connessione cade (failsafe)

Per un veicolo guidato via WiFi il momento più pericoloso è quando cade il segnale. Lo schermo del telefono si blocca, la scheda del browser va in secondo piano o la macchina esce dalla portata; se l'ESP32 continua a eseguire l'ultimo comando, la macchina va a tutta velocità contro il muro o giù per le scale. In questo codice la pagina invia un comando ogni 100 ms anche quando il joystick è fermo, e invia 0 / 0 quando sollevi il dito. L'ESP32 salva l'istante di ogni comando in lastCmd e a ogni giro di loop() controlla quanto è vecchio l'ultimo. Se per 500 ms non arriva nessuna richiesta nuova, cioè se si perdono cinque comandi di fila, i motori si fermano. Il flag busy nel browser evita inoltre che le richieste si accumulino quando la rete rallenta: la successiva parte solo dopo la risposta, così un comando vecchio non viene mai eseguito in ritardo.

Per provare il failsafe, con le ruote sollevate spingi il joystick in avanti e, tenendolo, spegni il WiFi del telefono; le ruote devono fermarsi entro mezzo secondo. Se su una rete affollata la macchina va a scatti, puoi portare FAILSAFE_MS a 800 ms.

Versione collegata al WiFi di casa (modalità STA)

Se usi la macchina in casa, puoi anche collegare l'ESP32 al tuo router. Così il telefono resta sul solito WiFi e non perde internet, ma la portata si limita alla copertura del router e l'indirizzo dell'ESP32 diventa l'IP assegnato dal router. Basta sostituire la riga WiFi.softAP in setup() con il frammento qui sotto. WiFi.setSleep(false) disattiva il risparmio energetico del modem dell'ESP32; senza questa riga i comandi possono arrivare a volte con 100–200 ms di ritardo. Se non si collega, leggi L'ESP32 non si connette al WiFi.

C++ (Arduino IDE)
1// setup() içinde WiFi.softAP(...) satırının yerine / in setup(), instead of the WiFi.softAP(...) line
2WiFi.mode(WIFI_STA);
3WiFi.begin("EvAgim", "sifre123");          // ev ağının adı ve şifresi / your home network name and password
4while (WiFi.status() != WL_CONNECTED) delay(300);
5WiFi.setSleep(false);                      // modem uykusunu kapat, gecikme düşer / disable modem sleep, lower latency
6Serial.println(WiFi.localIP());            // tarayıcıya bu adresi yaz / type this address in the browser

Portata, ritardo e impostazioni dello smartphone

  • Avviso "nessuna connessione a internet": il telefono segnala che la rete BlueGrays-Car non ha internet; scegli "Resta connesso". Su Android, se il passaggio automatico ai dati mobili è attivo, il telefono può uscire dalla rete; spegnere i dati mobili mentre guidi è la soluzione più semplice.
  • Portata: con l'antenna PCB della scheda aspettati 30–50 m all'aperto e 10–20 m in casa attraverso uno o due muri. Lascia l'antenna sul bordo della scheda, libera, lontana da parti metalliche e dalle batterie.
  • Canale: se intorno ci sono molte reti, scegli il più libero tra i canali 1, 6 e 11 con un terzo parametro, per esempio WiFi.softAP(AP_SSID, AP_PASS, 6).
  • Ritardo: in softAP le richieste HTTP impiegano di solito 20–50 ms, più che sufficienti per guidare. Per un controllo più fluido o per inviare dati dalla macchina al telefono (tensione delle batterie, distanza), passa a WebSocket; Web server e WebSocket con ESP32 lo spiega passo passo.
  • Un solo pilota: se due telefoni si collegano e usano il joystick insieme, i comandi si mescolano. Cambia la password per tenere la macchina solo per te.

Errori comuni e soluzioni

SintomoCausa probabileSoluzione
L'ESP32 si riavvia quando partono i motoriLa tensione delle batterie cala per un attimo (brownout)Usa 18650 di qualità; aggiungi 470 µF all'ingresso del L298N e 100 nF ai morsetti dei motori
Errore di compilazione "'ledcSetup' was not declared"Core ESP32 3.x, il codice usa le vecchie funzioni PWMUsa il codice di questa guida con il controllo #if ESP_ARDUINO_VERSION_MAJOR
La macchina non si muove a bassa velocitàIl valore PWM è sotto la soglia di avvio del motoreAlza MIN_DUTY a 100–120
Una ruota gira al contrarioI fili del motore sono invertitiInverti i due fili di quel motore sul L298N
La macchina va sempre a tutta velocitàI jumper ENA / ENB sono ancora inseritiTogli i jumper e collega quei pin ai GPIO 25 e 33
192.168.4.1 non si apreIl telefono è uscito dalla rete o usa i dati mobiliSpegni i dati, ricollegati e scrivi l'indirizzo con http://
La macchina va a scattiCanale WiFi affollato o segnale deboleCambia canale, lascia libera l'antenna e aumenta un po' FAILSAFE_MS
Il L298N scalda moltoI motori sono sempre sotto sforzo o una ruota è bloccataControlla che le ruote girino libere; valuta un driver più efficiente (TB6612FNG)

Idee per migliorare la tua macchina

  • Freno anticollisione: monta un HC-SR04 davanti e ignora i comandi di avanzare quando un ostacolo è a meno di 20 cm. Come usarlo lo trovi in Sensore a ultrasuoni HC-SR04.
  • Modalità autonoma: aggiungi un pulsante alla pagina; premendolo la macchina gira da sola come un robot che evita gli ostacoli.
  • Indicatore batteria: misura la tensione del pacco su un pin analogico con un partitore di tensione a due resistenze e mostrala nella pagina del joystick.
  • Aggiornamenti senza fili: con l'OTA dell'ESP32 carichi il nuovo codice senza collegare ogni volta il cavo USB.
  • Radiocomando fisico: guida senza telefono con un secondo ESP32 e un modulo joystick tramite ESP-NOW.
  • Luci: aggiungi LED WS2812B davanti e dietro; in retromarcia le luci posteriori diventano rosse.

La macchina WiFi ESP32 è un ottimo primo progetto che insegna in un colpo solo web server, PWM, ponte H e logica di controllo sicura. Più avanti potrai riutilizzare la stessa pagina joystick per un braccio robotico o una macchina con telecamera. Se vuoi capire come funziona il driver dall'interno, leggi Controllo motore DC con L298N; per la versione Arduino con Bluetooth vedi Costruire una macchinina robot con Arduino. Nell'app BlueGrays trovi anche la macchina Bluetooth con L298N, il robot che evita gli ostacoli e i progetti di web server con ESP32, con schemi di collegamento e codice passo passo.

Domande frequenti

Una macchina WiFi con ESP32 ha bisogno di internet?

No. In modalità softAP l'ESP32 crea la propria rete wireless e lo smartphone si collega direttamente; non servono router né internet. La pagina del joystick è salvata nella memoria dell'ESP32, quindi si apre completamente offline.

Che portata ha una macchina WiFi con ESP32?

Con l'antenna PCB della scheda di solito 30–50 m all'aperto e 10–20 m in casa, a seconda dei muri. I moduli con connettore per antenna esterna, come l'ESP32-WROOM-32U, aumentano parecchio la portata.

Il L298N funziona con i 3,3 V dell'ESP32?

Sì. Gli ingressi del L298N considerano HIGH qualsiasi tensione sopra 2,3 V, quindi i pin dell'ESP32 si collegano direttamente a IN1–IN4 ed ENA–ENB. L'importante è unire le masse delle due schede.

Serve un'app sullo smartphone per guidare la macchina?

No. Il joystick è una pagina web servita dall'ESP32 e funziona in qualsiasi browser, come Chrome, Safari o Firefox. Per questo si usa allo stesso modo su Android, iPhone, tablet e computer.

Perché l'ESP32 si riavvia quando partono i motori?

All'avvio i motori assorbono per un attimo diversi ampere e la tensione di batterie deboli crolla per un istante; l'ESP32 lo rileva come brownout e si riavvia. Celle 18650 di qualità, 470 µF all'ingresso del L298N e 100 nF ai morsetti dei motori risolvono quasi sempre il problema.

Meglio Bluetooth o WiFi per una macchinina robot?

Il WiFi non richiede app, funziona anche con iPhone e ha più portata. Il Bluetooth classico (HC-05 o il BluetoothSerial dell'ESP32) offre un collegamento leggero, ma dipende da Android e da un'app terminale. Per una macchina ESP32 guidata dallo smartphone, il WiFi è di solito la scelta più pratica.

Vedi tutti i progetti
Auto controllata via Bluetooth con L298N
AR-80Avanzato
Premium

Auto controllata via Bluetooth con L298N

Trasforma il telefono in un telecomando e guida la tua auto robot. L'Arduino riceve tramite un modulo Bluetooth i comandi di un'app di controllo remoto sul telefono e fa girare le ruote con un driver…

5.0(39)
66
Robot che evita gli ostacoli
AR-81Avanzato
Premium

Robot che evita gli ostacoli

Che ne dite di costruire un veicolo intelligente che trova la propria strada? L'Obstacle Avoiding Robot scruta costantemente l'ambiente circostante grazie al sensore a ultrasuoni posto davanti a lui.

5.0(38)
49
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
Dissolvenza LED ESP32 con PWM
ES-8Principiante

Dissolvenza LED ESP32 con PWM

Modificare la luminosità del LED in modo fluido da 0 a max, da max a 0. Controlliamo il PWM con analogWrite() come in Arduino - la stessa sintassi con ESP32 Arduino Core 3.0+ funziona senza problemi. La definizione del pin + pinMode + analogWrite è sufficiente.

4.8(36)
55
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
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