Beiträge von bjoernschiffer

/*
  ===============================================
  ★ Automatische Heizungsmischerregelung mit Shelly Mischerregelung V4.2 ★
  ===============================================

  Dieses Script regelt einen Heizungsmischer (z. B. über einen Shelly 2PM Gen3)
  basierend auf einer gemessenen Vorlauftemperatur und dem Zustand einer Umwälzpumpe.
  Die Pumpe selbst wird durch einen separaten Shelly (z. B. Shelly 1PM) geschaltet,
  dessen Status regelmäßig per HTTP abgefragt wird.

  ✔ Ziel: Steuern der Heizleistung durch Öffnen/Schließen des Mischers
  ✔ Sicherheitsmechanismen für Übertemperatur und Pumpenausfall
  ✔ Steuerung per Impulsbetrieb oder absolute Positionierung
  ✔ Ausfallsicherheit bei WLAN-/Shelly-Fehlern

  === FUNKTIONSÜBERSICHT ===

  1. **Pumpe AUS**:
     - Mischer fährt auf 0 % (vollständig geschlossen)
     - Keine weitere Regelung, bis Pumpe wieder an

  2. **Pumpe EIN**:
     - Mischer fährt auf definierte Startposition (`startPosition`, z. B. 45 %)
     - Danach Regelung gemäß Temperatur und Hysterese

  3. **Temperaturregelung** (alle 15 Sekunden):
     - Ist-Temperatur wird ausgelesen (`tempSensorKey`)
     - Bei zu kalt → Mischer öffnen (Impuls)
     - Bei zu warm → Mischer schließen (Impuls)
     - Im Zielbereich → keine Aktion

  4. **Überhitzungsschutz**:
     - Wenn `safetyTemp` überschritten wird (z. B. 45 °C)
     → Mischer fährt auf `safetyPosition` (z. B. 30 %)

  5. **Pumpen-Shelly nicht erreichbar (WLAN weg / Shelly defekt)**:
     - Nach Ablauf von `pumpTimeoutMs` (z. B. 2 Minuten)
     → Mischer fährt **einmalig auf 0 % (Failsafe-Stellung)** → keine Heizenergie
     - Wenn Shelly wieder erreichbar → Mischer fährt automatisch zurück auf `startPosition`

  ===============================================
*/

// === EINSTELLUNGEN ===
let pumpIP = "192.168.178.34";        // IP-Adresse des Pumpen-Shelly (1PM)
let targetTemp = 33.0;                 // Zieltemperatur in °C
let hysteresis = 1.5;                  // Toleranzbereich um die Zieltemperatur (±1,5 °C)
let impulseTimeMs = 2000;              // Dauer, wie lange der Mischer pro Impuls läuft (in ms)
let lockTimeMs = 1 * 60 * 1000;        // Sperrzeit nach jeder Mischerbewegung (1 Minute)
let startPosition = 45;                // Öffnungsposition (in %) nach Einschalten der Pumpe
let safetyTemp = 45.0;                 // Sicherheitsgrenze: ab hier Mischer auf safetyPosition fahren
let safetyPosition = 30;               // Öffnungsposition (in %) bei Sicherheitsabschaltung (z.B. Kaltfahren bei Überhitzung)
let pumpTimeoutMs = 1 * 60 * 1000;    // Zeit (2 Minuten), nach der der Mischer bei Pumpenausfall geschlossen wird

// === VARIABLEN ===
let lastActionTime = 0;                // Zeit der letzten Mischerbewegung (Timestamp)
let isMoving = false;                  // Flag zum Verhindern paralleler Mischerbewegungen
let lastPumpState = false;             // Letzter bekannter Pumpenzustand (an/aus)
let lastPumpReachable = true;          // Letzter bekannter Erreichbarkeitszustand der Pumpe
let pumpNotReachableSince = 0;         // Zeitpunkt, seit wann die Pumpe nicht erreichbar ist
let tempSensorKey = "temperature:100"; // Schlüssel zum Auslesen der Temperatur im Shelly Status

