从零实现卷积神经网络硬件加速：Verilog脉动阵列核心设计详解

简介：本资源是一套完整可运行的Verilog脉动阵列卷积加速器实现，面向计算机体系结构、AI芯片设计、数字电路课程学习者及毕设/课设开发者，聚焦TPU核心计算单元——脉动阵列在卷积运算中的硬件建模与验证。压缩包共32个文件（1.17MB），含18个Verilog模块源码（如PE.v、PE_array.v、controller.v、accelerator.v等）、6个文本配置与测试说明、3个.npy实验数据文件、3个Python数据预处理脚本及1份PDF实验报告和1份README文档；测试用例覆盖单元级（PE、shifter）到系统级（pe_all_testbench）全链路验证。已有178人下载学习，所有模块均通过仿真测试并功能完备，支持直接上手仿真、理解脉动阵列数据流调度机制，亦可作为AI加速器课程设计基础框架或毕设硬件部分原型，具备良好可扩展性与教学适配性。

1. 项目缘起：从软件仿真到硬件加速的跨越

几年前，我在做一个图像识别的边缘计算项目，当时用Python写的卷积神经网络（CNN）在树莓派上跑，识别一张图要好几秒，功耗还高得烫手。那会儿我就琢磨，能不能用硬件来加速这个最耗时的卷积计算？软件层面的优化已经到瓶颈了，无非是调调库、用用GPU，但真想追求极致的能效比和实时性，还得是专用硬件。TPU（张量处理单元）的核心秘密武器——脉动阵列（Systolic Array），就成了我研究的重点。这东西听起来高大上，其实原理很直观：它像一条精心设计的流水线，让数据和计算在阵列中“脉动”流动，最大化地复用数据，减少访存，从而爆发出惊人的计算吞吐量。

但网上的资料要么是论文里复杂的数学描述和架构图，看得人云里雾里；要么就是一些高度抽象的行为级仿真代码，离真正的硬件实现隔着一层纱。对于一个硬件工程师来说，不亲手用Verilog敲出一个能综合、能下板的模块，心里总是不踏实。所以，我决定自己动手，实现一个用于计算卷积的脉动阵列核心模块。这个项目的目标很明确：不是复现一个完整的TPU，而是深入最核心的计算单元，用Verilog语言，从寄存器传输级（RTL）设计开始，构建一个参数可配置、接口清晰、经过充分仿真验证的卷积计算模块。我会把整个思考过程、设计细节、踩过的坑以及最终的源码和实验数据都分享出来，希望能给同样对硬件加速感兴趣的朋友们一块可靠的“砖头”。

2. 脉动阵列为何是卷积计算的“天作之合”

在深入代码之前，我们必须先搞清楚，为什么脉动阵列这种结构特别适合做卷积，或者说更广义的矩阵乘法（GEMM）运算。理解这一点，是设计好这个模块的前提。

2.1 卷积的本质：多重矩阵乘法的叠加

很多人一提到卷积就想到滑动窗口、乘加运算。没错，但对于硬件实现，尤其是追求规则化和并行化的硬件，我们需要一个更“整齐”的视角。实际上，一个卷积层可以通过一个叫做im2col（Image to Column）的变换，被转换成一个大大的矩阵乘法。

简单来说，对于输入特征图（IFMAP），我们根据卷积核大小和步长，将其每个可能的卷积窗口展平成一个列向量，所有这些列向量拼起来，就形成了一个大的二维矩阵。卷积核的权重，也展平成一个行向量（对于单个输出通道）或矩阵（对于多个输出通道）。这样，卷积运算就变成了这个权重矩阵和im2col变换后的输入矩阵的乘法，结果就是输出特征图（OFMAP）的数据。

注意：im2col变换会引入巨大的数据冗余（同一输入像素在不同窗口被重复展开），在软件上这是内存开销，但在脉动阵列的硬件数据流设计中，这种“冗余”恰恰可以被巧妙地利用和掩盖，通过数据复用减少对高带宽存储的依赖。

2.2 脉动阵列的精妙：数据流与计算流的交响

脉动阵列可以看作一个计算单元的网格（比如8x8, 32x32, 256x256）。每个处理单元（PE）非常简单，通常只做乘积累加（MAC）操作：PE.out = PE.reg + PE.in_weight * PE.in_data。

