ESP32 Bluetooth Anleitung: Classic und BLE mit dem Smartphone

ESP32 Bluetooth nutzt die im Chip eingebaute Funkverbindung, um deinen ESP32 ganz ohne Zusatzmodul mit Smartphone, Tablet oder Computer zu verbinden. Der klassische ESP32 beherrscht gleich zwei Bluetooth-Arten: Bluetooth Classic, das sich wie eine serielle Schnittstelle verhält, und Bluetooth Low Energy (BLE), das extrem wenig Strom braucht. Beim Arduino Uno brauchst du für die Verbindung zum Handy ein separates HC-05-Modul, beim ESP32 reichen ein paar Zeilen Code. In dieser Anleitung richtest du beide Varianten Schritt für Schritt ein, schaltest eine LED per Smartphone, schreibst deinen eigenen BLE-Service und schickst Sensordaten aufs Handy.

Welche Methode du wählst, hängt von deinem Handy und deinem Board ab. Hast du ein Android-Smartphone und ein klassisches ESP32-DevKit, ist die Bibliothek BluetoothSerial der schnellste Einstieg. Nutzt du ein iPhone oder ist dein Board ein ESP32-S3 oder ESP32-C3, hilft dir Bluetooth Classic nicht weiter; dann brauchst du BLE. Gegen Ende findest du dasselbe BLE-Projekt auch für den Raspberry Pi Pico W mit MicroPython. Arbeitest du zum ersten Mal mit dem ESP32, schließe zuerst die Einrichtung der Arduino IDE aus Was ist der ESP32? ab.

Was ist ESP32 Bluetooth? Classic und BLE im Vergleich

Bluetooth Classic ist die ältere, bekannte Variante, die in kabellosen Kopfhörern und Modulen wie dem HC-05 steckt. Der ESP32 nutzt sie über SPP (Serial Port Profile): Die Bytes fließen nacheinander, als läge ein unsichtbares serielles Kabel zwischen Handy und Board. Du koppelst das Gerät zuerst in den Bluetooth-Einstellungen des Handys und verbindest dich dann mit einer Terminal-App. BLE dagegen ist ein eigenständiges System, das 2010 mit Bluetooth 4.0 kam und für Geräte gedacht ist, die monatelang mit einer Batterie laufen. Bei BLE gibt es keinen durchgehenden Datenstrom; der ESP32 hält eine kleine Tabelle mit Werten (GATT) bereit, und das Handy liest diese Werte, schreibt sie oder abonniert sie, um bei Änderungen benachrichtigt zu werden. Trotz der ähnlichen Namen können die beiden nicht miteinander reden: Eine für BLE geschriebene App kann sich nicht mit einem Bluetooth-Classic-Gerät verbinden.

Eine praktische Faustregel: Willst du vom Android-Handy aus Text senden und empfangen und schnell Ergebnisse sehen, nimm Classic; brauchst du iPhone-Unterstützung, wenig Stromverbrauch oder eines der neueren ESP32-Boards, nimm BLE. Startest du ein neues Projekt, lohnt es sich, BLE zu lernen, denn es funktioniert auf beiden Handy-Typen und steckt in jedem neuen Espressif-Chip mit Bluetooth. Hast du schon mit dem HC-05 gearbeitet, wirst du sehen, dass die Befehlslogik aus HC-05 Bluetooth-Modul bei BluetoothSerial genau gleich ist.

Welches ESP32-Board hat welches Bluetooth?

Nicht jeder Chip der ESP32-Familie hat dieselbe Bluetooth-Hardware. Der häufigste Fehler ist, ein im Netz gefundenes BluetoothSerial-Beispiel auf ein ESP32-S3- oder ESP32-C3-Board laden zu wollen. Espressif hat Bluetooth Classic nur in den ursprünglichen ESP32-Chip eingebaut; die späteren Chips mit Bluetooth beherrschen ausschließlich BLE. Welchen Chip dein Board trägt, verrät die Aufschrift auf der Metallabschirmung des Moduls (zum Beispiel ESP32-WROOM-32 oder ESP32-S3-WROOM-1).

Bluetooth Classic: LED per Smartphone mit BluetoothSerial steuern

