WALL·E bauen

1. Arduino IDE 2 installieren (von arduino.cc, unter Linux am einfachsten das AppImage).
2. In der Arduino IDE: Datei → Einstellungen. Bei „Zusätzliche Boardverwalter-URLs" das hier eintragen:
   https://espressif.github.io/arduino-esp32/package_esp32_index.json
3. Links auf das Board-Symbol klicken (Boardverwalter), nach esp32 suchen und „esp32 by Espressif Systems" installieren (Version 3.x).
4. Links auf das Bücher-Symbol (Bibliotheksverwalter), nach Adafruit PWM Servo Driver suchen und installieren.
5. ESP32 per USB anstecken. Oben in der Auswahlleiste „ESP32 Dev Module" und den richtigen Anschluss wählen (unter Linux meist /dev/ttyUSB0 oder /dev/ttyACM0).
6. Test: Datei → Beispiele → 01.Basics → Blink öffnen, auf den Pfeil (Hochladen) klicken. Blinkt eine kleine LED auf dem ESP32? Super.

Auf dem Erweiterungsboard steckt der ESP32 in einer Buchsenleiste. Neben jedem Pin gibt es eine Reihe mit drei Stiften: S (Signal, der Pin selbst), V (Plus) und G (GND). Dadurch bekommt jedes Modul seinen Strom direkt neben seinem Signal, und du brauchst keine selbstgelöteten Verteiler-Kabel.

1. Jumper umstecken: Oben neben der USB-C-Buchse steht JUMP mit 3.3V, V und 5V. Das schwarze Steckerchen (Jumper) muss den mittleren Stift V mit 3.3V verbinden. Auf deinem Foto steckt er auf 5V. Einfach abziehen und eins weiter rüber stecken.
2. ESP32 einstecken: Die Beschriftung auf dem ESP32 muss zur Beschriftung auf dem Board passen (z.B. D25 neben D25). Falsch herum eingesteckt geht der ESP32 kaputt, also genau hinschauen.
3. Welcher Stift ist was? Am Ende der Dreierreihen sind die Buchstaben G, V, S aufgedruckt. Schau einmal nach und merk dir die Reihenfolge.
4. Nachmessen: ESP32 per USB anstecken (an der USB-Buchse des ESP32). Multimeter auf „V⎓": schwarze Spitze an einen G-Stift, rote an einen V-Stift. Es müssen ungefähr 3,3 V sein. Dann dasselbe am VCC-Stift des kleinen Vierer-Blocks GND VCC D21 D22: auch hier 3,3 V.

Worum geht es? Der Akku hat nur einen einzigen Stecker. Strom brauchen aber vier Geräte: zwei Motortreiber und zwei Spannungswandler. In diesem Schritt baust du deshalb eine kleine Verteilerstation: Vom Akku geht ein Kabel zu zwei Klemmen (eine für Plus, eine für Minus), und an diese Klemmen kommen später alle vier Geräte. In das Plus-Kabel kommt eine Sicherung, die bei einem Fehler durchbrennt, bevor etwas heiß wird. Löten musst du dafür nicht, die WAGO-Klemmen halten die Kabel mit kleinen Hebeln fest.

1. Akku weglegen. Er bleibt den ganzen Schritt über abgesteckt und liegt weit weg.
2. Die Sicherung noch nicht einstecken. Solange sie fehlt, kann kein Strom fließen, selbst wenn du dich irgendwo vertust. Sie kommt erst ganz am Schluss rein.
3. Klemmen beschriften: Ein Stück Kreppband mit PLUS auf die erste WAGO, eins mit MINUS auf die zweite. Die dritte ist nur ein Verbinder.
4. So funktioniert eine WAGO: Kabelende 11 mm abisolieren (an der Seite der Klemme ist eine Markierung zum Abmessen). Orangen Hebel hochklappen, Kabel bis zum Anschlag reinschieben, Hebel runterdrücken. Kurz am Kabel ziehen: Es muss fest sitzen. Die Litzen dürfen dabei nicht auffächern, dreh sie vorher zwischen den Fingern zusammen.
5. Schwarzes Kabel vom XT60 in die MINUS-Klemme.
6. Rotes Kabel vom XT60 in die Verbinder-Klemme. In dieselbe Klemme kommt das eine Kabel vom Sicherungshalter.
7. Das andere Kabel vom Sicherungshalter in die PLUS-Klemme.
8. Messpunkte: In die PLUS-Klemme und in die MINUS-Klemme je ein kurzes, an beiden Enden abisoliertes Kabelstück stecken. Daran misst du jetzt und in A3.
9. Kurzschluss-Test: Multimeter auf Durchgang (das Piepser-Symbol; tipp die zwei Spitzen kurz zusammen, dann piepst es). Jetzt eine Spitze an den PLUS-Messpunkt, die andere an den MINUS-Messpunkt. Es darf nicht piepsen. Piepst es, hast du irgendwo Plus und Minus verbunden: Klemmen nochmal ansehen, bevor der Akku drankommt.
10. Sicherung einstecken (die 10-A-Sicherung).
11. Spannung messen: Multimeter auf V⎓ 20V. Rote Spitze an den PLUS-Messpunkt, schwarze an den MINUS-Messpunkt. Erst jetzt den Akku in den XT60 stecken. Das Multimeter muss zwischen 11,0 und 12,6 anzeigen, ohne Minus davor. Springt die Zahl um ein paar Zehntel hin und her, liegt das an den Spitzen, die nicht ganz fest anliegen. Das ist in Ordnung. Danach Akku wieder abziehen.

