⚙️ Motores y energía

Casi todo el movimiento de un robot de mesa viene de tres tipos de motor. El motor DC gira sin parar mientras recibe energía: es la rueda del rover. El servo llega hasta un ángulo y se queda allí: es el «cuello» que gira el sensor. El motor paso a paso avanza en pasos pequeños y exactos: es el eje de la impresora 3D. La pregunta correcta no es «cuál es mejor», sino «qué movimiento requiere la tarea».

Cómo leer: La flecha continua del motor DC indica giro libre; el arco discontinuo del servo muestra que solo se mueve dentro de un rango (0° a 180°); las pequeñas marcas del motor paso a paso son las posiciones fijas en las que se detiene. Las dos tarjetas verdes giran sin límite; la cian funciona por posición.

Por qué aprender

Un motor inadecuado deja al robot débil, lento o impreciso, y ningún código lo corrige. Elegir según el tipo de movimiento también determina lo demás: qué driver comprar, cuánta corriente debe suministrar la batería y cuántos pines del ESP32 se usarán.

Conceptos clave

Un pin del ESP32 entrega pocos miliamperios a 3,3 V; un motor TT consume cientos de miliamperios y más de 1 A al arrancar. Conectar el motor directamente al pin lo quema. Entre ambos va un driver de motor: el ESP32 solo envía la señal y el driver abre el paso para la corriente que viene de la batería.

Cómo leer: sigue la flecha verde: entra por S1, atraviesa el motor de izquierda a derecha y sale por S4. La flecha cian discontinua muestra el recorrido en espejo (S2, motor en sentido contrario, S3). Cerrar S1 y S3 a la vez conectaría la batería directamente a GND y causaría un cortocircuito; el chip del driver existe precisamente para que los pines IN1/IN2 nunca lo permitan.

Por qué aprender

El driver es el puente entre el código y la fuerza. Entender sus pines (potencia, lógica, sentido, velocidad, encendido y apagado) hace que el cableado del rover de la 1.6 deje de ser una receta memorizada: sabes por qué está cada cable ahí y puedes cambiar de driver sin miedo.

Conceptos clave

El sentido viene de los pines IN1/IN2. La velocidad viene del PWM, que ya usaste en el módulo 1.3 para el brillo del LED: el driver conecta y desconecta la batería al motor miles de veces por segundo, y el motor responde al promedio. Cuanto mayor sea la fracción «encendida» de cada ciclo, el duty cycle, más rápido gira.

Cómo leer: las tres ondas tienen la misma altura (el voltaje de la batería) y el mismo ritmo; lo que cambia es el ancho del tramo alto. Con 25%, el motor TT suele solo zumbar: la fuerza promedio no vence la fricción de la caja reductora. Esta franja inútil es la zona muerta, y el código de abajo la evita.

Objetivo: crear los «verbos» del rover (adelante, reversa, girar, parar y rampa) con un TB6612FNG y ver cada uno en el Monitor Serie. Los pines son los mismos del proyecto 1.6: motor izquierdo en PWMA 25, AIN1 26, AIN2 27; derecho en PWMB 33, BIN1 32, BIN2 4; STBY en el 13.

// Prueba de motores con TB6612FNG (ESP32, paquete esp32 3.x)
// Adelante, reversa, giro y parada, con rampa de aceleración.
// La primera vez, deja el robot SUSPENDIDO (ruedas en el aire).

const int PINO_PWMA = 25, PINO_AIN1 = 26, PINO_AIN2 = 27;  // motor izquierdo
const int PINO_PWMB = 33, PINO_BIN1 = 32, PINO_BIN2 = 4;   // motor derecho
const int PINO_STBY = 13;
const int PWM_FREQ = 20000;  // 20 kHz: fuera del rango que oye el oído
const int PWM_BITS = 8;      // velocidad de 0 a 255
const int VEL_MIN  = 90;     // por debajo de esto el motor TT zumba y no gira
// vel de -255 (reversa) a 255 (adelante); 0 = detenido
void motor(int in1, int in2, int pinoPwm, int vel) {
  vel = constrain(vel, -255, 255);
  int forca = abs(vel);
  if (forca > 0 && forca < VEL_MIN) forca = VEL_MIN;  // evita la zona muerta
  digitalWrite(in1, vel > 0 ? HIGH : LOW);
  digitalWrite(in2, vel < 0 ? HIGH : LOW);
  ledcWrite(pinoPwm, forca);                  // API 3.x: recibe el PIN
}
void andar(int esq, int dir) {
  motor(PINO_AIN1, PINO_AIN2, PINO_PWMA, esq);
  motor(PINO_BIN1, PINO_BIN2, PINO_PWMB, dir);
}
void frente(int v)       { andar(v, v); }
void re(int v)           { andar(-v, -v); }
void girarDireita(int v) { andar(v, -v); }  // ruedas en sentidos opuestos
void parar()            { andar(0, 0); }
// aumenta (o reduce) la velocidad de 5 en 5: sin tirones
void rampa(int de, int ate, int passoMs) {
  int passo = (ate > de) ? 5 : -5;
  for (int v = de; (passo > 0) ? (v < ate) : (v > ate); v += passo) { frente(v); delay(passoMs); }
  frente(ate);
}
void setup() {
  Serial.begin(115200);
  pinMode(PINO_AIN1, OUTPUT); pinMode(PINO_AIN2, OUTPUT);
  pinMode(PINO_BIN1, OUTPUT); pinMode(PINO_BIN2, OUTPUT);
  pinMode(PINO_STBY, OUTPUT);
  ledcAttach(PINO_PWMA, PWM_FREQ, PWM_BITS);   // canal elegido automáticamente
  ledcAttach(PINO_PWMB, PWM_FREQ, PWM_BITS);
  digitalWrite(PINO_STBY, HIGH);               // saca al driver del modo de espera
  parar();
  Serial.println("Prueba de motores: adelante, reversa, giro, parar");
  delay(2000);
}
void loop() {
  Serial.println("rampa hasta adelante 200"); rampa(0, 200, 20); delay(1000);
  Serial.println("parar");                parar();           delay(800);
  Serial.println("re 160");               re(160);           delay(1000);
  Serial.println("parar");                parar();           delay(800);
  Serial.println("girar a la derecha"); girarDireita(160); delay(700);
  Serial.println("parar");                parar();           delay(2000);
}

Por qué aprender

Adelante, reversa, girar y parar son los verbos que usará la máquina de estados del rover. Al escribirlos una sola vez en funciones pequeñas, el código del proyecto queda corto y legible: «si la pared está cerca, parar(), después re()".

Conceptos clave

El servo tiene tres cables: marrón (GND), rojo (5 V) y naranja (señal). No interpreta el duty cycle como el motor DC; interpreta el ancho del pulso. Cada 20 ms (50 veces por segundo) llega un pulso, y su duración indica el ángulo. La biblioteca ESP32Servo calcula estos pulsos por ti. La Servo.h de Arduino Uno no funciona en el ESP32.

Cómo leer: cada color del pulso, a la izquierda, corresponde al brazo del mismo color, a la derecha. El pulso corto (verde) pone el brazo en un extremo, el medio (cian) en el centro y el largo (ámbar) en el otro extremo. El espacio después del pulso completa los 20 ms. Tu servo puede tener un rango un poco diferente; los números 500 y 2400 del código lo ajustan.

Paso a paso

Objetivo: hacer que el servo «mire» hacia adelante, hacia la derecha, de nuevo hacia adelante y hacia la izquierda, como lo hará el cuello del rover en la 1.6.

// Servo SG90 en ESP32 con la biblioteca ESP32Servo (paquete esp32 3.x)
#include <ESP32Servo.h>

const int PINO_SERVO = 23;  // cable naranja (señal)
Servo cabeca;   // el servo que gira el sensor del rover

void setup() {
  Serial.begin(115200);
  cabeca.setPeriodHertz(50);             // un pulso cada 20 ms
  cabeca.attach(PINO_SERVO, 500, 2400);  // 0,5 ms = 0 grados ... 2,4 ms = 180 grados
  cabeca.write(90);                      // comienza mirando hacia adelante
  Serial.println("Servo listo en GPIO 23");
  delay(1000);
}

void loop() {
  int angulos[] = {90, 20, 90, 160};    // adelante, derecha, adelante, izquierda
  for (int i = 0; i < 4; i++) {
    cabeca.write(angulos[i]);
    Serial.printf("ángulo: %d\n", angulos[i]);
    delay(800);                          // tiempo para que el servo llegue
  }
}

Por qué aprender

Con el sensor de distancia sobre el servo, el rover mira hacia ambos lados antes de decidir hacia dónde girar, en vez de girar siempre hacia el mismo lado. Es la misma técnica de «apuntar» que usarás en la pinza, en la cámara que sigue un objeto y en el brazo de la Trilha 5.

Conceptos clave

Una batería para robot necesita dos cosas: la voltaje adecuada para los motores y corriente suficiente para el arranque. Aquí es donde falla la batería cuadrada de 9 V: el voltaje parece bueno, pero entrega poca corriente, cae en la primera aceleración y el ESP32 se reinicia. Para la Trilha 1, la opción segura es usar 4 pilas AA recargables (NiMH) o 2 celdas 18650 con una placa de protección.

Cómo leer: cuanto más larga es la barra, más corriente entrega la batería sin que el voltaje se desplome. La diminuta barra roja explica por qué la batería de 9 V reinicia el robot. La LiPo tiene la barra más larga, y por eso mismo es la más peligrosa: en un cortocircuito entrega toda esa corriente en forma de calor.

Por qué aprender

La alimentación incorrecta es la causa número uno de que un robot «se reinicie solo», y la batería de litio es el mayor riesgo real en la mesa de trabajo. Saber leer el voltaje, la capacidad y la protección hace que el rover funcione más tiempo y que el laboratorio (y tu casa) sean más seguros.

Conceptos clave

La batería tiene 7,4 V; el ESP32, el sensor y el servo necesitan 5 V. Quien hace esta conversión es un regulador buck, una pequeña placa que baja el voltaje y pierde poca energía en forma de calor. La conexión queda dividida en dos ramas: la batería va directamente a VM del driver (potencia de los motores) y, a través del buck, a los 5 V de la electrónica. Y todos los negativos se conectan en un solo punto: el GND común.

Cómo leer: el camino ámbar es el voltaje de la batería, que solo va al driver y al buck. El verde es el 5 V limpio de la electrónica. La línea cian discontinua es el 3,3 V que el ESP32 envía a la lógica del driver. Las líneas grises punteadas son los GND: todas terminan en el mismo círculo. Si falta una, las señales pierden la referencia y el robot se comporta de manera aleatoria.

Objetivo: descubrir por qué se reinició el ESP32. Ejecuta el sketch solo para ver el motivo «normal». Después copia la función motivo() y las líneas de setup() al inicio de la prueba de motores del tema 3: cada vez que se reinicie, la primera línea del Serial Monitor indicará la causa.

// ¿Por qué se reinició el ESP32? (paquete esp32 3.x)
#include "esp_system.h"

const char* motivo(esp_reset_reason_t r) {
  switch (r) {
    case ESP_RST_POWERON:  return "encendiste el equipo o presionaste EN (normal)";
    case ESP_RST_SW:       return "reinicio solicitado por el programa";
    case ESP_RST_PANIC:    return "error en el programa (panic)";
    case ESP_RST_BROWNOUT: return "BROWNOUT: bajó el voltaje (motor, batería baja, cable)";
    default:               return "otro motivo";
  }
}
void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.print("Último reinicio: ");
  Serial.println(motivo(esp_reset_reason()));
}

void loop() {}

Por qué aprender

Sin regulador, capacitores y GND común, el ruido del motor reinicia el ESP32 justo cuando más necesitas que funcione: al frenar y girar frente a la pared. Esta falla parece un «bug de código» y hace que mucha gente se rinda; ahora sabes que primero debes revisar la alimentación.

Conceptos clave