Forem: Ganesh Kumar

How to Connect a DHT11 to a NodeMCU v2 board?

Ganesh Kumar — Sat, 04 Apr 2026 16:59:31 +0000

Hello, I'm Ganesh. I'm building git-lrc, an AI code reviewer that runs on every commit. It is free, unlimited, and source-available on Github. Star Us to help devs discover the project. Do give it a try and share your feedback for improving the product.

In this article, we will see how to work with DHT11 sensor with NodeMCU v2 using PlatformIO.

Hardware Check

We should always check datasheets before working with any hardware.

So, by checking the datasheet of DHT11 and NodeMCU v2, we can determine how connection should be done and how to create firmware for it.

You can check datasheets here:

Power Compatibility

As per the datasheet of DHT11, it can operate on a supply range of 3V to 5.5V DC.
Since the NodeMCU v2 runs on 3.3V.

You can power the sensor directly from the NodeMCU's 3V3 pin. This keeps your build simple and safe without needing extra voltage regulators.

Also they recommend to use a pull-up resistor of 4.7K to 10K between VDD and DATA pins.To make sure data is read properly.

Hardware Identification

Check which version of the DHT11 you have. This changes how many pins you’ll be dealing with.

Feature	Bare DHT11 Sensor	DHT11 Module
Appearance	Blue plastic square with 4 metal pins.	Sensor soldered onto a small PCB.
Pin Count	4 Pins.	3 Pins.
Resistor	Required. You must add your own 4.7K to 10K resistor.	Built-in. Usually pre-soldered on the board.

Step-by-Step Wiring Guide

For the 4-Pin Bare Sensor

If you are using the bare sensor, follow this pinout based on the official datasheet:

Pin 1 (VDD): Connect to the 3V3 pin on the NodeMCU.
Pin 2 (DATA): Connect to a digital pin like D1 or D2.
- Crucial Step: Place a 4.7K to 10K pull-up resistor between Pin 1 (VDD) and Pin 2 (DATA). This prevents the signal from "floating" and ensures stable data readings.
Pin 3 (NULL): Leave this disconnected. It serves no electrical purpose.
Pin 4 (GND): Connect to any GND pin on the NodeMCU.

For the 3-Pin Module

If you have the module, life is even easier. The board is usually labeled:

VCC (+): Connect to 3V3.
DATA (out): Connect to D1 or D2.
GND (-): Connect to GND.

Why the Pull-up Resistor Matters?

Without a pull-up resistor, the DATA line doesn't have a clear "High" or "Low" state when the sensor isn't talking, which leads to erratic readings or "Sensor not found" errors.

If you're using the bare sensor, don't skip the 4.7K to 10K resistor (though anything from 4.7K to 10K usually works in a pinch!).

Coding Your DHT11 with PlatformIO

Now that the hardware is ready.

Since we are using PlatformIO, we’ll need to configure our project environment and use the industry-standard Adafruit library.

1. Configure `platformio.ini`

First, we need to tell PlatformIO which board we are using and which library to download. Open your platformio.ini file and ensure it looks like this:

[env:nodemcuv2]
platform = espressif8266
board = nodemcuv2
framework = arduino
monitor_speed = 115200
lib_deps = 
    adafruit/DHT sensor library @ ^1.4.6
    adafruit/Adafruit Unified Sensor @ ^1.1.14

Note: The Adafruit Unified Sensor library is a hidden dependency that the DHT library needs to function correctly.

2. The Main Code (`src/main.cpp`)

In your project’s src folder, open main.cpp. We’ll use a modified version of your snippet specifically tuned for the DHT11.

#include <Arduino.h>
#include "DHT.h"

// Define the NodeMCU pin connected to the DHT11 data pin
// Using D2 (GPIO 4) as per our wiring guide
#define DHTPIN D2     

// Since we are using the DHT11, we specify it here
#define DHTTYPE DHT11   

// Initialize the DHT sensor
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  // Start serial communication at the speed defined in platformio.ini
  Serial.begin(115200);
  Serial.println(F("DHT11 Sensor Initializing..."));

  // Start the sensor
  dht.begin();
}

void loop() {
  // Wait 2 seconds between measurements. 
  // DHT11 is slower than modern sensors; don't rush it!
  delay(2000);

  // Reading temperature or humidity takes about 250 milliseconds!
  float h = dht.readHumidity();
  float t = dht.readTemperature(); // Celsius
  float f = dht.readTemperature(true); // Fahrenheit

  // Check if any reads failed
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Failed to read from DHT sensor! Check your wiring."));
    return;
  }

  // Compute heat index (how it actually feels)
  float hic = dht.computeHeatIndex(t, h, false);

  // Print results to the Serial Monitor
  Serial.print(F("Humidity: "));
  Serial.print(h);
  Serial.print(F("%  |  Temp: "));
  Serial.print(t);
  Serial.print(F("°C  |  Heat Index: "));
  Serial.print(hic);
  Serial.println(F("°C"));
}

DHT11 Sensor Initializing...
Humidity: 45.00 %  |  Temp: 25.00°C  |  Heat Index: 25.00°C
Humidity: 46.00 %  |  Temp: 25.12°C  |  Heat Index: 25.12°C
Humidity: 45.00 %  |  Temp: 25.25°C  |  Heat Index: 25.25°C

Key Adjustments for the DHT11

DHTTYPE: Ensure this is set to DHT11. While the code for a DHT22 is almost identical, the timing and data conversion logic inside the library are different for these two models.
Sampling Rate: The DHT11 has a sampling rate of about 1Hz (one reading per second). Using a delay(2000) (2 seconds) is a "safe bet" to ensure you don't get stale data or errors.
Accuracy Note: Don't be surprised if the readings are slightly different from your home thermostat. The DHT11 is an entry-level sensor with an accuracy of ±2°C for temperature and ±5% for humidity.

Conclusion

We could able to connect DHT11 sensor with NodeMCU v2 using PlatformIO and read temperature and humidity values.

In next article we will learn different sensor.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

Why is Nginx configuration organized as sites-available and sites-enabled?

Ganesh Kumar — Thu, 02 Apr 2026 19:30:03 +0000

In this article, We will exploring how to do nginx configuration directory structure. Why it is organized in this way?

How are ngix config files organized?

Majorly nginx config files are organized in the following way:

Main config file: /etc/nginx/nginx.conf This deal with setting up global configuration for nginx.
Sites available directory: /etc/nginx/sites-available This deal with setting up sites configuration for nginx. Where we can write multiple site configuration files.
Sites enabled directory: /etc/nginx/sites-enabled This deal with enabling sites configuration for nginx. Where we can enable sites configuration.
Logs directory: /var/log/nginx This deal with logs configuration for nginx. Where we can see logs of nginx.
Cache directory: /var/cache/nginx This deal with cache configuration for nginx. Where we can see cache of nginx.

How to write site configuration file?

A site configuration file is a file that is used to configure a site for nginx.

Which you can further read in official documentation https://nginx.org/en/docs/.

These configuration should be written in this directory.

/etc/nginx/sites-available

Once you write the configuration file. This will not enable the site.

How to enable the site?

To enable the site, you need to create a symbolic link from the sites-available directory to the sites-enabled directory.

For example, if you have a site configuration file named example.com in the sites-available directory, you can enable it by running the following command:

we should always test the configuration file before enabling it.

sudo nginx -t

sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/example.com

This will create a symbolic link from the sites-available directory to the sites-enabled directory.

The core reason for using symbolic link is that it will allow us to enable and disable the site without removing the configuration file.

if we directly put the configuration file in sites-enabled directory, then we need to remove the configuration file to disable the site.

That means if I want to update small change.
If the configration was copy to sites-enabled directory, then on nginx server restart, the changes will not be reflected.

so, to make it easier we use symbolic link.

Now once the site is enabled, we need to restart the nginx server to apply the changes.

sudo systemctl restart nginx

