在std_logic_vector中生成常规模式

Question

我正在寻找一种资源有效的方法来将位设置在std_logic_vector的特定位置。

假设我有一个std_logic_vector，例如signal a := std_logic_vector(LEN-1 downto 0) := (others => '0') ，其中LEN是泛型的。 我想将其定期设置为1 ，例如在第五，第十，...位置，其中间隔可能来自一组（小的）预定义数字，例如(5,10,20,25,30,40,50) 。 最节省资源的方法是什么？

显然，这可以使用for循环和mod函数来实现。 但是，我想将此方法用于综合，因此mod函数可能会很昂贵。 另一种可能性是展开循环。但是，由于LEN是通用的，因此我不知道步骤数。 此外，我想排除不可能的组合，例如，如果LEN = 20 ，则应该排除> 20的整数。

Answer 1

Yann的答案有几个问题，在这里我想解决，以为不熟悉VHDL语法的人提供答案。 这不是对Yann选择的实现的批评，而是要阐明语法问题。

首先，以上示例不完整。 它描述了一个component语句，但没有相应的entity 。 component的使用仅在声明性区域中，不能在package或architecture之外独立存在。 如所写，它将无法编译。 而是应将其更改为：

entity columns is
...
end entity columns;

其次，如果没有相应的类型声明，就无法声明数组。 也就是说，Yann的帖子中的示例：

values  : array (0 to choices-1) of integer

无法完成。 必须先声明一个类型，然后才能使用它。 并且为了使该类型对于组件/实体可见，必须在component或entity之前定义它。 对于entity ，需要在包中定义它。 例如：

package columns_pkg is
  type values_array is array(natural range <>) of integer;
end package columns_pkg;

然后，可以在entity引用columns_pkg 。 如：

library ieee;
use ieee.std_logic_1164.all;
use work.columns_pkg.all;

entity columns is
  generic (
    LEN     : integer;                  -- bits of output
    choices : integer;                  -- number of column combinations
      -- distances at which bits may be 1
    values  : values_array(0 to choices-1)
  );
  ...

现在，这仍然不太正确。 只有在VHDL-2008中，泛型才能相互依赖。 也就是说， values的范围只能取决于VHDL-2008中的choices 。 较早的语言版本要求它们不相关，这意味着上述values的声明将在VHDL-2002及更早版本中失败。

但是事实证明， choices甚至没有必要。 相反，可以做到这一点（将它们放在一起并清理一些错字）：

library ieee;
use ieee.std_logic_1164.all;

package columns_pkg is
  type values_array is array(natural range <>) of integer;
end package columns_pkg;

library ieee;
use ieee.std_logic_1164.all;
use work.columns_pkg.all;

entity columns is
  generic
  (
    LEN     : integer;                  -- bits of output
    values  : values_array
  );
  port
  (
    -- one hot encoded distance choice
    distance : in  std_logic_vector(values'length-1 downto 0);
    -- data which is 1 at selected distance
    bits     : out std_logic_vector(LEN-1 downto 0)
  );
end entity columns;

architecture behavioural of columns is    
begin  -- architecture behavioural

  bitgen: for i in bits'range generate
  begin
    -- purpose: calculate one individual bit
    -- type   : combinational
    -- inputs : distance
    -- outputs: bits(i)
    bitcalc: process (distance) is
      variable j : integer;
    begin  -- process bitcalc
      bits(i) <= '0';
      for j in values'range loop
        if i mod values(j) = 0 and distance(j) = '1' then
          bits(i) <= '1';
        end if;
      end loop;  -- j
    end process bitcalc;
  end generate;

end architecture behavioural;

请注意， values不受限制。 该长度将在详细说明时确定。 并且可以利用属性来确定长度和范围。

同样，如果LEN与values的范围之间存在关系，那么LEN泛型也可能会被消除。

最后，要利用columns ，可以做到：

entity top is
end entity top;

use work.columns_pkg.all;

architecture behavioural of top is
  constant columns_values : values_array(0 to 5) := (0, 5, 10, 15);

  -- one hot encoded distance choice
  signal distance : std_logic_vector(columns_values'length-1 downto 0);

  -- data which is 1 at selected distance
  signal bits     : out std_logic_vector(31 downto 0);
begin
  columns_inst : entity work.columns
  generic map
  (
    LEN => bits'length,
    values => columns_values
  )
  port map
  (
    distance => distance,
    bits => bits
  );

end architecture behavioural;

Answer 2

鉴于您的数字是预定义的，您只需要在一个恒定的位位置和一个（少数）恒定数之间进行模运算。 这可以通过一组两个循环完成，每个循环产生一个简单的树和/或树。 合成器很可能也可以消除一些常见的逻辑。 我可能会将步距编码为一个热点，或者将其编码为5表示n * 5的树形式。 我猜代码可能类似于：

component columns is
  generic (
    LEN     : integer;                  -- bits of output
    choices : integer;                  -- number of column combinations
      -- distances at which bits may be 1
    values  : array (0 to choices-1) of integer);
  port (
      -- one hot encoded distance choice
    distance : in  std_logic_vector(choices-1 downto 0);
      -- data which is 1 at selected distance
    bits     : out std_logic_vector(LEN-1 downto 0));
end component columns;

architecture behavioural of columns is

begin  -- architecture behavioural

  bitgen: for i in 0 to choices-1 generate
  begin
    -- purpose: calculate one individual bit
    -- type   : combinational
    -- inputs : distance
    -- outputs: bits(i)
    bitcalc: process (distance) is
      variable j : integer;
    begin  -- process bitcalc
      bits(i) <= '0';
      for j in 0 to chocies-1 loop
        if i mod values(j) = 0 and distance(j) then
          bits(i) <= '1';
        end if;
      end loop;  -- j
    end process bitcalc;
  end generate;

end architecture behavioural;

这只会产生少量的或宽度可变的门。