Es geht ja nicht nur um ein kleines Puzzle vom ganzen.
Praxisbeispiel:
Perfekt wäre natürlich, wie mein Vorschreiber schon erwähnt, ein übergeordnetes System, wo mit deinen Lampen arbeitet.
Aber so ein System bedeutet natürlich auch Einarbeitung.
Informationen, welche auch berücksichtigt werden sollten:
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
2023 stand ich vor dem selben Problem... LED Leuchten mit einer BT APP und Fernbedienung(en) [neuere Generation kann auch WLAN / Matter etc.}
Meine Ansatz bzw. mittlerweile funktionierende Lösung ist:
• Der Wandschalter wurde durch einen "smarten Schalter" ersetzt. (Früher Schalter und SonOff, jetzt Taster und Gen3 Shelly)
- Dieser schaltet weiterhin wie gewohnt die Phase zur Leuchte ein und aus.
• Wenn ich in der App schalte, modis ändere, dimme etc. lese ich das BT Signal im Schalter via. Script mit, wenn dieser aktuell "AUS" ist dann schalte ich ihn "EIN".
- Wenn "EIN" und BT sagt "AUS" dann wird eben der Schalter [int.Relais] auf "AUS" geschaltet.
• Über das übergeordnete System (Home Assistant) läuft es ähnlich dort muss ich jedoch BT nicht auslesen da alle aktuellen Status (Schalter und Leuchte) bereits vorliegen haben.
• Beim übergeordneten System habe ich eine Anfahrschaltung, wenn der Schalter auf "AUS" stand automatisiert, dort wird eine Schleife gestartet welche für 6 Sekunden alle Sekunden den gewünschten Befehl überträgt.
- Dadurch ist die "Boot"-Zeit der Leuchte vor Ort kaum spürbar, Remote gar nicht.
- Generell kommt es kaum vor, dass die Leuchten Parameter just im spannungslosen Zustand der Leuchte geändert werden.
• Einziger Nachteil ist, wenn der Schalter "AUS" ist und ich die App nutze, dauert es 2...4 Sekunden bis ich die Lampe via App bedient werden kann.
- Da die Leuchte den letzten Zustand speichert, ist dies zu verschmerzen.
Wie du erkennen kannst, nutze ich auch übergeordnete Systeme, jedoch versuche ich möglichst alles wie gewohnt Bedienbar zu halten.
Die Frage war, warum hier eine Fehlermeldung auftritt
-> Unbestritten eine berechtigte Frage.
Da es jedoch so aussieht,
wird es schwierig bzw. fast unmöglich dir Antworten zu liefern.
Trotzdem viel Glück und vielleicht statt der Microschritte ein Sprung.
Ansonsten: denkt euch was aus, postet es hier. Ebenso eure goilen Lichtanimationen
Eine meine Lösungen mit dem Plus Plug S bildet aus unten angeführten externe MQTT-Daten eine "Ampel" Anzeige mit wechselnden Helligkeitswerte bzw. farbiges Blinken.
/// Shelly Plus Plug S {LED visualization Heating V3.0}
////////////////////////////////////////////////////////////////////////////////////////////
///
/// Created by HighFive © 2024
///
////////////////////////////////////////////////////////////////////////////////////////////
let SHELLY_ID = undefined;
//
let MQTTconnect = false;
// set this to false to stop publishing on MQTT
let MQTTpublish = true;
//
let topicHeartBeat = "Home Assistant/HeartBeat";
let topicKESSELStatus = "Home Assistant/KESSEL/Status";
let topicKESSELStatusInfo = "Home Assistant/KESSEL/Status/Info";
let topicKESSELTemperatur = "Home Assistant/KESSEL/Temperatur";
let topicPUFFERTemperaturoben = "Home Assistant/PUFFER/Temperatur oben";
let topicPUFFERLadezustand = "Home Assistant/PUFFER/Ladezustand";
//
let counter = [0, 0, 0, 0, 0];
let log = 0;
let blink;
let maximumCycle = 0;
let red;
let green;
let blue;
let brightness;
let lastcolorLamp;
let lastcolorLampOld;
//
let KESSELStatus = "Bereit";
let KESSELStatusInfo = "*** Kessel für Automatik vorbereiten ***";
let KESSELTemperatur = 0;
let PUFFERTemperaturoben = 0;
let PUFFERLadezustand = 0;
//
// query the MQTT prefix on startup
Shelly.call("Mqtt.GetConfig", "", function(res, err_code, err_msg, ud) {
SHELLY_ID = res["topic_prefix"];
MQTT.subscribe(topicHeartBeat, MQTTCmdListener);
MQTT.subscribe(topicKESSELStatus, MQTTCmdListener);
MQTT.subscribe(topicKESSELStatusInfo, MQTTCmdListener);
MQTT.subscribe(topicKESSELTemperatur, MQTTCmdListener);
MQTT.subscribe(topicPUFFERTemperaturoben, MQTTCmdListener);
MQTT.subscribe(topicPUFFERLadezustand, MQTTCmdListener);
});
///
function MQTTCmdListener(topic, message) {
try {
if (topic === topicHeartBeat) {
maximumCycle = Math.max(maximumCycle, counter[1]);
counter[1] = 0;
}
if (topic === topicKESSELStatus) {
KESSELStatus = message;
}
if (topic === topicKESSELStatusInfo) {
KESSELStatusInfo = message;
}
if (topic === topicKESSELTemperatur) {
KESSELTemperatur = message;
}
if (topic === topicPUFFERTemperaturoben) {
PUFFERTemperaturoben = message;
}
if (topic === topicPUFFERLadezustand) {
PUFFERLadezustand = message;
}
} catch (e) {
print(e);
}
}
///
function timer666Handler() {
try {
Shelly.call("Switch.set", {
'id': 0,
'on': true
});
//
blink = !blink;
//
if (KESSELStatusInfo === "*** Kessel für Automatik vorbereiten ***") {
red = 100;
green = 100;
blue = 100;
brightness = 40;
colorLamp = "weiß";
} else {
red = 0;
green = 100;
blue = 0;
brightness = 20;
colorLamp = "grün";
}
//
if ((KESSELStatusInfo === "*** Kessel für Automatik vorbereiten ***") && (PUFFERTemperaturoben < 68.0)) {
if (PUFFERLadezustand < 40.0) {
red = 100;
green = 100;
blue = 0;
brightness = 20;
colorLamp = "gelb";
}
//
if (PUFFERLadezustand < 35.0) {
if (blink === false) {
red = 100;
green = 100;
blue = 100;
brightness = 00;
} else {
red = 100;
green = 100;
blue = 0;
brightness = 40;
}
colorLamp = "gelb/blinken";
}
}
//
changeLEDs(red, green, blue, brightness);
//
if (typeof SHELLY_ID !== "undefined" && MQTTconnect === true && MQTTpublish === true) {
if (colorLamp !== lastcolorLamp || (counter[2] >= 20)) {
MQTT.publish(SHELLY_ID + "/Lampe/color", colorLamp, 0, false);
lastcolorLamp = colorLamp;
counter[2] = 0;
}
if (counter[3] >= 60) {
MQTT.publish(SHELLY_ID + "/Lampe/color/runtime", (counter[4] / 3600).toString(), 0, false);
counter[3] = 0;
}
if (colorLamp !== lastcolorLampOld) {
MQTT.publish(SHELLY_ID + "/Lampe/color/runtime", (counter[4] / 3600).toString(), 0, false);
lastcolorLampOld = colorLamp;
counter[3] = 0;
counter[4] = 0;
}
}
} catch (e) {
print(e);
}
}
///
function timer1000Handler() {
try {
MQTTconnect = MQTT.isConnected();
//
if ((false == false) && (counter[1] >= 900)) {
}
//
if (counter[0] >= 5 && log != 0) {
print("HeartBeat: " + counter[1] + " / " + maximumCycle + " / " + lastcolorLamp + " / " + MQTTconnect + " / " + MQTTpublish);
print("KESSEL Status: " + KESSELStatus + " " + KESSELStatusInfo + " Temperatur: " + KESSELTemperatur + "°C");
print("PUFFER Temperatur oben: " + PUFFERTemperaturoben + " °C Ladezustand " + PUFFERLadezustand + "%");
counter[0] = 0;
}
//
for (let i = 0; i < counter.length; i++) {
counter[i] = counter[i] + 1;
}
} catch (e) {
print(e);
}
}
///
Timer.set(666, true, timer666Handler, null);
Timer.set(1000, true, timer1000Handler, null);
///
///
///
function changeLEDs(red, green, blue, brightness) {
try {
let config = {
"config": {
"leds": {
"colors": {
"switch:0": {
"on": {
"rgb": [red, green, blue],
"brightness": brightness
}
}
}
}
}
};
Shelly.call("PLUGS_UI.SetConfig", config);
} catch (e) {
print(e);
}
}Interessant wie Shelly Variablen-Declarationen behandelt. (let vs. const)
-> Good to know 
weiß jemand, wo man Shelly eine Rückmeldung zur Beta-Version geben kann?
Hier:
Ok, danke für den tiefen Einblick in die Limitierungen deiner an und für sich genialen Grund-Idee bzw. der verbundenen Script Umsetzung.
Da nun doch ein paar weitere Fragezeichen für mich am Schirm sind, werde ich mich ein wenig tiefer in die Materie und deinem Script einarbeiten.
Auszugsweise, für mich offene Punkte:
wosjack Ich denke du solltest dir den unten angefügten Link nochmal durchlesen.
Dynamische Stromtarife: Für wen es sich lohnt und worauf Sie achten sollten
Der "Arbeitspreis" welchen du bei dynamischen Strompreisen bezahlst beinhaltet auch noch Steuern, Abgaben, Umlagen und Netzentgelte etc. Diese sind bis auf die Steuern vom jeweiligen EVU-Anbieter abhängig.
Wir reden hier beim Steuern/Regeln via Shelly's nur über den Anteil des Arbeitspreises der bei einem dynamischen Strom-Börsenpreis Vertrag auch in ganz Österreich od. Deutschland gilt.
Aktuelle Börsenpreise für die nächsten 24 Std. Österreich
Aktuelle Börsenpreise für die nächsten 24 Std. Deutschland
Also die API Daten über den dynamischen Anteil erhält jeder frei. Der Rest ist Anbieterabhängig.
Hab mir dein 'genialen' Script runtergeladen und wie auch TomPu31 schreibt passiert erst mal nix. (bzw. bis zur nächsten Scheduled Time dann ist auch ein KVS vorhanden)
Ich hab als Workaround/rascheren Lebenszeichen einfach mal "calculate()" in die Eingabezeile eingetragen und bestätigt. -> Augenblicklich erschien der log und KVS wurde korrekt eingetragen.
Was spricht dagegen, wenn beispielhaft kein KVS vorhanden d.h. beim ersten Start einmal diesen Aufruf automatisch auszuführen? -> Würde die Verwirrung beim ersten Installieren reduzieren.
Trotzdem hast du hiermit ein sehr smartes, hilfreiches Tool entwickelt.
Werden die Daten der SQL Abfrage automatisch erneuert, oder muss ich sie neu anstoßen?
Habe im Beitrag #17 versucht diese Frage vorab zu klären.
Das ist eine Besonderheit von SQLite bzw. HA. Schon seit dem ersten Release von HA wird darüber diskutiert,
Bisher wurde keine wirklich brauchbare Lösung gefunden...
Also einfach für irgend einen Temp Sensor gestern um 12:00 und ein Beispiel am Sonntag 18:00?
Die zwei Beispiele:
Aussentemperatur gestern 12:00:
SELECT
states.state
FROM
states
INNER JOIN states_meta ON states.metadata_id = states_meta.metadata_id
WHERE
states_meta.entity_id = 'sensor.aussen_temperatur'
AND last_updated_ts <= unixepoch(
datetime(
'now', 'localtime', 'start of day',
'-14 hours'
)
)
ORDER BY
last_updated_ts DESC
LIMIT
1;Aussentemperatur letzter Sonntag 18:00:
SELECT
states.state
FROM
states
INNER JOIN states_meta ON states.metadata_id = states_meta.metadata_id
WHERE
states_meta.entity_id = 'sensor.aussen_temperatur'
AND last_updated_ts <= unixepoch(
datetime(
'now', 'localtime', 'start of day',
'-8 hours', 'weekday 0'
)
)
ORDER BY
last_updated_ts DESC
LIMIT
1; apreick Mit ein wenig SQL Syntax hast dann alle Türen für jede denkbare Daten -verknüpfung und -analyse offen.
Wird die SQL Datenbank dann "unendlich" groß oder kann man die irgendwie wieder dynamisch löschen?
Theoretisch ja, Jedoch hat HA einen internen Algorithmus per default, welcher nur für 10 Tage Daten feingranual speichert.
Danach werden die Daten reduziert aber haben immer noch einen sehr gutes Abbild der historischen Vergangenheit.
Beispiel Außentemp. dieses Jahr:
Möchte es am Ende noch die Möglickeit haben, dass der HA auf einem RasPi läuft, falls mir mal der Server ausfällt.
Temperaturänderung pro Stunde/Tag
Änderung der Bodenfeuchtigkeit pro Stunde/Tag
Änderung des Luftdrucks pro Stunde/Tag
usw
Alle diese Werte könnte ganz elegant auch mit SQL Querys zum lösen sein!
SQL Vorteil zu allen anderen möglichen Varianten:
Wenn du willst erzeuge ich dir ein Beispiel.
Die einzelnen Schritte:
Aber irgendwo wird da wohl noch der Haken sein
Wie soll ich da etwas im Voraus berechnen, ob sich das lohnt, wenn ich die Preise vorher nicht kenne.
Dynamische Strompreise basieren auf Produktions-, Verbrauchs- und Wetter- Prognosen. (Strompreis-Börse)
Dieser Wert kann falls man über einen entsprechenden Tarif verfügt, auch via API (Shelly-Script) direkt zum Steuern von Verbrauchern nutzen. (Ist auch keine Raketen-Technologie)
Heute:
Morgen:
Diese Daten liegen in der Regel schon mindestens 2 Tage vor und sind auch bindend.