DoorPi-Videotürsprechanlage und HomeMatic

User stellen ihre Haussteuerung vor

Moderator: Co-Administratoren

dtp
Beiträge: 4924
Registriert: 21.09.2012, 08:09
Wohnort: Stuttgart

DoorPi-Videotürsprechanlage und HomeMatic

Beitrag von dtp » 01.04.2016, 08:59

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.
Briefkasten_01.JPG
DoorPi_dtp_02.jpg
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.
Briefkasten_02.jpg
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.
DoorPi_dtp_01.jpg
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.
DoorPi_dtp_05.jpg
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.
DoorPi_dtp_03.jpg
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.
DoorPi_dtp_07.jpg
Weiterhin befindet sich dort eine USB-Soundkarte, die den Raspi 3 mit dem Mikro und dem Lautsprecher des TLE 061-0 verbindet.
DoorPi_dtp_04.jpg
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 per Telegram.
  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.
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

Hinweis: Wer das PiFace Digital 2 Modul unter Raspbian Stretch nutzen möchte, sollte bitte unbedingt dies beachten. Wer dagegen Raspbian Jessie verwendet, braucht lediglich unter raspian-config das SPI auf enabled zu setzen.
Zuletzt geändert von dtp am 10.01.2018, 09:48, insgesamt 30-mal geändert.

dtp
Beiträge: 4924
Registriert: 21.09.2012, 08:09
Wohnort: Stuttgart

1. Installation von DoorPi und RPI-Cam-Web-Interface

Beitrag von dtp » 01.04.2016, 09:02

Vorbereitung des Raspberry Pi 3

Da sich im Internet zahlreiche Seiten mit der Einrichtung eines Raspberry Pi befassen, möchte ich hier nur zwei stellvertretende Links posten. Bitte einfach den Anleitungen Schritt für Schritt folgen. Sie gelten weitestgehend unabhängig vom Raspi-Modell und der gewählten Raspian-Version.

Klick und klick!

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.

Die Einrichtung ist z.B. hier (Variante 2 wählen) sehr gut beschrieben.

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.10" des Raspi 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.10/24
static routers=192.168.0.1
static domain_name_servers=192.168.0.1
Vermeiden eines Abbruchs der WLAN-Verbindung

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
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
sudo chown -R pi:pi /usr/local/etc/DoorPi
Erster Start des DoorPi

Ist alles ohne Fehlermeldungen durchgelaufen, sollte der DoorPi mit folgendem Befehl aus dem Verzeichnis "/usr/local/etc/DoorPi" heraus gestartet werden können:

Code: Alles auswählen

cd /usr/local/etc/DoorPi
./main.py --trace
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. Zunächst sollte 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 git clone https://github.com/silvanmelchior/RPi_Cam_Web_Interface.git
    cd RPi_Cam_Web_Interface
    sudo chmod u+x *.sh
    sudo ./install.sh
    Hinweis: Unter Raspbian Jessie oder Stretch Lite muss vorher noch git mit

    Code: Alles auswählen

    sudo apt-get install git
    installiert werden. Das obige Setzen der Rechte für die Shellskripte ist nur für ältere Versionen des RPi_Cam_Web_Interfaces notwendig.
  3. Zur Konfigration und zum Starten des RPI-Cam-Web-Interface den Befehl

    Code: Alles auswählen

    ./RPi_Cam_Web_Interface_Installer.sh install

    erneut ausführen. Im dann erscheinenden Fenster des Installers können schließlich unter Punkt x3 weitere Konfigurationen vorgenommen und unter Punkt x4 das Interface gestartet werden.
    RPI-Cam-Web-Interface.jpg
    Das Interface lässt sich übrigens später jederzeit durch Aufruf von

    Code: Alles auswählen

    ./RPi_Cam_Web_Interface_Installer.sh

    im Verzeichnis "/RPi_Cam_Web_Interface" öffnen.
  4. Schließlich lässt sich durch Eingabe der IP-Adresse des Raspi in einem Browser-Fenster direkt das Web-Interface öffnen.
    RPI-Cam-Web-Interface2.jpg
  5. Ein Tipp noch zum Abschluss: Gelegentlich kann es vorkommen, dass sich das RPi_Cam_Web_Interface nicht updaten lässt. Dann empfiehlt sich die Eingabe von

    Code: Alles auswählen

    cd RPi_Cam_Web_Interface
    git reset --hard FETCH_HEAD
Gruß,

Thorsten
Zuletzt geändert von dtp am 09.04.2018, 07:46, insgesamt 29-mal geändert.

dtp
Beiträge: 4924
Registriert: 21.09.2012, 08:09
Wohnort: Stuttgart

2. Konfiguration des DoorPi und der FRITZ!Box

Beitrag von dtp » 01.04.2016, 09:02

Konfiguration der USB-Soundkarte

Der ALSA-Treiber wird automatisch mit Raspian Jessie 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 steht auch noch in "/home/pi/.asoundrc". 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_installer]
.* = 

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

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

[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

[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 = call:11
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

[Group]
administrator = door

[SIP-Phone]
firewallpolicy = PolicyNoFirewall
audio_codecs = PCMA,PCMU
call_timeout = 16
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 = xxxxxxx
sipserver_realm = fritz.box
sipserver_server = 192.xxx.xxx.xxx
sipserver_username = 620
stun_server = 
ua.max_calls = 2
video_codecs = VP8
video_device = StaticImage: Static picture
video_display_enabled = False
video_size = vga

[User]
door = pi

[WritePermission]
administrator = installer

[keyboards]
onboardpins = piface
virtual = filesystem

[onboardpins_InputPins]
0 = Klingel
1 = Briefkasten-Klappe
2 = Briefkasten-Tuer
3 = Briefkasten-Status
4 = Licht
5 = Briefkasten-Sabotage
6 = Tueroeffner
7 = Auflegen

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

[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/

[virtual_InputPins]
briefkastenstatus = out:Briefkasten-Status-LED,1,0,6
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.
SIP-Server_FB_01.png
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) 131-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.
SIP-Server_FB_02.png
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.
SIP-Server_FB_03.png
Zuletzt geändert von dtp am 16.03.2018, 15:40, insgesamt 22-mal geändert.

dtp
Beiträge: 4924
Registriert: 21.09.2012, 08:09
Wohnort: Stuttgart

3. Umbaumaßnahmen am Siedle TLE 061-0

Beitrag von dtp » 01.04.2016, 09:07

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.
DoorPi_SiedleTLE061_01.jpg
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.
DoorPi_SiedleTLE061_03.jpg
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).
LBoxPi_Blockschaltbild.png
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.
SiedleTLE061_mod.jpg
Hier noch ein Bild von der wieder in die Gehäuseunterschale eingesetzten Platine des TLE 061-0.
DoorPi_SiedleTLE061_05.jpg
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.
DoorPi_SiedleTLE061_09.jpg
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.
Zuletzt geändert von dtp am 15.08.2017, 08:17, insgesamt 13-mal geändert.

dtp
Beiträge: 4924
Registriert: 21.09.2012, 08:09
Wohnort: Stuttgart

4. Anschluss des Klingeltasters und der Mikrotaster

Beitrag von dtp » 01.04.2016, 09:07

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.
LBoxPi_Schaltplan.png
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 = call:11
...
[keyboards]
onboardpins = piface
...
[onboardpins_InputPins]
0 = Klingel
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.
Briefkasten_02.jpg
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

[keyboards]
onboardpins = piface
...
[onboardpins_InputPins]
1 = Briefkasten-Klappe
2 = Briefkasten-Tuer
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.
DoorPi_dtp_01.jpg
Hier noch die dafür notwendigen Einträge in der doorpi.ini:

Code: Alles auswählen

[keyboards]
onboardpins = piface
...
[onboardpins_InputPins]
5 = Briefkasten-Sabotage
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
Briefkasten_01.JPG (62.44 KiB) 6655 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

[keyboards]
onboardpins = piface
...
[onboardpins_InputPins]
4 = Licht
Zuletzt geändert von dtp am 15.03.2018, 17:28, insgesamt 33-mal geändert.

dtp
Beiträge: 4924
Registriert: 21.09.2012, 08:09
Wohnort: Stuttgart

5. Konfiguration des DoorPi zum Versenden von Push-Nachricht

Beitrag von dtp » 01.04.2016, 09:08

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
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.168.xxx.xxx # IP-Adresse der CCU
LBoxPi_IP=192.168.xxx.xxx # IP-Adresse des LBoxPi

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

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

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

# CCU-Systemvariable "Haus SV Anwesenheit" 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="Achtung, DoorPi <font color=orange>in Abwesenheit</font> neu gestartet!"
  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.168.xxx.xxx # IP-Adresse der CCU
LBoxPi_IP=192.168.xxx.xxx # IP-Adresse des LBoxPi

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

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

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

# CCU-Systemvariable "Haus SV Anwesenheit" 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="DoorPi heruntergefahren."
  PoPrio=0
  PoSound=classical
else # Abwesenheit
  TgHMlevel=$TgHwarning
  TgMessage="Achtung, DoorPi <b>in Abwesenheit</b> beendet!"
  PoHMlevel=$PoHMwarning
  PoMessage="Achtung, DoorPi <font color=red>in Abwesenheit</font> beendet!"
  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 = call:11
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 = Klingel
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.168.xxx.xxx # IP-Adresse der CCU
LBoxPi_IP=192.168.xxx.xxx # IP-Adresse des LBoxPi

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

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

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

# CCU-Systemvariable "Haus SV Anwesenheit" 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

# 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="Haustürklingel in Anwesenheit betätigt."
  PoPrio=0
  PoSound=pushover
else # Abwesenheit
  TgMessage="Haustürklingel <b>in Abwesenheit</b> betätigt."
  PoMessage="Haustürklingel <font color=orange>in Abwesenheit</font> betätigt."
  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.
Dateianhänge
Klingel.txt
(3.08 KiB) 19-mal heruntergeladen
StopDoorPi.txt
(2.58 KiB) 16-mal heruntergeladen
StartDoorPi.txt
(2.59 KiB) 16-mal heruntergeladen
Zuletzt geändert von dtp am 01.04.2018, 18:07, insgesamt 40-mal geändert.

dtp
Beiträge: 4924
Registriert: 21.09.2012, 08:09
Wohnort: Stuttgart

6. Meldungen über Briefeinwürfe, Sabotage, etc.

Beitrag von dtp » 01.04.2016, 09:09

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 = Briefkasten-Klappe
2 = Briefkasten-Tuer
...
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.168.xxx.xxx # IP-Adresse der CCU
LBoxPi_IP=192.168.xxx.xxx # IP-Adresse des LBoxPi

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

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

# HomeMatic CCU ISE_IDs
HMiseid1=4203 # "CCU SV Push Dienst" 0(aus) 1(alle) 2(Pushover) 3(Telegram)
HMiseid2=1023 # "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="Briefkasteneinwurf" -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="$Briefkasteneinwurf" -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.168.xxx.xxx # IP-Adresse der CCU

# HomeMatic CCU ISE_IDs
HMiseid1=1027 # "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.
DoorPi_dtp_08.jpg
DoorPi_dtp_09.jpg
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 = Briefkasten-Status
...
[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.168.xxx.xxx # IP-Adresse der CCU

# HomeMatic CCU ISE_IDs
HMiseid1=62023 # "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.168.xxx.xxx # IP-Adresse der CCU
LBoxPi_IP=192.168.xxx.xxx # IP-Adresse des LBoxPi

# Telegram Keys
TgHMwarning=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Bot Token "HomeMatic Info"
TgHMalarm=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # Bot Token "HomeMatic Alarm"
TgChatId1=-xxxxxxxxxxx # Chat-ID Benutzer 1
TgChatId2= # Chat-ID Benutzer 2

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

# HomeMatic CCU ISE_IDs
HMiseid1=34197 # "Haus SV Anwesenheit"
HMiseid2=4203 # "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="Briefkasten-Serviceklappe in Anwesenheit geöffnet."
  PoPrio=1
  PoSound=intermission
else # Abwesenheit
  TgHMlevel=$TgHMalarm
  TgMessage="<b>ACHTUNG - Sabotage am Briefkasten!</b>"
  PoHMlevel=$PoHMalarm
  PoMessage="ACHTUNG - <font color=red>Sabotage</font> am Briefkasten!"
  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.
Dateianhänge
BriefkastenStatus.txt
(619 Bytes) 14-mal heruntergeladen
BriefkastenSabotage.txt
(3.23 KiB) 14-mal heruntergeladen
BriefkastenLeerung.txt
(304 Bytes) 14-mal heruntergeladen
BriefkastenEinwurf.txt
(2.26 KiB) 14-mal heruntergeladen
Zuletzt geändert von dtp am 01.04.2018, 18:07, insgesamt 18-mal geändert.

dtp
Beiträge: 4924
Registriert: 21.09.2012, 08:09
Wohnort: Stuttgart

7. Steuerung des Türöffners und der Haustürbeleuchtung

Beitrag von dtp » 01.04.2016, 09:09

Haustürbeleuchtung

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

Code: Alles auswählen

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

# HomeMatic CCU ISE_IDs
HMiseid1=4827 # "EG Haustür Licht"
HMiseid2=4960 # "Haus Wettersensor"
 
# Helligkeit des Kombisensors abfragen
brightness=$(curl -s -k "http://${CCU_IP}:8181/rega.exe?x=dom.GetObject(${HMiseid2}).DPByHssDP('BRIGHTNESS').Value()")
brightness=${brightness##*<x>}
brightness=${brightness%%</x>*}
# echo $brightness

# HM-Aktor "EG Hautür Licht" einschalten, wenn Helligkeitsschwelle unterschritten
if [ "$brightness" -lt 25 ]
  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.168.xxx.xxx # IP-Adresse der CCU

# HomeMatic CCU ISE_IDs
HMiseid1=4827 # "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 = Tueroeffner
...
[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.
Dateianhänge
LichtAus.txt
(257 Bytes) 16-mal heruntergeladen
LichtAn.txt
(628 Bytes) 16-mal heruntergeladen
Zuletzt geändert von dtp am 01.04.2018, 18:07, insgesamt 12-mal geändert.


braindead
Beiträge: 492
Registriert: 28.11.2014, 22:20

Re: DoorPi-Videotürsprechanlage und HomeMatic

Beitrag von braindead » 01.04.2016, 09:39

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

Antworten

Zurück zu „Projektvorstellungen“