Construye un Brazo Robótico Preciso Controlado por PC con Arduino Nano y Servos Tower Pro MG996R

Componentes y suministros

Arduino Nano R3	×	1
Servos (Tower Pro MG996R)	×	4

Aplicaciones y servicios online

• Microsoft Visual Studio 2015
• Arduino IDE

Sobre este proyecto

Siempre he admirado las tecnologías modernas de fabricación y el papel importante que juegan estas máquinas en diferentes áreas como: elevación de materiales, instalación y recogida de piezas, soldadura y corte, y no menos importante, su uso en almacenes.

Mi experiencia construyendo este brazo robótico fue un desafío. Como punto de partida elegí un brazo robótico simple diseñado por fortzeroas en 2016, pero decidí no controlarlo a mano como de costumbre. Creé una App de Automatización con "Aplicación Windows C#" y la hice parecer apps de automatización de fabricación.

Según mi experiencia en programación, creé esta Aplicación de Automatización para controlar totalmente el brazo robótico, monitorizar su movimiento y darle diferentes tareas.

Paso 1: Material

El material principal es madera MDF: usé 2mm para la estructura y 4mm para la base.

Los planos están disponibles para descargar en el último paso, debes imprimir el patrón y pegarlo directamente al MDF.

Corta siguiendo los contornos y taladra agujeros. Usé una herramienta rotativa para taladrar y cortar la madera, y para la base no tengo planos pero creo que puedes improvisar.

Paso 2: Pintado y Estilizado

Para dar un aspecto atractivo al proyecto usé los mismos planos y diseñé una cubierta con Photoshop para crear calcomanías y formas geométricas que se vean realistas, luego la pegué en la madera con cola blanca.

Paso 3: Montaje de la Estructura

Este brazo robótico fue simple de montar porque todo se planificó con antelación: simplemente fijar los servomotores en su lugar con tornillos, y mientras trabajaba hice pequeños ajustes.

Luego, para unir el lado derecho e izquierdo usé palos de madera gruesa y los pegué con superglue en lugar de tornillos largos para reducir el peso.

Paso 4: Pinza (Mecanismo de Pellizco)

Doblé dos varillas metálicas con alicates, luego taladré un agujero en una pieza de madera de 3mm de grosor con taladro rotativo y la pegué con superglue.

Paso 5: Hacer la Base

La base está hecha de madera MDF de 4mm de grosor, corté un cuadrado aprox 17cm x 10cm con sierra de mesa, luego taladré un agujero para sentar el servomotor de base 9g. Para reducir la fricción entre base y cilindro, corté una parte de cartón fuerte de 2.5cm altura x 10cm diámetro, y también la taladré para fijar el eje del servomotor.

Paso 6: Electrónica

Al usar más de dos servos con Arduino debes usar una fuente de alimentación externa para ellos. En este proyecto usé tres microservos 9g y uno servomotor grande.

Por supuesto, la primera prueba de demostración fue virtual en tinkercad.com para simular los servos y probar el circuito eléctrico.

En este caso usé 4 pilas AA 1.5V que suman 6V, luego hice una configuración de prueba en protoboard y después hice una base de expansión muy simple para Arduino Nano.

Paso 7: Código Arduino

1. Descarga e instala la última versión de Arduino IDE. Puedes encontrar la última versión para Windows, Linux o MAC OSX en la web de Arduino: https://www.arduino.cc/en/main/software
2. Conecta tu placa Arduino al puerto USB.
3. Ve a Herramientas > Placa > elige tu placa.
4. Copia y pega el código en el editor del IDE.
5. Verifica tu código haciendo clic en el icono (✔).
6. Sube el código a tu placa haciendo clic en el icono (➤).

Paso 8: Aplicación de Automatización

Esta es mi parte favorita: automatizar un proyecto Arduino usando PC. En mi opinión, fue un buen comienzo para aprender a mejorar las capacidades de control de la placa y cualquier otro proyecto futuro.

Llegar a posiciones de ángulos fijos no fue fácil. Al principio resolví este problema usando una aplicación de terceros llamada "Processing 3".

En las etapas iniciales hice una interfaz que simula los servos del brazo robótico (Base, Hombro, Codo y Pinza) por teclado y los mueve por separado "ángulo por ángulo" hasta alcanzar una posición fija preparada previamente.

Cuando alcanzaba esa posición preparada, registraba estos cuatro ángulos en un array de código (A,B,C,D). Luego usé estos multi-arrays más tarde en mi aplicación Windows, lo que me ayudó mucho a conocer los límites de ángulo de cada servomotor en su posición.

