Verilog HDL

目录

  • 1. 基本知识
    • 1.1. 什么是Verilog HDL
    • 1.2. Verilog HDL的功能
  • 2. 语法
    • 2.1. 模块
      • 2.1.1. 端口
        • 模块实例化
      • 2.1.2. 逻辑功能
        • assign声明
        • always块
        • initial块
    • 2.2. 模块的测试
    • 2.3. 常量
      • 2.3.1. 数字常量
      • 2.3.2. 参数常量 parameter 与 localparam
    • 2.4. 变量
      • 2.4.1. wire型
      • 2.4.2. reg型
        • 补码系统
      • 2.4.3. integer型
    • 2.5. 运算符
      • 2.5.1. 算术运算符(+,-,*,/,%,**)
      • 2.5.2. 位运算符(~,&,|,^, ^ ~)
      • 2.5.3. 逻辑运算符(!,&&,||)
      • 2.5.4. 关系运算符(<,>,<=,>=, = = == ==,!=, = = = === ===
      • 2.5.5. 移位运算符(<<,>>)
      • 2.5.6. 位拼接运算符({})
    • 2.6. 常用语句
      • 2.6.1. 块语句
        • 顺序块 begin...end
        • 并行块 fork...join
        • 生成块 generate...endgenerate
        • 禁用关键字 disable
      • 2.6.2. 条件语句(if...else)
      • 2.6.3. 分支语句(case)
        • casez 与 casex
      • 2.6.4. 循环语句(while,for)
      • 2.6.5. 赋值语句
        • 阻塞赋值 = 与 非阻塞赋值 <=
    • 2.7. 函数
      • 系统函数
    • 2.8. 任务
    • 2.9. 编译预处理
  • 3. 流水线设计技术(Pipeline)
    • 3.1. 组合逻辑模块中 使用Pipeline
  • 4. 有限状态机
    • 4.1. 有限状态机的Verilog描述


1. 基本知识

硬件描述语言(Hardware Description Language, HDL) 是一种能够用于描述数字电路的语言,可通过分层的模块表示复杂的数字系统,并可通过电子设计自动化(Electrionic Design Automation, EDA) 工具进行仿真,以得到具体的物理门级电路组合,即电路网表

之后再将上述网表,在专用集成电路(Application Specific Integrated Circuit, ASIC) 或者 现场可编程门阵列(Field Programmable Gate Array, FPGA) 上将网表转化为具体的电路布局结构。

1.1. 什么是Verilog HDL

Verilog HDL 就是HDL的一种,用于数字电子系统设计,进行数字逻辑系统的仿真验证、时序分析、逻辑综合,是目前应用最广泛的一种硬件描述语言。

Verilog的特点在于:

● 与工艺无关性:在使用verilog功能逻辑设计时无须过多考虑门级及工艺实现的具体细节,通过EDA工具的帮助可自动实现具体的网表。其实就是写代码实现电路,所以大大提高了verilog的可重用性。

知识产权核(Intellectual Property, IP):将一些在数字电路中常用、功能比较复杂、已经预先设计好的可修改参数的模块,即封装,类似于C++中的各种函数。IP核有三种形式:软核(HDL形式的IP核,代码)、固核(在FPGA上实现的正确的电路结构编码文件)和 硬核(在ASIC上实现的正确的电路结构版图掩膜,以经过完全的布局布线的网表形式提供)

1.2. Verilog HDL的功能

verilog可实现行为描述和结构描述,其中行为描述包括系统级模型(描述设计模块的外部特性)、算法级模型(实现算法运行)和寄存器级模型(Register Transfer Level, RTL)。

而结构描述就包括门级和开关级的模型,可描述逻辑门之间的连接。

比较重要而具体的功能:

● 顺序执行 or 并行执行:与电路网表一致,在verilog中既可以实现HDL的并行执行,也可实现与C相似的顺序执行结构。

● 时间延迟:可明确控制的启动时间延迟

● 事件触发:通过命名与设计事件设计激活or停止行为。

2. 语法

2.1. 模块

verilog建立的verilog模型就是模块,通过模块实现各种逻辑功能,并可通过EDA工具将verilog代码模块转化为门电路的连接,该过程为综合

如下所示,一个名为OR的模块

module OR(input a, input b, output c);			//分号千万别忘了
	assign c = a || b;
endmodule

综合之后则为

Verilog HDL_第1张图片
注意模块module的结构写法,以及使用endmodule结尾

需要说明的是模块module实际上是创建了一个类型,例如与们、或门、非门、加法器等等,这些模块可以被实例化,即一个具体的有名字、输入信号确定的对象。

2.1.1. 端口

指的是该模块的输入/输出端口,即IO口。

既可以标注输入、输出以及输入输出口,注意信号位宽的写法一般是“高位:低位”,具体可见代码:

module OR(
	input [2:0] a, 
	input [3:1] b, 												//不写明类型就默认为wire类型 
	output reg [2:0] c,		
	inout [5:0] d
	);		
														
assign d = a | b;
always@(*) begin
	if(a)
		c = 3'b1;
	else
		c = 3'b0;
end
	
endmodule

注意module输入必须为wire型,输出建议也用wire

例如上面的代码,输出c虽然是reg型但在后期综合的时候还是会把它综合成导线而不是触发器。

但always块赋值右侧又必须是reg型,所以推荐的写法如下

module block(
	input a,
	input b,
	output c
);
reg c_r;						//由于要通过always赋值故声明一个reg型变量
always@(*) begin
	if(a)
		c_r = 1'b1;
	else
		c_r = 1'b0;
end
assign c = c_r;					//用一个assign为wire型输出c赋值
endmodule
模块实例化

实例化引用就是,在某个模块内部引用其他模块,并将该模块的IO与外部连起来。

引用方式如下:

module trist2(input a, input b, output c);
	//......
	block u_block1(a_i,b_i,c_o);						//严格按照block模块定义端口的顺序			

	block u_block2(.c(c_o),.a(a_i),.b(b_i));			//指明谁连谁,注意写法是  ".模块端口(连接变量)"

endmodule

如上代码所示有两种实例化方式。

但是这里有一个问题:实例化时模块端口连接的变量,是wire型还是reg型呢?答案是输入可wire可reg,输出必须是wire

有个小技巧,既然是例化连接,其实还是导线的连接,所以将例化时的变量连接看成assign语句。
那么输入就相当于 assign a = a_i;,那显然模块定义的时候input a必须是wire型,而a_i任意
输出相当于assign c_o = c;,那显然例化时连接的变量c_o必须是wire型,而模块定义时的output c任意(但从后期综合考虑建议为wire型)

2.1.2. 逻辑功能

指模块内部产生逻辑功能的语句,所有的逻辑一般均必须通过assign、always、initial以及实例化引用实现功能。

需要说明的是模块内的所有逻辑功能均是并行实现的,即同时执行。所以执行顺序与代码的写作顺序无关。

module exercise(input in1, input in2,...,output out1, output out2,... );

//块1
initial 
	...
//块2
assign ...;
//块3
assign...;
//块4
always@(...)
...
endmodule				//块1234同时执行

但是块内部则可能出现顺序执行的逻辑,这个后面会涉及到。

assign声明

直接assign后面接方程式即可,表示持续地满足该方程式的关系。

assign a = b & c;	//永远满足a为b与c的按位与的结果

assign #10 clk = ~clk;		//延迟10个单位时间之后,clk按位翻转,且永远如此变换

注意上例子中的#10表示延迟10个单位时间再去执行。

always块

不断运行的语句,同时可以为always添加时序控制语句来判断语句执行的条件。会永远持续地判断条件,一旦条件满足,则执行后面的语句。

always块@里面是敏感列表,表示always块触发的条件:时序逻辑包括posedge表示上升沿触发、negedge表示下降沿触发

组合逻辑则使用(*)电平触发,即变量值发生变化时触发

同时可加入begin…end表示触发要执行的语句块,注意该语句块为顺序执行

具体的书写形式如下

always@(posedge clk or negedge rstn)			//时序逻辑
begin
	if(!rstn)
		q <= 1'b0;
	else if(flag)								//若某个posedge clk处flag为低,则q会保持原值。即 q <= q;
		q <= 1'b1;
end

always@(*) begin								//组合逻辑
	if(flag)
		q = 1'b0;
	else if(width)								//若flag为低、width也为低,则q会锁存,被综合成锁存器Latch
		q = 1'b1;
end

一定要注意verilog中的各always块均为并行执行,因此禁止多个always块对同一个变量赋值,可合并为一个always块解决此问题,例如:

always@(posedge clk)
begin
	if(A)
		q <= 1'b0;
	......
end

always@(posedge clk)
begin
	if(B)
		q <= 1'b1;
	......
end
//合并为一个always块/
always@(posedge clk)
begin
	if(A)
		q <= 1'b0;
	else if(B)
		q <= 1'b1;
	......
end

需要说明的是,always块中使用组合逻辑时,if语句的else、case语句的default等等要写全,否则会被综合成锁存器Latch。

而时序逻辑中写不全,触发器就不会成为Latch。

initial块

可在仿真开始时对各变量进行初始化,注意initial块只会执行一次,但initial内部的begin…end是顺序执行。

但是多个initial块则是并行运行的!!!见verilog中的initial语句

initial						//注意结尾没有分号
	begin
		inputs = 3'b000;
		#10 inputs = 3'b000;
		#20 inputs = 3'b001;
		#30 inputs = 3'b010;
	end

2.2. 模块的测试

在建立模块之后,可再建立一个专门用于测试的模块。在测试模块中引用之前建立的模块,并给定相应的输入,以观察所建立的模块的输出信号,以判断设计的结构合理与否。

所以测试模块不需要输入和输出,例子如下:

'include "mux.v"
module mux_test
	reg ain,bin,select,out;
	reg clock;

	//参数初始化	

	initial
		begin
			ain = 0;
			bin = 0;
			select = 0;
			clock = 0;
		end

	//设定时序
	
	assign #100 clock = ~clock;
	
	always@(posedge clock)
		begin
			#1 ain = {$random}%2;
			#3 bin = {$random}%5;
		end
	assign #1000 select = !select;
	
	//实例化mux
	
	mux m(.out(out),.a(ain),.b(bin),.sl(select));


endmodule

之后可以用相关仿真软件对信号的波形作仿真,以观察信号是否符合要求。

2.3. 常量

即程序运行中不能改变的量。

2.3.1. 数字常量

由于verilog为数字系统描述语言,对于数字系统来说最基本的是端口电平的高低,即基本为数字量,所以常用的是整数。

常见形式为

仅数字

默认为32bit的十进制的数

bit位宽 + ’ + 进制 + 数字

表示一定位宽下某个进制的值,例如3’b101、8’ha2等等。

注意位宽为二进制的bit,例如 8’ha2 表示 8bit的 十六进制a2。

其中进制表示法如下:

字母 进制
b 或 B 二 进制
d 或 D 十 进制
h 或 H 十六 进制

别忘记二进制 和 十六进制的相互转换
1位十六进制 = 4位二进制,例如 4’ha = 4’b1010, 4’hf = 4’b1111, 16’habc = 12’b1011_1100_1101,12’h1010 = 16’b0001_0000_0001_0000

所以位数÷4就是十六进制的总位数,例如16‘ha2的十六进制位数为16/4 = 4,因此完整写法为16’h00a2。32’h10的十六进制位数为32/4 = 8,所以完整写法为32’h00000010

对于数字而言,除了完整地按照位宽正常地写出各位的值以外,还有其他写法和注意事项:

● 值相同即可,bit数可以不相同,例如4’b0010 == 2’b10 == 2,这一点与数组相区别。

● 可通过下划线分割位数 以提高可读性,例如12’b1011_1100_1101

x 可用来表示不定值,z或?可用来定义高阻值,且均可以作为十六、八、二进制的一位,例如 4’hx == 4’bxxxx,4’b1x0z等等。

● bit数与数字的二进制位数不相等的,前补0,只有最左边的x或z才具有扩展性

这一点容易弄混,例如8’ha == 8’b0000_1010, 4’b1 == 4’b0001,16’h4x == 16’h004x, 8’bzx == 8’bzzzzzzzx, 8’hx == 8’hxx

● 十六进制数字部分不区分大小写, 不定值x 和 高阻值z 也不区分大小写

2.3.2. 参数常量 parameter 与 localparam

可以为某个参数定义某个常量数值,方便程序中使用,例如

parameter width = 1,
		  polarity = 2;
		  length = width * 10;
		  
localparam phy = 1.396;
localparam pi = 3.14159;

		begin
			a = 2 * pi * r;		//等价于2*3.14159*r
			...
		end

无论是localparam还是parameter,一定要注意定义的是常量!是常量!值不可以更改的!上面的代码中出现pi = pi +1;是错误!想要更改的话要把类型定义成integer或是large等等的变量!

而parameter和localparam的区别是,parameter参数可通过其他模块重新配置,而localparam为私有参数常量不可被外部配置。

那么如何外部模块如何对该模块的parameter进行配置呢?一般在例化时指定

module block#(									//这里不可出现localparam!
		  parameter width = 1,
		  parameter polarity = 2;
		  parameter length = width * 10;					
		  )(
		  input a,
		  input b,
		  output c
		 );
