Beiträge von Schwarzermann

Schwarzermann

So soll es sein mit Endlagen eisellbar, dann funktioniert auch alles, und die Spielwiese is eröffnet.

Schwarzermann

Ach in deutschland gibt es soviele unsinnige verordnungen aber manche machen schon Sinn und so ein hydraulischer abgleich kann man als Heimwerker auch gut stemmen

Schwarzermann

Ja das ist mit so das entscheidenste das ganze Langsam hoch zufahren, ich Fahre hohen Volumenstrom und konnte so meine Vorlauftemperatur die noch von 2 temperatur Sensoren gesteuret wird Innen und Aussen von 65° auf aktuell bei 10° auf 38 ° drücken es ist muckelig warm in der Bude 22-23° ja das ganze braucht wenn es mal runter gekühlt hat weil mal ich ausversehen die Heizung ausgeschlten habe schon 2-3 Std bis es wieder auf soll Temperatur ist aber wirklich kalt ist es nicht, und die WP läuft mittlerweile stur durch zieht wenige 1100w und macht daraus je nach cop der ja Temperutarabhängig ist 4-5 kw Heizleistung

Schwarzermann

Code

/***** Markise – Sonnen/Wetter-Logik (Shelly Plus 2PM, InfluxDB = wunderweather)
 * Datum: 2025-10-06
 *****/

/*** Ersatz für encodeURIComponent (da Shelly JS 1.71 das nicht kennt) ***/
function encodeURIComponent(str) {
  let map = {' ':'%20','"':'%22','%':'%25','&':'%26','\'':'%27','(':'%28',')':'%29','+':'%2B',',':'%2C','/':'%2F',':':'%3A',';':'%3B','<':'%3C','=':'%3D','>':'%3E','?':'%3F','@':'%40','[':'%5B',']':'%5D'};
  let out=""; for (let i=0;i<str.length;i++){let c=str[i]; out+=map[c]?map[c]:c;} return out;
}

/*** === Konfiguration === ***/
let CFG = {
  IPCOVER_SELF: "192.168.178.131",
  IPCOVER_BATH: "192.168.178.195",
  INFLUX: {
    url: "http://192.168.178.54:8086/query",
    db:  "wunderweather",             // ✅ Korrigiert
    meas: "weather",
    fields: {
      irradiance: "Sonnenstrahlung",
      temperature: "Temperatur",
      wind: "Windgeschwindigkeit",
      humidity: "Luftfeuchtigkeit"
    }
  },
  POLL_MS: 60000,
  IRR_ON:  300,
  IRR_OFF: 200,
  T_MIN:   20.0,
  W_MID:   8.0,
  W_HIGH: 10.0,
  HUMI_RAIN: 90.0,
  STAB_SUN_SEC:   120,
  STAB_TEMP_SEC:  120,
  STAB_WMID_SEC:  120,
  STAB_WHIGH_SEC: 120,
  STAB_RAIN_SEC:  120,
  STAB_NIGHT_SEC: 120,
  POS_FULL_OUT: 100,
  POS_HALF:     50,
  POS_IN:        0,
  CMD_COOLDOWN_MS: 30000
};

/*** === Helper === ***/
function nowMs() { return Date.now(); }
function log() { let s=""; for(let i=0;i<arguments.length;i++){s+=(i>0?" ":"")+arguments[i];} print("[Markise] "+s); }

/*** === Debouncer === ***/
function Debouncer(sec){this.stabMs=sec*1000;this.sinceTrue=null;this.update=function(v){if(v){if(this.sinceTrue===null)this.sinceTrue=nowMs();}else this.sinceTrue=null;};this.stableTrue=function(){return this.sinceTrue!==null&&(nowMs()-this.sinceTrue)>=this.stabMs;};}
let DB={sunOn:new Debouncer(CFG.STAB_SUN_SEC),sunOff:new Debouncer(CFG.STAB_SUN_SEC),tOk:new Debouncer(CFG.STAB_TEMP_SEC),wMid:new Debouncer(CFG.STAB_WMID_SEC),wHigh:new Debouncer(CFG.STAB_WHIGH_SEC),rain:new Debouncer(CFG.STAB_RAIN_SEC),night:new Debouncer(CFG.STAB_NIGHT_SEC)};
let state={lastCmdAt:0,lastTargetPos:null,coverPos:null,irr:null,temp:null,wind:null,humi:null,isDay:null};

/*** === Cover === ***/
function refreshSelfCover(){Shelly.call("Cover.GetStatus",{id:0},function(r,e,c){if(c===200&&r){state.coverPos=r.current_pos;}});}
function setCoverPos(target){let t=nowMs();if(t-state.lastCmdAt<CFG.CMD_COOLDOWN_MS)return;if(state.lastTargetPos!==null&&Math.abs(state.lastTargetPos-target)<2)return;state.lastCmdAt=t;state.lastTargetPos=target;log("→ Fahre Markise auf",target,"%");Shelly.call("Cover.GoToPosition",{id:0,pos:target});}

/*** === HTTP Wrapper === ***/
function httpGet(url,cb){Shelly.call("HTTP.GET",{url:url,timeout:8},function(r,e,m){if(e===0&&r&&r.code===200){cb(r);}else{log("❌ HTTP Fehler",e,m);cb(null);}});}

/*** === Bad-Rollo Tag/Nacht === ***/
function fetchBathDayNight(cb){let url="http://"+CFG.IPCOVER_BATH+"/rpc/Cover.GetStatus?id=0";log("HTTP →",url);httpGet(url,function(r){if(!r){log("❌ Keine Antwort vom Bad-Rollo");cb(false);return;}log("← Bad-Rollo:",r.body);try{let j=JSON.parse(r.body);let pos=j.current_pos;let isDay=(pos>=100);DB.night.update(!isDay);state.isDay=isDay;cb(true);}catch(e){log("❌ JSON Fehler Bad-Rollo",e);cb(false);}});}

/*** === Influx Abfrage === ***/
function buildInfluxQuery(){let f=CFG.INFLUX.fields,m=CFG.INFLUX.meas;return 'SELECT last("'+f.irradiance+'") AS irr, last("'+f.temperature+'") AS temp, last("'+f.wind+'") AS wind, last("'+f.humidity+'") AS humi FROM "'+m+'" WHERE time > now() - 10m';}
function fetchInflux(cb){let query=buildInfluxQuery();let url=CFG.INFLUX.url+"?db="+CFG.INFLUX.db+"&q="+encodeURIComponent(query);log("HTTP →",url);httpGet(url,function(r){if(!r){log("❌ Keine Antwort von Influx");cb(false);return;}log("← Influx:",r.body);try{let d=JSON.parse(r.body);let s=d.results[0].series[0];let cols=s.columns;let vals=s.values[0];let map={};for(let i=0;i<cols.length;i++)map[cols[i]]=vals[i];state.irr=map.irr;state.temp=map.temp;state.wind=map.wind;state.humi=map.humi;log("→ Werte:",state.irr,state.temp,state.wind,state.humi);cb(true);}catch(e){log("❌ JSON Fehler Influx",e);cb(false);}});}

/*** === Entscheidungslogik === ***/
function decideAndAct(){let sunOn=(state.irr!==null&&state.irr>=CFG.IRR_ON);let sunOff=(state.irr!==null&&state.irr<=CFG.IRR_OFF);DB.sunOn.update(sunOn);DB.sunOff.update(sunOff);DB.tOk.update(state.temp>=CFG.T_MIN);DB.wHigh.update(state.wind>=CFG.W_HIGH);DB.wMid.update(state.wind>=CFG.W_MID&&state.wind<CFG.W_HIGH);DB.rain.update(state.humi>=CFG.HUMI_RAIN);let night=DB.night.stableTrue();log("Check:",state.isDay,state.irr,state.temp,state.wind,state.humi);if(night){log("→ Nacht ⇒ 0%");setCoverPos(CFG.POS_IN);return;}if(DB.rain.stableTrue()){log("→ Regen ⇒ 0%");setCoverPos(CFG.POS_IN);return;}if(DB.wHigh.stableTrue()){log("→ Wind hoch ⇒ 0%");setCoverPos(CFG.POS_IN);return;}if(DB.wMid.stableTrue()){log("→ Wind mittel ⇒ 50%");setCoverPos(CFG.POS_HALF);return;}if(DB.sunOn.stableTrue()&&DB.tOk.stableTrue()&&state.isDay){log("→ Sonne & Temp OK ⇒ 100%");setCoverPos(CFG.POS_FULL_OUT);return;}if((DB.sunOff.stableTrue()||!DB.tOk.stableTrue())&&state.isDay){log("→ Sonne weg / kalt ⇒ 0%");setCoverPos(CFG.POS_IN);return;}log("→ Keine stabile Änderung – wartet…");}

/*** === Loop === ***/
function loop(){refreshSelfCover();fetchBathDayNight(function(){fetchInflux(function(){decideAndAct();});});}
log("Script gestartet – Poll =",CFG.POLL_MS,"ms");loop();Timer.set(CFG.POLL_MS,true,loop);

Alles anzeigen

Hier mal wieder was neues aus meiner Spielwiese ein markisen Skript für einen shelly 2pm gen 4 er fragt meine influx DB wetterstation ab und vergleicht die Werte ebenfalls holt er sich den Status einen Rollos für die Tag Nacht schaltung für das skript die Werte werden bei mir zuverlässig bgefragt ob das ganze funktioniert sehe ich in ein paar Tagen

Schwarzermann

Genau so mach ich es mit meiner zentralheizung auch de mi einer WP gefüttert wird einmal alle Räume vernüftig einselen und man ht ruhe funktioniert bei mir seit 2 Jahren die heizung mach das was sie soll nämlich warm

Schwarzermann

Code

// ###########################################################
// Shelly 1PM / 1 Plus (Gen4) – Mastersteuerung
// folgt 3 Toren (Shelly 2PM) + mehreren Licht-Shellys (1PM/1)
// Nachtmodus wird vom Bad-Rollo (IP 192.168.178.195) bestimmt
// ###########################################################

// === KONFIGURATION =========================================

// Tore (Shelly 2PM)
let garageDoors = [
  "192.168.178.109", // Tor 1 – Garage links
  "192.168.178.110", // Tor 2 – Garage rechts
  "192.168.178.104"  // Tor 3 – Hebebühne
];

// Externe Licht-Shellys
let linkedLights = [
  { ip: "192.168.178.201", active: true },   // Außenlicht Haus
  { ip: "192.168.178.202", active: true },   // Außenlicht Haustüre
  { ip: "192.168.178.xxx", active: false }   // Reserviert (Einfahrt)
];

// Referenz-Rollo für Sonnenstand (Bad)
let refRollo = "192.168.178.195";

// Abfrageintervalle & Zeiten
let interval = 30000;        // 30 s – Torabfrage
let lightCheckInterval = 20000; // 20 s – Lichtabfrage
let holdTimeOpen = 240;      // s – Lichtdauer bei 100 %
let holdTimeClose = 120;     // s – Nachlauf bei Schließen

// Zustände
let lastOn = false;
let holdTimer = null;
let delayOffTimer = null;
let holdActive = false;
let lastPos = { "192.168.178.109": null, "192.168.178.110": null, "192.168.178.104": null };
let lastLightCheck = 0;

// === FUNKTIONEN ============================================

function switchLight(on) {
  Shelly.call("Switch.Set", { id: 0, on: on });
  lastOn = on;
  print("Master-Licht", on ? "EIN" : "AUS");
}

function cancelTimers() {
  if (holdTimer !== null) { Timer.clear(holdTimer); holdTimer = null; }
  if (delayOffTimer !== null) { Timer.clear(delayOffTimer); delayOffTimer = null; }
}

// --- Prüft, ob Nacht ist (Rollo geschlossen)
function isNight(callback) {
  let url = "http://" + refRollo + "/rpc/Cover.GetStatus?id=0";
  Shelly.call("HTTP.GET", { url: url }, function(res) {
    if (!res || res.code !== 200) {
      print("Fehler beim Rollo-Check:", res ? res.code : "n/a");
      callback(true); // Fallback: Nacht
      return;
    }
    try {
      let data = JSON.parse(res.body);
      let pos = parseFloat(data.current_pos);
      let night = (pos <= 0.5); // 0 % = geschlossen ⇒ Nacht
      print("Rollo (Bad):", pos, "% →", night ? "NACHT" : "TAG");
      callback(night);
    } catch (e) {
      print("Parsing-Fehler beim Rollo-Check:", e);
      callback(true);
    }
  });
}

// --- Prüft externe Licht-Shellys
function checkExternalLights(callback) {
  let index = 0;
  function next() {
    if (index >= linkedLights.length) { if (callback) callback(); return; }
    let dev = linkedLights[index++];
    if (!dev.active) return next();
    let url = "http://" + dev.ip + "/rpc/Switch.GetStatus?id=0";
    Shelly.call("HTTP.GET", { url: url }, function(res) {
      if (res && res.code === 200) {
        let data = JSON.parse(res.body);
        if (data.output && !lastOn) {
          switchLight(true);
          print("Master EIN (externer Shelly", dev.ip, "ist EIN)");
        }
      }
      next();
    });
  }
  next();
}

// --- Prüft Tore nacheinander
function checkCoversSequentially(i) {
  if (i >= garageDoors.length) return;
  let ip = garageDoors[i];
  let url = "http://" + ip + "/rpc/Cover.GetStatus?id=0";

  Shelly.call("HTTP.GET", { url: url }, function(res) {
    if (res && res.code === 200) {
      try {
        let data = JSON.parse(res.body);
        let pos = parseFloat(data.current_pos);
        print("Tor", ip, "Position:", pos, "%");

        if (pos >= 100) {
          if (!holdActive) {
            holdActive = true;
            switchLight(true);
            cancelTimers();
            holdTimer = Timer.set(holdTimeOpen * 1000, false, function() {
              switchLight(false);
              print("Licht AUS (240 s abgelaufen)");
            });
            print("Licht EIN (Tor", ip, "100%)");
          }
          lastPos[ip] = pos;
          return checkCoversSequentially(i + 1);
        }

        if (lastPos[ip] !== null && lastPos[ip] >= 100 && pos < 100) {
          switchLight(true);
          holdActive = false;
          cancelTimers();
          print("Licht EIN (Start Schließen Tor", ip, ")");
        }

        if (lastPos[ip] !== null && lastPos[ip] < 20 && pos >= 20) {
          switchLight(true);
          print("Licht EIN (Tor", ip, "öffnet über 20 %)");
        }

        let allClosed = true;
        lastPos[ip] = pos;
        for (let j = 0; j < garageDoors.length; j++) {
          if (lastPos[garageDoors[j]] !== null && lastPos[garageDoors[j]] > 20) {
            allClosed = false;
            break;
          }
        }

        if (allClosed && !delayOffTimer) {
          print("Alle Tore geschlossen – starte 120 s Nachlauf");
          delayOffTimer = Timer.set(holdTimeClose * 1000, false, function() {
            switchLight(false);
            print("Licht AUS (120 s Nachlauf)");
          });
        } else if (!allClosed && delayOffTimer) {
          Timer.clear(delayOffTimer);
          delayOffTimer = null;
          print("Nachlauf abgebrochen (ein Tor wieder aktiv)");
        }

      } catch (e) {
        print("Fehler beim Parsen Tor", ip);
      }
    }
    checkCoversSequentially(i + 1);
  });
}

// --- Hauptsteuerung
function checkSystem() {
  isNight(function(nightMode) {
    if (!nightMode) {
      if (lastOn) switchLight(false);
      print("Tag erkannt – Lichtsteuerung gesperrt");
      return;
    }

    let now = (new Date()).getTime();
    if (now - lastLightCheck > lightCheckInterval) {
      lastLightCheck = now;
      checkExternalLights(function() {
        checkCoversSequentially(0);
      });
    } else {
      checkCoversSequentially(0);
    }
  });
}

// === TIMER STARTEN =========================================
Timer.set(interval, true, checkSystem);
print("Skript gestartet – Nachtmodus über Rollo", refRollo);

Alles anzeigen

So mal schaun ob dos so funktioniert ein Skript das 3 Rolltore abfragt ob diese geöffnet oder geschlossen sind, damit soll ein Shelly 1pm plus sein Licht schalten.

Dazu kommt noch eine Tag n

Nacht erkennung über einen Rolladenstatus der hier die Sonnenaufgang Sonnenuntergang Regelung nutzt, hier mit wird aber die Logik gesteuert ob das Licht einschalten darf ( am Tag nicht in der Nacht schon) hinzu kommen noch ein Shelly 1pm plus der als 2 ter Lichtschalter abgefragt wird zb an der Haustüre und ein shelly 1 der für das Einfahrtstor zuständig ist. Tor öffnet Licht ein tor shliest licht läuft timer ab.

Das ganze teste ich gerade ob es funktioniert, bin gespannt ob das so klappt dann kann ich auch meine anderen Lichtschaltungen damit ausrüsten mit der Rolladenstatus Abfrage.

Kleiner Nachtrag ich abs eben getestet und es funktioniert ich bin mehr als Happy.

*****************************ACHTUNG********ACHTUNG********************ACHTUNG**************ACHTUNG************************************************
Ich weise Ausdrücklich darauf hin das programierungen mit Skripten funktionieren können, und nicht müssen, hier ist jeder selbst dafür verantwortlich und muss auch alle Sicherheitsregeln beachten alle meine Angaben sind somit ohne Gewähr und Rechtlichkeit verbunden.

Schwarzermann

Ich für meine Teil habe hier eine lösung gefunden die auch gut funtioniert ich habe eine Software die grafana visualisiert da ich ier eh schon viele geräte auslese, hier habe in Grafana ein text Plugin wo ich mir buttons konfiguriere und shellys damit schalte so hab ich in jedem Raum wo es von nöten ist ein kleines Display wo ich grafana und die Buttons aufrufen kann und die shellys schalten kann wenn jetzt noch die neuen anwesenheitssensoren von shelly kommen muss mann gar nichts mehr schalten den das machen dann die sensoren für einen.

Schwarzermann

Code

// ###########################################################
// Shelly 1PM Plus (Gen4) – folgt zwei Toren (Shelly 2PM im Cover-Modus)
// mit Sonnenstands-Sperre (nur nachts aktiv)
// ###########################################################
//
// Regeln (pro Tor geprüft, nur aktiv wenn es dunkel ist!):
// - Bei 20% öffnen              -> Licht EIN
// - Bei 100%                    -> Licht holdTime EIN, danach AUS (nur einmal)
// - Wenn Tor von 100% auf <100% fährt (Start Schließen) -> Licht EIN
// - Bei 20% schließen           -> Licht AUS
//
// ###########################################################

// IP-Adressen der beiden Shelly 2PM (Torsteuerungen)
let garageDoors = [
  "192.168.178.109", // Tor 1
  "192.168.178.110"  // Tor 2
];

// Abfrageintervall (ms)
let interval = 5000;   // alle 5 Sekunden

// Haltezeit wenn Tor komplett offen (in Sekunden)
let holdTime = 120;

// interne Zustände
let lastOn = false;
let holdTimer = null;
let holdActive = false;
let lastPos = { "192.168.178.109": null, "192.168.178.110": null };

// Sonnenauf-/untergang
let sunrise = null;
let sunset = null;

// === Hilfsfunktionen ===
function switchLight(on) {
  Shelly.call("Switch.Set", { id: 0, on: on });
  lastOn = on;
  print("Licht", on ? "EIN" : "AUS");
}

function cancelHoldTimer() {
  if (holdTimer !== null) {
    Timer.clear(holdTimer);
    holdTimer = null;
    print("Hold-Timer abgebrochen");
  }
}

function isNight() {
  if (!sunrise || !sunset) return true; // wenn keine Werte -> sicherheitshalber aktiv
  let now = (new Date()).getTime() / 1000; // aktuelle Zeit in UNIX Sekunden
  return (now < sunrise || now > sunset);
}

function updateSunTimes() {
  Shelly.call("Sys.GetStatus", {}, function(res) {
    if (res && res.sunrise && res.sunset) {
      sunrise = res.sunrise;
      sunset = res.sunset;
      print("Sonnenaufgang:", sunrise, "Sonnenuntergang:", sunset);
    } else {
      print("Keine Sonnenzeiten gefunden – Nacht-Check immer TRUE");
    }
  });
}

// === Hauptfunktion: prüft beide Tore ===
function checkCovers() {
  if (!isNight()) {
    // Tagsüber -> Licht sicher ausschalten und überspringen
    if (lastOn) {
      switchLight(false);
      cancelHoldTimer();
      holdActive = false;
    }
    print("Tag erkannt – Steuerung gesperrt");
    return;
  }

  // Zustand pro Tor prüfen
  for (let i = 0; i < garageDoors.length; i++) {
    let ip = garageDoors[i];
    let url = "http://" + ip + "/rpc/Cover.GetStatus?id=0";

    Shelly.call("HTTP.GET", { url: url }, function(res) {
      if (!res || res.code !== 200) {
        print("HTTP Fehler an Tor", ip, ":", res ? res.code : "kein Ergebnis");
        return;
      }

      try {
        let data = JSON.parse(res.body);
        let pos = data.current_pos;
        if (typeof pos === "string") pos = parseFloat(pos);
        print("Tor", ip, "Position:", pos, "%", "(last:", lastPos[ip], ")");

        // --- Regel 2: Bei 100% -> Licht holdTime EIN, danach AUS (nur einmal)
        if (pos >= 100) {
          if (!holdActive) {
            holdActive = true;
            if (!lastOn) {
              switchLight(true);
              print("Licht EIN (Tor", ip, "100%, Timer gestartet)");
            }
            cancelHoldTimer();
            holdTimer = Timer.set(holdTime * 1000, false, function() {
              switchLight(false);
              print("Licht AUS (Timer abgelaufen bei 100%)");
            });
          }
          lastPos[ip] = pos;
          return;
        }

        // --- Regel 3: Start Schließen von 100% -> Licht EIN
        if (lastPos[ip] !== null && lastPos[ip] >= 100 && pos < 100) {
          if (!lastOn) {
            switchLight(true);
            print("Licht EIN (Start Schließen Tor", ip, ")");
          }
          holdActive = false;
          cancelHoldTimer();
        }

        // --- Regel 1: Bei 20% öffnen -> Crossing von <20% auf >=20%
        if (lastPos[ip] !== null && lastPos[ip] < 20 && pos >= 20) {
          if (!lastOn) {
            switchLight(true);
            print("Licht EIN (Tor", ip, "öffnet über 20%)");
          }
        }

        // --- Regel 4: Bei 20% schließen -> Crossing von >20% auf <=20%
        if (lastPos[ip] !== null && lastPos[ip] > 20 && pos <= 20) {
          // prüfe, ob beide Tore <= 20 sind → erst dann aus
          let allClosed = true;
          for (let j = 0; j < garageDoors.length; j++) {
            if (garageDoors[j] !== ip && lastPos[garageDoors[j]] !== null && lastPos[garageDoors[j]] > 20) {
              allClosed = false;
              break;
            }
          }
          if (allClosed && lastOn) {
            switchLight(false);
            print("Licht AUS (beide Tore geschlossen, letzter war", ip, ")");
          }
          holdActive = false;
          cancelHoldTimer();
        }

        lastPos[ip] = pos;

      } catch (e) {
        print("Parsing Fehler an Tor", ip, ":", e);
      }
    });
  }
}

// === Timer starten ===
Timer.set(interval, true, checkCovers);

// Sonnenauf-/untergang alle 10 min aktualisieren
updateSunTimes();
Timer.set(600000, true, updateSunTimes);

Alles anzeigen

So hier mal eine erweiterte Licht Steuerung für einen Shelly 1 pm gen 4 der das Licht schaltet und auf 2 x 2 pm im Rolltormodus horcht, das heißt ein Tor offen und das andere öffnet sich ebenfalls, bleibt das Licht 120 Sekunden an, erst wenn beide geschlossen sind, geht auch das Licht aus.

Entweder nach den 120 sek bei einem Offen eins geschlossen oder beide geschlossen sofort wieder aus.
Ihr müsst das Skript auf den 1 pm kopieren und die ip der Rolltore eben anpassen viel Spass damit.

*****************************ACHTUNG********ACHTUNG********************ACHTUNG**************ACHTUNG************************************************
Ich weise Ausdrücklich darauf hin das programierungen mit Skripten funktionieren können, und nicht müssen, hier ist jeder selbst dafür verantwortlich und muss auch alle Sicherheitsregeln beachten alle meine Angaben sind somit ohne Gewähr und Rechtlichkeit verbunden.

Schwarzermann

Das ist Richtig was du sagst und ja die Kontakte brennen da sehr schnell weg, ich kenne das noch von meiner Ex Arbeitsstelle (Kieswerk) wenn da die Brecher mit über 700kw hart abgeschaltet wurden da kanns schon mal etwas komisch im Schaltschrank riechen.

Ok Elektromotren sind jetzt nicht so empfindlich aber bei Klimaanlagen mit Inverter bzw Wärmepumpen da wäre ich auch vorschtig.

Schwarzermann

Zitat von Schwarzermann

Ich hätte da keine Skrupel ich habe an einem 4 pm 3 Geräte hängen 1 Wärmepumpe mit 3000w eine Split Klima mit 3000w und eine weitere plit klima mit 2700W das reais bleibt dauerhaft geschaltet und soll nur die aufgenommene Leistung messen schaun mer mal wie lange es hält.
Die Leistungen sind das Maximale was sie können was aber selten abgefordert wird.

Les dir doch bitte diesen von mir geposteten Satz durch, und was da steht, es ist nicht Sinn und zweck die Geräte einfach weg zuschalten, es dient allein der Leistungsmessung und ja wenn das Gerät abgeschalten werden soll fahre ich es eh sauber runter.

Meine WP hat einen extra Kontakt den ich mit einem Shelly beschalte damit sie das dann auch zuverlässig tut ohne sie hart vom Netz zutrennen.

Und die Split Klimas sind nur Back up im Winter, und im Sommer eben zum Kühlen gerade des Dachgeschosses, vorteil für mich ich kann so 4 bzw aktuell 3 Geräte auslesen wieviel Strom sie wann brauchen, da ich hinten dran eine Solaranzeige mit Grafana laufen habe und hier mein Ganzes Haus Visualisiere Der Inhalt kann nicht angezeigt werden, da Sie keine Berechtigung haben, diesen Inhalt zu sehen. Der Inhalt kann nicht angezeigt werden, da Sie keine Berechtigung haben, diesen Inhalt zu sehen. Der Inhalt kann nicht angezeigt werden, da Sie keine Berechtigung haben, diesen Inhalt zu sehen.

Hier mal einen kleinen Auszug aus den verschiedenen Visualisierungen Der Inhalt kann nicht angezeigt werden, da Sie keine Berechtigung haben, diesen Inhalt zu sehen.

Und das ist noch nicht ganz Fertig gebaut aber man kann erkennen wohin die Reise geht, alleine das Bild mit der KI so zu generieren hat doch ein paar Stunden gekostet. Es ist nicht perfekt aber ich finde es für mich erst mal gelungen.

Schwarzermann

5 Monate nach dem Shelly wurde aber jedes Gerät nochmals mit eines Sicherung versehen und vor dem 4 PM sitzt ebenfalls eine Sicherung sollte also etwas nicht mehr funktionieren ist in allen Richtungen das ganze abgesichert der 4 pm soll 40 A Vertragen die WP zieht maimal 13A die grosse Splitt ebenfalls wenn so Vollgas läuft die kleine geht mit 9 A zugange.

Bis jetzt funktioniert alles we es soll im Sommer ist die WP eh aus da Heizen wir mit den Split kimas bzw Kühlen.

Schwarzermann

Ich hätte da keine Skrupel ich habe an einem 4 pm 3 Geräte hängen 1 Wärmepumpe mit 3000w eine Split Klima mit 3000w und eine weitere plit klima mit 2700W das reais bleibt dauerhaft geschaltet und soll nur die aufgenommene Leistung messen schaun mer mal wie lange es hält.

Die Leistungen sind das Maximale was sie können was aber selten abgefordert wird.

Schwarzermann

Ja und welche Leisung hat diese? es gibt sie in 6 Leistungsstufen wenn aber soviel falsch gemacht wurde denke ich das du da ein WP Mnster hast also ne relativ große und da wundert mich das tackten nicht.

Schwarzermann

Warum nicht nicht nach Sonnen aufgang und Sonnen Untergang regel?

Schwarzermann

Der schaltet aber normalerweise einen heizstab und nicht die Wärmepumpe oder verstehe ich da was falsch und welche Wärmepumpe hast du nun?

Schwarzermann

Veräts du mir was für eine WP du da hast und wo der Anschluss dazu ist?

Schwarzermann

Dokumentation: Shelly 2PM Pro Steuerung mit SOC +
PV-Überschuss
Dieses Skript wird auf einem **Shelly 2PM Pro** ausgeführt und dient der automatischen Steuerung eines Relais (z. B.
Netzladegerät für Batteriespeicher) basierend auf zwei Informationsquellen: 1. **Batterie-SOC (State of Charge)** aus
der InfluxDB (bereitgestellt durch die Solaranzeige). 2. **PV-Überschuss / Netzbezug** vom Bitshake-Lesekopf. Ziel
ist es, die Batterie zu schützen und gleichzeitig PV-Überschüsse sinnvoll zu nutzen.
■ Funktionsumfang
■ **SOC-Überwachung** - Abfrage alle 60 Sekunden aus der InfluxDB. - Wenn SOC < 30 % → Relais 0 EIN
(Netzladegerät einschalten). - Wenn SOC >= 70 % und kein PV-Überschuss → Relais 0 AUS. ■
**PV-Überschuss-Erkennung** - Abfrage alle 10 Sekunden über den Bitshake (HTTP). - Wenn negativer
Leistungswert (Überschuss) → Relais 0 EIN. - Bei Netzbezug und SOC >= 70 % → Relais 0 AUS. ■ **Manuelles
Schalten** - Wird das Relais manuell über das Dashboard oder die Shelly-Oberfläche geschaltet, wird die Automatik
deaktiviert, um Eingriffe des Benutzers nicht zu überschreiben. ■ **Automatikmodus** - Automatik ist standardmäßig
aktiviert. - Status wird in der **Key-Value-Storage (KVS)** des Shelly gespeichert. - Automatik kann reaktiviert werden
über einen HTTP-Aufruf: ``` http://[Shelly-IP]/rpc/Script.Eval?code=autoMode%3Dtrue%3BsaveKV() ```
■ Zweck
Dieses Skript sorgt dafür, dass die Batterie nicht tiefentladen wird (Schutz durch Mindest-SOC), gleichzeitig aber bei
PV-Überschuss zusätzliche Ladeleistung genutzt wird, um Netzbezug zu vermeiden. Dadurch wird die
**Eigenverbrauchsquote optimiert** und die **Lebensdauer der Batterie** verlängert. Das Relais 0 am Shelly 2PM Pro
kann z. B. ein **Netzladegerät (Studer, Meanwell, etc.)** steuern.

Schwarzermann

Code

/*
 Shelly 2PM Pro Steuerung mit SOC + PV-Überschuss
 ------------------------------------------------
 - SOC aus Influx (60s), Bitshake Power (10s)
 - Relais 0 EIN wenn SOC < 30% oder PV-Überschuss
 - AUS wenn SOC >= 70% und kein Überschuss
 - Manuelles Schalten stoppt Automatik
 - Automatik kann per HTTP-Befehl reaktiviert werden
*/

// ===== Konfiguration =====
let SOC_URL = "http://192.168.178.54:8086/query?db=JBDBMS1&q=SELECT+last(%22SOC%22)+FROM+Batterie";
let BIT_URL = "http://192.168.178.18/cm?cmnd=status%2010";  

let RELAY_ID = 0;
let POLL_SOC = 60000;
let POLL_BIT = 10000;

let SOC_ON  = 30;
let SOC_OFF = 70;
let autoMode = true;

// ===== Funktionen =====
function checkSOC(){
  if(!autoMode) return;
  Shelly.call("http.get", { url:SOC_URL }, function(res){
    if(res.code === 200){
      try {
        let data = JSON.parse(res.body);
        let soc = data.results[0].series[0].values[0][1];
        print("📊 SOC =", soc, "%");

        if(soc < SOC_ON){
          setRelay(true, "SOC niedrig");
        } else if(soc >= SOC_OFF){
          checkBitshake(false, soc);
        }
      } catch(e){ print("❌ Fehler SOC-Parse:", e); }
    }
  });
}

function checkBitshake(forceOn, socVal){
  if(!autoMode) return;
  Shelly.call("http.get", { url:BIT_URL }, function(res){
    if(res.code === 200){
      try {
        let data = JSON.parse(res.body);
        let power = data.StatusSNS.mMe4.Power;
        print("🔌 Bitshake Power =", power, "W");

        if(forceOn){
          setRelay(true, "SOC <"+SOC_ON+"%");
        } else {
          if(power < 0){
            setRelay(true, "PV-Überschuss");
          } else if(socVal >= SOC_OFF){
            setRelay(false, "SOC >="+SOC_OFF+"% und kein Überschuss");
          }
        }
      } catch(e){ print("❌ Fehler Bitshake-Parse:", e); }
    }
  });
}

function setRelay(state, reason){
  Shelly.call("Switch.GetStatus", { id:RELAY_ID }, function(res){
    if(res.output !== state){
      Shelly.call("Switch.Set", { id:RELAY_ID, on:state });
      print("⚡ Relais", RELAY_ID, state ? "EIN" : "AUS", "Grund:", reason);
    }
  });
}

// === Automatik speichern ===
function saveKV(){
  Shelly.call("KV.Set", { key:"autoMode", value:(autoMode ? "true":"false") });
}

function loadKV(){
  Shelly.call("KV.Get", { key:"autoMode" }, function(res){
    if(res && typeof res.value !== "undefined" && res.value !== null){
      autoMode = (res.value === "true");
    } else {
      autoMode = true;
    }
    print("🔧 Automatik-Status geladen:", autoMode);
  });
}

// === Manuelles Schalten abfangen ===
Shelly.addEventHandler(function(ev){
  if(ev.component === "switch:"+RELAY_ID && typeof ev.info.output !== "undefined"){
    if(autoMode){
      print("🖐 Manuell geschaltet – Automatik deaktiviert!");
      autoMode = false;
      saveKV();
    }
  }
});

// === HTTP-Kommando für Automatik aktivieren ===
// Aufruf im Browser oder von Grafana:
// http://192.168.178.79/rpc/Script.Eval?code=autoMode%3Dtrue%3BsaveKV()
//
// Damit wird autoMode=true gesetzt und gespeichert.


// === Start ===
print("▶️ Steuerung gestartet: SOC alle", POLL_SOC/1000, "s, Bitshake alle", POLL_BIT/1000, "s");
loadKV();
Timer.set(POLL_SOC, true, checkSOC);
Timer.set(POLL_BIT, true, function(){ checkBitshake(false, 0); });


Ich habe hier ein Skript für eine Steuerungslogik für einen Akku und einem Ladegerät mit einem Shelly 2pm pro

Alles anzeigen

Schwarzermann

Ich hb hier 2 Somfy funkmotoren noch waren bei den Fenstern damals dabei ich hab nur Probleme damit und ich brauch einen extra Funkwandler um diese mit Shellys nun zuschalten nächstes Jahr fliegen die raus weil ich so keinen % einstellen kann und die rollos selbst auch schlecht sind trotz alu

Schwarzermann

Ich verwende Standart Rohrmotore mit Endabschaltung zum einstellen das funktioniert am zuverlässigsten und ist günstig, und man muss bei Stromausfall nicht immer wieder die Endpunkt anlernen was bei anderen pssieren kann.

Ansonten lässt sich mit en 2pm eine gute jalousie Steuerung realisieren.

Beiträge von Schwarzermann

Motor für Rollläden

Fußbodenheizung

Fußbodenheizung

Schwarzermann's Ideen und Umsetzungen Shellys in Grafana schalten

Fußbodenheizung

Schwarzermann's Ideen und Umsetzungen Shellys in Grafana schalten

Hausaustattung komplett von Anfang an mit Shelly

Schwarzermann's Ideen und Umsetzungen Shellys in Grafana schalten

Shelly Pro 4PM mögliche Lasten? (Poolpumpe, Wärmepumpe)

Shelly Pro 4PM mögliche Lasten? (Poolpumpe, Wärmepumpe)

Shelly Pro 4PM mögliche Lasten? (Poolpumpe, Wärmepumpe)

Shelly Pro 4PM mögliche Lasten? (Poolpumpe, Wärmepumpe)

Wechsel von Shelly 1 zu 1PM Gen4

Zufallssteuerung

Wechsel von Shelly 1 zu 1PM Gen4

Wechsel von Shelly 1 zu 1PM Gen4

Schwarzermann's Ideen und Umsetzungen Shellys in Grafana schalten

Schwarzermann's Ideen und Umsetzungen Shellys in Grafana schalten

Motor für Rollläden

Motor für Rollläden