Die Bibliothek BluetoothSerial meldet den ESP32 beim Handy wie ein HC-05-Modul an und nutzt dieselben Befehle wie das Serial-Objekt: available(), read(), print() und println(). Sie ist im ESP32-Boardpaket enthalten, du musst also nichts zusätzlich installieren. Für die Schaltung reicht die blaue Onboard-LED an GPIO 2, die die meisten DevKit-Boards haben; nimmst du eine externe LED, schließe sie über einen 220-Ω-Widerstand an GPIO 2 an. Den Widerstandswert kannst du mit dem LED-Vorwiderstandsrechner prüfen, die übrigen sicheren Pins des ESP32 zeigt das Tool Pinout. Achte darauf, dass unter Werkzeuge > Board ESP32 Dev Module ausgewählt ist, und lade diesen Code hoch:

1#include "BluetoothSerial.h"
2
3// Klasik Bluetooth yalnızca ilk ESP32'de var / Classic Bluetooth exists only on the original ESP32
4#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
5#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
6#endif
7#if !defined(CONFIG_BT_SPP_ENABLED)
8#error Serial Bluetooth not available or not enabled. It is only available for the ESP32 chip.
9#endif
10
11BluetoothSerial SerialBT;
12const int LED_PIN = 2;                 // DevKit dahili LED / DevKit onboard LED
13bool ledAcik = false;
14
15void ledAyarla(bool acik) {
16  ledAcik = acik;
17  digitalWrite(LED_PIN, acik ? HIGH : LOW);
18  SerialBT.println(acik ? "LED acik / LED on" : "LED kapali / LED off");
19}
20
21void setup() {
22  Serial.begin(115200);
23  pinMode(LED_PIN, OUTPUT);
24  SerialBT.begin("BlueGrays-ESP32");   // telefonda görünecek ad / name shown on the phone
25  Serial.println("Eslesmeye hazir / Ready to pair");
26}
27
28void loop() {
29  if (SerialBT.available()) {
30    String komut = SerialBT.readStringUntil('\n');  // satır sonuna kadar oku / read until newline
31    komut.trim();                                   // CR ve boşlukları sil / strip CR and spaces
32    komut.toLowerCase();
33
34    if (komut == "1" || komut == "ac") {
35      ledAyarla(true);
36    } else if (komut == "0" || komut == "kapat") {
37      ledAyarla(false);
38    } else if (komut == "durum") {
39      SerialBT.println(ledAcik ? "LED acik / LED on" : "LED kapali / LED off");
40    } else if (komut.length() > 0) {
41      SerialBT.print("Bilinmeyen komut / Unknown command: ");
42      SerialBT.println(komut);
43    }
44  }
45
46  if (Serial.available()) {            // Seri Monitör'den telefona / Serial Monitor to phone
47    SerialBT.write(Serial.read());
48  }
49}

Der Code liest jede Zeile, die vom Handy kommt, als Befehl ein. readStringUntil() wartet, bis das Zeilenende-Zeichen eintrifft, und trim() entfernt den Wagenrücklauf (CR), den das Handy anhängt, sowie Leerzeichen; vergisst du diese Zeile, kommt beim Senden von "1" in Wirklichkeit "1" plus ein unsichtbares CR an, und kein Befehl passt. Da die Befehle in Kleinbuchstaben umgewandelt werden, bewirken "AC" und "ac" dasselbe. Die beiden untersten Zeilen leiten alles, was du in den Seriellen Monitor tippst, ans Handy weiter; so kannst du dich drahtlos zwischen Computer und Smartphone unterhalten. Die #error-Prüfungen am Anfang sorgen dafür, dass der Build bei falsch gewähltem Board mit einer verständlichen Meldung abbricht.

Mit Serial Bluetooth Terminal vom Handy aus verbinden

