VGA Controller mit Krummen und Flimmerndem Bild, Timings scheinen korrekt

[Matze (Gast)]

Hallo,

Ich möchte an einem Nexys4DDR (Artix7) einen VGA-Monitor betreiben, dass 
Bild flimmert jedoch und ist auch recht krumm...

Hier die Timings:
https://www.avrfreaks.net/sites/default/files/k2J87.jpg

Das Board läuft mit 100MHz...

Also stimmt vermutlich was mit meinem Code nicht:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use work.utilities.all;

-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating
-- any Xilinx leaf cells in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity VGA_Controller is
    Port ( red : out STD_LOGIC_VECTOR (3 downto 0);
           grn : out STD_LOGIC_VECTOR (3 downto 0);
           blu : out STD_LOGIC_VECTOR (3 downto 0);
           vsync : out STD_LOGIC;
           hsync : out STD_LOGIC;
           
           clk : in STD_LOGIC);
end VGA_Controller;

architecture Behavioral of VGA_Controller is
signal int_vsync : STD_LOGIC; -- Triggert 2. Timer für Signalverlängerung
signal int_hsync : STD_LOGIC; -- Triggert 2. Timer für Signalverlängerung
signal start_vsync : std_logic;
signal start_hsync : std_logic;
signal end_vsync : std_logic;
signal end_hsync : std_logic;
signal rst_vsync : std_logic;
signal rst_hsync : std_logic;
signal vsync_count : std_logic_vector(log2(1678400)-1 downto 0);
signal hsync_count : std_logic_vector(log2(3177)-1 downto 0);
begin

    process (clk)
    begin
        if rising_edge(clk) then
            if hsync_count <= x"236" or hsync_count >= x"C0B" or vsync_count >= ('1' & x"8EC78") or vsync_count <= ('0' & x"1A770") then
                red <= "0000";
                blu <= "0000";
                grn <= "0000";
            else
                red <= "1111";
                blu <= "1111";
                grn <= "1111";           
            end if;         
        end if;
    end process;
    
    process (clk)
    begin      
        if rising_edge(clk) then  
            if hsync_count <= x"04D" then    --x"fe4d90" then 
                hsync <= '0';                   --Signal ausgeben
            else    
                hsync <= '1';
            end if;
        end if;
    end process; 

    h_sync: entity work.Counter 
    generic map (
        MAX   => 3177,
        MIN   => log2(3177-1)
    )
    port map(
        d_in   => x"04E", --: in  std_logic_vector(log2(MAX)-1 downto 0),
        load   => int_vsync,    --: in  std_logic,
        up     => '1',   --: in  std_logic := '1',
        en     => '1',    --: in  std_logic,
        rst    => '0',        --: in  std_logic,
        clk    => clk,     --: in  std_logic,
        ov     => int_hsync,
        count  => hsync_count   --: out std_logic_vector(log2(MAX)-1 downto 0)
    );

    process (clk)
    begin      
        if rising_edge(clk) then  
            if vsync_count <= '0' & x"00960" then     --x"AFC8" then 
                vsync <= '0';                   --Signal ausgeben
            else
                vsync <= '1';
            end if;
        end if;
    end process; 
    
    v_sync: entity work.Counter 
    generic map (
        MAX   => 1678400-1,
        MIN   => log2(1678400-1)
    )
    port map(
        d_in   => (others => '0'), --: in  std_logic_vector(log2(MAX)-1 downto 0),
        load   => '0',    --: in  std_logic,
        up     => '1',   --: in  std_logic := '1',
        en     => '1',    --: in  std_logic,
        rst    => '0',        --: in  std_logic,
        clk    => clk,     --: in  std_logic,
        ov     => int_vsync,
        count  => vsync_count   --: out std_logic_vector(log2(MAX)-1 downto 0)
    );
end Behavioral;

Hier der Counter:

library IEEE;
use IEEE.STD_LOGIC_1164.all;
use IEEE.numeric_std.all; --Signed/unsigned
use work.utilities.all;

entity Counter is
  generic (
    MAX   : positive := 8;
    MIN   : positive := 4
  );
  port (
    d_in   : in  std_logic_vector(MIN-1 downto 0);
    load   : in  std_logic;
    up     : in  std_logic := '1';
    en     : in  std_logic;
    rst    : in  std_logic;
    clk    : in  std_logic;
    ov     : out std_logic;
    count  : out std_logic_vector(MIN-1 downto 0)
  );
end entity;

architecture rtl of Counter is 
  signal counter : unsigned(count'range) := (others => '0');
begin
  process (clk)
  begin
    if rising_edge(clk) then
      if (rst or ov)= '1' then
        counter <= (others => '0');
      elsif load = '1' then
        counter <= unsigned(d_in);
      elsif en = '1' then
        if up = '1' then
          counter <= counter + 1;
        else
          counter <= counter - 1;
        end if;
      end if;
    end if;
  end process;
  ov <= '1' when (counter >= MAX and en = '1') else '0';
  count <= (count'high downto counter'length => '0') & std_logic_vector(counter);
end architecture;

Vielleicht hat mir jemand eine Idee woran es liegen könnte???

Schonmal vielen Dank,
Matze

[Matze (Gast)]

Hier ein Bild dazu...

[Klakx (Gast)]

funktioniert die Simulation? Testbench?

vielleicht hängt ein Counter schief. Die hex-Werte finde ich jetzt nicht 
unbedingt einfach zu debuggen beim Gegenlesen.

[C. A. Rotwang (Gast)]

Matze schrieb:

>     process (clk)
>     begin
>         if rising_edge(clk) then
>             if hsync_count <= x"04D" then    --x"fe4d90" then
>                 hsync <= '0';                   --Signal ausgeben
>             else
>                 hsync <= '1';
>             end if;
>         end if;
>     end process;
>
>     h_sync: entity work.Counter
>     generic map (
>         MAX   => 3177,
>         MIN   => log2(3177-1)
>     )
Hm, counter der nicht ab 0 zählt?!
>
>     process (clk)
>     begin
>         if rising_edge(clk) then
>             if vsync_count <= '0' & x"00960" then     --x"AFC8" then
>                 vsync <= '0';                   --Signal ausgeben
>             else
>                 vsync <= '1';
>             end if;
>         end if;
>     end process;


sind die syncs in der richtigen Polarität?
http://martin.hinner.info/vga/timing.html

Pegel in Ordnung? Also 5V knackige Flanke? liegen die Grounds richtig?
http://www.javiervalcarce.eu/html/vga-signal-format-timming-specs-en.html

[C. A. Rotwang (Gast)]

Da gab es mal einen Thread zu einem ähnlichen Fehlerbild:
Beitrag "VGA Testbild-Fehler-Symptome bekannt ?"

[Duke Scarring (Gast)]

Eine schöne Einschwingkurve hast Du da...

Geht Deine log2-Funktion richtig?
Nicht das da ein Bit im Zählvektor fehlt. BTDT.

Duke

[J. S. (engineer)]

Matze schrieb:
> Hier ein Bild dazu...

Cool! Ich würde sagen, du zählst mal deine Synchs durch oder misst die 
Pegel.

[S. R. (svenska)]

Matze schrieb:
> Vielleicht hat mir jemand eine Idee woran es liegen könnte???

Irgendwas machst du falsch. Ich sehe in deinem Code die üblichen 
Konstanten nicht. Die Berechnungen habe ich mir jetzt nicht im Detail 
angeschaut, aber es ist sinnvoller, sämtliche Zähler auf Pixeltakt-Basis 
aufzubauen als mit den Mikrosekunden zu hantieren.

Für 640x480@60 (25 MHz Pixeltakt) reicht es also völlig aus, wenn du die 
Zeilen von 0..799 zählst (hcount) und die Spalten von 0..524 (vcount).

Das Bild ist sichtbar, wenn (hcount < 640 and vcount < 480).
Hsync ist High, wenn (hcount >= 656 and hcount < 752), sonst Low.
Vsync ist High, wenn (vcount >= 490 and vcount < 492), sonst Low.
Das ergibt ein stabiles Bild.

Mit einem 100 MHz Basistakt kannst du auch 800x600@72 (50 MHz Pixeltakt) 
bauen. Dann gelten folgende Zahlen:

Das Bild ist sichtbar, wenn (hcount < 800 and vcount < 600).
Hsync ist High, wenn (hcount >= 856 and hcount < 976), sonst Low.
Vsync ist High, wenn (vcount >= 637 and vcount < 643), sonst Low.

Den Zählertakt von 100 MHz musst du entsprechend runterteilen, oder du 
ignorierst bei den Vergleichen einfach die unteren ein oder zwei Bits.

Und dann simulierst du den Kram mal über 20-50 ms (mehr als einen ganzen 
Frame) und schaust, ob die Syncsignale auch zu den richtigen Zeiten 
kommen und ob die Zähler ordentlich zählen (und nicht um ±1 daneben 
liegen).

[Pedro (Gast)]

S. R. schrieb:
> Mit einem 100 MHz Basistakt kannst du auch 800x600@72 (50 MHz Pixeltakt)
> bauen. Dann gelten folgende Zahlen:

Da geht laut Tabelle Projekt VGA Core in VHDL unten offenbar auch 
1280x1024.

[*.* (Gast)]

Schaltest du HSYNC während VSYNC aus? Das wäre falsch.

Und dieser Monitor funktioniert ansonsten noch? ;)

[S. R. (svenska)]

Pedro schrieb:
> Da geht laut Tabelle Projekt VGA Core in VHDL
> unten offenbar auch 1280x1024.

Das stimmt, allerdings muss die Gesamtschaltung dann auch 100 MHz 
schaffen und es passiert relativ schnell, dass das nicht mehr so ist. 
Mit einem Pixeltakt von 50 MHz hat man da deutlich mehr Luft.

Außerdem kann mein Testmonitor nur 1024x768. :-)