DoorPi von MarcusS

    This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

    Da in jedem Forum ein paar Regeln eingehalten werden müssen, möchte ich diese auch vorher hier festlegen und niederschreiben. Die grundsätzliche Netiquette setze ich bei Jedem voraus. Darüber hinaus möchte ich nur spezielle Regeln ansprechen:
    - Unterlasse FullQuote sondern nutze Alternativen wie Inline-Quoting
    -> siehe auch https://de.wikipedia.org/wiki/Fullquote vs. https://de.wikipedia.org/wiki/TOFU#Alternativen_zu_TOFU
    - Unterlasse nichtssagende Antworten wie "Danke" oder "werde ich mal testen" oder ähnliches, sofern Du nicht der Threadersteller bist und einen Lösungsvorschlag angeboten bekommen hast.
    - Vermeide Doppel-Posts (zwei Beiträge von Dir hintereinander) sondern editiere wenn möglich Deine Posts.

    Danke...

    • 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
      IOPlatine (Selbst gebaut)
      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-

      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
      Software

      DoorPI 2.5.* mittels PIP: http://www.doorpi.org/forum/thread/8-anleitung-pi2-jessie-release-2016-02-26-mittels-pypi/
      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 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:

      KomponentePreis ca.
      SIP Anlage
      Raspberry Pi 235 €
      Mini-Digitalverstärker13 €
      Soundkarte10 €
      Mikrofon4 €
      Kamera27 €
      Objektiv10 €
      Lautsprecher5 €
      Platine10 €
      Kleinteile wie Schutzlack,
      Kabelbinder, Silca Säckchen,
      Sicherheitsschrauben, Klettband,Dichtungsband, Silikon usw.
      40 €
      Netzteil15 €
      Massetrennfilter (Optional, da ich knatternde Störgeräusche hatte)16
      Versandkosten20 €
      Zwischenstand205 €
      ------------------------------------------------------------------------------------------------
      Gehäuse
      -
      Unterputzdose Loxone65 €
      Klingelplatte50 €
      Mikroschalter3 €
      LED Taster12 €
      Summe Gehäuse 130 €
      -------------------------------------------------------------------------------------------------
      Gesamt335 €




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



      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.
      Images
      • DoorPi Prototyp (3).jpg

        541.95 kB, 1,920×1,076, viewed 5,526 times
      Cheers,
      Marcus
      -------------------------------------------------------
      Mein DoorPi (Eingebaut und in Betrieb)

      The post was edited 26 times, last by MarcusS: Langzeiterfahrung hinzugefügt ().

    • MarcusS wrote:

      Loxone alsHausautomation einsetze
      Und so schließt sich der Kreis wieder...
      DoorPi kommt ursprünglich von door-berry Projekt und das wiederum ist ursprünglich für die Kombination mit Loxone entwickelt wurden.
      Da sollten in dem Loxone Forum eine Menge an Themen rund um door-berry existieren, an denen sich viele die Zähne ausbeisen - so zumindest mal eine Mail die an mich kam.
      Darauf hin sollte ich mich im Loxone Forum vorstellen - hatte aber abgelehnt, denn ich will die Entwicklung und den Support konzentrieren und nicht noch mehr verteilen.
      Außerdem fehlt mir die Zeit um in einem weiteren Forum Support zu geben und Fragen zu beantworten, die ich hier schon ausgiebig beantwortet habe.
      --
      MfG Thomas
    • 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.
      loxforum.com/forum/faqs-tutori…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
      Cheers,
      Marcus
      -------------------------------------------------------
      Mein DoorPi (Eingebaut und in Betrieb)

      The post was edited 3 times, last by MarcusS: Korrektur ().

    • motom001 wrote:

      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

      Python Source Code

      1. # Actions for Button listener
      2. def btn_action(tmp, event):
      3. global outSocket
      4. try:
      5. # activate socket
      6. s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
      7. if (event.pin_num == 0):
      8. s.sendto("?light#10?", (LOX_SERVER, LOX_UDP_OUT_PORT))
      9. logging.debug("light pushed!")
      10. elif (event.pin_num == 1):
      11. if not (current_call):
      12. s.sendto("?bell#20 ?", (LOX_SERVER, LOX_UDP_OUT_PORT))
      13. logging.debug("bell pushed!")
      14. elif (event.pin_num == 2):
      15. if not (current_call):
      16. s.sendto("?post_incoming#30 ?", (LOX_SERVER, LOX_UDP_OUT_PORT))
      17. logging.debug("post incoming!")
      18. elif (event.pin_num == 3):
      19. if not (current_call):
      20. s.sendto("?post_obtained#40 ?", (LOX_SERVER, LOX_UDP_OUT_PORT))
      21. logging.debug("post obtained!")
      22. except pj.Error, e:
      23. logging.error("Exception: " + str(e))
      Display All
      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)
      loxforum.com/forum/faqs-tutori…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
      Cheers,
      Marcus
      -------------------------------------------------------
      Mein DoorPi (Eingebaut und in Betrieb)
    • Auf Basis welcher Loxone-API ist das realisiert?
      Was ist in der Variable LOX_SERVER abgepsiechert?

      Hab was gefunden:

      VIDEOGEGENSPRECHEN wrote:


      VIDEOGEGENSPRECHEN

      Eingänge:

      Doorbell Eingang am Kamera-Block für die Glocken-Taste


      Befehl:

      answer Informiert Miniserver darüber, dass „abgehoben“ wurde und das Läuten beendet werden kann.
      1/on, 1/off Wie Schalter für Ausgang 1
      2/on, 2/off Wie Schalter für Ausgang 2
      3/on, 3/off Wie Schalter für Ausgang 3


      Status:

      Läuten (uuidAction, durch „alert=“true““ wird anzeige als Popup erzielt)
      Öffner Ist der Öffner aktiv
      Licht Ist das Licht eingeschaltet


      Bsp.: <Function name="Haupteingang" Type="Intercom"
      UUIDaction="5bba39-757-11df-9ce39e208d4d7420"
      alert="true">
      <StateBell UUID="5bba3129-3757-11df-9ce39e208d4d722"/>
      <StateOut1 UUID="5bba3129-3757-11df-9ce39e208d4d723" Name="Öffner"/>
      <StateOut2 UUID="5bba3129-3757-11df-9ce39e108dd7424" Name="Licht"/>
      <StateOut3 UUID="5bba3129-3757-11df-9ce39e108dd7425" Name="Licht2"/>
      <VideoInfo Type=”JPG”
      alertImage=”10.7.7.68:80/record/current.jpg”
      streamURL=”10.7.7.68:80/control/faststream.jpg?
      stream=full&fps=0&size=480x320”
      user=”admin” pass=”admin“/>
      <AudioInfo Type=”SIP” host=iptel.org” user=”PhoneUser2”/>
      </Function>
      Bsp.: <Function name="News"
      UUIDaction="078c6bb4-02c1-09b3-ffffeee000b0003c"
      Type="Webpage">
      <Info URL="http://orf.at/m/"
      URLhd="http://orf.at/"
      Icon="84000005-d7a1-11e1-bd978d56cfab0bf4"/>
      </Function>
      Bsp.: <Function name="CasaTunes"
      UUIDaction="078c6bb4-02c1-09b3-ffffeee000b0003c"
      Type="Application">
      <Info URL="casatunes://?power=on&room=office&source=1&volume=40"
      Icon="84000005-d7a1-11e1-bd978d56cfab0bf4"/>
      </Function>
      Bsp.: <Function name="Fernbedienung"
      UUIDaction="078c6bb4-02c1-09b3-ffffeee000b0003c"
      Type="Media">
      </Function>
      --
      MfG Thomas
    • Das ist in dem Sinne keine API. Die Loxone hat für solche Zwecke http eingangsverbinder
      loxone.com/dede/service/dokume…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"

      Python Source Code

      1. #!/usr/bin/python
      2. # Module: SIP Intercom
      3. # Version: 1.0
      4. #
      5. # Author: Christian Gessner
      6. # Date: 2014-03-02
      7. # Description: SIP Intercom on RPI using PJSIP to communicate with Loxone miniserver's
      8. # door-control module
      9. # Copyright: Copyright (C) 2014 Christian Gessner <christiany@gessner.cc>
      10. #
      11. #
      12. #
      13. # Credits: PJSIP/PJSUA:
      14. # Inspired by the call.py sample of the PSJIP distribution, http://www.pjsip.org
      15. #
      16. # Raspberry Pi as Intercom:
      17. # Inspired by the door-berry project form Marco Pozzato, http://marpoz.blogspot.de
      18. # and https://github.com/mpodroid/door-berry
      19. import pjsua as pj
      20. from time import sleep
      21. import RPi.GPIO as GPIO
      22. import socket
      23. import atexit
      24. import logging
      25. import threading
      26. LOG_LEVEL = 0
      27. current_call = None
      28. lib = None
      29. acc = None
      30. transport = None
      31. # Logging callback
      32. def log_cb(level, str, len):
      33. logging.debug(str)
      34. # Callback to receive events from account
      35. class SipAccountCallback(pj.AccountCallback):
      36. sem = None
      37. def __init__(self, account=None):
      38. pj.AccountCallback.__init__(self, account)
      39. # Notification on incoming call
      40. def on_incoming_call(self, call):
      41. global current_call
      42. if current_call:
      43. call.answer(486, "Busy")
      44. return
      45. print "Incoming call from ", call.info().remote_uri
      46. logging.debug("Incoming call from ", call.info().remote_uri)
      47. current_call = call
      48. call_cb = SipCallCallback(current_call)
      49. current_call.set_callback(call_cb)
      50. current_call.answer(200)
      51. def wait(self):
      52. self.sem = threading.Semaphore(0)
      53. self.sem.acquire()
      54. def on_reg_state(self):
      55. logging.debug("on_reg_state")
      56. logging.debug("Status %d",self.account.info().reg_status)
      57. if self.sem:
      58. if self.account.info().reg_status >= 200:
      59. self.sem.release()
      60. # Callback to receive events from Call
      61. class SipCallCallback(pj.CallCallback):
      62. def __init__(self, call=None):
      63. pj.CallCallback.__init__(self, call)
      64. # Notification when call state has changed
      65. def on_state(self):
      66. global current_call
      67. print "Call with", self.call.info().remote_uri,
      68. print "is", self.call.info().state_text,
      69. print "last code =", self.call.info().last_code,
      70. print "(" + self.call.info().last_reason + ")"
      71. if self.call.info().state == pj.CallState.DISCONNECTED:
      72. current_call = None
      73. print 'Current call is', current_call
      74. # Notification when call's media state has changed.
      75. def on_media_state(self):
      76. if self.call.info().media_state == pj.MediaState.ACTIVE:
      77. # Connect the call to sound device
      78. call_slot = self.call.info().conf_slot
      79. pj.Lib.instance().conf_connect(call_slot, 0)
      80. pj.Lib.instance().conf_connect(0, call_slot)
      81. print "Media is now active"
      82. else:
      83. print "Media is inactive"
      84. # SIP Intercom listener class
      85. class SipIntercom:
      86. # Constructor
      87. def __init__(self):
      88. # Initialize logging
      89. logging.basicConfig(filename='/home/pi/sip_intercom/sip.log', level=logging.DEBUG, format='%(asctime)s %(levelname)s %(threadName)-10s %(message)s')
      90. # Initialize GPIO pins
      91. #GPIO.setmode(GPIO.BCM)
      92. #GPIO.setup(23, GPIO.IN)
      93. #GPIO.setup(24, GPIO.IN)
      94. #GPIO.setup(25, GPIO.IN)
      95. #GPIO.setup(18, GPIO.OUT)
      96. logging.debug("initialized!")
      97. # Run SIP client and react to GPIO inputs by sending UDP telegrams
      98. def run(self):
      99. # Globals
      100. global lib
      101. global transport
      102. global acc
      103. logging.debug("run!")
      104. # Create library instance
      105. lib = pj.Lib()
      106. try:
      107. # Init library with default config and some customized logging config.
      108. lib.init(log_cfg=pj.LogConfig(level=LOG_LEVEL, callback=log_cb))
      109. # Create UDP transport which listens port 5060
      110. transport = lib.create_transport(pj.TransportType.UDP, pj.TransportConfig(5060))
      111. # Start the library
      112. lib.start()
      113. # Create local account
      114. # acc = lib.create_account_for_transport(transport, cb=SipAccountCallback())
      115. acc_cfg = pj.AccountConfig("iptel.org","mein_benutzername","mein_passwort")
      116. acc_cb = SipAccountCallback()
      117. acc = lib.create_account(acc_cfg, cb=acc_cb)
      118. acc_cb.wait()
      119. logging.debug("account registred!")
      120. # Turn on LED
      121. #GPIO.output(18, GPIO.HIGH)
      122. logging.info("SIP Intercom started!")
      123. logging.debug("pjsua started")
      124. # Menu loop
      125. while True:
      126. # This button quits the loop and exits the SIP listener
      127. #if (GPIO.input(23) == False):
      128. #break
      129. # This button sends a command to switch on the light
      130. #if (GPIO.input(24) == False):
      131. #s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
      132. #s.sendto("? #10 ?", ("192.168.178.2", 7000))
      133. #logging.debug("light pushed!")
      134. # This button sends a command to ring the bell
      135. #if (GPIO.input(25) == False):
      136. #s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
      137. #s.sendto("? #50 ?", ("192.168.178.2", 7000))
      138. #logging.debug("bell pushed!")
      139. sleep(0.1)
      140. # Cleanup resources before leaving the function
      141. shutdown()
      142. except pj.Error, e:
      143. logging.error("Exception: " + str(e))
      144. lib.destroy()
      145. lib = None
      146. # Cleanup resources on service shutdown
      147. def shutdown():
      148. # Globals
      149. global lib
      150. #global transport
      151. global acc
      152. try:
      153. logging.debug("start destruction...")
      154. # Turn off LED
      155. #GPIO.output(18, GPIO.LOW)
      156. # GPIO cleanup
      157. #GPIO.cleanup()
      158. # PJSIP
      159. #transport = None
      160. if acc:
      161. acc.delete()
      162. acc = None
      163. lib.destroy()
      164. lib = None
      165. logging.info("SIP Intercom terminated!")
      166. logging.debug("destroyed")
      167. except pj.Error, e:
      168. logging.error("Exception: " + str(e))
      169. lib.destroy()
      170. lib = None
      171. # atexit.register(shutdown)
      Display All
      Cheers,
      Marcus
      -------------------------------------------------------
      Mein DoorPi (Eingebaut und in Betrieb)
    • Sehr schönes Projekt!

      Die Intercom von Loxone hat ja echt nen stolzen Preis für ein proprietäres System 8|
      Eins muss man aber sagen, geil aussehen tut sie :D

      Bin sehr auf deine Frontplatte gespannt. Wie hast du die bei Prokilo bestellt, fertigen die nach CAD-Datei oder wie läuft das? Bekommst du die für die 60€ in Edelstahl? Das wäre ja echt vergleichsweise günstig, ich habe mal eine ähnliche Frontplatte über das Tool von Schaeffer-Ag erstellt und das kommt auch auf ca. 60€, allerdings in Alu eloxiert.
    • 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.
      Cheers,
      Marcus
      -------------------------------------------------------
      Mein DoorPi (Eingebaut und in Betrieb)

      The post was edited 3 times, last by MarcusS ().

    • 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.

      Source Code

      1. #!/usr/bin/env python
      2. # -*- coding: utf-8 -*-
      3. import socket
      4. s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
      5. 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

      Source Code

      1. 2016-04-14 22:15:21,326 [DEBUG] [doorpi.sipphone.linphone_lib.CallBacks] is_admin_number (sip:192.168.2.43)[/tt]
      2. 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]
      3. 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
      4. 2016-04-14 22:15:21,329 [TRACE] [doorpi.action.handler] fire Event OnCallReject from doorpi.sipphone.linphone_lib.CallBacks asyncron
      5. 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]
      6. 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
      7. 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
      8. SIP/2.0 403 Forbidden
      9. Via: SIP/2.0/UDP 192.168.2.43:5060;rport;branch=z9hG4bKPjXYJTOzn-Fw3hL81Y2qiq3VUCdgDq2MkP
      10. From: <sip:192.168.2.43>;tag=5WcZe6R562JnlvimTyLdrvhZpEY-ZN-M
      11. To: <sip:622@192.168.2.46>;tag=qr6Jue9
      12. Call-ID: MKNAVRR8J0T3ZMSKePQz5auzUGngZYde
      13. CSeq: 6437 INVITE
      14. User-Agent: (belle-sip/1.4.2)[
      15. Supported: outbound
      Display All


      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?
      Cheers,
      Marcus
      -------------------------------------------------------
      Mein DoorPi (Eingebaut und in Betrieb)
    • 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.
      Cheers,
      Marcus
      -------------------------------------------------------
      Mein DoorPi (Eingebaut und in Betrieb)

      The post was edited 4 times, last by MarcusS: Update gepostet ().

    • 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ß :thumbdown:
      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 ||
      Images
      • Klingelplatte V1 (1).jpg

        204.08 kB, 1,076×1,920, viewed 2,358 times
      • Klingelplatte V1 (8).jpg

        304.07 kB, 1,080×1,919, viewed 2,578 times
      Cheers,
      Marcus
      -------------------------------------------------------
      Mein DoorPi (Eingebaut und in Betrieb)

      The post was edited 2 times, last by MarcusS ().

    • 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.
      Cheers,
      Marcus
      -------------------------------------------------------
      Mein DoorPi (Eingebaut und in Betrieb)
    • 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...

      Cheers,
      Marcus
      -------------------------------------------------------
      Mein DoorPi (Eingebaut und in Betrieb)

      The post was edited 4 times, last by MarcusS ().

    • 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.
      Cheers,
      Marcus
      -------------------------------------------------------
      Mein DoorPi (Eingebaut und in Betrieb)