bp4willi soweit ich deine Fragen interpretiere, habe ich den Eindruck, du hast dir den Betriebsmodus 'detatched' noch nicht angesehen.
Bei dieser Konfiguration schaltet der Shelly den Output direkt:
Und im detached Mode fungieren die Komponenten einzeln und du hast bei den Actions andere Möglichkeiten zur Steuerung:
Und so sieht der Menüpunkt bei den Input/Output settings aus:
Oha, um mich komplett reinzudenken fehlt mir gerade die Zeit.
Soweit ich dich verstanden habe, hast du als Taktgeber eine Endlosschleife mit zwei Actions gebaut?
Oder sehe ich das falsch?
Falls dem so ist, dann solltest du diese per URL Aufruf (HTTP GET RPC Call) durchbrechen können.
Normal müsste es einen Call zum Ausschalten geben, der die internen Timer zurücksetzt (switch.set auto-off 0 oder so etwas).
Sollte das nicht gehen, weil die Action immer wieder erneut triggert, so müsstest du zusätzlich die Actions per RPC Call alle einmal aus und wieder einschalten:
Aber: Mir wäre nicht bekannt wie das über RPC Calls gehen sollte. Die WebUI vom Shelly sendet folgendes WebSocket wenn man klickt:
D.h. du bräuchtest wohl einen neuen Ansatz mit einem kleinen Script, welches entweder über SW oder RPC CALL (z.B. Virtueller Button) geschaltet wird.
Korrigiert mich, wenn ich völlig falsch liege. Ich wollte noch schnell meinen Gedanken los werden bevor ich den Rechner verlasse.
Hallo Klaus,
ich habe deinen grundsätzlichen Aufbau und die Konfiguration noch nicht ganz verstanden. Das lässt noch viel Raum für freie Interpretation.
Schaltest du die Shellies per Stromstoß oder Dauerstrom? Gerne auch ein Screenshot von deinen Actions.
Wenn das schon so weit funktioniert, brauchst die vielleicht (noch) gar kein Script für deine Lösung.
Viele Grüße,
Marco
Wäre ja prinzipiell machbar, wenn es Allterco im Shelly und der GUI implementieren würde,
dass man eine Wenn-Kombination aus lokalen Messwerten, Schaltzuständen und virtuellen Schaltern definieren könnte, die dann woanders eine Shelly Schalte auslöst (oder verhindert).
Das alles deckt Shelly über das Scripting ab.
Für komplexere logische Verknüpfungen ohne Shelly Script kann man externe Tools wie Node Red, Home Assistant, und vermutlich auch IO Broker verwenden.
Letztlich mündet jede Aktion oder Szene doch in einen Http Befehl, der an den Shelly gesendet wird.
Es wäre das beste, wenn es dort eine Kommandoerweiterung im http Befehl gäbe, die dem Shelly sagt: nach diesem Befehl für X Minuten keinen anderen schalt-request berücksichtigen. (= für Dauer X alle weiteren eingehenden schalt requests verwerfen)
Gibt's sowas??
Nein, selbst mit Shelly Script wüsste ich nicht, dass es eine Möglichkeit gäbe um das Ausschalten zu verhindern.
Es ist immer möglich, dass jemand per RPC Call den Shelly ausschaltet. Also auch über Webinterface oder Apps.
Bei den physischen Schaltern (input) ist das hingegen anders. Du kannst den Shelly 'detached' betreiben und dann auf den Input reagieren. Wenn es hier bei den Actions und Szenen Einschränkungen gibt, kann man diese über ein Script umgehen.
Bei mir Zuhause sind z.B. einige Lichtschalter bei genügend Tageslicht per Script deaktiviert.
Ja danke, ich habe ja eine komplett neue Energizer Batterie eingelegt, und jetzt nach 2 Wochen nur noch 55%... komisch.
Mangels eigener Erfahrung kann ich nur eine Idee Beisteuern:
Kann es sein, dass der Beacon Mode aktiv ist?
Hatte gelesen, dass dieser zu einem höheren Batterieverbrauch führt und deshalb das Thema nicht weiter verfolgt.
Den Beacon Mode kann man über die Shelly Debug App deaktivieren/aktivieren.
Hallo AAAAAA ,
nein, das geht leider nicht. Soweit ich es sehe, nutzt Blutooth am H&T Gen3 nur für die Einrichtung etwas, ich habe bisher noch keinen sinnvollen Anwendungsfall für aktiviertes Bluetooth bei dem Gerät gefunden.
Hatte gehofft, jemand hat hier eine positivere Nachricht.
Der H&T Gen3 punktet mit dem schönen Display
Der BLU H&T punktet mit deutlich besserem Updateintervall und geringerem Stromverbrauch
Auf dieser Seite bin ich auf eine Alternative gestoßen https://bthome.io/
Hallo sp00ky ,
gerne.
Für einige TVs gibt es sogar Integrationen für Home Assistant, vielleicht nimmt dir das schon die meiste Arbeit ab.
Und noch ein Tipp, falls du über den Stromverbrauch vom Shelly gehst: Es gibt Blaupausen für Home Assistant um z.B. die Betriebsdauer einer Waschmaschine zu Ermitteln. Zumindest der erste Teil, der zwischen Standby und Betrieb unterscheidet, könnte dir da schon als Basis weiterhelfen.
Seit wann dein Shelly läuft kannst du u.a. über folgenden RPC Call im Browser herausfinden:
http://192.168.xxx.xxx/rpc/Sys.GetStatusIm Ergebnis steht dann die Uptime in Sekunden:
reset reason ist leider nicht dokumentiert, sollte aber Auskünfte über Stromausfall, Software Reboot oder Software Absturz liefern.
Das sieht man dann so oder wie also die Betriebsstunden?
Die Betriebsdauer sieht man aktuell nur unter "KVS" in der Weboberfläche vom Shelly.
Wenn du ein Gen3 Gerät hast, so können wir das Verbessern und in der Cloud/App anzeigen.
Alternativ kannst du den Wert auch per RPC Call per MQTT.Control oder HTTP GET abfragen.
Mal ne Frage kann man mit dieser Variante den Shelle schrotten mit Flashspeicher usw.
Ein Flashspeicher ist per se ein Verschleißteil. Die Frage ist also nicht ob sondern wann. Bestimmt hast du auch schon mal eine defekte SD-Karte in der Hand gehabt.
Rechnen wir es durch. Angenommen du schaltest durchschnittlich 24x am Tag so haben wir 24 Schreibvorgänge. 24x365 = wir haben 24 Schreibvorgänge am Tag. So haben wir 8.544 Schreibzyklen im Jahr. Laut Datenblatt gehe ich von 100.000 Schreibzyklen aus. D.h. wenn wir uns eine Toleranz denken, so sollte der Shelly über 10 Jahre durchhalten.
Würden wir Internas kennen, so könnten wir per Script versuchen, andere Speicherbereiche zu erreichen. Aber ohne konkretes Wissen ist das alles nur Rätselraten.
Also muss die Antwort lauten: Ja, wir belasten die Lebensdauer, jedoch in einem moderatem Bereich.
P.S.: Um die Lebensdauer zu verbessern, sollten auch die Logs zur Diagnose deaktiviert werden. Außerdem haben wir die Lebensdauer der Elkos etc. noch nicht beleuchtet.
Ich habe eine erste Iteration geschrieben, da mir der Anwendungsfall durchaus nützlich erschien.
Im Kern ist es ganz simpel. Meinen MQTT Logger einfach ignorieren, Script sollte auch ohne MQTT lauffähig sein.
Im KVS taucht nun folgende Information auf:
/// <reference path="../../shelly-script.d.ts" />
// created from vscode
/**
* operation hours counter for Shellies with switch component
*
* Autor: Marco Grießhammer (https://github.com/mgrie)
* Date: 2025-01-21
* Version: 0.1
*
* ToDo: write initial values on first run
* Idea: use 2 KVS entries instead of JSON
* ToDo: write periodic to virtual component, if available (InMemory)
* ToDo: support multiple switch components (array)
*/
const CONFIG = {
component: 'switch:0',
kvsKey: 'operation-hours-counter',
//componentSeconds: 'label:200',
//componentHours: 'label:201'
}
// set dynamic at initEnv()
let ENV = {
mqttTopicPrefix: undefined,
mqttClientId: undefined
};
// logger
function log(message) {
try {
if (typeof message === 'object') {
message = JSON.stringify(message);
} else if (typeof message !== 'string') {
message = message.toString();
}
print(message);
// Shelly.emitEvent("log", message);
if (MQTT.isConnected()) {
MQTT.publish(ENV.mqttTopicPrefix + "/log", message);
}
} catch (error) {
print("Error: " + JSON.stringify(error));
}
}
// init script environment
function initEnv(callback) {
Shelly.call('MQTT.GetConfig', {}, function (result, error_code, error_message, userdata) {
if (error_code) log({ error_code: error_code, error_message: error_message });
if (error_code === 0 && result) {
ENV.mqttTopicPrefix = result.topic_prefix;
ENV.mqttClientId = result.client_id;
}
callback();
});
}
function addTimespanToKVS(timespan){
Shelly.call('KVS.Get', {key: CONFIG.kvsKey}, function(result, error_code, error_message, ud){
let data = {totalHours:0,totalSeconds:0,lastSeconds:0, lastHours:0, cycles:0};
if(error_code) {
log(error_code + ': ' + error_message);
} else {
log(result);
data = JSON.parse(result.value);
}
data.lastSeconds = timespan;
data.lastHours = Math.round(timespan/360);
data.totalSeconds = data.totalSeconds + timespan;
data.totalHours = Math.round(data.totalSeconds/360);
data.cycles++;
Shelly.call('KVS.Set', {key:CONFIG.kvsKey, value:JSON.stringify(data)}, function(result, error_code, error_message, ud){
if(error_code) log(error_code + ': ' + error_message);
}, null);
},null);
}
function main(){
const userdata = {ts: null};
Shelly.addEventHandler(function(data, ud){
if(!data || !data.info) return;
if(data.component === CONFIG.component && data.info.event === 'toggle'){
// on
if(data.info.state === true){
ud.ts = data.info.ts;
}
// off
if(data.info.state === false){
if(ud.ts != null){
addTimespanToKVS(Math.round(data.info.ts - ud.ts));
}
}
}
}, userdata);
}
initEnv(main);Was heist das jetzt dann kann man sowas machen oder nicht!?
Ja, natürlich lässt es sich umsetzen.
Laut dem folgendem Datenblatt scheint der Flash Speicher 100.000 Schreibvorgängen standzuhalten, während manche von 10.000 Zyklen sprechen.
https://chipmaster.pro/wp-content/upl…/04/GD25Q32.pdf
Praxiswerte wären sehr interessant. Bis dahin würde ich empfehlen die Schreibvorgänge auf ~24x pro Tag beschränken. Aber das scheint ja bei dir gegeben zu sein, wenn wir Reboot und Scriptabbrüche außen vor lassen.
Die Umsetzung ist nicht sonderlich Umfangreich, allerdings kann ich dir nicht versprechen ob oder wann ich Zeit dazu finde.Es reicht auf die on / off Events zu lauschen um die beiden Timestamps voneinander abzuziehen. Alten Wert vom KVS laden, addieren, speichern. Zusätzlich würde ich immer den aktuellen Wert in Stunden umrechnen und gerundet in einen zweiten Eintrag im KVS schreiben. So hast du dort immer den aktuellen Wert stehen.
Das würde erstmal reichen. Danach hätte ich noch 3 Ideen, wie man das Script für Gen3 und Pro Geräte erweitert und perfektioniert.
Guten Morgen Krauskopp,
in der heutigen Zeit empfinde ich es als viel wichtiger als früher, dass die Kinder beim Thema Mediennutzung selbständig und ehrlich auf die Regeln der Eltern hören.
Dennoch sehe ich es als Problem an, dass diese ganzen Tools für Eltern zur Kontrolle nichts taugen. Egal ob Family Link oder Amazon Kids. Diese Apps sind alle nur halbgar und nicht praxistauglich.
Ich finde das Projekt durchaus interessant und bin gespannt welche Lösung sp00ky am Ende umsetzen wird.
Viele Grüße,
Marco
Ich hatte mit nicht funktionierenden Print Ausgaben schon so viel Zeit und Nerven verloren, dass ich komplett auf MQTT umgestiegen bin.
Kurz gesagt hat mich bisher keine Variante zufrieden gestellt, weil einfach keine zu 100% funktionierte. Auch mit VS Code Plugin war ich sehr unzufrieden.
Manchmal scheint es eine Art Timing Problem zu sein, wie eine Queue, welche voll läuft und ignoriert wird.
// set dynamic at initEnv()
const ENV = {
mqttTopicPrefix: undefined,
mqttClientId: undefined
};
// logger
function log(message){
try {
if(typeof message === 'object' ){
message = JSON.stringify(message);
} else if (typeof message !== 'string'){
message = message.toString();
}
print(message);
// Shelly.emitEvent("log", message);
if(MQTT.isConnected()) {
MQTT.publish(ENV.mqttTopicPrefix + "/log", message);
}
} catch (error) {
print("Error: " + JSON.stringify(error));
}
}
function initEnv(callback){
Shelly.call('MQTT.GetConfig', {}, function(result, error_code, error_message, userdata){
if(error_code === 0 && result){
ENV.mqttTopicPrefix = result.topic_prefix;
ENV.mqttClientId = result.client_id;
}
callback();
});
}
function main() {
log('Whoop woop!');
}
initEnv(main);Ich habe mir aus Interesse die API von einem beliebigen Smart TV angesehen.
Mittlerweile gibt es da REST APIs mit denen du du den Status abfragen kannst, ein Bild einblenden könntest und nach einer kurzen Zeit das Gerät herunterfährst. Ob du die API dann über einen Shelly oder über ein anderes Gerät ansprichst, ist von deinen Vorlieben und Fähigkeiten abhängig.
Ich selbst würde in diesem Fall Home Assistant oder Node Red nehmen.
Ein Shelly-Script verwende ich immer dann, wenn der Anwendungsfall autark und dezentral laufen soll.
Wenn du schon gute Erfahrungen mit C# hast, so reicht dir vielleicht ein Crashkurs in JavaScript.
Beim Shelly fehlen hier alle modernen Features und es gibt ein paar Einschränkungen im Vergleich zu anderen Interpretern.
Für Einsteiger sehe ich zwei Hürden:
Ein passendes Snippet habe ich so schnell nicht zur Hand.
KVS ist am Shelly Plus 1 vorhanden. Gespeicherter Wert könnte über das Webinterface oder einen RPC Call (z.B: HTTP GET) ausgelesen werden.
Allerdings belastet man mit permanenten Schreibzugriffen auch den Flash Speicher. Deshalb würde mich selbst interessieren ob hier jemand etwas fundiertes dazu weiß.
Ob das harte Schalten dem TV gut tut, steht auf einem anderen Blatt...
Bei meiner Tochter würde eine Durchsage über Alexa "Papa sagt, du musst den Fernseher jetzt ausschalten" reichen. 
Ich dachte, ich hätte erst vor zwei Wochen gelesen, dass es neuere Fernseher gibt, welche eine eigene cool down phase haben. Diese sollte man dann erst nach dieser Phase vom Netz nehmen (Urlaub, Gewitter, Stromsparen).
Interessanter Anwendungsfall. Ich wäre da eher auf die Idee gekommen, nach einem smarteren TV zu suchen.
In eine ähnliche Richtung habe ich einen Prototypen geschrieben, der zwischen Standby und Betrieb unterscheiden kann und die Betriebszeit zusätzlich (grob) aufzeichnet. Allerdings liegt das gerade aus Zeitgründen auf Eis.
Wie schon erwähnt, ist dein Projekt mit Shelly Script umsetzbar.
Alternativ sollte es auch in Home Assistant oder Node Red (und weiteren externen) umsetzbar sein.
Schreib doch einfach mal, in welche Richtung du denkst und welche Vorkenntnisse du dazu hast.
Ich habe dich so verstanden, dass dir ein einfacher Timer für 1h nicht ausreicht und dir die verbrauchte Energie anstelle eines Zeitwertes wichtig ist?
Sobald ab 18:00 Uhr 30Wh verbraucht sind, soll der Shelly das Relais öffnen und die Steckdose deaktivieren?
Ja, das ist auch per Script möglich.
Welchen Shelly verwendest du denn?
