Heizungssteuerung mit MicroPython auf dem ESP32 – Teil 6

What is this part about?

In this part you will learn:

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 this 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") and 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 the 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.

Heating control with MicroPython on the ESP32 - Part 6

Tobias Eydam

What is this part about?

Messdaten senden über MQTT

Leave A Reply Cancel reply

Heating control with MicroPython on the ESP32 - Part 6

Tobias Eydam

What is this part about?

Messdaten senden über MQTT

Related Articles

Weather station with SolidCircuit HV3

Heating control with MicroPython on the ESP32 - Part 3

MicroPython: Configuring WiFi with a Simple HTTP Server - Part 2

Leave A Reply Cancel reply