Question

我正在开展一个小型项目来学习VHDL。目前我正在研究BCD转换器（将二进制转换为BCD编号）。

但是在实施测试平台时我遇到了困难。在应用模式后，它不会重置输出。

我的实体的VHDL代码：

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

entity bcd_mod is
        port (
                entry: in std_logic_vector(16 downto 0);
                outp: out std_logic_vector(20 downto 0)
        );
end bcd_mod;

architecture calculate of bcd_mod is

begin
        process(entry)
                variable outp_cp : std_logic_vector(20 downto 0) := (others => '0');
                variable place : integer := 1;
                variable digit : integer := 0;
                variable number : integer := 0;

                begin

                        for i in 16 downto 0 loop
                                case entry(i) is
                                        when '0' => null;
                                        when '1' => number := number + (2**i);
                                        when others => null;
                                end case;
                        end loop;

                        if number > 99999 then
                                outp_cp(20) := '1';
                        else
                                while (number > 0) loop
                                        digit := number mod 10;

                                        if place = 1 then
                                                outp_cp(3 downto 0) := std_logic_vector(to_unsigned(digit, 4));
                                        elsif place = 2 then
                                                outp_cp(7 downto 4) := std_logic_vector(to_unsigned(digit, 4));
                                        elsif place = 3 then
                                                outp_cp(11 downto 8) := std_logic_vector(to_unsigned(digit, 4));
                                        elsif place = 4 then
                                                outp_cp(15 downto 12) := std_logic_vector(to_unsigned(digit, 4));
                                        else
                                                outp_cp(19 downto 16) := std_logic_vector(to_unsigned(digit, 4));
                                        end if;

                                        number := number - digit;
                                        number := number / 10;
                                        place := place + 1;
                                end loop;
                        end if;

                        outp <= outp_cp;
                        outp_cp := (others => '0');

        end process;

end calculate;

我的代码测试平台：

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

entity bcd_mod_testbench is
end bcd_mod_testbench;

architecture calculate of bcd_mod_testbench is
        component bmt
                port(entry : in std_logic_vector(16 downto 0); outp : out std_logic_vector(20 downto 0));
        end component;

        for bmt_0: bmt use entity work.bcd_mod;
                signal entry : std_logic_vector(16 downto 0);
                signal outp : std_logic_vector(20 downto 0);
                begin

        bmt_0: bmt port map (entry => entry, outp => outp);

        process
                type pattern_type is record
                        entry : std_logic_vector(16 downto 0);
                        outp : std_logic_vector(20 downto 0);
                end record;

                type pattern_array is array (natural range <>) of pattern_type;
                constant patterns : pattern_array :=
                (("00000110111101101", "000000011010101100101"),
                 ("00000000000000011", "000000000000000000011"),
                 ("00000000000011011", "000000000000000100111"));
                begin

                for i in patterns'range loop

                        entry <= patterns(i).entry;

                        wait for 1 ns;

                        assert outp = patterns(i).outp
                        report "Wrong BCD number." severity error;
                end loop;

                assert false report "End of test." severity note;
                wait;
        end process;
end calculate;

这是GTKWave的输出。你可以在这里看到，在运行带有大数字的代码之后，以下数字从结束前的数字开始。

（点击）

希望获得解决此问题的任何提示。

Answer 1

在VHDL中，variable在进程重新进入之间保留它的值。因此，当您输入数字X"000003"的流程时，所有变量仍然具有在X"003565"处理结束时添加的值。

快速测试表明，在流程开始时将place设置为1可以解决问题：

process(entry)
    variable outp_cp : std_logic_vector(20 downto 0) := (others => '0');
    variable place : integer := 1;
    variable digit : integer := 0;
    variable number : integer := 0;
begin
    place := 1;

    ...

Answer 2

您的问题出在bcd_mod的未标记过程中。您没有在每个新条目上将place初始化为1：

architecture calculate of bcd_mod is

