ESP32 Receiver Interrupt

Question

Why my code is not working? What i am trying to is when i get the input from Hercules in RX pin of UART in ESP32 then the receiver interrupt should occur and should log that "Interrupt Occur, Data Received"? Here is my code of Espressif IDE. In the Hercules Emulator it is only written Hello World after every 2 seconds with FreeRTOS and nothing in without FreeRTOS

1. Without using FreeRTOS

    #include <stdio.h>
    #include <string.h>
    #include "driver/uart.h"
    #include "esp_log.h"
    #include "esp_system.h"
    #include "driver/gpio.h"
    #include "soc/uart_reg.h"

    #define RX_BUF_SIZE 1024
    #define TXD_PIN GPIO_NUM_17
    #define RXD_PIN GPIO_NUM_16

    SemaphoreHandle_t uart_mutex;
    QueueHandle_t uart_queue;

    static void IRAM_ATTR uart_rx_intr_handler(void *arg);
    static void rx_polling(void);
    static void tx_polling(void);

    void init(void) {
        const uart_config_t uart_config = {
            .baud_rate = 115200,
            .data_bits = UART_DATA_8_BITS,
            .parity = UART_PARITY_DISABLE,
            .stop_bits = UART_STOP_BITS_1,
            .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
            .source_clk = UART_SCLK_DEFAULT,
        };

        uart_driver_install(UART_NUM_2, RX_BUF_SIZE * 2, 0, 0, NULL, 0);
        uart_param_config(UART_NUM_2, &uart_config);
        uart_set_pin(UART_NUM_2, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);

        uart_queue = xQueueCreate(10, sizeof(char));

        gpio_config_t io_conf = {
            .pin_bit_mask = (1ULL << RXD_PIN),
            .mode = GPIO_MODE_INPUT,
            .intr_type = GPIO_INTR_ANYEDGE,
            .pull_up_en = GPIO_PULLUP_ENABLE,
        };

        gpio_config(&io_conf);
        gpio_install_isr_service(0);
        gpio_isr_handler_add(RXD_PIN, uart_rx_intr_handler, (void *)RXD_PIN);
    }

    int sendData(const char* logName, const char* data)
    {
        const int len = strlen(data);
        const int txBytes = uart_write_bytes(UART_NUM_2, data, len);
        ESP_LOGI(logName, "Wrote %d bytes", txBytes);
        return txBytes;
    }

    static void IRAM_ATTR uart_rx_intr_handler(void *arg)
    {
        ESP_LOGI("ISR", "Interrupt called");

        char message = 'I';

        if (xQueueSendFromISR(uart_queue, &message, NULL) != pdPASS) {
            ESP_LOGI("ISR", "Queue send failed");
        }
    }

    static void rx_polling(void)
    {
        static const char *RX_TASK_TAG = "RX_TASK";
        esp_log_level_set(RX_TASK_TAG, ESP_LOG_INFO);

        char received_msg;

        while (1) {
            if (xQueueReceive(uart_queue, &received_msg, portMAX_DELAY)) {
                ESP_LOGI(RX_TASK_TAG, "Received: %c", received_msg);
            } else {
                ESP_LOGI(RX_TASK_TAG, "Queue receive failed");
            }
        }
     }

    static void tx_polling(void)
    {
        static const char *TX_TASK_TAG = "TX_TASK";
        esp_log_level_set(TX_TASK_TAG, ESP_LOG_INFO);

        while (1) {
            sendData(TX_TASK_TAG, "Hello world\n");
            vTaskDelay(2000 / portTICK_PERIOD_MS);
        }
    }

    void app_main(void)
    {
        uart_mutex = xSemaphoreCreateMutex();
        init();

        while (1) {
            rx_polling();
            tx_polling();
        }
    }

2. With Using FreeRTOS

    #include <stdio.h>
    #include <string.h>
    #include "freertos/FreeRTOS.h"
    #include "freertos/task.h"
    #include "freertos/queue.h"
    #include "driver/uart.h"
    #include "esp_log.h"
    #include "esp_system.h"
    #include "driver/gpio.h"
    #include "soc/uart_reg.h"

    static const int RX_BUF_SIZE = 1024;
    #define TXD_PIN GPIO_NUM_17
    #define RXD_PIN GPIO_NUM_16

    SemaphoreHandle_t uart_mutex;
    QueueHandle_t uart_queue;

    static void IRAM_ATTR uart_rx_intr_handler(void *arg);

    static void rx_task(void *arg);
    static void tx_task(void *arg);

    void init(void) {
        const uart_config_t uart_config = {
            .baud_rate = 115200,
            .data_bits = UART_DATA_8_BITS,
            .parity = UART_PARITY_DISABLE,
            .stop_bits = UART_STOP_BITS_1,
            .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
            .source_clk = UART_SCLK_DEFAULT,
        };

        uart_driver_install(UART_NUM_2, RX_BUF_SIZE * 2, 0, 0, NULL, 0);
        uart_param_config(UART_NUM_2, &uart_config);
        uart_set_pin(UART_NUM_2, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);

        uart_queue = xQueueCreate(10, sizeof(char));

        gpio_config_t io_conf = {
            .pin_bit_mask = (1ULL << RXD_PIN),
            .mode = GPIO_MODE_INPUT,
            .intr_type = GPIO_INTR_ANYEDGE,
            .pull_up_en = GPIO_PULLUP_ENABLE,
        };

        gpio_config(&io_conf);
        gpio_install_isr_service(0);
        gpio_isr_handler_add(RXD_PIN, uart_rx_intr_handler, (void *)RXD_PIN);
    }

    int sendData(const char* logName, const char* data)
    {
        const int len = strlen(data);
        const int txBytes = uart_write_bytes(UART_NUM_2, data, len);
        ESP_LOGI(logName, "Wrote %d bytes", txBytes);
        return txBytes;
    }

    static void IRAM_ATTR uart_rx_intr_handler(void *arg)
    {
        ESP_LOGI("ISR", "Interrupt called");
        BaseType_t xHigherPriorityTaskWoken = pdFALSE;

        char message = 'I';

        if (xQueueSendFromISR(uart_queue, &message, &xHigherPriorityTaskWoken) != pdPASS) {
            ESP_LOGI("ISR", "Queue send failed");
        }

        if (xHigherPriorityTaskWoken == pdTRUE) {
            portYIELD_FROM_ISR();
        }
    }


    static void rx_task(void *arg)
    {
        static const char *RX_TASK_TAG = "RX_TASK";
        esp_log_level_set(RX_TASK_TAG, ESP_LOG_INFO);

        char received_msg;

        while (1) {
            if (xQueueReceive(uart_queue, &received_msg, portMAX_DELAY)) {
                ESP_LOGI(RX_TASK_TAG, "Received: %c", received_msg);
            } else {
                ESP_LOGI(RX_TASK_TAG, "Queue receive failed");
            }
        }
    }

    static void tx_task(void *arg)
    {
        static const char *TX_TASK_TAG = "TX_TASK";
        esp_log_level_set(TX_TASK_TAG, ESP_LOG_INFO);

        while (1) {
            sendData(TX_TASK_TAG, "Hello world\n");
            vTaskDelay(2000 / portTICK_PERIOD_MS);
        }
    }

    void app_main(void)
    {
        uart_mutex = xSemaphoreCreateMutex();
        init();
        xTaskCreate(rx_task, "uart_rx_task", 1024*2, NULL, configMAX_PRIORITIES, NULL);
        xTaskCreate(tx_task, "uart_tx_task", 1024*2, NULL, configMAX_PRIORITIES-1, NULL);
    }