Einfaches Register mit AXI Interface

[Student (Gast)]

Hallo,

Ich habe mal eine Frage, was spricht dagegen dass man selbst AXI4 Lite 
Interface implementiert, statt vorgefrtiger IP-Core (mit IPIF Interface) 
von Xilinx zu nehmen?

Ich habe mal kurz einfaches Register implementiert und in ISIM 
Simuliert. Sieht maeine meinung nach gut aus. Oder was meint ihr?

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
  
------------------------------------------------------------------------------
-- Entity section
------------------------------------------------------------------------------
-- Definition of Generics:
--   C_S_AXI_DATA_WIDTH           -- AXI4LITE slave: Data width
--   C_S_AXI_ADDR_WIDTH           -- AXI4LITE slave: Address Width
--   C_BASEADDR                   -- AXI4LITE slave: base address
--   C_HIGHADDR                   -- AXI4LITE slave: high address
--
-- Definition of Ports:
--   S_AXI_ACLK                   -- AXI4LITE slave: Clock 
--   S_AXI_ARESETN                -- AXI4LITE slave: Reset
--   S_AXI_AWADDR                 -- AXI4LITE slave: Write address
--   S_AXI_AWVALID                -- AXI4LITE slave: Write address valid
--   S_AXI_WDATA                  -- AXI4LITE slave: Write data
--   S_AXI_WSTRB                  -- AXI4LITE slave: Write strobe
--   S_AXI_WVALID                 -- AXI4LITE slave: Write data valid
--   S_AXI_BREADY                 -- AXI4LITE slave: Response ready
--   S_AXI_ARADDR                 -- AXI4LITE slave: Read address
--   S_AXI_ARVALID                -- AXI4LITE slave: Read address valid
--   S_AXI_RREADY                 -- AXI4LITE slave: Read data ready
--   S_AXI_ARREADY                -- AXI4LITE slave: read addres ready
--   S_AXI_RDATA                  -- AXI4LITE slave: Read data
--   S_AXI_RRESP                  -- AXI4LITE slave: Read data response
--   S_AXI_RVALID                 -- AXI4LITE slave: Read data valid
--   S_AXI_WREADY                 -- AXI4LITE slave: Write data ready
--   S_AXI_BRESP                  -- AXI4LITE slave: Response
--   S_AXI_BVALID                 -- AXI4LITE slave: Resonse valid
--   S_AXI_AWREADY                -- AXI4LITE slave: Wrte address ready
------------------------------------------------------------------------------
 
entity simple_ipcore_axilite is
  generic(
    -- Bus protocol parameters
    C_S_AXI_DATA_WIDTH             : integer              := 32;
    C_S_AXI_ADDR_WIDTH             : integer              := 32;
    C_BASEADDR                     : std_logic_vector     := X"FFFFFFFF";
    C_HIGHADDR                     : std_logic_vector     := X"00000000"
  );
  port(
    --USER ports
    calc_time                       : out std_logic;
    -------------------------
    -- AXI4lite interface
    -------------------------
    --- Global signals
    S_AXI_ACLK                     : in  std_logic;
    S_AXI_ARESETN                  : in  std_logic;
    --- Write address channel
    S_AXI_AWADDR                   : in  std_logic_vector(C_S_AXI_ADDR_WIDTH-1 downto 0);
    S_AXI_AWVALID                  : in  std_logic;
    S_AXI_AWREADY                  : out std_logic;
    --- Write data channel
    S_AXI_WDATA                    : in  std_logic_vector(C_S_AXI_DATA_WIDTH-1 downto 0);
    S_AXI_WVALID                   : in  std_logic;
    S_AXI_WREADY                   : out std_logic;
    S_AXI_WSTRB                    : in  std_logic_vector((C_S_AXI_DATA_WIDTH/8)-1 downto 0);
    --- Write response channel
    S_AXI_BVALID                   : out std_logic;
    S_AXI_BREADY                   : in  std_logic;
    S_AXI_BRESP                    : out std_logic_vector(1 downto 0);
    --- Read address channel
    S_AXI_ARADDR                   : in  std_logic_vector(C_S_AXI_ADDR_WIDTH-1 downto 0);
    S_AXI_ARVALID                  : in  std_logic;
    S_AXI_ARREADY                  : out std_logic; 
    --- Read data channel
    S_AXI_RDATA                    : out std_logic_vector(C_S_AXI_DATA_WIDTH-1 downto 0);
    S_AXI_RVALID                   : out std_logic;
    S_AXI_RREADY                   : in  std_logic;
    S_AXI_RRESP                    : out std_logic_vector(1 downto 0)
  );
 
