Ergebnis 1 bis 2 von 2

Thema: Formeln und Grundlagen

  1. #1
    H@ckse Avatar von SailorSat
    Registriert seit
    26.08.2004
    Ort
    Hanau (Hessen)
    Beiträge
    2.052

    Post Formeln und Grundlagen

    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:
      Code:
      	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:
      Code:
      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:
      Code:
      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:
      Code:
      	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:
      Code:
      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:
      Code:
      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:
      Code:
      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:
      Code:
      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:
      Code:
      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:

      Code:
      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
    Geändert von SailorSat (10-03-2007 um 22:10 Uhr)
    Ich mach das alles auch ohne Joystick ,)

  2. #2
    H@ckse Avatar von SailorSat
    Registriert seit
    26.08.2004
    Ort
    Hanau (Hessen)
    Beiträge
    2.052

    Post

    • Anhang 1 - 25KHz Beispiel
      Für einen Arcade Monitor mit Mittlerer Auflösung (im folgenden 25KHz) benutzen wir folgende Werte:
      Code:
      	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.
      Code:
       -- 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:
      Code:
      	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.
      Code:
       -- 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
    Geändert von SailorSat (06-08-2008 um 07:30 Uhr)
    Ich mach das alles auch ohne Joystick ,)

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •