Arrays 创建通用多路复用器

我想创建一个通用多路复用器，这意味着它可以有可变数量的输入和可变的数据宽度。这意味着为了声明数据输入，我需要一个如下所示的数组：

type data is array(entries-1 downto 0) of std_logic_vector(data_width-1 downto 0);

---

然而，我不知道我如何才能做到这一点。我不清楚应该在哪里声明类型“data”，因为我必须在输入端口声明中使用它，仅用于组合mux操作，并且没有任何特殊的数据类型， 那么这样的函数可能很方便：

function mux(constant ENTRIES : natural;
                      sel     : std_logic_vector;
                      data    : std_logic_vector)  -- Data for sel = 0 at left position
  return std_logic_vector is
  constant DATA_WIDTH   : natural := data'length / ENTRIES;
  alias    data_norm    : std_logic_vector(0 to data'length - 1) is data;
  type     data_split_t is array (0 to ENTRIES - 1) of std_logic_vector(0 to DATA_WIDTH - 1);
  variable data_split_v : data_split_t;
  variable res_v        : std_logic_vector(0 to DATA_WIDTH - 1);
begin
  for i in 0 to ENTRIES - 1 loop
    data_split_v(i) := data(i * DATA_WIDTH to (i + 1) * DATA_WIDTH - 1);
  end loop;
  res_v := data_split_v(to_integer(unsigned(sel)));
  return res_v;
end function;

数据宽度是根据数据的数量从整个

数据
长度中得出的
指定的条目

使用时，函数可以作为并发函数调用调用，如：

dut_out <= mux(ENTRIES,
               dut_sel,
               dut_in_0 &
               dut_in_1 &
               dut_in_2);

dut\u out您可以实现通用多位多路复用器，如下所示：

类型数据是
标准逻辑向量（数据宽度-1到0）；
--##计算函数ceil（log（n））的整数结果
--#其中b是基数
函数cell_log（n，b：正）返回自然值
可变对数，残差：自然；
开始
残差：=n-1；
对数：=0；
而残差>0循环
剩余：=剩余/b；
log:=log+1；
端环；
返回日志；
末端功能；
函数mux_数据（输入：数据；选择：无符号）
返回标准逻辑向量为
别名输入\u asc：数据（0到输入的长度-1）为输入；
可变焊盘输入：数据（0至（2**Sel'长度）-1）；
可变结果：标准逻辑向量（输入asc（0）范围）；
开始
assert inputs_asc'length您可以在端口元素没有特定数据数组类型的情况下实现mux：

library ieee;
use ieee.std_logic_1164.all;


entity generic_mux is
    generic (
        entries:    natural := 3;
        data_width: natural := 8        
    );
    port (
        signal inp:     in  std_logic_vector (entries*data_width-1 downto 0);
        signal sel:     in  natural range 0 to entries-1;
        signal outp:    out std_logic_vector (data_width-1 downto 0)
    );
end entity;

architecture foo of generic_mux is
    type mux_array is array (natural range 0 to entries-1) of 
                std_logic_vector(outp'range);
    signal array_val: mux_array;
begin

GEN: for i in array_val'range generate
        array_val(i) <= inp (outp'LEFT+(i*data_width) downto i*data_width);
    end generate;

    outp <= array_val(sel);

end architecture;

ieee库；
使用ieee.std_logic_1164.all；
实体通用_mux是
一般的(
条目：自然：=3；
数据宽度：自然宽度：=8
);
港口(
信号输入：标准逻辑向量（条目*数据宽度-1向下至0）；
信号选择：在0到1的自然范围内；
信号输出：输出标准逻辑向量（数据宽度-1到0）
);
终端实体；
通用μmux的体系结构foo是
类型mux_数组是
标准逻辑向量（输出范围）；
信号阵列：mux阵列；
开始
GEN:为数组中的i_val'生成
数组值（i）
library ieee;
use ieee.std_logic_1164.all;


entity generic_mux is
    generic (
        entries:    natural := 3;
        data_width: natural := 8        
    );
    port (
        signal inp:     in  std_logic_vector (entries*data_width-1 downto 0);
        signal sel:     in  natural range 0 to entries-1;
        signal outp:    out std_logic_vector (data_width-1 downto 0)
    );
end entity;

architecture foo of generic_mux is
    type mux_array is array (natural range 0 to entries-1) of 
                std_logic_vector(outp'range);
    signal array_val: mux_array;
begin

GEN: for i in array_val'range generate
        array_val(i) <= inp (outp'LEFT+(i*data_width) downto i*data_width);
    end generate;

    outp <= array_val(sel);

end architecture;

library ieee;
use ieee.std_logic_1164.all;

entity instantiation is
end entity;

architecture foo of instantiation is
    constant entries:   natural := 4;
    constant data_width: natural := 8;
    signal a:    std_logic_vector (data_width-1 downto 0) := X"FE";
    signal b:    std_logic_vector (data_width-1 downto 0) := X"ED";
    signal c:    std_logic_vector (data_width-1 downto 0) := X"FA";
    signal d:    std_logic_vector (data_width-1 downto 0) := X"CE";
    signal sel:  natural range 0 to 3;
    signal inp:  std_logic_vector (entries*data_width-1 downto 0);
    signal outp: std_logic_vector (data_width-1 downto 0);
begin
    inp <= d & c & b & a;
MUX: entity work.generic_mux
    generic map (entries => 4)
    port map (
        inp => inp,
        sel => sel,
        outp => outp
    );

STIMULUS:
    process
    begin
        for i in 1 to entries-1 loop
            wait for 10 ns;
            sel <= i;
        end loop;
        wait for 10 ns;
        wait;
    end process;

end architecture;