Finaly we can access the site in browser.

How to disable the site?

To disable the site, you need to remove the symbolic link from the sites-enabled directory.

sudo rm /etc/nginx/sites-enabled/example.com

By this process it will not delete the configuration file. We can enable and disable the site without removing the configuration file.

Conclusion

By this we understood how to enable and disable the site in nginx.

How configuration file is organized in nginx.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to use Task Scheduler in ESP8266?

Ganesh Kumar — Wed, 01 Apr 2026 12:06:54 +0000

In this article, We will be exploring inbult task function in ESP8266.

Core Logic of Task Scheduler

I want to perform two operations in ESP8266.

Blink LED every 2.5 seconds 1 time.
Blink LED every 5 seconds 2 times.

Let's see how to do this without using inbuilt task scheduler.

Setup Serial communication and LED pin.
Start Loop.
Check if 2.5 seconds have passed since the last task activation.
If yes, perform the blink.
Check if 5 seconds have passed since the last task activation.
If yes, perform the blink

#include <Arduino.h>

unsigned long t25, t50;

/**
 * Performs a single blink on the built-in LED (Active Low).
 * @param message Debug message to output to Serial.
 */
void performBlink(const char *message) {
  Serial.println(message);
  digitalWrite(LED_BUILTIN, 0); // LED ON
  delay(80);
  digitalWrite(LED_BUILTIN, 1); // LED OFF
  delay(80);
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 1); // Start with LED OFF
}

void loop() {
  // Task 1: Every 2.5s (triggers at 2.5s, 5.0s, 7.5s...)
  if (millis() - t25 >= 2500) {
    t25 = millis();
    performBlink("[2.5s] 💡");
  }

  // Task 2: Every 5.0s (triggers at 5.0s, 10.0s...)
  // At 5s, both tasks trigger, resulting in a double blink.
  if (millis() - t50 >= 5000) {
    t50 = millis();
    performBlink("[5.0s] 💡");
  }
}

Output:

[2.5s] 💡
[5.0s] 💡
[2.5s] 💡
[2.5s] 💡
[5.0s] 💡

See as we defined to use 2.5 sec interval for first task and 5 sec interval for second task.

This also mean 2nd time 2.5 sec blink will happen after 5 sec from 1st blink.

This will create 2 times blink in 5 sec.

Using Task Scheduler

We are going to use task scheduler library to perform multiple operations in specific intervals.

Let's see how to do this using task scheduler library.

Include task scheduler library.
Create a scheduler object.
Define tasks.
Add tasks to the scheduler.
Enable tasks.
Run the scheduler.

#include <Arduino.h>
#include <TaskScheduler.h>

Scheduler runner;

/**
 * Performs a single blink pulse.
 * Note: NodeMCU V2 built-in LED is active LOW.
 */
void pulse() {
  digitalWrite(LED_BUILTIN, 0); // ON
  delay(80);
  digitalWrite(LED_BUILTIN, 1); // OFF
  delay(80);
}

void Callback(const char *msg) {
  Serial.println(msg);
  pulse();
}

// Task Definitions
Task t25(2500, TASK_FOREVER, []() { Callback("[2.5s] 💡"); });
Task t50(5000, TASK_FOREVER, []() { Callback("[5.0s] 💡"); });

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 1); // Start OFF

  runner.init();

  // Add tasks to the scheduler
  runner.addTask(t25);
  runner.addTask(t50);

  // Enable tasks
  t25.enable();
  t50.enable();
}

void loop() { runner.execute(); }

By this way we can perform multiple operations in specific intervals without blocking the loop function.

Output:

[5.0s] 💡
[2.5s] 💡
[5.0s] 💡
[2.5s] 💡
[2.5s] 💡

You can also see 5.0s blink is happening first and sometimes 2.5s blink is happening first.

This is because of the task scheduler.

Conclusion

By this we understood how task scheduler works in ESP8266.

And we actualy used task scheduler to perform multiple operations in specific intervals without blocking the loop function.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to perform multiple operations in the ESP8266?

Ganesh Kumar — Mon, 30 Mar 2026 09:23:53 +0000

In this article, We will be exploring how to perform multiple operations in ESP8266.

As we are using ESP8266, we will be using Arduino framework.
Let see how operations are performed in ESP8266 or any other embedded system.

How Operations are performed in ESP8266?

Before going to understand how to perform multiple operations in ESP8266. Let's understand what is how regular programming works in embedded systems.

Any activity in embedded system is done using loop function.

void loop() {
  // Do something
}

This loop function will run continuously.

In this loop we can do multiple things.

For example we can read dht11 sensor data

void loop() {
  // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  // Send data to cloud
  sendDataToCloud(temperature, humidity);
}

But this comes with a problem.

If we run this loop function, it will run continuously. Means there will be no delay between the operations.

How Normal Loop will cause problem?

Let's assume above operation takes 1 ms (which is not true in real world).
And DHT11 sensor should have 1 second delay between readings.

That means above loop will run 1000 times in 1 second to just see if the sensor data is changed.

Can you see the problem?

1000 times operation means 1000 times power consumption.

1000 times power consumption means battery will drain fast or embedded system will heat up.

To Avoid this we can use delay function.

void loop() {
  // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  // Send data to cloud
  sendDataToCloud(temperature, humidity);

  // Wait for 1 second
  delay(1000);
}

By adding delay we are making sure that the loop function is not running continuously.

But this also has a problem.

If we add delay of 1 second, it means the loop function will run only once in 1 second.

So if we want to do multiple operations to be performed in specific intervals. It will be blocked.

Adding Other Operation in loop

Like this if we want to read dht11 sensor every 1 second and read mq2 sensor every 5 seconds. We can't use delay function.

It will be like this

void loop() {
  // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  // Send data to cloud
  sendDataToCloud(temperature, humidity);
  // Read data from sensor
  float gas = analogRead(MQ2_PIN);

  // Send data to cloud
  sendDataToCloud(gas);

  // Wait for 5 seconds
  delay(5000);
}

This will cause 5 sec no data reading from dht11 sensor.

Here where task scheduler comes into picture.

What is Task Scheduler?

A task scheduler is a lightweight system that allows a processor to juggle multiple activities seemingly at the same time, a concept known as multitasking.

A Task Scheduler solves this problem using a "to-do list" approach.

Instead of freezing, the program loops continuously at top speed.

Every time it loops, the scheduler checks the clock and looks at its list of tasks to see if any are due to run right now.

If a task's time is up, the scheduler runs it, and then immediately goes back to checking the clock.

To understand the internal clock, imagine the microcontroller holding a stopwatch that starts counting milliseconds the moment it powers on.

In Arduino framework, this stopwatch is read using a function called millis().

Instead of pausing the whole system to wait, the scheduler constantly checks this stopwatch against a simple formula for each task:

Current Time - Last Time Executed >= Interval

Here is simple example of how task scheduler works in ESP8266.

Ex:

unsigned long previousDHTTime = 0;  // Remembers the last time DHT ran
unsigned long previousMQ2Time = 0;  // Remembers the last time MQ2 ran

const long dhtInterval = 1000;      // 1000 milliseconds = 1 second
const long mq2Interval = 5000;      // 5000 milliseconds = 5 seconds

void setup() {
  // Initialization code goes here
}

void loop() {
  // 1. Read the internal stopwatch
  unsigned long currentMillis = millis(); 

  // 2. Check the DHT Task ⏱️
  if (currentMillis - previousDHTTime >= dhtInterval) {
    previousDHTTime = currentMillis;  // Reset this task's timer
    float temperature = dht.readTemperature();
    float humidity = dht.readHumidity();

    // Send data to cloud
    sendDataToCloud(temperature, humidity);

  }

  // 3. Check the MQ2 Task ⏱️
  if (currentMillis - previousMQ2Time >= mq2Interval) {
    previousMQ2Time = currentMillis;  // Reset this task's timer

    float gas = analogRead(MQ2_PIN);

    // Send data to cloud
    sendDataToCloud(gas);
  }
}

This way we can perform multiple operations in specific intervals without blocking the loop function.

Conclusion

In this article we have seen how to perform multiple operations in specific intervals without blocking the loop function in ESP8266.

In next article we will use inbuilt task scheduler and itegrate with painlessmesh.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to Send Data from PainlessMesh to the Cloud Using MQTT in an ESP8266?

Ganesh Kumar — Sat, 28 Mar 2026 20:46:51 +0000

In this article, I will be demonstrating how to use PainlessMesh and MQTT with a NodeMCUv2 (ESP8266) board.

What Problem we are solving?

We will be reciving data from multiple nodes and send it to cloud using MQTT.

Publish the data from received at gateway to cloud using MQTT
Scallable MQTT topics publishing

How it works?

Receive data from multiple nodes

These data will be in compressed in these format.

void onMeshReceive(const uint32_t &from, const String &msg) {
  Serial.printf("[mesh] From %u: %s\n", from, msg.c_str());

  JsonDocument doc;
  if (deserializeJson(doc, msg) != DeserializationError::Ok) {
    Serial.println("[mesh] JSON parse failed");
    return;
  }

  const char *msgType = doc["type"] | "data";
  String topic = buildTopic(from, msgType);

  if (mqttClient.connected()) {
    mqttClient.publish(topic.c_str(), msg.c_str());
    Serial.printf("[mqtt] Published → %s\n", topic.c_str());
  } else {
    Serial.println("[mqtt] Not connected — message dropped");
  }
}

Publish the data from received at gateway to cloud using MQTT

Setup wifi credentials.

#define STATION_SSID "your_ssid"
#define STATION_PASSWORD "your_password"

Connect to wifi using painlessmesh.

As painlessmesh is heavy library it will consume lot of power and data.

So we will use mesh.stationManual() to connect to wifi.

 mesh.stationManual(STATION_SSID,
                     STATION_PASSWORD); // ← key: mesh owns the STA
  mesh.setHostname("ais-gateway")

Scallable MQTT topics publishing We will use MQTT to send data from gateway to cloud.

We will use these credentials for MQTT.

#define MQTT_HOST "your_mqtt_host"
#define MQTT_PORT_TLS 8883
#define MQTT_USER "your_mqtt_user"
#define MQTT_PASS "your_mqtt_password"

We will use these topics for MQTT.

Each topic will have different meaning.

For example we will use these topics for MQTT.

For sending an industrial sensor data we will use these topics.

#define T_VERSION "v1"
#define T_TENANT "electrotech"
#define T_INDUSTRY "pcba"
#define T_SITE "plant1"
#define T_GATEWAY "gw_01"

Finally followed with config message.

{
  "type": "config",
  "schema": {
    "temp": {"type":"float","scale":10,"offset":0,"min":0,"max":51.1},
    "hum": {"type":"float","scale":10,"offset":-20,"min":20,"max":122.3},
    "gas": {"type":"float","scale":0.1,"offset":0,"min":0,"max":1023}
  }
}

/**
 * gateway.cpp — PainlessMesh Root + MQTT Bridge (HiveMQ TLS)
 *
 * Follows the official painlessMesh MQTT bridge pattern:
 *   - mesh.stationManual() hands WiFi STA management to the mesh library
 *     so it never disconnects from the router to scan for mesh peers.
 *   - MQTT connect is triggered by IP change detection in loop().
 *   - mesh.setRoot(true) called BEFORE init().
 *
 * Data flow: sensor node → mesh → gateway → HiveMQ MQTT → backend
 * Topic format: v1/{tenant}/{industry}/{site}/{gateway}/{node}/{type}
 */

#include <Arduino.h>
#include <ArduinoJson.h>
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <WiFiClientSecure.h>
#include <painlessMesh.h>

// ─── WiFi credentials ────────────────────────────────────────────────────────
#define STATION_SSID "your_ssid"
#define STATION_PASSWORD "your_password"

// ─── Mesh credentials ────────────────────────────────────────────────────────
#define MESH_PREFIX "your_mesh_prefix"
#define MESH_PASSWORD "your_mesh_password"
#define MESH_PORT 5555

// ─── MQTT credentials (from backend .env) ────────────────────────────────────
#define MQTT_HOST "your_mqtt_host"
#define MQTT_PORT_TLS 8883
#define MQTT_USER "your_mqtt_user"
#define MQTT_PASS "your_mqtt_password"

// ─── Topic routing constants ─────────────────────────────────────────────────
#define T_VERSION "v1"
#define T_TENANT "electrotech"
#define T_INDUSTRY "pcba"
#define T_SITE "plant1"
#define T_GATEWAY "gw_01"

// ─── Globals ─────────────────────────────────────────────────────────────────
painlessMesh mesh;
BearSSL::WiFiClientSecure wifiClient;
PubSubClient mqttClient(wifiClient);
IPAddress myIP(0, 0, 0, 0);
unsigned long lastMqttAttempt = 0;

// ─── Helpers ─────────────────────────────────────────────────────────────────

String buildTopic(uint32_t nodeId, const char *msgType) {
  return String(T_VERSION) + "/" + T_TENANT + "/" + T_INDUSTRY + "/" + T_SITE +
         "/" + T_GATEWAY + "/" + String(nodeId) + "/" + msgType;
}

IPAddress getStationIP() { return IPAddress(mesh.getStationIP()); }

// ─── MQTT callback (placeholder for future /cmd downlink) ────────────────────
void mqttCallback(char *topic, byte *payload, unsigned int len) {
  Serial.printf("[mqtt] Received on %s: %.*s\n", topic, (int)len,
                (char *)payload);
  // Phase 2: parse /cmd and forward to specific mesh node via mesh.sendSingle()
}

// ─── Mesh callback: forward every message to the correct MQTT topic
// ───────────
void onMeshReceive(const uint32_t &from, const String &msg) {
  Serial.printf("[mesh] From %u: %s\n", from, msg.c_str());

  JsonDocument doc;
  if (deserializeJson(doc, msg) != DeserializationError::Ok) {
    Serial.println("[mesh] JSON parse failed");
    return;
  }

  const char *msgType = doc["type"] | "data";
  String topic = buildTopic(from, msgType);

  if (mqttClient.connected()) {
    mqttClient.publish(topic.c_str(), msg.c_str());
    Serial.printf("[mqtt] Published → %s\n", topic.c_str());
  } else {
    Serial.println("[mqtt] Not connected — message dropped");
  }
}

// ─── Setup ───────────────────────────────────────────────────────────────────
void setup() {
  Serial.begin(115200);
  delay(100);

  // 1. Mesh — setRoot() and stationManual() BEFORE init()
  //    stationManual() hands STA management to the mesh library:
  //    it will NOT disconnect from the router to scan for mesh peers.
  mesh.setDebugMsgTypes(ERROR | CONNECTION);
  mesh.setRoot(true);
  mesh.setContainsRoot(true);
  mesh.init(MESH_PREFIX, MESH_PASSWORD, MESH_PORT, WIFI_AP_STA); // auto channel
  mesh.onReceive(&onMeshReceive);
  mesh.onNewConnection(
      [](size_t id) { Serial.printf("[mesh] +Node %u\n", (uint32_t)id); });
  mesh.onDroppedConnection(
      [](size_t id) { Serial.printf("[mesh] -Node %u\n", (uint32_t)id); });
  mesh.stationManual(STATION_SSID,
                     STATION_PASSWORD); // ← key: mesh owns the STA
  mesh.setHostname("ais-gateway");

  // 2. TLS client — setInsecure() skips cert check (ok for dev)
  wifiClient.setInsecure();
  wifiClient.setTimeout(5);
  mqttClient.setServer(MQTT_HOST, MQTT_PORT_TLS);
  mqttClient.setCallback(mqttCallback);
  mqttClient.setKeepAlive(30);
  mqttClient.setSocketTimeout(5);
  mqttClient.setBufferSize(512);

  Serial.println("[gw] Gateway started — waiting for IP...");
}

// ─── Loop ────────────────────────────────────────────────────────────────────
void loop() {
  mesh.update();     // must run every iteration
  mqttClient.loop(); // process keep-alive / incoming

  // Connect (or reconnect) to MQTT whenever the station IP changes.
  // This is the official painlessMesh bridge pattern — no blocking delay().
  IPAddress ip = getStationIP();
  if (ip != myIP) {
    myIP = ip;
    Serial.printf("[wifi] IP: %s\n", myIP.toString().c_str());

    if (myIP != IPAddress(0, 0, 0, 0)) {
      Serial.print("[mqtt] Connecting... ");
      String clientId = "gw-" + String(ESP.getChipId(), HEX);
      if (mqttClient.connect(clientId.c_str(), MQTT_USER, MQTT_PASS)) {
        Serial.println("OK");
        // Publish gateway online status
        String statusTopic = String(T_VERSION) + "/" + T_TENANT + "/" +
                             T_INDUSTRY + "/" + T_SITE + "/" + T_GATEWAY +
                             "/status";
        mqttClient.publish(statusTopic.c_str(), "{\"state\":\"online\"}");
      } else {
        Serial.printf("[mqtt] Failed (rc=%d)\n", mqttClient.state());
      }
    }
  }

  // Non-blocking reconnect if MQTT dropped after initial connect
  if (myIP != IPAddress(0, 0, 0, 0) && !mqttClient.connected()) {
    unsigned long now = millis();
    if (now - lastMqttAttempt > 5000) {
      lastMqttAttempt = now;
      Serial.print("[mqtt] Reconnecting... ");
      String clientId = "gw-" + String(ESP.getChipId(), HEX);
      if (mqttClient.connect(clientId.c_str(), MQTT_USER, MQTT_PASS)) {
        Serial.println("OK");
      } else {
        Serial.printf("[mqtt] Failed (rc=%d)\n", mqttClient.state());
      }
    }
  }
}

Conclusion

Though this is very complex in terms of code. It is very efficient in terms of power and data consumption.

If you have any questions or suggestions, please feel free to ask in the comments section.

I will be going indetail how these both sender and receiver works in my next article.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to send sensor data to a gateway using PainlessMesh in ESP8266?

Ganesh Kumar — Fri, 27 Mar 2026 19:04:03 +0000

In this article, I will be demonstrating how to use PainlessMesh with a NodeMCUv2 (ESP8266) board and send data from one ESP8266 board to another ESP8266 board.

What Problem we are solving?

Previously we explored how to use MQTT with ESP8266.

Now let's integrate painlessmesh with MQTT.

Let's assume we have 2 ESP8266 boards.
One is gateway and another is node.

We want to send data from node to gateway using painlessmesh. Next we want to send data from gateway to cloud using MQTT.

For example we will use DHT11 sensor and mq series gas sensor with node to send data to gateway.

This operation should be done with very minimal data transfer.

If one node has 2 or more sensors it should be compressed and sent to gateway.

What We will be achieving?

Painlessmesh is very heavy library. It does lot of operations to keep network alive. With this if we send data without compressing it. It will consume lot of power and data. Casuing network to be unstable.

Main Goal is

Receive data from multiple sensors
Compress the data
Send the data to gateway
Publish the data from received at gateway to cloud using MQTT
Scallable MQTT topics publishing

I will be combining all the above mentioned in single project.

In this article we will be covering first 2 points.

Receiving Data from Multiple Sensors
Compressing the data
Send the data to gateway

Receiving Data from Multiple Sensors and Compressing it

For this example we will use DHT11 sensor and MQ2 gas sensor.

Setup connection with painlessmesh We will use these credentials for painlessmesh.

#define MESH_PREFIX "secreat_name"
#define MESH_PASSWORD "SecreateKey"
#define MESH_PORT 5555

With this funtion we create scheduler and painlessmesh object.

#include <painlessMesh.h>

  mesh.init(MESH_PREFIX, MESH_PASSWORD, &scheduler, MESH_PORT);
  mesh.onReceive(&onReceive);
  mesh.onNewConnection(&onNewConnection);

Setup connection with DHT11 sensor

We use DHT library sensor to measure temperature and humidity.

We use D2 pin to connect DHT11 sensor.

#include <DHT.h>
#define DHT_PIN D2
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);

Read the temperature and humidity from the sensor.

float t = dht.readTemperature();
float h = dht.readHumidity();

As Dht sensor should have 1 second delay between readings. We will use scheduler to read the temperature and humidity from the sensor.

Task readDHTTask(10000, TASK_FOREVER, []() {
    float t = dht.readTemperature();
    float h = dht.readHumidity();
    if (isnan(t) || isnan(h)) {
        Serial.println("Failed to read from DHT sensor!");
        return;
    }
    Serial.printf("Temperature: %.2f C, Humidity: %.2f %%", t, h);
});

Setup connection with MQ2 gas sensor

We use MQ2 gas sensor to measure the gas concentration.

We use A0 pin to connect MQ2 gas sensor.

#define MQ2_PIN A0

Read the gas concentration from the sensor.

float gas = analogRead(MQ2_PIN);

As MQ2 sensor should have 1 second delay between readings. We will use scheduler to read the gas concentration from the sensor.

Task readMQ2Task(10000, TASK_FOREVER, []() {
    float gas = analogRead(MQ2_PIN);
    if (isnan(gas)) {
        Serial.println("Failed to read from MQ2 sensor!");
        return;
    }
    Serial.printf("Gas: %.2f ppm", gas);
});

Compress the data with bit packing

We use bit packing to compress the data.

As sensor will be in specified range we can use bit packing to compress the data.

String packToHex(float temp, float hum, float gas) {
  uint16_t packedTemp = (uint16_t)(temp * 10.0f) & 0x1FF;         // 9 bits
  uint16_t packedHum = (uint16_t)((hum - 20.0f) * 10.0f) & 0x3FF; // 10 bits
  uint16_t packedGas = (uint16_t)(gas / 10.0f) & 0x3FF;           // 10 bits

  uint32_t packed = 0;
  packed |= (uint32_t)packedTemp << 20; // bits 28-20
  packed |= (uint32_t)packedHum << 10;  // bits 19-10
  packed |= (uint32_t)packedGas;        // bits  9-0

  char buf[9];
  snprintf(buf, sizeof(buf), "%08X", packed);
  return String(buf);
}

Finaly commbining all these into one code.

/**
 * sensor_node_1.cpp — PainlessMesh Sensor Node (DHT11 + MQ6)
 *
 * Boot flow:
 *   1. Joins the mesh network
 *   2. On first connection to gateway → broadcasts /config (packing schema)
 *      The gateway forwards /config to MQTT → backend caches the schema
 *   3. After 3 s delay → starts sending /data every 5 s
 *      (gives backend time to process /config before first hex payload arrives)
 *
 * /alert is sent immediately any time gas > GAS_THRESHOLD.
 *
 * Bit packing layout (29 bits used, 3 MSBs unused):
 *   bits 28-20 (9 bits) : temp  = temp_celsius * 10        (0–511 → 0–51.1°C)
 *   bits 19-10 (10 bits): hum   = (humidity - 20) * 10     (0–1023 → 20–122.3%)
 *   bits  9-0  (10 bits): gas   = gas_ppm / 10             (0–1023 → 0–10230
 * ppm)
 */

#include <Arduino.h>
#include <ArduinoJson.h>
#include <DHT.h>
#include <painlessMesh.h>

// ─── Mesh credentials (must match gateway) ───────────────────────────────────
#define MESH_PREFIX "secreat_name"
#define MESH_PASSWORD "SecreateKey"
#define MESH_PORT 5555

