基于FPGA的千兆以太网的实现

一、简介

　　一般来说，我们要将 FPGA 板子上采集的数据传输到 PC 端有多种方式，如  UART、USB、千兆网、光纤、PCIe等手段，感觉还是千兆网传输的性价比最高，实现上不是很难，传输速率也比较快。以太网的分类有标准以太网（10Mbit/s），快速以太网（100Mbit/s）和千兆以太网（1000Mbit/s）。随着以太网技术的飞速发展，市场上也出现了万兆以太网（10Gbit/s），它扩展了IEEE802.3协议和MAC规范，使其技术支持 10Gbit/s的传输速率。然而在实际应用中，标准以太网和快速以太网已经能够满足我们的日常需求，对通信速率较高的场合才会用到千兆以太网。

二、对以太网数据包格式的协议一一讲解

　　由上图可知，要发送的数据是加载在UDP协议中，UDP协议又是加载在IP协议中，IP协议加载在MAC协议中，是一种层层包含的关系，下面对MAC、IP、UDP协议一一详细讲解。

　　1、MAC帧格式

 　　　　1）前导码（Preamble）：实现底层数据的正确阐述，物理层使用 7 个字节同步码（0和1交替（55_55_55_55_55_55_55））实现数据的同步。

　　　　 2）帧起始界定符：一个字节，固定为（0xd5）来表示一帧的开始，即后面紧跟着传输的就是以太网的帧头。

　　　　 3）目的MAC地址：六个字节，表明帧的接受者（电脑的MAC地址）。

　　　　 4）源MAC地址：六个字节，表明帧的发送者（板子的MAC地址，一般为自己设置一个地址）。

　　　　 5）长度/类型：两个字节，长度/类型具有两个意义，当着连个字节的值小于1536（十六进制为0x0600）时，代表该以太网中数据段的长度；如果这两个字节的值大于1536，则表示该以太网中的数据属于哪个上层协议，例如0x0800代表IP协议、0x0806代表ARP协议等。

　　　　 6）数据：以太网中的数据段长度最小 46 字节，最大1500个字节。最大值1500称为以太网的最大传输单元，之所以闲置最大传输单元是因为在多个计算机的数据帧排队等待传输时，如果某个数据帧太大的话，那么其他数据帧等待的时间就会加长，导致体验变差。

　　　　 7）帧校验序列（FCS）：四个字节，为了保证数据的正确传输，在数据的尾部加入了4个字节的循环冗余校验码（CRC校验）来检测数据是否传输错误。CRC数据校验从以太网帧头开始即不包含前导码和帧起始界定符。

　　　　值得注意的地方：以太网相邻两帧之间的时间间隔，即帧间隙（IFG）。帧间隙的时间就是网络设备和组件在接收一帧之后，需要短暂的时间来恢复并未接收下一帧做准备的时间。不管是10M/100M/1000M的以太网，两帧之间最少要有96bit time，IFG的最小间隔时间计算方法如下：

　　　　10Mbit/s 最小时间为 ：96 * 100ns = 9600ns；

　　　　100Mbit/s最小时间为 ：96 *10ns = 960ns；

　　　　1000Mbit/s最小时间为：96 * 1ns = 96ns;

　　2、IP数据报格式

　　　　IP数据报前 20 个字节是固定的，IP首部的每一行以32位（4个字节）为单位。

　　　　1）版本：4位IP版本号，设置为0x4时，表示 IPv4，设置为0x6，表示IPv6，目前使用较多的IP协议版本号是IPv4。

　　　　2）首部长度：4位首部长度，表示IP首部一共有多少个32位。在没有可选字段时，IP首部长度为20个字节，因此首部长度的值为0x5。

　　　　3）服务类型：8位服务类型，一般设置为全零，8'h00。

　　　　4）总长度：16位，IP首部长度 + UDP首部长度 + 数据部分的长度（如：IP首部长度固定为 20个字节 + UDP首部长度为 8个字节 + 数据部分的字节数）。

　　　　5）标识：16位，用来标识主句发送的每一份数据报，通常每发一份报文它的值就会加1。（也可以设置为0）

　　　　6）标志字段：3位，第一位为保留为；第二位表示禁止分片（1表示不分片，0表示分片）；第三位表示更多分片。（也可以设置为0）

　　　　7）片偏移：13位，在接收方进行数据报重组时用来标识分片的顺序。（也可以设置为0）

　　　　8）生存时间：8位，防止丢失的数据包在无休止的传播，一般被设置为64或者128。

　　　　9）协议：8位，表示此数据包所携带上层数据使用的协议类型，ICMP为1，TCP为6，UDP为17。

　　　　10）首部校验和：16位，该字段只校验数据报的首部，不包含数据部分，校验IP数据报头部是否被破坏、篡改和丢失等。

　　　　11）源IP地址：32位，即发送端的IP地址（板子的IP地址），一般为自己设置，如192.168.0.2。

　　　　12）目的IP地址：32位，即接收端的IP地址（电脑的IP地址），也可以自己设置，如192.168.0.3。在上板实验时，需将电脑上的IP改为自己设置的那个IP地址。

　　　　IP首部校验和的计算方法：

　　　　　　（1）将16位检核和字段置为0，然后将IP首部按照16位分成多个单元；

　　　　　　（2）将各个单元采用反码加法运算（即高位溢出会加到低位，通常的补码运算时直接丢掉溢出的高位）；

　　　　　　（3）此时仍然可能出现进位的情况，将得到的和再次分成高16位和低16位进行累加；

　　　　　　（4）最后将得到的和的反码填入校验和字段；

　　　　　　如：0 - 31:  45_00_00_32

　　　　　　　　0 - 31:  00_00_00_00

　　　　　　　　0 - 31:  40_11_00_00

　　　　　　　　0 - 31 :  c0_a8_00_02

　　　　　　　　0 - 31 :  c0_a8_00_03

　　　　　　　　（a）0x4500 + 0x0032 +0x0000 +0x0000 +0x4011 +0x0000 + 0xc0a8 +0x 0002 + 0xc0a8 +0x0003 = 0x20698

　　　　　　　　（b）0x0002 + 0x0698 = 0x0698

　　　　　　　　（c）0x0000 + 0x0698 = 0x0698

　　　　　　　　（d）ip_checksm = ~0x0698 = 0xf967

　　3、UDP协议

 　　　　1）源端口号：16位发送端端口号，用于区分不同服务的端口。

　　　　 2）目的端口号：16位接收端端口号。

