projekt.tex

\documentclass[../mainDocument.tex]{subfiles}

\begin{document}
	\section{Projekt}

	\subsection{Ordnerstruktur}
	\begin{figure}[!ht]
	\caption{Ordnerstruktur}
	\dirtree{%
	.1 catkin\textunderscore ws.
	.2 src.
	.3 NetworkingLib \DTcomment{Library, um TCP und UDP zu nutzen}.
	.3 PC \DTcomment{Programm des Steuerrechners}.
	.3 PC2CarLib \DTcomment{Kommunikation zwischen Steuerrechner und Fahrzeug}.
	.3 PCGui \DTcomment{Grafische Nutzeroberfläche}.
	.3 PlatoonProtocolLib \DTcomment{Kommunikation zwischen den Fahrzeugen}.
	.3 VeloxProtocolLib \DTcomment{Mavlink Kommunikation, Fahrzeugsteuerung}.
	.3 wiringPi \DTcomment{Library für PIN basierten GPIO Zugriff}.
	.3 car \DTcomment{Fahrzeugmodule}.
	.4 include.
	.5 camera.
	.5 environment.
	.5 exceptions.
	.5 lanekeeping.
	.5 logging.
	.5 mainNode.
	.5 mavLink.
	.5 ultrasonic.
	.4 launch.
	.4 msg.
	.4 plugins.
	.4 src.
	.5 camera.
	.5 environment.
	.5 lanekeeping.
	.5 logging.
	.5 mainNode.
	.5 mavLink.
	.5 ultrasonic.
	.4 test.
	}
	\end{figure}

	\subsection{Setup}
In diesem Abschnitt werden die Schritte beschrieben, um die Fahrzeuge vollständig einzurichten. Auf das Speichermodul, die eMMC, muss das Betriebssystem Ubuntu 16.04 LTS gespielt werden. Das WLAN (eduroam) muss eingerichtet werden, um grundlegende Tools wie vim und git und die ROS Software Bibliotheken/Werkzeuge zu installieren und die Repositories der Gruppen zu klonen. Auf das Steuerungsmodul, dem STM, muss Software aufgespielt werden um Fahrbefehle des ODROIDS umzusetzen und Daten an dieses zuliefern.

\subsubsection{ODROID und Ubuntu}
Um das ODROID nutzen zu können, müssen wir das Betriebssystem Ubuntu 16.04 LTS installieren. Dazu benötigen wir einen Computer, die eMMC und einen microSD-Adapter.
\begin{figure}[h]
\centering
\begin{minipage}{.4\textwidth}
  \centering
  \includegraphics[width=2cm]{emmc}
  \captionof{figure}{ODROID-XU3/XU4 eMMC 5.0 Modul, 32 GB}
  \label{fig:test1}
\end{minipage}%
\hfill
\begin{minipage}{.4\textwidth}
  \centering
  \includegraphics[width=2cm]{emmcAdapter}
  \captionof{figure}{eMMC/microSD Kartenleser-Adapter}
  \label{fig:test2}
