Este artigo descreve a concepção e implementação de um sistema de alarme inteligente para o interior de residências, construído sobre uma plataforma de baixo custo. A arquitetura centraliza a aquisição de dados, processamento local e comunicação com a nuvem para monitoramento e alerta contínuo.

Arquitetura do Sistema

O sistema segue um modelo de três camadas. Na primeira, os módulos sensores coletam dados ambientais e de segurança. A segunda camada, baseada no microcontrolador, executa a lógica de decisão local e gerencia a comunicação. A terceira camada, a nuvem, armazena os dados, gera alertas e fornece uma interface de usuário.

Componentes de Hardware Essenciais

O núcleo do sistema utiliza um microcontrolador com conectividade Wi-Fi integrada. Sensores de gás e fumaça, como os da série MQ, são conectados a pinos analógicos para leitura de concentrações. Sensores de proximidade infravermelhos detectam presença, enquanto módulos de temperatura e umidade monitoram o clima interno. Atuadores como buzinas, LEDs indicadores e módulos relé são acionados pelo controlador para acionar alarmes locais ou equipamentos de resposta (como ventilação).

Implementação do Software

O firmware é desenvolvido em um framework de alto nível para o microcontrolador. A estrutura principal envolve a inicialização dos periféricos, conexão com a rede e com o broker MQTT, e um loop principal que orquestra as tarefas de leitura, processamento e comunicação.

Exemplo de Estrutura do Código Principal

#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>

// Definições de pinos e limiares
#define PINO_FUMACA 34
#define PINO_GAS 35
#define PINO_DHT 4
#define PINO_PIR 5
#define PINO_SIRENE 12
#define PINO_VENTILADOR 16

const char* ssid = "SUA_REDE";
const char* senha = "SUA_SENHA";
const char* servidor_mqtt = "mqtt.seubroker.com";

WiFiClient clienteWifi;
PubSubClient clienteMQTT(clienteWifi);
DHT sensorAmbiente(PINO_DHT, DHT11);

struct LeituraSensores {
    uint16_t valorFumaca;
    uint16_t valorGas;
    float temp;
    float umid;
    bool movimento;
    bool alarmeAtivo;
} leituraAtual;

void setup() {
    Serial.begin(115200);
    pinMode(PINO_SIRENE, OUTPUT);
    pinMode(PINO_VENTILADOR, OUTPUT);
    digitalWrite(PINO_SIRENE, HIGH); // Desativa sirene (lógica inversa)
    
    sensorAmbiente.begin();
    conectarWiFi();
    clienteMQTT.setServer(servidor_mqtt, 1883);
    clienteMQTT.setCallback(callbackMQTT);
}

void loop() {
    if (!clienteMQTT.connected()) {
        reconectarMQTT();
    }
    clienteMQTT.loop();
    
    // Rotina principal de 1 segundo
    static unsigned long ultimaAtualizacao = 0;
    if (millis() - ultimaAtualizacao > 1000) {
        coletarDadosSensores();
        avaliarRiscos();
        gerarAlarmeLocal();
        transmitirDados();
        ultimaAtualizacao = millis();
    }
}

Lógica de Detecção e Filtragem

Para reduzir falsos positivos, os dados brutos dos sensores passam por um filtro de média móvel. A lógica de alarme utiliza múltiplas condições; por exemplo, um alarme de incêndio pode exigir tanto a detecção de fumaça quanto uma temperatura acima do normal. A detecção de intrusão pode ser configurada para operar apenas em horários específicos.

void coletarDadosSensores() {
    // Leitura com filtro simples
    static uint16_t bufferFumaca[5] = {0};
    static uint8_t idxFumaca = 0;
    bufferFumaca[idxFumaca] = analogRead(PINO_FUMACA);
    idxFumaca = (idxFumaca + 1) % 5;
    
    uint32_t somaFumaca = 0;
    for(int i=0; i<5; i++) somaFumaca += bufferFumaca[i];
    leituraAtual.valorFumaca = somaFumaca / 5;
    
    leituraAtual.valorGas = analogRead(PINO_GAS);
    leituraAtual.temp = sensorAmbiente.readTemperature();
    leituraAtual.umid = sensorAmbiente.readHumidity();
    leituraAtual.movimento = digitalRead(PINO_PIR);
}

void avaliarRiscos() {
    const uint16_t LIMIAR_FUMACA = 1500;
    const uint16_t LIMIAR_GAS = 1200;
    const float LIMIAR_TEMP_FOGO = 60.0;
    
    bool alertaFumaca = (leituraAtual.valorFumaca > LIMIAR_FUMACA);
    bool alertaGas = (leituraAtual.valorGas > LIMIAR_GAS);
    bool alertaTemperatura = (leituraAtual.temp > LIMIAR_TEMP_FOGO);
    bool intrusaoDetectada = leituraAtual.movimento && ehHorarioNoturno();
    
    leituraAtual.alarmeAtivo = (alertaFumaca || alertaGas || intrusaoDetectada);
    // Uma condição composta poderia ser: alertaFumaca && alertaTemperatura
}

void gerarAlarmeLocal() {
    if (leituraAtual.alarmeAtivo) {
        // Acionar sirene intermitente
        static unsigned long ultimoPisca = 0;
        static bool estadoSirene = false;
        if (millis() - ultimoPisca > 500) {
            estadoSirene = !estadoSirene;
            digitalWrite(PINO_SIRENE, estadoSirene ? LOW : HIGH);
            ultimoPisca = millis();
        }
        // Acionar ventilação de emergência se for fumaça/gás
        if (leituraAtual.valorFumaca > 1500 || leituraAtual.valorGas > 1200) {
            digitalWrite(PINO_VENTILADOR, HIGH);
        }
    } else {
        digitalWrite(PINO_SIRENE, HIGH);
        digitalWrite(PINO_VENTILADOR, LOW);
    }
}

Comunicação com a Nuvem via MQTT

O protocolo MQTT é utilizado para comunicação assíncrona e leve. O dispositivo publica periodicamente os dados dos sensores em um tópico e se inscreve em outro para receber comandos remotos (como "teste de alarme" ou atualização de limiares).

void transmitirDados() {
    if (!clienteMQTT.connected()) return;
    
    // Montagem do payload JSON
    char payload[200];
    snprintf(payload, sizeof(payload),
        "{\"fumaca\":%d,\"gas\":%d,\"temp\":%.1f,\"umid\":%.1f,\"mov\":%d,\"alarme\":%d}",
        leituraAtual.valorFumaca, leituraAtual.valorGas,
        leituraAtual.temp, leituraAtual.umid,
        leituraAtual.movimento ? 1 : 0,
        leituraAtual.alarmeAtivo ? 1 : 0
    );
    
    clienteMQTT.publish("residencia/sensores/status", payload);
}

void callbackMQTT(char* topico, byte* mensagem, unsigned int comprimento) {
    String mensagemRecebida;
    for (int i = 0; i < comprimento; i++) {
        mensagemRecebida += (char)mensagem[i];
    }
    Serial.println("Comando recebido: " + mensagemRecebida);
    // Lógica para processar comandos (ex: parse JSON)
}

Considerações de Design e Otimização

O posicionamento dos sensores é crítico. Sensores de gás devem ficar próximos ao chão, enquanto os de fumaça no teto. Algoritmos de calibração em tempo de execução podem ajustar os limiares com base nas condições ambientais. Para economia de energia, em cenários com bateria, o microcontrolador pode entrar em modo de sono profundo, despertando por interrupção do sensor de movimento ou por temporizador.