home Tecnología de fabricación Equipo de fabricación
Manufactura industrial
Internet industrial de las cosas | Materiales industriales | Mantenimiento y reparación de equipos | Programación industrial |
home  MfgRobots >> Manufactura industrial >  >> Manufacturing Technology >> Proceso de manufactura

Arduino Robot Arm and Mecanum Wheels Platform Operación automática

En este tutorial, le mostraré cómo hice mi plataforma de robot de ruedas Mecanum de mi video anterior, para trabajar en conjunto y operar automáticamente con mi brazo robótico impreso en 3D, también un proyecto Arduino de uno de mis videos anteriores.

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

Resumen

Entonces, podemos controlar el robot de ruedas Mecanum con la aplicación de Android personalizada de la misma manera que se explica en el video anterior. Además de eso, ahora la aplicación también tiene botones para controlar el brazo robótico.

La aplicación de control del brazo del robot original en realidad tenía controles deslizantes para controlar las articulaciones del robot, pero eso estaba causando algunos problemas con la estabilidad del brazo. De esta forma, el brazo funciona mucho mejor, por lo que también proporcionaré esta versión actualizada de la aplicación de control del brazo robótico y el código Arduino al proyecto original del brazo robótico.

Sin embargo, la característica más interesante de este robot es la capacidad de almacenar los movimientos y luego repetirlos automáticamente.

Usando el botón Guardar, simplemente podemos almacenar las posiciones de los motores para cada paso. Luego, solo debemos hacer clic en el botón Ejecutar y el robot repetirá automáticamente los movimientos almacenados una y otra vez.

Construyendo el Robot Arduino

Bien, aquí tengo la plataforma de ruedas Mecanum ya ensamblada y puedes encontrar todos los detalles al respecto en mi video anterior.

Además, aquí tengo las partes impresas en 3D del brazo robótico y los servomotores y ahora les mostraré cómo ensamblarlos. Aquí está el modelo 3D de este proyecto.

Puede buscar y descargar este modelo 3D, así como explorarlo en su navegador en Thangs.

Descarga el modelo 3D en Thangs.

Archivos STL para impresión 3D:

El primer servo del brazo robótico se montará directamente en la cubierta superior de la plataforma de ruedas mecanum.

Marqué la ubicación y con un taladro de 10 mm hice varios agujeros.

Luego, usando una escofina, corté los agujeros y luego ajusté la apertura para el servo. Aseguré el servo a la placa superior con cuatro pernos y tuercas M3.

Luego, en este eje de salida de este servo, usando la bocina redonda que viene como accesorio con el servo, debemos unir la siguiente parte o la cintura del brazo del robot. Sin embargo, podemos notar que de esta manera la pieza queda unos 8 mm por encima de la placa. Por lo tanto, coloqué dos piezas de tableros MDF de 8 mm, para que la parte de la cintura pueda deslizarse sobre ellos y la unión sea más estable.

La bocina redonda se asegura a la parte de la cintura usando los tornillos autorroscantes que vienen como accesorios con el servo, y luego la bocina redonda se asegura al eje del servo usando los pernos apropiados que también vienen con el servo.

A continuación tenemos el servo de hombro. Simplemente lo colocamos en su lugar y lo aseguramos a la pieza impresa en 3D con tornillos autorroscantes.

La bocina redonda va en la siguiente parte, y luego las dos partes se aseguran entre sí mediante un perno en el eje de salida del servo.

Debemos tener en cuenta que antes de asegurar las piezas, debemos asegurarnos de que la pieza tenga el rango completo de movimiento. Aquí también agregué una banda elástica a la articulación del hombro para que ayude un poco al servo, porque este servo soporta el peso del resto del brazo, así como la carga útil.

De manera similar, ensamblé el resto del brazo robótico.

