Nó sensor Raspberry Pi Zero 2 W com MQTT: compacto, econômico e confiável

Um nó Raspberry Pi Zero 2 W MQTT coloca um computador Linux completo no tamanho de um chiclete, o que o torna ideal para nós sensores que precisam de Python, TLS e acesso remoto, mas não de uma placa de tamanho normal. Neste guia você vai configurar um Zero 2 W sem monitor (headless), reduzir seu consumo, ler um sensor ambiental BME280 e publicar as leituras e a saúde do dispositivo via MQTT 5, com a blindagem necessária para rodar sem supervisão por meses.

Por que o Zero 2 W é um bom nó sensor

O Zero 2 W tem um Arm Cortex-A53 quad-core de 64 bits, 512 MB de RAM, Wi-Fi 2,4 GHz e Bluetooth, além do conector GPIO padrão de 40 pinos. Isso basta para rodar Python, paho-mqtt com TLS e alguns sensores com bastante folga, consumindo visivelmente menos energia que um Pi 4 ou Pi 5.

Mas ele não é um microcontrolador. Não consegue entrar em deep sleep entre as leituras e dá boot no Linux a partir de um cartão SD. Se o seu nó precisa funcionar com bateria por meses, o ESP32 é a ferramenta melhor; nossa comparação Raspberry Pi vs ESP32 explica esse equilíbrio. O Zero 2 W brilha onde há energia da rede ou USB e você valoriza ferramentas Linux, acesso SSH e Python mais do que o último miliwatt.

Lista de materiais

Configuração headless com Raspberry Pi OS Lite

Use o Raspberry Pi Imager para gravar o Raspberry Pi OS Lite (64 bits). Nas opções avançadas, defina o hostname, habilite o SSH com chave pública, informe sua rede Wi-Fi e o país e crie seu usuário. A imagem Lite não tem desktop, o que economiza RAM, gravações no armazenamento e energia. Ligue o Zero, aguarde um minuto e conecte:

ssh pi@zero-node-01.local
sudo apt update && sudo apt full-upgrade -y
sudo raspi-config nonint do_i2c 0
sudo apt install -y python3-venv i2c-tools

Lembre que o Zero 2 W suporta apenas Wi-Fi 2,4 GHz. Se ele nunca aparecer na rede, verifique se o seu access point transmite na banda de 2,4 GHz e se o país do Wi-Fi está configurado corretamente.

Reduzindo o consumo e o desgaste do cartão SD

Adicione estas linhas a /boot/firmware/config.txt e reinicie:

# Disable Bluetooth if you do not need it
dtoverlay=disable-bt
# Turn off the activity LED
dtparam=act_led_trigger=none

Depois mantenha o journal do sistema na RAM para que os logs de rotina não desgastem o cartão SD:

sudo mkdir -p /etc/systemd/journald.conf.d
printf "[Journal]\nStorage=volatile\nRuntimeMaxUse=16M\n" | \
  sudo tee /etc/systemd/journald.conf.d/volatile.conf
sudo systemctl restart systemd-journald
sudo systemctl disable --now bluetooth hciuart 2>/dev/null || true

Uma configuração de energia é um compromisso deliberado. A economia de energia do Wi-Fi reduz o consumo, mas pode atrasar pacotes de entrada o suficiente para causar timeouts de keepalive e reconexões. Se aparecerem desconexões frequentes nos logs, desative-a com sudo iw wlan0 set power_save off e torne a mudança permanente pelo NetworkManager. Para um nó que só publica, deixar a economia ativa costuma funcionar bem.

Ligando o BME280

Execute i2cdetect -y 1. O sensor deve aparecer no endereço 0x76 ou 0x77. Anote qual; o script usa 0x76 como padrão.

Instalando o ambiente Python

mkdir -p ~/node && cd ~/node
python3 -m venv .venv
source .venv/bin/activate
pip install "paho-mqtt>=2.0" adafruit-circuitpython-bme280

O script Raspberry Pi Zero 2 W MQTT

Este script usa MQTT 5 para que cada leitura possa carregar um intervalo de expiração de mensagem: se um assinante com sessão persistente ficar offline por mais de cinco minutos, as leituras antigas são descartadas em vez de entregues com atraso. Ele também publica uma mensagem de saúde com temperatura da CPU, sinal do Wi-Fi e uptime, algo valiosíssimo quando o nó estiver escondido dentro de um armário. Salve como node.py:

