Verilog语法整理

一、Verilog数据类型

1.1 wire类型

wire类型用于表示硬件电路单元之间的物理连线。

• 未声明的信号类型默认为wire

比如下面的这种情况，默认定义为wire型
module key(
    input clk_i,		//默认wire
    input key_i,		//默认wire
    output key_cap		//默认wire，不允许在always块中赋值
);
endmodule

• wire不允许在always块内部定义和赋值，但可以在always块使用非阻塞赋值<=取其数值
• 常用在always块外部用assign连续赋值（硬件相连）

eg：

module d_flip_flop(		//以D触发器为例，输出信号有reg，也有wire，以说明其赋值操作的区别
	input wire clk,		
    input wire rst_n，
    input wire D,		//wire型输入
    output reg Q_reg,	//reg型输出
    output wire Q_wire	//wire型输出
);
    
reg Q_0= 1'd0;			//定义内部变量
    
always@(posedge clk or negedge rst_n) begin
    if(!rst_n) begin	//复位
        Q_reg <= 1'd1;
        Q_0 <= 1'd0;
    end
    else begin
        Q_reg <= D;		//wire类型可以在always块中使用非阻塞赋值取其数值
        Q_0 <= !D;
    end
end
    
assign Q_wire = Q_0;	//对wire类型的赋值需要在always块外部进行
endmodule

1.2 reg类型、integer整数、real实数

verilog中数值表达形式为：(位宽)’(进制)(数值) 比如【4’d1】。

• reg 类型的变量只能在 always 或 initial 中赋值，因此给reg变量赋初值一般在if(!rst_n) begin里面，或者在定义的时候直接赋值，reg [5:0] LED = 6'b000001;
• reg类型不能在 assign 语句中赋值，因为那是给 wire 类型用的。

b	二进制
o	八进制
d	十进制
h	十六进制

reg d = 4'b0001;
real e = 3.14;
integer f = 3e2;	//3*10^2=300 

• 这里有一个比较重要的问题：给a赋值15的时候为什么尽量不要用a<=15;来赋值，而是使用a<=5'd15;。

  可以看下面的示例↓

wire [3:0] a;
assign a = 15;     // 实际是 32'd15 → 截断 → 4'b1111
assign a = 16;     // 实际是 32'd16 → 截断 → 4'b0000 (!)
assign a = 4'd16;  // 编译报错 (因为 16 超过 4 位能表示的范围)
所以尽量使用清楚的赋值，可以减少未来不可见的一些bug

1.3 数组（一维向量、二维向量（类矩阵））

数组问题主要有：

• 一维数组操作（赋值、按位赋值、拼接）
• 二维数组操作（赋值、取值）

module xxx(
    input wire [7:0] a,		//8位宽数组（一维向量）
    output reg [15:0] b,	//16位宽数组
    output reg [7:0] c		//8位宽数组
);
reg [7:0] d [3:0];		//定义4个8位宽数据 d[0]-d[3]
    
wire [7:0] d2_full;		
wire       bit_d3_5;
wire [7:0] d0_shifted;
    
//一维数组操作    
always@(*) begin
    //一维数组赋值
    b = 16'b1111_1110_1101_1100;	//  a = 8'b1010_1010;这个是非法操作，input不能赋值
    
    //一维数组的按位赋值
    c = b[15:8];             // 截取b的高8位输出
    c[7:1] = a[6:0];         // 截取赋值
    
    //一维数组拼接
    b = {a[7:0] , b[15:8]};		//b=16'b1010_1010_1111_1110
end
    
//二维数组操作
always@(*) begin
    //二维数组赋值
    d[0] = 8'b0000_0001;d[1] = 8'b0000_0010;d[2] = 8'b0000_0011;d[3] = 8'b0000_0100;	//正常来说应该放到initial块中
end

    //二维数组取值
assign d2_full = d[2];		//取d的第二个数据（8位）放到d2_full里
assign bit_d3_5 = d[3][5];		//取d的第三个数据的第五位，即0
assign d0_shifted = d[0] << 1;	//将d[0]左移一位放到d0_shifted里
    
endmodule

    // ========== 二维数组初始化（initial 块） ==========
initial begin
    d[0] = 8'b0000_0001;
    d[1] = 8'b0000_0010;
    d[2] = 8'b0000_0011;
    d[3] = 8'b0000_0100;
