Motor-Leinwand und Motor-Maskierung (optional) via Alexa steuern

RF-Befehle lernen

- Geht im ioBroker links auf "Objekte" und öffnet dann im Hauptfenster die Ordner "Broadlink2.0", "RM:RMProPlus" und "L".

(Der "L"-Ordner sollte bei Euch noch leer sein)

- Sieht man jetzt nicht diese kleinen schwarzen Dreiecke auf der rechten Seite, muss man oben bei den Symbolen den "Expertenmodus umschalten".
- Klickt nun auf das schwarze Dreieck in der Zeile "LearnRF" und drückt danach die zu lernende Taste auf eurer RF-Fernbedienung. Sobald der RF-Befehl gelernt wurde erscheint im "L"-Ordner ein neuer Eintrag.
- Der Eintrag trägt jedoch einen merkwürdigen Namen der mit "CODE_" anfängt. Klickt also in der Namenspalte auf den Namen und ändert ihrn in was Sinnvolles (zb 'Leinwand rauf') und bestätigt mit dem Häkchen.
- Das Ganze wiederholt man nun bis alle Tasten erlernt sind und am ende sollte es aussehen, wie auf dem Screenshot.

Hinweis:
Soweit also die Theorie ! In der Praxis ist das allerdings, wie schon oben erwähnt, etwas hakelig.
Ich warte bei mir immer so 7-8 Sekunden bevor ich die FB drücke und dennoch braucht es idR mehrere Anläufe. Das ist sicher ägerlich, aber auf der anderen Seite gibt's auch nur 3 Tasten zu erlernen und man macht es nur einmalig.



ioBroker Objekte anlegen

- Den "javascript.0"-Ordner anklicken
- Bei den Symbolen oben das "+" klicken. Das öffnet ein neues Fenster.
- Bei 'Name' trägt man 'LeinwandIstLevel' ein. Den Datenpunkttyp stellt man auf 'Zahl'. Fenster schliessen mit 'Hinzufügen'
- Es öffnet sich ein weiteres Fenster, das mit 'Abbrechen' verlassen wird.
- In der Zeile des neu erstellten Objekts klickt man nun in die 'Rolle'-Spalte -> 'value' wählen -> mit dem Häkchen bestätigen
- Das Ganze wieder holt man nun noch mit den Namen 'LeinwandSollLevel', 'MaskierungIstLevel' und 'MaskierungSollLevel'.

WICHTIG:
Die Maskierungs-Objekte, auch wenn man gar keine Motor-Maskierung hat, auf jeden Fall mit erstellen !

Hinweis:
In den Objekten (man könnte auch Variablen oder Speicherstellen dazu sagen) merkt sich der ioBroker den 'Zustand' der Leinwand/Maskierung.
'Zustand' bedeutet in dem Zusammenhang: Wie weit Ist die Leinwand/Maskierung ausgefahren bzw wie weit Soll sie ausgefahren werden.
Ein Script überwacht später die Soll-Objekte und reagiert auf Änderungen der darin gespeicherten Werte.

Noch sind wir hier nicht ganz fertig, denn wir brauchen noch ein paar Objekte als Trigger für die noch zu erstellenden Scenen:
- Den "javascript.0"-Ordner anklicken
- Bei den Symbolen oben das "+" klicken. Das öffnet ein neues Fenster.
- Bei 'Name' trägt man 'Leinwand Format 0' ein. Den Datenpunkttyp stellt man auf 'Logikwert'. Fenster schliessen mit 'Hinzufügen'
- Es öffnet sich ein weiteres Fenster, das mit 'Abbrechen' verlassen wird.
- Das Ganze wieder holt man nun noch mit den Namen 'Leinwand Format 1', 'Leinwand Format 2' und 'Leinwand Format 3'.

u]Hinweis:[/u]
'Format 0' = Leinwand eingefahren
'Format 1' = Bildformat 1,78:1
'Format 2' = Bildformat 1,85:1
'Format 3' = Bildformat 2,35:1
Mir reichen diese Bildformate... wer möchte kann hier natürlich noch mehr Bildformate hinzufügen.


