Week 11 Group Assignment — Networking and Communications

Project Context

This group assignment demonstrates wireless communication between two independent embedded systems using the ESP-NOW protocol. Unlike conventional Wi-Fi communication, ESP-NOW allows ESP32 devices to exchange data directly without requiring a wireless router or internet connection, making it an efficient solution for low-latency embedded applications.

The system was implemented using two Seeed Studio XIAO ESP32-C3 development boards. One board acts as the transmitter, reading two push buttons and sending a message whenever one of them is pressed. The second board acts as the receiver, listening for incoming ESP-NOW packets and displaying the received value on an SSD1306 OLED display through the I²C interface.

Communication Workflow

Before communication can begin, both ESP32 boards must identify their unique MAC addresses and register each other as trusted peers. Once paired, the transmitter sends an integer value whenever a button is pressed, and the receiver automatically processes the incoming packet through an event-driven callback function, updating the OLED display in real time.

This architecture demonstrates how multiple embedded systems can cooperate wirelessly, combining digital inputs, peer-to-peer networking, and graphical feedback without relying on external networking infrastructure.

System architecture showing the ESP-NOW communication between two XIAO ESP32-C3 boards. The transmitter reads two push buttons and sends the corresponding command wirelessly to the receiver, which displays the received value on an SSD1306 OLED display.

Device Identification – MAC Address

Unlike traditional Wi-Fi communication, ESP-NOW establishes a direct peer-to-peer connection between ESP32 devices. Each board is identified by a unique 48-bit MAC (Media Access Control) address, which acts as its hardware identifier on the wireless network.

Before sending any data, both XIAO ESP32-C3 boards must discover their own MAC addresses. These addresses are then used to register each board as a trusted peer, allowing secure point-to-point communication without requiring a Wi-Fi router.

#include <WiFi.h>

void setup() {

  Serial.begin(115200);
  delay(1000);

  WiFi.mode(WIFI_STA);

  Serial.println("Getting MAC Address...");

  Serial.print("MAC: ");
  Serial.println(WiFi.macAddress());

}

void loop() {

}

ESP-NOW Transmitter

Once both XIAO ESP32-C3 boards were identified, the first device was configured as the ESP-NOW transmitter. Its purpose is to continuously monitor two push buttons and send a wireless message whenever the user presses one of them.

The transmitted packet contains a single integer value representing the user's action. A value of 1 is sent when the UP button is pressed, while -1 is transmitted when the DOWN button is activated. These packets are delivered directly to the receiver using its MAC address without requiring a Wi-Fi router.

#include  <WiFi.h <
#include  <esp_now.h<

#define BTN_UP    4
#define BTN_DOWN  5

typedef struct {
  int accion;
} mensaje_t;

mensaje_t msg;

// Reemplazar por la MAC real
uint8_t receptorMAC[] = {0x64,0xE8,0x33,0x12,0x34,0x56};

bool lastUp = HIGH;
bool lastDown = HIGH;

void setup() {

  Serial.begin(115200);

  pinMode(BTN_UP, INPUT_PULLUP);
  pinMode(BTN_DOWN, INPUT_PULLUP);

  WiFi.mode(WIFI_STA);

  if (esp_now_init() != ESP_OK) {
    Serial.println("Error ESPNOW");
    return;
  }

  esp_now_peer_info_t peerInfo = {};

  memcpy(peerInfo.peer_addr, receptorMAC, 6);
  peerInfo.channel = 0;
  peerInfo.encrypt = false;

  esp_now_add_peer(&peerInfo);
}

void loop() {

  bool up = digitalRead(BTN_UP);
  bool down = digitalRead(BTN_DOWN);

  if (lastUp == HIGH && up == LOW) {

    msg.accion = 1;

    esp_now_send(
      receptorMAC,
      (uint8_t *)&msg,
      sizeof(msg)
    );

    delay(50);
  }

  if (lastDown == HIGH && down == LOW) {

    msg.accion = -1;

    esp_now_send(
      receptorMAC,
      (uint8_t *)&msg,
      sizeof(msg)
    );

    delay(50);
  }

  lastUp = up;
  lastDown = down;
}

ESP-NOW Receiver

The second XIAO ESP32-C3 was configured as the ESP-NOW receiver. Its role is to continuously listen for incoming wireless packets sent by the transmitter. Every received message contains an integer value that is used to update a counter displayed on an SSD1306 OLED screen connected through the I²C interface.

Unlike the transmitter, the receiver does not actively poll for data. Instead, it uses an event-driven callback that is automatically executed whenever a new ESP-NOW packet arrives. This approach reduces processor usage and provides an efficient communication workflow.

#include <WiFi.h<
#include <esp_now.h<

#include <Wire.h<
#include <Adafruit_GFX.h<
#include <Adafruit_SSD1306.h<

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

Adafruit_SSD1306 display(
  SCREEN_WIDTH,
  SCREEN_HEIGHT,
  &Wire,
  -1
);

typedef struct {
  int accion;
} mensaje_t;

volatile int contador = 0;

void actualizarPantalla() {

  display.clearDisplay();

  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);

  display.setCursor(0, 0);
  display.println("PULSOS");

  display.setTextSize(4);
  display.setCursor(10, 25);
  display.println(contador);

  display.display();
}

void onReceive(
  const esp_now_recv_info_t *info,
  const uint8_t *incomingData,
  int len
) {

  mensaje_t msg;

  memcpy(&msg, incomingData, sizeof(msg));

  contador += msg.accion;

  actualizarPantalla();
}

void setup() {

  Serial.begin(115200);

  Wire.begin(6, 7); // SDA,SCL XIAO ESP32-C3

  if (!display.begin(
        SSD1306_SWITCHCAPVCC,
        0x3C)) {

    Serial.println("OLED no encontrada");
    while (1);
  }

  actualizarPantalla();

  WiFi.mode(WIFI_STA);

  if (esp_now_init() != ESP_OK) {

    Serial.println("Error ESPNOW");
    return;
  }

  esp_now_register_recv_cb(onReceive);
}

void loop() {
}

Physical Implementation

After programming both XIAO ESP32-C3 boards, the system was assembled and tested physically. One board worked as the transmitter, reading the state of two push buttons, while the second board worked as the receiver, displaying the received value on an SSD1306 OLED screen.

Since ESP-NOW uses wireless peer-to-peer communication, no router or physical data cable was required between the two projects. Each board only needed power, and the communication was established using the receiver's MAC address registered in the transmitter code.

Physical setup showing the transmitter XIAO ESP32-C3 with push buttons and the receiver XIAO ESP32-C3 connected to the OLED display.

Implementation Workflow

• Program the first XIAO ESP32-C3 as the ESP-NOW transmitter.
• Program the second XIAO ESP32-C3 as the ESP-NOW receiver.
• Connect two push buttons to the transmitter board.
• Connect the SSD1306 OLED display to the receiver through I²C.
• Power both boards independently.
• Press the buttons and verify that the OLED counter updates wirelessly.

Validation:
Pressing the UP button sends accion = 1 and increases the counter, while pressing the DOWN button sends accion = -1 and decreases the counter on the receiver display.

Individual Reflection

This group assignment expanded my understanding of embedded communication by introducing wireless networking between independent microcontrollers. While my individual assignment focused on wired protocols such as UART and I²C, working with ESP-NOW allowed me to explore a completely different communication approach, where devices exchange information directly without requiring cables, routers, or internet connectivity.

One of the most valuable aspects of this experience was learning how peer-to-peer communication is established using MAC addresses. Understanding that each ESP32 must identify its communication partner before exchanging data helped me better appreciate how wireless embedded networks are organized. I also reinforced my knowledge of event-driven programming through the use of callback functions, which process incoming messages only when new data is received.

Another important lesson was recognizing how different communication protocols are selected according to the application requirements. UART is ideal for serial debugging, I²C efficiently connects multiple peripherals on the same board, and ESP-NOW provides a lightweight wireless solution for communication between independent embedded systems. Understanding the strengths of each protocol has given me a broader perspective on designing distributed electronic systems.

This experience will be especially useful for my future embedded projects and Final Project, where reliable communication between multiple devices may be required. Learning to configure wireless peers, exchange structured data, and validate communication in real time has strengthened both my programming skills and my understanding of modern embedded networking architectures.