ESP32 Forum

Code: Select all

//rmtTest.c
//
//Testing to see if we can use rmt module for pulse width measurement
//  and quick response for short circuit detect
//
#include "myConfig.h"
#include "myOs.h"
#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "freertos/semphr.h"
#include "esp_err.h"
#include "esp_log.h"
#include "driver/rmt.h"
#include "driver/periph_ctrl.h"
#include "soc/rmt_reg.h"

#define RMT_RX_ACTIVE_LEVEL  0   /*!< If we connect with a IR receiver, the data is active low */
#define RMT_TX_CARRIER_EN    1   /*!< Enable carrier for IR transmitter test with IR led */

#define RMT_RX_CHANNEL    0     /*!< RMT channel for receiver */
#define RMT_RX_GPIO_NUM  36     /*!< GPIO number for receiver */
#define RMT_CLK_DIV      160     /*!< RMT counter clock divider */

#define PW_PULSE_COUNT_MAX  10

static int IRAM_ATTR rmt_get_mem_len(rmt_channel_t channel)
{
    int block_num = RMT.conf_ch[channel].conf0.mem_size;
    int item_block_len = block_num * RMT_MEM_ITEM_NUM;
    volatile rmt_item32_t* data = RMTMEM.chan[channel].data32;
    int idx;
    for(idx = 0; idx < item_block_len; idx++) {
        if(data[idx].duration0 == 0) {
            return idx;
        } else if(data[idx].duration1 == 0) {
            return idx + 1;
        }
    }
    return idx;
}

uint16_t recvBuffer[128];
uint32_t intCount = 0;

void IRAM_ATTR rmt_isr_handler(void* arg)
{
    static uint8_t DRAM_ATTR toggle = 0;
    //read RMT interrupt status
    uint32_t intr_st = RMT.int_st.val;


    if( RMT.int_st.ch0_rx_end )
    {
        RMT.conf_ch[RMT_RX_CHANNEL].conf1.rx_en = 0;
            int item_len = rmt_get_mem_len(RMT_RX_CHANNEL);

            //change memory owner to protect data.
            RMT.conf_ch[RMT_RX_CHANNEL].conf1.mem_owner = RMT_MEM_OWNER_TX;
            rmt_item16_t *item = RMTMEM.chan[RMT_RX_CHANNEL].data16;

            if( toggle )
            {
             GPIO.out_w1tc = outputEnableMask;
            }
            else
            {
             GPIO.out_w1ts = outputEnableMask;
            }

            toggle ^= 1;

            for(int i = 0; i < 8; ++i)
            {
                TRACE_ISR(("RX %d: %d %d %d\n", i, item[i].level, item[i].duration, !(GPIO.in1.data & shiftRegister_zeroCrossingMask)));
            }

            TRACE_ISR(("RX %d %X %X\n", ++intCount, intr_st, RMT.status_ch[RMT_RX_CHANNEL]));

            RMT.conf_ch[RMT_RX_CHANNEL].conf1.mem_wr_rst = 1;
            RMT.conf_ch[RMT_RX_CHANNEL].conf1.mem_owner = RMT_MEM_OWNER_RX;
        RMT.conf_ch[RMT_RX_CHANNEL].conf1.rx_en = 1;
    }
    else if( RMT.int_st.ch0_err )
    {
        TRACE_ISR(("RMT ERR STATUS %X\n", RMT.status_ch[RMT_RX_CHANNEL]));
        if( toggle )
        {
            GPIO.out_w1tc = outputEnableMask;
        }
        else
        {
            GPIO.out_w1ts = outputEnableMask;
        }

        toggle ^= 1;
    }

    RMT.int_clr.val = intr_st;
}



/*
 * @brief RMT receiver initialization
 */
static void rx_init()
{
    rmt_item16_t *item = RMTMEM.chan[RMT_RX_CHANNEL].data16;

    rmt_config_t rmt_rx;
    rmt_rx.channel = RMT_RX_CHANNEL;
    rmt_rx.gpio_num = RMT_RX_GPIO_NUM;
    rmt_rx.clk_div = RMT_CLK_DIV;
    rmt_rx.mem_block_num = 1;
    rmt_rx.rmt_mode = RMT_MODE_RX;
    rmt_rx.rx_config.filter_en = true;
    rmt_rx.rx_config.filter_ticks_thresh = 0xFF;
    rmt_rx.rx_config.idle_threshold = 4000;
    if( rmt_config(&rmt_rx) )
    {
        TRACE(("rmt config did not work\n"));
    }

    if( rmt_isr_register(rmt_isr_handler, NULL, ESP_INTR_FLAG_LEVEL1, 0) )
    {
        TRACE(("rmt interrupt could not be allocated\n"));
    }
    else
    {
        if(rmt_set_rx_intr_en(RMT_RX_CHANNEL, 1) || rmt_set_err_intr_en(RMT_RX_CHANNEL, 1))
        {
            TRACE(("rmt interrupt could not be enabled\n"));
        }
    }
    RMT.apb_conf.fifo_mask = RMT_DATA_MODE_MEM;
    TRACE_LINE;
}



void test_rmt(void)
{
    gpio_config_t io_conf;

    // Configure renesas reset line
    io_conf.intr_type    = GPIO_INTR_DISABLE;
    io_conf.mode         = GPIO_MODE_OUTPUT;
    io_conf.pin_bit_mask = outputEnableMask;
    io_conf.pull_down_en = 0;
    io_conf.pull_up_en   = 0;
    if( gpio_config(&io_conf) )
    {
        TRACE(("ERROR SETTING UP IO\n"));
    }
    GPIO.out_w1ts = outputEnableMask;

    rx_init();
    rmt_rx_start(RMT_RX_CHANNEL, 1);
    for(;;)
    {
        vpOs_delay_ms(2000);
        intCount = 0;
        TRACE_LINE;
    }
}

Code: Select all

rmt_rx.rx_config.idle_threshold = 0xffff;