Werbung in eigener Sache: Werbung Werbung Werbung

GitLab – Continous Integration-Server mit Docker für Tests

gitlabdocker Zum Entwickeln eigener Projekte habe ich zu Hause einen eigenen GitLab-Server installiert, den ich seit geraumer Zeit auch für Unit-Tests und Lint verwende. GitLab bietet dazu über einen Continous Integration-Server (kurz CI-Server), die Möglichkeit beim Einchecken von neuem Code automatisch die Tests ablaufen zu lassen und dem Entwickler bei Misserfolg über eine Mail in Kenntnis zu setzen. Zur Konfiguration des CI-Servers gibt es mehrere Möglichkeiten. Zum Einen kann der Code direkt auf dem Host des Servers ausgeführt werden. Das hat jedoch den Nachteil, dass ich bei bestimmten Entwicklungsumgebungen extrem aufpassen muss, dass diese mir nicht Probleme auf dem Server machen. Beispielsweise, wenn ich in Python bestimmte Bibliotheken in einer bestimmten Version benötige, diese jedoch von einem Programm auf dem Server in einer anderen Version gebraucht werden. Zum Anderen habe ich aber auch die Möglichkeit den Code in einem Docker-Container auszuführen. Dies hat mehrere Vorteile. Die angesprochene Problematk wird gelöst, da alle Entwicklungsumgebungen in einem separaten Container gestartet werden, was den Host nicht verändert und es lassen sich damit unterschiedliche Versionen testen. Soll die Software beispielsweise mit Nodejs 6.11.3 und 8.5.0 kompatibel sein, lässt sich beides testen, indem unterschiedliche Docker-Images zum Einsatz kommen.

Für die Konfiguration von GitLab mit Docker müssen wir zunächst einmal Docker installieren. Leider werden nicht immer die aktuellen stabilen Versionen von bestimmen Paketen mitgeliefert. Daher deinstallieren wir erstmal Docker, falls dies bereits vorhanden ist und fügen dann die aktuellen stabilen Quellen hinzu, bevor wir es letztlich installieren. Ich installiere das Ganze auf einem Ubunutu Server 16.04.3 LTS.

# remove old docker installation
sudo apt remove docker docker-engine docker.io
# add current stable docker sources
sudo apt update
sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
# update sources
sudo apt update
# install community edition from docker
sudo apt-get install docker-ce
# upload and start docker container hello-world
sudo docker run hello-world

Nach dem letzten Befehl sudo docker run hello-world solltet ihr eine Ausgabe bekommen, die mit Hello from Docker beginnt, womit ihr die Installation von Docker erfolgreich abgeschlossen habt. Jetzt müssen wir den GitLab-Runner installieren und entsprechend mit Docker einen GitLab-Runner konfigurieren. Zur Installation des GitLab-Runner genügt folgender Befehl:

sudo apt install -y gitlab-ci-multi-runner

Für die Konfiguration benötigen wir jetzt noch ein paar individuelle Informationen eures GitLab-Servers. Dazu meldet ihr euch als Admin auf eurem GitLab-Server an und wechselt in der Admin-Area auf den Reiter Runners (sollte <GitLab-Server>/admin/runners sein). Dort findet ihr unter How to setup a shared Runner for a new project die Informationen, welche URL (<GitLab-Server>) und Token (<Token>) ihr im Folgdendne angeben müsst. Dazu einfach im folgenden Befehl die Platzhalter ersetzen und letztlich alles mit Enter quittieren.

sudo gitlab-runner register --url "<GitLab-Server>" --registration-token "<Token>" --description "docker" --executor "docker" --docker-image node:6.11.3

Dadurch haben wir jetzt einen GitLab-Runner konfiguriert, der als Standard-Image ein Nodejs-Server in Version 6.11.3 verwendet. Die Angabe des Docker-Images lässt sich aber in jeder gitlab-ci-Datei seperat definieren. Aktualisiert ihr jetzt die geöffnete GitLab-Seite (<GitLab-Server>/admin/runners), sollte dort ein neuer Runner-Eintrag vorhanden sein.

Möchtet ihr jetzt beispielsweise eure Nodejs-Applikation in Version 6.11.3 und 8.5.0 testen, so könnt ihr eurem Projekt die Datei .gitlab-ci.yml hinzufügen und folgenden Inhalt hinzufügen. Dadurch werden beide Versionen getestet.

node_6:
  image: node:6.11.3
  script:
   - npm install
   - npm run test

node_8:
  image: node:8.5.0
  script:
   - npm install
   - npm run test

Mit dieser Konfiguration laufen eurere Tests jetzt in einem vom Server-System abgekapselten Docker-Images, womit ihr die auf dem Server installierten Pakete unangetastet lassen könnt. Weiterhin könnt ihr jetzt mit unterschiedlichen Docker-Images euere Tests laufen lassen und somit besser eure Software testen. Ich hoffe der Beitrag hilft euch bei der Konfiguration und verbessert eueren Alltag. Solltet ihr Fragen oder Anregungen haben, dann könnt ihr mich jederzeit gerne kontaktieren.

LinConnect – Android-Benachrichtigungen am Computer erhalten

fhem Oft, wenn ich am Rechner sitze, verpasse ich immer Anrufe auf meinem Android-Smartphone, da dies lautlos und ohne Vibration in der Hosentasche ist. Mein Wunsch war also, dass ich die Benachrichtigungen über eingehende Anrufe im Benachrichtungsdienst meines Ubuntu-Rechners erhalte. Die Lösung nennt sich LinConnect. Das System besteht aus einer Server-Applikation auf dem Linux-Desktop (muss nicht Ubuntu sein) und einer Android-App, die als Client auf dem Smartphone läuft.