end entity simple_ipcore_axilite;
 
------------------------------------------------------------------------------
-- Architecture section
------------------------------------------------------------------------------
 
architecture IMP of simple_ipcore_axilite is
  type axi_states is (addr_wait, read_state, write_state, response_state);
  signal state : axi_states;
 
  signal address : std_logic_vector(C_S_AXI_ADDR_WIDTH-1 downto 0);
  signal value : std_logic_vector(C_S_AXI_DATA_WIDTH-1 downto 0);
  signal reset : std_logic;
 
  signal S_AXI_BVALID_i : std_logic;
 
  -- selection signals

  -- core interface signeals
  signal write_enable : std_logic;
  
begin
  -- unused signals
  S_AXI_BRESP <= "00";
  S_AXI_RRESP <= "00";
 
  -- axi-lite slave state machine
  axi_slave_states : process (S_AXI_ACLK)
  begin
    if rising_edge(S_AXI_ACLK) then
      if S_AXI_ARESETN='0' then -- slave reset state
        S_AXI_RVALID <= '0';
        S_AXI_BVALID_i <= '0';
        S_AXI_ARREADY <= '0';
        S_AXI_WREADY <= '0';
        S_AXI_AWREADY <= '0';
        state <= addr_wait;
        address <= (others=>'0');
        write_enable <= '0';
      else
        case state is
          when addr_wait => 
          -- wait for a read or write address and latch it in
            if S_AXI_ARVALID = '1' then -- read
              state <= read_state;
              address <= S_AXI_ARADDR;
              S_AXI_ARREADY <= '1';
            elsif (S_AXI_AWVALID = '1' and S_AXI_WVALID = '1') then -- write
              state <= write_state;
              address <= S_AXI_AWADDR;
            else
              state <= addr_wait;
            end if;
 
          when read_state =>
          -- place correct data on bus and generate valid pulse
            S_AXI_ARREADY <= '0';
            S_AXI_RVALID <= '1';
            state <= response_state;
 
        S_AXI_RDATA <= value;
          
       when write_state =>
          -- generate a write pulse
            S_AXI_AWREADY <= '1';
            write_enable <= '1';
            S_AXI_WREADY <= '1';
            state <= response_state;
        
        value <= S_AXI_WDATA;
 
          when response_state =>
            write_enable <= '0';
            S_AXI_AWREADY <= '0';
            S_AXI_WREADY <= '0';
            S_AXI_BVALID_i <= '1';
          -- wait for response from master
            if (S_AXI_RREADY = '1') or (S_AXI_BVALID_i = '1' and S_AXI_BREADY = '1') then
              S_AXI_RVALID <= '0';
              S_AXI_BVALID_i <= '0';
              state <= addr_wait;
            else
              state <= response_state;
            end if;
 
        end case;
      end if;
    end if;
  end process;
  S_AXI_BVALID <= S_AXI_BVALID_i;  
 

end IMP;

Die Simulation dazu:

 

--------------------------------------------------------------------------------
-- Company: 
-- Engineer:
--
-- Create Date:   17:03:36 01/07/2014
-- Design Name:   
-- Module Name:   C:/Users/user71/Desktop/Xilinx_projects/AXI_Test/tb_simple_ipcore_axilite.vhd
-- Project Name:  AXI_Test
-- Target Device:  
-- Tool versions:  
-- Description:   
-- 
-- VHDL Test Bench Created by ISE for module: simple_ipcore_axilite
-- 
-- Dependencies:
-- 
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
-- Notes: 
-- This testbench has been automatically generated using types std_logic and
-- std_logic_vector for the ports of the unit under test.  Xilinx recommends
-- that these types always be used for the top-level I/O of a design in order
-- to guarantee that the testbench will bind correctly to the post-implementation 
-- simulation model.
--------------------------------------------------------------------------------
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;
 
ENTITY tb_simple_ipcore_axilite IS
END tb_simple_ipcore_axilite;
 
ARCHITECTURE behavior OF tb_simple_ipcore_axilite IS 
 
    -- Component Declaration for the Unit Under Test (UUT)
 
    COMPONENT simple_ipcore_axilite
    PORT(
         calc_time : OUT  std_logic;
         S_AXI_ACLK : IN  std_logic;
         S_AXI_ARESETN : IN  std_logic;
         S_AXI_AWADDR : IN  std_logic_vector(31 downto 0);
         S_AXI_AWVALID : IN  std_logic;
         S_AXI_AWREADY : OUT  std_logic;
         S_AXI_WDATA : IN  std_logic_vector(31 downto 0);
         S_AXI_WVALID : IN  std_logic;
         S_AXI_WREADY : OUT  std_logic;
         S_AXI_WSTRB : IN  std_logic_vector(3 downto 0);
         S_AXI_BVALID : OUT  std_logic;
         S_AXI_BREADY : IN  std_logic;
         S_AXI_BRESP : OUT  std_logic_vector(1 downto 0);
         S_AXI_ARADDR : IN  std_logic_vector(31 downto 0);
         S_AXI_ARVALID : IN  std_logic;
         S_AXI_ARREADY : OUT  std_logic;
         S_AXI_RDATA : OUT  std_logic_vector(31 downto 0);
         S_AXI_RVALID : OUT  std_logic;
         S_AXI_RREADY : IN  std_logic;
         S_AXI_RRESP : OUT  std_logic_vector(1 downto 0)
        );
    END COMPONENT;
    

   --Inputs
   signal S_AXI_ACLK : std_logic := '0';
   signal S_AXI_ARESETN : std_logic := '0';
   signal S_AXI_AWADDR : std_logic_vector(31 downto 0) := (others => '0');
   signal S_AXI_AWVALID : std_logic := '0';
   signal S_AXI_WDATA : std_logic_vector(31 downto 0) := (others => '0');
   signal S_AXI_WVALID : std_logic := '0';
   signal S_AXI_WSTRB : std_logic_vector(3 downto 0) := (others => '0');
   signal S_AXI_BREADY : std_logic := '0';
   signal S_AXI_ARADDR : std_logic_vector(31 downto 0) := (others => '0');
   signal S_AXI_ARVALID : std_logic := '0';
   signal S_AXI_RREADY : std_logic := '0';

   --Outputs
   signal calc_time : std_logic;
   signal S_AXI_AWREADY : std_logic;
   signal S_AXI_WREADY : std_logic;
   signal S_AXI_BVALID : std_logic;
   signal S_AXI_BRESP : std_logic_vector(1 downto 0);
   signal S_AXI_ARREADY : std_logic;
   signal S_AXI_RDATA : std_logic_vector(31 downto 0);
   signal S_AXI_RVALID : std_logic;
   signal S_AXI_RRESP : std_logic_vector(1 downto 0);

   -- Clock period definitions
   constant S_AXI_ACLK_period : time := 10 ns;
 
BEGIN
 
  -- Instantiate the Unit Under Test (UUT)
   uut: simple_ipcore_axilite PORT MAP (
          calc_time => calc_time,
          S_AXI_ACLK => S_AXI_ACLK,
          S_AXI_ARESETN => S_AXI_ARESETN,
          S_AXI_AWADDR => S_AXI_AWADDR,
          S_AXI_AWVALID => S_AXI_AWVALID,
          S_AXI_AWREADY => S_AXI_AWREADY,
          S_AXI_WDATA => S_AXI_WDATA,
          S_AXI_WVALID => S_AXI_WVALID,
          S_AXI_WREADY => S_AXI_WREADY,
          S_AXI_WSTRB => S_AXI_WSTRB,
          S_AXI_BVALID => S_AXI_BVALID,
          S_AXI_BREADY => S_AXI_BREADY,
          S_AXI_BRESP => S_AXI_BRESP,
          S_AXI_ARADDR => S_AXI_ARADDR,
          S_AXI_ARVALID => S_AXI_ARVALID,
          S_AXI_ARREADY => S_AXI_ARREADY,
          S_AXI_RDATA => S_AXI_RDATA,
          S_AXI_RVALID => S_AXI_RVALID,
          S_AXI_RREADY => S_AXI_RREADY,
          S_AXI_RRESP => S_AXI_RRESP
        );

   -- Clock process definitions
   S_AXI_ACLK_process :process
   begin
    S_AXI_ACLK <= '0';
    wait for S_AXI_ACLK_period/2;
    S_AXI_ACLK <= '1';
    wait for S_AXI_ACLK_period/2;
   end process;
 

   -- Stimulus process
   stim_proc: process
   begin    
      -- hold reset state for 50 ns.
      wait for 20 ns;  

      -- insert stimulus here

    -- Write operation 
    S_AXI_ARESETN <= '1';
    
    wait for 10 ns;
    wait until rising_edge(S_AXI_ACLK);
    
    S_AXI_AWADDR <= x"FEEEEEEF";
    S_AXI_AWVALID <= '1';
    S_AXI_WDATA <= x"0000000F";
    S_AXI_WVALID <= '1';
    S_AXI_WSTRB <= x"F";
    S_AXI_BREADY <= '1';
    
    wait for 10 ns;  
    wait until falling_edge(S_AXI_WREADY);
    
    S_AXI_AWADDR <= x"00000000";
    S_AXI_AWVALID <= '0'; 
    S_AXI_WDATA <= x"00000000";
    S_AXI_WVALID <= '0';
    S_AXI_WSTRB <= x"0";

    wait until falling_edge(S_AXI_BVALID);
    S_AXI_BREADY <= '0';
    
    -- Read operation 
    
    wait for 50 ns;
    wait until rising_edge(S_AXI_ACLK);
    
    S_AXI_ARADDR <= x"FEEEEEEF";
    S_AXI_ARVALID <= '1';
    S_AXI_RREADY <= '1';
    
    wait for 10 ns;  
    wait until falling_edge(S_AXI_ARREADY);
    
    S_AXI_ARADDR <= x"00000000";
    S_AXI_ARVALID <= '0';
    
    wait until falling_edge(S_AXI_RVALID);
    S_AXI_RREADY <= '0';
    
      wait;
   end process;

END;

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

Student schrieb:
> Hallo,
>
> Ich habe mal eine Frage, was spricht dagegen dass man selbst AXI4 Lite
> Interface implementiert, statt vorgefrtiger IP-Core (mit IPIF Interface)
> von Xilinx zu nehmen?

nichts. AXI4 ist ein häufiger Standard von Xilinx. Lässt sich alles 
einfach zusammenschmeißen. Die Cores lassen sich so entkoppeln.


> Ich habe mal kurz einfaches Register implementiert und in ISIM
> Simuliert. Sieht maeine Meinung nach gut aus. Oder was meint ihr?
>

Vom Screenshot erstmal nicht schlecht. Was mir bei deinem Code 
aufgefallen ist; Du hast alles in einen Prozess gepackt. Solcher Code 
ist schlecht wartbar und ISE tut sich mit dem Fitten schwer. Es wird 
auch Unterumständen unerwartete Effekte geben. Da sind solche langen 
Prozesse schwierig bei der Fehlersuche.
Bei dir würde es sich anbieten einen Prozess für lesen und einen 
weiteren für schreiben.

Du kannst mal in die Mais CPU schauen, das sind z.B. die Dateien
reg_bank.vhd
spb_memory.vhd
wo du verstehst kannst wie ich es meine.

Weiter so, du bist auf dem richtigen Weg in der Lernkurve.

[Duke Scarring (Gast)]

Student schrieb:
> Ich habe mal eine Frage, was spricht dagegen dass man selbst AXI4 Lite
> Interface implementiert, statt vorgefrtiger IP-Core (mit IPIF Interface)
> von Xilinx zu nehmen?
Nichts.
Vielen Dank für Deinen Vorstoß.
Die IP-Cores kann man nehmen, wenn sie für die gestellte Aufgabe genau 
passen. Sobald man eine Sonderlocke braucht, wird der Aufwand einen 
feritgen IP-Core hinzubiegen schnell so groß, das man es auch gleich 
selber machen kann.

> Ich habe mal kurz einfaches Register implementiert und in ISIM
> Simuliert. Sieht maeine meinung nach gut aus. Oder was meint ihr?
Ja, die Simulation sieht auf den ersten Blick gut aus.

Ich würde die drei Interfaces in records packen. Die Signalnamen sind 
wegen der minimalen Unterschiede fehlerträchtig zu lesen:

     S_AXI_AWADDR
     S_AXI_AWVALID
     S_AXI_AWREADY
     S_AXI_WDATA
     S_AXI_WVALID
     S_AXI_WREADY
     S_AXI_WSTRB
     S_AXI_BVALID
     S_AXI_BREADY
     S_AXI_BRESP
     S_AXI_ARADDR
     S_AXI_ARVALID
     S_AXI_ARREADY
     S_AXI_RDATA
     S_AXI_RVALID
     S_AXI_RREADY
     S_AXI_RRESP

Student schrieb:
> use ieee.std_logic_arith.all;
> use ieee.std_logic_unsigned.all;
Bitte nimm diese Bibliotheken raus:
1. Hier wird nichts gerechnet, Du brauchst Sie gar nicht.
2. Beitrag "Re: IEEE.STD_LOGIC_ARITH.ALL obsolete"

Und dann noch ein kleiner Schönheitsfehler:
Mit calc_time wird nichts angestellt...

Duke

[Atze vom Bau (Gast)]

René D. schrieb:
> Du hast alles in einen Prozess gepackt. Solcher Code
> ist schlecht wartbar und ISE tut sich mit dem Fitten schwer.

...hast Du dazu weiterführende Informationen von Xilinx, wie groß ein 
Prozess sein soll/darf?

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

Atze vom Bau schrieb:

> ...hast Du dazu weiterführende Informationen von Xilinx, wie groß ein
> Prozess sein soll/darf?

Da gibt es sicher keine Beschränkung. Der Fitter wird es schon packen.
Ich habe auch so angefangen VHDL zu schreiben. Doch man merkt, das die 
Kennzahlen, wie erreichbare Frequenz nach oben oder auch verwendete LUT 
nach unten gehen.

[Student (Gast)]

Vielen Dank für eure Antworten!

Die Frage ist insofern entstanden da es im Internet nicht mal ein 
Beispiel darüber gibt, wie man in solchen Fällen vorgehen soll und 
Xilinx nur vorgefertigter IPCore empfiehlt.

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

Student schrieb:
> Vielen Dank für eure Antworten!
>
> Die Frage ist insofern entstanden da es im Internet nicht mal ein
> Beispiel darüber gibt, wie man in solchen Fällen vorgehen soll und
> Xilinx nur vorgefertigter IPCore empfiehlt.

Melde dich mal hier an. Das ist besser, wenn du in späteren Threads 
wieder auftauchst. Halte uns hier auf dem Laufenden. Ich habe auch von 
deinem Beispiel das AXI timing gelernt.

Ich habe ähnliche Probleme gehabt. AXI kam nachdem ich meinen Einstieg 
in die FPGA welt gefunden habe. Es ist immer etwas Zauber über einfache 
Sachen.

Für meine eigenen Sachen habe ich mir einen eigenen Bus spezifiziert. 
Ich habe Ihn SPB simple Pipeline Bus genannt.