ESP32 Bluetooth Handy-Klavier
Mach dein Handy zum Klavier mit 8 Tasten: Auf Tastendruck spielt ein passiver Summer am ESP32 den Ton, ohne Internet oder WLAN. Das ist die Schritt-für-Schritt-Anleitung zur Bluetooth-Vorlage Handy-Klavier der App, gebaut mit Summer und zwei Jumperkabeln. Geh zu Werkstatt › Geräte › Gerät hinzufügen › Bluetooth, wähl Handy-Klavier und lade den Code mit Code holen hoch. Die Taste Als Bluetooth-Panel einrichten auf dieser Seite startet denselben Assistenten.

Video
Schaltplan

Quellcode
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32 │
4// │ BG-Piyano │
5// └───────────────────────────┘
6// Handy-Klavier
7// Board in der Arduino IDE: ESP32 Dev Module
8// die BLE-Bibliothek kommt mit dem ESP32-Boardpaket, nichts extra zu installieren
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13
14const char BLE_NAME[] = "BG-Piyano"; // das Board sendet unter diesem Namen, die App findet es damit in der Liste
15
16// Pins: hier ändern, wenn du anders verkabelt hast
17const int BUZZER_PIN = 25; // nimm einen passiven Summer (ein aktiver kann nur einen Ton)
18
19void btWrite(const char *text);
20void onValue(const char *key, const char *value);
21void sendAll();
22void onLinkLost();
23
24// ── Die App sendet Zeilen im Format "Schlüssel=Wert"; bei "?" schickt das Board alle Werte ──
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"); // die Zeile "@v" meldet der App die Codeversion
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// eingehende Bytes gelangen über einen kleinen Ringpuffer vom Bluetooth-Task in 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// Zeilen gehen in 20-Byte-Paketen raus (klappt mit jedem Handy)
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" spielt den Ton, "nota=0" stoppt ihn
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); // Verbindung weg: der Ton verstummt
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}
180FAQ
Klappt das mit dem iPhone?
Ja. Das eingebaute Bluetooth Low Energy (BLE) des ESP32 spricht mit iPhone und Android. Ein iPhone kann sich nicht mit klassischen Bluetooth-Modulen wie HC-05 und HC-06 verbinden, die brauchst du hier aber auch nicht. Versuch nicht, das Board in den Bluetooth-Einstellungen des Handys zu koppeln; BLE-Boards tauchen dort oft gar nicht auf, das ist normal. Die Verbindung stellt die BlueGrays-App her.
Was ist der Unterschied zwischen aktivem und passivem Summer, und welchen brauche ich?
Du brauchst einen passiven Summer. Ein passiver Summer arbeitet wie ein winziger Lautsprecher: Er spielt die Frequenz, die du ihm schickst. Ein aktiver Summer hat eine eigene Schaltung eingebaut und gibt immer denselben festen Ton von sich, sobald er Spannung bekommt; die Tasten lassen sich damit nicht unterscheiden. Welchen du hast, zeigt dir dieses Projekt: Spielen die Tasten verschiedene Töne, ist er passiv, klingt jede Taste gleich schnarrend, ist er aktiv. Achte beim Kauf auf das Wort passiv (passive) im Produktnamen.
Kann ich zwei Tasten gleichzeitig drücken und einen Akkord spielen?
Nein. Ein Summer kann immer nur eine Frequenz spielen, und der tone-Befehl auf dem Board erzeugt einen einzelnen Ton. Drückst du zwei Tasten zusammen, überlagern sich die Töne nicht; das Board spielt nur den Ton, der zuletzt angekommen ist. Spiel Melodien Ton für Ton. Die Taste Im Vollbild spielen im Panel macht die Tasten größer, und dort kannst du auch mit dem Finger über die Tasten gleiten und von Ton zu Ton wechseln.
Kann ich andere Töne oder mehr Tasten hinzufügen?
Die acht Tasten im Panel sind fest: vom tiefen bis zum hohen C, ohne Halbtöne, und in der App lassen sich keine Tasten ergänzen. Die Board-Seite ist dagegen flexibel: Der Code spielt jede positive Zahl, die vom Handy kommt, als Frequenz und verstummt bei 0. Du kannst den Klang also im Code ändern; multiplizierst du zum Beispiel die ankommende Frequenz mit zwei, rückt das ganze Klavier eine Oktave höher.
