openWB Forum

Code: Alles auswählen

import requests
import paho.mqtt.client as mqtt
import logging
from datetime import datetime

# --- Logging ---
LOGFILE = "/var/log/openwb_heater.log"
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    handlers=[
        logging.FileHandler(LOGFILE),
        logging.StreamHandler()
    ]
)

# --- OpenEMS-Einstellungen ---
openems_url = "http://IP:8084/rest/channel/ctrlGridOptimizedCharge0/DelayChargeMaximumChargeLimit"
openems_username = "x"
openems_password = "user"
openems_base = "http://IP:8084"  # Basis-URL für REST-Channels

# --- Heizstab-/SOC-Parameter ---
SOC_THRESHOLD = 25          # Mindest-SOC für manuelles Einschalten
MIN_SOC_AUTO_MODE = 10      # Unterhalb dieses SOC -> sofort Automatik (auch vor AUTO_MODE_TIME)
MANUEB_POWER = 4000         # Leistung für den Heizstab im manuellen Modus

# --- Zeit-Parameter (einstellbar) ---
# Manuell-EIN nur im Fenster [HEATER_ON_START, HEATER_ON_END)  (Ende exklusiv)
HEATER_ON_START_HOUR = 5
HEATER_ON_START_MIN = 0
HEATER_ON_END_HOUR = 7
HEATER_ON_END_MIN = 0

# Ab dieser Uhrzeit wird zurück auf AUTOMATIK gestellt (>= AUTO_MODE_TIME)
AUTO_MODE_HOUR = 7
AUTO_MODE_MIN = 0

# --- Zeitfenster & Limits für adjust_value (parametrisierbar) ---
# Jedes Element: ((start_h, start_m), (end_h, end_m), cap_value)
CAP_RULES = [
    ((0, 0),   (10, 0),  1000),   # 00:00–09:59 -> max 1000
    ((10, 1),  (12, 0),  5000),   # 10:01–11:59 -> max 5000
    ((12, 1),  (18, 0),  30000),  # 12:01–17:59 -> max 30000
    ((18, 1),  (24, 0),  2000),   # 18:01–23:59 -> max 2000
]

# --- MQTT-Einstellungen ---
mqtt_broker_ip = "localhost"
mqtt_topic = "openWB/set/LegacySmartHome/config/get/maxBatteryPower"  # bestehender Publish

# --- Hilfsfunktionen ---
def get_openems_channel_value(channel: str):
    url = f"{openems_base}/rest/channel/{channel}"
    try:
        response = requests.get(url, auth=(openems_username, openems_password))
        response.raise_for_status()
        data = response.json()
        return data.get("value")
    except requests.exceptions.RequestException as e:
        logging.error(f"Fehler beim Abrufen des Channels {channel}: {e}")
        return None

def _minutes_since_midnight(dt: datetime) -> int:
    return dt.hour * 60 + dt.minute

def _in_window(now: datetime, start_h: int, start_m: int, end_h: int, end_m: int) -> bool:
    now_min = _minutes_since_midnight(now)
    start = start_h * 60 + start_m
    end = end_h * 60 + end_m
    if start <= end:
        return start <= now_min < end
    else:
        # Fenster über Mitternacht
        return now_min >= start or now_min < end

# --- paho-mqtt 1.x-kompatible Callbacks ---
def on_connect(client, userdata, flags, rc):
    logging.info(f"MQTT verbunden, rc={rc}")

def on_publish(client, userdata, mid):
    logging.info(f"MQTT Publish bestätigt, MID={mid}")

def get_openems_value():
    """Liest den Wert vom in openems_url konfigurierten Channel."""
    try:
        response = requests.get(openems_url, auth=(openems_username, openems_password))
        response.raise_for_status()
        data = response.json()
        return data["value"]
    except requests.exceptions.RequestException as e:
        logging.error(f"Fehler beim Abrufen des OpenEMS-Werts: {e}")
        return None

def send_mqtt_message(topic, value):
    """Einfacher One-shot Publish (connect → publish → disconnect)."""
    try:
        client = mqtt.Client()  # keine CallbackAPIVersion → kompatibel zu paho 1.x
        client.on_connect = on_connect
        client.on_publish = on_publish
        client.connect(mqtt_broker_ip, 1883, keepalive=30)
        client.loop_start()
        res = client.publish(topic, str(value))
        res.wait_for_publish()
        client.loop_stop()
        client.disconnect()
    except Exception as e:
        logging.error(f"Fehler beim Senden an {topic}: {e}")

def _cap_for_now(now: datetime):
    for (sh, sm), (eh, em), cap in CAP_RULES:
        if _in_window(now, sh, sm, eh, em):
            return cap
    return None

def adjust_value(value):
    now = datetime.now()
    cap = _cap_for_now(now)
    if cap is None:
        return value
    return min(value, cap)

# --- Hauptlogik ---

# 1) Wert abrufen und anpassen
value = get_openems_value()
if value is None:
    value = 0
    logging.warning("Kein Wert von OpenEMS erhalten. Standardwert 0 verwendet.")
else:
    logging.info(f"OpenEMS-Wert: {value}")

adjusted_value = adjust_value(value)
logging.info(f"Angepasster Wert: {adjusted_value}")

# 2) MaxBatteryPower senden
send_mqtt_message(mqtt_topic, adjusted_value)

# 3) Heizstab-Steuerung
soc = get_openems_channel_value("battery0/Soc")
if soc is None:
    logging.warning("SOC konnte nicht gelesen werden – Heizstab bleibt aus.")
else:
    logging.info(f"SOC: {soc}%")
    now = datetime.now()

    in_on_window = _in_window(
        now,
        HEATER_ON_START_HOUR, HEATER_ON_START_MIN,
        HEATER_ON_END_HOUR, HEATER_ON_END_MIN
    )

    # 3a) Manuell EIN nur im Zeitfenster und bei ausreichendem SOC
    if in_on_window and soc > SOC_THRESHOLD:
        logging.info("Bedingungen erfüllt (SOC>Schwelle & im Einschalt-Zeitfenster) → Heizstab MANUELL EIN")
        send_mqtt_message("openWB/set/LegacySmartHome/config/set/Devices/9/device_manual_control", 1)
        send_mqtt_message("openWB/set/LegacySmartHome/config/set/Devices/9/mode", 1)
        send_mqtt_message("openWB/set/LegacySmartHome/config/set/Devices/9/manueb", MANUEB_POWER)

    # 3b) Zurück in Automatik, wenn Zeit >= AUTO_MODE_TIME ODER SOC < MIN_SOC_AUTO_MODE
    elif (_minutes_since_midnight(now) >= (AUTO_MODE_HOUR * 60 + AUTO_MODE_MIN)) or (soc < MIN_SOC_AUTO_MODE):
        logging.info("Bedingungen erfüllt (Zeit >= Auto-Mode oder SOC < Min-SOC) → Heizstab AUTOMATIK")
        send_mqtt_message("openWB/set/LegacySmartHome/config/set/Devices/9/device_manual_control", 0)

    else:
        logging.info("Bedingungen nicht erfüllt (SOC/Zeitraum) – keine Aktion.")