基于Zynq的数据采集系统设计与调试(三) —— FIFO的使用

╰+哭是因爲堅強的太久メ 2022-06-14 05:26 834阅读 0赞

前言：

FIFO是数据采集系统中必不可少的环节，AD采回来的数据要送至ARM/DSP处理，或将采回来的数据写到本地，都需要解决读写速度匹配问题，解决这类问题，首选FIFO。

在我们的设计当中，使用的是ADI公司的AD7989，18bit，100KSPS，采用三线SPI数据传输模式。采用两级FIFO，第一级FIFO用于缓存AD采样点数据，第二级FIFO用于DMA数据传输。

一. FIFO的使用

在本设计中，将数据这样打包：一个package包含1024个字(4096Byte)其中1020个AD采样数据点(AD采样数据扩展成32bit)，4个字的数据包信息：通道号(有两个通道)、块号(package编号)、触发信号位置、CRC校验码。

第一级FIFO(FIFO1)缓存AD采样点，时钟与AD时钟相同，都是50MHz，第二级FIFO(FIFO2)从第一级FIFO取数据，当取到1020个数据时，就往FIFO2中写4个字的数据包信息，第二级FIFO用于DMA将数据流送至内存DDR3的数据缓存。FIFO2采用异步时钟，因为触发信号(Trig)是一个脉冲，触发信号模块使用的时钟也是50MHz，因此写时钟仍然是50MHz，读时钟采用DMA时钟(200MHz)。FIFO都是Xilinx Vivado下自带的IP core。

FIFO1的写使能信号是ad模块的ad\_data\_rdy，当FIFO1中有数据时，读使能信号就有效(rd\_en = !fifo\_empty); FIFO2的写使能信号在FIFO1数出数据有效后一个时钟有效, 读使能是FIFO2的prog\_empty来控制的。关于prog\_empty信号，一开始的时候对Empty Threshold Assert Value和Empty Threshold Negate Value理解有误，后来查看了Xilinx FIFO ipCore手册pg057-fifo-generator.pdf的pg105-106得知:

Forbuilt-in FIFOs, the number of entries in the FIFO must be greater than thethreshold value + 1 before prog\_empty is deasserted. For non built-inFIFOs(block RAM, distributed RAM, and so forth), if the number of entries inthe FIFO is greater than threshold value, prog\_empty is deasserted. 本设计使用的是Block RAM，对于Block RAM FIFO而言，当FIFO中的数据个数大于Negate Value时，prog\_empty=0，当FIFO中数据个数小于等于Assert Value时，prog\_empty=1。本设计中，FIFO\_RD\_EN = prog\_empty，下图是第二级FIFO读写数据时序图，wr\_fifo2\_count表示写入到FIFO中数据个数，read\_pointer表示从FIFO中读出的数据个数，FIFO\_ALMOST\_EMPTY即prog\_empty信号。

![Center][]

左边红线可看出，本设计中设置的Empty Threshold Negate Value=16，当FIFO中有17(>= Negate Value)个数据时，prog\_empty=0。本设计中设置的Empty Threshold Assert Value=2，所以当FIFO中数据个数小于等于2时，prog\_empty要变为1。对应到右边红线，在这个时钟边沿，FIFO中正好还有2个数据，因此prog\_empty由0变为1，而FIFO\_RD\_EN = !prog\_empty，此时仍有效，因此会继续从FIFO中读出一个数据。

二. FIFO的配置

1. FIFO1的配置如下：

1) 选型: Common Clock Block RAM

![Center 1][]

2) 设置数据深度：因ad7989采样率为100KSPS，每隔10us转换得到1个数据，DAM时钟是200M，相对而言AD速度较慢，因此深度设为64就满足设计要求，但考虑到资源使用情况都是1个18K BRAM，所以设置为128

![Center 2][]

3) 其他为默认设置

2. FIFO2的配置如下:

1) 选型: Independent Clock Block RAM

![Center 3][]

2) 数据深度设置: 此处设为1个package的数据深度(可能优化的时候会更改，但1024足够满足本设计要求的)

![Center 4][]

3) 设置prog\_empty(很关键)：Empty Threshold Assert Value=2，Empty Threshold Negate Value=16

为什么要用prog\_empty信号来作为FIFO2的读使能控制信号(rd\_en = !prog\_empty)呢? 因为DMA的MAX Burst Length = 16，关于DMA的Burst传输我是这样理解的，(如果有误，还请指点哈！) 对于Write Channel(write channel --- Receive packet --- S2MM)，dma端先送TREADY信号， 等待M\_AXIS\_S2MM主机的TVALID和TDATA，每接收一个数据内部计数器加一，当计数器达到16时，TREADY拉低，dma申请一次总线，然后把接收到的数据写入到DDR3(或者内存)中，即每接收burst length个数据，申请一次总线，这样就不会太占用系统资源。使用prog\_empty作为FIFO读使能控制，可保证连续读出Burst Length个数据，这样就不会每次占用总线太长时间。

![Center 5][]

4) 其他采用默认设置

三. ad7989\_fifo模块的实现

**\[plain\]**  [view plain][]   [copy][view plain]

1.  \`timescale 1ns / 1ps  
2.  //  
3.  // Company:   
4.  // Engineer:   
5.  //   
6.  // Create Date: 2016/06/20 11:03:04  
7.  // Design Name:   
8.  // Module Name: ad7989\_fifo  
9.  // Project Name:   
10. // Target Devices:   
11. // Tool Versions:   
12. // Description:   
13. //   
14. // Dependencies:   
15. //   
16. // Revision:  
17. // Revision 0.01 - File Created  
18. // Additional Comments:  
19. //   
20. //  
21.   
22.   
23. module ad7989\_fifo(  
24.                      input    ad\_clk,rst\_n,ad\_start,//ad\_start: ad\_start是由PS部分发送过来的ad采样控制信号   
25.                     // input    trig\_in,//trig\_in由DA部分(DDS)传过来脉冲信号，启动ad转换  
26.                      // AD SPI port  
27.                      input    ad\_sdo, //ad转换串型数据  
28.                      output   ad\_cnv,  
29.                      output   ad\_sclk,       
30.                      // FIFO2 port  
31.                      input    rd\_clk,    
32.                      input    rd\_en,  
33.                      output   empty,  
34.                      output   full,  
35.                      output   almost\_empty, //Empty Threshold Assert Valie = 16，Empty Threshold Negate Valie = 17，  
36.                      output   \[31:0\] fifo\_dout               
37.                    );  
38.     // intern signal                 
39.     wire    ad\_data\_rdy;  
40.     wire    \[17:0\] ad\_data;  
41.     wire    \[31:0\] sample\_data;  
42.     wire    \[31:0\] fifo1\_dout;  
43.     wire    \[31:0\] fifo2\_din;  
44.     wire    fifo1\_empty;  
45.     wire    wr\_fifo1\_en;  
46.     wire    rd\_fifo1\_en;  
47.     wire    wr\_fifo2\_en;  
48.     wire    trigger;  
49.     wire    trig\_in;  
50.       
51.     // reg variable  
52.     reg    \[31:0\] block\_num = 0; //块序列号  
53.     reg    \[31:0\] trig\_position = 32'd0; //触发信号来时对应的AD数据位置信息  
54.     reg    \[31:0\] channel\_num = 32'd1; //通道号: 1表示1倍频通道采集的数据，2表示2倍频采集的数据  
55.     reg    \[31:0\] crc\_code = 32'd0;  //crc校验码  
56.     // trig\_in detect  
57.     reg    trig\_reg1 = 0;  
58.     reg    trig\_reg2 = 0;  
59.     // FIFO\_1  
60.     reg    \[9:0\] wr\_fifo1\_count = 0; //Sample data 计数器 4096Byte数据(1020次)一次循环  
61. //    reg    rd\_fifo1\_en\_tmp;  
62.     // FIFO\_2  
63.     reg    wr\_fifo2\_en\_tmp1;  
64.     reg    wr\_fifo2\_en\_tmp2;  
65.     reg    \[10:0\]  wr\_fifo2\_count = 0;  
66.     reg    \[31:0\]  fifo2\_din\_reg;    
67.           
68.              
69.     assign    sample\_data = (\{ \{15\{ad\_data\[17\]\}\},ad\_data\[16:0\]\});  //  
70.   
71. //    always @(posedge ad\_clk) begin  
72. //      rd\_fifo1\_en\_tmp <= wr\_fifo1\_en;  
73. //    end  
74. //    assign   rd\_fifo1\_en = rd\_fifo1\_en\_tmp;  
75.   
76.     assign    wr\_fifo1\_en = ad\_data\_rdy;   
77.     assign    rd\_fifo1\_en = !fifo1\_empty;  
78.       
79.       
80.     //=========== fifo1\_data count ===========  
81.     always @(posedge ad\_clk) begin  
82.       if(wr\_fifo1\_count == 11'd1020) wr\_fifo1\_count <= 11'd0; //一个packet包含1020个ADC数据  
83.       else if(wr\_fifo1\_en) wr\_fifo1\_count <= wr\_fifo1\_count + 1'b1;         
84.       else wr\_fifo1\_count <= wr\_fifo1\_count;  
85.     end  
86.       
87.     //========== trig\_position ==========  
88.     always @(posedge ad\_clk) begin  
89.       trig\_reg1 <= trig\_in;  
90.       trig\_reg2 <= trig\_reg1;  
91.     end  
92.     assign trigger = trig\_reg1 & (!trig\_reg2);  
93.       
94.     always @(posedge ad\_clk) begin // trig\_in是边沿信号  
95.       if(trigger == 1) trig\_position <= wr\_fifo1\_count + 1; //trig\_position   
96.       else if(wr\_fifo2\_count == 11'd1024) trig\_position <= 0; //wr\_fifo2\_count = 1022时,将trig\_position写入fifo中  
97.       else trig\_position <= trig\_position;  
98.     end  
99.       
100.     // ========== block\_num ==========  
101.     always @(posedge ad\_clk) begin  
102.       if(wr\_fifo2\_count == 11'd1024 && wr\_fifo2\_en == 1) block\_num <= block\_num + 1'b1;  
103.       else block\_num <= block\_num;  
104.     end  
105.       
106.     // ========== crc\_code ==========  
107.     always @(posedge ad\_clk) begin  
108.       if(!rst\_n) crc\_code <= 0;  
109.       else if(wr\_fifo2\_count < 11'd1020 && wr\_fifo2\_en == 1) crc\_code <= crc\_code ^ fifo2\_din\_reg;  
110.       else case(wr\_fifo2\_count)  
111.         11'd1020: crc\_code <= crc\_code ^ block\_num;  
112.         11'd1021: crc\_code <= crc\_code ^ trig\_position;  
113.         11'd1022: crc\_code <= crc\_code ^ channel\_num;  
114.         11'd1023: crc\_code <= crc\_code;  
115.         11'd1024: crc\_code <= 0;  
116.       endcase        
117.     end   
118.       
119.     // ========== wr\_fifo2\_en ==========  
120.     always @(posedge ad\_clk) begin  
121.       wr\_fifo2\_en\_tmp1 <= rd\_fifo1\_en;  
122.       wr\_fifo2\_en\_tmp2 <= wr\_fifo2\_en\_tmp1;  
123.     end  
124.      
125.     assign    wr\_fifo2\_en = (wr\_fifo2\_count <= 11'd1020) ? wr\_fifo2\_en\_tmp2 : 1'b1; //连续写4个字的控制信息: 块序列号、crc校验码、触发信号来时对应的AD数据位置信息、通道号  
126.   
127.     // ========== fifo2 data count ==========    
128.     always @(posedge ad\_clk) begin  
129.       if(wr\_fifo2\_count == 11'd1024) wr\_fifo2\_count <= 0;  
130.       else if(wr\_fifo2\_en == 1) wr\_fifo2\_count <= wr\_fifo2\_count + 1'b1;  
131.       else if(wr\_fifo2\_count>= 11'd1020) wr\_fifo2\_count <= wr\_fifo2\_count + 1'b1;  
132.       else wr\_fifo2\_count <= wr\_fifo2\_count;  
133.     end  
134.       
135.     // ========== fifo2\_din ==========  
136.     assign  fifo2\_din = fifo2\_din\_reg;  
137.       
138.     always @(posedge ad\_clk) begin  
139.         case(wr\_fifo2\_count)   
140.           11'd1020: fifo2\_din\_reg <= block\_num;  
141.           11'd1021: fifo2\_din\_reg <= trig\_position;  
142.           11'd1022: fifo2\_din\_reg <= channel\_num;  
143.           11'd1023: fifo2\_din\_reg <= crc\_code;  
144.           default: fifo2\_din\_reg <= fifo1\_dout;  
145.         endcase  
146.     end  
147.   
148.                   
149.     ad7989\_dev\_if   U\_ad(  
150.                           .ad\_clk(ad\_clk),  
151.                           .rst\_n(rst\_n),  
152.                           .ad\_start(ad\_start),//ad\_start: ad\_start是由PS部分发送过来的ad采样控制信号   
153.                           .ad\_sdo(ad\_sdo),                      //ad转换串型数据  
154.                           .ad\_cnv(ad\_cnv),  
155.                           .ad\_sclk(ad\_sclk),                         
156.                           .ad\_data(ad\_data),  
157.                           .ad\_data\_rdy(ad\_data\_rdy)   // data is available  
158.                          );     
159.     trig\_generator    U\_trig(  
160.                               .ad\_clk(ad\_clk),  
161.                               .rst\_n(rst\_n),  
162.                               .ad\_data\_rdy(ad\_data\_rdy),  
163.                               .trig\_signal(trig\_in)  
164.                             );  
165.                            
166.     fifo\_sample\_data    U\_ad\_samle\_fifo (  
167.                                            .clk(ad\_clk),      // input wire clk  
168.                                            .srst(!rst\_n),    // input wire srst  
169.                                            .din(sample\_data),      // input wire \[31 : 0\] din  
170.                                            .wr\_en(wr\_fifo1\_en),  // input wire wr\_en  
171.                                            .rd\_en(rd\_fifo1\_en),  // input wire rd\_en  
172.                                            .dout(fifo1\_dout),    // output wire \[31 : 0\] dout  
173.                                            .full(),    // output wire full  
174.                                            .empty(fifo1\_empty)  // output wire empty  
175.                                          );      
176.                                            
177.     fifo\_dma\_stream\_0    U\_dma\_fifo (  
178.                                        .rst(!rst\_n),        // input wire rst  
179.                                        .wr\_clk(ad\_clk),  // input wire wr\_clk  
180.                                        .rd\_clk(rd\_clk),  // input wire rd\_clk  
181.                                        .din(fifo2\_din),        // input wire \[31 : 0\] din  
182.                                        .wr\_en(wr\_fifo2\_en),    // input wire wr\_en  
183.                                        .rd\_en(rd\_en),    // input wire rd\_en  
184.                                        .dout(fifo\_dout),      // output wire \[31 : 0\] dout  
185.                                        .full(full),      // output wire full  
186.                                        .empty(empty),    // output wire empty  
187.                                        .prog\_empty(almost\_empty)   
188.                                      );  
189.          
190. endmodule

[Center]: /images/20220614/b0d373673fda44edb2603f102c24fa5a.png
[Center 1]: /images/20220614/e2e9092439894433928d1d5bb8c990c6.png
[Center 2]: /images/20220614/c69b61c2f696469689edd843aa2a6a20.png
[Center 3]: /images/20220614/f0499970b67249dd8c115c3e5a17111e.png
[Center 4]: /images/20220614/eb3c58d009ac412f8cb8eacec77fc851.png
[Center 5]: /images/20220614/bc938e47523f4730986ddaf7ae036d00.png
[view plain]: http://blog.csdn.net/yang2011079080010/article/details/51921581#