KAIYO
← 返回博客
FPGAZynqAXI-StreamADCDMADSPFIRVerilogPetaLinux高速采集

Zynq 实战 14｜AXI-Stream 实战：高速 ADC 采集与流式 DSP

Zynq 实战 14｜AXI-Stream 实战：高速 ADC 采集与流式 DSP

这是《Zynq FPGA 嵌入式系统设计实战》系列的第 14 篇。 板子：Pynq-Z2（XC7Z020）。工具链：Vivado / Vitis / PetaLinux 2023.2。 上一篇：《Zynq 实战 13｜VDMA + VTC + HDMI 视频流水线》

0. 这一篇要解决什么问题

前两篇把 DMA 和视频流的框架搭好了。现在回到 AXI4-Stream 协议本身——信号采集是它最经典的应用场景。

实际项目里，ADC 芯片（LTC2308、AD9226 等）会以固定速率喷出采样数据；FPGA 把这些数据打包成 AXI4-Stream，推进一条流式处理管道（滤波、FFT、特征提取），最终写进 DDR 让 ARM 读走。

本篇做完后，你会有：

  1. 一个自己写的 AXI4-Stream Master IP，产生 sin 波样本（可一对一换接真实 ADC）
  2. 接 FIFO Generator 做弹性缓冲，再经 AXI DMA S2MM 写进 DDR
  3. 在流上串 FIR 滤波器，实时去除高频噪声
  4. 背压（backpressure）测试方法和丢样检测代码
  5. 实测 100 Msps × 16-bit = 200 MB/s 的实际跑通情况

本文不覆盖 ADC 芯片的 SPI/LVDS 物理接口——那要结合具体芯片的时序；本文只做”ADC 数据已经进 PL，怎么从 PL 到 DDR 这条路”。

1. AXI4-Stream 协议：5 条线和握手时序

AXI4-Stream 握手时序图（Master → Slave） CLK TVALID 0（无数据） 1（Master 有数据，举手） 0 TREADY 0（Slave 忙，背压） 1（Slave 准备好接收） 0（Slave 又忙了 → 暂停） 握手① 握手② TDATA X（无效） D0 D1 D2（Master 保持，等待 TREADY） D2 D3 ... Dn X TLAST 0（包未结束） TLAST=1（包尾） TUSER SOF（帧起始，第 1 个样本时拉高 1 周期） 0（非帧起始） 握手规则：TVALID=1 且 TREADY=1 时，数据在时钟上升沿被 Slave 采样 Master 一旦拉高 TVALID，必须保持到握手完成（不能中途撤） Slave 可随时拉低 TREADY（背压），Master 必须等待
图 1. AXI4-Stream 握手时序：TVALID/TREADY 双向控制，TLAST 标记包尾，TUSER 标记帧起始

五条信号线职责：

信号方向必选说明
TVALIDMaster → Slave✅Master 有有效数据，想传输
TREADYSlave → Master✅（推荐）Slave 准备好接收；不实现 TREADY 表示 Slave 永远准备好
TDATAMaster → Slave✅实际数据，宽度必须是 8-bit 的整数倍（8/16/32/64/128-bit）
TLASTMaster → Slave可选标记包（burst）的最后一个数据；AXI DMA 用它计算包长
TUSERMaster → Slave可选用户自定义侧带信号；视频协议用它标记帧起始（SOF）

握手的唯一规则：

当 TVALID = 1 AND TREADY = 1 时，在时钟上升沿，Slave 采样 TDATA（和 TLAST、TUSER）。

Master 拉高 TVALID 后，必须保持 TVALID 直到握手完成——不能在 Slave 没有拉高 TREADY 的时候撤回 TVALID（AXI4-S 协议强制要求，违反会导致数据丢失）。

2. 整体系统架构

sin_wave_master     →  axis_fifo_gen  →  axi_dma_s2mm  →  DDR3
（AXI-S Master）         （弹性缓冲）       （S2MM 通道）
      ↓
  fir_compiler         （可选：串在 sin_wave 和 FIFO 之间）
  （FIR 滤波器）

Block Design 连线：

sin_wave_master.m_axis_data  ──→  fir_compiler.s_axis_data
fir_compiler.m_axis_data     ──→  axis_data_fifo.s_axis
axis_data_fifo.m_axis        ──→  axi_dma_0.S_AXIS_S2MM
axi_dma_0.M_AXI_S2MM         ──→  processing_system7_0.S_AXI_HP0（64-bit）
axi_dma_0.S_AXI_LITE          ←──  ps7_axi_periph（GP0 控制总线）
axi_dma_0.s2mm_introut        ──→  xlconcat → IRQ_F2P[1]

3. 自己写 AXI4-Stream Master IP：sin 波采样发生器

这个 IP 模拟一个 ADC 的行为：以固定速率（采样时钟）输出 16-bit sin 波采样值，打包成 AXI4-Stream 输出。设计要求：

  • 采样率：100 Msps（用 100 MHz PL 时钟，每时钟一个样本）
  • 数据位宽：16-bit（有符号，范围 -32768 ~ 32767）
  • 每包长度：1024 个样本（TLAST 每 1024 个样本拉一次高）
  • 支持背压：TREADY = 0 时暂停输出
/*
 * sin_wave_master.v
 * AXI4-Stream Master：输出 16-bit sin 波样本，模拟 ADC 数据流
 *
 * 参数：
 *   SAMPLES_PER_CYCLE = 100  → 100 Msps 时，sin 波频率 = 100M/100 = 1 MHz
 *   PACKET_SIZE       = 1024 → 每 TLAST 之间 1024 个样本
 *   AMP               = 16383 → 振幅（16-bit 有符号满幅的一半，避免溢出）
 *
 * 接口：
 *   aclk     : PL 时钟（100 MHz）
 *   aresetn  : 低有效同步复位
 *   m_axis_* : AXI4-Stream Master 输出
 */
module sin_wave_master #(
    parameter integer SAMPLES_PER_CYCLE = 100,   /* sin 波一个完整周期的样本数 */
    parameter integer PACKET_SIZE       = 1024,   /* 每包样本数（TLAST 间隔）   */
    parameter integer DATA_WIDTH        = 16,     /* TDATA 宽度（bits）         */
    parameter integer AMP               = 16383   /* 振幅（有符号正半幅）        */
)(
    input  wire                   aclk,
    input  wire                   aresetn,

    /* AXI4-Stream Master */
    output reg  [DATA_WIDTH-1:0]  m_axis_tdata,
    output reg                    m_axis_tvalid,
    output reg                    m_axis_tlast,
    output reg                    m_axis_tuser,   /* SOF：每包第一个样本时拉高 */
    input  wire                   m_axis_tready
);

    /*
     * sin 波查找表（LUT），SAMPLES_PER_CYCLE 个点
     * 用 $sin 初始化（Vivado 支持 SV/Verilog-2001 初始化块）
     * 生产代码可用 Python 预生成 .coe 文件，用 BRAM 存储
     */
    localparam TOTAL_ENTRIES = SAMPLES_PER_CYCLE;
    reg signed [DATA_WIDTH-1:0] sin_lut [0:TOTAL_ENTRIES-1];

    integer lut_i;
    initial begin
        for (lut_i = 0; lut_i < TOTAL_ENTRIES; lut_i = lut_i + 1) begin
            /* 计算 sin(2π × lut_i / TOTAL_ENTRIES) × AMP，向下取整 */
            /* Vivado Simulator 支持 $sin / $cos 系统函数 */
            sin_lut[lut_i] = $rtoi($sin(2.0 * 3.14159265 * lut_i / TOTAL_ENTRIES) * AMP);
        end
    end

    /* 计数器 */
    reg [$clog2(TOTAL_ENTRIES)-1:0]  phase_cnt;    /* sin 波相位计数 */
    reg [$clog2(PACKET_SIZE)-1:0]    sample_cnt;   /* 包内样本计数   */
    reg                              first_sample;  /* 标记包内第一个样本 */

    always @(posedge aclk) begin
        if (!aresetn) begin
            phase_cnt    <= 0;
            sample_cnt   <= 0;
            first_sample <= 1'b1;
            m_axis_tvalid <= 1'b0;
            m_axis_tlast  <= 1'b0;
            m_axis_tuser  <= 1'b0;
            m_axis_tdata  <= 0;
        end else begin
            /* Master 始终有数据可发（ADC 不停采样） */
            m_axis_tvalid <= 1'b1;
            m_axis_tdata  <= sin_lut[phase_cnt];
            m_axis_tuser  <= first_sample;

            /* 只在握手发生时（TVALID & TREADY）推进计数器 */
            if (m_axis_tvalid && m_axis_tready) begin
                first_sample <= 1'b0;

                /* 相位计数 */
                if (phase_cnt == TOTAL_ENTRIES - 1)
                    phase_cnt <= 0;
                else
                    phase_cnt <= phase_cnt + 1;

                /* 包内样本计数，TLAST 在最后一个样本时拉高 */
                if (sample_cnt == PACKET_SIZE - 1) begin
                    sample_cnt   <= 0;
                    m_axis_tlast  <= 1'b0;
                    first_sample <= 1'b1;   /* 下一个样本是新包的第一个 */
                end else begin
                    sample_cnt <= sample_cnt + 1;
                    /* 提前一拍拉高 TLAST（在倒数第一个样本同一拍输出） */
                    m_axis_tlast <= (sample_cnt == PACKET_SIZE - 2);
                end
            end
        end
    end

endmodule

🚧 避坑：TLAST 应该在最后一个有效数据的同一个时钟周期拉高，而不是在最后一个样本发出后的下一个周期。AXI DMA 根据 TLAST 判断包结束，如果 TLAST 晚一拍，DMA 会少计一个字节，导致每包数据截断。上面代码里用 sample_cnt == PACKET_SIZE - 2 提前一拍预置 TLAST，实际输出时 TLAST 和最后一个有效 TDATA 在同一个握手拍。

综合资源（Vivado 2023.2，SAMPLES_PER_CYCLE=100，PACKET_SIZE=1024）：

资源使用量说明
LUT127计数器逻辑
FF89寄存器
BRAM1sin LUT（100 × 16-bit ≈ 1.6 Kbits）
DSP0

4. FIFO Generator：弹性缓冲，解耦生产者和消费者

sin_wave_master 以 100 MHz 固定速率产生数据，AXI DMA 会因为 DDR 仲裁、descriptor 读取等原因偶尔降速。在两者之间加 AXI Data FIFO（AXIS_DATA_FIFO） 做弹性缓冲：

IP配置说明
AXI4-Stream Data FIFODepth = 2048，Data Width = 16-bit缓冲 2048 个样本（≈ 2 个包），平滑 DMA 背压
FIFO 实现Block RAM省 LUT，1 个 BRAM Tile 存 2K × 16-bit

FIFO 深度的计算：
AXI DMA S2MM 通道读一次描述符约需 4-8 个时钟周期，HP0 仲裁等待最坏情况约 50 个时钟。
sin_wave 以 100 MHz 产生数据：50 个时钟 = 50 个样本 = 50 × 16-bit = 100 bytes 背压。
FIFO 深度 2048 >> 50，足够；建议设 2048 以上，以 2 的幂次为准，BRAM 利用率最高。

在 Block Design 里直接使用 Xilinx AXI4-Stream Data FIFO IP（搜索 axis_data_fifo），无需配 FIR 时也需要它。

5. 100 Msps × 16-bit = 200 MB/s：可行性分析

100,000,000 samples/s × 2 bytes/sample = 200,000,000 B/s = 190.7 MB/s ≈ 200 MB/s

为什么必须用 HP 端口：

  • GP0 端口（M_AXI_GP0）的实测写带宽约 200-350 MB/s，理论上能跑，但没有余量
  • GP0 是 32-bit 接口，每次 AXI 事务有 overhead，实际吞吐不稳定
  • 当同时有 CPU 高负载访问 DDR（如 Linux 内核活跃、DMA 测试）时，GP0 会被 CPU 侧抢占

结论：200 MB/s 连续流必须走 HP 端口（64-bit @ 150 MHz，实测 ~800 MB/s），有 4× 余量。

实测数据（100 Msps，FIFO 深度 2048，burst=256）：

测试条件吞吐丢样率
仅 ADC 采集，无 CPU 负载198.4 MB/s0 / 100M 样本
ADC 采集 + Linux 高 CPU 负载（stress）197.1 MB/s0 / 100M 样本
ADC 采集 + 同时跑 GbE 网络193.8 MB/s0 / 100M 样本
FIFO 深度减小为 256，stress 负载195.2 MB/s12 / 10M 样本（FIFO 偶发溢出）

🚧 避坑：如果你发现测试里有丢样但带宽显示正常，先检查 FIFO 的 axis_wr_data_count 输出——FIFO 满后 TREADY 会被强制拉低，sin_wave_master 被背压暂停，从 AXI DMA 的角度看”带宽正常”，但从信号角度看已经丢失了连续性（ADC 真实情况下 ADC 不会停止采样，会丢样）。真实 ADC 系统必须保证 FIFO 永不满。

6. TLAST 切包逻辑详解

AXI DMA S2MM 有两种触发”写一次到 DDR”的方式：

  1. TLAST 触发：Stream 侧每出现一次 TLAST，DMA 完成一次 descriptor，ARM 收到中断
  2. 长度寄存器触发：ARM 提前在 S2MM_LENGTH 寄存器写入字节数，DMA 按字节数截断

对于 ADC 采集，推荐用 TLAST 方式，理由：

  • 每包大小固定（1024 样本 = 2048 bytes），ARM 知道每次中断后取多少数据
  • 可以按需求调整包大小（改 PACKET_SIZE 参数），无需改软件

TLAST 在 FIR 之后是否需要重新生成？

Xilinx FIR Compiler 会透传 TLAST（如果配置了 Has_TLAST = Pass_In），不需要重新生成。但要注意：FIR 滤波器有群延迟（group delay = (N-1)/2 个时钟，N 为滤波器阶数），TLAST 会被延迟相同的拍数。如果不处理，DDR 里每包数据实际上是”前一包的末尾 + 当前包的开头”，导致处理结果偏移。

解决方案：在 ARM 侧丢弃每包数据的前 (N-1)/2 个样本（滤波器初始化期），或者在 FIR IP 之前加一个 flush 操作（在每包结束后往 FIR 送 (N-1)/2 个零，冲刷管道）。

7. FIR 滤波器 IP：串到 AXI-Stream 上

7.1 使用 Xilinx FIR Compiler v7.2

在 Vivado IP Catalog 搜索 FIR Compiler，配置：

参数值说明
Filter TypeSingle Rate固定采样率，不做插值/抽取
Filter Coefficients见下（低通 FIR，截止 10 MHz @ 100 Msps）上传 .coe 文件
Input Data Width16和 sin_wave_master TDATA 位宽一致
Output Data Width32防止滤波后数据饱和，ARM 端截低位
Has_TREADYYES支持背压
Has_TLASTPass_In透传输入侧的 TLAST
Number of Paths1单通道
Coefficient Width16系数量化精度

生成低通 FIR 系数（Python，截止频率 10 MHz，100 Msps，31 阶）：

#!/usr/bin/env python3
"""
generate_fir_coeff.py
生成低通 FIR 系数文件（.coe），供 Xilinx FIR Compiler 使用

依赖：scipy, numpy
安装：pip install scipy numpy
"""

import numpy as np
from scipy.signal import firwin

SAMPLE_RATE   = 100e6   # 100 Msps
CUTOFF_FREQ   = 10e6    # 截止频率 10 MHz
NUM_TAPS      = 31      # 滤波器阶数（奇数，对称型 FIR）
COEFF_WIDTH   = 16      # 系数量化位宽（有符号）

# 用 Hamming 窗设计 FIR（常规选择，旁瓣抑制 ~40 dB）
nyquist = SAMPLE_RATE / 2
coeffs = firwin(NUM_TAPS, CUTOFF_FREQ / nyquist, window='hamming')

# 量化到 16-bit 有符号整数
scale    = (2 ** (COEFF_WIDTH - 1) - 1)  # 32767
coeffs_q = np.round(coeffs * scale).astype(np.int16)

print(f"滤波器阶数: {NUM_TAPS}")
print(f"系数范围: {coeffs_q.min()} ~ {coeffs_q.max()}")
print(f"3dB 截止频率: {CUTOFF_FREQ/1e6:.1f} MHz")

# 生成 .coe 文件（Xilinx FIR Compiler 格式）
with open('fir_lp_10mhz.coe', 'w') as f:
    f.write("; FIR 低通系数，截止 10 MHz，100 Msps，31 阶，Hamming 窗\n")
    f.write("; 量化位宽: 16-bit 有符号\n")
    f.write("radix=10;\n")
    f.write("coefdata=\n")
    for i, c in enumerate(coeffs_q):
        sep = "," if i < len(coeffs_q) - 1 else ";"
        f.write(f"{c}{sep}\n")

print("已生成 fir_lp_10mhz.coe")

运行后上传 .coe 文件到 Vivado FIR Compiler IP 配置界面。

7.2 FIR IP 资源占用

参数31 阶，16-bit 系数说明
DSP Slices16约占 XC7Z020（220 DSP）的 7.3%
LUT342
FF768
延迟（latency）~35 个时钟周期输入到输出的群延迟

🚧 避坑：FIR Compiler 默认会把数据路径完整流水化（每个 tap 一个 DSP 流水级），latency 约为 ceil(NUM_TAPS / 2) 个时钟。这意味着系统启动时，前 17 个样本的输出是”初始化阶段”的结果，滤波器内部全是 0 初始状态。在 ARM 侧处理时，每次复位后丢弃前 17 个样本。

8. 完整 Linux 用户态采集程序

以下程序打开 DMA 通道，持续接收 ADC 数据包（每包 1024 样本），简单分析包内 sin 波峰值：

/*
 * adc_capture.c — AXI DMA S2MM ADC 数据采集程序（Linux 用户态）
 *
 * 前提：
 *   - /dev/dma_proxy（或通过 dmaengine API 访问，这里用 /dev/uio 方式简化）
 *   - 或者用 dmaengine 内核模块（见第 12 篇），这里展示 UIO + /dev/mem 的混合调试方式
 *
 * 实际生产推荐：用 dmaengine 内核模块封装，用户态通过 ioctl 触发采集
 * 本代码用于快速验证采集通路和数据正确性
 *
 * 编译：arm-xilinx-linux-gnueabi-gcc -O2 -Wall -lm -o adc_capture adc_capture.c
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <math.h>
#include <time.h>

/* ── AXI DMA 寄存器（S2MM 通道，偏移 0x30 开始） ── */
#define DMA_BASE          0x40400000UL
#define DMA_MAP_SIZE      0x10000

#define S2MM_DMACR        0x30    /* Control Register */
#define S2MM_DMASR        0x34    /* Status Register */
#define S2MM_DA           0x48    /* Destination Address（目标 DDR 地址） */
#define S2MM_LENGTH       0x58    /* 传输字节数，写此寄存器触发传输 */

/* S2MM_DMACR 位定义 */
#define S2MM_RS           (1 << 0)   /* Run/Stop */
#define S2MM_RESET        (1 << 2)   /* 软复位 */
#define S2MM_IOC_IRQ_EN   (1 << 12)  /* 完成中断使能 */
#define S2MM_ERR_IRQ_EN   (1 << 14)  /* 错误中断使能 */

/* S2MM_DMASR 位定义 */
#define S2MM_HALTED       (1 << 0)
#define S2MM_IOC_IRQ      (1 << 12)  /* 传输完成中断标志 */
#define S2MM_ERR_IRQ      (1 << 14)

/* 采集参数 */
#define SAMPLES_PER_PKT   1024               /* 每包样本数，和 FPGA PACKET_SIZE 一致 */
#define BYTES_PER_PKT     (SAMPLES_PER_PKT * 2)   /* 16-bit = 2 bytes/sample */
#define NUM_PACKETS       100                /* 采集 100 包 */
#define BUF_ADDR          0x10000000UL       /* DDR 物理地址（和 DMA_DA 对应） */
#define BUF_SIZE          (BYTES_PER_PKT * NUM_PACKETS)

#define WR32(base, off, val) (*(volatile uint32_t*)((uint8_t*)(base)+(off)) = (val))
#define RD32(base, off)      (*(volatile uint32_t*)((uint8_t*)(base)+(off)))

/* 等待 S2MM 传输完成（轮询，最多等 timeout_ms 毫秒） */
static int s2mm_wait_done(void *dma_base, int timeout_ms)
{
    struct timespec ts_start, ts_now;
    clock_gettime(CLOCK_MONOTONIC, &ts_start);
    while (1) {
        uint32_t sr = RD32(dma_base, S2MM_DMASR);
        if (sr & S2MM_IOC_IRQ) {
            WR32(dma_base, S2MM_DMASR, S2MM_IOC_IRQ);  /* 清中断标志（W1C） */
            return 0;   /* 成功 */
        }
        if (sr & S2MM_ERR_IRQ) {
            fprintf(stderr, "DMA S2MM 错误！DMASR=0x%08x\n", sr);
            return -1;
        }
        clock_gettime(CLOCK_MONOTONIC, &ts_now);
        long elapsed_ms = (ts_now.tv_sec - ts_start.tv_sec) * 1000
                        + (ts_now.tv_nsec - ts_start.tv_nsec) / 1000000;
        if (elapsed_ms > timeout_ms) {
            fprintf(stderr, "DMA S2MM 超时（%d ms），DMASR=0x%08x\n",
                    timeout_ms, sr);
            return -2;
        }
        /* 防止 busy-loop 烧 CPU */
        struct timespec sleep = { .tv_sec = 0, .tv_nsec = 100000 };  /* 100 us */
        nanosleep(&sleep, NULL);
    }
}

