ES-114Începător

Pian pe telefon prin Bluetooth cu ESP32

Transformă telefonul într-un pian cu 8 clape: apeși o clapă, iar un buzzer pasiv conectat la ESP32 redă nota, fără internet sau Wi-Fi. Ghid pas cu pas pentru șablonul Bluetooth Pian pe telefon, cu un buzzer și două fire jumper. Mergi la Atelier › Dispozitive › Adaugă un dispozitiv › Bluetooth, alege Pian pe telefon și încarcă codul cu Obține codul. Butonul Configurează ca panou Bluetooth de pe pagină deschide și el asistentul cu acest șablon.

0.0(0)
Pian pe telefon prin Bluetooth cu ESP32
Apasă o clapă pe telefon, iar buzzerul de pe birou cântă un do; ridică degetul și sunetul se oprește: fără internet, router sau server la mijloc. ESP32 are Bluetooth integrat, așa că telefonul se conectează direct la placă. Cele opt clape acoperă notele de la do grav la do acut. Când apeși o clapă, telefonul trimite frecvența notei (262 Hz pentru do grav); când o eliberezi, trimite 0 și sunetul se oprește. Dacă se întrerupe conexiunea, placa oprește automat sunetul. Circuitul are doar un buzzer pasiv și două fire, fără breadboard. În aplicație, alege Bluetooth și șablonul Pian pe telefon, încarcă codul cu Obține codul, apoi găsește placa în listă. Înveți despre comunicarea prin Bluetooth Low Energy folosind linii scurte de text, despre cum frecvența determină nota și despre diferența dintre un buzzer pasiv și unul activ.

Video

Schemă electrică

Pian pe telefon prin Bluetooth cu ESP32 - Schemă electrică

Cod sursă

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Piyano                 │
5// └───────────────────────────┘
6// Phone piano
7// Arduino IDE board: ESP32 Dev Module
8// the BLE library comes with the ESP32 board package, nothing extra to install
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13
14const char BLE_NAME[] = "BG-Piyano";  // the board advertises with this name, the app finds it in the list by it
15
16// Pins: change them here if you wired differently
17const int BUZZER_PIN = 25;  // use a passive buzzer (an active one only makes a single tone)
18
19void btWrite(const char *text);
20void onValue(const char *key, const char *value);
21void sendAll();
22void onLinkLost();
23
24// ── The app sends "key=value" lines; on "?" the board sends all its values ──
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");  // the "@v" line tells the app the code version
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// incoming bytes move from the Bluetooth task to loop() through a small ring buffer
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// lines go out in 20-byte packets (works with every phone)
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" plays the note, "nota=0" stops it
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);  // Connection lost: the sound stops
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

Întrebări frecvente

Funcționează cu un iPhone?

Da. Bluetooth Low Energy (BLE) integrat în ESP32 comunică atât cu iPhone, cât și cu Android. Un iPhone nu se poate conecta la module Bluetooth clasice precum HC-05 și HC-06, iar acest proiect nu are nevoie de ele. Nu încerca să asociezi placa din setările Bluetooth ale telefonului; plăcile BLE pot să nu apară acolo, ceea ce este normal. Aplicația BlueGrays stabilește conexiunea.

Care este diferența dintre un buzzer activ și unul pasiv și de care am nevoie?

Ai nevoie de un buzzer pasiv. Acesta funcționează ca un mic difuzor: redă frecvența pe care i-o trimiți. Un buzzer activ are propriul circuit intern și emite același sunet fix de fiecare dată când este alimentat, așa că toate clapele ar suna la fel. Poți afla ce tip ai folosind acest proiect: dacă fiecare clapă redă o notă diferită, buzzerul este pasiv; dacă toate produc același bâzâit, este activ. Când cumperi unul, caută cuvântul „pasiv” (passive) în numele produsului.

Pot apăsa două clape simultan ca să cânt un acord?

Nu. Un buzzer poate reda o singură frecvență la un moment dat, iar comanda tone de pe placă produce o singură notă. Dacă apeși două clape simultan, notele nu se suprapun; placa redă doar ultima notă primită. Cântă melodiile notă cu notă. Butonul Cântă pe tot ecranul din panou mărește clapele; în acest mod poți și să glisezi degetul peste ele pentru a trece de la o notă la alta.

Pot adăuga alte note sau mai multe clape?

Cele opt clape din panou sunt fixe: de la do grav la do acut, fără diezi sau bemoli, iar din aplicație nu poți adăuga clape. Codul de pe placă este însă flexibil: interpretează orice număr pozitiv primit de la telefon ca frecvență și oprește sunetul când primește 0. Așadar, poți modifica sunetul din cod; de exemplu, dacă înmulțești frecvența primită cu doi, toate notele pianului urcă cu o octavă.