Un robot autoequilibrado en un Arduino
Avanzado
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
Un robot autoequilibrado se para sobre dos ruedas, como un péndulo invertido, y se mantiene en pie solo porque sigue colocando sus ruedas debajo de sí mismo. Es un proyecto clásico de Arduino porque reúne dos grandes ideas en un solo montaje: convertir un sensor ruidoso en un buen ángulo, y un controlador PID que actúa sobre él cientos de veces por segundo.
El circuito de arriba es un Uno manejando un robot de dos ruedas con su propio MPU6050 y controlador de motores TB6612. Tres perillas ajustan las ganancias del PID mientras funciona, y una pantalla OLED muestra el ángulo y las ganancias. Presiona Ejecutar: el robot se sostiene erguido un momento y luego se suelta, y se recupera solo. Luego empújalo con los botones de flechas del robot y gira las perillas para ver qué hace cada ganancia.
Lo que necesitas
- Un Arduino Uno
- Un chasis de robot de dos ruedas con motores de corriente directa engranados
- Un acelerómetro y giroscopio MPU6050
- Un controlador de motores TB6612FNG
- Tres potenciómetros de 10k
- Una OLED SSD1306, de 128x64, con I2C (opcional)
- Un paquete de pilas para los motores
Cableado
| Componente y pin | Va a | Nota |
|---|---|---|
| SCL y SDA del robot | Pines 12 y 2 | El MPU6050 del robot en 0x68, en su propio I2C por software |
| AIN1, AIN2, PWMA | Pines 10, 9 y 6 | Motor izquierdo |
| BIN1, BIN2, PWMB | Pines 5, 4 y 3 | Motor derecho |
| STBY | 5 V | El driver funciona siempre que reciba energía |
| Perillas de Kp, Ki y Kd | A0, A1 y A2 | Extremos a 5 V y GND |
| SCL y SDA de la OLED | A5 y A4 | Ángulo y ganancias |
Paso 1: calcular la inclinación
El MPU6050 tiene dos sensores, y ninguno es suficientemente bueno por sí solo. El acelerómetro sabe hacia dónde es abajo, así que atan2(-ax, az) da la inclinación respecto a la gravedad. Pero también siente cada empujón que las ruedas le dan al cuerpo, así que mientras el robot se mueve es ruidoso y da errores. El giroscopio mide qué tan rápido gira el cuerpo, de forma suave, pero hay que ir sumando esa velocidad para obtener un ángulo, y los pequeños errores también se acumulan, así que el ángulo se desvía.
El filtro complementario toma lo mejor de cada uno: angle = 0.98 * (angle + rate * dt) + 0.02 * accelAngle. De momento a momento el giro mueve el ángulo, y el acelerómetro lo atrae suavemente de vuelta a la verdad, un 2% en cada paso. Es una sola línea de código, y es lo que usan la mayoría de los robots que se equilibran.
Paso 2: un PID sobre el ángulo
Cada 10 ms el sketch calcula qué tan lejos está el cuerpo de la vertical y mueve las ruedas para corregirlo. La salida son tres términos sumados. P (proporcional) es la inclinación por Kp: más inclinación, más impulso. D (derivativo) es la velocidad del giro por Kd: se opone a que el cuerpo gire rápido, lo que evita que se pase de largo. I (integral) va sumando la inclinación en el tiempo por Ki: aporta el empuje constante que un motor necesita solo para mantener una velocidad.
La suma se limita a -255 a 255, y su signo elige la dirección (AIN1 y AIN2) mientras su magnitud va a analogWrite en PWMA y PWMB. Al inclinarse hacia adelante, las ruedas avanzan para volver a colocarse bajo el cuerpo.
Las tres perillas ajustan Kp de 0 a 80, Ki de 0 a 600 y Kd de 0 a 2. Con cada perilla a la mitad (40, 300 y 1) el robot se equilibra: suéltalo al segundo uno, se sostiene, y unos cuatro segundos después de Ejecutar el monitor serie reporta "Balanced for 3 s". Empújalo con la flecha y un momento después dice "Caught it: upright again".
const float ALPHA = 0.98;
const float FALLEN = 45.0;
const float I_LIMIT = 150.0;
void loop() {
unsigned long now = micros();
if (now - lastUs < PERIOD_US) return; // every 10 ms
float dt = (now - lastUs) / 1000000.0;
lastUs = now;
Mpu6050Reading r;
if (!imu.read(r)) return;
float accelAngle = atan2(-(float)r.ax, (float)r.az) * 57.29578;
float rate = r.gy / 131.0;
angle = ALPHA * (angle + rate * dt) + (1 - ALPHA) * accelAngle;
if (fabs(angle) > FALLEN) {
fallen = true;
integral = 0;
brake();
Serial.println("FALLEN");
} else {
integral += angle * dt;
if (ki > 0.01) {
float limit = I_LIMIT / ki;
if (integral > limit) integral = limit;
if (integral < -limit) integral = -limit;
}
float pid = kp * angle + ki * integral + kd * rate;
output = (int)constrain(pid, -255, 255);
drive(output);
}
readKnob();
}Qué hace cada ganancia: pruébalo
Baja Ki por completo. Sin la integral, el robot no puede sostener el empuje que un motor necesita a velocidad, así que se va arrastrando, se inclina cada vez más para mantenerse y se cae: el monitor serie dice "FALLEN". Ese es el término I ganándose su lugar.
Baja Kd por completo y luego presiona el botón de levantarse del robot. Sin el amortiguamiento, cada oscilación se pasa más que la anterior: se balancea cada vez más fuerte hasta caerse. Con Kd de vuelta arriba, el mismo empujón se apaga en una o dos oscilaciones.
Kp define qué tan fuerte combate una inclinación. Muy bajo y es perezoso y tambaleante; muy alto y tiembla. La gente afina un robot real en ese orden: Kp hasta que casi se sostenga y empiece a temblar, Kd hasta que el temblor pare, y luego Ki hasta que deje de desviarse.
Sostenido, soltado, caído
A real robot is held upright while it powers up. If the PID ran during that time, the integral would fill up with a lean the wheels cannot fix (your hand is holding it), and the stored push would throw it over the moment you let go. So the sketch keeps the motors braked while the gyro says the body is still, and starts balancing when the rate goes over 1 degree a second: the hand has let go.
Pasados los 45 grados se ha caído. Los motores frenan, la integral se reinicia, y en el robot queda tirado en el piso a unos 80 grados. Levántalo con el botón y queda sostenido otra vez, listo para el siguiente intento.
El modelo es un péndulo real sobre ruedas, calculado cada milisegundo, con motores que empujan el cuerpo hacia atrás mientras impulsan las ruedas hacia adelante. Lo que deja fuera son los baches del piso, la holgura de las cajas de engranes baratas y una batería que se descarga, que son las cosas que hacen que uno real sea más difícil de afinar.
Errores comunes
Las ruedas girando al revés. Si el robot avanza en dirección contraria a su inclinación, se cae de inmediato. Intercambia los cables de un motor o cambia el signo de la salida.
El ángulo con el signo equivocado, porque el MPU6050 está montado en otra orientación. Inclínalo hacia adelante con la mano y verifica que el ángulo sea positivo antes de ejecutar los motores.
Confiar solo en el acelerómetro. Este lee los empujones de las ruedas como inclinación. Mézclalo con el giroscopio.
Dejar STBY del TB6612 sin conectar. Tiene una resistencia de bajada, así que el driver permanece apagado y los motores nunca giran. Conecta STBY en el circuito de arriba y el robot se cae en cuanto lo sueltas.
Un ciclo lento. Imprimir en el monitor serie en cada ciclo, o dibujar toda la OLED de una vez, roba el tiempo que el PID necesita. El sketch imprime cuatro veces por segundo y dibuja una fila de la OLED por llamada.
Saturación de la integral. Sin un límite, el término I sigue creciendo mientras el robot está sostenido o atascado. El sketch lo limita y lo reinicia en cada caída.
Abre este circuito en el editor. Arduino Uno: un robot autoequilibrado, conectado tal como corre en la parte superior de esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Abrir el circuitoPreguntas
¿Qué sensor necesita un robot autoequilibrado?
Un acelerómetro y un giroscopio juntos, como el MPU6050. El acelerómetro da el ángulo respecto a la gravedad, el giroscopio qué tan rápido gira, y un filtro complementario o de Kalman los combina.
¿Cómo afino el PID de un robot equilibrista?
Empieza con Ki y Kd en cero. Sube Kp hasta que casi se sostenga y empiece a temblar, sube Kd hasta que el temblor pare, y luego agrega un poco de Ki para que deje de desviarse.
¿Qué driver de motor conviene para un robot equilibrista?
Un TB6612FNG es buena opción para motores engranados pequeños: es eficiente y conmuta rápido. Un L298N funciona, pero desperdicia más energía en forma de calor.
¿Por qué mi robot equilibrista se desvía y se cae?
Normalmente por muy poca integral, así no puede sostener el empuje que necesita a velocidad, o porque el punto de equilibrio no está del todo vertical. Agrega algo de Ki o ajusta el ángulo cero.
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.