Carrinho Wi-Fi com ESP32: dirija com um joystick no celular (L298N, SoftAP)
Monte um carrinho Wi-Fi com ESP32 que você dirige pelo navegador do celular: rede softAP própria, joystick web, velocidade PWM no L298N, tabela de custos e parada de segurança.
Um carrinho Wi-Fi com ESP32 é um carrinho robô que você dirige com uma página de joystick no navegador do celular, sem instalar nenhum app. O ESP32 cria a própria rede Wi-Fi (softAP), o celular entra nela e, quando você digita 192.168.4.1 no navegador, aparece um joystick. Conforme você desliza o dedo, o ESP32 acelera, desacelera e vira dois motores com redução usando PWM por um driver de motor L298N. Não precisa de roteador, internet nem pareamento Bluetooth, e funciona igual no Android e no iPhone.
Neste guia montamos o carrinho do começo ao fim: a lista de peças e o custo aproximado, a tabela de ligação ESP32–L298N, um primeiro sketch que testa os motores sem Wi-Fi, o sketch principal que embute a página do joystick no ESP32 e como uma posição do joystick vira a velocidade de duas rodas. Também adicionamos um recurso de segurança que a maioria dos exemplos esquece: quando a conexão cai, o carrinho para sozinho em meio segundo. O código compila nas versões 2.x e 3.x do core ESP32 Arduino.




