RPC Limit durch RPC Queue vermeiden

Ich@Home

Hallo 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

Code

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();
});

Alles anzeigen

Ich@Home

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

Code

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 rpcQueueShift

Alles anzeigen

_[Deleted]_

Super, das sieht schon ganz gut aus, aber schau dir mal den letzten Teil der Shelly Skript API an, dort steht:

Known Issues

A limitation of the javascript engine that it cannot parse too many levels of nested anonymous functions. With more than 2 or 3 levels the device crashes when attempting to execute the code. To avoid this problem it is recommended that asynchronous callback functions are defined at the top level and passed as a named reference. Also, where possible prefer synchronous calls like Shelly.getComponentStatus and Shelly.getComponentConfig to avoid the need for async callbacks altogether.

For example, instead of using an anonymous function for a callback:

Code

Shelly.call(
  "HTTP.GET",
  {url: "http://example.com/"},
  function(result, error_code, error_message) {
    if (error_code != 0) {
      // process error
    } else {
      // process result
    }
  });

Prefer a named function:

Code

  function processHttpResponse(result, error_code, error) {
  if (error_code != 0) {
    // process error
  } else {
    // process result
  }
}

Shelly.call("HTTP.GET", {url: "http://example.com/"}, processHttpResponse);

wenn möglich dann versuch keine Unbenannte Funktionen zu nutzen, dein Skript enthält zurzeit noch einige verschachtelten Unbenannten Funktionen. Das könnte zu Problemen führen.

Ich@Home

Update!

Danke für den Hinweis und die unbenannte Funktion im Callback habe ich entfernt. Hatte zwar nur Level1 Aufrufe, aber man weiß ja nie.
Die Anzahl gleichzeitiger Callbacks kann nun eingestellt werden (default bei mir 2), damit der Shelly nicht überfordert wird.
Der Callback Stack wird nun kontrolliert und falls es ein Problem mit hängenden Callbacks gibt, wird eine Warnung ausgegeben.

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 …

Code

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)
    }
}

Alles anzeigen

RPC Limit durch RPC Queue vermeiden

Super, das sieht schon ganz gut aus, aber schau dir mal den letzten Teil der Shelly Skript API an, dort steht:

Known Issues

Shelly 3EM

Shelly EM

Shelly PRO 4PM