DoorPi-Videotürsprechanlage und HomeMatic

[dtp]

Hallo,

mittlerweile ist mein DoorPi-Projekt als Ergänzung unserer vorhandenen Siedle-Türsprechanlage soweit fortgeschritten, dass ich es nun als Weiterführung dieses Threads als Projekt vorstellen möchte.

Zur Ausgangslage

Im Zuge des Neubaus unseres Hauses vor ca. 5 Jahren haben wir uns eine Siedle-Türsprechanlage, die u.a. aus dem Einbautürlautsprecher TLE 061-0 und drei Haustelefonen HTA 811-0 besteht, installieren lassen. Der TLE 061-0 sitzt hinter einer Serviceklappe eines in die Hauswand eingelassenen Briefkastens. Direkt darunter befindet sich das eigentliche Fach für Wurfsendungen verschiedenster Art.

Mit der Installation der HomeMatic kam auch irgendwann der Wunsch auf, den Briefkasten in das System einzubinden. Und so sägte ich zur besseren Funkübertragung hinter der Serviceklappe des Briefkasten eine Aussparung aus, in die ich ein 3-Kanal-Funk-Schließerkontaktinterface, HM-SCI-3-FM, einsetzte. Einen Kanal des Interfaces verband ich über eine Relaisplatine mit dem Klingeltaster, so dass wir fortan über die Betätigung der Haustürklingel per Push-Nachricht informiert wurden. Ergänzend kam dann kurze Zeit später der Wunsch auf, sich auch über etwaige Briefkasteneinwürfe per Push-Nachricht informieren zu lassen. Und so installierte ich zwei Mikroschalter hinter der Briefkastentür, die den Zustand der Tür und der Einwurfklappe detektieren sollten.

Diese beiden Mikroschalter wurden dann mit den beiden verbliebenen Kanälen des HM-SCI-3-FM verbunden. Beschrieben hatte ich das Ganze schon mal an dieser Stelle, so dass ich hier nicht weiter auf Details eingehen möchte. Mittlerweile habe ich das 3-Kanal-Funk-Schließerkontaktinterface durch den DoorPi ersetzt, was mir deutlich mehr Möglichkeiten eröffnete.

Die Serviceklappe des Briefkastens eignete sich hervorragend für die Montage eines Raspberry Pi 3 in Ergänzung zum Siedle TLE 061-0.

An dem Raspi habe ich das zugehörige Kamera-Modul angeschlossen, das ein Bild aufnimmt, sobald jemand an der Haustür klingelt oder einen Brief einwirft. Der Raspi wird dazu über die CCU entsprechend angesteuert. Als Basis für die Bild- und Videoübertragung dient mir das RPI-Cam-Web-Interface.

Im oberen Teil des Sandwiches befinden sich der Raspi 3 samt PiFace- und Kamera-Modul sowie ein DC/DC-Wandler (24V auf 5V, 3A) zur Versorgung des Raspi 3.

Im unteren Teil des Sandwiches sind der Siedle TLE 061-0 sowie ein Kemo Verstärker-Modul M031N zur Ansteuerung des Lautsprechers des TLE 061-0 über den DoorPi angeordnet.

Weiterhin befindet sich dort eine USB-Soundkarte, die den Raspi 3 mit dem Mikro und dem Lautsprecher des TLE 061-0 verbindet.

Das Ganze ist so verschaltet, dass der Kemo-Verstärker nur im Falle eines über den DoorPi geführten Gesprächs mit dem Lautsprecher verbunden wird. Ansonsten - auch falls der Raspi 3 einmal ausfallen sollte - wird der Lautsprecher immer über den internen Verstärker des TLE 061-0 angesteuert. Aber dazu später mehr.

In den nachfolgenden Postings möchte ich auf folgende Aspekte eingehen:

1. Installation von DoorPi und RPI-Cam-Web-Interface.
2. Konfiguration des DoorPi und der FRITZ!Box.
3. Umbaumaßnahmen am Siedle TLE 061-0.
4. Anschluss des Klingeltasters und der Mikrotaster.
5. Konfiguration des DoorPi zum Versenden von Push-Nachrichten.
6. Meldungen über Briefeinwürfe, Sabotage, etc.
7. Steuerung des Türöffners und der Haustürbeleuchtung.
8. Einbindung eines Wand-Tablets über ioBroker und vis.
9. Steuerung von DoorPi-Events per SIRI.
10. Umleiten von Gesprächen bei Abwesenheit.
11. Ansteuern einer Status-LED über das PiFace-Modul

Bitte habt etwas Geduld mit mir, bis ich alles beschrieben habe. Familie und Beruf lassen sich mit dem Hobby nicht immer reibungslos kombinieren.

Übrigens, der parallele Betrieb von DoorPi und Siedle-Anlage ist lediglich eine optionale Ergänzung. Wen das nicht weiter interessiert, der kann daher trotzdem gerne von Zeit zu Zeit vorbei schauen.

Hier mal meine Einkaufsliste:

• Raspberry Pi 3: 36,- €
• PiFace Digital 2: 40,- €
• Raspberry Pi NoIR Kamera-Modul: 30,- €
• DBPOWER® Universal 3in1 Clip-Objektiv Fisheye: 10,- €
• Gehäuse Schwarz-Fall für Raspi & PiFace-Modul: 6,- €
• Relaisplatine REL-PCB3 3 2 Wechsler 24 V/DC: 8,- €
• Gehäuse für Relaisplatine: 6,- €
• MeanWell DR-30-5 Hutschienen-Netzteil (15W, 5V, 3A): 19,- €
• UGREEN USB Soundkarte: 9,- €
• CPT DC/DC-Wandler 24V zu 5V / 3A, 15W: 12,- €
• Kemo M031-N Universalverstärker 3,5W, 4,5-12V: 9,- €
• diverse Kleinteile, wie Lochrasterplatten, Abstandsbolzen, Muttern, Unterlegscheiben, Kabel, Kabelbinder, etc: 20,- €

Somit bekommt man eine extrem flexibel anpassbare Videotürsprechanlage für ca. 200,- €.

Stay tuned,

Thorsten

[dtp]

Vorbereitung des Raspberry Pi 3

Zunächst sollte man sich Raspbian Buster Lite herunterladen. Wählt man die zip-Datei, dann diese entpacken und das Image z.B. mit dem Win32DiskImager auf eine µSD-Karte installieren. Danach die Karte in den Raspi stecken und ihn mit Strom versorgen. Sehr hilfreich sind zudem eine per USB bzw. USB-Dongle mit dem Raspi verbindbare Tastatur und Maus.

Hinweis: Ich hatte irgendwann Probleme nach Updates von Raspbian Jessie Lite bzw. Stretch Lite und des RPi_Cam_Web_Interfaces, weil die aktuelle GLIBC nicht mehr gefunden werden konnte. Daher habe ich auf Raspbian Buster Lite gewechselt. Damit läuft alles sauber und problemlos.

Nach dem ersten Booten des Raspis loggt man sich erstmalig mit dem User "pi" und dem Passwort "raspberry" (Achtung: die Tastatur dürfte noch auf Englisch stehen, so dass das Y auf der Z-Taste liegt) ein. Anschließend ruft man die Konfiguration mit

Code: Alles auswählen

sudo raspi-config

auf. Hier nun in Kurzform die erforderlichen Einstellungen:

• Change User Password -> Zur Änderung des Standardpassworts "raspberry" für den User pi.
• Network Options -> Zum Einstellen des Hostnamens (z.B. bei mir "LBoxPi"), der SSID des eigenen Routers und des WLAN-Passworts, falls gewünscht.
• Localisation Options -> Zum Ändern des WiFi-Lands (z.B. DE), der Zeitzone (z.B. Europa, Berlin) und des Keyboard-Layouts (alle drei de_DE-Optionen aus- und en abwählen; danach de_DE.UTF-8 und die verwendet Tastatur mit den Standardeinstellungen für Deutsch übernhemen).
• Interfacing Options -> Zur Aktivierung insbesondere des Kamera-Moduls und der Secure Shell (SSH). Soll ein PiFace Digital 2 Moduls verwendet werden, muss auch SPI aktiviert werden.

Abschließend den Raspi neu booten.

Vergeben einer statischen IP-Adresse für die WLAN-Verbindung

Ich würde grundsätzlich empfehlen, statische IP-Adressen für Geräte zu vergeben, die innerhalb des WLANs von anderen Geräten häufig angesprochen werden müssen. Dies ist auch bei DHCP-Betrieb möglich, wobei dann eine IP-Adresse außerhalb des DHCP-Bereichs gewählt werden sollte. Zur statischen IPv4-Konfiguration öffnet man die Datei "/etc/dhcpcd.conf" mit dem Befehl

Code: Alles auswählen

sudo nano /etc/dhcpcd.conf

Dann fügt man z.B. für die statische WLAN-Adresse "192.168.0.21" des Raspis und im Falle der Server-Adresse "192.168.0.1" des WLAN-Routers die folgenden Zeilen am Ende von "dhcpcd.conf" hinzu:

Code: Alles auswählen

interface wlan0
static ip_address=192.168.0.21/24
static routers=192.168.0.1
static domain_name_servers=192.168.0.1

Vermeiden eines Abbruchs der WLAN-Verbindung (nicht für Buster Lite)

Ich hatte häufiger das Problem, dass mein Raspi 3 irgendwann nicht mehr per WLAN erreichbar war. Der Grund dafür waren die Energiespareinstellungen für das WLAN-Modul. Mit folgendem Befehl lässt sich das Problem sehr einfach vermeiden:

Code: Alles auswählen

sudo apt-get remove ifplugd

Hinweis: Da dieses Paket bei Buster Lite nicht enthalten ist, muss es auch nicht mit obigem Befehl entfernt werden. Vielleicht hilft die Info aber ja trotzdem mal jemandem weiter.

Installation von DoorPi

Wenn soweit alles konfiguriert wurde, kann es mit der Installation des DoorPi weitergehen. Zunächst müssen pip und linphone als wichtige Pakete heruntergeladen und installiert werden:

Code: Alles auswählen

sudo apt-get remove python-pip
sudo easy_install pip  || (wget https://bootstrap.pypa.io/ez_setup.py -O - | sudo python) && sudo easy_install pip
sudo pip install linphone4raspberry python-daemon

Danach geht es mit dem Download und der Installation von DoorPi weiter:

Code: Alles auswählen

sudo pip install doorpi
sudo doorpi_cli --trace

Abschließend noch den Benutzer anpassen:

Code: Alles auswählen

sudo chown -R pi:pi /usr/local/etc/DoorPi

Erster Start des DoorPi

Es kann sein, dass der Startvorgang des DoorPi beim ersten Mal mit der folgenden Fehlermeldung stoppt.

Trotzdem sollte das Web-Interface nun in einem Browser mit "http://<doorpi-IP>/dashboard/pages/index.html" aufgerufen werden können.

Nach dem Start wird automatisch die Konfigurationsdatei "doorpi.ini" angelegt, die es später noch zu bearbeiten gilt. Hat soweit alles geklappt, kann DoorPi mit CTRL-C wieder beenden werden.

Einrichten von DoorPi als Deamon

Die Einrichtung von DoorPi als Deamon hat den Vorteil, dass dieser nach dem Schließen der Konsole weiterläuft und dass nach jedem Neustart des Raspi gleichzeitig auch ein automatischer Start des DoorPi erfolgt. Zuerst sollte geprüft werden, ob der DoorPi überhaupt als Daemon lauffähig ist:

Code: Alles auswählen

sudo systemctl daemon-reload
sudo /etc/init.d/doorpi start

Falls bei der Installation kein Daemon-File erzeugt wurde und/oder dieses nachträglich erzeugt werden soll (Achtung: Die Datei /etc/init.d/doorpi wird ohne Rückfrage überschrieben!), folgende Befehlszeilen ausführen:

Code: Alles auswählen

cd /tmp
wget https://raw.githubusercontent.com/motom001/DoorPi/master/doorpi/docs/service/create_daemon_file.py -O - | sudo python
sudo systemctl daemon-reload

Danach wird der Daemon in den "Autostart" eingetragen:

Code: Alles auswählen

sudo systemctl daemon-reload
sudo update-rc.d doorpi defaults

DoorPi wird jetzt automatisch bei einem Neustart des Raspi gestartet. Zudem kann der Dienst auch mit

Code: Alles auswählen

sudo service doorpi start

gestartet werden (außer "start" gibt es auch noch die Optionen "stop", "restart" und "status").

Installation des RPI-Cam-Web-Interface

Voraussetzung für die nachfolgende Installationsanleitung ist ein mit dem Raspi verbundenes Raspberry Camera Module.

1. Falls nicht bereits bei der Ersteinrichtung des Raspis geschehen, sollte zunächst mit
   

   Code: Alles auswählen

   sudo raspi-config

   
   das Konfigurationstool von Raspian gestartet und die Kamera unter "Enable Camera" aktiviert werden. Anschließend den Raspi mit
   

   Code: Alles auswählen

   sudo reboot

   
   neu starten.
2. Im Anschluss wird das RPI-Cam-Web-Interface mit der folgenden Befehlsfolge installiert:
   

   Code: Alles auswählen

   sudo apt-get install git
   sudo git clone https://github.com/silvanmelchior/RPi_Cam_Web_Interface.git
   cd RPi_Cam_Web_Interface
   sudo ./install.sh

3. Nach Abschluss der Installation sollte sich automatisch das nachfolgende Konfigurationsfenster öffnen.
   

   

   RPi_Cam_Web_Interface_01.png (16.5 KiB) 21904 mal betrachtet

   Standardmäßig ist als Cam subfolder "html" eingestellt. Ich habe auf dieses Unterverzeichnis verzichtet, da auch schon mal anderer Raspi so konfiguriert ist. Zudem verwende ich den Webport 8181 statt 80. Auch das ist eher dem anderen Raspi geschuldet, weil dort bereits der Port 80 belegt war.
   
   Raspbian Buster findet nach dem erstmaligen Aufruf nicht alle Pakete. Daher ist nach dem Drücken auf den OK-Button vermutlich erst mal ein
   

   Code: Alles auswählen

   sudo apt-get update

   mit anschließendem, nochmaligem
   

   Code: Alles auswählen

   sudo ./install.sh

   notwendig. Danach sollte dann aber das nachfolgende Fenster zum Starten des Interfaces angezeigt werden.

   

   RPi_Cam_Web_Interface_02.png (8.49 KiB) 21904 mal betrachtet

Konfiguration des RPi_Cam_Web_Interfaces

Das eigentliche Web-Interface kann nun in eimem Brower durch Eingabe der IP-Adresse gefolgt vom konfigurierten Port, also z.B. mit "http://192.168.0.22:8181/" geöffnet werden.

Die Konfiguration gestaltet sich recht einfach, da man sämtliche Änderungen sofort angezeigt bekommt. Neben der Auflösung (ich empfehle keine allzu hohen Werte, um eine möglichst schnelle Anzeige und Übertragung zu erzielen) und der Bildlage kann man unter anderem auch den Inhalt, die Größe, die Farbe und den Hintergrund einer Texteinblendung (Annotation) ändern.

Auch lässt sich hier eine Bewegungserkennung einstellen, was ich aber in Verbindung mit einer Haustürkamera eher nicht empfehlen würde, da diese besser in Abhängigkeit von einem Klingeln und/oder einem Briefeinwurf ausgelöst werden sollte.

Anzeige der Außentemperatur im Video- und Standbild

Um von der CCU aus Dateien auf dem Raspi schreiben und verändern zu können, sind zunächst folgende Schritte auf dem Raspi und der CCU per PuTTY, Termius oder einem anderen Terminal-Programm auszuführen:

Raspi (IPv4: 192.168.0.21)

Code: Alles auswählen

sudo mkdir /home/pi/.ssh
sudo chmod -R 777 /home/pi/.ssh

Die Schreibrechte müssen zunächst für alle eingeräumt werden, da ssh-copy-id sonst im nachfolgenden Schritt die Datei "authorized_keys" nicht anlegen kann.

CCU (IPv4: 192.168.0.20)

1. Bemerkung: nicht für CCU3 erforderlich

   Code: Alles auswählen

   mount -o remount,rw /

2. Code: Alles auswählen

   ssh-keygen -b 2048 -t rsa

3. Enter file in which to save the key (/root/.ssh/id_rsa): Return-Taste drücken
4. Enter passphrase (empty for no passphrase): Return-Taste drücken
5. Enter same passphrase again: Return-Taste drücken

6. Code: Alles auswählen

   ssh-copy-id 'pi@192.168.0.21'

Achtung (nur für CCU1 und 2 erforderlich): nach einem FW-Update der CCU gehen die rsa-Dateien im root-Verzeichnis der CCU in der Regel verloren (dies ist bei der CCU3 und der Raspberrymatic nicht der Fall). Daher empfiehlt sich, das von @uwe111 erzeugte WebUI-Addon ssh-keygen zu installieren. Damit sind die Dateien dann sicher.

Raspi (IPv4: 192.168.0.21)

Wichtig: Die Schreibrechte des Ordners ".ssh" müssen abschließend auf den Eigentümer beschränkt sein (755 oder 700). Ansonsten wird immer wieder eine Authentifizierung verlangt und das automatische Einwählen der CCU auf dem Raspi schlägt fehl.

Code: Alles auswählen

sudo chmod -R 755 /home/pi/.ssh

Nun legt man mit

Code: Alles auswählen

sudo nano /home/pi/RPi_Cam_Web_Interface/user_annotate.txt

eine leere Datei im Verzeichnis "/home/pi/RPi_Cam_Web_Interface" an und beendet den Editor mit Ctrl-X und J zum Abspeichern. Anschließend vergibt man noch Lese- und Schreibreichte für alle:

Code: Alles auswählen

sudo chmod 666 /home/pi/RPi_Cam_Web_Interface/user_annotate.txt

Wichtig: Standardmäßig ist raspimjpeg so konfiguriert, dass es die Datei "user_annotate.txt" im Verzeichnis "/dev/shm/mjpeg" erwartet. Dies führt aber leider dazu, dass die Datei bei jedem Refresh des Verzeichnisses wieder gelöscht wird und die Annotations nur flüchtig sind. Daher muss "/etc/raspimjpeg" mit

Code: Alles auswählen

sudo nano /etc/raspimjpeg

so umkonfiguriert werden, dass der Eintrag

Code: Alles auswählen

user_annotate /dev/shm/mjpeg/user_annotate.txt

in

Code: Alles auswählen

user_annotate /home/pi/RPi_Cam_Web_Interface/user_annotate.txt

geändert wird. Danach den Raspi mit

Code: Alles auswählen

sudo reboot

zur Übernahme der Änderungen neu starten.

In die Datei "user_annotate.txt" kann dann mit dem nachfolgenden Programm und HomeMatic-Skript die aktuelle Außentemperatur eines Wettersensors oder dergleichen geschrieben werden.

Code: Alles auswählen

! Aktuelle Außentemperatur in Datei für RPI-Cam-Web-Interface auf LBoxPi schreiben
! Version 1.1, Autor: dtp

! Kanal des Kombisensors
string channel = "DG Dach Wettersensor Daten";

! Einwahldaten des LBoxPi
string login = "pi@192.168.0.21";

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

! +++++ Deklaration weiterer Variablen +++++
string temp;

! +++++ Ausgabe des aktuellen Außentemperaturwerts +++++
temp = (dom.GetObject(ID_CHANNELS).Get(channel)).DPByHssDP("ACTUAL_TEMPERATURE").Value().ToString(1);

! +++++ Temperaturwert in Datei schreiben +++++
(dom.GetObject(ID_DATAPOINTS).Get("CUxD.CUX2801001:1.CMD_EXEC")).State("echo -n "#temp#" C | ssh "#login#" 'cat > /home/pi/RPi_Cam_Web_Interface/user_annotate.txt'");

Leider wird das °-Zeichen nicht vom RPi_Cam_Web_Interface unterstützt. Daher muss man darauf verzichten und die Temperatur nur mit "C" ausgeben. Nicht schön, aber leider nicht zu ändern. Und "Gr C" sieht irgendwie auch doof aus.

Update des RPi_Cam_Web_Interfaces

Zum Updaten des RPi_Cam_Web_Interfaces zunächst einfach die folgenden Schritte durchführen und die dann erscheinenden Fenster jeweils mit OK bestätigten.

Code: Alles auswählen

cd /RPi_Cam_Web_Interface
sudo ./update.sh

Im Anschluss daran muss die Datei "user_annotate.txt" im Verzeichnis "/dev/shm/mjpeg" mit

Code: Alles auswählen

sudo nano /etc/raspimjpeg

noch wieder so umkonfiguriert werden, dass der Eintrag

Code: Alles auswählen

user_annotate /dev/shm/mjpeg/user_annotate.txt

in

Code: Alles auswählen

user_annotate /home/pi/RPi_Cam_Web_Interface/user_annotate.txt

geändert wird. Dies ist leider nach jedem Update notwendig, da "user_annotate.txt" immer mit den Standardwerten überschrieben wird. Danach den Raspi mit

Code: Alles auswählen

sudo reboot

zur Übernahme der Änderungen neu starten.

Gruß,

Thorsten

[dtp]

Konfiguration der USB-Soundkarte

Der ALSA-Treiber wird automatisch mit Raspian Buster Lite installiert und sollte demnach schon vorhanden sein. Eine angeschlossene USB-Soundkarte sollte folglich automatsich erkannt werden. Ich verwende eine UGREEN USB Soundkarte, die es für vergleichsweise geringes Geld gibt und die eine durchaus gute Soundqualität liefert, die auf alle Fälle für eine Wechselsprechanlage ausreichend ist.

Zur Konfiguration der Soundkarte ist es lediglich notwendig, mit

Code: Alles auswählen

sudo nano /usr/share/alsa/alsa.conf

die Datei "alsa.conf" zu öffnen, um dann die Zeilen

Code: Alles auswählen

defaults.ctl.card 0
defaults.pcm.card 0

durch die Zeilen

Code: Alles auswählen

defaults.ctl.card 1
defaults.pcm.card 1

zu ersetzen.

Wichtig: Die ALSA-Konfiguration könnte auch noch in "/home/pi/.asoundrc" stehen. Diese Datei darf nicht existieren! Daher löschen wir sie mit dem Befehl

Code: Alles auswählen

rm /home/pi/.asoundrc

Schließlich die Wiedergabe testen mit

Code: Alles auswählen

aplay /usr/share/sounds/alsa/Front_Center.wav

Empfohlene Mixer-Einstellungen (Lautstärke, Mikrofoneingang) sind:

Code: Alles auswählen

amixer -c1 contents
amixer -c1 cset numid=3 0
amixer -c1 cset numid=4 0
amixer -c1 cset numid=7 1
amixer -c1 cset numid=8 35

Das war's auch schon, was die Soundkarte und den Treiber angeht.

Ein paar Basics zur doorpi.ini

Die Datei "doorpi.ini" ist sozusagen die Kommandozentrale von DoorPi. Sie befindet sich in der Regel im Verzeichnis "/usr/local/etc/DoorPi/conf". Hier befinden sich nahezu sämtliche Konfigurationen zur Steuerung des DoorPi und der mit ihm verbundenen Komponenten.

Eine gute Übersicht der Parameter findet sich hier. Ich werde jedoch nur auf diejenigen Parameter eingehen, die auch für meine Installation eine Rolle spielen. Ansonsten sei verwiesen auf das DoorPi-Forum.

Hier zunächst mal meine doorpi.ini (Passwörter geixt). Diese stammt aus meinem Live-System, das nun seit Anfang 2015 absolut problemlos läuft.

Code: Alles auswählen

[AREA_public]
.* =

[User]
admin = xxxxxxxxx

[Group]
administrators = admin

[WritePermission]
administrators = public

[ReadPermission]
administrators = public

[AdminNumbers]
**610 = active
**611 = active
**621 = active

[DoorPi]
base_path = /usr/local/etc/DoorPi
eventlog = !BASEPATH!/conf/eventlog.db
is_alive_led = DoorPi-Alive-LED
last_snapshot = 
snapshot_path = 

[DoorPiWeb]
indexfile = index.html
ip = 
loginfile = login.html
online_fallback = http://motom001.github.io/DoorPiWeb
port = 80
public = AREA_public
www = !BASEPATH!/../DoorPiWeb

[SIP-Phone]
firewallpolicy = PolicyNoFirewall
audio_codecs = PCMA,PCMU
call_timeout = 12
capture_device = ALSA: USB Audio Device
dialtone = !BASEPATH!/media/ShortDialTone.wav
dialtone_renew_every_start = False
dialtone_volume = 35
echo_cancellation_enabled = False
identity = Klingel
local_port = 5060
max_call_time = 60
playback_device = ALSA: USB Audio Device
record_while_dialing = False
records = !BASEPATH!/records/Haustuerklingel.wav
sipphonetyp = linphone
sipserver_password = xxxxxxxxx
sipserver_realm = fritz.box
sipserver_server = 192.168.0.1
sipserver_username = xxxxxxxxx
stun_server = 
ua.max_calls = 2
video_codecs = VP8
video_device = StaticImage: Static picture
video_display_enabled = False
video_size = vga

[DTMF]
"##" = out:Tueroeffner,1,0,3

[EVENT_AfterShutdown]
10 = os_execute:/usr/local/etc/DoorPi/scripts/StopDoorPi.sh

[EVENT_AfterStartup]
10 = os_execute:/usr/local/etc/DoorPi/scripts/StartDoorPi.sh

[EVENT_OnCallStateConnect]
10 = out:Verstaerker,1,0,60

[EVENT_OnCallStateDisconnect]
10 = out:Verstaerker,0
20 = os_execute:/usr/local/etc/DoorPi/scripts/LichtAus.sh

[EVENT_OnKeyPressed_onboardpins.0]
10 = file_call_value:/usr/local/etc/DoorPi/rufumleitung.txt
20 = os_execute:/usr/local/etc/DoorPi/scripts/Klingel.sh
30 = os_execute:/usr/local/etc/DoorPi/scripts/LichtAn.sh

[EVENT_OnKeyPressed_onboardpins.1]
10 = os_execute:/usr/local/etc/DoorPi/scripts/BriefkastenEinwurf.sh

[EVENT_OnKeyPressed_onboardpins.2]
10 = os_execute:/usr/local/etc/DoorPi/scripts/BriefkastenLeerung.sh

[EVENT_OnKeyPressed_onboardpins.3]
10 = os_execute:/usr/local/etc/DoorPi/scripts/BriefkastenStatus.sh

[EVENT_OnKeyPressed_onboardpins.4]
10 = os_execute:/usr/local/etc/DoorPi/scripts/LichtAn.sh

[EVENT_OnKeyPressed_onboardpins.5]
10 = os_execute:/usr/local/etc/DoorPi/scripts/BriefkastenSabotage.sh

[EVENT_OnKeyPressed_onboardpins.6]
10 = out:Tueroeffner,1,0,3

[EVENT_OnKeyPressed_onboardpins.7]
10 = hangup:0

[EVENT_OnStartup]
10 = sleep:1

[keyboards]
onboardpins = piface
virtual = filesystem

[onboardpins_keyboard]
bouncetime = 4000
polarity = 0
pressed_on_keydown = True

[virtual_keyboard]
base_path_output = /usr/local/etc/DoorPi/filesystem/outputs/
base_path_input = /usr/local/etc/DoorPi/filesystem/inputs/

[onboardpins_InputPins]
0 = sleep:0
1 = sleep:0
2 = sleep:0
3 = sleep:0
4 = sleep:0
5 = sleep:0
6 = sleep:0
7 = sleep:0

[onboardpins_OutputPins]
0 = Verstaerker
1 = Tueroeffner
2 = Briefkasten-Status-LED
7 = DoorPi-Alive-LED

[virtual_InputPins]
briefkastenstatus = out:Briefkasten-Status-LED,1,0,6

[virtual_OutputPins]

Einrichten des SIP-Servers auf der FRITZ!Box

Damit das Klingeln an der Haustür auch auf einem FRITZ!Fon inkl. Aufnahme der Haustürkamera angezeigt werden kann, muss der DoorPi noch als SIP-Client für den SIP-Server der FRITZ!Box konfiguriert werden (die nachfolgenden Screenshots sind unter FRITZ!OS 6.63 entstanden). Dazu ein neues LAN/WLAN-Gerät unter "Telefonie | Telefoniegeräte" als IP-Türsprechanlage einrichten. Die FRITZ!Box vergibt dann automatisch die interne Nummer **620 für den ersten SIP-Client.

Bei der Konfiguration der IP-Türsprechanlage können die Einträge für "Klingeltaste" und "Rufnummer der Klingeltaste" unverändert bleiben. Unter "Klingeln weiterleiten an" kann man einzelne Telefone oder auch eine Gruppe aus bis zu vier Telefonen definieren, die bei Betätigung des Klingeltasters klingeln sollen. Da auf den FRITZ!Fons leider kein schöner Klingelton installiert ist, habe ich mir einen entsprechenden MP3-Sound erzeugt, den man als eigenen Klingelton auf dem FRITZ!Fon installieren kann.

Tuerklingel_mp3.txt

(133.28 KiB) 621-mal heruntergeladen

Achtung: Bei der Datei "Tuerklingel_mp3.txt" handelt es sich eigentlich um eine MP3-Datei. Da hier das Hochladen von MP3-Dateien nicht möglich ist, habe ich sie in eine txt-Datei umbenannt. Vor dem Hochladen auf euer FRITZ!Fon müsst ihr die Datei daher einfach in "Tuerklingel.mp3" umbenennen.

In den nachfolgenden Feldern sind schließlich noch die Bezeichnung der Türsprechanlage sowie, falsch gewünscht, die Zeichenfolge für den Türöffner gemäß doorpi.ini und der Link zum RPI-Cam-Web-Interface "http://192.xxx.xxx.xxx:Port/cam.jpg" einzutragen.

Schließlich sind noch unter dem Reiter "Anmeldedaten" die in der doorpi.ini vorgenommenen Einstellungen im Block "[SIP-Phone]"

Code: Alles auswählen

[SIP-Phone]
...
sipserver_password = xxxxxxx
sipserver_realm = fritz.box
sipserver_server = 192.xxx.xxx.xxx
sipserver_username = 620

einzutragen.

[dtp]

Der Umbau des Siedle Einbautürlautsprechers TLE 061-0 ist eigentlich relativ leicht gemacht. Die Idee, die dahinter steckt, ist die wahlweise Verwendung des TLE 061-0 und des DoorPi unter Nutzung des bereits im TLE 061-0 eingebauten Lautsprechers und Mikrofons. Sprich, warum noch ein weiteres Mikrofon und einen weiteren Lautsprecher kaufen, wenn dieses bereits in guter Qualität vorhanden ist?

Zunächst einmal habe ich den TLE 061-0 aus unserem Briefkasten ausgebaut und von seinem Gehäuse befreit. Lautsprecher und Mikrofon sind - wie nicht anders zu erwarten war- gut zu erkennen.

Vorteilhaft ist, dass beide jeweils über einen Steckverbinder mit der Platine verbunden sind. Der Lautsprecher mit zwei grünen, das Mikrofon mit einem roten und einem blauen Kabel. Das macht die nachfolgenden Arbeiten etwas einfacher.

Der Rest der Platine braucht uns eigentlich nicht weiter zu interessieren, da die Funktionalität ja voll erhalten bleiben soll.

Gemäß des nachfolgenden Schaltplans wird nun zunächst das Mikrofon des TLE 061-1 einfach parallel mit dem Eingang der USB-Soundkarte verbunden. Dazu habe ich ein vorhandenes 3,5mm-Klinken-Verlängerungskabel aufgetrennt und das steckerlose Ende der einen Hälfte an die Lötpunkte der Mikrofon-Anschlussklemme des TLE 061-1 gelötet. Zusätzlich wurden noch zwei kleine Löcher in die Gehäuse-Unterschale des TLE 061-1 zur Durchführung der Kabel gebohrt (siehe nachfolgende Bilder).

Etwas aufwändiger gestaltet sich die Verkabelung des Lautsprechers, da ein Parallelbetrieb schon aufgrund der Impedanz-Veränderung problematisch wäre. Zudem wäre es unschön, wenn zwei Leute gleichzeitig im Haus das Gespräch mit der Person an der Tür führten. Daher habe ich vorgesehen, dass der Lautsprecher bei Gesprächsannahme über den DoorPi automatisch vom TLE 061-1 auf den DoorPi umgeschaltet und nach Gesprächsende ebenso automatisch wieder zurückgeschaltet wird. Zur notwendigen Konfiguration in der doorpi.ini komme ich später.

Wie man dem obigen Schaltplan entnehmen kann, habe ich das andere Ende des aufgetrennten 3,5mm-Klinken-Verlängerungskabels mit den Eingangskabeln des Kemo-Verstärkers verlötet und den Klinkenstecker in die Kopfhörer-Buchse der USB-Soundkarte gesteckt. Der mit dem Lautsprecher-Symbol markierte Ausgang des Kemo-Verstärkers wurde mit dem NO-Kontakt (Normally Open) von Relais 0 des PiFace-Moduls verbunden. Eines der beiden grünen Kabel des Lautsprechers wurde aufgetrennt und der nun freie Lötpunkt mit dem C-Kontakt (Common) des Relais 0 mit einem Rest des bereits genutzten Verlängerungskabels verbunden. Die andere Ader des Kabels diente zur Verbindung des nun nicht mehr mit dem Lautsprecher direkt verbundenen Lötpunkts der zugehörigen Lautsprecher-Anschlussklemme mit dem NC-Kontakt (Normally Closed) des Relais 0. Schließlich diente noch der Schirm des Verlängerungskabels als Verbindung zwischen dem anderen Lötpunkt der Lautsprecher-Anschlussklemme und dem mit "-" makierten Kontakt des Kemo-Verstärkers, der gleichzeitig auch als Masseanschluss der Spannungsversorgung dient.

Hier noch ein Bild von der wieder in die Gehäuseunterschale eingesetzten Platine des TLE 061-0.

WICHTIG: Die Spannungsversorgungen des Raspberry Pi 3 und des Kemo-Verstärkers sollten unbedingt galvanisch voneinander getrennt sein, da es sonst zu einer unangenehmen Brummschleife kommt. Daher habe ich für den Kemo-Verstärker einen 24V/5V-DC/DC-Wandler verwendet, der die Spannung des TLE 061-0 abgreift, während der Raspberry Pi 3 direkt über ein 5V-Netzteil versorgt wird, das bei uns im Schaltschrank des Hauswirtschaftsraums positioniert ist. Selbst die Verwendung von zwei DC/DC-Wandlern (einen für den Kemo-Verstärker und einen für den Raspberry Pi 3) führte aufgrund der nicht vorhandenen galvanischen Trennung zu Problemen.

Hier noch mal ein Bild eines frühen Versuchsaufbaus.

Damit der Lautsprecher nun automatisch zwischen DoorPi und LTE 061-0 umgeschaltet wird, sind folgende Konfigurationen in der doorpi.ini notwendig:

Code: Alles auswählen

[EVENT_OnCallStateConnect]
10 = out:Verstaerker,1,0,60

[EVENT_OnCallStateDisconnect]
10 = out:Verstaerker,0

...

[keyboards]
onboardpins = piface

...

[onboardpins_OutputPins]
0 = Verstaerker

Unter "[keyboards]" wird zunächst das PiFace-Modul für die Onboard-Pins gesetzt, während "[onboardpins_OutputPins]" die zugehörigen Ausgänge des PiFace-Moduls definiert. "0" bezeichnet hier das Relais 0, das dem Namen "Verstaerker" zugewiesen wurde.

Weiter oben in der doorpi.ini sind mit "Verstarker" zwei Events verknüpft, nämlich zum Einen unter "[EVENT_OnCallStateConnect]" das automatische Umschalten des Relais auf den NO-Kontakt für 60 Sekunden (1 -> an, 0 -> aus, 60 -> Dauer) nach Rufannahme und zum Anderen unter "[EVENT_OnCallStateDisconnect]" das automatische Zurückschalten auf den NC-Kontakt nach Gesprächsende.

Das war's schon.

PS.: Ich habe bewusst auf ein Ein- und Ausschalten des Kemo-Verstärkers verzichtet, auch wenn dadurch der Stromverbrauch etwas höher ist. Aber so vermeide ich Schaltgeräusche und Zeitverzögerungen nach dem Einschalten.

[dtp]

Schaltplan

Nachdem der DoorPi soweit vorbereitet ist, geht es an die Integration in die bestehende Türsprechanlage von Siedle. Diese umfasst neben dem Einbautürlautsprecher TLE 061-0 noch den Netzgleichrichter NG 602-0, der neben der 24V-Versorgungsspannung auch noch eine 12V-Wechselspannung für einen elektrischen Türöffner bereit stellt. Zudem umfasst die Installation noch die Zubehör-Dioden ZD 061-10 sowie die daran anzuschließenden Haustelefone HTS 811-0. Der nachfolgende Schaltplan verdeutlicht den Aufbau, wobei die Anschlüsse der Siedle-Komponenten in der unteren Hälfte in Grün mit schwarzen Verbindungsleitungen dargestellt sind.

Im oberen Teil des Schaltplans ist das PiFace-Modul des Raspberry Pi zu erkennen. Alle gegenüber der bestehenden Installation neu hinzu gekommen Verbindungsleitungen sind in Blau dargestellt. Das PiFace-Modul wird von verschiedenen Tastern (gelber Hintergrund) und Mikroschaltern (roter Hintergrund) getriggert. Die Farbgebung der Anschlüsse des PiFace-Moduls (Inputs: grün, Open Collector Outputs: orange, Relais Outputs: rot) entspricht den im Original mitgelieferten Aufklebern.

Nachfolgend möchte ich kurz auf die Taster und Microschalter sowie deren Anschluss eingehen, um dann in weiteren Postings die davon abhängige Steuerung des DoorPi und der CCU zu beschreiben.

Klingeltaster

Der wichtigste Taster ist natürlich der Klingeltaster. Ursprünglich hat dieser einfach den Anschluss 6 des TLE 061-0 mit dem Anschluss 7.1 des ZD 061-10 verbunden, so dass der Klingelimpuls an das HTS 811-0 weitergegeben werden konnte. Leider ist es jedoch nicht möglich, einen Eingang des PiFace-Moduls parallel zu dieser Verbindung zu legen, da das der TLE 061-0 fortan mit Ignoranz des Tastersignals quittiert. Aus diesem Grund musste ein Klingelrelais verbaut werden, dessen Spule bei Betätigung des Klingeltasters auf die 24 V des NG 602-0 gelegt wird. Diese steuert dann zwei Schließer an, die ihrerseits jeweils die Anschlüsse 7.1 des ZD 061-10 und 6 des TLE 061-0 sowie GND und 0 der PiFace-Eingänge verbinden. Somit führt das Drücken des Klingel-Tasters sowohl zum Klingeln der Haustelefone HTS 811-0 als auch der FRITZ!Fons über den DoorPi. Eine geeignete Relaisplatine findet sich z.B. bei Conrad.

In der doorpi.ini sind folgende Einträge notwendig:

Code: Alles auswählen

[EVENT_OnKeyPressed_onboardpins.0]
10 = file_call_value:/usr/local/etc/DoorPi/rufumleitung.txt

...

[keyboards]
onboardpins = piface

...

[onboardpins_InputPins]
0 = sleep:0

Briefkasten-Klappe und -Tür

Da ich den DoorPi ja nun schon in den Briefkasten eingebaut hatte, lag es nahe, über das PiFace-Modul auch den Briefkastenstatus abzufragen. Das mache ich mit den bereits im Eingangsposting gezeigten Mikroschaltern im Briefkastenfach.

Der obere Schalter detektiert die Briefkastenklappe für die Einwürfe und ist mit Input-Pin 1 des PiFace-Moduls verbunden. Der untere Schalter dient zum Detektieren des Öffnens der Briefkastentür und ist mit Input-Pin 2 des PiFace-Moduls verbunden.

In der doorpi.ini sind folgende Einträge notwendig:

Code: Alles auswählen

[EVENT_OnKeyPressed_onboardpins.1]
10 = os_execute:/usr/local/etc/DoorPi/scripts/BriefkastenEinwurf.sh

[EVENT_OnKeyPressed_onboardpins.2]
10 = os_execute:/usr/local/etc/DoorPi/scripts/BriefkastenLeerung.sh

...

[keyboards]
onboardpins = piface

...

[onboardpins_InputPins]
1 = sleep:0
2 = sleep:0

Briefkasten Sabotagekontakt Serviceklappe

Da noch einige Eingänge des PiFace-Moduls frei waren, kam ich auf die Idee, einen weiteren Mikroschalter auf Input-Pin 5 zu legen, über den ich das Öffnen der Serviceklappe erkennen kann.

Hier noch die dafür notwendigen Einträge in der doorpi.ini:

Code: Alles auswählen

[EVENT_OnKeyPressed_onboardpins.5]
10 = os_execute:/usr/local/etc/DoorPi/scripts/BriefkastenSabotage.sh

...

[keyboards]
onboardpins = piface

...

[onboardpins_InputPins]
5 = sleep:0

Lichttaster

Auf dem ersten Bild des Ausgangspostings sind insgesamt drei Taster zu erkennen. Neben dem bereits erwähnten Klingeltaster sind dies noch der rot hinterlegte Licht-Taster für eine Außenlampe im Eingangsbereich sowie ein Taster in der unteren Briefkastentür, der ein ursprünglich dort positioniertes Namensschild ersetzt hat.

Briefkasten_01.JPG (62.44 KiB) 35778 mal betrachtet

Der Licht-Taster war ursprünglich mit dem Anschluss "L" des TLE 061-0 verbunden, das dann einen Eltako-Zeitautomaten für die Außenlampe ansteuerte. Da ich aber gerne das Außenlicht über die CCU steuern wollte, habe ich den Zeitautomaten gegen einen Hutschienen-Schaltaktor mit Leistungsmessung, HM-ES-PMSw1-DR, ausgetauscht und den Licht-Taster auf Input-Pin 4 des PiFace-Moduls gelegt.

Die notwendigen Einträge in der doorpi.ini sehen wie folgt aus:

Code: Alles auswählen

[EVENT_OnKeyPressed_onboardpins.4]
10 = os_execute:/usr/local/etc/DoorPi/scripts/LichtAn.sh

...

[keyboards]
onboardpins = piface

...

[onboardpins_InputPins]
4 = sleep:0

[dtp]

Telegram als Push-Dienst

Das Einrichten eines Telegram-Bots hatte ich ja hier schon mal beschrieben. Will man einen bereits vorhandenen Bot nutzen, braucht man natürlich keinen weiteren mehr einrichten.

Der Vollständigkeit halber hier noch mal die Einrichtung eines Bots in Kurzform:

1. Herunterladen und installieren der Telegram-App für sein Betriebssystem.
2. Starten der App, eingeben der Telefonnummer, an die die SMS mit dem Freischaltcode geschickt werden soll, und frei schalten des Accounts.
3. In der InApp-Suche "BotFather" eingeben und starten eines Chats mit dem BotFather per

   Code: Alles auswählen

   /start

4. Einrichten des eigenen Bots mit

   Code: Alles auswählen

   /newbot

5. Eingabe eines Namens für den Bot (z.B. "DoorPi") und anschließend eines Usernamens. Letzterer muss immer auf "bot" oder "Bot" enden (z.B. "MeinHMBot").
6. Nun ist der Bot eingerichtet und man erhält vom BotFather eine Nachricht mit dem API-Schlüssel des Bots und mit einem Link (z.B. "telegram.me/MeinHMBot").
7. Damit der Bot eine Nachricht schicken kann, muss noch die chat_id des Empfängers ermittelt werden. Dazu in der App auf den vom BotFather gesenden Link klicken und entweder "/start" eingeben oder unten auf den Start-Button klicken. Nun eine kleine Nachricht an den Bot senden (z.B. "Hallo Bot").
8. Auf der Konsole des Raspi nun folgendes eingeben (die "<>" des API-Schlüssels weglassen):

   Code: Alles auswählen

   curl -s -X POST https://api.telegram.org/bot<API-Schlüssel des Bots>/getUpdates

9. Nun in dem angezeigten String nach der ID des Chats suchen. Diese steht in der Regel hinter

   Code: Alles auswählen

   "chat"; {"id":

   Das war's.

Mit dem Befehl

Code: Alles auswählen

curl -s -k "https://api.telegram.org/bot<API-Schlüssel des Bots>/sendMessage" -d text="DoorPi gestartet" -d chat_id=<chatid>

sollte man sich nun über die Konsole des Raspi eine kleine Nachricht schicken lassen können, wobei "<API-Schlüssel des Bots>" der obige API-Key des Bots und "<chatid>" die ID des Chats sind.

Fertig.

Pushover als Push-Dienst

Da zwischenzeitlich auch Pushover um die Möglichkeit erweitert wurde, Bilder per Push-Nachricht zu versenden, habe ich diesen Dienst nun zusätzlich in die nachfolgenden Skripte mit eingebunden. Eine kurze Erläuterung für die Einrichtung und Konfiguration von Pushover findet sich hier.

Die Befehlszeilen zum Senden einer Push-Nachricht per Telegram und/oder Pushover lässt sich auch sehr gut in ein Shellskript integrieren, das vom DoorPi aufgerufen werden kann. Nachfolgend habe ich mal ein paar Shellskript-Beispiele gepostet, wie ich sie für verschiedene Push-Nachrichten und Steuerbefehle verwende. Dabei fragen die Skripte jeweils auf der CCU ab, welcher Push-Dienst aktiviert ist und senden dann darüber die Push-Nachricht. Das Ganze habe ich für zwei User eingerichtet. Nähere Infos hierzu liefern meine Erläuterungen zum zPNP.

Start und Stopp von DoorPi

Um mich über das Starten und Beenden des DoorPis informieren zu lassen, wird mit den beiden folgenden Events in der doorpi.ini jeweils ein Shellskript gestartet.

Code: Alles auswählen

[EVENT_AfterShutdown]
10 = os_execute:/usr/local/etc/DoorPi/scripts/StopDoorPi.sh

[EVENT_AfterStartup]
10 = os_execute:/usr/local/etc/DoorPi/scripts/StartDoorPi.sh

Hinweise

• Sämtlichen Shellskripten müssen Ausführungsrechte (z.B. mit "sudo chmod 755 *.sh") zugewiesen werden, damit sie entsprechend ausgeführt werden können.
• Zur Ermittlung der ISE IDs der benötigen Datenpunkte kann man auf der CCU unter "Skript testen" folgendes Skript ausführen, wobei "Name des Datenpunkts" für dessen genaue Bezeichnung steht.
  

  Code: Alles auswählen

  string ISEID = dom.GetObject("Name des Datenpunkts").ID();
  WriteLine(ISEID);

  So ergibt sich z.B. bei mir mit dem Datenpunktnamen "DG Dach Wettersensor Daten" die ISE ID für Kanal 1 des HmIP-SWO-PR zu 4982. Diese ID wird dann im Shellskript "LichtAn.sh" zum Auslesen des Helligkeitswerts verwendet.

Das Skript "StartDoorPi.sh" schickt in Abhängigkeit von der CCU-Systemvariablen "CCU SV Push Dienst" eine Push-Nachricht per Telegram und/oder Pushover, wenn der DoorPi neu gestartet wurde. Dabei wird auch die CCU-Systemvariable "Haus SV Anwesenheit" für die Priorität der Push-Nachricht berücksichtigt.

Code: Alles auswählen

#!/bin/bash
CCU_IP=192.xxx.xxx.xxx # IP-Adresse der CCU
LBoxPi_IP=192.xxx.xxx.xxx # IP-Adresse des LBoxPi

# Telegram Keys
TgHMinfo=xxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Token "HomeMatic Info"
TgHMwarning=xxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Token "HomeMatic Warnung"
TgChatId1=xxxxxxxxx # Telegram Chat-ID Benutzer 1
TgChatId2= # Telegram Chat-ID Benutzer 2

# Pushover Keys
PoHMinfo=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Token "HomeMatic Info" 
PoHMwarning=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  # Token "HomeMatic Warnung"
PoUser1=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # API-Key Benutzer 1
PoUser2= # API-Key Benutzer 2

# HomeMatic CCU ISE_IDs
HMiseid1= # "Haus SV Anwesendheit"
HMiseid2= # "CCU SV Push Dienst" 0(aus) 1(alle) 2(Pushover) 3(Telegram)

# CCU-Systemvariable "Haus SV Anwesendheit" auslesen
present=$(curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid1}).Value()")
present=${present##*<x>}
present=${present%%</x>*}
# echo $present

# CCU-Systemvariable "CCU SV Push Dienst" auslesen
service=$(curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid2}).Value()")
service=${service##*<x>}
service=${service%%</x>*}
# echo $service

# An- oder Abwesenheit
if [ "$present" = "true" ] # Anwesenheit
  then 
  TgHMlevel=$TgHMinfo
  TgMessage="DoorPi neu gestartet."
  PoHMlevel=$PoHMinfo
  PoMessage="DoorPi neu gestartet."
  PoPrio=0
  PoSound=classical
else # Abwesenheit
  TgHMlevel=$TgHwarning
  TgMessage="Achtung, DoorPi <b>in ABWESENHEIT</b> neu gestartet!"
  PoHMlevel=$PoHMwarning
  PoMessage=" <font color=orange>Achtung, DoorPi in Abwesenheit neu gestartet!</font>"
  PoPrio=1
  PoSound=siren
fi

# Push-Nachricht senden
if [ $service -eq 3 -o $service -eq 1 ] # Telegram
  then 
  if [ -n "$TgChatId1" ] # Benutzer 1
    then
    curl -s -k "https://api.telegram.org/bot${TgHMlevel}/sendMessage" -d text="$TgMessage" -d chat_id=$TgChatId1 -d parse_mode=html
  fi
  if [ -n "$TgChatId2" ] # Benutzer 2
    then
    curl -s -k "https://api.telegram.org/bot${TgHMlevel}/sendMessage" -d text="$TgMessage" -d chat_id=$TgChatId2 -d parse_mode=html
  fi
elif [ $service -eq 2 -o $service -eq 1 ] # Pushover	
  then
  if [ -n "$PoUser1" ] # Benutzer 1
    then
    curl -s -k -F token=$PoHMlevel -F user=$PoUser1 -F message="$PoMessage" -F priority=$PoPrio -F sound=$PoSound -F html=1 "https://api.pushover.net/1/messages.json"
  fi
  if [ -n "$PoUser2" ] # Benutzer 2
    then
    curl -s -k -F token=$PoHMlevel -F user=$PoUser2 -F message="$PoMessage" -F priority=$PoPrio -F sound=$PoSound -F html=1 "https://api.pushover.net/1/messages.json"
  fi
fi

exit 0

Das Skript "StopDoorPi.sh" schickt zudem in Abhängigkeit von der CCU-Systemvariablen "CCU SV Push Dienst" eine Push-Nachricht per Telegram und/oder Pushover, wenn der DoorPi heruntergefahren wurde.

Code: Alles auswählen

#!/bin/bash
CCU_IP=192.xxx.xxx.xxx # IP-Adresse der CCU
LBoxPi_IP=192.xxx.xxx.xxx # IP-Adresse des LBoxPi

# Telegram Keys
TgHMinfo=xxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Token "HomeMatic Info"
TgHMwarning=xxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Token "HomeMatic Warnung"
TgChatId1=xxxxxxxxx # Telegram Chat-ID Benutzer 1
TgChatId2= # Telegram Chat-ID Benutzer 2

# Pushover Keys
PoHMinfo=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Token "HomeMatic Info" 
PoHMwarning=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  # Token "HomeMatic Warnung"
PoUser1=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # API-Key Benutzer 1
PoUser2= # API-Key Benutzer 2

# HomeMatic CCU ISE_IDs
HMiseid1= # "Haus SV Anwesendheit"
HMiseid2= # "CCU SV Push Dienst" 0(aus) 1(alle) 2(Pushover) 3(Telegram)

# CCU-Systemvariable "Haus SV Anwesendheit" auslesen
present=$(curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid1}).Value()")
present=${present##*<x>}
present=${present%%</x>*}
# echo $present

# CCU-Systemvariable "CCU SV Push Dienst" auslesen
service=$(curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid2}).Value()")
service=${service##*<x>}
service=${service%%</x>*}
# echo $service

# An- oder Abwesenheit
if [ "$present" = "true" ] # Anwesenheit
  then 
  TgHMlevel=$TgHMinfo
  TgMessage="DoorPi heruntergefahren."
  PoHMlevel=$PoHMinfo
  PoMessage=" <font color=orange>DoorPi heruntergefahren.</font>"
  PoPrio=0
  PoSound=classical
else # Abwesenheit
  TgHMlevel=$TgHwarning
  TgMessage="Achtung, DoorPi <b>in ABWESENHEIT</b> beendet!"
  PoHMlevel=$PoHMwarning
  PoMessage=" <font color=red>Achtung, DoorPi in Abwesenheit beendet!</font>"
  PoPrio=1
  PoSound=siren
fi

# Push-Nachricht senden
if [ $service -eq 3 -o $service -eq 1 ] # Telegram
  then 
  if [ -n "$TgChatId1" ] # Benutzer 1
    then
    curl -s -k "https://api.telegram.org/bot${TgHMlevel}/sendMessage" -d text="$TgMessage" -d chat_id=$TgChatId1 -d parse_mode=html
  fi
  if [ -n "$TgChatId2" ] # Benutzer 2
    then
    curl -s -k "https://api.telegram.org/bot${TgHMlevel}/sendMessage" -d text="$TgMessage" -d chat_id=$TgChatId2 -d parse_mode=html
  fi
elif [ $service -eq 2 -o $service -eq 1 ] # Pushover	
  then
  if [ -n "$PoUser1" ] # Benutzer 1
    then
    curl -s -k -F token=$PoHMlevel -F user=$PoUser1 -F message="$PoMessage" -F priority=$PoPrio -F sound=$PoSound -F html=1 "https://api.pushover.net/1/messages.json"
  fi
  if [ -n "$PoUser2" ] # Benutzer 2
    then
    curl -s -k -F token=$PoHMlevel -F user=$PoUser2 -F message="$PoMessage" -F priority=$PoPrio -F sound=$PoSound -F html=1 "https://api.pushover.net/1/messages.json"
  fi
fi

exit 0

Klingeln an der Haustür

Bei der Beschreibung des Schaltplans bin ich bereits auf die wesentlichen doorpi.ini-Einträge zum Klingeltaster eingegangen. Weiterhin werden in Abhängigkeit vom Klingeltaster auch noch die Shellskripte "Klingel.sh" und "LichtAn.sh" getriggert.

Code: Alles auswählen

[EVENT_OnKeyPressed_onboardpins.0]
10 = file_call_value:/usr/local/etc/DoorPi/rufumleitung.txt
20 = os_execute:/usr/local/etc/DoorPi/scripts/Klingel.sh
30 = os_execute:/usr/local/etc/DoorPi/scripts/LichtAn.sh

...

[keyboards]
onboardpins = piface

...

[onboardpins_InputPins]
0 = sleep:0

Mit "Klingel.sh" wird im Wesentlichen eine Push-Nachricht per Telegram und/oder Pushover inkl. eines mit dem RPi-Cam-Web-Interface aufgenommenen Bildes der Briefkastenkamera gesendet. Außerdem schaltet das Skript bei Anwesenheit die virtuelle Taste "EG Briefkasten VT Klingel" auf der CCU, mittels der weitere Ereignisse, wie z.B. das Blinken des Dimmers im Büro des Kellers, ausgelöst werden.

Code: Alles auswählen

#!/bin/bash
CCU_IP=192.xxx.xxx.xxx # IP-Adresse der CCU
LBoxPi_IP=192.xxx.xxx.xxx # IP-Adresse des LBoxPi

# Telegram Keys
TgHMinfo=xxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Telegram Bot Token "HomeMatic Info" Benutzer 1
TgChatId1=xxxxxxxxx # Telegram Chat-ID Benutzer 1
TgChatId2= # Telegram Chat-ID Benutzer 2

# Pushover Keys
PoHMinfo=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Token "HomeMatic Info"
PoUser1=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # API-Key Benutzer 1
PoUser2= # API-Key Benutzer 2

# HomeMatic CCU ISE_IDs
HMiseid1= # "Haus SV Anwesenheit"
HMiseid2= # "CCU SV Push Dienst" 0(aus) 1(alle) 2(Pushover) 3(Telegram)
HMiseid3= # "EG Briefkasten VT Klingel"

# CCU-Systemvariable "Haus SV Anwesendheit" auslesen
present=$(curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid1}).Value()")
present=${present##*<x>}
present=${present%%</x>*}
# echo $present

# CCU-Systemvariable "CCU SV Push Dienst" auslesen
service=$(curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid2}).Value()")
service=${service##*<x>}
service=${service%%</x>*}
# echo $service

# Shellscript zum Einschalten des Lichts aufrufen
sh /usr/local/etc/DoorPi/scripts/LichtAn.sh

# Snapshot holen
wget -O /home/pi/Haustürklingel.jpg http://${LBoxPi_IP}:8181/cam.jpg

# An- oder Abwesenheit
if [ "$present" = "true" ] # Anwesenheit
  then 
  # virtuellen CCU-Schalter "EG Briefkasten VT Klingel" betätigen
  curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid3}).DPByHssDP('PRESS_SHORT').State(1)"

  TgMessage="Haustürklingel in Anwesenheit betätigt."
  PoMessage=" <font color=royalblue>Haustürklingel in Anwesenheit betätigt.</font>"
  PoPrio=0
  PoSound=pushover
else # Abwesenheit
  TgMessage="Haustürklingel <b>in ABWESENHEIT</b> betätigt."
  PoMessage=" <font color=orange>Haustürklingel in Abwesenheit betätigt.</font>"
  PoPrio=-1
  PoSound=pushover
fi

# Push-Nachricht senden
if [ $service -eq 3 -o $service -eq 1 ] # Telegram
  then 
  if [ -n "$TgChatId1" ] # Benutzer 1
    then
    curl -s -k "https://api.telegram.org/bot${TgHMinfo}/sendMessage" -d text="$TgMessage" -d chat_id=$TgChatId1 -d parse_mode=html
    curl -s -k "https://api.telegram.org/bot${TgHMinfo}/sendPhoto" -F chat_id=$TgChatId1 -F disable_notification=1 -F photo="@/home/pi/Haustürklingel.jpg"
  fi
  if [ -n "$TgChatId2" ] # Benutzer 2
    then
    curl -s -k "https://api.telegram.org/bot${TgHMinfo}/sendMessage" -d text="$TgMessage" -d chat_id=$TgChatId2 -d parse_mode=html
    curl -s -k "https://api.telegram.org/bot${TgHMinfo}/sendPhoto" -F chat_id=$TgChatId2 -F disable_notification=1 -F photo="@/home/pi/Haustürklingel.jpg"
  fi
elif [ $service -eq 2 -o $service -eq 1 ] # Pushover	
  then
  if [ -n "$PoUser1" ] # Benutzer 1
    then
    curl -s -k -F token=$PoHMinfo -F user=$PoUser1 -F message="$PoMessage" -F attachment="@/home/pi/Haustürklingel.jpg" -F priority=$PoPrio -F sound=$PoSound -F html=1 "https://api.pushover.net/1/messages.json"
  fi
  if [ -n "$PoUser2" ] # Benutzer 2
    then
    curl -s -k -F token=$PoHMinfo -F user=$PoUser2 -F message="$PoMessage" -F attachment="@/home/pi/Haustürklingel.jpg" -F priority=$PoPrio -F sound=$PoSound -F html=1 "https://api.pushover.net/1/messages.json"
  fi
fi

exit 0

Das Skript "LichtAn.sh" dient zum automatischen Einschalten der Haustürbeleuchtung und wird weiter unten behandelt.

Ich habe die Shellskripte als txt-Dateien angefügt, da sh-Dateien von der Forumssoftware nicht unterstützt werden. Bitte die Endungen der herunter geladenen Dateien einfach von txt in sh ändern.

[dtp]

Briefeinwürfe zählen und zurücksetzen

Code: Alles auswählen

...
[EVENT_OnKeyPressed_onboardpins.1]
10 = os_execute:/usr/local/etc/DoorPi/scripts/BriefkastenEinwurf.sh

[EVENT_OnKeyPressed_onboardpins.2]
10 = os_execute:/usr/local/etc/DoorPi/scripts/BriefkastenLeerung.sh

...

[keyboards]
onboardpins = piface

[onboardpins_InputPins]
...
1 = sleep:0
2 = sleep:0
...

Shellskript "BriefkastenEinwurf.sh" zum Zählen der Briefkasten-Einwürfe und zum Senden eines Bilds der Briefkastenkamera beim Einwurf:

Code: Alles auswählen

#!/bin/bash
CCU_IP=192.xxx.xxx.xxx # IP-Adresse der CCU
LBoxPi_IP=192.xxx.xxx.xxx # IP-Adresse des LBoxPi

# Telegram Keys
TgHMinfo=xxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Telegram Bot Token "HomeMatic Info" Benutzer 1
TgChatId1=xxxxxxxxx # Telegram Chat-ID Benutzer 1
TgChatId2= # Telegram Chat-ID Benutzer 2

# Pushover Keys
PoHMinfo=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Token "HomeMatic Info"
PoUser1=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # API-Key Benutzer 1
PoUser2= # API-Key Benutzer 2

# HomeMatic CCU ISE_IDs
HMiseid1= # "CCU SV Push Dienst" 0(aus) 1(alle) 2(Pushover) 3(Telegram)
HMiseid2= # "EG Briefkasten VT Klappe"

# CCU-Systemvariable "CCU SV Push Dienst" auslesen
service=$(curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid1}).Value()")
service=${service##*<x>}
service=${service%%</x>*}
# echo $service

# Shellscript zum Einschalten des Lichts aufrufen
sh /usr/local/etc/DoorPi/scripts/LichtAn.sh

# virtuelle CCU-Taste "EG Briefkasten VT Klappe" betätigen
curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid2}).DPByHssDP('PRESS_SHORT').State(1)"

# Snapshot holen
wget -O /home/pi/Briefkasteneinwurf.jpg http://${LBoxPi_IP}:8181/cam.jpg
sleep 2

# Push-Nachricht senden
if [ $service -eq 3 -o $service -eq 1 ] # Telegram
  then 
  if [ -n "$TgChatId1" ] # Benutzer 1
    then
    curl -s -k "https://api.telegram.org/bot${TgHMinfo}/sendPhoto" -F chat_id=$TgChatId1 -F disable_notification=1 -F photo="@/home/pi/Briefkasteneinwurf.jpg"
  fi
  if [ -n "$TgChatId2" ] # Benutzer 2
    then
    curl -s -k "https://api.telegram.org/bot${TgHMinfo}/sendPhoto" -F chat_id=$TgChatId2 -F disable_notification=1 -F photo="@/home/pi/Briefkasteneinwurf.jpg"
  fi
elif [ $service -eq 2 -o $service -eq 1 ] # Pushover	
  then 
  if [ -n "$PoUser1" ] # Benutzer 1
    then
    curl -s -k -F token=$PoHMinfo -F user=$PoUser1 -F message=" <font color=royalblue>Briefkasteneinwurf!</font>" -F attachment="@/home/pi/Briefkasteneinwurf.jpg" -F priority=-1 -F sound=none -F html=1 "https://api.pushover.net/1/messages.json"
  fi
  if [ -n "$PoUser2" ] # Benutzer 2
    then
    curl -s -k -F token=$PoHMinfo -F user=$PoUser2 -F message=" <font color=royalblue>Briefkasteneinwurf!</font>" -F attachment="@/home/pi/Briefkasteneinwurf.jpg" -F priority=-1 -F sound=none -F html=1 "https://api.pushover.net/1/messages.json"
  fi