1. Beide Wandler haben einen Eingang (IN+, IN−) und einen Ausgang (OUT+, OUT−). Schau genau hin, meist steht es auf der Platine.
2. Den Eingang beider Wandler mit dem Plus- und Minus-Verteiler verbinden (rot an IN+, schwarz an IN−).
3. Akku an, Schalter an. Multimeter an OUT+ und OUT− des LM2596 halten.
4. An der kleinen Messingschraube drehen, bis das Multimeter 5,0 V zeigt. Keine Sorge: Man muss oft viele Umdrehungen machen, bis sich etwas tut.
5. Jetzt das Multimeter an den Ausgang des 12-A-Wandlers. Den auf 6,0 V stellen.
6. Ausschalten, 10 Sekunden warten, wieder einschalten und nochmal messen. Stimmen beide Werte noch?
7. Mit Kreppband beschriften: „5 V: ESP32" und „6 V: SERVOS". Die Messingschrauben ab jetzt nicht mehr anfassen.

1. Akku aus. ESP32 per USB am PC.
2. 4 Dupont-Kabel vom Board zum PCA9685 (linke Stiftleiste am PCA9685):

   Vierer-Block am Board	PCA9685
   GND	GND
   VCC	VCC
   D21	SDA
   D22	SCL

   Der Vierer-Block GND VCC D21 D22 sitzt links oben auf dem Board, neben den zwei großen Kondensatoren. Er passt genau zum Servo-Board. Die Pins OE und V+ an der Stiftleiste bleiben frei.
3. Den Ausgang des 6-V-Wandlers an die blaue Schraubklemme oben auf dem PCA9685: Plus an V+, Minus an GND. Genau hinschauen, verpolt geht das Board kaputt.
4. Die Servos in die Kanäle 0 bis 6 stecken. Das braune Kabel zeigt zur Reihe mit der Aufschrift GND, das orange Kabel zur Reihe PWM.
5. Jeden Servo mit Kreppband beschriften, damit du später weißt, wohin er gehört:

   Kanal	Servo für …
   0	Kopf drehen (links/rechts)
   1	Hals oben (Kopf nicken)
   2	Hals unten (Hals heben/senken)
   3	Auge rechts
   4	Auge links
   5	Arm links
   6	Arm rechts

   Das ist dieselbe Reihenfolge wie im Original-Programm. So passt später alles zusammen.
6. Das Programm „Servo-Tester" (unten) in die Arduino IDE kopieren und hochladen.
7. Oben rechts den Seriellen Monitor öffnen (Lupe). Unten rechts einstellen: 115200 Baud und „Neue Zeile".
8. Jetzt erst den Akku anstecken und einschalten. Die Servos bekommen Strom.
9. Im Monitor m tippen und Enter. Alle Servos fahren auf 90° (Mitte).
10. Einen Servo einzeln testen: z.B. 3 45 + Enter, dann 3 135 + Enter. Bewegt er sich hin und her? Dann 3 90.
11. Am Ende nochmal m, dann Akku aus. Ab jetzt die Servo-Wellen nicht mehr von Hand verdrehen!

Programm „Servo-Tester"

// WALL·E Servo-Tester für ESP32 + PCA9685
// Serieller Monitor: 115200 Baud, "Neue Zeile"
//   m        = alle 7 Servos auf Mitte (90 Grad)
//   3 90     = Servo an Kanal 3 auf 90 Grad
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);

const int SERVO_MIN_US = 500;   // Pulslänge bei 0 Grad
const int SERVO_MAX_US = 2500;  // Pulslänge bei 180 Grad

