Robot Mecanum 4WD con Arduino y servos

Un robot Mecanum es una plataforma que combina cuatro ruedas con rodillos diagonales para trasladarse y girar sin orientar primero el chasis.

Las ruedas Mecanum (inventadas por Bengt Ilon en 1973) son una maravilla de la ingeniería. A diferencia de las Omni convencionales, sus rodillos están montados a 45 grados respecto al eje principal.

Esto cambia las reglas del juego. Mientras que en el robot Omni triangular las fuerzas se cancelaban de forma evidente, aquí tenemos una configuración rectangular mucho más estable y capaz de cargar peso, pero que requiere una combinación vectorial muy específica para moverse de lado.

La Teoría: La Fuerza en X

El secreto de las ruedas Mecanum no está solo en la rueda, sino en cómo se montan. No todas las ruedas son iguales; hay “Ruedas Izquierdas” y “Ruedas Derechas” (espejadas).

Para que el sistema funcione, debemos montarlas de tal forma que, vistos desde arriba, los rodillos formen una X apuntando hacia el centro del robot.

• Las ruedas delanteras empujan el suelo hacia adentro.
• Las ruedas traseras también.

Descomposición de vectores

Al girar, una rueda Mecanum genera una fuerza diagonal a 45º.

• Si giramos todas hacia adelante, las componentes laterales se cancelan y el robot avanza.
• Si giramos las de un lado hacia dentro y las del otro hacia fuera, las componentes longitudinales se cancelan y el robot se desliza lateralmente.

La cinemática para calcular la velocidad de cada rueda () basándonos en los inputs de movimiento () y rotación () es:

Ojo con esto. 4 servos arrancando a la vez pueden resetear cualquier batería pequeña.

Esquema de conexión

El cableado es similar al proyecto anterior, pero añade un motor. Servo.h puede usar pines digitales normales; no necesita que tengan PWM por hardware.

Señales de los servos

Cada rueda tiene su propia señal de control.

Alimentación de los servos

Cuatro servos arrancando a la vez piden bastante corriente. Alimentadlos desde una batería o fuente externa, con GND común.

El código

Vamos a crear un “Mixer” (mezclador) que reciba nuestros deseos (ir adelante, ir de lado, girar) y calcule qué debe hacer cada rueda individualmente.

Un punto crítico que muchos tutoriales pasan por alto es la normalización. Si le pides al robot ir al 100% hacia adelante () y girar al 100% (), la fórmula dirá que la rueda FL debe ir a velocidad 2. Eso es imposible. Si cortamos a 1 (clipping), perderemos la proporción y el robot hará movimientos extraños. La solución es dividir todos los valores por el máximo si este supera 1.

Definiciones y setup

#include <Servo.h>

// Definimos los 4 servos
Servo servoFL; // Front Left
Servo servoFR; // Front Right
Servo servoRL; // Rear Left
Servo servoRR; // Rear Right

// Pines
const int PIN_FL = 6;
const int PIN_FR = 9;
const int PIN_RL = 10;
const int PIN_RR = 11;

void setup() {
  Serial.begin(9600);
  
  servoFL.attach(PIN_FL);
  servoFR.attach(PIN_FR);
  servoRL.attach(PIN_RL);
  servoRR.attach(PIN_RR);
  
  stopRobot();
  delay(1000);
}

Mezclador cinemático

void moverMecanum(float x, float y, float w) {
  // x: Movimiento lateral (-1.0 a 1.0)
  // y: Movimiento frontal (-1.0 a 1.0)
  // w: Rotación (-1.0 a 1.0)

  // 1. Aplicamos las fórmulas vectoriales
  // Nota: Dependiendo de tu cableado, quizás debas invertir (+/-) algún término
  float fl = y + x + w;
  float fr = y - x - w;
  float rl = y - x + w;
  float rr = y + x - w;

  // 2. Normalización (Mantiene la dirección correcta si saturamos los motores)
  // Buscamos el valor absoluto más alto
  float maxVal = max(abs(fl), max(abs(fr), max(abs(rl), abs(rr))));
  
  // Si alguno se pasa de 1.0, dividimos todos por ese máximo
  if (maxVal > 1.0) {
    fl /= maxVal;
    fr /= maxVal;
    rl /= maxVal;
    rr /= maxVal;
  }

  // 3. Enviar a los servos
  escribirServo(servoFL, fl);
  escribirServo(servoFR, fr);
  escribirServo(servoRL, rl);
  escribirServo(servoRR, rr);
}

void escribirServo(Servo &s, float val) {
  // Mapeamos -1.0 a 1000us y 1.0 a 2000us
  // 1500us es el punto neutro (stop)
  // A veces hay que invertir (val * -500) si la rueda gira al revés
  int pwm = 1500 + (val * 500);
  s.writeMicroseconds(pwm);
}

void stopRobot() {
  moverMecanum(0, 0, 0);
}

loop de demostración

Vamos a realizar la maniobra reina de las Mecanum: El cuadrado sin girar. El robot dibujará un cuadrado en el suelo manteniendo siempre el “frente” mirando al mismo sitio.

void loop() {
  // 1. Adelante
  moverMecanum(0, 1.0, 0); 
  delay(1000);
  
  // 2. Desplazamiento lateral Derecha (Strafe Right)
  moverMecanum(1.0, 0, 0);
  delay(1000);
  
  // 3. Atrás
  moverMecanum(0, -1.0, 0);
  delay(1000);
  
  // 4. Desplazamiento lateral Izquierda (Strafe Left)
  moverMecanum(-1.0, 0, 0);
  delay(1000);
  
  // 5. Giro sobre su eje (Spin)
  moverMecanum(0, 0, 1.0);
  delay(2000);
  
  stopRobot();
  delay(2000);
}

Solución de problemas frecuentes

En este proyecto, el 99% de los fallos son físicos.

1. El robot no se mueve de lado, gira raro: Has montado las ruedas mal. Recuerda la regla de la X. Los rodillos deben apuntar al centro del chasis. Si forman una “O” (rombo), el robot no funcionará bien.
2. Una rueda no gira o el Arduino se reinicia: Falta de corriente. 4 servos consumen mucho. Revisa tus baterías y el grosor de los cables de alimentación.
3. El robot se va de lado cuando quiero ir recto: Los servos de rotación continua no son precisos. Seguramente uno gira un poco más rápido que otro. Tendrás que ajustar los valores en el código (multiplicando por un factor de corrección, ej: fr * 0.95).