Relatório meteorológico usando os miniaplicativos ThingSpeak MQTT e IFTTT: 8 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Introdução

Um aplicativo meteorológico baseado em nuvem que fornece relatórios meteorológicos diários como notificação por e-mail. Este aplicativo da web mede temperatura e umidade usando SHT25 e Adafruit Huzzah ESP8266. Ele nos fornece dados de temperatura e umidade em tempo real e análises de hora em hora. Os dados são enviados usando ThingSpeak MQTT API e, posteriormente, estamos fornecendo uma notificação por e-mail ao usuário sempre que a temperatura atinge o limite atribuído usando o protocolo IFTTT. SHT25 é um sensor de temperatura e umidade fabricado pela Sensirion. O SHT25 fornece um alto nível de precisão em torno de ± 2% UR. Sua faixa de umidade está entre 0 a 100% e a faixa de temperatura está entre -40 a 125 ° C. É muito mais confiável e rápido com 8 segundos de tempo de resposta do sensor.

Recursos

• Fornece estatísticas e estatísticas em tempo real usando Thing Speak MQTT API
• Uma notificação por e-mail é fornecida ao usuário em um momento atribuído usando IFTTT
• O Agendador de Tarefas é usado para programar a tarefa, como buscar dados de sensores, Publicar as leituras do sensor, Inscrever-se no tópico MQTT
• Ele usa o protocolo I2C para buscar a leitura do sensor que é mais precisa, expansível e escalável
• modo de hibernação quando o dispositivo está ocioso ou nenhum retorno de chamada de tarefa é chamado.
• o agendamento de tarefas eficaz fornece um uso sem complicações
• Uma página da web separada é hospedada onde o usuário deve fornecer suas credenciais de usuário para evitar que seu dispositivo pisque sempre que estiver ao alcance de outras redes wi-fi
• SPIFFS é usado para armazenar nossa página da web para tornar nosso código legível e menos desajeitado

Etapa 1: Especificação de Hardware e Software

Especificação de Hardware

• Placa Adafruit esp8266 Huzzah
• Huzzah Board Shield
• Módulo de sensor SHT25
• Cabo I2C

Especificação de Software

• IDE Arduino
• IFTTT Thing Speak
• API MQTT

Etapa 2: armazenamento de credenciais de usuário

Aqui, estamos usando o sensor SHT25 I2C para ler o valor em tempo real da temperatura e da umidade relativa e postando esses valores na nuvem. Para obter o valor do sensor atualizado de tempos em tempos e postar essas atualizações simultaneamente, estamos usando a Biblioteca do Agendador de Tarefas do Arduino. Para operações em nuvem, estamos usando a API ThingSpeak MQTT. Posteriormente, estaremos fornecendo um relatório do tempo em tempo real para o usuário usando miniaplicativos IFTTT. Você pode seguir estas etapas para criar sua própria estação meteorológica. Então, faça você mesmo.

Antes de prosseguir. Precisamos salvar as credenciais do usuário. Para isso, estamos hospedando um servidor web em 192.169.1.4. Armazenamos nosso formulário da web em SPIFFS. Assim que o dispositivo é iniciado, ele hospeda um servidor da web por 60 segundos. O usuário deve seguir estas etapas.

• Conecte-se ao usuário do AP ESP, que está listado em sua lista de rede wi-fi disponível. Conecte-se a este AP e digite a senha "*******"
• Assim que estiver conectado, vá para o seu navegador e digite o IP 192.168.1.4.
• Digite o SSID e a senha de seu WiFi local nos campos de entrada e digite SUBMIT
• Essas credenciais serão salvas na EEPROM
• Após 60 segundos, o dispositivo se desconectará automaticamente do AP
• Da próxima vez que você ligar o dispositivo, o usuário não precisará seguir este procedimento, o dispositivo buscará automaticamente as credenciais do usuário da EEPROM e continuará obtendo as leituras do sensor da interface I2C e publicando-as na nuvem

// --------- AP config ------------ // IPAddress ap_local_IP (192, 168, 1, 4); Endereço IP ap_gateway (192, 168, 1, 254); Endereço IP ap_subnet (255, 255, 255, 0);

Serial.print ("Configurando ponto de acesso…");

WiFi.softAPConfig (ap_local_IP, ap_gateway, ap_subnet);

Serial.print ("Configurando as credenciais do usuário");

WiFi.softAP (ssidAP, passAP);

server.on ("/", handleRoot);

server.onNotFound (onHandleNotFound);

server.begin ();

APTimer = milis ();

while (millis () - APTimer <APInterval) {

server.handleClient ();

}

// ***************************** HANDLE ROOT ****************** ********* // void handleRoot () {

if (server.hasArg ("ssid") && server.hasArg ("senha"))

{

// Se todos os campos do formulário contiverem chamada de dados

handelSubmit ()

handleSubmit (); }

outro {

// Reexibir o formulário

// leia o arquivo contido em spiffs

Arquivo file = SPIFFS.open ("/ webform.html", "r");

server.streamFile (arquivo, "text / html");

// não se esqueça de fechar o arquivo

file.close ();

}}

// Verifique o status se possui os argumentos ssid e senha

// Em seguida, escreva as credenciais para ROM

ROMwrite (String (server.arg ("ssid")), String (server.arg ("senha")))

Etapa 3: Configurando Seu Formulário da Web em SPIFFS

SPIFFS

Sistema de arquivos Flash de interface periférica serial ou SPIFFS para abreviar. É um sistema de arquivos leve para microcontroladores com um chip flash SPI. O chip flash integrado do ESP8266 tem bastante espaço para suas páginas da web, especialmente se você tiver a versão de 1 MB, 2 MB ou 4 MB. Também armazenamos nossa página da web em Flash System. Existem algumas etapas que precisamos seguir para fazer upload de dados para spiffs

1. Baixe a ferramenta:
2. No diretório do caderno de desenho do Arduino, crie o diretório de ferramentas se ainda não existir
3. Descompacte a ferramenta no diretório de ferramentas (o caminho será semelhante a /Arduino/tools/ESP8266FS/tool/esp8266fs.jar)
4. Reinicie o Arduino IDE
5. Abra um esboço (ou crie um novo e salve-o)
6. Vá para o diretório de esboço (escolha Sketch> Show Sketch Folder)
7. Crie um diretório denominado data e quaisquer arquivos que você deseja no sistema de arquivos lá. Carregamos nossa página HTML com o nome webform.html
8. Certifique-se de ter selecionado uma placa, porta e monitor serial fechado
9. Selecione Ferramentas> Upload de dados de esboço ESP8266. Isso deve começar a carregar os arquivos no sistema de arquivos flash ESP8266. Quando terminar, a barra de status do IDE exibirá a mensagem SPIFFS Image Uploaded.

Arquivo file = SPIFFS.open ("/ webform.html", "r");

server.streamFile (arquivo, "text / html");

// não se esqueça de fechar o arquivo

file.close ();

Etapa 4: Agendamento de Tarefas

Neste tutorial, estamos realizando duas operações:

• Leia os dados de SHT25 usando o protocolo I2C
• Publique os dados atualizados na nuvem usando ThingSpeak MQTT API

Para conseguir isso, estamos usando a biblioteca TaskScheduler. Agendamos duas tarefas diferentes referentes a duas operações de controle diferentes. Isto se faz do seguinte modo

• A tarefa 1 é para ler o valor do sensor, esta tarefa é executada por 1 segundo até atingir o tempo limite de 10 segundos.
• Quando a Tarefa1 atinge o tempo limite, estamos nos conectando ao Wifi local e ao corretor MQTT.
• Agora, a Tarefa 2 está ativada e estamos desativando a Tarefa 1 A Tarefa 2 é para publicar os dados do sensor no intermediário Thing Speak MQTT, esta tarefa é executada por 20 segundos até atingir o tempo limite de 20 segundos
• Quando a Tarefa2 atinge seu tempo limite, a Tarefa 1 é habilitada novamente e a Tarefa2 é desabilitada. aqui novamente, estamos obtendo o valor atualizado e o processo continua
• quando nenhuma chamada de retorno é chamada ou o dispositivo está ocioso, ele entra no modo de suspensão leve, economizando energia.

// --------- protótipo para callback de tarefa ------------ //

void taskI2CCallback ();

void taskI2CDisable ();

void taskWiFiCallback ();

void taskWiFiDisable ();

//---------Tarefas------------//

Tarefa tI2C (2 * TASK_SECOND, TASK_FOREVER, & taskI2CCallback, & ts, false, NULL, & taskI2CDisable);

Tarefa tWiFi (20 * TASK_SECOND, TASK_FOREVER, & taskWiFiCallback, & ts, false, NULL, & taskWiFiDisable);

// habilita tI2C tI2C.enable ();

Etapa 5: Leitura dos valores de temperatura e umidade de SHT25

I2C é uma interface de dois fios que usa apenas dois fios para se comunicar com o dispositivo mestre. Um é SCL (Serial Clock) e o outro é SDA (Serial Data). Cada dispositivo escravo possui um endereço único. SHT 25 também possui um endereço de 8 bits e pode ser acessado por um endereço 0x44. ele tem 8 bits do endereço, onde 7 bits são o endereço real e enquanto o bit 0 do LSB mais à direita é usado para sinalizar a leitura ou a gravação no dispositivo. Se o bit 0 for definido como 1, o dispositivo mestre fará a leitura do dispositivo I2C escravo. I2C é muito mais confiável, escalável e rápido e ainda tem muitos modos de operação que o torna muito mais eficiente em termos de energia

Estamos usando a biblioteca Wire.h para ler os valores de temperatura e umidade. Esta biblioteca facilita a comunicação i2c entre o sensor e o dispositivo mestre. 0x44 é o endereço I2C para SHT25. SHT25 opera em um modo diferente de operação. Você pode consultar a folha de dados para isso. Estamos usando 0x2C e 0x06 como MSB e LSB, respectivamente, para operação de disparo único

Etapa 6: Publicação de valores no ThingSpeak usando a API ThingSpeak MQTT

Para postar nossos valores de temperatura e umidade na nuvem, estamos usando a API ThingSpeak MQTT. ThingSpeak é uma plataforma IoT. ThingSpeak é um serviço da web gratuito que permite coletar e armazenar dados do sensor na nuvem. MQTT é um protocolo comum usado em sistemas IoT para conectar dispositivos e sensores de baixo nível. MQTT é usado para transmitir mensagens curtas de e para um broker. ThingSpeak adicionou recentemente um broker MQTT para que os dispositivos possam enviar mensagens para ThingSpeak. Você pode seguir o procedimento para configurar o Canal ThingSpeak deste post

ThingSpeak MQTT

MQTT é uma arquitetura de publicação / assinatura desenvolvida principalmente para conectar largura de banda e dispositivos com restrição de energia em redes sem fio. É um protocolo simples e leve que roda em soquetes TCP / IP ou WebSockets. MQTT sobre WebSockets pode ser protegido com SSL. A arquitetura de publicar / assinar permite que as mensagens sejam enviadas por push para os dispositivos do cliente sem que o dispositivo precise pesquisar continuamente o servidor. Um cliente é qualquer dispositivo que se conecta ao broker e pode publicar ou assinar tópicos para acessar as informações. Um tópico contém as informações de roteamento para o broker. Cada cliente que deseja enviar mensagens as publica em um determinado tópico, e cada cliente que deseja receber mensagens se inscreve em um determinado tópico