Como funciona um carrinho Wi-Fi com ESP32?
O sistema tem quatro partes. O ESP32 é ao mesmo tempo o cérebro e um pequeno servidor web: ele envia a página do joystick ao celular e depois aplica os comandos "motor esquerdo nesta velocidade, motor direito naquela" que chegam dez vezes por segundo. O L298N é uma ponte H dupla; ele transforma os sinais fracos de 3,3 V do ESP32 na corrente de que os motores precisam. Dois motores TT amarelos giram as rodas; não há direção, o carrinho vira pela diferença de velocidade entre as duas rodas (tração diferencial). Duas células 18650 alimentam os motores e, pelo regulador de 5 V da placa do L298N, o ESP32. No modo softAP o ESP32 age como um roteador e sempre se dá o endereço 192.168.4.1, então você dirige o carrinho no quintal, na escola ou em qualquer lugar sem roteador.
| Wi-Fi softAP (este guia) | Wi-Fi de casa (STA) | Bluetooth (HC-05 ou BT clássico) | |
|---|---|---|---|
| Precisa de roteador? | No | Sim | No |
| App no celular | Nenhum, o navegador basta | Nenhum, o navegador basta | Precisa de um app de terminal Bluetooth |
| Suporte a iPhone | Sim | Sim | Não (o iOS não suporta serial Bluetooth clássico) |
| Alcance ao ar livre | Cerca de 30–50 m | Até onde o roteador alcança | Cerca de 10–20 m |
| Atraso dos comandos | Cerca de 20–50 ms | 20–100 ms conforme o tráfego da rede | Cerca de 20–40 ms |
Lista de peças e custo
| Peça | Qtd. | Preço aprox. (USD) | Observação |
|---|---|---|---|
| ESP32 DevKit V1 (30 ou 38 pinos) | 1 | 4–7 | Os GPIOs que usamos existem nas duas placas |
| Módulo driver de motor L298N | 1 | 2–4 | 2 A por canal; aciona dois motores de forma independente |
| Kit de chassi de carrinho robô 2WD | 1 | 8–15 | Normalmente traz 2 motores TT, 2 rodas, uma roda boba e uma chave |
| Célula Li-ion 18650 | 2 | 6–12 | Células de marca com descarga de pelo menos 5 A |
| Suporte para 2 células 18650 (em série) | 1 | 1–2 | Um modelo com chave facilita a ligação |
| Carregador de 18650 | 1 | 3–10 | Um carregador que carrega cada célula separadamente |
| Jumpers (fêmea-fêmea, macho-fêmea) | 10+ | 1–3 | Entre o ESP32 e o L298N |
| Capacitores de 470 µF / 16 V e 100 nF | 1 + 2 | Menos de 1 | Contra quedas de tensão e ruído dos motores |
| Total | 25–50 | 15–25 se você já tem células e carregador |
Os preços são valores típicos de lojas online de eletrônica e variam conforme o país, o frete e o câmbio. Os itens mais caros são o kit de chassi e as células. Não economize nas células: as muito baratas marcadas como "9900 mAh" costumam ser falsas, a tensão delas despenca quando os motores arrancam e o ESP32 reinicia. Se você já tem um kit de carrinho robô para Arduino, só precisa comprar um ESP32; o chassi, os motores e o L298N continuam os mesmos. Explicamos em detalhes como escolher células em bateria Li-ion 18650.
Ligação: ESP32, L298N e motores
| L298N | ESP32 | Descrição |
|---|---|---|
| ENA | GPIO 25 | Velocidade do motor esquerdo (PWM); retire o jumper ENA |
| IN1 | GPIO 26 | Direção do motor esquerdo |
| IN2 | GPIO 27 | Direção do motor esquerdo |
| ENB | GPIO 33 | Velocidade do motor direito (PWM); retire o jumper ENB |
| IN3 | GPIO 18 | Direção do motor direito |
| IN4 | GPIO 19 | Direção do motor direito |
| +12V (VS) | – | Positivo do pack 2×18650 (depois da chave) |
| GND | GND | Negativo da bateria e GND do ESP32; terra comum é obrigatório |
| +5V | VIN (5V) | Alimenta o ESP32 pelo regulador do L298N enquanto o jumper 5V-EN estiver no lugar |
| OUT1 / OUT2 | – | Motor esquerdo |
| OUT3 / OUT4 | – | Motor direito |
As entradas lógicas do L298N tratam qualquer coisa acima de 2,3 V como HIGH, então as saídas de 3,3 V do ESP32 podem ser ligadas direto, sem conversor de nível. Um pack totalmente carregado dá 8,4 V; o L298N perde 1,5–3 V disso internamente e os motores recebem 5–6 V, a faixa ideal para motores TT. O regulador 78M05 da placa gera 5 V a partir do mesmo pack e alimenta o ESP32 pelo pino VIN. A escolha dos pinos também não é aleatória: os GPIO 0, 2, 12 e 15 são pinos de strapping que definem o modo de inicialização, os 6–11 são reservados à memória flash e os 34–39 são só de entrada. Os 25, 26, 27, 33, 18 e 19 são saídas seguras que existem nas placas de 30 e de 38 pinos. Explicamos por que o terra precisa ser comum em GND e terra comum.
Montagem passo a passo
- No Gerenciador de Placas da Arduino IDE, instale esp32 by Espressif Systems e escolha ESP32 Dev Module como placa.
- Parafuse os motores no chassi; ligue os fios dos motores aos bornes OUT1-OUT2 (esquerdo) e OUT3-OUT4 (direito) do L298N.
- Retire os jumpers ENA e ENB do L298N; deixe o jumper 5V-EN no lugar.
- Ligue os seis fios de sinal da tabela e o GND comum com jumpers fêmea-fêmea.
- Coloque o carrinho sobre uma caixa para as rodas ficarem no ar; carregue o sketch de teste dos motores e confira as direções.
- Carregue o sketch principal, abra o Monitor Serial a 115200 baud e anote o endereço que ele mostra.
- Nas configurações de Wi-Fi do celular, entre na rede BlueGrays-Car com a senha 12345678 e digite 192.168.4.1 no navegador.
- Empurre o joystick de leve; se as rodas girarem para o lado certo, coloque o carrinho no chão e dirija.
Teste os motores primeiro
Antes de passar para o código Wi-Fi, confira a ligação com este sketch curto. Ele mantém ENA e ENB em HIGH, então os motores giram em velocidade máxima: um segundo para a frente, depois para trás, depois girando no lugar para a esquerda e para a direita. Se uma roda girar para trás no comando de ir para a frente, não mexa no código; troque os dois fios daquele motor no L298N. Se nenhum motor girar, confira a chave da bateria, o GND comum e os fios de ENA-ENB.
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 principal: um carrinho que cria a própria rede Wi-Fi (softAP)
No sketch principal a página do joystick fica embutida no ESP32 como um único bloco de texto HTML, CSS e JavaScript. Você não precisa enviar arquivos nem instalar bibliotecas; só são usadas a WiFi e a WebServer, que vêm com o pacote do ESP32. Com a página aberta, o navegador envia a cada 100 ms uma requisição minúscula como /d?l=60&r=-60; o ESP32 lê os dois números, aplica-os aos motores e anota a hora do comando.
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}| Linha | O que faz |
|---|---|
| WiFi.softAP(AP_SSID, AP_PASS) | Transforma o ESP32 em ponto de acesso; a senha precisa ter pelo menos 8 caracteres, senão a rede não é criada |
| PAGE[] = R"rawliteral(…)rawliteral" | A página inteira do joystick; como string raw, você não precisa escapar as aspas |
| server.on("/d", handleDrive) | Lê os valores l e r (-100 … 100) vindos do navegador e os aplica aos motores |
| map(abs(speed), 1, 100, MIN_DUTY, 255) | Começa até a menor velocidade no menor valor de PWM que move o motor |
| ledcAttach / ledcSetup + ledcAttachPin | Configura o PWM de acordo com a versão do core (3.x / 2.x) |
| millis() - lastCmd > FAILSAFE_MS | Para os dois motores se nenhum comando chegar por 500 ms |
Como o joystick vira velocidade dos motores?
O joystick da página mede a posição do seu dedo em relação ao centro como x (esquerda-direita) e y (frente-trás), de -100 a 100. Uma mistura simples chamada tank drive dá a velocidade de cada roda: esquerda = y + x, direita = y − x. Se o resultado passar de ±100 ele é cortado e depois multiplicado pela porcentagem de velocidade máxima do controle deslizante. No lado do ESP32 essa porcentagem vira um valor de PWM. Aqui há um truque pequeno, mas importante: os motores TT zumbem e não giram abaixo de um PWM de cerca de 80–90. Por isso o código mapeia 1–100 não para 0–255, e sim para MIN_DUTY–255; 50% de velocidade, por exemplo, é map(50, 1, 100, 90, 255) = 171. Se o carrinho não se mexe em baixa velocidade, aumente o MIN_DUTY de 10 em 10; se ele dá um tranco quando você mal encosta no joystick, diminua.
| Joystick (x, y) | Esquerda | Direita | O que o carrinho faz |
|---|---|---|---|
| (0, 100) | 100 | 100 | Para a frente em velocidade máxima |
| (0, -100) | -100 | -100 | Para trás em velocidade máxima |
| (100, 0) | 100 | -100 | Gira no lugar para a direita |
| (-100, 0) | -100 | 100 | Gira no lugar para a esquerda |
| (50, 100) | 100 | 50 | Faz uma curva suave para a direita andando para a frente |
| (0, 0) | 0 | 0 | Para |
Controle de velocidade PWM: core ESP32 2.x vs 3.x
No ESP32, o PWM é gerado por uma unidade de hardware chamada LEDC. O código usa frequência de 1 kHz e resolução de 8 bits, então o ciclo de trabalho vai de 0 a 255. Os transistores bipolares dentro do L298N chaveiam devagar, então passar de alguns kHz não deixa o motor mais rápido, só esquenta mais o driver; o leve chiado em 1 kHz é normal. A versão 3.0 do core ESP32 Arduino mudou as funções de PWM: o antigo par ledcSetup(canal, frequência, resolução) e ledcAttachPin(pino, canal) foi substituído por um único ledcAttach(pino, frequência, resolução), e o ledcWrite agora recebe o número do pino em vez do canal. As linhas #if ESP_ARDUINO_VERSION_MAJOR >= 3 do código escolhem a função certa seja qual for a sua versão. O básico de PWM está em O que é PWM.
Parando o carrinho quando a conexão cai (failsafe)
Para um veículo dirigido por Wi-Fi, o momento mais perigoso é quando o sinal cai. A tela do celular bloqueia, a aba do navegador vai para segundo plano ou o carrinho sai do alcance; se o ESP32 continuar aplicando o último comando, o carrinho vai a toda velocidade contra uma parede ou escada abaixo. Neste código a página envia um comando a cada 100 ms mesmo com o joystick parado, e envia 0 / 0 quando você tira o dedo. O ESP32 guarda a hora de cada comando em lastCmd, e cada volta do loop() verifica a idade do último comando. Se nenhuma requisição nova chegar por 500 ms, ou seja, se cinco comandos seguidos se perderem, os motores param. A flag busy no navegador também impede que as requisições se acumulem quando a rede fica lenta; uma nova não é enviada antes da resposta chegar, então um comando velho não pode ser aplicado atrasado.
Versão que entra na rede de casa (modo STA)
Se você usa o carrinho em casa, também pode ligar o ESP32 ao seu roteador. Assim o celular continua no Wi-Fi de sempre e mantém a internet, mas o alcance fica limitado à cobertura do roteador e o endereço do ESP32 é o IP que o roteador lhe dá. Basta trocar a linha WiFi.softAP no setup() pelo trecho abaixo. O WiFi.setSleep(false) desliga o modem sleep do ESP32; sem ele, os comandos podem atrasar de vez em quando 100–200 ms. Se não conectar, veja ESP32 não conecta ao Wi-Fi.
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 browserAlcance, atraso e ajustes do celular
- Aviso de "sem internet": o celular avisa que a rede BlueGrays-Car não tem internet; escolha "Manter conectado". No Android, se a troca automática para dados móveis estiver ativada, o celular pode sair da rede; desligar os dados móveis enquanto dirige é a solução mais fácil.
- Alcance: com a antena PCB da placa, espere 30–50 m ao ar livre e 10–20 m em ambientes internos atravessando uma ou duas paredes. Deixe a antena na borda da placa, livre, longe de peças metálicas e das células.
- Canal: se houver muitas redes por perto, escolha o mais vazio entre os canais 1, 6 ou 11 com um terceiro parâmetro, como WiFi.softAP(AP_SSID, AP_PASS, 6).
- Atraso: as requisições HTTP no softAP costumam levar 20–50 ms, mais que suficiente para dirigir um carrinho. Para um controle mais suave, ou para enviar dados do carrinho ao celular (tensão da bateria, distância), passe para WebSocket; servidor web e WebSocket no ESP32 explica passo a passo.
- Um motorista só: se dois celulares entrarem na rede e usarem o joystick ao mesmo tempo, os comandos se misturam. Troque a senha para deixar o carrinho só para você.
Problemas comuns e soluções
| Sintoma | Causa provável | Solução |
|---|---|---|
| O ESP32 reinicia quando os motores arrancam | A tensão da bateria cai por um instante (brownout) | Use células 18650 de qualidade; coloque 470 µF na entrada de alimentação do L298N e 100 nF nos terminais dos motores |
| Erro de compilação "'ledcSetup' was not declared" | Core ESP32 3.x, o código usa as funções de PWM antigas | Use o código deste guia com a chave #if ESP_ARDUINO_VERSION_MAJOR |
| O carrinho não se mexe em baixa velocidade | O valor de PWM está abaixo do limite de partida do motor | Aumente o MIN_DUTY para 100–120 |
| Uma roda gira para trás | Os fios do motor estão invertidos | Troque os dois fios daquele motor no L298N |
| O carrinho sempre anda em velocidade máxima | Os jumpers ENA / ENB ainda estão no lugar | Retire os jumpers e ligue os pinos aos GPIO 25 e 33 |
| 192.168.4.1 não abre | O celular saiu da rede ou está usando dados móveis | Desligue os dados móveis, entre de novo na rede e digite o endereço com http:// |
| O carrinho engasga | Canal Wi-Fi congestionado ou sinal fraco | Mude o canal, deixe a antena livre, aumente um pouco o FAILSAFE_MS |
| O L298N esquenta muito | Os motores estão sempre forçados ou uma roda está travada | Confira se as rodas giram sem prender; considere um driver mais eficiente (TB6612FNG) |
Ideias para turbinar o seu carrinho
- Freio anticolisão: coloque um HC-SR04 na frente e ignore os comandos para a frente quando houver um obstáculo a menos de 20 cm. Veja como usá-lo em sensor de distância HC-SR04.
- Modo autônomo: adicione um botão na página; quando apertado, o carrinho anda sozinho como um robô que desvia de obstáculos.
- Indicador de bateria: meça a tensão do pack em um pino analógico com um divisor de tensão de dois resistores e mostre-a na página do joystick.
- Atualizações sem fio: com OTA no ESP32 você carrega código novo sem ligar o cabo USB toda vez.
- Controle físico: dirija sem celular usando um segundo ESP32 e um módulo de joystick via ESP-NOW.
- Luzes: adicione LEDs WS2812B na frente e atrás; faça as luzes traseiras acenderem em vermelho na ré.
Um carrinho Wi-Fi com ESP32 é um ótimo primeiro projeto que ensina de uma vez servidor web, PWM, driver de motor e lógica de controle segura. Depois você pode reaproveitar a mesma página de joystick em um braço robótico ou em um carrinho com câmera. Se tiver curiosidade sobre como o driver de motor funciona por dentro, leia controle de motor DC com L298N, e para a versão Bluetooth com Arduino veja como montar um carrinho robô com Arduino. No app BlueGrays você também encontra os projetos Carrinho Bluetooth com L298N, Robô que Desvia de Obstáculos e Servidor Web com ESP32, com esquemas de ligação e código passo a passo.
Perguntas frequentes
Um carrinho Wi-Fi com ESP32 precisa de internet?
Não. No modo softAP o ESP32 cria a própria rede sem fio e o celular se conecta direto a ela; não precisa de roteador nem de conexão com a internet. A página do joystick fica guardada na memória do ESP32, então abre totalmente offline.
Qual é o alcance de um carrinho Wi-Fi com ESP32?
Com a antena PCB da placa, costuma ser de 30–50 m ao ar livre e 10–20 m em ambientes internos, dependendo das paredes. Módulos que aceitam antena externa, como o ESP32-WROOM-32U, aumentam o alcance de forma perceptível.
O L298N funciona com a lógica de 3,3 V do ESP32?
Sim. As entradas do L298N tratam qualquer coisa acima de 2,3 V como HIGH, então os pinos do ESP32 podem ser ligados direto em IN1–IN4 e ENA–ENB. O importante é que o GND das duas placas esteja ligado entre si.
Preciso de um app no celular para dirigir o carrinho?
Não. O joystick é uma página web servida pelo ESP32 e funciona em qualquer navegador, como Chrome, Safari ou Firefox. Por isso funciona igual em celulares Android, iPhones, tablets e computadores.
Por que o meu ESP32 reinicia quando os motores arrancam?
Os motores puxam vários ampères por um instante ao arrancar, e a tensão de células fracas despenca por um momento; o ESP32 entende isso como brownout e reinicia. Células 18650 de qualidade, 470 µF na entrada do L298N e 100 nF nos terminais dos motores resolvem a maior parte.
Bluetooth ou Wi-Fi: qual é melhor para um carrinho robô?
O Wi-Fi não precisa de app, funciona com iPhone também e tem alcance maior. O Bluetooth clássico (HC-05 ou o BluetoothSerial do ESP32) dá uma conexão leve, mas depende do Android e de um app de terminal. Para um carrinho com ESP32 dirigido pelo celular, o Wi-Fi costuma ser a escolha mais prática.
Projetos para montar depois desta leitura
Ver todos os projetos
Carrinho controlado por Bluetooth com L298N
Transforme seu celular em um controle remoto e dirija seu próprio carrinho robô.

Robô que desvia de obstáculos
Que tal construir um veículo inteligente que encontra seu próprio caminho? O robô que desvia de obstáculos monitora o ambiente constantemente com o sensor ultrassônico na parte da frente.

Servidor web assíncrono com ESP32 (IP no LCD)
Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

Contador WebSocket com ESP32 (2 botões + LCD + web em tempo real)
Neste projeto, dois botões conectados ao ESP32 (GPIO 5 aumenta, GPIO 4 diminui) alteram um contador. O valor é atualizado instantaneamente no LCD I2C 16x2 e, com o suporte a WebSocket do ESPAsyncWebServer, em todos os navegadores conectados, sem recarregar a página. Em vez de consultas periódicas por HTTP, usamos uma única conexão persistente, e o ESP32 envia o novo valor a todos com ws.textAll().

Conexão Wi-Fi STA com ESP32 e display LCD
Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.

Variação gradual do brilho do LED com PWM no ESP32
Varie suavemente o brilho do LED de 0 ao máximo e do máximo a 0. Controlamos o PWM com analogWrite(), como no Arduino. A mesma sintaxe funciona sem problemas com ESP32 Arduino Core 3.0+. Basta definir o pino e usar pinMode e analogWrite.

ESP32 mDNS: acesso via bluegrays-esp.local (com display LCD)
Neste projeto, adicionamos o serviço mDNS (Multicast DNS) ao ESP32 para acessar o dispositivo por um nome de host fácil de ler, como bluegrays-esp.local, em vez de um endereço IP. Mesmo que o IP atribuído pelo DHCP mude, você pode acessar o dispositivo pelo mesmo nome. Também executamos um pequeno servidor web no dispositivo para enviar comandos de controle do LED pelo navegador no endereço http://bluegrays-esp.local/.

Atualização OTA no ESP32 — firmware sem fio (com display LCD)
Neste projeto, você aprende a carregar um novo firmware no ESP32 por Wi-Fi, sem cabo USB. Com a biblioteca ArduinoOTA, o ESP32 fica visível na rede e aparece automaticamente como bluegrays-ota na aba "Porta de rede" do Arduino IDE. A primeira carga é feita por USB, e todas as atualizações seguintes são sem fio — um recurso essencial para dispositivos em campo. O LCD I2C mostra o estado do Wi-Fi, o IP, o nome do host, a porcentagem de envio por OTA e as mensagens de erro em turco e inglês.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

