VerilogHDL基本语法和程序_verilog程序

Verilog语法

注意点

• 在always过程块中赋值的变量应该定义为 reg 型。reg型的变量不能用assign赋值
• 函数可以出现在持续赋值assign的右端表达式中
• input,output如果没有规定位宽或者类型的话，则默认是1位的wire类型
• verilog中for,if语句都不用加“：”
• 当没有指定函数名（返回值）的位宽和类型时，则默认是1位的reg类型
• output reg [7:0] y = 0;这种初始化赋值方式只能在模块级别出现，不能在函数中出现
• 变量声明尽量不要在匿名代码块begin end中，可以在模块级别声明，代码块中赋值
• 几进制计数器就是模几计数器

module命名规则

• 模块的名称必须以字母或下划线开头。
• 模块的名称可以包含字母、数字和下划线。
• 模块的名称不能包含空格或其他特殊字符，如符号和标点符号。

assign关键字

assign 关键字用于在 Verilog 中创建连续赋值，它可以将一个表达式赋值给一个 wire 类型的信号。assign 赋值发生在每个仿真时间步骤的开始，因此连续赋值可以用于在组合逻辑中实现一些功能。assign左侧的值必须是wire型，右侧的值可以是寄存器或者函数表达式。

下面是一个使用 assign 的简单例子，实现了一个两个输入信号的异或门：

module xor_gate(
    input a,
    input b,
    output y
);
	wire a,b;
    assign y = a ^ b;
endmodule
//这里使用 assign 关键字将 a ^ b 赋值给 y，从而实现了异或门的逻辑。
//需要注意的是，
//使用 assign 赋值的信号必须是 wire 类型的信号，
//而且不能使用时序逻辑语句来修改这些信号的值

1
2
3
4
5
6
7
8
9
10
11
12
13

reg 关键字

reg 是 Verilog HDL 中的一种数据类型，表示寄存器类型。在模块中，我们通常使用 reg 声明模块的内部寄存器变量。

reg 变量可以存储数字、布尔、字符串等类型的值，可以通过赋值语句来修改其值。在模块中，reg 变量的值可以在 always 块、initial 块或任务，函数中修改。

下面是一个简单的例子，展示如何在模块中使用 reg 变量：

module example_module(
    input clk,
    input rst,
    output reg [7:0] counter
);

always @(posedge clk, posedge rst) begin
    if (rst) begin
        counter <= 8'b0; // 复位计数器为0
    end else begin
        counter <= counter + 1; // 正常加1
    end
end

endmodule

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个例子中，我们声明了一个名为 counter 的 8 位寄存器变量，并在 always 块中使用了该变量。当 rst 信号为高电平时，我们将 counter 变量复位为0。当 clk 信号上升沿到来时，我们将 counter 变量的值加 1。output reg 声明指定了 counter 变量是该模块的一个输出端口，并且是一个寄存器类型。

需要注意的是，在 always 块中，对于 reg 变量的修改操作必须在时钟上升沿或下降沿的敏感列表中，否则在模拟过程中可能会导致意外的行为。

<=运算符

在 Verilog HDL 中，= 表示的是阻塞式赋值操作符，而 <= 表示的是非阻塞式赋值操作符。在时序逻辑中，我们通常使用 <= 来表示寄存器或者组合逻辑的输出信号。这是因为 <= 是一种非阻塞式赋值，可以在时钟边沿触发时更新输出信号，而不受其他语句的阻塞。在always块中，如果有多条“<=”赋值语句的话，是并行执行的，而有多条“=”赋值语句的话，是顺序执行的。

wire关键字

用途1：
wire clk,rst；
wire clk, rst; 是 Verilog HDL 语言中的语句，用于声明两个信号变量 clk 和 rst。

在 Verilog HDL 中，wire 类型的变量用于声明一个信号线，它表示一种被连接到模块输入或输出端口的信号类型，因此 wire 类型的变量通常被用来表示模块的输入输出端口，或者用于将模块中的各个部分连接起来。

在你的程序中，clk 和 rst 分别表示模块的时钟信号和复位信号，声明为 wire 类型的变量表示它们是从模块的外部输入的信号。因此，在模块实例化时，需要将外部的时钟信号和复位信号连接到这两个信号变量上，以便模块能够正确地工作。