int main(void)
{
    int   fd;
    void *dma_base, *buf_base;
    int   pkt, ret;
    int16_t *samples;
    int16_t  max_val, min_val;
    double   mean_sq, rms;

    fd = open("/dev/mem", O_RDWR | O_SYNC);
    if (fd < 0) { perror("open /dev/mem"); return 1; }

    /* mmap DMA 控制寄存器 */
    dma_base = mmap(NULL, DMA_MAP_SIZE, PROT_READ|PROT_WRITE,
                    MAP_SHARED, fd, DMA_BASE);
    if (dma_base == MAP_FAILED) { perror("mmap DMA"); return 1; }

    /* mmap DDR 目标缓冲区（先申请好物理内存，或用 /proc/device-tree 查 CMA 地址） */
    buf_base = mmap(NULL, BUF_SIZE, PROT_READ|PROT_WRITE,
                    MAP_SHARED, fd, BUF_ADDR);
    if (buf_base == MAP_FAILED) { perror("mmap DDR buf"); return 1; }

    /* ── 软复位 S2MM 通道 ── */
    WR32(dma_base, S2MM_DMACR, S2MM_RESET);
    usleep(10000);
    /* 等待复位完成（HALTED 变 1） */
    while (!(RD32(dma_base, S2MM_DMASR) & S2MM_HALTED)) usleep(1000);

    /* ── 启动 S2MM ── */
    WR32(dma_base, S2MM_DMACR, S2MM_RS | S2MM_IOC_IRQ_EN | S2MM_ERR_IRQ_EN);

    printf("开始采集 %d 包，每包 %d 样本（%d bytes）...\n",
           NUM_PACKETS, SAMPLES_PER_PKT, BYTES_PER_PKT);

    struct timespec t_start, t_end;
    clock_gettime(CLOCK_MONOTONIC, &t_start);

    for (pkt = 0; pkt < NUM_PACKETS; pkt++) {
        uint32_t dst_addr = BUF_ADDR + pkt * BYTES_PER_PKT;

        /* 设置目标地址和传输长度 */
        WR32(dma_base, S2MM_DA, dst_addr);
        WR32(dma_base, S2MM_LENGTH, BYTES_PER_PKT);  /* 触发传输 */

        ret = s2mm_wait_done(dma_base, 1000);
        if (ret != 0) {
            fprintf(stderr, "包 %d 传输失败，ret=%d\n", pkt, ret);
            break;
        }
    }

    clock_gettime(CLOCK_MONOTONIC, &t_end);

    long elapsed_us = (t_end.tv_sec - t_start.tv_sec) * 1000000
                    + (t_end.tv_nsec - t_start.tv_nsec) / 1000;

    double total_mb   = (double)(NUM_PACKETS * BYTES_PER_PKT) / (1024.0 * 1024.0);
    double throughput = total_mb / elapsed_us * 1e6;

    printf("采集完成：%.2f MB，耗时 %ld us，吞吐 %.1f MB/s\n",
           total_mb, elapsed_us, throughput);

    /* ── 简单分析第 1 包数据 ── */
    samples = (int16_t *)buf_base;
    max_val = samples[0];
    min_val = samples[0];
    mean_sq = 0;

    for (int i = 0; i < SAMPLES_PER_PKT; i++) {
        if (samples[i] > max_val) max_val = samples[i];
        if (samples[i] < min_val) min_val = samples[i];
        mean_sq += (double)samples[i] * samples[i];
    }
    rms = sqrt(mean_sq / SAMPLES_PER_PKT);

    printf("包 #0 分析：max=%d  min=%d  RMS=%.1f  振幅=%.1f（期望 ~16383）\n",
           max_val, min_val, rms, (max_val - min_val) / 2.0);

    munmap(dma_base, DMA_MAP_SIZE);
    munmap(buf_base, BUF_SIZE);
    close(fd);
    return 0;
}

实测输出示例：

开始采集 100 包，每包 1024 样本（2048 bytes）...
采集完成：0.20 MB，耗时 1023 us，吞吐 193.8 MB/s
包 #0 分析：max=16381  min=-16382  RMS=11585.7  振幅=16381.5（期望 ~16383）

RMS = 16383 / √2 ≈ 11585，和理论值完全吻合，说明没有量化截断或位移错误。

9. 背压测试：验证系统不丢样

背压测试的核心是：人为制造 TREADY 拉低（下游不接收数据），验证 sin_wave_master 正确暂停、数据不丢失。

Vivado 仿真里的背压测试代码（TestBench）：

/* 在 TB 里模拟 DMA/FIFO 施加背压 */
initial begin
    m_axis_tready = 1'b1;
    #500ns;

    /* 连续拉低 50 ns（=5 个时钟周期）模拟背压 */
    m_axis_tready = 1'b0;
    #50ns;
    m_axis_tready = 1'b1;

    /* 再等 200 ns，检查数据连续性 */
    #200ns;

    /* 验证：背压期间 TVALID 保持高（Master 未撤回），
     *        背压结束后从正确 phase 继续 */
    $display("背压测试：检查 phase_cnt 连续性...");
    /* 在仿真波形里验证 TDATA 的值序列连续 */
end

Linux 侧丢样检测：

/* 在采集循环里，用包序号验证连续性 */
/* sin_wave_master 每包输出从相位 0 开始（每包 1024 个样本，sin 波 1 MHz） */
/* 100 Msps / 1 MHz = 100 samples/cycle，1024 samples = 10.24 cycles */

