Wikis der einzelnen Spaces hierher zusammengeführt

+## Voraussetzungen

+

+- Ihr Computer befindet sich im Uni-Netz bzw. im TUM-VPN

+- Sie haben das Programm Microsoft Remote Desktop installiert (kostenlos für PC und Mac verfügbar)

+

+## Vorgehen

+

+- Microsoft Remote Desktop öffnen

+- unter "+"-Symbol "PC hinzufügen"

+- Bei "PC Name" eingeben: `TUEDS09-RECOM.srv.mwn.de`

+- Mit TUM-Kennung anmelden

+- Die Software "GRIPS_V5" von Desktop-Verknüpfung aus starten. (Falls die Software nicht zu finden ist: Admin benachrichtigen)

+# Setup

+

+Die Software von Recom ("Recom Grips") läuft auf einer VM beim LRZ: `tueds09-recom.srv.mwn.de`. Zugriff auf die VM-Konsole, d. h. die Verwaltungsoberfläche der VM beim LRZ, hat Bert Krohn.

+

+# Admin-Zugriff

+

+Auf der VM selbst ist auch Joachim Siegert mit seiner LRZ-Kennung `ge52jep` als Admin angelegt sowie der Benutzer `RECOM` zur Nutzung durch Recom (insbesondere Gohl).

+

+# Remote Desktop Verbindungen

+

+Für einen RDP-Zugriff muss der Benutzer der Gruppe "Remotedesktopbenutzer" hinzugefügt sein und sich im TUM-VPN befinden (zu Testen: geht es aus dem MWN auch ohne VPN?).

+Der für RDP-Zugriffe verwendete Port 3389 ist in der Firewall nur für TUM-VPN sowie für die einzelne IP `217.239.200.202` freigegeben; diese verwendet Recom.

+RDP-Lizenzen haben wir extra dafür gekauft, falls die Frage jemals aufkommt.

+

+# Benutzer anlegen

+

+Studierende sollen per Remote Desktop-Zugriff mit Recom Grips arbeiten. Es ist zu klären, wie wir den Zugriff auf die VM effizient verwalten.

+

+## Variante 1: Mit TUM-Kennung

+

+Aktueller Weg: Wenn `{TUM-Kennung}` mit Recom arbeiten können soll, dann als Admin

+1. Startmenü -> Systemsteuerung -> Benutzerkonten -> "Anderen Benutzern Zugriff auf diesen Computer geben" (ggf. mit Admin-Anmeldedaten bestätigen) -> "Hinzufügen" -> "Durchsuchen…" -> `{TUM-Kennung}` eingeben und "Namen überprüfen" -> OK -> weiter -> Frage nach Zugriffsebene: Unter "Andere" "Remotedesktopbenutzer" auswählen. Benutzer kann sich also per RDP anmelden.

+2. Bei erstmaliger Anmeldung des Benutzers wird das Verzeichnis `OSDisk (C:)/Benutzer/{TUM-Kennung}` angelegt. Für Zugriff auf Recom Grips nun die Verknüpfung dazu in `OSDisk (C:)/Benutzer/{TUM-Kennung}/Desktop` kopieren, damit der Benutzer sie gleich auf dem Desktop sieht.

+

+TO DO: Mit Bert und ggf. Gohl klären, ob das ein sinnvolles Multi-User-Setup ist. Wenn ja, Prozess automatisieren (insb. automatische Erstellung der Grips-Verknüpfung, damit da nicht auf den ersten Login gewartet werden muss).

+

+## Variante 2: Lokale Benutzer

+

+Wir können auch ADS-unabhängige Benutzerkonten anlegen, z. B. `Max Mustermann`, und dann die Login-Daten für solche lokalen "Avatare" den Studierenden für die Lehre weitergeben. Vorteile: Man kann die gleichen Avatare im nächsten Semester weiter benutzen, und man muss nicht nach Erstanmeldung der Studierenden noch die Verknüpfung zu Recom Grips bereitstellen sondern kann die Erstanmeldung ein mal selbst durchführen. Außerdem könnte man die gleichen Benutzer mit dem gleichen Passwort innerhalb von Recom Grips anlegen.

+

+# Recom Grips nutzen

+

+Im Zuge einer Schulung wurden die meisten TAT4.0/DigiLLab-Teammitglieder als Nutzer in Recom Grips angelegt. Passwort ist jeweils der Nachname.

+# Kurzfassung

+

+Da Recom keine Web-Oberfläche anbietet, sind parallele Zugriffe auf Recom Grips nur über parallele Remote Desktop Sessions auf dem Server `tueds09-recom.srv.mwn.de` möglich. Wir haben 25 Remote Desktop Lizenzen erworben und auf dem Server eingerichtet.

+

+# Konfiguration auf dem Server

+

+Dank Beratung durch das LRZ (Indicent Nr. 193572 von Joachim Siegert angelegt, Bert Krohn im cc) haben im Endeffekt folgende Schritte gefruchtet:

+1. https://learn.microsoft.com/en-us/troubleshoot/windows-server/remote/install-rds-host-role-service-without-connection-broker befolgen, einschließlich https://learn.microsoft.com/en-us/windows-server/remote/remote-desktop-services/rds-activate-license-server, wo ich in Schritt 7 von "Activate the License Server" allerdings den Wizzard genutzt habe (und die Aktivierungsnummer unserer Bestellung ohne Fehlermeldung angenommen wurde).

+2. "Remote Desktop Session Host" Rolle installieren

+3. In den Gruppenrichtlinien für den Remotedesktopsitzungs-Host den Lizenzierungsmodus von "Benutzer" auf "Gerät" umgestellt

+

+# Lizenzlage

+

+Sauber ist das nicht, denn wir haben User CALs gekauft, nicht Device CALs. Eigentlich müssten wir den Server also auf nutzerbasierte Lizenzierung umstellen, also nicht mit Lokalen Benutzern passend zu den Recom-Avataren ("Max Mustermann") arbeiten, sondern tatsächlich für jede Studierenden-Kohorte die ADS-Kennungen als Benutzer anlegen. Das ist entweder viel Klickarbeit für einen HiWi, dem man Admin-Rechte geben müsste, oder wir müssen uns eine geeignete Automatisierung überlegen. Die Frage ist aufgeschoben, bis tatsächlich mal die erste LV mit Recom läuft; auf Grundlage der Erfahrungen dort können wir uns das nochmal überlegen.

+

+Ob man die User CALs so lange nach Kauf gegen Device CALs umtauschen könnte, um sich diese Umstellung auf Nutzerbasierung zu sparen, ist unklar.

+Die Rechnung mit der siebenstelligen Vertragsnummer, die die Lizenzen identifiziert, liegt im Projektordner unter `TAT4_0/05_Organisation/02_DigiLLab/05_EPA/Recom/Microsoft\ Lizenzen/CCF_000354.pdf`

+### Grundidee: Fortsetzung des letzten Zustands

+

+In einem neuen Training wird die Montage in dem Zustand wieder aufgenommen, den das letzte Training hinterlassen hat. Am Ende eines Trainings muss jede Station ihren aktuellen Auftrag fertigstellen und in ihren Ausgang legen. Am Anfang eines neuen Trainings muss also lediglich der Logistiker ein mal rumgehen und schon sind alle Stationen mit Arbeit versorgt.

+

+

+### Im Vorfeld

+

+- [ ] Im DigiLLab prüfen, ob genügend Kisten im Startzustand vorhanden sind, d. h. Kisten im Eingangslager=rechter Logistikplatz (diese enthalten das Auto im Roh-Zustand). Falls nicht: Fertige Kisten in Startzustand zurücksetzen (siehe unten "Im Nachgang").

+- [ ] Stationen so verschieben, dass alle Monteure genug Platz zum Arbeiten haben.

+- [ ] Gedrucke Montage-Anleitungen an den Stationen auslegen.

+

+### Erste Runde: Papierbasierte Montage

+

+- [ ] Auf dem Meister-PC Firefox öffnen und das Lesezeichen "Odoo" anklicken. Odoo öffnet sich mit einer Ansicht der aktuellen Fertigungsaufträge.

+- [ ] Um Fertigungsaufträge hinzuzufügen: **a) Make to stock**: Oben links "Neu", dann als Produkt "Racer" eintippen und eine der gespeicherten Varianten auswählen, und oben links "Bestätigen". **b) Make to order:** Gleiches Vorgehen, anhand eines eingegangenen Auftrags (Brief, Email; TO DO Joachim: Beispiel-Bestellungen ausdrucken bzw. Email-Eingang simulieren)

+

+Die folgenden Schritte sind nur nötig, wenn zuletzt digital produziert wurde, was der Regelfall ist. Sollte ausnahmsweise zuletzt ohnehin schon papierbasiert produziert worden sein, dann liegen bereits überall Umlaufzettel bereit und die papierbasierte Fertigung kann direkt aufgenommen werden.

+

+- [ ] Umlaufzettel ausdrucken: Alle Fertigungsaufträge in Odoo auswählen, dann auf das Drucker-Symbol (mittig über der Auftragsliste) klicken, vierten Menüpunkt "Production Order mit Konfiguration" auswählen. Nach <1min Wartezeit wird eine mehrseitige PDF erzeugt. Diese ausdrucken (Papier dabei nur einseitig bedrucken).

+- [ ] Umlaufzettel verteilen: Odoo zeigt in der Spalte "current location" den letzten digital erfassten Standort an, was also dem anfänglichen Standort in der Papierrunde entspricht. Die Umlaufzettel der Aufträge, die schon an Stationen sind, in die entsprechenden Kisten legen. Die Umlaufzettel der Aufträge mit Standort "Lager" und Status "bestätigt" in beliebige Kisten des Eingangslagers legen. Sonderfall: Gibt es einen Auftrag mit Standort "Lager", der schon den Status "In Bearbeitung" hat, so muss dessen Umlaufzettel in diejenige Kiste gelegt werden, die für diesen Auftrag gescannt worden ist (zeigt die entsprechende Auftragsnummer auf e-Ink-Display an).

+- [ ] In Odoo die Spalte "current location" ausblenden durch Klick auf Schieberegler oben rechts in der Liste der Fertigungsaufträge und Entfernen des Hakens bei "current location", denn die dort angezeigten Informationen verlieren in der Papierrunde ihre Gültigkeit.

+- [ ] Einarbeitungsrunde: Alle Stationen einen Auftrag ohne Zeitangabe abarbeiten lassen, damit sich die Schulungsteilnehmer ein mal mit den Anleitungen und Montageschritten vertraut machen können, und Logistiker sowie Produktionsleiter einweisen. [Wie kommen Umlaufzettel vom Produktionsleitstand zum Eingangslager und vom Ausgangslager zum Leitstand? Macht das der Logistiker oder der Produktionsleiter?]

+- [ ] Produktion: Monteure ihre Arbeitszeiten mittels Stoppuhr erfassen lassen (To Do Joachim: bestellen). Ist ein Auftrag fertig montiert, so muss der Produktionsleiter die erfassten Zeiten eingeben, indem er den Auftrag in Odoo öffnet und dann im Reiter "Arbeitsaufträge" in der Spalte "tatsächliche Dauer" die Zeit einträgt. [TO DO: In Kopie der DB testen!]

+- [ ] Am Ende der Produktion: Alle Monteure ihren aktuellen Arbeitsschritt beenden und die Zeit notieren lassen.

+

+### Umstellung Papier -> digital

+

+- [ ] Stationen hochfahren und Server einschalten (vgl. Anleitung zu reinem digital-Ablauf)

+- [ ] Für die offenen Aufträge laut Logistik-Display in der Reihenfolge, in der sie angezeigt werden, erstens die zugehörige Kiste von der Station holen und einscannen, damit ihr dieser Auftrag zugewiesen wird, und wieder an die Station zurücktragen, und zweitens die Zeiten aus dem Umlaufzettel in Odoo abtippen damit der Fertigungsfortschritt erfasst ist

+- [ ] Dann Hochfahren der Produktion entsprechend Anleitung zu reinem digital-Ablauf

+

+

+

+### Im Nachgang

+

+Fertig montierte Autos sammeln sich im Ausgangslager (=linker Logistikplatz) an. Die e-Ink-Displays der Kisten dort zeigen dementsprechend "Produktion abgeschlossen" an. Um das Eingangslager wieder aufzufüllen:

+- [ ] Alle(!) Autos in den fertigen Kisten wieder demontieren.

+- [ ] "Steuerung öffnen" (wenn der Server nicht mehr läuft, muss er hierfür gestartet werden), "Erweitert" anklicken, "Alle fertigen Boxen zurücksetzen" anklicken. Alle Kisten, die bis dahin "Produktion abgeschlossen" angezeigt hatten, werden nun zurückgesetzt und können für neue Aufträge genutzt werden.

+- [ ] Alle Kisten ins Eingangslager (=rechter Logistikplatz) legen.

+

+Zuletzt den Server stoppen und den Strom an den Stationen mit der Fernbedienung, Taste A Off, abschalten.

+

+### Troubleshooting

+

+Wenn sich eine Station nicht verbindet oder es an einer Station ein Problem gibt, wie z. B. ein nicht verbundener RFID-Scanner (Scan einer Box verursacht nur Piepen, aber kein Update im Fertigungsfortschritt), dann das Stromkabel, das den Kleincomputer dieser Station versorg, ab- und anstecken um die Station neu zu starten.

+### Grundidee: Fortsetzung des letzten Zustands

+

+In einem neuen Training wird die Montage in dem Zustand wieder aufgenommen, den die letzte Nutzung hinterlassen hat. Am Anfang eines neuen Trainings sind also direkt alle Stationen mit Arbeit versorgt.

+

+| Achtung |

+| ------ |

+| Wenn Kisten für andere als Schulungszwecke bewegt werden (Fototermine o. ä.), dann nachher an die ursprüngliche Position zurückstellen; sonst divergieren physischer Zustand und digitaler Zustand. Wenn für Demo-Zwecke die Factory hochgefahren und Kisten gescannt werden, dann gilt wie in Schulungen (s. u.), dass an jeder Station alle Schritte zum laufenden Auftrag (Standort "Station X Desk") fertig gemeldet werden müssen bevor wieder heruntergefahren werden kann. |

+

+

+

+### Im Vorfeld

+

+- [ ] Im DigiLLab prüfen, ob genügend Bauteile an den Stationen und genügend Kisten im Startzustand vorhanden sind, d. h. Kisten im Eingangslager=rechter Logistikplatz (diese enthalten das Auto im Roh-Zustand). Falls nicht: Fertige Aufträge demontieren (siehe unten "Im Nachgang").

+- [ ] Vergewissern, dass die Kisten an der richtigen Stelle stehen: Im Stationseingang (=obere Rutsche) von Station Y dürfen nur Kisten stehen, deren e-Ink-Display den Transportauftrag X->Y anzeigt, und im Stationsausgang (=untere Rutsche) von Station Y dürfen nur Kisten stehen, deren e-Ink-Display den Transportauftrag Y->Z anzeigt.

+

+### Trainingsablauf

+- [ ] Stationen so verschieben, dass alle genug Platz zum Montieren haben.

+- [ ] Alle Stationen mit der Fernbedienung einschalten (Taste A). Es ertönten zwei Pieps pro Station (eines je RFID-Scanner). Mit den nächsten Schritten fortfahren, während die Stationen hochfahren (was ein paar Minuten dauern kann).

+- [ ] Falls der Server auf dem Meister-PC noch nicht läuft, mit der Verknüpfung "DigiLLab Factory Starten" auf dem Desktop starten und dann auf "Server starten/neustarten" klicken.

