ESP32 WiFi Mesh Network: Whole-Home IoT

An ESP32 WiFi mesh network lets you extend IoT sensor coverage across your entire home, office, or campus without worrying about WiFi range limitations. Using the ESP-MESH protocol built into the ESP-IDF framework, multiple ESP32 nodes self-organise into a mesh topology where each node acts as both a sensor and a relay, passing data through the network until it reaches a root node connected to the internet. This guide shows you how to build a complete mesh network from scratch.

Why Mesh Networks for IoT?
Understanding ESP-MESH Protocol
Hardware Requirements
Building with painlessMesh Library
Practical: Temperature Sensor Mesh
Root Node as Internet Gateway
Optimising Mesh Performance
Frequently Asked Questions

Why Mesh Networks for IoT?

Traditional WiFi networks use a star topology — every device connects directly to the router. This creates two problems for IoT deployments:

Range limitation: A typical WiFi router covers 15-30 metres indoors. Sensors in far rooms, the terrace, or the garden may not reach the router.
Single point of failure: If the router fails, all devices go offline.

A mesh network solves both problems. Each ESP32 node communicates with its nearest neighbours, and data hops through the network node-by-node until it reaches the root node (which has internet access). Benefits include:

Self-healing: If one node fails, the network automatically reroutes around it
Extended range: Each node extends the network by another 15-30 metres
No router dependency: Nodes communicate peer-to-peer without a central access point
Scalability: Add nodes as needed — the network adapts automatically

Understanding ESP-MESH Protocol

ESP-MESH is built on top of the WiFi protocol and creates a tree-like network topology:

Root Node: The topmost node. Connected to the external WiFi router for internet access. Only one root node exists per mesh network.
Parent Nodes: Intermediate nodes that relay data between leaf nodes and the root.
Leaf Nodes: End nodes that only send and receive data, do not relay for other nodes.

Key characteristics of ESP-MESH:

Supports up to 1000 nodes (ESP-IDF) or ~50 nodes (painlessMesh)
Up to 6 layers deep (root → 5 hops)
Automatic parent selection based on signal strength
Each node can connect to the mesh AND run as a WiFi access point simultaneously
Messages are JSON-formatted and can be broadcast or sent to specific nodes

🛒 Recommended: ESP32 Development Board CP2102 38-Pin — Affordable ESP32 board with CP2102 USB-serial chip, perfect for mesh network nodes.

Hardware Requirements

For a basic 4-node mesh network you need:

4x ESP32 development boards (any variant with WiFi)
4x USB cables for power
Sensors for each node (DHT22, LDR, PIR, etc.)
USB power banks or phone chargers for deployment

Total cost: approximately ₹1,200-2,000 for a 4-node network (₹300-500 per ESP32 board).

🛒 Recommended: ESP32 38-Pin WiFi+Bluetooth Development Board — Ultra-low power dual-core ESP32 board ideal for battery-powered mesh nodes.

Building with painlessMesh Library

The painlessMesh library simplifies ESP-MESH programming enormously. Install it from the Arduino Library Manager (search for “painlessMesh” by GitLab).

Basic Mesh Node

#include <painlessMesh.h>

#define MESH_PREFIX   "ZboticMesh"
#define MESH_PASSWORD "mesh_password_123"
#define MESH_PORT     5555

painlessMesh mesh;

// Called when a message is received
void receivedCallback(uint32_t from, String &msg) {
  Serial.printf("Received from %u: %sn", from, msg.c_str());
}

// Called when mesh topology changes
void changedConnectionCallback() {
  Serial.printf("Mesh changed. Nodes: %dn", 
    mesh.getNodeList().size() + 1);
}

// Called when a new node connects
void newConnectionCallback(uint32_t nodeId) {
  Serial.printf("New node connected: %un", nodeId);
}

void setup() {
  Serial.begin(115200);
  
  mesh.setDebugMsgTypes(ERROR | STARTUP);
  mesh.init(MESH_PREFIX, MESH_PASSWORD, MESH_PORT);
  
  mesh.onReceive(&receivedCallback);
  mesh.onChangedConnections(&changedConnectionCallback);
  mesh.onNewConnection(&newConnectionCallback);
  
  Serial.print("Node ID: ");
  Serial.println(mesh.getNodeId());
}

void loop() {
  mesh.update();
  
  // Send a message every 10 seconds
  static unsigned long lastSend = 0;
  if (millis() - lastSend > 10000) {
    String msg = "Hello from node " + String(mesh.getNodeId());
    mesh.sendBroadcast(msg);
    Serial.println("Broadcast: " + msg);
    lastSend = millis();
  }
}

Flash this same code to all ESP32 boards. They will automatically discover each other and form a mesh. The MESH_PREFIX and MESH_PASSWORD must be identical on all nodes.

Practical: Temperature Sensor Mesh

Here is a complete example with each node reading a DHT22 sensor and broadcasting temperature/humidity data in JSON format:

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

#define MESH_PREFIX   "ZboticMesh"
#define MESH_PASSWORD "mesh_password_123"
#define MESH_PORT     5555
#define DHT_PIN       4
#define DHT_TYPE      DHT22
#define ROOM_NAME     "Living Room"  // Change per node

painlessMesh mesh;
DHT dht(DHT_PIN, DHT_TYPE);

void receivedCallback(uint32_t from, String &msg) {
  // Parse incoming JSON
  JsonDocument doc;
  deserializeJson(doc, msg);
  
  Serial.printf("[%s] Temp: %.1fC, Humidity: %.1f%%n",
    doc["room"].as(),
    doc["temp"].as(),
    doc["humidity"].as());
}

void changedConnectionCallback() {
  Serial.printf("Network: %d nodes connectedn",
    mesh.getNodeList().size() + 1);
}

void setup() {
  Serial.begin(115200);
  dht.begin();
  
  mesh.init(MESH_PREFIX, MESH_PASSWORD, MESH_PORT);
  mesh.onReceive(&receivedCallback);
  mesh.onChangedConnections(&changedConnectionCallback);
}

void loop() {
  mesh.update();
  
  static unsigned long lastRead = 0;
  if (millis() - lastRead > 30000) { // Every 30 seconds
    float temp = dht.readTemperature();
    float humidity = dht.readHumidity();
    
    if (!isnan(temp) && !isnan(humidity)) {
      JsonDocument doc;
      doc["nodeId"] = mesh.getNodeId();
      doc["room"] = ROOM_NAME;
      doc["temp"] = temp;
      doc["humidity"] = humidity;
      doc["uptime"] = millis() / 1000;
      
      String msg;
      serializeJson(doc, msg);
      mesh.sendBroadcast(msg);
      
      Serial.printf("Sent: %s: %.1fC, %.1f%%n",
        ROOM_NAME, temp, humidity);
    }
    lastRead = millis();
  }
}

Change the ROOM_NAME variable for each node before flashing: “Living Room”, “Bedroom”, “Kitchen”, “Terrace”, etc. Each node will broadcast its readings and display readings from all other rooms.

Root Node as Internet Gateway

To send mesh data to the internet (for a web dashboard or MQTT broker), designate one node as the root and connect it to your WiFi router:

#include <painlessMesh.h>
#include <WiFiClient.h>

#define MESH_PREFIX   "ZboticMesh"
#define MESH_PASSWORD "mesh_password_123"
#define MESH_PORT     5555
#define WIFI_SSID     "YourHomeWiFi"
#define WIFI_PASS     "YourWiFiPassword"

painlessMesh mesh;

void receivedCallback(uint32_t from, String &msg) {
  Serial.printf("Gateway received from %u: %sn", from, msg.c_str());
  
  // Forward to HTTP server
  WiFiClient client;
  if (client.connect("api.thingspeak.com", 80)) {
    // Parse and forward sensor data
    // ... HTTP POST implementation
    client.stop();
  }
}

void setup() {
  Serial.begin(115200);
  
  mesh.setDebugMsgTypes(ERROR | STARTUP);
  mesh.init(MESH_PREFIX, MESH_PASSWORD, MESH_PORT);
  mesh.onReceive(&receivedCallback);
  
  // Connect mesh to WiFi router
  mesh.stationManual(WIFI_SSID, WIFI_PASS);
  mesh.setHostname("MeshGateway");
  mesh.setRoot(true);           // This node is the root
  mesh.setContainsRoot(true);   // Tell mesh a root exists
}

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

🛒 Recommended: ESP32 LoRa with OLED Display — Use as a gateway node with the OLED displaying real-time mesh network status and sensor data.

Optimising Mesh Performance

Reduce broadcast frequency: Sending data every 30-60 seconds is ideal. More frequent broadcasts cause congestion in larger networks.
Use targeted messages: Use mesh.sendSingle(nodeId, msg) instead of broadcast when you know the destination. This reduces network traffic.
Limit network depth: Keep the mesh to 3-4 layers. Each hop adds latency. Place nodes so that every sensor is within 2-3 hops of the root.
Power management: For battery-powered nodes, use ESP32 light sleep between sensor readings. The painlessMesh library supports task scheduling via the built-in task scheduler.
Channel selection: The mesh uses WiFi channel 1 by default. In Indian apartments with many WiFi networks, change to channel 6 or 11 to avoid interference.

Frequently Asked Questions

How many ESP32 nodes can be in one mesh?

The painlessMesh library practically supports up to 50 nodes. The ESP-IDF native mesh implementation supports up to 1000 nodes. For most home and small office applications, 10-20 nodes provide excellent coverage.

What is the range between mesh nodes?

Each ESP32 node can communicate up to 30 metres indoors through walls, and 100+ metres in open areas. The mesh extends range by relaying — a 5-node chain can cover 150 metres of building.

Can I mix ESP32 and ESP8266 in the same mesh?

Yes, painlessMesh supports both ESP32 and ESP8266. However, ESP8266 has limited memory and can only handle smaller networks. Use ESP32 for parent nodes and ESP8266 for simple leaf nodes.

Does the mesh work without internet?

Yes. The mesh network is completely independent of the internet. Nodes can communicate with each other without any WiFi router. The internet connection is only needed if you want to send data to cloud services.

How does the mesh handle power failures?

When a node loses power and comes back, it automatically rejoins the mesh. If the root node fails, another node can be promoted to root. The network is self-healing by design.

Conclusion

Building an ESP32 WiFi mesh network is the most cost-effective way to deploy IoT sensors across a large area. With nodes costing under ₹500 each and no central infrastructure required, you can cover your entire home, hostel floor, office building, or warehouse with temperature, humidity, motion, and air quality sensors. The painlessMesh library makes setup incredibly simple — flash the same code to all boards and they auto-organise into a network.

Start building your mesh network today. Explore our range of ESP32 development boards at Zbotic.in — we stock 30-pin, 38-pin, and specialty ESP32 boards with fast delivery across India.