Gidsen · 16 min leestijd

ESP32 Bluetooth-tutorial: Classic versus BLE, ledbediening en sensoren

ESP32 Bluetooth-gids: bedien een LED met je telefoon via BluetoothSerial, bouw een BLE-server met services en UUID's, test met nRF Connect en stuur sensordata.

ESP32 Bluetooth gebruikt de draadloze radio in de chip om je ESP32 zonder extra module te verbinden met een telefoon, tablet of computer. De originele ESP32 ondersteunt twee soorten Bluetooth tegelijk: Bluetooth Classic, dat zich gedraagt als een seriële poort, en Bluetooth Low Energy (BLE), dat heel weinig stroom verbruikt. Bij een Arduino Uno heb je een aparte HC-05-module nodig om met je telefoon te praten; op de ESP32 volstaan een paar regels code. In deze gids stel je beide methoden stap voor stap in, zet je een LED aan met je telefoon, schrijf je je eigen BLE-service en stuur je sensordata naar je telefoon.

Welke methode je kiest, hangt af van je telefoon en je board. Heb je een Android-telefoon en een klassiek ESP32 DevKit-board, dan begin je het snelst met de bibliotheek BluetoothSerial. Gebruik je een iPhone, of is je board een ESP32-S3 of ESP32-C3, dan heb je niets aan Classic Bluetooth en heb je BLE nodig. Aan het einde vind je hetzelfde BLE-project ook voor de Raspberry Pi Pico W in MicroPython. Werk je voor het eerst met de ESP32, rond dan eerst de installatie van de Arduino IDE af in Wat is de ESP32?.

ESP32-ontwikkelboard met Bluetooth en BLE
ESP32-ontwikkelboard: Wi-Fi, Bluetooth Classic en BLE zitten allemaal in dezelfde chip, dus je hebt geen externe Bluetooth-module nodig om een telefoon te verbinden.

Wat is ESP32 Bluetooth? Classic versus BLE

Bluetooth Classic is de oudere, bekende variant die wordt gebruikt in draadloze koptelefoons en modules zoals de HC-05. De ESP32 gebruikt het via SPP (Serial Port Profile): bytes stromen na elkaar door, alsof er een onzichtbare seriële kabel tussen telefoon en board zit. Je koppelt het apparaat eerst in de Bluetooth-instellingen van je telefoon en verbindt daarna met een terminal-app. BLE is daarentegen een apart systeem dat in 2010 met Bluetooth 4.0 is geïntroduceerd en bedoeld is voor apparaten die maandenlang op een batterij draaien. BLE kent geen continue datastroom; de ESP32 houdt een kleine tabel met waarden bij (GATT), en de telefoon leest die, schrijft ze of abonneert zich om een bericht te krijgen als ze veranderen. Ondanks de vergelijkbare namen kunnen de twee niet met elkaar praten: een app voor BLE kan niet verbinden met een Classic Bluetooth-apparaat.

EigenschapBluetooth Classic (SPP)Bluetooth Low Energy (BLE)
Arduino-bibliotheekBluetoothSerial (zit in het ESP32-pakket)BLEDevice (zit in het ESP32-pakket) of NimBLE-Arduino
DatamodelContinue bytestroom, zoals een seriële poortGATT-tabel met services en characteristics
Hoeveelheid dataHoog, geschikt voor continue datastromenKleine pakketjes; standaard 20 bytes per melding
StroomverbruikConstant hoog zolang er verbinding isZeer laag; kan maandenlang op een batterij draaien
KoppelenGebeurt in de Bluetooth-instellingen van de telefoonNiet nodig; de verbinding wordt in de app gemaakt
AndroidOndersteundOndersteund
iPhone (iOS)Niet ondersteundOndersteund
Ondersteunde ESP32'sAlleen de originele ESP32 (WROOM-32, WROVER)ESP32, S3, C3, C6 en H2 (niet S2)
Typisch gebruikSeriële terminal, robotauto, vervanging van de HC-05Sensoren, wearables, smart home, beacons

Een praktische vuistregel: wil je tekst versturen en ontvangen met een Android-telefoon en snel resultaat zien, kies dan Classic; heb je ondersteuning voor de iPhone, laag verbruik of een van de nieuwere ESP32-boards nodig, kies dan BLE. Begin je een nieuw project, dan is BLE de moeite van het leren waard, want het werkt op beide soorten telefoons en zit in elke nieuwe Espressif-chip met Bluetooth. Heb je eerder met de HC-05 gewerkt, dan zie je dat de commandologica uit HC-05 Bluetooth-module met BluetoothSerial precies hetzelfde is.

