Monitor de temperatura IOT baseado em ESP8266 usando Adafruit Broker: IOT Parte 21

No tutorial anterior, o módulo ESP8266 foi usado para projetar uma Home Area Network para controlar uma luz LED de um PC remoto. O cliente PC foi usado para enviar sinais de controle para ligar e desligar a luz LED na Home Area Network. Neste tutorial, o módulo ESP será interligado com o sensor de temperatura DHT-11 e os dados de temperatura serão enviados ao cliente PC para monitoramento de temperatura em tempo real.

Neste projeto, em vez de LED, o sensor DHT-11 será interligado com o ESP8266 no lado do ESP Client. O esboço do Arduino será escrito para ler a temperatura do sensor e enviá-la ao broker MQTT. Um PC remoto que será configurado como outro cliente MQTT que então receberá as leituras de temperatura e umidade e as exibirá em um navegador.
O dispositivo IOT projetado neste projeto é um monitor de temperatura projetado através da interface do sensor de temperatura e umidade DHT-11 com o módulo Wi-Fi ESP-8266. O módulo Wi-Fi, bem como o sensor DHT-11, são alimentados continuamente com a ajuda de um conversor USB para serial. O módulo Wi-Fi precisa ser carregado com um firmware que possa ler a temperatura do sensor e publicá-la no corretor MQTT. O Arduino UNO é usado para atualizar o código do firmware no módulo ESP8266. O módulo ESP também pode ser atualizado com código usando um conversor FTDI como o CP2102. O firmware em si é escrito no Arduino IDE.
O PC remoto atua como outro dispositivo IOT no projeto. O PC se conecta com o dispositivo baseado em ESP8266 por meio do broker MQTT. O PC se conecta com o broker Adafruit, que por sua vez atuará como um cliente MQTT.
No tutorial anterior, foi usado o corretor HiveMQ. Neste tutorial, será utilizado o corretor Adafruit. O corretor Adafruit é um corretor MQTT altamente seguro e suporta TLS/SSL, autenticação e segurança de autorização. Para usar a corretora Adafruit, é necessário criar uma conta em io.adafruit.com. O corretor gera uma chave aleatória para a conta do usuário. Esta é a chave privada de um corretor que pode ser usada para conectar o dispositivo ao corretor. Assim, apenas os dispositivos que possuem a chave privada da corretora podem solicitar conexão da corretora. Desta forma, fornece segurança básica. O corretor Adafruit pode atuar como cliente MQTT simultaneamente. Neste projeto a corretora Adafruit também está configurada como cliente.
Componentes necessários –
Lista de componentes necessários para o protocolo MQTT no monitor de dados do sensor IoT baseado no módulo ESP8266
Fig. 1: Lista de componentes necessários para o protocolo MQTT no módulo ESP8266 baseado no monitor de dados do sensor IoT
Software necessário –
• IDE do Arduino
• Corretor Adafruit
Diagrama de bloco –
Diagrama de blocos do monitor de temperatura e umidade baseado em ESP8266 controlado pelo Adafruit Broker
Fig. 2: Diagrama de blocos do monitor de temperatura e umidade baseado em ESP8266 controlado pelo Adafruit Broker
Conexões de Circuito –
Primeiramente, a placa ESP8266 precisa ser carregada com o código do firmware. Neste tutorial, o código do firmware é escrito usando Arduino IDE. Ele é carregado na placa ESP8266 usando o Arduino UNO. Uma placa ESP8266 genérica é usada neste projeto. Esta placa não possui resistores de inicialização, regulador de tensão, circuito de reinicialização e adaptador serial USB. O módulo ESP8266 opera com fonte de alimentação de 3,3 V com corrente maior ou igual a 250 mA. Portanto, o adaptador CP2102 USB para serial é usado para fornecer tensão de 3,3 V com corrente suficiente para executar o ESP8266 de maneira confiável em todas as situações.
O Módulo Wi-Fi ESP8266 é um SOC independente com pilha de protocolo TCP/IP integrada que pode acessar uma rede Wi-Fi. O ESP8266 é capaz de hospedar um aplicativo ou descarregar todas as funções de rede Wi-Fi de outro processador de aplicativo. Cada módulo ESP8266 vem pré-programado com um firmware de conjunto de comandos AT. O módulo está disponível em dois modelos – ESP-01 e ESP-12. O ESP-12 possui 16 pinos disponíveis para interface, enquanto o ESP-01 possui apenas 8 pinos disponíveis para uso. O ESP-12 possui a seguinte configuração de pinos –
Tabela de listagem de configuração de pinos do modem Wi-Fi ESP8266 ESP-12
Fig. 3: Tabela listando a configuração dos pinos do modem Wi-Fi ESP8266 ESP-12
O modelo ESP-01 é utilizado no projeto. O modelo ESP-01 possui a seguinte configuração de pinos –
Tabela de listagem de configuração de pinos do modem Wi-Fi ESP8266 ESP-01
Fig. 4: Tabela listando a configuração dos pinos do modem Wi-Fi ESP8266 ESP-12
Os pinos Chip Enable e VCC do módulo são conectados ao 3,3 V DC enquanto o pino Ground é conectado ao terra comum. O pino chip enable é conectado ao VCC por meio de um resistor pull up de 10K. O pino RESET é conectado ao terra por meio de um interruptor tátil onde o pino é alimentado por VCC por meio de um resistor pull up de 10K por padrão. Os pinos Tx e Rx do módulo são conectados aos pinos RX e TX do Arduino UNO. O pino GPIO-0 do módulo é conectado ao terra por meio de um interruptor tátil onde o pino é alimentado por VCC por meio de um resistor pull up de 10K por padrão. Esses resistores pull-up atuam como um circuito divisor de tensão que protege a placa ESP8266 de alta tensão. A placa Arduino opera a 5V e também a 3,3 V enquanto o ESP8266 opera a 3,3 V. Embora a própria placa Arduino seja alimentada por meio de seu pino de alimentação de 3,3 V, esse circuito divisor de tensão adiciona ainda mais proteção contra qualquer surto de tensão. O uso de resistores pull-up aumenta a estabilidade do circuito. Com essas conexões de circuito, a própria placa Arduino atua como um adaptador USB para serial. As conexões de circuito entre o Arduino UNO e o módulo ESP8266 para carregamento de inicialização podem ser resumidas como segue –
Tabela de listagem de conexões de circuito entre o modem ESP8266 e o ​​Arduino Uno
Fig. 5: Tabela listando as conexões do circuito entre o modem ESP8266 e o ​​Arduino Uno
Durante a compilação do código, as chaves GPIO0 e RESET devem ser pressionadas. Para carregar o programa, a chave RESET deve ser liberada enquanto a chave de programação GPIO0 deve ser deixada pressionada, para que o ESP possa entrar no modo de programação. Após o upload do código, a chave de programação também deve ser liberada.
Escreva o código do firmware no Arduino IDE e conecte a placa Arduino ao PC via cabo USB. Abra o Arduino IDE e vá em Ferramentas->Porta e selecione a placa Arduino (Arduino UNO). Pode parecer /dev/ttyABM0 (Arduino/Genuino Uno). Selecione o nome da porta correto. O nome da porta pode ser diferente em diferentes configurações de IDE. Em seguida, abra o monitor serial no IDE do Arduino navegando até Ferramentas-> Monitor serial e defina a taxa de transmissão para 115.200 bauds por segundo. Passe os comandos 'AT' e 'AT+GMR' para testar a conexão entre o Arduino e o módulo ESP-01. Experimente configurações diferentes para a opção 'Fim de linha' do monitor serial, como NL e CR. Experimente diferentes combinações até que o módulo ESP comece a interagir corretamente com o monitor serial.
Baixe Python, PIP e ESPtool. Apague o firmware pré-carregado se o módulo ESP tiver algum. Faça o flash do código do firmware para o módulo ESP-01 escrevendo os comandos no monitor serial conforme as instruções para o ESPtool. Confira o link a seguir para escrever o comando adequado para fazer o flash do código do firmware usando o ESPtool –
Comandos ESPtool
Para fazer upload do programa, a chave RESET deve ser liberada enquanto a chave de programação GPIO0 deve ser deixada pressionada. Após carregar o código, a chave de programação também deve ser liberada. Desta forma, o código do firmware pode ser carregado no ESP8266 utilizando a placa Arduino como conversor FTDI. Deve-se observar que todo GND precisa ser comum para completar o circuito. O GPIO2 é um TX alternativo para o modo bootloader.
Remova as conexões. Agora o módulo ESP está pronto para ser instalado no circuito do projeto. No circuito do projeto, o ESP8266 é interligado com o adaptador CP2102 e o Sensor DHT-11.
O CP2102 é um chip único USB para UART Bridge. Ele é usado para fornecer energia ao módulo ESP. Ele pode ser usado para bootloading também. Um CP2102 IC tem a seguinte configuração de pinos –
Tabela de listagem da configuração de pinos do CI CP2102
Fig. 6: Tabela listando a configuração dos pinos do CI CP2102
Tabela de listagem da configuração de pinos do CI CP2102
Fig. 7: Tabela listando a configuração dos pinos do CI CP2102
Figura 8: Tabela listando a configuração dos pinos do CI CP2102
A placa ESP é conectada ao CP2102 para o modo de bootloading e propósito de uso. Para bootloading, o pino TX do ESP-01 é conectado ao pino RX do CP2102 e o pino RX do ESP é conectado ao TX do CP2102 para que ambos possam enviar e receber dados. O ESP8266-01 precisa de uma fonte de alimentação de 3,3 V, então o VCC do ESP é conectado ao 3V3 do CP2102 e os GNDs de ambos precisam ser conectados um ao outro. O pino de reset do ESP8266 junto com o resistor pull-up de 10k (resistor bootstrap) é conectado ao pino RTS do CP2102. O GPIO0 é um pino de programação que é usado para terminar o ESP-01 no modo de programação. O GPIO0 junto com o resistor pull-up de 10K é conectado ao pino DTR do CP2102. O pino CHPD do ES-01 é puxado para cima com um resistor de 10K. As conexões do circuito entre o módulo ESP e o CP2102 estão resumidas na tabela a seguir –
Tabela listando as conexões do circuito entre o modem ESP8266 ESP-01 e o CI CP2102
Fig. 9: Tabela listando as conexões do circuito entre o modem ESP8266 ESP-01 e o IC CP2102
Após conectar o módulo ESP com o adaptador CP2102, o adaptador deve ser conectado ao PC e o módulo ESP deve ser carregado com o código do firmware de maneira semelhante à demonstrada com o Arduino.
Após carregar o código, o módulo ESP acessará automaticamente o ponto Wi-Fi com o SSID fornecido no firmware. O sensor DHT-11 faz interface com o módulo ESP.
Diagrama de pinos do sensor de temperatura e umidade DHT-11
Fig. 10: Diagrama de pinos do sensor de temperatura e umidade DHT-11
O sensor DHT11 consiste em dois componentes principais – um é o componente de detecção de umidade e o outro é o sensor de temperatura NTC (ou termistor). O termistor é, na verdade, um resistor variável que muda sua resistência com a mudança de temperatura. Ambos detectam a temperatura e a umidade da área e fornecem a saída para o IC (que é colocado na parte traseira do sensor). O sensor tem quatro pinos – VCC, Ground, data Out e NC. Os pinos VCC e Ground são conectados ao VCC e Ground comuns, respectivamente. O pino Data Out do sensor é conectado ao pino GPIO2 do módulo ESP por meio de um resistor pull-up de 10K. As conexões do circuito do módulo ESP com o sensor DHT são resumidas na tabela a seguir –
Tabela listando as conexões do circuito entre o modem ESP8266 e o ​​sensor DHT-11
Fig. 11: Tabela listando as conexões do circuito entre o modem ESP8266 e o ​​sensor DHT-11
No lado do PC, o próprio Adafruit atua como Cliente. O cliente do PC deve ser atribuído com um ID de cliente exclusivo para que o broker MQTT possa identificar facilmente qual cliente está publicando e assinando o tópico e a carga útil. Saiba mais sobre como configurar o PC como Cliente MQTT no seguinte tutorial –
Como configurar PC e celular como clientes MQTT
Aprenda sobre como criar e assinar tópicos em um corretor MQTT e publicar mensagens neles no tutorial a seguir –
Comunicação entre PC e celular usando protocolo MQTT via HiveMQ Broker
Da mesma forma, os tópicos podem ser criados na corretora Adafruit e os Clientes MQTT podem se inscrever e publicar mensagens sobre esses tópicos. O corretor Adafruit é um corretor altamente escalonável e confiável. Para acessar esta corretora, o usuário precisa criar uma conta. A conta do usuário recebe uma chave de acesso privada exclusiva que pode ser usada apenas para fins individuais. Esta chave privada pode ser compartilhada apenas com clientes confiáveis ​​para que eles também possam se conectar com o corretor. Não deve ser compartilhado com nenhum cliente não confiável, caso contrário os dados também poderão ser acessados ​​por outras pessoas.
Após criar a conta, os tópicos podem ser criados. Os tópicos são chamados Feeds no ambiente Adafruit. Então, vá para feed e crie um novo feed como feed de temperatura e umidade para este projeto. Os feeds devem ser criados e registrados com o broker MQTT. Após criar os feeds, vá para dashboard e crie um novo dashboard. O dashboard serve apenas para visualizar dados. Dentro do dashboard, crie novos blocos para monitorar valores de temperatura e umidade. Com este Dashboard, as leituras de temperatura e umidade podem ser visualizadas no Browser no cliente do PC.
As seguintes precauções devem ser tomadas ao montar o circuito –
1) O ESP8266 precisa de energia de 3,3 V para funcionar, portanto não forneça 5 V.
2) Algumas pessoas dizem que o ESP8266 não tem entradas tolerantes a 5 V, mas quando o Arduino foi usado como adaptador USB para serial, ele forneceu com sucesso a comunicação serial. De acordo com a folha de dados do ESP8266, também foi escrito que os GPIOs do ESP8266 podem tolerar mais energia de até 6 V.
3) Se o erro espcomm_sync-failed.md for mostrado durante o upload do código do firmware, primeiro verifique a porta selecionada na qual o módulo ESP está conectado e depois verifique se o módulo está entrando no modo de bootloading ou não. Isso pode ser verificado conectando os pinos RX e GND do conversor aos pinos TX e GND do ESP. Em seguida, abra um terminal e verifique se a seguinte mensagem foi recebida na janela serial ou não.
ets 8 de janeiro de 2017, primeira causa: 2, modo de inicialização: (x, y).
4) Verifique se os pinos do módulo estão recebendo tensão adequada ou não usando multímetro.
5) Se o módulo estiver funcionando, mas começar a queimar depois de algum tempo, pode haver um problema de requisito atual. Nesse caso, use uma fonte de alimentação externa para fornecer 3,3 V ao ESP8266.
Protótipo do monitor de temperatura e umidade baseado em ESP8266 controlado pelo corretor Adafruit
Fig. 12: Protótipo do monitor de temperatura e umidade baseado no ESP8266 controlado pelo Adafruit Broker
Como funciona o circuito –
Após carregar o firmware e as conexões do circuito, o módulo ESP8266 está pronto para publicar dados sobre o protocolo MQTT do ponto de acesso Wi-Fi disponível. O cliente do PC também está pronto para receber valores de temperatura e umidade. Os clientes ESP8266 e PC se comunicam e enviam mensagens um ao outro por meio do broker MQTT que é o Adafruit. O Adafruit também serve como Cliente no lado do PC. No tutorial anterior, o complemento MQTTLens foi instalado no navegador Chrome para configurar o PC como Cliente MQTT. Com o Adafruit, não há necessidade de instalar nenhum complemento. O próprio Adafruit atua como Cliente no lado do PC.
O cliente ESP8266 configura como publicador para o tópico “temp” e “humidity”. O cliente PC configura como assinante para esses tópicos. O cliente ESP8266 lê os valores de temperatura e umidade do sensor DHT-11. O sensor de temperatura e umidade DHT11 é um sensor digital com sensor de umidade capacitivo e termistor integrados. Ele transmite uma leitura de temperatura e umidade em tempo real a cada 2 segundos. O sensor opera com alimentação de 3,5 a 5,5 V e pode ler temperatura entre 0 °C e 50 °C e umidade relativa entre 20% e 95%. O DHT11 detecta vapores de água medindo a resistência elétrica entre os dois eletrodos. O componente de detecção de umidade é um substrato de retenção de umidade com eletrodos aplicados à superfície. Quando os vapores de água são absorvidos pelo substrato, os íons são liberados pelo substrato, o que aumenta a condutividade entre os eletrodos. A mudança na resistência entre os dois eletrodos é proporcional à umidade relativa. Uma umidade relativa mais alta diminui a resistência entre os eletrodos, enquanto uma umidade relativa mais baixa aumenta a resistência entre os eletrodos. O DHT11 mede a temperatura com um sensor de temperatura NTC montado na superfície (Thermistor) integrado à unidade.
O Sensor DHT 11 envia dados em formato digital para o módulo ESP em protocolo one-wire que deve ser implementado no lado do firmware. Primeiro, o pino de dados é configurado para entrada e um sinal de início é enviado a ele. O sinal de início compreende um BAIXO por 18 milissegundos seguido por um ALTO por 20 a 40 microssegundos seguido por um BAIXO novamente por 80 microssegundos e um ALTO por 80 microssegundos. Depois de enviar o sinal de início, o pino é configurado para saída digital e os dados de 40 bits compostos pela leitura de temperatura e umidade são bloqueados. Dos dados de 5 bytes, os dois primeiros bytes são a parte inteira e decimal da leitura da umidade relativa, respectivamente, o terceiro e o quarto bytes são a parte inteira e decimal da leitura da temperatura e o último é o byte da soma de verificação. O protocolo one-wire é implementado no firmware usando uma biblioteca de código aberto disponível para Arduino.
Os valores lidos de temperatura e umidade são enviados como mensagens para os feeds (tópicos) “temp” e “umidade”, respectivamente. O cliente PC recebe mensagens nos feeds e as exibe no Dashboard usando blocos de temperatura e umidade.
Guia de programação –

