Construye un brazo robot Arduino sin cables, controlado desde tu smartphone

En este tutorial aprenderemos a hacer un brazo robot Arduino controlable y programable inalámbricamente mediante una app Android personalizada. Te muestro todo el proceso: diseño e impresión 3D de piezas, conexión electrónica, programación Arduino, y desarrollo de nuestra app Android para control.

Puedes ver el vídeo o leer el tutorial escrito.

Resumen

Con sliders en la app controlamos manualmente cada servo/eje del brazo. Con botón "Save" (Guardar) grabamos cada posición/paso y el brazo ejecuta automáticamente la secuencia. Mismo botón pausa operación automática, y "Reset" borra pasos para grabar nuevos.

Modelo 3D Brazo Robot Arduino

Diseñé el brazo robot con Solidworks. Tiene 5 grados de libertad.

Construye un brazo robot Arduino sin cables, controlado desde tu smartphone

Para primeros 3 ejes (base, hombro, codo): servos MG996R. Para otros 2 ejes (muñeca roll, pitch) y pinza: servos SG90 micro.

Modelo 3D para descargar y explorar en navegador en Thangs:

Descargar modelo ensamblado desde Thangs.

Gracias Thangs por apoyar este tutorial.

Archivos STL para impresión 3D:

Archivos STL Brazo Robot Arduino

1 archivo(s) 0.00 KB Descargar

Impresión 3D del brazo robot

Con mi nueva impresora Creality CR-10, imprimí todas las piezas.

Agradecimiento a Banggood.com por proporcionar esta impresora. Calidad CR-10 increíble para su precio y viene ~90% pre-ensamblada.

Para completar ensamblaje: unir marco superior e inferior con tornillos/soportes, conectar electrónica a caja control con cables provistos.

Recomendado: verificar ruedas rodillos estén bien ajustadas; si no, usar tuercas excéntricas para apretar. Tras nivelar cama, ¡listo para transformar creaciones 3D en realidad!

Todas las piezas listas en pocas horas.

Leer más: Top 15 Accesorios y Herramientas Imprescindibles para Impresora 3D

Ensamblaje del brazo robot

Listos para ensamblar. Empecé por base: primer servo atornillado (tornillos incluidos). En eje salida puse disco redondo y tornillo.

Encima coloqué parte superior y aseguré con 2 tornillos.

Mismo patrón: servo → disco en siguiente pieza → asegurar con tornillo eje salida.

En eje hombro es buena idea incluir muelle (en mi caso goma elástica) para ayudar al servo, ya que soporta peso resto del brazo + carga.

Continué ensamblando resto. Para pinza usé tornillos/ tuercas 4 mm.

Finalmente pinza en último servo → brazo robot completado.

Diagrama de circuito brazo robot Arduino

Etapa electrónica. Esquema simple: Arduino + módulo Bluetooth HC-05 para comunicación smartphone. Pines control 6 servos → 6 pines digitales Arduino.

Alimentación servos: 5V desde fuente externa (Arduino no aguanta corriente de todos). Fuente mín 2A. Conectado todo, pasamos a programar Arduino y crear app Android.

Componentes necesarios:

Motor Servo MG996R……………………….….
Motor Servo SG90 Micro ……..…….….…….
Módulo Bluetooth HC-05 ………………….…
Placa Arduino …………………………………….
Fuente DC 5V 2A ………………….…..

Código Brazo Robot Arduino

Código largo; lo publico en secciones con descripción. Al final, código completo.

Incluimos librería SoftwareSerial (comunicación serial Bluetooth) y Servo.h. Ambas vienen con Arduino IDE. Definimos 6 servos, módulo HC-05, variables posiciones actual/anterior, arrays para guardar posiciones/pasos modo automático.

#include <SoftwareSerial.h>
#include <Servo.h>
Servo servo01, servo02, servo03, servo04, servo05, servo06;
SoftwareSerial Bluetooth(3, 4); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)
int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // posición actual
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // posición anterior
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // posiciones/pasos
int speedDelay = 20;
int index = 0;
String dataIn = "";

En setup(): inicializar servos y Bluetooth, mover brazo a posición inicial con write() (0-180°).

void setup() {
  servo01.attach(5); servo02.attach(6); servo03.attach(7);
  servo04.attach(8); servo05.attach(9); servo06.attach(10);
  Bluetooth.begin(38400); // Baud rate default HC-05
  Bluetooth.setTimeout(1);
  delay(20);
  // Posición inicial brazo
  servo1PPos = 90;  servo01.write(servo1PPos);
  servo2PPos = 150; servo02.write(servo2PPos);
  servo3PPos = 35;  servo03.write(servo3PPos);
  servo4PPos = 140; servo04.write(servo4PPos);
  servo5PPos = 85;  servo05.write(servo5PPos);
  servo6PPos = 80;  servo06.write(servo6PPos);
}

En loop(), con Bluetooth.available() comprobamos datos entrantes smartphone. Si hay, readString() lee como string y guarda en dataIn. Según dato recibido, decidimos acción.