它的精妙之处在于数据流动方式：

1. 权重（Weight）：通常沿阵列的列方向（垂直）同步向下流动。每个时钟周期，权重向下移动一行。
2. 输入数据（Data/IFMAP）：通常沿阵列的行方向（水平）同步向右流动。每个时钟周期，数据向右移动一列。
3. 部分和（Partial Sum）：在PE内部累加，并可以沿着阵列的对角线或列方向传递，用于跨PE的累加。

想象一下，一个权重元素W和一个数据元素D在某个PE相遇。它们相乘的结果被累加到该PE的部分和寄存器中。下一个周期，W流到了它下面的PE，D流到了它右边的PE。此时，原来的PE迎来了新的W'和D'进行运算，而W和D则在新的PE中与新的邻居（来自其他PE的部分和）结合，继续完成更大范围的乘积累加。

这样设计带来的核心优势：

• 极高的数据复用率：每个权重和数据在穿过整个阵列的过程中，会与多行/多列的数据/权重进行计算，被重复使用多次。这极大地降低了对片外存储器（如DDR）带宽的需求，而带宽往往是硬件加速器的瓶颈。
• 规则的数据流和控制流：整个阵列的PE执行相同的操作（MAC），只需要全局的时钟和简单的数据移动控制，硬件控制逻辑极其简单，易于扩展。
• 高并行度：一个N x N的阵列，每个时钟周期理论上可以进行N^2次乘法和N^2次加法操作，计算密度非常高。

对于卷积（经im2col变换后）这种需要大量规整乘加运算的任务，脉动阵列能将数据流和计算流完美匹配，把计算资源“喂”得饱饱的，效率自然远高于通用处理器。

3. 模块架构设计与关键接口定义

有了理论铺垫，我们开始动手设计。我的目标是实现一个参数化的、可综合的Verilog模块。它不是一个完整的SoC，而是一个计算核心，需要与外部存储器控制器、数据搬运单元等协同工作。

3.1 顶层模块接口与参数

我定义的顶层模块名为systolic_array_conv。通过parameter实现高度可配置，这是工业级IP的常见做法。

module systolic_array_conv #( parameter DATA_WIDTH = 8, // 输入数据和权重的位宽 parameter ACC_WIDTH = 32, // 累加器的位宽，防止溢出 parameter ARRAY_SIZE = 8, // 脉动阵列的大小，如8表示8x8 parameter KERNEL_SIZE = 3, // 卷积核尺寸（假设为方形，如3x3） parameter STRIDE = 1, // 卷积步长 parameter IFMAP_CH = 4, // 输入特征图通道数 parameter OFMAP_CH = 8 // 输出特征图通道数（卷积核个数） )( input wire clk, input wire rst_n, // 数据加载接口（类AXI-Stream简化版） input wire data_in_valid, input wire [DATA_WIDTH-1:0] data_in, output wire data_in_ready, input wire weight_in_valid, input wire [DATA_WIDTH-1:0] weight_in, output wire weight_in_ready, // 计算结果输出接口 output wire data_out_valid, output wire signed [ACC_WIDTH-1:0] data_out, input wire data_out_ready, // 控制信号 input wire start, // 启动一次计算 output wire busy, // 模块忙标志 output wire done // 计算完成标志 );

参数设计考量：

• DATA_WIDTH=8： 这是为了模拟量化后的神经网络，常用INT8，平衡精度和硬件开销。
• ACC_WIDTH=32： 8位乘8位得到16位结果，在ARRAY_SIZE=8的情况下，最多累加8次，需要约19-20位。设置32位留有充足余量，便于后续添加批归一化（Batch Norm）或激活函数的偏移计算。
• ARRAY_SIZE=8： 这是一个折衷。阵列越大，并行度越高，但布线延迟和面积也会急剧增加。8x8对于学习和中小规模FPGA验证比较合适。

接口设计考量：

• 采用了类AXI-Stream的valid/ready握手协议。这是现代片上互联（NoC）和IP核间通信的事实标准，能很好地处理数据生产者和消费者之间的速度匹配问题。
• 将data_in和weight_in分离，是因为在实际系统中，权重通常一次性加载到阵列附近的权重缓存（Weight Buffer）中并保持静止（或缓慢更新），而输入数据则连续流入。这里为了模块的通用性，设计为均可流式输入。
• start/busy/done是简单的全局状态信号，方便上层控制器进行调度。

