12 Lab 1: ESP32 MQTT Publisher

12.1 Start With One Working Pipeline

Every lab is a version of the same review path: a device senses something, publishes it to a topic, the broker applies a delivery rule, and another client proves it received the right state. Build that small path first, then make it secure, reliable, battery-aware, and observable.

12.2 Learning Objectives

By the end of this chapter, you will be able to build an ESP32-to-broker sensor path, isolate its public exercise traffic with a unique identity and topic root, and justify its publish interval using observed broker and energy evidence.

12.4 Prerequisites

Before diving into this chapter, you should be familiar with:

• MQTT Publisher-Subscriber Setup: Basic publisher/subscriber creation and simulator usage
• MQTT Python Patterns: Production patterns, security awareness, and debugging
• MQTT QoS Levels and MQTT Session Management: Understanding QoS 0, 1, 2 and clean/persistent sessions
• Arduino/ESP32 development: Experience with Arduino IDE, libraries, and basic C++ syntax

12.5 Lab 1: ESP32 DHT22 MQTT Publisher with QoS Levels

Objective: Build a temperature/humidity sensor that publishes to MQTT with different QoS levels.

Materials:

• ESP32 development board
• DHT22 temperature/humidity sensor
• 10k ohm pull-up resistor
• Breadboard and jumper wires
• Wi-Fi connection

Circuit Diagram:

DHT22          ESP32
-----          -----
VCC   ------>  3.3V
DATA  ------>  GPIO 4 (with 10k ohm pull-up to 3.3V)
GND   ------>  GND

Complete Code:

#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>
#include <esp_system.h>

// Wi-Fi credentials
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";

// MQTT Broker settings
const char* mqtt_server = "test.mosquitto.org";
const int mqtt_port = 1883;

// Generated on this ESP32 at boot: 48 random bits, printed in setup().
char learner_suffix[13];
char mqtt_client_id[24];

// DHT22 sensor
#define DHTPIN 4
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

// MQTT topics
char topic_root[40];
char topic_temp[56];
char topic_humidity[56];
char topic_status[56];
char topic_command[56];

WiFiClient espClient;
PubSubClient client(espClient);

// Forward declaration (defined below loop)
void mqtt_callback(char* topic, byte* payload, unsigned int length);

unsigned long lastPublish = 0;
const long publishInterval = 5000; // 5 seconds

void make_lab_identity() {
  uint32_t random_high = esp_random();
  uint32_t random_low = esp_random();

  snprintf(learner_suffix, sizeof(learner_suffix), "%08lX%04lX",
           (unsigned long)random_high,
           (unsigned long)(random_low & 0xFFFF));
  snprintf(mqtt_client_id, sizeof(mqtt_client_id), "iotlab-%s", learner_suffix);
  snprintf(topic_root, sizeof(topic_root), "iotclass/lab1/%s", learner_suffix);
  snprintf(topic_temp, sizeof(topic_temp), "%s/temperature", topic_root);
  snprintf(topic_humidity, sizeof(topic_humidity), "%s/humidity", topic_root);
  snprintf(topic_status, sizeof(topic_status), "%s/status", topic_root);
  snprintf(topic_command, sizeof(topic_command), "%s/command", topic_root);
}

void setup_wifi() {
  Serial.println("\nConnecting to Wi-Fi...");
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("\nWi-Fi connected");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}

