Howto - zentrales Push-Nachrichten-Programm (zPNP) V3.1

[dtp]

Einleitung

Motivation

Die nachfolgende Anleitung soll dazu dienen, Push-Nachrichten, die durch unterschiedliche WebUI-Programme bzw. -Skripte erzeugt wurden, durch ein zentrales Programm wahlweise mit den Push-Diensten

Pushover (iOS, Android sowie als Desktop-Variante für Safari, Chrome oder Firefox),
Pushsafer (iOS, Android, Windows Mobile, Windows Desktop sowie Chrome, Firefox) und/oder
Telegram (nahezu alle aktuellen OS)
Prowl (iOS, Mac OS X sowie als Desktop-Variante für Chrome oder Firefox, zudem als Growl für Windows und Snarl verfügbar),
Pushalot (Windows Phone bzw. Mobile, Windows Desktop ab Version 8),

zu verschicken. Im Folgenden werden das zentrale Push-Nachrichten-Programm kurz als zPNP und die darin enthaltenen zentralen Push-Nachrichten-Skripte als zPNS-Po, zPNS-Pl, zPNS-Pa, zPNS-Ps und zPNS-Tg bezeichnet.

Prowl und Pushalot werden aktuell nicht mehr gepflegt.

Warum das Ganze? Nun, hier mal eine Auflistung der Vorteile gegenüber dem Aufrufen der Push-Dienste in einzelnen Programmen und Skripten.

• Die Änderung von API-Keys muss nur noch an einer einzigen Stelle vorgenommen werden.
• Übersetzung von Umlauten und Leerzeichen in den zPNS-xx in UTF-8.
• Deutliche Vereinfachung der das zPNP aufrufenden Skripte mit entsprechend vereinheitlichter Struktur.
• Zentrale Nutzerverwaltung für den Fall, dass Push-Nachrichten an mehrere Empfänger verschickt werden sollen.
• Kontrolle darüber, ab welcher Prio weitere Empfänger Push-Nachrichten empfangen sollen.
• Möglichkeit zur Auswahl einzelner Push-Dienste für unterschiedliche Ereignisse.
• Möglichkeit zur generellen Deaktivierung von Push-Nachrichten mit einer Priorität < 2.
• Möglichkeit zur Unterbindung identischer Push-Nachrichten innerhalb eines definierbaren Zeitfensters (nicht bei Priorität 2).
• Möglichkeit zum Bilderversand mit Pushover, Pushsafer und Telegram.

Hinweise

• Achtung: Ab Version 2.1 der zPNS-xx ist ein WebUI ab der Version 2.29.22 erforderlich!
• Bitte auf alle Fälle vermeiden, den Inhalt von Systemvariablen auf der WebUI-Startseite anzuzeigen, wenn diese HTML-Tags enthalten.
• Wer Bedenken hinsichtlich der Verwendung von Leerzeichen, Umlauten oder Sonderzeichen in Systemvariablen-Namen hat, der sollte die Namen entsprechend ändern. Auf meiner CCU hatte ich damit in den zurückliegenden Jahren noch nie irgendwelche Probleme. Es kann aber natürlich z.B. diverse Addons für die CCU geben, die damit Probleme haben. Keine Probleme gab es bisher mit den folgenden Addons: SSH-keydir, Programmedrucken CCU2, XML-API und CUx-Deamon.
• Systemvariablen, die nicht benutzt werden, sollten in WebUI auch nicht angelegt sein.

Voraussetzungen

Zusatzsoftware

Auf der CCU muss CUxD installiert und das Gerät "CUxD.CUX2801001:1.CMD_EXEC" eingerichtet sein. Hier eine Kurzanleitung zur Einrichtung des CUxD-Geräts:

1. Unter CUxD-Gerätetyp das Gerät "(28) System-Exec" auswählen und den Rest am besten unverändert lassen (Seriennummer: 1, etc.).
2. Anschließend auf "Gerät auf CCU erzeugen!" klicken.
3. Danach in WebUI in den Posteingang für neue Geräte gehen und den neuen Gerätetyp bestätigen.
4. Zur Sicherheit CCU neu booten.

Weitere Informationen zum Thema findet ihr an dieser Stelle. Wer mag, kann dem Gerätetyp unter Geräte auch noch einen neuen Namen geben. Bei mir heißt er z.B. "CCU CUxD Exec" bzw. der entsprechende Kanal 1 "CCU CUxD Exec 1". Das ist aber nicht notwendig. Man kann den Eintrag auch unverändert lassen, da der Aufruf stets mit dom.GetObject("CUxD.CUX2801001:1.CMD_EXEC") erfolgt, also unabhängig vom vergebenen WebUI-Namen ist.

Das zPNP

Das zPNP selbst ist sehr trivial. Bei mir enthält es im "Wenn"-Zweig lediglich eine Abfrage über den Status der CCU. Diese Abfrage kann man theoretisch aber auch weglassen. Grundsätzlich empfehle ich jedoch, kein Programm oder besser noch keinen Programmzweig auf der CCU ohne Bedingung zu erstellen, weil dieses dann bei jedem Neustart der CCU ausgeführt wird.

Der Name des zPNP ("CCU PRG Push-Nachrichten") ist sehr wichtig, weil er in den aufrufenden Skripten verwendet wird. Natürlich kann dieser auch individuell gewählt werden. Aber dazu später mehr. Die von mir gewählte Nomenklatur basiert auf der Einrichtung meiner eigenen CCU. Und dort habe ich z.B. sämtlichen Programmen den Zusatz "PRG", sämtlichen Systemvariablen den Zusatz "SV" und sämtlichen virtuellen Schaltern den Zusatz "VT" verpasst. Somit kann ich einem Gerät und einer dazu gehörenden Systemvariablen ansonsten identische Namen geben. Aber dies nur am Rand.

Unter "Aktivität" sind die gewünschten zPNS-xx sowie ein kleines, aber zwingend erforderliches Skript zum Setzen der Systemvariablen "CCU SV Push Text Ref" einzufügen.

Systemvariablen

Seit Version 2.0 der zPNS-xx werden die benötigten Systemvariablen automatisch erzeugt, sofern nicht vorhanden. Die Namen der Systemvariablen können in den zPNS-xx nach eigenen Wünschen angepasst werden. Der Einfachheit halber gehe ich von den im nachfolgenden Code-Block des zPNS-xx verwendeten Namen aus.

Code: Alles auswählen

! +++++ Namen der zwingend benötigten Systemvariablen +++++
string svPushText = "CCU SV Push Text"; ! Text der aktuell zu übertragenden Push-Nachricht, Voreinstellung: "CCU SV Push Text"
string svPushTextRef = "CCU SV Push Text Ref"; ! Text der vorherigen Push-Nachricht als Referenz, Voreinstellung: "CCU SV Push Text Ref"

! +++++ Namen der optionalen Systemvariablen (auf "" setzen, wenn nicht benötigt) +++++
string svPushPrio = "CCU SV Push Prio"; ! Prioritäten der Push-Nachrichten, Voreinstellung: "CCU SV Push Prio" 
string svPushService = "CCU SV Push Dienst"; ! Push-Dienste, Voreinstellung: "CCU SV Push Dienst"
string svPushImage = ""; ! Link auf ein anzufügendes Bild (z.B. "CCU SV Push Bild"), Voreinstellung: ""

Ganz wichtig ist, dass für svPushText, svPushTextRef, svPushPrio, svPushService und svPushImage in allen Skripten jeweils immer dieselben Namen eingetragen sind! svPushImage hat jedoch nur für Pushover, Pushsafer und Telegram Bedeutung.

Zwingend erforderlich für den Betrieb des zPNPs sind die beiden Systemvariablen "CCU SV Push Text" und "CCU SV Push Text Ref". "CCU SV Push Text" enthält den aktuell zu übertragenden Textinhalt der Push-Nachricht. "CCU SV Push Test Ref" dient als Referenz und ist wichtig für die Möglichkeit zur zeitweisen Sperrung identischer Push-Nachrichten. Auch dazu später mehr.

Um das zPNP mit mehreren Push-Diensten betreiben und möglichst variabel steuern zu können, empfiehlt sich die zusätzliche Einrichtung der Systemvariablen "CCU SV Push Prio" und "CCU SV Push Dienst".

Damit die Systemvariablen nun erzeugt werden, muss das zPNP einmal per Klick auf den Start-Button unter "Status und Bedienung | Programme" ausgeführt werden.

Die Systemvariable "CCU SV Push Prio" dient zum Setzen der Priorität der Push-Nachrichten. Sowohl Prowl als auch Pushover nutzen Prioritäten von -2 bis 2. Allerdings ist die Bedeutung bei den beiden Diensten etwas abweichend. Daher kann es sein, dass sich bei gleichzeitiger Nutzung dieser Push-Dienste ein unterschiedliches Verhalten ergibt. Pushalot, Pushsafer und Telegram arbeiten eigentlich nicht mit Prioritäten. Pushalot erlaubt aber stattdessen eine Beeinflussung über die Parameter "IsImportant" und "IsSilent". Bei Pushsafer kann man verschiedene Sounds, Icons, Titel und Vibrationen setzen. Bei Telegram lassen sich den Prioritäten entsprechende Bots definieren, die dann mit unterschiedlichen Sounds und/oder Icons auf Push-Nachrichten hinweisen. Zur einheitlichen Nutzung des zPNPs habe ich mich entschieden, auch für Pushalot, Pushsafer und Telegram die obigen Prioritäten zu verwenden.

Für Pushalot werden "IsImportant" sowie "IsSilent" entsprechend der nachfolgenden Regel angepasst:

Prio -2, -1: IsImportant=False, IsSilent=True
Prio 0: IsImportant=True, IsSilent=True
Prio 1, 2: IsImportant=True, IsSilent=False

Bei Pushsaver habe ich mich für folgende Werte für den Sound (s), die Vibration (v) und das Icon (i) entschieden:

Prio -2: s=0, v=1, i=4
Prio -1, 0: v=1, i=4
Prio 1: v=1, i=5
Prio 2: v=1, i=6

Für Telegram sollten gemäß den Erläuterungen in einem der nachfolgenden Postings entsprechende Bots angelegt werden. Zudem wird bei Prio -2 die Ausgabe von Tönen mit dem Parameter "disable_notification=1" unterbunden.

"CCU SV Push Dienst" erlaubt zum einen, gezielt einen bestimmten Push-Dienst in einem das zPNP aufrufenden Programm bzw. Skript auswählen zu können. Zum anderen kann die Systemvariable auch mit einer anderen App, wie z.B. pocketControl, auf "aus" gesetzt werden, um das Versenden von Push-Nachrichten generell zu unterdrücken. Hierbei gilt aber zu beachten, dass Push-Nachrichten der Priorität 2 (Alarm) niemals unterbunden werden. Mehr dazu in einem nachfolgenden Posting zum Aufruf des zPNP. "CCU SV Push Dienst" wird automatisch mit den Namen der Pushdienste in der Reihenfolge der zPNS-xx gemäß zPNP gefüllt, wobei die beiden ersten Einträge für "aus" und "alle" reserviert sind. Es spielt also keine Rolle, wie die zPNS-xx sortiert sind. Selbst später kann die Sortierung geändert werden, ohne dass es eine Einschränkung in der Funktionalität gibt. Das fangen die zPNS-xx automatisch auf.

Für Pushover und Pushsafer können noch jeweils zwei weitere Systemvariablen eingerichtet werden. "CCU SV Pushover Sound" bzw. "CCU SV Pushsafer Sound" erlaubt es, zwischen 15 (Pushover) bzw. 27 (Pushsafer) verschiedenen Sounds bei der Übertragung von Pushover- bzw. Pushsafer-Nachrichten zu wählen. Bei Prowl existieren lediglich fünf feste Benachrichtigungssounds, die direkt von der gesetzten Priorität abhängen und nur innerhalb der App definiert werden können. Pushalot bietet derzeit keine Auswahl von Sounds. Telegram ermöglicht, wie gesagt, die Verwendung unterschiedlicher Sounds in Abhängigkeit von den Bots oder auch von definierten Gruppen.

Mit den Systemvariablen "CCU SV Pushover Gerät" bzw. "CCU SV Pushsafer Gerät" hat man zudem die Möglichkeit, Pushover- bzw. Pushsafer-Nachrichten gezielt an ein unter pushover.net bzw. in der Pushsafer App definiertes Gerät (Device) zu senden.

Die Systemvariable "CCU SV Pushover Titel" erlaubt die Vergabe eine Titels für Pushover-Nachrichten.

Versand von Bildern

Seit Version 3.0 können mit Pushover, Pushsafer und Telegram neben Texten auch Bilder direkt über die CCU versendet werden. Dazu dient die optionale Systemvariable "CCU SV Push Bild", die wie die obigen Systemvariablen automatisch angelegt wird, wenn sie beim Aufruf des zPNP bzw. des zPNS-Po, zPNS-Ps oder zPNS-Tg noch nicht angelegt war. Pushalot und Prowl eignen sich nicht zum Bildversand. Seit Version 2.2 werden die entsprechenden zPNS-xx nicht mehr von mir gepflegt.

In die Systemvariable "CCU SV Push Bild" wird mit dem aufrufenden Skript der Pfad inkl. Namen der zu übertragenden Bilddatei eingetragen. Wurde zum Beispiel eine Datei Bild.jpg in das tmp-Verzeichnis der CCU gespeichert, dann muss"CCU SV Push Bild" auf "/tmp/Bild.jpg" gesetzt werden. Es ist aber auch möglich, direkt Pfade auf eine Webcam oder dergleichen zu setzen.

Die zPNS-xx

Kommen wir zum wesentlichen Bestandteil des zPNP, den zPNS-xx. Es ist möglich, bis zu 100 User pro Push-Dienst zu definieren. Dazu gibt es eine so genannte Master-Liste, die die durch Leerzeichen getrennten Keys für jeden User enthalten. Jedem Key ist dabei ein Identifyer "xx|" vorangetellt. Wenn man also nur einen User hat, trägt man jeweils nur einen Key "01|+++key1+++" ein. Hat man zwei User, trägt man zwei Keys "01|+++key1+++ 02|+++++key2+++++" ein, die durch ein Leerzeichen getrennt sind. Bei drei Usern sind es drei Keys und so weiter. Achtung, es darf nur ein einziges Leezeichen zwischen den Keys eingetragen sein. Hier mal ein Beispiel für Pushover

Hier mal ein Beispiel für Pushover mit drei Usern:

Code: Alles auswählen

string keyList = "01|+++key1+++ 02|+++++key2+++++ 03|++key3++"; ! API-Basisschlüssel
string HMinfoList = "01|+++++key1+++++ 02|+++++key2+++++ 03|+++++key3+++++"; ! API-Schlüssel für Info-Meldungen
string HMwarnungList = ""; ! optionale API-Schlüssel für Warnmeldungen
string HMalarmList = ""; ! optionale API-Schlüssel für Alarmmeldungen
string prioMinList = "02|0 03|-1"; ! Prioritäten, ab der die User Nachrichten erhalten sollen

Die Schlüssel-Angabe von Keys für HMwarnungList und HMalarmList ist optional. Wenn man nicht zwischen Info-, Warnungs- und Alarm-Meldungen unterscheiden möchte, lässt man HMwarnung_list und HMalarm_list einfach leer. Auch dürfen die Listen unterschiedlich viele Elemente in beliebiger Reihenfolge enthalten, da die User-Zuordnung über die Identifyer erfolgt. Hier mal ein Beispiel, was ebenfalls problemlos funktioniert:

Code: Alles auswählen

string keyList = "02|+++++key2+++++ 03|++key3++ 01|+++key1+++ "; ! API-Basisschlüssel
string HMinfoList = "01|+++++key1+++++ 03|+++key3+++ 02|+++++key2+++++"; ! API-Schlüssel für Info-Meldungen
string HMwarnungList = "02|++key2++"; ! optionale API-Schlüssel für Warnmeldungen
string HMalarmList = "04|+++++++++++key4|+++++++++++"; ! optionale API-Schlüssel für Alarmmeldungen
string prioMinList = "03|0 04|-1"; ! Prioritäten, ab der die User Nachrichten erhalten sollen

Ausschlaggebend für die User-Definition ist immer die Master-Liste (erste Liste), wobei auch hier die Reihenfolge wegen der Identifyer egal ist. Wenn z.B. HMwarnungList nur zwei und HMinfoList vier Keys enthält, werden für User3 und User4 die Warnmeldungen als Infomeldungen versendet. Definiert man für die Client-Listen (alle weiteren Listen) mehr User, als in der Master-Liste, werden diese Einträge ignoriert. Die Anzahl der User definiert sich nur über die Keys in der Master-Liste. Sind die nachfolgenden Listen länger bzw. enthalten sie Identifyer, die in der Master-Liste nicht enthalten sind, werden diese Keys nicht berücksichtigt. Achtung: Keine Identifyer in einer Liste doppelt vergeben! Statt "xx|" kann auch ein anderer Identifyer, wie z.b. "xx-" oder "xx#" verwendet werden. Wichtig ist nur, dass die ersten beiden Zeichen den Zahlenwert als integer definieren und das dritte Zeichen ein beliebiges Trennzeichen sein kann.

Mit prioMinList definiert man die Prioritäten, ab denen die einzelnen User Push-Nachrichten erhalten sollen. Wird für einen User kein Wert definiert, erhält er automatisch sämtlich Push-Nachrigen aller Prioritäten. Tipp: Last hier den Identifyer "01|" weg, da der erste User am besten immer Push-Nachrichten aller Prioritäten empfangen können sollte. Es ist aber trotzdem möglich, ihn auf Wunsch zu definieren. Mit "01|0" würde User1 z.B. nur Push-Nachrichten ab der Priorität 0 erhalten.

Pushover - zPNS-Po

zPNS-Po311.txt

(11.38 KiB) 118-mal heruntergeladen

Pushsafer - zPNS-Ps

zPNS-Ps31.txt

(10.19 KiB) 18-mal heruntergeladen

Telegram - zPNS-Tg

zPNS-Tg31.txt

(9.35 KiB) 83-mal heruntergeladen

Pushalot - zPNS-Pa (wird seit Version 2.2 nicht mehr weitergeführt)

zPNS-Pa22.txt

(7.95 KiB) 12-mal heruntergeladen

Prowl - zPNS-Pl (wird seit Version 2.2 nicht mehr weitergeführt)

zPNS-Pl22.txt

(6.66 KiB) 11-mal heruntergeladen

Abschlussskript zum Setzen der Push-Nachrichten-Referenz (erforderlich)

SetPushTextRef30.txt

(1.17 KiB) 353-mal heruntergeladen

Die fünf Push-Dienste können einzeln oder in beliebiger Kombination genutzt werden. Sobald ein API-Schlüssel eingegeben wurde, wird der entsprechende Push-Dienst vorbehaltlich des Wertes der Systemvariablen "CCU SV Push Dienst" genutzt. Wird "CCU SV Push Dienst" nicht verwendet, gehen die eingebundenen zPNS-xx automatisch von ihrer Verwendung aus (default = 1 -> alle).

Für Pushover, Pushalot und Telegram können überdies noch verschiedene App- bzw. Bot-Tokens zur Unterscheidung von normalen Informationen (Prio -2, -1, 0), Warnungen (Prio 1) und Alarmmeldungen (Prio 2) eingerichtet und verwendet werden. Im Gegensatz zu Pushover ist bei Pushalot die Verwendung der App-Tokens kein normaler User-Key mehr erforderlich. Telegram bedingt die Verwendung von Bots, so dass hier nur einfach weitere API-Schlüssel für die zusätzlichen Bots hinzu kommen. Mehr dazu in einem der nachfolgenden Postings.

Updates der zPNS-xx

Wenn nicht explizit anders von mir erwähnt, zum Updaten am besten einfach alles unterhalb von

Code: Alles auswählen

! #####################################################################
! ##### ab hier bitte keine weiteren Einstellungen mehr vornehmen #####
! #####################################################################

aus den jeweiligen txt-Dateien per Copy & Paste in die auf der CCU installierten Skripte überschreiben und den Kopf mit den Keys darüber unverändert lassen.

HTML-Tags

An dieser Stelle möchte ich mich sehr beim User SMA bedanken, der mir einige wichtige Impulse zur Lösung des Problems gegeben hat.

Pushover und Telegram bieten die Möglichkeit zur Verwendung so genannter HTML-Tags. Damit lassen sich Textteile von Push-Nachrichten in der App z.B. farbig oder fett hervorheben. Ein Problem ist jedoch, dass Prowl, Pushalot und Pushsafer mit diesen HTML-Tags nichts anfangen können und Telegram den HTML-Tag "<font color=...>...</font>" nicht versteht. Pushsafer verwendet zum Hervorheben von Texten statt HTML- sogenannte BBCode-Tags. Die einzelnen zPNS-xx wandeln jedoch etwaig verwendete HTML-Color-Tags automatisch in für sie nutzbaren Code um.

So erzeugt das zPNS-Tg aus "<font color='orange'>Dies</font> ist ein <font color='red'>Test</font>." automatisch den String "<b'>Dies</b> ist ein <b>Test</b>.", während das zPNS-Ps ihn in "Dies ist ein Test." wandelt. Das zPNS-Po lässt den String dagegen unverändert, während das zPNS-Pl und das zPNS-Pa sämtliche HTML-Tags vollständig entfernen.

Unterbindung aufeinander folgender, identischer Push-Nachrichten

Die zPNS-xx enthalten noch eine weitere Variable, über die man den Versand von Push-Nachrichten beeinflussen kann. Mit "stopRepeat" definiert man einen Zeitraum, innerhalb dem keine identischen Push-Nachrichten gesendet werden sollen. Sobald eine andere Push-Nachricht gesendet wurde, beginnt diese Sperrzeit wieder von vorne. Ich habe diese Variable eingeführt, weil ich gelegentlich mit Push-Nachrichten eines prellenden Sabotage-Kontakts eines Fenster-Drehgriffkontakts bombadiert wurde. Auch kann man damit recht gut Push-Nachrichten über das zu häufige Betätigen der Haustürklingel oder dergleichen unterbinden. Standardmäßig ist "stopRepeat" auf 10 Sekunden gesetzt, kann aber auch beliebig variiert werden. Will man zum Beispiel die Funktion der zPNS-xx testen, sollte "stopRepeat" auf 0 oder einen entsprechend geringen Wert gesetzt werden.

Wichtig: Damit das Unterbinden funktioniert, muss am Ende des zPNP das oben erwähnte, kleine Skript zum Setzen der Systemvariablen "CCU SV Push Text Ref" angefügt werden.

Übrigens können für jedes zPNS-xx unabhängig voneinander unterschiedliche Sperrzeiten definiert werden. Dies nur zur Info, falls es mal jemand benötigen sollte.

Im nächsten Posting zeige ich Euch dann ein einfaches Beispiel zum Aufruf des zPNP in einem Skript.

Mögliche Gründe für ein Nichtfunktionieren

• Die Systemvariable "CCU SV Push Dienst" steht noch auf "aus" oder auf dem falschen Push-Dienst. In dem Fall bitte "CCU SV Push Dienst" auf den gewünschten Push-Dienst einstellen.
• Es wurden andere Systemvariablen-Namen als die Standardwerte verwendet und nicht entsprechend in den Skripten angepasst.
• Es ist ein anderes CUxD-Gerät als "CUxD.CUX2801001:1.CMD_EXEC" definiert worden. In dem Fall im zPNS-xx das korrekte CUxD-Gerät einstellen.
• Es wurden nicht überall die korrekten API-Schlüssel eingetragen. Insbesondere für Pushover müssen sich die API-Basisschlüssel in der Skriptvariablen "keyList" und die API-Schlüssel für die Anwendungen "HM...List" unterscheiden.
• Es wurde vergessen, bei den API-Schlüsseln durchgehend die so genannten Identifyer "xx|" zu verwenden. Diese sind jedoch wichtig für die Zuordnung der Schlüssel zu den jeweiligen Usern. Selbst für einen einzigen User muss stets der Identifyer "01|" verwendet werden.
• Die lokale Skriptvariable "stopRepeat" steht auf einem zu hohen Wert und unterdrückt das zeitnahe Hintereinandersenden identischer Push-Nachrichten. In dem Fall entweder "stopRepeat" auf 0 setzen oder zwei aufeinander folgende Push-Nachrichten unterschiedlichen Inhalts senden. Es genügt hier bereits ein geändertes Zeichen.

Beispiele für das zPNP aufrufende Skripte

1. Servicemeldungen auf Grundlage des Allinclusive-Skripts von Alchy.
2. Skripte für Strom-, Gas- und Wasserzähler.
3. Zentrales Programm und Skript zur Steuerung von Beschattungsgeräten (Rollläden, Markisen, Raffstore, Jalousien, etc.).
4. Alarmmeldung bei Auslösen eines Rauchmelders.
5. Meldung unverschlossener Fenster und Türen bei Änderung auf Abwesenheit und in Abwesenheit.
6. Meldungen von Briefkasten-Einwürfen und der Leerung des Briefkastens.
7. Ausschalten von Verbrauchern bei Abwesenheit.
8. Sturmwarnungen.
9. Meldung einer fertigen Waschmaschine und eines fertigen Trockners mittels HM-ES-PMSw1-Pl.
10. Meldung über einen offenen Tagesriegel (analog auch auf Fenster und Türen anwendbar).

Bis dann,

Thorsten

Versionshistorie

1. Version 1.0
   • Komplette Überarbeitung des bishirgen zPNS.
   • Einbindung der drei Push-Dienste Pushover, Prowl und Pushalot.
2. Version 1.1
   • Überarbeitung des Prowl-Aufrufs
   • Entfernung der Möglichkeit zum Zurücksetzen bestimmter Systemvariablen (push_reset)
3. Version 1.2
   • Hinzufügung von Telegram.
   • Aufteilung des zPNS in einzelne zPNS-xx (zPNS-Po, zPNS-Pl, zPNs-Pa, zPNS-Tg).
   • Umbenennung der Systemvariablen "CCU SV Push-Dienst" in "CCU SV Push Dienst".
   • Umbenennung der Systemvariablen "CCU SV Push Sound" in "CCU SV Push Pushover-Sound".
4. Version 1.3
   • Neues Abschlussskript für das Setzen von "CCU SV Push Text Ref".
   • Reihenfolge und Anzahl der zPNS-xx innerhalb des zPNP nun beliebig.
   • Umbenennung der Systemvariablen "CCU SV Push Pushover-Sound" in "CCU SV Pushover Sound".
   • Möglichkeit zur Einbindung von Devices in Pushover und Einführung der optionalen Systemvariablen "CCU SV Pushover Gerät".
   • zPNS-xx 1.3.1: Deklaration der Variablen prio als Integer statt als String.
5. Version 1.4
   • Senden von Push-Nachrichten der Prio 2 unabhängig von der Systemvariablen "CCU SV Push-Dienst".
   • Vermeidung der Unterdrückung identischer, aufeinander folgender Push-Nachrichten im Falle von Prio = 2.
   • Unterdückung von Sounds für Telegram im Falle von Prio = -2.
   • zPNS-xx 1.4.1: %-Zeichen als UTF-8-Code hinzugefügt.
   • zPNS-xx 1.4.2: Umwandlung UTF-8-Codes angepasst (Bugfix).
   • zPNS-xx 1.4.2: ²- und ³-Zeichen als UTF-8-Code hinzugefügt.
   • zPNS-xx 1.4.3: Einfügen von ".ToInteger()" bei der Prioabfrage (Bugfix). Danke an Alchy für den Hinweis.
   • zPNS-Tg 1.4.3.1: Ersetzen von "disable_notifications" durch "disable_notification" (Bugfix).
6. Version 1.5
   • Neue, vereinfachte User-Verwaltung für sämtliche zPNS-xx.
   • Einführung von Pushsafer als neuen Push-Dienst.
7. Version 1.6
   • Definition einer maximalen Nachrichtenlänge zum Sicherstellen des Sendens.
   • Umbenennung einiger lokaler Variablen.
8. Version 2.0
   • Automatische Erstellung der Systemvariablen.
9. Version 2.1
   • Einbindung der ".ToUTF8()"-Funktion zur Umwandlung von Sonderzeichen (erfordert mindestens WebUI 2.29.22).
   • Verwendung von "dom.GetObject(ID_xxx).Get(yyy)" statt "dom.GetObject(yyy)".
   • Automatisches, individuelles Umwandeln von HTML-Color-Tags in den einzelnen zPNS-xx (erfordert teilweise mindestens WebUI 2.29.22 wegen ".Replace()"-Funktion).
   • zPNS-Po 2.1.2: Unterstützung von Titeln inkl. UTF-8-Codes.
   • zPNS-Po 2.1.3: Automatisches Löschen von Titeln nach der Übertragung.
10. Version 3.0
    • Unterstützung der Bildübertragung im zPNS-Po, zPNS-Ps und zPNS-Tg
11. Version 3.1/2.2
    • alle zPNS-xx: Einbindung der ".UriEncode()"-Funktion zur Umwandlung von Sonderzeichen
    • zPNS-Po 3.1.1: Umwandlung des Farbstrings "orange" in den Farbcode "#ffa500" für Android-Geräte

[dtp]

Um nun das zPNP zu testen, klickt bitte unter "Programme und Verknüpfungen > Programme" auf den Button "Skript testen" und gebt folgenden Zeilen ein:

Code: Alles auswählen

! Namen der verwendeten Systemvariablen
string svPushText = "CCU SV Push Text"; ! gem. zPNS-xx, obligatorisch

! Name des zentralen Push-Nachrichten-Programms
string zPNP = "CCU PRG Push-Nachrichten"; ! obligatorisch

! +++++ Erzeugen der Test-Nachricht +++++
string message = "<font color=orange>Dies</font> ist eine <font color=green>gewöhnliche</font> Test-Nachricht.";

! +++++ zPNP ausführen +++++
(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushText)).State(message);
(dom.GetObject(ID_PROGRAMS).Get(zPNP)).ProgramExecute();

WriteLine("Nachricht gesendet");

Wollt ihr auch die Wirkung der Systemvariablen "CCU SV Push Dienst", "CCU SV Push Prio" und "CCU SV Push Pushover Sound" testen, so verwendet nachfolgendes Skript und ändert ggf. die String-Werte in ".State()".

Code: Alles auswählen

! Namen der verwendeten Systemvariablen
string svPushText = "CCU SV Push Text"; ! gem. zPNS-xx, obligatorisch
string svPushPrio = "CCU SV Push Prio"; ! gem. zPNS-xx, obligatorisch
string svPushService = "CCU SV Push Dienst"; ! gem. zPNS-xx, optional
string svPushoverSound = "CCU SV Pushover Sound"; ! gem. zPNS-Po, optional

! Name des zentralen Push-Nachrichten-Programms
string zPNP = "CCU PRG Push-Nachrichten"; ! obligatorisch

! +++++ Erzeugen der Test-Nachricht +++++
string message = "<font color=orange>Dies</font> ist eine <font color=green>gewöhnliche</font> Test-Nachricht.";

! +++++ Auswahl des Push-Dienstes +++++
if(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushService)){(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushService)).State("1");}

! +++++ Setzen der Priorität für die Push-Nachricht +++++
(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushPrio)).State("0");

! +++++ Sound für Pushover-Nachricht +++++
if(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushoverSound)){(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushoverSound)).State("gamelan");}

! +++++ zPNP ausführen +++++
(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushText)).State(message);
(dom.GetObject(ID_PROGRAMS).Get(zPNP)).ProgramExecute();

WriteLine("Nachricht gesendet");

"CCU SV Push Dienst" hat ja eigentlich die Werte "aus;alle;Pushover;Prowl;Pushalot;Telegram". Diese werden CCU-intern jedoch auf 0, 1, ..., 5 gesetzt. Sprich, wenn ihr nur Prowl nutzen wollt, obwohl ihr auch für Pushalot und/oder Pushover entsprechende API-Keys vergeben habt, dann setzt "CCU SV Push Dienst" oben auf den Wert 3.

Um den Versand von Bildern zu testen, empfiehlt es sich, zunächst eine kleine Bilddatei (vorzugsweise < 500 KB) mit dem Namen "Bild.jpg" in das tmp-Verzeichnis der CCU zu kopieren. Danach könnt ihr dieses Bild dann mit dem folgenden Skript per Pushover oder Telegram versenden.

Code: Alles auswählen

! Namen der verwendeten Systemvariablen
string svPushText = "CCU SV Push Text"; ! gem. zPNS-xx, obligatorisch
string svPushImage = "CCU SV Push Bild"; ! Link auf ein anzufügendes Bild, default: ""

! Name des zentralen Push-Nachrichten-Programms
string zPNP = "CCU PRG Push-Nachrichten"; ! obligatorisch

! +++++ Erzeugen der Test-Nachricht +++++
string message = "Test-Nachricht mit <font color=green>angehängtem Bild</font>.";

! +++++ Verzeichnis auf der CCU, in dem das Bild gespeichert werden soll +++++
string image = "/tmp/Bild.jpg";

! +++++ zPNP ausführen +++++
(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushText)).State(message);
(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushImage)).State(image);
(dom.GetObject(ID_PROGRAMS).Get(zPNP)).ProgramExecute();

WriteLine("Nachricht gesendet!");

Um Bilder mit Pushsafer zu versenden, ist es notwendig das entsprechende Bild vor dem Versand mit Base64 zu konvertieren. Dafür hat Pushsafer zum Beispiel einen entsprechenden Konverter verlinkt.

Wenn diese Tests erfolgreich waren, könnt ihr Euch zum Beispiel Alchys Allinclusive-Skript installieren, das ich hier zur Verwendung mit dem zPNP modifiziert habe.

TIPP: Nach jedem Neustart der CCU werden Systemvariablen mit Wertelisten immer auf den jeweils ersten Eintrag gesetzt. Im vorliegenden Fall bedeutet dies, dass das Senden von Push-Nachrichten immer ausgeschaltet wäre. Ihr könnt dies wirkungsvoll vermeiden, wenn ihr ein Reboot-Programm verwendet, das bestimmte Systemvarialben nach einem Reboot der CCU auf definierte Werte setzt. Wie das geht, habe ich hier beschrieben. Und so sollte das entsprechende Programm aussehen, wobei ich die für "CCU SV Push Dienst" relevante Zeile rot umrandet habe:

Gruß,

Thorsten

[dtp]

Pushover

Für Pushover ist die entsprechend iOS- oder Android-App notwendig. Diese ist kostenpflichtig; dafür kann man sich dann aber auch sehr viele Push-Nachrichten pro Tag kostenfrei zusenden lassen. Ich persönlich bin noch nie an die Grenzen gestoßen. Unten im Bild erkennt man die drei von mir eingerichteten Tokens bzw. Applications, die ich je nach Priorität verwende. "HomeMatic" für Push-Nachrichten der Prioritäten -2, -1 und 0, "HomeMatic Warnung" für Push-Nachrichten der Prio 1 und "HomeMatic Alarm" für Push-Nachrichten der Prio 2. Die zugehörigen Icons entstammen übrigens diesem Beitrag. Man kann die Tokens auch für andere Pushover-User verwenden, ohne sie bei dem jeweiligen User neu einrichten zu müssen. Die Erfahrung zeigt aber, dass dies mitunter zu einer deutlichen Verzögerung führen kann. Daher empfehle ich, die App-Tokens für jeden User separat einzurichten.

Prowl

Die Einrichtung einer User-API ist genau so simpel, wie bei Pushover. Prowl ist im Funktionsumfang gegenüber Pushover jedoch eingeschränkt. So sind z.B. keine App-Tokens mit unterschiedlichen Icons möglich. Auch können nur 5 statt 15 Sounds verwendet werden, die zudem unmittelbar in der App in Abhängigkeit von der Priorität eingestellt werden müssen. Prowl gestattet überdies keine Verwendung von HTML-Tags. Genau, wie Pushover erlaubt Prowl fünf verschiedene Prios von -2 bis 2.

Pushalot

Pushalot ist noch relativ neu. Dafür ist es im Gegensatz zu Prowl und Pushover kostenfrei. Ich nutze Pushalot seit einigen Tagen auf meinen Windows-10-Rechner. Was mir hier noch fehlt, ist die unmittelbare Verwendung von Prios und Sounds. Wie bei Pushover, so kann man auch bei Pushalot verschiedene App-Tokens mit entsprechenden Icons definieren. Die png-Dateien müssen dann aber auf einem separaten Webserver, wie Google+ oder dergleichen liegen. Man kann mit Pushalot daher ggf. auch sich dynamisch verändernde Bilder einer Webcam nutzen. Da die Auflösung aber 72 x 72 Pixel nicht überschreiten sollte, ist der Nutzen wohl entsprechend begrenzt.

Telgram

Für Telegram sei zunächst mal hierhin verwiesen. Da erfahrt ihr, wie ihr den Dienst und die Bots einrichten müsst.

Gruß,

Thorsten

[dtp]

So, und hier dann mal ein paar Ausgaben der Apps, jeweils mit den Prios -2, -1, 0, 1 und 2 von unten nach oben.

1. Pushover

2. Prowl

3. Pushalot

Gruß,

Thorsten

[SMA]

EDIT: KANN GELÖSCHT WERDEN UM DTP'S BEITRÄGE ANEINANDER ZU REIHEN!!!
EDIT: KANN GELÖSCHT WERDEN UM DTP'S BEITRÄGE ANEINANDER ZU REIHEN!!!
EDIT: KANN GELÖSCHT WERDEN UM DTP'S BEITRÄGE ANEINANDER ZU REIHEN!!!
EDIT: KANN GELÖSCHT WERDEN UM DTP'S BEITRÄGE ANEINANDER ZU REIHEN!!!

[Grisuli]

Hallo Thorsten,

ich habe jetzt nach deiner Beratung alles ans laufen gebracht und es funktioniert wunderbar.
Ich hätte aber noch eine Frage.

Ich habe in das Script noch eine vierte Pushover APP eingefügt und das funktioniert soweit auch, allerdings kann man die Pushover APP´s nur Anhand der Prio Einstellung unterscheiden. Ich habe bei mir noch eine APP Klingel angelegt und mit Prio 1 versehen, wenn nun die Klingel betätigt wird, geht HM Warnung und HM Klingel gleichzeitig los. Könnte man evtl. noch eine Möglichkeit einbauen die APP´s anhand des Namens auszuwählen und nicht mit der Priorität? Somit könnte man in dem Script verschiedenste APP´s ansprechen und hätte nochmehr möglichkeiten es zu verwenden.

Ich habe mal das geänderte Script angehangen, vielleicht habe ich auch einen Fehler gemacht.

VG Grisuli

