Arduino Bluetooth Projekte: 15 Ideen mit HC-05, HM-10 und ESP32
15 Arduino Bluetooth Projekte: LED und Relais per Handy, Bluetooth-Auto, Sprachsteuerung, Laufschrift, BLE-Sensor; HC-05, HM-10, ESP32 und Apps im Vergleich.
Arduino Bluetooth Projekte machen dein Handy zur Fernbedienung, die drahtlos Befehle an einen Arduino schickt, oder zeigen dir die Messwerte des Arduino auf dem Handy: eine LED oder ein Relais schalten, ein Roboterauto fahren, eine Nachricht auf eine LED-Laufschrift schreiben oder einen Sensorwert in der Hosentasche sehen. Internet oder Router sind nicht nötig; Handy und Board sprechen auf wenigen Metern direkt miteinander. Deshalb ist Bluetooth meist die erste Funktechnik, die man noch vor WLAN lernt, und eines der beliebtesten Themen für Schulprojekte.
Wählst du aber das falsche Modul oder die falsche App, steckt das Projekt fest, bevor es beginnt: Ein iPhone sieht ein HC-05 nie, manche Apps sprechen nur mit BLE-Modulen, und neuere ESP32-Chips haben kein klassisches Bluetooth. In diesem Ratgeber vergleichen wir zuerst HC-05, HC-06, HM-10 und ESP32, dann Apps wie App Inventor, Serial Bluetooth Terminal und Dabble, und danach gehen wir 15 Projekte von leicht bis schwer durch. Dazu gibt es zwei fertige Sketche: LED-, Relais- und Helligkeitssteuerung mit HC-05 und LED-Steuerung per Handy mit ESP32 BLE. Nutzt du das Modul zum ersten Mal, starte mit dem Artikel zum HC-05 Bluetooth-Modul.

Welches Bluetooth-Modul? HC-05, HC-06, HM-10 und ESP32
Alle Bluetooth-Module scheinen dasselbe zu tun, nutzen aber zwei verschiedene Techniken. Klassisches Bluetooth (SPP) verhält sich wie eine serielle Schnittstelle: Jedes Zeichen, das du vom Handy schickst, liest der Arduino mit Serial.read(), der Code ist sehr einfach. HC-05 und HC-06 gehören dazu; mit Android klappen sie problemlos, da Apple dieses Profil auf dem iPhone aber nicht für Apps freigibt, sind sie unter iOS unsichtbar. Bluetooth Low Energy (BLE) überträgt Daten über eine kleine Tabelle aus Services und Characteristics, braucht sehr wenig Energie und funktioniert mit Android und iPhone. Das HM-10 ist ein BLE-Modul, das wie eine serielle Schnittstelle am Arduino hängt; der ESP32 hat klassisches Bluetooth und BLE eingebaut. Neuere Chips wie ESP32-S3 und ESP32-C3 haben nur noch BLE.
| Modul | Bluetooth | Rolle | iPhone | Arduino-Seite | Ideales Projekt |
|---|---|---|---|---|---|
| HC-05 | 2.0 klassisch (SPP) | Master und Slave | Funktioniert nicht | SoftwareSerial, 9600 Baud | Android-Fernbedienung, Verbindung zweier Arduinos |
| HC-06 | 2.0 klassisch (SPP) | Nur Slave | Funktioniert nicht | SoftwareSerial, 9600 Baud | Einfachste Android-Fernbedienung |
| HM-10 | 4.0 BLE | Master und Slave | Funktioniert | SoftwareSerial, 9600 Baud | Projekte, die mit dem iPhone laufen müssen |
| ESP32 (klassisch) | Klassisch + BLE eingebaut | Beides | Über BLE | BluetoothSerial oder BLEDevice | Projekte ohne Modul, BLE-Sensor, Tastatur |
| ESP32-S3 / C3 | Nur BLE | Beides | Funktioniert | BLEDevice oder NimBLE | Stromsparende BLE-Geräte |
Welche Handy-App? Kompatibilitätstabelle für Apps und Module
Die Handyseite ist genauso wichtig wie die Arduino-Seite. Zum Testen ohne Code nimmst du eine fertige Terminal-App, für eine Fernbedienung mit Tasten fertige Panels wie Dabble und für dein eigenes Design App Inventor. Die Regel ist einfach: Mit klassischen Modulen (HC-05, HC-06) sprechen nur Android-Apps, mit BLE-Modulen (HM-10, ESP32 BLE) sowohl Android- als auch iPhone-Apps. Die Tabelle zeigt, welche App mit welchem Modul funktioniert.
| App | Handy | Unterstützte Module | Wofür? |
|---|---|---|---|
| Serial Bluetooth Terminal | Android | HC-05, HC-06, HM-10, ESP32 | Befehle senden und Daten lesen; schnelle Tests mit Makrotasten |
| Dabble | Android und iOS | HC-05, HC-06 (Android), HM-10, ESP32 | Fertiges Gamepad, Terminal, Handysensoren; Dabble-Bibliothek auf dem Arduino |
| App Inventor | Android (du baust die App) | Klassische Module; HM-10 und ESP32 mit BLE-Erweiterung | Eigene Tasten, Schieberegler und Sprachbefehle in deiner eigenen App |
| nRF Connect / LightBlue | Android und iOS | BLE (HM-10, ESP32) | BLE-Services ansehen und Werte in Characteristics schreiben |
| Bluetooth Electronics | Android | HC-05, HC-06, HM-10 | Panels mit Tasten, Reglern und Diagrammen per Drag-and-drop |
15 Arduino Bluetooth Projekte in einer Tabelle
| # | Projekt | Board und Modul | Zusätzliche Teile | Handy-App | Niveau |
|---|---|---|---|---|---|
| 1 | LED per Handy ein/aus | Uno + HC-05 | LED, 220 Ω | Serial Bluetooth Terminal | Leicht |
| 2 | Lampe mit Relais schalten | Uno + HC-05 | Relaismodul | Serial Bluetooth Terminal, Dabble | Leicht |
| 3 | RGB-LED-Farbwähler | Uno + HC-05 | RGB-LED, 3 Widerstände | App Inventor | Leicht |
| 4 | Bluetooth-gesteuertes Auto | Uno + HC-05 | L298N, Chassis mit 2 Motoren, Akku | Dabble Gamepad oder RC-Auto-App | Mittel |
| 5 | Sprachsteuerung | Uno + HC-05 | Relais oder LEDs | App Inventor (Spracherkennung) | Mittel |
| 6 | Bluetooth-LED-Laufschrift | Uno + HC-05 | MAX7219 8x32 Matrix | Serial Bluetooth Terminal | Mittel |
| 7 | Servo und Roboterarm per Handy | Uno + HC-05 | SG90-Servos, externe 5 V | Schieberegler in App Inventor | Mittel |
| 8 | Sensordaten aufs Handy | Uno + HC-05 | DHT11 | Bluetooth Electronics, Terminal | Leicht |
| 9 | Bluetooth-Türschloss mit Passwort | Uno + HC-05 | Servo oder Magnetschloss | App Inventor | Mittel |
| 10 | Bluetooth zwischen zwei Arduinos | 2 × Uno + 2 × HC-05 | Taster, LED | Nicht nötig | Mittel |
| 11 | Dabble-Gamepad | Uno + HC-05 oder HM-10 | Motoren oder LEDs | Dabble Gamepad | Leicht |
| 12 | ESP32-BLE-LED-Steuerung | ESP32 | Keine (Onboard-LED) | nRF Connect, LightBlue | Mittel |
| 13 | ESP32-BLE-Sensor | ESP32 | DHT22 | nRF Connect, eigene App | Mittel |
| 14 | ESP32-BLE-Tastatur und Präsentationsfernbedienung | ESP32 | 2–3 Taster | Nicht nötig (der PC sieht eine Tastatur) | Mittel |
| 15 | Auto mit Konsolen-Controller | ESP32 | Motortreiber, Chassis | Nicht nötig (PS4- / Xbox-Controller) | Schwer |
Die ersten beiden Ideen gibt es in der BlueGrays-App auch als fertige Projekte: Das Projekt LED per Bluetooth vom Handy einschalten baut Projekt 1 und das Projekt Bluetooth-gesteuertes Auto mit L298N Projekt 4 Schritt für Schritt mit Schaltplan und Code auf. Die übrigen Punkte sind Projektideen, die du umsetzt, indem du die RGB-LED-, Relais-mit-230-V-Lampe-, Servo- und WS2812B-Projekte der App mit Bluetooth-Befehlen kombinierst; welche Teile und welche Handyseite jedes braucht, steht in der Tabelle.
Erste Projekte mit dem HC-05 (1–3): LED, Relais und Helligkeit
Die ersten drei Projekte laufen mit derselben Schaltung und demselben Code. Wir schließen das HC-05 nicht an die Hardware-Seriellpins 0 und 1 an, sondern per SoftwareSerial an die Pins 10 und 11; so musst du das Modul beim Hochladen nicht abziehen und behältst den seriellen Monitor zur Fehlersuche. Der TX-Pin des Moduls liefert ein 3,3-V-Signal, das der Arduino problemlos liest. In die andere Richtung darf das 5-V-TX-Signal des Arduino nicht direkt an den RX-Pin des Moduls: Ein Spannungsteiler aus 1 kΩ und 2 kΩ senkt 5 V auf etwa 3,3 V.
| Verbindung | Arduino Uno | Hinweis |
|---|---|---|
| HC-05 VCC | 5V | Das Modulboard hat einen Spannungsregler |
| HC-05 GND | GND | Gemeinsame Masse |
| HC-05 TXD | D10 (SoftwareSerial RX) | Direkt verbunden |
| HC-05 RXD | D11 (SoftwareSerial TX) | Über Teiler 1 kΩ (zu D11) + 2 kΩ (zu GND) |
| LED | D13 | Die Onboard-LED liegt am selben Pin |
| Relaismodul IN | D7 | Das Relais läuft mit 5 V |
| PWM-LED | D5 | Mit 220-Ω-Widerstand |
1// Arduino Uno + HC-05/HC-06: telefondan LED, röle ve PWM parlaklık kontrolü
2// Arduino Uno + HC-05/HC-06: control an LED, a relay and PWM brightness from your phone
3// Komutlar / Commands: L1, L0, R1, R0, P0..P255, ? (her komut satır sonuyla / each ends with a newline)
4#include <SoftwareSerial.h>
5
6#define BT_RX_PIN 10 // HC-05 TX buraya / HC-05 TX goes here
7#define BT_TX_PIN 11 // HC-05 RX'e gerilim bölücüyle / to HC-05 RX through a voltage divider
8#define LED_PIN 13
9#define RELAY_PIN 7
10#define PWM_PIN 5 // 220 ohm dirençli LED / LED with a 220 ohm resistor
11
12SoftwareSerial bt(BT_RX_PIN, BT_TX_PIN);
13char line[16];
14byte len = 0;
15int brightness = 0;
16
17void reportState() {
18 bt.print(F("LED=")); bt.print(digitalRead(LED_PIN));
19 bt.print(F(" ROLE=")); bt.print(digitalRead(RELAY_PIN));
20 bt.print(F(" PWM=")); bt.println(brightness);
21}
22
23void runCommand(const char* cmd) {
24 switch (cmd[0]) {
25 case 'L': digitalWrite(LED_PIN, cmd[1] == '1' ? HIGH : LOW); break;
26 case 'R': digitalWrite(RELAY_PIN, cmd[1] == '1' ? HIGH : LOW); break; // aktif LOW modülde tersle / invert for active-LOW modules
27 case 'P':
28 brightness = constrain(atoi(cmd + 1), 0, 255);
29 analogWrite(PWM_PIN, brightness);
30 break;
31 case '?': break;
32 default:
33 bt.println(F("Bilinmeyen komut / Unknown command"));
34 return;
35 }
36 reportState(); // her komuttan sonra durumu telefona yaz / send the state back after each command
37}
38
39void setup() {
40 pinMode(LED_PIN, OUTPUT);
41 pinMode(RELAY_PIN, OUTPUT);
42 pinMode(PWM_PIN, OUTPUT);
43 Serial.begin(9600);
44 bt.begin(9600); // HC-05 ve HC-06 varsayılan hızı / default HC-05 and HC-06 baud rate
45 Serial.println(F("Bluetooth hazir / Bluetooth ready"));
46}
47
48void loop() {
49 while (bt.available()) {
50 char c = bt.read();
51 if (c == '\r') continue;
52 if (c == '\n') { // satır bitti, komutu çalıştır / line complete, run it
53 line[len] = '\0';
54 if (len > 0) runCommand(line);
55 len = 0;
56 } else if (len < sizeof(line) - 1) {
57 line[len++] = toupper(c); // l1 ile L1 aynı / l1 equals L1
58 }
59 }
60}Der Code sammelt ankommende Zeichen in einem Puffer, bis ein Zeilenende (\n) kommt, und führt dann den Befehl aus. So werden mehrstellige Befehle wie P128 am Stück gelesen. Stell in Serial Bluetooth Terminal als Zeilenende "LF" oder "CR+LF" ein; das Zeichen \r ignoriert der Code ohnehin. Nach jedem Befehl schreibt der Arduino den aktuellen Zustand (etwa LED=1 ROLE=0 PWM=128) zurück aufs Handy, sodass du siehst, dass der Befehl wirklich ankam. Die Zeile mit toupper() akzeptiert auch klein geschriebene Befehle. Ist dein Relaismodul Low-aktiv, tausch einfach HIGH und LOW in den Zeilen für L und R. Warum 220 Ω reichen, prüfst du mit dem LED-Vorwiderstandsrechner.
Projekt 3 erweitert dieselbe Logik auf drei PWM-Pins: In App Inventor baust du drei Schieberegler für Rot, Grün und Blau, jeder sendet bei Änderung einen Text wie "R120", und der Arduino stellt die Farbe mit analogWrite() ein. Wichtig ist hier, ob die RGB-LED eine gemeinsame Anode oder Kathode hat; bei gemeinsamer Anode bedeutet 255 aus und 0 maximale Helligkeit (RGB-LED verwenden). Bau die Schaltung aus den BlueGrays-Projekten RGB-LED verwenden und Sanfter Farbübergang mit RGB-LED auf und ergänze den Teil zum Befehlslesen aus diesem Code.
Projekte mit Bewegung (4, 7): Bluetooth-Auto und Roboterarm
Projekt 4 ist der Liebling unter den Bluetooth-Projekten: Mit den Pfeiltasten auf dem Handy fährt das Auto vor, zurück, nach links und rechts. Die meisten RC-Auto-Apps senden pro Taste einen Buchstaben (F vorwärts, B rückwärts, L links, R rechts, S stopp); der Arduino setzt danach die vier Eingänge des L298N und regelt die Geschwindigkeit per PWM an ENA und ENB. Versorge die Motoren aus einem eigenen 7–12-V-Akkupack, nicht aus den 5 V des Arduino, und verbinde alle Massen; sonst bricht die Spannung beim Anlaufen der Motoren ein und das HC-05 verliert die Verbindung. Details zum Treiber stehen im Artikel DC-Motor mit L298N steuern. In Projekt 7 sendet jeder Schieberegler in App Inventor einen Servowinkel (etwa "A90" oder "B45"); zwei oder mehr Servos versorgst du unbedingt aus einer externen 5-V-Quelle.
Steuerung per Handydisplay und Sprache (5, 6, 8, 9)
In Projekt 5 hört die Spracherkennung von App Inventor über das Handymikrofon zu und wandelt das Gesagte in Text um; die App schickt diesen Text, etwa "Licht an", unverändert per Bluetooth. Auf dem Arduino liest du die Zeile in einen String und steuerst das Relais mit einfachen Prüfungen wie indexOf("an"). Umlaute belegen in UTF-8 mehr als ein Byte, schreib die Befehlswörter auf dem Arduino also genauso oder lass die App den Text in Kleinbuchstaben umwandeln und Sonderzeichen ersetzen. In Projekt 6 läuft die Nachricht, die du auf dem Handy tippst, als Laufschrift über eine 8x32-LED-Matrix mit MAX7219; die Bibliothek MD_Parola erledigt das Scrollen in einer Zeile (MAX7219 LED-Matrix). Halte die Nachricht in einem char-Array und begrenze ihre Länge, denn die 2 KB RAM des Uno sind bei langen Texten schnell voll.
Projekt 8 funktioniert umgekehrt: Alle zwei Sekunden schickt der Arduino Temperatur und Luftfeuchte vom DHT11 als Zeile wie "T:24.0,H:45" ans Handy. Die App Bluetooth Electronics macht daraus ein Diagramm oder eine Anzeige (DHT11 Temperatur- und Feuchtesensor). In Projekt 9 sendet die Handy-App ein Passwort, und ist es richtig, öffnet der Arduino über einen Servo oder ein Relais ein Magnetschloss. Die Bluetooth-PIN allein bietet keine Sicherheit; leg das Befehlspasswort nicht fest im Code ab, bau nach Fehlversuchen eine Wartezeit ein und konstruiere das Schloss so, dass es bei Stromausfall auch mechanisch zu öffnen ist (Magnetschloss).
Modul zu Modul und fertige Panels (10, 11)
In Projekt 10 gibt es kein Handy: Eines von zwei HC-05 wird per AT-Befehl zum Master gemacht und so eingestellt, dass es sich automatisch mit der Adresse des anderen verbindet (mit Befehlen wie AT+ROLE=1 und AT+BIND). Steht die Verbindung, liest der eine Arduino alles, was der andere auf die serielle Schnittstelle schreibt; so schaltest du per Taster eine LED in einem anderen Raum oder zeigst einen Sensorwert drahtlos an. Da das HC-06 nur Slave sein kann, braucht dieses Projekt mindestens ein HC-05. AT-Modus und Befehlsliste findest du im Artikel zum HC-05. In Projekt 11 nutzt du den fertigen Gamepad-Bildschirm der App Dabble: Installier die Dabble-Bibliothek auf dem Arduino und lies die Tasten mit Funktionen wie GamePad.isUpPressed(); auf dem Handy musst du nichts gestalten. Mit HM-10 oder ESP32 läuft Dabble auch auf dem iPhone.
ESP32-Bluetooth-Projekte (12–15): BLE, Tastatur und Konsolen-Controller
Beim ESP32 ist Bluetooth eingebaut, du brauchst weder Modul noch Spannungsteiler. Projekt 12 zeigt, wie BLE funktioniert: Der ESP32 sendet unter dem Namen "BlueGrays-LED" und enthält einen Service mit einer beschreibbaren Characteristic. Verbinde dich mit nRF Connect oder LightBlue und schreib "1", "0" oder "P128" als UTF-8-Text hinein, dann geht die LED an, aus oder auf halbe Helligkeit. Da dieselben Apps auch auf dem iPhone laufen, kann dieses Projekt, was das HC-05 nicht kann.
1// ESP32 BLE: telefondan LED aç/kapa ve parlaklık (nRF Connect, LightBlue)
2// ESP32 BLE: switch an LED and set its brightness from your phone (nRF Connect, LightBlue)
3// Komutlar / Commands: 1, 0, P0..P255 (UTF-8 metin olarak yaz / write as UTF-8 text)
4#include <BLEDevice.h>
5#include <BLEServer.h>
6#include <BLEUtils.h>
7
8#define LED_PIN 2 // DevKit üzerindeki mavi LED / onboard blue LED on most DevKits
9#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
10#define CMD_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
11
12volatile bool connected = false;
13
14class ServerEvents : public BLEServerCallbacks {
15 void onConnect(BLEServer* server) override { connected = true; }
16 void onDisconnect(BLEServer* server) override {
17 connected = false;
18 BLEDevice::startAdvertising(); // bağlantı kopunca yeniden görünür ol / advertise again after disconnect
19 }
20};
21
22class CommandEvents : public BLECharacteristicCallbacks {
23 void onWrite(BLECharacteristic* ch) override {
24 String cmd = ch->getValue().c_str(); // 2.x ve 3.x çekirdekte çalışır / works on core 2.x and 3.x
25 cmd.trim();
26 if (cmd == "1") analogWrite(LED_PIN, 255);
27 else if (cmd == "0") analogWrite(LED_PIN, 0);
28 else if (cmd.startsWith("P")) analogWrite(LED_PIN, constrain(cmd.substring(1).toInt(), 0, 255));
29 Serial.println("Komut / Command: " + cmd);
30 }
31};
32
33void setup() {
34 Serial.begin(115200);
35 pinMode(LED_PIN, OUTPUT);
36
37 BLEDevice::init("BlueGrays-LED"); // telefonda görünen ad / name shown on the phone
38 BLEServer* server = BLEDevice::createServer();
39 server->setCallbacks(new ServerEvents());
40
41 BLEService* service = server->createService(SERVICE_UUID);
42 BLECharacteristic* cmdChar = service->createCharacteristic(
43 CMD_UUID, BLECharacteristic::PROPERTY_WRITE | BLECharacteristic::PROPERTY_WRITE_NR);
44 cmdChar->setCallbacks(new CommandEvents());
45 service->start();
46
47 BLEAdvertising* adv = BLEDevice::getAdvertising();
48 adv->addServiceUUID(SERVICE_UUID); // uygulamalar servisi taramada görsün / apps see the service while scanning
49 adv->setScanResponse(true);
50 BLEDevice::startAdvertising();
51 Serial.println("BLE yayinda: BlueGrays-LED / Advertising as BlueGrays-LED");
52}
53
54void loop() {
55 delay(1000); // tüm iş geri çağırmalarda / all work happens in the callbacks
56}Die wichtigste Zeile im Code ist der Aufruf startAdvertising() in onDisconnect: Der ESP32 beendet das Advertising, sobald sich ein Handy verbindet, und startet es nach dem Trennen nicht unbedingt selbst neu; ohne diese Zeile findest du das Board kein zweites Mal. Die UUIDs für Service und Characteristic dürfen beliebige zufällige 128-Bit-Werte sein; in deiner eigenen App nutzt du einfach dieselben. Die Form getValue().c_str() kompiliert mit den Versionen 2.x und 3.x des Arduino-ESP32-Cores. In Projekt 13 kommt eine lesbare Characteristic mit Benachrichtigung (notify) hinzu; der ESP32 schickt die Temperatur vom DHT22 alle paar Sekunden aufs Handy. Details im Artikel ESP32 Bluetooth und BLE.
In Projekt 14 meldet sich der ESP32 bei deinem Computer oder Handy als BLE-Tastatur an. Mit einer Bibliothek wie ESP32-BLE-Keyboard legst du die Pfeiltasten rechts und links auf zwei Taster und hast eine Fernbedienung für Präsentationsfolien; mit Tastenkürzeln auf ein paar Tastern entsteht eine kleine Makrotastatur. Am Computer brauchst du weder Treiber noch App. Die Bibliothek wird auf dem klassischen ESP32 viel genutzt; wähl eine Version, die zu deiner Core-Version passt. In Projekt 15 verbindet die Bibliothek Bluepad32 einen PS4-, PS5- oder Xbox-Controller direkt mit dem ESP32; heraus kommt ein Roboterauto, dessen Tempo du mit den Analogsticks fein regelst (ESP32-Auto mit PS4-Controller).
Häufige Fehler bei Arduino Bluetooth Projekten und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Das iPhone sieht das Modul nicht | HC-05 und HC-06 sind klassisches Bluetooth; iOS gibt es nicht für Apps frei | HM-10 oder ESP32 BLE verwenden |
| Kopplung klappt, Befehle kommen nicht an | Falsche Baudrate oder TX/RX vertauscht | 9600 Baud nutzen; Modul-TX an D10, RX über Teiler an D11 |
| Wirre Zeichen auf dem Bildschirm | Arduino und Modul nutzen verschiedene Baudraten | bt.begin() an die Rate des Moduls anpassen |
| Code lässt sich nicht hochladen | Modul hängt an D0 und D1 | Modul beim Hochladen abziehen oder per SoftwareSerial an andere Pins legen |
| Verbindung bricht beim Anlaufen der Motoren ab | Spannungseinbruch | Motoren aus eigenem Akku versorgen, Massen verbinden, Kondensator ergänzen |
| BluetoothSerial kompiliert auf dem ESP32-S3 nicht | Der Chip hat kein klassisches Bluetooth | BLE nutzen oder auf ein klassisches ESP32-Board wechseln |
Mit welchem Bluetooth-Projekt solltest du anfangen?
- Du hast ein Android-Handy und ein HC-05: Starte mit Projekt 1 und 2 und schick die Befehle von Hand aus Serial Bluetooth Terminal.
- Du nutzt ein iPhone: Hol dir ein HM-10 oder gleich einen ESP32 und lern BLE mit Projekt 12.
- Du willst Bewegung: Bau das Auto aus Projekt 4, indem du die Motoren erst in der Luft testest und dann aufs Chassis setzt.
- Du willst eine eigene App: Wechsel für Projekt 3 und 5 zu App Inventor; Tasten und Regler senden dieselben Textbefehle.
- Du willst den Computer steuern: Mach den ESP32 mit Projekt 14 zur BLE-Tastatur.
Das Schöne an Bluetooth-Projekten: Dieselbe Befehlslogik funktioniert überall. Der Befehl "L1", der heute eine LED einschaltet, steuert morgen ein Relais und übermorgen ein Roboterauto. Wählst du das passende Modul für dein Handy und testest zuerst mit einer Terminal-App, laufen die meisten Projekte beim ersten Versuch. In der BlueGrays-App findest du die Projekte LED per Bluetooth und Bluetooth-Auto mit L298N sowie RGB-LED-, Relais-, Servo- und WS2812B-Projekte, jeweils mit Schaltplan, Teileliste und fertigem Code, und kannst sie mit Bluetooth-Befehlen kombinieren.
Häufige Fragen
Welche Bluetooth-Projekte kann man mit Arduino bauen?
Die beliebtesten Arduino Bluetooth Projekte sind LED- und Relaissteuerung per Handy, ein Bluetooth-gesteuertes Auto, sprachgesteuerte Hausautomation, eine LED-Laufschrift, die du vom Handy aus beschreibst, Sensordaten aufs Handy und ein Türschloss mit Passwort. Mit einem ESP32 sind außerdem ein BLE-Sensor, eine BLE-Tastatur und die Steuerung per Konsolen-Controller möglich.
Was ist der Unterschied zwischen HC-05 und HC-06?
Beide sind klassische Bluetooth-Module und sprechen gleich über eine serielle Schnittstelle mit dem Arduino. Das HC-05 kann Master oder Slave sein und damit zwei Arduinos verbinden; das HC-06 ist nur Slave und wartet darauf, dass sich ein Gerät wie ein Handy verbindet.
Funktioniert das HC-05 mit dem iPhone?
Nein. HC-05 und HC-06 nutzen das serielle Profil des klassischen Bluetooth, und iOS gibt dieses Profil nicht für Apps frei. Für ein Projekt mit iPhone nimm ein BLE-Modul wie das HM-10 oder einen ESP32 mit eingebautem BLE.
Welche App für Arduino Bluetooth?
Zum Testen sind Serial Bluetooth Terminal unter Android sowie nRF Connect oder LightBlue für BLE-Module am praktischsten. Für ein fertiges Fernbedienungs-Panel nimm Dabble, für eigene Tasten und Regler App Inventor.
Warum braucht der RX-Pin des HC-05 einen Widerstand?
Das HC-05 arbeitet mit 3,3-V-Logik, der TX-Pin des Arduino Uno liefert dagegen 5 V. Ein Spannungsteiler aus 1 kΩ und 2 kΩ senkt das Signal auf etwa 3,3 V und schützt den Moduleingang; vom TX des Moduls zum Arduino ist kein Widerstand nötig.
Wie groß ist die Reichweite von Arduino Bluetooth?
HC-05, HC-06 und HM-10 schaffen im Freien etwa 10 Meter; Wände und Körper verkürzen die Strecke. Das eingebaute Bluetooth des ESP32 bietet eine ähnliche Reichweite; für größere Entfernungen brauchst du WLAN, ESP-NOW oder LoRa.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
LED per Bluetooth mit dem Handy steuern
Eine kleine Probe dafür, das Licht in deinem Zimmer vom Handy aus ein- und auszuschalten.

