echtzeitsysteme.tex

\chapter{Echtzeitsysteme}

Zusammenfassung der Vorlesung "`Echtzeitsysteme"' von Professor Längle, Professor Hein und Professor Wörn aus dem Sommersemester 2014.\footnote{\url{http://rob.ipr.kit.edu/lehrangebote_728.php}}



\section{Grundlagen für Echtzeitsysteme in der Automatisierung}

Bei Echtzeitsystemen kommt es neben der logischen Korrektheit auch auf die zeitliche Korrektheit der Ergebnisse an.

\subsection{Anforderungen an Echtzeitsysteme}
\begin{itemize}
	\item Rechtzeitigkeit
	\item Gleichzeitigkeit
	\item Verfügbarkeit
\end{itemize}

\subsubsection{Rechtzeitigkeit}
Die Ausgabedaten müssen rechtzeitig berechnet werden und zur Verfügung stehen.

\subsubsection{Gleichzeitigkeit}
Die Gleichzeitigkeit bedeutet, dass die Rechtzeitigkeit für mehrere Aktionen gleichzeitig gewährleistet sein muss.

\subsubsection{Verfügbarkeit}
Die Verfügbarkeit: Echtzeitsysteme müssen über einen längeren Zeitraum hinweg verfügbar sein, einige sogar rund um die Uhr für 24 Stunden. Verfügbarkeit erfordert keine Unterbrechungen des Betriebs für Reorganisationsphasen.

\subsection{Gütekriterien für Echtzeitsysteme}
\begin{itemize}
	\item Stabilität
	\item Genauigkeit
	\item Schnelligkeit
\end{itemize}


\subsubsection{Varianten zur Angabe einer Zeitbedingung}
\begin{itemize}
	\item Angabe eines genauen Zeitpunkts
	\item Angabe eines spätesten Zeitpunkts
	\item Angabe eines frühesten Zeitpunkts
	\item Angabe eines Zeitintervalles
\end{itemize}

\subsection{Wertfunktionen zur Bewertung von Zeitbedingungen}
\begin{itemize}
	\item Weiche Echtzeitbedingungen: Kann in gewissen Grenzen überschritten werden ohne zu fatalen Systemzuständen zu führen
	\item Feste Echtzeitbedingungen: Bewirken bei Überschreitung einen Abbruch der Aktion
	\item Harte Echtzeitbedigungen: Müssen eingehalten werden, anderenfalls droht Schaden
\end{itemize}


\subsection{Wirkungskette einer Steuerung}
Die Steuerung ist ein Vorgang in einem abgegrenzten System, bei dem eine oder mehrere Größen als Eingangsgrößen andere Größen als Ausgangsgrößen aufgrund der dem System eigenen Gesetzmäßigkeiten beeinflussen.\footnote{DIN 19226}
\begin{enumerate}
	\item Steuerglied
	\item Stellglied
	\item Prozess/Strecke
\end{enumerate}

\subsubsection{Übergangsfunktionen}
\begin{itemize}
	\item Sollwert (Führungsgröße): \(w(t)\)
	\item Steuersignal: \(u(t)\)
	\item Stellgröße: \(y(t)\)
	\item Steuergröße: \(x(t)\)
\end{itemize}

\subsection{Wirkungskette einer Regelung}
Die Regelung ist ein technischer Vorgang in einem abgegrenzten System, bei dem eine technische oder physikalische Größe (Regelgröße oder Istwert), fortlaufend erfasst und durch Vergleich ihres Signales mit dem Signal einer anderen von außen vorgegebenen Größe (Sollwert), im Sinne einer Angleichung an die Führungsgröße beeinflusst wird.\footnote{DIN 19226}

\begin{itemize}
	\item Regler
	\item Stellglied
	\item Prozess/Strecke
	\item Messglied für Istwert
\end{itemize}

\subsubsection{Vorgehen Entwurf eines Reglers}
\begin{enumerate}
	\item Anforderungen definieren, speziell Stabilität, Schnelligkeit, Genauigkeit
	\item Ermitteln des Modells der Strecke
	\item Wahl Reglertyp
	\item Optimieren des Streckenmodells durch Simulation
	\item Realisieren des Reglers, experimentelle Überprüfung und Optimierung
\end{enumerate}


\subsection{PID-Regler}
\(w \rightarrow Regler~R(s) \rightarrow Strecke~H(s) \rightarrow x\)

\begin{enumerate}
	\item P-Regler: \(R(s) = K_P\)
	\item PI-Regler: \(R(s) = K_P(1+\frac{1}{T_Ns})\)
	\item PD-Regler: \(R(s) = K_P(1+T_Vs)\)
	\item PID-Regler: \(R(s) = K_P(1+\frac{1}{T_Ns}+T_Vs)\)
\end{enumerate}


\subsection{Das Abtasttjeorem nach Shannon}
Das Abtasttheorem besagt, dass ein auf \(f_{max}\) bandbegrenztes Signal mit einer Frequenz von mindestens \(2\cdot f_{max}\) abgetastet werden muss, damit man es aus dem zeitdiskreten Signal wieder exakt rekonstruieren kann. Die exakte Rekonstruktion ist dabei nur theoretisch möglich, da hierzu eine unendliche Anzahl an Abtastpunkten nötig wäre. In der Praxis beschränkt man sich deswegen darauf, das ursprüngliche Signal möglichst gut zu interpolieren.\footnote{\url{http://de.wikipedia.org/wiki/Nyquist-Shannon-Abtasttheorem}}

\subsection{Bode-Diagramm}
Das Bode-Diagramm dient der Darstellung des Übertragungsverhaltens eines dynamischen Systems, auch Frequenzantwort oder Frequenzgang genannt.
Das Bode-Diagramm wird, wie auch die anderen Diagramme, aus mathematischen Systembeschreibungen durch Differentialgleichungen hergeleitet und berechnet.\footnote{\url{https://de.wikipedia.org/wiki/Bode-Diagramm}}



\section{Rechnerarchitekturen}

\subsection{Mikrorechner}
\begin{itemize}
	\item Bestandteile: \textit{Mikroprozessor} (Prozessokern, Steuerwerk, Rechenwerk), Hauptspeicher, IO
	\item Verbindungseinrichtung, Bus-System
	\item Wird durch Peripheriegeräte zum \textit{Mikrorechnersystem}
\end{itemize}


\subsection{Unterbrechungen}
\begin{itemize}
	\item \textbf{Unterbrechungsarten}
	\begin{itemize}
		\item Exception: Fehlersituation im Prozessorkern
		\item Software Interrupt: Unterbrechungswunsch eines laufenden Programms
		\item Hardware Interrupt: Unterbrechungswunsch durch externe Hardwarekomponenten
	\end{itemize}
	\item Behandlung per \textit{Interrupt Service Routine}, Zwischenspeichern des Prozessorstatus auf den Stackspeicher mit anschließendem Wiederherstellen
	\item Auslösen im Mikroprozessor: Externe Untebrechung, Quitting, Vektor -> Datenbus
	\item Prioritätsebene, gespeichert im Interrupt-Maskenregister (Teil des Steuerregisters)
	\item Viele Prioritätsebenen: Dezentral (Daisy-Chain) oder mittels zentralem Controller
\end{itemize}

\subsubsection{Reaktionsmöglichkeiten auf Unterbrechungen}
\begin{itemize}
	\item Taskabbruch
	\item Taskwechsel: Verdrängung durch höhere Priorität
	\item Kein Taskwechsel: Zurückstellung bei Unterbrechung mit einer niedrigeren Priorität
\end{itemize}


\subsection{Signalprozessor}
\begin{itemize}
	\item Hardvard-Architektur
	\item Hochleistungsarithmetik
	\item Hohe, benutzerbestimmbare Parallelität
\end{itemize}


\subsection{Microcontrollers}
\begin{itemize}
	\item Prozessor
	\item RAM
	\item ROM, EORPM, EEPROM
	\item Takt
	\item Ein-/Ausgabesteuerung
	\item Unterbrechungssteuerung
	\item Zähler/Zeitgeber
	\item Erweiterungbusschnittstelle
\end{itemize}
Ziel: Möglichst wenig externe Bausteine für eine Steuerungsaufgabe.

\subsubsection{Speicher für Mikrokontroller}
\begin{itemize}
	\item Flüchtiger Speicher (RAM)
	\begin{itemize}
		\item Statischer Speicher
		\item Dynamischer Speicher
	\end{itemize}
	\item Nichtflüchtiger Speicher (ROM)
	\begin{itemize}
		\item Einmal beschreibbar: ROM, PROM
		\item Wiederbeschreibbar: EPROM, EEPROM, FlashRAM
	\end{itemize}
\end{itemize}

\subsubsection{Aufbau Zähler-/Zeitgebereinheit}
\begin{itemize}
	\item Aufgaben: Zählen von Ereignissen, Erzeugen von Impulsfolgen, Messen von Zeiten
	\item Über den internen Datenbus angebunden
	\item Externen Takt notwendig
\end{itemize}

\subsubsection{Watchdog}
\begin{itemize}
	\item Spezieller Zähler, der bei Ablauf einen Reset auslöst
	\item Muss regelmäßig von der Software angesprochen werden ("`Totmannschalter"')
	\item Anbindung über den internen Datenbus
\end{itemize}

\subsubsection{Serielle und parallele Ein-/Ausgabekanäle}
\begin{itemize}
	\item Auswahl der Komponente über den internen Adressbus
	\item Anbindung zur Datenübertragung über den internen Datenbus
\end{itemize}

\subsubsection{Aufbau einer Echtzeit-Ausgabeeinheit}
\begin{itemize}
	\item Ports, deren Verhalten nicht von der Software, sondern von einem Zeitgeber gesteuert werden
	\item Ausgabe idealerweise jitterfrei
\end{itemize}

\subsubsection{Direct Memory Access}
\begin{itemize}
	\item Daten direkt, ohne Beteiligung des Prozessorkerns zwischen Peripherie und Speicher transportieren
	\item Prozessor definiert lediglich Randbedingungen: Speicheradresse, Peripherieadresse, Anzahl Zeichen
	\item Ende der Übertragung durch Unterbrechungssignal
\end{itemize}


\subsection{Busse}


\subsection{Augaben Feldbusse}
\begin{itemize}
	\item Echtzeitfähigkeit
	\item Robustheit
	\item Interoperabilität
\end{itemize}


\subsubsection{Datenbuss}
\begin{itemize}
	\item Prozessorabhängig: Mikroprozessor als Master Device
	\item Prozessorunabhängig: Komponenten am PCI-Bus über Pentium-PCI-Bus Bridge ausgelagert
	\item Gepufferter, entkoppelter Bus: Erweiterung des prozessorunabhängigen Bus, da bei einem zentralen Bus langsame Geräten den Bus blockieren $\rightarrow$ Verletzung der Echtzeitbedingungen
\end{itemize}

\subsubsection{Busbetrieb}
\begin{itemize}
	\item (Nicht-)multiplex-Betrieb
	\item Weiter Kriterien: Synchronisationsart, Übertragungsart, Busbreite, Taktfrequenz, Max. Übertragungsrate/Datentransportbreite
\end{itemize}

\subsubsection{Buszuteilung}
\begin{itemize}
	\item Master: Aktiver Zugriff auf den Bus
	\item Slave: Passiver Zugriff auf den Bus
	\item \textbf{Mehrere Busmaster}
	\begin{itemize}
		\item Mehrere Busmaster: Verfahren zur Zuteilung notwenig. Kann im einfachsten Fall durch den Mikroprozessor geschehen
		\item Externer Bus-Arbiter: Schiedsrichter über die Bus-Zuteilung, Master muss aktiven Zustand anfordern. Aufbau wahlweise zentral oder dezentral per Daisy Chain
	\end{itemize}
\end{itemize}

\subsubsection{Echtzeitaspekte von Systembussen}
\begin{itemize}
	\item Zeitliche Vorhersagbarkeit von zentraler Bedeutung
	\item Einfaches System, synchroner Bus, keine Wartezyklen: Deterministisches Zeitverhalten
	\item Einfaches System, synchroner Bus, Wartezyklen: Wenn Wartezyklen bekannt, dann deterministisch, ansonsten Obergrenze einführen
	\item Mehrere Busmaster: Echtzeitverhalten vom Verhalten im Konfliktfall abhängig
\end{itemize}

\subsubsection{PCI-Bus Transferarten}
\begin{itemize}
	\item Standardtransfer: <Adresse>(<Wartezyklus>)<Datum>
	\item Bursttransfer: <Adresse>(<Wartezyklus>)<Datum><Datum><Datum>
\end{itemize}


\subsection{VME-Bus}

Echtzeitfähiges Bussystem, war lange Zeit das dominierende System für Automatisierungsrechner, wird allerdings zunehmend durch den PCI-Bus verdrängt (höhere Übertragungsraten).

\subsubsection{Wichtige Eigenschaften}
\begin{itemize}
	\item Prozessorunabhängigkeit
	\item Signal-orientiert und asynchron
	\item Kein Multiplex, burst-fähig, fehlererkennend
\end{itemize}

\subsubsection{Transfer}
\begin{itemize}
	\item Einzeltransfer: Einzelne Adresse über den Adressbus, einzelnes Datum über den Datenbus
	\item 32-Bit-Bursttransfer: Einzelne Adresse über den Adressbus, mehrere Daten über den Datenbus
	\item 64-Bit-Bursttransfer: Gemeinsame Nutzung von Daten- und Adressbus, jeweils im Burstmodus
	\item Bestandteile: Bus-Manager, Bus-Master, Bus-Slave
\end{itemize}


\subsection{Schnittstellenbausteine}
Verbindung von Mikrorechner und Umwelt.
\begin{itemize}
	\item Pufferung von IO
	\item Umsetzung der Daten (z.B. parallel $\leftrightarrow$ seriell oder digital $\leftrightarrow$ analog)
	\item Erzeugen von Steuer- und Handshake-Signalen
	\item Annahme und Erzeugen von Unterbrechungsanforderungen
	\item Werden wie Speicher durch IO angesprochen
\end{itemize}



\section{Hardwareschnittstelle zwischen Echtzeitsystem und Prozess}

\subsection{Netzberechnung}
\begin{itemize}
	\item Knotenregel: Die Summe aller Ströme in einem Knoten ist $0$, es entstehen oder verschwenden keine Ströme.
	\item Maschenregel: Die Summe aller Spannungen in einer Masche ist $0$.
\end{itemize}


\subsection{Transistoren}
Grundbaustein aller elektrischen Schaltungen.

\subsubsection{Transistor als Verstärker}
Es ergibt sich eine Leistungsverstärkung, da sowohl Spannung, als auch Strom verstärkt werden.


\subsubsection{Transistor als Schalter}
Der Transistor wird lediglich in den Zuständen \textit{Sättigung} und \textit{Gesperrt} ($U_{BE} < 0,6 V$) betrieben.


\subsection{AD-Wandler}

\subsubsection{Wägeverfahren}
\begin{itemize}
	\item \textbf{Bestandteile}
	\begin{itemize}
		\item Abtast-Halte-Glied: Hält die Eigangsspannung wärend des Abtastvorgangs konstant
		\item Komparator: Vergleicht die Engangsspannung
		\item Datenspeicher
		\item Steuerlogik
		\item Taktgenerator
	\end{itemize}
	\item \textbf{Vorgehen}
	\begin{enumerate}
		\item Setze alle Bits im Datenspeicher gleich $0$
		\item Beginnend beim höchstwertigen Bits werden schrittweise alle Bits des Digitalwerts ermittelt, in dem über einen DA-Wandler Referenzspannungen generiert werden
	\end{enumerate}
\end{itemize}

\subsubsection{Kompensationsverfahren}
\begin{itemize}
	\item Nutzt ebenfalls generierte Spannungen als Referenz
	\item Zähler, der vorwärts und rückwärts zählen kann, hält den zu wandelten Wert
	\item Koparatorergebnis steuert die Zählrichtung
	\item Ergebnis in maximal $N$ Schritten vorhanden
\end{itemize}

\subsubsection{Parallelverfahren}
\begin{itemize}
	\item Vergleich der Eingangsspannung mit $2^n-1$ Referenzspannungen über einen Spannungsteiler und speichert die Resultate in Flip-Flops
	\item Schnellstes Verfahren, kann Signale im GHz-Bereich verarbeiten
	\item Nachteil: Hoher Aufwand und hohe Zahl an Bauelementen
\end{itemize}

\subsubsection{Vergleich verschiedener Verfahren}
Auswahl des Verfahrens nach Zielfrequenz und Zielauflösung.
\begin{itemize}
	\item Kompensationsverfahren, Zählverfahren
	\item Wägeverfahren
	\item Parallelverfahren
\end{itemize}


\subsection{Asynchrone Datenübertragung}

\subsubsection{Rs-232}

\begin{itemize}
	\item Space ($+$, Übertragung der $0$) und Mark ($-$, Übertragung der $1$)
	\item \textbf{Verfahren}
	\begin{enumerate}
		\item Ruhepegel
		\item Statusbit ($0$)
		\item Übertragung des Datums, LSB $\rightarrow$ MSB
		\item Stopbit ($1$, abhängig vom gewählten Verfahren)
		\item Ruhepegel
	\end{enumerate}
\end{itemize}

\subsubsection{RS-422}
Analog wie RS-232, allerdings größere Entfernung (1200 m) und höhere Datenraten (100 kBit/s) möglich.



\section{Echtzeitkommunikation}

\subsection{Zugriffsverfahren auf Echtzeitkommunikationssysteme}
\begin{itemize}
	\item Polling
	\item CSMA/CD und CSMA/CA
	\item Token-Passing (Obergrenze für Medienzugreifzeit möglich)
	\item TDMA (Time Division Multiple Access)
\end{itemize}


\subsection{Netzwerkprotokolle}

\subsubsection{Ethernet-Frame}
\begin{itemize}
	\item \textbf{Header}
	\begin{itemize}
		\item Präambel: Wechselnde 4 Bit Folge zur Synchonisation
		\item Start Frame Delimeter: Beginn des Adressfeld
		\item Zieladresse
		\item Quelladresse
	\end{itemize}
	\item Datenfeld: 46 - 1500 Byte
	\item CRC-Checksummer (Trailer)
\end{itemize}

\subsubsection{Internet Controll Message Protocol (ICMP)}
\begin{itemize}
	\item Flusskontroller
	\item Erkennen von unerreichbaren Zielrechnern
	\item Routenoptimierung
	\item Überprüfen von erreichbaren Hosts
\end{itemize}

\subsubsection{CSMA/CD}
\begin{itemize}
	\item \(T_{Paket} \ge 2 \cdot T_{Prop}\)
\end{itemize}

\subsubsection{Overhead der Protokoll/Schicht}
\begin{itemize}
	\item Ethernet 26 Byte
	\item IPv4: 24 Byte
	\item TCP: 24 Byte
\end{itemize}


\subsection{Kodierungen}

\subsubsection{Manchester Kodierung}
\begin{itemize}
	\item XOR von Takt und Signal
	\item Benötigt kein externes Taktsignal zwischen Sender und Empfänger \(\rightarrow\) wird aus dem Signalverlauf abgeleitet
	\item Benötigt doppelte Bandbreite im Vgl. zu NRZ. Pro Nutzdatenbit werden zwei Signalzustände benötigt
\end{itemize}


\subsection{Busse}

\subsection{Profibus}
PROFIBUS (Process Field Bus) ist ein Standard für die Feldbus-Kommunikation in der Automatisierungstechnik.\footnote{\url{http://de.wikipedia.org/wiki/Profibus}}

\subsubsection{Hybrides Zugriffsverfahren}
\begin{itemize}
	\item Token-Passing unter den aktiven Stationen (Multi-Master)
	\item Polling zwischen einem Master und den dazugehörigen Slaves
\end{itemize}


\subsection{Interbus}
Interbus ist ein Feldbussystem für einen breiten Einsatz in einem Unternehmen. Interbus deckt verschiedene Applikationsbereiche ab, von Sensor/Aktor-Ebene in der Prozess-Automatisierung, bis zu Überwachungs-PC.\footnote{\url{http://de.wikipedia.org/wiki/Interbus}}

\subsubsection{Eigenschaften}
\begin{itemize}
	\item Topologie: Aktiver Ring
	\item Buslänge: Fernbus max. 12,8 km und Pripheriebus max. 10 m
	\item Übertragungsrate: 500 kBit/s
	\item Buszugriffsverfahren: Festes Zeitraster
	\item Busverwaltung: Monomaster
\end{itemize}

\subsubsection{Komponententypen}
\begin{itemize}
	\item Master
	\item Busklemme zur Verzweigung
	\item IO-Modul (Peripheriebusgerät)
	\item IO-Modul (Fernbusgerät)
\end{itemize}

\subsubsection{Bus-Beispiele}
\begin{itemize}
	\item Steuergeräte in einem Auto: CAN-Bus (hohe Übertragungssicherheit)
	\item Gebäudeautomation: Profibus (große Buslänge, multimasterfähig)
	\item Automation in der Produktion: Interbus (feste MMAT, geringe Latenz)
	\item Regelung Industrieroboter: Sercos (kurze Zykluszeiten, nur wenige Daten, Synchronisierung)
\end{itemize}



\section{Echtzeitprogrammierung}
Das Ergebnis von Echtzeit-Datenverarbeitung ist nur dann korrekt, wenn es logisch und zeitlich korrekt ist.


\subsection{Synchrone Programmierung}
\begin{itemize}
	\item Zeitliches Verhalten periodischer Aktionen ist vorgeplant
	\item Die periodischen Aktionen werden in einem Zeitraster synchronisiert
	\item Die Reihenfolge des Ablaufs ist fest vorgegeben
	\item \textbf{Vorteile}
	\begin{itemize}
		\item Festes, vorhersagbares Zeitverhalten
		\item Einfaches Analyse und Testen
		\item Gut für zyklische Abläufe anwendbar
		\item Kann bei guter Planung Rechtzeitigkeit und Gleichzeitigkeit garantieren
	\end{itemize}
	\item \textbf{Nachteile}
	\begin{itemize}
		\item Geringe Flexibilität gegenüber Änderungen
		\item Reaktionen auf aperiodische Ereignisse sind nicht vorgesehen (synchron nur durch periodische Überwachung möglich)
	\end{itemize}
\end{itemize}


\subsection{Asynchrone Programmierung}
Ablaufplanung der Aktionen zur Laufzeit durch ein Organisationsprogramm (Echtzeitbetriebssystem).

\begin{itemize}
	\item Flexibler Programmablauf und flexible Programmstruktur
	\item Reaktion auf periodische und aperiodische Ereignisse
	\item Rechtzeitigkeit nicht immer im Voraus garantierbar
	\item Systemtests und Systemanalyse schwierig
\end{itemize}

\subsubsection{Aufgaben des Organisationsprogramms (Echtzeitscheduling)}
\begin{itemize}
	\item Ereignisse überwachen
	\item Informationen über Zeitbedingungen entgegennehmen
	\item Ablaufreihenfolge von Teilprogrammen der eingetretenen Ereignisse ermitteln
	\item Teilprogramme gemäß der ermittelten Ablaufreihenfolge aktivieren
\end{itemize}

\subsubsection{Fixed Priority Preemptive Scheduling}
\begin{itemize}
	\item Feste Prioritäten, Reihenfolge der Ausführung richtet sich danach
	\item Ereignisse mit hoher Priorität unterbrechen Ereignisse mit niedriger Priorität
	\item Bearbeitung des niedrig priorisieten Ereignisses wird erst wieder aufgenommen, wenn alle höher priorisierten abgearbeitet sind
\end{itemize}



\section{Echtzeitbetriebssysteme}

\subsubsection{Aufgaben eines Echtzeitbetriebssystems}
\begin{itemize}
	\item Taskverwaltung
	\item Betriebsmittelverwaltung
	\item Interprozesskommunikation
	\item Synchronisation der Tasks
	\item Schutz der Betriebsmittel vor unberechtigtem Zugriff von Tasks
	\item Wahrung der Rechtzeitigkeit und Gleichzeitigkeit
	\item Wahrung der Verfügbarkeit
\end{itemize}


\subsection{Makrobetriebssystem}

\subsubsection{Schichtenmodell eines Makrobetriebssystems}
\begin{itemize}
	\item Anwendung
	\item API/Shell
	\item Taskverwaltung
	\item Betriebsmittelverwaltung
	\item Speicherverwaltung/IO-Verwaltung
	\item IO-Steuerung
	\item Gerätetreiber
	\item Prozessor
\end{itemize}


\subsection{Mikrobetriebssystem}

\subsubsection{Schichtenmodell eines Mikrobetriebssystems}
\begin{itemize}
	\item \textbf{Erweiterungsmodule}
	\begin{itemize}
		\item Anwendung
		\item API/Shell
		\item Taskverwaltung
		\item Betriebsmittelverwaltung
		\item Speicherverwaltung/IO-Verwaltung
		\item IO-Steuerung
		\item Gerätetreiber
	\end{itemize}
	\item \textbf{Mikrokern}
	\begin{itemize}
		\item Erweiterungsmodule im Userspace
		\item Interprozesskommunikation
		\item Synchronisation
		\item Taskverwaltung
	\end{itemize}
	\item Prozessor
\end{itemize}

\subsubsection{Vorteile}
\begin{itemize}
	\item Sehr gut an die Aufgabe anpassbar
	\item Hohe Skalierbarkeit durch Erweiterungsmodule
	\item Einfache Portierbarkeit
	\item Preemptiver Kern
	\item Kurze kritische Bereiche
\end{itemize}


\subsection{Echtzeitscheduling}
Aufteilung des Prozessors zwischen allen ablaufwilligen Tasks derart, dass - sofern möglich - alle Zeitbedingungen eingehalten werden.


\subsection{Scheduling-Verfahren}

\subsubsection{FirstIn-FirstOut}
\begin{itemize}
	\item Wer zuerst kommt erhält den Prozessor
	\item Dynamisch, nicht-preemptive, ohne Prioritäten
	\item Wenig geeignet für Echtzeit, da keinerlei Zeitbedingungen
\end{itemize}

\subsubsection{Fixed-Priority-Scheduling}
\begin{itemize}
	\item Jeder Task erhält fixe Piorität
	\item Dynamisches Scheduling, statische Prioritäten
	\item Wahlweise (nicht-)preemptiv
	\item Vergabe von Prozessorzuteilung: \(\frac{Ausfuehrungszeit}{Maximalzeit}\)
	\item Prozessorauslastung:\(\sum Prozessorzuteilung_i\)
\end{itemize}

\subsubsection{Rate-Monotonic-Scheduling}
\begin{itemize}
	\item Periodisch auszuführende Tasks erhalten Prioritäten: \(PR_i =\frac{1}{Maximalzeit}\) 
	\item Preemptiv
\end{itemize}

\subsubsection{Earliest-Deadline-First-Scheduling}
\begin{itemize}
	\item Diejenige Task, die am nächsten an der eigenen Zeitschrank ist, erhält den Prozessor
	\item Scheduling und Prioritäten ergeben sich dynamisch
	\item Wahlweise (nicht-)preemptiv
\end{itemize}

\subsubsection{Least-Laxity-First-Scheduling}
\begin{itemize}
	\item Diejenige Task, die den geringsten Spielraum hat, erhält den Prozessor
	\item Dynamisches Scheduling mit dynamischen Prioritäten
	\item Wahlweise (nicht-)preemptiv
	\item Vergleich zu EDF: Deutlich mehr Taskwechsel, allerdings besser bei Überlast
	\item Spielraum: \(I_i = deadline_i -(t+Restausfuehrungszeit_i)\)
\end{itemize}

\subsubsection{Time-Slice-Scheduling}
\begin{itemize}
	\item Zuordnen von individuellen, festen Zeitscheiben
	\item Preemptives, dynamische Scheduling ohne Prioritäten
\end{itemize}

\subsubsection{Guaranteed Percentage Scheduling}
\begin{itemize}
	\item Zuordnen von festen Prozentsätzen der verfügbaren Prozessorleitung innerhalb einer Periode
	\item Preemptives, dynamische Scheduling ohne Prioritäten
	\item Auf Einprozessorsystem ein optimales Verfahren
\end{itemize}


\subsection{Synchronisation}

\subsubsection{Gemeinsame Betriebsmittel}
\begin{itemize}
	\item Daten
	\item Geräte
	\item Programme
\end{itemize}

\subsubsection{Synchronisationsvarianten}
\begin{enumerate}
	\item Sperrsynchronisation mit Mutex (wechselseitiger Ausschluss), bei belegtem Mutex wird die zugreifende Task verzögert, bis der Mutex frei ist
	\item Reihenfolgensynchronisation mit Semaphoren, Operationen: Passiere, Verlasse
\end{enumerate}

\subsubsection{Deadlocks}
Mehrere Tasks warten auf die Freigabe von Betriebsmitteln, die sich gegenseitig blockieren.

\subsubsection{Gegenmaßnahmen}
\begin{itemize}
	\item Abhängigkeitsanalyse
	\item Vergabe der Betriebsmittel in gleicher Reihenfolge
	\item Timeout
\end{itemize}

\subsubsection{Livelocks}
Eine Task wird durch andere Tasks ständig an der Ausführung gehindert.


\subsection{Kommunikation zwischen Tasks}
\begin{itemize}
	\item Gemeinsamer Speicher
	\item Austausch von Nachrichten
\end{itemize}


\subsection{IO-Verwaltung}

\subsubsection{Aufgaben}
\begin{itemize}
	\item Zuteilung und Freigeben von Geräten
	\item Benutzen von Geräten
\end{itemize}
Schwierigkeit: Bieten einer transparenten Schnittstelle bei sehr unterschiedlichen Geräten, die sich in Geschwindigkeit und Datenformat stark unterscheiden.

\subsubsection{Aufgaben im Detail}
\begin{itemize}
	\item Symbolische Namensgebung
	\item Synchronisation und Schutz der Geräte
	\item Kommunikation mit den Gerätetreibern über Schnittstellenbausteine
	\item Pufferung und einheitliches Datenformt
\end{itemize}

\subsubsection{Synchronisationsmechanismen}
\begin{itemize}
	\item Polling: Einfach und hohe Übertragungsleistung, allerdings ist der Prozessor ständig aktiv, keine Nebenaktivitäten
	\item Busy Waiting (Periodisches Einschieben von Nebenaktivitäten): Nebenaktivität möglich, allerdings verlangsamte Reaktionszeit und Nebenaktivitäten müssen in kleine Teilschritte unterteilt werden
	\item Interrupt: Beliebige Nebenaktivitäten, schnelle Übertragung, allerdings verringerte Übertragungsraten
	\item Polling mit Handshake: Zusätzlicher Handshake notwendig, falls das Gerät schneller liefert als die Task sie entgegennehen kann
	\item Interrupt mit Handshake: s.o.
\end{itemize}


\subsection{Virtuelle Speicherverwaltung}
Ein größerer Adressraum wird auf einen kleineren physikalischen Adressraum abgebildet. Dies heißt, es müssen Verdrängungen stattfinden, um den Speicherbedarf aller Tasks zu befriedigen.

\begin{itemize}
	\item Lineare oder streuende Adressbildung
	\item Vorteile: Größerer Adressraum, leichteres Abfangen von Zugriffsverletzungen
	\item Nachteile: Aufwendige Realisierung, Verdrängung notwendig, Auflösung von Adressen
\end{itemize}


\subsection{Auswahlkriterien für Echtzeitbetriebssysteme}
\begin{enumerate}
	\item Entwicklungs- und Zielumgebung: Programmiersprache, Zielsystem, Cross-Entwicklung
	\item Modularität und Kerngröße: Konfigurierbarkeit der Anwendung, minimaler Mikrokern für eingebettete Systeme
	\item Anpassbarkeit an verschiedene Zielumgebungen für Automatisierung
	\item Allgemeine Eigenschaften: Shell, Bibliotheken, Werkzeuge
	\item Leistungsdaten
\end{enumerate}

\subsubsection{QNX-Architektur}
\begin{itemize}
	\item Anwendertasks
	\item Systemtasks
	\item Mikrokern
	\item Hardware
\end{itemize}

\subsubsection{Architektur von RTLinux}
\begin{itemize}
	\item Hardware-Echtzeitkern
	\item Linuxkern ist Echtzeitanwendung neben Echtzeittasks
	\item Echtzeit-FIFO
	\item RT-Prozesse werden über Kernel-Module definiert und geladen
\end{itemize}



\section{Echtzeitmiddleware}
\begin{itemize}
	\item Mittler zwischen verteilten Objekten zwischen Kommunikation und Anwendung
	\item Vebirgt die Verteilung
	\item Übernimmt Aufgaben der Identifikation, Lokalisierung, Interaktion, Fehlerbehebung
\end{itemize}

\subsection{Vorteile}
\begin{itemize}
	\item Anwendung muss sich nicht um Verteilung kümmern
	\item Verteile und lokale Anwendung können auf die gleiche Weise entwickelt werden
	\item Bei einer Rekonfiguration muss die Anwendung nicht geändert werden
	\item Alle Aufgaben werden von einer einheitlichen Software übernommen
\end{itemize}

\subsubsection{Abgeleitete Vorteile}
\begin{itemize}
	\item Portierbarkeit wächst
	\item Heterogene Umgebung bleibt verborgen
	\item Testbarkeit und Wartbarkeit wird verbessert
\end{itemize}
Somit werden Entwicklungszeiten und -kosten reduziert.

\subsection{Nachteile}
\begin{itemize}
	\item Zusätzlicher Speicher-Overhead
	\item Zusätzlicher Verarbeitungs-Overhead
	\item Standard-Middleware-Architekturen für Echtzeitanwendungen nicht geeignet (Prioritätsinversion)
\end{itemize}


\subsection{COBRA}

\subsubsection{Architektur}
\begin{itemize}
	\item Application Objects (Anwendung), Object Services (Basisdienste), Common Facilities (Dienste für bestimmte Anwendungsbereiche)
	\item Object Request Broker
	\item Verteiltes, heterogenes Rechnersystem
\end{itemize}

\subsubsection{Features}
\begin{itemize}
	\item Objektmodell: Anwendungen in verschiedenen Sprachen möglich, Interface-Definition per IDL
	\item Aufruf eines entfernten Objektes: IDL-Stub $\rightarrow$ ORB-Kern $\rightarrow$ IDL-Skeleton
\end{itemize}


\subsection{RT-CORBA}
\begin{itemize}
	\item Zeitschranken für Methodenaufrufe
	\item Prioritätsgesteuerte Warteschlangen
	\item EInheitliches Prioritätsschema
	\item Echtzeitfähiger Ereignisdienst
	\item Echtzeitfähige Ausnahmebehandlung
	\item Dienstorientierte Struktur für eingebettet Systeme
\end{itemize}

\subsubsection{Anforderungen}
\begin{itemize}
	\item Synchronisierte Uhren
	\item Echtzeitfähige Kommunikation: Priorisierung der Nachrichten
	\item Echtzeitscheduling
	\item Blockaden-Vermeidung
\end{itemize}



\section{Speicherprogrammierbare Steuerung}
Eine SPS hat im einfachsten Fall Eingänge, Ausgänge, ein Betriebssystem (Firmware) und eine Schnittstelle, über die das Anwenderprogramm geladen werden kann. Das Anwenderprogramm legt fest, wie die Ausgänge in Abhängigkeit von den Eingängen geschaltet werden sollen.\footnote{\url{http://de.wikipedia.org/wiki/Speicherprogrammierbare_Steuerung}}


\subsection{Softwarestruktur einer Soft-SPS}
\begin{itemize}
	\item Anwendungen: Tasks, Visualisierung, Motion Control, usw.
	\item API
	\item RT-Kern
	\item Hardware: Timer, Interrupt Controller, usw.
\end{itemize}


\subsection{SPS-Programmiersprachen}
\begin{itemize}
	\item \textbf{Grafisch}
	\begin{itemize}
		\item Kontaktplan (KOP)
		\item Funktionsplan (FUP)
	\end{itemize}
	\item \textbf{Textuell}
	\begin{itemize}
		\item Anweisungsliste (AWL)
		\item Strukturierter Text (ST)
	\end{itemize}
\end{itemize}


\subsection{Phasen der Softwareentwicklung einer SPS}
\begin{itemize}
	\item Lastenheft
	\item Pflichtenheft
	\item Programmkonzept (Entwurf)
	\item Programmierung
	\item Integration
	\item Test
	\item Wartung und Pflege
\end{itemize}



\section{Werkzeugmaschinen}

\subsection{Prinzip einer NC-Werkeugmaschine}
\begin{enumerate}
	\item NC-WProgramm
	\item Werkzeugmaschine
	\item Werkstück
\end{enumerate}

\subsection{Kaskadensteuerung}
\begin{itemize}
	\item Regler bekommt Soll-Wert, vergleicht mit Ist-Wert und erzeugt Soll-Wert für den nächsten Regler
	\item Synchrone Programmierung: Rein zeitgesteuert, keine asynchronen Ereignisse. Festes Zeitverhalten, einfache Tests und Analysen, leichtes Garantieren von Rechtzeitigkeit und Gleichzeitigkeit
	\item Ablaufdiagramm: Logische Abfolge mit zeitlicher Reihenfolge kombiniert mit Säulen darstellen
\end{itemize}



\section{Robotersteuerung}

\subsection{Wesentliche Komponenten}
\begin{itemize}
	\item Mechanik
	\item Steuerschrank
	\item Programmiergerät
\end{itemize}


\subsection{Informationsfluss und Funktionen}
\begin{itemize}
	\item IO, Speicherebene: Bedienung, Programmierung, Speicherung von Befehlen
	\item Verarbeitungsebene: Sensordatenverarbeitung, Verarbeitung von Logik
	\item Prozess-IO-Ebene: Antrieb, Wegmeßsystem, Sensore, Robotermechanik, Peripherie
\end{itemize}


\subsection{Robotersoftwarearchitektur}
\begin{itemize}
	\item \textbf{Mit Echtzeit-Betriebssystem}
	\begin{itemize}
		\item Anwendung: Steuerung, Sessordatenverarbeitung, Feldbusse, Shell
		\item API
		\item RT-Kernel
		\item Hardware
	\end{itemize}
	\item \textbf{Mit Hardware-Umschaltung zwischen zwei Betriebssysteme}
	\begin{itemize}
		\item Jeweils ein Standard-Betriebssystem und ein Echtzeit-Betriebssystem
		\item Hardware-Task-Umschalter dazwischen
	\end{itemize}
	\item \textbf{Mit zusätzlichem Standardbetriebssystem für niederpriore Tasks}
	\begin{itemize}
		\item Standardbetriebssystem als Task innerhalb des Echtzeitsystems
		\item Shared Memory
	\end{itemize}
\end{itemize}


\subsection{Aufgabenstellung von Robotern in der Industrie}
\begin{itemize}
	\item Bearbeitungsaufgaben
	\item Handhabungsaufgaben
	\item Montageaufgaben
	\item Inspektionsaufgaben
\end{itemize}



\section{Appendix A: Differenzialgleichungen}

\subsection{Homogene lineare Differenzialgleichung}
\[x_h(t) = C_ke^{\lambda_kt}\]
\begin{enumerate}
	\item Setze \(x(t) = e^{\lambda t}\) und setze integriert pro Term ein
	\item Ausklammern und kürzen von \(e^{\lambda t}\)
	\item Nullstellen berechnen
\end{enumerate}



\section{Appendix B: Operationsverstärker}

\subsubsection{Der ideale Operationsverstärker: Annahmen}
\begin{itemize}
	\item Verstärkung ist unendlich
	\item Der Eingangswiderstand ist unendlich
	\item Der Ausgangswiderstand ist null
\end{itemize}

\subsubsection{Eigenschaften}
\begin{itemize}
	\item Verstärkt die Differenz $U_D$ der beiden anliegenden Spannungen
	\item Die Versorgungsspannungen legen den maximalen und den minimalen Ausgangsbereich fest
	\item Verstärkung ist linear
\end{itemize}

\subsubsection{Grundsätzliche Beschaltung}
\begin{itemize}
	\item Eingangssignal wird auf den positiven Eingang gelegt
	\item Ausgangssignal wird auf den negativen Eingang rückgekoppelt
\end{itemize}

\subsubsection{Ausgangsspannung}
\[U_A = Y_D \cdot (U_P - U_N) = Y_D \cdot U_D\]


\subsection{Operationsverstärker als Vergleicher}
\begin{itemize}
	\item $U_{E1} > U_{E2} \rightarrow U_A = U_{CC}$
	\item $U_{E1} < U_{E2} \rightarrow U_A = U_{EE}$
\end{itemize}


\subsection{Nicht-invertierter Spannungsverstärker}
Die Verstärkung der Schaltung muss immer größer oder gleich eins sein.

\[Y = \frac{U_A}{U_E} = \frac{R_1 + R_N}{R_1}\]



\section{Appendix C: Formelsammlung}

\subsection{Busse}

\subsubsection{Übertragungsrate}
\[\frac{AnzahlBytes}{Taktzykluszeit \cdot Anzahl~Taktzyklen}\]


\subsection{Transistor}
$\beta$ bezeichnet den \textit{Stromverstärkungsfaktor} des Transistors.

\subsubsection{Spannungsverstärkung}
\[V_U = \frac{-R_C}{R_B} \cdot \beta\]

\subsubsection{Leistungsverstäkung}
\[V_L = V_U \cdot \beta\]


\subsection{Netze}

\subsubsection{Maximale Buslänge}
\[l \le \frac{1}{2} \cdot L_{Paket} \cdot \frac{v}{BW}\]

\subsubsection{Übertragungsdauer eines Pakete}
\[T_{Paket} = \frac{L_{Paket}}{BW}\]


\subsubsection{Busspezifische Signallaufzeit}
\[T_{Prop} = \frac{l}{v}\]

\subsubsection{Übertragungseffiziens}
\[\eta = \frac{1}{1+5\cdot\frac{T_{Prop}}{T_{Paket}}}\]


\subsection{Echtzeitbetriebssysteme}

\subsubsection{Prozessorauslastung}
\[H = \frac{Benoetigte~Prozessorzeit}{Verfuegbare~Prozessorzeit}\]

\subsubsection{Prozessorauslastung Taskset auf Einprozessorsystem}
\[H = \sum_{i=1}^{n}\frac{Ausfuehrungszeit_i}{Periodendauer~Task_i}\]

\subsubsection{Maximale Medienzugriffszeit}
\[MMAT = T_{Paket} + N \cdot T_{Token} + T_{Prop} + (N-1) \cdot T_{THT}\]


\section{Appendix D: Klausuraufgaben}

\subsection{Zeitkontinuierliche Regelung}

\subsubsection{Rückkopplungen}
\begin{itemize}
	\item Gegenkopplung \((-)\): \(\frac{G_1(s)}{1 + G_1(s) \cdot G_2(s)}\), bei positiven Konstanten
	\item Mitkopplung \((+)\): \(\frac{G_1(s)}{1-G_1(s) \cdot G_2(s)}\), bei negativen Konstanten
\end{itemize}

\subsubsection{Differenzialgleichung \(\rightarrow\) Blockschaldbild}
\begin{enumerate}
	\item Aufbau: \(u \rightarrow \ddot{x} \rightarrow \dot{x} \rightarrow x\), zwischen den Differenzialen jeweils \(\frac{1}{s}\), nach \(u\) die Konstante, Konstanten der Differenziale als Rückkopplung, Rückkopplung von \(x\) nach \(u\)
	\item Streichen unnötiger Differenziale
	\item Zusammenfassen von Konstanten in Reihe per Multiplikation
	\item Zusammenfassen der letzten Rückkopplung
\end{enumerate}

\subsubsection{Stabilität eines Systems mit Hurwitz-Kriterium}
\begin{itemize}
	\item Alle Koeffizienten \(a_i > 0\)
	\item Alle Hauptminoren der Hurwitz-Matrix positiv
	\item \(H = \begin{pmatrix}
					a_{n-1} & a_{n-3} & a_{n-5} & a_{n-7} & ... & 0 \\
					1 & a_{n-2} & a_{n-4} & a_{n-6} & ... & 0 \\
					0 & a_{n-1} & a_{n-3} & a_{n-5} & ... & 0 \\
					0 & 1 & a_{n-1} & a_{n-2} & ... & 0 \\
					. & . & . & . & ... & . \\
					0 & 0 & 0 & 0 & 0 & a_n
				\end{pmatrix}\)
\end{itemize}

\subsubsection{Laplace-Transformierte berechnen}
Linear: Nach s ableiten.

\subsubsection{Übertragungsfunktion berechnen}
\begin{itemize}
	\item Laplace-Transformierte berechnen
	\item Einsetzen in \(G(s) = \frac{X(s)}{U(s)}\). Kehrwert beachten!
\end{itemize}


\subsection{Zeitdiskrete Regelung}

\subsubsection{Differenzialgleichung \(\rightarrow\) Differenzengleichung}
Berechnung der diskreten Schritte mit \(T_A\). Vorsicht: \(tx(t) \rightarrow kT_Ax_k\)

\subsubsection{Z-Transformation}


\subsection{Netze}

\subsubsection{N Geräte, die senden möchten}
Benötigte Bandbreite und vorhandene Bandbreite berechnen und vergleichen.


\subsection{Scheduling}

\subsubsection{Gibt es einen gültigen Schedul}
Auslastung anschauen!