static void wifi_event_handler(void *event_handler_arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
{
    if (event_id == WIFI_EVENT_STA_START)
    {
        ESP_LOGI(TAG, "Tentando conexao wifi....\n");
    }
    else if (event_id == WIFI_EVENT_STA_CONNECTED)
    {
        ESP_LOGI(TAG, "WiFi conenctado");
    }
    else if (event_id == WIFI_EVENT_STA_DISCONNECTED)
    {
        ESP_LOGI(TAG, "WiFi desconectado\n");
        if (retry_num < 5)
        {
            esp_wifi_connect();
            retry_num++;
            ESP_LOGI(TAG, "Tentando reconexao wifi...\n");
        }
    }
    else if (event_id == IP_EVENT_STA_GOT_IP)
    {
        ESP_LOGI(TAG, "IP recebido");
        
        //Inicia procedimento de conexão ao MQTT
        mqtt_app_start();
    }
}

esp_err_t wifi_app_start()
{
    //Inicializa o armazenamento flash (requerido pelo driver de wifi)
    ESP_ERROR_CHECK(nvs_flash_init());

    //Inicializa o sistema  Wi-fi e a pilha TCP/IP
    esp_netif_init();
    esp_event_loop_create_default();
    esp_netif_create_default_wifi_sta();
    wifi_init_config_t wifi_initiation = WIFI_INIT_CONFIG_DEFAULT();
    esp_wifi_init(&wifi_initiation);

    //Registra as funçoes de callback para os eventos de wifi e ip
    esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, wifi_event_handler, NULL);
    esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, wifi_event_handler, NULL);

    //Estrutura de incialização
    wifi_config_t wifi_configuration = {
        .sta = {
            .ssid = "",
            .password =  "",
        }
    };

    //Faz uma cópia das variaveis globais para dentro da estrutura de inicialização
    strcpy((char*)wifi_configuration.sta.ssid, ssid);
    strcpy((char*)wifi_configuration.sta.password, passwd);

    //Atribui os parametros de inicialização
    esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_configuration);

    //Inicializa a conexão
    esp_wifi_start();
    esp_wifi_set_mode(WIFI_MODE_STA);
    esp_wifi_connect();

    return ESP_OK;
}

static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
{
    esp_mqtt_event_handle_t event = event_data;
    switch ((esp_mqtt_event_id_t)event_id)
    {
    case MQTT_EVENT_CONNECTED:
        ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");

        char *topico = "testtopic/238191212838";
        char *mensagem = "Olá mundo";

        esp_mqtt_client_publish(handler_args, topico, mensagem, 0, 0 ,0 );
        esp_mqtt_client_subscribe_single(handler_args, topico, 0);

        break;
    case MQTT_EVENT_DISCONNECTED:
        ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
        break;
    case MQTT_EVENT_SUBSCRIBED:
        break;
    case MQTT_EVENT_UNSUBSCRIBED:
        ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_PUBLISHED:
        ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_DATA:
        ESP_LOGI(TAG, "Dados recebidos: ");
        printf("TOPICO=%.*s\r\n", event->topic_len, event->topic);
        printf("DADOS=%.*s\r\n", event->data_len, event->data);
        break;
    default:
        ESP_LOGI(TAG, "Other event id:%d", event->event_id);
        break;
    }
}

static void mqtt_app_start(void)
{

    esp_mqtt_client_config_t mqtt_cfg = {
        .broker.address.uri = "mqtt://broker.emqx.io:1883",
    };

    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt_cfg);

    esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler, client);
    esp_mqtt_client_start(client);
}

#include 
#include 
#include 
#include 
#include "esp_wifi.h"
#include "esp_system.h"
#include "nvs_flash.h"
#include "esp_event.h"
#include "esp_netif.h"

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "freertos/queue.h"

#include "lwip/sockets.h"
#include "lwip/dns.h"
#include "lwip/netdb.h"

#include "esp_log.h"
#include "mqtt_client.h"


char *ssid = "Nome canonico da rede wifi";
char *passwd = "senha";

static const char *TAG = "EXEMPLO_MQTT";
int retry_num = 0;

static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
{
    esp_mqtt_event_handle_t event = event_data;
    switch ((esp_mqtt_event_id_t)event_id)
    {
    case MQTT_EVENT_CONNECTED:
        ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");

        char *topico = "testtopic/238191212838";
        char *mensagem = "Olá mundo";

        esp_mqtt_client_publish(handler_args, topico, mensagem, 0, 0 ,0 );
        esp_mqtt_client_subscribe_single(handler_args, topico, 0);

        break;
    case MQTT_EVENT_DISCONNECTED:
        ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
        break;
    case MQTT_EVENT_SUBSCRIBED:
        break;
    case MQTT_EVENT_UNSUBSCRIBED:
        ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_PUBLISHED:
        ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_DATA:
        ESP_LOGI(TAG, "Dados recebidos: ");
        printf("TOPICO=%.*s\r\n", event->topic_len, event->topic);
        printf("DADOS=%.*s\r\n", event->data_len, event->data);
        break;
    default:
        ESP_LOGI(TAG, "Other event id:%d", event->event_id);
        break;
    }
}

static void mqtt_app_start(void)
{

    esp_mqtt_client_config_t mqtt_cfg = {
        .broker.address.uri = "mqtt://broker.emqx.io:1883",
    };

    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt_cfg);

    esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler, client);
    esp_mqtt_client_start(client);
}

static void wifi_event_handler(void *event_handler_arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
{
    if (event_id == WIFI_EVENT_STA_START)
    {
        ESP_LOGI(TAG, "Tentando conexao wifi....\n");
    }
    else if (event_id == WIFI_EVENT_STA_CONNECTED)
    {
        ESP_LOGI(TAG, "WiFi conenctado");
    }
    else if (event_id == WIFI_EVENT_STA_DISCONNECTED)
    {
        ESP_LOGI(TAG, "WiFi desconectado\n");
        if (retry_num < 5)
        {
            esp_wifi_connect();
            retry_num++;
            ESP_LOGI(TAG, "Tentando reconexao wifi...\n");
        }
    }
    else if (event_id == IP_EVENT_STA_GOT_IP)
    {
        ESP_LOGI(TAG, "IP recebido");

        //Inicia procedimento de conexão ao MQTT
        mqtt_app_start();
    }
}

esp_err_t wifi_app_start()
{
    //Inicializa o armazenamento flash (requerido pelo driver de wifi)
    ESP_ERROR_CHECK(nvs_flash_init());

    //Inicializa o sistema  Wi-fi e a pilha TCP/IP
    esp_netif_init();
    esp_event_loop_create_default();
    esp_netif_create_default_wifi_sta();
    wifi_init_config_t wifi_initiation = WIFI_INIT_CONFIG_DEFAULT();
    esp_wifi_init(&wifi_initiation);

    //Registra as funçoes de callback para os eventos de wifi e ip
    esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, wifi_event_handler, NULL);
    esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, wifi_event_handler, NULL);

    //Estrutura de incialização
    wifi_config_t wifi_configuration = {
        .sta = {
            .ssid = "",
            .password =  "",
        }
    };

    //Faz uma cópia das variaveis globais para dentro da estrutura de inicialização
    strcpy((char*)wifi_configuration.sta.ssid, ssid);
    strcpy((char*)wifi_configuration.sta.password, passwd);

    //Atribui os parametros de inicialização
    esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_configuration);

    //Inicializa a conexão
    esp_wifi_start();
    esp_wifi_set_mode(WIFI_MODE_STA);
    esp_wifi_connect();

    return ESP_OK;
}

void app_main(void)
{
    esp_log_level_set("*", ESP_LOG_NONE);

    ESP_ERROR_CHECK(wifi_app_start());
}

idf.py create-component uart_simple_reader

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

#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)

#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;
}

#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);
}

pyserial-miniterm /dev/ttyUSB0 115200