Szenen erstellen

- Klickt ganz links im ioBroker auf "Szenen"
- Klickt im Hauptbereich auf das kleine '+' oben links und es erscheint ein neuer Szene-Ordner
- Klickt ganz rechts in der Zeile des neuen Szene-Ordners auf "Scene bearbeiten", was ein neues Fenster öffnet
- Als Name 'Leinwand 'Format 0' eingeben
- Als Beschreibung taugt in dem Fall zb 'Leiwand einfahren' o.ä.
- Bei "Benutze Trigger für Status Wahr:" den Haken setzen
- Bei "Trigger ID:" per '...'-Knopf 'javascript.0.Leinwand_Format_0' auswählen
- "Trigger-Bedingung:" auf '==' einstellen
- Bei "Trigger-Wert:" einfach 'true' eintippen
Das sollte nun so aussehen:
- Fenster mit "Ok" schliessen
- Klickt ganz rechts in der Zeile des Szene-Ordners auf "+"
- Vor 'javascript.0.LeinwandSollLevel' und 'javascript.0.MaskierungSollLevel' die Häkchen setzen und dann "Auswählen" klicken
- In den zwei neu erzeugten Zeilen, werden wir später noch etwas in der 'Sollwert bei Wahr'-Spalte eintragen müssen.
- Nun das Ganze nach gleichem Muster für 'Leinwand Format 1', 'Leinwand Format 2', 'Leinwand Format 3' wiederholen
- Am Ende sieht das dann in etwa so aus:

Hinweis:
Die Szenen sind das, was später von Alexa angetriggert wird. Dabei macht eine angetriggerte Szene eigentlich nichts anderes als die Werte in den Soll-Objekten (s.o) zu ändern. Diese Änderungen wiederum bemerkt dann das noch zu erstellende Script, welches daraufhin die Leinwand (und die Maskierung) bewegt.

Die Formel

Jetzt geht es so richtig ins Eingemachte... Also bitte Anschnallen und Sitze in eine aufrechte Position bringen !

Für unser Script benötigen wir eine Formel, die wir mit der gewünschten Ausfahrlänge füttern und die uns dann die dafür nötige Motorlaufzeit liefert.
Es ist davon auszugehen, dass der Leinwandmotor mit einer relativ konstanten Drehgeschwindigkeit läüft. Nur das trifft leider für die Absenk-Geschwindigkeit der Leinwand nicht. Anfangs senkt sich die Leinwand schneller (weil da die Rolle im Leinwandkasten noch recht dick ist) als gegen Ende (weil die Rolle immer dünner wird). Das könnte man mathematisch lösen, aber das war mir schlicht zu kompliziert.
Mein Lösungsansatz ist daher ein anderer.

Tabelle mit verschiedenen Ausfahrlängen und den dafür nötigen Ausfahrzeiten ermitteln
- Man bewaffnet sich mit Zollstock und Stoppuhr und fährt die Leinwand ganz ein.
- Nun drückt man den AB-Knopf auf der Leinwand-Fernbedienung gleichzeitig mit der Stoppuhr
- Man lässt die Leinwand einige Zeit fahren und drückt dann den STOPP-Knopf gleichzeitig mit der Stoppuhr
- Dann misst man die ausgefahrene Länge, notiert sich Länge und Zeit (in Millisekunden... Sekunden *1000) und fährt die Leinwand wieder ganz hoch
- Das Ganze wiederholt man dann für alle möglichen Ausfahrlängen. So etwa 10-20 Messpaare sollten reichen.
- Ergänzt Eure Tabelle noch mit dem Wertepaar 0/0, es braucht genau 0 Millisekunden um die Leinwand 0 cm zu bewegen.

Absolute Längen in relative Längen umrechnen
- Leinwand soweit runter gefahren, dass ein 16:9 Bild perfekt passt.
- Länge messen. Diese maximale Länge entspricht 100%
- Alle gemessenen absoluten Längen der Tabelle in relative Längen (in Prozent) umrechnen. Dazu die umzurechnende Länge durch die maximale Länge teilen und mit 100 multipliziert.
Beispiel:
Maximale Länge = 200cm
Eine der Länge aus der Tabelle = 173cm
Länge in Prozent = 173/200 * 100 = 86,500% (Auf 3 Kommastellen genau notieren !)


