Ein VGA Controller in VHDL mit Xilinx Spartan 3/6

In VGA Controller wird ein VGA controller für ein Altera board vorgestellt.

Problemstellung

Die Entwicklungsboards BASYS2 und NEXYS3 von Digilent haben einen VGA Anschluss. Auf der Suche nach Quellcode für die Ansteuerung findet man meistens nur eine Auflösung von 640x480 Pixeln. Diese Auflösung wird von heutigen Monitoren und Beamern schlecht oder gar nicht dagestellt. Es soll ein VGA controller in VHDL für die folgenden Auflösungen entwickelt werden.
Auflösung Bildfrequenz
800 x 600 60Hz
1024 x 768 60Hz
1280 x 1024 60Hz
1366 x 768 60Hz
1680 x 1050 60Hz
1920 x 1080 60Hz

Messung des VGA Signals

Es wird das VGA Signal eines Laptops gemessen und die Werte mit Tabellen aus dem Internet verglichen. Auf den Leitungen VSYNC, HSYNC und R,G,B wird ein serieller Datenstrom erzeugt. Jedes Bild beginnt mit einem VSYNC Puls mit der Länge VR (vertical refresh) und der Periodendauer VR+VF+VD+VB. (VF: vertical front porch, VD: vertical display, VB: vertical back porch). Diese Werte werden in der Anzahl der Zeilen angegeben. Nur während VD werden das Bilddaten ausgegeben. Jede Zeile des Bildes beginnt mit einem HSYNC Puls mit der Länge HR und der Periodendauer HR+HF+HD+HB. Während der Zeit VD werden die einzelnen Pixel mit der Pixelfrequenz ausgegeben. Die Länge von HR, HF, HD und HB werden in Pixeln angegeben. Das nächste Bild zeigt das Zeitverhalten der Signale für 2 Zeilen mit jeweils 6 Pixeln.



Das folgende Bild zeigt die Steckerbelegung mit den HSYNC und VSYNC Signalen, Red, green, blue und Masse (GND).

Um das VGA Signal zu untersuchen wurde eine Y-Weiche and den VGA Ausgang eines Laptops angeschlossen und ein externer Monitor verbunden. Das VSYNC, HSYNC und ein Farbsignal wurden mit dem Electronic Explorer Board mit der Oszilloskopfunktion aufgenommen und gleichzeitig auf dem steuernden Laptop dargestellt. Die Messanordnung sieht man in folgendem Bild.

Messergebnisse

Im folgenden Bild sieht man das HSYNC C2 in Blau, das VSYNC Signal in Gelb und ein Farbsignal in Rot. Bei jedem Zeilenanfang wird das HSYNC Signal kurze Zeit 0V (Retrace). Das VSYNC Signal ist 0V da man mitten im Bild ist. Auf dem Farbsignal kann man gut die Farbinformation einer Zeile des Bildes sehen. Am Anfang einer Zeile im nicht sichtbaren Bereich ist das Signal 0V (back porch). Dann wird erst der blaue Hintergrund als Signal dargestellt, dann das weiße Fenster mit einem höheren Pegel, bevor wieder der Hintergrund kommt (display). Auch am Ende der Zeile befindet sich ein nicht sichtbarer Bereich (front porch). Man kann das Fenster auf dem Bildschirm von rechts nach links bewegen und sieht wie sich das Farbsignal verschiebt. Das HSYNC und VSYNC Signal haben einen Pegel von 3.3V. Die Farbinformation hat einen Pegel zwischen 0V und 0.7V. Dieser Pegel wird durch Widerstände aus dem digitalen 3.3V Signal erzeugt.


Im folgenden Bild sieht man mehrere Bilder (Frames). Für jedes Bild wird ein VSYNC generiert. Das HSYNC Signal hat eine viel höhere Frequenz und man sieht die vielen Zeilenpulse eines Bildes. Die Farbinformation repräsentiert ein vollständiges Bild. Veschiebt man das Fenster mit der Oszilloskopdarstellung von oben nach unten, bewegt sich auch das Farbsignal.


