N位加法器/减法器VHDL

你好我试图实现一个N位加法器/ VHDL减法器，但我没有得到它的正常工作，出于某种原因，我似乎无法找到什么问题是..N位加法器/减法器VHDL

该加法器正在工作，因为它应该但减法器不是，我真的不能看到问题是什么，因为我检查了表达式，它是正确的，但是当我模拟它似乎是减法部分不工作...

下面是我的实现与溢出检测和饱和度控制：

LIBRARY IEEE; 
USE IEEE.STD_LOGIC_1164.ALL; 

entity ripple_adder_subtracter_saturate is 
    generic (WIDTH : INTEGER := 8); 
    port (a : IN STD_LOGIC_VECTOR(WIDTH-1 downto 0); 
      b : IN STD_LOGIC_VECTOR(WIDTH-1 downto 0); 
      cin : IN STD_LOGIC := '0'; 
      saturate : IN STD_LOGIC := '0'; 
      add_sub : IN STD_LOGIC := '1'; 
      y : OUT STD_LOGIC_VECTOR(WIDTH-1 downto 0); 
      cout : OUT STD_LOGIC; 
      overflow : OUT STD_LOGIC); 
    end ripple_adder_subtracter_saturate; 

ARCHITECTURE behavior OF ripple_adder_subtracter_saturate is 

component bitAdder is 
port(a : IN STD_LOGIC; 
     b : IN STD_LOGIC; 
     cin : IN STD_LOGIC; 
     add_sub : IN STD_LOGIC; 
     y : OUT STD_LOGIC; 
    cout : OUT STD_LOGIC); 
end component; 

signal carry : STD_LOGIC_VECTOR (WIDTH-1 downto 0); -- hold the carry outs from the adders 
signal temp_sum : STD_LOGIC_VECTOR (WIDTH-1 downto 0); 
signal o_flow : STD_LOGIC;        -- internal overflow signal so I can read it in the process 

begin 
cell_0: bitAdder port map(a(0), b(0), cin, add_sub, temp_sum(0), carry(0)); 
G: FOR i IN 1 TO WIDTH-1 GENERATE 
    cell_i: bitAdder port map(a(i), b(i), carry(i-1), add_sub, temp_sum(i), carry(i)); 
    end GENERATE; 

    o_flow <= carry(WIDTH-1) XOR carry(WIDTH-2); 
    overflow <= o_flow; 
    cout <= carry(WIDTH-1); 

    process(saturate, temp_sum, carry, o_flow) 
    begin 
     if (saturate = '1' AND o_flow = '1') then 
      if (carry(WIDTH-1) = '0') then 
       y <= (WIDTH-1 => '0', others => '1'); 
      else 
       y <= (WIDTH-1 => '1', others => '0'); 
      end if; 
     else 
      y <= temp_sum; 
     end if; 
    end process; 
end behavior;

当信号add_sub = 0，应该减去时，它的1它应该做的additon等。这是怎么全加法/减法的样子：

LIBRARY ieee; 
USE ieee.std_logic_1164.ALL; 

ENTITY bitAdder IS 
    PORT (a: IN STD_LOGIC; 
     b: IN STD_LOGIC; 
     cin: IN STD_LOGIC; 
     add_sub : IN STD_LOGIC; 
     y: OUT STD_LOGIC; 
     cout: OUT STD_LOGIC); 
END bitAdder; 

ARCHITECTURE behavior OF bitAdder IS 
signal b_sub : STD_LOGIC := '1'; 
BEGIN 
    process(a, b, cin, add_sub) 
    begin 
     if (add_sub = '0') then 
      b_sub <= (not b); 
      y <= (a XOR b_sub) XOR cin; 
      cout <= (a AND b_sub) OR (b_sub AND cin) OR (a AND cin); 
     else 
      y <= (a XOR b) XOR cin; 
      cout <= (a AND b) OR (b AND cin) or (a AND cin); 
     end if; 
    end process; 