8421BCD码是什么意思

8421BCD码是一种二进制编码方式，其中每个十进制数位用4个二进制位表示，这四个二进制位分别代表这个数位上的权值分别为8、4、2和1。因此，它的名称中“8421”代表了这四个权值，而“BCD”代表了“二进制编码的十进制数”（Binary Coded Decimal）的缩写。

举个例子，如果要表示十进制数53，就可以使用8421BCD码来表示为0101 0011，其中第一个字节“0101”代表5，第二个字节“0011”代表3。这种编码方式在数字电路中常被用于数码管的驱动和BCD码加法器等电路中。

练习实例：

组合逻辑电路

verilog设计方式（以2选一MUX为例）

//结构描述---根据电路结构图来画
//行为描述---只需描述出输入和输出的关系即可
//数据流描述---根据逻辑表达式把verilog中的逻辑运算符替换布尔代数中的逻辑运算符
1
2
3

统计二进制数中1的个数

module cal(a,
           y);
    input [7:0] a;
    output [7:0] y;
    function reg [7:0] get0;
        input [7:0] x;
        reg [7:0] count;
        integer i;
        begin   //这里尽量使用begin end 包裹
            count = 0;
            for (i = 0; i <= 7; i = i + 1)
                if (x[i] == 1'b1) 
                    count = count + 1;
            get0 = count;
        end
    endfunction
    assign  y = get0(a);
endmodule 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

for语句实现8位二进制数的乘法

module mult_repeat(a,
                   b,
                   result);
    parameter size = 8;
    input [size : 1] a,b;
    output reg [2*size :1] result;
    integer i;
    always @ (a or b)
        begin
            result = 0;
            for (i = 1; i <= size; i=i+1)
                if(b[i])
                    result = result + (a << (i - 1));
        end
endmodule

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

带同步复位的4位模10 8421BCD码计数器

时序逻辑电路

模4方向可控计数器

module counter(clk,rst,dir,count);
    input clk,rst,dir;
    output [1:0] count;
    
    reg [1:0] count;  // 声明寄存器变量
    always @(posedge clk, negedge rst)
    begin
        if (~rst)
            count <= 2'b00;
        else if (dir)
            count <= (count == 2'b11) ? 2'b00 : count + 1;
        else
            count <= (count == 2'b00) ? 2'b11 : count - 1;
    end
endmodule

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

模7方向可控计数器

module mode7(clk,
             rst,
             dir,    // dir为 1 表示加法，dir 为 0 表示减法
             count);
    input clk,rst,dir;
    wire clk,rst;
    output reg [2:0] count;
    
    always @(posedge clk or negedge rst)
    begin
        if (~rst)
            count <= 3'b000;
        else if (dir)  // 加法
        begin
            if (count == 3'b110)
                count <= 3'b000;
            else
                count = count + 1;
        end
        else
            count <= (count == 3'b000) ? 3'b110 : count - 1;
    end
endmodule
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

寄存器（74HC175）

module HC175_Reg (
    input wire clk,    // 时钟输入
    input wire resetn, // 复位输入，低电平有效
    input wire [3:0] d, // 数据输入
    input wire we,     // 写使能信号
    output reg [3:0] q  // 数据输出
);
    always @(posedge clk or negedge resetn) begin
        if (~resetn) begin
            q <= 4'b0; // 复位时将寄存器清零
        end else if (we) begin
            q <= d; // 写入数据到寄存器
        end
    end
endmodule

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

移位寄存器

• 具有移位 + 存储功能

• 真值表
  

• 电路图
  

• 波形图
  

• verilog程序代码

module shifter_latch(din,
                     clk,
                     qout);
    input din,clk;
    output reg [3:0] qout;
    output reg dout;
    always @(posedge clk)
        begin
            qout <= qout << 1; //左移一位八上一个时钟上升沿时的输出删掉
            qout[0] <= din; //输入信号补充到输出信号的最低位
            dout <= qout[3]; //输出最高位
        end
endmodule
1
2
3
4
5
6
7
8
9
10
11
12
13

有限状态机的设计

• 101序列检测器(三种方法)

//1. CS,NS,OL各用一个过程描述
module fsm1_seq101(input clk,
                   clr,
                   x,
                   output reg z);
    reg[1:0] state, next_state;
    parameter S0 = 2'b00, S1 = 2'b01,S2 = 2 'b11,S3 = 2'b10;
    /*状态编码,采用格雷（Gray）编码方式*/
    always @(posedge clk , posedge clr)  /*此过程定义当前状态*/
        begin 
            if (clr)  state <= S0;   //异步复位，s0为起始状态
            else state <= next_state; 
        end
        always @(state, x)  /*此过程定义次态*/
        begin
            case (state)
                S0 : begin if (x) next_state <= S1; else next_state <= S0; end
                S1 : begin if (x) next_state <= S1; else next_state <= S2; end
                S2 : begin if (x) next_state <= S3; else next_state <= S0; end
                S3 : begin if (x) next_state <= S1; else next_state <= S2; end
                default: next_state <= S0;
            endcase
        end
        always @*
        //此过程产生输出逻辑
            begin 
                case (state)
                    S3:      z = 1'b1;
                    default: z = 1'b0;
                endcase
            end
endmodule


// 2. CS + NS ,OL双过程描述
module fsm2_seq101(input clk,
                   clr,
                   x,
                   output reg z);
    reg [1:0] state;
    parameter S0 = 2'b00,S1 = 2'b01,S2 = 2'b11,S3 = 2'b10; /*状态编码,采用格雷(Gray)编码方式*/
    always @(posedge clk, posedge clr)  /*此过程定义起始状态*/
        begin if (clr) state <= S0;  //异步复位, sO为起始状态
              else 
                case(state)
                    S0 : begin if (x) state <= S1; else state <= S0; end
                    S1 : begin if (x) state <= S1; else state <= S2; end
                    S2 : begin if (x) state <= S3; else state <= S0; end
                    S3 : begin if (x) state <= S1; else state <= S2; end
                default:state <= S0;
                endcase
        end
    //产生输出逻辑（OL)
    always @(state)
        begin
            case (state)
                S3:      z = 1'b1;
                default: z = 1'b0;
            endcase
    end
endmodule


// 3.CS+NS+OL 单过程描述
module fsm4_seq101(input clk,
                   clr,
                   x,
                   output reg z);
    reg [1:0] state;
    parameter S0 = 2'b00, S1 = 2'b01,S2 = 2'b11,S3 = 2'b10; /*状态编码，采用格雷（Gray)编码方式*/
    always @(posedge clk, posedge clr)
        begin 
            if (clr) state <= S0;
            else 
                case (state)
                    S0: begin if (x) begin state <= S1; z = 1'b0; end else begin state <= S0; z = 1'b0; end end
                    S1: begin if (x) begin state <= S1; z = 1'b0; end else begin state <= S2; z = 1'b0; end end
                    S2: begin if (x) begin state <= S3; z = 1'b0; end else begin state <= S0; z = 1'b0; end end
                    S3: begin if (x) begin state <= S1; z = 1'b1; end else begin state <= S2; z = 1'b1; end end
                default:begin state <= S0; z = 1'b0; end
            endcase
        end        
endmodule
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

• 1111序列检测器

module fsm_detect(input x,
                  clk,
                  reset,
                  output reg Z);
    reg[4:0] state;
    localparam S0='d0,S1 ='d1, S2 = 'd2,S3 = 'd3,S4 ='d4;  //用localparam语句进行状态定义
    always @(posedge clk)
        begin 
            if (reset) begin state <= S0; Z <= 0; end 
            else 
                case (state) 
                    S0: begin if (x == 0) begin state <= S0; Z <= 0; end else begin state <= S1; Z <= 0; end end
                    S1: begin if (x == 0) begin state <= S0; Z <= 0; end else begin state <= S2; Z <= 0; end end
                    S2: begin if (x == 0) begin state <= S0; Z <= 0; end else begin state <= S3; Z <= 0; end end
                    S3: begin if (x == 0) begin state <= S0; Z <= 0; end else begin state <= S4; Z <= 1; end end
                    S4: begin if (x == 0) begin state <= S0; Z <= 0; end else begin state <= S4; Z <= 1; end end
                default: state <= S0;
                endcase
        end
endmodule

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21