Chapter 142: RMT for Infrared Communication

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "driver/rmt_tx.h"
#include "driver/gpio.h"
#include "ir_nec_encoder.h" // We will create this helper header/source

// Define NEC timing constants (in microseconds for 1MHz RMT resolution)
#define NEC_LEADING_CODE_DURATION_0    9000
#define NEC_LEADING_CODE_DURATION_1    4500
#define NEC_PAYLOAD_BIT_DURATION_0     560
#define NEC_PAYLOAD_LOGIC0_DURATION_1  560
#define NEC_PAYLOAD_LOGIC1_DURATION_1  1690 // approx 3 * 560
#define NEC_ENDING_CODE_DURATION_0     560
#define NEC_REPEAT_CODE_DURATION_0     9000
#define NEC_REPEAT_CODE_DURATION_1     2250

#define IR_TX_GPIO_NUM      GPIO_NUM_18 // Choose your TX GPIO
#define RMT_RESOLUTION_HZ   1000000   // 1MHz resolution, 1 tick = 1us
#define RMT_MEM_BLOCK_SYMBOLS 64      // Standard for ESP32/S2/S3
#define NEC_CARRIER_FREQ_HZ 38000     // 38kHz carrier
#define NEC_CARRIER_DUTY_PERCENT 33   // 33% duty cycle

static const char *TAG = "IR_NEC_TX";

// Helper function to create RMT symbols for NEC
// This function would typically be in ir_nec_encoder.c
// For simplicity, placing a basic structure here.
// A complete NEC encoder handles address, command, and their inverses.
// This example sends a raw sequence for brevity.
size_t ir_nec_encode_dummy(rmt_encoder_handle_t base_encoder, rmt_channel_handle_t channel, const void *primary_data, size_t data_size, rmt_encode_state_t *ret_state, rmt_symbol_word_t *output_symbols) {
    // This is a placeholder for a real NEC encoder.
    // A real encoder would take an address and command, and generate all 32 bits + leader + stop.
    // For this example, we'll use a pre-defined simple pattern.
    // This pattern is NOT a full NEC frame, just a few pulses for demonstration.
    output_symbols[0] = (rmt_symbol_word_t){{{NEC_LEADING_CODE_DURATION_0, 1, NEC_LEADING_CODE_DURATION_1, 0}}}; // Leader
    output_symbols[1] = (rmt_symbol_word_t){{{NEC_PAYLOAD_BIT_DURATION_0, 1, NEC_PAYLOAD_LOGIC1_DURATION_1, 0}}}; // "1"
    output_symbols[2] = (rmt_symbol_word_t){{{NEC_PAYLOAD_BIT_DURATION_0, 1, NEC_PAYLOAD_LOGIC0_DURATION_1, 0}}}; // "0"
    output_symbols[3] = (rmt_symbol_word_t){{{NEC_ENDING_CODE_DURATION_0, 1, 0, 0}}};                             // Stop bit

    *ret_state = RMT_ENCODE_STATE_FINISH;
    return 4 * sizeof(rmt_symbol_word_t); // 4 symbols
}


void app_main(void)
{
    ESP_LOGI(TAG, "Create RMT TX channel");
    rmt_tx_channel_config_t tx_chan_config = {
        .gpio_num = IR_TX_GPIO_NUM,
        .clk_src = RMT_CLK_SRC_DEFAULT,
        .resolution_hz = RMT_RESOLUTION_HZ,
        .mem_block_symbols = RMT_MEM_BLOCK_SYMBOLS,
        .trans_queue_depth = 4,
        .flags.invert_out = false, // IR LED typically not inverted at RMT level
    };
    rmt_channel_handle_t tx_channel = NULL;
    ESP_ERROR_CHECK(rmt_new_tx_channel(&tx_chan_config, &tx_channel));

    ESP_LOGI(TAG, "Install IR NEC encoder");
    // For a real NEC protocol, you'd use a proper NEC encoder.
    // ESP-IDF provides examples of how to build these (e.g. in idf-extra-components or examples)
    // Here, we use a simple copy encoder and manually define the symbols for a basic pattern.
    // A more robust approach uses rmt_bytes_encoder or a custom encoder.
    // Let's use a copy encoder for this example and manually form symbols.

    rmt_copy_encoder_config_t copy_encoder_config = {};
    rmt_encoder_handle_t nec_encoder = NULL;
    ESP_ERROR_CHECK(rmt_new_copy_encoder(&copy_encoder_config, &nec_encoder));


    ESP_LOGI(TAG, "Modulate carrier to TX channel");
    rmt_carrier_config_t carrier_cfg = {
        .frequency_hz = NEC_CARRIER_FREQ_HZ,
        .duty_cycle = (float)NEC_CARRIER_DUTY_PERCENT / 100.0,
        .flags.polarity_active_low = false, // Carrier is on when signal is high
    };
    ESP_ERROR_CHECK(rmt_apply_carrier(tx_channel, &carrier_cfg));

    ESP_LOGI(TAG, "Enable RMT TX channel");
    ESP_ERROR_CHECK(rmt_enable(tx_channel));

    // Manually define symbols for a simplified NEC-like pattern
    // Address: 0x00, Command: 0x01 (LSB first for command bits: 10000000)
    // For simplicity, let's send a leader, one '1' bit, one '0' bit, and a stop bit.
    // A full NEC frame would be: Leader + 8 addr + 8 !addr + 8 cmd + 8 !cmd + Stop
    rmt_symbol_word_t nec_symbols[] = {
        // Leader code
        {.duration0 = NEC_LEADING_CODE_DURATION_0, .level0 = 1, .duration1 = NEC_LEADING_CODE_DURATION_1, .level1 = 0},
        // Bit 0 (e.g. LSB of command = 1)
        {.duration0 = NEC_PAYLOAD_BIT_DURATION_0, .level0 = 1, .duration1 = NEC_PAYLOAD_LOGIC1_DURATION_1, .level1 = 0},
        // Bit 1 (e.g. next bit of command = 0)
        {.duration0 = NEC_PAYLOAD_BIT_DURATION_0, .level0 = 1, .duration1 = NEC_PAYLOAD_LOGIC0_DURATION_1, .level1 = 0},
        // ... (add all 32 bits for full address and command)
        // Stop bit
        {.duration0 = NEC_ENDING_CODE_DURATION_0, .level0 = 1, .duration1 = 0, .level1 = 0} // duration1=0 to signify end
    };

    rmt_transmit_config_t transmit_config = {
        .loop_count = 0, // Transmit once
        // .flags.eot_level = 0, // Signal level after transmission
    };

    while (1) {
        ESP_LOGI(TAG, "Transmitting IR NEC signal...");
        ESP_ERROR_CHECK(rmt_transmit(tx_channel, nec_encoder, nec_symbols, sizeof(nec_symbols), &transmit_config));
        // Wait for the transmission to complete.
        // For short bursts, this is okay. For continuous, consider events.
        ESP_ERROR_CHECK(rmt_tx_wait_all_done(tx_channel, pdMS_TO_TICKS(1000)));
        ESP_LOGI(TAG, "Transmission complete.");
        vTaskDelay(pdMS_TO_TICKS(2000)); // Transmit every 2 seconds
    }

    // Cleanup (not reached in this example)
    // ESP_ERROR_CHECK(rmt_disable(tx_channel));
    // ESP_ERROR_CHECK(rmt_del_encoder(nec_encoder));
    // ESP_ERROR_CHECK(rmt_del_channel(tx_channel));
}

#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "driver/rmt_rx.h"
#include "driver/gpio.h"

#define IR_RX_GPIO_NUM      GPIO_NUM_19 // Choose your RX GPIO
#define RMT_RESOLUTION_HZ   1000000   // 1MHz resolution, 1 tick = 1us
#define RMT_MEM_BLOCK_SYMBOLS 64      // Use a single block for RX
// NEC timing constants (in microseconds)
#define NEC_HDR_MARK_US         9000 // NEC header: mark
#define NEC_HDR_SPACE_US        4500 // NEC header: space
#define NEC_BIT_MARK_US          560 // NEC bit: mark
#define NEC_ONE_SPACE_US        1690 // NEC bit: one space
#define NEC_ZERO_SPACE_US        560 // NEC bit: zero space
#define NEC_RPT_SPACE_US        2250 // NEC repeat: space
#define NEC_TOLERANCE_US         150 // Tolerance for pulse duration comparison (microseconds)

#define NEC_PACKET_SYMBOLS      (1 + 32 * 1 + 1) // Leader + 32 data bits (each 1 symbol for mark+space) + Stop
#define RMT_RX_MAX_SYMBOLS      (NEC_PACKET_SYMBOLS + 10) // Buffer size for RMT symbols

static const char *TAG = "IR_NEC_RX";

// Helper to check if a duration is within tolerance
static inline bool nec_check_in_range(uint32_t duration_ticks, uint32_t target_us, uint32_t tolerance_us) {
    return (duration_ticks >= (target_us - tolerance_us)) && (duration_ticks <= (target_us + tolerance_us));
}

// Simple NEC decoder function
// This function parses an array of rmt_symbol_word_t
// Note: TSOP output is typically active low. If RMT level0 is 0, it means IR mark was detected.
// Configure rmt_rx_channel_config_t.flags.invert_in if your TSOP output is active high or your logic needs it.
// Assuming TSOP output is active low: mark = level 0, space = level 1 from RMT perspective if invert_in=false
// Or, if invert_in=true: mark = level 1, space = level 0 from RMT perspective.
// For this example, let's assume invert_in = true (so RMT level 1 = IR mark)
static bool parse_nec_frame(rmt_symbol_word_t *rmt_nec_symbols, size_t symbol_count, uint16_t *address, uint16_t *command, bool *is_repeat) {
    *is_repeat = false;
    bool valid_leading_code = false;
    int symbol_idx = 0;

    // Check for leader code
    if (symbol_count < 2) return false; // Not enough symbols for even a leader

    // Leader Mark + Space (assuming level 1 is mark after potential inversion)
    if (rmt_nec_symbols[symbol_idx].level0 == 1 && nec_check_in_range(rmt_nec_symbols[symbol_idx].duration0, NEC_HDR_MARK_US, NEC_TOLERANCE_US * 5) &&
        rmt_nec_symbols[symbol_idx].level1 == 0 && nec_check_in_range(rmt_nec_symbols[symbol_idx].duration1, NEC_HDR_SPACE_US, NEC_TOLERANCE_US * 3)) {
        valid_leading_code = true;
        symbol_idx++;
    }
    // Check for repeat code
    else if (rmt_nec_symbols[symbol_idx].level0 == 1 && nec_check_in_range(rmt_nec_symbols[symbol_idx].duration0, NEC_HDR_MARK_US, NEC_TOLERANCE_US * 5) &&
             rmt_nec_symbols[symbol_idx].level1 == 0 && nec_check_in_range(rmt_nec_symbols[symbol_idx].duration1, NEC_RPT_SPACE_US, NEC_TOLERANCE_US * 2)) {
        // Check for stop bit of repeat code
        if (symbol_count > symbol_idx &&
            rmt_nec_symbols[symbol_idx+1].level0 == 1 && nec_check_in_range(rmt_nec_symbols[symbol_idx+1].duration0, NEC_BIT_MARK_US, NEC_TOLERANCE_US)) {
            *is_repeat = true;
            return true;
        }
        return false; // Invalid repeat
    } else {
        return false; // Neither leader nor repeat
    }

    if (!valid_leading_code) return false;

    // Decode 32 bits (Address, ~Address, Command, ~Command)
    uint32_t nec_data = 0;
    for (int i = 0; i < 32; i++) {
        if (symbol_idx >= symbol_count) return false; // Ran out of symbols

        // Mark part of the bit
        if (!(rmt_nec_symbols[symbol_idx].level0 == 1 && nec_check_in_range(rmt_nec_symbols[symbol_idx].duration0, NEC_BIT_MARK_US, NEC_TOLERANCE_US))) {
            ESP_LOGD(TAG, "Data bit %d mark fail: L%d D%d", i, rmt_nec_symbols[symbol_idx].level0, rmt_nec_symbols[symbol_idx].duration0);
            return false;
        }
        // Space part of the bit
        if (rmt_nec_symbols[symbol_idx].level1 == 0 && nec_check_in_range(rmt_nec_symbols[symbol_idx].duration1, NEC_ONE_SPACE_US, NEC_TOLERANCE_US * 2)) {
            nec_data |= (1UL << i); // Logical 1
        } else if (rmt_nec_symbols[symbol_idx].level1 == 0 && nec_check_in_range(rmt_nec_symbols[symbol_idx].duration1, NEC_ZERO_SPACE_US, NEC_TOLERANCE_US)) {
            // Logical 0, do nothing to nec_data as it's already 0
        } else {
            ESP_LOGD(TAG, "Data bit %d space fail: L%d D%d", i, rmt_nec_symbols[symbol_idx].level1, rmt_nec_symbols[symbol_idx].duration1);
            return false;
        }
        symbol_idx++;
    }

    // Check stop bit
    if (symbol_idx >= symbol_count ||
        !(rmt_nec_symbols[symbol_idx].level0 == 1 && nec_check_in_range(rmt_nec_symbols[symbol_idx].duration0, NEC_BIT_MARK_US, NEC_TOLERANCE_US))) {
        ESP_LOGD(TAG, "Stop bit fail");
        return false;
    }

    // LSB first for NEC, so bits are in order: Addr0-7, InvAddr0-7, Cmd0-7, InvCmd0-7
    uint8_t addr_val = (nec_data >> 0) & 0xFF;
    uint8_t inv_addr_val = (nec_data >> 8) & 0xFF;
    uint8_t cmd_val = (nec_data >> 16) & 0xFF;
    uint8_t inv_cmd_val = (nec_data >> 24) & 0xFF;

    // Validate address and command
    if ((uint8_t)(addr_val ^ inv_addr_val) != 0xFF || (uint8_t)(cmd_val ^ inv_cmd_val) != 0xFF) {
        ESP_LOGW(TAG, "NEC data integrity check failed. Addr:0x%02X !Addr:0x%02X Cmd:0x%02X !Cmd:0x%02X",
                 addr_val, inv_addr_val, cmd_val, inv_cmd_val);
        return false;
    }

    *address = addr_val;
    *command = cmd_val;
    return true;
}


