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. Diese muss man 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 mittels unxz 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} überprü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.

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.

\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 HochAutonomes 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} (\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}.

\subsection{Projekt ausführen}
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 bringen will:
\begin{enumerate}
\item Das Skript, welches sich unter \lstinline{Gruppe-A/modules/} befindet, ausführen, um das Projekt zu bauen: \lstinline{./build.sh}
\item Das Skript, welches sich unter \lstinline{Gruppe-A/modules/catkin_ws/wiringPi} befindet, ausführen, um die wiringPi Library zu installieren: \lstinline{./build}
\item Unter \lstinline{Gruppe-A/modules/catkin_ws/} das \lstinline{setup.bash} sourcen: \lstinline{source devel/setup.bash}
\item Projekt starten: \lstinline{roslaunch car fullstart.launch}
\end{enumerate}
=======
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 fehlen bzw. falsch inkludiert sind. Im Repository sind bereits alle Änderungen behoben.

\subsubsection{STM}
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}

\end{document}