Implementación de un acumulador en VHDL

Question

Estoy tratando de implementar un acumulador firmado Usando Core Gen en Xilinx. Según mi comprensión, un acumulador realiza la función de un registro normal que solo está enrutando la entrada a la salida, pero quería aclararlo.

Agregué el módulo de acumulador IPCORE (.XCO) al proyecto y tengo un archivo principal que básicamente contiene la declaración de componentes y el mapa del puerto. También tengo un proceso de solo paso. Todo lo compila y puedo ver el resultado en el tablero, pero no entiendo bien lo que está pasando ...

Cuando ingreso 1000 La salida de 8 bits en los LED es 11111000. Otra entrada de 1111 me da 11110111. Adjunto el código aquí para el archivo VHD principal llamado Accm y el .vho expediente.

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

----------------------------------------------------------------------------------
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 Accm is
port( b: in std_logic_vector(3 downto 0);
        sclr, clk, b1, b2 : in std_logic;
        q : out std_logic_vector(7 downto 0)
);      

end Accm;

architecture Behavioral of Accm is

-- signal declaration
type tell is (rdy,pulse,not_rdy);
signal d_n_s: tell; 
signal en: std_logic;

-- component declaration
COMPONENT my_accm
  PORT (
    b : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    clk : IN STD_LOGIC;
    sclr : IN STD_LOGIC;
    q : OUT STD_LOGIC_VECTOR(7 DOWNTO 0)
  );
END COMPONENT;

-- port map
begin

A1 : my_accm
  PORT MAP (
    b => b,
    clk => en,
    sclr => sclr,
    q => q
  );

process(clk)
begin
if clk'event and clk='1' then
case d_n_s is
when rdy => en <= '0';
if b1='1' then d_n_s <= pulse; end if;
when pulse => en <= '1';
d_n_s <= not_rdy;
when not_rdy => en <='0';
if b2='1' then d_n_s <= rdy; end if;
end case;
end if;
end process;

-- .VHO CODE

------------- Begin Cut here for COMPONENT Declaration ------ COMP_TAG
COMPONENT my_accm
  PORT (
    b : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    clk : IN STD_LOGIC;
    sclr : IN STD_LOGIC;
    q : OUT STD_LOGIC_VECTOR(7 DOWNTO 0)
  );
END COMPONENT;
-- COMP_TAG_END ------ End COMPONENT Declaration ------------

-- The following code must appear in the VHDL architecture
-- body. Substitute your own instance name and net names.

------------- Begin Cut here for INSTANTIATION Template ----- INST_TAG
your_instance_name : my_accm
  PORT MAP (
    b => b,
    clk => clk,
    sclr => sclr,
    q => q
  );

end Behavioral;

También estoy pegando una imagen del AcumualTor que generé en Coregen.

Agradecería que alguien pudiera explicarme lo que está sucediendo en este programa. ¡Gracias!

Answer 1

"Acumulador" puede significar muchas cosas. En la biblioteca de hardware Xilinx, el componente que instancia es un sumador frente a un registro. El sumador está agregando el valor actual del registro del acumulador con el término de entrada. El registro del acumulador es más amplio que la entrada, por lo que puede acumular (agregar) muchos términos de entrada sin desbordar la salida.

Cuando comienza su circuito, el acumulador contiene cero. Ingresa 1000 (-8) que cuando se agrega a cero se convierte en 11111000 (-8 signo extendido) en la salida. Luego agrega 1111 (-1), y la salida se convierte en 11110111 (-9 signo extendido).

Una vez que haya terminado de "acumular", afirme a SCLR para borrar el registro del acumulador de nuevo a cero (o use sset o sinit, según corresponda para su lógica).

Todo esto debería estar cubierto por la documentación para la biblioteca Xilinx (intente hacer clic en el botón "Hoja de datos" en el cuadro de diálogo Corgen).

Answer 2

En realidad, creo que lo entiendo ahora. Es solo actuar como un Adder con entradas firmadas. Creo que tengo razón en esto, ¡pero agradecería cualquier aclaración!