UKTech - Blog UKTech #Arduino

ESP-IDF: Utilizando MQTT em seus projetos

Mon, 29 Jan 2024 16:35:11 -0300

O MQTT (Message Queuing Telemetry Transport) emerge como uma poderosa solução de comunicação para o mundo interconectado de dispositivos na era da Internet das Coisas (IoT). Este protocolo leve e eficiente foi projetado para facilitar a troca de mensagens entre dispositivos distribuídos em redes com larguras de banda variadas. Com sua arquitetura baseada em publicação/assinatura, o MQTT proporciona uma comunicação assíncrona, permitindo que dispositivos troquem informações de forma eficaz e sem a necessidade de conexões persistentes.

Uma das principais vantagens do uso do MQTT é a sua baixa sobrecarga de rede, o que o torna ideal para dispositivos com recursos limitados, como micro controladores. Além disso, o MQTT é altamente escalável e flexível, permitindo a comunicação entre milhares de dispositivos simultaneamente.

Para utilizar o MQTT em seus projetos baseados no ESP-IDF, é necessário primeiro configurar um broker MQTT, que será responsável por receber e encaminhar as mensagens entre os dispositivos. Em seguida, você pode utilizar a biblioteca MQTT do ESP-IDF para se conectar ao broker, publicar e assinar tópicos e trocar informações com outros dispositivos.

Ao utilizar o MQTT em seus projetos, você poderá criar aplicações IoT robustas e eficientes, permitindo que seus dispositivos se comuniquem de forma confiável e escalável.

Broker

Para fins didaticos neste tutorial utilizaremos o broker de testes gratuito disponível no endereço:

[broker.emqx.io] na porta 1883.

Objetivo

A aplicação ira conectar ao WiFi obeter o endereço IP via DHCP, em seguida a mesma ira se increver no topico MQTT e publicar uma mensagem, além de imprimir no monitor serial as mensagens recebidas no mesmo topico.

Código

A execução inicial do código é conduzida pela função wifi_app_start(). Essa função tem a responsabilidade de iniciar o Wi-Fi, estabelecer a conexão com a internet e, adicionalmente, através de uma função de callback configurada para ser acionada após o ESP receber um endereço IP válido, estabelecer a conexão com o MQTT.


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

A função mqtt_app_start() é invocada para configurar o endereço do broker MQTT e definir a função de callback responsável por gerenciar os eventos associados. Após a conexão bem-sucedida com o broker, o ESP se inscreve em um tópico específico e envia uma mensagem correspondente. Adicionalmente, o conteúdo desse tópico é impresso no monitor serial.


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

Resultado

Usando o cliente MQTTX para interagir com o broker:

Mensagem enviada pelo computador:

Mensagem recebida no ESP:

Bônus: Código completo:


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

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.

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

Mon, 11 Dec 2023 11:10:40 -0300

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:

https://github.com/uktechbr/esp-devkit-samples/tree/main/uart-simple

Sobre o autor:

ESP-IDF: Publicando componentes para o Espressif IDF Component Registry

Wed, 01 Nov 2023 17:32:52 -0300

O tutorial de hoje tem como objetivo ensinar a publicar componentes para o novíssimo Espressif IDF Component Registry, esse que tem por objetivo se tornar o padrão para distribuição de componentes dentro da plataforma IDF.

Credenciais:

O primeiro passo para publicação de um componente é a criação de uma conta no ESP Registry, com a conta criada basta gerar um Token de acesso com permissão de criação de componentes no mesmo.

Com as credencias agora é necessário criar o arquivo idf_component_manager.yml dentro da pasta de instalação do IDF (no Linux ~/.espressif/idf_component_manager.yml). Com a seguinte estrutura

profiles: default: api_token: token default_namespace: meu-namespace

Configurar o componente:

As informações da publicação do componente são referentes a um arquivo chamado idf_component.yml que deve residir na raiz do projeto. Este contém a informação da versão, descrição, url do repositório remoto do projeto (ex: Github), dependências e a licença do componente.

Exemplo:

version: "1.0.1" description: Emonlib ESP-IDF url: https://github.com/uktechbr/emonlib-esp-idf dependencies: idf: ">=4.0" license: "AGPL-3.0-only"

Publicar componente

Com todas as etapas anteriores concluídas basta rodar o comando:

compote component upload --namespace [namespace] --name [nome do componente]

Curiosidade:

Primeiro componente publicado pela UKTech:

https://components.espressif.com/components/uktech/emonlib-esp-idf

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 microcontroladores 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.

ESP-IDF: Criando e utilizando componentes

Wed, 25 Oct 2023 15:47:07 -0300

Componentes são a base dos projetos feitos no ESP-IDF, eles são uma ótima ferramenta para modularizar, abstrair e reutilizar código.

Onde ficam os componentes de um projeto ?

Os componentes de um projeto por padrão se encontram na pasta components dentro da raiz do mesmo.

Criando um componente:

Basta utilizar o atalho CTRL + SHIFT + P e selecionar o comando ESP-IDF: Create new ESP-IDF Component, em seguida declarar o nome deste novo componente.

Estrutura de um Componente:

Por padrão um componente consiste em um pasta include para arquivos de cabeçalho, arquivos de código fonte e um arquivo CMakeLists.txt.

A função do arquivo CMakeLists.txt é justamente declarar essa estrutura, mas não só, ele também é responsável por declarar as dependências externas do componente, como por exemplo a API de log’s do próprio IDF.

Usando um componente:

Vamos tomar como exemplo um componente hello que tem como função imprimir um log na saída serial do microcontrolador, o nome dessa função também sera hello, basta incluir o arquivo de cabeçalho na função main.

E declarar a dependência no arquivo CMakeLists.txt da pasta main.

Resultado rodando no micro controlador

Código fonte deste tutorial disponível na pasta hello-component em:

https://github.com/uktechbr/esp-devkit-samples/

Utilizando o ESP32-C3 em conjunto com o sensor BME680e a Arduíno IDE

Mon, 02 Oct 2023 14:19:42 -0300

No tutorial de hoje vamos mostrar como usar o ESP32-C3 em conjunto com o sensor BME680 para medir temperatura, umidade, pressão e VOC (Composto orgânico volátil), também vamos mostrar essas informações em um display OLED.

Materiais utilizados:

ESP32-C3 (UKT-ESP32C3-DEV-MINI-USB)
BME680
Display LCD (128x32)
Jumpers ou fios

Esquemático:

Bibliotecas Arduíno utilizadas:

BME680 by Adafruit
SSD1306 by Adafruit

E dependências das respectivas bibliotecas acima.

Seleção da placa na Arduíno IDE:

Selecionamos o módulo ESP32C3.

Código:

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






            

          
    


    
        


  

      
      
      

      
        
      
      
      

      
  
          

              


  














  

  

  

  

  
  
  

  

  


  
  

  
  

  

  

  

  
  
  

	
  
  Resultado:




          
    


    
        


  

      
      
      

      
        
      
      
      

      
  
          

              
    



    




























    



  
        
        
          
          
          

            
            
            
          
        
          
          
      
    
  




          
    


    
        


  

      
      
      

      
        
      
      
      

      
  
          

            

    

    

    

    

    

    

    
      
    
    
    
      

    



          
    


    
        


  

      
      
      

      
        
      
      
      

      
  
          

              


  
















 

 

  

  














    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 microcontroladores 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.



Utilizando o ESP32-C3 em conjunto com o sensor de luz ultravioleta ML8511 e a Arduíno IDE
Tue, 26 Sep 2023 11:45:54 -0300

    
    
      


  

      
      
      

      
        
      
      
      

      
  
          

              
                  
                      
                      
                              
              

              







































    
























  
  


  

      
      
      

      
        
      
      
      

      
  
          

              

















    
        


  

      
      
      

      
        
      
      
      

      
  
          

              










    

    
    


    
    


    

    

    

    
    
      
    
    
    
        


  

      
      
      

      
        
      
      
      

      
  
          

              
    



    




























    



  
        
        
          
          
          

            
            
            
          
        
          
          
      
    
  




          
    


    
    



          
    


    




          
    


  






















































           
    


    
      


  

      
      
      

      
        
      
      
      

      
  
          

              
                  
                      
                      
                              
              

              






























































  
  


  

      
      
      

      
        
      
      
      

      
  
          

              

















    
        


  

      
      
      

      
        
      
      
      

      
  
          

              










    

    
    


    
    


    

    

    

    
    
      
    
    
    
        


  

      
      
      

      
        
      
      
      

      
  
          

              


  





  





  








 

 

  

  














    No tutorial de hoje, vamos mostrar como usar o ESP32-C3 em conjunto com o sensor ML8511 para luminosidade no espectro ultravioleta, também vamos mostrar essas informações em um display OLED.

Materiais utilizados: 
ESP32-C3 (UKT-ESP32C3-DEV-MINI-USB)
ML8511 
Display LCD (128x32)
Jumpers ou fios
Esquemático:




          
    


    
        


  

      
      
      

      
        
      
      
      

      
  
          

              
    



    




























    



  
        
        
          
          
          

            
            
            
          
        
          
          
      
    
  




          
    


    
        


  

      
      
      

      
        
      
      
      

      
  
          

              


  
















 

 

  

  














    Bibliotecas Arduíno utilizadas: 
ML8511 by RobTillaart 
SSD1306 by Adafruit

