分类 FPGA&ASIC 下的文章 - 我的学记|刘航宇的博客

登录 / 注册

FPGA&ASIC(共61篇)

找到 61 篇与 FPGA&ASIC 相关的结果

Python与Verilog实现卡尔曼滤波器 — 机器人位置估计摘要：本文介绍了卡尔曼滤波在机器人位置估计中的应用，分别用Python和Verilog实现了卡尔曼滤波器，并对比了两种实现方式的优缺点。目录一、引言：为什么机器人需要卡尔曼滤波？二、卡尔曼滤波的五大核心公式三、以机器人为例卡尔曼公式实现和说明设计运动传感器的观测值卡尔曼滤波四、Verilog实现：定点运算与硬件加速4.1 系统架构 4.2 核心代码解析（1）Kalman_1：状态预测（公式1）（2）Kalman_2_3：协方差预测与增益计算（公式2、3）（3）Kalman_4_5：状态与协方差更新（公式4、5）（4）Kalman_ctrl：数据源控制 4.3 10级流水线时序五、Python vs Verilog：对比分析六、总结工程参考代码清单Python仿真代码 Verilog完整工程文件一、引言：为什么机器人需要卡尔曼滤波？想象你开发了一个可以在树林里自主导航的机器人。为了知道它的实时位置，你在机器人上安装了GPS传感器，但GPS的精度大约为10米——在布满沟壑和悬崖的树林里，10米的误差足以让机器人坠入深渊。此时，你还可以获取一些额外的运动信息：里程计可以记录机器人的行走距离，惯性测量单元（IMU）可以感知姿态变化。但这些传感器同样存在噪声和漂移。GPS告诉了你"大概在哪"，里程计告诉了你"走了多远"，但两者都不完美。卡尔曼滤波（Kalman Filter）的核心思想正是：综合利用所有可用的信息，根据其本身的噪声特性分配权重，得到一个比任何单一估计都更准确的结果。本文将从原理出发，分别用 Python（浮点运算，算法验证）和 Verilog（定点运算，硬件加速）实现一维卡尔曼滤波器，用于机器人位置估计。二、卡尔曼滤波的五大核心公式卡尔曼滤波是一种最优线性递归估计算法，由预测（Prediction）和更新（Update）两个阶段组成，共五个核心公式：对于线性离散系统，卡尔曼滤波通过以下五个公式递归运行：阶段公式含义预测$\hat{X}_k^- = A\hat{X}_{k-1} + BU_{k-1}$先验状态估计：用上一时刻的最优估计预测当前状态预测$P_k^- = AP_{k-1}A^T + Q$先验误差协方差：预测的不确定性会累积更新$K_k = \frac{P_k^-H^T}{HP_k^-H^T + R}$卡尔曼增益：决定"更信预测还是更信测量"更新$\hat{X}_k = \hat{X}_k^- + K_k(Z_k - H\hat{X}_k^-)$后验状态估计：用测量残差修正预测更新$P_k = (I - K_kH)P_k^-$后验误差协方差：更新后的不确定性其中： $A$ 为状态转移矩阵，$B$ 为控制矩阵，$H$ 为观测矩阵 $Q$ 为过程噪声协方差，$R$ 为测量噪声协方差 $K_k$ 是卡尔曼增益，它是整个算法的"灵魂"：$P_k^-$ 越大（预测越不靠谱），$K_k$ 越大，越重视测量反馈。三、以机器人为例卡尔曼公式实现和说明下面我们用一个例子来说明上述卡尔曼滤波公式的内在逻辑。假如我们有一台轮式机器人 Robo 如图所示，它只能够进行一维直线运动。 pmqvRRH.png图片我们用状态向量 $\vec{x}$ 来表示机器人的当前状态： $\vec{x}=\left[ \begin{array}{c}{p} \\ {v}\end{array}\right] \\$ 其中 $p$ 和 $v$ 分别为相对于绝对坐标系 $O_1$ 的位移。那么我们要做的是，已知某时刻的最佳状态估计 $\hat{\mathbf{x}}_{k}$ ，预测下一时刻的最佳估计 $\hat{\mathbf{x}}_{k+1}$ 。设计运动我们为 Robo 设计一个匀加速直线运动。设初始状态向量为 $\vec{x_0}=\left[ \begin{array}{c}{0} &{1}\end{array}\right]^T $ ，并有一个加速指令性，使其以 $a = 0.1$ 的加速度做匀加速直线运动。那么根据匀加速直线运动的位移计算公式，任意时刻 $k$ 的位移 $p$ 与速度 $v$ 都可以由位移、速度、加速度递推得到： $\begin{aligned} p_{k} &=p_{k-1}+v_{k-1} \times \Delta k+a\times \frac{\Delta k^{2}}{2} \\ v_{k} &=v_{k-1}+a \times \Delta k \end{aligned} \tag{3} $ 将其转化为矩阵形式： $\left[ \begin{array}{c}{p_{k}} \\ {v_{k}}\end{array}\right]=\left[ \begin{array}{cc}{1} & {\Delta k} \\ {0} & {1}\end{array}\right] \left[ \begin{array}{c}{p_{k-1}} \\ {v_{k-1}}\end{array}\right]+\left[ \begin{array}{c}{\frac{\Delta k^{2}}{2}} \\ {\Delta k}\end{array}\right] a \tag{4}$ $x_{t}=F_{t} x_{t-1}+B_{t} a \\$ 我们取时间间隔 $\Delta k = 1$ ，由上式编程计算得到机器人的真实状态向量轨迹： import numpy as np import math import matplotlib.pyplot as plt if __name__=="__main__": ## 1.设计一个匀加速直线运动，以观测此运动 X_real = np.mat(np.zeros((2, 100))) # 空矩阵，用于存放真实状态向量 X_real[:, 0] = np.mat([[0.0], # 初始状态向量 [1.0]]) a_real = 0.1# 真实加速度 F = np.mat([[1.0, 1.0], # 状态转移矩阵 [0.0, 1.0]]) Q = np.mat([[0.0001, 0.0], # 状态转移协方差矩阵，我们假设外部干扰很小 [0.0, 0.0001]]) B = np.mat([[0.5], # 控制矩阵 [1.0]]) for i in range(99): X_real[:, i + 1] = F * X_real[:, i] + B * a_real # 计算真实状态向量 X_real = np.array(X_real) fig = plt.figure(1) plt.grid() plt.title('real displacement') plt.xlabel('k (s)') plt.ylabel('x (m)') plt.plot(X_real[0, :]) plt.show() fig = plt.figure(2) plt.grid() plt.title('real velocity') plt.xlabel('k (s)') plt.ylabel('v (m/s)') plt.plot(X_real[1, :]) plt.show() X_real = np.mat(X_real)pasted_1786518907327_xixy8e.png图片位移真实值 pasted_1786518920293_nxitzh.png图片速度真实值传感器的观测值我们有一台传感器 $O_2$ 放置于机器人的前方，它可以测得机器人位移 $s$ 和速度 $w$ 。当然，传感器自身本身有一定的噪声 $\xi$ ，其协方差为 $R$ 。由于传感器的信息是相对于自身坐标系 $O_2$ 的，而我们的状态向量 $\vec{x}$ 是相对于绝对坐标系 $O_1$ 的，二者的方向刚好相反，我们使用观测矩阵 $\mathbf{H}$ 来转换二者的关系。因此，相对于真实状态向量，传感器的观测向量可以表示如下： $\left[ \begin{array}{c}{s} \\ {w}\end{array}\right]=\left[ \begin{array}{cc}{-1} & 0\\ {0} & {-1}\end{array}\right] \left[ \begin{array}{c}{p} \\ {v}\end{array}\right]+\left[ \begin{array}{c}{\xi_p} \\ {\xi_v}\end{array}\right] \tag{5}$ $z_{t}=H x_{t}+\xi \\$ 我们设传感器噪声的协方差 $R$ 为单位阵(噪声方差为1)。根据上式编写程序，得到的传感器的观测值如下： ## 2.建立传感器观测值 z_t = np.mat(np.zeros((2, 100))) # 空矩阵，用于存放传感器观测值 H = np.mat(np.zeros((2, 2))) H[0, 0], H[1, 1] = -1.0, -1.0 noise = np.mat(np.random.randn(2,100)) # 加入位移方差为1，速度方差为1的传感器噪声 R = np.mat([[1.0, 0.0], # 观测噪声的协方差矩阵 [0.0, 1.0]]) for i in range(100): z_t[:, i] = H * X_real[:, i] + noise[:, i] z_t = np.array(z_t) fig = plt.figure(3) plt.grid() plt.title('sensor displacement') plt.xlabel('k (s)') plt.ylabel('x (m)') plt.plot(z_t[0, :]) plt.show() fig = plt.figure(4) plt.grid() plt.title('sensor velocity') plt.xlabel('k (s)') plt.ylabel('v (m/s)') plt.plot(z_t[1, :]) plt.show() z_t = np.mat(z_t)pasted_1786518974937_94intu.png图片传感器观测到的位移，与真实值相反且有噪声 pasted_1786519009388_5uhe6m.png图片传感器观测到的速度，与真实值相反且有噪声卡尔曼滤波前两步的操作主要是为了获取数据，现在我们利用预测和更新公式对以上数据进行卡尔曼滤波： ## 3.执行线性卡尔曼滤波 Q = np.mat([[1.0, 0.0], # 状态转移协方差矩阵，我们假设外部干扰很小， [0.0, 1.0]])# 转移矩阵可信度很高 # 建立一系列空序列用于储存结果 X_update = np.mat(np.zeros((2, 100))) P_update = np.zeros((100, 2, 2)) X_predict = np.mat(np.zeros((2, 100))) P_predict = np.zeros((100, 2, 2)) P_update[0, :, :] = np.mat([[1.0, 0.0], # 状态向量协方差矩阵初值 [0.0, 1.0]]) P_predict[0, :, :] = np.mat([[1.0, 0.0], # 状态向量协方差矩阵初值 [0.0, 1.0]]) for i in range(99): # 预测 X_predict[:, i + 1] = F * X_update[:, i] + B * a_real P_p = F * np.mat(P_update[i, :, :]) * F.T + Q P_predict[i + 1, :, :] = P_p # 更新 K = P_p * H.T * np.linalg.inv(H * P_p * H.T + R) # 卡尔曼增益 P_u = P_p - K * H * P_p P_update[i + 1, :, :] = P_u X_update[:, i + 1] = X_predict[:, i + 1] + K * (z_t[:, i + 1] - H * X_predict[:, i + 1]) X_update = np.array(X_update) X_real = np.array(X_real) fig = plt.figure(5) plt.grid() plt.title('Kalman predict displacement') plt.xlabel('k (s)') plt.ylabel('x (m)') plt.plot(X_real[0, :], label='real', color='b') plt.plot(X_update[0, :], label='predict', color='r') plt.legend() plt.show() fig = plt.figure(6) plt.grid() plt.title('Kalman predict velocity') plt.xlabel('k (s)') plt.ylabel('v (m/s)') plt.plot(X_real[1, :], label='real', color='b') plt.plot(X_update[1, :], label='predict', color='r') plt.legend() plt.show() X_update = np.mat(X_update) X_real = np.mat(X_real)pasted_1786519044132_v2numq.png图片位移卡尔曼滤波结果 pasted_1786519056398_qpvdv1.png图片速度卡尔曼滤波结果可以看出，卡尔曼滤波将存在误差的传感器信号和状态向量很好的融合，较好地预测出了真实地机器人运动状态。四、Verilog实现：定点运算与硬件加速当我们需要将卡尔曼滤波部署到FPGA或ASIC上时，Python的浮点运算就不再适用。硬件实现需要考虑：定点数表示、流水线设计、时序约束和资源复用。附件中的Verilog代码展示了一个轻量级、10级流水线的卡尔曼滤波器实现。 4.1 系统架构 pasted_1786519272107_29m7o0.png图片整个系统分为5个模块：模块功能对应公式Kalman顶层模块，实例化子模块并连接信号—Kalman_1预测状态 X^-公式1Kalman_2_3预测协方差 P^- 并计算增益 Kg公式2、3Kalman_4_5更新状态 X 和协方差 P公式4、5Kalman_ctrl数据控制器，从DPRAM读取测量值—以及3个共享运算器：add（加减法）、mux（乘法）、div（除法）。 4.2 核心代码解析（1）Kalman_1：状态预测（公式1） module Kalman_1( input clk_50M, input Rst_n, input [15:0] X_last, // t-1时刻的后验估计 input [15:0] B_X_last, // 控制输入（预留，当前为0） output reg [15:0] X_ // t时刻的先验估计 ); // 流水线计数 0~9 always@(posedge clk_50M or negedge Rst_n) begin if(!Rst_n) X_ <= 16'd0; else begin case (Count) 4'd1: begin X_ <= X_last; // X^- = X_last（简化模型） end // ... 其他时钟周期可用于更复杂的预测 endcase end end endmodule设计要点：当前实现为简化模型，直接令 X^- = X_last。B_X_last 预留了控制输入接口，可扩展为带速度项的运动模型。（2）Kalman_2_3：协方差预测与增益计算（公式2、3） module Kalman_2_3( input clk_50M, input Rst_n, input [15:0] P_last, output reg [15:0] P_, output reg [15:0] Kg ); reg [15:0] Q_error = 0; // 系统过程协方差 reg [15:0] R_error = 3; // 测量噪声协方差 always@(posedge clk_50M or negedge Rst_n) begin case (Count) 4'd1: begin ADD_sub <= 1'd1; // 加法 ADD_dataa <= P_last * 'd100; // P_last 放大100倍 ADD_datab <= Q_error; // + Q end 4'd2: begin P_ <= ADD_result; // P^-（仍放大100倍） ADD_dataa <= ADD_result / 'd10; // 缩小10倍 ADD_datab <= R_error * 'd10; // R 放大10倍 end 4'd3: begin DIV_dataa <= P_; // 被除数 = P^-（×100） DIV_datab <= ADD_result; // 除数 = P^-/10 + R×10 end 4'd4: begin Kg <= DIV_result; // Kg = P^- / (P^- + R) P_ <= P_ / 'd100; // P^- 恢复原始量级 end endcase end endmodule定点数与缩放处理：这是硬件实现中最关键的部分。由于16位定点数无法直接表示小数，代码采用了缩放因子（Scaling Factor）策略： P_last * 100：将协方差放大100倍，避免小数被截断 R_error * 10：测量噪声放大10倍最终 Kg 的计算结果也需要在后续模块中相应缩放 // 在Kalman_4_5中处理缩放还原 MULT_datab <= ADD_result / 'd10; // 乘法结果缩小10倍 ADD_datab <= Kg / 10; // Kg缩小10倍用于1-Kg计算（3）Kalman_4_5：状态与协方差更新（公式4、5） module Kalman_4_5( input clk_50M, input Rst_n, input [15:0] in_data, // 测量值 Z input [15:0] X_, // 先验估计 input [15:0] P_, // 先验协方差 input [15:0] Kg, // 卡尔曼增益 output reg [15:0] X, // 后验估计 output reg [15:0] P // 后验协方差 ); always@(posedge clk_50M or negedge Rst_n) begin case (Count) 4'd2: begin // 计算 |Z - X^-|，通过比较大小确定减法顺序 if(in_data > X_) begin ADD_dataa <= in_data; ADD_datab <= X_; end else begin ADD_dataa <= X_; ADD_datab <= in_data; end end 4'd5: begin MULT_dataa <= Kg; MULT_datab <= ADD_result; // Kg * |Z - X^-| end 4'd6: begin // 根据in_data和X_的大小关系，决定加或减 if(in_data > X_) ADD_sub <= 1'd1; // 加法：X = X^- + Kg*(Z-X^-) else ADD_sub <= 1'd0; // 减法：X = X^- - Kg*(X^- - Z) ADD_dataa <= X_; ADD_datab <= MULT_result / 'd10; end 4'd7: begin X <= ADD_result; // 输出更新后的状态 ADD_dataa <= 16'd1; ADD_datab <= Kg / 10; // 1 - Kg/10 end 4'd8: begin MULT_dataa <= P_; MULT_datab <= ADD_result; // P = P^- * (1 - Kg) end 4'd9: begin P <= MULT_result; // 输出更新后的协方差 end endcase end endmodule有符号数处理技巧：由于Verilog中 [15:0] 默认是无符号数，代码巧妙地通过先取绝对值做减法，再根据大小关系决定加减，避免了有符号数运算的复杂性。（4）Kalman_ctrl：数据源控制该模块模拟了传感器数据源。实际应用中，这里可以替换为ADC接口、串口接收或传感器总线（如I2C/SPI）。 4.3 10级流水线时序 pasted_1786519515333_7gcyvi.png图片每个滤波周期 = 10个时钟周期 @ 50MHz = 200ns，即每秒可处理500万次滤波迭代，这是硬件加速相比软件的巨大优势。五、Python vs Verilog：对比分析对比维度Python实现Verilog实现数据表示IEEE 754 双精度浮点（64位）16位定点整数 + 缩放因子运算精度高（~15位有效数字）有限（受限于位宽和缩放策略）执行速度受限于CPU，~μs级50MHz时钟，200ns/次迭代资源消耗内存（MB级）LUT/FF/DSP（硬件资源）开发难度低，代码简洁高，需处理时序、缩放、位宽适用场景算法验证、仿真、离线分析实时嵌入式、FPGA加速、ASIC可移植性跨平台依赖具体FPGA/ASIC工艺关键差异——定点数缩放： Python中可以直接写 Kg = P_pred / (P_pred + R)，而Verilog中必须手动管理数值范围： # Python：自然优雅 Kg = P_pred / (P_pred + R) # 0.09... X = X_pred + Kg * (z - X_pred)// Verilog：需要精心设计的缩放 // P_last * 100 -> ADD -> /100 -> DIV -> Kg // Kg / 10 -> MULT -> /10 -> ADD -> X这种"不优雅"是硬件实现的代价，但也是达到实时性能的必要手段。六、总结卡尔曼滤波是机器人状态估计的基石算法。本文从机器人位置估计这一经典场景出发：原理层面：梳理了卡尔曼滤波的五大核心公式，阐明了预测与更新的闭环逻辑。 Python层面：利用浮点运算实现了算法原型，验证了滤波器对噪声的抑制效果和增益收敛特性。 Verilog层面：设计了10级流水线的定点数实现，通过缩放因子策略在16位位宽下完成了滤波运算，达到了200ns/次迭代的实时性能。两种实现方式各有其用：Python用于"想清楚"，在算法层面验证正确性；Verilog用于"跑得快"，在硬件层面实现实时处理。在实际工程中，通常先用Python/MATLAB进行算法仿真和参数整定，再将验证通过的算法移植到Verilog/VHDL进行硬件部署——这正是从算法到芯片的完整开发流程。工程参考代码清单 Python仿真代码见上文第三节完整代码。 Verilog完整工程文件

