Arduino-Ameisen-Hexapod-Roboter bauen: Schritt-für-Schritt-Anleitung

In diesem Tutorial zeige ich, wie ich einen Arduino-Hexapod gebaut habe. Wie der Name sagt, hat er 6 Beine, zusätzlich aber auch einen Hinterleib (Schwanz), einen Kopf, Antennen, Mandibeln und sogar funktionale Augen. Damit sieht er aus wie eine Ameise – daher der Name Arduino-Ameisen-Roboter.

Video ansehen oder schriftliche Anleitung unten lesen.

Überblick

Zur Steuerung habe ich eine eigene Android-App entwickelt. Sie hat 4 Buttons für vorwärts, rückwärts, links, rechts. Zusätzlich kann der Roboter Kopf und Schwanz bewegen, beißen, greifen, loslassen und angreifen.

Der Roboter hat funktionale Augen: Der Kopf ist für einen Ultraschallsensor (HC-SR04) ausgelegt. Nähert man sich dem Kopf, bereitet der Roboter einen Angriff vor.

Zieht man die Hand zurück, bricht er den Angriff ab. Kommt man näher, beißt er zu. Ziemlich cool, oder? Bleiben Sie dran für den kompletten Aufbau und die Funktionsweise.

Arduino-Hexapod – Ameisen-Roboter 3D-Modell

Wie immer begann ich mit dem 3D-Design (SolidWorks). Der Hexapod hat 6 Beine, jedes mit 3 Gelenken = 3 Servos pro Bein = 18 Servos. Ich verwendete MG996R-Servos.

Der Schwanz wird von einem weiteren MG996R angetrieben. Der Kopf hat 2 Freiheitsgrade (Rollen & Neigen) – zwei weitere Servos. Insgesamt also 21 MG996R-Servos plus ein kleiner SG90-Mikroservo für die Mandibeln.

Die Augen sind für den HC-SR04-Ultraschallsensor designed. Alle Teile werden zwischen zwei Platten montiert, eine geschwungene Abdeckung oben versteckt Verkabelung, Arduino und Akku.

Das 3D-Modell können Sie auf Thangs herunterladen und im Browser betrachten. STL-Dateien stehen zum Download bereit.

3D-Druck der Teile

Gedruckt auf meinem Creality CR-10 – hervorragende Qualität. Das schwierigste Teil war der Kopf, den ich in einem Stück drucken wollte. Dafür nutzte ich Support-Overhang-Winkel 60° und Support-Blocker. Der CR-10 meisterte es perfekt.

Hexapod montieren

Beine zusammenbauen: M3-Schrauben und Muttern (mind. 12 mm, ich nutzte 16 mm) mit Federringen. Ca. 200 Schrauben für den Gesamtbau. Verbindungsglieder nutzen die runden Servo-Hörner (3 mm bohren oder Metallhörner mit M3-Gewinde kaufen).

Wichtig: Servos immer in gleicher Position montieren, voller Bewegungsbereich. Die kleine dreieckige Stütze am Servo entfernen (Cuttermesser), damit sie bündig anliegen. Vor dem dritten Servo ein M4-Bolt für die Befestigung an der Basisplatte einsetzen.

Ein Bein fertig – fünf weitere folgen.

Alle Beine an den beiden Körperplatten montieren: Erst runde Hörner auf der oberen Platte befestigen, dann an Servowellen anschrauben. Servos vorher exakt auf Mittelstellung bringen (voller Bewegungsbereich, weniger Kalibrieraufwand).

Jetzt sieht es schon wie ein Hexapod aus.

Hinten noch ein Horn für den Schwanz-Servo. Roboter umdrehen, untere Platte durch M4-Bolzen der Beine schieben, mit Unterlegscheiben und Selbstsicherungsmuttern fixieren. Nicht zu fest anziehen – sind Drehgelenke!

Kopf-Mechanik: Erstes Servo (Rollen) senkrecht zu Platten – zwei kleine Adapterplatten helfen. U-förmiger Halter für zweites Servo (Neigen). Wieder Mittelstellung prüfen. Neige-Servo-Halter: M4-Bolt einsetzen, vier M3-Schrauben für Kopf-Befestigung vorbereiten, Servo einpassen (Halter flexibt etwas).

