Guias · 9 min de leitura

Servidor web com servo no ESP32: controle um servo com um slider no celular

Monte um servidor web com servo no ESP32: biblioteca ESP32Servo, slider na web que envia o ângulo com fetch, escolha do pino, alimentação e GND comum, tremidas e pan-tilt.

O jeito mais divertido de montar um servidor web com servo no ESP32 é girar o servo em tempo real com um slider no celular: você desliza o dedo e o servo acompanha, sem instalar nenhum app no celular. Neste guia, transformamos o ESP32 em servidor web, enviamos o valor do slider da página no navegador para o ESP32 com o comando fetch do JavaScript e levamos o servo até esse ângulo com a biblioteca ESP32Servo.

Além do código, tratamos em detalhes do lado do hardware, porque a maioria dos projetos de servo com Wi-Fi falha por causa da alimentação, não do software: o servo treme, o ESP32 reinicia ou a conexão cai. Passo a passo, você vai ver qual pino escolher, de onde alimentar o servo, por que o GND comum é essencial, como acabar com as tremidas e, por fim, como montar um suporte pan-tilt com dois servos.

Micro servo motor SG90
Micro servo SG90: gira de 0 a 180 graus, funciona com 4,8–6 V e é posicionado pela largura de pulso de um sinal PWM de 50 Hz.

Como funciona: do slider ao servo

  1. O navegador do celular abre o endereço IP do ESP32, e o ESP32 devolve uma pequena página HTML com um slider.
  2. Quando você mexe no slider, o JavaScript da página envia o ângulo com fetch para um endereço como /set?angle=120; a página não recarrega.
  3. O servidor web no ESP32 recebe a requisição, lê o ângulo e o limita à faixa de 0–180.
  4. A biblioteca ESP32Servo converte o ângulo em largura de pulso: cerca de 500 µs para 0 grau e 2400 µs para 180 graus, enviados 50 vezes por segundo.
  5. A placa de controle dentro do servo lê o pulso, leva o motor até aquele ângulo e o mantém ali.

Explicamos como um servo funciona e como a largura de pulso se relaciona com o ângulo em O que é um servo motor? O que importa aqui é isto: a biblioteca Servo padrão do Arduino não funciona no ESP32, porque o ESP32 gera PWM com outro hardware (LEDC). Por isso usamos a biblioteca ESP32Servo; ela oferece os mesmos comandos attach() e write() e funciona com os cores 2.x e 3.x do ESP32.

O que você precisa

  • Uma placa de desenvolvimento ESP32 (DevKit, NodeMCU-32S ou parecida)
  • Um servo SG90 ou MG90S (dois deles e um suporte pan-tilt para a versão pan-tilt)
  • Uma fonte externa de 5 V: um adaptador de pelo menos 2 A ou um suporte para 4 pilhas AA
  • Um capacitor eletrolítico de 470–1000 µF (de 10 V ou mais)
  • Uma protoboard e jumpers
  • O pacote de placas ESP32 instalado na Arduino IDE e a biblioteca ESP32Servo instalada pelo Gerenciador de Bibliotecas

Escolhendo o pino: qual GPIO o servo deve usar?

Quase todos os pinos de saída do ESP32 geram PWM, mas nem todos são igualmente bons para um servo. Alguns pinos emitem sinais curtos durante a inicialização e fazem o servo dar um tranco toda vez que a placa liga; outros são só entrada. O mapa completo de pinos da sua placa está na ferramenta Pinagem:

PinosPara servoPor quê
GPIO 13, 25, 26, 27, 32, 33RecomendadosFicam quietos na inicialização, e todos geram PWM (LEDC)
GPIO 4, 16, 17, 18, 19, 21, 22, 23ServemPinos de uso geral seguros; deixe-os livres se usar I2C (21, 22) ou SPI (18, 19, 23)
GPIO 2, 5, 12, 14, 15EvitePinos de strapping ou que emitem PWM na inicialização; o servo pode dar um tranco ou a placa pode não iniciar
GPIO 34–39Não servemSão só entrada, não geram PWM
GPIO 6–11Não servemLigados à memória flash interna
GPIO 1 e 3Não servemA linha serial do USB (TX, RX)

