ES-114Beginner

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.

0.0(0)
ESP32 Bluetooth-telefoonpiano
Druk op een toets op je telefoon en de buzzer op je bureau speelt een C; laat los en het wordt stil: geen internet, router of server ertussen. De ESP32 heeft Bluetooth ingebouwd, dus de telefoon verbindt er rechtstreeks mee. Acht toetsen lopen van lage C tot hoge C. Druk op een toets en de telefoon stuurt de frequentie van die noot (262 Hz voor lage C); laat je los, dan stuurt hij 0 voor stilte. Valt de verbinding weg, dan zwijgt het board vanzelf. De schakeling is één passieve buzzer en twee draden, zonder breadboard. Kies in de app Bluetooth en het sjabloon Telefoonpiano, upload de code met Code ophalen en zoek je board in de lijst. Je leert: Bluetooth Low Energy met korte tekstregels, hoe de frequentie de noot bepaalt en het verschil tussen passieve en actieve buzzers.

Video

Schakelschema

ESP32 Bluetooth-telefoonpiano - Schakelschema

Broncode

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

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