Introduction: Projeto IoT - Sistema Detector De Fumaça

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 a 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 Telegram 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

Step 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 usando a 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, e também fumaça ou álcool.
  • Led vermelho
  • Led verde
  • 2 Resistores 200Ω
  • Protoboard e jumpers para conexão e teste do protótipo

Step 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. 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:

  • Field 1: Concentração de gás
  • Field 2: Alarme
  • Field 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 desligar alarme em função do tempo

Leitura e escrita no ThingSpeak

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

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

Step 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 mantido 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.

Na tela de Designer é possível montar as telas do aplicativo, selecionando os componentes necessários (botões, labels, imagens, etc) no menu lateral esquerdo (Palette). Para cada um dos componentes selecionados, é possível alterar configurações de cores, tamanho, posição, entre outras no menu lateral direito (Properties).

Na tela Blocks é feita 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 request 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 é mostrado 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 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 alarme (Button1) é desabilitado.

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

Step 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 doresistor 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

Step 5: Programação Do Microcontrolador

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

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

Fluxo do setup:

  • Inicializa a porta serial
  • Inicializa os outputs (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 ultrapassa o limite definido (ideal: CO2 <= 700 ppm)
    • Liga o alarme (LED vermelho), desliga o LED de status (verde) e envia notificação pelo Telegram 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, do alarme e de comando para o ThingSpeak a cada 20 segundos

Abaixo será descrita a programação de cada um dos principais módulos com o respectivo código para teste.

Conectando na rede WiFi

Abra a IDE do Arduino, vá em File->Preferences eadicione em Additional Board Manager URLs a URL https://arduino.esp8266.com/stable/package_esp8266com_index.json.

Em seguida, vá em Tools->Boards->Boards Manager 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, copie o código abaixo, altere as variáveis para conexão WIFI listadas acima e faça upload no módulo ESP8266.

<strong>#include <ESP8266WiFi.h>  

/************************ 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 obtido: ");
  Serial.println(WiFi.localIP());
}


// Setup da placa 
void setup(){  
  Serial.begin(115200);
  delay(50);

  // Conecta ao wifi
  ConnectToWiFi();
}
</strong>

Lendo dados do sensor MQ135

Para ler os dados do sensor MQ135, primeiramente deve-se baixar a biblioteca MQ135.h e adicioná-la na IDE do Arduino através do menu Skecth->Include Library->Add .ZIP Library.

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.

<strong>#include "MQ135.h"

#define SMOKE_SENSOR A0     // IO do sensor de fumaça

float sensorValue;

// Setup da placa 
void setup(){  
    Serial.begin(115200);
    delay(50);
}

// Loop principal
void loop(){
  // Faz leitura do sensor
  MQ135 gasSensor = MQ135(SMOKE_SENSOR);
  sensorValue = gasSensor.getPPM();
  Serial.print("Concentracao de CO2 (ppm): ");
  Serial.println(sensorValue);
}</strong>


Escrevendo e lendo dados do ThingSpeak

Primeiro, adicione a Biblioteca do ThingSpeak no Arduino IDE. Vá em Tools->Boards->Boards Manager 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, copie o código abaixo, altere as variáveis para conexão na rede e as variáveis listadas acima e faça upload no módulo ESP8266.

<strong>#include <ESP8266WiFi.h>  
#include <ThingSpeak.h>

/************************ 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
#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; 

WiFiClient client;

// Função que faz a conexão wifi 
void ConnectToWiFi(void){
  // Configura root certificate 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());
}


// Setup da placa 
void setup(){  
  Serial.begin(115200);
  delay(50);

  // Conecta ao wifi
  ConnectToWiFi();

  // Inicializa ThingSpeak
  lastTime = 0; 
  ThingSpeak.begin(client);
}


// 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(value);
	
  // 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;
  }
  delay(20000);
}<br></strong>


Enviando notificação pelo Telegram

Primeiro, adicione a Biblioteca do Telegram no Arduino IDE. Vá em Tools->Boards->Boards Manager 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ê a ele um nome e nome de usuário. Se o seu bot for criado com sucesso, você receberá uma mensagem com um link para acessar o bot e o token do bot. Salve o token, porque você precisará dele para que o ESP8266 possa enviar notificações.

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

Para teste do envio de notificação pelo telegram, copie o código abaixo, altere as variáveis de definições para conexão WIFI e para comunicação com o Telegram (BOT_TOKEN e CHAT_ID) e faça upload no módulo ESP8266.

<strong>#include <WiFiClientSecure.h>
#include <ESP8266WiFi.h>  
#include <UniversalTelegramBot.h>
/********************* ALTERAR DEFINIÇÕES ABAIXO **************************/
</strong><strong>#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 telegram
#define CHAT_ID "CHANGEYOURCHATID" // ID do chat do telegram

X509List cert(TELEGRAM_CERTIFICATE_ROOT);
WiFiClientSecure clientSecure;
UniversalTelegramBot bot(BOT_TOKEN, clientSecure);

// Envia notificação ao Telegram
void SendTelegramNotification(String message) {
  bot.sendMessage(CHAT_ID, message, "");
  Serial.println(message);
}

// Função que faz a conexão wifi 
void ConnectToWiFi(void){
  // Configura root certificate 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 obtido: ");
  Serial.println(WiFi.localIP());
}

// Setup da placa 
void setup(){  
  Serial.begin(115200);
  delay(50);
  
  // Conecta ao wifi
  ConnectToWiFi();
	
  // Testa notificação pelo telegram 
  SendTelegramNotification("Testando envio de notificação.");
}<br></strong>

Attachments