Projeto IoT - Sistema Detector De Fumaça: 5 etapas

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

Introdução

O Sistema Detector de Fumaça consiste em uma solução IoT com o objetivo de permitir o monitoramento de alarmes de incêndio de residências através de um aplicativo Android. O projeto é baseado em um microcontrolador que se comunica com uma nuvem pela rede WiFi, enviando os sinais detectados por um sensor de fumaça. O proprietário da residência consegue monitorar o sistema através de um aplicativo e recebe notificações via telegrama em caso de ativação do alarme de incêndio.

Desenvolvedores

• Bruno Gonçalves Pereira
• João Paulo Tadeu Borges Paiva
• Juliana Guimarães Soares Buére
• Willan Alexander Condor Asenjo

Etapa 1: Materiais Utilizados

Os materiais utilizados para construção do projeto foram:

• Módulo WiFi ESP8266 NodeMcu ESP-12: Placa de desenvolvimento que combina o chip ESP8266 (comunicação WiFi), uma interface USB-serial e um regulador de tensão 3.3V. A programação pode ser feita utilizando um IDE do Arduino, através da comunicação via cabo micro-usb.
• Sensor de Gás MQ-135 para Gases Tóxicos: O Sensor de Gás MQ-135 é um módulo capaz de detectar vários tipos de gases tóxicos como amônia, dióxido de carbono, benzeno, óxido nítrico, também e fumaça ou álcool.
• Led vermelho
• Led Verde
• 2 resistores 200Ω
• Protoboard e jumpers para conexão e teste do protótipo

Etapa 2: Configuração Do ThingSpeak

O ThingSpeak é um serviço de plataforma IoT para armazenar e recuperar dados usando o protocolo HTTP e MQTT pela Internet ou por meio de uma rede local. O ThingSpeak permite agregar, visualizar e analisar fluxos de dados na nuvem.

O ThingSpeak está disponível como um serviço gratuito para pequenos projetos não comerciais (menos de 3 milhões de mensagens por ano ou aproximadamente 8000 mensagens por dia). Para projetos maiores ou aplicações comerciais, quatro tipos diferentes de licença anual são oferecidos: Standard, Academic, Student and Home.

Configuração de um canal no ThingSpeak

Após criar uma conta no ThingSpeak, é necessário criar um canal. Os canais armazenam os dados enviados de um determinado projeto. Cada canal inclui 8 campos que podem conter qualquer tipo de dados, mais 3 campos para dados de localização e 1 para dados de status. Depois de coletar dados em um canal, você pode usar os aplicativos ThingSpeak para analisá-los e visualizá-los.

Para este projeto, foi criado um canal com nome IoTProject-SmokeDetector e 3 campos para envio de dados:

• Campo 1: Concentração de gás
• Campo 2: Alarme
• Campo 3: Comando desligar

Na aba "Private View" é possível criar as visualizações de cada um dos campos criados. Neste projeto, foram criados:

• 1 gráfico com os dados de concentração de gás CO2 em função do tempo
• 1 indicador de led para indicação de alarme
• 1 gráfico com os dados de comando de desligamento de alarme em função do tempo

Leitura e escrita no ThingSpeak

O canal do ThingSpeak é criado com um identificador único (ID do canal) que possibilita sua identificação para envio e leitura de dados. Na aba "API Keys" são disponibilizadas como chaves para escrita (Write API Key) e leitura (Read API Key) de dados no canal. Além disso, também são disponibilizados como API Requests (HTTP get requests) que também podem ser usados para envio e requisição de dados.

O identificador do canal e as chaves utilizadas posteriormente no código do microcontrolador. Já as solicitações de API serão utilizadas na programação do aplicativo Android.

Etapa 3: Aplicativo - MIT App Inventor

O aplicativo para monitoramento do sistema foi desenvolvido utilizando o MIT App Inventor. O MIT App Inventor é um ambiente web gratuito e de código aberto para desenvolvimento integrado de aplicativos mantidos pelo Massachusetts Institute of Technology (MIT). Ele permite que iniciantes na programação criem aplicativos para Android e iOS.

