首页 > 试题广场 >

4bit超前进位加法器电路

[编程题]4bit超前进位加法器电路
  • 热度指数：46494 时间限制：C/C++ 5秒，其他语言10秒 空间限制：C/C++ 256M，其他语言512M
  • 算法知识视频讲解

4bit超前进位加法器的逻辑表达式如下：

中间变量G_i=A_i B_i，<br />P_i=A_i⊕B_i

和：S_i=P_i⊕C_{i-1}，进位：

请用Verilog语言采用门级描述方式，实现此4bit超前进位加法器，接口电路如下：


输入描述:
输入信号：
A_in[3:0],
B_in[3:0]
C_1
类型：wire


输出描述:
输出信号：
S[3:0]
CO
类型：wire
算法知识视频讲解
查看答案及解析
添加回答
Verilog
牛客012345678910号头像 牛客012345678910号 
`timescale 1ns/1ns

module lca_4(
    input        [3:0]       A_in  ,
    input        [3:0]        B_in  ,
    input                   C_1   ,

     output     wire            CO    ,
    output   wire [3:0]        S
);
wire [3:0]G;
wire [3:0]P;
wire [2:0]C;

assign G = A_in & B_in;
assign P = A_in ^ B_in;
assign S = P ^ {C,C_1};
assign {CO,C} = G | (P&{C,C_1});
endmodule

直接把公式翻译就可以了

发表于 2023-02-20 22:58:50 回复(3)
牛客56870799号头像 牛客56870799号
assign {CO,S} = A_in + B_in + C_1;
发表于 2022-04-13 11:08:25 回复(1)
牛客665038609号头像 牛客665038609号 
`timescale 1ns/1ns

module lca_4(
	input		[3:0]       A_in  ,
	input	    [3:0]		B_in  ,
    input                   C_1   ,
 
 	output	 wire			CO    ,
	output   wire [3:0]	    S
);
    and ad0(ad0_o,A_in[0],B_in[0]),
        ad1(ad1_o, A_in[1],B_in[1]),
        ad2(ad2_o, A_in[2],B_in[2]),
        ad3(ad3_o, A_in[3],B_in[3]),
        ad4(ad4_o, xr0_o,C_1),
        ad5(ad5_o,C0,xr1_o),
        ad6(ad6_o,C1,xr2_o),
        ad7(ad7_o,C2,xr3_o);
    
    xor xr0(xr0_o,A_in[0],B_in[0]),
        xr1(xr1_o,A_in[1],B_in[1]),
        xr2(xr2_o,A_in[2],B_in[2]),
        xr3(xr3_o,A_in[3],B_in[3]),
        xr4(S[0],xr0_o,C_1),
        xr5(S[1],xr1_o,C0),
        xr6(S[2],xr2_o,C1),
        xr7(S[3],xr3_o,C2);
    
   &nbs***bsp; or0(C0,ad0_o,ad4_o),
        or1(C1,ad1_o,ad5_o),
        or2(C2,ad2_o,ad6_o),
        or3(C3,ad3_o,ad7_o);
    assign CO = C3;
endmodule

发表于 2022-09-07 21:49:52 回复(0)
Verilog
牛客380217871号头像 牛客380217871号
知识点：
    1、逻辑式化简
        S = P ^ C = A ^ B ^ C = ABC + ~A~BC + ~AB~C + A~B~C
        Co = G + PC = AB + (A ^ B)C = AB + ~ABC + A~BC
    2、卡若图化简   
C\AB 00 01 11 10
0

1
1
1 1 1
     将Co利用卡若图化简：Co = AB + BC + AC

综上所述，单bit超前进位加法器代码如下： 
module full_add (
    input    a,
    input    b,
    input    c,
    
    output    s,
    output    co
);
    
assign s = (a & b & c) | (~a & ~b & c) | (~a & b & ~c) | (a & ~b & ~c);
assign co = (a & b) | (a & c) | (b &c);

endmodule
总结，4bit超前进位加法只需要将单bit加法器级联即可实现。 
module lca_4(
	input		[3:0]       A_in  ,
	input	    [3:0]		B_in  ,
    input                   C_1   ,
 
 	output	 wire			CO    ,
	output   wire [3:0]	    S
);

wire [3:0] C;
full_add u_add0(
    .a  (A_in[0]),
    .b  (B_in[0]),
    .c  (C_1    ),
    .s  (S[0]   ),
    .co (C[0]   )
);   

full_add u_add1(
    .a  (A_in[1]),
    .b  (B_in[1]),
    .c  (C[0]   ),
    .s  (S[1]   ),
    .co (C[1]   )
);
    
full_add u_add2(
    .a  (A_in[2]),
    .b  (B_in[2]),
    .c  (C[1]   ),
    .s  (S[2]   ),
    .co (C[2]   )
);
    
full_add u_add3(
    .a  (A_in[3]),
    .b  (B_in[3]),
    .c  (C[2]   ),
    .s  (S[3]   ),
    .co (C[3]   )
);

assign CO = C[3];    
endmodule












发表于 2022-05-30 21:38:49 回复(3)
Verilog
Jensen_1235头像 Jensen_1235 
`timescale 1ns/1ns

module lca_4(
	input		[3:0]       A_in  ,
	input	    [3:0]		B_in  ,
    input                   C_1   ,
 
 	output	 wire			CO    ,
	output   wire [3:0]	    S
);
    wire P0,P1,P2,P3;
	wire G0,G1,G2,G3;
	wire C0,C1,C2,C3;
	wire P0C_1,P1G0,P1P0C_1,P2G1,P2P1G0,P2P1P0C_1,P3G2,P3P2G1,P3P2P1G0,P3P2P1P0C_1;

	xor xor0(P0,A_in[0],B_in[0]),
		xor1(P1,A_in[1],B_in[1]),
		xor2(P2,A_in[2],B_in[2]),
		xor3(P3,A_in[3],B_in[3]),
		xor4(S[0],P0,C_1),
		xor5(S[1],P1,C0),
		xor6(S[2],P2,C1),
		xor7(S[3],P3,C2);

	and and0(G0,A_in[0],B_in[0]),
		and1(G1,A_in[1],B_in[1]),
		and2(G2,A_in[2],B_in[2]),
		and3(G3,A_in[3],B_in[3]),
		and4(P0C_1,P0,C_1),
		and5(P1G0,P1,G0),
		and6(P1P0C_1,P1,P0,C_1),
		and7(P2G1,P2,G1),
		and8(P2P1G0,P2,P1,G0),
		and9(P2P1P0C_1,P2,P1,P0,C_1),
		and10(P3G2,P3,G2),
		and11(P3P2G1,P3,P2,G1),
		and12(P3P2P1G0,P3,P2,P1,G0),
		and13(P3P2P1P0C_1,P3,P2,P1,P0,C_1);

	or or0(C0,G0,P0C_1),
	   or1(C1,G1,P1G0,P1P0C_1),
	   or2(C2,G2,P2G1,P2P1G0,P2P1P0C_1),
	   or3(C3,G3,P3G2,P3P2G1,P3P2P1G0,P3P2P1P0C_1);

	assign CO = C3;

endmodule

发表于 2023-10-31 20:44:23 回复(0)
牛友7452666985985头像 牛友7452666985985 
`timescale 1ns/1ns

module lca_4(
	input		[3:0]       A_in  ,
	input	    [3:0]		B_in  ,
    input                   C_1   ,
 
 	output	 wire			CO    ,
	output   wire [3:0]	    S
);
    wire [3:0] g;
	wire [3:0] p;
	wire [3:0] c_o;

assign CO = c_o[3];

generate
	genvar i;
	for(i=0; i<4; i=i+1) begin: cl_adder
		assign g[i] = A_in[i] & B_in[i];
		assign p[i] = A_in[i] ^ B_in[i];
		if(i==0) begin
			assign S[i] = p[i] ^ C_1;
			assign c_o[i] = g[i] | p[i] & C_1;
		end
		else begin
			assign S[i] = p[i] ^ c_o[i-1];
			assign c_o[i] = g[i] | p[i] & c_o[i-1];
		end
	end
endgenerate

endmodule

发表于 2022-11-16 11:09:38 回复(0)
牛客336825462号头像 牛客336825462号 
`timescale 1ns/1ns

module lca_4(
	input		[3:0]       A_in  ,
	input	    [3:0]		B_in  ,
    input                   C_1   ,
 
 	output	 wire			CO    ,
	output   wire [3:0]	    S
);
	wire [4:0] C;//每一位上获得的前一时刻的进位
	assign C[0] = C_1;
    genvar i;
	generate
		for (i = 0;i<4;i=i+1) begin:process_1
		assign S[i] = A_in[i] ^ B_in[i] ^ C[i];
		assign C[i+1] = (A_in[i] & B_in[i]) || ((A_in[i] ^ B_in[i]) & C[i]);
		end
	endgenerate
	
	assign CO = C[4];

endmodule

编辑于 2023-12-06 16:32:11 回复(1)
Verilog
寻摸蓝色的天空头像 寻摸蓝色的天空

题解：

门级描述

笔者理解为使用逻辑门实现，即例化门级原语（and / or / not / xor 等）

超前进位：

首先想到单bit迭代，即行波进位，尝试后通过案例，并分析发现此法所需的逻辑门延时很长。
令n=串联单bit全加器的数目，则：
计算CO的门延时为2n+1，本案例采用4级串行，共需要需要9级门；
计算S各级bit的门延时为2n，即本例bit从0到3所需门延时分别为2、4、6、8。

然后根据题目，决定采用超前进位。即在理解行波进位的基础上，代入消除中间变量，将各级C和S都用初始输入表示。公式太复杂，图解太复杂，因此并未画出。此时，可发现：
计算各级C都统一需要3级
计算S需要在得到C的基础上再异或一次，共需要4级。


参考代码： 

`timescale 1ns/1ns

module lca_4(
	input		[3:0]       A_in  ,
	input	    [3:0]		B_in  ,
    input                   C_1   ,
 
 	output	 wire			CO    ,
	output   wire [3:0]	    S
);
// 法一：超前进位
// 第1级：异或门
wire	q0,q1,q2,q3;
xor	my_xor0(q0,A_in[0],B_in[0]);
xor	my_xor1(q1,A_in[1],B_in[1]);
xor	my_xor2(q2,A_in[2],B_in[2]);
xor	my_xor3(q3,A_in[3],B_in[3]);


// 第2级：与门
wire	a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13;
and	my_and0(a0,A_in[0],B_in[0]);
and	my_and1(a1,C_1,q0);

and	my_and2(a2,A_in[1],B_in[1]);
and	my_and3(a3,A_in[0],B_in[0],q1);
and	my_and4(a4,C_1,q0,q1);

and	my_and5(a5,A_in[2],B_in[2]);
and	my_and6(a6,A_in[1],B_in[1],q2);
and	my_and7(a7,A_in[0],B_in[0],q1,q2);
and	my_and8(a8,C_1,q0,q1,q2);

and	my_and9 (a9, A_in[3],B_in[3]);
and	my_and10(a10,A_in[2],B_in[2],q3);
and	my_and11(a11,A_in[1],B_in[1],q2,q3);
and	my_and12(a12,A_in[0],B_in[0],q1,q2,q3);
and	my_and13(a13,C_1,q0,q1,q2,q3);

// 第3级：或门 —— 得到Cout
wire	C0,C1,C2;
or	my_or0 (C0,a0,a1);
or	my_or1 (C1,a2,a3,a4);
or	my_or2 (C2,a5,a6,a7,a8);
or	my_or3 (CO,a9,a10,a11,a12,a13);

// 第4级：异或门 —— 得到S[3:0]
xor	my_xor4(S[0],q0,C_1);
xor	my_xor5(S[1],q1,C0);
xor	my_xor6(S[2],q2,C1);
xor	my_xor7(S[3],q3,C2);



// // 法二：行波进位
// wire	C_2,C_3,C_4;
// lca_1	my_lca1(A_in[0],B_in[0],C_1,C_2,S[0]);
// lca_1	my_lca2(A_in[1],B_in[1],C_2,C_3,S[1]);
// lca_1	my_lca3(A_in[2],B_in[2],C_3,C_4,S[2]);
// lca_1	my_lca4(A_in[3],B_in[3],C_4,CO ,S[3]);

// endmodule

// module lca_1(
// 	input		A_in  ,
// 	input		B_in  ,
//     input		C_1   ,
 
//  	output	wire	CO  ,
// 	output	wire	S
// );

// wire	G,P,Q;
// xor		my_xor1(P,A_in,B_in);
// xor		my_xor2(S,P,C_1);
// and		my_and1(G,A_in,B_in);
// and		my_and2(Q,P,C_1);
// or		my_or1(CO,G,Q);

endmodule


发表于 2023-04-02 13:52:32 回复(0)
Verilog
牛侠客头像 牛侠客 
`timescale 1ns/1ns

module lca_4(
    input       [3:0]   A_in,
    input       [3:0]   B_in,
    input               C_1,

    output wire         CO,
    output wire [3:0]   S
);
    wire [4-1: 0]        g;
    wire [4-1: 0]        p;
    wire [4-1:-1]        c;
    wire [4-1: 0]        s;

    assign g = A_in & B_in;
    assign p = A_in ^ B_in;
    assign c[-1] = C_1;
    assign c[3:0] = g | p & c[2:-1];
    assign s = p ^ c[2:-1];

    // Output Logic
    assign CO = c[3];
    assign S = s;
endmodule

发表于 2023-01-24 16:37:04 回复(0)
Verilog
PinkFloyd1007头像 PinkFloyd1007
`timescale 1ns/1ns

/*
4位***：

  0 1 1 0
 +1 0 0 1
 ——————————
  1 1 1 1

*/

module lca_4(
    
    input       [N-1:0]       A_in  ,
    input       [N-1:0]     B_in  ,
    input                   C_1   ,
 
    output   wire           CO    ,
    output   wire [N-1:0]       S
    
);
parameter N=4;//数据长度为4，4位超前进位加法器
wire[N-1:0] C;

genvar i;
generate 
    for(i=0;i<N;i=i+1)
    begin:zyl1
        if(!i)begin
            assign S[i]=(A_in[i]^B_in[i])^C_1;
            assign C[i]=(A_in[i]&B_in[i])|((A_in[i]^B_in[i])&C_1);
        end
        else begin
            assign S[i]=(A_in[i]^B_in[i])^C[i-1];
            assign C[i]=(A_in[i]&B_in[i])|((A_in[i]^B_in[i])&C[i-1]);
        end     
    end
endgenerate
assign CO=C[N-1];
endmodule
发表于 2022-09-17 00:17:36 回复(0)
Verilog
JoeGreat头像 JoeGreat 
`timescale 1ns/1ns

module lca_4(
	input		[3:0]       A_in  ,
	input	    [3:0]		B_in  ,
    input                   C_1   ,
 
 	output	 wire			CO    ,
	output   wire [3:0]	    S
);
    wire [2:0]CO_temp;
    
    lca_1 lca_1_U1(
        .A_in(A_in[0]),
        .B_in(B_in[0]),
        .C_in(C_1),
        .CO(CO_temp[0]),
        .S(S[0])
    );
    
    lca_1 lca_1_U2(
        .A_in(A_in[1]),
        .B_in(B_in[1]),
        .C_in(CO_temp[0]),
        .CO(CO_temp[1]),
        .S(S[1])
    );
    
    lca_1 lca_1_U3(
        .A_in(A_in[2]),
        .B_in(B_in[2]),
        .C_in(CO_temp[1]),
        .CO(CO_temp[2]),
        .S(S[2])
    );
    
    lca_1 lca_1_U4(
        .A_in(A_in[3]),
        .B_in(B_in[3]),
        .C_in(CO_temp[2]),
        .CO(CO),
        .S(S[3])
    );
    
endmodule

module lca_1(
    input             A_in,
    input             B_in,
    input             C_in,
    
    output            CO,
    output            S
);
    wire G;
    wire P;
    
    assign G = A_in & B_in;
    assign P = A_in ^ B_in;
    
    assign S = P ^ C_in;
    assign CO = G | (P & C_in);
    
endmodule

发表于 2022-05-25 11:05:29 回复(1)
Verilog
Zagret头像 Zagret 
`timescale 1ns/1ns

module lca_4(
	input		[3:0]       A_in  ,
	input	    [3:0]		B_in  ,
    input                   C_1   ,
 
 	output	 wire			CO    ,
	output   wire [3:0]	    S
);
    wire [3:0] G , P  , C , PC;
	and and0 (G[0],A_in[0],B_in[0]),
		and1 (G[1],A_in[1],B_in[1]),
		and2 (G[2],A_in[2],B_in[2]),
		and3 (G[3],A_in[3],B_in[3]);

	xor xor0 (P[0],A_in[0],B_in[0]),
		xor1 (P[1],A_in[1],B_in[1]),
		xor2 (P[2],A_in[2],B_in[2]),
		xor3 (P[3],A_in[3],B_in[3]);

	and and4 (PC[0],P[0],C_1),
		and5 (PC[1],P[1],C[0]),
		and6 (PC[2],P[2],C[1]),
		and7 (PC[3],P[3],C[2]);

	or  or0 (C[0],G[0],PC[0]),
		or0 (C[1],G[1],PC[1]),
		or0 (C[2],G[2],PC[2]),
		or0 (CO,G[3],PC[3]);

	xor xor4 (S[0],P[0],C_1),
		xor5 (S[1],P[1],C[0]),
		xor6 (S[2],P[2],C[1]),
		xor7 (S[3],P[3],C[2]);