3.2 核心PE单元的设计

PE是阵列的基石。它的设计直接关系到性能、面积和功耗。

module processing_element #( parameter DATA_WIDTH = 8, parameter ACC_WIDTH = 32 )( input wire clk, input wire rst_n, input wire en, // PE使能信号，可用于功耗门控 // 数据流 input wire signed [DATA_WIDTH-1:0] data_in_left, // 来自左侧PE的数据 output reg signed [DATA_WIDTH-1:0] data_out_right, // 输出到右侧PE的数据 // 权重流 input wire signed [DATA_WIDTH-1:0] weight_in_top, // 来自上方PE的权重 output reg signed [DATA_WIDTH-1:0] weight_out_bottom, // 输出到下方PE的权重 // 部分和流 input wire signed [ACC_WIDTH-1:0] psum_in_top, // 来自上方PE的部分和（用于累加） output reg signed [ACC_WIDTH-1:0] psum_out_bottom // 输出到下方PE的部分和 // 注：实际设计中，psum的流向可能有多种（向下、向右、累加后输出），这里采用经典的向下传递模式。 ); reg signed [DATA_WIDTH-1:0] weight_reg; // 当前PE锁存的权重 reg signed [ACC_WIDTH-1:0] psum_reg; // 当前PE的部分和寄存器 always @(posedge clk or negedge rst_n) begin if (!rst_n) begin weight_reg <= '0; psum_reg <= '0; data_out_right <= '0; weight_out_bottom <= '0; psum_out_bottom <= '0; end else if (en) begin // 1. 锁存传入的权重和部分和（对于第一行/列，这些输入来自外部） weight_reg <= weight_in_top; // 注意：psum_in_top是来自上一个PE的累加结果，需要与本地计算结果相加 // 本地计算：data_in_left * weight_reg (注意是上一周期锁存的权重！) psum_reg <= psum_in_top + (data_in_left * weight_reg); // 2. 将数据和权重传递给下一个PE（直通或寄存器打拍） data_out_right <= data_in_left; weight_out_bottom <= weight_reg; // 传递锁存后的权重 psum_out_bottom <= psum_reg; // 传递累加后的部分和 end end endmodule

PE设计的关键点与踩坑记录：

1. 数据对齐问题（大坑！）： 注意看psum_reg的计算psum_in_top + (data_in_left * weight_reg)。这里用的是weight_reg，即上一个周期锁存的weight_in_top。为什么？因为在本时钟周期，data_in_left和weight_in_top是同时到达PE端口的。如果直接用它们相乘，那么这个乘积无法在本周期内与同样刚到达的psum_in_top相加（需要额外的组合逻辑，可能导致时序紧张）。更严重的是，这样设计会破坏脉动节奏。标准的做法是：PE在时钟上升沿锁存来自上方和左侧的输入（权重和部分和），而数据则是直通或打一拍传到右侧。本地计算使用的是锁存的权重和当前到达的数据。这确保了每个PE内的乘法和加法有完整的时钟周期完成，并且数据、权重、部分和在阵列中的“流动”是同步的。
2. 使能信号en： 这个信号非常有用。当阵列不需要工作时，可以通过拉低en关闭所有PE的时钟门控（如果综合工具支持）或至少阻止寄存器翻转，能显著降低静态和动态功耗。
3. 寄存器打拍 vs. 直通： 上述代码中，数据、权重、部分和的传递都经过了一级寄存器打拍。这增加了一个周期的延迟，但极大地改善了时序（Timing），因为打破了组合逻辑长路径。这是面积换速度的典型做法。在高速设计中，几乎必须这么做。

3.3 阵列互联与控制逻辑生成

将PE实例化并连接成网格，是体力活也是精细活。我们需要生成阵列第一行和第一列的特殊输入，以及收集最后一行的输出。