// === Funktion: Pumpenzustand per HTTP GET abfragen ===
// Callback gibt zwei Werte zurück:
// - reachable: bool, ob Pumpen-Shelly erreichbar ist
// - pumpOn: bool, ob die Pumpe eingeschaltet ist (true) oder nicht (false)
function getPumpState(callback) {
  Shelly.call("http.get", { url: "http://" + pumpIP + "/status" }, function(res) {
    if (res && res.body) {
      try {
        let data = JSON.parse(res.body);
        let isOn = data.relays && data.relays[0] && data.relays[0].ison === true;
        callback(true, isOn);
      } catch (e) {
        print("Fehler beim Parsen der Pumpenantwort:", e);
        callback(false, false);
      }
    } else {
      callback(false, false);
    }
  });
}

// === Funktion: Mischer per Impuls bewegen (öffnen/schließen) ===
function moveMischer(direction) {
  if (isMoving) return;  // Wenn schon in Bewegung, nicht nochmal starten
  isMoving = true;

  if (direction === "open") {
    Shelly.call("Cover.Open", { id: 0 });
  } else if (direction === "close") {
    Shelly.call("Cover.Close", { id: 0 });
  }

  Timer.set(impulseTimeMs, false, function () {
    Shelly.call("Cover.Stop", { id: 0 });
    lastActionTime = Date.now();
    isMoving = false;
    print("Bewegung abgeschlossen, Sperrzeit aktiv");
  });
}

// === Funktion: Mischer auf eine feste Position fahren (0–100%) ===
function setMischerToPercent(percent) {
  if (isMoving) return;
  isMoving = true;

  percent = Math.max(0, Math.min(100, percent));  // Begrenzung auf 0–100 %
  print("Setze Mischer auf", percent, "%");
  Shelly.call("Cover.GoToPosition", { id: 0, pos: percent });

  lastActionTime = Date.now();
  Timer.set(1000, false, function () {
    isMoving = false;
  });
}

// === Hauptzyklus: alle 15 Sekunden prüfen ===
Timer.set(15000, true, function () {
  let now = Date.now();

  // Pumpenzustand abfragen (Erreichbarkeit + an/aus)
  getPumpState(function(reachable, pumpOn) {
    if (!reachable) {
      // Pumpe nicht erreichbar
      if (lastPumpReachable) {
        // Erster Erkennungszeitpunkt
        pumpNotReachableSince = now;
        print("Pumpen-Shelly nicht erreichbar, starte Timer");
      }

      lastPumpReachable = false;

      // Prüfen, ob Pumpe länger als timeout nicht erreichbar
      if (now - pumpNotReachableSince >= pumpTimeoutMs) {
        // Mischer auf 0% fahren, aber nur einmalig
        if (lastPumpState !== false) {
          print("Pumpen-Shelly länger als Timeout nicht erreichbar → Mischer auf 0% fahren");
          setMischerToPercent(0);
          lastPumpState = false;  // Pumpe als aus markieren
        } else {
          print("Pumpen-Shelly weiterhin nicht erreichbar – Mischer bleibt in Sicherheitsstellung");
        }
      }
      return; // Keine weitere Regelung
    }

    // Pumpe wieder erreichbar
    if (!lastPumpReachable) {
      print("Pumpen-Shelly wieder erreichbar");
      lastPumpReachable = true;
      pumpNotReachableSince = 0;

      if (pumpOn) {
        // Pumpe an → Mischer auf Startposition fahren
        print("Pumpe an nach Erreichbarkeit → Mischer auf Startposition", startPosition, "%");
        setMischerToPercent(startPosition);
        lastPumpState = true;
      } else {
        // Pumpe aus → Mischer auf 0%
        print("Pumpe aus nach Erreichbarkeit → Mischer auf 0%");
        setMischerToPercent(0);
        lastPumpState = false;
      }
      return;
    }

    // Pumpe erreichbar, Zustand prüfen
    if (!pumpOn) {
      if (lastPumpState === true) {
        // Pumpe gerade ausgeschaltet
        print("Pumpe ausgeschaltet → Mischer auf 0%");
        setMischerToPercent(0);
      } else {
        print("Pumpe weiterhin aus – keine Aktion");
      }
      lastPumpState = false;
      return;
    }

    // Pumpe an
    if (lastPumpState === false) {
      // Pumpe gerade eingeschaltet
      print("Pumpe eingeschaltet → Mischer auf Startposition", startPosition, "%");
      setMischerToPercent(startPosition);
      lastPumpState = true;
    }

    // Sperrzeit prüfen
    if ((now - lastActionTime) < lockTimeMs) {
      print("Sperrzeit aktiv – keine Bewegung");
      return;
    }

    // Temperatur abfragen und regeln
    Shelly.call("Shelly.GetStatus", {}, function (res) {
      if (res[tempSensorKey] && res[tempSensorKey].tC !== undefined) {
        let temp = res[tempSensorKey].tC;
        print("Aktuelle Temperatur:", temp);

        if (temp > safetyTemp) {
          // Temperatur zu hoch → Mischer auf Sicherheitsposition fahren
          print("Temperatur über Sicherheitsgrenze:", safetyTemp, "°C → Mischer auf", safetyPosition, "%");
          setMischerToPercent(safetyPosition);
          return;
        }

        // Hysterese-Regelung
        if (temp < (targetTemp - hysteresis)) {
          print("Temperatur zu niedrig → Mischer öffnen");
          moveMischer("open");
        } else if (temp > (targetTemp + hysteresis)) {
          print("Temperatur zu hoch → Mischer schließen");
          moveMischer("close");
        } else {
          print("Temperatur im Zielbereich → keine Aktion");
        }
      } else {
        print("Temperatursensor nicht gefunden");
      }
    });
  });
});

/**
 * Heizungsmischer Steuerung mit Impulsbetrieb und Sicherheitsfunktion
 * ---------------------------------------------------------------
 * Dieses Script steuert einen Heizungsmischer (z.B. Fußbodenheizung)
 * anhand der Temperatur eines Sensors.
 * 
 * Ziel:
 * - Zieltemperatur (targetTemp) mit Hysterese-Bereich halten.
 * - Steuerung erfolgt durch kurze Impulse zum Öffnen oder Schließen des Mischers.
 * - Sperrzeit (lockTimeMs) nach jeder Bewegung verhindert zu häufige Betätigung.
 * 
 * Erweiterte Sicherheitsfunktion:
 * - Überschreitet die Temperatur eine definierte Sicherheitsgrenze (safetyTemp),
 *   wird der Mischer für 30 Sekunden komplett geschlossen („Kaltfahrt“),
 *   um Überhitzung zu vermeiden.
 * 
 * Variablen:
 * - targetTemp: Zieltemperatur in °C.
 * - hysteresis: Temperaturtoleranz ± in °C.
 * - impulseTimeMs: Dauer eines Mischer-Impulses in ms.
 * - lockTimeMs: Sperrzeit nach einer Bewegung in ms.
 * - tempSensorKey: Schlüssel zur Temperatur im Shelly-Status.
 * - safetyTemp: Maximal erlaubte Temperatur, darüber erfolgt Notabschaltung.
 * - isMoving: Flag, um parallele Bewegungen zu verhindern.
 * 
 * Ablauf:
 * - Alle 10 Sekunden wird die Temperatur abgefragt.
 * - Liegt Temperatur über safetyTemp: Mischer für 30 Sekunden schließen (Notfall).
 * - Liegt Temperatur unter (targetTemp - hysteresis): Mischer öffnen.
 * - Liegt Temperatur über (targetTemp + hysteresis): Mischer schließen.
 * - Temperatur im Zielbereich: keine Bewegung.
 * - Nach jeder Bewegung wird Sperrzeit aktiviert.
 * 
 * Voraussetzungen:
 * - Temperatur muss im Shelly-Status unter tempSensorKey vorhanden sein.
 * - Shelly Cover mit id=0 steuert den Mischer.
 * 

 */

