Aplicativo da web do clima usando Esp8266: 7 etapas

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

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

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 a STA (IP local) neste retorno de chamada
• 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.

Scheduler ts;

// Tarefas para i2c, servidor web de hospedagem e postagem no thingspeak

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 da web
• Primeiro, precisamos declarar o endereço IP, gateway e máscara de sub-rede para criar nosso IP estático
• Agora declare o SSID e a senha do seu ponto de acesso.
• conectar 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 em 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 AP

Endereço IP ap_local_IP (192, 168, 1, 4);

Endereço IP ap_gateway (192, 168, 1, 254);

IPAddress 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: 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 thing speak
• Crie 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

void 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 7: Código geral

O código geral está disponível no meu repositório github

Créditos:

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