WJ Componentes

Estação Meteorológica com ESP32 e Nextion

,

Olá, como estão? Antes de tudo no post passado falamos sobre o display Nextion e fizemos um “Stream Deck” via bluetooth, passando instruções para o computador, caso queira conferir clique aqui. Entretanto pense no seguinte cenário, você está no seu quarto e gostaria de saber a temperatura da sala com um display Nextion, como podemos fazer? Podemos passar um cabo da sala até o quarto, entretanto não seria a melhor opção, pois além de gastar com o cabo irá dar trabalho. Mas e se no caso usarmos dois ESP32 um transmitindo informação para o outro e mostrar no Nextion assim fazendo uma Estação Meteorológica.

ESP32
Tela Nextion - WJ Componentes

Componentes Utilizados no Projeto Estação Meteorológica

Funcionamento do Projeto Estação Meteorológica

A princípio iremos utilizar 2 ESP32 LoRa sendo um deles para enviar as informações referentes ao DHT11 e LDR para o outro ESP32 via ethernet. Então o segundo ESP32 irá receber essas informações e transmitir para o display Nextion.

Obs.: Não iremos entrar a fundo referente a como instalar, configurar e explicar o funcionamento das bibliotecas. Pois já falamos a fundo eles nos posts passados aqui no blog, caso queira conferir clique no tópico que gostaria:

Montagem do Circuito do Projeto Estação Meteorológica

Logo após compra dos componentes na WJ Componentes, vamos à montagem! Então agora iremos montar o circuito, onde iremos dividir a montagem e duas partes. Contudo a primeira sendo o ESP32 LoRa enviando informações para o segundo ESP32 que receberá as informações.

Pinout DHT - WJ Componentes

Primeiramente iremos conectar o DHT11 e LDR em 3,3V, como o LDR é um resistor de luminosidade conectamos no outro pino um resistor de 10K ao GND. Do mesmo modo conectamos um jumper a esse pino e conectamos no pino 32 do ESP32 LoRa. Em seguida no DHT11 conectamos o pino logico dele no pino 35 do ESP e conectamos o GND.

Logo após temos a segunda etapa onde iremos alimentar o Nextion com 5V e conectaremos o RX, TX e GND no TX2, RX2 e GND do ESP32. Sendo as cores do cabo vermelho (alimentação), azul (TX), amarelo (Rx) e preto (GND).

Contudo segue abaixo uma imagem que demonstrando a montagem do circuito.

Montagem do Circuito Eletrônico na Protoboard - Estação Meteorológica

Código-fonte do Projeto Estação Meteorológica

Contudo o código foi dividido em dois arquivos. Sendo o primeiro sendo o Sender que enviara as informações e o outro, sendo o Reciver que recebera as informações.

Código-fonte Sender:

//Biblioteca -----------------------------------------------------------------------------------------
#include <WiFi.h>                                       // Responsável pelo WiFi
#include <heltec.h>                                     // Responsável pelo display e LoRa
#include <DHT.h>                                        // Responsável pelo DHT
#include <DHT_U.h>                                      // Responsável pelo DHT

//DHT11 - Variáveis Globais e Define -----------------------------------------------------------------
#define DHTPIN 32                                       // Define o pino
#define DHTTYPE DHT11                                   // Define o sensor que ira ser usado
DHT dht(DHTPIN,DHTTYPE);                                // Criando um objeto DHT
float temp = 0;                                         // Temperatura
float umid = 0;                                         // Umidade

//LDR - Variáveis Globais e Define -------------------------------------------------------------------
#define LDR 36                                          // Define pino do LDR
int luz = 0;                                            // Umidade

//WiFi -----------------------------------------------------------------------------------------------
const char* SSID     = "<NOME-DA-REDE>";                // Nome da rede WiFi
const char* password = "<SENHA-DA-REDE>";               // Senha do WiFi
WiFiServer server(80);                                  // Declaração do servidor junto a sua porta

//Setup ----------------------------------------------------------------------------------------------
void setup() {
    dht.begin();                                          // Inicializa o DHT11
    pinMode(LDR, INPUT);                                  // Configura o pino do LDR como INPUT
    // Abaixo inicializa Display, LoRa, Serial, PABOOST, BAND
    Heltec.begin(true, false, true, false);
    Heltec.display->init();                               // Inicializa o display
    Heltec.display->flipScreenVertically();               // Vira na vertical
    WiFi.begin(SSID, password);                           // Tenta se logar no WiFi
    while (WiFi.status() != WL_CONNECTED) {               // Verifica se a conexão foi realizada
        delay(500);                                         // Espera 0,5s
    }
    Serial.println(WiFi.localIP());                       // Mostra o IP do ESP32
    server.begin();                                       // Inicia o servidor
}

//Loop -----------------------------------------------------------------------------------------------
void loop() {
    temp = dht.readTemperature();                             // Leitura da Temperatura
    umid = dht.readHumidity();                                // Leitura da Humidade
    luz = analogRead(LDR);                                    // Leitura do LDR
    Heltec.display->clear();                                  // Limpa o display 
    Heltec.display->setTextAlignment(TEXT_ALIGN_LEFT);        // Alinha o texto na esquerda
    Heltec.display->setFont(ArialMT_Plain_10);                // Escolhe a fonte
    Heltec.display->drawString(0, 11, "Temperatura: " + String(temp)); // Imprime temperatura
    Heltec.display->drawString(0, 22, "Umidade: " + String(umid)); // Imprime umidade
    Heltec.display->drawString(0, 33, "Luminozidade: " + String(luz)); // Imprime luminosidade
    WiFiClient cliente = server.available();                  // Verifica alguma alteração no servidor
    if(cliente){                                              // Verifica se o cliente se conectou
        Serial.println("Entrou no cliente");                  // Imprime que o cliente se conectou
        String currentLine="";                                // Declara variável vazia
        while(cliente.connected()){                           // Faz loop enquanto estiver conectado
            if(cliente.available()){                          // Verifica se tem algum dados
                char c = cliente.read();                      // Atribui a C as informações do cliente
                if(c == '\n'){                                // Verifica se C é igual a '\n'
                    if(currentLine.length() == 0){            // Verifica o tamanho de currntLine = 0
                        cliente.println("HTTP/1.1 200 OK");   // Imprime Status de OK
                        cliente.println("Content-type:application/json"); // Informa JSON
                        cliente.println("Connection: close"); // Encerra conexão
            
                        // Imprime JSON
                        cliente.print("{\"Status\":{\"Temperatura\":");
                        cliente.print(temp);                  // Imprime temperatura para o client
                        cliente.print(",\"Umidade\":");
                        cliente.print(umid);                  // Imprime umidade para o client
                        cliente.print(",\"Luminosidade\":");
                        cliente.print(luz);                   // Imprime luz para o client
                        cliente.print("}}");
                        break;
                    } else{
                        currentLine = "";                     // Limpa a variável
                    }
                } else if(c != '\r'){                         // Verifica se C é diferente de '\r'
                currentLine += c;                             // Incrementa C em currentLine 
                }
            }
        }
    cliente.stop();                                            // Desconecta do Servidor
    Serial.println("Cliente Desconectou.\n");                  // Imprime que cliente se desconectou
    }
    delay(100);                                                // Espera 0,1s
}

Vamos dar uma olhada mais de perto no código:

Incluindo Bibliotecas

Primeiramente temos que incluir as bibliotecas que iremos utilizar em nosso projeto.

//Biblioteca -----------------------------------------------------------------------------------------
#include <WiFi.h>                                       // Responsável pelo WiFi
#include <heltec.h>                                     // Responsável pelo display e LoRa
#include <DHT.h>                                        // Responsável pelo DHT
#include <DHT_U.h>                                      // Responsável pelo DHT