Zur Installation haben die Entwickler ein Installations-Skript angelegt. Doch bevor dies ausgeführt werden kann, müssen die Abhängigkeiten installiert werden. Dazu die folgenden Befehle in der Konsole ausführen.

sudo apt install -y python-pip python-gobject git libavahi-compat-libdnssd1 gir1.2-notify-0.7
wget https://storage.googleapis.com/google-code-archive-downloads/v2/code.google.com/pybonjour/pybonjour-1.1.1.tar.gz
tar zxf pybonjour-1.1.1.tar.gz
cd pybonjour-1.1.1
sudo python setup.py install
cd ..
rm pybonjour-1.1.1.tar.gz
find pybonjour-1.1.1 -delete

Jetzt sind wir soweit, dass LinConnect installiert werden kann. Mit folgenden Befehlen ladet ihr das Installations-Skript herunter, macht dies ausführbar und startet es.

wget --quiet https://raw.github.com/hauckwill/linconnect-server/master/LinConnectServer/install.sh
chmod +x install.sh
./install.sh

LinConnect Screenshot Nach dem Start des Skript werden Fragen zur Installation gestellt, die ich unter Ubuntu (was auf Debian basiert) wie folgt beantwortet habe.

Install LinConnect server? [Y/N]Y
Install dependencies automatically (for Debian-based distros) [Y/N]Y
Autostart LinConnect server on boot? [Y/N]Y
Install complete. Start LinConnect server now? [Y/N]Y

Der LinConnect-Server sollte jetzt starten und auch immer nach dem Starten des Computers automatisch aktiv sein. Als Gegenstelle wird jetzt noch die LinConnect-App benötigt, die ihr im App-Store findet. Sind Smartphone und Rechner im gleichen Netzwerk, findet die App automatich den Server und sendet Benachrichtigungen an den eigenen Computer. So erhält man dann alle Benachrichtigungen, wie Anrufe, Messenger und sonstige Meldungen (siehe Bild). In der App lassen sich dann unter Configuration –> Enable applications auch Apps abwählen, die keine Benachrichtigungen senden sollen. Beispielsweise bekommt man sonst Benachrichtigungen von neuen Mails doppelt, da Thunderbird und die Mail-App auf dem Android-Smartphone eine Benachrichtigungen schicken.

Ich hoffe ich konnte euch helfen. Solltet ihr Probleme bei der Installation oder Konfiguration haben, dann könnt ihr mich gerne kontaktieren. Ich freue mich immer über eure Mails.

FHEM – Einrichten von Heizungsthermostaten mit Raspberry Pi

fhem Wie bereits in einem älteren Blog-Eintrag beschrieben, verwende ich zu Hause FHEM mit dem HM-MOD-RPI-PCB-Modul von ELV auf einem Raspberry Pi 2. In dem Blog-Eintrag ist auch beschrieben, wie FHEM mit dem Modul auf dem Raspberry Pi installiert werden kann. Damals wollte ich einfach das Smarthome-System auf dem Raspberry Pi testen und hatte daher auch nur einen Außentemperatursensor bestellt. Da wir in eine neue Wohnung gezogen sind und hier die Heizungsthermostate nicht wie in der alten ein eigenes System haben, hab ich beschlossen mir von Homematic die passenden Heizungsthermostate HM-CC-RT-DN zu bestellen. Diese haben den Vorteil, dass sie selbst die Raumtemperatur messen können und daher keinen zusätzlichen Temperatursensor im Raum benötigen.

Mein Ziel ist es durch das System Heizkosten zu sparen, indem sich Wochenpläne definieren lassen, die es ermöglichen die einzelnen Zimmer in der Wohnung zu bestimmten Tagen und zu bestimmten Uhrzeiten zu heizen, beziehungsweise nicht zu heizen. In der Verpackung der Heizungsthermostate sind notwendige Adapter für die gängigsten Heizungsventile vorhanden und auch eine Montageanleitung, die ich euch ans Herz legen würde, damit der Thermostat richtig an der Heizung sitzt. Die weitere Einrichtung in FHEM möchte ich jetzt im Folgenden erklären.

Die Installation der Thermostate bezieht sich auf die Einstellungen, die bereits in diesem Blog-Eintrag gemacht wurden. Solltet ihr hier von abgewichen sein, müsst ihr dies selbstverständlich beachten. Wir öffnen als erstes unsere FHEM-Seite unter http://raspberry:8083/fhem. Damit wir unsere Thermostate nun mit dem Modul pairen können, müssen wir das Modul öffnen. Dazu fügt ihr folgenden Befehl oben ein und drückt Enter.

set myHmUART hmPairForSec

Als nächstes möchten wir jetzt den Thermostat verbinden und drücken dazu auf dem Thermostat für 3 Sekunden auf die mittlere Taste (Boost-Taste). Es beginnt ein Countdown von 30 herunterzuzählen. War die Verbindung erfolgreich, erscheint ein AC auf dem Thermostat-Display. Weiterhin solltet ihr jetzt unter http://raspberry:8083/fhem?room=all weitere Einträge unter CUL_HM finden. Hat die Verbindung nicht funktioniert, solltet ihr versuchen den Raspberry Pi zum Anlernen möglichst in die Nähe des Thermostates bringen. Danach könnt ihr ihn wieder an den gewohnten Platz stellen (Das hat zumindest bei mir dann sofort funktioniert).

Damit wir erstmal keine anderen Geräte anlernen, ist es sinnvoll das Modul wieder zu schließen. Das hat auch den Vorteil, dass ich Thermostat für Thermostat anlernen kann und den richtigen Zimmern zuordnen kann, bevor ich alle Thermostate in FHEM habe und mir erstmal schwer fällt über die kryptische Nummer herauszufinden, wo der zugehörige Thermostat installiert ist. Also folgenden Befehl wieder einfügen und Enter drücken.

set myHmUART close

weekprofile FHEM Jetzt möchten wir als die Konfiguration des Thermostats in FHEM laden. Dazu nehmen wir die unter http://raspberry:8083/fhem?room=all erschienenen Einträge zur Hilfe. In meinem Fall stehen hier jetzt unter CUL_HM: HM_5ABEDF_Clima, HM_5ABEDF_ClimaTeam, HM_5ABEDF_Climate und so weiter. Zum Laden der Konfiguration benötigen wir allerdings nur die kryptische Nummer HM_5ABEDF und können dann mit folgendem Befehl die Konfiguration laden. In eurem Fall müsst ihr natürlich die Nummer durch eure ersetzen.

set HM_5ABEDF getConfig

Nach Ausführung des Befehls werden die Einträge von HM_5ABEDF_Clima, HM_5ABEDF_ClimaTeam, HM_5ABEDF_Climate und so weiter mit den erhaltenen Informationen befüllt. Hier könnt ihr jetzt auch beispielsweise schon mit dem Dropdown-Menü bei HM_5ABEDF_Clima die gewünschte Temperatur festlegen. Ihr könnte auch diese Zeile direkt einem Zimmer zuordnen, indem ihr folgenden Befehl ausführt.

attr HM_5ABEDF_Clima room Wohnzimmer

Zum Anlegen des angesprochen Wochenplans könnt ihr mit folgendem Befehl eine grafische Komponente in FHEM dafür erhalten. Dort lassen sich dann mehrere Profile erstellen, wo ihr genau definieren könnt, wie geheizt werden soll. Über den –>-Button lässt sich dann das Profil auf den Thermostat übertragen.

define Heizungsplan weekprofile HM_5ABEDF_Clima

Ich hoffe ich konnte euch beim Einrichten der Thermostate in FHEM helfen. Ich bin zufrieden mit dem System, weil ich mit dem Raspberry Pi neben der Hausautomatisierung auch andere Probleme lösen kann und werde vermutlich auf diesem Raspberry Pi auch die Software für den MagicMirror installieren. Solltet ihr Probleme haben oder Fragen, dann könnt ihr mich gerne kontaktieren. Ich versuche dann so gut es geht zu helfen.

Radicale – Kalender und Kontakte auf dem eigenen Server (Raspberry Pi) verwalten

Radicale Decker

Ich verwendete schon seit Jahren Baikal zum Speichern meiner Kalender-Einträge und Kontakte. Früher noch auf meinem Raspberry Pi mittlerweile auf meinem Heim-Server. Ich bin völlig zufrieden mit der Lösung und war daher traurig darüber, dass das Projekt nicht mehr weiter entwickelt wird http://sabre.io/blog/2017/development-on-hold/. Aktuell läuft noch alles perfekt, doch war ich dennoch auf der Suche nach einer Alternative und bin auch fündig geworden. Radicale ist ein in Python3 implementierter CalDAV- und CardDAV-Server, der mir die gleichen Vorzüge wie Baikal bietet und ist ebenso schlank implementiert, dass es auch ohne Probleme auf dem Raspberry Pi läuft.

Die Installation ist denkbar einfach. Ihr solltet zunächst python3 und pip installieren und anschließend radicale.

# install python3 and pip
sudo apt install python3 python3-pip -y
# install radicale
sudo python3 -m pip install --upgrade radicale

Nach diesen Schritten legt ihr eine Konfigurationsdatei an, mit der ihr festlegt, dass ihr den Server auch innerhalb eures Netzwerkes erreicht, da standardmäßig nur ein lokaler Zugriff gestattet wird.

sudo mkdir -p /etc/radicale
sudo nano /etc/radicale/config

Fügt folgende Zeilen ein und speichert mit Strg+X und Y und Enter.

[server]
hosts = 0.0.0.0:5232

Jetzt können wir radicale zum ersten Mal starten, wobei ihr über den storage-filesystem-folder angeben könnt, wo eure Daten gespeichert werden und damit auch welchen Ordner ihr im Anschluss von diesem Blog-Eintrag eurem Backup hinzufügen müsst.

python3 -m radicale --storage-filesystem-folder=/home/pi/radicale/collections

Jetzt könnt ihr unter http://localhost:5253, wenn ihr euch direkt auf dem Server befindet, oder aber auch http://raspberrypi:5253 aufrufen, wenn ihr euch in eurem Netzwerk befindet. Es zeigt sich jetzt eine Weboberfläche, die seit Version 2.1 in radicale integriert ist und mit der ihr ganz einfach neue Nutzer anlegen könnt und neue Kalender und Todo-Listen oder Adressbücher erstellt. Meldet euch dazu einfach mit eurem gewünschten Nutzernamen und Passwort an. Der Nutzer wird automatisch generiert. Am Besten ihr speichert direkt euer Passwort, weil ich noch keine Möglichkeit gesehen habe, das Passwort zurück zusetzen oder eine Datei zu finden, wo das Passwort im Klartext steht. Dann klickt ihr einfach auf Create new addressbook or calender, legt Title, Description, Type und Color fest und bestätigt mit Create euren Vorgang. Zur Belohnung bekommt ihr einen URL-Link, mit dem ihr jetzt Zugriff auf den Kalender und Todo-Liste oder Adressbuch erhalten könnt.