Welke ESP32-boards hebben welk Bluetooth?

Niet elke chip in de ESP32-familie heeft dezelfde Bluetooth-hardware. De meest gemaakte fout is een BluetoothSerial-voorbeeld van internet proberen te uploaden naar een ESP32-S3- of ESP32-C3-board. Espressif heeft Classic Bluetooth alleen in de originele ESP32-chip gebouwd; de latere chips met Bluetooth ondersteunen alleen BLE. Welke chip op je board zit, zie je aan de tekst op het metalen kapje van de module (bijvoorbeeld ESP32-WROOM-32 of ESP32-S3-WROOM-1).

Board / chipBluetooth ClassicBLEOpmerking
ESP32 (WROOM-32, WROVER, DevKit V1)JaJa (4.2)De enige ESP32-variant waarop BluetoothSerial draait
ESP32-S2NeeNeeAlleen Wi-Fi
ESP32-S3NeeJa (Bluetooth 5)BluetoothSerial compileert niet, gebruik BLE
ESP32-C3NeeJa (Bluetooth 5)Kleine, goedkope BLE-boards
ESP32-C6NeeJa (Bluetooth 5)Heeft ook Wi-Fi 6, Zigbee en Thread
ESP32-H2NeeJa (Bluetooth 5)Geen Wi-Fi; gericht op Zigbee en Thread
ESP8266 (NodeMCU, Wemos D1)NeeNeeVoor Bluetooth heb je een HC-05 of HM-10 nodig
Raspberry Pi Pico W / Pico 2 WIn hardwareJaMicroPython ondersteunt alleen BLE
Raspberry Pi Pico / Pico 2NeeNeeHeeft een externe Bluetooth-module nodig
Compileer je BluetoothSerial-code terwijl in het boardmenu een ESP32-S3, C3, C6 of H2 is gekozen, dan stopt de controleregel in de voorbeelden van Espressif (en in onze code hieronder) de build met "Serial Bluetooth not available or not enabled. It is only available for the ESP32 chip." Dit is geen installatie- of bibliotheekprobleem; de chip heeft gewoon geen Classic Bluetooth-hardware. Heb je zo'n board, ga dan meteen naar het BLE-voorbeeld (Nordic UART) hieronder.

Bluetooth Classic: een LED bedienen met je telefoon via BluetoothSerial

De bibliotheek BluetoothSerial presenteert de ESP32 aan je telefoon als een HC-05-module en gebruikt dezelfde commando's als het Serial-object: available(), read(), print() en println(). De bibliotheek zit in het ESP32-boardpakket, dus je hoeft niets extra te installeren. Voor de schakeling volstaat de blauwe ingebouwde LED op GPIO 2 van de meeste DevKit-boards; gebruik je een externe LED, sluit die dan via een weerstand van 220 Ω aan op GPIO 2. De weerstandswaarde controleer je met de LED-weerstandscalculator en de andere veilige pins van de ESP32 zie je in de Pinout-tool. Zorg dat onder Tools > Board ESP32 Dev Module is gekozen en upload deze code:

C++ (Arduino IDE)
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}

De code leest elke regel van de telefoon als een commando. readStringUntil() wacht tot het regeleindeteken binnenkomt en trim() verwijdert de carriage return (CR) die de telefoon meestuurt, plus eventuele spaties; vergeet je deze regel, dan verstuur je met "1" eigenlijk "1" plus een onzichtbaar CR-teken en komt er geen commando overeen. Omdat de commando's naar kleine letters worden omgezet, doen "AC" en "ac" hetzelfde. De twee regels onderaan sturen alles wat je in de Serial Monitor typt door naar de telefoon, zodat je een draadloze chat kunt voeren tussen je computer en je telefoon. De #error-controles bovenaan laten de build stoppen met een duidelijke melding als het verkeerde board is gekozen.