Es wurden folgende Zeiten gemessen:

Auflösung Bildfrequenz VSYNC length VSYNC period HSYNC length HSYNC period
800 x 600 60Hz 105.8 us 16.66 ms 3.2 us 26.45 us
1024 x 768 60Hz 124 us low 16.66 ms 2.1 us 20.7 us
1280 x 1024 60Hz 46.8 us 16.66 ms 1.035 us 15.6us
1366 x 768 60Hz 62.8 us 16.66 ms 1.64 us 20.93 us
1680 x 1050 60Hz 91.8 us 16.66 ms 1.23 us 15.27 us
1920 x 1080 60Hz 44.6 us 16.66 ms 1.19us 14.87 us

Entwicklungsboards


Es steht ein BASYS2 Board von Digilent mit einem Spartan3E 250k Gate FPGA von Xilinx (ca 90 Euro) zur Verfügung. Auf dem Board wird von einem Timer ein nicht stabiler Takt von 50MHz erzeugt (Pin B8). Es hat sich gezeigt, dass das Bild ausfranst und die Zeilen flackern. Deshalb wurde in den vorhandenen Sockel ein Quarzoszillator eingesetzt (Pin M6). Das Board stellt nur 3.3V zur Verfügung, so dass ein 3.3V SMD Quarzoszillator auf eine Platine gelötet wurde (Conrad, 155980 SMD-Quarz Oszillator XO53-Serie 50.000MHZ XO53050UITA ca 2.20 Euro) und in den Sockel eingesteckt wurde. Ein interner Clockmanager (DCM_SP), der mit dem IP Core Generator erzeugt wurde, erlaubt es den Takt anzupassen.

Das Nexys Board hat ein Spartan6 FPGA von Xilinx und einen Quarzstabilisierten 100MHz Takt. Der Coregenerator Wizard erzeugt eine PLL_BASE primitive für 1920x1080 172MHz und ein DCM_SP für 108 MHz.



Normalerweise leitet man den benötigten Systemtakt von der Pixelfrequenz ab. Werte für HD, HF, HB, HR, VD, VF, VB, VR findet man im http://www.tinyvga.com/vga-timing . In der folgenden Tabelle werden einige Auflösungen dargestellt.
In Klammern stehen die äquivalenten Werte für 50 MHz. Hier wird der feste Takt von 50MHz verwendet und entsprechend viele horizontale Pixel zusammengefasst.

Auflösung Bildfrequenz HD HF HB HR VD VF VB VR Pixelfrequenz
800 x 600 72 Hz 800 56 64 120 600 37 23 6 50MHz
1024 x 768 (681 x 768) 70Hz 1024 (681) 24 (16) 144 (96) 136(90) 768 3 29 6 75MHz (50MHz)
1280 x 1024 (640 x 1024) 60Hz 1280 (640) 48 (24) 248 (124) 112 (56) 1024 1 38 3 108MHz (50MHz)
1366 x 768 (683 x 768) 60Hz (70Hz) 1368 (683) 72 (36) 144 (72) 216 (108) 768 1 23 3 85.86MHz (50MHz)
1680 x 1050 (560 x 1050) 60Hz 1680 (560) 104 (35) 288 (96) 184 (61) 1050 1 33 3
1920 x 1080 (548 x 1080) 60Hz 1920 (548) 119 (34) 326 (93) 207 (59) 1080 1 32 3 172MHz (50MHz)

Der VGA Controller


Ein VGA Controller soll verschiedene Eingangstakte, Auflösungen und Testmuster unterstützen. Ein Hauptmodul erlaubt die Auswahl der Auflösung und der Testmuster. Ein VGA Modul erzeugt aus den gemessenen Timingparametern (HD, HF, HB, HR, VD, VF, VB, VR) ein VSYNC, HSYNC, Video_on und die Pixelposition pixel_x, pixel_y. Da es Zeiten gibt in denen kein Pixel dargestellt werden soll gibt es noch ein Video_on Signal.

Der VGA Controller soll mit einem Testmuster verifiziert werden. Dazu wird bei bestimmten x,y Zaehlerstand ein farbiges Pixel aus den die Rot, Grün und Blau Signalen erzeugt werden. Dabei stehen auf dem Entwicklungsboard 3 Bit für Rot und Grün zur Verfügung und 2 Bit für Blau. Damit stehen 256 Farben zur Verfügung. Diese werden mit Widerständen in ein analoges Signal (DA-Wandler) gewandelt.

Clock Manager


Im Xilinx FPGAs steht ein Clock Manager zur Verfügung, der den einen internen Takt erzeugen kann. Unter IP-Cores, FPGA Features and Design, Clocking kann man den externen Takt in eine geeignete Taktfrequenz mit dem Digital Frequency Synthesizer übersetzen.
Es gilt folgende Formel: CLKFX = (CLKFX_MULTIPLY_value/CLKFX_DIVIDE_value) * FrequencyCLKIN Es wird z.B. folgender VHDL code erzeugt, wenn man die Aktion view functional model durchführt. 
  2. entity CLK_Manager is
  3. port
  4.  (-- Clock in ports
  5.   CLK_IN1           : in     std_logic;
  6.   -- Clock out ports
  7.   CLK_OUT1          : out    std_logic;
  8.   -- Status and control signals
  9.   RESET             : in     std_logic;
  10.   LOCKED            : out    std_logic
  11.  );
  12. end CLK_Manager;
  14. architecture xilinx of CLK_Manager is
  15.   attribute CORE_GENERATION_INFO : string;
  16.   -- One line which can not be broken
  17.   attribute CORE_GENERATION_INFO of xilinx : architecture is "CLK_Manager,clk_wiz_v1_8,{component_name=CLK_Manager,use_phase_alignment=true,use_min_o_jitter=false,use_max_i_jitter=false,use_dyn_phase_shift=false,use_inclk_switchover=false,use_dyn_reconfig=false,feedback_source=FDBK_AUTO,primtype_sel=DCM_SP,num_out_clk=1,clkin1_period=10.0,clkin2_period=10.0,use_power_down=false,use_reset=true,use_locked=true,use_inclk_stopped=false,use_status=false,use_freeze=false,use_clk_valid=false,feedback_type=SINGLE,clock_mgr_type=AUTO,manual_override=false}";
  18. 	  -- Input clock buffering / unused connectors
  19.   signal clkin1            : std_logic;
  20.   -- Output clock buffering
  21.   signal clkfb             : std_logic;
  22.   signal clk0              : std_logic;
  23.   signal clkdv             : std_logic;
  24.   signal clkfbout          : std_logic;
  25.   signal locked_internal   : std_logic;
  26.   signal status_internal   : std_logic_vector(7 downto 0);
  27. begin
  30.   -- Input buffering
  31.   --------------------------------------
  32.   clkin1_buf : IBUFG
  33.   port map
  34.    (O => clkin1,
  35.     I => CLK_IN1);
  38.   -- Clocking primitive
  39.   --------------------------------------
  40.   -- Instantiation of the DCM primitive
  41.   --    * Unused inputs are tied off
  42.   --    * Unused outputs are labeled unused
  43.   dcm_sp_inst: DCM_SP
  44.   generic map
  45.    (CLKDV_DIVIDE          => 2.000,
  46.     CLKFX_DIVIDE          => 1,
  47.     CLKFX_MULTIPLY        => 4,
  48.     CLKIN_DIVIDE_BY_2     => FALSE,
  49.     CLKIN_PERIOD          => 10.0,
  50.     CLKOUT_PHASE_SHIFT    => "NONE",
  51.     CLK_FEEDBACK          => "1X",
  52.     DESKEW_ADJUST         => "SYSTEM_SYNCHRONOUS",
  53.     PHASE_SHIFT           => 0,
  54.     STARTUP_WAIT          => FALSE)
  55.   port map
  56.    -- Input clock
  57.    (CLKIN                 => clkin1,
  58.     CLKFB                 => clkfb,
  59.     -- Output clocks
  60.     CLK0                  => clk0,
  61.     CLK90                 => open,
  62.     CLK180                => open,
  63.     CLK270                => open,
  64.     CLK2X                 => open,
  65.     CLK2X180              => open,
  66.     CLKFX                 => open,
  67.     CLKFX180              => open,
  68.     CLKDV                 => clkdv,
  69.    -- Ports for dynamic phase shift
  70.     PSCLK                 => '0',
  71.     PSEN                  => '0',
  72.     PSINCDEC              => '0',
  73.     PSDONE                => open,
  74.    -- Other control and status signals
  75.     LOCKED                => locked_internal,
  76.     STATUS                => status_internal,
  77.     RST                   => RESET,
  78.    -- Unused pin, tie low
  79.     DSSEN                 => '0');
  81.   LOCKED                <= locked_internal;
  84.   -- Output buffering
  85.   -------------------------------------
  86.   clkf_buf : BUFG
  87.   port map
  88.    (O => clkfb,
  89.     I => clk0);
  92.   clkout1_buf : BUFG
  93.   port map
  94.    (O   => CLK_OUT1,
  95.     I   => clkdv);
  97. end xilinx;
  98.

VHDL Code für einen VGA Controller

Als erstes der Code für den Controller.

  2. library ieee;
  3. use ieee.std_logic_1164.all;
  4. use ieee.std_logic_unsigned.all;
  5. use ieee.numeric_std.all;
  7. entity vga_gen is
  8.     generic(
  9.     -- VGA 1920x1080 sync parameters 50MHz Clock 3.5 pixels at once -> 548 x 1080 bad ok
  10.      HD: integer := 548; -- horizontal display area 640;  800
  11.      HF: integer := 34;  -- h. front porch          (8) 16;     40
  12.      HB: integer := 93;  -- h. back porch           (56) 48;    88 
  13.      HR: integer := 59;  -- h. retrace              96;    128
  14. 	 -- VD+VF+VB+VR-1 -> 1087
  15.      VD: integer := 1080; -- vertical display area   480;   600
  16.      VF: integer := 1;  -- v. front porch          (2) 11;    4
  17.      VB: integer := 32;  -- v. back porch           (41) 31;    23
  18.      VR: integer := 3   -- v. retrace               (2) 2;    1
  19. 	 );
  20.     port(
  21.         clk, not_reset: in std_logic;
  22.         hsync, vsync: out std_logic;
  23.         video_on, p_tick: out std_logic;
  24.         pixel_x, pixel_y: out std_logic_vector (11 downto 0)
  25.     );
  26. end vga_gen;
  28. architecture Behavioral of vga_gen is
  29.     -- 50 MHz Clock input
  30.     -- sync counters
  31.     signal v_count: std_logic_vector(11 downto 0);
  32.     signal h_count: std_logic_vector(11 downto 0);
  33. begin
  34.     process(clk, not_reset)
  35.     begin
  36.         if not_reset = '0' then
  37.             v_count <= (others => '0');
  38.             h_count <= (others => '0');
  39.         elsif clk'event and clk = '0' then
  40.             if (h_count < (HD + HF + HB + HR)) then
  41.                 h_count <= h_count+1;
  42.             else
  43.                 h_count <= (others => '0');
  44.             end if;
  45.             if (h_count = (HD + HF -1)) then
  46.                 if (v_count < (VD + VF + VB + VR)) then
  47.                     v_count <= v_count +1;
  48.                 else
  49.                     v_count <= (others => '0');
  50.                 end if;
  51.             end if;
  52.         end if;
  53.     end process;
  55.     -- horizontal and vertical sync
  56.     hsync <= '0' when (h_count >= (HD + HF)) and
  57.                       (h_count <= (HD + HF + HR - 1)) else
  58.              '1';
  59.     vsync <= '1' when (v_count > (VD + VF)) and
  60.                       (v_count <= (VD + VF + VR)) else
  61.              '0';
  62.     -- video on/off
  63.     video_on <= '1' when (h_count < HD) and (v_count < VD) else '0';
  65.     -- output signal
  66.     pixel_x <= h_count;
  67.     pixel_y <= v_count;
  68.     p_tick <= clk;
  69. end Behavioral;
  70.

Programm mit Testmuster



Als Testmuster bietet sich ein Diagonalmuster an. Man kann die Auflösung an derAnzahl der Rauten abzählen. Weiterhin kann man am Rand überprüfen, dass das gesamte Muster nicht abgeschnitten wird


  2. library ieee;
  3. use ieee.std_logic_1164.all;
  4. use ieee.std_logic_unsigned.all;
  5. use ieee.numeric_std.all;
  7. entity vga_Main is
  8.     port(
  9.         clk, not_reset: in std_logic;
  10.         sw:std_logic_vector(3 downto 2);
  11.         hsync, vsync: out std_logic;
  12.         vgaRed: out std_logic_vector(2 downto 0);
  13.         vgaGreen: out std_logic_vector(2 downto 0);
  14.         vgaBlue: out std_logic_vector(2 downto 1);
  15.         led: out std_logic_vector(7 downto 0)
  16.         );
  17. end vga_Main;
  19. architecture Behavioral of vga_Main is
  20.  -- sw(7) not_reset should be '1' for normal operation
  21.  -- sw(3,2) "11" 1024x768 otherwise 800x600
  22. 	COMPONENT CLK_Manager
  23. 	PORT(
  24. 		CLK_IN1 : IN std_logic;
  25. 		RESET : IN std_logic;          
  26. 		CLK_OUT1 : OUT std_logic;
  27. 		LOCKED : OUT std_logic
  28. 		);
  29. 	END COMPONENT;
  30.     COMPONENT vga_gen
  31.     generic(
  32. 	    HD: integer := 548; -- horizontal display area 640;  800
  33.         HF: integer := 34;  -- h. front porch          (8) 16;     40
  34.         HB: integer := 93;  -- h. back porch           (56) 48;    88 
  35.         HR: integer := 59;  -- h. retrace              96;    128
  36. 	    -- VD+VF+VB+VR-1 -> 1087
  37.         VD: integer := 1080; -- vertical display area   480;   600
  38.         VF: integer := 1;  -- v. front porch          (2) 11;    4
  39.         VB: integer := 32;  -- v. back porch           (41) 31;    23
  40.         VR: integer := 3   -- v. retrace               (2) 2;    1
  41. 	 );
  42.     port(
  43.         clk, not_reset: in std_logic;
  44.         hsync, vsync: out std_logic;
  45.         video_on, p_tick: out std_logic;
  46.         pixel_x, pixel_y: out std_logic_vector (11 downto 0)
  47.     );
  48.     END COMPONENT;
  50.     signal rgb_reg, rgb_next: std_logic_vector(2 downto 0);
  51.     signal video_on,video_on0,video_on2: std_logic;
  52.     signal px_x, px_y,px_x0, px_y0,px_x2, px_y2: std_logic_vector(11 downto 0);
  53.     signal hsync0,vsync0,hsync2,vsync2: std_logic;
  54.     signal clkx:std_logic;
  55.     signal en,reset, p_tick,p_tick0, p_tick2: std_logic;
  56.     signal sbtn: std_logic_vector(3 downto 0);
  57.     signal graph_rgb: std_logic_vector(7 downto 0);
  59. begin
  60. 	 reset<=not(not_reset);
  61.     
  62. 	 led(7) <= not_reset;
  63. 	 led(6) <= px_y(6);
  64. 	 led(5) <= px_y(5);
  65. 	 led(4) <= reset;
  66. 	 led(3) <= p_tick;
  67. 	 led(2) <= video_on;
  68. 	 led(1) <= px_x(8);
  69. 	 led(0) <= px_x(8);
  70. 	 
  71. 	vgaRed <=graph_rgb(7 downto 5);
  72. 	vgaGreen <=graph_rgb(4 downto 2);
  73. 	vgaBlue <=graph_rgb(1 downto 0);
  74.         
  75. 	vga0:
  76.         vga_gen
  77.         generic map(
  78. 		    HD => 681, HF => 16, HB=> 96, HR=> 90,  -- (1024) 681x 768 70Hz
  79. 		    VD=> 768, VF=> 3, VB=> 29, VR=> 6   
  80. 		  )
  81.         port map(
  82.             clk => clkx, not_reset => not_reset,
  83.             hsync => hsync0, vsync => vsync0,
  84.             video_on => video_on0, p_tick => p_tick0,
  85.             pixel_x => px_x0, pixel_y => px_y0
  86.         );
  87. 	vga2:
  88.         vga_gen
  89.         generic map(
  90. 		    HD => 800, HF => 56, HB=> 64, HR=> 120,  -- 800x600
  91. 		    VD=> 600, VF=> 37, VB=> 23, VR=> 6   
  92. 		)
  93.         port map(
  94.             clk => clkx, not_reset => not_reset,
  95.             hsync => hsync2, vsync => vsync2,
  96.             video_on => video_on2, p_tick => p_tick2,
  97.             pixel_x => px_x2, pixel_y => px_y2
  98.         );
  100.    ----------------------------------------------
  101.    -- Clock to pixel frequency with Clocking Wizard
  102.    ----------------------------------------------
  103. 	Inst_CLK_y: CLK_Manager PORT MAP(
  104. 		CLK_IN1 => clk,
  105. 		CLK_OUT1 => clkx,
  106. 		RESET => reset,
  107. 		LOCKED => locked 
  108. 	);
  109. 	-- Alternative 1) Fixed external clock
  110. 	-- clkx <= clk;
  111. 	-- Alternative 2) Half external clock
  112.     -- process(clk, not_reset) --- NEXYS3 100MHz transfers clk to 50MHz clkx
  113.     -- begin
  114. 	--   if not_reset = '0' then
  115. 	--      clkx <='0';
  116. 	-- 	 elsif clk'event and clk='1' then -- generate clkx 50 MHz from clk 100MHz NEXYS3 board
  117. 	--	    clkx <= not(clkx);
  118.     --   end if;
  119.     -- end process;
  120. 	
  121.    ----------------------------------------------
  122.    -- signal multiplexing circuit
  123.    ----------------------------------------------
  124.   	hsync <= hsync0 when sw(3 downto 2)="11" else
  125.            hsync2;
  126.   	vsync <= vsync0 when sw(3 downto 2)="11" else
  127.            vsync2;				
  128.   	video_on <= video_on0 when sw(3 downto 2)="11" else
  129.            video_on2;
  130.   	p_tick <= p_tick0 when sw(3 downto 2)="11" else
  131.            p_tick2;
  132.   	px_x <= px_x0 when sw(3 downto 2)="11" else
  133.            px_x2;
  134.   	px_x <= px_x0 when sw(3 downto 2)="11" else
  135.            px_x2;
  136. 	px_y <= px_y0 when sw(3 downto 2)="11" else
  137.            px_y2;
  138.    ----------------------------------------------
  139.    -- rgb multiplexing circuit
  140.    ----------------------------------------------
  141.    process(video_on,px_x,px_y)
  142.    begin
  143.       if video_on='0' then
  144.           graph_rgb <= "00000000"; --blank
  145.       else
  146.          if (px_x(4 downto 0) = px_y(4 downto 0)) or (px_x(4 downto 0) = not(px_y(4 downto 0)) ) then
  147.             graph_rgb <= "00000011"; -- blue lines
  148.          else
  149.             graph_rgb <= "11111111";-- white background
  150.          end if;
  151.       end if;
  152.    end process;
  153. end Behavioral;
  154.

Simulation

Für den Test erzeugt man mit ISE ein VHDL Testmodul.

Die Schalter sw werden zu Anfang automatisch auf "00" gesetzt. Für 50MHz Takt wird die Clockperiode gesetzt: 
  2.     -- Clock period definitions
  3.    constant clk_period : time := 20 ns;
  4.
Am Anfang wird das not_reset Signal aktiviert und dann wird 20ms, mehr als ein volles Bild simuliert und dann die Bildschirmauflösung umgeschaltet. Damit kann man dann VSYNC, HSYNC und das RGB Signal beobachten. 
  2.    -- Stimulus process
  3.    stim_proc: process
  4.    begin		
  5.       -- hold reset state for 100 ns.
  6.       wait for 100 ns;	
  7.       not_reset <='0';
  8.       wait for 100 ns;	
  9.       not_reset <='1';
  10. 		
  11.       wait for 20 ms;
  12.       sw<="11";
  13.       wait for 100 ns;	
  14.       not_reset <='0';
  15.       wait for 100 ns;	
  16.       not_reset <='1';
  17.       wait for 20 ms;
  19.       wait;
  20.    end process;
  21.
In folgendem Bild wird der simulierte Signalverlauf dargestellt.



Man sieht wie sich VSYNC und die Farbsignale bei Umschalten der Grafikauflösung verändern. Bei einer Bildwiederholfrequenz von 60Hz kommt das VSYNC Signal alle 16.66ms. Vergößert man das Simulationsbild um das VSYNC Signal bekommt man folgendes Bild.



Das VSYNC Signal hat 6 Zeilen high Pegel und vorher und nachher werden einige Zeilen ohne Farbsignale ausgegeben.

Files and Implementation


NEXYS3 xc6slx16-3csg324 Projekt und bit Datei

Inbetriebsnahme und Fehlersuche (Debugging)


Nach dem Konfigurieren des FPGAs sollte man sw(7) (Reset) auf '1' und sw(3,2) auf "11" stellen.
Wird kein Bild dargestellt, sollte man mit einem Oszilloskop HSYNC und VSYNC messen.
Die korrekte Pinbelegung kann man im 'Summary:' 'Pinout' überprüfen.

Literatur


[1] VGA Controller (VHDL), http://eewiki.net/pages/viewpage.action?pageId=15925278

[2] Projekt VGA Core in VHDL, http://www.mikrocontroller.net/articles/Projekt_VGA_Core_in_VHDL

[3] Open Cores Yet Another VGA [4] VGA Timings, http://info.electronicwerkstatt.de/bereiche/monitortechnik/vga/Standard-Timing/index.html

[5] http://en.wikipedia.org/wiki/Video_Graphics_Array

[6] http://www.hs-augsburg.de/~beckmanf/dokuwiki/doku.php?id=dtpr_versuch_6

[7] VESA VGA standard DMTv1r11, Google search

[8] Spartan-3 Libraries Guide for HDL Designs (UG607)

[9] Spartan-3 Generation FPGA User Guide, Extended Spartan-3A, Spartan-3E, and Spartan-3 FPGA Families, UG331 (v1.8) June 13, 2011

Work plan


Date Topic Duration Start End
13.06.2014 Messung Grafikmodi 4h 13.6.2014 13.6.2014
19.06.2014 VHDL Syntax Highlighter 4h 19.6.2014 19.6.2014
20.06.2014 Dokumentation Grafikmodi 4h 20.6.2014 20.6.2014
20.06.2014 VHDL Code Main project 1h 20.6.2014 20.6.2014
20.6.2014 VHDL Code Simulation 1h 20.6.2014 20.6.2014
28.06.2014 Clockmanager Xilinx 4h 28.06.2014 28.06.2014
19.06.2017 Nexys3 Aktualisierung, Dateibereitstellung, Debug 4h 28.06.2014 28.06.2014