\documentclass[ngerman,11pt,oneside]{memoir}
\usepackage[utf8]{inputenc} %europäischer Zeichensat
\usepackage[ngerman]{babel} %europäischer Zeichensatz
\usepackage{ngerman} %europäischer Zeichensatz
\usepackage{geometry} %Seitenrand konfigurieren
\usepackage{lastpage}%gibt letzte Seite aus
\usepackage{multirow}%gibt letzte Seite aus
%\usepackage[pdftex]{graphicx}%Graphic-Formatierung
\usepackage{pdfpages}
\usepackage{titlesec}
%\usepackage[automark]{scrpage2} %Kopf/Fuß-Zeile
%\usepackage[singlespacing]{setspace}
\usepackage{amsmath} %Mathematische Zeichen
\usepackage[pdftex, colorlinks=true, breaklinks=true,plainpages=false,linkcolor=black,ngerman,citecolor=black]{hyperref} 
\usepackage{listings}
%\usepackage{caption}
\usepackage{multicol}
%\usepackage{subfigure}
\pdfminorversion=9
\maxtocdepth{subsection}
\setcounter{secnumdepth}{2}

\titleformat{\chapter}[hang]{\Large\bfseries}{}{0pt}{}
\titlespacing{\chapter}{0pt}{-3em}{6pt}
\titleformat{\section}[hang]{\large\bfseries}{\thesection\quad}{0pt}{}

\geometry{a4paper,left=30mm,right=10mm, top=20mm, bottom=50mm} %Seitenrand %aktiviere geometrie!

\hypersetup{pdfauthor = {Julian Bergmann, Jan Mühlhans, Katja Kleeberg},pdftitle = {Mikrocontrollertechnik Protokolle},pdfsubject = {Mikrocontrollertechnik Protokolle},pdfcreator = {TeXniccenter/LaTeX}}

\definecolor{darkgreen}{rgb}{0,0.7,0}
\definecolor{darkorange}{rgb}{0.7,0.5,0}
\definecolor{red}{rgb}{1,0,0}
\definecolor{black}{rgb}{0,0,0}

\createmark{chapter}{both}{nonumber}{}{\space}
%\createmark{section}{both}{nonumber}{}{\space}
%\createmark{subsection}{both}{shownumber}{}{\space}

\makepagestyle{standard}
\makeheadrule{standard}{\textwidth}{\normalrulethickness}
\makeoddhead{standard}{\Kurztitel~~-~~\rightmark}{}{-~\thepage~-~}