Verbinden met je telefoon via Serial Bluetooth Terminal

  1. Open na het uploaden de Serial Monitor op 115200 baud en zoek de melding "Eslesmeye hazir / Ready to pair".
  2. Zoek op je Android-telefoon onder Instellingen > Bluetooth naar nieuwe apparaten en koppel met BlueGrays-ESP32. Standaard koppelt de ESP32 zonder om een pincode te vragen; toont de telefoon een bevestigingscode, bevestig die dan.
  3. Installeer de app Serial Bluetooth Terminal van Kai Morich uit Google Play.
  4. Open in de app via het zijmenu Devices en kies BlueGrays-ESP32 op het tabblad Bluetooth Classic.
  5. Tik op het stekkericoon in de bovenbalk; zodra "Connected" in beeld verschijnt, ben je verbonden.
  6. Typ 1 in het vak onderaan en verstuur het: de LED gaat aan en het antwoord "LED acik / LED on" verschijnt. Met 0 zet je hem uit en durum geeft de huidige status.
Houd de macroknoppen M1 en M2 onderaan Serial Bluetooth Terminal ingedrukt en sla de commando's "1" en "0" op om de LED met één tik te schakelen. De optie Send > Newline in de instellingen van de app staat standaard op CR+LF; trim() in de code verwijdert de extra CR al. Sluit een relais aan in plaats van de LED en dezelfde code kan een lamp of stopcontact schakelen; zie Wat is een relaismodule? voor de details.

Hoe werkt BLE? Services, characteristics en UUID's

BLE kent twee rollen. De ESP32 speelt de server (peripheral): hij bewaart de waarden en meldt "ik ben hier" door met korte tussenpozen kleine advertising-pakketjes van maximaal 31 bytes te sturen (standaard elke 20–40 ms op de ESP32). De telefoon speelt de client (central): hij scant de omgeving, vindt het apparaat en maakt verbinding. Is er verbinding, dan leest de telefoon de GATT-tabel (Generic Attribute Profile) van de ESP32. Zie deze tabel als een archiefkast: elke la is een service en elke map in een la is een characteristic. Een characteristic bevat één waarde (zoals een temperatuur of een LED-commando) plus eigenschappen die aangeven wat je ermee kunt doen.

TermBetekenisVoorbeeld in deze gids
AdvertisingKort pakket waarin het apparaat zijn naam en services bekendmaaktAdvertising onder de naam "BlueGrays-BLE"
ServiceGroep die bij elkaar horende characteristics bundeltNordic UART-service, Environmental Sensing (0x181A)
CharacteristicEen enkele waarde die wordt gelezen of geschrevenLED-commando, temperatuur (0x2A6E)
READDe telefoon leest de waarde wanneer hij wilLaatst gemeten temperatuur
WRITE / WRITE_NRDe telefoon schrijft een waarde (met of zonder antwoord)Door "1" te schrijven gaat de LED aan
NOTIFYDe ESP32 meldt zelf aan de telefoon dat de waarde is veranderdElke 2 seconden een nieuwe temperatuur
Descriptor 0x2902 (CCCD)Schakelaar die meldingen aan- en uitzetKnop met drie pijltjes in nRF Connect
UUIDID-nummer van services en characteristics6E400001-B5A3-F393-E0A9-E50E24DCCA9E

Elke service en characteristic wordt geïdentificeerd door een UUID. Standaardfuncties die door de Bluetooth SIG zijn gedefinieerd, gebruiken korte 16-bitsnummers, zoals 0x180F voor de batterijservice en 0x2A6E voor de temperatuurcharacteristic. Voor je eigen data zonder standaardvariant genereer je een willekeurige 128-bits UUID; in Python is import uuid; print(uuid.uuid4()) genoeg. Gebruik als eigen UUID geen waarde die past op het patroon xxxxxxxx-0000-1000-8000-00805F9B34FB, want dat patroon is gereserveerd voor de 16-bitsnummers van de Bluetooth SIG. Wil je soepel samenwerken met bestaande apps, dan is het nog praktischer om UUID's te gebruiken die iedereen herkent:

Service / characteristicUUIDGegevensformaat
Battery Service / Battery Level0x180F / 0x2A191 byte, procent (0–100)
Environmental Sensing / Temperature0x181A / 0x2A6E2 bytes, geheel getal met teken, 0,01 °C
Environmental Sensing / Humidity0x181A / 0x2A6F2 bytes, geheel getal zonder teken, 0,01%
Heart Rate / Heart Rate Measurement0x180D / 0x2A37Flags-byte + hartslagwaarde
Nordic UART Service (NUS)6E400001-B5A3-F393-E0A9-E50E24DCCA9ERX 6E400002 (write), TX 6E400003 (notify)

ESP32 BLE-server: een LED bedienen met je telefoon (Nordic UART)

In ons eerste BLE-project maken we van de ESP32 een Nordic UART Service (NUS)-server. NUS is een door Nordic Semiconductor gedefinieerde service voor een "seriële poort over BLE" die een de-factostandaard is geworden: de telefoon schrijft naar de RX-characteristic en de ESP32 stuurt meldingen vanuit de TX-characteristic. Het voordeel is dat veel kant-en-klare apps hem herkennen; nRF Connect, het tabblad Bluetooth LE van Serial Bluetooth Terminal en Bluefruit Connect op de iPhone werken allemaal met dezelfde code. De code in dit onderdeel werkt dus met zowel Android als iPhone, en ook op boards met alleen BLE zoals de ESP32-S3 en C3. De BLE-bibliotheek zit in het ESP32-boardpakket, dus je hoeft niets extra te installeren.

C++ (Arduino IDE)
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}

Het belangrijkste deel van de code zijn de callback-klassen. onConnect en onDisconnect houden de verbindingsstatus bij en onWrite vangt de waarde op die de telefoon naar de RX-characteristic schrijft. Deze functies draaien in de eigen taak van de Bluetooth-stack, dus we doen er geen lange klussen in maar passen alleen een variabele aan; loop() doet het eigenlijke werk. De BLE2902-descriptor die aan de TX-characteristic is toegevoegd, is nodig zodat de telefoon meldingen kan inschakelen. Valt de verbinding weg, dan start de ESP32 het advertising niet zelf opnieuw; zonder de regel startAdvertising() in loop() is het apparaat na de eerste verbinding niet meer te vinden. De regels setMinPreferred en setMaxPreferred voegen het gewenste verbindingsinterval toe aan de advertentie, wat verbinden met iPhones makkelijker maakt.

De code in dit artikel is gecompileerd met versie 2.0.11 van de ESP32 Arduino-core (boardpakket). In deze versie geven BLE-functies zoals getValue() een std::string terug, en de meeste voorbeelden op internet gebruiken ook dat type. Met core 3.0 zijn de BLE-functies overgestapt op het String-type van Arduino, dus code die met std::string is geschreven geeft op 3.x de fout "conversion from 'String' to non-scalar type 'std::string' requested". Wijs je het resultaat toe aan een String-variabele en voeg je .c_str() aan het eind toe, zoals in onze code, dan compileert de regel op zowel de 2.x- als de 3.x-core.

BLE stap voor stap testen met nRF Connect

  1. Installeer de gratis app nRF Connect for Mobile van Nordic Semiconductor op je telefoon; hij is er voor Android en iPhone.
  2. Op Android vraagt de app toestemming voor Bluetooth en Apparaten in de buurt (op Android 11 en ouder: locatietoestemming met locatieservices aan); zonder die toestemming blijft de scanlijst leeg.
  3. Druk op het tabblad Scanner op SCAN en zoek BlueGrays-BLE in de lijst. De RSSI-waarde ernaast is de signaalsterkte: -50 dBm betekent heel dichtbij, -90 dBm is de rand van het bereik.
  4. Tik op CONNECT. Het scherm dat opent toont de Nordic UART Service; had je zelfgegenereerde UUID's gebruikt, dan stond hier "Unknown Service".
  5. Tik op het icoon met de drie pijlen omlaag naast de TX-characteristic (6E400003) om meldingen in te schakelen.
  6. Tik op het pijl-omhoog-icoon naast de RX-characteristic (6E400002), kies Text (UTF-8) als gegevenstype, typ 1 en verstuur het. De LED gaat aan en "LED acik" verschijnt op de TX-regel.

Deze test is de snelste manier om te bewijzen dat de ESP32-kant werkt voordat je een telefoon-app schrijft. Gaat er iets mis, probeer dan eerst nRF Connect: staat het apparaat niet in de lijst, dan zit het probleem in het advertising; maakt het verbinding maar verschijnt de service niet, dan ontbreekt de aanroep start() van de service; schrijf je een waarde en blijft de LED uit, controleer dan de vergelijking in onWrite. Je kunt dezelfde code ook proberen via het tabblad Bluetooth LE van Serial Bluetooth Terminal; de app herkent de NUS-service en je chat net zoals met Classic Bluetooth. Wil je je eigen Android-app bouwen, kijk dan eens naar App Inventor Arduino Bluetooth.

Sensordata uitzenden via BLE (DHT22)

DHT22 temperatuur- en vochtigheidssensor
De DHT22 meet de temperatuur met een resolutie van 0,1 °C; omdat hij op 3,3 V werkt, sluit je hem direct aan op de ESP32.
DHT22-pinESP32Opmerking
VCC (+)3V3Werkt op 3,3 tot 5 V
DATA (OUT)GPIO 4Voeg bij een kale sensor een weerstand van 10 kΩ toe tussen DATA en 3V3
GND (−)GNDGemeenschappelijke massa

In dit voorbeeld gebruiken we de standaardservice Environmental Sensing (0x181A) met de characteristics voor temperatuur (0x2A6E) en luchtvochtigheid (0x2A6F). Het mooie van standaard-UUID's is dat apps zoals nRF Connect de waarde herkennen en direct tonen als "23.45 °C". De standaard vraagt om waarden niet als tekst te versturen maar als gehele getallen vermenigvuldigd met 100: een temperatuur van 23,45 °C wordt het getal 2345 en wordt verstuurd als 2 bytes, laagste byte eerst (little-endian). Om de sensor uit te lezen gebruiken we de DHT sensor library van Adafruit, die we in de DHT11-gids hebben behandeld; je installeert hem via de Library Manager.

C++ (Arduino IDE)
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}

De code doet elke twee seconden een meting, omdat de DHT22 niet vaker uitgelezen kan worden. De waarden worden eerst met setValue() in de characteristic geschreven, zodat de telefoon bij het lezen (READ) ook de laatste meting krijgt zonder op een melding te wachten. Is de telefoon verbonden, dan stuurt notify() de nieuwe waarde meteen. Kan nRF Connect de waarde niet decoderen, dan zie je de ruwe bytes: voor 23,45 °C toont het scherm (0x) 29-09. Draai de bytes om en je krijgt 0x0929, oftewel 2345 decimaal; deel door 100 en je hebt de temperatuur. Dezelfde berekening moet je ook doen als je je eigen app schrijft. De waarde als tekst versturen lijkt misschien makkelijker, maar het standaardformaat gebruikt minder bytes en werkt met bestaande apps.

Het is ook mogelijk om data zonder verbinding te versturen: de ESP32 kan de meting direct in het veld met fabrikantdata van zijn advertising-pakket zetten, en elke telefoon of gateway in de buurt kan die lezen zonder te verbinden. Deze methode heet een beacon, en het open BTHome-formaat dat Home Assistant herkent, werkt op dezelfde manier. Gaat de ESP32 na elke meting in deep sleep, dan loopt de batterijduur op tot maanden; zie ESP32 Deep Sleep voor hoe dat werkt.

ESP32 Bluetooth met de iPhone (iOS)

De vraag die iPhone-gebruikers het vaakst stellen, is waarom de ESP32 niet in de Bluetooth-instellingen verschijnt. Apple opent het Classic Bluetooth-profiel voor de seriële poort (SPP) alleen voor MFi-gecertificeerde accessoires, dus je kunt met een iPhone niet verbinden met een ESP32 die BluetoothSerial draait. De oplossing is BLE, en de NUS- en sensorvoorbeelden hierboven werken prima op de iPhone. Een paar dingen om op te letten:

  • Zoeken in Instellingen: BLE-apparaten staan niet in de Bluetooth-instellingen van iOS; maak de verbinding in een app zoals nRF Connect, LightBlue of Bluefruit Connect.
  • Cache: iOS onthoudt de naam en de servicelijst van het apparaat. Zie je na het wijzigen van de services in je code nog steeds de oude lijst, zet dan Bluetooth op de telefoon uit en weer aan.
  • Geen MAC-adres: iOS toont apps het MAC-adres van het apparaat niet en geeft elk apparaat een eigen identifier; gebruik je meerdere ESP32's, geef ze dan elk een andere naam.
  • Verbindingsinterval: verwijder de regels setMinPreferred(0x06) en setMaxPreferred(0x12) niet; de voorbeelden van Espressif raden ze ook aan tegen verbindingsproblemen met iPhones.
  • Je eigen app: op iOS gebruik je Core Bluetooth met Swift; koppelen is niet nodig en de app scant direct op de UUID van de service.

BLE met de Raspberry Pi Pico W en MicroPython

Raspberry Pi Pico-board
In de Raspberry Pi Pico-familie zit Bluetooth alleen op de boards met een W in de naam (Pico W, Pico 2 W); de standaard Pico heeft geen draadloze verbinding.

In de Raspberry Pi Pico-familie is Bluetooth alleen beschikbaar op de Pico W en Pico 2 W. De ingebouwde CYW43439-chip ondersteunt in hardware zowel Classic Bluetooth als BLE, maar MicroPython gebruikt alleen BLE (vanaf versie 1.20). De code hieronder is het MicroPython-equivalent van het ESP32 NUS-voorbeeld; omdat hij dezelfde UUID's gebruikt, test je hem op dezelfde manier met nRF Connect en Serial Bluetooth Terminal. Je moet de MicroPython-build voor de Pico W hebben geflasht. De code leest ook de interne temperatuursensor van het board uit en stuurt de waarde elke 2 seconden naar de verbonden telefoon.

MicroPython
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)

Omdat de module bluetooth van MicroPython laag-niveau is, bouwen we het advertising-pakket zelf op. Elk veld bestaat uit een lengtebyte, een typebyte en de data: 0x01 zijn de flags, 0x09 de volledige naam van het apparaat en 0x07 de 128-bits service-UUID. Omdat een advertising-pakket maximaal 31 bytes bevat, zetten we het UUID-veld van 18 bytes in de scan response (resp_data). gatts_register_services() geeft de handles van de characteristics terug; met die handles lezen we de waarde die de telefoon heeft geschreven en versturen we meldingen. Wil je kortere code, installeer dan met mip de op asyncio gebaseerde bibliotheek aioble. Om de code onder MicroPython op de ESP32 te draaien, verander je alleen de LED-regel in Pin(2, Pin.OUT) en lees je bijvoorbeeld een DHT11 uit in plaats van de interne temperatuursensor.

Wi-Fi en Bluetooth samen: geheugen, bereik en stroom

Op de ESP32 delen Wi-Fi en Bluetooth dezelfde 2,4 GHz-radio. De chip draait beide in tijdsverdeling, dus je kunt ze tegelijk gebruiken, maar ze worden allebei iets trager, en Classic Bluetooth in combinatie met zwaar Wi-Fi-verkeer is het lastigste scenario. Het echte probleem is meestal het geheugen: de Bluetooth-stack is groot en samen met Wi-Fi kan het programma de standaard app-partitie van 1,2 MB (1.310.720 bytes) overschrijden; zelfs het BLE-voorbeeld in deze gids vult al ongeveer 80% van die ruimte. Eindigt de build met "Sketch too big" of "text section exceeds available space in board" en gebruik je geen updates over the air (OTA), kies dan onder Tools > Partition Scheme voor Huge APP (3MB No OTA/1MB SPIFFS). De bibliotheek NimBLE-Arduino, die minder flash en RAM gebruikt, is ook een goed alternatief.

Het bereik hangt af van het antenneontwerp van het board en de omgeving. Met een ESP32 met ingebouwde printplaatantenne kun je binnenshuis 10–20 meter verwachten, afhankelijk van de muren, en meer in open ruimte; modules met een aansluiting voor een externe antenne (bijvoorbeeld de ESP32-WROOM-32U) halen nog meer. Als je de antenne afdekt met een metalen doos, een batterij of kabels, daalt het bereik sterk. Omdat de stroom even stijgt wanneer de radio inschakelt, kan een zwakke USB-kabel ervoor zorgen dat het board herstart met de melding "Brownout detector was triggered"; de oplossingen vind je in ESP32 Brownout en Guru Meditation.

Projectideeën voor ESP32 Bluetooth

  • Bluetooth-robotauto: geef de commando's F, B, L en R die je via BluetoothSerial ontvangt door aan een L298N-motordriver; voor de mechanica, zie Een Arduino-robotauto bouwen.
  • Slim stopcontact: vervang de LED in het NUS-voorbeeld door een relaismodule en zet vanaf je iPhone een lamp aan.
  • Draadloze thermometer: voeg een OLED-display toe aan het DHT22-voorbeeld, zodat de waarde zowel op het scherm als op je telefoon verschijnt.
  • Kleurrijke sfeerverlichting: verander de kleur van een WS2812B NeoPixel-strip met R-, G- en B-waarden vanaf je telefoon.
  • Je eigen Android-app: bouw in een paar uur een afstandsbedieningsapp met knoppen en schuifregelaars in App Inventor.
  • Communicatie tussen twee ESP32's: wil je twee boards zonder telefoon laten praten, probeer dan het eenvoudigere en snellere ESP-NOW in plaats van Bluetooth.