Configuramos DHT

Então realizamos a configuração do DHT, onde definimos o pino e o tipo do DHT.

//DHT11 - Variáveis Globais e Define -----------------------------------------------------------------
#define DHTPIN 32                                       // Define o pino
#define DHTTYPE DHT11                                   // Define o sensor que ira ser usado
DHT dht(DHTPIN,DHTTYPE);                                // Criando um objeto dht
float temp = 0;                                         // Temperatura
float umid = 0;                                         // Umidade

Configuramos LDR

Em seguida definimos o pino do LDR que utilizamos.

//Variáveis Globais ----------------------------------------------------------------------------------
int i = 0;                                                         // Variável de controle

Configuramos WiFi

Então declaramos duas constantes para o WiFi sendo elas SSID (nome da rede) e password (senha da rede). Além disso declaramos um objeto chamado server e passamos a porta 80 para ele.

//WiFi -----------------------------------------------------------------------------------------------
const char* SSID     = "<NOME-DA-REDE>";                // Nome da rede WiFi
const char* password = "<SENHA-DA-REDE>";               // Senha do WiFi
WiFiServer server(80);                                  // Declaração do servidor junto a sua porta

Funções Setup

Logo após na função setup, iniciamos o WiFi, server, DHT, Serial, Display do LoRa e configuramos o pino do LDR.

//Setup ----------------------------------------------------------------------------------------------
void setup() {
    dht.begin();                                          // Inicializa o DHT11
    pinMode(LDR, INPUT);                                  // Configura o pino do LDR como INPUT
    // Abaixo inicializa Display, LoRa, Serial, PABOOST, BAND
    Heltec.begin(true, false, true, false);
    Heltec.display->init();                               // Inicializa o display
    Heltec.display->flipScreenVertically();               // Vira na vertical
    WiFi.begin(SSID, password);                           // Tenta se logar no WiFi
    while (WiFi.status() != WL_CONNECTED) {               // Verifica se a conexão foi realizada
        delay(500);                                         // Espera 0,5s
    }
    Serial.println(WiFi.localIP());                       // Mostra o IP do ESP32
    server.begin();                                       // Inicia o servidor
}

Funções Loop

Então agora no loop, atribuímos o que for lido do DHT e LDR e imprimimos no display OLED do LoRa.

//Loop -----------------------------------------------------------------------------------------------
void loop() {
    temp = dht.readTemperature();                             // Leitura da Temperatura
    umid = dht.readHumidity();                                // Leitura da Humidade
    luz = analogRead(LDR);                                    // Leitura do LDR
    Heltec.display->clear();                                  // Limpa o display 
    Heltec.display->setTextAlignment(TEXT_ALIGN_LEFT);        // Alinha o texto na esquerda
    Heltec.display->setFont(ArialMT_Plain_10);                // Escolhe a fonte
    Heltec.display->drawString(0, 11, "Temperatura: " + String(temp)); // Imprime temperatura
    Heltec.display->drawString(0, 22, "Umidade: " + String(umid)); // Imprime umidade
    Heltec.display->drawString(0, 33, "Luminozidade: " + String(luz)); // Imprime luminosidade

Em seguida verificamos se o cliente se conectou e imprimimos um JSON com as informações dos sensores.

    WiFiClient cliente = server.available();                  // Verifica alguma alteração no servidor
    if(cliente){                                              // Verifica se o cliente se conectou
        Serial.println("Entrou no cliente");                  // Imprime que o cliente se conectou
        String currentLine="";                                // Declara variável vazia
        while(cliente.connected()){                           // Faz loop enquanto estiver conectado
            if(cliente.available()){                          // Verifica se tem algum dados
                char c = cliente.read();                      // Atribui a C as informações do cliente
                if(c == '\n'){                                // Verifica se C é igual a '\n'
                    if(currentLine.length() == 0){            // Verifica o tamanho de currntLine = 0
                        cliente.println("HTTP/1.1 200 OK");   // Imprime Status de OK
                        cliente.println("Content-type:application/json"); // Informa JSON
                        cliente.println("Connection: close"); // Encerra conexão
            
                        // Imprime JSON
                        cliente.print("{\"Status\":{\"Temperatura\":");
                        cliente.print(temp);                  // Imprime temperatura para o client
                        cliente.print(",\"Umidade\":");
                        cliente.print(umid);                  // Imprime umidade para o client
                        cliente.print(",\"Luminosidade\":");
                        cliente.print(luz);                   // Imprime luz para o client
                        cliente.print("}}");
                        break;
                    } else{
                        currentLine = "";                     // Limpa a variável
                    }
                } else if(c != '\r'){                         // Verifica se C é diferente de '\r'
                currentLine += c;                             // Incrementa C em currentLine 
                }
            }
        }

Então encerramos a conexão com o cliente e esperamos 0,1 segundos.

    cliente.stop();                                            // Desconecta do Servidor
    Serial.println("Cliente Desconectou.\n");                  // Imprime que cliente se desconectou
    }
    delay(100);                                                // Espera 0,1s
}

E assim finalizamos o Sender e vamos agora para o Reciver

Código-fonte Reciver:

//Biblioteca -----------------------------------------------------------------------------------------
#include <WiFi.h>                                       // Responsavel pelo Wifi
#include <HTTPClient.h>                                 // Responsavel pelas requisições HTTP
#include <ArduinoJson.h>                                // Responsavel pela leitura JSON
#include <EasyNextionLibrary.h>                         // Facilitar o uso do Nextion
#include <time.h>                                       // Facilitar o uso de tempo
#include <NTPClient.h>                                  // Facilitar o uso dos Servidores NTP

//WiFi -----------------------------------------------------------------------------------------------
const char* SSID     = "<NOME-DA-REDE>";                // Nome da rede Wifi
const char* password = "<SENHA-DA-REDE>";               // Senha do Wifi

//Data e Hora ----------------------------------------------------------------------------------------
const cha r* ntpServer = "a.st1.ntp.br";                // Servidor NTP 
const int   fusoHorario = -3*3600;                      // Fuso horario que sera aplicado

//Declarando Objetos ---------------------------------------------------------------------------------
HTTPClient http;                                        // Objeto para requisições 
StaticJsonDocument<128> doc;                            // Objeto para leitura JSON
EasyNex Nextion(Serial2);                               // Objeto para Nextion
WiFiUDP udp;                                            // Objeto para Update do time
NTPClient ntp(udp, ntpServer, fusoHorario, 60000);      // Objeto "NTP"

//Variavel Global ------------------------------------------------------------------------------------
char json[200] = {0};                                   // Armazena JSON
float Status_Temperatura;                               // Armazena Temperatura JSON
float Status_Umidade;                                   // Armazena Umidade JSON
int Status_Luminosidade;                                // Armazena Luminosidade JSON
uint16_t temp;                                          // Armazena Temperatura Nextion 
uint16_t umid;                                          // Armazena Umidade Nextion
uint16_t luz;                                           // Armazena Luz Nextion
const int REFRESH_TIME = 100;                           // Tempo para atualizar a página
unsigned long refresh_timer = millis();                 // Cronometro para atualizar a página

//Funções Auxiliores ---------------------------------------------------------------------------------
void requisicao();                                      // Função realizar as requisições
void resultOfGet(String msg);                           // Função que trata o o retorno GET
void init();                                            // Função da Home

//Setup ----------------------------------------------------------------------------------------------
void setup() {
    Serial.begin(115200);                               // Inicializa o Serial
    WiFi.begin(SSID, password);                         // Tenta se logar no Wifi
    while (WiFi.status() != WL_CONNECTED) {             // Verifica se a Conecção foi realizada
        delay(500);                                     // Espera 0,5s
    }
    Serial.println("Conectado!!!");                     // Mostra o IP do ESP32
    Nextion.begin(115200);                              // Inicializa o Objeto Nextion
    delay(100);                                         // Espera 0,1s
    Nextion.writeStr("page 0");                         // Set a pagina inicial do Nextion
    const size_t capacity = JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(3) + 64; // Calcula a capadidade
    DynamicJsonDocument doc(capacity);                  // Aloca espaço de memoria
    ntp.begin();                                        // Inicializa o Objeto NTP
    ntp.forceUpdate();                                  // Força um Update da Hora
}

//Loop -----------------------------------------------------------------------------------------------
void loop() {
    requisicao();                                       // Chama a função requisicao()
    delay(1000);                                        // Espera 1s
    init();                                             // Chama a função init()
}

//Requisição HTTP ------------------------------------------------------------------------------------
void requisicao(){
    Nextion.NextionListen();                            // Verificamos se teve mudança no Nextion
    http.begin("http://192.168.0.122/");                // Realizamos um requisição
    int httpCode = http.GET();                          // Armazenamos o retorno
    if (httpCode > 0) {                                 // Maior que 0, tem resposta a ser lida
        Serial.println("Requisição feita com Sucesso"); // Imprime na Serial
        String msg = http.getString();                  // Armazenamos a string
        resultOfGet(msg);                               // Chamamos a função resultOfGet()
    }
    else {                                              // Caso seja 0 ou menor
    Serial.println("Falha na requisição");              // Imprime que deu erro na requisição
    }
    http.end();                                         // Encerra a requisição
}

//Retorno Metodo GET ---------------------------------------------------------------------------------
void resultOfGet(String msg) {
    memset(json, 0, sizeof(json));                      // Limpa a variavel
    msg.toCharArray(json, 200);                         // Armazena msg no array da variavel json
    deserializeJson(doc, json);                         // Analiza o documento JSON
    JsonObject Status = doc["Status"];                  // Armazena os Status em doc
    Status_Temperatura = Status["Temperatura"];         // Armazena o Status da Temperatura
    Status_Umidade = Status["Umidade"];                 // Armazena o Status da Umidade 
    Status_Luminosidade = Status["Luminosidade"];       // Armazena o Status da Luminosidade
}

//Tela Inicial ----------------------------------------------------------------------------------------
void init(){
    Nextion.writeNum("n0.val", Status_Luminosidade);
    Nextion.writeNum("x0.val", Status_Temperatura * 100);
    Nextion.writeNum("x1.val", Status_Umidade * 100);
    Nextion.writeNum("n1.val", ntp.getHours());
    Nextion.writeNum("n2.val", ntp.getMinutes());
    switch (ntp.getDay()) {
        case 0:
            Nextion.writeStr("t3.txt", "Domingo");
            break;
        case 1:
            Nextion.writeStr("t3.txt", "Segunda");
            break;
        case 2:
            Nextion.writeStr("t3.txt", "Terca");
            break;
        case 3:
            Nextion.writeStr("t3.txt", "Quarta");
            break;
        case 4:
            Nextion.writeStr("t3.txt", "Quinta");
            break;
        case 5:
            Nextion.writeStr("t3.txt", "Sexta");
            break;
        case 6:
            Nextion.writeStr("t3.txt", "Sabado");
            break;
    }
}  

//Temperatura ----------------------------------------------------------------------------------------
void trigger1() {
  while (Nextion.currentPageId == 1) {                  // Cria um loop verifica a pagina atual
    if ((millis() - refresh_timer) > REFRESH_TIME) {
      requisicao();                                     // Chama função requisicao()
      delay(100);                                       // Espera 0,1s
      Nextion.writeNum("x0.val", Status_Temperatura*100);
      temp = map(Status_Temperatura, 0, 50, 0, 5000);
      Nextion.writeNum("NvoltageGraph.val", temp);      // Escreve o valor de temperatura no Nextion
      refresh_timer = millis();
    }
  }
}

//Umidade --------------------------------------------------------------------------------------------
void trigger2() {
  while (Nextion.currentPageId == 2) {                  // Cria um loop verifica a pagina atual
    if ((millis() - refresh_timer) > REFRESH_TIME) {
      requisicao();                                     // Chama função requisicao()
      delay(100);                                       // Espera 0,1s
      Nextion.writeNum("x0.val", Status_Umidade*100);
      umid = map(Status_Umidade, 20, 90, 0, 5000);
      Nextion.writeNum("NvoltageGraph.val", umid);      // Escreve o valor de umidade no Nextion
      refresh_timer = millis();
    }
  }
}

//Luminozidade ---------------------------------------------------------------------------------------
void trigger3() {
  while (Nextion.currentPageId == 3) {                  // Cria um loop verifica a pagina atual
    if ((millis() - refresh_timer) > REFRESH_TIME) {
      requisicao();                                     // Chama função requisicao()
      delay(100);                                       // Espera 0,1s
      luz = map(Status_Luminosidade, 0, 4096, 0, 5000);
      Nextion.writeNum("NvoltageGraph.val", luz);       // Escreve o valor de luz no Nextion
      refresh_timer = millis();
    }
  }
}

Vamos dar uma olhada mais de perto no código:

Incluindo Bibliotecas

Primeiramente temos que incluir as bibliotecas que iremos utilizar em nosso projeto.

//Biblioteca -----------------------------------------------------------------------------------------
#include <WiFi.h>                                       // Responsavel pelo Wifi
#include <HTTPClient.h>                                 // Responsavel pelas requisições HTTP
#include <ArduinoJson.h>                                // Responsavel pela leitura JSON
#include <EasyNextionLibrary.h>                         // Facilitar o uso do Nextion
#include <time.h>                                       // Facilitar o uso de tempo
#include <NTPClient.h>                                  // Facilitar o uso dos Servidores NTP

Configuramos WiFi

Então declaramos duas constantes para o WiFi sendo elas SSID (nome da rede) e password (senha da rede). Além disso declaramos um objeto chamado server e passamos a porta 80 para ele.

//WiFi -----------------------------------------------------------------------------------------------
const char* SSID     = "<NOME-DA-REDE>";                // Nome da rede Wifi
const char* password = "<SENHA-DA-REDE>";               // Senha do Wifi

Configuramos Data e Hora

Em seguida declaramos constantes do servidor NTP e fuso horário.

//Data e Hora ----------------------------------------------------------------------------------------
const cha r* ntpServer = "a.st1.ntp.br";                // Servidor NTP 
const int   fusoHorario = -3*3600;                      // Fuso horário que será aplicado

Declaração de Objetos

Logo após declaramos Objetos dos tipos HTTPClient, StaticJsonDocument, EasyNex, WiFiUDP e NTPClient.

//Declarando Objetos ---------------------------------------------------------------------------------
HTTPClient http;                                        // Objeto para requisições 
StaticJsonDocument<128> doc;                            // Objeto para leitura JSON
EasyNex Nextion(Serial2);                               // Objeto para Nextion
WiFiUDP udp;                                            // Objeto para Update do time
NTPClient ntp(udp, ntpServer, fusoHorario, 60000);      // Objeto "NTP"

Declaração de Variáveis

Então declaramos 9 variáveis globais.

//Variavel Global ------------------------------------------------------------------------------------
char json[200] = {0};                                   // Armazena JSON
float Status_Temperatura;                               // Armazena Temperatura JSON
float Status_Umidade;                                   // Armazena Umidade JSON
int Status_Luminosidade;                                // Armazena Luminosidade JSON
uint16_t temp;                                          // Armazena Temperatura Nextion 
uint16_t umid;                                          // Armazena Umidade Nextion
uint16_t luz;                                           // Armazena Luz Nextion
const int REFRESH_TIME = 100;                           // Tempo para atualizar a página
unsigned long refresh_timer = millis();                 // Cronometro para atualizar a página

