Construye un Robot Arduino con Ruedas Mecanum: Movilidad 360° Guía DIY

En este tutorial aprenderemos a construir un Robot Arduino con Ruedas Mecanum capaz de moverse en cualquier dirección. Esta movilidad única del robot se logra usando un tipo especial de ruedas, llamadas Ruedas Mecanum.

Puedes ver el siguiente video o leer el tutorial escrito a continuación.

Resumen

En realidad diseñé e imprimí en 3D estas ruedas porque pueden ser un poco caras para comprar. Funcionan bastante bien y debo decir que conducir esta plataforma robot es muy divertido. Podemos controlar el robot de forma inalámbrica usando los módulos transceptores de radio NRF24L01, o en mi caso, estoy usando mi Transmisor RC DIY que hice en uno de mis videos anteriores.

Construye un Robot Arduino con Ruedas Mecanum: Movilidad 360° Guía DIY

También hice posible controlarlo usando un smartphone vía comunicación Bluetooth. Hice una aplicación Android personalizada a través de la cual podemos controlar el robot de ruedas Mecanum para moverse en cualquier dirección. También, usando el slider en la app podemos controlar la velocidad de movimiento.

El cerebro de esta plataforma robot es una placa Arduino Mega que controla cada rueda individualmente. Cada rueda está acoplada a un motor paso a paso NEMA 17, y sabiendo que los motores paso a paso pueden controlarse con precisión, agregué una característica más genial en la app a través de la cual podemos programar el robot para moverse automáticamente. Usando el botón Guardar (Save) podemos guardar cada posición o paso y luego el robot puede ejecutar y repetir estos pasos automáticamente. Con el mismo botón también podemos pausar la operación automática, así como reiniciar o borrar todos los pasos para poder almacenar nuevos.

Modelo 3D Robot Ruedas Mecanum

Para comenzar, diseñé este robot de ruedas Mecanum usando un software de modelado 3D. La plataforma base de este robot es una caja simple que haré con tableros MDF de 8mm de espesor.

Los cuatro motores paso a paso se sujetan a esta plataforma y las ruedas Mecanum se sujetan a los ejes de los motores.

Puedes encontrar y descargar este modelo 3D, así como explorarlo en tu navegador en Thangs.

Descarga el modelo 3D de ensamblaje desde Thangs.

Archivos STL para Impresión 3D:

Cómo Funcionan las Ruedas Mecanum

Una rueda Mecanum es una rueda con rodillos unidos a su circunferencia. Estos rodillos están posicionados diagonalmente o en un ángulo de 45 grados respecto al eje de rotación de la rueda. Esto hace que la rueda ejerza fuerza en dirección diagonal al moverse hacia adelante o hacia atrás.

Así, al rotar las ruedas en cierto patrón, utilizamos estas fuerzas diagonales y así el robot puede moverse en cualquier dirección.

También debemos notar aquí que necesitamos dos tipos de ruedas Mecanum, a menudo referidas como ruedas Mecanum zurdas y diestras. La diferencia entre ellas es la orientación de los rodillos y deben instalarse en el robot en ubicaciones específicas. El eje de rotación del rodillo superior de cada rueda debe apuntar hacia el centro del robot.

Aquí tienes una demostración rápida de cómo se mueve el robot dependiendo de la dirección de rotación de las ruedas.

Si las cuatro ruedas giran hacia adelante, el movimiento resultante del robot será hacia adelante, y viceversa, si todas las ruedas giran hacia atrás el robot se moverá hacia atrás. Para moverse a la derecha, las ruedas derechas necesitan rotar hacia dentro del robot, mientras que las ruedas izquierdas necesitan rotar hacia fuera del robot. La fuerza resultante debido a los rodillos posicionados diagonalmente hará que el robot se mueva a la derecha. Lo mismo pero opuesto ocurre al moverse a la izquierda. Con estas ruedas también podemos lograr movimiento en dirección diagonal rotando solo dos ruedas.

Construcción del Robot Mecanum