// 在 systolic_array_conv 模块内部 genvar i, j; wire signed [DATA_WIDTH-1:0] data_h [0:ARRAY_SIZE][0:ARRAY_SIZE]; // 水平数据线 wire signed [DATA_WIDTH-1:0] weight_v [0:ARRAY_SIZE][0:ARRAY_SIZE]; // 垂直权重线 wire signed [ACC_WIDTH-1:0] psum_v [0:ARRAY_SIZE][0:ARRAY_SIZE]; // 垂直部分和线 // 初始化边界输入 assign data_h[0][0] = ext_data_in; // 来自外部数据流，需要经过FIFO或缓存对齐 assign weight_v[0][0] = ext_weight_in; // 来自外部权重流 assign psum_v[0][0] = '0; // 第一行PE的顶部部分和输入为0 generate for (i = 0; i < ARRAY_SIZE; i = i + 1) begin: row_gen for (j = 0; j < ARRAY_SIZE; j = j + 1) begin: col_gen processing_element #( .DATA_WIDTH(DATA_WIDTH), .ACC_WIDTH(ACC_WIDTH) ) u_pe ( .clk(clk), .rst_n(rst_n), .en(pe_enable), // 全局PE使能，可由状态机控制 .data_in_left( (j==0) ? data_h[i][0] : data_h[i][j] ), .data_out_right( data_h[i][j+1] ), .weight_in_top( (i==0) ? weight_v[0][j] : weight_v[i][j] ), .weight_out_bottom( weight_v[i+1][j] ), .psum_in_top( (i==0) ? psum_v[0][j] : psum_v[i][j] ), .psum_out_bottom( psum_v[i+1][j] ) ); end end endgenerate // 收集输出：阵列最后一行的psum_out_bottom就是最终的部分和输出 // 需要将它们组织起来，通过一个输出FIFO或寄存器链送出。 reg [ARRAY_SIZE-1:0] out_col_valid; // 每列输出有效标志 always @(posedge clk) begin // 这里需要一个复杂的逻辑，判断何时最后一行的psum是有效结果。 // 这涉及到计算“水线”（watermark），即从第一个数据进入阵列到第一个结果流出阵列的延迟周期数。 // 延迟周期数 = ARRAY_SIZE * 2 - 1 （对于这种数据流模式） end

互联与控制逻辑的难点：

1. 输入数据对齐： 外部数据流是连续的，但阵列需要严格对齐的数据和权重。通常需要在阵列前放置输入FIFO或双缓冲（Double Buffer），由一个状态机控制，在正确的时间点将数据“喂”给阵列的第一行和第一列。这是控制逻辑中最容易出错的部分。
2. 输出收集与有效性判断： 阵列的输出不是每个周期都有效。从开始输入到第一个有效结果输出，有一个固定的流水线延迟。之后，在理想满负荷情况下，每个周期可以输出一个有效结果（对于8x8阵列，可能是8个通道的部分和）。需要设计一个输出缓冲区和对应的data_out_valid生成逻辑，确保只将完整的、正确的计算结果送出。
3. 非方形卷积与填充处理： 我们的阵列是方形的，但卷积核和特征图可能不是。这需要通过外部控制器将计算任务“切片”（Tiling），分解成多个能被阵列处理的子矩阵乘法。模块内部可能还需要支持累加模式，即多次计算的结果在模块内部累加，以完成一个更大矩阵的乘法。

4. 仿真验证与实验数据分析

设计完成之后，验证是重中之重。我使用SystemVerilog搭建了测试平台（TB），并针对几个关键场景进行测试。

4.1 测试平台构建与激励生成

TB的主要任务是：

1. 生成仿真的输入数据和权重： 我写了一个简单的C程序，生成随机整数，或者更有意义的模式（如全1、递增序列），并写入文件。TB通过$readmemh读取这些文件，模拟数据流。
2. 模拟外部控制器行为： TB中的一个task模拟了上层状态机，它按照预设的时序，在data_in_ready和weight_in_ready为高时，将数据压入模块。这测试了握手协议。
3. 自动结果比对： 这是TB的核心。我同样用C语言（或Python）写了一个黄金模型（Golden Model），执行相同的卷积运算（使用浮点或高精度整数）。TB将模块的输出data_out捕获，与黄金模型的输出逐拍比较。任何失配都会立即报错并终止仿真。

// 简化的TB数据比对片段 initial begin int golden_output[$]; // ... 从文件加载黄金模型输出到 golden_output ... fork begin: data_monitor int idx = 0; forever begin @(posedge clk); if (dut.data_out_valid && dut.data_out_ready) begin if (dut.data_out !== golden_output[idx]) begin $error("Mismatch at output %0d: RTL=%h, Golden=%h", idx, dut.data_out, golden_output[idx]); $finish; end idx++; if (idx == golden_output.size()) begin $display("*** All %0d outputs matched! Test PASSED. ***", idx); $finish; end end end end join end

