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 ?
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:
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:
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:
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:
Utilizando o componente:
#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:
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:
