PDA

Archiv verlassen und diese Seite im Standarddesign anzeigen : Formeln und Grundlagen



SailorSat
25-02-2007, 19:53
Hier werde ich einige Formeln und Grundlagen erläutern die ich bei der Entwicklung dieses Projekts verwendet habe.

Berechung der "realen" Auflösung anhand der aktiven Pixel
Für einen Arcade Monitor mit Standard-Auflösung (im folgenden 15KHz) benutzen wir folgende Werte:

Horizontal
Aktiv Front Sync Back Total
0,73 0,09 0,09 0,09 1,00

Vertikal
Aktiv Front Sync Back Total
0,92 0,01 0,01 0,06 1,00


Um die "realen" Pixel zu berechnen, benutzen wir folgende Formeln:

Total = Pixel / Aktiv
Start = (Aktiv + Front) * Total
Ende = (Aktiv + Front + Sync) * Total


Als Beispiel errechnen wir die Werte für die Auflösung 320*240 Pixel:


Horizontal
Aktiv = 320
Total = 320 / 0,73 = 438
Start = (0,73 + 0,09) * 438 = 0,82 * 438 = 359
Ende = (0,73 + 0,09 + 0,09) * 438 = 0,91 * 438 = 399

Vertikal
Aktiv = 240
Total = 240 / 0,92 = 261
Start = (0,92 + 0,01) * 261= 0,93 * 261= 242
Ende = (0,92 + 0,01 + 0,01) * 261= 0,94 * 261= 245


Für die Auflösung 320*240 Pixel ergeben sich also folgende Werte:

Horizontal
Aktiv Start Ende Total
320 359 399 438

Vertikal
Aktiv Start Ende Total
240 242 245 261


Dem geübten Auge fällt sofort auf das die Ergebnisse der Zahlen gerundet wurden.
Diese "Messungenauigkeit" darf man ignorieren, da jede Grafikkarte bzw. jeder Bildschirm hier eine gewisse Tolleranz hat.



Berechnen der Monitor-Frequenz
Die Frequenz berechnet sich zum einen aus der "realen" Anzahl der Zeilen, sowie der Anzahl der Bilder pro Sekunde.

Daraus ergibt sich im groben folgende Tabelle:

Standard Auflösung = 262 Zeilen die 50 bis 60 mal pro Sekunde erneuert werden
Erweiterte Auflösung = 312 Zeilen die 53 mal pro Sekunde erneuert werden
Mittlere Auflösung = 416 Zeilen die 50 bis 60 mal pro Sekunde erneuert werden
Hohe Auflösung = 525 Zeilen die 50 bis 60 mal pro Sekunde erneuert werden


Da man in der Regel von der maximalen Auflösung ausgeht ergibt sich folgende Tabelle:

Standard Auflösung = 262 Zeilen * 60 Bilder pro Sekunde = 15720 Zeilen pro Sekunde
Erweiterte Auflösung = 312 Zeilen * 53 Bilder pro Sekunde = 16536 Zeilen pro Sekunde
Mittlere Auflösung = 416 Zeilen * 60 Bilder pro Sekunde = 24960 Zeilen pro Sekunde
Hohe Auflösung = 525 Zeilen * 60 Bilder pro Sekunde = 31500 Zeilen pro Sekunde


Eine gemessene Frequenz "pro Sekunde" wird gerne mit Hertz (kurz Hz) abgekürzt und ergibt dann schließlich diese Tabelle:

Standard Auflösung = 262 Zeilen * 60 Hz = 15,7 kHz
Erweiterte Auflösung = 312 Zeilen * 53 Hz = 16,5 kHz
Mittlere Auflösung = 416 Zeilen * 60 Hz = 25,0 kHz
Hohe Auflösung = 525 Zeilen * 60 Hz = 31,5 kHz


Man bezeichnet das Endergebniss auch gerne als Horizontal-Auflösung, sowie die "Bilder pro Sekunde" als Vertikal-Auflösung.

Man kann selbstverständlich mit ein kleinwenig Rechnen bereits zu folgenden Formeln kommen:


Horizontal-Auflösung = Anzahl der Zeilen * Vertikal-Auflösung
Vertikal-Auflösung = Horizontal-Auflösung / Anzahl der Zeilen
Anzahl der Zeilen = Horizontal-Auflösung / Vertikal-Auflösung


Da wäre allerdings noch ein Wert von großer Bedeutung, nämlich die sogenannte Pixel-Frequenz, die bestimmt wie oft eine Grafikkarte die Farbsignale verändert.
Diese lässt sich allerdings ziemlich leicht berechnen:

Anzahl der Pixel = Total Horizontal * Total Vertikal
Pixel-Frequenz = Anzahl der Pixel * Bilder pro Sekunde


Um nochmal unsere Beispielauflösung von 320*240 Pixel aufzugreifen ergibt sich folgende Tabelle:


Anzahl der Pixel = 438 Pixel pro Zeile * 261 Zeilen = 114318 Pixel pro Bild
Pixel-Frequenz = 114318 Pixel pro Bild * 60 Bilder pro Sekunde = 6859080 Pixel pro Sekunde = 6,86MHz




Die "XFree86 Modeline"
Im weiteren Projekt wird mit sogenannten Modelines gearbeitet.
Eine Modeline setzt sich mit allen nötigen Informationen für eine Auflösung zusammen.

Modeline <NAME> <PIX_FREQ> <H_AKTIV> <H_START> <H_ENDE> <H_TOTAL> <V_AKTIV> <V_START> <V_ENDE> <V_TOTAL> <OPTIONEN>

Der NAME hat eigentlich nur einen kosmetischen Wert und dient lediglich der Erkennung, allerdings verwenden wir im folgenden einfach die "aktive" Auflösung.

PIX_FREQ steht für die Pixel Frequenz, angegeben in MHz.

H_AKTIV steht für die aktiven Pixel in der Breite.
H_START steht für den Beginn der Synchronisation in der Breite.
H_ENDE steht für das Ende der Synchronisation in der Breite.
H_TOTAL steht für die realen Pixel in der Breite.

V_AKTIV steht für die aktiven Zeilen in der Höhe.
V_START steht für den Beginn der Synchronisation in der Höhe.
V_ENDE steht für das Ende der Synchronisation in der Höhe.
V_TOTAL steht für die realen Zeilen in der Höhe.

OPTIONEN kann, sofern angegeben eine Reihe von Schlüsselwörtern beinhalten.

interlace gibt an, das das Bild im Zeilensprungverfahren aufgebaut wird, welches die Anzahl der sichtbaren Zeilen effektiv halbiert in dem es abwechselnd nur die graden bzw. die ungraden Zeilen darstellt.
doublescan gibt an, das das Bild im Zeilendoppelverfahren aufgebaut wird, welches die Anzahl der sichtbaren Zeilen effektiv verdoppelt, in dem es jede Zeile doppelt darstellt.
(+/-)hsync gibt an ob das horizontale Synchronisations-Signal positiv (+) oder negativ (-) ist.
(+/-)vsync gibt an ob das vertikale Synchronisations-Signal positiv (+) oder negativ (-) ist.


Hierbei sei erwähnt das 99% aller Arcademonitore mit negativer Synchronisation arbeiten.

Unsere Beispielauflösung von 320*240 Pixel sähe als Modeline wiefolgt aus:
Modeline "320x240@60" 6,86 320 359 399 438 240 242 245 261 -hsync -vsync

SailorSat
27-02-2007, 17:07
Anhang 1 - 25KHz Beispiel
Für einen Arcade Monitor mit Mittlerer Auflösung (im folgenden 25KHz) benutzen wir folgende Werte:

Horizontal
Aktiv Front Sync Back Total
0,80 0,02 0,10 0,08 1,00

Vertikal
Aktiv Front Sync Back Total
0,92 0,01 0,01 0,06 1,00



Berechnen wir als Beispielauflösung mal 512*384 Pixel bei 60Hz.


-- 25KHz Referenz --
512x384 60hz

Horizontal
aktiv = 512
total = 512 / 0,8 = 640
start = 0,82 * 640 = 524
ende = 0,92 * 640 = 588

Vertikal
aktiv = 384
total = 384 / 0,92 = 416
start = 0,93 * 416 = 386
ende = 0,94 * 416 = 391

h_freq = 416 * 60 = 24960 = 24,96 KHz

pix_tot = 640 * 416 = 266240
pix_clk = 266240 * 60 = 15974400 = 15,974 MHz

Modeline
Modeline "512x384@60" 15,974 512 524 588 640 384 386 391 416 -hsync -vsync




Anhang 2 - 31KHz Beispiel
Für einen Arcade Monitor mit Hoher Auflösung (im folgenden 31KHz) benutzen wir folgende Werte:

Horizontal
Aktiv Front Sync Back Total
0,79 0,02 0,17 0,02 1,00

Vertikal
Aktiv Front Sync Back Total
0,91 0,01 0,02 0,06 1,00



Berechnen wir als Beispielauflösung 640*480 Pixel bei 60Hz.


-- 31KHz Referenz --
640x480 60hz

Horizontal
aktiv = 640
total = 640 / 0,79 = 810
start = 0,81 * 810 = 656
ende = 0,98 * 810 = 793

Vertikal
aktiv = 480
total = 480 / 0,91 = 527
start = 0,92 * 527 = 484
ende = 0,94 * 527 = 495

h_freq = 527 * 60 = 31620 = 31,620 KHz

pix_tot = 810 * 527 = 426870
pix_clk = 426870 * 60 = 25612200 = 25,612 MHz

Modeline
Modeline "640x480@60" 25,612 640 656 793 810 480 484 495 527 -hsync -vsync