let targetTemp = 30.0;          // Zieltemperatur in °C
let hysteresis = 1.5;           // +/- Toleranzbereich
let impulseTimeMs = 2000;       // Mischer läuft 2 Sekunden pro Impuls
let lockTimeMs = 1 * 60 * 1000; // Sperrzeit: 1 Minute
let lastActionTime = 0;         // Zeit der letzten Bewegung
let tempSensorKey = "temperature:100"; // key aus Status
let safetyTemp = 45.0;          // Sicherheitsgrenze in °C
let isMoving = false;           // Schutz gegen gleichzeitige Bewegungen

Timer.set(10000, true, function () {
  let now = Date.now();

  if ((now - lastActionTime) < lockTimeMs) {
    print("Sperrzeit aktiv – keine Aktion");
    return;
  }

  Shelly.call("Shelly.GetStatus", {}, function (res) {
    if (res[tempSensorKey] && res[tempSensorKey].tC !== undefined) {
      let temp = res[tempSensorKey].tC;
      print("Aktuelle Temperatur:", temp);

      // Sicherheitsfunktion: Wenn Temperatur über safetyTemp, dann 30s Kaltfahrt
      if (temp > safetyTemp) {
        print("Übertemperatur! Mischer 30s schließen.");
        forceCoolDown();
        return; // restliche Regelung überspringen
      }

      if (temp < (targetTemp - hysteresis)) {
        print("Zu kalt → Mischer öffnen");
        moveMischer("open");
      } else if (temp > (targetTemp + hysteresis)) {
        print("Zu warm → Mischer schließen");
        moveMischer("close");
      } else {
        print("Temperatur im Zielbereich → keine Bewegung");
      }
    } else {
      print("Sensor", tempSensorKey, "nicht gefunden!");
    }
  });
});

// Sicherheitsfunktion: 30 Sekunden Kaltfahrt + Sperrzeit aktivieren
function forceCoolDown() {
  if (isMoving) return;

  isMoving = true;

  Shelly.call("Cover.Close", { id: 0 }); // Mischer schließen (kalt)
  Timer.set(30000, false, function () {
    Shelly.call("Cover.Stop", { id: 0 });
    lastActionTime = Date.now(); // Sperrzeit starten
    isMoving = false;
    print("Kaltfahrt abgeschlossen, Sperrzeit aktiv.");
  });
}

// Mischer für eine bestimmte Zeit öffnen oder schließen
function moveMischer(direction) {
  if (isMoving) {
    print("Mischer bewegt sich bereits!");
    return;
  }

  isMoving = true;

  if (direction === "open") {
    Shelly.call("Cover.Open", { id: 0 });
  } else if (direction === "close") {
    Shelly.call("Cover.Close", { id: 0 });
  }

  Timer.set(impulseTimeMs, false, function () {
    Shelly.call("Cover.Stop", { id: 0 });
    lastActionTime = Date.now();
    isMoving = false;
    print("Bewegung abgeschlossen, Sperrzeit gestartet");
  });
}