// ─── Sensor pins ─────────────────────────────────────────────────────────────
#define DHT_PIN D2
#define DHT_TYPE DHT11
#define MQ6_PIN A0 // analog pin

// ─── Alert threshold ─────────────────────────────────────────────────────────
#define GAS_THRESHOLD 5000 // ppm — triggers /alert

// ─── Timing ──────────────────────────────────────────────────────────────────
#define DATA_INTERVAL_MS 5000

// ─── Globals ─────────────────────────────────────────────────────────────────
Scheduler scheduler;
painlessMesh mesh;
DHT dht(DHT_PIN, DHT_TYPE);
bool configSent = false; // send /config once per gateway connection

// ─── Bit packing ─────────────────────────────────────────────────────────────

/**
 * Pack temperature, humidity and gas into an 8-char hex string.
 * The encoding matches what the backend's unpackHex() expects.
 *
 *   temp  → 9 bits, mult 10, min 0
 *   hum   → 10 bits, mult 10, min 20
 *   gas   → 10 bits, div 10, min 0
 */
String packToHex(float temp, float hum, float gas) {
  uint16_t packedTemp = (uint16_t)(temp * 10.0f) & 0x1FF;         // 9 bits
  uint16_t packedHum = (uint16_t)((hum - 20.0f) * 10.0f) & 0x3FF; // 10 bits
  uint16_t packedGas = (uint16_t)(gas / 10.0f) & 0x3FF;           // 10 bits

  uint32_t packed = 0;
  packed |= (uint32_t)packedTemp << 20; // bits 28-20
  packed |= (uint32_t)packedHum << 10;  // bits 19-10
  packed |= (uint32_t)packedGas;        // bits  9-0

  char buf[9];
  snprintf(buf, sizeof(buf), "%08X", packed);
  return String(buf);
}

// ─── Message builders
// ─────────────────────────────────────────────────────────

/**
 * Build the /config JSON that tells the backend how to decode our hex payloads.
 * This matches the NodeConfig struct on the backend.
 */
String buildConfigMsg() {
  JsonDocument doc;
  doc["type"] = "config";
  doc["hw"] = "NodeMCUv2";

  JsonObject packing = doc["packing"].to<JsonObject>();
  packing["bits"] = 32;
  JsonArray layout = packing["layout"].to<JsonArray>();
  layout.add("temp");
  layout.add("hum");
  layout.add("gas");

  JsonObject sensors = doc["sensors"].to<JsonObject>();
  JsonObject t = sensors["temp"].to<JsonObject>();
  t["model"] = "DHT11";
  t["metric"] = "temperature";
  t["min"] = 0;
  t["max"] = 50;
  t["mult"] = 10;
  t["bits"] = 9;

  JsonObject h = sensors["hum"].to<JsonObject>();
  h["model"] = "DHT11";
  h["metric"] = "humidity";
  h["min"] = 20;
  h["max"] = 90;
  h["mult"] = 10;
  h["bits"] = 10;

  JsonObject g = sensors["gas"].to<JsonObject>();
  g["model"] = "MQ6";
  g["metric"] = "gas_mq6";
  g["min"] = 0;
  g["max"] = 10000;
  g["div"] = 10;
  g["bits"] = 10;

  String out;
  serializeJson(doc, out);
  return out;
}

String buildDataMsg(const String &hexStr) {
  JsonDocument doc;
  doc["type"] = "data";
  doc["d"] = hexStr;
  String out;
  serializeJson(doc, out);
  return out;
}

String buildAlertMsg(const String &hexStr, const char *cause) {
  JsonDocument doc;
  doc["type"] = "alert";
  doc["cause"] = cause;
  doc["d"] = hexStr;
  String out;
  serializeJson(doc, out);
  return out;
}

// ─── Periodic data task
// ────────────────────────────────────────────────────────

Task dataTask(DATA_INTERVAL_MS, TASK_FOREVER, []() {
  float temp = dht.readTemperature();
  float hum = dht.readHumidity();

  // MQ6: raw analog 0-1023 → scale to ppm (rough calibration, adjust to yours)
  int raw = analogRead(MQ6_PIN);
  float gas = raw * (10000.0f / 1023.0f); // map 0-1023 → 0-10000 ppm

  if (isnan(temp) || isnan(hum)) {
    Serial.println("[sensor] DHT read failed");
    return;
  }

  Serial.printf("[sensor] temp=%.1f°C  hum=%.1f%%  gas=%.0f ppm\n", temp, hum,
                gas);

  String hexStr = packToHex(temp, hum, gas);

  // Always send /data
  mesh.sendBroadcast(buildDataMsg(hexStr));

  // Send /alert if threshold breached
  if (gas > GAS_THRESHOLD) {
    Serial.println("[sensor] ⚠ Gas threshold breached — sending alert");
    mesh.sendBroadcast(buildAlertMsg(hexStr, "gas_mq6"));
  }
});

// One-shot task: fires 3 s after /config is sent, then enables dataTask.
// The 3 s gives the gateway time to publish /config to MQTT and the backend
// time to cache the packing schema before the first hex payload arrives.
Task startupTask(3000, 1, []() {
  Serial.println("[sensor] Config settle time elapsed — starting data stream");
  scheduler.addTask(dataTask);
  dataTask.enable();
});

// ─── Mesh callbacks
// ────────────────────────────────────────────────────────────
void onReceive(uint32_t from, String &msg) {
  Serial.printf("[mesh] From %u: %s\n", from, msg.c_str());
  // Future: handle /cmd messages from gateway
}

void onNewConnection(size_t nodeId) {
  Serial.printf("[mesh] +Connected to %u\n", (uint32_t)nodeId);

  if (!configSent) {
    // First connection — push /config so backend can cache packing schema
    mesh.sendBroadcast(buildConfigMsg());
    Serial.println("[mesh] Sent /config — waiting 3 s before data stream");
    configSent = true;

    // Start the 3-second countdown before data begins
    scheduler.addTask(startupTask);
    startupTask.enable();
  }
}

// ─── Setup / Loop
// ─────────────────────────────────────────────────────────────
void setup() {
  Serial.begin(115200);
  delay(100);

  dht.begin();

  mesh.setDebugMsgTypes(ERROR | CONNECTION);
  mesh.setContainsRoot(
      true); // tells node the root (gateway) is in this network
  mesh.init(MESH_PREFIX, MESH_PASSWORD, &scheduler, MESH_PORT);
  mesh.onReceive(&onReceive);
  mesh.onNewConnection(&onNewConnection);

  Serial.printf("[mesh] Node ID: %u — waiting for gateway connection...\n",
                mesh.getNodeId());
}

void loop() { mesh.update(); }

By above code we can send data from multiple sensors to gateway using painlessmesh.

Conclution

In this article we have seen how to use painlessmesh with a NodeMCUv2 (ESP8266) board and send data from one ESP8266 board to another ESP8266 board.

In next article we will integrate scallable gateway.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to Set Up MQTT With ESP8266?

Ganesh Kumar — Tue, 24 Mar 2026 11:10:23 +0000

In this article, I will be demonstrating how to use MQTT with a NodeMCUv2 (ESP8266) board.

What is MQTT?

MQTT is a lightweight messaging protocol for IoT devices.

It is a publish-subscribe protocol, which means that devices can publish messages to a topic and other devices can subscribe to that topic to receive messages.

Why is MQTT needed?

As the ESP8266 is a low-cost WiFi microcontroller, it can connect to a WiFi network, and it can transmit data wirelessly.

For sending data from the ESP8266 to the cloud, we need to use the MQTT protocol.

Integrate MQTT with ESP8266

Let's start with setting up mqtt with esp8266.

We use PubSubClient library for mqtt with esp8266.

Add this in platformio.ini file.

[env:nodemcuv2]
platform = espressif8266
board = nodemcuv2
framework = arduino
upload_speed = 115200
monitor_speed = 115200
lib_deps = 
    knolleary/PubSubClient @ ^2.8

Here is the simple example of MQTT with ESP8266.

#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h> // <-- Added MQTT library

// --- 1. WiFi Credentials ---
const char* ssid = "Add your wifi name"; 
// !! YOU MUST CHANGE THIS to your WiFi password !!
const char* password = "Add your wifi password"; 

// --- 2. MQTT Credentials ---
const char* mqtt_server = "Add your mqtt server";
const int   mqtt_port = 1883;
const char* mqtt_user = "Add your mqtt username";
const char* mqtt_pass = "Add your mqtt password";
// This is the topic we will listen to
const char* mqtt_topic_to_subscribe = "nodemcu/messages";

// --- 3. MQTT Client Objects ---
WiFiClient espClient;
PubSubClient client(espClient);


// --- 4. Function to handle incoming MQTT messages ---
void callback(char* topic, byte* payload, unsigned int length) {
    Serial.print("Message arrived [");
    Serial.print(topic);
    Serial.print("] ");

    // Print the message payload
    for (int i = 0; i < length; i++) {
        Serial.print((char)payload[i]);
    }
    Serial.println();
}

// --- 5. Function to connect to MQTT ---
void reconnect() {
    // Loop until we're reconnected
    while (!client.connected()) {
        Serial.print("Attempting MQTT connection...");
        // Attempt to connect
        if (client.connect("esp32-client-123", mqtt_user, mqtt_pass)) {
            Serial.println("connected");
            // Subscribe to the topic
            client.subscribe(mqtt_topic_to_subscribe);
            Serial.print("Subscribed to topic: ");
            Serial.println(mqtt_topic_to_subscribe);
        } else {
            Serial.print("failed, rc=");
            Serial.print(client.state());
            Serial.println(" try again in 5 seconds");
            // Wait 5 seconds before retrying
            delay(5000);
        }
    }
}

// --- 6. setup() ---
// This runs once at the beginning
void setup() {
    Serial.begin(115200);
    delay(10);

    Serial.println();
    Serial.print("Connecting to: ");
    Serial.println(ssid);

    // Start connecting to WiFi
    WiFi.begin(ssid, password);

    // Wait for the connection to complete
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }

    // If we get here, we are connected!
    Serial.println(""); // New line
    Serial.println("WiFi connected!");
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());

    // --- Add MQTT setup ---
    client.setServer(mqtt_server, mqtt_port);
    client.setCallback(callback); // Set the function to run when a message arrives
}


// --- 7. loop() ---
// This runs over and over, forever
void loop() {
    // Check if connected to MQTT, if not, reconnect
    if (!client.connected()) {
        reconnect();
    }
    // This function processes MQTT messages
    client.loop(); 

    // Small delay to keep things stable
    delay(10); 
}

Output:

Conclusion

Finally, we could set up MQTT with ESP8266.

In the next article, we will use MQTT with PainlessMesh. To send data from one ESP8266 to another ESP8266.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to Set Up PainlessMesh With a NodeMCUv2 (ESP8266) Board?

Ganesh Kumar — Wed, 18 Mar 2026 19:59:30 +0000

In this article, I will be demonstrating how to use PainlessMesh with a NodeMCUv2 (ESP8266) board.

What Problem we are solving?

ESP8266 is a low-cost Wi-Fi microcontroller. It is a popular choice for IoT projects.

Main advantage is it can connect to Wi-Fi network.

If it connect to network and it can transmit data wirelessly.

This make it suitable for IoT projects. Where we need to collect data from sensor and transmit to cloud or any other device.

But this also comes with a limitation. If we need to connect each ESP8266 board to router, then we need to have router in range of each ESP8266 board.

For Example I will name ESP8266 boards as Node A, Node B, Node C.

If Node A and B are within range of and connected to the gateway
If Node C is OUT of the range of the gateway and node B, but Node C is IN of the range of Node A

Node C cannot transmit data to cloud directly.

To Solve this problem we need a mesh or ad-hoc network. Where Node C can transmit data to Node A, and Node A can transmit data to router and then to cloud.

So, There are many ways to solve this problem. Multi Gateway, Repeater, Star Network, Mesh Network.

As, I did few experiments with ESP8266. I found PainlessMesh is a good solution for this problem.

What is PainlessMesh?

PainlessMesh creates a self organizing and repairing network where all nodes are connected.

All nodes in the mesh are equal. The network uses a star topology, avoiding any circular paths.

Messages between different nodes are sent in JSON format, making them easy to understand and produce.

So, Basicaly it is very easy to use and understand library for connecting multiple ESP8266 boards in a mesh network.

Key Features of PainlessMesh

We can see how network are connected in the image below.

It is True ad-hoc networking: Which means all nodes are equal and can communicate with each other. These self organizing and repairing network.

The number of nodes is limited only by the memory of the ESP8266 board.

JSON based: Messages between different nodes are sent in JSON format, making them easy to understand and produce.

Wifi & Networking: It uses ESP8266's wifi radio to create a mesh network.

painlessMesh is not IP networking: It does not use IP networking. It use esp8266's node id for communication for identifying nodes.

What are limitations of PainlessMesh?

If you know little bit about IOT you would have already identified limitations of PainlessMesh.

As it uses json based communication. More data will be consumed for just sending data.

As painlessmesh uses json to keep network alive. It will consume more power. That means instead of sending data esp8266 will be consuming lot of power to keep network alive.

There are many other limitations too. Also I found 2 articles which they had made performance check of painlessmesh. Here is one of the article Performance Assessment of ESP8266 Wireless Mesh Networks

But despite all these limitations, painlessmesh is a good library for small scale projects. which is compatible with ESP8266 boards.

Let's start with setting up painlessmesh with ESP8266.

How to use PainlessMesh With a NodeMCUv2 (ESP8266) Board?

In Previous article we saw how to use DHT22 sensor with ESP8266 in platformio.

Do refer if don't know how to setup platformio.

Now let's focus on setting up painlessmesh with ESP8266.

In the examples folder of painlessmesh library we can find many examples.

Let's start with the basic example.

Add this in platformio.ini file.

[env:nodemcuv2]
platform = espressif8266
board = nodemcuv2
framework = arduino
upload_speed = 115200
monitor_speed = 115200
upload_port = /dev/ttyUSB0
monitor_port = /dev/ttyUSB0
lib_deps = 
    painlessmesh/painlessMesh @ ^1.5.0
    bblanchon/ArduinoJson @ ^7.0.0

And upload the same code to 2 ESP8266 boards.

Add this in main.cpp file.

#include <Arduino.h>
#include <painlessMesh.h>
#include <ArduinoJson.h>

#define   MESH_PREFIX     "MyMeshNetwork"
#define   MESH_PASSWORD   "SecretPassword"
#define   MESH_PORT       5555

Scheduler     userScheduler; // to control your personal task
painlessMesh  mesh;

// Prototype
void receivedCallback( uint32_t from, String &msg );

// Send my ID every 10 seconds to inform others that I am the Server
Task logServerTask(10000, TASK_FOREVER, []() {
    JsonDocument jsonBuffer;
    JsonObject msg = jsonBuffer.to<JsonObject>();

    msg["topic"] = "logServer";
    msg["nodeId"] = mesh.getNodeId();

    String str;
    serializeJson(msg, str);
    mesh.sendBroadcast(str);

    // log to serial
    serializeJson(msg, Serial);
    Serial.printf("\n");
});

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

  // Keep debug messages clean: only show errors and connections
  mesh.setDebugMsgTypes( ERROR | CONNECTION );  

  mesh.init( MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT, WIFI_AP_STA, 6 );
  mesh.onReceive(&receivedCallback);

  mesh.onNewConnection([](size_t nodeId) {
    Serial.printf("New Connection %u\n", nodeId);
  });

  mesh.onDroppedConnection([](size_t nodeId) {
    Serial.printf("Dropped Connection %u\n", nodeId);
  });

  // Add the task to your scheduler
  userScheduler.addTask(logServerTask);
  logServerTask.enable();
}

void loop() {
  mesh.update();
}

void receivedCallback( uint32_t from, String &msg ) {
  Serial.printf("logServer: Received from %u msg=%s\n", from, msg.c_str());
}

Initialize the mesh network.

Add debug messages.

Add new connection callback.

Add dropped connection callback.

Add the task to your scheduler. To make the wifi keep alive.

Compile and upload the code to 2 ESP8266 boards.

Output:

New Connection 1
New Connection 2
logServer: Received from 1 msg={"topic":"logServer","nodeId":1}
logServer: Received from 2 msg={"topic":"logServer","nodeId":2}

Conclusion

Will be shareing detailed example on how to connect painlessmesh with DHT22 sensor in next article.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to use the DHT22 sensor with ESP8266?

Ganesh Kumar — Tue, 17 Mar 2026 20:08:56 +0000

In this article, I will be explaining how to use DHT22 sensor with ESP8266.

Setup Requirements

Most of use confuse with DHT11 and DHT22.

Both are temperature and humidity sensors. But they have different specifications.

DHT22 is more accurate than DHT11.

For visual identification, DT22 comes in white color while DHT11 comes in blue color.

Once this is correctly identified, and have a datasheet with us. We can proceed with the setup.

Integrate Using Pre-built Libraries.

Most of the sensor manufacturers provide libraries for their sensors. Also if they don't provide libraries, we can find libraries for them in the internet.

Mostly we can use arduino IDE for searching libraries.

we can use platformio by just adding the library name in the lib_deps section of platformio.ini file.

PlatformIO Setup

Go to PlatformIO extension in VSCode.

Click on Create New Project.

Give Project Name.
Select the board in my case it was NodeMCU 1.0 (ESP-12E Module).
Select Framework as Arduino.

You can see platformio.ini file with the following content:

; PlatformIO Project Configuration File
;
;   Build options: build flags, source filter
;   Upload options: custom upload port, speed and extra flags
;   Library options: dependencies, extra library storages
;   Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
; Common settings for both environments
; Common settings for both environments
[env]
platform = espressif8266
board = nodemcuv2
framework = arduino
monitor_speed = 115200

How to Code for DHT22 Sensor with ESP8266?

Now we setup project

Let's add library for DHT sensor.

lib_deps = 
    adafruit/DHT sensor library@^1.4.4

In the main code let's add the following code.

#include "DHT.h"

// Define the NodeMCU pin connected to the DHT22 data pin
#define DHTPIN D2     

// Define the sensor type
// If yours is DHT11, then change it to DHT11

#define DHTTYPE DHT22   

// Initialize the DHT sensor
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  // Start the serial communication
  Serial.begin(115200);
  Serial.println(F("DHT22 Sensor Test with NodeMCU!"));

  // Start the sensor
  dht.begin();
}

void loop() {
  // Wait a few seconds between measurements.
  // The DHT22 requires about 2 seconds to stabilize between readings.
  delay(2000);

  // Read humidity
  float h = dht.readHumidity();
  // Read temperature as Celsius (the default)
  float t = dht.readTemperature();
  // Read temperature as Fahrenheit (isFahrenheit = true)
  float f = dht.readTemperature(true);

  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Failed to read from DHT sensor!"));
    return;
  }

  // Compute heat index in Fahrenheit (the default)
  float hif = dht.computeHeatIndex(f, h);
  // Compute heat index in Celsius (isFahreheit = false)
  float hic = dht.computeHeatIndex(t, h, false);

  // Print the results to the Serial Monitor
  Serial.print(F("Humidity: "));
  Serial.print(h);
  Serial.print(F("%  Temperature: "));
  Serial.print(t);
  Serial.print(F("°C "));
  Serial.print(f);
  Serial.print(F("°F  Heat index: "));
  Serial.print(hic);
  Serial.print(F("°C "));
  Serial.print(hif);
  Serial.println(F("°F"));
}

In here we are setting up the DHT22 sensor with ESP8266.

Initialize DHT sensor.

Start DHT sensor.

Read humidity.

Read temperature.

Read heat index.

Print the results.

Compile and Connection of DHT22 with ESP8266

Now we can see tick mark in the bottom of the VSCode.

On clicking it we can verify the code is compiling.

Output 1:

Checking size .pio/build/sensor_node_1/firmware.elf
Advanced Memory Usage is available via "PlatformIO Home > Project Inspect"
RAM:   [===       ]  34.5% (used 28236 bytes from 81920 bytes)
Flash: [===       ]  26.3% (used 274819 bytes from 1044464 bytes)
======================================================================= [SUCCESS] Took 0.56 seconds =======================================================================

After compilation we can upload the code to the ESP8266 by clicking the upload button.

Now we can connect the vin pin of DHT22 to 3V3 pin of ESP8266 and gnd pin of DHT22 to gnd pin of ESP8266.
Data pin of DHT22 to D2 pin of ESP8266.

Uploading the code to ESP8266

Connect ESP8266 to the computer and click on arrow button.

Output 2:

Writing at 0x0002c000... (92 %)
Writing at 0x00030000... (100 %)
Wrote 278976 bytes (204732 compressed) at 0x00000000 in 18.0 seconds (effective 123.7 kbit/s)...
Hash of data verified.

Leaving...
Hard resetting via RTS pin...

Finally we can see the output in the serial monitor on clicking socket button.

Output 3:

DHT22 Sensor Test with NodeMCU!
Humidity: 51.80%  Temperature: 31.30°C 88.34°F  Heat index: 33.51°C 92.31°F
Humidity: 51.80%  Temperature: 31.30°C 88.34°F  Heat index: 33.51°C 92.31°F
Humidity: 51.80%  Temperature: 31.30°C 88.34°F  Heat index: 33.51°C 92.31°F
Humidity: 51.70%  Temperature: 31.30°C 88.34°F  Heat index: 33.49°C 92.27°F

Conclusion

Now we could able to setup and test DHT22 sensor with ESP8266.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

What Do You Need to Know About the DHT22 Sensor Before Using It?

Ganesh Kumar — Sun, 15 Mar 2026 19:42:13 +0000

In this article, I will be explaining the DHT22 sensor.

What is the DHT22 sensor?

So, Based on datasheet provided by the manufacturer.

DHT22 is a low cost digital temperature and humidity sensor.

It is a digital sensor, which means it outputs a digital signal, which can be read by a microcontroller.

What are it's Key Features?

Sensor Type: Digital-output relative humidity and temperature sensor/module.

Key Features: It offers full-range temperature compensation, a calibrated digital signal, outstanding long-term stability, and low power consumption.

Design: It comes in a 4-pin single row package and is fully interchangeable. Where only 3 pins are used. It does not require any extra components.

What are it's Technical Specifications of DHT22?

Power Supply: It operates on 3.3-6V DC. Which means it can be powered by 3.3v supply microcontrollers like ESP32, ESP8266, Raspberry Pi Pico, etc. It can also be connected with 5v supply microcontrollers like Arduino Uno, etc.
But it is recommended to use 3.3v supply for better accuracy.

Output Signal: Digital signal via single-bus.

Operating Range: Humidity 0-100% RH; Temperature -40 to 80 Celsius.

Accuracy: Humidity ±2% RH (Max ±5% RH); Temperature <±0.5 Celsius.

Resolution: Humidity 0.1% RH; Temperature 0.1 Celsius.

Long-term Stability: ±0.5% RH/year.
Sensing Period: Average of 2 seconds.

What is the Pin Configuration of DHT22?

Pin 1: VDD (Power supply).

Pin 2: DATA (Signal).

Pin 3: NULL (No connection).

Pin 4: GND (Ground).

Which Communication Protocol DHT22 uses?

It uses a single-bus communication between the microcontroller (MCU) and the DHT22, taking about 5ms for a single communication.

Data Format: The sensor sends 40-bit data in this exact structure:

8-bit integral RH data
8-bit decimal RH data
8-bit integral T data
8-bit decimal T data
8-bit check-sum.

The check-sum should equal the sum of the first four 8-bit data blocks if the transmission was successful.

What are the Operational Precautions of DHT22?

Chemical Exposure: Vapor from chemical materials can interfere with its sensitive elements and decrease sensitivity.

Environmental Factors: You should avoid using the sensor under dew conditions and keep it away from prolonged exposure to strong light and ultraviolet rays, as this can degrade performance.

Soldering: Welding temperature must be kept below 260 Celsius.
Safety Warning: Do not use this product in safety or emergency stop devices, or in any situation where its failure could cause personal injury.

Conclusion

We could understand about DHT22 sensor. Majorly identified it's features, technical specifications, pin configuration, communication protocol, and operational precautions.

For even more detailed information, you can refer to the datasheet provided by the manufacturer. Link to datasheet

In the next article, let's connect the MCU to the sensor and read sensor data.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to work with buffered channels?

Ganesh Kumar — Fri, 13 Mar 2026 17:55:12 +0000

In Channels We Go, there are 2 types of channels.

Buffered channels
Unbuffered channels

In this article, we will learn about buffered channels.

Buffered channels

Buffered channels are channels that have a buffer size.

How to create a buffered channel?

Which will be defined by the second argument to the makefunction.

This will make the channel able to hold the number of values equal to the buffer size.

package main

import "fmt"

func main() {
    ch := make(chan int, 2)
    ch <- 1
    ch <- 2
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

Let's add 2 values to the channel and print them.

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
1
2

Now let's add 3 values to the channel and print them.

package main

import "fmt"

func main() {
    ch := make(chan int, 2)
    ch <- 1
    ch <- 2
    ch <- 3
    fmt.Println(<-ch)
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
        /home/gk/exp/code/rd/go-exmaple/main.go:9 +0x58
exit status 2

In the error message, we can see that all goroutines are asleep—deadlock!

This is because we are trying to send 3 values to the channel which has a buffer size of 2.

So, the value 3 will be waiting for a receiver to receive it.

But there is no receiver to receive it.

So, the program will deadlock.

Also, we are sending 3 values in the main thread and receiving 3 values in the main thread. So, the program will deadlock.

How to avoid deadlock:

we should send values to the channel in a separate goroutine.

The receiver should be in a separate goroutine.

package main

import "fmt"

func main() {
    ch := make(chan int, 2)

    // Start a concurrent routine to send the data
    go func() {
        ch <- 1
        ch <- 2
        ch <- 3
    }()

    // Main routine reads the data as it comes in
    fmt.Println(<-ch)
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
1
2
3

Loop over a channel

We can use the for range loop to iterate over a channel.

package main

import "fmt"

func main() {
    ch := make(chan int, 2)

    // Start a concurrent routine to send the data
    go func() {
        ch <- 1
        ch <- 2
        ch <- 3
    }()

    // Main routine reads the data as it comes in
    for i := range ch {
        fmt.Println(i)
    }
}

Expected Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
1
2
3

Actual Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
1
2
3
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
        /home/gk/exp/code/rd/go-exmaple/main.go:16 +0xc5
exit status 2

We expected the output to be 1, 2, 3.
But we got a deadlock.

This is because the for range loop will wait for the channel to be closed.

But we didn't close the channel.

let's close the channel.

package main

import "fmt"

func main() {
    ch := make(chan int, 2)

    // Start a concurrent routine to send the data
    go func() {
        ch <- 1
        ch <- 2
        ch <- 3
        close(ch)
    }()

    // Main routine reads the data as it comes in
    for i := range ch {
        fmt.Println(i)
    }
}

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
1
2
3

Conclusion

We explored how to work with buffered channels.

Understood how to avoid deadlock in buffered channels.

We also understood how to loop over a channel.

Next we will see how to work with unbuffered channels.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to work with channels?

Ganesh Kumar — Thu, 12 Mar 2026 21:10:55 +0000

In this article we will understand how to work with channels.

What is a channel? Why it is needed?

Channels are used to pass data between goroutines.
They are a way to synchronize the flow of data between different parts of a program.

When to use channels?

Let's see the example below.

Have 2 goroutines to calculate the sum of an array.

First, we will calculate the sum of the first half of the array.

Second, we will calculate the sum of the second half of the array.

package main

import (
    "fmt"
)

func add(a []int, c chan int) {
    sum := 0
    for _, v := range a {
        sum += v
    }
    c <- sum
}

func main() {
    a := []int{7, 2, 8, -9, 4, 0}

    c1 := make(chan int)
    go add(a[:len(a)/2], c1)

    c2 := make(chan int)
    go add(a[len(a)/2:], c2)

    x, y := <-c1, <-c2
    fmt.Println(x, y, x+y)
}

Finally, we will print the sum of the first half and the second half of the array.

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
17 -5 12

Conclusion

Channels play a crucial role in concurrent programming by enabling safe communication and synchronization between goroutines.
This makes it easier to build concurrent programs that are both efficient and safe.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

Forem: Ganesh Kumar

How to Connect a DHT11 to a NodeMCU v2 board?

Hardware Check

Power Compatibility

Hardware Identification

Step-by-Step Wiring Guide

For the 4-Pin Bare Sensor

For the 3-Pin Module

Why the Pull-up Resistor Matters?

Coding Your DHT11 with PlatformIO

1. Configure platformio.ini

2. The Main Code (src/main.cpp)

Key Adjustments for the DHT11

Conclusion

Why is Nginx configuration organized as sites-available and sites-enabled?

How are ngix config files organized?

How to write site configuration file?

How to enable the site?

How to disable the site?

Conclusion

How to use Task Scheduler in ESP8266?

Core Logic of Task Scheduler

Using Task Scheduler

Conclusion

How to perform multiple operations in the ESP8266?

How Operations are performed in ESP8266?

How Normal Loop will cause problem?

Adding Other Operation in loop

What is Task Scheduler?

Conclusion

How to Send Data from PainlessMesh to the Cloud Using MQTT in an ESP8266?

What Problem we are solving?

How it works?

Conclusion

How to send sensor data to a gateway using PainlessMesh in ESP8266?

What Problem we are solving?

What We will be achieving?

Receiving Data from Multiple Sensors and Compressing it

Conclution

How to Set Up MQTT With ESP8266?

What is MQTT?

Why is MQTT needed?

Integrate MQTT with ESP8266

Conclusion

How to Set Up PainlessMesh With a NodeMCUv2 (ESP8266) Board?

What Problem we are solving?

What is PainlessMesh?

Key Features of PainlessMesh

What are limitations of PainlessMesh?

How to use PainlessMesh With a NodeMCUv2 (ESP8266) Board?

Conclusion

How to use the DHT22 sensor with ESP8266?

Setup Requirements

Integrate Using Pre-built Libraries.

PlatformIO Setup

How to Code for DHT22 Sensor with ESP8266?

Compile and Connection of DHT22 with ESP8266

Uploading the code to ESP8266

Conclusion

What Do You Need to Know About the DHT22 Sensor Before Using It?

What is the DHT22 sensor?

What are it's Key Features?

What are it's Technical Specifications of DHT22?

What is the Pin Configuration of DHT22?

Which Communication Protocol DHT22 uses?

What are the Operational Precautions of DHT22?

Conclusion

How to work with buffered channels?

Buffered channels

How to create a buffered channel?

How to avoid deadlock:

Loop over a channel

Conclusion

How to work with channels?

What is a channel? Why it is needed?

When to use channels?

Conclusion

1. Configure `platformio.ini`

2. The Main Code (`src/main.cpp`)