Alimentação do servo e GND comum

Um SG90 parado consome uns 10 mA, mas, no instante em que começa a se mover ou segura uma carga, a corrente pula para 500–700 mA. O próprio ESP32 puxa picos de cerca de 250 mA enquanto transmite por Wi-Fi. Alimente os dois pela mesma linha USB fraca e a tensão despenca, e o ESP32 reinicia com "Brownout detector was triggered". A solução é alimentar o servo com uma fonte de 5 V separada e ligar os GNDs dos dois circuitos:

Fio do servoLigar emObservação
Marrom ou preto (GND)Negativo da fonte externa e pino GND do ESP32GND comum é obrigatório: é a referência do sinal
Vermelho (V+)Fonte externa de 5 V (4,8–6 V)Nunca ligue no pino 3V3 do ESP32
Laranja ou amarelo (sinal)GPIO 13Um sinal de 3,3 V basta para o SG90 e o MG90S
Não esqueça o GND comum. O sinal do servo é uma tensão medida em relação ao GND do ESP32. Se você não ligar o negativo da fonte externa ao pino GND do ESP32, o servo se move aleatoriamente ou nem responde. E nunca alimente o servo pelo pino 3V3 do ESP32: o regulador da placa não dá conta dessa corrente e o ESP32 vai ficar reiniciando.
MontagemFonte recomendadaObservação
1 SG90, teste sem cargaPino 5V (VIN) da placa ESP32, pelo USBSó para testes curtos; com Wi-Fi pode haver brownout
2 SG90 (pan-tilt)Adaptador de 5 V, pelo menos 2 AColoque um capacitor de 470–1000 µF na alimentação
1–2 MG996R5–6 V, pelo menos 3 AA corrente de travamento pode chegar a 2,5 A por servo
Projeto portátil4 pilhas AA (alcalinas, 6 V)Pilhas recarregáveis NiMH dão 4,8 V, o que também serve

Passo 1: um primeiro teste com a ESP32Servo

Antes de acrescentar o Wi-Fi, confira se o servo e a alimentação estão funcionando direito. Procure ESP32Servo no Gerenciador de Bibliotecas, instale a biblioteca de Kevin Harrington e John K. Bennett e carregue o sketch abaixo. O servo deve varrer devagar entre 0 e 180 graus; se não fizer isso, o problema está na ligação ou na alimentação, não no 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}
Os dois números em attach(pin, 500, 2400) são as larguras de pulso para 0 e 180 graus, em microssegundos. A maioria dos clones do SG90 funciona nessa faixa. Se o servo zumbir nas pontas ou bater no batente mecânico, estreite a faixa (por exemplo, 600 e 2300) ou mantenha o ângulo entre 5 e 175 graus.

Passo 2: controle o servo com um slider em uma página web

Agora vem o projeto principal. O sketch abaixo conecta o ESP32 à sua rede de casa, serve uma página com um slider e grava no servo o ângulo que chega em /set. A página HTML fica dentro do código como uma string bruta, então não há arquivo separado para enviar. Coloque o nome e a senha do seu Wi-Fi, carregue o sketch e abra no navegador do celular o endereço IP mostrado no Monitor Serial.

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}

Há dois pontos-chave neste código. Primeiro, o JavaScript não envia uma requisição a cada movimento do slider: ele espera pelo menos 100 ms entre as requisições e sempre envia o último valor quando você tira o dedo. Um slider pode disparar 60 eventos por segundo; enviar todos entope o servidor web do ESP32 e faz o servo se mover aos trancos. Segundo, do lado do servidor, constrain() limita o ângulo a 0–180, então, mesmo que alguém digite um valor errado na barra de endereço, o servo não é forçado.

Toda vez que a página abre, o marcador %ANGLE% é trocado pelo ângulo atual do servo, então o slider começa na posição certa mesmo depois de você fechar e abrir o navegador de novo. Vários celulares podem se conectar ao mesmo tempo, e vale o último ângulo enviado. Se quiser uma interface ao vivo que atualize na hora em todos os celulares, passe para a abordagem de Servidor web assíncrono e WebSocket no ESP32.