END behavior;

你能看到什么，我可能已经做错了？现在我已经甩了几个小时，没有任何成功。所以任何类型的指针都会有所帮助！

这里的，它应该通过测试平台：

----------------------------------- 
-- testbench type 3 for   -- 
-- ripple carry adder/subtracter -- 
-- with overflow signal   -- 
-- and saturation logic   -- 
-- for generic vector   -- 
----------------------------------- 

LIBRARY ieee; 
USE ieee.std_logic_1164.ALL; 
USE ieee.numeric_std.ALL; 

ENTITY ripple_adder_subtracter_saturate_tb3 IS 
    GENERIC (WIDTH:INTEGER:=8); 
    PORT(test_OK:OUT STD_LOGIC); 
END ripple_adder_subtracter_saturate_tb3; 

ARCHITECTURE arch_ripple_adder_subtracter_saturate_tb3 OF 
         ripple_adder_subtracter_saturate_tb3 IS 

    COMPONENT ripple_adder_subtracter_saturate IS 
     GENERIC (WIDTH:INTEGER:=8); 
     PORT(a:IN STD_LOGIC_VECTOR(WIDTH-1 DOWNTO 0); 
      b:IN STD_LOGIC_VECTOR(WIDTH-1 DOWNTO 0); 
      add_sub:IN STD_LOGIC; 
      saturate:IN STD_LOGIC; 
      y:OUT STD_LOGIC_VECTOR(WIDTH-1 DOWNTO 0); 
      overflow:OUT STD_LOGIC); 
    END COMPONENT ripple_adder_subtracter_saturate; 

    SIGNAL a_tb_signal:STD_LOGIC_VECTOR(WIDTH-1 DOWNTO 0); 
    SIGNAL b_tb_signal:STD_LOGIC_VECTOR(WIDTH-1 DOWNTO 0); 
    SIGNAL y_tb_signal:STD_LOGIC_VECTOR(WIDTH-1 DOWNTO 0); 
    SIGNAL add_sub_tb_signal:STD_LOGIC; 
    SIGNAL saturate_tb_signal:STD_LOGIC; 
    SIGNAL overflow_tb_signal:STD_LOGIC; 
BEGIN 
    ripple_adder_subtracter_saturate_comp: 
    COMPONENT ripple_adder_subtracter_saturate 
     PORT MAP(a=>a_tb_signal, 
        b=>b_tb_signal, 
        add_sub=>add_sub_tb_signal, 
        saturate=>saturate_tb_signal, 
        y=>y_tb_signal, 
        overflow=>overflow_tb_signal); 

    saturate_tb_signal<='0',    -- overflow 
       '1' AFTER 1400 ns; -- saturate 
    add_sub_tb_signal<='1',    -- add 
       '0' AFTER 700 ns, -- sub 
       '1' AFTER 1400 ns, -- add 
       '0' AFTER 2100 ns; -- sub 
    a_tb_signal<="00000000", -- 0 
     "01010101" AFTER 100 ns, -- 85 
     "11100101" AFTER 300 ns, -- -27 
     "00000000" AFTER 700 ns, -- 0 
     "01010101" AFTER 800 ns, -- 85 
     "11100101" AFTER 1000 ns, -- -27 
     "00000000" AFTER 1400 ns, -- 0 
     "01010101" AFTER 1500 ns, -- 85 
     "11100101" AFTER 1700 ns, -- -27 
     "00000000" AFTER 2100 ns, -- 0 
     "01010101" AFTER 2200 ns, -- 85 
     "11100101" AFTER 2400 ns; -- -27 

    b_tb_signal<="00000000", -- 0 
     "00011101" AFTER 100 ns, -- 29 
     "00111000" AFTER 200 ns, -- 56 
     "00000110" AFTER 400 ns, -- 6 
     "11001000" AFTER 500 ns, -- -56 
     "10010111" AFTER 600 ns, -- -105 
     "00000000" AFTER 700 ns, -- 0 
     "00011101" AFTER 800 ns, -- 29 
     "11001000" AFTER 900 ns, -- -56 
     "00111000" AFTER 1000 ns, -- 56 
     "00000110" AFTER 1100 ns, -- 6 
     "11001000" AFTER 1200 ns, -- -56 
     "01101001" AFTER 1300 ns, -- 105 
     "00000000" AFTER 1400 ns, -- 0 
     "00011101" AFTER 1500 ns, -- 29 
     "00111000" AFTER 1600 ns, -- 56 
     "00000110" AFTER 1800 ns, -- 6 
     "11001000" AFTER 1900 ns, -- -56 
     "10010111" AFTER 2000 ns, -- -105 
     "00000000" AFTER 2100 ns, -- 0 
     "00011101" AFTER 2200 ns, -- 29 
     "11001000" AFTER 2300 ns, -- -56 
     "00111000" AFTER 2400 ns, -- 56 
     "00000110" AFTER 2500 ns, -- 6 
     "11001000" AFTER 2600 ns, -- -56 
     "01101001" AFTER 2700 ns; -- 105 

test_proc: 
PROCESS 
    BEGIN 
--overflow 
--addition 
     WAIT FOR 50 ns; -- 50 ns 0+0=0 (00000000) 
     ASSERT (y_tb_signal="00000000") 
     REPORT "Error for 0+0=0=00000000" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when 0+0=0=00000000" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 150 ns 85+29=114 (01110010) 
     ASSERT (y_tb_signal="01110010") 
     REPORT "Error for 85+29=114=01110010" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when 85+29=114=01110010" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 250 ns 85+56=141->-115 (10001101) 
     ASSERT (y_tb_signal="10001101") 
     REPORT "Error for 85+56=141->-115=10001101" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='1') 
     REPORT "Error in overflow bit when 85+56=141->-115=10001101" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 350 ns -27+56=29 (00011101) 
     ASSERT (y_tb_signal="00011101") 
     REPORT "Error for -27+56=29=00011101" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when -27+56=29=00011101" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 450 ns -27+6=-21 (11101011) 
     ASSERT (y_tb_signal="11101011") 
     REPORT "Error for -27+6=-21=11101011" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when -27+6=-21=11101011" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 550 ns -27-56=-83 (10101101) 
     ASSERT (y_tb_signal="10101101") 
     REPORT "Error for -27-56=-83=10101101" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when -27-56=-83=10101101" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 650 ns -27-105=-132->124 (01111100) 
     ASSERT (y_tb_signal="01111100") 
     REPORT "Error for -27-105=-132->124=01111100" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='1') 
     REPORT "Error in overflow bit when -27-105=-132->124=01111100" 
     SEVERITY ERROR; 
--subtraction 
     WAIT FOR 100 ns; -- 750 ns 0-0=0 (00000000) 
     ASSERT (y_tb_signal="00000000") 
     REPORT "Error for 0-0=0=00000000" 
     SEVERITY ERROR;  
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when 0-0=0=00000000" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 850 ns 85-29=56 (00111000) 
     ASSERT (y_tb_signal="00111000") 
     REPORT "Error for 85-29=56=00111000" 
     SEVERITY ERROR;  
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when 85-29=56=00111000" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 950 ns 85-(-56)=141->-115 (10001101) 
     ASSERT (y_tb_signal="10001101") 
     REPORT "Error for 85-(-56)=141->-115=10001101" 
     SEVERITY ERROR;  
     ASSERT (overflow_tb_signal='1') 
     REPORT "Error in overflow bit when 85-(-56)=141->-115=10001101" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 1050 ns -27-56=-83 (10101101) 
     ASSERT (y_tb_signal="10101101") 
     REPORT "Error for -27-56=-83=10101101" 
     SEVERITY ERROR;  
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when -27-56=-83=10101101" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 1150 ns -27-6=-33 (11011111) 
     ASSERT (y_tb_signal="11011111") 
     REPORT "Error for -27-6=-33=11011111" 
     SEVERITY ERROR;  
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when -27-6=-33=11011111" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 1250 ns -27-(-56)=29 (00011101) 
     ASSERT (y_tb_signal="00011101") 
     REPORT "Error for -27-(-56)=29=00011101" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when -27-(-56)=29=00011101" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 1350 ns -27-105=-132->124 (01111100) 
     ASSERT (y_tb_signal="01111100") 
     REPORT "Error for -27-105=-132->124=01111100" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='1') 
     REPORT "Error in overflow bit when -27-105=-132->124=01111100" 
     SEVERITY ERROR; 
