Beiträge von ostfriese

Ist tatsächlich so gewollt und wird in der Console auch ausgegeben. Meine Reinigungskraft macht auch Überstunden

So, hier nun das richtige Skrip für den Anwendungsfall.

Über Scripts --> Create ein zweites Skript anlegen, mit dem Namen Alarm. Den u.g. Code einfügen.

Im config Teil anpassen:

alarm_off_duration <- Wie lange soll ein single push den Alarm unscharf schalten (Minuten)

alarm_duration <- Wie lange soll der Alarm ertönen.

button_mac <- Mac von dem Button

Save und Start.

Zusätzlich die Schiebeschalter neben den Skriptnamen beide auf on. Das bewirkt, dass beide Skripte nach Reboot (z.B. Stromausfall) automatisch starten.

////////////////////// config //////////////////////
let alarm_off_duration = 1;  //Minuten
let alarm_duration     = 30; //Sekunden
let button_mac         = "bc:02:6e:c3:cc:61";
//////////////////// config end ////////////////////

function reset_timer() {
  alarm_state = true;
  Shelly.call('Switch.Set', {'id':0, 'on':false});
  print('Alarm turned on');
}

function get_ws(ev) {
  try {
    if(ev === undefined) return;
    if(ev.info.data.gen === undefined) return;
    if (ev.info.data.mac === button_mac) {
      state = ev.info.data.device_state;
      print('Detected button:', state);
      if (state == 'single_push') {
        print('Alarm turned off for', alarm_off_duration, 'minutes.');
        alarm_state = false;
        Timer.clear(t1);
        t1 = Timer.set(alarm_off_duration * 60 * 1000, false, reset_timer);
        return;
      }
      if (state == 'long_push') {
        alarm_state = true;
        print('Alarm turned on');
        Shelly.call('Switch.Set', {'id':0, 'on':false});
        Timer.clear(t1);
      }
      if (state == 'double_push') {
        alarm_state = false;
        print('Alarm turned off');
        Shelly.call('Switch.Set', {'id':0, 'on':false});
        Timer.clear(t1);
      }
    }
  }catch(e){}
}

function send_response(response, body) {
  response.code = 200;
  response.body = body;
  response.send();
}

function get_http(request,response) {
  try {
    query = String(request.query);
    send_response(response, 'OK');
    if (alarm_state && query === 'on') {
      print('!!!!!! ALARM !!!!!!!');
      Timer.clear(t1);
      t1 = Timer.set(alarm_duration * 1000, false, reset_timer);
      Shelly.call('Switch.Set', {'id':0, 'on':true});
    }
  } catch(e){print('ERROR in get_http:', e.message)};
}

function start() {
  script_id = Shelly.getCurrentScriptId();
  print('Your possible urls are:');
  print('http://' + Shelly.getComponentConfig('wifi').sta.ip + '/script/' + script_id + '/alarm?on');
  print('');
  print('');
  HTTPServer.registerEndpoint('alarm',get_http);
  print('System ready. Alarm turned on');
  Shelly.addEventHandler(get_ws);
}
let alarm_state = true;
let t1 = Timer.set(2000, false, start);

Bedienung des Skriptes:

Zunächst wird in der Console eine url ausgegeben. Diese url muss deine Synology Surveillance Station anstelle von

192.168.188.xxx/relay/0?turn=on

an den Mini senden, um einen Alarm auszulösen.

Nach dem Start reagiert das Skript auf die url, die beim Start in der Console angezeigt wird. kann man auch

mit einem Browser testen.

Ein kurzer Druck auf den Button schaltet die Alarmanlage für die unter alarm_off_duration konfigurierte Zeit unscharf. Nach Ablauf dieser Zeit schaltet sich der Alarm wieder scharf.

Ein langer Druck schaltet sie sofort wieder scharf.

Sollte ein Alarm ausgelöst werden, ertönt das Horn für die unter alarm_duration konfigurierte Zeit. Danach ist die Anlage wieder scharf.

Ein langer Druck beendet den Alarm und schaltet sofort wieder scharf.

Insgesamt unscharf schalten kann man über einen double pusch.

Der Status der Alarmanlage wird über die Console ausgegeben.

Habe den Eingangspost noch einmal gelesen. Du hast Recht, Gerhard eiche

EDIT: Willst du das machen mit dem endpoint?

senoone Das für dich richtige Skript ist in Post #14

Ahh, wenn das so ist, Gerhard, braucht er aber das @De kat Skript trotzdem. Danke für den Hinweis, hatte das anders verstanden.

Die Lösung mit physikalischem Schalter wäre diese gewesen.

 ////////////////////// config //////////////////////
let alarm_off_duration = 1 //Minuten
let button_mac         = "bc:02:6e:c3:dc:51";
//////////////////// config end ////////////////////

function reset_timer() {
  Shelly.call('http.get',{url:'http://localhost/rpc/Input.SetConfig?id=0&config={"enable":true}'});
  print('Alarm turned on');
}

function get_ws(ev) {
  try {
    if(ev === undefined) return;
    if(ev.info.data.gen === undefined) return;
    if (ev.info.data.mac === button_mac) {
      state = ev.info.data.device_state;
      print(state);
      if (state == 'single_push') {
        print('Alarm turned off for', alarm_off_duration, 'minutes.');
        Shelly.call('http.get',{url:'http://localhost/rpc/Input.SetConfig?id=0&config={"enable":false}'});
        Timer.clear(t1);
        t1 = Timer.set(alarm_off_duration * 60 * 1000, false, reset_timer);
        return;
      }
      if (state == 'long_push') {
        Shelly.call('http.get',{url:'http://localhost/rpc/Input.SetConfig?id=0&config={"enable":true}'});
        print('Alarm turned on');
        Timer.clear(t1);
      }
    }
  }catch(e){}
}

function start() {
  print('System ready. Alarm turned on');
  Shelly.call('http.get',{url:'http://localhost/rpc/Input.SetConfig?id=0&config={"enable":true}'});
  Shelly.addEventHandler(get_ws);
}

let t1 = Timer.set(2000, false, start);

Das andere lasst sich aber auch leicht umsetzen, wie du ja richtig gesagt hast, über einen http endpoint.

Ich warte mal, was senoone sagt, wie das angesteuert ist.

Ok. FW-Update auf dem Mini.

Unter Settings --> Debug -->

Websocket debug

aktivieren.

Dann unter Scripts Create Script bei

Enter your script name here

Blu_Events <-genau so, mit Unterstrich!!

eingeben und Save.

Jetzt das Skript von HIER (Danke an @De kat ) kopieren und in dem oberen weißen Feld einfügen und wieder Save.

Dann Start und im unteren Bereich (Console) schauen, ob Tastendrücke des Blue Button dort angezeigt werden.

Dann wieder melden

Alarmanlage und Cloud ist, gelinde gesagt, suboptimal.

Wenn der Mini in Reichweite des Button (oder eines anderen Gen2 im Netz) ist, lässt sich das lokal besser lösen.

Und, vergiss die App. Gib in einem Browser die IP des Mini in der Adresszeile ein. Dann können wir arbeiten.

Einfache Antwort: Nein.

Wo wird denn der Button bei dir ausgewertet?

Ist doch schon in meinem Post:

Zitat von ostfriese

Hier ein Beispiel für so ein Schütz.

Hier

Das kleine Minirelais des Plus 1 PM ist nicht gut geeignet, diese hohe Last zu schalten. Auf Dauer werden die Relaiskontakte schaden nehmen.

Der Einbau eines Schützes ist hier die Lösung.

Vorteil: Die Last wird vom Shelly genommen, eine übermäßige Erwärmung wird vermieden.

Nachteil: Die Leistung kann nicht mehr mit dem Shelly gemessen werden. Ist aber eh von nachrangiger Bedeutung, da die Leistung,

bei eingeschaltetem Schütz konstant ist.

Hier ein Beispiel für so ein Schütz.

Ich würde den Button mit kurzem Druck folgenden Befehl ausführen lassen:

http://<*ip_des_mini>/rpc/Input.SetConfig?id=0&config={"enable":false}

Das schaltet den Input aus. Es werden keine Synology Surveillance Station Befehle mehr angenommen.

Dann, wenn fertig, wieder scharf schalten, z.B. mit double push:

http://<*ip_des_mini>/rpc/Input.SetConfig?id=0&config={"enable":true}

*Wenn das Script zur Auswertung des Blue Button auch auf dem Mini 1 läuft, statt *<ip_des_shelly>

localhost

verwenden.

Wenn es unbedingt zeitgesteuert wieder scharf gestellt werden soll, würde ich das durch ein kleines Skript erledigen. Dazu müsste ich aber wissen,

welches Skript du verwendest, um den Button zu erfassen.

Zitat von eiche

meine Skripteinführung

Habe ich mir soeben mal angeschaut. Gut gemacht und sehr lesenswert

Am Besten, dass Thema wird gepinnt. Die Frage wird jetzt wohl öfter kommen

Na dann, gute Ernte

Das lässt sich mit einem Skript lösen. Da ich aber keinen 0-10V Dimmer habe, kann ich nur indirekt weiter helfen.

Vlt. findet sich ja ein interessierter Skript Befähigter, der sich des Themas annimmt.

Außerdem stell sich, bei unbenutzt, die Frage, wie gut der Akku die lange Zeit ohne Benutzung verkraftet hat.

Zitat von BooWseR

Ich habe keine Lampen in den 5 Tastern

Ich hatte das, als keine Kontrollleuchten, interpretiert, obwohl das Verhalten des Shelly darauf hindeutet, dass doch welche vorhanden sind

EDIT BooWseR hat geantwortet während ich geschrieben habe.

Statt

// process error

setze:

print(error_code, error);

sollte dir die richtige Richtung zeigen.

Willkommen im Forum.

Schön, das es klappt. Http Endpoints sind sehr vielseitig einsetzbar. Wenn Alterco das auch noch für UDP in die API packt, ein Traum

Hier das Grundgerüst:

function log(to_log) {
    console.log(to_log);
}

function send_response(response, body) {
    response.code = 200;
    response.body = body;
    response.send();
    log(body);
}

function watch(request,response) {
     what = request.query;
     print(what);
     if(what === 'alarm') {
        //do something; //Alles, was bei Alarm passieren soll
        what_done = 'Alarm start'
     }
     if(what === 'alarm_aus') {
        //do something else; //Alles, was bei Alarm_aus passieren soll
        what_done = 'Alarm stop'
     }     
     body = what_done;
     send_response(response, body);
}

HTTPServer.registerEndpoint('http',watch);
script_id = Shelly.getCurrentScriptId();
log('Your possible urls are:');
log('http://' + own_ip + '/script/' + script_id + '/my_endpoint?alarm');
log('http://' + own_ip + '/script/' + script_id + '/my_endpoint?alarm_aus');

Schalter auf detached und alles über http regeln.