Latch statt Multiplexer?

[TM (Gast)]

Guten Tag,

Ich sitze im Moment an einem Problem und weiß nicht wirklich woher es 
kommt.

Also, was möchte ich beschreiben:

Einen Eingangsmultiplexer, welcher mit IN_MODE das interne Signal 
auswählt und einen Ausgangsmultiplexer, welcher mittels OUT_MODE das 
interne Signal auf verschiedene Ausgänge aufteilen kann.

Was wird draus:

Anstelle des Ausgangsmultiplexers werden zwei 8 bit lachtes erzeugt.

Hier mein Code:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity Instruction_Ex is
    Port ( CLK          : in std_logic;
        INPUT_ALU     : in std_logic_vector (7 downto 0);
        INPUT_BYP      : in std_logic_vector(7 downto 0);
           INPUT_MODE     : in std_logic_vector (1 downto 0);
        OUTPUT_MODE    : in std_logic_vector (1 downto 0);
           OUTPUT_REG     : out std_logic_vector (7 downto 0);
           OUTPUT_DIRECT   : out std_logic_vector (7 downto 0));
end Instruction_Ex;

architecture Behavioral of Instruction_Ex is

signal output_int   : std_logic_vector(7 downto 0);
signal input_int     : std_logic_vector (7 downto 0);

begin
  
  INPUTMux:process(INPUT_MODE,INPUT_ALU,INPUT_BYP)
  begin
    case INPUT_MODE is 
      when "00" =>
        input_int <= INPUT_ALU;
      when "01" =>
        input_int <= INPUT_BYP;
      when others =>
         input_int <= INPUT_ALU;
    end case;
  end process;
  
  OUTPUTMux:process(OUTPUT_MODE,input_int,INPUT_ALU,INPUT_BYP,INPUT_MODE)
  begin
    case OUTPUT_MODE is 
      when "00" =>
        OUTPUT_REG     <= input_int;
      when "01" =>
        OUTPUT_DIRECT   <= input_int;
      when others =>
        OUTPUT_REG    <= input_int;
    end case;
  end process;
    
end Behavioral;

[Lutz Laserblick (Gast)]

TM schrieb:
> OUTPUTMux:process(OUTPUT_MODE,input_int,INPUT_ALU,INPUT_BYP,INPUT_MODE)
>   begin
>     case OUTPUT_MODE is
>       when "00" =>
>         OUTPUT_REG     <= input_int;
          ##########
>       when "01" =>
>         OUTPUT_DIRECT   <= input_int;
          #############
>       when others =>
>         OUTPUT_REG    <= input_int;
          ##########
>     end case;
>   end process;



da steckt das latch. Du beschreibst zwei (output_reg und Output_direct)
statt einen Ausgang.

mahlzeit

[TM (Gast)]

Ok habs jetzt zu einen Multiplexer mit zwei Ein und Ausgaengen 
umgeschrieben IN und OUT_MODE steuern zusammen den MODE es funktioniert 
nun einwandfrei und wird ohne Latches synthetisiert danke.

Gruss TM

[J. S. (engineer)]

Das ist wieder mal ein schönes Beispiel für die Notwendigkeit, alle 
Signale isoliert voneinander als Ausgang = Funktion (Eingänge) zu 
beschreiben. Dann sieht man nämlich leichter dass, dass in o.g. 
Beschreibung jeweils die Alternativen für die Fälle fehlen. Ansonsten 
muss man jeden denkbaren Zweig im Möglichkeitsbaum durchgehen und alle 
Fälle abdecken, was zu viel redundanter Beschreibung führt.