VGA Text Mode Problem

[Samuel J. (capstrovor)]

Hallo

Ich bin gerade dabei mir eine Textausgabe zu schreiben.
Die VGA Ansteuerung funktioniert.
Aber wenn ich Buchstaben ausgeben will, dann fahren nur ein paar Striche 
über den Bildschirm.

library IEEE;
use IEEE.std_logic_1164.all;

entity vga_core is
port
(
  clk_50: in std_logic;
  red: out std_logic_vector(3 downto 0);
  green: out std_logic_vector(3 downto 0);
  blue: out std_logic_vector(3 downto 0);
  hsync: out std_logic;
  vsync: out std_logic
);
end vga_core;

architecture vga_core_arch of vga_core is

signal clk: std_logic;
signal lineCounter: integer:=0;
signal pixelCounter: integer:=0;

signal bm_pixelCounter: integer:=0; --bm für bitmap
signal bm_lineCounter: integer:=0;
signal signCounter: integer:=0;

type ascii is array (0 to 5, 0 to 4) of std_logic; 
signal ascii_a: ascii :=    (('0','1','1','1','0'),
                             ('1','1','0','1','1'),
                             ('1','0','0','0','1'),
                             ('1','1','1','1','1'),
                             ('1','0','0','0','1'),
                             ('1','0','0','0','1'));
type zeilenpuffer is array (0 to 79) of integer;
signal zeilenpuffer1: zeilenpuffer:= (others => 1);

begin
vga_clk: process(clk_50)
begin
  if rising_edge(clk_50) then
    clk <= NOT clk;
  end if;
end process vga_clk;

  zeilenpuffer1(0) <= 0;
  zeilenpuffer1(1) <= 0;


  
  ------------------------------------------------
vga_testpic: process(clk)
begin
  if clk = '1' then
    
    pixelCounter <= pixelCounter + 1;
    
    if pixelCounter = 800 then
      pixelCounter <= 0;
      signCounter <= 0;
      lineCounter <= lineCounter + 1;
    end if;
    
    if bm_pixelCounter = 640 then
      bm_pixelCounter <= 0;
    end if;
    
    if lineCounter = 524 then
      lineCounter <= 0;
    end if;
    
    if lineCounter > 13 AND lineCounter < 481 then
      bm_lineCounter <= bm_lineCounter + 1;
    end if;
    
    if pixelCounter > 112 AND pixelCounter < 641 then
      bm_pixelCounter <= bm_pixelCounter + 1;
    end if;
    
    if (bm_pixelCounter mod 8) = 0 then
      signCounter <= signCounter + 1;
    end if;
    
    if bm_lineCounter = 6 then
      bm_lineCounter <= 0;
    end if;
  ------------------------------------------------
    if pixelCounter > 704 AND pixelCounter < 800 then
      hsync <= '0';
    else
      hsync <= '1';
    end if;
    
    if lineCounter > 522 AND lineCounter < 524 then
      vsync <= '0';
    else
      vsync <= '1';
    end if;
  -------------------------------------------------
    if pixelCounter > 112 AND pixelCounter < 752 AND lineCounter > 13 AND lineCounter < 493 then
      
      red <= "0000";
      green <= "0000";  
      blue <= "0000";
      
      case zeilenpuffer1(signCounter) is
        when 0 => 
          if ascii_a(bm_pixelCounter, bm_lineCounter) = '1' then
            green <= "1111";
          else
            green <= "0000";
          end if;          
        when 1 => green <= "0000";
        when OTHERS => green <= "0000";
      end case;
    else
      red <= "0000";
      green <= "0000";
      blue <= "0000";
    end if;
  ------------------------------------------------
  end if;
end process vga_testpic;
end architecture vga_core_arch;

Ich dachte mir, dass es für eine (spätere) Tastatureingabe mit Video RAM 
nützlich wäre, einen Zeilenpuffer zu nehmen. Dort würde ich dann immer 
während der Schwarzschulter eine Zeile des VideoRam auslesen und in 
dieses Array schreiben. Momentan habe ich nur 0 für 'A' anzeigen und 1 
für nichts anzeigen. Wieso werden hier in jeder Zeile 2 'A's angezeigt?

mfg

[Samuel J. (capstrovor)]

Hier noch ein Bild zur Ausgabe.

PS: Eben diese Striche "flimmern" so nach unten über den Bildschirm

[Samuel J. (capstrovor)]

PS: der Violettstich kommt von meiner Kamera ;)

[peter (Gast)]

Ich stell mir das so vor das man ohne eine Zeilenabfrage bei 320x240 
9600 Byte einlesen muss damit der Screen voll ist.

if pixelCounter >= 0 AND pixelCounter <= 319 AND lineCounter >= 0 AND lineCounter <= 239 then
  red <= "0000";
  green <= "0000";
  blue <= "0000";
  
  if bitmap_pixelCounter <= 7 then   
    bitmap_pixelCounter <= bitmap_pixelCounter + 1;
    
    if ascii(bitmap_pixelCounter) = '1' then
      green <= "1111";
    else
      green <= "0000";
    end if;
  else
    bitmap_pixelCounter <= 0;
    hier 0-9599 Ascii aus Array einlesen  bei 320x240 Pixel ???
  end if;
  
else  
  red <= "0000";
  green <= "0000";
  blue <= "0000";
end if;

Kann aber auch falsch liegen...

[peter (Gast)]

Hallo, guten Tag.
Ich habe jetzt mal ein Bild 320x240 umgewandelt und in ein Array 
gelesen.
Das Bild erscheint zwar, aber es sind dazwischen senkrechte Lnien und 
die Kreisabschnitte werden verkehrt eingelesen.

Wo liegt der Fehler.

Danke.

[peter (Gast)]

Das ist das original BMP-Bild 320x240 :

Gruss

[Selbsternannter Weltverbesserer (Gast)]

Hallo,

peter schrieb:
> Das Bild erscheint zwar, aber es sind dazwischen senkrechte Lnien und
> die Kreisabschnitte werden verkehrt eingelesen.

zu letzterem:
MSB und LSB vertauscht?
http://de.wikipedia.org/wiki/Bitwertigkeit

Mit freundlichen Grüßen
Selbsternannter Weltverbesserer

[Selbsternannter Weltverbesserer (Gast)]

Hallo,

Selbsternannter Weltverbesserer schrieb:
> zu letzterem:
> MSB und LSB vertauscht?
> http://de.wikipedia.org/wiki/Bitwertigkeit

...oder die Reihenfolge der Spalten ist falsch.

Mit freundlichen Grüßen
Selbsternannter Weltverbesserer

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

peter schrieb:
> Wo liegt der Fehler.
1. Bitreihenfolge vertauscht.
2. vermutlich Latency in diesem Bereich:

        RomAddr <= RomAddr + 1;  
        if RomAddr = 9599 then
          romaddr <= 0;
        end if;
        ascii <= std_logic_vector(ascii_rom(RomAddr));

RomAddr hat beim Zugriff auf das ascii_rom noch den alten Wert! Du 
könntest diese Zeilen ebensogut auch so schreiben:

        RomAddr <= RomAddr + 1;  
        ascii <= std_logic_vector(ascii_rom(RomAddr));  
        if RomAddr = 9599 then
          romaddr <= 0;
        end if;

Oder so:

        ascii <= std_logic_vector(ascii_rom(RomAddr));  
        RomAddr <= RomAddr + 1;  
        if RomAddr = 9599 then
          romaddr <= 0;
        end if;

Der Synthesizer wird in ALLEN 3 Fällen EXAKT die selbe Hardware machen!
die Ursache liegt im Verhalten von Signalen in Prozessen: erst "am Ende" 
des Prozesses wird RomAddr den zuletzt zugewiesenen Wert "übernehmen".

Noch zwei Anmerkungen.
Das hier nennt man umgangssprachlich eine kombinatorische Schleife:

  if clk = '1' then
    pixelCounter <= pixelCounter + 1;

Siehe 
http://www.lothar-miller.de/s9y/archives/42-Kombinatorische-Schleifen.html
Aber augenscheinlich hat dein Synthesizer erkannt, dass du das nicht 
willst und was halbwegs Sinnvolles draus gemacht...

So werden keine Takte gemacht!

    clk <= NOT clk;

Wofür sind im FPGA Taktmanager eingebaut?

[peter (Gast)]

Entschuldigung, mein Purebasicprogramm war falsch geschrieben.
Jetzt ist der Kreis zu sehen, aber noch mit senkrechten Linien. Was wird 
da zuviel eingelesen?