A continuación, debemos ensamblar el mecanismo de agarre. La pinza se controla con un servomotor SG90, en el que, primero, conectamos un eslabón de engranaje diseñado a medida. Emparejamos este eslabón con otro eslabón dentado en el otro lado, que se asegura con pernos y tuercas M4. En realidad, todos los demás enlaces se conectan con pernos y tuercas M4.

El modelo 3D de la pinza originalmente tenía orificios de 3 mm, pero no tenía suficientes pernos M3, por lo que expandí los orificios con un taladro de 4 mm y usé pernos M4 en su lugar.

Una vez que ensamblé el mecanismo de agarre, lo aseguré al último servo y así se completó el brazo del robot.

A continuación hice un poco de gestión de cables. Pasé los cables del servo a través de los orificios diseñados específicamente del brazo del robot. Usando un taladro de 10 mm, hice un agujero en la placa superior para que los cables puedan pasar.

Usando una brida, aseguré todos los cables juntos, y ahora lo que queda es conectarlos a la placa Arduino.

Diagrama del circuito del robot Arduino

Aquí está el diagrama de circuito de este proyecto y cómo se debe conectar todo.

Puede obtener los componentes necesarios para este proyecto en los siguientes enlaces:

  • Motor paso a paso:NEMA 17 …………..…
  • Controlador paso a paso DRV8825 ……….…….…
  • Servomotor MG996R…………………….….
  • Microservomotor SG90 …………….….
  • Módulo Bluetooth HC-05 …………….… 
  • Batería Li-Po ……………………………….…… 
  • Megaplaca Arduino ………….………….…

En el tutorial anterior, expliqué cómo funciona la parte del robot de ruedas Mecanum y también les mostré cómo hice una placa de circuito impreso personalizada para él.

Incluí un regulador de voltaje de 5V en esta PCB para que podamos hacer este proyecto, o conectar los servomotores porque funcionan a 5V. El regulador de voltaje es el LM350, que puede manejar hasta 3 amperios de corriente. Los seis servos del brazo robótico pueden consumir alrededor de 2 amperios a 3 amperios de corriente, lo que significa que puede manejarlos, pero eso hará que el regulador se caliente mucho.

Por lo tanto, le adjunté un disipador de calor, así como un pequeño ventilador de CC de 12 V para soplar un poco de aire, porque el disipador de calor en sí mismo no era suficiente para enfriar el regulador.

Conecté los cables de señal de los servos a los pines digitales de Arduino del número 5 al 10, y para encender usé el cabezal de pines de 5V en la PCB. Finalmente, empujé todos los cables dentro de la plataforma y aseguré la placa superior con las dos tuercas.

Y eso es todo, ahora hemos terminado con este proyecto.

Código Arduino

Lo que queda es echar un vistazo a cómo funciona el código Arduino y la aplicación de Android. Como el código es un poco más largo, para una mejor comprensión, publicaré el código fuente del programa en secciones con descripción para cada sección. Y al final de este artículo publicaré el código fuente completo.

Entonces, primero debemos definir los 6 servos, los 4 motores paso a paso y la comunicación Bluetooth, así como definir algunas variables necesarias para el programa a continuación. En la sección de configuración establecemos la velocidad máxima de los motores paso a paso, definimos los pines a los que se conectan los servos, comenzamos la comunicación Bluetooth y colocamos el brazo del robot en la posición inicial.

#include <SoftwareSerial.h>
#include <AccelStepper.h>
#include <Servo.h>

Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;

SoftwareSerial Bluetooth(A8, 38); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)

// Define the stepper motors and the pins the will use
AccelStepper LeftBackWheel(1, 42, 43);   // (Type: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 lbw[50], lfw[50], rbw[50], rfw[50]; // arrays for storing positions/steps

int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // current position
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // previous position
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // for storing positions/steps
int speedDelay = 20;
int index = 0;
int dataIn;
int m = 0;