Veelvoorkomende ESP32 Bluetooth-problemen en oplossingen

Symptoom / foutOorzaakOplossing
"Serial Bluetooth not available or not enabled"Het gekozen board is een ESP32-S3, C3, C6 of H2, die geen Classic Bluetooth hebbenGebruik een klassieke ESP32 of stap over op het BLE-voorbeeld (NUS)
"conversion from 'String' to non-scalar type 'std::string' requested"Code geschreven voor core 2.x (std::string) gecompileerd op een 3.x-coreWijs getValue().c_str() toe aan een String-variabele
"Sketch too big"Bluetooth plus Wi-Fi overschreed de app-partitiePartition Scheme: kies Huge APP of gebruik NimBLE-Arduino
De iPhone vindt de ESP32 nietClassic Bluetooth (SPP) wordt op iOS niet ondersteundGebruik BLE en maak de verbinding in een app
Het apparaat verdwijnt na de eerste verbindingAdvertising is na het verbreken niet opnieuw gestartRoep startAdvertising() aan na een verbreking
Er komen geen meldingen binnenMeldingen zijn niet ingeschakeld op de telefoon, of BLE2902 ontbreektTik op de drie pijltjes in nRF Connect; voeg BLE2902 toe aan de characteristic
"read failed, socket might closed or timeout"Verouderde koppelgegevens, of een andere telefoon is al verbondenVerwijder het apparaat op de telefoon en koppel opnieuw; SPP accepteert maar één verbinding tegelijk
Het einde van een lang bericht wordt afgekaptDe standaard-MTU is 23 bytes, dus 20 bytes data per meldingSplits het bericht in stukken van 20 bytes of sta een grotere MTU toe met BLEDevice::setMTU(185)
Wijzigingen in services verschijnen niet op de telefoonDe telefoon bewaart de oude GATT-tabel in zijn cacheZet Bluetooth op de telefoon uit en aan; verwijder het apparaat op Android
Kies bij het oplossen van verbindingsproblemen onder Tools > Core Debug Level voor Debug of Verbose. De Serial Monitor toont dan de logs van verbinden, verbreken en fouten van de Bluetooth-stack, waaraan je snel ziet of het probleem bij de telefoon of bij de ESP32 ligt. Dezelfde test herhalen met nRF Connect op de telefoon laat ook zien of je eigen app de oorzaak is.

Met ESP32 Bluetooth maak je met een paar regels code van je telefoon een afstandsbediening en van de ESP32 een draadloze sensor of slim apparaat. BluetoothSerial is de juiste keuze voor een snelle start met Android, en BLE voor ondersteuning van de iPhone en laag verbruik. Wil je doorgaan met draadloze ESP32-projecten, dan heeft de BlueGrays-app projecten zoals LED's, RGB-LED's, temperatuurmeting met de DHT22 en een Bluetooth-bestuurde auto, elk met een stap-voor-stap schakelschema en kant-en-klare code.

Veelgestelde vragen

Heeft de ESP32 Bluetooth?

Ja. De originele ESP32-chip ondersteunt zowel Classic Bluetooth (BR/EDR) als BLE met Bluetooth 4.2 en heeft geen extra module nodig. De ESP32-S3, C3, C6 en H2 ondersteunen alleen BLE, en de ESP32-S2 heeft helemaal geen Bluetooth.

Wat is het bereik van ESP32 Bluetooth?

Met een ESP32 met ingebouwde printplaatantenne haal je binnenshuis meestal 10–20 meter; muren, metalen voorwerpen en de richting van de antenne beïnvloeden die afstand. In open ruimte is het bereik groter, en modules met een externe antenne (bijvoorbeeld de WROOM-32U) halen nog meer.

Kan de ESP32 via Bluetooth verbinden met een iPhone?

Ja via BLE, maar niet via Classic Bluetooth (BluetoothSerial), omdat iOS het profiel voor de seriële poort (SPP) alleen opent voor MFi-gecertificeerde accessoires. Op de iPhone kun je met een app zoals nRF Connect, LightBlue of Bluefruit Connect verbinden met de BLE-service van de ESP32.

Werkt BluetoothSerial op de ESP32-S3 en ESP32-C3?

Nee. Deze chips hebben geen Classic Bluetooth-hardware, dus BluetoothSerial compileert niet. Voor dezelfde logica van een seriële poort over BLE kun je de Nordic UART Service (NUS) gebruiken; apps zoals Serial Bluetooth Terminal herkennen die.

Kan de ESP32 Wi-Fi en Bluetooth tegelijk gebruiken?

Ja, ze werken samen door dezelfde 2,4 GHz-radio in tijdsverdeling te delen. De snelheid daalt wel een beetje en het programma wordt groter; krijg je de fout "Sketch too big", kies dan onder Partition Scheme voor Huge APP of gebruik de lichtere bibliotheek NimBLE-Arduino.

Heb ik een HC-05 nodig bij de ESP32?

Meestal niet. De bibliotheek BluetoothSerial op de klassieke ESP32 doet intern het werk van de HC-05 en werkt met dezelfde terminal-apps. Een HC-05 heb je alleen nodig bij boards zonder Bluetooth (Arduino Uno, ESP8266, de standaard Pico, ESP32-S2) of als een project Classic Bluetooth vereist en je een ESP32 met alleen BLE gebruikt.

Alle projecten bekijken
Ingebouwde led van de ESP32 laten knipperen
ES-4Beginner

Ingebouwde led van de ESP32 laten knipperen

De ingebouwde blauwe led op de ESP32 DevKit V1 laten knipperen. Geen externe componenten nodig! Het eerste project dat je moet proberen als je een ESP32 koopt. GPIO 2 is verbonden met de ingebouwde led.

4.8(29)
54
Led laten knipperen met ESP32
ES-1Beginner

Led laten knipperen met ESP32

Leert je het basisgebruik van een GPIO-uitgang met de ESP32. Door een led via een digitale pin aan en uit te zetten krijgen we een knippereffect. Dit is de ESP32-versie van het klassieke blinkproject op de Arduino UNO; de basiscommando's in de Arduino-omgeving zijn hetzelfde, maar de pinindeling en de 3,3 V-GPIO-niveaus van de ESP32 verschillen van die van de Arduino UNO.

4.7(37)
108
ESP32-ledbesturing met drukknop (Toggle)
ES-3Beginner

ESP32-ledbesturing met drukknop (Toggle)

Elke keer dat je op de knop drukt, verandert de led van stand: is hij aan, dan gaat hij uit; is hij uit, dan gaat hij aan. Het klassieke togglepatroon. Met debounce filteren we de mechanische ruis van de drukknop weg, zodat één druk precies één wisseling geeft.

4.6(39)
59
LED bedienen met je telefoon via Bluetooth
AR-34Beginner
Premium

LED bedienen met je telefoon via Bluetooth

Een kleine oefening voor het aan- en uitzetten van de lampen in je kamer met je telefoon.

4.8(69)
91
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

Auto met Bluetooth-besturing en L298N

Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

5.0(39)
66
ESP32 RGB-led aansturen
ES-9Beginner

ESP32 RGB-led aansturen

Onbeperkt kleuren maken met één RGB-led in plaats van 3 aparte leds. Net als op Arduino stel je met analogWrite() de R/G/B-waarden in en maak je een regenboogovergang. Kleurtheorie (zoals red+green=yellow) zie je in de praktijk.

4.6(29)
52
ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
ES-15Gemiddeld

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)

Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

4.8(38)
57
ESP32 WS2812B NeoPixel-strip aansturen
ES-24Gemiddeld
Premium

ESP32 WS2812B NeoPixel-strip aansturen

WS2812B-leds (NeoPixel) zijn adresseerbare slimme RGB-leds die je kunt doorlussen en via één datapin kunt aansturen. In dit project sturen we een WS2812B-strip met 8 leds aan met de Adafruit_NeoPixel-bibliotheek en maken we een vloeiende regenbooganimatie. De 3,3V-logica van de ESP32 werkt met de meeste WS2812B-batches; wordt het instabiel, dan laten we de oplossing zien met een serieweerstand van 470Ω en een condensator van 1000µF. De animatie schuift de tint op in de HSV-kleurruimte.

4.9(19)
30