Kopf vormontieren: Mandibeln mit SG90-Servo und Ultraschallsensor. Erste Mandibel mit M4-Bolt befestigen (Loch im Augenbereich für Schraubendreher).

Mikroservo einsetzen, zweite Mandibel mit Armhorn versehen, Zahnräder paaren, auf Servowelle schrauben.

Ultraschallsensor in Augenöffnungen einkleben (AC-Kleber). Antennen: 3-mm-Draht, ca. 13 cm, leicht gebogen, einkleben. Kopf auf Roll-/Neige-Mechanik schrauben (4 vorbereitete Bolzen).

Kopf funktionsfähig: Rollen, Neigen, Beißen. Noch Schwanz (in Halter schieben) und geschwungene Abdeckung (später für Elektronik) anbringen. Finales Aussehen in Blau-Weiß – sehr gelungen.

Schaltplan des Ameisen-Roboters

Elektronik: 22 Servos, HC-05 Bluetooth-Modul, Kondensatoren, Widerstände. Gehirn: Arduino Mega (einzige Board, das >12 Servos per Servo-Library steuern kann).

Stromversorgung: 3S LiPo (~12 V). LiPos liefern hohen Strom (bei Vollast aller Servos ~10 A). Servos vertragen nur 4,8–7,2 V → DC-DC-Buck-Converter (12 V → 5 V). Mein Converter schafft 8 A, empfehle 10–15 A für Reserve. Gemessener Maximalstrom beim Gehen: ~6 A.

Komponenten-Links:

• MG996R Servo
• SG90 Mikroservo
• HC-05 Bluetooth-Modul
• Arduino Mega
• 3S LiPo-Akku
• DC-DC Buck Converter (10-15A empfohlen)

PCB-Design für Hexapod

Wegen der vielen Servo-Anschlüsse: Custom PCB als Arduino-Mega-Shield (EasyEDA). Servo-Anschlüsse gruppiert, zwei große Kondensatoren für stabile Spannung. Anschluss für NRF24L01 (optional Funksteuerung), diverse digitale/analoge Pins, 5V/GND, zwei LEDs, Batteriespannungsmessung über Spannungsteiler (R1, R2) auf Analog-Pin.

Projektdateien auf EasyEDA. Gerber-Dateien generiert, bei JLCPCB bestellt (Sponsor). Blaues PCB passend zum Arduino Mega.

PCBs angekommen – top Qualität, exakt wie Design.

PCB bestücken

Stiftleisen für Arduino-Verbindung auf Unterseite löten (Platte als Haltehilfe nutzen, umdrehen, löten). Dann alle Servo-Anschlüsse (Stiftleisten), Widerstände, Kondensatoren, Klemmenblöcke. Fertig – Shield auf Arduino Mega aufstecken.

Buck-Converter auf 5 V einstellen (Potentiometer). Netzteil-Schalter am Eingang, Batterie 12 V an 12-V-Pin (nur für Spannungsmessung). Haupt-Eingang am PCB muss 5 V sein!

Elektronik zwischen den Platten verstauen: Akku (mit Tape fixiert), Arduino mit Shield, NRF24L01 oder Bluetooth-Modul, LED für Batteriewarnung (<11 V). Alle Servos anstecken (Pin-Nummern notieren!). Geschwungene Abdeckung drauf – fertig.

Arduino-Hexapod-Code

Code ist länger, daher in Abschnitten erklärt. Am Ende kompletter Code.

Bibliotheken: Servo, SoftwareSerial (Bluetooth). Alle Servo-Objekte und Variablen definieren.

#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; Servo s23; Servo s22; // ... alle 22 Servos

Setup: Bluetooth, Ultraschall-Pins, LED, Servo-Pins zuweisen (mit Min/Max-Pulsweite 600-2400 µs für MG996R).

void setup() {
  Serial.begin(38400);
  Bluetooth.begin(38400); Bluetooth.setTimeout(1); delay(20);
  pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); pinMode(ledB, OUTPUT);
  // Servos an Pins attachen (Beispiel)
  s15.attach(36, 600, 2400); // Kopf Roll
  s14.attach(35, 600, 2400); // Kopf Neigung
  s13.attach(34, 600, 2400); // Greifer
  s5.attach(26, 600, 2400);  // Schwanz
  // ... alle 6 Beine (je 3 Servos) ...
}

Dann Servos in Startposition fahren – hier kalibriert man die mechanischen Abweichungen.

// Startpositionen
s15.write(72); s14.write(50); s13.write(90); // Kopf
s5.write(65); // Schwanz
// Bein 4
s10.write(65); s11.write(35); s12.write(40);
// Bein 5
s7.write(80); s8.write(50); s9.write(25);
// Bein 6
s1.write(90); s2.write(45); s3.write(60);
// Bein 1
s18.write(60); s17.write(90); s16.write(100);
// Bein 2
s21.write(50); s20.write(85); s19.write(75);
// Bein 3
s24.write(50); s23.write(80); s22.write(80);

Gangprogrammierung: Ich nutze keine komplexe Kinematik (Servos zu ungenau), sondern programmiere jeden Beinzyklus manuell per Zählern. Ein Zyklus: Schwungphase (Bein durch Luft von Start- zu Endposition) und Stützphase (Bein am Boden zurück zur Startposition, schiebt Körper vorwärts).

Beispiel Bein 1:

void moveLeg1() {
  // Schwungphase
  if (i1L1 <= 10) { s18.write(60 - i1L1*2); s17.write(90 - i1L1*3); i1L1++; } // Bein heben
  if (i2L1 <= 30) { s16.write(100 - i2L1); i2L1++; } // Drehen
  if (i2L1 > 20 && i3L1 <= 10) { s18.write(40 + i3L1*2); s17.write(60 + i3L1*3); i3L1++; } // Absetzen
  // Stützphase
  if (i2L1 >= 30) { s16.write(70 + i4L1); i4L1++; l1status = HIGH; }
  // Zähler zurücksetzen
  if (i4L1 >= 30) { i1L1=i2L1=i3L1=i4L1=i5L1=0; }
}

Ähnliche Funktionen für alle Beine, plus Rückwärts, Links, Rechts. Im Hauptloop werden je nach Befehl (per Bluetooth/App) die passenden Funktionen aufgerufen.

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

Drei Beine versetzt: 1,3,5 Schwungphase, 2,4,6 Stützphase. Links/Rechts analog.

Bluetooth-Empfang:

if (Bluetooth.available() > 0) {
  dataIn = Bluetooth.read();
  // Daten auswerten...
}

Android-App für Ameisen-Roboter

App mit MIT App Inventor erstellt. Grafik: Bilder als Buttons. Unten Slider für Geschwindigkeit, oben Bluetooth-Verbindungs-Buttons.

Blöcke: Drückt man „Vorwärts“, wird Zahl 2 gesendet → Arduino führt Vorwärts-Funktionen aus. Button-Bild wechselt auf hervorgehobene Version. Erneut drücken sendet 0 → Roboter stoppt, Zähler zurückgesetzt, Button-Bild zurückgesetzt. Gleiches Prinzip für alle Buttons.

Download: MIT App Inventor Projektdatei & fertige Android App (APK).

Zwei weitere Funktionen: Batterieüberwachung & Ultraschall.

// Batteriespannung überwachen
int sensorValue = analogRead(A3);
float voltage = sensorValue * (5.00 / 1023.00) * 2.9; // Umrechnung auf 12V
Serial.println(voltage);
if (voltage < 11) digitalWrite(ledB, HIGH); else digitalWrite(ledB, LOW);

// Ultraschall-Abstand
if (getDistance() > 40) att = 0;
if (getDistance() <= 40) { att = 1; dataIn = 99; }

Kein Objekt mehr → Angriff abbrechen. Objekt näher → Angriff ausführen.

// Angriffslogik (vereinfacht)
if (att == 1) { prepareAttack(); if (aStatus==HIGH) { delay(2000); if (getDistance()>30) { att=2; dismissAttack(); } if (getDistance()<30) { att=3; attack(); } } }
if (att == 2) { dismissAttack(); if (aStatus==HIGH) { dataIn=0; att=0; } }
if (att == 3) { attack(); /* ... */ }

Das war's im Wesentlichen. Kompletter Code am Ende des Artikels downloadbar.

Hinweis: Die billigen MG996R-Servos waren die größte Herausforderung (ungenau, schwaches Drehmoment). Viel Spaß beim Nachbauen! Fragen in den Kommentaren, Arduino-Projektsammlung checken.