Brazo de robot Arduino DIY:controlado por gestos con las manos

Acerca de este proyecto

Presentamos el brazo robótico de bricolaje controlado por gestos humanos.

Películas de gran éxito como Pacific Rim, Avatar y otras películas de ciencia ficción han insinuado la capacidad de crear sinergias con Robots, donde sus movimientos pueden mejorarse con la asistencia robótica.

¿Y si pudiéramos construir el mismo robot industrial, pero a menor escala?

Este proyecto es un intento de lograrlo.

Este es un brazo robótico Arduino que se puede programar o incluso controlar mediante gestos con las manos.

Manteniéndose fiel a la convención de trajes de Iron Man, cada iteración se conocería como Mark. Este prototipo se conocería como MARK 1. Podemos esperar más iteraciones para mejorar el brazo robótico original.

Vea el tutorial completo del brazo robótico de bricolaje (controlado por gestos con las manos) aquí

Descripción general

En este tutorial, construiremos un robot de seis ejes controlado por gestos con las manos utilizando un guante robótico. Y al imitar los gestos humanos naturales, como un pellizco o una rotación de la muñeca hacia la izquierda, podrá abrir / cerrar o girar el brazo robótico hacia la izquierda y hacia la derecha, respectivamente. En efecto, controlando manualmente un brazo robótico.

Encuentre más detalles sobre el artículo original

Funciones de MARK 1:

• Rotación de 6 ejes
• Portátil
• Controla el robot con gestos humanos
• Puede preprogramarse para realizar funciones básicas
• Puede controlarse de forma inalámbrica desde un rango
• Puede soportar un peso de carga de 600 g (carga máxima de 1 kg)

Lista de piezas

El brazo robótico es totalmente personalizable. Puede comprar el suyo propio o imprimir en 3D el suyo. Si elige imprimir en 3D, no se preocupe. Hay una lista de diferentes Robots que usan servomotores, por lo que la teoría de lo que estamos construyendo todavía se aplica.

Para este proyecto, este prototipo (Mark 1) se imprimiría en 3D, ya que me da más espacio para crear piezas personalizadas.

Brazo robótico: Brazo robótico impreso en 3D Thingiverse (créditos:Wonder Tiger):

• Parte 1:Piezas de pinza
• Parte 2:Base y plato giratorio
• Parte 3:Brazo de núcleo robótico

Puede encontrar más información sobre esta construcción, junto con los tipos de tornillos de las partes anteriores. El tiempo necesario para imprimir puede ser de hasta 40 horas. Sin embargo, esto reduce el costo de comprar un brazo robótico.

Guante robótico : Los archivos Robotic Glove.STL (créditos:Roman 13)

El guante robótico fue una adición estética al proyecto, pero también puede usar un guante de construcción para implementar el brazo robótico.

Nota: para manos más grandes, imprima a una escala del 105%

Cómo funciona

En general, estamos enviando una señal (por Bluetooth) desde el guante robótico al servomotor. Cuando se recibe un valor, el servocontrolador enviará una señal a un servomotor específico que mueve el brazo robótico.