1. Öffne nach dem Hochladen den Seriellen Monitor mit 115200 Baud und achte auf die Meldung "Eslesmeye hazir / Ready to pair".
2. Suche auf deinem Android-Handy unter Einstellungen > Bluetooth nach neuen Geräten und kopple BlueGrays-ESP32. Standardmäßig koppelt der ESP32 ohne PIN; zeigt das Handy einen Bestätigungscode an, bestätige ihn.
3. Installiere die App Serial Bluetooth Terminal von Kai Morich aus Google Play.
4. Öffne in der App über das Seitenmenü Devices und wähle im Reiter Bluetooth Classic den BlueGrays-ESP32.
5. Tippe oben auf das Stecker-Symbol; sobald "Connected" erscheint, steht die Verbindung.
6. Gib unten 1 ein und sende es: Die LED leuchtet, und die Antwort "LED acik / LED on" erscheint. Mit 0 geht sie aus, mit durum erfährst du ihren aktuellen Zustand.

Wie funktioniert BLE? Services, Charakteristiken und UUIDs

Bei BLE gibt es zwei Rollen. Der ESP32 ist der Server (Peripheral): Er hält die Werte bereit und ruft "Ich bin hier", indem er in kurzen Abständen (beim ESP32 standardmäßig alle 20–40 ms) kleine Advertising-Pakete mit höchstens 31 Byte sendet. Das Handy ist der Client (Central): Es scannt die Umgebung, findet das Gerät und verbindet sich. Nach dem Verbinden liest das Handy die GATT-Tabelle (Generic Attribute Profile) des ESP32. Stell dir diese Tabelle wie einen Aktenschrank vor: Jede Schublade ist ein Service, jede Akte in der Schublade eine Charakteristik. Eine Charakteristik enthält einen einzelnen Wert (etwa eine Temperatur oder einen LED-Befehl) und Eigenschaften, die festlegen, was man mit ihm tun darf.

Jeder Service und jede Charakteristik wird über eine UUID erkannt. Standardfunktionen der Bluetooth SIG nutzen kurze 16-Bit-Nummern, etwa 0x180F für den Batterie-Service und 0x2A6E für die Temperatur-Charakteristik. Für eigene Daten ohne Standard-Gegenstück erzeugst du eine zufällige 128-Bit-UUID; in Python genügt dafür import uuid; print(uuid.uuid4()). Verwende für deine eigene UUID keinen Wert nach dem Muster xxxxxxxx-0000-1000-8000-00805F9B34FB, denn dieses Muster ist für die 16-Bit-Nummern der Bluetooth SIG reserviert. Willst du reibungslos mit fertigen Apps zusammenarbeiten, ist es noch praktischer, allgemein bekannte UUIDs zu nutzen:

ESP32 BLE-Server: LED per Smartphone steuern (Nordic UART)

In unserem ersten BLE-Projekt machen wir den ESP32 zu einem Nordic UART Service (NUS)-Server. NUS ist ein von Nordic Semiconductor definierter Dienst für eine "serielle Schnittstelle über BLE", der sich zum De-facto-Standard entwickelt hat: Das Handy schreibt in die RX-Charakteristik, der ESP32 sendet Benachrichtigungen über die TX-Charakteristik. Der Vorteil: Viele fertige Apps kennen ihn; nRF Connect, der Bluetooth-LE-Reiter von Serial Bluetooth Terminal und Bluefruit Connect auf dem iPhone funktionieren mit demselben Code. Der Code in diesem Abschnitt läuft also mit Android und iPhone und zudem auf reinen BLE-Boards wie dem ESP32-S3 und C3. Die BLE-Bibliothek ist Teil des ESP32-Boardpakets, du musst nichts weiter installieren.

1#include <BLEDevice.h>
2#include <BLEServer.h>
3#include <BLEUtils.h>
4#include <BLE2902.h>
5
6// Nordic UART Service UUID'leri / Nordic UART Service UUIDs
7#define SERVICE_UUID "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
8#define RX_UUID      "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"  // telefon -> ESP32 / phone -> ESP32
9#define TX_UUID      "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"  // ESP32 -> telefon / ESP32 -> phone
10
11const int LED_PIN = 2;
12
13BLEServer *sunucu = nullptr;
14BLECharacteristic *txKarakteristik = nullptr;
15volatile bool bagli = false;
16bool oncekiBagli = false;
17volatile int bekleyenKomut = -1;          // -1: yeni komut yok / no new command
18
19class SunucuOlaylari : public BLEServerCallbacks {
20  void onConnect(BLEServer *s) { bagli = true; }
21  void onDisconnect(BLEServer *s) { bagli = false; }
22};
23
24class RxOlaylari : public BLECharacteristicCallbacks {
25  void onWrite(BLECharacteristic *c) {
26    String deger = c->getValue().c_str(); // çekirdek 2.x ve 3.x ile uyumlu / works on core 2.x and 3.x
27    deger.trim();
28    if (deger == "1") bekleyenKomut = 1;
29    else if (deger == "0") bekleyenKomut = 0;
30  }
31};
32
33void cevapGonder(const char *mesaj) {
34  txKarakteristik->setValue((uint8_t *)mesaj, strlen(mesaj));
35  txKarakteristik->notify();              // telefona bildirim / notify the phone
36}
37
38void setup() {
39  Serial.begin(115200);
40  pinMode(LED_PIN, OUTPUT);
41
42  BLEDevice::init("BlueGrays-BLE");       // yayında görünecek ad / advertised name
43  sunucu = BLEDevice::createServer();
44  sunucu->setCallbacks(new SunucuOlaylari());
45
46  BLEService *servis = sunucu->createService(SERVICE_UUID);
47
48  txKarakteristik = servis->createCharacteristic(TX_UUID, BLECharacteristic::PROPERTY_NOTIFY);
49  txKarakteristik->addDescriptor(new BLE2902());   // bildirim anahtarı (CCCD) / notification switch (CCCD)
50
51  BLECharacteristic *rx = servis->createCharacteristic(
52    RX_UUID, BLECharacteristic::PROPERTY_WRITE | BLECharacteristic::PROPERTY_WRITE_NR);
53  rx->setCallbacks(new RxOlaylari());
54
55  servis->start();
56
57  BLEAdvertising *yayin = BLEDevice::getAdvertising();
58  yayin->addServiceUUID(SERVICE_UUID);
59  yayin->setScanResponse(true);
60  yayin->setMinPreferred(0x06);           // iPhone bağlantısına yardımcı / helps iPhone connections
61  yayin->setMaxPreferred(0x12);
62  BLEDevice::startAdvertising();
63  Serial.println("BLE yayini basladi / BLE advertising started");
64}
65
66void loop() {
67  if (bekleyenKomut != -1) {              // telefondan komut geldi / command received
68    int komut = bekleyenKomut;
69    bekleyenKomut = -1;
70    digitalWrite(LED_PIN, komut == 1 ? HIGH : LOW);
71    if (bagli) cevapGonder(komut == 1 ? "LED acik" : "LED kapali");
72  }
73
74  if (!bagli && oncekiBagli) {            // bağlantı koptu / disconnected
75    delay(500);                           // yığına zaman tanı / give the stack time
76    sunucu->startAdvertising();           // yeniden görünür ol / advertise again
77    Serial.println("Yeniden yayin / Advertising again");
78    oncekiBagli = false;
79  }
80  if (bagli && !oncekiBagli) {            // yeni bağlantı / new connection
81    Serial.println("Telefon baglandi / Phone connected");
82    oncekiBagli = true;
83  }
84}

Der wichtigste Teil des Codes sind die Callback-Klassen. onConnect und onDisconnect verfolgen den Verbindungsstatus, onWrite fängt den Wert ab, den das Handy in die RX-Charakteristik schreibt. Diese Funktionen laufen im eigenen Task des Bluetooth-Stacks; statt darin lange Arbeiten zu erledigen, ändern wir nur eine Variable, die eigentliche Arbeit macht loop(). Der BLE2902-Deskriptor an der TX-Charakteristik ist nötig, damit das Handy Benachrichtigungen einschalten kann. Bricht die Verbindung ab, startet der ESP32 das Advertising nicht von selbst neu; ohne die Zeile startAdvertising() in loop() lässt sich das Gerät nach der ersten Verbindung nicht mehr finden. Die Zeilen setMinPreferred und setMaxPreferred fügen dem Advertising das bevorzugte Verbindungsintervall hinzu, was die Verbindung mit iPhones erleichtert.

BLE mit nRF Connect testen: Schritt für Schritt