endmodule
题目要求用门级电路，起码给出了式子而且不太复杂，比上一题人性化多了
发表于 2025-07-12 11:38:58 回复(0)
青C第一🌸孝子头像 青C第一🌸孝子 
`timescale 1ns/1ns

module lca_4(
	input		[3:0]       A_in  ,
	input	    [3:0]		B_in  ,
    input                   C_1   ,
 
 	output	 wire			CO    ,
	output   wire [3:0]	    S
);
    wire g1,g2,g3,g4;
	wire p1,p2,p3,p4;
	wire c1,c2,c3,c4;
	
	assign g1=A_in[0]&B_in[0];
	assign g2=A_in[1]&B_in[1];
	assign g3=A_in[2]&B_in[2];
	assign g4=A_in[3]&B_in[3];
	assign p1=A_in[0]^B_in[0];
	assign p2=A_in[1]^B_in[1];
	assign p3=A_in[2]^B_in[2];
	assign p4=A_in[3]^B_in[3];

    assign c1=g1|(p1&C_1);
	assign c2=g2|(p2&(g1|(p1&C_1)));
	assign c3=g3|(p3&(g2|(p2&(g1|(p1&C_1)))));
	assign CO=g4|(p4&g3|(p3&(g2|(p2&(g1|(p1&C_1))))));
	assign  S[0]=p1^C_1;
	assign  S[1]=p2^(g1|(p1&C_1));
	assign  S[2]=p3^(g2|(p2&(g1|(p1&C_1))));
	assign  S[3]=p4^(g3|(p3&(g3|(p3&(g2|(p2&(g1|(p1&C_1))))))));

endmodule

发表于 2025-04-04 21:16:48 回复(0)
Estrella316头像 Estrella316 
`timescale 1ns/1ns

module lca_4(
	input		[3:0]       A_in  ,
	input	    [3:0]		B_in  ,
    input                   C_1   ,
 
 	output	 wire			CO    ,
	output   wire [3:0]	    S
);

wire c0, c1, c2;
wire g0, g1, g2, g3;
wire p0, p1, p2, p3;
wire pc0, pc1, pc2, pc3;


and g0(g0, A_in[0], B_in[0]),
	g1(g1, A_in[1], B_in[1]),
	g2(g2, A_in[2], B_in[2]),
	g3(g3, A_in[3], B_in[3]);


xor p0(p0, A_in[0], B_in[0]),
	p1(p1, A_in[1], B_in[1]),
	p2(p2, A_in[2], B_in[2]),
	p3(p3, A_in[3], B_in[3]);

and pc0(pc0, p0, C_1),
	pc1(pc1, p1, c0),
	pc2(pc2, p2, c1),
	pc3(pc3, p3, c2);

//C out
or	c0(c0, g0, pc0),
	c1(c1, g1, pc1),
	c2(c2, g2, pc2),
	c3(CO, g3, pc3);


//S out
xor	s0(S[0], p0, C_1),
	s1(S[1], p1, c0),
	s2(S[2], p2, c1),
	s3(S[3], p3, c2);


endmodule
照着公式无脑写
发表于 2025-02-28 15:45:54 回复(0)
cckom头像 cckom
`timescale 1ns/1ns

module testbench();
reg[3:0] A_in,B_in;
reg C_1;
wire CO;
wire[3:0] S;

initial begin
    $dumpfile("out.vcd");
    $dumpvars(0,testbench);

end
initial begin
    A_in ='d0;
    B_in='d0;
    C_1=1'b0;
    #2
    A_in ='d4;
    B_in='d5;
    C_1=1'b0;
        #2
    A_in ='d2;
    B_in='d3;
    C_1=1'b1;
        #2
    A_in ='d2;
    B_in='d3;
    C_1=1'b0;
        #2
    A_in ='d15;
    B_in='d2;
    C_1=1'b0;
    #2
    $finish;

end

lca_4 dut(
    .A_in(A_in),
    .B_in(B_in),
    .C_1(C_1),
    .CO(CO),
    .S(S)
);
endmodule
发表于 2025-01-13 13:52:25 回复(0)
牛客525176850号头像 牛客525176850号
请问一下我这个错在哪里了呢？谢谢大家
`timescale 1ns/1ns

module lca_4(
    input       [3:0]       A_in  ,
    input       [3:0]       B_in  ,
    input                   C_1   ,
 
    output   wire           CO    ,
    output   wire [3:0]     S
);

