Latch statt Multiplexer?

Gast #2960587
Lesenswert?

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:
1
library IEEE;
2
use IEEE.STD_LOGIC_1164.ALL;
3

4
entity Instruction_Ex is
5
    Port ( CLK          : in std_logic;
6
        INPUT_ALU     : in std_logic_vector (7 downto 0);
7
        INPUT_BYP      : in std_logic_vector(7 downto 0);
8
           INPUT_MODE     : in std_logic_vector (1 downto 0);
9
        OUTPUT_MODE    : in std_logic_vector (1 downto 0);
10
           OUTPUT_REG     : out std_logic_vector (7 downto 0);
11
           OUTPUT_DIRECT   : out std_logic_vector (7 downto 0));
12
end Instruction_Ex;
13

14
architecture Behavioral of Instruction_Ex is
15

16
signal output_int   : std_logic_vector(7 downto 0);
17
signal input_int     : std_logic_vector (7 downto 0);
18

19
begin
20
  
21
  INPUTMux:process(INPUT_MODE,INPUT_ALU,INPUT_BYP)
22
  begin
23
    case INPUT_MODE is 
24
      when "00" =>
25
        input_int <= INPUT_ALU;
26
      when "01" =>
27
        input_int <= INPUT_BYP;
28
      when others =>
29
         input_int <= INPUT_ALU;
30
    end case;
31
  end process;
32
  
33
  OUTPUTMux:process(OUTPUT_MODE,input_int,INPUT_ALU,INPUT_BYP,INPUT_MODE)
34
  begin
35
    case OUTPUT_MODE is 
36
      when "00" =>
37
        OUTPUT_REG     <= input_int;
38
      when "01" =>
39
        OUTPUT_DIRECT   <= input_int;
40
      when others =>
41
        OUTPUT_REG    <= input_int;
42
    end case;
43
  end process;
44
    
45
end Behavioral;
Gast #2960603
Lesenswert?

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
Gast #2960715
Lesenswert?

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
Persönliche Seite #2988330
Lesenswert?

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.

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren