Merge branch 'master' of https://github.com/wieerwill/Informatik into master

Betriebssysteme.md

@@ -172,7 +172,7 @@ Buchführung über sämtliche zum management notwendigen Informationen
 a. Prozessdeskriptor (process control block ~ PCB)
 b. Prozessdeskriptortabelle: Deskriptioren sämtlicher Prozesse
 
-| Prozessormanagement | |
+| Prozessormanagement (Prozessdeskriptor) | |
 | Identifikation | eindeutige Prozessbezeichnung; einordnung in Abstammungshierarchie |
 | Scheduling | Informationen für Schedulingalgorithmen |
 | Prozessorkontext | gesichert bei Verdrängung des Prozesses, restauriert bei Reaktivierung |
@@ -252,7 +252,7 @@ Implementierungsebenen
 | | Individualität: anwendungsindividuelle Thread Schedulingstrategien möglich | 
 | | Portabilität | 
 
-es gibt Work-Arounds: alle gefählrichen Systemaufrufe einpacken (in Pakete)
+es gibt Work-Arounds: alle gefährlichen Systemaufrufe einpacken (in Pakete)
 
 Wahl zwischen ULT- und KLT hängt ab von:
 1. Vorraussetzung: Prozessmodell des Betriebssystems Multithread Modell?
@@ -273,6 +273,13 @@ Threads können
 - kurzfristig warten (Bsp. benötigt keinen Prozesoor aber Arbeitsspeicher)
 - langfristig warten (Bsp. benötigt länger keinen Prozessor/Arbeitsspeicher)
 
+Threadzustände im 3/5-Zustandsmodell
+- bereit: kann aktiv werden, sobald Prozessor frei wird
+- aktiv: besitzt einen Prozessor, arbeitet
+- blockiert: wartet auf Ereignis (Timer Ablauf,...)
+- frisch: erzeugt, Betriebsmittel/Rechte zum Ablauf fehlen noch
+- beendet: Betriebsmittel in der Freigabephase
+
 Folge: effizientes Ressourcenmanagement benötigt präzise Informationen über Threadzustände.
 
 ## Aufgabe der Zustandsmodelle
@@ -288,3 +295,214 @@ Nutzung
 Beschreibungsmittel: endliche deterministische Automaten
 - Menge der annehmbaren Zustände ist endlich
 - Folgezustand ist immer eindeutig bestimmt
+
+## Scheduleraktivierung
+Wann wird die letzte Scheduling-Entscheidung überprüft?
+1. Prozess/Thread erzeugung (neuer, rechenbereiter Thread)
+2. Threadterminierung, Threadblockierung (ein Prozessor wird frei)
+3. Ereigniseintritt (Thread wird rechenbereit)
+4. Wechsel von Prioritäten (in prioritätenbastierten Schedulingalgorithmen)
+5. periodisch (in zeitscheibenbasierten Schedulingalgorithmen)
+
+Ein Kontextwechsel umfasst:
+- bei Wechsel zwischen Threads desselben Prozesses
+  - Stackkontext
+  - Prozessorregister
+  - floating point unit (hohe Kosten)
+- zusätzlicher Wechsel zwischen Threads verschiedener Prozesse
+  - Speicherlayout (sehr hohe Kosten)
+- starke Auswirkungen auf
+  - Gesamtperformanz
+  - Reaktivität
+  - Echtzeiteigenschaften
+
+Kostenfaktor FPU
+- Kopieren des FPU-Kontexts: sehr viele Register (sofortkosten)
+  - Realisierung: "faul"
+  - Hardware hilft: FPU Protextion
+- Auswirkung
+  - nur ein THread benutzt FPU: tatsächliches Sichern erfolgt nie
+  - wenige Threads benutzen FPU: tatsächliches Sichern minimiert
+
+## Scheduling Strategien
+Strategische Ziele
+- abhängig vom Einsatzfeld eines Betriebssystems
+  - Echtzeitsysteme: Einhaltung von Fristen
+  - interaktive Systeme: Reaktivität
+  - Serversysteme: Reaktivität, E/A-Performanz
+  - Batch-Verarbeitungssysteme: Durchsatz
+- ergänzt durch allgemeine Ziele
+  - Fairness: Threads bekommen einen fairen Anteil an Rechenzeit
+  - Lastbalancierung: alle Systemkomponenten (CPUs, Speicher, E/A-Peripherie) sind gleichmäßig ausgelastet
+  - Overhead: z.B. wenig Prozesswechsel
+- Ausbalancierung mehrerer Ziele
+  - multikriterielle Optimierungsaufgabe, i.d.R. NP-vollständig
+  - heuristische Scheduling-Algorithmen
+
+Typische Muster aktiver Threadphasen:
+- CPU lastig (mathematische Berechnung, Verschlüsselung,...)
+- E/A lastig (interaktiver Prozess, ...)
+- periodische Last (Echtzeitvideoverarbeitung, ...)
+- chaotische Last (server mit inhomogenen Diensten)
+
+Differenzierte Scheduling-Strategien
+- nutzen Wissen über Lastmuster zur Optimierung, z.B.
+  1. Einhaltung von Fristen
+  2. Minimierung der Thread/Prozesswechsel
+
+### Batch-System („Stapelverarbeitungs“-System)
+- Aufträge: in Gruppen („Stapel“) eingeteilt u. so verarbeitet
+- Abarbeitung: ohne aktive Mitwirkung eines Benutzers (Gegensatz: interaktiv)
+- ursprünglich: frühe Entwicklungsstufe von Betriebssystemen
+
+Ziele hier
+1. Auslastung teurer Betriebsmittel (i.d.R. Maximierung der CPU-Auslastung)
+2. Minimierung der Scheduling-Kosten (wenig Prozesswechsel, kurze Laufzeit des Scheduling-Algorithmus)
+3. Maximierung des Durchsatzes (erledigte Arbeit / Zeit)
+
+zwei der bekannteren:
+1. First Come, First Served (FCFS)
+   - in Reihenfolge, in der Threads rechenbereit werden
+   - extrem einfache Strategie, guter Durchsatz
+   - nicht immer sehr klug
+2. Shortest Remaining Time Next (SRTN)
+   - Prozessor erhält Thread mit voraussichtlich kürzester Restrechenzeit
+   - preemptiv* ) , d.h. Threads können von konkurrierenden Threads verdrängt werden
+   - (Schätzwert über) Restlaufzeit muss vorliegen
+
+### Interaktives System
+- Benutzer: kann bei Programmabarbeitung in Aktivitäten des Computers eingreifen
+- Abarbeitung: mit aktiver Mitwirkung eines Benutzers (Gegensatz: batch processing)
+- fortgeschrittenere Betriebssystem-Technik
+
+Ziele hier
+1. Minimierung von Reaktionszeiten (subjektiver Eindruck von Performanz)
+2. Fairness (mehrere Benutzer/Klienten)
+
+Algorithmen: Round Robin Varianten
+  - jeder Thread: bekommt ein gleich großes Teil „des Kuchens“: die Zeitscheibe
+  - einfach zu implementieren (1 Warteschlange, Uhr)
+  - geringe Algorithmuskosten (O(1): FIFO-Warteschlange, Ring)
+  - schnelle Entscheidungen (O(1): Nr. 1 aus Warteschlange)
+  - notwendiges Wissen gering (CPU-Nutzungsdauer des aktiven Threads)
+
+#### Einbeziehung von Prioritäten
+Ziel: Ausdrucksmöglichkeit der Wichtigkeit von Threads
+1. niedrig: z.B.
+  - Dämonen (die z.B. im Hintergrund Emails abrufen)
+  - Putzarbeiten (z.B. Defragmentierung)
+2. hoch: z.B.
+  - auf Aufträge reagierende Threads (z.B. in Servern)
+  - auf Benutzereingaben reagierende Threads (z.B. aktives Fenster einer GUI)
+  - unter Echtzeitbedingungen arbeitende Threads (z.B. Motormanagement, DVD-Spieler)
+
+Idee(n)
+1. jeder Thread: erhält individuelle Priorität
+2. Threads der höchsten Prioritäten: erhalten einen Prozessor
+3. zwischen Threads gleicher Priorität: Round-Robin
+
+viele Varianten dieses Schemas
+- statische Prioritäten, z.B. in
+  - planbaren Echtzeitsystemen (Autoradio: Reaktion auf Stationswechseltaste hat Vorrang vor Senderfeldstärkenüberwachung)
+  - kommerziellen Rechenzentren (wer mehr zahlt, ist eher an der Reihe)
+- dynamische Prioritäten, abhängig z.B. von
+  - verbrauchter CPU-Zeit (Verhinderung der Dominanz)
+  - E/A-Intensität
+  - Wartegrund
+
+### Schedulingziele in Echtzeitsystemen
+Finden einer Bearbeitungsreihenfolge (ein „Schedule“),
+- die Fristen einhält
+- deren Berechnung ökonomisch ist (Kosten des Scheduling-Algorithmus)
+- die selbst ökonomisch ist (Minimierung der Threadwechsel)
+- die sich (evtl.) an wechselnde Lastmuster anpasst
+
+Verbreitete Algorithmen
+- EDF: früheste Frist zuerst (earliest deadline first)
+  - für dynamische Lasten
+  - wird ein Thread rechenbereit, so „nennt“ er seine nächste Deadline (Frist)
+  - von allen bereiten Threads ist immer derjenige mit der frühesten Deadline aktiv (dringend=wichtig)
+  - Folglich
+    - arbeitet der Algorithmus mit dynamischen Prioritäten → adaptiv
+    - ist die Thread-Priorität um so höher, je näher dessen Frist liegt
+    - ist er preemptiv
+  - Voraussetzung: kausale und zeitliche Unabhängigkeit der Threads (keine wechselseitige Blockierung)
+- RMS: Raten-monotones Scheduling (rate-monotonic scheduling)
+  - für periodische Lasten (z.B. Mischpult, DVD-Spieler, technische Prozesse)
+  - wird ein Thread rechenbereit, so „nennt“ er seine Periodendauer
+  - von allen bereiten Threads ist immer derjenige mit der kürzesten Periodendauer aktiv
+  - Folglich:
+    - arbeitet der Algorithmus mit statischen Prioritäten
+    - ist die Thread-Priorität um so höher, je kürzer die Periodendauer ist
+    - ist er preemptiv
+  - Voraussetzung: periodische Threads; kausale und zeitliche Unabhängigkeit der Threads
+
+## Zusammenfassung
+Anzahl der Threads >> Anzahl der Prozessoren
+- nicht alle können gleichzeitig rechnen
+- eine Auswahl muss getroffen werden
+- → Auswahlstrategie: Schedulingalgorithmen
+
+# Privilegierungsebenen
+Problematik: Anwendungsprozesse und Betriebssystem nutzen gemeinsame (Hardware-)Ressourcen
+
+Schutz vor fehlerbedingten oder bösartigen räumlichen/zeitlichen Wechselwirkungen
+
+2 Konzepte
+1. private Adressräume
+2. Zugriffsschutz auf Arbeitsspeicherbereiche
+
+Verhinderung zeitlicher Wechselwirkungen
+- Ursache: Prozesse geben freiwillig keine Prozessoren auf
+- Umgang damit
+  - periodische Aktivierungen preemptiver Scheduler (Uhr)
+  - Scheduler-Aktivierungen durch asynchrone Ereignisse
+- kritisch also: Operationen zum Abschalten von
+  1. Uhr
+  2. Ereignismanagement (s. Kap. 5.4)
+- weitere kritische Operationen
+  1. Veränderung des Speicherlayouts
+  2. Veränderung kritischer Prozessorkontrollregister
+  3. Zugriff auf E/A-Geräte
+- notwendig: Schutz kritischer Operationen des Instruktionssatzes
+
+Lösungskonzept: Privilegierungsebenen ablaufender Aktivitäten, z.B.
+  - „kernel mode“ (≈ Betriebssystem-Modus)
+  - „user mode“ (Nutzer-Modus)
+- ermöglichen: Durchsetzung von Regeln:
+  - „Nur eine im „kernel mode“ ablaufende Aktivität hat Zugriff auf ...“
+- Privilegierungsebenen steuern Rechte ...
+  1. zur Ausführung privilegierter Prozessorinstruktionen
+  2. zur Konfiguration des Arbeitsspeicher-Layouts
+  3. zum Zugriff auf Arbeitsspeicherbereiche
+  4. zum Zugriff auf E/A-Geräte
+
+Realisierung: abhängig von Prozessorarchitektur
+- in Ringen 0 (höchste Priorität) bis 3 (niedrigste Priorität)
+
+Implementierung: Hardware-Unterstützung
+- aktuelle Privilegierungsebene ist
+  - Teil des Prozessor-Statusregisters: „Current Privilege Level“ (CPL)
+  - Grundlage der Hardware-Schutzmechanismen; permanente Überwachung
+    - der ausgeführten Instruktionen
+    - der Arbeitsspeicherzugriffe
+    - der E/A-Peripheriezugriffe
+- Modifikation des CPLs nur
+  1. durch privilegierte Instruktionen
+  2. bei Beginn und Abschluss
+    - des Aufrufs von Systemdiensten
+    - einer Ereignisbehandlung
+
+Botschaften
+- jede auf Privilegierungsebene < 3 ablaufende Aktivität hat Zugriff auf kritische Ressourcen
+- jede auf Privilegierungsebene 0 ablaufende Aktivität hat Zugriff auf
+  1. sämtliche Ressourcen eines Prozessors
+    - sämtliche Instruktionen (z.B. HALT)
+    - sämtliche Prozessorregister (z.B. Prozessor-Status-Register (PSR) )
+  2. MMU-Register zur Arbeitsspeicherkonfiguration 
+  3. sämtliche Register der E/A-Peripherie
+
+Sämtliche Schutz- und Sicherheitsmechanismen von
+- Anwendungsprozessen
+- Betriebssystem
+beruhen elementar auf 2 Bits: „Current Privilege Level“ (CPL) im Prozessor-Status-Register (PSR)

README.md

@@ -17,6 +17,8 @@ bisher:
 - [Neuroinformatik](Neuroinformatik.md) (letzte 2 Kapitel fehlen)
 - [Programmierparadigmen](Programmierparadigmen.md)
 - [Rechnerarchitekturen 1](Rechnerarchitekturen%201.md)
+  - [Praktikum A1](Rechnerarchitekturen%201%20-%20Praktikum%20A1.pdf)
+  - [Praktikum A2](Rechnerarchitekturen%201%20-%20Praktikum%20A2.pdf)
 - [Rechnerarchitekturen 2](Rechnerarchitekturen%202.md) (ongoing)
 - [Softwaretechnik](Softwaretechnik%201.md) (ongoing)
 - [Stochastik](Stochastik.md) (ongoing)
@@ -27,20 +29,20 @@ Keine Garantie auf Vollständigkeit/Korrektheit! Hilf uns Fehler zu korrigieren
 
 ## Verwendung
 Alle Dokumente werden in Markdown (bevorzugt) oder LaTex geschrieben. Bilder, Grafiken, Musik etc ist in einem eigenen Ordner "Assets". Bei Fragen zu Markdown könnt ihr Google befragen, Cheatsheets lesen (da steht meistens alles drauf) oder im Notfall den Admin fragen.
-Dieses Repo ist zum Selbststudium und erlernen neuen Wissens gedacht. Kein Inhalt oder Teile dieses Repositories darf kommerziell verwendet werden. Es steht frei zu Teilen, Klonen und Mitzuarbeiten.
+Dieses Repo ist zum Selbststudium und erlernen neuen Wissens gedacht. Kein Inhalte oder Teile dieses Repositories dürfen kommerziell verwendet werden. Es steht frei zu Teilen, Klonen und Mitzuarbeiten.
 Wir freuen uns über jeden der mitmacht.
 
 ## Mitmachen
-Eine kleine Beschreibung für Leute die noch nie auf Github zusammengearbeitet haben. Vorraussetzung für diese Aktionen ist, ein Github-Konto zu besitzen.
+Eine kleine Beschreibung für Leute die noch nie auf Github zusammengearbeitet haben. Vorraussetzung für diese Aktionen ist es, ein Github-Konto zu besitzen.
 - Erstelle ein 'issue'. Gehe davor die offene 'issues' durch (oder überlege dir welches Fach/Seminar noch fehlt)
 - Klone das Repository oder erstelle einen Fork. Über die Kommandozeile: ```git clone https://github.com/wieerwill/Informatik.git```
-- Erstelle deinen eigenen Feature Branch, damit deine Version nicht mit anderen Kollidiert: ```git checkout -b my-new-feature``` (in "" kannst du frei wählen wie du deinen Branch nennst)
+- Erstelle deinen eigenen Feature Branch, damit deine Version nicht mit anderen kollidiert: ```git checkout -b my-new-feature``` (in "" kannst du frei wählen wie du deinen Branch nennst)
 - Nachdem du Änderungen vorgenommen hast, stelle deine Änderungen bereit: ```git add * && git commit -m "dein Kommentar"``` (in "" kommt dein Kommentar was sich geändert hat bzw woran du gearbeitet hast. Nicht der Dateiname!)
-- Lade auf deinen Branch hoch: ```git push origin my-new-feature```
-- Erstelle ein 'pull request' damit deine Änderungen in diesem Repository übernommen werden. Dies kannst du über dein Github Dashboard machen.
+- Lade die Änderung auf deinen Branch hoch: ```git push origin my-new-feature```
+- Erstelle ein 'pull request' damit deine Änderungen in diesem Repository übernommen werden können. Dies kannst du über dein Github Dashboard machen.
 
 ## Bild- und Textrechte
-Der Inhalt aller Dokumente hier ist die Mitschrift aus besuchten Vorlesungen. Bilder werden von uns selbst erstellt oder unter ausführlicher Quellangabe verwendet. Es werden keine Bücher kopiert oder anderweitig Copyright verletzt. Die Verletzung des Copyright oder anderer Rechte Dritte wird mit einem Ausschluss aus dem Repository gehandelt. Sollte Ihnen ein Verstoß auffallen geben Sie uns bitte umgehend bescheid, wir werden jedem Fall nachgehen.
+Der Inhalt aller vorhandenen Dokumente beruht auf den Mitschriften besuchter Vorlesungen. Bilder werden von uns selbst erstellt oder unter ausführlicher Quellangabe verwendet. Es werden keine Bücher kopiert oder anderweitig Copyright verletzt. Die Verletzung des Copyright oder anderer Rechte Dritter wird mit einem Ausschluss aus dem Repository gehandelt. Sollte Ihnen ein Verstoß auffallen, geben Sie uns bitte umgehend Bescheid, wir werden jedem Fall nachgehen.
 
 ## Lizenz
 Dieses Repository und sein Inhalt sind unter der GNU GENERAL PUBLIC LICENSE Version 3 veröffentlicht. Was das bedeutet könnt ihr [hier](LICENSE) nachlesen.

Rechnerarchitekturen 1 - Praktikum A1.tex

@@ -0,0 +1,264 @@
+\documentclass[10pt, a4paper]{report}
+\usepackage[utf8]{inputenc}
+\usepackage[ngerman]{babel}
+\usepackage{datetime}
+\usepackage[]{amsmath} 
+\usepackage[]{amsthm} 
+\usepackage[]{amssymb}
+\usepackage{listings}
+\usepackage{xcolor}
+\usepackage{fancyhdr}
+
+\pagestyle{fancy}
+\fancyhf{}
+\lhead{Rechnerarchitekturen 1 - Praktikum A1 - WS 20/21}
+\rfoot{Page \thepage}
+
+\definecolor{codegreen}{rgb}{0,0.6,0}
+\definecolor{codegray}{rgb}{0.5,0.5,0.5}
+\definecolor{codepurple}{rgb}{0.58,0,0.82}
+\definecolor{backcolour}{rgb}{0.95,0.95,0.92}
+
+%Code listing style named "mystyle"
+\lstdefinestyle{mystyle}{
+  backgroundcolor=\color{backcolour},   
+  commentstyle=\color{codegreen},
+  keywordstyle=\color{magenta},
+  numberstyle=\tiny\color{codegray},
+  stringstyle=\color{codepurple},
+  basicstyle=\ttfamily\footnotesize,
+  breakatwhitespace=false,         
+  breaklines=true,                 
+  captionpos=b,                    
+  keepspaces=true,                 
+  numbers=left,                    
+  numbersep=5pt,                  
+  showspaces=false,                
+  showstringspaces=false,
+  showtabs=false,                  
+  tabsize=2
+}
+
+%"mystyle" code listing set
+\lstset{style=mystyle}
+
+\newdateformat{myformat}{\THEDAY{ten }\monthname[\THEMONTH], \THEYEAR}
+
+\title{Rechnerarchitekturen 1 - Praktikum A1}
+\date\today
+\begin{document}
+
+\section*{ Grundaufgabe a: Funktionen ermitteln}
+\begin{lstlisting}[language=Assembler]
+; Programmbereich:
+anf:    MOV   EDX,400000H  ;Groessee der Verzoegerung
+        MOV   [verzoe],EDX ;Verzoegerung speichern
+
+m1:     MOV   EDI,10    ;EDI=10
+        MOV   ESI,OFFSET ziff   ;Adresse von ziff in ESI
+
+m2:     MOV   AL,[ESI+EDI-1]    ;AL=ziff+9
+        OUT   0B0H,AL   ;SiebenSegment schreibt AL
+        CALL  zeit      ;warten
+        DEC   EDI       ;EDI=EDI-1
+        JNZ   m2        ;if(EDI!=0) goto m2
+
+        MOV   AL,0FFH   ;AL=255 (dec)
+m3:     OUT   5CH,AL    ;LED Reihe links schreiben
+        NOT   AL        ;AL negieren
+        OUT   5DH,AL    ;LED Reihe rechts schreiben
+        CALL  zeit      ;warten
+        MOV   BL,AL     ;Inhalt von AL wird noch gebraucht
+        IN    AL,59H    ;Tastenreihe rechts lesen auf AL
+        BT    EAX,7     ;Bit 7 von EAX in Carry Flag
+        MOV   AL,BL     ;AL bekommt alten Wert zurueck
+        JC    m1        ;if(m1==0) goto m1
+        JMP   m3        ;goto m3 (Loop)
+
+;zeit ist ein Unterprogramm, welches nur Zeit verbrauchen soll:
+zeit:   MOV   ECX,[verzoe] ;Lade wartezeit
+z1:     DEC   ECX       ;ECX=ECX-1
+        JNZ   z1        ;if(ECX!=0) goto z1
+        RET             ;zurueck zum Hauptprogramm
+
+; Datenbereich:
+verzoe  DD    ?         ;Eine Speicherzelle (Doppelwort)
+ziff    DB    3FH,03H,6DH,67H,53H,76H,7EH,23H,7FH,77H
+\end{lstlisting}
+
+\begin{description}
+    \item[anf] setzt die Länge der Wartezeit
+    \item[m1] Lädt Register
+    \item[m2] Zählt auf Sieben Segment Anzeige
+    \item[m3] schreibt auf LED Reihe links und invertierend rechts
+    \item[zeit] Verbraucht Zeit nach "verzoe"     
+\end{description}
+
+\clearpage
+
+\section*{ Grundaufgabe b: Programmentwurf}
+\subsection*{einfaches Lauflicht}
+auf der rechten LED-Reihe soll ein sichtbarer Lichtpunkt von links nach rechts laufen und immer wieder von links beginnen
+
+\begin{lstlisting}[language=Assembler]
+anf:    MOV     EDX,400000H
+        MOV     [verzoe],EDX
+
+        MOV     AL, 80H     ;Startwert fuer LED Reihe
+lauf:   OUT     5CH, AL     ;Wert auf LED Reihe schreiben
+        CALL    zeit        ;warten
+        ROR     AL, 1       ;Bits um 1 nach rechts 
+        JMP     lauf        ;Schleife wiederholen
+
+zeit:   MOV     ECX,[verzoe]
+z1:     DEC     ECX
+        JNZ     z1
+        RET
+\end{lstlisting}
+
+
+
+\subsection*{Lauflicht mit Geschwindigkeitsumschalter}
+das Lauflicht soll durch den linken Schalter zwischen "schnell" (Schalter oben) und "langsam" (Schalter unten) umschalten
+
+\begin{lstlisting}[language=Assembler]
+anf:    MOV     Al, 80H
+
+lauf:   MOV     EDX, 400000H    ; Wert fuer "langsam"
+        MOV     [verzoe], EDX   ;"langsam" in Speicher
+        OUT     5CH, AL         ;LED Reihe schreiben
+        MOV     BL, AL          ;AL speichern
+        IN      AL, 58H         ;Schalter einlesen
+        BT      AL, 7           ;7. Bit von AL in Carry Flag
+        JNC     langsam         ;Carry Flag = 0, schalter unten
+        MOV     EDX, 200000H    ; Wert fuer "schnell"
+        MOV     [verzoe], EDX   ;"schnell" in Speicher
+        CMC                     ;Carry Flag umschalten (0)
+
+langsam: CALL   zeit            ;warten
+        MOV     AL, BL          ;AL aus speicher zurueck
+        ROR     AL,1            ;Bits um 1 nach rechts
+        JMP     anf             ;Schleife wiederholen
+
+zeit:   MOV     ECX,[verzoe]
+z1:     DEC     ECX
+        JNZ     z1
+        RET
+\end{lstlisting}
+
+\clearpage
+
+\subsection*{Lauflicht verändert Richtung}
+zusätzlich zum oben implementierten soll die Bewegungsrichtung des Lichtpunktes durch den rechten Schalter der Schalterreihe zwischen "nach links" und "nach rechts" wechseln.
+
+\begin{lstlisting}[language=Assembler]
+anf:    MOV     Al, 80H
+lauf:   MOV     EDX, 400000H    ; Wert fuer "langsam"
+        MOV     [verzoe], EDX   ;"langsam" in Speicher
+        OUT     5CH, AL         ;LED Reihe schreiben
+        MOV     BL, AL          ;AL speichern
+        IN      AL, 58H         ;Schalter einlesen
+        BT      AL, 7           ;7. Bit von AL in Carry Flag
+        JNC     langsam         ;Carry Flag = 0, Schalter unten
+        MOV     EDX, 200000H    ; Wert fuer "schnell"
+        MOV     [verzoe], EDX   ;"schnell" in Speicher
+        CMC                     ;Carry Flag umschalten
+langsam: CALL   zeit            ;warten
+        MOV     AL, BL          ;AL aus speicher zurueck
+        BT      AL, 0           ;0. Bit von AL in Carry Flag
+        JNC     rechts          ;Carry Flag = 1; Schalter oben 
+        ROL     AL,1            ;Bits um 1 nach links
+        CMC                     ;Carry Flag umschalten (0)
+        JMP     anf             ;Schleife wiederholen
+rechts: ROR     AL, 1           ;Bits um 1 nach rechts
+        JMP     anf             ;Schleife wiederholen
+zeit:   MOV     ECX,[verzoe]
+z1:     DEC     ECX
+        JNZ     z1
+        RET
+\end{lstlisting}
+
+
+\subsection*{Lauflicht mit Invertierung}
+durch drücken einer beliebigen Taste der blauen Tastenreihe wird die Anzeige invertiert, d.h. der Lichtpunkt ist dunkel etc. Invertierung nur solange die Taste gedrückt wird.
+\begin{lstlisting}[language=Assembler]
+anf:    MOV     Al, 80H
+lauf:   MOV     EDX, 400000H    ; Wert fuer "langsam"
+        MOV     [verzoe], EDX   ;"langsam" in Speicher
+        MOV     BL, AL          ;Kopie von AL anlegen
+        IN      AL, 59H         ;Tastenreihe einlesen
+        AND     AL, FFH         ;UND Operation mit FF
+        JZ      nopress         ;kein Schalter gedrueckt
+        NOT     BL              ;BL invertieren
+        MOV     AL, BL          ;AL ueberschreiben
+nopress: OUT    5CH, AL         ;LED Reihe schreiben
+        IN      AL, 58H         ;Schalter einlesen
+        BT      AL, 7           ;7. Bit von AL in Carry Flag
+        JNC     langsam         ;Carry Flag = 0, Schalter unten
+        MOV     EDX, 200000H    ; Wert fuer "schnell"
+        MOV     [verzoe], EDX   ;"schnell" in Speicher
+        CMC                     ;Carry Flag umschalten
+langsam: CALL   zeit            ;warten
+        MOV     AL, BL          ;AL aus speicher zurueck
+        BT      AL, 0           ;0. Bit von AL in Carry Flag
+        JNC     rechts          ;Carry Flag = 1; Schalter oben
+        ROL     AL,1            ;Bits um 1 nach links
+        CMC                     ;Carry Flag umschalten (0)
+        JMP     anf             ;Schleife wiederholen
+rechts: ROR     AL, 1           ;Bits um 1 nach rechts
+        JMP     anf             ;Schleife wiederholen
+zeit:   MOV     ECX,[verzoe]
+z1:     DEC     ECX
+        JNZ     z1
+        RET
+\end{lstlisting}
+
+
+\subsection*{Zusatzaufgabe}
+Erweiterungen des Programms nach eigenen Ideen:
+\begin{itemize}
+    \item symetrische LED Reihe zur Mitte
+    \item Sieben Segment zählt 9 Schritte mit 
+\end{itemize}
+\begin{lstlisting}[language=Assembler]
+anf:    MOV     Al, 80H
+        MOV     EDI, 0 
+        MOV     ESI, OFFSET ziff
+lauf:   MOV     EDX, 400000H    ; Wert fuer "langsam"
+        MOV     [verzoe], EDX   ;"langsam" in Speicher
+        MOV     BL, AL          ;Kopie von AL anlegen
+        IN      AL, 59H         ;Tastenreihe einlesen
+        AND     AL, FFH         ;UND Operation mit FF
+        JZ      nopress         ;kein Schalter gedrueckt
+        NOT     BL              ;BL invertieren
+        MOV     AL, BL          ;AL ueberschreiben
+nopress: OUT    5CH,AL           ;LED Reihe links schreiben
+        NOT     AL              ;AL negieren
+        OUT     5DH,AL          ;LED Reihe rechts schreiben
+        MOV     BH,[ESI+EDI-1]  ;Sieben Segment berechnen
+        OUT     0B0H,BH         ;Sieben Segment schreiben
+        DEC     EDI             ;Sieben Segment runterzaehlen
+        JZ      timer           ;Timer auf 0 setzen
+        IN      AL, 58H         ;Schalter einlesen
+        BT      AL, 7           ;7. Bit von AL in Carry Flag
+        JNC     langsam         ;Carry Flag = 0, Schalter unten
+        MOV     EDX, 200000H    ; Wert fuer "schnell"
+        MOV     [verzoe], EDX   ;"schnell" in Speicher
+        CMC                     ;Carry Flag umschalten
+langsam: CALL   zeit            ;warten
+        MOV     AL, BL          ;AL aus speicher zurueck
+        BT      AL, 0           ;0. Bit von AL in Carry Flag
+        JNC     rechts          ;Carry Flag = 1; Schalter oben
+        ROL     AL,1            ;Bits um 1 nach links
+        CMC                     ;Carry Flag umschalten (0)
+        JMP     anf             ;Schleife wiederholen
+rechts: ROR     AL, 1           ;Bits um 1 nach rechts
+        JMP     anf             ;Schleife wiederholen
+timer:  MOV     BH, 0FFH
+        RET 
+zeit:   MOV     ECX,[verzoe]
+z1:     DEC     ECX
+        JNZ     z1
+        RET
+\end{lstlisting}
+\end{document}

Rechnerarchitekturen 1 - Praktikum A2.tex

@@ -0,0 +1,155 @@
+\documentclass[10pt, a4paper]{report}
+\usepackage[utf8]{inputenc}
+\usepackage[ngerman]{babel}
+\usepackage{datetime}
+\usepackage[]{amsmath} 
+\usepackage[]{amsthm} 
+\usepackage[]{amssymb}
+\usepackage{listings}
+\usepackage{xcolor}
+\usepackage{fancyhdr}
+
+\pagestyle{fancy}
+\fancyhf{}
+\lhead{Rechnerarchitekturen 1 - Praktikum A2 - WS20/21}
+\rfoot{Page \thepage}
+
+\definecolor{codegreen}{rgb}{0,0.6,0}
+\definecolor{codegray}{rgb}{0.5,0.5,0.5}
+\definecolor{codepurple}{rgb}{0.58,0,0.82}
+\definecolor{backcolour}{rgb}{0.95,0.95,0.92}
+
+%Code listing style named "mystyle"
+\lstdefinestyle{mystyle}{
+  backgroundcolor=\color{backcolour},   
+  commentstyle=\color{codegreen},
+  keywordstyle=\color{magenta},
+  numberstyle=\tiny\color{codegray},
+  stringstyle=\color{codepurple},
+  basicstyle=\ttfamily\footnotesize,
+  breakatwhitespace=false,         
+  breaklines=true,                 
+  captionpos=b,                    
+  keepspaces=true,                 
+  numbers=left,                    
+  numbersep=5pt,                  
+  showspaces=false,                
+  showstringspaces=false,
+  showtabs=false,                  
+  tabsize=2
+}
+
+%"mystyle" code listing set
+\lstset{style=mystyle}
+
+\newdateformat{myformat}{\THEDAY{ten }\monthname[\THEMONTH], \THEYEAR}
+
+\title{Rechnerarchitekturen 1 - Praktikum A2}
+\author{}
+\date\today
+\begin{document}
+
+
+\begin{center}
+        \begin{tabular}{| l | c | c | c | c | c | c | c | c | }
+                \hline
+                \multicolumn{9}{|c|}{Frequenzen der C-Dur Tonleiter}\\
+                \hline
+                \hline
+                Ton   & c'    & d'    & e'    & f'    & g'    & a'    & h'    & c''   \\\hline
+                f(Hz) & 261,6 & 293,7 & 329,6 & 349,2 & 392,0 & 440,0 & 493,9 & 523,2 \\\hline
+                Zählkonstante & 7662 & 6825 & 6079 & 5730 & 5102 & 4545 & 4056 & 3824 \\\hline
+                Freq(Hex) & 1DEEH & 1AA9H & 17BFH & 1662H & 13EEH & 11C1 & FD8H & EF0H\\\hline
+        \end{tabular}
+\end{center}
+
+\section*{ Grundaufgabe a)}
+\scriptsize{Der  Kanal  0  des  Timerbausteins  soll  als  programmierbarer  Frequenzgenerator  benutzt  werden.  Dazu  wird  die  Betriebsart  „Mode  3“  verwendet  (Frequenzteiler  mit  symmetrischer  Rechteckschwingung  am  Output).  Die  Output-Frequenz  soll  440  Hz  betragen. Als Input benutzen Sie den eingebauten 2-MHz-Generator.}
+$$\text{Zählkonstante: } \frac{2 MHz}{440 Hz} = 4545,4545 = (11C1)_{16}$$
+\begin{lstlisting}
+        MOV AL, 36H; Steuerbyte 00110110
+        OUT 57H, AL
+        MOV AL, 0C1H; LSB
+        OUT 54H, Al
+        MOV AL, 011H; MSB
+        OUT 54H, AL
+\end{lstlisting}
+
+
+\section*{ Grundaufgabe b)}
+\scriptsize{Schalten  Sie  die  Tonausgabe  zunächst  wieder  ab  und  erweitern  Sie  das  Programm  um  die  Initialisierung der PIT-Kanäle 1 und 2. Die am Output des Kanals 2 angeschlossene LED soll mit  einer  Periodendauer  von  0,5s  blinken.  Es  ist  wiederum  Mode  3  zu  benutzen.  Da  beide  Kanäle hintereinander geschaltet (kaskadiert) sind, müssen Sie die benötigte Frequenzteilung auf beide Kanäle aufteilen. Außer der LED haben Sie diesmal keine weitere Kontrollmöglichkeit. }
+$$\text{Zählkonstante: } \frac{2 MHz}{2 Hz} /2 = 1000000 / 2 = 500000$$
+\begin{lstlisting}
+        MOV AL, 0B6H; Kanal 2
+        OUT 57H, AL
+        MOV AL, 0FFH
+        OUT 56H, AL
+        MOV AL, 0FFH
+        OUT 56H, AL
+
+        MOV AL, 076H ;Kanal 1
+        OUT 57H, AL
+        MOV AL, 0FFH
+        OUT 55H, AL
+        MOV AL, 0FFH
+        OUT 56H, AL
+
+\end{lstlisting}
+\clearpage
+
+\section*{ Grundaufgabe c)}
+\scriptsize{Die Tonausgabe von Kanal 0 wird wieder eingeschaltet. Sie soll jetzt aber nur noch dann aktiv sein, wenn gerade eine beliebige Taste in der blauen Tastenreihe gedrückt ist. Dazu müssen Sie in der Endlosschleife des Programms eine entsprechende Abfrage einbauen.}
+
+\begin{lstlisting}
+noton:  MOV AL, 59H
+        OUT 57H, AL
+taste:  IN AL, 59H
+        AND AL, 0FFH
+        JZ noton        ;keine taste gedrueckt
+        JMP ton
+ton:    MOV AL, 0C1H
+        OUT 54H, AL
+        MOV AL, 011H
+        OUT 54H, AL
+        JMP taste
+\end{lstlisting}
+
+\section*{ Fortgeschrittene Aufgabe d)}
+\scriptsize{Erweitern Sie das Programm dann so, dass den einzelnen Tasten unterschiedliche Frequenzen zugeordnet sind. Es wird angenommen, dass nicht mehrere Tasten gleichzeitig gedrückt werden. Das  Blinken  der  LED  von  Aufgabe  b)  soll  weiterhin  funktionieren. }
+
+\begin{lstlisting}
+noton:  MOV AL, 59H
+        OUT 57H, AL
+taste:  IN AL, 59H
+        MOV BL, AL
+        AND AL, 0FFH
+        JZ noton        ;keine taste gedrueckt
+        MOV AL, BL
+        AND AL, 001H    ; Taste A
+        JNZ tonA
+        MOV AL, BL
+        AND AL, 003H    ; Taste B
+        JNZ tonB
+        MOV AL, BL
+        AND AL, 004H    ;Taste C
+        JNZ tonC
+        JMP taste
+tonA:   MOV AL, 0C1H
+        OUT 54H, AL
+        MOV AL, 011H
+        OUT 54H, AL
+        JMP taste
+tonB:   MOV AL, 008H
+        OUT 54H, AL
+        MOV AL, 0FDH
+        OUT 54H, AL
+        JMP taste
+tonC:   MOV AL, 000H
+        OUT 54H, AL
+        MOV AL, 0EFH
+        OUT 54H, AL
+        JMP taste
+
+\end{lstlisting}
+
+\end{document}