Brazo Robótico Arduino Controlado por Gestos Manuales – Construcción Paso a Paso

Componentes y materiales

• 1x Arduino UNO
• 1x PCB personalizada JLCPCB
• 6x Servomotor MG996R
• 1x Pack batería 5V
• 1x Driver PCA9685 8‑canales I²C (National Control Devices)
• 2x Módulo Bluetooth HC‑05
• 1x Driver paso a paso SparkFun A4988
• 1x Motor paso a paso NEMA‑17
• 1x Protoboard
• 1x IMU (6 DoF)
• 1x Arduino Nano R3
• 1x Sensor flex

Herramientas necesarias

• Impresora 3D

Sobre el proyecto

Presentamos el Brazo Robótico DIY controlado por Gestos Humanos.

Películas como Pacific Rim o Avatar sugieren la sinergia con robots donde tus movimientos se amplifican con asistencia robótica. ¿Y si construimos el mismo robot industrial a escala reducida? Este proyecto lo intenta.

Siguiendo la convención de Iron Man, cada iteración es un "Mark". Este prototipo es MARK 1.

Ver tutorial completo del Brazo Robótico DIY (controlado por gestos) aquí

Visión general

Construiremos un robot de 6 ejes controlado por gestos manuales mediante un Guante Robótico. Imitando gestos naturales (pellizco, rotación de muñeca) podrás abrir/cerrar o girar el brazo. En efecto, control manual de un brazo robótico.

Características MARK 1:

• Rotación 6 ejes
• Portátil
• Control por gestos humanos
• Programable para funciones básicas
• Control inalámbrico con alcance
• Carga máxima 1 kg (operativo 600 g)

Lista de piezas

El brazo es totalmente personalizable: compra o imprime en 3D. Si imprimes, hay muchos diseños en Thingiverse que usan servos; la teoría es la misma.

Brazo robótico: Thingiverse "3D Printed Robotic Arm" (créditos: Wonder Tiger):

• Parte 1: Pinza
• Parte 2: Base y plato giratorio
• Parte 3: Núcleo del brazo

Tiempo de impresión: hasta 40 horas. Ahorra coste frente a comprar.

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

El guante es una adición estética; puedes usar un guante de obra. Nota: para manos grandes, imprime al 105%.

Cómo funciona

Enviamos señal (por Bluetooth) del guante al servomotor. Al recibir un valor, el driver envía la orden al servo correspondiente.

Si pensamos el brazo como serie de servos coordinados, podemos controlarlo con el guante. El Arduino del guante usa sensores para comunicar con el Arduino del brazo y enviar ángulos deseados por Bluetooth.

Sensores del guante (MARK 1):

• Sensores flex: Cambian resistencia al doblarse; miden movimiento de dedos.
• Acelerómetro (MPU6050): Detecta rotación de muñeca/brazo para gestos naturales.

Detectamos cambios de gesto, enviamos valor mapeado al brazo para mover un servo vía Bluetooth. Con suficientes gestos, el brazo cobra vida.

Mapeo del brazo robótico

Tabla de valores enviados del guante al brazo (claves: P=meñique, L=derecha, etc.). La "F" mayúscula (finger) indica dirección opuesta del servo.

Montaje de piezas

Montaje del brazo robótico

Comprar un brazo es caro. La impresión 3D mantiene el presupuesto. Permite personalización futura (añadir LED, soporte cámara). El diseño se basa en Wonder Tiger (Thingiverse): 6 ejes, bien documentado, robusto. Mis remixes para soporte cámara se tratarán en futuras versiones. La impresión total puede llevar 40+ horas. Hay alternativas en Thingiverse.

Servomotor y driver

El brazo es una serie de motores coordinados. Usamos driver PCA9685 para alimentar servos MG996R. Nota: Usa fuente externa para los motores; Arduino no suministra suficiente corriente. Aquí: batería RC 5V 2200 mAh.

NEMA‑17 para rotación de base

El servo MG996R no tenía torque para girar la base con el peso del brazo. Usamos motor paso a paso NEMA‑17 por su precisión y alto par.

Driver A4988 controla dirección del NEMA‑17.

Diagrama final de cableado del brazo completo (incluye Bluetooth).

Montaje de la electrónica

Sensor flex humano

