ESP32 Forum

Code: Select all

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "esp_log.h"
#include "driver/rmt_rx.h"


// Set the RMT channel number
#define RMT_CHANNEL 0

static const char *TAG ="RMTExample";

static void parse_frame(rmt_symbol_word_t *items, size_t numItems)
{
    uint8_t data[numItems / 2];
    printf("Frame start %d---\r\n", numItems);
    for (size_t i = 0; i < numItems; i++) {
        printf("{%d:%d},{%d:%d}\r\n", items[i].level0, items[i].duration0, items[i].level1, items[i].duration1);
        uint8_t high = items[i * 2].duration1 > items[i * 2].duration0 ? 1 : 0;
        uint8_t low = items[i * 2 + 1].duration1 > items[i * 2 + 1].duration0 ? 1 : 0;
        data[i] = (high << 1) | low;
    }
    printf("---Frame end: \r\n");
    for (int i = 0; i < numItems / 2; i++) {
        printf("%x ", data[i]);
    }
    printf ("\r\n");

}

static bool example_rmt_rx_done_callback(rmt_channel_handle_t channel, const rmt_rx_done_event_data_t *edata, void *user_data)
{
    BaseType_t high_task_wakeup = pdFALSE;
    QueueHandle_t receive_queue = (QueueHandle_t)user_data;
    // send the received RMT symbols to the parser task
    xQueueSendFromISR(receive_queue, edata, &high_task_wakeup);
    return high_task_wakeup == pdTRUE;
}


void app_main(void)
{
    rmt_rx_channel_config_t rx_channel_cfg = {
        .clk_src = RMT_CLK_SRC_DEFAULT,
        .resolution_hz = 1000000, // 1MHz resolution, 1 tick = 1us,
        .mem_block_symbols = 256, // number of RMT symbols that the channel can store at a time
        .gpio_num = GPIO_NUM_4,
    };

    rmt_channel_handle_t rx_channel = NULL;
    ESP_ERROR_CHECK(rmt_new_rx_channel(&rx_channel_cfg, &rx_channel));

    ESP_LOGI(TAG, "register RX done callback");
    QueueHandle_t receive_queue = xQueueCreate(1, sizeof(rmt_rx_done_event_data_t));
    
    assert(receive_queue);

    rmt_rx_event_callbacks_t cbs = {
        .on_recv_done = example_rmt_rx_done_callback,
    };

    ESP_ERROR_CHECK(rmt_rx_register_event_callbacks(rx_channel, &cbs, receive_queue));

    // rmt_carrier_config_t rx_carrier_cfg = {
    //     .duty_cycle = 0.33,                 // duty cycle 33%
    //     .frequency_hz = 25000,              // 25 KHz carrier, should be smaller than the transmitter's carrier frequency
    //     .flags.polarity_active_low = false, // the carrier is modulated to high level
    // };
    // demodulate carrier from RX channel
    // ESP_ERROR_CHECK(rmt_apply_carrier(rx_channel, &rx_carrier_cfg));


    rmt_receive_config_t receive_config = {
        .signal_range_min_ns = 650000,     // 650-ms What should this be set to?
        .signal_range_max_ns = 20000000,   // 20s What should this be set to?
    };


    ESP_ERROR_CHECK(rmt_enable(rx_channel));

    rmt_symbol_word_t raw_symbols[256]; // 256 symbols should be sufficient 
    rmt_rx_done_event_data_t rx_data;
    // ready to receive

    ESP_ERROR_CHECK(rmt_receive(rx_channel, raw_symbols, sizeof(raw_symbols), &receive_config));
    while (1) {
        // wait for RX done signal
        if (xQueueReceive(receive_queue, &rx_data, pdMS_TO_TICKS(1000)) == pdPASS) {
            // parse the receive symbols and print the result
            parse_frame(rx_data.received_symbols, rx_data.num_symbols);
            // start receive again
            ESP_ERROR_CHECK(rmt_receive(rx_channel, raw_symbols, sizeof(raw_symbols), &receive_config));
        }
    }
}