FHEMWiki - Benutzerbeiträge [de]

Dewpoint

2018-05-21T16:31:41Z

Nielsiwilsi: /* Attribute */

{{SEITENTITEL:dewpoint}}
{{Infobox Modul
|ModPurpose=Berechnung des Taupunkts
|ModType=h

|ModCmdRef=dewpoint
|ModTechName=98_dewpoint.pm
|ModOwner=Willi Herzig}}

Das Modul [[dewpoint]] bietet Funktionen im Zusammenhang mit der Taupunktberechnung an. Die verfügbaren Funktionen, über einen Parameter bei der Definition gesteuert, sind
* dewpoint (Taupunkt)
* fan (erzeugt ein Event, das zur Lüftersteuerung verwendet werden kann)
* alarm (erzeugt einen "Schimmel-Alarm", wenn eine Referenztemperatur unter den Taupunkt fällt)
{{todo|Seite muss noch vervollständigt werden --[[Benutzer:Ph1959de|Peter]] ([[Benutzer Diskussion:Ph1959de|Diskussion]]) 13:49, 14. Mär. 2016 (CET)}}
== Voraussetzungen ==
Es muss ein Device geben, das die zur Berechnung erforderlichen Basisdaten ''Temperatur'' und ''Feuchte'' liefert. Die Namen der entsprechenden Readings können bei der Definition des ''dewpoint'' Device angegeben werden.

== Anwendung ==
=== Define ===
Ein ''dewpoint'' Device (siehe auch {{Link2CmdRef|Anker=dewpoint}}) wird definiert mit:
:<code>define <name> dewpoint <type> ...</code>
Mögliche Werte und Bedeutung von
;type
*dewpoint - aus ''temp_name'' und ''hum_name'' wird der Taupunkt berechnet und als Reading mit dem Namen ''new_name'' an die durch ''devicename-regex'' spezifizierten Devices hinzugefügt
*fan -
*alarm -

Die vollständige Syntax für den Typ ''dewpoint'':
:<code>define <name> dewpoint '''dewpoint''' <devicename-regex> [<temp_name> <hum_name> <new_name>]</code>
wobei die Platzhalter folgende Bedeutung haben:
;name
:der Name des definierten ''dewpoint'' Device
;devicename-regex
:Spezifikation des Geräts / der Geräte, von denen ''temp_name'' und ''hum_name'' gelesen und ''new_name'' geschrieben werden soll
;temp_name
:Name des Readings, das den Temperaturwert enthält; wenn dieser Parameter nicht angegeben ist, wird ''temperature'' angenommen
;hum_name
:Name des Readings, das den Feuchtewert enthält; wenn dieser Parameter nicht angegeben ist, wird ''humidity'' angenommen
;new_name
:Name des Readings, das den berechneten Taupunkt aufnehmen soll; wenn dieser Parameter nicht angegeben ist, wird ''dewpoint'' angenommen

==== Statuszeile ====
Will man den Taupunkt nicht als einzelnes Reading ''dewpoint'', sondern in Kurzform zusammen mit den anderen Werten in der Statuszeile anzeigen lassen, so muss man für ''temp_name'' und ''hum_name'' die Spezialwerte ''T'' und ''H'' angeben:
:<code>define dew_state dewpoint dewpoint .* T H D</code>
Dies bewirkt, dass bei allen abgefragten Geräten die Werte ''T'' und ''H'' aus der Statuszeile ausgelesen werden und selbige dann wie folgt um den Taupunkt mit dem Buchstaben ''D'' erweitert wird:
<pre>T: 18.2 H: 55 D: 9.0</pre>

=== Attribute ===
;absFeuchte
:Beim Setzen dieses Attributs wird zusätzlich die absolute Luftfeuchtigkeit (in Gramm Wasser pro Kubikmeter Luft) berechnet und als Reading mit dem Namen ''absFeuchte'' ausgegeben. Hat man das Dewpoint-Device vorher so definiert, dass es den Taupunkt an den Status anhängt:

:<code>define dew_state dewpoint dewpoint .* T H D</code>
:<code>attr dew_state absFeuchte 1</code>

:dann braucht man nichts weiter zu tun, die absolute Feuchtigkeit wird ab sofort unter dem Buchstaben ''A'' an den Status angehängt:

:<pre>T: 18.2 H: 55 D: 9.0 A: 8.5</pre>

:Für den Taupunkt konnte man mit dem Parameter ''new_name'' einen eigenen Namen für das erzeugten Reading festlegen. Für die absolute Luftfeuchte ist dieser Parameter nicht vorhanden, das Reading hat immer den Standardnamen ''absFeuchte'' bzw. ''A'' in der Statuszeile.

== Anwendungsbeispiele ==

== Alternativen zu diesem Modul ==

=== Berechnung direkt im userReading ===

Um den Taupunkt einfach berechnen zu können, kann neben dem Modul ''dewpoint'' auch das Folgende userReading gesetzt werden (der Code dazu wurde direkt aus dem Modul entnommen und ist so über das Webinterface einzugeben).

Das Userreading hat den Vorteil, nicht mit anderen Modulen in Konflikt zu geraten.
<syntaxhighlight lang="perl">attr <Device> userReadings dew:temperature.* {
my $dp;
my $temperature = ReadingsVal($name,"temperature",0);
my $humidity = ReadingsVal($name,"humidity",0);
my $A = 17.2694;
my $B = ($temperature > 0) ? 237.3 : 265.5;
my $es = 610.78 * exp( $A * $temperature / ($temperature + $B) );
my $e = $humidity/ 100 * $es;
if ($e == 0) { Log 1, "Error: dewpoint() e==0: temp=$temperature, hum=$humidity";
return 0;
}
my $e1 = $e / 610.78;
my $f = log( $e1 ) / $A;
my $f1 = 1 - $f;
if ($f1 == 0) {
Log 1, "Error: dewpoint() (1-f)==0: temp=$temperature, hum=$humidity";
return 0;
}
$dp = $B * $f / $f1 ;
sprintf "%.2f", $dp;
}</syntaxhighlight>
(Das obige Beispiel wurde nach Umstellung auf "Source"-Formatierung noch nicht getestet. --[[Benutzer:Ph1959de|Peter]] ([[Benutzer Diskussion:Ph1959de|Diskussion]]) 13:49, 14. Mär. 2016 (CET))

=== Variante über 99_myUtils ===

Noch besser ist es, die im vorigen Abschnitt durchgeführte Berechnung nicht für jedes Device per userReading wieder neu einzugeben, sondern diese einmalig als Funktion in der 99_myUtils zu hinterlegen und diese dann im jeweiligen Device im userReading nur noch aufzurufen.

Dazu ist in der 99_myUtils folgende sub anzulegen:

<syntaxhighlight lang="perl">
sub urDewpoint
{
my ($dname,$tname,$hname) = @_;

#Prüfen, ob überhaupt ein Device(-name) als Parameter übergeben wurde
if(!defined($dname)) {
Log3 undef,1,"Error: urDewpoint - No device specified!";
return 0;
}

#Prüfen, ob das angegebene Device überhaupt existiert
if(!$defs{$dname}) {
Log3 undef,1,"Error: urDewpoint - Device $dname is not defined!";
return 0;
}

#Wenn keine Readingsnamen für die Temperatur oder Luftfeuchtigkeit
#übergebenwurde wird per default temperature oder humidity verwendet
$tname='temperature' if(!defined($tname));
$hname='humidity' if(!defined($hname));

my $dp;

#Auslesen der Readingswerte für Temperatur und Luftfeuchtigkeit aus den
#entsprechenden Readings des Devic
my $temperature = ReadingsVal($dname,$tname,0);
my $humidity = ReadingsVal($dname,$hname,0);

#Magische Berechnung :)
my $A = 17.2694;
my $B = ($temperature > 0) ? 237.3 : 265.5;
my $es = 610.78 * exp( $A * $temperature / ($temperature + $B) );
my $e = $humidity/ 100 * $es;
if ($e == 0) {
Log3 undef,1, "Error: urDewpoint: $dname - e==0: temp=$temperature, hum=$humidity";
return 'ERR';
}
my $e1 = $e / 610.78;
my $f = log( $e1 ) / $A;
my $f1 = 1 - $f;
if ($f1 == 0) {
Log3 undef,1, "Error: urDewpoint: $dname - (1-f)==0: temp=$temperature, hum=$humidity";
return 'ERR';
}
$dp = $B * $f / $f1 ;

#Rückgabe der Taupunkt-Temperatur
return sprintf "%.2f", $dp;
}
</syntaxhighlight>

Anschließend kann dann im jeweiligen Device ganz einfach ein userReading definiert werden:

<syntaxhighlight lang="perl">attr <Device> userReadings dew:temperature.* {urDewpoint($name)}</syntaxhighlight>

Die Readings-Namen für Temperatur und Luftfeuchtigkeit bei Device können bei bedarf auch abweichend angegeben werden. Bei den Homematic-Wandthermostaten heßt das Reading für die tatsächlich gemessene Temperatur measured-temp und nicht temperature, dann würde die definition des userReading wie folgt aussehen:

<syntaxhighlight lang="perl">attr <Device> userReadings dew:measured-temp.* {urDewpoint($name,'measured-temp')}</syntaxhighlight>

== Links ==
* Forendiskussion um {{Link2Forum|Topic=8576|LinkText=Lüften oder nicht}}
* Forendiskussion um {{Link2Forum|Topic=23080|LinkText=Temperaturdifferenz}}

[[Kategorie:HOWTOS]]

E-Mail senden

2016-05-06T22:09:01Z

Nielsiwilsi: /* Raspberry Pi */

Um aus FHEM heraus '''E-Mail senden''' zu können, sind abhängig von der verwendeten Platform unterschiedliche Vorgehensweisen erforderlich.

{{Randnotiz|RNTyp=y|RNText=Anleitung zur Einrichtung von Exim4 auf Debian mit GMX als Smarthost:[http://www.fhemwiki.de/w/images/f/f6/Anleitung_Exim4_Debian_GMX.pdf PDF]}}

== Linux ==
=== FritzBox 7170 (non-chroot) oder "reine" Linuxe ===
Datei 99_email.pm im Modul-Verzeichnis mit folgender Funktion anlegen (oder in bestehende 99_irgendwas.pm kopieren):

<nowiki>sub fb_mail {
my $rcpt = $_[0];
my $subject = $_[1];
my $text = $_[2];
system("/bin/echo \"$text\" | /usr/bin/mail send -i - -s \"$subject\" -t \"$rcpt\"");
}</nowiki>
Aufruf dann mittels
:<code>{ fb_mail('empfaenger@mail.de','Subject','text 123') }</code>
Darauf achten, dass der fhem-User Mails senden darf (in richtige Gruppe eintragen. Ggf. vorher einmal su fhem und probieren).

=== Fritz!Box 7390 ===
Auf der [[AVM Fritz!Box|FritzBox 7390]] ist diese Funktion seit 10/2012 Bestandteil der Fhem Standardauslieferung. Sie ist untergebracht in FritzBoxUtils.pm und heisst dort FB_mail($$$) (Groß-Kleinschreibung beachten).

Da der Dateiname von FritzBoxUtils.pm nicht mit 99_ beginnt, wird diese Programmdatei nicht automatisch beim Start von Fhem geladen. Fhem muss zum Laden dieser Programmdatei aufgefordert werden. Dazu (z. B. in 99_myUtils.pm) die Zeile ''use FritzBoxUtils;'' einfügen.

Mit dem Install von AVM.de wird fhem in einer chroot-Umgebung ausgeführt, die den Zugriff auf die Mailfunktion der Fritzbox nicht zulässt. Daher muss Fhem in der [http://fhem.de/fhem.html#Download Version von fhem.de] installiert sein. Sollte Ihre Fritzbox bisher mit dem install von AVM laufen, kann (nach einem backup!) das image von fhem.de einfach drüberinstalliert werden. Es sollten dabei alle Einstellungen erhalten bleiben.

<nowiki>sub fb_mail {
my $rcpt = $_[0];
my $subject = $_[1];
my $text = $_[2];
system("/bin/echo \"$text\" > /var/tmp/fhem_nachricht.txt");
system("/sbin/mailer send -i '/var/tmp/fhem_nachricht.txt' -s \"$subject\" -t \"$rcpt\"");
system("rm /var/tmp/fhem_nachricht.txt");
}</nowiki>

Aufruf dann mittels
:<code>{ fb_mail('empfaenger@mail.de','Subject','text 123') }</code>
bzw.
:<code>{ FB_mail('empfaenger@mail.de','Subject','text 123') }</code>

Dem Mailer können noch weitere Parameter hinzugefügt werden. Mehr dazu siehe: [http://www.wehavemorefun.de/fritzbox/Mailer Mailer]

=== OpenWRT ===
Die Anleitung wurde mit einer frühen Beta von Barrier Breaker (r391xx) mit einem TP_Lind WDR 4900 getestet. Da "sendEmail" nicht als Package vorliegt wird in dieser Anleitung "ssmtp" verwendet.
Die Installation erfolgt mittels:

<pre>
opkg update
opkg install ssmtp_2.64-4_mpc85xx.ipk
</pre>

Hierbei werden die Packete libopenssl und zlib mit installiert. Damit ssmtp funktioniert müssen die Dateien /etc/ssmtp/ssmtp.conf und /etc/ssmtp/revaliases angepasst werden.

/etc/ssmtp/ssmtp.conf
<nowiki>root=arnold@gmx.net
mailhub=mail.gmx.net:465
rewriteDomain=gmx.net
hostname=gmx.net
FromLineOverride=YES
UseTLS=YES
#UseSTARTTLS=YES
AuthUser=arnold@gmx.net
AuthPass=Passwort_von_arnold@gmx.net
</nowiki>

/etc/ssmtp/revaliases
<nowiki>
root:arnold@gmx.net:mail.gmx.net:465</nowiki>

In der [[99_myUtils_anlegen|99_myUtils]] folgende Unterroutine einfügen (von der RPi-Anleitung übernommen):

<nowiki>sub
OpenWRTMail
{
my $rcpt = shift;
my $subject = shift;
my $text = shift;
my $ret = "";
my $sender = "dockstar\@heye-tammo.de";
Log 1, "sendEmail RCP: $rcpt, Subject: $subject, Text: $text";
$ret .= qx(echo -e 'to:$rcpt\n from:$sender\nsubject:$subject\n$text\n' | ssmtp $rcpt);
$ret =~ s,[\r\n]*,,g; # remove CR from return-string
Log 1, "sendEmail returned: $ret";
}</nowiki>

Ab hier den entsprechenden Abschnitt unter "Raspberry Pi" lesen.

=== Synology DiskStation ===
Beim DSM 3.2 gab es keinen <code>sendmail</code>-Befehl, sondern nur eine Funktion für den Versand der System-Benachrichtigungen. Interessanterweise funktionierte aber der <code>php-mail</code>-Befehl, so dass man mittels folgendem Modul Mails frei versenden kann:

<nowiki>sub sendmail($$$) {
my($empf, $subj, $nachricht) = @_;
system("php -r 'mail(\"$empf\",\"$subj\",\"$nachricht\");'");
undef;
}</nowiki>

=== Raspberry Pi ===
In der weezy-Version, wie sie von busware zur Verfügung gestellt wird, muss auf einem [[Raspberry Pi]] noch sendEmail nachinstalliert werden. Diese Anleitung funktioniert auch unter '''Ubuntu'''.

<pre>
sudo apt-get update
sudo apt-get install sendEmail libio-socket-ssl-perl libnet-ssleay-perl perl
</pre>

in der [[99_myUtils_anlegen|99_myUtils]] folgende Unterroutine einfügen:

<nowiki>######## DebianMail Mail auf dem RPi versenden ############
sub
DebianMail
{
my $rcpt = shift;
my $subject = shift;
my $text = shift;
my $attach = shift;
my $ret = "";
my $sender = "absender\@account.de";
my $konto = "kontoname\@account.de";
my $passwrd = "passwrd";
my $provider = "smtp.provider.de:587";
Log 1, "sendEmail RCP: $rcpt";
Log 1, "sendEmail Subject: $subject";
Log 1, "sendEmail Text: $text";
Log 1, "sendEmail Anhang: $attach";;

$ret .= qx(sendEmail -f '$sender' -t '$rcpt' -u '$subject' -m '$text' -a '$attach' -s '$provider' -xu '$konto' -xp '$passwrd' -o tls=auto -o message-charset=utf-8);
$ret =~ s,[\r\n]*,,g; # remove CR from return-string
Log 1, "sendEmail returned: $ret";
}</nowiki>

Um die TLS Verschlüsselung (ehem. SSL) nicht zu nutzen, muss in der 4. letzten Zeile tls=no verwendet und der Port des Mailproviders auf 25 eigetragen werden. Sollte anschließend keine Mail verschickt werden, siehe Probleme.

Falls der Body-Text in einem (Android-)Mailer auf dem Handy nicht gezeigt wird, kann der Parameter '''-o message-content-type=html''' helfen.

Die Funktion kann beispielsweise folgendermaßen aufgerufen werden:

<nowiki>define Sonstiges notify Fenster:Window:.*,.*Low.Batt*. {\
DebianMail('email@email.domain','Subject','Text','Anhang');;\
}</nowiki>

oder

<nowiki>define Sonstiges at *01:00:00 {\
DebianMail('email@email.domain','Subject','Text','Anhang');;\
}</nowiki>

=== BeagleBoard-xM ===
Auf einem [[:Kategorie:BeagleBoard-xM|BeagleBoard-xM]] mit einem [http://en.opensuse.org/HCL:BeagleBoard-xM OpenSUSE 12.2] kann man ebenfalls das Perl-Programm ''sendEmail'' wie beim RPi nutzen. Dies gibt es aber nicht in den Repositories von openSUSE, sondern man muss sich ''sendEmail'' als Source herunterladen. Das geht am einfachsten per ''wget'', welches man ebenfalls erst installieren muss (aber aus einem Repository).

<nowiki>$ zypper in wget
$ cd /opt
$ wget http://caspian.dotconf.net/menu/Software/SendEmail/sendEmail-v1.56.tar.gz
$ tar xvfz sendEmail-v1.56.tar.gz
$ cd sendEmail-v1.56
$ cp sendMail /usr/local/bin</nowiki>
Dann geht man weiter vor wie unter RPi beschrieben (anlegen der SUB-Routine in 99_myUtils usw.).

'''Hinweis:''' Die Version 1.56 von ''sendEmail'' ist Stand Januar 2013 die aktuelle. Da diese Programmversion von 2009 stammt, ist mit neuen Versionen selten zu rechnen. Vielleicht schauen Sie trotzdem vorher auf der [http://caspian.dotconf.net/menu/Software/SendEmail/ Homepage von sendEmail] nach.

== Windows ==
# Kopiere die Datei sendEmail.exe* in Dein FHEM Verzeichnis (hier c:\fhem-5.0\); Quelle: [http://caspian.dotconf.net/menu/Software/SendEmail/ http://caspian.dotconf.net/menu/Software/SendEmail/]
# Erstelle im FHEM Verzeichnis die Datei wmail.bat mit folgendem Inhalt (eine Zeile): <code>sendEmail -f absender@domain.de -u "%1" -m " " -s SMTP-SERVERAdresse -xu SMTP_USERNAME -xp SMTP_PASSWORT -t empfänger@domain.de -o message-header="X-Message-Flag: FHEM"</code>
# Beispiel fhem.cfg
## Mail wenn sich der Status von Heizung.* oder Hzg.* ändert <code>define Mail_Heizung notify Heizung.*|Hzg.* { system("wmail $NAME:$EVENT")}</code>
## Mail bei Signal Aussentemperatur (für dieses Beispiel wird [http://fhem.de/commandref.html#getstate http://fhem.de/commandref.html#getstate getstate] benötigt) <code>define Mail_Aussentemperatur notify Aussentemperatur {\</code> <code>my ($val);;\</code> <code>$val = fhem "getstate $NAME";;\</code> <code>system("wmail \"$NAME: $val\"");;\</code> <code>}</code>

== Probleme ==
=== sendEmail ===
Falls man keine E-Mails verschicken kann, kann man in einem ersten Test prüfen, ob sendEmail als solches funktioniert und die Konfiguration (Benutzer, Passwort, Server-Name usw.) des Mail-Kontos, über das die Mails abgesetzt werden sollen, richtig ist.

Hierzu setzt man in der FHEM-Befehlszeile die folgende Anweisung ab:
:<code>{ SUB-Routinen-Name('EMailAdresse@Mail.Domain','Test','Test-Text');; }</code>
und ersetzt ''SUB-Routinen-Name'' durch den Namen der in 99_myUtils erzeugten Prozedur. Statt ''EMailAdresse@Mail.Domain'' trägt man noch eine gültige E-Mail-Adresse ein und bestätigt den Befehl dann mittels <Enter> (nicht "save"). Empfangen Sie nicht kurzfristig eine entsprechende E-Mail, ist sehr wahrscheinlich an den Zugangsdaten etwas verkehrt.

Vor dem testen der Routine oben kann sendEmail auch über die Konsole (z. B. via Putty) getestet werden:
:<code>sendEmail -f 'fhemsystem@meinedomain.tld' -t 'ich@meinedomain.tld' -u 'subject' -m 'body' -s 'meinmailserver.meinedomain.de' -xu 'fhemmailer' -xp 'geheimespassword' -o tls=no</code>

=== Keine Mail mit TLS Verschlüsselung ===
Den Test über die Konsole durchführen. Erhält man folgende Fehlermeldung:
''invalid SSL_version specified at /usr/share/perl5/IO/Socket/SSL.pm line 332''
muss auf dem Raspberry folgende Datei angepasst werden: ''/usr/bin/sendEmail''.
In Zeile 1907 muss
if (! IO::Socket::SSL->start_SSL($SERVER, SSL_version => 'SSLv3 TLSv1')) {

in folgendes geändert werden
if (! IO::Socket::SSL->start_SSL($SERVER, SSL_version => 'SSLv23:!SSLv2')) {

Der frühere Tipp direkt in der SSL.pm Datei zu editieren führt zu Problemen wenn man auf FHEM per HTTPS zugreifen will und ist daher nicht zu empfehlen.

== Email laut Log gesendet aber nicht angekommen? ==
Dann bitte in der Fritzbox Oberfläche überpüfen, ob unter "System" -> "Push Service" selbiger eingerichtet und aktiviert wurde.

[[Kategorie:HOWTOS]]
[[Kategorie:FritzBox]]
[[Kategorie:BeagleBoard-xM]]
[[Kategorie:Raspberry Pi]]

E-Mail senden

2016-05-06T22:07:29Z

Nielsiwilsi: /* Raspberry Pi */

Um aus FHEM heraus '''E-Mail senden''' zu können, sind abhängig von der verwendeten Platform unterschiedliche Vorgehensweisen erforderlich.

{{Randnotiz|RNTyp=y|RNText=Anleitung zur Einrichtung von Exim4 auf Debian mit GMX als Smarthost:[http://www.fhemwiki.de/w/images/f/f6/Anleitung_Exim4_Debian_GMX.pdf PDF]}}

== Linux ==
=== FritzBox 7170 (non-chroot) oder "reine" Linuxe ===
Datei 99_email.pm im Modul-Verzeichnis mit folgender Funktion anlegen (oder in bestehende 99_irgendwas.pm kopieren):

<nowiki>sub fb_mail {
my $rcpt = $_[0];
my $subject = $_[1];
my $text = $_[2];
system("/bin/echo \"$text\" | /usr/bin/mail send -i - -s \"$subject\" -t \"$rcpt\"");
}</nowiki>
Aufruf dann mittels
:<code>{ fb_mail('empfaenger@mail.de','Subject','text 123') }</code>
Darauf achten, dass der fhem-User Mails senden darf (in richtige Gruppe eintragen. Ggf. vorher einmal su fhem und probieren).

=== Fritz!Box 7390 ===
Auf der [[AVM Fritz!Box|FritzBox 7390]] ist diese Funktion seit 10/2012 Bestandteil der Fhem Standardauslieferung. Sie ist untergebracht in FritzBoxUtils.pm und heisst dort FB_mail($$$) (Groß-Kleinschreibung beachten).

Da der Dateiname von FritzBoxUtils.pm nicht mit 99_ beginnt, wird diese Programmdatei nicht automatisch beim Start von Fhem geladen. Fhem muss zum Laden dieser Programmdatei aufgefordert werden. Dazu (z. B. in 99_myUtils.pm) die Zeile ''use FritzBoxUtils;'' einfügen.

Mit dem Install von AVM.de wird fhem in einer chroot-Umgebung ausgeführt, die den Zugriff auf die Mailfunktion der Fritzbox nicht zulässt. Daher muss Fhem in der [http://fhem.de/fhem.html#Download Version von fhem.de] installiert sein. Sollte Ihre Fritzbox bisher mit dem install von AVM laufen, kann (nach einem backup!) das image von fhem.de einfach drüberinstalliert werden. Es sollten dabei alle Einstellungen erhalten bleiben.

<nowiki>sub fb_mail {
my $rcpt = $_[0];
my $subject = $_[1];
my $text = $_[2];
system("/bin/echo \"$text\" > /var/tmp/fhem_nachricht.txt");
system("/sbin/mailer send -i '/var/tmp/fhem_nachricht.txt' -s \"$subject\" -t \"$rcpt\"");
system("rm /var/tmp/fhem_nachricht.txt");
}</nowiki>

Aufruf dann mittels
:<code>{ fb_mail('empfaenger@mail.de','Subject','text 123') }</code>
bzw.
:<code>{ FB_mail('empfaenger@mail.de','Subject','text 123') }</code>

Dem Mailer können noch weitere Parameter hinzugefügt werden. Mehr dazu siehe: [http://www.wehavemorefun.de/fritzbox/Mailer Mailer]

=== OpenWRT ===
Die Anleitung wurde mit einer frühen Beta von Barrier Breaker (r391xx) mit einem TP_Lind WDR 4900 getestet. Da "sendEmail" nicht als Package vorliegt wird in dieser Anleitung "ssmtp" verwendet.
Die Installation erfolgt mittels:

<pre>
opkg update
opkg install ssmtp_2.64-4_mpc85xx.ipk
</pre>

Hierbei werden die Packete libopenssl und zlib mit installiert. Damit ssmtp funktioniert müssen die Dateien /etc/ssmtp/ssmtp.conf und /etc/ssmtp/revaliases angepasst werden.

/etc/ssmtp/ssmtp.conf
<nowiki>root=arnold@gmx.net
mailhub=mail.gmx.net:465
rewriteDomain=gmx.net
hostname=gmx.net
FromLineOverride=YES
UseTLS=YES
#UseSTARTTLS=YES
AuthUser=arnold@gmx.net
AuthPass=Passwort_von_arnold@gmx.net
</nowiki>

/etc/ssmtp/revaliases
<nowiki>
root:arnold@gmx.net:mail.gmx.net:465</nowiki>

In der [[99_myUtils_anlegen|99_myUtils]] folgende Unterroutine einfügen (von der RPi-Anleitung übernommen):

<nowiki>sub
OpenWRTMail
{
my $rcpt = shift;
my $subject = shift;
my $text = shift;
my $ret = "";
my $sender = "dockstar\@heye-tammo.de";
Log 1, "sendEmail RCP: $rcpt, Subject: $subject, Text: $text";
$ret .= qx(echo -e 'to:$rcpt\n from:$sender\nsubject:$subject\n$text\n' | ssmtp $rcpt);
$ret =~ s,[\r\n]*,,g; # remove CR from return-string
Log 1, "sendEmail returned: $ret";
}</nowiki>

Ab hier den entsprechenden Abschnitt unter "Raspberry Pi" lesen.

=== Synology DiskStation ===
Beim DSM 3.2 gab es keinen <code>sendmail</code>-Befehl, sondern nur eine Funktion für den Versand der System-Benachrichtigungen. Interessanterweise funktionierte aber der <code>php-mail</code>-Befehl, so dass man mittels folgendem Modul Mails frei versenden kann:

<nowiki>sub sendmail($$$) {
my($empf, $subj, $nachricht) = @_;
system("php -r 'mail(\"$empf\",\"$subj\",\"$nachricht\");'");
undef;
}</nowiki>

=== Raspberry Pi ===
In der weezy-Version, wie sie von busware zur Verfügung gestellt wird, muss auf einem [[Raspberry Pi]] noch sendEmail nachinstalliert werden:

<pre>
sudo apt-get update
sudo apt-get install sendEmail libio-socket-ssl-perl libnet-ssleay-perl perl
</pre>

in der [[99_myUtils_anlegen|99_myUtils]] folgende Unterroutine einfügen:

<nowiki>######## DebianMail Mail auf dem RPi versenden ############
sub
DebianMail
{
my $rcpt = shift;
my $subject = shift;
my $text = shift;
my $attach = shift;
my $ret = "";
my $sender = "absender\@account.de";
my $konto = "kontoname\@account.de";
my $passwrd = "passwrd";
my $provider = "smtp.provider.de:587";
Log 1, "sendEmail RCP: $rcpt";
Log 1, "sendEmail Subject: $subject";
Log 1, "sendEmail Text: $text";
Log 1, "sendEmail Anhang: $attach";;

$ret .= qx(sendEmail -f '$sender' -t '$rcpt' -u '$subject' -m '$text' -a '$attach' -s '$provider' -xu '$konto' -xp '$passwrd' -o tls=auto -o message-charset=utf-8);
$ret =~ s,[\r\n]*,,g; # remove CR from return-string
Log 1, "sendEmail returned: $ret";
}</nowiki>

Um die TLS Verschlüsselung (ehem. SSL) nicht zu nutzen, muss in der 4. letzten Zeile tls=no verwendet und der Port des Mailproviders auf 25 eigetragen werden. Sollte anschließend keine Mail verschickt werden, siehe Probleme.

Falls der Body-Text in einem (Android-)Mailer auf dem Handy nicht gezeigt wird, kann der Parameter '''-o message-content-type=html''' helfen.

Die Funktion kann beispielsweise folgendermaßen aufgerufen werden:

<nowiki>define Sonstiges notify Fenster:Window:.*,.*Low.Batt*. {\
DebianMail('email@email.domain','Subject','Text','Anhang');;\
}</nowiki>

oder

<nowiki>define Sonstiges at *01:00:00 {\
DebianMail('email@email.domain','Subject','Text','Anhang');;\
}</nowiki>

=== BeagleBoard-xM ===
Auf einem [[:Kategorie:BeagleBoard-xM|BeagleBoard-xM]] mit einem [http://en.opensuse.org/HCL:BeagleBoard-xM OpenSUSE 12.2] kann man ebenfalls das Perl-Programm ''sendEmail'' wie beim RPi nutzen. Dies gibt es aber nicht in den Repositories von openSUSE, sondern man muss sich ''sendEmail'' als Source herunterladen. Das geht am einfachsten per ''wget'', welches man ebenfalls erst installieren muss (aber aus einem Repository).

<nowiki>$ zypper in wget
$ cd /opt
$ wget http://caspian.dotconf.net/menu/Software/SendEmail/sendEmail-v1.56.tar.gz
$ tar xvfz sendEmail-v1.56.tar.gz
$ cd sendEmail-v1.56
$ cp sendMail /usr/local/bin</nowiki>
Dann geht man weiter vor wie unter RPi beschrieben (anlegen der SUB-Routine in 99_myUtils usw.).

'''Hinweis:''' Die Version 1.56 von ''sendEmail'' ist Stand Januar 2013 die aktuelle. Da diese Programmversion von 2009 stammt, ist mit neuen Versionen selten zu rechnen. Vielleicht schauen Sie trotzdem vorher auf der [http://caspian.dotconf.net/menu/Software/SendEmail/ Homepage von sendEmail] nach.

== Windows ==
# Kopiere die Datei sendEmail.exe* in Dein FHEM Verzeichnis (hier c:\fhem-5.0\); Quelle: [http://caspian.dotconf.net/menu/Software/SendEmail/ http://caspian.dotconf.net/menu/Software/SendEmail/]
# Erstelle im FHEM Verzeichnis die Datei wmail.bat mit folgendem Inhalt (eine Zeile): <code>sendEmail -f absender@domain.de -u "%1" -m " " -s SMTP-SERVERAdresse -xu SMTP_USERNAME -xp SMTP_PASSWORT -t empfänger@domain.de -o message-header="X-Message-Flag: FHEM"</code>
# Beispiel fhem.cfg
## Mail wenn sich der Status von Heizung.* oder Hzg.* ändert <code>define Mail_Heizung notify Heizung.*|Hzg.* { system("wmail $NAME:$EVENT")}</code>
## Mail bei Signal Aussentemperatur (für dieses Beispiel wird [http://fhem.de/commandref.html#getstate http://fhem.de/commandref.html#getstate getstate] benötigt) <code>define Mail_Aussentemperatur notify Aussentemperatur {\</code> <code>my ($val);;\</code> <code>$val = fhem "getstate $NAME";;\</code> <code>system("wmail \"$NAME: $val\"");;\</code> <code>}</code>

== Probleme ==
=== sendEmail ===
Falls man keine E-Mails verschicken kann, kann man in einem ersten Test prüfen, ob sendEmail als solches funktioniert und die Konfiguration (Benutzer, Passwort, Server-Name usw.) des Mail-Kontos, über das die Mails abgesetzt werden sollen, richtig ist.

Hierzu setzt man in der FHEM-Befehlszeile die folgende Anweisung ab:
:<code>{ SUB-Routinen-Name('EMailAdresse@Mail.Domain','Test','Test-Text');; }</code>
und ersetzt ''SUB-Routinen-Name'' durch den Namen der in 99_myUtils erzeugten Prozedur. Statt ''EMailAdresse@Mail.Domain'' trägt man noch eine gültige E-Mail-Adresse ein und bestätigt den Befehl dann mittels <Enter> (nicht "save"). Empfangen Sie nicht kurzfristig eine entsprechende E-Mail, ist sehr wahrscheinlich an den Zugangsdaten etwas verkehrt.

Vor dem testen der Routine oben kann sendEmail auch über die Konsole (z. B. via Putty) getestet werden:
:<code>sendEmail -f 'fhemsystem@meinedomain.tld' -t 'ich@meinedomain.tld' -u 'subject' -m 'body' -s 'meinmailserver.meinedomain.de' -xu 'fhemmailer' -xp 'geheimespassword' -o tls=no</code>

=== Keine Mail mit TLS Verschlüsselung ===
Den Test über die Konsole durchführen. Erhält man folgende Fehlermeldung:
''invalid SSL_version specified at /usr/share/perl5/IO/Socket/SSL.pm line 332''
muss auf dem Raspberry folgende Datei angepasst werden: ''/usr/bin/sendEmail''.
In Zeile 1907 muss
if (! IO::Socket::SSL->start_SSL($SERVER, SSL_version => 'SSLv3 TLSv1')) {

in folgendes geändert werden
if (! IO::Socket::SSL->start_SSL($SERVER, SSL_version => 'SSLv23:!SSLv2')) {

Der frühere Tipp direkt in der SSL.pm Datei zu editieren führt zu Problemen wenn man auf FHEM per HTTPS zugreifen will und ist daher nicht zu empfehlen.

== Email laut Log gesendet aber nicht angekommen? ==
Dann bitte in der Fritzbox Oberfläche überpüfen, ob unter "System" -> "Push Service" selbiger eingerichtet und aktiviert wurde.

[[Kategorie:HOWTOS]]
[[Kategorie:FritzBox]]
[[Kategorie:BeagleBoard-xM]]
[[Kategorie:Raspberry Pi]]

Yowsup

2015-12-03T13:01:11Z

Nielsiwilsi: /* Attribute */

{{SEITENTITEL:yowsup}}
{{Infobox Modul
|ModPurpose=Schnittstelle, um WhatsApp-Nachrichten empfangen und senden zu können.
|ModType=d
|ModCmdRef=yowsup
|ModFTopic=27543
|ModForumArea=Unterstuetzende Dienste
|ModTechName=32_yowsup.pm
|ModOwner=André / justme1968 ({{Link2FU|430|Forum}} / [[Benutzer Diskussion:justme|Wiki]])
}}

Das Modul [[yowsup]] dient dazu, WhatsApp-Nachrichten zu empfangen und zu senden.

== Voraussetzungen ==
* Die Funktionalität ist vermutlich auf Linux/Unix Systeme beschränkt.
* Nach der Erstinstallation/-einrichtung '''muss''' zwingend das ''cmd'' Attribut korrekt gesetzt werden.

== Installation ==
Die ursprüngliche Einrichtung wurde {{Link2Forum|Topic=27543|Message=204426|LinkText=hier beschrieben}}, jedoch sind noch einige wichtige Dinge zu setzen.

=== Yowsup Installation ===
Bevor man loslegt sollte man wie immer sicherstellen, dass Debian auf dem aktuellen Stand ist:
<code>sudo apt-get update</code>
<code>sudo apt-get upgrade</code>
<code>sudo apt-get dist-upgrade</code>

Los gehts mit den Paketen:
<code>sudo apt-get install python-soappy python-dateutil python-pip python-dev build-essential</code>

Nun erstmal pip updaten:
<code>sudo pip install --upgrade pip</code>

Und dann axolotl installieren (das dauert ne Weile):
<code>sudo pip install python-axolotl</code>

Will man Bilder verarbeiten, so braucht man noch ein paar Pakete mehr:
* Paketinstallationen:
** Unter Debian Wheezy: <code>sudo apt-get install libtiff4-dev libjpeg8-dev zlib1g-dev libfreetype6-dev liblcms2-dev libwebp-dev tcl8.5-dev tk8.5-dev python-tk</code>
** Unter Debian Jessie: <code>sudo apt-get install libtiff5-dev libjpeg-dev zlib1g-dev libfreetype6-dev liblcms2-dev libwebp-dev tcl8.5-dev tk8.5-dev python-tk</code>
* PIP:<code>sudo pip install pillow</code>

Vor den weiteren Schritten sollte geprüft werden, ob dem User fhem eine Loginshell zugewiesen ist:
:<code>getent passwd fhem</code>
Wird hier am Ende /bin/false ausgegeben, so muss dies angepasst werden:
:<code>sudo chsh -s /bin/bash fhem</code>

Mittels ''getent passwd fhem'' kann auch bereits das Home-Verzeichnis ausgelesen werden, dies steht in der ausgegebenen Doppelpunkt-separierten Liste an vorletzter Stelle.

Nun loggt man sich unter dem User ein, unter dem fhem läuft (in den folgenden Beispielen werden die vom fhem-Setup-Script generierten Defaults verwendet: User=fhem , home=/opt/fhem Gruppe=dialout) und liest dort die $HOME-Variable aus und prüft das Home-Verzeichnis:
<pre>sudo su - fhem
echo $HOME
cd $HOME
logout</pre>
Diesen Wert braucht man später - gut merken. Sollte hier ein Fehler auftreten (z.B. das home nicht vorhanden), so muss dies zuerst korrigiert werden.

Desweiteren muss man nun yowsup installieren, was wie folgt vonstatten geht:
<pre>cd /opt
sudo mkdir yowsup-config
sudo wget https://github.com/tgalal/yowsup/archive/master.zip
sudo unzip master.zip
rm master.zip
cd yowsup-config
sudo nano yowsup.config</pre>

Wie bemerkt, ist man nun im Editor für die yowsup.config gelandet. Diese wird nun wie folgt gefüllt:
<pre>## Actual config starts below ##

#cc ist wichtig ansonsten funktioniert es nicht aus dem Script
cc=49
phone=498912345678
id=0000000000
password=</pre>
Ersetze die Nummer 498912345678 gegen eine Festnetz oder Handynummer welche derzeit nicht mit WhatsApp verwendet wird. Mittels STRG+o wird die Datei nun gespeichert und mittels STRG+x verlässt man den Editor.

Vor den weiteren Schritten sollte man nun erstmal die yowsup Verzeichnisse dem fhem-user zugängig machen:
<pre>sudo chown -R fhem:dialout /opt/yowsup-master /opt/yowsup-config</pre>

Für die folgenden Schritte würde ich auf den FHEM-Nutzer wechseln:
<pre>sudo su - fhem
cd /opt/yowsup-master</pre>

Nun erfolgt die Anmeldung am WhatsApp-Server. Dies kann man nun via <code>voice</code> oder <code>sms</code> machen. Bei einem Handy bietet sich SMS an, bei Festnetzanschlüssen sollte voice gewählt werden, wenn man sich nicht sicher ist, dass der Anschluss die Funktion 'SMS im Festnetz' unterstützt. Dann wird der Bestätigungscode zwar auf Englisch vorgelesen, dafür ist die Zuverlässigkeit des Registrierungsvorganges zuverlässiger. Bei Festnetznummern sollte man unbedingt etwas zum schreiben bereit halten!
<pre>python yowsup-cli registration -c /opt/yowsup-config/yowsup.config -r sms</pre>

Die Rückmeldung ist nun entscheidend. Wenn man diese zurückbekommt:
<pre>de sms
status: fail
retry_after: 3600
reason: no_routes</pre>
Dann ist die Nummer so nicht kompatibel. Was man dann noch probieren kann, ist die registration via voice - meistens ist das aber vergebene Liebesmüh'.

Wenn man folgende Rückmeldung bekommt:
<pre>Detected cc: 49
status: sent
retry_after: 1805
length: 6
method: sms</pre>

So ist alles gut gelaufen und man sollte kurz später eine SMS bekommen. Darin ist ein Text, der am Ende z.B. 123-456 lautet. Diesen fügt man ohne Bindestrich am Ende des folgenden Befehls ein:
<pre>python yowsup-cli registration -c /opt/yowsup-config/yowsup.config -R 123456</pre>

Dann kommt ein Text der etwa so aussehen sollte:
<pre>status: ok
kind: free
pw: bfGA9wPWWNeHcSBxxxxxxxxxxxxxxxxx
price: 0,89 €
price_expiration: 1432127524
currency: EUR
cost: 0.89
login: 498912345678
type: existing
expiration: 1460832553</pre>
Den Text hinter dem Zeilenanfang <code>pw: </code> benötigt man nun für die Konfigurationsdatei, wo dieser eingefügt werden muss:
<pre>nano /opt/yowsup-config/yowsup.config</pre>
Sodass die Datei beispielhaft dann so aussieht:
<pre>## Actual config starts below ##

#cc ist wichtig ansonsten funktioniert es nicht aus dem Script
cc=49
phone=498912345678
id=0000000000
password=bfGA9wPWWNeHcSBxxxxxxxxxxxxxxxxx</pre>

Wie man schon gesehen hat, ist der Account nur begrenzt gültig - die Gültigkeit kann man anhand der als <code>expiration: </code> bezeichneten Zeile ablesen, welche einen Unix-Timestamp beinhaltet. Diese kann man [http://elmar-eigner.de/tstamps.html?zeichen=1444570276&timeformat=2 HIER] umrechnen lassen.

Nun mal ein schneller test an die eigene Nummer (im Beispiel 491751234567):
<pre>python yowsup-cli demos -c /opt/yowsup-config/yowsup.config -s 491751234567 "Das ist ein Test"</pre>

Das sollte dir eine Nachricht einbringen. Wenn du darauf antwortest, kommt diese allerdings noch nicht an - der Client hat sich nach dem Befehl sofort beendet. Damit dieser dauerhaft im Hintergrund läuft legen wir nun in FHEM ein Gerät an, welches dies steuert.

=== FHEM Define ===
* Fhem Device anlegen: <code> define <name> yowsup</code>, also z.B. <code>define WhatsApp yowsup</code>
* Nun muss man den Pfad zu yowsup anpassen: <code>attr WhatsApp cmd /opt/yowsup-master/yowsup-cli demos -c /opt/yowsup-config/yowsup.config --yowsup</code>
* Und das Home directory mit dem Pfad zum Home des fhem users: <code>attr WhatsApp home PWD</code>
* Wenn alles gut geht, gibt es danach im Device ein internal PID und das Reading ''state''
* Im Whatsapp Client auf dem Handy sollte man sehen, dass Fhem online ist
* Zum Senden aus Fhem kann man das Kommando <code>set WhatsApp send <nummer> <text></code> verwenden

== Attribute ==
Bitte sehe immer in der [[http://fhem.de/commandref.html#yowsup Commandref]] nach - diese hier könnten veraltet sein.

* <code>cmd</code> komplettes Kommando, um den yowsup Client zu starten. z.B.: <code>attr WhatsApp cmd /opt/yowsup-master/yowsup-cli demos -c /opt/yowsup-config/yowsup.config --yowsup</code>. Wenn die ab yowsup-Version 2.4 standartmässig aktivierte Verschlüsselung abgeschaltet werden muss weil die entsprechenden Libs nicht installiert sind: <code>attr WhatsApp cmd /opt/local/bin/yowsup-cli demos -c /root/yowsup-config --yowsup -M</code>.
* <code>accept_from</code> kommagetrennte Liste von Kontakten (Nummern), von denen Nachrichten akzeptiert werden. Ist das Attribut nicht gesetzt, so werden die Nachrichten von jedem akzeptiert.
* <code>commandPrefix</code> nicht gesetzt -> es werden keine Befehle akzeptiert. 0 -> es werden keine Befehle akzeptiert. 1 -> erlaubt Befehle, jede Nachricht wird als Fhem-Befehl interpretiert. alles andere -> Wenn die Nachricht mit diesem Prefix startet, wird alles weitere als Befehle interpretiert.
{{Randnotiz|RNTyp=Warn|RNText='''allowedCommands''' should work as intended, but no guarantee can be given, that there is no way to circumvent it.}}
* <code>allowedCommands</code> Eine Komma-getrennte Liste von zulässigen Befehlen für diesen Kontakt. Wenn die Liste leer ist (z.B. nur ein Komma), dann werden keine Befehle akzeptiert.
* <code>home</code> Setzt das Home-directory welches für yowsup verwendet werden soll.

== Befehle ==
* image -> Über diesen Befehl können Bilder gesendet werden.

* raw -> Status ändern :
<code>set WhatsApp raw /profile setStatus 'mein Status' <--- die ' ' müssen bleiben</code>

Name der angezeigt werden soll, wenn eine Nachricht z.B. ans iPhone geschickt wird:

<code>set WhatsApp raw /presence name <DeinNick></code>

Anzeige online :

<code>set WhatsApp raw /presence available</code>

Profilbild ändern :

<code>set WhatsApp raw /profile setPicture '/opt/fhem/fhem_logo.png'</code>
<--- der gesamte Pfad zum Bild muss angegeben werden und Rechte müssen ggfs. bei fhem liegen

Falls es nicht funktioniert disconnect/connect probieren.

== Anwendungsbeispiele ==
=== Beispielnachricht ===
Beim Empfang einer Nachricht wird automatisch ein Fhem Device für diesen Kontakt angelegt. In diesem Device gibt es das Reading '''message''' für die empfangene Nachricht und ab der ersten Nachricht auch das Reading '''chatstate''', in dem zu sehen ist, ob gerade getippt wird.
Nachdem ein Device für einen Kontakt angelegt ist, lässt sich auch direkt dieses Device zum Senden verwenden:
:<code>set <device> send <text></code>,
d.h., man spart sich die Angabe der Nummer.

=== Gruppen ===
Gruppen müssen über die App (Smartphone / Tablet) angelegt werden. Nach dem Empfang einer entsprechenden Nachricht werden Gruppen genauso behandelt, wie einfache Teilnehmer.

=== Broadcast ===
Beim Senden über das Masterdevice lassen sich mehrere Empfänger mit Komma (und ohne Leerzeichen) getrennt angeben. Die entsprechenden Nachrichten werden dann per Broadcast an alle Teilnehmer gesendet. Die Broadcastempfänger müssen zuvor mindestens eine normale Nachricht erhalten haben.

=== Komponenten steuern ===
Um ein [[notify]] anlegen zu können, müssen wir zuerst eine Nachricht vom Handy an FHEM senden. Dadurch wird ein Device mit der Nummer als Namen angelegt. Danach sollte das Device umbenannt werden, da einige Befehle einen Namen ausschließlich aus Ziffern nicht akzeptieren. Dies geschieht wie folgt:

:<code>rename 49123456789 HandySeppel</code>

Danach kann ein ''notify'' angelegt werden:

<source lang="perl">
define notifySeppelLicht notify (HandySeppel:message.*) {
if (ReadingsVal("HandySeppel","message",0) eq "Licht an") {
fhem "set HandySeppel send Licht ist nun an...";;
fhem "set FS20_a5d800 dim100%"
} else {
if (ReadingsVal("HandySeppel","message",0) eq "Licht aus") {
fhem "set HandySeppel send Licht ist nun aus...";;
fhem "set FS20_a5d800 dim0%"
} else {
fhem "set HandySeppel send Wie bitte?"
}}}</source>

Natürlich ist dieses ''notify'' noch auf die eigenen Wünsche anzupassen.

== Links ==
* {{Link2Forum|Topic=27543|LinkText=Forenthread}}, in dem die Whatsapp Anwendung beschrieben wird
* {{Link2Forum|Topic=27543|Message=299292|LinkText=Foreneintrag}}, ab dem das yowsup Modul beschrieben wird
* Die Python Whatsapp Library auf [https://github.com/tgalal/yowsup github]
* Imagehandling Bugfix [https://github.com/tgalal/yowsup/issues/901 github]

Yowsup

2015-12-03T12:59:59Z

Nielsiwilsi: /* Attribute */

{{SEITENTITEL:yowsup}}
{{Infobox Modul
|ModPurpose=Schnittstelle, um WhatsApp-Nachrichten empfangen und senden zu können.
|ModType=d
|ModCmdRef=yowsup
|ModFTopic=27543
|ModForumArea=Unterstuetzende Dienste
|ModTechName=32_yowsup.pm
|ModOwner=André / justme1968 ({{Link2FU|430|Forum}} / [[Benutzer Diskussion:justme|Wiki]])
}}

Das Modul [[yowsup]] dient dazu, WhatsApp-Nachrichten zu empfangen und zu senden.

== Voraussetzungen ==
* Die Funktionalität ist vermutlich auf Linux/Unix Systeme beschränkt.
* Nach der Erstinstallation/-einrichtung '''muss''' zwingend das ''cmd'' Attribut korrekt gesetzt werden.

== Installation ==
Die ursprüngliche Einrichtung wurde {{Link2Forum|Topic=27543|Message=204426|LinkText=hier beschrieben}}, jedoch sind noch einige wichtige Dinge zu setzen.

=== Yowsup Installation ===
Bevor man loslegt sollte man wie immer sicherstellen, dass Debian auf dem aktuellen Stand ist:
<code>sudo apt-get update</code>
<code>sudo apt-get upgrade</code>
<code>sudo apt-get dist-upgrade</code>

Los gehts mit den Paketen:
<code>sudo apt-get install python-soappy python-dateutil python-pip python-dev build-essential</code>

Nun erstmal pip updaten:
<code>sudo pip install --upgrade pip</code>

Und dann axolotl installieren (das dauert ne Weile):
<code>sudo pip install python-axolotl</code>

Will man Bilder verarbeiten, so braucht man noch ein paar Pakete mehr:
* Paketinstallationen:
** Unter Debian Wheezy: <code>sudo apt-get install libtiff4-dev libjpeg8-dev zlib1g-dev libfreetype6-dev liblcms2-dev libwebp-dev tcl8.5-dev tk8.5-dev python-tk</code>
** Unter Debian Jessie: <code>sudo apt-get install libtiff5-dev libjpeg-dev zlib1g-dev libfreetype6-dev liblcms2-dev libwebp-dev tcl8.5-dev tk8.5-dev python-tk</code>
* PIP:<code>sudo pip install pillow</code>

Vor den weiteren Schritten sollte geprüft werden, ob dem User fhem eine Loginshell zugewiesen ist:
:<code>getent passwd fhem</code>
Wird hier am Ende /bin/false ausgegeben, so muss dies angepasst werden:
:<code>sudo chsh -s /bin/bash fhem</code>

Mittels ''getent passwd fhem'' kann auch bereits das Home-Verzeichnis ausgelesen werden, dies steht in der ausgegebenen Doppelpunkt-separierten Liste an vorletzter Stelle.

Nun loggt man sich unter dem User ein, unter dem fhem läuft (in den folgenden Beispielen werden die vom fhem-Setup-Script generierten Defaults verwendet: User=fhem , home=/opt/fhem Gruppe=dialout) und liest dort die $HOME-Variable aus und prüft das Home-Verzeichnis:
<pre>sudo su - fhem
echo $HOME
cd $HOME
logout</pre>
Diesen Wert braucht man später - gut merken. Sollte hier ein Fehler auftreten (z.B. das home nicht vorhanden), so muss dies zuerst korrigiert werden.

Desweiteren muss man nun yowsup installieren, was wie folgt vonstatten geht:
<pre>cd /opt
sudo mkdir yowsup-config
sudo wget https://github.com/tgalal/yowsup/archive/master.zip
sudo unzip master.zip
rm master.zip
cd yowsup-config
sudo nano yowsup.config</pre>

Wie bemerkt, ist man nun im Editor für die yowsup.config gelandet. Diese wird nun wie folgt gefüllt:
<pre>## Actual config starts below ##

#cc ist wichtig ansonsten funktioniert es nicht aus dem Script
cc=49
phone=498912345678
id=0000000000
password=</pre>
Ersetze die Nummer 498912345678 gegen eine Festnetz oder Handynummer welche derzeit nicht mit WhatsApp verwendet wird. Mittels STRG+o wird die Datei nun gespeichert und mittels STRG+x verlässt man den Editor.

Vor den weiteren Schritten sollte man nun erstmal die yowsup Verzeichnisse dem fhem-user zugängig machen:
<pre>sudo chown -R fhem:dialout /opt/yowsup-master /opt/yowsup-config</pre>

Für die folgenden Schritte würde ich auf den FHEM-Nutzer wechseln:
<pre>sudo su - fhem
cd /opt/yowsup-master</pre>

Nun erfolgt die Anmeldung am WhatsApp-Server. Dies kann man nun via <code>voice</code> oder <code>sms</code> machen. Bei einem Handy bietet sich SMS an, bei Festnetzanschlüssen sollte voice gewählt werden, wenn man sich nicht sicher ist, dass der Anschluss die Funktion 'SMS im Festnetz' unterstützt. Dann wird der Bestätigungscode zwar auf Englisch vorgelesen, dafür ist die Zuverlässigkeit des Registrierungsvorganges zuverlässiger. Bei Festnetznummern sollte man unbedingt etwas zum schreiben bereit halten!
<pre>python yowsup-cli registration -c /opt/yowsup-config/yowsup.config -r sms</pre>

Die Rückmeldung ist nun entscheidend. Wenn man diese zurückbekommt:
<pre>de sms
status: fail
retry_after: 3600
reason: no_routes</pre>
Dann ist die Nummer so nicht kompatibel. Was man dann noch probieren kann, ist die registration via voice - meistens ist das aber vergebene Liebesmüh'.

Wenn man folgende Rückmeldung bekommt:
<pre>Detected cc: 49
status: sent
retry_after: 1805
length: 6
method: sms</pre>

So ist alles gut gelaufen und man sollte kurz später eine SMS bekommen. Darin ist ein Text, der am Ende z.B. 123-456 lautet. Diesen fügt man ohne Bindestrich am Ende des folgenden Befehls ein:
<pre>python yowsup-cli registration -c /opt/yowsup-config/yowsup.config -R 123456</pre>

Dann kommt ein Text der etwa so aussehen sollte:
<pre>status: ok
kind: free
pw: bfGA9wPWWNeHcSBxxxxxxxxxxxxxxxxx
price: 0,89 €
price_expiration: 1432127524
currency: EUR
cost: 0.89
login: 498912345678
type: existing
expiration: 1460832553</pre>
Den Text hinter dem Zeilenanfang <code>pw: </code> benötigt man nun für die Konfigurationsdatei, wo dieser eingefügt werden muss:
<pre>nano /opt/yowsup-config/yowsup.config</pre>
Sodass die Datei beispielhaft dann so aussieht:
<pre>## Actual config starts below ##

#cc ist wichtig ansonsten funktioniert es nicht aus dem Script
cc=49
phone=498912345678
id=0000000000
password=bfGA9wPWWNeHcSBxxxxxxxxxxxxxxxxx</pre>

Wie man schon gesehen hat, ist der Account nur begrenzt gültig - die Gültigkeit kann man anhand der als <code>expiration: </code> bezeichneten Zeile ablesen, welche einen Unix-Timestamp beinhaltet. Diese kann man [http://elmar-eigner.de/tstamps.html?zeichen=1444570276&timeformat=2 HIER] umrechnen lassen.

Nun mal ein schneller test an die eigene Nummer (im Beispiel 491751234567):
<pre>python yowsup-cli demos -c /opt/yowsup-config/yowsup.config -s 491751234567 "Das ist ein Test"</pre>

Das sollte dir eine Nachricht einbringen. Wenn du darauf antwortest, kommt diese allerdings noch nicht an - der Client hat sich nach dem Befehl sofort beendet. Damit dieser dauerhaft im Hintergrund läuft legen wir nun in FHEM ein Gerät an, welches dies steuert.

=== FHEM Define ===
* Fhem Device anlegen: <code> define <name> yowsup</code>, also z.B. <code>define WhatsApp yowsup</code>
* Nun muss man den Pfad zu yowsup anpassen: <code>attr WhatsApp cmd /opt/yowsup-master/yowsup-cli demos -c /opt/yowsup-config/yowsup.config --yowsup</code>
* Und das Home directory mit dem Pfad zum Home des fhem users: <code>attr WhatsApp home PWD</code>
* Wenn alles gut geht, gibt es danach im Device ein internal PID und das Reading ''state''
* Im Whatsapp Client auf dem Handy sollte man sehen, dass Fhem online ist
* Zum Senden aus Fhem kann man das Kommando <code>set WhatsApp send <nummer> <text></code> verwenden

== Attribute ==
Bitte sehe immer in der [[http://fhem.de/commandref.html#yowsup Commandref]] nach - diese hier könnten veraltet sein.

* <code>cmd</code> komplettes Kommando, um den yowsup Client zu starten. z.B.: <code>attr WhatsApp cmd /opt/yowsup-master/yowsup-cli demos -c /opt/yowsup-config/yowsup.config --yowsup</code>. Wenn die ab yowsup-Version 2.4 standartmässig aktivierte Verschlüsselung abgeschaltet werden muss weil die entsprechenden Libs nicht installiert sind: <code>attr WhatsApp cmd /opt/local/bin/yowsup-cli demos -c /root/config.yowsup --yowsup -M</code>.
* <code>accept_from</code> kommagetrennte Liste von Kontakten (Nummern), von denen Nachrichten akzeptiert werden. Ist das Attribut nicht gesetzt, so werden die Nachrichten von jedem akzeptiert.
* <code>commandPrefix</code> nicht gesetzt -> es werden keine Befehle akzeptiert. 0 -> es werden keine Befehle akzeptiert. 1 -> erlaubt Befehle, jede Nachricht wird als Fhem-Befehl interpretiert. alles andere -> Wenn die Nachricht mit diesem Prefix startet, wird alles weitere als Befehle interpretiert.
{{Randnotiz|RNTyp=Warn|RNText='''allowedCommands''' should work as intended, but no guarantee can be given, that there is no way to circumvent it.}}
* <code>allowedCommands</code> Eine Komma-getrennte Liste von zulässigen Befehlen für diesen Kontakt. Wenn die Liste leer ist (z.B. nur ein Komma), dann werden keine Befehle akzeptiert.
* <code>home</code> Setzt das Home-directory welches für yowsup verwendet werden soll.

== Befehle ==
* image -> Über diesen Befehl können Bilder gesendet werden.

* raw -> Status ändern :
<code>set WhatsApp raw /profile setStatus 'mein Status' <--- die ' ' müssen bleiben</code>

Name der angezeigt werden soll, wenn eine Nachricht z.B. ans iPhone geschickt wird:

<code>set WhatsApp raw /presence name <DeinNick></code>

Anzeige online :

<code>set WhatsApp raw /presence available</code>

Profilbild ändern :

<code>set WhatsApp raw /profile setPicture '/opt/fhem/fhem_logo.png'</code>
<--- der gesamte Pfad zum Bild muss angegeben werden und Rechte müssen ggfs. bei fhem liegen

Falls es nicht funktioniert disconnect/connect probieren.

== Anwendungsbeispiele ==
=== Beispielnachricht ===
Beim Empfang einer Nachricht wird automatisch ein Fhem Device für diesen Kontakt angelegt. In diesem Device gibt es das Reading '''message''' für die empfangene Nachricht und ab der ersten Nachricht auch das Reading '''chatstate''', in dem zu sehen ist, ob gerade getippt wird.
Nachdem ein Device für einen Kontakt angelegt ist, lässt sich auch direkt dieses Device zum Senden verwenden:
:<code>set <device> send <text></code>,
d.h., man spart sich die Angabe der Nummer.

=== Gruppen ===
Gruppen müssen über die App (Smartphone / Tablet) angelegt werden. Nach dem Empfang einer entsprechenden Nachricht werden Gruppen genauso behandelt, wie einfache Teilnehmer.

=== Broadcast ===
Beim Senden über das Masterdevice lassen sich mehrere Empfänger mit Komma (und ohne Leerzeichen) getrennt angeben. Die entsprechenden Nachrichten werden dann per Broadcast an alle Teilnehmer gesendet. Die Broadcastempfänger müssen zuvor mindestens eine normale Nachricht erhalten haben.

=== Komponenten steuern ===
Um ein [[notify]] anlegen zu können, müssen wir zuerst eine Nachricht vom Handy an FHEM senden. Dadurch wird ein Device mit der Nummer als Namen angelegt. Danach sollte das Device umbenannt werden, da einige Befehle einen Namen ausschließlich aus Ziffern nicht akzeptieren. Dies geschieht wie folgt:

:<code>rename 49123456789 HandySeppel</code>

Danach kann ein ''notify'' angelegt werden:

<source lang="perl">
define notifySeppelLicht notify (HandySeppel:message.*) {
if (ReadingsVal("HandySeppel","message",0) eq "Licht an") {
fhem "set HandySeppel send Licht ist nun an...";;
fhem "set FS20_a5d800 dim100%"
} else {
if (ReadingsVal("HandySeppel","message",0) eq "Licht aus") {
fhem "set HandySeppel send Licht ist nun aus...";;
fhem "set FS20_a5d800 dim0%"
} else {
fhem "set HandySeppel send Wie bitte?"
}}}</source>

Natürlich ist dieses ''notify'' noch auf die eigenen Wünsche anzupassen.

== Links ==
* {{Link2Forum|Topic=27543|LinkText=Forenthread}}, in dem die Whatsapp Anwendung beschrieben wird
* {{Link2Forum|Topic=27543|Message=299292|LinkText=Foreneintrag}}, ab dem das yowsup Modul beschrieben wird
* Die Python Whatsapp Library auf [https://github.com/tgalal/yowsup github]
* Imagehandling Bugfix [https://github.com/tgalal/yowsup/issues/901 github]

Trick der Woche

2015-11-08T21:19:18Z

Nielsiwilsi:

Diese Seite enthält Tipps und Tricks, die zu unbedeutend sind, einen eigenen Artikel zu rechtfertigen, alternative Schreibweisen/Lösungen für eine Problem darstellen, Ungenauigkeiten oder unklare Formulierungen in den offiziellen Dokumenten ergänzen und ähnliches. Jeder Eintrag ist typischerweise sehr kurz (wenige Zeilen lang) und beleuchtet vielleicht nur einen Aspekt von Fhem, er kann allgemeiner Natur sein, oder sich auf ein spezielles Gerät oder einen speziellen Anwendungsfall beziehen.

== April 2015 ==
===FS20 Timer===
FS20 Aktoren beherrschen zwei verschiedene Timer-Methoden.

Angenommen ein FS20 Device heisse "Lampe" und sei z.B. ein [[FS20_SU_Unterputz-Funk-Schalter|FS20 SU]] (Unterputzschalter), dann kann man mit FHEM sowohl
:<code> set Lampe on-for-timer 30</code>
verwenden um die Lampe 30 Sekunden einzuschalten, aber auch zunächst in den FS20 SU die maximale Einschaltdauer einprogrammieren:
:<code> set Lampe timer 30</code>
Dannach wird jedes normale
:<code> set Lampe on</code>
die Lampe für nur 30 Sekunden einschalten.

Als Timerwerte kommen in beiden Fällen die bekannten [[Trick_der_Woche#FS20_Timerzeiten|128 Sekundenwerte]] von 0,25 Sekunden bis Etwa 4,5 Stunden in Frage.

Es ist offenbar nicht bei allen Aktoren möglich einen einmal eingestellten Timer zu löschen, neue Werte eingeben aber sehr wohl.

Mehr hier: [[FS20_Allgemein#Gerätetimer setzen / löschen|FS20 timer]].

== Februar 2015 ==
=== 1-wire am GPIO4-Port des RaspberryPi funktioniert nicht mehr nach Systemupdate ===
Es kann passieren, dass nach einem Systemupdate (apt-get update oder apt-get dist-upgrade) die 1-wire-Geräte am GPIO4-Port plötzlich nicht mehr funktionieren. Eine Problemlösung dazu ist im Artikel "[[Raspberry Pi und 1-Wire#1-wire am GPIO4-Port funktioniert nicht mehr nach Systemupdate]]" beschrieben.

=== Backup der Konfiguration (fhem.cfg und fhem.state) bei jedem "save" ===
Der nachfolgende Codeschnipsel erstellt bei jedem "save" eine Kopie der aktuellen [[Konfiguration]] (fhem.cfg und fhem.state) in ein Verzeichnis "backup_cfg-state" welches unter /opt/fhem/ zu finden ist. Somit kann bei einem Fehler jederzeit auf den letzten Stand zurückgegangen werden.
Zuerst ins FHEM Befehlsfeld den folgenden Befehl eingeben:
:<code>{ `mkdir backup_cfg-state` } </code>

Danach folgendes [[notify]] anlegen:
define backupCfg notify global:SAVE {\
my $now = TimeNow();; $now =~ s/ /_/g;; \
`cp $attr{global}{configfile} ./backup_cfg-state/fhem.cfg.$now`;;\
`cp $attr{global}{statefile} ./backup_cfg-state/fhem.state.$now`;;\
}

Quelle: {{Link2Forum|Topic=30873|Message=234412|LinkText=FHEM-Forum}}

== Januar 2015 ==
=== CUL & CO über Serial ID-einbinden ===
Bei mehreren USB-Geräten kann es vorkommen, dass sie vertauscht werden z.B. ''/dev/ttyUSB0'' zu'' /dev/ttyUSB1'' oder ''/dev/ttyACM0'' zu ''/dev/ttyACM1''.

Um dies zu umgehen, kann man sie über ihre Serial-ID in Fhem einbinden.

Dieser Befehl zeigt die Serial-ID:

:<code>ls -l /dev/serial/by-id</code>

Hier die Beispielausgabe eines CUL868, JeeLink, RFXtrx und eines CUL433

user@xxxx:~# ls -l /dev/serial/by-id
lrwxrwxrwx 1 root root 13 Jan 9 23:34 usb-busware.de_CUL868-if00 -> ../../ttyACM0
lrwxrwxrwx 1 root root 13 Jan 9 13:26 usb-FTDI_FT232R_USB_UART_A901RQ9F-if00-port0-> ../../ttyUSB0
lrwxrwxrwx 1 root root 13 Jan 9 13:26 usb-RFXCOM_RFXtrx433_A1WZWL5Y-if00-port0-> ../../ttyUSB1
lrwxrwxrwx 1 root root 13 Jan 9 21:29 usb-busware.de_CUL433-if00 -> ../../ttyACM1

Damit lässt sich folgende Definition erstellen:

z.B. für einen CUL868

:<code>define CUL868 CUL /dev/serial/by-id/usb-busware.de_CUL868-if00@9600 1134</code>

oder einen JeeLink

:<code>define Jeelink JeeLink /dev/serial/by-id/usb-FTDI_FT232R_USB_UART_A901RQ9F-if00-port0@57600</code>

'''Einschränkung:''' Bei CULs von Busware lassen sich nur CUL433 und CUL868 unterscheiden. Zwei CUL868 haben z.B. immer die gleiche Serial-ID.

=== HM LAN Konfig-Adapter Antenne verbessern===
Die Antenne des [[HM-CFG-LAN LAN Konfigurations-Adapter]] kann man mit etwas Bastelgeschick verlängern um den Empfang zu verbessern.

Sinnvoll ist die Verlängerung auf 1/2 Lambda (868MHz = 17,27 cm) oder gar 1 Lambda.
1 Lambda Antennen haben starke Richtwirkung in Form eines gedachten Zylinders, dessen Mittelachse die Antenne ist.
D.h., Alles was sich in Richtung des Anfangs und des Endes des Antennedrahtes befindet, hat schlechteren Empfang als mit einer kurzen Antenne. Daher muss man die Antenne ggf. genauer ausrichten.

Anleitungen dazu werden an verschiedenen Stellen veröffentlicht, z.B. in
[http://www.ip-symcon.de/forum/threads/18411-Umbau-HM-LAN-Adapter-auf-Lambda-1-2-Dipol-Antenne diesem Beitrag] im IP-Symcon Forum (anders als der Namen der Anleitung vermuten lässt, liegt hier kein Dipol vor, sondern eine "normale" 1 Lambda Antenne.)

Prinzipiell so dünnen Draht wie möglich verwenden.

Wer noch mehr rausholen will, kann auch zusätzlichen Aufwand betreiben und die Antenne etwas von der Elektronik entfernen, die nämlich Störstrahlung in die Antenne einkoppelt. Oder eine Groundplane bauen.
Ein Anleitung für die CCU (analog auch für den HM LAN Konfig-Adapter einsetzbar) gibt es [http://www.techwriter.de/beispiel/funkeige.htm hier].

== Dezember 2014 ==
=== FHT80TF als "Prüfsender" einsetzen ===
Da der [[FHT80TF-2]] günstig ist und seinen Zustand ca. alle zwei Minuten sendet, kann er gut zum Ermitteln der Funklage von [[SlowRF]] Komponenten genutzt werden, auch wenn diese nicht senden. Den RSSI einer FS20 Schaltsteckdose kann man z.B. nicht wissen, da die Dose nur ein Empfänger ist. Wenn eine Dose nicht gut funktioniert und man den Verdacht hat, dass sie funktechnisch ungünstig liegt, kann man einen [[FHT80TF-2]] neben die Steckdose legen und man bekommt nach zwei Minuten einen Wert, der (trotz umgekehrter Funkrichtung) gut genug ist, um einem Hinweise zu geben.

== November 2014 ==
=== FS20 Adressschema und die Rolle des Hauscodes ===
[[FS20_Allgemein#FS20_Adressierungsschema_.28Vorschlag.29]]

== Oktober 2014 ==
=== Aktor für Wanddosen ohne Nulleiter ===
Zwar gibt es viele Aktoren, die man in Wanddosen hinter Schaltern einbauen kann, oft scheitert deren Nutzung aber daran, dass in vielen Elektroinstalltionen in der Wanddose eines (Licht)schalters kein Nulleiter verlegt ist, den die meisten Aktoren zur eigenen Stromversorgung brauchen. Hier kann der [[RSL 2-Draht Einbauschalter]] helfen, der auch ohne Nulleiter funktioniert und kompatibel zu InterTechno ist. Er lässt sich z.B. mit einem CUL(433) schalten.

== August 2014 ==
=== Perl-Skripte Online testen ===
Im Internet existieren Webseiten auf denen man Perl-Code online testen kann. Beispielsweise auf [http://www.tutorialspoint.com/execute_perl_online.php codingground] kann man Code zum Testen eingeben und die Auswirkungen betrachten. Dies eignet sich zur schnellen Fehleranalyse oder um Perl zu lernen. Natürlich lassen sich keine Fhem-Besonderheiten nutzen.

== Juli 2014 ==
=== Funklast reduzieren===
Bewegungsmelder erzeugen in der Regel eine recht hohe Funklast, wenn sie oft ausgelöst werden, also z.B. Licht in einem Zimmer schalten sollen.

Konstruktionen der Art:
:<code>define FlurLicht notify Bewegungsmelder_Flur:motion:.* set Licht_Flur on-for-timer 256</code>
haben daher den Nachteil bei viel Bewegung im Flur und je nach Einstellung des Sendeabstandes des Bewegungsmelders mindestens alle 120 Sekunde oder öfter ein
:<code>on-for-timer 256</code>
zu senden. Das erzeugt eine hohe Funklast, speziell wenn der Aktor ein SlowRF Gerät ist (z.B. FS20 Unterputzschalter).
In solchen Fällen kann es helfen, nur dann einen Befehl zu senden, wenn das Licht nicht schon an ist:
:<code>define FlurLicht notify Bewegungsmelder_Flur:motion:.* { if (Value("Licht_Flur") eq "off") { fhem ("set Licht_Flur1 on-for-timer 256") } }</code>
Nachteilig ist aber, dass eine Auslösung innerhalb 256 Sekunden die Einschaltzeit nicht verlängert. Dies kann man umgehen, indem man nicht on-for-timer verwendet, sondern den Aktor selber verzögert auschaltet und bei weiteren Auslösungen nur die Verzögerung erneut anlegt:
:<code>define FlurLicht notify Bewegungsmelder_Flur:motion:.* { if (Value("Licht_Flur1") eq "off") { fhem ("set Licht_Flur on ;; define FlurLicht_aus at +00:04:16 set Licht_Flur off") } else { fhem ("delete FlurLicht_aus ;; define FlurLicht_aus at +00:04:16 set Licht_Flur off") }}</code>

== Juni 2014 ==
=== Batteriestatus bei HomeMatic Devices aktivieren===
Zumindest einige (wenn nicht alle) batteriegespeisten HM-Geräte können Batteriemeldungen senden, tun dies in der normalen Konfiguration aber nicht.
Dazu muss das Register cyclicInfoMsg auf on gesetzt werden.

Wie man das macht steht z.B. hier
[[HM-SEC-SC_Tür-Fensterkontakt#Batteriestatus_aktivieren]]
und hier
[[HomeMatic_Type_ThreeState]]

== Mai 2014 ==
=== Dummywert mit aktueller Uhrzeit versehen in anderen Dummy kopieren===
Der Inhalt von Dummy1 soll erweitert um Uhrzeit und Datum in Dummy2 kopiert werden (z.B. um die Urzeit der letzten Auslösung einer Alarmanlage anzuzeigen)
:<code>{ fhem("set dummy2 " . (Value("Dummy1")." ".TimeNow()) ) } </code>

=== Zwei Dummywerte in einen anderen Dummy kopieren ===
Der String in Dummy1 soll um den String in Dummy2 erweitert und nach Dummy3 kopiert werden:
:<code>{ fhem("set Dummy3 ".(Value("Dummy1")+Value("Dummy2"))) } </code>
(Achtung: "+" ist Zahlen addieren, "." ist String konkatenieren)

== April 2014==
=== Code sparen ===
Wer Definitionen wie die aus dem März zum [[Trick der Woche#Zuverlässigkeit von FS20 Schaltungen erhöhen|Abfangen von Fehlbedienungen]] verwendet, kann durch eine ELSE Erweiterung auch gleich das Auschalten erledigen.
:<code>define act_on_TV_on notify TV { if ("$EVENT" eq "on" || "$EVENT" eq "dimup") { fhem("set TV on") } else { fhem("set TV off") } }</code>

Hierdurch schaltet ON oder versehentlich zu langes Drücken (also DIMUP) den Fernseher ein, jeder ''andere'' Tastendruck (also insbesondere die OFF Taste oder zu langes Drücken der OFF Taste -> DIMDOWN) den Fernseher aus.

Voraussetzung ist, dass die Fernbedienung standardkonfiguriert ist, siehe auch nächster Tip.

=== Konfiguration eines FS20 Senders prüfen ===
Gelegentlich reagieren bestimmte notifys nicht, die von Sendern (Fernbedienungen, Sensoren oder Schaltern) ausgelöst werden sollen. Speziell bei FS20 aber auch bei HomeMatic kann das daran liegen, dass der Sender nicht sendet was man denkt. So gut wie alle FS20 Sender kennen nämlich nicht nur ON und OFF, sondern über ein Dutzend Schaltzustände. Dimmen ist einem noch hinreichend bewusst, es gibt aber auch exotische Dinge wie Ein-für-Zeitdauer, Ein-auf-alte-Helligkeit, Aus-für-Zeitdauer (nur FS20), Ein-für-Zeitdauer-dannach-alter-Zustand und vieles mehr.

Was also ein Infrarot-Bewegungsmelder bei Auslösung sendet und auch was eine Fernbedienungstaste sendet ist einstellbar. Wenn jetzt zum Beispiel an einer Fernbedienung auf Tastendruck nicht ON sondern Ein-für-Zeitdauer (ON-FOR-TIMER) gesendet wird, wird
:<code>define act_on_TV_on notify TV:on set TV on</code>
seltsamerweise nicht auslösen, obwohl die richtige Taste (und diese auch nicht zu lang) gedrückt wurde.

Auch wenn man sich sicher ist, das Richtige in die Fernbedienung/Sensoren einprogramiert zu haben, ist ein einfacher Test immer, dies mit
:<code>define act_on_TV notify TV set TV on</code>
zu prüfen. Dieses notify löst immer aus, wenn "TV" ''irgendetwas'' sendet, egal was. (Beachte: Man kann dann den Fernseher aber nicht mehr ausschalten, da auch die Austaste das notify auslöst und zum TV-Aktor nur "on" sendet). Geht die Schaltung jetzt (kann man den Fernseher also jetzt EINschalten), liegt der Verdacht nahe, dass die Konfiguration des Senders / Sensors anders ist, als man denkt. Das Logfile gibt Aufschluss, welcher Befehl tatsächlich empfangen wurde.

=== Alles in FHEM, nichts in der Fernbedienung ===
Versuche in deiner FHEM Umgebung nicht, das Verhalten von Aktoren durch entsprechende Befehle aus Sensoren oder Fernbedienungen zu steuern. An Besten senden die nur ON und OFF oder DIM, den Rest möglichst immer in FHEM erledigen.

Wer eine Lampe immer für vier Minuten einschalten will, programmiert seinen Schalter (Fernbedienung) also so, das nur "on" gesendet wird und erledigt den Rest in FHEM:
:<code>define act_on_Schalter notify Schalter set Lampe-on-for-timer 240</code>

Vielfach wird argumentiert, das eine dirkete Kopplung die Zuverlässigkeit erhöht, da bei einem Ausfall von FHEM der Aktor totzdem schaltbar sei.
Überlege, ob es hier nicht weniger komplex ist, die Zuverlässigkeit der FHEM Instanz zu erhöhen.

== März 2014==
=== Zuverlässigkeit von FS20 Schaltungen erhöhen ===
FS20 Fernbedienungen senden bei Tastendrücken von mehr als 0,4 Sekunden anstatt ON bzw. OFF DIMUP bzw DIMDOWN.

Das führt gelegentlich zu allgemein schlechter Bedienbarkeit (und schlechtem WAF), da 0,4 Sekunden relativ kurz ist und gerne aus versehen länger gedrückt wird. Das ist vor allem problematisch, wenn etwas geschaltet werden soll, was keinen Dimmer hat oder Dimmen nicht unterstützt.

Eine Konfiguration wie
:<code>define act_on_TV_on notify TV:on set TV on</code>
hat also dann den Nachteil, dass bei versehentlich zu langem Tastendruck das TV nicht angeht. Da die meisten Nutzer unbewusst dazu neigen, bei Misserfolg die selbe Taste erneut aber länger zu drücken (was erneut keinen Erfolg zeigt) ist Frustration zu erwarten.

Es kann daher speziell bei nicht dimmbaren Aktoren von Vorteil sein, auch dimmen abzufangen, z.B. durch eine zweite zusätzliche Definition:

:<code>define act_on_TV_dimup notify TV:dimup set TV on</code>

Es ist in der Regel einfacher, einige dieser zusätzlichen Definitionen einzufügen, als allen Bedienern des Systems zu erklären, dass man keinesfalls länger als 0,4 Sekunden drücken darf.

Alternativ kann man auch beide Befehle in einer Definition durch Perlbefehle {} abfangen:

:<code>define act_on_TV_on notify TV { if ("$EVENT" eq "on" || "$EVENT" eq "dimup") { fhem("set TV on") }}</code>

Andere Möglichkeiten vergleiche: [[Trick der Woche#notify durch mehrere Ereignisse auslösen lassen|Notify durch mehrere Ereignisse auslösen lassen]]

== Februar 2014==
=== Sequence nutzen ===
Man kann Aktionen statt mit einem Tastedruck auch mit einer Sequenz von Tastendücken auslösen. Das Format des Befehle ist:

:<code>define <name> sequence <re1> <timeout1> <re2> [<timeout2> <re3> ...] </code>

wobei <re1> ...<re_n> die Aktionen sind und <timeout_n> der maximale Abstand der Tastendrücke in Sekunden.

Angenommen, man wolle z.B. eine Lampe dann anschalten, wenn man zuerst Taste1 EIN, dann Taste2 AUS und dann wieder Taste1 EIN einer Fernbedienung drückt, könnte das konkret so aussehen:

:<code>define MeineLampenSequenz1 sequence Btn1:on 0.5 Btn2:off 0.5 Btn1:on</code>

Zwischen jedem der Tastendrücke darf eine halbe Sekunde Abstand sein. Diese Definition selbst löst die Lampe nicht aus, sondern definiert nur wie die Sequenz aussehen soll. Um die Lampe bei erfolgreicher Betätigung der Sequenz auch einzuschalten, bedarf es zusätzlich etwas wie:

:<code>define MeineLampe notify MeineLampenSequenz1:trigger set Lampe on</code>

Sequence kann man gut nutzen, um mit einer Fernbedienung mehr Funktionen zu schalten als Tasten zur Verfügung stehen. Ebenso könnte man damit simple Codeschlösser für Alarmanlagen bauen, z.B. um eine Anlage auszuschalten, wenn eine bestimmte Abfolge von Tasten gedrückt wird.

Je nach Funksystem nimmt die Zuverlässigkeit aber rasch ab. Angenommen im Bereich FS20 (das System ist etwas unzuverlässiger ist als z.B. HomeMatic) seien 95% aller Funktsignale ungestört übertragbar, dann würden in der Praxis von 100 Tastendrücken an einer Fernbedienung 95x Erfolg zeigen und 5x fehlschlagen; das ist sicher tolerabel.

Bei einer Sequenzlänge von nur 4 Tasten würde die kombinierte Erfolgsquote der Sequenz jedoch nur noch ca. 80% sein, zum Ausschalten einer Alarmanlage vermutlich bereits unpraktisch.

== Januar 2014==
===isday===
Bekanntlich kann man mit "isday" leicht testen ob es draussen hell ist oder nicht. isday ist eine Funktion des (automatisch geladenen) Moduls [[SUNRISE_EL]], das auch sunset und sunrise enthält.

Problematisch bei isday ist die fehlende Möglichkeit, Sonnenaufgang und Untergang einzustellen (zumindest wenn man nicht 99_SUNRISE_EL.pm verändern will): isday ist wahr, wenn die Sonne im gegebenen Breitengrad sichtbar ist. Wenn örtliche Gegebenheiten eine Anpassung erfordern, kann man sich auch ein eigenes isday basteln, in dem man sunrise und sunset verwendet und dieses mit getrennten offsets versieht.

Zuerst definiert man sich eine Variable ("dummy") der anstelle isday eingesetzt werden soll, z.B.:

:<code>define Tageslicht dummy </code>

Dann wird diese mit sunset und sunrise befüllt:

define SetDummy1 at *{sunset(-3600)} set Tageslicht hell
define SetDummy2 at *{sunrise(+1800)} set Tageslicht dunkel

Jetzt kann für jeden Wechsel ein eigener Offset gewählt werden, im Beispiel 3600 Sekunden vor Sonnenuntergang und 1800 Sekunden nach Sonnenaufgang. Anstatt das Dummy "Tageslicht" mit den Werten "hell/dunkel" zu befüllen, kann natürlich auch 1/0 oder "Tag/Nacht" etc. verwendet werden, je nach dem was bei der Anwendung besser passt.

Für höhere Ansprüche könnte hingegen das [[Twilight]]-Modul verwendet werden, das Dämmerungsstufen kennt.

===Struktur von "else if" Verzweigungen===
define ... notify ... {\
if ... {\
fhem ("... ;; ...")\
}\
elsif ... {\
fhem ("... ;; ...")\
}\
elsif ... {\
fhem ("... ;; ...")\
}\
else {\
if ... {\
fhem ("... ;; ...")\
}\
}

Achtung: es muss tatsächlich "elsif" heissen und nicht "elseif" oder "else if".

Gilt für Perl Aufrufe.
Wer aktuell in FHEM neu einsteigt kann auch den seit 2014 zur Verfügung stehenden Fhem Befehl [[DOIF]] verwenden, der bei ähnlichem Funktionsumfang wir Perl if/elsif übersichtlicher ist.

== Dezember 2013==
===notify durch mehrere Ereignisse auslösen lassen===
Bekanntermassen löst

:<code>define irgendwas notify MeinSchalter …</code>

aus, wenn irgendein Ereignis vom Sender "MeinSchalter" eintrifft.

Mit

:<code>define irgendwas notify MeinSchalter:on …</code>

wird das notify jedoch nur ausgelöst, wenn dieses Ereignis eine "on" ist.
Wenn man aber möchte, das z.B. "on" und "off" auslöst (um etwa Dim-Befehle auszuschliessen) kann dies wie folgt erreicht werden:

:<code>define irgendwas notify MeinSchalter:(on|off) …</code>

Die Klammern sind wichtig, vergleiche eine Lösung, bei der zwei Sender alternativ das notify auslösen können:

:<code>define irgendwas notify MeinSchalter:on|MeinAndererSchalter:on …</code>

Selbstverständlich geht z.B. auch folgendes:

:<code>define irgendwas notify MeinSchalter:on|MeinAndererSchalter …</code>

Hier wird ausgelöst wenn "MeinSchalter" das Ereignis "on" liefert oder "MeinAndererSchalter" irgendein Ereignis

=== Aktoren über mehrere Funkschnittstellen ansprechen ===
Falls man mehrere Funkschnittstellen zur Reichweitenverlängerung hat (CUL / CUNO etc), und ein Aktor von beiden Funkschnittstellen in etwa gleich (schlecht) erreichbar ist, mag der Wunsch aufkommen, einen Funkbefehl über beide Schnittstellen auszusenden. Dies ist bei Funkprotokollen möglich, die kein echtes Pairing der Aktoren an die Funkschnittstelle erfordern, also z.B. FS20 oder Intertechno, nicht jedoch ohne weiteres bei HomeMatic.

Problematisch ist aber, dass die Funkschnittstelle über IODev eindeutige je Aktor festgelegt werden muss, eine Zuordnung mehrerer IODevs ist nicht vorgesehen.
(wenn man IODev nicht setzt, wird per default die LETZTE definiert passende Schnittstelle verwendet)

Dieses Problem kann mit einem Trick aber umgangen werden. Und zwar legt man den Aktor 2x mit gleicher Adresse aber abweichenden Namen und IOdevs an, z.B. so:

define brenner_CUL1 FS20 11114244 11
attr brenner_CUL1 IODev CUL1
attr brenner_CUL2 room Keller

define brenner_CUL2 FS20 11114244 11
attr brenner_CUL2 IODev CUL2
attr brenner_CUL2 room Keller

Ein Befehl der Art:

set brenner_CUL1,brenner_CUL2 on

sendet den ON Befehl für den FS20 Aktor 11114244 11 jetzt tatsächlich über beide CULs aus!

Achtung: Wenn die Schnittstellen gleichschnell angebunden sind, sollte vermutlich der [[Sendpool]] verwendet werden, da die Aussendungen sonst tatsächlich gleichzeitig erfolgen könnten und sich dann gegenseitig stören würden. Dieser Trick funktioniert ausserdem nur bei Befehlen, bei denen es im Zweifel egal ist, wenn sie beim Aktor 2x eintreffen.

Bei HomeMatic lässt sich ein ähnlicher Effekt durch einrichten einer [[Virtueller Controller VCCU|virtuellen CCU]] erreichen.

=== Retrycount bei FHTs ist überflüssig===
Das von der Funktion ''autocreate'' älterer FHEM Versionen beim Anlegen von FHT80 Heizungsreglern voreingetragene attribute "retrycount" hat in den allermeisten Fällen keine Wirkung, da es NUR greift, wenn man als Funkschnittstelle eine FHZ1X00PC verwendet und dann den Softbuffer einschaltet. Selbst wenn man diese Konfiguration nutzt, will gut überlegt werden, ob die Wirkung postiv ist: Bei ungenügender Empfangslage vergrössert es Kommunikationsprobleme eventuell sogar.

Es kann also in der Regel entfernt oder auf den Wert "1" gesetzt werden.

define Heizung_Bad FHT 060d
attr Heizung_Bad retrycount 3 <=== Diese Zeile entfernen

Siehe auch:[[Kommunikationsprobleme mit FHT]]

== November 2013 ==
=== FS20 Funksteckdose sicherer schalten===
Seltsamerweise kommt es vor, das FS20 Aktoren - insbesondere die FS20 Funksteckdose - an der Grenze der Funkreichweite bestimmte Befehle eines Typs empfängt, andere aber nicht. Z.B. lässt sich die FS20 Steckdose zwar immer einschalten, aber oft nicht mehr aus (oder umgekehrt).

Gelegentlich kann man die Zuverlässigkeit erhöhen, indem man statt dem nicht funktionierenden Befehl das Gegenteil mit "for-timer 1" verwendet.

Im Fall, dass eine FS20 Steckdose sich also einwandfrei EINschalten lässt:
:<code>set SteckdoseA on</code>
aber oft ein AUSschalten mittels
:<code>set SteckdoseA off</code>
nicht funktioniert, kann man versuchen die Dose anstelle mit "off" mit dem Befehl
:<code>set SteckdoseA on-for-timer 1</code>
auszuschalten.

Analog kann man mit off-for-timer arbeiten, wenn sich Aktoren nicht einschalten lassen, ausschalten aber geht.

Achtung: Dieser Trick funtioniert ausdrücklich nur, wenn der "on/off-for-timer" Befehl im Aktor selber abgebildet wird. Daher ist der Trick vermutlich nicht auf andere Funksysteme übertragbar. z.B. unterstützt HM nur on-for-timer und Intertechno kennt keinen Timer.

=== Mehrere Geräte zugleich schalten===
Ein Ereignis soll mehrere Geräte schalten:

:<code>define act_on_Bewegungsmelder notify Bewegungsmelder set Lampe1 on;;set Lampe2 on;;set FunksteckdoseA on</code>

Aus Übersichtlichkeitsgründen können vor und nach den Semikolons auch Leerzeichen eingefügt werden (obwohl in einigen Dokumentation behauptet wird, dies dürfe man nicht machen):

:<code>define act_on_Bewegungsmelder notify Bewegungsmelder set Lampe1 on ;; set Lampe2 on ;; set FunksteckdoseA on</code>

Wenn der Schaltbefehl bei allen Geräten gleich ist, kann man wie folgt zusammenfassen:

:<code>define act_on_Bewegungsmelder notify Bewegungsmelder set Lampe1,Lampe2,FunksteckdoseA on</code>

Das Komma wird nicht [[Escapen in Perlbefehlen|escaped]] (verdoppelt), hier darf tatsächlich KEIN Leerzeichen vor oder nach dem Komma eingefügt werden.

=== Logfileinträge unterdrücken===
Das Attribute "verbose 0" verhindert, dass das Gerät Logfileinträge erzeugt.

Beispiel:

define Funksteckdose FS20 22224222 01
attr Funksteckdose verbose 0

===FHT Lazy Mode benutzen===
Es gibt wenig Gründe, den FHT "Lazy Mode" nicht zu verwenden
define Heizung_Bad FHT 060d
attr Heizung_Bad lazy

Dieser sorgt dafür, dass Temperaturänderungen (genau genommen alle Änderungen, auch z.B. date) nur übertragen werden, wenn sie nicht sowieso schon am FHT eingestellt sind und veringern die Funklast dadurch deutlich.

Siehe auch: [[Kommunikationsprobleme mit FHT]]

== Oktober 2013 ==
=== Zuverlässigkeit von Wiedereinschalten erhöhen ===
Speziell bei FS20 Aktoren ist wegen des fehlenden Rückkanals nicht leicht erkennbar, ob ein Einschaltbefehl Wirkung gezeigt hat. Das hat ganz schlechten WAF, wenn man z.B. mit einem FS20 Aktor eine Heizung ausschaltet und das Wiedereinschalten nach z.B. einer Stunde nicht klappt.

Hier empfiehlt es sich, das Ausschalten mittels
:<code>set Heizungs_schalter off-for-timer 3584</code> (= fast eine Stunde)
zu erledigen. Da bei FS20 der off-for-timer Befehl im Aktor abgewickelt wird (und nicht durch FHEM), schaltet sich der Aktor auch dann garantiert wieder ein, wenn Fhem abstürzt, eine Funkstörung vorliegt oder ähnliches. Bei Bedarf kann der Befehl off-for-timer zur Verlängerung der Ausschaltzeit wiederholt werden. Dies kann z.B. nötig sein, wenn die Ausschaltung länger als 4,5 Stunden (15360 Sekunden, der Maximalwert des Timers) dauern soll.

Achtung: dieser Trick funktioniert nur, wenn der Aktor "off-for-timer" selbst beherrscht. FS20 Geräte können das, HomeMatic können aber nur "on-for-timer". Man kann off-for-timer mit HomeMatic trotzdem verwenden, aber in diesem Fall sendet Fhem den Einschaltbefehl nach der Timerzeit. InterTechno, RSL etc, können gar keinen Timer, hier sendet Fhem immer 2 Befehle im passenden Abstand.

=== FS20 Timerzeiten ===
FS20 Timer werden in Sekunden angegeben. Es sind jedoch nicht alle Werte einstellbar. Da der Timer Wert in 7 Bit übertragen werden muss, sind nur 128 Werte möglich. Um mit diesen Werten im unteren Bereich möglichst fein aufzulösen, andererseits aber auch lange Zeiten zu ermöglichen, ist die Verteilung nicht linear. Einstellbar sind folgende Zeiten in Sekunden;

0,25 0,5 0,75 1 1,25 1,5 1,75 2 2,25 2,5 2,75 3 3,25 3,5 3,75
4 4,5 5 5,5 6 6,5 7 7,5 8 9 10 11 12 13 14 15 16 18 20 22
24 26 28 30 32 36 40 44 48 52 56 60 64 72 80 88 96 104 112
120 128 144 160 176 192 208 224 240 256 288 320 352 384 416
448 480 512 576 640 704 768 832 896 960 1024 1152 1280 1408
1536 1664 1792 1920 2048 2304 2560 2816 3072 3328 3584 3840 4096
4608 5120 5632 6144 6656 7168 7680 8192 9216 10240 11264 12288
13312 14336 15360
(etwas übersichtlicher formatiert auch [[FS20 Allgemein#ON/OFF Befehle mit Time Parameter|hier]]).

Andere Zeiten werden von Fhem gerundet. Ein neues Setzen des Timer für FS20 löscht den alten Wert.

HM-SEC-SD Rauchmelder

2014-12-16T16:58:33Z

Nielsiwilsi: /* virtueller TeamLead */

== Features ==
Das Gerät ist ein VdS-zertifizierter Rauchmelder. Mehrere Rauchmelder können unabhängig von einer Zentrale zu einer Gruppe zusammengefasst werden. Auch ohne FHEM-Zentrale meldet ein Rauchmelder seinen Alarm immer an die anderen vernetzten Rauchmelder weiter.

== Hinweise zum Betrieb mit FHEM ==
Der HM-SEC-SD Rauchmelder beherrscht kein AES. Der Betrieb ist mit [[HMLAN Konfigurator]] oder mit [[CUL]] möglich.
Das Pairing sollte wie in [[HomeMatic Devices pairen]] beschrieben durchgeführt werden.

===Teams===
Rauchmelder können/sollen in Teams gruppiert werden. Jeder SD kann einem Team angehören - und das sollte man auch einrichten. Nutzt man nur einen SD sollte man diesen mit sich selbst Teamen.

Beispiele:
nutzt man einen SD und will diese nicht mit anderen in einem team haben peert man ihm mit sich selbst. Damit ist der SD sein eigener teamLead.
<code>set Rauchmelder_Flur peerChan 0 Rauchmelder_Flur single set actor</code>.

Hat man mehrere SDs, die in einem Team zusammenfassen will wird der teamLead festgelegt und alle SDs werden mit ihm gepeert. Das Team kann jederzeit erweitert werden.
<code>set Rauchmelder_Flur peerChan 0 Rauchmelder_Flur single set actor
set Rauchmelder_Flur peerChan 0 Rauchmelder_WZ single set actor
set Rauchmelder_Flur peerChan 0 Rauchmelder_SZ single set actor
set Rauchmelder_Flur peerChan 0 Rauchmelder_KZ single set actor
...
</code>.

Nutzt man einen virtuellen TeamLead - siehe Kapitel - werden alle realen SDs mit diesem gepeert
<code>set Rauchmelder_Team peerChan 0 Rauchmelder_Flur single set actor
set Rauchmelder_Team peerChan 0 Rauchmelder_WZ single set actor
set Rauchmelder_Team peerChan 0 Rauchmelder_SZ single set actor
set Rauchmelder_Team peerChan 0 Rauchmelder_KZ single set actor
...
</code>.
entfernen eines SDs aus dem team geht mit unset. Um einen SD von einem Team in ein anderes zu transferieren muss man ihn erst mit unset aus dem Team entfernen, dann mit set in das neue Team eintragen. Einen physkalischen TeamLead kann man nur aus dem Team nehmen, indem man ihn aus allen team-mitgliedern entfernt.

Die korrekte Gruppierung sollte nach der Konfiguration durch einen teamCall geprüft werden. 
Der Betrieb mehrer Teams ist möglich, ein SD kann aber nur einem Team angehören. Will man einen SD von einem Team in ein anderes umhängen muss man ihn erste aus dem ersten Team entfernen (unset) und dann in das Neue aufnehmen.

===TeamLead===
Für ein Team muss immer ein TeamLead festgelegt werden. Anders als der Name suggeriert gibt es hier keinen Master. Sinn und Zweck ist einzig, eine Team-Adresse (HMId) festzulegen, unter der man alle SDs eines Teams ansprechen kann. Diese muss, wie alle HMIds, einzig im System sein. Um dies zu erreichen verwendet HM beim Teamen ohne Zentrale die HMId eines der SDs.
Verwendet man eine Zentrale (FHEM) kann man dies auch entzerren und einen virtuelen SD als teamLead nutzen. Siehe hierzu virtual TeamLead. 
Nutzt man nur einen einzelnen SD sollte man diesen mit sich selbst teamen.
===Kommandos===
Es gibt Team-Nachrichten die jeder SD senden kann und auf die jeder SD im Team reagiert. Jeder SD kann somit einen teamcall auslösen oder einen Alarm ausgeben. Die Kommandos werden '''nicht''' von einem SD zum anderen weitergereicht. Auch der TeamLead hat '''keine''' Sonderfunktion. Der einzelne SD sendet seine Nachricht an das Team und jeder im Team reagiert darauf. 
Es ist somit darauf zu achten, dass auch die entferntesten SDs sich gegenseitig erreichen können. 
Die Kommandos können von der Zentrale getriggert werden. Da sie unter der TeamId gesendet werden stehen sie nur bei der Komponente des Teamleads zu Verfügung. 
Dazu gehören teamCall, alarmOn und alarmOff. 
Sie stehen nur für die Entity des TeamLeads zu Verfügung.

<code>set EurerTeamleader alarmOn
set EurerTeamleader alarmOff
set EurerTeamleader teamCall</code>

'''teamCall''' testet die Zugehörigkeit und Erreichbarkeit aller SDs im Team. Alle SDs sollten 10 mal leise piepen.

Einzelne SDs kann man mit "statusRequest" abfragen.

==virtueller TeamLead==
Nutzt man einen SD kann/sollte man diesen mit sich selbst teamen (peerChan). In allen andere Fällen braucht man einen Teamlead um eine team-ID zu erhalten. Man kann hierzu einen der SDs nutzen. Wird dieser einmal ausgewechselt hat man allerdings seine team-ID verloren. 
Wenn man mit Zentrale (FHEM) arbeitet gibt es eigentlich keinen vernünftigen Grund (ausser 1-SD-Teams) einen der SDs als lead zu nutzen. Man kann genauso gut einen virtuellen Aktor bauen und diesen zum Lead machen. Das ergibt eine sauberere Struktur. 
Erzeugen eines virtuellen TeamLeads könnte so aussehen:

<code>define TeamDev CUL_HM 111111
set TeamDev virtual 1
rename TeamDev_Btn1 Rauchmelder_Team</code>

Bitte beachten: '''die HMID muss für die gesamte Installation einmalig sein'''. 
Anschließend muss man noch einen Homematic-Kanal für das Peering definieren. 
Jeder Rauchmelder muss jetzt in das Team aufgenommen werden:

<code>set Rauchmelder_Team peerChan 0 Rauchmelder_Flur single set
set Rauchmelder_Team peerChan 0 Rauchmelder_WZ single set
...
save</code>

Hierbei ist "Rauchmelder_Team" der Name des virtuellen Teamleaders und "Rauchmelder_Flur" der Name des jeweiligen Rauchmelders. 
Das "save" ist notwendig um auch die Einstellungen des virtuellen SDs im Config file zu sichern. 
Bei jedem Rauchmelder sollte den Name des virtuellen Teamleaders in der peerList stehen und beim virtuellen Teamleader jeder Rauchmelder. 
Mit teamCall sollte man die korrekte Funktion des Teams prüfen, wer will auch mit alarmOn.

==Variablen==
===Internals===
keine Spezifischen
===Readings===
Für '''jeden''' SD sind folgende Readings relevant:
teamCall from <name>:<count>
state:[off|smoke-Alarm_<count>]
smoke_detect:<von_name>
battery:[ok|low]
level:<0..200>
*'''count''' ist ein Zähler, den das Gerät liefert um neue Alarme unterschieden zu können
*'''level''' ist ein Wert zwischen 0 und 200. 200 ist alarm, 199 bedeutet Alarm, aber die Sirene ist abgeschaltet.

Beim '''Teamlead''' laufen alle Alarme auf
teamCall: from <name>:<count>
recentAlarm:<von_name>
level:<0..200>
eventNo:<count>
state:[off|smoke-Alarm_<count>]
smoke_detect:<von_name>
SDteam:[add_<name>|remove_<name>]
*'''von_name''' ist der Name des SD, der gemeldet hat.
*'''smoke_detect''' ist der aktuelle Alarm, während '''recentAlarm''' die letzte Alarmquelle anzeigt, auch wenn der Alarm schon behoben ist.
*'''SDteam''' kommt gelegentlich bei Konfigurationsereignissen zum Tragen.

===Attribute===
besondere Attribute
* '''msgRepeat''' sollte auf 1 stehen. SD ist ein burst device, wiederholen von Nachrichten belastet das HMLAN besonders. Die Team-kommandos sind hiervon nicht beeinflusst, also auch nicht das Auslösen eines Alarms.
* '''actCycle''' wird auf 99 Stunden gesetzt. Ein SD meldet sich alle 3 Tage bei der Zentrale, was der ActionDetector prüft.
* '''msgRepeat''' 1
Allgemein vorgeschlagen
'''IODev''' [HMLAN/HMUSB/CUL]
'''autoReadReg''' 5_readMissing
'''event-on-change-reading''' .*
Optional, nur als Anregung zu verstehen
'''devStateIcon off''' general_ok *:secur_alarm
'''group''' smokeDetect
'''icon''' secur_smoke_detector

==Alarme==
Meldet ein SD einen Alarm wird dieser in dem SD und im TeamLead angezeigt. 
Nutzt man HMIinfo wird ein Rauchalarm auch hier als "Error" gemeldet. In HMInfo wird dies für alle SD-teams im System gemacht.

== Nützliche Notifies ==
Codefragmente, die man einsetzen kann. Ggf. muss man etwas anpassen, zumindest können sie als Anregung nützlich sein.
* Bei Alarm email schicken und Licht im Flur anschalten
define sd.nf.report notify sdTeam:.*smoke-Alarm.* {\
<Mail versenden>;;
fhem("set LichtTreppenhaus on");;
}\

* Bei Alarm alle SDs des Team stumm schalten durch stumm Schalten eines einzelnen
define sd.nf.quiet notify sdTeam:.*level:.199 set sdTeam alarmOff

== Links ==
Anleitung [http://www.eq-3.de/Downloads/eq3/pdf_produkte/83454_HM-Sec-SD_GE_V1.4_20131011.pdf] PDF

[[Kategorie:HomeMatic Components]]
[[Kategorie:Rauchmelder]]

HM-SEC-SD Rauchmelder

2014-12-16T16:54:13Z

Nielsiwilsi: /* virtueller TeamLead */

== Features ==
Das Gerät ist ein VdS-zertifizierter Rauchmelder. Mehrere Rauchmelder können unabhängig von einer Zentrale zu einer Gruppe zusammengefasst werden. Auch ohne FHEM-Zentrale meldet ein Rauchmelder seinen Alarm immer an die anderen vernetzten Rauchmelder weiter.

== Hinweise zum Betrieb mit FHEM ==
Der HM-SEC-SD Rauchmelder beherrscht kein AES. Der Betrieb ist mit [[HMLAN Konfigurator]] oder mit [[CUL]] möglich.
Das Pairing sollte wie in [[HomeMatic Devices pairen]] beschrieben durchgeführt werden.

===Teams===
Rauchmelder können/sollen in Teams gruppiert werden. Jeder SD kann einem Team angehören - und das sollte man auch einrichten. Nutzt man nur einen SD sollte man diesen mit sich selbst Teamen.

Beispiele:
nutzt man einen SD und will diese nicht mit anderen in einem team haben peert man ihm mit sich selbst. Damit ist der SD sein eigener teamLead.
<code>set Rauchmelder_Flur peerChan 0 Rauchmelder_Flur single set actor</code>.

Hat man mehrere SDs, die in einem Team zusammenfassen will wird der teamLead festgelegt und alle SDs werden mit ihm gepeert. Das Team kann jederzeit erweitert werden.
<code>set Rauchmelder_Flur peerChan 0 Rauchmelder_Flur single set actor
set Rauchmelder_Flur peerChan 0 Rauchmelder_WZ single set actor
set Rauchmelder_Flur peerChan 0 Rauchmelder_SZ single set actor
set Rauchmelder_Flur peerChan 0 Rauchmelder_KZ single set actor
...
</code>.

Nutzt man einen virtuellen TeamLead - siehe Kapitel - werden alle realen SDs mit diesem gepeert
<code>set Rauchmelder_Team peerChan 0 Rauchmelder_Flur single set actor
set Rauchmelder_Team peerChan 0 Rauchmelder_WZ single set actor
set Rauchmelder_Team peerChan 0 Rauchmelder_SZ single set actor
set Rauchmelder_Team peerChan 0 Rauchmelder_KZ single set actor
...
</code>.
entfernen eines SDs aus dem team geht mit unset. Um einen SD von einem Team in ein anderes zu transferieren muss man ihn erst mit unset aus dem Team entfernen, dann mit set in das neue Team eintragen. Einen physkalischen TeamLead kann man nur aus dem Team nehmen, indem man ihn aus allen team-mitgliedern entfernt.

Die korrekte Gruppierung sollte nach der Konfiguration durch einen teamCall geprüft werden. 
Der Betrieb mehrer Teams ist möglich, ein SD kann aber nur einem Team angehören. Will man einen SD von einem Team in ein anderes umhängen muss man ihn erste aus dem ersten Team entfernen (unset) und dann in das Neue aufnehmen.

===TeamLead===
Für ein Team muss immer ein TeamLead festgelegt werden. Anders als der Name suggeriert gibt es hier keinen Master. Sinn und Zweck ist einzig, eine Team-Adresse (HMId) festzulegen, unter der man alle SDs eines Teams ansprechen kann. Diese muss, wie alle HMIds, einzig im System sein. Um dies zu erreichen verwendet HM beim Teamen ohne Zentrale die HMId eines der SDs.
Verwendet man eine Zentrale (FHEM) kann man dies auch entzerren und einen virtuelen SD als teamLead nutzen. Siehe hierzu virtual TeamLead. 
Nutzt man nur einen einzelnen SD sollte man diesen mit sich selbst teamen.
===Kommandos===
Es gibt Team-Nachrichten die jeder SD senden kann und auf die jeder SD im Team reagiert. Jeder SD kann somit einen teamcall auslösen oder einen Alarm ausgeben. Die Kommandos werden '''nicht''' von einem SD zum anderen weitergereicht. Auch der TeamLead hat '''keine''' Sonderfunktion. Der einzelne SD sendet seine Nachricht an das Team und jeder im Team reagiert darauf. 
Es ist somit darauf zu achten, dass auch die entferntesten SDs sich gegenseitig erreichen können. 
Die Kommandos können von der Zentrale getriggert werden. Da sie unter der TeamId gesendet werden stehen sie nur bei der Komponente des Teamleads zu Verfügung. 
Dazu gehören teamCall, alarmOn und alarmOff. 
Sie stehen nur für die Entity des TeamLeads zu Verfügung.

<code>set EurerTeamleader alarmOn
set EurerTeamleader alarmOff
set EurerTeamleader teamCall</code>

'''teamCall''' testet die Zugehörigkeit und Erreichbarkeit aller SDs im Team. Alle SDs sollten 10 mal leise piepen.

Einzelne SDs kann man mit "statusRequest" abfragen.

==virtueller TeamLead==
Nutzt man einen SD kann/sollte man diesen mit sich selbst teamen (peerChan). In allen andere Fällen braucht man einen Teamlead um eine team-ID zu erhalten. Man kann hierzu einen der SDs nutzen. Wird dieser einmal ausgewechselt hat man allerdings seine team-ID verloren. 
Wenn man mit Zentrale (FHEM) arbeitet gibt es eigentlich keinen vernünftigen Grund (ausser 1-SD-Teams) einen der SDs als lead zu nutzen. Man kann genauso gut einen virtuellen Aktor bauen und diesen zum Lead machen. Das ergibt eine sauberere Struktur. 
Erzeugen eines virtuellen TeamLeads könnte so aussehen:

<code>define TeamDev CUL_HM 111111
set TeamDev virtual 1
rename TeamDev_Btn1 Rauchmelder_Team</code>

Bitte beachten: '''die HMID muss für die gesamte Installation einmalig sein'''. 
Anschließend muss man noch einen Homematic-Kanal für das Peering definieren. 
Jeder Rauchmelder muss jetzt in das Team aufgenommen werden:

<code>set Rauchmelder_Team peerChan 0 Rauchmelder_Flur single set
set Rauchmelder_Team peerChan 0 Rauchmelder_WZ single set
...
save</code>.

Hierbei ist "Rauchmelder_Team" der Name des virtuellen Teamleaders und "Rauchmelder_Flur" der Name des jeweiligen Rauchmelders. 
Das "save" ist notwendig um auch die Einstellungen des virtuellen SDs im Config file zu sichern. 
Bei jedem Rauchmelder sollte den Name des virtuellen Teamleaders in der peerList stehen und beim virtuellen Teamleader jeder Rauchmelder. 
Mit teamCall sollte man die korrekte Funktion des Teams prüfen, wer will auch mit alarmOn.

==Variablen==
===Internals===
keine Spezifischen
===Readings===
Für '''jeden''' SD sind folgende Readings relevant:
teamCall from <name>:<count>
state:[off|smoke-Alarm_<count>]
smoke_detect:<von_name>
battery:[ok|low]
level:<0..200>
*'''count''' ist ein Zähler, den das Gerät liefert um neue Alarme unterschieden zu können
*'''level''' ist ein Wert zwischen 0 und 200. 200 ist alarm, 199 bedeutet Alarm, aber die Sirene ist abgeschaltet.

Beim '''Teamlead''' laufen alle Alarme auf
teamCall: from <name>:<count>
recentAlarm:<von_name>
level:<0..200>
eventNo:<count>
state:[off|smoke-Alarm_<count>]
smoke_detect:<von_name>
SDteam:[add_<name>|remove_<name>]
*'''von_name''' ist der Name des SD, der gemeldet hat.
*'''smoke_detect''' ist der aktuelle Alarm, während '''recentAlarm''' die letzte Alarmquelle anzeigt, auch wenn der Alarm schon behoben ist.
*'''SDteam''' kommt gelegentlich bei Konfigurationsereignissen zum Tragen.

===Attribute===
besondere Attribute
* '''msgRepeat''' sollte auf 1 stehen. SD ist ein burst device, wiederholen von Nachrichten belastet das HMLAN besonders. Die Team-kommandos sind hiervon nicht beeinflusst, also auch nicht das Auslösen eines Alarms.
* '''actCycle''' wird auf 99 Stunden gesetzt. Ein SD meldet sich alle 3 Tage bei der Zentrale, was der ActionDetector prüft.
* '''msgRepeat''' 1
Allgemein vorgeschlagen
'''IODev''' [HMLAN/HMUSB/CUL]
'''autoReadReg''' 5_readMissing
'''event-on-change-reading''' .*
Optional, nur als Anregung zu verstehen
'''devStateIcon off''' general_ok *:secur_alarm
'''group''' smokeDetect
'''icon''' secur_smoke_detector

==Alarme==
Meldet ein SD einen Alarm wird dieser in dem SD und im TeamLead angezeigt. 
Nutzt man HMIinfo wird ein Rauchalarm auch hier als "Error" gemeldet. In HMInfo wird dies für alle SD-teams im System gemacht.

== Nützliche Notifies ==
Codefragmente, die man einsetzen kann. Ggf. muss man etwas anpassen, zumindest können sie als Anregung nützlich sein.
* Bei Alarm email schicken und Licht im Flur anschalten
define sd.nf.report notify sdTeam:.*smoke-Alarm.* {\
<Mail versenden>;;
fhem("set LichtTreppenhaus on");;
}\

* Bei Alarm alle SDs des Team stumm schalten durch stumm Schalten eines einzelnen
define sd.nf.quiet notify sdTeam:.*level:.199 set sdTeam alarmOff

== Links ==
Anleitung [http://www.eq-3.de/Downloads/eq3/pdf_produkte/83454_HM-Sec-SD_GE_V1.4_20131011.pdf] PDF

[[Kategorie:HomeMatic Components]]
[[Kategorie:Rauchmelder]]