\end{minipage}
\end{figure}\\
Eine Anleitung zur Installation von Ubuntu auf dem ODROID XU4 gibt es hier:
\url{https://scroom.de/ubuntu-16-04-lts-auf-dem-odroid-xu4-installieren/}

Als Erstes muss man die eMMC mittels microSD-Adapter an einen Computer anschließen und formatieren.

Dann muss man die für das ODROID passende Ubuntu-Distribution von Hardkernel herunterladen:
\url{https://wiki.odroid.com/odroid-xu4/os_images/linux/ubuntu/ubuntu}

Dieses Image entpacken:

\lstinline{unxz ubuntu-16.04.3-4.14-minimal-odroid-xu4-20171213.img.xz}

Um nun Ubuntu auf das eMMC zu flashen, benutzt man am besten Etcher. Alternativ kann man diesen Vorgang auch mit Konsolenbefehlen durchführen. Diese findet man in der oben angegebenen Anleitung.
Für Linux Systeme gibt es Etcher als .AppImage Datei:\\
\url{https://etcher.io}

Um diese auszuführen:
\begin{enumerate}
\item Das AppImage ausführbar machen:

\lstinline{chmod a+x etcher-1.3.1-x86_64.AppImage}
\item Das Programm ausführen:

\lstinline{./etcher-1.3.1-x86_64.AppImage}
\end{enumerate}
Dann wählt man das Ubuntu Image und die eMMC aus. Dann führt Etcher den Flashvorgang inklusive Validierung durch. Dann ist es möglich, vom Computer aus auf das Dateisystem auf der eMMC zuzugreifen. Skripte oder andere Dateien, die man zur Einrichtung des ODROIDs benötigt oder die die Einrichtung erleichtern, kann man also schon an dieser Stelle auf die eMMC übertragen.
Anschließend kann man die eMMC vom Computer trennen und an das ODROID anschließen.
Dann sollte es booten.


Standardmäßig kann man sich mit dem Nutzernamen \textit{root} und dem Passwort \textit{odroid} anmelden.
Um das Passwort zu ändern, führt man den folgenden Befehl aus:

\lstinline{sudo passwd}

Für das Semesterprojekt lautet das Passwort bei jedem fertig eingerichteten ODROID \glqq autonom1718\grqq.

\subsubsection{WLAN (eduroam)}
Um eine WLAN-Verbindung herzustellen, benötigt man einen WLAN-Stick oder ein WLAN-Modul. Wir gehen an dieser Stelle davon aus, dass diese nach dem Plug-and-Play-Prinzip funktionieren und hier keine Einrichtung nötig ist.
Man kann mittels \lstinline{ifconfig} und \lstinline{iwconfig} überprüfen, ob die WLAN-Schnittstelle vorhanden ist und wie sie heißt. Wir gehen von nun an davon aus, dass die Schnittstelle \textit{wlan0} heißt. Andernfalls muss man den Namen der Schnittstelle im Folgenden immer anpassen.

Der herkömmliche Weg, wie man sich mit einem WLAN-Netzwerk verbindet:
\begin{enumerate}
\item Mittels \lstinline{ifconfig wlan0 up} die WLAN-Karte anschalten.
\item Mit \lstinline{iwconfig wlan0 essid name key password} mit dem Netzwerk verbinden. Ersetze \textit{name} dem Namen des Netzwerks, \textit{password} mit dem Sicherheitsschlüssel des Netzwerks.
\item Mit \lstinline{dhclient wlan0} eine IP Adresse erhalten und mit dem WLAN- Netzwerk verbinden.
\end{enumerate}
Die WLAN-Verbindung kann man mittels \lstinline{iwconfig} und \lstinline{ping www.hu-berlin.de} über{-}prüfen.


Um sich mit dem eduroam zu verbinden, sind andere Schritte nötigt. Die Einrichtung wird in der folgenden Anleitung ausführlich beschrieben:\\
\url{https://www.cms.hu-berlin.de/de/dl/netze/wlan/config/eduroam/linux/eduroam-linux-wpa_supp.pdf}

Für die Einrichtung sind zwei Dateien nötig:
\begin{enumerate}
\item \href{http://www.cms.hu-berlin.de/dl/netze/wlan/config/eduroam/deutsche-telekom-root-ca-2.crt}{\texttt{deutsche-telekom-root-ca-2.crt}}
\item \href{http://www.cms.hu-berlin.de/dl/netze/wlan/config/eduroam/linux/wpa_supplicant.conf}{\texttt{wpa\_supplicant.conf}}
\end{enumerate}
Am besten lädt man diese Dateien mit einem anderen Computer herunter und kopiert diese (z.B. nach dem Flashvorgang) auf das ODROID. Ansonsten kann man die Dateien auf einen USB-Stick kopieren und diese auf das ODROID übertragen. Um auf den USB-Stick zuzugreifen, führt man folgende Schritte durch:
\begin{enumerate}
\item Mit \lstinline{lsblk} herausfinden, wie der USB-Stick heißt. Die Partition sollte in etwa so aussehen wie \lstinline{/dev/sdb1}.
\item Mit \lstinline{sudo mkdir /media/usb} einen Mount Point (Einhängepunkt) erstellen.
\item Mit \lstinline{sudo mount /dev/sdb1 /media/usb} mounten. Über den Ordner \lstinline{/media/usb} kann man nun auf die Dateien im USB-Stick zugreifen.
\item Mit \lstinline{sudo umount /media/usb} unmounten, wenn man nicht mehr länger auf den USB-Stick zugreifen will.
\end{enumerate}
Alternativ lädt man die Dateien mittels \lstinline{curl} oder \lstinline{wget} vorher mit einer WLAN-Verbindung zu Hause oder via Hotspot herunter. Z.B.:
\begin{itemize}
\item \lstinline{wget http://www.cms.hu-berlin.de/dl/netze/wlan/config/eduroam/deutsche-telekom-root-ca-2.crt}
\item \lstinline{curl -O http://www.cms.hu-berlin.de/dl/netze/wlan/config/eduroam/linux/wpa_supplicant.conf}
\end{itemize}
In jedem Fall muss man die zwei Dateien in den \lstinline{/etc/wpa_supplicant} Ordner bewegen (oder mit \lstinline{cp} kopieren). Dabei muss \lstinline{/path/to} durch den entsprechenden Pfad zu den Dateien ersetzt werden.
\begin{itemize}
\item \lstinline{sudo mv /path/to/deutsche-telekom-root-ca-2.crt /etc/wpa_supplicant/}
\item \lstinline{sudo mv /path/to/wpa_supplicant.conf /etc/wpa_supplicant}
\end{itemize}
Nun muss man \lstinline{wpa_supplicant.conf} bearbeiten. Am einfachsten ist es, diese Datei schon vorher auf einem Computer zu bearbeiten. Ansonsten muss man \lstinline{vi /etc/wpa_supplicant/wpa_supplicant.conf} ausführen. Außer \lstinline{vi} ist standardmäßig kein anderer Editor auf dem ODROID installiert. Ansonsten kann man sich schon vorher via Hotspot oder zu Hause mittels \lstinline{sudo apt install vim} den Editor \lstinline{vim} installieren. Hier ist eine Anleitung, wie man \lstinline{vi} verwendet:\\
\url{https://www.suse.com/de-de/documentation/sles10/book_sle_reference/data/sec.suse.vim.html}.

In der \lstinline{wpa_supplicant.conf} muss man \textit{YourNameHere} durch die HU E-Mail Adresse ersetzen, also etwas wie \textit{foobar@informatik.hu-berlin.de}. \textit{YourPasswordHere} kann man durch das entsprechende Passwort ersetzen. Allerdings steht das Passwort in der Datei als Klartext und ist für jeden sichtbar, der auf die Datei als root User zugreifen kann. Alternativ kann man die Passwortzeile löschen oder auskommentieren. Dann muss man das Passwort jedes Mal eingeben, wenn man sich mit eduroam verbinden will.

Um die Verbindung zu testen, führt man nun folgende Befehle aus:
\begin{enumerate}
\item \lstinline{sudo service network-manager stop}, um eventuelle automatische Konfigurationsversuche zu vermeiden
\item \lstinline{sudo wpa_supplicant -i wlan0 -D wext -c /etc/wpa_supplicant/wpa_supplicant.conf -d}
\end{enumerate}
Falls die Passwortzeile gelöscht wurde, muss man nun in einer neuen Konsole Ctrl+Alt+F2
\lstinline{sudo wpa_cli} ausführen. Nach kurzer Zeit sollte eine Zeile angezeigt werden, die sagt, dass für eduroam ein Passwort nötig ist. Dann gibt man \lstinline{password 0 YourPassword} ein, wobei \textit{YourPassword} durch das entsprechende HU Passwort ersetzt werden muss. Falls die Eingabe akzeptiert wird, dann sollte eine Zeile angezeigt werden, die sagt, dass die Verbindung erfolgreich war. Aus diesem interaktiven Modus kommt man mittels \lstinline{q} heraus.
Nun kann man die WLAN-Verbindung wie zuvor mittels \lstinline{iwconfig} oder \lstinline{ping www.hu-berlin.de} überprüfen. Falls dies noch nicht funktioniert, führt man noch folgende Befehle aus, um eine neue IP Adresse zu erhalten und sich mit dem WLAN-Netzwerk zu verbinden.:
\begin{enumerate}
\item \lstinline{dhclient wlan0 -r}
\item \lstinline{dhclient wlan0}
\end{enumerate}

Um die Änderungen permanent zu machen, bearbeiten wir \lstinline{/etc/network/interfaces}. Die Einstellungen für das WLAN-Interface sollten wie folgt aussehen:
\begin{lstlisting}
auto wlan0
iface wlan0 inet dhcp
wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf
\end{lstlisting}
Beim nächsten Hochfahren des ODROIDs muss man, falls die Passwortzeile gelöscht wurde, den Befehl \lstinline{sudo wpa_cli} ausführen und wie zuvor beschrieben das Passwort eingeben, um sich mit dem eduroam zu verbinden. Für das Kolonnenfahren ist es unvermeidbar, das Passwort direkt in die Konfigurationsdatei zu schreiben, denn sonst muss jedes ODROID mit einem Bildschirm und einer Tastatur verbunden werden, um am Anfang eingerichtet zu werden. Sonst muss man auf die AdHoc Methode zurückgreifen, bei der es allerdings nur mit sehr großem Aufwannd möglich ist, Änderungen aus dem Git Repository herunterzuladen.

Nun ist es möglich, das ODROID per \lstinline{ssh} zu steuern. Die IP-Adresse des ODROIDs erfährt man mit \lstinline{ifconfig wlan0}. Anschließend kann man sich mit \lstinline{ssh root@10.42.43.1} verbinden. Die IP-Adresse muss hier entsprechend angepasst werden. Mit \lstinline{scp} ist es außerdem möglich, Daten zu übertragen.
Bsp.: \lstinline{scp foobar.txt root@10.42.43.1:/some/remote/directory}

\subsubsection{Essentials}
Nun da das ODROID eine Internetverbindung hat, sollte man es updaten: \lstinline{sudo apt-get update && sudo apt-get upgrade && sudo apt-get dist-upgrade}

Anschließend sollte \lstinline{git} installiert werden, damit die Repositories der Gruppen mit der Software geklont werden können: \lstinline{sudo apt install git-all}

Der Befehl, um ein Repository zu klonen, sieht dann z.B. so aus:\\
\lstinline{git clone https://gitlab.informatik.hu-berlin.de/adapt/ws17-HF/Gruppe-A.git}\\
Beim Klonen, Pullen, Pushen usw. wird jedes Mal der Nutzername und das Passwort abgefragt. Alternativ richtet man sich den Zugang zum Git Repository mit einem SSH-Schlüssel ein. 
Das sollte man dann allerdings per \lstinline{ssh} mit einem Computer machen, der über eine grafische Oberfläche verfügt, da man den SSH-Schlüssel kopieren und und auf der Gitlab Website einfügen muss. Mit einigen Konfigurationsschritten\footnote{\url{https://docs.gitlab.com/ee/ssh/} \url{https://stackoverflow.com/questions/1595848/configuring-git-over-ssh-to-login-once}} ist es dann möglich, nur einmal das Passwort eingeben zu müssen. 

\subsubsection{ROS}
Für das Semesterprojekt wird ROS (Robot Operating System) verwendet. Konkret wird die ROS Version Lunar Loggerhead verwendet. Eine ausführliche Anleitung zur Installation gibt es hier: \url{http://wiki.ros.org/lunar/Installation/Ubuntu}

Es empfiehlt sich, vorher auf einem Computer (mit GUI und Browser) ein Skript mit den folgenden Befehlen vorzubereiten und dieses Skript auf auf das ODROID zu kopieren, damit man dieses nur noch ausführen muss. Ansonsten muss man die Befehle manuell eintippen.
\begin{enumerate}
\item Das ODROID so einstellen, dass er Software von packags.ros.org akzeptiert:\\
\lstinline{sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'}
\item Die Schlüssel einstellen:\\
\lstinline{sudo apt-key adv --keyserver hkp://ha.pool.sks-keyservers.net:80 --recv-key 421C365BD9FF1F717815A3895523BAEEB01FA116}
\item Den Debian Package Index aktualisieren: \lstinline{sudo apt-get update}
\item ROS-Base installieren: \lstinline{sudo apt-get install ros-lunar-ros-base}
\item \lstinline{rosdep} initialisieren:\\
\lstinline{sudo rosdep init}\\
\lstinline{rosdep update}
\item Die Umgebung einrichten, damit ROS Umgebungsvariablen automatisch zur Bash Session hinzugefügt werden:\\
\lstinline[mathescape]{echo "source /opt/ros/lunar/setup.bash" >> $\sim$/.bashrc}\\
\lstinline[mathescape]{source $\sim$/.bashrc}
\item Werkzeuge und andere Abhängigkeiten zum Bauen von ROS Packages installieren:\\
\lstinline{sudo apt-get install python-rosinstall python-rosinstall-generator python-wstool build-essential}
\end{enumerate}
Alle weiteren Schritte mit ROS werden in den ROS Tutorials beschrieben:\\
\url{http://wiki.ros.org/ROS/Tutorials}

\subsubsection{AdHoc Netzwerk}
Man kann die ODROIDs über ein gemeinsames WLAN-Netzwerk kommunizieren lassen. In einem Szenario, wo echte Autos in Kolonne fahren sollen, ist so ein WLAN-Netzwerk jedoch meist nicht vorhanden.
Für die drahtlose Kommunikation zwischen den ODROIDs verwenden wir daher ein AdHoc Netzwerk.
Dafür empfiehlt es sich, ein Skript zu erstellen.
\begin{lstlisting}
IFACE="wlan0"

sudo service network-manager stop

sudo ifconfig $IFACE down
sudo iw $IFACE set type ibss
sudo ifconfig $IFACE up

sudo iw $IFACE ibss join SPHAF 2432
sudo ifconfig $IFACE 10.42.43.1
\end{lstlisting}
Dies nennen wir \lstinline{connectAdHoc.sh}. Mittels \lstinline{chmod u+x connectAdHoc.sh} macht man das Skript ausführbar und kann es dann mit \lstinline{./connectAdHoc.sh} ausführen.
Mit \lstinline{iwconfig} kann man überprüfen, ob alles funktioniert hat.

Mit dem Skript wird ein AdHoc Netzwerk mit dem Namen \textit{SPHAF} (SemesterProjekt HochAutomatisiertes Fahren) auf dem Kanal 5 erstellt und das ODROID erhält die IP-Adresse 10.42.43.1. Für jeden Teilnehmer führt man das Skript durch. Dabei sollte jeder Teilnehmer am AdHoc Netzwerk eine eigene IP-Adresse erhalten. Die letzte Zeile sollte also für jeden Teilnehmer angepasst werden.

Nun kann man mit \lstinline{crontab}\footnote{\url{https://wiki.ubuntuusers.de/Cron/}} einstellen, dass das Skript jedes Mal direkt beim Neustart (vor dem Login-Vorgang) ausgeführt wird. Dies ist insbesondere dann hilfreich, wenn das ODROID auf dem Auto montiert ist und keine Tastatur angeschlossen ist.
Dazu muss man nun \lstinline{crontab -e} ausführen und die folgende Zeile einfügen: \lstinline{@reboot /root/connectAdHoc.sh}. Eventuell ist noch folgender Schritt nötig, um crond automatisch beim Hochfahren zu starten: \lstinline{update-rc.d cron defaults}.

Falls das AdHoc Netzwerk steht, kann man sich mittels \lstinline{ssh root@10.42.43.1} mit dem ODROID verbinden.
Bei uns kam es vor, dass das AdHoc Netzwerk gelegentlich abgestürzt ist.
In \lstinline{crontab -e} kann man dann noch folgende Zeile einfügen, um das Adhoc Netzwerk alle 2 Minuten neuzustarten bzw., das entsprechende Skript auszuführen: \lstinline{*/2 * * * * /root/connectAdHoc.sh}.

\subsubsection{STM}
Es wird nun beschrieben, wie das STM funktionstüchtig gemacht wird. Es wird zunächst die von Assystem gelieferte Software benötigt, welche mit der ARM-Toolchain kompiliert wird und anschließend von st-flash auf das Board gebracht wird.


Eine Anleitung zur Einrichtung der ARM-Toolchain auf dem STM gibt es hier: \url{https://gnu-mcu-eclipse.github.io/toolchain/arm/install/}


Als erstes wird die Datei \lstinline{gcc-arm-none-eabi-4_8-2014q2-20140609-linux.tar.bz2} benötigt, diese ist auf \lstinline{https://launchpad.net/gcc-arm-embedded/4.8/4.8-2014-q2-update} zu finden. Die Version wurde aus dem ursprünglichen makefile entnommen. Nun werden in der Konsole folgende Befehle eingegeben:
\begin{lstlisting}[mathescape]
sudo apt-get -y install lib32ncurses5
cd /opt
sudo tar xjf $\sim$/Downloads/gcc-arm-none-eabi-4_8-2014q2-20140609-linux.tar.bz2
sudo chmod -R -w /opt/gcc-arm-none-eabi-4_8-2014q2
\end{lstlisting}

Mit folgendem Befehl kann getestet werden, ob die Toolchain läuft:
\lstinline{/opt/gcc-arm-none-eabi-4_8-2014q2/bin/arm-none-eabi-gcc --version}
Die erste Zeile der erwarteten Ausgabe lautet:

\lstinline{arm-none-eabi-gcc (GNU Tools for ARM Embedded Processors) 4.8.4 20140526 (release) [ARM/embedded-4_8-branch revision 211358] ...}


Die Dateien wurden von Assystem durch Oliver Kreuzmann per Dropbox bereitgestellt. Diese waren nicht kompilierbar, da einige Dateien fehlten bzw. falsch inkludiert worden sind. Im Repository sind bereits alle Änderungen behoben.

Alle Änderungen werden im \lstinline{quellcode}-Ordner gemacht, dieser befindet sich in \lstinline{attachments/Austausch\ Assystem\ -\ HU/02_lieferung/vehicle_ecu_sw/quellcode/}.

Die Datei \lstinline{nano.specs} muss nach \lstinline{quellcode} kopiert werden:
\lstinline{cp /opt/gcc-arm-none-eabi-4_8-2014q2/arm-none-eabi/lib/nano.specs .}

Im \lstinline{makefile} wird der Pfad korrigiert:
\lstinline{/home/jenkins/ARM_GCC/2014q2/bin} wird zu \lstinline{/opt/gcc-arm-none-eabi-4_8-2014q2/bin}

Nun müssen in vielen verschiedenen Dateien die \#\lstinline{include}'s geändert werden. Welche dies sind lässt sich nach und nach einfach durch die Fehlermeldung mit \lstinline{make} herausfinden. Zum Beispiel muss in \lstinline{app/rx24fctrl/rx24fctrl.h1} in Zeile 21 \#\lstinline{include "stm32f4xx.h"} zu \#\lstinline{/ include "brd/startup/stm32f4xx.h"} werden.

Zuletzt fehlt in \lstinline{quellcode/sys} die Datei \lstinline{rtwtypes.h}, diese ist unter\\ \url{http://ecmc.rochester.edu/ecmc/docs/supercollider/scbook/Ch23_Dialects/extensions_c23_dialects/ENIAC/Eniac_Cycling%20Source%20Code/rtwtypes.h} zu finden.

Jetzt ist das Code kompilierbereit. Bei Ausführung von \lstinline{make} sollte ungefähr folgende Ausgabe erscheinen:
\begin{lstlisting}
/opt/gcc-arm-none-eabi-4_8-2014q2/bin/arm-none-eabi-gcc obj/app/rx24fctrl/src/rx24fctrl.o obj/app/main.o ...
...
/opt/gcc-arm-none-eabi-4_8-2014q2/bin/arm-none-eabi-objcopy -O binary vlx.elf vlx.bin
-e \x1b[32;01mFinished Compiling and Linking\x1b[0m
\lstinline{\end{lstlisting}

\subsubsection{st-flash}
Eine Anleitung zur Einrichtung der st-flash gibt es hier:\\
\url{https://startingelectronics.org/tutorials/STM32-microcontrollers/programming-STM32-flash-in-Linux/}


Durch folgende Befehle wird st-flash installiert:
\begin{lstlisting}[mathescape]
sudo apt-get install libusb-1.0-0-dev git
sudo apt-get install libgtk-3-dev
cd $\sim$/Git
git clone https://github.com/texane/stlink
cd stlink
make
cd build/Release
sudo make install
sudo ldconfig
\end{lstlisting}
Es kann nun entweder stlink-gui oder st-flash benutzt werden. Als erstes werden Rechner und STM per USB-to-miniUSB verbunden.

Durch Aufruf von \lstinline{stlink-gui} wird die GUI gestartet. In das Textfeld \lstinline{Goto address} muss der Wert 0x08000000 eingetragen werden. Anschließend klicken der Schaltflächen Connect, Flash und Disconnect.

Wer ein CLI bevorzugt kann auch in \lstinline{quellcode} ein \lstinline{run.sh}-Skript erstellen:
\begin{lstlisting}
make && st-flash erase && st-flash write vlx.bin 0x0800000 && st-flash reset
\end{lstlisting}

\subsection{Projekt ausführen}
\subsubsection{Anleitung}
Wenn man das Repository heruntergeladen hat (\lstinline{git clone https://gitlab.informatik.hu-berlin.de/adapt/ws17-HF/Gruppe-A.git}), muss man nun folgende Schritte ausführen, um das Projekt einzurichten und später die Autos zum Fahren zu bringen:
\begin{enumerate}
\item Das Skript, welches sich unter \lstinline{Gruppe-A/modules/catkin_ws/wiringPi} befindet, ausführen, um die wiringPi Library zu installieren: \lstinline{sudo ./build}. Falls dieser Befehl fehlschlagen sollte, muss man \lstinline{make clean} ausführen und dann noch einmal \lstinline{sudo ./build}.
\item Außerdem benötigt man noch \lstinline{opencv}. Die Installation gestaltet sich jedoch etwas schwieriger. Hier sind zwei unterschiedliche Anleitungen:
	\begin{itemize}
	\item auf \texttt{docs.opencv.org} (offiziell): \url{https://goo.gl/kZWmgt}
	\item auf \texttt{pyimagesearch.com} (Blog): \url{https://goo.gl/xu2Jqa}
	\end{itemize}
	Die Schritte sind im Grunde wie folgt:
	\begin{enumerate}
	\item Werkzeuge für die \lstinline{opencv}-Installation installieren
	\begin{lstlisting}
	sudo apt-get install build-essential
	sudo apt-get install cmake git libgtk2.0-dev pkg-config libavcodec-dev libavformat-dev libswscale-dev unzip\end{lstlisting}
	Einige der Werkzeuge sind schon mit ROS installiert worden.
	\item \lstinline{opencv} herunterladen: \lstinline{wget -O opencv.zip https://github.com/opencv/opencv/archive/3.4.1.zip}
	\item \lstinline{opencv} entpacken: \lstinline{unzip opencv.zip}
	\item \lstinline{opencv} installieren:
	\begin{lstlisting}[mathescape]
	cd $\sim$/opencv
	mkdir build
	cd build
	cmake ..
	make -j2	# als 2 Jobs\end{lstlisting}
	\end{enumerate}
\item Das Skript, welches sich unter \lstinline{Gruppe-A/modules/} befindet, ausführen, um das Projekt zu bauen: \lstinline{./build.sh}
\item Die \lstinline{setup.bash} unter \lstinline{Gruppe-A/modules/catkin_ws/devel/} sourcen: 
\begin{lstlisting}[mathescape]
echo "source $\sim$/Gruppe-A/modules/catkin_ws/devel/setup.bash" >> $\sim$/.bashrc
source $\sim$/.bashrc
\end{lstlisting}
\item Projekt starten: \lstinline{roslaunch car fullstart.launch}
\end{enumerate}
Später muss man nur noch die Schritte 3 und 5 ausführen, wobei der Schritt 3 nur dann nötig ist, falls etwas an den Bibliotheken verändert wurde.
Falls das nicht der Fall ist, sondern nur Code an anderer Stelle verändert wurde, reicht ein \lstinline{catkin_make} Befehl im \lstinline{catkin_ws} Ordner.

\subsection{ODROID des Projektes}
Tatsächlich ist die Ordnerstruktur auf den ODROIDs etwas anders. Dementsprechend müssen alle Befehle, die einen Pfad angeben, entsprechend angepasst werden.
\begin{figure}[!ht]
	\caption{Ordnerstruktur}
	\dirtree{%
	.1 root.
	.2 repos.
	.3 Hochautomatisiertes-Fahren.
	.2 ODROID\textunderscore Setup.
	}
\end{figure}
In unserem Fall wurde hauptsächlich in einem Git Repository gearbeitet, das außerhalb des Oberordners \lstinline{adapt/ws-17-HF} liegt. Dieses heißt \glqq Hochautomatisiertes-Fahren\grqq. Außerdem liegen auf den ODROIDs noch einige Setup Skripte, die für die Einrichtung verwendet wurden. Auf manchen der ODROIDs sind diese in einem Ordner namens \glqq ODROID\textunderscore Setup\grqq.

\subsection{Steuercomputer}
Auf einem Steuercomputer (Ubuntu) sind für die Benutzung der CommandGui und der MessageGui zur Ansteuerung des Autos und zum Ausgeben von Logging-Informationen noch weitere Schritte nötig.
Dazu muss man das Programm Qt installieren. Eine ausführliche Anleitung dafür gibt es auf dieser Website:\\ \url{https://wiki.qt.io/Install_Qt_5_on_Ubuntu}

Wenn man dort alle Schritte durchgegangen ist, muss man ggf. noch QtQuick.Controls nachinstallieren bzw. die Abhängigkeiten reparieren, falls dies mit dem Installer nicht korrekt passiert ist.
Das tut man mit diesem Befehl: \lstinline{sudo apt-get install qml-module-qtquick-controls}

Anschließend muss man im Projekt in den Ordner \lstinline{modules/catkin_ws/src/PCGui/PCGui} navigieren. 
Dann muss man die CommandGui und die MessageGui bauen:
\begin{lstlisting}
mkdir build
cd build
cmake ..
make
\end{lstlisting}
Nun kann man die CommandGui und die MessageGui mit \lstinline{./CommandGui} bzw. \lstinline{./MessageGui} ausführen. Um ein Auto zu steuern oder die Logging-Informationen zu erhalten, muss man die IP-Adresse des Autos bzw. des jeweiligen ODROIDs eingeben.

\subsection{Auto bauen}
Für das Fahrzeug benötigte Teile:\\

\begin{tabular}{l c}
	\underline{\textbf{Benötigtes Teil}} & \underline{\textbf{Anzahl}}\\
	Fotosensor für die Kamera            & 1\\
	Objektiv für die Kamera              & 1\\
	Objektivhalterung für die Kamera     & 1
\end{tabular}
%Reihenfolge
\subsubsection*{Kamera}
Da die Kamera in Einzelteilen geliefert wird, muss diese zuerst zusammen gebaut werden. Zu aller erst muss man sich selbst erden, da der Fotosensor hochempfindlich ist, reichen geringe statische Ströme um diesen zu beschädigen.\\
Ist dies getan, so kann von dem Fotosensor vorsichtig die Folie abgezogen werden. Direkt danach muss die Objektivhalterung über dem Fotosensor montiert werden. Dabei ist zu beachten, dass die Halterung eine kleine Kerbe hat, die in Richtung des Mini-USB-Ports des Fotosensor zeigen muss, damit die Objektivhalterung überhaupt passt. Die Objektivhalterung wird dabei mit den \textit{MISSING}-Schrauben fixiert. Im Anschluss kann das Objektiv eingeschraubt werden. Mit dem Gewinde in der Objektivhalterung kann zusätzlich noch die Schärfe und der Fokus der Kammer nachjustiert werden.\\

\includegraphics[scale = 0.05, angle =-90]{kamera-1.jpg}
\includegraphics[scale = 0.05, angle =-90]{kamera-2.jpg}
\includegraphics[scale = 0.05, angle =-90]{kamera-3.jpg}\\

Nun kann die Kamera in der Kamerahaltung festigt werden. Diese wird auch \glqq vordere Platinenhalterung\grqq\ genannt. Um die Kamera einzuschrauben werden \textit{Missing}-Schrauben verwendet.\\

\includegraphics[scale = 0.05, angle = 0]{kamera-4.jpg}
\includegraphics[scale = 0.05, angle = 0]{kamera-5.jpg}

\subsubsection*{Fahrzeug}
\begin{enumerate}
	\item[\textit{Schritt 1.}] \textbf{Gehäuse entfernen.} Zu aller erst wird das Gehäuse des Fahrzeugs entfernt. Dafür befinden sich im vorderen und hinteren Teil jeweils eine Nasenklammer. Dies muss nur herausgezogen werden und dann lässt sich das Verdeck schon abnehmen.
	\item[\textit{Schritt 2.}] \textbf{Reifen entfernen.} Zunächst müssen die Reifen entfernt werden. Diese lassen sich mit Hilfe eines \textit{MISSING}-Maulschlüssels lösen und abnehmen.
	\item[\textit{Schritt 3.}] \textbf{Radaufhängung anpassen.} Als nächstes wird die Radaufhängung angepasst. Die Schrauben werden mit einem \textit{Missing} und einfachem Kontern mit einem \textit{MISSING}-Maulschlüssel oder einer Spitzzange gelöst und entsprechend der Bild wieder neu befestigt.
	
	\includegraphics[scale = 0.05, angle = 0]{schritt3-1}
	\includegraphics[scale = 0.05, angle = 0]{schritt3-2}\\
	\includegraphics[scale = 0.05, angle = 180]{schritt3-3}		% potentiell einmal Spiegeln
	\includegraphics[scale = 0.05, angle = 180]{schritt3-4}\\
	
	\item[\textit{Schritt 4.}] \textbf{Radbefestigung tauschen.} Nun müssen die kurzen Originalbefestigungen entfernt werden. Dafür sind die Stifte mit geeignetem Werkzeug durchzudrücken um auf der anderen Seite aufzufangen. Wichtig dabei zu beachten ist, dass immer genügen Gegendruck an der Achse aufgebracht wird, da sich dort ebenfalls ein solcher Stift befindet, der nicht heraus rutschen darf.
	
	\includegraphics[scale = 0.05, angle = -90]{schritt4-1.jpg}
	\includegraphics[scale = 0.05, angle = -90]{schritt4-2.jpg}\\
	
	Sobald die alte Befestigung vom Fahrzeug entfernt wurde, kann die neue angebracht werden. Falls der Stift sich nur sehr schwergängig durch schieben lässt, kann mit einem 3mm-Bohrer nach gebohrt werden. Vorsicht, ist der Stift zu locker, wird er immer wieder herausrutschen. Auch für die Radbefestigung gilt: lässt sie sich nicht einfach genug aufstecken, so muss etwas nach geschliffen werden. Allerdings darf sie im aufgesteckten Zustand kein Spiel haben. Befindet sich die neue Radbefestigung an ihrem Platz, so wird diese mit dem zuvor entfernten Stift gesichert.
	
	\includegraphics[scale = 0.05, angle = -90]{schritt4-3.jpg}
	\includegraphics[scale = 0.05, angle = -90]{schritt4-4.jpg}\\
	
	Dieser Prozess muss an allen 4 Radbefestigungen durchgeführt werden.
	\item[\textit{Schritt 5.}] \textbf{Fahrzeug aufbocken.} Nun musst das Fahrzeug aufgebockt werden. Danach können die Plastikringe auf die Radbefestigungen geschoben werden, um die Stift an ihrem Platz zu fixieren. Im Anschluss wird die Radencoderscheibe auf die Radbefestigung geschraubt. Sie sorgt dafür, dass alles an seinem Platz bleibt und wird später den Radstand auswerten können. Insbesondere sollte die aufgeschraubte Encoderscheibe nicht den Boden berühren, wenn das Fahrzeug aufgebockt ist.\\
\end{enumerate}

\subsection{Akkus aufladen}
Die Anleitung sollte beigelegt sein, wenn nicht digital:\\
\url{https://www.robitronic.com/en/manual-robitronic-all.html?file=files/anleitungen/robitronic/LD15z-Manual_DE-EN.pdf}

\subsubsection{Lagerung}
Zum Schutz im Falle einer Fehlfunktion werden die LiPos im First-Alert-Koffer sicher gelagert. Eingepackt in Luftpolsterfolie sollten diese sich im STORAGE-Modus befinden. Falls die Akkus außerhalb des Koffers gelagert bzw. unbeaufsichtigt aufgeladen werden, sollten diese in die Schutztasche gepackt werden.

\subsubsection{Aufladen}

\begin{tabular}{l c c}
	\underline{\textbf{Benötigtes Teil}} & \underline{\textbf{Anzahl}} & \underline{\textbf{Vorhanden}}\\
	Lithium-Polymer-Akkumulator          & 1                           & 8+\\
	Expert LD 15z                        & 1                           & 2\phantom{+}\\
	Schutztasche                         & 1                           & 2\phantom{+}\\
	Netzkabel                            & 1                           & 2\phantom{+}\\
	Balancer Adapter                     & 1                           & 2\phantom{+}\\
	Ladeadapter                          & 1                           & 2+
\end{tabular}

\includegraphics[scale = 0.1]{lipo.jpg}

\begin{enumerate}
	\item Die Anordnung im Bild nachbauen. Der Akku sollte aber in die Schutztasche gepacktwerden
	\item Nach Herstellen der Stromverbindung im Menü solange Mode/Stop drücken bis das LiPo-Programm ausgewählt ist
	\item Enter/Start drücken
	\item Inc./$>$ drücken bis das BALANCE bzw. BAL-CHG Lademodus ausgewählt ist
	\item Enter/Start ca. 3s gedrückt halten
	\item Durch Drücken von Enter/Start beginnt der Lademodus. Hier wird noch mal die Zellenanzahl überprüft, es soll 2S eingestellt sein, da unsere Akkus zwei Zellen haben
	\item Der Akku lädt, warten bis es piept
	\item Akku entfernen, Netzteil entfernen
	\item Nächsten Akku laden oder alles sicher lagern
\end{enumerate}

\end{document}