Die Formel ermitteln:
- Nun rufen wir eine Seite auf, die eine sogenannte Regressionsanalyse anbietet.
- Im 'x-values'-Feld löschen wir erstmal alle Daten und geben da dann unsere gemessen Längen (Prozentwerte), getrennt durch Leerzeichen, ein.
- Im 'y-values'-Feld machen wir das Gleiche, nur halt mit den gemessenen Zeiten
- Nun drücken wir den "Calculate"-Button
- Jetzt scrollen wir etwas runter und achten auf die 'Correlation coefficient'-Werte. Dabei suchen wir den größten Wert !
- Die darüberstehende Formel ist die Formel, die wir nachher im Script benötigen. Diese notieren wir sorgfältit !

Bei mir war es die Formel: y = 310.24559101 * x hoch 1.07168791
Dabei ist 'x' die gewünschte Ausfahrlänge und 'y' die dafür nötige Motor-Laufzeit

Hinweise:

- Verwendet bei der Zahleneingabe auf der Regressions-Seite '.' als Komma
- Wenn ihr weiter runterscrollt seht ihr ein x-y Diagramm mit den Kurven der diversen ermittelten Formeln und Euren Messwerten (als Kreuze). Seht Ihr da einen herben "Ausreisser", dann löscht diesen einfach bei den 'x-values' und bei den 'y-values' und drückt nochmal den "Calculate"-Button.
- Besitzt Ihr eine Maskierung, dann müsst Ihr die ganze Prozedur auch für diese durchführen und habt dann unterschiedliche Formeln für Leinwand und Maskierung. Hat man jedoch eine Maskierung, die nur eine rumgedrehte Leinwand vom gleichen Fabrikat wie die Leinwand selber ist, kann man sich das schenken und hat für beide die gleiche Formel. Das ist zum Glück bei mir der Fall.




Zurück zu den Szenen

Ganz fertig sind wir mit der Messerei noch nicht. Es gilt noch die Soll-Werte für die Szenen zu bestimmen und einzutragen.
- Man fährt Leinwand und Maskierung auf die gewünschten Höhen für die Bildformate 1,78:1, 1,85:1 und 2,35:1 und misst jeweils die Längen
- Die gemessenen Längen wieder in Prozent umrechnen und notieren.
- Die Prozentwerte werden nun bei den entsprechenden Szenen-Zeilen in die 'Sollwert bei Wahr'-Spalte eingetragen

Hinweise:
- Bei 'Format 0' trägt man 0 ein, weil da sowohl Leinwand als auch Maskierung eingefahren sind.
- 'ioBroker' ist bei der Eingabe der Werte etwas zickig... es klappt am besten die Werte recht schnell einzutippen.
- Ggf müsst ihr die Soll-Werte später noch leicht korrigieren, wenn ihr merkt, dass Leinwand und Bild nicht perfekt zusammen passen.

Das Skript

Das Skript ist der Baustein, der letztlich die Leinwand und die Maskierung an die gewünschten Positionen bewegt.

- Ganz links im ioBroker auf "Skripte" klicken
- Im Bereich gleich links neben dem Editier-Breich einmal auf 'common' klicken
- Im selben Bereich oben auf das '+' klicken und es öffnet sich ein Fenster
- Auf 'Hinzufügen' unter 'JavaScript' klicken und es öffnet sich ein weiteres Fenster
- Bei 'Name' geben wir 'Leinwandsteuerung' ein und bestätigen mit 'Ok'
- Per Copy&Paste (Strg-C & Strg-V) das unten stehende Script in den Editier-Bereich gleich unterhalb von "Script läuft nicht" kopieren

const MaskierungIst    = "javascript.0.MaskierungIstLevel",
      MaskierungSoll   = "javascript.0.MaskierungSollLevel",
      MaskierungRauf   = "broadlink2.0.RM:RMProPlus.L.Maskierung Rauf",
      MaskierungRunter = "broadlink2.0.RM:RMProPlus.L.Maskierung Runter",
      MaskierungStop   = "broadlink2.0.RM:RMProPlus.L.Maskierung Stop";

const LeinwandIst      = "javascript.0.LeinwandIstLevel",
      LeinwandSoll     = "javascript.0.LeinwandSollLevel",
      LeinwandRauf     = "broadlink2.0.RM:RMProPlus.L.Leinwand Rauf",
      LeinwandRunter   = "broadlink2.0.RM:RMProPlus.L.Leinwand Runter",
      LeinwandStop     = "broadlink2.0.RM:RMProPlus.L.Leinwand Stop";

const Delay            = 500; /* Pause (in ms) zwischen Maskierung- und Leinwandbewegung */


function CalcLaufzeitLeinwand(Soll, Ist) { /* Eingabe=Ausfahrlängen in Prozent Ausgabe=Motor-Laufzeit*/
  /* return Math.round( 1111 * (Soll - Ist) ); /* Linear regression [ y = 1111*x + 2222 ] */
  /* return Math.round( 1111 * (Math.pow(Soll,2)-Math.pow(Ist,2)) + 2222 * (Soll-Ist) ); /* Quadratic regression [ y = 1111*x² + 2222*x + 3333 ] */
  /* return Math.round( 1111 * (Math.pow(Soll,3)-Math.pow(Ist,3)) + 2222 * (Math.pow(Soll,2)-Math.pow(Ist,2)) + 3333 * (Soll-Ist) ); /* Cubic regression [ y = 1111*x³ + 2222*x² + 3333*x + 4444 ] */
  /* return Math.round( 1111 * (Math.pow(Soll, 2222)-Math.pow(Ist, 2222)) ); /* Power regression [ y = 1111*x hoch 2222 ] */
  /* return Math.round( 1111 * (Math.pow(2222,Soll)-Math.pow(2222,Ist)) ); /* ab-Exponential regression [ y = 1111 * 2222 hoch x ] */
  /* return Math.round( 2222 * (Math.log(Soll)-Math.log(Ist)) ); /* Logarithmic regression [ y = 1111 + 2222*ln(x) ] */
  /* return Math.round( 2222/Soll - 2222/Ist ); /* Hyperbolic regression [ y = 1111 + 2222/x ] */
  /* return Math.round( Math.exp(1111+2222*Soll)-Math.exp(1111+2222*Ist) ); /* Exponential regression  [ y = e hoch (1111 + 2222*x) ] */};

function CalcLaufzeitMaskierung(Soll, Ist) { /* Eingabe=Ausfahrlängen in Prozent Ausgabe=Motor-Laufzei */
  /* return Math.round( 1111 * (Soll - Ist) ); /* Linear regression [ y = 1111*x + 2222 ] */
  /* return Math.round( 1111 * (Math.pow(Soll,2)-Math.pow(Ist,2)) + 2222 * (Soll-Ist) ); /* Quadratic regression [ y = 1111*x² + 2222*x + 3333 ] */
  /* return Math.round( 1111 * (Math.pow(Soll,3)-Math.pow(Ist,3)) + 2222 * (Math.pow(Soll,2)-Math.pow(Ist,2)) + 3333 * (Soll-Ist) ); /* Cubic regression [ y = 1111*x³ + 2222*x² + 3333*x + 4444 ] */
  /* return Math.round( 1111 * (Math.pow(Soll, 2222)-Math.pow(Ist, 2222)) ); /* Power regression [ y = 1111*x hoch 2222 ] */
  /* return Math.round( 1111 * (Math.pow(2222,Soll)-Math.pow(2222,Ist)) ); /* ab-Exponential regression [ y = 1111 * 2222 hoch x ] */
  /* return Math.round( 2222 * (Math.log(Soll)-Math.log(Ist)) ); /* Logarithmic regression [ y = 1111 + 2222*ln(x) ] */
  /* return Math.round( 2222/Soll - 2222/Ist ); /* Hyperbolic regression [ y = 1111 + 2222/x ] */
  /* return Math.round( Math.exp(1111+2222*Soll)-Math.exp(1111+2222*Ist) ); /* Exponential regression  [ y = e hoch (1111 + 2222*x) ] */};

};