void setServoAngle(uint8_t kanal, int winkel) {
  winkel = constrain(winkel, 0, 180);
  int us = map(winkel, 0, 180, SERVO_MIN_US, SERVO_MAX_US);
  pwm.writeMicroseconds(kanal, us);
}

void setup() {
  Serial.begin(115200);
  delay(500);
  Wire.begin(21, 22);  // SDA = 21, SCL = 22

  Wire.beginTransmission(0x40);
  if (Wire.endTransmission() == 0) {
    Serial.println("PCA9685 gefunden :)");
  } else {
    Serial.println("PCA9685 NICHT gefunden! Pruefe 3V3, GND, SDA (21) und SCL (22).");
  }

  pwm.begin();
  pwm.setOscillatorFrequency(27000000);
  pwm.setPWMFreq(50);
  delay(10);

  Serial.println("Servo-Tester bereit.");
  Serial.println("Tippe  m  = alle Servos auf Mitte");
  Serial.println("Tippe  3 90  = Kanal 3 auf 90 Grad");
}

void loop() {
  if (!Serial.available()) return;
  String zeile = Serial.readStringUntil('\n');
  zeile.trim();
  if (zeile.length() == 0) return;

  if (zeile == "m") {
    for (int k = 0; k < 7; k++) setServoAngle(k, 90);
    Serial.println("Alle 7 Servos auf 90 Grad.");
    return;
  }

  int leer = zeile.indexOf(' ');
  if (leer < 0) {
    Serial.println("Bitte so tippen: Kanal Winkel, z.B. 3 90");
    return;
  }
  int kanal  = zeile.substring(0, leer).toInt();
  int winkel = zeile.substring(leer + 1).toInt();
  if (kanal < 0 || kanal > 15) {
    Serial.println("Kanal muss 0 bis 15 sein.");
    return;
  }
  setServoAngle(kanal, winkel);
  Serial.printf("Kanal %d -> %d Grad\n", kanal, winkel);
}

1. Akku aus.
2. Jeder Motortreiber (BTS7960, nicht der Motor) hat 4 Schraubklemmen: B+ B− (Strom rein) und M+ M− (zum Motor). B+ an den Plus-Verteiler, B− an den Minus-Verteiler. Einmal für den linken, einmal für den rechten Treiber.
3. Kabel an den Motor: Der Motor selbst hat hinten nur zwei kleine Metall-Laschen (Lötfahnen), keine Klemmen. Dort lötest du je ein rotes und ein schwarzes Silikonkabel an (ca. 20 cm). Das geht auch, wenn der Motor schon am Radgestell sitzt. Schrumpfschlauch über die Lötstellen, damit sich die zwei Laschen nie berühren.
4. Die zwei Kabel vom Motor an M+ und M− des Motortreibers. Welches wohin, ist hier egal. Wenn die Kette später falsch herum läuft, tauscht du die zwei einfach.
5. Beschrifte die Treiber mit „LINKS" und „RECHTS" (aus Sicht von WALL·E, also wenn er von dir wegschaut).
6. Die 8-polige Stiftleiste mit Dupont-Kabeln an das Board. „S von D25" heißt: der Signal-Stift in der Reihe von D25.

   BTS7960	Board bei LINKS	Board bei RECHTS
   RPWM	S von D25	S von D32
   LPWM	S von D26	S von D33
   R_EN	S von D27	S von D4
   L_EN	S von D13	S von D23
   R_IS, L_IS	frei lassen	frei lassen
   VCC	V von D25	V von D32
   GND	G von D25	G von D32

   D4 und D23 sitzen auf der anderen Seite des Boards als die übrigen, das ist in Ordnung.
7. Die Ketten müssen in der Luft sein bzw. die Motoren dürfen frei drehen (noch nicht eingebaut ist perfekt).
8. Programm „Motor-Test" (unten) hochladen, Seriellen Monitor öffnen, dann Akku an. Nach dem Programmstart kannst du auch die Taste EN (Reset) am ESP32 drücken (die Taste heißt nur zufällig genauso wie die EN-Pins am Motortreiber), dann läuft der Test nochmal.

Programm „Motor-Test"

// WALL·E Motor-Test für ESP32 + 2x BTS7960
// KETTEN IN DIE LUFT! Serieller Monitor: 115200 Baud
const int L_VOR = 25;   // BTS7960 LINKS:  RPWM
const int L_ZUR = 26;   // BTS7960 LINKS:  LPWM
const int R_VOR = 32;   // BTS7960 RECHTS: RPWM
const int R_ZUR = 33;   // BTS7960 RECHTS: LPWM
const int EN_PINS[] = {27, 13, 4, 23}; // R_EN/L_EN links, R_EN/L_EN rechts