Declaração de Funções Auxiliares

Além disso declaramos também os protótipos das funções auxiliares.

//Funções Auxiliores ---------------------------------------------------------------------------------
void requisicao();                                      // Função realizar as requisições
void resultOfGet(String msg);                           // Função que trata o o retorno GET
void init();                                            // Função da Home

Funções Setup

Então agora na função setup, iniciamos o WiFi, NTP, Nextion e Serial. Contudo definimos a página do Nextion em 0.

//Setup ----------------------------------------------------------------------------------------------
void setup() {
    Serial.begin(115200);                               // Inicializa o Serial
    WiFi.begin(SSID, password);                         // Tenta se logar no WiFi
    while (WiFi.status() != WL_CONNECTED) {             // Verifica se a Conexão foi realizada
        delay(500);                                     // Espera 0,5s
    }
    Serial.println("Conectado!!!");                     // Mostra o IP do ESP32
    Nextion.begin(115200);                              // Inicializa o Objeto Nextion
    delay(100);                                         // Espera 0,1s
    Nextion.writeStr("page 0");                         // Set a pagina inicial do Nextion
    const size_t capacity = JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(3) + 64; // Calcula a capacidade
    DynamicJsonDocument doc(capacity);                  // Aloca espaço de memoria
    ntp.begin();                                        // Inicializa o Objeto NTP
    ntp.forceUpdate();                                  // Força um Update da Hora
}

Em seguida na função loop, chamamos a função requisição esperamos 1 segundo e chamamos a função init.

//Loop -----------------------------------------------------------------------------------------------
void loop() {
    requisicao();                                       // Chama a função requisicao()
    delay(1000);                                        // Espera 1s
    init();                                             // Chama a função init()
}

Funções Requisição

Então na função requisição, verificamos se o Nextion enviou alguma informação, depois fazermos uma requisição no IP do ESP32 LoRa. Do mesmo modo armazenamos o retorno do protocolo GET. Verificamos se httpCode é maior que 0, pois se for quer dizer que tem texto a ser lido. Em seguida imprimimos na serial e armazenamos o texto da requisição em uma string, após isso chamamos a função resultOfGet passando a variável msg para ela. Entretanto caso a verificação seja negativa imprimimos na serial que deu falha e encerramos a requisição.

//Requisição HTTP ------------------------------------------------------------------------------------
void requisicao(){
    Nextion.NextionListen();                            // Verificamos se teve mudança no Nextion
    http.begin("http://192.168.0.122/");                // Realizamos um requisição
    int httpCode = http.GET();                          // Armazenamos o retorno
    if (httpCode > 0) {                                 // Maior que 0, tem resposta a ser lida
        Serial.println("Requisição feita com Sucesso"); // Imprime na Serial
        String msg = http.getString();                  // Armazenamos a string
        resultOfGet(msg);                               // Chamamos a função resultOfGet()
    }
    else {                                              // Caso seja 0 ou menor
    Serial.println("Falha na requisição");              // Imprime que deu erro na requisição
    }
    http.end();                                         // Encerra a requisição
}

Funções ResultOfGet

Passando para nossa próxima função temos resultOfGet, essa função retorna o resultado da requisição, primeiro limpamos a variável, armazenamos o msg num array e atribuímos a cada variável seu respectivo valor.

//Retorno Metodo GET ---------------------------------------------------------------------------------
void resultOfGet(String msg) {
    memset(json, 0, sizeof(json));                      // Limpa a variavel
    msg.toCharArray(json, 200);                         // Armazena msg no array da variavel json
    deserializeJson(doc, json);                         // Analiza o documento JSON
    JsonObject Status = doc["Status"];                  // Armazena os Status em doc
    Status_Temperatura = Status["Temperatura"];         // Armazena o Status da Temperatura
    Status_Umidade = Status["Umidade"];                 // Armazena o Status da Umidade 
    Status_Luminosidade = Status["Luminosidade"];       // Armazena o Status da Luminosidade
}

