Saltar al contenido
Nivel inicial

Conectar, calibrar y armar el brazo de 6 servomotores

Conectar los seis servomotores

El brazo tiene 6 motores (servomotores) que le permiten rotar y trasladarse en el espacio imitando el movimiento de un brazo humano. Cada servo mueve una articulación —base, hombro, codo, muñeca, rotación de la pinza y apertura/cierre de la pinza—, y juntos le dan al brazo sus 6 grados de libertad. Cada servo tiene tres cables: el naranja o amarillo es la señal (va al pin de datos), el rojo es el positivo (VCC) y el marrón o negro es el negativo (GND).

Esquema de conexión: seis servomotores rotulados SERVO en fila, cada uno con tres cables, conectados a una placa Arduino con el IO Expansion Shield de DFRobot. A la izquierda, una fuente externa rotulada Fuente externa 5 Volt 2 Amp se conecta a la entrada de alimentación de servos del shield.
Conexión de los seis servomotores al IO Shield de DFRobot con la fuente externa de 5 V 2 A (figura original del proyecto). El shield agrupa, para cada pin, la señal (D), el positivo (VCC) y el negativo (GND).

En el Arduino UNO usamos el IO Expansion Shield de DFRobot, que se apila sobre la placa. Para cada pin ofrece una fila de tres contactos —señal, VCC y GND—, así que el servo se enchufa completo sin cablear la alimentación aparte. Conectamos los seis servos a los pines 2, 3, 4, 5, 6 y 7 (servo 1 = pin 2 … servo 6 = pin 7). El shield tiene dos grupos de 5 pines de un lado y dos grupos de 6 del otro: hay un solo modo de encastrarlo sin forzar las piezas.

El IO Shield de DFRobot está hecho para el formato del Arduino UNO y no encaja en un ESP32. Por eso, en esta placa no se usa shield: cada servo se cablea directo, con la señal a un GPIO y la alimentación a la fuente externa (con GND común). Conectamos los seis servos a los GPIO 13, 14, 25, 26, 27 y 32 (servo 1 = GPIO 13 … servo 6 = GPIO 32). En el ESP32 los servos se manejan con la librería ESP32Servo (la Servo.h clásica del UNO no funciona en esta placa).

Como el consumo de corriente de seis servos es alto, el sistema necesita una fuente de alimentación externa de 5V 2A. No la tomamos del USB: seis servos moviéndose a la vez piden más corriente de la que da el puerto, y podrían resetear la placa o dañar su regulador. La fuente comparte GND con la placa.

Programar los ángulos de los servomotores (calibración)

Antes de armar el brazo hay que calibrar los servos: llevarlos a todos a 90°, el centro de su recorrido (que va de 0° a 180°). Con los seis en 90°, el brazo queda en una posición neutra desde la que puede girar por igual hacia ambos lados; si armáramos el brazo con los servos en una posición cualquiera, quedaría torcido y con menos margen de movimiento.

La programación la hacemos directamente en el lenguaje de Arduino (C++), con el Arduino IDE 2.x, que se descarga gratis de arduino.cc/en/software. Un programa de Arduino se llama sketch y tiene dos bloques: setup(), que se ejecuta una sola vez al encender, y loop(), que se repite después. La calibración vive en setup(): el programa engancha cada servo a su pin y le ordena write(90). Para no repetir seis veces lo mismo, guardamos los pines en un arreglo y recorremos los seis con un for. En este nivel el loop() queda vacío a propósito: la calibración es estática, los servos solo tienen que sostener los 90°.

Subir el código a la placa

Para subir el programa, conectá la placa a la computadora, elegí en el Arduino IDE 2.x la placa y el puerto (en el IDE 2.x se eligen juntos en el desplegable de la barra superior) y apretá el botón Subir (la flecha →). Al terminar, aparece el mensaje de carga completada. Con la fuente externa conectada, los seis servomotores deberían moverse a su nueva posición de 90°.

Para el Arduino UNO: usá el cable USB tipo B, elegí la placa Arduino UNO y el puerto que se agregó al conectarla. La librería Servo ya viene incluida con el IDE. Si tu placa DFRobot no es reconocida, quizás necesites el driver del conversor CH340 (era un requisito del material original).