Sin embargo, ahora déjame mostrarte cómo construí esta plataforma robot. Como mencioné, para hacer la base de la plataforma estoy usando tableros MDF de 8mm de espesor. Usando una sierra de mesa, primero corté todas las piezas según las dimensiones del modelo 3D.

Luego, usando una broca de 3mm y una broca Forstner de 25mm hice las aberturas en los paneles laterales para sujetar los motores paso a paso. Una vez que tuve las piezas listas, continué ensamblando. Usé pegamento para madera y algunos tornillos para asegurarlos. Lo más importante aquí es tener las aberturas para los motores hechas con precisión para que todas las ruedas tengan contacto uniforme con la superficie más tarde.

Por supuesto, también podrías imprimir en 3D esta plataforma base, en lugar de hacerla con MDF, así que incluiré un archivo 3D de ella en el artículo del sitio web. Finalmente, pinté la base y su tapa con pintura en spray blanca.

Luego están las ruedas Mecanum. Como dije antes, estas ruedas pueden ser un poco caras de comprar, así que por eso decidí diseñar e imprimir en 3D las mías propias. Las ruedas están hechas de dos partes, lado exterior e interior, que se aseguran juntas con algunos tornillos M4 y tuercas. Tienen 10 rodillos cada una, y un acoplador de eje diseñado específicamente para ajustarse a un motor paso a paso NEMA 17.

Imprimí en 3D todas las partes para las ruedas Mecanum usando mi impresora 3D Creality CR-10.

Aquí tienes un enlace a esta impresora 3D por si quieres echarle un vistazo.

Así que, una vez tuve las piezas impresas en 3D listas, pasé a hacer los ejes para los rodillos. Para ese propósito, usé alambre de acero de 3mm de espesor. La longitud de los ejes necesita ser de alrededor de 40mm, así que usando una herramienta rotativa corté el alambre a esa longitud.

Empecé a ensamblar la rueda Mecanum asegurando los dos lados y el acoplador de eje usando cuatro tornillos M4 y tuercas. La longitud de los tornillos necesita ser de 45mm.

Para instalar los rodillos, primero necesitamos insertar ligeramente el eje a través de los agujeros ubicados en la circunferencia del lado interior.

Luego podemos insertar una arandela M3 pequeña, insertar el rodillo y empujar el eje todo el camino hasta la ranura del lado exterior de la rueda. Usé una sola arandela porque no tenía suficiente espacio para insertar una segunda arandela en el otro lado.

Repetí este proceso para los 10 rodillos. En realidad es fácil y bastante divertido ensamblar estas ruedas. Lo importante aquí es que los rodillos necesitan poder moverse libremente.

Al final usé unas gotas de pegamento AC en cada uno de los agujeros interiores para asegurar que los ejes no se aflojen.

Ok, así que una vez que las ruedas están listas, ahora podemos pasar a ensamblar el robot completo. Primero, necesitamos sujetar los motores paso a paso a la plataforma base. Para asegurarlos en su lugar usé tornillos M3 con longitud de 12mm.

Luego, necesitamos sujetar las ruedas a los ejes de los motores. El acoplador de eje que hice tiene una ranura para insertar una tuerca M3, a través de la cual un tornillo M3 puede pasar y así podemos asegurar la rueda al eje.

Luego, para asegurar la tapa superior a la base, sujeté varillas roscadas en dos esquinas de la base. Hice agujeros en la misma posición en la tapa y así pude insertar y asegurar fácilmente la tapa a la base.

En el lado trasero de la base hice un agujero de 20mm para sujetar un interruptor de encendido más tarde, así como un agujero de 5mm para un LED.

Diagrama de Circuito

Ahora podemos pasar a la electrónica. Aquí tienes el diagrama de circuito completo de este proyecto.

Así que controlaremos los cuatro motores paso a paso NEMA 17 usando cuatro drivers de paso a paso DRV8825, o también podríamos usar los drivers A4988. Para alimentar los steppers y todo el robot usaremos una fuente de 12V, y en mi caso usaré una batería Li-Po 3S que proporciona alrededor de 12V. Para la comunicación por radio usamos el módulo NRF24L01, y para la comunicación Bluetooth usamos el módulo HC-05. También incluí un divisor de voltaje simple que se usará para monitorear el voltaje de la batería y una conexión de LED para indicar cuando el voltaje de la batería caiga por debajo de 11V.

