VGA - Fortsetzung

[Kampi (Gast)]

Hallo,

ich habe gestern mein VGA Projekt wieder ausgekramt und wollte mal 
wieder etwas daran weiter arbeiten (das lag jetzt eine ganze Weile).
Aber irgendwie funktioniert das nicht....ich möchte den Bildschirm 
einfach einfarbig machen...
Wo steckt der Fehler im Code?
Die Komponente "System" ist ein RAM + Clock Manager für den VGA Takt.

VGA Top

----------------------------------------------------------------------------------
-- Company:         www.kampis-elektroecke.de
-- Engineer:        Daniel Kampert
-- 
-- Create Date:     02.08.2014 13:17:51
-- Design Name: 
-- Module Name:     VGA_Top - VGA_Top_Arch
-- Project Name: 
-- Target Devices:  XC7Z010CLG400-1
-- Tool Versions:   Vivado 2014.2
-- Description:     VGA Interface for a 640 x 480 Pixel Screen
-- 
-- Dependencies: 
-- 
-- Revision:
-- Revision         0.01 - File Created
-- Additional Comments:
-- 
----------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.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_Top is
    Port (  Color : out STD_LOGIC_VECTOR(15 downto 0);
            HSync : out STD_LOGIC;
            VSync : out STD_LOGIC;
            Output : out STD_LOGIC_VECTOR(3 downto 0);
            Reset : in STD_LOGIC;
            Clock : in STD_LOGIC         
            );
end VGA_Top;

architecture VGA_Top_Arch of VGA_Top is

    constant Char_Size : integer := 8;

    -- Clocksignale
    signal Clock_VGA : std_logic;
    signal Clock_1250 : std_logic;

    -- Koordinaten des Zeigers auf dem Bildschirm
    signal Pos_x : std_logic_vector(9 downto 0) := "0001100100";                
    signal Pos_y : std_logic_vector(9 downto 0) := "0001100100"; 
    
    -- Font ROM
    signal Character_No : std_logic_vector(1 downto 0);
    signal Row_Addr : std_logic_vector(2 downto 0);
    signal ROM_Col : std_logic_vector(2 downto 0);
    signal ROM_Addr : std_logic_vector(4 downto 0);
    signal ROM_Data : std_logic_vector(7 downto 0);
    signal ROM_Bit : std_logic;
    
    -- Positionen
    signal Pos_x_l : integer := 8;
    signal Pos_y_t : integer := 8;
    signal Pos_x_r : integer := Pos_x_l + Char_Size - 1;
    signal Pos_y_b : integer := Pos_y_t + Char_Size - 1;
    
    --Enable Signale für die Formen
    signal Text_on : std_logic;

    -- Systemsignale
    signal Lock : std_logic;

    -- Erzeugung des 25,175MHz Taktes und einbinden des RAM Moduls
    component System is
        Port (  Address_RAM : in STD_LOGIC_VECTOR (3 downto 0);
                Clock_In : in STD_LOGIC;
                Clock_Locked : out STD_LOGIC;
                Clock_Out : out STD_LOGIC;
                Clock_RAM : in STD_LOGIC;
                Clock_Reset : in STD_LOGIC;
                RAM_Out : out STD_LOGIC_VECTOR (3 downto 0)
                );
    end component System;
    
    -- Einbinden des VGA-Controllers
    component VGA_Controller is
        Port (  HSync : out STD_LOGIC;
                VSync : out STD_LOGIC;
                Clock_VGA : in STD_LOGIC;
                Reset : in STD_LOGIC;
                x_out : out STD_LOGIC_VECTOR(9 downto 0);                
                y_out : out STD_LOGIC_VECTOR(9 downto 0) 
                );
    end component VGA_Controller;  

begin
    
    Clock_25MHz     : System port map ("0001", Clock, Lock, Clock_VGA, Clock_VGA, '1', Output);
    VGA_Core        : VGA_Controller port map (HSync, VSync, Clock_VGA, '1', Pos_x, Pos_y);   

    -- Wenn Position erreicht, Enable-Signal auf High setzen
    Text_on <=
        '1' when (Pos_x_l <= to_integer(unsigned(Pos_x))) and (to_integer(unsigned(Pos_x)) <= Pos_x_r) and
                 (Pos_y_t <= to_integer(unsigned(Pos_y))) and (to_integer(unsigned(Pos_y)) <= Pos_y_b) else '0'; 
    
    -- ROM auslesen
    Row_Addr <= Pos_y(2 downto 0);
    ROM_Addr <= Character_No & Row_Addr;
    
    ROM_Col <= Pos_x(2 downto 0);
    ROM_Bit <= ROM_Data(7 - to_integer(unsigned(ROM_Col)));

    -- Formen am Bildschirm ausgeben
   -- process(Clock_VGA)
    --begin
        --if(Text_on = '1') then
             Color <= x"FFFF";   
        --end if;
        
        --Color <= x"0000" ;
        
    --end process;

    -- Betriebsstatus
    --Output(1) <= Lock;
    --Output(0) <= Reset;
    
end VGA_Top_Arch;

VGA Controller

----------------------------------------------------------------------------------
-- Company:         www.kampis-elektroecke.de
-- Engineer:        Daniel Kampert
-- 
-- Create Date:     06.08.2014 23:31:52
-- Design Name: 
-- Module Name:     VGA_Controller - VGA_Controller_Arch
-- Project Name: 
-- Target Devices:  XC7Z010CLG400-1
-- Tool Versions:   Vivado 2014.2
-- Description:     Der Controller erzeugt alle notwendigen Signale
--                  für ein VGA Interface
-- Dependencies: 
-- 
-- Revision:
-- Revision         0.01 - File Created
-- Additional Comments:
-- 
----------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
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
    Generic (
            -- Bildeinstellungen
            -- Für andere Monitorformate diese Werte anpassen
            -- Horizontal timing
            WholeLine : integer := 800;
            BackPorch_H : integer := 48;
            SyncPulse_H : integer := 96;
            VisibleArea_H : integer := 640;
            FrontPorch_H : integer := 16;
            
            -- Vertical timing
            WholeFrame : integer := 525;
            BackPorch_V : integer := 33;
            SyncPulse_V : integer := 2;
            VisibleArea_V : integer := 480
            );
    Port (  HSync : out STD_LOGIC;            
            VSync : out STD_LOGIC;              
            Clock_VGA : in STD_LOGIC;           
            Reset : in STD_LOGIC;                           
            x_out : out STD_LOGIC_VECTOR(9 downto 0);                
            y_out : out STD_LOGIC_VECTOR(9 downto 0)                
            );
end VGA_Controller;

architecture VGA_Controller_Arch of VGA_Controller is

    signal x : integer range 0 to (VisibleArea_H - 1);
    signal y : integer range 0 to (VisibleArea_V - 1);
    
    -- Aktuelle Pixelpositionen des Monitors
    signal Pixel_Counter : integer;
    signal Line_Counter : integer;