FPGA&ASIC 通信&信息处理 VLSI&IC验证软硬件算法 # ASIC/FPGA # 信号处理 # Verilog # 软件算法

刘航宇 8月12日
1 45 2
在FPGA上部署轻量BP神经网络-Python与Verilog：信号检测实战摘要：本文介绍了在FPGA上部署轻量BP神经网络进行信号检测的实战，包括系统架构、神经网络模型设计、FPGA硬件实现详解以及关键优化技巧，实验结果表明该方案功耗低、性能好。目录储备知识：一、背景：为什么要在FPGA上跑神经网络？二、系统整体架构三、神经网络模型设计：极致轻量四、FPGA硬件实现详解4.1 串并转换模块（Serial-to-Parallel 4.2 数据归一化模块 4.3 隐藏层神经元模块（核心计算单元） 4.4 ReLU激活函数模块 4.5 输出层神经元模块 4.6 阈值判断模块五、关键优化技巧5.1 归一化的"逆向"处理 5.2 权值二值化（BWN）降低功耗 5.3 亚稳态消除六、实验结果：功耗与性能七、总结与思考 python和verilog源程序下载储备知识：我们在前文讲了BP神经网络算法和激活函数 BP神经网络算法 https://ee.ac.cn/index.php/archives/612.html 激活函数讲解 https://ee.ac.cn/index.php/archives/617.html 一、背景：为什么要在FPGA上跑神经网络？在无源物联网（Battery-free IoT）和反向散射通信（Backscatter）场景中，传统的信号检测方法（如能量检测）虽然电路简单，但无法区分同频段的多种信号，且受噪声影响大；而基于PC或GPU的深度学习方案虽然精度高，但功耗动辄数十瓦，显然无法部署在依赖能量采集的微瓦级标签上。核心矛盾在于：缺乏一种检测精度高、功耗极低（毫瓦级）、且能实时处理的解决方案。答案是将轻量级的BP神经网络部署到低功耗FPGA上，在边缘端完成信号推理。二、系统整体架构整个检测系统的链路如下：目标信号 → 天线 → 阻抗匹配 → LNA放大 → 包络检波(ENV) → ADC采样(1MSPS, 12bit) → FPGA(BP神经网络推理) → 调制控制信号在FPGA内部，BP神经网络负责识别当前输入的512点采样数据是否为目标信号的前导码（Preamble）。一旦识别成功，输出控制信号，开启后端的Backscatter调制模块。 FPGA选型：Actel IGLOO/e系列 AGLE600V5-FG484。选择它的原因是： Flash架构：上电即运行，无需外部配置芯片，适合无源系统；超低功耗：静态功耗仅0.046mW，适合能量采集场景；资源适中：13824个逻辑单元，足以容纳轻量级网络。三、神经网络模型设计：极致轻量为了在FPGA上高效部署，网络结构必须足够"轻"。本文设计的网络结构如下： pasted_1785558315326_lc6zyp.png图片层级神经元数说明输入层512对应ADC采集的一条信号的512个采样点隐藏层2仅2个神经元，大幅降低计算量输出层1二分类：是目标信号(1) / 非目标信号(0)激活函数：隐藏层和输出层均采用 ReLU。 $$f(x) = \max(0, x)$$ 选择ReLU的原因不仅是训练效果好，更重要的是硬件实现极其简单——只需一个比较器判断正负，无需计算指数或乘法，这对FPGA非常友好。 pasted_1785561816152_bsny25.png图片训练环境：TensorFlow/Keras，使用Adam优化器和MSE损失函数。在真实环境数据集上训练后，测试集识别准确率可达 95.76%。 pasted_1785561967835_yy5zgm.png图片四、FPGA硬件实现详解 FPGA内部的神经网络是一个纯推理引擎。本节按数据流方向，逐个拆解每个模块的设计思路和Verilog实现要点。 pasted_1785562098406_gf64mu.png图片整体RTL结构如下： pasted_1785563631508_f74j4w.png图片 4.1 串并转换模块（Serial-to-Parallel pasted_1785563649652_chqrj8.png图片 ADC（ADS7042）在片选信号CS拉低后，先输出2个前导0，再输出12位有效数据（D11→D0），每个数据位占用一个CLK周期。设计要点： CS和CLK由FPGA内部产生，CS每16个CLK周期拉低一次；在CS下降沿开始，用计数器对串行数据移位寄存；凑齐12位有效数据后，输出一组并行数据 adc_data[11:0]。波形图 pmhbofe.png图片 module serial_p(input data0_in,input cs,input clk,output[12:0] data0_out,input rst); reg[11:0] temp; reg[12:0] save; integer count; integer cnt; always @(negedge clk or negedge rst) begin if(!rst) begin//reset temp<=12'b000000000000; count<=-1; save<=12'b111111111111; cnt<=-1; end else if(cs&&count%16==0) begin save<={1'b0,temp}; count<=1; cnt<=cnt+1; if(cnt==512) begin cnt<=1; end end else if(cs) begin temp<=12'b0; count<=1; end else if(count<3) count<=count+1; else begin temp<={temp,data0_in}; count<=count+1; end end assign data0_out=save; endmodule 4.2 数据归一化模块问题：训练时，输入数据被归一化到 [0, 1.8]（对应ADC参考电压1.8V）。如果在FPGA中直接用除法做 Vin = adc_data / 4095 * 1.8，会消耗大量逻辑资源（FPGA做除法器代价极高）。解决方案：在软件端完成归一化，FPGA端只做整数运算。具体做法：在Python/Keras训练时，将输入数据 x 归一化为 x_norm = x / 4095 * 1.8；在提取权值时，将第一层权值 w 除以 1.8 并放大 1024 倍取整；这样FPGA输入的原始ADC值 adc_data（范围0~4095）直接与预处理后的权值相乘，等效于完成了归一化+加权。 # 创建一个自定义的回调对象 cb = MyCallback() # 以只读方式打开训练数据文件 with open('/content/work/data/data.txt') as traindata: # 读取文件内容 data = traindata.read() # 将文件内容转换为numpy数组，并将数据类型转换为float，并将数组形状调整为(47100, 2) data = np.array(list(data.split()), dtype=float).reshape((47100, 2)) # 创建一个最大最小归一化对象 min_max_scaler = preprocessing.MinMaxScaler() # 归一化 data = data * (1/65535) # 以只读方式打开训练标签文件 with open('/content/work/data/label.txt') as labda: # 读取文件内容 labels = labda.read() # 将文件内容转换为numpy数组，并将数据类型转换为float，并将数组形状调整为(47100, 2) labels = np.array(list(labels.split()), dtype=float).reshape((47100, 2)) # 对data和labels进行乱序，保持它们的对应关系 # 为了保持对应关系，需要先将data和labels沿着第二个维度拼接起来，形成一个(100, 4)的数组 # 然后对这个数组进行乱序，再将它们沿着第二个维度分开，还原成data和labels data_labels = np.concatenate((data, labels), axis=1) np.random.shuffle(data_labels) data = data_labels[:, :2] labels = data_labels[:, 2:]FPGA端实现：实际上，归一化模块在FPGA中被合并到了权值预处理阶段，硬件上不需要额外的归一化电路。但为了模块化清晰，也可以显式设计一个"电压映射"模块，将12bit ADC码值转换为定点数格式：工程建议：永远不要在FPGA里做除法。所有线性变换（归一化、缩放）都应在软件端合并到权值中，FPGA只做整数乘加。 4.3 隐藏层神经元模块（核心计算单元）隐藏层的数学表达式： $$y = \text{ReLU}\left( \sum_{i=1}^{512} x_i \cdot w_i + b \right)$$ , i = 1..512 工程难点： 512次乘累加如果在一个时钟周期完成，需要512个乘法器，资源爆炸；如果纯串行完成，需要512个时钟周期，一条chirp要512×512=262144个周期，太慢。解决方案：采用串行MAC流水线 + 双缓冲FIFO 架构。设计思路：权值存储：512个权值和1个偏置在编译时以 reg [31:0] w[0:511] 形式固化在FPGA中； FIFO缓存：ADC每输出一个采样点，立即写入FIFO。FIFO深度设为16即可（只要保证不溢出），因为读出速度（MAC运算）和写入速度（ADC采样）基本匹配；串行MAC：每个时钟周期从FIFO读出一个数据 xi，与对应的 wi 相乘，累加到累加器 acc； 512个周期后：累加器结果加上偏置 b，送入ReLU模块。 pasted_1785563798085_32317i.png图片 FIFO波形图 pmhqDBt.png图片关键设计细节：位宽设计：输入22bit × 权值32bit = 乘法结果54bit，累加512次需要额外9bit，因此累加器至少需要 63bit。如果位宽不够，累加会溢出，导致结果完全错误。时序约束：乘法器和加法器要满足16MHz时钟的建立保持时间。如果组合逻辑延迟太大，需要插入流水线寄存器（将乘法器和加法器分两级完成）。双神经元并行：隐藏层有2个神经元，需要例化两个上述模块，各自独立的权值存储和累加器，但共享同一个FIFO输入。 4.4 ReLU激活函数模块 ReLU的硬件实现是整个网络中最简单的部分： pmhqWcj.png图片 module relu ( input wire clk, input wire rst_n, input wire [31:0] x_in, // MAC+bias结果 input wire x_valid, output reg [31:0] y_out, output reg y_valid ); always @(posedge clk or negedge rst_n) begin if (!rst_n) begin y_out <= 32'd0; y_valid <= 1'b0; end else begin y_valid <= x_valid; if ($signed(x_in) >= 0) y_out <= x_in; else y_out <= 32'd0; end end endmodule4.5 输出层神经元模块输出层只有1个神经元，输入是隐藏层2个神经元的输出： $$\text{output} = \text{ReLU}\left( h_1 \cdot w'_1 + h_2 \cdot w'_2 + b' \right)$$ 这个模块与隐藏层类似，但逻辑资源消耗极小。 pmhq7NT.png图片 module nerual_out( clk, rst,x1,x2,data_out ); input clk, rst; input signed[0:49] x1,x2; output signed[79:0] data_out; //<statements> //reg signed[0:28] weight[0:1]; reg signed[0:7] save,save1,save2; localparam bais=-50'd214979034352654; //localparam bais = -26'd6406874; localparam weight0 = 29'd22506522; localparam weight1 =-29'd341584992; //integer bais; integer count; always @(negedge clk or negedge rst) begin if(!rst) //reset,set values and bias begin // bais<=-50'd214979034352654; // weight[0]<=29'd22506522; // weight[1]<=-29'd341584992; save<=0; save1<=0; save2<=0; count<=0; end else begin save1<=x1*weight0; save2<=x2*weight1; count<=count+1; if(count>518) save<=save1+save2+bais;//Multiply the input by the weights and add up the results end end assign data_out=save; endmodule4.6 阈值判断模块为什么需要阈值判断？前面提到，我们在保存权值时将所有参数扩大了 1024 倍（即 $2^{10}$）。这意味着：隐藏层的输出值也被放大了约1024倍；输出层的计算结果同样被放大；原本训练时，输出层ReLU后大于0即判定为目标信号；现在由于数值被放大，不能简单以0为界，需要设定一个等效的阈值。阈值推导：原始判定边界：输出 > 0.5（二分类常用阈值）；放大后等效边界：threshold = 0.5 × 1024 × 1024 = 524288；实际上，由于隐藏层和输出层都放大了1024倍，总放大倍数为 $1024^2 = 1048576$，因此： threshold = 0.5 × 1048576 = 524288。波形图 pmhqXv9.png图片五、关键优化技巧 5.1 归一化的"逆向"处理再次强调这个最重要的优化：处理方式FPGA资源消耗推荐度FPGA内做除法（adc/4095）极高，需除法器IP❌FPGA内用移位近似除法中等，精度损失大△权值预处理（本文方法）零额外消耗✅具体做法：训练时归一化：$V_{\text{in}} = \frac{\text{adc_data}}{4095} \times 1.8$；提取权值时：$w' = \frac{w}{1.8} \times 1024$，取整； FPGA输入：直接使用原始ADC值 $x$（0~4095）；等效运算。 5.2 权值二值化（BWN）降低功耗为了进一步压缩模型、降低功耗，本文采用了 Binary-Weight-Networks (BWN) 对权值进行二值化：权值只取 +1 或 -1；引入缩放因子 α 保证量化后的权值尽可能接近原始浮点权值。二值化后，乘法运算退化为加减法或符号位判断，FPGA资源占用和动态功耗大幅下降。虽然精度略有损失，但在本场景中仍能保持97%以上的识别率。二值化乘法器的Verilog实现： // 二值化权值乘法：只需判断符号 wire signed [31:0] product; assign product = bin_weight ? x_in : -x_in; // bin_weight=1为正，0为负相比32bit×32bit的硬件乘法器，这个逻辑几乎不消耗DSP资源。 5.3 亚稳态消除 ADC数据输入和CS信号是异步信号（相对于16MHz系统时钟），必须做双级触发器同步，防止亚稳态传播： reg adc_dat_d1, adc_dat_d2; always @(posedge clk) begin adc_dat_d1 <= adc_dat; // 第一级 adc_dat_d2 <= adc_dat_d1; // 第二级（稳定后使用） end wire adc_dat_sync = adc_dat_d2;六、实验结果：功耗与性能通过 Actel Libero SOC 对FPGA各模块进行功耗仿真，结果如下：工作模式静态功耗动态功耗总功耗空闲态0.046 mW00.046 mW正常工作0.046 mW2.79 mW2.835 mWFlash*Freeze模式0.115 mW00.115 mW2.835 mW 的总功耗，对于低功耗设备来说是完全可以接受的。各子模块动态功耗分解：串并转换：0.01 mW 隐藏层神经元（含FIFO）：0.083 mW ReLU激活：0.067 mW 输出层神经元：0.067 mW 七、总结与思考本文介绍了一套完整的从算法到硬件的轻量化神经网络部署方案：算法层：针对低功耗约束，设计了512-2-1极简BP网络，避免使用CNN/RNN等重算力模型；数据层：在真实环境中采集目标信号，建立含噪样本库，并通过数据增强提升泛化能力；硬件层：基于Actel低功耗FPGA，用FIFO流水、整数运算、ReLU硬判决、权值二值化等手段，实现了毫瓦级推理；系统层：与射频前端（LNA、包络检波、ADC）紧密配合，形成完整的标签信号检测链路。可扩展性：该FPGA神经网络框架不仅可用于目标信号检测，只需更换训练数据集和权值参数，即可用于FMCW、RFID等其他射频信号的识别，具备良好的通用性。 python和verilog源程序下载

FPGA&ASIC 通信&信息处理机器学习软硬件算法 # ASIC/FPGA # 信号处理 # 机器学习 # 软件算法 # 物联网 # Python

