Arduino Roboterauto bauen: Bluetooth-Auto Schritt für Schritt

Ein Arduino-Auto zu bauen ist eine der schönsten Möglichkeiten, Elektronik und Programmieren in einem einzigen Projekt zu lernen. Mit zwei Getriebemotoren, einem L298N-Motortreiber, zwei 18650-Akkus, einem HC-05-Bluetooth-Modul und einem Arduino Uno baust du an einem Wochenende ein Roboterauto, das du mit dem Handy steuerst. Dabei erlebst du selbst, warum Motoren nicht direkt an den Arduino gehören, warum die Wahl des Akkus so wichtig ist und wie ein paar Zeilen Code ein echtes Fahrzeug bewegen.

In dieser Anleitung bauen wir gemeinsam ein 2WD-Roboterauto (zwei Motoren) von Anfang bis Ende: Teileliste und Kostenpunkte, Montage des Chassis, Verkabelungstabellen, Code für vorwärts, rückwärts und Kurven sowie Bluetooth-Steuerung per Handy. Die zwei Probleme, an denen Einsteiger am häufigsten hängen bleiben, nämlich dass das Auto nicht geradeaus fährt und dass der Arduino beim Anlaufen der Motoren neu startet, bekommen jeweils einen eigenen Abschnitt mit konkreten Lösungen. In den letzten Abschnitten erfährst du, wie du dasselbe Auto mit einem ESP32 oder einem Raspberry Pi Pico steuerst und es zu einem Roboter erweiterst, der Hindernissen ausweicht oder einer Linie folgt.

Wie funktioniert ein Arduino-Roboterauto?

Ein Roboterauto lässt sich in vier Teile gliedern. Der Arduino ist das Gehirn: Er liest den Befehl vom Handy und entscheidet, welcher Motor in welche Richtung und wie schnell dreht. Der L298N-Motortreiber ist der Muskel: Er wandelt die schwachen 5-V-Signale des Arduino in den hohen Strom um, den die Motoren brauchen. Die Getriebemotoren drehen die Räder, und der Akkupack versorgt alles mit Energie. Diese Autos haben keine Lenkung; sie lenken, indem sich die beiden Räder unterschiedlich schnell oder in unterschiedliche Richtungen drehen. Das nennt man Differentialantrieb: Dreht das linke Rad vorwärts und das rechte rückwärts, dreht sich das Auto auf der Stelle nach rechts. Eine kleine, frei drehbare Lenkrolle vorne oder hinten hält das Fahrzeug im Gleichgewicht.

Die wichtigste Zeile der Tabelle ist der Blockierstrom: Wenn ein Rad gegen ein Hindernis drückt oder das Auto anfährt, zieht jeder Motor kurzzeitig mehr als 1 Ampere. Ein Arduino-Pin liefert dagegen höchstens 20–40 mA, deshalb werden Motoren immer über einen Treiber angeschlossen. Der L298N verliert dabei etwa 1,5–2,5 V; mit einem 7,4-V-Akkupack bleiben für die Motoren 5–6 V übrig, genau der ideale Bereich für TT-Motoren. Den inneren Aufbau des Treibers und das Prinzip der H-Brücke erklären wir ausführlich in Gleichstrommotor mit dem L298N steuern.

Teileliste

Die meisten Chassis-Bausätze enthalten auch einen Batteriehalter für 4 AA-Zellen; wie du gleich sehen wirst, ist dieser zusammen mit dem L298N zu schwach, deshalb stehen 18650-Akkus auf der Liste. Der HC-06 ist der einfachere Bruder des HC-05, der nur als Slave arbeitet, und reicht für die Steuerung eines Autos per Handy völlig aus. Die geschlitzten Kunststoffscheiben im Bausatz sind Encoderscheiben für einen Drehzahlsensor, mit dem du das Auto später exakt geradeaus fahren lassen kannst; wirf sie nicht weg, sondern leg sie vorerst beiseite.

Kosten: Wohin fließt das Budget?