Funções init

Na função init, escrevemos nos componentes do Nextion cada valor respectivamente, após isso fazemos um switch verificando o que retorna a função ntp.getDay, pois para domingo ela retorna 0, segunda 1, terça 2 e assim por diante…

//Tela Inicial ----------------------------------------------------------------------------------------
void init(){
    Nextion.writeNum("n0.val", Status_Luminosidade);
    Nextion.writeNum("x0.val", Status_Temperatura * 100);
    Nextion.writeNum("x1.val", Status_Umidade * 100);
    Nextion.writeNum("n1.val", ntp.getHours());
    Nextion.writeNum("n2.val", ntp.getMinutes());
    switch (ntp.getDay()) {
        case 0:
            Nextion.writeStr("t3.txt", "Domingo");
            break;
        case 1:
            Nextion.writeStr("t3.txt", "Segunda");
            break;
        case 2:
            Nextion.writeStr("t3.txt", "Terca");
            break;
        case 3:
            Nextion.writeStr("t3.txt", "Quarta");
            break;
        case 4:
            Nextion.writeStr("t3.txt", "Quinta");
            break;
        case 5:
            Nextion.writeStr("t3.txt", "Sexta");
            break;
        case 6:
            Nextion.writeStr("t3.txt", "Sabado");
            break;
    }
}

Funções Trigger

Agora é as funções trigger, todas elas são praticamente iguais por isso só irei falar de uma. A trigger 1 cria um loop até que a página seja diferente de 1, chama a função requisição, espera 0,1s, realiza a conversão de 0 a 50 para 0 a 5000 e escreve no Nextion.

//Temperatura ----------------------------------------------------------------------------------------
void trigger1() {
  while (Nextion.currentPageId == 1) {                  // Cria um loop verifica a pagina atual
    if ((millis() - refresh_timer) > REFRESH_TIME) {
      requisicao();                                     // Chama função requisicao()
      delay(100);                                       // Espera 0,1s
      Nextion.writeNum("x0.val", Status_Temperatura*100);
      temp = map(Status_Temperatura, 0, 50, 0, 5000);
      Nextion.writeNum("NvoltageGraph.val", temp);      // Escreve o valor de temperatura no Nextion
      refresh_timer = millis();
    }
  }
}

E assim encerramos o projeto da estação meteorológica.

Resultado do Projeto Estação Meteorológica

Por fim esse foi o resultado obtido com nosso projeto.

Estação Meteorológica - WJ Componentes 2
Estação Meteorológica - WJ Componentes
Estação Meteorológica - WJ Componentes 3

Agradecemos sua Presença

Por fim, espero que tenham gostado e aprendido. Compartilhe com seus colegas e deixe um comentário de qual projeto deveria ser o próximo aqui no Blog da WJ Componentes!!
Enfim estarei deixando os arquivos do código-fonte e Fritzing, software e sites utilizados e deixarei também o GitHub da biblioteca utilizada.
Fique à vontade para tirar suas dúvidas nos comentários.

Sender – Download do Arquivo:Baixar
Reciver – Download do Arquivo:Baixar
Display Nextion – Estação MeteorológicaBaixar
Fritzing – Download do Arquivo:Baixar

Software e Sites Utilizados

GitHub das Bibliotecas Utilizadas

Post Relacionados

    Posts mais Recentes

    Julio Cesar Bonow Manoel

    Julio Cesar Bonow Manoel

    Cursando Engenharia da Computação pelo Centro Universitário Facens e atua no desenvolvimento de projetos na WJ Componentes. Participante da equipe de robótica Omegabotz.

    Deixe um comentário

    O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *