VPN/Proxy erkannt
Es scheint, dass Sie einen VPN- oder Proxy-Dienst verwenden. Bitte beachten Sie, dass die Nutzung eines solchen Dienstes die Funktionalität dieser Webseite einschränken kann.
Shelly.addStatusHandler(function(event) {
print(event);
if (event.component === "switch:0") {
if (event.delta.output === true) {
MQTT.publish("stat/s_ug_heizung_brenner_temp/POWER", JSON.stringify(1), 0, false);
} else if (event.delta.output === false)
{
MQTT.publish("stat/s_ug_heizung_brenner_temp/POWER", JSON.stringify(0), 0, false);
}
}
});Debug dir mal event und schaue was in den JSON ankommt.
Von einem Modul wird auch der analoge Wert erfasst.
DIYROLLY Wie sind die Werte bei der Analog Messung mit LDR Modulen? Ich habe beim Anschluss Fotowiederstand + AddOn bei Sonnenlicht, bzw. wenn des sehr hell ist, Werte die sehr nahe bei einander liegen. > 98 bis 99.9. Sind die Werte mit LDR Modul anders?
Mein Wunsch: Die Raffstore (Jalousien) sollen bei Sonnenintensität nach Überschreitung von X zeitverzögert (10 min.) schließen. Nach Unterschreitung von X sollen sie zeitverzögert öffnen.
Deine Messperiode ist dann nur 1x á 10 Min.
Meiner Erfahrung nach würde ein Messen in 30 Min Messzeitraum mehr Sinn machen. Bei Wechsel von Sonnen und Wolken könnte es sein das deine Jalousien alle 10 Min hoch und runter fahren. Bei Raffstores wäre das nicht so schlimm. Mann kann ja die Kippsteuerung nehmen.
Im 30 Min Messzeitraum jede Minute die Helligkeit messen und zählen ob Wert über- oder unterschritten wurde.
Aus den zwei Summen kann man dann entscheiden ob beschattet werden soll oder nicht.
Beispiel: in 30 Min. wurde 20x Sonnen und 10x Schatten gezählt also Sonnen überwiegt -> Beschatten.
Die Steuerung sollte auch ohne Script über Szenen möglich sein.
Wie würdest du das per Szene machen?
Beschatten bleibt eine König Disziplin.
Ich habe 12 Jalousie/Raffstore Antriebe auf Shelly Pro Dual Cover umgestellt. Vorher hatte ich 20 Jahre ein System von Theben.
Frage: Wie bringe ich die Lichtsensoren mit den Dual Cover zusammen?
Über ein Plus AddOn?
Wäre das möglich und wenn ja wie?
In der Frage steht nicht was Riggermoos damit bezwecken will. Aber im Kontext geht es wohl um die Steuerung der Jalousien / Raffstores mit dem Sensor. Warum umrechnen? Der Fotosensor liefert einen Wert zwischen 0 und 100 am ID Ausgang.
Beispiel Automation: Wenn Wert > 98 = Sonne: dann beschatte. Wenn Wert < 98 = Bewölkt: dann beschatte nicht.
Mit einem Script lässt sich das präzise steuern.
OK, ein Fotowiederstand.
Shelly AddOn nehmen und so anschließen.
Das sieht doch schon gut aus! Bravo!
Noch zwei Anmerkungen:
Mit Happen aus deinem ersten Code habe ich mir grad folgendes zusammengebaut, der erste Test funktioniert:
CodeCall('HTTP.get',{url: 'http://192.168.0.' + IP + '/light/0?turn=on&red=0&green=0&blue=0&white='+ SZ_RGBW.white});Der Auslöser der RGBW_setzeWeiss ist ja der erste Switch, das Gleiche würde ich jetzt für den zweiten Switch bauen, nur halt in farbig.
Durch den Trigger des Switches ist dann ja dein Loop überflüssig.
Wie liest du diesen Code, ist er sauber?
Beim Call Solltest du RPC Verwenden. Das ist die aktuelle Methode die Shelly in der API beschreibt.
Beispiel: http://192.168.33.1/rpc/Switch.Set?id=0&on=true
https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/RGBW
Ist die Fehlerbehandlung überhaupt nötig? Die IPs sind alle fest vergeben, auch der Test wenn der Shelly stromlos ist, lässt das Script nicht abstürzen, lediglich: "Error: ErrorChk(), call Answer ---> Error Cannot read property 'body' of undefined" kommt
Natürlich kann man hier auf ein Error Handling verzichten.
In anderen Programmiersprachen kann das aber zum Crash führen.
Simples Beispiel: Du möchtest aus der Cloud Daten abrufen. Ist die aber nicht erreichbar, sollte zwingend der Error Request im Code behandelt werden.
Ich mache es aber, und Kommentiere dann den Error Request aus. Gibt es irgendwann ein problem mit der Ausführung des Codes,
kann ich ihn wieder einschalten und mir den Fehler im Log einfach anzeigen lassen.
2fach Switch.
Taste 1 drücken:
Taste 2 drücken:
Würde das Script so gestalten:
Einen Callback wäre dann nicht nötig.
let CONFIG = {
IPs: ["192.168.x.x", "192.168.x.x"],
}
Loop (ip durch CONFIG.IPs) {
istLampeOn(ip);
}
function istLampeOn(ip) {
Call("http.get",{url: "http://192.168.1." + IP + "/light/0", timeout: 3}, // Status der Lampe abfragen
function (x) {
let state = JSON.parse(x.body).ison; // Bool
let mode = JSON.parse(x.body).color; // String
...
function set(ip, state, mode); // Daten vorhanden ->
}
function set(ip, state, mode, ...) {
// Auswerten und set RGB Shelly
}Wenn das nicht funktioniert müsste man die beiden (Switch 1 + 2) ineinander verschachteln mit Callback, sodas alles nacheinander ausgeführt wird.
Eine Verständnisfrage:
Sehe ich es richtig, dass der Code der function aus Zeile 2-6 erst nach einer Antwort ausgeführt wird? Also ohne Einbau deines Loopbacks? Bzw. die Function "hauptCode" ist dann quasi der Loopback da sie erst nach einer Antwort aufgerufen wird?!
Dein Hautcode läuft stur von 1 - 11 durch.
In der Funktion: function istLampeOn(ip, callback) {..} ist callback eine Funktion. Also: istLampeOn(value, function) {..}
Durchlauf des Codes #1 bis #4
// #2 Funktion wird aufgerufen und ausgeführt
function istLampeOn(ip, callback) {
Shelly.call(
"http.get",
..
function (result, error_code, error_message) {
...
// #3 Variable wird funktion Callback übergeben.
callback(jsonData.ison, null); // value an Callback weitergeben
}
}
);
}
// #1 Starte funktionsaufruf
istLampeOn(CONFIG.ip, function (state, error_message) { // calback = function (state, error_message)
// #4 Variable wird von Callback empfangen.
});Ich habe den RGB Shelly nicht. Kannst du mit dem Http.Get Befehl im JSON.Body
alle Zustände (RGBW / fabig / on / off) auf einmal lesen?
print(JSON.parse(x.body);
Ich weis ja nicht wofür dein Script bestimmt ist.
Wenn dein Script im Timer Loop läuft, wäre das vielleicht nicht weiter ein Problem, da beim nächsten Durchlauf die Variable korrekt wäre.
Bei einmaligen Aufruf müsstest du dein Script so umstellen das aus der Funktion dein Hauptteil wieder als Funktion aufgerufen wird.
Also die Funktionen ineinander verschachteln.
Ein direkter Code im Haupt Thread ist dann nicht mehr möglich.
istLampeOn(CONFIG.ip, function (state, error_message) {
if (error_message) {
print("Fehler: " + error_message);
} else {
hauptCode(state);
}
});
function hauptCode(input) {
// Weiter... input verarbeiten..
}Wie Gesagt dein wie mein Code läuft Asynchron.
Zeitlicher Ablauf deines Codes vereinfacht:
1. var ret=false;
2. Call Function istLampeOn(IP){..}; // Http.Get Aufruf Benötigt Zeit um Daten zu lesen.. -> Übergabe in funktion(x)
Äußere Funktions Aufruf beendet -> Rückgabe: return ret = false weil
function (x) { if (JSON.parse(x.body).ison) ret=true; }); noch nicht beendet ist.
3. Print immer false
4. Ende
5. Erst jetzt würde (JSON.parse(x.body).ison) ret=true; }) gelesen werdenDeswegen der Callback fuction Aufruf, der auf die Fertigstellung der Anfrage wartet und dann das Ergebnis liefert.
In anderen Programmiersprachen wie z.B. Swift wird das als CompletionHandler bezeichnet.
Man könnte auch ein Timer einsetzen und 1 Sekunde warten.. Aber das ist kein guter Programmierstiel.
Kann es leider nicht Testen...
Habe ein Callback eingefügt weil der Code Asynchron abläuft.
let CONFIG = {
ip: "192.168.xxx.xxx"
};
function istLampeOn(ip, callback) {
Shelly.call(
"http.get",
{
url: "http://" + ip + "/light/0",
timeout: 3
},
function (result, error_code, error_message) {
if (error_code !== 0) {
callback(null, error_message); // Fehler an den Callback weitergeben
} else {
try {
let jsonData = JSON.parse(result.body);
callback(jsonData.ison, null); // Erfolg an den Callback weitergeben
} catch (e) {
callback(null, "JSON-Parsing-Fehler: " + e.message); // Parsing-Fehler
}
}
}
);
}
istLampeOn(CONFIG.ip, function (state, error_message) {
if (error_message) {
print("Fehler: " + error_message);
} else {
print("Lampe ist " + (state ? "an" : "aus"));
}
});Hast du Erfahrung mit Shelly Code schreiben?
Probiere mal auf einen anderen Shelly ob du von dort aus ihn ansprechen kannst:
Lege dafür ein Script an, Aktiviere den Debug Modus und starte das Skript.
-> danach Script stop -> dann wieder play Script.
Dein Shelly sollte dann "toggle" von hand ausführen ohne Fehlermeldung.
let url = "http://192.168.xxx.xxx/relay/0?turn=toggle"; // IP: von Shelly 1 Plus
function logResponse(res, error_code, error_msg) {
if (error_code === 0) {
print("Response:", res.body);
} else {
print("Error:", error_msg);
}
}
Shelly.call("http.get", { url: url }, logResponse);Wenn Tim_St seine Wünsche genauer beschreibt, kann ich auch den Schaltplan ändern.
Aber man müsste auch die Verkabelung berücksichtigen die vorhanden ist.
Der beste Schaltplan nützt nichts, wenn man ihn nicht umsetzen kann.
Erst mal den Shelly checken ob der Shelly korrekt auf cover eingerichtet ist.
Würde die Jarolift Typ Thor entfernen. Einfache Jalousie - Doppel taster einbauen.
Der Shelly lässt sich viel besser als Schaltuhr konfigurieren.
Im Handbuch schauen wo der Handtaster am Antrieb angeschlossen ist.
Dort werden dann Parallel dazu die potenzialfreien Kontakte des Shelly 1 angeschlossen.
Es hat keine feste Zeit. Wenn mein Windmesser Script mir Sturm meldet (wird im Script errechnet) möchte ich mir auch eine Push Nachricht zusenden lassen.
Ich suche eine Möglichkeit per Script eine Push Benachrichtigung abzusetzen.
Es ist eine reine Textnachricht ohne Variablen.
Ich habe mich schon mit diesem Beitrag beschäftigt aber mich stört das im Script der cloud Key hinterlegt werden muss.
Gibt es eine Möglichkeit eine Szene anzulegen um diese dann per Script zu starten sodas die Szene die Nachricht sendet?
Ist das vielleicht mit Virtuellen Komponenten möglich?
Ich möchte keine Alternativen Push Systeme wie Telegram & Co benutzen.
Hat jemand schon so etwas erfolgreich eingerichtet?