wire [3:0] g, p, c, s;
genvar i;
generate
    for(i  = 0; i <= 3 ; i = i + 1) begin
        assign g[i] = A_in[i] & B_in[i];
        assign p[i] = A_in[i] ^ B_in[i];
        if(i == 0) begin
            assign s[i] = p[i] ^ C_1;
            assign c[i] = g[i] + p[i] & C_1;
        end
        else begin
            assign c[i] = g[i] + p[i] & c[i - 1];
            assign s[i] = p[i] ^ c[i - 1];
        end
    end
endgenerate

assign CO = c[3];
assign S = s;
endmodule


发表于 2024-06-25 16:32:06 回复(0)
宸熙头像 宸熙
`timescale 1ns/1ns

module lca_4(
    input       [3:0]       A_in  ,
    input       [3:0]       B_in  ,
    input                   C_1   ,
 
    output   wire           CO    ,
    output   wire [3:0]     S
);

wire [3:0] p,g;

wire [4:0]C;

assign C[0]=C_1;

assign p=A_in|B_in;

assign g=A_in&B_in;

assign C[1]=g[0]|(p[0]&C[0]);

assign C[2]=g[1]|(p[1]&C[1]);

assign C[3]=g[2]|(p[2]&C[2]);

assign C[4]=g[3]|(p[3]&C[3]);

assign CO=C[4];

assign S=A_in^B_in^C[3:0];

endmodule
发表于 2024-06-16 16:16:15 回复(0)
dafeilang头像 dafeilang
`timescale 1ns/1ns

module lca_4(
    input       [3:0]       A_in  ,
    input       [3:0]       B_in  ,
    input                   C_1   ,
 
    output   wire           CO    ,
    output   wire [3:0]     S
);

wire [3:0] G;
wire [3:0] P;

wire [3:0] C;

genvar i;
generate
for( i =0; i < 4; i = i +1)
begin : gen_
    assign G[i] = A_in[i] * B_in[i];
    assign P[i] = A_in[i] ^ B_in[i];
end
endgenerate

assign S[0] = P[0] ^ C_1;
assign C[0] = G[0] + P[0]*C_1;
generate
for( i =1; i < 4; i = i +1)
begin : gen_2
    assign C[i] = G[i] + P[i] * C[i-1];
    assign S[i] = P[i] ^ C[i-1];
end

assign CO = C[3];

endgenerate

   
endmodule
编辑于 2024-04-25 14:38:58 回复(0)
tyhj796头像 tyhj796
题目里，进位项的逻辑表达式是错的，正确的表达式如图所示

发表于 2024-02-26 00:10:05 回复(0)
Verilog
加油cccccc头像 加油cccccc
`timescale 1ns/1ns

module lca_4(
    input       [3:0]       A_in  ,
    input       [3:0]       B_in  ,
    input                   C_1   ,
 
    output   wire           CO    ,
    output   wire [3:0]     S
);
    wire c1,c2,c3;
    wire cout1, cout2, cout3;
    wire [3:0] g, p;
   
    // 算出 G 和 P
    and a1 (g[0], A_in[0], B_in[0]);
    xor x1 (p[0], A_in[0], B_in[0]);

    and a2 (g[1], A_in[1], B_in[1]);
    xor x2 (p[1], A_in[1], B_in[1]);
   
    and a3 (g[2], A_in[2], B_in[2]);
    xor x3 (p[2], A_in[2], B_in[2]);
   
    and a4 (g[3], A_in[3], B_in[3]);
    xor x4 (p[3], A_in[3], B_in[3]);
   
    // 算出Cout(本级) = G(本级) + P(本级) * Cout(上一级)
    and a5 (c1, p[0], C_1);
  &nbs***bsp;o1 (cout1, g[0], c1);

    and a6 (c2, p[1], cout1);
  &nbs***bsp;o2 (cout2, g[1], c2);

    and a7 (c3, p[2], cout2);
  &nbs***bsp;o3 (cout3, g[2], c3);

    and a8 (c4, p[3], cout3);
  &nbs***bsp;o4 (CO, g[3], c4);

    // 算出S
    xor x5 (S[0], p[0], C_1);
    xor x6 (S[1], p[1], cout1);
    xor x7 (S[2], p[2], cout2);
    xor x8 (S[3], p[3], cout3);

endmodule
发表于 2024-01-30 06:32:43 回复(0)
提交观点

问题信息

难度：
56条回答 2337浏览

热门推荐

通过挑战的用户

查看代码

相关试题

4bit超前进位加法器电路

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号