void setup() {
  // Set initial seed values for the steppers
  LeftFrontWheel.setMaxSpeed(3000);
  LeftBackWheel.setMaxSpeed(3000);
  RightFrontWheel.setMaxSpeed(3000);
  RightBackWheel.setMaxSpeed(3000);
  pinMode(led, OUTPUT);
  servo01.attach(5);
  servo02.attach(6);
  servo03.attach(7);
  servo04.attach(8);
  servo05.attach(9);
  servo06.attach(10);
  Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
  Bluetooth.setTimeout(5);
  delay(20);
  Serial.begin(38400);
  // Move robot arm to initial position
  servo1PPos = 90;
  servo01.write(servo1PPos);
  servo2PPos = 100;
  servo02.write(servo2PPos);
  servo3PPos = 120;
  servo03.write(servo3PPos);
  servo4PPos = 95;
  servo04.write(servo4PPos);
  servo5PPos = 60;
  servo05.write(servo5PPos);
  servo6PPos = 110;
  servo06.write(servo6PPos);
}Code language: Arduino (arduino)

Luego, en la sección de bucle, comenzamos verificando si hay datos entrantes.

// Check for incoming data
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.read();  // Read the dataCode language: Arduino (arduino)

Estos datos provienen del teléfono inteligente o de la aplicación de Android, así que echemos un vistazo al tipo de datos que realmente envía. La aplicación de Android se realiza utilizando la aplicación en línea MIT App Inventor. Consiste en botones simples que tienen imágenes apropiadas como fondo.

Si echamos un vistazo a los bloques de la aplicación, podemos ver que todo lo que hace es enviar números de un byte cuando se hace clic en los botones.

Entonces, dependiendo del botón en el que se hizo clic, le decimos al Arduino qué hacer. Por ejemplo, si recibimos el número '2', la plataforma de ruedas mecanum se moverá hacia adelante, utilizando la función personalizada moveForward.

if (dataIn == 2) {
      m = 2;
    }
//
if (m == 2) {
      moveForward();
    }Code language: Arduino (arduino)

Esta función personalizada configura los cuatro motores paso a paso para que giren hacia adelante.

void moveForward() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}Code language: Arduino (arduino)

Para moverse en cualquier otra dirección, solo necesitamos girar las ruedas en las direcciones adecuadas.

Para controlar el brazo del robot, usamos el mismo método. Nuevamente, tenemos botones en la aplicación y cuando los mantienes presionados, las articulaciones del brazo del robot se mueven en una dirección particular.

Como mencioné anteriormente, en la aplicación de control Robot Arm original, usábamos controles deslizantes para controlar las posiciones de los servos, pero eso causaba algunos problemas porque de esa manera teníamos que enviar texto al Arduino, en lugar de un número de 1 byte. El problema es que Arduino a veces pierde el texto que proviene de la aplicación y comete un error o el brazo del robot tiembla y se comporta de manera anormal.

De esta manera, simplemente enviamos un solo número de 1 byte cuando se toca un botón en particular.

El código Arduino entra en el bucle while de ese número, y se queda allí hasta que tocamos el botón, porque en ese momento enviamos el número 0, lo que significa que el robot no debe hacer nada.

// Move servo 1 in positive direction
    while (m == 16) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo01.write(servo1PPos);
      servo1PPos++;
      delay(speedDelay);
    }
    // Move servo 1 in negative direction
    while (m == 17) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo01.write(servo1PPos);
      servo1PPos--;
      delay(speedDelay);
    }Code language: Arduino (arduino)

Entonces, dependiendo de los botones tocados, los servos se mueven en dirección positiva o negativa. El mismo principio de funcionamiento se aplica a todos los servomotores. Para cambiar la velocidad de movimiento, usamos los valores provenientes del control deslizante que van de 100 a 250.

// If arm speed slider is changed
    if (dataIn > 101 & dataIn < 250) {
      speedDelay = dataIn / 10; // Change servo speed (delay time)
    }Code language: Arduino (arduino)

