ESP-IDF: UART, lendo e escrevendo dados utilizando o conversor serial FT232RL.

11/12/2023 11:10 - Comentário(s) - Por Carlos Korovsky

O tutorial de hoje tem como objetivo mostrar como se da a utilização do protocolo UART através da comunicação do ESP32-C3 e o conversor serial FT232RL.

O que é UART ?

Um Receptor/Transmissor Assíncrono Universal (UART) é um recurso de comunicação amplamente usado e adotado que utiliza como o nome já diz comunicação assíncrona serial, como por exemplo RS232, RS422, e RS485. UART é um método barato de comunicação que pode ser feito de maneira full-duplex ou half-duplex entre diferentes dispositivos. 

Começando:

Vamos criar um componente que será responsável pelo UART, dentro de um projeto basta rodar o comando:


idf.py create-component uart_simple_reader

Esse comando criara uma pasta com o nome uart_simple_reader, devemos move-la para dentro de uma pasta chamada components na raiz do projeto, se ela não existir basta criá-la.

Configurando o componente:

Dentro do CMakeLists.txt desse componente iremos adicionar o parâmetro “REQUIRES driver” para que o mesmo tenha acesso aos recursos responsáveis pelo UART do ESP-IDF, ficando assim:


idf_component_register(SRCS "uart_simple_reader.c"
                    REQUIRES driver
                    INCLUDE_DIRS "include")

Criando o arquivo de cabeçalho:

Iremos utilizar duas funções para executar as tarefas, uma irá ficar responsável por inicializar o componente e a outra será uma task responsável pela leitura e escrita de fato.

Além disso iremos definir duas constantes que serão utilizadas mais a frente, ficando assim:


#include "esp_log.h"
#include "driver/uart.h"
#include "driver/gpio.h"

#define BUF_SIZE (1024)
#define UART_NUM UART_NUM_1

void readUartTask(void *arg);

esp_err_t uartInit(uart_port_t uart_num,
									 uart_config_t *uart_config,
									 int *intr_alloc_flags,
									 gpio_num_t tx_pin, 
									 gpio_num_t rx_pin)

Implementação:

Como citado anteriormente a função uartInit ficara responsável por receber os parâmetros de inicialização, esses sendo qual o UART interno utilizado, parâmetros de funcionamento e os pinos a qual serão atribuídos TX e RX.

Já a função readUartTask ficara responsável por ler e escrever, recebendo apenas como parâmetro de task a unidade UART que estaremos utilizando.


#include 
#include "uart_simple_reader.h"

void readUartTask(void *arg)
{
    uint8_t *data = (uint8_t *)malloc(BUF_SIZE);

    while (1)
    {
        int len = uart_read_bytes((uart_port_t)arg, data, (BUF_SIZE - 1), pdMS_TO_TICKS(20));
        if (len)
        {
            data[len] = '\0';
            uart_write_bytes((uart_port_t)arg, data, len);
            uart_write_bytes((uart_port_t)arg, "\n", 1);
            ESP_LOGI("TAG", "Recv str: %s", (char *)data);
        }
    }
}

esp_err_t uartInit(uart_port_t uart_num, uart_config_t *uart_config, int *intr_alloc_flags, gpio_num_t tx_pin, gpio_num_t rx_pin)
{   
     uart_config = malloc(sizeof(uart_config_t));
    if (uart_config == NULL) {
        return ESP_FAIL;
    }

    *uart_config = (uart_config_t){
        .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,
    };

#if CONFIG_UART_ISR_IN_IRAM
    intr_alloc_flags = ESP_INTR_FLAG_IRAM;
#endif

    ESP_ERROR_CHECK(uart_driver_install(uart_num, BUF_SIZE * 2, 0, 0, NULL, *intr_alloc_flags));
    ESP_ERROR_CHECK(uart_param_config(uart_num, uart_config));
    ESP_ERROR_CHECK(uart_set_pin(uart_num, tx_pin, rx_pin, 0, 0));

    return ESP_OK;
}

Utilizando o componente:

Primeiramente é necessário declara a utilização do mesmo, dentro da pasta main adicionamos “REQUIRES uart_simple_reader” ao CMakeLists.txt.

Depois importamos o componente dentro do arquivo main, criamos os parâmetros de inicialização e chamamos a função uartInit. Então criamos a task do FreeRTOS e passamos por parâmetro qual UART estamos utilizando.

#include 
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "sdkconfig.h"
#include "esp_log.h"
#include "uart_simple_reader.h"

void app_main(void)
{
    uart_config_t uart_config;
    int intr_alloc_flags = 0;
    uart_port_t uart_port = UART_NUM;
    gpio_num_t tx = 3;
    gpio_num_t rx = 2;
    ESP_ERROR_CHECK(uartInit(uart_port, 
														&uart_config, 
														&intr_alloc_flags, 
														tx, rx));

    xTaskCreate(readUartTask, "uart_task", 2048, (void *)uart_port, 10, NULL);
}

Acessando o serial:

Com o código já rodando no micro controlador, estabelecemos uma conexão serial, no caso iremos utilizar o pyseria-miniter, outra alternativa é utilizar o PuTTY.



pyserial-miniterm /dev/ttyUSB0 115200

Onde enviaremos a string “Olá UART”:

Que será mostrada na saída serial padrão do micro controlador:

Exemplo disponível em:

Sobre o autor:

Matheus desempenha o papel de desenvolvedor de sistemas de tecnologia da informação dentro da equipe da UKTech. Possui  experiência no domínio de micro controladores e desenvolvimento de software, e está na reta final de sua graduação em Engenharia de Computação. Em seus momentos de lazer, ele se dedica a interesses como jogos de computador e a apreciação de animes.
Categorias -
Maker
Partilhar -
Etiquetas -