ES-114Anfänger

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.

0.0(0)
ESP32 Bluetooth Handy-Klavier
Drück eine Taste auf dem Handy, und der Summer am ESP32 spielt ein C; lass los, und er verstummt: ohne Internet, Router oder Server. Der ESP32 hat Bluetooth an Bord, das Handy verbindet sich direkt mit ihm. Acht Tasten reichen vom tiefen bis zum hohen C. Beim Drücken sendet das Handy die Frequenz des Tons (262 Hz für das tiefe C), beim Loslassen eine 0. Reißt die Verbindung ab, verstummt das Board von selbst. Die Schaltung: ein passiver Summer, zwei Kabel, kein Steckbrett. Wähl in der App Bluetooth und die Vorlage Handy-Klavier, lade den Code mit Code holen hoch und finde dein Board in der Liste. Du lernst: Bluetooth Low Energy mit kurzen Textzeilen, Frequenz als Tonhöhe, passiver und aktiver Summer im Vergleich.

Video

Schaltplan

ESP32 Bluetooth Handy-Klavier - Schaltplan

Quellcode

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

FAQ

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.