/**
 * Heizungsmischer Steuerung mit Impulsbetrieb über Shelly Cover API
 * ---------------------------------------------------------------
 * Dieses Script steuert einen Heizungsmischer (z.B. für Fußbodenheizung) 
 * in Abhängigkeit von der gemessenen Temperatur eines Sensors.
 * 
 * Ziel ist es, die Zieltemperatur (targetTemp) mit einem Hysterese-Bereich
 * zu halten, indem der Mischer nur für kurze Impulse geöffnet oder geschlossen wird.
 * 
 * Funktionsweise:
 * - Alle 10 Sekunden wird die aktuelle Temperatur des Sensors abgefragt.
 * - Liegt die Temperatur unter (targetTemp - hysteresis), wird der Mischer
 *   für 2 Sekunden geöffnet (Impuls).
 * - Liegt die Temperatur über (targetTemp + hysteresis), wird der Mischer
 *   für 2 Sekunden geschlossen (Impuls).
 * - Liegt die Temperatur im Zielbereich (innerhalb Hysterese), wird keine
 *   Bewegung ausgeführt.
 * - Nach jedem Impuls wird eine Sperrzeit (lockTimeMs, hier 1 Minute) aktiviert,
 *   in der keine weiteren Bewegungen ausgelöst werden können, um zu häufige
 *   Betätigungen zu vermeiden.
 * 
 * Variablen:
 * - targetTemp: Zieltemperatur in °C.
 * - hysteresis: Toleranz um die Zieltemperatur ± in °C.
 * - impulseTimeMs: Dauer des Mischerimpulses in Millisekunden.
 * - lockTimeMs: Sperrzeit nach einer Bewegung in Millisekunden.
 * - tempSensorKey: Key des Temperaturwerts im Shelly Status-Objekt.
 * 
 * Funktionen:
 * - Timer.set: Periodische Abfrage alle 10 Sekunden.
 * - Shelly.call("Shelly.GetStatus"): Abfrage aktueller Sensorwerte.
 * - moveMischer(direction): Führt einen Impuls zum Öffnen oder Schließen durch.
 * 
 * Besonderheiten:
 * - Schutz gegen parallele Bewegungen mit der Flag isMoving.
 * - Absicherung der Temperaturwerte auf gültige Zahlen.
 * 
 * Voraussetzung:
 * - Sensor muss unter tempSensorKey im Status verfügbar sein.
 * - Shelly Cover mit id=0 muss den Mischer steuern können.
 * 
 */

let targetTemp = 33.0;            // Zieltemperatur in °C
let hysteresis = 2.0;             // +/- Toleranzbereich
let impulseTimeMs = 2000;         // Mischer läuft 2 Sekunden pro Impuls
let lockTimeMs = 1 * 60 * 1000;   // Sperrzeit: 1 Minuten
let lastActionTime = 0;           // Zeit der letzten Bewegung
let tempSensorKey = "temperature:100";  // key aus Status

// Alle 10 Sekunden prüfen
Timer.set(10000, true, function () {
  let now = Date.now();

  if ((now - lastActionTime) < lockTimeMs) {
    print("Sperrzeit aktiv – keine Aktion");
    return;
  }

  Shelly.call("Shelly.GetStatus", {}, function (res) {
    if (res[tempSensorKey] && res[tempSensorKey].tC !== undefined) {
      let temp = res[tempSensorKey].tC;
      print("Aktuelle Temperatur:", temp);

      if (temp < (targetTemp - hysteresis)) {
        print("Zu kalt → Mischer öffnen");
        moveMischer("open");
      } else if (temp > (targetTemp + hysteresis)) {
        print("Zu warm → Mischer schließen");
        moveMischer("close");
      } else {
        print("Temperatur im Zielbereich → keine Bewegung");
      }
    } else {
      print("Sensor", tempSensorKey, "nicht gefunden!");
    }
  });
});

// Mischer für bestimmte Zeit laufen lassen
function moveMischer(direction) {
  if (direction === "open") {
    Shelly.call("Cover.Open", { id: 0 });
  } else if (direction === "close") {
    Shelly.call("Cover.Close", { id: 0 });
  }

  Timer.set(impulseTimeMs, false, function () {
    Shelly.call("Cover.Stop", { id: 0 });
    lastActionTime = Date.now();
    print("Bewegung abgeschlossen, Sperrzeit gestartet");
  });
}