ES-114Débutant

ESP32 Bluetooth : piano sur téléphone

Transforme ton téléphone en piano à 8 touches : appuie sur une touche et un buzzer passif sur l'ESP32 joue la note, sans internet ni Wi-Fi. C'est le guide pas à pas du modèle Bluetooth Piano sur téléphone de l'appli, monté avec un buzzer et deux fils. Va dans Mon Atelier › Appareils › Ajouter un appareil › Bluetooth, choisis ce modèle et téléverse le code avec Obtenir le code. Le bouton Configurer en panneau Bluetooth de cette page ouvre aussi l'assistant.

0.0(0)
ESP32 Bluetooth : piano sur téléphone
Appuie sur une touche du téléphone et le buzzer sur ton bureau joue un Do ; relâche et il se tait : ni internet, ni box, ni serveur. L'ESP32 a le Bluetooth intégré, le téléphone s'y connecte directement. Huit touches vont du Do grave au Do aigu. À l'appui, le téléphone envoie la fréquence de la note (262 Hz pour le Do grave) ; au relâchement, il envoie 0. Si la connexion tombe, la carte se tait seule. Le montage : un buzzer passif et deux fils, sans breadboard. Dans l'appli, choisis Bluetooth et le modèle Piano sur téléphone, téléverse le code avec Obtenir le code puis trouve ta carte dans la liste. Tu apprends : le Bluetooth Low Energy en courtes lignes de texte, la fréquence qui fixe la note, buzzer passif ou actif.

Vidéo

Schéma du circuit

ESP32 Bluetooth : piano sur téléphone - Schéma du circuit

Code source

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Piyano                 │
5// └───────────────────────────┘
6// Piano sur téléphone
7// Carte dans l’IDE Arduino : ESP32 Dev Module
8// la bibliothèque BLE est fournie avec le paquet de cartes ESP32, rien à installer en plus
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13
14const char BLE_NAME[] = "BG-Piyano";  // la carte s’annonce sous ce nom, l’appli la retrouve ainsi dans la liste
15
16// Broches : modifie-les ici si tu as câblé autrement
17const int BUZZER_PIN = 25;  // utilise un buzzer passif (un buzzer actif ne fait qu’un seul son)
18
19void btWrite(const char *text);
20void onValue(const char *key, const char *value);
21void sendAll();
22void onLinkLost();
23
24// ── L’appli envoie des lignes "clé=valeur" ; sur "?", la carte renvoie toutes ses valeurs ──
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 ligne "@v" indique à l’appli la version du code
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// les octets reçus passent de la tâche Bluetooth à loop() par un petit tampon circulaire
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// les lignes partent en paquets de 20 octets (compatible avec tous les téléphones)
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" joue la note, "nota=0" l’arrête
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);  // Connexion perdue : le son s’arrête
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

Est-ce que ça marche avec un iPhone ?

Oui. Le Bluetooth Low Energy (BLE) intégré à l'ESP32 parle aussi bien à l'iPhone qu'à Android. Un iPhone ne peut pas se connecter aux modules Bluetooth classiques comme le HC-05 et le HC-06, et ce projet n'en a pas besoin. N'essaie pas d'appairer la carte dans les réglages Bluetooth du téléphone ; les cartes BLE peuvent ne pas y apparaître, c'est normal. C'est l'appli BlueGrays qui établit la connexion.

Quelle est la différence entre un buzzer actif et un buzzer passif, et lequel me faut-il ?

Il te faut un buzzer passif. Il fonctionne comme un minuscule haut-parleur : il joue la fréquence que tu lui envoies. Un buzzer actif contient son propre circuit et émet toujours le même son fixe dès qu'il est alimenté ; avec lui, impossible de distinguer les touches. Ce projet te dit lequel tu as : si les touches donnent des notes différentes, il est passif ; si elles font toutes le même grésillement, il est actif. À l'achat, cherche le mot passif (passive) dans le nom du produit.

Est-ce que je peux appuyer sur deux touches à la fois pour jouer un accord ?

Non. Un buzzer ne joue qu'une fréquence à la fois, et la commande tone de la carte produit une seule note. Si tu appuies sur deux touches ensemble, les notes ne s'additionnent pas ; la carte joue seulement la dernière arrivée. Joue les mélodies note par note. Le bouton Jouer en plein écran du panneau agrandit les touches, et tu peux aussi y glisser le doigt sur les touches pour passer d'une note à l'autre.

Est-ce que je peux ajouter d'autres notes ou plus de touches ?

Les huit touches du panneau sont fixes : du Do grave au Do aigu, sans dièses ni bémols, et l'appli ne permet pas d'en ajouter. Côté carte, c'est plus souple : le code joue comme fréquence tout nombre positif envoyé par le téléphone et se tait quand il reçoit 0. Tu peux donc changer le son dans le code ; par exemple, multiplie par deux la fréquence reçue et tout le piano monte d'une octave.