void reconnect_mqtt() {
  while (!client.connected()) {
    Serial.print("Connecting to MQTT broker...");

    if (client.connect(mqtt_client_id)) {
      Serial.println(" Connected");

      // Publish online status as retained message
      client.publish(topic_status, "online", true);

      // Subscribe to commands (optional)
      client.subscribe(topic_command);
    } else {
      Serial.print(" Failed, rc=");
      Serial.println(client.state());
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  dht.begin();

  setup_wifi();
  make_lab_identity();

  Serial.print("Unique MQTT ClientID: ");
  Serial.println(mqtt_client_id);
  Serial.print("Your Lab 1 topic root: ");
  Serial.println(topic_root);

  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(mqtt_callback);
}

void mqtt_callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message received on ");
  Serial.print(topic);
  Serial.print(": ");

  String message = "";
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  Serial.println(message);
}

void loop() {
  if (!client.connected()) {
    reconnect_mqtt();
  }
  client.loop();

  unsigned long now = millis();
  if (now - lastPublish >= publishInterval) {
    lastPublish = now;

    // Read sensor
    float humidity = dht.readHumidity();
    float temperature = dht.readTemperature();

    if (isnan(humidity) || isnan(temperature)) {
      Serial.println("Failed to read from DHT sensor!");
      return;
    }

    // Publish temperature with QoS 0
    char tempStr[8];
    dtostrf(temperature, 6, 2, tempStr);
    bool temp_success = client.publish(topic_temp, tempStr, false);
    Serial.print("Temperature: ");
    Serial.print(tempStr);
    Serial.print("C ");
    Serial.println(temp_success ? "OK" : "FAIL");

    // Publish humidity with QoS 0
    char humStr[8];
    dtostrf(humidity, 6, 2, humStr);
    bool hum_success = client.publish(topic_humidity, humStr, false);
    Serial.print("Humidity: ");
    Serial.print(humStr);
    Serial.print("% ");
    Serial.println(hum_success ? "OK" : "FAIL");

    Serial.println("---");
  }
}

Expected Output (Serial Monitor):

Connecting to Wi-Fi...
Wi-Fi connected
IP address: 192.168.1.100
Unique MQTT ClientID: iotlab-7A31C09E4B62
Your Lab 1 topic root: iotclass/lab1/7A31C09E4B62
Connecting to MQTT broker... Connected
Temperature: 22.50C OK
Humidity: 45.30% OK
Temperature: 22.48C OK
Humidity: 45.35% OK
***

Interactive Simulator: MQTT Publisher (ESP32 + DHT22)

Try it yourself! See a complete IoT system publishing sensor data to an MQTT broker.

What This Simulates: An ESP32 with DHT22 sensor connecting to Wi-Fi, then publishing temperature and humidity data to an MQTT broker every 5 seconds.

How to Use:

1. Click the Play button to start simulation
2. Watch the Serial Monitor show Wi-Fi connection
3. Observe MQTT broker connection with client ID
4. See temperature/humidity published to topics
5. Notice QoS 0 delivery with confirmation
6. Open MQTT Explorer or subscriber to see messages in real-time!

Learning Points

Observe:

Build the decision in sequence. Begin with PubSubClient Library: Arduino MQTT client for ESP32. Then consider client.connect(): establishes one broker session under the random iotlab-... ClientID printed by your board. Then consider client.publish(): sends a message to a topic and returns success or failure. Then consider Topic Hierarchy: iotclass/lab1/<your-suffix>/temperature separates your disposable lab traffic from another learner’s namespace. Then consider QoS 0 (At Most Once): fire-and-forget, fastest but with no delivery guarantee. Then consider Retained Messages: client.publish(topic, msg, true) stores the last value for new subscribers, which is another reason never to put private data on a public broker. Close by considering Auto-Reconnect: if (!client.connected()) reconnect_mqtt().

MQTT Publishing Flow:

1. ESP32 connects to Wi-Fi network
2. ESP32 generates and prints its random learner suffix, ClientID, and topic root
3. ESP32 connects to MQTT broker (test.mosquitto.org:1883)
4. ESP32 publishes "online" status as a retained message under its own topic root
5. Every 5 seconds:
   a. Read DHT22 sensor (temperature, humidity)
   b. Convert float to string
   c. Publish to "iotclass/lab1/<your-suffix>/temperature"
   d. Publish to "iotclass/lab1/<your-suffix>/humidity"
   e. Print success/failure indicators
6. Maintain connection with client.loop()

MQTT Topic Structure:

Before extending the lab with more sensors or subscriptions, inspect Figure 12.1 to predict which filters will receive the two concrete telemetry topics. This is the point where a readable namespace becomes observable broker behavior.

Read Figure 12.1 from the published topic into the broker’s stored filters. Check the exact filter first, then substitute one level with +, and finally follow a terminal # across the remaining levels. The non-matches show that level count, literal text, and wildcard placement are part of the comparison rather than suggestions. Use the fan-out result to connect the ESP32 publications above to the subscribers that should—and should not—receive them.

Quality of Service Levels:

QoS 0 (At Most Once): Fast, no acknowledgment - used here
QoS 1 (At Least Once): Acknowledged, may deliver duplicates
QoS 2 (Exactly Once): Slowest, guaranteed single delivery

Real-World Applications:

Build the decision in sequence. Begin with Smart Agriculture: Soil moisture sensors publishing to cloud dashboard. Then consider Industrial Monitoring: Temperature/pressure sensors in manufacturing. Then consider Home Automation: Smart thermostats publishing temperature readings. Then consider Environmental Monitoring: Weather stations sending data to aggregation service. Close by considering Asset Tracking: GPS devices publishing location updates.

Experiment:

Build the decision in sequence. Begin with Add more sensors (motion, light) and publish to separate topics. Then consider Implement QoS 1 or 2 to see acknowledgments. Then consider Add Last Will and Testament message for disconnect detection. Then consider Publish JSON payload with multiple values: {"temp":22.5,"hum":45.3}. Close by considering Add timestamp to messages for data logging.

Learning Outcomes:

Build the decision in sequence. Begin with Configure ESP32 Wi-Fi connection. Then consider Integrate DHT22 sensor with MQTT. Then consider Implement publish with QoS levels. Then consider Handle MQTT reconnection. Close by considering Use retained messages for status.

Challenges:

Build the decision in sequence. Begin with Modify to publish only when temperature changes by +/-0.5C (reduce traffic). Then consider Add battery voltage monitoring and publish with QoS 2. Then consider Implement Last Will and Testament to detect unexpected disconnections. Close by considering Add JSON payload with multiple sensor readings.