Com a recente evolução de tecnologias de comunicação sem fio de longo alcance e que demandam baixíssimo consumo energético, surgiram muitas soluções no contexto de Internet das Coisas. Tal evolução deu uma nova perspectiva, alcance e aplicabilidade às soluções já existentes. O monitoramento de gases inflamáveis é uma destas soluções que ganharam ainda mais alcance e aplicabilidade com as novas tecnologias de comunicação sem fio, uma vez que este pode ser aplicado em locais cada vez mais distantes de sua central de monitoramento, consumindo pouquíssima energia elétrica para estabelecer a comunicação.
O monitoramento de gases inflamáveis é algo de extrema importância, tanto em ambiente industrial quanto residencial, uma vez que a presença de gases inflamáveis no ambiente – juntamente a outros fatores, como fogo, faíscas, etc. – pode levar a incêndios e até explosões.
Neste artigo, é mostrado o projeto de uma solução de monitoramento de gases inflamáveis que utiliza SigFox como conectividade. A solução é capaz de detectar a presença de alguns tipos de gases inflamáveis e também fumaça no ar, avisando de sua detecção via conectividade SigFox. Para maior didática, o projeto utiliza Arduino, porém é facilmente portável para qualquer outra plataforma.
Kit RedFox
Este projeto faz uso do kit de desenvolvimento RedFox, de autoria do engenheiro Luiz Henrique Corrêa Bernardes. O kit de desenvolvimento, vendido junto com o livro “IoT SigFox com Edukit Redfox”, escrito pelo mesmo autor, permite o uso da rede IoT SigFox a partir de um Arduino Nano para programação e como “modem” SigFox um microcontrolador HT32SX, do fabricante nacional HT Micron. Dessa forma, este é um dos poucos kits de desenvolvimento de excelência feitos em grande parte com material nacional. Ainda, o kit conta com 1 ano de conectividade SigFox de forma gratuita, permitindo que você avalie o uso do SigFox em seu protótipo.
Figura 1 – Kit de desenvolvimento RedFox
O kit exige o uso de um Arduino Nano para que o usuário faça a programação do projeto / solução. Isso torna o uso do kit muito simples, pois é possível programá-lo de forma idêntica a um Arduino comum.
Material necessário
Para realizar o projeto, você precisará de:
- Um kit de desenvolvimento RedFox;
- Um Arduino Nano V3 (e seu respectivo cabo USB de alimentação / programação);
- Um sensor MQ-2 (sensor de gases inflamáveis e fumaça);
- Uma barra de pinos fêmea 1×40;
- Jumpers macho-macho e macho-fêmea;
- Protoboard de 400 pontos;
- Material para solda (ferro de solda ou estação de solda, estanho, sugador, etc.).
Visão geral – projeto
O projeto aqui abordado possui o seguinte funcionamento:
- Antes de funcionar, aguardar o tempo necessário para aquecimento do sensor (burn-in time);
- Monitorar, a cada segundo, a existência de gases inflamáveis e/ou fumaça no ar;
- Em caso de detecção de gases inflamáveis e/ou fumaça no ar, imediatamente avisar a situação, via mensagem SigFox;
- Em casos comuns (sem alarmes, ou seja, sem a detecção de gases inflamáveis e/ou fumaça no ar), deve ser enviada a cada 30 minutos, via mensagem pelo SigFox, uma mensagem informando que não há detecção de gases inflamáveis e fumaça.
As mensagens são recebidas no backend SigFox, onde podem, de acordo com a necessidade da solução aplicada, serem encaminhadas automaticamente de lá para outro sistema em nuvem (para um e-mail, planilha eletrônica ou para uma plataforma IoT, por exemplo).
Circuito esquemático
O circuito esquemático da solução pode ser visto na figura 2.
Importante: o circuito esquemático apresentado faz referência às ligações no Arduino Nano que é soquetado no kit RedFox. Logo, é preciso soldar a barra de pinos fêmea na placa RedFox (em ambos terminais espelhados do Arduino Nano, localizados nas laterais).
Figura 2 – Circuito esquemático do projeto
MQ-2 – Visão geral do sensor
O sensor MQ-2 é capaz de detectar no ar a presença de fumaça e, além disso, os seguintes gases inflamáveis (com faixa de concentração detectável entre 300 ppm e 10.000 ppm):
- GLP;
- Metano;
- Propano;
- Butano;
- Hidrogênio;
- Álcool;
- Gás Natural
Para fins de prototipação, é recomendado utilizar um módulo com o sensor já integrado. O módulo pode ser visto na figura 3.
Figura 3 – Módulo com o sensor MQ-2
O módulo possui somente 4 terminais, o que faz com que a interligação com microcontroladores seja bem simples. Essa característica fez dele uma opção muito popular de módulo-sensor para detecção de gases inflamáveis e/ou fumaça no ar. As especificações elétricas do módulo com o sensor MQ-2 podem ser vistas abaixo:
- Tensão de operação: 5V;
- Sensibilidade ajustável via potenciômetro;
- Disponibiliza duas formas de saída: digital e analógica (de 0V a 5V).
Registro do transceiver SigFox na rede SigFox
Para utilizar a rede SigFox, antes é preciso registrar o transceiver SigFox à referida rede. No caso do kit RedFox, o procedimento para realizar o registro encontra-se em: https://www.newtoncbraga.com.br/arquivos/edukit_redfox_ativacao.pdf.
Uma vez que o transceiver esteja registrado na rede SigFox, você possuirá acesso ao backend SigFox (https://backend.sigfox.com/). O backend SigFox é um portal, onde você poderá gerenciar os seus dispositivos, mensagens dos dispositivos, redirecionamentos automáticos de mensagens e muito mais. Tanto a infraestrutura física da rede quanto toda a parte de backend é mantida pela empresa SigFox e seus distribuidores autorizados.
Visão geral – backend SigFox
Uma vez possuindo seus transceivers devidamente registrados na rede SigFox e estando logado no backend SigFox, é possível gerenciar no portal tudo a respeito da comunicação SigFox e posteriores redirecionamentos das mensagens recebidas dos seus transceivers.
Como exemplo, observe a figura 4. Nesta figura, são mostradas informações do transceiver SigFox utilizado neste projeto, incluindo: localização geográfica aproximada do transceiver, distância aproximada do transceiver a base station que recebeu a mensagem SigFox e qualidade da recepção (quanto mais longe da base station, ou quanto pior for a cobertura SigFox na localização do transceiver, pior fica a qualidade de recepção).
Figura 4 – informações gerais do transceiver SigFox
Outra informação muito interessante, possível de se obter no backend SigFox é o sumário das mensagens recebidas, conforme mostra a figura 5. Aqui, várias informações muito úteis relativas às mensagens enviadas pelo transceiver podem ser extraídas, incluindo todos os bytes do payload da mensagem enviada (raw message), quais base-stations receberam a mensagem enviada pelo transceiver, quais as frequências de recepção e SNR.
Figura 5 – informações gerais de cada mensagem enviada pelo transceiver
Código-fonte do projeto
O código-fonte completo do projeto pode ser visto abaixo. A programação e gravação do Arduino Nano deve ser feita utilizando a Arduino IDE (utilize sempre a versão mais recente disponível).
| /* Programa: monitoramento de gases inflamaveis via conectividade SigFox
* Autor: Pedro Bertoleti * Data: Outubro/2021 * Hardware utilizado: kit RedFox */ #include <SoftwareSerial.h> /* Definições gerais relativas aos sensores */ #define GPIO_MQ2 6 #define GAS_INFLAMAVEL_NAO_DETECTADO 0x00 #define GAS_INFLAMAVEL_DETECTADO 0x01 #define ESCREVE_DEBUG_SENSORES /* Definição – breathing light */ #define TEMPO_BREATHING_LIGHT 500 //ms /* Definição – tempo para aauecimento (burn-in time) do sensor MQ-2 */ #define TEMPO_BURNIN_MQ2 180 //s (3 minutos) /* Definições – comandos AT para o HT32SX */ #define CMD_AT_HT32SX_RESET “AT+RESET;” #define CMD_AT_HT32SX_RCZ2 “AT+CFGRCZ=2;” #define CMD_AT_HT32SX_MANDA_BYTES “AT+SEND=0:” //sem downlink #define CMD_AT_HT32SX_ENTRA_DEEP_SLEEP “AT+DEEPSLEEP;” #define CMD_AT_HT32SX_SAI_DEEP_SLEEP “AT+WKP;” /* Definições – tempo entre envios SigFox */ #define TEMPO_ENTRE_ENVIOS_SIGFOX 1800000 /* 1800000ms = 30 minutos */ /* Definições – GPIOs usados na comunicação com HT32SX*/ #define RESET 4 /* Reset no HT32SX */ #define TX 2 /* Serial TX (Nano -> HT32SX) */ #define RX 3 /* Serial RX (Nano <- HT32SX) */ /* Definição – GPIO do LED */ #define LED 13 /* Definições – baudrates das comunicações seriais */ #define BAUDRATE_SERIAL_DEBUG 115200 #define BAUDRATE_SERIAL_HT32SX 9600 /* Objeto para controle da software serial (para comunicação Nano <-> HT32SX */ SoftwareSerial serial_HT32SX(RX, TX); /* Variáveis globais */ unsigned long timestamp_medicao_gas; unsigned long timestamp_envio_sigfox; unsigned long timestamp_breathing_light; char sensor_gas = GAS_INFLAMAVEL_NAO_DETECTADO; bool led_aceso = false; char comando_at_envio_sigfox[20] = {0}; bool alarme_gases_inflamaveis_enviado = false; /* Protótipos */ void hardware_reset_HT32SX(void); void envia_comando_AT_HT32SX(char * pt_comando); unsigned long diferenca_tempo(unsigned long tref); void aguarda_e_mostra_recepcao_HT32SX(void); void envia_mensagem_sigfox(void); /* Função: reseta (via hardware) o HT32SX * Parâmetros: nenhum * Retorno: nenhum */ void hardware_reset_HT32SX(void) { digitalWrite(RESET, HIGH); delay(1000); digitalWrite(RESET, LOW); delay(100); } /* Função: envia comando AT para o HT32SX * Parâmetros: ponteiro para string de comando * Retorno: nenhum */ void envia_comando_AT_HT32SX(char * pt_comando) { char cmd_buffer[50] = {0}; memcpy(cmd_buffer, pt_comando, strlen(pt_comando)); serial_HT32SX.write(cmd_buffer, strlen(cmd_buffer)); serial_HT32SX.flush(); } /* Função: calcula a diferença entre instante atual e * uma referência de tempo * Parâmetros: referência de tempo * Retorno: diferença de tempo calculada */ unsigned long diferenca_tempo(unsigned long tref) { return (millis() – tref); } /* Função: aguarda recepcao de dados do HT32SX * pela UART * Parâmetros: nenhum * Retorno: nenhum */ void aguarda_e_mostra_recepcao_HT32SX(void) { unsigned long timestamp_recepcao_serial; char c;
timestamp_recepcao_serial = millis();
while(diferenca_tempo(timestamp_recepcao_serial) <= 3000) { if (serial_HT32SX.available()) { c = serial_HT32SX.read(); Serial.print(c); } } } /* Função: envia mensagem via SigFox * Parâmetros: nenhum * Retorno: nenhum */ void envia_mensagem_sigfox(void) { /* Acorda HT32SX, faz a configuração da zona de comunicação e envia mensagem SigFox */ envia_comando_AT_HT32SX(CMD_AT_HT32SX_SAI_DEEP_SLEEP); aguarda_e_mostra_recepcao_HT32SX(); hardware_reset_HT32SX(); aguarda_e_mostra_recepcao_HT32SX(); envia_comando_AT_HT32SX(CMD_AT_HT32SX_RCZ2); aguarda_e_mostra_recepcao_HT32SX(); /* Formata e envia comando AT */ memset(comando_at_envio_sigfox, 0x00, sizeof(comando_at_envio_sigfox)); sprintf(comando_at_envio_sigfox, “%s%02x;”, CMD_AT_HT32SX_MANDA_BYTES, (unsigned char)sensor_gas); #ifdef ESCREVE_DEBUG_SENSORES Serial.print(“Comando AT: “); Serial.println(comando_at_envio_sigfox); #endif
envia_comando_AT_HT32SX(comando_at_envio_sigfox); aguarda_e_mostra_recepcao_HT32SX();
/* HT32SX entra em modo sleep novamente */ envia_comando_AT_HT32SX(CMD_AT_HT32SX_ENTRA_DEEP_SLEEP); aguarda_e_mostra_recepcao_HT32SX(); } void setup() { int contador_segundos_burnin_mq2;
/* Inicializa as comunicações seriais */ Serial.begin(BAUDRATE_SERIAL_DEBUG); serial_HT32SX.begin(BAUDRATE_SERIAL_HT32SX); Serial.println(“SigFox – monitor de gases inflamaveis e fumaca”); Serial.println(“Aguarde 3 minutos para o burn-in time do sensor MQ-2…”); /* Inicializa GPIOs */ pinMode(RESET, OUTPUT); digitalWrite(RESET, HIGH); pinMode(LED, OUTPUT); digitalWrite(LED, LOW); pinMode(GPIO_MQ2, INPUT); /* Reseta HT32SX via hardware, via software e configura zona para RCZ2*/ hardware_reset_HT32SX(); delay(8000); envia_comando_AT_HT32SX(CMD_AT_HT32SX_ENTRA_DEEP_SLEEP); contador_segundos_burnin_mq2 = 0; while (contador_segundos_burnin_mq2 < TEMPO_BURNIN_MQ2) { Serial.print(“Tempo restante: “); Serial.print(TEMPO_BURNIN_MQ2 – contador_segundos_burnin_mq2); Serial.println(“s”); contador_segundos_burnin_mq2++; delay(1000); }
/* Inicializa temporização da medição de: * – Leitura do sensor MQ-2 * – Envio SigFox * – Breathing light */ timestamp_medicao_gas = millis(); timestamp_envio_sigfox = millis(); timestamp_breathing_light = millis(); } void loop() { char c;
/* Escreve mensagens recebidas da UART com o HT32SX */ if (serial_HT32SX.available()) { c = serial_HT32SX.read(); Serial.print(c); } /* Pisca breathing light */ if (diferenca_tempo(timestamp_breathing_light) >= TEMPO_BREATHING_LIGHT) { if (led_aceso == false) { digitalWrite(LED, HIGH); led_aceso = true; } else { digitalWrite(LED, LOW); led_aceso = false; }
timestamp_breathing_light = millis(); } /* Faz a leitura do sensor MQ-2 a cada segundo */ if (diferenca_tempo(timestamp_medicao_gas) >= 1000) { /* Le sensor de gás MQ-2. Se houver gás inflamável detectado, força o envio de uma mensagem. */ if (digitalRead(GPIO_MQ2) == HIGH) { sensor_gas = GAS_INFLAMAVEL_DETECTADO; if (alarme_gases_inflamaveis_enviado == false) { envia_mensagem_sigfox(); alarme_gases_inflamaveis_enviado = true; timestamp_envio_sigfox = millis(); } } else { sensor_gas = GAS_INFLAMAVEL_NAO_DETECTADO; alarme_gases_inflamaveis_enviado = false; } #ifdef ESCREVE_DEBUG_SENSORES if (sensor_gas == GAS_INFLAMAVEL_DETECTADO) { Serial.println(“Gas inflamavel: detectado!”); } else Serial.println(“Gas inflamavel: nada detectado”);
Serial.println(“——“); #endif timestamp_medicao_gas = millis(); } /* Verifica se é o momento de enviar medições via SigFox */ if (diferenca_tempo(timestamp_envio_sigfox) >= TEMPO_ENTRE_ENVIOS_SIGFOX) { envia_mensagem_sigfox(); timestamp_envio_sigfox = millis(); } } |
Teste do projeto
Para testar o projeto, basta que seu transceiver SigFox esteja registrado na referida rede (conforme abordado no tópico Registro do transceiver SigFox na rede SigFox). Você poderá ver as mensagens recebidas no backend SigFox, conforme abordado no tópico Visão geral – backend SigFox.
Este projeto está programado para enviar mensagens a cada 30 minutos em caso de ausência de gases inflamáveis e/ou fumaça no ar e, em caso da presença destes, uma mensagem (em caráter emergencial) é enviada imediatamente.
O payload (raw message) das mensagens conterá apenas 1 byte, podendo ser igual a:
- 0x00: Nenhum gás inflamável e/ou fumaça detectados no ar;
- 0x01: Detecção de gás inflamável e/ou fumaça detectados no ar (mensagem enviada em caráter emergencial.
Próximos passos
Como próximos passos, as sugestões são:
- Utilizar o recurso chamado Message Callback, presente no backend SigFox. O recurso permite, dentre outras coisas, redirecionar automaticamente as mensagens recebidas no backend SigFox para onde quer que você deseja: e-mail, planilha eletrônica, plataforma IoT (incluindo integração direta com grandes players do mercado, como AWS e Microsoft Azure), etc. Leia mais sobre isso no link da documentação do SigFox: https://build.sigfox.com/backend-callbacks-and-api
- Acrescentar mais sensores ao monitoramento, uma vez que este projeto fez uso de apenas 1 byte dentre os 12 bytes disponíveis para o payload da mensagem. Exemplos de grandezas muito interessantes de serem monitoradas: pressão barométrica, temperatura ambiente, umidade relativa do ar e concentração de dióxido de carbono (em ppm) no ar.
- Acrescentar sinalização sonora e luminosa ao projeto, visando alertar as pessoas próximas ao dispositivo da detecção de gases inflamáveis e/ou fumaça no ar e, permitindo que evacuem o local em segurança.