1. Installiere die kostenlose App nRF Connect for Mobile von Nordic Semiconductor; es gibt sie für Android und iPhone.
2. Unter Android fragt die App nach Bluetooth und der Berechtigung Geräte in der Nähe (bis Android 11 nach dem Standort, und der Standortdienst muss eingeschaltet sein); ohne sie bleibt die Scanliste leer.
3. Tippe im Reiter Scanner auf SCAN und suche BlueGrays-BLE in der Liste. Der RSSI-Wert daneben ist die Signalstärke: -50 dBm heißt sehr nah, -90 dBm ist die Grenze der Reichweite.
4. Tippe auf CONNECT. Auf dem folgenden Bildschirm erscheint der Nordic UART Service; hättest du selbst erzeugte UUIDs verwendet, stünde hier "Unknown Service".
5. Tippe neben der TX-Charakteristik (6E400003) auf das Symbol mit dem dreifachen Abwärtspfeil, um Benachrichtigungen einzuschalten.
6. Tippe neben der RX-Charakteristik (6E400002) auf den Aufwärtspfeil, wähle als Datentyp Text (UTF-8), gib 1 ein und sende. Die LED leuchtet, und in der TX-Zeile erscheint "LED acik".

Dieser Test ist der schnellste Weg, um zu beweisen, dass die ESP32-Seite funktioniert, bevor du eine Handy-App schreibst. Klappt etwas nicht, teste zuerst mit nRF Connect: Taucht das Gerät nicht in der Liste auf, liegt es am Advertising; verbindet es sich, zeigt aber den Service nicht, fehlt der start()-Aufruf des Service; schreibst du einen Wert und die LED bleibt aus, prüfe den Vergleich in onWrite. Du kannst denselben Code auch über den Reiter Bluetooth LE in Serial Bluetooth Terminal ausprobieren; die App erkennt den NUS-Service, und du schreibst wie bei Bluetooth Classic hin und her. Willst du eine eigene Android-App bauen, wirf einen Blick auf App Inventor mit Arduino und Bluetooth.

Sensordaten per BLE senden (DHT22)

In diesem Beispiel nutzen wir den Standard-Service Environmental Sensing (0x181A) mit seinen Charakteristiken für Temperatur (0x2A6E) und Luftfeuchtigkeit (0x2A6F). Das Schöne an Standard-UUIDs: Apps wie nRF Connect erkennen den Wert und zeigen ihn direkt als "23.45 °C" an. Der Standard verlangt, dass die Werte nicht als Text, sondern als mit 100 multiplizierte Ganzzahlen übertragen werden: Aus 23,45 °C wird die Zahl 2345, die als 2 Byte mit dem niedrigen Byte zuerst (Little-Endian) gesendet wird. Zum Auslesen des Sensors dient die Adafruit-Bibliothek DHT sensor library, die wir in der DHT11-Anleitung vorgestellt haben; du installierst sie über den Bibliotheksverwalter.