Dividiéndolos por 10 obtenemos valores de 10 a 25, que se utilizan como retardo en microsegundos en los bucles while para accionar los servos.

Para almacenar los movimientos del robot, simplemente guardamos las posiciones actuales de los servos y los motores paso a paso en matrices, cada vez que se hace clic en el botón Guardar.

// If button "SAVE" is pressed
    if (m == 12) {
      //if it's initial save, set the steppers position to 0
      if (index == 0) {
        LeftBackWheel.setCurrentPosition(0);
        LeftFrontWheel.setCurrentPosition(0);
        RightBackWheel.setCurrentPosition(0);
        RightFrontWheel.setCurrentPosition(0);
      }
      lbw[index] = LeftBackWheel.currentPosition();  // save position into the array
      lfw[index] = LeftFrontWheel.currentPosition();
      rbw[index] = RightBackWheel.currentPosition();
      rfw[index] = RightFrontWheel.currentPosition();

      servo01SP[index] = servo1PPos;  // save position into the array
      servo02SP[index] = servo2PPos;
      servo03SP[index] = servo3PPos;
      servo04SP[index] = servo4PPos;
      servo05SP[index] = servo5PPos;
      servo06SP[index] = servo6PPos;
      index++;                        // Increase the array index
      m = 0;
    }Code language: Arduino (arduino)

Luego, cuando presionamos el botón Ejecutar, llamamos a la función personalizada runSteps(). Esta función personalizada ejecuta todos los pasos almacenados utilizando algunos bucles for y while.

if (m == 14) {
      runSteps();

      // If button "RESET" is pressed
      if (dataIn != 14) {
        stopMoving();
        memset(lbw, 0, sizeof(lbw)); // Clear the array data to 0
        memset(lfw, 0, sizeof(lfw));
        memset(rbw, 0, sizeof(rbw));
        memset(rfw, 0, sizeof(rfw));
        memset(servo01SP, 0, sizeof(servo01SP)); // Clear the array data to 0
        memset(servo02SP, 0, sizeof(servo02SP));
        memset(servo03SP, 0, sizeof(servo03SP));
        memset(servo04SP, 0, sizeof(servo04SP));
        memset(servo05SP, 0, sizeof(servo05SP));
        memset(servo06SP, 0, sizeof(servo06SP));
        index = 0;  // Index to 0
      }
    }Code language: Arduino (arduino)

Debemos notar que comienza desde la primera posición y va a la última posición, y lo repite una y otra vez. Por lo tanto, al guardar los pasos, necesitamos posicionar el robot de manera que el primer paso tenga la misma posición que el último paso. Mientras recorremos los pasos, también podemos cambiar la velocidad tanto de la plataforma como del brazo del robot, así como pausar y restablecer todos los pasos.

Aquí puede descargar esta aplicación, así como el archivo del proyecto editable:

Aquí está el código Arduino completo para este proyecto de robot Arduino:

/*
       Arduino Robot Arm and Mecanum Wheels Robot
          Smartphone Control via Bluetooth
       by Dejan, www.HowToMechatronics.com
*/

#include <SoftwareSerial.h>
#include <AccelStepper.h>
#include <Servo.h>

Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;

SoftwareSerial Bluetooth(A8, 38); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)

// Define the stepper motors and the pins the will use
AccelStepper LeftBackWheel(1, 42, 43);   // (Type: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 lbw[50], lfw[50], rbw[50], rfw[50]; // arrays for storing positions/steps

int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // current position
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // previous position
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // for storing positions/steps
int speedDelay = 20;
int index = 0;
int dataIn;
int m = 0;

