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

#include "Adafruit_SSD1306.h"
#include "Adafruit_BME680.h"

// Define o tamanho do display OLED
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32

#define SEALEVELPRESSURE_HPA (1013.25)

// Inidicaliza o sensor e o display
Adafruit_BME680 bme;
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

void setup() {
  //Velocidade do monitor serial
  Serial.begin(115200);
  // Pinos do barramento I2C
  Wire.begin(3, 2);

   // Verifica estado de inicialização do display, acusa falha em caso de erro
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0, false, true)) {
    Serial.println(F("Falha ao inicializar o SSD1306"));
    for (;;)
      ;
  }

  if (!bme.begin()) {
    Serial.println(F("Could not find a valid BME680 sensor, check wiring!"));
    while (1);
  }

  // Ajusta os filtros da biblioteca do sensor
  bme.setTemperatureOversampling(BME680_OS_8X);
  bme.setHumidityOversampling(BME680_OS_2X);
  bme.setPressureOversampling(BME680_OS_4X);
  bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
  bme.setGasHeater(320, 150); // 320*C for 150 ms

  // Limpe o buffer do display
  display.clearDisplay();

  // Configuração do texto
  display.setTextSize(1.5);             // Tamanho do texto (1 = 6x8 pixels)
  display.setTextColor(SSD1306_WHITE);  // Cor do texto
}

void loop() {
  // Tempo entre cada medida
  delay(2000);


  // BME680 inicia o processo de amostragem
  unsigned long endTime = bme.beginReading();
  if (endTime == 0) {
    Serial.println(F("Falha ao obter medicao"));
    return;
  }
  Serial.print(F("Medicao comecou em: "));
  Serial.print(millis());
  Serial.print(F(" e terminou em "));
  Serial.println(endTime);

  if (!bme.endReading()) {
    Serial.println(F("Falha com completar medicao"));
    return;
  }

  Serial.