--saturate 
--addition 
     WAIT FOR 100 ns; -- 1450 ns 0+0=0 (00000000) 
     ASSERT (y_tb_signal="00000000") 
     REPORT "Error for 0+0=0=00000000" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when 0+0=0=00000000" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 1550 ns 85+29=114 (01110010) 
     ASSERT (y_tb_signal="01110010") 
     REPORT "Error for 85+29=114=01110010" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when 85+29=114=01110010" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 1650 ns 85+56=141->127 (01111111) 
     ASSERT (y_tb_signal="01111111") 
     REPORT "Error for 85+56=141->127=10001101" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='1') 
     REPORT "Error in overflow bit when 85+56=141->127=10001101" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 1750 ns -27+56=29 (00011101) 
     ASSERT (y_tb_signal="00011101") 
     REPORT "Error for -27+56=29=00011101" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when -27+56=29=00011101" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 1850 ns -27+6=-21 (11101011) 
     ASSERT (y_tb_signal="11101011") 
     REPORT "Error for -27+6=-21=11101011" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when -27+6=-21=11101011" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 1950 ns -27-56=-83 (10101101) 
     ASSERT (y_tb_signal="10101101") 
     REPORT "Error for -27-56=-83=10101101" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when -27-56=-83=10101101" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 2050 ns -27-105=-132->-128 (10000000) 
     ASSERT (y_tb_signal="10000000") 
     REPORT "Error for -27-105=-132->-128=01111100" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='1') 
     REPORT "Error in overflow bit when -27-105=-132->-127=10000000" 
     SEVERITY ERROR; 
--subtraction 
     WAIT FOR 100 ns; -- 2150 ns 0-0=0 (00000000) 
     ASSERT (y_tb_signal="00000000") 
     REPORT "Error for 0-0=0=00000000" 
     SEVERITY ERROR;  
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when 0-0=0=00000000" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 2250 ns 85-29=56 (00111000) 
     ASSERT (y_tb_signal="00111000") 
     REPORT "Error for 85-29=56=00111000" 
     SEVERITY ERROR;  
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when 85-29=56=00111000" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 2350 ns 85-(-56)=141->127 (01111111) 
     ASSERT (y_tb_signal="01111111") 
     REPORT "Error for 85-(-56)=141->127=01111111" 
     SEVERITY ERROR;  
     ASSERT (overflow_tb_signal='1') 
     REPORT "Error in overflow bit when 85-(-56)=141->127=01111111" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 2450 ns -27-56=-83 (10101101) 
     ASSERT (y_tb_signal="10101101") 
     REPORT "Error for -27-56=-83=10101101" 
     SEVERITY ERROR;  
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when -27-56=-83=10101101" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 2550 ns -27-6=-33 (11011111) 
     ASSERT (y_tb_signal="11011111") 
     REPORT "Error for -27-6=-33=11011111" 
     SEVERITY ERROR;  
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when -27-6=-33=11011111" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 2650 ns -27-(-56)=29 (00011101) 
     ASSERT (y_tb_signal="00011101") 
     REPORT "Error for -27-(-56)=29=00011101" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='0') 
     REPORT "Error in overflow bit when -27-(-56)=29=00011101" 
     SEVERITY ERROR; 

     WAIT FOR 100 ns; -- 2750 ns -27-105=-132->-128 (10000000) 
     ASSERT (y_tb_signal="10000000") 
     REPORT "Error for -27-105=-132->-128=10000000" 
     SEVERITY ERROR; 
     ASSERT (overflow_tb_signal='1') 
     REPORT "Error in overflow bit when -27-105=-132->-128=10000000" 
     SEVERITY ERROR; 
    END PROCESS test_proc; 
