How to use MQTT to monitor ESP32 sensors over Wi-Fi

Why Use MQTT with ESP32 for Sensor Monitoring?

Monitoring sensors in real-time, whether in a smart home or on an industrial production line, demands an efficient and reliable way to transmit data. This is where the MQTT (Message Queuing Telemetry Transport) protocol and the ESP32 microcontroller truly shine. MQTT is a lightweight publish/subscribe messaging protocol, ideal for resource-constrained devices like microcontrollers, as it minimizes power consumption and network bandwidth. The ESP32, on the other hand, is a robust and affordable platform with integrated Wi-Fi and Bluetooth, perfect for collecting and sending sensor data.

In this article, we'll explore how to combine the power of ESP32 with the intelligence of MQTT to create effective telemetry systems. We'll cover everything from the connection lifecycle to best practices for organizing your topics and optimizing data transmission over Wi-Fi, ensuring your readings reach their destination securely and efficiently, even in challenging environments such as factory floors or residences with many devices.

MQTT: The Heart of IoT Telemetry

MQTT operates with a centralized architecture where a server, called a broker, acts as a message distribution point. Devices, known as clients, connect to this broker and can publish messages (send data) or subscribe (receive data) to specific topics. A topic is like a hierarchical "mailbox" (e.g., home/livingroom/temperature) to which data is sent or from which it is retrieved.

The beauty of MQTT lies in its simplicity and advanced features for ensuring delivery. Quality of Service (QoS), for example, defines the level of assurance for message delivery, ranging from "at most once" (QoS 0) to "exactly once" (QoS 2). Furthermore, `Last Will and Testament` (LWT) messages are essential: the client configures a message that the broker automatically sends to a specific topic if the client's connection drops unexpectedly. This is vital for knowing when a sensor has stopped working, indicating network or device issues.

ESP32: The Ideal Choice for Connectivity and Automation

The ESP32, from Espressif Systems, has become a favorite among IoT developers. Its dual-core processing capabilities (or single, depending on the model), ability to operate at very low power, and integrated Wi-Fi module make it perfect for telemetry applications. It can collect data from a wide range of sensors, such as temperature, humidity, presence, or liquid levels, and send it to the MQTT broker using the existing Wi-Fi network, eliminating the need for complex wiring or additional communication modules.

Its versatility and strong community support, with robust libraries for MQTT, Wi-Fi, and various sensors, significantly accelerate development. The ease of programming, whether via Arduino IDE or ESP-IDF, allows both hobbyists and engineers to create complex solutions relatively quickly. For home automation scenarios, it can integrate lighting and climate control systems; in industry, it can monitor machines and processes, optimizing predictive maintenance and operational efficiency.

Connection Lifecycle & Wi-Fi Efficiency

Managing the Wi-Fi connection is a critical point for battery-powered IoT devices. The ESP32 allows for power-saving strategies, such as `light sleep` and `deep sleep`, where it "sleeps" for long periods and "wakes up" only to read sensors and send data. In MQTT, the `keep-alive` parameter is fundamental: it defines the maximum inactivity interval between the client and the broker. If no packets are exchanged during this period, the client sends a `PINGREQ` to keep the connection alive. A well-tuned `keep-alive` prevents unnecessary reconnections and preserves battery life.

Moreover, how data is sent also impacts efficiency. Sending small data packets at regular intervals is generally more efficient than sending large blocks infrequently. Using JSON payloads, but in a compact format (avoiding overly long key names), reduces traffic volume. Understanding the full cycle – connecting to Wi-Fi, connecting to MQTT, publishing, and potentially disconnecting to sleep – is key to robust and energy-efficient telemetry.

Practical Implementation: Monitoring a Sensor

Let's get hands-on and implement a temperature and humidity monitor using a DHT11/DHT22 sensor and an ESP32, publishing data via MQTT. For this, you'll need the ESP32, a DHT sensor, and an MQTT broker (which can be local, like Mosquitto, or a cloud service).

1. Set Up the Development Environment

   First, ensure you have the Arduino IDE installed with ESP32 board support. Install the necessary libraries via the Library Manager: "PubSubClient" for MQTT and "DHT sensor library" for the sensor.

2. Connect the Sensor to ESP32

   Connect the data pin of your DHT sensor to an ESP32 digital pin (e.g., GPIO4). The VCC pin goes to 3.3V and GND to ESP32's GND. Add a 10k Ohm resistor between the data pin and VCC if your sensor doesn't have an internal one.

3. Structure the Main Code

   The code below demonstrates Wi-Fi and MQTT connection and sensor reading. Adapt the SSID, password, broker IP, and topics as needed.

   #include <WiFi.h> #include <PubSubClient.h> #include <DHT.h> const char* ssid = "YourSSID"; const char* password = "YourPassword"; const char* mqtt_server = "192.168.1.100"; const int mqtt_port = 1883; const char* mqtt_client_id = "ESP32Sensor"; const char* mqtt_user = ""; // Optional const char* mqtt_pass = ""; // Optional const char* mqtt_topic_temp = "home/livingroom/temperature"; const char* mqtt_topic_hum = "home/livingroom/humidity"; #define DHTPIN 4 #define DHTTYPE DHT11 DHT dht(DHTPIN, DHTTYPE); WiFiClient espClient; PubSubClient client(espClient); void setup_wifi() { delay(10); Serial.println("Connecting to WiFi..."); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("WiFi connected"); Serial.print("IP address: "); Serial.println(WiFi.localIP()); } void reconnect_mqtt() { while (!client.connected()) { Serial.print("Attempting MQTT connection..."); if (client.connect(mqtt_client_id, mqtt_user, mqtt_pass)) { Serial.println("connected"); // If there are topics to subscribe to, do it here. // client.subscribe("control/topic"); } else { Serial.print("failed, rc="); Serial.print(client.state()); Serial.println(" trying again in 5 seconds"); delay(5000); } } } void setup() { Serial.begin(115200); dht.begin(); setup_wifi(); client.setServer(mqtt_server, mqtt_port); } void loop() { if (!client.connected()) { reconnect_mqtt(); } client.loop(); // Handles reconnections and incoming messages // Sensor reading float h = dht.readHumidity(); float t = dht.readTemperature(); if (isnan(h) || isnan(t)) { Serial.println("Failed to read from DHT sensor!"); } else { // Publish temperature String tempPayload = String(t, 2); Serial.print("Publishing temperature: "); Serial.print(tempPayload); Serial.print(" to topic "); Serial.println(mqtt_topic_temp); client.publish(mqtt_topic_temp, tempPayload.c_str()); // Publish humidity String humPayload = String(h, 2); Serial.print("Publishing humidity: "); Serial.print(humPayload); Serial.print(" to topic "); Serial.println(mqtt_topic_hum); client.publish(mqtt_topic_hum, humPayload.c_str()); } delay(30000); // Publishes every 30 seconds } 

4. Monitor with the MQTT Broker

   After uploading the code to your ESP32, use an MQTT client like `mqtt-explorer` or `mosquitto_sub` to subscribe to the topics home/livingroom/temperature and home/livingroom/humidity. You'll see your sensor data being published in real-time.

   mosquitto_sub -h 192.168.1.100 -t "home/livingroom/#" -v 

Managing Topics & Messages: Best Practices

How you structure your MQTT topics is vital for system scalability and organization. Avoid generic topics and prefer a logical hierarchy. For instance, instead of `temperature`, use `building/floor/room/temperature`. This allows you to subscribe to broader topics (e.g., `building/#`) to receive data from the entire building or a specific floor (`building/floor/+`). Also, consider using QoS 1 (`At least once`) for critical messages that require delivery assurance, such as security alerts, and QoS 0 (`At most once`) for telemetry data that doesn't demand strict retransmission, like routine temperature readings, aiming for efficiency.

For message payloads, JSON is the most flexible format. It allows you to encapsulate multiple values (e.g., temperature, humidity, pressure) in a single message, reducing the number of publications. For example, instead of two topics for temperature and humidity, a single topic home/livingroom/data can publish {"temperature":24.5, "humidity":60.2}. Retained messages are also useful: the broker stores the last message published on a topic and sends it immediately to any new subscriber, ensuring new clients receive the current state of a sensor as soon as they connect. This can be crucial in systems where understanding the current state of a device is important, much like how one might use `iostat` to understand the current performance of a server's disk I/O.

Conclusion

The combination of ESP32 with the MQTT protocol offers a robust and flexible solution for monitoring sensors and implementing telemetry in diverse environments, from home automation to industrial applications. By understanding and applying best practices for connection lifecycle, topic management, and data optimization via Wi-Fi, it is possible to build efficient, scalable, and resilient systems.

Mastering these concepts not only enables the creation of more effective IoT projects but also lays the groundwork for more complex automation systems, where reliable communication and low power consumption are key differentiators. Continue exploring and adapting these techniques to meet the specific demands of your projects, ensuring your data gets where it needs to go, when it needs to go.