\setlength{\columnseprule}{0.4pt}
\lstset{
	keepspaces=true,
	columns=flexible,
	captionpos=t,
	language=[x86masm]Assembler,
	breaklines=true,
	tabsize=4,
	basicstyle=\ttfamily\scriptsize,
	keywordstyle=\bfseries\ttfamily\color{darkorange},
	stringstyle=\color{brown}\ttfamily,
	commentstyle=\itshape\color{darkgreen}\ttfamily,
	showstringspaces=false,
	%breakatwhitespace=true,  
	literate={ö}{{\"o}}1 {ä}{{\"a}}1 {ü}{{\"u}}1 {Ö}{{\"O}}1 {Ä}{{\"A}}1 {Ü}{{\"U}}1 {ß}{{\ss}}1	{µ}{$\mu$}{1},
	morekeywords={subb,clr,cjne,djnz,cpl,addc,swap, anl, rl,rr,xrl},
	deletekeywords={loop,tr0,tr1,bh,dh,eh,ah,es,ch},
	%multicols=2
	%prebreak=\raisebox{0ex}[0ex][0ex],
	%postbreak=\space	
}

%\DeclareCaptionFont{white}{\color{white}}
%\DeclareCaptionFormat{listing}{\colorbox{gray}{\parbox{\textwidth}{#1#2#3}}}
%\captionsetup[lstlisting]{format=listing,labelfont=white,textfont=white}


\newcommand{\Titel}{
{\normalfont Mikrocontrollertechnik Protokolle\\[2cm]}
%Bestimmung von Ionenstrahleigenschaften mit einer Strahlkamera
Protokolle zu den Versuchen 1 bis 8 des Moduls Mikrokontrollertechnik and der JLU Gießen
}

\newcommand{\Kurztitel}{Mikrocontrollertechnik}
\title{\vfil\Titel\\[4cm]}
\author{Julian Bergmann, Jan Mühlhans, Katja Kleeberg}
\newcommand{\chaptern}[1]{\chapter*{#1}\addcontentsline{toc}{chapter}{#1}\addtocounter{chapter}{1}\setcounter{section}{0}\setcounter{subsection}{0}\phantomsection\renewcommand{\rightmark}{#1}}
%
\newcommand{\sectionn}[1]{\section*{#1}\addcontentsline{toc}{section}{#1}\addtocounter{section}{1}\setcounter{subsection}{0}\phantomsection}
%%\pagestyle{scrheadings} %Standard-Format, Kopf/Fußzeilen %aktiviere scrpage2!
%\ifoot{} %fußlinks %aktiviere scrpage2! 
%\cfoot{} %fußmitte %aktiviere scrpage2!
%\ofoot{} %fußrechts %aktiviere scrpage2!
%\ihead{\Kurztitel~~-~~\headmark} %kopflinks %aktiviere scrpage2!
%\chead{} %kopfmitte %aktiviere scrpage2!
%\ohead{-~\thepage~-~} %kopfrechts \setlength{\unitlength}{1cm}
\setlength{\headsep}{2cm}
\renewcommand{\theequation}{\thesection.\arabic{equation}} 
\renewcommand{\paragraph}[1]{~\\[1em]\textbf{#1}\\}
\renewcommand{\lstlistingname}{Quellcode}
\sloppy

\setcounter{page}{-1}
\begin{document}
\pagenumbering{Roman} 
%\begin{titlepage}
\begin{titlingpage}
	\maketitle\thispagestyle{empty} 	
\vspace{1cm}
\begin{center}
\end{center}
\end{titlingpage}\newpage\vspace*{-4cm}
%\end{titlepage}
\pagestyle{standard}  
\shorthandoff{"}
{
%\onehalfspacing
\OnehalfSpacing
\tableofcontents
\thispagestyle{empty}}
\setcounter{page}{0}
\newpage 
\pagenumbering{arabic} 
%\onehalfspacing
\OnehalfSpacing

%############################################################
%                       Hier geht's los                     %
%############################################################
\chaptern{Versuch 1}%Versuchsnummer ?ern

\sectionn{Versuchsziel} %schreibt was zum Versuch

\begin{quote}
Durch die Programmierung von Verzögerungsschleifen, sollte eine LED im Sekundentakt zum Blinken gebracht werden. Die LED war an den Pin-Port P3.5 angeschlossen und konnte über diesen geregelt werden. Mit Hilfe der NOP-Befehle wird jeweils $1 \ \mu\mathrm{s}$ verschwendet. Dadurch wurde eine Zeitbasis von $10 \ \mu\mathrm{s}$ erzeugt, welche mit Hilfe von drei Schleifen $100.000$ mal durchlaufen wurde, sodass genau eine Sekunde verging. Hierbei wurde berücksichtigt, dass für den DJNZ-Befehl $2\ \mu\mathrm{s}$ benötigt werden.
\end{quote}

\sectionn{Quellcode}
\lstinputlisting{"../Versuch 1/Versuch 1.a51"} %hier einfach die beiden Nummern entsprechend ändern

\newpage
\sectionn{Flussdiagramm}

\begin{figure}[!htpb]
\centering
\includegraphics[type=pdf,ext=.pdf,read=.pdf]{Versuch1} %Hier gebt ihr den Pfad zu eurem Flussdiagramm im pdf-Format an.
\end{figure}
\newpage
\chaptern{Versuch 2}%Versuchsnummer ndern
\sectionn{Versuch 2.1}
\subsection{Versuchsziel} %schreibt was zum Versuch
\begin{quote}
Ziel des Versuchs war es wieder die LED in einem gewünschten Takt leuchten zu lassen. Im Unterschied zu Versuch 1, sollte zum Programmieren der Zeitbasis nun die interne Zähler/Zeitgeber-Einheit verwendet werden. Im ersten Teil des Versuchs wurde der Timer im 16-Bit Modus verwendet, hierbei sollte eine Zeitbasis von $10 \ \mathrm{ms}$ entstehen. Diese wurde in der Timerinitialisierung durch Setzen des Startwertes realisiert, der Startwert für $10 \ \mathrm{ms}$ ergibt sich durch die Subtraktion vom Maximalwert unter Berücksichtigung der einzelnen Befehlsdauern, die hier mit $11\ \mu\mathrm{s}$ eingingen. Zum Erreichen einer vollen Sekunde wurde die Zeitbasis, mit Hilfe einer Schleife, 100 mal durchlaufen.
\\In der Initialisierung des Timers wurde der errechnete Startwert in das entsprechende high bzw. low Byte geschrieben, in unserem Fall war dies $TH0=0D8\ \mathrm{h}$ und $TH0=0FA\ \mathrm{h}$. Außerdem musste in der Initialisierung das Überlaufflag TF0, mit Hilfe des clear-Befehls, zurückgesetzt werden. Über das TMOD Register wurde eingestellt, dass der Timer 0 im Modus 1 verwendet werden sollte und Timer 1 nicht benutzt wurde, dazu musste hier dass letzte bit gesetzt werden, wobei das TMOD Register nicht bitadressierbar ist und demnach das ganze Byte gesetzt wurde. Durch das Setzen des bits TR0 wurde zuletzt noch der Timer gestartet.
\end{quote}

\subsection{Quellcode}
\lstinputlisting{"../Versuch 2/Versuch 2.a51"} 
\subsection{Flussdiagramm}
\begin{figure}[!htpb]
\centering
\includegraphics[type=pdf,ext=.pdf,read=.pdf]{"versuch2.1"} %Hier gebt ihr den Pfad zu eurem Flussdiagramm im pdf-Format an.
\end{figure}
\newpage


\sectionn{Versuch 2.2}
\subsection{Versuchsziel} %schreibt was zum Versuch
\begin{quote}
Im zweiten Teil des Versuchs sollte der Timer nun im 8-Bit Autoreload Modus betrieben werden. Hierbei wird das niederwerige Byte TL0 beim Auslösen des Interrupts durch Überlauf mit dem höherwertigen Byte TH0 überschrieben, dieses muss demnach den benötigten Reload-Wert enthalten. Im Gegensatz zum vorigen Versuchsteil sollte die Zeitbasis $250\ \mu\mathrm{s}$ betragen. Der Reload-Wert ergibt sich durch Abzug der gewünschten Zeit von 256 zuzüglich der Dauer für die Ausführung enthaltener Befehle, die diesmal mit $2 \ \mu\mathrm{s}$ berücksichtigt wurden, d.h. sowohl in TH0 als auch in TL0 sollte der Wert $$256-250+2=8 \ \ \rightarrow \ \ 8\ \mathrm{h}$$ eingetragen werden. Dies geschah wieder in der Initialisierung, in der ausserdem wie oben das Überlaufflag gelöscht und das TMOD Register gesetzt wurde. Um den Timer 0 nun im Modus 2 zu verwenden wurde im TMOD Register das vorletzte bit gesetzt. Über das Setzen des TR0 bits wurde wieder der Timer gestartet.
\end{quote}

\subsection{Quellcode}

\lstinputlisting{"../Versuch 2.2/Versuch 2.2.a51"} 

\subsection{Flussdiagramm}
\begin{figure}[!htpb]
\centering
\includegraphics[type=pdf,ext=.pdf,read=.pdf]{"versuch2.2"} %Hier gebt ihr den Pfad zu eurem Flussdiagramm im pdf-Format an.
\end{figure}

\newpage
\chaptern{Versuch 3}%Versuchsnummer ?ern
\sectionn{Versuch 3.1}\setcounter{section}{1}
\subsection{Versuchsziel} %schreibt was zum Versuch
\begin{quote}
In diesem Versuch sollte das Port der seriellen Schnittstelle auf dem $\mu$-Controller programmiert werden. Dazu sollte der interne Baudratengenerator im ersten Versuchsteil mit einer Oszillatorfrequenz von $12 \ \mathrm{MHz}$ eine Baudrate von 9600 Baud erzeugen. Zur Kommunikation mit der seriellen Schnittstelle wurden die Unterprogramme "Rec" und "Trans" geschrieben, welche dem Empfang und dem Zurücksenden von Zeichen dienen. Außerdem wurde ein Unterprogramm "Carret" geschrieben, welches den Carriage-Return Befehl erkennt und durch ein CR-Zeichen und ein anschließendes Line-Feed Zeichen ersetzt. Zusätzlich wurde ein Unterprogramm "Buchstaben" zum Umwandeln von Klein- in Großbuchstaben erarbeitet. 
\\In der Initialisierung des Programms wurden zunächst folgende bits gesetzt $\mathrm{SM0}=0,\ \mathrm{SM1}=1\ \mathrm{und}\ \mathrm{REN}=1$, die ersten beiden dienen der Einstellung der seriellen Schnittstelle, welche somit im Modus 1 (8-bit-UART mit einstellbarer Baudrate) betrieben werden kann. Über das bit REN ist zunächst der serielle Empfang durch die Software im Allgemeinen freigegeben. Durch Setzen des bits BD wird der interne Baudratengenerator aktiviert. Weiterhin wurde noch das SMOD bit gesetzt, welches die Baudrate in dem verwendeten Modus verdoppelt. Dieses bit ist dabei nicht direkt bitaddressierbar und wurde deswegen über den Akku, mit Hilfe des gesamten Registers (PCON), gesetzt.
\end{quote}

\subsection{Quellcode}
\lstinputlisting{"../Versuch 3/Versuch 3.a51"} %hier einfach die beiden Nummern entsprechend ändern

\begin{figure}[!htpb]
\centering
\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=0.8]{"zeichnung"} %Hier gebt ihr den Pfad zu eurem Flussdiagramm im pdf-Format an.
\end{figure}

\newpage
\sectionn{Versuch 3.2}\setcounter{section}{1}

\subsection{Versuchsziel} %schreibt was zum Versuch

\begin{quote}
Anders als in Teil 1 sollte die Baudrate mit Hilfe des Timers erzeugt werden. Hierbei wurden verschiedene Baudraten ausprobiert, die Baudraten mit den zugehörigen Werten des Nachladeregisters können dem Quellcode entnommen werden. Bereits bei einer Baudrate von 9600 Baud wurde die Übertragung fehlerhaft, bei einer Baudrate von 19200 Baud fand gar keine korrekte Übertragung mehr statt. 
\\Die Initialisierung ist ähnlich zu der in Teil 1, nur das hier anstelle der Aktivierung des internen Baudratengenerators eine zusätzliche Timerinitialisierung vorgenommen wurde. Die Timerinitialisierung ist analog zu der in Versuch 2.2, mit dem Unterschied, dass diesmal Timer 1 verwendet wurde und je nach gewünschter Baudrate der Reload-Wert angepasst wurde. Der Wert für TH1 bzw. TH0 ergibt sich aus der in der Anleitung angegebenen Formel für die Baudrate:
$$\mathrm{Baudrate}=\frac{2^{\mathrm{SMOD}}}{32}\cdot\frac{\mathrm{Oszillatorfrequenz}}{12\cdot(256-\mathrm{TH1})}.$$

\end{quote}

\subsection{Quellcode}
\lstinputlisting{"../Versuch 3.2/Versuch 3.a51"} %hier einfach die beiden Nummern entsprechend ändern

\newpage

\chaptern{Versuch 4}%Versuchsnummer ?ern

\sectionn{Versuchsziel} %schreibt was zum Versuch

\begin{quote}
In diesem Versuch sollte die Kommunikation über die serielle Schnitstelle und der Timer auf Interrupt-Betrieb umgestellt werden, sodass Versuch 2 und 3 parallel ablaufen konnten. Die Zeitbasis des Timers zum Blinken der LED sollte $100\ \mu\mathrm{s}$ betragen, weswegen sich der Reload-Wert des Timers zu dem in Versuch 2 unterscheidet. Aus diesem Grund musste die Zeitbasis nun 10000 mal durchlaufen werden. Dies wurde mit Hilfe zweier Schleifen mit jeweils 100 Durchläufen realisiert. Die Unterprogramme sind mit denen aus Versuch 3 identisch und deswegen nicht nochmal aufgeführt. Im Hauptprogramm wird neben der Initialisierung eine Endlosschleife ausgeführt, die nur durch den entsprechenden Interrupt unterbrochen wird. Dabei ist in den verschiedenen Interrupt-Einsprungadressen, der Verweis auf die zugehörige Serviceroutine vermerkt, wodurch diese im Falle eines Interrupts ausgeführt wird.
\\Die Initialisierung besteht zum einen aus der Timerinitialisierung, die bis auf den erwähnten Reload-Wert mit der in Versuch 2.2 übereinstimmt, und zum Anderen aus der Initialisierung der seriellen Schnittstelle, die der in Versuch 3.1 entspricht. Weiterhin werden hier die Register für die Schleifen gesetzt ($\mathrm{R0}=\mathrm{R1}=100$) und die benötigten Interrupt Einstellungen vorgenommen, wofür die drei bits ETO, ES und EAL gesetzt werden. Diese bits entsprechen der Aktivierung des Timer Interrupts, der Aktivierung des Interrupts der seriellen Schnittstelle und der allgemeinen Aktivierung von Interrupts.
\end{quote}

\sectionn{Quellcode}
\lstinputlisting{"../Versuch 4/Versuch 4.a51"} %hier einfach die beiden Nummern entsprechend ändern

\newpage
\sectionn{Flussdiagramm}
%\vspace{1cm}
\begin{center}
\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.35]{"versuch4_hauptprogramm"} %Hier gebt ihr den Pfad zu eurem Flussdiagramm im pdf-Format an.
\end{center}
\vspace{1.3cm}
\begin{center}
\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.35]{"serviceroutine"} %Hier gebt ihr den Pfad zu eurem Flussdiagramm im pdf-Format an.
\end{center}

%############################################################
%                       Versuch 5	                     %
%############################################################

\chaptern{Versuch 5} %Versuchsnummer ndern

\sectionn{Versuchsziel} %schreibt was zum Versuch
\begin{quote}
Mit Hilfe eines pulsweitenmodulierten Signals soll die Position eines Stellhebels an einem Servomotor
entsprechend der Benutzereingaben am Terminal verändert werden.
Der Mikrocontroller muss hier ein Signal mit einer Frequenz von ca. 60Hz (Periodendauer = 16,3 ms) und einer Pulszeit zwischen 0,6 und 2,1 ms erzeugen.
Die Elektronik des Servomotors übersetzt dann das Verhältnis aus Pulszeit und Pausenzeit in einen festen  Stellwinkel. \\
%
Für die Pulsweitenmodulation wird Timer2 des Mikrocontrollers verwendet.
Dieser verfügt über 4 16-Bit-Compare-Register die jeweils mit einem Ausgangspin verbunden sind.
Eines der Register (CRCH/CRCL) wird für den Reload des Timers verwendet. Der Reloadwert C000h entspricht einer Frequenz von 61,03 Hz.
Wärend der Timer von C000h nach oben zählt wird in jedem Schritt mit den drei restlichen Compare-Registern verglichen.
Stimmt der Timerwert mit dem Wert eines der Register überein wird der entsprechende Ausgangspin auf 1 gesetzt.
Bei Timerüberlauf werden wieder alle Pins auf 0 gesetzt.
In diesem Versuch ist der Servomotor am Ausgang P1.3 angeschlossen. Entsprechend bestimmt der Wert des dritten Registers (CCL3/CCH3) die Pulsweite und somit die Position des Stellhebels. \\
%
Nach Reset des 80C535 wird der Stellhebel zunächst auf eine mittige Position gefahren.
Der hierfür nötige Compare-Wert wurde durch Ausprobieren bestimmt..
Die Kommunikation mit dem Terminal verläuft analog zu Versuch 3 über die serielle Schnittstelle.
Die Zeichen 1,2 und 3 werden als Steuerzeichen für den Servomotor verwendet.
Gibt der Benutzer eine 1 oder 3 ein wird 0020h zum Wert des dritten Compare-Registers addiert (oder subtrahiert), entsprechend ändert
sich die Position des Hebels um ein kleines Stück.
Der Comparewert muss hierbei aber in einem bestimmten Intervall bleiben um sicherzustellen dass der Servomotor beim Erreichen des Anschlags 
nicht beschädigt wird. 
Das Programm muss also zunächst den Comparewert mit einem Maximal/Minimal Wert vergleichen. \\
%
Bei Eingabe des Zeichen 2 wird der Hebel wieder auf seine Ausgangsposition gefahren, d.h. der Initialisierungswert wird ins Compareregister geladen.
\end{quote}

\newpage
\sectionn{Quellcode}
\lstinputlisting[tabsize=3]{"../Versuch 5/Versuch 5.a51"} %hier einfach die beiden Nummern entsprechend ändern

\sectionn{Flussdiagramm}
\begin{center}
\includegraphics[type=pdf,ext=.pdf,read=.pdf]{"../Versuch 5/versuch5_small"} %Hier gebt ihr den Pfad zu eurem Flussdiagramm im pdf-Format an.
\end{center}

%############################################################
%                       Versuch 6                           %
%############################################################
\clearpage
\chaptern{Versuch 6} %Versuchsnummer ndern

\sectionn{Versuchsziel} %schreibt was zum Versuch
\begin{quote}
In diesem Versuch soll ein LC-Display mit Hilfe des Mikrocontrollers angesteuert werden.
Die Kommunikation mit dem Display läuft über 8-Datenleitungen (Port 5.0 - 5.7) und über drei Steuerleitungen $RS$, $RW$ und $E$ (Port 4..0 - 4.2).
Ist das Bit $RS$ nicht gesetzt wird die Bitfolge an der Datenleitung als Befehl für den Display-Controller interpretiert.
Bei $RS = 1$ dagegen als ASCII-Zeichen für die Darstellung.
Das $RW$ Bit gibt an, ob Daten vom Mikrocontroller geschrieben oder gelesen werden. Um Befehle oder Zeichen zu übertragen, muss $RW = 0$ sein.
$E$ (Enable) muss zur Übertragung zunächst gesetzt sein. Sind alle Daten und Steuerleitungen richtig gesetzt wird $E$ gelöscht.
Die fallende Flanke von $E$ gibt den Zeitpunkt an, zu welchem der Dispaly-Controller die Daten liest.

Für die Initilaisierung des Displays müssen nach dem Einschalten eine Reihe von Befehlen in bestimmten zeitlichen Abständen gesendet werden.
In dem Unterprogramm $init$ werden unter anderem die für die Befehle entsprechenden Bitfolgen in den Akku geladen und das Unterprogramm 
$Befehl$ aufgerufen. Dieses setzt die Daten- und Steuerleitungen, erzeugt die fallende Flanke an Port $E$ und ruft anschließend das Unterprogramm
$delay5$ auf. Durch den Aufruf von $delay5$ (5 ms Pause) ist sichergestellt, dass mindestens die benötigten Pausenzeiten verstreichen die der Dispaly-Controller
benötigt.

Neben dem LCD wird auch die serielle Schnittstelle (s. Versuch 3) für die Kommunikation mit dem Terminal initialisiert.
Zeichen die auf dem Terminal eingegeben werden gibt der Mikrocontroller zur Darstellung an das LCD weiter.
Dabei prüft das Unterprogramm $deletpruf$ ob eines der drei Steuerzeichen eingegeben wurde.
Ist dies der Fall wird ein entsprechender Befehl an den LCD gesendet.
Für Backspace (08h) wird der gesamte Display gelöscht und der Cursor auf die Ausgangsposition gesetzt.
Wird Esc (1Bh) eingegeben springt der Cursor in die zweite Zeile.
Bei Return (0Dh) springt das Programm in eine Endlosschleife. Dabei wird der Inhalt des Displays in Abständen von 250 ms nach links verschoben.
\end{quote}

\newpage
\sectionn{Quellcode}
\lstinputlisting[tabsize=3]{"../Versuch 6/Versuch 6.a51"} %hier einfach die beiden Nummern entsprechend ändern

\newpage
\sectionn{Flussdiagramm}
\begin{center}
\includegraphics[type=pdf,ext=.pdf,read=.pdf]{"../Versuch 6/versuch6_small"} %Hier gebt ihr den Pfad zu eurem Flussdiagramm im pdf-Format an.
\end{center}

%############################################################
%                       Verusch 7                           %
%############################################################

\chaptern{Versuch 7} %Versuchsnummer ndern

\sectionn{Versuchsziel} %schreibt was zum Versuch
\begin{quote}
Der Mikrocontroller soll in diesem Versuch als Analog/Digital-Wandler programmiert werden.
Dabei sollen die gemessenen Spannungen über die serielle Schnittstelle auf dem Terminal ausgegeben werden.

Der 80535 verfügt über einen 8-Bit A/D-Wandler. Mit diesem können Spannungen zwischen $0 V$ und $+5 V$ gemessen werden.

Zusätzlich kann über das DAPR-Register der Messbereich variiert und damit die Auflösung vergrößert werden.
Diese Möglichkeit soll dazu genutzt werden einen Softwareseitigen 10-Bit A/D-Wandler zu programmieren.
Zunächst wird eine 8-Bit Messung durchgeführt und mit dem Ergebnis der Messbereich für die genauere Messung festgelegt.
Aus der ersten Messung ergeben sich dann die Bits 8 und 9, aus der genaueren Messung
die Bits 0 - 7 des 10-bit Ergebnis.
10-Bit entsprechen hier einer Auflösung von $4,88 mV$ im Gegensatz zur 8-Bit Auflösung von $19,53 mV$.
Vorraussetzung ist allerdings, dass die Eingangsspannung zwischen den beiden Messungen konstant bleibt.
\newline
Nach Reset des Mikrocontrollers wartet dieser zunächst auf die Eingabe des Benutzers am Terminal.
Sobald die Eingabe erfolgt, ruft das Unterprogramm \textit{runreturn} das Unterprogramm \textit{Messung} auf.
Dieses startet die 8-Bit Messung in dem $0$ in das DARP-Register geschrieben wird.
Nach erfolgter Messung steht das Ergebnis im Register ADDAT und wird an den Terminal gesendet (\textit{Trans}).
Das Unterprogramm \textit{calc-DARP} berechnet die neuen Grenzen und schreibt die entsprechenden Bitfolgen in DARP.
Die Ergebnisse der beiden Messungen werden zu einem 10-Bit Ergebnis zusammengesetzt. Hierfür werden unter anderem die Befehle \textit{RR},
\textit{RL} und \textit{ANL} benötigt. \textit{RR} verschiebt die Bitfolge im Akku nach rechts (\textit{RL} nach links). \textit{ANL} 
verundet den Akku mit einer Bitfolge, wodurch es möglich ist
einzelne Bits zu löschen, obwohl der Akku nicht direkt bitadressierbar ist.
Das 10-Bit Ergebnis wird schließlich auf dem Terminal ausgegeben.
\end{quote}

\sectionn{Quellcode}
\lstinputlisting[tabsize=3]{"../Versuch 7/Versuch 7.a51"} %hier einfach die beiden Nummern entsprechend ändern

\sectionn{Flussdiagramm}
\begin{center}
\includegraphics[type=pdf,ext=.pdf,read=.pdf]{"../Versuch 7/versuch7_small"} %Hier gebt ihr den Pfad zu eurem Flussdiagramm im pdf-Format an.
\end{center}


%############### Versuch 8

\chaptern{Versuch 8}%Versuchsnummer ndern

\sectionn{Versuchsziel} %schreibt was zum Versuch
\begin{quote}
Ziel dieses Versuches war es, das Zeitsignal einer DCF77-Funkuhr zu empfangen, zu decodieren und gut lesbar auf einem Display anzuzeigen
\\[5mm]
Hierbei wurde zusätzlich eine LED angeschlossen, welche bei Pulshöhen leuchtet. Jede Sekunde leuchtet diese 100 bzw. 200 ms auf. Lediglich in der letzten Sekunde jeder Minute erfolgt keine Pulshöhe als Indikator für das Ende der Minute.
\\[5mm]
Das Programm wurde dabei von uns in 4 größere  Unterprogramme unterteilt. "\textit{Init}" Initialisiert dabei den Timer und die LCD-Kommunikation. Der Timer0 wird hierbei im Modus 0 benutzt, um nach dem Senden der LCD--Befehle 5 ms zu warten. Auch wird damit in Impulstiefen ein Zähler im 10 ms Takt betrieben, um die Länge der Pause zu bestimmen. Das LCD--Dispay wird während der Initialisierung mehrfach über einen Software--Befehl zurück gesetzt, um dessen Speicher und Anzeige tatsächlich zu resetten. Während der Initialisierung wird zudem \texttt{init} auf dem Display angezeigt.
\\[5mm]
Danach betritt das Hauptprogramm eine Endlos--Schleife, in der es die Unterprogramme "\textit{Puls}", "\textit{Analyse}" und "\textit{Decoder}" aufruft.
\\[5mm]
"\textit{Puls}" schaltet zunächst über das Programm "\textit{LED}" die LED bei Pulshöhen ein, bzw. bei Pulstiefen aus. Danach wird auf ein Pulstief gewartet, die LED ausgeschaltet und bestimmt, wie lange es zum nächsten Pulshoch dauert. Hierbei wird ein Zähler im 10 ms Takt erhöht. Der damit erreichte Wert entspricht ungefähr der  durch 10 ms geteilten Zeitdauer zwischen zwei Impulsen. Dieser Wert sollte idealerweise 80 für Bitwert 1 und 90 für Bitwert 0 betragen. Um Ungenauigkeiten zu vermeiden, wird nun geprüft, ob es in den Intervallen (0,75] (Fehler), (75,85] (Bitwert 1), (85,95] (Bitwert 0), (95,105] (Fehler) oder (105,$\infty$] (Minuten--Ende) liegt. Das Minuten--Ende sollte etwa 1800 ms-1900 ms betragen, den Bereich 950-1050 als Fehlerpuffer zu benutzen hat jedoch ausgereicht, daher vergleichen wir hier mit 1050 ms für das Minuten--Signal. Der Typ des aktuellen Signals wird nun in den ACC kodiert und gespeichert.
\\[5mm]
"\textit{Analyse}" inkrementiert dabei einen Zeiger auf die Speicherstelle der aktuellen Sekunde. Der Speicherbereich beginnt dabei bei 30h. Danach zeigt es den Typ des aktuellen Bits in der Konsole an, wobei das Minuten--Signal \texttt{CR+LF} ausgibt. Außerdem wird der Typ nun an die Speicherstelle geschrieben, zu der der Sekundenzeiger zeigt. Wird ein Minuten--Signal empfangen, wird hier zudem noch R3 überprüft, welche die Ausgabe und Dekodierung abschalten kann. Dieser Wert wird bei Fehlern oder der Initialisierung auf 1 bzw. 2 gesetzt und lässt Dekodierung und Ausgabe nur zu, wenn die entsprechende Menge an Minuten-Signalen vorher bereits gezählt wurde. R3=1 lässt das Programm also bis zur nächsten Minute warten, um 59 Fehlerfreie Sekunden--Bits zu erhalten.
\\[5mm]
"\textit{Decoder}" überprüft auch zunächst R3 und stoppt bei $R3\neq0$. Zusammengefasst überprüft "\textit{Decoder}" ob die aktuelle Sekunde einen Informationsblock (Stunde, Minute, Datum etc.) abschließt, überprüft das Prüfbit und gibt das entsprechende Zeichen auf dem LCD-Display aus.\\
Im Detail  prüft es zunächst auf Minutenanfang, ob nun eine vollständige Minute vorliegt. Danach wird nun die 35. Sekunde als Stunden-Prüfbit mittels "\textit{Pruf}" überprüft. Das Programm erwartet in R1 die Adresse des Prüfbits (34d+30h$\Rightarrow$54h) und in R5 die Anzahl der betroffenen Bits (\{29-34\}+\{35\}=7) und gibt bei Fehlern im ACC=1 aus. Tritt ein Fehler auf, zeigt "\textit{Fehler}" \texttt{FEHLER} im LCD an, setzt R3 auf 1, um bis zum nächsten Minutensignal zu warten, und verlässt das Unterprogramm.\\
Hier sollte erwähnt werden, dass das Signal der 1. Sekunde bei 30h abgespeichert wird, die Adresse der 35. Sekunde also mit $34d+30h=54h$ berechnet wird.\\


Ohne Fehler wird nun die aktuelle Stunde ausgewertet. Dazu wird das Bit der 34. Sekunde ausgelesen (für 20 Stunden), um eine Stelle nach links verschoben und mit dem Bit der 33. Sekunde (für 10 Stunden) addiert. Um die Zahl als Text darzustellen wird nun 30h addiert (e.g. 4d+30h=34h= "4"). Man erhält die somit erste Stelle der Stunde. 
Dies wiederholt man mit dem 32-29. Sekundenbit (8, 4, 2, 1 Stunden) für die 2. Stelle der Anzeige. Nun wird ein ":" angezeigt und mit der Prüfung des Minuten--Prüfbits wie oben gezeigt, fortgefahren. Stimmt die Prüfung, werden hier die Sekunden--Bits 27-25 (40, 20, 10 Minuten) bzw. 24-21 (8, 4, 2, 1 Minuten) ausgewertet und angezeigt.


Wird das Programm bei Sekunde 43 ausgeführt, wird nun an den vorangegangen Teil mit dem gleichen Verfahren der Tag und "." angehangen. In der 50. Sekunde dann der Monat und in der 56. das Jahr. Da mit der 56. Sekunde auch das Prüfbit für das Datum verfügbar wird, wird es auch hier überprüft. Im Anschluss erfolgt die Ausgabe des Wochentags in der 2. LCD--Anzeigen--Zeile. Hierbei wird im Unterschied zu vorher jedoch nicht 30h addiert, sondern mit 0 bis 6 verglichen, wobei 0 Sonntag, 1 Montag,... und 6 Samstag bedeutet.
Der Wochentag wird dabei abgekürzt in der 2. Zeile des LCD angezeigt angezeigt (e.g. \texttt{So} Für Sonntag).
\end{quote}
\pagebreak
\sectionn{Quellcode}
\lstinputlisting{"../Versuch 8/Versuch 8.a51"} %hier einfach die beiden Nummern entsprechend ändern
\newsubfloat{figure}
\begin{figure}
\sectionn{Flussdiagramm}
\subtop[Gesamtablauf]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./gesamt"}}
\subtop[Init]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./init"}}
\subtop[Timerinit]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./timerinit"}}
\subtop[Uhrinit]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./uhrinit"}}
\subtop[LCD-Befehl]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./befehl"}}
\subtop[LCD-Zeichen]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./zeichen"}}
\subtop[delay (5ms)]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./delay5"}}
\end{figure}
\begin{figure}\setcounter{subfigure}{7}
\subtop[Puls]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./puls"}}
\subtop[LED]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./LED"}}
\subtop[Cleardisplay]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./cleardisplay"}}
\subtop[Cursorhome]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./cursorhome"}}
\subtop[Zeile 2]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./zeile2"}}
\end{figure}
\begin{figure}\setcounter{subfigure}{12}
\subtop[Analyse]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./analyse"}}
\setcounter{subfigure}{23}
\subtop{
\begin{minipage}{0.5\textwidth}\setcounter{subfigure}{13}
\subtop[Fehler]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./fehler"}}
\subtop[Pruf]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./pruf"}}
\subtop[Trans]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,scale=1.5]{"./trans"}}
\end{minipage}
}
\end{figure}
\begin{figure}\setcounter{subfigure}{16}
\subtop[Decoder]{\includegraphics[type=pdf,ext=.pdf,read=.pdf,width=\textwidth]{"./decoder"}}
\end{figure}
%############################################################
%     für weitere Projekte den Teil bis hier kopieren       %
%############################################################


\end{document}