END arch_ripple_adder_subtracter_saturate_tb3;

而且。做文件：

-- ripple_adder_saturate_tb3.do 

restart -f -nowave 
view signals wave 
add wave saturate_tb_signal a_tb_signal b_tb_signal y_tb_signal 
add wave -radix signed a_tb_signal b_tb_signal y_tb_signal 
add wave -radix unsigned y_tb_signal 
add wave overflow_tb_signal 
run 1380ns

来源

2015-09-15 Pethead

没有模拟测试台，没有预期的输出，没有用于比较的实际输出。如果你有这些，你可能会看到从哪里开始寻找...... –

我有一个测试台和一个文件，想让我把它们发布在这里，我的波形是？我认为它会占用太多的东西，但我确定会发布它们。 – Pethead

当它开始测试减法部分时，它在750ns时失败，所以我认为它是全加器/减法器出错，但我找不到任何错误......所以它可能是我的nBitadder中的其他东西设计，但我似乎无法找到可能是什么，我一直在尝试一段时间，所以帮助将不胜感激。 – Pethead

不运行你的测试平台有出现错在未标记的加法几件事情处理。

冷杉，在bitAdder过程敏感性列表丢失b_sub，这将在b后有一个事件一个增量周期。您最终可能会在最后的b_sub值上运行，如果您想合成此值（b_sub未在其他字段中指定），则该值也具有推测的锁存器。

还要注意，add_sub有效地补充了顶层b，通过反转bitAdder b位。

通过添加顶层的补b需要通过在进完成了+ 1完成减法。若要保持使用您的顶层cin的能力，你可以简单地反转的cin值传递到cell_0时add_sub = '0'。这允许您链接宽度操作数的操作。

在ripple_adder_subtracter_saturate：

signal o_flow : STD_LOGIC;        -- internal overflow ... 

signal cin_add_sub: std_logic;       -- added 

begin 

    cin_add_sub <= not add_sub xor cin;    -- added

而在cell_0实例代替cin_add_sub为cin：

cell_0: bitAdder port map(a(0), b(0), cin_add_sub, add_sub, temp_sum(0), carry(0));

你可以在bitAdder添加一个单独的语句或过程反转b时add_sub = '0'，并消除其他在当前流程中的if语句中。

喜欢的东西：

architecture foo of bitAdder is 
    signal b_sig: std_logic; 
begin 
    b_sig <= not b when add_sub = '0' else 
        b;    -- b_sig <= not add_sub xor b; 
    y  <= a xor b_sig xor cin; 

    cout <= (a and b_sig) or 
       (b_sig and cin) or 
       (a and cin); 
end architecture;

同样，你可以整补作业移至设计顶尖水平。

我做了上述更改，并且您的设计没有产生任何断言违规。（只要你不让它运行的时间足够延长断言陈述的过程，就应该终止，例如wait 49 ns; wait;。额外的等待，所以你可以显示所有测试的波形或多或少一致。）

检查波形转储显示减法获得正确的值。我没有验证其余的断言。

来源

2015-09-16 01:28:29 user1155120

非常感谢您的帮助，并提供支持，现在就可以使用。我做了你所建议的改变，并且运行了模拟，但无法使其正常工作......所以在将我的头撞向墙的几个小时之后，我重新启动了模拟软件，它运行了... 再次感谢！ – Pethead

您的测试台没有设置为连续模拟，它应该完成，或者您应该从模拟时间0重新开始。 – user1155120

N位加法器/减法器VHDL

回答

相关问题