void treiber(bool an) {
  for (int pin : EN_PINS) digitalWrite(pin, an ? HIGH : LOW);
}

// tempo: -255 (voll rückwärts) bis 255 (voll vorwärts)
void motor(int pinVor, int pinZur, int tempo) {
  tempo = constrain(tempo, -255, 255);
  if (tempo >= 0) {
    analogWrite(pinZur, 0);
    analogWrite(pinVor, tempo);
  } else {
    analogWrite(pinVor, 0);
    analogWrite(pinZur, -tempo);
  }
}

void stopp() {
  motor(L_VOR, L_ZUR, 0);
  motor(R_VOR, R_ZUR, 0);
}

void schritt(const char* text, int links, int rechts, int ms) {
  Serial.println(text);
  motor(L_VOR, L_ZUR, links);
  motor(R_VOR, R_ZUR, rechts);
  delay(ms);
  stopp();
  delay(1000);
}

void setup() {
  Serial.begin(115200);
  for (int pin : EN_PINS) pinMode(pin, OUTPUT);
  treiber(false);                // Treiber erstmal aus
  stopp();
  delay(500);
  Serial.println("Motor-Test startet in 3 Sekunden ...");
  delay(3000);
  treiber(true);                 // Treiber einschalten

  schritt("LINKS vorwaerts",   150,    0, 2000);
  schritt("LINKS rueckwaerts", -150,   0, 2000);
  schritt("RECHTS vorwaerts",    0,  150, 2000);
  schritt("RECHTS rueckwaerts",  0, -150, 2000);
  schritt("BEIDE vorwaerts",   150,  150, 2000);

  treiber(false);
  Serial.println("Fertig. Taste EN druecken fuer einen neuen Durchlauf.");
}

void loop() {}

1. Anschließen: Trig → S von D18, Echo → S von D19, VCC → V von D18, GND → G von D18.
2. Programm „Abstand" hochladen, Seriellen Monitor öffnen, Hand vor den Sensor halten.

// WALL·E Abstands-Test (RCWL-1601)
const int TRIG = 18;
const int ECHO = 19;

void setup() {
  Serial.begin(115200);
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
}

void loop() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);

  long dauer = pulseIn(ECHO, HIGH, 30000);  // max. ca. 5 m
  if (dauer == 0) {
    Serial.println("nichts gemessen");
  } else {
    Serial.printf("Abstand: %.1f cm\n", dauer * 0.0343 / 2.0);
  }
  delay(300);
}

1. Akku aus, USB-Kabel ab.
2. Den Ausgang des 5-V-Wandlers (LM2596) an das Board, und zwar an den Achter-Block rechts oben (beschriftet 3.3V, 5V, GND): OUT+ → ein Stift der 5V-Reihe, OUT− → ein Stift der GND-Reihe. Nicht an die 3.3V-Reihe!
3. Akku an. Leuchtet die LED PWR auf dem Board und die rote LED am ESP32? Das zuletzt hochgeladene Programm startet jetzt von allein.

1. Zusammenstecken: Die Kamera mit dem kleinen Flachkabel in die Buchse am Aufsteckboard stecken (die Klappe hochklappen, Kabel rein, Klappe zu). Das Aufsteckboard auf den XIAO drücken, bis es einrastet.
2. Antenne anstecken: Den kleinen runden Stecker der Antenne auf die Buchse am XIAO drücken, bis es klickt. Ohne Antenne ist das WLAN sehr schwach.
3. Programm hochladen: XIAO per USB-C an den PC. In der Arduino-IDE als Board XIAO_ESP32S3 wählen und unter Werkzeuge → PSRAM auf OPI PSRAM stellen. Ohne PSRAM findet das Programm die Kamera nicht. Dann das Programm „Kamera" unten hochladen.
4. Seriellen Monitor öffnen (115200). Dort muss „Kamera ok." stehen.
5. Handy verbinden: In den WLAN-Einstellungen das Netz WALL-E-Kamera wählen, Passwort walle1234. Das Handy meckert vielleicht, dass es kein Internet gibt. Das ist richtig so, einfach verbunden bleiben.
6. Im Handy-Browser 192.168.4.1 eingeben. Jetzt siehst du live, was die Kamera sieht.
7. Test durch die Linse: Die Linse (gewölbte Seite nach außen) vor die Kamera halten, mit etwa dem Abstand, den sie später im Auge hat. Wie sieht das Bild aus?

