[Workshop] 02_RSS.pm für Anfänger - Schritt für Schritt erklärt

[betateilchen]

Ausgehend von der ab hier geführten Diskussion

http://forum.fhem.de/index.php/topic,21846.msg159025.html#msg159025

werde ich hier in einer Schritt-für-Schritt-Anleitung erklären, wie man das in fhem vorhandene Modul 02_RSS.pm nutzen kann.

Um diesen Anleitungs-Thread übersichtlich zu halten, bitte ich darum, hier im Thread keine Diskussion zu führen oder Fragen zu stellen.

Für Fragen und Diskussion habe ich diesen Thread eröffnet: Diskussions-Thread zum RSS-Workshop

[betateilchen]

Vorbereitungen für den Workshop:

• Debian Nutzer installieren bitte das Paket msttcorefonts (ich hab keine Ahnung, ob es sowas auch für Fritzbox gibt)
• Legt Euch im Verzeichnis ./FHEM eine leere Datei mit dem Namen "rss.layout" an
• Eventuell brauchen wir im Verlauf des Kurses auch die 99_myUtils.pm - das weiss ich noch nicht genau

Wichtiger Nachtrag:

Das Modul 02_RSS.pm benutzt einige zusätzliche perl Module.
Für Debian Distributionen gelten folgende Paketnamen, die mit "apt-get install" nachinstalliert werden können, was viel schneller geht als über CPAN.

• libgd-graph-perl - zwingend!
• libgd-text-perl - optional, aber dringend empfohlen
• libimage-librsvg-perl - optional, aber dringend empfohlen

In diesem Workshops werden ALLE DREI genannten Module gebraucht!

Im Laufe des Workshops werden wir auch mit dem Modul openweathermap als Datenquelle für die Befüllung des RSS arbeiten.
Dieses Modul benötigt für seine Funktion zumindest das Modul XML::Simple, das man auf Debian im Paket libxml-simple-perl bereitgestellt wird.

[betateilchen]

Die Ausgangsfrage, die zu diesem Workshop führte, war die Frage, wie man eine solche Seite in fhem erstellen kann:

(http://up.picr.de/17966931jv.jpg)

Die Grundlagen dazu werde ich hier erklären.

Grundsätzliche Funktion des Moduls 02_RSS.pm

Das Modul stellt einen "echten" RSS Feed bereit, der als einzigen Inhalt eine JPEG Datei in sich trägt. Dieser RSS kann z.B. von Tablets, WLAN Bilderrahmen usw. angezeigt werden.

Den "echten" RSS brauchen wir hier im Workshop nicht wirklich, wir werden nur das darin enthaltene Image benutzen.

 

[betateilchen]

1. Schritt - Definition des RSS in fhem

Code: [Auswählen]


define myrss RSS jpg 192.168.123.241 ./FHEM/rss.layout


Die IP müsst Ihr natürlich durch die IP Eures fhem Servers ersetzen. Man kann dort auch den Hostnamen des fhem-Servers angeben, wenn dieser Name zuverlässig aufgelöst werden kann. Aber bitte nicht "localhost" oder 127.0.0.1 eintragen, sonst ist der RSS nicht von einem anderen PC aus abrufbar! Der Einfachheit halber verwenden wir hier bei der IP Adresse. (Bitte nicht daran stören, wenn hier im Workshop wechselnde IP Adressen auftauchen, bei Euch sollte das immer die gleiche bleiben.)

Es gibt zwei Ergebnisse:

1. ein neu angelegtes Device:

(http://up.picr.de/18004789tl.png)

2. ein neuer Eintrag in der Navigation links, der RSS heißt:

(http://up.picr.de/17974921cp.png)

Den Eintrag RSS könnt Ihr bereits anklicken, dann kommt eine Seite die ungefähr so aussieht:

(http://up.picr.de/17974953ly.png)

Auf dieser Seite stehen Links zu allen in fhem definierten RSS - im Moment steht da nur einer.

Klickt man diesen Link an, kommt man zu dieser Seite:

(http://up.picr.de/17974954bo.png)

Das ist der "echte" RSS Feed, der von RSS Readern verarbeitet werden kann.

Im dargestellten XML findet sich die URL zum RSS-Image:

Code: [Auswählen]

http://192.168.123.158:8083/fhem/rss/myrss.jpg
Diese Adresse sollte Ihr Euch am besten als Lesezeichen ablegen, die brauchen wir immer wieder, um die Ergebnisse unserer Arbeit anzuschauen.

Ich könnt Euch das Ergebnis auch jetzt schon anschauen, es sollte ein schwarzes Rechteck in der Größe 800x600 Pixel erscheinen. Warum das so ist, erkläre ich Euch nach der nächsten

(http://www.wdrmaus.de/codebase/img/start/maus_hinter_schlitz.png)

[betateilchen]

Erklärungen: Woher kommt das schwarze Rechteck?

Ganz einfach: Es wird standardmäßig ein JPEG in der Größe 800 x 600 Pixel generiert, das die Hintergrundfarbe schwarz hat. Bisher haben wir noch kein anderes Verhalten vorgegeben.

Grundsätzlich läßt sich die Größe über das Attribut size steuern, dort kann man z.B. 1024x768 (Achtung: wirklich mit x!) setzen. Bei meinem 7" Tablet, das eine Auflösung von 800x480 Pixel hat, habe ich die Auflösung zum Beispiel auf 800x442 gesetzt, da die Android-Symbole noch von der Nutzfläche abgezogen werden müssen (bei mir 38px hoch) und ich nicht scrollen wollte.

Die Statusseite auf meinem Tablet sieht deshalb so aus:

(http://up.picr.de/17975274qh.jpg)

Der Hintergrund kann auch ein Bild sein, das wird aber jetzt hier noch nicht erklärt, das ist dann "RSS für Fortgeschrittene", wir bleiben hier bei einem farbigen Hintergrund, im Normalfall schwarz. Ich warte auf die Implemenierung der Möglichkeit, die Hintergrundfarbe per Attribut bestimmen zu können, aber Boris als Modul-Maintainer prüft alle Änderungsvorschläge sorgfältig und das dauert manchmal ein bisschen. Ich hoffe, die Umsetzung kommt noch im Laufe dieses Workshops.

[betateilchen]

2. Schritt - Wir erstellen das erste Layout

Mit einem schwarzen Rechteck kann natürlich niemand was anfangen, deshalb werden wir das jetzt mit Inhalt füllen.
Alles was in dem Image dargestellt werden soll, muss in einer Layout-Datei definiert werden. Diese Layout-Datei habt Ihr (hoffentlich) in der Vorbereitungsphase bereits angelegt.

Die Layout-Datei kann direkt aus dem FHEM Frontend bearbeitet werden. Ihr findet die Datei unter "Edit Files" links in der Navigation

(http://up.picr.de/17975497el.png)

Dort könnt Ihr die Datei nun zum Editieren auswählen und bekommt sowas hier angezeigt:

(http://up.picr.de/17975543fh.png)

In das angezeigte Editorfenster tragt Ihr nun bitte folgendes ein und speichert die Datei dann mit dem "Save rss.layout" Button ab:

(http://up.picr.de/17975562yg.png)

Jetzt kommt etwas ganz wichtiges!

Nach jeder Änderung der Layout-Datei muss der RSS intern neu generiert werden. Das passiert mit folgendem Befehl im Frontend

Code: [Auswählen]

set myrss rereadcfg
Danach könnt Ihr das Ergebnis Eurer Arbeit anhand des schon beschriebenen Lesezeichens (die URL zur Imagedatei) anschauen:

(http://up.picr.de/17975608yz.jpg)

Das ist jetzt optisch noch nicht der Knaller, aber keine Sorge, das ändern wir alles noch.

Erklärung zu dem, was grade passiert ist - nach der nächsten Maus

[betateilchen]

Erklärungen - was ist in Schritt 2 passiert?

Wir haben in der Layout-Datei den ersten Eintrag angelegt, der dem RSS Generator sagt, was gemacht werden soll:

Code: [Auswählen]

text 100 100 "Hallo, ich bin Dein RSS!"
Dröseln wir das mal auf:

text = gibt an, dass wir einen Text ausgeben wollen

100 100 = das sind die x und y Koordinaten, WO wir den Text ausgeben wollen, gezählt wird dabei von oben links (0,0) nach unten rechts (800,600)

"Hallo, ich bin Dein RSS!" = das ist der Text, der ausgegeben werden soll

Technisch gesehen, wird der Text quasi als Bild in die schwarze Fläche "gemalt" (gerendert)

Dieses Verfahren ist für alle darzustellenden Objekte, die ich noch beschreiben werde, gleich.

Die Syntax besteht immer aus den Komponenten

- Objekttyp
- Position
- Inhalt

Der Text im vorliegenden Beispiel wurde statisch vorgegeben. Das macht natürlich für sich ändernde Statusanzeigen nicht viel Sinn. Und deshalb kommt jetzt die gute Nachricht: "Man kann den Text selbstverständlich auch dynamisch erzeugen!"

Ändert doch einfach mal die Zeile in der Layout-Datei in folgendes:

Code: [Auswählen]

text 100 100 { fhem("version fhem.pl") }
Und schaut Euch dann das Ergebnis an. (das rereadcfg nicht vergessen!)


Das soll es für heute gewesen sein. Irgendwann hab ich auch mal Feierabend

Morgen machen wir als Erstes den Text optisch "schöner".

[betateilchen]

mir ist grade noch was wichtiges eingefallen 

Im "Vorbereitungs"-Beitrag hier im Thread habe ich noch die zusätzlichen perl-Module aufgelistet, die von 02_RSS.pm genutzt werden.

http://forum.fhem.de/index.php/topic,22520.msg159292.html#msg159292

[betateilchen]

Schritt 3: Wir machen den Text schön.

Die optische Darstellung eines Textes im RSS wird durch 5 Faktoren maßgeblich beeinflußt:

• Schriftart (font)
• Schriftgröße (Höhe in pixel)
• Schriftfarbe
• Rechtschreibung
• Grammatik

Die Punkte 4 und 5 lassen wir hier aussen vor, dafür ist das allgemeine Schulwesen mit seinem Lehrauftrag zuständig 

Für die Punkte 1-3 haben wir Möglichkeiten in der Layoutdatei.

Die Schriftart wird durch das Schlüsselwort "font" bestimmt. Damit wird der komplette Pfad inklusive Dateinamen zu einer TTF Datei angegeben, die wir verwenden wollen.

Beispiel:

Code: [Auswählen]

font /usr/share/fonts/truetype/msttcorefonts/arial.ttf
Die Schriftgröße wird durch das Schlüsselwort "pt" bestimmt. Damit wird die Höhe der Schriftart angegeben, ähnlich wie man das aus Textverarbeitungsprogrammen kennt.

Beispiel:

Code: [Auswählen]

pt 12
Die Schriftfarbe wird durch das Schlüsselwort "rgb" bestimmt. Damit wird die Farbe im Hexcode (wie z.B. in HTML üblich) angegeben.

Beispiel (für die Farbe weiss):

Code: [Auswählen]

rgb "FFFFFF"

Nun kommen wir zur generellen Verarbeitung der Layoutdatei. Diese Datei wird IMMER von oben nach unten abgearbeitet. Es kann also in einer Datei durchaus mehrere Definitionen der Farben und Schriftgrößen geben (auch der Schriftart, damit sollte man aber sparsam umgehen, viele Schriftarten auf einer Seite erschweren die Lesbarkeit erheblich)

Hierbei gilt eine einfache Regel:

Jede Definition eines Parameters gilt so lange, bis in der Layoutdatei eine neue Definition erfolgt.

Was bedeutet das?

Legt Euch bitte die Layout-Datei mit folgendem Inhalt an:

(http://up.picr.de/17979166sl.png)

und kontrolliert dann das Ergebnis, das so aussehen sollte:

(http://up.picr.de/17979170iq.jpg)

Ich denke, das Beispiel erklärt die oben angegebene Regel von selbst.

Achja - Zeilen in der Layout-Datei, die mit # beginnen, sind Kommentare und werden bei der Verarbeitung ignoriert.

[betateilchen]

Schritt 4: Sonderformen von "text"

Zusätzlich zur Ausgabe eines freigewählten (oder eines irgendwie variabel ermittelten) Textes bietet das RSS Modul einfache Möglichkeiten zur Ausgabe von Datum und Uhrzeit.

Fügt bitte am Ende der Layout-Datei aus Schritt 3 folgende Zeilen ein:

Code: [Auswählen]

# nun geben wir das Datum aus
date 400 100

# und jetzt noch die aktuelle Uhrzeit
time 400 200

Und schaut Euch das Ergebnis an.

(http://up.picr.de/17979725xh.jpg)

Das war einfach, oder? 

[betateilchen]

Erklärung - was ist im letzten Schritt passiert?

Ich denke, das erklärt sich weitgehend selbst. Die Syntax von date und time ist ähnlich der Syntax von Text, es werden einfach die x und y Koordinaten angegeben, der auszugebende Text ergibt sich automatisch durch das Schlüsselwort date bzw. time, das wird vom RSS Modul automatisch verarbeitet.

ABER...

Wenn man sich den Screenshot aus dem vorherigen Beispiel anschaut, kommt man irgendwann auf folgende Frage:

"Worauf beziehen sich eigentlich die Positionsangaben in Bezug auf die Ausrichtung des auszugebenden Objektes?"

Bei Text ist das relativ einfach: Die x-Position bezeichnet die Stelle, von der aus der Text nach rechts ausgegeben wird.
Die y-Position bestimmt eine Schriftlinie, "auf der der Text steht". Das heißt, Unterlängen wie bei g j p q y erscheinen unterhalb dieser Linie
Sowohl der Text "Ich bin ein weisser, 12px hoher Text" als auch das Datum wurden an der y-Position 100 ausgegeben.
Denkt Euch eine Linie, die ebenfalls an der y-Position 100 gezogen ist, dann würde das so aussehen:

(http://up.picr.de/17979799hq.jpg)

Ich denke, anhand des Bildes wird klar, was ich mit Schriftlinie meine. (im Bild ist der Vollständigkeit halber auch noch die Linie für die x-Position eingezeichnet)

Dieses Verständnis ist wichtig, um später mehrere Objekte korrekt aneinander ausrichten zu können.

Selbstverständlich kann man auch das Verhalten der Ausrichtung von Objekten an einer angebenen Position noch definieren, aber das kommt erst viel später. Im Moment bleiben wir erstmal beim Standardverhalten.

[betateilchen]

Übrigens: Ihr braucht Euch die einzelnen Beispiele nicht alle speichern, am Ende des Workshops werdet Ihr eine Layout-Datei haben, in der alle besprochenen Teile enthalten sind.

Schritt 5 - wir zeichnen Linien

Legt Euch bitte eine die Layout-Datei wie folgt an:

Code: [Auswählen]

rgb "FFFFFF"
line 0 300 800 300

rgb "FF0000"
line 400 0 400 600

rgb "00FF00"
line 0.1 0.1 0.9 0.9

rgb "FFFF00"
line 0.9 0.1 0.1 0.9

und betrachtet Euch das Ergebnis:

(http://up.picr.de/17980114vv.jpg)

Erklärungen

Die Syntax des line Befehls ist folgende:

Code: [Auswählen]

line <x1> <y1> <x2> <y2> [<thick>]
<x1><y1> bezeichnet den Startpunkt, <x2><y2> bezeichnet den Endpunkt der Linie, die NICHT nur horizontal oder vertikal sein muss!

Die Angabe der Linienstärke <thick> ist optional. Die Standardlinienstärke ist 1px.

Code: [Auswählen]

rgb "FFFFFF"
line 0 300 800 300
bedeutet also:

"Nimm weisse Farbe und ziehe eine Linie von 0,300 nach 800,300. Das entspricht einer durchgehenden Linie vom linken zum rechten Rand."

Würde man diese erste Linie mit einer Dicke von 5 zeichnen wollen, müsste es so aussehen:

Code: [Auswählen]

rgb "FFFFFF"
line 0 300 800 300 5
Das Ergebnis könnt Ihr euch ja mal selbst basteln.

Der zweite Teil

Code: [Auswählen]

rgb "FF0000"
line 400 0 400 600
dürfte sich damit auch selbst erklären.

Aber kommen wir nun zu den zwei weiteren Linien:

Code: [Auswählen]

rgb "00FF00"
line 0.1 0.1 0.9 0.9

rgb "FFFF00"
line 0.9 0.1 0.1 0.9

Was sind denn das für komische Positionsangaben mit 0.1 und 0.9?

Relativ einfach erklärt:

Alle Positionsangaben >= 1 werden als absolute (Pixel-)Positionen interpretiert, also z.B. 300/500

Alle Positionsangaben < 1 werden als relative Positionen, bezogen auf die Gesamtbreite und Gesamthöhe des Bildes  interpretiert.

Das heißt:

Code: [Auswählen]

line 0.1 0.1 0.9 0.9
wird in unserem Beispiel intern umgerechnet in "line 80 60 720 540" und dann gezeichnet.

Um ein Fadenkreuz in die Mitte des RSS zu zeichnen, könnte man also auch schreiben:

Code: [Auswählen]

line 0.5 0 0.5 600
line 0 0.5 800 0.5
Achtung: Die Angabe von "1" zur Kennzeichnung der vollen Breite bzw. Höhe funktioniert leider nicht mehr, das hat Boris irgendwann aus mir bisher unerfindlichen Gründen wieder ausgebaut (es gab die Möglichkeit früher schonmal)


Es gibt auch noch eine dritte Möglichkeit zur Angabe von Positionsdaten, dazu kommen wir später noch.

[betateilchen]

Schritt 6 - Grafiken in den RSS einbinden

Wir können jetzt schon Text (inkl. Datum und Uhrzeit) schreiben und Linien zeichnen. Was noch fehlt, ist das Einbinden von Grafiken in den RSS.

Auch das ist recht einfach möglich, und es folgt dem bereits bekannten, wenn auch im "Inhalt" erweiterten Syntaxprinzip:

Code: [Auswählen]

img <x> <y> <scale> <type> <srcType> <source>
Legt Euch bitte folgendes Layout an:

Code: [Auswählen]

rgb "FFFFFF"

line 0 0.5 800 0.5
line 0.5 0 0.5 600

img 0.5 0.5 1 png url "http://fhem.de/www/images/default/fhemicon.png"

und bewundert das Ergebnis 

(http://up.picr.de/17983753hm.jpg)

Erklärung - nach der nächsten Maus.

[betateilchen]

Erklärung

Code: [Auswählen]

img 0.5 0.5 1 png url "http://fhem.de/www/images/default/fhemicon.png"
aufgedröselt:

img = Schlüsselwort für den auszuführenden Befehl

0.5 0.5 = x/y Position, im Beispiel also genau die Mitte

1 = Skalierungsfaktor, das heißt, die Grafik wird 1:1 wiedergegeben.

png = Grafikformat der einzufügenden Datei/Daten

url = gibt an, dass die Grafikdatei von einer URL gelesen wird. Alternativ gibt es noch "file" und "data" (das erkläre ich auch noch)

"http://..." = die URL mit der Grafikadresse

Achtung: Die Angabe des Formates (z.B. "png") ist unabhängig von der Angabe des Dateinamens notwendig!

Das weiße Fadenkreuz im Beispiel dient nur zur Verdeutlichung, worauf sich die Positionsangaben bei img standardmäßig beziehen: es geht dabei immer um die linke obere Ecke des Bildes.

[betateilchen]

Noch ein wichtiger Hinweis zum Einbinden von img über url:

Niemals eine url verwenden, die vom gleichen fhem bereitgestellt wird!

Wer das versucht, landet in einer Endlosschleife.

[betateilchen]

Schritt 7 - Anwendung des bisher gelernten

Wir haben uns jetzt die wichtigsten Grundlagen erarbeitet, um daraus schon etwas sinnvolles zu bauen.
Nun bauen wir uns daraus uns erstes "echtes" Layout, mit dem wir im Laufe dieses Workshops weiterarbeiten werden.

Bitte folgendes Layout anlegen:

Code: [Auswählen]

# Schriftart festlegen
font /usr/share/fonts/truetype/msttcorefonts/arial.ttf

# Farbe weiss
rgb "FFFFFF"

# drei waagerechte Linien
line 0  40 800  40
# 0.4 * 600 = 240
line 0 0.4 800 0.4
line 0 440 800 440

# wir bauen uns eine Kopfzeile
# Schriftgroesse festlegen
pt 20
date  10 30
time  650 30
rgb "00FF00"
text 300  30 "myrss Workshop"

# ein skaliertes Bild einbinden
img 764 1 .29 png url "http://fhem.de/www/images/default/fhemicon.png"

# einige vorlaeufige Beschriftungen
pt 12
rgb "FFFFFF"
text  10  80 "Darstellungsbereich 1"
text  10 280 "Darstellungsbereich 2"
text  10 480 "Hier bauen wir uns einen SVG Plot ein"

In diesem Layout sind alle bisher besprochenen Elemente enthalten - ich hoffe, ich habe keines vergessen

Das Ergebnis sollte so aussehen:

(http://up.picr.de/17988154om.jpg)

Das macht doch schonmal was her, oder?

[betateilchen]

Für den weiteren Fortgang des Workshops brauchen wir ein paar Datenquellen und einen SVG Plot. Ich schlage vor, wir nutzen dafür openweathermap als Quelle für Wetterdaten, damit kann man am einfachsten arbeiten und alle haben die gleichen Bedingungen.

1. Definition eines owo device

Code: [Auswählen]

define owo openweathermap
attr owo owoInterval 600
set owo stationByName Hamburg

(wer möchte, kann natürlich auch seinen Heimatort oder die nächstgelegene größere Stadt eintragen)

2. Definition eines zugehörigen Logfiles

Code: [Auswählen]

define owolog FileLog ./log/owo.log owo.*(c_temperature|c_humidity|c_pressure).*
3. Anlegen eines gplot-Files mit Namen SVG_owolog_1.gplot im Verzeichnis www/gplot

Code: [Auswählen]

set terminal png transparent size <SIZE> crop
set output '<OUT>.png'
set xdata time
set timefmt "%Y-%m-%d_%H:%M:%S"
set xlabel " "
set title '<L1>'
set ytics
set y2tics
set grid ytics
set ylabel "Temperatur"
set y2label "Luftfeuchte"
set yrange [10:30]
set y2range [0:100]

#FileLog 4:owo.c_temperature\x3a::
#FileLog 4:owo.c_humidity\x3a::
#FileLog 4:owo.c_pressure\x3a:950:$fld[3]-950

plot "<IN>" using 1:2 axes x1y1 title 'Temperatur' ls l0 lw 1 with lines,\
     "<IN>" using 1:2 axes x1y2 title 'Feuchte' ls l2 lw 1 with lines,\
     "<IN>" using 1:2 axes x1y2 title 'Luftdruck' ls l1 lw 1 with lines

4. Definition des SVG plots

Code: [Auswählen]

define SVG_owo SVG owolog:SVG_owolog_1:CURRENT
attr SVG_owo label "min:$data{min1}°C   max:$data{max1}°C   akt:$data{currval1}°C"

Wenn alles richtig gemacht wurde und die ersten Daten im Logfile stehen (Achtung: es wird nur alle 10 Minuten geloggt!) sollte so etwas erscheinen:

(http://up.picr.de/17988574un.jpg)

• Diesen Plot werden wir in den RSS einbinden.
• Die Readings aus dem owo Device werden wir für die Weiterentwicklung des RSS verwenden.

[betateilchen]

Schritt 8 - wir binden den SVG Plot in unseren RSS ein

Zuerst erinnern wir uns an diese Aussage:

url = gibt an, dass die Grafikdatei von einer URL gelesen wird. Alternativ gibt es noch "file" und "data"

"file" sollte sich eigentlich selbst erklären, da wird einfach eine Grafikdatei aus dem Dateisystem gelesen und verwendet, darauf werde ich nicht weiter eingehen.

Aber nun kommen wir zu "data". Wir können auch einfach die DATEN verwenden, die eine Grafik beschreiben, vereinfacht gesagt, wäre das der Inhalt, der in eine Grafikdatei geschrieben würde, wenn man sie abspeichern wollte. Den Umweg über die Grafikdatei sparen wir uns aber.

Das Modul 98_SVG stellt uns dafür eine schöne Funktion namens "plotAsPng()" bereit, die einen SVG plot als Datenstrom im png-Format bereitstellt, und genau diese Funktion nutzen wir im RSS. Die Standardplots aus SVG sind im Format 800x160 und passen damit vom Format exakt zu unserem RSS.

Wir ändern am Ende der Layoutdatei folgendes:

1. Auskommentieren (oder Löschen) der Zeile für den Ausgabebereich
2. Einbinden des SVG plots anhand seines in fhem definierten Namen

Code: [Auswählen]

#text  10 480 "Hier bauen wir uns einen SVG Plot ein"
img  0 441 1 png data { plotAsPng("SVG_owo") }

Das war schon alles, was wir tun müssen, um das hier zu erhalten:

(http://up.picr.de/17988799mq.jpg)

Einfacher gehts wohl kaum noch, glaube ich.

[betateilchen]

Schritt 9 - wir zeichnen Rechtecke

Seit heute (danke Boris!) gibt es in RSS neu die Möglichkeit, Rechtecke mit und ohne Füllung zu zeichnen.

Wir fügen am Ende der Layoutdatei folgende drei Zeilen ein:

Code: [Auswählen]

rgb "FF0000"
rect 400 120 480 160
rect 400 320 480 360 1

und betrachten das Ergebnis:

(http://up.picr.de/17989138uo.jpg)

Erklärung: nach der nächsten Maus 

[betateilchen]

Erklärung - was ist im letzten Schritt passiert?

Die Syntax für das Zeichnen von Rechtecken

Code: [Auswählen]

rect 400 120 480 160
rect 400 320 480 360 1

ist ähnlich wie die Syntax für das Zeichnen von Linien.

Code: [Auswählen]

rect <x1> <y1> <x2> <y2> [<filled>]
x1/y1 = bezeichnet dabei die linke obere Ecke
x2/y2 = bezeichnet die untere rechte Ecke
filled  = (optional) gibt an, ob das Rechteck nur gezeichnet oder auch mit Farbe gefüllt werden soll

Damit sollten sich die beiden Befehlszeilen eigentlich selbst erklären.

Wozu man die Rechtecke nutzen kann, erkläre ich Euch nach der nächsten Maus 

[betateilchen]

Schöner machen - wir kombinieren den Plot im RSS mit einem Rechteck

Mal ehrlich, so richtig "schön" sieht das hier ja noch nicht aus:

(http://up.picr.de/17990117wq.jpg)

Irgendwie hängen die Achsenbeschriftungen auf dem schwarzen Hintergrund "in der Luft".
So würde das doch viel angenehmer aussehen:

(http://up.picr.de/17990121nv.jpg)

Kein Problem, wir können ja nun Rechtecke zeichnen und die sogar füllen. Wir legen also einfach ein passend großes Rechteck mit der gewünschten Hintergrundfarbe unter den Plot.

Code: [Auswählen]

#text  10 480 "Hier bauen wir uns einen SVG Plot ein"
rgb "585858"
rect 0 441 800 600 1
img  0 441 1 png data { plotAsPng("SVG_owo") }

Wichtig: auf die Reihenfolge achten.

Wer nicht glaubt, dass das wichtig sei, kann ja spasseshalber die Reihenfolge mal umdrehen und erst den Plot und dann das Rechteck einbauen  Ich sagte ja eingangs schon, dass die Layout von oben nach unten abgearbeitet wird. Man muss sich das an dem aktuellen Beispiel wie ein Wurstbrot vorstellen:

• der schwarze Hintergrund ist die Brotscheibe
• das graue Rechteck ist die Butter auf der Brotscheibe
• der SVG Plot ist der Wurstbelag auf der Butter auf der Brotscheibe

[betateilchen]

Bitte kommentiert jetzt die drei Zeilen für die roten Rechtecke wieder aus (oder löscht sie einfach)

Code: [Auswählen]

#rgb "FF0000"
#rect 400 120 480 160
#rect 400 320 480 360 1

Seit heute gibt es noch eine weitere Neuerung im RSS-Modul

Seit heute kann man mit einem Attribut die Hintergrundfarbe eines RSS definieren, anstatt immer nur mit dem schwarzen Standardhintergrund arbeiten zu müssen.

Beispiel:

Code: [Auswählen]

attr myrss bgcolor 0000FF
Diese Änderung wird sofort wirksam, das "set myrss rereadcfg" ist nicht notwendig, da die Änderung ja nicht im Layout erfolgt.

(http://up.picr.de/17990239iq.jpg)

Die "Unschärfen" im Bild kommen von der Unzulänglichkeit des jpg Formates. Das wurde ja im Diskussionsthread schon besprochen und ich habe heute auch schon einen Patch vorgeschlagen, mit dem man wahlweise auch PNG als Ausgabeformat definieren kann.

Das würde dann so aussehen:

(http://up.picr.de/17990240mp.png)

Die Unschärfen sind komplett verschwunden. Sofern die Änderung im Laufe des Workshops noch in das Modul eingebaut wird, werde ich darauf natürlich noch einmal eingehen.

Ich bevorzuge als bgcolor übrigens den Farbcode 1C1C1C - das ist nicht ganz so hart wie das totale schwarz.

Code: [Auswählen]

attr myrss bgcolor 1C1C1C
Für den weiteren Verlauf des Workshops gehe ich von einem schwarzen (zumindest einem sehr dunklen) Hintergrund aus.

[betateilchen]

Schritt 10 - wir benutzen Werte aus fhem-Readings im RSS

Bitte ändert in der Layout-Datei den Teil mit der Kopfzeile so ab:

Code: [Auswählen]

# wir bauen uns eine Kopfzeile
# Schriftgroesse festlegen
pt 20
date  10 30
time  650 30
#rgb "00FF00"
#text 300  30 "myrss Workshop"

rgb "FF0000"
text 200 30 { ReadingsVal('owo','c_temperature','')."°C"}

rgb "2E64FE"
text .5  30 { ReadingsVal('owo','c_humidity','')."%"}

rgb "00FF00"
text 500 30 { ReadingsVal('owo','c_pressure','')." hPa"}

und bewundert die schöne neue Kopfzeile:

(http://up.picr.de/17990309bk.jpg)

Ich denke, dazu muss man nicht viel erklären. Das ist die grundsätzliche Vorgehensweise, wenn man Werte aus irgendwelchen fhem-Devices im RSS darstellen möchte: man liest sie einfach aus und übergibt sie an "text" Der Teil zwischen den geschweiften Klammern ist reine perl Syntax, wie man sie auch aus notify, at und der 99_myUtils kennt.

[betateilchen]

Schritt 11a - Ausrichtung von Texten

Bitte ergänzt in Eurer Layoutdatei am Ende folgende Zeilen:

Code: [Auswählen]

# weitere  Linien im Darstellungsbereich 1
rgb "7F7F7F"
line 400  40 400 240
line 600  40 600 240
line 400 140 800 140

# Demo Textausrichtung vertikal
rgb "FFFFFF"
tvalign "top"
text 410 140 "TO"

tvalign "center"
text 440 140 "CE gjp"

tvalign "base"
text 490 140 "BA gjp"

tvalign "bottom"
text 540 140 "BO gjp"

tvalign "base" # Rücksetzen auf default

# Demo Textausrichtung horizontal
thalign "left"
text 600 170 "LEFT"

thalign "center"
text 600 200 "CENTER"

thalign "right"
text 600 230 "RIGHT"

thalign "left" # Rücksetzen auf default

Das Ergebnis sollte so aussehen:

(http://up.picr.de/17991364oh.jpg)

Auf diese Weise kann man anhand von gedachten Hilfslinien Texte sowohl waagerecht als auch senkrecht ausrichten.
Das Beispiel sollte eigentlich selbst erklärend sein.

thalign => aufgedröselt:
t = text
h = horizontal
align= ausrichten

tvalign => aufgedröselt:
t = text
v = vertikal
align= ausrichten

Natürlich gibt es diese Möglichkeit auch für eingefügte Bilder - nach der nächsten Maus.

[betateilchen]

Schritt 11b - Ausrichtung von Bildern

Was für Texte geht, geht natürlich auch für Bilder.

Bitte ergänzt Eure Layout-Datei am Ende um folgende Zeilen:

Code: [Auswählen]

# nochmal zwei Hilfslinien
rgb "7F7F7F"
line 300  40 300 240
line   0 140 250 140

# Demo Bildausrichtung vertikal
ivalign "top"
img  10 140 1 png url "http://up.picr.de/17991350as.png"

ivalign "center"
img  75 140 1 png url "http://up.picr.de/17991350as.png"

ivalign "bottom"
img 140 140 1 png url "http://up.picr.de/17991350as.png"

ivalign "top" # Rücksetzen auf default

# Demo Bildausrichtung horizontal
ihalign "left"
img 300  50 1 png url "http://up.picr.de/17991350as.png"

ihalign "center"
img 300 115 1 png url "http://up.picr.de/17991350as.png"

ihalign "right"
img 300 180 1 png url "http://up.picr.de/17991350as.png"

ihalign "left" # Rücksetzen auf default

Das Ergebnis sollte so aussehen:

(http://up.picr.de/17991713uj.png)

ihalign => aufgedröselt:
i = image
h = horizontal
align= ausrichten

ivalign => aufgedröselt:
i = text
v = vertikal
align= ausrichten


Für die Ausrichtung von Text und Bilder gilt gleichermassen: Natürlich kann man horizontale und vertikale Ausrichtung auch kombinieren!

Wer also das Popcorn genau in den Mittelpunkt des RSS setzen will, ohne die Pixel für die Positionierung ausrechnen zu müssen, kann das so machen:

Code: [Auswählen]

ihalign "center"
ivalign "center"
img .5 .5 1 png url "http://up.picr.de/17991350as.png"

Dafür mache ich jetzt keinen Screenshot, das könnt Ihr mal selbst testen.

[betateilchen]

Bei mir sieht das Ergebnis unserer Arbeit aktuell übrigens so aus:

(http://up.picr.de/17991915rf.jpg)

Wenn ich mir die Sache so recht überlege, sind wir schon sehr weit in unserem Workshop, es fehlen nur noch zwei oder drei wichtige Themen. Und wenn wir diese durchgearbeitet haben, werde ich eine Auflistung machen, was ich Euch NICHT gesagt habe 

[betateilchen]

Schritt 12 - bedingtes Einbinden von Informationen

Bitte legt Euch einen Dummy namens "regenDummy" an und gebt ihm den Wert "rain"

Code: [Auswählen]

define regenDummy dummy
set regenDummy rain

Wir wollen im RSS die Meldung "Es regnet!" ausgeben, aber nur wenn der regenDummy auch den Wert "rain" hat.

Dafür gibt es grundsätzlich zwei Wege.

Lösungsweg 1:

Fügt bitte am Ende der Layoutdatei folgende Zeilen ein:

Code: [Auswählen]

# Deno für bedingtes Einbinden von Informationen
# Variante 1
rgb "2E64FE"
text 210 280  { "Es regnet!" if(ReadingsVal('regenDummy','state','') eq 'rain') }


und schaut Euch das Ergebnis an:

(http://up.picr.de/17992345kv.png)

Zum Vergleich macht Ihr dann bitte ein "set regenDummy norain" und ladet Euer Lesezeichen für das RSS-Bild (nicht das Layout!) neu.
Die Meldung sollte dann nicht mehr erscheinen.

Die zweite Variante, so etwas zu machen, erkläre ich Euch - nach der nächsten Maus.

[betateilchen]

Fortsetzung: bedingtes Einbinden von Informationen

Bitte die eben eingefügten zwei Zeilen wieder auskommentieren, wir kommen jetzt zu Variante 2:

Code: [Auswählen]

# Deno für bedingtes Einbinden von Informationen
# Variante 1
#rgb "2E64FE"
#text 210 280  { "Es regnet!" if(ReadingsVal('regenDummy','state','') eq 'rain') }

# Variante 2
condition {(ReadingsVal('regenDummy','state','') eq 'rain')}
rgb "2E64FE"
text 210 280 "Es regnet!"
condition 1

Das Verhalten sollte identisch zu Variante 1 sein.

Wo ist der Unterschied? Was sind die Vorteile?

• In der ersten Variante haben wir die Bedingung direkt in das text-Statement eingebaut. Davor wurde aber auf jeden Fall noch die Farbe umschaltet

In der zweiten Variante haben wir einen anderen Ablauf:

• Alle Befehle, die in der Layout-Definition nach der ersten condition-Zeile stehen, werden nur dann ausgeführt, wenn die in der condition angegebene Bedingung erfüllt ist.

Es wird also auch die bis dahin mit rgb gesetzte Farbe nicht verändert, wenn die Bedingung nicht erfüllt ist.

Ist die Bedingung nicht erfüllt, werden alle folgenden Zeilen übersprungen, bis entweder wieder eine condition Zeile kommt, die erfüllt wird, oder bis das Ende der Layoutdefinition erreicht ist.

Deshalb ist es wichtig, an einen Block, der nur bedingt ausgeführt werden soll, wieder eine Bedingung anzuschließen, mit der die Bedingung wieder aufgehoben wird. Im Beispiel macht das die Zeile "condition 1"

Ein konkretes Anwendungsbeispiel aus meiner Produktivumgebung kommt noch, dazu muss ich erst nochwas basteln, wir kommen nochmal auf das Thema hier zurück, keine Sorge

[betateilchen]

Schritt 14 - noch eine Methode zur Positionsangabe im RSS
oder: "Wer kennt noch Turtle Graphics"? 

Bitte ergänzt Euer Layout am Dateiende ^*):

Code: [Auswählen]

# Kapitel 14 - Readingliste anzeigen
# zuerst nochmal eine Linie zeichnen
rgb "7F7F7F"
line 400 240 400 440

# Wertebezeichnungen linksbündig ausgeben
rgb "FFFFFF"
pt 12
thalign "left"
text 410 270 "Temperatur"
text 410 300 "Luftfeuchte"
text 410 330 "Luftdruck"

# Messwerte rechtsbündig ausgeben
thalign "right"
text 550 270 {ReadingsVal('owo','c_temperature','?')}
text 550 300 {ReadingsVal('owo','c_humidity','?')}
text 550 330 {ReadingsVal('owo','c_pressure','?')}

# Einheiten linksbündig an die Messwerte anhängen
thalign "left"
text 552 270 "°C"
text 552 300 "%"
text 552 330 " hPa"

Was da passiert, sollte inzwischen jeder problemlos verstehen können, der den Workshop konzentriert mitgearbeitet hat.
Das Ergebnis sollte so aussehen:

(http://up.picr.de/17993729yt.png)

Das mit den Positionsangaben kann man aber auch noch anders machen. Wie? Das erkläre ich Euch nach der nächsten Maus.

^{*) für stgeran: das bedeutet nach der letzten aktuell vorhandenen Zeile in der Layoutdatei}

[betateilchen]

Schritt 14 - Teil 2, die Alternative

Stellt Euch vor, Euer RSS wäre so groß, dass Ihr eine Schildkröte darauf laufen lassen könnt ^*)

Ihr setzt die Schildkröte auf die Position "x=100 y=100" und sagt Ihr "gehe 100 Schritte in Richtung x" Wo befindet sie sich dann?
Richtig: an der Position x=200 y=100
Jetzt schickt Ihr die Schildkröte weiter: "gehe 50 Schritte in Richtung y". Dann befindet sie sich an der Position x=200 y=150.
Und nun schickt Ihr die Schildkröte nochmal los: "gehe 50 Schritte in Richtung x vorwärts und 30 Schritte in Richtung y rückwärts".
Dann steht die Schildkröte bei x=250 y=120.

Soweit verstanden? Gut.

Und genau das kann der RSS auch.

Wir hatten bisher absolute Positionsangaben, z.B. x=200 y=300
Dann haben wir relative Positionen kennengelernt, z.B. x=0.25 y=0.5

Jetzt kommt die dritte Variante - die Schildkröte.
Dazu gibt es für das RSS Layout die Befehle "moveto <x> <y>" und "moveby <deltaX> <deltaY>"

Nehmen wir unsere Schildkröte von oben und übersetzen ihre Bewegungen in Befehle für unser RSS Layout

setzt die Schildkröte auf die Position "x=100 y=100"

Code: [Auswählen]

moveto 100 100
gehe 100 Schritte in Richtung x

Code: [Auswählen]

moveby 100 0
gehe 50 Schritte in Richtung y

Code: [Auswählen]

moveby 0 50
gehe 50 Schritte in Richtung x vorwärts und 30 Schritte in Richtung y rückwärts

Code: [Auswählen]

moveby 50 -30
Grundregel:
Bei jeder Positionänderung innerhalb eines RSS Layouts wird die x und y Positon in zwei internen Variablen gespeichert.
Auf diese Variablen "x" und "y" kann innerhalb des Layouts zugegriffen werden, um Positionsangaben zu erzeugen.

Beispiel:

Code: [Auswählen]

text x y "blubber"
Im nächsten Beitrag geht es um eine Anwendung in unserem Layout. Ich habe jetzt erstmal Hunger, Abendessenzeit.

^{*) weiterführende Informationen zur Schildkröte}
http://de.wikipedia.org/wiki/Turtle-Grafik
http://de.wikipedia.org/wiki/KTurtle

[betateilchen]

Schritt 14 - Kapitel 3, jetzt schicken wir die Schildkröte los

Bitte baut am Ende der Layoutdatei folgende Zeilen ein:

Code: [Auswählen]

# Kapitel 14 - Teil 3
# wir schicken die Schildkröte los
# http://de.wikipedia.org/wiki/KTurtle
#

rgb "00FF00"
pt 12

# Wertebezeichnungen linksbündig ausgeben
thalign "left"

moveto 410 360
text x y "Temperatur"

moveby 0 30
text x y "Luftfeuchte"

moveby 0 30
text x y "Luftdruck"

# Messwerte rechtsbündig ausgeben
thalign "right"

moveby 140 0
text x y {ReadingsVal('owo','c_pressure','?')}

moveby 0 -30
text x y  {ReadingsVal('owo','c_humidity','?')}

moveby 0 -30
text x y {ReadingsVal('owo','c_temperature','?')}

# Einheiten linksbündig an die Messwerte anhängen
thalign "left"

moveby 2 0
text 552 y "°C"

moveby 0 30
text   x 390 "%"

moveby 0 30
text   x y " hPa"

Das Ergebnis sieht optisch genauso aus wie die ersten drei Wertezeilen, nur in grün.

(http://up.picr.de/17994399nk.png)

Wozu dann das Ganze?

Nunja, stellt Euch mal vor, Ihr wollt bei den drei Readings die Luftfeuchtigkeit nur dann anzeigen, wenn es regnet.

Dann kann man das entweder so lösen (am Beispiel der weiss angezeigten Readings)

Code: [Auswählen]

condition {(ReadingsVal('regenDummy','state','') eq 'rain')}
text 410 300 "Luftfeuchte"
condition 1

oder so - (am Beispiel des Schildkrötenprinzips)

Code: [Auswählen]

condition {(ReadingsVal('regenDummy','state','') eq 'rain')}
moveby 0 30
text x y "Luftfeuchte"
condition 1

Der grundlegende Unterschied für den Fall, dass es NICHT regnet, ist klar erkennbar:

(http://up.picr.de/17994455ji.png)

Im weissen Beispiel wird zwar die Luftfeuchtigkeit nicht angezeigt, aber es entsteht eine Lücke.

Im grünen Beispiel wird die Luftfeuchtigkeit nicht anzeigt, die Schildkröte läuft aber auch nicht weiter und der Luftdruck rutscht einfach um eine Zeile nach oben.

Klar?


Ein Anwendungsfall aus meiner Produktivumgebung, ich überwache damit meine Fenster- und Türkontakte.
Geschlossene Fenster/Türen werden nicht angezeigt, gekippte Fenster/Türen werden gelb, geöffnete Fenster/Türen in rot dargestellt.

Dieses Codebeispiel NICHT in das Workshop-Layout übernehmen!

Code: [Auswählen]

#--------------------
# Türen und Fenster
#

condition 1
thalign "left"
moveto 410 50

condition { ReadingsVal("Melder_TEingang","state","") eq "open" }
rgb "FF0000"
moveby 0 20
text 410 y { "Eingang" }
text 470 y { ts2text(ReadingsTimestamp("Melder_TEingang","state","")) }

condition { ReadingsVal("Melder_TBalkon","state","") eq "open" }
rgb "FF0000"
moveby 0 20
text 410 y { "Balkon" }
text 470 y { ts2text(ReadingsTimestamp("Melder_TBalkon","state","")) }

condition { ReadingsVal("Melder_TBalkon","state","") eq "tilted" }
rgb "FFFF00"
moveby 0 20
text 410 y { "Balkon" }
text 470 y { ts2text(ReadingsTimestamp("Melder_TBalkon","state","")) }

condition { ReadingsVal("Melder_FSl","state","") eq "open" }
rgb "FF0000"
moveby 0 20
text 410 y { "SZ li" }
text 470 y { ts2text(ReadingsTimestamp("Melder_FSl","state","")) }

condition { ReadingsVal("Melder_FSr","state","") eq "open" }
rgb "FF0000"
moveby 0 20
text 410 y { "SZ re" }
text 470 y { ts2text(ReadingsTimestamp("Melder_FSr","state","")) }

condition { ReadingsVal("Melder_FSr","state","") eq "tilted" }
rgb "FFFF00"
moveby 0 20
text 410 y { "SZ re" }
text 470 y { ts2text(ReadingsTimestamp("Melder_FSr","state","")) }

condition { ReadingsVal("Melder_FKl","state","") eq "open" }
rgb "FF0000"
moveby 0 20
text 410 y { "KU li" }
text 470 y { ts2text(ReadingsTimestamp("Melder_FKl","state","")) }

condition { ReadingsVal("Melder_FKr","state","") eq "open" }
rgb "FF0000"
moveby 0 20
text 410 y { "KU re" }
text 470 y { ts2text(ReadingsTimestamp("Melder_FKr","state","")) }

condition { ReadingsVal("Melder_FKr","state","") eq "tilted" }
rgb "FFFF00"
moveby 0 20
text 410 y { "KU re" }
text 470 y { ts2text(ReadingsTimestamp("Melder_FKr","state","")) }

condition { ReadingsVal("Melder_FAl","state","") eq "open" }
rgb "FF0000"
moveby 0 20
text 410 y { "AZ li" }
text 470 y { ts2text(ReadingsTimestamp("Melder_FAl","state","")) }

condition { ReadingsVal("Melder_FAr","state","") eq "open" }
rgb "FF0000"
moveby 0 20
text 410 y { "AZ re" }
text 470 y { ts2text(ReadingsTimestamp("Melder_FAr","state","")) }

condition { ReadingsVal("Melder_FAr","state","") eq "tilted" }
rgb "FFFF00"
moveby 0 20
text 410 y { "AZ re" }
text 470 y { ts2text(ReadingsTimestamp("Melder_FAr","state","")) }


[betateilchen]

Teil 15 - Die Textbox für lange Texte

Ein grundlegendes Objekt fehlt bisher noch - die Textbox. Die wird zum Beispiel gebraucht, wenn man längere Texte, deren Länge man aber im Voraus nicht kennt, vernünftig darstellen will. Ich nutze sowas zum Beispiel für die Anzeige von Wetterwarnungen aus dem fhem Modul GDS. Man kann damit aber zum Beispiel auch Schlagzeilen aus RSS Feeds, z.B. der Tagesschau anzeigen.

Fügt bitte am Ende Eurer Layoutdatei folgende Zeilen ein:

Code: [Auswählen]

# Teil 15 - die Textbox
rgb "FFFFFF"
pt 12

thalign "left"
textbox 50 330 300 "Verbraucher erfahren auch künftig nicht, ob Honig Pollen von genmanipulierten Pflanzen enthält."

was folgendes Ergebnis bringt:

(http://up.picr.de/17994759pp.png)

textbox 50 330 300 => aufgedröselt:

textbox = Befehl
50 = x-Position
330 = y-Position
300 = Breite der Textbox in pixeln

Die x- und y-Positon bezieht sich auf die linke obere Ecke der Textbox.


Für Optik-Fetischisten läßt sich die Anzeige innerhalb der Textbox auch noch im Blocksatz formatieren, also so:

(http://up.picr.de/17994760wl.png)

Dazu muss das thalign vor dem Beschreiben der Textbox auf

Code: [Auswählen]

thalign "justified"
gesetzt werden. Achtung: Dieses thalign ist ausschließlich innerhalb der textbox wirksam!

[betateilchen]

Das wars.

Ich habe fertig!

Weitere Dinge werde ich hier im Workshop nicht beschreiben. Weiterführende Informationen, auch über die wenigen hier nicht besprochenen Dinge, finden sich in der commandref zum Modul 02_RSS.pm.

http://fhem.de/commandref.html#RSS

Viel Spaß beim Basteln Eurer RSS Feeds.

[betateilchen]

Was fehlt noch?

Folgende Punkte wurden im Workshop nicht besprochen, aber das sollte jeder selbst hinbekommen.

• neben date und time gibt es auch noch das spezielle Textobjekt "seconds" zur Anzeige von Sekunden
• neben thalign und ihalign gibt es auch noch den "Sammelwert" halign, der sowohl für text als auch für img gleichzeitig gilt Von der Verwendung rate ich aber dringend ab, da text und img nicht grundsätzlich die gleichen Parameterwerte für die Ausrichtung verwenden und das sehr schnell zu sehr merkwürdigen Effekten führen kann. (gleiches gilt natürlich auch für die vertikalen Ausrichtungen)
• mit linespace <px> läßt sich ein Abstand des Textes von der imaginären Textboxwand innerhalb der textbox einstellen

Folgende Dinge können innerhalb eines RSS über { perl-Special } berechnet bzw. ermittelt werden:

• rgb
• .halign und .valign
• text
• img (bei Verwendung des sourcetyp = data)

Sonstiges:

• Plots können auch mit zoom und offset angegeben werden: img x y 1 png data { plotAsPng("SVG_owo","qday",-1) }
• es gibt einen internen Zähler $defs{$name}{fhem}{counter} der bei jeder RSS Generierung um 1 erhöht wird. Damit kann man z.B. bei jedem Durchlauf die Hintergrundfarbe wechseln lassen oder bei jedem 7. Durchlauf eine Sondermeldung anzeigen. Verwenden kann man den Zähler z.B. in einer "condition" Anweisung
• mit dem Attribut bgdir kann ein Verzeichnis mit Bildern definiert werden, die abwechselnd als Hintergrundbild (anstatt des farbigen Hintergrundes) verwendet werden
• mit dem Attribut tmin kann festgelegt werden, wieviele Minuten ein Hintergrundbild mindestens angezeigt wird, bevor es gewechselt wird. Der Wechsel ist dann unabhängig von der Anzahl der RSS-Abrufe innerhalb dieser Zeitspanne
• to be continued... (falls mir noch was einfällt)

[Dr. Boris Neubert]

Seit neuestem bindet die von RSS ausgelieferte Webseite auch die Javascripte ein.

Wer also beispielsweise die App WebViewControl (http://www.fhemwiki.de/wiki/WebViewControl) auf seinem Tablet benutzt, kann nun in der App zu

Code: [Auswählen]

http://myFHEM:8083/fhem/rss/myRSS.html
navigieren und kommt in den Genuss der vollen Funktionalität von RSS und WebViewcontrol.

Das sieht dann so aus wie in der Anlage. Der Knopf links oben ist im RSS-Layout als Grafik eingebunden und mit einer Image-Map hinterlegt, die zur FHEM-Startseite führt.

Viele Grüße
Boris

Grüße
Boris