Para el ESP32 hay dos pasos que se hacen una sola vez: instalar el soporte de placas ESP32 desde el gestor de placas (buscá “esp32” e instalá el paquete de Espressif) y, desde el Gestor de bibliotecas, la librería ESP32Servo. Si el puerto no aparece, instalá el driver del conversor USB-serie (CP210x o CH340). Elegí la placa ESP32 Dev Module y el puerto. Si al subir queda en “Connecting…”, mantené apretado el botón BOOT.

Armar el brazo robótico

Con los servos calibrados a 90°, recién ahora ensamblamos el brazo del kit sobre ellos: cada servo queda en el centro de su recorrido, así que las piezas mecánicas se montan derechas y el brazo puede moverse el mismo ángulo hacia un lado y hacia el otro. El material original acompaña el armado con un video paso a paso.

Si no contás con una mesa o superficie donde fijar la base del brazo, conviene imprimir en 3D unas piezas de soporte y lastrarlas con material de descarte (por ejemplo, metal) para darle estabilidad: un brazo que se mueve con fuerza necesita una base firme para no volcarse. Estas piezas forman parte de los paquetes de fabricación del proyecto, que se descargan desde su ficha.

Programar un movimiento sincronizado de los servomotores

Con el brazo armado, vemos su primer movimiento sincronizado: el mismo programa de calibración que subimos es el que produce ese movimiento. Cuando la placa arranca o se resetea, los seis servos se mueven a 90° al mismo tiempo, desde donde estuvieran hasta el centro. Ese salto coordinado de las seis articulaciones es la primera vez que el brazo se mueve como un conjunto: no seis motores sueltos, sino un cuerpo articulado que adopta una pose común.

Ver el código completo · brazo-calibracion.ino
brazo-calibracion.ino Arduino UNO
// Brazo robotico — Nivel Inicial (Arduino UNO).
//
// CALIBRACION: los 6 servomotores se llevan a 90 grados (posicion central).
// Es el punto de partida obligatorio del armado: con todos los servos a 90 el
// brazo puede girar en ambos sentidos por igual, tal como pide el Paso 1 de la
// guia ("asegurarnos de que la posicion de los servomotores sea de 90").
//
// Plataforma: Arduino UNO con IO Shield de DFRobot (el shield expone los pines
// de servo con alimentacion; no cambia el numero de pin). Proyecto de BAJA
// TENSION (servos 5 V): no hay 220 V ni agua.
//
// ATENCION — ALIMENTACION: seis servos consumen demasiada corriente para el
// puerto USB. Es OBLIGATORIO usar la FUENTE EXTERNA 5V 2A con GND comun a la
// placa. Alimentar por USB puede resetear el Arduino o danar el regulador.
//
// ATENCION — MECANICA: el brazo tiene 6 grados de libertad y al energizarse
// salta a 90 grados de golpe. Despejar la zona de barrido antes de conectar.
//
// Nivel inicial: se permite delay() (fiel a la progresion original).
//
// Basado en: Fragmento de codigo del Nivel Inicial, Paso 2 — Brazo Robotico,
// Saberes Digitales (INET/EDUCAR 2019).
// Desvios respecto del original (ver README):
//  (1) mBlock3 -> C++ limpio: se elimina el cruft del generador de bloques
//      (angle_rad/angle_deg, _delay/_loop) y los nombres servo_2..servo_7.
//  (2) Los seis servos se manejan con un arreglo indexado por constante, sin
//      numeros magicos en el cuerpo del programa.

#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

// --- Servomotores (contrato UNO: pines digitales 2..7) ---
// Indice 0 = servo 1 (base) ... indice 5 = servo 6 (pinza).
const int CANT_SERVOS = 6;
const int PINES_SERVO[CANT_SERVOS] = {2, 3, 4, 5, 6, 7};

// Angulo de calibracion: centro del recorrido 0..180.
const int ANGULO_CENTRO = 90;

Servo servos[CANT_SERVOS];

void setup() {
  // Enganchar cada servo a su pin y llevarlo al centro. Al terminar, el brazo
  // queda calibrado y listo para el armado mecanico.
  for (int i = 0; i < CANT_SERVOS; i++) {
    servos[i].attach(PINES_SERVO[i]);
    servos[i].write(ANGULO_CENTRO);
  }
}

void loop() {
  // Calibracion estatica: no hay movimiento. Los seis servos sostienen los 90
  // grados; el loop queda vacio a proposito.
}
brazo-calibracion.ino ESP32
// Brazo robotico — Nivel Inicial (ESP32 DevKit v1).
//
// CALIBRACION: los 6 servomotores se llevan a 90 grados (posicion central),
// punto de partida del armado (Paso 1: "asegurarnos de que la posicion de los
// servomotores sea de 90"), para que el brazo pueda girar por igual en ambos
// sentidos.
//
// Plataforma: ESP32 (DevKit v1). Se usa la libreria ESP32Servo (la Servo.h
// clasica NO funciona en ESP32). El IO Shield de DFRobot es para UNO: en ESP32
// NO se usa shield, los servos se cablean directo a los GPIO (senal al GPIO,
// alimentacion a la fuente externa, GND comun).
//
// ATENCION — ALIMENTACION: seis servos NO se alimentan por USB. Es OBLIGATORIA
// la FUENTE EXTERNA 5V 2A con GND comun. El ESP32 trabaja a 3,3 V pero el pin
// de senal del servo tolera ese nivel; la potencia sale de la fuente de 5 V.
//
// ATENCION — MECANICA: 6 grados de libertad; al energizar, los servos saltan a
// 90 grados. Despejar la zona de barrido.
//
// Nivel inicial: se permite delay() (fiel a la progresion original).
//
// Basado en: Fragmento de codigo del Nivel Inicial, Paso 2 — Brazo Robotico,
// Saberes Digitales (INET/EDUCAR 2019).
// Desvios (ver README): mBlock3 -> C++ limpio (sin angle_rad/deg, sin
// _delay/_loop, sin servo_2..servo_7); GPIO seguros del contrato; sin shield.

#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

// --- Servomotores (contrato ESP32: GPIO 13,14,25,26,27,32 con ESP32Servo) ---
// Indice 0 = servo 1 (base) ... indice 5 = servo 6 (pinza).
const int CANT_SERVOS = 6;
const int PINES_SERVO[CANT_SERVOS] = {13, 14, 25, 26, 27, 32};

const int ANGULO_CENTRO = 90;

Servo servos[CANT_SERVOS];

void setup() {
  for (int i = 0; i < CANT_SERVOS; i++) {
    servos[i].attach(PINES_SERVO[i]);
    servos[i].write(ANGULO_CENTRO);
  }
}

void loop() {
  // Calibracion estatica: los seis servos sostienen los 90 grados.
}
Calibración del brazo: en setup() los seis servos se enganchan a su pin y se llevan a 90° con un bucle. Lo único que cambia entre plataformas son los pines (2..7 en el UNO; GPIO 13..32 en el ESP32) y la librería del servo (Servo / ESP32Servo).

Podés ver cómo las seis articulaciones se acomodan a 90° en el simulador, antes de energizar el brazo real:

Simulación del comportamiento

La misma máquina de estados del firmware, portada a TypeScript, maneja el comportamiento del dispositivo. No se ejecuta el binario real: la ejecución del .hex con avr8js está en el roadmap.

Simulación lista. Presioná «Iniciar» para arrancar la secuencia.

Cierre del nivel

Al terminar este nivel, tu brazo robótico ya existe físicamente: los seis servos están conectados y alimentados con la fuente externa, calibrados a 90° y con las piezas del kit ensambladas sobre ellos. Subiste el programa desde el Arduino IDE 2.x y viste a las seis articulaciones moverse de forma sincronizada. Pero por ahora el brazo hace un único gesto fijo. En el nivel intermedio vamos a darle un mando a distancia: seis potenciómetros con los que vas a mover cada articulación con la mano, como los controles de una grúa.

Evidencia de cierre

Al terminar este nivel, esto tiene que estar funcionando:

  • Los seis servomotores están conectados al IO Shield de DFRobot (o directo a los GPIO en el ESP32) y alimentados con la fuente externa de 5V 2A, con GND común a la placa.
  • Subiste desde el Arduino IDE 2.x el programa de calibración: al energizar, los seis servos se mueven a 90° de forma sincronizada y sostienen esa posición.
  • El brazo del kit está ensamblado sobre los servos ya calibrados a 90°, de modo que puede girar por igual hacia ambos lados desde el centro.
  • Entendés que seis servos necesitan la fuente externa (no alcanza el USB) y que, antes de energizar, hay que despejar la zona de movimiento del brazo.