📖 Project Story – Wireless RTOS-Based Control System using ESP32
💡 Idea Behind the Project
⚙️ How It Works
🔥 Key Features
🚀 What Makes It Special
🧠 What I Learned
💬 Conclusion

Published March 30, 2026

Wireless Smart Dimmer using ESP-NOW and RTOS

An advanced ESP32-based wireless control system leveraging ESP-NOW and FreeRTOS to achieve real-time communication, multitasking, and respon

IntermediateWork in progress2 hours10

Wireless Smart Dimmer using ESP-NOW and RTOS

Things used in this project

Hardware components

Espressif ESP32 Development Board - Developer Edition

Rotary Encoder with Push-Button

DFRobot I2C 16x2 Arduino LCD Display Module

Jumper wires (generic)

USB Cable Assembly, USB Type A Plug to Micro USB Type B Plug

Software apps and online services

Arduino IDE

Story

📖 Project Story – Wireless RTOS-Based Control System using ESP32

In modern electronics, systems are becoming smarter, faster, and more connected. Traditional wired control systems not only increase complexity but also limit flexibility and scalability. This project was born out of a simple idea: can we build a fast, reliable, and wireless control system without relying on WiFi or the internet?

To explore this, I designed a real-time wireless control system using ESP32, ESP-NOW, and FreeRTOS.

💡 Idea Behind the Project

The goal was to create a system where a user could control a device wirelessly with instant response, while also learning how real embedded systems handle multitasking and communication.

Instead of using conventional communication methods like WiFi or Bluetooth, I chose ESP-NOW, a lightweight and low-latency protocol that allows direct communication between ESP32 devices. To make the system more realistic and efficient, I integrated FreeRTOS, enabling multiple tasks to run simultaneously.

⚙️ How It Works

The system consists of two ESP32 nodes:

Sender Node (Control Unit):A rotary encoder is used as an input device. As the user rotates the encoder, the value is updated in real-time and sent wirelessly using ESP-NOW.

Receiver Node (Processing Unit):The receiver ESP32 processes incoming data using RTOS tasks. One task controls the LED brightness using PWM, while another task updates a 16x2 LCD display via I2C to provide real-time feedback.

To ensure safe data sharing between tasks, a mutex-based shared memory approach is used, which reflects real-world embedded system design practices.

🔥 Key Features

⚡ Low-latency wireless communication using ESP-NOW

🔄 Multitasking with FreeRTOS (LED control + LCD display)

🎛️ Human interface using rotary encoder

📺 Real-time feedback on LCD display

🔒 Thread-safe data handling using Mutex

🌐 No WiFi or internet required

🚀 What Makes It Special?

This project goes beyond basic Arduino-level implementations and demonstrates concepts used in real embedded systems, such as:

Task schedulingInter-task communicationSynchronization (Mutex)Event-driven designIt also shows how scalable architectures can be built using simple hardware like ESP32.

🧠 What I Learned

Through this project, I gained a deeper understanding of:

How ESP-NOW enables fast device-to-device communicationHow FreeRTOS manages multiple tasks efficientlyWhy synchronization mechanisms like mutex are critical in concurrent systemsHow to design systems that are both responsive and reliable🔮 Future Improvements

This system can be extended further by:

Adding multiple sensor nodes (temperature, air quality, etc.)

Integrating a cloud dashboard using MQTT

Upgrading to a graphical TFT interface

Implementing a menu system using the rotary encoder

💬 Conclusion

This project is a step toward building professional-grade embedded systems using ESP32. It combines wireless communication, real-time processing, and user interaction into a single scalable solution — making it a strong foundation for future IoT and automation projects.

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

// Rotary Encoder Pins
#define CLK 32
#define DT  33

// Shared data
int encoderValue = 0;

// Mutex
SemaphoreHandle_t encoderMutex;

// Receiver MAC
uint8_t broadcastAddress[] = {0x04, 0x83, 0x08, 0x57, 0xBC, 0xB4};

// Structure
typedef struct struct_message {
  int encoderValue;
} struct_message;

struct_message myData;
esp_now_peer_info_t peerInfo;

// ================= CALLBACK =================
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  Serial.print("Send Status: ");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Success" : "Fail");
}

// ================= ENCODER TASK =================
void encoderTask(void *pvParameters) {

  int lastStateCLK = digitalRead(CLK);
  int currentStateCLK;

  while (1) {

    currentStateCLK = digitalRead(CLK);

    if (currentStateCLK != lastStateCLK && currentStateCLK == HIGH) {

      if (digitalRead(DT) != currentStateCLK) {
        if (xSemaphoreTake(encoderMutex, portMAX_DELAY)) {
          encoderValue++;
          xSemaphoreGive(encoderMutex);
        }
      } else {
        if (xSemaphoreTake(encoderMutex, portMAX_DELAY)) {
          encoderValue--;
          xSemaphoreGive(encoderMutex);
        }
      }

      Serial.print("Encoder: ");
      Serial.println(encoderValue);
    }

    lastStateCLK = currentStateCLK;

    vTaskDelay(1); // small delay for stability
  }
}

// ================= SEND TASK =================
void sendTask(void *pvParameters) {

  int lastSentValue = 0;

  while (1) {

    int localValue;

    // Get value safely
    if (xSemaphoreTake(encoderMutex, portMAX_DELAY)) {
      localValue = encoderValue;
      xSemaphoreGive(encoderMutex);
    }

    // Send only if value changed
    if (localValue != lastSentValue) {

      myData.encoderValue = localValue;

      esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *)&myData, sizeof(myData));

      if (result == ESP_OK) {
        Serial.println("Data Sent");
      } else {
        Serial.println("Send Error");
      }

      lastSentValue = localValue;
    }

    vTaskDelay(pdMS_TO_TICKS(50)); // control send rate
  }
}

// ================= SETUP =================
void setup() {
  Serial.begin(115200);

  pinMode(CLK, INPUT);
  pinMode(DT, INPUT);

  WiFi.mode(WIFI_STA);

  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW Init Failed");
    return;
  }

  esp_now_register_send_cb(OnDataSent);

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

  if (esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("Failed to add peer");
    return;
  }

  // Create Mutex
  encoderMutex = xSemaphoreCreateMutex();

  // Create Tasks
  xTaskCreatePinnedToCore(encoderTask, "Encoder Task", 2048, NULL, 2, NULL, 0);
  xTaskCreatePinnedToCore(sendTask, "Send Task", 2048, NULL, 1, NULL, 1);
}

// ================= LOOP =================
void loop() {}

#include <esp_now.h>
#include <WiFi.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);

// I2C pins
#define SDA_PIN 32
#define SCL_PIN 33

// PWM
#define LED_PIN 14
#define PWM_CHANNEL 0
#define PWM_FREQ 5000
#define PWM_RESOLUTION 8

// Structure
typedef struct struct_message {
  int encoderValue;
} struct_message;

// Shared data
struct_message sharedData;

// Mutex
SemaphoreHandle_t dataMutex;

// ================= ESP-NOW CALLBACK =================
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {
  
  struct_message tempData;
  memcpy(&tempData, incomingData, sizeof(tempData));

  // Take mutex (ISR-safe version)
  if (xSemaphoreTakeFromISR(dataMutex, NULL) == pdTRUE) {
    sharedData = tempData;
    xSemaphoreGiveFromISR(dataMutex, NULL);
  }
}

// ================= LED TASK =================
void ledTask(void *pvParameters) {

  struct_message localData;

  while (1) {

    if (xSemaphoreTake(dataMutex, portMAX_DELAY)) {
      localData = sharedData;
      xSemaphoreGive(dataMutex);
    }

    int brightness = map(localData.encoderValue, 0, 100, 0, 255);
    brightness = constrain(brightness, 0, 255);

    ledcWrite(PWM_CHANNEL, brightness);

    Serial.print("LED Brightness: ");
    Serial.println(brightness);

    vTaskDelay(pdMS_TO_TICKS(50));
  }
}

// ================= LCD TASK =================
void lcdTask(void *pvParameters) {

  struct_message localData;

  while (1) {

    if (xSemaphoreTake(dataMutex, portMAX_DELAY)) {
      localData = sharedData;
      xSemaphoreGive(dataMutex);
    }

    int brightness = map(localData.encoderValue, 0, 100, 0, 255);

    lcd.setCursor(0, 0);
    lcd.print("Encoder:       ");
    lcd.setCursor(9, 0);
    lcd.print(localData.encoderValue);

    lcd.setCursor(0, 1);
    lcd.print("Bright:        ");
    lcd.setCursor(9, 1);
    lcd.print(brightness);

    vTaskDelay(pdMS_TO_TICKS(200));
  }
}

// ================= SETUP =================
void setup() {
  Serial.begin(115200);

  // I2C
  Wire.begin(SDA_PIN, SCL_PIN);
  lcd.init();
  lcd.backlight();
  lcd.print("System Ready");

  // PWM
  ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_RESOLUTION);
  ledcAttachPin(LED_PIN, PWM_CHANNEL);

  // WiFi + ESP-NOW
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();

  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW Init Failed");
    return;
  }

  esp_now_register_recv_cb(OnDataRecv);

  // Create Mutex
  dataMutex = xSemaphoreCreateMutex();

  // Create Tasks
  xTaskCreatePinnedToCore(ledTask, "LED Task", 2048, NULL, 1, NULL, 0);
  xTaskCreatePinnedToCore(lcdTask, "LCD Task", 2048, NULL, 1, NULL, 1);
}

// ================= LOOP =================
void loop() {}

Credits

ELECTRO MOTIF

5 projects • 0 followers

Electronics enthusiast focused on PCB design, power electronics, and embedded hardware. I design circuits and share hardware projects.

Wireless Smart Dimmer using ESP-NOW and RTOS