精华内容
下载资源
问答
  • 半加器实现全加器
    2022-03-07 09:41:43
    module fulladder(	input wire in_1,
    						input wire in_2,
    						input wire cin,   //进位
    						
    						output wire sum,
    						output wire count
        );
    wire hfsum1;
    wire hfcount1;
    wire hfcount2;
    halfadder  halfadder_inst1
    (    						.in_1(in_1),
    							.in_2(in_2),
    							.sum(hfsum1),
    							.count(hfcount1)
        );
    halfadder  halfadder_inst2
    (    						.in_1(cin),
    							.in_2(hfsum1),
    							.sum(sum),
    							.count(hfcount2)
        );
    assign count = hfcount1 | hfcount2;  //或运算
    
    endmodule

    半加器:

    module halfadder(    input wire in_1,
    							input wire in_2,
    							output wire sum,
    							output wire count
        );
    assign {count,sum} = in_1+in_2;
    
    
    endmodule
    module vtf_fulladder;
    
    	// Inputs
    	reg in_1;
    	reg in_2;
    	reg cin;
    
    	// Outputs
    	wire sum;
    	wire count;
    
    	// Instantiate the Unit Under Test (UUT)
    	fulladder uut (
    		.in_1(in_1), 
    		.in_2(in_2), 
    		.cin(cin), 
    		.sum(sum), 
    		.count(count)
    	);
    
    	initial begin
    		// Initialize Inputs
    		in_1 = 0;
    		in_2 = 0;
    		cin = 0;
    
    		// Wait 100 ns for global reset to finish
    		#100;
    
            
    		// Add stimulus here
    
    	end
    	
    		always #10 in_1<= {$random} %2;  //取随机数对2求余(0或者1) 
    		always #10 in_2<= {$random} %2;
    		always #10 cin <= {$random} %2;
          
    endmodule

    更多相关内容
  • 用门电路实现两个二进数相加并求出和的组合线路,称为一个全加器。
  • 本文主要讲了半加器和全加器的真值表,一起来学习一下
  • 本文主要讲了半加器和全加器的区别是什么,下面一起来学习一下
  • 组合逻辑电路分析,使用基本门电路组成全加器,半加器,Multisim仿真。以及使用逻辑转换器分析电路的最简表达式。
  • 实验设计:利用半加器计算8位原码求补码的电路图,请用logisim.exe打开,欢迎下载。
  • 半加器的代码,以及ucf文件,仿真已过,可在basys2上运行
  • QuartusII13.1 详细开发步骤(半加器为例)(FPGA) 最近在学FPGA,用的是Quartus II 13.1的版本,仿真工具是ModelSim,之前看着视频做了一遍,但是详细的步骤还是有些记得不太清了,就写个博客记录一下吧,也方便...
  • Simulink_半加器.zip

    2020-07-07 03:25:43
    用Simulink仿真半加器,用了两种实现方法,一种是逻辑门构建子系统搭建,另一种是编写用S函数。输入用了两个方波信号,输出在四通道示波器中显示,分别为加数A,加数B,和数S,进位C。
  • 综述:使用Verilog编写的由半加器构成的16位全加器。 该16位的全加器采用结构化设计,由4个4位的全加器构成;4位全加器由4个1位的全加器构成;1位全加器由2个半加器和1个与门构成。 上述文件包含所有的源代码。 以上...
  • 半加器 全加器 16bit全加器
  • 半加器是三值光计算机设计中的重要器件,需要尽量设计至最优。通过“剔除光电转换器”有效地简化了半加器结构。该项化简依靠统一设计编码器和半加器来实现,使半加器简化成类似两个液晶阵列和两层偏振片的的叠放。该...
  • proteus半加器逻辑仿真电路
  • 本文主要讲了一下关于半加器和全加器的作用,下面一起来看看
  • half adder半加器的VHDL代码文件和原理图文件
  • 自顶向下式设计。 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  • 半加器全加器的工作原理和设计方法实验报告.doc
  • 通过本实验掌握半加器和全加器的设计与实现方法,能够使用半加器或全加器设计并实现多位二进制加法运算。
  • 半加器的代码

    2013-11-13 15:02:32
    半加器的模拟,代码txt,上传使用,使用matlab。
  • 半加器设计

    2015-06-10 18:53:05
    了解和学习Quartus II 5.1软件设计平台。了解EDA的设计过程。通过实例,学习和掌握Quartus II 5.1平台下的图形输入法,学习和掌握半加器的工作和设计原理。
  • 模拟测试文件没有上传,可以自己设计,当然这么简单又粗糙的东西不会有人要啦,但是划个水还是没啥问题的
  • 这里面有QuartusII的半加器、1位全加器、4位全加器、4位加减法器的工程文件、原理图、仿真图等,这是我大一的时候做的,能正常运行,如有错误,敬请谅解。
  • 半加器与全加器

    2022-04-03 09:06:43
    FPGA 半加器与全加器

    FPGA学习篇之半加器与全加器

    半加器与全加器的区别与联系



    前言

      加法器作为数字电路中基本的器件,主要作用是实现两个数的加法运算。加法器有半加器和全加器之分,区别是半加器不接受低位的进位信号,全加器接受来自低位的进位信号并参与运算。


    一、半加器

    1.逻辑分析

      如下图所示,半加器只有两个输入和两个输出
    半加器
    半加器的真值表如下

    In1In2SumCout
    0000
    0110
    1010
    1101

    通过真值表可以得出: S u m = I n 1 ⊕ I n 2 Sum = In1 \oplus In2 Sum=In1In2 C o u t = I n 1 & I n 2 Cout = In1 \& In2 Cout=In1&In2

    2.代码编写

    module adderN#(parameter N = 4)(
    	input [N-1 : 0] in1,
    	input [N-1 : 0] in2,
    	output [N-1 : 0] sum,
    	output  cout
    );
    
    assign {cout,sum} = in1 + in2;
    
    //always@(*)
    //	{cout,sum} = in1 + in2;
    
    endmodule
    

    二、全加器

    1.逻辑分析

      如下图所示,全加器的输入有来自低位的仅为信号
    在这里插入图片描述
    全加器的真值表如下:

    In1In2CinSumCout
    00000
    00110
    01010
    10010
    01101
    11001
    10101
    11111

    通过卡诺图化简可以得出 S u m = C i n ′ ( I n 1 ⊕ I n 2 ) + C i n ( I n 1 ⊙ I n 2 ) = C i n ⊕ I n 1 ⊕ I n 2 Sum =Cin'( In1 \oplus In2) + Cin( In1 \odot In2) = Cin \oplus In1 \oplus In2 Sum=Cin(In1In2)+Cin(In1In2)=CinIn1In2
    C o u t = C i n ( I n 1 ∥ I n 2 ) + ( I n 1 & I n 2 ) Cout = Cin( In1 \parallel In2) +(In1 \& In2) Cout=Cin(In1In2)+(In1&In2)

    2.代码编写

    module adderN#(parameter N = 4)(
    	input [N-1 : 0] in1,
    	input [N-1 : 0] in2,
    	input  cin,
    	output [N-1 : 0] sum,
    	output  cout
    );
    
    assign {cout,sum} = in1 + in2 + cin;
    //assign {cout,sum[N-1 : 0]} = {in1[N-1],in1[N-1 : 0]} + {in2[N-1],in2[N-1 : 0]} + cin;
    
    endmodule
    

    三、总结

      文中通过真值表和逻辑表达式推导了半加器和全加器的原理,同时编写了verilog代码。全加器可以用两个半加器和一个或门实现,所以全加器的代码也可以调用两个半加器,再将两个半加器输出的进位信号相或得到。

    展开全文
  • 数据结构与算法分析第二版课后逻辑门电路半加器与全加器算法实现

    该书是北大数据结构与算法python版课程教材,视频b站上有,第一章课后练习有逻辑门电路实现。

    数字电路中,所谓“门”就是只能实现基本逻辑关系的电路。最基本的逻辑关系是与、或、非,最基本的逻辑门与门或门非门。逻辑门可以用电阻、电容、二极管、三极管等分立原件构成,成为分立元件门。也可以将门电路的所有器件及连接导线制作在同一块半导体基片上,构成集成逻辑门电路

    半加器(半加就是只求本位的和,暂不管低位送来的进位数)

    逻辑状态表

    ABCS
    0000
    0101
    1001
    1110

    其中,A和B是相加的两个数,S是半加和数,C是进位数。

        由逻辑状态表可写出逻辑式:    

     

    半加器逻辑电路图

    实现代码如下:

    # 电路正向计算&半加器
    # 超类LogicGate
    class LogicGate:
    
        def __init__(self, n):
            self.label = n
            self.output = None
    
        def getLabel(self):
            return self.label
    
        def getOutput(self):
            self.output = self.performGateLogic()
            return self.output
    
    
    # 二引脚逻辑门
    class BinaryGate(LogicGate):
    
        def __init__(self, n, pinA=None, pinB=None):
            super().__init__(n)
    
            self.pinA = pinA
            self.pinB = pinB
            self.output = self.getOutput()
    
        # def getPinA(self):
        # if self.pinA == None:
        # return int(input("Enter Pin A for gate" + self.getLabel() + "-->"))
        # else:
        # return self.pinA.getFrom().getOutput()
    
        # def getPinB(self):
        # if self.pinB == None:
        # return int(input("Enter Pin B for gate" + self.getLabel() + "-->"))
        # else:
        # return self.pinB.getFrom().getOutput()
    
        def __str__(self):
            return "{} - pinA: {}; pinA: {}; output: {}".format(self.label, self.pinA, self.pinB, self.output)
    
        def setNextPin(self, source):
            if self.pinA == None:
                self.pinA = source.output
            else:
                if self.pinB == None:
                    self.pinB = source.output
                else:
                    raise RuntimeError("Error: NO EMPTY PINS")
    
    
    # 单引脚逻辑门
    class UnaryGate(LogicGate):
    
        def __init__(self, n, pin=None):
            super().__init__(n)
    
            self.pin = None
            self.output = self.getOutput()
    
        # def getPin(self):
        # if self.pin == None:
        # return int(input("Enter Pin for gate" + self.getLabel() + "-->"))
        # else:
        # return self.pin.getFrom().getOutput()
    
        def __str__(self):
            return "{} - pin: {}; output: {}".format(self.label, self.pin, self.output)
    
        def setNextPin(self, source):
            if self.pin == None:
                self.pin = source.output
            else:
                print("Cannot Connect: NO EMPTY PINS on this gate")
    
    
    # 与门
    class AndGate(BinaryGate):
    
        def __init__(self, n, pinA=None, pinB=None):
            super().__init__(n, pinA, pinB)
    
        def performGateLogic(self):
            # self.pinA = self.getPinA()
            # self.pinB = self.getPinB()
            if self.pinA == 1 and self.pinB == 1:
                return 1
            else:
                return 0# 与非门
    class NandGate(BinaryGate):
    
        def __init__(self, n, pinA=None, pinB=None):
            super().__init__(n, pinA, pinB)
    
        def performGateLogic(self):
            # self.pinA = self.getPinA()
            # self.pinB = self.getPinB()
            if self.pinA == 1 and self.pinB == 1:
                return 0
            else:
                return 1
    
    
    # 或门
    class OrGate(BinaryGate):
    
        def __init__(self, n, pinA=None, pinB=None):
            super().__init__(n, pinA, pinB)
    
        def performGateLogic(self):
            # self.pinA = self.getPinA()
            # self.pinB = self.getPinB()
            if self.pinA == 1 or self.pinB == 1:
                # pinA = self.getPinA()
                # pinB = self.getPinB()
                # if pinA == 1 or pinB == 1:
                return 1
            else:
                return 0
    
    
    # 或非门
    class NorGate(BinaryGate):
    
        def __init__(self, n, pinA=None, pinB=None):
            super().__init__(n, pinA, pinB)
    
        def performGateLogic(self):
            # self.pinA = self.getPinA()
            # self.pinB = self.getPinB()
            if self.pinA == 0 and self.pinB == 0:
                return 1
            else:
                return 0
    
    
    # 异或门
    class XorGate(BinaryGate):
    
        def __init__(self, n, pinA=None, pinB=None):
            super().__init__(n, pinA, pinB)
    
        def performGateLogic(self):
            # self.pinA = self.getPinA()
            # self.pinB = self.getPinB()
            if self.pinA == self.pinB:
                return 0
            else:
                return 1
    
    
    # 非门
    class NotGate(UnaryGate):
        def __init__(self, n, pin=None):
            super().__init__(n, pin)
    
        def performGateLogic(self):
            # self.pin = self.getPin()
            if self.pin == 1:
                return 0
            else:
                return 1
    
    
    class Connector():
        def __init__(self, fgate, tgate):
            self.fromgate = fgate
            self.togate = tgate
    
            tgate.setNextPin(fgate)
    
        def getFrom(self):
            return self.fromgate
    
        def getTo(self):
            return self.togate
    #半加器
    class HalfAdder():
    
        def __init__(self, n, A, B):
            self.label = n
            self.A = A
            self.B = B
            self.S = XorGate("n1", A, B).output
            self.C = AndGate("n2", A, B).output
    
        def __str__(self):
            return "{} - A: {}; B: {}; S: {}; C: {}".format(self.label, self.A, self.B, self.S, self.C)
    
    

     运行测试

    if __name__ == "__main__":
        g1 = AndGate("G1",0,1)
        g2 = AndGate("G2",1,1)
        g3 = OrGate("G3")
        g4 = NotGate("G4")
    
        c1 = Connector(g1,g3)
        c2 = Connector(g2,g3)
        c3 = Connector(g3,g4)
        print(g1)
        print(g2)
        print(g3)
        print(g4)
        print(g4.output)
        h1 = HalfAdder("h1", 0, 0)
        h2 = HalfAdder("h2", 0, 1)
        h3 = HalfAdder("h3", 1, 0)
        h4 = HalfAdder("h4", 1, 1)
        print(h1)
        print(h2)
        print(h3)
        print(h4)

    与逻辑状态表对比,核验逻辑是否正确。

    全加器

    当多位数相加时,半加器可用于最低位求和,并给出进位数。第二位的相加有两个待加数Ai

    和Bi,还有一个来自前面低位送来的进位数Ci-1.这三个数相加,得出本位和数(全加和数)Si和进位数Ci.这种就是“全加“,下表为全加器的逻辑状态表。

    AiBiCi-1CiSi
    00000
    00101
    01001
    01110
    10001
    10110
    11010
    11111

    全加器可用两个半加器和一个“或“门组成。

     全加器一位逻辑电路图

     四位全加器行波进位法逻辑电路图

     实现代码如下:

    #全加器
    class Adder():
    
        def __init__(self,n,A,B,cin=0):
            self.label=n
            self.A=A
            self.B=B
            self.cin=cin
            self.rs=None
            self.cun=None
    
        def performLogic(self):
            ha1=HalfAdder('h1',self.A,self.B)
            ha2=HalfAdder('h2',ha1.S,self.cin)
            self.rs=ha2.S
            self.cun=OrGate('n1',ha1.C,ha2.C).output
            return self.rs,self.cun
    
        def __str__(self):
            self.performLogic()
            return "{} - A: {}; B: {};cin: {}; S: {}; C: {}".format(self.label, self.A, self.B, self.cin,self.rs, self.cun)
    
    #行波进位加法器(四位)
    class FourAdder():
        def __init__(self,n,A1,A2,A3,A4,B1,B2,B3,B4):
            self.label=n
            self.A1=A1
            self.A2=A2
            self.A3=A3
            self.A4=A4
            self.B1=B1
            self.B2=B2
            self.B3=B3
            self.B4=B4
            self.a=None
            self.b=None
            self.c=None
            self.d=None
            self.c1=None
            self.c2=None
            self.c3=None
            self.c4=None
    
        def performLogic(self):
            a1=Adder('a1',self.A1,self.B1)
            a1.performLogic()
            a2=Adder('a2',self.A2,self.B2,a1.cun)
            a2.performLogic()
            a3=Adder('a3',self.A3,self.B3,a2.cun)
            a3.performLogic()
            a4=Adder('a4',self.A4,self.B4,a3.cun)
            a4.performLogic()
            self.a=a1.rs
            self.b=a2.rs
            self.c=a3.rs
            self.d=a4.rs
    
        def __str__(self):
            self.performLogic()
            return "{} - A1: {};A2: {};A3: {};A4: {}; B1: {};B2: {};B3: {};B4: {}; a: {};b: {}; c: {};d: {}"\
                .format(self.label, self.A1, self.A2,self.A3,self.A4,self.B1,self.B2,self.B3,self.B4, self.a,self.b, self.c,self.d)
    

    运用了类的继承机制,由基本的与门、或门、与或门组成半加器,全加器可以看成是两个半加器组合运算,继承实现十分方便,同理,四位全加器是由四个全加器串联起来组成,测试如下:

    if __name__ == "__main__":
        a1=Adder('a1',0,1,0)
        a2=Adder('a2',0,1,1)
        a3=Adder('a3',1,1,0)
        a4=Adder('a4',1,0,1)
        a5=Adder('a5',1,1,1)
        print(a1)
        print(a2)
        print(a3)
        print(a4)
        print(a5)
    
        f1=FourAdder('f1',0,1,1,0,1,1,0,0)
        print(f1)
    展开全文
  • 与非门74LS00和异或门74HC86设计一个半加器.
  • FPGA设计半加器

    2021-10-27 23:36:48
    设计一位半加器,首先明确有两个输入端,这里定义为ip_A和ip_B,因为是半加器没有进位所以输出端也是两个端口就能搞定,列出真值表后写出逻辑表达式然后画出门电路图开始些verilog代码,输入端定义为wire型的,输出...

            设计一位半加器,首先明确有两个输入端,这里定义为ip_A和ip_B,因为是半加器没有进位所以输出端也是两个端口就能搞定,列出真值表后写出逻辑表达式然后画出门电路图开始些verilog代码,输入端定义为wire型的,输出端目前我还不知道reg型和wire型的具体用法上的区别,所以我就用的是wire型,如果错误的话还能帮助我区分一下,用assign持续给op_C和op_S赋值,异或有两种表达方式,注释后的就是第二种写法,两种用法都是一样的效果,但是后面的那种写法比较简便一些

    module adder
    //-----------------define--------------------//
    (
        input    wire     ip_A,
        input    wire     ip_B,
        output wire op_C,
        output wire op_S
    );
    //-----------------function--------------------//
        assign op_C    =    ip_A    &    ip_B;
        assign op_S    =    (ip_A&(~ip_B))|((~ip_A)&ip_B);//ip_A    ^    ip_B
    endmodule 

     

     

    展开全文
  • 初学者——半加器

    2022-03-09 19:19:22
    加法器是数字电路中经常用到的一种基本器件,主要用于两个数或者多个数的加和,加法器又分为半加器(half adder)和全加器(full adder)。 半加器电路是指对两个输入数据位相加,输出一个结果位和进位,没有进位...
  • 编程Verilog——半加器详解

    千次阅读 2020-11-29 13:10:37
    1.半加器:用于计算两个一位二进制相加,不考虑低位进位。 (1) 我们现在假设一下:a和b都是输入信号,cout是输出信号,sum是求和 (2) 那么它们的真值表可以表示为: ![在这里插入图片描述]...
  • 用FPGA实现半加器

    2021-10-19 14:19:06
    首先,让我们区别一下半加器与全加器。 半加器(HA)有两个代表数字(A0,B0)有两个输出端,用于输出和S0及进位C1(只考虑两个1位二进制数A和B相加,不考虑低进位来的进位数相加称为半加) 全加器(FA)有三个输入端,...
  • 全加器、半加器都是在数电学习路上非常主要的部分,下面我将全加器和半加器做一个详细的解释。 半加器 半加器是指对输入的两个一位二进制数相加(A与B),输出一个结果位(SUM)和进位(C),没有进位的输入加法器...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,061
精华内容 824
关键字:

半加器

友情链接: insjantiated.rar