Code: Alles auswählen

  ! Push-Nachrichten senden
    string APkey; string CPkey; string HMinfo; string HMwarnung; string HMalarm; string HMklingel; string push; string prio; string sound; string message; string newmessage; string messageindex;

    ! Pushover API-Schlüssel
    ! A
    APkey = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";

    ! C
    CPkey = "cccccccccccccccccccccccccccccccccccc";

    ! Pushover Tokens
    HMinfo = "xxxxxxxxxxxxxxxxxxxxxxxxx";
    HMwarnung = "xxxxxxxxxxxxxxxxxxxxxxxxx";
    HMalarm = "xxxxxxxxxxxxxxxxxxxxxxxxx";
    HMklingel = "xxxxxxxxxxxxxxxxxxxxxxxxx";

    ! Systemvariablen auslesen
    message = dom.GetObject("CCU SV Push Text").Variable();
    prio = dom.GetObject("CCU SV Push Prio").Variable();
    sound = dom.GetObject("CCU SV Push Sound").Variable();

    ! Umwandlung von Sonderzeichen in UTF-8-Codes

    ! Umwandlung Leerschritt in "%20"
    foreach(messageindex,message.Split(" "))
    {
      newmessage = newmessage+messageindex+"%20";
    }
    message = newmessage;
    newmessage = "";

    ! Umwandlung "Ä" in "%C3%84"
    foreach(messageindex,message.Split("Ä"))
    {
      newmessage = newmessage+messageindex+"%C3%84";
    }
    message = newmessage;
    newmessage = "";

    ! Umwandlung "Ö" in "%C3%96"
    foreach(messageindex,message.Split("Ö"))
    {
      newmessage = newmessage+messageindex+"%C3%96";
    }
    message = newmessage;
    newmessage = "";

    ! Umwandlung "Ü" in "%C3%9C"
    foreach(messageindex,message.Split("Ü"))
    {
      newmessage = newmessage+messageindex+"%C3%9C";
    }
    message = newmessage;
    newmessage = "";

    ! Umwandlung "ä" in "%C3%A4"
    foreach(messageindex,message.Split("ä"))
    {
      newmessage = newmessage+messageindex+"%C3%A4";
    }
    message = newmessage;
    newmessage = "";

    ! Umwandlung "ö" in "%C3%B6"
    foreach(messageindex,message.Split("ö"))
    {
      newmessage = newmessage+messageindex+"%C3%B6";
    }
    message = newmessage;
    newmessage = "";

    ! Umwandlung "ü" in "%C3%BC"
    foreach(messageindex,message.Split("ü"))
    {
      newmessage = newmessage+messageindex+"%C3%BC";
    }
    message = newmessage;
    newmessage = "";

    ! Umwandlung "ß" in "%C3%9F"
    foreach(messageindex,message.Split("ß"))
    {
      newmessage = newmessage+messageindex+"%C3%9F";
    }
    message = newmessage;
    newmessage = "";

    ! Umwandlung "°" in "%C2%B0"
    foreach(messageindex,message.Split("°"))
    {
      newmessage = newmessage+messageindex+"%C2%B0";
    }
    message = newmessage;
    newmessage = "";

    ! Kürzen der Nachricht um die jeweils am Ende angefügten Umwandlungscodes.
    message = message.Substr(0, message.Length()-51);

    ! Informationsmeldungen "HomeMatic"
    if((prio == -2) || (prio == -1) || (prio == 0))
    {
      push = dom.GetObject("CCU SV Push Info").Value();
      if(push == true)
      {
        ! Push-Nachricht an A senden
        dom.GetObject("CUxD.CUX2801001:1.CMD_EXEC").State("LD_LIBRARY_PATH=/usr/local/addons/cuxd /usr/local/addons/cuxd/curl -s -k -d token='"#HMinfo#"' -d user='"#APkey#"' -d message='"#message#"' -d priority='"#prio#"' -d sound='"#sound#"' -d html=1 https://api.pushover.net/1/messages.json");

        ! Push-Nachricht nur an C senden, wenn prio = 0
        if(prio == 0)
        {
          dom.GetObject("CUxD.CUX2801001:1.CMD_EXEC").State("LD_LIBRARY_PATH=/usr/local/addons/cuxd /usr/local/addons/cuxd/curl -s -k -d token='"#HMinfo#"' -d user='"#CPkey#"' -d message='"#message#"' -d priority='"#prio#"' -d sound='"#sound#"' -d html=1 https://api.pushover.net/1/messages.json");
        }
      }
    }

    ! Warnmeldungen "HomeMatic Warnung"
    if(prio == 1)
    {
      ! Push-Nachricht an A senden
      dom.GetObject("CUxD.CUX2801001:1.CMD_EXEC").State("LD_LIBRARY_PATH=/usr/local/addons/cuxd /usr/local/addons/cuxd/curl -s -k -d token='"#HMwarnung#"' -d user='"#APkey#"' -d message='"#message#"' -d priority='"#prio#"' -d sound='"#sound#"' -d html=1 https://api.pushover.net/1/messages.json");

      ! Push-Nachricht an C senden
      dom.GetObject("CUxD.CUX2801001:1.CMD_EXEC").State("LD_LIBRARY_PATH=/usr/local/addons/cuxd /usr/local/addons/cuxd/curl -s -k -d token='"#HMwarnung#"' -d user='"#CPkey#"' -d message='"#message#"' -d priority='"#prio#"' -d sound='"#sound#"' -d html=1 https://api.pushover.net/1/messages.json");
    }

    ! Alarmmeldungen "HomeMatic Alarm"
    if(prio == 2)
    {
      ! Push-Nachricht an A senden
      dom.GetObject("CUxD.CUX2801001:1.CMD_EXEC").State("LD_LIBRARY_PATH=/usr/local/addons/cuxd /usr/local/addons/cuxd/curl -s -k -d token='"#HMalarm#"' -d user='"#APkey#"' -d message='"#message#"' -d priority='"#prio#"' -d sound='"#sound#"' -d html=1 -d retry=30 -d expire=120 https://api.pushover.net/1/messages.json");

      ! Push-Nachricht an C senden
      dom.GetObject("CUxD.CUX2801001:1.CMD_EXEC").State("LD_LIBRARY_PATH=/usr/local/addons/cuxd /usr/local/addons/cuxd/curl -s -k -d token='"#HMalarm#"' -d user='"#CPkey#"' -d message='"#message#"' -d priority='"#prio#"' -d sound='"#sound#"' -d html=1 -d retry=30 -d expire=120 https://api.pushover.net/1/messages.json");
    }

  ! Alarmmeldungen "HomeMatic Klingel"
    if(prio == 1)
    {
      ! Push-Nachricht an A senden
      dom.GetObject("CUxD.CUX2801001:1.CMD_EXEC").State("LD_LIBRARY_PATH=/usr/local/addons/cuxd /usr/local/addons/cuxd/curl -s -k -d token='"#HMklingel#"' -d user='"#APkey#"' -d message='"#message#"' -d priority='"#prio#"' -d sound='"#sound#"' -d html=1 -d retry=30 -d expire=120 https://api.pushover.net/1/messages.json");

      ! Push-Nachricht an C senden
      dom.GetObject("CUxD.CUX2801001:1.CMD_EXEC").State("LD_LIBRARY_PATH=/usr/local/addons/cuxd /usr/local/addons/cuxd/curl -s -k -d token='"#HMklingel#"' -d user='"#CPkey#"' -d message='"#message#"' -d priority='"#prio#"' -d sound='"#sound#"' -d html=1 -d retry=30 -d expire=120 https://api.pushover.net/1/messages.json");
    }

    ! Push-Systemvariablen zurücksetzen
    dom.GetObject("CCU SV Push Text").Variable("");
    dom.GetObject("CCU SV Push Prio").Variable("");
    dom.GetObject("CCU SV Push Sound").Variable("");

[dtp]

Hier dann mal ein Beispiel für eine Meldung, die im Falle eines durch die Rauchmelder detektierten Brandes abgesetzt wird.

Code: Alles auswählen

! Meldung Rauch
! Version 2.2, Autor: dtp

! Namen der verwendeten Systemvariablen
string svPushText = "CCU SV Push Text"; ! gem. zPNS-xx, obligatorisch
string svPushPrio = "CCU SV Push Prio"; ! gem. zPNS-xx, obligatorisch
string svPushoverSound = "CCU SV Pushover Sound"; ! gem. zPNS-Po, optional

! Name des zentralen Push-Nachrichten-Programms
string zPNP = "CCU PRG Push-Nachrichten"; ! obligatorisch

! #####################################################################
! ##### ab hier bitte keine weiteren Einstellungen mehr vornehmen #####
! #####################################################################

! +++++ Deklaration weiterer Variablen +++++
string index; string list = ""; string message; 
var device;

! +++++ Setzen der Priorität für die Push-Nachricht +++++
(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushPrio)).State("2");

! +++++ Sound für Pushover-Nachricht +++++
if(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushoverSound)){(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushoverSound)).State("persistent");}

! +++++ auslösende Rauchmelder ermitteln +++++
foreach(index, dom.GetObject("Sicherheit").EnumUsedIDs()){
  if(dom.GetObject(index).IsTypeOf(OT_CHANNEL)){
    device = dom.GetObject(dom.GetObject(index).Device());
    if(device.HssType()=="HM-Sec-SD"){
      if(dom.GetObject(index).DPByHssDP("STATE").Value()){
        list=list#"\n"#device.Name();
      }
    }
  }
}

! +++++ Erzeugen der Nachricht +++++
message = "<font color=red>Achtung, Rauch im Haus!</font>";
message = message#list;

! +++++ zPNP ausführen +++++
(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushText)).State(message);
(dom.GetObject(ID_PROGRAMS).Get(zPNP)).ProgramExecute();

Und das zugehörige Programm:

Die Systemvariable "CCU SV Status" dient lediglich dazu, dass das Programm beim Neustart der CCU nicht ausgeführt wird (siehe dazu meine Signatur).

Gruß,

Thorsten

[dtp]

Code: Alles auswählen

! Aktoren für bestimmte Gewerke ausschalten
! Version 2.4, Autor: dtp 

! ----- Listen der Gewerke (trennen mit "\t", alle Gewerke oder Räume: "alle") -----
string tradeList = "Licht\t
                    Verbraucher";  

! ----- Liste der Geräte, die nicht ausgeschaltet werden sollen (trennen mit "\t") -----
string exList = "DG Schlafzimmer Dimmer Kanal 2\t
                 EG Garage Licht\t
                 EG Flur Tablet Sender Wohnzimmer\t
                 EG Flur Tablet Schaltzustand Wohnzimmer\t
                 EG Flur Tablet Schalter Wohnzimmer\t
                 UG Büro Dimmer Kanal 2\t
                 UG HWR Waschmaschine Schalter\t
                 UG HWR Trockner Schalter"; 

! ----- Namen der verwendeten Systemvariablen -----
string svPushText = "CCU SV Push Text"; ! gem. zPNS-xx, obligatorisch
string svPushPrio = "CCU SV Push Prio"; ! gem. zPNS-xx, obligatorisch
string svPushoverSound = "CCU SV Pushover Sound"; ! gem. zPNS-Po, optional

! ----- Name des zentralen Push-Nachrichten-Programms -----
string zPNP = "CCU PRG Push-Nachrichten"; ! obligatorisch

! #####################################################################
! ##### ab hier bitte keine weiteren Einstellungen mehr vornehmen #####
! #####################################################################

! +++++ Deklaration weiterer Variablen +++++
string message; string list = ""; string trade; string channelName;

! +++++ Setzen der Priorität für die Push-Nachricht +++++
(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushPrio)).State("-1");

! +++++ Sound für Pushover-Nachricht +++++
if(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushoverSound)){(dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushoverSound)).State("none");}

! +++++ Skriptkern +++++
if(tradeList == "alle"){tradeList = dom.GetObject(ID_FUNCTIONS).EnumNames();}

foreach(trade, tradeList){
  trade = trade.Trim();
  if(dom.GetObject(ID_FUNCTIONS).Get(trade)){
    foreach(channelName, (dom.GetObject(ID_FUNCTIONS).Get(trade)).EnumUsedNames()){
      if(!exList.Contains(channelName)){
        if((dom.GetObject(ID_CHANNELS).Get(channelName)).DPByHssDP("STATE").Value()){
          (dom.GetObject(ID_CHANNELS).Get(channelName)).DPByHssDP("STATE").State(0); 
          list = list#"\n- "#channelName;
        }
        if((dom.GetObject(ID_CHANNELS).Get(channelName)).DPByHssDP("LEVEL").Value()){
          (dom.GetObject(ID_CHANNELS).Get(channelName)).DPByHssDP("LEVEL").State(0.0); 
          list = list#"\n- "#channelName;
        }
      }
    }
  }
}

! +++++ Erzeugen der Nachricht +++++
message = "Geräte-Kanäle wegen Abwesenheit ausgeschaltet!";

if(list != ""){
  message = message#list;

  ! +++++ zPNP ausführen +++++
  (dom.GetObject(ID_SYSTEM_VARIABLES).Get(svPushText)).State(message);
  (dom.GetObject(ID_PROGRAMS).Get(zPNP)).ProgramExecute();
}

Das zugehörige Programm zum Setzen des 60-Sekunden-Timers.

[dtp]

Nachfolgend das von mir an das zPNP angepassten Allinclusive-Skript von Alchy samt aufrufendem Programm.

Servicemeldungen.txt

(12.38 KiB) 49-mal heruntergeladen

Und noch ein kleines Skript, mit dem ich mich informieren lasse, sobald sämtliche Servicemeldungen beseitigt sind.

Servicemeldungen_beseitigt.txt

(1.25 KiB) 335-mal heruntergeladen

Wie es in der Einleitung des "Servicemeldungen"-Skripts schon geschrieben steht, habe ich auf folgende Funktionalitäten von Alchys Allinclusive-Skript verzichtet: BLOCK, USE_SYSVAR, WITHTIME, GO.

Der Grund ist, dass man ja in den zPNS-xx eine Sperrzeit definieren kann, binnen der keine aufeinander folgenden, identischen Push-Nachrichten zugestellt werden sollen. Weiterhin erfolgt immer das Schreiben der Nachricht in die Systemvariable "CCU SV Push Text", so dass keine gesonderte Systemvariable mehr erforderlich ist. Und da die Push-Apps fast alle immer die Uhrzeit der zugestellten Nachricht anzeigen, braucht man diese ebenfalls nicht innerhalb der Nachricht zu übertragen.

Ansonsten habe ich das "Servicemeldungen"-Skript an meine Anforderungen bzgl. der Prios angepasst, um z.B. zu vermeiden, dass meine Frau die Servicemeldungen erhält. Zudem sind die Texte der Servicemeldungen etwas modifiziert worden.

Batteriebetriebene HM- und HMIP-Geräte

Ich bin noch mal sämtliche aktuell verfügbaren HM- und HMIP-Batterie-Devices durchgegangen, um deren Batteriezustand zu erfassen

HM-HMIP-Bat.txt

(1.28 KiB) 245-mal heruntergeladen

Code: Alles auswählen

block9   = "HM-LC-Sw1-Ba-PCB\tHM-LC-Sw4-PCB\tHM-LC-Sw4-WM\tHM-MOD-EM-8\tHM-MOD-Re-8\tHM-OU-CM-PCB\tHM-Sen-RD-O";
cr2016   = "HM-RC-4\tHM-RC-4-B\tHM-RC-Key3\tHM-RC-Key3-B\tHM-RC-P1\tHM-RC-Sec3\tHM-RC-Sec3-B\tZEL STG RM HS 4";
cr2032   = "HM-PB-2-WM\tHM-PB-4-WM\tHM-PBI-4-FM\tHM-SCI-3-FM\tHM-Sec-TiS\tHM-SwI-3-FM";
lr14x2   = "HM-OU-CFM-TW\tHM-Sec-Sir-WM";
lr3x1    = "HM-RC-4-2\tHM-RC-4-3\tHM-RC-Key4-2\tHM-RC-Key4-3\tHM-RC-Sec4-2\tHM-RC-Sec4-3\tHM-Sec-RHS-2\tHM-Sec-SCo\tHmIP-KRC4\tHmIP-KRCA\tHmIP-RC8\tHmIP-SRH\tHMIP-SWDO";
lr3x2    = "HM-Dis-WM55\tHM-Dis-EP-WM55\tHM-PB-2-WM55\tHM-PB-2-WM55-2\tHM-PB-6-WM55\tHM-PBI-2-FM\tHM-RC-8\tHM-Sen-DB-PCB\tHM-Sen-EP\tHM-Sen-MDIR-SM\tHM-Sen-MDIR-WM55\tHM-TC-IT-WM-W-EU\tHM-WDS30-T-O\tHM-WDS30-OT2-SM\tHmIP-STH\tHmIP-STHD\tHMIP-WRC2\tHMIP-WRC6\tHMIP-WTH\tHMIP-WTH-2\tHmIP-SAM\tHmIP-SLO\tHMIP-SWDO-I";
lr3x3    = "HM-PB-4Dis-WM\tHM-PB-4Dis-WM-2\tHM-RC-Dis-H-x-EU\tHM-Sen-LI-O";
lr3x3a   = "HM-RC-12\tHM-RC-12-B\tHM-RC-12-W\tHM-RC-19\tHM-RC-19-B";
lr3x3a   = "HM-RC-19\tHM-RC-19-B\tHM-RC-12\tHM-RC-12-B\tHM-RC-12-W";
lr44x2   = "HM-Sec-RHS\tHM-Sec-SC\tHM-Sec-SC2\tHM-Sec-SC-2";
lr6x2    = "HM-CC-RT-DN\tHM-CC-VD\tHM-CC-TC\tHM-Dis-TD-T\tHM-Sec-WDS\tHM-Sec-WDS-2\tHM-WDS10-TH-O\tHM-WDS30-OT2-SM-2\tHM-WDS40-TH-I\tHM-WDS40-TH-I-2\tHB-UW-Sen-THPL-I\tHMIP-eTRV\tHmIP-eTRV-2\tHmIP-eTRV-C\tHmIP-SMI\tHmIP-SMO\tHmIP-SMO-A\tHmIP-SPI\tHmIP-STHD\tHmIP-SPDR\tHmIP-SWD";
lr6x3    = "HM-Sec-MDIR\tHM-Sec-MDIR-2\tHM-Sec-Key\tHM-Sec-Key-S\tHM-Sec-Key-O\tHM-Sec-SD\tHM-Sen-MDIR\tHM-Sen-MDIR-O\tHM-Sen-MDIR-O-2\tHM-Sen-Wa-Od\tHM-WDS100-C6-O\tHM-WDS100-C6-O-2\tHmIP-ASIR\tHmIP-SWO-B\tHmIP-SWO-PL";
lr6x4    = "HM-CCU-1\tHM-ES-TX-WM\tHM-WDC7000";
fixed    = "HM-Sec-SD-2\tHMIP-SWSD";
recharge = "HM-Sec-Win\tHM-Sec-SFA-SM";

Falls noch jemand ein Gerät findet, was nicht in der Liste ist, immer her damit!

Anzeige der Servicemeldungen in ioBroker vis

Die Servicemeldungen lassen sich übrigens recht einfach in vis anzeigen. Das sieht dann z.B. für eine Sabotagemeldung und nach ihrem Entfernen so aus:

Dazu bedarf es lediglich eines kleinen Javaskripts.

Code: Alles auswählen

createState('vis.Servicemeldungen', 0, {
  type: 'string',
  read: true,
  write: true,
  desc: 'vis Servicemeldungen',
  def: ''
});

on("hm-rega.0.2093", function(obj){
  var message = obj.state.val;
  if(message.search("Servicemeldung") > 0){
    message = message.replace(/%0A/g, '<br>');
    setState("vis.Servicemeldungen", message);
    setState("vis.0.control.command", '{"instance": "*", "data": "08CCU", "command": "changeView"}');
  } 
});

Mit "vis.0.control.command" kann man automatisch auf den entsprechenden View (bei mir "08CCU") wechseln. Wer das nicht braucht, der löscht die Zeile einfach oder kommentiert sie aus. Der Datenpunkt "2093" ist die ISE_ID für die auf meiner CCU3 erstellte Systemvariable "CCU SV Push Text". Das Skript fragt bei Änderung dieser Systemvariablen den String "Servicemeldung" ab und zeigt im vis-Widget "basic - String (unescaped)" über das Objekt "javascript.0.vis.Servicemeldungen" alles an, was diesen String enthält.

Bis dann,

Thorsten

[Gnadenloos]

Hallo,ich bin auch ein absoluter Newbie der sich mit Push Nachrichten auseinander setzt (wenn auch mit Programmiererfahrung, hoffe es hilft . Mir ist der Aufbau und die Wirkungsweise nicht so ganz klar. Ich lese oftmals im www, dass User bestehende Prowl Probleme dadurch gelöst haben, dass sie sich auf mein-homatic (kostenpflichtig) angemeldet haben.

Die hier dargestellte Anleitung ist super, muss ich irgendwelche Dienste zum Einsatz freischalten?
Bitte Info und DANKE? Hoffe perspektivisch auch helfen zu können...