function MoveScreen(Rauf, Runter, Stop, Dauer, StartZeitpunkt) {
  if (Dauer > 0) { /* Positive Dauer = Runter */
    setStateDelayed(Runter, true, StartZeitpunkt, true); setStateDelayed(Stop, true, StartZeitpunkt+Dauer, true);
  } else {  /* Negative Dauer = Rauf */
    Dauer = Math.abs(Dauer); /* Dauer positiv machen */
    setStateDelayed(Rauf, true, StartZeitpunkt, true); setStateDelayed(Stop, true, StartZeitpunkt+Dauer, true);
  };
  return StartZeitpunkt+Dauer;
}

/* Script wird getriggert, wenn sich das LeinwandSoll durch den Aufruf einer Scene geändert hat */
on({id: LeinwandSoll, change: "ne"}, function (obj) {

  var Laufzeit=0,
       MaskierungLaufzeit=0,
       GesamtLaufzeit=0;

  /* Warten bis sich auch das MaskierungSoll geändert hat */
  while(getState(MaskierungIst).val == getState(MaskierungSoll).val);

  /* Maskierung bewegen */
  Laufzeit = CalcLaufzeitMaskierung(getState(MaskierungSoll).val, getState(MaskierungIst).val);
  MaskierungLaufzeit = MoveScreen(MaskierungRauf, MaskierungRunter, MaskierungStop, Laufzeit, Delay);
  setStateDelayed(MaskierungIst, getState(MaskierungSoll).val, true, MaskierungLaufzeit, false);

  MaskierungLaufzeit = MaskierungLaufzeit + Delay; /* Kurze Pause zwischen Maskierung- und Leinwandbewegung */ 

  /* Leinwand bewegen */
  Laufzeit = CalcLaufzeitLeinwand(getState(LeinwandSoll).val, getState(LeinwandIst).val);
  GesamtLaufzeit = MoveScreen(LeinwandRauf, LeinwandRunter, LeinwandStop, Laufzeit, MaskierungLaufzeit);
  setStateDelayed(LeinwandIst, getState(LeinwandSoll).val, true, GesamtLaufzeit, false);
});


- Nun gilt es, die im letzen Schritt gewählten Formeln, in die beiden Funktionen "CalcLaufzeitLeinwand()" und "CalcLaufzeitMaskierung()" einzubauen.
Ein Beispiel:
Bei mir hatte die 'Power regression'-Formel den grössten 'Correlation coefficient' und lautete y=310.24559101 * x hoch 1.07168791
Nun suche ich mir in "CalcLaufzeitLeinwand()" und "CalcLaufzeitMaskierung()" die Zeilen raus, wo ' 'Power regression' drin steht und entferne da erstmal die '/*' am Anfang der Zeilen.
Dann ersetze ich die Zahlen 1111 und 2222 mit 'meinen' Werten und erhalte die Zeilen:
return Math.round( 310.24559101 * (Math.pow(Soll, 1.07168791)-Math.pow(Ist, 1.07168791)) ); /* Power regression [ y = 1111*x hoch 2222 ] */

- Zuletzt noch auf "Speichern" klicken und dann auf das rote Dreieck um das Skript zu starten


Hinweise
- Da bei mir Leinwand und Maskierung baugleich sind, kann ich in "CalcLaufzeitLeinwand()" und "CalcLaufzeitMaskierung()" die gleiche Formel verwenden. Wenn das bei Euch anders ist, gilt es das zu berücksichtigen.

- Hat man keine Maskierung kann man folgende Zeilen auskommentieren oder löschen:
_ - die ersten 5 Zeilen
_ - die Zeilen von "/* Warten bis..." bis "setStateDelayed(MaskierungIst, ..." (einschliesslich)
Ausserdem braucht man natütlich auch nicht die Funktion "CalcLaufzeitMaskierung()" zu bearbeiten

- Mit dem 'Delay'-Wert kann man ruhig mal etwas rumspielen, dh ihn vergrössern oder verkleinern. Damit wird im Grunde nur verhindert das 2 RF-Befehle gleichzeitig abgesetzt werden.

- Das Script ist so gestrickt, dass eine Position aus jeder beliebigen anderen Position heraus angefahren werden kann. Das allerdings nur, wenn man nicht manuell (zb über die Fernbedienung) Leinwand und/oder Maskierung verstellt hat, weil dann ja die Ist-Werte nicht mehr stimmen.
Sollte das dennoch mal passiert sein, dann einfach Leinwand und Maskierung manuell ganz einfahren und auch noch das Kommando zum Einfahren (Leinwand Format 0) absetzen. Dann ist wieder alles syncron



Ein erster Test

Für einen ersten Test wechseln wir nun zu den Szenen und klicken auf eines der schwarzen Dreiecke in der 'Sollwert bei Wahr'-Spalte.
Wenn alles funktioniert sollte sich nun Leinwand und Maskierung bewegen.... am besten natürlich zumindest halbwegs in die gewünschten Positionen.

Sollte hier was gar so nicht klappen, schlage ich vor hier nochmal alles durchzugehen und zu überprüfen, bevor man mit der Anbindung an Alexa weiter macht.

Anbindung an Alexa:

Die Anbindung an Alexa läuft über die 'node red'-Instanz, was den Vorteil hat, dass es nicht über die ioBroker-Cloud läuft, sondern nur übers Heimnetz.
Im Netz findet man recht häufig die Alexa-Anbindung über ioBroker-Cloud beschrieben. Das habe ich auch getestet, war damit aber nicht sehr glücklich, da es dadurch oft zu unkalkulierbaren Verzögerungen bei der Ausführung der Befehle kam. Je nach dem, was man machen will, ist das nicht so tragisch, aber in diesem Fall hier ist das problematisch.


Node Red konfigurieren
- Im 'ioBoker' ganz links auf "node-red.0' klicken
- Im Einstellungsmenü oben rechts "Palette verwalten" -> Reiter "installieren" anklicken -> im Suchfeld darunter "Amazon" eingeben -> "node-red-contrib-amazon-echo" installieren.
- Neben dem Symbol für das Einstellungsmenü findet man ein Feld "Deploy". Da klickt man auf das Pfeilsymbol und wählt 'Geänderte Nodes'

Flow erstellen
- Auf der linken Seite der 'red node'-Seite scrollt man zum Bereich "Eingabe" und zieht dort die 'Amazon Echo Hub'-Box in den Editierbereich.
- Nun eine 'Amazon Echo Device'-Box in den Editierbereich ziehen und per Doppelklick dessen Einstellungen öffnen und einen Namen vergeben. Das ist der Name des Geräts, dass Alexa später finden wird.
- Das wiederholt man jetzt für alle benötigten Geräte.
- Jetzt links auf den Bereich "Ausgabe' scrollen und eine 'ioBroker out'-Box in den Editierbreich ziehen, dessen Einstellungen öffnen und bei 'Topic' eine Scene wählen.
- Dabei wird auch ein Name voreingetragen, den man, wenn man möchte, ändern kann. Das wiederholt man für alle benötigten Scenen.
- Nun verbindet man noch die Ausgänge (kleiner grauer Kreis rechts an der jeweiligen Box) mit den Eingängen (Kreis links). Dazu den Ausgangs-Kreis anklicken und festhalten und dann das 'Kabel' zu einem der Eingangskreise ziehen und loslassen.
- Mit einem Klick auf den 'Deploy'-Button aktiviert man dann seinen gerade erstellten 'Flow'


So oder so ähnlich sollte das dann aussehen.

Hinweise
- Wie man auf dem 'red node'-Screenshot sieht, kann man auch zb die gelernten RF-Befehle in eine Ausgabe-Box packen und diese so Alexa beibringen. Das ist aber optional und ich will hier darauf vorläufig nicht eingehen. Wichtig sind erstmal nur die 4 oberen Zeilen !
- WICHTIG: Wenn man etwas Neues erstellt, etwas hinzugefügt oder geändert hat, dann muss man immer den "Deploy"-Button klicken, damit die Änderungen wirksam werden.