//...
endmodule

module top;
	//...
	block u_block#(
			.width		(`WIDTH),
			.polarity	(`POLARITY),
			.length		(`LENGTH)
			)(
			.a	(a_i),
			.b	(b_i),
			.c	(c_o)
			);
endmodule

parameter其实很像即将要讲到的宏定义’define,二者均可以进行参量代换,但是区别在于:parameter只能表示数字且可以在其他模块进行修改
'define可以表示任意量甚至是表达式的一部分,例如 'define DelayNand nand #5就可以用于表示DelayNand n1(a,b,c),等价于nand #5 n1(a,b,c);,但是’define一旦定义不可修改。
注意define使用结尾不加分号

2.4. 变量

即在程序运行过程中其值可以改变的量。

注意:禁止在initial, always块中进行常量、变量的定义

2.4.1. wire型

即导线,属于线网net型,用于描述模块内部各结构实体(例如门)之间的连接。因此wire型均为无符号数

常用assign 描述的组合逻辑信号,模块中的输入输出自动定义为wire,默认为高阻值z

wire型可以指多个位的变量,如下所示定义方式。

wire a;
wire [31:0] b;
wire [32:1] c,d;		//位不好数的时候可以将最低位下标设为1

既然是导线的含义,通过如下例子解释wire的含义:

module compose(input a, input b, output c)	//可以写成input wire a, input wire b, output wire c
	wire mid;
	assign mid = a && b,c = ~mid;
endmodule

模块结构如下图所示,确实是一根导线。

Verilog HDL_第2张图片

2.4.2. reg型

来自于register寄存器,可用来表示数据存储器、寄存器、触发器等等。

常用于always模块中代表触发器,并且always模块中 每一个被赋值的信号 都必须是reg型,并且reg型默认为不定值x

见如下定义方式

reg [31:0] r1,r2,r3;	//定义了3个寄存器r1,r2,r3,每个寄存器有32bit
reg r4 [9:0];			//定义了10个寄存器,r4[0]...r4[9],每个寄存器有1bit
reg [31:0] r5 [9:0];	//定义了10个寄存器,r5[0]...r5[9],每个寄存器有32bit

always@(posedge clk)
	begin
		r5[0][0] <= 1;
		r5[0][1] < =0;
	end

需要说明的是reg型可以被赋予负值,但是reg型数据实际上表示的是无符号数

无符号数可按照如下数字循环取到,以3bit为例:

Verilog HDL_第3张图片
对于有符号数而言,定义方法为:

reg signed [7:0] a;
补码系统

有符号数中,

负数的表示方法为 符号位(1为负)+补码,例如-3在verilog中就表示为4’b1101,-5就表示为4’b1011。

正数的表示方法为 符号位(0为正)+原码

计算时直接相加即可,例如

reg signed [3:0] a = 4'b1011;	//-5
reg signed [3:0] b = 4'b0100;	//4
reg signed [3:0] sum;

assign sum = a + b;				// 4-5 = 4 + (-5) = 4'b1111,为-1
reg signed [3:0] a = 4'b1101;	//-3
reg signed [3:0] b = 4'b0101;	//5
reg signed [3:0] sum;

assign sum = a + b;				// 5-3 = 5 + (-3) = 5'b10010,截掉最高位为1

在SystemVerilog中为了避免纠结变量类型是wire还是reg,引入了新的变量类型logic,系统会自动推断是wire还是reg。
但是logic类型变量并不允许多于一次的持续赋值or输出端口给同一变量赋值
详情可参考systemverilog中logic变量的使用

由于经常出现模块类型定义和子模块变量传递类型的矛盾,此处对reg和wire的使用做如下总结:
always中 被赋值为reg,assign中 被赋值为wire
顶层模块:输入为wire,输出为 reg/wire
子模块实例:输出用wire连接,如下图所示:
Verilog HDL_第4张图片

2.4.3. integer型

其本质还是reg型,只不过是一种有符号的32位寄存器类型,其实直接看成整数变量即可。

例如常见的循环for(integer i = 0; i <= 10 ;i = i + 1)

注意verilog中变量没有小数的概念,可以有小数的运算,但是最终输入输出的值永远是整数。毕竟是数字电路只有高电平1和低电平0二者之分。

2.5. 运算符

有很多运算符,可分成单目、双目和三目三种。

2.5.1. 算术运算符(+,-,*,/,%,**)

比较简单,注意如果有个操作数存在不确定值x,则算术运算结果也为x

%表示求余运算符,但是余数符号只与第一个操作数一致

例如 -14%3 = -2,但 14%-3 = 2

实际设计中+、-可随意使用,但*、/、%、**不建议使用,因为无法判断最后会综合成什么电路。
那么怎么作这些计算呢?使用各种封装的IP模块,用多周期的流水设计实现运算结果,综合可控

2.5.2. 位运算符(~,&,|,^, ^ ~)

表示一个操作数或两个操作数相互按位一位一位地进行关系运算。

位数不同则自动高位补0

下面举例说明

wire [3:0] a;
wire [2:0] b;

assign a = 4'b1010;
assign b = 3'b011;

wire [3:0] c;

begin
	c = ~a;				// 按位取反,c为 4'b0101
	c = a & b;			// 按位与,c为 4'b0010
	c = a | b;			// 按位或,c为 4'b1011
	c = a ^ b;			// 按位异或,c为 4'b1001
	c = a ^~ b;			// 按位同或,c为 4'b0110
end

位运算符同样可以一个操作数的不同位一位一位的相互运算,即

wire d;
begin
	d = & a;			// 等价于a[0]&a[1]&a[2]&a[3],d为 1'b0
	d = | a;			// 等价于a[0]|a[1]|a[2]|a[3],d为 1'b1
end

2.5.3. 逻辑运算符(!,&&,||)

注意逻辑运算符永远只能是单个bit进行运算,不能如~|&这种对应为相互运算。

wire a,b;
assign a = 1'b1;
assign b = 1'b0;

wire [3:0] c;
begin
	c = !(a && b);		//c为 4'b0001
	c = !(a || b);		//c为 4'b0000
end

但注意取反运算符~和!的区别,二者都可以对一个bit进行取反操作,但是多个bit只能用 ~。

常用!来进行低电平判断:

always@(negedge reset)
	begin
		if(!reset)
			...
	end

2.5.4. 关系运算符(<,>,<=,>=, = = == ==,!=, = = = === ===

如果关系是模糊的,则返回不定值x

注意的变量值为x或z时a===b一律返回false,只有a与b均为0或均为1时才会返回true。例如a==b在a为x、b为1仍然为true,而a===b就为false

2.5.5. 移位运算符(<<,>>)

左移位后补0,右移位删除对应位。

注意变量位数是确定的,左移位可能会消掉某些高位,见下例

reg [4:0] a;
reg [6:0] b;
initial 
	begin
		a = 10;
		#10 a = (a<<2);		//a原为5'b01010,移位之后为5'b01000
		
		b = 10;
		#10 b = (b<<2);		//b原为7'b0001010,移位之后为7'b0101000
	end

2.5.6. 位拼接运算符({})

将某些信号的某些bit拼接在一起形成新的值,

注意一些写法,例如{3{w}}={w,w,w},还可以加入常量,例如

wire [3:0] a,b;

assign a = 4'b1011;
assign b = 4'b0101;

wire [16:1] c;

assign c = {a,b[2:0],a[1],a[2],1'b1,1'b0,2{a[1],b[2]}};		
//c为 16'b1011_101_1_0_1_0_11_11

2.6. 常用语句

很多语句都与C语言非常类似。

2.6.1. 块语句

将多条语句组合在一起,非常类似于C中的大括号。

顺序块 begin…end

begin…end内部的语句是顺序执行的,并且可以为该顺序块命名,执行完最后一条语句跳出。

begin:give			//命名不是必须
	a = b;
	c = d;
end

别忘了可以使用#10进行延迟执行。

'timescale 1ns			//定义时间单位
module seq
	reg [2:0] r;
	initial r = 4'b000;
	begin
		#5 r = 4'b001;
		#10 r = 4'b010;
		#15 r = 4'b011;
		#20 r = 4'b100;
	end
endmodule

变量r产生的波形如下,其中delay表示持续的时间
在这里插入图片描述
也就是说 顺序块中的延迟时间为上一条语句执行结束之后等待的时间。

并行块 fork…join

即并行块中的语句为并行执行的,即所有语句同时开始执行,这个在C中没有定义。

所以如果要产生与seq模块相同的波形,使用并行块写法如下:

'timescale 1ns			//定义时间单位
module para
	reg [2:0] r;
	initial r = 4'b000;
	fork
		#5 r = 4'b001;
		#15 r = 4'b010;
		#30 r = 4'b011;
		#50 r = 4'b100;
	join
endmodule

由于是并行的,所以一定要检查并行块是否存在矛盾的语句,即竞争冒险现象,例如重复赋值等等。

同时块语句相互之间可以嵌套,例如

begin
	x = 1'b0;
	fork
		#5 y = 1'b1;
		#10 z = {x,y};
	join
end
生成块 generate…endgenerate

可用于动态生成代码

例如

genvar i;
generate if(`DATA1 > `DATA2)					//只有满足if条件才会生成下面的代码
	for(i=0;i<`WIDTH;i=i+1)						//以for循环的方式生成多行相同代码
		always@(posedge clk) begin
			//...
		end
