Controla un servomotor con un ESP32
Principiante
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
Para controlar un servomotor con un ESP32, alimenta el servo con 5 V, une las tierras, conecta su señal a un pin GPIO y envía un pulso de 544 a 2400 microsegundos de ancho cincuenta veces por segundo. En un ESP32 el periférico LEDC genera ese pulso por hardware: ledcAttach(pin, 50, 14) configura el marco y ledcWrite(pin, duty) fija el ángulo.
El circuito de arriba es un servomotor tipo SG90 en el GPIO 4 de una placa ESP32-C3, que barre de 0 a 180 grados y de regreso. Se ejecuta en tu navegador sobre un ESP32-C3 simulado, y el sketch es el que cargarías en la placa real.
Lo que necesitas
- Una placa ESP32 (aquí una ESP32-C3-DevKitM-1; la clásica ESP32 DevKit se conecta de la misma forma)
- Un servo de hobby SG90 (o similar)
- Cables puente y una protoboard para los rieles de alimentación
Cableado
| Componente y pin | Va a | Nota |
|---|---|---|
| Cable café del servo (GND) | GND | A través del riel de tierra de la protoboard |
| Cable rojo del servo (VCC) | 5V | No 3V3: un SG90 necesita 4 V o más |
| Cable naranja del servo (señal) | GPIO 4 | Cualquier GPIO libre que pueda ser una salida |
Paso 1: conecta primero la alimentación
Un servomotor tiene tres cables. El café (o negro) es tierra, el rojo es alimentación y el naranja (o amarillo, o blanco) es la señal. La ESP32 es una placa de 3.3 voltios, pero un SG90 necesita cuatro voltios o más para moverse, así que su cable rojo va al pin 5V de la placa, que trae la alimentación del USB, y no a 3V3. En el simulador, igual que en el banco de trabajo, un servomotor a 3.3 V no gira.
La tierra es el cable que la gente olvida. La señal se mide contra la propia tierra del servomotor, así que el servomotor y la ESP32 deben compartir una. Aquí ambos van al riel de tierra de la protoboard. Si alimentas un servomotor real con su propia fuente, une la tierra de esa fuente con la de la placa.
Paso 2: entiende el pulso
Un servomotor de hobby escucha el ancho de un pulso, no un ciclo útil en el sentido del control de intensidad. Según los valores de la biblioteca Servo de Arduino, 544 microsegundos llevan el cuerno a un extremo, 2400 microsegundos al otro y 1472 microsegundos al centro, repetidos cada 20 milisegundos. Entre pulsos mantiene el último ángulo que se le indicó.
Sigue siendo una forma de onda PWM, solo que lenta, así que el periférico LEDC de la ESP32 puede generarla. Hacerlo por hardware es mejor que conmutar un pin en un bucle: el ancho es exacto, ninguna interrupción puede estirarlo y el núcleo queda libre entre cuadros.
La señal de 3.3 voltios de la ESP32 la aceptan la mayoría de los servomotores tipo SG90, así que el cable de señal normalmente no necesita un desplazador de nivel, aunque el servomotor mismo funcione a 5 voltios.
Paso 3: el código, explicado
ledcAttach(SERVO_PIN, 50, 14) le da al GPIO 4 un cuadro de 50 hercios dividido en 16384 cuentas, así que una cuenta es 20000 / 16384, unos 1.22 microsegundos. writeAngle() convierte de 0 a 180 grados en 544 a 2400 microsegundos, la ventana de la biblioteca Servo y el valor predeterminado del componente, y luego en cuentas: 544 microsegundos son 445 cuentas y 2400 son 1966. La multiplicación va antes que la división para que nada se pierda por redondeo.
setup() deja el cuerno en 90 grados y espera medio segundo. loop() luego lo mueve de 0 a 180 en pasos de cinco grados, cada 40 milisegundos, imprime "at 180", lo regresa e imprime "back at 0". Abre el monitor serie para ver llegar las dos líneas al terminar cada barrido.
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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Paso 4: o usa la biblioteca ESP32Servo
La mayoría de los tutoriales de servomotores con ESP32 usan la biblioteca ESP32Servo, que tiene las mismas llamadas que la biblioteca Servo de Arduino: attach(pin) y luego write(angle). En Mokxi, ESP32Servo.h es la misma clase que Servo.h con el nombre que esos tutoriales usan, así que sus sketches compilan tal cual. attach(pin) sin anchos usa los valores predeterminados de ESP32Servo, 544 a 2400 microsegundos, así que write(90) son 1472 microsegundos y 90 grados en el servomotor.
De todos modos vale la pena conocer la versión con LEDC de arriba. Muestra lo que la biblioteca hace por ti, no necesita ninguna biblioteca, y es la llamada a usar cuando quieres una frecuencia de cuadro o una ventana de pulso que la biblioteca no ofrece.
Pruébalo en el editor
Abre el circuito en el editor y cambia el paso de 5 a 1 grado y el retardo de 40 a 10 milisegundos: el barrido queda más suave y más o menos igual de rápido. Luego cambia MIN_US y MAX_US a 1200 y 1800. Ahora el cuerno recorre un arco más estrecho, que es como mantienes un servomotor lejos de un tope mecánico.
Mueve el cable de señal a otro GPIO y cambia SERVO_PIN para que coincida. LEDC puede dirigirse a cualquier pin de salida, así que el servomotor lo sigue. Selecciona el servomotor para ver sus propiedades, incluida la ventana de pulso y qué tan rápido gira.
Errores comunes
Alimentar el servomotor desde 3V3. El servomotor no se mueve, o en un banco real tiembla y se atasca. Usa 5V, o una fuente aparte de 5 voltios con las tierras unidas.
Usar código del núcleo viejo de ESP32. Los tutoriales escritos para la versión 2 del núcleo Arduino-ESP32 llaman ledcSetup() y ledcAttachPin() con un número de canal. La versión 3 los reemplazó con ledcAttach(pin, frequency, resolution) y ledcWrite(pin, duty), que es lo que este sketch usa.
Esperar que la placa alimente un servomotor atascado. Un SG90 real puede consumir unos cientos de miliamperios cuando se atasca, lo suficiente para reiniciar una ESP32 alimentada por USB. El simulador no modela la corriente de la fuente, así que si construyes esto de verdad, dale al servomotor su propia alimentación.
Elegir la resolución equivocada. A 8 bits, un cuadro de 50 hertz tiene solo 256 cuentas de 78 microsegundos cada una, así que un servomotor obtiene unos 13 pasos en todo su recorrido. Catorce bits dan unas 819.
Abre este circuito en el editor. ESP32-C3: barrido de servomotor, conectado como se ejecuta al inicio de esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Abrir el circuitoPreguntas
¿Qué pines de la ESP32 pueden controlar un servomotor?
Cualquier GPIO que pueda ser una salida. LEDC puede dirigirse a cualquiera de ellos. Evita los pines que tu placa usa para la memoria flash o para el arranque, que su diagrama de pines indica.
¿Puedo alimentar un SG90 desde el pin de 3.3 V de la ESP32?
No. Un SG90 necesita entre 4 y 6 voltios para moverse. Aliméntalo desde 5V o desde su propia fuente de 5 voltios, y comparte la tierra con la ESP32. La señal de 3.3 voltios sí está bien.
¿Funciona la biblioteca Servo de Arduino en una ESP32?
No la original, que está escrita para los temporizadores AVR. La biblioteca ESP32Servo tiene las mismas llamadas y es la que usan los tutoriales de ESP32. En Mokxi, tanto Servo.h como ESP32Servo.h compilan para las placas ESP32.
¿Cuántos servomotores puede manejar una ESP32?
Tantos como canales LEDC y pines de salida libres tenga: la ESP32-C3 tiene seis canales LEDC y la ESP32 clásica tiene dieciséis. Para más, o para ahorrar pines, una placa PCA9685 maneja dieciséis servomotores por I2C.
Sigue así
Ármalo en la vida real
Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.