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.
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.
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.
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 DHTConfiguramos 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; // UmidadeConfiguramos LDR
Em seguida definimos o pino do LDR que utilizamos.
//Variáveis Globais ----------------------------------------------------------------------------------
int i = 0; // Variável de controleConfiguramos 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 portaFunçõ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 luminosidadeEm 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 NTPConfiguramos 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 WifiConfiguramos 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á aplicadoDeclaraçã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áginaDeclaraçã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 HomeFunçõ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.
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.
Software e Sites Utilizados
GitHub das Bibliotecas Utilizadas
Post Relacionados
Posts mais Recentes
- Acionando motor DC por meio do pino “Touch” do ESP-32Neste projeto, vamos explorar uma aplicação ainda mais dinâmica e… Leia mais: Acionando motor DC por meio do pino “Touch” do ESP-32
- Acendendo led RGB por meio do pino “Touch” do ESP-32No último post, exploramos o fascinante mundo dos pinos touch… Leia mais: Acendendo led RGB por meio do pino “Touch” do ESP-32
- Utilizando os Pinos touch do ESP32
Nesse projeto Vamos aprender a usar os pinos touch´s do… Leia mais: Utilizando os Pinos touch do ESP32 - Como Programar e Localizar o Endereço de uma Tela OLED I2C com Arduinoeste guia, vou levá-lo através dos passos para programar uma… Leia mais: Como Programar e Localizar o Endereço de uma Tela OLED I2C com Arduino
- GPS com ArduínoOlá, como estão? Você está com dificuldade com o seu… Leia mais: GPS com Arduíno
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