else
	//...
endgenerate
禁用关键字 disable

可用disable使任意块语句停止运行,也可用于跳出循环,类似于break

但注意必须提前给块语句命名才能disable,例如要终止块语句block1则有disable block1;

例如跳出循环

begin:block1
	while(i<16)
		begin:block2
			if( flag[i] )
				begin
					$display("True bit at %d", i);
					disable block1;		//跳出while,类似break
				end
			else
				begin
					$display("Wrong bit at %d",i);
					i = i + 1;
					disable block2;		//跳出本次循环,类似continue
				end
		end
end

上面的语句意思是如果变量flag的第i位为1就disable block1,即跳出循环,表达出C里面break的效果。

如果flag的第i为为0,就先移动到下一位然后disable block2,之后根据while语句的规则,继续循环判断下一位是否为0,因此此处的disable表达出continue的效果。

所以如果将disable block1替换成i = i + 1; disable block2;循环的意思就变成了检查flag中所有的bit是否为1,此处就不再是break的效果而是continue

2.6.2. 条件语句(if…else)

非常熟悉的条件语句,常见写法如下:

if(!rst)
	begin
		instruction = 0;
		index = 0;
	end
else
	begin
		instruction = sa;
		index = index + 1;
	end

但是有一些需要注意的地方

● if后面的条件表达式结果,0,x,z均为假,只有1为真

