hilfe bei fifo

[reno k. (Firma: student) (rayes)]

hallo zusammen
ich habe ein IP core fifo 8x8 bit und ein test data_wort 64 bit
eingangsignal des Fifo ist DIN 8bit.
ich will das wort ins fifo schreiben aber es wird nur die ersten 8 bit 
gelesen brauche ich ein zähler ? ich komme nicht voran irgendwelche 
vorschläfe.

meine simulation sieht so aus
danke im voraus

[M. D. (wpmd)]

Du musst deinem FIFO auch die anderen Bits anbieten damit er diese 
übernehmen kann.
Kannst du mal deinen Code zeigen? Nur die Waveform bringt nicht so 
viel...

[reno k. (Firma: student) (rayes)]

danke für die rückmeldung
hier ist mein code
ich habe zwei fsm eine zum schreiben und die andere zum lesen aus dem 
fifo
ich beschäftige mich erst seit einpaar wochen mit vhdl

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 primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity fifo_26 is   
end fifo_26;
architecture Behavioral of fifo_26 is

COMPONENT fifo_generator_v9_3_0
  PORT (
    clk :   IN STD_LOGIC;
    rst :   IN STD_LOGIC;
    din :   IN STD_LOGIC_VECTOR(7 DOWNTO 0);
    wr_en : IN STD_LOGIC;
    rd_en : IN STD_LOGIC;
    dout :  OUT STD_LOGIC_VECTOR(7 DOWNTO 0);
    full :  OUT STD_LOGIC;
    empty : OUT STD_LOGIC
  );
END COMPONENT;
-- inputs
signal  clk :   STD_LOGIC ;--:= '0';
signal rst :    STD_LOGIC := '0';
signal reset:   STD_LOGIC ;--= '0';
signal din :    STD_LOGIC_VECTOR(7 DOWNTO 0);
signal  wr_en : STD_LOGIC ;--= '0';
signal  rd_en : STD_LOGIC := '0';
signal  data   :STD_LOGIC_VECTOR (63 downto 0):=X"aabbccddeeffaaff";
--signal counter :    STD_LOGIC_VECTOR(7 DOWNTO 0);
--outputs
signal dout :   STD_LOGIC_VECTOR(7 DOWNTO 0);
signal full :   STD_LOGIC ;
signal empty:   STD_LOGIC ;
type state_type is (zustand_1,zustand_2,zustand_3,zustand_4,zustand_5); 
signal zwischen_zustand ,naechst_zustand : state_type ;
type status_type is (status_1);
signal zwischen_status ,naechst_status : status_type ;
--type voll_type is (start);
--signal zwischen, naechst: voll_type;
--clock period definition
 constant clk_period : time := 20 ns;
begin
your_instance_name : fifo_generator_v9_3_0
  PORT MAP (
    clk => clk,
    rst => reset,
    din => din,
    wr_en => wr_en,
    rd_en => rd_en,
    dout => dout,
    full => full,
    empty => empty
  );
  --clock process definition
clk_process: process begin
   clk <= '0';
   wait for clk_period/2;
   clk <= '1';
   wait for clk_period/2;
end process;    
rst_process: process begin
   reset <= '0';
   wait for clk_period;
   reset <= '1';
   wait for clk_period;
   reset <= '0';
   wait;   
end process;
t_1: process (clk,reset) begin
  if (reset='1') then
  rst<='1';
 --default state on reset.
  elsif (clk' event and clk ='1') then --rising_edge(clk)
  rst<='0';  
  --rd_en <='0';          
  zwischen_zustand <= naechst_zustand ;   --state change.
   --naechst_zustand<= zustand_1;
  end if;
end process;
     --fsm process zum schreiben
t_2:  process (zwischen_zustand,full)
    begin
    case zwischen_zustand is
    when zustand_1 =>
    wr_en<='0';
    naechst_zustand <= zustand_2;
    when zustand_2 =>
    naechst_zustand <= zustand_3;
    when zustand_3 =>  
    naechst_zustand <= zustand_4;
    when zustand_4 =>
   --if (clk' event and clk ='1') then 
   -- for index in 0 to 7 loop
   -- din <= data(index*8 to (index*8)+7);
   din <= data;
   if  (full = '0') then 
   wr_en <='1' ;
   naechst_zustand <= zustand_4;

   else
   wr_en<='1';
   naechst_zustand <= zustand_5;
   end if;
   when zustand_5 => 
   -- wr_en <='0';
   naechst_zustand <= zustand_5;
    end case;
 end process; 
t_6: process (clk) begin
   if (clk' event and clk ='1') then
   zwischen_status <= naechst_status;
   end if;
end process;
   -- fsm process zum lesen 
t_7: process (zwischen_status,empty) begin
   case (zwischen_status)is 
   when status_1 =>
   if (empty ='0')then
   rd_en <='1';
  else 
   rd_en <= '0';
   end if;
   end case;
end process; 
end Behavioral;

danke im voraus

[M. D. (wpmd)]

Beim ersten schnellen drüberschauen springt mir erstmal das hier ins 
Auge:

reno kortes schrieb:
> din <= data;

din ist ein 8 bit Vektor, data ein 64 bit Vektor. Damit wird din immer 
die ersten 8 bit von data zugewiesen. Ich vermisse irgendwo die 
Zuweisung der nächsten 8 bit.

z.B.

din <= data (63 downto 56)
din <= data (55 downto 48)
...

[pks (Gast)]

M. D. schrieb:
> reno kortes schrieb:
>> din <= data;
>
> din ist ein 8 bit Vektor, data ein 64 bit Vektor. Damit wird din immer
> die ersten 8 bit von data zugewiesen.

Welcher Compiler/Simulator macht das denn so? Modelsim würde dafür einen 
Fehler ausgeben...

[reno k. (Firma: student) (rayes)]

ja das stimmt aber ich auch schon mit
din <= data(63 downto 56)
din <= data(55 downto 48)
din <= data(47 downto 40)
din <= data(39 downto 32)
... probiert aber immer nur die ersten 8bit
wie macht er das liest er die alle in einem clk
oder jede 8bit in einem clk
aber ist die simulation schon richtig überhaupt ich meine die "FULL" UND 
"EMPTY"

[reno k. (Firma: student) (rayes)]

ich habe mir sowas überlegt :

if (clk' event and clk ='1') then
   for index in 0 to 7 loop --da mein fifo ist 8x8 bit
    din <= data(index*8 to (index*8)+7);
aber wo soll ich die schleife einsetzen in einem processs oder fsm ???

[pks (Gast)]

reno kortes schrieb:
> ich habe mir sowas überlegt :
>
> if (clk' event and clk ='1') then
>    for index in 0 to 7 loop --da mein fifo ist 8x8 bit
>     din <= data(index*8 to (index*8)+7);
> aber wo soll ich die schleife einsetzen in einem processs oder fsm ???

Abgesehen davon, dass der Compiler über "to" ungleich "downto" meckern 
würde, hätte das denselben Effekt wie die Zuweisungen, die Du vorher 
beschrieben hast...
Ich weiß solche Antworten helfen nicht wirklich weiter, aber da fehlt es 
eindeutig noch an VHDL-Grundlagen.

[Duke Scarring (Gast)]

Offenbar möchtest Du ein FIFO mit unterschiedlichen Datenbreiten.

Trotzdem muß der mittlere Zufluss dem mittleren Abfluss entsprechen.
Wenn Du mit einem Takt 64 Bit ins FIFO schreibst (dazu muss muß der 
Schreibport auch 64 Bit breit sein), kannst Du mit acht Takten auf der 
anderen Seite 8 x 8 Bit auslesen (dazu muß die Leseseite 8 Bit breit 
sein).

Duke

[reno k. (Firma: student) (rayes)]

eingentlich will ich nur simulieren wie es aussieht wenn der fifo voll 
ist deswegen will ich 64 bit reinschreiben bis er voll ist.
ich will nur den satz : "schreibe solange der fifo nicht voll immer 
wieder daten rein" implimentieren. und das habe ich im zustand_4 
probiert

when zustand_4 =>
   --if (clk' event and clk ='1') then 
   -- for index in 0 to 7 loop
   -- din <= data(index*8 to (index*8)+7);
   din <= data;
   
if  (full = '0') then 
   wr_en <='1' ;
   naechst_zustand <= zustand_4;

   else
   wr_en<='1';
   naechst_zustand <= zustand_5;
   end if;
   when zustand_5 =>

[bko (Gast)]

soweit ich verstehe solls ja nur eine Testbench werden, soll
also nicht synthetisiert werden, dann ist so doch einfacher:

din_process: process begin
  wr_en <= '0';   --  in den Ruhezustand
  din <= "wert1";
  wait until rising_edge(clk);
  wr_en <= '1';
  wait until rising_edge(clk);
  wr_en <= '0';

  wait until rising_edge(clk); -- kann auch in eine procedure
  din <= "wert2";
  wait until rising_edge(clk);
  wr_en <= '1';
  wait until rising_edge(clk);
  wr_en <= '0';                -- oder stures copy paste ...

  wait until rising_edge(clk); -- so warten wir noch auf den fifo
  if (full = '1')
     wait until falling_edge(full)
  din <= "wert3";
  wait until rising_edge(clk);
  wr_en <= '1';
  wait until rising_edge(clk);
  wr_en <= '0';

    -- und und und 
end din_process: process;

read_process : process
  read_en <= '0';
  wait für 200us; -- oder so, halt eine Zeitlang bis fifo voll ist 
  read_en <= '1';

  --usw usw usw ...

nur so als Anregung, Vorsicht könnte sytaxfehler enthalten!