APLICATIVO DE TEMPERATURA E UMIDADE DA FALA DE COISA USANDO ESP8266: 9 etapas

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

Enquanto mexia nas minhas coisas eletrônicas, tive a ideia de fazer um aplicativo de previsão do tempo baseado na web. Este aplicativo da web usa o sensor SHT31 para obter os dados de temperatura e umidade em tempo real. Implementamos nosso projeto no módulo WiFi ESP8266. Online ou offline! Não precisa se preocupar, esteja você online ou offline, você receberá as atualizações do tempo de qualquer lugar e a qualquer hora. Este aplicativo da web envia dados para o servidor da web local, bem como para a nuvem. Para operações em nuvem, estamos usando a API ThingSpeak. SHT31 usa I2C para obter os dados do sensor.

SHT 31 é um sensor de temperatura e umidade fabricado pela Sensirion. O SHT31 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. Sua funcionalidade inclui processamento de sinal aprimorado e compatibilidade I2C. Possui diferentes modos de operação, o que o torna eficiente em termos de energia.

Neste tutorial, fizemos a interface do SHT 31 com a placa Adafruit Huzzah. Para a leitura dos valores de Temperatura e Umidade, usamos a blindagem ESP8266 I2C. Este adaptador torna todos os pinos acessíveis ao usuário e oferece um ambiente I2C amigável.

Etapa 1: Hardware necessário

Hardware usado para completar esta tarefa:

1. SHT 31
2. Adafruit Huzzah ESP8266
3. Adaptador ESP8266 I2C
4. Cabo I2C

Etapa 2: Conexões de Hardware

Esta etapa inclui o guia de conexão de hardware. Esta seção explica basicamente as conexões de fiação necessárias entre o sensor e o ESP8266. As conexões são as seguintes.

1. O SHT31 funciona em I2C. A imagem acima demonstra a conexão entre o ESP8266 e o módulo SHT31. Estamos usando um cabo I2C para ele ou podemos usar fios de jumper 4 F a F.
2. um fio é usado para Vcc, o segundo fio para GND e outros dois para SDA e SCL, respectivamente
3. De acordo com o adaptador I2C, o pino 2 e o pino 14 de uma placa ESP8266 são usados como SDA e SCL, respectivamente

Etapa 3: Código para agendamento de tarefas

Neste tutorial, estamos realizando três operações

• Leia os dados de SHT11 usando o protocolo I2C
• hospedar o servidor da web e postar a leitura do sensor na página da web
• postar as leituras do sensor na API ThingSpeak

Para conseguir isso, estamos usando a biblioteca TaskScheduler. Agendamos três tarefas diferentes referentes a três 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 seu tempo limite, a Tarefa 2 é ativada e a Tarefa1 é desativada.
• Nós nos conectamos ao AP neste retorno de chamada. Duas variáveis booleanas são tomadas para cuidar da comutação entre o STA e o AP
• Na Tarefa 2, estamos hospedando um servidor web em 192.168.1.4. Esta tarefa é executada a cada 5 segundos até atingir seu tempo limite, que é de 50 segundos

• Quando a Tarefa 2 atinge o tempo limite, a Tarefa 3 é ativada e a Tarefa2 é desativada.

• Nós nos conectamos ao STA (IP local) neste calback. Na Tarefa 3, estamos postando a leitura do sensor na API ThingSpeak da nuvem
• A Tarefa 3 é executada a cada cinco segundos até atingir o tempo limite, ou seja, 50 segundos
• Quando a Tarefa3 atinge seu tempo limite, a Tarefa 1 é habilitada novamente e a Tarefa3 é desabilitada.
• Quando nenhuma chamada de retorno é chamada ou o dispositivo está ocioso, ele entra no modo de suspensão leve, economizando energia.

void taskI2CCallback ();

void taskI2CDisable (); void taskAPCallback (); void taskAPDisable (); void taskWiFiCallback (); void taskWiFiDisable (); // Tarefas para i2c, servidor web de hospedagem e postagem no thingspeak Tarefa tI2C (1 * TASK_SECOND, TASK_FOREVER, & taskI2CCallback, & ts, false, NULL, & taskI2CDisable); Tarefa tI2C (1 * TASK_SECOND, TASK_FOREVER, & taskI2CCallback, & ts, false, NULL, & taskI2CDisable); Tarefa tAP (5 * TASK_SECOND, TASK_FOREVER, & taskAPCallback, & ts, false, NULL, & taskAPDisable); Tarefa tWiFi (5 * TASK_SECOND, TASK_FOREVER, & taskWiFiCallback, & ts, false, NULL, & taskWiFiDisable); // tempo limite para tarefas tI2C.setTimeout (10 * TASK_SECOND); tAP.setTimeout (50 * TASK_SECOND); tWiFi.setTimeout (50 * TASK_SECOND); // habilita a tarefa I2C tI2C.enable ();

Etapa 4: Código para leitura dos valores de temperatura e umidade

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

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

// callback de tarefa I2C void taskI2CCallback () {Serial.println ("taskI2CStarted"); raiz interna sem sinal [6]; // começa a transmissão de 0x44; Wire.beginTransmission (Addr); // para uma transmissão única com alta repetibilidade, usamos 0x2C (MSB) e 0x06 (LSB) Wire.write (0x2C); Wire.write (0x06); // fim da transmissão Wire.endTransmission (); // solicitar bytes de 0x44 Wire.beginTransmission (Addr); Wire.endTransmission (); Wire.requestFrom (Addr, 6); if (Wire.available () == 6) {// data [0] e data [1] contém 16 bits de temperatura. root [0] = Wire.read (); root [1] = Wire.read (); // dados [2] contém 8 bits de raiz CRC [2] = Wire.read (); // dados [3] e dados [4] contém 16 bits de raiz de umidade [3] = Wire.read (); root [4] = Wire.read (); // dados [5] consistem em raiz CRC de 8 bits [5] = Wire.read (); } int temp = (root [0] * 256) + root [1]; // desloca o MSB em 8 bits adiciona LSB float cTemp = -45,0 + (175,0 * temp / 65535,0); float fTemp = (cTemp * 1,8) + 32,0; // desloca o MSB em 8 bits adiciona LSB a ele dividido por resolução total e * 100 para umidade de flutuação percentual = (100.0 * ((root [3] * 256.0) + root [4])) / 65535.0; tempC = cTemp; tempF = fTemp; úmido = umidade; Serial.print ("Temperatura em C: / t"); Serial.println (String (cTemp, 1)); Serial.print ("Temperatura em F: / t"); Serial.println (String (fTemp, 1)); Serial.print ("Umidade: / t"); Serial.println (String (umidade, 1)); }

Etapa 5: Código para hospedar um servidor da web

Hospedamos um servidor web de nosso dispositivo em um IP estático.

A biblioteca ESP8266WebServer é usada para hospedar o servidor web

• Primeiro, precisamos declarar o endereço IP, gateway e máscara de sub-rede para criar nosso IP estático
• Agora declare SSID e senha para o seu ponto de acesso. Conecte-se ao ponto de acesso a partir de qualquer dispositivo STA
• hospedar o servidor na porta 80, que é uma porta padrão para o protocolo de comunicação da Internet, Hypertext Transfer Protocol (HTTP) digite 192.168.1.4 no seu navegador para a página de introdução e 192.168.1.4/Value para a página de leitura do sensor

// IP estático para APIPAddress ap_local_IP (192, 168, 1, 4); IPAddress ap_gateway (192, 168, 1, 254); Endereço IP ap_subnet (255, 255, 255, 0); // ssid e AP para WiFi local no modo STA const char WiFissid = "*********"; const char WiFipass = "*********"; // ssid e passar para AP const char APssid = "********"; const char APpass = "********"; Servidor ESP8266WebServer (80); void setup {server.on ("/", onHandleDataRoot); server.on ("/ Value", onHandleDataFeed); server.onNotFound (onHandleNotFound);} void taskAPCallback () {Serial.println ("taskAP iniciado"); server.handleClient (); } void onHandleDataRoot () {server.send (200, "text / html", PÁGINA1); } void onHandleDataFeed () {server.send (200, "text / html", PÁGINA2); } void onHandleNotFound () {String message = "Arquivo não encontrado / n / n"; mensagem + = "URI:"; mensagem + = server.uri (); mensagem + = "\ nMétodo:"; mensagem + = (server.method () == HTTP_GET)? "GET": "POST"; mensagem + = "\ nArgumentos:"; mensagem + = server.args (); mensagem + = "\ n"; server.send (404, "texto / simples", mensagem); } void reconnectAPWiFi () {WiFi.mode (WIFI_AP_STA); atraso (100); WiFi.disconnect (); status booleano = WiFi.softAPConfig (ap_local_IP, ap_gateway, ap_subnet); if (status == true) {Serial.print ("Configurando soft-AP…"); booleano ap = WiFi.softAP (APssid, APpass); if (ap == true) {Serial.print ("conectado a: / t"); // IPAddress myIP = WiFi.softAPIP (); Serial.println (WiFi.softAPIP ()); } server.begin ();

}

Etapa 6: configuração do Thingspeak

ThingSpeak é uma plataforma IoT. ThingSpeak é um serviço da web gratuito que permite coletar e armazenar dados do sensor na nuvem.

Nesta etapa, apresentarei um breve procedimento para configurar sua conta do Thing Speak

• Inscreva-se para uma nova conta de usuário no ThingSpeak
• Crie um novo canal selecionando Canais, Meus canais e, em seguida, Novo canal
• Edite seus campos
• Esses campos contêm seus dados de sensor
• Observe a Write API Key e Channel ID
• Em seu esboço do Arduino, você pode usar a biblioteca ThingSpeak para Arduino ou pode POSTAR diretamente os dados na API ThingSpeak
• a próxima etapa explica como postar o conteúdo na API Thing Speak

Etapa 7: Código para postar dados no Thing Speak

Aqui estamos postando as leituras dos sensores no Thing Speak. as etapas a seguir são necessárias para completar esta tarefa-

• Crie sua conta no speakCreate canais e campos para armazenar seus dados de sensor
• podemos obter e postar os dados do ESP para o thingSpeak e vice-versa usando solicitações GET e POST para a API.
• podemos postar nossos dados no ThingSpeak da seguinte maneira

id taskWiFiCallback () {WiFiClient wifiClient; if (wifiClient.connect (hostId, 80)) {String postStr = apiKey; postStr + = "& field1 ="; postStr + = String (úmido); postStr + = "& field2 ="; postStr + = String (tempC); postStr + = "& field3 ="; postStr + = String (tempF); postStr + = "\ r / n / r / n"; wifiClient.print ("POST / atualizar HTTP / 1.1 / n"); wifiClient.print ("Host: api.thingspeak.com / n"); wifiClient.print ("Conexão: fechar / n"); wifiClient.print ("X-THINGSPEAKAPIKEY:" + apiKey + "\ n"); wifiClient.print ("Content-Type: application / x-www-form-urlencoded / n"); wifiClient.print ("Comprimento do conteúdo:"); wifiClient.print (postStr.length ()); wifiClient.print ("\ n / n"); wifiClient.print (postStr); } wifiClient.stop (); }

Etapa 8: Código geral

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

Etapa 9: Créditos

• Arduino JSON
• ESP826WebServer
• Agendador de tarefas
• SHT 31
• Scan I2C
• Tutorial de instructables HIH6130
• Arame
• NCD.io