Brazo Robótico Inteligente Controlado por Arduino: Tutorial DIY Fácil

Componentes y suministros

Sobre el proyecto

Brazo robótico simple controlado por un "brazo maestro" con potenciómetros. El brazo memoriza movimientos y los reproduce en secuencia. Inspirado en "Mini Robotic Arm" de Stoerpeak. Diseño barato, sencillo y compartido.

Paso 1: Materiales

• 5 Servomotores
• 5 Potenciómetros
• Arduino UNO
• Fuente 5V (o adaptador)
• Protoboard
• Material estructural: cartón, madera, palitos de helado, etc.
• Arduino IDE instalado

Paso 2: Construcción del brazo

Se usaron palitos de helado para la estructura. Servos pegados con cinta doble cara y atornillados. Potenciómetros pegados a palitos para el brazo maestro. Todo montado sobre base de cartón A4.

Paso 3: Conexiones

• Servos en paralelo a fuente externa: Rojo a +5V, Negro/Marrón a GND. Importante: Conectar GND de servos a GND de Arduino.
• Señal de servos (Naranja/Amarillo) a pines PWM: 3, 5, 6, 9, 10.
• Potenciómetros: extremos a +5V y GND en paralelo; cursor a pines analógicos A0-A4.
• Correspondencia: Servo pin 3 ← Potenciómetro A0, pin 5 ← A1, etc.

Paso 4: Programación

Lógica: leer potenciómetros, mapear a 0-179°, mover servos. Al pulsar 'R' en monitor serie, graba posiciones en array. Al pulsar 'P', reproduce la secuencia.

Variables globales

#include <Servo.h>
Servo Servo_0, Servo_1, Servo_2, Servo_3, Servo_4;
int Pot_0, Pot_1, Pot_2, Pot_3, Pot_4;
int Servo_0_Pos, Servo_1_Pos, Servo_2_Pos, Servo_3_Pos, Servo_4_Pos;
int Prev_0_Pos, Prev_1_Pos, Prev_2_Pos, Prev_3_Pos, Prev_4_Pos;
int Current_0_Pos, Current_1_Pos, Current_2_Pos, Current_3_Pos, Current_4_Pos;
int Servo_Position, Servo_Number;
int Storage[600]; // Array para grabar movimientos
int Index = 0;
char data = 0;

setup()

void setup() {
  Serial.begin(9600);
  Servo_0.attach(3); Servo_1.attach(5); Servo_2.attach(6);
  Servo_3.attach(9); Servo_4.attach(10);
  Servo_0.write(100); Servo_1.write(100); Servo_2.write(100);
  Servo_3.write(100); Servo_4.write(100);
  Serial.println("Press 'R' to Record and 'P' to play");
}

Función Map_Pot()

void Map_Pot() {
  Pot_0 = analogRead(A0); Servo_0_Pos = map(Pot_0, 0, 1023, 1, 179); Servo_0.write(Servo_0_Pos);
  Pot_1 = analogRead(A1); Servo_1_Pos = map(Pot_1, 0, 1023, 1, 179); Servo_1.write(Servo_1_Pos);
  Pot_2 = analogRead(A2); Servo_2_Pos = map(Pot_2, 0, 1023, 1, 179); Servo_2.write(Servo_2_Pos);
  Pot_3 = analogRead(A3); Servo_3_Pos = map(Pot_3, 0, 1023, 1, 179); Servo_3.write(Servo_3_Pos);
  Pot_4 = analogRead(A4); Servo_4_Pos = map(Pot_4, 0, 1023, 1, 179); Servo_4.write(Servo_4_Pos);
}

loop() - Grabación y reproducción

void loop() {
  Map_Pot();
  while (Serial.available() > 0) {
    data = Serial.read();
    if (data == 'R') Serial.println("Recording Moves...");
    if (data == 'P') Serial.println("Playing Recorded Moves...");
  }
  if (data == 'R') {
    // Guardar posiciones previas
    Prev_0_Pos = Servo_0_Pos; Prev_1_Pos = Servo_1_Pos; Prev_2_Pos = Servo_2_Pos;
    Prev_3_Pos = Servo_3_Pos; Prev_4_Pos = Servo_4_Pos;
    Map_Pot(); // Leer nuevas posiciones
    // Comparar y guardar cambios en array Storage con offset por servo
    if (abs(Prev_0_Pos - Servo_0_Pos) > 0) { Storage[Index] = Servo_0_Pos + 0; Index++; Current_0_Pos = Servo_0_Pos; }
    if (abs(Prev_1_Pos - Servo_1_Pos) > 0) { Storage[Index] = Servo_1_Pos + 100; Index++; Current_1_Pos = Servo_1_Pos; }
    if (abs(Prev_2_Pos - Servo_2_Pos) > 0) { Storage[Index] = Servo_2_Pos + 200; Index++; Current_2_Pos = Servo_2_Pos; }
    if (abs(Prev_3_Pos - Servo_3_Pos) > 0) { Storage[Index] = Servo_3_Pos + 300; Index++; Current_3_Pos = Servo_3_Pos; }
    if (abs(Prev_4_Pos - Servo_4_Pos) > 0) { Storage[Index] = Servo_4_Pos + 400; Index++; Current_4_Pos = Servo_4_Pos; }
    // Imprimir posiciones
    Serial.print(Servo_0_Pos); Serial.print("\t"); Serial.print(Servo_1_Pos); Serial.print("\t");
    Serial.print(Servo_2_Pos); Serial.print("\t"); Serial.print(Servo_3_Pos); Serial.print("\t");
    Serial.println(Servo_4_Pos); Serial.print("Index = "); Serial.println(Index);
    delay(50);
  }
  if (data == 'P') {
    for (int i = 0; i < Index; i++) {
      Servo_Number = Storage[i] / 100;
      Servo_Position = Storage[i] % 100;
      switch (Servo_Number) {
        case 0: Servo_0.write(Servo_Position); break;
        case 1: Servo_1.write(Servo_Position); break;
        case 2: Servo_2.write(Servo_Position); break;
        case 3: Servo_3.write(Servo_Position); break;
        case 4: Servo_4.write(Servo_Position); break;
      }
      delay(50);
    }
  }
}

Paso 5: Pruebas

1. Sube el código, abre Monitor Serie (9600 baudios). Arduino se reinicia.
2. Controla el brazo con el maestro. Nada se graba aún.
3. Escribe 'R' y realiza los movimientos a grabar.
4. Escribe 'P' para reproducir la secuencia grabada. Se repite hasta reset.

Esquemático