Sem roteador? Deixe o ESP32 criar a própria rede Wi-Fi

Se você vai usar o projeto em uma feira de ciências, no jardim ou em qualquer lugar sem rede de casa, rode o ESP32 no modo ponto de acesso (AP). No setup(), troque as linhas WiFi.mode e WiFi.begin e o laço que espera a conexão pelas linhas abaixo; depois, é só entrar na rede ESP32-Servo com o celular e abrir 192.168.4.1 no navegador:

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

Como acabar com as tremidas do servo

  • Alimentação separada e GND comum: uma fonte fraca é a causa número um das tremidas; alimente o servo com uma fonte de 5 V de pelo menos 2 A e ligue os GNDs.
  • Capacitor: coloque um capacitor eletrolítico de 470–1000 µF nos fios de alimentação do servo, perto dele; ele suaviza a queda de tensão quando o servo arranca. Para decifrar as marcações de capacitores, use a ferramenta código de capacitor.
  • Limite as requisições: não envie todos os eventos do slider; o limite de 100 ms do código alivia a rede e o servo.
  • Não regrave o mesmo ângulo: a verificação if (angle != currentAngle) do código evita gravações desnecessárias.
  • A faixa de pulso certa: se o servo zumbe nas pontas, ele está forçando contra o batente mecânico; estreite a faixa do attach() ou os limites de ângulo.
  • Fio de sinal curto: com fios de mais de 30 cm, passe o sinal e o GND lado a lado, de preferência trançados.
  • Último recurso, detach(): chamar detach() quando o servo chega à posição corta o sinal e a tremida para, mas o servo deixa de segurar a carga.

Se o problema continuar, veja Servo tremendo: causas e soluções, onde passamos por todas as causas de tremida com medições. Se for usar pilhas, dá para estimar antes quanto tempo elas vão durar com a calculadora de duração de bateria.

Passo 3: uma versão pan-tilt com dois servos

Um suporte pan-tilt tem dois servos: o de baixo gira na horizontal (pan) e o de cima na vertical (tilt). Acrescente uma câmera, um laser ou um sensor ultrassônico e você terá um olho que dá para apontar a distância. Ligue o servo de pan no GPIO 13 e o de tilt no GPIO 27, e alimente os dois pela mesma fonte externa de 5 V. Esta versão traz duas mudanças: a página tem dois sliders e, em vez de pular direto para o novo ângulo, os servos andam um grau a cada 10 ms até chegar lá. Isso deixa o movimento mais suave e evita que os dois servos puxem uma corrente alta no mesmo instante.

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}

O eixo de tilt fica limitado a 20–160 graus, porque na maioria dos suportes pan-tilt de plástico o servo de cima bate na base nos extremos. No seu suporte, leve o servo devagar até cada ponta, anote o ângulo logo antes de bater e ajuste os valores min e max do slider e os limites do constrain() no código de acordo. Se precisar de mais servos, trocar os pinos do ESP32 por uma placa driver de servo PCA9685 de 16 canais facilita muito a ligação e a alimentação.

Erros comuns e como resolver

  • O servo não se mexe de jeito nenhum: os GNDs não estão ligados, o servo está no 3V3 ou o fio de sinal está em um dos pinos só de entrada, GPIO 34–39.
  • O ESP32 reinicia quando o servo se move: a alimentação não dá conta; alimente o servo com uma fonte de 5 V separada e coloque um capacitor.
  • Erro "This library only supports boards with an AVR...": a biblioteca Servo do Arduino não suporta o ESP32; use #include <ESP32Servo.h>.
  • A página não abre: o celular e o ESP32 não estão na mesma rede, o celular passou para os dados móveis ou a rede é de 5 GHz; o ESP32 só entra em redes de 2,4 GHz. Para outros problemas de conexão, veja ESP32 não conecta ao Wi-Fi.
  • O servo fica atrás do slider: requisições demais estão se acumulando; mantenha o limite de 100 ms no JavaScript ou suba para 150 ms.
  • O servo dá um tranco toda vez que a placa liga: o sinal está em um pino que emite PWM na inicialização (GPIO 2, 5, 12, 14, 15); passe para o GPIO 13, 25–27 ou 32–33.