Puedes imprimir un guante exoesqueleto 3D o usar un guante de obra para prototipar. El diseño exoesqueleto combina estéticamente con el brazo.

Componentes del guante:

• Sensor flex: cambia corriente al doblar dedo → señal al motor
• Acelerómetro MPU6050: control por gestos en ejes X, Y, Z
• LED: indica envío de gesto al Arduino
• Bluetooth HC‑05: envía datos al receptor del brazo
• Arduino Nano: cerebro del guante

Importante: El brazo será tan preciso como el control del guante. Vale la pena ajustarlo bien.

Configuración Bluetooth (Maestro y Esclavo)

Comunicación por HC‑05. Configuración crítica:

Módulo	Configuración
Guante HC‑05	Maestro
Brazo HC‑05	Esclavo

Baud rate: 4800.

Programación Arduino

Código descargable abajo. Otros códigos de prueba y última versión en GitHub Arduino Robot Arm.

Programación del brazo robótico

Usa librería HCPCA9685 para el driver de servos. Permite alimentar múltiples servos desde un Arduino. Declaración de variables:

#include "HCPCA9685.h"
#define I2CAdd 0x40
HCPCA9685 HCPCA9685(I2CAdd);
const int servo_joint_L_parking_pos = 60;
int servo_joint_L_pos_increment = 20;
int servo_joint_L_parking_pos_i = servo_joint_L_parking_pos;
int servo_joint_L_min_pos = 10;
int servo_joint_L_max_pos = 180;

Inicializa puerto serie a 4800 baudios para Bluetooth:

Serial.begin(4800);

En loop() se comprueban datos entrantes del guante. Si hay, se guardan en state y se mueve el motor correspondiente.

if (Serial.available() > 0) {
  state = Serial.read();
  Serial.print(state);
  // Bloque funcionalidad motores
}

Ejemplo: al recibir 'S' gira base a la izquierda (stepper).

if (state == 'S') {
  baseRotateLeft();
  delay(response_time);
}

Límite duro para no sobrepasar ángulo máximo (evita desgastar engranajes):

if (servo_joint_3_parking_pos_i < servo_joint_3_max_pos) {
  HCPCA9685.Servo(4, servo_joint_3_parking_pos_i);
  servo_joint_3_parking_pos_i += servo_joint_3_pos_increment;
}

Programación del sensor flex

Código en GitHub. Puntos clave:

Definición de 5 sensores:

int pinkie_Data = A1;
int finger_Data = A2;
int thumb_Data = A3;
const int MPU2 = 0x69, MPU1 = 0x68; // Direcciones I2C de 2 MPU6050
int response_time = 1000;

Lectura de sensores:

pinkie = analogRead(pinkie_Data);
finger = analogRead(finger_Data);
thumb = analogRead(thumb_Data);
GetMpuValue1(MPU1);
GetMpuValue2(MPU2);

Calibración (al resetear Arduino):

if (!bool_caliberate) {
  delay(1000);
  thumb_high = thumb * 1.15; thumb_low = thumb * 0.9;
  finger_high = finger * 1.03; finger_low = finger * 0.8;
  pinkie_high = pinkie * 1.06; pinkie_low = pinkie * 0.8;
  bool_caliberate = true;
}

Comprobación continua de límites calibrados:

if (finger >= finger_high) { Serial.print("F"); delay(response_time); }
if (finger <= finger_low)  { Serial.print("f"); delay(response_time); }

Resultados

El brazo mueve objetos con precisión suficiente para MARK 1. Requiere refinamiento para tareas complejas, pero funciona según lo previsto. Mejoras en código aumentarán precisión.

¿Quieres mejorar el código? Contribuye al Repo GitHub Arduino Robot Arm y construye tu brazo. ¡Hagámoslo abierto para que otros lo mejoren!

Además, podemos controlar el robot por gestos y programarlo para automatizar tareas básicas.

Próximos pasos

¡Esto es todo por MARK 1! Si te gusta el proyecto, apoya mi Patreon.

Código

Fragmentos de código disponibles en el repositorio GitHub.

Partes personalizadas y cajas

• Thingiverse 1748596
• Thingiverse 1750025
• Thingiverse 1838120
• Thingiverse 1982745

Esquemáticos

Repo GitHub del brazo: github.com/EbenKouao/arduino-robot-arm