HDLbits——procedures

最新推荐文章于 2024-06-07 23:09:19 发布

NDLilaco

最新推荐文章于 2024-06-07 23:09:19 发布

阅读量300

点赞数

分类专栏： HDLBits 文章标签： fpga开发

本文链接：https://blog.csdn.net/m0_60790618/article/details/128242551

版权

HDLBits 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

procedures

1 Alwaysblock1

我们知道数字电路是由导线连接的逻辑门组成，因此任何电路都可以表示为module和assign语句的某种组合。但是，有时候这不是描述电路最简便的方法。过程块(比如always块)提供了一种用于替代assign语句描述电路的方法。

有两种always块是可以综合出电路硬件的：

综合逻辑：always @(*)
时序逻辑：always @(posedge clk)

组合always块相当于assign语句，因此组合电路存在两种表达方法。具体使用哪个主要取决于使用哪个更方便。过程块内的代码与外部的assign代码不同。过程块中可以使用更丰富的语句(比如if-then,case)，但不能包含连续赋值*。但也引入了一些非直观的错误。(*过程连续赋值确实可以存在，但与连续赋值有些不同，并且不可综合)

例如，assign和组合always块描述相同的电路。两者均创造出了相同的组合逻辑电路。只要任何输入(右侧)改变值，两者都将重新计算输出。

assign out1 = a & b | c ^ d;
always @(*) out2 = a & b | c ^ d;

对于组合always块，敏感变量列表总是使用(*)。如果把所有的输入都列出来也是可以的，但容易出错的(可能少列出了一个)，并且在硬件综合时会忽略您少列了一个，仍按原电路综合。但仿真器将会按少列一个来仿真，这导致了仿真与硬件不匹配。(在SystemVerilog中，使用always_comb)

// synthesis verilog_input_version verilog_2001
module top_module(
    input a, 
    input b,
    output wire out_assign,
    output reg out_alwaysblock
);
    assign out_assign=a&b;
    always @(*) out_alwaysblock = a & b ;
endmodule

2 Alwaysblock2

对于硬件综合来说，存在两种always块：

组合逻辑：always @(*)
时序逻辑：always @(posedge clk)

时序always块也会像组合always块一样生成一系列的组合电路，但同时在组合逻辑的输出生成了一组触发器(或寄存器)。该输出在下一个时钟上升沿(posedge clk)后可见，而不是之前的立即可见。

阻塞性赋值和非阻塞性赋值

在Verilog中有以下三种赋值方法：

连续赋值(assign x=y;)：不能在过程块内使用；
过程阻塞性赋值(x=y;)：只能在过程块中使用；
过程非阻塞性赋值(x<=y)：只能在过程块内使用。

在组合always块中，使用阻塞性赋值。在时序always块中，使用非阻塞性赋值。具体为什么对设计硬件用处不大，还需要理解Verilog模拟器如何跟踪事件(译者注：的确是这样，记住组合用阻塞性，时序用非阻塞性就可以了)。不遵循此规则会导致极难发现非确定性错误，并且在仿真和综合出来的硬件之间存在差异。

从仿真的波形图可以看出，out_always_ff比其他两个输出延迟了一个时钟周期，这就是非阻塞性赋值带来的。

module top_module(
    input clk,
    input a,
    input b,
    output wire out_assign,
    output reg out_always_comb,
    output reg out_always_ff   );
    assign out_assign= a^b;
    always @(*) out_always_comb=a^b;
    always @(posedge clk) out_always_ff<=a^b;

endmodule

3 Always if

if语句通常对应一个二选一多路复用器，如果条件为真，则选择其中一个输入作为输出；反之如果条件为假，则选择另一个输入所谓输出。if语句必须在过程块内使用。

下面给出了一个基本的if语句和其综合出来的电路。

always @(*) begin
    if (condition) begin
        out = x;
    end
    else begin
        out = y;
    end
end

这与下面使用条件运算符连续赋值的语句是等价的：

assign out = (condition) ? x : y;

但是，过程if语句使用不当可能会引入新的错误，只有out在所有的条件下都被赋值才会生成正确的组合电路，具体的错误下一个训练才会讲到，

module top_module(
    input a,
    input b,
    input sel_b1,
    input sel_b2,
    output wire out_assign,
    output reg out_always   ); 
    assign  out_assign=(sel_b1&sel_b2)?b:a;
    always @(*) begin
        if (sel_b1&sel_b2) begin
            out_always=b;
        end
        else begin
            out_always=a;
        end
    end
endmodule

4 Always if2

常见的错误来源：如何避免引入锁存器

在设计电路时，必须首先具体考虑电路：

1、我想实现一个逻辑门；

2、我想实现一个具有输入并产生输出的组合逻辑块；

3、我想实现一组组合逻辑，紧接着一组触发器。

不要上来就写代码，这样往往与你想象的电路相差很远。

if (cpu_overheated) then shut_off_computer = 1;
if (~arrived) then keep_driving = ~gas_tank_empty;

除了你指定的情况以外，会发生些什么，答案是什么也不会发生，输出保持不变。而这往往就导致了电路的错误，所以说语法正确的代码不一定能产生合理的电路(组合逻辑+触发器)。

输出保持不变，这就意味着电路需要记住当前状态，从而产生锁存器。组合逻辑(比如逻辑门)不能记住任何状态。

Warning (10240): ... inferring latch(es)

上述这类警告通常情况下代表错误，除非锁存器是故意生成的。组合电路输出必须在所有输入的情况下都有值。这意味着必须需要else子句或着输出默认值。

