【学习笔记】4、组合逻辑电路(下)

接前文《【学习笔记】4、组合逻辑电路(上)》

4.4.5 算术运算电路

1. 半加器和全加器

• 半加器和全加器是算术运算电路中的基本单元。
• 半加器和全加器是1位相加的组合逻辑电路。

（1）半加器

• 半加器：只考虑两个加数本身，不考虑低位进位。

• A、B是两个加数

• S表示和数

• C表示进位

• 列出真值表：

A	B	C	S
0	0	0	0
0	1	0	1
1	0	0	1
1	1	1	0

• 逻辑表达式
  • $S=\overline{A}B+A\overline{B}=A\oplus B$//异或
  • $C=AB$
• 逻辑图
  

（2）全加器

• 全加器：加数A，加数B，以及低位进位$C_i$。
• S表示和数
• $C_o$表示进位
• 列出真值表

A加数1	B加数2	$C_i低位进位$	$C_o进位$	S和
0	0	0	0	0
0	1	0	0	1
1	0	0	0	1
1	1	0	1	0
0	0	1	0	1
0	1	1	1	0
1	0	1	1	0
1	1	1	1	1

• 列出逻辑表达式
• 不能直接给出最简形式，借助卡诺图。（先出现低位C，后出现高位A）
  
  

$S=\overline{A}\cdot \overline{B}\cdot C_i+\overline{A}\cdot B\cdot \overline{C_i}+A\cdot \overline{B}\cdot \overline{C_i}+AB{C}_i=A\oplus B\oplus C_i$//异或
$C_o=\overline{A}\cdot B\cdot C_i+A\cdot \overline{B}\cdot C_i+A\cdot B=（A\oplus B）\cdot C_i+A\cdot B$

2. 多位数加法器

（1）并行相加，串行进位，加法

• 必须在低1位进行完成后，才可以进行高1位的加法。
• 先低位相加，进位，再高位相加。
• 受到进位信号的限制。
  

（2）集成4位超前进位加法器

• 74HC283

• 考虑到全加器组成的“并行相加，串行进位”的缺点，设计了新的多位加法逻辑电路。

• 这里的超前，指的是 各个位加法不用等低1位的进位信号，提前进行加法。

• 每位的进位，只由加数和被加数决定，与低位的进位无关。

• 前文的全加器逻辑表达式：

  • $S=A\oplus B\oplus C_i$ //这里的i表示输入input
  • $C_o=（A\oplus B）\cdot C_i+A\cdot B$//这里的i表示输入input
  • $S_i=A_i\oplus B_i\oplus C_{i-1}$//i表示当前全加器，i-1表示前一个全加器
  • $C_i=（A_i\oplus B_i）\cdot C_{i-1}+A_i\cdot B_i$//i表示当前全加器，i-1表示前一个全加器

• 为了只观察进位$C_i$，定义中间变量$G_i=A_i{B}_i，P_i=A_i\oplus B_i$,这两个中间变量，在计算一开始，就已经固定了。
  

  • $S_i=P_i\oplus C_{i-1}$
  • $C_i=P_i\cdot C_{i-1}+G_i$

• 这里重点关注$C_i=P_i\cdot C_{i-1}+G_i$，一个迭代函数。

  • $C_0=G_0+P_0{C}_{-1}$
  • $C_1=G_1+P_1{C}_0=G_1+P_1(G_0+P_0{C}_{-1})=G_1+P_1{G}_0+P_1{P}_0{C}_{-1}$
  • $C_2=G_2+P_2{C}_1=G_2+P_2(G_1+P_1{G}_0+P_1{P}_0{C}_{-1})=G_2+P_2{G}_1+P_2{P}_1{G}_0+P_2{P}_1{P}_0{C}_{-1}$
  • $C_3=G_3+P_3{C}_2=G_3+P_3(G_2+P_2{G}_1+P_2{P}_1{G}_0+P_2{P}_1{P}_0{C}_{-1})=G_3+P_3{G}_2+P_3{P}_2{G}_1+P_3{P}_2{P}_1{G}_0+P_3{P}_2{P}_1{P}_0{C}_{-1}$
  • 根据推导，我们可以知道，当前加法器的进位信号$C_i$，只和$P_i$、$G_i$、初始进位信号$C_{-1}$有关。

