Nach dem Update kann auf einem Shelly Plus 1 bei mir nur noch ein Script ausgeführt werden. Versuche ich das 2. Script über die neue App zu starten, gibt es die Fehlermeldung "Skriptfehler: out_of_memory!". Das ist sehr ärgerlich und ein deutlicher Rückschritt! Hätte gerne die alte Firmware zurück! Vermutlich hängt das mit der neu eingeführten 15kb Grenze zusammen, die den Shelly für mich unbrauchbar macht.
Gruß Martin
Die zweite Zeile scheint mir eine Fehlermeldung mit Fehlernummer zu sein: "1676459656 - L-1: E:M 19339". Der Rest gibt Auskunft über die aktuelle Speicherbelegung, was aber ohne Systemwissen unbrauchbar ist. Für mich sieht es so aus, als ob der Editor einen Speicherfehler verursacht. Derartige Blöcke finden sich mehrfach im Log und lassen sich zeitlich dem Aufruf des Editors zuordnen. Seitdem ich den Editor nicht mehr verwende und stattdessen die Scripte per ShellyScanner hochlade, starte und stoppe, gibt es bisher keine Probleme mehr.
Gruß Martin
Hallo Zusammen,
das Debugging ist (noch?) etwas mühsam. Aktuell verwende ich diverse "prints" im Script und kontrolliere die Ausgabe im Web GUI des Shellys. Leider läuft mein Script stundenlang völlig unauffällig und korrekt, um dann den Shelly scheinbar zum Absturz zu bringen.
Tritt der Fall ein, wird das Script in der Übersicht als "Running" geführt, aber klickt man auf das Script, ist der Editor leer und auch der Scriptname wird nicht angezeigt. Es ist so, als gäbe es das Script nicht. Lediglich das "Stop" deutet darauf hin, dass das Script noch zu laufen scheint. Klickt man wieder auf die Scriptübersicht, taucht das Script wieder in der Übersicht als "Running" auf. Auffällig ist auch, dass in dieser Situation die Verbindung zum Shelly ständig neu aufgebaut werden muss. Das Problem lässt sich dann nur durch einen Reboot beheben.
Nachdem ich mein Script xmal kontrolliert habe, keinen Fehler finden konnte, bin ich der Sache mit dem ShellyScanner (sehr nützliches Tool!) nachgegangen und habe folgenden Hinweis im Log gefunden:
1676459656 - L2: shelly_scripts_rpc.:332 Sending "script_2.js"
1676459656 - L-1: E:M 19339
1676459656 - L-1: Heap summary for capabilities 0x00001800:
1676459656 - L-1: At 0x3ffb6388 len 7288 free 4 allocated 6048 min_free 4
1676459656 - L-1: largest_free_block 0 alloc_blocks 78 free_blocks 0 total_blocks 78
1676459656 - L-1: At 0x3ffb9a20 len 16648 free 4 allocated 15436 min_free 4
1676459656 - L-1: largest_free_block 0 alloc_blocks 71 free_blocks 0 total_blocks 71
1676459656 - L-1: At 0x3ffcc678 len 80264 free 396 allocated 75764 min_free 4
1676459656 - L-1: largest_free_block 112 alloc_blocks 795 free_blocks 6 total_blocks 801
1676459656 - L-1: At 0x3ffe0440 len 129984 free 42616 allocated 86340 min_free 26120
1676459656 - L-1: largest_free_block 17408 alloc_blocks 26 free_blocks 9 total_blocks 35
1676459656 - L-1: At 0x3ff80000 len 8192 free 7268 allocated 0 min_free 7268
1676459656 - L-1: largest_free_block 7168 alloc_blocks 0 free_blocks 1 total_blocks 1
1676459656 - L-1: Totals:
1676459656 - L-1: free 49644 allocated 184232 min_free 33400 largest_free_block 17408
Für mich sieht es so aus, dass nicht mein Script, sondern das Web GUI die Ursache für das merkwürdige Verhalten ist. Scheinbar verursacht der Aufruf des Editors das Problem? Ein Temperaturproblem ist es nicht, weil die Shelly Temperatur laut ShellyScanner unter 45 Grad bleibt. Kann man den Fehlercode (Firmware 0.13.0, Shelly Plus1) irgendwo nachlesen?
Gruß Martin
Wenn es auch ein Script sein darf, schau dir doch einmal RPC Limit durch RPC Queue vermeiden - Shelly Scripting - Offizielles technisches Shelly Support Forum (DACH) (smarthome-forum.eu) an. Wenn du maxrpcQueueCallbackStacksize = 1 setzt, wird nur genau ein Befehl gleichzeitig ausgeführt. Über ein passendes Delay beim Aufruf von rpcQueuePush kannst du dann die gewünschte Zeitverzögerung einstellen.
Gruß Martin
Hat schon jemand ein Shelly Script zur Anwesenheitskontrolle realisiert, das einfach die im WLan angemeldeten Geräte überprüft?
Gruß Martin
Update!
Damit lassen sich nun eine ganze Reihe von Shellys zentral von einem Shelly (quasi 1W Homeserver) steuern, ohne den Shelly selbst zu überfordern. Das Kernstück ist damit soweit ok und ich kann mit dem eigentlichen Projekt beginnen …
let shellyConfig = [
{
shellyIp : "192.168.178.xx",
shellyType: "Plug s",
shellyName: "Desk lamp",
shellyGroup: "FlashLight"
}
];
// rpcQueue
let maxrpcQueueCallbackStackSize = 2; // Actual Limit is 5
let maxrpcQueuePendingTime = 10; // Seconds
let rpcQueuedbg = true; // False is quite mode
let rpcQueueIntervall = 1 * 1000; // As small as possible (will reduce call delay error),
// but avoid RPC Limit of 5 and simultaneous calls of the same shelly
let rpcQueueVersion = "1.00";
let rpcQueueMsgPrefix = "*** rpcQueue" + rpcQueueVersion;
Timer.set(rpcQueueIntervall, true, function () { // Process rpcQueue
rpcQueueShift();
});
let rpcQueue = [];
let rpcQueueCallbackStackSize = 0;
let rpc = {
shellyId: 0,
shellyAction: 'NoAction',
shellyUnixtime: 0,
shellyDelay: 0 // Execution delay in seconds after registration by rpcQueuePush
};
function rpcQueuePush(shellyId,shellyAction,shellyDelay) {
let newrpc = Object.create(rpc);
newrpc.shellyId = shellyId;
newrpc.shellyAction = shellyAction;
newrpc.shellyUnixtime = Shelly.getComponentStatus("sys").unixtime;
newrpc.shellyDelay = shellyDelay;
rpcQueue.push(newrpc);
}
function rpcCallback(response,error_code,error_msg,nextrpc) {
if (rpcQueuedbg) {
print(rpcQueueMsgPrefix,"Callback Response of",shellyConfig[nextrpc[0].shellyId].shellyName,"ShellyAction",nextrpc[0].shellyAction,"ShellyResponse",JSON.stringify(response));
}
rpcCallbackDoaddStuff(response,nextrpc)
rpcQueueCallbackStackSize = rpcQueueCallbackStackSize - 1;
}
function checkrpcQueueForPendingCalls() {
print(rpcQueueMsgPrefix,"Warning Callback Stacksize",rpcQueueCallbackStackSize,"reached");
for (let i=0; i<rpcQueue.length; i++) {
if ((Shelly.getComponentStatus("sys").unixtime - rpcQueue[i].shellyUnixtime - rpcQueue[i].shellyDelay) >= maxrpcQueuePendingTime) {
print(rpcQueueMsgPrefix,"rpcQueue Warning",shellyConfig[rpcQueue[i].shellyId].shellyName,"ShellyAction",rpcQueue[i].shellyAction,"pending for",Shelly.getComponentStatus("sys").unixtime - rpcQueue[i].shellyUnixtime - rpcQueue[i].shellyDelay,"s");
}
}
}
function rpcQueueShift() {
if (rpcQueue.length > 0) {
let rpcIndex = -1;
for (let i=0; i<rpcQueue.length; i++) {
if (((rpcQueue[i].shellyUnixtime + rpcQueue[i].shellyDelay) <= Shelly.getComponentStatus("sys").unixtime) && (rpcIndex < 0)) {
rpcIndex = i;
}
}
if (rpcIndex >= 0) {
if (rpcQueueCallbackStackSize >= maxrpcQueueCallbackStackSize) {
// Wait for the next loop
checkrpcQueueForPendingCalls();
return;
}
let nextrpc = rpcQueue.splice(rpcIndex,1);
if (rpcQueuedbg) {
print(rpcQueueMsgPrefix,shellyConfig[nextrpc[0].shellyId].shellyName,
shellyConfig[nextrpc[0].shellyId].shellyIp
nextrpc[0].shellyAction,
"Call Delay Error:",nextrpc[0].shellyUnixtime + nextrpc[0].shellyDelay - Shelly.getComponentStatus("sys").unixtime,"s");
}
rpcQueueCallbackStackSize = rpcQueueCallbackStackSize + 1;
Shelly.call("http.get",{ url: "http://" + shellyConfig[nextrpc[0].shellyId].shellyIp + nextrpc[0].shellyAction }, rpcCallback, nextrpc);
}
}
}
function rpcCallbackDoaddStuff(response,nextrpc) {
// Do additional Stuff in Callback
}
// End rpcQueue
// Test rpcQueue
for (let s=0; s < shellyConfig.length; s++) {
if (shellyConfig[s].shellyGroup === "FlashLight") {
rpcQueuePush(0,"/relay/0?turn=on" , 0);
rpcQueuePush(0,"/relay/0?turn=off",10);
rpcQueuePush(0,"/relay/0?turn=on" ,15);
rpcQueuePush(0,"/relay/0?turn=off",25);
rpcQueuePush(0,"/relay/0?turn=off",40); // The order of execution depends on the delay!
rpcQueuePush(0,"/relay/0?turn=on" ,30); // Look at output of rpcQueueShift (rpcQueuedbg = true)
}
}Der Code passt für mich nicht und ich habe es jetzt anders und für mich passender implementiert. Siehe rpcQueue!
Gruß Martin
Update! Nun kann man nicht nur ein Überschreiten des RPC Limits von derzeit 5 vermeiden, sondern zusätzlich ein wait(seconds) zwischen den Shelly.calls vorgeben. In dem Beispiel wird ein Plug s nach definierten Zeiten ein- und ausgeschaltet. Für einen Test bitte nicht die eigene IP in shellyConfig vergessen. Viel Spaß damit!
Gruß Martin
let shellyConfig = [
{
shellyIp : "192.168.178.xx",
shellyType: "Plug s",
shellyName: "Desk lamp"
}
];
let rpc = {
shellyId: 0,
shellyAction: 'NoAction',
shellyUnixtime: 0,
shellyDelay: 0 // Execution delay in seconds after registration by rpcQueuePush
};
// rpcQueue
let rpcQueue = [];
let rpcQueueIntervall = 1 * 1000; // As small as possible (will reduce call delay error),
// but avoid RPC Limit of 5 and simultaneous calls of the same shelly
Timer.set(rpcQueueIntervall, true, function () { // Process rpcQueue
rpcQueueShift();
});
function rpcQueuePush(shellyId,shellyAction,shellyDelay) {
let newrpc = Object.create(rpc);
newrpc.shellyId = shellyId;
newrpc.shellyAction = shellyAction;
newrpc.shellyUnixtime = Shelly.getComponentStatus("sys").unixtime;
newrpc.shellyDelay = shellyDelay;
rpcQueue.push(newrpc);
}
function rpcQueueShift() {
if (rpcQueue.length > 0) {
let rpcIndex = -1;
for (let i=0; i<rpcQueue.length; i++) {
if (((rpcQueue[i].shellyUnixtime + rpcQueue[i].shellyDelay) <= Shelly.getComponentStatus("sys").unixtime) && (rpcIndex < 0)) {
rpcIndex = i;
}
}
if (rpcIndex >= 0) {
let nextrpc = rpcQueue.splice(rpcIndex,1);
print(shellyConfig[nextrpc[0].shellyId].shellyName,
shellyConfig[nextrpc[0].shellyId].shellyIp
nextrpc[0].shellyAction,
"Call Delay Error:",nextrpc[0].shellyUnixtime + nextrpc[0].shellyDelay - Shelly.getComponentStatus("sys").unixtime,"s");
Shelly.call("http.get",
{ url: "http://" + shellyConfig[nextrpc[0].shellyId].shellyIp + nextrpc[0].shellyAction },
function (response, error_code, error_msg, nextrpc) { /* print(JSON.stringify(response)); */ } );
}
}
}
// Test
rpcQueuePush(0,"/relay/0?turn=on" , 0);
rpcQueuePush(0,"/relay/0?turn=off",10);
rpcQueuePush(0,"/relay/0?turn=on" ,15);
rpcQueuePush(0,"/relay/0?turn=off",25);
rpcQueuePush(0,"/relay/0?turn=off",40); // The order of execution depends on the delay!
rpcQueuePush(0,"/relay/0?turn=on" ,30); // Look at output of rpcQueueShiftHallo Zusammen,
mit folgendem beispielhaften Code kann man das RPC Limit umgehen. Die RPCs werden in eine Warteschlange eingereiht und über einen Timer nacheinander abgearbeitet. Eventuell kann es jemand auf seine Bedürfnisse anpassen.
Gruß Martin
let rpcQueue = [];
let rpcQueueIntervall = 5 * 1000;
let rpc = {
shutterIndex: 0,
shutterAction: 'NoAction'
};
function rpcQueuePush(shutterIndex,shutterAction) {
let newrpc = Object.create(rpc);
newrpc.shutterIndex = shutterIndex;
newrpc.shutterAction = shutterAction;
rpcQueue.push(newrpc);
}
function rpcQueueShift() {
if (rpcQueue.length > 0) {
let nextrpc = rpcQueue.splice(0,1);
print(nextrpc[0].shutterIndex,nextrpc[0].shutterAction);
/*
Call Shelly ...
*/
}
}
rpcQueuePush(1,'adjustShutterOnShutterClosePosition');
rpcQueuePush(2,'adjustShutterOnShutterOpenPosition');
rpcQueuePush(3,'getShutterTimespec');
// Empty rpcQueue
Timer.set(rpcQueueIntervall, true, function () {
rpcQueueShift();
});Danke für den Hinweis auf die Zugriffsfunktion. Ein Timer ist eine Alternative und mit dem Bug führt auch kaum ein Weg daran vorbei.
Auch eine for Schleife läuft nicht durch, wenn die Anzahl der Zyklen groß ist (Siehe Code). Scheint ein grundsätzliches Problem zu sein.
Also a for loop will crash if the number of cycles is large (see code). Seems to be a fundamental problem.
[script][/script]
[script]let n = 0; [/script]
[script]for (let i=0; i < 500000; i++) { [/script]
[script]n = n + 1; [/script]
[script]} [/script]
[script]print("End");[/script]
[script][/script]
Syntax und Semantik einer while Schleife sind dem Interpreter bekannt. Reduziert man die Schleifendurchläufe, läuft es auch durch. Das Problem scheint woanders zu liegen.
[script][/script]
[script]let n = 0; [/script]
[script]while (n < 5000) { [/script]
[script]n = n + 1; [/script]
[script]} [/script]
[script]print("End");[/script]
[script][/script]
Seems to be a basic error of while. The following simple code will crash also:
[script][/script]
[script]let n = 0; [/script]
[script]while (n < 500000) { [/script]
[script]n = n + 1; [/script]
[script]} [/script]
[script]print("End");[/script]
[script][/script]
Hallo Zusammen,
in einem größeren Projekt benötige ich eine wait bzw. sleep Funktion, damit ich nicht die maximale Anzahl gleichzeitiger RPC's überschreite. Leider funktioniert mein Ansatz (hier reduziert auf das eigentliche Problem) nicht, weil der Code ohne Rückmeldung auf einem Shelly Plus1 (aktuelle Firmware 0.12.0) abstürzt. Wäre toll, wenn jemand eine Erklärung dafür hätte.
Gruß Martin
[script][/script]
[script]let Shellyunixtime = 0; [/script]
[script]let updateShellytimeInterval = 5 * 1000; [/script]
[script]
[/script]
[script]function getShellyTime(){ [/script]
[script]Shelly.call("Shelly.GetStatus", {}, [/script]
[script]function (res, error_code, error_msg, ud ) { [/script]
[script]Shellyunixtime = res.sys.unixtime; [/script]
[script]print("Shellyunixtime:",Shellyunixtime); [/script]
[script]}, [/script]
[script]null); [/script]
[script]} [/script]
[script]
[/script]
[script]function wait(seconds) { [/script]
[script]let start = Shellyunixtime; [/script]
[script]let now = start; [/script]
[script]while (now <= (start + seconds)) { [/script]
[script]now = Shellyunixtime; [/script]
[script]} [/script]
[script]} [/script]
[script]
[/script]
[script]function testwait() { [/script]
[script]print("Start wait"); [/script]
[script]wait(10); [/script]
[script]print("End wait"); [/script]
[script]} [/script]
[script]
[/script]
[script]// Keep ShellyTime up to date [/script]
[script]Timer.set(updateShellytimeInterval, true, function () { [/script]
[script]getShellyTime(); [/script]
[script]}); [/script]
[script]
[/script]
[script]// Test wait [/script]
[script]Timer.set(updateShellytimeInterval*2, true, function () { [/script]
[script]testwait(); [/script]
[script]});[/script]
[script][/script]