+

+- [ ] Auf dem Surface Hub im Browser zwei Seiten öffnen: Erstens `http://192.168.188.41:3030/dashbard.html` für das Dashboard (exakt so eingeben, insb. mit `http://`) und zweitens `https://odoo-mrp.erp.digit40.edu.sot.tum.de` für den Webshop.

+- [ ] Am Meister-PC auf "Odoo öffnen" klicken bzw. in Firefox das Lesezeichen "Odoo DigiLLab Factory" öffnen. Odoo öffnet sich mit einer Ansicht der aktuellen Fertigungsaufträge.

+- [ ] Um Fertigungsaufträge hinzuzufügen: **a) Make to stock**: Oben links "Neu", dann als Produkt "Racer" eintippen und eine der gespeicherten Varianten auswählen, und oben links "Bestätigen". **b) Make to order:** Bestellung(en) im Webshop [https://odoo-mrp.erp.digit40.edu.sot.tum.de](https://odoo-mrp.erp.digit40.edu.sot.tum.de) platzieren. Das kann man am Surface Hub im Webshop selber machen und/oder t von Schulungsteilnehmern machen lassen, indem man ihnen den Link als QR-Code gibt (liegt ausgedruckt am Meister-PC). Dann in Odoo ins "Verkauf"-Modul wechseln, dort das Angebot öffnen und "bestätigen", dann zurück ins "Fertigung"-Modul, wo nun automatisch ein entsprechender Fertigungsauftrag erzeugt worden ist. Dieser erscheint nun auch auf dem Logistik-Monitor in der Liste neuer Aufträge.

+- [ ] Das Lesezeichen "Steuerung" in neuem Tab öffnen und vergewissern, dass alle Stationen verbunden sind. Falls nicht, obwohl schon ein paar Minuten seit Einschalten vergangen sind, siehe hier unten "Troubleshooting".

+- [ ] Einarbeitungsrunde: Allen Schulungsteilnehmern die Aufgaben des Logistikers erklären sodass bekannt ist, wo Ein- und Ausgang der Stationen sind und wie die Kisten zu scannen sind. Im Zuge dieser Einarbeitung ggf. so viele Kisten bewegen wie nötig, damit in jedem Stationseingang etwas liegt. Nun an allen Stationen einen Auftrag abarbeiten lassen, damit sich die Monteure ein mal mit den Anleitungen und Montageschritten vertraut machen können. Nach Abschluss ihres ersten Auftrags sollen alle Monteure warten (noch keine neue Kiste scannen).

+- [ ] Schicht starten: In Odoo -> Fertigung unter "Production Cycles" (oben drittes von links) einen Produktionszyklus erstellen und benennen.

+- [ ] Den Production Cycle mit Klick auf den grünen Button "Start" rechts in seiner Zeile starten. Ab jetzt gehen die Zeiten in die Statistiken und die Ablaufanzeige auf dem Dashboard ein. Lesezeichen "Dashboard" öffnen um dieses anzuzeigen bzw. auf dem Surface Hub zeigen.

+- [ ] Am Ende der Produktion: den Production Cycle in Odoo beenden und alle Monteure ihre aktuelle Kiste vollständig bearbeiten, fertig melden und in den Stationsausgang legen lassen.

+

+

+| Achtung |

+| ------ |

+| Am Schulungsende müssen alle Arbeitsschritte des aktuellen Auftrags an jeder Station fertig gemeldet und die Kiste danach in den Ausgang gelegt werden; andernfalls kann die nächste Schulungsgruppe die Produktion möglicherweise nicht richtig aufnehmen. Aus Zeitgründen kann notfalls auf die tatsächliche Ausführung der Schritte verzichtet werden, aber der Klick auf "fertig" für jeden Schritt ist unbedingt nötig, damit die nächste Gruppe an den Stationen jeweils von vorne starten kann. |

+

+### Im Nachgang

+

+Fertig montierte Autos sammeln sich im Ausgangslager (=linker Logistikplatz) an. Die e-Ink-Displays der Kisten dort zeigen dementsprechend "Produktion abgeschlossen" an. Um das Eingangslager wieder aufzufüllen:

+- [ ] Alle(!) Autos in den fertigen Kisten wieder demontieren.

+- [ ] "Steuerung öffnen" (wenn der Server nicht mehr läuft, muss er hierfür gestartet werden) und "Alle fertigen Boxen zurücksetzen" anklicken. Alle Kisten, die bis dahin "Produktion abgeschlossen" angezeigt hatten, werden nun zurückgesetzt und können für neue Aufträge genutzt werden.

+- [ ] Alle Kisten ins Eingangslager (=rechter Logistikplatz) legen.

+

+Zuletzt den Server stoppen und den Strom an den Stationen mit der Fernbedienung, Taste A Off, abschalten. Den Meister-PC laufen lassen, damit der für Fernzugriffe verfügbar bleibt.

+

+### Troubleshooting

+

+Wenn sich eine Station nicht verbindet:

+1. Vergewissern, dass sie Strom hat (Fernbedienung vor die Funksteckdose der Station halten und Taste A on drücken; rote Kontrollleuchte an Funksteckdose muss leuchten).

+2. Vergewissern, dass der Monitor an ist.

+3. Ggf. den Kleincomputer dieser Station ab- und anstecken um die Station neu zu starten. (Stromkabel steckt in Funksteckdose.)

+

+

+Wenn der Scan einer Kiste an einem Montage-Tisch nicht wie erwartet den Montage-Schritt startet (Anleitung anzeigt):

+1. E-Ink Display der Kiste prüfen um sicherzugehen, dass die Kiste an diese Station gehört. Mögliche Fehlerquellen: Logistiker hat die Kiste nicht am Eingangslager gescannt, sodass sie überhaupt keinem Auftrag zugeordnet ist, oder die Kiste steht im Ein- statt Ausangslager der Station (vgl. oben "im Vorfeld")

+2. Ggf. Neustart der Station durch ab- und anstecken des Stromkabels des Kleincomputers (steckt in weißer Funksteckdose).

+3. Vergewissern, dass die Positionen aller Kisten tatsächlich den Positionen gemäß Odoo entsprechen. Insbesondere vergewissern, dass kein Auftrag den Standort "Station X Desk" anzeigt, der dort gar nicht tatsächlich in Arbeit ist. Wenn es eine Abweichung gibt, dann den Fertigungsschritt des fraglichen Fertigungsauftrag händisch in Odoo als abgeschlossen melden.

+

+## Infos für Entwickler

+

+Der zentrale Websocket Server für die Odoo Factory läuft auf dem Meister-Arbeitsplatz PC. Alle Raspis im lokalen Netz verbinden sich mit diesem über `tuedfed-dl01.fritz.box:3030` bzw. `192.168.188.41:3030`. Um die Bedienung so einfach wie möglich zu machen gibt es eine kleine graphische Anwendung (`windows.py`), mit der man den Server auf dem Meister-PC starten kann:

+

+

+

+Der Ordner links enthält das Verzeichnis `Lokaler-Server` aus dem Repo, sowie ein virtualenv (Einrichtung siehe unten). Rechts ist eine Verknüpfung, die `Lokaler-Server\windows.py` aufruft:

+

+

+

+Das Fenster im Hintergrund zeigt den Log und eventuelle Fehlermeldungen. Mit dem Fenster im Vordergrund kann man Odoo oder das Control Panel im Browser öffnen und den Server im Hintergrund starten/stoppen. Der Server wird nicht automatisch gestartet, wenn man das Fenster öffnet, das heißt man muss ihn einmal am Anfang starten. Wenn der Server und alle Raspis laufen und verbunden sind, ist die Odoo Factory einsatzbereit.

+

+Verbindungsprobleme können leider manchmal auftreten, wenn Router und Raspis falsch zueinander stehen.

+

+### Production Cycle

+Für die Statistiken gibt es in Odoo Produktionszyklen (Manufacturing->Production Cycles), mit denen man einen Referenzzeitraum für die Produktion vorgibt. Das Dashboard zeigt immer den aktuell laufenden Produktionszyklus, oder den als letztes beendeten, bei dem "show after finish" in Odoo gesetzt ist.

+

+### Dashboard

+Auf dem Surface Hub ist das Dashboard unter `tuedfed-dl01.fritz.box:3030/dashboard.html` erreichbar. Prinzipiell kann man das Dashboard auch auf anderen Geräten öffnen, es ist aber vom Layout auf das Surface Hub angepasst (evtl. hilft zoomen). Die Metriken der aktuellen Produktion werden alle 10s geupdatet, der Workorder Plan alle 20s. Die Updates werden nur gemacht, wenn das Dashboard offen ist, weil sie vom Dashboard initiiert werden.

+

+### Stationen sperren

+Über das Control Panel lassen sich alle Station sperren. Die Bildschirme zeigen dann nur den Namen der Station und den Verbindungsstatus an (Praktisch wird ein Overlay angezeigt, das heißt noch offene Workorder laufen weiter). Scans an den RFID Scannern haben dann keinen Effekt mehr.

+

+In der Praxis ist das auch ein praktischer Test, ob alle Station noch verbunden sind. Der Status im Control Panel updatet sich nicht sofort, sondern erst nach einem Timeout.

+

+# Einrichtung

+### Venv

+Der Server läuft mit Python, das mit dem offiziellen Installer auf dem Meister-PC installiert ist. Das Programm ist auf dem Desktop unter `DigiLLab-Factory\Lokaler-Server\` abgelegt. Das venv lässt sich mit der Power Shell einrichten mit:

+```powershell

+# Im Ordner "DigiLLab-Factory":

+py.exe -m venv .\venv

+.\venv\Scripts\pip.exe install -r .\Lokaler-Server\requirements.txt

+```

+Nur der Server selbst (`server.py`) verwendet und braucht das venv, das GUI Programm `windows.py` nicht.

+

+### Konfiguration

+Die Konfiguration des Server liegt in `DigiLLab-Factory\Lokaler-Server\server-config.ini` auf dem Desktop. Möchte man eigene Anleitungen den Arbeitsstationen zur Verfügung stellen, kann man die in `DigiLLab-Factory\Lokaler-Server\web` ablegen. Die URLs in der Odoo Einstellung dazu sind immer relativ zu diesem Verzeichnis. Wichtig ist, dass PDFs immer im Unterordner `pdf` und MP4 Videos im Unterordner `mp4` abgelegt werden, weil der relative einfache statische Server von socketio nur so den richtigen Content-Type gibt. Die Content-Types sind in `server.py` eingerichtet.

+Eine flexiblere Lösung wäre ein richtiger Webserver, der dann aber ein passenden CORS Header braucht (die erlaubte Quelle muss `tuedfed-dl01.fritz.box` sein). Sofern CORS eingerichtet ist, können in Odoo zu den Anleitungen auch vollständige URLs (http://...) eingegeben werden.

+

+### Firewall

+Damit man vom lokalen Netzwerk aus den Server auf Port 3030 erreichen kann, muss man in Windows eine Firewall Regel einrichten:

+

+## Zweck

+

+Der USB-Drucker sollte sowohl vom Host-Betriebssystem als auch von der SLF-VM aus erreichbar sein, damit es egal ist, in welchem Kontext Druckbefehle gegeben werden (insb. für die Startaufträge in der papierbasierten Runde).

+

+## Gewähltes Vorgehen

+Damit der Drucker auch von der VM aus angesprochen werden kann, hat JS entsprechend [dieser Anleitung](https://docs.microsoft.com/en-us/troubleshoot/windows-server/remote/printer-redirection-not-work) zuerst den aktuellen Security Descriptor des Print Spoolers anzeigen lassen:

+

+```

+sc sdshow spooler

+```

+Der Output war genau wie in der Anleitung

+```

+D:(A;;CCLCSWLOCRRC;;;AU)(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;BA)(A;;CCLCSWRPWPDTLOCRRC;;;SY)

+```

+Dem war nochmal der Block `(A;;CCLCSWLOCRRC;;;AU)` hinzuzufügen, also mit folgendem Befehl zu setzen (ggf. anzupassen, wenn obiger Output anders aussieht):

+```

+sc sdset spooler D:(A;;CCLCSWLOCRRC;;;AU)(A;;CCLCSWLOCRRC;;;AU)(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;BA)(A;;CCLCSWRPWPDTLOCRRC;;;SY)

+```

+Dieser Befehl musste als Admin ausgeführt werden, also in das Suchfenster von Windows eingegeben werden und dann die Option "Als Administrator ausführen" angeklickt werden.

+

+## Alternativen

+Mit einem Netzwerkdrucker sollten keine derartigen Anpassungen vonnöten sein, da die VM ja normalen Netzwerkzugriff hat. Falls USB also hartnäckig Probleme macht, sollten wir einfach ein Netzwerkkabel in den Drucker stecken.

+Hier werden Fragen für die Beratung gesammelt. Alternativ kann auch einfach das Label ["Beratungsfrage"](https://gitlab.lrz.de/teachtum40/industrie4.0/-/boards?label_name[]=Beratungsfrage) bei Issues gesetzt werden, für die die Beratung herangezogen werden sollte. Die Reihenfolge der Auflistung entspricht der Priorisierung.

+

+# Prio 1) Fragen zur Benutzung von Odoo

+

+@all bitte hier eure Fragen reinschreiben

+- **Buchhaltungs-Modul**: Was ist zu tun, um Buchhaltung in Odoo CE zu ermöglichen? Laut Gespräch mit much.consulting am 08.12.2022 gibt es dafür ein geeignetes Modul, das von der Community gepflegt wird (Buchhaltung inkl. Personalkostenplanung, aber ohne rechtssichere Lohnabrechnung, was für unsere Zwecke ja auch völlig egal ist)

+- **Fertigungsstraße mit Odoo MRP Modul betreiben**: Wie gut würde sich unsere Fertigungsstraße (vier Montagestationen + Qualitätssicherung, die i.d.R. der Reihe nach durchlaufen werden) im Odoo-Fertigungsmodul abbilden lassen? Hab gesehen dass man Anleitungen bereitstellen und verschiedene "Assembly lines" definieren kann, aber wir haben ja vielmehr die Situation, dass Aufträge nicht parallel auf Stationen verteilt werden, sondern seriell durch eine Folge von Stationen abgearbeitet werden.

+- **Trends**: Kann Odoo Trends abbilden bzw. Forecasts ausgeben? Ist eine KI Anbindung hier möglich?

+

+

+# Prio 2) Fragen zur Entwicklung von Odoo

+

+- **Standardworkflow in MRP Modul, und überhaupt Dokumentation**: Die [SLF-Odoo-Schnittstelle](https://gitlab.lrz.de/teachtum40/industrie4.0/-/blob/main/Odoo-SLF-Verbindung/slf_to_odoo.py) löst je nach Fertigungsfortschritt in unserer Montagestraße Odoo-Funktionen aus, um den Durchlauf eines Fertigungsauftrags von Bestätigung bis Abschluss abzubilden. Diese Funktionen habe ich ermittelt, indem ich den Standardworkflow in Odoo durchgeklickt und dabei die Debugging-Konsole im Blick behalten habe (und dann natürlich getestet). Ist das der übliche Weg, die Funktionsweise eines Odoo-Moduls nachzuvollziehen, oder gibt es irgendwo noch eine Modul-spezifische Entwicklerdokumentation?

+- **Beispieldaten/Zurücksetzen auf Startzustand**: Wir wollen unsere Datenbank(en) immer wieder in einen gewissen Startzustand zurückversetzen können. Was ist grundsätzlich der stabilere Weg? Eher von Hand eine DB erstellen und als .zip ablegen, oder eher Skripte schreiben und in ein Addon-Modul packen, das unsere Daten in die DB schreibt? Wie läuft das eigentlich mit den Möbelladen-Beispieldaten?

+- **Custom JavaScript**: Wir haben als Beispiel für die Personalisierung in Webshops ein sehr kurzes Skript, das eine teurere Konfiguration des Autos auswählt, wenn die Seite mit einem Apple-Gerät (insb. iPhone) aufgerufen wird (#21 ). Wo würde man dies Skript innerhalb von Odoo am besten hinpacken (siehe Kommentare in der Issue)?

+- **Varianten-Kombinatorik**: Die Auswahlmöglichkeiten bei der Konfiguration des Autos, das der Webshop anbietet, ergeben ca. 27.000 Varianten. Via GUI kann man so viele Varianten nicht statisch in Odoo anlegen. Und wenn man doch alle 27k Varianten haben will, anstatt kleinere Variantenzahl statisch oder alle Varianten dynamisch zu generieren (Vgl. #25 und #7 )? Geht Postgres dann in die Knie, oder muss man bloß irgendwo ein Limit hochsetzen und dann ein mal ein bisschen Geduld mitbringen?

+- **Odoo auf Raspberry Pi**: Welche Konfiguration ist geeignet? Joachim hat aktuell Raspberry Lite 32-bit laufen. Hintergründe: much.consulting hatte erwähnt, dass man (bis zu gewisser Anzahl zeitgleicher Nutzer) mit dem Raspi zurechtkommt. Das kann nützlich sein für 1) Entwicklung ohne VM, 2) Transfer an Schulen, insb. portables Industrie-Szenario, 3) Kostenneutraler Betrieb über Projektende hinaus (ein Raspi als Odoo-Server im MWN und fertig)

+- **Speicherung von Bildern**: Nur so aus Neugierde: Kommen die Bilder, die man für eine Webseite und Produkte hochlädt, als Blobs in die zugehörige DB?

+# Zweck

+

+Nachvollziehbar machen, welche Handlungen in der SLF mit welchen Änderungen in der SLF-Datenbank korrespondieren. Auf Grundlage dieser Erkenntnisse wird es vielleicht möglich, weitere Kennzahlen zu generieren, die die Datenbank nicht direkt ausgibt.

+

+# Konfiguration

+

+Die Datei ```C:\Program Files\PostgreSQL\13\data\postgresql.conf``` auf der VM ist wie in [https://stackoverflow.com/questions/722221/how-to-log-postgresql-queries](https://stackoverflow.com/questions/722221/how-to-log-postgresql-queries) beschrieben verändert, außer dass

+```

+log_statement = 'mod'

+```

+gesetzt ist um das richtige Logging-Level zu erhalten.

+Das Log liegt in ```C:\Program Files\PostgreSQL\13\data\log\...```

+

+Um nur eine spezifische Datenbank zu loggen, kann man das log_statement oben auf `none` setzen, und stattdessen mit pgAdmin über das Query Tool (Button direkt unter "Tools" ganz oben) folgendes eingeben:

+

+```sql

+ALTER DATABASE slf

+SET log_statement = 'mod';

+```

+

+# PostgreSQL neustarten

+1. Eingabeaufforderung als Admin starten (danach suchen und dann Rechtsklick)

+2. `services.msc` eingeben, und dann Enter

+3. In der Liste `postgresql-13` suchen, und mit Rechtsklick neustarten

+- [ ] Um Fertigungsaufträge hinzuzufügen: **a) Make to stock**: Oben links "Neu", dann als Produkt "Racer" eintippen und eine der gespeicherten Varianten auswählen, und oben links "Bestätigen". **b) Make to order:** Bestellung(en) im Webshop [https://odoo-mrp.erp.digit40.edu.sot.tum.de](https://odoo-mrp.erp.digit40.edu.sot.tum.de) platzieren (das kann auch gut von Schulungsteilnehmern gemacht werden; den Link am besten als QR-Code bereitstellen). Dann in Odoo ins "Verkauf"-Modul wechseln, dort das Angebot öffnen und "bestätigen", dann zurück ins "Fertigung"-Modul, wo nun automatisch ein entsprechender Fertigungsauftrag erzeugt worden ist. Dieser erscheint nun auch auf dem Logistik-Monitor in der Liste neuer Aufträge.

+- [ ] Produktion: Unter "Production Cycles" (oben drittes von links) einen Produktionszyklus erstellen und benennen.

+- [ ] Den Production Cycle in Odoo starten. Ab jetzt gehen die Zeiten in die Statistiken und die Ablaufanzeige auf dem Dashboard ein.

+- [ ] Am Ende der Produktion: den Production Cycle in Odoo beenden und alle Monteure ihren aktuellen Auftrag vollständig bearbeiten und dann in den Stationsausgang legen lassen. **Achtung**: nicht einfach inmitten eines Auftrags die Schraubendreher fallen lassen und die Fabrik herunterfahren, denn dann findet sich die nächste Gruppe, die die Fertigung wieder aufnimmt, nicht zurecht.

+Die Konfiguration (Motor, Stoßdämpfer usw.) eines Fertigungsauftrags für ein Modellauto ergibt sich wie folgt:

+

+Jeder Fertigungsauftrag der Tabelle `mrp_production` hat eine `product_id` die auf `product_product` verweist, und die Tabelle `product_product` hat eine Spalte `combination_indices`, die einen String der Konfiguration enthält, z. B. `40,41,46,47,49,51,54,57,60`.

+

+Diese Indices entsprechen den IDs von

+```

+select product_template_attribute_value.id, product_attribute_value.attribute_id, product_attribute_value.name from product_template_attribute_value join product_attribute_value on product_template_attribute_value.product_attribute_value_id=product_attribute_value.id;

+```

+also zum Beispiel für den Motor

+

+| id | attribute_id | name |

+| ------ | ------ | ------ |

+| 38 | 6 | {"de_DE": "193kW", "en_US": "193kW"} |

+| 39 | 6 | {"de_DE": "245kW", "en_US": "245kW"} |

+| 40 | 6 | {"de_DE": "615kW", "en_US": "615kW"} |

+

+d. h. die 40 in obigen `combination_indices` bedeutet, dass der 615kW-Motor gewählt wurde.

+

+Mit `select id,name from product_attribute;` gibt's den Text zu obiger `attribute_id` (und es gäbe alles auf einmal, wenn man einen doppelten `join` syntaxfehlerfrei hinbekäme).

+# Installation

+## a) Zum schnellen Ausprobieren

+

+Raspberry Pi OS (32-bit) auf SD-Karte schreiben. Installation gemäß [Doku für Odoo 16-Installation auf Debian/Ubuntu](https://www.odoo.com/documentation/16.0/administration/install/install.html). Erstmal Postgres:

+```

+sudo apt install postgresql

+```

+Dann das Odoo-Repository:

+```

+wget -q -O - https://nightly.odoo.com/odoo.key | sudo gpg --dearmor -o /usr/share/keyrings/odoo-archive-keyring.gpg

+echo 'deb [signed-by=/usr/share/keyrings/odoo-archive-keyring.gpg] https://nightly.odoo.com/16.0/nightly/deb/ ./' | sudo tee /etc/apt/sources.list.d/odoo.list

+sudo apt-get update && sudo apt-get install odoo

+```

+Und jetzt im Browser `localhost:8069` öffnen und loslegen.

+

+## b) Zum Entwickeln

+

+Wie in Kapitel 2 von [Odoo 15 Development Essentials](https://www.oreilly.com/library/view/odoo-15-development/9781800200067/) S. 46-50 beschrieben vorgehen, d. h. Odoo **nicht** über apt installieren, sondern git-Verzeichnis klonen und virtuelle Python-Umgebung erstellen.

+Ist alles installiert, startet man mit `odoo` die Instanz und kann dann im lokalen Netzwerk über `{IP des Raspi}:8069` die GUI aufrufen.

+

+## wkhtmltopdf installieren

+

+Damit PDFs, also z. B. Rechnungen, erstellt werden können, muss wkhtmltopdf installiert werden. Das ist nicht teil der Standard-Paketquellen, man muss also die [passenden präkombilierten Binaries](https://wkhtmltopdf.org/downloads.html) herunterladen. Für Raspberry Pi bedeutete das zuletzt:

+```

+wget https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.raspberrypi.bullseye_armhf.deb

+sudo apt install ./wkhtmltox_0.12.6.1-2.raspberrypi.bullseye_armhf.deb

+```

+

+

+## pgadmin zur Postgres-Entwicklung

+

+Um nicht an der Kommandozeilen-Eingabe von Funktionen in Postgres zu verzweifeln, empfiehlt sich die Verwendung von pgadmin. Auf dem Raspi selbst läuft pgadmin4 mangels arm-Unterstützung nicht, also: pgadmin4 von anderem Computer aus verwenden mit SSL-Tunneling, siehe [Postgres: lokaler und remote Zugriff](https://gitlab.lrz.de/teachtum40/industrie4.0/-/wikis/Postgres:-lokaler-und-remote-Zugriff).

+

+

+# Entwicklung

+

+## Häufige Befehle

+

+Python-Umgebung aktivieren:

+```

+source ~/odoo-entwicklung/py_env/bin/activate

+```

+Odoo so starten, dass bei Quellcode-Änderungen sofort neugestartet wird:

+```

+odoo --dev=reload

+```

+

+Odoo mit eigenem Addons-Verzeichnis starten, z. B. dasjenige für die Bücherei-App (vgl. Buch):

+```

+odoo --addons-path="~/odoo-16-playground/odoo/addons, ~/odoo-16-playground/library"

+```

+Direkt mit der Bücherei-App installiert (entsprechende .conf vorausgesetzt):

+```

+odoo -c ~/odoo-16-playground/library/library_app/library.conf -d library -i \

+library_app

+```

+Bei Entwicklung unterwegs am Handy-Hotspot: Beachten, dass selten die gleiche IP an den Raspi vergeben wird. Das muss bei SSL-Tunneling in pgAdmin berücksichtigt werden (vgl. Kommentare in pgAdmin auf Macbook).

+# Vorbereitungen

+

+## Odoo kontrollieren

+

+Auf https://erp-test.oct.re sollte Odoo unter Verwendung der Datenbank `schnittstelle-erste-iteration` erreichbar sein. Kontrolle durch Blick auf https://erp-test.oct.re/web/database/manager. (Die Datenbank ist auf `tuedfed-tat40web.srv.mwn.de` in `/etc/odoo/odoo.conf` festgelegt, und mit dieser Config startet der Service).

+Die DB sollte in einem Zustand sein, wo

+- Der Racer in der einfachsten Variante über Stückliste, Arbeitsauftrag und automatische Aufstockung verfügt

+- Vom Racer in der einfachsten Variante kein Exemplar vorrätig bzw. als bald vorrätig prognostiziert ist (zum Beispiel aus make-to-stock Aufträgen, die man im Fertigungsmodul erteilt hat)

+- Von den Einzelteilen der Stückliste genügend vorhanden ist (also nicht alles durch Rumspielen im Fertigungsmodul verbraucht)

+- Max Mustermann als Kunde existiert

+

+## Skripte starten

+

+Auf `tuedfed-tat40web.srv.mwn.de` die Skripte starten, und zwar am besten in zwei sichtbaren Fenstern um etwaige Fehlermeldungen sofort mitzukriegen.

+```

+python3 /home/joachim/industrie4.0/Odoo-SLF-Verbindung/slf_to_odoo.py

+```

+```

+python3 /home/joachim/industrie4.0/Odoo-SLF-Verbindung/odoo_to_slf.py

+```

+

+## SLF zurücksetzen

+Im Trainer Interface zurücksetzen, falls noch eine Produktion vorbereitet ist: http://10.162.111.159:8080/

+Dadurch wird das aktuelle Szenario beendet und mit ihm alle zwischenzeitlich über die Schnittstelle geschickten Aufträge weggeräumt

+

+## Browser-Fenster vorbereiten

+

+Entweder mit Admin-Konto alles machen, oder zwei getrennte Sessions (Inkognito-Fenster, mit dem Surface in Edge erst mal testen ob Tabs reichen) mit Max Mustermann zum Bestellen und Admin zur Weiterverarbeitung

+

+## Falls nicht vor Ort: pgAdmin für SLF-DB starten

+

+Nur nötig für virtuelle Demo, d. h. wenn man nicht vor Ort die Kisten durchschieben kann um den Fertigungsstatus zu verändern. Auf Workstation (Host, nicht VM) mit Benutzer `DigiLLab` pgAdmin öffnen.

+

+# Durchführen

+

+## SLF vorbereiten und sichtbar machen

+

+- Im Trainer Interface Produktion vorbereiten: http://10.162.111.159:8080/

+- Dashboard öffnen: http://10.162.111.159:3000/d/zaRwSgS7k/lab-main-dashboard?orgId=1&refresh=1s&kiosk&var-plant_id=3 und dort zur Auftragsliste scrollen

+

+

+## a) Make to Stock

+

+1. Odoo öffnen https://erp-test.oct.re (damit die hübsche Webseite zumindest kurz sichtbar ist)

+2. Modul "Manufacturing" öffnen

+3. "Create"

+4. Bei "Product" "Racer" eingeben und ersten Vorschlag (ist die einfachste Produktvariante) anklicken. Der Name der zugehörigen Stückliste erscheint in "Bill of Material", und diese legt auch ein Work Order fest, ohne das der ganze Workflow nicht geht (Skript versucht, Work Order zu starten; ohne BOM/Work Order kann kein Materialverbrauch berechnet werden und dann müsste man Dialoge durchklicken, was nicht per API geht)

+5. "Confirm"

+6. Im SLF-Dashboard zeigen, dass der entsprechende neue Fertigungsauftrag angelegt worden ist mit Status "Ready" (und Auftragsnummer `PO-IND-XXXX` für SQL-Update notieren)

+7. Falls vor Ort: Produktion starten und Auftrag durchs Eingangslager ziehen. Falls remote oder wenig Zeit: In pgadmin den SLF-Status eins weiter setzen durch `update production_order set state='Running' where name='PO-IND-XXXX';`

+8. Im SLF-Dashboard auf neuen "Status" hinweisen und Seite in Odoo neu laden und auf Zustand "In Progress" hinweisen; ggf. zusätzlich Reiter "Work Orders" öffnen

+9. Falls vor Ort: Produktion durch alle Stationen ziehen bis fertig. Falls remote oder wenig Zeit: In pgadmin den SLF-Status eins weiter setzen durch `update production_order set state='Completed' where name='PO-IND-XXXX';`

+10. Im SLF-Dashboard auf neuen "Status" hinweisen und Seite in Odoo neu laden und auf Zustand "To Close" hinweisen; runterscrollen um die Einträge von SLF-Odoo-Interface im Log anzuzeigen.

+11. Wenn unvermeidbar: Auf "Mark as done" und mit der Fehlermeldung leben

+

+## b) Make to Order

+

+1. Kundensicht: Odoo öffnen https://erp-test.oct.re

+1. Bestellung aufgeben für billigsten Racer (gemäß Default, also jede Auswahl ganz links lassen)

+1. Mitarbeitersicht: Odoo mit Admin-Konto öffnen

+1. Den gerade erteilten Auftrag von Max Mustermann öffnen, vergewissern dass prognostizierte verfügbare Menge null ist (rotes Symbol) und bestätigen

+2. Modul "Manufacturing" öffnen, dort zeigen unter welchem Namen `WH/MO/...` der zugehörige Fertigungsauftrag angelegt wurde, und hinweisen auf die Quelle "Replenishment Report"

+6. Im SLF-Dashboard zeigen, dass der entsprechende neue Fertigungsauftrag angelegt worden ist mit Status "Ready".

+7. Falls vor Ort: Produktion starten und Auftrag durchs Eingangslager ziehen. Falls remote oder wenig Zeit: In pgadmin den SLF-Status eins weiter setzen durch `update production_order set state='Running' where name='PO-IND-XXXX';`

+8. Im SLF-Dashboard auf neuen "Status" hinweisen ("Paused) und Seite in Odoo neu laden und auf Zustand "In Progress" hinweisen; ggf. zusätzlich Reiter "Work Orders" öffnen

+9. Falls vor Ort: Produktion durch alle Stationen ziehen bis fertig (dabei zeigen, dass die richtige Konfiguration übermittelt wurde). Falls remote oder wenig Zeit: In pgadmin den SLF-Status eins weiter setzen durch `update production_order set state='Completed' where name='PO-IND-XXXX';` (die Richtigkeit der Konfiguration kann im MES gezeigt werden)

+10. Im SLF-Dashboard auf neuen "Status" hinweisen und in Odoo Seite des MO öffnen bzw. Seite des MO neu laden (Obacht: nicht Listenansicht neu laden, dann verschwindet das wegen "To Do"-Filter) und auf Zustand "Done" hinweisen; runterscrollen um die Einträge von SLF-Odoo-Interface im Log anzuzeigen.

+# Kurzfassung

+

+Das Standard-Accounting-Modul der Community Edition hat einen zu kleinen Funktionsumfang. Odoo selbst will damit einen Anreiz zum Kauf der Enterprise Edition setzen. Es gibt aber ein von der Community geschriebenes Accounting-Modul für Odoo CE mit ausreichendem Funktionsumfang.

+

+# Installation

+

+Ausgangspunkt: https://apps.odoo.com/apps/modules/16.0/om_account_accountant/

+Damit das Modul richtig geladen wird mussten (Stand August 2023) die heruntergeladenen Module (es handelt sich um ein ganzes Rudel, von denen das Hauptmodul abhängt) so in die Verzeichnis-Struktur von Odoo bewegt werden, dass diese Addons sowie das Hauptmodul tatsächlich von Odoo gefunden werden.

+

+1. https://apps.odoo.com/apps/modules/16.0/om_account_accountant/ öffnen

+2. "Download for v 16.0" anklicken

+3. Das heruntergeladene zip-Verzeichnis entpacken

+4. Alle Ordner innerhalb des Verzeichnisses (also "accounting_pdf_reports" bis "om_recurring_payments") in ein Addons-Verzeichnis dieser Odoo-Instanz verschieben (die Verzeichnisse sind in der `odoo.conf` angegeben). Alternative: Das entpackte zip-Verzeichnis als weiteren Addons-Path in der `odoo.conf` angeben bzw. in Entwicklungs-Umgebung als Kommandozeilen-Parameter mitgeben. Jedenfalls müssen die einzelnen Module direkte Kinder eines Addons-Verzeichnisses sein, und nicht in einem Ordner innerhalb eines Addons-Verzeichnisses rumliegen. Falls man sich in einer Entwicklungs-Umgebung nicht sicher ist, wo Odoo nach Addons guckt: `odoo --stop` startet und stoppt Odoo, wobei es ein mal die aktuellen Einstellungen ausgibt.

+5. In Odoo: Entwickler-Modus aktivieren (z. B. ?debug=1 in die URL hauen) und dann erscheint im "Apps"-Menü der Punkt "App-Liste aktualisieren". Den anklicken.

+6. Nun ist das Modul "om_account_accountant" auffindbar. Aktivieren!

+# Installation

+Auf unserem Server `tuedfed-tat40web.srv.mwn.de` wurde Odoo nach der [offiziellen Anleitung](https://www.odoo.com/documentation/16.0/administration/install/install.html) von Odoo unter Ubuntu installiert.

+

+Odoo verwendet als Datenbank Postgres. Das muss also zuerst installiert werden:

+```bash

+sudo apt install postgresql -y

+```

+

+Odoo richtet bei der Installation über die Paketquellen (siehe unten) automatisch einen Benutzer `odoo` in Linux und Postgres ein. Für Zugriff auf Postgres siehe auch die Seite zu [Postgres Zugriff](https://gitlab.lrz.de/teachtum40/industrie4.0/-/wikis/Postgres:-lokaler-und-remote-Zugriff).

+

+Eine weitere Abhängigkeit, die man von Hand vorher installieren muss ist `wkhtmltopdf`. Nachdem die Installation über die Standard Ubuntu Paketquellen nicht funktioniert hat, wurde es manuell installiert.

+```bash

+wget https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6-1/wkhtmltox_0.12.6-1.focal_amd64.deb

+apt install ./wkhtmltox_0.12.6-1.focal_amd64.deb

+# Test:

+#wkhtmltopdf

+```

+

+Odoo selbst ist nicht Teil von den Ubuntu Paketquellen. Daher muss man es zuerst als Repo Quelle hinzufügen und kann es dann aber gewohnt mit apt installieren.

+```bash

+# Odoo hat ein eigenes Paket Repo. Dazu muss man den deren Key als vertrauenswürdig hinzufügen

+wget -q -O - https://nightly.odoo.com/odoo.key | sudo gpg --dearmor -o /usr/share/keyrings/odoo-archive-keyring.gpg

+# Dann das Repo hinzufügen

+echo 'deb [signed-by=/usr/share/keyrings/odoo-archive-keyring.gpg] https://nightly.odoo.com/16.0/nightly/deb/ ./' | sudo tee /etc/apt/sources.list.d/odoo.list

+# Und abschließend Paketlisten aktualisieren und Odoo installieren

+sudo apt-get update && sudo apt-get install odoo

+```

+

+# Konfiguration

+Details zur Standard-Konfiguration von Odoo finden sich in der [Dokumentation von Odoo](https://www.odoo.com/documentation/16.0/administration/install/deploy.html). Unsere Installation unterscheidet sich dahingehend von Standard-Installationen, dass wir verschiedene Datenbanken über verschiedene Subdomains erreichbar machen, damit verschiedene Nutzer(-gruppen) unabhängig voneinander arbeiten können. Folgende Änderungen gegenüber den Standards sind dafür nötig:

+- *dbfilter* ist eine Funktion, wie eine Odoo Instanz mit getrennten Datenbanken von mehrere "Kunden" unabhängig verwendet werden kann. Der aktuelle Filter `^%d.*$` bewirkt, dass über eine gegebene Subdomain nur Datenbanken erreichbar sind, deren Name mit dem Namen der Subdomain beginnt (oder einfach übereinstimmt). Beispielsweise sind die Datenbanken `startzustand-ohne-webshop` und `startzustand-mit-webshop` über [startzustand.usw](https://starzustand.erp.digit40.edu.sot.tum.de) erreichbar und `dobhan` über [dobhan.usw](https://dobhan.erp.digit40.edu.sot.tum.de).

+- *db_maxconn* ist ein Parameter, mit dem die Anzahl der Verbindungen von Odoo zu Postgres begrenzt werden kann. Bei einem Multi-Datenbank-Setup muss man diesen Parameter so einstellen, dass die Parameter `db_maxconn`, `workers` und `max_cron_threads` aus `odoo.conf` und der Parameter `max_connections` aus `postgresql.conf` folgende Ungleichung erfüllen: `(1 + workers + max_cron_threads) * db_maxconn < max_connections` ([Quelle](https://odoo-development.readthedocs.io/en/latest/admin/db_maxconn.html)).

+- *PostgreSQL* kann man weitestgehend so lassen wie es ist, nachdem Odoo und Postgres auf dem gleichen Server laufen. Wenn sie auf getrennten Maschinen laufen müsste man eine Verbindung über einen SSH-Tunnel herstellen oder externe IPs erlauben. Um obige Ungleichung zur Vermeidung zu vieler Clients zu erfüllen, muss der Wert von `max_connections` in `/etc/postgresql/12/main/postgresql.conf` entsprechend gewählt werden. In unserem Fall ist `max_connections = 300` statt der ursprünglichen 100 gesetzt, sodass noch etwas Puffer oberhalb der (1+6+1)*32=256 Clients vorhanden ist, die Odoo maximal in Anspruch nimmt.

+

+Im Fall unserer Installation findet sich die Hauptkonfiguration von Odoo in `/etc/odoo/odoo.conf` statt `/etc/odoo.conf`, wie es in der Dokumentation steht. Die aktuelle Config ist relativ kurz (falls sich nicht geändert hat):

+```

+; See https://www.odoo.com/documentation/16.0/administration/install/deploy.html

+

+[options]

+; This is the password that allows database operations:

+admin_passwd = ...

+db_host = False

+db_port = False

+db_user = odoo

+db_password = False

+dbfilter = ^%d.*$

+addons_path = /usr/lib/python3/dist-packages/odoo/addons,/opt/odoo-addons,/var/sftp/andre_schulz_addons,/home/joachim/indust>

+default_productivity_apps = True

+

+; Proxy mode for Nginx

+proxy_mode = True

+xmlrpc_interface = 127.0.0.1

+netrpc_interface = 127.0.0.1

+

+; Performance settings

+limit_memory_hard = 1677721600

+limit_memory_soft = 629145600

+limit_request = 8192

+limit_time_cpu = 450

+limit_time_real = 900

+max_cron_threads = 1

+workers = 6

+db_maxconn = 32

+```

+

+Ein zufälliges 16 stelliges Passwort lässt sich mit Linux Befehl `< /dev/urandom tr -dc A-Za-z0-9 | head -c${1:-16};echo;` generieren.

+

+

+# Nginx

+Für HTTPS läuft Odoo hinter einem Nginx Proxy, der in `/etc/nginx/sites-enabled/odoo.conf` konfiguriert ist.

+Das Template dazu steht auch in der oben verlinkten Dokumentation. Die Subdomains kommen jeweils in die `server`-Blöcke, d. h.

+```

+server {

+ listen 80;

+ listen [::]:80;

+ server_name dobhan.erp.digit40.edu.sot.tum.de;

+ server_name repoli.erp.digit40.edu.sot.tum.de;

+ ...

+ rewrite ^(.*) https://$host$1 permanent;

+}

+

+server {

+ listen 443 ssl;

+ listen [::]:443 ssl;

+ server_name dobhan.erp.digit40.edu.sot.tum.de;

+ server_name repoli.erp.digit40.edu.sot.tum.de;

+ ...

+

+```

+# Subdomain hinzufügen

+

+Um eine neue Subdomain von Hand hinzuzufügen:

+```

+sudo nano /etc/nginx/sites-enabled/odoo.conf # An beiden Stellen wo "server_name" vorkommt eine neue Zeile hinzufügen

+sudo certbot --expand -d neueSubdomain.erp.digit40.edu.sot.tum.de -d dobhan.erp.digit40.edu.sot.tum.de ... # Hier alle Domains auflisten (bei der Frage zum redirect die "1: no redirect" auswählen)

+sudo systemctl restart nginx

+```

+

+Dann kann man unter der neuen Subdomain in Odoo eine neue Datenbank einrichten. Wir starten derzeit üblicherweise mit einer Kopie [derjenigen Datenbank](https://erp-test.oct.re/web/database/manager), an der der Lehrstuhl WiPäd rumspielt. Das geht bequem über den Endpunkt /web/database/manager, also erst auf https://quelle.erp.digit40.edu.sot.tum.de/web/database/manager ein Backup erstellen (Master-Passwort siehe oben `odoo.conf`) und dieses zip-Archiv dann via "restore" in https://ziel.erp.digit40.edu.sot.tum.de/web/database/manager hochladen (dabei "this database is a copy" wählen).

+

+Eine Skripting-Lösung ist in Arbeit (#39), wird aber gerade durch den Domain-Umzug von erp-test.oct.re zu erp.digit40.edu.sot.tum.de gebremst. Der nervigste Schritt in Handarbeit, nämlich der Certbot-Aufruf mit `-d subdomain.erp.digit40.edu.sot.tum.de` für jede Subdomain, lässt sich mit

+```

+DOMAINS=$(grep -E 'server_name' /etc/nginx/sites-enabled/odoo.conf | sort | uniq -d | sed 's/server_name //' | sed 's/;//')

+CERTBOTPARAM=$(echo $DOMAINS | sed 's/ / -d /g')

+sudo certbot --expand --no-redirect -d $CERTBOTPARAM

+```

+erledigen.

+

+# Update

+Updates (zumindest innerhalb einer Version, z.B. Version 16) gehen einfach mit `apt update && apt upgrade`. Upgrades (z.B. 16->17, sobald verfügbar) sind noch nicht getestet.

+Falls es nach dem Update zu Fehlermeldungen kommt, die sowas wie `web.assets_backend.min.js` enthalten, hilft es vermutlich [Asset Bundles](https://www.odoo.com/documentation/16.0/developer/reference/frontend/assets.html) neu zu generieren. Dazu öffnet man die Instanz mit `?debug=assets`, und klickt dann oben rechts auf das "Bug" Symbol und dort auf "Regenerate Assets Bundles":

+

+

+

+# SFTP-Zugriff für André Schulz

+

+Solange keine Containerisierung umgesetzt ist, brauchen fortgeschrittene Benutzer wie André Schulz (Masterand WiPäd), die eigene Addons schreiben, eine Möglichkeit, ihren Code auf den Server zu bringen. Provisorisch ist das entsprechend https://www.digitalocean.com/community/tutorials/how-to-enable-sftp-without-shell-access-on-ubuntu-20-04 mit einem Benutzer `andresftp` gelöst, der nur per SFTP und nur auf den Ordner `/var/sftp/andre_schulz_addons` zugreifen kann. Letzterer ist in `/etc/odoo/odoo.conf` als Addons-Pfad hinzugefügt, sodass André (und jeder andere der neugierig ist) die dortigen Addons installieren kann.

+Diese Anleitung beschreibt, wie man Odoo für die Fertigung im Industrie Space einrichtet. Die ersten Schritte beziehen sich auf Odoo noch ohne das Addon für die Fertigung. Erst wenn alles in Odoo eingerichtet ist, kommt das Addon dran, damit klar ist, was vom Addon hinzugefügt wurde.

+

+Die Anleitung bezieht sich auf die Interfacesprache Englisch, weil im Internet mehr Dokumentation zur englischen Version verfügbar ist.

+

+# Odoo Einrichtung

+

+## Erster Schritte: Module aktivieren

+

+1. Apps -\> Manufacturing -\> Activate

+2. Apps -\> Sales -\> Activate

+3. Apps -\> Filter: Installed ... und dann unnötige deinstallieren (gebraucht wird: Sales, Inventory und Manufacturing)

+4. Optional:\

+ Settings -\> Activate the developer mode\

+ Settings -\> Users (oben) -\> ..user auswählen -\> Preferences -\> Home Action auf "Manufacturing Orders" (muss man etwas ausprobieren welches der Möglichkeiten das ist, das funktioniert).\

+ Auf diese Art zeigt Odoo standardmäßig die Fertigungsaufträge anstelle von "Discuss" an.

+

+## Inventory

+

+- Settings -\> Inventory ... und dann aktivieren:

+ - Products -\> Variants

+ - Warehouse -\> Storage Locations

+ - Warehouse -\> Multi-Step Routes

+ - Save

+- Inventory -\> Configuration -\> Locations

+ - WH/Stock z.B. in WH/Lager umbenennen, damit es auf den Logistik Bildschirmen auch als "Lager" steht

+ - Neu hinzufügen: WH/Station A IN, WH/Station A DESK, WH/Station A OUT, ... (Es reicht Location Name und Parent location (WH) auszufüllen, der Rest kann so bleiben)

+ - Hinweis: Unter Configuration -\> Warehouses -\> Warehouse auswählen -\> Technical Information kann man einstellen, was das Standard Lager ist (Location Stock). Das wird vom MRP Modul dann auch als Startort für neue Aufträge verwendet

+

+## Produkte

+

+- Inventory -\> Configuration -\> Attributes:

+ - Neue Attribute einrichten:

+ - Motor (193 kW, 245 kW, 615 kW)

+ - Hülle (keine, blau, schwarz)

+ - Batterie (keine, 2000 mAh, 3000 mAh)

+ - Vorderrad links (schwarz, weiß, blau)

+ - Vorderrad rechts (schwarz, weiß, blau)

+ - Hinterrad links (schwarz, weiß, blau)

+ - Hinterrad rechts (schwarz, weiß, blau)

+ - Stoßdämpfer vorne (innen, außen)

+ - Stoßdämpfer hinten (innen, außen)

+ - Heckspoiler (keiner, blau, schwarz)

+ - Display Type: Radio für alles außer die vier Räder, Hülle und Heckspoiler, dort Color

+ - Variants Creation Mode: dynamically _\<-- hier stattdessen static?_

+- Inventory -\> Products -\> Products -\> New:

+ - Racer:

+ - Can be Sold: aktiviert

+ - Can be Purchased: deaktiviert

+ - Sales Price: zB 150€

+ - Attributes & Variants: Alle vorher erstellten Attribute und alle Werte dazu eingeben

+ - Inventory -\> Routes -\> Manufacture: aktivieren

+ - Optional: Bild einrichten

+ - Save

+ - Komponenten auch jeweils als Produkte hinzufügen, aber Can be Sold deaktiviert, und Can be Purchased aktiviert

+ - 193 kW Motor

+ - 245 kW Motor

+ - 615 kW Motor

+ - 2000 mAh Batterie

+ - 3000 mAh Batterie

+ - Hinterrad blau

+ - Hinterrad schwarz

+ - Hinterrad weiß

+ - Vorderrad blau

+ - Vorderrad schwarz

+ - Vorderrad weiß

+ - Hülle blau

+ - Hülle schwarz

+ - Heckspoiler blau

+ - Heckspoiler schwarz

+ - Je Komponente:

+ - Nach dem Speichern: Update Quantity -\> New

+ - Counted Quantity eingeben: 100.000 (solange der Materialbestand nicht Schulungsthema ist)

+ - Apply

+

+## Manufacturing

+

+- Manufacturing -\> Configuration -\> Settings:

+ - Work Orders und dann auch Work Order Dependencies aktivieren

+- Arbeitszeiten einrichten (Workorders können nicht außerhalb der Arbeitszeiten geplant werden. Die Arbeitszeiten werden aber nicht außerhalb von Odoo angezeigt, daher kann man die einfach auf 24/7 einrichten und hat keine unerwarteten Effekte):

+ - Settings -\> Activate the developer mode

+ - Settings -\> Technical -\> Working Times (ganz unten)

+ - New, und einrichten wie dargestellt: 

+- Manufacturing -\> Configuration -\> Work Centers:

+ - Station A-D einrichten (Es reicht den Namen im Feld "Work Center Name" einzugeben und die Arbeitszeiten auf 24/7 zu stellen)

+- Manufacturing -\> Products -\> Bills of Materials -\> New:

+ - Product: Racer

+ - Miscellaneous: Operation Dependencies? aktivieren

+ - _Save_

+ - Operations:

+ - "Ein-/Aus Schalter befestigen" (Work Center: Station A)

+ - "Motor einbauen" (Work Center: Station A)

+ - "Hinterräder befestigen" (Work Center: Station B)

+ - "Vorderräder befestigen" (Work Center: Station C)

+ - "Motor und Batterie anschließen" (Work Center: Station D)

+ - "Heckspoiler und Hülle einbauen" (Work Center: Station D)

+ - _Bei allen außer dem ersten: Jeweils Blocked By das vorherige auswählen_

+ - Components: Alle oben erstellten Komponenten hinzufügen

+ - Die Vorder-/Hinterräder jeweils zwei mal (li/re). Falls li/re nicht unterschiedlich konfigurierbar sind stattdessen die Quantity auf 2

+ - Apply on Variants, Consumed in Operation aktivieren: 

+ - Jeweils passend zuweisen: 

+

+# Addon Einrichtung

+

+- Installation: Apps öffnen und oben rechts den Filter für "Apps" entfernen. Das Plugin findet sich in der Kategorie "Manufacturing"

+- Manufacturing -\> Configuration -\> Work Centers:

+ - Je Station: *Input Location* und *Output Location* eintragen (Bei Station A z.B. "WH/Station A IN" und "WH/Station A OUT")

+- Manufacturing -\> Configuration -\> Operations:

+ - Über das neue Feld "Display attributes" lassen sich die Attribute auswählen, die zu diesem Arbeitsschritt auf den Stationsmonitoren angezeigt werden sollen (z.B. welcher Motor eingebaut werden soll beim zugehörigen Arbeitsschritt)

+ - Bei Worksheet gibt es die Optionen "URL (PDF/MP4/...)" und "URL (Website)". Der Unterschied ist nicht groß, nur dass bei ersterem noch URL-Parameter angehängt werden, damit PDFs ohne Toolbar etc. angezeigt werden (ursprünglich wurde ersteres als `<embed>` und zweiteres als `<iframe>` eingebunden, aber am Ende war es einfacher den URL immer als `<iframe>` einzubinden).

+ - Im Feld URL kann man relative URLs zum Verzeichnis `web` im lokalen Server (Meister-PC) angeben, z.B. `pdf/Station-A.pdf` bzw. `station-a.html` (Falls HTML Seiten in einem Unterordner liegen, sollten sie Dateien besser mit einem Slash am Anfang einbinden, z.B. `/mp4/video.mp4`). Absolute URLs sind auch möglich, allerdings müssen diese dann CORS für `tuedfed-dl01.fritz.box` erlauben.

+

+Nicht für die Einrichtung relevant, aber auch vom Plugin hinzugefügt werden:

+- Bei Manufacturing Orders die Felder "RFID" (read-only) und "Current location". Außerdem gibt es noch das zusätzliche Template "Production Order mit Konfiguration" bei "Print" für den Papierdurchlauf.

+- Bei Work Orders der Zustand "Waiting for transfer", wenn der vorige WO abgeschlossen ist, aber die aktuelle Position des MO noch nicht da ist, wo die Station des neuen WO die "Input location" hat. Work Orders können zu Demozwecken aber den Transfer zur "IN" location überspringen und direkt an der Station gescannt und gestartet werden.

+- Production Cycles (oben im Menü): Zur Erfassung von Statistiken braucht es einen Referenzzeitraum, den man mit Produktionszyklen festlegen kann. Es kann immer nur maximal ein Produktionszyklen gleichzeitig laufen.

+- Ein verstecktes Detail ist noch der Blockiergrund "Break"/Pause, wenn man einen Work Order (und damit für Odoo die ganze Station) blockiert. Das passiert im Hintergrund, wenn man bei einer Station auf "Pause" klickt, um die Berechnung der Availability zuverlässiger zu machen.

+## Kurzfassung

+

+Eine Bestellung des Modellautos im Webshop soll zu einem Fertigungs-Auftrag innerhalb von Odoo führen.

+

+## Einrichtung

+

+Der Racer muss mit der Produktart "Lagerfähiges Produkt" angelegt werden, und "Fertigung" muss als "Route" zu seiner Beschaffung ausgewählt worden sein. Das Addon-Modul `tum_product_variant_automation` ([Quellcode](https://gitlab.lrz.de/teachtum40/industrie4.0/-/tree/main/tum_odoo_addons/tum_product_variant_automation?ref_type=heads)) muss installiert sein. Das ist Stand 26.10.2023 in der DB `odoo-mrp` geschehen, um den Workflow von der Bestellung bis zur Fertigung im DigiLLab demonstrieren zu können.

+Im "Verkauf"-Modul muss der Filter "Meine Angebote" entfernt worden sein (s.u.).

+

+## Nutzung

+

+Der Workflow von Bestellung zu Fertigungsauftrag geht nun so:

+1. Jemand bestellt im Webshop einen Racer.

+2. Im "Verkauf"-Modul von Odoo erscheint nun diese Bestellung.

+3. Im "Fertigung"-Modul von Odoo ist nun automatisch ein Fertigungsauftrag für diese Variante angelegt worden.

+

+### "My Quotations"-Filter deaktivieren

+

+Damit man alle Aufträge - einschließlich der bisher keinem Mitarbeiter zugewiesenen - sieht, muss der "My Quotations"-Filter weg. Der ist derzeit wie folgt deaktiviert (ob das der sinnvolle Weg ist, bleibt zu klären): Im Developer-Modus auf der Startseite des Sales-Modul das Debug-Menü -> Edit Action und dann unter Filters -> Context Value den Eintrag von

+```

+{'search_default_my_quotation': 1}

+```

+zu

+```

+{'search_default_my_quotation': 0}

+```

+abgeändert.

+## Kurzfassung

+

+Um Änderungen in einer Postgres-DB ein externes Skript auslösen zu lassen, kann man den `trigger`-Mechanismus sowie `notify` in Postgres nutzen und ein externes Skript ein entsprechendes `listen` auf der selben Datenbank durchführen lassen.

+Damit kann man z. B. bewerkstelligen, dass ein neuer Fertigungsauftrag aus Odoo einen `curl` an den SLF-Configurator auslöst.

+

+

+## Postgres: notify mit trigger auslösen

+

+### a) von Odoo an SLF

+

+Beispiel: Um bei Einfügung eines neuen Fertigungsauftrags in die Tabelle `mrp_production` ein `notify` an den Kanal `joachim_production_insert` auszulösen, muss zuerst eine Funktion definiert werden, die einen `trigger` als Rückgabewert hat und die das `notify` aufruft:

+```

+create or replace function joachim_production_insert() returns trigger as $joachim_production_insert_trigger$

+begin

+ perform pg_notify('joachim_production_insert',row_to_json(NEW)::text);

+ return new;

+end;

+$joachim_production_insert_trigger$ language plpgsql;

+```

+Jetzt muss noch festgelegt werden, dass ein `insert` in diese Tabelle obige Funktion triggert:

+```

+create trigger joachim_production_insert_trigger after insert on mrp_production

+for each row execute function joachim_production_insert();

+```

+Bemerkungen:

+- Die Namen von Kanal, Funktion und Trigger sind logisch unabhängig; hier sind sie nur gleich bzw. ähnlich um einigermaßen selbsterklärend zu sein wenn man aus anderem Kontext darüber stolpert

+- Für mehrzeilige SQL-Eingabe kann man zum Beispiel pgadmin nutzen. (Aber nicht versuchen, die Trigger mit den dafür vorgesehenen Dialogen in pgadmin zu definieren; da habe ich mich im Kreis gedreht)

+- `notify` lässt standardmäßig eine Payload von bis zu 8000 Byte Länge zu. Wenn nicht sicher ist dass man damit hinkommt, dann bloß Primärschlüssel übergeben und das Python-Skript die Daten aus der Tabelle lesen lassen statt via notify-Payload zu schicken. Oder neue Zeile in dedizierte Tabelle kopieren, die dem Python-Skript als abzuarbeitende Queue dient.

+

+### b) von SLF an Odoo

+

+In "SLF"-DB auf Workstation (Achtung: Posgres läuft auf Host, nicht auf VM, und zwar mit Benutzer `DigiLLab`):

+```

+creat function notify_update_for_odoo() returns trigger as $production_order_update_trigger$

+begin

+ perform pg_notify('update_for_odoo',row_to_json(NEW)::text);

+ return new;

+end;

+$production_order_update_trigger$ language plpgsql;

+```

+```

+create trigger production_order_update_trigger after update of state on production_order

+for each row execute function notify_update_for_odoo();

+````

+

+

+## Python: mit listen auf notify reagieren

+

+Um nun mit einem Python-Skript auf ein `notify` im fraglichen Kanal zu reagieren, sollte zunächst ein dedizierter Benutzer dafür angelegt werden (zumindest ging es mit dem einzigen Admin erstmal nicht).

+```

+import asyncio

+import psycopg2

+

+conn = psycopg2.connect(host="localhost",dbname="my_first_database",user="python_test",password="1234")

+conn.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)

+

+cursor = conn.cursor()

+cursor.execute('LISTEN joachim_production_trigger')

+

+def handle_notify():

+ conn.poll()

+ for notify in conn.notifies:

+ print(notify.payload)

+ conn.notifies.clear()

+

+

+loop = asyncio.get_event_loop()

+loop.add_reader(conn, handle_notify)

+loop.run_forever()

+```

+Für eine Lösung ohne `asyncio` siehe [hier](https://www.depesz.com/2012/06/13/how-to-send-mail-from-database/). Das `ISOLATION_LEVEL_AUTOCOMMIT` ist nötig, damit jede Datenbankanfrage durch psycopg2 automatisch committed wird anstatt auf einen commit zu warten (gemäß irgendeinem in diesem Punkt nicht besonders sinnvollen Standard; finde die Diskussion auf Stackexchange gerade nicht wieder).

+

+## Auf Workstation (SLF-VM auf Workstation)

+

+Lieber Powershell als Powershell ISE, denn erstere macht den `print` wie man ihn von Unix kennt einfach auf die Konsole selbst. Mit Powershell ISE landet diese Ausgabe irgendwo anders.

+Die SLF Postgres Datenbank kann im MWN über `10.162.111.159` Port `5432` mit Passwort geöffnet werden. Zur Sicherheit ist allerdings nur eine Verbindung über SSL möglich.

+

+# Einrichtung

+SSL Support auf dem Server ist nach der [offiziellen Anleitung](https://www.postgresql.org/docs/13/ssl-tcp.html) (Siehe "Basic Setup" und "Creating Certificates") eingerichtet. Dazu kommentiert man in `C:\Program Files\PostgreSQL\13\data\postgresql.conf` in der VM die Zeile `ssl = on` aus (Siehe [Dokumentation der Konfigurationsdatei](https://www.postgresql.org/docs/13/runtime-config-connection.html#RUNTIME-CONFIG-CONNECTION-SSL)) und lädt in den gleichen Ordner die Dateien `server.crt` und `server.key` hoch.

+

+Die Zertifikatsdateien sind alle im Repo und nach Anleitung (lokal auf dem Laptop) generiert:

+```bash

+# Root Certificate Signing Request (CSR) erstellen

+openssl req -new -nodes -text -out root.csr -keyout root.key -subj "/CN=root.industry40.digillab"

+chmod og-rwx root.key

+# Root CSR selbst signieren

+openssl x509 -req -in root.csr -text -days 3650 -extfile /etc/ssl/openssl.cnf -extensions v3_ca -signkey root.key -out root.crt

+# Server CSR erstellen und selbst signieren

+openssl req -new -nodes -text -out server.csr -keyout server.key -subj "/CN=db.industry40.digillab"

+chmod og-rwx server.key

+openssl x509 -req -in server.csr -text -days 3650 -CA root.crt -CAkey root.key -CAcreateserial -out server.crt

+```

+

+Danach startet man Postgresql neu (in der VM: Eingebeaufforderung als Admin starten, dann `services.msc<ENTER>` und bei postgres 13 ber Rechtsklick neustarten. Falls eine Fehlermeldung kommt, ist evtl etwas in der Konfiguration falsch).

+

+# Clients hinzufügen

+Damit nur berechtigte Clients aus dem MWN zugreifen können, müssen die Client IPs einzeln in `C:\Program Files\PostgreSQL\13\data\pg_hba.conf` eingetragen werden. Diese Zeile erlaubt zum Beispiel den tuedfed-tat40web Server mit IP `138.246.225.122`:

+```

+hostssl all all 138.246.225.122/32 md5

+```

+

+# Verbindung mit psycopg

+Mit psycopg kann man entweder ohne Verifzierung des Server Zertifikates (nur Transportverschlüsselung) sich verbinden:

+```

+conn = psycopg.connect(..., password="...", sslmode='require')

+```

+oder mit Verifizierung:

+```

+conn = psycopg.connect(..., password="...", sslmode='verify-ca', sslrootcert='root.crt')

+```

+In letzterem Fall braucht man die Datei `root.crt`.

+

+Falls der Client noch nicht in `pg_hba.conf` hinzugefügt wurde (siehe oben), erhält man die IP praktischerweise in der Fehlermeldung.

+Auf dem teachtum40 Server ist für Odoo Postgres standard über die Ubuntu Paketquellen installiert:

+```

+sudo apt install postgresql -y

+```

+

+Die primäre Konfiguration zu Postgres findet sich in

+- `/etc/postgresql/12/main/postgresql.conf`: Grundsätzliche Server Konfiguration

+- `/etc/postgresql/12/main/pg_hba.conf`: Anmeldemethoden je nach Quelle (lokal/remote) und User / DB

+

+# Lokaler Zugriff

+Für die Anmeldemethode `peer` ([Peer Authentication](https://www.postgresql.org/docs/current/auth-peer.html)):

+```bash

+# Grundlegendes Kommando

+#sudo -u USER psql DB

+sudo -u postgres psql postgres

+sudo -u odoo psql odoo_test

+```

+

+Für die Anmeldemethode `md5` ([Password Authentication](https://www.postgresql.org/docs/current/auth-password.html)):

+```bash

+# Grundlegendes Kommando

+#psql -U USER [-d DB]

+psql -U postgres

+psql -U odoo -d odoo_test

+```

+

+Falls man für den User `postgres` Password Auth eingerichtet hat, kann man trotzdem das obige Kommando mit Peer Auth verwenden, wenn man eine `.pgpass` Datei erstellt. Dann muss man das Passwort nicht immer eintippen.

+```bash

+# Als root, also nach

+#sudo su

+echo "localhost:*:*:postgres:PASSWORD" > ~postgres/.pgpass

+chown postgres:postgres ~postgres/.pgpass

+chmod 0600 ~postgres/.pgpass

+```

+

+# Remote Zugriff

+Mit SSH Port Tunneling

+```bash

+ssh -L 5432:localhost:5432 user@tuedfed-tat40web.srv.mwn.de

+```

+## Beekeeper Studio

+Nach dem öffnen von [Beekeeper Studio](https://www.beekeeperstudio.io/) ([Downloads für die Community Version](https://github.com/beekeeper-studio/beekeeper-studio/releases)) kann man dann direkt zugreifen im Falle von Password Auth:

+

+

+

+## pgAdmin

+

+Für einen Benutzer/Passwort-Login via pgAdmin kann man einen dedizierten Benutzer anlegen, z. B.

+erst lokal mit

+```

+sudo -u postgres psql postgres

+```

+anmelden und Nutzer mit Passwort anlegen

+```

+CREATE USER pgAdmin WITH PASSWORD '1234' SUPERUSER

+```

+

+Oder aber als bestehender Benutzer via Kommandozeile einloggen und ein (postgres-spezifisches) Passwort festlegen. Gehört zum Beispiel der System-Benutzer `joachim` zu den postgres-Superusern, braucht aber noch ein Passwort damit pgAdmin sich so ausweisen kann, dann

+```

+sudo -u joachim psql postgres

+postgres-# \password joachim

+```

+und Passwort festlegen. (Man kann auch bloß '\password' aufrufen, das ändert das Passwort für den aktuell via 'psql' eingeloggten Benutzer.) Übrigens kann man mit '\dg' in der postgres-Shell die vorhandenen Benutzer auflisten lassen, falls da Unklarheiten bestehen.

+

+Für lokalen Zugriff dann mit diesem Benutzer/Passwort-Paar in pgAdmin anmelden.

+

+Für Remote-Zugriff dann SSH Port Tunneling wie oben und schließlich in pgAdmin mit diesem Benutzer an localhost angemeldet (Port Tunneling besorgt die remote Verbindung).

+

+## Kurzfassung

+

+Um Arbeit auf der Workstation auch aus dem Home Office zu ermöglichen, ist diese innerhalb des MWN (insbesondere also nach Verbindung mit dem TUM-VPN) über Microsoft Remote Desktop unter der IP `10.162.111.159` erreichbar, solange sie eingeschaltet ist.

+

+## Benutzerkonten

+

+### Für Login auf Workstation aus dem MWN

+

+| PC name | Benutzer | Wer hat das Passwort? | Bemerkung |

+| ------ | ------ | ------ | ------ |

+| 10.162.111.159 | DigiLLab | Bert, Joachim, Arne | Administrator |

+| 10.162.111.159 | Joachim | Joachim| Administrator |

+

+Beides sind lokale Konten auf der Workstation (tbc: die Workstation ist gar nicht mit dem Active Directory verbunden).

+

+### Für Login auf der SLF-VM von der Workstation aus

+

+Falls mit Benutzer `DigiLLab` eingeloggt: HyperV-Manager öffnen und Doppelklick auf die VM.

+Falls mit Benutzer `Amelie` eingeloggt: Remote Desktop Anwendung öffnen und dann

+

+| PC name | Benutzer | Wer hat das Passwort? | Bemerkung |

+| ------ | ------ | ------ | ------ |

+| SLF-LAB-SERVER | Amelie | Joachim, Amelie | gleiches Passwort wie oben |

+

+Benutzer ```Amelie``` ist als lokaler Benutzer innerhalb der VM angelegt und dort der Gruppe der Benutzer hinzugefügt, die Remote-Zugriff auf die VM haben (heißt in dem Fall: rdp-Zugriff auf die VM von der Workstation aus). Dieser Benutzer ist logisch unabhängig von ```Amelie``` auf Ebene der Workstation (=> etwaige Passwortänderungen auf beiden Ebenen vornehmen!)

+

+## Konfiguration

+

+Die Workstation hängt aktuell an der Fritz Box, die als Internet-Router (und nicht IP-Client) eingestellt ist, wodurch sie einen eigenen IP-Adressbereich erstellt der nicht direkt aus dem MWN erreichbar ist.

+Um einen Zugriff mit Microsoft Remote Desktop zu ermöglichen, ist daher auf der Fritz Box der Port `3389` (Standard-Port für remote desktop protocol) der Work Station freigegeben.

+Die beteiligten IP-Adressen `10.162.111.159` der Fritz Box im MWN und `192.168.188.41` der Work Station im Netz der Fritz Box sind nicht fest, werden aber auch bei Neuanmeldung im jeweiligen Netzwerk normalerweise wieder so zugewiesen (vgl. System -> Ereignisse auf der Fritz Box).

+

+## Sicherheit

+

+Den Empfehlungen einer Mini-Serie auf heise.de folgend (insb. Teil 3 [RDP: Testen und angreifen](https://www.heise.de/hintergrund/Remote-Desktop-via-RDP-Testen-und-angreifen-3-4-4702968.html) und Teil 4 [RDP: Best Practices](https://www.heise.de/hintergrund/Remote-Desktop-via-RDP-Best-Practices-4-4-4711807.html)), ist der Zugriff nur aus dem MWN und nicht aus dem Internet möglich.

+Zusätzlich liefert der in Teil 3 beschriebene Test

+```

+nmap -P0 -p 3389 --script rdp-enum-encryption 10.162.111.159

+```

+das gewünschte Ergebnis:

+```

+Starting Nmap 7.80 ( https://nmap.org ) at 2022-03-02 20:36 CET

+Nmap scan report for 10.162.111.159

+Host is up (0.0020s latency).

+

+PORT STATE SERVICE

+3389/tcp open ms-wbt-server

+| rdp-enum-encryption:

+| Security layer

+| CredSSP (NLA): SUCCESS

+| CredSSP with Early User Auth: SUCCESS

+|_ RDSTLS: SUCCESS

+```

+d. h. ein Downgrade auf unsichere RDP-Verbindungen kann dank der aktuellen Version auf der Work Station nicht erzwungen werden.

+## Kurzfassung

+

+Der "Configurator" ist ein Endpunkt der SLF, der zur programmatischen Eingabe von Fertigungsaufträgen benutzt werden kann. Er liefert daher einen ersten Ansatzpunkt für die Odoo-SLF-Integration.

+

+## Einrichtung

+

+Im Netzwerk des Industrial Space (SSID `FRITZ!Box 4040 CI`) ist unter `192.168.188.27:8080/slf/configurator` der Configurator erreichbar, über den Aufträge eingegeben werden können. Der Port ist auf dem Router freigegeben, also ist der Configurator MWN-weit unter [10.162.111.159:8080/slf/configurator](http://10.162.111.159:8080/slf/configurator) erreichbar.

+

+## Gebrauch

+

+Voraussetzung: Im der SLF-Steuerung (`192.168.188.28:8080`) muss eine Produktion vorbereitet worden sein, sonst ist `plant_state:idle` und keine Aufträge werden angenommen. Für Entwicklungszwecke ist es egal, ob die Stationen erreichbar sind. (Die Stationen können dank Funksteckdosen vom `sturzkamera`-Raspi im Smart Home aus über 433MHz eingeschaltet werden; das muss noch dokumentiert und ggf. durch WLAN-Steckdosen im Industrie-WLAN verbessert werden).

+

+Mit

+```

+curl -X POST -H 'Content-Type: application/x-www-form-urlencoded' -d 'configuration_elements=10&command=submit&name=yesWeCURL&motor=MM&battery=NO&chassis=CB&shock_absorbers_front=O&shock_absorbers_back=O&front_left=W&front_right=S&back_left=S&back_right=S' http://10.162.111.159:8080/slf/configurator

+```

+lässt sich aus dem MWN ein Auftrag eingeben (oder natürlich im Browser). Die Bedeutung der Parameter wird ersichtlich, wenn man im Browser das Formular abschickt und den POST Request anschaut.

+

+## Einschränkungen

+

+### Configurator ist Mischung aus Konfigurations-/Auftrags-Eingabe

+

+Dieses ganze Vorgehen – das von Inoyad als "Schnittstelle" für die Auftragseingabe vorgeschlagen wurde - ist eigentlich eine Zweckentfremdung des Configurators, der wohl mal als Eingabemöglichkeit einer Konfiguration (von den insgesamt ca. 25000 möglichen Konfigurationen des Autos, Spoiler nicht mal mitgezählt) gedacht war und nicht so sehr als Eingabemöglichkeit einer Einzelbestellung. Dementsprechend zeigt

+```

+select * from product_configuration where name like 'WHM%'

+```

+dass die Fertigungsaufträge, die wir aus Odoo über den Configurator einspeisen, nicht bloß in `production_order` (mit `product_configuration_id` als Fremdschlüssel) abgelegt werden, sondern auch in `product_configuration` verewigt werden.

+

+Das ist zwar von der Modellierung her nicht sauber, fällt aber in der Praxis nicht weite rauf.

+

+### Heckspoiler nicht konfigurierbar

+

+Der Configurator bietet keine Auswahl für den Heckspoiler. TO DO: Mal mit Matthias kläre, wie der Heckspoiler eigentlich in den Beispielaufträgen vorkommt. Eventuell werden wir Inoyad ohnehin mal beauftragen, den Configurator in der Hinsicht zu erweitern, wenn wir nämlich 3D-gedruckte individuelle Spoiler-Designs implementieren (vgl. Ticket #18 )

+Der DB-Filter ist so, dass die Datenbank der zugehörigen Subdomain verwendet wird. Das heißt die erp-test.oct.re verwendet die DB erp-test (ich hab dazu WiPaed über ein Backup/Restore kopiert und in erp-test umbenannt), und z.B. odoo-mrp.erp-test.oct.re verwendet die DB odoo-mrp. Um eine neue DB einzurichen muss man sie aber noch Nginx hinzufügen und das Zertifikat erstellen:

+

+```

+sudo nano /etc/nginx/sites-enabled/odoo.conf # An beiden Stellen wo "server_name" vorkommt eine neue Zeile hinzufügen

+sudo certbot --expand -d erp-test.oct.re -d odoo-mrp.erp-test.oct.re -d 2.erp-test.oct.re # Hier alle Domains auflisten (bei der Frage zum redirect die "1: no redirect" auswählen)

+sudo systemctl restart nginx

+```

+

+Dann kann man unter der neuen Subdomain in Odoo eine neue Datenbank einrichten, wo der DB-Name mit der Subdomain beginnen muss, z. B. auf startzustand.erp-test.oct.re: startzustand-ohne-webshop, startzustand-mit-webshop, startzustand-mit-webshop-und-fertigung usw.

+SLF-VM hochfahren. Danach pgAdmin als Benutzer `DigiLLab` auf dem Host-System (!) öffnen, nicht innerhalb der SLF-VM. Master-Passwort für pgAdmin siehe Joachims Schlüsselbund; Passwörter für einzelne DBs siehe Passwortliste die Inoyad bereitgestellt hat (oder Joachims Schlüsselbund).

+

+Mit Ansible lässt sich das Einrichten und Verwalten der Geräte (Raspis) im Smart Home teilweise automatisieren. Der Aufwand kann zu Beginn vielleicht etwas größer sein, um Ansible einzurichten, dafür ist es später dann schneller und einfacher. Voraussetzung hierfür ist, dass die Raspis (oder andere Geräte) ein frisch installiertes Raspbian (aktuell: Bullseye) haben. Die Installation ist in [Einrichtung der Raspis](Einrichtung der Raspis) beschrieben.

+

+# Erste Schritte

+Die folgenden Schritte sind alle für eine Linux-artige Kommandozeile (BASH) geschrieben. Unter Windows kann man dazu das Windows Subsystem for Linux verwenden, siehe: [Installation unter Windows mit WSL](https://www.purrucker.de/2019/01/14/installation-von-ansible-auf-einem-windows-system/). Unter Mac OS sollte das [eingebaute Terminal](https://support.apple.com/de-li/guide/terminal/apd5265185d-f365-44cb-8b09-71a064a42125/mac) auch funktionieren.

+

+## 1. SSH Keys einrichten

+Ansible lässt sich mit SSH Keys am einfachsten verwenden. Falls man noch keine hat, kann man sich SSH Keys erstellen mit:

+```bash

+ssh-keygen -t ed25519 -b 4096

+```

+und dann den Schritten folgen. Die Standardwerte sind in der Regel passend. Hat man das abgeschlossen, kann man den öffentlichen Teil des Keys auslesen:

+```bash

+cat ~/.ssh/id_ed25519.pub

+```

+Den Inhalt der Datei muss man jetzt auf dem Smart Home Server in die Datei `/home/pi/.ssh/authorized_keys` einfügen. Falls der Ordner oder die Datei noch nicht existiert, muss man sie noch erstellen (`mkdir ~/.ssh` und `nano ~/.ssh/authorized_keys`). Danach kann man wie gewohnt sich per SSH verbinden, muss aber kein Passwort mehr eintippen:

+```bash

+ssh pi@192.168.xx.yy

+```

+

+## 2. Installation

+Die offzielle Dokumentation findet sich hier:

+[Installing Ansible](https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html)

+

+Voraussetzung für die Installation ist Python, über das man Ansible einfach mit pip installieren kann:

+```bash

+python3 -m pip install --user ansible

+```

+(Die Installation erfolgt nur auf dem lokalen Computer. Auf den Raspis muss man nichts installieren.)

+

+## 3. Ausführen von Ansible Befehlen

+Zur Verwendung von Ansible muss man im Ordner `ansible` im Smart Home Repo sein:

+```bash

+cd ansible

+```

+

+Dort lassen sich mit folgendem Bezehl zum Beispiel alle Kühlschrank Raspi Zeros neustarten:

+```bash

+ansible-playbook zeros.yml --tags "reboot"

+```

+# Überblick

+

+Das Smart Home ist um eine Art "Smart Home Zentrale" herum gebaut (dem _smart-home-control_ Server), der auf einem Raspberry Pi läuft. Alle weiteren Geräte und Softwarekomponenten lassen sich aufteilen in Geräte, Gerätesteuerungen und Interfaces/Apps.

+

+**Geräte** sind meistens kommerzielle Produkte, die im Smart Home verbaut sind. Manche sind speziell für Smart Homes gedacht (z.B. die smarten Steckdosen oder der SensFloor), andere eher Elektronik "Bastelprodukte" für den Raspberry Pi (z.B. die Kameras oder der Fenstersensor).

+

+Die **Gerätesteuerungen** verbinden die häufig gerätespezifischen Interfaces mit der Smart Home Zentrale. Auf die Art kann es im Smart Home eine einheitliche API geben (fertige Smart Home Software bringt für sowas in der Regel eigene Bibliotheken an unterstützten Geräten mit). Vor allem bei den Kameras läuft die Gerätesteuerung aufgrund der Entfernung auf einem eigenen Raspberry Pi.

+

+**Interfaces oder Apps** verbinden sich auf ähnliche Weise mit der Smart Home Zentrale, verwenden aber andere Funktionen der API. Sie können Daten in Echtzeit auslesen und Ereignisse auslösen, die dann an die Gerätesteuerungen geschickt werden. Für manche spezielle Funktionen (z.B. Push-Benachrichtigungen für die App) gibt es zusätzliche "Plugins" in der Smart Home Zentrale.

+

+

+

+# Architektur

+

+Anders als typische Softwareprogramme besteht das Smart Home eher aus vielen einzelnen, verteilten Programmen/Komponenten. Das hat den Vorteil, dass es einen deutlich geringeren Unterschied macht, auf welchem Gerät die Programme laufen. Zum Beispiel ist das Mikron zwar gerade an den zentralen Raspberry Pi angeschlossen, und hat dort auch seine Gerätesteuerung laufen. Man könnte es aber genauso gut wo anders hinstellen und (bei nicht ausreichendem Kabel) an einen anderen Raspberry Pi dort anschließen. Außerdem ist es leichter sicherzustellen, dass das Smart Home robust gegenüber ausgefallenen Geräten ist.

+

+Der Nachteil ist allerdings, dass die Organisation von Daten und Gerätestatus komlexer wird. Aus diesem Grund spielt die Socket.IO (SIO) API zwischen den Gerätesteuerungen bzw. Interfaces/Apps und der Smart Home Zentral eine wesentliche Rolle.

+

+# Details

+

+Die meisten Gerätesteuerungen laufen als Systemd Service (eine Art Hintergrunddienst, der automatisch neustartet), daher die Namen mit `.service`.

+

+

+

+Dokumentation zu den einzelnen Komponenten:

+

+[smart-home-control](Smart%20Home%20Control%20%E2%80%93%20Server)

+# Beteiligte Computer

+

+Die folgenden Computer sind am Smart Home beteiligt:

+

+| Typ | Name im Netzwerk | Ort | Äußere Merkmale | Erforderlich für |

+| ------ | ------ | ------ | ------ | ------ |

+| Raspberry Pi 4 | smart-home-server | Weißes Regel, unteres geschlossenes Fach | Transparentes Acrylgehäuse | Alles |

+| Raspberry Pi 3 | aa000024 | Auf dem weißen Regal | an Rückseite linker Monitor montiert | SensFloor |

+| Raspberry Pi 3 | c8a000ae | Boden nebem dem Schreibtisch | Schwarzes Plastikgehäuse | SensFloor |

+| Raspberry Pi | camera | An der Decke | Kamera | Sturzkamera |

+| Raspberry Pi Zero | kuehlschrank-1 | Kühlschrank innen oben | Mit Öffnungssensor verkabelt | Kühlschrank-Fotos (alle) |

+| Raspberry Pi Zero | kuehlschrank-2 | Kühlschrank Tür oben | | Zweites Kühlschrank-Foto|

+| Raspberry Pi Zero | kuehlschrank-3 | Kühlschrank Tür unten | | Drittes Kühlschrank-Foto|

+

+Überprüfung im Netzwerk (SSID `Smart Home`, Passwort `05808161781375379960`): Im Browser die Adresse `192.168.178.1` öffnen und in die Fritz Box einloggen mit Passwort `soft0734`. Dann sollten unter dem Seitenreiter "Netzwerk" obige Geräte mit folgenden IPs sichtbar sein:

+

+| Name im Netzwerk | IP | lokale Domain |

+| ------ | ------ | ------ |

+| smart-home-server | 192.168.178.24 | smart-home-server.fritz.box |

+| c8a000ae | 192.168.178.22 | c8a000ae.fritz.box |

+| aa000024 | 192.168.178.27 | aa000024.fritz.box |

+| camera | 192.168.178.25 | camera.fritz.box |

+| kuehlschrank-1 | ... | kuehlschrank-1.fritz.box |

+| kuehlschrank-2 | ... | kuehlschrank-2.fritz.box |

+| kuehlschrank-3 | ... | kuehlschrank-3.fritz.box |

+

+# Smart Home Control Server starten

+Der Server vom Smart Home Control sollte automatisch starten. Falls etwas nicht funktioniert hat, oder der Server neugestartet werden soll, geht das über den Systemd Service:

+

+```

+sudo systemctl restart smart-home

+```

+

+Neben `restart` gibt es auch `start`, `stop` und `status`. Die Service-Konfiguration liegt in `/etc/systemd/system/smart-home.service`. Der Server selbst in `/home/pi/smart-home/smart-home-control`.

+

+Die Smart Home Control Oberfläche ist dann erreichbar unter `https://smart-home-server.fritz.box:3030/#home` (Achtung: Selbst-signiertes Zertifikat).

+

+# SensFloor sichtbar machen

+

+Den linken Monitor an der Fensterbank einschalten; dort ist das SensFloor "Stationsterminal" (aa000024) angeschlossen, das automatisch den SensFloor visualisieren sollte. Falls nicht: Diesen Computer (Rückseite vom Monitor) neu starten. Falls immer noch nicht: Einen anderen Computer ins "Smart Home" WLAN einloggen (Passwort s. o.) und im Browser die Adresse

+```192.168.178.22:8000```

+eingeben. Dort sollte der SensFloor visualisiert werden.

+

+# Sprachsteuerung einschalten

+

+## Spracherkennung starten

+

+Die Spracherkennung läuft über das Skript in `/home/pi/smart-home/spracherkennung/`. Das kann man entweder von Hand starten:

+```

+python3 /home/pi/smart-home/spracherkennung/spracherkennung.py -r 48000 --model /home/pi/vosk-api/python/example/model/ -s https://localhost:3030

+```

+Oder den user-level service starten (und später mit `stop` statt `start` stoppen), dann läuft der im Hintergrund:

+```

+systemctl --user start spracherkennung

+```

+

+Das geht per SSH, oder wenn man den rechten Monitor einschaltet, an den smart-home-server Tastatur und Maus anschließt, ein neues Terminal-Fenster öffnet (oben links in der Menüleiste auf dem Desktop) und einen der obigen Befehle eingibt.

+

+Was das Mikrofon aufnimmt ist auf der Smart Home Control Oberfläche unter `Details anzeigen` bei Mikrofon, wenn das Mikrofon an ist.

+

+## Lichtsteuerung starten

+

+Auf smart-home-server neues Terminalfenster öffnen und

+```

+node /home/pi/Desktop/nodejs-server/server.js

+```

+eingeben. Sollte einen Prozess starten, der unter anderem die Anzeige "Sprachsteuerung hat PID … " ausgibt.

+

+## Sprachsteuerung benutzen

+

+Die Sprachsteuerung sollte unter anderem auf die Befehle "mach das Küchenlicht an", "mach das Küchenlicht aus", "mach die Stehlampe an", "mach die Stehlampe aus" reagieren. Hinweis: Den Befehl "mach das Licht an" versteht sie derzeit nicht; man muss angeben, welches Licht.

+

+# Kamera einschalten

+Wenn der Raspi für die Kamera an ist, sollte das zugehörige Skript automatisch starten und sich mit dem Smart Home Control verbinden. Dazu gibt es einen Service in `/etc/systemd/system/camera.service`.

+

+Von Hand kann man die Kamera starten/stoppen/etc. mit:

+```

+# (Neu)starten

+sudo systemctl restart camera

+# Stoppen

+sudo systemctl stop camera

+# Status anzeigen

+sudo systemctl status camera

+```

+Die Einrichtung der ganzen Dienste und Software auf den Raspis geht einfach mit Ansible (siehe [Ansible](Ansible)). Hier geht es darum, wie man die Raspis dazu erstmals vorbereitet, dass man im weiteren mit Ansible arbeiten kann.

+

+Das Aufspielen vom Betriebssystem geht ganz einfach mit dem Tool [Raspi Imager](https://www.raspberrypi.com/software/) (Paket: `rpi-imager`):

+

+

+

+**1. Betriebssystem auswählen:**

+

+

+

+**2. SD Karte auswählen:**

+

+

+

+**3. Erweiterte Einstellungen öffen:** (Zahnradsymbol)

+

+

+

+Hier gibt es eventuell anzupassen:

+- Den Hostname (Wird über Ansible evtl. nochmal geändert, aber es hilft schon mal, den Raspi im lokalen Netz erkennen zu können),

+- Passwort oder SSH-Key. Man kann auch erstmal die Anmeldung mit Passwort einrichten, und dann später den SSH Key draufspielen. Spätestens für Ansible braucht man dann aber ein SSH Key. Wichtig ist dabei, dass es am Schluss einen User *pi* gibt, der root Rechte hat.

+

+**4. Image aufspielen** mit Klick auf `Write`.

+# Installation

+Der Sensor ist ein Reed Schalter, das heißt es gibt einem Magneten, der am Fenster befestigt wird, und ein Sensor, der an der Wand / am Fensterrand fest gemacht wird. Man kann den Schalter im Prinzip direkt an den Raspberry Pi anschließen, aber zur Sicherheit ist aktuell noch ein 2,2kOhm widerstand dazwischen, um einen Kurzschluss zu vermeiden, falls man mal aus Versehen den entsprechenden Pin als Output setzen würde.

+

+# Auslesen

+Angeschlossen ist die eine Seite auf GND, die andere an [BCM Pin 26 (Physischer Pin 37)](https://pinout.xyz/pinout/pin37_gpio26). Der Pin wird als Pull-Up konfiguriert, das heißt wenn der Kontakt offen ist (Fenster offen), ließt man eine 1, und wenn der Kontakt zu ist eine 0. Der Code dazu, der das an den `smart-home-server` überträgt liegt in `sensors/window` und ist auf dem Raspi als User-level Service eingerichtet. Das heißt man kann ihn starten/stoppen mit:

+

+```bash

+systemctl --user start/stop window-sensor

+```

+

+Die Service Datei liegt in `~/.config/systemd/user/window-sensor.service`.

+

+# Daten

+Der Sensor schreibt in den Kanal `fenster` folgendes Objekt:

+```js

+{

+ offen: true / false / null

+}

+```

+`null` bedeutet, dass noch nicht bekannt ist, ob des Fenster offen, oder der Kontakt einfach nicht am Raspi verbunden ist. Nur wenn der Kontakt zu ist, kann man sicher davon ausgehen, dass was verbunden ist. Das heißt falls man den `window-sensor` service neustartet, während das Fenster offen ist, muss man es einmal schließen, damit da `true` oder `false` steht.

+Der smart-home-control Server ist aus Sicherheitsgründen nur sehr eingeschränkt von außen zu erreichen. Trotzdem sollen bestimmte Funktionlitäten, wie zum Beispiel Push-Benachrichtigungen oder Alexa Anbindung möglich sein. Außerdem muss intern auch HTTPS verfügbar sein (idealerweise nicht selbst-signiert, weil das auf allen Geräten eingerichtet werden müsste). Die Seite hier beschreibt, wie das funktioniert und eingerichtet wird.

+

+# 0. Allgemeine Funktionsweise

+Die beteiligten Server sind:

+- Der smart-home-control Raspi, der nur aus dem Smart-Home LAN vollständig erreichbar ist. Aus dem MWN kann man sich (via Portfreigabe auf der FritzBox) per SSH verbinden. Von ganz außen geht keine Verbindung.

+- Der teachtum40 Server, der aus bestimmten MWN Adressen SSH Verbindungen erlaubt, von ganz außen aber nur HTTP(S).

+

+Verbindungen von außen nimmt also der teachtum40 Server per HTTPS entgegen. Jeder Client, der sich darüber per Socket.io verbindet, muss ganz am Anfang ein Token schicken (`sio.emit("login", "<token>")`), damit er Zugriff auf die smart-home-control API bekommt. Je nach Token lässt sich konfigurieren, welche spezifischen Zugriffe erlaubt sind.

+

+Das Token bekommt der Client entweder aus dem internen Netz (dazu ruft er `https://smart-home-internal.teachtum40.../token` ab (tbd)), oder er hat es woanders her. Zum Beispiel könnte man es in URLs / scannbare QR-Codes einbetten.

+

+# 1. Zertifikat-Forwarding

+Damit der Smart-Home-Server Let's Encrypt Zertifikate erhalten kann, obwohl er nicht von außerhalb des MWN ereichbar ist, werden die Zertifikate vom teachtum40 Server generiert, und mithilfe eines Post-Hooks per SCP an den smart-home-server übertragen.

+

+## Einrichtung der SCP-Übertragung

+Damit wirklich _nur_ die Übertragung des Zertifikats möglich ist, wird für den teachtum40 Server ein eigenes SSH Keypair generiert (auf dem teachtum40 Server):

+

+```bash

+ssh-keygen -t ed25519 -b 4096 -C "certificate-forwarder@digillab" -f id_ed25519_cert_forwarder

+```

+

+Das neue Keypair wird als `id_ed25519_cert_forwarder(.pub)` gespeichert.

+

+Auf dem Smart Home Server kann man jetzt einen Zielordner erstellen, an den der teachtum40 Server hinkopieren kann:

+```bash

+sudo mkdir /srv/from-teachtum40

+sudo chown pi:pi /srv/from-teachtum40

+```

+

+Dann fügt man den Public Key von Forwarder (`id_ed25519_cert_forwarder.pub`) auf dem Pi hinzu:

+```bash

+echo 'from="138.246.225.122,2001:4ca0:800::8af6:e17a",restrict,command="scp -r -v -t /srv/from-teachtum40/" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAICCHnczUZaDTfj/2muKX4A32fsGsq8LH3DzC7Du4UfFz certificate-forwarder@digillab' >> ~/.ssh/authorized_keys

+```

+(Public Key und IP Adressen ggf. ändern)

+

+Durch Angabe der IPs kann der Key nur für Verbindung von der gegebenen IP Adresse verwendet werden.

+

+Mit dieser Konfiguration kann der teachtum40 Server jetzt Dateien in das oben erstellte Verzeichnis kopieren:

+```bash

+scp -i /pfad/zu/id_ed25519_cert_forwarder -o StrictHostKeyChecking=no lokale-datei-zum-kopieren.txt pi@10.162.111.146:

+```

+(IP Adresse ggf. ändern)

+

+Falls ein Fehler kommt, dass die Berechtigungen für den private Key zu locker sind, kann man das einschränken mit:

+```bash

+chmod u=rw,g=,o= id_ed25519_cert_forwarder*

+```

+

+## Certbot Post-Hook

+Zum Schluss richtet man noch den Post-Hook ein. Dazu gibt man das neue Zertifikat den root user, unter dem der renewal läuft (in `/etc/cron.d/certbot`):

+```bash

+sudo cp id_ed25519_cert_forwarder* /root/

+```

+

+Und erstellt eine Datei `/etc/letsencrypt/renewal-hooks/deploy/forward_certificate.sh` mit dem Inhalt:

+```bash

+#!/bin/bash

+scp -q -r -i /root/id_ed25519_cert_forwarder -o StrictHostKeyChecking=no /etc/letsencrypt/live/<die-domain>.de pi@10.162.111.146: > /dev/null 2>&1

+```

+(Domain und IP ggf. ändern)

+

+Bei der Ersteinrichtung des Zertifikats muss man das Skript einmal von Hand laufen lassen:

+```bash

+sudo /etc/letsencrypt/renewal-hooks/deploy/forward_certificate.sh

+```

+

+# 2. Port-Forwarding (für den Socket.io Server)

+Auf die gleiche Art wie das Zertifikat-Forwarding, lässt sich ein Port-Forwarding einrichten, bei dem sichergestellt wird, dass das nur für den teachtum40 Server möglich ist. Deswegen hier etwas abgekürzt:

+

+Auf teachtum40:

+```bash

+ssh-keygen -t ed25519 -b 4096 -C "port-forwarder@digillab" -f id_ed25519_port_forwarder

+sudo cp id_ed25519_port_forwarder* /root/

+

+# Public Key lesen und kopieren:

+cat id_ed25519_port_forwarder.pub

+```

+

+Auf dem smart-home-control:

+```bash

+echo 'from="138.246.225.122,2001:4ca0:800::8af6:e17a",restrict,port-forwarding,permitopen="localhost:3030",command="sleep infinity" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINgFE3nxYE/GEtwltRsa81/DuWDbeUXM7Y9Q+S0vFjaT port-forwarder@digillab' >> ~/.ssh/authorized_keys

+```

+

+Zum Schluss den Service dazu auf teachtum40 einrichten:

+```bash

+sudo vim /etc/systemd/system/smart-home-forwarder.service

+```

+und befüllen mit:

+```ini

+[Unit]

+Description=Port forwarding SSH script

+After=network.target

+StartLimitIntervalSec=0

+

+[Service]

+Type=simple

+Restart=always

+RestartSec=1

+ExecStart=/usr/bin/ssh -v -i /root/id_ed25519_port_forwarder -o StrictHostKeyChecking=no -L 3031:localhost:3030 pi@10.162.111.146 dummy-cmd

+

+[Install]

+WantedBy=multi-user.target

+```

+Und dann:

+```bash

+sudo systemctl enable smart-home-forwarder

+sudo systemctl start smart-home-forwarder

+```

+## Kurzfassung

+

+Der Raspberry Pi `smart-home-server` ist per ssh und vnc unter `10.162.111.146` erreichbar. Für ssh-Zugriff muss der Zugreifende im MWN sein und seine öffentlichen Schlüssel auf `smart-home-server` hinterlegt haben. Für vnc-Zugriff muss der Zugreifende per TUM-VPN verbunden sein und sich per Passwort anmelden (Passwort hat JS). Dabei muss der VNC Viewer von RealVNC verwendet werden.

+

+## Konfiguration Router

+

+Auf der Fritz Box im Smart Home werden die Ports 22 (ssh) und 5900 (vnc) an `smart-home-server` weitergeleitet. Dieser hat bei der Fritz Box die feste IP `192.168.178.24`; die Fritz Box allerdings hat keine feste IP im MWN. Sie bekommt für gewöhnlich `10.162.111.146`.

+

+## Konfiguration `smart-home-server`

+

+### ssh

+

+ssh-Zugriffe sind nur über hinterlegten public key erlaubt, nicht über Passwort.

+

+### vnc

+

+VNC akzeptiert nur verschlüsselte Verbindungen (schwächt man in den Optionen des RealVNC Servers auf dem Raspberry Pi unter "Sicherheit" die Einstellung "Verschlüsselung: immer aktiviert" ab, so kann man auch andere als den RealVNC Viewer verwenden). Der IP-Range akzeptierter eingehender Verbindungen ist auf [TUM-VPN](https://doku.lrz.de/display/PUBLIC/VPN-Technik#VPNTechnik-VPN:IP-AdressenundSubdomains:neueBereicheseit2020-03!) beschränkt; auch innerhalb des MWN muss man daher das VPN verwenden. Falls es mal scheitert: Adress-Tabellen überprüfen. (Stand 2022-03: Aus Faulheit sind nur die IP Ranges freigegeben, die auch auf `tuedfed-tat40web.srv.mwn.de` vom LRZ eingestellt wurden, und nicht alle in der LRZ Doku aufgelisteten Ranges)

+

+### X2Go

+

+Nachdem VNC manchmal etwas langsam aus der Ferne ist, lauft aktuell auch [X2Go](https://wiki.x2go.org/doku.php) auf dem smart-home-control. X2Go verbindet sich über SSH. Damit ist keine weitere Portfreigabe nötig. Anders als VNC erstellt man mit X2Go aber eine neue LXDE Desktop Sitzung (zu konfigurieren in X2Go Client), und sieht damit nicht, was auf dem Bildschirm vor Ort zu sehen ist. Somit stört man zwar das lokale Display nicht, verursacht aber möglicherweise extra Last auf dem Raspi. Damit eher besser vermeiden, wenn das Smart Home gerade aktiv verwendet wird.

+

+Ein eigenen Chrome kann man starten mit:

+

+```bash

+#mkdir /tmp/chrome2

+chromium-browser --user-data-dir=/tmp/chrome2/

+```

+# Hardware

+

+## Funksteckdose

+

+Kleinen Deckel aufschrauben, anhand der ersten fünf Ziffern einen Hauscode einstellen (Bsp: 25, d. h. 2 und 5 nach oben, 1, 3, 4 nach unten) und dann genau einen Buchstaben auswählen (Bsp: A nach oben, Rest nach unten)

+

+## 433MHz-Sender auf Raspberry Pi

+

+Sender braucht 5,5V auf VCC (mittlerer Kontakt), Erde auf Ground und einen GPIO auf Data. Am Einfachsten verbindet man Data mit dem physischen Pin Nr. 11 auf dem Raspi 4, was aus Gründen GPIO Nr. 17 ist (siehe https://cdn.mos.cms.futurecdn.net/kSo96fYwdrfQKSvALMKqzc.png) und jedenfalls dem Default

+```

+int pin = 0;

+```

+in Z. 49 von raspberry-remote/send.cpp entspricht. Falls der physische Pin 11 belegt sein sollte, muss diese Zeile entsprechend der Wiring Pi Nummerierung verändert werden, siehe hierzu http://wiringpi.com/pins/

+

+# Software

+

+## Wiring Pi

+

+Wiring Pi ist auf Raspian schon vorinstalliert, siehe http://wiringpi.com/download-and-install/

+Aber update nötig (http://wiringpi.com/wiringpi-updated-to-2-52-for-the-raspberry-pi-4b/):

+

+```

+cd /tmp

+wget https://project-downloads.drogon.net/wiringpi-latest.deb

+sudo dpkg -i wiringpi-latest.deb

+```

+

+Prüfen mit:

+```

+gpio -v

+```

+sollte 2.52 sein

+

+Übrigens: WiringPi-Entwickler hat keinen Bock mehr, also letzte Version. (http://wiringpi.com/wiringpi-deprecated/)

+

+## Raspberry Remote

+

+```

+cd ~

+sudo git clone git://github.com/xkonni/raspberry-remote.git

+cd raspberry-remote

+sudo make send

+```

+

+# Benutzung

+

+Nun ist obige Funksteckdose (mit der Schalterstellung 25A) einschaltbar durch

+```

+cd ~/raspberry-remote

+sudo ./send 01001 1 1

+```

+und ausschaltbar durch

+```

+sudo ./send 01001 1 0

+```

+Syntax: .send [Hauscode, d. h. 0 für nicht gewählte Ziffer und 1 für gewählte Ziffer] [1 für A, 2 für B…] [1 für an, 0 für aus]

+# Übersicht

+

+<table>

+<tr>

+<th>Sensor</th>

+<th>Bild</th>

+<th>Beschreibung</th>

+</tr>

+<tr>

+<td>Sensorboden (SensFloor)</td>

+<td>

+

+</td>

+<td>

+

+Der Sensorboden erkennt, wo sich Personen befinden, und ob sie gestürzt sein könnten. Das Prinzip dahinter ist genau das gleiche wie bei einem Touchscreen auf dem Handy, nur in groß.<br>Die Kacheln erkennen mittels Kapazitätssensoren, ob sich etwas leitfähiges in der Nähe befindet. Holzmöbel stellen somit kein Problem dar. Für statische, metallische Gegenstände kann eine Kalibration durchgeführt werden, sodass am Schluss im Idealfall nur Menschen oder ein rutschiger Boden (Wasser) erkannt werden.

+</td>

+</tr>

+

+<tr>

+<td>Sturzkamera</td>

+<td>

+

+

+</td>

+<td>Die Sturzkamera kann ein Foto machen, wenn ein Sturz erkannt wurde. Damit können Angehörige wissen, ob tatsächlich etwas passiert ist, oder es ein Fehlalarm war.</td>

+</tr>

+

+<tr>

+<td>Mikrofon</td>

+<td>

+

+</td>

+<td>Das Mikrofon erlaubt es, auf einfache Sprachbefehle zu reagieren. Zum Beispiel kann so das Küchenlicht ein- und ausgeschaltet werden. Die Verarbeitung der Sprache passiert dabei ausschließlich lokal.</td>

+</tr>

+<tr>

+<td>Fenstersensor</td>

+<td>

+

+

+</td>

+<td>

+

+Der Fenstersensor besteht aus einem einfachen Magnetsensor, der erkennen kann, ob das passende, am Fenster befestigte, Gegenstück da ist (Fenster zu) oder nicht (Fenster offen).

+

+Öffnet man das Fenster, schaltet die Heizung automatisch runter, um keine Energie zu verschwenden. Schließt man es wieder stellt sich das Thermostat wieder auf den vorigen Wert.

+</td>

+</tr>

+<tr>

+<td>smartes Thermostat</td>

+<td>

+

+</td>

+<td>Das smarte Thermostat (Modell Shelly TRV) ist aktuell an einem 3D-gedruckten Fake-Ventil befestigt (sonst funktioniert es nicht). Es kann sowohl selbst auf eine gewünschte Temperatur regeln (automatischer Modus), oder auf einen bestimmten prozentualen Öffnungswert (manueller Modus).</td>

+</tr>

+<tr>

+<td>Kühlschrank</td>

+<td>

+

+

+</td>

+<td>Der Kühlschrank hat drei kleine Kameras und einen Abstandssensor eingebaut, der den Öffnungswinkel misst. Kurz bevor man den Kühlschrank schließt, machen die Kameras ein Foto vom Inneren, sodass z.B. die Familie oder eine Haushaltshilfe von unterwegs nachsehen kann, was noch da ist.</td>

+</tr>

+<tr>

+<td>Umgebungssensor</td>

+<td>

+

+</td>

+<td>

+

+Der Umgebungssensor (Modell Aeotec Multi Sensor 6) kann Temperatur, Feuchtigkeit, Helligkeit, UV-Index, Erschütterungen und Bewegung messen. Die Messwerte für die ersten vier Funktionen werden auf dem Dashboard gezeigt.<br>Erschütterungsmessungen sollen (laut Hersteller) dazu helfen, zu erkennen, ob der Sensor absichtlich oder unabsichtlich entfernt wurde oder heruntergefallen ist.

+</td>

+</tr>

+<tr>

+<td>smarte Steckdosen ("Shellies")</td>

+<td>

+

+

+</td>

+<td>Die smarten Steckdosen können über das lokale Netzwerk geschalten werden, und je nach verbautem Modell auch den Stromverbrauch messen. Auf diese Art wird zum Beispiel das Küchenlicht geschalten.</td>

+</tr>

+<tr>

+<td>Wärmekamera</td>

+<td>

+

+</td>

+<td>Die Wärmekamera bietet eine möglichkeit die Anwesenheit von Personen und eventuelle Stürze zu erkennen, ohne so sehr in die Privatsphäre einzugreifen wie eine normale Kamera. Die Auflösung ist auf 32x24 Pixel begrenzt.</td>

+</tr>

+</table>

+

+Beispielfoto der Sturzkamera:

+

+

+Um bestimmte Prozesse wie die Anmeldung, die bei allen Gerätesteuerungen gleich sind, zu vereinfachen, gibt es eine Art kleine JavaScript und Python 'Bibliothek'. So wird es etwas einfacher, eine Gerätesteuerung für ein neues Gerät zu schreiben. In diesem Artikel werden die Bibliotheken beschrieben. Die JS und Python Versionen sind ähnlich aufgebaut, werden aber etwas unterschiedlich verwendet.

+

+#### Init

+

+Besonders für die Gerätesteuerungen ist, dass sie sich mit einem Gerätenamen anmelden. Pro Gerätename kann sich nur ein laufendes Skript anmelden, um sich bei den Daten in den Kanälen nicht in die Quere zu kommen. Das ist ein Problem beim Kühlschrank, da dort mehrere Skripte (mehrere Raspis) laufen, die aber alle den Kühlschrank Kanal verwenden. Aus diesem Grund kann der Gerätename z.B. als `kuehlschrank.kameras.innen` angegeben werden. Dann wird der Kanal `kuehlschrank` verwedet, aber Daten werden immer geschrieben in:

+

+```javascript

+{ // Kanal `kuehlschrank`

+ "kameras": {

+ "innen": { /* Daten hier */ }

+ }

+}

+```

+

+# Python

+

+```python

+# Threads sind nicht zwingend notwendig, aber praktisch falls es sich

+# um ein Skript mit Main-Loop handelt.

+from threading import Event, Thread

+exit_event = Event()

+

+# Import: Die Datei liegt in `geraete/interface.py` und kann so von Gerätesteuerungen

+# in einem Unterordner davon importiert werden

+import sys

+sys.path.append("..")

+import interface as smart_home

+

+@smart_home.init("fenster")

+def init(_config):

+ # ... Initialisierung alle Variablen anhand der Config, die

+ # hier mitgegeben wird. Diese Funktion muss als einziges immer

+ # vorhanden sein.

+

+

+@smart_home.on_quit

+def on_quit():

+ # ... Code, der ausgeführt werden soll oder muss, wenn das Skript

+ # beendet werden soll (z.B. beim Reset). Zum Beispiel kann hier

+ # ein Event ausgelöst werden, das einen parallelen Thread stoppt: