Construye un Robot Hexápodo Arduino Tipo Hormiga: Guía Paso a Paso

En este tutorial te muestro cómo construí un hexápodo Arduino. Como su nombre indica, tiene 6 patas, pero además cola/abdomen, cabeza, antenas, mandíbulas e incluso ojos funcionales. Todo esto hace que parezca una hormiga, así que también lo llamamos Robot Hormiga Arduino.

Puedes ver el video o leer el tutorial escrito a continuación.

Resumen

Para controlar el robot hice una aplicación Android personalizada con 4 botones: avanzar, retroceder, girar izquierda/derecha. Además el robot mueve cabeza y cola, puede morder, agarrar, soltar y atacar.

Los ojos funcionales son en realidad un sensor ultrasónico HC-SR04 integrado en la cabeza. Si acercamos la mano, el robot se prepara para atacar.

Si nos alejamos, cancela el ataque; si nos acercamos más, ataca y muerde. ¡Genial! Quédate para ver exactamente cómo lo construí y cómo funciona.

Modelo 3D del Hexápodo Arduino - Robot Hormiga

Como siempre, empecé diseñando el hexápodo en software 3D. Tiene 6 patas, cada una con 3 articulaciones (3 servos) = 18 servos. Usé servos MG996R.

La cola usa otro MG996R. La cabeza tiene 2 grados de libertad (balanceo e inclinación) con 2 servos más. Total: 21 servos MG996R + 1 micro servo SG90 para mandíbulas.

Los ojos están diseñados para encajar el sensor HC-SR04. Todas las piezas se ensamblan entre dos placas, con una cubierta curva superior para ocultar cableado, Arduino y batería.

Puedes encontrar y descargar el modelo 3D, y explorarlo en el navegador en Thangs.

Impresión 3D de las Piezas

Imprimí todas las piezas en mi Creality CR-10, que hizo un gran trabajo. La parte más difícil fue la cabeza, queriéndola en una sola impresión.

Usé ángulo de voladizo de soporte de 60° y bloqueadores de soporte. El CR-10 lo hizo perfecto.

Ensamblaje del Hexápodo Arduino

Con todas las piezas impresas, empecé montando las patas. Para fijar servos a piezas impresas usé tornillos M3 y tuercas, con arandelas elásticas. Tornillos de al menos 12mm (usé 16mm).

Se necesitan ~200 tornillos para todo. Para conectar eslabones usé los cuernos redondos que vienen con los servos, taladrando orificios de 3mm, o cuernos metálicos con rosca M3.

Al fijar eslabones a servos, asegurarse de conectarlos siempre en la misma posición y con rango completo de movimiento. Los servos tienen un soporte triangular superior que hay que quitar (cúter) para que queden a ras.

Antes del tercer servo, insertamos un tornillo M4 para unir la pata a la placa base.

Con las 6 patas listas, las instalamos en el cuerpo (dos placas). Primero fijamos cuernos redondos en la placa superior. Luego conectamos a los ejes de los servos, pero antes ajustamos la posición de los servos exactamente al centro.

Esto asegura rango completo de movimiento y reduce calibración posterior. Tras fijar las patas, ya parece un hexápodo.

Hay un cuerno más atrás para el servo de la cola. Ponemos el hexápodo boca abajo para insertar la placa inferior por los tornillos M4 de las patas. Aseguramos con arandelas y tuercas autoblocantes. Cuidado al apretar: son pivotes y las patas deben rotar.

Instalamos el primer servo de la cabeza (balanceo). Debe ser perpendicular a las placas, así que hice dos plaquetas para fijarlo. Luego insertamos entre placas y aseguramos con M3.

Tenemos un soporte en U para conectar los dos servos de la cabeza. Fijamos dos cuernos redondos. Antes de asegurar al servo de balanceo, centramos su posición para ±90°.

Soporte del servo de inclinación: insertamos tornillo M4 y lo aseguramos al soporte en U. Antes de montar el motor de inclinación, insertamos 4 tornillos M3 para fijar la cabeza después. Insertamos el servo y encajamos el eje en el cuerno (el soporte en U flexiona un poco).

Aseguramos el servo con M3. Mecanismo de cabeza completado: balanceo e inclinación funcionan.

Antes de poner la cabeza, pre-ensamblamos: mandíbulas con micro servo SG90 y sensor ultrasónico. Insertamos primera mandíbula y aseguramos con tornillo M4 (agujero en zona de ojos para destornillador).

Micro servo en su sitio con 2 tornillos. En segunda mandíbula ponemos brazo pequeño para SG90.

Insertamos mandíbula, engranamos y aseguramos al eje del motor.

Sensor ultrasónico en su hueco (encaja exacto), fijado con pegamento cianocrilato.

Antenas: alambre de 3mm, ~13cm, doblado ligeramente, pegado con cianocrilato. Finalmente atornillamos la cabeza al mecanismo (4 tornillos previos).

Cabeza funcional: balanceo, inclinación, mordida. Quedan cola (desliza en soporte) y cubierta curva (para tapar electrónica). Aspecto final en azul/blanco.

Diagrama de Circuito del Robot Hormiga Arduino

Electrónica: diagrama simple aunque parece complejo por muchos servos.

Además de 22 servos: módulo Bluetooth HC-05, capacitores, resistencias. Cerebro: Arduino Mega (único que controla >12 servos con librería Servo).

Alimentación: batería 3S LiPo (~12V). Las LiPo aguantan mucho corriente (hasta ~10A si todos los servos a plena carga). Servos trabajan a 4.8-7.2V → necesitamos convertidor DC-DC buck 12V a 5V. Mi buck aguanta 8A, recomiendo 10-15A. Pico medido: ~6A.

Componentes

• Servo MG996R (x21)
• Micro servo SG90 (x1)
• Módulo Bluetooth HC-05
• Arduino Mega
• Batería 3S LiPo
• Convertidor DC-DC Buck (10-15A recomendado)

Diseño PCB para Hexápodo Arduino

Muchas conexiones de servos = lío de cables. Diseñé PCB personalizado en EasyEDA. Actúa como shield para Arduino Mega: se conecta directamente encima. Conexiones de servos agrupadas, 2 capacitores grandes para estabilizar voltaje. Incluye conexión para NRF24L01 (control por radio), pines digitales/analógicos, 5V/GND, 2 LEDs, y monitor de batería (divisor de tensión R1/R2 para leer voltaje 12V en pin analógico).

Enlace a archivos del proyecto PCB. Generé Gerber y pedí a JLCPCB (patrocinadores). Color azul para combinar con Arduino Mega.

Montaje del PCB

Soldé headers macho para conectar al Arduino (abajo, uso placa para voltear y soldar). Luego headers para conexiones de servos (mismo método). Finalmente resistencias, capacitores y bornes. Shield listo, lo inserto en Arduino Mega.

Ajusté buck converter a 5V (potenciómetro). Añadí interruptor en entrada y conecté batería 12V a pin 12V del PCB (solo para monitor). ¡Entrada principal al PCB debe ser 5V!

Electrónica entre placas: batería (cinta), Arduino+PCB encima, módulo NRF24L01 o Bluetooth, LED indicador batería baja (<11V), conectar todos los servos a pines (¡apuntar qué servo va a qué pin!), poner cubierta curva. ¡Proyecto completado!

Código del Hexápodo Arduino

El código es largo; lo presento en secciones con explicación. Código completo al final.

Librerías: Servo (control servos) y SoftwareSerial (Bluetooth). Definimos objetos servo y variables.

#include <Servo.h> #include <SoftwareSerial.h>
#define trigPin 7 #define echoPin 6 #define ledB 10
SoftwareSerial Bluetooth(12, 9); // Arduino(RX, TX) - HC-05(TX, RX)
Servo s24, s23, s22; // ... (22 servos total)

En setup(): inicializar Bluetooth (38400 baudios), pines ultrasónico, LED, y asignar pines a servos con attach(pin, 600, 2400) (pulso min/max μs).

void setup() {
  Serial.begin(38400); Bluetooth.begin(38400); Bluetooth.setTimeout(1); delay(20);
  pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); pinMode(ledB, OUTPUT);
  // Head
  s15.attach(36, 600, 2400); s14.attach(35, 600, 2400); s13.attach(34, 600, 2400);
  // Grip / Tail
  s5.attach(26, 600, 2400);
  // Leg 4
  s10.attach(31, 600, 2400); s11.attach(32, 600, 2400); s12.attach(33, 600, 2400);
  // Leg 5
  s7.attach(28, 600, 2400); s8.attach(29, 600, 2400); s9.attach(30, 600, 2400);
  // Leg 6
  s1.attach(22, 600, 2400); s2.attach(23, 600, 2400); s3.attach(24, 600, 2400);
  // Leg 1
  s18.attach(39, 600, 2400); s17.attach(38, 600, 2400); s16.attach(37, 600, 2400);
  // Leg 2
  s21.attach(42, 600, 2400); s20.attach(41, 600, 2400); s19.attach(40, 600, 2400);
  // Leg 3
  s24.attach(45, 600, 2400); s23.attach(44, 600, 2400); s22.attach(43, 600, 2400);
}

Luego write() para posición inicial. Aquí calibramos: no se puede montar cada servo perfecto, pero por software ajustamos valores iniciales.

// Posición inicial
s15.write(72); s14.write(50); s13.write(90); // Cabeza
s5.write(65); // Mandíbulas
// Pata 4
s10.write(65); s11.write(35); s12.write(40);
// Pata 5
s7.write(80); s8.write(50); s9.write(25);
// Pata 6
s1.write(90); s2.write(45); s3.write(60);
// Pata 1
s18.write(60); s17.write(90); s16.write(100);
// Pata 2
s21.write(50); s20.write(85); s19.write(75);
// Pata 3
s24.write(50); s23.write(80); s22.write(80);

Programación del movimiento

Hay métodos como cinemática directa/inversa (matemáticas serias), pero los servos MG996R baratos no tienen torque ni precisión suficiente. Opté por programar manualmente posiciones de cada servo usando contadores en loop principal.

Ciclo de pata: fase swing (pata por aire, posición inicial → final) y fase stance (pata en suelo, final → inicial). Así el cuerpo avanza.

Función personalizada para cada pata. Ejemplo pata 1:

void moveLeg1() {
  // Swing: subir pata
  if (i1L1 <= 10) { s18.write(60 - i1L1 * 2); s17.write(90 - i1L1 * 3); i1L1++; }
  // Rotar pata
  if (i2L1 <= 30) { s16.write(100 - i2L1); i2L1++; }
  // Bajar al suelo
  if (i2L1 > 20 && i3L1 <= 10) { s18.write(40 + i3L1 * 2); s17.write(60 + i3L1 * 3); i3L1++; }
  // Stance: rotar de vuelta
  if (i2L1 >= 30) { s16.write(70 + i4L1); i4L1++; l1status = HIGH; }
  // Reset contadores
  if (i4L1 >= 30) { i1L1=i2L1=i3L1=i4L1=i5L1=0; }
}

Primero dos servos externos suben la pata, el tercero (cuerpo) rota. 10 pasos antes de parar rotación, bajamos patas al suelo. Swing completado. Luego rotamos tercero de vuelta (stance). Contadores se reinician y ciclo se repite. Cada iteración en loop principal con delay para velocidad.

Funciones similares para otras patas, y funciones inversas para retroceso, giro izquierda/derecha. Igual para cabeza, cola, mandíbulas.

Para avanzar, llamamos 6 funciones moveLeg() en loop:

if (m == 2) { // Adelante
  moveLeg1(); moveLeg3(); moveLeg5();
  if (l1status == HIGH) { moveLeg2(); moveLeg4(); moveLeg6(); }
}

Patas 1,3,5 en swing; 2,4,6 en stance (alternadas). Para girar izquierda, funciones moveLeft().

Comandos vienen de Bluetooth / app Android.

if (Bluetooth.available() > 0) {
  dataIn = Bluetooth.read(); // Leer dato
}

App Android Robot Hormiga Arduino

App hecha con MIT App Inventor. Gráficos son imágenes usadas como botones. Slider abajo para velocidad, botones arriba para conectar Bluetooth.

Ejemplo: botón Adelante → envía '2' a Arduino → ejecuta funciones avance. Cambia imagen a versión resaltada. Volver a pulsar → envía '0' → resetea contadores y posición inicial. Mismo principio para todos los botones.

Descarga: proyecto MIT App Inventor y APK lista para instalar.

Monitor de batería y sensor ultrasónico

// Monitor batería
int sensorValue = analogRead(A3);
float voltage = sensorValue * (5.00 / 1023.00) * 2.9; // Divisor tensión
Serial.println(voltage);
if (voltage < 11) digitalWrite(ledB, HIGH); else digitalWrite(ledB, LOW);

// Ultrasonico: si objeto < 40cm → preparar ataque
if (getDistance() > 40) att = 0;
if (getDistance() <= 40) { att = 1; dataIn = 99; }

Si no hay objeto → cancelar ataque. Si objeto sigue cerca (<30cm) → atacar.

if (att == 1) { prepareAttack(); /* ... */ }
if (att == 2) { dismissAttack(); /* ... */ }
if (att == 3) { attack(); /* ... */ }

Código completo descargable al final. Nota: el mayor reto fue el mal rendimiento de los servos baratos. ¡Espero que lo disfrutaras! Preguntas en comentarios y revisa mi colección de Proyectos Arduino.