Para começar, após criar uma conta no MIT App Inventor, criou-se um projeto com o nome IotProject_SmokeDetector.

A tela de Designer é possível montar como telas de aplicativo, componentes de base (botões, rótulos, imagens, etc) no menu esquerdo lateral (Paleta). Para cada um dos componentes selecionados, é possível alterar configurações de cores, tamanho, posição, entre outras no menu direito lateral (Propriedades).

Os blocos de tela são feitos toda a lógica de programação do aplicativo. A programação é feita através de blocos, facilitando o desenvolvimento para iniciantes.

Explicação do código

Duas variáveis locais são inicializadas: alarmData e sensorData.

A cada 1 segundo (definido pelo Clock1), o aplicativo faz um pedido de dados no canal ThingSpeak através da URL de leitura de dados que pode ser copiada na aba "API Keys". Quando os dados são retornados, o dado do sensor correspondente à concentração de gás CO2 é visível na tela do aplicativo. Já o dado do alarme é testado:

1. Se o alarme estiver acionado (alarmData = 1), o aplicativo mostra ao usuário a mensagem "Atenção! Sua casa está em perigo!" e o botão de desligar o alarme (Button1) é habilitado.
2. Se o alarme não estiver acionado (alarmData = 0), o aplicativo mostra ao usuário a mensagem "Não se preocupe! Sua casa não está em perigo." e o botão de desligar o alarme (Button1) é desabilitado.

Quando o botão de desligar alarme (Botão1) para clicado, o aplicativo escreverá 1 no campo Campo3: comando desligar criado no ThingSpeak, indicando que o comando de desligar foi acionado. O dado é enviado ao ThingSpeak através da URL para escrita de dados que pode ser copiada na aba "API Keys".

Etapa 4: Montagem do Protótipo

O protótipo foi montado no protoboard conforme indicado na figura.

Sensor MQ135

• Pino AO: conectado ao pino AD0 do módulo ESP8266
• Pino GND: conectado ao GND do módulo ESP8266
• Pino Vcc: conectado ao pino VIN do módulo ESP8266

LED verde

• Conectar uma perna do resistor de 200Ω no pino D5 do módulo ESP8266
• Conectar o anodo do LED (positivo - maior perna) na outra perna do resistor
• Conectar o catodo do LED (negativo - menor perna) no GND do módulo ESP8266

LED vermelho

• Conectar uma perna doristor de 200Ω no pino D7 do módulo ESP8266.
• Conectar o anodo do LED (positivo - maior perna) na outra perna do resistor
• Conectar o catodo do LED (negativo - menor perna) no GND do módulo ESP8266

Etapa 5: Programação Do Microcontrolador

O microcontrolador do módulo ESP8266 foi programado utilizando um IDE do Arduino (faça o download aqui).

O código fonte completo usado no projeto pode ser baixado no final deste tutorial (Iot_project.ino). O código tem duas funções principais: configuração e loop.

Fluxo do setup:

• Inicializa a porta serial
• Inicialização de saídas (pinos dos leds)
• Conecta à rede WiFi
• Inicializa o ThingSpeak

Fluxo do loop:

• Lê os dados do sensor MQ135

• Verifica se a concentração de gás CO2 além do limite definido (ideal: CO2 <= 700 ppm)

  • Liga o alarme (LED vermelho), desliga o LED de status (verde) e envia notificação pelo Telegrama se o valor estiver acima do limite
  • Desliga o alarme (LED vermelho) e liga o LED de status (verde) se o valor estiver abaixo do limite

• Lê o dado de "comando desligar alarme" do ThingSpeak

  Se o comando = 1, desliga o alarme (LED vermelho) e liga o LED de status (verde)

• Envia dados do sensor, alarme e de comando para o ThingSpeak a cada 20 segundos

Abaixo será necessário a programação de cada um dos principais componentes com o respectivo código para teste.

Conectando na rede WiFi

Abra a IDE do Arduino, vá em Arquivo-> Preferências eadicione em URLs adicionais do gerenciador de placa a URL

