Mastering IR Communication: Capturing HEX Codes for Universal Remotes with ESP32

Stephanie Sadler
Stephanie Sadler
Tip and Tricks
Mastering IR Communication: Capturing HEX Codes for Universal Remotes with ESP32

In the world of home automation and smart device control, infrared (IR) communication remains a crucial technology. Whether you’re a DIY enthusiast or a professional developer, understanding how to capture and utilize IR signals can open up a world of possibilities. Today, we’re diving deep into the process of obtaining HEX codes for universal remotes using an ESP32 microcontroller. Let’s embark on this exciting journey to unlock the potential of IR communication!

Table of Contents
The Challenge: From NEC Frames to Precise HEX ValuesUnderstanding the Current SetupThe Arduino Approach: A Blueprint for SuccessBridging the Gap: From Arduino to ESP-IDFPutting It All TogetherAdvanced Considerations and OptimizationsReal-World Applications and Future DirectionsConclusion: Empowering Your IR Universe

The Challenge: From NEC Frames to Precise HEX Values

Imagine you’re sitting in your living room, universal remote in hand, ready to embark on a project that will revolutionize how you interact with your devices. You’ve got your ESP32-DevKitC-32E set up, running ESP-IDF v5.2.2 in Visual Studio Code. Your trusty TSMP98000 photodetector circuit is primed to catch those elusive IR signals, and your IR LED driver circuit is standing by, ready to transmit. But there’s a problem: while you’re successfully capturing NEC frames, you’re missing the crucial piece of the puzzle – those precise HEX values that make universal remotes truly universal.

You’re not alone in this quest. Many developers find themselves in a similar situation, caught between the raw data of NEC frames and the need for clean, usable HEX codes. Let’s break down the problem and build a solution step by step.

Understanding the Current Setup

Before we dive into the solution, let’s take a closer look at what we’re working with:

  • Hardware: ESP32-DevKitC-32E
  • Software: ESP-IDF v5.2.2
  • IDE: Visual Studio Code
  • IR Receiver: TSMP98000 photodetector circuit
  • IR Transmitter: Custom IR LED driver circuit
  • Target Remotes: Universal Remote (K-1028E) and SONY TV xbr-55x900e remote

You’ve successfully implemented the NEC remote infrared RMT example (ir_nec_transceiver) and are receiving NEC frames. Here’s a snippet of what you’re seeing:

NEC frame start---
---NEC frame end: Unknown NEC frame

While this data is a great start, it’s not quite what we need. Our goal is to transform these frames into HEX values like 0x41F5BBD1, which are much more useful for programming universal remotes.

The Arduino Approach: A Blueprint for Success

You’ve wisely looked to the Arduino ecosystem for inspiration. The Arduino code you’ve referenced provides a clear path forward. Let’s break down the key components of this approach:

  1. Utilizing libraries specifically designed for IR communication (IRremote, IRsend, etc.)
  2. Setting up both receiver and transmitter pins
  3. Creating objects for receiving and sending IR signals
  4. Implementing a loop to continuously check for incoming IR signals
  5. Converting received signals to hexadecimal format
  6. Optionally retransmitting the received signal

This approach is elegant in its simplicity and effectiveness. Now, the challenge is to translate this methodology to our ESP-IDF environment.

Bridging the Gap: From Arduino to ESP-IDF

Transitioning from Arduino to ESP-IDF might seem daunting, but fear not! The principles remain the same, even if the implementation details differ. Here’s how we can adapt the Arduino approach to our ESP32 setup:

1. Setting Up the RMT (Remote Control) Peripheral

The ESP32’s RMT (Remote Control) peripheral is perfect for handling IR communication. It’s designed to generate and receive precisely timed signals, which is exactly what we need for IR protocols.

#include "driver/rmt.h"

#define RMT_RX_CHANNEL    0     // Use RMT channel 0 for receiving
#define RMT_TX_CHANNEL    1     // Use RMT channel 1 for transmitting
#define RMT_RX_GPIO_NUM   13    // GPIO pin for IR receiver
#define RMT_TX_GPIO_NUM   16    // GPIO pin for IR transmitter

void setup_rmt() {
    rmt_config_t rmt_rx_config = RMT_DEFAULT_CONFIG_RX(RMT_RX_GPIO_NUM, RMT_RX_CHANNEL);
    rmt_driver_install(RMT_RX_CHANNEL, 1000, 0);

    rmt_config_t rmt_tx_config = RMT_DEFAULT_CONFIG_TX(RMT_TX_GPIO_NUM, RMT_TX_CHANNEL);
    rmt_driver_install(RMT_TX_CHANNEL, 0, 0);

2. Implementing the IR Receiver

Now that we’ve set up the RMT peripheral, let’s create a function to receive IR signals:

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

void ir_rx_task(void *arg) {
    size_t rx_size = 0;
    rmt_item32_t *items = NULL;
    while (1) {
        rmt_receive(RMT_RX_CHANNEL, &items, sizeof(rmt_item32_t) * 1000, ℞_size, portMAX_DELAY);
        if (rx_size > 0) {
            // Process received IR signal
            process_ir_signal(items, rx_size);
        vTaskDelay(10 / portTICK_PERIOD_MS);

3. Processing the IR Signal

The heart of our solution lies in correctly interpreting the received IR signal and converting it to a HEX value. Here’s a simplified version of how we might approach this:

void process_ir_signal(rmt_item32_t *items, size_t size) {
    uint32_t ir_code = 0;
    for (int i = 0; i < size; i++) {
        if (items[i].level0 == 1 && items[i].level1 == 0) {
            // Assuming a simple encoding where 1 is represented by a longer pulse
            ir_code = (ir_code << 1) | (items[i].duration0 > items[i].duration1 ? 1 : 0);
    printf("Received IR code: 0x%08X\n", ir_code);

4. Implementing the IR Transmitter

For completeness, let’s also implement a function to transmit IR signals:

void send_ir_code(uint32_t code) {
    rmt_item32_t items[32];
    int item_count = 0;

    // Convert the code to RMT items (simplified example)
    for (int i = 31; i >= 0; i--) {
        if (code & (1 << i)) {
            items[item_count].level0 = 1;
            items[item_count].duration0 = 1000;  // 1ms on
            items[item_count].level1 = 0;
            items[item_count].duration1 = 500;   // 0.5ms off
        } else {
            items[item_count].level0 = 1;
            items[item_count].duration0 = 500;   // 0.5ms on
            items[item_count].level1 = 0;
            items[item_count].duration1 = 1000;  // 1ms off

    rmt_write_items(RMT_TX_CHANNEL, items, item_count, true);

Putting It All Together

Now that we have all the pieces, let’s assemble them into a cohesive solution:

void app_main() {
    xTaskCreate(ir_rx_task, "ir_rx_task", 2048, NULL, 10, NULL);

    while (1) {
        // Main application loop
        vTaskDelay(1000 / portTICK_PERIOD_MS);

This setup creates a dedicated task for IR reception, continuously monitoring for incoming signals. When a signal is received, it’s processed and converted to a HEX value, which is then printed to the console.

Advanced Considerations and Optimizations

While the solution above provides a solid foundation, there are several areas where we can further refine and optimize our IR communication system:

1. Protocol-Specific Decoding

Different IR protocols (NEC, Sony, RC5, etc.) use varying encoding schemes. Implementing protocol-specific decoding can improve accuracy and reliability:

typedef enum {
    // Add more protocols as needed
} ir_protocol_t;

void decode_ir_protocol(rmt_item32_t *items, size_t size, ir_protocol_t protocol) {
    switch (protocol) {
        case IR_PROTOCOL_NEC:
            decode_nec(items, size);
        case IR_PROTOCOL_SONY:
            decode_sony(items, size);
        // Add more protocol decoders

2. Error Checking and Validation

Implement checksums and error-checking mechanisms to ensure the integrity of received IR codes:

bool validate_ir_code(uint32_t code, ir_protocol_t protocol) {
    // Implement protocol-specific validation
    // Return true if valid, false otherwise

3. Dynamic Protocol Detection

Create a system that can automatically detect the IR protocol being used:

ir_protocol_t detect_ir_protocol(rmt_item32_t *items, size_t size) {
    // Analyze signal characteristics to determine protocol
    // Return the detected protocol

4. Persistent Storage of IR Codes

Store frequently used IR codes in non-volatile memory for quick access:

#include "nvs_flash.h"
#include "nvs.h"

void store_ir_code(const char* key, uint32_t code) {
    nvs_handle_t my_handle;
    nvs_open("storage", NVS_READWRITE, &my_handle);
    nvs_set_u32(my_handle, key, code);

uint32_t retrieve_ir_code(const char* key) {
    nvs_handle_t my_handle;
    uint32_t code = 0;
    nvs_open("storage", NVS_READONLY, &my_handle);
    nvs_get_u32(my_handle, key, &code);
    return code;

Real-World Applications and Future Directions

Now that we’ve built a robust IR communication system for the ESP32, let’s explore some exciting applications and future directions:

1. Smart Home Integration

Integrate your ESP32-based IR system with popular smart home platforms like Home Assistant or OpenHAB. This allows you to control IR devices through voice commands or smartphone apps:

void smart_home_ir_control(const char* device, const char* command) {
    uint32_t ir_code = retrieve_ir_code(device);
    if (ir_code != 0) {
        printf("Sent command to %s: %s\n", device, command);
    } else {
        printf("Unknown device or command\n");

2. IR Learning Mode

Implement a learning mode that allows your system to capture and store new IR codes from various remotes:

void ir_learning_mode() {
    printf("Enter learning mode. Point your remote at the IR receiver and press a button.\n");
    // Wait for IR signal
    // Process and store the received code
    printf("New IR code learned and stored.\n");

3. Multi-Device Control

Create macros that send multiple IR commands in sequence, allowing complex operations with a single trigger:

void execute_ir_macro(const char* macro_name) {
    // Retrieve and execute a series of IR commands
    // Example: Turn on TV, set input, adjust volume

4. Web Interface for Remote Management

Develop a web server on the ESP32 that allows users to manage IR codes and control devices through a browser interface:

#include "esp_http_server.h"

httpd_handle_t start_webserver(void) {
    // Initialize and start a simple HTTP server
    // Implement endpoints for IR code management and device control

Conclusion: Empowering Your IR Universe

We’ve journeyed from the basics of capturing NEC frames to building a comprehensive IR communication system for the ESP32. By leveraging the power of the RMT peripheral and implementing smart decoding and processing techniques, we’ve created a solution that rivals and even surpasses many Arduino-based alternatives.

Remember, the world of IR communication is vast and varied. As you continue to explore and expand your system, you’ll encounter new challenges and opportunities. Whether you’re controlling your home theater, automating your blinds, or inventing the next big thing in IoT, the foundations we’ve laid here will serve you well.

So, grab your ESP32, fire up your favorite IDE, and start exploring the endless possibilities of IR communication. Who knows? Your next project might just revolutionize how we interact with the devices around us. Happy coding, and may your IR signals always find their mark!

Related Blogs