在同一个块内,else只与最近的if 相对应

见下面的代码,请问下面的那个else是与哪个if相对应呢?

if(index>0)
	for(i = 0;i<index;i++)
		if(memory[i]>0)
			memory[i] = 0;
else
	$display("error");

答案是第二个if,这是由于第二个if并没有在顺序块内,所以else可以与之匹配,但如果是下面这种情况就是else与第一个if相匹配了

if(index>0)
	begin
		for(i = 0;i<index;i++)
			if(memory[i]>0)
				memory[i] = 0;
	end
else
	$display("error");

多个if嵌套需要用 begin…end包括

例如下面的代码并不等价于if(a>b && c>d) sig<= 1'b1;

if(a>b)
	if(c>d)
		sig <= 1'b1;

上面代码中即使c>d满足也会执行sig <= 1'b1;这是因为上面的代码本质是

if(a>b)					//a>b满足什么都不做
if(c>d)					//c>d满足则赋值
	sig <= 1'b1;

如果想等价于if(a>b && c>d) sig<= 1'b1;就要加入begin…end块

if(a>b) begin
	if(c>d)						//等价于if(a>b && c>d)
		sig <= 1'b1;
end

2.6.3. 分支语句(case)

多分枝选择语句,常用于指令译码、状态机等。

通过计算case后面括号内部的表达式,找到与表达式相等的分支项,注意比较时位宽必须相等,x与z也必须严格在对应的bit上彼此相等,则执行该分支项后面的语句,执行完后跳出case结构

如果没有与表达式相等的分支项,则执行default后面的语句,且default只有一项。

例子如下,注意写法,冒号等写法:

case(rega)
	2'b00: res = 4'b1110;
	2'b01: res = 4'b1101;
	2'b10: res = 4'b1011;
	2'b11: res = 4'b0111;
	2'bx,
	2'bz: res = 4'bx;
	default: begin 
				res = 4'bx;
				$display("Input is wrong.");
			end
endcase

注意HDL中的case与C++中的switch…case有着很大的区别,首先是写法:

switch(grade)
   {    
   	 case 'A' :   cout << "很棒!" << endl; break;  
      case 'B' :   
      case 'C' : cout << "做得好" << endl; break; 
      case 'D' : cout << "您通过了" << endl; break;  
      case 'F' : cout << "最好再试一下" << endl; break;  
      default :  cout << "无效的成绩" << endl;  
   }  

然后HDL中case执行完对应的语句之后直接跳出,而C++的switch则是执行完某个case之后会继续执行下一个case的内容,直到遇到break才会跳出switch。
HDL中的case与状态机的原理是对应的:状态机就是在某个状态下经过某个条件转换到下一个状态,所以case语句在找到分支之后就直接跳出,而不会再执行下一个分支。

casez 与 casex

这两种语句是为了处理比较过程中不必考虑的情况