Linux-Gefummel
Wenn der ioBroker unter Linux lüppt (wie bei mir), gilt es, dank einiger Besonderheiten der Linux Firewall, eine weitere Klippe zu umschiffen.
- Doppelklick auf den "Amazon Echo Hub" machen und den Port auf 8080 ändern
- Auf die Linux-Console bemühen und folgende Zeilen eingeben um ein Port-Forwarding von Port 80 auf Port 8080 vorzunehmen:

sudo apt-get install iptables-persistent
sudo iptables -I INPUT 1 -p tcp --dport 80 -j ACCEPT
sudo iptables -A PREROUTING -t nat -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8080
sudo iptables-persistent save
sudo iptables-persistent reload


Hinweise
- Das Port-Forwarding ist nötig, weil unter Linux die Ports 1 bis 1024 reserviert sind. Alexa werkelt fest auf Port 80 und das gäbe Problem mit der Kommunikation.
- Man kann auch einen anderen Port wählen, aber er muss halt grösser 1024 sein. Dann ändern sich aber auch der Werte unten in Zeile 3 !!!
- Seid Ihr bei Linux als Root-User angemeldet, könnt ihr die 'sudo'-Befehle weglassen

Alexa sucht und findet
- Alexa eine Gerätesuche machen lassen.Sie erkennt dabei die Lampen(!) "Leinwand Format 0", "Leinwand Format 1"... bis "Mask Up".

Hinweis
Zur einfacheren Bedienung hab ich Alexa dann noch ein paar Routinen beigebracht... zb schaltet der Befehl "Alexa, keine Balken" die Lampe(!) "Leinwand Format 1" ein. Das finde ich einfacher als den Befehl "Alexa, Leinwand Format 1 einschalten" (wobei der auch funktioniert)
Desweiteren hab ich, da bei mir zusäzlich zum 'RM Pro' auch noch eine 'Logitech Harmony+Hub' werkelt, noch den Befehl "Alexa, starte Kinoabend" erstellt. Damit werden sämtliche am "Kinoabend" beteiligten Geräte eingeschaltet und auf die richtigen Ein- und Ausgänge geschaltet, die Raum-Beleuchtung angepasst, als auch die Leinwand und Maskierung in die 16:9-Position gefahren.
Mit dem Befehl "Alexa, beende Kinoabend" wird dann wieder alles ausgeschaltet.



Das Zusammenspiel

Abschliessend der Versuch das Zusammenspiel der zahlreichen Komponenten kurz und knapp anhand eines Beispiels zu erläutern:

Sage ich zum Beispiel "Alexa, keine Balken" und schalte damit "Leinwand Format 1" ein (s.o), dann merkt dies 'node red' und startet die Scene "Leinwand Format 1", welche alsdann die Soll-Objekte auf die Werte 17,7% (Maskierung) und 100%(Leinwand) ändert. Dies wiederrum merkt das Java-Script und fährt Leinwand als auch Maskierung nacheinander auf die richtigen Positionen und ändert zu guter Letzt noch die Werte der Ist-Objekte in die Werte der Soll-Objekte um.


So... Das wars soweit. Hoffe ich konnte Euch dieses komplexe Thema gut genug nahebringen.
Nun wünsche ich viel Spass beim Nachbau und freu mich schon auf Eure Fragen.

Gruß
Rudi

Nachtrag
Ich hab den 'ioBroker' nun auf einem Pi 4 unter "Debian Buster Lite" laufen. Beim Umzug hab ich festgestellt, dass das Abspeichern des Port-Forwardings (siehe letzter Post) nun etwas anders läuft...

sudo apt-get install iptables-persistent
sudo iptables -I INPUT 1 -p tcp --dport 80 -j ACCEPT
sudo iptables -A PREROUTING -t nat -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8080
sudo su -
iptables-save > /etc/iptables/rules.v4
exit