También incluí un regulador de voltaje dedicado de 5V que puede proporcionar alrededor de 3A de corriente. Esto es opcional, pero estoy planeando en un video futuro combinar este proyecto con mi proyecto de Brazo Robótico Arduino, y para ese propósito necesitaría 5V para impulsar sus servomotores.

Componentes Electrónicos Necesarios

Motor Paso a Paso – NEMA 17
Driver DRV8825
Módulo Transceptor NRF24L01
Módulo Bluetooth HC-05
Batería Li-Po
Placa Arduino Mega

Diseño del PCB

Sin embargo, para mantener los componentes electrónicos organizados y deshacernos del lío de cables, diseñé un PCB personalizado usando el software gratuito de diseño de circuitos en línea EasyEDA. Este PCB actuará realmente como un shield para Arduino MEGA porque podremos conectarlo directamente encima de la placa Arduino Mega. Usé tanto la capa superior como la inferior para las conexiones. Para esos pines de Arduino que no usé, incluí conexiones de headers de pines para que estén disponibles en caso de que queramos usarlos para algo en el futuro. También incluí pines de conexión de 12V, 5V y GND, así como pines para seleccionar la resolución de microstepping de los drivers.

Aquí tienes el enlace a los archivos del proyecto de este diseño de PCB. Una vez terminé el diseño, generé el archivo Gerber necesario para la fabricación del PCB.

Archivo Gerber:

Luego pedí el PCB a JLCPCB, que también son los patrocinadores de este video.

Aquí simplemente arrastramos y soltamos el archivo Gerber y una vez subido, podemos revisar nuestro PCB en el visor Gerber. Si todo está bien, podemos continuar y seleccionar las propiedades que queremos para nuestro PCB. Esta vez elegí el color del PCB azul para que coincida con el color de la placa Arduino. Y listo, ahora podemos simplemente pedir nuestro PCB a un precio razonable. Ten en cuenta que si es tu primer pedido en JLCPCB, puedes conseguir hasta 10 PCBs por solo $2.

Después de varios días, los PCBs han llegado. La calidad de los PCBs es excelente y todo es exactamente igual que en el diseño.

Montaje del PCB

Ok, ahora podemos pasar a montar el PCB. Empecé soldando los componentes más pequeños primero, las resistencias y los capacitores. Luego inserté y soldé headers de pines macho al PCB que se usarán para conectarlo a la placa Arduino.

Luego, coloqué todos los headers de pines hembra en su lugar y los soldé también. Para las conexiones de los motores paso a paso y pines para seleccionar la resolución de microstepping usé headers de pines macho. De esta forma podemos conectar directamente los motores al PCB y usar jumpers para seleccionar la resolución de microstepping. Luego soldé los bornes de tornillo, el potenciómetro y el regulador de voltaje.

¡Y eso es todo, el PCB ahora está listo y podemos pasar a insertar los drivers y conectar los motores a él! Primero, puse los jumpers para seleccionar la resolución de microstepping. Seleccioné resolución de 1/16 de paso conectando los pines MS3 de los drivers a 5V.

Luego, encima de ellos coloqué los drivers DRV8825, así como conecté el módulo NRF24L01 y el módulo Bluetooth HC-05. Ahora podemos simplemente sujetar el PCB a la placa Arduino.

Luego, conecté la batería al borne apropiado y la coloqué dentro de la plataforma base.

Aquí inserté el interruptor de encendido en su lugar y lo conecté al otro borne. Justo encima del interruptor de encendido también inserté el LED indicador de batería.

Lo que queda ahora es conectar los motores al PCB. Debemos notar aquí que al conectar motores opuestos, también debemos conectar sus conectores de forma opuesta. Esto es necesario luego al programar el robot, para que, por ejemplo, el comando de adelante mueva ambos motores en la misma dirección, aunque en realidad están volteados y uno haría rotación en sentido horario y el otro antihorario.

