Willkommen in der aufregenden Welt der Robotik! Haben Sie sich jemals gefragt, wie man einen Roboter baut, der autonom einer Linie folgen kann? Das ist nicht nur ein faszinierendes Konzept, sondern auch ein perfektes Einsteigerprojekt, um die Grundlagen der Elektronik, Programmierung und Mechanik zu verstehen. In diesem Artikel begleiten wir Sie Schritt für Schritt beim Bau Ihres eigenen smarten Linefollower-Roboters mit dem vielseitigen Raspberry Pi Pico.
### Warum einen Linefollower bauen?
Ein Linefollower ist ein Roboter, der eine visuelle Linie (meist eine schwarze Linie auf hellem Grund oder umgekehrt) erkennen und ihr autonom folgen kann. Dieses Projekt ist aus mehreren Gründen ideal für Anfänger:
* **Grundlagen verstehen:** Sie lernen, wie Sensoren Daten sammeln, wie ein Mikrocontroller diese Daten verarbeitet und wie Aktuatoren (Motoren) darauf reagieren.
* **Praktische Anwendung:** Linefollower sind die Grundlage für viele fortschrittlichere Robotersysteme, von autonomen Lieferrobotern bis hin zu Lagerhaltungssystemen.
* **Problem lösen:** Sie entwickeln Fähigkeiten zur Fehlersuche und zum Experimentieren, während Sie den Roboter optimieren.
* **Spaßfaktor:** Es ist unglaublich befriedigend, zu sehen, wie Ihr selbst gebauter Roboter zum Leben erwacht und seine Aufgabe erfüllt!
### Warum der Raspberry Pi Pico?
Der Raspberry Pi Pico ist ein kleiner, kostengünstiger und leistungsstarker Mikrocontroller, der von der Raspberry Pi Foundation entwickelt wurde. Er ist eine ausgezeichnete Wahl für dieses Projekt aus mehreren Gründen:
* **Erschwinglichkeit:** Er ist deutlich günstiger als viele andere Entwicklungsboards und bietet dennoch beeindruckende Fähigkeiten.
* **Leistung:** Mit seinem Dual-Core ARM Cortex-M0+ Prozessor und 264 KB RAM kann er komplexe Berechnungen schnell durchführen.
* **Einfache Programmierung:** Sie können den Pico problemlos mit MicroPython (einer schlanken Version von Python für Mikrocontroller) programmieren, was ihn besonders anfängerfreundlich macht. Alternativ ist auch die Programmierung in C/C++ möglich.
* **Vielseitige GPIOs:** Er verfügt über zahlreiche General Purpose Input/Output (GPIO)-Pins, die sich perfekt zum Anschließen von Sensoren, Motoren und anderen Komponenten eignen.
* **Kompakte Größe:** Seine geringe Größe macht ihn ideal für kleinere Roboterchassis.
### Was benötigen Sie für Ihr Projekt?
Bevor wir loslegen, stellen Sie sicher, dass Sie alle notwendigen Komponenten und Werkzeuge zur Hand haben.
**Elektronische Komponenten:**
1. **Raspberry Pi Pico:** Das Gehirn Ihres Roboters.
2. **Motortreiber (z.B. L298N oder DRV8833):** Der Pico kann Motoren nicht direkt mit genug Strom versorgen. Ein Motortreiber ist eine Brücke, die die Steuerbefehle des Pico in die benötigte Leistung für die Motoren umwandelt. Der L298N ist robust, der DRV8833 ist kleiner und effizienter für kleinere Motoren.
3. **Gleichstrommotoren mit Getriebe (2 Stück):** Kleine 3V-6V-Motoren sind ideal. Die Getriebe sorgen für das nötige Drehmoment.
4. **Räder (2 Stück):** Passend zu Ihren Motoren.
5. **Line-Follower-Sensormodul (z.B. 3-5 IR-Sensoren):** Diese Module enthalten Infrarot-Sender und -Empfänger. Sie erkennen Linien, indem sie die Reflexion von Infrarotlicht messen. Ein Modul mit 3 oder 5 Sensoren bietet mehr Präzision.
6. **Batteriehalter und Batterien (z.B. 4x AA oder 1x 18650 Li-Ion):** Die Stromversorgung für Ihren Roboter. Achten Sie auf ausreichende Spannung (ca. 4,5V – 7,4V), die für den Motortreiber und den Pico geeignet ist.
7. **Mini-Breadboard (optional, aber empfohlen):** Zum einfachen Verkabeln und Testen von Komponenten.
8. **Jumper-Kabel (männlich-männlich, weiblich-weiblich, männlich-weiblich):** Für die Verbindungen zwischen den Komponenten.
9. **Stiftleisten (optional):** Falls Ihr Pico noch keine verlöteten Pins hat.
10. **USB-Kabel (Micro-USB):** Zum Programmieren des Pico.
**Mechanische Komponenten:**
1. **Roboter-Chassis:** Eine einfache Plattform aus Acryl, Holz oder 3D-gedrucktem Material. Es gibt auch vorgefertigte Kits.
2. **Lenkrolle (Caster Wheel):** Ein kleines, frei drehbares Rad, das an der Vorder- oder Rückseite des Chassis angebracht wird, um Stabilität zu gewährleisten.
**Werkzeuge:**
1. **Lötkolben und Lötzinn (optional, falls Pins oder Kabel gelötet werden müssen):** Für robustere Verbindungen.
2. **Schraubendreher-Set:** Zum Zusammenbau des Chassis und der Komponenten.
3. **Seitenschneider und Abisolierzange:** Zum Bearbeiten von Kabeln.
4. **Computer mit USB-Anschluss:** Zum Programmieren des Pico.
### Software-Einrichtung: MicroPython auf dem Pico
Bevor wir mit dem Verkabeln beginnen, bereiten wir den Raspberry Pi Pico vor:
1. **Thonny IDE herunterladen:** Thonny ist eine benutzerfreundliche Python-IDE, die speziell für Anfänger und den Einsatz mit Mikrocontrollern wie dem Raspberry Pi Pico entwickelt wurde. Laden Sie sie von der offiziellen Website herunter und installieren Sie sie.
2. **Pico im Bootloader-Modus starten:** Halten Sie die BOOTSEL-Taste auf dem Pico gedrückt, während Sie ihn mit dem USB-Kabel an Ihren Computer anschließen. Lassen Sie die Taste los, sobald er verbunden ist. Er wird als Massenspeichergerät angezeigt.
3. **MicroPython-Firmware flashen:** Gehen Sie zur offiziellen Raspberry Pi Pico MicroPython-Downloadseite und laden Sie die neueste UF2-Datei herunter. Ziehen Sie diese Datei auf das Massenspeichergerät des Pico. Der Pico wird neu starten und die Firmware ist installiert.
4. **Thonny konfigurieren:** Öffnen Sie Thonny. Gehen Sie zu „Tools” -> „Options” -> „Interpreter”. Wählen Sie „MicroPython (Raspberry Pi Pico)” als Interpreter und den richtigen COM-Port für Ihren Pico. Klicken Sie auf OK. Nun sollten Sie in der Shell unten in Thonny eine Verbindung zum Pico sehen.
### Die Schaltung aufbauen: Verkabelung des Linefollowers
Die Verkabelung ist ein entscheidender Schritt. Arbeiten Sie sorgfältig und überprüfen Sie alle Verbindungen.
**1. Line-Follower-Sensoren an den Pico anschließen:**
* Verbinden Sie den VCC-Pin des Sensors mit einem 3.3V-Ausgang des Pico (z.B. Pin 36, 3V3_OUT).
* Verbinden Sie den GND-Pin des Sensors mit einem GND-Pin des Pico (z.B. Pin 38, GND).
* Verbinden Sie die Ausgangspins der Sensoren (OUT1, OUT2, OUT3…) mit digitalen GPIO-Pins des Pico (z.B. GP0, GP1, GP2, GP3, GP4). Die Anzahl der verwendeten Pins hängt von der Anzahl der Sensoren in Ihrem Modul ab.
**2. Motortreiber an den Pico und die Motoren anschließen:**
* **Stromversorgung des Motortreibers:**
* Verbinden Sie den VCC/VM-Pin des Motortreibers (Motor Power Input) mit dem positiven Pol Ihrer Batterie.
* Verbinden Sie den GND-Pin des Motortreibers mit dem negativen Pol Ihrer Batterie.
* **Motoren an den Motortreiber:**
* Verbinden Sie die Drähte des ersten Motors mit den Ausgangspins OUT1 und OUT2 des Motortreibers.
* Verbinden Sie die Drähte des zweiten Motors mit den Ausgangspins OUT3 und OUT4 des Motortreibers.
* **Steuerungspins des Motortreibers an den Pico:**
* Motortreiber wie der L298N haben typischerweise 4 Eingangspins (IN1, IN2, IN3, IN4) und manchmal einen Enable-Pin (ENA, ENB).
* Verbinden Sie IN1, IN2, IN3, IN4 mit digitalen GPIO-Pins des Pico (z.B. GP6, GP7, GP8, GP9).
* Wenn Ihr Motortreiber Enable-Pins hat, verbinden Sie diese mit weiteren GPIO-Pins des Pico (z.B. GP10, GP11) oder direkt mit 3.3V, wenn Sie die Motoren immer auf voller Geschwindigkeit laufen lassen möchten (nicht empfohlen für präzise Steuerung). Für eine bessere Geschwindigkeitskontrolle verwenden Sie PWM-fähige Pins des Pico (viele GPIOs sind PWM-fähig).
**3. Pico-Stromversorgung:**
* Der Raspberry Pi Pico kann über den USB-Anschluss mit Strom versorgt werden. Für den mobilen Betrieb ist es am besten, den VBUS-Pin (Pin 40) des Pico mit der positiven Spannung Ihrer Batterie zu verbinden (stellen Sie sicher, dass diese 5V nicht übersteigt oder verwenden Sie einen Step-Down-Regler, wenn Ihre Batterie mehr als 5V liefert, um den Pico nicht zu beschädigen). Alternativ können Sie einen 3.3V-Regler verwenden und den Vsys-Pin (Pin 39) des Pico mit der geregelten 3.3V versorgen. Die einfachste Methode ist oft, den 5V-Ausgang eines L298N-Moduls (falls vorhanden) mit dem VBUS des Pico zu verbinden, sofern Ihre Gesamtbatteriespannung für den L298N passend ist.
### Die Programmierung: Das Gehirn des Roboters
Jetzt wird es spannend! Wir programmieren den Pico in MicroPython, um die Sensordaten zu lesen und die Motoren entsprechend zu steuern.
**1. Bibliotheken importieren und Pins definieren:**
„`python
from machine import Pin, PWM
import time
# Sensoren definieren (passen Sie die Pins an Ihr Setup an)
# Beispiel für 5 Sensoren:
sensor_pins = [Pin(0, Pin.IN), Pin(1, Pin.IN), Pin(2, Pin.IN), Pin(3, Pin.IN), Pin(4, Pin.IN)]
# Motorsteuerung definieren (passen Sie die Pins an Ihr Setup an)
# Motor 1 (links)
motor1_forward = Pin(6, Pin.OUT)
motor1_backward = Pin(7, Pin.OUT)
motor1_enable = PWM(Pin(10)) # PWM Pin für Geschwindigkeitskontrolle
motor1_enable.freq(1000) # Frequenz setzen
# Motor 2 (rechts)
motor2_forward = Pin(8, Pin.OUT)
motor2_backward = Pin(9, Pin.OUT)
motor2_enable = PWM(Pin(11)) # PWM Pin für Geschwindigkeitskontrolle
motor2_enable.freq(1000)
# Startgeschwindigkeit der Motoren (0-65535 für 16-Bit PWM)
base_speed = 30000
„`
**2. Funktionen für die Motorsteuerung:**
„`python
def set_motor_speed(motor_enable_pin, speed):
motor_enable_pin.duty_u16(speed)
def stop_motors():
motor1_forward.value(0)
motor1_backward.value(0)
motor2_forward.value(0)
motor2_backward.value(0)
set_motor_speed(motor1_enable, 0)
set_motor_speed(motor2_enable, 0)
def move_forward(speed):
motor1_forward.value(1)
motor1_backward.value(0)
motor2_forward.value(1)
motor2_backward.value(0)
set_motor_speed(motor1_enable, speed)
set_motor_speed(motor2_enable, speed)
def turn_left(left_speed, right_speed):
motor1_forward.value(0) # Linker Motor rückwärts oder aus
motor1_backward.value(1)
motor2_forward.value(1)
motor2_backward.value(0)
set_motor_speed(motor1_enable, left_speed)
set_motor_speed(motor2_enable, right_speed)
def turn_right(left_speed, right_speed):
motor1_forward.value(1)
motor1_backward.value(0)
motor2_forward.value(0) # Rechter Motor rückwärts oder aus
motor2_backward.value(1)
set_motor_speed(motor1_enable, left_speed)
set_motor_speed(motor2_enable, right_speed)
„`
**3. Sensoren auslesen und Logik implementieren:**
Infrarot-Line-Follower-Sensoren geben typischerweise ein niedriges Signal (0) aus, wenn sie eine dunkle Linie erkennen, und ein hohes Signal (1), wenn sie einen hellen Untergrund erkennen (oder umgekehrt, je nach Modul). Eine schwarze Linie auf weißem Untergrund ist Standard.
Die Logik basiert darauf, welche Sensoren die Linie sehen:
* **Alle Sensoren auf Weiß (oder die Linie ist nicht sichtbar):** Roboter stoppt oder sucht.
* **Mittlerer Sensor auf Schwarz:** Roboter fährt geradeaus.
* **Rechter Sensor auf Schwarz:** Roboter muss nach links lenken.
* **Linker Sensor auf Schwarz:** Roboter muss nach rechts lenken.
* **Extreme Sensoren auf Schwarz:** Roboter muss stark lenken.
Eine einfache P-Regelung (Proportionalregelung) kann hier schon Wunder wirken. Wir definieren einen Fehlerwert basierend auf der Sensorposition und passen die Motorgeschwindigkeiten proportional dazu an.
„`python
# PID-Parameter (vereinfacht für P-Regler)
kp = 1000 # Proportionaler Anteil, muss feinjustiert werden
def read_sensors():
# Liest die Werte der Sensoren.
# Annahme: Schwarz = 0, Weiß = 1
# Sensor 0 ist ganz links, Sensor 4 ist ganz rechts
values = [s.value() for s in sensor_pins]
return values
def calculate_error(sensor_values):
# Berechnet einen Fehlerwert basierend auf den Sensorwerten
# Ein Wert von 0 bedeutet, dass die Linie perfekt mittig ist.
# Negative Werte bedeuten, der Roboter ist zu weit rechts (muss links lenken).
# Positive Werte bedeuten, der Roboter ist zu weit links (muss rechts lenken).
# Beispiel für 5 Sensoren:
# Gewichtungen: [-2, -1, 0, 1, 2]
# Wenn z.B. nur der zweite Sensor (Index 1) die Linie sieht,
# ist der gewichtete Durchschnitt: (0*(-2) + 1*(-1) + 0*0 + 0*1 + 0*2) / (Anzahl der Sensoren die Linie sehen)
line_on_sensor = False
weighted_sum = 0
num_sensors_on_line = 0
# Gewichtungen für 5 Sensoren: Ganz links -2, links -1, mitte 0, rechts 1, ganz rechts 2
weights = [-2, -1, 0, 1, 2]
for i, val in enumerate(sensor_values):
if val == 0: # Wenn Sensor eine Linie erkennt (Schwarz)
line_on_sensor = True
weighted_sum += weights[i]
num_sensors_on_line += 1
if not line_on_sensor:
# Roboter hat die Linie verloren.
# Hier können Sie eine Strategie implementieren (z.B. letzte Richtung beibehalten, stoppen, etc.)
# Für diesen einfachen Fall: Ein sehr großer Fehler, um ihn zurückzulenken
if last_error < 0: # Zuvor zu weit rechts
return -4 # Stark nach links lenken
else: # Zuvor zu weit links
return 4 # Stark nach rechts lenken
speed_adjust = kp * error
left_motor_speed = base_speed – speed_adjust
right_motor_speed = base_speed + speed_adjust
# Geschwindigkeiten begrenzen
if left_motor_speed > 65535: left_motor_speed = 65535
if left_motor_speed < 0: left_motor_speed = 0
if right_motor_speed > 65535: right_motor_speed = 65535
if right_motor_speed < 0: right_motor_speed = 0
# Roboter bewegen
# Standard: Beide Motoren vorwärts
motor1_forward.value(1) # Linker Motor vorwärts
motor1_backward.value(0)
motor2_forward.value(1) # Rechter Motor vorwärts
motor2_backward.value(0)
set_motor_speed(motor1_enable, int(left_motor_speed))
set_motor_speed(motor2_enable, int(right_motor_speed))
time.sleep(0.01) # Kurze Pause
```
Speichern Sie diesen Code als `main.py` auf Ihrem Raspberry Pi Pico (in Thonny: "File" -> „Save as” -> „Raspberry Pi Pico” -> „main.py”). Der Code wird dann automatisch ausgeführt, wenn der Pico eingeschaltet wird.
### Den Roboter zusammenbauen und testen
1. **Chassis montieren:** Schrauben Sie die Motorhalterungen an das Chassis und befestigen Sie die Motoren. Stecken Sie die Räder auf die Motorwellen. Bringen Sie die Lenkrolle an.
2. **Sensoren anbringen:** Montieren Sie die Line-Follower-Sensoren an der Unterseite des Chassis, direkt vor den Antriebsrädern. Achten Sie darauf, dass sie nahe genug am Boden sind (ca. 0,5 – 1,5 cm), um die Linie gut zu erkennen.
3. **Pico und Motortreiber montieren:** Befestigen Sie den Raspberry Pi Pico und den Motortreiber sicher auf dem Chassis, idealerweise mit Abstandshaltern, um Kurzschlüsse zu vermeiden.
4. **Verkabelung prüfen:** Überprüfen Sie alle Verbindungen noch einmal sorgfältig gemäß Ihrem Schaltplan. Doppelt prüfen ist besser als einmal alles durchschmoren!
5. **Batterie anschließen:** Verbinden Sie die Batterie. Seien Sie vorsichtig und achten Sie auf die richtige Polarität.
**Erster Testlauf und Feinabstimmung:**
* **Sensor-Kalibrierung:** Testen Sie die Sensoren. Halten Sie sie über eine schwarze Linie und dann über eine weiße Fläche. Prüfen Sie in Thonny in der Shell, ob die ausgegebenen Sensorwerte korrekt sind (0 für Schwarz, 1 für Weiß oder umgekehrt). Passen Sie den Code bei Bedarf an.
* **Motor-Richtung:** Fahren Sie den Roboter manuell ein kurzes Stück vorwärts, indem Sie eine Testfunktion im Code ausführen. Drehen sich die Räder in die richtige Richtung? Falls nicht, vertauschen Sie die Kabel für den jeweiligen Motor am Motortreiber.
* **Linie zeichnen:** Verwenden Sie ein großes Blatt Papier oder eine weiße Pappe und zeichnen Sie eine dicke schwarze Linie (ca. 2-3 cm breit). Ein Klebeband ist auch gut geeignet.
* **PID-Tuning:** Dies ist der wichtigste Teil der Feinabstimmung.
* **Basisgeschwindigkeit (`base_speed`):** Beginnen Sie mit einem moderaten Wert, bei dem der Roboter gut fährt.
* **Proportional-Anteil (`kp`):** Erhöhen Sie den `kp`-Wert langsam.
* Ist der Roboter zu langsam beim Reagieren auf Kurven? Erhöhen Sie `kp`.
* Pendelt der Roboter stark hin und her (Oszillation)? Reduzieren Sie `kp`.
Es geht darum, einen guten Kompromiss zu finden, bei dem der Roboter sanft und präzise der Linie folgt, ohne zu sehr zu „zappeln” oder von der Linie abzukommen.
### Häufige Probleme und deren Behebung
* **Roboter fährt nicht:** Überprüfen Sie die Stromversorgung der Motoren und des Pico. Ist der Motortreiber richtig angeschlossen? Sind die Motoren richtig verkabelt?
* **Roboter dreht sich im Kreis:** Einer der Motoren ist falsch herum verkabelt oder der Code sendet falsche Signale. Überprüfen Sie die Motorpolarität und die Logik in den `turn_left`/`turn_right` Funktionen.
* **Roboter folgt der Linie nicht oder überfährt sie:** Sensoren falsch angeschlossen oder die Logik in `calculate_error` ist falsch. Überprüfen Sie die Sensorwerte. `kp` Wert ist falsch (zu niedrig oder zu hoch).
* **Sensoren erkennen die Linie nicht:** Der Abstand der Sensoren zum Boden ist zu groß oder zu klein. Umgebungslicht stört (IR-Sensoren können empfindlich auf starkes Licht reagieren). Die Linie ist nicht kontrastreich genug.
### Erweiterungen für Ihr Projekt
Sobald Ihr Linefollower erfolgreich funktioniert, gibt es zahlreiche Möglichkeiten, ihn zu erweitern und zu verbessern:
* **PID-Regler erweitern:** Fügen Sie den Integral- (Ki) und Differential-Anteil (Kd) zu Ihrem Regler hinzu, um die Leistung zu verbessern und das Übersteuern zu reduzieren.
* **Benutzeroberfläche:** Fügen Sie einen kleinen OLED-Bildschirm hinzu, um Sensorwerte oder den aktuellen Status anzuzeigen.
* **Bluetooth-Steuerung:** Verbinden Sie ein Bluetooth-Modul (z.B. HC-05) mit dem Pico, um den Roboter drahtlos von Ihrem Smartphone aus zu steuern oder Parameter zu ändern.
* **Hinderniserkennung:** Integrieren Sie einen Ultraschall-Abstandssensor (HC-SR04), um Hindernisse zu erkennen und diesen auszuweichen.
* **Labyrinth-Löser:** Implementieren Sie Algorithmen, um den Roboter nicht nur einer Linie folgen zu lassen, sondern auch Abzweigungen zu erkennen und den Weg durch ein Labyrinth zu finden.
### Fazit
Der Bau eines smarten Linefollower-Roboters mit dem Raspberry Pi Pico ist ein fantastisches erstes Projekt in der Robotik. Sie haben gelernt, wie man Hardware anschließt, Software programmiert und ein System zum autonomen Verhalten bringt. Dies ist nur der Anfang Ihrer Reise in die Welt der Maker und DIY-Roboter. Nehmen Sie das Wissen, das Sie hier gesammelt haben, und wenden Sie es auf Ihre nächsten, noch komplexeren Projekte an. Viel Erfolg und vor allem: Haben Sie Spaß beim Experimentieren!