E dependências das respectivas bibliotecas acima.





          
    


    
        


  

      
      
      

      
        
      
      
      

      
  
          

              


  














  

  

  

  

  
  
  

  

  


  
  

  
  

  

  

  

  
  
  

	
  
  Seleção da placa na Arduíno IDE:





          
    


    
        


  

      
      
      

      
        
      
      
      

      
  
          

              
    



    




























    



  
        
        
          
          
          

            
            
            
          
        
          
          
      
    
  




          
    


    
        


  

      
      
      

      
        
      
      
      

      
  
          

              


  
















 

 

  

  














    Selecionamos o módulo ESP32C3.





          
    


    
        


  

      
      
      

      
        
      
      
      

      
  
          

              


  














  

  

  

  

  
  
  

  

  


  
  

  
  

  

  

  

  
  
  

	
  
  Código:




          
    


    
        


  

      
      
      

      
        
      
      
      

      
  
          
            

              

	
	 	
			
				#include "Adafruit_SSD1306.h"
#include 

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

#define ANALOGPIN 0
ML8511 ml(ANALOGPIN);
// Inidicaliza o sensor e o display
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"));
    while (1);
  }
  //Parametros da tensão de operação do sensor e do adc
  ml.setVoltsPerStep(3.3, 4096);   

  // 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);


  Serial.print("UV: ");
  Serial.println( ml.getUV(), 4);

  // Formata o dados para exibir no display
  char uvString[25];
  sprintf(uvString, "Ultravioleta: %.5f", ml.getUV());

  // Limpa o buffer do display
  display.clearDisplay();
  // Posição inicial do cursor no display
  display.setCursor(0, 0);
  //Envia novos dados ao buffer do display
  display.println(uvString);
  // Atualiza o display para mostrar os dados no buffer
  display.display();
}
Resultado:

Agora, o ESP32-C3 deve ler os valores do sensor ML8511 e exibi-los no display OLED. Você verá a luminosidade no espectro ultravioleta em tempo real.

Este é um exemplo básico para começar a trabalhar com o sensor ML8511 e um display OLED em um ESP32-C3. Você pode personalizar o código e adicionar recursos adicionais, como a conversão para unidades UV específicas ou a inclusão de informações adicionais no display, conforme necessário para o seu projeto.

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.
 


Utilizando o ESP32-C3 em conjunto com o sensor de temperatura e umidade DHT11/DHT22 e a Arduíno IDE
Mon, 18 Sep 2023 16:35:01 -0300
No tutorial de hoje vamos mostrar como usar o ESP32-C3 em conjunto com o sensor DHT11/DHT22 para medir temperatura e umidade, também vamos mostrar essas informações em um display OLED. 
Materiais utilizados: 
ESP32-C3 (UKT-ESP32C3-DEV-MINI-USB)
DHT11 
Resistor 10KΩ 
Display LCD (128x32) 
Jumpers ou fios
Esquemático:


Bibliotecas Arduíno utilizadas: 
DHT sensor library by Adafruit 
SSD1306 by Adafruit 
E dependências das respectivas bibliotecas acima.

Seleção da placa na Arduíno IDE:


Selecionamos o modulo ESP32C3 .

Código:


#include "DHT.h"
#include "Adafruit_SSD1306.h"

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

#define DHTPIN 1  //Pino onde esta conectado o sensor DHT

// Define o modelo de sensor DHT que estamos usando
#define DHTTYPE DHT11  // DHT 11
//#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

// Inidicaliza o sensor e o display
DHT dht(DHTPIN, DHTTYPE);
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

void setup() {
  //Velocidade do monitor serial
  Serial.begin(115200);
  Serial.println(F("DHTxx test!"));

  dht.begin();
  // 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 (;;)
      ;
  }

  // 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);

  float h = dht.readHumidity();
  float t = dht.readTemperature();
  float f = dht.readTemperature(true);

  // Verifica se as leituras são validas
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Falha ao ler do sensor"));
    return;
  }

  // Calcula o índice de calor em Fahrenheit
  float hif = dht.computeHeatIndex(f, h);
  // Calcula o índice de calor em Celsius
  float hic = dht.computeHeatIndex(t, h, false);

  Serial.print(F("Umidade: "));
  Serial.print(h);
  Serial.print(F("%  Temperatura: "));
  Serial.print(t);
  Serial.print(F("°C "));
  Serial.print(f);
  Serial.print(F("°F  Indice de calor: "));
  Serial.print(hic);
  Serial.print(F("°C "));
  Serial.print(hif);
  Serial.println(F("°F"));

  // Formata o dados para exibir no display
  char tempString[25];
  sprintf(tempString, "Temperatura: %.2f%cC", t, (char)247);
  char humString[20];
  sprintf(humString, "Umidade: %.2f%%", h);

  // Limpa o buffer do display
  display.clearDisplay();
  // Posição inicial do cursor no display
  display.setCursor(0, 0);

  //Envia novos dados ao buffer do display
  display.println(tempString);
  display.println(humString);

  // Atualiza o display para mostrar os dados no buffer
  display.display();
}
Resultado: