Heizungssteuerung mit MicroPython auf dem ESP32 – Teil 6

Worum geht es in diesem Teil?

In diesem Teil erfährst du:

Wie du Messdaten über MQTT sendest

Messdaten senden über MQTT

Zum Schluss wollen wir die Daten noch an einen MQTT-Broker senden, um sie in Grafana oder IO-Broker darzustellen. Du brauchst einen funktionierenden MQTT-Broker, damit die folgenden Schritte funktionieren. Wie du einen MQTT-Broker mit einem Raspberry Pi aufsetzt, habe ich in diesem Tutorial beschrieben.

Wir brauchen zunächst einmal zwei weitere Module, um MQTT nutzen zu können. Du kannst sie mit upip.install("micropython-umqtt.simple2") und upip.install("micropython-umqtt.robust2") installieren. Das Herunterladen und Entpacken nimmt recht viel RAM in Anspruch. Falls du also Probleme mit der Installation hast, kannst du alles andere anhalten (ggf. indem du die main.py mit rm /pyboard/main.py löscht und später wieder neu kopierst) und die Installation dann durchführen.

Für MQTT brauchen wir noch ein paar Parameter (Host, Port und Topic). Ich habe dafür die nw_config.html erweitert (siehe nw_config_v4.html)

Anschließend erstellen wir uns eine mqtt.py, die uns mit dem MQTT-Broker verbindet:

mqtt.py view raw

import ubinascii
import machine
import sys
sys.path.reverse()
from umqtt.robust2 import MQTTClient
sys.path.reverse()

def setup(host, port):
    client_id = ubinascii.hexlify(machine.unique_id())
    client = MQTTClient(client_id, host, int(port))
    client.connect()
    return client

In der main.py rufen wir diese Funktion dann auf und senden in unserem Timer die MQTT-Botschaften:

main.py view raw

import ep_logging
import ep_wifi
import ep_config
import heater_http
import onewire
import ds18x20
import machine
import ubinascii
import statemachine
import menu
import mqtt
import gc
import _thread
import json
gc.collect()

_thread.stack_size(6144)

wifi = ep_wifi.wifi("./network_config.json", max_time_wait_for_connect=10)
wlan, ssid, bssid = wifi.connect()
ip = wlan.ifconfig()[0]

logger = ep_logging.colored_logger(appname="main")
logger.notice("WiFi connected")

logger_http = ep_logging.colored_logger(appname="http")

ow = onewire.OneWire(machine.Pin(4))
ds = ds18x20.DS18X20(ow)

ht_config = ep_config.config("ht_config.json")
ht_config.load()
thresh = ht_config.get("")

ds_config = ep_config.config("ds_config.json")
ds_config.load()
temps = ds_config.get("")
get_temp = lambda name: temps[name]["value"] if (name in temps) and ("value" in temps[name]) else 0
sm, pump_state = statemachine.setup(
    get_temp,
    lambda name: thresh.get(name, 0)
)
sm.init()
sm.step_until_stationary()

def read_temps(timer, ds, temps, sm):
    ds.convert_temp()
    for key in temps:
        temps[key]["value"] = ds.read_temp(ubinascii.unhexlify(temps[key]["id"]))
    sm.step()
    mqtt_publish()
    gc.collect()

tim_ds = machine.Timer(0)
tim_ds.init(mode=machine.Timer.PERIODIC, period=5000, callback=lambda timer: read_temps(timer, ds, temps, sm))

http_server = heater_http.setup(wlan, logger_http, ds)
http_server.start()

m = menu.setup(get_temp, sm)
m.display_funcs["print_ssid"] = lambda: "{}".format(ssid)
m.display_funcs["print_ip"] = lambda: "{}".format(ip)
m.display_funcs["print_rssi"] = lambda: "{} db".format(wlan.status("rssi")) if wlan.isconnected() else "---"

nw_config = ep_config.config("network_config.json")
nw_config.load()

mqtt_client = mqtt.setup(nw_config.get("mqtt_config/mqtt_host"), nw_config.get("mqtt_config/mqtt_port"))

def mqtt_publish():
    gc.collect()
    data = {key: temps[key]["value"] for key in temps}
    data["Pump"] = pump_state()
    data["State"] = sm.state
    data["FreeRAM"] = gc.mem_free()
    data["RSSI"] = wlan.status("rssi")
    
    s_data = json.dumps(data)
    try:
        mqtt_client.publish(nw_config.get("mqtt_config/mqtt_topic"), s_data, qos=0)
        logger.debug(s_data)
    except:
        logger.error("Could not send MQTT Data")

Zusätzlich braucht die statemachine.py noch ein kleines Update. Sie muss noch eine Funktion zurückgeben, mit der wir den Zustand der Pumpe ermitteln können:

statemachine.py view raw

...

return ep_statemachine.statemachine([s_cold, s_heatUp1, s_heatUp2, s_hot, s_toHot, s_muchToHot]), lambda: 1-pump_pin.value()

So, das wars. Unsere Steuerung ist fertig für die Montage. Im nächsten und letzten Kapitel bauen wir das Gehäuse und nehmen die Steuerung in Betrieb.

Heizungssteuerung mit MicroPython auf dem ESP32 – Teil 6

Tobias Eydam

Worum geht es in diesem Teil?

Messdaten senden über MQTT

Hinterlasse eine Antwort Antworten abbrechen

Heizungssteuerung mit MicroPython auf dem ESP32 – Teil 6

Tobias Eydam

Worum geht es in diesem Teil?

Messdaten senden über MQTT

Zum Thema passende Artikel

Heizungssteuerung mit MicroPython auf dem ESP32 – Übersicht

Smart Home Zentrale mit dem Raspberry Pi

Heizungssteuerung mit MicroPython auf dem ESP32 – Teil 4

Hinterlasse eine Antwort Antworten abbrechen