DoorPi von MarcusS

Aktueller Stand: (August 2017)

Seit 20.5.2016 ohne irgendwelche Probleme im Livebetrieb. Nur zwecks Update neu gestartet.Winter und Sommer überstanden.

Hardware

• Board:Raspberry Pi 2
• Soundkarte:Conrad "No Name" (driverless)
• Verstärker: Kanal 3W PAM8403 Audio Verstärker
• Mikrofon: KönigCMP-MIC8 Mikrofon - Mikrofone (PC, 30 - 15000 Hz, verkabelt, Schwarz, 3.5mm)
• Kamera: Raspberry Pi Camera Modul
• Objektiv: Bresser Handy-Kamera Aufsatz Clip-On 180° Fisheye Handylinse (Nach starkem Regen ist Feuchtigkeit eingezogen s. U.)
• Lautsprecher: VISATON Kleinlautsprecher mit Kunststoffmembran und quadratischem Metallkorb 5 cm, K 50 SQ / 8 Ω
• Zusätzlich Massetrennfilter eingesetzt wegen massiver Störgeräusche: Mehr in diesem Thread hier

IOPlatine (Selbst gebaut)

• 2x GPIO Tast-Eingänge
  
  
  • a:Klingelstaster

  
  

  • b:Mikroschalter im Gehäuse, der auslöst, wenn der Deckel abgenommen wird (Alarm meiner Hausautomation)
• 1x LED Blau. Betriebsanzeige und weil sie einfach blau leuchtet
• 1x Relais um den Verstärker zu schalten (->Infos http://www.doorpi.org/forum/th…ais/?postID=1169#post1169)

Klingelanlage:Ich habe das UP Gehäuse von Loxone genommen, da ich diese Hausautomation einsetze. Sollte mit dem DoorPi mal was nicht so laufen wie ich es mir vorstelle, dann kann ich auf die Original SIP-Anlage zurückgreifen. Diese passt dann in das UP Gehäuse-

• Hier die UP Dose: http://shop.loxone.com/dede/unterputz-box.html
• Hier alle Infos zu meinem Nachbau der Klingelplatte: http://www.doorpi.org/forum/thread/43-mein-zuk%C3%BCnftiges-geh%C3%A4use/?postID=157#post157
• Das wäre die Originalanlage, die nur mit einem Loxone Miniserver kompatibel ist http://shop.loxone.com/dede/intercom.html

Sonstiges:

• Breadboard
• T-Cobbler40 Pin GPIO Extension Board
• Silicat Päckchen um die Feuchtigkeit aus dem Gehäuse zu halten
• Klettband zur flexiblen Befestigung der Platinen
• Silikon zu Abdichtung und Befestigung von Kamera, Mikrofon usw.
• Dichtungsband/Kompriband zur Abdichtung des Deckels
• Kabelbinder, Klebesockel usw.

Telko Hardware

• Fritzbox 7490 mit Fritz.OS > 6.5
• 2x Fritz.fon C4 (Als Video Sprechstelle)
  
  
  • Howto :Live-Bild für FRITZ! Fon
• ELCOM Video Phone auf einem Android Tablet:* https://play.google.com/store/…m.elcom.android.app&hl=de
  
  
  • Howto: Problem mit dem Stream per ELCOM App

  * ELCOM App habe ich durch eine Anbindung an App für die Loxone ersetzt.

  
  

  
  

  
  

  
  

  
  

Software

DoorPI 2.5.* mittels PIP:http://www.doorpi.org/forum/th…-2016-02-26-mittels-pypi/

• mjpg-streamer(Videostream auf dem selben Raspi installiert):http://www.doorpi.org/forum/th…lation-des-mjpg-streamer/
• Push per Telegram apphttp://www.doorpi.org/forum/th…oorpi/?postID=305#post305
• Verschiedene Scripte (Push, Mail, Ansprechen meiner Loxone Hausautomation)

Aktuelle Aktionen wenn es klingelt

• Anruf einer internen Gruppenrufnummer (Fritzbox Telefonbuch -> Gruppenruf). Gespräch und Anzeige des Streams auf den Fritz.fons und dem Tablet (Loxone oder alternativ Elcom App)
• Snapshot per Mail und Telegram Push App mit Bild und Benachrichtung der Loxone App per UDP
• Einschalten des Verstärkers bei Gesprächsannahme, abschalten nach Beendigung
• Umschaltung von Intern auf Mobil wenn abwesend. Führt zu merklich längeren Denkpausen bei Gästen, wenn man aus dem Urlaub zu ihnen spricht

Bekannte Probleme:

• Nach den reichhaltigen Regenfällen ist das Objektiv in der Mitte kurzzeitig blind geworden. Mögliche Lösung könnte das Objektiv aus dieser angeblichen IP54 Schutzhülle sein. Achtung: Anderer Durchmesser!
• Echo-Problem (wie fast alle hier) beim Sprechen. Hält sicher aber in Grenzen und reicht für ein "Tür-Gespräch"

Lessons learned:

• PiFace anstelle der GPIO Platine nehmen oder noch besser eine eigens im durch die FHEM Community entwickelte Platine https://wiki.fhem.de/wiki/DoorPiBoard
• Wassergeschütztes Objektiv nehmen (siehe oben)
• Doch besser eine Variante mit IR Beleuchtung für die Makera nehmen. Das würde allerdings die schlichte Optik meiner Deckplatte versauen. Ggf. kann der IR Scheinwerfer aber auch woanders sitzen. Müsste man austesten

Preise:

...............................................

Erste Schritte:
Prototypen Aufbau mit Breadboard:

IO Platine im Selbstbau

Gehäuse Unterputzdose:

Einbau ins Gehäuse (Mit Klettband, so kann man alles wieder abnehmen und es ist direkt gegen das Gehäuse isoliert)

So sieht das Endprodukt von Außen aus.

Seitenansicht mit eingebrachtem Kompriband, was man normalerweise beim Einbau von Fensterrahmen verwendet um Schlagregen abzuhalten. PU-Schaum vNext sozusagen

Hier die CAD Daten als TurboCAD sowie DXF Datei. Turbocad 2D V17 gibt es kostenlos bei Registrierung, falls ihr nachbearbeiten müsst/wollt.

Klingelplatte CAD.zip

Ein Hinweis zu den CAD Daten. Ich habe die Abdeckung als völliger Laie im CAD Programm erstellt. Daher sind dort mit Sicherheit diverse Dinge drin, die man nicht als "best practice" bezeichnen würde. So würde man vermutlich die Ausschnitte/Löcher nicht einfach nur als Kreis einzeichnen, sondern in Form einer boolschen Operation vom Werkstück "abziehen". Soll ja ein Loch und keine Gravur werden. Auch die Bemaßung wird mit Sicherheit als Layer eingefügt. Ich habe nicht verstanden wie es geht und daher zur Sicherheit ein PDF mit Beschreibungen erstellt. Das Sprechsieb ist übrigens eine Loch-Reihe in beiden Dimensionen zu groß für den von mir verwendeten Lautsprecher und müsste daher verkleinert werden bei einem Nachbau.

Habe ich mir gedacht Und um den Kreis vollständig zu schließen:

Ich bin im Loxone Forum auf die Türcksprechstelle aufmerksam geworden und hatte versucht diese nachzubauen.
https://www.loxforum.com/forum…sprechanlage-howto-teil-1

Da ich bis dahin noch nie einen Raspi hatte, kein Python kenne und seit 10 Jahren kein Linux mehr angefasste habe, bin ich aber kläglich gescheitert. Die Skripte und Installation aus dem Forum sind nichts für NOOBs da fehlerhaft und unvollständig. Von da aus bin ich dann ins Raspi-Forum auf diesen 100 Seiten Thread gekommen und nun hierhin. An dieser Stelle ein dickes Lob übrigens. Hier ist ein Schlaraffenland im Sachen Support und Doku (mittlerweile wirklich gut)

Ich hatte mich dann irgendwann entschieden keine Anlage für die Loxone zu bauen, sondern auf den DoorPi zu setzen. Das hat verschiedene Gründe. Zum Einen bin ich ein überzeugter Windows Phone (Lumia 950) und Surface Tablet User. Die Loxone Integration der Sprechanlage macht aber nur per App Sinn. Es gibts zwar ein Webinterface. aber dort gibts kein kein Push und keine Sprechverbindung. Ich hätte also von Windows weggemusst um die App nutzen zu können. Das möchte ich aber definitiv nicht. Beim Doorberry habe ich mehrere Wege (mail, 3rd Party Apps, Telegram).

Außerdem brauchte ich Community Support für das Projekt und der ist im Loxone Forum schwierig für den Doorberry. Alles zur Loxone ist super, aber sowas steht eben nicht im Fokus.

Ich kann mir mittlerweile aber vorstellen, dass sich die Loxone aber einfach einbinden ließe. Die Loxone ruft den DoorPi bzw. den Fritz.box als SIp Server an. So funktioniert es mit der Orginalanlage auch. Dieser baut dann einen Call zur Loxone App auf. Ich müsste also einen UPD Aufruf vom DoorPi zur Loxone per Script (os_execute) initiieren und dann wird ein Call aufgebaut. So stelle ich es mir in der Theorie zumindest vor

Zitat von motom001

Loxone wird keinen Support für Geräte geben

Das ist klar. Ich meinte auch den Community Support. Also gleichgesinnte Verrückte, die sich eine Anlage selber bauen

Aber noch mal zu Loxone. Ich glaube das ist machbar. Mit der Version aus dem Forum ging es ja schon bei mir. Wenn man sich den Code aus der Doorberry Implementierung für Loxone anschaut, dann wird glaube ich klar was gemacht werden muss. Das ist die sip.py aus dem Archiv im ersten Post des aktuellen Forums.

Es ist ein Übertrag aus dem eingestellten Hersteller Forum

# Actions for Button listener
    def btn_action(tmp, event):
        global outSocket
        try:
            # activate socket
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            if (event.pin_num == 0):
                s.sendto("?light#10?", (LOX_SERVER, LOX_UDP_OUT_PORT))
                logging.debug("light pushed!")
            elif (event.pin_num == 1):
                if not (current_call):
                    s.sendto("?bell#20 ?", (LOX_SERVER, LOX_UDP_OUT_PORT))
                    logging.debug("bell pushed!")
            elif (event.pin_num == 2):
                if not (current_call):
                    s.sendto("?post_incoming#30 ?", (LOX_SERVER, LOX_UDP_OUT_PORT))
                    logging.debug("post incoming!")
            elif (event.pin_num == 3):
                if not (current_call):
                    s.sendto("?post_obtained#40 ?", (LOX_SERVER, LOX_UDP_OUT_PORT))
                    logging.debug("post obtained!")
        except pj.Error, e:	
		logging.error("Exception: " + str(e))

Beim Drücken der Klingel wird ein Socket aufgemacht und per UDP eine speziell formatierte Nachricht an die Loxone geschickt. Auf Loxone Seite gibt es Eingangsverbinder, die diese Nachricht auswerten und verarbeiten (im verlinkten Loxone Thread. Speziell auch Post#1 und #13)
https://www.loxforum.com/forum…sprechanlage-howto-teil-1

Das könnte man doch gut in einem Script parken!?

Auf Loxone Seite wird dann ein Baustein namens "Türbausteuerung" angesprochen, der eine interne Nummer anruft. Das wäre dann wohl der SIP Account, unter dem der DoorPi an der Fritze registriert ist. So verstehe ich es

Das ist in dem Sinne keine API. Die Loxone hat für solche Zwecke http eingangsverbinder
http://www.loxone.com/dede/ser…tueller-http-eingang.html

Hier wird dann die abgeschickte Zeichenfolge ausgewertet. Wird sie erkannt, dann wird das der Türsteuerung gemeldet. In LOX_SERVER steht die IP des Loxone Servers im Schaltschrank (Also dem Herzstück der Haus-Automation)

Diese meldet sich dann beim Pi. Dort muss aber ein Listener laufen

Ich poste mal die vollstände sip.py. Da sind ei paar Sachen auskommentiert zu damaligen Testzwecken, die muss man sich wieder "reindenken"

#!/usr/bin/python


# Module:      SIP Intercom
# Version:     1.0
#
# Author:      Christian Gessner
# Date:        2014-03-02
# Description: SIP Intercom on RPI using PJSIP to communicate with Loxone miniserver's
#              door-control module
# Copyright:   Copyright (C) 2014 Christian Gessner <christiany@gessner.cc>
#
#
#
# Credits:     PJSIP/PJSUA:
#              Inspired by the call.py sample of the PSJIP distribution, http://www.pjsip.org
#
#              Raspberry Pi as Intercom:
#              Inspired by the door-berry project form Marco Pozzato, http://marpoz.blogspot.de
#              and https://github.com/mpodroid/door-berry


import pjsua as pj
from time import sleep
import RPi.GPIO as GPIO
import socket
import atexit
import logging
import threading


LOG_LEVEL = 0
current_call = None


lib = None
acc = None
transport = None




# Logging callback
def log_cb(level, str, len):
    logging.debug(str)




# Callback to receive events from account
class SipAccountCallback(pj.AccountCallback):
    sem = None


    def __init__(self, account=None):
        pj.AccountCallback.__init__(self, account)


    # Notification on incoming call
    def on_incoming_call(self, call):
        global current_call
        if current_call:
            call.answer(486, "Busy")
            return


        print "Incoming call from ", call.info().remote_uri
        logging.debug("Incoming call from ", call.info().remote_uri)
        current_call = call


        call_cb = SipCallCallback(current_call)
        current_call.set_callback(call_cb)
        current_call.answer(200)


    def wait(self):
	self.sem = threading.Semaphore(0)
	self.sem.acquire()


    def on_reg_state(self):
        logging.debug("on_reg_state")
	logging.debug("Status %d",self.account.info().reg_status)
	if self.sem:
	    if self.account.info().reg_status >= 200:
		self.sem.release()


# Callback to receive events from Call
class SipCallCallback(pj.CallCallback):


    def __init__(self, call=None):
        pj.CallCallback.__init__(self, call)


    # Notification when call state has changed
    def on_state(self):
        global current_call
        print "Call with", self.call.info().remote_uri,
        print "is", self.call.info().state_text,
        print "last code =", self.call.info().last_code,
        print "(" + self.call.info().last_reason + ")"


        if self.call.info().state == pj.CallState.DISCONNECTED:
            current_call = None
            print 'Current call is', current_call


    # Notification when call's media state has changed.
    def on_media_state(self):
        if self.call.info().media_state == pj.MediaState.ACTIVE:
            # Connect the call to sound device
            call_slot = self.call.info().conf_slot
            pj.Lib.instance().conf_connect(call_slot, 0)
            pj.Lib.instance().conf_connect(0, call_slot)
            print "Media is now active"
        else:
            print "Media is inactive"




# SIP Intercom listener class
class SipIntercom:


    # Constructor
    def __init__(self):
        # Initialize logging
        logging.basicConfig(filename='/home/pi/sip_intercom/sip.log', level=logging.DEBUG, format='%(asctime)s %(levelname)s %(threadName)-10s %(message)s')


        # Initialize GPIO pins
        #GPIO.setmode(GPIO.BCM)
        #GPIO.setup(23, GPIO.IN)
        #GPIO.setup(24, GPIO.IN)
        #GPIO.setup(25, GPIO.IN)
        #GPIO.setup(18, GPIO.OUT)


        logging.debug("initialized!")


    # Run SIP client and react to GPIO inputs by sending UDP telegrams
    def run(self):
        # Globals
        global lib
        global transport
        global acc


        logging.debug("run!")


        # Create library instance
        lib = pj.Lib()


        try:
            # Init library with default config and some customized logging config.
            lib.init(log_cfg=pj.LogConfig(level=LOG_LEVEL, callback=log_cb))


            # Create UDP transport which listens port 5060
            transport = lib.create_transport(pj.TransportType.UDP, pj.TransportConfig(5060))


            # Start the library
            lib.start()


            # Create local account
            # acc = lib.create_account_for_transport(transport, cb=SipAccountCallback())
            acc_cfg = pj.AccountConfig("iptel.org","mein_benutzername","mein_passwort")
            acc_cb = SipAccountCallback()
            acc = lib.create_account(acc_cfg, cb=acc_cb)
            acc_cb.wait()


            logging.debug("account registred!")


            # Turn on LED
            #GPIO.output(18, GPIO.HIGH)


            logging.info("SIP Intercom started!")
            logging.debug("pjsua started")


            # Menu loop
            while True:
                # This button quits the loop and exits the SIP listener
                #if (GPIO.input(23) == False):
                #break


                # This button sends a command to switch on the light
                #if (GPIO.input(24) == False):
                #s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                #s.sendto("? #10 ?", ("192.168.178.2", 7000))
                #logging.debug("light pushed!")


                # This button sends a command to ring the bell
                #if (GPIO.input(25) == False):
                #s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                #s.sendto("? #50 ?", ("192.168.178.2", 7000))
                #logging.debug("bell pushed!")


                sleep(0.1)


            # Cleanup resources before leaving the function
            shutdown()
        except pj.Error, e:
            logging.error("Exception: " + str(e))
            lib.destroy()
            lib = None




# Cleanup resources on service shutdown
def shutdown():
    # Globals
    global lib
    #global transport
    global acc


    try:
        logging.debug("start destruction...")


        # Turn off LED
        #GPIO.output(18, GPIO.LOW)
        # GPIO cleanup
        #GPIO.cleanup()


        # PJSIP
        #transport = None
        if acc:
            acc.delete()
        acc = None
        lib.destroy()
        lib = None


        logging.info("SIP Intercom terminated!")
        logging.debug("destroyed")
    except pj.Error, e:
        logging.error("Exception: " + str(e))
        lib.destroy()
        lib = None




# atexit.register(shutdown)

Nun ja. Die SIP Anlage ist zugegebenermaßen teuer. Mir war es auch zu teuer für den Anwendungsfall. Aber eigentlich finde ich alle schönen Anlagen zu teuer. Vergl. Siedle & Co. Selbst die hicht so schönen SIP Anlagen sind nicht billig (Mobotix z.B.). Man muss das daher im Kontext sehen.

Loxone verdient Geld über die eigene Hardware (wirklich gute und schöne Hardware, Portfolio wird ständig erweitert) und verschenken den Softwareteil. Man ist wahnsinnig flexibel und kann sich die benötigte Logik in Software so bauen wie man will. Es gibt Schnittstellen zu KNX, Modbus, usw. und auch http Schnittstellen. Das macht fast alles möglich. Bei anderen Anbietern ist man eingeschränkter oder muss spezielle Hardware kaufen (KNX). Von daher verstehe ich den Preis, auch wenn ich nicht bereit bin das zu zahlen.

Ich habe die UP Dose von Loxone als Vorlage genommen und eine eigene Abdeckung erstellt, die für meine Komponenten funktioniert und auf die UP Box passt. Die DXF Datei schickt man dann an prokilo, bekommt ein Angebot und dann produzieren die es in einem Material nach Wunsch. Ich habe 2mm Edelstahl, gebürstet/geschliffen genommen. Ich finde den Preis auch ok.

Noch mal zur Loxone... Ich bin nicht allzu weit weg sie "dranzukriegen". Ich habe ein kleines Script verfasst, was per Socket eine UDP Message an die Loxone schickt.

#!/usr/bin/env python
# -*- coding: utf-8 -*-


import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.sendto("? #50 ?", ("192.168.2.100", 7000))

Darauf reagiert besagter http Eingangsverbinder und öffnet den sogenannten Türbaustein in der App. Das klappt und ich bekomme schon den Stream angezeigt. Außerdem kann (könnte) ich nun einen Call zum Raspi (Linphone) aufbauen.

Das schlägt aber leider fehl.

Ich denke es liegt nur noch an der richtigen Admin Nummer. Laut log muss nämlich
die SIP id des Tablets (der Loxone App) als Admin Nummer eingetragen
werden. Das log sagt nämlich

sip:192.168.2.43 is not an adminnumber

hier die Langversion

2016-04-14 22:15:21,326 [DEBUG] [doorpi.sipphone.linphone_lib.CallBacks] is_admin_number (sip:192.168.2.43)[/tt]


2016-04-14 22:15:21,327 [TRACE] [doorpi.conf.config_object][color=#FF0000] get_keys for section AdminNumbers returns ['sip', '192.168.2.43', '**630', '**621', '**99', '**622', '**612'][/color][/tt]


2016-04-14 22:15:21,328 [DEBUG] [doorpi.sipphone.linphone_lib.CallBacks] [color=#FF0000]sip:192.168.2.43 is not an adminnumbe[/color]r


2016-04-14 22:15:21,329 [TRACE] [doorpi.action.handler] fire Event OnCallReject from doorpi.sipphone.linphone_lib.CallBacks asyncron


2016-04-14 22:15:21,331 [DEBUG] [doorpi.sipphone.from_linphone] [PYLINPHONE] >>> pylinphone_Core_instance_method_decline_call(0x7475c950 [0x10cca20], 0x76cf0550 [0x1101b50], 2)[/tt]


2016-04-14 22:15:21,332 [DEBUG] [doorpi.action.handler] no actions for event OnCallReject - skip fire_event OnCallReject from doorpi.sipphone.linphone_lib.CallBacks


2016-04-14 22:15:21,334 [INFO] [doorpi.sipphone.from_linphone] channel [0x1143d28]: message sent to [UDP://192.168.2.43:5060], size: [333] bytes


SIP/2.0 403 Forbidden


Via: SIP/2.0/UDP 192.168.2.43:5060;rport;branch=z9hG4bKPjXYJTOzn-Fw3hL81Y2qiq3VUCdgDq2MkP


From: <sip:192.168.2.43>;tag=5WcZe6R562JnlvimTyLdrvhZpEY-ZN-M


To: <sip:622@192.168.2.46>;tag=qr6Jue9


Call-ID: MKNAVRR8J0T3ZMSKePQz5auzUGngZYde


CSeq: 6437 INVITE


User-Agent: (belle-sip/1.4.2)[


Supported: outbound

So habe ich es eingetragen
[AdminNumbers]
**621 = active
**622 = active
sip:192.168.2.43 = active
192.168.2.43 = active

vermutlich stört also nur der Doppelpunkt, so dass die Adresse in zwei Teile aufgeteilt wird. Kann ich den irgendwie maskieren?

Ah, chic.. wusste ich nicht. Ist das schon im Haupt-Branch der Version 2.5.0.0? Vermutlich nicht, oder? Bei mir kommt immer noch ein "forbidden" mit dem Wildcard Eintrag. Da der Link auf den Main Branch verweist, gehe ich mal davon aus, dass es in den aktuellen Versionen enthalten ist. Ich müsste also ein Update mittels pip machen. Zerschieße ich mir dabei irgendwas? (Eigene Scripte)

Viele Grüße
Marcus

UPDATE: Ich habe meine Mittagspause geopfert und ein Update auf die 2.5.0.2 Version gemacht. Ein Blick in die Sources meiner Version hat mir gezeiugt, dass die Config mit "* = active" nicht umgehen konnte. Nach dem Upadte gehts. Perfekt. Somit habe ich auch meine Loxone angebunden.

Ich habe meine Klingelplatte aus der Schlosserei oder besser "Laserei" bekommen. 49,90 hat's gekostet in 2mm Edelstahl, geschliffen. Leider ist da aber ein bisserl was schief gelaufen. War wohl Montagmorgen oder man hat den Azubi drangesetzt. Ich hatte gesenkte Löcher für die Sicherheitsschrauben bestellt sowie einen 19mm Ausschnitt für den Klingeltaster. Die Löcher sind aber leider nicht gesenkt und das Loch ist nur 16mm groß
Jetzt habe ich reklamiert und bin mal gespannt wie's weitergeht. Auf jeden Fall muss ich aber noch was warten...

EDIT 21.04.2016: Man macht die Platte neu. Bearbeitungszeit 10 Tage

Die ist absolut ok. Ich denke das limitierende Glied in der Kette ist eh der kleine Lautsprecher. Ich hatte im Zuge meiner Störgeräuschsuche die Soundblaster Karte vorige Tage mal kurz verbaut (lie0 sich nicht mehr stornieren) und konnte keine nennenswerte Steigerung der Qualität feststellen.

Endlich ist die Klingelplatte gekommen. Ich musste letzte Woche ein wenig deutlich meine Erwartungshaltung bezüglich Lieferfriste machen, aber nun ist sie da und diesmal sogar korrekt ausgeführt. D.h. jetzt gehts es in die Endrunde. In den kommenden Tagen werde ich die Teile endgültg befestigen. Dazu gehört: Gewindebolzen für die Lautsprecher aufschweißen, Haltekapsel für das Mic sowie eine Namensgravur in die Platte einbringen lassen und dann wird es verbaut.

So siehts das Endergebnis aus.

Als UP Gehäuse habe ich das bereist erwähnte der Firma Loxone genommen, weil es
a) Zur von Loxone angeboten Intercom passt und der DoorPi damit gegen eine einigermaßen verbreiteten und bei Elektrofachbetrieben bekannten Standardlösung austauschbar wird (Interessant, wenn ich z.B. mal das Haus verkaufe und keinen "Wartungsvertrag" bis ans Ende meiner Tage erhalten möchte) und
b) aus Edestahl und damit relativ vandalismussicher ist. Was bringen mir Sicherheitsschrauben und eine Abdeckung aus Edelstahl, wenn alles in einer Plastik-Büche sitzt? Einmal Schraubendreher unter die Platte und aufgehebelt ist die Anlage. Nee nee...

Danke, danke... Ich bin auch sehr zufrieden mit dem Ergebnis. Die CAD Zeichnung kann ich bei Bedarf gerne zur Verfügung stellen falls sich jemand die Arbeit sparen möchte. Man kann die Maße ja noch anpassen auf seinen Bedarf, aber hat dann schonmal eine Grundlage.