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.

Como funciona: do slider ao servo
- O navegador do celular abre o endereço IP do ESP32, e o ESP32 devolve uma pequena página HTML com um slider.
- 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.
- O servidor web no ESP32 recebe a requisição, lê o ângulo e o limita à faixa de 0–180.
- 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.
- 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:
| Pinos | Para servo | Por quê |
|---|---|---|
| GPIO 13, 25, 26, 27, 32, 33 | Recomendados | Ficam quietos na inicialização, e todos geram PWM (LEDC) |
| GPIO 4, 16, 17, 18, 19, 21, 22, 23 | Servem | Pinos de uso geral seguros; deixe-os livres se usar I2C (21, 22) ou SPI (18, 19, 23) |
| GPIO 2, 5, 12, 14, 15 | Evite | Pinos de strapping ou que emitem PWM na inicialização; o servo pode dar um tranco ou a placa pode não iniciar |
| GPIO 34–39 | Não servem | São só entrada, não geram PWM |
| GPIO 6–11 | Não servem | Ligados à memória flash interna |
| GPIO 1 e 3 | Não servem | A 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 servo | Ligar em | Observação |
|---|---|---|
| Marrom ou preto (GND) | Negativo da fonte externa e pino GND do ESP32 | GND 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 13 | Um sinal de 3,3 V basta para o SG90 e o MG90S |
| Montagem | Fonte recomendada | Observação |
|---|---|---|
| 1 SG90, teste sem carga | Pino 5V (VIN) da placa ESP32, pelo USB | Só para testes curtos; com Wi-Fi pode haver brownout |
| 2 SG90 (pan-tilt) | Adaptador de 5 V, pelo menos 2 A | Coloque um capacitor de 470–1000 µF na alimentação |
| 1–2 MG996R | 5–6 V, pelo menos 3 A | A corrente de travamento pode chegar a 2,5 A por servo |
| Projeto portátil | 4 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.
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}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.
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:
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.1Como 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.
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.
Projetos para montar depois desta leitura
Ver todos os projetos
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.

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.

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.

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

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

