Ausweichroboter

Ein Roboter, der selbstständig durch den Raum fährt und Hindernissen ausweicht. Kein Bausatz, kein Lasercut, kein 3D-Druck -- das Chassis ist ein Paketkarton. Schere, Heißkleber, fertig. Die Elektronik ist ein Arduino Uno, ein Motortreiber-Shield und ein Ultraschallsensor. Gesamtkosten unter 20 Euro (ohne den Karton).

Stückliste

Das DRV8835 Shield steckt direkt auf den Arduino -- keine Kabel zwischen Uno und Motortreiber nötig. Die TT-Motoren mit Rädern werden oft im Doppelpack verkauft.

Chassis

Das Chassis ist ein einziges Stück Wellpappe, das zu einer flachen Wanne gefaltet wird. Kein Schneiden und Kleben von Einzelteilen -- ein Zuschnitt, falten, fertig. Die hochgeklappten Wände geben Stabilität und dienen gleichzeitig als Halterung für den Sensor und die Elektronik.

Zuschnitt

Ausgangsmaterial: ein Stück doppelwellige Pappe, ca. 30 × 24 cm (passt in jeden Paketkarton). Die Wellpappe-Rillen sollten quer zur Fahrtrichtung laufen -- dann lassen sich die Seitenwände sauber falten.

        ┌─────── 18 cm ───────┐
        │                      │
   4 cm │   ○ ○   Frontwand   │ 4 cm
────────┼──────────────────────┼────────
        │                      │
        │                      │
   4 cm │     Bodenplatte      │ 4 cm
        │       18 × 12        │
        │                      │
────────┼──────────────────────┼────────
   4 cm │    Heckwand (2 cm)   │ 4 cm
        │                      │
        └──────────────────────┘

• Bodenplatte: 18 × 12 cm (Mitte)
• Seitenwände: je 4 cm hoch, links und rechts
• Frontwand: 4 cm hoch, mit zwei Löchern (Ø 16 mm, Abstand 26 mm) für die HC-SR04-Augen
• Heckwand: nur 2 cm hoch (Kabel müssen raus)
• Ecklaschen: Die 4 × 4 cm Ecken einschneiden, dann als Verstärkung nach innen falten und festkleben

Falzlinien

Die Falzlinien (gestrichelt im Zuschnitt) mit der stumpfen Seite einer Schere oder einem Lineal einritzen -- nicht durchschneiden. Dann klappen die Wände sauber hoch. Bei doppelwelliger Pappe geht das einwandfrei.

Motorhalterung

Die TT-Motoren werden von innen an die Seitenwände geklebt. Dazu in jede Seitenwand einen Schlitz schneiden (ca. 20 × 15 mm), durch den die Motorachse nach außen ragt. Der Motor liegt flach an der Innenseite der Wand an -- Heißkleber hält bombenfest.

Die Motorachsen sollten ungefähr auf halber Länge der Bodenplatte sitzen, leicht hinter der Mitte. So kippt der Bot nicht nach vorne.

Zusammenbau

1. Zuschnitt ausschneiden, Falzlinien ritzen
2. Motorschlitze in die Seitenwände schneiden
3. HC-SR04-Löcher in die Frontwand bohren (Kugelschreiber reicht)
4. Wände hochklappen, Ecklaschen nach innen falten und festkleben
5. Motoren von innen einkleben, Räder aufstecken
6. Kugelrad hinten mittig unter die Bodenplatte kleben (oder eine Murmel in einen Heißklebe-Klecks drücken)
7. Arduino Uno oben auf die Bodenplatte -- doppelseitiges Klebeband oder Gummibänder. DRV8835 Shield aufstecken.
8. Batteriehalter unter die Bodenplatte zwischen die Motoren

Zeitaufwand: ca. 30 Minuten. Wenn was nicht passt -- neuen Karton nehmen, kostet nichts.

Schaltung

Das DRV8835 Shield steckt direkt auf den Arduino Uno -- die Motorsteuerung braucht keine extra Kabel. Nur der Ultraschallsensor und die Stromversorgung werden separat angeschlossen.

Pinbelegung

Der MODE-Pin des DRV8835 ist auf dem Shield fest auf HIGH verdrahtet (Phase/Enable-Modus) -- dafür wird kein Arduino-Pin belegt.