• 逻辑图。
  

• 下图是猜测的74HC283逻辑图。
  

• 串联进位，级联。
  

• 超前进位产生器（并不是一个完整的加法器）

  • 74LS182

3. 减法运算

• 补码：$N_{补码}=2^n-N_{原码}$
• 补码：$N_{补码}=N_{反码}+1$
• 将减法变成加法。
  • $A-B=A-(2^n-B_{补})=A+B_{补}-2^n=A+B_{反}+1-2^n$
• 求4位减法的结果补码：$A-B=A+B_{反}+1$
  • $结果补码D_{3:0}^{’}=A_{3:0}+(B_{3:0}{)}_{反码}+1，C_o为进位信号$
• 求结果的原码
  • $结果原码D_{3:0}=[结果补码D_{3:0}^{’}，C_o]-2^n=[结果补码D_{3:0}^{’}，C_o]-2^4=[结果补码D_{3:0}^{’}，C_o]-(10000{)}_b$
  • 已知$结果补码D_{3:0}^{’}数值范围是(0000{)}_b到(1111{)}_b$。
  • 当$C_o=1$时，bit4=1, 减去$2^n=(10000{)}_b$,不需要借位，异或0。
  • $中间D_0^{{}^{\prime \prime }}=D_0^{{}^{\prime }}\oplus 0=D_0^{{}^{\prime }}$；
  • $中间D_1^{{}^{\prime \prime }}=D_1^{{}^{\prime }}\oplus 0=D_1^{{}^{\prime }}$；
  • $中间D_2^{{}^{\prime \prime }}=D_2^{{}^{\prime }}\oplus 0=D_2^{{}^{\prime }}$；
  • $中间D_3^{{}^{\prime \prime }}=D_3^{{}^{\prime }}\oplus 0=D_3^{{}^{\prime }}$；
  • $结果原码D_{3:0}=D_{3:0}^{{}^{\prime \prime }}+A_{3:0}^{{}^{\prime \prime }}=结果补码D_{3:0}^{{}^{\prime }}=A_{3:0}+B_{3:0}反码+1$
  • 举例：$A≥B，A=0101，B=0001
    • 公式计算：A-B=A+B_{反码}+1-2^4=(0101)_b+(1110)_b+1-(10000)_b=(10100)_b-(10000)_b=(00100)_b$ //不需要借位，
    • 电路逻辑：$A-B=A_{3:0}+B_{3:0}反码+1$
  • 当$C_o=0$时，bit4=0, 减去$2^n=(10000{)}_b$,需要借位，异或1。
  • $中间D_0^{{}^{\prime \prime }}=D_0^{{}^{\prime }}\oplus 1=(D_0^{{}^{\prime }}{)}_{反}$；
  • $中间D_1^{{}^{\prime \prime }}=D_1^{{}^{\prime }}\oplus 1=(D_1^{{}^{\prime }}{)}_{反}$；
  • $中间D_2^{{}^{\prime \prime }}=D_2^{{}^{\prime }}\oplus 1=(D_2^{{}^{\prime }}{)}_{反}$；
  • $中间D_3^{{}^{\prime \prime }}=D_3^{{}^{\prime }}\oplus 1=(D_3^{{}^{\prime }}{)}_{反}$；
  • $结果原码D_{3:0}=D_{3:0}^{{}^{\prime \prime }}+A_{3:0}^{{}^{\prime \prime }}+C_{-1}=D_{3:0}^{{}^{\prime }}反码+1=(A_{3:0}+B_{3:0}反码+1{)}_{反码}+1$
  • 举例：$A<B，A=0001，B=0101$
    • 公式计算：$A-B=A+B_{反码}+1-2^4=(0001{)}_b+(1010{)}_b+1-(10000{)}_b=(01100{)}_b-(10000{)}_b=(借位1\cdot 01100{)}_b-(10000{)}_b=(11100{)}_b（直接计算得到的就是-4的补码）$
    • 电路逻辑: $A-B=(A_{3:0}+B_{3:0}反码+1{)}_{反码}+1=((01100{)}_b{)}_{反码}+1=(10011{)}_b+1=(1\cdot 0100)，也就是绝对值=4，符号=V借位信号=1，为负，-4$
      

4. 集成算术/逻辑单元

• 算术逻辑单元ALU（Arithmetic Logic Unit）。既支持算术运算，又支持逻辑运算。
• 74LS181是双极型ALU。
• 功能引脚M=H时，执行逻辑运算
• 功能引脚M=L时，执行算术运算
  

4.5 组合可编程逻辑器件

4.5.1 PLD的结构、表示方法及分类

1. PLD的结构

• PLD：可编程逻辑器件
• 基本组成：与阵列、或阵列。
  

2. PLD的表示方法

• 早期使用熔丝和二极管，一次性编程。
• 可擦除CMOS技术，使用浮栅技术。
  

3. PLD的分类

• 按照集成度划分：
  • 低密度（1000以下）：PROM可编程只读存储器、PLA可编程逻辑阵列、PAL可编程阵列逻辑、GAL通用阵列逻辑
  • 高密度（1000以上）：CPLD复杂可编程逻辑器件、FPGA现场可编程门阵列
• 按照结构体系划分：
  • 简单PLD
  • 复杂可编程逻辑器件CPLD
  • 现场可编程逻辑器件FPGA
• 按照与或阵列是否可编程划分：
  • PROM：与阵列固定，或阵列可编程
  • PAL和GAL：与阵列可编程、或阵列固定。
  • PLA：与阵列、或阵列都可以编程。
    

4.5.2 组合逻辑电路的PLD实现

• 任何组合逻辑关系都可以变换成 与或 表达式
• 通过PLD的与、或阵列，可以实现任何一个逻辑函数。

1. 可编程逻辑阵列PLA

• 缺少开发环境支持，价格贵。

• $L_0=\overline{A}\cdot \overline{B}\cdot C+\overline{A}\cdot B\cdot \overline{C}+A\cdot \overline{B}\cdot \overline{C}+ABC$
• $L_1=AB+AC+BC$
• 列出真值表之后，可以发现该电路是“全加器”的功能。
• 全加器的逻辑表达式：
  $S=\overline{A}\cdot \overline{B}\cdot C_i+\overline{A}\cdot B\cdot \overline{C_i}+A\cdot \overline{B}\cdot \overline{C_i}+AB{C}_i=A\oplus B\oplus C_i$//异或
  $C_o=\overline{A}\cdot B\cdot C_i+A\cdot \overline{B}\cdot C_i+A\cdot B=（A\oplus B）\cdot C_i+A\cdot B$
  $变形：C_o=\overline{A}\cdot B\cdot C_i+A\cdot \overline{B}\cdot C_i+A\cdot B=\overline{A}\cdot B\cdot C_i+A\cdot \overline{B}\cdot C_i+(A\cdot B+ABC+ABC)$//吸收律
  $变形：C_o=\overline{A}\cdot B\cdot C_i+A\cdot \overline{B}\cdot C_i+(A\cdot B+ABC+ABC)=(\overline{A}\cdot B\cdot C_i+ABC)+(A\cdot \overline{B}\cdot C_i+ABC)+AB=B{C}_i+A{C}_i+AB$
  $变形：C_o=B{C}_i+A{C}_i+AB$

2.可编程阵列逻辑PAL

• 与阵列可编程，或阵列固定。
• 已知 逻辑表达式，使用PAL与阵列实现该功能。
• 一个 或单元 接三个可编程 与单元。
• 没有使用到的与单元，需要全接通，简化图是“与单元中画一个大的X”，因为正反 与 在了一起，该支路逻辑值为0。
• L3有需要4个或输入，硬件受限，可以使用L0的输出作为两个输入。
  

4.6 用Verilog HDL描述组合逻辑电路

• HDL硬件描述语言

4.6.1 组合逻辑电路的门级建模

• verilog语言内置的12个基本门级元件。

分类	元件符号	功能说明
多输入门	and	与门
多输入门	nand	与非门
多输入门	or	或门
多输入门	nor	或非门
多输入门	xor	异或门
多输入门	xnor	异或非门
------------	----------	------------------------------------------
多输出门	buf	缓冲器
多输出门	not	反相器
------------	----------	------------------------------------------
三态门	bufif1	三态缓冲器，if-如果，控制信号为1-高电平，输出有效 （in->out）
三态门	bufif0	三态缓冲器 ，if-如果，控制信号为0-低电平，输出有效（in->out）
三态门	notif1	三态反相器，if-如果，控制信号为1-高电平，输出有效（in->out）
三态门	notif0	三态反相器，if-如果，控制信号为0-低电平，输出有效 （in->out)