Die Preise ändern sich je nach Händler und Wechselkurs ständig, deshalb nennen wir keine Zahlen; stattdessen zeigen wir, welche Posten das Budget ausmachen und wo du sparen kannst. Die Faustregel lautet: Elektronikmodule (L298N, HC-05, Widerstände) sind günstig, der Großteil des Budgets geht in das Board, den Chassis-Bausatz und vor allem in Akkus und Ladegerät. Beim Akku solltest du zuletzt sparen: Gute 18650-Zellen lassen sich hunderte Male laden und in jedem weiteren Roboterprojekt wiederverwenden.

2WD oder 4WD?

Für dein erstes Auto empfehlen wir 2WD: Es ist günstiger, braucht weniger Strom, dreht leicht auf der Stelle und eignet sich besser für Folgeprojekte wie einen Linienfolger. Baust du ein 4WD-Auto, schließe die zwei Motoren jeder Seite parallel an dieselben OUT-Klemmen an und prüfe, dass beide in dieselbe Richtung drehen. Ein L298N-Kanal trägt dann den Strom von zwei Motoren; im normalen Fahrbetrieb ist das kein Problem, aber wenn die Räder blockieren, kann die Grenze von 2 A pro Kanal überschritten werden und der Überhitzungsschutz des Treibers schaltet die Motoren ab.

Stromversorgung: Warum zwei 18650-Akkus?

Die meisten Probleme mit Roboterautos kommen vom falschen Akku. Die richtige Quelle muss zwei Bedingungen gleichzeitig erfüllen: Sie muss den Motoren nach dem Verlust im L298N noch genug Spannung lassen, und sie darf nicht einbrechen, wenn die Motoren beim Anfahren mehrere Ampere ziehen. Zwei 18650-Li-Ionen-Zellen in Reihe (2S) liefern voll geladen 8,4 V und im Mittel 7,4 V und schaffen problemlos mehrere Ampere. Der Arduino Uno empfiehlt für seinen VIN-Eingang 7–12 V, also kann derselbe Pack sowohl die Motoren als auch den Arduino versorgen. Mit 2500-mAh-Zellen fährt ein 2WD-Auto, das beim Fahren mit Motoren und Platinen im Schnitt 0,8 A zieht, theoretisch etwa 3 Stunden; da du den Akku nie ganz leer fährst, sind 2–2,5 Stunden realistischer. Mit deinen eigenen Werten rechnest du im Tool Akkulaufzeit.

Statt zu raten, wie voll der Akku noch ist, kannst du es messen. Verbinde den Pluspol des Akkus (nach dem Schalter) über einen Spannungsteiler aus zwei 10-kΩ-Widerständen mit A0: Ein 8,4-V-Pack erscheint an A0 als 4,2 V und bleibt unter der 5-V-Messgrenze des Arduino. Der Teiler zieht nur etwa 0,4 mA und beeinflusst die Laufzeit nicht.

1// Pil + (anahtardan sonra) → 10 kΩ → A0 → 10 kΩ → GND / battery + (after the switch) → 10 kΩ → A0 → 10 kΩ → GND
2const float DIVIDER = 2.0;   // iki eşit direnç gerilimi yarıya böler / two equal resistors halve the voltage
3
4void setup() {
5  Serial.begin(9600);
6}
7
8void loop() {
9  float v = analogRead(A0) * 5.0 / 1023.0 * DIVIDER;
10  Serial.print(F("Pil / Battery: "));
11  Serial.print(v, 2);
12  Serial.println(F(" V"));
13  if (v < 6.6) Serial.println(F("Sarj et / Charge now"));   // hücre başına 3,3 V / 3.3 V per cell
14  delay(1000);
15}

Montage Schritt für Schritt