void setup() {
  // Set initial seed values for the steppers
  LeftFrontWheel.setMaxSpeed(3000);
  LeftBackWheel.setMaxSpeed(3000);
  RightFrontWheel.setMaxSpeed(3000);
  RightBackWheel.setMaxSpeed(3000);
  pinMode(led, OUTPUT);
  servo01.attach(5);
  servo02.attach(6);
  servo03.attach(7);
  servo04.attach(8);
  servo05.attach(9);
  servo06.attach(10);
  Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
  Bluetooth.setTimeout(5);
  delay(20);
  Serial.begin(38400);
  // Move robot arm to initial position
  servo1PPos = 90;
  servo01.write(servo1PPos);
  servo2PPos = 100;
  servo02.write(servo2PPos);
  servo3PPos = 120;
  servo03.write(servo3PPos);
  servo4PPos = 95;
  servo04.write(servo4PPos);
  servo5PPos = 60;
  servo05.write(servo5PPos);
  servo6PPos = 110;
  servo06.write(servo6PPos);
}

void loop() {
  // Check for incoming data
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.read();  // Read the data

    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;
    }
    if (dataIn == 16) {
      m = 16;
    }
    if (dataIn == 17) {
      m = 17;
    }
    if (dataIn == 18) {
      m = 18;
    }
    if (dataIn == 19) {
      m = 19;
    }
    if (dataIn == 20) {
      m = 20;
    }
    if (dataIn == 21) {
      m = 21;
    }
    if (dataIn == 22) {
      m = 22;
    }
    if (dataIn == 23) {
      m = 23;
    }
    if (dataIn == 24) {
      m = 24;
    }
    if (dataIn == 25) {
      m = 25;
    }
    if (dataIn == 26) {
      m = 26;
    }
    if (dataIn == 27) {
      m = 27;
    }

    // Move the Mecanum wheels platform
    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();
    }

    // Mecanum wheels speed
    if (dataIn > 30 & dataIn < 100) {
      wheelSpeed = dataIn * 20;
    }

    // Move robot arm
    // Move servo 1 in positive direction
    while (m == 16) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo01.write(servo1PPos);
      servo1PPos++;
      delay(speedDelay);
    }
    // Move servo 1 in negative direction
    while (m == 17) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo01.write(servo1PPos);
      servo1PPos--;
      delay(speedDelay);
    }
    // Move servo 2
    while (m == 19) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo02.write(servo2PPos);
      servo2PPos++;
      delay(speedDelay);
    }
    while (m == 18) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo02.write(servo2PPos);
      servo2PPos--;
      delay(speedDelay);
    }
    // Move servo 3
    while (m == 20) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo03.write(servo3PPos);
      servo3PPos++;
      delay(speedDelay);
    }
    while (m == 21) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo03.write(servo3PPos);
      servo3PPos--;
      delay(speedDelay);
    }
    // Move servo 4
    while (m == 23) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo04.write(servo4PPos);
      servo4PPos++;
      delay(speedDelay);
    }
    while (m == 22) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo04.write(servo4PPos);
      servo4PPos--;
      delay(speedDelay);
    }
    // Move servo 5
    while (m == 25) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo05.write(servo5PPos);
      servo5PPos++;
      delay(speedDelay);
    }
    while (m == 24) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo05.write(servo5PPos);
      servo5PPos--;
      delay(speedDelay);
    }
    // Move servo 6
    while (m == 26) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo06.write(servo6PPos);
      servo6PPos++;
      delay(speedDelay);
    }
    while (m == 27) {
      if (Bluetooth.available() > 0) {
        m = Bluetooth.read();
      }
      servo06.write(servo6PPos);
      servo6PPos--;
      delay(speedDelay);
    }

    // If arm speed slider is changed
    if (dataIn > 101 & dataIn < 250) {
      speedDelay = dataIn / 10; // Change servo speed (delay time)
    }

    // If button "SAVE" is pressed
    if (m == 12) {
      //if it's initial save, set the steppers position to 0
      if (index == 0) {
        LeftBackWheel.setCurrentPosition(0);
        LeftFrontWheel.setCurrentPosition(0);
        RightBackWheel.setCurrentPosition(0);
        RightFrontWheel.setCurrentPosition(0);
      }
      lbw[index] = LeftBackWheel.currentPosition();  // save position into the array
      lfw[index] = LeftFrontWheel.currentPosition();
      rbw[index] = RightBackWheel.currentPosition();
      rfw[index] = RightFrontWheel.currentPosition();

      servo01SP[index] = servo1PPos;  // save position into the array
      servo02SP[index] = servo2PPos;
      servo03SP[index] = servo3PPos;
      servo04SP[index] = servo4PPos;
      servo05SP[index] = servo5PPos;
      servo06SP[index] = servo6PPos;
      index++;                        // Increase the array index
      m = 0;
    }

    // If button "RUN" is pressed
    if (m == 14) {
      runSteps();

      // If button "RESET" is pressed
      if (dataIn != 14) {
        stopMoving();
        memset(lbw, 0, sizeof(lbw)); // Clear the array data to 0
        memset(lfw, 0, sizeof(lfw));
        memset(rbw, 0, sizeof(rbw));
        memset(rfw, 0, sizeof(rfw));
        memset(servo01SP, 0, sizeof(servo01SP)); // Clear the array data to 0
        memset(servo02SP, 0, sizeof(servo02SP));
        memset(servo03SP, 0, sizeof(servo03SP));
        memset(servo04SP, 0, sizeof(servo04SP));
        memset(servo05SP, 0, sizeof(servo05SP));
        memset(servo06SP, 0, sizeof(servo06SP));
        index = 0;  // Index to 0
      }
    }
  }
  LeftFrontWheel.runSpeed();
  LeftBackWheel.runSpeed();
  RightFrontWheel.runSpeed();
  RightBackWheel.runSpeed();

  // Monitor the battery voltage
  int sensorValue = analogRead(A0);
  float voltage = sensorValue * (5.0 / 1023.00) * 3; // Convert the reading values from 5v to suitable 12V i
  //Serial.println(voltage);
  // If voltage is below 11V turn on the 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);
}