1. 多输入门

• and、nand、or、nor、xor、xnor

• 只允许一个输出，但允许有多个输入。

• 多输入门的输出端out，不可能为高阻状态z。
  

• 列出真值表，以2输入为例。

and 与门	$i{n}_1=0$	$i{n}_1=1$	$i{n}_1=x$	$i{n}_1=z(高阻)$
$i{n}_2=0$	0	0	0	0
$i{n}_2=1$	0	out=1	x	x
$i{n}_2=x$	0	x	x	x
$i{n}_2=z(高阻)$	0	x	x	x

nand 与非门	$i{n}_1=0$	$i{n}_1=1$	$i{n}_1=x$	$i{n}_1=z(高阻)$
$i{n}_2=0$	out=1	out=1	out=1	out=1
$i{n}_2=1$	out=1	0	x	x
$i{n}_2=x$	out=1	x	x	x
$i{n}_2=z(高阻)$	out=1	x	x	x

or 或门	$i{n}_1=0$	$i{n}_1=1$	$i{n}_1=x$	$i{n}_1=z(高阻)$
$i{n}_2=0$	0	out=1	x	x
$i{n}_2=1$	out=1	out=1	out=1	out=1
$i{n}_2=x$	x	out=1	x	x
$i{n}_2=z(高阻)$	x	out=1	x	x

xor 异或门	$i{n}_1=0$	$i{n}_1=1$	$i{n}_1=x$	$i{n}_1=z(高阻)$
$i{n}_2=0$	0	out=1	x	x
$i{n}_2=1$	out=1	0	x	x
$i{n}_2=x$	x	x	x	x
$i{n}_2=z(高阻)$	x	x	x	x

2. 多输出门

• buf缓冲器、not反相器

• 只能有一个输入，但允许多个输出。
  

• 列出1个输出的真值表

buf 缓冲器	$in=0$	$in=1$	$in=x$	$in=z(高阻)$
输出out1	0	1	x	x

not 反相器	$in=0$	$in=1$	$in=x$	$in=z(高阻)$
输出out1	1	0	x	x

3. 三态门

• bufif1、bufif0、notif1、notif0

• 有一个输出，一个输入，一个控制。

• 当控制信号为无效时，三态门输出高阻状态z。
  

• if1表示，高电平时允许输出（in->out），低电平时，输出高阻状态。

• if0表示，低电平时允许输出（in->out），高电平时，输出高阻状态。

• 列出真值表

bufif1 缓冲器	$控制信号ctrl=0$	$控制信号ctrl=1$	$控制信号ctrl=x$	$控制信号ctrl=z(高阻)$
$数据输入in=0$	out=z（高阻）	out=0	out=0或者z	out=0或者z
$数据输入in=1$	out=z（高阻）	out=1	out=1或者z	out=1或者z
$数据输入in=x$	out=z（高阻）	x	x	x
$数据输入in=z(高阻)$	out=z（高阻）	x	x	x

notif1 缓冲器	$控制信号ctrl=0$	$控制信号ctrl=1$	$控制信号ctrl=x$	$控制信号ctrl=z(高阻)$
$数据输入in=0$	out=z（高阻）	out=1	out=1或者z	out=1或者z
$数据输入in=1$	out=z（高阻）	out=0	out=0或者z	out=0或者z
$数据输入in=x$	out=z（高阻）	x	x	x
$数据输入in=z(高阻)$	out=z（高阻）	x	x	x

4. 举例

(1) Verilog实现2线-4线译码器

• 2线-4线译码器，使用Verilog语言的门级元件进行描述。
  
• 2个数据输入A1和A0
• 1个使能输入E
• 4个输出Y
• 3个内部节点，使用wire定义。
• 关键字定义多个元件时，调用名不能省略，多个调用名元件之间必须使用逗号分隔。

//门级Gate-Level
//2线-4线译码器 2-to-4 line decoder