刘航宇 8月1日
0 45 6
数字IC设计项目高性能FFT芯片设计（前后端全流程）摘要：本项目基于SMIC 0.18 μm工艺，设计并实现了16点基-4 FFT算法芯片，工作频率135 MHz，面积4.6953 mm²，单次FFT能耗5.25×10⁻⁶ mJ。项目涵盖RTL建模、功能仿真、逻辑综合与物理实现，并提供了源码与项目文件。目录一、设计规范简介1.1 功能描述 1.2 性能指标能耗计算单位面积功耗时间操作次数二、电路性能分析与结构设计2.1 性能估算面积开销运算性能吞吐率带宽工作频率 2.2 硬件结构图 2.3 流水线时序设计 2.4 时序过程三、RTL 模型与仿真验证3.1 验证方法 3.2 验证平台搭建 3.3 仿真验证结果3.3.1 功能点验证 3.3.2 第一组数据验证对比 3.3.3 测试向量 3.3.4 仿真性能统计四、逻辑综合策略与结果4.1 逻辑综合流程参数设置 4.2 逻辑综合结果时序结果面积结果功耗结果资源使用设计违例五、物理实现与结果分析5.1 ICC 设计步骤5.1.1 数据设定 (Data Setup) 5.1.2 布局规划 (Floorplanning) 5.1.3 布局 (Placement) 5.1.4 时钟树综合 (CTS) 5.1.5 布线 (Routing) 5.2 ICC 设计结果5.2.1 芯片概貌 5.2.2 时序结果 5.2.3 面积结果 5.2.4 功耗结果 5.2.5 芯片压降 5.2.6 拥塞分析 5.2.7 资源使用 5.2.8 设计违例六、设计总结6.1 遇到的主要问题 6.2 相应的解决思路 6.3 关键优化点乘法器优化（频率提升核心）七、参考资料八、项目工程下载（源码、文档和参考文献）一、设计规范简介 1.1 功能描述本次课程设计的核心目标是实现一个高能效的快速傅里叶变换（FFT）电路，具体规格如下：算法：16 点基-4 FFT 算法输入数据：实部与虚部均为 17 bit（1 bit 符号位 + 8 bit 整数位 + 8 bit 小数位）旋转因子：实部与虚部均为 8 bit（1 bit 符号位 + 7 bit 数据位）数据格式：定点数表示，如图 1 所示图 1 16 点基-4 FFT 蝶形运算原理图 pasted_1785032408236_t4qsdl.png图片图 2 数据表示方式（17 bit 输入 / 8 bit 旋转因子）运算数据的实部虚部均为17 bit 而旋转因子的实部与虚部为8 bit pm2xSTf.png图片1.2 性能指标评价指标具体数值完成一次 16 点 FFT 运算的能耗5.25118208 × 10⁻⁶ mJ单位面积功耗时间 FFT 操作次数4.1987688 × 10⁴ 次/(mm²·mW·s)工作频率135.135135 MHz面积开销4.695300 mm²能耗计算单次 FFT 能耗 = 每秒能耗 / 每秒 FFT 运算次数 = 44.3512 mW/s / (1 / (16 × 7.4 ns)) = 5.251182 × 10⁻⁶ mJ单位面积功耗时间操作次数单位面积功耗时间 FFT 操作次数 = 每秒 16 点 FFT 运算次数 / (面积 × 功耗 × 时间) = (1 / (16 × 7.4 ns)) / (4.535456 mm² × 44.3512 mW × 1 s) = 4.1987688 × 10⁴ 次/(mm²·mW·s)二、电路性能分析与结构设计 2.1 性能估算面积开销芯片共有 90 个管脚，布局尺寸计算如下：长：76 μm × 23 + 210 μm × 2 = 2168 μm = 2.168 mm 宽：76 μm × 22 + 210 μm × 2 = 2092 μm = 2.092 mm 总面积：2.168 mm × 2.092 mm = 4.535456 mm² pasted_1785034131111_9ws1vf.png图片运算性能每秒可完成 FFT 运算次数 = 1 s / (16 × 7.4 ns) = 8.445946 × 10⁶ 次吞吐率芯片采用串行输入输出方式，每 16 个周期完成一次信号输入，从输入第 13 个信号时开始蝶形运算，经过 8 个周期完成运算，再经过 16 个周期输出：单次运算周期：13 + 8 + 16 = 37 个周期单次运算吞吐率：1 / (37 × 7.4 ns) = 3.65 × 10⁶ 次/秒由于采用了三级流水线架构，在连续运算足够多的情况下：流水运算周期：16 个周期（每周期输出一个结果）流水吞吐率：1 / (16 × 7.4 ns) = 8.45 × 10⁶ 次/秒带宽存储器时钟频率和数据输入速度保持恒定，峰值带宽与平均带宽相同：带宽 = 17 bit × 2(实部+虚部) × 135.135135 MHz = 4.595 Gbps工作频率工作频率 = 1 / 时钟周期 = 1 / 7.4 ns = 135.135135 MHz2.2 硬件结构图图 3 电路硬件结构图 pm2x9k8.png图片整个电路分为以下模块：模块名称文件名模块类型功能描述控制模块ctrl时序逻辑控制电路中各个模块的运行时序串转并模块s_p时序逻辑将串行输入的数据整合为并行并改变顺序复选器mux时序逻辑按照 FFT 级数选择进入运算模块的数据中转存储模块reg1时序逻辑存储并转发两级 FFT 运算间的运算数据运算模块（蝶形运算）butterfly组合逻辑进行四输入蝶形运算乘法器multi16组合逻辑计算数据与旋转因子间的乘法并转串模块p_s时序逻辑将并行输出的数据分解为串行并倒位序2.3 流水线时序设计时钟周期1-1617-2122-2930-37input第 N 组输入数据到 REG1第 N+1 组输入数据到 REG1——calculate—两级蝶形运算两级蝶形运算—output——第 N-1 组从 REG3 输出第 N 组从 REG3 输出2.4 时序过程 pasted_1785033901140_9815cd.png图片三、RTL 模型与仿真验证 3.1 验证方法 FFT 芯片的验证包括两部分：输出结果验证：通过 testbench 输入数据，将仿真输出与理论正确结果对比流水线验证：一次输入多组数据，观察电路是否能流水式执行 3.2 验证平台搭建在 ModelSim SE-64 10.1c 中，将所有模块的 Verilog 代码通过 top 文件连接，撰写 testbench 从指定文本文件读入输入数据并进行计算。 3.3 仿真验证结果 3.3.1 功能点验证取三组输入作为测试向量，验证输出结果正确性与流水线功能。图 4 测试波形（流水线时序验证） pmR29yj.png图片从波形可见，p_s 模块数据按预期工作：每周期进入 4 个数据，逐个输出，上一组数据输出完毕后下一周期立即输出下一组，流水式执行衔接良好。3.3.2 第一组数据验证对比 X[k]理论输出（实部）实际输出（实部）理论输出（虚部）实际输出（虚部）X[0]0_00010010_000000000_00010001_110010000_00010010_000000000_00010001_10111000X[1]0_00000101_011011100_00000101_010111101_11110000_101110101_11110000_11100101X[2]1_11110110_000000001_11110110_001001100_00000100_001111100_00000100_00101101X[3]0_00000010_000011010_00000010_000000110_00001010_010111000_00001010_00111100X[4]0_00001000_000000000_00000111_111011001_11110110_000000001_11110110_00101000X[5]1_11110110_001100001_11110111_010011010_00000011_100100000_00000011_10000100X[6]0_00000011_001010110_00000011_000111000_00000010_111000000_00000001_01100101X[7]0_00000000_011011010_00000000_011101000_00000010_111000000_00000010_11100001X[8]0_00000010_000000000_00000010_000010001_11111110_000000001_11111110_00001000X[9]0_00000101_111000010_00000101_110100101_11111111_111101011_11111111_11110111X[10]1_11110110_000000001_11110110_001001101_11111011_110000011_11111011_11010001X[11]0_00001001_010000100_00001001_001001110_00000100_111100110_00000100_11100010X[12]1_11111100_000000001_11111100_000111001_11111010_000000001_11111010_00011000X[13]1_11111101_011111111_11111101_100010110_00000011_101111110_00000011_10110000X[14]0_00001000_110101000_00001000_101100001_11111110_100101011_11111110_10011101X[15]1_11110100_010000101_11110100_011010101_11110101_110011111_11110101_11110001图 5 Transcript 输出 pasted_1785032904139_lcns0m.png图片通过对比可知，实际输出与理论输出的实部与虚部均十分接近，在误差范围内可认为相等（存在数据位宽限制等不可避免的截断误差）。第二组、第三组数据经同样验证，结果一致。3.3.3 测试向量第一组测试向量： 0000000010000000000000000000000000 0000000000000000000000000000000000 0000000010000000000000000000000000 0000000000000000000000000000000000 0000000110000000000000000000000000 0000000100000000000000010000000000 0000000010000000000000100000000000 0000000100000000000000001000000000 0000000010000000000000000000000000 0000000100000000000000010000000000 0000000010000000000000000000000000 0000000000000000000000000000000000 0000000010000000000000000000000000 0000000010000000000000000000000000 0000000010000000000000000000000000 0000000010000000000000000000000000第二组测试向量：全 1 序列（16 个相同数据）第三组测试向量：仅第一个数据为 1，其余为 0 3.3.4 仿真性能统计 ✅ 成功实现 16 点 FFT 算法，输出结果与理论值一致 ✅ 每周期输入一个数据，每周期输出一个数据 ✅ 成功实现流水式运行 ✅ 多次测试输出结果稳定，未出现错误四、逻辑综合策略与结果 4.1 逻辑综合流程使用 Synopsys Design Compiler (DC) 进行逻辑综合，主要流程：指定库文件 → 读入设计(转GTECH) → 定义环境 → 设计约束 → 编译策略 → 综合优化 → 存储网表pasted_1785034037920_i4ehar.png图片参数设置参数数值工艺SMIC 0.18 μm时钟周期7.4 ns输入输出延迟3.7 ns工作电压1.62 V运行温度125 ℃面积约束0（无约束）互连模型balanced_tree时钟延时4.3 ns不确定时钟0.5 ns过渡时钟0.2 ns端口最大过渡3 ns4.2 逻辑综合结果时序结果项目时间 (ns)clock clk (rise edge)7.40clock network delay (ideal)4.30clock uncertainty-0.50clk slack (MET)0.007.4 ns 时钟符合设计要求，换算工作频率约为 135 MHz。面积结果项目数量项目面积 (μm²)Ports70Combinational area1,483,546.41Nets140Non-combinational area153,599.85Cells71Net Interconnect area2,089,790.57References3Total Area3,726,936.83功耗结果项目数值Global Operating Voltage1.62 VCell Internal Power756.0848 mWNet Switching Power375.6310 mWTotal Dynamic Power1.1317 WCell Leakage Power28.5281 μW资源使用项目数量Hierarchical Cell85 个Hierarchical Port5,373 个Leaf Cell16,473 个Buf/Inv Cell2,815 个Total Number of Nets18,037 个设计违例 ✅ 电路逻辑综合结果中无设计违例五、物理实现与结果分析 5.1 ICC 设计步骤使用 Synopsys IC Compiler (ICC) 进行物理实现，分为四个阶段： pasted_1785034197720_i2g0so.png图片 5.1.1 数据设定 (Data Setup) 读入逻辑和时序库文件、SDC 约束文件、门级网表，以及 IO 物理库文件、TF 工艺文件、TLU+ 文件等物理数据。 5.1.2 布局规划 (Floorplanning) 定义所有管脚（输入输出、时钟、初始信号）及电源组添加电源环，生成基本布局规划尝试标准单元虚拟布局（create_fp_placement -timing_driven）分析拥塞（面积利用率设置不高，拥塞问题较少）形成电源网络，分析时序，调整电源管脚位置使电压降 < 10% 5.1.3 布局 (Placement) 遵循 NDR 规则，特殊信号线（如 clock）加宽、加大间距执行 place_opt 进行布局布局优化（解决建立时间违例）拥塞分析与优化 5.1.4 时钟树综合 (CTS) 生成时钟网络，加入 buffer 解决负载和 slew time 问题执行 clock_opt 单时钟同步设计，CTS 工作较简单 5.1.5 布线 (Routing) 全局布线 → 轨道分配 → DRC 修复先对时钟布线（route_group -all_clock_nets）解决 verify_lvs 报错（查阅资料后确认无实质影响）解决虚拟机内存不足导致的闪退问题（清理空间后完成） 5.2 ICC 设计结果 5.2.1 芯片概貌图 6 芯片概貌 pasted_1785032971553_0fu3op.png图片顶部和底部各 22 个管脚左边和右边各 23 个管脚共 10 组电源管脚：4 组为管脚供电（分列四周），6 组为内核供电（上下各 1 组，左右各 2 组） 5.2.2 时序结果阶段input (ns)output (ns)clk (ns)data_setup——0.48data_setup_zic1.430.481.19floorplan0.95-1.02-1.39placement1.010.590.19cts_only_psyn1.260.820.62cts_only_cts1.260.830.36route_initial1.350.880.65route_final1.350.850.015.2.3 面积结果图 7 芯片面积测量 pasted_1785033659880_dlug93.png图片 | 项目 | 面积或长度 |Combinational Area1,477,888.21 μm²Non-combinational Area154,248.50 μm²Net Area0.00 μm²Net X Length620,954.62 nmNet Y Length666,869.44 nmCell Area1,632,136.71 μm²Design Area1,632,136.71 μm²Net Length1,287,824.00 nmTotal Area4,695,300.72 μm²芯片尺寸：2092.38 μm × 2244.00 μm 5.2.4 功耗结果项目数值Global Operating Voltage1.62 VCell Internal Power33.6445 mWNet Switching Power12.7067 mWTotal Dynamic Power44.3512 mWCell Leakage Power26.0446 μW5.2.5 芯片压降图 8 芯片压降分析 pasted_1785033682302_ytnfda.png图片工作电压：1.62 V 最大压降：129.6 mV 压降比例：129.6 / 1620 = 8% < 10%，符合设计要求 5.2.6 拥塞分析图 9 拥塞分析（Placement / Detail Route / Track Assignment / Global Route） pasted_1785033720429_zl0o70.png图片由于芯片面积较大，面积利用率设置不高，拥塞问题较少，顺利解决。5.2.7 资源使用项目数量或利用率Module Cells16,240 个Pins91,614 个IO Pad Cells90 个IO Pins70 个Nets18,151 个Average Pins Per Net3.0535 个Total Std Cell Area514,936.70 μm²Total Pad Cell Area1,612,800.00 μm²Core Size1612.38 × 1764.00 = 2,844,238.32 μm²Pad Core Size1672.38 × 1824.00 = 3,050,421.12 μm²Chip Size2092.38 × 2244.00 = 4,695,300.72 μm²Std cells utilization18.10%Cell/Core Ratio18.10%Cell/Chip Ratio45.32%Number of Cell Rows350图 10 单元密度分布 pasted_1785033741857_8nbcxl.png图片5.2.8 设计违例 ✅ 最终设计无设计违例六、设计总结 6.1 遇到的主要问题管脚数量过多，芯片面积过大电路计算结果不正确时序模块数据传输不同步，拖慢运算速度芯片工作频率过低芯片电压降问题 6.2 相应的解决思路问题解决方案管脚过多、面积过大采用串并转换减少管脚；改用基-4 FFT 算法并复用蝶形运算模块减小面积计算结果不正确手动计算关键中间数据，逐一比对各模块输入输出，逐个修复 bug数据传输不同步在时序电路传输标志信号的同时，用组合逻辑电路传输数据，避免同步问题工作频率过低重写乘法器：将乘法运算改为组合逻辑状态机判断旋转因子，采用移位方法完成乘法，频率从 82 MHz 提升至 135 MHz电压降问题增加供电管脚数量并调整位置，最大压降控制在 8%（何卫锋老师指导）6.3 关键优化点乘法器优化（频率提升核心）优化前： assign mul = in_17bit[16:0] * in_8bit[7:0]; // 直接乘法，延迟大优化后： always @ (in_17bit or in_8bit) begin case (in_8bit) 8'b00000000: neg_mul = 25'b0; 8'b01111111: neg_mul = (in_17bit << 7); // ... 其他旋转因子用移位实现 endcase end通过 set_flatten true 和 compile –map high 策略，将工作频率从 82 MHz 大幅提升至 135 MHz。七、参考资料 [1] FFT 算法相关教材与文献 [2] Synopsys Design Compiler 用户手册 [3] Synopsys IC Compiler 用户手册 [4] SMIC 0.18 μm 工艺设计套件文档项目成果总结：本项目完整实践了数字 IC 设计的前后端全流程，从 RTL 编码、功能仿真、逻辑综合到物理实现，成功将 16 点基-4 FFT 算法芯片化。通过架构优化（串并转换、流水线）、算法优化（基-4 复用）、电路优化（组合逻辑移位乘法器），在 SMIC 0.18 μm 工艺下实现了 135 MHz 工作频率、4.70 mm² 面积、5.25×10⁻⁶ mJ 单次运算能耗的优异性能指标。八、项目工程下载（源码、文档和参考文献）包含：前端RTL源码、中端DC源码脚本、后端ICC源码脚本、项目报告、参考文件等

FPGA&ASIC IP&SOC设计 VLSI&IC验证 # VLSI # ASIC/FPGA # TCL脚本 # SOC设计