Controlar um servo pelo celular com um slider é a base de muitos projetos: braços robóticos, suportes de câmera, fechaduras inteligentes e tampas que abrem a distância. Se for passar para um servo mais forte, calcule o consumo de energia com Servo motor MG996R. No app BlueGrays você encontra passo a passo os projetos de controle de servo com potenciômetro no ESP32, fechadura RFID com servo e servidor web no ESP32, cada um com esquema de ligação e código.

Perguntas frequentes

Como controlar um servo motor com o ESP32?

Instale a biblioteca ESP32Servo, ligue o fio de sinal do servo a um pino seguro como o GPIO 13, inicie com servo.attach(13, 500, 2400) e depois use servo.write(ângulo). Alimente o servo com uma fonte externa de 5 V, e não pelo ESP32, e ligue os GNDs.

Por que a Servo.h não funciona no ESP32?

A biblioteca Servo padrão do Arduino foi escrita para processadores como AVR e SAMD e não conhece o hardware de PWM do ESP32 (LEDC). A biblioteca ESP32Servo oferece os mesmos comandos e funciona nos cores 2.x e 3.x do ESP32.

O sinal de 3,3 V do ESP32 é suficiente para um servo?

A maioria dos servos comuns, incluindo SG90, MG90S e MG996R, lê um sinal de 3,3 V sem problema. O problema quase sempre é a alimentação, não o sinal: o fio vermelho do servo precisa ir a uma fonte de 5–6 V que entregue corrente suficiente.

Quantos servos um ESP32 consegue controlar?

A unidade LEDC do ESP32 clássico tem 16 canais de PWM, então em teoria dá para acionar até 16 servos. Na prática, faltam pinos adequados ou energia antes disso; para mais de quatro servos, uma placa driver PCA9685 via I2C é uma solução mais limpa.

Dá para controlar um servo com o ESP32 sem roteador?

Sim. Coloque o ESP32 no modo ponto de acesso com WiFi.softAP() e ele cria a própria rede Wi-Fi. Entre nessa rede com o celular, abra 192.168.4.1 no navegador e use a mesma página com o slider.

Por que o meu servo treme quando ligado a um ESP32?

As causas mais comuns são alimentação insuficiente, falta de GND comum e comandos demais por segundo. Alimente o servo com uma fonte de 5 V separada, coloque um capacitor de 470–1000 µF e limite as requisições da página web a uma a cada 100 ms.

Ver todos os projetos
Servo motor com ESP32 (controle por potenciômetro)
ES-16Intermediário
Premium

Servo motor com ESP32 (controle por potenciômetro)

Neste projeto, controlamos um servo motor SG90 com um potenciômetro. Ajustamos o ângulo do servo mapeando o valor analógico lido do potenciômetro para a faixa de 0 a 180 graus. A biblioteca ESP32Servo gera sinais para o servo nos GPIOs do ESP32 adequados e capazes de operar como saída; este projeto usa o GPIO 18. Esse é um método básico de controle para braços robóticos, estabilizadores de câmera e mecanismos de portas automáticas.

4.3(29)
42
Fechadura RFID com ESP32 (RC522 + servo + OLED + buzzer + LED)
ES-35Avançado
Premium

Fechadura RFID com ESP32 (RC522 + servo + OLED + buzzer + LED)

Vamos montar uma fechadura inteligente com ESP32, módulo RFID RC522, servo motor SG90, display OLED SSD1306, buzzer ativo e 2 LEDs. Ao ler um cartão, seu UID é comparado à lista de cartões autorizados definida no código. Se estiver autorizado, o servo motor gira para abrir a fechadura (LED verde + 2 bipes curtos), que trava novamente após 5 segundos. Com um cartão não autorizado, o LED vermelho acende, 3 bipes rápidos soam e o UID lido aparece no OLED.

4.8(9)
16
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
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
Controle de servos com joystick
AR-60Intermediário
Premium

Controle de servos com joystick

Controle dois motores com um joystick, como ao girar uma câmera de segurança. Empurre a alavanca para os lados e o servo motor inferior gira lentamente; mova para cima ou para baixo e o servo…

4.7(42)
58