begin

    x_out <= std_logic_vector(to_unsigned(x, x_out'length));
    y_out <= std_logic_vector(to_unsigned(y, y_out'length));

    -- X-Koordinate hochzählen
    process(Clock_VGA)
    begin
        if rising_edge(Clock_VGA) then
            if(x < (VisibleArea_H - 1)) then    
                x <= x + 1;  
            end if;
           
            if(Pixel_Counter <= (BackPorch_H + SyncPulse_H)) then
                x <= 0;
            end if;
        end if;        
    end process;
   
    -- Y-Koordinate hochzählen
    process(Clock_VGA)
    begin
        if rising_edge(Clock_VGA) then
            if((y < (VisibleArea_V - 1)) and (Pixel_Counter = WholeLine))  then    
                y <= y + 1; 
            end if;
           
            if(Line_Counter <= BackPorch_V)     then    y <= 0;     end if;
        end if;        
    end process;

    -- HSync auslösen
    process(Clock_VGA)
    begin
        if rising_edge(Clock_VGA) then
            if(Pixel_Counter = 0)               then    HSync <= '0';   end if;
            if(Pixel_Counter = SyncPulse_H)     then    HSync <= '1';   end if;
        end if;
    end process; 
   
    -- VSync auslösen
    process(Clock_VGA)
    begin
        if rising_edge(Clock_VGA) then
            if(Line_Counter = 0)                then    VSync <= '0';   end if;  
            if(Line_Counter = SyncPulse_V)      then    VSync <= '1';   end if;          
        end if;
    end process; 
   
    -- Counter
    process(Clock_VGA)
    begin
        if (rising_edge(Clock_VGA)) then
            if(Reset = '0') then
                Pixel_Counter <= 0;
                Line_Counter <= 0;
            else
                -- Pixelzähler erhöhen
                Pixel_Counter <= Pixel_Counter + 1;
               
                -- Pixelcounter zurücksetzen und Zeilencounter erhöhen
                if(Pixel_Counter = WholeLine) then
                    Pixel_Counter <= 0;
                    Line_Counter <= Line_Counter + 1;
                end if; 
               
                -- Zeilencounter zurücksetzen
                if(Line_Counter = WholeFrame)  then    Line_Counter <= 0;  end if;
            end if;
        end if;
    end process;
end VGA_Controller_Arch;

Ist bestimmt nur ein kleiner Fehler...aber ich sehe es gerade nicht :(

Danke für die Hilfe!

[Dumdi D. (dumdidum)]

Vielleicht ist die Hardware ein Problem. Bei mir ging einfarbig nicht. 
(Da war wohl irgendeo ein Hochpass). Probier mal zweifarbig.

[Fpgakuechle K. (Gast)]

Kampi schrieb:
> Hallo,
>
> ich habe gestern mein VGA Projekt wieder ausgekramt und wollte mal
> wieder etwas daran weiter arbeiten (das lag jetzt eine ganze Weile).
> Aber irgendwie funktioniert das nicht....ich möchte den Bildschirm
> einfach einfarbig machen...
> Wo steckt der Fehler im Code?

Der fehler steckt erst mal in deiner Vorgehensweise:
-Es fehlt eine genaue Beschreibung des Fehlerbildes - Was passiert am 
Monitor
-Es fehlt eine Simulation.

So mit drüberschauen hab ich nicht erkennen wann welche synxs wie lange 
aktiv sind und ob im nicht sichtbaren Feld die Daten auch auf 0 gezogen 
werden.
Besser ist IMHO zwei counter für horizontal und vertikal durchlaufen 
lassen und dann mit komperatoren syncs und enable zu setzen.

MfG,

[Daniel K. (daniel_k80)]

Hallo,

danke für die Antworten.
Also zum Fehlerbild:
Ich habe einen kleinen 640x480 Monitor den ich an das FPGA anschließe. 
Sobald kein Kabel angeschlossen ist, gibt er eine Meldung "No Signal" 
aus....diese verschwindet beim FPGA, aber der Monoitor bleibt schwarz.
Daraufhin habe ich mit meinem LA mal HS und VS durchgemessen und die 
Signale laufen und auch die Timings stimmen.
Es kann daher eigentlich nur an den Farben liegen (ich probiere mal 
zweifarbig).

Was meinst du genau mit den zwei Countern?
Im Moment habe ich es ja so gelöst, dass ein Counter das Zählen 
übernimmt und dann mit Hilfe zweier Vergleichswerte die Synchs 
geschaltet werden (VGA-Controller ist für das Timing da....VGA Top soll 
die Farben darstellen - im Idealfall aus dem RAM :) ).

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Fpga Kuechle schrieb:
> -Es fehlt eine Simulation.
Das würde ich auch sagen. Denn gerade so ein unidirektionales Interface 
wie hier ist doch in Sekundenschnelle wenigstens bis zur Waveform 
simuliert: Takt anlegen und zuschauen. Dann sieht man blitzschnell, ob 
die Timings grundlegend passen...

BTW: du hattest das Zeug im Beitrag "Kein Bild bei eigenem VGA" 
doch schon am Laufen. Warum geht das nicht mehr?

[Mike (Gast)]

Du musst das Farbsignal während der Austastlücken unbedingt auf 0 
setzen.

Bei aktuellen Monitoren kann man im OSD nachschauen was für eine 
Auflösung erkannt wurde. Steht dort was?

[Daniel K. (daniel_k80)]

Mike schrieb:
> Du musst das Farbsignal während der Austastlücken unbedingt auf 0
> setzen.
>
> Bei aktuellen Monitoren kann man im OSD nachschauen was für eine
> Auflösung erkannt wurde. Steht dort was?

Ah der Tipp ist gut....
Bei dem Monitor handelt es sich um einen VGA/LVDS Konverter + 
Display...da habe ich leider nicht die entsprechende Platine mit Knöpfen 
um das zu sehen.

Btw...ich versuche gerade das ganze zu simulieren, bekomme bei VSync und 
HSync die ganze Zeit nur ein "U" im Simulator (hab erst einmal nur den 
VGA-Controller für die Timings).
Da ich gestern mit dem LA gemessen habe weiß ich, dass es 
funktioniert....aber warum nicht in der Simulation?

Edit:
Problem gefunden.... -.-
Der Simulator hat die längere Simulationszeit nicht akzeptiert :D
Anbei die Screenshots der Simulation vom Controller

[Daniel K. (daniel_k80)]

Daniel K. schrieb:
> Mike schrieb:
>> Du musst das Farbsignal während der Austastlücken unbedingt auf 0
>> setzen.
>>
>> Bei aktuellen Monitoren kann man im OSD nachschauen was für eine
>> Auflösung erkannt wurde. Steht dort was?
>
> Ah der Tipp ist gut....
> Bei dem Monitor handelt es sich um einen VGA/LVDS Konverter +
> Display...da habe ich leider nicht die entsprechende Platine mit Knöpfen
> um das zu sehen.
>
> Btw...ich versuche gerade das ganze zu simulieren, bekomme bei VSync und
> HSync die ganze Zeit nur ein "U" im Simulator (hab erst einmal nur den
> VGA-Controller für die Timings).
> Da ich gestern mit dem LA gemessen habe weiß ich, dass es
> funktioniert....aber warum nicht in der Simulation?
>
> Edit:
> Problem gefunden.... -.-
> Der Simulator hat die längere Simulationszeit nicht akzeptiert :D
> Anbei die Screenshots der Simulation vom Controller

Sorry Timings sind auf den Screens falsch...
VSync: 16,7047ms, Breite Low Level: 63,597us
HSync: 35,632us, Breite Low Level: 3,813us

[Daniel K. (daniel_k80)]

Hallo,

ich habe gestern noch mal die Timins gecheckt...sowohl in der Simulation 
als auch in der Hardware. Beide waren für einen 640x480 Monitor in 
Ordnung.
Jetzt will ich einfach eine Farbe am Monitor ausgeben....:

----------------------------------------------------------------------------------
-- Company:         www.kampis-elektroecke.de
-- Engineer:        Daniel Kampert
-- 
-- Create Date:     02.08.2014 13:17:51
-- Design Name: 
-- Module Name:     VGA_Top - VGA_Top_Arch
-- Project Name: 
-- Target Devices:  XC7Z010CLG400-1
-- Tool Versions:   Vivado 2014.2
-- Description:     VGA Interface for a 640 x 480 Pixel Screen
-- 
-- Dependencies: 
-- 
-- Revision:
-- Revision         0.01 - File Created
-- Additional Comments:
-- 
----------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.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_Top is
    Port (  Color : out STD_LOGIC_VECTOR(15 downto 0);
            HSync : out STD_LOGIC;
            VSync : out STD_LOGIC;
            Reset : in STD_LOGIC;
            Clock_In : in STD_LOGIC         
            );
end VGA_Top;

architecture VGA_Top_Arch of VGA_Top is

    -- Clocksignale
    signal Clock_VGA : std_logic;
    signal Output : std_logic_vector(3 downto 0);

    -- Koordinaten des Zeigers auf dem Bildschirm
    signal Pos_x : std_logic_vector(9 downto 0);                
    signal Pos_y : std_logic_vector(9 downto 0); 
    
    -- Font ROM
    signal Character_No : std_logic_vector(1 downto 0);
    signal Row_Addr : std_logic_vector(2 downto 0);
    signal ROM_Col : std_logic_vector(2 downto 0);
    signal ROM_Addr : std_logic_vector(4 downto 0);
    signal ROM_Data : std_logic_vector(7 downto 0);
    signal ROM_Bit : std_logic;

    -- Systemsignale
    signal Lock : std_logic;

    -- Erzeugung des 25,175MHz Taktes und einbinden des RAM Moduls
    component Clock is
        Port (  Clock_In : in STD_LOGIC;
                Clock_Locked : out STD_LOGIC;
                Clock_Out : out STD_LOGIC;
                Clock_Reset : in STD_LOGIC
                );
    end component Clock;
    
    -- Einbinden des VGA-Controllers
    component VGA_Controller is
        Port (  HSync : out STD_LOGIC;
                VSync : out STD_LOGIC;
                Clock_VGA : in STD_LOGIC;
                Reset : in STD_LOGIC;
                x_out : out STD_LOGIC_VECTOR(9 downto 0);                
                y_out : out STD_LOGIC_VECTOR(9 downto 0) 
                );
    end component VGA_Controller;  
    
    -- Font-ROM für VGA-Controller
    component Font_ROM is
        Port (  ROM_DataOut : out STD_LOGIC_VECTOR(2 downto 0);
                ROM_Address : in STD_LOGIC_VECTOR(3 downto 0);
                ROM_Clock : in STD_LOGIC
                );
    end component Font_ROM;

begin
    
    Clock_25MHz     : Clock port map (Clock_In, Lock, Clock_VGA, '1');
    VGA_Core        : VGA_Controller port map (HSync, VSync, Clock_VGA, '1', Pos_x, Pos_y);   

    -- Formen am Bildschirm ausgeben
    process(Pos_x, Pos_y, Clock_VGA)
    begin
    if rising_edge(Clock_VGA) then
        if((to_integer(unsigned(Pos_x)) > 200) and (to_integer(unsigned(Pos_y)) > 200)) then
             Color <= x"FFFF";   
        end if;
    end if;   
        Color <= x"0000" 
    
end VGA_Top_Arch;

Ich habe jetzt auch mal einen anderen Monitor genommen 
(testweise)...dort ist das selbe Verhalten zu erkennen...es passiert 
nichts....keine Farben, nur die Meldung "No Signal" verschwindet :/

[peter (Gast)]

Setz mal x> , x< und y> , y<
Also Grenzen setzen auf das Sichtbare...

Gruss

[peter (Gast)]

Wie ist bei dir RGB aufgeteilt?

Bei meinem DE0 ist es zb:
red   : OUT STD_LOGIC_VECTOR(3 downto 0);
green : OUT STD_LOGIC_VECTOR(3 downto 0);
blue  : OUT STD_LOGIC_VECTOR(3 downto 0);

Meine Abfrage für ein Farbkästchen zb:
if Counterx >=230 and Counterx < 245 then
if Countery >=20 and Countery < 40 then
red <="0011";
blue <="0011";
green <="0011";


Gruss

[Daniel K. (daniel_k80)]

Hallo,

habe ich mal gemacht:

    Clock_25MHz     : Clock port map (Clock_In, Lock, Clock_VGA, '1');
    VGA_Core        : VGA_Controller port map (HSync, VSync, Clock_VGA, '1', Pos_x, Pos_y);   

    -- Formen am Bildschirm ausgeben
    process(Reset, Color_Enable, Clock_VGA)
    begin
        if(rising_edge(Clock_VGA)) then
            if(Reset = '0') then
                Color <= x"0000";
            else
                if(Color_Enable = '1') then
                    Color <= x"FFFF";
                else
                    Color <= x"0000";
                end if;
            end if;
        end if;
    end process;
    
   Color_Enable <= '1' when ((Pixel_x >= 230) and (Pixel_x < 245) and (Pixel_y >= 50) and (Pixel_y < 200)) else '0';

    Pixel_x <= unsigned(Pos_x);
    Pixel_y <= unsigned(Pos_y);

Aufteilung beim Zybo ist wie folgt:

Rot: 5 Bit (0 - 4)
Blau: 5 Bit (5 - 9)
Grün: 6 Bit (10 -15)

Zusammen sind es die 16 Bit des Vectors "Color"

[Daniel K. (daniel_k80)]

Ok! Ich habe es hinbekommen.
Ich habe noch mal den VGA-Controller simuliert, die Timings gecheckt, 
paar kleine Änderungen vorgenommen und dann das Top Design simuliert.
Wie sich herausgestellt hat, hat der Core nicht die x und y Koordinaten 
hochgezählt, da ich die Bedingung vor dem Hochzählen immer vorher zurück 
gesetzt habe.

Danke für die Hilfe! Es war zudem eine schöne Übung für den 
Simulator....und wie ich gesehen habe mag der Simulator keinen DCM, da 
ich immer keinen Takt hatte sobald dieser im Design war.

[Duke Scarring (Gast)]

Daniel K. schrieb:
> wie ich gesehen habe mag der Simulator keinen DCM, da
> ich immer keinen Takt hatte sobald dieser im Design war.
Du mußt möglicherweise die Zeitauflösung des Simulators auf ps 
(Picosekunden) stellen, damit die DCm richtig simuliert wird.

Duke

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Daniel K. schrieb:
> die x und y Koordinaten
Diese beiden Zähler würde ich sowieso als Integer ausführen, damit diese 
Umwandlungsorgie entfällt:

        if((to_integer(unsigned(Pos_x)) > 200) and (to_integer(unsigned(Pos_y)) > 200)) then

Es liest sich so einfach flüssiger:

        if (Pos_x > 200 and Pos_y > 200) then

[Josef G. (bome)]

Lothar Miller schrieb:
> Diese beiden Zähler würde ich sowieso als Integer
> ausführen, damit diese Umwandlungsorgie entfällt:

Oder einfach das to_integer weglassen.
Rechnen kann man auch mit unsigned.

[Daniel K. (daniel_k80)]

Josef G. schrieb:
> Lothar Miller schrieb:
>> Diese beiden Zähler würde ich sowieso als Integer
>> ausführen, damit diese Umwandlungsorgie entfällt:
>
> Oder einfach das to_integer weglassen.
> Rechnen kann man auch mit unsigned.

Ich habe nun einfach einen Integer genommen :)
Funktioniert genau so gut

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Josef G. schrieb:
> Oder einfach das to_integer weglassen.
> Rechnen kann man auch mit unsigned.
Bringt nichts, denn der Vergleich ist dann genauso unleserlich:

        if (Pos_x > to_unsigned(200,Pos_x'length) and Pos_y > to_unsigned(200,Pos_y'length)) then

[Josef G. (bome)]

Lothar Miller schrieb:
> Bringt nichts, denn der Vergleich ist dann genauso unleserlich:

So hatte ich gemeint:

if((unsigned(Pos_x) > 200) and (unsigned(Pos_y) > 200)) then

Geht das nicht?

[Daniel K. (daniel_k80)]

Hallo,

so ich habe gestern noch etwas weiter gewerkelt...
Mittlerweile läuft der Core richtig gut...Timing Probleme sind alle 
behoben und ich kann über Positionen zwischen 0-79 und 0-59 die Position 
des Zeichens auf dem Monitor angeben.
Ein FONT-Rom ist auch weitestgehend vorhanden und ich bin schon in der 
Lage Buchstaben und Zahlen auszugeben.
Leider sind das erst einzelne Zahlen und Buchstaben.
Ich möchte nun mal zusammenhängende Zahlen und Worte (z.B. ein "Hello 
World") ausgeben.
Da muss ich ja einfach nur Zeichen x ausgeben, Zähler inkrementieren, 
Zeichen x+1 an Position+1 ausgeben, etc.
Das ganze wollte ich mal für die Buchstabenkombi "ABCD" probieren:

    Clock_25MHz     : Clock port map (Clock_In, Clock_Lock, Clock_VGA, Reset);
    VGA_Top         : VGA port map (Clock_VGA, Reset, '1', std_logic_vector(to_unsigned(Zeichen, 8)), Farbe, Position, Zeile, HSync, VSync, RGB);
    
    process(Clock_1)
    begin
        if rising_edge(Clock_1) then
            for I in 0 to 3 loop
                Zeichen <= 64 + I;
                Position <= 39 + I;
            end loop;
   
        end if;
    end process;

Die Buchstaben sind nach ASCII-Wert in meinem ROM hinterlegt, sprich 65 
ist A etc.
Clock_1 ist einfach ein 1Hz Takt (etwa 1Hz :) ).
Leider wird mir auf dem Bildschirm nur der Buchstabe "A" angezeigt.
Ich gehe mal davon aus, dass ich die Schleife falsch benutzt habe...aber 
wie mache ich es richtig :)

Danke für die Hilfe!

[Markus F. (mfro)]

Daniel K. schrieb:
> Ich gehe mal davon aus, dass ich die Schleife falsch benutzt habe

Hast Du. Was passiert innerhalb eines Prozesses?

Alles was da steht. Und zwar alles gleichzeitig. Innerhalb eines Taktes.

Eine FOR-Schleife ist damit prinzipiell nur eine verkürzte Schreibweise 
gegenüber der "ausgerollten" Form:

PROCESS (Clock1)
BEGIN
    FOR i IN 0 TO 3 LOOP
        a <= i;
    END LOOP;
END PROCESS;

ist also genau dasselbe wie

PROCESS (Clock1)
BEGIN
    a <= 0;
    a <= 1;
    a <= 2;
    a <= 3;
END PROCESS;

Nur daß Du letzteres wahrscheinlich gar nicht erst hinschreiben würdest, 
weil dir sofort klar ist, daß das irgendwie keinen großen Sinn macht...

[peter (Gast)]

Hast du ein Screenram der dauernd von 0 - 4799 mit Ascii-Code 
beschrieben wird und die Pixel dann vom ROM geholt werden und 
dargestellt werden ?

Gruss

[Daniel K. (daniel_k80)]

Hallo,

so ich habe noch etwas weiter gemacht...
Jetzt habe ich einen Display-RAM gemacht und diesen mit drei Zeichen 
gefüllt (jeweils Pixel 0, 1 und 2):

----------------------------------------------------------------------------------
-- Company:             www.kampis-elektroecke.de
-- Engineer:            Daniel Kampert
-- 
-- Create Date:         10.03.2015 09:26:02
-- Design Name: 
-- Module Name:         Display_RAM - Display_RAM_Arch
-- Project Name: 
-- Target Devices:      XC7Z010CLG400-1
-- Tool Versions:       Vivado 2014.4
-- Description: 
-- 
-- Dependencies: 
-- 
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
-- 
----------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.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 Display_RAM is
    Generic (
            Addr_Width : integer := 20;
            Data_Width : integer := 8
            );
    Port (  Clock : in STD_LOGIC;
            Read_Write : in STD_LOGIC;
            Address : in STD_LOGIC_VECTOR((Addr_Width - 1) downto 0);
            Data_Out : out STD_LOGIC_VECTOR ((Data_Width - 1) downto 0);
            Data_In : in STD_LOGIC_VECTOR ((Data_Width - 1) downto 0)
            );
end Display_RAM;

architecture Display_RAM_Arch of Display_RAM is

    type Display_RAM_Type is array (0 to (2**Address'length) - 1) of std_logic_vector(Data_In'range);
    signal Read_Address : std_logic_vector(Address'range);
    signal RAM : Display_RAM_Type := (
    "01000000",
    "01000001",
    "01000010",
    others=> (others=>'0')
    );
    
begin
    
    process(Clock)
    begin
        if(rising_edge(Clock)) then
            if(Read_Write = '0') then
                RAM(to_integer(unsigned(Read_Address))) <= Data_In;
            end if;
            
            Read_Address <= Address;
            
        end if;
    end process;

    Data_Out <= RAM(to_integer(unsigned(Read_Address)));   

end Display_RAM_Arch;

Dieses Display-RAM soll meinen aktuellen Bildschirminhalt darstellen
Jetzt habe ich mein Top Design mit dem Display-RAM und meinem 
VGA-Controller, der ein bestimmtes, gegebenes Zeichen an einer 
bestimmten Stelle auf dem Monitor ausgibt.

----------------------------------------------------------------------------------
-- Company:             www.kampis-elektroecke.de
-- Engineer:            Daniel Kampert
-- 
-- Create Date:         05.03.2015 13:21:32
-- Design Name: 
-- Module Name:         Top - Top_Arch
-- Project Name: 
-- Target Devices:      XC7Z010CLG400-1
-- Tool Versions:       Vivado 2014.4
-- Description: 
-- 
-- Dependencies: 
-- 
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
-- 
----------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.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 Top is
    Port (  RGB         : out STD_LOGIC_VECTOR(15 downto 0);
            Input       : in STD_LOGIC_VECTOR(3 downto 0);
            HSync       : out STD_LOGIC;
            VSync       : out STD_LOGIC;
            Reset       : in STD_LOGIC;
            Clock_In    : in STD_LOGIC;    
            Output      : out STD_LOGIC_VECTOR(3 downto 0)
            );
end Top;

architecture Top_Arch of Top is

    signal Reset_In : std_logic;
    
    -- Clocksignale
    signal Clock_VGA    : std_logic;
    signal Clock_100    : std_logic;
    
    -- Systemsignale
    signal Clock_Lock : std_logic;
    
    -- Testsignale
    signal Display_Counter : integer := 0;
    signal Zaehler      : integer;
    signal Zeichen_RAM  : std_logic_vector(7 downto 0);
    signal Pixel    : integer := 39;
    signal Zeile    : integer := 29;
    signal Farbe    : std_logic_vector(15 downto 0) := x"F800";
    
    -- Erzeugung des 25,175MHz Taktes und einbinden des RAM Moduls
    component Clock is
        Port (  Clock_In    : in STD_LOGIC;
                Clock_Locked: out STD_LOGIC;
                Clock_Out   : out STD_LOGIC;
                Clock_Reset : in STD_LOGIC
                );
    end component Clock;
    
    component VGA is
        Generic (
                ROM_Address_Width   : integer := 11;
                ROM_Data_Width      : integer := 8;
                Char_Size           : integer := 8
                );
        Port (  Clock_VGA   : in STD_LOGIC;
                Reset       : in STD_LOGIC;
                Mode        : in STD_LOGIC; 
                Character   : in STD_LOGIC_VECTOR((ROM_Address_Width - 4) downto 0); 
                Color       : in STD_LOGIC_VECTOR(15 downto 0);
                Position    : in INTEGER;
                Zeile       : in INTEGER;
                HSync       : out STD_LOGIC;
                VSync       : out STD_LOGIC;
                RGB         : out STD_LOGIC_VECTOR(15 downto 0)
                );
    end component VGA;
    
    component Clock_Divider
        Port (  Clock_In : in  STD_LOGIC;
                Clock_Out : out  STD_LOGIC;
                Div : in  integer
                );
    end component;
    
    component Display_RAM
        Generic (
                Addr_Width : integer := 20;
                Data_Width : integer := 8
                );
        Port (  Clock : in STD_LOGIC;
                Read_Write : in STD_LOGIC;
                Address : in STD_LOGIC_VECTOR((Addr_Width - 1) downto 0);
                Data_Out : out STD_LOGIC_VECTOR ((Data_Width - 1) downto 0);
                Data_In : in STD_LOGIC_VECTOR ((Data_Width - 1) downto 0)
                );
    end component;

begin

    Clock_25MHz     : Clock port map (Clock_In, Clock_Lock, Clock_VGA, Reset);
    Clock_100Hz     : Clock_Divider port map(Clock_VGA, Clock_100, 25000000);
    VGA_Top         : VGA port map (Clock_VGA, Reset, '1', Zeichen_RAM, Farbe, Pixel, Zeile, HSync, VSync, RGB);
    Display         : Display_RAM port map (Clock_VGA, '1', std_logic_vector(to_unsigned(Pixel, 20)), Zeichen_RAM, "00000000");
    
    process(Clock_VGA)
    begin
        if rising_edge(Clock_VGA) then
            Zaehler <= Zaehler + 1;
            
            if(Zaehler > 7) then
                Zaehler <= 0;
                Pixel <= Pixel + 1;
            end if;
        end if;
    end process;

    -- Betriebsstatus
    Output(0) <= not Reset;
    Output(1) <= Clock_Lock;

end Top_Arch;

Aber ich bekomme immer einen Implementierungsfehler:

[Place 30-640] Place Check : This design requires more F7 Muxes cells 
than are available in the target device. This design requires 69904 of 
such cell types but only 8800 compatible sites are available in the 
target device. Please analyze your synthesis results and constraints to 
ensure the design is mapped to Xilinx primitives as expected. If so, 
please consider targeting a larger device.

Im Prinzip muss ich doch nur die Pixel zählen (mit jedem Clock einen 
Pixel) und bei 8 Pixeln wird eine Stelle im RAM weiter gesprungen.

Aber wo ist der Fehler?
Danke für die Hilfe!

[Duke Scarring (Gast)]

Daniel K. schrieb:
> -- Target Devices:      XC7Z010CLG400-1
Wenn dies das richtige Device ist, hast Du laut Datenblatt 240 KB(yte) 
bzw. 60 BRAMs.


>             Addr_Width : integer := 20;
>             Data_Width : integer := 8
...
> type Display_RAM_Type is array (0 to (2**Address'length) - 1) of
> std_logic_vector(Data_In'range);
Hier verlangst Du vom Tool, Dir einen Speicher mit 2^20 Bytes zu 
erzeugen.
Den Rest darfst Du selber rechnen...

Duke

[Daniel K. (daniel_k80)]

Ahh danke :)
Hab mal einen Blick auf die Post-Synthese geworfen und da wurde es auch 
angezeigt...konnte den Fehler halt nicht zuordnen...
Wie kann ich den dann jetzt einen Displayinhalt vernünftig anzeigen 
lassen, wenn ich kein RAM im FPGA implementieren kann?
Gibt es da eine Möglichkeit?

[Duke Scarring (Gast)]

Daniel K. schrieb:
> Gibt es da eine Möglichkeit?
Ja, z.B. mit einem Zeichengenerator.
Oder man nutzt externen RAM.
Oder eine 'Funktion', die das Bild bei jedem Durchlauf neu generiert.

Duke

[peter (Gast)]

SRAM von außen zuführen evtl.

Eigentlich brauchst du Screenram  4800 Byte, wo der AScii drin steht zb 
für A = 65, B = 66 usw. , alle Ramzellen (4800 Byte) füllen. Dann ein 
RAM , für 256 Zeichen sind das 8x256=2048 Byte wenn ein Zeichen 8 Byte 
hoch ist.

Mehr brauchst du nicht.
Ist merkwürdig, das dein Ding nicht soviel BRAM anlegen kann.

Gruss

[Daniel K. (daniel_k80)]

peter schrieb:
> SRAM von außen zuführen evtl.
>
> Eigentlich brauchst du Screenram  4800 Byte, wo der AScii drin steht zb
> für A = 65, B = 66 usw. , alle Ramzellen (4800 Byte) füllen. Dann ein
> RAM , für 256 Zeichen sind das 8x256=2048 Byte wenn ein Zeichen 8 Byte
> hoch ist.
>
> Mehr brauchst du nicht.
> Ist merkwürdig, das dein Ding nicht soviel BRAM anlegen kann.
>
> Gruss

Ja genau so habe ich es bisher gemacht.
Ich habe mein Font-ROM da stehen die ASCII Zeichen drin (auch nach ASCII 
Tabelle). Dieses ROM ist 8x8096 groß (meine Zeichen sind 8x8 groß und 
ich habe die untersten drei Bits der Adresse vom Font-ROM für die Zeilen 
der Zeichen genommen und dann die obersten 8 Bits für die 256 Zeichen).
Wenn ich an meinem VGA-Controller nun als Zeichen die 65 angebe, so gibt 
er mir auf dem Display den Buchstaben "A" aus.

In meinem Display-RAM soll nun mein Bild stehen für ein 640x480 Monitor 
und idealerweise steht an jeder Stelle im RAM das Zeichen für 1 Zeichen 
(also ein 8x8 Feld) und diese Felder adressiere ich dann, lese das 
Zeichen aus und gib das Zeichen in den VGA-Controller, der es mir 
anzeigt.

Edit:
Mir ist gerade eingefallen....wenn ich ein 8x8 großes Zeichen habe, dann 
kann mein Bildschirm ja nur 80x60 Zeichen anzeigen.
Ich brauche also nur ein RAM, welches 80*60 groß ist mit einer Bitbreite 
von 8 (erst einmal Text only)
....Jetzt verstehe ich auch wo der Wert 4800 her kommt :/

[Daniel K. (daniel_k80)]

Ok ich habe meinen Display-RAM nun implementiert bekommen und am 
Bildschirm werden jetzt auch vier Zeichen ausgegeben. Allerdings sieht 
es so aus, als ob die von unten nach oben aufgebaut werden und das immer 
abwechselnd, sprich erst Zeichen 1, dann Zeichen zwei, etc.
Wie bekomme ich das nun "schöner" hin? Ich kann ja keinen schnelleren 
Takt als die 25MHz vom VGA nehmen oder?

----------------------------------------------------------------------------------
-- Company:             www.kampis-elektroecke.de
-- Engineer:            Daniel Kampert
-- 
-- Create Date:         05.03.2015 13:21:32
-- Design Name: 
-- Module Name:         Top - Top_Arch
-- Project Name: 
-- Target Devices:      XC7Z010CLG400-1
-- Tool Versions:       Vivado 2014.4
-- Description: 
-- 
-- Dependencies: 
-- 
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
-- 
----------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.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 Top is
    Port (  RGB         : out STD_LOGIC_VECTOR(15 downto 0);
            Input       : in STD_LOGIC_VECTOR(3 downto 0);
            HSync       : out STD_LOGIC;
            VSync       : out STD_LOGIC;
            Reset       : in STD_LOGIC;
            Clock_In    : in STD_LOGIC;    
            Output      : out STD_LOGIC_VECTOR(3 downto 0)
            );
end Top;

architecture Top_Arch of Top is

    signal Reset_In : std_logic;
    
    -- Clocksignale
    signal Clock_VGA    : std_logic;
    signal Clock_100    : std_logic;
    
    -- Systemsignale
    signal Clock_Lock : std_logic;
    
    -- Testsignale
    signal Display_Counter : integer := 0;
    signal Zaehler      : integer;
    signal Zeichen_RAM  : std_logic_vector(7 downto 0);
    signal Pixel    : integer := 0;
    signal Zeile    : integer := 1;
    signal Farbe    : std_logic_vector(15 downto 0) := x"F800";
    
    -- Erzeugung des 25,175MHz Taktes und einbinden des RAM Moduls
    component Clock is
        Port (  Clock_In    : in STD_LOGIC;
                Clock_Locked: out STD_LOGIC;
                Clock_Out   : out STD_LOGIC;
                Clock_Reset : in STD_LOGIC
                );
    end component Clock;
    
    component VGA is
        Generic (
                ROM_Address_Width   : integer := 11;
                ROM_Data_Width      : integer := 8;
                Char_Size           : integer := 8
                );
        Port (  Clock_VGA   : in STD_LOGIC;
                Reset       : in STD_LOGIC;
                Mode        : in STD_LOGIC; 
                Character   : in STD_LOGIC_VECTOR((ROM_Address_Width - 4) downto 0); 
                Color       : in STD_LOGIC_VECTOR(15 downto 0);
                Position    : in INTEGER;
                Zeile       : in INTEGER;
                HSync       : out STD_LOGIC;
                VSync       : out STD_LOGIC;
                RGB         : out STD_LOGIC_VECTOR(15 downto 0)
                );
    end component VGA;
    
    component Clock_Divider
        Port (  Clock_In : in  STD_LOGIC;
                Clock_Out : out  STD_LOGIC;
                Div : in  integer
                );
    end component;
    
    component Display_RAM
        Generic (
                Addr_Width : integer := 13;
                Data_Width : integer := 8
                );
        Port (  Clock : in STD_LOGIC;
                Read_Write : in STD_LOGIC;
                Address : in STD_LOGIC_VECTOR((Addr_Width - 1) downto 0);
                Data_Out : out STD_LOGIC_VECTOR ((Data_Width - 1) downto 0);
                Data_In : in STD_LOGIC_VECTOR ((Data_Width - 1) downto 0)
                );
    end component;

begin

    Clock_25MHz     : Clock port map (Clock_In, Clock_Lock, Clock_VGA, Reset);
    VGA_Top         : VGA port map (Clock_VGA, Reset, '1', Zeichen_RAM, Farbe, Pixel, Zeile, HSync, VSync, RGB);
    Display         : Display_RAM port map (Clock_VGA, '1', std_logic_vector(to_unsigned(Pixel, 13)), Zeichen_RAM, "00000000");
    
    process(Clock_VGA)
    begin
        if rising_edge(Clock_VGA) then
            Zaehler <= Zaehler + 1;
            
            if(Zaehler > 7) then
                Zaehler <= 0;
                Pixel <= Pixel + 1;
            end if;
            if(Pixel > 4) then
                Pixel <= 0;
            end if;
            
        end if;
    end process;

    -- Betriebsstatus
    Output(0) <= not Reset;
    Output(1) <= Clock_Lock;

end Top_Arch;

[Duke Scarring (Gast)]

Da hilft Dir eine (Diagnose-)Testbench weiter, die in Deinem Fall sogar 
recht schnell erstellt ist.

Duke

[René D. (Firma: www.dossmatik.de) (dose)]

Du kannst auch ander Pixelclocks wählen. Dann bist du bei anderen VGA 
Modi, die auch andere Auflösungen zulassen aber auch andere timings 
haben.

http://martin.hinner.info/vga/timing.html

[Daniel K. (daniel_k80)]

So ich habe den Code mal etwas umgebaut...

----------------------------------------------------------------------------------
-- Company:             www.kampis-elektroecke.de
-- Engineer:            Daniel Kampert
-- 
-- Create Date:         02.08.2014 13:17:51
-- Design Name: 
-- Module Name:         VGA - VGA_Arch
-- Project Name: 
-- Target Devices:      XC7Z010CLG400-1
-- Tool Versions:       Vivado 2014.4
-- Description:         VGA Interface for a 640 x 480 Pixel Screen
-- 
-- Dependencies: 
-- 
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
-- 
----------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.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 is
    Generic (
            Color_Width         : integer := 16;
            ROM_Address_Width   : integer := 11;
            ROM_Data_Width      : integer := 8;
            Char_Size           : integer := 8
            );
    Port (  Clock_VGA   : in STD_LOGIC;                                         -- Taktsignal für VGA-Logik
            Reset       : in STD_LOGIC;                                         -- Reset für VGA-Logik
            Mode        : in STD_LOGIC;                                         -- Auswahl Betriebsmodus, 0 -> Grafik, 1 -> Text
            Color       : in STD_LOGIC_VECTOR(15 downto 0);
            HSync       : out STD_LOGIC;                                        -- Ausgang für H-Sync Signal
            VSync       : out STD_LOGIC;                                        -- Ausgang für V-Sync Signal
            RGB         : out STD_LOGIC_VECTOR((Color_Width - 1) downto 0)      -- RGB Ausgang für das VGA-Signal
            );
end VGA;

architecture VGA_Arch of VGA is
    
    signal Counter: integer := 0;
    
    -- Display Cursor
    signal Cursor       : integer := 0;
    signal Position_Flag: std_logic;

    -- Koordinaten des Zeigers auf dem Bildschirm
    signal Pixel_x      : integer;                
    signal Pixel_y      : integer; 
    signal Zeile        : integer := 5;
    
    -- Font ROM
    signal ROM_Data     : std_logic_vector(0 to (ROM_Data_Width - 1));
    signal ROM_Address  : std_logic_vector(0 to (ROM_Address_Width - 1));
    signal ROM_Bit      : std_logic;
    signal Font_On      : std_logic;
    
    -- Display RAM
    signal Display_Address  : std_logic_vector(12 downto 0);
    signal Character        : std_logic_vector(7 downto 0); 
    signal Char_Counter     : std_logic_vector(10 downto 0);
 
    -- Adressierung für Zeile + Pixel 
    signal Row_Addr     : std_logic_vector(2 downto 0);
    signal Col_Addr     : std_logic_vector(2 downto 0);

    -- Einbinden des VGA-Controllers
    component VGA_Timing is
        Port (  HSync : out STD_LOGIC;
                VSync : out STD_LOGIC;
                Clock_VGA : in STD_LOGIC;
                Reset : in STD_LOGIC;
                x_out : out INTEGER;                
                y_out : out INTEGER 
                );
    end component VGA_Timing;  
    
    -- Font-ROM für VGA-Controller
    component Font_ROM is
        port (  ROM_Address : in STD_LOGIC_VECTOR (10 downto 0);
                ROM_Clock : in STD_LOGIC;
                ROM_DataOut : out STD_LOGIC_VECTOR (7 downto 0)
                );
    end component Font_ROM;
    
    -- Display RAM für das VGA Bild    
    component Display_RAM
        Generic (
                Addr_Width : integer := 13;
                Data_Width : integer := 8
                );
        Port (  Clock : in STD_LOGIC;
                Read_Write : in STD_LOGIC;
                Address : in STD_LOGIC_VECTOR((Addr_Width - 1) downto 0);
                Data_Out : out STD_LOGIC_VECTOR ((Data_Width - 1) downto 0);
                Data_In : in STD_LOGIC_VECTOR ((Data_Width - 1) downto 0)
                );
    end component;

begin

    VGA_Ctrl        : VGA_Timing port map (HSync, VSync, Clock_VGA, Reset, Pixel_x, Pixel_y);   
    Char_Font       : Font_ROM port map (ROM_Address, Clock_VGA, ROM_Data);
    Display         : Display_RAM port map (Clock_VGA, '1', "0000000000001", Character, "00000000");

    -- ROM auslesen
    Row_Addr    <= std_logic_vector(to_unsigned(Pixel_y, Row_Addr'length));
    ROM_Address <= Character & Row_Addr;
    Col_Addr    <= std_logic_vector(to_unsigned(Pixel_x, Col_Addr'length));
    ROM_Bit     <= ROM_Data(to_integer(unsigned(Col_Addr)));     

    Position_Flag <= '1' when ((Pixel_x >= Cursor) and (Pixel_x < (Cursor + Char_Size)) and (Pixel_y >= (8 * Zeile)) and (Pixel_y < (8 * Zeile) + Char_Size)) else '0';

    -- Display RAM auslesen
    --Display_Address <= "000" & std_logic_vector(to_unsigned((Pixel_x mod 8), 10));

    -- Farbausgabe
    process(Reset, Clock_VGA)
    begin
        if(rising_edge(Clock_VGA)) then
            if(Reset = '0') then
                RGB <= x"0000";
            else
                if(Pixel_x mod 8 = 7) then
                    Cursor <= Cursor + 1;
                end if;
                
                if(Cursor = 79) then
                    Cursor <= 0;
                end if;
            
                if((Position_Flag = '1') and (ROM_Bit = '1')) then
                    RGB <= Color;
                else
                    RGB <= x"0000";
                end if;
            end if;
        end if;
    end process;
  
end VGA_Arch;

Ich versuche nun das zweite Zeichen aus dem Display RAM auszulesen und 
dieses Zeichen auf der kompletten Displayreihe darzustellen (das ist ein 
A). Das Auslesen klappt schon mal und auch die Darstellung klappt mehr 
oder weniger gut (siehe Foto).
Leider flackern die Buchstaben noch recht stark und sind schwer zu 
erkennen...
Ich habe den Code auch mal simuliert und alle 8 Pixel wird der Cursor um 
eins hoch gezählt und dort soll dann der neue Buchstabe gezeichnet 
werden.
Leider klappt das nicht ganz so wunderbar....
Woran könnte das liegen?

[Duke Scarring (Gast)]

Ich würde mich erstmal auf die Sync-Signale konzentrieren.
Lt. Deiner Simulation ist HSYNC = '1' und VSYNC = 'U'. Das macht mich 
stutzig...

Duke

[Daniel K. (daniel_k80)]

Hallo Duke,

ja aber nur die ersten paar Mikrosekunden. :) (im Anhang ist noch mal 
eine längere Simulation) - vielleicht wäre es besser dem Signal noch 
einen Startwert von '1' zu geben?.
Ich habe meinen Code noch mal etwas überarbeitet, nachdem ich von 
funkheld mal ein lauffähiges Beispiel bekommen habe, welches ich 
erfolgreich auf mein Board portieren konnte.
Ich habe nun für die x- und y-Koordinaten einen Typ "unsigned" 
genommen...laut Internet soll der Typ ohnehin besser zum Rechnen sein 
(?).

entity VGA is
    Generic (
            Color_Width         : integer := 16;
            ROM_Address_Width   : integer := 11;
            ROM_Data_Width      : integer := 8;
            Char_Size           : integer := 8
            );
    Port (  Clock_VGA   : in STD_LOGIC; 
            Reset       : in STD_LOGIC; 
            Mode        : in STD_LOGIC;
            Color       : in STD_LOGIC_VECTOR(15 downto 0);
            HSync       : out STD_LOGIC; 
            VSync       : out STD_LOGIC;
            RGB         : out STD_LOGIC_VECTOR((Color_Width - 1) downto 0) 
            );
end VGA;

architecture VGA_Arch of VGA is

    signal Pixel_x      : unsigned(9 downto 0);               
    signal Pixel_y      : unsigned(9 downto 0); 
    
    signal ROM_Data     : std_logic_vector(0 to (ROM_Data_Width - 1));
    signal ROM_Address  : std_logic_vector(0 to (ROM_Address_Width - 1));
    signal ROM_Bit      : std_logic;
    signal Row_Addr     : std_logic_vector(2 downto 0);
    signal Col_Addr     : std_logic_vector(2 downto 0);
       
    signal Display_Address  : unsigned(12 downto 0);
    signal Zeichen_Address  : unsigned(6 downto 0);
    signal Reihen_Address   : unsigned(5 downto 0);
    signal Character        : std_logic_vector(7 downto 0); 

    component VGA_Timing is
        Port (  HSync : out STD_LOGIC;
                VSync : out STD_LOGIC;
                Clock_VGA : in STD_LOGIC;
                Reset : in STD_LOGIC;
                x_out : out UNSIGNED(9 downto 0);                
                y_out : out UNSIGNED(9 downto 0) 
                );
    end component VGA_Timing;  
    
    component Font_ROM is
        port (  ROM_Address : in STD_LOGIC_VECTOR (10 downto 0);
                ROM_Clock : in STD_LOGIC;
                ROM_DataOut : out STD_LOGIC_VECTOR (7 downto 0)
                );
    end component Font_ROM;
      
    component Display_RAM
        Generic (
                Addr_Width : integer := 13;
                Data_Width : integer := 8
                );
        Port (  Clock : in STD_LOGIC;
                Read_Write : in STD_LOGIC;
                Address : in STD_LOGIC_VECTOR((Addr_Width - 1) downto 0);
                Data_Out : out STD_LOGIC_VECTOR ((Data_Width - 1) downto 0);
                Data_In : in STD_LOGIC_VECTOR ((Data_Width - 1) downto 0)
                );
    end component;

begin

    VGA_Ctrl        : VGA_Timing port map (HSync, VSync, Clock_VGA, Reset, Pixel_x, Pixel_y);   
    Char_Font       : Font_ROM port map (ROM_Address, Clock_VGA, ROM_Data);
    Display         : Display_RAM port map (Clock_VGA, '1', "0000000000010", Character, "00000000");

    Row_Addr    <= std_logic_vector(Pixel_y(2 downto 0));
    ROM_Address <= Character & Row_Addr;
    Col_Addr    <= std_logic_vector(Pixel_x(2 downto 0));
    ROM_Bit     <= ROM_Data(to_integer(unsigned(Col_Addr)));     

    Zeichen_Address <= Pixel_x(9 downto 3);
    Reihen_Address <= Pixel_y(8 downto 3);
        
    RGB <= Color when (ROM_Bit = '1') else x"0000";

end VGA_Arch;

Das oben gezeigte Beispiel gibt nun lauter "L" auf dem Bildschirm aus 
(da nutze ich noch die feste Adresse 0000000000010 um das dritte Zeichen 
im Displayspeicher auszulesen).

Jetzt habe ich aber ein Problem mit dem automatischen Auslesen des 
Displayspeichers.
Wenn ich nun statt "0000000000010" das Signal ""000000" & 
std_logic_vector(Zeichen_Address)" einsetze, bekomme ich das auf dem 
zweiten Foto gezeigte Phänomen, obwohl der komplette Displayspeicher 
leer ist (bis auf das zweite Zeichen, was immer noch ein "L" ist).
Wenn ich die Adressierung der Zeilen weg lasse müsste ich doch in jeder 
Zeile an der zweiten Stelle ein "L" stehen haben, da ja der Zähler 
"Zeichen_Address" jede Zeile von neuem anfängt zu zählen.
Aber anscheinend habe ich da noch einen Versatz drin und ich habe keine 
Idee wo der her kommt (in der Simulation ist das auch zu erkennen).

Vielleicht hat ja jemand eine Idee woher das kommen könnte :)
In der Zwischenzeit suche ich schon mal weiter :o

[Sigi (Gast)]

Das ist ein typischer Latenzfehler: Du liest das Zeichen
aus einem Speicher (BlockRAM?) und dann das Zeichenpixel
aus einen Anderen (ebenfalls BlockRAM?).

Für das Zeichenpixel werden aber noch X- und Y-Koordinate
verwendet. Durch das Zeichen-RAM hst du jetzt eine Latenz
zu den Koordinaten. Aufheben kannst Du das, indem die
X- und Y-Koordinate (d.h. je 3 Bits) einmal (oder evtl.
mehrmals) pipelinest. Das "hebt" die Latenz auf.

[Daniel K. (daniel_k80)]

So neues update :)
Das Timing-Problem ist nun behoben....ich habe die x und y Koordinaten 
einmal durch nen Clock verzögert und dann war es weg (danke für den 
Tipp).
Bin auch schon fast am Ziel...ich habe jetzt mal das Wort "Hallo" 17x in 
das Display-RAM geschrieben (17*5 Zeichen = 85 Zeichen = 1 komplette 
Zeile + 1 Wort), aber das letzte "o" wird nicht angezeigt (dafür am 
Anfang ein "H" mehr), in der zweiten Zeile wird kein "Hallo" angezeigt 
und unten am Bildschirm habe ich weiße Punkte (siehe Screenshot).

Die Sourcen habe ich mal angehängt, da das sonst zu lang wird wenn ich 
diese immer poste...
Ich habe auch mal mein VGA Timing an das hier angepasst:

http://www.ece.unm.edu/~jimp/vhdl_fpgas/slides/VGA.pdf

Als Startpunkt für den Zähler habe ich jeweils die steigende Flanke vom 
Sync genommen, sprich in x-Richtung 48 Pixel, dann 640 sichtbare, dann 
16 nicht sichtbare und dann der Sync für 96 Pixel.
Analog bin ich beim V-Sync vorgegangen. Eventuell steckt da ja der 
Fehler?

[peter (Gast)]

Hallo, das sieht ja gut aus.
Warum hast du VGA_Timing 2x drin?

Kannst du die VHD Font-Rom auch mal reinsetzen. Dann könnte man es mal 
als ganzes Testen.

Danke.

GRuss

[peter (Gast)]

Wenn der Text nicht stimmt, musst du hier ein bisschen mit rumspielen.
Kann sein das der Monitor zu pingelig ist.

Gruss

WholeLine : integer     := 800;
VisibleArea_H : integer := 640;
BackPorch_H : integer   := 40;
SyncPulse_H : integer   := 96;

[peter (Gast)]

-- Description:         Display-RAM for VGA-Core
--                      (640x480, Charsize 8x8 -> 80x40 Chars per 
Screen)

Hmmm..., bei Charsize 8x8 hast du 80x60 Chars....
Dann nimm Cahrrsize 8x16...

GRuss

[Daniel K. (daniel_k80)]

Hallo,

peter schrieb:
> Hallo, das sieht ja gut aus.
> Warum hast du VGA_Timing 2x drin?
>
> Kannst du die VHD Font-Rom auch mal reinsetzen. Dann könnte man es mal
> als ganzes Testen.
>
> Danke.
>
> GRuss

mist...ich hatte da noch was an der Datei geändert...dachte er hätte die 
vorhandene Datei überschrieben.
Ich habe es im Anhang noch mal komplett als ZIP-Datei hochgeladen.

Zu dem 80x40...da habe ich mich verschrieben :)
Es ist alles für 80x60 Zeichen ausgelegt.
Ich probiere in der Zeit mal etwas weiter :)

[Daniel K. (daniel_k80)]

Daniel K. schrieb:
> Hallo,
>
> peter schrieb:
>> Hallo, das sieht ja gut aus.
>> Warum hast du VGA_Timing 2x drin?
>>
>> Kannst du die VHD Font-Rom auch mal reinsetzen. Dann könnte man es mal
>> als ganzes Testen.
>>
>> Danke.
>>
>> GRuss
>
> mist...ich hatte da noch was an der Datei geändert...dachte er hätte die
> vorhandene Datei überschrieben.
> Ich habe es im Anhang noch mal komplett als ZIP-Datei hochgeladen.
>
> Zu dem 80x40...da habe ich mich verschrieben :)
> Es ist alles für 80x60 Zeichen ausgelegt.
> Ich probiere in der Zeit mal etwas weiter :)

HA ein Problem habe ich schon mal gelöst :)
Im VGA-Timing musste

if((Pixel_Counter > (BackPorch_H + LeftBorder_H - 1)) and (Pixel_Counter < (VisibleArea_H + BackPorch_H + LeftBorder_H - 1))) then

durch

if((Pixel_Counter > (BackPorch_H - 1)) and (Pixel_Counter < (VisibleArea_H + BackPorch_H + LeftBorder_H - 1))) then

ersetzt werden.
Jetzt habe 16x "Hallo" in einer Zeile stehen. Fehlt nur noch das 17. 
"Hallo" in der zweiten Zeile

[peter (Gast)]

Hallo, warum hastdu hier noch color drin:
Color       : in STD_LOGIC_VECTOR(15 downto 0);
Da steht doch schon RGB?

Wofür ist das?

Danke.
Gruss

 Port (  Clock_VGA   : in STD_LOGIC; 
-- Taktsignal für VGA-Logik
            Reset       : in STD_LOGIC; 
-- Reset für VGA-Logik
            Mode        : in STD_LOGIC; 
-- Auswahl Betriebsmodus, 0 -> Grafik, 1 -> Text
            Color       : in STD_LOGIC_VECTOR(15 downto 0);
            HSync       : out STD_LOGIC; 
-- Ausgang für H-Sync Signal
            VSync       : out STD_LOGIC; 
-- Ausgang für V-Sync Signal
            RGB         : out STD_LOGIC_VECTOR((Color_Width - 1) downto 
0)      -- RGB Ausgang für das VGA-Signal
            );

[Daniel K. (daniel_k80)]

Hallo,

das ist quasi die Farbe die ich in dem Top_Design übergebe. RGB ist der 
Ausgang der auf den DAC geht und über Color sage ich welche Farbe er auf 
den DAC gibt.
Das kommt aber noch raus, wenn der Text + RAM läuft landet die Farbe mit 
im RAM und dann hole ich mir die da her.
Im Moment ist das einfach nur zum ausprobieren :)

[Sigi (Gast)]

Daniel K. schrieb:
> Das Timing-Problem ist nun behoben....ich habe die x und y Koordinaten
> einmal durch nen Clock verzögert und dann war es weg

So wie ich das auf die Schnelle sehe, hast Du die X-/Y-Koordinaten
gepipelined, aber nicht die ROW-/COL-Koordinaten wie von mir
vorgeschlagen (ROW bzw. COL werden aus Pixel_x/Pixel_y generiert).
Du hast also eine weitere Latenz drin.

Und: Du müsstest für exaktes Timing auch HSYNC/VSYNC zweimal
verzögern, denn dein Zeichenpixel kommt zwei Takte später an.

Mach Dir am Besten dazu ein einfachen Datengraph, bei dem jeder
Kante die Anzahl Verzögerungen zugeordnet werden. Dann muss in
jeden Knoten alle einlaufenden Pfade die selbe Gesamtzahl an
Verzögerungen aufweisen, ansonsten muss gepipelined werden.

Kleine Nebenbemerkung: Dein Font-RAM hat 8 Bits für Datenausgang,
ändere das doch auf ein Bit um, dann ist die Ansteuerung evtl.
einfacher.

[Daniel K. (daniel_k80)]

Hallo Sigi,

mmh ok dann hatte ich dich falsch verstanden. Ich habe es nun mal 
testweise so gemacht:

    process(Clock_VGA)
    begin
        if(rising_edge(Clock_VGA)) then
            Row_Addr_Delay <= std_logic_vector(Pixel_y(2 downto 0));
            Col_Addr_Delay <= std_logic_vector(Pixel_x(2 downto 0));   
        end if;
    end process;

Aber das hat die ganze Sache nur verschlimmert, wodurch der Text gar 
nicht mehr lesbar war :(
Das mit dem Datengraph verstehe ich nicht so ganz. Hast du da vielleicht 
mal ein Beispiel für mich, wo ich sehe wie du das meinst?

[Sigi (Gast)]

Also wenn der Text überhaupt nichtmehr lesbar ist, dann sind
noch ein paar grössere Hauer drin.

Aber zum Graph bzw. zur Analyse (Ann.: Pixel-ROM liefert nur
ein Bit zurück), Ansätze bzw. Interpretationen gibt es so
viele wie Lehr/Leerbücher:
Ein Zustand sei eine Menge von Signalwerten, ein Übergang/Kante
sei die Verarbeitung inkl. Speicherung(en) und Weitergabe an den
nächsten Zustand (dann ist ein einfache Register eine Kante mit
Verzögerung 1, die Eingabe-/Ausgabe-Werte die Zustände).

Bei Dir besteht dann auf VGA_top-Ebene der Startzustand S1 aus
HSync, VSync, Pixel_x, Pixel_y. Das Auslesen des Zeichens
ist dann eine Kante zum nächsten Zustand S2 (Zeichen-Code), mit
D1 Latenz. Von da dann eine Kante für das Auslesen des
Font-Pixels (D2 latenz) nach S3 mit Font-Pixel. Jetzt hast Du
aber noch eine Kante von S1 nach S3, denn Pixel_x und Pixel_y
werden als ROW und COL für dein Font-ROM verwendet.

Jetzt gilt für Pixel:
  S1->S2->S3 hat D1+D2 Delay
  S1->S3 hat D1 Delay,
d.h. für dein Zeichen-Pixel werden Signalwerte von t-D1-D2
als auch von t-D1 verwendet, also müssen ROW und COL und D2
verzögert werden. Für HSync und VSync hast du 0 Latenz, d.h
beide Signale müssen um D1+D2 verzögert werden.

Für Dein Problem bzw. Design ist das natürlich übertrieben,
ein erfahrener Designer eine trivale Geschichte.
Wenn Du aber mehr als 10 Komponenten mit unterschiedlichsten
Delays hast, dann kommst Du um eine formalere Beschreibung
nicht rum.

nur als komplexeres Beispiel: Ich habe eine komplette
Graphikanwendung mit Text, Graphik, Overlay, Windows und
verschiedensten Algos wie Linie, Dreieck, Z/W-Buffer etc. mit
den unterschiedlichsten Verzögerungen. Ohne einen solchen
Ansatz wäre das nur noch ein wildes Basteln, und das für jede
beliebige Konfiguration (ich habe bestimmt schon >= 50 Stück).

Versuch Dir also die Abläufe bzw. Delays klarzumachen und
entsprechend zu korigieren.

[Daniel K. (daniel_k80)]

Hallo Sigi,

danke für die ausführliche Erklärung :)
Das Verfahren wird mir aber leider noch nicht so recht deutlich. Hat 
dieses Verfahren einen speziellen Namen, welchen ich mal googlen könnte?
Dann kann ich mir ein bisschen dazu durchlesen :)
In der Zwischenzeit lasse ich das erstmal so "unsauber" und konzentriere 
mich darauf die Zeilenproblematik zu lösen (habe da gestern im Simulator 
schon die Ursache gefunden und muss nun nur noch eine Lösung 
erarbeiten).

Wenn das Ding dann so funktioniert werde ich die Timings schön machen. 
Habe gestern nämlich gemerkt, dass das Bild bei einem anderen Monitor 
etwas verschoben ist und so das erste "H" nur halb dargestellt wird.

[peter (Gast)]

Das verschieben der Zeilen kann von Monitor zu Monitor verschieden sein.
Da musst du an deinen Timingschrauben drehen.

Mit deinem Clock verschlimmert es sich noch wenn du später dein VGA 
erweitern möchtest, PS2-Tastatur , Grafikausgabe und RS232 
(Datenübertragung vom PC)

Ich habe nur 80x30 Auflösung mit funktionierender PS2 Tastatur. Wenn ich 
mein ROM auf 2400 Zeichen erweitere (19200 Byte , geht noch mit dem DE0) 
dann kann ich sogar ein Bild ins ROM ablegen und die Screenbelegung wird 
einfach immer von 0-2400 hochgezählt statt einen bestimmten Text 
auszugeben.

Weiterhin habe ich es mal übertrieben und noch RS232-RX eingebaut und 
kann jetzt auch ein Grafikbild mit 640X240 übertragen vom PC aus zum ROM 
und es wird sauber dargestelt. Die Grafik-Bytes werden als 
Ascii-Zeichen(8 byte 1 Zeichen) übertragen.

GRuss.

[Sigi (Gast)]

Hallo Daniel,

Daniel K. schrieb:
> Hat
> dieses Verfahren einen speziellen Namen, welchen ich mal googlen könnte?
> Dann kann ich mir ein bisschen dazu durchlesen :)

Dafür gibt's keine Namen, jeder Dozent hat da seine eigene/mehrere
Notationen. Und ein Buch bzw. Artikel kann ich Dir leider auch nicht
nennen.

Aber vlt. wird's ja einfacher, wenn man das Ganze auf der Zeitachse
betrachtet. Voraussetung für folgendes Beispiel ist, das FONT- als
auch CHAR-RAM jeweils 1 Takt brauchen und das FONT-RAM einen Pixel
zurückliefert:

-------------------------------------------------------------
time         :  .. t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 .. .. .. ..
-------------------------------------------------------------
sync:
  hsync  out :  .. h0 h1 h2 h3 h4 h5 h6 h7 h8 h9 .. .. .. ..
  vsync  out :  .. v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 .. .. .. ..

pos:
  x      out :  .. x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 .. .. .. ..
  y      out :  .. y0 y1 y2 y3 y4 y5 y6 y7 y8 y9 .. .. .. ..
-------------------------------------------------------------
delay1:
  x      in  :  .. x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 .. .. .. ..
  y      in  :  .. y0 y1 y2 y3 y4 y5 y6 y7 y8 y9 .. .. .. ..
  x1     out :  .. .. r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 .. .. ..
  y1     out :  .. .. s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 .. .. ..

delay2:
  x      in  :  .. x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 .. .. .. ..
  y      in  :  .. y0 y1 y2 y3 y4 y5 y6 y7 y8 y9 .. .. .. ..
  x2     out :  .. .. .. t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 .. ..
  y2     out :  .. .. .. u0 u1 u2 u3 u4 u5 u6 u7 u8 u9 .. ..

delay3:
  hsync  in  :  .. h0 h1 h2 h3 h4 h5 h6 h7 h8 h9 .. .. .. ..
  vsync  in  :  .. v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 .. .. .. ..
  hsync3 out :  .. .. .. .. i0 i1 i2 i3 i4 i5 i6 i7 i8 i9 ..
  vsync3 out :  .. .. .. .. j0 j1 j2 j3 j4 j5 j6 j7 j8 j9 ..
-------------------------------------------------------------
char ram:
  x      in  :  .. x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 .. .. .. ..
  y      in  :  .. y0 y1 y2 y3 y4 y5 y6 y7 y8 y9 .. .. .. ..
  ascii  out :  .. .. a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 .. .. ..

font ram (error):
  x      in  :  .. x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 .. .. .. ..
  y      in  :  .. y0 y1 y2 y3 y4 y5 y6 y7 y8 y9 .. .. .. ..
  ascii  in  :  .. .. a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 .. .. ..
  pixel  out :  .. .. .. p0 p1 p2 p3 p4 p5 p6 p7 p8 p9 .. ..

