ES-109Boshlang‘ich

ESP32 Bluetooth Temp and Humidity (DHT11)

Watch your room's temperature and humidity live on your phone with an ESP32 and a DHT11 sensor: two reading boxes and a chart update every 2 seconds, no internet needed. This project is the step-by-step guide for the Temperature and humidity Bluetooth template in the app. Go to Workshop › Devices › Add a device › Bluetooth, pick the template and upload the code with Get the code. The Set up as a Bluetooth panel button on this page opens the wizard ready to go.

0.0(0)
ESP32 Bluetooth Temp and Humidity (DHT11)
Ever wondered how warm your room really is, or why the air feels heavy? In this project you connect a small DHT11 sensor to the ESP32 with three wires, and the board sends the temperature and humidity to your phone over Bluetooth every 2 seconds. The app shows two reading boxes and a live chart; no internet, router or server needed. Setup is short: Add a device, Bluetooth, pick the Temperature and humidity template, upload with Get the code, then find your board. The button on the project page takes you straight to setting up this panel. Learning: measuring with the DHT11, sending data over Bluetooth Low Energy, catching sensor errors and a timer that never waits.

Video

Elektr sxemasi

ESP32 Bluetooth Temp and Humidity (DHT11) - Elektr sxemasi

Manba kodi

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Hava                   │
5// └───────────────────────────┘
6// Temperature and humidity
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#include <DHT.h>  // Library Manager: 'DHT sensor library' (Adafruit)
14
15const char BLE_NAME[] = "BG-Hava";  // the board advertises with this name, the app finds it in the list by it
16
17// Pins: change them here if you wired differently
18const int DHT_PIN = 4;
19const unsigned long READ_EVERY_MS = 2000;  // a new reading is sent every 2 seconds
20
21void btWrite(const char *text);
22void onValue(const char *key, const char *value);
23void sendAll();
24void onLinkLost();
25
26// ── The app sends "key=value" lines; on "?" the board sends all its values ──
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");  // the "@v" line tells the app the code version
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// incoming bytes move from the Bluetooth task to loop() through a small ring buffer
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// lines go out in 20-byte packets (works with every phone)
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// if the sensor can't be read the app gets "@err=dht": check the wiring
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

Ko‘p so‘raladigan savollar

Does it work with an iPhone?

Yes. The board uses the ESP32's built-in Bluetooth Low Energy (BLE), and the BlueGrays app connects to it on both iPhone and Android. Classic Bluetooth modules such as the HC-05 or HC-06 cannot connect to an iPhone, which is why this project does not use them. Do not try to pair the board in your phone's Bluetooth settings; only the app makes the connection.

Can I use a DHT22 instead of the DHT11?

Yes. The DHT22 (AM2302) measures a wider range more precisely: about -40 to 80 °C, ±0.5 °C. The wiring stays the same. The template in the app is made for the DHT11, so change DHT11 to DHT22 in the line DHT dht(DHT_PIN, DHT11) and upload again. The panel's chart scale is set for the DHT11 range (0 to 50 °C).

Why do the values change only every 2 seconds, and how accurate are they?

The DHT11 cannot be read more than once a second, so the code measures and sends every 2 seconds with READ_EVERY_MS = 2000. The sensor covers 0 to 50 °C and 20% to 90% humidity, with an error of about ±2 °C and ±5% humidity. That is fine for keeping an eye on a room; for more precision, move to a DHT22.

Are readings saved while my phone is away?

No. The board only sends the current value and keeps no history. The chart is drawn from the values that arrive while the panel is open and the board is connected; when the phone goes out of range or you close the app, no new points are added. When you reconnect, the app sends ? and the board sends its latest values right away.