ESP32 Bluetooth-telefoonpiano
Verander je telefoon in een piano met 8 toetsen: druk op een toets en een passieve buzzer op de ESP32 speelt die noot, zonder internet of Wi-Fi. Dit is de gids bij het Bluetooth-sjabloon Telefoonpiano, gebouwd met een buzzer en twee jumperdraden. Ga naar Werkplaats › Apparaten › Apparaat toevoegen › Bluetooth, kies Telefoonpiano en upload de code met Code ophalen. Instellen als Bluetooth-paneel opent de wizard ook.

Video
Schakelschema

Broncode
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32 │
4// │ BG-Piyano │
5// └───────────────────────────┘
6// Telefoonpiano
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-Piyano"; // 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 BUZZER_PIN = 25; // gebruik een passieve buzzer (een actieve geeft maar één toon)
18
19void btWrite(const char *text);
20void onValue(const char *key, const char *value);
21void sendAll();
22void onLinkLost();
23
24// ── De app stuurt regels "sleutel=waarde"; bij "?" stuurt het board al zijn waarden ──
25char line[65];
26uint8_t lineLen = 0;
27unsigned long lastRxMs = 0;
28
29bool is(const char *a, const char *b) { return strcmp(a, b) == 0; }
30bool isOn(const char *v) { return v[0] == '1'; }
31
32void sendText(const char *key, const char *value) {
33 char out[72];
34 snprintf(out, sizeof(out), "%s=%s\n", key, value);
35 btWrite(out);
36}
37
38void sendInt(const char *key, long value) {
39 char text[12];
40 snprintf(text, sizeof(text), "%ld", value);
41 sendText(key, text);
42}
43
44void sendFloat(const char *key, float value) {
45 char text[16];
46 dtostrf(value, 1, 1, text);
47 sendText(key, text);
48}
49
50void handleLine(char *text) {
51 char *eq = strchr(text, '=');
52 if (eq == nullptr) {
53 if (text[strlen(text) - 1] == '?') {
54 btWrite("@v=1.0\n"); // de regel "@v" geeft de app de codeversie door
55 sendAll();
56 }
57 return;
58 }
59 *eq = '\0';
60 onValue(text, eq + 1);
61}
62
63void feed(char c) {
64 lastRxMs = millis();
65 if (c == '\n' || c == '\r') {
66 if (lineLen == 0) return;
67 line[lineLen] = '\0';
68 lineLen = 0;
69 handleLine(line);
70 } else if (lineLen < sizeof(line) - 1) {
71 line[lineLen++] = c;
72 }
73}
74
75// ── Bluetooth (Nordic UART) ──
76#define UART_SERVICE "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
77#define UART_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
78#define UART_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
79
80BLECharacteristic *txChar = nullptr;
81volatile bool linked = false;
82volatile bool linkLost = false;
83// binnenkomende bytes gaan via een kleine ringbuffer van de Bluetooth-taak naar loop()
84const int RX_SIZE = 256;
85volatile uint8_t rxBuf[RX_SIZE];
86volatile int rxHead = 0, rxTail = 0;
87
88class ServerEvents : public BLEServerCallbacks {
89 void onConnect(BLEServer *server) override { linked = true; }
90 void onDisconnect(BLEServer *server) override { linked = false; linkLost = true; }
91};
92
93class RxEvents : public BLECharacteristicCallbacks {
94 void onWrite(BLECharacteristic *c) override {
95 auto v = c->getValue();
96 for (size_t i = 0; i < v.length(); i++) {
97 int next = (rxHead + 1) % RX_SIZE;
98 if (next == rxTail) break;
99 rxBuf[rxHead] = (uint8_t)v[i];
100 rxHead = next;
101 }
102 }
103};
104
105// regels worden in pakketten van 20 bytes verstuurd (werkt met elke telefoon)
106void btWrite(const char *text) {
107 if (!linked || txChar == nullptr) return;
108 size_t n = strlen(text);
109 for (size_t i = 0; i < n; i += 20) {
110 size_t len = n - i < 20 ? n - i : 20;
111 txChar->setValue((uint8_t *)text + i, len);
112 txChar->notify();
113 delay(4);
114 }
115}
116
117void btBegin() {
118 BLEDevice::init(BLE_NAME);
119 BLEServer *server = BLEDevice::createServer();
120 server->setCallbacks(new ServerEvents());
121 BLEService *uart = server->createService(UART_SERVICE);
122 txChar = uart->createCharacteristic(UART_TX, BLECharacteristic::PROPERTY_NOTIFY);
123 txChar->addDescriptor(new BLE2902());
124 BLECharacteristic *rx = uart->createCharacteristic(UART_RX, BLECharacteristic::PROPERTY_WRITE | BLECharacteristic::PROPERTY_WRITE_NR);
125 rx->setCallbacks(new RxEvents());
126 uart->start();
127 BLEAdvertisementData adv;
128 adv.setFlags(0x06);
129 adv.setCompleteServices(BLEUUID(UART_SERVICE));
130 BLEAdvertisementData scan;
131 scan.setName(BLE_NAME);
132 BLEAdvertising *advertising = BLEDevice::getAdvertising();
133 advertising->setAdvertisementData(adv);
134 advertising->setScanResponseData(scan);
135 BLEDevice::startAdvertising();
136}
137
138void btPoll() {
139 while (rxTail != rxHead) {
140 char c = (char)rxBuf[rxTail];
141 rxTail = (rxTail + 1) % RX_SIZE;
142 feed(c);
143 }
144 if (linkLost) {
145 linkLost = false;
146 onLinkLost();
147 delay(100);
148 BLEDevice::startAdvertising();
149 }
150}
151
152// ── ESP32 ──
153void onValue(const char *key, const char *value) {
154 if (is(key, "nota")) { // "nota=Hz" speelt de noot, "nota=0" stopt hem
155 int hz = atoi(value);
156 if (hz > 0) tone(BUZZER_PIN, hz);
157 else noTone(BUZZER_PIN);
158 }
159}
160
161void sendAll() {
162 sendInt("nota", 0);
163}
164
165void onLinkLost() {
166 noTone(BUZZER_PIN); // Verbinding verbroken: het geluid stopt
167}
168
169void setup() {
170 Serial.begin(115200);
171 pinMode(BUZZER_PIN, OUTPUT);
172 btBegin();
173 Serial.print(F("BlueGrays Bluetooth: "));
174 Serial.println(BLE_NAME);
175}
176
177void loop() {
178 btPoll();
179}
180Veelgestelde vragen
Werkt het met een iPhone?
Ja. De ingebouwde Bluetooth Low Energy (BLE) van de ESP32 werkt met zowel iPhone als Android. Een iPhone kan geen verbinding maken met klassieke Bluetooth-modules zoals de HC-05 en HC-06, en die heb je in dit project ook 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.
Wat is het verschil tussen een actieve en een passieve buzzer en welke heb ik nodig?
Je hebt een passieve buzzer nodig. Een passieve buzzer werkt als een piepklein luidsprekertje: hij speelt elke frequentie die je hem stuurt. Een actieve buzzer heeft een eigen schakeling en maakt steeds hetzelfde vaste geluid zodra hij stroom krijgt, dus de toetsen zijn niet van elkaar te onderscheiden. Dit project laat zien welke je hebt: spelen de toetsen verschillende noten, dan is hij passief; geeft elke toets hetzelfde zoemgeluid, dan is hij actief. Zoek bij het kopen naar het woord passive in de productnaam.
Kan ik twee toetsen tegelijk indrukken en een akkoord spelen?
Nee. Een buzzer kan maar één frequentie tegelijk spelen en het tone-commando op het board maakt één noot. Druk je twee toetsen tegelijk in, dan worden de noten niet gestapeld; het board speelt alleen de laatst ontvangen noot. Speel melodieën noot voor noot. De knop Volledig scherm spelen in het paneel maakt de toetsen groter, en daar kun je ook met je vinger over de toetsen glijden om van noot naar noot te glijden.
Kan ik andere noten of meer toetsen toevoegen?
De acht toetsen in het paneel liggen vast: lage C tot hoge C, zonder kruisen of mollen, en vanuit de app kun je geen toetsen toevoegen. De kant van het board is wel flexibel: de code speelt elk positief getal van de telefoon als frequentie af en zwijgt bij 0. Je kunt het geluid dus in de code aanpassen; vermenigvuldig bijvoorbeeld de binnenkomende frequentie met twee en de hele piano gaat een octaaf omhoog.