　　　　 3）UDP长度：16位UDP长度，包含UDP首部长度 + 数据长度，单位是字节；（如，UDP首部长度 8 个字节 + 传输的数据字段的字节数）

　　　　 4）UDP校验和：16位UDP校验和，在大多数情况下设置 0x0000

三、接口时序

　　　　1、接口信号介绍

　　　　（1）GTX_CLK：发送时钟信号，由FPGA中的PLL产生发送给以太网芯片，频率为 125MHz；

　　　　（2）TX_EN：发送数据使能信号，高电平有效；

　　　　（3）TX_ER：发送错误信号，高电平有效，用以破坏数据包的发送，这个信号有些博文中设置为零，但是有条件的话还是设置一下，这个信号挺有用的；

　　　　（4）TXD：发送数据线，FPGA通过该数据线将需要发送的数据依次发送给PHY芯片；

　　　　（5）RX_CLK：由PHY芯片产生，125MHz；

　　　　（6）RX_EN：接收使能信号，高电平有效；

　　　　（7）RX_ER：接收错误信号，高电平有效；

　　　　（8）RXD：接收数据线，FPGA通过该数据线从PHY接收数据；

　　　　2、接口时序（仅列出发送时序）

 　　　　这个GMII模式的千兆网的发送时序，在TX_EN为高电平时，在时钟的上升沿发送数据给以太网芯片，在千兆网中，发送数据是先发高位，再发低位；

 　　3、按照上述的协议，发送数据实现协议的顺序如下：

　　　　（1）前导码 + 帧定界符：64'h55_55_55_55_55_55_55_d5；

　　　　（2）MAC首部：des_mac：48'hff_ff_ff_ff_ff_ff；src_mac：48'h00_0a_35_01_fe_c0；type_len：16'h08_00；

　　　　（3）IP首部：0~31:45_00_00_(ip_total_len)

　　　　　　　　　  ：0~31:00_00_00_00（注：这一列数据要慎重考虑，可以设为零，也可以按照正经要求来填写）

　　　　　　　　　  ：0~31:40_11_(ip_checksum)

　　　　　　　　　  ：0~31:c0_a8_00_02

　　　　　　　　　  ：0~31:c0_a8_00_03

　　　　（4）UDP首部：0~31:13_88_17_70（这里源端口和目的端口分别为5000，6000）

　　　　　　　　　　　：0~31:(udp_len)_00_00

　　　　（5）数据部分，自定义；

　　　　（6）CRC校验，我用的是一个普遍适用的CRC校验，代码会在下文给出；

四、代码实现（仅做参考用）

　　1、硬件平台：MP801

　　2、软件环境：Quartus II 13.0

　　3、RTL视图：

 　　注：以太网芯片为 RTL8211EG；以太网复位是高电平有效；gtx_clk这个时钟信号是由FPGA通过PLL倍频到 125MHz；

　　4、实现源码：

　　顶层模块：gmii_test.v

// *********************************************************************************
// Project Name : udpsend
// Email             : 
// Create Time    : 2020/07/06 15：21
// Module Name  : udpsend
// editor         : qing
// Version         : Rev1.0.0
// *********************************************************************************

module gmii_test(
    input                    sclk            ,
    
    output                phy_rst_n,
    output    [7:0]               tx_data            ,
    output                tx_en        ,
    output                tx_er        ,
    output                gtx_clk    
);



pll u0 (
    .inclk0 (sclk    ),
    .c0     (gtx_clk )
    );
    


udp_send u2(
        .gtx_clk        (gtx_clk        ),                   //GMII发送的时钟信号
        .tx_en        (tx_en        ),                  //GMII数据使能信号
        .tx_er        (tx_er        ),                  //GMII发送错误信号
        .tx_data        (tx_data        ),
        .phy_rst_n        (phy_rst_n         )
);



endmodule
   

　　子模块：udp_send.v

// *********************************************************************************
// Project Name : gmii_tx_test
// Email        : 
// Create Time  : 2020/07/06 19：15
// Module Name  : udp_send
// editor        : qing
// Version        : Rev1.0.0
// *********************************************************************************

module udp_send(
        input                    gtx_clk        ,

        output    reg                tx_en        ,
        output    reg                tx_er        ,
        output    reg[7:0]        tx_data        ,
        output                    phy_rst_n
    );

//========================================================================
// =========== Define Parameter and Internal signals =========== 
//========================================================================/

wire            [15:0]        data_length        ;  // 数据字段的长度
wire            [15:0]        ip_total_length ;  // ip首部 + udp首部 + 数据字段的长度

reg                [3:0]        state             ;

reg        [31:0]    ip_head        [6:0]            ;  // ip首部 + udp首部
reg        [ 7:0]    premeble     [7:0]            ;
reg        [ 7:0]  mac_addr    [13:0]            ;  // mac 首部

reg        [ 4:0]  i,j                         ;

reg        [31:0]  check_buff                    ;
reg     [31:0]    delay_cnt                    ;
reg     [15:0]    cnt_data                    ;

reg                crcen                        ;
reg                crcre                         ;
wire     [31:0]    crc                         ;
wire    [31:0]    CrcNext                     ;


parameter         idle         =    4'b0000        ;
parameter         start       =   4'b0001        ;
parameter         make         =    4'b0010     ;
parameter         send55      =   4'b0011        ;
parameter         sendmac     =     4'b0100     ;
parameter         sendhead    =   4'b0101     ;
parameter         senddata    =    4'b0110     ;
parameter         sendcrc     =   4'b0111     ;

//=============================================================================
//****************************     Main Code    *******************************
//=============================================================================

crc u0(
    .Clk         (gtx_clk    ), 
    .Reset        (crcre        ), 
    .Data_in    (tx_data    ), 
    .Enable        (crcen      ), 
    .Crc         (crc           ),
    .CrcNext    (CrcNext    )
    );

assign data_length = 16'd33 ;
assign ip_total_length = 16'd28 + data_length;
assign phy_rst_n = 1'b1;

always @(posedge gtx_clk ) begin
    premeble[0]    <= 8'h55;
    premeble[1]    <= 8'h55;
    premeble[2]    <= 8'h55;
    premeble[3]    <= 8'h55;
    premeble[4]    <= 8'h55;
    premeble[5]    <= 8'h55;
    premeble[6]    <= 8'h55;
    premeble[7]    <= 8'hd5;

    mac_addr[0] <= 8'hff;
    mac_addr[1] <= 8'hff;
    mac_addr[2] <= 8'hff;
    mac_addr[3] <= 8'hff;
    mac_addr[4] <= 8'hff;
    mac_addr[5] <= 8'hff;

    mac_addr[6] <= 8'h00;
    mac_addr[7] <= 8'h0a;
    mac_addr[8] <= 8'h35;
    mac_addr[9] <= 8'h01;
    mac_addr[10] <= 8'hfe;
    mac_addr[11] <= 8'hc0;

    mac_addr[12] <= 8'h08;
    mac_addr[13] <= 8'h00;
end

initial
    begin
        //state <= idle;
        
        delay_cnt <= 0;
        check_buff <= 32'h00000000;
    end

always @(posedge gtx_clk) begin
    //state <= idle;
    case(state)
        idle:begin
            tx_er <= 1'b0;
            tx_en <= 1'b0;

            crcen <= 1'b0;
            crcre <= 1'b1;
            i <= 0;
            j <= 0;
            tx_data <= 8'd0;
            cnt_data <= 0;

            if(delay_cnt == 32'h1000) begin  // 04000000
                state <= start;
                delay_cnt <= 0;
            end
            else
                delay_cnt <= delay_cnt + 1'b1;
        end

        start:begin
            ip_head[0] <= {16'h4500,ip_total_length};
            ip_head[1][31:16] <= ip_head[1][31:16] + 1'b1;  //ip_head[1][31:16] + 1'b1
            ip_head[1][15:0] <= 16'h0000;  // 4000
            ip_head[2] <= 32'h80110000;
            ip_head[3] <= 32'hc0a80002;
            ip_head[4] <= 32'hc0a80003;
            ip_head[5] <= 32'h13881770;
            ip_head[6] <= {data_length,16'h0000};
            state <= make; 
        end

        make:begin
            if(i==0) begin
                check_buff <= (ip_head[0][15:0] + ip_head[0][31:16] + ip_head[1][15:0] + ip_head[1][31:16]
                             +ip_head[2][15:0] + ip_head[2][31:16] + ip_head[3][15:0] + ip_head[3][31:16]
                             +ip_head[4][15:0] + ip_head[4][31:16] );
                i <= i + 1'b1;
            end
            else if(i == 1) begin
                check_buff[15:0] <= check_buff[31:16] + check_buff[15:0];
                i <= i + 1'b1;
            end
            else begin
                ip_head[2][15:0] <= ~check_buff[15:0];
                i <= 0;
                state <= send55;
            end
        end

        send55:begin
            tx_en <= 1'b1;
            crcre <= 1'b1;
            if(i == 7) begin
                tx_data[7:0] <= premeble[i][7:0];
                i <= 0;
                state <= sendmac;
            end
            else begin
                tx_data[7:0] <= premeble[i][7:0];
                i <= i + 1'b1;
            end
        end

        sendmac:begin
            crcen <= 1'b1;
            crcre <= 1'b0;
            if(i == 13) begin
                tx_data[7:0] <= mac_addr[i][7:0];
                i <= 0;
                state <= sendhead;
            end
            else begin
                tx_data[7:0] <= mac_addr[i][7:0];
                i <= i + 1'b1;
            end
        end

        sendhead:begin
            if(j == 6) begin
                if(i == 0) begin
                    tx_data[7:0] <= ip_head[j][31:24];
                    i <= i + 1'b1;
                end
                else if(i == 1)begin
                    tx_data[7:0] <= ip_head[j][23:16];
                    i <= i + 1'b1;
                end
                else if(i == 2)begin
                    tx_data[7:0] <= ip_head[j][15:8];
                    i <= i + 1'b1;
                end
                else if(i == 3) begin
                    tx_data <= ip_head[j][7:0];
                    i <= 0;
                    j <= 0;
                    state <= senddata;
                end
                else
                    tx_er <= 1'b1;
            end
            else begin
                if(i == 0) begin
                    tx_data[7:0] <= ip_head[j][31:24];
                    i <= i + 1'b1;
                end
                else if(i == 1) begin
                    tx_data <= ip_head[j][23:16];
                    i <= i + 1'b1;
                end
                else if(i == 2) begin
                    tx_data <= ip_head[j][15:8];
                    i <= i + 1'b1;
                end
                else if(i == 3) begin
                    tx_data <= ip_head[j][7:0];
                    i <= 0;
                    j <= j + 1'b1;
                end
                else
                    tx_er <= 1'b1;
            end
        end

        senddata:begin
            if(cnt_data == data_length - 1) begin
                cnt_data <= 0;
                state <= sendcrc;
                tx_data <= 8'haa;
            end
            else begin
                cnt_data <= cnt_data + 1'b1;
                state <= senddata;
            end
            case(cnt_data)
                0:tx_data <= 8'hff;
                1:tx_data <= 8'h01;
                2:tx_data <= 8'h02;
                3:tx_data <= 8'h03;
                4:tx_data <= 8'h04;
                5:tx_data <= 8'h05;
                6:tx_data <= 8'h06;
                7:tx_data <= 8'h07;
                8:tx_data <= 8'h08;
                9:tx_data <= 8'h09;
                10:tx_data <= 8'h0a;
                11:tx_data <= 8'h0b;
                12:tx_data <= 8'h0c;
                13:tx_data <= 8'h0d;
                14:tx_data <= 8'h0e;
                15:tx_data <= 8'h0f;
                16:tx_data <= 8'hf0;
                17:tx_data <= 8'hf1;
                18:tx_data <= 8'hf2;
                19:tx_data <= 8'hf3;
                20:tx_data <= 8'hf4;
                21:tx_data <= 8'hf5;
                22:tx_data <= 8'hf6;
                23:tx_data <= 8'hf7;
                24:tx_data <= 8'hf8;
                25:tx_data <= 8'hf9;
                26:tx_data <= 8'hfa;
                27:tx_data <= 8'hfb;
                28:tx_data <= 8'hfc;
                29:tx_data <= 8'hfd;
                30:tx_data <= 8'hfe;
                31:tx_data <= 8'h11;
                32:tx_data <= 8'h22;
                default:tx_data <= 8'hff;
            endcase
        end

        sendcrc:begin
            crcen <= 1'b0;
            if(i == 0) begin
                tx_data[7:0] <= {~crc[24], ~crc[25], ~crc[26], ~crc[27], ~crc[28], ~crc[29], ~crc[30], ~crc[31]};
                i <= i + 1'b1; 
            end
            else begin
                if(i == 1) begin
                    tx_data[7:0] <= {~crc[16], ~crc[17], ~crc[18], ~crc[19], ~crc[20], ~crc[21], ~crc[22], ~crc[23]};
                    i <= i + 1'b1;
                end
                else if(i == 2) begin
                    tx_data[7:0] <= {~crc[8], ~crc[9], ~crc[10], ~crc[11], ~crc[12], ~crc[13], ~crc[14], ~crc[15]};
                    i <= i + 1'b1;
                end
                else if(i == 3) begin
                    tx_data[7:0] <= {~crc[0], ~crc[1], ~crc[2], ~crc[3], ~crc[4], ~crc[5], ~crc[6], ~crc[7]};
                    i <= 0;
                    state <= idle;
                end
                else begin
                    tx_er <= 1'b1;
                end
            end
        end
        default:state <= idle;
    endcase
end

endmodule

　　子模块：crc.v

`timescale 1ns / 1ps
/****************************************/
//      　CRC32数据校验模块　　　   　　　　//
/****************************************/
module crc (Clk, Reset, Data_in, Enable, Crc,CrcNext);


parameter Tp = 1;

input Clk;
input Reset;
input [7:0] Data_in;

input Enable;

output [31:0] Crc;
reg  [31:0] Crc;

output [31:0] CrcNext;

wire [7:0] Data;

assign Data={Data_in[0],Data_in[1],Data_in[2],Data_in[3],Data_in[4],Data_in[5],Data_in[6],Data_in[7]};


assign CrcNext[0] = Crc[24] ^ Crc[30] ^ Data[0] ^ Data[6];
assign CrcNext[1] = Crc[24] ^ Crc[25] ^ Crc[30] ^ Crc[31] ^ Data[0] ^ Data[1] ^ Data[6] ^ Data[7];
assign CrcNext[2] = Crc[24] ^ Crc[25] ^ Crc[26] ^ Crc[30] ^ Crc[31] ^ Data[0] ^ Data[1] ^ Data[2] ^ Data[6] ^ Data[7];
assign CrcNext[3] = Crc[25] ^ Crc[26] ^ Crc[27] ^ Crc[31] ^ Data[1] ^ Data[2] ^ Data[3] ^ Data[7];
assign CrcNext[4] = Crc[24] ^ Crc[26] ^ Crc[27] ^ Crc[28] ^ Crc[30] ^ Data[0] ^ Data[2] ^ Data[3] ^ Data[4] ^ Data[6];
assign CrcNext[5] = Crc[24] ^ Crc[25] ^ Crc[27] ^ Crc[28] ^ Crc[29] ^ Crc[30] ^ Crc[31] ^ Data[0] ^ Data[1] ^ Data[3] ^ Data[4] ^ Data[5] ^ Data[6] ^ Data[7];
assign CrcNext[6] = Crc[25] ^ Crc[26] ^ Crc[28] ^ Crc[29] ^ Crc[30] ^ Crc[31] ^ Data[1] ^ Data[2] ^ Data[4] ^ Data[5] ^ Data[6] ^ Data[7];
assign CrcNext[7] = Crc[24] ^ Crc[26] ^ Crc[27] ^ Crc[29] ^ Crc[31] ^ Data[0] ^ Data[2] ^ Data[3] ^ Data[5] ^ Data[7];
assign CrcNext[8] = Crc[0] ^ Crc[24] ^ Crc[25] ^ Crc[27] ^ Crc[28] ^ Data[0] ^ Data[1] ^ Data[3] ^ Data[4];
assign CrcNext[9] = Crc[1] ^ Crc[25] ^ Crc[26] ^ Crc[28] ^ Crc[29] ^ Data[1] ^ Data[2] ^ Data[4] ^ Data[5];
assign CrcNext[10] = Crc[2] ^ Crc[24] ^ Crc[26] ^ Crc[27] ^ Crc[29] ^ Data[0] ^ Data[2] ^ Data[3] ^ Data[5];
assign CrcNext[11] = Crc[3] ^ Crc[24] ^ Crc[25] ^ Crc[27] ^ Crc[28] ^ Data[0] ^ Data[1] ^ Data[3] ^ Data[4];
assign CrcNext[12] = Crc[4] ^ Crc[24] ^ Crc[25] ^ Crc[26] ^ Crc[28] ^ Crc[29] ^ Crc[30] ^ Data[0] ^ Data[1] ^ Data[2] ^ Data[4] ^ Data[5] ^ Data[6];
assign CrcNext[13] = Crc[5] ^ Crc[25] ^ Crc[26] ^ Crc[27] ^ Crc[29] ^ Crc[30] ^ Crc[31] ^ Data[1] ^ Data[2] ^ Data[3] ^ Data[5] ^ Data[6] ^ Data[7];
assign CrcNext[14] = Crc[6] ^ Crc[26] ^ Crc[27] ^ Crc[28] ^ Crc[30] ^ Crc[31] ^ Data[2] ^ Data[3] ^ Data[4] ^ Data[6] ^ Data[7];
assign CrcNext[15] =  Crc[7] ^ Crc[27] ^ Crc[28] ^ Crc[29] ^ Crc[31] ^ Data[3] ^ Data[4] ^ Data[5] ^ Data[7];
assign CrcNext[16] = Crc[8] ^ Crc[24] ^ Crc[28] ^ Crc[29] ^ Data[0] ^ Data[4] ^ Data[5];
assign CrcNext[17] = Crc[9] ^ Crc[25] ^ Crc[29] ^ Crc[30] ^ Data[1] ^ Data[5] ^ Data[6];
assign CrcNext[18] = Crc[10] ^ Crc[26] ^ Crc[30] ^ Crc[31] ^ Data[2] ^ Data[6] ^ Data[7];
assign CrcNext[19] = Crc[11] ^ Crc[27] ^ Crc[31] ^ Data[3] ^ Data[7];
assign CrcNext[20] = Crc[12] ^ Crc[28] ^ Data[4];
assign CrcNext[21] = Crc[13] ^ Crc[29] ^ Data[5];
assign CrcNext[22] = Crc[14] ^ Crc[24] ^ Data[0];
assign CrcNext[23] = Crc[15] ^ Crc[24] ^ Crc[25] ^ Crc[30] ^ Data[0] ^ Data[1] ^ Data[6];
assign CrcNext[24] = Crc[16] ^ Crc[25] ^ Crc[26] ^ Crc[31] ^ Data[1] ^ Data[2] ^ Data[7];
assign CrcNext[25] = Crc[17] ^ Crc[26] ^ Crc[27] ^ Data[2] ^ Data[3];
assign CrcNext[26] = Crc[18] ^ Crc[24] ^ Crc[27] ^ Crc[28] ^ Crc[30] ^ Data[0] ^ Data[3] ^ Data[4] ^ Data[6];
assign CrcNext[27] = Crc[19] ^ Crc[25] ^ Crc[28] ^ Crc[29] ^ Crc[31] ^ Data[1] ^ Data[4] ^ Data[5] ^ Data[7];
assign CrcNext[28] = Crc[20] ^ Crc[26] ^ Crc[29] ^ Crc[30] ^ Data[2] ^ Data[5] ^ Data[6];
assign CrcNext[29] = Crc[21] ^ Crc[27] ^ Crc[30] ^ Crc[31] ^ Data[3] ^ Data[6] ^ Data[7];
assign CrcNext[30] = Crc[22] ^ Crc[28] ^ Crc[31] ^ Data[4] ^ Data[7];
assign CrcNext[31] = Crc[23] ^ Crc[29] ^ Data[5];

always @ (posedge Clk, posedge Reset)
 begin
  if (Reset) begin
    Crc <={32{1'b1}};
  end
   else if (Enable)
    Crc <=CrcNext;
 end
endmodule

　　5、用Wireshark捕捉的数据包

 　　这个代码还是有些瑕疵的如：

　　　　（1）在代码中，我发送的数据长度是 33 个字节，用Wireshark捕捉到的数据长度也有 33 个字节，但是像这个图中显示的数据长度 Len = 25，这个我还没搞明白；

　　　　（2）在RTL仿真时，有些信号会出现未知的状态，但是上板却又能正常的工作；

　　6、在学习千兆网的过程中，看了好几个人的百兆网，千兆网代码，下面列出一个自己写的代码，上板实验没有成功，但是RTL仿真和Signal Tap II仿真都是正常的，思路较为简单，容易上手，仅供参考。

　　顶层模块：gmii_tx_test.v

`timescale 1ns/1ps
module gmii_tx_test(
    input                    clk            ,
    input                    rst_n            ,
    output                gtx_clk        ,
    output                tx_en            ,
    output                tx_er            ,
    output    [7:0]        tx_data        ,
    output                tx_done        ,
    output                phy_rst_n
);


pll_125m    u0 (
    .inclk0 ( clk                     ),
    .c0     ( gtx_clk              )
    );


gmii_tx u1(
      .rst_n            (rst_n        ),
      .tx_done        (tx_done        ),
      .gtx_clk        (gtx_clk      ),
      .tx_en            (tx_en        ),
      .tx_er            (tx_er        ),
      .tx_data        (tx_data        ),
      .phy_rst_n    (phy_rst_n    )
);

endmodule

　　子模块：gmii_tx.v

 // *********************************************************************************
// Project Name : gmii_tx
// Email        : 
// Create Time  : 2020/06/22  10:41
// Module Name  : 
// editor         : 
// Version         : Rev1.0.0
// *********************************************************************************

// Notice : 较为主流的CRC复位是发生在 前导码 的时候，而我的复位是在 IDLE 状态
//            主流的 CRC_EN 是发生在发送 MAC帧和CRC帧前面，我的都是组合逻辑来实现的，而其他的都是时序逻辑

module gmii_tx(
      rst_n        ,
      tx_done    ,

      gtx_clk    ,
      tx_en        ,
      tx_er        ,
      tx_data    ,

      phy_rst_n    
);
input                    gtx_clk            ;
input                    rst_n            ;
output    reg                   tx_en            ;
output    reg             tx_er            ;
output    reg[7:0]        tx_data            ; 
output    reg                 tx_done            ;
output    wire            phy_rst_n        ;

//========================================================================
// =========== Define Parameter and Internal signals =========== 
//========================================================================/

parameter   Tx_Idle            =    4'd0                    ;
parameter     Tx_premeble        =    4'd1                    ;
parameter   Tx_Mac            =    4'd2                    ;
parameter   Tx_ip            =    4'd3                    ;
parameter   Tx_udp            =    4'd4                    ;
parameter    Tx_data            =   4'd5                    ;
parameter   Tx_crc            =    4'd6                    ;

reg            [47:0]            des_mac                        ;
reg            [47:0]            src_mac                        ;
reg            [15:0]            type_length                    ;

reg            [7:0]            ver_hdr_len                    ;
reg            [7:0]            tos                            ;
reg            [15:0]            ip_length                    ;
reg            [15:0]            id                             ;
reg         [15:0]            offset                        ;
reg         [7:0]            ttl                         ;
reg         [7:0]            protocol                    ;
reg         [31:0]            des_ip                        ;
reg         [31:0]            src_ip                        ;

reg            [15:0]            des_port                    ;
reg         [15:0]            src_port                    ;
reg            [15:0]            udp_length                    ;
reg         [15:0]            udp_checksum                ;

/*
parameter    data_length        =    16'h22                    ;  // 

// -------------------- MAC ----------------------------
parameter    des_mac            =    48'hff_ff_ff_ff_ff_ff    ;  // 18_31_bf_b8_b9_d9
parameter    src_mac            =    48'h00_0a_35_01_fe_c0    ;
parameter    type_length        =    16'h08_00                ;

// -------------------- IP -----------------------------
parameter    ver_hdr_len        =    8'h45                        ;
parameter    tos             =    8'h00                         ;
parameter    ip_length        =    16'h001c + data_length        ;  // 之前是 ip首部 + 数据部分，现在是 ip首部 + udp首部 + 数据长度
parameter    id                =    16'h0000                     ;
parameter    offset            =    16'h0000                     ;
parameter    ttl             =    8'h40                         ;
parameter    protocol        =    8'h11                         ;
parameter    des_ip            =    32'hc0_a8_00_03                ;
parameter    src_ip            =    32'hc0_a8_00_02                ;

// -------------------- UDP ----------------------------

parameter    des_port        =    16'h17_70                    ; // 6000
parameter    src_port        =    16'h13_88                    ; // 5000
parameter    udp_length        =    16'h0008 + data_length        ;
parameter    udp_checksum    =    16'h0000                     ;
*/

wire            [7:0]            tx_delay                ;
reg                [19:0]            cnt                     ;

reg                [3:0]            current_state            ;
reg                [3:0]            next_state                ;

wire            [15:0]            ip_checksum                ;
wire            [31:0]            crc_result                ;
wire            [31:0]            sum                        ;
reg                                CRC_EN                    ;
reg                                CRC_reset                ;

wire            [31:0]            crc                     ;
wire            [31:0]            crcNext                    ;

reg                [4:0]            cnt_premeble            ;
reg                [4:0]            cnt_mac                    ;
reg                [4:0]            cnt_ip                    ;
reg                [4:0]            cnt_udp                    ;
reg                [5:0]            cnt_data                ;
reg                [4:0]            cnt_crc                    ;

//=============================================================================
//****************************     Main Code    *******************************
//=============================================================================

parameter    data_length        =    16'h22                    ;

always @(posedge gtx_clk) begin  // MAC
    des_mac    <=    48'hffffffffffff;
    src_mac    <=    48'h000a3501fec0;
    type_length    <= 16'h0800;
end

always @(posedge gtx_clk) begin  // IP
    ver_hdr_len    <=    8'h45;                    
    tos         <=    8'h00 ;                    
    ip_length    <=    16'h001c + data_length;    
    id            <=    16'h0021;                 
    offset        <=    16'h4000;                 
    ttl         <=    8'h80;          //             
    protocol    <=    8'h11;                     
    des_ip        <=    32'hc0_a8_00_03;            
    src_ip        <=    32'hc0_a8_00_02;            
end

always @(posedge gtx_clk) begin  // UDP
    des_port        <=    16'h17_70;                
    src_port        <=    16'h13_88;                
    udp_length        <=    16'h0008 + data_length;    
    udp_checksum    <=    16'h0000 ;                
end

assign sum = {ver_hdr_len,tos} + ip_length + id 
            + offset + {ttl,protocol} + src_ip[31:16]
            + src_ip[15:0] + des_ip[31:16] + des_ip[15:0];

/*
CRC32_D8 u0 (
    .Clk        (gtx_clk     ),
    .Reset         (CRC_reset     ),
    .Data_in    ( tx_data    ), 
    .Enable     ( CRC_EN     ),
    .Crc        (   Crc       ),
    .CrcNext    (   CrcNext  ),
    .Crc_eth    ( crc_result )
);
*/

crc u0(
    .Clk        (gtx_clk   ), 
    .Reset    (CRC_reset ),   // CRC_reset
    .Data_in (tx_data   ), 
    .Enable    (CRC_EN      ), 
    .Crc        (    crc      ),
    .CrcNext (crcNext   )
);
    
//assign CRC_reset = (current_state == Tx_Idle) ? 1'b1 : 1'b0;

//assign CRC_EN    = (current_state >= Tx_Mac && current_state <= Tx_data) ? 1'b1 : 1'b0;

assign ip_checksum = ~(sum[31:16] + sum[15:0]);

assign phy_rst_n   =  1'b1;

always @(posedge gtx_clk or negedge rst_n) begin  // cnt
    if(!rst_n)
        cnt <= 20'd0;
    else if(cnt == 80000)
        cnt <= 20'd0;
    else
        cnt <= cnt + 1'b1;
end

assign  tx_delay = (cnt == 80000)? 1'b1 : 1'b0;

//=============================================================================\
//****************************    State Machine    *******************************\
//=============================================================================\

always @(posedge gtx_clk or negedge rst_n) begin
    if(!rst_n)
        current_state <= Tx_Idle;
    else
        current_state <= next_state;

end

always @(*) begin
    next_state = Tx_Idle;
    case(current_state)
        Tx_Idle:begin
            if(tx_delay == 1'b1)
                next_state = Tx_premeble;
            else
                next_state = current_state;
        end

        Tx_premeble:begin
            if(cnt_premeble >= 8 -1 )
                next_state = Tx_Mac;
            else
                next_state = current_state;
        end

        Tx_Mac:begin
            if(cnt_mac >= 14-1)
                next_state = Tx_ip;
            else
                next_state = current_state;
        end

        Tx_ip:begin
            if(cnt_ip >= 20-1)
                next_state = Tx_udp;
            else
                next_state = current_state;
        end

        Tx_udp:begin
            if(cnt_udp >= 8-1)
                next_state = Tx_data;
            else
                next_state = current_state;
        end

        Tx_data:begin
            if(cnt_data >= data_length- 1 )
                next_state = Tx_crc;
            else
                next_state = current_state;
        end

        Tx_crc:begin
            if(cnt_crc >= 4-1 ) 
                next_state = Tx_Idle;
            else
                next_state = current_state;
        end

        default:begin
            next_state = Tx_Idle;
        end
    endcase
end

always @(posedge gtx_clk or negedge rst_n) begin
    if(!rst_n) begin
        tx_data <= 8'h00;
        tx_en <= 1'b0;
        tx_er <= 1'b0;
        tx_done <= 1'b0;
        cnt_premeble <= 0;
        cnt_mac <= 0;
        cnt_ip <= 0;
        cnt_udp <= 0;
        cnt_data <= 0;
        cnt_crc <= 0;
        CRC_EN <= 1'b0;
        CRC_reset <= 1'b0;
    end
    else begin
        case(current_state)  // next_satae
            Tx_Idle: begin
                tx_done <= 1'b0;
                tx_en <= 1'b0;
                tx_er <= 1'b0;
                tx_data <= 8'h00;
                CRC_reset <= 1'b1;
            end

            Tx_premeble:begin
                CRC_reset <= 1'b1;
                tx_en <= 1'b1;
                if(cnt_premeble >= 8 -1 )
                    cnt_premeble <= 0;
                else
                    cnt_premeble <= cnt_premeble + 1'b1;
                case(cnt_premeble)
                    0,1,2,3,4,5,6:
                        tx_data <= 8'h55;
                    7:tx_data <= 8'hd5;
                    default:tx_data <= 8'h55;
                endcase
            end

            Tx_Mac:begin
                CRC_reset <= 1'b0;
                CRC_EN <= 1'b1;
                if(cnt_mac >= 14 -1)
                    cnt_mac <= 0;
                else
                    cnt_mac <= cnt_mac + 1'b1;
                case(cnt_mac)
                    0 :tx_data <= des_mac[47:40];
                    1 :tx_data <= des_mac[39:32];
                    2 :tx_data <= des_mac[31:24];
                    3 :tx_data <= des_mac[23:16];
                    4 :tx_data <= des_mac[15: 8];
                    5 :tx_data <= des_mac[ 7: 0];
                    
                    6 :tx_data <= src_mac[47:40];
                    7 :tx_data <= src_mac[39:32];
                    8 :tx_data <= src_mac[31:24];
                    9 :tx_data <= src_mac[23:16];
                    10:tx_data <= src_mac[15: 8];
                    11:tx_data <= src_mac[ 7: 0];
                    
                    12:tx_data <= type_length[15:8];
                    13:tx_data <= type_length[ 7:0];
                    default:tx_data <= 8'hff;
                endcase
            end

            Tx_ip:begin
                if(cnt_ip >= 20-1 )
                    cnt_ip <= 0;
                else
                    cnt_ip <= cnt_ip + 1'b1;
                case(cnt_ip)
                    0 : tx_data <= ver_hdr_len;
                    1 :    tx_data <= tos;
                    2 :    tx_data <= ip_length[15:8];
                    3 :    tx_data <= ip_length[7:0];
                    4 :    tx_data <= id[15:8];
                    5 :    tx_data <= id[7:0];
                    6 :    tx_data <= offset[15:8];
                    7 :    tx_data <= offset[7:0];
                    8 :    tx_data <= ttl;
                    9 :    tx_data <= protocol;
                    10:    tx_data <= ip_checksum[15:8];
                    11:    tx_data <= ip_checksum[7:0];
                    12:    tx_data <= src_ip[31:24];
                    13:    tx_data <= src_ip[23:16];
                    14:    tx_data <= src_ip[15:8];
                    15:    tx_data <= src_ip[7:0];
                    16:    tx_data <= des_ip[31:24];
                    17:    tx_data <= des_ip[23:16];
                    18:    tx_data <= des_ip[15:8];
                    19:    tx_data <= des_ip[7:0];
                    default:tx_data <= 8'hff;
                endcase
            end

            Tx_udp:begin
                if(cnt_udp >= 8 -1)
                    cnt_udp <= 0;
                else
                    cnt_udp <= cnt_udp + 1'b1;
                case(cnt_udp)
                    0: tx_data <= src_port[15:8];
                    1: tx_data <= src_port[7:0];
                    2: tx_data <= des_port[15:8];
                    3: tx_data <= des_port[7:0];
                    4: tx_data <= udp_length[15:8];
                    5: tx_data <= udp_length[7:0];
                    6: tx_data <= udp_checksum[15:8];
                    7: tx_data <= udp_checksum[7:0];
                    default:tx_data <= 8'hff;
                endcase
            end

            Tx_data:begin
                if(cnt_data >= data_length -1)
                    cnt_data <= 0;
                else
                    cnt_data <= cnt_data + 1'b1;
                case(cnt_data)
                    0:  tx_data <= 8'hf;
                    1:  tx_data <= 8'h0;
                    2:  tx_data <= 8'h1;
                    3:  tx_data <= 8'h2;
                    4:  tx_data <= 8'h3;
                    5:  tx_data <= 8'h4;
                    6:  tx_data <= 8'h5;
                    7:  tx_data <= 8'h6;
                    8:  tx_data <= 8'h7;
                    9:  tx_data <= 8'h8;
                    10: tx_data <= 8'h9;
                    11: tx_data <= 8'ha;
                    12: tx_data <= 8'hb;
                    13: tx_data <= 8'hc;
                    14: tx_data <= 8'hd;
                    15: tx_data <= 8'he;
                    16: tx_data <= 8'hf;
                    17: tx_data <= 8'h1;
                    18: tx_data <= 8'h2;
                    19: tx_data <= 8'h3;
                    20: tx_data <= 8'h4;
                    21: tx_data <= 8'h5;
                    22: tx_data <= 8'h6;
                    23: tx_data <= 8'h7;
                    24: tx_data <= 8'h8;
                    25: tx_data <= 8'h9;
                    26: tx_data <= 8'ha;
                    27: tx_data <= 8'hb;
                    28: tx_data <= 8'hc;
                    29: tx_data <= 8'hd;
                    30: tx_data <= 8'he;
                    
                    31: tx_data <= 8'haa;
                    32: tx_data <= 8'hab;
                    33: tx_data <= 8'hac;
                    default:tx_data <= 8'hff;
                endcase
            end

            Tx_crc:begin
                CRC_EN <= 1'b0;
                if(cnt_crc >= 4 -1) begin
                    tx_done <= 1'b1;
                    cnt_crc <= 0;
                    //tx_en <= 1'b0;
                end
                else
                    cnt_crc <= cnt_crc + 1'b1;
                case(cnt_crc)
                    0: tx_data <= {~crc[24], ~crc[25], ~crc[26], ~crc[27], ~crc[28], ~crc[29], ~crc[30], ~crc[31]};                        // 8'h1b;
                    1: tx_data <= {~crc[16], ~crc[17], ~crc[18], ~crc[19], ~crc[20], ~crc[21], ~crc[22], ~crc[23]};                        // 8'h75;
                    2: tx_data <= {~crc[8], ~crc[9], ~crc[10], ~crc[11], ~crc[12], ~crc[13], ~crc[14], ~crc[15]};                        // 8'h49;
                    3: tx_data <= {~crc[0], ~crc[1], ~crc[2], ~crc[3], ~crc[4], ~crc[5], ~crc[6], ~crc[7]};                        // 8'h0c;
                    default:tx_data <= 8'hff;
                endcase
            end
            default:tx_data <= 8'h00;
        endcase
    end
end


endmodule

/*
crc_result[31:24];
crc_result[23:16];
crc_result[15:8];
crc_result[7:0];
*/

　　子模块：CRc32_D8.v

`timescale 1ns/1ns
module CRC32_D8(
    Clk,
    Reset,
    Data_in, 
    Enable,
    Crc,
    CrcNext,
    Crc_eth
);

    parameter Tp = 1;

    input Clk;
    input Reset;
    input [7:0] Data_in;
    input Enable;

    output reg [31:0] Crc;
    
    output [31:0]Crc_eth;

    output [31:0] CrcNext;

    wire [7:0] Data;

    assign Data={Data_in[0],Data_in[1],Data_in[2],Data_in[3],Data_in[4],Data_in[5],Data_in[6],Data_in[7]};

    assign CrcNext[0] = Crc[24] ^ Crc[30] ^ Data[0] ^ Data[6];
    assign CrcNext[1] = Crc[24] ^ Crc[25] ^ Crc[30] ^ Crc[31] ^ Data[0] ^ Data[1] ^ Data[6] ^ Data[7];
    assign CrcNext[2] = Crc[24] ^ Crc[25] ^ Crc[26] ^ Crc[30] ^ Crc[31] ^ Data[0] ^ Data[1] ^ Data[2] ^ Data[6] ^ Data[7];
    assign CrcNext[3] = Crc[25] ^ Crc[26] ^ Crc[27] ^ Crc[31] ^ Data[1] ^ Data[2] ^ Data[3] ^ Data[7];
    assign CrcNext[4] = Crc[24] ^ Crc[26] ^ Crc[27] ^ Crc[28] ^ Crc[30] ^ Data[0] ^ Data[2] ^ Data[3] ^ Data[4] ^ Data[6];
    assign CrcNext[5] = Crc[24] ^ Crc[25] ^ Crc[27] ^ Crc[28] ^ Crc[29] ^ Crc[30] ^ Crc[31] ^ Data[0] ^ Data[1] ^ Data[3] ^ Data[4] ^ Data[5] ^ Data[6] ^ Data[7];
    assign CrcNext[6] = Crc[25] ^ Crc[26] ^ Crc[28] ^ Crc[29] ^ Crc[30] ^ Crc[31] ^ Data[1] ^ Data[2] ^ Data[4] ^ Data[5] ^ Data[6] ^ Data[7];
    assign CrcNext[7] = Crc[24] ^ Crc[26] ^ Crc[27] ^ Crc[29] ^ Crc[31] ^ Data[0] ^ Data[2] ^ Data[3] ^ Data[5] ^ Data[7];
    assign CrcNext[8] = Crc[0] ^ Crc[24] ^ Crc[25] ^ Crc[27] ^ Crc[28] ^ Data[0] ^ Data[1] ^ Data[3] ^ Data[4];
    assign CrcNext[9] = Crc[1] ^ Crc[25] ^ Crc[26] ^ Crc[28] ^ Crc[29] ^ Data[1] ^ Data[2] ^ Data[4] ^ Data[5];
    assign CrcNext[10] = Crc[2] ^ Crc[24] ^ Crc[26] ^ Crc[27] ^ Crc[29] ^ Data[0] ^ Data[2] ^ Data[3] ^ Data[5];
    assign CrcNext[11] = Crc[3] ^ Crc[24] ^ Crc[25] ^ Crc[27] ^ Crc[28] ^ Data[0] ^ Data[1] ^ Data[3] ^ Data[4];
    assign CrcNext[12] = Crc[4] ^ Crc[24] ^ Crc[25] ^ Crc[26] ^ Crc[28] ^ Crc[29] ^ Crc[30] ^ Data[0] ^ Data[1] ^ Data[2] ^ Data[4] ^ Data[5] ^ Data[6];
    assign CrcNext[13] = Crc[5] ^ Crc[25] ^ Crc[26] ^ Crc[27] ^ Crc[29] ^ Crc[30] ^ Crc[31] ^ Data[1] ^ Data[2] ^ Data[3] ^ Data[5] ^ Data[6] ^ Data[7];
    assign CrcNext[14] = Crc[6] ^ Crc[26] ^ Crc[27] ^ Crc[28] ^ Crc[30] ^ Crc[31] ^ Data[2] ^ Data[3] ^ Data[4] ^ Data[6] ^ Data[7];
    assign CrcNext[15] =  Crc[7] ^ Crc[27] ^ Crc[28] ^ Crc[29] ^ Crc[31] ^ Data[3] ^ Data[4] ^ Data[5] ^ Data[7];
    assign CrcNext[16] = Crc[8] ^ Crc[24] ^ Crc[28] ^ Crc[29] ^ Data[0] ^ Data[4] ^ Data[5];
    assign CrcNext[17] = Crc[9] ^ Crc[25] ^ Crc[29] ^ Crc[30] ^ Data[1] ^ Data[5] ^ Data[6];
    assign CrcNext[18] = Crc[10] ^ Crc[26] ^ Crc[30] ^ Crc[31] ^ Data[2] ^ Data[6] ^ Data[7];
    assign CrcNext[19] = Crc[11] ^ Crc[27] ^ Crc[31] ^ Data[3] ^ Data[7];
    assign CrcNext[20] = Crc[12] ^ Crc[28] ^ Data[4];
    assign CrcNext[21] = Crc[13] ^ Crc[29] ^ Data[5];
    assign CrcNext[22] = Crc[14] ^ Crc[24] ^ Data[0];
    assign CrcNext[23] = Crc[15] ^ Crc[24] ^ Crc[25] ^ Crc[30] ^ Data[0] ^ Data[1] ^ Data[6];
    assign CrcNext[24] = Crc[16] ^ Crc[25] ^ Crc[26] ^ Crc[31] ^ Data[1] ^ Data[2] ^ Data[7];
    assign CrcNext[25] = Crc[17] ^ Crc[26] ^ Crc[27] ^ Data[2] ^ Data[3];
    assign CrcNext[26] = Crc[18] ^ Crc[24] ^ Crc[27] ^ Crc[28] ^ Crc[30] ^ Data[0] ^ Data[3] ^ Data[4] ^ Data[6];
    assign CrcNext[27] = Crc[19] ^ Crc[25] ^ Crc[28] ^ Crc[29] ^ Crc[31] ^ Data[1] ^ Data[4] ^ Data[5] ^ Data[7];
    assign CrcNext[28] = Crc[20] ^ Crc[26] ^ Crc[29] ^ Crc[30] ^ Data[2] ^ Data[5] ^ Data[6];
    assign CrcNext[29] = Crc[21] ^ Crc[27] ^ Crc[30] ^ Crc[31] ^ Data[3] ^ Data[6] ^ Data[7];
    assign CrcNext[30] = Crc[22] ^ Crc[28] ^ Crc[31] ^ Data[4] ^ Data[7];
    assign CrcNext[31] = Crc[23] ^ Crc[29] ^ Data[5];

    always @ (posedge Clk,posedge Reset)
    if (Reset)
        Crc <={32{1'b1}};
   else if (Enable)
        Crc <= #1 CrcNext;

assign Crc_eth = ~{
                        CrcNext[24], CrcNext[25], CrcNext[26], CrcNext[27],CrcNext[28], CrcNext[29], CrcNext[30], CrcNext[31],
                        Crc[16], Crc[17], Crc[18], Crc[19],Crc[20], Crc[21], Crc[22], Crc[23],
                        Crc[ 8], Crc[ 9], Crc[10], Crc[11],Crc[12], Crc[13], Crc[14], Crc[15],
                        Crc[ 0], Crc[ 1], Crc[ 2], Crc[ 3],Crc[ 4], Crc[ 5], Crc[ 6], Crc[ 7]};        

endmodule

五、参考

　　【1】代码实现上参考了小梅哥和黑金的千兆网程序；

　　【2】文字叙述上参考了《基于ac620的fpga系统设计与验证实战指南20190516》，《开拓者FPGA开发指南_V1.2》，草山FPGA等；

　　

　　上面的文字中若有不当或者疏漏之处，还望各位道友能告知一二，我会立即订正~