fi

exit 0

Shellskript "BriefkastenLeerung.sh" zum Zurücksetzen des Einwurfzählers auf der CCU per virtueller Taste:

Code: Alles auswählen

#!/bin/bash
CCU_IP=192.xxx.xxx.xxx # IP-Adresse der CCU

# HomeMatic CCU ISE_IDs
HMiseid1= # "EG Briefkasten VT Tür"

# virtuelle CCU-Taste "EG Briefkasten VT Tür" betätigen
curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid1}).DPByHssDP('PRESS_SHORT').State(1)"

exit 0

Briefkasten-Taster

Input-Pin 3 des PiFace-Moduls wurde mit dem nachträglich in die Briefkastentür eingesetzten Taster verbunden. Warum ich diesen Taster eingebaut habe? Nun, mir kam die Idee, dass man doch einfach mit einer LED im Briefkasten anzeigen lassen könnte, ob sich Post darin befindet. Da ich diese LED nach einem Briefkasteneinwurf nicht permanent leuchten lassen wollte, entschied ich mich für eine Abfrage per Taster, wobei die LED für den Fall, das sich Post im Briefkasten befindet, für 6 Sekunden leuchtet und danach automatisch wieder erlischt.

Die LED habe ich gemäß obigem Schaltplan mit Output-Pin 2 verbunden. Achtung: Output-Pins 0 und 1 sind jeweils parallel mit den Relais 0 und 1 des PiFace-Moduls verschaltet. Und da beide Relais anderweitig benutzt werden (Relais0 für den Lautsprecher, Relais1 für den Türöffner), sind die Pins 0 und 1 bereits belegt.

Die notwendigen Einträge für den Taster und die LED in der doorpi.ini lauten:

Code: Alles auswählen

...
[EVENT_OnKeyPressed_onboardpins.3]
10 = os_execute:/usr/local/etc/DoorPi/scripts/BriefkastenStatus.sh

...

[keyboards]
onboardpins = piface
virtual = filesystem

...

[onboardpins_InputPins]
3 = sleep:0

...

[onboardpins_OutputPins]
2 = Briefkasten-Status-LED

...

[virtual_keyboard]
base_path_output = /usr/local/etc/DoorPi/filesystem/outputs/
base_path_input = /usr/local/etc/DoorPi/filesystem/inputs/

[virtual_InputPins]
briefkastenstatus = out:Briefkasten-Status-LED,1,0,6

Auf die Besonderheiten des Filesystems gehe ich dann an entsprechender Stelle ein.

Hier noch das zugehörige Shellskript "BriefkastenStatus.sh" zum Setzen der Datei "briefkastenstatus" auf true bei mindestens einem Einwurf, was dann zum Einschalten der Status-LED gemäß "[virtual_InputPins]" für sechs Sekunden führt.

Code: Alles auswählen

#!/bin/bash
CCU_IP=192.xxx.xxx.xxx # IP-Adresse der CCU

