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?.

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.
| Eigenschap | Bluetooth Classic (SPP) | Bluetooth Low Energy (BLE) |
|---|---|---|
| Arduino-bibliotheek | BluetoothSerial (zit in het ESP32-pakket) | BLEDevice (zit in het ESP32-pakket) of NimBLE-Arduino |
| Datamodel | Continue bytestroom, zoals een seriële poort | GATT-tabel met services en characteristics |
| Hoeveelheid data | Hoog, geschikt voor continue datastromen | Kleine pakketjes; standaard 20 bytes per melding |
| Stroomverbruik | Constant hoog zolang er verbinding is | Zeer laag; kan maandenlang op een batterij draaien |
| Koppelen | Gebeurt in de Bluetooth-instellingen van de telefoon | Niet nodig; de verbinding wordt in de app gemaakt |
| Android | Ondersteund | Ondersteund |
| iPhone (iOS) | Niet ondersteund | Ondersteund |
| Ondersteunde ESP32's | Alleen de originele ESP32 (WROOM-32, WROVER) | ESP32, S3, C3, C6 en H2 (niet S2) |
| Typisch gebruik | Seriële terminal, robotauto, vervanging van de HC-05 | Sensoren, 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 / chip | Bluetooth Classic | BLE | Opmerking |
|---|---|---|---|
| ESP32 (WROOM-32, WROVER, DevKit V1) | Ja | Ja (4.2) | De enige ESP32-variant waarop BluetoothSerial draait |
| ESP32-S2 | Nee | Nee | Alleen Wi-Fi |
| ESP32-S3 | Nee | Ja (Bluetooth 5) | BluetoothSerial compileert niet, gebruik BLE |
| ESP32-C3 | Nee | Ja (Bluetooth 5) | Kleine, goedkope BLE-boards |
| ESP32-C6 | Nee | Ja (Bluetooth 5) | Heeft ook Wi-Fi 6, Zigbee en Thread |
| ESP32-H2 | Nee | Ja (Bluetooth 5) | Geen Wi-Fi; gericht op Zigbee en Thread |
| ESP8266 (NodeMCU, Wemos D1) | Nee | Nee | Voor Bluetooth heb je een HC-05 of HM-10 nodig |
| Raspberry Pi Pico W / Pico 2 W | In hardware | Ja | MicroPython ondersteunt alleen BLE |
| Raspberry Pi Pico / Pico 2 | Nee | Nee | Heeft een externe Bluetooth-module nodig |
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:
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
- Open na het uploaden de Serial Monitor op 115200 baud en zoek de melding "Eslesmeye hazir / Ready to pair".
- 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.
- Installeer de app Serial Bluetooth Terminal van Kai Morich uit Google Play.
- Open in de app via het zijmenu Devices en kies BlueGrays-ESP32 op het tabblad Bluetooth Classic.
- Tik op het stekkericoon in de bovenbalk; zodra "Connected" in beeld verschijnt, ben je verbonden.
- 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.
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.
| Term | Betekenis | Voorbeeld in deze gids |
|---|---|---|
| Advertising | Kort pakket waarin het apparaat zijn naam en services bekendmaakt | Advertising onder de naam "BlueGrays-BLE" |
| Service | Groep die bij elkaar horende characteristics bundelt | Nordic UART-service, Environmental Sensing (0x181A) |
| Characteristic | Een enkele waarde die wordt gelezen of geschreven | LED-commando, temperatuur (0x2A6E) |
| READ | De telefoon leest de waarde wanneer hij wil | Laatst gemeten temperatuur |
| WRITE / WRITE_NR | De telefoon schrijft een waarde (met of zonder antwoord) | Door "1" te schrijven gaat de LED aan |
| NOTIFY | De ESP32 meldt zelf aan de telefoon dat de waarde is veranderd | Elke 2 seconden een nieuwe temperatuur |
| Descriptor 0x2902 (CCCD) | Schakelaar die meldingen aan- en uitzet | Knop met drie pijltjes in nRF Connect |
| UUID | ID-nummer van services en characteristics | 6E400001-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 / characteristic | UUID | Gegevensformaat |
|---|---|---|
| Battery Service / Battery Level | 0x180F / 0x2A19 | 1 byte, procent (0–100) |
| Environmental Sensing / Temperature | 0x181A / 0x2A6E | 2 bytes, geheel getal met teken, 0,01 °C |
| Environmental Sensing / Humidity | 0x181A / 0x2A6F | 2 bytes, geheel getal zonder teken, 0,01% |
| Heart Rate / Heart Rate Measurement | 0x180D / 0x2A37 | Flags-byte + hartslagwaarde |
| Nordic UART Service (NUS) | 6E400001-B5A3-F393-E0A9-E50E24DCCA9E | RX 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.
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.
BLE stap voor stap testen met nRF Connect
- Installeer de gratis app nRF Connect for Mobile van Nordic Semiconductor op je telefoon; hij is er voor Android en iPhone.
- 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.
- 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.
- Tik op CONNECT. Het scherm dat opent toont de Nordic UART Service; had je zelfgegenereerde UUID's gebruikt, dan stond hier "Unknown Service".
- Tik op het icoon met de drie pijlen omlaag naast de TX-characteristic (6E400003) om meldingen in te schakelen.
- 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-pin | ESP32 | Opmerking |
|---|---|---|
| VCC (+) | 3V3 | Werkt op 3,3 tot 5 V |
| DATA (OUT) | GPIO 4 | Voeg bij een kale sensor een weerstand van 10 kΩ toe tussen DATA en 3V3 |
| GND (−) | GND | Gemeenschappelijke 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.
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.
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

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.
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 / fout | Oorzaak | Oplossing |
|---|---|---|
| "Serial Bluetooth not available or not enabled" | Het gekozen board is een ESP32-S3, C3, C6 of H2, die geen Classic Bluetooth hebben | Gebruik 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-core | Wijs getValue().c_str() toe aan een String-variabele |
| "Sketch too big" | Bluetooth plus Wi-Fi overschreed de app-partitie | Partition Scheme: kies Huge APP of gebruik NimBLE-Arduino |
| De iPhone vindt de ESP32 niet | Classic Bluetooth (SPP) wordt op iOS niet ondersteund | Gebruik BLE en maak de verbinding in een app |
| Het apparaat verdwijnt na de eerste verbinding | Advertising is na het verbreken niet opnieuw gestart | Roep startAdvertising() aan na een verbreking |
| Er komen geen meldingen binnen | Meldingen zijn niet ingeschakeld op de telefoon, of BLE2902 ontbreekt | Tik 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 verbonden | Verwijder het apparaat op de telefoon en koppel opnieuw; SPP accepteert maar één verbinding tegelijk |
| Het einde van een lang bericht wordt afgekapt | De standaard-MTU is 23 bytes, dus 20 bytes data per melding | Splits het bericht in stukken van 20 bytes of sta een grotere MTU toe met BLEDevice::setMTU(185) |
| Wijzigingen in services verschijnen niet op de telefoon | De telefoon bewaart de oude GATT-tabel in zijn cache | Zet Bluetooth op de telefoon uit en aan; verwijder het apparaat op Android |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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.

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.

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

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…

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.

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.

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.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