Verkabelung

• Shield aufstecken: DRV8835 Shield auf den Arduino Uno stecken. Fertig -- alle Steuerleitungen laufen über die Pin-Header.
• Stromversorgung: 4× AA (6V) an die VIN-Schraubklemme des Shields (+ und GND). Das Shield versorgt darüber auch den Arduino.
• Motoren: Linker Motor an die Klemmen M1A/M1B, rechter Motor an M2A/M2B.
• HC-SR04: VCC an Arduino 5V, GND an GND, Trigger an D2, Echo an D3.

Code

// Ausweichroboter -- Arduino Uno + HC-SR04 + DRV8835 Shield
// Fährt geradeaus, weicht bei Hindernis aus.

// --- Pins ---
const int TRIG = 2;
const int ECHO = 3;

// DRV8835 Shield -- MODE ist auf dem Shield fest auf HIGH (Phase/Enable-Modus)
const int M1DIR = 7;   // Richtung Motor 1
const int M2DIR = 8;   // Richtung Motor 2
const int M1PWM = 9;   // PWM Motor 1
const int M2PWM = 10;  // PWM Motor 2

// --- Parameter ---
const int SPEED       = 150;  // 0-255, Motorgeschwindigkeit
const int TURN_SPEED  = 180;
const int MIN_DIST_CM = 25;   // Ausweichdistanz
const int TURN_MS     = 400;  // Drehzeit in ms

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  pinMode(M1DIR, OUTPUT);
  pinMode(M2DIR, OUTPUT);
  pinMode(M1PWM, OUTPUT);
  pinMode(M2PWM, OUTPUT);
  // MODE ist auf dem Shield fest auf HIGH -- kein Arduino-Pin noetig

  Serial.begin(9600);
}

void loop() {
  int dist = measureDistance();

  if (dist > 0 && dist < MIN_DIST_CM) {
    stop();
    delay(200);
    backward(SPEED);
    delay(300);
    stop();
    delay(200);
    turnRight(TURN_SPEED);
    delay(TURN_MS);
    stop();
    delay(200);
  } else {
    forward(SPEED);
  }

  delay(50);
}

// --- Entfernung messen ---
int measureDistance() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);

  long duration = pulseIn(ECHO, HIGH, 30000);
  if (duration == 0) return -1;
  return duration / 58;
}

// --- Motorfunktionen (DRV8835 Phase/Enable) ---
// DIR LOW = vorwärts, DIR HIGH = rückwärts
// PWM = Geschwindigkeit

void forward(int speed) {
  digitalWrite(M1DIR, LOW);
  digitalWrite(M2DIR, LOW);
  analogWrite(M1PWM, speed);
  analogWrite(M2PWM, speed);
}

void backward(int speed) {
  digitalWrite(M1DIR, HIGH);
  digitalWrite(M2DIR, HIGH);
  analogWrite(M1PWM, speed);
  analogWrite(M2PWM, speed);
}

void turnRight(int speed) {
  digitalWrite(M1DIR, LOW);   // links vorwärts
  digitalWrite(M2DIR, HIGH);  // rechts rückwärts
  analogWrite(M1PWM, speed);
  analogWrite(M2PWM, speed);
}

void turnLeft(int speed) {
  digitalWrite(M1DIR, HIGH);  // links rückwärts
  digitalWrite(M2DIR, LOW);   // rechts vorwärts
  analogWrite(M1PWM, speed);
  analogWrite(M2PWM, speed);
}

void stop() {
  analogWrite(M1PWM, 0);
  analogWrite(M2PWM, 0);
}

Der Code ist bewusst simpel gehalten -- eine Zustandsmaschine mit zwei Zuständen: "Fahren" und "Ausweichen". Das reicht, um den Bot durch ein Zimmer fahren zu lassen.

Was man verbessern kann

• Zufällige Drehrichtung: Mal links, mal rechts ausweichen (random())
• Zweiter Sensor: Seitlich montiert, für bessere Orientierung
• Geschwindigkeitsregelung: Langsamer werden je näher das Hindernis
• Serielle Ausgabe: Serial.println(dist) für Debugging über USB

Weiterführendes

• HC-SR04 Ultraschallsensor -- Details zum Sensor
• Mikrocontroller -- ATMega328P und ESP32 im Überblick