Estos límites recopilados los puse como guía en las barras laterales de la interfaz de usuario para mantener el BRAZO bajo control y también para soportar la función de reproducción.

Así, usando esta aplicación puedes controlar, grabar y monitorizar el Brazo Robótico de la siguiente manera:

1. Control de Movimiento:

Hay dos modos para controlar este brazo robótico: primero manual arrastrando las barras de seguimiento que controlan un servo específico:

• Pinza: clic en abrir y cerrar para abrir y cerrar la pinza del robot.
• Base: arrastra la barra de seguimiento derecha e izquierda o usa flechas del teclado (derecha/izquierda) para mover la base.
• Hombro: arrastra la barra derecha/izquierda o usa flechas (arriba/abajo) para mover el hombro arriba y abajo.
• Codo: arrastra la barra derecha/izquierda o usa teclas (w/s) para mover el motor del codo arriba y abajo.

2. Grabación de Movimiento:

Cuando quieras automatizar el movimiento del brazo robótico, debes grabar la posición en cada paso clicando "Rec. Position" o presionando (R) en el teclado. La aplicación se encarga del resto.

En cada paso, la aplicación detecta la posición del motor movido y la guarda en una lista separada.

Al clicar "Start Auto mood", la aplicación enviará esas posiciones guardadas en forma de órdenes secuenciales.

3. Monitorización:

Creé una interfaz gráfica que dibuja cada paso en un gráfico para que el usuario note cualquier cambio inusual. Al mismo tiempo hay una tabla de datos a la derecha que da el ángulo específico y el tiempo exacto de su movimiento.

Así, usando estas características puedes componer tus propios movimientos y enviarlos al Brazo Robótico como una tarea, exactamente como hacen en automatización de fabricación.

Paso 9: Actualizaciones

Agosto 2018:

Recientemente hice el mismo diseño añadiendo modificaciones en una máquina de corte láser usando MDF de 3mm. Esta idea adicional fue genial, especialmente cuando añadí un Joystick personalizado.

Código

• Task.ino
• RobotArm.ino

Task.ino Arduino

int delayT = 350;
void Home() // Llamar esta función cuando quieras poner el brazo en posición home
{
  MyServo0.write(valGripper); // Pinza
  delay(15);
  MyServo.write(valBase); // base
  delay(30);
  MyServo2.write(valShoulder); // hombro
  delay(30);
  MyServo3.write(valElbow); // codo
  delay(delayT);
}
void Pick() // Esta es una posición fija de recoger.
{
  MyServo.write(4); // base
  delay(delayT);
  MyServo3.write(125); // codo
  MyServo2.write(95); // hombro
  delay(delayT);
  MyServo0.write(50); // Pinza abrir amplio
  delay(delayT);
  MyServo0.write(2); // Pinza cerrar
  delay(delayT);
  MyServo2.write(60); // hombro subir un poco
  MyServo3.write(80); // codo subir un poco
  delay(delayT);
  Serial.println("Objeto Recogido");
}
void Drop() // Esta es una posición fija de soltar.
{
  MyServo.write(145); // base
  delay(delayT);
  MyServo2.write(80); // hombro
  delay(15);
  MyServo3.write(115); // codo
  delay(delayT);
  MyServo0.write(40); // Pinza abrir amplio
  delay(delayT);
  MyServo3.write(90); // codo subir un poco
  delay(delayT);
  Serial.println(F("Objeto Soltado"));
}
void Playback() {
  // https://arduino.stackexchange.com/questions/1013/how-do-i-split-an-incoming-string
  // input DEBE ser array ( servoId : Position & servoId : Position & servoId : Position )
  // String phrase;
  // phrase = String(phrase + ByteReceived);
  // convertir la entrada char a string puede ser split
  // Leer cada par de comando
  char* command = strtok(ByteReceived, "&");
  while (command != 0) {
    // Separar el comando en dos valores
    char* separator = strchr(command, ':');
    if (separator != 0) {
      // Realmente separar el string en 2: reemplazar ':' con 0
      *separator = 0;
      int servoId = atoi(command);
      ++separator;
      int angle = atoi(separator);
      // Hacer algo con servoId y angle
      if (servoId = 1) {
        MyServo.write(angle);
        delay(delayT);
      } else if (servoId = 2) {
        MyServo2.write(angle);
        delay(delayT);
      } else if (servoId = 3) {
        MyServo3.write(angle);
        delay(delayT);
      }
    }
    // Encontrar el siguiente comando en string de entrada
    command = strtok(0, "&");
  }
}

RobotArm.ino Arduino