casez不考虑高阻值z的比较过程,即 控制表达式或分支表达式 的某个bit出现z,该bit就不再参与比较,但x还是要进行严格比较的
例如:

casez(ir)
	4'bzzz1: out = a;
	4'bzz1z: out = b;
	4'bz1zz: out = c;
	default: out = d;
endcase

但存在一个问题:如果存在多个相符的分支,该如何判定执行哪个?例如上述代码中ir = 4'bzzzz

注意case不会出现这种情况,因为case要求对应的bit严格相等才行,x必须与x对应,z也必须与z对应

答案是最上面的分支语句被执行,若ir = 4'bzzzz虽然与4'bzzz14'bzz1z4'bz1zz都匹配但out = a,也就是说系统的匹配检查是从第一个语句开始依次检查的。结果可参考Verilog语法有关casez和casex的分析。

而casex则表示z和x都被视为不必关心的情况。

2.6.4. 循环语句(while,for)

这两个语句与C中的循环语句相同,各子循环按顺序执行,但注意使用块语句begin…end。

while(temp)
	begin
		if(temp[0])
			count = count + 1;
	end

for(integer i = 0;i <= 10;i = i + 1)
	temp[i] = 0;

再次复习一下for循环各表达式的执行顺序:

若定义:
for(表达式1;表达式2;表达式3) 循环语句;

成立
不成立
表达式1
表达式2
循环语句
表达式3
跳出循环

2.6.5. 赋值语句

即将某个值赋给某个量,包括两种方式:阻塞赋值和非阻塞赋值。

阻塞赋值 =
例如a = b;表示在执行该语句的时候直接计算b的值,并 立刻改变 a的值。

这个与C语言是相同的,并且下面再用到a时,使用的是新值。

但是需要注意的是verilog的并行执行的特点有时会产生竞争与冒险

always@(posedge clk)
	y1 = y2;

always@(posedge clk)
	y2 = 0;

在上述代码中当clk上升沿的时候,y1 = y2;y2 = 0;应是同时执行的,而系统内部实际的执行顺序是不确定的,不同的顺序会导致不同的结果。

注意阻塞赋值包括计算右侧值 + 赋予左侧变量 两个步骤,执行这两个步骤时绝不允许任何其他其他语句的干扰,阻塞的含义就在于此。

非阻塞赋值 <=

非阻塞赋值的符号与小于等于的符号是相同的。例如a<=b;表示先计算b的值,直到块结束之后才改变a的值。

所以在块内的下面的语句用的a值是旧值。

阻塞赋值 = 与 非阻塞赋值 <=

关键在于赋值操作是何时实现的,从下面这个例子可以看出区别:

module BlockAndUnblock;

integer a,b,c;
reg clk;
initial
	begin
		clk = 0;
		a = 1;
		b = 2;
		c = 3;
	end

assign #10 clk = ~clk;

always@(posedge clk)
	begin
		b <= a;		//阻塞赋值就为 b = a;
		c <= b;		//阻塞赋值就为 c = b;
	end
	
endmodule

如果是非阻塞赋值,在一个clk上升沿到来时,b的值为a的值,c的值为b的旧值,综合的电路如下:

Verilog HDL_第5张图片

但如果是阻塞赋值(注释),在上升沿来了之后,b和c均为a的值,综合的电路如下:

Verilog HDL_第6张图片
也就是说在always模块中,如果是阻塞赋值,效果就可以概括为时钟到来时,赋值结果直接完成,表达的是组合逻辑(该时刻的输出仅仅与该时刻的输入有关)

如果在always模块中采用非阻塞赋值,效果就是时钟到来时,每个赋值操作含有旧值(例如c<=b;这一句),因此表达的是时序逻辑(该时刻的输出与原来电路的状态有关)

此处这么理解,还是上面模块BlockAndUnblock的例子,将a看作输入c看作输出,其余部分看作电路,b就为电路内部的量。
当clk上升沿到来之后,采取阻塞赋值c就是a的值(组合逻辑),而采取非阻塞赋值c的结果不是a的值,而是另一个电路内部的原来的值b(时序逻辑)。

因此得到结论:建立时序逻辑电路模型时,用非阻塞赋值;建立组合逻辑电路模型时,用阻塞赋值;时序和组合逻辑电路模型时,用非阻塞赋值。

2.7. 函数

系统函数

一些常见的系统函数如下

Verilog HDL_第7张图片

以及最重要的 $clog2(),注意这是个向上取整函数

2.8. 任务

2.9. 编译预处理

3. 流水线设计技术(Pipeline)

如果一件事情需要好几个阶段一步一步地完成,各个步骤之间没有反馈,而且这件事情需要重复做很多次,就可以使用pipeline。

pipeline的核心思想是若前一个事件的某个阶段已经完成,则立即进行下一个事件的该阶段工作

例如有一家咖啡吧有客人ABCDE依次排队买套餐。
一般为客人供给食物的策略是:员工甲放个盘子,员工乙装上薯条,员工丙放上豌豆,老板最后配上一杯饮料,完成对客人A的服务,然后再服务下一位客人B服务,顺序依次。
但是这样的策略有个问题:员工甲给了客人盘子之后,就一直闲着直到该客人套餐购买完全结束,才为下一个客人服务。其他员工同样存在相同的问题
而pipeline的策略是:在甲为客人A放完盘子之后,为客人B放盘子,再为客人C放盘子,直到客人E。其他员工也是这样的策略。

3.1. 组合逻辑模块中 使用Pipeline

与核心思想类似,可将一个组合逻辑电路分为好几个级,这些级只有前馈没有反馈。

一般情况下是对于某个输入,该电路的所有级全部处理完输出结果之后,再更换新的输入再运行。

而使用pipeline的方法是:在每一级之后插入寄存器组暂存数据,所有寄存器同步触发

下面分析这样做的好处,如下图所示是否采用pipeline结构示意图:

Verilog HDL_第8张图片

在采用了pipeline结构时,考虑每个 组合逻辑级传输延迟 T p d T_{pd} Tpd寄存器传输延迟 T c o T_{co} Tco时钟周期 T c l k T_{clk} Tclk,时序图为:

Verilog HDL_第9张图片

可以看出,组合逻辑中并不是整体处理完输入a之后才处理输入b,而是每一级处理完a在下一个脉冲到来时直接处理b。

