ES-108Beginner

ESP32 Bluetooth-led en relais

Schakel een LED en een relais via Bluetooth aan en uit vanaf je telefoon, zonder internet of wifi. Dit project is de stap-voor-stapgids bij het Bluetooth-sjabloon LED and relay in de app, gebouwd met een ESP32 en een 5V-relaismodule. Ga naar Werkplaats › Apparaten › Apparaat toevoegen › Bluetooth, kies Led en relais en upload de code via Code ophalen. De knop Instellen als Bluetooth-paneel op deze pagina opent de wizard ook met dit sjabloon.

0.0(0)
ESP32 Bluetooth-led en relais
Tik op een schakelaar op je telefoon en het relais op je bureau klikt: geen internet, geen router, geen server ertussen. De ESP32 heeft Bluetooth ingebouwd, dus je telefoon verbindt direct met het board en twee schakelaars in het paneel bedienen de led en het relais. Als het paneel opent, meldt het board zijn echte status, dus wat je op het scherm ziet, is wat het board doet. Voeg in de app een nieuw apparaat toe, kies Bluetooth en het sjabloon Led en relais, upload de code via Code ophalen en zoek dan je board in de lijst. De knop op deze pagina brengt je naar dezelfde installatie. Je leert: praten via Bluetooth Low Energy met korte tekstregels, een relais dat bij LOW schakelt en een board dat zijn status aan het paneel meldt. Opmerking over het relais: dit board werkt op 3,3 V. Gebruik een relaismodule met optocoupler die met een 3,3V-signaal kan worden aangestuurd; 5V-modules zonder optocoupler schakelen met een 3,3V-signaal mogelijk niet uit.

Video

Schakelschema

ESP32 Bluetooth-led en relais - Schakelschema

Broncode

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Lamba                  │
5// └───────────────────────────┘
6// Led en relais
7// Board in de Arduino IDE: ESP32 Dev Module
8// de BLE-bibliotheek zit in het ESP32-boardpakket, je hoeft niets extra te installeren
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13
14const char BLE_NAME[] = "BG-Lamba";  // het board zendt deze naam uit, de app herkent het in de lijst aan deze naam
15
16// Pinnen: pas ze hier aan als je anders hebt aangesloten
17const int LED_PIN = 2;
18const int RELAY_PIN = 26;
19const bool RELAY_ACTIVE_LOW = true;  // de meeste relaismodules schakelen in bij LOW
20
21void btWrite(const char *text);
22void onValue(const char *key, const char *value);
23void sendAll();
24void onLinkLost();
25
26// ── De app stuurt regels "sleutel=waarde"; bij "?" stuurt het board al zijn waarden ──
27char line[65];
28uint8_t lineLen = 0;
29unsigned long lastRxMs = 0;
30
31bool is(const char *a, const char *b) { return strcmp(a, b) == 0; }
32bool isOn(const char *v) { return v[0] == '1'; }
33
34void sendText(const char *key, const char *value) {
35  char out[72];
36  snprintf(out, sizeof(out), "%s=%s\n", key, value);
37  btWrite(out);
38}
39
40void sendInt(const char *key, long value) {
41  char text[12];
42  snprintf(text, sizeof(text), "%ld", value);
43  sendText(key, text);
44}
45
46void sendFloat(const char *key, float value) {
47  char text[16];
48  dtostrf(value, 1, 1, text);
49  sendText(key, text);
50}
51
52void handleLine(char *text) {
53  char *eq = strchr(text, '=');
54  if (eq == nullptr) {
55    if (text[strlen(text) - 1] == '?') {
56      btWrite("@v=1.0\n");  // de regel "@v" geeft de app de codeversie door
57      sendAll();
58    }
59    return;
60  }
61  *eq = '\0';
62  onValue(text, eq + 1);
63}
64
65void feed(char c) {
66  lastRxMs = millis();
67  if (c == '\n' || c == '\r') {
68    if (lineLen == 0) return;
69    line[lineLen] = '\0';
70    lineLen = 0;
71    handleLine(line);
72  } else if (lineLen < sizeof(line) - 1) {
73    line[lineLen++] = c;
74  }
75}
76
77// ── Bluetooth (Nordic UART) ──
78#define UART_SERVICE "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
79#define UART_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
80#define UART_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
81
82BLECharacteristic *txChar = nullptr;
83volatile bool linked = false;
84volatile bool linkLost = false;
85// binnenkomende bytes gaan via een kleine ringbuffer van de Bluetooth-taak naar loop()
86const int RX_SIZE = 256;
87volatile uint8_t rxBuf[RX_SIZE];
88volatile int rxHead = 0, rxTail = 0;
89
90class ServerEvents : public BLEServerCallbacks {
91  void onConnect(BLEServer *server) override { linked = true; }
92  void onDisconnect(BLEServer *server) override { linked = false; linkLost = true; }
93};
94
95class RxEvents : public BLECharacteristicCallbacks {
96  void onWrite(BLECharacteristic *c) override {
97    auto v = c->getValue();
98    for (size_t i = 0; i < v.length(); i++) {
99      int next = (rxHead + 1) % RX_SIZE;
100      if (next == rxTail) break;
101      rxBuf[rxHead] = (uint8_t)v[i];
102      rxHead = next;
103    }
104  }
105};
106
107// regels worden in pakketten van 20 bytes verstuurd (werkt met elke telefoon)
108void btWrite(const char *text) {
109  if (!linked || txChar == nullptr) return;
110  size_t n = strlen(text);
111  for (size_t i = 0; i < n; i += 20) {
112    size_t len = n - i < 20 ? n - i : 20;
113    txChar->setValue((uint8_t *)text + i, len);
114    txChar->notify();
115    delay(4);
116  }
117}
118
119void btBegin() {
120  BLEDevice::init(BLE_NAME);
121  BLEServer *server = BLEDevice::createServer();
122  server->setCallbacks(new ServerEvents());
123  BLEService *uart = server->createService(UART_SERVICE);
124  txChar = uart->createCharacteristic(UART_TX, BLECharacteristic::PROPERTY_NOTIFY);
125  txChar->addDescriptor(new BLE2902());
126  BLECharacteristic *rx = uart->createCharacteristic(UART_RX, BLECharacteristic::PROPERTY_WRITE | BLECharacteristic::PROPERTY_WRITE_NR);
127  rx->setCallbacks(new RxEvents());
128  uart->start();
129  BLEAdvertisementData adv;
130  adv.setFlags(0x06);
131  adv.setCompleteServices(BLEUUID(UART_SERVICE));
132  BLEAdvertisementData scan;
133  scan.setName(BLE_NAME);
134  BLEAdvertising *advertising = BLEDevice::getAdvertising();
135  advertising->setAdvertisementData(adv);
136  advertising->setScanResponseData(scan);
137  BLEDevice::startAdvertising();
138}
139
140void btPoll() {
141  while (rxTail != rxHead) {
142    char c = (char)rxBuf[rxTail];
143    rxTail = (rxTail + 1) % RX_SIZE;
144    feed(c);
145  }
146  if (linkLost) {
147    linkLost = false;
148    onLinkLost();
149    delay(100);
150    BLEDevice::startAdvertising();
151  }
152}
153
154// ── ESP32 ──
155bool ledOn = false, relayOn = false;
156
157void setRelay(bool on) {
158  if (RELAY_ACTIVE_LOW) {
159    if (on) { pinMode(RELAY_PIN, OUTPUT); digitalWrite(RELAY_PIN, LOW); }
160    else { pinMode(RELAY_PIN, INPUT); }  // bij uit wordt de pin losgelaten: een HIGH van 3,3 V is niet genoeg om een 5V-module uit te zetten
161  } else {
162    pinMode(RELAY_PIN, OUTPUT); digitalWrite(RELAY_PIN, on ? HIGH : LOW);
163  }
164}
165
166void apply() {
167  digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
168  setRelay(relayOn);
169}
170
171void onValue(const char *key, const char *value) {
172  if (is(key, "led")) ledOn = isOn(value);
173  else if (is(key, "role")) relayOn = isOn(value);
174  apply();
175}
176
177void sendAll() {
178  sendInt("led", ledOn);
179  sendInt("role", relayOn);
180}
181
182void onLinkLost() {
183}
184
185void setup() {
186  Serial.begin(115200);
187  pinMode(LED_PIN, OUTPUT);
188  apply();
189  btBegin();
190  Serial.print(F("BlueGrays Bluetooth: "));
191  Serial.println(BLE_NAME);
192}
193
194void loop() {
195  btPoll();
196}
197