// escrito por AhmedAzouz
#include <Servo.h>
Servo MyServo,MyServo2,MyServo3,MyServo0;
char ByteReceived;
int MyPosition,MyPosition2,MyPosition3,MyPositionG;
int runCounter = 0;
int ledPin = A5;
// posiciones home por defecto de los servos
int valGripper = 30;
int valBase = 70;
int valShoulder = 25;
int valElbow = 150;
void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
  digitalWrite(13,LOW);
  MyServo0.attach(12); // Pinza
  MyServo.attach(11); // base
  MyServo2.attach(13); // hombro
  MyServo3.attach(10); // Codo
  // Posiciones de inicio
  MyServo0.write(valGripper); // Pinza
  delay(15);
  MyServo.write(valBase); // base
  delay(30);
  MyServo2.write(valShoulder); // hombro
  delay(30);
  MyServo3.write(valElbow); // codo
  delay(300);
}
void loop() {
  Serial.print("Base : ");
  Serial.print(valBase);
  Serial.print("\t");
  Serial.print("Hombro : ");
  Serial.print(valShoulder);
  Serial.print("\t");
  Serial.print("Codo : ");
  Serial.print(valElbow);
  Serial.print("\t");
  Serial.print("Pinza : ");
  Serial.println(valGripper);
  while (Serial.available() > 0 ) {
    ByteReceived = Serial.read();
    switch (ByteReceived) {
      // ************* LED
      case 'n':
        digitalWrite(ledPin,HIGH); // encender LED
        Serial.println("LED encendido");
        break;
      case 'f':
        digitalWrite(ledPin,LOW); // apagar LED
        Serial.println("LED apagado");
        break;
      // ************* Base
      case 'l':
        MyPosition = MyServo.read() + 2; // L para mover base izquierda
        MyServo.write(MyPosition);
        Serial.print("Base");
        Serial.print("\t");
        Serial.println(MyServo.read());
        delay(15);
        break;
      case 'r':
        MyPosition = MyServo.read() - 2; // R para mover base derecha
        MyServo.write(MyPosition);
        Serial.print("Base");
        Serial.print("\t");
        Serial.println( MyServo.read());
        delay(15);
        break;
      // ************* Codo
      case 'u':
        MyPosition2 = MyServo2.read() + 2; // U para mover Codo arriba
        MyServo2.write(MyPosition2);
        Serial.print("Codo");
        Serial.print("\t");
        Serial.println(MyServo2.read());
        delay(15);
        break;
      case 'd':
        MyPosition2 = MyServo2.read() - 2; // D para mover Codo abajo
        MyServo2.write(MyPosition2);
        Serial.print("Codo");
        Serial.print("\t");
        Serial.println(MyServo2.read());
        delay(15);
        break;
      // ************* Hombro
      case 'w':
        MyPosition3 = MyServo3.read() + 2; // W para mover Hombro abajo
        MyServo3.write(MyPosition3);
        Serial.print("Hombro");
        Serial.print("\t");
        Serial.println(MyServo3.read());
        delay(15);
        break;
      case 's':
        MyPosition3 = MyServo3.read() - 2; // S para mover Hombro arriba
        MyServo3.write(MyPosition3);
        Serial.print("Hombro");
        Serial.print("\t");
        Serial.println(MyServo3.read());
        delay(15);
        break;
      // ************* Pinza
      case 'o':
        MyServo0.write(30); // O para abrir Pinza
        Serial.print("Pinza Abierta");
        Serial.print("\t");
        Serial.println(MyServo0.read());
        delay(15);
        break;
      case 'c':
        // C para cerrar Pinza
        MyServo0.write(1);
        Serial.print("Pinza Cerrada");
        Serial.print("\t");
        Serial.println(MyServo0.read());
        delay(15);
        break;
      // ************* Posición Default Dropped (soltar rápido)
      case 'q':
        digitalWrite(ledPin,HIGH);
        Serial.println("Default Dropped activado!");
        Pick();
        Drop();
        Home();
        digitalWrite(ledPin,LOW);
        break;
      // ************* Parada forzada y posición home
      case 'h':
        Home();
        digitalWrite(ledPin,LOW);
        break;
      // ************* Modo automático ejecuta función Playback
      // serial read DEBE estar en este formato: 1:90&2:80&3:180
      // posición de recogida es fija, esta función automatiza la posición de soltar.
      default:
        digitalWrite(ledPin,HIGH);
        Serial.println("Modo automático activado!");
        Pick();
        Playback();
        Home();
        digitalWrite(ledPin,LOW);
        break;
    }
  }
}

Partes personalizadas y cajas

f98t2axin238k2n_khGWAEIqdl.skp

Esquemáticos