die video-karte sp2-070 - fritzler-avr.defiles/doku/periph/videokarte/03_video.pdf · mixed signal...

Mixed Signal Baugruppen 2015/16 SPACE AGE 2 VIDEO-Karte

Seite 3- 1

Die Video-Karte SP2-070 Von Henry Westphal, Lukas Hey und Steffen Freimuth


Seite 3- 2

Die Video-Karte SP2-070 ....................................................................................................................... 1 Dokumentation der Vorüberlegungen ................................................................................................. 4

Festlegung / Ermittlung von Randbedingungen/Parametern bezüglich des Video-Timings/der Darstellung: .......................................................................................................................................... 4

Beginn der Ausgabe ................................................................................................................................ 8 Zeilenumbruch bei Erreichen des Zeilenendes ....................................................................................... 9 Vorzeitiger Zeilenumbruch durch Steuerzeichen ..................................................................................... 9 Dokumentation des Detailentwurfs ................................................................................................... 13

Die Erzeugung des Video-Timings und weitere Schaltungsteile auf Video-Timing-Ebene ................. 15 Grundsätzliches .............................................................................................................................. 15 Erzeugung des Horizontal-Timings .................................................................................................. 15 Erzeugung des Vertikal-Timings ....................................................................................................... 19 Erzeugung der Sync-Patterns .......................................................................................................... 20 Erzeugung des active_video Signals .............................................................................................. 25 Erzeugung des new-field-Signals .................................................................................................... 28 Erzeugung des Transfer-Enable-Signals .......................................................................................... 28 Erzeugung der horizontalen Leseadresse für den Textspeicher (pointer_char_read [5..0]) ........... 28 Erzeugung der vertikalen Leseadresse für den Textspeicher (pointer_text_line_read [4..0], mit Scroll-Offset) .................................................................................................................................... 30

Der Text- und der Zeichensatzspeicher .............................................................................................. 37 Allgemeines .................................................................................................................................... 37 Das Auslesen des Textspeichers ..................................................................................................... 37 Erzeugung der Signale pointer_text_line_write[5..0] ....................................................................... 37 Erzeugung der Signale pointer_char_write_[5..0] ........................................................................... 38 Erzeugung der Signale text_line_scroll_offset_[3..0] ....................................................................... 39 Einblendung von Funktionszeichen ................................................................................................ 39 Erzeugung des Cursors ................................................................................................................... 39 Blanken von Zeichen ...................................................................................................................... 40 Steuerung des Schreibens in den Textspeicher .............................................................................. 41

Das Businterface ................................................................................................................................ 51 Die Erzeugung des Pixeltaktes ............................................................................................................ 52

Dokumentation der Betrachtung des Timings der Video -Karte ..................................................... 53 Diagramm 1 & 2: Fifo-Schreibvorgang mit erstmaligem Offset ........................................................ 53 Diagramm 3: Ende des Schreibvorganges ....................................................................................... 56 Diagramm 4: Beginn des aktiven Bildbereiches ................................................................................ 57 Diagramm 5: Zeichenwechsel beim Auslesen .................................................................................. 59 Diagramm 6: Cursor und Blanking, Ende des aktiven Bereichs ......................................................... 61

Dokumentation der Modifikationen während der Inbetr iebnahme ................................................. 66 Das Hinzufügen eines Interruptausgangs zur Synchronisation der CPU auf den Bildwechsel ............ 66

Definition der Funktion .................................................................................................................... 66 Schaltungstechnische Realisierung: ............................................................................................... 66

Vergrößern des Ausgangskondensators C1701 ................................................................................ 70 Hinzufügen eines EEPROMs ................................................................................................................ 70 Verändern der Bildlage ...................................................................................................................... 70

Dokumentation des Tests der Baugruppe auf der Hardw are-Ebene ............................................. 70 Benötigtes Testequipment: ............................................................................................................. 71 Schritt 1: Reset ................................................................................................................................ 71 Schritt 2: Pixeltakt ............................................................................................................................ 71 Schritt 3: Horizontal-Decoder .......................................................................................................... 71 Schritt 4: Statemachine für Signal active_pixel .............................................................................. 72 Schritt 5: Horizontal-Zähler............................................................................................................... 72 Schritt 6: Vertikal-Decoder ............................................................................................................. 73 Schritt 7: Statemachine für Signal active_line ................................................................................ 76 Schritt 8: Statemachine für Signal transfer_en ................................................................................ 76 Schritt 9: Vertikal-Zähler ................................................................................................................... 76 Schritt 10: CSYNC-Signal ................................................................................................................. 78 Schritt11: Video-Timing in der Gesamtheit ..................................................................................... 79 Schritt 12: Pointer Character Read ................................................................................................. 79


Seite 3- 3

Schritt 13: Signale char_matrix_Y_[3..0] .......................................................................................... 82 Schritt 14: Pointer_Text_Line_Read.................................................................................................. 83 Schritt 16: Parallelport ausgebend / Cursor-Blinksignal ................................................................... 86 Schritt 17: Parallelport einlesend .................................................................................................... 87 Schritt 18: Erkennung vom Steuerzeichen ...................................................................................... 88 Schritt 19: Erkennung von #last_char und #first_char.................................................................... 88 Schritt 20: Erkennung von #last_line ............................................................................................... 88 Schritt 21: Erkennung von #max_offset .......................................................................................... 88 Schritt 22: Decoder Statemachine Write ........................................................................................ 89 Schritt 23: Statemachine Scroll ....................................................................................................... 95 Schritt 24: Pointer Char Write .......................................................................................................... 96 Schritt 25: Pointer Text Line Write ..................................................................................................... 98 Schritt 26: Pointer Text Line Scroll Offset ........................................................................................ 100 Schritt 27: Statemachine Write ..................................................................................................... 102 Schritt 28: Statemachine Write und Write-Pointer im Zusammenhang / Textspeicher ................. 106 Schritt 29: FIFO-Zugriffssignale ...................................................................................................... 111 Schritt 30: Datentransfer über FIFO ............................................................................................... 113 Schritt 31: Erkennen der Cursor-Position........................................................................................ 114 Schritt 32: Statemachine Cursor Reached ................................................................................... 115 Schritt 33: Statemachine Line Blank ............................................................................................. 116 Schritt 34: Comparator LF............................................................................................................. 118 Schritt 35: Statemachine Character Blank ................................................................................... 118 Schritt 36: Character-Multiplexer .................................................................................................. 122 Schritt 37: Character-RAM ............................................................................................................ 126 Schritt 38: Schieberegister ............................................................................................................ 127 Schritt 39: Ausgangsstufe ............................................................................................................. 129 Schritt 40: Interrupt-Schaltung (nachverdrahtet) ........................................................................... 131 Schritt 41: Gesamttest (am Testadapter)...................................................................................... 133 Schritt 42: Gesamttest (mit CPU) ................................................................................................... 134

Abbildungen ....................................................................................................................................... 135 Test mit dem Monitor „Mainstream“ aus dem WS2004/5 ................................................................... 137 Dokumentation aller Änderungen/Nachverdrahtungen ................................................................ 140


Seite 3- 4

Dokumentation der Vorüberlegungen (21.11.2015 bis 16.05.2016)

Festlegung / Ermittlung von Randbedingungen/Paramet ern bezüglich des Video-Timings/der Darstellung: Am Monitor eines bei Ebay ersteigerten HP-Industrierechners aus den mittleren 1980-er Jahren, der eine zu unserer Bildröhre von der Schirmfläche her äquivalente Bildröhre besitzt wurden folgende Beobachtungen gemacht: Es werden ca. 35..40 Zeichen pro Zeile ausgegeben. (Darstellung einer vollständigen Zeile war mangels Zugriff auf die Software des Rechners nicht möglich, es konnten nur die vorhandenen Boot-Statusmeldungen ausgewertet werden, die weniger als die Hälfte der Textzeilen füllen) Die Zeichen sind aus einer Dotmatrix mit 5 x 7 Dots (ohne Unterlängen) aufgebaut Es werden 20 (Zeichen-)Zeilen ausgegeben. (Extrapolation mit Schiebelehre) Das Videosignal wurde mit dem Oszilloskop vermessen. Die Bildwiederholfrequenz ist 60Hz Die Zeilenfrequenz ist 15,625kHz. Damit ergeben sich 15625Hz/60Hz = 260 Zeilen pro Halbbild. Das entspricht 520 Zeilen pro Frame. Dies ist der amerikanische NTSC-Standard. Es soll nun eine Beziehung zwischen der Höhe der Dotmatrix eines einzelnen Zeichens, der Zahl der Zeichenzeilen und der Zahl der Videozeilen hergestellt werden: Die Höhe der Dotmatrix wird wie folgt abgeschätzt: - „Normales Zeichen“ = 7 Dots (durch Beobachtung sichergestellt) - Unterlängen = 2 Dots - Abstand = 2 Dots Summe = 11 Dots. 520 (Video-)Zeilen / 11 Dots = 47,3 (Zeichen-)Zeilen. Es liegt also nahe, das ein sichtbarer Bildpunkt aus 4 Pixeln (2 Pixel in der Höhe, 2 Pixel in der Breite) zusammengesetzt wird: 520 (Video-)Zeilen / (11 Dots * 2) = 23,6 (Zeichen-)Zeilen. Die Übereinstimmung ist für diese erste Betrachtung hinreichend und zeigt, das man auf dem richtigen Weg ist. Eine exakte Übereinstimmung erhält man jedoch, wenn man von einer Höhe der Zeichenzeile von 13 Dots ausgeht: 520 (Video-)Zeilen / (13 Dots * 2) = 20,0 (Zeichen-)Zeilen. Daher geht der Verfasser von einer Zeilenhöhe von 13 Dots aus.


Seite 3- 5

Es soll nun eine Beziehung zwischen der Breite der Dotmatrix eines einzelnen Zeichens und der Zahl der Pixel (Hinweis: Bildröhre arbeitet analog, Pixel sind daher nur gedacht als der räumliche Bereich, der in einer Taktperiode des Pixeltakts vom Elektronenstrahl überstrichen wird, der Pixeltakt bei NTSC ist 14.31818 MHz = 1/69,8ns) Die exakte Dauer einer Zeile ist nach NTSC-Definition: 63.556us Die Dauer des „Active Video ist 52,6us

Die Breite der Dotmatrix wird wie folgt abgeschätzt: - Zeichen = 5 Dots (durch Beobachtung sichergestellt) - Abstand = 3 Dots Summe = 8 Dots. 32 Zeichen entsprechen dann 8 * 32 = 256 Dots. 52,5us / 256 = 205ns Das entspricht mit vernachlässigbarer Abweichung 3 Taktperioden des Pixeltaktes zu je 69,8ns. Es soll aber auch die (für den Verfasser näherliegende) Möglichkeit nicht ausgeschlossen werden, werden, das ein Dot eines Zeichens auch in horizontaler Richtung aus zwei „Pixeln“ besteht. Hierzu wurde das Video-Ausgangssignal des HP-Rechners noch einmal genauer mit dem Oszilloskop betrachtet. Hierbei zeigte sich eindeutig, das die Breite eines Dots mit vernachlässigbarer Abweichung das Doppelte der Periode des Pixeltaktes = 69,8ns * 2 = 139,6ns beträgt. Daher wurden die zuvor gemachte Beobachtung noch einmal hinterfragt. Hierzu wurde noch einmal die Bildschirmdarstellung am HP-Monitor mit der Schiebelehre ausgemessen. Der Abstand zwischen zwei Zeichen beträgt (im Rahmen der Messunsicherheit)4 Dots. Damit nimmt ein Zeichen horizontal 9 Dots ein. Dies entspricht 2 * 9 * 69,8ns = 1,2564us 52,5us (Active Video) / 1,2564us = 41,8. Daher ist davon auszugehen, das tatsächlich 40 Zeichen ausgegeben werden (was auch ein gängiger Standard ist. Die Extrapolation von der der auf dem Bildschirm angezeigten Zeichenkette


Seite 3- 6

auf die Anzahl der maximal darstellbaren Zeichen ist mit einer relativ hohen Unsicherheit behaftet, so das die nachträglich durch Zeitmessung ermittelten Zeichenzahl von 40 als richtig angenommen wird. Damit können folgende Angaben bezüglich des HP-Rechners als verifiziert gelten: - Ausgabe von 40 Zeichen pro Zeile - Ausgabe von 20 (Zeichen-)Zeilen - Ein Dot auf dem Bildschirm ist aus 2 x 2 „Pixeln“ zusammengesetzt - Ein „normales“ Zeichen besteht aus 5 x 7 Dots - Die Summe aus Unterlänge und vertikalem Abstand beträgt 6 Dots - Der horizontale Abstand beträgt 4 Dots - Ein Zeichen plus 1x Abstand in beide Richtungen nimmt damit 9 x 13 Dots ein. - Das Timing des Video-Signals ist nach NTSC (Interlaced, 520 Zeilen, 60Hz Bildwiederholrate) Der im WS2004/5 aufgebaute Monitor MAINSTREAM, mit dem die Video-Karte im Gesamtsystem arbeiten soll, arbeitet mit dem PAL-Timing (625-Zeilen, Bildwiderholrate 50Hz). Hierbei wurden folgende Parameter realisiert: - Ausgabe von 42 Zeichen pro Zeile - Ausgabe von 20 (Zeichen-)Zeilen - Ein Dot auf dem Bildschirm ist aus 2 x 2 „Pixeln“ zusammengesetzt - Ein Zeichen plus 1x Abstand in beide Richtungen nimmt 9 x 14 Dots ein. Man erkennt nur geringe Abweichungen zum HP-Industrierechner. Es wurde entschieden, das PAL-Timing beizubehalten, um das vorhandene und bewährte Design des Monitors MAINSTREAM unverändert weiter zu nutzen. Die Unterschiede zu dem als Vorbild genommenen Industriestandard des HP-Rechners sind nur minimal. Die Zahl der „aktiven“ Zeilen beim PAL-Timing ist: 625- 20 (Austastlücke in der Mitte des Frames) – 20 (Austastlücke zwischen zwei Frames) = 585 Zeilen. Es wird nun zu der vorherigen Dotmatrix (beim HP-Rechner) ein weiteres (Abstands-) Dot in der Vertikalen hinzugefügt, so das man (wie beim Monitor aus dem WS2004/5) 14 Dots erhält. 14 Dots * 2 (Ein Dot = 2x 2 Pixel) * 20 (Zeichen-)Zeilen = 560 Zeilen. Es verbleiben also 585-60 = 25 Zeilen ungenutzt (zweckmäßigerweise am oberen und unteren Bildschrimrand aufgeteilt, Nutzung des vollen Bildschirms über erhöhte Ablenkamplitude möglich) Um quadratische Pixel zu bekommen ist beim PAL-Timing ein Pixeltakt von 14,7456MHz notwendig. (Als Standardwert für Quarzoszillatoren problemlos lieferbar, z.B. SG-531P 14.7456MC EPSON (Mouser)) Die „active Video“-Zeit einer PAL-Zeile ist wie bei einer NTSC-Zeile 52,5us. Ein Zeichen nimmt horizontal 9 Dots = 18Pixel ein. Dies entspricht einer Zeit von 18 * ( 1/ 14,7456MHz) = 18 * 67,82ns = 1,22us. Damit können 52,5us/ 1,22us = 42,6 Zeichen dargestellt werden. Es verbleiben also 2,6 Zeichenpositionen ungenutzt, die sinnvollerweise auf den rechten und den linkem Bildschirmrand aufgeteilt werden. Damit werden die folgenden Parameter für unsere Video-Karte festgelegt: - Ausgabe von 40 Zeichen pro Zeile - Ausgabe von 20 (Zeichen-)Zeilen - Ein Dot auf dem Bildschirm ist aus 2 x 2 „Pixeln“ zusammengesetzt


Seite 3- 7

- Ein „normales“ Zeichen besteht aus 5 x 7 Dots - Die Summe aus Unterlänge und vertikalem Abstand beträgt 7 Dots - Der horizontale Abstand beträgt 4 Dots - Ein Zeichen plus 1x Abstand in beide Richtungen nimmt damit 9 x 14 Dots ein. - Das Timing des Video-Signals ist nach PAL (Interlaced, 625 Zeilen, 50Hz Bildwiederholrate) - Der Pixeltakt ist 14,7456MHz - Beginn der Darstellung am oberen Bildschirmrand nach 12 Zeilen, die untersten 13 Zeilen bleiben

ungenutzt - Beginn der Darstellung am linken Bildschirmrand nach ca. 1,3 Zeichenpositionen, am rechten

Bildschirmrand bleiben ca. 1,3 Zeichenpositionen ungenutzt. Festlegung des Funktionsumfangs Die (über den FIFO-Schreibport) hereinkommenden ASCII-Zeichen werden in der Reihenfolge ihres Eintreffens zeilenweise ausgegeben. Hierbei sind folgende Steuerzeichen wirksam: LF,CR „Line Feed, Carriage Return“ Beginn einer neuen Zeile FF (12 Dezimal) „Form Feed“, Beginn einer neuen Seite, Clearen des Bildschirms, Start der

Ausgabe bei 0/0 BS „Backspace“ Zurückgehen um eine Zeichenposition, jedoch auf die aktuelle

Zeile beschränkt Weiterhin ist ein Cursor vorgesehen, der als Attribut dem dargestellten Zeichen überlagert


Seite 3- 8

Festlegung der Organisation des Textspeichers Der Textspeicher wird als Dual-Port-RAM ausgeführt. Die Breite des Speichers ist 8 Bit. (Verzicht auf Helligkeitssteuerung für zusätzlichen Grafik-Zeichensatz) Es wird eine Speicherkapazität von 20 x 40 Zeichen = 800 Byte benötigt. Der Textspeicher wird mit dem Video-Timing ausgelesen. Die Anordnung der Zeichen im Textspeicher entspricht ihrer räumlichen Lage auf dem Bildschirm. Die folgenden Skizzen visualisieren den Aufbau des anzuzeigenden Textes im Speicher: (Es wurde zwecks Vereinfachung der Zeichnungen eine Reduktion auf 10 x 10 Zeichen durchgeführt) Grau = undefinierter Speicherinhalt Grün = gespeicherter Text Orange = gespeichertes Steuerzeichen

1 2 3 4 5 6 7 8 9 10

1 D e r G e p a

2

3

4

5

6

7

8

9

10 Beginn der Ausgabe


Seite 3- 9

1 2 3 4 5 6 7 8 9 10

1 D e r G e p a r d

2 f a u

3

4

5

6

7

8

9

10 Zeilenumbruch bei Erreichen des Zeilenendes

1 2 3 4 5 6 7 8 9 10

1 D e r G e p a r d

2 f a u c h t CR LF

3

4

5

6

7

8

9

10 Vorzeitiger Zeilenumbruch durch Steuerzeichen Im Zuge der tatsächlichen Implementierung der Video-Karte wurde entschieden, abweichend von der hier gezeigten Darstellung nur das Zeichen LF auszuwerten.


Seite 3- 10

1 2 3 4 5 6 7 8 9 10

1 D e r G e p a r d

2 f a u c h t CR LF

3 D i e K a t z e

4

5

6

7

8

9

10 Beginn einer neuen Zeile mit den dann folgenden Zeichen Man erkennt, das die Inhalte der Speicherstellen (X/Y) 10/2 sowie 10/3 nicht angezeigt werden dürfen. Diese beiden Fälle unterscheiden sich und müssen getrennt behandelt werden: Speicherstelle 10/2: (Umbruch durch Steuerzeichen) Zunächst müssen die Steuerzeichen im Zeichensatz so codiert sein, das „nichts“ angezeigt wird (Blank) Das Steuerzeichen LF muss weiterhin bewirken, das alle folgenden Zeichen, bis zum Beginn einer neuen Zeile, „geblankt“ werden. (Setzen eines States „Blank“, der über ein AND-Gatter das Videosignal „blankt“, Rücksetzen des States durch Zeilenwechsel der Ausleseadresse) Speicherstelle 10/3 (Zeile wird gerade beschrieben) Bei der Speicheradresse 10/3 ist die auslesende Zeilenadresse gerade um Eins höher als die Zeilenadresse für das Schreiben. Ein Comparator erkennt, das die Ausleseadresse höher als die Schreibadresse ist und „blankt“ das Videosignal. Auf diese Weise wird auch die Anzeige der (ebenfalls undefinierten) Zeilen 4 bis 10 verhindert. Die Schreibadresse, bestehend aus Zeile und Spalte, wird wie folgt beeinflusst: Schreibadresse Zeile: Systemreset => Adresse := 0 Letztes Zeichen in der Zeile wurde gefüllt => Adresse := Adresse + 1 Zeilenumbruch durch Steuerzeichen => Adresse := Adresse + 1 Zeile 20 durch Füllen letztes Zeichen oder Umbruch mit Steuerzeichen beendet => Adresse := 0 Steuerzeichen „FF“ (neue Seite) => Adresse :=0 Schreibadresse Spalte:


Seite 3- 11

Systemreset => Adresse := 0 Neues Zeichen kommt herein => Adresse := Adresse + 1 Zeilenumbruch durch Überlauf oder Steuerzeichen => Adresse = 0 Steuerzeichen BS „Backspace“, Spaltenadresse größer Null => Adresse := Adresse –1 Steuerzeichen BS „Backspace“, Spaltenadresse =Null => Adresse := Adresse (0) Diese Funktionen lassen sich in einer Statemachine codieren. Bei einem Überlauf des Textspeichers wird somit die „älteste“ Zeile zuerst überschrieben. Damit ist dann nicht mehr die erste Zeile (Zeile 1) die Zeile, die zuoberst auf dem Bildschirm angezeigt wird, sondern die Zeile 2. Zeile 1 wird also als unterste Zeile auf dem Bildschirm angezeigt. Damit muss die am Speicher wirksame Zeilen-Leseadresse gegenüber der vom Video-Timing abgegebenen „nativen“ Leseadresse um einen Offset von 1 erhöht sein. Mit dem Schreiben einer weiteren Zeile muss dieser Offset um 1 auf 2 erhöht werden. Nach dem Schreiben von 10 weiteren Zeilen (in der Zeichnung, 20 Zeilen im realen Gerät) ist der Offset erneut Null. Der Offset wird mit einem Synchronzähler und einer Statemachine erzeugt und der Zeilen-Leseadresse mit einem Addierer hinzugefügt. Für den Offset gelten folgende Bedingungen Systemreset=> Offset :=0 Steuerzeichen „FF“ (neue Seite) => Offset :=0 Schreibadresse war erstmalig nach Systemreset oder Formfeed 20 und erneuter Zeilenumbruch => Offset := Offset + 1 Offset = 20 und erneuter Zeilenumbruch => Offset := 0 Es muss nun überprüft werden, wie die Bedingung „Blank, wenn Leseadresse größer Schreibadresse“ im Zusammenhang mit dem soeben eingeführten Offset funktionieren kann: Die Bedingung bleibt erhalten, wenn man die (mit dem Offset behaftete) Leseadresse am Speicher mit der Schreibadresse vergleicht.


Seite 3- 12

Festlegung der Datenübertragung vom CPU-Bus in den Textspeicher Die CPU legt die auszugebenden Daten (8 Bit ASCII) in einem FIFO ab. Dieses FIFO muss eine Kapazität von mindestens einer Bildschirmseite (800 Byte) haben. In der Vertikalen Austastlücke (zwischen zwei Frames) werden die Daten aus dem FIFO ausgelesen und in den Textspeicher geschrieben. (Es wird nicht zwischen zwei Halbbildern innerhalb eines Frames aktualisiert) Die Länge der Austastlücke ist 20 Zeilen (Quelle: Möhring, Seite 27) Das entspricht 64us * 20 = 1280us. Damit stehen für die Übertragung eines einzelnen Zeichens maximal 1280us/800 = 1,6us zur Verfügung, was problemlos ausreicht. Das Auslesen des FIFOs wird von einer Statemachine wie folgt gesteuert: Erkennen der Austastlücke Als Schleife wiederholen: Wenn Austastlücke vorhanden, und FIFO nicht leer (Empty-Flag auswerten), dann Übertragung eines Zeichens aus FIFO in Textspeicher. Das Schreiben ins FIFO erfolgt asynchron vom Bus aus. Das FULL-Flag wird über ein Statusregister an die CPU zurückgemeldet, eventuell auch das HALF-FULL-Flag. Auswahl geeigneter Bausteine Es sollen nur Bausteine im DIL-Gehäuse verwendet werden, um Layout, Bestückung und Inbetriebnahme (Verwendung von IC-Fassungen) einfach zu halten und um ein „zeittypisches“ Vintage-Aussehen der Baugruppe (wichtg für mögliche zukünftige museale Verwendung) zu erreichen. Als FIFO eignet sich der IDT 7204L12TPG (Mouser) mit einer Kapazität von 4Kx8 (die zu große Kapazität ist unschädlich, kleinere Kapazitäten sind schwieriger beschaffbar) Als Dual-Port-RAM eignet sich der IDT 7130LA35PDG (Mouser) mit einer Kapazität von 1K x 8. Mit dem 7134LA20PDG (4K x 8) ergeben sich aber ggf. Vorteile bei der getrennten „Verwaltung“ von Zeilen- und Spaltenadressen.


Seite 3- 13

Dokumentation des Detailentwurfs Detaillierte Definition des Video-Timings Es zeigte sich, das die zunächst im Rahmen der Vorüberlegungen genutzte Definition des Video-Signals nach Möhring (1961, Seite 10) im Widerspruch zu anderen Quellen steht, das Timing bezüglich des ersten und des Zweiten Frames ist genau vertauscht. Es wird nun das folgende Timing implementiert, das in mehreren (heutigen) Quellen übereinstimmend dargestellt ist:

Achtung: hier andere Zählweise: die erste Zeile heißt Zeile Null !


Seite 3- 14

Quelle: Wikipedia

Quelle: Wikipedia Es wurde die Entscheidung getroffen, das Video-Timing nach Wikipedia als Grundlage zur Realisierung zu verwenden.


Seite 3- 15

Die Erzeugung des Video-Timings und weitere Schaltu ngsteile auf Video-Timing-Ebene

Grundsätzliches Zunächst war vorgesehen, einen höher integrierten Baustein 74ACT715/LM1882 zur Erzeugung des Video-Timings zu verwenden. Im Verlauf des Entwurfsprozesses zeigte sich jedoch, das es vielfältige Verknüpfungen zwischen dem Video-Timing und den anderen Funktionsgruppen gibt, die teilweise vom Timing her sehr kritisch sind. Daher wurde die Entscheidung getroffen, auch das Video-Timing mit SSI-Bausteinen der Serie 74F zu realisieren. Dieser Weg ist zwar zunächst aufwendiger, er vermeidet jedoch mögliche Risiken bezüglich des Timings, die erst ein einem späteren Zeitpunkt des Projektverlaufs sichtbar werden könnten. Aufgrund von Vorüberlegungen wird ein Pixeltakt von 14,7456MHz vorgesehen (PAL Square Pixel). Um das Timing der gesamten Video-Karte synchron zu gestalten wird der Pixel-Takt auch als Takt für die Steuerung des Textspeichers verwendet.

Erzeugung des Horizontal-Timings Dieser Schaltungsteil zählt den Pixeltakt hoch und decodiert aus dem Zählerstand verschiedene Steuersignale. Der Zählerstand ist der horizontalen Position des Elektronenstrahls auf der Bildröhre proportional. Es werden die folgenden Steuersignale ausgegeben: hor_pix_count = 177 = 12us markiert den Beginn des aktiven Bereichs der Zeile, in

dem ein Bildinhalt dargestellt wird.

hor_pix_count = 944 = 64us markiert das Ende der Zeile hor_pix_count = 35 = 2,35us für Generierung der Sync-Patterns hor_pix_count = 69 = 4,7us hor_pix_count = 403 = 27,3us hor_pix_count = 472 = 32us hor_pix_count = 507 = 34,35us hor_pix_count = 874 = 59,3us Es soll zunächst hergeleitet werden, welche Steuersignale zum Erzeugen der verschiedenen Sync-Patterns benötigt werden. Man erkennt, das 6 verschiedene Patterns, hier mit P0 bis P6 bezeichnet, vorkommen:


Seite 3- 16

:= P2

59,3

us

623 :=P1

0us

34,3

5us

2,35

us

32us

27,3

us

Default := P0

3 := P4

624,625, 4,5, 311,312, 316,317

64us

4,7u

s

1,2, 314, 315 := P3

313 := P5

Hinweis: In der folgenden Darstellung wurde irrtümlich die Zeile 318 als „normale“ Zeile interpretiert, obwohl sie ein spezielles, nur in dieser Zeile vorkommendes, Pattern aufweist, bei dem der Sync-Impuls bereits nach 2,35us endet und nicht nach 4,7us, wie bei „normalen“ Zeilen. In der Praxis zeigte sich, dass mit den zum Test verwendeten Monitoren hierdurch keinerlei Beeinträchtigungen auftraten. Daher wurde dieser Fehler nicht korrigiert. Im weiteren Verlauf dieses Textes findet sich die Beschreibung einer möglichen Schaltungsänderung, die den genannten Umstand berücksichtigt. Diese Patterns sind in der obenstehenden Abbildung mit den dazugehörigen Zeiten und den Zeilen, in denen sie vorkommen, dargestellt. Man erkennt, das sich alle 6 Pattern an einem oder mehreren der 7 Zeitpunkte 2,35us, 4,7us, 27,3us, 32us, 34,35us, 59,3us und 64us ändern. Wenn man diese Zeitpunkte aus dem Zählerstand des Horizontal-Zählers decodiert, dann erhält man Ausgangssignale, die für die Länge einer Periode des Pixeltakts aktiv sind, wenn der entsprechende Zählerstand anliegt. Diese Signale können dann das Setzen oder Rücksetzen des Sync-Signals


Seite 3- 17

veranlassen. Hierbei werden diese Signale in Abhängigkeit von der aktuell anliegenden Zeile auf die Setz- bzw. Rücksetzeingänge für das Sync-Signal geschaltet. Es soll noch der durch die Bildung der Zeiten mit dem (nicht exakt „passenden“) Pixeltakt entstehenden Quantisierungsfehler eingegangen werden: Die Periode des Pixeltaltes 14.7456 MHz ist 0,06788168 us. Zählerstand tatsächliche Zeit ideale Zeit Abweichung 35 2,374us 2,35us +23,6ns +1,0% 69 4,679us 4,7us -20,6ns -0,44% 177 12,00us 12,00us +3,5ns 0% 403 27,33us 27,3us +30,2ns +0,1% 472 32,01us 32,00us +9,5ns +0,03% 507 34,38% 34,35us +33,1ns +0,1% 874 59,27us 59,3us -28,1ns -0,05% 944 64,02us 64,00us +19,1ns +0,03% Man erkennt, das die beiden für die Synchronisation kritischen Zeiten, 32us und 64us mit einer besonders geringen Abweichung (gerade auch relativ zueinander) erzeugt werden. Die mit 64,02 us etwas zu hohe Zeitdauer einer Zeile ist ohne Belang, da dies durch den Monitor mühelos ausgeglichen werden kann. (Man erkennt, das eine exakte Darstellung der 32us-Zeitmarke nur mit einer geraden Anzahl an Pixeln pro Zeile möglich ist) Mit den hintereinander geschalteten Synchronzählern U1101 und U1102 wird der Pixeltakt hochgezählt. Die Freigabeeingänge /ENT und /ENP von U1101 sind fest auf L gelegt. Damit zählt der Zähler (sofern das /PE-Signal auf H ist, Laden {/PE auf L} hat Priorität gegenüber dem Zählen) mit jeder Periode des Pixeltaktes. Wenn U1101 überläuft, dann ist dessen Ausgang /RCO für eine Periode des Pixeltaktes auf L, womit dann U1102 bei der dann erfolgenden ansteigenden Flanke des Pixeltaktes um Eins hochzählt. Beim Erreichen des Zählerstandes 944 wird vom (bisher in diesem Text noch nicht beschriebenen) Decoder das Signal hor_pix_count=944=64us_unreg auf L gesetzt. In der Folge wird die Zählerkette aus U1101 und U1102 mit dem Wert 1 (nicht Null!) geladen. Das Rücksetzen auf Eins wurde vorgenommen, da in der Literatur die Pixel und Zeilen eines Videobildes im Allgemeinen von Eins an beginnend gezählt werden und nicht von Null an. Damit werden Verwechslungen nebeneinanderliegender Zeilen und Pixel im Verlauf von Entwurf und Inbetriebnahme unwahrscheinlicher gemacht. Die Steuereingänge der Zählerbausteine 74F269 haben die folgende Wirkung: - Die Zählrichtung ist durch einen festen H-Pegel am Eingang U/D stets aufwärts zählend. - Wenn der Eingang /PE auf L ist, dann wird der Zähler geladen. Das Laden hat Priorität vor dem

Zählen. - Wenn der Eingang /PE auf H ist und einer der beiden (oder beide) der Eingänge /ENT oder /ENP

auf H sind, dann wird der bestehende Zählerstand unverändert gehalten. - Wenn der Eingang /PE auf H ist und beide Eingänge /ENT und /ENP auf L sind, dann wird (im

konkreten Fall aufsteigend) gezählt. Im Resetzustand (#reset = L) wird der Zähler (da der Pixeltakt auch während des Resetzustandes durchläuft) mit dem Startwert 1 geladen. Um dies zu ermöglichen wurde das Gatter U1111A vorgesehen. Im Resetzustand ergibt sich am Ausgang des Gatters U1111A stets ein L-Pegel.


Seite 3- 18

Bei einem Zählerstand von ungleich 944 ist das Signal #hor_pix_count=944=64us_unreg auf H. Damit ergibt sich (wenn #reset für den Normalbetrieb auf H-Pegel angenommen wird) ein H-Pegel am Ausgang des AND-Gatters U1111A. Damit sind die Eingänge /PE der Zählerkette auf H, womit die Zählerkette bei jeder ansteigenden Flanke des Pixeltaktes ihren Zählerstand um Eins erhöht. Beim Erreichen des Zählerstandes 944 geht das Signal #hor_pix_count=944=64us_unreg auf L. Damit geht der Ausgang des AND-Gatters U1111A auf L. Damit sind die Eingänge /PE der Zählerkette auf L, womit die Zählerkette mit der dann folgenden ansteigenden Flanke des Pixeltaktes mit dem Wert 1 geladen wird. Da an das Signal #hor_pix_count=944=64us_unreg besondere Anforderungen an das Timing gestellt werden (Dieses Signal muss in der die Zeilen hochzählenden Zählerkette bei der ersten Stelle die Kombinatorik bis zum /RCO-Ausgang durchlaufen) wird für dieses Signal ein separater Comparator, U1112, vorgesehen. Der Comparator hat eine Breite von 8 Bit, während der zu überprüfende Zählerstand eine Breite von 10 Bit hat. Man kann jedoch darauf verzichten, die beiden niederwertigsten Bits des Zählerstandes zu betrachten, da der Zähler mit dem Erkennen von 944 zurückgesetzt wird. Es ist daher nicht nötig, zwischen 944 und 945..947 unterscheiden zu können, damit ist durch die Vermeidung der Kaskadierung von Comparatoren eine Einsparung von Laufzeit und Bauteilen möglich. Nun wird die Decoderschaltung für die anderen Ausgangssignale beschrieben: Die Schaltung ist auf einen möglichst geringen Bauteilaufwand hin ausgelegt. Mit den Decodern U1103, U1104 und U1105A werden die einzelnen „Stellen“ des Zählerstandes, wenn man ihn als Hex-Zahl betrachtet, getrennt voneinander decodiert. Bei jedem Zählerstand ist von jedem der drei Decoder ist genau ein Ausgang auf L. Die weitere Wirkungsweise des Decoders wird anhand des Signals hor_pix_count=921=62,5us_unreg beschrieben. 921 ist die Summe aus 3 * 256 + 9 * 16 + 9*1 = 768 + 144 + 9 Bei einem Zählerstand von 921 sind die folgenden drei Decoderausgänge auf L, während alle anderen Decoderausgänge auf H sind: U1101 Ausgang Y9 U1104 Ausgang Y9 U1105 Ausgang Y3 Diese drei Ausgänge werden an die Eingänge eines 3-fach NOR-Gatters (U1108B) geführt. Der Ausgang dieses Gatters ist nur dann auf H, wenn alle drei Eingänge auf L sind, dies ist nur dann der Fall, wenn der Zählerstand 921 beträgt. Die Decodierschaltungen für die anderen Steuersignale arbeiten sinngemäß mit den Gattern U1106A bis U1108A.


Seite 3- 19

Die Laufzeit von der ansteigenden Flanke des Pixeltaktes bis zum Ausgang der soeben beschriebenen NOR-Gatter setzt sich wie folgt zusammen: (Verzögerungszeiten max. über Temperatur, der jeweils größte Wert aus L zu H oder H zu L, Betrachtung des langsamsten Pfades) 74F269 Clk => Q 10,5ns max. 74F154 A..D zu Y 10,5ns max. 74F27 A zu Y 7ns max. Summe 28ns max. Eine Periode des Pixeltaktes dauert 67,8ns. Die auf die betrachtete Schaltung folgende kombinatorische Schaltung hat eine Laufzeit in ähnlicher Größenordnung wie die gerade betrachtete Decoderschaltung, womit nicht mehr sichergestellt ist, das sich rechtzeitig vor der nachfolgenden Taktflanke am Eingang der dann folgenden Registerstufe stabile Pegel eingestellt haben. Daher wird eine Registerstufe am Ausgang des hier beschriebenen Decoders eingefügt (Pipelining), aufgebaut mit dem Octal-Registerbaustein U1109. Die damit entstandene Pipeline-Verzögerung von einem Takt wird an den anderen Pfaden der Schaltung nachvollzogen.

Erzeugung des Vertikal-Timings Die Zählerkette aus U1201 und U1202 sowie die nachfolgende Decoderschaltung mit U1203, U1204 und U1105B gibt Steuersignale aus, die jeweils für die Dauer einer Zeile auf H sind. Die Schaltung zählt dann um Eins hoch, wenn die die Pixel zählende Zählerkette aus U1101 und U1102 den Zählerstand 944 (also das letzte Pixel vor dem Zeilenumbruch) erreicht hat. Mit dem Abschluss der letzten Zeile (625) wird der Zähler auf den Wert 1 zurückgesetzt. (Um mit der üblichen Notation für Zeilen im Videobild konform zu gehen ist die oberste Zeile des Bildes auch in dieser Schaltung die Zeile 1 und nicht die Zeile Null) Die Wirkungsweise der Steuereingänge der Zählerbausteine wurde bereits anhand des Pixel-Zählers beschrieben. Bei einem L-Pegel am Signal #reset ergibt sich am Ausgang des Gatters U1111B stets ein L-Pegel. womit die Zählerkette mit dem Wert 1 geladen wird. Für die folgende Betrachtung sei das Signasl #reset stets auf H. Man erkennt das der Ausgang von U1302C nur dann auf L ist, wenn die Signale video_line_count=625_unreg und hor_pix_count=944=64us_ unreg gleichzeitig auf H sind. Dies ist nur dann der Fall, wenn gerade das letzte Pixel der letzten Zeile des zweiten Halbbildes (von beiden Zählerketten im Zusammenwirken) adressiert ist. Dieser L-Pegel am Ausgang von U1302C führt zu einem L-Pegel am Ausgang von U111B, womit dann der Zähler (bei der dann folgenden ansteigenden Flanke des Pixeltaktes) mit 1 geladen wird. Wenn das Signal hor_pix_count=944=64us_unreg auf H ist, das Signal video_line_cont=625_unreg aber auf L ist, dann stellt sich am Ausgang von U1302C ein H-Pegel ein. Damit stellt sich auch an den Eingang /PE der Zählerketten ein H-Pegel ein. Gleichzeitig werden über das mit U1110B invertierte Signal #hor_pix_count=944=64us_unreg die Eingänge ENT/ und /ENP des ersten Zählers der Kette


Seite 3- 20

(U1201) und der Eingang /ENP des Zweiten Zählers der Kette (U1202) auf L gesetzt. Bei der dann folgenden ansteigenden Flanke des Pixeltaktes zählt die Zählerkette um Eins hoch. Wenn das Signal hor_pix_count=944=64us_unreg auf L ist, dann sind die Eingänge /ENT /ENP von U1201 sowie /ENP von U1202 auf H, der Zählerstand ändert sich nicht, obwohl der Pixeltakt anliegt. Es soll noch der Fall des Überlaufs von U1201 betrachtet werden: In diesem Fall geht der Ausgang /RCO von U1201 in Folge des L-Pegels an /ENP und /ENT auf L. (Verzögerungszeit 10ns max.). Erst dann ist auch der Eingang /ENT des Zählers U1202 auf L. Es ergibt sich hierbei die folgende Laufzeit: (max.-Werte 0..70°C) U1101/U1102 74F269 Clk => Q 10,5ns U1112 74F521 A => Y 11ns U1302C 74F00 A => Y 6ns U1111B 74F08 A => Y 6,6ns U1201 74F269 /ENT => /RCO 10ns U1202 74F269 tsu /ENT => CLK 8ns Summe: 43,1ns Man erkennt einen ausreichenden „Sicherheitsbstand“ von 67,8ns – 43,1ns = 24,7ns. Der mit U1203, U1204,U1105B sowie U1206A..U1212B aufgebaute Decoder ist zu dem bereits beschriebenen Decoder für den Horizontalteil identisch, lediglich die Zahl der Ausgänge wurde erhöht. Das Fan-out der Bausteine 74F154 und 74F139 beträgt 33 und wird in dieser Schaltung mit hohen Reserven nicht ausgenutzt.

Erzeugung der Sync-Patterns Die Signale #P0, P1..P5 steuern die Erzeugung der verschiedenen Pulsformen für die Erzeugung des CSYNC-Signals. Von diesen 6 Signalen ist jeweils ein Signal in Abhängigkeit von der aktuell anliegenden Zeile aktiv: P1: Zeile 623 P2: Zeilen 624,625, 4,5, 311,312, 316,317 P3: Zeilen 1,2, 314,315 P4: Zeile 3 P5: Zeile 313 #P0 ist immer dann aktiv, wenn keines der Signale P1..P5 aktiv ist, also in allen Zeilen mit „normalem“ Sync-Pattern. Das Signal P1 ist direkt der Decoderausgang video_line_count=623. Das Signal P1 wird durch Veroderung der dazugehörigen Decoderausgänge erzeugt. Hierzu werden die Inverter U1101E/F, U1215A/B, U1215 E/F sowie U1216A/B und das NAND-Gatter U1218 verwendet. Das Signal P3 wird auf identische Weise mit den Invertern U1110C/D und U1215C/D sowie dem NAND-Gatter U1219A erzeugt. Die Signale P4 und P5 entsprechen den Decoderausgängen für die Zeilen 3 und 313. Es soll nun die längste Laufzeit für diese Signale bestimmt werden. Diese ist für das Signal P3 (bis zum Ausgang des Gatters U1219A) wirksam: (Verzögerungszeiten max. über Temperatur, der jeweils größte Wert aus L zu H oder H zu L, Betrachtung des langsamsten Pfades)


Seite 3- 21

74AS867 Clk => Q 16ns max. 74F154 A..D zu Y 10,5ns max. 74F27 A zu Y 7ns max. 74F04 A zu Y 6ns max. 74F20 A zu Y 6ns max. Summe 45,5ns max. Mit der Laufzeit der noch folgenden Logik ergäbe sich eine zu hohe Gesamtlaufzeit, die in der Größenordnung der Periode des Pixeltaktes von 67,8ns liegen würde. Daher wird eine Pipeline-Registerstufe mit dem Octal-Registerbaustein U1221 vorgesehen. Die Set-Up-Zeit des verwendeten Registers 74F574 ist 2,0ns. Das CSYNC-Signal wird mit der aus dem Multiplexer U1303 und dem Flipflop U1304A aufgebauten Statemachine erzeugt. Der Eingang A des Multiplexers U1303 ist der Set-Eingang der Statemachine. Wenn dieser Eingang auf H ist, dann wird mit der folgenden ansteigenden Flanke des Pixeltakts die Statemachine gesetzt. Der Eingang A des Multiplexers U1303 ist der Reset-Eingang der Statemachine. Wenn dieser Eingang auf H ist, dann wird mit der folgenden ansteigenden Flanke des Pixeltakts die Statemachine rückgesetzt. Die Funktion der Statemachine wird anhand der folgenden Wahrheitstabelle veranschaulicht: U1303 U1303 gewählter U1303 Funktion B A Eingang Y U1303 (= Q (t+1) L L D0 Q halten L H D1 L rücksetzen H L D2 H setzen H H D3 Q halten (Widerspruch) Das am Multiplexerausgang U1303/Y anliegende Signal geht an den D-Eingang des Flipflops U1304A. Mit der dann folgenden ansteigenden Flanke des Pixeltaktes wird dieses Signal vom Flipflop übernommen und erscheint am Ausgang Q des Flipflops.


Seite 3- 22

Aus der noch einmal wiedergegebenen Impulsdiagramm des CSYNC-Signals kann nun die Funktion der soeben beschriebenen Statemachine in Verbindung mit der ihr vorgeschalteten Logik beschrieben werden:

:= P2

59,3

us

623 :=P1

0us

34,3

5us

2,35

us

32us

27,3

us

Default := P0

3 := P4

624,625, 4,5, 311,312, 316,317

64us

4,7u

s

1,2, 314, 315 := P3

313 := P5

Hinweis: In der folgenden Darstellung wurde irrtümlich die Zeile 318 als „normale“ Zeile interpretiert, obwohl sie ein spezielles, nur in dieser Zeile vorkommendes, Pattern aufweist, bei dem der Sync-Impuls bereits nach 2,35us endet und nicht nach 4,7us, wie bei „normalen“ Zeilen. In der Praxis zeigte sich, dass mit den zum Test verwendeten Monitoren hierdurch keinerlei Beeinträchtigungen auftraten. Daher wurde dieser Fehler nicht korrigiert. Im weiteren Verlauf dieses Textes findet sich die Beschreibung einer möglichen Schaltungsänderung, die den genannten Umstand berücksichtigt. Es wurde bereits sichergestellt, das die Signale P0..P5 gegeneinander ausschließend sind. Wenn das Signal P0 aktiv ist, dann soll folgende Funktion ausgeführt werden: Setzen der Statemachine zum Zeitpunkt 4,7us Rücksetzen der Statemachine zum Zeitpunkt 64us. Wenn das Signal P1 aktiv ist, dann soll folgende Funktion ausgeführt werden: Setzen der Statemachine zum Zeitpunkt 4,7us Rücksetzen der Statemachine zum Zeitpunkt 32us. Setzen der Statemachine zum Zeitpunkt 34,35us Rücksetzen der Statemachine zum Zeitpunkt 64us. Wenn das Signal P2 aktiv ist, dann soll folgende Funktion ausgeführt werden:


Seite 3- 23

Setzen der Statemachine zum Zeitpunkt 2,35us Rücksetzen der Statemachine zum Zeitpunkt 32us. Setzen der Statemachine zum Zeitpunkt 34,35us Rücksetzen der Statemachine zum Zeitpunkt 64us. Wenn das Signal P3 aktiv ist, dann soll folgende Funktion ausgeführt werden: Setzen der Statemachine zum Zeitpunkt 27,3us Rücksetzen der Statemachine zum Zeitpunkt 32us. Setzen der Statemachine zum Zeitpunkt 59,3us Rücksetzen der Statemachine zum Zeitpunkt 64us. Wenn das Signal P4 aktiv ist, dann soll folgende Funktion ausgeführt werden: Setzen der Statemachine zum Zeitpunkt 27,3us Rücksetzen der Statemachine zum Zeitpunkt 32us. Setzen der Statemachine zum Zeitpunkt 34,35us Rücksetzen der Statemachine zum Zeitpunkt 64us. Wenn das Signal P5 aktiv ist, dann soll folgende Funktion ausgeführt werden: Setzen der Statemachine zum Zeitpunkt 2,35us Rücksetzen der Statemachine zum Zeitpunkt 32us. Setzen der Statemachine zum Zeitpunkt 59,3us Rücksetzen der Statemachine zum Zeitpunkt 64us. Umgekehrt kann man diese Funktionsbeschreibung nach den Zeitpunkten des Setzens und Rücksetzens auflösen: Setzen zum Zeitpunkt 2,35us: Wenn P2 oder wenn P5 Setzen zum Zeitpunkt 4,7us: Wenn P0 oder wenn P1 aktiv Setzen zum Zeitpunkt 27,3us: Wenn P3 oder wenn P4 aktiv Setzen zum Zeitpunkt 34,35us: Wenn P1 oder wenn P2 oder wenn P4 aktiv Setzen zum Zeitpunkt 59,3us: Wenn P3 oder wenn P5 aktiv Rücksetzen zum Zeitpunkt 32us: Wenn P0 NICHT aktiv Rücksetzen zum Zeitpunkt 64us immer. Diese Funktion wird mit der aus U1301A..D, U1302A..C und U1306 aufgebauten Logik implementiert. Die auf das Horinzontaltiming bezogenen Zeitinfomation hor_pix_count=... und die auf das Vertikaltiming bezogene Zeileninformation P... werden in der ersten Gatterebene (U1301A..D, U1302A/B) mit NAND-Gattern verundet. Beim Zusammentreffen der ausgewählten auf das Horizontale bezogenen Zeitinformation pix_count=... und der auf das Vertikale bezogenen Zeileninformation P.. geht der Ausgang des entsprechenden NAND-Gatters für die Dauer eines Pixels auf L. Wenn einer der Ausgänge der ersten Gatterebene auf L geht, dann geht das dazugehörige Ausgangssignal der zweiten Gatterebene (U1217E, U1306) auf H, womit die Statemachine in der bereits beschriebenen Weise über die Signale set_sm_csync und res_sm_csync gesetzt oder rückgesetzt wird.


Seite 3- 24

Die zusammengesetzten Zeileninformationssignale #P0, P0+P1, P1+P2+P4, P2+P5,P3+P4, P3+P5 werden mit den Bausteinen U1212C, U1217B/F und U1222A..D durch einfache Veroderung erzeugt. Es soll nun die Laufzeit durch die soeben beschriebenen Logikschaltungen und die zuvor beschriebene Statemachine betrachtet werden: (Verzögerungszeiten max. über Temperatur, der jeweils größte Wert aus L zu H oder H zu L, Betrachtung des langsamsten Pfades) U1221 74F574 Clk => Q 10ns U1212C 74F27 A => Y 7ns U1217F 74F04 A => Y 6ns U1301D 74F00 A => Y 6ns U1306 74F30 A => Y 5,5ns U1303 74F151 S => Y 10,5ns U1304A 74F74 tsu 3ns Summe: 48ns Die Taktperiode des Pixeltaktes ist 67,8ns, die Reserve ist noch hinreichend. Weiterhin soll das Timing des CSNC-Signals an U1304A/Q in Bezug auf das ursprüngliche Horizontaltiming (Bezug: Zählerstand U1101/U1102) betrachtet werden. 1. Pipeline-Stufe: Register U1109 parallel zu Vertikalzähler U1201/U1202 2. Pipeline-Stufe: Flipflop U1304A. Das CSYNC-Signal ist also dem als Referenz dienenden Zählerstand U1101/U1102 um 2 Pipeline-Stufen (= 2 Pixeltakte) nachfolgend. Der exakte Zeitpunkt, zu dem die Signale P0..5 nach Zeilenbeginn umschalten ist unkritisch, da alle Sync-Patterns bis zum Zeitpunkt 2,35ns = 35 Pixeltakte miteinander identisch sind. Daher geht der Pipeline-Delay durch U1221 nicht in diese Betrachtung ein. Zu einem späteren Zeitpunkt wird noch die Angleichung der Pipeline-Delays zwischen dem CSYNC-Signal und dem den Bildinhalt darstellendne Signal betrachtet. Hinweis: Mit der folgenden Schaltungsänderung kann das spezielle Sync-Pattern in der Zeile 318 realisiert werden. Diese Änderung wurde bisher nicht umgesetzt, da sich bei dem zum Test verwendeten Monitoren keine Beeinträchtigung der Synchronisation zeigte.

4,7u

s

0us

irrtümlicherweise für Zeile 318verwendetes Pattern

2,35

us

:= P6

64us

für Zeile 318 richtiges Pattern


Seite 3- 25

64

U??A74F27

12

1312

L1

208

144

112

video_line_count_2

11

L1

15

U130674F30

4

58

61112

123

48

video_line_count_4

96

256

6

P6

128

13

768

80

#P0

512

16

U120374F154

12345678910111314151617

23222120

1819

Y0Y1Y2Y3Y4Y5Y6Y7Y8Y9

Y10Y11Y12Y13Y14Y15

ABCD

G1G2

2

U122074F30

4

58

61112

123

192

8

pix_clk_1

H1

10

video_line_count_8

176

4

0

32

video_line_count_0

U120474F154

12345678910111314151617

23222120

1819

Y0Y1Y2Y3Y4Y5Y6Y7Y8Y9

Y10Y11Y12Y13Y14Y15

ABCD

G1G2

U??F74F04

1312

12

0 #P0

video_line_count_3

video_line_count_9

9

video_line_count_7

3

L1

0

L1

U122174F574

23456789

11

1

1918171615141312

D1D2D3D4D5D6D7D8

CLK

OE

Q1Q2Q3Q4Q5Q6Q7Q8

video_line_count_6Video_line_count = 318

L1

U??B74F00

4

56

U1105B74F139

1413

15

1211109

AB

G

Y0Y1Y2Y3

1

14

160

5

video_line_count_5

224240

7

hor_pix_count=35=2,35us

video_line_count_1

set_sm_csync

Diese Schaltungsänderung kann im Bedarfsfall nachträglich eingebracht werden.

Erzeugung des active_video Signals Das active_video-Signal ist dann auf H, wenn Bildinhalte ausgegeben werden sollen, also im aktiven Bereich einer Zeile (12us..64us), dies aber nur, wenn es sich um eine zur Darstellung des Bildinhalts gedachten Zeile handelt, also eine Zeile, die sich ausserhalb der beiden Bereiche des Bildrücklaufs eines Frames befindet. Wenn das active_viedo-Signal auf L ist, dann wird die Ausgabe des Schwarzwertes erzwungen, der entsprechende Bereich der Zeile oder des Bildes also geblankt. In der Folge wird das exakte Timing dieses Signals hergeleitet: Vertikal: Nach Definition:


Seite 3- 26

Field 1 Zeilen 1 .. 312 23 .. 310 visible Field 2 Zeilen 312,5 .. 625 336.. 623 visible 310 – 22 = 288 623-335 = 288 288 + 288 = 576 visible Zeilen. Unsere Zeichen plus einmal Abstand brauchen 14 dots das sind 14 Zeilen je Halbbild. Wir stellen 20 Textzeilen dar. 20 * 14 = 280 => man stellt 8 Zeilen pro Halbbild nicht dar Auf das Vollbild bezogen: 20 * 14 * 2 = 560 Zeilen. 576 – 560 = 16. Wir stellen die obersten 4 sichtbaren Zeilen des jeweiligen Halbbildes nicht dar, ebenso die untersten 4 sichtbaren Zeilen. 22 geblankt, ist nicht im Visible-Bereich 23 geblankt 24 geblankt 25 geblankt 26 geblankt 27 Bildinhalt, active .. .. 306 Bildinhalt, active 307 geblankt 308 geblankt 309 geblankt 311 geblankt 312 ist nicht im Visible-Bereich 306- 26 = 280. 335 geblankt, ist nicht im Visible-Bereich 336 geblankt 337 geblankt 338 geblankt 339 geblankt 340 Bildinhalt, active .. .. 619 Bildinhalt, active 620 geblankt 621 geblankt 622 geblankt 623 geblankt 624 ist nicht im Visible-Bereich 619- 339 = 280. � setzen Statemachine ACTIVE bei 27,340 � rücksetzen Statemachine ACTIVE bei 307,620 Horizontal:


Seite 3- 27

Ein Zeichen mit Abstand ist 9 Dots breit, das sind 18 Pixel. Wir stellen 40 Zeichen dar. Das entspricht dann 40 * 18 = 720 Pixeln. Die Zeile umfasst 944 Pixel. Active (aus signaltechnischer Sicht) beginnt bei Pixel 177 und endet bei Pixel 944. Das sind 944-176 = 768 Pixel. Es verbleiben 48 Pixel. Bei mittiger Zentrierung: 48/2 = 24 Start des Aktiven Bereichs bei Pixel 177 + 24 = 201. Stop des Aktiven Bereichs bei Pixel 944-24 = 920. (Das Signal zum Stoppen wird dann bei 921 erzeugt oder das Signal zum Starten wird bei 200 erzeugt und das Signal zum Stoppen dann bei 920 erzeugt) Die zur Bilddarstellung aktive Region innerhalb der Zeilen wird durch das Signal active_pixel angezeigt, das mit der aus U1305 und U1304B aufgebauten Statemachine gebildet wird. Der Aufbau dieser Statemachine entspricht der bereits beschriebenen Statemachine für das CSYNC-Signal. Die Statemachine wird dann gesetzt, wenn horizontal die Zeit 12us (177 Pixel) erreicht ist (hor_pix_count = 177 = 12us) und beim Zeilenende (hor_pix_count = 944 = 64us) wieder rückgesetzt. Die zur Bilddarstellung aktiven Zeilen innerhalb des Frames werden durch das Signal active_line angezeigt. Dieses Signal wird mit der aus U1401 und U1402A aufgebauten Statemachine erzeugt. Die Statemachine wird dann gesetzt, wenn die Zeilen 27 oder 340 erreicht werden. (Verknüpfung mit U1213B). Die Statemachine wird dann rückgesetzt, wenn die Zeilen 307 oder 620 erreicht werden (Verknüpfung mit U1213B) Die Signale active_Pixel und active_line werden mit dem Gatter U1111C verknüpft. Die Signallaufzeiten für die zuletzt beschriebene Statemachine (active Line) ist: (Verzögerungszeiten max. über Temperatur, der jeweils größte Wert aus L zu H oder H zu L, Betrachtung des langsamsten Pfades) 74F269 Clk => Q 10,5ns max. 74F154 A..D zu Y 10,5ns max. 74F27 A zu Y 7ns max. 74F32 A zu Y 6,6ns max. 74F151 S => Y 10,5ns 74F74 tsu 3ns Summe 48,1ns max. Man erkennt eine noch ausreichende Reserve von 67,8ns - 48,1ns = 19,7ns.


Seite 3- 28

Die Signallaufzeit für die Statemachine für das Signal active_Pixel ist geringer.

Erzeugung des new-field-Signals Das new_field-Signal geht dann für die Dauer einer Zeile auf H, wenn die Zeilen 312 oder 625 erreicht werden, also in der kommenden Zeile ein neues Halbbild beginnt. Das Signal entsteht durch Verknüpfung im Gatter U1213C. Es hat eine Pipeline-Verzögerung von einem Pixeltakt zum Horizontal-Zählerstand. (Bedingt durch die Steuerung des Vertikal-Zählers vom Horizontal-Zähler aus)

Erzeugung des Transfer-Enable-Signals Das Signal transfer_en ist in der Austastlücke nach dem zweiten Halbbild, also vor Beginn eines neuen Frames, aktiv. Dieses Signal gibt das Nachladen des Textspeichers aus dem FIFO frei. Es wird mit der aus U1404 und U1405A aufgebauten Statemachine erzeugt. Es wird mit dem Erreichen der Zeile 620 gesetzt und mit dem Erreichen der Zeile 26 zurückgesetzt. Es hat eine Pipeline-Verzögerung von 2 Pixeltakten zum Horizontal-Zählerstand.

Erzeugung der horizontalen Leseadresse für den Textspeicher (pointer_char_read [5..0]) Ein Zeichen plus Abstand nimmt horizontal 9 Dots, das sind 18 Pixel, ein. Die horizontale Leseadresse soll ab dem Zeitpunkt 12us = 177 Pixel nach jeweils dem Durchlaufen von 18 Pixeln um Eins hochgezählt werden, um das nächstfolgende Zeichen zu adressieren. Es werden vom Character-ROM jeweils 8 Dots eines Zeichens parallel ausgegeben und ein einem Schieberegister serialisiert, wobei dann das neunte Dot (Teil des Abstandes) automatisch generiert wird. Daher wird keine horizontale Leseadresse für das Character-ROM benötigt. Die Leseadresse pointer_char_read[5..0] wird im Zählerbaustein U1505 hochgezählt. Die Funktion des Zählers wird durch seine Steuereingänge wie folgt bestimmt, wenn, wie es hier der Fall ist, der Eingang U/D fest an H liegt: /PE L load H count up (wenn gleichzeitig /ENT und /ENP auf L) Wenn das #reset-Signal auf L ist, dann wird der Zähler mit Null geladen. (Pixeltakt auch bei Reset durchlaufend, Verknüpfung mit AND-Gatter U1502B) Für die weitere Betrachtung wird davon ausgegangen, das das Signal #reset stets auf H ist. Wenn das Signal hor_pix_count = 944 = 64us (aus Pipeline-Register U 1109) auf L ist, dann wird der Zähler ebenfalls mit Null geladen. Damit wird der Zähler mit dem Ende jeder Zeile auf Null zurückgesetzt.


Seite 3- 29

Wenn das Signal hor_pix_count = 944 = 64us auf L ist, dann zählt der Zähler immer dann um Eins hoch, wenn das Signal #incr_char_pointer_read auf L ist und eine ansteigende Flanke des Pixeltaktes auftritt. Dies ist vor Beginn eines neuen darzustellenden Zeichens der Fall. Das Signal #incr_char_pointer_read wird mit dem Zählerbaustein U1501 erzeugt. Um die Schaltung im Detail zu betrachten wird noch einmal die Wirkungsweise der Steuereingänge des 74F269 beschrieben: Der Eingang U/D ist fest auf L-Pegel, womit dann der Zähler stets abwärts zählt. Ein L-Pegel am Eingang /PE bewirkt das Laden des Zählers (hier mit dem Wert 17) Wenn das Signal active_pixel auf L ist, also der aktive Bereich der Zeile noch nicht erreicht ist, stellt sich am Eingang /PE von U1501 ein L-Pegel ein. Damit wird der Zähler mit dem Wert 17 geladen, der an seinen Eingängen „hardwired“ eingestellt ist. Der Ausgang /RCO des Zählers geht damit auf H. Zu diesem Zeitpunkt ist der Zähler U1505, der die Signale pointer_char_read[5..0] erzeugt, bereits definiert mit dem Erreichen des Endes der vorherigen Zeile zurückgesetzt. Wenn der aktive Bereich der Zeile erreicht ist, dann stellt sich an active_line ein H-Pegel ein. Damit ergibt sich am Ausgang des AND-Gatters U1502A ein H-Pegel (/RCO ist auf H, da Zähler mit 17 geladen), womit sich an /PE ein H-Pegel einstellt. Damit zählt der Zähler (von 17 an beginnend) mit jeder steigenden Flanke des Pixeltakts um Eins nach unten. Beim Erreichen des Wertes Null stellt sich ein L-Pegel am Ausgang /RCO ein. Damit wird der Zähler erneut mit dem Wert 17 geladen. Der RCO-Ausgang steuert direkt das Signal #incr_char_pointer_read. Damit wird dann gleichzeitig die Character-Adresse mittels des Zählers U1505 um Eins erhöht. Erzeugung der vertikalen Leseadresse für das Character-ROM (char_matrix_Y_[3..0]) Ein Zeichen plus Abstand nimmt vertikal 14 Dots, das sind 28 Zeilen pro Ganzbild, ein. Pro Halbbild nimmt das Zeichen dann vertikal 14 Zeilen ein. Aufgrund der Festlegung, das ein Dot aus 2 x 2 Pixeln besteht, wird in beiden Halbbildern ein identisches Videosignal ausgegeben. Das Character-Rom wird vertikal mit den Signalen char_matrix_Y_[3..0] adressiert. Diese Signale stellen den Zählerstand des Zählers U1503 dar. Die mit U1503 aufgebaute Zählschaltung wird nun im Detail beschrieben. Wenn das Signal active_line auf L ist, dann ist gerade noch keine Zeile mit darzustellendem Bildinhalt anstehend. In diesem Fall stellt sich am Ausgang von U1502C ein L-Pegel ein, womit der Zähler mit dem Wert Null geladen wird. Damit wird an char_matrix_Y_[3..0] die Adresse Null ausgegeben. Weiterhin geht auch der Ausgang des Comparators U1504 auf H. Wenn das Signal active_line auf H geht, also der darzustellende Bereich des Halbbildes beginnt, stellt sich am Ausgang des Gatters U1502C ein H-Pegel ein. Wenn nun, am Ende der Zeile, das Signal hor_pix_count = 944 = 64us (für die Zeitdauer eines Pixeltaktes) auf H geht, erhöht sich der Zählerstand von U1503 um Eins. Die tatsächliche Veränderung des Zählerstandes geschieht also dann, wenn gerade die Austastlücke begonnen hat. Sobald der Zählerstand 14 erreicht wird, befindet man sich schon in der obersten Zeile des nächstfolgenden Zeichens. Dies wird zum Zeitpunkt 64us (944 pixel) dieser Zeile mittels des


Seite 3- 30

Comparators U1504 erkannt, da sich zu diesem Zeitpunkt der Zählerstand ändert. Die Eingänge B dieses Comparators liegen „hardwired“ auf dem Wert 14. Mit dem Erkennen von „14“ geht der Ausgang des Comparators auf L, womit auch der Ausgang des Gatters U1502C auf L geht und der Zähler erneut mit Null geladen wird. (Laden hat Priorität vor Zählen) Beim Erreichen des aktiven Bereichs der Zeile ist dann die Adresse „0“ stabil anstehend und es wird die oberste Zeile des zur nächsten Textzeile gehörenden Characters adressiert. Der soeben beschriebene Comparatorausgang steuert auch das Signal #incr_text_line_pointer_read, so das beim Übergang von Matrixzeile 13 auf Matrixzeile Null die nächstfolgende Textzeile aus dem Textspeicher adressiert wird. Das Signal #incr_text_line_pointer_read hat eine Dauer von einem Pixeltakt.

Erzeugung der vertikalen Leseadresse für den Textspeicher (pointer_text_line_read [4..0], mit Scroll-Offset) Die Adresse pointer_text_line_read[4..0] entspricht dem Zählerstand des Zählers U1506. Die grundlegende Version der verwendeten Zählschaltung wurde bereits anhand der Schaltung zur Erzeugung der Adresse pointer_char_read[5..0] beschrieben. Laden Offset bei Pixel 35 von Zeile 27 sowie 340 (vor aktivem Bereich der ersten Zeile des Halbbildes) Der Zähler U1506 wird mit einem gleichzeitigen H-Pegel am Signal set_active_line (Während der Zeilen 27 und 340 auf H) und am Signal hor_pix_count=35=2,35us (Zeitpunkt vor aktiven Bereich der Zeile) über den Tristate-Buffer U1508 mit dem Scroll-Offset geladen. Das bedeutet, das der Zähler zu Beginn jedes Halbbildes auf die Adresse des Textspeichers gesetzt wird, die in der obersten Textzeile des dargestellten Bildes erscheinen soll. Wenn nicht gescrollt wird ist der Scroll-Offset Null und die im Textspeicher unter der Zeilenadresse Null abgelegte Zeile wird als oberste Zeile des Bildes dargestellt. Der Zähler wird mit einem L-Pegel des Signals #incr_text_line_pointer_read um Eins hochgezählt, dieses Signal geht dann für einen Pixeltakt auf L, wenn die erste Matrixzeile einer neuen Textzeile beginnt, mit noch einigem Abstand vor dem aktiven Bereich dieser Zeile. Am Ende der letzten Videozeile zur Darstellung der 19.Textzeile (=vorletzte Textzeile) geht der Zählerstand von 18 auf 19 über. Damit ist zu Beginn der Darstellung der ersten Videozeile der 20.Textzeile (=letzte Textzeile) der Ausgang des Comparators U1507 auf L. Am Ende der letzten Videozeile zur Darstellung dieser Textzeile wird auch das Signal #incr_text_pointer_read L. Damit ist dann auch (für einen Pixeltakt) der Ausgang des OR-Gatters U1511A auf L. Damit wird über U1509 der Wert Null in den Zähler geladen. Kurz darauf beginnt die Darstellung des darauffolgenden Halbbildes und es wird damit der Scroll-Offset in den Zähler geladen, der ebenfalls Null ist. Damit hat dieser Vorgang in dem beschriebenen Fall keine Wirkung. Nun wird der Fall betrachtet, das der Scroll-Offset den Wert Eins hat. Wenn das Signal new_field aktiv wird, dann wird der Zähler mit dem Wert Eins geladen. Damit beginnt die Bilddarstellung mit der Zeile, die im Textspeicher unter der Zeilenadresse Eins abgelegt ist. Mit dem Beginn der Darstellung der vorletzten Textzeile (19. Textzeile) ist bereits der Zählerstand 19 vorhanden. Mit dem Übergang auf die 20. Textzeile wird damit der Wert Null in den Zähler geladen, so das in dieser untersten Textzeile auf dem Bildschirm die Textzeile angezeigt wird, die im Textspeicher an der Zeilenadresse Null abgelegt ist.


Seite 3- 31

Man erkennt weiterhin, das zu Beginn eines neuen Fields bereits wieder der Scroll-Offset im Zähler steht, das nachladen des Scroll-Offsets, solange sich dieser nicht verändert, keine Wirkung hat. Wenn der Scroll-Offset den Wert 2 hat, dann würde das Nullsetzen des Zählers bereits mit dem Beginn der vorletzten Textzeile wirksam. Man erkennt, das das Zählmuster 0,1,2,3..18,19,0,1.. um den Scroll-Offset versetzt abläuft. Das Widerstandsnetzwerk RN1501 verhindert, das sich dann, wenn beide Tristate-Buffer U1508 und U1509 hochohmig sind, undefinierte Pegel an den Eingängen des Zählers aufbauen. Die Ansteuerung des /PE-Steuereingangs von U1506 und des aus U1508 und U1509 gebildeten Multiplexers soll noch im Detail betrachtet werden: Die AND-Gatter U1510B und U1510C bewirken , das bei einem L-Pegel am Signal #reset der Zähler U1506 über den Tristatebaustein U1509 mit dem Wert Null geladen wird. Im Resetzustand sind die Signale hor_pix_count = 35 = 2.35us sowie set_sctive_line auf L, so das die Ausgänge von U1508 definiert hochohmig bleiben. Im Fall des Ladens des Scroll-Offsets ergibt sich ein L-Pegel am Ausgang von U1512A . Damit wird der Multiplexer U1508 durchgeschaltet. Über die Verknüpfung in U1510A wird das Laden des Zählers bewirkt. Der Multiplexer U1509 ist dabei in jedem Fall gesperrt (#reset als H angenommen), da der Ausgang von U1511A nur in direkter Folge des Signals hor_pix_count = 966 =64us (für einen Pixeltakt) auf L sein kann. Das Laden des Scroll-Offsets geschieht dagegen in Folge des Signals hor_pix_count=35=2,35us. Das Laden der Null erfolgt dann, wenn die Bedingungen „#incr_text_line_pointer_read auf L“ und „Ausgang Comparator U1507 auf L“ gleichzeitig auf L sind, bedingt durch die OR-Verknüpfung in U1511A. Erzeugung des Videosignals (Schieberegister) Das vom Zeichensatzspeicher kommende Signal dot[7..0] wird parallel in die Schieberegister U1602 und U1603 geladen und dann seriell aus diesen herausgetaktet. Dot 0 ist dabei der zuerst erscheinende Dot des Zeichens (an der linken Seite des Zeichens) Das Zeichen selbst besteht horizontal aus 5 Dots. Der Abstand zwischen den Zeichen beträgt 4 Dots. Damit ergeben sich 9 Dots, der Zeichensatzspeicher gibt jedoch nur 8 Dots aus. Das letzte Dot wird daher gedoppelt, in dem der Ausgang QA des Schieberegisters U1602 an dessen Eingang zurückgeführt wird. (Mit dieser Methode ist auch die Darstellung größerer grafischer Elemente möglich, wenn man das „vorletzte“ Dot auf hell setzt, dann wird der Abstandsraum zwischen den Zeichen vollständig überbrückt. Die Beschaltung der Schieberegister 74F194 soll nun im Detail beschrieben werden. Die Funktionsauswahleingänge S1 und S0 der Schieberegister werden über den Multiplexer U1601 (74F153) gesteuert. Hierbei gilt die folgende Wahrheitstabelle: U1601 U1601 74F194 74F194 74F194 B A S1 S0 Funktion L L L L hold L H L H Shift right (SR => QA, QA => QB) H L H H parallel load H H H H parallel load


Seite 3- 32

Wenn das Signal load_sr (an U1601/B) auf H ist, dann wird das Schieberegister (unabhängig vom Steuersignal an U1601/A) mit dem Ausgangswert des Zeichensatzspeichers geladen. Wenn das Signal load_sr auf L ist und das Signal shift_sr an U1601/A auf H ist, dann wird der Inhalt der Schieberegister (mit der ansteigenden Flanke des Pixeltakts) um Eins nach rechts geschoben. Da ein Dot aus zwei Pixeln besteht, soll das Schieberegister nur mit jeden zweiten Pixeltakt um Eins weitergeschoben werden. Hierzu wird der Eingang U1601/A (shift_sr) an das (über U1512B) invertierte Signal hor_pix_count_0 gelegt. Das Laden des Schieberegisters wird (mit der entsprechenden Pipeline-Verzögerung) durch das Signal #incr_char_pointer_read veranlasst. Dieses Signal wird jedoch nicht für das erste Zeichen einer Zeile erzeugt. Daher muss dieses Signal gesondert erzeugt werden und es wird mit dem (zuvor negierten) Signal #incr_char_pointer_read mit dem Gatter U1213C verodert. Mit dem Flipflop U1606 / FF6 wird das Signal active_pixel um einen Pixeltakt verzögert. Wenn das Signal active_pixel von L auf H übergeht, dann ist der Eingang D von U1410A auf H, während der mit U1512C invertierte Ausgang Q von U1606 / FF6 noch auf H ist, womit sich am Ausgang des AND-Gatters U1111D ein H-Impuls von der Dauer eines Pixeltakts ergibt. Dieser Impuls wird mit U1607 FF1..FF4 um 4 Pixeltakte verzögert, damit er zum richtigen Zeitpunkt an den Schieberegistern eintrifft.


Seite 3- 33

Erzeugung des Videosignals (Analoge Ausgangsschaltung) Es wird ein dreiwertiges Signal mit den Zuständen „Weiß“, „Schwarz“ und „Sync“ benötig. Deshalb benutzen wir die folgende Schaltung, die im Prinzip einem D/A-Wandler entspricht. Verwendet wird hierbei der Baustein 74ABT125 (U1707A/B). An ihn werden die digitalen Signalausgänge CSYNC_del4 und WEISS angelegt. Ein L-Pegel am Steuereingang eines Gatters des 74ABT125 bewirkt, das der Ausgang aktiv wird und den Pegel am Dateneingang des Bausteins am Ausgang wiedergibt. Bei einem H-Pegel am Steuereingang ist der Ausgang dagegen hochohmig. Mit diesen Gattern wird nun ein steuerbarer Spannungsteiler aufgebaut. Der Zustand WEISS wird mittels des Gatters U1701A nur dann zugelassen, wenn der Zustand SYNC nicht aktiv ist, was im aktiven Bereich des Bildes stets der Fall ist.

Es ist sinnvoll, mit Hilfe des geschalteten Spannungsteilers zunächst ein Videosignal zu erzeugen, daß eine Amplitude von 2Vpp hat und Amplitudenwerte zwischen 1V und 3V hat. Damit kann dann ein mit +5V betriebener Pufferverstärker angesteuert werden. Dieser muß bei Verstärkungen von +1 stabil sein und eine ausreichende Bandbreite haben, wie es beim verwendeten Baustein AD8041 der Fall ist. Das Videosignal wird mit der doppelten Amplitude des am Monitor benötigten Eingangspegels (1Vpp) ausgegeben, da hinter den Verstärkerausgang noch ein 75Ohm-Abschlusswiderstand geschaltet ist. Dieser bildet dann mit dem eingangsseitigen Abschlußwiderstand des Monitors von ebenfalls 75Ohm einen Spannungsteiler, womit sich dann der gewünschte Spannungspegel von 1Vpp ergibt. Die Ausgangsimpedanz des Operationsverstärkers ist idealisiert Null, daher muß der Abschlußwiderstand in Serie zu diesem sein. Die folgende Tabelle illustriert die möglichen Zustände: SYNC WEISS Beschreibung Spannung 0 0 Synchronimpuls 1,0V 0 1 Von Logik

ausgeschlossen

1 0 Schwarz 1,6V 1 1 Weiss 3,0V Im Zustand „weiss“ sind beide Gatterausgänge des 74ABT125 hochohmig. Der Spannungspegel wird dabei von R1701 und R1704 bestimmt. R1704 wird auf 330 Ohm festgelegt, um die Einflüsse von Schaltkapazitäten auf die Bandbreite hinreichend niedrig zu halten. Damit fließt ein Querstrom von 3,0V / 330 R = 9,09 mA durch R1701 und R1704. R1701 ist dann (5V – 3V) / 9,09mA = 220 R Im Zustand „Schwarz“ ist der „obere“ 74ABT125 ausgangsseitig nach Masse durchgeschaltet. Durch R1704 fließt dann ein Strom von 1,6V / 330R = 4,85 mA Durch R1701 fließt dann ein Strom von (5V – 1,6V) / 220R = 15,45 mA. Durch R1702 fließt dann ein Strom von 15,45mA – 4,85mA = 10,6mA R1702 ist dann: 1,6V / 10,6mA = 150 R Im Zustand „Sync“ sind beide 74ABT125 ausgangsseitig nach Masse geschaltet. Durch R1704 fließt dann ein Strom von 1V / 330R = 3,03 mA Durch R1702 fließt dann ein Strom von 1V / 150R = 6,66 mA Durch R1701 fließt dann ein Strom von (5V – 1V) / 220R = 18,18 mA.


Seite 3- 34

Durch R1703 fließt dann ein Strom von 18,18 mA – 3,03mA – 6,77 mA = 8,38mA R1703 ist dann 1V / 8,38mA = 120 R Um eine unsinnige Bilddarstellung während des Ladens des Zeichensatzes zu vermeiden wird das über ein GPIO-Register direkt von der CPU gesteuerte Signal video_en vorgesehen. Ein L-Pegel auf diesem Signal führt zur Darstellung eines schwarzen Bildes, während ein H-Pegel die Darstellung des Bildinhaltes freigibt.


Seite 3- 35

Ausgleich der Laufzeiten Die Laufzeiten der verschiedenen Signalanteile müssen durch Pipeline-Schieberegister an die Laufzeit des langsamsten Signals angepasst werden, damit alle Signalanteile während des gleichen Pixeltakt-Increments an der Ausgangsschaltung eintreffen. Die folgende Skizze stellt die Zeitverhältnisse bezüglich der Bilddarstellung dar:

Decoder

Delay

Delay

par

#incr_pointer_char_read

Delay

Delay

Delay

State-machine

1

OR

Zeichensatz-speicher

Delay

1

Delay

erstmaliges Laden am Zeilenanfang

Delay

1

1

char

active,active_pixel

1

1

Delay

load

Delay

1

1

1

State-machine

Delay

Video

Delay Delay

11

pointer_char_read

Delay

1

1

CSYNC

Unter-setzung

Register

Delay

1

Delay

1

1

1 1

Puls-bildung

1

Decoder

1

Delay

hor_pix_count

1

Textspeicher

1

periodisches Laden bei jedem 18.Pixel

1

Delay

Delay

1

Delay

Das erste Pixel des ersten Zeichens einer Zeile erscheint im 5. Pixeltakt nach dem Beginn des aktiven Pegels der active-Signale am Ausgang des Schieberegisters. Nach jeweils 18 Pixeltakten erscheint das erste Pixel des nachfolgenden Zeichens.


Seite 3- 36

Diese Verhältnisse sind in dem folgenden Impulsdiagramm dargestellt:

134

3530

2

11 16 10

17 396

7

3

15

12

14

3

0

12

17 164

22

9

40

20

2

33

9

8 24

1 17

11

0

28 38

6

7

12

5

15

17

16 41

6

34

active

8

#incr_pointer_char_read del 5

14

4

48 1710

8 5

2720

16 3

16

37

3

7

1

1

2

151

23 36

inital load

1114

11

13

Pixel Clk

9 9 13

8

26

13

110

17 12

18

Zeichen

6

12

12

2

14

#incr_pointer_char_read

18

5

14

3229 3121

7

25

14

16

7 194

15 6

CountU1501 11

10

5

3 18

15

13 155

9

1013


Seite 3- 37

Der Text- und der Zeichensatzspeicher

Allgemeines Für den Text- und den Zeichensatzspeicher werden Dual-Port-RAMs des Typs IDT7134LA20PDG verwendet. Diese Speicher haben eine Zugriffszeit von 20ns und TTL-kompatible Eingänge.

Das Auslesen des Textspeichers Der Textspeicher ist der Baustein U2101. Der Speicher wird von der Seite L her aus dem FIFO heraus beschrieben und von der Seite R her synchron zum Video-Timing ausgelesen. Das Beschreiben des Speichers erfolgt nur in der Austastlücke vor dem Beginn eines neuen Frames. Die Adressierung bezüglich der horizontalen Anordnung der Zeichen erfolgt mit den Signalen pointer_char_read[5..0], deren Erzeugung bereits beschrieben wurde. Diese Signale sind zum Video-Timing synchron. Die Adressierung bezüglich der Textzeilen erfolgt mit den Signalen pointer_text_line_read[4..0], in denen bereits der Scroll-Offset vorhanden ist. Die Erzeugung der Signale pointer_text_line_read[4..0] wurde bereits beschrieben. Diese Signale sind zum Video-Timing synchron. Die Signale text_line_scroll_offset[4..0] werden in der Austastlücke, vor dem Beginn des neuen Frames, aktualisiert. Die Erzeugung der Signale text_line_scroll_offset[4..0] wird in der weiteren Abfolge dieses Dokuments noch beschrieben.

Erzeugung der Signale pointer_text_line_write[5..0] Mit diesen Signalen wird der Textspeicher für das Schreiben im Bezug auf die Textzeile adressiert. An dieser Stelle wird eine synchrone Zählschaltung mit dem Baustein U2502 eingesetzt. Wenn das Steuersignal #res_pointer_text_line_write aktiv ist, dann wird der Zähler mit der nächstfolgenden ansteigenden Flanke des Pixeltaktes mit Null geladen. Wenn das Steuersignal #incr_pointer_text_line_write aktiv ist, dann wird der Zähler mit der nächstfolgenden ansteigenden Flanke des Pixeltaktes um Eins hochgezählt. Beim Erreichen der untersten Textzeile (Zählerstand 19, entspricht der 20-sten Zeile) geht das Signal #last_line auf L. Die Funktion der Schaltung wird im Detail anhand der folgenden Wahrheitstabelle erklärt:

1

U/D#incr

idle

/PE ENT/P

0 11

11

1

3

0

idle

1

12

1

#res

0

1

1

01incr

1

1

0

dec

10

load 0

0


Seite 3- 38

Man erkennt, das der Zähler nur dann zum Hochzählen freigegeben wird, wenn das Signal #incr_pointer_text_line_write aktiv ist und gleichzeitig das Signal #res_pointer_text_line_write inaktiv ist. Ebenso wird der Zähler nur dann zum Laden (= rücksetzen) freigegeben, wenn das Signal #res_pointer_text_line_write aktiv ist und gleichzeitig das Signal #incr_pointer_text_line_write inaktiv ist. Das Signal #last_line wird durch Vergleichen des Zählerstandes mit dem „hardwired“-Wert 19 mit dem Comparator U2503 erzeugt.

Erzeugung der Signale pointer_char_write_[5..0] Mit diesen Signalen wird der Textspeicher für das Schreiben im Bezug auf die Position des zu schreibenden Zeichens innerhalb der Textzeile adressiert. An dieser Stelle wird eine synchrone Zählschaltung mit dem Baustein U2404 eingesetzt. Wenn das Steuersignal #res_pointer_char_write aktiv ist, dann wird der Zähler mit der nächstfolgenden ansteigenden Flanke des Pixeltaktes mit Null geladen. Wenn das Steuersignal #incr_pointer_char_write aktiv ist, dann wird der Zähler mit der nächstfolgenden ansteigenden Flanke des Pixeltaktes um Eins hochgezählt. Wenn das Steuersignal #decr_pointer_char_write aktiv ist, dann wird der Zähler mit der nächstfolgenden ansteigenden Flanke des Pixeltaktes um Eins heruntergezählt. Beim Erreichen der letzten Zeichenposition einer Zeile (Zählerstand 39, entspricht dem 40-sten Zeichen) geht das Signal #last_char auf L. Beim Erreichen der ersten Zeichenposition einer Zeile (Zählerstand 0, entspricht dem 1-sten Zeichen) geht das Signal #first_char auf L. Diese Signale werden mit den Comparatoren U2405 und U2406 erzeugt. Die Funktion der Schaltung wird im Detail anhand der folgenden Wahrheitstabelle erklärt:

2

1

00

1

#incr

01

1

01

#res /PE

0

1

idle

1

decr

U/D

1

1

1

1

1

idle

101

13

7

10

ENT/Pdec

1

0

11

idle1

4 10 1

0

1

0

idle

0idle

0

0

5

1

0

10 incr1

0

6

1

1

1

load 01

11

#decr

1

Die Eingangssignale werden mit dem Decoder U2401 decodiert. Das Enable-Signal wird durch eine Oder-Verknüpfung (in Bezug auf den L-Pegel) zweier Decoderausgänge mit dem AND-Gatter U3219A gebildet, damit wird der Zähler sowohl für das hinauf- als auch für das hinabzählen freigegeben.


Seite 3- 39

Erzeugung der Signale text_line_scroll_offset_[3..0] Mit diesen Signalen wird der für die Scrollfunktion benötigte Offset zwischen Lese- und Schreibadresse generiert. Die Schaltung mit dem Synchronzähler U2602, dem Decoder U2601 und dem Comparator U2603 entspricht der bereits beschriebenen Schaltung für die Signale pointer_text_line_write[5..0]. Wenn das Steuersignal #res_pointer_text_line_offset aktiv ist, dann wird der Zähler mit der nächstfolgenden ansteigenden Flanke des Pixeltaktes mit Null geladen. Wenn das Steuersignal #incr_pointer_text_line_offset aktiv ist, dann wird der Zähler mit der nächstfolgenden ansteigenden Flanke des Pixeltaktes um Eins hochgezählt. Beim Erreichen des maximal möglichsten Offsets (Zählerstand 18, entspricht der 19 Zeilen) geht das Signal #max_offset auf L.

Einblendung von Funktionszeichen Mit dem aus den Tristate-Buffern U2206, U2207 und U2208 gebildeten Multiplexer kann ausgewählt werden, ob der Zeichensatzspeicher mit dem aus dem Textspeicher ausgelesenem Zeichen, dem Leerzeichen (=Blanking) oder dem Cursorzeichen adressiert wird. Wird die Notwendigkeit des Einblenden eines Blanks (von den noch im weiteren Verlauf des Textes beschriebenen Schaltungsteilen) erkannt, dann wird das Signal #display_blank auf L gesetzt. Damit sind die Ausgänge des Bausteins U2208 aktiv, an dessen Eingängen „hardwired“ das SPACE-Zeichen (32d) anliegt. Die Ausgänge der Bausteine U2206 und U2207 sind hochohmig, da im beschriebenen Fall die Signale #display_char_mem_out und #display_Cursor auf H sind. Wenn das Signal #display_cursor auf L ist wird über U2207 das Cursor-Zeichen (220d) durchgeschaltet. Wenn das Signal #display_char_mem_out auf L ist, wird das am Ausgang des Textspeichers anstehende Zeichen durchgeschaltet. Die mit dem Decoder U2209B und dem Gatter U1701B aufgebaute Schaltung stellt sicher, das immer nur eine der drei Auswahlleitungen auf L ist. Wenn die Anforderung „#Cursor“ und „#Blank“ gleichzeitig vorhanden sind, dann wird durch die Wirkung des Gatters U1710B der Cursor angezeigt.

Erzeugung des Cursors Es wird noch gezeigt, das die Signale zur Adressierung des Schreibvorgangs in den Textspeicher (nach Beendigung des Schreibvorgangs in der Austastlücke) immer auf die als nächstes zu beschreibende Zeichenposition zeigen. Dies ist die Position des Cursors. Immer dann, wenn während des Auslesens die Gleichheit der gerade ausgelesenen Zeichenposition mit der für den nächsten Schreibvorgang vorgesehenen Zeichenposition festgestellt wird, muss also das Cursor-Zeichen (Cursor-Block 220d) in den Character-Datenstrom eingeblendet werden.


Seite 3- 40

Durch ein externes Taktsignal von ca. 2Hz kann weiterhin zwischen dem Cursor und dem Blank-Zeichen umgeschaltet werden, womit der Eindruck eines blinkenden Cursors entsteht. Die Erzeugung dieses Signals wird an anderer Stelle dieses Dokuments noch beschrieben. Die Gleichheit der Lese- und Schreibpointer auf Zeichenebene (innerhalb einer Zeile) wird mit dem Comparator U2104 festgestellt. Die Gleichheit der Lese- und Schreibpointer auf Textzeilenebene wird mit dem Comparator U2105 festgestellt. Nur dann, wenn beide Comparatoren Gleichheit erkennen ist auch der Ausgang des OR-Gatters U2108A auf L. Wenn gleichzeitig das Signal cursor_on auf H ist, dann ergibt sich am Ausgang des Gatters U2108C ein L-Pegel, der (über die bereits beschriebene Schaltung mit dem Decoder U2209B) zur Anzeige des Cursor-Signals führt. Wenn dagegen, bei gleichzeitigem L-Pegel am Signal #cursor, das Signal cursor_on auf H ist, dann ergibt sich ein L-Pegel am Ausgang des Gatters U2108B, der zum Anzeigen eines Leerzeichens führt. Es soll nun die Generierung des Steuersignals cursor on beschrieben werden: Wenn das vom Businterface kommende Signal cursor_en auf H ist, blinkt der Cursor mit der durch den mit U2611A aufgebauten Oszillator vorgegebenen Frequenz von ca. 2Hz. Wenn das Signal cursor_en auf L ist, dann ist der Cursor unsichtbar. Die Ausführung des Oszillators als RC-Oszillator erlaubt eine einfache Anpassung der Frequenz an den visuellen Eindruck in tatsächlichen Einsatz. Sowohl das Ausgangssignal des Oszillators auch das vom Businterface kommende Signal cursor_en sind zum Pixeltakt asynchron. Daher wird das verknüpfte Signal am Ausgang von U1701C mit den Flipflops U2610A/B auf den Pixeltakt synchronisiert. Um Fehler durch metastabile Zustände zu vermeiden werden zwei Flipflops kaskadiert.

Blanken von Zeichen Für das Blanken von ganzen Zeilen ist die mit U2201 und U2202A aufgebaute Statemachine vorgesehen. Für das Blanken des „Rests“ einer Zeile nach dem Auftreten einer zum Blanken führenden Bedingung ist die mit U2203 und U2202B aufgebaute Statemachine vorgesehen. Die Ausgangssignale beider Statemachines werden mit dem Gatter U2204A verodert (es handelt sich um low-aktive Signale) Die mit U2210 und U2211A aufgebaute Statemachine speichert das Erkennen der Cursorposition, womit diese Information zu Beginn der kommenden Zeile für den Zweck des zeilenweisen Blankens zur Verfügung steht. Für das Blanken gelten die folgenden Bedingungen: - Die Cursorposition selbst und alle auf diese innerhalb des aktuellen Halbildes folgenden Zeichen

und Zeilen sollen geblankt sein. (ansonsten würden undefinierte Zeichen angezeigt) - Das Cursor-Symbol ist kombinatorisch „stärker“ als das Blanken. - Die Position eines LF-Zeichens und alle darauf folgenden Zeichenpositionen in einer Zeile sollen

geblankt sein. Es wird zunächst das Blanken an und nachfolgend der Cursorposition betrachtet:


Seite 3- 41

Beim Erreichen der Cursorposition (Signal #cursor auf L) wird die mit U2210 und U2211A aufgebaute Statemachine gesetzt. Damit geht das Ausgangssignal der Statemachine, #cursor_reached, auf L. Mit dem Beginn eines neuen Halbbildes wird die Statemachine durch das Signal new_field zurückgesetzt. Wenn die Signale #cursor_reached und #incr_text_line_pointer_read gleichzeitig auf L sind, dann ist der Ausgang des Gatters U2108D, das Signal #start_of_blanked_line auf L. Damit wird die mit U2201 und U2202A aufgebaute Statemachine gesetzt. Damit wird, über die bereits beschriebene, kombinatorische Logik mit U2204A, U2209B und U1701B die Ausgabe von Leerzeichen an den Zeichensatzspeicher bewirkt, also das Blanken der entsprechenden Zeichenpositionen. Mit dem Beginn eines neuen Halbbildes wird auch diese Statemachine durch das Signal new_field zurückgesetzt. Bei Erkennen eines LF-Zeichens mit dem Comparator U2107 (Signal #char=LF auf L) oder dem Erkennen der Cursor-Position (Signal #cursor auf L) geht der Ausgang des Gatters U2204B (Signal #char=LF_or_#cursor) auf L. Wenn das Signal #char=LF_or_#cursor auf L ist wird die mit U2203 und U2202B aufgebaute Statemachine gesetzt, wenn eine der folgenden zeitlichen Bedingungen vorhanden ist: - Das differenzierte active_pixel-Signal ist aktiv, dies ist im ersten Pixeltaktincrement nach dem

Ansteigen des active-Signals der Fall (Abfrage auf Blanking für das erste Zeichen einer Zeile) - Das Signal #incr_char_pointer_read_del2 ist aktiv (Das Folgezeichen liegt am Ausgang des

Textspeichers an, Abfrage für alle Zeichen einer Zeile ausser dem ersten Zeichen) Damit geht das Ausgangssignal der Statemachine auf L, womit dann über U2204A und die folgenden Bausteine das Blanking bewirkt wird. Mit dem Beginn einer neuen Videozeile wird die Statemachine durch das Signal #hor_pix_count=944 unreg zurückgesetzt.

Steuerung des Schreibens in den Textspeicher Die von der CPU kommenden Zeichen werden von dieser in ein FIFO (U3101) geschrieben. Der Inhalt dieses FIFOs wird in der Austastlücke (vor einem neuen Frame) in den Textspeicher übertragen. Hierbei wird zwischen den darstellbaren Zeichen und den Steuerzeichen unterschieden. Die Wirkung der Steuerzeichen wird im Folgenden beschrieben. Der Umfang der Steuerzeichen und die Komplexität ihrer Wirkung wurde gegenüber tatsächlich existierenden historischen Terminals stark reduziert, auf das unbedingt Notwendige reduziert. Das verlagert einen Teil des Aufwands, erlaubt es aber auch die Video-Karte mit einfachen TTL-Bausteinen im gegebenen Zeitrahmen aufzubauen. (Im VT-100 werden die Funktionen der Steuerzeichen mit einem 8080-Microprozessor implementiert) Steuerzeichen LF: Dieses Zeichen wird im Textspeicher abgelegt (um das Blanken des undefinierten auf LF folgenden Teils der Textzeile zu steuern). Es bewirkt weiterhin, das der Schreibpointer zum Anfang der Folgezeile springt. Das dann folgende Zeichen wird also an die erste Position der Folgezeile geschrieben. Steuerzeichen CLS: Dieses Zeichen wird nicht im Textspeicher abgelegt. Es bewirkt, das der Schreibpointer auf das erste Zeichen der obersten Textzeile gesetzt wird. Das dann folgende Zeichen wird also in der ersten Zeichenposition der obersten Zeile abgespeichert.


Seite 3- 42

Aufgrund der bereits beschriebenen Blanking-Steuerung erscheint bis zum Schreiben des ersten Zeichens ein leerer Bildschirm mit dem Cursor an der ersten Zeichenposition der obersten Zeile. Steuerzeichen BS: Dieses Zeichen wird nicht im Textspeicher abgelegt. Es bewirkt, das der Schreibpointer um eine Zeichenposition zurückgesetzt wird, wenn er sich nicht schon auf der ersten Zeichenposition der Zeile befindet. (Ein Zurückgehen über die Zeilengrenzen hinweg ist bewusst ausgeschlossen) Diese Funktionen werden mit einer Statemachine implementiert. Man kann alle benötigten Abläufe als linearen Ablauf der 6 Zustände S0 bis S5 implementieren. In einigen Abläufen geschieht dann in einigen Zuständen „nichts“, sie werden „leer“ durchlaufen. Dies stört aber nicht, da diese Abläufe nur selten vorkommen und da ohnehin ausreichend Zeit in der Austastlücke vorhanden ist, um die Zeichen aus dem FIFO in den Textspeicher zu übertragen. Das folgende Impulsdiagramm visualiert diese Vorgehensweise:

#FIFO_read = S0 + S5

wenn #normal = 0+ #LF = 0

#RAM_we

Daten aus FIFO

Scroll-Flag

AND hinter Decoder

S4

Set-Signal fürScroll-Flag

ein State kann mehrere Taktzyklen dauern.

S5

#FIFO_read

S3

Das Scroll-Flag wird bereist in S4 ausgewertet

S2S1S0 (idle)

Zeichen-Kategorienaus Comparator

/#RAM_we = S2 * (#normal + #LF)

SteuersignalefürPointer/Offset/Scroll

Normalerweise befindet sich die Statemachine im Zustand S0, in dem alle ihre Ausgangssignale den inaktiven Zustand einnehmen, es wird also nicht aus dem FIFO gelesen und nicht in den Textspeicher geschrieben. Wenn das Signal transfer_en, das die Austastlücke vor Beginn eines neuen Frames anzeigt und das Signal #FIFO_EF (dessen H-Pegel anzeigt, das Daten im FIFO „abholbereit“ sind) gleichzeitig auf H sind, dann sollen Daten vom FIFO in den Textspeicher übertragen werden. Dazu geht die Statemachine dann in den Zustand S1 über. Im Zustand S1 blockiert die Statemachine die weitere Wirkung der Signale #FIFO_EF und transfer_EN, um sicherzustellen, das der aktuelle Lese-Schreib-Zyklus auch dann vollständig zuende geführt wird, wenn eine der auslösenden Bedingungen entfällt. (das ist beim Auslesen der letzen Speicherstelle im FIFO oder beim Beenden der Austastlücke durch das Video-Timing der Fall, im zweiten Fall entsteht keine gestörte Anzeige, weil das Beenden des Zyklusses wesentlich weniger Zeit als die noch geblankte Schwarzschulter des Videosignals benötigt)


Seite 3- 43

Weiterhin wird das FIFO ausgelesen, womit das im FIFO stehende Zeichen an den Comparatoren für die Erkennung von Steuerzeichen und am Dateneingang des Textspeichers anliegt. Zum Ende des Zustandes S1, der drei Pixeltakte andauert, stehen die aus den möglicherweise erkannten Steuerzeichen abgeleiteten Auswahlsignale für die in den nachfolgenden Zyklen auszuführenden Aktionen an. Der Zustand S1 geht in den Zustand S2 über. Wenn im Zustand S1 erkannt wurde, das es sich um ein Zeichen handelt, das im Textspeicher gespeichert werden soll (darstellbares Zeichen oder LF), dann geht das Schreibsignal für den Textspeicher in diesem Zustand auf L. Weiterhin wird im Zustand S2 der Übergang in den Scroll-Modus erkannt und die das Scroll-Flag steuernde Statemachine in diesem Fall gesetzt. Der Zustand S2 geht in den Zustand S3 über. Wenn im Zustand S2 ein Zeichen in den Textspeicher gespeichert werden sollte, dann wird im Zustand S3 das Schreibsignal für den Textspeicher wieder auf H gesetzt, womit das tatsächliche Speichern ausgelöst wird. Der Zustand S3 geht in den Zustand S4 über. Im Zustand S4 werden die Steuersignale für die Adresspointer (Zeichenposition, Textzeile, Scroll-Offset) in Abhängigkeit vom in S1 erkannten Zeichen ausgegeben. Der Zustand S4 geht in den Zustand S5 über. Im Zustand S5 werden die in Zustand S4 aktivierten Steuersignale wieder in den Ruhezustand versetzt. Ebenso wird das Lesesignal für das FIFO wieder in den inaktiven Zustand gesetzt. Der Zustand S5 geht in den Zustand S0 über. Damit erfolgt eine erneute Abfrage der Signale #FIFO_EF und transfer_en. In der Folge wird ein neuer Transfer durch den Übergang in S1 eingeleitet oder die Statemachine verbleibt im Ruhezustand S0. Durch den Systemreset wird die Statemachine in den Zustand S0 gebracht (Verknüpfung U3206C). Nun soll die Funktion der Steuersignale in Abhängigkeit von den erkannten Zeichentypen genauer beschrieben werden. Um dies zu vereinfachen wird das Signal #char=normal vorgesehen, das bei allen Zeichen außer LF,BS und CLS aktiv ist. Zunächst wird das Setzen des Scroll-Flags beschrieben, das im Zustand S2 geschieht: Set_scroll: Erkennen der Notwendigkeit des Scrollens (überlauf des Bildschrims) aktiv wenn: last_line

Die folgende Beschreibung aller anderen Funktionen bezieht sich auf den Zustand S4. In allen anderen Zuständen sind diese Signale inaktiv. #incr_pointer_char_write: Weitergehen zur nächsten Zeichenposition. aktiv wenn char = normal und /last_char Das in diesem Zyklus ausgelesene und abgespeicherte Zeichen ist ein normales Zeichen und es ist noch nicht die letzte Zeichenposition in der Zeile erreicht.


Seite 3- 44

#res_pointer_char_write: Springe zur ersten Zeichenposition am Anfang der Zeile. aktiv wenn char = normal und last_Char oder char = LF oder char = CLS Das in diesem Zyklus ausgelesene und abgespeicherte Zeichen ist ein normales Zeichen und es ist die letzte Zeichenposition in der Zeile erreicht. oder Das in diesem Zyklus ausgelesene Zeichen ist LF oder CLS #decr_pointer_char_write: Gehe um eine Zeichenposition zurück. aktiv wenn char = BS und /first_char Das in diesem Zyklus ausgelesene Zeichen ist BS und man befindet sich nach er ersten Zeichenposition der Zeile (Im Fall, das man sich auf der ersten Zeichenposition der Zeile befindet soll keine Aktion erfolgen.) #incr_pointer_text_line_write: Gehe um eine Zeile nach unten. aktiv wenn char = normal und last_char oder char = LF Es wurde ein „normales“ Zeichen in die letzte Zeichenposition einer Zeile geschrieben, die nicht die unterste (=letzte) Zeile ist. oder Es wurde das Zeichen LF erkannt und in eine beliebige Zeichenposition geschrieben, die Zeile ist nicht die unterste (letzte) Zeile. #res_pointer_text_line_write: Gehe zur obersten (=ersten) Zeile. aktiv wenn char = normal und last_line und last_char oder char = LF und last_line oder char = CLS Es wurde ein „normales“ Zeichen in die letzte Zeichenposition der letzten Zeile geschrieben.


Seite 3- 45

oder Es wurde das Zeichen LF erkannt und in eine beliebige Zeichenposition der letzten Zeile geschrieben. oder Es wurde das Zeichen CLS erkannt.


Seite 3- 46

res_scroll: Rücksetzen des Scroll-Modus char = CLS #incr_pointer_text_line_offset: Beginne das Auslesen des Textspeichers um eine Textzeile tiefer. aktiv wenn #max_offs und scrollen aktiv und (

char = normal * last_char *

oder char = LF *

Es wurde ein „normales“ Zeichen in die letzte Zeichenposition einer Zeile geschrieben, das Scroll-Flag wurde gesetzt und der maximale Scroll-Offset wurde noch nicht erreicht. Es wurde ein „LF Zeichen erkannt während das Scroll-Flag gesetzt ist und der maximale Scroll-Offset wurde noch nicht erreicht. #res_pointer_text_line_offset: Beginne das Auslesen des Textspeichers an der obersten Textzeile. aktiv wenn max_offs und (

char = normal * last_char *

oder char = LF *

oder

char = CLS


Seite 3- 47

Nun soll die Schaltung im Detail betrachtet werden: Der Baustein U3101 ist der FIFO mit einer Kapazität von 4096 Byte (die weit über dem an dieser Stelle Benötigten liegt) Mit den Bausteinen U3102A/B und U3103A/B wird erreicht, das die besonderen Bedingungen für das Resetten des FIFOs eingehalten werden. Die Signale /W und /R müssen während des Resettens und noch eine definierte Zeit nach dem Resetten auf H sein. (Ist dies nicht der Fall, ist die Initialisierung der Pointer des FIFOS nicht eindeutig gesichert) Wenn das Signal #reset auf L ist, dann ist der Ausgang /Q des Flipflops U3102B auf H, womit dann auch über die Gatter U3103A und U3103B die Signale /W und /R des FIFOs auf H sein. Wenn das Signal #reset auf H geht, dann geht mit der dann folgenden ansteigenden Flanke des Pixeltaktes der Ausgang Q des Flipflops U3102A auf H. Mit der dann weiter folgenden Flanke des Pixeltaktes geht der Ausgang /Q des Flipflops U3102B auf L, womit dann über die Gatter U3103A/B die Möglichkeit freigeschaltet wird, das die Signale /W und /R auf L gesteuert werden können. Die Beschaltung der Steuereingänge /XI und /FL/RT erfolgte nach den Angaben im Datenblatt für die einfachste, unkaskadierte Anwendung des Bausteins. Mit den Comparatoren U32303, U3204 und U3205 werden die Steuerzeichen LF, CLS und BS erkannt. Hierbei werden die aus dem FIFO ausgelesenen Zeichen mit den folgenden „hardwired“ Mustern verglichen: LF (Line-Feed) 10d CLS (Clear Screen) = FF (Form Feed) = 12d BS (Backspace) = 8d Beim Erkennen eines der genannten Steuerzeichen geht der Ausgang des entsprechenden Comparators auf L. Um die Auslegung der Steuerlogik zu vereinfachen wird mit dem NAND-Gatter U1219B das Signal #char=normal generiert, das immer dann auf L ist, wenn das anliegende Zeichen weder LF, CLS oder BS ist. Mit dem Synchronzähler U3201 werden die Zustände S0 bis S5 der Statemachine für die Steuerung des Schreibens in den Textspeicher hochgezählt. Der Zustand S1 nimmt hierbei drei Taktperioden ein. Der Zähler wird mit dem Pixeltakt getaktet. Damit ergibt sich der Vorteil, nur einen einzigen Takt im System zu haben (Ausnahme: der über das genau dafür konstruierte FIFO sicher abgetrennte asynchrone Buszugriff der CPU) Ausserhalb der für den Transfer vom FIFO zum Textspeicher vorgesehenen Austastlücke ist das Signal transfer_en auf L. Das Signal #FIFO_EF ist dann auf L, wenn keine noch zu übertragenden Daten mehr im FIFO stehen. In den beiden genannten Fällen ist der Ausgang des Gatters U3206A auf L. Es wird weiter angenommen, die Statemachine befinde sich im Ruhezustand S0. (Die Begründung für diese Annahme wird noch gegeben) Dann ist das Signal #S0 auf L, womit auch am Ausgang des Gatters U3103C ein L-Pegel ansteht. Damit ergibt sich auch (unabhängig vom Pegel am Signal #S5) ein L-Pegel am Ausgang des Gatters U3206B. Damit liegt auch an dem Eingängen /PE des Zählers U3201 ein L-Pegel an. Damit wird der Zähler bei der nächstfolgenden ansteigenden Flanke des Pixeltakts mit dem „hardwired“ an seinen Eingängen anliegende Wert Null geladen. Dies entspricht dem Zustand S0, das Ausgangssignal #S0 des den Zählerstand decodierenden Decoders U3202 ist damit auf L, womit die eingangs gemachte Annahme begründet ist. Man erkennt, das dieser Zustand stabil ist und so lange anhält, bis sich durch die Gleichzeitigkeit eines H-Pegels an den Signalen #FIFO_EF und transfer_en („Zeichen vorhanden“ und gleichzeitig „Austastlücke“) ein H-Pegel am Ausgang des Gatters U3206A ergibt, der auch am Ausgang von U3103C ansteht. Da der Zähler den Zählerstand Null hat, ist das Signal #S5 auf H, womit sich auch am Ausgang von U3206B ein H-Pegel einstellt. Damit liegt am den Eingang /PE des Zählers U3201 ein


Seite 3- 48

H-Pegel an. Damit zählt der Zähler bei der nächstfolgenden ansteigenden Flanke des Pixeltakts um Eins hoch. Damit geht das Signal #S0 auf H. Durch das sich Einstellen eines L-Pegels an den Signalen #FIFO_EF (Letztes Zeichen wurde gelesen) oder transfer_en (Austastlücke vorbei) wird der Pegel am Ausgang von U3103C nicht mehr beeinflusst, der H-Pegel bleibt anstehend, womit der begonnene Transfer-Zyklus abgeschlossen wird. (Ausreichend Zeitreserve zum Beginn der aktiven Region der ersten Zeile ist vorhanden) Mit jeder ansteigenden Flanke des Pixeltaktes zählt der Zähler um Eins hoch. Nach 7 Takten ist der Zustand S5 erreicht, das Signal #S5 geht auf L. Damit wird, unabhängig von den Signalen #FIFO_EF und transfer_en ein L-Pegel am Ausgang von U3206B erzwungen. Damit wird der Zähler mit der dann folgenden ansteigenden Flanke des Pixeltaktes wieder mit dem Wert Null geladen. Damit stellt sich erneut ein L-Pegel am Signal #S0 ein, womit dann der Pegel am Ausgang des Gatters U3206A (Gleichzeitigkeit von Austastlücke und Vorhandensein eines zu übertragenden Zeichens) darüber entscheidet, ob die Statemachine im Ruhezustand S0 verbleibt oder einen neuen Transferzyklus beginnt. Ein Transfer-Zyklus dauert 8 * 67,8ns = 0,542us. In einer Video-Zeile können daher 118 Zeichen übertragen werden. Die Austastlücke dauert 32 Zeilen. Damit können in der Austastlücke 3775 Zeichen übertragen werden. Der Inhalt des Bildschirms beträgt 20 x 40 Zeichen, das sind 800 Zeichen. Man erkennt eine erhebliche Reserve. Der Zustand S1 dauert 3 Taktyklen an, womit die Laufzeiten der kombinatorischen Logik zur Erkennung der Steuerzeichen berücksichtigt wird. Mit dem Gatter U2314C wird erreicht, das das Signal #FIFO_read in den Zuständen S1,S2,S3 und S4 auf L ist. Mit den Gattern U3214A und U4314B wird das Schreibsignal für den Textspeicher erzeugt. Das Signal #ram_we ist im Zustand S2 aktiv, wenn entweder ein „normales“ Zeichen oder ein LF-Zeichen anliegend ist. Die Schaltungen zur Erzeugung der weiteren Steuersignale sind eine direkte Umsetzung der bereits im vorstehenden Text dargestellten Verknüpfungen. Die Statemachine zur Generierung des Scroll-Flags ist mit den Bausteinen U3220 und U3221A aufgebaut. Das Funktionsprinzip dieser Schaltung wird mit der folgenden Tabelle gezeigt: set_scroll res_scroll dezimal Eingang MUX Funktion L L 0 Q halten L H 1 L rücksetzen H L 2 H setzen H H 3 L rücksetzen Es sollen nun die Laufzeiten genauer betrachtet werden. Die Zugriffszeit des FIFOS IDT7204L12TPG ist 12ns Die Zugriffszeit des Textspeichers 7134LA20PDG ist 20ns. Die Taktzeit der Statemachine ist 67,8ns, so das an dieser Stelle Zeitreserven bestehen. Es soll nun die Laufzeit vom Übergang zu S1 bis zum Anstehen des Signals #char=normal ermittelt werden:


Seite 3- 49

(max.-Werte über Temperatur) U3201 74F269 clk => Q 10,5ns U3202 74F138 A..C => Y 9ns U3214C 74F00 A..Y 6ns U3101 7204L12 /R => Q 12ns U3203..5 74F521 A/B => A=B 11ns U1219B 74F20 A => Y 6ns Summe: 54,5ns Es soll nun die Laufzeit vom Übergang auf S2 bis zum Signal #ram_we ermittelt werden: (Der Ausgang von U3214B ist zum Ende von S1 schon stabil) U3201 74F269 clk => Q 10,5ns U3202 74F138 A..C => Y 9ns U3214A 74F00 A => Y 6ns Summe: 25,5ns Es soll nun die Laufzeit vom Übergang zu S1 bis zum Anstehen der Steuersignale (bis auf die Bedingung S4) ermittelt werden. Der Pfad von #char=normal zu #incr_pointer_text_line_offset ist hierbei der längste Pfad. (max.-Werte über Temperatur) U3201 74F269 clk => Q 10,5ns U3202 74F138 A..C => Y 9ns U3214C 74F00 A..Y 6ns U3101 7204L12 /R => Q 12ns U3203..5 74F521 A/B => A=B 11ns U1219B 74F20 A => Y 6ns U3215A 74F27 A => Y 7ns U3217A 74F32 A => Y 6,6ns U3216B 74F27 A => Y 7ns U3208F 74F04 A => Y 6ns U3218A 74F08 A => Y 6,6ns U3219A 74F00 A => Y 6ns Summe: 93,7ns Damit besteht eine Reserve von 3 x 67,8ns – 93,7ns = 203,4ns – 93,7ns = 109,7ns. Würde man S1 auf zwei Taktzyklen verkürzen bestünde noch eine Reserve von 41ns. Angesichts der in der Summe recht großen Kapazitäten der vielen hintereinandergeschalteten Verbindungsleitungen in dem recht langen Pfad wird jedoch die ursprünglich geplante Dauer von S1 von drei Taktperioden beibehalten, insbesondere auch, da die zur Verfügung stehende Zeit für den Transfer mehr als ausreichend ist. Bei der Inbetriebnahme der Schaltung zeigte sich eine sehr hohe Stromaufnahme des Textspeichers U2101 (CMOS), wenn die FIFO-Ausgänge hochohmig waren. Es stellte sich ein Pegel von ungefähr 2V


Seite 3- 50

an den Datenleitungen ein (Strom aus den Eingängen der Comparatoren U3203..U3205). Es wurde ein Pull-Up-Widerstandsnetzwerk 8X10kOhm an die FIFO-Ausgänge angebracht, um den Pegel bei offenem Bus auf ca. 5V zu bringen. Damit ging die Stromaufnahme auf normale Werte zurück.


Seite 3- 51

Das Businterface Mit dem Businterface werden die folgenden Funktionen ausgeführt. 1. Schreiben von Zeichen in das FIFO 2. Auslesen des Full-Flags des FIFOs 3. Aktivieren / Deaktivieren der Cursordarstellung 4. Laden des Zeichensatzes 5. Auswahl des Zeichensatzes (für Laden und Darstellen, es sind zwei Zeichensätze möglich) Das Businterface weist keine Besonderheiten auf, es entspricht weitgehend dem bereits realisierten Businterface der Karte SP2-001 MEM_IO. Mit den Comparatoren U5201 und U5202 wird zunächst der Adressbereich FF FF 00 00 .. FF FF FF FF ausgewählt. Mit dem Comparator U5203 wird weiterhin der Adressbereich FF FF FF E0. .FF FF FF FF ausgewählt, aus diesem nach weiterer Decodierung mit den Decodern U5205 und U5206 die Chipselectsignale für den I/O-Port und das FIFO abgeleitet werden: FF FF FF EC Parallelport (Lesen und Schreiben)

Lesen: Bit 0 #FIFO_FF (L wenn FIFO voll, H wenn noch Platz im FIFO)

Schreiben: Bit 0 cursor_en (L = Cursor aus / H = Cursor

sichtbar)

Bit 1 video_en (L = Blanking / H = Bilddarstellung)

Mit dem Comparator U5207 wird der Adressbereich FF FF 8 xx .. FF FF B xx für das Laden des Zeichensatzes in den Zeichensatzspeicher decodiert.


Seite 3- 52

Die Erzeugung des Pixeltaktes Der Pixeltakt wird mit dem Oszillator U4901 erzeugt und durchläuft dann den aus U1502D, U1510D und U1511C aufgebauten Multiplexer. Das Ausgangssignal des Multiplexers wird mit dem Buffer U4902 verstärkt und auf drei Taktsignale verteilt. Der Multiplexer ermöglicht es, das Signal clk_test anstelle des vom Oszillator erzeugten Taktes in die Schaltung einzuspeisen. Dieses Signal wird auf dem Testadapter als prellfrei manuell getriggerte Einzelpulse zur Verfügung gestellt. Im Normalbetrieb ist der Eingang #sel_clk_test offen, da der entsprechende Pin am Busstecker auf der Backplane nicht beschaltet ist. Damit stellt sich durch den Pull-up-Widerstand R4904 ein H-Pegel am Eingang des Inverters U2611B ein. Damit ist dann der Oszillator auf den Takttreiber durchgeschaltet. Wenn ein Einzelschrittbetrieb gewünscht wird, dann wird das Signal auf dem Testadapter an Masse gelegt. Die Multiplexerschaltung wurde mit noch freien Gattern realisiert.


Seite 3- 53

Dokumentation der Betrachtung des Timings der Video -Karte (28.6.2016 Lukas Hey) Der folgende Text beschreibt das Timing der Videokarte an den wichtigsten Stellen und dient als Orientierung für den Signalverlauf und zum Nachvollziehen der Pipeline. Diese Diagramme sin in der diesem Bericht anliegenden Datei „Impulsdiagramme-VideoKarte-SP2.pdf“in voller Auflösung dargestellt.

Diagramm 1 & 2: Fifo-Schreibvorgang mit erstmaligem Offset

Randbedingungen:

• Wechsel vom Zweiten zum ersten Halbbild • Daten werden vom Fifo in den Textspeicher übertragen. Das aktuell übertragene Zeichen sei

kein Steuerzeichen. • Die vorletzte Zeile (18) das letzte Zeichen (39) wird gerade das erste Mal beschrieben, folglich

wurde noch nicht gescrollt. Das darauf folgende Zeichen sei ein „LF“


Seite 3- 54

Der Schreibvorgang eines Zeichens vom Fifo in den Textspeicher dauert genau acht Takte. Die kritische Stelle des eigentlichen Schreibvorgangs in pxl-Takt 940, S2, ist zeitlich mit mehr als genügend Rahmen zu beiden Richtungen gedeckt. Auf S4 reagieren alle entsprechenden pointer-Steuersignale, die in S5 wirksam werden und den Schreibvorgang damit abschließen. Pointer-Zustände wie u.a. #last_line reagieren ebenfalls noch in S5; mit S0 kann also der nächste Schreibvorgang gültig begonnen werden. Da der pointer_text_line_write nun auf Maximalwert 19 steht, zeigt #last_line an, dass beim nächsten Inkrement dieses Pointers der Offset erhöht werden muss. Das Scrollflag, welches dafür benötigt wird, bedingt #last_line und einen weiteren Schreibvorgang. Der nächste Schreibvorgang löst also die Scrollfähigkeit überhaupt erst aus. Diagramm 2 zeigt, neben dem eigentlichen Bildübergang, den Sonderfall, dass ein „LF“ zu Beginn der letzten Zeile, also als erstes Zeichen eingetragen wird. Er unterscheidet sich in der Notwenigkeit, dass hier bereits in S5 nicht nur das Scroll-Flag zu setzten ist und den Zeilenvektor zu reseten wäre, sondern auch den Offsetvektor zu erhöhen ist. Deshalb muss das dafür notwendige Scroll-Flag bereits in S2 gesetzt werden und nicht wie alle anderen betroffenen Steuersignale in S5. Nur so ist es rechtzeitig gültig, was erkennbar ist in pxl-Takt Vier bis Sechs. Jedes andere Zeichen löst noch keine Erhöhung des Offsetvektors aus, sorgt aber durch das Aufrufen des States S2 automatisch ebenfalls dafür, dass das Scrollflag für den nächsten Inkrement in jedem Falle bereits gesetzt wurde (was dann natürlich auch in S5 möglich wäre). Alle anderen Schreibvorgänge zeigen sich als weniger zeitkritisch, da sie sich inhaltlich nicht mehr unterscheiden.


Seite 3- 55


Seite 3- 56

Diagramm 3: Ende des Schreibvorganges


Seite 3- 57

Randbedingungen: • Wechsel vom erlaubten Übertragungsbereich in den Bildbereich, Zeilenwechsel 25/26 • Daten werden vom Fifo letztmöglich in den Textspeicher übertragen. Das aktuell übertragene

Zeichen sei kein Steuerzeichen • Die vorletzte Zeile (18) das letzte Zeichen (39) wird beschrieben. Der Offset beträgt 19 und

läuft somit beim nächsten Zeichen über. Der Datentransfer vom FIFO in den Textspeicher ist nur in den geblankten Zeilen 620 bis 25 möglich und wird durch transfer_en direkt gesteuert. Das verlassen von S0 ist ohne transfer en nicht möglich, wohl aber werden alle angefangen Übertragungen beendet. Dies ist absolut unkritisch, da bereits eine ganze Zeile vor dem Bildbereich die Übertragung beendet ist, nämlich im ” schlimmsten “Falle in pxl-Takt 9 der Zeile 26, wie zu erkennen ist. Es ergibt sich somit ein Maximalfenster von 28329 Pixeln, und somit etwa 3541 Chars, was 4,4 Bildern pro Bildwechsel entspricht. Der Überlauf des Offsets und somit das Zurücksetzten des Offsets wird von #max_offset ausgelöst, sowie alle anderen Steuersignale auch. Der Vorgang ist aufgrund der frühzeitigen Beendigung aller Fifo-¨Ubertragungen unkritisch. Geladen wird der Offsetwert erst in Zeile 27 durch set_active_line und Pixel 35.

Diagramm 4: Beginn des aktiven Bildbereiches Siehe Folgeseite


Seite 3- 58


Seite 3- 59

Randbedingungen: • Wechsel in den aktiven Zeilenbereich ab Zeile 27 • Im Speicher an der Stelle [2:0] (Zeile 2, Spalte 0) befinndet sich ein „T“, an der Stelle [0:0] sei

ein „S“. • Es wurde bereits gescrollt, der Offset beträgt 2, der erste dargestellte Buchstabe auf dem

Bildschirm wird also das „T“ in [2:0] sein. Es muss sichergestellt werden, dass alle CSYNC Pulse und die Bildinformationen ohne zeitlichen Versatz zueinander zur Videoendstufe gelangen. Durch die Laufzeiten und besonders durch die kaskadierten Speicher ist die Verzögerung vom Zählwerk zur Endstufe nicht unerheblich und muss kompensiert werden. Im Wesentlichen stellt active_video_del5 diese Kompensation zum Beginn des aktiven Bereichs dar, da dieser den Video-Ausgang steuert (s. pxl 207). Insgesamt ist somit eine Verzögerung vom auslösenden Pixel-Count 201 zum tatsächlich ausgegebenen Zeitpunkt 207 eine Verzögerung von 6 Takten. Da active_pixel von den unreg Signalen ausgelöst wird, CSYNC sich aber aus registerten Signale bildet, muss der beim Video resultierende CSYNC um nur 4 Takte verzögert werden, um in gleicher zeitlicher Lage mit dem Bildinhalt zu sein. Die Verzögerungskette beim CSYNC setzt sich also zusammen aus: Stufe gültig in Takt auslösender Pixel 0 Register 1 Sync SM 2 Verzögerung 4 Takte 6 Beim Bildinhalt: Stufe gültig in Takt auslösender Pixel 0 active_pixel SM 1 active_video 1 active pixel del4 5 active video del5 6 Hierbei ist auch active_pixel entscheidend, welches im gleichen Takt wie active_viedo gesetzt wird (welches ja active_pixel bedingt!). Active_pixel lädt 5 Takte nach dem auslösenden Pixel-count das erste Dot des ersten Zeichens der Zeile in das Shift-Register. Die Untersetzung von zwei Pixeln auf ein Dot geschieht über den hor_pix_count=0, welcher ja gerade mit halbem Pixeltakt toggelt. Entscheidend hierbei ist, dass in Takt 207, also dem ersten Dot auf 1 steht, wodurch die Shiftregister in diesem Takt auf hold stehen. Takt 208 ist dann der Wechsel auf 0, wodurch in Takt 209 wiederum geshiftet wird. (Takt 210 wird wieder gehalten usw.) Wichtig zu beachten ist, dass die Auswahl der Sync-Pattern P0-P5 zwar prinzipiell auch zur Kette des CSYNC dazugehört, hier aber keine Beachtung finden muss. Grund hierfür ist, dass das Resetten der CSYNC-Statemachine zum Zeilenbeginn immer unabhängig vom aktuellen Pattern stattfinden kann, da dies bei jedem Pattern der Fall ist. Für alle weiteren Änderungen, die auch abhängig von P0-P5 sind, sind diese Werte schon längst gültig. Ab Takt 2 liegt gültiges ein P* an, welches frühestens in Takt 35 gebraucht wird; P ändert sich nur mit viedo_line_count. Es zeigt sich also, dass sowohl CSYNC als auch Bildinhalt eine Verzögerung von 6 Takten zu ihrer Ursache haben und somit zeitgleich bleiben. Das Laden des korrekten Zeichens aus dem Textspeicher ist zu Beginn der Zeile unkritisch. Der Offset wird in Takt 35 geladen und das erste angezeigte Zeichen liegt rechtzeitig am Shiftregister an.

Diagramm 5: Zeichenwechsel beim Auslesen Siehe Folgeseite


Seite 3- 60


Seite 3- 61

Randbedingungen • Wechsel eines Zeichens während der Ausgabe zu Beginn von Zeile 27, Fortsetzung aus

Diagramm 4 • Im Speicher an der Stelle [2:0] (Zeile 2, Spalte 0) befindet sich ein „T“, an der Stelle [2:1] sei ein

„I“. Der Wechsel eines Zeichens wird durch die Untersetzung der Character-Breite ausgelöst. Das Signal #incr_pointer_char_read ist der RCO dieses Counters, der rückwärts von 17 aus auf 0 zählt. Damit ergeben sich 18 Pixel für ein Zeichen. Da ein angezeigtes Dot auf dem Bildschirm zwei Pixeln entspricht werden hier also neun Dots angezeigt (das letzte Dot wird gedoppelt) und anschließend das Zeichen gewechselt. Klar ist, dass auch hier wieder eine Verzögerung zur Endstufe stattfinden muss, da die Untersetzung ebenfalls von active_video (und somit active_pixel in der aktiven Zeile) gesteuert wird. Die insgesamt 6 Takte vom Auslöser zur Endstufe müssen auch hier gelten. In Pixeltakt 219 kommt es zum Unterlauf des Counters, der #incr_pointer_char_read wird aktiv und führt im nächsten Takt natürlich zur Erhöhung des pointer_char_read. Von hier aus müssen jetzt noch fünf weitere Takte verzögert werden, damit in Takt 225, 6 Takte nach 219, das Shiftregister mit dem neuen Charakter geladen werden kann. Da beim Zeichenwechsel gleich beide Speicher hintereinander ausgelesen werden, ist dieser Zeitversatz notwendig, da es durchaus ein bis zwei Pixel dauern kann (pro Speicher etwa 20nS), bis am Shiftregister das nächste gültige Zeichen anliegen kann. Die Reserve ist mit mindestens vier vollen Takten (Takt 220 bis 224) hierfür völlig ausreichend. Das Laden des neuen Zeichens in das Shiftregister ist zeitlich nicht zu unterscheiden vom Shiften. Dies ist wichtig, da sich hierdurch kein signifikanter Jitter im Videosignal bemerkbar machen sollte, der Wechsel von Dot 8 (inhaltlich auch Dot 7) zu Dot 0 ist genauso schnell wie jeder andere Wechsel.

Diagramm 6: Cursor und Blanking, Ende des aktiven B ereichs Siehe Folgeseite


Seite 3- 62


Seite 3- 63


Seite 3- 64

Randbedingungen:

• Bildmitte, aktiver Bereich • Im [19,38] steht ein „G“, das Zeichen danach wird der Cursor sein, als vorletztes Zeichen. • Der Wechsel von cursor_on ist an dieser Stelle zufällig • char_matrix_Y steht auf 13. Es wird also die letzte Videozeile der Textzeile (hier 9) angezeigt

Die Cursor-Auswertung und das Blanking dürfen sich im Videosignal zeitlich nicht vom normalen Zeichenwechsel unterscheiden. Hierfür werden der Wechsel eines angezeigten Characters zum Cursor und der anschließende Wechsel zum Zeilenblanking betrachtet. Mit Wechsel zum Zeichen 38 der Zeile 19 in Pixel 886 (als Reaktion auf den Unterlauf des Untersetzungscounters) ist die Cursorposition erreicht, da Schreib-, und Lesevektor nun gleich sind. Dank der 6 Takte Verzögerung zum Videosignal kann rechtzeitig durch das #cursor-Flag ein Anzeigen eines ungültigen Zeichens verhindert werden. #cursor1 setzt kombinatorisch mit cursor_en, welches hier nun zufällig aktiv ist, #display_cursor aktiv und lädt somit direkt den Hardwired Cursor-Block. Ab diesem Zeitpunkt ist Dot unabhängig von dem vom Textspeicher ausgegebenen Zeichen. Mit #incr_pointer_char_read_del5 wird nun der Cursorblock zum richtig Zeitpunkt in das Shiftregister geladen. Erkennbar unterscheidet sich auch dies nicht von jedem anderen Zeichen. Der kurz nach dem Landen erfolgte Wechsel von Cursor on hat zu diesem Zeitpunkt keinen Einfluss mehr, da erst mit dem nächsten Inkrement das neue Zeichen in das Shiftregister geladen wird. Es ist allerdings abzusehen, dass mit dem nächsten Halbbild wahrscheinlich der Cursorblock nicht angezeigt wird, und stattdessen mit Space geblankt wird. Etwas kritischer kann der Fall sein, wenn cursor_on zufällig so fällt, dass zum Laden des Dots der Speicher gerade seinen Ausgang setzt. Dieser Fall dürfte theoretisch nicht vorkommen, da cursor_on noch durch ein Register gepuffert wird, und die summierten Verzögerungszeiten noch zu gering sind, um tatsächlich zur nächsten Taktflanke einen Speicherwechsel hervorzurufen (cursor_on 8ns - or 6ns - and 6ns - demux 8ns - and 6ns - tristate 6ns - insg. 40ns max. bis RAM, also 60 ns max bis Dot gültig!). Trotz der maximalen Verzögerungen bleiben zur nächsten Taktflanke noch mind. 8ns (was allerdings auch unter der eigentlich gewünschten Reserve von mind. 12ns liegt!), womit sicher immer ein gültiges Zeichen am Shiftregister anliegen sollte und es nicht undefinierten Zuständen kommen sollte. Der Fall wäre aber auch mit einem Gatter mehr noch nicht wirklich kritisch, da dieser Zustand zwar unschön ist, aber nicht optisch weiter auffallen sollte. Der Cursor kann seinen Zustand auch nach einer Zeile zur nächsten ändern, wodurch (in nur einem Halbbild!) der Cursorblock nur teilweise dargestellt werden würde. Da aber nach 1/50 s bereits das nächste Halbbild abgebildet wird bzw. nach 1/25 s das neue Vollbild abgezeichnet wird, bleibt dieser Effekt für den Nutzer unsichtbar, da spätestens das nächste Halbbild wieder ein korrektes Bild darstellt. Für das Blanking nach dem Cursor wird mit #incr_pointer_char_read_del2 die Character-Blank SM gesetzt. Durch sie wird jedes Zeichen nach dem Cursor, bzw. dem LF (und auch eben diese Zeichen!) geblankt. Zu sehen im Diagramm ab Takt 894. Da cursor_en fällt wird auch der Cursor nicht mehr angezeigt und durch Space ersetzt, was als nächstes Zeichen in Takt 910 geladen wird. Dies bedeutet aber auch, dass ein angefangener Cursorblock eventuell nicht beendet wird. #cursor setzt außerdem das #cursor_reached-Flag, wodurch zum Beginn der nächsten Zeile mit Takt 944 #Text_Line_Blank gesetzt wird und nun jede weitere Zeile nach dem Cursor blankt. Da Blanking höhere Priorität hat als Zeichen anzeigen, ist ab diesem Zeitpunkt auch egal welche Zeichen vom Textspeicher ausgegeben werden. Die Inhaltliche Trennung sichert das gültige Videosignal. Das Blanking außerhalb des sichtbaren Bildbereichs wird jedoch an anderer Stelle verwirklicht. Takt 921 löst in Takt 922 das Abfallen von active_video aus. Dieses Signal muss natürlich ebenfalls eine 6-

1 Alternativ könnte hier auch ein LF betrachtet werden. Der Unterschied zum Cursor ist lediglich eine geringe zeitliche Verzögerung, durch das Propagation Delay des Textspeichers und des anschließenden Komparators. Da die Reserve jedoch so großzügig gewählt wurde, ist dieser Unterschied hier unkritisch und ist qualitativ vergleichbar. Außerdem wird natürlich der Cursorblock nicht angezeigt, was aber ebenfalls mit dem Cursor ohne cursor_en der Fall ist.


Seite 3- 65

Takte Verzögerung zur Video-Endstufe aufweisen wie bereits gezeigt. Das verzögerte Signal active_video_del5 blankt nun den Videoausgang des Shiftregisters, weshalb es nicht relevant ist, was in der ungültigen Adresse [9:40] (welche kurzzeitig an dieser Stelle erzeugt wird) Undefiniertes gespeichert ist. Erst im aktiven Bereich der neuen Zeile, wenn durch active_video dieses Blanking wieder aufgehoben wird, ist dies wieder wichtig. Dass zu diesem Zeitpunkt bereits wieder gültige Daten anliegen werden, wurde bereits gezeigt. Mit Takt 944 und dem Beginn der neuen Zeile werden die vorherigen Lesevektoren zurückgesetzt und der Matrix-Counter erhöht. Da dieser hier nun den Wert 14 erreicht, wird ein #incr_pointer_text_line_read ausgelöst. Andernfalls würde dies nicht geschehen. Generell ist die vertikale Untersetzung eher unkritisch. Der Wechsel findet im Blanking statt und hat nur beim Überlauf Einfluss auf den Line-Pointer. Es gibt 20 Textzeilen, somit 280 Videozeilen pro Halbbild. Die Werte für Videozeile und Matrix Y lassen sich somit einfach bestimmen. Die Textzeilen beginnen schlicht immer in den Zeilen 27, 41, [...], 293 und 307. Der Bereich danach ist nicht im active_video und wird geblankt. Wäre davor nicht #cursor_reached gesetzt worden, würde dadurch hier nun das korrekte erste Zeichen der neuen Zeile zum Laden in das Shiftregister bei active_pixel bereitgestellt und #character_Blank deaktiviert werden. In dem hier betrachteten Fall jedoch ist der Ausgang des Textspeichers irrelevant, da bis zum Zeilenwechsel das #Character_Blank aktiv war und nun #Text_Line_Blank aktiv wird, da der Cursor erreicht wurde. Das Space-Zeichen bleibt nun also bis zum nächsten new_field erhalten. Es ist aber leicht vorstellbar, dass die zeitliche Reserve bis zum Pixel 35 in jedem Falle mehr als ausreichend sein dürfte.


Seite 3- 66

Dokumentation der Modifikationen während der Inbetr iebnahme

Das Hinzufügen eines Interruptausgangs zur Synchron isation der CPU auf den Bildwechsel (22.08.2016)

Definition der Funktion Das Schreiben einer 1 auf die Bitposition 26 ( = Bit 2 bei Byte-Zugriff) der Adresse des Paralleports (FF FF FF EC) gibt die Interrupt-Ausgabe frei. Während und nach dem Verlassen des Resetzustandes ist die Interrupt-Ausgabe solange gesperrt, bis sie auf die zuvor beschriebene Weise aktiviert wird. In diesem Fall verhält sich die Video-Karte exakt so, wie es vor der Modifikation der Fall war. Die Interrupt-Ausgabe kann auch durch die Ausgabe einer Null auf die auf die Bitposition 26 ( = Bit 2 bei Byte-Zugriff) der Adresse des Parallelports (FF FF FF EC) deaktiviert werden. Bei aktivierter Interrupt-Ausgabe zeigt sich das folgende Verhalten: Beim Erreichen der Video-Zeile 26 wird, unabhängig von der beschriebenen Modifikation, das Signal transfer_en auf L (inaktiv) gesetzt. Gleichzeitig wird die Statemachine zum Auslösen des Interrupts gesetzt. Damit wird das Interrupt-Signal #ext_int auf L gezogen. Der Zustand der Statemachine kann aus der Bitposition 26 ( = Bit 2 bei Byte-Zugriff) der Adresse FF FF FF E8 ausgelesen werden. Eine 1 entspricht dem Zustand „Interrupt ist aktiv“ Der Interrupt kann durch einen Schreibzugriff auf die Adresse FF FF FF E4 mit beliebigen Daten quittiert werden. Damit wird die Interrupt-Statemachine zurückgesetzt.

Schaltungstechnische Realisierung: Die folgende Abbildung zeigt die schaltungstechnische Realisierung:


Seite 3- 67

en

#ext_intZu J5101/C17

U_NV574F151

4321

15141312

11109

7

65

D0D1D2D3D4D5D6D7

ABC

G

YYH2

video_line_count=26

#reset

zu U5223/4

H2

#reset

X

set

Statemachine Interrupt

#reset

L

von U5205/13#sel_INT_rd

H

L

mem_d26_u

H

H2

#sel_INT_quit

L

pix_clk_2

LH2

L

H

1

von U1501/11

U_NV6B74ABT125

5 6

4

0

von U1207/8

pix_clk_2

U_NV4B74F74

12

11

98

1013

D

CLK

QQ

PRECLR

Y

U_NV6A74ABT125

2 3

1

L

U_NV2B74F74

12

11

98

1013

D

CLK

QQ

PRECLR

H2

#sel_PP_wr

3

pix_clk_2

mem_d26_u

pix_clk_2

set

4..7

H

rücksetzen

von U1501/18

#reset

U_NV4_A74F74

2

3

56

41

D

CLK

QQ

PRECLR

2

rücksetzen

L QVon U5206/12

U_NV3A74F74

2

3

56

41

D

CLK

QQ

PRECLR

U_NV3B74F74

12

11

98

1013

D

CLK

QQ

PRECLR

L

von U5223/4

halten

H2

H X

H2

H

#reset

dec

pix_clk_2

L

L

/en

res

L

von U1502/5

rücksetzen

res

#reset

setzen

von U5206/14

U_NV2A74F74

2

3

56

41

D

CLK

QQ

PRECLR

Die Interrupt-Statemachine ist mit dem Multiplexer U_NV5 und dem Flipflop U_NV4B aufgebaut. Bei gleichzeitig auftretender Setz- und Rücksetzanforderung hat das Rücksetzen Priorität. Die Signale zum Freigeben und Rücksetzen der Statemachine werden asynchron zum Pixeltakt aus dem Bus-Timing (4MHz) heraus generiert. Daher werden diese Signale mit zwei hintereinandergeschalteten D-Flipflops auf den Pixeltakt synchronisiert.


Seite 3- 68

Lageplan (Teil 1)

UNV5

UNV4

UNV3 UNV2


Seite 3- 69

Lageplan (Teil 2)

UNV6


Seite 3- 70

Vergrößern des Ausgangskondensators C1701 (24.09.2016) Bei Tests mit Computerspielen (Game of Life) stellte sich heraus, dass bei der Darstellung größerer in der Horizontalen zusammenhängender weißer Flächen die Synchronisation des Monitors verlorenging. Dieses Verhalten trat sowohl mit dem SONY-Monitor als mit dem MAINSTREAM-Monitor auf. Es stellte sich heraus, dass die Potentialverschiebung „hinter“ dem Ausgangskondensator C1701 durch die Ausgabe einer horizontal zusammenhängenden weißen Fläche so hoch wird, dass die nachfolgenden Sync-Impulse vom Monitor nicht mehr erkannt werden können. Mit einer Vergrößerung des Ausgangskondensators von 10uF auf 33uF wurde das Problem gelöst. Um eine Sicherheitsmarge zu bekommen wurde ein 47uF-Folienkondensator eingebaut.

Hinzufügen eines EEPROMs (24.09.2016) Es wurde ein serielles EEPROM hinzugefügt, da im System noch ein vom Programmspeicher unabhängiger nichtflüchtiger Speicher benötigt wird. Auf der Video-Karte war der Aufwand zum Nachverdrahten dieses Speichers am geringsten. Daher wurde entschieden, den Speicher auf der Video-Karte unterzubringen. Es wurde ein getrennter I/O-Port für diesen Speicher vorgesehen (UNV7), um das EEPROM ansprechen zu können, ohne dabei die Steuerbits für die Video-Ausgabe zu beeinflussen. Da der EEPROM-Baustein (UNV9) CMOS-Pegel benötigt, wurde als Level-Shifter ein Baustein 74HCT244 (UNV8) in die zum EEPROM führenden Signale eingeschleift.

Verändern der Bildlage (24.09.2016) Es zeigte sich, dass die Bildlage zu weit rechtsstehend ist. Dies führt zu einer deutlich sichtbaren Unsymmetrie bei der Darstellung von Rahmen, wie sie für einige Spiele benötigt werden. Die Zeichen werden von der Video-Karte „zu spät“ ausgegeben. Der analoge Abgleich an der Bildröhre kann dies nicht sinnvoll kompensieren, da beim Verlassen der zentrischen Einstellung verschiedene Verzerrungen zunehmen. Daher wurde das Setzen und das Rücksetzen der Statemachine für die Generierung des Signals active Pixel um 32 Pixeltakte „nach vorne verlegt“. Hierzu wurde der Eingang 10 des Gatters U1106C vom Ausgang #Y12 des Decoders U1194 (192) abgetrennt und mit dem Ausgang #Y10 (160) verbunden. Damit wird das Signal active_pixel beim Erreichen des Horizontal-Zählerstandes 169 (bisher 201) gesetzt. Weiterhin wurde der Eingang 4 des Gatters U1108B vom Ausgang #Y9 des Decoders U1194 (144) abgetrennt und mit dem Ausgang #Y7 (112) verbunden. Damit wird das Signal active_pixel beim Erreichen des Horizontal-Zählerstandes 889 (bisher 921) zurückgesetzt.

Dokumentation des Tests der Baugruppe auf der Hardw are-Ebene


Seite 3- 71

Benötigtes Testequipment: 1. Testadapter SP2-040 2. Schablone SP2-041... für Peripheriekarten für Testadapter SP2-040 3. Simulator 74F269 SP2-071-1/6 6x Q[7..0], /RCO 4. Simulator FIFO7204 SP2-071 –2/6 1x /EF, /FF, Q 5. Simulator 74F74 SP2-071-4 2 x Q 6. Simulator RAM7134 SP2-071-3/6 1x Q(R) 7. Simulator 74F194 SP2-071-5 1x QD

Schritt 1: Reset Reset-Taste auf Testadapter drücken. Am Signal #reset (U4902/11) stellt sich ein L-Pegel ein.

Schritt 2: Pixeltakt Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Beim Drücken der CLK-Taste auf dem Testadapter ist an den Taktsignalen pix_clk_1..3 an U4902 ein Taktimpuls zu sehen. Pixeltakt auf Oszillatorbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf H stelllen) An den Taktsignalen pix_clk_1..3 an U4902 ist ein 14,7456 MHZ-Takt zu sehen.

Schritt 3: Horizontal-Decoder Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F269 in Fassung U1101 Simulator 74F269 in Fassung U1102

niedrig

Hoch

Test des direkten Pfades: 944 = 03B0 L-Pegel an U1112/19 bei anderem Zählerstand (z.B. 0) stellt sich ein H-Pegel ein. 944 = 03B0 H-Pegel an U1110/4 bei anderem Zählerstand (z.B. 0) stellt sich ein L-Pegel ein. 201 = 00C9 H-Pegel an U1106/8 bei anderem Zählerstand (z.B. 0) stellt sich ein L-Pegel ein. 921 = 0399 H-Pegel an U1108/6 bei anderem Zählerstand (z.B. 0) stellt sich ein L-Pegel ein.


Seite 3- 72

Test des Pipelined-Pfades: Die interessierende Pegeländerung wird erst dann sichtbar, wenn ein Pixeltakt ausgelöst wird. 944 = 03B0 H-Pegel an U1109/19 bei anderem Zählerstand (z.B. 0) stellt sich ein L-Pegel ein. 874 = 036A H-Pegel an U1109/18 bei anderem Zählerstand (z.B. 0) stellt sich ein L-Pegel ein. 507 = 01FB H-Pegel an U1109/17 bei anderem Zählerstand (z.B. 0) stellt sich ein L-Pegel ein. 472 = 01D8 H-Pegel an U1109/16 bei anderem Zählerstand (z.B. 0) stellt sich ein L-Pegel ein. 403 = 0193 H-Pegel an U1109/15 bei anderem Zählerstand (z.B. 0) stellt sich ein L-Pegel ein. 69 = 0045 H-Pegel an U1109/13 bei anderem Zählerstand (z.B. 0) stellt sich ein L-Pegel ein. 35 = 0023 H-Pegel an U1109/13 bei anderem Zählerstand (z.B. 0) stellt sich ein L-Pegel ein.

Schritt 4: Statemachine für Signal active_pixel Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F269 in Fassung U1101 Simulator 74F269 in Fassung U1102 Setzen und Rücksetzen der Statemachine durch Einstellen der relvanten Zählerstände und durch Ausgabe eines Pixeltaktes, Prüfen des Haltens bei sonstigen Zählerständen. 921 = 0399 => CLK => U1304/9 auf L Statemachine rückgesetzt 201 = 00C9 => CLK => U1304/9 auf H Statemachine gesetzt 0 = 0000 => CLK => U1304/9 auf H Keine Änderung 921 = 0399 => CLK => U1304/9 auf L Statemachine rückgesetzt 0 = 0000 => CLK => U1304/9 auf L Keine Änderung

Schritt 5: Horizontal-Zähler Pixeltakt auf Oszillatorbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf H stelllen) Baustein 74F269 in Fassung U1101 Baustein 74F269 in Fassung U1102 An U1112/19 erscheinen Low-gerichtete Impulse von derDauer eines Pixeltakts im Abstand von 64us. Kontrolle der Zähler-Ausgänge mit dem Oszilloskop. U1101/2 U1101/3 U1101/4


Seite 3- 73

U1101/5 U1101/6 U1101/8 U1101/9 U1101/10 U1102/2 U1102/3 Die Frequenz halbiert sich von jedem Ausgang zu dem nachfolgenden Ausgang. Einige Ausgangssignale sind bezüglich des H-Pegels „angeschnitten“, da das Rücksetzen beim Erreichen von 944 erfolgt. 944 ist keine „glatte Hex-Zahl“.

Schritt 6: Vertikal-Decoder Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F269 in Fassung U1201 Simulator 74F269 in Fassung U1202 Einstellen der relevanten Zählerstände. Kontrolle der direkten Ausgangssignale. (An den dreifach-NOR-Gattern und den nachgeschalteten Invertern)


Seite 3- 74

Test des direkten Pfades: Zählerstand Dezimal

Zählerstand Hex Decoder-Ausgang Pegel bei Zählerstand Null

Pegel bei Zählerstand gemäss Spalten 1 und 2

1 0001 U1206/12 L H 2 0002 U1206/6 L H 3 0003 U1206/8 L H 4 0004 U1207/12 L H 5 0005 U1207/6 L H 26 001A U1207/8 L H 27 001B U1208/12 L H 307 0133 U1208/6 L H 311 0137 U1208/8 L H 312 0138 U1209/12 L H 313 0139 U1209/6 L H 314 013A U1209/8 L H 315 013B U1210/12 L H 316 013C U1210/6 L H 317 013D U1210/8 L H 340 0154 U1211/12 L H 620 026C U1211/6 L H 623 026F U1211/8 L H 624 0270 U1212/12 L H 625 0271 U1212/6 L H


Seite 3- 75

Test des Pipelined-Pfades: Die interessierende Pegeländerung wird erst dann sichtbar, wenn ein Pixeltakt ausgelöst wird. Kontrolle der zusammengesetzten Ausgangssignale #P0, P1..P5 Zählerstand Dezimal

Zählerstand Hex

#P0 U1221/19

P1 U1221/18

P2 U1221/17

P3 U1221/16

P4 U1221/15

P5 U1221/14

1 0001 H L L H L L 2 0002 H L L H L L 3 0003 H L L L H L 4 0004 H L H L L L 5 0005 H L H L L L 26 001A L L L L L L 27 001B L L L L L L 307 0133 L L L L L L 311 0137 H L H L L L 312 0138 H L H L L L 313 0139 H L L L L H 314 013A H L L H L L 315 013B H L L H L L 316 013C H L H L L L 317 013D H L H L L L 340 0154 L L L L L L 620 026C L L L L L L 623 026F H H L L L L 624 0270 H L H L L L 625 0271 H L H L L L 0 0000 L L L L L L Test der zusammengesetzen Ausgangssignale set_active_line und new_field: Diese Signale laufen nicht durch die Pipeline Zählerstand Dezimal

Zählerstand Hex set_active_line U1213/6

27 001B H 340 0154 H andere L Zählerstand Dezimal

Zählerstand Hex new_field U1213/8

312 0138 H 625 0271 H andere L


Seite 3- 76

Schritt 7: Statemachine für Signal active_line Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F269 in Fassung U1201 Simulator 74F269 in Fassung U1202 Setzen und Rücksetzen der Statemachine durch Einstellen der relvanten Zählerstände und durch Ausgabe eines Pixeltaktes, Prüfen des Haltens bei sonstigen Zählerständen. Setzen der Statemachine mit den Zeilen 27 und 340 Rücksetzen der Statemachine mit den Zeilen 307 und 620 Ausgangssignal active_line an U1402/5 Rücksetzen über Reset-Taster aus Testadapter => U1402/5 = L Setzen mit Line Count = 27 = 001B => CLK => U1402/5 = H Rücksetzen mit Line Count = 307 = 0133 => CLK => U1402/5 = L Setzen mit Line Count = 340 = 0154 => CLK => U1402/5 = H Rücksetzen mit Line Count = 620 = 026C => CLK => U1402/5 = L

Schritt 8: Statemachine für Signal transfer_en Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F269 in Fassung U1201 Simulator 74F269 in Fassung U1202 Setzen und Rücksetzen der Statemachine durch Einstellen der relvanten Zählerstände und durch Ausgabe eines Pixeltaktes, Prüfen des Haltens bei sonstigen Zählerständen. Setzen der Statemachine mit der Zeile 620 Rücksetzen der Statemachine mit der Zeile 26 Ausgangssignal transfer_en an U1402/9 Rücksetzen über Reset-Taster aus Testadapter => U1402/9 = L Setzen mit Line Count = 620 = 026C => CLK => U1402/9 = H Rücksetzen mit Line Count = 26 = 001A => CLK => U1402/9 = L

Schritt 9: Vertikal-Zähler Pixeltakt auf Oszillatorbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf H stelllen) Baustein 74F269 in Fassung U1201 Baustein 74F269 in Fassung U1202 Kontrolle der Zähler-Ausgänge mit dem Oszilloskop.


Seite 3- 77

Für diesen Test müssen der Horizontal-Zähler und der Horizontal-Decoder funktionsfähig sein. An U1212/6 sind H-gerichtete Impulse im Abstand von 40ms (2 Halbbilder) zu sehen. Kontrolle der Zähler-Ausgänge mit dem Oszilloskop. U1201/2 128us U1201/3 U1201/4 U1201/5 U1201/6 U1201/8 U1201/9 U1201/10 U1202/2 U1202/3 Die Frequenz halbiert sich von jedem Ausgang zu dem nachfolgenden Ausgang. Einige Ausgangssignale sind bezüglich des H-Pegels „angeschnitten“, da das Rücksetzen beim Erreichen von 625 erfolgt. 625 ist keine „glatte Hex-Zahl“.


Seite 3- 78

Schritt 10: CSYNC-Signal Der Vertikal-Zählerstand wird mit den Simulatoren eingestellt, während der Horizontal-Zähler mit dem Pixeltakt (Oszillatorbetrieb) durchläuft. Simulator 74F269 in Fassung U1201 Simulator 74F269 in Fassung U1202 Die Kurvenform am Signal CSYNC (U1304A/5) wird auf Korrektheit der Pattern in den relevanten Zeilen geprüft. Es wird mit dem zweiten Oszilloskopkanal getriggert, der an U1112/19 (hor_pix_count = 944 = 64us unreg) gelegt wird. Damit ist das CSYNC-Signal eindeutig auf den Zeilenanfang bezogen sichtbar. Es zeigen sich die folgenden Kurvenformen:

313 = 0139 P5

3 = 0003 P4

2,35

us

624 = 0270 P2

34,3

5us

27,3

us

1 = 0001 P3

0 = 0000 P0

4,7u

s

32us 64

us

0us

59,3

us

623 = 026F P1

Das Signal CSYNC_del4 wird ebenfalls, bei einem einzigen Pattern, überprüft (U1607/12) Das Sync-Pattern der Zeile 318 wird aufgrund eines Entwurfsfehlers entsprechend der Zeile 0 ausgegeben. Der Sync-Impuls dürfte nur 2,35us breit sein, ist aber 4,7us breit. Mit den zum Test verwendeten Monitoren ergab sich hierdurch aber keine Beeinträchtigung der Bildqualität, so dass dieser Fehler nicht korrigiert wurde.


Seite 3- 79

Schritt11: Video-Timing in der Gesamtheit Pixeltakt auf Oszillatorbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf H stelllen) Baustein 74F269 in Fassung U1201 Baustein 74F269 in Fassung U1202 Der Horizontal- und der Vertikal-Zähler laufen mit dem Pixeltakt (Oszillatorbetrieb) durch. Die folgenden Signale werden überprüft: An CSYNC_del4 (U1707B/4) ergibt sich ein Pattern entsprechend des vorherigen Testschritts. Während des aktiven Bereichs einer Zeile (13,6us bis 62,5us) ist im aktiven Bildbereich (Zeilen 27...307 und Zeilen 340..620) ein H-Pegel am Signal active_video (U1111C/8) . Das Signal active_video_del5 (U1606/15) folgt dem Signal active_video (U1111C/8) um 5 Pixeltakte verzögert.

Schritt 12: Pointer Character Read Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F74 in Fassung U1304 (für Signal active pixel) Simulator 74F269 in Fassung U1101 (Für hor_pix_count) Simulator 74F269 in Fassung U1102 (Für hor_pix_count)

active_pixel ist H

U1304

active_pixel ist L

Test der Untersetzung des Pixeltakts fürGenerierung des Signals #incr_char_pointer_read in Abhängigkeit von active_pixel:


Seite 3- 80

active_pixel ist auf L gesetzt: - An den Ausgängen von U1501 (Pins 2..6 und 8..10) ist statisch der Wert 0001 0001 (17d) - Dieser Wert bleibt auch dann erhalten, wenn man Pixeltakte ausgibt - Das Signal #incr_char_pointer_read ist auf H (U1501/14) active_Pixel ist auf H gesetzt: - Mit jedem ausgegebenen Pixeltakt zählt der Zähler U1501 um Eins herunter - Beim Erreichen des Zählerstandes Null geht das Signal #incr_char_pointer_read auf L (U1501/14) - Beim Ausgeben eines weiteren Pixeltaktes geht der Zählerstand von U1501 wieder auf 17. Das

Signal #incr_char_pointer_read geht wieder auf H (U1501/14)

1617 114

Pixel_clk

3**** Zählerstand U15011717 2 0 16

#incr_char_pointer_read

17 15

active_pixel

17 1415

Test des Hochzählens von pointer_char_read[5..0] bei manuellem Takten des Pixeltaktes mit dem Oszilloskop: Zunächst wird der Zählerstand von U1501 durch einen Reset bei gleichzeitigem Pixeltakt auf Null zurückgesetzt. (Messung an den Ausgängen, Pins 2..6 und 8..10) Active_Pixel wird auf H gesetzt. Es werden 18 Pixeltakte ausgegeben. Damit erhöht sich der Zählerstand von U1501 von Null auf 1 (Messung an den Ausgängen, Pins 2..6 und 8..10) Es werden erneut 18 Pixeltakte ausgegeben. Damit erhöht sich der Zählerstand von U1501 von 1 auf 2 (Messung an den Ausgängen, Pins 2..6 und 8..10) Auf diese Weise wird das weitere Hochzählen des Zählers bis zum Erreichen eines H-Pegels am Ausgang QF getestet. Test des Rücksetzens von pointer_char_read[5..0] bei Simulation des Zählerstandes hor_pix_count = 944 bei manuellem Takten des Pixeltaktes mit dem Oszilloskop: Es wird sichergestellt, dass der Zählerstand von U1505 von Null verschieden ist.


Seite 3- 81

Hor_Pix_count[9..0] wird auf 944 = 03B0 gestellt. Es werden zwei Pixeltakte ausgegeben (Pipeline). Danach ist der Zählerstand von U1505 Null. Kontrolle von pointer_char_read bei laufendem Video-Timing mit dem Oszilloskop: Baustein 74F74 in Fassung U1304 Baustein 74F269 in Fassung U1101 Baustein 74F269 in Fassung U1102 Pixeltakt auf Oszillatorbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf H stelllen) An den Signalen pointer_char_read[5..0] erkennt man, dass der Zähler U1505 mit einer Untersetzung von 18 Pixeltakten bis zum Überlauf (255) hochzählt.


Seite 3- 82

Schritt 13: Signale char_matrix_Y_[3..0] Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F74 in Fassung U1402 (für Signal active line) Simulator 74F269 in Fassung U1101 (Für hor_pix_count) Simulator 74F269 in Fassung U1102 (Für hor_pix_count)

active_line ist H

active_line ist L

U1402

Test des Hochzählens von char_matrix_Y_[3..0] bei manuellem Takten des Pixeltaktes mit dem Oszilloskop in Abhängigleit von active_line und hor_pix_count=944=64us: active_Line wird auf L gesetzt. - Der Zählerstand von U1503 ist (nach Ausgabe eines Pixeltaktes) auf 0 - Der Zählerstand bleibt auch dann auf Null, wenn weitere Pixeltakte ausgegeben werden. Hor_Pix_count[9..0] wird auf 944 = 03B0 gestellt. Es werden zwei Pixeltakte ausgegeben (Pipeline). Danach ist der Zählerstand von U1503 auf Eins hochgezählt. Mit jedem weiteren Pixeltakt erhöht sich der Zählerstand um Eins. Nach dem Erreichen des Zählerstandes 14 zählt der Zähler bei Null weiter. Der Zähler U1503 wird auf einen von Null verschiedenen Wert hochgezählt. Hor_Pix_count[9..0] wird auf einen von 944 = 03B0 verschiedenen Wert gestellt. Es wird ein Pixeltakt ausgegeben. Aufgrund des Pipeline-Registers nach dem Horizontal-Decoder zählt der Zähler noch einmal um Eins hoch.


Seite 3- 83

Anschliessend wird der nun vorhandene Zählerstand auch beim Ausgeben weiterer Pixeltakte gehalten.

Schritt 14: Pointer_Text_Line_Read Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F269 in Fassung U2602 (Für text_line_scroll_offset[4..0]) Simulator 74F74 in Fassung U1402 (für Signal active line) Simulator 74F269 in Fassung U1101 (Für hor_pix_count) Simulator 74F269 in Fassung U1102 (Für hor_pix_count) Simulator 74F269 in Fassung U1201 (Für video_line_count) Simulator 74F269 in Fassung U1202 (Für video_line_count) Test der grundätzlichen Zählfunktion und des Überlaufs: text_line_scroll_offset wird zunächst auf Null gestellt. Der Zählerstand von U1506 wird durch die Ausgabe eines Resets bei gelichzeitigem Pixeltakt auf Null gesetzt. Test des Hochzählens von pointer_text_line_read_[4..0] mit manuellem Takten des Pixeltaktes. Hierbei Untersetzung um den Faktor 14 (bedingt durch U1503) beachten. Kontrolle des Zählerstandes an pointer_Text_line_read[4..0] an U1506/ 2..6 Nach dem Erreichen des Zählerstandes 19 und bei erneut aktivem Signal #incr_text_line_pointer_read (Untersetzung Pixeltakt um Faktor 14 mit U1503) geht der Zählerstand auf Null und es beginnt ein neuer Hochzähl-Zyklus. Test des Laden des Scroll-Offsets über set_active_line: (Steuerung über Simulatoren in U1201 und U1202) und hor_pix_count=35=2,35us (Simulatoren in U1101 und U1102) Es wird weiter auf einen von Null verschiedener Zählerstand hochgezählt. Hor_Pix_Count wird an den Simulatoren in U1101 und U1102 auf 35 = 0023 eingestellt. Video_line_Count wird an den Simulatoren in U1201 und U1202 auf 340 = 0154 eingestellt. Nach zwei Pixeltakten (Pipeline) wird der Scroll-Offset (Hier noch Null) geladen, der Zählerstand geht auf Null. Es wird noch einmal auf einen von Null verschiedenen Zählerstand hochgezählt. Hor_Pix_Count bleibt an den Simulatoren in U1101 und U1102 auf 35 = 0023 eingestellt. Video_line_Count wird an den Simulatoren in U1201 und U1202 auf 27 = 001B eingestellt. Nach zwei Pixeltakten (Pipeline) wird der Scroll-Offset (Hier noch Null) geladen, der Zählerstand geht auf Null.


Seite 3- 84

text_line_scroll_offset wird nun nacheinander auf die Werte 1,2,4,8 und 16 gestellt und jeweils auf die soeben beschriebene Weise in den Zähler geladen. Der Zählerstand wird kontrolliert, er muss dem Scroll-Offset entsprechen. Test der Zählsequenz mit von Null verschiedenem Scroll-Offset: Mit einem der von Null verschiedenen Werte für den Scroll-Offset wird kontrolliert, dass der Zähler bei von Null verschiedenem Offset eine korrekte Zählsequenz durchführt. Hierzu wird nach dem Laden des Offsets hor_pix_count auf einen von 0023 verschiedenen Wert gestellt. Mit dem Offset 1 soll sich dann die folgende Zählsequenz ergeben: 1=>2 => 3 .... => 18 => 19 => 0 => 1... Test des korrekten Verhaltens beim Reset: Es wird ein von Null verschiedener Wert des Zählerstandes von U1506 hergestellt (Hochzählen oder von Null verschiedenen Scroll-Offset laden) Bei Druck auf die Reset-Taste bei gleichzeitigem Pixeltakt stellt sich dann der Zählerstand Null ein.


Seite 3- 85

Schritt 15: Bus-Decoder Ausgabe der relevanten Adressen auf dem Testadapter. Kontrolle der Cipselectsignale #sel_char_ROM_write, #seld_PP_rd, #sel_PP_wr und #sel_FIFO_write. Es muss darauf geachtet werden, nachdem Erkennen der Adressierung alle Bedingungen, die dann zur Ungleichheit anden Comparatoren führen EINZELN abzutesten. Signal #sel_char_rom_write (U5207/19): mem_adr[31..24] werden auf H gestellt. mem_adr[23..16] werden auf H gestellt. mem_adr[15] werden auf H gestellt. mem_adr[14] werden auf L gestellt. An #sel_char_ROM_write (U5207/19) steht ein L-Pegel an. Nun wird jede Bedingung, die zur Gleichheit an der Comparatorkette geführt hat EINZELN (Signal für Signal) weggenommen. In jedem Fall muss sich ein H-Pegel am Signal #sel_char_ROM_write einstellen. Select-Signale für Parallelport: mem_adr[31..24] bleibt auf H gestellt. mem_adr[23..16] bleibt auf H gestellt. mem_adr[15..8] werden auf H gestellt. mem_adr[7..5] werden auf H gestellt. An U5204/19 ist ein L-Pegel. Nun wird jede Bedingung, die zur Gleichheit an der Comparatorkette geführt hat EINZELN (Signal für Signal) weggenommen, beginnend bei mem_adr_15. In jedem Fall muss sich ein H-Pegel an U5204/19 einstellen. Nun wird die Decodierung überprüft: #ram_we3 auf H stellen. #mem_oe <= L mem_adr 4 <= L mem_adr 3 <= H mem_adr 2 <= H Am Signal #sel_PP_rd (U5205/12) ist ein L-Pegel. Nun wird jede Bedingung, die zur Decodierung geführt hat EINZELN (Signal für Signal) weggenommen, beginnend bei mem_oe. In jedem Fall muss sich ein H-Pegel an U5205/12 einstellen. #mem_oe wieder auf H stellen. #ram_we3 <= L mem_adr 4 <= L mem_adr 3 <= H mem_adr 2 <= H


Seite 3- 86

Am Signal #sel_PP_wr (U5206/12) soll ein L-Pegel sein. Nun wird jede Bedingung, die zur Decodierung geführt hat EINZELN (Signal für Signal) weggenommen, beginnend bei #ram_we3. In jedem Fall muss sich ein H-Pegel an U5206/12 einstellen. #ram_we3 <= L mem_adr 4 <= L mem_adr 3 <= H mem_adr 2 <= L Am Signal #sel_FIFO_write (U5206/13) ist ein L-Pegel. Nun wird jede Bedingung, die zur Decodierung geführt hat EINZELN (Signal für Signal) weggenommen, beginnend bei #ram_we3. In jedem Fall muss sich ein H-Pegel an U5206/12 einstellen.

Schritt 16: Parallelport ausgebend / Cursor-Blinksignal Pixeltakt auf Oszillatorbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf H stelllen) Schreibzugriff vom Testadapter auf den Parallelport ausgebend (U5222), Kontrolle der Signale cursor_en und video_en. mem_adr[31..24] werden auf H gestellt. mem_adr[23..16] werden auf H gestellt. mem_adr[15..8] werden auf H gestellt. mem_adr[7..5] werden auf H gestellt. mem_adr 4 <= L mem_adr 3 <= H mem_adr 2 <= H Die zu schreibenden Daten werden an mem_d[31..24] eingestellt. Mit der Ausgabe eines Schreibpulses (#ram_we3 <= L, Taster auf Adapter, Jumper muss gesteckt sein) werden die Daten in den Parallelport übernommen. Daten <= 01 => H-Pegel am Signal cursor_en (U5222/19) Daten <= 02 => H-Pegel am Signal video_en (U5222/18) Wenn das Signal cursor_en auf H gesetzt wurde, dann soll das Signal cursor_on_unreg (U1701/8) mit ca. 2Hz seinen Pegel wechseln. Das Signal cursor_on an U1608/18 ist identisch (Verzögerung um zwei Pixeltakte)


Seite 3- 87

Schritt 17: Parallelport einlesend In die Fassung von U3101 wird der FIFO-Simulator gesteckt. Lesezugriff vom Testadapter auf den Parallelport einlesend (U5223) Variation des Signals #FIFO_FF über den FIFO-Simulator und Kontrolle des richtigen Erfassens des Signals.

Steckbrückegesteckt = L

EF FF

Adressierung des Parallelports: mem_adr[31..24] werden auf H gestellt. mem_adr[23..16] werden auf H gestellt. mem_adr[15..8] werden auf H gestellt. mem_adr[7..5] werden auf H gestellt. mem_adr 4 <= L mem_adr 3 <= H mem_adr 2 <= H mem_d[31..24] <= H (Datenbus als Eingang) #mem_oe <= L Auslesen des Parallelports: Bei nicht vorhandener Steckbrücke an FF ergibt sich das Datenmuster 1111 1111 Bei vorhandener Steckbrücke an FF ergibt sich das Datenmuster 0111 1111


Seite 3- 88

Schritt 18: Erkennung vom Steuerzeichen FIFO-Simulator in Fassung U3101 (Für Signal #FIFO_EF) Ausgabe der relvanten Zeichen am Datenausgang des FIFO-Simulators Kontrolle der Ausgangssignale der Comparatoren U3203, U3204, U3205 und des Gatters U1219B. (#char=LF, #char=CLS, #char=BS, #char_normal) Ausgabe von LF = 0A an FIFO-Simulator: #char=LF U3203/19 geht auf L Ausgabe von CLS = 0C an FIFO-Simulator: #char=CLS U3204/19 geht auf L Ausgabe von BS = 08 an FIFO-Simulator: #char=BS U3205/19 geht auf L Ausgabe eines von LF, CLS und BS verschiedenen Zeichens: #char=normal U1219/8 geht auf L

Schritt 19: Erkennung von #last_char und #first_char Simulator 74F269 in Fassung U2404 Variation des Zählerstandes Kontrolle der Signale #last_char und #first_char Bei Einstellen von 39 = 27h geht #last_char (U2405/19) auf L. Bei Einstellen von 0 geht #first_char (U2406/19) auf L

Schritt 20: Erkennung von #last_line Simulator 74F269 in Fassung U2502 Variation des Zählerstandes Kontrolle des Signals #last_line Bei Einstellung von 19 = 13h geht #last_line (U2503/19) auf L.

Schritt 21: Erkennung von #max_offset Dieser Testablauf bezieht sich auf die durch Nachverdrahtung korrigierte Schaltung. Simulator 74F269 in Fassung U2602 Variation des Zählerstandes Kontrolle des Signals #max_offset Bei Einstellung von 19 = 13h geht #max_offset (U2603/19) auf L.


Seite 3- 89

Schritt 22: Decoder Statemachine Write Simulator 74F269 in Fassung U2404 Simulator 74F269 in Fassung U2502 Simulator 74F269 in Fassung U2602 Simulator 74F269 in Fassung U3201 FIFO-Simulator in Fassung U3101 (Für Signal #FIFO_EF) 74F74-Simulator in Fassung U1402 (für Signal transfer_en) 74F74-Simulator in Fassung U1403 (für Signal scroll) Durchgehen der Zälkerstände 0..7, Kontrolle der Signale #S0, S2, S4 und #S5 Kontrolle des Signals /PE an U3201 bei Variation der Signale #FIFO_EF (Simulator in Fassung U1402) und transfer_en (Simulator in Fassung U3101) und des Zählerstandes sowie bei Reset. Kontrolle des Signals #FIFO_read bei Variation des Zählerstandes Kontrolle des Signals #ram_we anhand des Zählerstands und des simulierten FIFO-Ausgangs bezüglich LF und normaler Zeichen. Kontrolle des Signals #incr_pointer_char_write andhand der Variation des Zählerstandes, der Variation des Signals #last_char (über Simulator in Fassung U2404) und des anliegenden Characters (Simulator in Fassung U3101)


Seite 3- 90

Es zeigt sich das folgende Verhalten: Zählerstand U3201

#S0 U3202/15

S2 U3214/11

S4 U3208/4

#S5 U3202/7

#FIFO read U3214/8

#ram_we U3214/3

#incr_pointer_char_write U3209/6

0 L L L H H H H 1 H L L H L H H 2 H L L H L H H 3 H L L H L H H 4 H H L H L L* L** 5 H L L H L H H 6 H L H H L H H 7 H L L L H H H * Bei Erfüllung der folgenden Bedingungen: FIFO-Datenausgang <= 0A (LF) oder FIFO-Datenausgang <= 00 (beispielhaft für ‚normales‘ Zeichen) Wenn diese Bedingung nicht erfüllt ist (Test mit FIFO-Datenausgang = 0C (CLS)) dann ergibt sich ein H-Pegel ** Bei Erfüllung der folgenden Bedingungen: Zählerstand U2404 auf ungleich 27h gestellt (#last_char auf H) und FIFO-Datenausgang <= 00 (#char = normal auf L) Wenn diese Bedingung nicht erfüllt ist (Test mit FIFO-Datenausgang = 0C (CLS) bzw. Zählerstand U2404 <= 27h ), dann ergibt sich ein H-Pegel Die folgenden Ausgänge des Decoders sind mit S4 verknüpft. Hinweis: Der State S4 korrespondiert mit dem Zählerstand 6 an U3201. In der Folge ist stets die Kombination der Bedingungen dargestellt, die den jeweiligen Ausgang aktiv werden lässt. Für den Test auf den inaktiven Zustand werden jeweils alle Bedingungen einzeln weggenommen.


Seite 3- 91

#res_pointer_char_write (U3210/3) geht auf L wenn:

S4 Zählerstand 06 an Simulator U3201 und char = LF Datenausgang auf 0A an Simulator FIFO

oder

S4 Zählerstand 06 an Simulator U3201 und char = CLS Datenausgang auf 0C an Simulator FIFO

oder

S4 Zählerstand 06 an Simulator U3201 und char = normal Datenausgang auf 00 an Simulator FIFO

und last_char Zählerstand 27h an Simulator U2404

#decr_pointer_char_write (U3211/6) geht auf L wenn:

S4 Zählerstand 06 an Simulator U3201 und /first_char Zählerstand 00 an Simulator U2404 und char =BS Datenausgang an Simulator FIFO auf 08


Seite 3- 92

#incr_pointer_text_line write (U3211/8) geht auf L wenn:

S4 Zählerstand 06 an Simulator U3201 und /last line Zählerstand an Simulator U2502 ungleich 13h und last_char Zählerstand an Simulator U2404 = 27h und char = normal Datenausgang an Simulator FIFO auf 00 oder char = LF Datenausgang an Simulator FIFO auf 0A #res_pointer_text_line_write (U3210/8) geht auf L wenn:

S4 Zählerstand 06 an Simulator U3201 und last_line Zählerstand an Simulator U2502 13h und char = normal Datenausgang an Simulator FIFO auf 00 oder last_line Zählerstand an Simulator U2502 13h und char = LF Datenausgang an Simulator FIFO auf 0A oder char = CLS Datenausgang an Simulator FIFO auf 0C Anmerkung: Kein Reset bei char = BS #incr_pointer_text_line_offset (U3212/8)


Seite 3- 93

geht auf L wenn:

S4 Zählerstand 06 an Simulator U3201 und last_char Zählerstand an Simulator U2404 = 27h und char = normal Datenausgang an Simulator FIFO auf 00

oder Char = LF Datenausgang an Simulator FIFO auf 0A und scroll Simulator U2211, siehe untenstehende Zeichnung und /max.offs Zählerstand an Simulator U2404 ungleich 12h

scroll ist H

scroll ist L

U2211


Seite 3- 94

#res_pointer_text_line_offset (U3210/11) geht auf L wenn:

S4 Zählerstand 06 an Simulator U3201 und last_char Zählerstand an Simulator U2404 = 27h und

char = normal Datenausgang an Simulator FIFO auf 00

oder Char = LF Datenausgang an Simulator FIFO auf 0A und

max.offs Zählerstand an Simulator U2404 = 12h oder char = CLS Datenausgang an Simulator FIFO auf 0C ######## Laden des Zählers U3201 (U3206/8) geht auf L wenn:

/S5 Zählerstand an Simulator U3201 = 00..06 und

/FIFO_EF Steckbrücke am FIFO-Adapter gemäss untenstehender Zeichnung stecken

und

transfer_en Steckbrücke am Adapter U1402 gemäss untenstehender Zeichnung stecken

oder #S0 Zählerstand an Simulator U3201 = 00


Seite 3- 95


EF FF

transfer_en ist L

U1402

transfer_en ist H

Schritt 23: Statemachine Scroll Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Baustein 74F74 in Fassung U2211B. Steuern der Signale set_scroll und res_scroll über Zählerstand (Simulator in U3201) sowie Signal #last_line (Simulator in U2502) und Signal #char=CLS (Simulator in U3201). Damit Setzen und Rücksetzen der Statemachine mit manuell gesteuertem Pixeltakt, Kontrolle des Signals scroll. Setzen der Statemachine über Signal set_scroll (U3218/6) bei Erfüllung der folgenden Bedingung und der Ausgabe eines Pixeltakts: S2 Zählerstand an Simulator U3201 = 04 und last_line Zählerstand an Simulator U2502 13h


Seite 3- 96

Rücksetzen der Statemachine über Signal res_scroll (U3218/8) bei Erfüllung der folgenden Bedingung und der Ausgabe eines Pixeltakts: S2 Zählerstand an Simulator U3201 = 04 und char = CLS Datenausgang an Simulator FIFO auf 0C Anmerkung: Dieser Testablauf bezieht sich auf den durch Nachverdrahtung korrigierten Zustand der Schaltung

Schritt 24: Pointer Char Write Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Baustein 74F269 in Fassung U2404. Simulator 74F269 in Fassung U3201 FIFO-Simulator in Fassung U3101 (Für Character-Output) Steuern der Signale - #res_pointer_char_write - #decr_pointer_char_write - #incr_pointer_char_write wie in Testschritt „Decoder Statemachine Write“ über Variation Zählerstand Simulator U3201, Character Output an Simulator FIFO. Hierbei manuelles Auslösen einzelner Pixeltakte. Kontrolle der Signale pointer_char_write[5..0] an U2404 2..10 mit dem Oszilloskop hierbei folgende Funktionen kontrollieren: - Resetten über Reset - Hochzählen - Erkennung/Verarbeitung Überlauf beim Hochzählen - Herunterzählen über BS - Stopp des Herunterzählens am Zeilenanfang - Resetten über CLS - Resetten über LF Simulator in U3201 auf Zählerstand 06h stellen (S4 Statemachine Write) Verhalten bei „normalen“ Zeichen: An Simulator in U3101 Datenausgang auf 00h stellen („normales“ Zeichen) Mit Drücken der Reset-Taste und gleichzeitiger Ausgabe eines Pixeltaktes Zähler U2404 resetten. An den Ausgängen 2..10 von U2404 steht der Zählerstand Null an. Weitere Pixeltakte ausgeben.


Seite 3- 97

Der Zähler U2404 zählt dann mit jeden Pixeltakt um Eins hoch. (Kontrolle an den Ausgängen 2..10 von U2404) Bei den Zählerständen 0 bis 38 ergeben sich die folgenden Zustände an den Eingängen des Decoders U2401: #incr_pointer_char_write U2401/3

#decr_pointer_char_write U2401/2

#res_pointer_char_write U2401/1

L H H Wenn man den Zählerstand am Simulator für U3201 verschieden von 6 einstellt, dann gehen alle in der obigen Tabelle aufgeführten Eingänge des Decoders U2401 auf H. Mit dem Erreichen des Zählerstandes 39 ergeben sich die folgenden Zustände an den Eingängen des Decoders U2401: #incr_pointer_char_write U2401/3



H H L Das Signal #last_char geht mit dem Erreichen des Zählerstandes 39 auf L Wenn man den Zählerstand am Simulator für U3201 verschieden von 6 einstellt, dann gehen alle in der obigen Tabelle aufgeführten Eingänge des Decoders U2401 auf H. Bei der Ausgabe eines weiteren Pixeltaktes stellt sich erneut der Zählerstand 0 ein. (Kontrolle an den Ausgängen 2..10 von U2404) Bei der dann folgenden Ausgabe weiterer Pixeltakte zählt der Zähler erneut hoch. Verhalten bei Linefeed: An Simulator in U3101 Datenausgang auf 0Ah stellen ( char = LF) Es ergeben sich die folgenden Zustände an den Eingängen des Decoders U2401: #incr_pointer_char_write U2401/3



H H L Wenn man den Zählerstand am Simulator für U3201 verschieden von 6 einstellt, dann gehen alle in der obigen Tabelle aufgeführten Eingänge des Decoders U2401 auf H. Nach der Ausgabe eines Pixeltaktes stellt sich der Zählerstand 0 ein. (Kontrolle an den Ausgängen 2..10 von U2404) Bei der dann folgenden Ausgabe weiterer Pixeltakte bleibt der Zähler auf 0 stehen.


Seite 3- 98

Verhalten bei Backspace: Der Zählerstand wird zunächst gemäss dem vorvergangenen Testschritt „Verhalten bei ‚normalen‘ Zeichen auf einen Wert größer Null gebracht. Anschliessend Simulator in U3101 Datenausgang auf 08h stellen ( char = BS) Es ergeben sich die folgenden Zustände an den Eingängen des Decoders U2401: #incr_pointer_char_write U2401/3



H L H Wenn man den Zählerstand am Simulator für U3201 verschieden von 6 einstellt, dann gehen alle in der obigen Tabelle aufgeführten Eingänge des Decoders U2401 auf H. Mit der Ausgabe eines Pixeltaktes zählt der Zähler U2404 um Eins abwärts. (Kontrolle an den Ausgängen 2..10 von U2404) Wenn der Zählerstand Null erreicht ist, dann ergeben sich die folgenden Zustände an den Eingängen des Decoders U2401: #incr_pointer_char_write U2401/3



H H H Das Signal #first_char geht mit dem Erreichen des Zählerstandes 0 auf L Bei der Ausgabe weiterer Pixeltakte bleibt der Zähler auf 0 stehen. (Kontrolle an den Ausgängen 2..10 von U2404) Anmerkung: Die Backspace-Funktion ist nur innerhalb der aktuellen Zeile möglich, kein Zurückgehen zur vorigen Zeile Verhalten bei Clearscreen: An Simulator in U3101 Datenausgang auf 0Ch stellen ( char = CLS) Es ergeben sich die folgenden Zustände an den Eingängen des Decoders U2401: #incr_pointer_char_write U2401/3



H H L Nach der Ausgabe eines Pixeltaktes stellt sich der Zählerstand 0 ein. Bei der Ausgabe weiterer Pixeltakte bleibt der Zähler auf 0 stehen. (Kontrolle an den Ausgängen 2..10 von U2404)

Schritt 25: Pointer Text Line Write


Seite 3- 99

Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Baustein 74F269 in Fassung U2502. Simulator 74F269 in Fassung U3201 FIFO-Simulator in Fassung U3101 (Für Character-Output) Steuern der Signale - #res_pointer_text_line_write - #incr_pointer_text_line_write wie in Testschritt „Decoder Statemachine Write“ über Variation Zählerstand Simulator U3201, Character Output an Simulator FIFO. Hierbei manuelles Auslösen einzelner Pixeltakte. Kontrolle der Signale pointer_text_line_write[4..0] mit dem Oszilloskop hierbei folgende Funktionen kontrollieren: - Resetten über Reset - Hochzählen über Zeilenende - Hochzählen über LF - Resetten über CLS - Resetten über LF - Resetten über Zeilenende Simulator in U3201 auf Zählerstand 06h stellen (S4 Statemachine Write) Verhalten bei „normalen“ Zeichen: An Simulator in U3101 Datenausgang auf 00h stellen („normales“ Zeichen) Mit Drücken der Reset-Taste und gleichzeitiger Ausgabe eines Pixeltaktes Zähler U2502 resetten. An den Ausgängen 2..10 von U2502 steht der Zählerstand Null an. Es ergeben sich die folgenden Zustände an den Eingängen des Decoders U2501: #incr_pointer_text_line_write U2501/2

#res_pointer_text_line_write U2501/1

L H Wenn man den Zählerstand am Simulator für U3201verschieden von 6 einstellt, dann gehen alle in der obigen Tabelle aufgeführten Eingänge des Decoders U2501 auf H. Mit der Ausgabe von Pixeltakten zählt der Zähler jeweils um Eins nach oben. (Kontrolle an den Ausgängen 2..10 von U2502) Beim Erreichen des Zählerstandes 19 ergeben sich die folgenden Zustände an den Eingängen des Decoders U2501: #incr_pointer_text_line_write U2501/2


H L Wenn man den Zählerstand am Simulator für U3201verschieden von 6 einstellt, dann gehen alle in der obigen Tabelle aufgeführten Eingänge des Decoders U2501 auf H. Mit dem Erreichen des Zählerstandes 19 geht das signal #last_line auf L.


Seite 3- 100

Mit der Ausgabe eines weiteren Pixeltaktes stellt sich der Zählerstand 0 ein. Bei der Ausgabe weiterer Pixeltakte zählt der Zähler erneut hoch. Verhalten bei Linefeed: An Simulator in U3101 Datenausgang auf 0Ah stellen (char = LF) Es ergeben sich die folgenden Zustände an den Eingängen des Decoders U2501: #incr_pointer_text_line_write U2501/2


L H Mit der Ausgabe von Pixeltakten zählt der Zähler jeweils um Eins nach oben. (Kontrolle an den Ausgängen 2..10 von U2502) Verhalten bei Clearscreen: An Simulator in U3101 Datenausgang auf 0Ch stellen ( char = CLS) Es ergeben sich die folgenden Zustände an den Eingängen des Decoders U2501: #incr_pointer_text_line_write U2501/2


H L Wenn man den Zählerstand am Simulator für U3201verschieden von 6 einstellt, dann gehen alle in der obigen Tabelle aufgeführten Eingänge des Decoders U2501 auf H. Nach der Ausgabe eines Pixeltaktes stellt sich der Zählerstand 0 ein. Bei der Ausgabe weiterer Pixeltakte bleibt der Zähler auf 0 stehen. (Kontrolle an den Ausgängen 2..10 von U2502)

Schritt 26: Pointer Text Line Scroll Offset Dieser Testablauf bezieht sich auf die durch Nachverdrahtung korrigierte Schaltung. Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Baustein 74F269 in Fassung U2602. Simulator 74F269 in Fassung U3201 Simulator 74F269 in Fassung U2404 (für #last_char) Simulator FIFO in Fassung U3101 (Für Character-Output) Simulator 74F74 in Fassung U2211 (für Signal scroll) Steuern der Signale - #res_pointer_text_line_offset - #incr_pointer_text_line_offset


Seite 3- 101

wie in Testschritt „Decoder Statemachine Write“ über Variation Zählerstand Simulator U3201, Character Output an Simulator FIFO und Signal Scroll (Simulator U1403) Hierbei manuelles Auslösen einzelner Pixeltakte. Kontrolle der Signale pointer_text_line_scroll_offset[4..0] mit dem Oszilloskop hierbei folgende Funktionen kontrollieren: - Resetten über Reset - Hochzählen über Zeilenende (bedingt durch scroll-Flag) - Hochzählen über LF (bedingt durch scroll-Flag) - Resetten über CLS - Resetten über LF (Bedingt durch max. Offset) - Resetten über Zeilenende (Bedingt durch max. Offset) Simulator in U3201 auf Zählerstand 06h stellen (S4 Statemachine Write) Simulator in U2211 so einstellen, dass das Signal scroll auf H ist.

scroll ist H

scroll ist L

U2211

Verhalten bei „normalen“ Zeichen: An Simulator in U3101 Datenausgang auf 00h stellen („normales“ Zeichen) An Simulator in U2404 Zählerstand 39 = 27h einstellen. (Signal #last_char auf L) Mit Drücken der Reset-Taste und gleichzeitiger Ausgabe eines Pixeltaktes Zähler U2602 resetten. An den Ausgängen 2..10 von U2602 steht der Zählerstand Null an. Es ergeben sich die folgenden Zustände an den Eingängen des Decoders U2501: #incr_pointer_text_line_offset U2601/2

#res_pointer_text_line_offset U2601/1

L H Wenn man den Zählerstand am Simulator für U3201verschieden von 6 einstellt, dann gehen alle in der obigen Tabelle aufgeführten Eingänge des Decoders U2601 auf H. Mit der Ausgabe von Pixeltakten zählt der Zähler jeweils um Eins nach oben. (Kontrolle an den Ausgängen 2..10 von U2602)


Seite 3- 102

Beim Erreichen des Zählerstandes 19 ergeben sich die folgenden Zustände an den Eingängen des Decoders U2601: #incr_pointer_text_line_offset U2601/2


H L Wenn man den Zählerstand am Simulator für U3201verschieden von 6 einstellt, dann gehen alle in der obigen Tabelle aufgeführten Eingänge des Decoders U2601 auf H. Mit dem Erreichen des Zählerstandes 19 geht das signal #max_offset auf L. Mit der Ausgabe eines weiteren Pixeltaktes stellt sich der Zählerstand 0 ein. Bei der Ausgabe weiterer Pixeltakte zählt der Zähler erneut hoch. Verhalten bei Linefeed: An Simulator in U3101 Datenausgang auf 0Ah stellen (char = LF) An Simulator in U2404 Zählerstand auf verschieden von 39 = 27h einstellen. (Signal #last_char auf H) Es ergeben sich die folgenden Zustände an den Eingängen des Decoders U2501: #incr_pointer_text_line_offset U2601/2


L H Mit der Ausgabe von Pixeltakten zählt der Zähler jeweils um Eins nach oben. (Kontrolle an den Ausgängen 2..10 von U2602) Verhalten bei Clearscreen: An Simulator in U3101 Datenausgang auf 0Ch stellen ( char = CLS) Es ergeben sich die folgenden Zustände an den Eingängen des Decoders U2501: #incr_pointer_text_line_offset U2601/2


H L Wenn man den Zählerstand am Simulator für U3201verschieden von 6 einstellt, dann gehen alle in der obigen Tabelle aufgeführten Eingänge des Decoders U2601 auf H. Nach der Ausgabe eines Pixeltaktes stellt sich der Zählerstand 0 ein. Bei der Ausgabe weiterer Pixeltakte bleibt der Zähler auf 0 stehen. (Kontrolle an den Ausgängen 2..10 von U2602)

Schritt 27: Statemachine Write Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Baustein 74F269 in Fassung U3201 FIFO-Simulator in Fassung U3101 (Für Character-Output und #FIFO_EF) 74F74-Simulator in Fassung U1402 (für Signal transfer_en)


Seite 3- 103

Freigabe/Sperren der Statemachine durch Variation der Signale transfer_en und #FIFO_EF. Manuelles Auslösen einzelner Pixeltakte Beobachtung der Signale #S0, S2,S4 und #S5 sowie #FIFO_read und #ram_we mit dem Oszilloskop. Kontrolle des Beendes eines Zyklusses beim Sperren während des laufrnden Zyklusses.

transfer_en ist L

U1402

transfer_en ist H


EF FF

Schritt 1: #FIFO_EF wird auf H gesetzt. transfer_en wird auf L gesetzt. Ausgabe eines Pixeltaktes. Es stellen sich die folgenden Verhältnisse ein: #S0 U3202/15

S2 U3214/11

S4 U3208/4

#S5 U3202/7

#ram_we U3214/3

#fifo_read U3214/8

Kommentar

L L L H H H


Seite 3- 104

Schritt 2: transfer_en wird auf H gesetzt. Ausgabe eines Pixeltaktes. Es stellen sich die folgenden Verhältnisse ein: #S0 U3202/15

S2 U3214/11

S4 U3208/4

#S5 U3202/7

#ram_we U3214/3

#fifo_read U3214/8

Kommentar

H L L H H L Schritt 3: Ausgabe von drei Pixeltakten. Es stellen sich die folgenden Verhältnisse ein: #S0 U3202/15

S2 U3214/11

S4 U3208/4

#S5 U3202/7

#ram_we U3214/3

#fifo_read U3214/8

Kommentar

H H L H L* L * L-Pegel nur dann, wenn am FIFO-Simulator nicht CLS =0Ch oder BS =08h eingestellt ist

Schritt 4: Ausgabe eines Pixeltaktes. Es stellen sich die folgenden Verhältnisse ein: #S0 U3202/15

S2 U3214/11

S4 U3208/4

#S5 U3202/7

#ram_we U3214/3

#fifo_read U3214/8

Kommentar

H L L H H L Schritt 5: Ausgabe eines Pixeltaktes. Es stellen sich die folgenden Verhältnisse ein: #S0 U3202/15

S2 U3214/11

S4 U3208/4

#S5 U3202/7

#ram_we U3214/3

#fifo_read U3214/8

Kommentar

H L H H H L Schritt 6:


Seite 3- 105

Ausgabe eines Pixeltaktes. Es stellen sich die folgenden Verhältnisse ein: #S0 U3202/15

S2 U3214/11

S4 U3208/4

#S5 U3202/7

#ram_we U3214/3

#fifo_read U3214/8

Kommentar

H L L L H H Schritt 7: Ausgabe eines Pixeltaktes. Es stellen sich die folgenden Verhältnisse ein: #S0 U3202/15

S2 U3214/11

S4 U3208/4

#S5 U3202/7

#ram_we U3214/3

#fifo_read U3214/8

Kommentar

L L L H H H Der Ausgangs-zustand ist wieder erreicht..

Schritt 8: transfer_en wird auf L gesetzt. Ausgabe eines oder mehrerer Pixeltakte. Der Zustand aus Schritt 7 bleibt erhalten. transfer_en wird wieder auf H gesetzt. #FIFO_EF wird auf L gesetzt. Ausgabe eines oder mehrerer Pixeltakte. Der Zustand aus Schritt 7 bleibt erhalten. Der Ablauf der Schritte 1 bis 7 wird wiederholt. Während Schritt 4 wird das Signal #_FIFO_EF auf L gesetzt. Der Ablauf geht unbeeinflusst weiter. Nach dem Erreichen von Schritt 7 ändern sich die Zustände nicht mehr. Der Ablauf der Schritte 1 bis 7 wird wiederholt. Während Schritt 4 wird das Signal transfer_en auf L gesetzt. Der Ablauf geht unbeeinflusst weiter. Nach dem Erreichen von Schritt 7 ändern sich die Zustände nicht mehr.


Seite 3- 106

Schritt 28: Statemachine Write und Write-Pointer im Zusammenhang / Textspeicher Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Baustein 74F269 in Fassung U3201 Baustein IDT7134 in Fassung U1201 Baustein 74F269 in Fassung U2404 FIFO-Simulator in Fassung U3101 (Für Character-Output und #FIFO_EF) 74F74-Simulator in Fassung U1402 (für Signal transfer_en) Simulator 74F269 in Fassung U1505 (für Signal pointer_char_read_[5..0]) Simulator 74F269 in Fassung U1506 (für Signal pointer_text_line_read_[4..0]) Kontrolle der Steuersignale und Pointer mit dem Oszilloskop. „Durchspielen“ relevanter Sequenzen: - Schreiben „normaler“ Zeichen - Zeilenumbruch durch LF - Zurückgehen durch BS - Rücksetzen durch CLS - Scrollen Auslesen des Textspeichers U2101. die Adressierung wird mit den Simulatoren an U1505 und U1506 durchgeführt. Kontrolle der aus dem Textspeicher ausgelesenen Daten am Ausgang U2101 (besser zu erreichen an Fassung U2107) mit dem Oszilloskop. Prüfung der grundsätzlichen Funktion und der Wirkung des LF-Zeichens: Schritt 1: Ausgabe eines Resets und zwei Pixeltakten bei gedrückter Reset-Taste (Pipeline) Schritt 2: #FIFO_EF wird auf H gesetzt. transfer_en wird auf H gesetzt.


Seite 3- 107

transfer_en ist L

U1402

transfer_en ist H


EF FF

Schritt 3: Zu übertragenden Character 01 am FIFO-Datenausgang einstellen. Schritt 4: Ausgabe von 8 Pixeltakten. (Überprüfung der Wirkung am Signal #S0 (U3202/15)) Schritt 5: transfer_en wird auf L gesetzt. (stoppen der Übertragung) Schritt 6: Auslesen des Zeichens aus dem Textspeicher. Das Zeichen steht an der Adresse Null. Am Simulator U1506 den Zählerstand 00 einstellen (pointer_text_line_read) Am Simulator U1505 den Zählerstand 00 einstellen (pointer_char_read) An der Fassung von U2107 steht nun das zuvor gespeicherte Datenwort an:


Seite 3- 108

U2107/2 Bit 0 H U2107/4 Bit 1 L U2107/6 Bit 2 L U2107/8 Bit 3 L U2107/11 Bit 4 L U2107/13 Bit 5 L U2107/15 Bit 6 L U2107/17 Bit 7 L Es werden weiterhin die folgenden Character gemäß der Schritte 3 und 4 gespeichert: 02 04 09 0A (=LF) 0F Anschliessend wird der Speicher durch Einstellung der Adresse an den Simulatoren in U1506 und in U1505 und Kontrolle der Signale an der Fassung von U2107 ausgelesen. Hierbei zeigt sich der folgende Zustand: pointer_text_line_read

pointer_char_read

U2107/ 17 Q7

U2107/ 15 Q6

U2107/ 13 Q5

U2107/ 11 Q4

U2107/ 8 Q3

U2107/ 6 Q2

U2107/ 4 Q1

U2107/ 2 Q0

Hex

0 0 L L L L L L L H 01 0 1 L L L L L L H L 02 0 2 L L L L L H L L 04 0 3 L L L L H L L H 09 0 4 L L L L H L H L 0A 1 0 L L L L H H H H 0F


Seite 3- 109

Prüfung der Wirkung des Backspace-Zeichens: Nach dem Abschluss des vorhergehenden Testschritts steht die Schreibadresse wie folgt: pointer_text line_write = 1 pointer_char_write = 1 Es wird das Zeichen 10h in den Speicher geschrieben. Der Speicher wird wie folgt ausgelesen: pointer_text_line_read

pointer_char_read

U2107/ 17 Q7

U2107/ 15 Q6

U2107/ 13 Q5

U2107/ 11 Q4

U2107/ 8 Q3

U2107/ 6 Q2

U2107/ 4 Q1

U2107/ 2 Q0

Hex

1 1 L L L H L L L L 10 Es wird nun das Zeichen BS = 08 in den Speicher geschrieben. Damit ändert sich der Inhalt des Speichers nicht. Es wird nach wie vor unverändert ausgelesen: pointer_text_line_read

pointer_char_read

U2107/ 17 Q7

U2107/ 15 Q6

U2107/ 13 Q5

U2107/ 11 Q4

U2107/ 8 Q3

U2107/ 6 Q2

U2107/ 4 Q1

U2107/ 2 Q0

Hex

1 1 L L L H L L L L 10 Nun wird das Zeichen 11h in den Speicher geschrieben. Damit wird das zuvor in der Adresse 1/1 gespeicherte Zeichen 10h überschrieben. Das erneute Auslesen bringt das folgende Ergebnis: pointer_text_line_read

pointer_char_read

U2107/ 17 Q7

U2107/ 15 Q6

U2107/ 13 Q5

U2107/ 11 Q4

U2107/ 8 Q3

U2107/ 6 Q2

U2107/ 4 Q1

U2107/ 2 Q0

Hex

1 1 L L L H L L L H 11


Seite 3- 110

Prüfung der Wirkung des CLS-Zeichens: Dieser Testschritt baut auf dem Zustand am Abschluss des vorherigen Testschrittes auf. Das Zeichen 12h wird in den Speicher geschrieben. Es kann wie folgt wieder ausgelesen werden: pointer_text_line_read

pointer_char_read

U2107/ 17 Q7

U2107/ 15 Q6

U2107/ 13 Q5

U2107/ 11 Q4

U2107/ 8 Q3

U2107/ 6 Q2

U2107/ 4 Q1

U2107/ 2 Q0

Hex

1 1 L L L H L L H L 12 Das Zeichen CLS = 0C wird in den Speicher geschrieben. Das Zeichen 03h wird in den Speicher geschrieben. Das Zeichen 03h kann nun an der Adresse 0/0 wieder ausgelesen werden: pointer_text_line_read

pointer_char_read

U2107/ 17 Q7

U2107/ 15 Q6

U2107/ 13 Q5

U2107/ 11 Q4

U2107/ 8 Q3

U2107/ 6 Q2

U2107/ 4 Q1

U2107/ 2 Q0

Hex

0 0 L L L l L L H H 03 Prüfung des Rücksprungs zum Bildanfang bei wiederholtem Eingeben eines LF-Zeichens: Dieser Testschritt baut auf dem Zustand am Abschluss des vorherigen Testschrittes auf. Es wird 19 mal in Folge das Zeichen LH = 0A gespeichert. Anschliessend wird das Zeichen 04 gespeichert. Das Zeichen 04 kann dann aus der Adresse 0/0 ausgelesen werden: pointer_text_line_read

pointer_char_read

U2107/ 17 Q7

U2107/ 15 Q6

U2107/ 13 Q5

U2107/ 11 Q4

U2107/ 8 Q3

U2107/ 6 Q2

U2107/ 4 Q1

U2107/ 2 Q0

Hex

0 0 L L L l L H L L 04


Seite 3- 111

Schritt 29: FIFO-Zugriffssignale Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Baustein 74F269 in Fassung U3201 FIFO-Simulator in Fassung U3101 (Für Character-Output und #FIFO_EF) 74F74-Simulator in Fassung U1402 (für Signal transfer_en) Kontrolle der Funktion des Schieberegisters aus U3102A und U3102B nach dem Reset bei manueller Ausgabe des Pixeltaktes: Reset auslösen. U3102/5 ist auf L U3102/8 ist auf H Ausgabe eines Pixeltaktes U3102/5 ist auf H U3102/8 ist auf H Ausgabe eines Pixeltaktes U3102/5 ist auf H U3102/8 ist auf L Buszugriff über Testadapter, Schreiben in das FIFO (U3101): Sicherstellen, dass seit dem letzten Reset zwei Pixeltakte ausgegeben wurden. mem_adr[31..5] wird auf H gestellt mem_adr[4] wird auf L gestellt mem_adr[3] wird auf H gestellt mem_adr[2] wird auf L gestellt #ram_we3 wird auf L gestellt. Damit geht das Signal #sel_FIFO_write auf L Damit geht auch U3101/1 (/W) auf L Reset auslösen. Damit geht U3101/1 (/W) auf H. Zwei Pixeltakte ausgeben. Damit geht U3101/1 (/W) erneut auf L.


Seite 3- 112

Lesezugriff auf das FIFO über Zyklus der Statemachine: (#FIFO_EF und transfer_en auf H über Simulatoren) Sicherstellen, dass seit dem letzten Reset zwei Pixeltakte ausgegeben wurden.

transfer_en ist L

U1402

transfer_en ist H


EF FF

#FIFO_EF auf H stellen. transfer_en auf H stellen. Pixeltakt ausgeben (Verlassen des States S0) U3101/15 geht auf L (FIFO /R) 6 Pixeltakte ausgeben (Erreichen des States S5) U3101/15 geht auf H (FIFO /R) Pixeltakt ausgeben (Verlassen des States S0)


Seite 3- 113

U3101/15 geht auf L Reset auslösen U3101/15 geht auf H Zwei Pixeltakte ausgeben U3101/15 geht nach dem zweiten Takt auf L

Schritt 30: Datentransfer über FIFO Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Baustein IDT7204 in Fassung U3101 74F74-Simulator in Fassung U1402 (für Signal transfer_en)

transfer_en ist L

U1402

transfer_en ist H

Über den Testadapter werden Zeichen in das FIFO geschrieben. Das Signal transfer_en wird auf H gesetzt (Simulator U1402) Die ausgelesenen Zeichen werden mitdem Oszilloskop an den Ausgängen von U3101 kontrolliert. Die korrekte Funktion des Signals #FIFO_EF wird mit dem Oszilloskop kontrolliert. Schritt 1 (Schreibvorgang): transfer_en am Simulator U1402 auf L stellen. Reset auslösen. Zwei Pixeltakte ausgeben. (Pipeline FIFO-Zugrifssignale) Das Signal FIFO_EF an U3101/21 ist auf L.


Seite 3- 114

Bus-Adresse wie folgt einstellen: mem_adr[31..5] H mem_adr[4] L mem_adr[3] H mem_adr[2] L Damit geht #sel_FIFO_write auf L. an mem_d[31..24] die in das FIFO zu schreibenden Daten [ H L H L H L H L ] einstellen. Schreibvorgang durch (entprellte) Write-Taste auf Testadapter auslösen (Hierzu muss Jumper neben Taste gesteckt sein) Das Signal FIFO_EF an U3101/21 geht mit dem Beenden des Schreibvorgangs auf H Den Schreibvorgang mit einem anderen Datenwort [ L H L H L H L H ] wiederholen. Damit stehen zwei unterschiedliche Zeichen an den ersten beiden Positionen im FIFO. Schritt 2 (Lesevorgang): transfer_en am Simulator U1402 auf H stellen. Ausgeben eines Pixeltaktes Damit wird State S0 verlassen und es stellt sich ein L-Pegel am Signal /R an U3101/15 ein. Es erscheint nun das zuerst eingegebene Zeichen am Ausgang des FIFOs U3101: U3101/ 9 10 11 12 16 17 18 19 H L H L H L H L Es werden 8 weitere Pixeltakte ausgegeben. Es erscheint nun das zuletzt eingegebene Zeichen am Ausgang des FIFOs U3101: U3101/ 9 10 11 12 16 17 18 19 L H L H L H L H

Schritt 31: Erkennen der Cursor-Position Simulator 74F269 in Fassung U2404 (für Signal pointer_char_write_[5..0]) Simulator 74F269 in Fassung U2502 (für Signal pointer_text_line_write_[4..0]) Simulator 74F269 in Fassung U1505 (für Signal pointer_char_read_[5..0]) Simulator 74F269 in Fassung U1506 (für Signal pointer_text_line_read_[4..0]) Variation der verschiedenen Pointer, Überprüfung des Signals #cursor.


Seite 3- 115

Bei Gleichheit von pointer_char_read und pointer_char_write und Gleichheit von pointer_text_line_read und pointer_text_line_write geht das Signal #cursor an U2106/3 auf L. Es muss darauf geachtet werden, nachdem Erkennen der Gleichheit alle Bedingungen, die dann zur Ungleichheit führen BITWEISE EINZELN abzutesten.

Schritt 32: Statemachine Cursor Reached Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F269 in Fassung U2404 (für Signal pointer_char_write_[5..0]) Simulator 74F269 in Fassung U2502 (für Signal pointer_text_line_write_[4..0]) Simulator 74F269 in Fassung U1505 (für Signal pointer_char_read_[5..0]) Simulator 74F269 in Fassung U1506 (für Signal pointer_text_line_read_[4..0]) Simulator 74F269 in Fassung U1201 (Für video_line_count) Simulator 74F269 in Fassung U1202 (Für video_line_count) Kontrolle des Ausgangssignals der Statemachine #cursor_reached. Setzen der Statemachine über #cursor (Gleichheit der Pointer für Lesen und Scheiben einstellen, wie bei vorehrigen Testschritt „Erkennen der Cursor-Position“. Rücksetzen der Statemachine über Signal new_field, Generieren dieses Signals über video_line_count (Simulatoren U1201 und U1202) Reset auslösen. Das Signal #cursor_reached (U2211/6) geht auf H. Gleichheit zwischen beiden Pointerpaaren herstellen. Das Signal #cursor (U2106/3) geht auf L Ausgeben eines Pixeltaktes. Das Signal #cursor_reached (U2211/6) geht auf L. Gleichheit zwischen den Pointerpaaren wegnehmen. Video_line_count an den Simulatoren für U1201/2 auf 312 = 0138h stellen. Ausgeben eines Pixeltaktes Das Signal #cursor_reached (U2211/6) geht auf H. Gleichheit zwischen beiden Pointerpaaren herstellen. Ausgeben eines Pixeltaktes. Das Signal #cursor_reached (U2211/6) geht auf L. Gleichheit zwischen den Pointerpaaren wegnehmen. Video_line_count an den Simulatoren für U1201/2 auf 625 = 0271h stellen. Ausgeben eines Pixeltaktes


Seite 3- 116

Das Signal #cursor_reached (U2211/6) geht auf H.

Schritt 33: Statemachine Line Blank Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F74 in Fassung U2211A (für Signal #cursor_reached) Simulator 74F269 in Fassung U1503 (für Signal #incr_text_line_pointer_read_[4..0]) Simulator 74F269 in Fassung U1201 (Für video_line_count, für Signal new_field) Simulator 74F269 in Fassung U1202 (Für video_line_count, für Signal new_field)

#cursor_reached ist H

9

8

6

U2211

5

#cursor_reached ist L

Kontrolle des Ausgangssignals der Statemachine an U2202A/6. Rücksetzen der Statemachine über new_field: Video_line_count an den Simulatoren für U1201/2 auf 312 = 0138h stellen. Ausgeben eines Pixeltaktes U2202/6 soll auf H gehen. Video_line_count an den Simulatoren für U1201/2 auf ungleich 312 = 0138h stellen. Setzen der Statemachine über #cursor_reached UND #incr_text_line_pointer_read: Signal #cursor_reached auf L setzen (Simulator U2211) Am Simulator U1503 OEh einstellen. Damit geht das Signal #incr_text_line_pointer_read auf L


Seite 3- 117

Ausgeben eines Pixeltaktes U2202/6 soll auf L gehen. Nochmaliges Rücksetzen der Statemachine über new_field: Video_line_count an den Simulatoren für U1201/2 auf 312 = 0138h stellen. Ausgeben eines Pixeltaktes U2202/6 soll auf H gehen. Video_line_count an den Simulatoren für U1201/2 auf ungleich 312 = 0138h stellen. Test des Blockieren des Setzens der Statemachine: Signal #cursor_reached auf H setzen (Simulator U2211) Am Simulator U1503 OEh einstellen. Ausgeben eines Pixeltaktes U2202/6 soll auf H bleiben. Signal #cursor_reached auf L setzen (Simulator U2211) Am Simulator U1503 ungleich OEh einstellen. Ausgeben eines Pixeltaktes U2202/6 soll auf H bleiben.


Seite 3- 118

Schritt 34: Comparator LF Simulator RAM7134 in U2101 Einstellen von LF und anderen Zeichen Kontrolle des Ausgangssignals an Comparator U2107/19 Beim Einstellen von LF = 0A am Simulator U2101 geht U2107/19 auf L Beim Einstellen anderer Werte geht U2107/19 auf H Bedingungen für Ungleichheit bitweise einzeln testen mit: 0 1 0 2 0 8 0 4 1 0 2 0 4 0 8 0

Schritt 35: Statemachine Character Blank Dieser Testablauf bezieht sich auf die durch Nachverdrahtung korrigierte Version der Schaltung vom 14.08.2016. Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator RAM7134 in U2101(für Signal #char=LF über Comparator U2107) Simulator 74F269 in Fassung U2404 (für Signal pointer_char_write_[5..0], für Signal #cursor) Simulator 74F269 in Fassung U2502 (für Signal pointer_text_line_write_[4..0] für Signal #cursor) Simulator 74F269 in Fassung U1505 (für Signal pointer_char_read_[5..0] für Signal #cursor) Simulator 74F269 in Fassung U1506 (für Signal pointer_text_line_read_[4..0] für Signal #cursor) Simulator 74F269 in Fassung U1101 (Für hor_pix_count) Simulator 74F269 in Fassung U1102 (Für hor_pix_count) Simulator für 74F269 /RCO-Signal in Fassung U1501 (für Signal #incr_char_pointer_read) Achtung: Es sind nur 6 Simulatoren 74F269 vorhanden, daher Simulation des L-Pegels des /RCO-Signals durch Kurzschluss anch Masse mit Kabel mit 2 IC-Kontakten (aus Testequipment UART entnehmen) /RCO ist an Pin 14, GND ist an Pin 7 (bei 74F269 ungewöhliche Pinbelegung für GND und Vcc)) Simulator 74F74 in Fassung U1304 (für Signal active pixel)


Seite 3- 119

active_pixel ist H

U1304

active_pixel ist L

Setzen und Rücksetzen der Statemachine mit den relevanten Signalkombinationen, Kontrolle des Ausgangssignals an U2202B/8 Rücksetzen durch #hor_pix_count=944_unreg: hor_pix_count (Simulatoren U1101 und U1102) auf 944 = 03B0 einstellen. Ausgabe eines Pixeltaktes. An U2202/8 stellt sich ein H-Pegel ein. hor_pix_count (Simulatoren U1101 und U1102) auf ungleich 944 = 03B0 einstellen. Setzen durch #char = LF UND #incr_char_pointer_read_del2: Signal active_pixel am Simulator U1402 auf L stellen. Ungleichheit zwischen beiden Pointerpaaren herstellen. (Simulatoren U1505, U1506, U2404, U2502) Das Signal #cursor (U2106/3) geht auf H Simulator in U2101 auf 0A ( = LF ) stellen Damit geht das Signal #char=LF auf L. #incr_char_pointer_read durch Stecken der Brücke für /RCO an Simulator U1501 auf L stellen. Ausgabe von 3 Pixeltakten. (2.stufige Pipeline in #incr_char_pointer_read_del2) An U2202/8 stellt sich ein H-Pegel ein.


Seite 3- 120

Nochmaliges Rücksetzen durch #hor_pix_count=944_unreg: hor_pix_count (Simulatoren U1101 und U1102) auf 944 = 03B0 einstellen. Ausgabe eines Pixeltaktes. An U2202/8 stellt sich ein H-Pegel ein. hor_pix_count (Simulatoren U1101 und U1102) auf ungleich 944 = 03B0 einstellen. Setzen durch #cursor UND #incr_char_pointer_read_del2: Signal active_pixel am Simulator U1402 auf L stellen. Gleichheit zwischen beiden Pointerpaaren herstellen. (Simulatoren U1505, U1506, U2404, U2502) Das Signal #cursor (U2106/3) geht auf L Simulator in U2101 auf ungleich 0A ( = LF ) stellen Damit geht das Signal #char=LF auf H. #incr_char_pointer_read durch Stecken der Brücke von /RCO nach GND an Fassung U1501 auf L stellen. Ausgabe von 3 Pixeltakten. (2.stufige Pipeline in #incr_char_pointer_read_del2) An U2202/8 stellt sich ein H-Pegel ein. #incr_char_pointer_read durch Herausnehmen der Brücke von /RCO nach GND an Fassung U1501 auf H stellen. Nochmaliges Rücksetzen durch #hor_pix_count=944_unreg: hor_pix_count (Simulatoren U1101 und U1102) auf 944 = 03B0 einstellen. Ausgabe eines Pixeltaktes. An U2202/8 stellt sich ein H-Pegel ein. hor_pix_count (Simulatoren U1101 und U1102) auf ungleich 944 = 03B0 einstellen. Setzen durch #cursor UND L-zu-H-Übergang von active_pixel Gleichheit zwischen beiden Pointerpaaren herstellen. (Simulatoren U1505, U1506, U2404, U2502) Das Signal #cursor (U2106/3) geht auf L Simulator in U2101 auf ungleich 0A ( = LF ) stellen Damit geht das Signal #char=LF auf H. Signal active_pixel am Simulator U1402 auf L stellen. Ausgabe eines Pixeltaktes Signal active_pixel am Simulator U1402 auf H stellen.


Seite 3- 121

Ausgabe eines Pixeltaktes An U2202/8 stellt sich ein H-Pegel ein.


Seite 3- 122

Schritt 36: Character-Multiplexer Pixeltakt auf Oszillatorbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf H stelllen) Simulator 74F269 in Fassung U2404 (für Signal pointer_char_write_[5..0], für Signal #cursor) Simulator 74F269 in Fassung U2502 (für Signal pointer_text_line_write_[4..0] für Signal #cursor) Simulator 74F269 in Fassung U1505 (für Signal pointer_char_read_[5..0] für Signal #cursor) Simulator 74F269 in Fassung U1506 (für Signal pointer_text_line_read_[4..0] für Signal #cursor) Simulator 74F74 in Fassung U2202 (Für zeilen- und characterbezogene Blanking-Signale) Simulator RAM7134 in U2101(für Character-Output aus RAM) Signal cursor_en über Bus-Schreibzugriff von Testadapter auf Parallelport auf H setzen Kontrolle des Signals char[7..0] mit dem Oszilloskop Testen des am Ausgang des Multiplexers ausgegebenen Characters anhand der relevanten Signalkombinationen. Die folgende Skizze verdeutlicht die Wirkzusammenhänge bei diesem Test:


Seite 3- 123

IDT7134

pointer_text_line_write[4..0]

char_mem_out[7..0]

Textspeicher

pointer_text_line_read[4..0]

#cursor(Decoder)

U2404

#ram_we3

74F269

#text_line_blank

pointer_char_read[5..0]

aktiv (L) wenn:

pointer char read/writeidentisch

AND

pointer text_lineread/write identisch

#blank

pointer_char_write[5..0]

74F269

Daten: xxxx xxx0 = cursor off

U2202

Oszillator2Hz

74F269

cursor_en

=

U1506

#cursor

=

Pipeline2-stufig

Adresse[31..2] <= [ H..H L H H]

#character_blank

Über Bus:

Daten: xxxx xxx1 = cursor on

74F74

U150574F269

U2101

U2502


Seite 3- 124

#text_line_blank ist H

6

9

#character_blank ist H

U2202

5

#text_line_blank ist L

8#character_blank ist L

Schritt 1: Herstellen der Gleichheit aller 4 Pointer. Ausgabe von cursor_en = H über den Bus (Adresse / Daten siehe Skizze) #character_blank wird auf H gesetzt #text line_blank wird auf H gesetzt An U2206 / 11..18 wird mit einer Frequenz von ca. 2Hz zwischen den folgenden Zeichen gewechselt: U2206/ 11...18 H H L H H H L L Cursor L L H L L L L L Blank Schritt 2: Herstellen der Gleichheit aller 4 Pointer. Ausgabe von cursor_en = H über den Bus (Adresse / Daten siehe Skizze) #character_blank wird auf L gesetzt #text line_blank wird auf H gesetzt An U2206 / 11..18 wird mit einer Frequenz von ca. 2Hz zwischen den folgenden Zeichen gewechselt: U2206/ 11...18 H H L H H H L L Cursor L L H L L L L L Blank Schritt 3: Herstellen der Gleichheit aller 4 Pointer.


Seite 3- 125

Ausgabe von cursor_en = H über den Bus (Adresse / Daten siehe Skizze) #character_blank wird auf H gesetzt #text line_blank wird auf L gesetzt An U2206 / 11..18 wird mit einer Frequenz von ca. 2Hz zwischen den folgenden Zeichen gewechselt: U2206/ 11...18 H H L H H H L L Cursor L L H L L L L L Blank Schritt 4: Herstellen der Gleichheit aller 4 Pointer. Ausgabe von cursor_en = L über den Bus (Adresse / Daten siehe Skizze) #character_blank wird auf H gesetzt #text line_blank wird auf H gesetzt An U2206 / 11..18 erscheint das folgende Zeichen: U2206/ 11...18 L L H L L L L L Blank Schritt 5: Herstellen von Ungleichheit bei den Pointern char... Beibehalten der Gleichheit bei den Pointern text_line... Ausgabe von cursor_en = H über den Bus (Adresse / Daten siehe Skizze) #character_blank wird auf H gesetzt #text line_blank wird auf H gesetzt Ausgabe der Zeichen 1,2,4,8....64,128 am Simulator U2101 (Textspeicher) An U2206 / 11..18 erscheint jeweils das Zeichen, das am Simulator ausgegeben wird. Schritt 6: Herstellen von Ungleichheit bei den Pointern text_line... Wiederherstellen der Gleichheit bei den Pointern char... Ausgabe von cursor_en = H über den Bus (Adresse / Daten siehe Skizze) #character_blank wird auf H gesetzt #text line_blank wird auf H gesetzt Ausgabe des Zeichens 01 am Simulator U2101 (Textspeicher) Dieses Zeichen erscheint an U2206 / 11..18. An U2206 / 11..18 erscheint jeweils das Zeichen, das am Simulator ausgegeben wird.


Seite 3- 126

Schritt 7: Herstellen der Ungleichheit zwischen den Pointern. Ausgabe von cursor_en = H über den Bus (Adresse / Daten siehe Skizze) #character_blank wird auf L gesetzt #text line_blank wird auf H gesetzt An U2206 / 11..18 erscheint das folgende Zeichen: U2206/ 11...18 L L H L L L L L Blank Schritt 7: Beibehalten der Ungleichheit zwischen den Pointern. Ausgabe von cursor_en = H über den Bus (Adresse / Daten siehe Skizze) #character_blank wird auf H gesetzt #text line_blank wird auf L gesetzt An U2206 / 11..18 erscheint das folgende Zeichen: U2206/ 11...18 L L H L L L L L Blank

Schritt 37: Character-RAM Pixeltakt auf Oszillatorbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf H stelllen) Baustein 7134LA20PDG in Fassung U2301 (Zeichensatzspeicher) Simulator 74F269 in Fassung U2404 (für Signal pointer_char_write_[5..0], für Signal #cursor) Simulator 74F269 in Fassung U2502 (für Signal pointer_text_line_write_[4..0] für Signal #cursor) Simulator 74F269 in Fassung U1505 (für Signal pointer_char_read_[5..0] für Signal #cursor) Simulator 74F269 in Fassung U1506 (für Signal pointer_text_line_read_[4..0] für Signal #cursor) Simulator 74F74 in Fassung U2202 (Für zeilen- und characterbezogene Blanking-Signale) Simulator RAM7134 in U2101(für Character-Output aus RAM) Simulator 74F269 in Fassung U1503 (für Signal char_matrix_Y_[4..0]) Gemäß vorherigem Testschritt „Character-Multiplexer“ den mit dem Simulator am Ausgang des Textspeichers eingespeisten Character durchschalten. Zunächst werden die Character-Adressen überprüft. Hierfür werden die Folgenden Zeichen (jeweils in Matrix-Zeile 0) an die jeweilige Character Adresse im RAM geschrieben:


Seite 3- 127

mem_addr [13-6] (entspricht char_[0-7]!] * mem_d[24-31] (Character) 0000 0001 0000 0001 0000 0010 0000 0010 0000 0100 0000 0100 0000 1000 0000 1000 0001 0000 0001 0000 0010 0000 0010 0000 0100 0000 0100 0000 1000 0000 1000 0000 *mem_addr[5-2]=0000 Auf diese Weise wird sowohl jede Adressleitung als auch jede Datenleitung auf Fehlkontakt überprüft. Nach dem erfolgten Schreibvorgang kann mit Simulator 7134 in U2101die Leitungen zum Zeichensatzspeicher und die ausgegebene Zeile geprüft werden. Hierfür muss #cursor auf H sein, und somit #display_char_mem_out auf L. Dafür genügt es wenn Simulator 74F269 in U2404 ungleich Simulator 74F269 in U1505 eingestellt wird (pointer_char_write ungleich pointer_char_read). Äquivalent sind kann die Ungleichheit auch an den Simulatoren 2502/U1506 eingestellt werden. Nach erfolgreicher Prüfung der Adressen-, und Datenleitung wird in der Folge für jede Matrixzeile eines Characters das gleiche Verfahren angewendet. (Matrix-Adresse 0,1,2,4,8 und gleicher Wert in mem_d[24-31].

Schritt 38: Schieberegister Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F74 in Fassung U1304 (für Signal active_pixel) Simulator 74F269 in Fassung U1501 (für Signal #incr_char_pointer_read) Simulator 74F269 in Fassung U1101 (für Signal hor_pix_count_0) Test der Funktion des Schieberegisters mit den relevanten Signalkombinationen. Hierbei Pipeline-Delays der Ansteuersignale beachten. Kontrolle des Ausgangssignals an U1603/12 (QD) Zunächst wird folgende Ausgangssituation hergestellt: - active_pxl wird mit Simulator 74F74 auf L gesetzt. (Jumper gesetzt)


Seite 3- 128

- RCO am Simulator 74F269 in U1501 (#incr_char_pointer_read) wird auf H gesetzt (kein Jumper). - Simulator RAM7134 in U2301 (Zeichensatzspeicher) wird auf 81h (10000001b) gesetzt. - Simulator 74F269 in U1101 wird auf 00h gestellt (hor_pix_count_ 0) Zunächst wird der initiale Load-Vorgang getestet (load über active_pxl). Es zeigen sich die folgenden Verhältnisse: Zustand U1601/2

„B“ U1111/11 „active_pxl“

U1607/16 „pip2_out“

U1601/9 „S1“

Setze active_pxl 0. CLK

L Setze H! L L

1. CLK L H L L 2. CLK L H L L 3. CLK L H L L 4. CLK H H H H 5. CLK L H L L

Nun wird der Ausgang des Shiftregisters betrachtet. Mit dem 4. CLK lädt das Shiftregister folgende Werte. Zustand / Änderung U1602 und U1603

\[15-12] (Ausgang Shiftregister) U1601 /7(shift!) /9(load!)

4. CLK 5. CLK

1000 0001 1000 0001

0 0 1 (shift!) 0

7. CLK 8. CLK

1100 0000 1100 0000

0 0 1 0

9. CLK 10. CLK

1110 0000 1110 0000

0 0 1 0

11. CLK 12. CLK

1111 0000 1111 0000

0 0 1 0

13. CLK 14. CLK

1111 1000 1111 1000

0 0 1 0

15. CLK � Für den nächsten Load wird Simulator RAM7134 auf 00h gestellt.

1111 1100

0 0

active_pxl ist L

U1304


Seite 3- 129

� Simulator 74F269 in U1501, RCO auf L (Jumper setzen!) für #incr_char_pointer_read auf L 16. CLK

1111 1100

1 0

17. CLK 18. CLK

1111 1110 1111 1110

0 0 1 0

19. CLK 20. CLK

1111 1111 1111 1111

0 0 1 1 (load!)

21. CLK 0000 0000 0 0 Es ist zu erkennen, dass das letzte Pixel (im 4. CLK an U1602/15) sich bis zum ersten Pixel durchschiebt und der load durch die Pipeline im korrekten Takt das laden des neuen Zeichens verursacht.

Schritt 39: Ausgangsstufe Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F194 in Fassung U1603 (Bildinhalt) Simulator 74F74 in Fassung U1304 (active_pixel für Signal active_video und CSYNC) Simulator 74F74 in Fassung U1402 (active_line für Signal active_video) Einstellen des Signals video_en durch Buszugriff auf den Parallelport vom Testadapter aus. Kontrolle des Ausgangspegels an U1708/6 und J1701/1anhand der relvanten Signalkombinationen. Pipelibe-Delay con CSYNC und active_video beachten. Folgende Einstellungen werden für den Test genutzt: - Kein Jumper auf Simulator 74F194 � Pixel „weiß“. Änderung hier nicht notwendig, da das

Schwarzlevel Priorität hat. - Simulator 74F74 für active_pixel und CSYNC wurde wie folgt genutzt:

Wird ein Jumper entfernt ist das jeweilige Signal auf H. - Simulator 74F74 für active_line wird wie folgt genutzt:

active_pxl ist L

U1304

CSYNC ist L


Seite 3- 130

Wird der Jumper entfernt gilt active_line ist H. Es zeit sich das folgendes Verhalten: Zustand Pegel am U1708/6, bzw Video-Ausgang

Beobachtetes Verhalten Video_en auf H (beschreiben PP!) CSYNC auf H (kein Jumper) active_line auf L (setze Jumper) active_pixel auf L (setze Jumper)

� Blank, kein SNYC

1.6 V – korrekter Wert

Setze CSYNC auf L (setze Jumper) � 4x CLK (Pipeline!)

Pegel ändert sich zum letzen CLK-Puls auf 1V – korrekter Wert

Setze CSYNC wieder auf H (entferne Jumper) � 4x CLK (Pipeline)

Pegel geht zurück auf 1.6 V

active_line auf H (entferne Jumper) active_pxl auf H (entferne Jumper)

� CLK 5x (Pipeline)

active_video an U1606/2 auf H 3.0 V – korrekter Wert

Die Spannungspegel an J1701/1 sind bedingt durch den Koppelkondensator nicht statisch messbar.

active_line ist L

U1304


Seite 3- 131

Schritt 40: Interrupt-Schaltung (nachverdrahtet) Pixeltakt auf Einzelschrittbetrieb stellen. (Signal #sel_clk_test an J5101/C19 auf L stelllen) Simulator 74F269 in Fassung U1201 (für video_line_count=26) Simulator 74F269 in Fassung U1202 (für video_line_count=26) (26d = 1Ah) Test des Reset, Korrektes initialisieren Die Simulatoren werden auf einen Wert ungleich 26 eingestellt (für video_line_count=26 auf L). Nach dem Einschalten bzw. einem #reset ergeben sich folgende Werte: U NV2/2 U NV4/6 U NV4/8 U NV6 /3 U NV6 /6

� #reset H H L Z – Kann durch toggeln von B12 (mem_d26_u) überprüft werden, Pin toggelt mit!

Z - Kann durch toggeln von C17 (#ext_int) überprüft werden, Pin toggelt mit!

Durch U NV4/6 auf H ist der die Statemachine „deaktiviert“ (#en auf H). Ausgang U NV/8 auf L entkoppelt #ext_int vom Bus. CLK Impulse ändern nichts an diesem Zustand. Die Überprüfung von High Z an den Bus-Ausgängen wird am Pin überprüft und gleichzeitig die entsprechende Busleitung getoggelt. (Das Toggeln der Buswerte ist am Pin zu beobachten.) Das Umstellen der Simulatoren auf Video_line_count=26 hat keinen Einfluss auf den Ausgang der Statemachine. Test des korrekten Freischalten der Statemachine Der initiale Zustand kann nur mit #en auf L verlassen werden. Hierzu wird der Bus auf die Adresse #sel_PP_write ( FF F FF EC ) eingestellt. Zum /en setzen ist mem_d26 auf H notwendig. Beobachtet wird U NV3 /5. Zunächst ist dieser auf L und wird durch Setzen von #ram_we3 auf H wechseln und mit zwei CLK zum U NV5 /9 geführt. Das Verhalten ist wie folgt: U NV3 /5 U NV3 /9 U NV4 /6 (/en) U NV4 /9 U NV6 /6

� Reset H L H L Z Mem_d26 auf H #sel_PP_wr auf L

� #ram_we3 auf L

H L H L Z

� CLK H H H L Z � #ram_we3 auf

H � CLK

H H L L Z

Test Setzen Statemachine Nachdem nun /en auf L ist wird das nächste video_line_count=26 die Statemachine setzen. Es wird noch kein reset durchgeführt. Video_line_count=26 wird über die Simulatoren auf 001Ah (=26d) eingestellt. U NV4 /6 U NV4 /9 U NV6 /6 (#ext_int)


Seite 3- 132

Video_line_count=26 L L H � CLK L H L

Der Interrupt lässt sich auf dem Bus nachvollziehen, LED von C17 geht aus und Signalisiert #ext_int auf L. Rücksetzen der Statemachine #ext_int ist gerade auf L, Interrupt wurde also ausgelöst. Dies soll nun zurückgesetzt werden. Es wird die Adresse für #sel_INT_quit am Bus angelegt ( FF FF FF E4). #mem_we3 wird auf L gesetzt und mit 2x CLK zum U NV5 geführt: U NV2 /5 U NV2 /8 U NV4 /9 U NV6 /6 #sel_INT_quit auf L H L H L CLK, dann #sel_INT_quit auf H

L L H L

CLK H H H L CLK H L L Z Das Umschalten von U NV6 /6 ist am Bus zu beobachten (Schalter Busadapter von mem_d26 auf H!). Auslesen Statemachine von der CPU Für das Auslesen wird der Zustand nach Rücksetzen beschrieben, da hier ein L am Bus einfacher zu erkennen ist. Adresse für #sel_INT_rd anlegen ( FF FF FF E8 ) U NV4 /9 ist L – Kein Interrupt ! Schalter Busadapter B12 auf H (mem_d26)

� Toggeln von #mem_oe am Bus ( B16 ) führt zum Toggeln von mem_d26 (B12) Führt man diesen Test mit gesetztem Interrupt durch, ist durch den Busschalter keine Veränderung feststellbar (H bleibt auf H, den Schalter am Busadapter auf L zu setzen schließt auf Masse). Deshalb mit nicht gesetztem Interrupt testen. Test Priorität Rücksetzen /en wird auf L gesetzt (siehe oben) Simulatoren auf Vidoe_line_count=26 eingestellt. U NV5 /9 U NV4 /9 U NV6 /3 U NV6 /6 U NV2 /5 /en L L Z Z H Setzen – Video_line_count=26 CLK

L H Z L H

Video_line_count=26 bleibt

� #sel_INT_quit auf L

� CLK

L H Z L L

CLK L L Z Z L


Seite 3- 133

Schritt 41: Gesamttest (am Testadapter) Alle Simulatoren entfernen und die vorgesehenen IC-Bausteine in die entsprechenden Fassungen stecken. Anschluss eines Video-Monitors an J1701. Manuelles Beschreiben des Zeichensatzspeichers mit einigen beispielhaften Patterns Manuelles Beschreiben des Textspeichers mit relevanten Mustern Kontrolle der Darstellung auf dem Monitor. An dieser Stelle wird beispielhaft der Gesamttest beschrieben, wie er bei er Erstinbetriebnahme der Karte durchgeführt wurde. Zur Überprüfung der Funktion wurde das Zeichen „00h“ beschrieben mit einem Karomuster. Dafür wurde jede gerade Matrixzeile( incl. Zeile 0!) mit „01010101“ und jede ungerade mit 10101010“ beschrieben. Es wurde ein Treppenmuster in den FIFO eingeschrieben. Die n-te Zeile enthält n Zeichen „00h“. Mit einem „LF“ wurde dann die Treppe nach oben hin aus dem Bild geschoben. Für einen abschließenden Test wurde der Zeichensatzspeicher wie folgt manuell beschrieben: Zeichen A C F H O T U ! „blank“

(leer) „Cursor“ (voll)

Character-Adresse (mem_adr[11..6]

00h 01h 02h 03h 04h 05h 06h 07h 20h DCh

Die Bus-Adresse wurde auf auf den Zeichensatzspeicher eingestellt: mem_adr[31-15] auf H mem_adr14 auf L mem_adr[13-6] auf Zeichenadresse (Character nach obiger Tabelle) Mit mem_adr [5-2] =0d bis 13d (0000b –1101b) wurden die einzelnen Zeilen der Matrix in den Zeichensatzspeicher geschrieben. (Nach Zeichensatz-Tabelle) Den Inhalt der jeweiligen Matrix Zeile wurde in mem_d31-d24 eingestellt und mit dem entprelltem #ram_we3 Signal einspeichert (Taster auf Testboard). Der nächste Schritt war die Freigabe des Bildes und des Cursors durch video_en und cursor_en. Dafür Adresse für den Parallelport anlegen und mit #ram_we3 abschließen (entprellter Taster auf Testboard) : mem_adr[31..5] auf H mem_adr 4 auf L mem_adr [3-2] auf H mem_d[24-25] auf H (cursor_en und video_en) Nun wurde ein schwarzes Bild mit blinkendem Cursor angezeigt. (Beschreibt man zuerst den Paralellport und anschließend erst den Zeichensatzspeicher so lässt sich das Beschreiben von Cursor und Blank auf dem Bildschirm live mitverfolgen.)


Seite 3- 134

Nun wurde die Bus-Adresse auf #sel_FIFO_write eingestellet. mem_adr[31..5] auf H mem_adr 4 auf L mem_adr 3 auf H mem_adr 2 auf L Anschließend wurde die Folge der Zeichen über mem_d[31-24] eingetragen. Jedes Zeichen wurde durch den Taster #ram_we3 in den Fifo übertragen. Folgende Zeichenkette wurde übertragen: 01h|04h|01h|04h|0Ah(„LF“)| 02h|00h|06h|01h|03h|05h|07h| Somit wurde auf dem Monitor erfolgreich der Schriftzug angezeigt: „COCO FAUCHT!“

Schritt 42: Gesamttest (mit CPU) Die Baugruppe wird in einen Bussteckplatz des CPU-Moduls gesteckt. An J1701 wird ein Video-Monitor angeschlossen. Betrieb der Baugruppe mit dem dazugehörigen Testprogramm Beurteilung der Bildschirmdarstellung.


Seite 3- 135

Abbildungen

Die Gesamtansicht der Karte


Seite 3- 136

Hardware-Test mit dem Testadapter


Seite 3- 137

Test mit dem Monitor „Mainstream“ aus dem WS2004/5


Seite 3- 138

Systemtest mit CPU und Video-Monitor


Seite 3- 139

Der Gesamt-Testaufbau


Seite 3- 140

Dokumentation aller Änderungen/Nachverdrahtungen 24.07.2016 (1) Fehlender Inverter in Verknüpfung für res_scroll:


Seite 3- 141

1 Trennstelle:


Seite 3- 142

1 Trennstelle:


Seite 3- 143

2 Verbindungen:


Seite 3- 144

(2) Fehler: Kein Rücksetzen des Statemachine bei CLS in der letzten Zeile, wenn Scroll aktiv ist. set_scroll res_scroll dec D Kommentar L L 0 Q halten L H 1 L Rücksetzen H L 2 H Setzen H H 3 L war vorher Q.

(halten) Jetzt Prorität für Rücksetzen


Seite 3- 145

1 Trennstelle 1 Verbindung


Seite 3- 146

(3) Irrtümliche Invertierung Signal #first_char


Seite 3- 147

1 Trennstelle, 1 Verbindung

25.07.2016


Seite 3- 148

(4) Undefinierte Pegel bei hochohmigen FIFO führten zu starker Erwärmung des Dual-Port-RAMs und des FIFOs. Abhilfe durch Pull-Up-Widerstände.

(5) Schreibfehler bei der Definition der Statemachine (Kommentar in Wahrheitstabelle war richtig, Logikpegel waren falsch)


Seite 3- 149

2 Trennstellen:


Seite 3- 150

2 Verbindungen:


Seite 3- 151

(6) Rücksetzen Statemachine Character Blank erfolgt zum falschen Zeitpunkt

1 Trennstelle 1 Verbindung


Seite 3- 152

1 Trennstelle:


Seite 3- 153

1 Verbindung:


Seite 3- 154

27.7.2016 (7) Scroll-Offset wird eine Textzeile zu früh rückgesetzt.


Seite 3- 155

14.08.2016 (8) Veränderung Setzen Statemachine Line Blank


Seite 3- 156

Einfügen von 5 Verbindungen (Auf Basis der Trennstellen von Patch 6) Die Patch-Verbindung von U1511/4 nach U1511/5 wird wieder entfernt.


Seite 3- 157

(9)

von U1608/6 oder /16


Seite 3- 158

Die Patch-Verbindung von UNV1/3 nach U1511B wird wieder entfernt. 5 neue Verbindungen


Seite 3- 159

(10) Hinzufügen Interrupt-Ausgang siehe Schaltungsbeschreibung (11) Hinzufügen EEPROM siehe Schaltplan (12) Verschieben Bildlage nach links 24.09.2016


Seite 3- 160

die video-karte sp2-070 - fritzler-avr.defiles/doku/periph/videokarte/03_video.pdf · mixed signal...

Documents