格雷码增量器的 VHDL 数据流描述

Question

我正在尝试使用数据流描述样式为格雷码增量器编写 VHDL 代码。我不明白如何将我在行为描述中使用的 for 循环转换为数据流描述。有什么建议吗？

这是我在行为描述中的工作代码

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity graycode is
    Generic (N: integer := 4);
     Port ( gcode : in  STD_LOGIC_VECTOR (N-1 downto 0);
           nextgcode : out  STD_LOGIC_VECTOR (N-1 downto 0));
end graycode;

architecture Behavioral of graycode is
begin

process(gcode)

    variable bcode : STD_LOGIC_VECTOR(N-1 downto 0);
    variable int_bcode : integer;

begin

    for i in gcode'range loop
        if(i < gcode'length - 1) then
            bcode(i) := gcode(i) XOR bcode(i+1);
            else
                bcode(i) := gcode(i);
        end if;
    end loop;

    int_bcode := to_integer(unsigned(bcode));
    int_bcode := int_bcode + 1;
    bcode := std_logic_vector(to_unsigned(int_bcode, N));

    for i in gcode'range loop
        if(i < gcode'length - 1) then
            nextgcode(i) <= bcode(i) XOR bcode(i+1);
            else
                nextgcode(i) <= bcode(i);
        end if;
    end loop;

end process;
end Behavioral;

Answer 1

“数据流”的意思是“就像电路图中的样子”。换句话说，数据流通过真实的电路，而不是高级算法描述。因此，展开您的循环并查看您实际描述的内容。从 N=2 开始，画出展开的电路。您应该得到一个 2 位输入总线，其中有一个异或门，然后是一个 2 位（组合）增量器，然后是一个 2 位输出总线，其中有另一个异或门。完成，N=2。

您现在的问题是概括 N。一种明显的方法是将您的基本 N=2 电路放在generate 循环中（是的，这是数据流，因为它只是复制了 harwdare），然后扩展它。如果您不能这样做，请提出另一个问题。

顺便说一句，您的整数增量器很笨拙 - 您应该直接增加 unsigned bcode。

Answer 2

数据流意味着由使用信号的并发语句构成。

这意味着使用生成语句而不是循环。 if 语句可以是 -2008 中带有 else 的 if generate 语句，或者对于 VHDL 标准的早期版本，两个 if generate 语句的条件为正在评估的相同值提供相反的布尔结果。

将异常分配提升为他们自己的并发信号分配更容易：

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity graycode is
    generic (N: natural := 4); -- CHANGED negative numbers wont be interesting
     port ( 
         gcode:      in   std_logic_vector (N - 1 downto 0);
         nextgcode:  out  std_logic_vector (N - 1 downto 0)
    );
end entity graycode;

architecture dataflow of graycode is
    signal int_bcode:     std_logic_vector (N - 1 downto 0);  -- ADDED
    signal bcode:         std_logic_vector (N - 1 downto 0);  -- ADDED
begin

    int_bcode(N - 1) <= gcode (N - 1);
TO_BIN: 
    for i in N - 2 downto 0 generate
        int_bcode(i) <= gcode(i) xor int_bcode(i + 1);
    end generate;

    bcode <= std_logic_vector(unsigned(int_bcode) + 1);

    nextgcode(N - 1) <= bcode(N - 1);
TO_GRAY:
    for i in N - 2 downto 0 generate
        nextgcode(i) <= bcode(i) xor bcode(i + 1);
    end generate;

end architecture dataflow;

for generate 方案的每次迭代都会详细说明一个块语句，其中 i 的字符串图像的隐式标签连接在 generate 语句标签名称字符串上。

在这些块中的每一个中，都有一个 i 的迭代值的声明，并且任何并发语句都被详细说明到这些块中。

可见性规则告诉我们，在封闭声明区域中可见的任何未在块状态中声明的名称在块内都是可见的。

这些意味着块中的并发语句等同于架构主体中的并发语句，其中 i 的值被替换为文字等价物。

生成语句和架构主体中的并发语句为我们提供了数据流表示。

还有一个测试平台：

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity graycode_tb is
end entity;

architecture foo of graycode_tb is
    constant N:         natural := 4;
    signal gcode:       std_logic_vector (N - 1 downto 0);
    signal nextgcode:   std_logic_vector (N - 1 downto 0);
    signal bcode:       std_logic_vector (N - 1 downto 0);
begin
DUT:
    entity work.graycode
        generic map ( N => N)
        port map (
            gcode => gcode,
            nextgcode => nextgcode
        );

STIMULi:
    process
    variable gv:        std_logic_vector (N - 1 downto 0);
    variable bv:        std_logic_vector (N - 1 downto 0);
    begin
        wait for 10 ns;
        for i in 0 to 2 ** N - 1 loop  

            bv := std_logic_vector(to_unsigned( i, bv'length));
            gv(N - 1) := bv (N - 1);   
            for i in N - 2 downto 0 loop
                gv(i) := bv(i) xor bv(i + 1);
            end loop;
            gcode  <= gv;
            bcode  <= bv;
            wait for 10 ns;
        end loop;
        wait;
    end process;
end architecture;

我们可以看到递增int_bcode的效果：