#lang scribble/manual @title{Technische Dokumentation Türschließanlage, Version 3.1} @author{Hackspace Jena e. V.} @centered[@tabular[ #:sep @hspace[3] #:style 'block @;#:row-properties '(bottom-border ()) #:column-properties '(right right left) #:cell-properties (list '(top)) (list (list "Planung, Schaltung und Elektroklempnerei" "" "ulip, joe") (list "Dokumentation und Übersichten" "" "joe") (list "Hardware-Spenden" "" "chekov, joe") (list "Beschaffung von Bauteilen" "" "gecko, ndo") (list "Linux-System, WLAN" "" "ndo, chekov, joe") (list "Web-Server und GUI" "" "chekov, lycian, joe, ndo") (list "Systemd" "" "chekov, bernd") (list "GPIO, Reverse Engineering Tür 1.3" "" "joe") (list "Einführung und Skriptgrundlage" "" "fpunktk, aehtuer-Autoren") )]] @image["img/itsmagic.png"] @centered[@hyperlink["https://codeberg.org/kraut.space/tuer3.git" "codeberg.org/tuer3.git"]] @; --------------------------------------------------------------------- @section{Komponenten} @centered[@image["img/tueranlage.png"]] @; --------------------------------------------------------------------- @subsection{Embedded-PC} Als Steuerrechner verwenden wir einen Embedded-PC, genauer einen Raspberry-Pi 3. Er spannt ein WLAN-Netzwerk auf. Über einen Web-Server werden die Zugangsberechtigungen geprüft und ein Web-Interface angeboten. Die anderen Komponenten werden über die GPIO gesteuert. Für den Softwareteil (siehe: @secref{software}) @; --------------------------------------------------------------------- @subsection{Prototypeboard} Die Schaltplatine hat die Aufgabe die vom Steuerrechner gesetzten Signale weiterzugeben und dabei für eine galvanische Trennung von Steuerrechner, Schließelektronik und Haustürtelefon sorgen. @centered[@hyperlink["img/tuer-3.0-prototypeboard-x2.png" @image["img/tuer-3.0-prototypeboard.png"]]] Liste der verwendeten Bauteile: @centered[@tabular[ #:sep @hspace[3] #:style 'block #:row-properties '(bottom-border ()) #:column-properties '(left) #:cell-properties (list '(top)) (list (list @bold{Bezeichnung} @bold{Typ/Wert} @bold{Info/Datenblatt}) (list "R 1-3" "12Ω" "Metallschichtwiderstand") (list "R 4" "51Ω" "Metallschichtwiderstand") (list "R 5" "5600Ω" "Metallschichtwiderstand") (list "D 1-4" "grüne LED" "5mm Standard-LED, Statusanzeige") (list "D 5" "1N4148" "Rücklaufdiode für Relais") (list "OP 1-4" @hyperlink["../media/mXtwxrt.pdf" "PC817"] "Optokoppler") (list "T 1" @hyperlink["../media/BC546_48-CDIL.pdf" "BC546B"] "NPN-Transistor") (list "K 1" @hyperlink["../media/en-g6d.pdf" @nonbreaking{Omron G6D}] "5V-Relais") (list "CN 1" "2×13-polig" "Buchsenleiste in Raspberry-1/2-Breite, 500V~") (list "CN 2" "PS 2-polig" "Stiftleiste, 2-polig, abgewinkelt, RM 2,54mm, 250V~, 1A") (list "CN 3" "PS 4-polig" "Stiftleiste, 4-polig, abgewinkelt, RM 2,54mm, 250V~, 1A") (list "–" "Platine" "Lochrasterplatine mit Lötaugen") )]] An den GPIO liegen 3,3V an. Die Summe der Ströme aller Kanäle sollte unter 50mA bleiben. Es werden für jeden Kanal jeweils eine LED und ein Optokoppler in Reihe geschaltet. Sie teilen sich den Vorwiderstand. Die Vorwärtsspannung U@subscript{F} des Optokopplers liegt bei 1,0V und der LED bei 1,7V. Beim Haustürtelefon liegen die gemessenen Spannungen im Bereich von –11,89V bis +6,8-9,5V. Hier wird ein zusätzliches 5V-Relais mit Schutzdiode zwischengeschaltet. Bei 5V Betätigungsspannung wurde am Relais ein Haltestrom von 37mA, ergo ein Verbrauch von 185mW gemessen. Die Spannung am GPIO von 3,3V reichte nicht, die Sekundärseite des Optokoppler soweit durchzuschalten, dass der für das Relais notwendige Haltestrom erreicht wird. Um den Strom am GPIO nicht zu überschreiten und dennoch den LED-Strom im Optokoppler zu verstärken wurde ein Transistor vorgeschaltet. Am Raspberry-GPIO-Port genutzte Pins: @centered[@tabular[ #:sep @hspace[3] #:style 'block #:row-properties '(bottom-border ()) #:column-properties '(right left) #:cell-properties (list '(top)) (list (list @bold{Pin} @bold{Name} @bold{Aufgabe} @bold{Art}) (list "2" "5V" "Relais-Haltestromversorgung" "-") (list "7" "GPIO 04" "Tür verriegeln" "Tastimpuls") (list "9" "Ground" "Masse" "-" ) (list "13" "GPIO 27" "Tür öffnen" "Tastimpuls") (list "15" "GPIO 22" "Haustür öffnen" "längerer Tastimpuls") )]] @; --------------------------------------------------------------------- @subsection{Schlüsselmodul KeyMatic® KM-RC-Key4-2 (rote Box)} Das rote Schlüsselmodul triggert den Schließzylindermotor und bündelt die Verdrahtung aller Signalleitungen in einer Box. Die Box enthält die Platine eines Funkschlüssels. Die Leitungen der Knöpfe wurden mit Lötlackdraht kontaktiert und über Anschlussklemmen nach außen geführt. Der Funkschlüssel ist mit dem Schließzylinderantrieb an der Eingangstür gekoppelt. Der Kontakt vom Prototypeboard zum Haustürtelefon wird intern über zwei Anschlussklemmen durchgeleitet. Insgesamt wurde es vermieden freihängende Lüsterklemmen zu verwenden. Damit vermindern wir die Gefahr einer Fehlkontaktierung oder Verpolung. @bold{Hinweis: Die Stromversorgung erfolgt derzeit über eine 1,5V AAA-Batterie. Diese sollte alle 1-2 Jahre gewechselt werden.} Eine Anschlussklemme für die externe Stromversorgung ist vorgesehen aber intern nicht angelötet. Dies läuft unter dem Projekt „Könnte man mal machen“™. @centered[@hyperlink["../media/HM-RC-4-2_UM_GE_EQ-3_130906.pdf" @image["./img/thumbnail-keymatik-key-anleitung.png" ]]] @; --------------------------------------------------------------------- @subsection{Schließzylinderantrieb} Das Kernstück der Türschließanlage stellt der Schließzylinderantrieb dar. Es handelt sich um einen HomeMatic® HM-Sec-Key. Er empfängt die Signale vom gekoppelten Funkschlüssel und schließt mit dem eingebauten Metallschlüssel entsprechend auf oder zu. Die Stromversorgung erfolgt über ein Steckernetzteil. Zwei Fake-Batterien im Batteriefach kontaktieren die Pole des Steckernetzteils. @centered[@hyperlink["../media/HM_SECKEYS_ANL.pdf" @image["./img/thumbnail-keymatic-anleitung.png" ]]] @; --------------------------------------------------------------------- @subsection{Maus an der Eingangstür} An der Außenseite unserer Eingangstür befindet sich in der linken oberen Ecke des Türrahmens ein altes Mausgehäuse. Drückt man beide Maustasten gleichzeitig wird der Raum ohne Schlüssel oder Zugang zum Web-Interface abgeschlossen. Die Maus ist direkt an die rote Box des Schließmoduls angeschlossen. Eine Betätigung triggert so auch direkt den Schließenknopf. Diese Lösung erlaubt uns, dass das Abschließen von jedem möglich ist und das unabhängig von der Verfügbarkeit des Raspberry Pi®. @; --------------------------------------------------------------------- @subsection{Haustürtelefon} Das Haustürtelefon ist eine klassische Gegensprechanlage mit Hörer und einem Taster für den Haustürsummer. KTA als auch Steuer-PC schalten lediglich den Pin5 und Pin6 im Inneren zusammen. Beim Prototypeboard erledigt diese Aufabe ein Relais. Hinweis: Das Auslösen des Summers ist, nach dem Umbau der Haustelefonanlage, nur möglich nachdem geklingelt wurde. @; --------------------------------------------------------------------- @subsection{KTA – Klingeltüröffnerautomat} Der @hyperlink["http://www.jtxp.org/tech/kta2.htm" " Hersteller jtxp.org"] sagt: @emph{„Eine Elektronik wird an die Stromkreise von Hausklingel und Türöffner angeschlossen. Wenn sie ein bestimmtes Klingelzeichen erkennt, betätigt sie per Relais den elektrischen Türöffner. Der memorierbare Code ersetzt den mechanischen Schlüssel, der Klingelknopf wird als bereits vorhandenes und unauffälliges Eingabegerät gleich doppelt genutzt.“} Die Stromversorgung kommt vom Haustelefon. Dabei wird eine Kondensator durch längeres erstmaliges Klingeln aufgeladen. Die Stromversorgung der Schaltung erfolgt dann durch diesen. Danach kann die Auswertung des Klingelzeichens erfolgen. @; --------------------------------------------------------------------- @subsection{Elektrische Verdrahtung} @centered[@hyperlink["../media/tuer3.1.svg" @image["img/tuer3.1-kaskadierspiranz.png"]]] @; --------------------------------------------------------------------- @section[#:tag "usage" "Bedienung"] @; --------------------------------------------------------------------- @subsection{Web-Oberfläche} Um die Tür zu steuern loggt sich das Mitglied mit geeignetem Gerät in das WLAN @tt{tuer.kraut.space} mit dem Passwort @tt{krautspace} ein. Mit einem Browser gelangt man dann über die Adresse @tt{https://tuer.kraut.space} zur Bedienoberfläche der Türschließanlage. Die Bedienoberfläche teilt sich in einen Login-Bildschirm der ein Eingabefeld für den persönlichen Token bereit hält, einem Bildschirm zur Steuerung der Schließvorgänge und einem Wartebildschirm. Jedes Mitglied erhält seinen persönlichen Token, mit dem es sich an der Schließanlage anmelden kann. @centered[@hyperlink["https://principiadiscordia.com/book/36.php" @image["img/guilogin.png"]]] Die Schließvorgänge wurden nach Verwendungshäufigkeit geordnet und die wichtigsten, Tür öffnen und abschließen, hervorgehoben. Ein Druck auf den entsprechenden Knopf löst einen Schließvorgang aus. @centered[@image["img/guibuttons.png"]] Während der Schaltdauer wird eine Übergangsseite angezeigt, welche nach einer gewissen Zeit zum Login zurückkehrt. @centered[@image["img/guiwait.png"]] @; --------------------------------------------------------------------- @subsection{Neuen Token/Passphrase generieren} Das zugehörige Token kann mit einem @hyperlink["../media/genpw.sh" "Skript"] generiert werden. Einfach unter Linux ausführen und den Anweisungen folgen. @tt{$./genpw.sh } @; --------------------------------------------------------------------- @section[#:tag "software" "Software"] Als Betriebssystem dient ein handelsübliches @hyperlink["https://www.raspbian.org" "Raspian"]. @; --------------------------------------------------------------------- @subsection{Webserver} Als Webserver wird @tt{Nginx} genommen. Zum Ausführen von CGI-Skripten wird @tt{FastCGI} eingesetzt. Der Webserver ist so konfiguriert, dass unverschlüsselte HTTP-Anfragen grundsätzlich auf eine SSL-gesicherte Verbindung umgeleitet werden. Der alleinige Aufruf von @tt{https://tuer.kraut.space} leitet auf die Login-Seite um. Für die SSL-Verbindung wird ein von @emph{Let's Encrypt} signiertes Zertifikat verwendet. @; --------------------------------------------------------------------- @subsection{Web-Interface} Die gesamte Seite wird durch ein einziges Shell-Skript @tt{/var/www/cgi-bin/kraut.space} erzeugt. Dieses wird von Nginx über FastCGI aufgerufen. Das Shell-Skript entscheidet anhand der GET-Parameter welche Seite angezeigt und welche Funktion ausgeführt werden soll. Für einen Eindruck siehe @secref{usage}. Intern verwendet es HTML-Templates welche über CSS formatiert werden. @subsubsection{Authentifikation} Für jedes Mitglied wurde mit dem Generierungsskript (siehe @secref{usage}) eine persönliche Passphrase und der zugehörige Hash erstellt. Die Hashs aller @emph{aktiven} Schlüssel sind in eine semikolonseparierten Datei @tt{/etc/tuer3.0/door_access_list} eingetragen. Sie enthält drei Spalten. In der ersten Spalte steht ein Bezeichner für den Schlüsselbesitzer, vorzugsweise der Nick. In der zweiten Spalte wird das Erstellungsdatum hinterlegt. Das Datum hat die Form von @tt{date +'%FT%T'}. Die dritte Spalte enthält den Hash der Passphrase. Als Hash wird @tt{SHA-512} verwendet. Die ersten zwei Spalten sind rein informativ und haben für das Web-Interface keine Auswirkung auf die Ausführung. Sie erleichtern jedoch die geskriptete und händische Schlüsseladministration. Insoweit die Passphrase nicht mit dem Skript generiert wurde, muss sie einigen Anforderungen genügen. Sie muss mindestens 31 Zeichen lang sein und darf nur aus Zahlen, Kleinbuchstaben und dem Unterstrich '_' bestehen. @subsubsection{Türschließfunktion} Das Schalten der GPIO geschieht durch das Tool @tt{gpio} der @hyperlink["http://wiringpi.com" "WiringPi"]-Bibliothek. Im Shell-Skript werden die @emph{CPU-Pins} verwendet und mit der Option @tt{-g} übergeben. Als Timer wird @tt{sleep} verwendet. Der Nutzer @tt{www-data} muss in der Gruppe @tt{gpio} sein um die Pins schalten zu können. Verwendetes Pin-Out des Raspberry-PI 3: @centered[@tabular[ #:sep @hspace[3] #:style 'block #:row-properties '(bottom-border ()) #:column-properties '(left right) #:cell-properties (list '(top)) (list (list @bold{Funktion} @bold{LED-Pin} @bold{Raspi-Pin} @bold{CPU-Pin} @bold{WiringPi}) (list "indoor_lock" "1" "7" @bold{4} "7") (list "indoor_open" "3" "13" @bold{27} "2") (list "outdoor_buzz" "4" "15" @bold{22} "3") )]] @; --------------------------------------------------------------------- @subsection{WLAN} Die Website wird über ein eigenes WPA2-PSK-abgesichertes WLAN zur Verfügung gestellt. Das Aufspannen des Netzwerks übernimmt @hyperlink["https://w1.fi/hostapd/" "hostapd"]. Einige Kenndaten: @centered[@tabular[ #:sep @hspace[2] #:style 'block #:column-properties '(left left) #:cell-properties (list '(top)) (list (list "SSID" "tuer.kraut.space") (list "Passphrase" "krautspace") (list "address" "192.168.1.1") (list "netmask" "255.255.255.0") )]] Durch das aufgespannte WLAN ist das WLAN-Device belegt. Weiterhin besteht keine Verbindung oder Weiterleitung zum Internet. @; --------------------------------------------------------------------- @subsection{GPIO und systemd} Die verwendeten GPIO müssen beim Systemstart in den OUTPUT-Modus versetzt werden. Dies erfolgt über einen Systemd-Service. @; --------------------------------------------------------------------- @subsection{DNS und DHCP} Der DNS-Server wird von @tt{dnsmasq} und der DHCP-server von @tt{dhcpd} zur Verfügung gestellt. @; --------------------------------------------------------------------- @subsection{Let's Encrypt} Das Zertifikat wird von @hyperlink["https://letsencrypt.org" "Let's Encrypt"] signiert. Aus der auf maximal 90 Tage beschränkte Gültigkeit dieser Signatur ist eine regelmäßige Aktualisierung notwendig. Die Aktualisierung erfolgt jeden Montag gegen 4:00 Uhr. Bei einem Fehlschlag gibt es erst in der darauf folgenden Woche den nächsten Versuch. Ein Update erfolgt über ein Skript. Zuerst wird das aufgespannte WLAN abgebaut. Mittels @tt{wpa-supplicant} wird eine WLAN-Client-Verbindung zum Internet aufgebaut. Das neue signierte und GPG-verschlüsselte Zertifikat wird von @tt{https://tuer.kraut.space} gezogen und eingespielt. Danach wird die Internetverbindung abgebaut und das normale WLAN wieder aufgespannt. @; --------------------------------------------------------------------- @section[#:tag "history" "Historie"] Bei einem Verein mit vielen Mitgliedern und wenigen Schlüsseln kommt schnell der Wunsch nach einer Lösung auf, bei der jeder bei Bedarf in die Räume kommt. Die anfängliche Variante auf den Schlüsselbesitzer zu warten oder sich den Schlüssel auszuleihen ist auf Dauer zu fehleranfällig oder lästig. Es musste also eine technische Lösung her. Ausgangspunkt für dieses Kapitel war der geschichtliche Abriss im Wiki @hyperlink["https://kraut.space/hswiki:jensites:fernschliessanlage?rev=1432282264" "kraut.space/Fernschließanlage"]. @; ----------------- @subsection[#:style 'unnumbered]{September 2012} Einige Vereinsmitglieder hatten begonnen sich mit der Materie auseinander zu setzen. Enstanden ist eine Lösung, welche als Hardware einen OpenWRT-Router mit Parallelport, einer Relaiskarte mit acht 12V-Relais und einen ABUS-CFA-1000-Schließzylinderantrieb besteht. Die Pins des Parallelports schalteten je ein Relais. Was die Relais auf Sekundärseite schalteten ließ sich nicht recherchieren. Möglich wäre die Kontaktierung eines Funkschlüssels oder auch auch schon die im nächsten Abschnitt erwähnte Kabelfernbedienung. Für die Software kam als Betriebssystem @hyperlink["https://openwrt.org" "OpenWRT"] mit @tt{lighttpd} und @tt{dnsmasq} zum Einsatz. Die Webseite wurde durch ein CGI-Shell-Skript ausgeliefert. Zugang erfolgte über ein vom Router aufgespanntes offenes WLAN. Siehe auch @hyperlink["https://gitorious.org/hackspace-jena/aehtuer.git" "gitorius/aehtuer.git"] und @hyperlink["https://github.com/HackspaceJena/aehtuer" "github/aehtuer"]. Das letzte Update ist vom 26. Mai 2015. @; ----------------- @subsection[#:style 'unnumbered]{Anfang 2013} Zur Steuerung des Schließzylinderantriebs wird eine kabelgebundene Fernbedienung KM-300-RI verwendet. Die Box verhält sich genauso wie der zum Antrieb gehörige Funkschlüssel. Mit dem Unterschied, dass der Schlüsselaustausch und die Kommunikation über eine Leitung und nicht über Antennen erfolgt. @; ----------------- @subsection[#:style 'unnumbered]{November 2013} Bisher erhielt der Schließzylinderantrieb seine Stromversorgung aus Batterien im Batteriefach. Diese wurden durch ein Steckernetzteil ersetzt. Die Kabelfernbedienung wurde zurückgebaut. Von der Sekundärseite der Relaiskarte wurden nun die Knöpfe vom Schließzylinderantrieb direkt angesteuert. Die Knöpfe dienten als Lötkontakt und waren damit fortan disfunktional. Durch herausgeführte Drähte konnte man die Knöpfe bei Bedarf durch Kurzschließen dennoch betätigen. Die Knöpfe am Gerät erlauben nur auf- und abschließen. Da die Tür außen einen Knauf hat wird zum öffnen die Funktionen aufschließen mit Falle halten benötigt. Leider kann man diese nur mit dem Funkschlüssel oder der Kabelfernbedienung auslösen. Als Hack wurde auf eine Kallibrierung des Systems verzichtet, so dass der Schließzylinderantrieb beim aufschließen überdreht und die Falle zurückgezogen bleibt. @; ----------------- @subsection[#:style 'unnumbered]{Dezember 2013} Der Hack wurde rückgebaut und der Schließzylinderantrieb kalibriert. Die Kabelfernbedienung übernahm wieder das Schließen. Relaiskarte und Kabelfernbedienung teilen sich ein 12V-Netzteil. Als Neuerung kommt ein Knopf außerhalb vom Space hinzu, der es erlaubt beim Verlassen der Räume die Tür ohne Schlüssel und Netzzugang abzuschließen. Der Knopf wird durch eine Computermaus realisiert, bei dem linke und rechte Maustaste gleichzeitig gedrückt werden müssen. @; ----------------- @subsection[#:style 'unnumbered]{Oktober 2014 - Tür2.0} Im Oktober 2014 kam der Wunsch auf das System zu erweitern. In einem Repository, siehe @hyperlink["https://github.com/HackspaceJena/Tuer2.0" "github/tuer2.0"], wurden Ideen, Wünsche und Anforderungen gesammelt. Das letzte Update ist vom 24. September 2015. Es wurde mit der Umsetzung einer REST-Schnittstellen in @hyperlink["https://golang.org" "Golang"] begonnen. Ansonsten blieb es bei einer Ideensammlung. Von den hauptsächlich Hardware- und Feature-Wünschen wurde nichts umgesetzt und leider auch nichts in Angriff genommen. Das Ziel eine Spezifikation zu erstellen wurde nicht erreicht, da grundsätzliche Anforderungen und Zusammenhänge nicht definiert wurden und keine Linie erkennbar ist. @; ----------------- @subsection[#:style 'unnumbered]{September 2015} Die eigene Stromversorgung der Kabelfernbedienung wurde entfernt. Die Stromversorgung geschieht nun über den Schließzylinderantrieb. Die Maus an der Eingangstür wurde wegen eines Kurzschlusses neu verkabelt. Dieser Stand lief mit kleineren Reparaturen bis 24. August 2017. Wir nennen ihn Tür1.3. @; ----------------- @subsection[#:style 'unnumbered]{Juni 2017 - Tür3.0} Die Tür1.3 lief immer noch. Der Stand lief aber mit älter werdender Hardware. Als eines der Netzteile ausfiel offenbarte sich die Fragilität des Systems. Es wurde Hardware verwendet für die es keinen Ersatz mehr gab. Die Verdrahtung bestand aus sehr vielen Lüsterklemmen mit Kabelabschnitten bei denen die Farben willkürlich wechselten. Die Dokumentation der Hardware bestand aus einem historischem Abriss. Ein Verdrahtunsschema oder Dokumentation gab es nicht. Debuggen hieß Reverse-Engineeren. Das Projekt Tür3.0 wurde begonnen. Der Name wurde gewählt weil der Name Tür2.0, auch wenn es sie nie gab, belegt war. Zuerst erfolgte eine Bestandsaufnahme der Tür1.3 seiner Bauteile und Verkabelung. Alle Datenblätter wurden zusammengetragen und auch mit einer Dokumentation begonnen. @centered[@hyperlink["../media/tuer1.3.svg" @image["img/tuer1.3-kaskadierspiranz.png"]]] Als kritischer Punkte stellte sich der Router und der Schließzylinderantrieb heraus. Für den Router mit Parallelport gab es am Markt keine Ersatzgeräte mehr. Bei Versagen des Schließzylinderantriebs wird ein neuer gekauft. Gibt es das Modell nicht mehr, muss ein neues in das System integriert und das Gesamtsystem entsprechend angepasst werden. Der Routerlösung hatte einige Probleme. Sie war potentiell teuer im Ersatz und erforderte Spezialwissen über das eingesetzte Betriebssystem (spezielles Dateisystem und komplizierte Konfiguration). Damals gab es schon eine Reihe von Embedded-PCs auf denen ein reguläres Linux läuft. Damit sinkt die Einstiegshürde, die Wiederbeschaffbarkeit oder ein adäquater Ersatz ist gewärleistet. Die Wahl traf auf den im Februar 2016 erschienene Raspberry-Pi 3. Er hatte den Vorteil, dass er WLAN-on-board hat und er war durch eine Sachspende (Danke Chekov!) als Entwicklungssystem sofort verfügbar. Die Relaiskarte benötigte ein eigenes 12V-Netzteil. Mit der Verwendung von Optokopplern entfiel dieses und es konnte auf das Hantieren mit mehreren Spannungen verzichtet werden. Das Ergebnis ist als Aufsteckboard für den Raspberry zusätzlich kompakter. @centered[@hyperlink["../media/tuer3.0.svg" @image["img/tuer3.0-kaskadierspiranz.png"]]] Die gesamte Entwicklung und der Testbetrieb der Tür3.0 erfolgte parallel zur Hardware der Tür1.3. Es wurden viele Grundideen seitens der Hardware und Software der Tür1.3 übernommen. Zusätzlich wurde die Erweiterbarkeit um Wünsche der Tür2.0 berücksichtigt. Das System lässt sich erweitern wenn die Notwendigkeit besteht oder wenn bei fehlenden Features der Leidensdruck groß genug ist. Beispielsweise wurde die Variante für das Web-Interface ein Shell-Skript per CGI aufzurufen beibehalten. Die Komplexität der Kernfunktionalität beschränkt sich auf eben diese 60 Zeilen Shell-Code. Die Einarbeitungszeit für Neue bleibt so überschaubar. Passphrasengenerierung erfolgt nun über ein Skript und ist nur dem Mitglied bekannt. Bei der Tür1.3 wurde eine Liste von Passwörtern/Token geführt und den Mitgliedern vergeben. Den Administratoren waren potentiell alle Passwörter bekannt. Die Verkabelung wurde vereinfacht und die Zahl der Lüsterklemmen reduziert. Der Hauptfokus des Projekts Tür3.0 lag auf Modularität der Hardware und schneller Reparatur. @; ----------------- @subsection[#:style 'unnumbered]{August 2017 - RIP Tür1.3} Eines Tages drehte Schließzylinderantrieb durch, ohne die Tür mit dem enthaltenen Schlüssel zu öffnen. Die Fehleranalyse zeigte, dass viele Plastikverbindungen für die Gehäuseschrauben spröde geworden waren. Einige zerbröselten geradezu. Eventuell hängt es mit dem zur Schmierung der Zahnräder verwendeten Silikonfett zusammen. Damit verutschten Intern die Zahnräder und konnten keine Kraft mehr übertragen. Das Gerät war schon zu lange vom Markt. Es gab nur überteuerte Altgeräte (über einen finnischen Händler) oder Gebrauchtgeräte. Beide Möglichkeiten kamen nicht in Betracht, da wir von einer eingeschränkten Laufzeit ausgingen. Der Ersatz wurde ein HomeMatic-Modell. Die Vorteile waren, dass die Schlosshalterung für den Schließzylinderantrieb indentisch war, der enthaltene Schlüssel nicht abgesägt werden musste und die Bedienung der des alten Gerätes glich. Leider gab es den Nachteil, dass die Funkschlüssel inkompatibel waren, so auch die Kabelfernbedienung. Ein Gerät mit ähnlicher Funktionalität für die HomeMatic wird nicht angeboten. Der Ausfall kam mitten in der Tür3.0-Testphase. Wir entschieden uns das Projekt gleich auf die neue Situation anzupassen und in den Live-Betrieb zu gehen. Ein Umstellen der Tür1.3 auf das neue System war uns im Parallelbetrieb zu heikel. Das Tür3.0-Projekt war zudem weit genug fortgeschritten. @emph{Leb' wohl alte Tür1.3, du hast uns viele Jahre gute Dienste geleistet.} Da es keine Kabelfernbedienung gab wurde ein Funkschlüssel zerlegt und in ein Gehäuse (rote Box) untergebracht. Die Knöpfe wurden nach außen geführt und durch die Optokoppler geschaltet. Das Prototypeboard wurde von Pull-Up- auf Pull-Down-Betrieb umgelötet. Die rote Box sammelt zudem alle Kabel, so dass kein Lüsterklemmen mehr nötig sind und das Debuggen durch einfaches Abziehen und Anstecken erfolgen kann. @centered[@hyperlink["../media/tuer3.1.svg" @image["img/tuer3.1-kaskadierspiranz.png"]]] @; ----------------- @subsection[#:style 'unnumbered]{August 2018 - OMG Tür kaputt!} @; TODO CHECK August Nach fast einem Jahr Betrieb versagte auch der neue Schließzylinderantrieb. Es wurde ein Ersatzgerät beschafft. Der Vorfall ereignete sich innerhalb der Garantiezeit. Das neue Gerät scheint auch leiser als der Vorgänger zu sein. Auf eine Analyse durch Zerlegen wurde wegen der Gewährleistung verzichtet. Der neue Antrieb ließ sich reibungslos integrieren. Der Vorfall war neben ein paar kalten Lötstellen an Kabeln das einzige Hardware-Problem. @; ----------------- @subsection[#:style 'unnumbered]{Dezember 2018 - Update Tür3.1} Es wurde ein Mechanismus geschrieben, der die @emph{Let's Encrypt}-Zertifikate automatisch abholt. Dies ersetzt den bis dato händischen Prozess. @; ----------------- @subsection[#:style 'unnumbered]{September 2019 - Update} Das Web-Interface bekam von technischer Seite eine Kur. Dabei wurden die HTML-Templates und das Shell-Skript mittels @tt{htmllint} und @tt{shellcheck} auf Standardkonformität gebracht, die Konfiguraton des Webservers Nginx angepasst. Probleme mit dem Browser @tt{w3m} wurden beseitigt. Im Rahmen der Arbeiten wurden alle Übersichten und Grafiken in der Dokumentation aktualisiert, der gesamte Text der Dokumentation überarbeitet, alle relevanten Datenblätter und Anleitungen zusammengetragen und in die Dokumentation integriert. Die Dokumentation wurde um diese Historie ergänzt. Auf Codeberg wurde ein Repository, siehe @hyperlink["https://codeberg.org/kraut.space/tuer3.git" "codeberg.org/tuer3.git"], welches alle wichtigen Bestandteile der Türschließanlage vereint, angelegt. Mit diesem Update wurden viele der längst überfälligen Arbeiten erledigt : ) Danke an ndo und lycian. @; ----------------- @; @subsection[#:style 'unnumbered]{die Zukunft}