Em seguida, vá em Ferramentas-> Quadros-> Gerenciador de Quadros digite ESP8266, clique em instalar e fechar.

É necessário definir 2 variáveis para conexão na rede:

• WIFI_SSID: nome da rede WiFi que você deseja conectar seu sistema
• WIFI_PASSWORD: senha da rede

Para teste de conexão WiFi, cópia ou código abaixo, altere as variáveis para conexão WIFI listados acima e faça upload no módulo ESP8266.

#include / ************************ ALTERE AS DEFINIÇÕES ABAIXO ******************* ******* / #define WIFI_SSID "YOUR WIFI SSID" // Nome da rede wifi #define WIFI_PASSWORD "YOUR WIFI PASSWORD" // Senha da rede wifi WiFiClient client; // Função que faz a conexão wifi void ConnectToWiFi (void) {// Tenta conectar ao wifi Serial.println ("Conectando à rede WiFi"); WiFi.begin (WIFI_SSID, WIFI_PASSWORD); while (WiFi.status ()! = WL_CONNECTED) {delay (500); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi conectado com sucesso!"); Serial.println ("IP convencionais:"); Serial.println (WiFi.localIP ()); } // Configuração da placa void setup () {Serial.begin (115200); atraso (50); // Conecta ao wifi ConnectToWiFi (); }

Lendo dados do sensor MQ135

Para ler os dados do sensor MQ135, deve-se primeiro baixar uma biblioteca MQ135.h e adicionar a IDE do Arduino através do menu Skecth-> Incluir Biblioteca-> Adicionar Biblioteca. ZIP.

Depois, copie o código abaixo e faça upload no módulo ESP8266 através do cabo micro-usb. O código realiza a leitura da concentração de CO2 em ppm e imprime os valores lidos no serial monitor.

#include "MQ135.h" #define SMOKE_SENSOR A0 // IO do sensor de fumaça float sensorValue; // Configuração da placa void setup () {Serial.begin (115200); atraso (50); } // Loop principal void loop () {// Faz leitura do sensor MQ135 gasSensor = MQ135 (SMOKE_SENSOR); sensorValue = gasSensor.getPPM (); Serial.print ("Concentração de CO2 (ppm):"); Serial.println (sensorValue); }

Escrevendo e lendo dados do ThingSpeak

Primeiro, dedicada a Biblioteca do ThingSpeak no Arduino IDE. Vá em Ferramentas-> Quadros-> Gerenciador de Quadros digite ThingSpeak, clique em instalar e fechar.

A versão gratuita do ThingSpeak, aceita upload de dados apenas a cada 20 segundos, por isso, no código deve-se testar se o momento correto de enviar os dados.

Para comunicar com o ThingSpeak é necessário definir as variáveis abaixo:

• myChannelNumber: número do canal criado no ThingSpeak
• myWriteAPIKey: chave de escrita do canal do ThingSpeak
• myReadAPIKey: chave de leitura do canal do ThingSpeak

Para teste de comunicação com o ThingSpeak, cópia do código abaixo, altere as variáveis para a conexão na rede e as variáveis listadas acima e faça upload no módulo ESP8266.

