Arduino-Vierbeiner-Spinnenroboter bauen – Schritt-für-Schritt-Anleitung

Komponenten und Materialien

Komponente	Menge
Arduino Nano R3	1
Bluetooth Low Energy (BLE) Modul (Generic)	1
Onion Corporation OLED Expansion	1
RGB Diffused Common Cathode LED	1
JLCPCB Customized PCB (selbst entworfene Platine)	1
12 Servomotoren (3 pro Bein)	12
HC-06 Bluetooth Modul	1
OLED Display	1
5mm RGB LEDs	1
Header Connectors	1 Set
3D-gedruckte Roboter-Körperteile (STL-Dateien)	1 Satz

Über dieses Projekt

Hey! Hier ist ein neues Tutorial, das dich Schritt für Schritt durch den Bau dieses faszinierenden elektronischen Projekts führt – einen „Krabbelroboter“, auch bekannt als „Spinnenroboter“ oder „Vierbeiner-Roboter“ (Quadruped).

Angesichts der rasanten Entwicklung der Robotik-Technologie wollen wir dich auf ein höheres Level der Robotik und des Roboterbaus bringen. Wir begannen mit einfachen elektronischen Projekten und grundlegenden Robotern wie dem PICTO92 Linienfolger, um dich mit der Elektronik vertraut zu machen und dich in die Lage zu versetzen, eigene Projekte zu erfinden.

Nun steigen wir ein Level höher: Dieser Roboter ist im Konzept grundlegend, wird aber programmiertechnisch anspruchsvoller, je tiefer man einsteigt. Da solche Gadgets im Handel sehr teuer sind, bieten wir diese schrittweise Anleitung, damit du deinen eigenen Spiderbot bauen kannst.

Das Projekt ist besonders handlich umsetzbar, nachdem wir die maßgeschneiderte PCB von JLCPCB erhalten haben, die das Erscheinungsbild unseres Roboters verbessert. In dieser Anleitung findest du ausreichend Dokumentation und Code, um deinen Krabbelroboter einfach zu erstellen.

Wir haben das Projekt in nur 7 Tagen realisiert: zwei Tage für Hardware-Bau und Montage, fünf Tage für Code und Android-App zur Bluetooth-Steuerung. Doch bevor wir starten, schauen wir uns die Grundlagen an.

Was du lernen wirst

• Die richtigen Komponenten je nach Projektfunktionalität auswählen
• Den Schaltplan erstellen, um alle gewählten Komponenten zu verbinden
• Alle Projekteile montieren
• Die Balance des Roboters kalibrieren (Scaling)
• Die Android-App nutzen, um via Bluetooth zu verbinden und das System zu steuern

Schritt 1: Was ist ein „Spinnenroboter“?

Wie der Name sagt, ahmt unser Roboter die Bewegungen einer Spinne nach – allerdings mit vier statt acht Beinen. Er wird daher auch Quadruped (Vierbeiner) genannt. Die Bewegung jedes Beins steht in Relation zu den anderen, um die Körperposition zu bestimmen und die Balance zu kontrollieren.

Beinige Roboter meistern Gelände besser als Radroboter und bewegen sich tierisch-vielseitig. Das macht sie jedoch komplexer und für viele Maker weniger zugänglich. Zudem sind die Kosten höher, da Servo- oder Schrittmotoren teurer sind als die DC-Motoren von Radrobotern.

Vorteile eines Vierbeiners

In der Natur sind Vierbeiner weit verbreitet, weil vier Beine passive Stabilität ermöglichen – die Fähigkeit, ohne aktives Ausbalancieren zu stehen. Das gilt auch für Roboter: Ein vierbeiniger Roboter ist günstiger und simpler als einer mit mehr Beinen, erreicht aber dennoch Stabilität.

Schritt 2: Servomotoren als Hauptaktuatoren

Ein Servomotor (laut Wikipedia) ist ein Dreh- oder Linearaktuator, der präzise Kontrolle von Winkel- oder Linearposition, Geschwindigkeit und Beschleunigung erlaubt. Er besteht aus einem Motor, gekoppelt mit einem Sensor für Positionsfeedback, und erfordert einen relativ komplexen Controller – oft ein dediziertes Modul für Servomotoren.

Servomotoren sind keine eigene Motorklasse; der Begriff bezeichnet vielmehr einen Motor, der für geschlossene Regelkreise geeignet ist.

Das Steuersignal ist meist eine Rechteckwellen-Pulskette. Gängige Frequenzen: 44 Hz, 50 Hz, 400 Hz. Die positive Pulsbreite bestimmt die Servoposition: ca. 0,5 ms → maximaler Ausschlag links (45–90°), ca. 2,5–3,0 ms → maximaler Ausschlag rechts, ca. 1,5 ms → Neutralposition (0°). Ausgangsspannung High: 2,5–10 V (typisch 3 V), Low: -40 mV bis 0 V.