end

1.4 parameter参数、localparam内部参数

parameter用于声明设计参数，是一个常量，不支持小数。当代码多次使用同一个参数时（比如计时器的计数上限值），一个个修改起来较为麻烦，可以通过定义需要修改的变量为 parameter 参数类型，例化模块时直接设置 parameter 即可。

//子模块里面
module timer #(
    parameter time_count = 26'd24_999_999,  // 计数上限（常量，不能为小数）
    parameter width      = 8                // 数据位宽
)(
    input wire clk,
	...
);

//母模块里面例化
timer #(
    .time_count (26'd24_999_99)		//这里给子模块的parameter赋值
    .width (8)
) timer_例化名(			//后面的timer_lihua是例化名
	.clk (clk),
	...
);	

此外还有另外一种用 defparam 进行参数设置的方法，例如例化同一模块使用不同的参数：

timer timer_例化名(     //先不例化，等后面用defparam例化     
	.clk (clk),
	...
)
defparam timer_l.time_count = 26'd24_999_999;

localparam 用于在模块内部定义常量，其值在模块实例化时是固定的，无法被修改。用法同parameter 一致。但是与相比 parameter 而言 localparam 更严格，因为它只在定义的模块内部有效，不会影响外部模块。

module xxx(
	input wire clk,
    ...
);

    // ======= localparam 通常放在端口声明之后，逻辑代码之前 =======
    localparam time_count = 26'd24_999_999;  // 计数上限（仅模块内部使用）
    localparam width      = 8;               // 数据宽度

    // 后续逻辑可以使用 time_count 和 width
    reg [width-1:0] counter;

    // ...
endmodule

1.5 genvar变量

genvar i是Verilog和System Verilog中用于generate语句块的专用变量声明。

生命周期：只在generate内部生效，只在Elaborate（展开）过程起作用。

完整的设计周期包括：Elaborate→Synthesis→Implementation→generate bitstream

Elaborate之后，genvar变量就消失了

eg：

genvar i;
generate for (i=0;i<8;i=i+1) begin
    IIR u_IIR(.a(a[i]))
end
endgenerate

以上代码Elaborate之后会变成：

IIR u_IIR0(.a(a[0]));
IIR u_IIR0(.a(a[1]));
...
IIR u_IIR0(.a(a[7]));

从此以后，genvar变量就消失了。

那么为什么要用genvar变量呢？

genvar的唯一作用就是：在编译期批量生成可重复的硬件结构，使10行代码可以生成成百上千个真实的并行电路。

如果不用genvar：代码行数多不易读，任何端口名改一次，都要同步改很多遍，其中里面如果有一个端口有错误，代码就无法运行。

---

因此genvar不是时间循环，而是空间复制

1.6 Verilog 属性（attribute）声明

(* ... *) 是 属性语法

在 Verilog / SystemVerilog 中：

(* attribute_name = value *)

表示给后面的对象加一个“工具属性”，这个工具属性仅服务于综合、实现、调试，不服务于仿真。

常见的一些属性如下：

(* MARK_DEBUG="true" *) reg  state;
(* MARK_DEBUG="true" *) wire [8:0] CNTVALUEOUT;
(* DONT_TOUCH = "true" *) reg [7:0] Q_data;

属性	作用
MARK_DEBUG	保留 + 可被 ILA 探针
DONT_TOUCH	禁止综合器改动

MARK_DEBUG="true" 的作用：强制把这个信号保留下来，并允许被 ILA / Debug Core 观察。也就是告诉 Vivado：这个信号是“我想调试的”，防止综合优化把它删掉、合并掉

二、运算符

2.1 算数运算符

加：+ 减：- 乘：* 除：/ 取余：%

取余运算两侧数据必须是整数数据。

2.2 赋值运算符（阻塞赋值与非阻塞赋值）

= : 阻塞赋值	//前面赋值语句会阻塞后面的语句，按照顺序运行
<= : 非阻塞赋值	//所有非阻塞赋值会同时进行

注意：所有阻塞赋值与非阻塞赋值左边必须是变量数据类型，可以是reg、integer、real。右边可以是任何有效的表达式或信号
此外还有连续赋值（连线）assign：用于表示组合逻辑，左侧必须是wire或tri，右侧值变化，左侧数值立即更新。

2.3 比大小运算符

a < b  ：a小于b
a > b  ：a大于b
a == b ：a等于b
a != b ：a不等于b
a <= b ：a小于等于b
a >= b ：a大于等于b

2.4 逻辑运算符

&&：逻辑与：a&&b，a和b同时为真时才为真，否则为假
||：逻辑或：a||b，a和b同时为假时才为假，否则为真
! ：a为真时，!a为假

2.5 条件运算符

a = (条件) ? b : c;	//条件为真:a=b，条件为假：a=c
[eg: a = (b <= c) ? 1'b1 : 1'b0;	//b小于等于c时，a=1,否则，a=0

比较常用的条件运算符使用情况：
 assign a = (b) ? 4'b1 : 4'b0;

2.6 位运算符

~ : 按位取反	//a=1001 ~a=0110
& : 按位与		//a=1001 b=0001 a&b=0001
| : 按位或		//a=1001 b=0001 a|b=1001
^ : 按位异或xor 两个输入值不同时，输出1，否则输出0，即同为0，异为1		//a=1001 b=0001 a^b=1000
^~ : 按位同或xnor 两个输入值相同时，输出1，否则输出0，即同为1，异为0	//a=1001 b=0001 a^~b=0111

2.7 移位运算符

reg [3:0] a,c;
reg [5:0] b;
a = 4'b1001;
b = a<<2;
c = a>>2;
a = a<<2;

2.8 归约运算符（实现奇偶校验）

归约的操作数只有一个，实现该操作数所有位的运算，得到结果为一位
&  : 归约与           a=1101  b = &a （b = 1 & 1 & 0 & 1 = 0）
|  : 归约或           a=1101  b = |a （b = 1 | 1 | 0 | 1 = 1）
^  : 归约异或		  a=1101  b = ^a （b = 1 ^ 1 ^ 0 ^ 1 = 1） 从高位开始往低位异或
 
(归约异或可简单实现奇偶校验的逻辑)

三、语法与语句

3.1 always语句

• 组合逻辑：always@(*) 或 assign
• 时序逻辑：always@(posedge clk or negedge rst_n)

3.2 if语句

if (条件1) begin
    执行1;
end
else if (条件2) begin
    执行2;
end
else if (条件3) begin
    执行3;
end
else begin	//一定要加else begin，防止综合生成latch锁存器
    执行保护语句;
end

3.3 case语句

case(sel)
    2'd0 : begin 
        dout = a; 
    end
    2'd1 : begin
        dout = b;
    end
    2'd2 : begin
        dout = c;
    end
    2'd3 : begin
        dout = d;
    end
    default : begin		//其他情况，条件列完写default(里面可写复位操作防止出错)
        dout = 0;
    end		
endcase
//如果执行内容一样可以使用逗号(,)省略写。	eg: 2'd0, 2'd1 : dout = c

3.4 for语句

integer i,j;需要先声明整型变量i,j
 
------------------------------------------普通循环
for (i=0; i<2; i=i+1) begin  (循环变量赋初值; 执行条件; 循环变量自增/减)     
    循环体
end
 
------------------------------------------嵌套循环
for (j=0; j<2; j=j+1) begin   
    for (i=0; i<2; i=i+1) begin 
        循环体
    end
end

注意：如果一个语句块有两个 for 循环(比如一个 if 语句 的 begin end内),需要使用不同的循环变量分开(如 i 和 j)，但是如果两个for循环若分别在 if 和 else if 中就没问题：

if (条件1) begin
    integer i;
    for (i = 0; i < 4; i = i + 1) begin
        $display("Block A: %d", i);
    end
end 
else if (条件2) begin
    integer i;
    for (i = 0; i < 4; i = i + 1) begin
        $display("Block B: %d", i);  //作用域分开，不冲突
    end
end

3.5 typedef、enum、logic语句

• 这三个语句只能用于.sv文件，即SystemVerilog，.v文件用不了

typedef：类型重定义关键字 //作用：用于给一个类型取一个别名。
eg:
typedef enum logic [1:0] { ... } state_t;	//将一个枚举类型的逻辑值enum logic [1:0]定义成一个新的类型名，叫做state_t，凡是使用state_t进行定义的变量，其取值是一个列表，这个列表即为枚举类型的logic [1:0]，类似于单片机的typedef。
state_t current_state, next_state;
———————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
enum：枚举类型	// 作用：用于定义一组离散的、有名字的常量值，常用于状态机状态描述。
eg：
enum logic [1:0] {
    IDLE = 2'd0,
    S1   = 2'd1,
    S2   = 2'd2
}
//这里就定义了三个状态，分别命名为 IDLE、S1、S2，它们的值分别是 2'd0、2'd1、2'd2。
//相比传统的 localparam 写法，enum 语义更加清晰，表达的是一组状态集合，易读性和可维护性更高。
———————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
logic：新型变量类型	//作用：表示一个可以被多个驱动源控制的逻辑值，替代 Verilog 中的 reg 类型。
eg:
logic [1:0]		//等价于传统 Verilog 中的：reg [1:0]
//但 logic 是 SystemVerilog 推荐使用的现代写法，它避免了 reg 在组合逻辑中使用带来的语义混乱，更加通用、规范。
———————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
综合起来：
typedef enum logic [1:0] { 
    IDLE = 2'd0, 
    S1 = 2'd1, 
    S2 = 2'd2 
} state_t;
state_t current_state, next_state;
//可以翻译为：我定义了一个名字叫 state_t 的类型，它是一个 2 位宽的逻辑枚举类型，表示状态集合：IDLE、S1、S2。

3.6 generate if语句

条件调试逻辑generate if ：

在开发过程中，很多调试信号仅在验证阶段使用，最终综合时并不需要。这时，我们可以通过 generate if 语句控制 ILA 的插入，做到**“调试时打开，发布时关闭”**。

注意！！ generate if 是在综合前进行判断的静态条件语句。它依赖的通常是 parameter 等常量，综合工具只会根据条件选择其中一个分支进行综合，另一个分支不会生成逻辑电路。

举个例子：如果我写了两套互斥的逻辑 代码1 和 代码2，用 generate if 来选择哪套逻辑启用，最终综合时只会保留符合条件的那一套，不会像运行时 if 那样生成两套电路。因此，generate if 是控制代码结构的工具，而不是条件执行逻辑，它不会带来额外的电路资源浪费。

应用eg:

module Clk_Divider#
(
parameter DEBUG_ENABLE = 1'b1
)
(...
);
...
generate
  if (DEBUG_ENABLE == 1'b1) begin : debugcore
    // 添加 ILA IP，ChipScope 观察信号
    ila_0 ila_0_0 (
      .clk(clk_i),                                 // ILA 时钟
      .probe0(div2hz_o),                           // 输入探针 0
      .probe1({div2_o, div3_o, div4_o, div8_o})    // 输入探针 1，宽度为4
    );
  end
endgenerate

上述代码的核心思想是：仅在 DEBUG_ENABLE 为 1 时实例化 ILA IP，从而避免在正式交付中引入多余逻辑。该方式适用于 RTL 层面灵活插入调试器，并通过参数或宏开关控制启用状态。

四、三段式状态机

4.1 状态机结构简介

状态机Finite State Machine（有限状态机），一般有三种编码方式：

• 一段式状态机
  状态定义、状态转移、输出逻辑全部写在一个 always 块中，代码简单，但不利于维护和综合优化。
• 二段式状态机
  状态转移与输出逻辑分开写，有两个 always 块，适合纯组合输出的场景。
• 三段式状态机（推荐使用）
  状态寄存、状态转移、输出逻辑三块分开写，结构清晰，是最常用的写法，也是企业开发中最推荐的规范写法。

4.2 三段式状态机思路

三段式状态机包含以下三部分：

1. 第一段：状态寄存（时序逻辑）
   负责状态的寄存，用于记录当前状态（current_state）。
2. 第二段：状态转移逻辑（组合逻辑）
   根据输入和当前状态决定下一状态（next_state）。
3. 第三段：输出逻辑（组合逻辑 或 时序逻辑）
   根据当前状态和输入生成对应输出。

4.3 三段式状态机 Verilog 示例

功能描述：
设计一个有限三段式状态机，输入 in，当检测到连续两个 1 时输出 out=1，否则输出 0。

• 子模块定义：fsm_detector.v

module fsm_detector (
    input wire clk,
    input wire rst_n,
    input wire in,
    output reg out
);

    // 状态编码（使用 localparam）
    localparam IDLE = 2'd0;
    localparam S1   = 2'd1;
    localparam S2   = 2'd2;

    // 状态寄存器定义
    reg [1:0] current_state, next_state;

    // 第一段：状态寄存（同步时序）
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n)
            current_state <= IDLE;
        else
            current_state <= next_state;
    end

    // 第二段：状态转移逻辑（组合逻辑）
    always @(*) begin
        case (current_state)
            IDLE:    next_state = (in == 1'b1) ? S1 : IDLE;
            S1:      next_state = (in == 1'b1) ? S2 : IDLE;
            S2:      next_state = (in == 1'b1) ? S2 : IDLE;
            default: next_state = IDLE;
        endcase
    end

    // 第三段：输出逻辑（组合逻辑 或 时序逻辑）
    always @(*) begin	//这里也可以改成(posedge clk or negedge rst_n)
        case (current_state)
            S2:      out = 1'b1;
            default: out = 1'b0;
        endcase
    end

endmodule

时钟周期	Current State	Input in	Next State	Output out
1	IDLE	1	S1	0
2	S1	1	S2	0
3	S2	0	IDLE	1
4	IDLE	0	IDLE	0
5	IDLE	1	S1	0
6	S1	1	S2	0
7	S2	1	S2	1
8	S2	0	IDLE	1

4.4 全都要用三段式状态机吗？

先说结论：并不是

情况1：代码逻辑极其简单

​ 这种情况下可以直接用简单逻辑实现，根本不需要加状态机

情况2：代码逻辑较为复杂（eg：uart的tx与rx逻辑）

​ 这种情况下可以选择多个三段式结合、三段式+两段式、三段式+零碎语句来实现，比如uart.v中的tx使用一个三段式状态机，rx使用一个三段式状态机，其余的零碎的计时器或分频器占用一个状态机或一个always块或直接再写一个.v底层模块，专门用来实现。

情况3：代码逻辑极其复杂（eg：spi的tx与rx逻辑）

​ 这种情况下尽量选择多模块设计，tx与rx分别分开写成两个.v文件，其余模块也分别使用别的.v文件实现，最终使用top作为顶层，依次例化连接，或者也可以直接封装为IP核，接线即可。

五、testbench仿真模块

5.1 语法问题

testbench之前会将之前所有代码看做成一个模块，这个模块里面会层层套很多模块，但是最终形成最大的那个模块会只有n个输入in，和m个输出out，testbench里，我们会将这n个输入都伺候好（一般使用reg来给赋值），并将m个输出都接出来（一般使用wire类型来接），最终通过仿真时序图来观察代码逻辑写的是否正确。

下面是testbench常用的架构：

`timescale 1ns / 1ps           //timescale 时间单位/精度

module tb_module_name();	//通常无输入无输出

1. 声明信号（wire/reg）	//input对应reg型、output对应wire型

2. 实例化待测模块		//例化

3. 产生时钟

4. 初始化输入信号与开始仿真
initial begin

    $finish;
end

endmodule

testbench区别于普通.v和.sv文件，常用tb_xxx.v来命名，其也有一些特殊的语法，常用的有：

指令	功能说明
$display()	单次打印
$monitor()	自动追踪变量变化打印
$time	获取当前仿真时间(64位int型)
$finish	停止仿真
$stop	暂停仿真（可调试）
$dumpfile/$dumpvars	波形输出（配合 GTKWave）
forever	=while(1) 会一直执行内部语句、注意：一个initial块只能有一个forever
$random/$random %n/{$random} %n	产生随机数/产生-n到n的随机数/产生0到n的随机数
$readmemh/$readmemb	读取文件16进制数据/读取文件2进制数据 eg：$readmemh("D:/mem.dat",memory); 读.dat文件并放到reg型memory中 |$
在这之后，还有一些常用的进阶仿真技巧语法：

1. 自动打印状态值：

initial begin
    $monitor("time=%0t | clk=%b rst_n=%b in=%b out=%b", $time, clk, rst_n, in, out);
end

2. 文件输出波形：

initial begin
    $dumpfile("waveform.vcd");		 // 指定生成的波形文件名（必须是 .vcd 格式）
    $dumpvars(0, tb_module_name);	//指定要记录的信号层次（0 表示当前模块及其所有子模块）
end

​ 生成后使用命令打开：

gtkwave waveform.vcd

3. for循环生成输入激励

integer i;
reg [7:0] input_seq = 8'b11001110;

initial begin
    rst_n = 0; in = 0;
    #20 rst_n = 1;

    for (i = 7; i >= 0; i = i - 1) begin	//这个for循环可以放到initial begin里面
        in = input_seq[i];
        #10;
    end

    $finish;
end

4. 两种生成50%占空比的时钟

第一种：使用forever语句
initial begin
    begin
        clk_i=0;
        forever #(clk_period/2) clk=~clk;
    end
end

第二种：使用always块
initial begin
    clk=0;
end
always #(clk_period/2) clk=~clk;

5. 使用 $readmemh 读取文件数据（激励文件驱动）

reg [7:0] mem [0:15];
initial begin
    $readmemh("input_data.txt", mem);	//读取input_data的数据放到mem矩阵（二维向量）里
end

5.2 代码示例

`timescale 1ns / 1ps           //timescale 时间单位/精度

module tb_module_name;

    // 1. 声明信号（wire/reg）
    reg clk;
    reg rst_n;
    reg in;
    wire out;

    // 2. 实例化待测模块
    xxx u_xxx (
        .clk(clk),
        .rst_n(rst_n),
        .in(in),
        .out(out)
    );

    // 3. 产生时钟
    initial begin
        clk = 0;
        forever #5 clk = ~clk;  // 10ns 时钟周期
    end

    // 4. 初始化输入信号与测试激励
    initial begin
        rst_n = 0;
        in = 0;
        #20;
        rst_n = 1;

        #10 in = 1;
        #10 in = 1;
        #10 in = 0;
        #10 in = 0;
        #10 in = 1;
        #10 in = 1;
        #10 in = 1;
        #10 in = 0;
        #10;

        $finish;
    end
    
//进阶
    // 打印信号变化
    initial begin
        $monitor("Time: %0t | in=%b | out=%b", $time, in, out);
    end

    // 输出波形文件
    initial begin
        $dumpfile("waveform.vcd");
        $dumpvars(0, tb_fsm_detector);
    end

endmodule

5.3 注意事项

建议	原因
永远不要在 Testbench 中用 always @ 写激励	会影响模拟流程，推荐全部写在 initial 中
分时序写激励，每段之间 #	模拟时间推进，需要 # 控制节拍
使用 $monitor 跟踪变量变化	方便调试输出
建议所有信号初值在仿真前显式赋值(都要尽量赋初值)	防止仿真中出现 x 状态

注意事项
`timescale 接时间单位/精度，#10即表示延时10个时间单位，支持计算形式：#(2*5)
仿真模块一般没有端口列表（input/output），通常输入信号为自定义为reg类型，而输出则定义为wire类型
模块例化：仿真模块相当于顶层文件，将待仿真模块例化后再进行验证，例化名可自定义

六、xdc文件语法

6.1 时钟语法

create_clock -name <名称> -period <周期> [get_ports <端口名>]

eg: create_clock -name sys_clk -period 10 [get_ports PL_CLK_P]

这句是时序分析的基础设置，告诉 Vivado 工具：PL_CLK_P这个端口是一个时钟源，且时钟频率为100MHz（周期10ns）。

只需对正向时钟（如 PL_CLK_P）写一次 create_clock，负向脚自动识别。

进阶篇（未完善）：时序约束与时钟分析

1. 时钟相关属性

• create_generated_clock
• set_clock_groups -asynchronous
• set_clock_latency, set_clock_uncertainty

2. 输入/输出时序约束

• set_input_delay / set_output_delay
• set_input_jitter, set_input_transition
• 对 IO 标准与板级延迟的建模

3. 路径约束（路径排除/限定）

• set_false_path
• set_max_delay / set_min_delay
• set_multicycle_path

6.2 绑定引脚

set_property PACKAGE_PIN <引脚名> [get_ports <端口名>]

eg: set_property PACKAGE_PIN F10 [get_ports {LED[0]}]

绑定引脚是为了将 Verilog 中定义的逻辑端口（v语言定义的）绑定到实际芯片封装上的物理管脚，这是使信号真正进入/输出芯片的关键步骤，没绑定=信号进不来/出不去。

命令名	作用对象	使用阶段	常见用途	示例
get_ports	顶层设计的端口（Verilog 中的 input/output）	综合前（前端约束）	引脚绑定、IO 电压、时钟创建等	get_ports clk
get_cells	设计中的逻辑单元（触发器、模块实例）	综合后（后端约束）	锁定资源、设置属性	get_cells u_led_reg
get_nets	网络连接（连线）	综合后	分析路径、添加布线或时序约束	get_nets clk_net

6.3 IO电平标准定义

set_property IOSTANDARD <标准名> [get_ports <端口名>]

eg1:单端接口
set_property IOSTANDARD LVCMOS18 [get_ports {LED[0]}]

eg2:差分接口
set_property IOSTANDARD DIFF_SSTL12 [get_ports clk_p]
set_property IOSTANDARD DIFF_SSTL12 [get_ports clk_n]

eg3:同时约束多个端口
set_property IOSTANDARD LVCMOS18 [get_ports {LED[*]}]

名称	电压(V)	差分	用途说明
LVCMOS18	1.8	否	常用于普通 GPIO，常见于 1.8V 供电系统
LVCMOS33	3.3	否	通用低速 IO，比如按钮、LED
LVCMOS25	2.5	否	适用于 2.5V 供电外设
SSTL15	1.5	否	DDR 控制器，单端 DDR 信号
SSTL18	1.8	否	DDR2 控制器，非差分使用
SSTL15_II	1.5	否	类似 SSTL15，带双边驱动
HSTL_I	1.5	否	高频信号通信
HSTL_II	1.5	否	高速 SDR/DDR 信号
DIFF_SSTL12	1.2	是	DDR3/DDR4 差分时钟/命令信号
DIFF_HSTL_I	1.5	是	差分高速 IO
DIFF_HSTL_II	1.5	是	DDR 或高性能 ADC 差分信号
LVDS	~1.2	是	低压差分信号，适合高速数据传输（如 ADC/DAC）
SUBLVDS	~1.2	是	亚 LVDS，功耗更低，常用于图像传感器
TMDS_33	3.3	是	HDMI/DVI 数字视频信号
MIPI_DPHY_DCI	1.2	是	MIPI CSI/DSI 差分接口，用于摄像头、屏幕

6.4 IO口控制

属性名	功能	常用取值	建议用法
PULLUP / PULLDOWN	上/下拉电阻	true / false	输入悬空或按键使用
SLEW	信号边沿速率	FAST / SLOW	高速信号用 FAST，排线建议 SLOW
DRIVE	驱动能力（电流）	2~24（mA）	驱动 LED 或高阻输入
OUTPUT_IMPEDANCE	输出阻抗匹配	50 / 75 等	高速信号布线匹配
DIFF_TERM	差分终端匹配电阻	TRUE / FALSE	差分输入时使用

1. PULLUP / PULLDOWN

   eg:
   set_property PULLUP true [get_ports btn]
   set_property PULLDOWN true [get_ports rst_n]

   PULLUP：给 IO 口内部接一个上拉电阻（连接到高电平）**
   PULLDOWN：给 IO 口内部接一个下拉电阻（连接到低电平）
   一般在按键输入、复位信号会加PULLUP，将该引脚默认为高电平。

2. SLEW

   eg:
   set_property SLEW FAST [get_ports {led[0]}]
   set_property SLEW SLOW [get_ports {data[*]}]

   控制输出信号转换速率，一般是 FAST 或 SLOW，低速信号用SLOW，高速信号用FAST。

3. DRIVE

   eg:
   set_property DRIVE 12 [get_ports led[0]]

   控制 IO 输出时能够提供的电流大小，常见值：2, 4, 6, …, 24 mA，单位是mA。一般驱动较大电流例如LED，选12或16。驱动越大，功耗越高、噪声越大，不是越大越好。某些 IOStandard（如 LVDS）不支持 DRIVE，设置会报错。

4. OUTPUT_IMPEDANCE

   eg:
   set_property OUTPUT_IMPEDANCE 50 [get_ports clk_out]

   用于设置IO输出的特性阻抗，配合 PCB 匹配阻抗，减少反射，提高信号完整性。

   适用于高速差分信号（如 TMDS、LVDS）等，大多数情况下可以忽略，由布线匹配完成。

5. DIFF_TERM

   eg:
   set_property DIFF_TERM TRUE [get_ports clk_p]

   在 FPGA 芯片内部的两个差分引脚之间插入一个 100Ω 匹配电阻，主要用于接收差分时钟、LVDS 信号等。

   如果板上已经接了 100Ω 匹配电阻，就不要再设置 DIFF_TERM。