#include #include / ************************ ALTERE AS DEFINIÇÕES ABAIXO ***************** ********* / #define WIFI_SSID "YOUR WIFI SSID" // Nome da rede wi-fi #define WIFI_PASSWORD "YOUR WIFI PASSWORD" // Senha da rede wifi #define THINGSPEAK_WRITE_INTERVAL 20000 // Intervalo em ms entre envios de dados ao ThingSpeak / ************************* ALTERE AS VARIÁVEIS ABAIXO ******************* ******** / unsigned long myChannelNumber = 0000000; // Número do canal do ThingSpeak const char * myWriteAPIKey = "your write api key"; // Chave de escrita do canal do ThingSpeak const char * myReadAPIKey = "your read api key"; // Chave de leitura do canal do ThingSpeak unsigned long lastTime; unsigned long currentTime; Cliente WiFiClient; // Função que faz uma conexão wi-fi void ConnectToWiFi (void) {// Configura o certificado raiz para api.telegram.org configTime (0, 0, "pool.ntp.org"); clientSecure.setTrustAnchors (& cert); // Tenta conectar ao wifi Serial.println ("Conectando à rede WiFi"); WiFi.begin (WIFI_SSID, WIFI_PASSWORD); while (WiFi.status ()! = WL_CONNECTED) {delay (500); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi conectado com sucesso!"); Serial.println (WiFi.localIP ()); } // Configuração da placa void setup () {Serial.begin (115200); atraso (50); // Conecta ao wifi ConnectToWiFi (); // Inicializa ThingSpeak lastTime = 0; ThingSpeak.begin (cliente); } // Loop principal void loop () {currentTime = millis (); // seta o tempo atual // Lê dados do ThingSpeak int value = ThingSpeak.readIntField (myChannelNumber, 1, myReadAPIKey); Serial.println ("Dado no campo 1 do ThingSpeak:"); Serial.println (valor); // Verifica se é o momento de enviar dados ao ThingSpeak if ((currentTime - lastTime> THINGSPEAK_WRITE_INTERVAL)) {ThingSpeak.setField (1, 100); ThingSpeak.writeFields (myChannelNumber, myWriteAPIKey); lastTime = currentTime; } atraso (20000); }

Enviando notificação pelo Telegram

Primeiro, dedicada a Biblioteca do Telegram no Arduino IDE. Vá em Ferramentas-> Placas-> Gerenciador de Placas digite UniversalTelegramBot, clique em instalar e fechar.

Abra o Telegram e siga as próximas etapas para criar um Bot. Primeiro, procure por botfather e clique nele. A janela a seguir deve abrir e você será solicitado a clicar no botão Iniciar. Digite / newbot e siga as instruções para criar seu bot. Dê um nome de usuário e um nome de usuário. Se o seu bot para criado com sucesso, você receberá uma mensagem com um link para acessar o bot e o token do bot. Salve o token, porque você deseja dele para que o ESP8266 possa enviar notificações.

Em seguida, em sua conta do Telegram, pesquise IDBot. Inicia uma conversa com esse bot e digite / getid. Você receberá uma resposta com seu ID de usuário. Salve o ID, porque você deseja dele para enviar de notificações.

Para teste de envio de notificação pelo telegrama, cópia do código abaixo, altere como variáveis de definição para conexão WIFI e para comunicação com o Telegrama (BOT_TOKEN e CHAT_ID) e faça upload no módulo ESP8266.

#include #include #include / ********************* ALTERAR DEFINIÇÕES ABAIXO ******************** ******* / #define WIFI_SSID "YOUR WIFI SSID" // Nome da rede wifi #define WIFI_PASSWORD "YOUR WIFI PASSWORD" // Senha da rede wifi #define BOT_TOKEN "CHANGEYOURTOKEN" // Token do bot do telegrama # define CHAT_ID "CHANGEYOURCHATID" // ID do chat do telegrama X509List cert (TELEGRAM_CERTIFICATE_ROOT); WiFiClientSecure clientSecure; Bot UniversalTelegramBot (BOT_TOKEN, clientSecure); // Envia notificação ao Telegram void SendTelegramNotification (String message) {bot.sendMessage (CHAT_ID, message, ""); Serial.println (mensagem); } // Função que faz uma conexão wi-fi void ConnectToWiFi (void) {// Configura o certificado raiz para api.telegram.org configTime (0, 0, "pool.ntp.org"); clientSecure.setTrustAnchors (& cert); // Tenta conectar ao wifi Serial.println ("Conectando à rede WiFi"); WiFi.begin (WIFI_SSID, WIFI_PASSWORD); while (WiFi.status ()! = WL_CONNECTED) {delay (500); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi conectado com sucesso!"); Serial.println ("IP convencionais:"); Serial.println (WiFi.localIP ()); } // Configuração da placa void setup () {Serial.begin (115200); atraso (50); // Conecta ao wifi ConnectToWiFi (); // Testa notificação pelo telegram SendTelegramNotification ("Testando envio de notificação."); }