Código fonte do projeto

###



//Program to 

/*

File Name- PC_to_ESP8266_communication_with_adafruit_broker.ino

Output pin of ESP-01

GPIO2-DHT11 sensor

*/

//Include libraries

#include                         //Include library for ESP8266 configuration   

#include "Adafruit_MQTT.h"                      //Include library for MQTT 

#include "Adafruit_MQTT_Client.h"

#include "DHT.h"                                //Include library for Temperature and humidity sensor configuration

// DHT11 or DHT22 pin and Type declaration

#define DHTPIN 2                                //DHT11 ouptput connected to ESP-01 GPIO02

#define DHTTYPE DHT11                           //DHT TYPE-DHT 11 or 22

DHT dht(DHTPIN, DHTTYPE, 15);                   //Create the instance for DHT sensor

// WiFi parameters

#define WLAN_SSID       "Replace it with the SSID of the Wi-Fi Network"                 //SSID of Home's WiFi network

#define WLAN_PASS       "Replace it with the password of the Wi-Fi Network"             //Password of Home's WiFi network

// Adafruit IO Broker Initialization

#define AIO_SERVER      "io.adafruit.com"      //Broker domain Name

#define AIO_SERVERPORT  1883                   //The port at which broker is listening

#define AIO_USERNAME    "priya22"              //The username which we have initializaed during account creation at io.adafruit.com

#define AIO_KEY         "acd65714ad7f4217a6b1c1c4815fcfa4"  //The private ley which will be alloted after creating account

//Create an ESP8266 WiFiClient class to connect to the MQTT server.

WiFiClient espclient;

// Setup the MQTT client class by passing in the WiFi client and MQTT server and login details.

Adafruit_MQTT_Client mqtt(&espclient, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);

//Create the topic to be registered on MQTT broker

//Notice MQTT paths for AIO follow the form: /feeds/

Adafruit_MQTT_Publish temp = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/temp");

Adafruit_MQTT_Publish humidity = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/humidity");

//Function declaration

void MQTT_connect ;

void setup  {

  Serial.begin(115200);                   //Start the serial communication for debugging 

  delay(10);

  dht.begin ;                           //DHT sensor initialization

  //Connect to WiFi access point.

  Serial.println ; Serial.println ;

  Serial.print("Connecting to ");

  Serial.println(WLAN_SSID);

  WiFi.begin(WLAN_SSID, WLAN_PASS);

  // Wait until the connection has been confirmed before continuing

  while (WiFi.status  != WL_CONNECTED) {

    delay(500);

      Serial.print(".");

    }

  Serial.println ;

  Serial.println("WiFi connected");

    Serial.println("IP address: "); 

  Serial.println(WiFi.localIP );

}