刘航宇 7月26日
1 98 6
EBI开发手册|FPGA与STM32 EBI高速并行通信技术详解摘要：本文详细介绍了FPGA与STM32 EBI高速并行通信技术，包括EBI的优势、系统框图、读写时序、硬件连接、信号定义、FPGA端Verilog接口设计、STM32端HAL配置与驱动等，适用于复杂电子系统和高可靠FPGA-MCU协同设计。目录 1. 为什么选EBI而非SPI？ 2. EBI系统框图 3. EBI开发手册下载 4. EBI读写时序EBI读时序 EBI写时序 5. EBI硬件连接与信号定义5.1 信号连接表 5.2 硬件设计注意事项 6. FPGA端Verilog接口设计6.1 模块接口定义 6.2 核心设计要点6.2.1 信号直通与数据三态控制 3.2.2 写信号同步 6.2.3 读信号同步 7. 内部模块连接示例 8. STM32端HAL配置与驱动8.1 GPIO初始化 8.2 FMC异步SRAM模式初始化 8.3 读写驱动函数 9. 读写时序分析9.1 读时序 (FPGA → STM32) 9.2 写时序 (STM32 → FPGA) 10. 关键设计决策说明10.1 为什么写信号只用1级同步，读信号用3级？ 10.2 三态门控制逻辑 10.3 地址直通 vs 同步 EBI开发手册下载适用场景：复杂电子系统 / 高可靠FPGA-MCU协同设计关键词：FPGA · STM32 · EBI · LocalBus · 异步SRAM · EE学术1. 为什么选EBI而非SPI？在高可靠嵌入式系统中，STM32与FPGA通信的常见方式有SPI、I2C、UART等串行接口，以及EBI（External Bus Interface）等并行总线。虽然SPI实现简单，但在需要高带宽、低延迟、内存映射访问的场景下，EBI并行总线具有显著优势：对比维度SPIEBI数据宽度1~4 bit (QSPI)8/16 bit理论带宽~50 MB/s (QSPI)~100+ MB/s访问方式寄存器操作内存映射 (直接读写)DMA支持有限原生支持适用场景控制命令、低速数据图像缓冲、FFT数据流、航电总线对于需要FPGA处理高速数据流（如传感器采集、信号处理）并将结果回传MCU的场景，EBI允许STM32像访问内部SRAM一样直接读写FPGA内部寄存器或FIFO，无需复杂的协议栈开销。这种"内存映射"方式使得CPU可以通过简单的指针操作完成数据交换，几乎零额外软件开销。 2. EBI系统框图 pasted_1784792114679_uqlyxj.png图片 pasted_1784792133238_8k92xm.png图片 3. EBI开发手册下载见文章末尾 4. EBI读写时序 EBI读时序 pasted_1784792256693_rqlsy7.png图片 EBI写时序 pasted_1784792336779_i0i8ah.png图片 5. EBI硬件连接与信号定义以STM32F407 + FPGA（Xilinx/Altera）为例，采用16位数据宽度、非复用地址模式，典型连接如下： 5.1 信号连接表 STM32 引脚FPGA 引脚信号说明PD14~PD15, PE7~PE15IO_EBI_data[15:0]EBI数据总线 (16位双向)PF0~PF5, PG0~PG13I_EBI_addr[23:0]EBI地址总线 (24位，可寻址16MB)PG9I_EBI_CS_nEBI片选 (低有效)PD4I_EBI_OE_nEBI读使能 (低有效)PD5I_EBI_WE_nEBI写使能 (低有效)—I_sys_clkFPGA系统时钟 (≥100MHz)—I_rst_n系统复位 (低有效)地址映射：Bank1_NE2 → 0x6400_0000 ~ 0x64FF_FFFF (16MB空间) 5.2 硬件设计注意事项 ⚠️ 关键提示 FPGA的IO电平必须与STM32匹配（通常 3.3V LVTTL/LVCMOS33）数据线建议串联 22~47Ω 电阻抑制信号反射，尤其是高速运行时地址线若不需要全部使用，可接地或接固定电平，减少FPGA引脚占用若使用等待信号（NWAIT），需在EBI配置中使能，并在FPGA中正确驱动航空电子场景需特别关注 EMC/EMI 设计，建议增加滤波和屏蔽 6. FPGA端Verilog接口设计 FPGA侧的核心任务是模拟一个"SRAM设备"，响应STM32的读写时序。以下是基于异步SRAM模式的完整Verilog接口模块，直接对应你的实际工程代码： 6.1 模块接口定义 module EBI_LOCALBUS ( /* --------------------- Input Signals --------------------- */ input I_sys_clk, // 系统时钟 input I_rst_n, // 系统复位 input I_EBI_CS_n, // EBI片选 input I_EBI_WE_n, // EBI写信号 input I_EBI_OE_n, // EBI读信号 input [23 : 00] I_EBI_addr, // EBI地址 (24位) inout [15 : 00] IO_EBI_data, // EBI数据总线 (16位双向) input [15 : 00] I_EBI_RD_data, // CPU读数据 (来自内部模块) /* --------------------- Output Signals -------------------- */ output [15 : 00] O_EBI_WR_data, // CPU写数据 (输出到内部模块) output O_EBI_CS_n, // 片选转接 output reg O_EBI_WE_n, // 写信号同步输出 output O_EBI_RD_n, // 读信号同步输出 output [23 : 00] O_EBI_addr // 地址转接 );6.2 核心设计要点 6.2.1 信号直通与数据三态控制 // EBI片选直通 assign O_EBI_CS_n = I_EBI_CS_n; // EBI地址直通 assign O_EBI_addr = I_EBI_addr; // 写数据：EBI总线 → FPGA内部 (写操作时数据由STM32驱动) assign O_EBI_WR_data = IO_EBI_data; // 读数据：FPGA内部 → EBI总线 (仅在片选有效且读使能有效时驱动) assign IO_EBI_data = ( (I_EBI_CS_n == 1'b0) && (S_EBI_RD_N_d2 == 1'b0) ) ? I_EBI_RD_data : 16'bz;关键设计： O_EBI_CS_n 和 O_EBI_addr 为直通信号，不做时钟域转换，确保地址和片选的最小延迟 IO_EBI_data 采用三态控制：仅在 CS_n == 0 且 RD_N_d2 == 0 时驱动读数据，否则置高阻态，避免总线冲突 O_EBI_WR_data 直接采样 IO_EBI_data，因为写操作时数据总线由STM32驱动，无需三态判断 3.2.2 写信号同步 // EBI写信号打拍同步 always @(posedge I_sys_clk or negedge I_rst_n) begin if (I_rst_n == 1'b0) begin O_EBI_WE_n <= 1'b1; // 复位后写无效 end else begin O_EBI_WE_n <= I_EBI_WE_n; end end设计意图：写信号经过1级同步，从异步EBI域转入FPGA系统时钟域同步后的 O_EBI_WE_n 可直接用于内部模块的写使能，配合 O_EBI_addr 和 O_EBI_WR_data 完成一次完整的写操作 6.2.3 读信号同步 reg S_EBI_RD_N_d0; reg S_EBI_RD_N_d1; reg S_EBI_RD_N_d2; // EBI读信号三级打拍 always @(posedge I_sys_clk or negedge I_rst_n) begin if (I_rst_n == 1'b0) begin S_EBI_RD_N_d0 <= 1'b1; S_EBI_RD_N_d1 <= 1'b1; S_EBI_RD_N_d2 <= 1'b1; end else begin S_EBI_RD_N_d0 <= I_EBI_OE_n; S_EBI_RD_N_d1 <= S_EBI_RD_N_d0; S_EBI_RD_N_d2 <= S_EBI_RD_N_d1; end end assign O_EBI_RD_n = S_EBI_RD_N_d2;为什么读信号需要3级同步？读信号采用三级延迟（而非写信号的1级），原因如下：同步级数作用S_EBI_RD_N_d0第一级同步，消除亚稳态S_EBI_RD_N_d1第二级同步，稳定信号S_EBI_RD_N_d2第三级延迟，为FPGA内部模块预留数据准备时间读操作需要FPGA内部模块在检测到读使能后，将数据放到 I_EBI_RD_data 上，再通过三态门驱动到 IO_EBI_data。三级延迟确保了：内部模块有足够的时间响应读请求数据在 S_EBI_RD_N_d2 == 0 时已经稳定满足STM32 EBI的数据建立时间要求 7. 内部模块连接示例 EBI_LOCALBUS 模块本身是一个总线桥接器，需要配合内部功能模块使用。以下是一个典型的寄存器文件连接示例： module internal_regfile ( input I_sys_clk, input I_rst_n, input I_cs_n, // 来自 EBI_TO_LOCALBUS.O_EBI_CS_n input I_we_n, // 来自 EBI_TO_LOCALBUS.O_EBI_WE_n input I_rd_n, // 来自 EBI_TO_LOCALBUS.O_EBI_RD_n input [23:0] I_addr, // 来自 EBI_TO_LOCALBUS.O_EBI_addr input [15:0] I_wr_data, // 来自 EBI_TO_LOCALBUS.O_EBI_WR_data output reg [15:0] O_rd_data // 送到 EBI_TO_LOCALBUS.I_EBI_RD_data ); reg [15:0] reg_file [0:255]; // 256个16位寄存器 integer i; initial begin for (i = 0; i < 256; i = i + 1) reg_file[i] = 16'd0; end // 写操作：WE_n下降沿 (同步后的信号) always @(posedge I_sys_clk or negedge I_rst_n) begin if (!I_rst_n) begin // 复位逻辑 end else if (!I_cs_n && !I_we_n) begin reg_file[I_addr[7:0]] <= I_wr_data; end end // 读操作：组合逻辑输出 (确保在RD_n有效时数据已稳定) always @(*) begin if (!I_cs_n && !I_rd_n) O_rd_data = reg_file[I_addr[7:0]]; else O_rd_data = 16'h0000; end endmodule顶层连接： module top_fpga_stm32 ( input sys_clk, input sys_rst_n, // EBI物理接口 inout [15:0] fmc_data, input [23:0] fmc_addr, input fmc_cs_n, input fmc_oe_n, input fmc_we_n ); wire [15:0] ebi_rd_data; wire [15:0] ebi_wr_data; wire ebi_cs_n; wire ebi_we_n; wire ebi_rd_n; wire [23:0] ebi_addr; EBI_LOCALBUS u_ebi_bridge ( .I_sys_clk (sys_clk), .I_rst_n (sys_rst_n), .I_EBI_CS_n (fmc_cs_n), .I_EBI_WE_n (fmc_we_n), .I_EBI_OE_n (fmc_oe_n), .I_EBI_addr (fmc_addr), .IO_EBI_data (fmc_data), .I_EBI_RD_data (ebi_rd_data), .O_EBI_WR_data (ebi_wr_data), .O_EBI_CS_n (ebi_cs_n), .O_EBI_WE_n (ebi_we_n), .O_EBI_RD_n (ebi_rd_n), .O_EBI_addr (ebi_addr) ); internal_regfile u_regfile ( .I_sys_clk (sys_clk), .I_rst_n (sys_rst_n), .I_cs_n (ebi_cs_n), .I_we_n (ebi_we_n), .I_rd_n (ebi_rd_n), .I_addr (ebi_addr), .I_wr_data (ebi_wr_data), .O_rd_data (ebi_rd_data) ); endmodule8. STM32端HAL配置与驱动 STM32侧使用HAL库配置FMC/EBI为异步SRAM模式。以下代码基于STM32F407，使用Bank1_NE2（对应地址 0x64000000）： 8.1 GPIO初始化 #include "stm32f4xx_hal.h" #define FPGA_BASE_ADDR 0x64000000 // 内存映射指针 (16位访问) volatile uint16_t *fpga_regs = (volatile uint16_t *)FPGA_BASE_ADDR; static void FMC_GPIO_Init(void) { GPIO_InitTypeDef GPIO_InitStruct = {0}; __HAL_RCC_GPIOD_CLK_ENABLE(); __HAL_RCC_GPIOE_CLK_ENABLE(); __HAL_RCC_GPIOF_CLK_ENABLE(); __HAL_RCC_GPIOG_CLK_ENABLE(); // 数据总线 D0~D15: PD14/15, PE7~15 GPIO_InitStruct.Pin = GPIO_PIN_14 | GPIO_PIN_15; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF12_FMC; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15; HAL_GPIO_Init(GPIOE, &GPIO_InitStruct); // 地址总线 A0~A5: PF0~PF5 (可扩展至A23) GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5; HAL_GPIO_Init(GPIOF, &GPIO_InitStruct); // 控制信号: NOE(PD4), NWE(PD5), NE2(PG9) GPIO_InitStruct.Pin = GPIO_PIN_4 | GPIO_PIN_5; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_9; HAL_GPIO_Init(GPIOG, &GPIO_InitStruct); }8.2 FMC异步SRAM模式初始化 void FMC_FPGA_Init(void) { SRAM_HandleTypeDef hsram = {0}; FMC_NORSRAM_TimingTypeDef Timing = {0}; FMC_GPIO_Init(); __HAL_RCC_FMC_CLK_ENABLE(); hsram.Instance = FMC_NORSRAM_DEVICE; hsram.Extended = FMC_NORSRAM_EXTENDED_DEVICE; // Bank1_NE2, 16位数据宽度, SRAM类型 hsram.Init.NSBank = FMC_NORSRAM_BANK2; hsram.Init.DataAddressMux = FMC_DATA_ADDRESS_MUX_DISABLE; // 非复用 hsram.Init.MemoryType = FMC_MEMORY_TYPE_SRAM; hsram.Init.MemoryDataWidth = FMC_NORSRAM_MEM_BUS_WIDTH_16; hsram.Init.BurstAccessMode = FMC_BURST_ACCESS_MODE_DISABLE; hsram.Init.WaitSignalPolarity = FMC_WAIT_SIGNAL_POLARITY_LOW; hsram.Init.WrapMode = FMC_WRAP_MODE_DISABLE; hsram.Init.WaitSignalActive = FMC_WAIT_TIMING_BEFORE_WS; hsram.Init.WriteOperation = FMC_WRITE_OPERATION_ENABLE; hsram.Init.WaitSignal = FMC_WAIT_SIGNAL_DISABLE; hsram.Init.ExtendedMode = FMC_EXTENDED_MODE_DISABLE; hsram.Init.AsynchronousWait = FMC_ASYNCHRONOUS_WAIT_DISABLE; hsram.Init.WriteBurst = FMC_WRITE_BURST_DISABLE; hsram.Init.ContinuousClock = FMC_CONTINUOUS_CLOCK_SYNC_ONLY; // 时序配置 (HCLK = 168MHz, 1周期 ≈ 5.95ns) // 需根据FPGA时序报告调整，满足建立/保持时间 Timing.AddressSetupTime = 2; // 地址建立: ~12ns Timing.AddressHoldTime = 1; // 地址保持 Timing.DataSetupTime = 5; // 数据建立: ~30ns Timing.BusTurnAroundDuration = 1; // 总线周转 Timing.CLKDivision = 2; Timing.DataLatency = 2; Timing.AccessMode = FMC_ACCESS_MODE_A; HAL_SRAM_Init(&hsram, &Timing, &Timing); }8.3 读写驱动函数 /** * @brief 向FPGA寄存器写入16位数据 */ static inline void FPGA_WriteReg(uint16_t reg, uint16_t value) { fpga_regs[reg] = value; __DSB(); // 数据同步屏障，确保写入完成 } /** * @brief 从FPGA寄存器读取16位数据 */ static inline uint16_t FPGA_ReadReg(uint16_t reg) { uint16_t val = fpga_regs[reg]; __DSB(); return val; } /** * @brief 批量数据写入 */ void FPGA_WriteBuffer(uint16_t reg_base, uint16_t *data, uint32_t len) { for (uint32_t i = 0; i < len; i++) { fpga_regs[reg_base + i] = data[i]; } __DSB(); } /** * @brief 批量数据读取 */ void FPGA_ReadBuffer(uint16_t reg_base, uint16_t *data, uint32_t len) { for (uint32_t i = 0; i < len; i++) { data[i] = fpga_regs[reg_base + i]; } __DSB(); }9. 读写时序分析 9.1 读时序 (FPGA → STM32) 读时序要点： I_EBI_OE_n 下降沿后，FPGA内部模块开始准备数据经过3个时钟周期（d0 → d1 → d2），S_EBI_RD_N_d2 变为低电平三态门在 S_EBI_RD_N_d2 == 0 时使能，将 I_EBI_RD_data 驱动到 IO_EBI_data STM32在 NOE 上升沿采样数据，需确保数据在采样前已稳定（满足DataSetupTime） 9.2 写时序 (STM32 → FPGA) 写时序要点： I_EBI_WE_n 下降沿表示写周期开始，STM32地址和数据已稳定 O_EBI_WE_n 在1个时钟周期后同步到低电平，内部模块在时钟上升沿检测 !O_EBI_WE_n && !O_EBI_CS_n 执行写操作 O_EBI_WR_data 直接采样 IO_EBI_data，无需额外延迟，因为写操作时数据总线由STM32持续驱动 10. 关键设计决策说明 10.1 为什么写信号只用1级同步，读信号用3级？信号同步级数原因I_EBI_WE_n → O_EBI_WE_n1级写操作对FPGA是"被动接收"，数据总线由STM32驱动，FPGA只需在时钟沿采样稳定的数据即可I_EBI_OE_n → S_EBI_RD_N_d23级读操作对FPGA是"主动输出"，需要给内部模块预留时间准备数据，再通过三态门驱动到总线10.2 三态门控制逻辑 assign IO_EBI_data = ( (I_EBI_CS_n == 1'b0) && (S_EBI_RD_N_d2 == 1'b0) ) ? I_EBI_RD_data : 16'bz;使用 S_EBI_RD_N_d2 而非 I_EBI_OE_n 的原因：直接使用 I_EBI_OE_n 会导致FPGA在STM32还未准备好接收数据时就驱动总线，可能产生总线冲突使用延迟后的 S_EBI_RD_N_d2 确保：① 内部数据已准备好；② STM32的读使能确实有效；③ 满足数据建立时间 10.3 地址直通 vs 同步 assign O_EBI_addr = I_EBI_addr; // 直通，无时钟延迟地址采用组合逻辑直通而非同步，原因：地址在EBI访问期间保持稳定，无需跨时钟域处理减少地址到内部模块的延迟，提高访问速度地址稳定性由STM32硬件保证 EBI开发手册下载

嵌入式＆系统 FPGA&ASIC # ASIC/FPGA # 嵌入式 # Verilog # C/C++

刘航宇 7月23日
0 57 6
2025-01-09
【FPGA】AXI DMA详解摘要：本文详细介绍了AXI DMA的工作原理、ZYNQ中的DMA类型、AXI DMA IP核的配置和使用方法，包括Direct Register模式、Scatter/Gather模式和Cyclic DMA模式，以及AXI DMA的参数和接口分析。<DMA简介 ZYNQ DMA简介三、AXI DMA IP简介四、AXI DMA参数与接口分析 Xilinx FPGA里面的AXI DMA IP核的简单用法 DMA简介 DMA是一种内存访问技术，允许某些计算机内部的硬件子系统可以独立的直接读写内存，而不需要CPU介入处理，从而不需要CPU的大量中断负载，否则，CPU需要从来源把每一片段的数据复制到寄存器，然后在把他们再次写回到新的地方，在这个时间里，CPU就无法执行其他的任务。 DMA是一种快速数据传送方式，通常用来传送数据量较多的数据块。使用DMA时，CPU向DMA控制器发送一个存储器传输请求，这样当DMA控制器在传输的时候，CPU执行其他的操作，传输完成时DMA以中断的方式通知CPU。 DMA传输过程的示意图为：图片 DMA的传输过程为： 1、为了配置用DMA传输数据到存储器，处理器（Cortex-A9）发出一条指令。 2、DMA控制器把数据从外设传输到存储器或者从存储器传输到存储器，从而较少CPU处理的事务量。 3、输出传输完成后，向CPU发出一个中断通知DMA传输可以关闭。为了发起传输事务，DMA控制器必须得到以下信息：（1）、源地址——数据被读出的地址（2）、目的地址——数据被写入的地址（3）、传输长度——应传输的字节数 ZYNQ DMA简介 ZYNQ提供了两种DMA，一种是集成在PS中的硬核DMA，另一种是PL中使用的软核AXI DMA IP。在ARM APU（Application Processor Unit，应用处理单元）设计过程中，已经考虑到大量数据搬移的情况，因此在APU中自带了一个DMA控制器DAMC，这个DMAC驻留在PS内，而且必须通过驻留在内存中的DMA指令编程，这些程序往往需要CPU准备，因此需要部分的CPU参与。DMAC支持多达8个通道，所以多个DMA结构的核可以挂载在单个DMAC上。 DMAC与PL的连接是通过AXI-GP接口，这个接口最高支持到32位宽，这也限制了这种模式下的传输速率，理论上最大为600MB/s，这种模式不占用PL资源，但需要对DMA指令编程，会增加软件的复杂性。为了获取更高的速率，可以空间换时间，在PL中添加AXI DMA IP core，并利用AXI_HP接口完成高速的数据传输，各种接口的传输比较为：图片 ZYNQ中ACI_HP接口的分布为：图片通过PL的DMA和AXI_HP接口传输方式的拓扑图为：图片 DMA的数据传输经过S_AXI_HP接口，每一个HP接口都含有控制和数据fifo，这些fifo为大数据量突发传输提供缓冲，使得HP成为理想的高速数据接口。对DMA的控制或配置通过M_AXI_GP接口（M代表master为PS），传输状态通过中断传达到PS的中断控制器。对M_AXI_GP0理解是：在ZYNQ7处理器系统IP core中，在PS-PL Configuration下的AXI Non Secure Enablement下有一个GP Master AXI Interface选项，可选一个M_AXI_GP0接口。该接口的作用是对PL侧的IP core通过AXI-Lite总线进行配置，如果不仅需要的话直接不使能即可。图片图片三、AXI DMA IP简介 ZYNQ提供了两种DMA，一种是集成在PS中的硬核DMA，另一种是PL中使用的软核AXI DMA IP。 AXI DMA IP核在AXI4-Stream IP接口之间提供高带宽直接存储访问。其可选的scatter gather（SG，链式相关）功能还可以从基于处理器的系统中的中央处理单元（CPU）卸载数据搬运任务。初始化、状态和管理寄存器通过AXI-Lite从接口访问（即数据发出方为PL，PS为Slave），核心功能组成为（这张图很有助于理解DMA中断以及SDK代码，下面会解释）：图片原图位于AXI_DMA数据手册的第五页。 AXI DMA使用了三种总线，分别是：（1）、AXI Memory Map，用于内存交互，AXI4 Memory Map Read用于从DMA读取，AXI4 Memory Map用于向DMA写入。（2）、AXI4-Lite同于对寄存器的配置。（3）、AXI4-Stream接口用于对外设的读写，S2MM（Stream to Memory Mapped，数据流向内存映射）用于对外设读取。AXI_MM2S和AXI_S2MM是AXI_Stream总线，可以发送和接收连续的数据流，无需地址。 AXI DMA提供3种模式：（1）、Direct Register模式：用于在MM2S和S2MM通道上执行简单的DMA传输，小的FPGA资源少。有两个通道：一个从Device到DMA，另一个从DMA到Device。应用程序必须设置缓冲区地址和长度字段以启动相应通道中的传输。（2）、Scatter/Gather模式：允许在单个DMA事务中将数据传输到多个存储区域传输数据。（3）、Cyclic DMA模式：四、AXI DMA参数与接口分析图片 1、接口分析：（1）、M_AXI_MM2S：DMA的读通道，从DDR中读取数据。受Enable Read Channel控制，表现为M_AXI_MM2S。（2）、M_AXI_S2MM：DMA的写通道，将数据写入DDR中。受Enable Write Channel控制，表现为M_AXI_S2MM。（3）、M_AXIS_MM2S：DMA将数据发送到具有stream接口IP。（4）、S_AXIS_S2MM：DMA将数据从具有Stream接口的IP中将数据读入。（5）、mm2s_introut：DMA将数据从DDR的映射单元中读出，然后将数据发送到具有Stream接口的IP完成信号。（6）、s2mm_introut：DMA将数据从具有stream接口的IP中读入，并写入到内存映射单元的完成中断信号。 2、参数分析图片（1）、Enable Scatter Gatter Engine 链式DMA操作，取消选中该选项可启用directregister模式操作。（2）、Enable Micro DMA 改选项会生成高度优化的DMA，资源数量较少，用于传输极少量数据的应用程序。（3）、Width of Buffer Length Register 根据IP手册pg021，在direct register模式下，此整数值用于指定控制字段缓冲区长度的有效位数，字节数等于2^（width），即字节读取和字节写入的有效长度都是2^(width)。比如宽度设置为26，可传输的字节数为2^（26）字节。（pg021，78页）。（4）、Address Width 指定地址空间的宽度，默认32。（5）、Enable Read Channel Memory Map Data Width：AXI MM2S存储映射读取总线的数据位宽，可为32、64、128、256、512、1024。 Stream Data Width：AXI MM2S AXI-Stream数据总线的位宽，该值必须小于等于Memory Map Data Width，可以为8、16、32、64、128、512、1024。 Max Burst Size：最大突发长度设置，指定的是MM2S的AXI4-Memory Map侧的突发周期的最大值，可为2、4、8、16、32、64、128、256。（6）、Enable Write channel：同Read channel。 3、关于中断的理解（1）、M_AXI_MM2S：DMA的读通道，从DDR中读取数据。受Enable Read Channel控制，表现为M_AXI_MM2S。在AXI_DMA ip core的输出信号中，有两个中断信号，分别是s2mm_introut和mm2s_introut，mm指的是Memory Mapped，S指的是Stream。 Memory Map指的是什么？根据AXI DMA的介绍，AXI DMA提供一个介于AXI4 Memory Mapped 与AXI4 Stream IP之间的高带宽DMA：原话位于IP参考的page5： The AXI DirectMemory Access (AXI DMA) IP core provides high-bandwidth direct memory accessbetween the AXI4 memory mapped and AXI4-Stream IP interfaces. 所以，对于DMA来说，S2MM，就是Stream形式的数据到达DDR映射空间，具体的实现方式是Stream数据流先进入DMA，之后再从DMA到Memeory Mapped。 MM2S是Memory Mapped将数据送入具有AXI Stream接口的IP。从这里分析mm2s_introut与s2mm_introut信号的区别是分析不出来的，因为数据都是先到DMA，再从DMA发送出去。在第5页还有一张图，讲述AXI DMA的架构：图片分析这张图，DDR内存映射空间的读写都是通过AXI4Memory Map完成的，也就是说s2mm与mm2s的重点不在PS DDR侧，重点在PL侧，当Stream接口的数据将输出传到DMA时候，这个过程叫做DMA的接收，DMA将映射单元的数据写到stream接口的IP，这个过程叫做DMA的发送。所以！也就可以理解在SDK中将s2mm_introut定义为DMA接收中断，将mm2s_introut定义为发送中断了！所以以下语句就很容易理解了： // DMA接收通道的中断ID #define RX_INTR_ID XPAR_FABRIC_AXIDMA_0_S2MM_INTROUT_VEC_ID #define TX_INTR_ID XPAR_FABRIC_AXIDMA_0_MM2S_INTROUT_VEC_IDXilinx FPGA里面的AXI DMA IP核的简单用法在FPGA里面，AXI DMA这个IP核的主要作用，就是在Verilog语言和C语言之间传输大批量的数据，使用的通信协议为AXI4-Stream。 Xilinx很多IP核都是基于AXI4-Stream协议的，例如浮点数Floating-point IP核，以及以太网Tri Mode Ethernet MAC IP核。要想将Verilog层面的数据搬运到C语言里面处理，就要使用DMA IP核。本文以浮点数Floating-point IP核将定点数转换为浮点数为例，详细讲解AXI DMA IP核的使用方法。浮点数IP核的输入输出数据都是32位，协议均为AXI4-Stream。C语言程序首先将要转换的定点数数据通过DMA发送给浮点数IP核，浮点数IP核转换完成后再通过DMA将单精度浮点数结果发回C语言程序，再通过printf打印出来。定点数的数据类型为int，小数点定在第四位上，即：XXXXXXX.X。整数部分占28位，小数部分占4位。转换后浮点数的数据类型为float，可以用printf的%f直接打印出来。工程下载地址：https://pan.baidu.com/s/1SXppHMdhroFT8vGCIysYTQ（提取码：u7wf） MicroBlaze C语言工程的建法不再赘述，请参阅：https://blog.csdn.net/ZLK1214/article/details/111824576 以读写Floating-point IP核数据为例图片首先添加Floating-point IP核，作为DMA的外设端：（主存端为BRAM）图片图片图片图片这里要注意一下，一定要勾选上TLAST，否则DMA接收端会出现DMA Internal Error的错误：图片下面是Xilinx DMA手册里面对DMA Internal Error错误的描述：图片添加AXI DMA IP核：图片 IP核添加好了，但还没有连线：图片点击Run Connection Automation，自动连接DMA的S_AXI_LITE接口：图片图片图片图片图片自动连接浮点数IP核的时钟引脚：图片图片图片图片图片添加BRAM控制器：图片图片最终的连线结果：图片修改新建的BRAM的容量为64KB：图片图片最终的地址分配方式：图片保存Block Design，然后生成Bitstream：图片 Bitstream生成后，导出xsa文件：图片 Vitis Platform工程重新导入xsa文件：图片图片修改C程序（helloworld.c）的代码：（这里面XPAR_BRAM_2_BASEADDR最好改成0xc0000000，因为生成的xparameters.h配置文件里面BRAM号可能有变化） /* * helloworld.c: simple test application * * This application configures UART 16550 to baud rate 9600. * PS7 UART (Zynq) is not initialized by this application, since * bootrom/bsp configures it to baud rate 115200 * * ------------------------------------------------ * | UART TYPE BAUD RATE | * ------------------------------------------------ * uartns550 9600 * uartlite Configurable only in HW design * ps7_uart 115200 (configured by bootrom/bsp) */ #include <stdio.h> #include <xaxidma.h> #include "platform.h" // DMA无法通过AXI Interconnect访问Microblaze本身的BRAM内存 // 只能访问挂接在AXI Interconnect上的内存 #define _countof(arr) (sizeof(arr) / sizeof(*(arr))) typedef struct { int numbers_in[40]; float numbers_out[40]; } BRAM2_Data; static BRAM2_Data *bram2_data = (BRAM2_Data *)XPAR_BRAM_2_BASEADDR; static XAxiDma xaxidma; int main(void) { int i, ret = 0; XAxiDma_Config *xaxidma_cfg; init_platform(); printf("Hello World\n"); printf("Successfully ran Hello World application\n"); // 初始化DMA xaxidma_cfg = XAxiDma_LookupConfig(XPAR_AXIDMA_0_DEVICE_ID); XAxiDma_CfgInitialize(&xaxidma, xaxidma_cfg); ret = XAxiDma_Selftest(&xaxidma); if (ret != XST_SUCCESS) { printf("XAxiDma_Selftest() failed! ret=%d\n", ret); goto err; } // 初始化DMA的输入数据 printf("numbers_in=%p, numbers_out=%p\n", bram2_data->numbers_in, bram2_data->numbers_out); for (i = 0; i < _countof(bram2_data->numbers_in); i++) { bram2_data->numbers_in[i] = 314 * (i + 1); if (i & 1) bram2_data->numbers_in[i] = -bram2_data->numbers_in[i]; } // DMA开始发送数据 (Length参数的单位为字节) ret = XAxiDma_SimpleTransfer(&xaxidma, (uintptr_t)bram2_data->numbers_in, sizeof(bram2_data->numbers_in), XAXIDMA_DMA_TO_DEVICE); if (ret != XST_SUCCESS) { printf("XAxiDma_SimpleTransfer(XAXIDMA_DMA_TO_DEVICE) failed! ret=%d\n", ret); goto err; } // DMA开始接收数据 ret = XAxiDma_SimpleTransfer(&xaxidma, (uintptr_t)bram2_data->numbers_out, sizeof(bram2_data->numbers_out), XAXIDMA_DEVICE_TO_DMA); if (ret != XST_SUCCESS) { printf("XAxiDma_SimpleTransfer(XAXIDMA_DEVICE_TO_DMA) failed! ret=%d\n", ret); goto err; } // 等待DMA发送完毕 i = 0; while (XAxiDma_Busy(&xaxidma, XAXIDMA_DMA_TO_DEVICE)) { i++; if (i == 200000) { // 必须确保DMA访问的内存是直接挂接在AXI Interconnect上的 // 否则这里会报DMA Decode Error的错误 (the address request points to an invalid address) printf("DMA Tx timeout! DMASR=0x%08lx\n", XAxiDma_ReadReg(xaxidma.RegBase + XAXIDMA_TX_OFFSET, XAXIDMA_SR_OFFSET)); goto err; } } printf("DMA Tx complete!\n"); // 等待DMA接收完毕 i = 0; while (XAxiDma_Busy(&xaxidma, XAXIDMA_DEVICE_TO_DMA)) { i++; if (i == 200000) { // floating-point IP核的配置里面一定要把A通道的tlast复选框勾选上, 使输入端和输出端都有tlast信号 // 否则s_axis_s2mm_tlast一直为0, DMA以为数据还没接收完, 就会报DMA Internal Error的错误 // (the incoming packet is bigger than what is specified in the DMA length register) printf("DMA Rx timeout! DMASR=0x%08lx\n", XAxiDma_ReadReg(xaxidma.RegBase + XAXIDMA_RX_OFFSET, XAXIDMA_SR_OFFSET)); goto err; } } printf("DMA Rx complete!\n"); err: for (i = 0; i < _countof(bram2_data->numbers_out); i++) printf("numbers_out[%d]=%f\n", i, bram2_data->numbers_out[i]); cleanup_platform(); return 0; }C程序的运行结果：图片图片接下来讲一下我们刚才禁用掉的Scatter Gather接口的用法。取消禁用后，之前的C代码就不能运行了。之前没有启用Scatter Gather的时候，我们一次只能提交一个DMA请求，等这个DMA请求的数据传输完毕后，我们才能提交下一个DMA传输请求。有了Scatter Gather接口，我们就可以一次性提交很多很多DMA请求，然后CPU去干其他的事情。这可以大大提高传输效率。除此以外，Scatter Gather还可以将多个位于不同内存地址的缓冲区合并成一个AXI4-Stream数据包传输。下面的示例演示了如何利用Scatter Gather功能批量收发3组数据包。启用了Scatter Gather后，DMA里面多出了一个M_AXI_SG接口，点击Run Connection Automation，连接到AXI Interconnect上：图片图片 Vivado工程Generate Bitstream，然后导出xsa文件。回到Vitis后，必须把Platform工程删了重建，不然XPAR_AXI_DMA_0_INCLUDE_SG的值得不到更新。图片图片图片原有的C程序不再可用，修改一下程序代码： /* * helloworld.c: simple test application * * This application configures UART 16550 to baud rate 9600. * PS7 UART (Zynq) is not initialized by this application, since * bootrom/bsp configures it to baud rate 115200 * * ------------------------------------------------ * | UART TYPE BAUD RATE | * ------------------------------------------------ * uartns550 9600 * uartlite Configurable only in HW design * ps7_uart 115200 (configured by bootrom/bsp) */ #include <stdio.h> #include <xaxidma.h> #include "platform.h" /* Xilinx的官方例程：C:\Xilinx\Vitis\2020.1\data\embeddedsw\XilinxProcessorIPLib\drivers\axidma_v9_11\examples\xaxidma_example_sg_poll.c */ // DMA无法通过AXI Interconnect访问Microblaze本身的BRAM内存 // 只能访问挂接在AXI Interconnect上的内存 #define _countof(arr) (sizeof(arr) / sizeof(*(arr))) typedef struct { int numbers_in[40]; float numbers_out[40]; } BRAM2_Data; typedef struct { uint8_t txbuf[640]; uint8_t rxbuf[640]; } BRAM2_BdRingBuffer; static BRAM2_Data *bram2_data = (BRAM2_Data *)0xc0000000; static BRAM2_BdRingBuffer *bram2_bdringbuf = (BRAM2_BdRingBuffer *)0xc0008000; static XAxiDma xaxidma; int main(void) { int i, n, ret = 0; XAxiDma_Bd *bd, *p; XAxiDma_BdRing *txring, *rxring; XAxiDma_Config *cfg; init_platform(); printf("Hello World\n"); printf("Successfully ran Hello World application\n"); // 初始化DMA cfg = XAxiDma_LookupConfig(XPAR_AXIDMA_0_DEVICE_ID); XAxiDma_CfgInitialize(&xaxidma, cfg); ret = XAxiDma_Selftest(&xaxidma); if (ret != XST_SUCCESS) { printf("XAxiDma_Selftest() failed! ret=%d\n", ret); goto err; } if (!XAxiDma_HasSg(&xaxidma)) { printf("XPAR_AXI_DMA_0_INCLUDE_SG=%d\n", XPAR_AXI_DMA_0_INCLUDE_SG); printf("Please recreate and build Vitis platform project!\n"); goto err; } // 初始化DMA的输入数据 printf("[0] numbers_in=%p, numbers_out=%p\n", bram2_data[0].numbers_in, bram2_data[0].numbers_out); printf("[1] numbers_in=%p, numbers_out=%p\n", bram2_data[1].numbers_in, bram2_data[1].numbers_out); printf("[2] numbers_in=%p, numbers_out=%p\n", bram2_data[2].numbers_in, bram2_data[2].numbers_out); for (i = 0; i < _countof(bram2_data[0].numbers_in); i++) { bram2_data[0].numbers_in[i] = 314 * (i + 1); bram2_data[1].numbers_in[i] = -141 * (i + 1); bram2_data[2].numbers_in[i] = -2718 * (i + 1); if (i & 1) { bram2_data[0].numbers_in[i] = -bram2_data[0].numbers_in[i]; bram2_data[1].numbers_in[i] = -bram2_data[1].numbers_in[i]; bram2_data[2].numbers_in[i] = -bram2_data[2].numbers_in[i]; } } // 配置DMA发送描述符 txring = XAxiDma_GetTxRing(&xaxidma); n = XAxiDma_BdRingCntCalc(XAXIDMA_BD_MINIMUM_ALIGNMENT, sizeof(bram2_bdringbuf->txbuf)); ret = XAxiDma_BdRingCreate(txring, (uintptr_t)bram2_bdringbuf->txbuf, (uintptr_t)bram2_bdringbuf->txbuf, XAXIDMA_BD_MINIMUM_ALIGNMENT, n); if (ret != XST_SUCCESS) { printf("XAxiDma_BdRingCreate(txring) failed! ret=%d\n", ret); goto err; } printf("BdRing Tx count: %d\n", n); ret = XAxiDma_BdRingAlloc(txring, 3, &bd); if (ret != XST_SUCCESS) { printf("XAxiDma_BdRingAlloc(txring) failed! ret=%d\n", ret); goto err; } p = bd; for (i = 0; i < 3; i++) { XAxiDma_BdSetBufAddr(p, (uintptr_t)bram2_data[i].numbers_in); XAxiDma_BdSetLength(p, sizeof(bram2_data[i].numbers_in), txring->MaxTransferLen); XAxiDma_BdSetCtrl(p, XAXIDMA_BD_CTRL_TXSOF_MASK | XAXIDMA_BD_CTRL_TXEOF_MASK); XAxiDma_BdSetId(p, i); p = (XAxiDma_Bd *)XAxiDma_BdRingNext(txring, p); } ret = XAxiDma_BdRingToHw(txring, 3, bd); if (ret != XST_SUCCESS) { printf("XAxiDma_BdRingToHw(txring) failed! ret=%d\n", ret); goto err; } // 配置DMA接收描述符 rxring = XAxiDma_GetRxRing(&xaxidma); n = XAxiDma_BdRingCntCalc(XAXIDMA_BD_MINIMUM_ALIGNMENT, sizeof(bram2_bdringbuf->rxbuf)); ret = XAxiDma_BdRingCreate(rxring, (uintptr_t)bram2_bdringbuf->rxbuf, (uintptr_t)bram2_bdringbuf->rxbuf, XAXIDMA_BD_MINIMUM_ALIGNMENT, n); if (ret != XST_SUCCESS) { printf("XAxiDma_BdRingCreate(rxring) failed! ret=%d\n", ret); goto err; } printf("BdRing Rx count: %d\n", n); ret = XAxiDma_BdRingAlloc(rxring, 3, &bd); if (ret != XST_SUCCESS) { printf("XAxiDma_BdRingAlloc(rxring) failed! ret=%d\n", ret); goto err; } p = bd; for (i = 0; i < 3; i++) { XAxiDma_BdSetBufAddr(p, (uintptr_t)bram2_data[i].numbers_out); XAxiDma_BdSetLength(p, sizeof(bram2_data[i].numbers_out), rxring->MaxTransferLen); XAxiDma_BdSetCtrl(p, 0); XAxiDma_BdSetId(p, i); p = (XAxiDma_Bd *)XAxiDma_BdRingNext(rxring, p); } ret = XAxiDma_BdRingToHw(rxring, 3, bd); if (ret != XST_SUCCESS) { printf("XAxiDma_BdRingToHw(rxring) failed! ret=%d\n", ret); goto err; } // 开始发送数据 ret = XAxiDma_BdRingStart(txring); if (ret != XST_SUCCESS) { printf("XAxiDma_BdRingStart(txring) failed! ret=%d\n", ret); goto err; } // 开始接收数据 ret = XAxiDma_BdRingStart(rxring); if (ret != XST_SUCCESS) { printf("XAxiDma_BdRingStart(rxring) failed! ret=%d\n", ret); goto err; } // 等待收发结束 n = 0; while (n < 6) { // 检查发送是否结束 ret = XAxiDma_BdRingFromHw(txring, XAXIDMA_ALL_BDS, &bd); if (ret != 0) { n += ret; p = bd; for (i = 0; i < ret; i++) { printf("DMA Tx%lu Complete!\n", XAxiDma_BdGetId(p)); p = (XAxiDma_Bd *)XAxiDma_BdRingNext(txring, p); } ret = XAxiDma_BdRingFree(txring, ret, bd); if (ret != XST_SUCCESS) printf("XAxiDma_BdRingFree(txring) failed! ret=%d\n", ret); } // 检查接收是否结束 ret = XAxiDma_BdRingFromHw(rxring, XAXIDMA_ALL_BDS, &bd); if (ret != 0) { n += ret; p = bd; for (i = 0; i < ret; i++) { printf("DMA Rx%lu Complete!\n", XAxiDma_BdGetId(p)); p = (XAxiDma_Bd *)XAxiDma_BdRingNext(rxring, p); } ret = XAxiDma_BdRingFree(rxring, ret, bd); if (ret != XST_SUCCESS) printf("XAxiDma_BdRingFree(rxring) failed! ret=%d\n", ret); } } err: for (i = 0; i < _countof(bram2_data[0].numbers_out); i++) printf("numbers_out[%d]=%f,%f,%f\n", i, bram2_data[0].numbers_out[i], bram2_data[1].numbers_out[i], bram2_data[2].numbers_out[i]); cleanup_platform(); return 0; }图片

FPGA&ASIC # ASIC/FPGA

刘航宇 1年前
1 5,517 9
2024-08-23
FPGA/数字IC之FIFO深度计算摘要：本文探讨了FIFO深度计算问题，分析了不同情况下FIFO深度的确定方法，包括读写频率、突发长度、空闲周期等因素，并给出了计算公式和实例。FIFO的深度计算问题1情况1:fa>fb，且在读和写中都没有空闲周期； 2情况2:fa>fb，两个连续的读写之间有一个时钟周期延迟； 3️情况3:fa>fb，在读和写中都有空闲周期； 4️情况4:fa>fb，读写使能的占空比给定； 5️情况5:fa<fb，在读和写中都没有空闲周期； 6情况6:fa<fb，在读和写中都有空闲周期 7情况7:fa=fb，在读和写中都没有空闲周期。 8️情况8:fa=fb，在写和读中都有空闲周期情况9:数据速率如下所示； 1️0情况10:以不同的形式给出写入和读取的规则。对于读写同时进行的FIFO，有一个简便计算公式 FIFO的深度计算问题 FIFO的最小深度问题，可以理解为两个模块之间的数据传输问题；只有在读取速度慢于写入速度的情况下，我们才需要一个FIFO，来暂时的寄存这些没有被读出去的数据；一个最主要的逻辑思想是：确定FIFO的大小，就是要找到在写入过程中没有被读取的数据的个数；即FIFO的深度等于未被读取的数据的数量。现在考虑一种实例，A时钟域数据发往B时钟域，将会出现以下几种情况： 1情况1:fa>fb，且在读和写中都没有空闲周期；例如：写入频率fa = 80MHz，读取频率fb = 50MHz。突发长度即要写入的数据数目为120个。计算如下：写入一个数据需要的时间 = 1 / 80MHz = 12.5ns；写入突发事件中所有数据需要时间 = 120 * 12.5 = 1500ns；读取一个数所需时间 = 1 / 50MHz = 20ns；所有数据写入完成后使用1500ns，1500ns可以读出数据为 = 1500 / 20 = 75个。所以，要在FIFO中存储的剩余数据量为 120 - 75 = 45；故：设计的FIFO的最小深度为45！ 2情况2:fa>fb，两个连续的读写之间有一个时钟周期延迟；这种情况和情况1一样，仅仅是人为的制造了某种混乱； 3️情况3:fa>fb，在读和写中都有空闲周期；例如：写入频率fa = 80MHz，读取频率fb = 50MHz。突发长度即要写入的数据数目为120个。两个连续的写之间空闲周期为1，两个连续的读之间空闲周期为3；计算如下：可以理解为每两个时钟周期写入一次数据，每四个时钟周期读出一个数据。写入一个数据需要的时间 = 2 (1 / 80MHz) = 2 12.5 = 25ns；写入突发事件中所有数据需要时间 = 120 * 25 = 3000ns；读取一个数所需时间 = 4 (1 / 50MHz) = 4 20 = 80ns；所有数据写入完成后使用3000ns，可以读出数据为 = 3000 / 80 = 37.5 ≈ 37个。所以，要在FIFO中存储的剩余数据量为120 - 37 = 83；故：设计的FIFO的最小深度为83！ 4️情况4:fa>fb，读写使能的占空比给定；例如：写入频率fa = 80MHz，读取频率fb = 50MHz。突发长度即要写入的数据数目为120个。写使能占空比为50%，读使能占空比为25%。这种情况和情况3一样，没有什么区别；【注】这里的情况2️和情况4仅仅是为了说明同一个问题可以通过不同的方式来提问。 5️情况5:fa<fb，在读和写中都没有空闲周期；例如：写入频率fa = 30MHz，读取频率fb = 50MHz。突发长度即要写入的数据数目为120个。计算如下：在这种情况下，深度为1的FIFO就足够了，因为不会有任何数据的丢失，因为读比写快。 6情况6:fa<fb，在读和写中都有空闲周期例如：写入频率fa = 30MHz，读取频率fb = 50MHz。突发长度即要写入的数据数目为120个。两个连续的写之间空闲周期为1，两个连续的读之间空闲周期为3；计算如下：可以理解为每两个时钟周期写入一次数据，每四个时钟周期读出一个数据。写入一个数据需要的时间 = 2 (1 / 30MHz) = 2 33.33 = 66.667ns；写入突发事件中所有数据需要时间 = 120 * 66.667 = 8000ns；读取一个数所需时间 = 4 (1 / 50MHz) = 4 20 = 80ns；所有数据写入完成后使用8000ns，可以读出数据为 8000 / 80 = 100个。所以，要在FIFO中存储的剩余数据量为120 - 100 = 20；故：设计的FIFO的最小深度为20 7情况7:fa=fb，在读和写中都没有空闲周期。例如：写入/读取频率fa = fb = 30MHz。突发长度即要写入的数据数目为120个。计算如下：如果clka和clkb之间没有相位差，则不需要FIFO；如果clka和clkb之间有一定的相位差，一个深度为“1”的FIFO就够了。 8️情况8:fa=fb，在写和读中都有空闲周期例如：写入频率fa = 50MHz，读取频率fb = 50MHz。突发长度即要写入的数据数目为120个。两个连续的写之间空闲周期为1，两个连续的读之间空闲周期为3；计算如下：可以理解为每两个时钟周期写入一次数据，每四个时钟周期读出一个数据。写入一个数据需要的时间 = 2 (1 / 50MHz) = 2 20 = 40ns；写入突发事件中所有数据需要时间 = 120 * 40 = 4800ns；读取一个数所需时间 = 4 (1 / 50MHz) = 4 20 = 80ns；所有数据写入完成后使用4800ns，可以读出的数据为4800 / 80 = 60个。所以，要在FIFO中存储的剩余数据量为120 - 60 = 60；故：设计的FIFO的最小深度为60！情况9:数据速率如下所示；例如：写入80个数据，需要100个时钟周期，(写入的时钟随机)；读出8个数据，需要10个时钟周期，(读取的时钟随机)。计算如下： ①上述表明，书写频率等于读出频率 ②读和写都可以在任何随机的时刻发生，以下是一些可能性。图片在上述情况中，完成写入所需的周期如下：图片在FIFO设计中，为了更稳妥的考虑，我们选择最坏的情况下进行数据传输，以此来设计FIFO的深度，以避免数据丢失；最坏的情况即：写和读之间的数据率差异应该最大，因此对于写操作，考虑最大的数据速率，对于读操作，考虑最小的数据速率。故：考虑上述可能性中的第四种情况(即所谓的“背靠背”情况)：计算如下： 160个时钟周期内，写入160个数据；数据的读取率为8个数据/10个时钟周期；在160个时钟周期内可以读取的数据量为：160 * 8 / 10 = 128。因此，需要存储在FIFO中的剩余字节数为160 - 128 = 32。故：设计的FIFO的最小深度为32！ 1️0情况10:以不同的形式给出写入和读取的规则。例如： fa = fb / 4； Tenb = Ta * 100； enb的占空比为25%。计算如下：在这种情况下，就需要假设一些数值：设：fb = 100MHz。则，fa = 1 / 4 * 100 = 25MHz。则：Ta = 40ns，Tenb = 4000ns；又因为写使能占空比25%。则：写使能时间为4000ns / 4 = 1000ns。【注】此处认为fb为写时钟，因为只有这样，才能是写入的比读出的快，当然了，把fa当做写时钟，下面就没法算了，哈哈。突发长度 = 1000ns / 10ns = 100个；在写入的1000ns内，可以读出 1000ns / 40ns = 25个；所以，要在FIFO中存储的剩余数据量为100 - 25 = 75；故：设计的FIFO的最小深度为75！例如假设两个异步时钟clk_a和clk_b，clk_a = 148.5M，clk_b = 140M。如图所示，clk_a时钟域中连续1920个16bit的数据通过data_valid标记，有效数据之后，紧接着720个无效数据时钟周期。请问，该数据通过异步fifo同步到clk_b时钟域，异步fifo的最小深度是多少？请写出计算过程。图片【解析】考虑情况9️中case-4案例，即所谓的“背靠背”情况：在a时钟域通过1920 * 2 = 3840个Ta传输3840个数据； Ta = 1 / 148.5MHz ≈ 6.734ns； Tb = 1 / 140MHz ≈ 7.143ns。 3840 * 6.734 = 25858.56ns；在25858.56ns内，通过clk_b读取的个数为:25858.56 / 7.143 ≈ 3620个。那么，剩余未读完的个数为3840 - 3620 = 220；即FIFO的深度最小为220。【注】在此情况下，理解清楚规则非常之重要！对于读写同时进行的FIFO，有一个简便计算公式 FIFO_Depth >= Burst_length -Burst_length (rd_clk/ wr_clk)(rd_rate) 最后，需要注意的是，我们在本文通篇计算的都是最小FIFO深度，但是在实际应用中，尤其是异步FIFO的应用中，需要使用格雷码计数，这就要求FIFO的深度为2的整数次幂，否则格雷码计数到最大值跳变为0时，将出现多位变化的情况，不符合设计。异步FIFO深度不是2的整数次幂情况下，则可能需要特殊处理，需要使用别的编码方式了。

FPGA&ASIC # ASIC/FPGA

刘航宇 2年前
1 1,183 3
2024-06-27
FPGA/数字IC-常考八股摘要：本文介绍了FPGA/数字IC设计中的关键概念，包括时间概念、亚稳态产生与防止、多时域设计、竞争与冒险现象、锁存器与寄存器区别、阻塞与非阻塞赋值、流水线设计、函数与任务、不可综合Verilog语句等，旨在帮助读者深入理解FPGA/数字IC设计原理。各种时间概念亚稳态的产生如何防止亚稳态？多时域设计中,如何处理信号跨时域？什么是竞争与冒险现象?怎样判断?如何消除? 锁存器(Latch)和寄存器(Flip-Flop)概念和区别 `timescale 阻塞赋值&非阻塞赋值流水线函数&任务不可综合verilog语句一些小计算总结各种时间概念建立时间（setup time）是指在触发器的时钟信号上升沿到来以前，数据稳定不变的时间，如果建立时间不够，数据将不能在这个时钟上升沿被打入触发器。保持时间（hold time）是指在触发器的时钟信号上升沿到来以后，数据稳定不变的时间，如果保持时间不够，数据同样不能被打出触发器。图片传输延时（transmission delay）数据相对于时钟上升沿tc-q后从触发器输出至Q端，则tc-q称为寄存器的传输延时恢复时间（recovery time）原本有效的复位信号释放后，与紧跟其后的第一个时钟上升沿之间的最小时间。清除时间（removal time）时钟信号的上升沿，与紧跟其后异步复位信号从有效到无效的最小时间。亚稳态的产生在FPGA系统中，如果数据传输中不满足触发器的 Tsu 和 Th 不满足，或者复位过程中复位信号的释放相对于有效时钟沿的恢复时间（recovery time）不满足，就可能产生亚稳态，此时触发器输出端Q在有效时钟沿之后比较长的一段时间处于不确定的状态，在这段时间里Q端在0和1之间处于振荡状态，而不是等于数据输入端D的值。这段时间称为决断时间（resolution time）。经过resolution time之后Q端将稳定到0或1上，但是稳定到0或者1，是随机的，与输入没有必然的关系。如何防止亚稳态？亚稳态是指触发器无法在某个规定时间段内达到一个可确认的状态。当一个触发器进入亚稳态时，既无法预测该单元的输出电平，也无法预测何时输出才能稳定在某个正确的电平上。在这个稳定期间，触发器输出一些中间级电平，或者可能处于振荡状态，并且这种无用的输出电平可以沿信号通道上的各个触发器级联式传播下去。解决方法： 1 降低系统时钟频率 2 用反应更快的FF 3 引入同步机制，防止亚稳态传播（加两级D触发器）。 4 改善时钟质量，用边沿变化快速的时钟信号多时域设计中,如何处理信号跨时域？不同的时钟域之间信号通信时需要进行同步处理，这样可以防止新时钟域中第一级触发器的亚稳态信号对下级逻辑造成影响。解决方法： 1 信号跨时钟域同步：当单个信号跨时钟域时，可以采用两级触发器来同步； 2 数据或地址总线跨时钟域：可以采用异步 FIFO 来实现时钟同步； 3 第三种方法就是采用握手信号。什么是竞争与冒险现象?怎样判断?如何消除? 在组合电路中，门电路两个输入信号同时向相反的逻辑电平跳变称为竞争；由于竞争而在电路的输出端可能产生尖峰脉冲的现象称为竞争冒险。（也就是由于竞争产生的毛刺叫做冒险）。判断方法： •代数法：如果布尔式中有相反的信号则可能产生竞争和冒险现象，即逻辑函数在一定条件下可以化简成 Y=A+A’或 Y=AA’则可以判断存在竞争冒险现象（只是一个变量变化的情况）； •卡诺图：有两个相切的卡诺圈并且相切处没有被其他卡诺圈包围，就有可能出现竞争冒险； •实验法+观察法：示波器观测；解决方法： 1：加滤波电容，消除毛刺的影响； 2：加选通信号，避开毛刺； 3：增加冗余项消除逻辑冒险。锁存器(Latch)和寄存器(Flip-Flop)概念和区别电平敏感的存储器件称为锁存器。可分为高电平锁存器和低电平锁存器，用于不同时钟之间的信号同步。有交叉耦合的门构成的双稳态的存储原件称为触发器（寄存器）。分为上升沿触发和下降沿触发。可以认为是两个不同电平敏感的锁存器串连而成。前一个锁存器决定了触发器的建立时间，后一个锁存器则决定了保持时间。 latch 是电平触发， register 是边沿触发。 register 在同一时钟边沿触发下动作，符合同步电路的设计思想，而 latch 则属于异步电路设计，往往会导致时序分析困难，不适当的应用 latch 则会大量浪费芯片资源。 `timescale `timescale 1ns / 1ps，含义为：时延单位为1ns，时延精度为1ps 在仿真文件里面需要写，例如 `timescale 10 ns / 1 ns //单位10ns，精度1ns module test; reg set; initial begin #1 set = 0; //1*10 ns = 10ns #10 set = 1; //10*10ns = 100ns end endmodule阻塞赋值&非阻塞赋值阻塞赋值“=”属于顺序执行，即下一条语句执行前，当前语句一定会执行完毕非阻塞赋值“<=”属于并行执行语句，即下一条语句的执行和当前语句的执行是同时进行的在设计电路时，always 时序逻辑块中多用非阻塞赋值，always 组合逻辑块中多用阻塞赋值；在仿真电路时，initial 块中一般多用阻塞赋值不要在一个过程结构中混合使用阻塞赋值与非阻塞赋值流水线流水线设计是verilog设计中基本功之一，是对组合逻辑系统的分割，并在各个部分之间插入寄存器，并暂存中间数据的方法。流水线操作的目的是把一个大操作分解为若干小操作，因为每一步操作变小了，所以时间更短，频率更快（面积换时间）。流水线在理各个阶段都需要增加寄存器保存中间计算状态，而且多条指令并行执行会导致功耗增加，硬件复杂度增加函数&任务函数返回一个值，而任务则不返回值函数至少要有一个输入变量，而任务可以没有或有多个任何类型的变量。函数只能与主模块共用同一个仿真时间单位，而任务可以定义自己的仿真时间单位。函数不能启动任务，而任务能够启动其他任务和函数。不可综合verilog语句（1）initial：只能在test bench中使用，不能综合。（2）events：event在同步test bench时更有用，不能综合。（3）real：不支持real数据类型的综合。（4）time：不支持time数据类型的综合。（5）force 和release：不支持force和release的综合。 (6）assign 和deassign：不支持对reg 数据类型的assign或deassign进行综合，支持对wire数据类型的assign或deassign进行综合。 (7) fork join：不可综合，可以使用非块语句达到同样的效果。 (8) primitives：支持门级原语的综合，不支持非门级原语的综合。 (9) table：不支持UDP 和table的综合。 (10) 敏感列表里同时带有posedge和negedge 如：always @(posedge clk or negedge clk) begin...end 这个always块不可综合。 (11) 同一个reg变量被多个always块驱动 (12) 延时以#开头的延时不可综合成硬件电路延时，综合工具会忽略所有延时代码，但不会报错。如：a=#10 b; 这里的#10是用于仿真时的延时，在综合的时候综合工具会忽略它。也就是说，在综合的时候上式等同于a=b; (13) 与X、Z的比较可能会有人喜欢在条件表达式中把数据和X(或Z)进行比较，殊不知这是不可综合的，综合工具同样会忽略。所以要确保信号只有两个状态：0或1。功耗（Power）等于处理器上的电流值与电压值的乘积，可以反应处理器最大负荷运行、满载工作时电流热效应造成热量释放的大小指标，单位为瓦(W)。总功耗由静态和动态两部分组成 PGA芯片内有两种存储器资源：一种叫block ram，另一种是由LUT配置成的内部存储器（也就是分布式ram）。block ram由一定数量固定大小的存储块构成的，使用block ram，不占用额外的逻辑资源，并且速度快。但是使用的时钟消耗block ram的资源是其大小的整数倍。 FPGA时钟结构：全局时钟、局部时钟和I/O时钟 MMCM、PLL即时钟管理模块，用来消除时钟的延迟、抖动以及产生各种不同频率的时钟。 MMCM相对PLL的优势就是相位可动态调整，但PLL占用的面积更小。一个属于单片机STM32（顺序处理），一个属于可编程阵列FPGA（并行处理） RAM随机读取存储器，掉电丢失 ROM只读存储器 Flash memory 是“闪存” EEPROM可以一次只擦除一个字节单端口RAM：只有一组地址线数据线伪双口RAM，一个端口只读，一个端口只写同步复位&异步复位同步复位：只有在时钟沿到来时复位信号才起作用，复位信号持续的时间应该超过一个时钟周期才能保证系统复位异步复位：复位信号容易受到毛刺的影响。复位结束时刻恰在亚稳态窗口内时异步复位同步释放最好当异步复位有效时，复位信号立刻复位信号释放时，会在时钟上升沿来临时，才可以恢复一些小计算总结 %0表示用最少位数表示进行取模运算%时，结果值的符号位采用模运算式里第一个操作数的符号位对于有符号数来说：若符号位为1，使用>>>，高位补1；若符号位为0，使用>>>，高位补0；对于无符号数来说，无论最高位是什么，使用>>>，高位都补0。标识符可以是任意一组数字、字母、$符合和下划线的组合，但第一个字符必须是字母或者下划线

FPGA&ASIC # ASIC/FPGA

刘航宇 2年前
0 2,419 6
Verilog语言实现读写txt文件方法摘要：本文介绍了Verilog语言中读写txt文件的方法。首先，通过MATLAB生成txt文件，并转换为十六进制格式。然后，在testbench中读取txt文件数据到寄存器，并按地址读取。接着，展示了如何写入txt文件，并提供了示例代码。最后，介绍了使用$display语句进行调试的方法。随着项目难度递增，例如AI芯片设计，不免需要验证Verilog的功能性，那么输入可以是测试集.txt，输出为预测结果/精确率.txt。下面讲解一下Verilog如何实现读写txt文件一、读txt文件二、写txt文件 $display语句的使用 demo案例一、读txt文件 1、准备一个txt文件 MATLAB上生成的txt文件的格式为每行一个数据，与coe文件不同的是，数据之间没有逗号。由于verilog的读txt的系统函数仅仅能识别十六进制和二进制数据，一般情况下，将数据转换为十六进制数比较方便。当数据为有符号数时，可以采用下面的方式生成txt文件： % 生成20个随机的int16类型数据 data_signed = int16(randi([-32768, 32767], 1, 20)); % 打开文件准备写入 fid = fopen('data_signed.txt', 'w'); % 将data_signed数组中的数据转换为无符号整数并以16进制格式写入文件 fprintf(fid, '%04x\r\n', typecast(data_signed, 'uint16')); % 关闭文件 fclose(fid);图片图片其中，typecast(int16(data_signed),‘uint16’) 可以将数据转变为补码形式。同时，需要注意的是，在换行中，需要采用’\r\n‘，不能仅仅使用’\r’ 2、在testbench上读写读txt文件时，一般选择先将txt中的数据置入寄存器memory中，然后按照地址读出memory中的数据。 reg [15:0] mem [0:1023]; reg [9:0] addr ; reg [11:0]data_out ; initial begin $readmemh("E:/self-study/VIVADO_workspace/prj/data_signed.txt",mem); addr = 10'd0; end always #10 begin data_out = mem[addr][11:0]; addr = addr + 10'd1; end需要注意的是，txt文件的地址不能出错，另外，注意地址分隔符需要用’/‘，windos系统中的’\‘需要对应改过来才能使用。二、写txt文件 integer handle; initial begin handle = $fopen("E:/self-study/VIVADO_workspace/prj/data_out.txt"); end always@(posedge sys_clk) begin if(data_in_valid) begin $fdisplay(handle,"%d",data_out); end end利用initial函数初始化handle的值，另外，地址分隔符同样要改回来。如果仿真之后，txt文件中并没有内容，可以尝试刷新一下txt文件。如果还没有内容出现，则就是txt文件没有关闭造成的，解决方法有两种： ①直接关闭xsim仿真程序，此时txt文件自动关闭，内容出现。 ②使用$fclose函数关闭文件，如果使能变量aagc_in_valid是一段高电平信号，则可以检测该信号的下降沿，在此时关闭文件即可： reg [2:0] valid_reg; always@(posedge sys_clk) begin valid_reg <= {valid_reg[1:0],data_in_valid}; if(valid_reg == 3'b110) begin $fclose(handle); end end甚至于，直接写一个计数器，也是可以的。 $display语句的使用在功能仿真阶段调试程序时，$display是很有用的一段程序，它和java，c语言中的打印语句使用方法是相似的，可以把变量和语句运行状况打在TCL log的窗口上，供调试者知晓代码运行情况。 $display("here is a debugging point."); $display("%d", data_in);demo案例 module wr_txt_tb; reg [15:0] mem [0:1023]; reg [9:0] addr; reg [15:0] data_out; initial begin $readmemh("E:/Downloads/data_signed.txt", mem); addr = 10'd0; end always #10 begin if (addr < 10'd20) begin // 假设您只想读取前20个数据 data_out = mem[addr][15:0]; addr = addr + 10'd1; $display("here is a debugging point."); $display("%h", data_out); // 以十六进制形式打印 end else begin $stop; // 结束仿真 end end endmodule图片图片

FPGA&ASIC # ASIC/FPGA

刘航宇 2年前
0 1,435 4
2023-12-11
大疆题解：跨时钟域脉冲信号处理—脉冲同步器（快到慢）摘要：本文介绍了如何将快时钟域（300M）的脉冲信号同步到慢时钟域（100M）中。通过将脉冲信号转换为沿信号，并在慢时钟域中进行两拍处理，最终实现脉冲信号的同步。文章还提供了相应的Verilog代码实现。问题描述题解1.1 电路波形图 1.2 代码注意问题描述 sig_a 是 clka（300M）时钟域的一个单时钟脉冲信号（高电平持续一个时钟clka周期），请设计脉冲同步电路，将sig_a信号同步到时钟域 clkb（100M）中，产生sig_b单时钟脉冲信号（高电平持续一个时钟clkb周期）输出。请用 Verilog 代码描述。 clka时钟域脉冲之间的间隔很大，无需考虑脉冲间隔太小的问题。电路的接口如下图所示：图片题解 1.1 电路波形图图片如上图所述，aclk快时钟域发送的信号signal_a，慢时钟域的时钟bclk根本就采集不到，此时不能使用打两拍的方式，要想办法转换思路，如果能够让同步于快时钟域aclk下的脉冲信号signal_a变长到可以让慢时钟域bclk检测到，那么这个问题就可以完美解决了。所以先将快时钟域clka下的脉冲信号signal_a，在快时钟域clka的作用下，变为沿信号，产生一个名为adata的中间变量来作为脉冲信号signal_a的沿信号。如上图所示，每当快时钟域aclk检测到signal_a脉冲信号为高时，让adata信号取反，使得signal_a的第一个脉冲变为adata信号的上升沿，signal_a的第二个脉冲变为adata信号的下降沿，后面如果Signal_a信号还有脉冲依然是变为adata信号的上升沿和下降沿。巧妙的利用将“脉冲信号”转化为“沿信号”的思想就可以使慢时钟域的时钟bclk检测到同步于快时钟域aclk且将脉冲信号signal_a转化为沿信号adata，相当于是把同步于快时钟域aclk的脉冲信号signal_a进行了展宽处理，这样我们就把快时钟域aclk的脉冲信号signal_a通过adata信号“沿”的形式在慢时钟域bclk中得到了保留。接着，我们再对adata信号做打两拍的处理就可以将adata信号同步到慢时钟域clkb中了。bdata0信号是adata信号在慢时钟域bclk下打的第一拍，bdata1信号是adata信号在慢速时钟域bclk下打第二拍，bdata1就是同步于慢速时钟域bclk的稳定信号。最后，采用边沿检测的方法，将变为bdata1信号的“沿”再转化为脉冲信号，这里我们使用的方法是采用异或门。需要注意的是不能直接使用bdata0和bdata1来产生沿标志信号，因为bdata0信号的不稳定性可能会导致产生的沿信号也不稳定，所以需要将bdata1信号再打一拍，产生signal_b信号。 1.2 代码 //快时钟数据同步 module pulse_detect( input clka , input clkb , input rst_n , input sig_a , output sig_b ); wire sig_a; reg adata; reg bdata0; reg bdata1; reg bdata2; always @(posedge clka or negedge rst_n) begin if(~rst_n) begin adata <= 1'd0; end else begin adata <= adata ^ sig_a; end end always @(posedge clkb or negedge rst_n) begin if(~rst_n) begin bdata0 <= 1'd0; bdata1 <= 1'd0; bdata2 <= 1'd0; end else begin bdata0 <= adata; bdata1 <= bdata0; bdata2 <= bdata1; end end assign sig_b = bdata1 ^ bdata2; endmodule注意 signal_a是两个脉冲，但是使用“脉冲同步”同步到bclk时钟域确只有一个脉冲了，在使用“脉冲同步”时应注意这一点。所以，脉冲同步一般适用于单比特信号从快时钟域传递慢时钟域的场景。

FPGA&ASIC # ASIC/FPGA # Verilog

刘航宇 3年前
0 1,194 4
2023-11-20
超声模块HC_SR04基本原理与FPGA、STM32应用摘要：本文介绍了HC-SR04超声波距离传感器的基本原理，包括其硬件构成、接口定义和测量操作。同时，详细阐述了如何利用FPGA和STM32实现超声波测距，包括FPGA模块代码和STM32的CubeMX配置及代码编写。HC-SR04硬件概述接口定义: 模式选择：测量操作: FPGA实现超声测距模块代码 STM32(Cubemax)实现超声波测距CubeMX配置STM32 编写代码 HC-SR04 硬件概述 HC-SR04超声波距离传感器的核心是两个超声波传感器。一个用作发射器，将电信号转换为40 KHz超声波脉冲。接收器监听发射的脉冲。如果接收到它们，它将产生一个输出脉冲，其宽度可用于确定脉冲传播的距离。就是如此简单！该传感器体积小，易于在任何机器人项目中使用，并提供2厘米至600厘米（约1英寸至13英尺）之间出色的非接触范围检测，精度为3mm。图片接口定义: 图片模式选择：图片测量操作: 一：GPIO模式图片外部MCU给模块Trig脚一个大于10uS的高电平脉冲；模块会给出一个与距离等比的高电平脉冲信号，可根据脉宽时间“T” 算出：距离=T*C/2 （C为声速）声速温度公式：c=(331.45+0.61t/℃)m•s-1 (其中330.45是在0℃） 0℃声速： 330.45M/S 20℃声速： 342.62M/S 40℃声速： 354.85M/S0℃-40℃声速误差7%左右。实际应用，如果需要精确距离值，必需要考虑温度影响，做温度补偿。二：UART模式 UART 模式波特率设置： 9600 N 1 图片连接串口。外部MCU或PC发命令0XA0，模块完成测距后发3个返回距离数据，BYTE_H，BYTE_M与BYTE_L。距离计算方式如下（单位mm）：距离=(（BYTE_H<<16）+（BYTE_M<<8）+ BYTE_L)/1000 三：IIC模式 IIC地址： 0X57 IIC传输格式：写数据：图片读数据：图片命令格式：图片向模块写入0X01，模块开始测距；等待200mS(模块最大测距时间) 以上。直接读出3个距离数据。BYTE_H，BYTE_M与BYTE_L。距离计算方式如下（单位mm）：距离=(（BYTE_H<<16）+（BYTE_M<<8）+ BYTE_L)/1000 FPGA实现超声测距本次测距教程一律按基本原理实现，至于UART、ICC测距原理可以网上查询 FPGA 产生周期性的 TRIG 脉冲信号，使得超声波模块周期性发出测距脉冲，当这些脉冲发出后遇到障碍物返回，超声波模块将返回的脉冲处理整形后返回给 FPGA，即 ECHO 信号。我们通过对 ECHO 信号的高脉冲保持时间就可以推算出超声波脉冲和障碍物之间的距离。本实例的功能如图三所示，FPGA 产生 10us 脉冲 TRIG 给超声波测距模块，然后以 10us 为单位计算超声波测距模块返回的回响信号 ECHO 的高电平保持时间。ECHO 的高电平保持时间通过一定的换算后可以得到障碍物和超声波测距模块之间的距离（由距离公式计算&进制换算模块实现），我们将最终获得的以 mm 为单位的距离信息显示在 4 位数码管上。图片模块代码 1、vlg_en模块 /* * @Author: Hangyu Liu * @Date: 2023-11-20 15:24:01 * @Email: hyliu@ee.ac.cn * @Descripttion: 板子时钟转化1us * @Last Modified time: 2023-11-20 15:24:01 */ //1us/50ns=20 module vlg_1us#(parameter P_CLK_PERIORD = 50) //i_clk的时钟周期50ns,20MHZ ( input i_clk, input i_rst_n, output reg o_clk //时钟周期1us ); parameter NUM_DIV = 20;// (1MHZ = 1us,20MHZ/20 = 1MHZ) reg [3:0] cnt; always @(posedge i_clk or negedge i_rst_n) begin if(!i_rst_n) begin cnt <= 4'd0; o_clk <= 1'b0; end else if(cnt == NUM_DIV/2 - 1) begin cnt <= 4'b0; o_clk <= ~o_clk; end else cnt <= cnt + 1'b1; end endmodule2、vlg_trig模块 /* * @Author: Hangyu Liu * @Date: 2023-11-20 16:50:44 * @Email: hyliu@ee.ac.cn * @Descripttion: 产生10us的触发超声信号 * @Last Modified time: 2023-11-20 16:50:44 */ module vlg_trig ( input i_rst_n, input clk_1us, //1us output reg o_trig ); reg[17:0] r_tricnt; //200ms的周期计数 1us一个单位 always @(posedge clk_1us or negedge i_rst_n)begin if(!i_rst_n) r_tricnt <= 18'd0; else if((r_tricnt == 18'd199999)) r_tricnt <= 18'd0; else r_tricnt <= r_tricnt + 1'b1; end //产生保持10us的高脉冲o_tring信号 always @(posedge clk_1us or negedge i_rst_n) begin if(!i_rst_n) o_trig<=1'b0; else if((r_tricnt > 18'd0) && (r_tricnt <= 18'd10)) o_trig <= 1'b1; //不从0开始0~9，防止出现不到10us的波干扰 else o_trig <= 1'b0; end endmodule3、vlg_echo模块 module vlg_echo ( input i_clk, //1us input i_rst_n, input i_clk_1us, input i_echo, output reg[15:0] o_t_us ); reg[1:0] r_echo; wire pos_echo,neg_echo; reg r_cnt_en; reg[15:0] r_echo_cnt; //对i_echo信号同步处理，获取边沿检测信号，产生计数使能信号r_cnt_en always @(posedge i_clk or negedge i_rst_n) begin if(!i_rst_n) r_echo <= 2'd0; else r_echo <= {r_echo[0],i_echo}; //设置两个寄存器进行打拍寄存 end assign pos_echo = r_echo[0] & ~r_echo[1]; //现状态是1上状态是0，就是上升沿 assign neg_echo = ~r_echo[0] & r_echo[1]; always @(posedge i_clk or negedge i_rst_n) begin if(!i_rst_n) r_cnt_en <= 1'b0; else if(pos_echo) r_cnt_en <= 1'b1; else if(neg_echo) r_cnt_en <= 1'b0; else r_cnt_en <= r_cnt_en; end //对i_echo信号的高脉冲计时，以us为单位 always @(posedge i_clk_1us or negedge i_rst_n) begin if(!i_rst_n) r_echo_cnt <= 1'b0; else if(r_cnt_en) r_echo_cnt <= r_echo_cnt + 1'b1; else r_echo_cnt <= 1'b0; end //在下降沿对计数最大值进行保存 always @(negedge i_clk or negedge i_rst_n) begin if(!i_rst_n) o_t_us <= 16'd0; else if(neg_echo) o_t_us <= r_echo_cnt; else o_t_us <= o_t_us; end endmodule4、顶层模块例化 /* * @Author: Hangyu Liu * @Date: 2023-11-23 17:16:40 * @Email: hyliu@ee.ac.cn * @Descripttion:HR04驱动模块 * @Last Modified time: 2023-11-23 17:16:40 */ module vlg_design ( input i_clk, //200MHZ input i_rst_n, input i_echo, //这是超声模块给的输入 output o_trig, output wire[15:0] w_t_us ); wire clk_20MHZ; clk_div_20MHZ UU( .i_clk(i_clk), .i_rst_n(i_rst_n), .clk_div(clk_20MHZ) ); localparam P_CLK_PERIORD = 50; wire clk_1us; //使能时钟产生模块 vlg_1us #( .P_CLK_PERIORD(P_CLK_PERIORD) //i_clk的时钟周期50ns,20MHZ )U1( .i_clk(clk_20MHZ), .i_rst_n(i_rst_n), .o_clk(clk_1us) ); //产生超声波测距模块的触发信号o_trig vlg_trig U2( .i_rst_n(i_rst_n), .clk_1us(clk_1us), .o_trig(o_trig) ); //超声波测距模块的回响信号i_echo的高电平时间采集 vlg_echo U3( .i_clk(clk_20MHZ), .i_rst_n(i_rst_n), .i_clk_1us(clk_1us), .i_echo(i_echo), .o_t_us(w_t_us) ); endmoduleSTM32(Cubemax)实现超声波测距 CubeMX配置STM32 1 时钟配置这里我用的是STM32F103C8T6的核心板，时钟配置如下图，我用了8MHz的HSE，HCLK调到了最大值72MHz 图片 2 设置输入捕获的定时器设置定时器TIM2每1us向上计数一次，通道4为上升沿捕获并连接到超声波模块的ECHO引脚，记得开启定时器中断（涉及到捕获中断+定时器溢出中断）。图片 3 触发引脚 PB10接到了HC-SR04的TIRG触发引脚，默认输出低电平图片 4 串口配置还要开启一个串口，以便通过串口查看测距结果图片编写代码 hc-sr04.h #ifndef HCSR04_H_ #define HCSR04_H_ #include "main.h" #include "delay.h" typedef struct { uint8_t edge_state; uint16_t tim_overflow_counter; uint32_t prescaler; uint32_t period; uint32_t t1; // 上升沿时间 uint32_t t2; // 下降沿时间 uint32_t high_level_us; // 高电平持续时间 float distance; TIM_TypeDef* instance; uint32_t ic_tim_ch; HAL_TIM_ActiveChannel active_channel; }Hcsr04InfoTypeDef; extern Hcsr04InfoTypeDef Hcsr04Info; /** * @description: 超声波模块的输入捕获定时器通道初始化 * @param {TIM_HandleTypeDef} *htim * @param {uint32_t} Channel * @return {*} */ void Hcsr04Init(TIM_HandleTypeDef *htim, uint32_t Channel); /** * @description: HC-SR04触发 * @param {*} * @return {*} */ void Hcsr04Start(); /** * @description: 定时器计数溢出中断处理函数 * @param {*} main.c中重定义void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim) * @return {*} */ void Hcsr04TimOverflowIsr(TIM_HandleTypeDef *htim); /** * @description: 输入捕获计算高电平时间->距离 * @param {*} main.c中重定义void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) * @return {*} */ void Hcsr04TimIcIsr(TIM_HandleTypeDef* htim); /** * @description: 读取距离 * @param {*} * @return {*} */ float Hcsr04Read(); #endif /* HCSR04_H_ */ hc-sr04.c #include "hc-sr04.h" Hcsr04InfoTypeDef Hcsr04Info; /** * @description: 超声波模块的输入捕获定时器通道初始化 * @param {TIM_HandleTypeDef} *htim * @param {uint32_t} Channel * @return {*} */ void Hcsr04Init(TIM_HandleTypeDef *htim, uint32_t Channel) { /*--------[ Configure The HCSR04 IC Timer Channel ] */ // MX_TIM2_Init(); // cubemx中配置 Hcsr04Info.prescaler = htim->Init.Prescaler; // 72-1 Hcsr04Info.period = htim->Init.Period; // 65535 Hcsr04Info.instance = htim->Instance; // TIM2 Hcsr04Info.ic_tim_ch = Channel; if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_1) { Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_1; // TIM_CHANNEL_4 } else if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_2) { Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_2; // TIM_CHANNEL_4 } else if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_3) { Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_3; // TIM_CHANNEL_4 } else if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_4) { Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_4; // TIM_CHANNEL_4 } else if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_4) { Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_4; // TIM_CHANNEL_4 } /*--------[ Start The ICU Channel ]-------*/ HAL_TIM_Base_Start_IT(htim); HAL_TIM_IC_Start_IT(htim, Channel); } /** * @description: HC-SR04触发 * @param {*} * @return {*} */ void Hcsr04Start() { HAL_GPIO_WritePin(TRIG_GPIO_Port, TRIG_Pin, GPIO_PIN_SET); DelayUs(10); // 10us以上 HAL_GPIO_WritePin(TRIG_GPIO_Port, TRIG_Pin, GPIO_PIN_RESET); } /** * @description: 定时器计数溢出中断处理函数 * @param {*} main.c中重定义void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim) * @return {*} */ void Hcsr04TimOverflowIsr(TIM_HandleTypeDef *htim) { if(htim->Instance == Hcsr04Info.instance) // TIM2 { Hcsr04Info.tim_overflow_counter++; } } /** * @description: 输入捕获计算高电平时间->距离 * @param {*} main.c中重定义void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) * @return {*} */ void Hcsr04TimIcIsr(TIM_HandleTypeDef* htim) { if((htim->Instance == Hcsr04Info.instance) && (htim->Channel == Hcsr04Info.active_channel)) { if(Hcsr04Info.edge_state == 0) // 捕获上升沿 { // 得到上升沿开始时间T1，并更改输入捕获为下降沿 Hcsr04Info.t1 = HAL_TIM_ReadCapturedValue(htim, Hcsr04Info.ic_tim_ch); __HAL_TIM_SET_CAPTUREPOLARITY(htim, Hcsr04Info.ic_tim_ch, TIM_INPUTCHANNELPOLARITY_FALLING); Hcsr04Info.tim_overflow_counter = 0; // 定时器溢出计数器清零 Hcsr04Info.edge_state = 1; // 上升沿、下降沿捕获标志位 } else if(Hcsr04Info.edge_state == 1) // 捕获下降沿 { // 捕获下降沿时间T2，并计算高电平时间 Hcsr04Info.t2 = HAL_TIM_ReadCapturedValue(htim, Hcsr04Info.ic_tim_ch); Hcsr04Info.t2 += Hcsr04Info.tim_overflow_counter * Hcsr04Info.period; // 需要考虑定时器溢出中断 Hcsr04Info.high_level_us = Hcsr04Info.t2 - Hcsr04Info.t1; // 高电平持续时间 = 下降沿时间点 - 上升沿时间点 // 计算距离 Hcsr04Info.distance = (Hcsr04Info.high_level_us / 1000000.0) * 340.0 / 2.0 * 100.0; // 重新开启上升沿捕获 Hcsr04Info.edge_state = 0; // 一次采集完毕，清零 __HAL_TIM_SET_CAPTUREPOLARITY(htim, Hcsr04Info.ic_tim_ch, TIM_INPUTCHANNELPOLARITY_RISING); } } } /** * @description: 读取距离 * @param {*} * @return {*} */ float Hcsr04Read() { // 测距结果限幅 if(Hcsr04Info.distance >= 450) { Hcsr04Info.distance = 450; } return Hcsr04Info.distance; } main.c 1、引用对应的头文件 /* USER CODE BEGIN Includes */ #include "hc-sr04.h" #include "printf.h" /* USER CODE END Includes */2、200ms测距一次 /** * @brief The application entry point. * @retval int */ int main(void) { /* USER CODE BEGIN 1 */ /* USER CODE END 1 */ /* MCU Configuration--------------------------------------------------------*/ /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ HAL_Init(); /* USER CODE BEGIN Init */ /* USER CODE END Init */ /* Configure the system clock */ SystemClock_Config(); /* USER CODE BEGIN SysInit */ /* USER CODE END SysInit */ /* Initialize all configured peripherals */ MX_GPIO_Init(); MX_TIM2_Init(); MX_USART1_UART_Init(); /* USER CODE BEGIN 2 */ DelayInit(72); Hcsr04Init(&htim2, TIM_CHANNEL_4); // 超声波模块初始化 Hcsr04Start(); // 开启超声波模块测距 printf("hc-sr04 start!\r\n"); /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { // 打印测距结果 printf("distance:%.1f cm\r\n", Hcsr04Read()); Hcsr04Start(); DelayMs(200); // 测距周期200ms /* USER CODE END WHILE */ /* USER CODE BEGIN 3 */ } /* USER CODE END 3 */ } 3、重定义定时器的中断服务函数 /* USER CODE BEGIN 4 */ /** * @description: 定时器输出捕获中断 * @param {TIM_HandleTypeDef} *htim * @return {*} */ void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) { Hcsr04TimIcIsr(htim); } /** * @description: 定时器溢出中断 * @param {*} * @return {*} */ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim) { Hcsr04TimOverflowIsr(htim); } /* USER CODE END 4 */ 4、串口打印结果图片

嵌入式＆系统 FPGA&ASIC # ASIC/FPGA # 嵌入式

刘航宇 3年前
0 1,418 2
嵌入式/SOC开发利器-ZYNQ简介与入门摘要：ZYNQ是一款集ARM处理器和FPGA可编程逻辑的SoC芯片，适用于多种领域。它具有可编程性，可执行代码程序，也可实现FPGA。ZYNQ开发流程包括硬件和软件两部分，使用Vivado、Vitis IDE和PetaLinux等工具。入门简单，精通需要大量知识储备。ZYNQ是什么？ ZYNQ为什么厉害 ZYNQ的结构开发工具 ZYNQ开发流程 ZYNQ是什么？这是一款由Xilinx公司开发的集成了ARM处理器和FPGA可编程逻辑的片上系统（SoC）芯片。ZYNQ7000有多个型号，根据处理器核心数和FPGA系列的不同，可以应用于多种领域，如图像处理，通信，嵌入式系统等。 ZYNQ中国人读法 “zingke”、“任克”，“Soc”，英文全称叫 System on one Chip ，也就是片上系统的意思。没有微机基础的同学可能不明白什么叫Soc，但是你可以细细琢磨一下，我们的手机和台式电脑的不同，你就可以理解Soc的内含了。传统计算机是将CPU，内存，GPU，南北桥焊接在印刷电路板上，各个组件之间是分立的。但是Soc则将CPU和各种外设集中到一块芯片上，集合成一个系统，因此像手机这种使用了Soc芯片的这种微机可以做的很轻薄，我们可以说，Soc是未来微机发展的一个趋势，我之前遇见过的像什么全志的A33就是典型的Soc。 ZYNQ为什么厉害就在于它是一块可编程的Soc。其内部往往有处理器硬核和一些定制外设，并且外设当中有一个很厉害的玩意：PL，即可编程逻辑模块，也就是我们一般意义上的FPGA，所以简单理解ZYNQ就是“ 单片机 + FPGA “，它既可以执行代码程序，也可以实现FPGA。因此我们设计ZYNQ就是在做Soc设计。 ZYNQ的结构我们先来开一下简化版的模型图片上面的模型细致低展开后就是下图的样子：图片图是 ZYNQ 7000的结构图，大体分为PS（Processing System）和 PL（Programmable Logic）两部分，其中的PS部分主要是由双核APU和外围的一些外设组成，说实话很像单片机的结构，而外围的PL则类似FPGA，并且两者通过AXI接口进行互联以实现功能. 重点介绍一下APU，应用处理单元：Application Processing Unit，位于PS（processing system）中，包括一个单核或者双核的cortex-A9处理器，处理器连接一个512KB的共享L2cache，每个处理器都有一个32KB的高速L1 cache，A9支持虚拟内存和32bit arm 指令。APU中的A9处理器由可配置的MP组成，MP包含SCU（snoop control unit：监控控制单元）单元，这个单元主要负责获取两个处理器的L1 cache和ACP（accelerator coherency port：加速器相关接口） PL的一致性。应用单元还有一个低延迟的片上memory，与L2 cache并行的，ACP（加速器接口）是PL与APU通信接口，该接口是PL作为主机的AXI协议的接口，最多支持64bit位宽，PL通过ACP接口访问L2 cache 和片上memory，同时保持和L1 cache的内存一致性。L2 cache 可以访问 DDR 控制，这个ddr 控制器是专用的，大大降低内存读写的延迟APU 还包括一个32bit的看门狗，一个64bit的全局定时器，APU 架构图如下所示：图片开发工具在Vivado 19.2之前，我们开发Zynq需要三样必须的软件： Vivado SDK PetaLinux 其中Vivado用来开发硬件平台，SDK开发软件，PetaLinux则制作配套的Linux系统。可能有些人还有用到HLS ，即VIvado HLS 或者Vitis HLS；其中Vivado HLS 2020.1将是Vivado HLS的最后一个版本，取而代之的是VitisHLS。到了Vivado 19.2之后，事情发生了变化。为了方便大家理解，我愿意称之这些软件成了为Vitis 家族的各个部分，原来的SDK被Vitis IDE取代，Vivado导出的 .hdf 文件被 .xsa文件代替，用来给vitis平台使用。因此我们需要的开发Zynq 最基本的软件变成了 Vivado Vitis IDE PetaLinux 各软件发挥的作用和之前的差不多，不过除了上面提到的四款软件外，Vitis家族还有 Vitis AI 等组件，他们共同组成了所谓的“Vitis™ Unified Software Platform ”，从发展趋势来看，这些开发软件应该会逐步的统一，入门的同学也不会再一头雾水地纠结 Vitis 和 Vivado 的区别和联系了。 ZYNQ开发流程 ZYNQ类似于一个单片机 + FPGA的结构，其实我觉得如果大家接触过一些 Soc就会更好地理解ZYNQ的作用，就例如全志A33这块Soc，它是一块ASIC，不可以通过编程来对芯片的硬件进行重设计的。图片我们可以看到，灰色部分的外设都是固定的，像什么摄像头接口，什么视频接口都是设计好的，定制化的好处就使得总体比较高效，制造成本也低；但是如果我要运用到其它场景下，比如说我需要多个摄像头，那这块芯片就不再适合了（硬件控制的上限就是前后两颗摄像头）而ZYNQ的意义相当于只给你定制的蓝色部分，也就是处理器内核，灰色的部分都可以通过FPGA实现，这让电子工程师们可以快速开发出各种各样有针对性的Soc；当然了，看过我第一篇博客的同学都知道，其实固定的硬核不止只有处理器内核，其实还有串口和内存控制器之类的外设，这其实是追寻一种固定和变化之间的平衡。咱们把话说回ZYNQ的开发上来。图片 ZYNQ的开发流程分为硬件和软件两部分，在SDK之前的属于硬件开发，也就是我们常说的PL部分的开发，而SDK后就属于软件部分的开发了，类似单片机，属于PS部分。当然现在最新的Vitis IDE已经取代了SDK，所以后半部分一般在SDK中进行。 PL部分的开发包括对嵌入式最小系统的构建，以及FPGA外设的设计两个方面。我觉得要转变的一个思维是，我们现在不是在开发一个什么SDRAM控制器，什么IIC协议控制器，我们在开发的是一个小型的微机系统！因此嵌入式最小系统的设计是我们的核心。首先，在IP INTEGRATOR中我们要创建BLOCK DESIGN。图片 IP是用来进行 Embedded System Design ，也就是咱们常说的嵌入式系统设计。也就是咱们上面说的嵌入式最小系统的设计。图片大家可以看到，一个最小的系统其实不需要PL参与的，PL可以作为PS的一个外设使用，或者是自己做自己的事情，仅仅作为一个PL工作。既然是外设，当然是可用可不用的，毕竟咱们有好多的外设可以在Block Design 中直接配置使用，即下图绿色部分。图片配置好嵌入式系统后，咱们根据需要进行PL部分的设计。这里涉及一个问题，那就是PS和PL之间的数据传输方式有哪些：中断 IO方式：MIO EMIO GPIO BRAM或FIFO或EMIF AXI DMA：PS通过AXI-lite向AXI DMA发送指令，AXI DMA通过HP通路和DDR交换数据，PL通过AXI-S读写DMA的数据。等等。。。可以看出，其实两个部分的交互方式还是很多的，以后咱们遇到一个说一个。在Vivado端完成对嵌入式系统的设计后，我们就要进入Vitis IDE 端进行软件的开发。图片 Vitis IDE简单来说流程一般是：新建一个工程，选择Platform ，也就是我们之前在Vivado中生成的 XSA文件，然后添加文件，进行开发。我相信使用过Keil 5的同学们应该心中对文件目录结构应该更胸有成竹，Src文件夹中存放的是源文件。代码编写完之后是编译，编译完就是下载了。不过这里要注意以下，如果我们使用了PL的资源，那么在下载软件编译生成的 elf 文件之前，需要先下载硬件设计过程中生成的 bitstream 文件，对 PL 部分进行配置。最后就是验证工作了，上述的流程是普通的ZYNQ开发流程；玩的花一点的同学可能是直接上Linux操作系统，这部分等后面我接触到了再说吧！其实我觉得ZYNQ入门简单，精通的话需要大量的知识储备，但也不是不可能，开发ZYNQ相比于做单片机开发肯定路子会更广一些，向上可以做IC设计，向下嵌入式、单片机什么的工作也能胜任。

FPGA&ASIC IP&SOC设计 # ASIC/FPGA # 嵌入式 # SOC设计

刘航宇 3年前
0 4,717 5
2023-07-27
一张图看懂数字IC设计前后端全流程（DC ICC PT的关系）摘要：本文通过一张图展示了数字IC设计前后端全流程，包括DC综合、后端Place和Route、STA分析等环节，强调了前后端关系及DC综合与PrimeTime的时序分析重要性。关系图 pCvyhuT.png图片 DC综合后用PrimeTime做一遍STA DC的时候，通过SDC定义了很多约束,留下了很多Margin为后端，DC综合的网表是理想的状态。后端会进行Place和Route并进行CTS，这才接近于真实的电路，后端会通过QRC吐出SPEF, SPEF在转成sdf,供PT分析.此时PT分析的已经不是综合之后的网表，PT分析的是经过PR之后且CTS之后的网表。目的就是看在经过后端处理之后时序是否还signoff。前端DC综合的时候,本身也会进行timing分析，有些路径时序不收敛，DC也会报出来,如果确认这是一条真的路径. 这样你就要改RTL了. DC自己都报时序不收敛,后面也都没有做的必要了。

FPGA&ASIC EDA&虚拟机 # VLSI # EDA&虚拟机

刘航宇 3年前
0 2,950 1

317 文章数

567 评论量

人生倒计时

那年今日

2024 08/23 FPGA/数字IC之FIFO深度计算
2024 08/23 SoC架构、通信举例、AHB、APB接口

最新回复

泽泽
2026-08-22

支持typecho1.3吗
平平淡淡
2026-08-22

不错不错
麦麦同学
2026-08-21

看看能不能下载后台