Publicar e assinar usando ThingSpeak MQTT

• Publicar em canais de feed de canal / publicar /
• Publicar em um determinado campo canais / publicar / campos / campo /
• Inscreva-se no campo de canal canais / inscreva-se //
• Inscreva-se nos canais de feed do canal privado // inscreva-se / campos / campo /
• Inscreva-se em todos os campos de um canal. canais // inscrever-se / campos / feild /

void taskWiFiCallback ()

{

Serial.println ("taskWiFiCallbackStarted");

Serial.print ("tempo limite para esta tarefa: / t");

Serial.println (tWiFi.getTimeout ());

if (! mqttCli.connected ())

{

Serial.println ("Cliente não conectado");

reconnectMQTT ();

}

String topicString = "channels /" + String (channelID) + "/ publish /" + String (writeAPIKey);

int topicLength = topicString.length () + 1;

char topicBuffer [topicLength];

topicString.toCharArray (topicBuffer, topicLength + 1);

Serial.println (topicBuffer);

String dataString = String ("field1 =" + String (tempC, 1) + "& field2 =" + String (tempF, 1) + "& field3 =" + String (úmido, 1));

int dataLength = dataString.length () + 1;

byte dataBuffer [dataLength];

dataString.getBytes (dataBuffer, dataLength);

mqttCli.beginPublish (topicBuffer, dataLength, false);

Serial.println (mqttCli.write (dataBuffer, dataLength)? "Publicado": "falha na publicação");

mqttCli.endPublish ();

//mqttCli.loop ();

}

Etapa 7: notificação por e-mail do boletim meteorológico

Estamos usando miniaplicativos IFTTT para fornecer ao usuário um relatório meteorológico em tempo real por e-mail. Então, nós o implementamos por meio do ThingSpeak. Estamos calculando a média dos valores 5-fay de temperatura e umidade. Sempre que o valor da última entrada for maior que o valor médio. Irá disparar uma notificação por email "é um dia quente". e quando for menor que o valor médio. Irá disparar uma notificação por email "Que lindo dia". Todos os dias por volta das 10h00 (IST), receberemos uma notificação por e-mail

channelID = ******;

iftttURL = 'https://maker.ifttt.com/***************';

umidadeData = thingSpeakRead (channelID, 'Fields', 3, 'NumDays', 5); tempData = thingSpeakRead (channelID, 'Fields', 1, 'NumDays', 5);

perHumid = max (umidadeData) -min (umidadeData);

valor úmido = 0,1 * perHúmido + min (dados umidade);

perTemp = max (tempData) -min (tempData);

tempValue = 0,1 * perTemp + min (tempDados);

urlTemp = strcat ('https://api.thingspeak.com/channels/', string (channelID), '/fields/1/last.txt');

urlHumid = strcat ('https://api.thingspeak.com/channels/', string (channelID), '/fields/3/last.txt'); lastTempValue = str2num (webread (urlTemp)); lastHumidValue = str2num (webread (urlHumid));

if (lastTempValue

if (lastTempValue> tempValue || lastHumidValue> humidValue)

plantMessage = 'É um dia quente.'; webwrite (iftttURL, 'valor1', plantMessage, 'valor2', lastTempValue, 'value3', lastHumidValue); fim

Etapa 8: Código geral

Código Geral

O código geral está disponível neste repositório GitHub

Limitações

• Existem alguns problemas com a publicação de dados usando um método de publicação para a grande massa de dados. Para resolver esse problema, estamos usando a função write ()
• O SPIFFS deve ser formatado antes de enviar os novos dados para o SPIFFS.
• Você não deve usar a função delay (). delay () impede a operação em segundo plano. Em vez disso, crie atrasos usando millis () apenas se for necessário

Créditos

• ESP826WebServer
• Agendador de tarefas
• SHT 25
• API ThingSpeak MQTT
• IFTTT
• PubSubClient