void app_main(void)
{
    ESP_LOGI(TAG, "Create RMT RX channel");
    rmt_rx_channel_config_t rx_chan_config = {
        .gpio_num = IR_RX_GPIO_NUM,
        .clk_src = RMT_CLK_SRC_DEFAULT,
        .resolution_hz = RMT_RESOLUTION_HZ,
        .mem_block_symbols = RMT_MEM_BLOCK_SYMBOLS, // Number of RMT symbols the channel can store
        .flags.invert_in = true, // Set to true if TSOP output is active low and you want RMT level 1 to represent IR mark
                                 // If TSOP is active low and invert_in=false, RMT level 0 is mark.
        .filter_en = true,       // Enable filter for noise
        .filter_threshold_us = 100, // Glitches shorter than 100us are ignored. Tune this value.
        .idle_threshold_us = 12000, // Max idle time (12ms) before RX finishes (NEC repeat is ~108ms apart)
                                    // This needs to be longer than any single NEC message component.
    };
    rmt_channel_handle_t rx_channel = NULL;
    ESP_ERROR_CHECK(rmt_new_rx_channel(&rx_chan_config, &rx_channel));

    ESP_LOGI(TAG, "Register RX event callbacks"); // Optional: for more advanced handling
    // rmt_rx_event_callbacks_t cbs = { .on_recv_done = ... };
    // ESP_ERROR_CHECK(rmt_rx_register_event_callbacks(rx_channel, &cbs, NULL));

    ESP_LOGI(TAG, "Enable RMT RX channel");
    ESP_ERROR_CHECK(rmt_enable(rx_channel));

    static rmt_symbol_word_t raw_symbols[RMT_RX_MAX_SYMBOLS]; // Buffer for RMT symbols
    size_t received_size = 0;

    rmt_receive_config_t receive_config = {
      .signal_range_min_ns = 1250, // Shortest pulse we expect (e.g. NEC mark is 560us)
                                   // RMT driver uses this to determine if a pulse is valid.
                                   // 560us * 1000 = 560000 ns. Let's set it lower.
      .signal_range_max_ns = 12000000, // Longest pulse (e.g. NEC leader mark 9ms = 9000000ns)
                                      // Set higher than longest expected pulse.
    };

    ESP_LOGI(TAG, "Starting RMT reception. Point IR remote to GPIO %d and press buttons.", IR_RX_GPIO_NUM);

    while (1) {
        // Clear buffer. Important if previous reception was partial.
        memset(raw_symbols, 0, sizeof(raw_symbols));
        received_size = 0; // Reset received_size for each call

        // Start reception - This is blocking
        esp_err_t ret = rmt_receive(rx_channel, raw_symbols, sizeof(raw_symbols), &receive_config, &received_size);

        if (ret == ESP_OK) {
            uint16_t addr, cmd;
            bool is_repeat;
            size_t num_symbols = received_size / sizeof(rmt_symbol_word_t);

            ESP_LOGD(TAG, "Received %d symbols (%d bytes)", num_symbols, received_size);
            // for (int i = 0; i < num_symbols; i++) {
            //    ESP_LOGD(TAG, "Symbol %2d: L0: %d D0: %5d | L1: %d D1: %5d", i,
            //             raw_symbols[i].level0, raw_symbols[i].duration0,
            //             raw_symbols[i].level1, raw_symbols[i].duration1);
            // }

            if (parse_nec_frame(raw_symbols, num_symbols, &addr, &cmd, &is_repeat)) {
                if (is_repeat) {
                    ESP_LOGI(TAG, "NEC Repeat Code Received");
                } else {
                    ESP_LOGI(TAG, "NEC Code Received: Address=0x%02X, Command=0x%02X", addr, cmd);
                }
            } else {
                ESP_LOGW(TAG, "Failed to parse NEC frame or unknown IR data received (%d symbols).", num_symbols);
            }
        } else if (ret == ESP_ERR_TIMEOUT) {
            // ESP_LOGD(TAG, "RMT RX Timeout"); // Expected when no signal
        } else {
            ESP_LOGE(TAG, "RMT Receive Error: %s", esp_err_to_name(ret));
            // Consider re-initializing or re-enabling channel on persistent errors
            // For simplicity, we just log and continue.
            // A brief delay might be good here if errors are frequent.
            vTaskDelay(pdMS_TO_TICKS(100));
        }
    }
    // Cleanup (not reached)
    // ESP_ERROR_CHECK(rmt_disable(rx_channel));
    // ESP_ERROR_CHECK(rmt_del_channel(rx_channel));
}