Bluetooth-gesteuertes Auto mit L298N
Mach dein Handy zur Fernbedienung und steuere dein eigenes Roboterauto. Der Arduino empfängt über ein Bluetooth-Modul die Befehle einer Fernsteuer-App auf dem Handy und treibt die Räder über einen…

RGB-LED verwenden
In einer einzigen LED stecken drei Farben: Die RGB-LED leuchtet erst rot, dann grün, dann blau, jede Farbe eine halbe Sekunde an und eine halbe Sekunde aus, und dann geht es von vorne los.

220-V-Glühbirne mit Taster ein- und ausschalten
Willst du eine echte Glühbirne aus dem Haushalt mit einem kleinen Taster ein- und ausschalten? Bei jedem Druck schaltet der Arduino ein Relais um und die Lampe geht an, beim nächsten Druck wieder aus.

Verwendung von Servomotoren
Der Arm eines kleinen Servomotors dreht sich nacheinander in drei Stellungen: ganz an den Anfang, genau in die Mitte und ganz ans Ende, mit jeweils zwei Sekunden Pause.

WS2812B-LED-Streifen verwenden
Du lernst einen smarten LED-Streifen kennen, bei dem du jedes einzelne Licht für sich einfärben kannst.

ESP32 RGB-LED-Steuerung
Unbegrenzte Farberzeugung mit einer einzigen RGB-LED anstelle von 3 separaten LEDs. Wie in Arduino machen wir Regenbogenübergänge, indem wir R/G/B-Werte mit analogWrite() setzen. Die Farbtheorie (z. B. Rot+Grün=Gelb) wird praktisch umgesetzt.

Roboter zur Hindernisvermeidung
Wie wäre es, ein intelligentes Fahrzeug zu bauen, das seinen Weg selbst findet? Der Obstacle Avoiding Robot scannt dank des Ultraschallsensors vor ihm ständig seine Umgebung.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

