kopia lustrzana https://github.com/espressif/esp-idf
rmt: update rmt ll APIs
morris
rodzic
ecbe0dad1b
commit
c91565d538
|
|
@ -59,7 +59,7 @@ typedef struct {
|
|||
|
||||
#ifdef RMT_SUPPORT_RX_DEMODULATION
|
||||
bool rm_carrier; /*!< RMT receiver remove carrier enable */
|
||||
uint16_t high_thres; /*!< The threshold of carrier high level tick number */
|
||||
uint16_t high_thres; /*!< The threshold of carrier high level tick number */
|
||||
uint16_t low_thres; /*!< The threshold of carrier low level tick number */
|
||||
rmt_carrier_level_t carrier_level; /*!< The level need to remove carrier */
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD
|
||||
// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
|
|
@ -79,7 +79,7 @@ typedef struct {
|
|||
#endif
|
||||
rmt_item32_t *tx_buf;
|
||||
RingbufHandle_t rx_buf;
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG_MODE
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG
|
||||
rmt_item32_t *rx_item_buf;
|
||||
uint32_t rx_item_buf_size;
|
||||
uint32_t rx_item_len;
|
||||
|
|
@ -160,8 +160,8 @@ esp_err_t rmt_set_tx_carrier(rmt_channel_t channel, bool carrier_en, uint16_t hi
|
|||
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
|
||||
RMT_CHECK(carrier_level < RMT_CARRIER_LEVEL_MAX, RMT_CARRIER_ERROR_STR, ESP_ERR_INVALID_ARG);
|
||||
RMT_ENTER_CRITICAL();
|
||||
rmt_ll_set_carrier_high_low_ticks(p_rmt_obj[channel]->hal.regs, channel, high_level, low_level);
|
||||
rmt_ll_set_carrier_to_level(p_rmt_obj[channel]->hal.regs, channel, carrier_level);
|
||||
rmt_ll_set_tx_carrier_high_low_ticks(p_rmt_obj[channel]->hal.regs, channel, high_level, low_level);
|
||||
rmt_ll_set_carrier_on_level(p_rmt_obj[channel]->hal.regs, channel, carrier_level);
|
||||
rmt_ll_enable_carrier(p_rmt_obj[channel]->hal.regs, channel, carrier_en);
|
||||
RMT_EXIT_CRITICAL();
|
||||
return ESP_OK;
|
||||
|
|
@ -171,7 +171,7 @@ esp_err_t rmt_set_mem_pd(rmt_channel_t channel, bool pd_en)
|
|||
{
|
||||
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
|
||||
RMT_ENTER_CRITICAL();
|
||||
rmt_ll_power_down_mem(p_rmt_obj[channel]->hal.regs, channel, pd_en);
|
||||
rmt_ll_power_down_mem(p_rmt_obj[channel]->hal.regs, pd_en);
|
||||
RMT_EXIT_CRITICAL();
|
||||
return ESP_OK;
|
||||
}
|
||||
|
|
@ -180,7 +180,7 @@ esp_err_t rmt_get_mem_pd(rmt_channel_t channel, bool *pd_en)
|
|||
{
|
||||
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
|
||||
RMT_ENTER_CRITICAL();
|
||||
*pd_en = rmt_ll_is_mem_power_down(p_rmt_obj[channel]->hal.regs, channel);
|
||||
*pd_en = rmt_ll_is_mem_power_down(p_rmt_obj[channel]->hal.regs);
|
||||
RMT_EXIT_CRITICAL();
|
||||
return ESP_OK;
|
||||
}
|
||||
|
|
@ -220,12 +220,12 @@ esp_err_t rmt_rx_start(rmt_channel_t channel, bool rx_idx_rst)
|
|||
rmt_ll_clear_rx_end_interrupt(p_rmt_obj[channel]->hal.regs, channel);
|
||||
rmt_ll_enable_rx_end_interrupt(p_rmt_obj[channel]->hal.regs, channel, true);
|
||||
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG_MODE
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG
|
||||
const uint32_t item_block_len = rmt_ll_get_mem_blocks(p_rmt_obj[channel]->hal.regs, channel) * RMT_MEM_ITEM_NUM;
|
||||
rmt_ll_set_rx_limit(p_rmt_obj[channel]->hal.regs, channel, item_block_len / 2);
|
||||
p_rmt_obj[channel]->rx_item_start_idx = 0;
|
||||
p_rmt_obj[channel]->rx_item_len = 0;
|
||||
if (rmt_ll_get_rx_pingpong_en(p_rmt_obj[channel]->hal.regs, channel)) {
|
||||
if (rmt_ll_is_rx_pingpong_enabled(p_rmt_obj[channel]->hal.regs, channel)) {
|
||||
rmt_ll_enable_rx_thres_interrupt(p_rmt_obj[channel]->hal.regs, channel, true);
|
||||
}
|
||||
#endif
|
||||
|
|
@ -241,7 +241,7 @@ esp_err_t rmt_rx_stop(rmt_channel_t channel)
|
|||
RMT_ENTER_CRITICAL();
|
||||
rmt_ll_enable_rx(p_rmt_obj[channel]->hal.regs, channel, false);
|
||||
rmt_ll_enable_rx_end_interrupt(p_rmt_obj[channel]->hal.regs, channel, false);
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG_MODE
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG
|
||||
rmt_ll_enable_rx_thres_interrupt(p_rmt_obj[channel]->hal.regs, channel, false);
|
||||
#endif
|
||||
RMT_EXIT_CRITICAL();
|
||||
|
|
@ -282,7 +282,7 @@ esp_err_t rmt_set_tx_loop_mode(rmt_channel_t channel, bool loop_en)
|
|||
{
|
||||
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
|
||||
RMT_ENTER_CRITICAL();
|
||||
rmt_ll_enable_tx_cyclic(p_rmt_obj[channel]->hal.regs, channel, loop_en);
|
||||
rmt_ll_enable_tx_loop(p_rmt_obj[channel]->hal.regs, channel, loop_en);
|
||||
RMT_EXIT_CRITICAL();
|
||||
return ESP_OK;
|
||||
}
|
||||
|
|
@ -291,7 +291,7 @@ esp_err_t rmt_get_tx_loop_mode(rmt_channel_t channel, bool *loop_en)
|
|||
{
|
||||
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
|
||||
RMT_ENTER_CRITICAL();
|
||||
*loop_en = rmt_ll_is_tx_cyclic_enabled(p_rmt_obj[channel]->hal.regs, channel);
|
||||
*loop_en = rmt_ll_is_tx_loop_enabled(p_rmt_obj[channel]->hal.regs, channel);
|
||||
RMT_EXIT_CRITICAL();
|
||||
return ESP_OK;
|
||||
}
|
||||
|
|
@ -378,8 +378,8 @@ esp_err_t rmt_set_rx_intr_en(rmt_channel_t channel, bool en)
|
|||
return ESP_OK;
|
||||
}
|
||||
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG_MODE
|
||||
esp_err_t rmt_set_rx_thr_intr_en(rmt_channel_t channel, bool en, uint16_t evt_thresh)
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG
|
||||
static esp_err_t rmt_set_rx_thr_intr_en(rmt_channel_t channel, bool en, uint16_t evt_thresh)
|
||||
{
|
||||
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
|
||||
if (en) {
|
||||
|
|
@ -497,7 +497,7 @@ static esp_err_t rmt_internal_config(rmt_dev_t *dev, const rmt_config_t *rmt_par
|
|||
uint8_t idle_level = rmt_param->tx_config.idle_level;
|
||||
|
||||
RMT_ENTER_CRITICAL();
|
||||
rmt_ll_enable_tx_cyclic(dev, channel, rmt_param->tx_config.loop_en);
|
||||
rmt_ll_enable_tx_loop(dev, channel, rmt_param->tx_config.loop_en);
|
||||
rmt_ll_enable_tx_pingpong(dev, true);
|
||||
/*Set idle level */
|
||||
rmt_ll_enable_tx_idle(dev, channel, rmt_param->tx_config.idle_output_en);
|
||||
|
|
@ -509,11 +509,11 @@ static esp_err_t rmt_internal_config(rmt_dev_t *dev, const rmt_config_t *rmt_par
|
|||
duty_div = rmt_source_clk_hz / carrier_freq_hz;
|
||||
duty_h = duty_div * carrier_duty_percent / 100;
|
||||
duty_l = duty_div - duty_h;
|
||||
rmt_ll_set_carrier_to_level(dev, channel, carrier_level);
|
||||
rmt_ll_set_carrier_high_low_ticks(dev, channel, duty_h, duty_l);
|
||||
rmt_ll_set_carrier_on_level(dev, channel, carrier_level);
|
||||
rmt_ll_set_tx_carrier_high_low_ticks(dev, channel, duty_h, duty_l);
|
||||
} else {
|
||||
rmt_ll_set_carrier_to_level(dev, channel, 0);
|
||||
rmt_ll_set_carrier_high_low_ticks(dev, channel, 0, 0);
|
||||
rmt_ll_set_carrier_on_level(dev, channel, 0);
|
||||
rmt_ll_set_tx_carrier_high_low_ticks(dev, channel, 0, 0);
|
||||
}
|
||||
RMT_EXIT_CRITICAL();
|
||||
|
||||
|
|
@ -530,15 +530,14 @@ static esp_err_t rmt_internal_config(rmt_dev_t *dev, const rmt_config_t *rmt_par
|
|||
rmt_ll_set_rx_filter_thres(dev, channel, filter_cnt);
|
||||
rmt_ll_enable_rx_filter(dev, channel, rmt_param->rx_config.filter_en);
|
||||
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG_MODE
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG
|
||||
rmt_ll_enable_rx_pingpong(dev, channel, true);
|
||||
#endif
|
||||
|
||||
#ifdef RMT_SUPPORT_RX_DEMODULATION
|
||||
rmt_ll_enable_rx_carrier_rm(dev, channel, rmt_param->rx_config.rm_carrier);
|
||||
rmt_ll_set_carrier_rm_high_thres_ticks(dev, channel, rmt_param->rx_config.high_thres);
|
||||
rmt_ll_set_carrier_rm_low_thres_ticks(dev, channel, rmt_param->rx_config.low_thres);
|
||||
rmt_ll_set_carrier_to_level(dev, channel, rmt_param->rx_config.carrier_level);
|
||||
rmt_ll_set_rx_carrier_high_low_ticks(dev, channel, rmt_param->rx_config.high_thres, rmt_param->rx_config.low_thres );
|
||||
rmt_ll_set_carrier_on_level(dev, channel, rmt_param->rx_config.carrier_level);
|
||||
#endif
|
||||
RMT_EXIT_CRITICAL();
|
||||
|
||||
|
|
@ -710,11 +709,11 @@ static void IRAM_ATTR rmt_driver_isr_default(void *arg)
|
|||
rmt_ll_set_mem_owner(p_rmt_obj[channel]->hal.regs, channel, RMT_MEM_OWNER_SW);
|
||||
if (p_rmt->rx_buf) {
|
||||
addr = RMTMEM.chan[channel].data32;
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG_MODE
|
||||
if(item_len > p_rmt->rx_item_start_idx) {
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG
|
||||
if (item_len > p_rmt->rx_item_start_idx) {
|
||||
item_len = item_len - p_rmt->rx_item_start_idx;
|
||||
}
|
||||
memcpy((void*)(p_rmt->rx_item_buf + p_rmt->rx_item_len), (void*)(addr + p_rmt->rx_item_start_idx), item_len * 4);
|
||||
memcpy((void *)(p_rmt->rx_item_buf + p_rmt->rx_item_len), (void *)(addr + p_rmt->rx_item_start_idx), item_len * 4);
|
||||
p_rmt->rx_item_len += item_len;
|
||||
BaseType_t res = xRingbufferSendFromISR(p_rmt->rx_buf, (void *)(p_rmt->rx_item_buf), p_rmt->rx_item_len * 4, &HPTaskAwoken);
|
||||
#else
|
||||
|
|
@ -727,10 +726,10 @@ static void IRAM_ATTR rmt_driver_isr_default(void *arg)
|
|||
ESP_EARLY_LOGE(RMT_TAG, "RMT RX BUFFER ERROR");
|
||||
}
|
||||
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG_MODE
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG
|
||||
p_rmt->rx_item_start_idx = 0;
|
||||
p_rmt->rx_item_len = 0;
|
||||
memset((void*)p_rmt->rx_item_buf, 0, p_rmt->rx_item_buf_size);
|
||||
memset((void *)p_rmt->rx_item_buf, 0, p_rmt->rx_item_buf_size);
|
||||
#endif
|
||||
rmt_ll_reset_rx_pointer(p_rmt_obj[channel]->hal.regs, channel);
|
||||
rmt_ll_set_mem_owner(p_rmt_obj[channel]->hal.regs, channel, RMT_MEM_OWNER_HW);
|
||||
|
|
@ -739,7 +738,7 @@ static void IRAM_ATTR rmt_driver_isr_default(void *arg)
|
|||
rmt_ll_clear_rx_end_interrupt(hal->regs, channel);
|
||||
}
|
||||
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG_MODE
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG
|
||||
// Rx thres interrupt
|
||||
status = rmt_ll_get_rx_thres_interrupt_status(hal->regs);
|
||||
while (status) {
|
||||
|
|
@ -749,8 +748,8 @@ static void IRAM_ATTR rmt_driver_isr_default(void *arg)
|
|||
int mem_item_size = rmt_ll_get_mem_blocks(p_rmt_obj[channel]->hal.regs, channel) * RMT_MEM_ITEM_NUM;
|
||||
int rx_thres_lim = rmt_ll_get_rx_limit(p_rmt_obj[channel]->hal.regs, channel);
|
||||
int item_len = (p_rmt->rx_item_start_idx == 0) ? rx_thres_lim : (mem_item_size - rx_thres_lim);
|
||||
if((p_rmt->rx_item_len + item_len) < (p_rmt->rx_item_buf_size / 4)) {
|
||||
memcpy((void*)(p_rmt->rx_item_buf + p_rmt->rx_item_len), (void*)(RMTMEM.chan[channel].data32 + p_rmt->rx_item_start_idx), item_len * 4);
|
||||
if ((p_rmt->rx_item_len + item_len) < (p_rmt->rx_item_buf_size / 4)) {
|
||||
memcpy((void *)(p_rmt->rx_item_buf + p_rmt->rx_item_len), (void *)(RMTMEM.chan[channel].data32 + p_rmt->rx_item_start_idx), item_len * 4);
|
||||
p_rmt->rx_item_len += item_len;
|
||||
p_rmt->rx_item_start_idx += item_len;
|
||||
if (p_rmt->rx_item_start_idx >= mem_item_size) {
|
||||
|
|
@ -800,7 +799,7 @@ esp_err_t rmt_driver_uninstall(rmt_channel_t channel)
|
|||
rmt_set_err_intr_en(channel, 0);
|
||||
rmt_set_tx_intr_en(channel, 0);
|
||||
rmt_set_tx_thr_intr_en(channel, 0, 0xffff);
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG_MODE
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG
|
||||
rmt_set_rx_thr_intr_en(channel, 0, 0xffff);
|
||||
#endif
|
||||
|
||||
|
|
@ -835,7 +834,7 @@ esp_err_t rmt_driver_uninstall(rmt_channel_t channel)
|
|||
p_rmt_obj[channel]->sample_to_rmt = NULL;
|
||||
}
|
||||
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG_MODE
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG
|
||||
if (p_rmt_obj[channel]->rx_item_buf) {
|
||||
free(p_rmt_obj[channel]->rx_item_buf);
|
||||
p_rmt_obj[channel]->rx_item_buf = NULL;
|
||||
|
|
@ -905,12 +904,12 @@ esp_err_t rmt_driver_install(rmt_channel_t channel, size_t rx_buf_size, int intr
|
|||
p_rmt_obj[channel]->rx_buf = xRingbufferCreate(rx_buf_size, RINGBUF_TYPE_NOSPLIT);
|
||||
}
|
||||
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG_MODE
|
||||
#ifdef RMT_SUPPORT_RX_PINGPONG
|
||||
if (p_rmt_obj[channel]->rx_item_buf == NULL && rx_buf_size > 0) {
|
||||
#if !CONFIG_SPIRAM_USE_MALLOC
|
||||
p_rmt_obj[channel]->rx_item_buf = (rmt_item32_t *)malloc(rx_buf_size);
|
||||
#else
|
||||
if (p_rmt_obj[channel]->intr_alloc_flags & ESP_INTR_FLAG_IRAM) {
|
||||
if (!(p_rmt_obj[channel]->intr_alloc_flags & ESP_INTR_FLAG_IRAM)) {
|
||||
p_rmt_obj[channel]->rx_item_buf = (rmt_item32_t *)malloc(rx_buf_size);
|
||||
} else {
|
||||
p_rmt_obj[channel]->rx_item_buf = (rmt_item32_t *)heap_caps_calloc(1, rx_buf_size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
|
||||
|
|
|
|||
|
|
@ -18,10 +18,12 @@
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define RMT_CHANNEL_MEM_WORDS (64) /*!< Each channel owns 64 words memory */
|
||||
#define RMT_CHANNELS_NUM (4) /*!< Total 4 channels */
|
||||
#define RMT_SUPPORT_RX_PINGPONG_MODE (1)
|
||||
#define RMT_SUPPORT_RX_DEMODULATION (1)
|
||||
#define RMT_CHANNEL_MEM_WORDS (64) /*!< Each channel owns 64 words memory (1 word = 4 Bytes) */
|
||||
#define RMT_CHANNELS_NUM (4) /*!< Total 4 channels */
|
||||
#define RMT_SUPPORT_RX_PINGPONG (1) /*!< Support Ping-Pong mode on RX path */
|
||||
#define RMT_SUPPORT_RX_DEMODULATION (1) /*!< Support signal demodulation on RX path (i.e. remove carrier) */
|
||||
#define RMT_SUPPORT_TX_LOOP_COUNT (1) /*!< Support transmit specified number of cycles in loop mode */
|
||||
#define RMT_SUPPORT_TX_SIMULTANEOUS (1) /*!< Support multiple channel transmit simultaneously */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
typedef volatile struct {
|
||||
uint32_t data_ch[4]; /**/
|
||||
uint32_t data_ch[4]; /* Data FIFO, Can only be accessed by PeriBus2 */
|
||||
struct {
|
||||
union {
|
||||
struct {
|
||||
|
|
@ -283,7 +283,7 @@ typedef volatile struct {
|
|||
uint32_t reserved_f0;
|
||||
uint32_t reserved_f4;
|
||||
uint32_t reserved_f8;
|
||||
uint32_t date; /**/
|
||||
uint32_t date; /* Version Control Register */
|
||||
} rmt_dev_t;
|
||||
extern rmt_dev_t RMT;
|
||||
|
||||
|
|
|
|||
|
|
@ -21,6 +21,11 @@ extern "C" {
|
|||
#include "soc/rmt_struct.h"
|
||||
#include "soc/rmt_caps.h"
|
||||
|
||||
static inline void rmt_ll_enable_drive_clock(rmt_dev_t *dev, bool enable)
|
||||
{
|
||||
dev->conf_ch[0].conf0.clk_en = enable;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_reset_counter_clock_div(rmt_dev_t *dev, uint32_t channel)
|
||||
{
|
||||
dev->conf_ch[channel].conf1.ref_cnt_rst = 1;
|
||||
|
|
@ -57,12 +62,12 @@ static inline void rmt_ll_enable_rx(rmt_dev_t *dev, uint32_t channel, bool enabl
|
|||
dev->conf_ch[channel].conf1.rx_en = enable;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_power_down_mem(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
static inline void rmt_ll_power_down_mem(rmt_dev_t *dev, bool enable)
|
||||
{
|
||||
dev->conf_ch[0].conf0.mem_pd = enable; // Only conf0 register of channel0 has `mem_pd`
|
||||
}
|
||||
|
||||
static inline bool rmt_ll_is_mem_power_down(rmt_dev_t *dev, uint32_t channel)
|
||||
static inline bool rmt_ll_is_mem_power_down(rmt_dev_t *dev)
|
||||
{
|
||||
return dev->conf_ch[0].conf0.mem_pd; // Only conf0 register of channel0 has `mem_pd`
|
||||
}
|
||||
|
|
@ -84,7 +89,8 @@ static inline void rmt_ll_set_counter_clock_div(rmt_dev_t *dev, uint32_t channel
|
|||
|
||||
static inline uint32_t rmt_ll_get_counter_clock_div(rmt_dev_t *dev, uint32_t channel)
|
||||
{
|
||||
return dev->conf_ch[channel].conf0.div_cnt;
|
||||
uint32_t div = dev->conf_ch[channel].conf0.div_cnt;
|
||||
return div == 0 ? 256 : div;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_enable_tx_pingpong(rmt_dev_t *dev, bool enable)
|
||||
|
|
@ -117,12 +123,12 @@ static inline uint32_t rmt_ll_get_mem_owner(rmt_dev_t *dev, uint32_t channel)
|
|||
return dev->conf_ch[channel].conf1.mem_owner;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_enable_tx_cyclic(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
static inline void rmt_ll_enable_tx_loop(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
{
|
||||
dev->conf_ch[channel].conf1.tx_conti_mode = enable;
|
||||
}
|
||||
|
||||
static inline bool rmt_ll_is_tx_cyclic_enabled(rmt_dev_t *dev, uint32_t channel)
|
||||
static inline bool rmt_ll_is_tx_loop_enabled(rmt_dev_t *dev, uint32_t channel)
|
||||
{
|
||||
return dev->conf_ch[channel].conf1.tx_conti_mode;
|
||||
}
|
||||
|
|
@ -248,7 +254,7 @@ static inline uint32_t rmt_ll_get_tx_thres_interrupt_status(rmt_dev_t *dev)
|
|||
return (status & 0xFF000000) >> 24;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_set_carrier_high_low_ticks(rmt_dev_t *dev, uint32_t channel, uint32_t high_ticks, uint32_t low_ticks)
|
||||
static inline void rmt_ll_set_tx_carrier_high_low_ticks(rmt_dev_t *dev, uint32_t channel, uint32_t high_ticks, uint32_t low_ticks)
|
||||
{
|
||||
dev->carrier_duty_ch[channel].high = high_ticks;
|
||||
dev->carrier_duty_ch[channel].low = low_ticks;
|
||||
|
|
@ -265,7 +271,7 @@ static inline void rmt_ll_enable_carrier(rmt_dev_t *dev, uint32_t channel, bool
|
|||
dev->conf_ch[channel].conf0.carrier_en = enable;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_set_carrier_to_level(rmt_dev_t *dev, uint32_t channel, uint8_t level)
|
||||
static inline void rmt_ll_set_carrier_on_level(rmt_dev_t *dev, uint32_t channel, uint8_t level)
|
||||
{
|
||||
dev->conf_ch[channel].conf0.carrier_out_lv = level;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,9 +21,16 @@ extern "C" {
|
|||
#include "soc/rmt_struct.h"
|
||||
#include "soc/rmt_caps.h"
|
||||
|
||||
static inline void rmt_ll_enable_drive_clock(rmt_dev_t *dev, bool enable)
|
||||
{
|
||||
dev->apb_conf.clk_en = enable; // register clock gating
|
||||
dev->apb_conf.mem_clk_force_on = enable; // memory clock gating
|
||||
}
|
||||
|
||||
static inline void rmt_ll_reset_counter_clock_div(rmt_dev_t *dev, uint32_t channel)
|
||||
{
|
||||
|
||||
dev->ref_cnt_rst.val |= (1 << channel);
|
||||
dev->ref_cnt_rst.val &= ~(1 << channel);
|
||||
}
|
||||
|
||||
static inline void rmt_ll_reset_tx_pointer(rmt_dev_t *dev, uint32_t channel)
|
||||
|
|
@ -53,15 +60,18 @@ static inline void rmt_ll_enable_rx(rmt_dev_t *dev, uint32_t channel, bool enabl
|
|||
dev->conf_ch[channel].conf1.rx_en = enable;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_power_down_mem(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
static inline void rmt_ll_power_down_mem(rmt_dev_t *dev, bool enable)
|
||||
{
|
||||
dev->apb_conf.mem_force_pu = enable;
|
||||
dev->apb_conf.mem_force_pu = !enable;
|
||||
dev->apb_conf.mem_force_pd = enable;
|
||||
}
|
||||
|
||||
static inline bool rmt_ll_is_mem_power_down(rmt_dev_t *dev, uint32_t channel)
|
||||
static inline bool rmt_ll_is_mem_power_down(rmt_dev_t *dev)
|
||||
{
|
||||
return (dev->apb_conf.mem_force_pu) && (dev->apb_conf.mem_force_pd);
|
||||
// the RTC domain can also power down RMT memory
|
||||
// so it's probably not enough to detect whether it's powered down or not
|
||||
// mem_force_pd has higher priority than mem_force_pu
|
||||
return (dev->apb_conf.mem_force_pd) || !(dev->apb_conf.mem_force_pu);
|
||||
}
|
||||
|
||||
static inline void rmt_ll_set_mem_blocks(rmt_dev_t *dev, uint32_t channel, uint8_t block_num)
|
||||
|
|
@ -81,7 +91,8 @@ static inline void rmt_ll_set_counter_clock_div(rmt_dev_t *dev, uint32_t channel
|
|||
|
||||
static inline uint32_t rmt_ll_get_counter_clock_div(rmt_dev_t *dev, uint32_t channel)
|
||||
{
|
||||
return dev->conf_ch[channel].conf0.div_cnt;
|
||||
uint32_t div = dev->conf_ch[channel].conf0.div_cnt;
|
||||
return div == 0 ? 256 : div;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_enable_tx_pingpong(rmt_dev_t *dev, bool enable)
|
||||
|
|
@ -114,16 +125,48 @@ static inline uint32_t rmt_ll_get_mem_owner(rmt_dev_t *dev, uint32_t channel)
|
|||
return dev->conf_ch[channel].conf1.mem_owner;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_enable_tx_cyclic(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
static inline void rmt_ll_enable_tx_loop(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
{
|
||||
dev->conf_ch[channel].conf1.tx_conti_mode = enable;
|
||||
}
|
||||
|
||||
static inline bool rmt_ll_is_tx_cyclic_enabled(rmt_dev_t *dev, uint32_t channel)
|
||||
static inline bool rmt_ll_is_tx_loop_enabled(rmt_dev_t *dev, uint32_t channel)
|
||||
{
|
||||
return dev->conf_ch[channel].conf1.tx_conti_mode;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_set_tx_loop_count(rmt_dev_t *dev, uint32_t channel, uint32_t count)
|
||||
{
|
||||
dev->tx_lim_ch[channel].tx_loop_num = count;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_reset_tx_loop(rmt_dev_t *dev, uint32_t channel)
|
||||
{
|
||||
dev->tx_lim_ch[channel].loop_count_reset = 1;
|
||||
dev->tx_lim_ch[channel].loop_count_reset = 0;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_enable_tx_loop_count(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
{
|
||||
dev->tx_lim_ch[channel].tx_loop_cnt_en = enable;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_enable_tx_sync(rmt_dev_t *dev, bool enable)
|
||||
{
|
||||
dev->tx_sim.en = enable;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_add_channel_to_group(rmt_dev_t *dev, uint32_t channel)
|
||||
{
|
||||
dev->tx_sim.val |= 1 << channel;
|
||||
}
|
||||
|
||||
static inline uint32_t rmt_ll_remove_channel_from_group(rmt_dev_t *dev, uint32_t channel)
|
||||
{
|
||||
dev->tx_sim.val &= ~(1 << channel);
|
||||
return dev->tx_sim.val & 0x0F;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_enable_rx_filter(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
{
|
||||
dev->conf_ch[channel].conf1.rx_filter_en = enable;
|
||||
|
|
@ -208,6 +251,12 @@ static inline void rmt_ll_enable_tx_thres_interrupt(rmt_dev_t *dev, uint32_t cha
|
|||
dev->int_ena.val |= (enable << (channel + 12));
|
||||
}
|
||||
|
||||
static inline void rmt_ll_enable_tx_loop_interrupt(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
{
|
||||
dev->int_ena.val &= ~(1 << (channel + 16));
|
||||
dev->int_ena.val |= (enable << (channel + 16));
|
||||
}
|
||||
|
||||
static inline void rmt_ll_enable_rx_thres_interrupt(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
{
|
||||
dev->int_ena.val &= ~(1 << (channel + 20));
|
||||
|
|
@ -234,6 +283,11 @@ static inline void rmt_ll_clear_tx_thres_interrupt(rmt_dev_t *dev, uint32_t chan
|
|||
dev->int_clr.val = (1 << (channel + 12));
|
||||
}
|
||||
|
||||
static inline void rmt_ll_clear_tx_loop_interrupt(rmt_dev_t *dev, uint32_t channel)
|
||||
{
|
||||
dev->int_clr.val = (1 << (channel + 16));
|
||||
}
|
||||
|
||||
static inline void rmt_ll_clear_rx_thres_interrupt(rmt_dev_t *dev, uint32_t channel)
|
||||
{
|
||||
dev->int_clr.val = (1 << (channel + 20));
|
||||
|
|
@ -254,7 +308,7 @@ static inline uint32_t rmt_ll_get_rx_end_interrupt_status(rmt_dev_t *dev)
|
|||
static inline uint32_t rmt_ll_get_err_interrupt_status(rmt_dev_t *dev)
|
||||
{
|
||||
uint32_t status = dev->int_st.val;
|
||||
return ((status & 0x04) >> 2) | ((status & 0x20) >> 4) | ((status & 0x100) >> 6) | ((status & 0x800) >> 8);;
|
||||
return ((status & 0x04) >> 2) | ((status & 0x20) >> 4) | ((status & 0x100) >> 6) | ((status & 0x800) >> 8);
|
||||
}
|
||||
|
||||
static inline uint32_t rmt_ll_get_tx_thres_interrupt_status(rmt_dev_t *dev)
|
||||
|
|
@ -263,34 +317,56 @@ static inline uint32_t rmt_ll_get_tx_thres_interrupt_status(rmt_dev_t *dev)
|
|||
return (status & 0xF000) >> 12;
|
||||
}
|
||||
|
||||
static inline uint32_t rmt_ll_get_tx_loop_interrupt_status(rmt_dev_t *dev)
|
||||
{
|
||||
uint32_t status = dev->int_st.val;
|
||||
return (status & 0xF0000) >> 16;
|
||||
}
|
||||
|
||||
static inline uint32_t rmt_ll_get_rx_thres_interrupt_status(rmt_dev_t *dev)
|
||||
{
|
||||
uint32_t status = dev->int_st.val;
|
||||
return (status & 0xF00000) >> 20;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_set_carrier_high_low_ticks(rmt_dev_t *dev, uint32_t channel, uint32_t high_ticks, uint32_t low_ticks)
|
||||
static inline void rmt_ll_set_tx_carrier_high_low_ticks(rmt_dev_t *dev, uint32_t channel, uint32_t high_ticks, uint32_t low_ticks)
|
||||
{
|
||||
dev->carrier_duty_ch[channel].high = high_ticks;
|
||||
dev->carrier_duty_ch[channel].low = low_ticks;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_set_rx_carrier_high_low_ticks(rmt_dev_t *dev, uint32_t channel, uint32_t high_ticks, uint32_t low_ticks)
|
||||
{
|
||||
dev->ch_rx_carrier_rm[channel].carrier_high_thres_ch = high_ticks;
|
||||
dev->ch_rx_carrier_rm[channel].carrier_low_thres_ch = low_ticks;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_get_carrier_high_low_ticks(rmt_dev_t *dev, uint32_t channel, uint32_t *high_ticks, uint32_t *low_ticks)
|
||||
{
|
||||
*high_ticks = dev->carrier_duty_ch[channel].high;
|
||||
*low_ticks = dev->carrier_duty_ch[channel].low;
|
||||
}
|
||||
|
||||
// This function has different meaning for TX and RX
|
||||
// TX: enable to modulate carrier
|
||||
// RX: enable to demodulate carrier
|
||||
static inline void rmt_ll_enable_carrier(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
{
|
||||
dev->conf_ch[channel].conf0.carrier_en = enable;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_set_carrier_to_level(rmt_dev_t *dev, uint32_t channel, uint8_t level)
|
||||
static inline void rmt_ll_set_carrier_on_level(rmt_dev_t *dev, uint32_t channel, uint8_t level)
|
||||
{
|
||||
dev->conf_ch[channel].conf0.carrier_out_lv = level;
|
||||
}
|
||||
|
||||
// set true, enable carrier in all RMT state (idle, reading, sending)
|
||||
// set false, enable carrier only in sending state (i.e. there're effective data in RAM to be sent)
|
||||
static inline void rmt_ll_tx_set_carrier_always_on(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
{
|
||||
dev->conf_ch[channel].conf0.carrier_eff_en = !enable;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_write_memory(rmt_mem_t *mem, uint32_t channel, const rmt_item32_t *data, uint32_t length, uint32_t off)
|
||||
{
|
||||
length = (off + length) > RMT_CHANNEL_MEM_WORDS ? (RMT_CHANNEL_MEM_WORDS - off) : length;
|
||||
|
|
@ -304,26 +380,6 @@ static inline void rmt_ll_enable_rx_pingpong(rmt_dev_t *dev, uint32_t channel, b
|
|||
dev->conf_ch[channel].conf1.chk_rx_carrier_en = enable;
|
||||
}
|
||||
|
||||
static inline bool rmt_ll_get_rx_pingpong_en(rmt_dev_t *dev, uint32_t channel)
|
||||
{
|
||||
return dev->conf_ch[channel].conf1.chk_rx_carrier_en;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_enable_rx_carrier_rm(rmt_dev_t *dev, uint32_t channel, bool enable)
|
||||
{
|
||||
dev->conf_ch[channel].conf0.carrier_en = enable;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_set_carrier_rm_high_thres_ticks(rmt_dev_t *dev, uint32_t channel, uint16_t high_ticks)
|
||||
{
|
||||
dev->ch_rx_carrier_rm[channel].carrier_high_thres_ch = high_ticks;
|
||||
}
|
||||
|
||||
static inline void rmt_ll_set_carrier_rm_low_thres_ticks(rmt_dev_t *dev, uint32_t channel, uint16_t low_ticks)
|
||||
{
|
||||
dev->ch_rx_carrier_rm[channel].carrier_low_thres_ch = low_ticks;
|
||||
}
|
||||
|
||||
/************************************************************************************************
|
||||
* Following Low Level APIs only used for backward compatible, will be deprecated in the future!
|
||||
***********************************************************************************************/
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ void rmt_hal_set_carrier_clock(rmt_hal_context_t *hal, uint32_t channel, uint32_
|
|||
uint32_t carrier_div = (base_clk_hz + carrier_clk_hz / 2) / carrier_clk_hz;
|
||||
uint32_t div_high = (uint32_t)(carrier_div * carrier_clk_duty);
|
||||
uint32_t div_low = carrier_div - div_high;
|
||||
rmt_ll_set_carrier_high_low_ticks(hal->regs, channel, div_high, div_low);
|
||||
rmt_ll_set_tx_carrier_high_low_ticks(hal->regs, channel, div_high, div_low);
|
||||
}
|
||||
|
||||
void rmt_hal_get_carrier_clock(rmt_hal_context_t *hal, uint32_t channel, uint32_t base_clk_hz, uint32_t *carrier_clk_hz, float *carrier_clk_duty)
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ void ref_clock_init()
|
|||
rmt_ll_set_counter_clock_div(s_rmt.regs, REF_CLOCK_RMT_CHANNEL, 1);
|
||||
rmt_ll_set_mem_blocks(s_rmt.regs, REF_CLOCK_RMT_CHANNEL, 1);
|
||||
rmt_ll_set_counter_clock_src(s_rmt.regs, REF_CLOCK_RMT_CHANNEL, 0);
|
||||
rmt_ll_enable_tx_cyclic(s_rmt.regs, REF_CLOCK_RMT_CHANNEL, true);
|
||||
rmt_ll_enable_tx_loop(s_rmt.regs, REF_CLOCK_RMT_CHANNEL, true);
|
||||
rmt_ll_start_tx(s_rmt.regs, REF_CLOCK_RMT_CHANNEL);
|
||||
|
||||
// Route signal to PCNT
|
||||
|
|
|
|||
Ładowanie…
Reference in New Issue