Connecting Two ESP8266s Over Wi-Fi: A Complete Guide with Code Examples

Wireless connection between two microcontrollers ESP8266 Opens up wide possibilities for creating distributed smart home systems, sensors with remote data transmission, or even simple chatbots based on IoT devices. Unlike the classic wired Arduino connection, Wi-Fi communication allows modules to be placed at a distance of up to 100 meters (under ideal conditions) without losing stability. However, many encounter problems when first attempting to establish such interaction: one module fails to see the other, data transfer is delayed, or the connection constantly breaks.

In this article we will look at three main methods of communication between ESP8266: through TCP server/client, UDP protocol and data exchange through MQTT brokerEach method has its pros and cons—for example, TCP is more reliable for transmitting critical data, while UDP is faster and easier to implement. We'll cover the configuration of each option in detail and provide ready-made sketches for Arduino IDE, and we will also tell you how to diagnose errors of the type connection failed or WiFi disconnectedIf you've never worked with network protocols on microcontrollers before, don't worry: all examples are tailored for beginners, with explanations for every line of code.

1. Preparation of equipment and software

Before you start programming, make sure you have everything you need. You'll need:

• 🔌 Two modules ESP8266 (For example, NodeMCU or Wemos D1 Mini). Any version will do, but it is better to use models with external antenna for greater connection stability.
• 💻 Computer with installed Arduino IDE (version 2.0 or later). Alternative - PlatformIO, but in this article we will use the classic environment.
• 🔌 USB cables for flashing and powering modules. Please note: some cheap cables may not provide sufficient current, resulting in unstable Wi-Fi operation.
• 📡 Wi-Fi router (router) with support for the standard 802.11 b/g/n. Modules ESP8266 don't work with modern ones Wi-Fi 6, so if you have a new router, you may need to enable compatibility mode.

Also check that in Arduino IDE drivers are installed for ESP8266To do this, go to File → Settings and in the field Additional links for the board manager add:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Then in Tools → Board → Board Manager find esp8266 and install the latest version. If you already have experience with ESP32, remember: libraries and settings for ESP8266 may differ!

⚠️ Attention: If you use modules ESP-01 with a limited number of pins, please note that firmware may require jumper between GPIO0 And GNDWithout it, loading the code will not be possible.

2. Method 1: Communication via TCP server and client

This is the most reliable method of data exchange, because The TCP protocol guarantees packet delivery. and monitors the integrity of the transmitted information. One module will act as servers, and the second one is clientThe server listens for incoming connections on a specified port, and the client initiates the connection and sends data.

Below is a sample code for servers (download to the first one) ESP8266):

#include <ESP8266WiFi.h>

const char* ssid = "your_SSID";
const char* password ="your_password";
WiFiServer server(80); // Port 80 (you can use any free one)

void setup {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status!= WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Server IP address:");
Serial.println(WiFi.localIP);
server.begin;
}

void loop {
WiFiClient client = server.available;
if (client) {
Serial.println("New client connected!");
while (client.connected) {
if (client.available) {
String data = client.readStringUntil('\n');
Serial.print("Received:");
Serial.println(data);
client.print("Server accepted:" + data); // Response to the client
}
}
client.stop;
Serial.println("The client has disconnected.");
}
}

Code for client (we load it on the second one) ESP8266):

#include <ESP8266WiFi.h>

const char* ssid = "your_SSID";
const char* password ="your_password";
const char* host ="IP_address_of_the_server"; // Specify the IP that the server returned
const uint16_t port = 80;

void setup {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status!= WL_CONNECTED) {
delay(500);
Serial.print(".");
}
}

void loop {
WiFiClient client;
if (!client.connect(host, port)) {
Serial.println("Connection failed...");
delay(5000);
return;
}
client.print("Greetings from the client!\n");
while (client.connected) {
if (client.available) {
String response = client.readStringUntil('\n');
Serial.println("The server responded:" + response);
}
}
client.stop;
delay(2000); // Pause before reconnecting
}

After downloading the code, open Serial Monitor V Arduino IDE (speed 115200 baud) and check the data exchange. If the connection is not established:

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

const char* ssid = "your_SSID";
const char* password ="your_password";
WiFiUDP udp;
unsigned int localPort = 4210; // Listening port

void setup {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status!= WL_CONNECTED) delay(500);
udp.begin(localPort);
Serial.print("UDP server started on port");
Serial.println(localPort);
}

void loop {
int packetSize = udp.parsePacket;
if (packetSize) {
char packetBuffer[255];
int len = udp.read(packetBuffer, 255);
if (len > 0) packetBuffer[len] ='\0';
Serial.print("Received:");
Serial.println(packetBuffer);

// Sending a response
udp.beginPacket(udp.remoteIP, udp.remotePort);
udp.write("The server has accepted your message!");
udp.endPacket;
}
}

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

const char* ssid = "your_SSID";
const char* password ="your_password";
WiFiUDP udp;
const char* serverIP ="IP_address_of_the_server";
unsigned int serverPort = 4210;

void setup {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status!= WL_CONNECTED) delay(500);
}

void loop {
udp.beginPacket(serverIP, serverPort);
udp.print("Greetings from UDP client!");
udp.endPacket;
delay(1000);

// Check the response from the server
int packetSize = udp.parsePacket;
if (packetSize) {
char reply[255];
int len = udp.read(reply, 255);
if (len > 0) reply[len] ='\0';
Serial.print("The server responded:");
Serial.println(reply);
}
}

Protocol MQTT (Message Queuing Telemetry Transport) is ideal for systems with a large number of devices where each module needs to send data to a central server (broker) and receive commands from it. Unlike a direct TCP/UDP connection, there is no need to know the IP addresses of the devices—they communicate via topics (topics).

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

const char* ssid = "your_SSID";
const char* password ="your_password";
const char* mqtt_server ="broker.hivemq.com"; // Public broker
const char* topic_pub ="esp8266/sensor1";
const char* topic_sub ="esp8266/command";

WiFiClient espClient;
PubSubClient client(espClient);

void callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Message in topic [");
Serial.print(topic);
Serial.print("]:");
for (int i = 0; i < length; i++) {
Serial.print((char)payload[i]);
}
Serial.println;
}

void setup {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status!= WL_CONNECTED) delay(500);
client.setServer(mqtt_server, 1883);
client.setCallback(callback);
}

void reconnect {
while (!client.connected) {
if (client.connect("ESP8266Client")) {
client.subscribe(topic_sub);
} else {
delay(5000);
}
}
}

void loop {
if (!client.connected) reconnect;
client.loop;

// Send data every 2 seconds
static unsigned long lastMsg = 0;
if (millis - lastMsg > 2000) {
lastMsg = millis;
int value = random(0, 100);
char msg[50];
snprintf(msg, 50,"Sensor value: %d", value);
client.publish(topic_pub, msg);
}
}

Serial.print("Wi-Fi status:");
Serial.println(WiFi.status); // Prints the numeric status code

Serial.print("Signal level (RSSI):");
Serial.print(WiFi.RSSI);
Serial.println(" dBm");

#include <espnow.h>

// MAC address of the second module (specify yours!)
uint8_t broadcastAddress = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

void setup {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
if (esp_now_init!= 0) {
Serial.println("ESP initialization error - NOW!");
return;
}
esp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER);
esp_now_add_peer(broadcastAddress, ESP_NOW_ROLE_SLAVE, 1, NULL, 0);
}

unsigned long startTime = millis;
//... sending data...
unsigned long endTime = millis;
Serial.print("Delay:");
Serial.print(endTime - startTime);
Serial.println("ms");

String encrypt(String data, char key) {
String result ="";
for (int i = 0; i < data.length; i++) {
result += char(data[i] ^ key);
}
return result;
}