\subsubsection{Einführung}
\label{sec:tut-intro}

\subsubsubsection{Warum der Umstieg zu \uVision{} 5?}
In der HTBL Hollabrunn wurde in den letzten Jahren laufend die Version 4 der \gls{IDE} \uVision{} verwendet, ein Umstieg auf die neuere Version 5 war weder nötig noch wirklich sinnvoll.

Allerdings hat die \uVision{} in der Version 4 einen großen Nachteil, welcher die Verwendbarkeit in der Zukunft stark einschränkt. Denn ein kompilieren von Programmen für Cortex-M4 oder höher ist bei dieser Version nicht möglich, und Version 5 wird zur zwingenden Vorraussetzung. Da die Entwicklung weiter voran schreitet, ist es für die HTBL Hollabrunn nicht mehr praktikabel die veraltete Version 4 einzusetzen.

Dieses Dokument wird kurz auf die Mindestanforderungen der neuen Software, und des Weiteren auf die Inbetriebnahme mittels einfacher Beispielprogramme eingehen. Alte \uVision{} 4 Projekte können auf diese Weise in die neue Umgebung übertragen werden.

\subsubsubsection{Mindestsystemanforderungen}
\tab{tut-systemanforderungen}{\uVision{} 5: Systemanforderungen}{Systemanforderungen der \gls{Keil} \uVision{} 5}{|c|p{5cm}|p{5cm}|}{
  \hline
  & Minimum & Empfohlen\\
  \hhline{|=|=|=|}
  Prozessor & 1 GHz (32/64 bit) & 2 GHz (64 bit) oder mehr\\
  \hline
  RAM & 1 GB & 4 GB oder mehr\\
  \hline
  Festplattenspeicher & 2 GB & 5 GB oder mehr\\
  \hline
  Internet & & 2 Mb/s oder mehr (für Pack Installer)\\
  \hline
}
Alle Windows Versionen ab Windows Vista (32/64 bit) werden unterstützt.

\begin{warning}
  Achtung: Im Gegensatz zu \uVision{} in Version 4, wird von dieser Version das Betriebssystem Microsoft Windows XP nicht mehr unterstützt!
\end{warning}

\subsubsection{Das erste \uVision{} 5 Projekt}
\label{sec:tut-firstproject}
\subsubsubsection{Die Installation}
\label{sec:tut-firstproject1}
Bevor mit der eigentlichen Installation der \gls{IDE} begonnen werden kann, muss diese von der offiziellen \gls{Keil} Webseite heruntergeladen werden. Dies kann unter diesem Link getan werden:
\url{https://www.keil.com/demo/eval/arm.htm}

\fig{tut-installer}{\uVision{} 5: Installer}{Der heruntergeladene \uVision{} 5 Installer}{\textwidth}{Mieke/Tutorial/Screenshots/installer}

Nachdem der Installer heruntergeladen wurde, sollte eine ausführbare Datei  wie in \fref{fig:tut-installer} zu sehen ist vorhanden sein, eventuell sollte die Größe dieser Datei überprüft werden, um auszuschließen, dass es beim Download zu einem Fehler kam.

\fig{tut-windowsUAC}{\uVision{} 5: Windows UAC Dialog}{Dialog von Windows User Account Control}{0.5\textwidth}{Mieke/Tutorial/Screenshots/windowsUAC}

Danach muss dieser mit einem Doppelklick gestartet werden. Eventuell zeigt Windows einen Bestätigungsdialog (\fref{fig:tut-windowsUAC}) an, dieser ist mit einem Klick auf den Button \texttt{Ja} zu bestätigen.

\fig{tut-install1}{\uVision{} 5: Begrüßungsbildschirm}{Begrüßungsbildschirm des Installers}{0.75\textwidth}{Mieke/Tutorial/Screenshots/install1}

Wenn der Dialog bestätigt wurde, startet der eigentliche Installationsprozess. Im Begrüßungsbildschirm (\fref{fig:tut-install1}) wird nochmals erläutert welche Version der Software zur Zeit installiert wird (in diesem Fall \uVision{} in Version \texttt{5.23}). Die Richtigkeit dieser Angaben wird mit einem Klick auf \texttt{Next} bestätigt.

\fig{tut-install2}{\uVision{} 5: Lizenzbedingungen}{Lizenzbedingungen}{0.75\textwidth}{Mieke/Tutorial/Screenshots/install2}

Nun müssen die Lizenzbedingungen akzeptiert werden (\fref{fig:tut-install2}), hierzu muss der Hacken in der Checkbox gesetzt werden und wieder mit einem Klick auf \texttt{Next} bestätigt werden.

\fig{tut-install3}{\uVision{} 5: Installationspfade}{Auswahl der Installationspfade}{0.75\textwidth}{Mieke/Tutorial/Screenshots/install3}

Im nächsten Bildschirm (\fref{fig:tut-install3}) wird der Installationsort für den Compiler und die IDE, sowie der Pfad für die Installation von \gls{CMSIS}-Packs (\fref{fig:tut-pack4}) abgefragt. Grundsätzlich können beide Felder auf beliebige Pfade gesetzt werden, aufgrund der Kompatibilität und der vereinfachten Fehlersuche wird aber empfohlen den Standard beizubehalten.

\fig{tut-install4}{\uVision{} 5: Benutzerdaten}{Eingabe der Benutzerdaten}{0.75\textwidth}{Mieke/Tutorial/Screenshots/install4}

Danach werden Daten zum Benutzer abgefragt (\fref{fig:tut-install4}). Diese Felder können entweder mit erfundenen Daten, oder -- wenn man später ggf. eine Lizenz hinzufügen will -- mit den realen Daten des Benutzers gefüllt werden.

\fig{tut-install5}{\uVision{} 5: Installationsfortschritt}{Installationsfortschritt}{0.75\textwidth}{Mieke/Tutorial/Screenshots/install5}

Jetzt wird mit der eigentlichen Installation der Dateien begonnen. Der Fortschritt wird in einem eigenen Bildschirm (\fref{fig:tut-install5}) angezeigt. Nun muss gewartet werden, bis der Balken komplett durchgelaufen ist.

\fig{tut-install6}{\uVision{} 5: Warnung der Windows-Sicherheit}{Warnung der Windows-Sicherheit}{0.75\textwidth}{Mieke/Tutorial/Screenshots/install6}

Je nach Windows Version kann ein Konsolenfenster auf gehen, welches einfach ignoriert werden kann. Gegebenenfalls wird auch eine Warnung der Windows-Sicherheit bezüglich der Installation von Treibern angezeigt (\fref{fig:tut-install6}). Diese ist mit einem Klick auf \texttt{Installieren} zu bestätigen.

\fig{tut-install7}{\uVision{} 5: Erfolgreiche Installation}{Erfolgreiche Installation}{0.75\textwidth}{Mieke/Tutorial/Screenshots/install7}

Am letzten Bildschirm (\fref{fig:tut-install7}) wird nachgefragt ob die Release Notes angezeigt werden sollen, dies ist nicht nötig und somit sollte in der Checkbox auch kein Hacken sein. Mit einem klick auf den \texttt{Finish} Button wird die Installation beendet. Ein Neustart des Rechners sollte nicht nötig sein.

\subsubsubsection{Der Pack Installer}
\label{sec:tut-firstproject2}
Nachdem die Installation erfolgreich beendet wurde, startet der \texttt{Pack Installer} der \uVision{}. Dieses Programm verwaltet alle \gls{CMSIS}-Pakete welche im Laufe der Verwendung der \gls{IDE} heruntergeladen und installiert werden. Der Installer hat im groben zwei Spalten, auf der linken Seite kann man den Prozessor, welchen man verwenden will, aussuchen und auf der rechten Seite werden dann die für diesen Prozessor verfügbaren Pakete angezeigt.

\fig{tut-pack1}{\uVision{} 5: Pack Installer}{Der Pack Installer nach dem ersten Start}{0.75\textwidth}{Mieke/Tutorial/Screenshots/pack1}

Beim ersten Start des Pack Installers wird eine Willkommensnachricht, welche diesen kurz beschreibt, angezeigt (\fref{fig:tut-pack1}). Diese kann entweder durch deaktivieren der entsprechenden Checkbox für immer versteckt, oder mittels Button geschlossen werden.

\fig{tut-pack3}{\uVision{} 5: Downloadfortschritt}{Downloadfortschritt}{\textwidth}{Mieke/Tutorial/Screenshots/pack3}

Beim ersten Start sind nur die direkt von \gls{ARM} ausgelieferten Prozessorkerne im Installer verfügbar (\fref{fig:tut-pack1}), allerdings wird gleichzeitig auch ein Updateprozess gestartet, welcher alle nötigen Paket-Infos herunterlädt und gegebenenfalls bereits installierte Pakete updatet. Um den Installer richtig verwenden zu können, müssen wir dieses erste Update abwarten. In der Statusleiste des Programms (\fref{fig:tut-pack3}) sieht man den entsprechenden Fortschritt. Wenn dieser auf 100\% steigt, beziehungsweise der Text komplett verschwindet ist das Update beendet und wir können fortfahren.

\begin{warning}
  Zu beachten: Es kann vorkommen, dass die Fortschrittsanzeige beim installieren der einzelnen Pakete kurz verschwindet, es sollte also zur Sicherheit einige Sekunden gewartet werden, wenn der Text verschwindet um sicher zu gehen, dass das Update auch wirklich fertig eingespielt wurde.
\end{warning}

\fig{tut-pack4}{\uVision{} 5: Verfügbare Pakete}{Verfügbare Pakete}{0.75\textwidth}{Mieke/Tutorial/Screenshots/pack4}

Nachdem die Updates erfolgreich eingespielt wurden sollte sich die gerade noch leere Liste (\fref{fig:tut-pack4}) mit knapp 4000 verfügbaren Prozessoren gefüllt haben.

\fig{tut-pack6}{\uVision{} 5: Prozessor des Minimalsystems}{Prozessor des \gls{Minimalsystem}s}{\textwidth}{Mieke/Tutorial/Screenshots/pack6}

Danach muss der passende Prozessor ausgewählt werden (\fref{fig:tut-pack6}). Im Zuge dieser Diplomarbeit wurde der Prozessor für den Schulgebrauch von \texttt{STM32F103RB} zu einem \texttt{STM32F107RB} geändert, dieser bietet mehr Features als der Alte Prozessor. Man kann den richtigen Prozessor entweder über die Liste auswählen, oder einfach das Suchfeld oben links verwenden um direkt den Richtigen angezeigt zu bekommen.

\fig{tut-pack7}{\uVision{} 5: Verfügbare Pakete für Prozessor}{Verfügbare Pakete für den Prozessor des \gls{Minimalsystem}s}{0.75\textwidth}{Mieke/Tutorial/Screenshots/pack7}

Auf der rechten Seite (\fref{fig:tut-pack7}) scheinen, sobald der richtige Prozessor ausgewählt ist, die für diesen Prozessor verfügbaren \gls{CMSIS}-Pakete auf, diese können nun mittels Klick auf den entsprechenden Button installiert und danach in der \gls{IDE} verwendet werden. Für den Schulgebrauch ist das Paket \texttt{\gls{Keil}::STM32F1xx\_DFP} nötig und ausreichend. Dieses beinhaltet alle verwendeten Libraries und auch Beispielprogramme. Während der Installation des Pakets ist wieder auf die Statusleiste und den Fortschritt in dieser zu achten, wenn alles erfolgreich installiert wurde, sollte unser verwendeter Prozessor auf der linken Übersichtsseite grün hinterlegt sein, siehe dazu \fref{fig:tut-pack9}. Des weiteren sollten sämtliche Packs, bei welchen \texttt{Update} steht geupdatet werden.

\fig{tut-pack9}{\uVision{} 5: Erfolgreich installierter Prozessor}{Erfolgreich installierter Prozessor}{0.75\textwidth}{Mieke/Tutorial/Screenshots/pack9}

\subsubsubsection{Installation des HTBL Packs}
\label{sec:tut-firstproject2.1}
Um die spezifischen Libraries und Header Files der HTBL Hollabrunn einfach zur Verfügung zu stellen, gibt es für eben diese ein eigenes \gls{CMSIS}-Pack. Dieses wird aber anders als die anderen Packs (noch) nicht über das Internet vertrieben, sondern vom Lehrer auf einem Medium wie USB-Stick oder CD ausgeteilt. Dementsprechend muss dieses Pack manuell in den Pack-Manager hinzugefügt werden.

\fig{tut-pack10}{\uVision{} 5: Menüpunkt zum manuellen Import von Packs}{Menüpunkt zum manuellen Import von Packs}{0.25\textwidth}{Mieke/Tutorial/Screenshots/pack10}

Hierzu muss auf \texttt{File}, und dann auf \texttt{Import...} geklickt werden, wie in \fref{fig:tut-pack10} dargestellt. Danach öffnet sich ein Explorer Fenster, in welchem man die entsprechende \texttt{.pack}-Datei auswählen muss. Wenn dies geschehen ist wird die Datei eingelesen und automatisch installiert. Sollte aus irgendeinem Grund die Zieldatei schon existieren, so ist das überschreiben mittels Klick auf \texttt{Ja} im entsprechenden Dialogfenster zu bestätigen. Nach erfolgter Installation sollte das Übersichtsfenster wie in \fref{fig:tut-pack11} aussehen.

\fig{tut-pack11}{\uVision{} 5: Hauptfenster mit HTL Pack}{Hauptfenster nach erfolgreicher Installation des HTBL Packs}{0.75\textwidth}{Mieke/Tutorial/Screenshots/pack11}

\subsubsection{Die Projekterstellung}
\label{sec:tut-firstproject3}
Als nächstes muss ein \uVision{} Projekt erstellt werden. Projekte dienen zur Organisation der Source-Files und der verwendeten Bibliotheken, sowohl \gls{CMSIS}- als auch eigene Bibliotheken. Das Projekt kann mittels grafischem Interface einfach konfiguriert und mit \gls{CMSIS}-Libraries versehen werden.

\fig{tut-projekt1}{\uVision{} 5: Hauptfenster der IDE}{Hauptfenster der \gls{IDE}}{0.75\textwidth}{Mieke/Tutorial/Screenshots/projekt1}

Nach dem Start der \gls{IDE} ist zunächst ein leeres Fenster zu sehen (\fref{fig:tut-projekt1}). Dieses besteht aus einer Menüleiste ganz oben und den Schnellzugriffsschaltflächen direkt darunter. Auf der linken Seite ist ein noch leerer Projektbaum zu finden und rechts im großen grauen Feld der eigentliche Texteditor für die Source-Files. Darunter befindet sich noch ein Fenster für Log und Compiler Ausgaben, unter diesem die Statusleiste.

\fig{tut-projekt2}{\uVision{} 5: Projekt-Menü}{Projekt-Menü}{0.3\textwidth}{Mieke/Tutorial/Screenshots/projekt2}

Mit einem Klick auf den entsprechenden Menüpunkt (\fref{fig:tut-projekt2}) kann ein neues \uVision{} Projekt erstellt werden.

\fig{tut-projekt3}{\uVision{} 5: Prozessorauswahldialog}{Prozessorauswahldialog}{0.75\textwidth}{Mieke/Tutorial/Screenshots/projekt3}

Im nächsten Bildschirm (\fref{fig:tut-projekt3}) wird abgefragt welcher Prozessor verwendet werden soll, in unserem Fall ist dies wieder der \texttt{STM32F107RB}. Man kann den richtigen Prozessor entweder in der Liste heraus suchen, oder den Namen direkt in das Suchfeld eingeben. Auf der rechten Seite wird ein Beschreibungstext mit den Features des gewählten Prozessors angezeigt.

\fig{tut-projekt4}{\uVision{} 5: Laufzeitumgebungskonfigurationsfenster}{Laufzeitumgebungskonfigurationsfenster}{0.75\textwidth}{Mieke/Tutorial/Screenshots/projekt4}

Danach wird gefragt welche \gls{CMSIS}-Libraries eingebunden werden sollen (\fref{fig:tut-projekt4}), hier ist mindestens \texttt{CORE} im Reiter \texttt{CMSIS} und \texttt{Startup} im Reiter \texttt{Device} zu wählen. Werden mehr Features benötigt, können diese in den entsprechenden Reitern aktiviert werden. Ein späteres Ändern der Laufzeitumgebung ist über einen Klick auf die entsprechende Schnellzugriffsschaltfläche ohne größere Umstände möglich. Die Konfiguration ist mittels Klick auf \texttt{OK} zu bestätigen.

\begin{warning}
  Zu beachten: Während die meisten \gls{CMSIS}-Libraries frei verfügbar sind, gibt es auch einige wenige (File System, Graphics, Network, USB) welche nur mit einer Pro Version von \uVision{} verwendbar sind. Ist dies der Fall muss auf freie Libraries ausgewichen, oder eine Pro Version erworben werden.
\end{warning}

\fig{tut-projekt5}{\uVision{} 5: Beispielprogramm}{Beispielprogramm}{0.75\textwidth}{Mieke/Tutorial/Screenshots/projekt5}

In \fref{fig:tut-projekt5} ist ein kleines Beispielprogramm zu sehen, welches die LEDs der LED-/Schalterplatine blinken lässt. Links zu sehen ist der Projektbaum. \gls{C}-Files werden über den entsprechenden Menüpunkt (Rechtsklick auf die \texttt{Source Group 1} und dann \texttt{Add Item to Group...}) angelegt und direkt in das Projekt eingebunden. Der passende Dateiname und Typ ist im folgenden Fenster (\fref{fig:tut-projekt5-2}) entsprechend zu wählen. Das \fref{lst:tut-example1} kann einfach in das \gls{C}-File kopiert werden.

\fig{tut-projekt5-2}{\uVision{} 5: Dateierstellungsdialog}{Dateierstellungsdialog}{0.75\textwidth}{Mieke/Tutorial/Screenshots/asm2}

\FloatBarrier
\lstinputlisting[language={[ANSI]C}, caption=LED Blinklicht, label=lst:tut-example1]{Mieke/Tutorial/Listings/example1.c}

\fig{tut-projekt5-1}{\uVision{} 5: Schaltfläche zum kompilieren}{Schaltfläche zum kompilieren}{0.3\textwidth}{Mieke/Tutorial/Screenshots/projekt5-1}

Als nächstes muss das geschriebene Programm kompiliert werden, dazu ist einfach auf die Schaltfläche (\fref{fig:tut-projekt5-1}) zu klicken. Nach einigen wenigen Sekunden sollte dieser Vorgang erfolgreich abgeschlossen sein (Ausgabe im Logfenster (Übersicht: \fref{fig:tut-projekt1}) beachten).

\fig{tut-projekt6}{\uVision{} 5: Optionsschaltfläche}{Optionsschaltfläche}{0.3\textwidth}{Mieke/Tutorial/Screenshots/projekt6}

Bevor nun aber das fertig kompilierte Programm auf das \gls{Minimalsystem} geflasht werden kann, muss der Debugging Adapter\footnote{In unserem Fall ein \gls{Keil} ULINK-ME} angeschlossen (\fref{fig:tut-projekt6-1}) und dessen Software geupdatet werden. Dies kann mittels Klick auf den Zauberstab (\fref{fig:tut-projekt6}) gestartet werden werden.

\fig{tut-projekt6-1}{\uVision{} 5: Aufbau des Minimalsystems}{Aufbau des \gls{Minimalsystem}s}{0.75\textwidth}{Mieke/Tutorial/Pictures/SetUp}

\fig{tut-projekt7}{\uVision{} 5: Optionsfenster}{Optionsfenster}{0.75\textwidth}{Mieke/Tutorial/Screenshots/projekt7}

Danach geht das in \fref{fig:tut-projekt7} abgebildete Fenster auf. Eventuell steht die Auswahl nicht auf dem Debug Reiter oben, dann ist dies manuell mittels Mausklick durchzuführen. Auf der rechten Seite muss der Radio Button bei \texttt{Use} ausgewählt werden und im Dropdown daneben \texttt{ULINK2/ME Cortex Debugger}. Wenn die Updateaufforderung (\fref{fig:tut-projekt8}) nicht automatisch auftaucht, muss der Button \texttt{Settings} geklickt werden.

\fig{tut-projekt8}{\uVision{} 5: Firmwareupdate}{Firmwareupdate}{0.75\textwidth}{Mieke/Tutorial/Screenshots/projekt8}

\begin{warning}
  Achtung: Das Firmware Update ist notwendig um den Debugger zusammen mit \uVision{} 5 zu verwenden, allerdings ist dieser dann nicht mehr mit Version 4 kompatibel, hierfür muss die Firmware wieder mittels externem Programm auf die Alte geändert werden.
\end{warning}

Die Meldung zum Update der Firmware muss mittels Klick auf den Button \texttt{OK} bestätigt werden. Danach muss gewartet werden, bis das Update durchgelaufen ist.

\begin{warning}
  Achtung: Trennen Sie in dieser Zeit nicht das USB Kabel des Debuggers, da dieser sonst gegebenenfalls irreperabel beschädigt werden könnte!
\end{warning}

Wenn das Update fertig durchgelaufen ist, und wieder das Optionsfenster (\fref{fig:tut-projekt7}) zu sehen ist, stellen Sie sicher, dass die dort gezeigten Einstellungen übereinstimmen, und klicken Sie dann auf \texttt{OK}.

\fig{tut-projekt9}{\uVision{} 5: Debugger Einstellungen}{Debugger Einstellungen}{0.75\textwidth}{Mieke/Tutorial/Screenshots/projekt9}

Im nun auf gegangenen Fenster (\fref{fig:tut-projekt9}) sollte die Checkbox \texttt{Reset and Run} aktiviert werden. Dies ist zwar für den korrekten Betrieb nicht nötig, erleichtert aber das Arbeiten sehr, da nicht nach jedem mal neu flashen der Reset Knopf des Prozessors gedrückt werden muss.

\fig{tut-projekt10}{\uVision{} 5: Load Button}{Load Button}{0.3\textwidth}{Mieke/Tutorial/Screenshots/projekt10}

Nun kann das kompilierte Programm mittels des Load Buttons (\fref{fig:tut-projekt10}) auf den Zielprozessor geladen werden. Wenn die Einstellungen, welche bei \fref{fig:tut-projekt9} zu sehen sind richtig angewendet wurden, sollte nun die LEDs der LED-/Schalterplatine anfangen zu blinken. Damit ist die \uVision{} \gls{IDE} in der Version 5 fertig eingerichtet und bereit verwendet zu werden!

\subsubsection{Debugging}
\label{sec:tut-debugging}
Im nächsten Teil dieses Tutorials wird auf den Debugger der \gls{Keil} \uVision{} 5 eingegangen werden, und des weiteren auch erläutert, wie sich eben dieser vom Debugger der \uVision{} 4 unterscheidet.

In der Symbolleiste (\fref{fig:tut-debugging1}) befinden sich entsprechende Icons zum starten des Debuggers und um Breakpoints zu verwalten. Mit Hilfe dieser Buttons kann der Debugger gestartet und gestoppt werden (Lupe ganz links) und Breakpoints hinzugefügt (roter Punkt), aktiviert und deaktiviert (weißer Punkt) werden. Des weiteren können alle Breakpoints gleichzeitig mittels Klick auf das Icon mit den zwei weißen Kreisen mit rotem Rand deaktiviert werden. Der Button rechts daneben löscht alle Breakpoints komplett.

\fig{tut-debugging1}{\uVision{} 5: Debugging-Symbolleiste}{\gls{Debugging}-Symbolleiste}{0.3\textwidth}{Mieke/Tutorial/Screenshots/debugging1}

Wird der Debugger nun mittels Klick auf die Lupe in \fref{fig:tut-debugging1} aktiviert, so wird das aktuelle Programm neu auf den Prozessor geflasht und gestartet, gleichzeitig erweitert sich auch das User Interface der \gls{IDE} (\fref{fig:tut-debugging2}) um für das \gls{Debugging} relevante Fenster. Weiters wird, wenn kein Breakpoint gesetzt ist, das Programm bis zum \texttt{main}-Aufruf ausgeführt und dort angehalten.

\fig{tut-debugging2}{\uVision{} 5: Debugging Modus}{User Interface der \gls{Keil} \uVision{} 5 im \gls{Debugging} Modus}{0.75\textwidth}{Mieke/Tutorial/Screenshots/debugging2}

Im Register Fenster (\fref{fig:tut-debugging3}) sind alle Register des Microcontrollers zu sehen, zusätzlich dazu sind jene, welche sich seit dem letzten Step verändert haben, blau eingefärbt. Das Register Fenster ist für das \gls{Debugging} von \gls{C}/\gls{C++} Programmen nicht wirklich sinnvoll, für Assembler-Programme aber eine große Hilfe.

\fig{tut-debugging3}{\uVision{} 5: Register Fenster}{Register Fenster}{0.3\textwidth}{Mieke/Tutorial/Screenshots/debugging3}

Ein weiteres Fenster ist das Disassembly-Fenster, welches den zur Zeit ausgeführten Binärcode in Form von Assemblerbefehlen zeigt, siehe \fref{fig:tut-debugging4}. Dies ist sinnvoll, wenn eine binäre Library analysiert und auf Fehler geprüft werden muss. Des weiteren kann man hier gut sehen bei welchem Teil einer Libraryfunktion das Programm zum Beispiel abstürzt oder hängen bleibt.

\fig{tut-debugging4}{\uVision{} 5: Disassembly Fenster}{Disassembly Fenster}{0.75\textwidth}{Mieke/Tutorial/Screenshots/debugging4}

Im Hauptfenster (\fref{fig:tut-debugging5}) wird der zur Zeit ausgeführte Programmcode angezeigt, mit zwei Pfeilen auf der Seite, welche die aktuelle Position und die Cursor-Position anzeigen. Der Cursor-Pfeil macht Sinn, wenn man die Funktion \enquote{Run to Line} benutzen will. Dies ist der zweite Button von rechts in \fref{fig:tut-debugging6}.

\fig{tut-debugging5}{\uVision{} 5: Hauptfenster}{Hauptfenster}{0.75\textwidth}{Mieke/Tutorial/Screenshots/debugging5}

\fig{tut-debugging6}{\uVision{} 5: Stepping-Buttons}{Stepping-Buttons}{0.3\textwidth}{Mieke/Tutorial/Screenshots/debugging6}

Des weiteren kann durch einen Klick auf die graue Fläche neben den Zeilennummern für die entsprechende Zeile ein Breakpoint aktiviert (und deaktiviert) werden. Siehe dazu \fref{fig:tut-debugging7}. Ein Breakpoint hält die Ausführung der laufenden Anwendung an dieser Stelle an und setzt diese erst nach einem Klick auf Run (\fref{fig:tut-debugging6}, zweiter Button von links) oder auf einen der Stepping-Buttons (zweite Buttongruppe von rechts) wieder im entsprechenden Modus fort. Dies ist sehr sinnvoll um sich zum Beispiel den Inhalt von Registern anzusehen und so Fehler zu suchen.

\fig{tut-debugging7}{\uVision{} 5: Breakpoint und Ausführungs-Pfeil}{Programmzeile mit Breakpoint und Ausführungs-Pfeil}{0.75\textwidth}{Mieke/Tutorial/Screenshots/debugging7}

Neben den Hauptregistern selbst, \fref{fig:tut-debugging3}, kann im Debugger auch die Konfiguration von einzelnen Peripherieeinheiten angesehen werden. Hierfür gibt es jeweils Extra Fenster, welche über das Hauptmenü geöffnet werden kann, zu sehen in \fref{fig:tut-debugging8}, in diesem Beispiel sehen wir uns die Konfiguration von GPIOA an.

\fig{tut-debugging8}{\uVision{} 5: Peripherie-Hauptmenü}{Peripherie-Hauptmenü}{0.3\textwidth}{Mieke/Tutorial/Screenshots/debugging8}

Nach dem Klick auf den entsprechenden Menüeintrag öffnet sich ein weiteres Fenster, \fref{fig:tut-debugging9}, entweder rechts angedockt, oder frei über der IDE liegend. Sollte es rechts angedockt sein, empfehle ich das Fenster raus zu ziehen und etwas größer zu machen, da dies der Übersicht hilft.

\fig{tut-debugging9}{\uVision{} 5: GPIOA Registerfenster}{GPIOA Registerfenster}{0.5\textwidth}{Mieke/Tutorial/Screenshots/debugging9}

Mit Hilfe dieses Fensters kann nun die Konfiguration der entsprechenden Peripherieeinheit angesehen werden. Anders als bei \gls{Keil} \uVision{} 4, werden in diesem Fenster nur noch die Konfigurationswerte in Hexadezimal dargestellt, beziehungsweise binäre Werte in Form von Checkboxen. Dies kann leider auch nach Nachfrage beim \gls{Keil} Support nicht umgestellt werden, was das einzige Manko der \uVision{} 5 gegenüber der Version 4 ist.

\fig{tut-debugging10}{\uVision{} 5: Memory Fenster}{Memory Fenster}{0.75\textwidth}{Mieke/Tutorial/Screenshots/debugging10}

Eine weitere Möglichkeit des Debuggings ist es, das Memory Fenster zu benutzen. Dieses Fenster (\fref{fig:tut-debugging10}) zeigt den Inhalt des Speichers ab einer eingegebenen Adresse an. Hier zu sehen ist die Instruktion, welche gerade in \fref{fig:tut-debugging4} ausgeführt wird. Weiters ist es Möglich mittels Rechtsklick den Inhalt von Speicherbereichen zu ändern. Dies ist insbesondere dann sinnvoll, wenn man den Op-Code einer Instruktion oder ähnliches während das Programm läuft ändern möchte.

\fig{tut-debugging11}{\uVision{} 5: Watches Fenster}{Watches Fenster}{0.75\textwidth}{Mieke/Tutorial/Screenshots/debugging11}

Mit Hilfe des Watches Fenster (\fref{fig:tut-debugging11}) können Variablen im \gls{C} Programm \enquote{beobachtet} werden. Das Fenster zeigt, sofern auf die Variable an der entsprechenden Programmstelle zugegriffen werden kann, immer den aktuellen Wert eben dieser an. Auch hier ist es möglich den Wert in Echtzeit zu ändern, außerdem können einfache Berechnungen durchgeführt werden.

\subsubsubsection[Keil ULINK2/ME Debugger]{\gls{Keil} ULINK2/ME Debugger}
\label{sec:tut-debugging1}

Der ULINK/ME\footnote{Diese Bezeichnung bezeichnet die alte Firmware, nach dem Upgrade der Firmware für \uVision{} 5 wird dieser Adapter als ULINK2/ME bezeichnet und ist inkompatibel zu \uVision{} 4.} ist der Standard-Debug-Adapter, welcher bis 2017 verwendet wurde und bei den alten \gls{Minimalsystem}en immer noch verwendet wird. Die entsprechende Konfiguration und das nötige Firmware-Upgrade wurden hierfür schon in \fref{sec:tut-firstproject3} erläutert. Hierbei sind besonders \fref{fig:tut-projekt7} und \fref{fig:tut-projekt9} zu beachten.

\subsubsubsection{ST-Link Debugger}
\label{sec:tut-debugging2}

Das neue \gls{Minimalsystem} ist dafür vorgesehen mit einem ST-Link Debugger im \gls{SWD}-Modus verwendet zu werden. Wenn das \gls{Core-Modul} mit der \gls{Basisplatine} vebunden ist, kann allerdings auch der ULINK2/ME \gls{Debugging}-Adapter verwendet werden. Der ST-Link braucht im Gegensatz zu einem auf \gls{JTAG} basierenden Debugger weniger Pins und somit weniger Platz auf dem Zielsystem. Die \gls{IDE} muss lediglich auf diesen neuen Debugger umgestellt werden, siehe dazu auch das Debug-Fenster, wo der ST-Link Debugger ausgewählt ist (\fref{fig:tut-debugging12}). Nähere Infos dazu, wie man zu diesem Fenster kommt kann in \fref{sec:tut-firstproject3} gefunden werden. Die Verwendung des aktuellen ST-Link (Version 2) \gls{Debugging}-Adapters ist in \uVision{} 4 nicht mehr möglich.

\fig{tut-debugging12}{\uVision{} 5: Debug Fenster (ST-Link ausgewählt)}{Debug Fenster (ST-Link ausgewählt)}{0.75\textwidth}{Mieke/Tutorial/Screenshots/debugging12}

\subsubsection{Assembler-Programmierung}
\label{sec:tut-asm}

Zu Beginn wird die Programmierung vom Cortex-M3 mittels Assembler unterrichtet, dementsprechend befasst sich auch dieses Tutorial zuerst mir der Assembler-Programmierung. Hierzu wird ein Beispielprogramm verwendet und erläutert wie die \gls{IDE} eingestellt werden muss, und was alles zu tun ist um dieses Programm erfolgreich zu assemblieren und auszuprobieren.

Als erstes muss ein neues Projekt angelegt werden wie in \fref{sec:tut-firstproject3} erklärt. Wichtig hierbei ist es die richtigen \gls{CMSIS}-Packs zu wählen, da das Ziel ein Assembler-Projekt ist, ist hierbei das HTL Assembler-Pack (\fref{fig:tut-asm1}) zu wählen.

\fig{tut-asm1}{\uVision{} 5: Paketwahldialog mit HTL Pack}{Paketwahldialog mit HTL Pack}{0.75\textwidth}{Mieke/Tutorial/Screenshots/asm1}

Ist dies erledigt, kann eine neue Assembler Source-Datei erstellt werden, dazu klickt man mit der rechten Maustaste auf die \texttt{Source Group 1} und wählt im Kontextmenü \texttt{Add New Item to Group...}, im sich nun öffnenden Fenster (\fref{fig:tut-asm2}) wählt man nun \texttt{Asm File} und vergibt einen passenden Namen (zum Beispiel \texttt{main.s}).

\fig{tut-asm2}{\uVision{} 5: Dateierstellungsdialog}{Dateierstellungsdialog}{0.75\textwidth}{Mieke/Tutorial/Screenshots/asm2}

Durch einen Kick auf \texttt{Add} wird die Datei hinzugefügt und kann anschließend bearbeitet werden. In diesem Beispiel wird das erste Beispielprogramm (eine blinkende LED auf der LED-/Schalterplatine) programmiert. Hierzu ist der Source Code aus \fref{lst:tut-asm} zu verwenden. In der zweiten Zeile wird die HTBL Memory Map inkludiert, welche durch das \gls{CMSIS}-Pack zur Verfügung gestellt wird.

\lstinputlisting[language={[ARM]Assembler}, caption=LED Blinklicht, label=lst:tut-asm]{Mieke/Tutorial/Listings/asm.s}

Danach kann das Programm assembliert und anschließend auf den Cortex geladen werden. Dieses vorgehen ist näher in \fref{sec:tut-firstproject3} beschrieben. Nun sollte, nach einem Reset des Microcontrollers, die erste LED von rechts (PB8) auf der LED-/Schalterplatine blinken. Nähere Informationen zum Debugging können in \fref{sec:tut-debugging} gefunden werden.

\subsubsection{\gls{C}-Programmierung}
\label{sec:tut-c}

Nach dem Einstieg mit Assembler, wird auch die Programmierung mit der Sprache \gls{C} unterrichtet, die Projekterstellung für diese Sprache weicht nicht sonderlich von der für Assembler (\fref{sec:tut-asm}) und dem vorgehen im Allgemeinen (\fref{sec:tut-firstproject3}) ab. Allerdings ist auch hier zu beachten das richtige \gls{CMSIS} Pack der HTL zu verwenden. Dies ist im Anfang noch nicht so wichtig, da die ersten Programme ohne die \gls{STDLib} auskommen, allerdings ist diese in den späteren Programmen unbedingt nötig. Um die Library einzufügen, ist diese im Pack Manager (\fref{fig:tut-c1}) auszuwählen.

\fig{tut-c1}{\uVision{} 5: Paketwahldialog mit HTL STDLib Pack}{Paketwahldialog mit \gls{STDLib} Pack}{0.75\textwidth}{Mieke/Tutorial/Screenshots/c1}

Als erstes Demoprogramm ist hier ein Lauflicht, welches in \fref{lst:tut-c} zu sehen ist, zu realisieren.

\lstinputlisting[language={[ANSI]C}, caption=LED Lauflicht, label=lst:tut-c]{Mieke/Tutorial/Listings/c.c}

Auch hier verhält sich das Debugging so wie in \fref{sec:tut-debugging} beschrieben.