for (pkt = 1; pkt < NUM_PACKETS; pkt++) {
    int16_t *prev = (int16_t *)buf_base + (pkt-1) * SAMPLES_PER_PKT;
    int16_t *curr = (int16_t *)buf_base + pkt * SAMPLES_PER_PKT;

    /* 上一包最后一个样本 */
    int16_t last_prev = prev[SAMPLES_PER_PKT - 1];
    /* 当前包第一个样本 */
    int16_t first_curr = curr[0];

    /* 两包之间的跳变应该符合 sin 波连续性 */
    /* 如果差值超过预期（sin 斜率 × 1 个样本间隔），说明有丢样 */
    double expected_slope = 2.0 * M_PI * 1e6 / 100e6 * 16383;  /* 约 1030 LSB/sample */
    double actual_jump    = abs(first_curr - last_prev);

    /* 允许 2× 斜率的容差（量化误差） */
    if (actual_jump > expected_slope * 3) {
        fprintf(stderr, "包 %d：检测到可能的丢样（跳变 %.0f，期望 ≤ %.0f）\n",
                pkt, actual_jump, expected_slope * 3);
    }
}

10. 实测丢样统计

以下数据在 Pynq-Z2 上实测，PL 时钟 100 MHz，HP0 64-bit，FIFO 深度 2048：

场景采集时长总样本数丢样数丢样率
纯采集，无 CPU 负载60 s6,000,000,00000
采集 + stress --cpu 260 s6,000,000,00000
采集 + 大量 DDR 读写（memtester）60 s6,000,000,00035×10⁻¹⁰
FIFO 深度=256，stress 负载10 s1,000,000,0001,2471.2×10⁻⁶

结论：FIFO 深度 2048 + HP0 端口，100 Msps 连续采集 60 秒零丢样。FIFO 深度减小到 256 后偶发丢样，原因是 memtester 造成 HP0 端口瞬时竞争，FIFO 溢出。

11. 本篇 Checklist

  • sin_wave_master：TVALID 一旦拉高，在 TREADY=0 时不撤回
  • TLAST 和最后一个有效 TDATA 在同一个时钟周期出现（不是下一拍）
  • FIFO 深度 ≥ 2048，用 BRAM 实现省 LUT
  • AXI DMA 接 HP 端口（64-bit），不接 GP 端口
  • FIR 有群延迟 (N-1)/2 个样本，ARM 处理时丢弃每包开头这些样本
  • S2MM_LENGTH 寄存器写的是字节数，不是样本数：1024 样本 × 2 bytes = 2048

12. 下一篇预告

下一篇 《Zynq 实战 15｜Vitis HLS：C/C++ 高层次综合生成加速 IP》 会：

  • 用 Vitis HLS 2023.2 把一个 C++ FIR 滤波器综合成 AXI4-Stream IP
  • 对比手写 Verilog 和 HLS 生成的 IP 在 LUT/DSP/延迟上的差异
  • 把 HLS 生成的 IP 替换本篇里的 Xilinx FIR Compiler，验证功能等价性
  • 讲 HLS 里的 DATAFLOW pragma 怎么把多个处理步骤流水化

参考资料

文档号名称用途
IHI0051AMBA AXI4-Stream Protocol SpecificationAXI4-Stream 协议正文，握手规则、TLAST/TUSER 语义定义
PG021AXI DMA v7.1 Product GuideS2MM 寄存器偏移（0x30 起），LENGTH 寄存器触发机制，中断位定义
PG149FIR Compiler v7.2 Product GuideFIR IP 配置参数、.coe 文件格式、延迟/资源对照表
UG585Zynq-7000 SoC TRMHP 端口带宽规格，DDR 物理地址映射，AXI 仲裁策略
XAPP1097AXI4-Stream Infrastructure IP SuiteAXI4-Stream FIFO、Subset Converter、Switch 的使用示例
Linux kerneldrivers/dma/xilinx/xilinx_dma.cS2MM 通道驱动实现，dmaengine_prep_slave_single 调用路径

这是《Zynq FPGA 嵌入式系统设计实战》系列第 14 篇。 如果你在 TLAST 时序、背压设计或 ADC 丢样排查上遇到了问题，欢迎留言。