ES-114Principiante

ESP32 Bluetooth: piano en el móvil

Convierte tu móvil en un piano de 8 teclas: al pulsar una tecla, un zumbador pasivo en el ESP32 toca esa nota, sin internet ni wifi. Es la guía paso a paso de la plantilla Bluetooth Piano en el móvil de la app, montada con un zumbador y dos cables puente. Ve a Mi Taller › Dispositivos › Añadir dispositivo › Bluetooth, elige la plantilla y sube el código con Obtener el código. El botón Configurar como panel Bluetooth de esta página también abre el asistente.

0.0(0)
ESP32 Bluetooth: piano en el móvil
Pulsa una tecla en tu móvil y el zumbador de tu mesa toca un Do; suelta y se calla: sin internet, router ni servidor. El ESP32 lleva Bluetooth integrado, y el móvil se conecta directo a la placa. Ocho teclas van del Do grave al Do agudo. Al pulsar, el móvil envía la frecuencia de la nota (262 Hz para el Do grave); al soltar envía 0 y el sonido se corta. Si se pierde la conexión, la placa se calla sola. El circuito: un zumbador pasivo y dos cables, sin protoboard. En la app elige Bluetooth y la plantilla Piano en el móvil, sube el código con Obtener el código y busca tu placa en la lista. Aprendes: Bluetooth Low Energy con líneas de texto cortas, la frecuencia que define la nota y zumbador pasivo frente a activo.

Video

Diagrama del circuito

ESP32 Bluetooth: piano en el móvil - Diagrama del circuito

Código fuente

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Piyano                 │
5// └───────────────────────────┘
6// Piano en el móvil
7// Placa en Arduino IDE: ESP32 Dev Module
8// la biblioteca BLE viene con el paquete de placas ESP32, no hay que instalar nada más
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13
14const char BLE_NAME[] = "BG-Piyano";  // la placa se anuncia con este nombre y la app la encuentra así en la lista
15
16// Pines: cámbialos aquí si conectaste de otra forma
17const int BUZZER_PIN = 25;  // usa un zumbador pasivo (uno activo solo da un tono)
18
19void btWrite(const char *text);
20void onValue(const char *key, const char *value);
21void sendAll();
22void onLinkLost();
23
24// ── La app envía líneas "clave=valor"; con "?" la placa manda todos sus valores ──
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");  // la línea "@v" indica a la app la versión del código
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// los bytes que llegan pasan de la tarea Bluetooth a loop() por un pequeño búfer circular
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// las líneas salen en paquetes de 20 bytes (funciona con cualquier móvil)
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" toca la nota y "nota=0" la para
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);  // Conexión perdida: el sonido se apaga
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

Preguntas frecuentes

¿Funciona con iPhone?

Sí. El Bluetooth Low Energy (BLE) integrado del ESP32 habla con iPhone y con Android. Un iPhone no puede conectarse a módulos de Bluetooth clásico como el HC-05 y el HC-06, y este proyecto no los necesita. No intentes emparejar la placa desde los ajustes Bluetooth del móvil; las placas BLE pueden no aparecer ahí, es normal. La conexión la hace la app BlueGrays.

¿Qué diferencia hay entre un zumbador activo y uno pasivo, y cuál necesito?

Necesitas un zumbador pasivo. Funciona como un altavoz diminuto: toca la frecuencia que le envíes. Un zumbador activo lleva su propio circuito y, en cuanto recibe tensión, emite siempre el mismo sonido fijo, así que las teclas no se distinguen. Este proyecto te dice cuál tienes: si las teclas dan notas distintas es pasivo; si todas suenan con el mismo zumbido, es activo. Al comprarlo, busca la palabra pasivo (passive) en el nombre del producto.

¿Puedo pulsar dos teclas a la vez y tocar un acorde?

No. Un zumbador solo puede tocar una frecuencia a la vez, y la orden tone de la placa genera una única nota. Si pulsas dos teclas juntas, las notas no se suman; la placa toca solo la última que llegó. Toca las melodías nota a nota. El botón Tocar a pantalla completa del panel agranda las teclas, y ahí también puedes deslizar el dedo por ellas para pasar de una nota a otra.

¿Puedo añadir otras notas o más teclas?

Las ocho teclas del panel son fijas: del Do grave al Do agudo, sin sostenidos ni bemoles, y desde la app no se pueden añadir teclas. El lado de la placa sí es flexible: el código toca como frecuencia cualquier número positivo que llegue del móvil y se calla cuando llega 0. Así que puedes cambiar el sonido en el código; por ejemplo, multiplica por dos la frecuencia recibida y todo el piano sube una octava.