Schritt 3: PCB-Fertigung (produziert von JLCPCB)

Über JLCPCB

JLCPCB (Shenzhen JIALICHUANG Electronic Technology Development Co., Ltd.) ist Chinas größter PCB-Prototypen-Hersteller und High-Tech-Fertiger für schnelle PCB-Prototypen und Kleinserien. Mit über 10 Jahren Erfahrung, 200.000+ Kunden weltweit und 8.000+ Online-Bestellungen täglich bietet JLCPCB jährliche Kapazität von 200.000 m² für 1- bis Mehrlagige PCBs – professionell, großskalig, gut ausgestattet, streng gemanagt, hohe Qualität.

Zurück zu unserem Projekt

Ich verglich Preise vieler PCB-Hersteller und wählte JLCPCB als besten und günstigsten Anbieter. Einfach Gerber-Datei hochladen, Parameter wie Dicke, Farbe, Menge setzen – und für nur 2 $ war die PCB nach 5 Tagen da.

Der Schaltplan zeigt: Ein Arduino Nano steuert das Gesamtsystem; die Roboter-Spinnenform wurde als PCB-Design umgesetzt für bessere Optik. Die gefertigte PCB entspricht exakt dem Design, alle Labels und Logos erleichtern das Bestücken.

Downloads: Schaltplan (PDF) | Gerber-Dateien (für Nachbestellung)

Schritt 4: Zutaten (Komponentenliste)

• PCB von JLCPCB
• 12 Servomotoren (3 pro Bein) – Bezugsquelle
• Arduino Nano – Bezugsquelle
• HC-06 Bluetooth Modul – Bezugsquelle
• OLED Display – Bezugsquelle
• 5mm RGB LEDs – Bezugsquelle
• Header Connectors – Bezugsquelle
• 3D-gedruckte Körperteile (STL-Dateien hier)

Schritt 5: Roboter-Montage

PCB ist bestückt, alle Komponenten verlötet. Jetzt der mechanische Aufbau – einfach den Schritten folgen:

1. Jedes Bein einzeln vorbereiten: Pro Bein zwei Servos für Gelenke (Coxa, Femur, Tibia) plus 3D-Teile und kleines Verbindungsstück.
2. Ersten Servo in Halterung schrauben, Achse auf 180° drehen (ohne Schraube für Anbauteil), Femur mit Tibia über ersten Servo und Verbindungsstück verbinden.
3. Zweiten Servo einsetzen, um drittes Beinglied (Coxa) zu halten.
4. Wiederholen für alle vier Beine.
5. Oberes Chassis nehmen, restliche Servos in Halterungen schrauben, jedes Bein am passenden Servo befestigen.
6. Unteres Chassis: Hier kommt die PCB-Platine hinein.

STL-Dateien für Körperteile hier herunterladen.

Schritt 6: Die Android-App

Die App ermöglicht:

• Bluetooth-Verbindung zum Roboter
• Vorwärts/Rückwärts-Bewegung & Links/Rechts-Drehung
• Echtzeit-Farbsteuerung der LEDs über Farbkreis

App kostenlos herunterladen: Link

Schritt 7: Arduino-Code & Testvalidierung

Fast fertig – zuerst Gelenkwinkel kalibrieren: Setup-Code hochladen, der jeden Servo auf 90° positioniert (7V DC-Batterie anschließen!). Dann Hauptprogramm für App-Steuerung hochladen. Beide Codes hier downloadbar (Scaling-Code & Hauptprogramm).

OLED-Display anschließen – im Hauptcode sind Cozmo-Gesichter (Smileys) programmiert. Der Roboter folgt allen Smartphone-Befehlen; weitere Verbesserungen sind möglich.

Arduino-Code (Hauptprogramm)

/************************************************************************************************************************************************************************ 
 * - Author : BELKHIR Mohamed 
 * - Profession : Electrical Engineer, MEGA DAS owner 
 * - Main purpose : Industrial Application 
 * - Copyright (c) holder : All rights reserved 
 * - License : BSD 2-Clause License 
 * - Date : 20/04/2017 
 ***********************************************************************************************************************************************************************/ 

#include <Servo.h> 
#include <FlexiTimer2.h> 
#include <Wire.h> 
#include <Adafruit_SSD1306.h> 
#include <Adafruit_GFX.h> 

#define OLED_ADDR 0x3C 
Adafruit_SSD1306 display(-1); 

