FPGA时序约束与分析-简单入门

文章目录

FPGA时序约束与分析-简单入门
- [1. 本课程概述](#1. 本课程概述)
- [2. 时序约束简介](#2. 时序约束简介)
- - [2.1 什么是时序约束](#2.1 什么是时序约束)
  - [2.2 合理的时序约束](#2.2 合理的时序约束)
  - [2.3 *基于Vivado的时序约束方法](#2.3 *基于Vivado的时序约束方法)
- [3. 时序分析的基本概念](#3. 时序分析的基本概念)
- - [3.1 时钟与时钟偏差](#3.1 时钟与时钟偏差)
  - [3.2 建立时间和保持时间](#3.2 建立时间和保持时间)
  - [3.3 时序分析中路径、沿和关系的定义](#3.3 时序分析中路径、沿和关系的定义)
- [4. 寄存器到寄存器的时序路径分析](#4. 寄存器到寄存器的时序路径分析)
- [5. 寄存器与引脚之间的时序路径分析](#5. 寄存器与引脚之间的时序路径分析)
- - [5.1 系统同步接口的引脚到寄存器的时序路径分析](#5.1 系统同步接口的引脚到寄存器的时序路径分析)
  - [5.2 源同步接口的引脚到寄存器的时序路径分析](#5.2 源同步接口的引脚到寄存器的时序路径分析)
  - [5.3 系统同步接口的寄存器到引脚的时序路径分析](#5.3 系统同步接口的寄存器到引脚的时序路径分析)
  - [5.4 源同步接口的寄存器到引脚的时序路径分析](#5.4 源同步接口的寄存器到引脚的时序路径分析)

笔记主要参考B站视频"特权同学《FPGA时序约束与分析》同名图书配套讲解视频"。

特权同学公众号视频链接：《FPGA时序约束与分析》视频课程

其他好文：快速入门系列--FPGA中的时序分析与约束

注：第2.3小节涉及Vivado进行时序约束的实际演示。

注：第3.1小节讲解了"时钟约束"，第4、5节讲解了"输入输出接口约束"的计算方法。

1. 本课程概述

对于FPGA学习者和初级工程师来说，"FPGA时序约束与分析"相对来讲是比较高级的技能。这部分内容很难，一方面是因为中文参考资料少，另一方面官网又只介绍"FPGA时序约束"的基本概念和工具的使用方法，很难与实践相结合起来。所以特权同学就结合自己十几年的FPGA开发经验，写了《FPGA时序约束与分析》。

图1-1 《FPGA时序约束与分析》封面和目录

第1、2章：基础知识。

第3、4章：重点介绍时钟的约束。

第5章：介绍和FPGA外部引脚相连接的IO口的约束。

第6、7、8、9章：第3/4/5章介绍的的是一些基本约束，第6/7/8/9章则介绍一些时序例外约束。++时序例外约束++ 是对 ++时钟约束++ 和 ++IO约束++ 的补充。正常的FPGA设计只需要做时钟约束和IO约束，但是这两种约束并不能非常真实的反映时序的要求，所以要通过时序例外约束来对这两种约束进行收紧或放松，大多数情况下是放松特定路径上的约束。

本套课程主要目的是 图书导读，点拨时序约束与分析的重点和难点，学习的方法和方向；不会非常全面的讲解，简单的概念一语带过或略过。另外本套课程尽可能精炼，每一节聚焦一个特定的知识点，时长都会控制在5~ 10分钟，适合碎片学习。

2. 时序约束简介

本节介绍什么是 ++合理的时序约束++ ，并演示如何使用Vivado进行 ++"时序约束"++ 中最简单、最基本的 ++"时钟约束"++。

2.1 什么是时序约束

图2-1 设计约束所处环节

在进行FPGA开发时，"约束(Constraints)"这个概念显然并不陌生，最直接的就是每个工程中都会创建一个XDC文件定义管脚分配。上图给出了FPGA基本开发流程中，设计约束 所处的环节（和约束有关的环节）：约束输入、分析实现结果、设计优化。这个"设计约束"是所有约束过程的统称，更进一步，"设计约束"基本可以分为两大类：

物理约束：I/O接口约束(例如引脚分配、电平标准设定等物理属性的约束)、布局约束、布线约束以及配置约束。

时序约束：涉及FPGA内部的各种逻辑或走线的延时，反映系统的频率和速度的约束。时序约束的目的是让FPGA编译工具合理地调配FPGA内部有限的布局布线资源，尽可能地满足设计者设定的所有。时序要求主要是将走线、逻辑电路等产生的延时限制在指定的范围内。

注：显然第一类的"物理约束"是FPGA初学者最常见的。

"时序约束"这个概念显然对于初学者来说有点陌生，下面通过一个简单的 时序约束实例 来说明时序约束的必要性。

图2-2 时序约束的简单实例

上图是对FPGA内部进行抽象后的简单模型，左侧是FPGA输入端口，右侧是FPGA输出端口，蓝色圆圈则表示寄存器(并给出寄存器延时)，连线则表示走线(并给出走线延时)。于是要想从输入走到输出，便有许多延时不同的路径（14ns、15ns、16ns、17ns、18ns等）。++若在没有时序约束的情况下进行编译，编译器会根据内置的算法自动选择一条路径++。于是：

器件对时序要求不严格：低速时钟下，编译器选择任何路径都没有问题。FPGA初学者基本上都是在低速时钟下开发，这也是为什么FPGA初学者即使不关心时序约束也可以正常实现功能的原因。

器件对时序要求严格：高速时钟下，若器件需要延时不超过14ns的路径才能正常工作，编译器选择其他路径便会造成功能异常。

上述只是一个简单的单条路径编译，实际项目往往更加复杂，不同的功能都对时钟都有要求时，比如A功能需要200MHz、B功能需要100MHz、C功能需要50MHz，若不告诉编译器这样的时序约束，则编译器可能会选择"整体最优"的100MHz延时路径，此时A功能便不能正常运行。所以 当项目越来越复杂时，进行时序约束非常有必要！

书籍原文 ：

在我们对系统延时(时序)有要求的情况下，我们不能指望FPGA编译工具自己"猜测"或靠"碰运气"来保证系统延时要求得到满足。我们需要将我们对系统的所有时序要求通过时序约束的方式告诉FPGA编译工具。这样，FPGA编译工具工作起来就有的放矢，不再漫无目的了。而布局布线结束后，我们也可以通过查看开发工具给出的时序分析报告 来确认我们的时序要求执行的状况。这正是我们对FPGA设计进行时序约束和时序分析的意义所在。

------《时序约束与分析》1.1节高亮字体

2.2 合理的时序约束

书籍原文 ：
没有任何设计约束 的工程，编译器工作时就如同"脱缰的野马"般漫无目的且随意任性；但是，任何的 时序过约束 (over-constraining，时序约束过于严格，超过实际设计的要求) 或 时序欠约束 (under-constraining, 时序约束过于松散，低于实际设计的要求)，都可能导致时序难以收敛，即难以达到设计要求。因此，为了达到特定应用的设计要求，设计者必须设定 合理的时序约束 。

------《时序约束与分析》1.2节亮字体

上面这一段原文给出了时序约束的四种情况：没有时序约束、时序过约束、时序欠约束、合理的时序约束。上一小节介绍了"时序约束"的必要性，显然"没有时序约束"是很危险的，但是也不能随意的将时序约束设置的过于宽松或严格：

若需求过于宽松导致时序欠约束，可能会导致走线延时过长无法正常工作。

若需求过于严格导致时序过约束，可能会受到实际资源限制，时序报告总是时序违规(Fail)；或者即使正常编译通过，也会造成高速布线资源的浪费。

下面来看具体的 设计约束实例 来说明上述提到的四种情况：

假设实际的时序约束需求为：din1 < 10ns, din2 < 10ns, din3 < 20ns, din4 < 20ns

1. 没有进行时序约束

图2-3 没有进行时序约束

不进行时序约束也就没有相应的"时序约束报告"，此时就难以确认所有路径是否满足时序要求。

2. 合理的时序约束

图2-4 合理的时序约束

时序约束与实际所需一致，此时性能达到最佳。

3. 时序欠约束

时序约束设置为：din1 < 20ns, din2 < 20ns, din3 < 20ns, din4 < 20ns

此时din1和din2欠约束。若din1或din2若被分配到 >10ns 的两条普通走线，则时序违规。

4. 时序过约束

时序约束设置为：din1 < 10ns, din2 < 10ns, din3 < 10ns, din4 < 10ns

此时din3和din4过约束。受到实际资源限制，无法找到合理路径，时序报告总是时序违规(Fail)。

书籍原文 ：说明时序违规的危害

对于整个设计来说，这个时序违规若出现在一些关键的逻辑上，设计的功能和性能都可能会受到一定的影响。最坏的情况，甚至可能导致系统无法正常工作。而对于一些并不重要的设计逻辑，虽然它有一定的时序要求，但是由于它在系统中的影响和作用非常小，对系统来说无足轻重，那么即便它出现了时序违规，可能也不会对系统正常运行产生任何影响。对于这类时序违规，虽然暂时不会有什么问题，但是从设计的严谨性来说，我们也是不允许它存在的，谁知道哪天这个小违规会不会幽灵般地上演一把"++千里之堤溃于蚁穴++ "的故事呢。

------《时序约束与分析》1.2节高亮字体

概括：有时候即使时序违规也可以正常工作，但是这样做非常危险！所以避免出现时序违规。
书籍原文 ：说明合理时序约束的重要

最优的设计并不意味着局部的最佳性能，而是一个系统全面的能满足设计要求的尽可能平衡的设计实现。设计者必须添加最恰当的时序约束，将设计的需求准确地传达给编译工具，这样才有可能指导工具进行资源的合理分配，保证系统的基本性能要求得以实现。

------《时序约束与分析》1.2节亮字体

2.3 *基于Vivado的时序约束方法

图2-5 时序约束的基本步骤

如上图所示，一个完整的时序约束步骤应该为：时钟约束、输入输出接口约束、时钟分组和跨时钟约束、时序例外约束。++强烈建议按照上述顺序进行时序约束++ 。其中，第一种 时钟约束 最重要，后三种约束的都是要基于已有的时钟约束路径才能完成。

图2-6 时序约束流程

上图给出了在Vivado中进行时序约束的两种方法：

GUI编辑：有图形界面，相对来说比较简单。输入相关参数，选择相关接口即可。Synthesis下的 Constrains Wizard和 Edit Timing Constraints都是做时序约束的GUI按钮。

手动编辑：需要手动在XDC文件中输入相关的约束脚本和参数。

注：做时序约束之前，需要先完成"综合"(synthesis)，有了实际的电路后才能进行时序约束。

显然为了区分 引脚约束 和 时序约束，通常建议创建两个XDC约束文件(或者三个)。这些XDC文件组合起来便是一个"约束策略"，可以创建多个"约束策略"，哪个加粗(active)哪个有效：

xxx_pins.xdc：引脚约束。

xxx_timing.xdc：时序约束。

xxx_debug.xdc(选做)：用于debug。

注：使用GUI做时序约束时，建议将约束文件的小括号(target)设置在 xxx_timing.xdc文件下。可以在相应的约束文件右键"Set as Target Constrain File"。

下面使用"LED闪烁"的Vivado工程 演示时序约束：

注：演示仅涉及"时序约束"的第一步"时钟约束"中最简单的时钟频率设置，但所有的时序约束都可以按照此演示完成。

1. 创建约束组

图2-7 创建约束组

注意引脚约束 led_pins.xdc可以直接复制 led.xdc中的内容。

2. 演示GUI做时序约束------Constrains Wizard

先运行Synthesis，且 xxx_timing.xdc文件为(target)。

图2-8 使用Constrains Wizard创建时序约束

3. 演示GUI做时序约束------Edit Timing Constraints

图2-9 使用Edit Timing Constraints创建时序约束

4. 演示手动编辑时序约束

手动编辑时序约束时，可以参考 时序约束模板：

图2-10 时序约束模板

附录1：led.v

verilog 复制代码

`timescale 1ns / 1ps
//
// Engineer: humu
// Description: 实现LED闪烁。
//

module led(
    input       sys_clk     ,
    input       sys_rst_n   ,
    output reg  led    
);

// 设置每0.5秒计数清空一次
parameter COUNT_MAX = 25_000_000;
reg [24:0] cnt;
always@(posedge sys_clk or negedge sys_rst_n)
if(!sys_rst_n)begin
    cnt <= 25'd0;
end
else if(cnt >= COUNT_MAX-1) begin
    cnt <= 25'd0;
end
else begin
    cnt <= cnt + 16'd1;
end

// 设置LED
always@(posedge sys_clk or negedge sys_rst_n)
if(!sys_rst_n)begin
    led <= 1'd0;
end
else if(cnt == COUNT_MAX - 1)begin
    led <= ~led;
end

endmodule

附录2：led_pins.xdc

verilog 复制代码

set_property IOSTANDARD LVCMOS33 [get_ports led]
set_property IOSTANDARD LVCMOS33 [get_ports sys_clk]
set_property IOSTANDARD LVCMOS33 [get_ports sys_rst_n]
set_property PACKAGE_PIN R4 [get_ports sys_clk]
set_property PACKAGE_PIN U7 [get_ports sys_rst_n]
set_property PACKAGE_PIN V9 [get_ports led]

3. 时序分析的基本概念

本节介绍一些时序分析的基本概念，为后续进行时序路径分析做铺垫。

3.1 时钟与时钟偏差

在FPGA的初学阶段中提到过，FPGA的时序设计主要分为：时序逻辑、组合逻辑。时序逻辑下，输出在 ++时钟沿的触发++ 下才能更新输入的变化；而在组合逻辑中，则无需时钟沿的触发，输出 ++立刻更新++ 输入的变化。两者的其他主要差异还有：

组合逻辑的输出与输入直接相关，时序逻辑的输出和原有状态也有关。

组合逻辑立即反应当前输入状态，时序逻辑还必须在时钟上升沿触发后输出新值。

组合逻辑容易出现竞争、冒险现象，时序逻辑一般不会出现竞争、冒险现象。

组合逻辑的时序较难保证，时序逻辑更容易达到时序收敛，时序逻辑更可控。

组合逻辑只适合简单的电路，时序逻辑能够胜任大规模的逻辑电路。

因为时序逻辑更加稳定，所以现代FPGA使用最多的是时序逻辑 。又因为时序逻辑需要时钟触发，于是时钟对于FPGA设计来说就显得非常重要。本小节接下来就详细介绍时钟模型及其主要参数。

基本时钟模型时钟偏差

图3-1 基本时钟模型

T1 \text{T1} T1 为高脉冲时间宽度， T2 \text{T2} T2 为低脉冲时间宽度。

Tclk = T1 + T2 \text{Tclk}=\text{T1}+\text{T2} Tclk=T1+T2 为一个时钟周期(单位：秒)。FPGA的时钟周期一般为纳秒(ns)级别。

时钟频率 ：时钟周期的倒数 1 / Tclk 1/\text{Tclk} 1/Tclk 即为时钟频率(单位：Hz)。FPGA的时钟频率一般为MHz级别。

占空比 ：时钟信号的高脉冲宽度与周期之比 T1 / Tclk \text{T1}/\text{Tclk} T1/Tclk 即该时钟信号的占空比。

上图给出了 基本时钟模型 。理想的时钟模型是周期性的产生方波，但实际上时钟的上升沿和下降沿都需要一定的时间，于是实际的时钟波形就像是上述的周期梯形。另外，无论是来自外部晶振的时钟信号，还是在FPGA内部经过PLL产生的时钟信号，它们的周期都无法保证绝对的精准，影响时钟周期准确性的因素有很多，比如材料、工艺、温度以及各种噪声等。这些对时钟周期的准确性产生的影响导致了 时钟偏差。下面是时钟偏差的三个主要参数：

时钟精度(Frequency tolerance)：实际时钟周期与标准时钟周期的最大差值占标准时钟周期的百分比，单位是百分比单位 p p m ( 1 0 − 6 ) ppm(10^{-6}) ppm(10−6)。

时钟温漂(Frequency versus temperature characteristics)：当温度变化时，晶体的物理特性也会变化，导致振荡器频率的漂移。温度所引起的时钟周期变化与标准时钟周期的最大差值占标准时钟周期的百分比，单位也是百分比单位 p p m ( 1 0 − 6 ) ppm(10^{-6}) ppm(10−6)。

时钟抖动(jitter)：一段时间内的最大时钟周期与最小时钟周期之差就是时钟抖动，单位是 p s ps ps。时钟倍频到GHz级别的高速收发器时，时钟抖动问题就会比较明显。所以在FPGA时序分析中，也会将时钟抖动作为时钟不确定性(uncertainty) 的一部分加以约束。

查看外部时钟偏差

实际上，FPGA项目的时钟偏差还分为：FPGA内部时钟偏差、外部晶振的时钟偏差。做时序约束时，主要关心外部时钟偏差即可：

FPGA内部时钟偏差：在FPGA内部集成了PLL等时钟产生单元，FPGA编译工具在做时序分析时可以直接套用既有的模型计算FPGA内部所产生的时钟偏差，并作为一部分需要预留的时序余量计算在内。通过时序报告可以查看FPGA内部的时钟偏差，所以 ++我们不用太关心FPGA内部所产生的时钟偏差++。

外部晶振的时钟偏差：外部晶振所产生的时钟信号，设计者需要指定相关的时钟偏差参数，以时序约束的方式告知FPGA编译工具。这些 ++外部的时钟偏差参数由晶振的芯片手册提供++。

图3-2 SiT8021晶振规格书

下面以SiTime公司的SiT8021系列晶振规格书为例，来看外部时钟偏差的三个主要参数。不同器件手册所给出的称呼可能有所差异，但是表达的参数指标都是一致的：

时钟精度： ± 15 p p m ( 1 0 − 6 ) \pm 15ppm(10^{-6}) ±15ppm(10−6)，也就是 1 26 ⋅ 1 0 6 ∗ 15 ⋅ 1 0 − 6 ≈ 0.577 p s \frac{1}{26·10^{6}} * 15·10^{-6} \approx 0.577 \, ps 26⋅1061∗15⋅10−6≈0.577ps。

时钟温漂： ± 100 p p m ( 1 0 − 6 ) \pm 100ppm(10^{-6}) ±100ppm(10−6)，也就是 1 26 ⋅ 1 0 6 ∗ 100 ⋅ 1 0 − 6 ≈ 3.846 p s \frac{1}{26·10^{6}} * 100·10^{-6} \approx 3.846 \, ps 26⋅1061∗100⋅10−6≈3.846ps。

时钟抖动：最大值为 110 p s 110 ps 110ps，典型值是 75 p s 75 ps 75ps。

注：将三个指标都转化成 p s ps ps 进行比较，可以发现时钟倍频到 GHz \text{GHz} GHz 量级时，时钟抖动问题最严重。
书籍原文 ：
时钟频率 是FPGA设计性能一个很重要的指标，但是，单纯的时钟频率并不是衡量设计性能好坏的唯一指标。FPGA

设计中，还有并行结构、流水线结构等 体系架构方式 也是设计性能的重要影响因素。

------《时序约束与分析》1.2节高亮字体

概括："FPGA设计"的性能不只体现在时钟频率上，同样也与体系架构等其他因素有关，不要一味的追求高频。

3.2 建立时间和保持时间

图3-3 建立时间和保持时间

本小节介绍时序分析中最基础、最常用的概念：建立时间和保持时间。建立时间和保持时间都是为了 保证数据信号稳定的被锁存触发，若数据会在时钟上升沿触发，如上图示：

建立时间(Setup Time, Tsu)：指在时钟上升沿到来之前数据必须保持稳定的时间。

保持时间(Hold Time, Th)：指在时钟上升沿到来以后数据必须保持稳定的时间。

要想数据被稳定的锁存触发，那么在时钟上升沿的 建立时间和保持时间内数据必须保持稳定。下面利用"与逻辑"作为示例，展示reg3输入数据被稳定锁存触发、建立时间违规、保持时间违规的情况：

图3-4 数据稳定锁存、建立时间违规、保持时间违规

时钟延时：第二级时钟clk_r3相比于第一级时钟clk有延时。

建立时间违规与保持时间违规都会造成信号的不确定。

3.3 时序分析中路径、沿和关系的定义

在上一小节"建立时间和保持时间"的基础上，本小节继续介绍时序分析中最主要的三个概念：

路径：数据到达路径和数据需求路径。

沿：时钟的启动沿和锁存沿。

关系：建立时间关系和保持时间关系。

数据到达路径和数据需求路径

图3-5 数据到达路径和数据需求路径

数据到达路径(data arrival path)：是指数据在两个寄存器间传输的 实际路径 ，由此路径可以算出数据在两个寄存器间传输的 实际时间。起点是时钟源，经过源寄存器的时钟输入端口、输出端口，再经过一定的走线延时、逻辑延时，最终达到目的寄存器的数据输入端口。

数据需求路径(data required path)：是指为了确保稳定、可靠且有效的传输(即满足相应的建立时间和保持时间要求)，数据在两个寄存器间传输的 理论所需时间 的计算路径。为了后续理论分析方便，就需要有一条路径来计算建立时间和保持时间是否被满足了、有多少裕量，也就是数据需求路径。起点是时钟源，终点是目的寄存器的时钟输入端口。

时钟启动沿和锁存沿

图3-6 时钟启动沿和锁存沿

启动时钟：++源寄存器++ 的时钟。

锁存时钟：++目的寄存器++ 的时钟。

时钟启动沿：传输到 ++源寄存器++ 的第一个时钟上升沿。

时钟锁存沿：传输到 ++目的寄存器++ 的时钟沿，对于建立时间和保持时间来说不一样。

建立时间关系和保持时间关系

下面引入建立时间关系和保持时间关系的概念，来方便时序分析：

建立时间关系：当前数据从源寄存器的时钟启动沿，经过一定的延时，最终到达目的寄存器的时钟锁存沿，保证当前数据被锁存的建立时间得到满足。主要关心数据可以正常被锁存，为了方便计算建立时间的时间裕量。

从时间上看，++启动沿比建立时间关系的锁存沿早一个时钟周期++，即它们之间通常是相差一个时钟周期的关系。

保持时间关系：当前数据从源寄存器的时钟启动沿，经过一定的延时，最终到达目的寄存器的时钟锁存沿，保证上一个数据的保持时间得到满足。

++启动沿和保持时间关系的锁存沿其实是同一个时钟周期++，并且都是由时钟源传输过来的时钟信号。

4. 寄存器到寄存器的时序路径分析

图4-1 寄存器到寄存器的路径延时示意图

T c2i \text{T}{\text{c2i}} Tc2i（确定值）：时钟从 ++源端++ 到达 ++源寄存器的时钟输入端口++ 的延时时间。
T c2j \text{T}{\text{c2j}} Tc2j（确定值）：时钟从 ++源端++ 到达 ++目的寄存器的时钟输入端口++ 的延时时间。
T co \text{T}{\text{co}} Tco（确定值）：寄存器内部 ++固有延时++ ，器件手册以及时序报告都会给出，且一般为同一常量，这里省略并包含在下面的 T d \text{T}{\text{d}} Td 中。
T d \text{T}{\text{d}} Td（待确定 ）：数据++从源寄存器被锁存++ 开始，经过++逻辑延时++ 以及++走线延时++ ，到达++目的寄存器的输入端++ 的时间。
T su \text{T}{\text{su}} Tsu / T h \text{T}_{\text{h}} Th（确定值）：目的寄存器的++建立时间++ 和++保持时间++，器件手册以及时序报告都会给出，且一般为同一常量。

正常情况：目的寄存器在当前周期锁存上一数据，所以数据传输不能太快；目的寄存器在下一周期锁存当前周期数据，所以数据传输不能太慢。

建立时间关系 ：源寄存器启动沿到目的寄存器锁存沿，保证 ++当前数据的建立时间++ 得到满足。也就是，在锁存沿(下一个上升沿)的建立时间之前，当前数据已经到达，所以应该是数据到达时间 < 数据需求时间。

数据到达时间 ：
Data Arrival Time = Launch Edge + T c2i ( max ) + T d \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{c2i}}(\text{max}) + \text{T}{\text{d}} Data Arrival Time=Launch Edge+Tc2i(max)+Td。

Launch Edge \text{Launch Edge} Launch Edge：启动沿，表示从源寄存器启动沿开始计算。

实际值，要尽可能大，才能使余量尽可能小，从而计算到最坏的情况。

数据需求时间 ：
Data Required Time = Latch Edge + T c2j ( min ) − T su − Clock Uncertainty Time + Clock Pessimism Removal \text{Data Required Time} = \text{Latch Edge} + \text{T}{\text{c2j}}(\text{min})- \text{T}{\text{su}} - \text{Clock Uncertainty Time} + \text{Clock Pessimism Removal} Data Required Time=Latch Edge+Tc2j(min)−Tsu−Clock Uncertainty Time+Clock Pessimism Removal。

Latch Edge \text{Latch Edge} Latch Edge：锁存沿，表示从目的寄存器锁存沿开始计算。

Clock Uncertainty Time \text{Clock Uncertainty Time} Clock Uncertainty Time：与时钟抖动等参数相关。

Clock Pessimsm Removal(CPR) = Tcommon(max) − Tcommon(min) \text{Clock Pessimsm Removal(CPR)} = \text{Tcommon(max)} - \text{Tcommon(min)} Clock Pessimsm Removal(CPR)=Tcommon(max)−Tcommon(min)：共线路径时间的最大值与最小值之差，时序报告会给出 CPR \text{CPR} CPR。

理论值，要尽可能小，才能使余量尽可能小，从而计算到最坏的情况。

建立时间余量 ：
Setup Time Slack = Data Required Time − Data Arrival Time \text{Setup Time Slack} = \text{Data Required Time} - \text{Data Arrival Time} Setup Time Slack=Data Required Time−Data Arrival Time。

主要关心数据传输不要太慢，以保证目的寄存器在下一周期正常锁存当前数据，也就是计算 T d \text{T}_{\text{d}} Td 最大值。

注：建立时间关系中，锁存沿 Latch Edge \text{Latch Edge} Latch Edge 比启动沿 Launch Edge \text{Launch Edge} Launch Edge 大一个时钟周期。

保持时间关系 ：源寄存器启动沿到目的寄存器保持沿。保证 ++上一数据的保持时间++ 得到满足。也就是，在锁存沿(当前上升沿)的保持时间之后，当前数据还没到，所以应该是数据到达时间 > 数据需求时间。

数据到达时间 ：
Data Arrival Time = Launch Edge + T c2i ( min ) + T d \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{c2i}}(\text{min}) + \text{T}{\text{d}} Data Arrival Time=Launch Edge+Tc2i(min)+Td。

实际值，要尽可能小，才能使余量尽可能小，从而计算到最坏的情况。

数据需求时间 ：
Data Required Time = Latch Edge + T c2j ( max ) + T h + Clock Uncertainty Time + Clock Pessimism Removal \text{Data Required Time} = \text{Latch Edge} + \text{T}{\text{c2j}}(\text{max})+ \text{T}{\text{h}} + \text{Clock Uncertainty Time} + \text{Clock Pessimism Removal} Data Required Time=Latch Edge+Tc2j(max)+Th+Clock Uncertainty Time+Clock Pessimism Removal。

理论值，要尽可能大，才能使余量尽可能小，从而计算到最坏的情况。

保持时间余量 ：
Hold Time Slack = Data Arrival Time − Data Required Time \text{Hold Time Slack} = \text{Data Arrival Time} - \text{Data Required Time} Hold Time Slack=Data Arrival Time−Data Required Time。

主要关心数据传输不要太快，防止目的寄存器在当前周期没锁存完成上一数据，当前数据就传输过来了，也就是计算 T d \text{T}_{\text{d}} Td 最小值。

注：保持时间关系中，锁存沿 Latch Edge \text{Latch Edge} Latch Edge 比启动沿 Launch Edge \text{Launch Edge} Launch Edge 相同。

从定义上看，我们就知道保持时间和建立时间是相对立，它们就如同天平的两侧，平衡是最好的一个状态。

5. 寄存器与引脚之间的时序路径分析

接下来的课程要学习 ++FPGA内部寄存器到外部引脚++ 、++外部引脚到FPGA内部寄存器++ 之间的接口。这些接口按照时钟源接入方式又分别分为两大类：++系统同步接口++ 、++源同步接口++。在具体进行时序分析时，针对外部引脚会有一些差异：

系统同步接口 ：

FPGA与外部芯片之间的通信时钟都由外部同一时钟源(系统时钟)产生时，我们称之为系统同步接口。也就是FPGA与外部芯片 ++直接共用++ 同一个时钟源。下图分别是FPGA器件作为目的端、外部芯片作为目的端的示意图。

源同步接口 ：

FPGA与外部芯片之间的通信时钟都由源寄存器所在一侧(输出端)产生时，我们称之为源同步接口。也就是FPGA与外部芯片通过级联的方式，++间接共用++ 同一个时钟。下图分别是外部芯片作为目的端、FPGA器件作为目的端的示意图。

于是，接下来的四个小节就分别针对上述四种情况，来进行时序路径分析。

5.1 系统同步接口的引脚到寄存器的时序路径分析

图5-1 时序寄存器模型--系统同步接口的外部芯片到FPGA寄存器

源寄存器在外部芯片中，目的寄存器在FPGA器件中，两者直接共用同一外部时钟源。

红色圆圈就是系统同步接口的源寄存器到目的寄存器的时序路径；绿色圆圈则是引脚到目的寄存器的时序路径，是FPGA时序约束的关键(pin2reg \text{pin2reg} pin2reg路径 )，也就是需要告诉FPGA编译器该路径延时 T pin2reg \text{T}_{\text{pin2reg}} Tpin2reg 的最大值和最小值。

图5-2 pin2reg路径模型--系统同步接口的外部芯片到FPGA寄存器

建立时间关系 ：源寄存器启动沿到目的寄存器锁存沿，保证 ++当前数据的建立时间++ 得到满足。

数据到达时间：实际值，要尽可能大，才能使余量尽可能小，从而计算到最坏的情况。
Data Arrival Time = Launch Edge + T c2i_pcb (max) + T co (max) + T d_pcb (max) + T pin2reg (max) \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{c2i\pcb}}\text{(max)} + \text{T}{\text{co}}\text{(max)} + \text{T}{\text{d\pcb}}\text{(max)} + \text{T}{\text{pin2reg}}\text{(max)} Data Arrival Time=Launch Edge+Tc2i_pcb(max)+Tco(max)+Td_pcb(max)+Tpin2reg(max)。

T c2i_pcb \text{T}_{\text{c2i\_pcb}} Tc2i_pcb（确定值）：时钟从时钟源到外部芯片输入引脚的PCB走线延时。

T co \text{T}_{\text{co}} Tco（确定值）：信号在芯片内部的总延时，器件手册一般会给出一个笼统的值。

T d_pcb \text{T}_{\text{d\_pcb}} Td_pcb（确定值）：数据从外部芯片输出引脚到 FPGA器件输入引脚的PCB走线延时。

T pin2reg \text{T}_{\text{pin2reg}} Tpin2reg（待确定）：数据从 FPGA器件输入引脚到目的寄存器输入端口的延时。

注：通常PCB延时是 0.17 ns/inch 0.17 \text{ns/inch} 0.17ns/inch，也就是每 25.4 mm 25.4\text{mm} 25.4mm 对应 0.17 ns 0.17\text{ns} 0.17ns 的延时。

数据需求时间：理论值，要尽可能小，才能使余量尽可能小，从而计算到最坏的情况。
Data Required Time = Latch Edge + T c2j_pcb (min) + T c2j_fp (min) − T su − Clock Uncertainty Time \text{Data Required Time} = \text{Latch Edge} + \text{T}_{\text{c2j\pcb}}\text{(min)} + \text{T}{\text{c2j\fp}}\text{(min)} - \text{T}{\text{su}} - \text{Clock Uncertainty Time} Data Required Time=Latch Edge+Tc2j_pcb(min)+Tc2j_fp(min)−Tsu−Clock Uncertainty Time。

T c2j_pcb \text{T}_{\text{c2j\_pcb}} Tc2j_pcb（确定值）：时钟从时钟源到 FPGA器件输入引脚的PCB走线延时。

T c2j_fp \text{T}_{\text{c2j\_fp}} Tc2j_fp（待确定）：时钟从 FPGA器件输入引脚到目的寄存器时钟输入引脚的延时。

建立时间余量： Setup Time Slack = Data Required Time − Data Arrival Time \text{Setup Time Slack} = \text{Data Required Time} - \text{Data Arrival Time} Setup Time Slack=Data Required Time−Data Arrival Time。

抽出其中的4个FPGA外部延时信息，就可以使用 set_input_delay-max命令来约束 外部延时的最大值 ：
set_input_delay(max) = T c2i_pcb (max) − T c2j_pcb (min) + T co (max) + T d_pcb (max) \text{set\input\delay(max)} = \text{T}{\text{c2i\pcb}}\text{(max)} - \text{T}{\text{c2j\pcb}}\text{(min)} + \text{T}{\text{co}}\text{(max)} + \text{T}{\text{d\_pcb}}\text{(max)} set_input_delay(max)=Tc2i_pcb(max)−Tc2j_pcb(min)+Tco(max)+Td_pcb(max)
保持时间关系 ：源寄存器启动沿到目的寄存器保持沿。保证 ++上一数据的保持时间++ 得到满足。

数据到达时间：实际值，要尽可能大，才能使余量尽可能小，从而计算到最坏的情况。
Data Arrival Time = Launch Edge + T c2i_pcb (min) + T co (min) + T d_pcb (min) + T pin2reg (min) \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{c2i\pcb}}\text{(min)} + \text{T}{\text{co}}\text{(min)} + \text{T}{\text{d\pcb}}\text{(min)} + \text{T}{\text{pin2reg}}\text{(min)} Data Arrival Time=Launch Edge+Tc2i_pcb(min)+Tco(min)+Td_pcb(min)+Tpin2reg(min)。

T c2i_pcb \text{T}_{\text{c2i\_pcb}} Tc2i_pcb（确定值）：从时钟源到外部芯片输入引脚的PCB走线延时。

T co \text{T}_{\text{co}} Tco（确定值）：信号在芯片内部的总延时，器件手册一般会给出一个笼统的值。

T d_pcb \text{T}_{\text{d\_pcb}} Td_pcb（确定值）：从外部芯片输出引脚到 FPGA器件输入引脚的PCB走线延时。

T pin2reg \text{T}_{\text{pin2reg}} Tpin2reg（待确定）：从 FPGA器件输入引脚到目的寄存器输入端口的延时。

数据需求时间：理论值，要尽可能小，才能使余量尽可能小，从而计算到最坏的情况。
Data Required Time = Latch Edge + T c2j_pcb (max) + T c2j_fp (max) + T h + Clock Uncertainty Time \text{Data Required Time} = \text{Latch Edge} + \text{T}_{\text{c2j\pcb}}\text{(max)} + \text{T}{\text{c2j\fp}}\text{(max)} + \text{T}{\text{h}} + \text{Clock Uncertainty Time} Data Required Time=Latch Edge+Tc2j_pcb(max)+Tc2j_fp(max)+Th+Clock Uncertainty Time。

T c2j_pcb \text{T}_{\text{c2j\_pcb}} Tc2j_pcb（确定值）：从时钟源到 FPGA器件输入引脚的PCB走线延时。

T c2j_fp \text{T}_{\text{c2j\_fp}} Tc2j_fp（待确定）：从 FPGA器件输入引脚到目的寄存器时钟输入引脚的延时。

注：其实少了 Clock Pessimsm Removal(CPR) \text{Clock Pessimsm Removal(CPR)} Clock Pessimsm Removal(CPR) 共线路径时间差，这是因为当前场景下，FPGA器件内部不存在共路径情况。

保持时间余量： Hold Time Slack = Data Arrival Time − Data Required Time \text{Hold Time Slack} = \text{Data Arrival Time} - \text{Data Required Time} Hold Time Slack=Data Arrival Time−Data Required Time

抽出其中的4个FPGA外部延时信息，就可以使用 set_input_delay-min命令来约束 外部延时的最小值 ：
set_input_delay(min) = T c2i_pcb (min) − T c2j_pcb (max) + T co (min) + T d_pcb (min) \text{set\input\delay(min)} = \text{T}{\text{c2i\pcb}}\text{(min)} - \text{T}{\text{c2j\pcb}}\text{(max)} + \text{T}{\text{co}}\text{(min)} + \text{T}{\text{d\_pcb}}\text{(min)} set_input_delay(min)=Tc2i_pcb(min)−Tc2j_pcb(max)+Tco(min)+Td_pcb(min)

5.2 源同步接口的引脚到寄存器的时序路径分析

图5-3 时序寄存器模型--源同步接口的外部芯片到FPGA寄存器

源寄存器在外部芯片中，目的寄存器在FPGA器件中，时钟通过级联的方式 ++间接共用++。

T d_pcb \text{T}_\text{d\_pcb} Td_pcb（确定值）：++数据++ 从外部芯片输出引脚到 FPGA器件输入引脚的PCB走线延时。

T pin2reg \text{T}_\text{pin2reg} Tpin2reg（待确定 ）++数据++ 从FPGA器件输入引脚到目的寄存器数据输入端的延时。

T c2j_pcb \text{T}_\text{c2j\_pcb} Tc2j_pcb（确定值）：++时钟++ 从外部芯片输出引脚到 FPGA器件输入引脚的PCB走线延时。

T c2j_fp \text{T}_\text{c2j\_fp} Tc2j_fp（待确定 ）：++时钟++ 从 FPGA器件输入引脚到目的寄存器时钟输入端的延时。

T su \text{T}\text{su} Tsu / T h \text{T}\text{h} Th（确定值）：寄存器的建立时间和保持时间。

图5-4 外部芯片输出引脚参数

外部芯片的器件手册中通常会给出输出引脚的 T co \text{T}_\text{co} Tco 的最大值和最小值(如上图)，也就是外部芯片从输出时钟上升沿到输出数据有效的时间。于是将其考虑进延时模型中，便可得到下图：

图5-5 pin2reg路径模型--源同步接口的外部芯片到FPGA寄存器

T co \text{T}_\text{co} Tco（确定值）：外部芯片从输出时钟上升沿到输出数据有效的延时。

T c_ext \text{T}\text{c\ext} Tc_ext（确定值）：由于上述 T co \text{T}\text{co} Tco 已经是相对与输出时钟的相对值，所以此时可以忽略 T c_ext \text{T}\text{c\_ext} Tc_ext，并认为其为0。

于是便可以得出建立时间关系和保持时间关系，注意"移项"是将常数项移项到数据到达时间中的加数项：

建立时间关系：
Data Arrival Time = Launch Edge + T co (max) + T d_pcb (max) + T pin2reg (max) \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{co}}\text{(max)} + \text{T}{\text{d\pcb}}\text{(max)} + \text{T}{\text{pin2reg}}\text{(max)} Data Arrival Time=Launch Edge+Tco(max)+Td_pcb(max)+Tpin2reg(max)
Data Required Time = Latch Edge + T c2j_pcb (min) + T c2j_fp (min) − T su − Clock Uncertainty Time \text{Data Required Time} = \text{Latch Edge} + \text{T}_{\text{c2j\pcb}}\text{(min)} + \text{T}{\text{c2j\fp}}\text{(min)} - \text{T}{\text{su}} - \text{Clock Uncertainty Time} Data Required Time=Latch Edge+Tc2j_pcb(min)+Tc2j_fp(min)−Tsu−Clock Uncertainty Time
Setup Time Slack = Data Required Time − Data Arrival Time \text{Setup Time Slack} = \text{Data Required Time} - \text{Data Arrival Time} Setup Time Slack=Data Required Time−Data Arrival Time

保持时间关系 ：
Data Arrival Time = Launch Edge + T co (min) + T d_pcb (min) + T pin2reg (min) \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{co}}\text{(min)} + \text{T}{\text{d\pcb}}\text{(min)} + \text{T}{\text{pin2reg}}\text{(min)} Data Arrival Time=Launch Edge+Tco(min)+Td_pcb(min)+Tpin2reg(min)
Data Required Time = Latch Edge + T c2j_pcb (max) + T c2j_fp (max) + T h + Clock Uncertainty Time \text{Data Required Time} = \text{Latch Edge} + \text{T}_{\text{c2j\pcb}}\text{(max)} + \text{T}{\text{c2j\fp}}\text{(max)} + \text{T}{\text{h}} + \text{Clock Uncertainty Time} Data Required Time=Latch Edge+Tc2j_pcb(max)+Tc2j_fp(max)+Th+Clock Uncertainty Time
Hold Time Slack = Data Arrival Time − Data Required Time \text{Hold Time Slack} = \text{Data Arrival Time} - \text{Data Required Time} Hold Time Slack=Data Arrival Time−Data Required Time

移项后的建立时间关系：
Data Arrival Time = Launch Edge − T c2j_pcb (min) + T co (max) + T d_pcb (max) + T pin2reg (max) \text{Data Arrival Time} = \text{Launch Edge} - \text{T}{\text{c2j\pcb}}\text{(min)} + \text{T}{\text{co}}\text{(max)} + \text{T}{\text{d\pcb}}\text{(max)} + \text{T}{\text{pin2reg}}\text{(max)} Data Arrival Time=Launch Edge−Tc2j_pcb(min)+Tco(max)+Td_pcb(max)+Tpin2reg(max)
Data Required Time = Latch Edge + T c2j_fp (min) − T su − Clock Uncertainty Time \text{Data Required Time} = \text{Latch Edge} + \text{T}_{\text{c2j\fp}}\text{(min)} - \text{T}{\text{su}} - \text{Clock Uncertainty Time} Data Required Time=Latch Edge+Tc2j_fp(min)−Tsu−Clock Uncertainty Time
Setup Time Slack = Data Required Time − Data Arrival Time \text{Setup Time Slack} = \text{Data Required Time} - \text{Data Arrival Time} Setup Time Slack=Data Required Time−Data Arrival Time

即： set_input_delay(max) = − T c2j_pcb (min) + T co (max) + T d_pcb (max) \text{set\input\delay(max)} = - \text{T}{\text{c2j\pcb}}\text{(min)} + \text{T}{\text{co}}\text{(max)} + \text{T}{\text{d\_pcb}}\text{(max)} set_input_delay(max)=−Tc2j_pcb(min)+Tco(max)+Td_pcb(max)

移项后的保持时间关系 ：
Data Arrival Time = Launch Edge − T c2j_pcb (max) + T co (min) + T d_pcb (min) + T pin2reg (min) \text{Data Arrival Time} = \text{Launch Edge} - \text{T}{\text{c2j\pcb}}\text{(max)} + \text{T}{\text{co}}\text{(min)} + \text{T}{\text{d\pcb}}\text{(min)} + \text{T}{\text{pin2reg}}\text{(min)} Data Arrival Time=Launch Edge−Tc2j_pcb(max)+Tco(min)+Td_pcb(min)+Tpin2reg(min)
Data Required Time = Latch Edge + T c2j_fp (max) + T h + Clock Uncertainty Time \text{Data Required Time} = \text{Latch Edge} + \text{T}_{\text{c2j\fp}}\text{(max)} + \text{T}{\text{h}} + \text{Clock Uncertainty Time} Data Required Time=Latch Edge+Tc2j_fp(max)+Th+Clock Uncertainty Time
Hold Time Slack = Data Arrival Time − Data Required Time \text{Hold Time Slack} = \text{Data Arrival Time} - \text{Data Required Time} Hold Time Slack=Data Arrival Time−Data Required Time

即： set_input_delay(min) = − T c2j_pcb (max) + T co (min) + T d_pcb (min) \text{set\input\delay(min)} = - \text{T}{\text{c2j\pcb}}\text{(max)} + \text{T}{\text{co}}\text{(min)} + \text{T}{\text{d\_pcb}}\text{(min)} set_input_delay(min)=−Tc2j_pcb(max)+Tco(min)+Td_pcb(min)

图5-6 外部芯片输出引脚参数

最后要说的是，有些器件手册也不会直接给出输出引脚的 T co \text{T}\text{co} Tco，而是给出外部芯片输出引脚的 T su \text{T}\text{su} Tsu 和 T h \text{T}_\text{h} Th (如上图)，于是便可以换算：

$\text{T}\text{co}\text{(max)} = \text{T} \text{clk} - \text{T}\text{su} $
T co (min) = T h \text{T}\text{co}\text{(min)} = \text{T}_\text{h} Tco(min)=Th

5.3 系统同步接口的寄存器到引脚的时序路径分析

图5-7 时序寄存器模型--系统同步接口的FPGA寄存器到外部芯片

源寄存器在FPGA器件中，目的寄存器在外部芯片中，两者直接共用同一外部时钟源。

红色圆圈就是系统同步接口的源寄存器到目的寄存器的时序路径；绿色圆圈则是源寄存器到引脚的时序路径，是FPGA时序约束的关键(reg2pin \text{reg2pin} reg2pin路径 )，也就是需要告诉FPGA编译器该路径延时 T reg2pin \text{T}_{\text{reg2pin}} Treg2pin 的最大值和最小值。

图5-8 reg2pin路径模型--系统同步接口的FPGA寄存器到外部芯片

数据到达路径：

T c2i_pcb \text{T}_{\text{c2i\_pcb}} Tc2i_pcb（确定值）：从时钟源到 FPGA器件输入引脚的PCB走线延时。

T c2i_fp \text{T}_{\text{c2i\_fp}} Tc2i_fp（待确定）：从 FPGA器件输入引脚到源寄存器时钟输入引脚的时钟延时。

T reg2pin \text{T}_{\text{reg2pin}} Treg2pin（待确定）：从源寄存器上升沿锁存到 FPGA器件输出引脚的数据延时。

T d_pcb \text{T}_{\text{d\_pcb}} Td_pcb（确定值）：从 FPGA器件输出引脚到外部芯片输入引脚的PCB走线延时。

数据需求路径：

T c2j_pcb \text{T}_{\text{c2j\_pcb}} Tc2j_pcb（确定值）：从时钟源到外部芯片输入引脚的PCB走线延时。

T su \text{T}{\text{su}} Tsu / T h \text{T}{\text{h}} Th（确定值）：外部芯片的建立时间和保持时间，器件手册一般会给出一个笼统的值。

于是便可以得出建立时间关系和保持时间关系，注意"移项"是将常数项移项到数据需求时间中的减数项：

建立时间关系：
Data Arrival Time = Launch Edge + T c2i_pcb (max) + T c2i_fp (max) + T reg2pin (max) + T d_pcb (max) \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{c2i\pcb}}\text{(max)} + \text{T}{\text{c2i\fp}}\text{(max)} + \text{T}{\text{reg2pin}}\text{(max)} + \text{T}{\text{d\pcb}}\text{(max)} Data Arrival Time=Launch Edge+Tc2i_pcb(max)+Tc2i_fp(max)+Treg2pin(max)+Td_pcb(max)
Data Required Time = Latch Edge + T c2j_pcb (min) − T su \text{Data Required Time} = \text{Latch Edge} + \text{T}{\text{c2j\pcb}}\text{(min)} - \text{T}{\text{su}} Data Required Time=Latch Edge+Tc2j_pcb(min)−Tsu
Setup Time Slack = Data Required Time − Data Arrival Time \text{Setup Time Slack} = \text{Data Required Time} - \text{Data Arrival Time} Setup Time Slack=Data Required Time−Data Arrival Time

保持时间关系 ：
Data Arrival Time = Launch Edge + T c2i_pcb (min) + T c2i_fp (min) + T reg2pin (min) + T d_pcb (min) \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{c2i\pcb}}\text{(min)} + \text{T}{\text{c2i\fp}}\text{(min)} + \text{T}{\text{reg2pin}}\text{(min)} + \text{T}{\text{d\pcb}}\text{(min)} Data Arrival Time=Launch Edge+Tc2i_pcb(min)+Tc2i_fp(min)+Treg2pin(min)+Td_pcb(min)
Data Required Time = Latch Edge + T c2j_pcb (max) + T h \text{Data Required Time} = \text{Latch Edge} + \text{T}{\text{c2j\pcb}}\text{(max)} + \text{T}{\text{h}} Data Required Time=Latch Edge+Tc2j_pcb(max)+Th
Hold Time Slack = Data Arrival Time − Data Required Time \text{Hold Time Slack} = \text{Data Arrival Time} - \text{Data Required Time} Hold Time Slack=Data Arrival Time−Data Required Time

移项后的建立时间关系：
Data Arrival Time = Launch Edge + T c2i_fp (max) + T reg2pin (max) \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{c2i\fp}}\text{(max)} + \text{T}{\text{reg2pin}}\text{(max)} Data Arrival Time=Launch Edge+Tc2i_fp(max)+Treg2pin(max)
Data Required Time = Latch Edge − [ T c2i_pcb (max) − T c2j_pcb (min) + T d_pcb (max) + T su ] \text{Data Required Time} = \text{Latch Edge} - [\text{T}{\text{c2i\pcb}}\text{(max)} - \text{T}{\text{c2j\pcb}}\text{(min)} + \text{T}{\text{d\pcb}}\text{(max)} + \text{T}{\text{su}}] Data Required Time=Latch Edge−[Tc2i_pcb(max)−Tc2j_pcb(min)+Td_pcb(max)+Tsu]
Setup Time Slack = Data Required Time − Data Arrival Time \text{Setup Time Slack} = \text{Data Required Time} - \text{Data Arrival Time} Setup Time Slack=Data Required Time−Data Arrival Time

即： set_output_delay(max) = T c2i_pcb (max) − T c2j_pcb (min) + T d_pcb (max) + T su \text{set\_output\delay(max)} = \text{T}{\text{c2i\pcb}}\text{(max)} - \text{T}{\text{c2j\pcb}}\text{(min)} + \text{T}{\text{d\pcb}}\text{(max)} + \text{T}{\text{su}} set_output_delay(max)=Tc2i_pcb(max)−Tc2j_pcb(min)+Td_pcb(max)+Tsu

移项后的保持时间关系 ：
Data Arrival Time = Launch Edge + T c2i_fp (min) + T reg2pin (min) \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{c2i\fp}}\text{(min)} + \text{T}{\text{reg2pin}}\text{(min)} Data Arrival Time=Launch Edge+Tc2i_fp(min)+Treg2pin(min)
Data Required Time = Latch Edge − [ T c2i_pcb (min) − T c2j_pcb (max) + T d_pcb (min) − T h ] \text{Data Required Time} = \text{Latch Edge} - [\text{T}{\text{c2i\pcb}}\text{(min)} - \text{T}{\text{c2j\pcb}}\text{(max)} + \text{T}{\text{d\pcb}}\text{(min)} - \text{T}{\text{h}}] Data Required Time=Latch Edge−[Tc2i_pcb(min)−Tc2j_pcb(max)+Td_pcb(min)−Th]
Hold Time Slack = Data Arrival Time − Data Required Time \text{Hold Time Slack} = \text{Data Arrival Time} - \text{Data Required Time} Hold Time Slack=Data Arrival Time−Data Required Time

即： set_output_delay(min) = T c2i_pcb (min) − T c2j_pcb (max) + T d_pcb (min) − T h \text{set\_output\delay(min)} = \text{T}{\text{c2i\pcb}}\text{(min)} - \text{T}{\text{c2j\pcb}}\text{(max)} + \text{T}{\text{d\pcb}}\text{(min)} - \text{T}{\text{h}} set_output_delay(min)=Tc2i_pcb(min)−Tc2j_pcb(max)+Td_pcb(min)−Th

注：由于"数据到达路径"中不经过FPGA器件，所以没有不确定性时间 Clock Uncertainty Time \text{Clock Uncertainty Time} Clock Uncertainty Time 一项。

5.4 源同步接口的寄存器到引脚的时序路径分析

图5-9 时序寄存器模型--源同步接口的FPGA寄存器到外部芯片

源寄存器在FPGA器件中，目的寄存器在外部芯片中，两者通过级联的方式 ++间接共用++ 同一外部时钟源。

红色圆圈就是系统同步接口的源寄存器到目的寄存器的时序路径；绿色圆圈则是源寄存器到引脚的时序路径，是FPGA时序约束的关键(reg2pin \text{reg2pin} reg2pin路径 )，也就是需要告诉FPGA编译器该路径延时 T reg2pin \text{T}_{\text{reg2pin}} Treg2pin 的最大值和最小值。

图5-10 reg2pin路径模型--源同步接口的FPGA寄存器到外部芯片

数据到达路径：

T c2i_fp \text{T}_{\text{c2i\_fp}} Tc2i_fp（确定值）：时钟从时钟源到源寄存器时钟输入引脚的延时。

T reg2pin \text{T}_{\text{reg2pin}} Treg2pin（待确定）：数据从源寄存器上升沿锁存到 FPGA器件输出引脚的延时。

T d_pcb \text{T}_{\text{d\_pcb}} Td_pcb（确定值）：数据从 FPGA器件输出引脚到外部芯片输入引脚的PCB走线延时。

数据需求路径：

T c2j_fp \text{T}_{\text{c2j\_fp}} Tc2j_fp（待确定）：时钟从时钟源到 FPGA器件输出引脚的PCB走线延时。

T c2j_pcb \text{T}_{\text{c2j\_pcb}} Tc2j_pcb（确定值）：时钟从 FPGA器件输出引脚到外部芯片输入引脚的PCB走线延时。

T su \text{T}{\text{su}} Tsu / T h \text{T}{\text{h}} Th（确定值）：外部芯片的建立时间和保持时间，器件手册一般会给出一个笼统的值。

于是便可以得出建立时间关系和保持时间关系，注意"移项"是将常数项移项到数据需求时间中的减数项：

建立时间关系：
Data Arrival Time = Launch Edge + T c2i_fp (max) + T reg2pin (max) + T d_pcb (max) \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{c2i\fp}}\text{(max)} + \text{T}{\text{reg2pin}}\text{(max)} + \text{T}{\text{d\pcb}}\text{(max)} Data Arrival Time=Launch Edge+Tc2i_fp(max)+Treg2pin(max)+Td_pcb(max)
Data Required Time = Latch Edge + T c2j_fp (min) + T c2j_pcb (min) − T su − Clock Uncertainty Time \text{Data Required Time} = \text{Latch Edge} + \text{T}{\text{c2j\fp}}\text{(min)} + \text{T}{\text{c2j\pcb}}\text{(min)} - \text{T}{\text{su}} - \text{Clock Uncertainty Time} Data Required Time=Latch Edge+Tc2j_fp(min)+Tc2j_pcb(min)−Tsu−Clock Uncertainty Time
Setup Time Slack = Data Required Time − Data Arrival Time \text{Setup Time Slack} = \text{Data Required Time} - \text{Data Arrival Time} Setup Time Slack=Data Required Time−Data Arrival Time

保持时间关系 ：
Data Arrival Time = Launch Edge + T c2i_fp (min) + T reg2pin (min) + T d_pcb (min) \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{c2i\fp}}\text{(min)} + \text{T}{\text{reg2pin}}\text{(min)} + \text{T}{\text{d\pcb}}\text{(min)} Data Arrival Time=Launch Edge+Tc2i_fp(min)+Treg2pin(min)+Td_pcb(min)
Data Required Time = Latch Edge + T c2j_fp (max) + T c2j_pcb (max) + T h + Clock Uncertainty Time \text{Data Required Time} = \text{Latch Edge} + \text{T}{\text{c2j\fp}}\text{(max)} + \text{T}{\text{c2j\pcb}}\text{(max)} + \text{T}{\text{h}} + \text{Clock Uncertainty Time} Data Required Time=Latch Edge+Tc2j_fp(max)+Tc2j_pcb(max)+Th+Clock Uncertainty Time
Hold Time Slack = Data Arrival Time − Data Required Time \text{Hold Time Slack} = \text{Data Arrival Time} - \text{Data Required Time} Hold Time Slack=Data Arrival Time−Data Required Time

移项后的建立时间关系：
Data Arrival Time = Launch Edge + T c2i_fp (max) + T reg2pin (max) \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{c2i\fp}}\text{(max)} + \text{T}{\text{reg2pin}}\text{(max)} Data Arrival Time=Launch Edge+Tc2i_fp(max)+Treg2pin(max)
Data Required Time = Latch Edge + T c2j_fp (min) − [ T d_pcb (max) − T c2j_pcb (min) + T su ] − Clock Uncertainty Time \text{Data Required Time} = \text{Latch Edge} + \text{T}{\text{c2j\fp}}\text{(min)} - [\text{T}{\text{d\pcb}}\text{(max)} - \text{T}{\text{c2j\pcb}}\text{(min)} + \text{T}{\text{su}}] - \text{Clock Uncertainty Time} Data Required Time=Latch Edge+Tc2j_fp(min)−[Td_pcb(max)−Tc2j_pcb(min)+Tsu]−Clock Uncertainty Time
Setup Time Slack = Data Required Time − Data Arrival Time \text{Setup Time Slack} = \text{Data Required Time} - \text{Data Arrival Time} Setup Time Slack=Data Required Time−Data Arrival Time

于是，建立时间约束值： set_output_delay(max) = T d_pcb (max) − T c2j_pcb (min) + T su \text{set\_output\delay(max)} = \text{T}{\text{d\pcb}}\text{(max)} - \text{T}{\text{c2j\pcb}}\text{(min)} + \text{T}{\text{su}} set_output_delay(max)=Td_pcb(max)−Tc2j_pcb(min)+Tsu

移项后的保持时间关系 ：
Data Arrival Time = Launch Edge + T c2i_fp (min) + T reg2pin (min) \text{Data Arrival Time} = \text{Launch Edge} + \text{T}{\text{c2i\fp}}\text{(min)} + \text{T}{\text{reg2pin}}\text{(min)} Data Arrival Time=Launch Edge+Tc2i_fp(min)+Treg2pin(min)
Data Required Time = Latch Edge + T c2j_fp (max) − [ T d_pcb (min) − T c2j_pcb (max) − T h ] + Clock Uncertainty Time \text{Data Required Time} = \text{Latch Edge} + \text{T}{\text{c2j\fp}}\text{(max)} - [\text{T}{\text{d\pcb}}\text{(min)} - \text{T}{\text{c2j\pcb}}\text{(max)} - \text{T}{\text{h}}] + \text{Clock Uncertainty Time} Data Required Time=Latch Edge+Tc2j_fp(max)−[Td_pcb(min)−Tc2j_pcb(max)−Th]+Clock Uncertainty Time
Hold Time Slack = Data Arrival Time − Data Required Time \text{Hold Time Slack} = \text{Data Arrival Time} - \text{Data Required Time} Hold Time Slack=Data Arrival Time−Data Required Time

于是，保持时间约束值： set_output_delay(min) = T d_pcb (min) − T c2j_pcb (max) − T h \text{set\_output\delay(min)} = \text{T}{\text{d\pcb}}\text{(min)} - \text{T}{\text{c2j\pcb}}\text{(max)} - \text{T}{\text{h}} set_output_delay(min)=Td_pcb(min)−Tc2j_pcb(max)−Th

总结下来， set_input_delay \text{set\_input\_delay} set_input_delay 和 set_output_delay \text{set\_output\_delay} set_output_delay 的约束值计算公式，都是将时序路径中所有FPGA器件外部的延时信息汇总在一起，告诉FPGA编译工具，使其引导布局布线，使其内部的延时能够满足系统(FPGA器件和外部芯片)的时序要求。