1#include <BLEDevice.h>
2#include <BLEServer.h>
3#include <BLE2902.h>
4#include <DHT.h>
5
6#define DHT_PIN 4
7DHT dht(DHT_PIN, DHT22);
8
9BLEServer *sunucu = nullptr;
10BLECharacteristic *sicaklikKar = nullptr;
11BLECharacteristic *nemKar = nullptr;
12volatile bool bagli = false;
13bool oncekiBagli = false;
14unsigned long sonOlcum = 0;
15
16class SunucuOlaylari : public BLEServerCallbacks {
17  void onConnect(BLEServer *s) { bagli = true; }
18  void onDisconnect(BLEServer *s) { bagli = false; }
19};
20
21BLECharacteristic *karakteristikEkle(BLEService *servis, uint16_t uuid) {
22  BLECharacteristic *k = servis->createCharacteristic(
23    BLEUUID(uuid), BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
24  k->addDescriptor(new BLE2902());        // bildirim için gerekli / needed for notify
25  return k;
26}
27
28void setup() {
29  Serial.begin(115200);
30  dht.begin();
31
32  BLEDevice::init("BlueGrays-Sensor");
33  sunucu = BLEDevice::createServer();
34  sunucu->setCallbacks(new SunucuOlaylari());
35
36  BLEService *servis = sunucu->createService(BLEUUID((uint16_t)0x181A));  // Environmental Sensing
37  sicaklikKar = karakteristikEkle(servis, 0x2A6E);  // sıcaklık, 0,01 °C / temperature, 0.01 °C
38  nemKar = karakteristikEkle(servis, 0x2A6F);       // nem, %0,01 / humidity, 0.01 %
39  servis->start();
40
41  BLEAdvertising *yayin = BLEDevice::getAdvertising();
42  yayin->addServiceUUID(BLEUUID((uint16_t)0x181A));
43  yayin->setScanResponse(true);
44  BLEDevice::startAdvertising();
45}
46
47void loop() {
48  if (millis() - sonOlcum >= 2000) {      // DHT22 en fazla 2 sn'de bir / DHT22 at most every 2 s
49    sonOlcum = millis();
50    float t = dht.readTemperature();
51    float h = dht.readHumidity();
52    if (!isnan(t) && !isnan(h)) {
53      int16_t t100 = (int16_t)lroundf(t * 100);    // 23,45 °C -> 2345
54      uint16_t h100 = (uint16_t)lroundf(h * 100);  // %41,2 -> 4120
55      sicaklikKar->setValue((uint8_t *)&t100, 2);  // 2 bayt, düşük bayt önce / 2 bytes, little-endian
56      nemKar->setValue((uint8_t *)&h100, 2);
57      if (bagli) {
58        sicaklikKar->notify();
59        nemKar->notify();
60      }
61      Serial.printf("%.2f C  %.2f %%\n", t, h);
62    }
63  }
64
65  if (!bagli && oncekiBagli) {            // bağlantı koptu / disconnected
66    delay(500);
67    sunucu->startAdvertising();           // yeniden yayın / advertise again
68    oncekiBagli = false;
69  }
70  if (bagli && !oncekiBagli) oncekiBagli = true;
71}

Der Code misst alle zwei Sekunden, weil der DHT22 nicht öfter ausgelesen werden kann. Die Werte werden zuerst mit setValue() in die Charakteristik geschrieben; so bekommt das Handy die letzte Messung auch dann, wenn es ohne Benachrichtigung liest (READ). Ist das Handy verbunden, schickt notify() den neuen Wert sofort. Kann nRF Connect den Wert nicht entschlüsseln, siehst du die Rohbytes: Für 23,45 °C steht dort (0x) 29-09. Drehst du die Bytes um, erhältst du 0x0929, dezimal 2345; geteilt durch 100 ergibt sich die Temperatur. Genau diese Rechnung musst du auch in deiner eigenen App machen. Den Wert als Text zu senden wirkt zwar einfacher, das Standardformat braucht aber weniger Bytes und funktioniert mit fertigen Apps.

ESP32 Bluetooth mit dem iPhone (iOS)

Die häufigste Frage von iPhone-Nutzern lautet, warum der ESP32 nicht in den Bluetooth-Einstellungen erscheint. Apple öffnet das serielle Profil (SPP) von Bluetooth Classic nur für MFi-zertifiziertes Zubehör; deshalb kannst du dich vom iPhone aus nicht mit einem ESP32 verbinden, auf dem BluetoothSerial läuft. Die Lösung heißt BLE, und die NUS- und Sensorbeispiele oben funktionieren auf dem iPhone problemlos. Ein paar Punkte solltest du beachten:

• Suche in den Einstellungen: BLE-Geräte werden in den Bluetooth-Einstellungen von iOS nicht aufgelistet; verbinde dich in einer App wie nRF Connect, LightBlue oder Bluefruit Connect.
• Cache: iOS merkt sich Namen und Service-Liste des Geräts. Siehst du nach einer Änderung der Services im Code noch die alte Liste, schalte Bluetooth am Handy aus und wieder ein.
• Keine MAC-Adresse: iOS zeigt Apps die MAC-Adresse des Geräts nicht, sondern vergibt eine eigene Kennung; nutzt du mehrere ESP32, gib jedem einen anderen Namen.
• Verbindungsintervall: Lösche die Zeilen setMinPreferred(0x06) und setMaxPreferred(0x12) nicht; auch die Espressif-Beispiele empfehlen sie gegen Verbindungsprobleme mit dem iPhone.
• Eigene App: Unter iOS verwendest du Core Bluetooth mit Swift; eine Kopplung ist nicht nötig, die App scannt direkt nach der Service-UUID.

BLE mit dem Raspberry Pi Pico W und MicroPython

In der Raspberry Pi Pico-Familie gibt es Bluetooth nur beim Pico W und Pico 2 W. Der CYW43439-Chip auf dem Board unterstützt in der Hardware sowohl Bluetooth Classic als auch BLE, MicroPython nutzt jedoch nur BLE (ab Version 1.20). Der folgende Code ist das MicroPython-Gegenstück zum NUS-Beispiel des ESP32; da er dieselben UUIDs verwendet, testest du ihn genauso mit nRF Connect und Serial Bluetooth Terminal. Auf dem Board muss die MicroPython-Version für den Pico W installiert sein. Zusätzlich liest der Code den internen Temperatursensor des Boards aus und schickt den Wert alle 2 Sekunden an das verbundene Handy.

1import bluetooth
2import struct
3import time
4from machine import Pin, ADC
5from micropython import const
6
7_IRQ_CENTRAL_CONNECT = const(1)
8_IRQ_CENTRAL_DISCONNECT = const(2)
9_IRQ_GATTS_WRITE = const(3)
10_FLAG_READ = const(0x0002)
11_FLAG_WRITE_NO_RESPONSE = const(0x0004)
12_FLAG_WRITE = const(0x0008)
13_FLAG_NOTIFY = const(0x0010)
14
15# Nordic UART Service: ESP32 örneğiyle aynı UUID'ler / same UUIDs as the ESP32 example
16NUS_UUID = bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
17TX = (bluetooth.UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E"), _FLAG_READ | _FLAG_NOTIFY)
18RX = (bluetooth.UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E"), _FLAG_WRITE | _FLAG_WRITE_NO_RESPONSE)
19
20led = Pin("LED", Pin.OUT)       # Pico W dahili LED / Pico W onboard LED
21sensor = ADC(4)                 # dahili sıcaklık sensörü / internal temperature sensor
22
23ble = bluetooth.BLE()
24ble.active(True)
25((tx_h, rx_h),) = ble.gatts_register_services(((NUS_UUID, (TX, RX)),))
26baglanti = None
27
28
29def alan(tur, veri):            # uzunluk + tür + veri / length + type + data
30    return struct.pack("BB", len(veri) + 1, tur) + veri
31
32
33YAYIN = alan(0x01, b"\x06") + alan(0x09, b"BlueGrays-Pico")  # bayraklar + ad / flags + name
34YANIT = alan(0x07, bytes(NUS_UUID))                          # 128 bit UUID / 128-bit UUID
35
36
37def yayinla():
38    ble.gap_advertise(100000, adv_data=YAYIN, resp_data=YANIT)  # 100 ms aralık / interval
39
40
41def olay(event, data):
42    global baglanti
43    if event == _IRQ_CENTRAL_CONNECT:
44        baglanti = data[0]
45    elif event == _IRQ_CENTRAL_DISCONNECT:
46        baglanti = None
47        yayinla()                                 # yeniden görünür ol / advertise again
48    elif event == _IRQ_GATTS_WRITE and data[1] == rx_h:
49        komut = ble.gatts_read(rx_h).decode().strip()
50        if komut == "1":
51            led.on()
52        elif komut == "0":
53            led.off()
54
55
56ble.irq(olay)
57yayinla()
58
59while True:
60    if baglanti is not None:
61        volt = sensor.read_u16() * 3.3 / 65535
62        sicaklik = 27 - (volt - 0.706) / 0.001721   # veri sayfası formülü / datasheet formula
63        try:
64            ble.gatts_notify(baglanti, tx_h, "T:{:.1f}\n".format(sicaklik).encode())
65        except OSError:
66            pass                                    # bağlantı yeni koptu / just disconnected
67    time.sleep(2)

Da das bluetooth-Modul von MicroPython sehr hardwarenah ist, bauen wir das Advertising-Paket selbst. Jedes Feld besteht aus einem Längenbyte, einem Typbyte und den Daten: 0x01 sind die Flags, 0x09 der vollständige Gerätename und 0x07 die 128-Bit-Service-UUID. Weil ein Advertising-Paket höchstens 31 Byte fasst, steht das 18 Byte lange UUID-Feld in der Scan-Antwort (resp_data). gatts_register_services() liefert die Handles der Charakteristiken; mit diesen Handles lesen wir den vom Handy geschriebenen Wert und senden die Benachrichtigungen. Für kürzeren Code kannst du die asyncio-basierte Bibliothek aioble mit mip installieren. Um den Code unter MicroPython auf dem ESP32 laufen zu lassen, änderst du die LED-Zeile in Pin(2, Pin.OUT) und liest statt des internen Temperatursensors zum Beispiel einen DHT11 aus.

WLAN und Bluetooth zusammen: Speicher, Reichweite und Stromversorgung

Beim ESP32 teilen sich WLAN und Bluetooth dasselbe 2,4-GHz-Funkmodul. Der Chip betreibt beide im Zeitmultiplex; du kannst sie also gleichzeitig nutzen, aber beide werden etwas langsamer, und Bluetooth Classic zusammen mit viel WLAN-Verkehr ist das schwierigste Szenario. Das eigentliche Problem ist meist jedoch der Speicher: Der Bluetooth-Stack ist groß, und zusammen mit WLAN kann das Programm die standardmäßige App-Partition von 1,2 MB (1.310.720 Byte) sprengen; schon das BLE-Beispiel dieser Anleitung füllt allein etwa 80 % davon. Endet der Build mit "Sketch too big" oder "text section exceeds available space in board" und nutzt du keine Updates über die Luft (OTA), wähle unter Werkzeuge > Partition Scheme Huge APP (3MB No OTA/1MB SPIFFS). Eine gute Alternative ist auch die Bibliothek NimBLE-Arduino, die weniger Flash und RAM braucht.

Die Reichweite hängt vom Antennendesign des Boards und von der Umgebung ab. Mit einem ESP32 mit PCB-Antenne auf dem Board kannst du in Innenräumen je nach Wänden mit 10–20 Metern rechnen, im Freien mit mehr; Module mit Anschluss für eine externe Antenne (zum Beispiel ESP32-WROOM-32U) kommen noch weiter. Deckst du die Antenne mit einem Metallgehäuse, einer Batterie oder Kabeln ab, sinkt die Reichweite drastisch. Weil der Strom beim Einschalten der Funkeinheit kurz ansteigt, kann ein schwaches USB-Kabel den ESP32 mit der Meldung "Brownout detector was triggered" neu starten lassen; Lösungen findest du in ESP32 Brownout und Guru Meditation.

Projektideen mit ESP32 Bluetooth

• Bluetooth-Roboterauto: Gib die per BluetoothSerial empfangenen Befehle F, B, L und R an einen L298N-Motortreiber weiter; die Mechanik erklärt Arduino-Roboterauto bauen.
• Smarte Steckdose: Ersetze die LED im NUS-Beispiel durch ein Relaismodul und schalte eine Lampe vom iPhone aus ein.
• Funkthermometer: Ergänze das DHT22-Beispiel um ein OLED-Display, damit der Wert auf dem Display und auf dem Handy erscheint.
• Bunte Stimmungsbeleuchtung: Ändere die Farbe eines WS2812B-NeoPixel-Streifens mit R-, G- und B-Werten vom Handy.
• Eigene Android-App: Baue mit App Inventor in wenigen Stunden eine Fernbedienungs-App mit Tasten und Schiebereglern.
• Kommunikation zwischen zwei ESP32: Damit zwei Boards ohne Handy miteinander reden, probiere statt Bluetooth das einfachere und schnellere ESP-NOW.

Häufige ESP32-Bluetooth-Fehler und Lösungen

Mit ESP32 Bluetooth machst du aus deinem Handy eine Fernbedienung und aus dem ESP32 einen Funksensor oder ein smartes Gerät, und das mit wenigen Zeilen Code. Für einen schnellen Start mit Android ist BluetoothSerial die richtige Wahl, für iPhone-Unterstützung und geringen Stromverbrauch BLE. Willst du mit drahtlosen ESP32-Projekten weitermachen, findest du in der BlueGrays-App Projekte wie LEDs, RGB-LEDs, Temperaturmessung mit dem DHT22 und ein per Bluetooth gesteuertes Auto, jeweils mit Schritt-für-Schritt-Schaltplan und fertigem Code.