# HomeMatic CCU ISE_IDs
HMiseid1= # "EG Briefkasten SV Einwürfe"

# CCU-Systemvariable "EG Briefkasten SV Einwürfe" auslesen
inserts=$(curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid1}).Value()")
inserts=${inserts##*<x>}
inserts=${inserts%%</x>*}
# echo $inserts
    
# Briefkasten-Status-LED aktivieren, wenn Anzahl der Einwürfe größer oder gleich 1
if [ $inserts -ge 1 ] 
  then
  # Briefkasten-Status-LED über DoorPi aktivieren
  echo true > /usr/local/etc/DoorPi/filesystem/inputs/briefkastenstatus
fi

exit 0

Sabotagekontakt für die Serviceklappe

Shellskript "BriefkastenSabotage.sh" zur Sabotagemeldung

Code: Alles auswählen

#!/bin/bash
CCU_IP=192.xxx.xxx.xxx # IP-Adresse der CCU
LBoxPi_IP=192.xxx.xxx.xxx # IP-Adresse des LBoxPi

# Telegram Keys
TgHMwarning=xxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Token "HomeMatic Warnung"
TgHMalarm=xxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Token "HomeMatic Alarm"
TgChatId1=xxxxxxxxx # Telegram Chat-ID Benutzer 1
TgChatId2= # Telegram Chat-ID Benutzer 2

# Pushover Keys
PoHMwarning=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Token "HomeMatic Warnung" 
PoHMalarm=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  # Token "HomeMatic Alarm"
PoUser1=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # API-Key Benutzer 1
PoUser2= # API-Key Benutzer 2

# HomeMatic CCU ISE_IDs
HMiseid1= # "Haus SV Anwesenheit"
HMiseid2= # "CCU SV Push Dienst" 0(aus) 1(alle) 2(Pushover) 3(Telegram)

# CCU-Systemvariable "Haus SV Anwesendheit" auslesen
present=$(curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid1}).Value()")
present=${present##*<x>}
present=${present%%</x>*}
# echo $present

# CCU-Systemvariable "CCU SV Push Dienst" auslesen
service=$(curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid2}).Value()")
service=${service##*<x>}
service=${service%%</x>*}
# echo $service

# Shellscript zum Einschalten des Lichts aufrufen
sh /usr/local/etc/DoorPi/scripts/LichtAn.sh

# Snapshot holen
wget -O /home/pi/Haustürklingel.jpg http://${LBoxPi_IP}:8181/cam.jpg

# An- oder Abwesenheit
if [ "$present" = "true" ] # Anwesenheit
  then 
  TgHMlevel=$TgHMwarning
  TgMessage=" <b>Briefkasten-Serviceklappe in Anwesenheit geöffnet.</b>"
  PoHMlevel=$PoHMwarning
  PoMessage=" <font color=orange>Briefkasten-Serviceklappe in Anwesenheit geöffnet.</font>"
  PoPrio=1
  PoSound=intermission
else # Abwesenheit
  TgHMlevel=$TgHMalarm
  TgMessage=" <b>Achtung, Sabotage am Briefkasten!</b>"
  PoHMlevel=$PoHMalarm
  PoMessage=" <font color=red>Achtung, Sabotage am Briefkasten!</font>"
  PoPrio=2
  PoSound=persistent
fi

# Push-Nachricht senden
if [ $service -eq 3 -o $service -eq 1 ] # Telegram
  then 
  if [ -n "$TgChatId1" ] # Benutzer 1
    then
    curl -s -k "https://api.telegram.org/bot${TgHMlevel}/sendMessage" -d text="$TgMessage" -d chat_id=$TgChatId1 -d parse_mode=html
    curl -s -k "https://api.telegram.org/bot${TgHMlevel}/sendPhoto" -F chat_id=$TgChatId1 -F disable_notification=1 -F photo="@/home/pi/Haustürklingel.jpg"
  fi
  if [ -n "$TgChatId2" ] # Benutzer 2
    then
    curl -s -k "https://api.telegram.org/bot${TgHMlevel}/sendMessage" -d text="$TgMessage" -d chat_id=$TgChatId2 -d parse_mode=html
    curl -s -k "https://api.telegram.org/bot${TgHMlevel}/sendPhoto" -F chat_id=$TgChatId2 -F disable_notification=1 -F photo="@/home/pi/Haustürklingel.jpg"
  fi
elif [ $service -eq 2 -o $service -eq 1 ] # Pushover	
  then
  if [ -n "$PoUser1" ] # Benutzer 1
    then
    curl -s -k -F token=$PoHMlevel -F user=$PoUser1 -F message="$PoMessage" -F attachment="@/home/pi/Haustürklingel.jpg" -F priority=$PoPrio -F sound=$PoSound -F html=1 "https://api.pushover.net/1/messages.json"
  fi
  if [ -n "$PoUser2" ] # Benutzer 2
    then
    curl -s -k -F token=$PoHMlevel -F user=$PoUser2 -F message="$PoMessage" -F attachment="@/home/pi/Haustürklingel.jpg" -F priority=$PoPrio -F sound=$PoSound -F html=1 "https://api.pushover.net/1/messages.json"
  fi
fi

exit 0

Ich habe die Shellskripte als txt-Dateien angefügt, da sh-Dateien von der Forumssoftware nicht unterstützt werden. Bitte die Endungen der herunter geladenen Dateien einfach von txt in sh ändern.

[dtp]

Haustürbeleuchtung

Shellskript "LichtAn.sh" zum Einschalten der Haustürbeleuchtung

Code: Alles auswählen

#!/bin/bash
CCU_IP=192.xxx.xxx.xxx # IP-Adresse der CCU

# HomeMatic CCU ISE_IDs
HMiseid1= # "EG Haustür Licht"
HMiseid2= # "DG Dach Wettersensor Daten"

# Helligkeit des Kombisensors abfragen
brightness=$(curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid2}).DPByHssDP('ILLUMINATION').Value()")
brightness=${brightness##*<x>}
brightness=${brightness%%</x>*}
# echo $brightness

# HM-Aktor "EG Hautür Licht" einschalten, wenn Helligkeitsschwelle unterschritten
if [ "$brightness" -lt 80 ]
  then
  curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid1}).State(1)"
fi

exit 0

Shellskript "LichtAus.sh" zum Ausschalten der Haustürbeleuchtung

Code: Alles auswählen

#!/bin/bash
CCU_IP=192.xxx.xxx.xxx # IP-Adresse der CCU

# HomeMatic CCU ISE_IDs
HMiseid1= # "EG Hautür Licht"

# HM-Aktor "EG Hautür Licht" ausschalten
curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid1}).State(0)"

exit 0

Türöffner

Da unsere Haustür bereits mit einem elektrischen Türöffner ausgestattet war, der sich über den TLE 061-0 ansteuern ließ, war es recht einfach, diesen zusätzlich auch über den DoorPi anzusteuern. Dazu mussten lediglich die Anschlüsse C und NO des Relais1 mit den Anschlüssen c und Tö des TLE 061-0 verbunden werden. Die Ansteuerung des Relais1 erfolgt über Input-Pin 6 des PiFace-Moduls. Ein zusätzlicher Hardware-Taster ist hier nicht notwendig, da dazu weiterhin die Taster der Haustelefone HTS 811-0 dienen. Außerdem lässt sich der Türöffner auch durch die CCU und die FRITZ!Fons betätigen. Aber dazu später mehr.

Und hier noch die notwendigen Einträge in der doorpi.ini:

Code: Alles auswählen

[DTMF]
"##" = out:Tueroeffner,1,0,3

...

[EVENT_OnKeyPressed_onboardpins.6]
10 = out:Tueroeffner,1,0,3

...

[keyboards]
onboardpins = piface

...

[onboardpins_InputPins]
6 = sleep:0

...

[onboardpins_OutputPins]
1 = Tueroeffner

Ich habe die Shellskripte als txt-Dateien angefügt, da sh-Dateien von der Forumssoftware nicht unterstützt werden. Bitte die Endungen der herunter geladenen Dateien einfach von txt in sh ändern.

[dtp]

[braindead]

Super! Wenn ich nicht schon eine Kamera vor der Tür installiert hätte, wäre das eine gute Alternative gewesen.