void loop  {

  MQTT_connect ;

  float temperature_data = 32.0; //dht.readTemperature ;     //Read the current temperature

  float humidity_data = 51.0; //dht.readHumidity ;           //Read the current humidity

 

  // Now we can publish stuff!

  Serial.print(F("nSending temperature value "));

  Serial.print(temperature_data);

  Serial.print("...");

  //Publish the temperature to the Adafruit broker

  if (! temp.publish(temperature_data)) 

  {

    Serial.println(F("Failed"));

    } else 

    {

      Serial.println(F("OK!"));

      }

    Serial.print(F("nSending Humidity value "));

    Serial.print(humidity_data);

    Serial.print("...");

    //Publish the humidity to the Adafruit broker

    if (! humidity.publish(humidity_data)) 

    {

      Serial.println(F("Failed"));

      } else 

    {

      Serial.println(F("OK!"));

      }

      delay(10000);

}

/*

Function Name- MQTT_connect 

Function to connect and reconnect as necessary to the MQTT server.

It should be called in the loop function and it will take care if connecting.

*/

 void MQTT_connect  {

  int8_t ret;

  //Stop if already connected.

  if (mqtt.connected ) {

    return;

  }

  Serial.print("Connecting to MQTT... ");

  uint8_t retries = 3;

    while ((ret = mqtt.connect ) != 0) {     // connect will return 0 for connected

       Serial.println(mqtt.connectErrorString(ret));

       Serial.println("Retrying MQTT connection in 5 seconds...");

       mqtt.disconnect ;

       delay(5000);               // wait 5 seconds

       retries--;

       if (retries == 0) {

         // basically die and wait for WDT to reset me

         while (1);

       }

  }

  Serial.println("MQTT Connected!");

}

###

Vídeo do Projeto

Conteúdo Relacionado

Voltar para o blog

Deixe um comentário

Os comentários precisam ser aprovados antes da publicação.