Circuitos Digitales - Ayuda con vhdl

 
Vista:

Ayuda con vhdl

Publicado por Alejandro (1 intervención) el 30/11/2012 09:44:12
Hola buenas. Veran, resulta que tengo que hacer una descripcion estructural de un circuito usando un decodificador 3 a 8 y un multiplexor 8 a 1 ( en apartados separados) que ya me dan previamente programados. El problema es que no se como usarlos, es decir, si tengo que usar una puerta logica lo escribiria asi:

puerta0: entity work.and2 port map(x,y,z) Por ejemplo.

Ahora como haria para usar de esta forma el decodificdor y el mutiplaexor.
Aqui les dejo ambos para que vean como estan programados.

library ieee;
use ieee.std_logic_1164.all;

entity mux8a1 is
port (enable: in std_logic;
x: in std_logic_vector(7 downto 0);
sel: in std_logic_vector(2 downto 0);
y: out std_logic);
end mux8a1;

architecture funcional of mux8a1 is
begin
process(enable, x, sel)
begin
if enable = '0' then
y <= '0';
else
case sel is
when "000" => y <= x(0);
when "001" => y <= x(1);
when "010" => y <= x(2);
when "011" => y <= x(3);
when "100" => y <= x(4);
when "101" => y <= x(5);
when "110" => y <= x(6);
when others => y <= x(7);
end case;
end if;
end process;
end funcional;
-------------------------------------------------------------------------
library ieee;
use ieee.std_logic_1164.all;

entity deco3a8 is
port(enable: in std_logic;
x: in std_logic_vector(2 downto 0);
y: out std_logic_vector(7 downto 0));
end deco3a8;

architecture funcional of deco3a8 is
begin
process(enable, x)
begin
if enable = '0' then
y <= (others => '0');
else
case x is
when "000" => y <= "00000001";
when "001" => y <= "00000010";
when "010" => y <= "00000100";
when "011" => y <= "00001000";
when "100" => y <= "00010000";
when "101" => y <= "00100000";
when "110" => y <= "01000000";
when others => y <= "10000000";
end case;
end if;
end process;
end funcional;

Me urge un poco. Gracias
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Ayuda con vhdl

Publicado por Alejandro (117 intervenciones) el 29/08/2023 17:59:48
¡Entiendo que estás buscando cómo utilizar estos componentes programados en una descripción estructural en VHDL! A continuación, te mostraré cómo puedes hacerlo utilizando las descripciones estructurales para el decodificador 3 a 8 y el multiplexor 8 a 1.

Descripción estructural del decodificador 3 a 8:

Para utilizar el decodificador 3 a 8 en una descripción estructural, necesitas conectar sus entradas y salidas a través de señales internas. Aquí te muestro cómo hacerlo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
library ieee;
use ieee.std_logic_1164.all;
 
entity uso_deco3a8 is
port (
    enable_dec: in std_logic;
    x_dec: in std_logic_vector(2 downto 0);
    y_dec: out std_logic_vector(7 downto 0)
);
end uso_deco3a8;
 
architecture estructural_deco of uso_deco3a8 is
    signal temp_out: std_logic_vector(7 downto 0);
begin
    -- Instancia del decodificador
    dec_inst: entity work.deco3a8
    port map (
        enable => enable_dec,
        x => x_dec,
        y => temp_out
    );
 
    -- Conexión de las salidas del decodificador a la salida y_dec
    y_dec <= temp_out;
end estructural_deco;

Descripción estructural del multiplexor 8 a 1:

De manera similar, aquí tienes cómo usar el multiplexor 8 a 1 en una descripción estructural:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
library ieee;
use ieee.std_logic_1164.all;
 
entity uso_mux8a1 is
port (
    enable_mux: in std_logic;
    x_mux: in std_logic_vector(7 downto 0);
    sel_mux: in std_logic_vector(2 downto 0);
    y_mux: out std_logic
);
end uso_mux8a1;
 
architecture estructural_mux of uso_mux8a1 is
    signal temp_out_mux: std_logic;
begin
    -- Instancia del multiplexor
    mux_inst: entity work.mux8a1
    port map (
        enable => enable_mux,
        x => x_mux,
        sel => sel_mux,
        y => temp_out_mux
    );
 
    -- Conexión de la salida del multiplexor a la salida y_mux
    y_mux <= temp_out_mux;
end estructural_mux;

En ambos casos, estamos creando una entidad nueva (por ejemplo, `uso_deco3a8` y `uso_mux8a1`) que contiene las instancias de los componentes decodificador y multiplexor. Luego, conectamos las entradas y salidas adecuadamente entre las señales internas y las interfaces de los componentes.

Estas descripciones estructurales permiten utilizar los componentes previamente programados en un nuevo contexto. Asegúrate de ajustar los nombres de las señales y los nombres de las entidades según tu necesidad.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar