ES-109Débutant

ESP32 Bluetooth Thermo-hygromètre (DHT11)

Suis en direct sur ton téléphone la température et l'humidité avec un ESP32 et un capteur DHT11 : deux cases de mesure et un graphique mis à jour toutes les 2 secondes, sans internet. Ce projet est le guide pas à pas du modèle Bluetooth Température et humidité de l'appli. Va dans Mon Atelier › Appareils › Ajouter un appareil › Bluetooth, choisis le modèle et téléverse le code avec Obtenir le code. Le bouton Configurer en panneau Bluetooth ici ouvre l'assistant tout prêt.

0.0(0)
ESP32 Bluetooth Thermo-hygromètre (DHT11)
Quelle température fait-il vraiment dans ta pièce, et pourquoi l'air semble si lourd ? Dans ce projet, tu relies un petit capteur DHT11 à l'ESP32 avec trois fils, et la carte envoie température et humidité à ton téléphone en Bluetooth toutes les 2 secondes. L'appli affiche deux cases de mesure et un graphique en direct, sans internet, box ni serveur. L'installation est rapide : Ajouter un appareil, Bluetooth, choisis le modèle Température et humidité, téléverse avec Obtenir le code, puis trouve ta carte. Le bouton de la page du projet t'y emmène directement. Tu apprends : mesurer avec le DHT11, envoyer des données en Bluetooth Low Energy, repérer les erreurs du capteur et un minuteur qui n'attend jamais.

Vidéo

Schéma du circuit

ESP32 Bluetooth Thermo-hygromètre (DHT11) - Schéma du circuit

Code source

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Hava                   │
5// └───────────────────────────┘
6// Température et humidité
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#include <DHT.h>  // Gestionnaire de bibliothèques : 'DHT sensor library' (Adafruit)
14
15const char BLE_NAME[] = "BG-Hava";  // la carte s’annonce sous ce nom, l’appli la retrouve ainsi dans la liste
16
17// Broches : modifie-les ici si tu as câblé autrement
18const int DHT_PIN = 4;
19const unsigned long READ_EVERY_MS = 2000;  // une nouvelle mesure part toutes les 2 secondes
20
21void btWrite(const char *text);
22void onValue(const char *key, const char *value);
23void sendAll();
24void onLinkLost();
25
26// ── L’appli envoie des lignes "clé=valeur" ; sur "?", la carte renvoie toutes ses valeurs ──
27char line[65];
28uint8_t lineLen = 0;
29unsigned long lastRxMs = 0;
30
31bool is(const char *a, const char *b) { return strcmp(a, b) == 0; }
32bool isOn(const char *v) { return v[0] == '1'; }
33
34void sendText(const char *key, const char *value) {
35  char out[72];
36  snprintf(out, sizeof(out), "%s=%s\n", key, value);
37  btWrite(out);
38}
39
40void sendInt(const char *key, long value) {
41  char text[12];
42  snprintf(text, sizeof(text), "%ld", value);
43  sendText(key, text);
44}
45
46void sendFloat(const char *key, float value) {
47  char text[16];
48  dtostrf(value, 1, 1, text);
49  sendText(key, text);
50}
51
52void handleLine(char *text) {
53  char *eq = strchr(text, '=');
54  if (eq == nullptr) {
55    if (text[strlen(text) - 1] == '?') {
56      btWrite("@v=1.0\n");  // la ligne "@v" indique à l’appli la version du code
57      sendAll();
58    }
59    return;
60  }
61  *eq = '\0';
62  onValue(text, eq + 1);
63}
64
65void feed(char c) {
66  lastRxMs = millis();
67  if (c == '\n' || c == '\r') {
68    if (lineLen == 0) return;
69    line[lineLen] = '\0';
70    lineLen = 0;
71    handleLine(line);
72  } else if (lineLen < sizeof(line) - 1) {
73    line[lineLen++] = c;
74  }
75}
76
77// ── Bluetooth (Nordic UART) ──
78#define UART_SERVICE "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
79#define UART_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
80#define UART_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
81
82BLECharacteristic *txChar = nullptr;
83volatile bool linked = false;
84volatile bool linkLost = false;
85// les octets reçus passent de la tâche Bluetooth à loop() par un petit tampon circulaire
86const int RX_SIZE = 256;
87volatile uint8_t rxBuf[RX_SIZE];
88volatile int rxHead = 0, rxTail = 0;
89
90class ServerEvents : public BLEServerCallbacks {
91  void onConnect(BLEServer *server) override { linked = true; }
92  void onDisconnect(BLEServer *server) override { linked = false; linkLost = true; }
93};
94
95class RxEvents : public BLECharacteristicCallbacks {
96  void onWrite(BLECharacteristic *c) override {
97    auto v = c->getValue();
98    for (size_t i = 0; i < v.length(); i++) {
99      int next = (rxHead + 1) % RX_SIZE;
100      if (next == rxTail) break;
101      rxBuf[rxHead] = (uint8_t)v[i];
102      rxHead = next;
103    }
104  }
105};
106
107// les lignes partent en paquets de 20 octets (compatible avec tous les téléphones)
108void btWrite(const char *text) {
109  if (!linked || txChar == nullptr) return;
110  size_t n = strlen(text);
111  for (size_t i = 0; i < n; i += 20) {
112    size_t len = n - i < 20 ? n - i : 20;
113    txChar->setValue((uint8_t *)text + i, len);
114    txChar->notify();
115    delay(4);
116  }
117}
118
119void btBegin() {
120  BLEDevice::init(BLE_NAME);
121  BLEServer *server = BLEDevice::createServer();
122  server->setCallbacks(new ServerEvents());
123  BLEService *uart = server->createService(UART_SERVICE);
124  txChar = uart->createCharacteristic(UART_TX, BLECharacteristic::PROPERTY_NOTIFY);
125  txChar->addDescriptor(new BLE2902());
126  BLECharacteristic *rx = uart->createCharacteristic(UART_RX, BLECharacteristic::PROPERTY_WRITE | BLECharacteristic::PROPERTY_WRITE_NR);
127  rx->setCallbacks(new RxEvents());
128  uart->start();
129  BLEAdvertisementData adv;
130  adv.setFlags(0x06);
131  adv.setCompleteServices(BLEUUID(UART_SERVICE));
132  BLEAdvertisementData scan;
133  scan.setName(BLE_NAME);
134  BLEAdvertising *advertising = BLEDevice::getAdvertising();
135  advertising->setAdvertisementData(adv);
136  advertising->setScanResponseData(scan);
137  BLEDevice::startAdvertising();
138}
139
140void btPoll() {
141  while (rxTail != rxHead) {
142    char c = (char)rxBuf[rxTail];
143    rxTail = (rxTail + 1) % RX_SIZE;
144    feed(c);
145  }
146  if (linkLost) {
147    linkLost = false;
148    onLinkLost();
149    delay(100);
150    BLEDevice::startAdvertising();
151  }
152}
153
154// ── ESP32 ──
155DHT dht(DHT_PIN, DHT11);
156float temperature = NAN, humidity = NAN;
157unsigned long lastReadMs = 0;
158
159// si le capteur ne répond pas, l’appli reçoit "@err=dht" : vérifie le câblage
160void readSensor() {
161  float t = dht.readTemperature();
162  float h = dht.readHumidity();
163  if (isnan(t) || isnan(h)) {
164    btWrite("@err=dht\n");
165    return;
166  }
167  temperature = t;
168  humidity = h;
169}
170
171void sendReadings() {
172  if (isnan(temperature)) return;
173  sendFloat("sicaklik", temperature);
174  sendInt("nem", lround(humidity));
175}
176
177void onValue(const char *key, const char *value) {
178}
179
180void sendAll() {
181  if (isnan(temperature)) readSensor();
182  sendReadings();
183}
184
185void onLinkLost() {
186}
187
188void setup() {
189  Serial.begin(115200);
190  dht.begin();
191  btBegin();
192  Serial.print(F("BlueGrays Bluetooth: "));
193  Serial.println(BLE_NAME);
194}
195
196void loop() {
197  btPoll();
198  if (millis() - lastReadMs >= READ_EVERY_MS) {
199    lastReadMs = millis();
200    readSensor();
201    sendReadings();
202  }
203}
204

FAQ

Est-ce que ça marche avec un iPhone ?

Oui. La carte utilise le Bluetooth Low Energy (BLE) intégré de l'ESP32, et l'appli BlueGrays s'y connecte sur iPhone comme sur Android. Les modules Bluetooth classiques comme le HC-05 ou le HC-06 ne peuvent pas se connecter à un iPhone, c'est pourquoi ce projet ne les utilise pas. N'essaie pas d'appairer la carte dans les réglages Bluetooth du téléphone ; seule l'appli établit la connexion.

Je peux utiliser un DHT22 à la place du DHT11 ?

Oui. Le DHT22 (AM2302) mesure plus précisément et sur une plage plus large : environ -40 à 80 °C, ±0,5 °C. Le câblage reste le même. Le modèle de l'appli est prévu pour le DHT11 : remplace DHT11 par DHT22 dans la ligne DHT dht(DHT_PIN, DHT11) et téléverse à nouveau. L'échelle du graphique du panneau est réglée sur la plage du DHT11 (0 à 50 °C).

Pourquoi les valeurs changent toutes les 2 secondes, et quelle est leur précision ?

Le DHT11 ne peut pas être lu plus d'une fois par seconde, donc le code mesure et envoie toutes les 2 secondes avec READ_EVERY_MS = 2000. Le capteur couvre 0 à 50 °C et 20 à 90 % d'humidité, avec une erreur d'environ ±2 °C et ±5 % d'humidité. C'est suffisant pour surveiller une pièce ; pour plus de précision, passe au DHT22.

Les mesures sont-elles enregistrées quand mon téléphone est loin ?

Non. La carte envoie seulement la valeur du moment et ne garde aucun historique. Le graphique se trace avec les valeurs reçues tant que le panneau est ouvert et la carte connectée ; si le téléphone sort de la portée ou si tu fermes l'appli, aucun nouveau point n'est ajouté. À la reconnexion, l'appli envoie ? et la carte renvoie aussitôt ses dernières valeurs.