Ahora, si agregamos múltiples servos y más sensores, podemos controlar cada motor. `

Si pensamos en un brazo robótico como una serie de servomotores que se coordinan entre sí para realizar una función, podemos crear un brazo robótico controlado por un guante robótico.

El Arduino del Robotic Glove utiliza sensores para comunicarse con el Arduino del brazo robótico y envía datos para mover un Servo al ángulo deseado.

Quizás se esté preguntando, ¿qué sensores usa el guante robótico?

Para MARK 1, estaríamos usando Flex Sensors y un acelerómetro (MPU6050)

• Sensores flexibles - En función del grado de curvatura de esta pieza plástica, la resistencia cambia afectando la corriente. Luego, esta medida se usa para detectar cambios en el movimiento de la mano.
• Acelerómetros - Para gestos más naturales, un acelerómetro puede detectar un cambio en la rotación de los brazos y la muñeca.

Estamos usando estos sensores para detectar un cambio en un gesto. Luego podemos enviar un valor específico mapeado de un gesto al brazo robótico para controlar un servomotor a través de Bluetooth. ¡Y con suficientes gestos, el brazo robótico cobra vida!

Mapeo de brazos robóticos

Lo siguiente representa una tabla de mapeo de los valores enviados al brazo robótico por el guante. Esto se puede encontrar en el artículo original. Cada uno tiene una clave para caracterizar su función. (P - Pinkie, L - Derecha, etc.)

Nota: "F" mayúscula (dedo ) representa la dirección opuesta del giro del servomotor

Montaje de piezas

Brazo robótico:montaje

Comprar un brazo robótico puede resultar bastante caro. Para mantener este brazo robótico dentro del presupuesto, la impresión 3D de un brazo robótico era la mejor opción.

Esto ayuda a largo plazo, ya que hay muchos ejemplos de un brazo robótico impreso en 3D que se puede personalizar, por ejemplo, agregando un LED, creando un soporte de cámara Abrazadera:

Como se mencionó anteriormente, el brazo robótico se inspiró en el brazo robótico en Thingyverse. Elegí este ejemplo porque era un diseño excelente que proporcionaba seis ejes, estaba bien documentado y tenía resistencia / solidez. Puede acceder al brazo robótico de Wonder Tiger desde la lista de piezas.

También puedes encontrar mis remixes para un soporte de cámara de brazo robótico. Cubriremos esto más en una versión futura. Sin embargo, las piezas pueden tardar al menos 40 horas en imprimirse.

También puede encontrar muchas otras alternativas impresas en 3D de brazo robótico.

Presentamos el servomotor y el controlador

Dado que el brazo robótico es idealmente una serie de motores que se coordinan juntos, teóricamente podemos conectar varios motores que pueden ser alimentados por Arduino. En este proyecto, usaremos el servocontrolador PCA9685 para alimentar el servo MG966R.

Nota: Utilice una fuente de alimentación externa al alimentar cada motor. El Arduino no puede suministrar suficiente energía para controlar todos los motores. En este proyecto, se utilizó una batería RC de 5 V y 2200 mAh.

El cableado del diagrama de Arduino debe verse como se muestra a continuación:

NEMA-17 para rotación de base

Dado que el robótico estaba comenzando a ganar un poco de peso, y el servomotor MG966R no era lo suficientemente potente como para girar el brazo robótico en la base. Para rotar el brazo robótico, se necesitaría utilizar un motor más robusto que un servomotor

Se puede usar un motor paso a paso (NEMA-17) debido a su precisión y alto par, lo que ayuda al brazo robótico a girar sin problemas para controlar los gestos.

El controlador NEMA-17 y A4988 se usa para controlar la dirección del motor, puede ver en el diagrama a continuación:

Y finalmente, el siguiente diagrama muestra el ensamblaje del diagrama de cableado final del Brazo Robótico completo.

Montaje de circuitos

El siguiente diagrama de cableado muestra el ensamblaje final de todas las partes electrónicas para crear un brazo robótico, incluido el módulo Bluetooth. Cubriremos el proceso de emparejamiento a continuación.

Sensor de flexión humano

Para mantenerse fiel a la estética del brazo robótico, puede imprimir un guantelete de exoesqueleto impreso en 3D para usarlo como su guante robótico.

Sin embargo, puede utilizar un Builder's Glove estándar para la creación de prototipos del guante robótico. Este diseño de "Exoesqueleto de guante de robot" se combinó bien con el diseño del brazo robótico.

El guante robótico consta de los siguientes componentes:

• Sensor flexible - Según la flexión del dedo, la corriente cambia que podríamos usar para enviar una señal al motor
• Acelerómetro (MPU6050 ) - Podemos controlar el motor mapeando los gestos humanos desde el plano X, Y, Z
• LED - El LED se iluminará cuando se haya enviado un control de gestos humanos al Arduino
• Módulo Bluetooth (HC-05) - Envío de datos al receptor HC-05 de brazo robótico
• Arduino Nano - El microcontrolador funcionaría como el cerebro del guante robótico

El siguiente diagrama es excelente para probar el sensor flexible y el acelerómetro.

Importante: El brazo robótico solo será tan preciso como lo controle el guante robótico, por lo que vale la pena hacerlo bien.

Configuración de Bluetooth (maestro y receptor)

El brazo robótico Arduino se comunica a través de Bluetooth utilizando los módulos HC-05. A continuación, resalte la información crítica.

Módulo

Configuración

Guante robótico HC-05 Master Brazo robótico HC-05 Slave

Nota:

La velocidad en baudios está establecida en 4800

Programación Arduino

Puede descargar el siguiente código a continuación:

Nota: Todos los demás códigos de prueba y la última versión se pueden encontrar en Arduino Robotic Arm Git Repo

Programación del brazo robótico

El código del brazo robótico utiliza la biblioteca HCPCA9685 (para el servodriver). De esta manera, podemos alimentar múltiples servomotores, todos controlados por un Arduino. En el código, podemos comenzar agregando esta biblioteca y declarando las servovariables.

Las siguientes variables se utilizan para encontrar el incremento / anterior y obtener la posición actual del Servo.

  * Incluye la biblioteca HCPCA9685 * / 
 #include "HCPCA9685.h" 
 / * Dirección esclava I2C para el dispositivo / módulo. Para el HCMODU0097, la dirección I2C predeterminada 
 es 0x40 * / 
 #define I2CAdd 0x40 
 / * Cree una instancia de la biblioteca * / 
 HCPCA9685 HCPCA9685 (I2CAdd); 
 // posición de estacionamiento inicial del motor 
 const int servo_joint_L_parking_pos =60; 
 // Grado de sensibilidad del servo del robot - Intervalos 
 int servo_joint_L_pos_increment =20; 
 // Realizar un seguimiento de el valor actual de las posiciones del motor 
 int servo_joint_L_parking_pos_i =servo_joint_L_parking_pos; 
 // Ángulo mínimo y máximo del servomotor 
 int servo_joint_L_min_pos =10; 
 int servo_joint_L_max_pos =180;  

Inicialice el puerto serie a una velocidad de 4800 baudios para iniciar la comunicación Bluetooth

  Serial.begin (4800); // Inicializar la velocidad de comunicación predeterminada del módulo Bluetooth  

En la sección loop (), verificamos constantemente si algún dato proviene del guante robótico. Si es verdadero, almacenaremos los datos entrantes en la variable "estado". Y dependiendo del carácter dado, lo usaremos para mover el (los) motor (es).

La siguiente sección describe el código:

El código del brazo robótico puede verse como una serie de servomotores que trabajan juntos para simular los movimientos humanos. El código es el mismo, con el Servo controlado por un Servocontrolador basado en los valores de Bluetooth.

  // Definición del servocontrolador. La dirección 0x40 es la dirección I2C predeterminada. 
 #define I2CAdd 0x40 
 int response_time =5; // Recibiendo valores del intervalo del guante robótico 
 // Verifica si los datos provienen del puerto serial 
 
 if (Serial.available ()> 0) {
 state =Serial .leer(); // Lee los datos del puerto serie 
 Serial.print (estado); // Imprime el valor enviado 
 // Bloque de código de funcionalidad del motor 
}  

Según el "valor del estado" actual, el servodriver enviaría una señal al motor respectivo.

Por ejemplo, si doblamos los dedos. El valor "f" sería enviado por el guante robótico (vía Bluetooth) por lo que el brazo robótico leería estos datos y activaría una función para rotar el servomotor respectivo. Este proceso se repite en un bucle infinito.

  if (Serial.available ()> 0) {// Comprueba si los datos provienen del puerto serie 
 state =Serial.read (); // Lee los datos del puerto serie 
 Serial.print (estado); // Imprime el valor enviado 
 // Para el nombre de los motores, consulte el artículo / tutorial 
 // Mover (Rotación base) Motor paso a paso a la izquierda 
 if (state ==' S ') {
 baseRotateLeft (); 
 delay (response_time); 
} 
}  

Nota: El código implementa una parada brusca para evitar que el motor exceda su ángulo máximo, lo que puede dañar los engranajes del motor.

  HCPCA9685.Servo (0, servo_joint_L_parking_pos_i); // Conduce el servomotor en el canal 0 al ángulo deseado. 
 // Mueve el motor de garra hacia abajo 
 if (state =='f') {
 if (servo_joint_3_parking_pos_i HCPCA9685.Servo(4, servo_joint_3_parking_pos_i); 
 delay (response_time); 
 Serial.println (servo_joint_3_parking_pos_i); 
 servo_joint_3_parking_pos_i =servo_jointpos_i_re_3_parking_i =servo_jointpos_i_re_3;>} 
 void baseRotateLeft () {
 digitalWrite (stepPin, LOW); // Gire en una dirección basada en HIGH, LOW 
 delayMicroseconds (stepDelay); // Cambia la velocidad del motor paso a paso 
}  

Si el valor del servomotor es menor que la rotación máxima, continúe girando. Si ha alcanzado la rotación máxima de 180 grados, deténgase.

  servo_joint_3_parking_pos_i  

Donde servo_joint_3_max_pos es la posición máxima del motor.

Nota: El código implementa una parada brusca para evitar que el motor exceda su ángulo máximo, lo que puede dañar los engranajes del motor.

Programación del sensor flexible

El código del brazo robótico se puede encontrar en GitHub. Si trabaja en el proyecto, contribuya con su propia versión a Git Repo. Esto ayudaría a construir un índice de diferentes versiones y funcionalidades del brazo robótico.

El código ya ha sido documentado (también disponible en Git). Sin embargo, cubriremos los puntos clave:

Definiremos los cinco sensores:

  // LED ENCENDIDO PIN 3 
 int pinkie_Data =A1; 
 int finger_Data =A2; 
 int thumb_Data =A3; 
 // const int MPU_addr =0x68; 
 const int MPU2 =0x69, MPU1 =0x68;  

Nota: 0x68 y 0x69 representan la dirección I2C de los 2 acelerómetros MPU6050

  // Con qué frecuencia enviar valores al brazo robótico 
 int response_time =1000;  

El siguiente código describe el Arduino leyendo los valores de los sensores:

  // lee los valores de Flex Sensors a Arduino 
 pinkie =analogRead (pinkie_Data); 
 finger =analogRead (finger_Data); 
 thumb =analogRead (thumb_Data);  

Leer la posición actual del acelerómetro:

  GetMpuValue1 (MPU1); 
 GetMpuValue2 (MPU2);  

Calibrando los valores:

El siguiente código se calibra para encontrar el límite superior e inferior del sensor flexible. Para volver a calibrar el guante flexible, presione el botón de reinicio en el Arduino.

  if (bool_caliberate ==false) {
 delay (1000); 
 thumb_high =(thumb * 1.15); 
 thumb_low =(thumb * 0.9); 
 dedo_alto =(dedo * 1.03); 
 dedo_bajo =(dedo * 0.8); 
 meñique_alto =(meñique * 1.06); 
 meñique_bajo =(meñique * 0.8); 
 bool_caliberate =verdadero; 
}  

Constantemente comprobaremos si el valor actual ha excedido el límite superior o inferior del flex definido según la calibración. Si el sensor flexible va por encima o por debajo de este valor, los datos se envían al brazo robótico para mover un servomotor específico en una dirección específica.

  // dedo 1 - Claw Bend / Open 
 if (finger> =finger_high) {
 Serial.print ("F"); 
 delay (response_time); 
} 
 if (finger <=finger_low) {
Serial.print("f "); 
 delay (response_time); 
}  

Programación del brazo robótico

Resultados:recompensa

El brazo robótico es lo suficientemente preciso para mover objetos. Sin embargo, requerirá algo de trabajo para mover objetos complejos, o incluso competir con los 'millones de años' que los seres humanos tienen en destreza ... aunque dedicando más tiempo a trabajar en el código, la precisión del Robot puede funcionar según lo previsto para MARK 1i . Aunque el brazo se puede mejorar, se puede mejorar significativamente.

Si desea mejorar el código, contribuya al Arduino Robot Arm Git Repo y construye tu brazo. ¡Dejemos esto abierto para que otros lo construyan!

Por último, también podemos controlar el robot mediante gestos con las manos y programar el robot para automatizar tareas básicas.

Pasos siguientes

¡Y eso es todo para la gente de MARK 1! Si desea este proyecto, considere apoyar mi página de Patreon.

Código

• Fragmento de código n. ° 1
• Fragmento de código n. ° 3
• Fragmento de código n. ° 4
• Fragmento de código n. ° 5
• Fragmento de código n.º 7
• Fragmento de código n. ° 11
• Fragmento de código n. ° 12

Fragmento de código n. ° 1 Texto sin formato

 * Incluye la biblioteca HCPCA9685 * / # incluye "HCPCA9685.h" / * Dirección esclava I2C para el dispositivo / módulo. Para el HCMODU0097, la dirección I2C predeterminada es 0x40 * / # define I2CAdd 0x40 / * Crea una instancia de la biblioteca * / HCPCA9685 HCPCA9685 (I2CAdd); // posición de estacionamiento inicial del motorconst int servo_joint_L_parking_pos =60; // Grado de servo del robot sensibilidad - Intervalsint servo_joint_L_pos_increment =20; // Realizar un seguimiento del valor actual de las posiciones del motor en servo_joint_L_parking_pos_i =servo_joint_L_parking_pos; // Ángulo mínimo y máximo del servomotorint servo_joint_L_min_pos =10; int servo_joint_L;_premax_pos =10; int servo_joint_L;_premax 
 Fragmento de código n. ° 3  Texto sin formato  
 
 // Definición del servocontrolador. La dirección 0x40 es la dirección I2C predeterminada. # Define I2CAdd 0x40 int response_time =5; // Recibiendo valores del intervalo del guante robótico // Comprueba si los datos provienen del puerto serie if (Serial.available ()> 0) {state =Serial.read (); // Lee los datos del puerto serie Serial.print (estado); // Imprime el valor enviado // Bloque de código de funcionalidad del motor} 
 
 Fragmento de código n.º 4  Texto sin formato  
 
 if (Serial.available ()> 0) {// Comprueba si los datos provienen del puerto serie state =Serial.read (); // Lee los datos del puerto serie Serial.print (estado); // Imprime el valor enviado // Para el nombre de los motores, consulte el artículo / tutorial // Mover (rotación base) Motor paso a paso a la izquierda if (state =='S') {baseRotateLeft (); retraso (tiempo_respuesta); }} 
 
 Fragmento de código n. ° 5  Texto sin formato  
 
 HCPCA9685.Servo (0, servo_joint_L_parking_pos_i); // Conduce el servomotor en el canal 0 al ángulo deseado .// Mueve el motor de garra hacia abajo if (state =='f') {if (servo_joint_3_parking_pos_i  
 Fragmento de código n.º 7  Texto sin formato  
 
 // LED ENCENDIDO PIN 3int pinkie_Data =A1; int finger_Data =A2; int thumb_Data =A3; // const int MPU_addr =0x68; const int MPU2 =0x69, MPU1 =0x68; 
 
 Fragmento de código n. ° 11  Texto sin formato  
 
 if (bool_caliberate ==false) {retraso (1000); pulgar_alto =(pulgar * 1,15); thumb_low =(pulgar * 0.9); dedo_alto =(dedo * 1.03); finger_low =(dedo * 0.8); meñique_alto =(meñique * 1.06); meñique_bajo =(meñique * 0.8); bool_caliberate =verdadero; } 
 
 Fragmento de código n. ° 12  Texto sin formato  
 
 // dedo 1 - Claw Bend / Open if (finger> =finger_high) {Serial.print ("F"); retraso (tiempo_respuesta); } if (dedo <=dedo_bajo) {Serial.print ("f"); retraso (tiempo_respuesta); } 
 
 Github 
 http://github.com/EbenKouao/arduino-robot-armhttp://github.com/EbenKouao/arduino-robot-arm 
 Github 
 https://github.com/EbenKouao/arduino-robotic-armhttps://github.com/EbenKouao/arduino-robotic-arm 

Piezas y carcasas personalizadas

Thingiverse

https://www.thingiverse.com/thing:1748596Archivo CAD en thingiverse.com

Thingiverse

https://www.thingiverse.com/thing:1750025Archivo CAD en thingiverse.com

Thingiverse

https://www.thingiverse.com/thing:1838120 Archivo CAD en thingiverse.com

Thingiverse

https://www.thingiverse.com/thing:1982745 Archivo CAD en thingiverse.com

Esquemas

Robot Arm Git Repo

https://github.com/EbenKouao/arduino-robot-arm

Controla tu sistema de iluminación mediante un teléfono inteligente Plantas de oficina sedientas de tweets