Die erhaltene URL könnt ihr beispielsweise in Thunderbird beim Erstellen eines neuen Kalenders angeben. Dazu beim Anlegen eines Kalender Im Netzwerk auswählen und dann CalDAV auswählen, sowie die URL in den vorgesehenen Bereich kopieren. Nach Weiter, Festlegung des Namens und der Farbe, Weiter und Fertigstellen könnt ihr dann den Kalender in Thunderbird verwenden, sobald ihr euren Benutzername und Passwort von radicale eingegeben habt. Für die Verwendung am Smartphone empfehle ich die DAVDroid-App. Dort könnt ihr auch, wenn ihr nur den Anfang eurer URL, in meinem Fall http://raspberrypi:5232/christian.decker, eintragt mehrere Adressbücher und Kalender laden.

Damit der Server automatisch gestartet wird, müssen wir jetzt noch ein Autostart-Skript erstellen. Dazu erstmal über Strg+C die Ausführung des aktuellen Skriptes beenden und anschließend erstellen wir die Datei radicale.service.

sudo nano /etc/systemd/system/radicale.service

Fügen folgenden Inhalt hinzu und speichern mit Strg+X und Y und Enter.

[Unit]
Description=A simple CalDAV (calendar) and CardDAV (contact) server

[Service]
ExecStart=/usr/bin/env python3 -m radicale --storage-filesystem-folder=/home/pi/radicale/collections
Restart=on-failure

[Install]
WantedBy=default.target

Jetzt können wir das Skript aktivieren, starten und direkt den Status überprüfen. Hier solltet ihr jetzt ein active (running) finden und ihr solltet

# enable service
sudo systemctl enable radicale.service
# start service
sudo systemctl start radicale.service 
# check status
sudo systemctl status radicale.service 

Nach einem Reboot (_sudo reboot) sollte radicale jetzt automatisch starten. Die Kommunikation zwischen eurem Smartphone oder Computer ist jedoch noch unverschlüsselt und ihr solltet entweder dafür sorgen, dass euer Server wirklich nicht von außen erreichbar ist oder ihn über einen Reverse Proxy mit nginx und einem Zertifikat absichern, wie hier beschrieben.

Ich hoffe, ich konnte euch einen guten Einblick in die Installation und Konfiguration von radicale bieten. Solltet ihr noch weitere Fragen haben, dann könnt ihr mich gerne kontaktieren.

EveBox – Interaktives Gruppenerlebnis auf Hochzeiten, Geburtstagen und sonstigen Events

EveBox Wir sind stolz, dass wir heute eine kleine Veröffentlichung feiern können. Im Zuge unserer Hochzeit haben wir ein Spiel für unsere Gäste entwickelt, das wir gerne mit euch teilen würden. EveBox ist ein interaktives Spiel, das es euch als Gastgeber ermöglicht euren Gästen Aufgaben zu stellen, die dann mit Smartphone oder aufgebauten Laptop-Stationen erledigt werden können. Es soll sich dabei ideal in euer Fest integrieren.

Das Spielprinzip ist denkbar einfach. Jeder Gast kann eine bestimmte Anzahl an Aufgaben lösen und bekommt dafür Punkte. Alle Gäste spielen zusammen und sammeln somit Punkte, um im Voraus ausgesuchte Bilder der Gastgeber freizuspielen. Zum Spielen gibt es vier Aufgabentypen: Aufgabe, Bild, Video und Frage. Aufgaben können dann beispielsweise “Tanze mit der Mutter des Bräutigams”, “Gib einem fremden ein Kompliment”, “Fotografiere eine Grimasse” und “Mache ein Foto von dir im Häschen-Kostüm” sein. Der Kreativität der Gastgeber sind dabei jedoch keine Grenzen gesetzt. Die freigespielten Bilder der Gastgeber sowie die eingereichten Aufgaben der Gäste mit Typ Bild werden dann während des Festes in einer Bilderschau auf einem Display dargestellt.

Aus eigener Erfahrung wurde das Spiel sehr gut angenommen und führt vor allem bei gemischten Gesellschaften wie bei Hochzeiten, wo sich die Gäste teilweise zum ersten Mal sehen, durch Aufgaben mit “Fremden” zum besseren gegenseitigen Kennelernen. Weiterhin entstehen viele lustige Bilder, Videos und Textbeiträge, die für die Gastgeber und Gäste für immer in Erinnerung bleiben werden. Im Zeitalter von Digitalisierung und Smartphone gehört unseres Erachtens nach EveBox zu einem unvergesslichen Event dazu. Wenn ihr herausfinden wollt, was EveBox genau ist, dann könnt ihr einfach auf die Homepage https://evebox.de gehen. Habt ihr noch Fragen oder wollt EveBox auf eurem nächsten Event ausprobieren? Dann findet ihr dort auch Kontaktmöglichkeiten.

Datenschutz – "Ist doch eh alles egal?!"

Kann man alles in einen Topf werfen In letzter Zeit wird viel über Industrie 4.0, Internet of Things (IoT), Big Data, und künstliche Intelligenz geschrieben und viel über die Vorteile gesprochen – Vernetze Systeme weltweit, verbesserte Wartbarkeit, individuelle Produktionsanlagen und erhöhte Sicherheit im Straßenverkehr und anderen Lebensbereichen. Als technisch interessierter Mensch verstehe ich die Vorteile, sehe allerdings auch einen bestimmten Machtmissbrauch der großen Konzerne, sowie der Machtlosigkeit der Anwender.

