Guias · 10 min de leitura

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.

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

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?NoSimNo
App no celularNenhum, o navegador bastaNenhum, o navegador bastaPrecisa de um app de terminal Bluetooth
Suporte a iPhoneSimSimNão (o iOS não suporta serial Bluetooth clássico)
Alcance ao ar livreCerca de 30–50 mAté onde o roteador alcançaCerca de 10–20 m
Atraso dos comandosCerca de 20–50 ms20–100 ms conforme o tráfego da redeCerca de 20–40 ms

Lista de peças e custo

PeçaQtd.Preço aprox. (USD)Observação
ESP32 DevKit V1 (30 ou 38 pinos)14–7Os GPIOs que usamos existem nas duas placas
Módulo driver de motor L298N12–42 A por canal; aciona dois motores de forma independente
Kit de chassi de carrinho robô 2WD18–15Normalmente traz 2 motores TT, 2 rodas, uma roda boba e uma chave
Célula Li-ion 1865026–12Células de marca com descarga de pelo menos 5 A
Suporte para 2 células 18650 (em série)11–2Um modelo com chave facilita a ligação
Carregador de 1865013–10Um carregador que carrega cada célula separadamente
Jumpers (fêmea-fêmea, macho-fêmea)10+1–3Entre o ESP32 e o L298N
Capacitores de 470 µF / 16 V e 100 nF1 + 2Menos de 1Contra quedas de tensão e ruído dos motores
Total25–5015–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

L298NESP32Descrição
ENAGPIO 25Velocidade do motor esquerdo (PWM); retire o jumper ENA
IN1GPIO 26Direção do motor esquerdo
IN2GPIO 27Direção do motor esquerdo
ENBGPIO 33Velocidade do motor direito (PWM); retire o jumper ENB
IN3GPIO 18Direção do motor direito
IN4GPIO 19Direção do motor direito
+12V (VS)–Positivo do pack 2×18650 (depois da chave)
GNDGNDNegativo da bateria e GND do ESP32; terra comum é obrigatório
+5VVIN (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.

Enquanto o ESP32 estiver ligado no USB, desconecte o fio +5V do L298N do VIN ou desligue a bateria; ligar duas fontes de 5 V ao mesmo tempo pode empurrar corrente de volta para a porta USB do computador em algumas placas. Nunca ligue o positivo da bateria direto no ESP32: 8,4 V no pino 3V3 destroem a placa na hora, e 8,4 V no VIN superaquecem o regulador AMS1117 da placa.

Montagem passo a passo

  1. No Gerenciador de Placas da Arduino IDE, instale esp32 by Espressif Systems e escolha ESP32 Dev Module como placa.
  2. Parafuse os motores no chassi; ligue os fios dos motores aos bornes OUT1-OUT2 (esquerdo) e OUT3-OUT4 (direito) do L298N.
  3. Retire os jumpers ENA e ENB do L298N; deixe o jumper 5V-EN no lugar.
  4. Ligue os seis fios de sinal da tabela e o GND comum com jumpers fêmea-fêmea.
  5. Coloque o carrinho sobre uma caixa para as rodas ficarem no ar; carregue o sketch de teste dos motores e confira as direções.
  6. Carregue o sketch principal, abra o Monitor Serial a 115200 baud e anote o endereço que ele mostra.
  7. 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.
  8. 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.

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 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.

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}
LinhaO 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 + ledcAttachPinConfigura o PWM de acordo com a versão do core (3.x / 2.x)
millis() - lastCmd > FAILSAFE_MSPara 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)EsquerdaDireitaO que o carrinho faz
(0, 100)100100Para a frente em velocidade máxima
(0, -100)-100-100Para trás em velocidade máxima
(100, 0)100-100Gira no lugar para a direita
(-100, 0)-100100Gira no lugar para a esquerda
(50, 100)10050Faz uma curva suave para a direita andando para a frente
(0, 0)00Para

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.

Para testar o failsafe, empurre o joystick para a frente com as rodas no ar e desligue o Wi-Fi do celular segurando-o; as rodas devem parar em meio segundo. Se o carrinho engasgar em uma rede congestionada, você pode aumentar o FAILSAFE_MS para 800 ms.

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.

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

Alcance, 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

SintomaCausa provávelSolução
O ESP32 reinicia quando os motores arrancamA 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 antigasUse o código deste guia com a chave #if ESP_ARDUINO_VERSION_MAJOR
O carrinho não se mexe em baixa velocidadeO valor de PWM está abaixo do limite de partida do motorAumente o MIN_DUTY para 100–120
Uma roda gira para trásOs fios do motor estão invertidosTroque os dois fios daquele motor no L298N
O carrinho sempre anda em velocidade máximaOs jumpers ENA / ENB ainda estão no lugarRetire os jumpers e ligue os pinos aos GPIO 25 e 33
192.168.4.1 não abreO celular saiu da rede ou está usando dados móveisDesligue os dados móveis, entre de novo na rede e digite o endereço com http://
O carrinho engasgaCanal Wi-Fi congestionado ou sinal fracoMude o canal, deixe a antena livre, aumente um pouco o FAILSAFE_MS
O L298N esquenta muitoOs motores estão sempre forçados ou uma roda está travadaConfira 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.

Ver todos os projetos
Carrinho controlado por Bluetooth com L298N
AR-80Avançado
Premium

Carrinho controlado por Bluetooth com L298N

Transforme seu celular em um controle remoto e dirija seu próprio carrinho robô.

5.0(39)
66
Robô que desvia de obstáculos
AR-81Avançado
Premium

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.

5.0(38)
49
Servidor web assíncrono com ESP32 (IP no LCD)
ES-27Avançado

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.

4.8(16)
26
Contador WebSocket com ESP32 (2 botões + LCD + web em tempo real)
ES-28Avançado
Premium

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().

4.5(14)
23
Conexão Wi-Fi STA com ESP32 e display LCD
ES-25Avançado

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.

4.4(21)
38
Variação gradual do brilho do LED com PWM no ESP32
ES-8Iniciante

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.

4.8(36)
55
ESP32 mDNS: acesso via bluegrays-esp.local (com display LCD)
ES-29Avançado
Premium

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/.

4.8(14)
23
Atualização OTA no ESP32 — firmware sem fio (com display LCD)
ES-30Avançado
Premium

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.

4.6(14)
22