Controle um servo com um ESP32
Iniciante
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as placas
Para controlar um servo com um ESP32, alimente o servo com 5 V, una os terras, ligue o sinal a um pino GPIO e envie um pulso de 544 a 2400 microssegundos de largura cinquenta vezes por segundo. Em um ESP32, o periférico LEDC gera esse pulso em hardware: ledcAttach(pin, 50, 14) configura o quadro e ledcWrite(pin, duty) define o ângulo.
O circuito acima é um servo do estilo SG90 no GPIO 4 de uma placa ESP32-C3, fazendo a varredura de 0 a 180 graus e voltando. Ele roda no seu navegador em um ESP32-C3 simulado, e o sketch é o mesmo que você gravaria na placa real.
O que você precisa
- Uma placa ESP32 (aqui uma ESP32-C3-DevKitM-1; a ESP32 DevKit clássica é ligada do mesmo jeito)
- Um servo de hobby SG90 (ou parecido)
- Fios jumper e uma protoboard para os trilhos de alimentação
Ligação
| Componente e pino | Vai para | Nota |
|---|---|---|
| Fio marrom do servo (GND) | GND | Pelo trilho de terra da protoboard |
| Fio vermelho do servo (VCC) | 5V | Não no 3V3: um SG90 quer 4 V ou mais |
| Fio laranja do servo (sinal) | GPIO 4 | Qualquer GPIO livre que possa ser uma saída |
Passo 1: ligue a alimentação primeiro
Um servo tem três fios. O marrom (ou preto) é o terra, o vermelho é a alimentação e o laranja (ou amarelo, ou branco) é o sinal. O ESP32 é uma placa de 3,3 volts, mas um SG90 precisa de quatro volts ou mais para se mover, então o fio vermelho vai no pino 5V da placa, que carrega a alimentação do USB, e não no 3V3. No simulador, como na bancada, um servo em 3,3 V não gira.
O terra é o fio que as pessoas esquecem. O sinal é medido em relação ao terra do próprio servo, então o servo e o ESP32 precisam compartilhar um. Aqui ambos vão ao trilho de terra da protoboard. Se você alimentar um servo real com uma fonte própria, una o terra dessa fonte ao da placa.
Passo 2: entenda o pulso
Um servo de modelismo escuta a largura de um pulso, não um ciclo ativo no sentido de dimmer. Pelos números da biblioteca Servo do Arduino, 544 microssegundos levam o braço a uma ponta, 2400 microssegundos à outra e 1472 microssegundos ao meio, repetidos a cada 20 milissegundos. Entre pulsos ele mantém o último ângulo que recebeu.
Isso ainda é uma forma de onda PWM, só que lenta, então o periférico LEDC do ESP32 consegue gerá-la. Fazer isso em hardware é melhor do que alternar um pino em um loop: a largura é exata, nada que uma interrupção faça pode esticá-la, e o núcleo fica livre entre os quadros.
O sinal de 3,3 volts do ESP32 é aceito pela maioria dos servos do estilo SG90, então o fio de sinal normalmente não precisa de conversor de nível, mesmo que o servo em si funcione com 5 volts.
Passo 3: o código, explicado
ledcAttach(SERVO_PIN, 50, 14) dá ao GPIO 4 um quadro de 50 hertz dividido em 16384 contagens, então uma contagem vale 20000 / 16384, cerca de 1,22 microssegundos. writeAngle() transforma 0 a 180 graus em 544 a 2400 microssegundos, a janela da biblioteca Servo e o padrão do componente de servo, e depois em contagens: 544 microssegundos são 445 contagens e 2400 são 1966. A multiplicação vem antes da divisão para que nada se perca por arredondamento.
setup() posiciona o braço em 90 graus e espera meio segundo. loop() então o move de 0 a 180 em passos de cinco graus, a cada 40 milissegundos, imprime "at 180", volta e imprime "back at 0". Abra o monitor serial para ver as duas linhas chegarem ao fim de cada varredura.
const uint8_t SERVO_PIN = 4;
const uint32_t FRAME_HZ = 50;
const uint8_t FRAME_BITS = 14;
const uint32_t FRAME_US = 1000000UL / FRAME_HZ; // 20000
const uint32_t FRAME_COUNTS = 1UL << FRAME_BITS; // 16384
const uint32_t MIN_US = 544;
const uint32_t MAX_US = 2400;
uint32_t countsForMicros(uint32_t us) {
return (us * FRAME_COUNTS) / FRAME_US;
}
void writeAngle(int degrees) {
degrees = constrain(degrees, 0, 180);
uint32_t us = MIN_US + ((MAX_US - MIN_US) * (uint32_t)degrees) / 180;
ledcWrite(SERVO_PIN, countsForMicros(us));
}
void setup() {
Serial.begin(115200);
ledcAttach(SERVO_PIN, FRAME_HZ, FRAME_BITS);
writeAngle(90);
delay(500);
}
void loop() {
for (int angle = 0; angle <= 180; angle += 5) {
writeAngle(angle);
delay(40);
}
Serial.println("at 180");
for (int angle = 180; angle >= 0; angle -= 5) {
writeAngle(angle);
delay(40);
}
Serial.println("back at 0");
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Passo 4: ou use a biblioteca ESP32Servo
A maioria dos tutoriais de servo no ESP32 usa a biblioteca ESP32Servo, que tem as mesmas chamadas da biblioteca Servo do Arduino: attach(pin) e depois write(angle). No Mokxi, ESP32Servo.h é a mesma classe de Servo.h com o nome que esses tutoriais usam, então os sketches deles compilam como estão. attach(pin) sem larguras usa os padrões do próprio ESP32Servo, 544 a 2400 microssegundos, então write(90) são 1472 microssegundos e 90 graus no servo.
A versão com LEDC acima vale a pena conhecer de qualquer jeito. Ela mostra o que a biblioteca faz por você, não precisa de biblioteca nenhuma e é a chamada certa quando você quer uma taxa de quadros ou uma janela de pulso que a biblioteca não oferece.
Experimente no editor
Abra o circuito no editor e mude o passo de 5 para 1 grau e o atraso de 40 para 10 milissegundos: a varredura fica mais suave e quase tão rápida. Depois mude MIN_US e MAX_US para 1200 e 1800. O braço agora cobre um arco mais estreito, que é como você mantém um servo longe de um fim de curso mecânico.
Mova o fio de sinal para outro GPIO e mude SERVO_PIN para combinar. O LEDC pode rotear para qualquer pino de saída, então o servo acompanha. Selecione o servo para ver suas propriedades, incluindo a janela de pulso e a velocidade de giro.
Erros comuns
Alimentar o servo pelo 3V3. O servo não se move, ou numa bancada real ele treme e trava. Use 5V, ou uma fonte separada de 5 volts com os terras unidos.
Usar código do core antigo do ESP32. Tutoriais escritos para a versão 2 do core Arduino-ESP32 chamam ledcSetup() e ledcAttachPin() com um número de canal. A versão 3 os substituiu por ledcAttach(pin, frequency, resolution) e ledcWrite(pin, duty), que é o que este sketch usa.
Esperar que a placa alimente um servo travado. Um SG90 real pode puxar algumas centenas de miliamperes quando trava, o bastante para reiniciar um ESP32 alimentado pelo USB. O simulador não modela a corrente da fonte, então se você montar isso de verdade, dê ao servo uma fonte própria.
Escolher a resolução errada. Com 8 bits, um quadro de 50 hertz tem só 256 contagens de 78 microssegundos cada, então um servo tem uns 13 passos em todo o seu curso. Quatorze bits dão cerca de 819.
Abra este circuito no editor. ESP32-C3: varredura de servo, ligado como está rodando no topo desta página. Mude um componente ou um valor e rode de novo.
Abrir o circuitoPerguntas
Quais pinos do ESP32 podem controlar um servo?
Qualquer GPIO que possa ser uma saída. O LEDC pode ser roteado para qualquer um deles. Evite os pinos que sua placa usa para flash ou para boot, marcados no pinout dela.
Posso alimentar um SG90 com o pino de 3,3 V do ESP32?
Não. Um SG90 precisa de cerca de 4 a 6 volts para se mover. Alimente-o pelo 5V ou por uma fonte própria de 5 volts, e compartilhe o terra com o ESP32. O sinal de 3,3 volts em si está ótimo.
A biblioteca Servo do Arduino funciona no ESP32?
Não a original, que é escrita para os timers de AVR. A biblioteca ESP32Servo tem as mesmas chamadas e é a que os tutoriais de ESP32 usam. No Mokxi, tanto Servo.h quanto ESP32Servo.h compilam para as placas ESP32.
Quantos servos um ESP32 consegue controlar?
Quantos canais LEDC e pinos de saída livres ele tiver: o ESP32-C3 tem seis canais LEDC e o ESP32 clássico tem dezesseis. Para mais, ou para economizar pinos, uma placa PCA9685 controla dezesseis servos por I2C.
Continuar
Monte isto de verdade
Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.