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.
Ich hab einen (den?) Fehler gefunden!
Im Fehlerfall hatte ich im script immer console.error stehen. Das kennt der shelly wohl nicht. Ich hab das auf console.log korrigiert. Damit wurde die Funktion im Fehlerfall mit Fehlermeldung abgearbeitet und das script lief weiter.
Ich habe trotzdem noch alle 3 Funktionen, die http.get verwenden, mit timeout und try…catch versehen.
Bin gespannt, wie lange das jetzt läuft!
Danke für die Erklärung. Das macht Sinn. Werde ich einbauen und Rückmeldung geben
Aber das ist hier doch gegeben? Script sollte im Fehlerfall weiterlaufen, oder nicht?
function setLampColorTemp(ipAddress, colorTemp) {
const url = 'http://' + ipAddress + '/light/0?temp=' + colorTemp;
Shelly.call(
'HTTP.GET',
{
'url': url
},
function (response, error_code, error_msg) {
//console.log('Antwort von HTTP.GET:', response, error_code, error_msg);
if (error_code === 0 && response && response.code && response.code === 200) {
console.log('Farbtemperatur erfolgreich an die Lampe gesendet:', colorTemp);
}
else {
console.error('Fehler: HTTP-Anfrage fehlgeschlagen:', error_msg);
}
}
);
}Mit den http endpoints hab ich verstanden und erfolgreich getestet.
Zu den Beschränkungen gehört aber auch, nur 3 scripts können gleichzeitig laufen. Dann wär der i4 voll. Ich hab in dem Raum noch RGBWs mit denen ich das gleiche machen will und was mit dimmen wollte ich auch noch versuchen.
Also würde ich das gerne in einem script belassen. Was ich weiß: Wenn ich checklampstatus und somit auch setlampcolortemp nicht aufrufe, läuft das script durch. Ich hab den http.get in setlampcolortemp als Verursacher in Verdacht. Kann ich da irgendwie den Fehler fangen, um ihn später auszulesen?
Danke für die Anregungen. Die Seiten kannte ich tatsächlich nicht. Zu deinen Punkten noch ein paar Nachfragen:
Welchen Vorteil hätten denn getcomponentstatus.time und .unixtime gegenüber meinem Abruf? Man muss zwar nicht parsen, da das Ergebnis in hh:mm ausgegeben wird. Aber da die Sonnenuntergangszeit in UTC ist, müsste ich beide Zeiten abrufen, und die GMT Differenz errechnen, damit das in Sommer- und Winterzeit funktioniert. Ich glaube, das würde nicht viel kürzer werden.
Wenn du konkrete Stellen oder Ansätze hast, wo ich das script noch vereinfachen kann, gerne her damit.
Auf mehrere scripts aufteilen kann ich machen. Ich dachte die Belastung für den Shelly wäre höher, wenn mehrer scripts parallel laufen. Wieviele dürfen das parallel sein?
Und Variablen übergeben würde ich dann wohl mit kvs.set und get (?)
ostfriese und natürlich gern auch alle anderen, hier mein aktuelles script.
Kurze Erläuterung: ich realisiere hiermit HCL, genauer gesagt den abendlichen Wechsel von Kaltweiß zu Warmweiß für 3 Duo Leuchten auf einem i4, beeinflussbar durch ein paar User Parameter.
Dafür müssen natürlich ein paar Sachen abgerufen und berechnet werden. Der Hauptablauf ist einmal die Funktion initscript, die beim Start und dann einmal täglich die nötigen Funktionen aufruft, und die Funktion gradientcycle, die zyklisch (zum Test alle 60s) die entsprechenden Aufrufe macht. Mittels den Verschachtelungen habe ich es erreicht, dass die Funktion einzeln erst abgearbeitet werden, und erst danach (plus Wartezeit) die nächste Funktion aufgerufen wird. Das ist somit meine am stabilsten laufende Version des scripts, aber auch das hält gerne nach ein paar Stunden an.
Hier das script, bei Unklarheiten bitte fragen:
(zum Testen einfach oben in den Variablen 3 echte ip Adressen von Lampen eintragen, sollte so überall laufen)
// User Parameter
let GradDur = 120; // Gradient Duration in Minuten
let GradOffset = 0; // Gradient Offset in Minuten, 0 = Ende Sonnenuntergang
let ColTempMin = 2703; // Min Wert der Farbtemperatur in Kelvin (Shelly Duo = 2703 Warm)
let ColTempMax = 6500; // Max Wert der Farbtemperatur in Kelvin (Shelly Duo = 6500 Kalt)
let initTimerDuration = 5 // Zykluszeit der Initialisierungsschritte in s !!nicht verändern !!
let cycleTimer = 1*60 // Zykluszeit des Gradienten in s
let cycleStepTimer = 5 // Zykluszeit der Einzelschritte des Gradienten in s
let newDayAt = "05:00"; // Uhrzeit der Neuinitalisierung für Abruf Sonnenuntergang und Gradientstatus auf 0
let Lat = "52.5200"; // Breitengrad für Berlin
let Lng = "13.4050"; // Längengrad für Berlin
let ShellyDuoIP1 = "192.168.X.XXX"; // IP-Adresse des ersten Shelly Duo-Geräts
let ShellyDuoIP2 = "192.168.X.XXX"; // IP-Adresse des zweiten Shelly Duo-Geräts
let ShellyDuoIP3 = "192.168.X.XXX"; // IP-Adresse des dritten Shelly Duo-Geräts
// Globale Variablen
let gmtOffsetMinutes = 0; // Differenz GMT zu UTC Zeit in Minuten
let localMinutes = 0; // Uhrzeit in Minuten
let sunsetMinutes = 0; // Sonnenuntergang in Minuten
let gradientEnd = 0; // Gradientende in Minuten
let gradientStart = 0; // Gradientstart in Minuten
let gradientStatus = 0; // 0: vor Start, 1: während, 2: nach Ende des Gradienten
let CurrentColorTemp = ColTempMin; // aktuelle Farbtemperatur
let timeUntilGradientStart = 0; // Minuten bis Gradient startet
let newDayInitCalled = false; // wurde neuer Tag heute schon initialisiert?
function getNumber(string, start, len) {
// Ziffern aus einer Zeichenkette als Zahl, 1. Zeichen hat Index 0
let number = 0;
let factor = Math.pow(10, len - 1);
for (let i = start; i < start + len; i++) {
// Weil bisher keine Typumwandlung funktioniert, Konvertierung über ASCII-Code, "0" => 48
number = number + (string.at(i) - 48 ) * factor;
factor = factor / 10;
}
return number;
}
function calculateMinutesFromMidnight(time) {
// Datum & Zeit extrahieren
let h = getNumber(time, 11, 2);
let m = getNumber(time, 14, 2);
// Umrechnen in Minuten seit Mitternacht
return h * 60 + m;
}
function minutesToTime(minutes) {
// Stunden und Minuten berechnen
let hours = Math.floor(minutes / 60);
let mins = minutes % 60;
// Uhrzeit formatieren
let formattedHours = hours < 10 ? '0' + hours : hours;
let formattedMins = mins < 10 ? '0' + mins : mins;
let formattedTime = formattedHours + ':' + formattedMins;
return formattedTime;
}
function startGradient(callback) {
console.log('Gradient Offset: ' + GradOffset + ' min');
gradientEnd = sunsetMinutes + GradOffset;
gradientStart = gradientEnd - GradDur;
timeUntilGradientStart = gradientStart - localMinutes;
// Überprüfen, ob die aktuelle Zeit vor dem Start des neuen Tages liegt
if (localMinutes < calculateMinutesFromMidnight(newDayAt)) {
// Setze gradientStatus auf 2, um sicherzustellen, dass er nicht auf 0 zurückgesetzt wird
gradientStatus = 2;
} else {
// Überprüfen des Gradientenstatus basierend auf der aktuellen Zeit
if (localMinutes < gradientStart) {
gradientStatus = 0;
} else if (localMinutes >= gradientStart && localMinutes <= gradientEnd) {
gradientStatus = 1;
} else {
gradientStatus = 2;
}
}
console.log('GradientStatus:', gradientStatus);
console.log('Gradient von ' + minutesToTime(gradientStart) + ' Uhr bis ' + minutesToTime(gradientEnd) + ' Uhr');
console.log('Sonnenuntergang um ' + minutesToTime(sunsetMinutes) + ' Uhr');
if (gradientStatus === 0) {
console.log('Gradient beginnt in ', minutesToTime(timeUntilGradientStart) + ' h');
CurrentColorTemp = ColTempMax;
} else if (gradientStatus === 2) {
console.log('Gradient endete vor ' + minutesToTime(localMinutes - gradientEnd) + ' h');
CurrentColorTemp = ColTempMin;
} else if (gradientStatus === 1) {
let remainingMinutes = gradientEnd - localMinutes;
console.log('Gradient läuft noch ' + remainingMinutes + ' Minuten von ' + GradDur + ' Minuten');
CurrentColorTemp = calculateCurrentColorTemp(localMinutes);
// Runden auf ganze Zahl
CurrentColorTemp = Math.round(CurrentColorTemp);
}
console.log('Aktuelle Farbtemperatur: ' + CurrentColorTemp + 'k');
callback();
}
function calculateCurrentColorTemp(currentMinutes) {
// Berechne Fortschritt innerhalb des Gradienten
let progress = (currentMinutes - gradientStart) / GradDur;
// Interpoliere zwischen ColTempMax und ColTempMin basierend auf dem Fortschritt
return ColTempMax - (ColTempMax - ColTempMin) * progress;
}
// Funktion zum Abrufen und Ausgeben der lokalen Zeit und des GMT-Offsets
function getLocalTime(callback) {
let currentDate = new Date();
localMinutes = currentDate.getHours() * 60 + currentDate.getMinutes();
// Extrahieren des GMT-Offsets aus dem toString-Ergebnis
let offsetString = currentDate.toString();
let sign = offsetString.charAt(offsetString.length - 5) === '-' ? '-' : '';
let hoursOffset = offsetString.substr(-5, 3);
let minutesOffset = offsetString.substr(-2);
let gmtOffsetString = sign + hoursOffset + minutesOffset;
gmtOffsetMinutes = parseInt(hoursOffset) * 60 + parseInt(minutesOffset);
console.log("Lokale Zeit:", minutesToTime(localMinutes), "Uhr, GMT", gmtOffsetString);
if (callback) {
callback();
}
}
function setLampColorTemp(ipAddress, colorTemp) {
const url = 'http://' + ipAddress + '/light/0?temp=' + colorTemp;
Shelly.call(
'HTTP.GET',
{
'url': url
},
function (response, error_code, error_msg) {
//console.log('Antwort von HTTP.GET:', response, error_code, error_msg);
if (error_code === 0 && response && response.code && response.code === 200) {
console.log('Farbtemperatur erfolgreich an die Lampe gesendet:', colorTemp);
}
else {
console.error('Fehler: HTTP-Anfrage fehlgeschlagen:', error_msg);
}
}
);
}
function checkLampStatus(ipAddress, callback) {
console.log('Status wird abgerufen von:', ipAddress);
Shelly.call(
'HTTP.GET',
{'url': 'http://' + ipAddress + '/status'},
function (response, error_code, error_msg) {
//console.log('Antwort von HTTP.GET:', response, error_code, error_msg);
if (error_code === 0 && response && response.code && response.code === 200) {
const responseData = JSON.parse(response.body);
const lampStatus = responseData.lights[0].ison;
const colorTemp = responseData.lights[0].temp;
if (lampStatus) {
console.log('Die Lampe ' + ipAddress + ' ist eingeschaltet. Farbtemperatur: ' + colorTemp);
if (colorTemp !== CurrentColorTemp) {
console.log('Die Farbtemperatur unterscheidet sich von der gespeicherten Farbtemperatur.');
setLampColorTemp(ipAddress, CurrentColorTemp); // Aktualisierte Farbtemperatur übergeben
//console.log('Die Farbtemperatur wurde aktualisiert:', CurrentColorTemp);
} else {
console.log('Die Farbtemperatur stimmt mit der gespeicherten Farbtemperatur überein.');
}
} else {
console.log('Die Lampe ' + ipAddress + ' ist ausgeschaltet.');
}
// Aufruf der Callback-Funktion, wenn die Funktion abgeschlossen ist
if (callback) {
callback();
}
}
else {
console.error('Fehler: HTTP-Anfrage fehlgeschlagen:', error_msg);
// Aufruf der Callback-Funktion auch im Fehlerfall, falls gewünscht
if (callback) {
callback();
}
}
}
);
}
function callSunset(callback) {
Shelly.call('HTTP.GET', { url: 'https://api.sunrise-sunset.org/json?lat=' + Lat + '&lng=' + Lng + '&formatted=0' },
function(res, error_code, error_msg, ud) {
if (error_code === 0 && res.code === 200) { // Überprüfen, ob der API-Aufruf erfolgreich war
let obj = JSON.parse(res.body);
let sunset = obj.results.sunset;
let sunsetUTCMinutes = calculateMinutesFromMidnight(sunset); // Sonnenuntergang in UTC-Minuten
sunsetMinutes = sunsetUTCMinutes + gmtOffsetMinutes; // Sonnenuntergang in Ortszeit-Minuten
// Umrechnung in Stunden und Minuten
let sunsetTime = minutesToTime(sunsetMinutes);
console.log('Sonnenuntergang abgerufen: ' + sunsetTime + ' Uhr (Ortszeit)'); // Ausgabe in Stunden und Minuten
// Rückruf aufrufen, nachdem der Sonnenuntergang abgerufen wurde
callback();
} else {
console.error('Fehler beim Abrufen des Sonnenuntergangs:', error_msg);
}
}
);
}
function initScript() {
console.log("*****Initialisiere Script*****");
newDayInitCalled = true; // neuer Tag wurde initialisiert
let functions = [
getLocalTime,
callSunset,
startGradient,
function() {
console.log("*****Initialisierung abgeschlossen*****");
}
];
let index = 0;
function executeNextFunction() {
if (index < functions.length) {
functions[index++](function() {
Timer.set(initTimerDuration * 1000, false, executeNextFunction); // Verwendung von initTimerDuration
});
}
}
executeNextFunction();
}
function GradientCycle() {
let functions = [
getLocalTime,
startGradient,
function(callback) {
// Array mit den IP-Adressen der Lampen
let lampIPs = [ShellyDuoIP1, ShellyDuoIP2, ShellyDuoIP3];
// Funktion, um rekursiv die Lampen zu überprüfen
function checkNextLamp(index) {
if (index < lampIPs.length) {
// Überprüfe die Lampe und rufe die nächste Lampe auf, wenn abgeschlossen
checkLampStatus(lampIPs[index], function() {
// Timer für die Pausen zwischen den Überprüfungen der Lampen
Timer.set(cycleStepTimer * 1000, false, function() {
checkNextLamp(index + 1);
});
});
} else {
// Alle Lampen überprüft, führe die nächste Aktion aus
console.log("Alle Lampen überprüft.");
callback();
}
}
// Starte die Überprüfung der Lampen
checkNextLamp(0);
}
];
let index = 0;
function executeNextFunction() {
if (index < functions.length) {
functions[index++](function() {
Timer.set(cycleStepTimer * 1000, false, executeNextFunction); // Verwendung von cycleStepTimer
});
} else {
// Nur wenn alle Funktionen abgeschlossen sind, rufe checkNewDayInit auf
checkNewDayInit();
}
}
// Starte den Ausführungszyklus
executeNextFunction();
}
function checkNewDayInit(callback) {
// Extrahiere Stunden und Minuten aus newDayAt
let newDayHours = parseInt(newDayAt.split(':')[0]);
let newDayMinutes = parseInt(newDayAt.split(':')[1]);
// Konvertiere newDayAt in Minuten seit Mitternacht
let newDayAtMinutes = newDayHours * 60 + newDayMinutes;
// Überprüfe, ob es ein neuer Tag ist (0:00 Uhr erreicht wurde)
if (localMinutes < newDayAtMinutes) {
newDayInitCalled = false; // Setze das Flag auf false, um sicherzustellen, dass initScript() am neuen Tag aufgerufen wird
}
// Überprüfe, ob die aktuelle Zeit das neue Tag-Startdatum erreicht oder überschreitet
if (localMinutes >= newDayAtMinutes && !newDayInitCalled) {
initScript(); // rufe initScript auf, wenn das neue Datum erreicht ist
}
// Führe den Rückruf aus
if (callback) {
callback();
}
}
// Initialer Aufruf der Funktionen
initScript();
// Aufruf der GradientCycle-Funktion
Timer.set(cycleTimer * 1000, true, function() {
GradientCycle();
});Für allgemeine Vorschläge zur Vereinfachung bin ich ebenso offen 😃
Seitdem ich bei den Lampen Off nach Power On eingestellt habe. Scheint der Fehler weg. Das war ja zu einfach...
Wo der Power On aber herkam, bleibt ungeklärt. Ich habe einen Shelly Plus 1 vorgeschaltet. Vielleicht 'flackert' der mal.
Waren das nicht 5 Timer pro script?
Ich habe das jetzt, bzw. bin noch dabei in Gruppenarbeit mit Chat GPT 😃 das zu erarbeiten und hab das script fast fertig stabil am laufen.
Callbacks auch für asynchrone funktion wie http.get ist das Stichwort.
Kann ich gerne hier posten, wenn es stabil läuft. Bis dahin melde ich mich, falls ich auf unüberwindbare Probleme stoße.
Booten lässt die Lampen unbeeindruckt. An bleibt an, aus bleibt aus.
EDIT: Oder meinst du die Lampen selber? Stand bei allen auf On, hab ich ich jetzt auf Off geändert. Werds weiter beobachten.
Ich habe jetzt ein script geschrieben, das alle 10min prüft, ob nur eine von 3 Lampen an ist, und dann ggf. abschaltet. Das behebt zwar nicht den Fehler (den hätte ich schon gern gefunden), aber immerhin die Auswirkung.
Hallo,
Wie kann ich das zyklische Ausführen von Funktionen am Besten ausführen?
Ich kenn mich nicht gut aus mit JavaScript, und versuche mir das Stück für Stück zu erarbeiten, aber hier komme ich nicht weiter.
Ich möchte:
1. Funktion A aufrufen. Da ich hier eine url abfrage und parse, dauert es ein paar Sekunden, bis die Funktion abgearbeitet ist; deshalb
2. Funktion B aufrufen mit einem Delay, da sie Variablenwerte braucht, die in Funktion A beschrieben wurden.
3. Funktion A dann alle 24h ausführen,
4. Funktion B alle 60s ausführen.
Es scheitert bei mir schon beim Delay. Das einzige, was ich mit Zeitverzögerung hinbekommen habe, war über Timer.Set.
Hier ist es aber so, dass das Script entweder stehen bleibt ohne Fehler, oder abbricht mit der Meldung To Many Timers, wenn ich 2, 3 und 4 mit Timern aufbaue.
Einzeln laufen beide Funktionen. Noch zu 2., logischer wäre es eigentlich, wenn der Aufruf kommt, wenn A abgearbeitet ist. Aber das hab ich erstrecht nicht hinbekommen.
Wie würde man so etwas aufbauen?
Hier noch Beispielhaft, was ich versucht habe, ist bei mir ganz am Ende des Scripts:
// Aufrufe
FunktionA();
Timer.set(24 * 60 * 60 * 1000, true, FunktionA);
Timer.set(10 * 1000, 0, FunktionB);
Timer.set(60 * 1000, true, FunktionB);Ja stimmt, habe ich schlecht formuliert. Ich habe ein script, dass auf einem i4 läuft und die Duos anspricht. Das ist aber derzeit deaktiviert.
Cloud ist über die weboberfläche deaktiviert.
Cloud ist disabled, und kein script läuft. Trotzdem waren heute wieder 2 Lampen an…
Ich habe die Duos gar nicht in die Cloud eingebunden. Von dort kann der Fehler also nicht kommen.
Evt. kommt das bei mir aus einer fehlgeleiteten funktion in einem script, an dem ich gerade bastele. Obwohl das eigentlich nicht sein kann, einen turnon befehl habe ich gar nicht drin. Nur setzten von Farbtemperatur, wenn eingeschaltet . Aber wer weiß . Ich werde das weiter beobachten.
Dank dir, funktioniert. In der Shelly App zeigt er ca. minütlich die Werte an. Jetzt muss ich nur noch sehen, dass ich ihn per script abgefragt bekomme oder dass er eine url sendet.
Die neuen BluMotion Sensoren zeigen die Werte NUR bei Auslösung an....und nicht kontinuierlich oder in festen Zeitabständen, das ist so in Ordnung
Gibt es Sensoren von Shelly, die Helligkeit zyklisch senden?
Danke! Jetzt habe ich es verstanden und erfolgreich getestet.
Mit der einen Funktion lokal lesen/schreiben, mit der anderen auf einem anderen Shelly lesen/schreiben.
Somit kann man es sich so rum oder so rum aufbauen - lokal speichern, entfernt abrufen; oder entfernt speichern, lokal abrufen.
Wenn ich so darüber nachdenke, eigentlich braucht es dafür kein Script da reicht ja ein einfacher URL Befehl aus, du kannst die KVS Werte direkt mit RPC HTTP Befehlen auf dem Shelly speichern ohne Script.
Beispiel URL: http://192.168.10.23/rpc/KVS.Set?key=testK1&value=test222
An was bastelst du denn? Wirklich trauen würde ich nem Shelly trotzdem nicht, ein Shellys ist bei mir schon über Nacht verstorben und somit auch alles was auf ihm hinterlegt war.
Muss ich auf dem Zielshelly dann eine var oder let=testK1 anlegen? Oder wie rufe ich den value auf dem Zielshelly ab?
Liefert der PlugS den aktuellen Stromverbrauch über ip/status?
Dann könnte man das auf einem 2. Gen shelly (wie dem i4) per script machen:
-1. funktion: mit http.get status des plug abfragen; power consumption parsen
-2. funktion: wenn leistung unter 5w, dann per http.post deine gewünschte url senden
-mit timer.set zyklisch (zb alle 60s) die funktionen aufrufen.
Hab nachgeschaut, meine Duos haben LongID, 12stellig.
Welchen Link meinst du? Bin anscheinend grad blind.