// Automatic mode custom function - run the saved steps
void runSteps() {
  while (dataIn != 13) {   // Run the steps over and over again until "RESET" button is pressed
    for (int i = 0; i <= index - 2; i++) {  // Run through all steps(index)
      if (Bluetooth.available() > 0) {      // Check for incomding data
        dataIn = Bluetooth.read();
        if ( dataIn == 15) {           // If button "PAUSE" is pressed
          while (dataIn != 14) {         // Wait until "RUN" is pressed again
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.read();
              if ( dataIn == 13) {
                break;
              }
            }
          }
        }
        // If speed slider is changed
        if (dataIn > 100 & dataIn < 150) {
          speedDelay = dataIn / 10; // Change servo speed (delay time)
        }
        // Mecanum wheels speed
        if (dataIn > 30 & dataIn < 100) {
          wheelSpeed = dataIn * 10;
          dataIn = 14;
        }
      }
      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();
      }
      // Servo 1
      if (servo01SP[i] == servo01SP[i + 1]) {
      }
      if (servo01SP[i] > servo01SP[i + 1]) {
        for ( int j = servo01SP[i]; j >= servo01SP[i + 1]; j--) {
          servo01.write(j);
          delay(speedDelay);
        }
      }
      if (servo01SP[i] < servo01SP[i + 1]) {
        for ( int j = servo01SP[i]; j <= servo01SP[i + 1]; j++) {
          servo01.write(j);
          delay(speedDelay);
        }
      }

      // Servo 2
      if (servo02SP[i] == servo02SP[i + 1]) {
      }
      if (servo02SP[i] > servo02SP[i + 1]) {
        for ( int j = servo02SP[i]; j >= servo02SP[i + 1]; j--) {
          servo02.write(j);
          delay(speedDelay);
        }
      }
      if (servo02SP[i] < servo02SP[i + 1]) {
        for ( int j = servo02SP[i]; j <= servo02SP[i + 1]; j++) {
          servo02.write(j);
          delay(speedDelay);
        }
      }

      // Servo 3
      if (servo03SP[i] == servo03SP[i + 1]) {
      }
      if (servo03SP[i] > servo03SP[i + 1]) {
        for ( int j = servo03SP[i]; j >= servo03SP[i + 1]; j--) {
          servo03.write(j);
          delay(speedDelay);
        }
      }
      if (servo03SP[i] < servo03SP[i + 1]) {
        for ( int j = servo03SP[i]; j <= servo03SP[i + 1]; j++) {
          servo03.write(j);
          delay(speedDelay);
        }
      }

      // Servo 4
      if (servo04SP[i] == servo04SP[i + 1]) {
      }
      if (servo04SP[i] > servo04SP[i + 1]) {
        for ( int j = servo04SP[i]; j >= servo04SP[i + 1]; j--) {
          servo04.write(j);
          delay(speedDelay);
        }
      }
      if (servo04SP[i] < servo04SP[i + 1]) {
        for ( int j = servo04SP[i]; j <= servo04SP[i + 1]; j++) {
          servo04.write(j);
          delay(speedDelay);
        }
      }

      // Servo 5
      if (servo05SP[i] == servo05SP[i + 1]) {
      }
      if (servo05SP[i] > servo05SP[i + 1]) {
        for ( int j = servo05SP[i]; j >= servo05SP[i + 1]; j--) {
          servo05.write(j);
          delay(speedDelay);
        }
      }
      if (servo05SP[i] < servo05SP[i + 1]) {
        for ( int j = servo05SP[i]; j <= servo05SP[i + 1]; j++) {
          servo05.write(j);
          delay(speedDelay);
        }
      }

      // Servo 6
      if (servo06SP[i] == servo06SP[i + 1]) {
      }
      if (servo06SP[i] > servo06SP[i + 1]) {
        for ( int j = servo06SP[i]; j >= servo06SP[i + 1]; j--) {
          servo06.write(j);
          delay(speedDelay);
        }
      }
      if (servo06SP[i] < servo06SP[i + 1]) {
        for ( int j = servo06SP[i]; j <= servo06SP[i + 1]; j++) {
          servo06.write(j);
          delay(speedDelay);
        }
      }
    }
  }
}Code language: Arduino (arduino)

Así que eso es prácticamente todo para este tutorial. El proyecto funciona bien, pero tenga en cuenta que está lejos de ser perfecto. Los movimientos automáticos pueden no ser tan precisos debido al deslizamiento de las ruedas mecanum, así como al bajo rendimiento de los servomotores. Estos servomotores económicos también pueden temblar o vibrar incluso cuando no se mueven simplemente porque no tienen la fuerza suficiente para soportar el peso de las piezas impresas en 3D.

Espero que hayas disfrutado este tutorial y hayas aprendido algo nuevo. No dude en hacer cualquier pregunta en la sección de comentarios a continuación y consulte mi Colección de proyectos de Arduino.


Proceso de manufactura

  • Proceso de manufactura
  • Impresión 3d
  • Sistema de control de automatización
  • Tecnología Industrial

    1. Cree su robot de transmisión de video controlado por Internet con Arduino y Raspberry Pi
    2. Robot Pi simple
    3. Obstáculos que evitan el robot con servomotor
    4. Controlar un robot Roomba con Arduino y un dispositivo Android
    5. Control del servomotor con Arduino y MPU6050
    6. Brazo robótico simple e inteligente con Arduino
    7. Littlearm 2C:Construya un brazo robótico Arduino impreso en 3D
    8. Brazo de robot Arduino DIY:controlado por gestos con las manos
    9. Brazo robótico programable local y remoto
    10. Controla el brazo del robot Arduino con la aplicación de Android
    11. Robot combina brazo robótico colaborativo con plataforma móvil