// Comprobar datos entrantes
if (Bluetooth.available() > 0) {
  dataIn = Bluetooth.readString(); // Leer dato como string

App Control Android

Veamos la app Android y qué datos envía a Arduino.

App hecha con MIT App Inventor online. Arriba: 2 botones conectar smartphone a HC-05. Izquierda: imagen brazo robot. Derecha: 6 sliders control servos + 1 slider velocidad.

Cada slider tiene valor inicial, mín y máx adecuados a juntas del brazo. Abajo: botones SAVE, RUN, RESET para programar ejecución automática. Etiqueta muestra número pasos guardados. Para detalles construcción apps MIT App Inventor, ver mi otro tutorial.

Bloques detrás de la app. Izquierda: bloques conexión Bluetooth.

Sliders control posición servos y botones programación. Al mover slider, con Bluetooth.SendText enviamos texto a Arduino: prefijo indica qué slider cambió + valor actual.

Archivos descarga: proyecto MIT App Inventor y app Android lista instalar:

Proyecto MIT App Inventor Control Brazo Robot

1 archivo(s) 24.85 KB Descargar Construye un brazo robot Arduino sin cables, controlado desde tu smartphone

App Android Control Brazo Robot

1 archivo(s) 2.57 MB Descargar

En Arduino, con startsWith() comprobamos prefijo dato entrante y sabemos qué hacer. Ej.: prefijo "s1" → mover servo 1. Con substring() extraemos valor posición, convertimos a int y movemos servo.

// Si slider "Waist" cambió - Mover Servo 1 a posición
if (dataIn.startsWith("s1")) {
  String dataInS = dataIn.substring(2, dataIn.length()); // Extraer número. Ej: "s1120" -> "120"
  servo1Pos = dataInS.toInt(); // Convertir string a integer

Podríamos llamar write() directo, pero servo iría a máxima velocidad (demasiado rápido). Controlamos velocidad con bucles FOR para mover gradualmente de posición anterior a actual con delay entre iteraciones. Cambiando delay cambias velocidad.

// Bucles FOR para controlar velocidad servo
// Si posición anterior > actual
if (servo1PPos > servo1Pos) {
  for (int j = servo1PPos; j >= servo1Pos; j--) {
    servo01.write(j); // Bajando servo
    delay(20); // Define velocidad rotación
  }
}
// Si posición anterior < actual
if (servo1PPos < servo1Pos) {
  for (int j = servo1PPos; j <= servo1Pos; j++) {
    servo01.write(j); // Subiendo servo
    delay(20);
  }
}
servo1PPos = servo1Pos; // Actualizar posición anterior

Mismo método para cada eje del brazo.

Botón SAVE: guarda posición cada servo en array. Cada pulsación incrementa índice → array se llena paso a paso.

// Si botón "SAVE" pulsado
if (dataIn.startsWith("SAVE")) {
  servo01SP[index] = servo1PPos;
  servo02SP[index] = servo2PPos;
  servo03SP[index] = servo3PPos;
  servo04SP[index] = servo4PPos;
  servo05SP[index] = servo5PPos;
  servo06SP[index] = servo6PPos;
  index++; // Incrementar índice array
}

Botón RUN: llama función runservo() que ejecuta pasos guardados. Veamos función: ejecuta pasos guardados en bucle hasta pulsar RESET. Bucle FOR recorre posiciones arrays y comprobamos datos entrantes smartphone. Dato puede ser RUN/PAUSE (pausa robot, si pulsas de nuevo continúa). Si cambias slider velocidad, usamos ese valor para cambiar delay en bucles FOR → controla velocidad servos.

// Función modo automático - ejecuta pasos guardados
void runservo() {
  while (dataIn != "RESET") { // Repite hasta botón RESET
    for (int i = 0; i <= index - 2; i++) { // Recorre todos pasos
      if (Bluetooth.available() > 0) {
        dataIn = Bluetooth.readString();
        if (dataIn == "PAUSE") { // Botón PAUSE
          while (dataIn != "RUN") { // Espera RUN
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.readString();
              if (dataIn == "RESET") break;
            }
          }
        }
        // Si slider velocidad cambiado
        if (dataIn.startsWith("ss")) {
          String dataInS = dataIn.substring(2, dataIn.length());
          speedDelay = dataInS.toInt(); // Cambia velocidad servos (delay)
        }
      }
      // 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);
        }
      }
      // ... (resto servos 2-6 mismo patrón)
    }
  }
}

Con IFs y bucles FOR movemos servos a siguiente posición. Finalmente botón RESET: limpia arrays a cero y resetea índice a cero para reprogramar nuevos movimientos.

// Si botón "RESET" pulsado
if (dataIn == "RESET") {
  memset(servo01SP, 0, sizeof(servo01SP));
  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;
}

¡Listo! A disfrutar y divertirse con el brazo robot.

Código completo Brazo Robot Arduino:

/* DIY Arduino Robot Arm Smartphone Control por Dejan, www.HowToMechatronics.com */
#include <SoftwareSerial.h>
#include <Servo.h>
Servo servo01, servo02, servo03, servo04, servo05, servo06;
SoftwareSerial Bluetooth(3, 4); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)
int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos;
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos;
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50];
int speedDelay = 20;
int index = 0;
String dataIn = "";

void setup() {
  servo01.attach(5); servo02.attach(6); servo03.attach(7);
  servo04.attach(8); servo05.attach(9); servo06.attach(10);
  Bluetooth.begin(38400); Bluetooth.setTimeout(1); delay(20);
  servo1PPos = 90;  servo01.write(servo1PPos);
  servo2PPos = 150; servo02.write(servo2PPos);
  servo3PPos = 35;  servo03.write(servo3PPos);
  servo4PPos = 140; servo04.write(servo4PPos);
  servo5PPos = 85;  servo05.write(servo5PPos);
  servo6PPos = 80;  servo06.write(servo6PPos);
}

void loop() {
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.readString();
    // Servo 1 (Waist)
    if (dataIn.startsWith("s1")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo1Pos = dataInS.toInt();
      if (servo1PPos > servo1Pos) {
        for (int j = servo1PPos; j >= servo1Pos; j--) { servo01.write(j); delay(20); }
      }
      if (servo1PPos < servo1Pos) {
        for (int j = servo1PPos; j <= servo1Pos; j++) { servo01.write(j); delay(20); }
      }
      servo1PPos = servo1Pos;
    }
    // Servo 2 (Shoulder)
    if (dataIn.startsWith("s2")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo2Pos = dataInS.toInt();
      if (servo2PPos > servo2Pos) {
        for (int j = servo2PPos; j >= servo2Pos; j--) { servo02.write(j); delay(50); }
      }
      if (servo2PPos < servo2Pos) {
        for (int j = servo2PPos; j <= servo2Pos; j++) { servo02.write(j); delay(50); }
      }
      servo2PPos = servo2Pos;
    }
    // Servo 3 (Elbow)
    if (dataIn.startsWith("s3")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo3Pos = dataInS.toInt();
      if (servo3PPos > servo3Pos) {
        for (int j = servo3PPos; j >= servo3Pos; j--) { servo03.write(j); delay(30); }
      }
      if (servo3PPos < servo3Pos) {
        for (int j = servo3PPos; j <= servo3Pos; j++) { servo03.write(j); delay(30); }
      }
      servo3PPos = servo3Pos;
    }
    // Servo 4 (Wrist Roll)
    if (dataIn.startsWith("s4")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo4Pos = dataInS.toInt();
      if (servo4PPos > servo4Pos) {
        for (int j = servo4PPos; j >= servo4Pos; j--) { servo04.write(j); delay(30); }
      }
      if (servo4PPos < servo4Pos) {
        for (int j = servo4PPos; j <= servo4Pos; j++) { servo04.write(j); delay(30); }
      }
      servo4PPos = servo4Pos;
    }
    // Servo 5 (Wrist Pitch)
    if (dataIn.startsWith("s5")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo5Pos = dataInS.toInt();
      if (servo5PPos > servo5Pos) {
        for (int j = servo5PPos; j >= servo5Pos; j--) { servo05.write(j); delay(30); }
      }
      if (servo5PPos < servo5Pos) {
        for (int j = servo5PPos; j <= servo5Pos; j++) { servo05.write(j); delay(30); }
      }
      servo5PPos = servo5Pos;
    }
    // Servo 6 (Gripper)
    if (dataIn.startsWith("s6")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo6Pos = dataInS.toInt();
      if (servo6PPos > servo6Pos) {
        for (int j = servo6PPos; j >= servo6Pos; j--) { servo06.write(j); delay(30); }
      }
      if (servo6PPos < servo6Pos) {
        for (int j = servo6PPos; j <= servo6Pos; j++) { servo06.write(j); delay(30); }
      }
      servo6PPos = servo6Pos;
    }
    // Botón SAVE
    if (dataIn.startsWith("SAVE")) {
      servo01SP[index] = servo1PPos;
      servo02SP[index] = servo2PPos;
      servo03SP[index] = servo3PPos;
      servo04SP[index] = servo4PPos;
      servo05SP[index] = servo5PPos;
      servo06SP[index] = servo6PPos;
      index++;
    }
    // Botón RUN
    if (dataIn.startsWith("RUN")) {
      runservo();
    }
    // Botón RESET
    if (dataIn == "RESET") {
      memset(servo01SP, 0, sizeof(servo01SP));
      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;
    }
  }
}

void runservo() {
  while (dataIn != "RESET") {
    for (int i = 0; i <= index - 2; i++) {
      if (Bluetooth.available() > 0) {
        dataIn = Bluetooth.readString();
        if (dataIn == "PAUSE") {
          while (dataIn != "RUN") {
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.readString();
              if (dataIn == "RESET") break;
            }
          }
        }
        if (dataIn.startsWith("ss")) {
          String dataInS = dataIn.substring(2, dataIn.length());
          speedDelay = dataInS.toInt();
        }
      }
      // 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); }
      }
    }
  }
}

¡Espero que te haya gustado y aprendido algo nuevo! Preguntas en comentarios y revisa mi Colección Proyectos Arduino.