FPGA设计心得（6）Aurora IP核例子简析与仿真（framing版）
背景
熬夜继续写Aurora系列博文！今天明显状态不如昨天，眼皮有点涩涩的，坚持一下。
如果不是写博客，我根本没有动力那么认真看，认真思考这个东西，这可能就是写博客输出的魅力吧。
尽管streaming格式很简单，但是肯定不如framing强大，很多项目还是用framing用户接口，因此有必要对此进行仿真分析来认识下。
博客首页
完成时间：第二天晚凌晨4点左右。
定制framing接口的IP核
很简单，灵活配置如下参数即可：
本例选择小端模式。
FLow Control 暂时选择为None。（有必要后面专门研究，暂时最主要的还是弄懂用户接口信号的用法！）
为分析方面，选择单通道传输数据。
生成示例工程并分析
如图，右击IP核，打开例子程序，保存到一个位置，即可自动打开例子工程。
对于我们用户来说，最重要还是我们的用户程序，通过用户程序模块与Aurora IP核交互，生成数据发出以及接收IP核传输的数据。
文末同样会分享示例工程，所以这里就不把源码贴出来，占用篇幅，给阅读带来不便。
GEN模块分析
先打开gen模块，对于该模块，有一段描述：
// Description: This module is a pattern generator to test the Aurora
// designs in hardware. It generates data and passes it
// through the Aurora channel. If connected to a framing
// interface, it generates frames of varying size and
// separation. LFSR is used to generate the pseudo-random
// data and lower bits of LFSR are connected to REM bus.
- 1
- 2
- 3
- 4
- 5
- 6
翻译过来：
该模块是一个模式生成器，用于在硬件中测试Aurora设计。 它生成数据并将其通过Aurora通道。 如果连接到成帧接口，它将生成大小和间隔不同的帧。 LFSR用于生成伪随机数据，并且LFSR的低位连接到REM总线。
首先，读了这段描述，一般肯定不知道具体干啥的，但是大概知道是生成一系列数据，并发送出去，而且用的是framing数据格式。
让我们看看具体内容：
看程序首先看输入输出：
// User Interface
output [0:15] TX_D;
output TX_REM;
output TX_SOF_N;
output TX_EOF_N;
output TX_SRC_RDY_N;
input TX_DST_RDY_N; // System Interface
input USER_CLK;
input RESET;
input CHANNEL_UP;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
从这几个信号用户接口，可见，有一些我们熟悉的接口，但是和axi接口的名字起的不一样罢了；
让我们对应下：
从如下接口方向可以断定：
s_axi_tx_tready为
input TX_DST_RDY_N;
- 1
二者之间的关系：
作为gen模块用户逻辑的条件，无论是tready还是RDY_N，有效即可。
tready为RDY_N的反，从以N结尾也该明白了。
也不卖关子了，其他的等价：
// User Interface
output [0:15] TX_D; //data
output TX_REM; //?
output TX_SOF_N; // start of frame
output TX_EOF_N; // end of frame
output TX_SRC_RDY_N; // valid
input TX_DST_RDY_N; //tready
- 1
- 2
- 3
- 4
- 5
- 6
- 7
当Aurora通道还未准备好时，需要设计复位，让通道出于复位状态：
always @ (posedge USER_CLK)
begin if(RESET) channel_up_cnt <= `DLY 5'd0; else if(CHANNEL_UP) if(&channel_up_cnt) channel_up_cnt <= `DLY channel_up_cnt; else channel_up_cnt <= `DLY channel_up_cnt + 1'b1; else channel_up_cnt <= `DLY 5'd0;
end assign dly_data_xfer = (&channel_up_cnt); //Generate RESET signal when Aurora channel is not ready
assign reset_c = RESET || !dly_data_xfer;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
从上面的计数条件，可见CHANNEL_UP为通道准备好的标志，当其有效时，channel_up_cnt则从0一直计数到5’b1111_1并保持；否则，channel_up_cnt为0；
这样的话，当CHANNEL_UP无效时，dly_data_xfer为0，那么reset_c为1，即处于复位状态。
当CHANNEL_UP为1，也即有效时，也会计数一段时间，确保稳定，之后dly_data_xfer为1，那么reset_c的值取决于RESET，RESET无效时，停止复位。这样确保了，RESET早就停止了复位，而通道还未准备好，等通道准备好了之后，才停止复位，发送逻辑开始有效执行。
下面继续分析数据传输的部分：
//______________________________ Transmit Data __________________________________ //Generate random data using XNOR feedback LFSR always @(posedge USER_CLK) if(reset_c) begin data_lfsr_r <= `DLY 16'hABCD; //random seed value end else if(!TX_DST_RDY_N && !idle_r) begin data_lfsr_r <= `DLY {!{data_lfsr_r[3]^data_lfsr_r[12]^data_lfsr_r[14]^data_lfsr_r[15]}, data_lfsr_r[0:14]}; end //Connect TX_D to the DATA LFSR assign TX_D = {1{data_lfsr_r}};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
可见，要发送的数据是一个有规则产生的随机数据，data_lfsr_r的初始值作为随机数的种子，之后通过异或非的方式产生随机数。
这种产生随机数的方式属于线性反馈移位寄存器
上面出现了一个陌生的变量idle_r：
//State registers for one-hot state machine
reg idle_r;
reg single_cycle_frame_r;
reg sof_r;
reg data_cycle_r;
reg eof_r; wire reset_c;
//*********************************Wire Declarations********************************** wire ifg_done_c; //Next state signals for one-hot state machine
wire next_idle_c;
wire next_single_cycle_frame_c;
wire next_sof_c;
wire next_data_cycle_c;
wire next_eof_c;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
它是状态机变量，众多为了描述状态机而设的变量之一。下面便是状态机部分，可以看出，是一个三段式状态机，很讲究！
使用状态机的目的在于确定 frame的起始，结束以及要发送数据还是什么也不发送等。
//_____________________________ Framing State machine______________________________ //Use a state machine to determine whether to start a frame, end a frame, send //data or send nothing //State registers for 1-hot state machine always @(posedge USER_CLK) if(reset_c) begin idle_r <= `DLY 1'b1; single_cycle_frame_r <= `DLY 1'b0; sof_r <= `DLY 1'b0; data_cycle_r <= `DLY 1'b0; eof_r <= `DLY 1'b0; end else if(!TX_DST_RDY_N) begin idle_r <= `DLY next_idle_c; single_cycle_frame_r <= `DLY next_single_cycle_frame_c; sof_r <= `DLY next_sof_c; data_cycle_r <= `DLY next_data_cycle_c; eof_r <= `DLY next_eof_c; end //Nextstate logic for 1-hot state machine assign next_idle_c = !ifg_done_c && (single_cycle_frame_r || eof_r || idle_r); assign next_single_cycle_frame_c = (ifg_done_c && (frame_size_r == 0)) && (idle_r || single_cycle_frame_r || eof_r); assign next_sof_c = (ifg_done_c && (frame_size_r != 0)) && (idle_r || single_cycle_frame_r || eof_r); assign next_data_cycle_c = (frame_size_r != bytes_sent_r) && (sof_r || data_cycle_r); assign next_eof_c = (frame_size_r == bytes_sent_r) && (sof_r || data_cycle_r); //Output logic for 1-hot state machine always @(posedge USER_CLK) if(reset_c) begin TX_SOF_N <= `DLY 1'b1; TX_EOF_N <= `DLY 1'b1; TX_SRC_RDY_N <= `DLY 1'b1; end else if(!TX_DST_RDY_N) begin TX_SOF_N <= `DLY !(sof_r || single_cycle_frame_r); TX_EOF_N <= `DLY !(eof_r || single_cycle_frame_r); TX_SRC_RDY_N <= `DLY idle_r; end
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
程序设计的是一个所谓的独热码状态机，且不是一般的独热码设计方法，类似于：
hdlbits，独热码状态机设计，非常重要
这个状态机有5个状态，每循环一次，就可以发送一帧数据。
五个状态如下：
reg idle_r; // 空闲状态
reg single_cycle_frame_r; //单字帧，也就是一帧数据只有一个字或者少于一个字长
reg sof_r; //帧起始
reg data_cycle_r; //有效赋值数据
reg eof_r; //帧结束
- 1
- 2
- 3
- 4
- 5
由于是独热码，故都是一位变量；
次态变量：
//Next state signals for one-hot state machine
wire next_idle_c;
wire next_single_cycle_frame_c;
wire next_sof_c;
wire next_data_cycle_c;
wire next_eof_c;
- 1
- 2
- 3
- 4
- 5
- 6
对应的次态部分代码：
//Nextstate logic for 1-hot state machine assign next_idle_c = !ifg_done_c && (single_cycle_frame_r || eof_r || idle_r); assign next_single_cycle_frame_c = (ifg_done_c && (frame_size_r == 0)) && (idle_r || single_cycle_frame_r || eof_r); assign next_sof_c = (ifg_done_c && (frame_size_r != 0)) && (idle_r || single_cycle_frame_r || eof_r); assign next_data_cycle_c = (frame_size_r != bytes_sent_r) && (sof_r || data_cycle_r); assign next_eof_c = (frame_size_r == bytes_sent_r) && (sof_r || data_cycle_r);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
可见，出现了很多条件来组成独热码：
如：
ifg_done_c
frame_size_r
bytes_sent_r
- 1
- 2
- 3
要搞清楚这些输入的含义，才能更好理解，根据次态生成部分以及输出生成部分，还可以画出状态转移图或者状态转移表，这是后面的工作（看心情）。
都在这里 ：
//Use a counter to determine the size of the next frame to send always @(posedge USER_CLK) if(reset_c) frame_size_r <= `DLY 8'h00; else if(single_cycle_frame_r || eof_r) frame_size_r <= `DLY frame_size_r + 1; //Use a second counter to determine how many bytes of the frame have already been sent always @(posedge USER_CLK) if(reset_c) bytes_sent_r <= `DLY 8'h00; else if(sof_r) bytes_sent_r <= `DLY 8'h01; else if(!TX_DST_RDY_N && !idle_r) bytes_sent_r <= `DLY bytes_sent_r + 1; //Use a freerunning counter to determine the IFG always @(posedge USER_CLK) if(reset_c) ifg_size_r <= `DLY 4'h0; else ifg_size_r <= `DLY ifg_size_r + 1; //IFG is done when ifg_size register is 0 assign ifg_done_c = (ifg_size_r == 4'h0);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
frame_size_r是一个计数器变量，使用计数器确定要发送的一帧数据的大小；
同理，bytes_sent_r 使用第二个计数器来确定已经发送了多少个帧字节；
最难理解的属于ifg了？
这是什么玩意？
通过查阅资料恍然大悟：IFG是Interframe Gap的缩写，意思是帧与帧之间的间距。
为什么要有这个东西呢？
简单地说，就是为了防止帧间距过小，而导致丢帧等，也就是说发送完一帧数据后，给下一帧数据的发送预留缓冲时间。
从程序中也能看出来：
第一部分：
//Use a freerunning counter to determine the IFG always @(posedge USER_CLK) if(reset_c) ifg_size_r <= `DLY 4'h0; else ifg_size_r <= `DLY ifg_size_r + 1; //IFG is done when ifg_size register is 0 assign ifg_done_c = (ifg_size_r == 4'h0);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
第二部分：
//Nextstate logic for 1-hot state machine assign next_idle_c = !ifg_done_c && (single_cycle_frame_r || eof_r || idle_r); assign next_single_cycle_frame_c = (ifg_done_c && (frame_size_r == 0)) && (idle_r || single_cycle_frame_r || eof_r); assign next_sof_c = (ifg_done_c && (frame_size_r != 0)) && (idle_r || single_cycle_frame_r || eof_r);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
ifg_size_r为计数变量，一直计数，计数满了之后溢出，自身 变为零，继续计数，一直如此。
当ifg_size_r不为零的时候，状态机出于idle状态，也就是空闲状态，等溢出之后的下一个周期，就可以进入下一个状态了，发送数据。
说了这么多，其实状态机 描述的就是一个帧数据的发送过程：
idle_r状态不发送数据；
single_cycle_frame_r这个状态什么时候会进入呢？就是要发送的数据就一个字或者更少，就进入这个状态，因为framing协议要求，其实标志sof和结束标志eof都要有效（此时）；
sof_r：如果要发送的数据多于一个字，那么安装情况就要分为几个周期完成数据发送；那么此时就会进入发送首字的状态；
data_cycle_r：这个状态，继续发送中间字；
eof_r：这就是要发送最后一个字了。
好了，我们的发送过程就讲完了。
CHECK模块分析
如果你知道了发送的过程，那收还不容易吗？
通信双方要按规矩办事，这个规矩就是协议！
首先看下输入输出定义，这也是看程序的第一步：
// User Interface
input [0:15] RX_D;
input RX_REM;
input RX_SOF_N;
input RX_EOF_N;
input RX_SRC_RDY_N; // System Interface
input USER_CLK;
input RESET;
input CHANNEL_UP;
output [0:7] ERR_COUNT;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
通过发送的过程，这里我们也心照不宣地领会到，CHANNEL_UP和复位有关；
RX_D是要收的数据；
RX_SOF_N是首字；
RX_EOF_N是末字；
RX_SRC_RDY_N为有效信号，即Valid，它有效的时候我们才能采样到有效的数据。
如果SOF以及EOF同时有效，那么我们知道这个帧就一个字，或者更少。
继续看：
// SLACK registers
always @ (posedge USER_CLK)
begin
RX_D_SLACK <= `DLY RX_D;
RX_SRC_RDY_N_SLACK <= `DLY RX_SRC_RDY_N;
RX_REM_1SLACK <= `DLY RX_REM;
RX_REM_2SLACK <= `DLY RX_REM;
RX_SOF_N_SLACK <= `DLY RX_SOF_N;
RX_EOF_N_SLACK <= `DLY RX_EOF_N;
end
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
程序对输入的变量都寄存了一拍，为什么呢？很简单，还不是为了改善时序，这样让布局布线更加容易。
接着给出了一些标志信号：
assign data_in_frame_c = data_in_frame_r || (!RX_SRC_RDY_N_SLACK && !RX_SOF_N_SLACK);
- 1
其中有：
//Start a multicycle frame when a frame starts without ending on the same cycle. End //the frame when an EOF is detected always @(posedge USER_CLK) if(reset_c) data_in_frame_r <= `DLY 1'b0; else if(CHANNEL_UP) begin if(!data_in_frame_r && !RX_SOF_N_SLACK && !RX_SRC_RDY_N_SLACK && RX_EOF_N_SLACK) data_in_frame_r <= `DLY 1'b1; else if(data_in_frame_r && !RX_SRC_RDY_N_SLACK && !RX_EOF_N_SLACK) data_in_frame_r <= `DLY 1'b0; end
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
先解释下data_in_frame_r：
有条件：!data_in_frame_r && !RX_SOF_N_SLACK && !RX_SRC_RDY_N_SLACK && RX_EOF_N_SLACK
可知，在帧开始后，为1；
又：data_in_frame_r && !RX_SRC_RDY_N_SLACK && !RX_EOF_N_SLACK
表示，在帧结束后，又变为0；
这点，在后面的行为仿真中，我们可以拉出来看看。
由这段分析可以知道data_in_frame_r在帧内（不包括sof有效的第一个周期）为1；
那么：
data_in_frame_c呢？
assign data_in_frame_c = data_in_frame_r || (!RX_SRC_RDY_N_SLACK && !RX_SOF_N_SLACK);
表示如果数据是单周期帧或已启动多周期帧，则数据在该帧中。
它把帧的第一个周期也纳进去了。
怎么理解呢？
它等于data_in_frame_r与
!RX_SRC_RDY_N_SLACK && !RX_SOF_N_SLACK的或，也就是二者有其一就为1；
在帧的第一个周期内，!RX_SRC_RDY_N_SLACK && !RX_SOF_N_SLACK有效；在后面的周期内，二者均有效。
这二者都有效了，肯定数据就在帧内了。那么这个信号data_in_frame_c就有效；
assign data_valid_c = data_in_frame_c && !RX_SRC_RDY_N_SLACK;
- 1
这个就是把data_in_frame_c与！RX_SRC_RDY_N_SLACK进行一个与操作。
作用于data_in_frame_c无异。
无论是单字帧（单周期帧）还是多周期帧，这个data_valid_c有效，数据一定是帧内有效数据。
//Register and decode the RX_D data with RX_REM bus always @ (posedge USER_CLK) begin if((!RX_EOF_N_SLACK) && (!RX_SRC_RDY_N_SLACK)) begin case(RX_REM_1SLACK) 1'd0 : RX_D_R <= `DLY {RX_D_SLACK[0:7], 8'b0}; 1'd1 : RX_D_R <= `DLY RX_D_SLACK; default : RX_D_R <= `DLY RX_D_SLACK; endcase end else if(!RX_SRC_RDY_N_SLACK) RX_D_R <= `DLY RX_D_SLACK; end
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
这段代码，包括后面的几乎都不用说了，就是把数据接收过来处理，换做你的工程，肯定按照自己的方式处理接收的数据。
那CHECK的分析到此结束吧。
示例工程仿真
仿真文件也就是例化两次例子程序，之后将二者的收发相接，形成一个环路。
总体仿真
这里直接仿真看我们想看的结果。
首先还是从宏观上看：
可以看出，1发2收，2发1收；
不过串行数据只能看到一个大概情况，更多 的细节，继续拉出来看：
可见，发的第一个数据和收的第一个数据一致！
后面的数据也是一致的。
发送模块仿真
从这里开始，我将关注gen模块的帧组成情况：
第一帧数据只有一个字，因此在发送的时候sof以及eof同时有效；
第二帧：
第二帧数据有两个字：如上图，因此，第一个字sof有效，第二字eof有效。
我还想看看第一帧数据和第二帧数据之间的间隔是不是ifg_size_r 进行了计数：
确实在计数！
和代码对应起来：
//Use a freerunning counter to determine the IFG always @(posedge USER_CLK) if(reset_c) ifg_size_r <= `DLY 4'h0; else ifg_size_r <= `DLY ifg_size_r + 1; //IFG is done when ifg_size register is 0 assign ifg_done_c = (ifg_size_r == 4'h0);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
计数是一直进行的过程。
assign next_idle_c = !ifg_done_c && (single_cycle_frame_r || eof_r || idle_r);
- 1
- 2
计数值不为0的时候，一直处于空闲状态。
assign next_single_cycle_frame_c = (ifg_done_c && (frame_size_r == 0)) && (idle_r || single_cycle_frame_r || eof_r); assign next_sof_c = (ifg_done_c && (frame_size_r != 0)) && (idle_r || single_cycle_frame_r || eof_r);
- 1
- 2
- 3
- 4
- 5
计数值为0的时候，如果是单周期帧，则进入单周期帧状态，发送单周期数据。
对于第一帧数据就是如此，直接进入单周期帧状态发送数据。将当前状态变量拉出来看看：
可见，一开始处于idle状态，之后进入单周期帧状态，在下一个周期便发送数据了。
assign next_single_cycle_frame_c = (ifg_done_c && (frame_size_r == 0)) && (idle_r || single_cycle_frame_r || eof_r);
- 1
- 2
由于进入单周期帧，需要另一个计数，就是帧长计数frame_size_r == 0；
这个计数量的条件是：
//Use a counter to determine the size of the next frame to send always @(posedge USER_CLK) if(reset_c) frame_size_r <= `DLY 8'h00; else if(single_cycle_frame_r || eof_r) frame_size_r <= `DLY frame_size_r + 1;
- 1
- 2
- 3
- 4
- 5
- 6
可见，确实应该进入了单周期帧状态：
在分析下，下一帧不是单周期帧的情况：
在sof之后直接进入eof也很显而易见：
assign next_eof_c = (frame_size_r == bytes_sent_r) && (sof_r || data_cycle_r);
- 1
- 2
满足了frame_size = bytes_size的条件。
这两个计数器有什么关系呢？
//Use a counter to determine the size of the next frame to send always @(posedge USER_CLK) if(reset_c) frame_size_r <= `DLY 8'h00; else if(single_cycle_frame_r || eof_r) frame_size_r <= `DLY frame_size_r + 1; //Use a second counter to determine how many bytes of the frame have already been sent always @(posedge USER_CLK) if(reset_c) bytes_sent_r <= `DLY 8'h00; else if(sof_r) bytes_sent_r <= `DLY 8'h01; else if(!TX_DST_RDY_N && !idle_r) bytes_sent_r <= `DLY bytes_sent_r + 1;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
frame计数器呢？
如果发送单周期帧，则遇到单周期帧状态加1；
如果发送多周期帧，则遇到eof状态就加1；
可见，是不断加的。
而bytes呢？
是每次的帧开始就置1，然后一直加到eof状态；
assign next_data_cycle_c = (frame_size_r != bytes_sent_r) && (sof_r || data_cycle_r);
- 1
- 2
bytes计数的含义是已经发送的数据字数，如何和要发送的字数不符合，就处于next_data_cycle_c状态，这个状态是要一直发送数据的状态；
assign next_eof_c = (frame_size_r == bytes_sent_r) && (sof_r || data_cycle_r);
- 1
- 2
如果等于了，则进入最后一个eof状态，发完最后一个字，结束。
//Output logic for 1-hot state machine always @(posedge USER_CLK) if(reset_c) begin TX_SOF_N <= `DLY 1'b1; TX_EOF_N <= `DLY 1'b1; TX_SRC_RDY_N <= `DLY 1'b1; end else if(!TX_DST_RDY_N) begin TX_SOF_N <= `DLY !(sof_r || single_cycle_frame_r); TX_EOF_N <= `DLY !(eof_r || single_cycle_frame_r); TX_SRC_RDY_N <= `DLY idle_r; end
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
有输出代码可知，输出都是在状态的基础上延迟一个时钟。
当sof_r状态的时候，下一个周期将TX_SOF_N置有效；
当eof_r状态的时候，下一个周期置TX_EOF_N有效；
而TX_SRC_RDY_N则在非空闲状态下有效，空闲状态下无效。
如果处于空闲状态，则下一个时钟无效，如果不处于空闲状态，则下一个周期有效。
总之，等价于状态延迟一个时钟。
接收模块仿真
有了上面的发送模块仿真的分析，我想接收模块的仿真也不再话下了。
我们就看看仿真结果就好了，至于结合程序分析，没有必要了，因为我们接收完数据后，按照自己的方式处理了。这个自己最清楚。
接收真的比发送要简单多了。毕竟发送要设计状态机来组合要发送的数据。
参考资料
FPGA设计心得（3）Aurora IP core 的理论学习记录
FPGA设计心得（4）Aurora IP core 的定制详情记录
FPGA设计心得（5）Aurora 例子工程分析与仿真实例分析（streaming版）
交个朋友
写在最后
这篇博客，可真的花费了很多时间，熬夜两个夜晚，说实话，如果没有实际需求，我才不会花这个心思去搞这个东西。
一方面是实验室工程需要；
另一方面是以后工作也需要。
还有就是这个IP核的定制，虽然选择了framing帧格式，但是并没有选择flow control，因此会不会有后续还说不准。
当然，还有数据手册的进一步细节学习，也说不准，因此后续应该会有的。
写的不好，还望见谅。
最后，写老师不催之恩（几天没催了，我也几天埋头学习，没有消息，你总是说我慢，我其实很用心！）。
2020/05/14
工程分享
链接：https://pan.baidu.com/s/1Tc2X6DWhOeO_AUiyE14UTQ
提取码：aw4x
或者csdn下载：
https://download.csdn.net/download/Reborn_Lee/12417421
文章来源: reborn.blog.csdn.net，作者：李锐博恩，版权归原作者所有，如需转载，请联系作者。
原文链接：reborn.blog.csdn.net/article/details/106088264
- 点赞
- 收藏
- 关注作者
评论（0）