add documentation source

This commit is contained in:
jtf 2019-09-29 17:37:44 +02:00
parent 652cbd82bd
commit 27e9828f7a
2 changed files with 622 additions and 0 deletions

2
documentation/build.sh Executable file
View file

@ -0,0 +1,2 @@
#!/bin/sh
scribble --htmls doc.scrbl

620
documentation/doc.scrbl Normal file
View file

@ -0,0 +1,620 @@
#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 <NICK>}
@; ---------------------------------------------------------------------
@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}