Archiv der Kategorie: Projekte

Projekte mithilfe von FHEM, Raspberry Pi und der Fritzbox

Projekte

Bild an Smartphone bei Auslösen der Haustürklingel

17 Kommentare

Bild beim Auslösen der Haustürklingel ans Smartphone übertragen

Oftmals wird die Haustürklingel betätigt, während man nicht zu Hause ist. Im Gegensatz zum Telefon hinterlässt die Person aber keine Rufnummer anhand derer wir sie identifizieren könnten.

Mithilfe einer Webcam und eines Türklingelsensors soll ein Foto in dem Augenblick erstellt werden, wenn die Person an der Haustüre den Klingelknopf gedrückt hat. Nun wird das Foto per Pushnachricht an das Smartphone übertragen.

Hard-und Software-Voraussetzungen

Zuerst brauchen wir einen Raspberry Pi mit entsprechendem Netzteil. Hierzu habe ich auch entsprechende Empfehlungen gegeben.
Genauso sollte man sich über die Vernetzung Gedanken machen, ob man die Raspberry Pis per Netzkabel oder per WLAN anbinden möchte. Dafür habe ich hier in meinen Artikeln über die Grundkonfiguration Tipps gegeben:

Klingelsignal-Sensor

Damit beim Drücken des Klingelknopfes ein Signal an die Hausautomatisierungs-Software FHEM übertragen werden kann, brauchen wir den passenden Sensor. Für das Haussteuerungsprotokoll FS20 ist das die mittlerweile kaum mehr erhältliche FS20 KSE.

Diese bekommt man noch in Restposten bei Amazon, wurde aber offensichtlich abgekündigt. Dagegen gibt es für Homematic ein Allround-Modul, mit dem auf Eingangsspannungen von bis zu 20V reagiert und daraufhin ein Signal an die Haussteuerung übertragen werden kann:

Mit leichten Anpassungen ist dies mit dem Homematic-Modul ebenfalls leicht möglich.

Outdoor-Webcam für die Hausautomatisierung

Im Grunde genommen klappt es mit jeder Outdoor-Webcam. Wenngleich es schon sehr günstige Webcams für den Außenbereich gibt, so wird man jedoch sehr schnell erkennen,  dass es massive Qualitätsunterschiede gibt.

Auf jeden Fall ist das Wichtigste an einer Outdoor-Webcam, dass sie für den Außenbereich auch auf Dauer geeignet ist und nicht bereits nach zwei Jahren den Betrieb einstellt. Entsprechend ist ein weiteres Kriterium, wie sich die Kamera bei schlechten Lichtverhältnissen schlägt. Dafür haben die besseren Geräte Infrarot-LEDs, mit deren Hilfe sehr brauchbare Schwarz-Weiß-Bilder in der Dunkelheit gelingen. Im Gegensatz zu den beiden gerade genannten Qualitätsmerkmalen spielt die Auflösung der Kamera eine eher untergeordnete Rolle. Full-HD als Auflösung wäre zwar schön, ist aber unnötig. Folglich ist HD-Auflösung (1280 x 720) völlig ausreichend. In erster Linie wollen wir ja lediglich ein Foto machen, anhand dessen wir eine Person erkennen können. Des Weiteren ist der Vorteil einer nicht zu hohen Auflösung der, dass die Kamera bei schlechten Lichtverhältnissen weniger verrauschte Bilder liefert.

Hierzu habe ich mich nach langer Recherche auf folgende Outdoor-Webcam festgelegt:

Die Instar IN-5907HD ist absolut robust und macht wirklich ansehnliche Fotos, auch und gerade bei schlechteren Lichtverhältnissen.

Push-Nachrichtendienst auswählen

Zuerst müssen wir uns auf einen Nachrichtendienst festlegen, der Bilder und Text an ein Smartphone übertragen kann. Die meisten von uns denken jetzt ganz automatisch an WhatsApp. Zuerst war das auch mein Ansatz und eine solche Integration hat auch bis Anfangs des Jahres 2017 funktioniert. Leider hat WhatsApp begonnen, nur noch zertifizierte Geräte für den Nachrichtendienst zuzulassen. iPhone bzw. Android sowie Windows Mobile Geräte funktionieren mit WhatsApp einwandfrei. Schwieriger wird es, wenn man selbst ein Gerät an WhatsApp koppeln wird. Ich habe mich ziemlich lange mit der Integration von WhatsApp beschäftigt. Nachdem mir WhatsApp meine Rufnummer das x-te gesperrt hatte, habe ich diesen Nachrichtendienst für die Einbindung in die Haussteuerung ad acta gelegt.

Es gibt einige Alternativen für Push-Nachrichtendienste. Wir suchen jedoch einen Nachrichtendienst, für den es entsprechende Programmier-Schnittstellen (APIs) gibt. Aus meiner Sicht gibt es hier zwei Alternativen zu WhatsApp:

Beide Nachrichtendienste sind gleichermassen für unser Vorhaben geeignet. Die Smartphone-App für Pushover ist allerdings kostenpflichtig. Demgegenüber ist Telegram völlig kostenlos und bietet einige andere Vorteile.

Push-Nachrichtendienst Telegram mit Bot

Im Folgenden verwenden wir Telegram als Nachrichtendienst. Die Apps für Smartphones (iOS, Android, Windows Phone) sind kostenlos. Darüberhinaus gibt es Einbindung in alle gängigen Desktop Betriebssysteme wie Windows, macOS und Linux.

Den größten Vorteil, den ich aber sehe, ist die Möglichkeit, einen Bot zu erstellen.  Dazu ein paar erklärende Worte. Normalerweise ist die Funktionalität einer Push-Nachricht wie folgt: Jeder Teilnehmer an dem Nachrichtendienst ist über seine Telefonnummer angemeldet. Normalerweise gibt es eine 1:1-Beziehung zwischen dem Gerät, dem Smartphone und dieser Telefonnummer. Dementsprechend hieße das für die Einbindung des Nachrichtendienstes für FHEM, dass wir eine eigene Telefonnummer für die Haussteuerung bräuchten, unter der FHEM erreichbar wäre. Anders ausgedrückt soll ja FHEM Nachrichten sowohl empfangen als auch senden können. Natürlich könnten wir einen Surfstick für den Raspberry Pi besorgen und dort eine eigene Simkarte betreiben. Demgemäß würden aber nicht unwesentliche Zusatzkosten entstehen. Dieses Geld müssen wir aber gar nicht ausgeben.

Was ist ein Bot?

Die Einbindung in die Haussteuerung FHEM kann man beim Nachrichtendienst Telegram mit einem sehr einfachen Bot bewerkstelligen. Dieser Bot (vom englischen Wort robot) soll in unserem Fall einfach als virtueller Account arbeiten. Später wollen wir uns auf diesen von FHEM aus verbinden. Anders ausgedrückt erstellen wir über unseren echten Telegram-Account (ebenso wie bei WhatsApp registriert mit unserer Smartphone-Telefonnummer) einen virtuellen Account, den Bot. Normalerweise kann man mit einem solchen Bot komplexe Antwortverhalten einstellen. Im Gegensatz dazu nutzen wir den Bot nur als weiteren Account. Die Logiken werden nicht im Bot selbst, sondern in der Haussteuerung implementiert.

Einen Bot anlegen

Zuerst brauchen wir einen Account für Telegram. Hierzu laden wir im Falle eines Android-Smartphones aus dem Google Play Store die App Telegram und für iPhones über iTunes die App Telegram Messenger herunter.

Telegram iTunes

Nachdem die App installiert und konfiguriert auf die Handynummer gekoppelt ist, können wir loslegen. Für die nächsten Schritte müssen wir den virtuellen Account anlegen, den wir an FHEM koppeln werden. Dazu gibt es einen virtuellen Ansprechpartner namens Botfather. Mit diesem Botfather führen wir ein Konversation über bestimmte Befehle.

Telegram Botfather

Dazu laden wir den User @botfather ein, mit uns zu „sprechen“. Wir drücken auf Starten.

Telegram Botstart

Daraufhin erscheint eine Auflistung von Befehlen, die unser Botfather versteht.

Telegram Botstart

Mit /newbot legen wir einen neuen Bot an. Wir werden nach einem Namen gefragt und wir nennen ihn beispielsweise MyFHEM:

Telegram newbot

Nun werden wir noch nach einem Accountnamen gefragt. Dieser muss eindeutig sein, im Gegensatz zu dem gerade eingegebenen Bot-Namen. Es kann also sein, dass der von uns eingegebene Name zunächst abgelehnt wird, hier müssen wir also kreativ sein. Der Name des Accounts muss nur auf „bot“ enden.

Telegram newbot MyFHEMresponsebot

In der letzten Antwort können wir das wichtige Token erkennen, das für die Einrichtung in FHEM gebraucht wird. Mit Klick auf den Link  t.me/MyFHEMresponsebot laden wir den erzeugten Bot und können ihn über Starten am unteren Bildschirmrand starten.

Telegram Bot starten

Telegram-Bot in FHEM einbinden

Danach gehen wir in FHEM und legen mit den Token-Daten aus der letzten Antwort des Bots (bitte in der ersten Zeile die Token-Werte aus der letzten Antwort übernehmen)

define teleBot TelegramBot 3071xxxxx:AAGKh5o-FfOK_2EUCy-xxxxxxxxxxxx
attr teleBot pollingTimeout 120

ein neues Device an und stellen mit dem zweiten Befehl die Timeout-Zeit ein. Nach den beiden Befehlen drücken wir unter dem Fhem-Symbol auf Save Config. Sofort können wir ein neues Gerät erkennen und dort auch über den Status erfahren, ob wir mit dem Bot gekoppelt sind. Der Status sollte durch das obige Starten auf Polling wechseln.

FHEM Telebot anlegen

Nun sind wir mit FHEM gekoppelt. Dies können wir gleich testen, in dem wir von unserem Smartphone eine Nachricht an unseren Bot schreiben.

Telebot Testmessage

Diese Nachricht sollten wir daraufhin in FHEM in den readings zu unserem neuen Gerät sehen:

Telegram Bot Readings

Im Folgenden können wir also sicher sein, dass FHEM an den virtuellen Telegram-Account angebunden ist. Aber eines fehlt noch: Damit wir Nachrichten und Bilder an unser Smartphone schicken können, müssen wir noch unseren Standard-Account angeben, an den wir senden wollen. Das ist also unser eigener Telegram-Account, von dem wir den Bot eingerichtet haben. Demzufolge setzen wir mit

attr teleBot defaultPeer Vorname_Nachname

den default peer (auf den Wert, den wir gerade in den Readings unter msgPeer sehen) und können nun mit

set teleBot send Nachricht angekommen

eine Nachricht zurück an unser Smartphone schicken. Auf unserm Smartphone kommt prompt die Nachricht wieder an:

Telebot Nachricht angekommen

Webcam in FHEM anlegen

Damit wir das Bild bei Betätigen der Haustürklingel an das Smartphone übertragen können, müssen wir die Webcam auch in FHEM anlegen. Hierfür legen wir in der Konfigurationsdatei fhem.cfg neue Einträge an. User und Passwort müssen natürlich angepasst werden.

define WebCamHaustuere IPCAM 192.168.188.71:80
attr WebCamHaustuere delay 0
attr WebCamHaustuere group Webcams
attr WebCamHaustuere icon it_camera
attr WebCamHaustuere path tmpfs/snap.jpg?usr=admin&pwd=instar
attr WebCamHaustuere snapshots 1
attr WebCamHaustuere storage /opt/fhem/www/webcam/WebCamHaustuere

Dadurch haben wir jetzt die Webcam per Modul in FHEM integriert. Wir können nun über den Befehl

get WebCamHaustuere image

das aktuelle Bild von der Webcam holen und in dem konfigurierten Verzeichnis /opt/fhem/www/WebCamHaustuere ablegen. Da das Verzeichnis /opt/fhem/www im Standard schon existiert, müssen wir hier nichts weiter tun. Wir sehen, dass das Verzeichnis WebCamHaustuere angelegt wurde, falls es noch nicht existiert hat. Darin befinden sich nun zwei Dateien, von denen für uns die Datei WebCamHaustuere_snapshot.jpg wichtig ist.

FS20 Klingelsensor KSE in FHEM anlegen

Nun brauchen wir nur noch den Klingelsensor selbst. Wir brauchen den Klingelsensor FS20 KSE lediglich mit dem Klingeldraht verbinden, der selbst in modernen Häusern immer noch verbaut wird.

Durch folgende, einfache Konfiguration lässt sich der Klingelsensor in FHEM einbinden:

# Tuerklingelsensor
define FS20_Tuerklingel FS20 12341234 00
attr FS20_Tuerklingel IODev CUL
attr FS20_Tuerklingel alias Tuerklingel
attr FS20_Tuerklingel devStateIcon on:rc_dot@green off:rc_dot@grey
attr FS20_Tuerklingel icon phone_missed_out
attr FS20_Tuerklingel model fs20kse
define FileLog_FS20_Tuerklingel FileLog ./log/FS20_Tuerklingel-%Y-%m-%V.log FS20_Tuerklingel
attr FileLog_FS20_Tuerklingel logtype text

Über das FS20 Zahlensystem habe ich im Artikel Kalenderabhängige Schaltung einer FS20-Steckdose bereits geschrieben. Die Vorgehensweise bei der Einbindung des FS20 Klingelsensors unterscheidet sich kaum von der Einbindung einer dort beschriebenen Funksteckdose.

Versenden von Text und Bild bei Auslösung durch den Klingelsensor

Schließlich haben wir eigentlich alles, um die gewünschte Funktionalität umzusetzen. Wir haben den Klingelsensor eingebunden, der bei Auslösen der Haustürklingel ein Signal an FHEM schickt. Weiters haben wir die Outdoor-Webcam an FHEM gekoppelt, wo wir durch einen einfachen Befehl das aktuelle Bild holen und im Filesystem des Raspberry Pi ablegen. Ausserdem haben wir FHEM über einen Messagedienst-Bot angebunden. Was uns jetzt nur noch fehlt, ist die Verbindung dieser drei Dinge.

Das ist denkbar einfach. Wir brauchen lediglich ein Notify in der zentralen Konfigurationsdatei fhem.cfg erstellen. Hiermit wird eine Push-Nachricht mit dem Text „An der Haustüre hat es geklingelt" an das Smartphone geschickt. Folglich wird über das Hilfsmodul IPCAM ein Bild geholt und sogleich dieses ebenfalls per Push-Nachricht ans Smartphone geschickt. Das geschieht mit folgenden Einträgen:

define Haustuerklingel_notify notify FS20_Tuerklingel:on {\
        { fhem("set teleBot send Jemand hat an der Haustüre geklingelt");; \
          fhem("get WebCamHaustuere image");; \
          fhem("set teleBot sendPhoto /opt/fhem/www/WebCamHaustuere/WebCamHaustuere_snapshot.jpg");; \
}

Das Ergebnis sieht am Smartphone dann so aus:

FHEM Klingelsensor Botnachricht

Zuletzt aktualisiert am 05.02.2017.

Projekte

Meine FHEM Projekte

Schreibe einen Kommentar

Meine FHEM Projekte

Hier gebe ich eine Auflistung meiner FHEM Projekte, die ich mit dem Raspberry Pi mit der Haussteuerung FHEM umgesetzt habe. Ausserdem beschreibe ich in jedem dieser Artikel meine Projekte Schritt-für-Schritt:

 

Zuletzt aktualisiert am 09.07.2017.
Projekte

Anwesenheitserkennung über Beacons

20 Kommentare

Anwesenheitserkennung über Beacons

Oftmals würde man gerne alle Geräte automatisch ausschalten wollen oder die Heizung zurückregeln, wenn niemand zuhause ist.  Aber wie können wir feststellen, ob das eigene Heim wirklich verwaist ist?
Im Artikel Anwesenheitserkennung über GPS-Position haben wir einen anderen Ansatz verfolgt.

Wir wollen hier nicht auf die Mittel von Geofencing zurückgreifen, sondern mit sog. Bluetooth Beacons oder Bluetooth LE Tags arbeiten. In diesem Falle handelt es sich um einen sehr kleinen Sender, den man normalerweise am Schlüsselbund bei sich trägt. Jedenfalls hat man dieses Gerät immer bei sich, also könnte die Haussteuerung diesen Beacon über Bluetooth erkennen und somit die Anwesenheit feststellen.

Der Vorteil dieses Ansatzes ist, dass der Beacon eigenständig ist. Man muss ihn im Gegensatz zum Smartphone nie laden und die Batterie hält ewig. Die Reichweite beträgt in etwa 30m (ohne Hindernisse).

Hard-und Software-Voraussetzungen

Zuerst brauchen wir einen Raspberry Pi mit entsprechendem Netzteil. Hierzu habe ich auch entsprechende Empfehlungen gegeben.
Genauso sollte man sich über die Vernetzung Gedanken machen, ob man die Raspberry Pis per Netzkabel oder per WLAN anbinden möchte. Dafür habe ich hier in meinen Artikeln über die Grundkonfiguration Tipps gegeben:

Bluetooth-Hardware-Voraussetzungen

Um mit Beacons arbeiten zu können müssen wir den Raspberry Pi mit einem entsprechenden Bluetooth USB-Dongle nachrüsten. Nicht jeder Bluetooth Dongle funktioniert hier, er muss Bluetooth 4.0 beherrschen, denn wir wollen die LE (Low Energy) Technologie benutzen. Gute Erfahrungen habe ich mit folgendem USB-Dongle gemacht:

Dieser lässt sich problemlos in den Raspberry Pi einbinden und wird von Raspbian Linux-Derivat erkannt.

Bluetooth-Dongle installieren

Sobald wir den Bluetooth-Dongle in den Raspberry Pi in einen USB-Port gesteckt haben, sollte dieser als USB-Gerät auftauchen. Hierfür schreiben wir auf der Konsole

lsusb

und sehen uns das Ergebnis an:Bluetooth lsusb

In unserem Falle taucht der Bluetooth-Dongle als Device 004 auf. Ohne Installation der notwendigen Pakete können wir jetzt aber noch nicht wirklich viel damit anfangen. Mit folgenden Kommandos holen wir uns die notwendige Software auf den Raspberry Pi:

sudo apt-get install bluetooth bluez-hcidump bluez blueman

Nach einem Restart über

sudo shutdown -r now

sollte die notwendige Software auf dem Rapberry Pi installiert sein. Aber das reicht noch nicht aus, um Beacons wie im Folgenden entsprechend zu lokalisieren. Dazu gleich mehr.

Passende Beacons

Grundsätzlich sollten alle Beacons bzw. Bluetooth LE Tags für unsere Funktionalität passen. Meistens werden diese als Schlüsselfinder verkauft. Ich habe hier nach einer sehr günstigen Variante gesucht, die auch nicht wirklich viel können muss. Das Entscheidende ist eher das Thema Reichweite. Ich habe es mit folgenden Beacons erfolgreich getestet:

Ferner gibt es diese auch in günstigeren Mehrfachpacks. Damit das Ganze funktioniert, sollte auch jeder in der Familie so einen Beacon an seinem Schlüsselanhänger haben.

Um die gezeigten Beacons in Betrieb zu nehmen, zieht man die durchsichtige Plastiklasche aus dem Gerät und setzt die Batterie damit aktiv.

Inbetriebnahme der Beacons

Zuerst sollten wir uns mit der Grundlage unserer neuen Funktionalität beschäftigen. Dies ist das hcitool, das einen permanenten LE-Scan durchführt. Führen wir einmal in der Konsole das Kommando

sudo hcitool lescan

aus. Nachdem hier Zeile für Zeile mit MAC-Adressen gescannter Bluetooth-Geräte nach unten scrollt, halten wir einmal diesen Endlos-Prozess mit der Tastenkombination STRG+C bzw. auf dem Mac mit ctrl+C an.

sudo hcitool lescan

Sobald unser Beacon aufgelistet wurde, halten wir die Endlosausgabe wie gerade beschrieben an. Solange wir nur einen Beacon haben, ist dieser leicht zu identifizieren. Sobald wir mehrere in Betrieb nehmen, müssen wir diesen Schritt wiederholen und uns jeweils die MAC-Adresse des Beacons aufschreiben und dem richtigen zuordnen. In unserem Falle merken wir uns die MAC-Adresse 7C:2F:80:AD:C2:0D.

Hilfsskript für Erreichbarkeit eines speziellen Beacons

Da das hcitool nur einen Endlos-Scan ausführen kann und manuell unterbrochen werden muss, müssen wir uns ein Hilfsskript basteln, das für eine spezielle MAC-Adress nachsehen kann, ob der Beacon erreichbar ist oder nicht.
Dazu kommt noch ein weiteres Problem, das erst auftritt, sobald wir mehr als einen Beacon besitzen. Damit habe ich mich eine Weile herumgeplagt, denn dann läuft der Scan mehr als einmal gleichzeitig.  Folglich kommt es zu einem Fehler, weil der Bluetooth USB-Dongle im Raspberry Pi bereits mit dem Scan auf LE Geräte beschäftigt ist. Denn dann meldet uns das hcitool folgenden Fehler:

Set scan parameters failed: Input/output error

Dies müssen wir in unserem Hilfsskript entsprechend berücksichtigen. Hierzu erstellen wir ein Shell-Skript, das wir im Verzeichnis /opt/fhem erstellen. Dementsprechend kopieren wir uns den unten aufgelisteten Code in eine leere Datei namens lescan.sh. Hierfür können wir den kleinen Editor nano benutzen und die neue Datei mit

cd /opt/fhem
nano lescan.sh

erstellen. Weiters kopieren wir den unten stehenden Code in den geöffneten Editor und speichern ihn mit STRG+O ab. Schließlich beenden wir den Editor mit STRG+X.
Im Anschluß der Code:

#!/bin/bash
devicefile=/tmp/le_device.$$
hcitool lescan 2>&1 > $devicefile & sleep 7
pkill --signal SIGINT hcitool
sleep 1
errorresult=$(grep -c "Input/output error" $devicefile)
if [ $errorresult -gt 0 ]; then
        echo 2
else
        scanresult=$(grep -c $1 $devicefile)
        if [ $scanresult -gt 0 ]; then
                echo 1
        else
                echo 0
        fi
fi
rm $devicefile

Wir müssen aber dieses Skript noch ausführbar machen und dafür sorgen, dass der User fhem das hcitool ausführen darf. Zuerst setzen wir die Zugriffsrechte für die neue Datei mit:

chown fhem:dialout lescan.sh
chmod 777 lescan.sh

Daraufhin brauchen wir noch den Eintrag in der sudoers-Datei, was wir mit dem Befehl

sudo visudo

erledigen. Dort fügen wir die Zeilen an

fhem ALL=(ALL) NOPASSWD: /usr/bin/hcitool
fhem ALL=(ALL) NOPASSWD: /opt/fhem/lescan.sh

und speichern die Datei wieder mit STRG+O ab. Schließlich beenden wir den Editor mit STRG+X. Dadurch ist der Benutzer fhem, unter dem die Haussteuerung läuft, berechtigt, das gerade erstellte Shell-Skript auszuführen. Da im Skript lescan.sh aber das hcitool ausgeführt wird, muss dieses ebenfalls berechtigt werden. Das erledigt die erste Zeile.

Einbinden in FHEM

Im Folgenden müssen wir jetzt nur noch eine Hilfsfunktion für FHEM erstellen, die das gerade erzeugte Shell-Skript aufruft. Hierzu erstellen wir ein neues Include, das wir im Verzeichnis /opt/fhem/FHEM erstellen. Dementsprechend kopieren wir uns den unten aufgelisteten Code in eine leere Datei namens 99_BTLEscanUtils.pm. Hierfür können wir den kleinen Editor nano benutzen und die neue Datei mit

cd /opt/fhem/FHEM
nano 99_BTLEscanUtils.pm

erstellen. Weiters kopieren wir den unten stehenden Code in den geöffneten Editor und speichern ihn mit STRG+O ab. Schließlich beenden wir den Editor mit STRG+X.
Im Anschluß der Code:

##############################################
# $Id: 99_BTLEscanUtils.pm 2691 2017-01-06 Martin Koch $
package main;

use strict;
use warnings;
use Digest::MD5 "md5_hex";
use HttpUtils;

sub
BTLEscanUtils_Initialize($$)
{
  my ($hash) = @_;
}

sub
get_LEBT_Status($$) 
{
  my ($le_device,$statusvar) = @_;
  
  my $semaphor_file ="/opt/fhem/log/lestatus_semaphor";
  my $oldvalue = ReadingsVal($statusvar,"state","absent");
  my @resultstrings = ();
  my $resultstring = "";
  my $exitcount = 0;	
  my $return = 2;
  
  # wait for unique le process
  while(-e $semaphor_file) {
    sleep(5);
                $exitcount += 1;
                if($exitcount > 10) {
                  unlink $semaphor_file;
                  return $oldvalue;
                }
  }
  open(SEM,">$semaphor_file");
    print SEM "Semaphor written by $le_device for $statusvar";
  close(SEM);
    
  @resultstrings = `sudo /opt/fhem/lescan.sh $le_device`;
  foreach my $resultstring (@resultstrings) {
    if($resultstring =~ /(\d)*/) {
      $return = $1;
    }
  }

  if($return > 1) {
    $return = $oldvalue;
  }

  # delete semaphor
  unlink $semaphor_file;
  return $return;
}

1;

Nun müssen wir nur noch eine Definition für die Anwesenheitsüberwachung per PRESENCE-Konstrukt in die Konfigurationsdatei fhem.cfg einbauen, die bei regelmässig die Anwesenheit durch Aufrufen der gerade erstellten Hilfsmethode überprüft:

define Martin_BT_Tag PRESENCE function {get_LEBT_Status("7C:2F:80:AD:C2:0D","Martin_BT_Tag")} 60 180
attr Martin_BT_Tag devStateIcon present:rc_dot@green absent:rc_dot@red
attr Martin_BT_Tag group Anwesenheitsstatus_Martin
attr Martin_BT_Tag room Anwesenheit
define FileLog_Martin_BT_Tag FileLog ./log/Martin_BT_Tag-%Y-%m-%V.log Martin_BT_Tag.*
attr FileLog_Martin_BT_Tag logtype text

Nun schaltet sich die Variable Martin_BT_Tag auf present, sobald der Beacon in Reichweite des Raspberry Pi ist. Falls unser Wunderkästchen den Bluetooth LE-Dongle nicht per Scan findet, schaltet sich die Variable Martin_BT_Tag auf absent.

FHEM Beacon

Wir zeigen dies mit unseren Define-Attributen mit einem grünen bzw. roten Punkt an.

Zusammenfassung

In unserem Beispiel für die Anwesenheitserkennung per Beacon passiert also folgendes: Sobald sich dieser Bluetooth LE-Dongle in Reichweite unseres Raspberry Pi befindet, soll eine Variable schalten. Nun könnten wir natürlich auf diese Wertänderung genauso reagieren wir bei der Anwesenheitserkennung über GPS-Position und beispielsweise die Heizung einschalten. Oder wir könnten eine Steckdose automatisch einschalten.

Damit das Ganze zuverlässiger wird, könnten wir jetzt noch die Anwesenheit zusätzlich über den WLAN-Status unseres Smartphones überprüfen und die beiden Status kombinieren. Sobald beide Variablen auf absent stehen, können wir sicher gehen, dass sich die Person wirklich nicht mehr zuhause befindet. Aber dazu mehr in einem weiteren Artikel.

 

Zuletzt aktualisiert am 02.05.2017.
Projekte

Anwesenheitserkennung über GPS-Position

10 Kommentare

Hallo, jemand zuhause?

Oftmals würde man gerne alle Geräte automatisch ausschalten wollen oder die Heizung zurückregeln, wenn niemand zuhause ist.  Aber wie können wir feststellen, ob das eigene Heim wirklich verwaist ist?
Umgekehrt hätten wir gerne, dass sich beispielsweise die Heizung einschaltet, wenn man weg war und gleich nach Hause kommen wird.

In beiden Fällen der Anwesenheitserkennung können wir auf die Mittel von Geofencing zurückgreifen.
Anwesenheitserkennung über GPS-Position weiterlesen →

Projekte

Über Google Kalender Ereignisse schalten

6 Kommentare

Einbindung des eigenen Google Kalender

In Zeiten des Smartphones nutzen auch sehr viele die integrierte Terminverwaltung. Hierzu gibt es mehrere Varianten, die Termine zu pflegen.  Sobald man nicht nur das Smartphone zur Terminverwaltung nutzt, sondern noch ein Tablet oder einen PC, so macht es Sinn, die Termine zentral zu verwalten. Hierzu nutze ich den Google Kalender, da die Einbindung in beinahe alle Applikationen problemlos möglich ist.

In Verbindung mit der Haussteuerung FHEM ist es ein Leichtes, den Google Kalender einzubinden.

Was ist das Ziel?

Über die Einbindung des Google Kalender wollen wir in FHEM eine oder mehrere Dummyvariablen setzen. Beispielsweise wollen wir eine Variable für „Urlaub“ setzen. Aufgrund eines Termineintrags im Google Kalender geht die Variable Urlaub_dummy von nein auf ja. Nun könnte man aufgrund der Änderung dieser Variable verschiedene Aktionen auslösen. Dementsprechend könnten wir im Winter die Heizkörper im Hobbyraum für diesen Tag einschalten oder die Medienzentrale im Wohnzimmer schon am Vormittag einschalten anstatt abends.

Hard-und Software-Voraussetzungen

Zuerst brauchen wir einen Raspberry Pi mit entsprechendem Netzteil. Hierzu habe ich auch entsprechende Empfehlungen gegeben.
Genauso sollte man sich über die Vernetzung Gedanken machen, ob man die Raspberry Pis per Netzkabel oder per WLAN anbinden möchte. Dafür habe ich hier in meinen Artikeln über die Grundkonfiguration Tipps gegeben:

Einrichtung des Google Kalenders

Wir wollen unseren Google Kalender in FHEM integrieren. Oftmals ist es aber sinnvoll einen zweiten Google Kalender zu benutzen, um die Termine für die Haussteuerung von normalen Terminen zu unterscheiden. Das ist wirklich ganz einfach:

Google Anmeldung

Man meldet sich bei Google über sein Profil an. Falls noch nicht vorhanden, erstellt man ein eigenes Profil. Anschließend ruft man den Online-Kalender auf. Dort erstellen wir einen eigenen Kalender namens „Haussteuerung„.

In vielen Beschreibungen der Einbindung wird empfohlen, den Kalender einfach öffentlich zu machen, damit die Haussteuerung auch darauf problemlos zugreifen kann. Das mag ja einfach sein, aber „öffentlich“ heißt nunmal, dass auch jeder diesen Kalender lesen könnte. Deswegen nie das Häkchen setzen bei „Diesen Kalender öffentlich machen„:

Google Kalender öffentlich

Nun drücken wir noch auf „Kalender erstellen“ und haben hiermit den Kalender angelegt. Wir müssen uns jetzt noch die Kalender-ID besorgen. Diese finden wir bei den Details unter „Privatadresse“.

Google Kalender Privatadresse

Drücken wir auf den grünen „ICAL„-Button, öffnet sich ein Fenster mit der URL, die wir uns in den Zwischenspeicher kopieren sollten.

Einbinden des Google Kalenders in FHEM

Im Folgenden müssen wir mit ein paar wenigen Einträgen in der Konfigurationsdatei fhem.cfg den gerade erzeugen Kalender einbinden. Das funktioniert mit zwei Zeilen Code:

define Kalender_Haussteuerung Calendar ical url link-aus-zwischenspeicher 14400
attr Kalender_Haussteuerung room Kalender

Google Kalender Integration FHEM

In dem Beispiel müssen wir nur noch die https-URL mit der eben kopierten für link-aus-zwischenspeicher ersetzen und den Wert von 14400 stehen lassen. Dieser Wert sorgt dafür, dass der Kalender alle 4 h (= 14400 Sekunden) eingelesen wird.

Testen durch einen Google Kalender Eintrag

Als Erstes probieren wir die Integration unseres Haussteuerungs-Kalenders mit einem Test-Termin aus. Nun sollten wir den neuen Kalender schon in unserem Smartphone sehen.

Wir tragen entweder direkt auf der Google-Kalender-Seite oder am Smartphone einen Testtermin in unserem Haussteuerungskalender ein. Da wir die Prüfung nur alle 4h machen, zwingen wir FHEM zu einem erneuten Laden unseres Kalender. Dazu klicken wir auf der FHEM-Webseite auf unsere neue Rubrik Kalender und dann auf Kalender_Haussteuerung.

FHEM Kalender reload

Dort drücken wir für set Kalender_Haussteuerung reload auf den Set-Button. Anschließend sollte sich in den Readings unterhalb des Kalenders etwas tun:

FHEM Kalender Readings

Infolge des Kalendereintrags und des Neuladens des Kalenders sind vercodete Einträge in den Readings entstanden. Das zeigt uns, dass die Integration funktioniert.

Weiters löschen wir den Testeintrag wieder und erstellen nun einen Eintrag namens „Urlaub„. Wichtig ist, dass der Termin nicht als Ganztageseintrag erstellt wir, sondern ein definiertes Beginn- und Endedatum haben muss. Also z.B. 07:00 Uhr bis 19:00 Uhr.

Dummyvariablen erzeugen

Damit wir hier auf die Kalendereinträge reagieren können, brauchen wir mindestens eine Dummyvariable. In unserem Beispiel wollen wir auf den Kalendertext „Urlaub“ checken. Dementsprechend legen wir eine Variable Urlaub_dummy an:

define Urlaub_dummy dummy
attr Urlaub_dummy alias Urlaubstag
attr Urlaub_dummy devStateIcon ja:rc_dot@green nein:rc_dot@grey
attr Urlaub_dummy icon weather_summer
attr Urlaub_dummy room Kalender
attr Urlaub_dummy setList ja nein
attr Urlaub_dummy webCmd ja:nein

Durch diesen Eintrag können wir später entscheiden, ob ein Urlaubstag ist (=ja) oder nicht (=nein)

Hilfsfunktionen

Damit das Schalten der Dummyvariable nun über den Eintrag in den Online-Kalender funktioniert, brauchen wir zwei Hilfsfunktionen. Zum Einen müssen wir feststellen, ob das Ereignis aufgrund des Kalendertexts für unsere Dummyvariable relevant ist oder nicht. Zum Anderen gibt es prinzipiell drei Events, die in FHEM überwacht werden müssen: Der Start, das Ende und das Löschen eines Termins. Zunächst kümmern wir uns um die benötigten Funktionen.

Hierzu erstellen wir ein neues Include, das wir im Verzeichnis /opt/fhem/FHEM erstellen. Dementsprechend kopieren wir uns den unten aufgelisteten Code in eine leere Datei namens 99_GoogleCalendarUtils.pm. Hierfür können wir den kleinen Editor nano benutzen und die neue Datei mit

cd /opt/fhem/FHEM
nano 99_GoogleCalendarUtils.pm

erstellen. Weiters kopieren wir den unten stehenden Code in den geöffneten Editor und speichern ihn mit STRG+O ab. Schließlich beenden wir den Editor mit STRG+X.
Im Anschluß der Code:

##############################################
# $Id: 99_GoogleCalendarUtils.pm 2691 2016-12-31 martin koch $
package main;

use strict;
use warnings;
use Digest::MD5 "md5_hex";
use HttpUtils;

sub
GoogleCalendarUtils_Initialize($$)
{
  my ($hash) = @_;
}


sub
Kalenderstart ($)
{
  my ($Ereignis) = @_;
        my @Ereignisarray = ();
        my $Ereignisteil1 = "";
        my @uids = ();

        @Ereignisarray = split(/.*:\s/,$Ereignis);
        if($#Ereignisarray > 0)
        {
          $Ereignisteil1 = $Ereignisarray[1];
          @uids=split(/;/,$Ereignisteil1);
          Log 3,"Termin fängt an";
    foreach my $uid (@uids) {
    my $Kalendertext = fhem("get Kalender_Haussteuerung summary $uid");
                Log 3,"uid = $uid, Text = $Kalendertext";
    if ($Kalendertext =~ /Urlaub/) {
      fhem("set Urlaub_dummy ja");
                        Log 3,"Urlaub found";
    }
  }
  }
}
sub Kalenderende ($) {
  my ($Ereignis) = @_;
        my @Ereignisarray = ();
        my $Ereignisteil1 = "";
        my @uids = ();
        
        @Ereignisarray = split(/.*:\s/,$Ereignis);
        if($#Ereignisarray > 0)
        {
          $Ereignisteil1 = $Ereignisarray[1];
          @uids=split(/;/,$Ereignisteil1);
          Log 3,"Termin wurde beendet oder gelöscht";
 	  foreach my $uid (@uids) {
    my $Kalendertext = fhem("get Kalender_Haussteuerung summary $uid");
    if ($Kalendertext =~ /Urlaub/) {
      fhem("set Urlaub_dummy nein");
    }
    }
   }
}

1;

Dummyvariablen schalten

Nun müssen wir nur noch in der Konfigurationsdatei fhem.cfg die Hilfsfunktionen bei Kalenderänderungen antriggern. Das geht ganz einfach mit folgenden drei Notify-Definitionen:

define Kalender_Haussteuerung_Start notify Kalender_Haussteuerung:modeStarted.* {\
   Kalenderstart("$EVENT");;\
}
define Kalender_Haussteuerung_Ende notify Kalender_Haussteuerung:modeEnded.* {\
   Kalenderende("$EVENT");;\
}
define Kalender_Haussteuerung_Loeschen notify Kalender_Haussteuerung:stateDeleted.* {\
   Kalenderende("$EVENT");;\
}

Diese drei Definitionen sorgen nun dafür, dass zu Beginn, Ablauf und Löschen eines Termins in unserem Google-Kalender Haussteuerung die gerade gezeigten Hilfsfunktionen aufgerufen werden. Passt dort der Kalendertext mit „Urlaub“ überein, so wird die Dummyvariable Urlaub_dummy auf „ja“ gesetzt. Sobald der Termin endet, wird die Variable auf „nein“ gesetzt.

Kalenderintegration für Urlaub final testen

Nachdem wir uns nun einen neuen Eintrag in unserem Google-Kalender „Haussteuerung“ unter dem Namen „Urlaub“ erstellt haben, zwingen wir unser FHEM zu einem Neuladen des Kalenders wie oben beschrieben. (set Kalender_Haussteuerung reload). Hierzu sollte der Termin in der Zukunft (für den Test reichen 5 Minuten) sein, da das Schalten sonst nicht ordnungsgemäß funktioniert.

Kalender Urlaub

Sobald nun der Termin beginnt, ruft FHEM die Hilfsmethoden auf und setzt die Variable „Urlaub_dummy“ auf „ja„.

Was sind die Grenzen?

Was nicht funktioniert ist, dass man beispielsweise einen Vorlauf vor einem solchen Termin einstellt. Da eine Heizung in der Regel einige Zeit braucht, um einen Raum aufzuwärmen, würden wir die Heizung gerne um eine Stunde früher einschalten als ein Termineintrag „Arbeit“ im Google Kalender aussagen würde. Leider triggert der Google Kalender exakt zum Beginn eines Termins „Arbeit“, so dass das mit diesem Modul nicht ohne weiteres möglich ist. Deswegen prüfe ich nicht nur nach einem Ereignis, sondern noch nach dem Termineintrag „Heizung“. Man benötigt zwar einen zusätzlichen Eintrag „Heizung“ im Kalender, diesen kann man aber immer wieder verschieben, auch aus der Vergangenheit. Man braucht ja den alten Termineintrag nicht mehr, also verschiebt man ihn dorthin, wo das Ereignis „Heizung“ den Dummy für die Heizung schalten soll.

Zuletzt aktualisiert am 24.09.2017.