using RTL_433 with rtl_433 -R 0 -X 'n=name,m=OOK_PCM, s=800, l=800, g=2000,r=6000'
time : 2023-08-12 20:08:07
model : name count : 2 num_rows : 2 rows :
len : 65 data : aaaaaaaaaaaaaaaa0,
len : 82 data : aa5999a5a699965666950
codes : {65}aaaaaaaaaaaaaaaa0, {82}aa5999a5a69996566695
I have been using the Arduino code here - https://www.espboards.dev/blog/esp32-433-rmt-ev1527/ as basis for what Ive done.
The data which I am reading with the following ESP-IDF code does not match.
I am new to RMT peripheral and how to use it.
Could I get some guidance on how to read the wave form using RMT?
Do I need to define a carrier wave so I can read? Like the example in the Arduino code? Would my carrier frequency be? 1/800 Mhz?
Are there any references I could read to learn how to turn the timings to binary data?
The timings appear to match the wave form? Is converting these my issue?
- Frame start 47---
{1:735},{0:914}
{1:758},{0:905}
{1:771},{0:897}
{1:809},{0:840}
{1:837},{0:859}
{1:797},{0:868}
{1:803},{0:862}
{1:815},{0:861}
{1:812},{0:840}
{1:850},{0:815}
{1:867},{0:815}
{1:834},{0:847}
{1:841},{0:832}
{1:843},{0:818}
{1:839},{0:834}
{1:846},{0:817}
{1:854},{0:818}
{1:843},{0:840}
{1:857},{0:4978}
{1:845},{0:915}
{1:832},{0:935}
{1:823},{0:949}
{1:840},{0:1817}
{1:992},{0:837}
{1:1850},{0:1876}
{1:1777},{0:1768}
{1:1759},{0:1793}
{1:1791},{0:990}
{1:841},{0:1859}
{1:1026},{0:825}
{1:1805},{0:918}
{1:843},{0:1747}
{1:1791},{0:966}
{1:845},{0:1843}
{1:1832},{0:1870}
{1:1809},{0:1748}
{1:939},{0:814}
{1:1800},{0:1796}
{1:1003},{0:824}
{1:1014},{0:836}
{1:1870},{0:1790}
{1:1745},{0:1775}
{1:1793},{0:968}
{1:843},{0:1823}
{1:1010},{0:836}
{1:1040},{0:817}
{1:886},{0:0}
---Frame end:
3 3 3 3 2 1 0 0 0 3 3 2 2 2 2 1 1 2 0 0 1 1 0
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));
}
}
}