Veelgestelde vragen

Werkt het met een iPhone?

Ja. De ingebouwde Bluetooth Low Energy (BLE) van de ESP32 praat met zowel iPhone als Android. Een iPhone kan niet verbinden met klassieke Bluetooth-modules zoals de HC-05 en HC-06, en die heb je in dit project niet nodig. Probeer het board niet te koppelen in de Bluetooth-instellingen van je telefoon; BLE-boards verschijnen daar mogelijk niet, dat is normaal. De BlueGrays-app maakt de verbinding.

Kan ik een echte lamp op het relais aansluiten?

De relaismodule kan netspanning schakelen, maar netspanning kan dodelijk zijn. In dit project zit niets aan de COM- en NO-aansluitingen van het relais; het relais laat met zijn klik en de led op de module zien dat het werkt. Wil je een belasting proberen, begin dan met een laagspanningsschakeling, zoals een batterij of een 12V-adapter. Ga je naar netspanning, doe dat dan samen met iemand met ervaring, laat geen blote draden of schroeven onbedekt en blijf binnen de stroomwaarde die op de module staat.

Waarom brandt de blauwe LED op het board samen met mijn LED?

Op veel ESP32 DevKit-boards is de blauwe led op het board ook op GPIO2 aangesloten. Jouw led zit op dezelfde pin, dus beide knipperen samen; dit is geen fout. Het is zelfs handig: zit er een draad los, dan laat de blauwe led nog steeds zien dat het commando het board bereikte. Wil je dat niet, verplaats je led dan naar een andere pin (bijvoorbeeld GPIO4) en pas LED_PIN in de code aan.

Heb ik internet of Wi-Fi nodig en wat is het bereik?

Nee. Je telefoon maakt rechtstreeks verbinding met het board via Bluetooth, zonder router of server. Binnenshuis is het bereik meestal ongeveer 10 meter; muren verkorten dat. Het board maakt met één telefoon tegelijk verbinding. Zodra die telefoon weggaat, begint het board weer te adverteren en kan een andere telefoon verbinden. Wil je het van buiten je huis bedienen, kies dan een project dat het Wi-Fi-IoT-paneel in de app gebruikt.