¿Cómo representar un contador de 3 bits en el estilo de flujo de datos? [cerrado]

Si tuviera que examinar el enlace proporcionado en el comentario de Dave Tweed -

  

Depende de exactamente lo que quiere decir con "Estilo de flujo de datos". Como puedas   vea en esto   discusión ,   No es un concepto bien definido. - Dave Tweed ♦

Es posible que ninguna de las tres respuestas (a partir de esta fecha) sea incompatible entre sí para describir una expresión de flujo de datos de una especificación de diseño. Para un contador de tres bits, tal especificación de diseño podría tener este aspecto:

library ieee;
use ieee.std_logic_1164.all;

entity ctr3 is
    port (
        input:      in  std_logic_vector (2 downto 0);
        load:       in  std_logic;
        reset:      in  std_logic;
        enable:     in  std_logic;
        clk:        in  std_logic;
        q:          out std_logic_vector (2 downto 0)
    );
end entity;

architecture behave of ctr3 is

    signal cntin,cntd,cntq: std_logic_vector (2 downto 0);

    begin

cntinc:         -- 3 bit incrementer
    process(cntq)   
        begin
    cntin(0) <= not cntq(0);
    cntin(1) <= cntq(1) xor cntq(0);
    cntin(2) <= cntq(2) xor (cntq(0) and cntq(1));
  end process;

cntdin:
    cntd <= (others => '0') when reset = '1' else
             cntq           when reset = '0' and enable = '0' else
             input          when reset = '0' and enable = '1' and
                                  load = '1' else
             cntin          when reset = '0' and enable = '1' and
                                  load = '0' else
             (others => 'X');

cntreg:
    process
        begin
        wait until clk'event and clk = '1';
        cntq <= cntd;
    end process;

cntout:
    q <= cntq;

end architecture;

  

No. Esta pregunta es demasiado vaga y amplia. - Olin   Lathrop   Hace 7 horas

La parte de la pregunta que es vaga es qué características tiene el contador, y el ejemplo anterior proporciona carga síncrona, reinicio síncrono y habilitación. Dentro de esos límites, sí proporciona "sugerencias sobre cómo se va a representar".

La parte más amplia consiste en describir lo que implica una descripción de flujo de datos.

La respuesta referenciada y aceptada de Brian:

  

"Flujo de datos" Creo que es bastante claro aquí; SÍ describe el flujo de datos y lo describe en términos de declaraciones concurrentes. Pero agregaría que cada declaración concurrente es despertada por cambios en sus entradas y entrega sus salidas; por lo tanto (el bit importante :) no hay correspondencia entre el orden de las cosas que suceden y el orden de los elementos en el código fuente. En ese sentido tiene mucho en común con la programación funcional. Y los dos primeros modelos son flujo de datos; en (I) los elementos están en orden lógico, mientras que (II) no lo está.

respuesta referenciada del sensor:

  

Flujo de datos: describe cómo fluyen los datos.

Mi respuesta referenciada:

  

• Flujo de datos: describe cómo los datos fluyen desde las entradas a la salida con mayor frecuencia utilizando las operaciones NOT, AND y OR.
  

Y la especificación de diseño anterior cumple con las tres definiciones.

Las tres respuestas son observaciones derivadas de instituciones educativas sobre la estructura de las descripciones de diseño de VHDL desde perspectivas particulares que no se prestan a una generalización sin explicación.

Extraí esta paráfrasis de un contador más grande de un diseño hecho antes del cambio de milenio en una era en la que una licencia de síntesis de expresión aritmética era un costo adicional.

Esta descripción de diseño analiza y un banco de pruebas simple:

library ieee;
use ieee.std_logic_1164.all;

entity ctr3_tb is
end entity;

architecture foo of ctr3_tb is
    signal input:      std_logic_vector (2 downto 0);
    signal load:       std_logic;
    signal reset:      std_logic;
    signal enable:     std_logic;
    signal clk:        std_logic := '0';
    signal q:          std_logic_vector (2 downto 0);
begin
CLOCK:
    process 
    begin
        wait for 5 ns;
        clk <= not clk;
        if NOW > 100 ns then
            wait;
        end if;
    end process;  
DUT:  
    entity work.ctr3 
        port map (
            input  =>  input,
            load   => load,
            reset  => reset,
            enable => enable,
            clk    => clk,
            q      => q
        );
STIMULUS:
    process
    begin
        wait for 6 ns;
        input <= "001";
        load <= '0';
        reset <= '1';
        enable <= '0';
        wait for 10 ns;
        reset <= '0';
        wait for 10 ns;
        enable <= '1';
        wait for 30 ns;
        load <= '1';
        wait for 20 ns;
        load <= '0';
        enable <= '0';
        wait;  
    end process;
end architecture;

demuestra que elabora y se ejecuta con resultados funcionales:

( clickable)