1. Zieh die Schutzfolie von den Acrylteilen ab. Wenn die Motoren ohne Kabel geliefert wurden, löte an jeden Motor zwei Kabel und sichere die Lötstellen mit Heißkleber; ein durch Vibration abgerissenes Motorkabel ist der häufigste Defekt.
2. Befestige die Motoren mit den T-förmigen Acrylhaltern und den langen M3-Schrauben aus dem Bausatz an der Unterseite des Chassis. Die beiden Motorwellen müssen fluchten, und die Kabelanschlüsse der Motoren sollten nach innen zeigen.
3. Wenn du die Encoderscheiben nutzen willst, steck sie jetzt auf die Innenseite der Motorwelle; mit montierten Rädern ist das schwierig.
4. Montiere die Lenkrolle mit Abstandsbolzen mittig am anderen Ende des Chassis. Wähle die Bolzenhöhe so, dass das Chassis parallel zum Boden steht.
5. Schieb die Räder passend zur D-förmigen Welle ganz auf; ein lockeres Rad lässt das Auto ständig abdriften.
6. Befestige den Batteriehalter mit doppelseitigem Klebeband oder Klettband so, dass sein Gewicht nahe an der Radachse liegt. Liegt das meiste Gewicht auf der Lenkrolle, rutschen die Antriebsräder durch.
7. Montiere Arduino und L298N mit Kunststoff-Abstandsbolzen auf dem oberen Deck. Der USB-Anschluss des Arduino muss gut erreichbar sein und der Kühlkörper des L298N frei an der Luft liegen; achte darauf, dass Metallschrauben keine Lötstellen unter den Platinen berühren.
8. Schalte den Schalter in Reihe mit dem Pluskabel des Akkus; so kannst du das Auto ein- und ausschalten, ohne die Zellen herauszunehmen.
9. Verdrille die beiden Kabel jedes Motors auf dem Weg zum L298N, halte alle Kabel kurz und bündele sie mit Kabelbindern. Prüfe vor dem Einsetzen der Zellen mit einem Multimeter, dass zwischen den Akkuanschlüssen kein Kurzschluss besteht.

Schaltplan und Verkabelung

Denk dir die Verkabelung in zwei Teilen: die Leistungsseite (Akku, Schalter, L298N, Motoren) und die Signalseite (die dünnen Kabel vom Arduino zum L298N und zum HC-05). Zieh die kleinen Jumper von den ENA- und ENB-Pins des L298N ab; diese Pins verbinden wir mit den PWM-Ausgängen des Arduino, um die Geschwindigkeit per Code einzustellen. Der 5V-Jumper des L298N bleibt dagegen gesteckt: Da der Pack unter 12 V liegt, versorgt der eigene Spannungsregler der Platine die Logik des Treibers.

D5 und D6 haben wir bewusst als Tempo-Pins gewählt. Auf dem Uno schaltet die Servo-Bibliothek die PWM an den Pins 9 und 10 ab, die Funktion tone() die an den Pins 3 und 11. Liegen ENA und ENB auf 5 und 6, funktioniert deine Geschwindigkeitsregelung auch dann noch, wenn du später einen Servo oder einen Summer ergänzt. D2 und D3 bleiben für Encoder frei, weil sie Interrupts unterstützen. Die Pinbelegung deines Boards siehst du im Tool Pinout.

Erster Sketch: vorwärts, rückwärts, links und rechts

Bevor es an Bluetooth geht, testen wir Motoren und Verkabelung für sich allein. Das Herz des Codes ist die Funktion drive(links, rechts): Sie nimmt die Geschwindigkeit jedes Motors getrennt von -255 bis 255 entgegen; ein positiver Wert heißt vorwärts, ein negativer rückwärts, null heißt Stopp. Wie aus dem Geschwindigkeitswert eine Spannung wird, erklären wir in Was ist PWM?. Stell das Auto vor dem Hochladen so auf eine Schachtel, dass die Räder frei drehen; die 3 Sekunden Wartezeit in setup() geben dir dafür Zeit.

1// Sol motor / left motor: ENA=5, IN1=7, IN2=8 — Sağ motor / right motor: ENB=6, IN3=9, IN4=4
2const int ENA = 5, IN1 = 7, IN2 = 8;
3const int ENB = 6, IN3 = 9, IN4 = 4;
4
5const int SPEED = 180;   // temel hız 0-255 / base speed 0-255
6const int TRIM = 0;      // % düzeltme: + sol, - sağ motoru yavaşlatır / % trim: + slows left, - slows right
7
8void drive(int left, int right) {               // her biri -255 … 255 / each -255 … 255
9  if (TRIM > 0) left = left * (100 - TRIM) / 100;
10  if (TRIM < 0) right = right * (100 + TRIM) / 100;
11  digitalWrite(IN1, left > 0);  digitalWrite(IN2, left < 0);
12  digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
13  analogWrite(ENA, abs(left));
14  analogWrite(ENB, abs(right));
15}
16
17void forward()   { drive(SPEED, SPEED); }
18void backward()  { drive(-SPEED, -SPEED); }
19void turnLeft()  { drive(-SPEED, SPEED); }     // yerinde sola / spin left in place
20void turnRight() { drive(SPEED, -SPEED); }     // yerinde sağa / spin right in place
21void stopCar()   { drive(0, 0); }
22
23void setup() {
24  int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
25  for (int p : pins) pinMode(p, OUTPUT);
26  stopCar();
27  delay(3000);             // tekerlekleri kaldırmak için zaman / time to lift the wheels
28}
29
30void loop() {
31  forward();   delay(1500);
32  stopCar();   delay(500);
33  backward();  delay(1500);
34  stopCar();   delay(500);
35  turnLeft();  delay(600);
36  stopCar();   delay(500);
37  turnRight(); delay(600);
38  stopCar();   delay(2000);
39}

Mit den Rädern in der Luft sollte das Auto nacheinander vorwärts, rückwärts, nach links und nach rechts fahren. Dreht ein Rad falsch herum, änderst du nicht den Code, sondern tauschst die beiden Kabel dieses Motors an der OUT-Klemme des L298N. Drehen beide Räder falsch, tausch die Kabel beider Motoren. Brummen die Motoren nur, ohne zu drehen, ist der Wert SPEED zu niedrig: Die meisten TT-Motoren brauchen einen PWM-Wert von mindestens etwa 80–120, um anzulaufen, und diese Schwelle steigt, je leerer der Akku wird.

Bluetooth-Steuerung per Handy (HC-05)

Der HC-05 arbeitet wie ein kabelloses serielles Kabel zwischen Handy und Arduino: Die App auf dem Handy sendet einen Buchstaben, der Arduino liest ihn und führt die passende Bewegung aus. Die meisten Steuer-Apps, die du im Play Store unter "Bluetooth RC Car" oder "Bluetooth RC Controller" findest, senden F für vorwärts, B für rückwärts, L für links, R für rechts und beim Loslassen einer Taste S für Stopp; manche nutzen außerdem G, I, H und J für die Diagonalen sowie 0–9 und q für die Geschwindigkeit. Pins, LED-Signale und AT-Befehle des Moduls findest du in HC-05 Bluetooth-Modul.

1. Beim Hochladen des folgenden Sketches kann der Schalter des Autos aus bleiben; Arduino und HC-05 werden über USB versorgt. Blinkt die LED des HC-05 schnell, wartet das Modul auf eine Verbindung.
2. Such den HC-05 in den Bluetooth-Einstellungen deines Android-Handys und kopple ihn mit der PIN 1234 (notfalls 0000).
3. Öffne die Steuer-App, erteile die Berechtigungen für Bluetooth und Geräte in der Nähe und wähle den HC-05 aus der Geräteliste. Nach dem Verbinden blinkt die LED des Moduls alle zwei Sekunden zweimal kurz.
4. Lass den Arduino per USB verbunden, öffne den seriellen Monitor mit 9600 Baud und drück die Tasten in der App. Der Buchstabe jeder Taste erscheint auf dem Bildschirm; sendet deine App andere Buchstaben, passe die case-Zeilen im Code an.
5. Zieh das USB-Kabel ab, schalte den Schalter ein, stell das Auto auf den Boden und fahr los.

1#include <SoftwareSerial.h>
2
3SoftwareSerial bt(10, 11);               // RX, TX → HC-05 TXD, RXD (RXD bölücüyle / RXD via divider)
4
5const int ENA = 5, IN1 = 7, IN2 = 8;     // sol motor / left motor
6const int ENB = 6, IN3 = 9, IN4 = 4;     // sağ motor / right motor
7const int TRIM = 0;                      // % düzeltme / % trim
8const unsigned long TIMEOUT = 600;       // ms; 0 = kapalı / 0 = disabled
9
10int speed = 200;                         // 0-255
11unsigned long lastCmd = 0;
12
13void drive(int left, int right) {
14  if (TRIM > 0) left = left * (100 - TRIM) / 100;
15  if (TRIM < 0) right = right * (100 + TRIM) / 100;
16  digitalWrite(IN1, left > 0);  digitalWrite(IN2, left < 0);
17  digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
18  analogWrite(ENA, abs(left));
19  analogWrite(ENB, abs(right));
20}
21
22void setup() {
23  int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
24  for (int p : pins) pinMode(p, OUTPUT);
25  drive(0, 0);
26  Serial.begin(9600);                    // gelen harfleri görmek için / to see incoming letters
27  bt.begin(9600);                        // HC-05 veri modu hızı / HC-05 data mode baud rate
28}
29
30void loop() {
31  if (bt.available()) {
32    char c = bt.read();
33    Serial.println(c);
34    lastCmd = millis();
35    int half = speed / 2;
36    switch (c) {
37      case 'F': drive(speed, speed);   break;   // ileri / forward
38      case 'B': drive(-speed, -speed); break;   // geri / backward
39      case 'L': drive(-speed, speed);  break;   // yerinde sola / spin left
40      case 'R': drive(speed, -speed);  break;   // yerinde sağa / spin right
41      case 'G': drive(half, speed);    break;   // ileri-sol / forward-left
42      case 'I': drive(speed, half);    break;   // ileri-sağ / forward-right
43      case 'H': drive(-half, -speed);  break;   // geri-sol / back-left
44      case 'J': drive(-speed, -half);  break;   // geri-sağ / back-right
45      case 'S': drive(0, 0);           break;   // dur / stop
46      case 'q': speed = 255;           break;   // tam hız / full speed
47      default:
48        if (c >= '0' && c <= '9') speed = map(c - '0', 0, 9, 100, 240);   // hız kademesi / speed level
49    }
50  }
51  if (TIMEOUT > 0 && millis() - lastCmd > TIMEOUT) drive(0, 0);   // komut yoksa dur / no command: stop
52}

Das TIMEOUT im Code ist eine Sicherheitsfunktion: Solche Apps senden denselben Buchstaben immer wieder, solange du die Taste hältst; kommt 600 ms lang kein Buchstabe an, nimmt der Code an, dass die Verbindung abgebrochen ist, und stoppt das Auto. So fährt das Auto nicht weiter auf die Wand zu, wenn das Handy außer Reichweite gerät oder die App sich schließt. Sendet deine App den Buchstaben pro Tastendruck nur einmal, bleibt das Auto nach 600 ms stehen; setze TIMEOUT dann auf 0, um die Funktion abzuschalten. Außerdem haben wir in loop() nirgends delay() verwendet; lange Wartezeiten verzögern die Befehle, warum, liest du in millis() statt delay().

Das Auto fährt nicht geradeaus: Ursachen und Lösung

Wenn das Auto langsam zur Seite driftet, obwohl beide Motoren für "vorwärts" denselben PWM-Wert bekommen, keine Sorge: Das ist das häufigste Problem bei Roboterautos. Billige Getriebemotoren drehen selbst bei gleicher Spannung unterschiedlich schnell; Unterschiede bei Getriebereibung, Bürsten und Magneten machen jeden Motor ein wenig anders. Kommen ein lockeres Rad, eine ständig umschwenkende Lenkrolle oder einseitig verteiltes Gewicht hinzu, sind 20–30 cm Abweichung auf 2 Metern ganz normal. Beseitige zuerst die mechanischen Ursachen und gleiche den Rest per Software aus.

Sind die mechanischen Probleme behoben, folgt der Feinabgleich per Software. Die Konstante TRIM im Code bremst den schnelleren Motor prozentual: Ein positiver Wert bremst den linken, ein negativer den rechten Motor. So gleichst du ab:

1. Lade die Zellen voll; ein Abgleich mit vollem Akku liefert gleichbleibende Ergebnisse.
2. Klebe einen geraden, 2 Meter langen Klebestreifen auf den Boden und stell das Auto an seinen Anfang, in Richtung des Streifens.
3. Lass in loop() des ersten Sketches nur forward() und 3 Sekunden Wartezeit stehen und lass das Auto fahren.
4. Driftet das Auto nach rechts, ist der linke Motor schneller: Erhöhe TRIM um 3; driftet es nach links, verringere TRIM um 3.
5. Wiederhole das, bis die Abweichung auf 2 Metern nur noch wenige Zentimeter beträgt, und übernimm denselben TRIM-Wert in den Bluetooth-Sketch.
6. Gleiche bei der Geschwindigkeit ab, die du am häufigsten nutzt; der Unterschied zwischen den Motoren ändert sich mit dem Tempo leicht.

Die nächste Stufe für perfekten Geradeauslauf und Streckenmessung ist der Encoder. Du steckst die Scheiben mit 20 Schlitzen aus dem Bausatz auf die Motorwellen und zählst jeden Schlitz mit einem Gabellichtschranken-Drehzahlsensor auf Basis des LM393. Verbinde die Sensorausgänge mit den interruptfähigen Pins D2 und D3 und vergleiche die Impulszahlen beider Räder: Liegt die linke Seite vorn, bremst du den linken Motor etwas. Diese einfache Proportionalregelung (P-Regler) hält das Auto unabhängig von Akkustand und Untergrund auf Kurs. Ein 65-mm-Rad legt pro Umdrehung etwa 20,4 cm zurück, jeder Impuls entspricht also rund 1 cm Weg. Wie Interrupts funktionieren, erklären wir in Arduino Interrupts.

Der Arduino startet neu, wenn die Motoren anlaufen

Startet der Arduino neu oder verliert der HC-05 die Verbindung (die LED blinkt wieder schnell), wenn das Auto anfährt, die Richtung wechselt oder gegen ein Hindernis stößt, liegt das Problem fast immer bei der Stromversorgung. Beim Anfahren können zwei Motoren zusammen 2–3 A ziehen; ein schwacher Akku schafft das nicht und seine Spannung bricht kurz ein. Der Prozessor des Uno setzt sich zur Sicherheit zurück, wenn seine Versorgung unter 2,7 V fällt (Brown-out). Dazu kommen elektrische Störungen der Motorbürsten und der Spannungsabfall in dünnen Kabeln. Hier die Lösungen, beginnend mit der wirksamsten:

• Akku wechseln: Nimm zwei geladene 18650-Zellen statt einer 9-V-Blockbatterie oder müder AA-Zellen; damit sind die meisten Probleme erledigt.
• Richtiger Versorgungsweg: Versorge den Arduino über VIN aus dem Akku; schließe den 5V-Ausgang des L298N nicht an VIN an.
• Motorkondensatoren: Löte einen 100-nF-Keramikkondensator zwischen die beiden Anschlüsse jedes Motors; er unterdrückt das Bürstenfeuer direkt an der Quelle.
• Pufferkondensator: Schließe einen 470–1000-µF-Elko an die 12V- und GND-Klemmen des L298N an (Plus an 12V). Er deckt den kurzen Strombedarf beim Anfahren.
• Sanftanlauf: Erhöhe die Geschwindigkeit wie unten schrittweise, statt sofort auf 255 zu springen; der Stromstoß wird kleiner.
• Erst stoppen, dann umkehren: Direkt von vorwärts auf rückwärts zu schalten treibt den Motorstrom auf den Höchstwert; halte vor jedem Richtungswechsel 100–200 ms an.
• Dicke, kurze Stromkabel: Verwende zwischen Akku und L298N keine Jumperkabel und kein Breadboard; nimm Kabel mit mindestens 0,5 mm² und Schraubklemmen.
• Getrennte Versorgung: Hält das Problem an, versorge den Arduino aus einer Powerbank und die Motoren aus dem Akku und verbinde die beiden GNDs.

1// Yumuşak kalkış: ilk koddaki drive() ile kullan / soft start: use with drive() from the first sketch
2void rampTo(int target) {
3  for (int s = 60; s < target; s += 20) {
4    drive(s, s);
5    delay(15);              // yaklaşık 10 adımda tam hız / full speed in about 10 steps
6  }
7  drive(target, target);
8}
9
10// Kullanım: forward() yerine rampTo(SPEED) / usage: rampTo(SPEED) instead of forward()

Roboterauto mit ESP32 und Raspberry Pi Pico

Der ESP32 hat klassisches Bluetooth eingebaut, deshalb brauchst du keinen HC-05: Die Bibliothek BluetoothSerial baut dieselbe serielle Verbindung zum Handy auf, und die Steuer-Apps von oben funktionieren unverändert. Die Eingänge des L298N werten alles über etwa 2,3 V als HIGH, daher reichen die 3,3-V-Signale des ESP32. Versorge das ESP32-Board über den 5V-Ausgang des L298N am 5V-Pin (VIN) des Boards; schließe den Akku nicht direkt an diesen Pin an. Dieser Code lässt sich für ESP32-S3 und ESP32-C3 nicht kompilieren, weil diese nur BLE haben.

1#include "BluetoothSerial.h"
2
3BluetoothSerial bt;
4
5const int ENA = 25, IN1 = 27, IN2 = 33;   // sol motor / left motor
6const int ENB = 26, IN3 = 32, IN4 = 4;    // sağ motor / right motor
7
8int speed = 200;                          // 0-255
9unsigned long lastCmd = 0;
10
11void drive(int left, int right) {
12  digitalWrite(IN1, left > 0);  digitalWrite(IN2, left < 0);
13  digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
14  analogWrite(ENA, abs(left));
15  analogWrite(ENB, abs(right));
16}
17
18void setup() {
19  int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
20  for (int p : pins) pinMode(p, OUTPUT);
21  drive(0, 0);
22  bt.begin("BlueGrays-Car");              // telefonda görünecek ad / name shown on the phone
23}
24
25void loop() {
26  if (bt.available()) {
27    char c = bt.read();
28    lastCmd = millis();
29    switch (c) {
30      case 'F': drive(speed, speed);   break;   // ileri / forward
31      case 'B': drive(-speed, -speed); break;   // geri / backward
32      case 'L': drive(-speed, speed);  break;   // yerinde sola / spin left
33      case 'R': drive(speed, -speed);  break;   // yerinde sağa / spin right
34      case 'S': drive(0, 0);           break;   // dur / stop
35      case 'q': speed = 255;           break;   // tam hız / full speed
36      default:
37        if (c >= '0' && c <= '9') speed = map(c - '0', 0, 9, 100, 240);
38    }
39  }
40  if (millis() - lastCmd > 600) drive(0, 0);    // komut yoksa dur / no command: stop
41}

Der normale Raspberry Pi Pico hat kein Bluetooth, also schließt du den HC-05 an die UART0-Pins an. Da der Pico mit 3,3 V arbeitet, ist diesmal kein Spannungsteiler nötig. Versorge den Pico über den VSYS-Pin und den HC-05 direkt aus dem 5V-Ausgang des L298N; im Akkubetrieb ohne USB liegt am VBUS-Pin keine Spannung an. Im Pico-Code wird die Geschwindigkeit in Prozent von -100 bis 100 angegeben:

1from machine import Pin, PWM, UART
2import time
3
4bt = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))   # GP0 → HC-05 RXD, GP1 ← HC-05 TXD
5
6ena = PWM(Pin(15)); ena.freq(1000)                  # sol motor hızı / left motor speed
7enb = PWM(Pin(10)); enb.freq(1000)                  # sağ motor hızı / right motor speed
8in1, in2 = Pin(14, Pin.OUT), Pin(13, Pin.OUT)
9in3, in4 = Pin(12, Pin.OUT), Pin(11, Pin.OUT)
10
11def drive(left, right):                             # -100 … 100 (%)
12    in1.value(left > 0); in2.value(left < 0)
13    in3.value(right > 0); in4.value(right < 0)
14    ena.duty_u16(int(abs(left) * 655))
15    enb.duty_u16(int(abs(right) * 655))
16
17speed = 80
18last = time.ticks_ms()
19drive(0, 0)
20
21while True:
22    if bt.any():
23        c = bt.read(1)
24        last = time.ticks_ms()
25        if c == b'F':   drive(speed, speed)          # ileri / forward
26        elif c == b'B': drive(-speed, -speed)        # geri / backward
27        elif c == b'L': drive(-speed, speed)         # yerinde sola / spin left
28        elif c == b'R': drive(speed, -speed)         # yerinde sağa / spin right
29        elif c == b'S': drive(0, 0)                  # dur / stop
30        elif c == b'q': speed = 100                  # tam hız / full speed
31        elif c and 48 <= c[0] <= 57:                 # '0'…'9' hız kademesi / speed level
32            speed = 40 + (c[0] - 48) * 6
33    if time.ticks_diff(time.ticks_ms(), last) > 600:
34        drive(0, 0)                                  # komut yoksa dur / no command: stop

Nächste Schritte: Rüste dein Auto auf

• Hindernisvermeidender Roboter: Ergänze vorne einen HC-SR04-Abstandssensor und einen Servomotor, der ihn nach links und rechts schwenkt; Details in der Anleitung Hindernisvermeidender Roboter.
• Linienfolger: Bau 2–3 TCRT5000-Infrarotsensoren unter die Front und folge einer schwarzen Linie auf dem Boden; siehe Linienfolger-Roboter.
• Joystick-Fernbedienung: Bau mit einem zweiten Arduino, einem Joystick-Modul und einem nRF24L01 eine echte Fernbedienung ohne Handy.
• Infrarot-Fernbedienung: Fahr mit den Tasten deiner TV-Fernbedienung; ordne die Codes aus IR-Empfänger und Fernbedienung den Fahrbefehlen zu.
• Fahren per WLAN: Lass einen ESP32 eine Steuerseite bereitstellen, die sich im Browser deines Handys öffnet; die Grundlagen stehen in ESP32 Webserver und WebSocket.
• Encoder und Strecke: Fahr mit Drehzahlsensoren genau 1 Meter und dreh exakt 90 Grad; das ist die Grundlage für Labyrinth-Roboter.
• Roboterarm: Setz einen kleinen Roboterarm mit Servos auf das Auto und transportiere Gegenstände.

Häufige Fehler und Lösungen

• Kein Motor dreht sich: Die GNDs sind nicht verbunden, der Schalter ist aus, die ENA- und ENB-Jumper wurden entfernt, aber die Pins nicht angeschlossen, oder der Akku ist leer.
• Die LED des L298N leuchtet, aber die Motoren brummen nur: Der PWM-Wert liegt unter der Anlaufschwelle oder die Akkuspannung ist zu niedrig; erhöhe das Tempo und lade den Akku.
• Der Sketch lässt sich nicht hochladen: Vielleicht sind Port oder Board falsch gewählt; hast du den HC-05 an die Pins 0 und 1 angeschlossen, trenne ihn beim Hochladen. Weitere Ursachen in Arduino Sketch lässt sich nicht hochladen.
• Das Handy sieht den HC-05, verbindet sich aber nicht: Das Modul ist mit einem anderen Handy verbunden, der App fehlt die Berechtigung "Geräte in der Nähe" oder die Kopplungs-PIN ist falsch.
• Das Auto reagiert verzögert: In loop() steckt ein delay() oder es wird zu viel auf den seriellen Monitor geschrieben; erledige Wartezeiten mit millis().
• Der Kühlkörper des L298N wird sehr heiß: Die Räder klemmen oder bei 4WD ist der Strom pro Kanal zu hoch; prüfe die mechanische Reibung.
• Das Auto zuckt beim Einschalten kurz: Beim Start sind die Pins für einen Moment undefiniert; setze die Pins in den ersten Zeilen von setup() als Ausgänge und rufe drive(0, 0) auf.

Ein Arduino-Roboterauto ist ein großartiger Einstieg, der Motorsteuerung, Energieversorgung, Funkkommunikation und Fehlersuche in einem Projekt vermittelt. Am Ende hast du ein Fahrgestell, das mit jedem neuen Sensor ein bisschen schlauer wird. In der BlueGrays-App findest du die Projekte Bluetooth-gesteuertes Auto mit L298N, hindernisvermeidender Roboter und Schwarz-Weiß-Untergrunderkennung mit TCRT5000 Schritt für Schritt mit Schaltplänen und Code.