begin
unlabeled:
    process(entry)
        variable outp_cp:  std_logic_vector(20 downto 0) := (others => '0');
        variable place:  integer := 1;
        variable digit:  integer := 0;
        variable number:  integer := 0;
    begin
        place := 1;   -- ADDED
        for i in 16 downto 0 loop

如果你查看二进制值，问题就变得很明显了，我在测试平台中使用了报告的数据：

architecture foo of bcd_mod_testbench is
    component bmt
        port (
            entry:  in  std_logic_vector(16 downto 0);
            outp:   out std_logic_vector(20 downto 0)
        );
    end component;
    for bmt_0: bmt use entity work.bcd_mod;
    signal entry:  std_logic_vector(16 downto 0);
    signal outp:   std_logic_vector(20 downto 0);

    function to_string(inp: std_logic_vector) return string is
        variable image_str: string (1 to inp'length);
        alias input_str:  std_logic_vector (1 to inp'length) is inp;
    begin
        for i in input_str'range loop
            image_str(i) := character'VALUE(std_ulogic'IMAGE(input_str(i)));
        end loop;
        return image_str;
    end;
 begin

bmt_0: 
    bmt 
        port map (
            entry => entry,
            outp => outp
        );

unlabeled:
    process
        type pattern_type is record
            entry:  std_logic_vector(16 downto 0);
            outp:  std_logic_vector(20 downto 0);
        end record;

        type pattern_array is array (natural range <>) of pattern_type;
        constant patterns:  pattern_array := (
             ("00000110111101101", "000000011010101100101"),
             ("00000000000000011", "000000000000000000011"),
             ("00000000000011011", "000000000000000100111")
        );
    begin
        for i in patterns'range loop
            entry <= patterns(i).entry;
            wait for 1 ns;
            assert outp = patterns(i).outp
            report "Wrong BCD number pattern (" & integer'image(i) & ")"
            severity error;
            report "entry = " & to_string(entry);
            report "outp = " & to_string(outp);
        end loop;
        assert false report "End of test." severity note;
        wait;
    end process;
end architecture;

给出了：

bcd_mod_tb.vhdl：119：13：@ 1ns :(报告单）：entry = 00000110111101101
  bcd_mod_tb.vhdl：120：13：@ 1ns :(报告单）：outp = 000000011010101100101
  bcd_mod_tb.vhdl：116：13：@ 2ns :(断言错误）：错误的BCD号码模式（1）
  bcd_mod_tb.vhdl：119：13：@ 2ns :(报告单）：entry = 00000000000000011
  bcd_mod_tb.vhdl：120：13：@ 2ns :(报告单）：outp = 000110000000000000000
  bcd_mod_tb.vhdl：116：13：@ 3ns :(断言错误）：错误的BCD号码模式（2）
  bcd_mod_tb.vhdl：119：13：@ 3ns :(报告单）：entry = 00000000000011011
  bcd_mod_tb.vhdl：120：13：@ 3ns :(报告单）：outp = 000100000000000000000
  bcd_mod_tb.vhdl：122：9：@ 3ns :(断言注释）：测试结束。

当地点初始化时，没有错误：

bcd_mod_tb.vhdl：119：13：@ 1ns :(报告单）：entry = 00000110111101101
  bcd_mod_tb.vhdl：120：13：@ 1ns :(报告单）：outp = 000000011010101100101
  bcd_mod_tb.vhdl：119：13：@ 2ns :(报告单）：entry = 00000000000000011
  bcd_mod_tb.vhdl：120：13：@ 2ns :(报告单）：outp = 000000000000000000011
  bcd_mod_tb.vhdl：119：13：@ 3ns :(报告单）：entry = 00000000000011011
  bcd_mod_tb.vhdl：120：13：@ 3ns :(报告单）：outp = 000000000000000100111
  bcd_mod_tb.vhdl：122：9：@ 3ns :(断言注释）：测试结束。

添加了to_string函数以支持符合'93标准的VHDL工具。

运行后重置输出

2 个答案: