Conectar, calibrar y armar el brazo de 6 servomotores
Recorrido del nivel
Esa barra de arriba te dice en qué paso estás. Tocala para ver el índice completo y saltar a cualquier paso.
Conectar los seis servomotores
El brazo tiene 6 motores (servomotoresServomotorMotor que se ubica en un ángulo específico (los comunes, de 0° a 180°) y se mantiene ahí. Se programa indicando el ángulo deseado; tiene tres cables: alimentación (VCC, GND) y señal.) 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).
En el Arduino UNO usamos el IO Expansion ShieldShieldPlaca modular que se monta encimada sobre una placa Arduino, encastrando en sus pines, para agregarle funciones (pantalla, sensores, comunicación). Suele diseñarse para un modelo concreto: el LCD Keypad Shield tiene el formato del Arduino UNO y no encaja en un ESP32. 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°.
Para el aula
Este código reemplaza al de bloques del original (mBlock3, discontinuado). El programa de bloques
generaba seis instrucciones servo_2.write(90) … servo_7.write(90) sueltas, más un andamiaje
(angle_rad, _delay, _loop) que el editor agregaba solo. La versión con un arreglo y un for
hace exactamente lo mismo con menos líneas y se lee mejor: “poné los seis servos en 90”. Es una
buena oportunidad para mostrar que un bucle no es “más difícil”, es menos repetición.
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 puertoPuerto COMPuerto de comunicaciones por el cual el sistema operativo se comunica con un dispositivo externo, como la placa. Se asigna automáticamente al conectarla por USB y puede cambiar de número; en el IDE hay que indicar cuál usar. (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.
Verificá
Con el código cargado y la fuente conectada, los seis servos tienen que girar hasta 90° y quedarse ahí, firmes. Si alguno no se mueve, revisá que sus tres cables estén en la fila correcta (señal, VCC, GND) y que la fuente externa esté encendida. Antes de energizar, despejá la zona: al arrancar, los servos saltan a 90° de golpe.
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 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 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.
} 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.
De la pose fija a la coreografía
Hoy el brazo llega a una pose (todos a 90°) y se queda quieto: el loop() está vacío. ¿Cómo harían
para que repita un movimiento, por ejemplo mover la base a un lado, bajar el codo y volver, una
y otra vez? Pista: eso ya no va en setup() sino en loop(), y necesitan una espera entre
movimiento y movimiento para alcanzar a ver cada paso. Es exactamente la idea que van a desarrollar
en el nivel avanzado, cuando el brazo tome y coloque objetos en 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.