Danke.
Gruss

[peter (Gast)]

Hier die VHDL

Gruss

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

peter schrieb:
> Was wird da zuviel eingelesen?
Nichts. Es wird einfach nur falsch "eingelesen".
Den Grund habe ich schon genannt: das Verhalten von Signalen in 
Prozessen.

[peter (Gast)]

Hmmm...ich kann das Fehlverhalten hier nicht lokalisieren für die 
schwarze linie , weiss auch nicht, wie ich das Zählen verlagern kann.
:
if pixelCounter >= 0 AND pixelCounter <= 319 AND lineCounter >=  0 AND 
lineCounter <= 239 then

vga_testpic: process(clk)

variable bitmap_pixelCounter: integer:=0; 

begin
  if rising_edge(clk) then
    
    pixelCounter <= pixelCounter + 1;
      
    if pixelCounter = 800 then
      pixelCounter <= 0;
      bitmap_pixelCounter := 0;
      lineCounter <= lineCounter + 1;
    end if;
    
    if lineCounter = 525 then
      lineCounter <= 0;
    end if;

    if pixelCounter >= 655 AND pixelCounter  <= 751 then
      hsync <= '0';
    else
      hsync <= '1';
    end if;
    
    if lineCounter  >= 489 AND lineCounter <= 491 then
      vsync <= '0';
    else
      vsync <= '1';
    end if;
  
    if pixelCounter >= 0 AND pixelCounter <= 319 AND lineCounter >=  0 AND lineCounter <= 239 then
      red <= "0000";
      green <= "0000";
      blue <= "0000";  
      
      if bitmap_pixelCounter <= 7 then  
        if ascii(bitmap_pixelCounter) = '1' then
          green <= "1111";
        else
          green <= "0000";
        end if;
      else
        bitmap_pixelCounter := 0;
        RomAddr <= RomAddr + 1;  
        
        if RomAddr = 9599 then
          romaddr <= 0;
        end if;
        
        ascii <= std_logic_vector(ascii_rom(RomAddr));          
      end if;   
    else
      red <= "0000";
      green <= "0000";
      blue <= "0000";
    end if;
    
    bitmap_pixelCounter := bitmap_pixelCounter + 1;
  end if;
end process vga_testpic;

end architecture vga_core_arch;

Danke.
Gruss

[peter (Gast)]

Ich meine diese Zählschleife:
if bitmap_pixelCounter <= 7 then

Gruss

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

Das hier:

    if pixelCounter >= 0 AND pixelCounter <= 319 AND lineCounter >=  0 AND lineCounter <= 239 then
      red <= "0000";
      green <= "0000";
      blue <= "0000";  
      
      if bitmap_pixelCounter <= 7 then  
        if ascii(bitmap_pixelCounter) = '1' then
          green <= "1111";
        else
          green <= "0000";
        end if;
      else
        bitmap_pixelCounter := 0;
        RomAddr <= RomAddr + 1;  
        
        if RomAddr = 9599 then
          romaddr <= 0;
        end if;
        
        ascii <= std_logic_vector(ascii_rom(RomAddr));          
      end if;   
    else
      red <= "0000";
      green <= "0000";
      blue <= "0000";
    end if;

Liesse sich so übersichtlicher schreiben:

    red <= "0000";
    green <= "0000";
    blue <= "0000";  
    if pixelCounter >= 0 AND pixelCounter <= 319 AND lineCounter >=  0 AND lineCounter <= 239 then
      if bitmap_pixelCounter <= 7 then  
        if ascii(bitmap_pixelCounter) = '1' then
          green <= "1111";
        end if;
      else
        bitmap_pixelCounter := 0;
        RomAddr <= RomAddr + 1;  
        
        if RomAddr = 9599 then
          romaddr <= 0;
        end if;
        
        ascii <= std_logic_vector(ascii_rom(RomAddr));          
      end if;   
    end if;

Dein Problem liegt auch in diesem Bereich: du darfst nicht sagen 
"solange bitmap_pixelCounter kleiner als 8 ist, mache das Eine, und 
sonst mache ein einziges Mal das Andere". Sondern du musst die Ausgabe 
erledigen und wenn nötig parallel neue Daten holen. Also in etwa so:

    red   <= "0000"; -- Defaultwerte
    green <= "0000";
    blue  <= "0000";  
    if pixelCounter >= 0 AND pixelCounter <= 319 AND lineCounter >=  0 AND lineCounter <= 239 then
      if ascii(bitmap_pixelCounter) = '1' then -- immer Pixeldaten ausgeben
        green <= "1111";
      end if;

      if bitmap_pixelCounter = 8 then          -- ab und zu gleichzeitig den Zähler zurücksetzen
        bitmap_pixelCounter := 0;
        RomAddr <= RomAddr + 1;  
        if RomAddr = 9599 then
          romaddr <= 0;
        end if;
        ascii <= std_logic_vector(ascii_rom(RomAddr));          
      else
      end if;   
    end if;

BTW
Ein wenig ungeschickt, dass in deinem Code der bitmap_pixelCounter 
niemals 0 werden kann:

        bitmap_pixelCounter := 0;
    :
    :
    bitmap_pixelCounter := bitmap_pixelCounter + 1;

[peter (Gast)]

jup, jetzt wird das Array-Bild gezeichnet mit 320x240 Pixel. 9600 Byte 
aus dem Array bilden den Screen ab als Kreis. Es läuft auf dem DE0/DE1.

So sieht jetzt dieses VHDL aus:

if pixelCounter >= 0 AND pixelCounter <= 319 AND lineCounter >=  0 AND lineCounter <= 239 then    
      if bitmap_pixelCounter <= 7 then  
        if ascii(bitmap_pixelCounter) = '1' then
          green <= "1111";
        else
          green <= "0000";
        end if;
      else
        bitmap_pixelCounter := 0;
        RomAddr <= RomAddr + 1;  
        if RomAddr = 9599 then
          romaddr <= 0;
        end if;
        ascii <= std_logic_vector(ascii_rom(RomAddr));          
      end if;   
    else
      red <= "0000";
      green <= "0000";
      blue <= "0000";
    end if;
    bitmap_pixelCounter := bitmap_pixelCounter + 1;
  end if;

Gruss.

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

Peter, kreuze die beiden richtigen Antworten an:
[ ] ich habe nicht verstanden, was Lothar mit "Defaultwerten" meinte
[ ] ich habe auch das mit dem "parallel neue Daten holen" nicht 
verstanden

peter schrieb:
> jetzt wird das Array-Bild gezeichnet
Das ist nicht das Bild aus dem 
Beitrag "Re: VGA Text Mode Problem"
Das Problem ist nämlich immer noch das selbe. Du hast es nur vertuscht, 
indem du den "letzten" Wert eines Bytes doppelt ausgibst. Genau dort, wo 
vorher schwarze Linien waren, hast du jetzt nämlich Sprünge.

Naja, was schreibe ich auch... :-(

[peter (Gast)]

So ist es ..habe es nicht verstanden, kannst jetzt jubeln.
Man...man..was bist du für ein Mensch..traurig..traurig.
Was hast du für ein beschissenes leben.

Danke für deine Hilfe.

Gruss

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

peter schrieb:
> So ist es ..habe es nicht verstanden, kannst jetzt jubeln.
Worüber denn?
Und warum sagst du das nicht früher mit dem "nicht verstanden"?
Oben sieht es ja so aus als ob du es verstanden hättest. Ich schreibe 
eine ganze Litanei, du ignorierst sie und schreibst "jup, jetzt wird das 
Array-Bild gezeichnet". Aber du schreibst mit keiner Silbe dass dir 
nicht klar ist, was ich meine! Und dass der Fehler nur versteckt ist, 
das hätte dir auch auffallen können...

> Man...man..was bist du für ein Mensch..traurig..traurig.
> Was hast du für ein beschissenes leben.
Wie man es sieht. Ich bin auf jeden Fall nicht so verbittert und 
lernresistent wie du...

> Danke für deine Hilfe.
Bitte. Du solltest aber nicht die Hand beißen, die dir hilft.

[peter (Gast)]

Hmmm.., ich habe eine Lösung gesucht, wie ich das zb mit "if test = ..." 
evtl umschiffen kann als Anfänger.

Gruss

[peter (Gast)]

-----------------
Ein wenig ungeschickt, dass in deinem Code der bitmap_pixelCounter
niemals 0 werden kann:
----------------

Wie kann man das umgehen...das suche ich schon ein weile.

Danke.
Gruss

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

Ich bekomme mit deinem Code gleich die Warnung:

WARNING:Xst:790 - "vga_core.vhd" line 1032: Index value(s) does not match array range, simulation mismatch.

Mit einer kleinen Bereichseinschränkung ist die schon mal behoben:

variable bitmap_pixelCounter: integer range 0 to 7 := 0;

Die hier sieht selbsterklärend aus:

WARNING:Xst:819 - "vga_core.vhd" line 999: One or more signals are missing in the process sensitivity list. 
... The missing signals are:   <lineCounter>, <ascii_rom>

Die Ursache ist aber diese Zeile hier:

  if clk = '1' then

Denn der Synthesizer erkennt so nicht, dass der Prozess getaktet sein 
sollte und macht einen kombinatorischen Prozess draus. Und bei einem 
kombinatorischen Prozess fehlen dann die angemeckerten Signale.

In der Summe habe ich deine Bescheibung mal angepackt und geradegebogen. 
Jetzt läuft sie ohne Warnungen und mit bitmap_pixelCounter von 0..7 
durhc den Synthesizer. Probier mal aus, was damit herauskommt...

[peter (Gast)]

-----------------
if clk = '1' then
------------------
habe ich schon ersetzt durch :
if rising_edge(clk) then  oder  :
wait until rising_edge(CLK);

Gruss

[peter (Gast)]

Jup, danke für deine Hilfe.

Das Bild ist ganz grün, alle Pixel von x=0-319 und y=0-239 sind 
gesetzt, kein Muster von nicht gesetzten Pixel erkennabr.

Vielleicht sollte man eine anderen Lösung anstreben um ein Array als 
Screen sichtbar zu machen bzw die Zählart ändern für die einzelnen Pixel 
vom Byte.?

Gruss

[Erklärbär (Gast)]

Wo ist denn eigentlich der TEXT in Deiner Anwendung?

[peter (Gast)]

Ich möchte jetzt ein Grafikbildarray(9600 Byte) 320x240 Pixel einlesen 
in den ganzen Screen, kein Text. Text ist ja wie ein Sprite, das ist 
keine Schwierigkeit mit dem einlesen und da treten keine Fehler auf.

Gruss

[Markus F. (mfro)]

Das muß nicht die Ursache sein, aber

clken25

 irgendwo mit irgendwas zu initialisieren, wär' sicher 'ne gute Idee.

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

Markus F. schrieb:
> Das muß nicht die Ursache sein, aber clken25 irgendwo mit irgendwas zu
> initialisieren
Ist egal. Das macht der Synthesizer sowieso. Nicht initialisierte 
Signale werden üblicherweise mit '0' belegt. Aber richtig: bei der 
Simulation merkt man das schnell...

[Lattice User (Gast)]

Lothar Miller schrieb:
>
> In der Summe habe ich deine Bescheibung mal angepackt und geradegebogen.
> Jetzt läuft sie ohne Warnungen und mit bitmap_pixelCounter von 0..7
> durhc den Synthesizer. Probier mal aus, was damit herauskommt...

Hat einen kleinen Fehler: RomAddr wird bei jeder Zeile wieder auf 0 
gesetzt, statt nur bei jedem Bild.

[peter (Gast)]

Ich habe jetzt ein Linienbild gezeichnet um die Fehler besser zu 
erkennen.
Originalbild als BMP und ein Bild von SCreen.

Ich weiss nicht woran es liegt.
Läuft auf DE1 und DE0.

Gruss

[peter (Gast)]

Hier das BMP-Bild:

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

Lattice User schrieb:
> Hat einen kleinen Fehler: RomAddr wird bei jeder Zeile wieder auf 0
> gesetzt, statt nur bei jedem Bild.
Ja, böse Sache.

peter schrieb:
> Ich weiss nicht woran es liegt.
Ich auch nicht, deshalb habe ich jetzt mal in der Vesperpause eine 
Testbench aufgesetzt und das Timing vom RAM-Zugriff weggezerrt und 
geradegebogen. Laut Waveform der Simulation müsste es jetzt in etwa tun. 
Peter, probiers mal aus...

[peter (Gast)]

Ja danke Lothar jetzt sind keine Pixelfehler mehr vorhanden.
Vielen...vielen dank es funktioniert jetzt einwandfrei auf dem DE1 und 
DE0.

Was heisst das hier:
Timing vom RAM-Zugriff weggezerrt

Vielen dank.

Gruss

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

peter schrieb:
> Was heisst das hier:  Timing vom RAM-Zugriff weggezerrt
Das Timing wird im Prozess gemacht, der Zugriff auf die bilddaten im RAM 
in einer nebenläufigen Zuweisung.

> jetzt sind keine Pixelfehler mehr vorhanden.
So hat es die Simulation vorausgesagt... ;-)
Du solltest dich echt mal mit dem Thema beschäftigen. Es wird dir das 
Verständnis deiner Beschreibungen erleichtern.

> Ja danke Lothar
Bitte.

[peter (Gast)]

Bei der Nebenläufigen Zuweisung : ascii <= 
std_logic_vector(ascii_rom(RomAddr));

kann ich die Daten nicht mehr ändern, es kommt die Meldung bei der 
Änderung der Daten :
Error (276003): Cannot convert all sets of registers into RAM 
megafunctions when creating nodes.
The resulting number of registers remaining in design exceeds the number 
of registers
in the device or the number specified by the assignment 
max_number_of_registers_from_uninferred_rams.
This can cause longer compilation time or result in insufficient memory 
to complete Analysis and Synthesis

wenn ich damit Daten zuweisen möchte :
if switch(0) = '1' then
  ascii_rom(Ramaddr )<= x"ff";
end if;

Ich möchte gerne über die serielle Schnittstelle die Grafik überspielen, 
welches funktioniert
wenn die nebenläufige Anweisung im Prozess steht. Bloss dann tritt der 
Grafikfehler wieder auf.

Danke.
Gruss

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use ieee.numeric_std.ALL;

entity vga_core is
port
(
  clk_50: in std_logic;
  red: out std_logic_vector(3 downto 0);
  green: out std_logic_vector(3 downto 0);
  blue: out std_logic_vector(3 downto 0);
  hsync: out std_logic;
  RXD    : in   STD_LOGIC;
  switch :  in std_logic_vector(1 downto 0); 
  vsync: out std_logic
);
end vga_core;

architecture vga_core_arch of vga_core is

signal clken25: std_logic := '0';
signal lineCounter: integer range 0 to 525 := 300; 
signal pixelCounter: integer range 0 to 800 := 0;

signal ascii : std_logic_vector(7 downto 0);
signal RomAddr  : integer range 0 to 9599 := 0;
signal ramAddr  : integer range 0 to 9599 := 0;

signal bitmap_pixelCounter: integer range 0 to 7 := 0; 
signal inpicture : std_logic := '0';

type Rom is array (0 to 9599) of unsigned (7 downto 0); 
signal ascii_rom : Rom;

begin
clken25 <= not clken25 when rising_edge(clk_50);

process
  begin
    wait until rising_edge(clk_50);
    
    if switch(0) = '1' then
      ascii_rom(Ramaddr )<= x"ff";
    end if;  
     
    if clken25='1' then
      if pixelCounter = 800 then
        pixelCounter <= 0;
        if lineCounter = 525 then
          lineCounter <= 0;
        else
          lineCounter <= lineCounter + 1;
        end if;
    else 
      pixelCounter <= pixelCounter + 1;
    end if;
    
    if pixelCounter >= 655 AND pixelCounter  <= 751 then
      hsync <= '0';
    else
      hsync <= '1';
    end if;
     
    if lineCounter  >= 489 AND lineCounter <= 491 then
      vsync <= '0';
    else
      vsync <= '1';
    end if;
   
    inpicture <= '0';
    if pixelCounter >= 0 AND pixelCounter <= 319 AND lineCounter >=  0 AND lineCounter <= 239 then  -- im Bildbereich  
      inpicture <= '1';
      if bitmap_pixelCounter < 7 then  
        bitmap_pixelCounter <= bitmap_pixelCounter + 1;
      else
        bitmap_pixelCounter <= 0;
        RomAddr <= RomAddr + 1;  
        if RomAddr = 9599 then
          RomAddr <= 0;
        end if;
      end if;   
    end if;
  end if;
end process;
   
  ascii <= std_logic_vector(ascii_rom(RomAddr)); 

  red   <= "0000";
  blue  <= "0000";
  green <= "1111" when ascii(bitmap_pixelCounter) = '1' and inpicture='1' else "0000";

end architecture;