Aussagen wie, “Ist doch eh egal, Google weiß eh schon alles”, machen mich immer hellhöhrig und auch etwas traurig. Letztlich haben die meisten ihre Daten und ihre Privatsphäre damit aufgegeben. Google und Co wissen eben nicht alles. Ihr und euer Leben verändert sich und das bekommen die Konzerne nur mit, weil ihr über Facebook teilt, mit Google sucht, über WhatsApp kommuniziert und mit Karte bezahlt. Ich muss gestehen, ich nutze all diese Dienste auch, weil es einfach praktisch ist, denoch finde ich sollte der Umgang damit kritisch hinterfragt werden und nicht bedenkenlos ohne Alternativen genutzt werden. Wer die Daten richtig kombiniert, kann beispielsweise noch bevor euer Arbeitgeber es erfährt wissen, dass ihr einen neuen Job sucht oder weiß Bescheid, wenn ihr ein Kind erwartet noch bevor es eure nächsten Freunde und Verwandten wissen. Würdet ihr bedenkenlos solche persönlichen und intimen Dinge in der regionalen Zeitung inserieren? Natürlich nicht, aber wenn die Konzerne daraus ein exaktes Bild von euch und den Menschen in euerer Umgebung machen können, ist das schon irgendwie okay. Kostet ja kein Geld und ist so schön bequem.

Ich frage mich, warum wir uns keine Zeit mehr nehmen uns Gedanken zu machen, welche Produkte und Dienste wir nutzen und wie wir sie nutzen, bevor wir sie nutzen. Wenn alle WhatsApp nutzen, tue ich das auch, auch wenn dadurch genau bekannt wird, wann ich mit wem und zur welcher Uhrzeit kommuniziert habe. Wenn alle ein Android oder iPhone haben, dann kaufe ich auch eins und natürlich möchte ich dann meine Standortinformationen mit Google und Apple teilen, weil … ja warum eigentlich? Damit der höchstbietende mir vorschlagen kann, wo ich esse, trinke, zum Friseur gehe und einkaufen gehe. Ich brauche mich nicht mehr auf meine Instikte zu verlassen, Google weiß ja eh alles, also kaufe ich was Google mir sagt. Bestelle das, was Amazon mir vorschlägt und wenn ich einsam bin, rede ich einfach mit Alexa, die mir dann sagt wie schön ich bin.

Ich habe einfach das Gefühl, dass wir den Konzernen mehr Vertrauen als unserem besten Freund entgegenbringen. Denn das “ist ja nur Technik”, aber das stimmt eben nicht. Es geht den Konzernen letztlich darum aus ihrer Technik mehr Kapital zu schlagen, als sie reinstecken und das machen sie richtig gut, wenn man sich mal die Gewinne anschaut. Ich möchte nicht grundsätzlich sagen, dass es schlecht ist, was uns der technische Fortschritt bringt. Das Beispiel “Autonomes Fahren” macht deutlich: Durch vernetzte Systeme, Datenanalyse und künstliche Intelligenz erreichen wir mehr Sicherheit, aber muss dabei Google bescheid wissen, wohin wir fahren, was wir nebenher machen und mit wem wir fahren? Durch Industrie 4.0 können bald Produktionsanlagen vorhersagen, welche Maschinenteile voraussichtlich defekt gehen und rechtzeitig gewartet werden, aber muss dabei der Maschinenbediener überwacht werden und ihm über eine Smartwatch mitgeteilt werden, dass er nur noch zehn Sekunden hat, um das nächste Teil einzulegen?

Ich denke wir stehen alle in der Verantwortung uns mehr über unser Nutzerverhalten Gedanken zu machen, denn letztlich entscheiden wir, was mit uns passiert und es ist eben nicht egal. Vielleicht nehmt ihr eine Kleinigkeit von meinen Gedanken mit und wenn ihr wollt, könnt iht mich wie immer gerne kontaktieren.

MagicMirror² – Das nächste große Projekt

magicmirror display Schon vor einigen Wochen (laut meinem Taskwarrior 11 Wochen) bin ich über das Projekt MagicMirror² gestolpert und bin sofort angefixt worden, dass wir das in unserem Haushalt brauchen. Es handelt sich dabei um einen Spionagespiegel, hinter dem ein Display angebracht wird und ihr somit sowohl euer Spiegelbild als auch die Informationen(Uhrzeit, Nachrichten, Komplimente und so weiter) auf dem Display sehen könnt. Nachdem zunächst das Projekt aufgrund anderer Projekte zurückstecken musste, konnte ich mich heute erstmals daran setzen. In der Vorbereitung darauf musste ich zunächst einen passenden Display finden. Ob er letztendlich passt, weiß ich noch nicht 100%, aber letztlich verwende ich einen alten Display aus einem kaputten Laptop. Zufälligerweise gab es für das Display bei ebay einen passenden Controller und für die Stromversorgung habe ich ein passendes Netzteil dafür bestellt. Letztlich kann aber jedes ausgediente Display dienen, das über einen HDMI-Port verfügt, da ihr es dann direkt in den Raspberry Pi stecken könnt. Da aber vor das Display noch der Spionagespiegel muss, dachte ich mir, dass das Laptop-Display aufgrund seines nichtvorhandenen Rahmens ideal sein könnte.

Der Spionagespiegel fehlt aktuell noch aber ich habe mich bereits mit der Installation der Software befasst und würde euch hier gerne eine kurze Anleitung dafür geben. Ich installiere das Ganze auf dem Raspberry Pi 3, allerdings sollte es auch auf dem 2er funktionieren. Als Basis nehme ich immer wieder gerne Raspbian Lite(aktuell mit Debian Jessie), da hier der unnötige Schnickschnack nicht mitgeliefert wird.

Da bei Raspbian Lite kein Desktop installiert ist, beziehungsweise der notwendige X11-Server fehlt, müssen wir zunächst einen Mini-Desktop installieren. Das kann einige Zeit in Anspruch nehmen, da hier ein paar Pakete heruntergeladen werden müssen. Weiterhin installiere ich im folgenden noch die notwendigen Pakete für den MagicMirror².

# update and upgrade
sudo apt update
sudo apt upgrade -y
# install desktop
sudo apt install --no-install-recommends xserver-xorg -y
sudo apt install openbox -y
sudo apt install lightdm -y
# install dependencies
sudo apt install git unclutter x11-xserver-utils xterm libxss1 libnss3 libgconf2-dev -y

magicmirror screenshot

Im Weiteren wollen wir jetzt, dass zum einen der Screensaver deaktiviert wird und dass kein Mauszeiger angezeigt wird und führen dazu folgende Befehle aus.

# turn off mousecursor and screensaver
sudo sed -i 's/# xserver-command = X.*/xserver-command = X -nocursor' /etc/lightdm/lightdm.conf
sudo sed -i 's/BLANK_TIME.*/BLANK_TIME=0/' /etc/kbd/config
sudo sed -i 's/POWERDOWN_TIME.*/POWERDOWN_TIME=0/' /etc/kbd/config
# write to ~/.bashrc
echo 'export DISPLAY=:0' >> ~/.bashrc 
echo 'xset s noblank' >> ~/.bashr
echo 'xset s off' >> ~/.bashrc
echo 'xset -dpms' >> ~/.bashrc

Damit das .bashrc-Skript auch aufgerufen wird, aktivieren wir noch über raspi-config den Autologin des Pi-Nutzers.

sudo raspi-config

Und jetzt unter Boot Options –> Desktop/CLI –> Desktop Autologin aktivieren. Zu guter letzt ein neustart mit sudo reboot, um all Änderungen auch aktiviert zu haben.

Nun verwenden wir das Installation-Skript von MagicMirror² zur Installation unseres Spiegels und starten ihn.

cd ~/MagicMirror
npm install
cp config/config.js.sample config/config.js
npm start

Ihr solltet jetzt bereits auf eurem Display eine schöne Anzeige wie im Bild haben. Damit nach einem Neustart die Software automatisch startet, könnt ihr noch ein Autostart-Skript anlegen und nach einem Neustart sollte MagicMirror² automatisch starten.

mkdir /home/pi/.config/autostart
touch /home/pi/.config/autostart/magicmirror.desktop
echo '[Desktop Entry]' >> /home/pi/.config/autostart/magicmirror.desktop
echo 'Type=Application' >> /home/pi/.config/autostart/magicmirror.desktop
echo 'Exec=/usr/bin/npm start' >> /home/pi/.config/autostart/magicmirror.desktop
echo 'Path=/home/pi/MagicMirror/' >> /home/pi/.config/autostart/magicmirror.desktop
sudo reboot

Soviel mal für den ersten Teil des MagicMirror². Es stehen jetzt noch ein paar Dinge an, die ich versuchen werden hier zu dokumentieren: Konfiguration der Oberfläche, Bau des Rahmen und eventuell noch die Entwicklung eigener Erweiterungen. Solltet ihr Fragen oder Anregungen haben, dann könnt ihr mich wie immer über den Kontakt-Bereich kontaktieren.

FHEM – Einfach besser als RaspberryMatic

fhem Ich berichtete bereits in einem Artikel von dem HM-MOD-RPI-PCB-Modul von ELV. Damals habe ich aus mangelndem Wissen das RaspberryMatic-System installiert. Ich war allerdings nie so wirklich glücklich damit. Das hatte mehrere Gründe: Zum einen wollte ich ein normales Raspbian nutzen und nicht ein eigenes Betriebsystem und zum anderen schien mir das Ganze sehr nach einer Notfalllösung, die nicht wirklich gut unterstützt wird. Die Tage bin ich mal wieder über die FHEM-Homepage gestolpert.

Dort war beschrieben, dass das HM-MOD-RPI-PCB-Modul bereits im Juni 2016 begonnen wurde in FHEM zu integrieren. Also setzte ich schnell ein neues Raspbian Jessie auf und begann FHEM zu installieren. Als kleine Hilfe für euch im Folgenden die Schritte, die notwendig sind:

sudo apt update
sudo apt upgrade -y

# add user and set password
sudo useradd -m fhem
sudo passwd fhem
sudo adduser fhem sudo
sudo usermod -a -G dialout fhem

# switch user
su fhem

# install dependencies
sudo apt -y install perl-base libdevice-serialport-perl libwww-perl libio-socket-ssl-perl libcgi-pm-perl libjson-perl sqlite3 libdbd-sqlite3-perl libtext-diff-perl libtimedate-perl libmail-imapclient-perl libgd-graph-perl libtext-csv-perl libxml-simple-perl liblist-moreutils-perl ttf-liberation libimage-librsvg-perl libgd-text-perl libsocket6-perl libio-socket-inet6-perl libmime-base64-perl libimage-info-perl libusb-1.0-0-dev libnet-server-perl

# add key
wget -qO - http://debian.fhem.de/archive.key | sudo apt-key add -

# add line
echo "deb https://debian.fhem.de/nightly /" | sudo tee -a /etc/apt/sources.list

Damit sind alle Vorbereitungen getroffen und es kann direkt FHEM installiert werden. Nach der Installation wird automatisch der Eintrag in /etc/apt/sourcelist entfernt. Die Installation dient nur zur initialen Konfiguration und muss dann in Zukunft über die update-Methode vom FHEM aktualisiert werden.

sudo apt update
sudo apt install fhem
sudo reboot

Nach dem Neustart solltet ihr unter http://raspberry:8083 FHEM erreichen. Jetzt müssen wir noch das HM-MOD-RPI-PCB-Modul konfigurieren. Dazu muss bei meinem Raspberry Pi 2 in der /boot/config.txt mit folgendem Befehl ein Eintrag hinzugefügt werden. Für den Raspberry Pi 3 lest ihr am besten im verlinkten Beitrag nach, da dort noch ein paar mehr Dinge beachtet werden müssen.

echo "enable_uart=1" | sudo tee -a /boot/config.txt

Jetzt in der /boot/cmdline.txt folgenden Eintrag löschen.

console=serial0,115200 

Und schließlich noch serial-getty deaktivieren und den Raspberry Pi neustarten.

sudo systemctl disable serial-getty@ttyAMA0.service
sudo reboot

Nach dem Neustart könnt ihr jetzt in FHEM das Modul definieren und eine hmId setzen. Dazu wieder unter http://raspberry:8083 gehen und in das Eingabefeld einfach nacheinander folgenden Befehle eingeben. myHmUART könnt ihr dabei frei definieren und stellt einfach den Namen dar über den ihr das Modul ansprechen könnt.

define myHmUART HMUARTLGW /dev/ttyAMA0
attr myHmUART hmId 100000

Wie in meinem alten Artikel habe ich immer noch den Außentemperatursensor HM-WDS10-TH-O, der sich sehr einfach pairen lässt. Dazu einfach auf http://raspberry:8083/fhem?detail=myHmUART gehen und unter set myHMUART im Dropdown-Menü hmPairForSev auswählen. Dann den Pair Knopf auf dem Außentemperatursensor drücken und ihr solltet verbunden sein. Dazu einfach mal unter Unsorted schauen, ob ein neues Gerät dort gelistet wird.

Jetzt solltet ihr FHEM mit dem HM-MOD-RPI-PCB-Modul installiert haben. Damit beginnen erst die Möglichkeiten von FHEM. Es lassen sich hier beispielsweise Diagramme definieren, weiterhin kann beispielsweise auch euer Smartphone als Sensor dienen, indem der Raspberry Pi die IP-Adresse das Smartphone anpingt und dann gegebenfalls Events gestartet werden, die beispielsweise euren Server in Standby schalten, wenn ihr nicht zu Hause seid. Der Kreativität sind hier kaum Grenzen gesetzt.

Für mich ist FHEM definitiv die Wahl für das HM-MOD-RPI-PCB-Modul. Dadurch, dass es auf dem normalen Raspbian installiert werden kann, kann der Raspberry Pi noch für weitere Dinge verwendet werden und ist nicht wie bei RaspberryMatic eingeschränkt in seinen Möglichkeiten. Solltet ihr Probleme haben oder Fragen, dann könnt ihr mich gerne kontaktieren.

Wechsel von Octopress zu Jekyll - Neuer Blog Kern

octopress to jekyll Vor gut einem Jahr haben wir diesen Blog auf Octopress umgezogen. Im Laufe des vergangenen Jahres wurde es immer schwieriger damit produktiv zu arbeiten und führte letztlich dazu, dass es kaum noch möglich war neue Blog-Einträge zu schreiben. Letztlich daraus geschuldet, dass Octopress scheinbar nicht weiterentwickelt wird, waren wir auf der Suche nach einer Alternative, die den Umstieg möglichst leicht macht.

Da Octopress so oder so auf jekyll basiert, haben wir jetzt den Wechsel komplett zu jekyll vollzogen. Leider haben wir dadurch unsere Links verändern müssen und somit müsst ihr eure Verlinkungen anpassen, denn die Inhalte sind immer noch die gleichen, nur unter einer anderen URL.

Viel Spaß mit dem neuen Blog.

Der Aufgabenkrieger - Aufgabenverwaltung mit Taskwarrior Teil 2

taskserver Ich berichtete bereits am 16.10.2016 über den Taskwarrior in meinem Blog-Eintrag Der Aufgabenkrieger - Aufgabenverwaltung mit Taskwarrior. Damit das Tool nicht nur lokal auf meinem Rechner läuft und ich es auch auf meinem Laptop und anderen Geräten verwenden kann, gibt es den Taskserver, der die Synchronisation zwischen einzelnen Geräten ermöglicht. Die Installation erfordert ein paar Schritte, die ich jedoch im folgenden kurz erläutern werde.

Zunächst benötigen wir einen Server. Dazu solltet ihr fast alles nehmen können, das 24 Stunden (bzw. die Zeit in der das Tool benötigt wird) an ist, Linux installiert hat und einigermaßen auf einem aktuellen Stand ist. Ich habe einen Ubuntu 16.04 LTS Server, allerdings sollte auch ein Raspberry Pi gehen oder euer vServer. Als erstes bringen wir den Server auf den aktuellsten Stand, installieren die notwendige Software und erstellen einen Benutzer taskserver mit den folgenden Befehlen.

# Update your server
sudo apt update
sudo apt upgrade -y
# Install dependencies
sudo apt install libgnutls-dev gnutls-bin uuid-dev cmake g++ -y
# Create new user
sudo useradd -m taskserver
# Set password for user
sudo passwd taskserver
# Give user sudoer permissions
sudo usermod -a -G sudo taskserver

Im nächsten Schritt wechseln wir jetzt zu dem neu angelegten Nutzer taskserver, laden taskd (den Taskserver) herunter, kompilieren die Software auf unserem Server und testen diese.

# Switch to taskserver-User
su taskserver
cd ~
# Download sources
git clone https://git.tasktools.org/scm/tm/taskd.git taskd.git
cd taskd.git/
# Compile sources
cmake -DCMAKE_BUILD_TYPE=release .
make
# Test compiled sources
cd test/
make
./run_all

Nach Ablauf des Tests sollte euer Ergebnis dem Folgenden ähneln, sonst ist etwas schief gelaufen und ihr müsst nochmal die einzelnen Schritte überprüfen.

Pass:     2920
Fail:        0
Skipped:     0
Runtime:     1 seconds

Anschließend kann der Server vollständig installiert werden und die Konfiguration vorgenommen werden. Ich habe beispielsweise meine Daten auf eine externe Festplatte unter /media/external/taskd ausgelagert, welches ihr im Folgenden dann an eure Bedürfnisse anpassen müsst.

cd ..
# Install taskserver
sudo make install
# Check if taskd gives you output
taskd
# Set storage place for the server
export TASKDDATA=/media/external/taskd
# Create storage and give taskserver user ownership
mkdir -p $TASKDDATA
sudo mkdir -p $TASKDDATA
sudo chown taskserver:taskserver $TASKDDATA
# Initalize taskd
taskd init
# Generate self-signed certificate
cd pki/
# Set your variables for creating the certificate. Change in any case the CN-Property to the name of your server (e.g. decker-software-solutions.de)
nano vars
./generate
cp client.cert.pem $TASKDDATA
cp client.key.pem $TASKDDATA
cp server.cert.pem $TASKDDATA
cp server.key.pem $TASKDDATA
cp server.crl.pem $TASKDDATA
cp ca.cert.pem $TASKDDATA
# Set configuration
taskd config --force client.cert $TASKDDATA/client.cert.pem
taskd config --force client.key $TASKDDATA/client.key.pem
taskd config --force server.cert $TASKDDATA/server.cert.pem
taskd config --force server.key $TASKDDATA/server.key.pem
taskd config --force server.crl $TASKDDATA/server.crl.pem
taskd config --force ca.cert $TASKDDATA/ca.cert.pem
cd $TASKDDATA
taskd config --force log $PWD/taskd.log
taskd config --force pid.file $PWD/taskd.pid
taskd config --force server 0.0.0.0:53589
taskd config

Jetzt sind wir soweit und können den Server das erste Mal starten, stoppen und anschließend direkt einen Benutzer für die Verwendung am Client-Rechner anlegen. Bei der Generierung des Users erhaltet ihr eine User-ID, die ihr euch für später speichern solltet, da ihr sonst euren Client nicht konfiguriert bekommt. Die User-ID findet ihr auch wieder in eurem Datenverzeichnis unter $TASKDDATA/orgs/Public/users/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX, einfacher ist es aber diese sich einfach direkt nach dem taskd add user ‘Public’ ‘Christian Decker’-Befehl zu sichern.

# Starts server
taskdctl start
# Stops server
taskdctl stop
# Starts again
taskdctl start
# Check if server is really running
ps -leaf | grep taskd
# Create an organisation Public
taskd add org Public
# Create an user in this organisation
taskd add user 'Public' 'Christian Decker'
# Create a key for secure communication with the server
cd ~/taskd.git/pki/
./generate.client christian_decker
# copy the following files to your client. cat just shows you the files. Maybe use scp to copy them to your client
cat christian_decker.cert.pem
cat christian_decker.key.pem
cat ca.cert.pem

Hat bis jetzt alles funktioniert, müssen wir nur noch den Client einrichten. Dazu müssen wir, wie bereits im obigen Skript beschrieben, irgendwie die Dateien christian_decker.cert.pem, christian_decker.key.pem und ca.cert.pem auf unseren Client bekommen. Entweder ihr erstellt einfach eine Datei und kopiert den Inhalt der Datei hinein (cat zeigt euch beispielsweise den Inhalt an) oder ihr verwendet scp, falls ihr eine SSH-Verbindung zu eurem Server habt. Jetzt müssen wir noch die Konfiguration auf dem Client anpassen und dann sollte es euch möglich sein eure Aufgaben auf dem Server zu verwalten und von überall aus zuzugreifen.

# Client side
cd ~/.task
# Set configuration
task config taskd.certificate -- ~/.task/christian_decker.cert.pem
task config taskd.key -- ~/.task/christian_decker.key.pem
task config taskd.ca -- ~/.task/ca.cert.pem
task config taskd.server -- decker-server:53589
# enter instead of XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX here your User-ID
task config taskd.credentials -- Public/Christian Decker/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
# sync for the first time
task sync init
# now you can sync with the following when you edited your tasks
task sync

Jetzt solltet ihr euren Taskserver erfolgreich installiert und konfiguriert haben. Eine kurze Anmerkung noch zu den verwendeten Zertifikaten, welche selbst signiert sind: Selbst signierte Zertifikate sind in der Regel nur für die ersten Tests zu verwenden und auf keinen Fall im Produktivsystem zu verwenden, es sei denn ihr betreibt euer System wirklich nur im lokalen Netzwerk, dann könnt ihr diese getrost nehmen. Ich hoffe ich konnte euch helfen. Wenn ihr noch Fragen oder Anregungen habt, dann könnt ihr mich gerne über den Kontakt-Bereich meiner Firma kontaktieren.

subscribe via RSS