从图中可以看出,在输出 K ( J ( F ( a ) ) ) K(J(F(a))) K(J(F(a)))时消耗了很长时间,但是在此之后每来一个时钟就会输出一个值。

注意 T p d + T c o < T c l k T_{pd}+T_{co}Tpd+Tco<Tclk,这样才能保证每个时钟周期都能够正常的流动结果,即保证建立时间

就此提出以下概念:

首次延迟: 从开始输入第一个值到该值输出 所消耗的时间。

吞吐延迟: 每个输出之间的时间间隔。

并给出以下表格(忽略触发器的建立时间):

项目 不使用pipeline 使用pipeline
首次延迟 3 T p d 3 T_{pd} 3Tpd 最大为 3 T c l k + T c o + T p d 3 T_{clk}+T_{co}+T_{pd} 3Tclk+Tco+Tpd
吞吐延迟 3 T p d 3 T_{pd} 3Tpd T c l k T_{clk} Tclk

所以如果组合逻辑非常冗长,即 3 T p d > > T c l k 3 T_{pd}>>T_{clk} 3Tpd>>Tclk,则数据的输入时间间隔or输出时间间隔就很长,吞吐量就很小。

但如果采用了pipeline,数据的输入时间间隔or输出时间间隔被控制在 T c l k T_{clk} Tclk以内,即短时间内输入or输出多个数据,因此提高了吞吐量

4. 有限状态机

对于时序电路而言,触发器是必不可少的元件,有了触发器才能够实现按照时钟的时序控制。

实际上,每一拍(时钟有效沿)的控制都可看作是电路状态的转换,类似于离散时间状态方程:

x ( k + 1 ) = A x ( k ) + B u ( k ) x(k+1)=Ax(k)+Bu(k) x(k+1)=Ax(k)+Bu(k)

而如果无论怎么控制,数字电路的状态都是有限的,且均是基于时钟沿进行转换的,这就构成了有限状态机。

4.1. 有限状态机的Verilog描述

此处给出标准的状态机Verilog模块写法,状态转移图如下所示:

Verilog HDL_第10张图片

方框表示状态名称,箭头表示状态转移,箭头上的标注表示:转移条件/输出结果。

建议的Verilog语言如下:

module FSM(
	input clk,
	input reset,
	input A,

	output reg K1,
	output reg K2
);

reg [3:0] state;
状态码编写///
parameter Idle = 4'b0001,
		  Start = 4'b0010,
		  Stop = 4'b0100,
		  Clear = 4'b1000;

仅状态转移逻辑///
always@(posedge clk)
begin
	if(reset)
		state <= Idle;
	else
		case(state)
			Idle:if(A)
					state <= Start;
				else
					state <= Idle;
			Start:if(!A)
					state <= Stop;
				else
					state <= Start;
			Stop:if(A)
					state <= Clear;
				else
					state <= Stop;
			Clear:if(!A)
					state <= Idle;
				else
					state <= Clear;
			default:state <= 4'bxxxx;
		endcase
end
仅输出逻辑///
always@(state or reset or A)
	if(!reset)
		K1 = 0;
	else if(state == Clear && !A)
			K1 = 1;
		else
			K1 = 0;

always@(state or reset or A)
	if(!reset)
		K2 = 0;
	else if(state == Stop && A)
			K2 = 1;
		else
			K2 = 0;
endmodule

下面总结写状态机的几个注意点:

● 使用parameter确定状态码, 状态码尽量采用独热码,即只有一位为1的编码形式

这里说明以下格雷码和独热码。
格雷码:相邻的代码中只有一bit不同,例如十进制1到5就为000,001,011,010,110,111
其优势在于相邻数字的变化均只对应一个bit变化,相比于普通的二进制码,可靠性高错误率低。比如二进制码从0111到1000变化过程中,可能出现类似1100的中间状态,进而可能引起电路不稳定,而格雷码就没有这个问题。
独热码:只有一bit为高的编码,例如00000,00001,00010,00100,01000,10000
优势也是显而易见,只需比较一bit即可得到结果,但需要消耗更多触发器,然而会节省很多组合逻辑。

对于状态机来说,如果用独热码只需比较对应的bit来确定在哪个状态即可,例如上面的代码中只需根据state[0] == 1即可判断当前状态是否为Idle。但是格雷码or二进制码就得每一位都要比较,消耗很多逻辑。
FPGA内部有丰富的Slice,每个Slice有几个FF,所以FPGA不缺触发器的,故使用独热码更好。

● 大型状态机,可将状态转移always逻辑和输出always逻辑分开写

case语句必须加入default,其状态编码为’bx

有同步or异步复位端

你可能感兴趣的:(数字IC设计方法学,verilog,systemverilog,fpga/cpld,asic,芯片)