/* Servos */ 
Servo servo[4][3]; 
const int servo_pin[4][3] = { {11, 12, 13}, {2, 4, 7}, {14, 15, 16}, {8, 9, 10} }; 

/* Roboter-Geometrie */ 
const float length_a = 50; 
const float length_b = 77.1; 
const float length_c = 27.5; 
const float length_side = 71; 
const float z_absolute = -28; 

/* Bewegungsparameter */ 
const float z_default = -50, z_up = -30, z_boot = z_absolute; 
const float x_default = 62, x_offset = 0; 
const float y_start = 0, y_step = 40; 
const float y_default = x_default; 

volatile float site_now[4][3]; 
volatile float site_expect[4][3]; 
float temp_speed[4][3]; 
float move_speed; 
float speed_multiple = 1; 
const float spot_turn_speed = 4; 
const float leg_move_speed = 8; 
const float body_move_speed = 3; 
const float stand_seat_speed = 1; 
volatile int rest_counter; 
const float KEEP = 255; 
const float pi = 3.1415926; 

/* Dreh-Konstanten */ 
const float temp_a = sqrt(pow(2 * x_default + length_side, 2) + pow(y_step, 2)); 
const float temp_b = 2 * (y_start + y_step) + length_side; 
const float temp_c = sqrt(pow(2 * x_default + length_side, 2) + pow(2 * y_start + y_step + length_side, 2)); 
const float temp_alpha = acos((pow(temp_a, 2) + pow(temp_b, 2) - pow(temp_c, 2)) / 2 / temp_a / temp_b); 
const float turn_x1 = (temp_a - length_side) / 2; 
const float turn_y1 = y_start + y_step / 2; 
const float turn_x0 = turn_x1 - temp_b * cos(temp_alpha); 
const float turn_y0 = temp_b * sin(temp_alpha) - turn_y1 - length_side; 

const int lightR = 3, lightG = 5, lightB = 6; 
int LedR = 0, LedG = 0, LedB = 0; 
char SerialData; 
String data = ""; 

void setup() { 
  Serial.begin(9600); 
  display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR); 
  display.clearDisplay(); 
  display.display(); 
  delay(10000); 
  set_site(0, x_default - x_offset, y_start + y_step, z_boot); 
  set_site(1, x_default - x_offset, y_start + y_step, z_boot); 
  set_site(2, x_default + x_offset, y_start, z_boot); 
  set_site(3, x_default + x_offset, y_start, z_boot); 
  for (int i = 0; i < 4; i++) 
    for (int j = 0; j < 3; j++) 
      site_now[i][j] = site_expect[i][j]; 
  FlexiTimer2::set(20, servo_service); 
  FlexiTimer2::start(); 
  servo_attach(); 
  stand(); 
  happy(); delay(random(500, 1000)); 
  cierra(); delay(150); 
  enfado(); delay(random(1000, 3000)); 
  cierra(); delay(150); 
  entorna(); delay(random(1000, 3000)); 
  cierra(); delay(150); 
  enfado1(); delay(random(1000, 3000)); 
  cierra(); delay(150); 
  triste(); delay(random(1000, 3000)); 
  cierra(); delay(150); 
  abre(); delay(random(500, 3000)); 
  cierra(); delay(150); 
  happy(); delay(random(500, 1000)); 
} 

void loop() { 
  while (Serial.available()) { 
    delay(10); 
    SerialData = Serial.read(); 
    if (SerialData == 'b') LedR = Serial.parseInt(); 
    else if (SerialData == 'g') LedG = Serial.parseInt(); 
    else if (SerialData == 'r') LedB = Serial.parseInt(); 
    else data += SerialData; 
  } 
  if (data == "f") { cierra(); delay(150); happy(); step_forward(1); } 
  if (data == "p") { cierra(); delay(150); triste(); step_back(1); } 
  if (data == "l") { cierra(); delay(150); enfado1(); turn_left(1); } 
  if (data == "m") { cierra(); delay(150); enfado(); turn_right(5); } 
  data = ""; 
  analogWrite(lightR, LedR); 
  analogWrite(lightG, LedG); 
  analogWrite(lightB, LedB); 
} 

// ... (Servo-Funktionen, Bewegungslogik, OLED-Animationen: abre, cierra, entorna, triste, happy, enfado, enfado1) 
// Der vollständige Code inkl. aller Funktionen (servo_service, set_site, wait_reach, cartesian_to_polar, polar_to_servo, etc.) 
// ist im Original enthalten. Hier gekürzt für Übersichtlichkeit.

Custom Parts & Gehäuse

3D-Druckdateien (STL) für alle Körperteile sind im Projekt verlinkt.

Schaltpläne

Schaltplan und PCB-Layout sind als PDF und Gerber-Dateien verfügbar (siehe Schritt 3).