// WALL·E Kamera-Test (Seeed XIAO ESP32S3 Sense)
// Der XIAO macht ein eigenes WLAN "WALL-E-Kamera" auf.
// Handy damit verbinden (Passwort: walle1234), dann im Browser 192.168.4.1 öffnen.
// Board: XIAO_ESP32S3, PSRAM: OPI PSRAM
#include "esp_camera.h"
#include <WiFi.h>
#include "esp_http_server.h"

const char* WLAN_NAME = "WALL-E-Kamera";
const char* WLAN_PASSWORT = "walle1234";

// Kamera-Pins des XIAO ESP32S3 Sense (fest verdrahtet)
camera_config_t kameraEinstellungen() {
  camera_config_t c = {};
  c.pin_pwdn = -1;  c.pin_reset = -1;  c.pin_xclk = 10;
  c.pin_sccb_sda = 40;  c.pin_sccb_scl = 39;
  c.pin_d7 = 48; c.pin_d6 = 11; c.pin_d5 = 12; c.pin_d4 = 14;
  c.pin_d3 = 16; c.pin_d2 = 18; c.pin_d1 = 17; c.pin_d0 = 15;
  c.pin_vsync = 38; c.pin_href = 47; c.pin_pclk = 13;
  c.xclk_freq_hz = 20000000;
  c.ledc_timer = LEDC_TIMER_0;  c.ledc_channel = LEDC_CHANNEL_0;
  c.pixel_format = PIXFORMAT_JPEG;
  c.frame_size = FRAMESIZE_VGA;      // 640 x 480
  c.jpeg_quality = 12;               // kleiner = schöner, aber langsamer
  c.fb_count = 2;
  c.fb_location = CAMERA_FB_IN_PSRAM;
  c.grab_mode = CAMERA_GRAB_LATEST;
  return c;
}

static const char SEITE[] =
  "<!doctype html><html><head><meta name=viewport content='width=device-width'>"
  "<title>WALL-E Kamera</title></head><body style='margin:0;background:#222;color:#eee;font-family:sans-serif;text-align:center'>"
  "<h2>WALL&middot;E sieht:</h2><img src='/stream' style='width:100%;max-width:640px'></body></html>";

esp_err_t seite(httpd_req_t* req) {
  httpd_resp_set_type(req, "text/html");
  return httpd_resp_send(req, SEITE, HTTPD_RESP_USE_STRLEN);
}

esp_err_t stream(httpd_req_t* req) {
  httpd_resp_set_type(req, "multipart/x-mixed-replace;boundary=bild");
  char kopf[64];
  while (true) {
    camera_fb_t* fb = esp_camera_fb_get();
    if (!fb) return ESP_FAIL;
    int n = snprintf(kopf, sizeof(kopf), "\r\n--bild\r\nContent-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n", fb->len);
    esp_err_t ok = httpd_resp_send_chunk(req, kopf, n);
    if (ok == ESP_OK) ok = httpd_resp_send_chunk(req, (const char*)fb->buf, fb->len);
    esp_camera_fb_return(fb);
    if (ok != ESP_OK) return ESP_OK;  // Browser geschlossen
  }
}

void setup() {
  Serial.begin(115200);
  delay(2000);

  camera_config_t c = kameraEinstellungen();
  if (esp_camera_init(&c) != ESP_OK) {
    Serial.println("FEHLER: Kamera nicht gefunden. Flachkabel richtig eingesteckt? PSRAM auf OPI?");
    return;
  }
  Serial.println("Kamera ok.");

  WiFi.softAP(WLAN_NAME, WLAN_PASSWORT);
  Serial.printf("WLAN \"%s\" ist an. Im Browser: http://%s\n", WLAN_NAME, WiFi.softAPIP().toString().c_str());

  httpd_config_t cfg = HTTPD_DEFAULT_CONFIG();
  httpd_handle_t server = NULL;
  if (httpd_start(&server, &cfg) == ESP_OK) {
    httpd_uri_t a = { "/", HTTP_GET, seite, NULL };
    httpd_uri_t b = { "/stream", HTTP_GET, stream, NULL };
    httpd_register_uri_handler(server, &a);
    httpd_register_uri_handler(server, &b);
  }
}

void loop() {
  delay(1000);
}

1. Zwei Kettenglieder so hinlegen, dass die Nasen ineinandergreifen (wie im Bild).
2. Von jeder Seite einen Stift durch die Löcher stecken. Die Stifte halten durch Klemmen, ohne Kleber.
3. Prüfen: Die zwei Glieder müssen sich leicht gegeneinander knicken lassen.
4. So weitermachen, bis 35 Glieder hintereinander hängen. Die Kette erst in Schritt B2 zum Ring schließen.
5. Das Ganze nochmal für die zweite Kette.