Al final puedo simplemente insertar la tapa en la parte superior, y así terminamos con este proyecto de robot de ruedas Mecanum.

Código Arduino Robot Ruedas Mecanum

Lo que queda para este video es echar un vistazo al código Arduino. En realidad, hay dos códigos Arduino separados. Este es para controlar el robot usando los módulos NRF24L01 y el otro es para controlar el robot usando un smartphone.

Código Arduino para Control por Radio NRF24L01

/* === Arduino Mecanum Wheels Robot === Radio control with NRF24L01 by Dejan, www.HowToMechatronics.com Libraries: RF24, https://github.com/tmrh20/RF24/ AccelStepper by Mike McCauley: https://www.airspayce.com/mikem/arduino/AccelStepper/index.html */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <AccelStepper.h>
RF24 radio(48, 49); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
// Definir los motores paso a paso y los pines que usarán
AccelStepper LeftBackWheel(1, 42, 43); // (Tipo:driver, STEP, DIR) - Stepper1
AccelStepper LeftFrontWheel(1, 40, 41); // Stepper2
AccelStepper RightBackWheel(1, 44, 45); // Stepper3
AccelStepper RightFrontWheel(1, 46, 47); // Stepper4
int wheelSpeed = 1500;
// Tamaño máximo de esta estructura es 32 bytes - límite buffer NRF24L01
struct Data_Package {
  byte j1PotX;
  byte j1PotY;
  byte j1Button;
  byte j2PotX;
  byte j2PotY;
  byte j2Button;
  byte pot1;
  byte pot2;
  byte tSwitch1;
  byte tSwitch2;
  byte button1;
  byte button2;
  byte button3;
  byte button4;
};
Data_Package data; // Crear una variable con la estructura anterior
void setup() {
  // Establecer valores iniciales de velocidad para los steppers
  LeftFrontWheel.setMaxSpeed(3000);
  LeftBackWheel.setMaxSpeed(3000);
  RightFrontWheel.setMaxSpeed(3000);
  RightBackWheel.setMaxSpeed(3000);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  radio.startListening(); // Configurar el módulo como receptor
  Serial.begin(115200);
}
void loop() {
  // Verificar si seguimos recibiendo datos, o si tenemos conexión entre los dos módulos
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) {
    // Si el tiempo actual es más de 1 segundo desde que recibimos el último dato, significa que perdimos conexión
    resetData(); // Si se pierde la conexión, reiniciar los datos. Evita comportamiento no deseado
  }
  // Verificar si hay datos para recibir
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Leer todos los datos y almacenarlos en la estructura 'data'
    lastReceiveTime = millis(); // En este momento hemos recibido los datos
  }
  // Establecer velocidad - potenciómetro izquierdo
  wheelSpeed = map(data.pot1, 0, 255, 100, 3000);
  if (data.j1PotX > 150) { moveSidewaysLeft(); }
  else if (data.j1PotX < 100) { moveSidewaysRight(); }
  else if (data.j1PotY > 160) { moveForward(); }
  else if (data.j1PotY < 100) { moveBackward(); }
  else if (data.j2PotX < 100 & data.j2PotY > 160) { moveRightForward(); }
  else if (data.j2PotX > 160 & data.j2PotY > 160) { moveLeftForward(); }
  else if (data.j2PotX < 100 & data.j2PotY < 100) { moveRightBackward(); }
  else if (data.j2PotX > 160 & data.j2PotY < 100) { moveLeftBackward(); }
  else if (data.j2PotX < 100) { rotateRight(); }
  else if (data.j2PotX > 150) { rotateLeft(); }
  else { stopMoving(); }
  // Ejecutar los pasos
  LeftFrontWheel.runSpeed();
  LeftBackWheel.runSpeed();
  RightFrontWheel.runSpeed();
  RightBackWheel.runSpeed();
  // Monitorizar voltaje de batería
  int sensorValue = analogRead(A0);
  float voltage = sensorValue * (5.0 / 1023.00) * 3; // Convertir lectura de 5V a 12V aprox
  // Si voltaje es inferior a 11V encender LED
  if (voltage < 11) { digitalWrite(led, HIGH); }
  else { digitalWrite(led, LOW); }
}
void moveForward() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}
void moveBackward() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void moveSidewaysRight() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}
void moveSidewaysLeft() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void rotateLeft() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}
void rotateRight() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void moveRightForward() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(wheelSpeed);
}
void moveRightBackward() {
  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(0);
}
void moveLeftForward() {
  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(0);
}
void moveLeftBackward() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void stopMoving() {
  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(0);
}
void resetData() {
  // Reiniciar valores cuando no hay conexión de radio - Establecer valores iniciales por defecto
  data.j1PotX = 127;
  data.j1PotY = 127;
  data.j2PotX = 127;
  data.j2PotY = 127;
  data.j1Button = 1;
  data.j2Button = 1;
  data.pot1 = 1;
  data.pot2 = 1;
  data.tSwitch1 = 1;
  data.tSwitch2 = 1;
  data.button1 = 1;
  data.button2 = 1;
  data.button3 = 1;
  data.button4 = 1;
}Code language: Arduino (arduino)

