Daten aus RAM zyklisch in VHDL lesen und parallel ausgeben

[shottky (Gast)]

Hallo Leute!

Ich habe ein RAM Baustein in VHDL implementiert, den ich via SPI von 
extern seriell beschreibe und auch seriell auslesen kann.
Jetzt ist es jedoch so, dass ich für meine Applikation ständig 6 Werte 
von meinen gesamten RAM-Daten als Initialisierungswerte für den 
Programmablauf meiner Applikation benötige.

Kann mir jemand einen Tipp geben, wie ich so einen  „Datendemultiplexer“ 
programmieren kann, der mir zyklisch die Daten aus den ersten Sechs 
Adressen herausliest und nach außen gibt?
Zur besseren Verdeutlichung habe ich euch ein kleines Blockschaltbild 
des benötigten „Datendemultiplexers“ beigefügt.
Oder gibt es so etwas in der Richtung schon im Netz? Ich selber habe 
leider noch nichts dergleichen gefunden…

Vielen Dank schon mal!
Shottky

[Christian R. (supachris)]

Da reicht doch ein Zähler an den Lese-Adressleitungen des RAMs. Dazu 6 x 
32 FlipFlops, die bei entsprechendem Zählerstand die Daten des RAM 
speichern. Die FPGA-internen BlockRAMs sind sowieso Dual Port, in deinem 
Fall bräuchtest du anscheinend sogar nur "simple Dual Port", also nur 
eine Schreib- und eine Leseseite.

[shottky (Gast)]

Also ich habe eine kleine Statemachine implementiert, die nacheinander 
die Adressen ausgibt und die Eingangswerte der jeweiligen Adresse an den 
Ausgang weiterschalten bzw. in den Ausgang speichern soll.

Problem ist jedoch, dass die Werte nur für einen Takt ausgegeben werden. 
Der Wert am Ausgang wird also wieder gelöscht.

Hat da jemand eine Idee? Muss ich die Werte zwischenspeichern und dann 
erst dem Ausgang zuweisen?

Gruß Shottky

Hier mein VHDL-Code:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
use IEEE.std_logic_unsigned.all;
use work.mytype.all;

entity autom_demux is
port (
    clk   : in  STD_LOGIC;
    reset   : in  STD_LOGIC;  
    set:   in  STD_LOGIC;  
    INPUT : in std_logic_vector(31 downto 0);
    ADDR : out  STD_LOGIC_VECTOR (4 downto 0);
    OUTPUT_0 : out  STD_LOGIC_VECTOR (15 downto 0);
    OUTPUT_1 : out  STD_LOGIC_VECTOR (31 downto 0);
    OUTPUT_2 : out  STD_LOGIC_VECTOR (31 downto 0);
    OUTPUT_3 : out  STD_LOGIC;
    OUTPUT_4 : out  STD_LOGIC_VECTOR (2 downto 0);
    OUTPUT_5 : out  STD_LOGIC;
    OUTPUT_6 : out  STD_LOGIC
     );
    
    
end autom_demux;


ARCHITECTURE a OF autom_demux IS
   TYPE STATE_TYPE IS (state0, state1, state2, state3, state4, state5, state6, state7);
   SIGNAL state   : STATE_TYPE;

BEGIN
   
  PROCESS (clk, reset)
   BEGIN
      IF reset = '0' THEN
         state <= state0;
      ADDR(4 downto 0) <= "00000";
      ELSIF (clk'EVENT AND clk = '1') THEN
         CASE state IS
            WHEN state0=>
               IF set = '1' THEN
                  state <= state1;
            ADDR(4 downto 0) <= "00001";
               ELSE
                  state <= state0;
            ADDR(4 downto 0) <= "00000";
               END IF;
            WHEN state1=>
               IF set = '1' THEN
                  state <= state2;
            ADDR(4 downto 0) <= "00010";
               ELSE
                  state <= state1;
            ADDR(4 downto 0) <= "00001";
               END IF;
            WHEN state2=>
               IF set = '1' THEN
                  state <= state3;
            ADDR(4 downto 0) <= "00011";
               ELSE
                  state <= state2;
            ADDR(4 downto 0) <= "00010";
               END IF;
            WHEN state3=>
               IF set = '1' THEN
                  state <= state4;
            ADDR(4 downto 0) <= "00100";
               ELSE
                  state <= state3;
            ADDR(4 downto 0) <= "00011";
               END IF;
            WHEN state4=>
               IF set = '1' THEN
                  state <= state5;
            ADDR(4 downto 0) <= "00101";
               ELSE
                  state <= state4;
            ADDR(4 downto 0) <= "00100";
               END IF;
            WHEN state5=>
               IF set = '1' THEN
                  state <= state6;
            ADDR(4 downto 0) <= "00110";
               ELSE
                  state <= state5;
            ADDR(4 downto 0) <= "00101";
               END IF;
            WHEN state6=>
               IF set = '1' THEN
                  state <= state7;
            ADDR(4 downto 0) <= "00111";
               ELSE
                  state <= state6;
            ADDR(4 downto 0) <= "00110";
               END IF;
            WHEN state7=>
               IF set = '1' THEN
                  state <= state0;
            ADDR(4 downto 0) <= "00000";
               ELSE
                  state <= state7;
            ADDR(4 downto 0) <= "00111";
               END IF;
         END CASE;
      END IF;
   END PROCESS;
   
   PROCESS (state)
   BEGIN
      CASE state IS
         WHEN state0 =>
            OUTPUT_0 <= INPUT(15 downto 0);
         WHEN state1 =>
            OUTPUT_1 <= INPUT(31 downto 0);
         WHEN state2 =>
            OUTPUT_2 <= INPUT(31 downto 0);
         WHEN state3 =>
            OUTPUT_3 <= INPUT(0);
         WHEN state4 =>
            OUTPUT_4 <= INPUT(2 downto 0);
         WHEN state5 =>
            OUTPUT_5 <= INPUT(0);
         WHEN state6 =>
            OUTPUT_6 <= INPUT(0);
         WHEN state7 =>
            NULL;
      END CASE;
   END PROCESS;
   
END a;

[Duke Scarring (Gast)]

shottky schrieb:
> Also ich habe eine kleine Statemachine implementiert, die nacheinander
> die Adressen ausgibt und die Eingangswerte der jeweiligen Adresse an den
> Ausgang weiterschalten bzw. in den Ausgang speichern soll.
>
> Problem ist jedoch, dass die Werte nur für einen Takt ausgegeben werden.
> Der Wert am Ausgang wird also wieder gelöscht.
Dann muß da noch ein WAIT-State dazwischen. Der muß solange warten, bis 
die Daten aus dem RAM angekommen sind.

> Hier mein VHDL-Code:
>
> library IEEE;
> use IEEE.STD_LOGIC_1164.ALL;
> use IEEE.NUMERIC_STD.ALL;
> use IEEE.std_logic_unsigned.all;
Nimm mal bitte die std_logic_unsigned raus. Sihe hier:
Beitrag "Re: IEEE.STD_LOGIC_ARITH.ALL obsolete"

Duke

[shottky (Gast)]

Danke für deine Antwort!

Du meinst einfach ein paar Takte zwischen dem Anlegen der Adresse und 
Ausgeben der Daten (von der Adresse) warten? Wieviele Takte sollten dies 
sein?

[Duke Scarring (Gast)]

shottky schrieb:
> Du meinst einfach ein paar Takte zwischen dem Anlegen der Adresse und
> Ausgeben der Daten (von der Adresse) warten? Wieviele Takte sollten dies
> sein?
Sehe ich das richtig, daß Du FPGA-internen RAM verwenden willst? Bei 
internem RAM sind die Daten üblicherweise im nächsten Takt verfügbar.

Hast Du schon eine Testbench? Damit läßt sich schön die Funktionalität 
des Codes zeigen.

Duke

[shottky (Gast)]

Ja richig es ist ein RAM aus der LPM-Library.
Eine Testbench habe ich nicht. Nutze SignalTap.

Gruß

[Falk B. (falk)]

@ shottky (Gast)

>Ja richig es ist ein RAM aus der LPM-Library.
>Eine Testbench habe ich nicht. Nutze SignalTap.

Selber Schuld. Eine Testbench würde dir in 10 Minuten das Verhalten des 
Codes klar zeigen.

Beitrag "Latente Phobie gegenüber VHDL-Simulationen"