1. Zwei Muttern in die sechseckigen Schlitze des Gestells schieben. Die bleiben dort einfach stecken: In B3 wird der Motorhalter mit Schrauben in diese Muttern geschraubt.
2. Das kleine Dreieck wheel-frame-addon an die markierte Stelle kleben (Bild 2).
3. Die Achsen in die Löcher des Gestells stecken (Bild 3). Geschraubt wird hier nichts. Die Achsen halten, weil auf beiden Enden ein Rad festgeklebt wird.
4. Die Räder auf die Achsen kleben: große Räder hinten, mittlere vorne, kleine oben. Das große Zahnrad gehört mit auf die hintere Achse (Bild 4).
5. Die dünnen Scheiben (spacer) auf die Achsen stecken, bevor das äußere Rad draufkommt. Sie sorgen dafür, dass nichts am Gestell schleift.
6. Die Kette um alle Räder legen. Das letzte Glied mit dem ersten verbinden (zwei Stifte), jetzt ist sie ein Ring.

1. Die zwei Motorhalter-Teile (wheel-bracket-inner und -outer) um den Motor legen. Der Motor liegt dazwischen wie in einer Schale.
2. Den Motor mit der M3 × 6 mm Schraube festmachen. Sie geht durch den Halter in eines der kleinen Gewindelöcher vorne am Getriebe.
3. Das kleine Zahnrad wheel-gear-motor auf die Motorwelle stecken. Die Welle hat eine flache Seite, das Loch im Zahnrad auch. Mit einem Tropfen Kleber sichern.
4. Den Halter so ans Radgestell setzen, dass das kleine Zahnrad in das große Zahnrad greift.
5. Mit 1× M3 × 20 mm und 2× M3 × 10 mm festschrauben (Bilder 3 und 4).
6. Das Ganze für die andere Seite wiederholen.

1. Die Hand: Die Finger und die Hand-Halterung (hand-bracket) übereinanderlegen und die dünne hand-axle von oben durchstecken (Bild 2). Die Finger sollen sich mit etwas Widerstand bewegen lassen, damit sie in jeder Stellung stehen bleiben.
2. Der Kolben: arm-piston an die Hand stecken, dann den Ring arm-barrel-end auf den Kolben schieben (Bild 3).
3. Das Rohr: Den Kolben in das lange Rohr arm-barrel schieben. Er soll hin- und hergleiten können.
4. Die Schulter: arm-hinge-inner in die Gabel am Rohr-Ende setzen und den kurzen Zylinder arm-hinge-axle von oben durchdrücken (Bild 4).
5. Den zweiten Arm genauso bauen. Achte darauf, dass du am Ende einen linken und einen rechten Arm hast (spiegelbildlich).

1. Augenringe noch nicht kleben! Die grünen Ringe (eye-front) kommen ganz zum Schluss dran (letzter Punkt). Sobald sie angeklebt sind, kommst du an Linse und Kamera nicht mehr heran.
2. Muttern: In jedes Mittelteil eine Mutter schieben (Bild 2) und in jedes Rückteil eye-back ebenfalls eine.
3. Mittelteile verschrauben: Je eine M3 × 20 mm durch die in Bild 3 markierten Löcher in die Mutter drehen.
4. Servos: Servo 3 ins rechte Auge, Servo 4 ins linke Auge (rechts/links aus Sicht von WALL·E). Kabel nach hinten herausführen.
5. Servo-Hebel: Einen einarmigen Hebel so aufstecken, dass er ungefähr so steht wie im Bild (das Auge ist dabei in der Mitte seines Weges). Servo dabei nicht verdrehen! Den Hebel ggf. um eine Zacke versetzen statt die Welle zu drehen. Mit der kleinen Servo-Schraube festschrauben.
6. Mittelstück einsetzen: head-center zwischen die beiden Augen legen, so dass die Löcher der Gelenke übereinanderliegen.
7. Büroklammer-Gestänge: Aus einer Büroklammer ein kurzes, gerades Stück mit zwei Haken biegen (Z-Form). Ein Haken in das 2. oder 3. Loch des Servo-Hebels, der andere in das Loch am Mittelstück head-center (Bilder 4 und 5). Einmal pro Auge.
8. Rückteile: Die eye-back-Teile hinten ansetzen und mit den letzten zwei M3 × 20 mm verschrauben (Bild 6).
9. Achse: Die lange Achse head-axle durch die Gelenklöcher der Augen und des Mittelstücks schieben. Die Augen hängen jetzt drehbar an der Achse.
10. Linsen und Einsätze: Erst wenn A8 (Kamera-Test) fertig ist. In jeden grünen Ring die Linse legen, gewölbte Seite nach außen, dahinter den schwarzen Einsatz. Ins eine Auge kommt eye-camera-replica (nur Deko), ins andere eye-camera-mount mit dem XIAO darin. Die zwei Stromkabel des XIAO hinten durch das Loch im Einsatz führen.
11. Augenring ankleben: Jetzt den Ring vorn an das Mittelteil (eye-middle) kleben (Bild 1, „Add Glue"). Vorher einmal prüfen: Die Linse liegt sauber im Ring und wackelt nicht.

1. Zwei Muttern in die Schlitze von neck-bottom-left schieben (Bild 1).
2. Servo 1 (Hals oben) in die Öffnung im unteren Halsstück setzen (Bild 2).
3. Den kurzen Zylinder neck-middle-axle ins Gelenkloch stecken und das obere Halsstück neck-top daraufsetzen.
4. Die zweite Hälfte neck-bottom-right auflegen und mit 2× M3 × 10 mm verschrauben (Bild 3). Das obere Halsstück muss danach leicht kippen können.
5. Servo 0 (Kopf drehen) von oben in neck-top einsetzen, Welle nach oben (Bild 4).
6. Drehteller: Einen Servo-Hebel in neck-round-bottom legen. Die zwei Hälften neck-round-top-left/right darum legen und alle drei zusammenkleben (Bild 5). Der Hebel sitzt dann fest im Teller.
7. Den Drehteller auf die Welle von Servo 0 stecken, so dass er gerade nach vorn zeigt (Servo steht ja auf 90° = Kopf schaut geradeaus).
8. Gestänge: Auf Servo 1 einen Hebel stecken. Das schwarze neck-top-linkage und ein Stück Büroklammer verbinden den Servo-Hebel mit dem oberen Halsstück (Bild 6). Die Büroklammer kommt ins 2. Loch des Servo-Hebels.

1. Vier Muttern in die Schlitze der Seitenwände body-left und body-right schieben (Bild 2).
2. Arm-Servos: Servo 5 in arm-servo-bracket-left, Servo 6 in arm-servo-bracket-right. In jeden Halter eine Mutter (Bild 3).
3. Einen Servo-Hebel in die gelbe Scheibe arm-hinge-outer einsetzen (bei Bedarf kleben) und die Scheibe auf die Servo-Welle stecken.
4. Die Servo-Halter innen an die Seitenwände kleben, so dass die Scheibe durch das Loch in der Wand nach außen schaut (Bild 4). Erst trocken probieren!
5. Die Klappe body-front-door mit den zwei Stiften body-front-pins an body-front befestigen (das ist das Scharnier). Die Klappe muss auf- und zugehen.
6. Seitenwände an die Rückwand body-back setzen, Front davor (Bild 6).
7. Alles auf den Boden body-bottom stellen und von unten mit 4× M3 × 20 mm verschrauben (Bild 7). Die restlichen 2× M3 × 20 mm gehen oben durch die Rückwand in die Muttern der Arm-Servo-Halter (die zwei Schrauben oben auf der Rückwand in Bild 6).
8. Arme anstecken: Das Schultergelenk jedes Arms (arm-hinge-inner) auf die Scheibe am Servo setzen. Stellung: Der Arm steht in der Mitte zwischen ganz oben und ganz unten.

1. Ketten an den Körper: Acht Muttern innen in den Boden legen. Die zwei Antriebsseiten von unten ansetzen und mit 8× M3 × 10 mm festschrauben (Bilder 2 und 3). Die Motorkabel zeigen nach innen.
2. Kopf auf den Hals: Das Mittelstück des Kopfes auf den Drehteller oben am Hals kleben (Bild 4). Vorher prüfen: Kopf schaut geradeaus, wenn Servo 0 auf 90° steht.
3. Hals-Servo unten: Servo 2 in den Halter body-neck-servo-holder setzen und den Halter unter dem Deckel body-top befestigen.
4. Hals auf den Deckel: Das untere Halsstück zwischen die zwei Ösen auf dem Deckel setzen und die Achse neck-bottom-axle durchschieben (Bild 5). Der Hebel am Hals ragt durch den Schlitz nach unten.
5. Gestänge: Den Hebel am Hals mit neck-bottom-linkage und einer Büroklammer mit dem Servo-Hebel von Servo 2 verbinden (Bild 6).
6. Kabel von Kopf und Hals nach unten durch die Öffnung im Deckel führen (siehe Teil C). Jetzt ist der beste Moment dafür!
7. Deckel auf den Körper setzen und mit 2× M3 × 20 mm festschrauben (Bild 7). Diesen Schritt machst du erst, wenn Teil C fertig ist.

1. Lege alle Elektronik-Teile vor dich und halte sie probeweise in den Körper. Der Deckel ist noch ab.
2. Akku vorn hinter die Klappe. Er muss zum Laden rausnehmbar bleiben, also mit Klettband, nicht fest kleben.
3. Die zwei BTS7960 nahe an die Motoren (Boden, links und rechts). Sie haben große Kühlkörper, die dürfen nichts berühren und brauchen etwas Luft.
4. PCA9685 weiter oben, nah am Hals. Dann reichen die Servokabel eher.
5. ESP32 so, dass du mit dem USB-Kabel noch dran kommst (z.B. an der Rückwand). Sonst musst du zum Programmieren alles ausbauen.
6. Wandler und Verteiler dazwischen, wo Platz ist.
7. Schalter: an eine Stelle, an die du von außen drankommst, ohne die Klappe zu öffnen. Dafür musst du ggf. ein Loch bohren. Mach das nur an einer unauffälligen Stelle, z.B. hinten unten.

1. Durch den Hals laufen 4 Servokabel: Auge rechts (3), Auge links (4), Kopf drehen (0) und Hals oben (1). Servo 2 sitzt schon unter dem Deckel. Dazu kommen die 2 Stromkabel der Kamera (5V und GND), die unten in die 5-V-WAGOs gehen.
2. Die Kabel locker am Hals entlang nach unten führen, mit den kleinen Kabelführungen oder einem dünnen Kabelbinder sichern.
3. Bewegungstest: Mit dem Servo-Tester Kopf ganz nach links und rechts drehen, Hals ganz hoch und runter. Die Kabel dürfen dabei nirgends ziehen oder eingeklemmt werden. Lieber eine Schlaufe Reserve lassen.
4. Reicht ein Kabel nicht bis zum PCA9685: Servo-Verlängerung dazwischenstecken. Die Steckverbindung mit einem Stück Klebeband sichern, damit sie nicht aufgeht.
5. Jedes Kabel am Ende nochmal beschriften (0 bis 6), dann ist das Einstecken leicht.

1. Akku ab.
2. Boards mit Klettband oder doppelseitigem Klebeband an ihre Plätze kleben. Unter die Platinen darf kein Metall (Schrauben, Muttern).
3. Nach dem Strom-Plan die dicken Kabel verbinden. Dann nach dem Signal-Plan die Dupont-Kabel.
4. Servos in die Kanäle 0 bis 6 stecken (braun zu GND).
5. Kabel mit Kabelbindern bündeln, damit nichts in die Zahnräder oder Ketten kommt.
6. Checkliste vor dem ersten Einschalten:
   • Rot und Schwarz nirgends vertauscht? (Wandler, PCA9685-Schraubklemme, BTS7960)
   • PCA9685-Schraubklemme hängt am 6-V-Wandler, die 5V-Reihe des Boards am 5-V-Wandler?
   • Jumper am Erweiterungsboard auf 3.3V? (Nachmessen: V-Stift gegen G-Stift = 3,3 V)
   • Nirgends blanke Drähte, die sich berühren können?
7. Akku an. Riecht etwas, wird etwas heiß? Sofort aus. Sonst: Servo-Tester und Motor-Test nochmal laufen lassen, jetzt im fertigen Roboter.

Jedes Gelenk kann sich nur ein Stück bewegen, nicht die vollen 180°. Fährt ein Servo weiter, drückt er gegen das Plastik, brummt, wird warm und geht irgendwann kaputt. Darum schreibst du dir für jeden Servo auf, wie weit er gehen darf.

1. Servo-Tester hochladen (5V-Kabel am Board dabei ab!), Seriellen Monitor öffnen, Akku an.
2. Mit Kanal 0 anfangen: 0 90. Dann in kleinen Schritten weiter: 0 80, 0 70 … bis der Kopf so weit gedreht ist wie auf dem Bild „LOW". Wert aufschreiben.
3. Genauso in die andere Richtung bis „HIGH". Wert aufschreiben.
4. Wenn es brummt: Du bist zu weit. 5° zurück.
5. Das für alle 7 Servos machen und in die Tabelle schreiben:

1. WALL·E auf den Boden stellen, genug Platz drumherum.
2. Motor-Test laufen lassen. Fährt er bei „BEIDE vorwärts" wirklich nach vorn? Wenn eine Seite rückwärts läuft: Akku aus, an diesem BTS7960 M+ und M− tauschen.
3. Bei „LINKS vorwärts" muss sich WALL·E nach rechts drehen (die linke Kette schiebt). Wenn nicht: linker und rechter Treiber sind vertauscht.