Descripción: Así que, aquí estamos usando la librería RF24 para la comunicación por radio y la librería AccelStepper para controlar los motores paso a paso. Primero necesitamos definir los pines a los que todos están conectados, definir algunas variables necesarias para el programa a continuación, y en la sección setup establecer la velocidad máxima de los steppers e iniciar la comunicación por radio.

En la sección loop empezamos leyendo los datos que vienen del transmisor RC. El código del transmisor RC así como más detalles de cómo funciona esta comunicación se pueden encontrar en mi tutorial particular para ello.

Así que dependiendo de los datos recibidos, por ejemplo, si el Joystick izquierdo se mueve hacia adelante, su valor será mayor que 160 y en tal caso llamaremos a la función personalizada moveForward(). Si echamos un vistazo a esta función, vemos que todo lo que hace es establecer la velocidad de los motores a positivo. Para mover hacia atrás, la velocidad se establece en negativo. Así que para moverse en todas las otras direcciones solo tenemos que establecer las rotaciones de las ruedas apropiadamente como se explicó al principio.

Para ejecutar estos comandos, en la sección loop necesitamos llamar a las funciones runSpeed() para todos los steppers. En la sección loop también leemos la entrada analógica del divisor de voltaje que viene de la batería, y según este valor podemos saber cuándo el voltaje de la batería caerá por debajo de 11V para encender el LED indicador.

Código Arduino para Control por Smartphone (Bluetooth)

/* === Arduino Mecanum Wheels Robot === Smartphone control via Bluetooth by Dejan, www.HowToMechatronics.com Libraries: RF24, https://github.com/tmrh20/RF24/ AccelStepper by Mike McCauley: https://www.airspayce.com/mikem/arduino/AccelStepper/index.html */
#include <SoftwareSerial.h>
#include <AccelStepper.h>
SoftwareSerial Bluetooth(A8, 38); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)
// Definir los motores paso a paso y los pines que usarán
AccelStepper LeftBackWheel(1, 42, 43); // (Tipo:driver, STEP, DIR) - Stepper1
AccelStepper LeftFrontWheel(1, 40, 41); // Stepper2
AccelStepper RightBackWheel(1, 44, 45); // Stepper3
AccelStepper RightFrontWheel(1, 46, 47); // Stepper4
#define led 14
int wheelSpeed = 1500;
int dataIn, m;
int lbw[50], lfw[50], rbw[50], rfw[50]; // para almacenar posiciones/pasos
int index = 0;
void setup() {
  // Establecer valores iniciales de velocidad para los steppers
  LeftFrontWheel.setMaxSpeed(3000);
  LeftBackWheel.setMaxSpeed(3000);
  RightFrontWheel.setMaxSpeed(3000);
  RightBackWheel.setMaxSpeed(3000);
  Serial.begin(38400);
  Bluetooth.begin(38400); // Baud rate por defecto del módulo Bluetooth
  Bluetooth.setTimeout(1);
  delay(20);
  pinMode(led, OUTPUT);
}
void loop() {
  // Verificar datos entrantes
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.read(); // Leer el dato
    if (dataIn == 0) { m = 0; }
    if (dataIn == 1) { m = 1; }
    if (dataIn == 2) { m = 2; }
    if (dataIn == 3) { m = 3; }
    if (dataIn == 4) { m = 4; }
    if (dataIn == 5) { m = 5; }
    if (dataIn == 6) { m = 6; }
    if (dataIn == 7) { m = 7; }
    if (dataIn == 8) { m = 8; }
    if (dataIn == 9) { m = 9; }
    if (dataIn == 10) { m = 10; }
    if (dataIn == 11) { m = 11; }
    if (dataIn == 12) { m = 12; }
    if (dataIn == 14) { m = 14; }
    // Establecer velocidad
    if (dataIn >= 16) {
      wheelSpeed = dataIn * 10;
      Serial.println(wheelSpeed);
    }
  }
  if (m == 4) { moveSidewaysLeft(); }
  if (m == 5) { moveSidewaysRight(); }
  if (m == 2) { moveForward(); }
  if (m == 7) { moveBackward(); }
  if (m == 3) { moveRightForward(); }
  if (m == 1) { moveLeftForward(); }
  if (m == 8) { moveRightBackward(); }
  if (m == 6) { moveLeftBackward(); }
  if (m == 9) { rotateLeft(); }
  if (m == 10) { rotateRight(); }
  if (m == 0) { stopMoving(); }
  //Serial.println(dataIn);
  // Si se presiona botón "SAVE"
  if (m == 12) {
    if (index == 0) {
      LeftBackWheel.setCurrentPosition(0);
      LeftFrontWheel.setCurrentPosition(0);
      RightBackWheel.setCurrentPosition(0);
      RightFrontWheel.setCurrentPosition(0);
    }
    lbw[index] = LeftBackWheel.currentPosition(); // guardar posición en array
    lfw[index] = LeftFrontWheel.currentPosition();
    rbw[index] = RightBackWheel.currentPosition();
    rfw[index] = RightFrontWheel.currentPosition();
    index++; // Incrementar índice del array
    m = 0;
  }
  if (m == 14) {
    runSteps();
    if (dataIn != 14) {
      stopMoving();
      memset(lbw, 0, sizeof(lbw)); // Limpiar datos del array a 0
      memset(lfw, 0, sizeof(lfw));
      memset(rbw, 0, sizeof(rbw));
      memset(rfw, 0, sizeof(rfw));
      index = 0; // Índice a 0
    }
  }
  LeftFrontWheel.runSpeed();
  LeftBackWheel.runSpeed();
  RightFrontWheel.runSpeed();
  RightBackWheel.runSpeed();
  // Monitorizar voltaje de batería
  int sensorValue = analogRead(A0);
  float voltage = sensorValue * (5.0 / 1023.00) * 3; // Convertir lectura de 5V a 12V aprox
  //Serial.println(voltage);
  // Si voltaje es inferior a 11V encender LED
  if (voltage < 11) {
    digitalWrite(led, HIGH);
  } else {
    digitalWrite(led, LOW);
  }
}
void runSteps() {
  for (int i = index - 1; i >= 0; i--) {
    // Recorrer todos los pasos(index)
    LeftFrontWheel.moveTo(lfw[i]);
    LeftFrontWheel.setSpeed(wheelSpeed);
    LeftBackWheel.moveTo(lbw[i]);
    LeftBackWheel.setSpeed(wheelSpeed);
    RightFrontWheel.moveTo(rfw[i]);
    RightFrontWheel.setSpeed(wheelSpeed);
    RightBackWheel.moveTo(rbw[i]);
    RightBackWheel.setSpeed(wheelSpeed);
    while (LeftBackWheel.currentPosition() != lbw[i] & LeftFrontWheel.currentPosition() != lfw[i] & RightFrontWheel.currentPosition() != rfw[i] & RightBackWheel.currentPosition() != rbw[i]) {
      LeftFrontWheel.runSpeedToPosition();
      LeftBackWheel.runSpeedToPosition();
      RightFrontWheel.runSpeedToPosition();
      RightBackWheel.runSpeedToPosition();
      if (Bluetooth.available() > 0) {
        // Verificar datos entrantes
        dataIn = Bluetooth.read();
        if ( dataIn == 15) {
          // Si se presiona botón "PAUSE"
          while (dataIn != 14) {
            // Esperar hasta que se presione "RUN" de nuevo
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.read();
              if ( dataIn == 13) {
                stopMoving();
                break;
              }
            }
          }
        }
        if (dataIn >= 16) {
          wheelSpeed = dataIn * 10;
          dataIn = 14;
        }
        if ( dataIn == 13) { break; }
      }
    }
  }
  // Volver a recorrer pasos en sentido inverso
  for (int i = 1; i <= index - 1; i++) {
    // Recorrer todos los pasos(index)
    LeftFrontWheel.moveTo(lfw[i]);
    LeftFrontWheel.setSpeed(wheelSpeed);
    LeftBackWheel.moveTo(lbw[i]);
    LeftBackWheel.setSpeed(wheelSpeed);
    RightFrontWheel.moveTo(rfw[i]);
    RightFrontWheel.setSpeed(wheelSpeed);
    RightBackWheel.moveTo(rbw[i]);
    RightBackWheel.setSpeed(wheelSpeed);
    while (LeftBackWheel.currentPosition() != lbw[i]& LeftFrontWheel.currentPosition() != lfw[i] & RightFrontWheel.currentPosition() != rfw[i] & RightBackWheel.currentPosition() != rbw[i]) {
      LeftFrontWheel.runSpeedToPosition();
      LeftBackWheel.runSpeedToPosition();
      RightFrontWheel.runSpeedToPosition();
      RightBackWheel.runSpeedToPosition();
      //Serial.print(" current: ");
      //Serial.println(LeftBackWheel.currentPosition());
      if (Bluetooth.available() > 0) {
        // Verificar datos entrantes
        dataIn = Bluetooth.read();
        if ( dataIn == 15) {
          // Si se presiona botón "PAUSE"
          while (dataIn != 14) {
            // Esperar hasta que se presione "RUN" de nuevo
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.read();
              if ( dataIn == 13) {
                stopMoving();
                break;
              }
            }
          }
        }
        if (dataIn >= 16) {
          wheelSpeed = dataIn * 10;
          dataIn = 14;
        }
        if ( dataIn == 13) {
          //Serial.println("DEKI");
          break;
        }
      }
    }
  }
}
void moveForward() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}
void moveBackward() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void moveSidewaysRight() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}
void moveSidewaysLeft() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void rotateLeft() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}
void rotateRight() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void moveRightForward() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(wheelSpeed);
}
void moveRightBackward() {
  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(0);
}
void moveLeftForward() {
  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(0);
}
void moveLeftBackward() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void stopMoving() {
  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(0);
}Code language: Arduino (arduino)

Descripción: El otro código para controlar el robot usando la aplicación Android, es muy similar y funciona de la misma manera. Aquí en lugar del módulo de radio necesitamos definir el módulo Bluetooth e inicializar su comunicación en la sección setup. Así que de nuevo, primero leemos los datos entrantes del smartphone o la app Android, y según eso, decimos al robot en qué dirección moverse.

Si echamos un vistazo a la app Android, podemos ver que simplemente envía números del 0 al 15 a través del Bluetooth cuando se presionan los botones.

La app está hecha usando la aplicación en línea MIT App Inventor y puedes encontrar más detalles sobre ella en mi tutorial particular para ello.

Aquí puedes descargar esta app así como el archivo de proyecto editable:

Para programar el movimiento automático del robot con esta app, cuando presionamos el botón "SAVE" simplemente almacenamos las posiciones actuales de los motores paso a paso en arrays. Luego, cuando presionamos el botón "RUN", llamamos a la función personalizada runSteps() que ejecuta o recorre todos los pasos almacenados usando algunos bucles for y while.

Espero que hayas disfrutado este tutorial y hayas aprendido algo nuevo. Siéntete libre de hacer cualquier pregunta en la sección de comentarios a continuación y revisa mi Colección de Proyectos Arduino.