Um computador de 10 g que faz uma coisa só, o dia inteiro.

#!/usr/bin/env python3
"""Nó MQTT móvel: detecta sensores, publica e guarda leituras offline."""
import glob, json, socket, sqlite3, time, tomllib

import paho.mqtt.client as mqtt
from smbus2 import SMBus, i2c_msg

CFG = tomllib.load(open("/boot/firmware/node.toml", "rb"))
M, N = CFG["mqtt"], CFG.get("node", {})


def cpu_serial():
    for line in open("/proc/cpuinfo"):
        if line.startswith("Serial"):
            return line.split(":")[1].strip()[-8:]
    return socket.gethostname()


NODE_ID = N.get("name") or f"zero-{cpu_serial()}"
BASE = f'{M.get("base", "nodes")}/{NODE_ID}'

DB = sqlite3.connect("/var/lib/node-agent/outbox.db", isolation_level=None)
DB.execute("PRAGMA journal_mode=WAL")
DB.execute("CREATE TABLE IF NOT EXISTS outbox (id INTEGER PRIMARY KEY, topic TEXT, payload TEXT)")

bus = SMBus(1)

# ---------- sensores ----------

def present(addr):
    try:
        bus.read_byte(addr)
        return True
    except OSError:
        return False


def read_bme280(addr):
    import bme280  # pacote RPi.bme280
    cal = bme280.load_calibration_params(bus, addr)
    d = bme280.sample(bus, addr, cal)
    # BMP280 no mesmo endereço não mede umidade; ignore esse campo se for o caso
    return {"temperatura": round(d.temperature, 2),
            "umidade": round(d.humidity, 1),
            "pressao": round(d.pressure, 1)}


def read_sht31(addr):
    bus.write_i2c_block_data(addr, 0x2C, [0x06])   # medição única, alta repetibilidade
    time.sleep(0.02)
    msg = i2c_msg.read(addr, 6)
    bus.i2c_rdwr(msg)
    d = list(msg)
    t = -45 + 175 * (d[0] << 8 | d[1]) / 65535
    h = 100 * (d[3] << 8 | d[4]) / 65535
    return {"temperatura": round(t, 2), "umidade": round(h, 1)}


def read_bh1750(addr):
    bus.write_byte(addr, 0x20)                     # uma leitura, alta resolução
    time.sleep(0.2)
    msg = i2c_msg.read(addr, 2)
    bus.i2c_rdwr(msg)
    d = list(msg)
    return {"luz": round((d[0] << 8 | d[1]) / 1.2, 1)}


I2C = {0x76: ("bme280", read_bme280), 0x77: ("bme280", read_bme280),
       0x44: ("sht31", read_sht31), 0x23: ("bh1750", read_bh1750)}


def detect():
    return [(name, addr, fn) for addr, (name, fn) in I2C.items() if present(addr)]


def read_ds18b20():
    out = {}
    for path in glob.glob("/sys/bus/w1/devices/28-*/temperature"):
        sid = path.split("/")[-2][-4:]
        try:
            out[f"ds18b20_{sid}"] = {"temperatura": int(open(path).read()) / 1000}
        except (OSError, ValueError):
            pass
    return out


def read_system():
    temp = int(open("/sys/class/thermal/thermal_zone0/temp").read()) / 1000
    rssi = None
    for line in open("/proc/net/wireless").readlines()[2:]:
        if line.strip().startswith("wlan0"):
            rssi = float(line.split()[3].rstrip("."))
    up = float(open("/proc/uptime").read().split()[0])
    return {"cpu_temp": round(temp, 1), "wifi_rssi": rssi, "uptime_h": round(up / 3600, 1)}


def read_gps():
    try:
        with socket.create_connection(("127.0.0.1", 2947), timeout=3) as s:
            s.sendall(b'?WATCH={"enable":true,"json":true}\n')
            f = s.makefile()
            for _ in range(20):
                msg = json.loads(f.readline())
                if msg.get("class") == "TPV" and msg.get("mode", 0) >= 2:
                    return {"lat": msg["lat"], "lon": msg["lon"],
                            "vel_kmh": round(msg.get("speed", 0) * 3.6, 1)}
    except (OSError, ValueError, KeyError):
        pass
    return {}

# ---------- fila offline ----------

def enqueue(topic, payload):
    DB.execute("INSERT INTO outbox (topic, payload) VALUES (?, ?)", (topic, json.dumps(payload)))
    DB.execute("DELETE FROM outbox WHERE id <= (SELECT MAX(id) - 50000 FROM outbox)")


def flush():
    rows = DB.execute("SELECT id, topic, payload FROM outbox ORDER BY id LIMIT 500").fetchall()
    for rid, topic, payload in rows:
        info = client.publish(topic, payload, qos=1)
        try:
            info.wait_for_publish(timeout=5)
        except Exception:
            return
        if not info.is_published():
            return
        DB.execute("DELETE FROM outbox WHERE id = ?", (rid,))

# ---------- Home Assistant ----------

META = {"temperatura": ("°C", "temperature"), "umidade": ("%", "humidity"),
        "pressao": ("hPa", "pressure"), "luz": ("lx", "illuminance"),
        "cpu_temp": ("°C", "temperature"), "wifi_rssi": ("dBm", "signal_strength"),
        "uptime_h": ("h", None), "vel_kmh": ("km/h", "speed")}


def announce(readings):
    dev = {"identifiers": [NODE_ID], "name": NODE_ID,
           "model": "Raspberry Pi Zero W", "manufacturer": "DIY"}
    for sensor, values in readings.items():
        for metric in values:
            unit, dclass = META.get(metric, (None, None))
            cfg = {"name": f"{sensor} {metric}",
                   "unique_id": f"{NODE_ID}_{sensor}_{metric}",
                   "state_topic": f"{BASE}/{sensor}",
                   "value_template": f"{{{{ value_json.{metric} }}}}",
                   "availability_topic": f"{BASE}/status",
                   "state_class": "measurement",
                   "device": dev}
            if unit:
                cfg["unit_of_measurement"] = unit
            if dclass:
                cfg["device_class"] = dclass
            client.publish(f"homeassistant/sensor/{NODE_ID}/{sensor}_{metric}/config",
                           json.dumps(cfg), qos=1, retain=True)

# ---------- MQTT ----------

state = {"announced": False}

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id=NODE_ID)
client.username_pw_set(M["user"], M["password"])
if M.get("tls", True):
    client.tls_set()
client.will_set(f"{BASE}/status", "offline", qos=1, retain=True)
client.reconnect_delay_set(min_delay=2, max_delay=120)


def on_connect(c, userdata, flags, reason_code, properties):
    if not reason_code.is_failure:
        c.publish(f"{BASE}/status", "online", qos=1, retain=True)
        state["announced"] = False
        print("conectado ao broker", flush=True)


client.on_connect = on_connect
client.connect_async(M["host"], M.get("port", 8883), keepalive=60)
client.loop_start()

# ---------- laço principal ----------

sensors, cycle = [], 0
while True:
    if cycle % 30 == 0:
        sensors = detect()
        print("sensores I2C:", [f"{n}@{a:#x}" for n, a, _ in sensors], flush=True)
    cycle += 1

    readings = {"sistema": read_system()}
    for name, addr, fn in sensors:
        try:
            readings[f"{name}_{addr:02x}"] = fn(addr)
        except OSError as e:
            print("falha na leitura", name, e, flush=True)
    readings.update(read_ds18b20())
    if CFG.get("gps", {}).get("enabled"):
        g = read_gps()
        if g:
            readings["gps"] = g

    ts = int(time.time())
    for sensor, values in readings.items():
        enqueue(f"{BASE}/{sensor}", {**values, "ts": ts})

    if client.is_connected():
        if not state["announced"]:
            announce(readings)
            state["announced"] = True
        flush()

    time.sleep(N.get("interval", 60))