font ram (ok):
  x1     in  :  .. .. r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 .. .. ..
  y1     in  :  .. .. s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 .. .. ..
  ascii  in  :  .. .. a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 .. .. ..
  pix_ok out :  .. .. .. q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 .. ..
-------------------------------------------------------------
vga_sync (error):
  hsync  in  :  .. h0 h1 h2 h3 h4 h5 h6 h7 h8 h9 .. .. .. ..
  vsync  in  :  .. v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 .. .. .. ..
  hsync  out :  .. h0 h1 h2 h3 h4 h5 h6 h7 h8 h9 .. .. .. ..
  vsync  out :  .. v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 .. .. .. ..

vga_color (error):
  x      in  :  .. x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 .. .. .. ..
  y      in  :  .. y0 y1 y2 y3 y4 y5 y6 y7 y8 y9 .. .. .. ..
  pixel  in  :  .. .. .. p0 p1 p2 p3 p4 p5 p6 p7 p8 p9 .. ..
  color  out :  .. .. .. .. c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ..

vga(error)   :
  hsync  out :  .. h0 h1 h2 h3 h4 h5 h6 h7 h8 h9 .. .. .. ..
  vsync  out :  .. v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 .. .. .. ..
  color  out :  .. .. .. .. c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ..

vga_sync (ok):
  hsync3 in  :  .. .. .. .. i0 i1 i2 i3 i4 i5 i6 i7 i8 i9 ..
  vsync3 in  :  .. .. .. .. j0 j1 j2 j3 j4 j5 j6 j7 j8 j9 ..
  hsync3 out :  .. .. .. .. i0 i1 i2 i3 i4 i5 i6 i7 i8 i9 ..
  vsync3 out :  .. .. .. .. j0 j1 j2 j3 j4 j5 j6 j7 j8 j9 ..

vga_color (ok):
  x2     in  :  .. .. .. t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 .. ..
  y2     in  :  .. .. .. u0 u1 u2 u3 u4 u5 u6 u7 u8 u9 .. ..
  pix_ok in  :  .. .. .. q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 .. ..
  color  out :  .. .. .. .. c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ..

vga (ok):
  hsync3 out :  .. .. .. .. i0 i1 i2 i3 i4 i5 i6 i7 i8 i9 ..
  vsync3 out :  .. .. .. .. j0 j1 j2 j3 j4 j5 j6 j7 j8 j9 ..
  color  out :  .. .. .. .. c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ..
-------------------------------------------------------------

Alle Signalwerte bekommen einen Zeitstempel, der beim Verarbeiten
bzw. Auslesen aus RAM/ROM auf den nächsten Wert übertragen wird.
Ausserdem müssen alle Eingangsignale eines Verarbeitungsschritts
den selben Zeitstempel tragen! SEHR WICHTIG!!
<sync> und <pos> werden bei Dir durch VGA_timing generiert,
die Zeitstempel setze ich gleich den Zeitpunkten.
<delay1> bis <delay3> verzögern <pos>- und <sync>-Signale.
Und jetzt wird es interessant. Wärend <char ram> noch korrekt
arbeitet (a0 wird aus x0,y0 ein Takt später generiert), ist bei
<font ram (error)> ein Fehler. Denn p0 wird aus a0,x1,y1 bestimmt,
müsste aber aus a0,x0,y0 bestimmt sein! Und das setzt sich bei
der Ausgabe von <vga (error)> fort. Hier wird c0,h3,v3 zu einem
Zeitpunkt ausgegeben, es müsste aber c0,h0,v0 sein.
Bei mein <font ram (ok)> dageben wird q0 aus a0,r0,s0 bestimmt
(r,s sind verzögerte h,v!), ebenso wird von <vga (ok)> c0,i0,j0
als Color/HSync/VSync ausgegeben, d.h. alle Signale haben die
korrekten Zeitstempel.

Ich habe jetzt kein Vivado installiert, nur ISE, weiss also nicht,
wie deine BRAMs konfiguriert sind, d.h. meine Verzögerungen müssten
entsprechend angepasst werden.

Mach Dir einfach den Ablauf klar, sollte relativ einfach sein,
ist in etwa wie penibel Buchführung bzw. in der Autoproduktion
die Hochzeitszerimonie. Es ist nicht wie bei Software, wo eine
Funktion Werte zurückliefert und dann "wartet", bis sie wieder
aufgerufen wird. In Hardware werden IMMER Werte produziert, deshalb
ist nicht nur der Wert, sondern auch der Zeitstempel wichtig.

Und noch eine kleine Nebenbemerkung: Speicher Color/HSync/VSync
noch in Register bevor sie an die Pins gegeben werden, dann
werden alle 3 Signale etwa Zeitgleich und glitchfrei an Dein
TFT übertragen.

[Daniel K. (daniel_k80)]

Hallo,

danke für die Ausführliche Erklärung. Ich schaue mal ob ich das so 
verstanden habe...
Ich nehme mein VGA-Timing als Basis, da dort zu jedem Clockzeitpunkt 
(die Zeiten t0 - tn) eine x und eine y Koordinate erzeugt werden.

Warum wird dann aber der H- und V-Sync mitgezogen? Der wird doch erst 
nach x-Takten ausgelöst?

Die Punkte delay 1-3 verzögern die entsprechenden Signale einfach um 1-3 
Zyklen. Die werden dann später gebraucht um aus dem RAMs die richtigen 
Daten zu holen.
Da die RAMs geclockt sind, kommen die Daten immer einen Taktzyklus 
später. Die Signale, welche als Vektoren genutzt werden, werden dabei 
als einzelnes Bit dargestellt. Bei meinem Font-RAM müssen dem 
entsprechen die Vektoren für Zeile 0 und Spalte 0, sowie das 
entsprechende Zeichen bei den Koordinaten (also meine erste Stelle aus 
dem Display-RAM) eingegeben werden. Einen Clockzyklus später kommt dann 
meine entsprechende Pixelzeile (also Pixel 7-0) aus dem RAM.
Da dieses Pixel dann aber jetzt schon mehrere Zyklen zu spät kommt 
(bedingt durch die RAMs) muss ich die entsprechenden Koordinaten für 
dieses Pixel so lange verzögern bis ich wieder ein Signal erhalte, was 
zeitgleich mit dem entsprechenden Pixel läuft (in dem Beispiel wäre es 
eine Verzögerung von 2 für die Koordinaten).
Und mit diesen verzögerten x-y Koordinaten erzeuge ich dann meine 
Synchronisationssignale, die auch noch durch einen Takt verzögert 
werden, damit sie mit der Farbe überein stimmen (aber wofür sind dann 
h0.... und v0...? Bei den Syncs komme ich noch etwas durcheinander).

Ist das so korrekt?
Wenn ja, dann mache ich das mal für mein Design neu und schaue ob ich es 
hin bekomme und danach versuche ich das mal umzusetzen.
Ist zwar wahrscheinlich bissl Overhead für sowas "simples" wie VGA, aber 
so lerne ich das wahrscheinlich am besten :)

[Sigi (Gast)]

Hi,

so wie ich das auf die Schnelle sehe, hast Du es fast korrekt
wiedergegeben. Nur die Verzögerung der HSync-/VSync arbeitet
anders: Dein VGA_Timing generiert schon HSync und VSync, es
wird später nicht noch einmal generiert/berechnet, sondern nur
verzögert. Die Verzögerung ist wieder so eine Korrektheitsgeschichte.
Denn wenn Du Dein Design änderst (andere BRAMs mit mehr Latenz,
dann änder sich auch die Bildlage (Bild schiebt sich nach Rechts),
und genau das verhinderst Du mit einer flexiblen Verzögerung der
Sync-Signale. Du änderst also nur Dein Design, sondern passt die
Pipelines an die neue Latenz an und erhältst an immer der selben
Stelle auf dem TFT dein Bild.

Und ob Dein RAM jetzt getacktet ist oder nicht, spielt auch keine
Rolle. Nimm mal an, die RAMs sind ungetacktetes SRAM, dann erzeugt
Dein Design einen irre langen kombinatorischen Pfad (>>30-40 ns),
zwar mit den "zeitkorrekten" Werten, aber für höhere Auflösungen
viel zu langsam.

Dir scheint das jetzt als zu kompliziert für so eine "einfache"
Geschichte wie VGA-Textausgabe, aber bei vielen Designs kommt
es immer wieder vor, dass mehrerte Komponenten mit unterschiedlichen
Latenzen Signale liefern, die wieder in Phase gebracht werden
müssen, z.B. durch Pipelining.

Und für ein Neudesign: Nenn VGA_timing in VGA_CoreController um,
der erzeugt für eine vielzahl von neuen VGA-Controller (z.B.
Textausgabe, Graphikausgabe, einfache Farbbalken, SDRAM-Ansteuerung
etc.) die Basis-Signale (X-Pos,Y-Pos,H-Sync,V-Sync). Diese Signale
werden dann durch weitere Komponenten in die Farbsignale und die
verzögerten Sync-Signale transformiert, und zwar so, dass Dein
Bild immer konstant an einer exakten Stelle auf dem TFT erscheint.

P.S.: ich habe noch mal nach der Bezeichnung für obige Automaten
gesucht. Die werden z.B. auch gewertete/bewertete Automaten
genannt. E-Tech hat Schnittstellen zum MachBau und zur InfTech.
Da gibt's ähnliche Ansätze/Modelle. Die sind aber oft viel zu
kompliziert für so ein einfaches Problem, ich hab versucht, es
einfacher zu machen.

[Daniel K. (daniel_k80)]

Ok wunderbar :)
Jetzt nur noch eine theoretische Frage...
Solche Analysen über Delays etc. werden wann im Design Flow gemacht?
Ich denke mal die macht man dann während der Entwicklung des Designs 
oder, da man vor der Entwicklung des Designs, also quasi bei der 
Überlegung was das Design können muss, ja nicht genau weiß was sich wie 
verzögert (außer man hat RAMs etc. wo man weiß das die ein Delay 
verursachen).

[Daniel K. (daniel_k80)]

Hallo,

ich bin gerade dabei mir die Simulation mit Hilfe deiner Tabelle genauer 
anzusehen und mittlerweile wird das doch schon recht deutlich wo die 
Probleme stecken :)
Ich habe mir auch noch mal im Vivado den Block-Memory angeschaut (siehe 
Screenshot).
Der hat anscheinend zwei Clocks als Delay...mal schauen ob ich das noch 
bisschen gedrückt bekomme.

[Daniel K. (daniel_k80)]

Daniel K. schrieb:
> Hallo,
>
> ich bin gerade dabei mir die Simulation mit Hilfe deiner Tabelle genauer
> anzusehen und mittlerweile wird das doch schon recht deutlich wo die
> Probleme stecken :)
> Ich habe mir auch noch mal im Vivado den Block-Memory angeschaut (siehe
> Screenshot).
> Der hat anscheinend zwei Clocks als Delay...mal schauen ob ich das noch
> bisschen gedrückt bekomme.

Hallo,

so anhand deiner Vorlage habe ich mir mal einen Ablauf erstellt (dort 
sind auch die zwei Zyklen Block Memory Latenz mit drin)....siehe Anhang 
(ist eine Textdatei).
Zudem habe ich mal versucht das ganze dann im Code einzubauen (siehe 
ebenfalls Anhang).
Aktuell habe ich auf dem Bildschirm noch Pixelfehler drin (ich gebe erst 
einmal wieder eine Zeile aus dem RAM auf der kompletten Bildschirmhöhe 
aus)...ich bin da noch am suchen aber vielleicht kannst du dir das ja 
schon mal anschauen, damit ich weiß ob ich damit richtig liege :)

[Daniel K. (daniel_k80)]

So hab den Fehler doch schon gefunden :D
Ich hatte das hier stehen:

Row_Addr    <= std_logic_vector(Pixel_y_delay_1(2 downto 0));
ROM_Address <= Character & Row_Addr;
Col_Addr    <= std_logic_vector(Pixel_x_delay_1(2 downto 0));
ROM_Bit     <= ROM_Data(to_integer(unsigned(Col_Addr)));

Ich muss aber das zweite Delay nehmen:

Row_Addr    <= std_logic_vector(Pixel_y_delay_2(2 downto 0));
ROM_Address <= Character & Row_Addr;
Col_Addr    <= std_logic_vector(Pixel_x_delay_2(2 downto 0));
ROM_Bit     <= ROM_Data(to_integer(unsigned(Col_Addr)));

Und schon wird der Text schön angezeigt (sieht sogar besser aus als 
vorher...) :)
Wunderbar....noch ein paar mal mit dieser "Buchführung" arbeiten und 
dann sollte das sicher funktionieren.
Jetzt kann ich mich darauf konzentrieren die Sache rund zu machen etc. 
:)

Btw:
Gibt es eine Möglichkeit die ganzen Signale, die ich zum Verzögern 
verwende, schöner darzustellen bzw. zusammenzufassen?

[Daniel K. (daniel_k80)]

Heyho,

noch mal ein kurzes Update :)
Habe gestern noch etwas am Timing-Controller rum gearbeitet, da der 
Zeilenwechsel nicht geklappt hat....der hat mehrfach einen Offset von 80 
drauf gehauen, was daran lag, dass ich geschaut habe wann x(2 downto 0) 
= 0 war und diese Bedingung war über mehrere Taktzyklen aktuell...
Daher habe ich es jetzt so gemacht, dass der Counter pro Takt von 0-639 
zählt und dann bei 640 stehen bleibt und 640 quasi der "Reset"-Wert 
ist...
Jetzt klappt auch der Zeilenwechsel (siehe Fotos).

Ich habe nur noch am ersten Zeichen ein Pixel was zuviel ist (unter dem 
"H")...da muss ich noch schauen woher das kommt...ich denke aber mal das 
kommt vom Timing, da durch die getaktete Adresserzeugung ist alles 
wieder um einen Takt verschoben, aber das ist schnell behoben :)

Ich habe mal den Code ebenfalls hochgeladen, falls jemand Interesse hat!
Der nächste Schritt wird (neben der Behebung des Pixelfehlers) das 
einbringen von Farbiinformationen + Beschreiben des Display-RAMs und 
korrigieren der ASCII-Tabelle im Font-ROM sein.....aber es nimmt schon 
Formen an :)

[Daniel K. (daniel_k80)]

Hallo zusammen,

so ich habe das Display-RAM jetzt auch als BRAM ausgelegt, da ich 
ansonsten bei 51% Auslastung für Memory Lut gekommen wäre....
Bis auf einen kleinen Pixelfehler beim ersten Zeichen...aber da finde 
ich den Fehler nicht :( ...  mal schauen...
Ich habe jetzt mal einen Zähler aufgebaut, der einen festen Text aus dem 
Initialisierungsfile für das Display-RAM ausgibt und einen veränderbaren 
Text (einen Zähler) der ins Display-RAM geschrieben und danach angezeigt 
wird.

Ich lade es mal hoch, falls es sich jemand anschauen möchte.
Im Großen und Ganzen ist das Thema VGA damit für mich abgeschlossen 
(Grafikausgabe lasse ich erst einmal weg :) ).

Danke nochmal an alle beteiligten für eure Hilfe, wodurch ich ein ganzes 
Stück weiter gekommen bin!

[Sigi (Gast)]

So, nach der Zeichen-/Font-RAM-Latenz-Problematik kann's ja weiter
gehen. Dein Problem ist jetzt, dass Du die Zeichen-Addresse korrekt
(bzw. Wert/Latenz) bestimmen musst. "VGA-Timing" liefert x/y-Pos,
aus den unteren 3 Bits wird das Pixel, aus den Bits 3..n-1 die
Zeichenaddresse. Und dass impliziert wieder Latenz.

Es gibt zwei einfache Möglichkeiten:
1. Je Zeile Wird ein Zähler, startend mit Offset, inkrementiert.
   Nach 8 Zeilen wird dann der Offset um z.B. 40 inkrementiert
   etc.
2. Du bestimmst aus den höheren Bits die Addresse direkt:
   2.1.: per einfacher Multiplikation (Verschwendung einer MULT-Unit)
   2.2.: bei z.B. 40 kann 40 in 32+8 zerlegt werden, d.h. die Mult
         kann durch 2 ADD ersetzt werden. Damit hat man nach
         2 Taktzyklen die Zeichenaddresse.

Also hast du 3 Aufgaben:
1. Zeichenaddresse bestimmen (1-2 Takte)
2. Zeichen lesen (1-2 Takte)
3. Font-Pixel lesen (1-2 Takte)
Plus jeweils x-/y-Pos-Pipelining.

Für 1. werden Bits 3..n benötigt, für 3. Bits 0..2, d.h. nur die
ersten 3 Bits der x-/y-Pos werden für's Pipelining benötigt. Gibt
also im Extremfall 6*2*3 Bits zum Speichern (HSync/VSync exkl.).

[peter (Gast)]

Hallo, kannst du nur mal bitte die benötigten VHDL zum compilieren 
reinstellen?

danke.

Gruss

[Daniel K. (daniel_k80)]

Hallo Peter,

ist alles in dem ZIP-File.
Unter VGA.srcs\sources_1\imports\new sind die beiden VHDL Files für den 
VGA.
Das Font-ROM und das Display-RAM ist als Block Memory ausgelegt. Da habe 
ich keine VHDL Files für, da ich das mit dem IP-Designer gemacht habe.
Unter VGA\VGA.srcs\constrs_1\new ist das entsprechende XDC-File für die 
IO Belegung.

[peter (Gast)]

Jup, danke.

Gruss