Generischer Multiplexer gesucht

Gast #895415
Ich bin auf der Suche nach einem generischem Multiplexer.
So wie unten geht es anscheinend nicht.
Das Schema zeigt keine entsprechende Strukturen.
Die Anzahl der Rotoren (number_of_rotors_array) ist generisch; die 
Anzahl der Selektoren (selector_internal) natürlich auch.

signal selector_internal: std_logic_vector(0 to number_of_rotors_array - 
1) := (others => '0');

Da fehlen natürlich noch einige Zeilen dazwischen.

lookup_position : process (clock_array, selector_internal)
begin
   if rising_edge(clock_array)
   then
  for i in 0 to number_of_rotors_array - 1 loop
     if selector_internal(i) = '1'
     then
    data_out_array   <= data_out_internal(i);
    address_out_array <= address_out_internal(i);
    position_array   <= position_internal(i);
    error_array      <= error_internal(i);
     end if;
        end loop;
   end if;
end process;

Dank euch
#1159182
Grüße!
Also ich hab auch schon seit Ewigkeiten nach einem generischen 
Multiplexer gesucht. Da ich nirgends einen komplett generischen finden 
konnte, habe ich mich selbst mal hingesetzt. Das ist für die Nachwelt 
dabei herausgekommen (die Bitbreite muss man dann nur im Package 
eintragen):

-- =====================================================================
-- Project:     General
-- Filename:    GENERIC_MUX.vhd
-- Description: Completely variable multiplexer for 32-bit data vectors.
-- Author(s):   Christian Anton
-- Created:     24.02.2009
-- Last Change: 24.02.2009
-- =====================================================================

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;   -- for conversion
use work.BASICS_PACK.all;   -- for N_x_std_logic_vec_32, ld_ceil

entity GENERIC_MUX is
    generic(
        COUNT_INPUT  : natural := 4   -- count of input vectors
    );
    port(
        INPUTS    : in  N_x_std_logic_vec_32(COUNT_INPUT-1 downto 0);
        SEL      : in  std_logic_vector(ld_ceil(COUNT_INPUT)-1 downto 
0);
        OUTPUT    : out  std_logic_vector(31 downto 0)
    );
end entity;


architecture BEHAVIOR of GENERIC_MUX is

begin
    -- Choose the output accordingly to SEL
    CHOOSE_OUTPUT : process(SEL, INPUTS)
    variable output_number  : std_logic_vector(ld_ceil(COUNT_INPUT)-1 
downto 0);
    begin
        -- Iterate over all input vectors and output the selected data
        for i in INPUTS'range loop

            output_number := std_logic_vector( to_unsigned(i, 
ld_ceil(COUNT_INPUT)) );
            if (SEL = output_number) then
                OUTPUT <= INPUTS(i);
                exit;
            else
                OUTPUT <= (others => '0');
            end if;

        end loop;

    end process CHOOSE_OUTPUT;

end architecture;



-- =====================================================================
-- Project:     General
-- Filename:    GENERIC_MUX_PACK.vhd
-- Description: Package including basic type definition and function for
--              the generic mulitplexer.
-- Author(s):   Christian Anton
-- Created:     24.02.2009
-- Last Change: 24.02.2009
-- =====================================================================

library ieee;
use ieee.std_logic_1164.all;

package GENERIC_MUX_PACK is

    type N_x_std_logic_vec_32 is array(natural range <>) of 
std_logic_vector(31 downto 0);

    -- Calculates the rounded up logarithmus duales of x
    function ld_ceil(x : natural) return natural;

end package;


package body GENERIC_MUX_PACK is

    -- Calculates the rounded up logarithmus duales of x
    function ld_ceil(x : natural) return natural is
    variable ld : natural := 0;
    variable x_int : real := real(x);
    begin
        while (x_int > 1.0) loop
            ld := ld + 1;
            x_int := x_int / 2.0;
        end loop;

        return ld;
    end function ld_ceil;

end package body;
#1159202
Wenn die Zahl der Eingaenge eine Zweierpotenz sind geht es auch in einer 
Zeile:

Q <= D(to_integer(sel)*Breite+Breite-1 downto to_integer(sel)*Breite);

Dieses Konstrukt muss man aber im Synthese-Report ueberpruefen: In 
manchen Faellen wird ein Multiplizierer erzeugt und die Logik sehr 
gross, weil ein Multiplexer gebaut wird, der jedes Bit auf jedes Bit 
abbildet und nicht wie benoetigt nur Wort auf Wort.

Antwort schreiben

Eine eigene Frage? Dieser Thread ist über 18 Jahre alt. Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [vhdl]VHDL-Code[/vhdl]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.