Projeto de Automação — Primeiro Andar (Raspberry Pi 4 Central)
Resumo Executivo
Documento técnico que descreve um sistema de automação para um primeiro andar com
9 cômodos, centralizado em um Raspberry Pi 4. O sistema integra dispositivos Zigbee,
dispositivos Wi-Fi (Shelly/Sonoff), sensores de movimento, câmeras e pontos de acesso.
Inclui diagrama de blocos, código Python de referência para execução no Raspberry Pi
(simulado), procedimentos de implantação e testes para defesa técnica.
Lista de Materiais (Bill of Materials)
1 × Raspberry Pi 4 Model B (4GB/8GB) + fonte 5V/3A
1 × MicroSD 32GB (Raspbian / Raspberry Pi OS)
1 × Dongle Zigbee (ConBee II ou CC2531) ou coordinator baseado em USB
1 × Dongle Wi-Fi (se necessário) / Access Point
4–9 × Sensores PIR / Sensores de presença
4–9 × Sensores magnéticos para portas/janelas (opcional)
3–6 × Câmeras IP (ou Raspberry Pi Camera Modules)
Vários × Relés (sonoff/shelly/relés DIN) para cargas (luzes, cortinas, portão)
1 × Servidor MQTT (Mosquitto) instalado no Raspberry Pi
Cabo Ethernet, fontes para câmeras, caixas de distribuição, fusíveis
Ferramentas de instalação e acessórios de montagem
Diagrama de Blocos
Figura 1 — Diagrama de alto nível do sistema (usado para explicar arquitetura na
defesa).
Visão Técnica do Sistema
Topologia: O Raspberry Pi 4 atua como controlador central, executando serviços críticos:
- Broker MQTT (Mosquitto)
- Serviços de ponte Zigbee (Zigbee2MQTT ou deCONZ)
- Serviços de captura/streaming para câmeras (RTSP / Picamera2)
- Aplicação em Python que unifica lógica de automação, regras e integrações
Comunicação: Zigbee para sensores e atuadores locais de baixa potência; Wi-Fi/MQTT
para dispositivos Shelly/Sonoff e câmeras; HTTP/REST e WebSocket para interface
web/mobile.
Suposições e Escopo
• O projeto cobre 9 cômodos (ex.: 5 quartos, 2 salas, cozinha, corredor) — cada cômodo
pode ter iluminação e um sensor.
• Uso de Zigbee para dispositivos de baixa potência e Wi-Fi para atuadores/relés que já
possuem firmware MQTT/HTTP.
• A conexão de câmeras será via RTSP ou captura direta com Picamera (se câmeras
forem módulos Pi).
• O código fornecido é uma referência pronta para executar num Raspberry Pi com as
dependências adequadas instaladas.
Código Python — Servidor Central (exemplo)
Nota: o código abaixo é uma implementação de referência. Em produção, trate
autenticação, segurança de rede, controle de acesso, logging e tratamento de exceções
mais detalhado.
# main_controller.py
# Requisitos (exemplos):
# sudo apt update && sudo apt install -y mosquitto mosquitto-clients
# pip3 install paho-mqtt gpiozero picamera2 opencv-python
#
# Estrutura:
# - Usa MQTT como barramento central
# - Recebe eventos de sensores Zigbee via Zigbee2MQTT (publica em tópicos)
# - Controla atuadores via MQTT/HTTP (Shelly/Sonoff) ou GPIO (relés locais)
# - Faz gravação/alerta quando sensor de presença detecta movimento
import time
import json
import threading
from datetime import datetime
import paho.mqtt.client as mqtt
# Configurações
MQTT_BROKER = "localhost"
MQTT_PORT = 1883
MQTT_USER = None
MQTT_PASS = None
BASE_TOPIC = "home/primeiro_andar"
# Mapas de dispositivos (exemplo)
LIGHTS = {
"sala1": f"{BASE_TOPIC}/lights/sala1/set",
"quarto1": f"{BASE_TOPIC}/lights/quarto1/set",
# ... até 9 cômodos
}
PIRS = {
"sala1": f"{BASE_TOPIC}/sensor/pir/sala1",
"quarto1": f"{BASE_TOPIC}/sensor/pir/quarto1",
}
CAMERAS = {
"sala1": "rtsp://192.168.1.101:554/stream",
# ou use indices de picamera
}
# Funções utilitárias
def log(msg):
print(f"{datetime.now().isoformat()} - {msg}")
# MQTT callbacks
def on_connect(client, userdata, flags, rc):
log(f"MQTT conectado com rc={rc}")
# Subscrever tópicos de sensores
client.subscribe(f"{BASE_TOPIC}/sensor/+/+")
client.subscribe(f"{BASE_TOPIC}/zigbee/#")
def on_message(client, userdata, msg):
topic = msg.topic
payload = msg.payload.decode('utf-8')
log(f"MQTT message: {topic} -> {payload}")
try:
data = json.loads(payload)
except Exception:
data = payload
# Exemplo: PIR trigger
if topic.startswith(f"{BASE_TOPIC}/sensor/pir/"):
room = topic.split("/")[-1]
handle_pir_event(room, data)
# Zigbee events (via Zigbee2MQTT)
if topic.startswith(f"{BASE_TOPIC}/zigbee/"):
# parse conforme payload do Zigbee2MQTT
pass
def handle_pir_event(room, data):
# data pode ser booleano ou dict com 'occupancy'
occupied = False
if isinstance(data, dict):
occupied = data.get("occupancy", False) or data.get("contact", False)
else:
# payload 'ON' / 'OFF' ou '1'/'0'
occupied = str(data).lower() in ("1","true","on")
log(f"PIR {room} -> occupied={occupied}")
if occupied:
# acende luz por 5 minutos e grava câmera
topic = LIGHTS.get(room)
if topic:
mqtt_client.publish(topic, json.dumps({"state":"ON"}))
# publicar evento para UI / histórico
mqtt_client.publish(f"{BASE_TOPIC}/events",
json.dumps({"event":"motion","room":room,"time":datetime.now().isoformat()}))
# exemplo: iniciar captura curto (delegar a thread)
threading.Thread(target=capture_snapshot, args=(room,)).start()
else:
# apagar luz após tempo ou deixar lógica de economia
pass
def capture_snapshot(room):
# Exemplo simples: salvar snapshot via ffmpeg/RTSP ou Picamera2
cam = CAMERAS.get(room)
if not cam:
return
filename = f"/tmp/{room}_{int(time.time())}.jpg"
# Usar ffmpeg para snapshot (assume ffmpeg instalado)
import subprocess
cmd = ["ffmpeg", "-rtsp_transport","tcp","-i", cam, "-frames:v","1",
filename, "-y", "-loglevel","error"]
try:
subprocess.run(cmd, timeout=15, check=True)
log(f"Snapshot salvo: {filename}")
# publicar localização do snapshot
mqtt_client.publish(f"{BASE_TOPIC}/camera/{room}/snapshot",
json.dumps({"file": filename, "time": datetime.now().isoformat()}))
except Exception as e:
log(f"Falha snapshot {room}: {e}")
# Inicializa MQTT
mqtt_client = mqtt.Client()
if MQTT_USER:
mqtt_client.username_pw_set(MQTT_USER, MQTT_PASS)
mqtt_client.on_connect = on_connect
mqtt_client.on_message = on_message
mqtt_client.connect(MQTT_BROKER, MQTT_PORT, 60)
# Loop principal (iniciar cliente MQTT)
try:
mqtt_client.loop_start()
log("Controller rodando. Pressione CTRL+C para sair.")
while True:
time.sleep(1)
except KeyboardInterrupt:
log("Encerrando...")
mqtt_client.loop_stop()
mqtt_client.disconnect()
Procedimentos de Implantação
1. Preparar Raspberry Pi OS no microSD e configurar acesso SSH e Wi-Fi.
2. Instalar Mosquitto: sudo apt install -y mosquitto mosquitto-clients
3. Instalar Docker (opcional) e Zigbee2MQTT/DeCONZ, ou usar ConBee II direto.
4. Configurar Zigbee2MQTT para publicar tópicos em home/primeiro_andar/zigbee/...
5. Configurar câmeras para RTSP e verificar acesso por ffmpeg.
6. Transferir main_controller.py para /opt/automation/ e criar serviço systemd:
/etc/systemd/system/automation.service (ExecStart=/usr/bin/python3
/opt/automation/main_controller.py)
7. Testar sensores e atuadores; validar latência e confiabilidade.
Procedimentos de Teste e Pontos para a Defesa
- Teste 1: Detecção de movimento e acionamento de luz (simular PIR com jumper ou
publicar MQTT manualmente).
- Teste 2: Snapshot de câmera após detecção; demonstrar arquivo salvo e tópico MQTT
publicado.
- Teste 3: Controle de cortina/relé via tópico MQTT (ON/OFF) e demonstração no UI.
- Pontos para defesa: segurança (TLS para MQTT), isolamento de rede (VLAN para
IoT), backup de configurações de Zigbee, escalabilidade (migrar Mosquitto para
container se necessário).
Anexo — Recomendações de Ligação e Segurança
• Separe circuitos de iluminação e tomadas em disjuntores apropriados.
• Nunca alimente relés diretamente do GPIO sem driver; use optoacopladores ou módulos
de relé com alimentação separada.
• Configure acesso SSH com chave pública; desabilite senha para o usuário pi.
• Habilite firewall local (ufw) e restrinja portas MQTT/SSH à rede interna ou VPN.