module _2to4decoder(A1,A0,E,Y);
    input    A1,A0,E; //定义输入信号
    output [3:0]Y;//定义输出信号
    wire     A1not,A0not,Enot;//内部节点信号

    //非门
    not n1(A1not,A1),
        n2(A0not,A0),
        n3(Enot,E);
        
    //与非门
    nand n4(Y[0],A1not,A0not,Enot),
         n5(Y[1],A1not,A0   ,Enot),
         n6(Y[2],A1   ,A0not,Enot),
         n7(Y[3],A1   ,A0   ,Enot);
 endmodule
 

• 激励函数

`timescale 1ns / 1ns        //时间单位和时间精度一般是1、10和100这三种整数，单位有s、ms、us、ns、ps和fs；
module _2to4decoder_TB;            
    reg [1:0]a;            //输入信号（激励信号）必须定义为reg类型，用来保持信号值；
    reg e;
    wire [3:0]lout;              //输出信号（显示信号）必须定义为wire类型；

    parameter DELAY=50;     //设置延迟参数为50 

    _2to4decoder fun(.A1(a[1]), .A0(a[0]), .E(e), .Y(lout));

    initial                 //使用initial过程快定义激励信号波形
        begin               //使用begin-end控制语句
                   e=1'b1; a[1] = 1'b0; a[0] = 1'b0;   

            #DELAY e=1'b0; a[1] = 1'b0; a[0] = 1'b0; //50ns

            #DELAY e=1'b0; a[1] = 1'b0; a[0] = 1'b1; //100ns


            #DELAY e=1'b0; a[1] = 1'b1; a[0] = 1'b0; //150ns
 
            #DELAY e=1'b0; a[1] = 1'b1; a[0] = 1'b1; //200ns

            #DELAY $stop;                 //200ns,执行$stop系统任务，停止仿真
        end                                 
    initial $monitor($time,,,"/E=%b,A1=%b,A1=%b,Y",e,a[1],a[0],~lout);
                                                //执行monitor系统任务，设置显示结果的格式
endmodule

(2) Verilog实现2选1数据选择器

• 使用了三态门缓冲器bufif0，bufif1。
  

• 重点：L同时受两路信号驱动。在多驱动元的情况下逻辑值会发生冲突，‌从而产生不确定值。‌类似于竞争冒险。

• 在Verilog中：

  • 线网 wire：用于表示单个门驱动或连续赋值语句驱动的网络数据类型，‌
  • 三态线网 tri：用来表示多驱动器驱动的网络型数据。‌
  • 当没有定义wire和tri的逻辑强度时，‌在多驱动元的情况下逻辑值会发生冲突，‌从而产生不确定值。‌

//门级Gate-Level
//2线-1线数据选择器 2-to-1-line multiplexer
module _2to1muxtri(A,B,SEL,L)
    input A,B,SEL;
    output L; //定义输出信号
    tri L;//tri数据类型（三态线网），多驱动网络类型。
    
    bufif1(L,B,SEL);
    bufif0(L,A,SEL);
endmodule

• 激励信号

//2线-1线数据选择器 2-to-1-line multiplexer
module _2to1muxtri_TB;
    reg SEL,A,B;
    wire L;

    parameter DELAY=50;     //设置延迟参数为50

    _2to1muxtri fun(.A(A),.B(B),.SEL(SEL),.L(L));
    
    always #10 A=~A;
    always #20 B=~B;

    
    initial                 //使用initial过程快定义激励信号波形
        begin
           A=1;
           B=1;
                   SEL = 1'b0;   

            #DELAY SEL = 1'b1; //50ns

            #DELAY SEL = 1'b0; //100ns


            #DELAY SEL = 1'b1; //150ns
 
            #DELAY SEL = 1'b0; //200ns

            #DELAY $stop;                 //200ns,执行$stop系统任务，停止仿真

        end

    initial $monitor($time,,,"SEL=%b,A=%b,B=%b,Y=%d",SEL,A,B,L);
endmodule

5. 分层次的电路设计方法简介

• 自顶而下（top-down）：先定义顶层模块，再定义顶层模块用到的子模块。
  

• 自底向上（bottom-up）：先定义底层的各个子模块，再将子模块组合起来，构成顶层模块。

  • （1）使用门级元件定义底层的半加器。
  • （2）调用2个半加器+一个或门，定义一个全加器。
  • （3）调用4个1位全加器，构成顶层的4位全加器。

• 上层模块调用下层模块时，通过模块名完成调用过程，调用名不能省略。

  • 调用模块时，按照原来端口的排列顺序，可以使用一套新的端口，也可以使用同名的旧端口。
  • 调用模块时，按照端口名称，对应下层模块端口名称。顺序任意。$".下层端口(上层端口)->.S(S1)"$

verilog实现4位全加器

• 非超前进位加法器。
• 底层半加器
  

//半加器
module halfadder(S,C,A,B);
    input A,B;
    output S,C;
    //和
    xor(S,A,B);//S=A⊕B
    //进位
    and(C,A,B);//C=AB
endmodule

• 2个半加器+1个或门=1个1位全加器
  

//全加器
module fulladder(S,CO,A,B,CI);
    input A,B,CI;
    output S,CO;

    wire S1,D1,D2;
    //计算中间值S1，D1
    halfadder HA1(S1,D1,A,B);
    //和
    halfadder HA2(S,D2,S1,CI);
    //进位
    or g1(CO,D2,D1);
endmodule

• 4个1位全加器=1个4位全加器
  

module _4bit_adder(S,C3,A,B,C_1);
    input [3:0]A,B;
    input C_1;
    output [3:0]S;
    output C3;

    wire C0,C1,C2;//内部进位信号
    
    fulladder FA0(S[0],C0,A[0],B[0],C_1),
              FA1(S[1],C1,A[1],B[1],C0),
              FA2(S[2],C2,A[2],B[2],C1),
              FA3(S[3],C3,A[3],B[3],C2);
endmodule

• 激励信号

module _4bit_adder_TB;

    reg [3:0]A,B;
    reg C_1;
    wire [3:0]S;
    wire C3;

    parameter DELAY=50;     //设置延迟参数为50

    _4bit_adder fun(.A(A),.B(B),.C_1(C_1),.S(S),.C3(C3));
        
    initial 
        begin
                C_1 = 0;A = 4'b0101;B = 4'b0001;
        
        #DELAY  C_1 = 1;A = 4'b0101; B = 4'b0001;

        #DELAY  C_1 = 0;A = 4'b0101; B = 4'b1010;

        #DELAY  C_1 = 1;A = 4'b0101; B = 4'b1010;

        #DELAY $stop;  
        end

    initial $monitor($time,,,"A=%b,B=%b,S=%b,C=%d",A,B,S,C3);
endmodule

4.6.2 组合逻辑电路的数据流建模

• 门级建模太费事，工作效率低。
• 使用数据流建模，较高的抽象级别，描述电路。
• 通过“综合软件”，能够自动转换成门级电路。

1. 运算符

• 大约30个运算符。

类型	分类	符号	功能说明
算术运算符	双目运算符	+	二进制加
算术运算符	双目运算符	-	二进制减
算术运算符	双目运算符	*	二进制乘
算术运算符	双目运算符	/	二进制除
算术运算符	双目运算符	%	求模
------------	----------	-----------------	-----------------
关系运算符	双目运算符	>	大于
关系运算符	双目运算符	<	小于
关系运算符	双目运算符	>=	大于等于
关系运算符	双目运算符	<=	小于等于
关系运算符	双目运算符	==	等于
关系运算符	双目运算符	!=	不等于
关系运算符	双目运算符	===	全等于
关系运算符	双目运算符	!==	不全等于
------------	----------	-----------------	-----------------
位运算符	双目运算符	~	按位取反
位运算符	双目运算符	&	按位与
位运算符	双目运算符	|	按位或
位运算符	双目运算符	^	按位异或
位运算符	双目运算符	^~ 或 ~^	按位同或
------------	----------	-----------------	-----------------
缩位运算符	单目运算符	&	缩位与
缩位运算符	单目运算符	~&	缩位与非
缩位运算符	单目运算符	|	缩位或
缩位运算符	单目运算符	~|	缩位或非
缩位运算符	单目运算符	^	缩位异或
缩位运算符	单目运算符	^~ 或 ~^	缩位同或
------------	----------	-----------------	-----------------
逻辑运算符	-	!	逻辑非
逻辑运算符	-	&&	逻辑与
逻辑运算符	-	||	逻辑或
------------	----------	-----------------	-----------------
移位运算符	双目运算符	>>	右移
移位运算符	双目运算符	<<	左移
------------	----------	-----------------	-----------------
位拼接运算符	-	{ , } { { } }	将多个操作数拼接成一个操作数
------------	----------	-----------------	-----------------
条件运算符	三目运算符	?:	如果真，则，否，则

2.举例

（1）连续赋值语句 assign

• verilog语言中，基本语句是“连续赋值语句”。
• 针对wire型变量进行赋值。
• 这里的“连续”，表示持续性赋值，而不是一次性。
• 如下所示，只要等式右边逻辑值发生变化，会立即被计算出，并赋值给左边的变量

wire A,B,SEL,L;//4个连线型变量

assign L = (A&~SEL)|(B&SEL);//连续赋值

• 例如1：前文门级实现的2-4译码器，重新描述如下：

module decoder_df(A1,A0,E,Y);
    input A1,A0,E;
    output [3:0]Y;
    assign Y[0] = ~(~A1 & ~A0 & ~E);//000
    assign Y[1] = ~(~A1 &  A0 & ~E);//010
    assign Y[2] = ~( A1 & ~A0 & ~E);//100
    assign Y[3] = ~( A1 &  A0 & ~E);//110
endmodule

• 数据流与门级建模对比
  
• 激励函数

module decoder_df_TB;
    reg [1:0]a;
    reg e;
    wire [3:0]Y;

    parameter DELAY=50;     //设置延迟参数为50

    decoder_df fun(.A1(a[1]),.A0(a[0]),.E(e),.Y(Y));

    initial                 //使用initial过程快定义激励信号波形
        begin               //使用begin-end控制语句
                   e=1'b1; a[1] = 1'b0; a[0] = 1'b0;   

            #DELAY e=1'b0; a[1] = 1'b0; a[0] = 1'b0; //50ns

            #DELAY e=1'b0; a[1] = 1'b0; a[0] = 1'b1; //100ns


            #DELAY e=1'b0; a[1] = 1'b1; a[0] = 1'b0; //150ns
 
            #DELAY e=1'b0; a[1] = 1'b1; a[0] = 1'b1; //200ns

            #DELAY $stop;                 //200ns,执行$stop系统任务，停止仿真
        end                                 
    initial $monitor($time,,,"/E=%b,A1=%b,A1=%b,Y",e,a[1],a[0],~Y);
                                                //执行monitor系统任务，设置显示结果的格式

endmodule

• 例如2，4位全加器，重新实现：
• 被加数、加数都是4位的，如果发生进位，结果可能是5位。
• 用{Cout,SUM}拼接起来，Cout接收bit4，SUM接收bit[3:0]。

module binary_adder(A,B,Cin,SUM,Cout);
    input [3:0]A,B;
    input Cin;
    output [3:0]SUM;
    output Cout;
    assign {Cout,SUM} = A+B+Cin;
endmodule

• 数据流与门级建模对比
  

• 例如3，2选1数据选择器

• 使用连续赋值语句

module mux2x1_df(A,B,SEL,L);
    input A,B,SEL;
    output L;
    assign L=SEL?A:B;
endmodule

• 数据流与门级建模对比
  
• 激励信号

module mux2x1_df_TB;
    reg SEL,A,B;
    wire L;

    parameter DELAY=50;     //设置延迟参数为50

    mux2x1_df fun(.A(A),.B(B),.SEL(SEL),.L(L));
    
    always #10 A=~A;
    always #20 B=~B;

    
    initial                 //使用initial过程快定义激励信号波形
        begin
           A=1;
           B=1;
                   SEL = 1'b0;   

            #DELAY SEL = 1'b1; //50ns

            #DELAY SEL = 1'b0; //100ns


            #DELAY SEL = 1'b1; //150ns
 
            #DELAY SEL = 1'b0; //200ns

            #DELAY $stop;                 //200ns,执行$stop系统任务，停止仿真

        end

    initial $monitor($time,,,"SEL=%b,A=%b,B=%b,Y=%d",SEL,A,B,L);
endmodule

4.6.3 组合逻辑电路的行为级建模

• 描述数字逻辑电路的功能和算法。

• always是一个循环执行语句，后面跟着循环执行条件。

• 在always结构中，逻辑表达式就是一种过程赋值语句。

always @( 循环执行的条件 )  //不加分号“;”
//括号里的任何一个变量发生变化时，都会触发执行后面的过程赋值语句。
//执行完最后一句后，执行挂起，always语句再次等待变量发生变化。
//因此，循环执行条件被称为，“敏感变量”。
always @( 敏感变量 ) 
//敏感变量之间，使用关键词or，代替逻辑或运算“|”

• always结构，过程赋值语句，只能给reg类型的变量赋值。

• 条件语句（if-else）

• 多路分支语句（case-endcase）

1. 条件语句

• condition_expr 一般是 逻辑表达式或者关系表达式
• condition_expr = 0，x，z时，按照“假”处理。
• condition_expr = 1，按照“真”处理，并执行相应的语句。

if(condition_expr) true_statement; 

if(condition_expr) true_statement; 
else fale_statement;

if(condition_expr1) true_statement1; 
else if(condition_expr2)true_statement2;
else if(condition_expr3)true_statement3;
......
else default_statement;

2. 多路分支语句

• 先计算case_expr的值。
• 每个分支可以是单条语句，也可以是多条语句。
• 多条语句时，需要用begin和end包围着，构成一个整体（顺序语句块）。
• 每个分支的表达式的值，必须不同。执行完某一个分支后，case语句结束。（不需要break）
• 连续几个分支，都执行同样的表达式，可以用逗号分隔各个分支表达式，将执行语句放在其中最后一个表达式的后面。

case(case_expr)
item_expr1: statement1;
item_expr2: statement2;
......
default: default_statement;//可以省略
endcase

3. 举例

• 2选1数据选择器。
• 因为过程赋值语句，只能给reg数据赋值，所以需要把输出L定义成reg类型。

module mux2to1_bh(A,B,SEL,L);
    input A,B,SEL;
    output L;
    reg L; //

    always @(SEL or A or B)    //敏感变量，任何一个变化，都会触发执行
        if(SEL == 1)L=B; //if(SEL) L=B;
        else L=A;
endmodule

• 激励函数

module mux2to1_bh_TB;
    reg SEL,A,B;
    wire L;

    parameter DELAY=50;     //设置延迟参数为50

    mux2to1_bh fun(.A(A),.B(B),.SEL(SEL),.L(L));
    
    always #10 A=~A;
    always #20 B=~B;

    
    initial                 //使用initial过程快定义激励信号波形
        begin
           A=1;
           B=1;
                   SEL = 1'b0;   

            #DELAY SEL = 1'b1; //50ns

            #DELAY SEL = 1'b0; //100ns


            #DELAY SEL = 1'b1; //150ns
 
            #DELAY SEL = 1'b0; //200ns

            #DELAY $stop;                 //200ns,执行$stop系统任务，停止仿真

        end

    initial $monitor($time,,,"SEL=%b,A=%b,B=%b,Y=%d",SEL,A,B,L);
endmodule

• 4选1数据选择器

module mux4to1_bh(A,SEL,E,L);
    input [3:0]A;
    input [1:0]SEL;
    input E;
    
    output L;
    
    reg L; 

    always @( A or SEL or E)    //敏感变量，任何一个变化，都会触发执行
    begin 
      if(E==1) L=0;  
      else 
          case(SEL)
            2'd0: L=A[0];
            2'd1: L=A[1];
            2'd2: L=A[2];
            2'd3: L=A[3];
          endcase
     end
endmodule

• 激励函数

module mux4to1_bh_TB;
    reg E;
    reg [3:0]A;
    reg [1:0]SEL;
    wire L;

    parameter DELAY=50;     //设置延迟参数为50

    mux4to1_bh fun(.A(A),.E(E),.SEL(SEL),.L(L));//(A,SEL,E,L);
    
    always #2  A[3]=~A[3];
    always #5  A[2]=~A[2];
    always #10 A[1]=~A[1];
    always #14 A[0]=~A[0];
    
    initial                 //使用initial过程快定义激励信号波形
        begin
                   A=0;
                   E =1 ;SEL = 2'b00;   

            #DELAY E =0 ;SEL = 2'b00;  //50ns

            #DELAY E =0 ;SEL = 2'b01;  //100ns


            #DELAY E =0 ;SEL = 2'b10;  //150ns
 
            #DELAY E =0 ;SEL = 2'b11;  //200ns

            #DELAY $stop;                 //200ns,执行$stop系统任务，停止仿真

        end

    
endmodule