Chisme 115 del lince: servo ESP32, la puerta de la cueva

Medianoche en Sierra Bermeja. Víctor Vílchez vuelve a la cueva con tres cajas de sensores para el instituto y la capa del Lince de la Noche colgando de un hombro.

La puerta de la guarida es una losa de madera que pesa lo suyo. Víctor intenta abrirla con el codo, con la rodilla y, por último, con la barbilla. Las cajas se le caen una a una.

—Tienes la guarida más avanzada de la sierra y la puerta se abre a empujones —comenta la Gata Montesa, sentada en una roca, sin ofrecerse a ayudar.

—Ya lo tengo —dice Víctor, con polvo hasta las cejas—. Escáner de retina, reconocimiento de voz y de huella dactilar. Y que CABRA reconozca mi forma de andar.

—¿Y si en vez de todo eso pones un botón?

—¿Un botón? Es muy poco —protesta Víctor, ofendido.

—Es muy poco hasta que llevas tres cajas en las manos. Un botón, un servo que abra la puerta y dos lucecitas: roja si está cerrada, verde si está abierta. Se abre tres segundos y se cierra sola.

Víctor mira la losa, mira las cajas y, por una vez, no dibuja nada en la pizarra. Así nace el Chisme 115: una puerta automática con un servo ESP32, un botón y dos LEDs.

Introducción

En el Chisme 113 encendimos un LED y en el Chisme 114 leímos el mundo con un sensor. Hoy la placa va a mover algo de verdad: un servo ESP32, el pequeño motor que mueve los brazos de los robots y los timones de los aviones de aeromodelismo. Con un servo ESP32 se consigue un movimiento preciso con muy pocos cables.

Antes de tocar un cable, practica en el simulador del Chisme 115: te guía paso a paso y no te deja avanzar hasta completar cada uno. Si solo quieres verlo funcionando, usa el modo demostración.

Qué necesitamos

• La placa ESP32 Plus de Acebott con ACECode (si no lo tienes instalado, mira el Chisme 112).
• Un servo ESP32 de 180° del kit. El de 360° no sirve: gira sin parar y no se queda en un ángulo.
• El módulo botón azul del kit de sensores.
• Un módulo LED verde y otro rojo.
• Cables y, si quieres, un trozo de cartulina pegado al brazo del servo para que parezca la puerta.

Cómo funciona un servo ESP32

Un servo ESP32 es un motor pequeño con engranajes, un sensor de posición y un circuito. Tú le dices a qué ángulo quieres el brazo y él se mueve hasta que su sensor confirma que ha llegado. Se lo dices con un pulso eléctrico que la placa repite cada 20 milisegundos: el ancho del pulso es el ángulo.

• Pulso de unos 0,5 ms: el brazo va a 0°.
• Pulso de unos 1,5 ms: el brazo va a 90°.
• Pulso de unos 2,5 ms: el brazo va a 180°.

¿Y 45°? Entre 0° y 180° hay 2 ms de diferencia, así que cada 90° suman 1 ms: 45° son 0,5 + 0,5 = 1 ms. En ACECode no calculas nada, porque el bloque «Servomotor establecer ángulo» lo hace por ti. En Arduino, en cambio, haremos el pulso a mano.

Cómo se conecta el servo ESP32

• Servo ESP32: cable naranja (señal) a la S del pin 25, cable rojo a V y cable marrón a G.
• Botón: pin 14.
• LED verde (puerta abierta): pin 5.
• LED rojo (puerta cerrada): pin 13.
• El interruptor de la placa, en 3,3 V.

Evita el pin 12: la placa lo usa al arrancar y puede dar problemas. Si el conector hembra del servo no encaja en los pines de tu placa, usa tres cables macho-macho como puente.

El servo ESP32 funciona con 3,3 V, aunque con menos fuerza. Si tiembla o la placa se reinicia al moverlo, conecta su cable rojo al pin 5V de la placa y deja los módulos a 3,3 V.

El programa con bloques

Este es el programa en ACECode. Léelo de arriba abajo:

1. Al hacer clic en la bandera: «Servomotor 25 establecer ángulo 0». La puerta empieza cerrada.
2. Por siempre: «LED de un solo color 13 Encender». El rojo dice «cerrada».
3. Si «Botón 14 presionado»: apaga el rojo, enciende el verde (pin 5), «Servomotor 25 establecer ángulo 90», esperar 3 segundos, ángulo 0 otra vez y apaga el verde.
4. Al final de cada vuelta: esperar 0,05 segundos.

Este programa pregunta al botón una y otra vez: «¿estás pulsado?, ¿estás pulsado?…». Con la espera de 0,05 s lo hace 20 veces por segundo, más que de sobra para un dedo. Fíjate en que, mientras la puerta espera sus 3 segundos, el programa está dormido y no mira el botón.

El código en Arduino IDE

Si prefieres el Arduino IDE (placa ESP32 Dev Module), este sketch hace lo mismo sin librerías: genera a mano los pulsos del servo. Si tu botón da BAJO al pulsar en lugar de ALTO, cambia HIGH por LOW en el if del botón.

const int SERVO = 25, BOTON = 14, LED_VERDE = 5, LED_ROJO = 13;

void mover(int angulo) {                    // lleva el servo a un ángulo (0-180)
  int us = map(angulo, 0, 180, 500, 2400);  // ángulo -> ancho de pulso en µs
  for (int i = 0; i < 30; i++) {            // 30 pulsos de ~20 ms = 0,6 s
    digitalWrite(SERVO, HIGH);
    delayMicroseconds(us);
    digitalWrite(SERVO, LOW);
    delay(20);
  }
}

void setup() {
  pinMode(SERVO, OUTPUT);
  pinMode(BOTON, INPUT);
  pinMode(LED_VERDE, OUTPUT);
  pinMode(LED_ROJO, OUTPUT);
  mover(0);                                 // puerta cerrada
}

void loop() {
  digitalWrite(LED_ROJO, HIGH);             // rojo = cerrada
  if (digitalRead(BOTON) == HIGH) {         // botón pulsado
    digitalWrite(LED_ROJO, LOW);
    digitalWrite(LED_VERDE, HIGH);          // verde = abierta
    mover(90);
    delay(3000);
    mover(0);
    digitalWrite(LED_VERDE, LOW);
  }
  delay(50);
}

Cómo probarlo

1. Sube el programa. La puerta debe quedar cerrada con el LED rojo encendido.
2. Pulsa el botón: el rojo se apaga, el verde se enciende, el servo gira 90° y, tres segundos después, vuelve a 0°.
3. Pulsa el botón mientras la puerta está abierta. ¿Qué ocurre? Ya sabes por qué.
4. Si el servo ESP32 no se mueve, revisa que el naranja esté en la S del pin 25 y que el rojo y el marrón no estén cruzados.

Qué estamos controlando realmente

Aquí no medimos nada: damos órdenes. La placa manda «ve a 90°» y confía en que el servo llegue. Si algo bloquea la puerta, la placa no se entera: es un control «en lazo abierto». Dentro del servo sí hay un sensor de posición, pero su señal no sale hacia la placa.

Además, el ángulo no es exacto. Un servo barato tiene holguras y puede quedarse unos grados corto o largo. Y el botón real no cambia limpiamente: rebota unos milisegundos al pulsar. Nuestro programa lo disimula porque solo pregunta cada 0,05 s.

Para el aula

• Calcula el ancho de pulso para 30°, 120° y 150°. Dibuja la gráfica ángulo-pulso: ¿qué tipo de función es y cuál es su pendiente?
• Con un transportador, mide el ángulo real del brazo para 0°, 45°, 90°, 135° y 180°. Calcula el error de cada uno. ¿Coinciden dos servos distintos?
• Cronometra cuánto tarda el servo ESP32 en pasar de 0° a 90° y compáralo con la espera de 3 s.
• Predice qué pasa si cambias 0,05 s por 2 s en la última espera. Pruébalo: ¿cuánto tarda en responder el botón?
• Cambia el ángulo de apertura a 45° y el tiempo de espera a 5 s. ¿Qué dos variables has modificado?

Retos

• Reto 1: haz que funcione.
• Reto 2: cambia el ángulo y el tiempo de apertura.
• Reto 3: añade el zumbador del Chisme 114 para que pite mientras la puerta está abierta.
• Reto 4: cuenta cuántas veces se abre la puerta y muéstralo por el monitor serie.
• Reto 5: sustituye el botón por el sensor ultrasónico para que se abra sola cuando alguien esté a menos de 20 cm.
• Reto 6: diseña una prueba para decidir qué es mejor en la cueva, botón o sensor. ¿Cuándo se abriría la puerta sin querer?

Qué hemos aprendido

Un servo ESP32 se coloca en el ángulo que le pides según el ancho de un pulso. Una puerta automática necesita tres piezas: una entrada (el botón), una salida (el servo) y un programa que las une con una condición. Y controlar no es lo mismo que medir: la placa da órdenes sin saber si se cumplen.

Para seguir investigando

• El Chisme 113: enciende un LED en el pin 5, la base de los avisos de esta puerta.
• El Chisme 114: un sonar con sensor ultrasónico, ideal para el Reto 5.
• Servomotor en Wikipedia: cómo es un servo por dentro.