Brauche dringend Hilfe mit 4Gewinnt

[Denis (Gast)]

Hallo,
ich brauche bitte eure Hilfe mit einem 4 Gewinnt, welches ich in VHDL 
für einen XILINX Spartan auf einem Evaluation Board entwickle.
Das ganze wird mit einer externen Platine worauf sich eine DuoLED 7x6 
Matrix befindet, inklusive Taster für die Spalten(inp(0) - inp(6)) und 
einem Reset Taster(inp(7))

Das ganze funktioniert bei mir in meiner Testbench(angehängt) 
einwandfrei, sobald ich es allerdings synthetisiere, verhält sich das 
Board komplett anders, es wird z.b. stets nur die 1. Spalte mit 
"Steinen" aufgefüllt, obwohl ein anderer Taster gedrückt wird. Lediglich 
der Reset Taster funktioniert so wie er soll.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;


entity ledmatrix is
  PORT
  (
  
    clk    : IN  std_logic; -- 50 MHz Quartz
      ledout   : OUT  std_logic_vector (0 to 23) := "000000000000000000000000"; 
    inp    : IN std_logic_vector (0 to 7); -- 0-6 = Spaltentaster, 7 = Reset  
    segments : out  std_logic_vector (0 to 7) := "00000000" 
    
  );

end ledmatrix;


architecture Behavioral of ledmatrix is

--Matrixmultiplex
type matrixB is array (1 to 8, 1 to 7) of integer range 0 to 3;
signal matP      : matrixB := (others => (others => 0)); --0 = None, 1=Rot, 2=Grün, 3=Gelb
signal f_multiplex: std_logic := '0'; -- 800Hz
-------------------

--Logik
signal win        : integer range 0 to 2 := 0;
-------------------

--Taster entprellen
signal inp_entp    :  std_logic_vector (0 to 7) := "00000000";
type intB is array(0 to 7) of integer range 0 to 50000;
signal inp_entp_cnt  :   intB := (others => 0);
signal inp_trigger  : std_logic := '0';
-------------------

begin




--------------Taster entprellen----------------------
process (clk)
begin 

  if rising_edge(clk) then
  -----------
  for i in 0 to 7 loop
  
    if (inp(i) = inp_entp(i)) then
      inp_entp_cnt(i) <= 0;
    else 
      inp_entp_cnt(i) <= inp_entp_cnt(i) + 1;
    end if;
  -----------
    if (inp_entp_cnt(i) = 50000) then
      inp_entp(i) <= inp(i);
    end if;
    
  end loop;
  end if;
end process;

inp_trigger <= inp_entp(0) or inp_entp(1) or inp_entp(2) or inp_entp(3) or inp_entp(4) or inp_entp(5) or inp_entp(6) or inp_entp(7); 
--------------------------------------------------------

--Schalterauswertung--
process
variable xls         : integer range 0 to 7 := 0;
variable yls         : integer range 0 to 6 := 0;

variable checkC      : integer range 0 to 4 := 0;
variable checkF      : integer range 0 to 2 := 0;

variable currentPlayer : std_logic := '0';

type intA is array(0 to 7) of integer range 0 to 8;
variable CountS      : intA := (others => 0);

variable isWin        : std_logic := '0';
begin

wait until rising_edge(inp_trigger);
  
  --Reset
  if inp_entp(7) = '1' then
  
  currentPlayer := '0'; 
  win <= 0;
  xls := 0;
  
  --Matrix zurücksetzen
  for x in 1 to 7 loop 
  
  CountS(x) := 0;
  
    for y in 1 to 6 loop
    matP(x, y) <= 0;
    end loop;

  end loop;
  
  ---Kein Reset
  elsif win = 0 then
  
  xls := 1;
  
  if inp_entp(0) = '1' then
  xls := 1;
  elsif inp_entp(1) = '1' then
  xls := 2;
  elsif inp_entp(2) = '1' then
  xls := 3;
  elsif inp_entp(3) = '1' then
  xls := 4;
  elsif inp_entp(4) = '1' then
  xls := 5;
  elsif inp_entp(5) = '1' then
  xls := 6;
  elsif inp_entp(6) = '1' then
  xls := 7;  
  end if;
  
  CountS(xls) := CountS(xls) + 1;
  
--Gewinnauswertung Start

    yls := CountS(xls);

    if currentPlayer = '0' then
    checkF := 1;
    else
    checkF := 2;
    end if;

    --Rechts
    checkC := 1;
    if xls < 5 then
    
    for j in 1 to 3 loop
      if (matP(xls+j, yls) = checkF) then
      checkC := checkC + 1;
      end if;
    end loop;
    if checkC >= 4 then
    win <= checkF;  
    end if;
    
    end if;
    
    
    --Links
    checkC := 1;
    if (win = 0) then
    if xls > 3 then
    
    for j in 1 to 3 loop
      if (matP(xls-j, yls) = checkF) then
      checkC := checkC + 1;
      end if;
    end loop;
    if checkC >= 4 then
    win <= checkF;    
    end if;
    
    end if;
    end if;
    
    
    --Unten
    checkC := 1;
    if (win = 0) then
    if yls > 3 then
    
    for j in 1 to 3 loop
      if (matP(xls, yls-j) = checkF) then
      checkC := checkC + 1;
      end if;
    end loop;
    if checkC >= 4 then
    win <= checkF;
    end if;
    
    end if;
    end if;  

    
    
    --Links Unten
    checkC := 1;
    if (win = 0) then
    if (yls > 3) and (xls > 3) then
    
    for j in 1 to 3 loop
      if (matP(xls-j, yls-j) = checkF) then
      checkC := checkC + 1;
      end if;
    end loop;
    if checkC >= 4 then
    win <= checkF;
    end if;
    
    end if;
    end if;    
    
    
    --Rechts Unten
    checkC := 1;
    if (win = 0) then
    if (yls > 3) and (xls < 5) then
    
    for j in 1 to 3 loop
      if (matP(xls+j, yls-j) = checkF) then
      checkC := checkC + 1;
      end if;
    end loop;
    if checkC >= 4 then
    win <= checkF;
    end if;
    
    end if;
    end if;
    
    
    --Rechts Oben
    checkC := 1;
    if (win = 0) then
    if (yls < 4) and (xls < 5) then
    
    for j in 1 to 3 loop
      if (matP(xls+j, yls+j) = checkF) then
      checkC := checkC + 1;
      end if;
    end loop;
    if checkC >= 4 then
    win <= checkF;
    end if;
    
    end if;
    end if;    
    
    
    --Links Oben
    checkC := 1;
    if (win = 0) then
    if (yls < 4) and (xls > 3) then
    
    for j in 1 to 3 loop
      if (matP(xls-j, yls+j) = checkF) then
      checkC := checkC + 1;
      end if;
    end loop;
    if checkC >= 4 then
    win <= checkF;  
    end if;
    
    end if;
    end if;  


--Gewinnauswertung Ende    

  
  --Spielstein erzeugen
  
  
  if currentPlayer = '0' then
  matP(xls, CountS(xls)) <= 1;
  else
  matP(xls, CountS(xls)) <= 2;
  end if;  
    
  currentPlayer := not currentPlayer;
  
  end if;
  



end process;
-------------------------------------------------------------------------------------------------------

---Gewinnanzeige provisorisch
process (f_multiplex)
begin
  if rising_edge(f_multiplex) then
  
    case win is
    when 0 => 
    segments <= "00000000";
    when 1 =>
    --R
    segments <= "01110111";
    when 2 =>
    --G
    segments <= "01111101";
    end case;
    
  end if;
end process;




  --clk -> f_multiplex
process (clk)
    constant  max_cnt    : integer := 62500; --ergibt ca 114 Hz Bildaufbau pro Led
    variable  cnt      : integer range 0 to max_cnt + 1;
begin
  if rising_edge(clk) then
    cnt := cnt + 1;
    if cnt = max_cnt +1 then
    cnt := 0;
    f_multiplex <= not f_multiplex;
    end if;
  end if;
end process;
   
  
  
  --////////Matrix Ausgabe Anfang//////////
  
  
  process
  variable x    : integer range 0 to 7 := 1;
  constant spaltenAnz   : integer range 0 to 10 := 7; 
  begin
  
    wait until rising_edge(f_multiplex);
  
    --unbenutzte pins
    for i in 13 to 17 loop
    ledout(i) <= '0';
    end loop;
  
  
    -- 1 Spalte auf High/Kathode durchschalten
    ledout(x-1) <= '1';
    
    -- die letzte Spalte wieder auf 0
      if (x>1) then
      ledout(x-2) <= '0';
      else
      ledout(spaltenAnz-1) <= '0';
      end if;
    
    
    --Code für die zu leuchtenden LEDs in der aktuellen Spalte:
    --ledout[0-6] = Kathoden // werden gemultiplext  // Header A - PIN[2-8]
    --ledout[7-12] = Anoden Rot // Header A - PIN[9-14]
    --ledout[18-23] = Anoden Grün // Header B - PIN[2-7]
    
      
      
      for i in 0 to 5 loop
      
        case (matP(x, i+1)) is 
          when 1 => 
          ledout(7+i) <= '1';
          ledout(18+i) <= '0';
          
          when 2 => 
          ledout(18+i) <= '1';
          ledout(7+i) <= '0';
          
          when 3 => 
          ledout(7+i) <= '1'; 
          ledout(18+i) <= '1';  
          
          when others => 
          ledout(7+i) <= '0'; 
          ledout(18+i) <= '0';
        end case;      
        
      end loop;
        

    
      
    
      if (x = spaltenAnz) then 
      x := 1;
      else
      x := x + 1;
      end if;
      
  
  
  end process;

   
   
   
   --////////Matrix Ausgabe Ende//////////
   
  


end Behavioral;

Danke schon einmal für euer Bemühen!

[Solide Vollnarkose (Gast)]

Ja glaubst du ernsthaft, solch langen Kot liest sich einer durch?

[Jürgen G. (Firma: Elektronikentwickler Aachen) (fjgensicke)]

wait until rising_edge(inp_trigger);

läuft nur im Simulator!

[Patrick (Gast)]

@ Solide Vollnarkose: Zumindest hast du schon mal drüber gescrollt und 
deinen unangebrachten Senf dazu abgegeben. Das ist doch schon mal ein 
Anfang.

Gruß Patrick

[Denis (Gast)]

Solide Vollnarkose schrieb:
> Ja glaubst du ernsthaft, solch langen Kot liest sich einer durch?

Wenn du nicht helfen willst spar dir in Zukunft die Antwort bitte, ich 
kann das Problem halt nicht wirklich eingrenzen.

Den Teil mit wait until habe ich auch mit if rising_edge(x) probiert mit 
dem selben Ergebnis. Laut Forum soll aber beides funktionieren und die 
wait methode sogar besser sein.

[Duke Scarring (Gast)]

Jürgen Gensicke schrieb:
> wait until rising_edge(inp_trigger);
>
> läuft nur im Simulator!
Kann man so nicht sagen.

Auf jeden Fall sollte der Originalposter nur einen Takt (clk) 
verwenden. Und auch nur der gehört in das rising_edge rein.
Abgesehen davon werden seine Tasten prellen.

Das Problem läßt sich z.B. so lösen:
http://www.lothar-miller.de/s9y/archives/18-Flinke-Flankenerkennung.html

Duke

[Duke Scarring (Gast)]

P.S.: Hier ist die Tastenentprellung noch besser erklärt:
http://www.lothar-miller.de/s9y/categories/5-Entprellung

[PittyJ (Gast)]

Ich nehme immer die Signale anstatt der Variablen.

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

Jürgen Gensicke schrieb:
> wait until rising_edge(inp_trigger);
> läuft nur im Simulator!
Diese Aussage war bis zum Ende des letzten Jahrtausends noch korrekt.
http://www.lothar-miller.de/s9y/archives/16-Takt-im-Prozess.html
Aber heute geht sogar noch viel mehr:
http://www.lothar-miller.de/s9y/archives/47-wait-im-Prozess.html

Denis schrieb:

 inp_trigger <= inp_entp(0) or inp_entp(1) or inp_entp(2) or inp_entp(3) or inp_entp(4) or inp_entp(5) or inp_entp(6) or inp_entp(7);
 wait until rising_edge(inp_trigger);

     f_multiplex <= not f_multiplex;
 wait until rising_edge(f_multiplex);

So werden im FPGA keine Takte erzeugt!
Deine Fehler wurden von anderen auch schon gemacht. Sieh dich einfach 
mal hier im Forum um. Auf jeden Fall wirst du ersntzunehmende Probleme 
durch die vielen Taktdomänen bekommen. Überleg das mal, was ich da 
geschrieben habe:
http://www.lothar-miller.de/s9y/archives/64-State-Machine-mit-asynchronem-Eingang.html
Taster sind asynchrone externe Eingänge...


Zum Thema "extensive und unnötige Verwendung von Variablen" mehr im 
Beitrag "Variable vs Signal"

[Bronco (Gast)]

Denis schrieb:
> Das ganze funktioniert bei mir in meiner Testbench(angehängt)
> einwandfrei, sobald ich es allerdings synthetisiere, verhält sich das
> Board komplett anders,

Das liegt mit an Sicherheit grenzender Wahrscheinlichkeit am Takt.
Benutze nach Möglichkeit nur einen einzigen Takt für alle Prozesse, 
sonst kommst Du in Teufel's Küche (wo wir alle schon öfters waren).

inp_trigger <= inp_entp(0) or inp_entp(1) or inp_entp(2) or inp_entp(3) or inp_entp(4) or inp_entp(5) or inp_entp(6) or inp_entp(7); 

process
begin
  wait until rising_edge(clk);
  if (inp_trigger = '1') and (inp_trigger_vorher = '0') then
    ...
  end if;
  inp_trigger_vorher <= inp_trigger;
end process;

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

Was wird daraus generiert:

inp_trigger <= inp_entp(0) or inp_entp(1) or inp_entp(2) or inp_entp(3) or inp_entp(4) or inp_entp(5) or inp_entp(6) or inp_entp(7); 
--------------------------------------------------------

--Schalterauswertung--
process begin

wait until rising_edge(inp_trigger);
  
  --Reset
  if inp_entp(0) = '1' then
  xls := 1;
  elsif inp_entp(1) = '1' then
  xls := 2;
  elsif inp_entp(2) = '1' then
  xls := 3;
  elsif inp_entp(3) = '1' then
  xls := 4;
  elsif inp_entp(4) = '1' then
  xls := 5;
  elsif inp_entp(5) = '1' then
  xls := 6;
  elsif inp_entp(6) = '1' then
  xls := 7;  
  end if;
  
  CountS(xls) := CountS(xls) + 1;

    checkC := 1;
    if xls < 5 then
    
    for j in 1 to 3 loop
      if (matP(xls+j, yls) = checkF) then  -- Wegen des Taktes ändert sich xls.
        checkC := checkC + 1;              -- gleichzeitig wird es ausgewertet und ein Zählerflipflop hochgezählt!

Eines jedes der checkC oder CountS Flipflops wird hier in etwa wie folgt 
beschaltet:

                          .-----.
Taster -----o---[Logik]---|D   Q|----
            |             |     |
            '-------------|>    |
                          '-----'

Meine Frage: was wird das Flipflop zuerst sehen?
Richtig: sehr wahrscheinlich den Takt, meistens...

VHDL sieht zwar aus wie eine prozedurale Programmiersprache, verhält 
sich aber komplett anders. In der Simulation wird alles nacheinander 
abgearbeitet, ind der Hardware ist alles parallel und gleichzeitig da.

Denis schrieb:
> Das ganze funktioniert bei mir in meiner Testbench einwandfrei

library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
 
entity BlinkLED is 
    Port (led : buffer  STD_LOGIC := '0'); 
end BlinkLED; 
 
architecture Behavioral of BlinkLED is 
begin 
   led <= not led after 500 ms;    -- LED alle 500 ms toggeln 
end Behavioral;

Das hier funktioniert in einer Testbench auch einwandfrei... ;-)

[Solide Vollnarkose (Gast)]

Denis schrieb:
> Wenn du nicht helfen willst spar dir in Zukunft die Antwort bitte, ich
> kann das Problem halt nicht wirklich eingrenzen.

In diesem Fall bitte ich um Entschuldigung...

[Denis (Gast)]

Es funktioniert jetzt!
Habe dank Lothar die Probleme erkannt und jetzt läuft alles synchron nur 
mit clk. Die Spiellogik hab ich jetzt nach der einleuchtenden Skizze mit 
einer kleinen Statemaschine umgesetzt.

Vielen Dank nochmal!

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

Denis schrieb:
> Es funktioniert jetzt!
Schön.
Wenn kein Copyright drauf ist könntest du den Code hier posten. Dann 
hätte man einen Vorher-Nachher Vergleich.