4.2 关键测试场景与结果

我设计了多组测试，逐步增加复杂度：

1. 基础功能测试（3x3卷积，单通道）：

   • 场景： 输入特征图5x5，卷积核3x3，步长1，填充0。权重设为全1，输入为递增序列。
   • 目的： 验证最基本的乘加和流水线逻辑是否正确。
   • 结果： RTL输出与黄金模型完全一致。通过观察波形，可以清晰地看到数据和权重在阵列中脉动传播的过程，第一个结果在预期延迟（2*ARRAY_SIZE-1=15个周期）后出现。

2. 多通道测试（IFMAP_CH=4, OFMAP_CH=8）：

   • 场景： 模拟一个真实的卷积层。输入4通道，输出8通道。这意味着需要计算8个不同的3x3x4卷积核。
   • 实现： 外部控制器需要将4通道输入数据在通道维度上拼接（或依次送入），并将8个卷积核的权重依次加载。阵列每次计算一个输出通道的一个空间位置（但并行计算所有输入通道的累加）。这需要复杂的调度。
   • 结果： 这是对控制逻辑的真正考验。我最初的设计在这里出现了错误：输出数据的顺序和黄金模型对不上。排查后发现，是输出结果收集FIFO的写入顺序和读取顺序与多通道计算流程不匹配。教训：对于复杂的数据流，必须在设计初期就明确每一个时钟周期，每一级流水线中数据的确切含义和索引，并用文档或注释详细记录。

3. 性能与吞吐量分析：

   • 理论峰值算力： 对于8x8 INT8阵列，运行在200MHz时钟下。每个周期完成8*8=64次乘加（MAC）操作。INT8乘加通常可视为一次操作。因此理论峰值算力为64 MAC/cycle * 200e6 cycle/s = 12.8 GMAC/s或25.6 GOPS（一次乘加算两次操作）。
   • 实测有效算力： 在完成一个较大尺寸的卷积后，统计总计算周期和实际完成的MAC操作总数。由于数据加载、填充、切片导致的空闲周期（Bubble），有效算力通常低于峰值。我的测试显示，在优化了数据加载顺序后，有效算力能达到峰值算力的70%以上，这对于一个简化设计来说已经不错。
   • 资源占用（FPGA综合）： 使用Vivado针对Xilinx Zynq-7000系列器件进行综合。一个8x8的阵列（不含外部FIFO和复杂控制器）大约占用：
     • LUT: ~5000
     • FF: ~4000
     • DSP48E1: 64个（每个PE的乘法器映射为一个DSP块）
   • 时序报告： 关键路径出现在PE内部psum_reg的累加路径上（psum_in_top + (data_in_left * weight_reg)）。在200MHz目标下，有约0.5ns的建立时间裕量（Slack）。如果频率要求更高，可能需要将累加器拆分为更多流水线级。

4.3 遇到的典型问题与调试技巧

1. 问题：仿真结果出现不定态（X）。

   • 排查： 首先检查所有寄存器在复位时是否被正确初始化。然后，重点检查数组（如data_h、weight_v）的索引是否可能越界。在generate循环中，i和j的边界[0:ARRAY_SIZE]容易出错，data_h[i][j+1]当j==ARRAY_SIZE-1时会访问data_h[i][ARRAY_SIZE]，这个元素必须被声明。
   • 技巧： 在仿真初期使用$display打印关键信号和索引值。使用波形查看器，将数组展开查看，能快速定位哪个节点出现了X。

2. 问题：数据输出顺序混乱，与预期不符。

   • 排查： 这是数据流控制逻辑的经典问题。我画了一个详细的时空图（Space-Time Diagram），横轴是时间（周期），纵轴是阵列的行或列。手动追踪第一个输入数据D00和第一个权重W00进入阵列后，它们如何移动，在哪个PE相遇，结果何时从底部输出。然后将这个理论波形与仿真波形对比，立刻发现了输出有效信号生成逻辑比实际数据晚了一个周期。
   • 技巧： 对于脉动阵列这种高度规则的结构，画图是最有效的调试方法。不要只依赖看代码。

3. 问题：时序不满足，无法达到目标频率。

   • 排查： 综合后的时序报告显示关键路径过长。使用Vivado的“Schematic”视图或“Timing”视图中的“Fail Path”追踪，发现关键路径是穿过多个PE的组合逻辑链（例如，部分和从第一行PE直接组合逻辑传递到最后一行）。
   • 解决： 这就是为什么我在PE设计中坚持使用寄存器打拍传递数据，而不是组合逻辑直通。对于已经打拍但依然紧张的路径，可以考虑插入更多的流水线寄存器。例如，将PE内部的(data_in_left * weight_reg)乘法结果先寄存一拍，再与psum_in_top相加。这会增加一个周期延迟，但能大幅提高频率。

5. 从模块到系统：集成考量与优化方向

完成一个独立运行的模块只是第一步。要把它用在一个真实的系统中，还需要考虑很多外围因素。

5.1 与存储系统的协同

脉动阵列是计算引擎，它自己不做数据搬运。需要一个强大的DMA（直接内存访问）控制器和多层次缓存（Memory Hierarchy）来为它服务。

• 权重缓存： 权重通常在计算一批数据前加载一次，然后保持不变。因此需要一个片上SRAM作为权重缓存（Weight Buffer），容量要能放下至少一层网络的所有权重。DMA负责从外部DDR将权重搬入此缓存，然后阵列以流式或静态方式从缓存读取。
• 输入/输出双缓冲： 为了隐藏数据传输时间，通常采用乒乓缓冲（Ping-Pong Buffer）。当阵列在处理Buffer A的数据时，DMA正在向Buffer B填充下一批数据。计算完成后再交换角色。这确保了计算单元几乎不会因等待数据而空闲。
• 我的模块适配： 我的模块接口是流式的，因此需要在外围封装一个数据打包/解包单元。这个单元负责从输入双缓冲中读取数据，按照阵列需要的顺序和节奏，组装成data_in流。同时，它也从阵列的输出流接收数据，解包后写入输出双缓冲。

5.2 支持更复杂的网络层

我们的模块目前专注于标准卷积。但现代CNN还有：

• 深度可分离卷积（Depthwise Separable Conv）： 这可以分解为逐通道卷积（Depthwise）和逐点卷积（Pointwise）。逐通道卷积是每个输入通道单独卷积，计算密度低，不适合用大阵列。一种优化思路是将阵列拆分成多个小单元并行处理不同通道。逐点卷积是1x1卷积，本质是密集矩阵乘，非常适合我们的阵列。
• 池化层（Pooling）： 通常在卷积后接一个池化层。一种高效的设计是将池化单元（如最大值比较、加法树）直接放在阵列的输出端，作为后处理模块，减少中间数据的写回和读取。
• 激活函数： 如ReLU，可以在输出数据流出阵列时，用一个简单的比较和选择逻辑实时完成，几乎不增加延迟。

5.3 面积、功耗与性能的权衡探索

• 精度可配置： 可以将DATA_WIDTH做成运行时可配置（虽然会增大面积），以支持混合精度训练或推理。例如，某些层用INT8，某些层用INT4。
• 稀疏性支持： 神经网络权重和激活值存在大量零。可以设计一种跳过零计算的机制，在数据进入阵列前进行压缩，或者让PE检测到零输入时关闭乘加操作，以节省功耗。
• 近似计算： 在PE的乘法器中，可以使用近似乘法器（如截断乘法器）来进一步降低面积和功耗，这对某些对精度不敏感的边缘应用很有吸引力。

这个Verilog实现的脉动阵列卷积模块，是一个理解硬件加速器核心思想的绝佳起点。它从最基础的PE单元开始，构建起规则的数据流，最终完成复杂的卷积运算。整个过程中，对时序的把握、对数据流的精确控制、对仿真验证的重视，是硬件设计成败的关键。我把项目源码、详细的文档说明以及仿真实验数据都整理了出来，其中包含了多个不同配置的测试用例和波形文件。通过这个项目，我深刻体会到，硬件设计不仅仅是写RTL代码，更是对计算、存储、通信之间平衡艺术的不断探索。下次，或许我们可以聊聊如何为这个阵列设计一个智能的调度器，让它能更高效地处理各种形状的卷积层。

本文还有配套的精品资源，点击获取