if else必须一起使用

修复错误，只有当它真的过热时才关闭计算机，真的到达目的地或者需要加油时，才停止驾驶。

module top_module (
    input      cpu_overheated,
    output reg shut_off_computer,
    input      arrived,
    input      gas_tank_empty,
    output reg keep_driving  ); //

    always @(*) begin
        if (cpu_overheated)
           shut_off_computer = 1;
        else
           shut_off_computer = 0;
    end

    always @(*) begin
        if (~arrived)
           keep_driving = ~gas_tank_empty;
        else
            keep_driving=~arrived;
    end

endmodule

5 Always case

Verilog中的case语句几乎等同于if-else if-else序列，它将一个表达式与其他表达式列表进行比较。它的语法和功能与C语言中的switch语句稍有不同：

always @(*) begin     // This is a combinational circuit
    case (in)
      1'b1: begin 
               out = 1'b1;  // begin-end if >1 statement
            end
      1'b0:    out = 1'b0;
      default: out = 1'bx;
    endcase
end

1、case语句以case开头，每个case项以冒号结束。而switch语句没有。

2、每个case项只执行一个语句。这样就不需要C语言中break来跳出switch。但这也意味着如果您需要多个语句，则必须使用begin … end。

3、case项允许重复和部分重叠，执行程序匹配到的第一个，而C语言不允许重复的case项目。

module top_module ( 
    input [2:0] sel, 
    input [3:0] data0,
    input [3:0] data1,
    input [3:0] data2,
    input [3:0] data3,
    input [3:0] data4,
    input [3:0] data5,
    output reg [3:0] out   );//

    always@(*) begin  // This is a combinational circuit
        case(sel)
            3'b000: out=data0;
            3'b001: out=data1;
            3'b010: out=data2;
            3'b011: out=data3;
            3'b100: out=data4;
            3'b101: out=data5;
            default: out=4'b000;
        endcase
    end
endmodule

6 Always case2

优先编码器是组合电路，当给定输入时，输出输入向量中的右边第一个1的位置。例如，输入8’b10010000的，则优先编码器将输出3’d4，因为位[4]是从右数第一个1。

构建一个4位优先编码器。如果没有输入均为零，则输出零。请注意，4位数字有16种输入发的可能。

小提示：使用十六进制(4’hb)或十进制(4’d11)与二进制(4’b1011)相比可以节省打字量。

module top_module (
    input [3:0] in,
    output reg [1:0] pos  );
    always@(*) begin
        case(in)
            4'b0001: pos=2'd0;
            4'b0010: pos=2'd1;
            4'b0011: pos=2'd0;
            4'b0100: pos=2'd2;
            4'b0101: pos=2'd0;
            4'b0110: pos=2'd1;
            4'b0111: pos=2'd0;
            4'b1000: pos=2'd3;
            4'b1001: pos=2'd0;
            4'b1010: pos=2'd1;
            4'b1011: pos=2'd0;
            4'b1100: pos=2'd2;
            4'b1101: pos=2'd0;
            4'b1110: pos=2'd1;
            4'b1111: pos=2'd0;
            default: pos=2'd0;
        endcase
    end
endmodule

7 Always casez

不过还是先谈谈优先译码器，可能在学数字电路的时候优先译码器是左边第一个为0的数字，在本题中是右面第一个。两者都可以叫做优先译码器，出现的第一个数字把后面的数字屏蔽掉了，第一个数字具有较高的优先级，所以叫做优先译码器。

与优先译码器相对应的简单译码器，简单译码器的输入要求只能有一个1。出现多个1的时候视不同情况有不同的处理方式

always @(*) begin
    casez (in[3:0])
        4'bzzz1: out = 0;   // in[3:1] can be anything
        4'bzz1z: out = 1;
        4'bz1zz: out = 2;
        4'b1zzz: out = 3;
        default: out = 0;
    endcase
end

module top_module (
    input [7:0] in,
    output reg [2:0] pos );
    always @(*) begin
        casez (in)
            8'bzzzzzzz1: pos=0;
            8'bzzzzzz1z: pos=1;
            8'bzzzzz1zz: pos=2;
            8'bzzzz1zzz: pos=3;
            8'bzzz1zzzz: pos=4;
            8'bzz1zzzzz: pos=5;
            8'bz1zzzzzz: pos=6;
            8'b1zzzzzzz: pos=7;
            default: pos=0;
        endcase
    end
endmodule

8 Always nolatches

module top_module (
    input [15:0] scancode,
    output reg left,
    output reg down,
    output reg right,
    output reg up  ); 
    always @(*) begin
        up = 1'b0; down = 1'b0; left = 1'b0; right = 1'b0;
        casez (scancode)
            16'he06b: left=1'b1;
            16'he072: down=1'b1;
            16'he074: right=1'b1;
            16'he075: up=1'b1;
        endcase
    end
endmodule

module top_module (
    input [15:0] scancode,
    output reg left,
    output reg down,
    output reg right,
    output reg up  ); 

always@(*)
    casez(scancode)
        16'he06b: begin up = 1'b0; down = 1'b0; left = 1'b1; right = 1'b0; end
        16'he072: begin up = 1'b0; down = 1'b1; left = 1'b0; right = 1'b0; end
        16'he074: begin up = 1'b0; down = 1'b0; left = 1'b0; right = 1'b1; end
        16'he075: begin up = 1'b1; down = 1'b0; left = 1'b0; right = 1'b0; end
        default:  begin up = 1'b0; down = 1'b0; left = 1'b0; right = 1'b0; end
    endcase

endmodule