> Vielen Dank nochmal!
De nada.

[Denis (Gast)]

Klar, hier:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;


entity ledmatrix is
  GENERIC ( 
              delay  : natural := 63
         );
  PORT
  (
  
    clk    : IN  std_logic; -- 50 MHz Quartz
      ledout   : OUT  std_logic_vector (0 to 23) := "000000000000000000000000"; 
    inp    : IN std_logic_vector (0 to 7); -- 0-6 = Spaltentaster, 7 = Reset  
    segments : out  std_logic_vector (7 downto 0) := "00000000" 
    
  );

end ledmatrix;


architecture Behavioral of ledmatrix is

--Matrixmultiplex
type matrixB is array (1 to 7, 1 to 6) of integer range 0 to 3;
signal matP      : matrixB := (others => (others => 0)); --0 = None, 1=Rot, 2=Grün, 3=Gelb
signal f_multiplex: std_logic := '0'; -- 800Hz
signal f_mult_f: std_logic := '0';
------------------- 

--Logik
signal win        : integer range 0 to 2 := 0;
signal xls         : integer range 1 to 7 := 1;
signal yls         : integer range 1 to 6 := 1;
signal state       : integer range 0 to 11 := 0;


signal checkF      : integer range 0 to 2 := 1;

signal currentPlayer : std_logic := '0';

type intA is array(0 to 7) of integer range 0 to 8;
signal CountS      : intA := (others => 0);
-------------------

--Taster entprellen
signal inp_entp    :  std_logic_vector (0 to 7) := "00000000";
-------------------

begin


EntprellenNeu:
process
type intB is array(0 to 7) of integer range 0 to 150000;
variable inpcnt : intB := (others => 0);
variable inp_active : std_logic_vector(0 to 7) := (others => '0');
begin
  wait until rising_edge(clk);
  
  for i in 0 to 7 loop
  inp_entp(i) <= '0';
  
  if inp(i) = '0' then
  inp_active(i) := '1';
  end if;
  
  if inp_active(i) = '1' then
    if inpcnt(i) = 150000 then
    inpcnt(i) := 0;
      if inp(i) = '1' then
      inp_entp(i) <= '1';  --Steigende flanke
      inp_active(i) := '0';
      end if;
    else
    
    inpcnt(i) := inpcnt(i) + 1;
    end if;
  end if;

  end loop;


end process;



--Schalterauswertung--
Schalterauswertung: 
process
variable checkC      : integer range 0 to 6 := 0;
variable checkV      : integer range 0 to 6 := 0;
variable checkH      : integer range 0 to 6 := 0;
variable checkDR      : integer range 0 to 6 := 0;
variable checkDL      : integer range 0 to 6 := 0;
begin

   wait until rising_edge(clk);
  
  
  case state is
  when 0 =>
    
      --Reset
      if inp_entp(7) = '1' then
      
      currentPlayer <= '0'; 
      win <= 0;
      xls <= 1;
      
      --Matrix zurücksetzen
      for x in 1 to 7 loop 
      
      CountS(x) <= 0;
      
        for y in 1 to 6 loop
        matP(x, y) <= 0;
        end loop;
        
      end loop;
    
    ---Kein Reset
    elsif (win = 0) then
      
      if inp_entp(0) = '1' then
      xls <= 1;
      state <= state + 1;
      elsif inp_entp(1) = '1' then
      xls <= 2;
      state <= state + 1;
      elsif inp_entp(2) = '1' then
      xls <= 3;
      state <= state + 1;
      elsif inp_entp(3) = '1' then
      xls <= 4;
      state <= state + 1;
      elsif inp_entp(4) = '1' then
      xls <= 5;
      state <= state + 1;
      elsif inp_entp(5) = '1' then
      xls <= 6;
      state <= state + 1;
      elsif inp_entp(6) = '1' then
      xls <= 7;  
      state <= state + 1;
      end if;  
    
    
    end if;
    
  
  when 1 =>
  --Auswertung Stufe 1
    
    CountS(xls) <= CountS(xls) + 1;
    
      if currentPlayer = '0' then
      checkF <= 1;
      else
      checkF <= 2;
      end if;
      
    state <= state + 1;

  when 2 =>


  yls <= CountS(xls);
  checkH := 1;
  checkV := 1;
  checkDL := 1;
  checkDR := 1;

  state <= state + 1;
  
  when 3 =>

  
    --Rechts

    
    for j in 1 to 3 loop
      if (matP(xls+j, yls) = checkF) then
      checkH := checkH + 1;
      end if;
    end loop;

    
  state <= state + 1;

  when 4 =>    
    
    --Links
    if (win = 0) then
    
    for j in 1 to 3 loop
      if (matP(xls-j, yls) = checkF) then
      checkH := checkH + 1;
      end if;
    end loop;
    end if;
    
  state <= state + 1;
  

  when 5 =>
    
    --Unten
    if (win = 0) then
    
    for j in 1 to 3 loop
      if (matP(xls, yls-j) = checkF) then
      checkV := checkV + 1;
      end if;
    end loop;

    end if;

  state <= state + 1;  


  when 6 =>
    
    --Links Unten
    if (win = 0) then
    
    for j in 1 to 3 loop
      if (matP(xls-j, yls-j) = checkF) then
      checkDR := checkDR + 1;
      end if;
    end loop;
    
    end if;
  
    state <= state + 1;
  
  when 7 =>

    --Rechts Unten


    if (win = 0) then
    
    for j in 1 to 3 loop
      if (matP(xls+j, yls-j) = checkF) then
      checkDL := checkDL + 1;
      end if;
    end loop;
    end if;
    
  state <= state + 1;

  when 8 =>
    
    --Rechts Oben

    if (win = 0) then
    
    for j in 1 to 3 loop
      if (matP(xls+j, yls+j) = checkF) then
      checkDR := checkDR + 1;
      end if;
    end loop;
    end if;
    
  state <= state + 1;
  
  when 9 =>
    
    --Links Oben
    if (win = 0) then
    for j in 1 to 3 loop
      if (matP(xls-j, yls+j) = checkF) then
      checkDL := checkDL + 1;
      end if;
    end loop;
    
    end if;  
  
  state <= state + 1;
  
  when 10 =>
  
  if (checkH >= 4) or (checkV >= 4) or (checkDR >= 4) or (checkDL >= 4) then
  win <= checkF;  
  end if;

  state <= state + 1;
  
  when 11 =>
  
  --Spielstein erzeugen
  
  if currentPlayer = '0' then
  matP(xls, CountS(xls)) <= 1;
  else
  matP(xls, CountS(xls)) <= 2;
  end if;  
    
  currentPlayer <= not currentPlayer;  
  
  state <= 0;
  
  end case;
  

end process;



-------------------------------------------------------------------------------------------------------

---Gewinnanzeige provisorisch
Gewinnanzeige: 
process
begin
  wait until rising_edge(clk);
  
    case win is
    when 0 => 
    segments <= "00000000";
    when 1 =>
    --R
    segments <= "00000110";
    when 2 =>
    --G
    segments <= "01011011";
    end case;

end process;




--clk -> f_multiplex
Multiplexfreq: 
process (clk)
    constant  max_cnt    : integer := 62500; --ergibt ca 114 Hz Bildaufbau pro Led
    variable  cnt      : integer range 0 to max_cnt + 1;
begin
   if rising_edge(clk) then
    cnt := cnt + 1;
    if cnt = max_cnt +1 then
    cnt := 0;
    f_multiplex  <= not f_multiplex;
    end if;
  end if;
end process;
   
  
  
  --////////Matrix Ausgabe Anfang//////////
  
FlankeFMult: 
process
    variable sr : std_logic_vector (3 downto 0) := "0000";
  begin
    wait until rising_edge(clk);
    -- Flanken erkennen
    f_mult_f <= not sr(3) and sr(2);
    
    -- Eingang in Schieberegister einlesen
    sr := sr(2 downto 0) & f_multiplex;
end process;
  
  
  
Matrixausgabe: process
  variable x    : integer range 0 to 7 := 1;
  constant spaltenAnz   : integer range 0 to 10 := 7;  
begin
    
  wait until rising_edge(clk);
  if (f_mult_f = '1') then
  
  
  --unbenutzte pins
  for i in 13 to 17 loop
  ledout(i) <= '0';
  end loop;
  
  
  -- 1 Spalte auf High/Kathode durchschalten
  ledout(x-1) <= '1';
    
  -- die letzte Spalte wieder auf 0
  if (x>1) then
  ledout(x-2) <= '0';
  else
  ledout(spaltenAnz-1) <= '0';
  end if;
    
    
  --Code für die zu leuchtenden LEDs in der aktuellen Spalte:
  --ledout[0-6] = Kathoden // werden gemultiplext  // Header A - PIN[2-8]
  --ledout[7-12] = Anoden Rot // Header A - PIN[9-14]
  --ledout[18-23] = Anoden Grün // Header B - PIN[2-7]
    
      
      
  for i in 0 to 5 loop
      
    case (matP(x, i+1)) is 
    when 1 => 
    ledout(7+i) <= '1';
    ledout(18+i) <= '0';
          
    when 2 => 
    ledout(18+i) <= '1';
    ledout(7+i) <= '0';
          
    when 3 => 
    ledout(7+i) <= '1'; 
    ledout(18+i) <= '1';  
          
    when others => 
    ledout(7+i) <= '0'; 
    ledout(18+i) <= '0';
    end case;      
        
  end loop;
          
    
    if (x = spaltenAnz) then 
    x := 1;
    else
    x := x + 1;
    end if;
   
  end if;
  

  
end process;

    
   --////////Matrix Ausgabe Ende//////////
   
  
end Behavioral;

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

Und die vielen Variablen? Na gut, so lernt man das heute...


Aber hier sind zwei grundlegender Fehler drin: ein Denkfehler und ein 
Strukturfehler. Der weniger schlimme Denkfehler:

    constant  max_cnt : integer := 62500; -- ergibt ca 114 Hz Bildaufbau pro Led
    variable  cnt : integer range 0 to max_cnt + 1;   -- wohl nur drin wegen der Simulation?
                                                      -- in der Praxis wird dieser maximale Zählerstand /nie/ erreicht!

Aber das ist der Knackpunkt: Du zählst einen Schritt zuviel! Nämlich 
nicht 62500 Zyklen, sondern 62501, weil die Null auch ein Schritt ist: 
0,1,2,...62499,62500. Klar macht das hier jetzt nur 1/10 Promille aus, 
aber wehe du bist mit dem Zählerendwert mal im einstelligen Bereich. Ein 
Zähler für drei Schritte darf nicht bis 3 zählen. Er darf nur 0,1 und 2 
erreichen...

Richtigerweise muss da also vorerst stehen:

    variable  cnt : integer range 0 to max_cnt-1;   

   if rising_edge(clk) then                -- besser die Abfrage so machen:
    if cnt = max_cnt-1 then                -- auf Endwert abfragen. Wenn erreicht: 
       cnt := 0;                           -- zurücksetzen         
       f_multiplex  <= not f_multiplex;
    else                                   -- sonst: 
       cnt := cnt + 1;                     -- zählen
    end if;
  end if;

Und dann kommt der schlimmere, strukturelle Fehler:
Denis schrieb:
> jetzt läuft alles synchron nur mit clk.
Naja, nicht so ganz...
Noch immer werden so keine Takte erzeugt:

  
      f_multiplex  <= not f_multiplex;

    :
    :

   if rising_edge(f_multiplex) then  -- hier darf nur einer stehen: der CLK

Mag sein, dass es jetzt gerade mal geht, aber sauber ist das nicht...

Richtig wäre ein Clock-Enable:

    variable  cnt : integer range 0 to max_cnt-1;   

   if rising_edge(clk) then                
    multiplex_enable <= '0';
    if cnt = max_cnt-1 then                
       cnt := 0;                           
       multiplex_enable <= '1';  -- nur für 1 Taktzyklus lang aktiv!
    else                                   
       cnt := cnt + 1;                     
    end if;
  end if;
   
  :
  :

  if rising_edge(clk) then -- es kann nur einen geben: den CLK
     if (multiplex_enable='1') then
        :

BTW:
Diese Konstante hier würdest du leichter den Synthesizer ausrechnen 
lassen:

    constant  max_cnt : integer := 62500; -- ergibt ca 114 Hz Bildaufbau pro Led

So etwa:

    constant  fosc : integer := 50000000;
  :
  :
    constant  max_cnt : integer := fosc/(7*114); -- ergibt bei 7 Spalten ca. 114 Hz Bildaufbau pro Led