#!/usr/bin/env python3
"""Pi Zero 2 W sensor node: BME280 + health metrics over MQTT 5."""
import json
import os
import time
import uuid

import board
import paho.mqtt.client as mqtt
from adafruit_bme280 import basic as adafruit_bme280
from paho.mqtt.packettypes import PacketTypes
from paho.mqtt.properties import Properties

BROKER = os.getenv("MQTT_HOST", "broker.connectmq.com")
PORT = int(os.getenv("MQTT_PORT", "1883"))
USERNAME = os.getenv("MQTT_USERNAME")
PASSWORD = os.getenv("MQTT_PASSWORD")
CLIENT_ID = os.getenv("MQTT_CLIENT_ID", f"zero2w-{uuid.uuid4().hex[:8]}")
PREFIX = os.getenv("MQTT_PREFIX", "connectmq/demo/4b9e27/zero-node-01")
INTERVAL = int(os.getenv("PUBLISH_INTERVAL", "60"))
BME_ADDRESS = int(os.getenv("BME280_ADDRESS", "0x76"), 16)

i2c = board.I2C()
bme = adafruit_bme280.Adafruit_BME280_I2C(i2c, address=BME_ADDRESS)

expiry = Properties(PacketTypes.PUBLISH)
expiry.MessageExpiryInterval = 300


def cpu_temp():
    with open("/sys/class/thermal/thermal_zone0/temp") as f:
        return round(int(f.read()) / 1000, 1)


def wifi_rssi():
    try:
        with open("/proc/net/wireless") as f:
            for line in f:
                if line.strip().startswith("wlan0:"):
                    return float(line.split()[3].rstrip("."))
    except (OSError, ValueError, IndexError):
        pass
    return None


def uptime_s():
    with open("/proc/uptime") as f:
        return int(float(f.read().split()[0]))


def on_connect(client, userdata, flags, reason_code, properties):
    if reason_code.is_failure:
        print(f"Connection refused: {reason_code}")
        return
    print(f"Connected as {CLIENT_ID}")
    client.publish(f"{PREFIX}/status", "online", qos=1, retain=True)


client = mqtt.Client(
    mqtt.CallbackAPIVersion.VERSION2,
    client_id=CLIENT_ID,
    protocol=mqtt.MQTTv5,
)
client.on_connect = on_connect
client.will_set(f"{PREFIX}/status", "offline", qos=1, retain=True)
client.reconnect_delay_set(min_delay=2, max_delay=120)
if USERNAME:
    client.username_pw_set(USERNAME, PASSWORD)
if PORT == 8883:
    client.tls_set()

client.connect(BROKER, PORT, keepalive=60)
client.loop_start()

try:
    while True:
        now = int(time.time())
        reading = {
            "temperature": round(bme.temperature, 2),
            "humidity": round(bme.relative_humidity, 1),
            "pressure": round(bme.pressure, 1),
            "ts": now,
        }
        health = {
            "cpu_temp": cpu_temp(),
            "rssi": wifi_rssi(),
            "uptime": uptime_s(),
            "ts": now,
        }
        client.publish(f"{PREFIX}/env", json.dumps(reading), qos=1, properties=expiry)
        client.publish(f"{PREFIX}/health", json.dumps(health), qos=0, properties=expiry)
        print(reading, health)
        time.sleep(INTERVAL)
except KeyboardInterrupt:
    pass
finally:
    client.publish(f"{PREFIX}/status", "offline", qos=1, retain=True).wait_for_publish(2)
    client.loop_stop()
    client.disconnect()

Teste em primeiro plano com python node.py e acompanhe de outra máquina:

mosquitto_sub -h broker.connectmq.com -p 1883 -i watch-4b9e27 -V mqttv5 \
  -t 'connectmq/demo/4b9e27/#' -v

O servidor MQTT público gratuito suporta MQTT 5 e serve para essa verificação, mas tudo nele pode ser lido publicamente, então use um prefixo aleatório como 4b9e27 e reserve-o para testes e protótipos.

Rodando sem supervisão

Um nó sensor só é útil se voltar sozinho depois de uma queda de energia ou de um travamento. Crie /etc/systemd/system/sensor-node.service:

[Unit]
Description=Zero 2 W MQTT sensor node
After=network-online.target
Wants=network-online.target

[Service]
User=pi
WorkingDirectory=/home/pi/node
EnvironmentFile=/home/pi/node/node.env
ExecStart=/home/pi/node/.venv/bin/python node.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Coloque as configurações de conexão em /home/pi/node/node.env e restrinja o acesso com chmod 600:

MQTT_HOST=broker.connectmq.com
MQTT_PORT=8883
MQTT_USERNAME=YOUR_USERNAME
MQTT_PASSWORD=YOUR_PASSWORD
MQTT_CLIENT_ID=YOUR_CLIENT_ID
MQTT_PREFIX=site1/office/zero-node-01

Habilite com sudo systemctl enable --now sensor-node. Para saber mais sobre arquivos de serviço e logs, veja como executar um script Python MQTT na inicialização.

Atualizando nós em campo

Mesmo com o nó fixado na parede, você vai querer alterar o código dele. Mantenha a aplicação em um repositório git e atualize com git pull seguido de sudo systemctl restart sensor-node via SSH. Como as configurações de conexão ficam em node.env e não no script, o mesmo código roda em todos os nós e só o arquivo de ambiente muda. Antes de enviar uma alteração para todos os nós, teste em um e acompanhe os topics health e status dele por um dia. Um nó que para de publicar mensagens de saúde mas continua mostrando online geralmente está travado em uma leitura de sensor, sinal de que vale adicionar timeouts no acesso ao hardware.

Checklist de blindagem

1. Use uma fonte oficial ou de alta qualidade; execute vcgencmd get_throttled e espere throttled=0x0.
2. Mantenha o journal na RAM e evite gravar arquivos no loop de publicação.
3. Habilite o watchdog de hardware com RuntimeWatchdogSec=15 em /etc/systemd/system.conf para que um kernel travado reinicie.
4. Monte o BME280 em um cabo curto, afastado da placa; o Zero aquece o ar ao redor.
5. Publique dados de saúde e defina o last will para que o topic de status mostre offline quando o nó desaparecer.
6. Use TLS e credenciais por dispositivo antes de o nó sair da sua bancada.

Escalando para muitos nós

Um Zero 2 W é um projeto; vinte deles são uma frota. Dê a cada nó suas próprias credenciais e client ID, um topic previsível como site1/<room>/<node>/env e a mesma imagem. Um broker MQTT gerenciado elimina a necessidade de rodar e proteger seu próprio servidor. Com o ConnectMQ, o client ID de cada nó fica vinculado às suas credenciais, a visão de dispositivos do portal lista os nós pela hierarquia de topics e uma regra de alerta por limite pode avisar quando um ambiente fica úmido demais. O plano Serverless (Free) permite até 25 conexões, o que cobre uma pequena frota mais um dashboard.

Se preferir sensores mais simples, o guia Raspberry Pi DS18B20 com MQTT funciona sem alterações no Zero 2 W, e o tutorial de MQTT com Raspberry Pi cobre os fundamentos de publish e subscribe por trás deste nó.

Comece a usar o ConnectMQ

Coloque seus nós Zero 2 W em um broker MQTT na nuvem que eles alcancem de qualquer rede. Cadastre-se gratuitamente no ConnectMQ, sem cartão de crédito, crie um broker e cole o username, a senha e o client ID gerados em node.env. Seu nó se conecta via TLS na porta 8883 com MQTT 5, e cada leitura aparece no explorador de topics ao vivo.

Perguntas frequentes

Um Raspberry Pi Zero 2 W pode funcionar com bateria?

Só por períodos curtos, porque ele não entra em deep sleep e consome energia continuamente. Para longa autonomia, use um microcontrolador como o ESP32 e reserve o Zero 2 W para locais com alimentação.

512 MB de RAM bastam para um nó sensor MQTT?

Sim. Um script Python com paho-mqtt, TLS e uma biblioteca de sensor usa uma pequena fração disso no Raspberry Pi OS Lite, sobrando espaço para um segundo serviço.

Por que meu Zero 2 W fica desconectando do MQTT?

As causas mais comuns são fonte fraca, sinal de 2,4 GHz ruim ou economia de energia do Wi-Fi agressiva. Verifique vcgencmd get_throttled, o RSSI na mensagem de saúde e experimente desativar o power save.

O Zero 2 W suporta MQTT 5?

Sim. O MQTT 5 é um recurso da biblioteca cliente, e o paho-mqtt 2.x o suporta por completo, incluindo expiração de mensagens e user properties.