• 以太网ARP测试实验

    1.1 ARP测试整体框架

            当上位机发送ARP请求时，FPGA返回ARP应答数据；当按下FPGA的触摸按键时，FPGA发送ARP请求，上位机返回ARP应答数据。

     PLL时钟对eth_rxc的输入时钟进行相位调整；GMII TO RGMI 模块负责将双沿(DDR)数据和单沿(SDR)数据之间的转换；ARP顶层模块实现了以太网ARP数据包的接收、发送以及CRC校验的功能；ARP控制模块根据输入的按键触摸信号和接收到的ARP请求信号，控制ARP顶层模块发送ARP请求或者ARP应答。

    1. module eth_arp_test(
    2.     input              sys_rst_n , //系统复位信号，低电平有效 
    3.     input              touch_key , //触摸按键,用于触发开发板发出ARP请求
    4.     //以太网RGMII接口   
    5.     input              eth_rxc   , //RGMII接收数据时钟
    6.     input              eth_rx_ctl, //RGMII输入数据有效信号
    7.     input       [3:0]  eth_rxd   , //RGMII输入数据
    8.     output             eth_txc   , //RGMII发送数据时钟    
    9.     output             eth_tx_ctl, //RGMII输出数据有效信号
    10.     output      [3:0]  eth_txd   , //RGMII输出数据          
    11.     output             eth_rst_n   //以太网芯片复位信号，低电平有效   
    12.     );
    13.  
    14.  
    15. //parameter define
    16. //开发板MAC地址 00-11-22-33-44-55
    17. parameter BOARD_MAC = 48'h00_11_22_33_44_55;    
    18. //开发板IP地址 192.168.1.10 
    19. parameter BOARD_IP  = {8'd192,8'd168,8'd1,8'd10};   
    20. //目的MAC地址 ff_ff_ff_ff_ff_ff           广播MAC地址，收到上位机的请求或应答后ARP模块会替换成真正的目的MAC地址
    21. parameter  DES_MAC   = 48'hff_ff_ff_ff_ff_ff;
    22. //目的IP地址 192.168.1.102                需要与电脑的以太网IP地址一致
    23. parameter  DES_IP    = {8'd192,8'd168,8'd1,8'd102};
    24.  
    25. //wire define      
    26. wire          eth_rxc_deg   ; //eth_rxc时钟相位偏移 
    27.  
    28. wire          gmii_rx_clk   ; //GMII接收时钟
    29. wire          gmii_rx_dv    ; //GMII接收数据有效信号
    30. wire  [7:0]   gmii_rxd      ; //GMII接收数据
    31. wire          gmii_tx_clk   ; //GMII发送时钟
    32. wire          gmii_tx_en    ; //GMII发送数据使能信号
    33. wire  [7:0]   gmii_txd      ; //GMII发送数据     
    34.  
    35. wire          arp_gmii_tx_en; //ARP GMII输出数据有效信号 
    36. wire  [7:0]   arp_gmii_txd  ; //ARP GMII输出数据
    37. wire          arp_rx_done   ; //ARP接收完成信号
    38. wire          arp_rx_type   ; //ARP接收类型 0:请求  1:应答
    39. wire  [47:0]  src_mac       ; //接收到目的MAC地址
    40. wire  [31:0]  src_ip        ; //接收到目的IP地址    
    41. wire          arp_tx_en     ; //ARP发送使能信号
    42. wire          arp_tx_type   ; //ARP发送类型 0:请求  1:应答
    43. wire  [47:0]  des_mac       ; //发送的目标MAC地址
    44. wire  [31:0]  des_ip        ; //发送的目标IP地址   
    45. wire          arp_tx_done   ; //ARP发送完成信号
    46.  
    47. //*****************************************************
    48. //**                    main code
    49. //*****************************************************
    50.  
    51. assign des_mac = src_mac;          //将收到的目的MAC地址和IP地址，作为FPGA发送时的目的MAC地址和IP地址
    52. assign des_ip = src_ip;
    53. assign eth_rst_n = sys_rst_n;
    54.  
    55. //PLL
    56. pll u_pll(
    57.     .inclk0  (eth_rxc),            //相位偏移180度
    58.     .c0      (eth_rxc_deg),
    59.     .locked  ()
    60.     );
    61.  
    62. //GMII接口转RGMII接口
    63. gmii_to_rgmii u_gmii_to_rgmii(
    65.     .gmii_rx_clk       (gmii_rx_clk ),
    66.     .gmii_rx_dv        (gmii_rx_dv  ),
    67.     .gmii_rxd          (gmii_rxd    ),
    68.     .gmii_tx_clk       (gmii_tx_clk ),   
    69.     .gmii_tx_en        (gmii_tx_en  ),
    70.     .gmii_txd          (gmii_txd    ),
    71.         
    72.     .rgmii_rxc         (eth_rxc_deg ),
    73.     .rgmii_rx_ctl      (eth_rx_ctl  ),
    74.     .rgmii_rxd         (eth_rxd     ),
    75.     .rgmii_txc         (eth_txc     ),
    76.     .rgmii_tx_ctl      (eth_tx_ctl  ),
    77.     .rgmii_txd         (eth_txd     )
    78.     );
    79.  
    80. //ARP通信
    81. arp                                             
    82.    #(
    83.     .BOARD_MAC     (BOARD_MAC),      //参数例化
    84.     .BOARD_IP      (BOARD_IP ),
    85.     .DES_MAC       (DES_MAC  ),
    86.     .DES_IP        (DES_IP   )
    87.     )
    88.    u_arp(
    89.     .rst_n         (sys_rst_n  ),
    90.                     
    91.     .gmii_rx_clk   (gmii_rx_clk),
    92.     .gmii_rx_dv    (gmii_rx_dv ),
    93.     .gmii_rxd      (gmii_rxd   ),
    94.     .gmii_tx_clk   (gmii_tx_clk),
    95.     .gmii_tx_en    (gmii_tx_en ),
    96.     .gmii_txd      (gmii_txd   ),
    97.                     
    98.     .arp_rx_done   (arp_rx_done),
    99.     .arp_rx_type   (arp_rx_type),
    100.     .src_mac       (src_mac    ),
    101.     .src_ip        (src_ip     ),
    102.     .arp_tx_en     (arp_tx_en  ),
    103.     .arp_tx_type   (arp_tx_type),
    104.     .des_mac       (des_mac    ),
    105.     .des_ip        (des_ip     ),
    106.     .tx_done       (tx_done    )
    107.     );
    108.  
    109. //ARP控制
    110. arp_ctrl u_arp_ctrl(
    111.     .clk           (gmii_rx_clk),
    112.     .rst_n         (sys_rst_n),
    113.                    
    114.     .touch_key     (touch_key),
    115.     .arp_rx_done   (arp_rx_done),
    116.     .arp_rx_type   (arp_rx_type),
    117.     .arp_tx_en     (arp_tx_en),
    118.     .arp_tx_type   (arp_tx_type)
    119.     );
    120.  
    121. endmodule

    1.2 GMII TO RGMII模块

    1. //实现双沿(DDR)和单沿(SDR)数据之间的转换
    2. module gmii_to_rgmii(
    3.     //以太网GMII接口
    4.     output             gmii_rx_clk     , //GMII接收时钟
    5.     output             gmii_rx_dv      , //GMII接收数据有效信号
    6.     output      [7:0]  gmii_rxd        , //GMII接收数据
    7.     output             gmii_tx_clk     , //GMII发送时钟 
    8.     input              gmii_tx_en      , //GMII发送数据使能信号
    9.     input       [7:0]  gmii_txd        , //GMII发送数据            
    10.     //以太网RGMII接口       
    11.     input              rgmii_rxc       , //RGMII接收时钟
    12.     input              rgmii_rx_ctl    , //RGMII接收数据控制信号
    13.     input       [3:0]  rgmii_rxd       , //RGMII接收数据
    14.     output             rgmii_txc       , //RGMII发送时钟    
    15.     output             rgmii_tx_ctl    , //RGMII发送数据控制信号
    16.     output      [3:0]  rgmii_txd         //RGMII发送数据          
    17.     );
    18.  
    19. //*****************************************************
    20. //**                    main code
    21. //*****************************************************
    22.  
    23. assign gmii_tx_clk = gmii_rx_clk;     //将GMII接收时钟赋值给GMII发送时钟，因此GMII的发送时钟和接收时钟为同一时钟
    24.  
    25. //RGMII接收
    26. rgmii_rx u_rgmii_rx(
    27.     .rgmii_rxc     (rgmii_rxc   ),
    28.     .rgmii_rx_ctl  (rgmii_rx_ctl),
    29.     .rgmii_rxd     (rgmii_rxd   ),
    30.     
    31.     .gmii_rx_dv    (gmii_rx_dv ),
    32.     .gmii_rxd      (gmii_rxd   ),
    33.     .gmii_rx_clk   (gmii_rx_clk)
    34.     );
    35.  
    36. //RGMII发送
    37. rgmii_tx u_rgmii_tx(
    38.     .gmii_tx_clk   (gmii_tx_clk ),
    39.     .gmii_tx_en    (gmii_tx_en  ),
    40.     .gmii_txd      (gmii_txd    ),
    41.               
    42.     .rgmii_txc     (rgmii_txc   ),
    43.     .rgmii_tx_ctl  (rgmii_tx_ctl),
    44.     .rgmii_txd     (rgmii_txd   )
    45.     );
    46.  
    47. endmodule

    关于 ALTDDIO_IN、ALTDDIO_OUT这两个IP核，可以参考：Altera（Quartus） IP核 ALTDDIO_IN、ALTDDIO_OUT（双倍数据速率I/O，DDIO）的使用和仿真_孤独的单刀的博客-CSDN博客

    1. module rgmii_rx(
    2.     //以太网RGMII接口
    3.     input              rgmii_rxc   , //RGMII接收时钟
    4.     input              rgmii_rx_ctl, //RGMII接收数据控制信号
    5.     input       [3:0]  rgmii_rxd   , //RGMII接收数据    
    6.  
    7.     //以太网GMII接口
    8.     output             gmii_rx_clk , //GMII接收时钟
    9.     output             gmii_rx_dv  , //GMII接收数据有效信号
    10.     output      [7:0]  gmii_rxd      //GMII接收数据   
    11.     );   
    12.  
    13. //wire define    
    14. wire  [1:0]  gmii_rxdv_t;        //两位GMII接收有效信号 
    15.  
    16. //*****************************************************
    17. //**                    main code
    18. //*****************************************************
    19.  
    20. assign gmii_rx_clk = rgmii_rxc;
    21. assign gmii_rx_dv = gmii_rxdv_t[0] & gmii_rxdv_t[1];
    22.  
    23. //通过ALTDDIO_IN这个IP实现双沿(DDR)和单沿(SDR)数据之间的转换
    24. ddi_x4 ddi_x4_inst(
    25.     .datain     (rgmii_rxd    ),    //datain，DDR输入端口
    26.     .inclock    (rgmii_rxc    ),    //inclock，DDR输入数据的采样时钟信号，在时钟信号的每个时钟边缘上对数据端口进行采样
    27.     .dataout_h  (gmii_rxd[7:4]),    //dataout_h，在inclock时钟上升沿输出的数据
    28.     .dataout_l  (gmii_rxd[3:0])     //dataout_l，在inclock时钟下降沿输出的数据
    29. );
    30.  
    31. ddi_x1 ddi_x1_inst(
    32.     .datain     (rgmii_rx_ctl),
    33.     .inclock    (rgmii_rxc  ),
    34.     .dataout_h  (gmii_rxdv_t[1]),
    35.     .dataout_l  (gmii_rxdv_t[0])
    36. );
    37.  
    38. endmodule

    Width是代表输入端的位宽，RGMII接口是4位输入，所以这里将其设为4
    Asynchronous clear and asynchronous set ports选项是表示端口是否需要复位，这里选择 Not used
    Use'inclocken’ports表示是否使用输入时钟使能，这里选择不使用
    Invert input clock表示输入时钟上升边缘上的第一个数据位是否被捕获。如果不启用，则在输入时钟的下降沿上捕获数据的第一个位，启用表示在输入时钟的上升沿上捕获数据的第一个位，这里选择不使用

    1. module rgmii_tx(
    2.     //GMII发送端口
    3.     input              gmii_tx_clk ,   //GMII发送时钟 
    4.     input              gmii_tx_en  ,   //GMII输出数据有效信号
    5.     input       [7:0]  gmii_txd    ,   //GMII输出数据        
    6.     
    7.     //RGMII发送端口
    8.     output             rgmii_txc   ,   //RGMII发送数据时钟    
    9.     output             rgmii_tx_ctl,   //RGMII输出数据有效信号
    10.     output      [3:0]  rgmii_txd       //RGMII输出数据     
    11.     );
    12.  
    13. //*****************************************************
    14. //**                    main code
    15. //*****************************************************
    16.  
    17. //通过ALTDDIO OUT这个IP实现SDR与DDR之间的转换
    18. ddo_x4 ddo_x4_inst(
    19.     .datain_h(gmii_txd[3:0]),
    20.     .datain_l(gmii_txd[7:4]),
    21.     .outclock(gmii_tx_clk),
    22.     .dataout(rgmii_txd)
    23. );
    24.  
    25. ddo_x1 ddo_x1_inst(
    26.     .datain_h(gmii_tx_en),
    27.     .datain_l(gmii_tx_en ), 
    28.     .outclock(gmii_tx_clk),
    29.     .dataout(rgmii_tx_ctl)
    30. );
    31.  
    32. ddo_x1 ddo_x1_clk(
    33.     .datain_h(1'b1),
    34.     .datain_l(1'b0),
    35.     .outclock(gmii_tx_clk), 
    36.     .dataout(rgmii_txc)
    37. );
    38.  
    39. endmodule

    1.3 ARP模块 

    1. module arp(
    2.     input                rst_n      , //复位信号，低电平有效
    3.     //GMII接口
    4.     input                gmii_rx_clk, //GMII接收数据时钟
    5.     input                gmii_rx_dv , //GMII输入数据有效信号
    6.     input        [7:0]   gmii_rxd   , //GMII输入数据
    7.     input                gmii_tx_clk, //GMII发送数据时钟
    8.     output               gmii_tx_en , //GMII输出数据有效信号
    9.     output       [7:0]   gmii_txd   , //GMII输出数据          
    11.     //用户接口
    12.     output               arp_rx_done, //ARP接收完成信号
    13.     output               arp_rx_type, //ARP接收类型 0:请求  1:应答
    14.     output       [47:0]  src_mac    , //接收到目的MAC地址
    15.     output       [31:0]  src_ip     , //接收到目的IP地址    
    16.     input                arp_tx_en  , //ARP发送使能信号
    17.     input                arp_tx_type, //ARP发送类型 0:请求  1:应答
    18.     input        [47:0]  des_mac    , //发送的目标MAC地址
    19.     input        [31:0]  des_ip     , //发送的目标IP地址
    20.     output               tx_done      //以太网发送完成信号    
    21.     );
    22.  
    23. //parameter define
    24. //开发板MAC地址 00-11-22-33-44-55
    25. parameter BOARD_MAC = 48'h00_11_22_33_44_55;    
    26. //开发板IP地址 192.168.1.10 
    27. parameter BOARD_IP  = {8'd192,8'd168,8'd1,8'd10};   
    28. //目的MAC地址 ff_ff_ff_ff_ff_ff           广播MAC地址，收到上位机的请求或应答后ARP模块会替换成真正的目的MAC地址
    29. parameter  DES_MAC   = 48'hff_ff_ff_ff_ff_ff;
    30. //目的IP地址 192.168.1.102                需要与电脑的以太网IP地址一致
    31. parameter  DES_IP    = {8'd192,8'd168,8'd1,8'd102};
    32.  
    33.  
    34.  
    35. //wire define
    36. wire           crc_en  ; //CRC开始校验使能
    37. wire           crc_clr ; //CRC数据复位信号 
    38. wire   [7:0]   crc_d8  ; //输入待校验8位数据
    39. wire   [31:0]  crc_data; //CRC校验数据
    40. wire   [31:0]  crc_next; //CRC下次校验完成数据
    41.  
    42. //*****************************************************
    43. //**                    main code
    44. //*****************************************************
    45.  
    46. assign  crc_d8 = gmii_txd;
    47.  
    48. //ARP接收模块    
    49. arp_rx 
    50.    #(
    51.     .BOARD_MAC       (BOARD_MAC),         //参数例化
    52.     .BOARD_IP        (BOARD_IP )
    53.     )
    54.    u_arp_rx(
    55.     .clk             (gmii_rx_clk),
    56.     .rst_n           (rst_n),
    57.  
    58.     .gmii_rx_dv      (gmii_rx_dv),
    59.     .gmii_rxd        (gmii_rxd  ),
    60.     .arp_rx_done     (arp_rx_done),
    61.     .arp_rx_type     (arp_rx_type),
    62.     .src_mac         (src_mac    ),
    63.     .src_ip          (src_ip     )
    64.     );                                           
    65.  
    66. //ARP发送模块
    67. arp_tx
    68.    #(
    69.     .BOARD_MAC       (BOARD_MAC),         //参数例化
    70.     .BOARD_IP        (BOARD_IP ),
    71.     .DES_MAC         (DES_MAC  ),
    72.     .DES_IP          (DES_IP   )
    73.     )
    74.    u_arp_tx(
    75.     .clk             (gmii_tx_clk),
    76.     .rst_n           (rst_n),
    77.  
    78.     .arp_tx_en       (arp_tx_en ),
    79.     .arp_tx_type     (arp_tx_type),
    80.     .des_mac         (des_mac   ),
    81.     .des_ip          (des_ip    ),
    82.     .crc_data        (crc_data  ),
    83.     .crc_next        (crc_next[31:24]),
    84.     .tx_done         (tx_done   ),
    85.     .gmii_tx_en      (gmii_tx_en),
    86.     .gmii_txd        (gmii_txd  ),
    87.     .crc_en          (crc_en    ),
    88.     .crc_clr         (crc_clr   )
    89.     );     
    90.  
    91. //以太网发送CRC校验模块
    92. crc32_d8   u_crc32_d8(
    93.     .clk             (gmii_tx_clk),                      
    94.     .rst_n           (rst_n      ),                          
    95.     .data            (crc_d8     ),            
    96.     .crc_en          (crc_en     ),                          
    97.     .crc_clr         (crc_clr    ),                         
    98.     .crc_data        (crc_data   ),                        
    99.     .crc_next        (crc_next   )                         
    100.     );
    101.  
    102. endmodule

    1.3.1 ARP接收模块 

    1. //ARP接收模块负责解析以太网的数据，判断目的MAC地址和目的IP地址是否为开发板的地址，然后按照ARP协议将数据解析出来
    2. module arp_rx
    3.   #(
    4.     //开发板MAC地址 00-11-22-33-44-55
    5.     parameter BOARD_MAC = 48'h00_11_22_33_44_55,  
    6.     //开发板IP地址 192.168.1.10   
    7.     parameter BOARD_IP = {8'd192,8'd168,8'd1,8'd10}      
    8.     )
    9.    (
    10.     input                clk        , //时钟信号
    11.     input                rst_n      , //复位信号，低电平有效
    12.                                     
    13.     input                gmii_rx_dv , //GMII输入数据有效信号
    14.     input        [7:0]   gmii_rxd   , //GMII输入数据
    15.     output  reg          arp_rx_done, //ARP接收完成信号
    16.     output  reg          arp_rx_type, //ARP接收类型 0:请求  1:应答
    17.     output  reg  [47:0]  src_mac    , //接收到的源MAC地址
    18.     output  reg  [31:0]  src_ip       //接收到的源IP地址
    19.     );
    20.  
    21. //parameter define
    22. localparam  st_idle     = 5'b0_0001; //初始状态，等待接收前导码
    23. localparam  st_preamble = 5'b0_0010; //接收前导码状态 
    24. localparam  st_eth_head = 5'b0_0100; //接收以太网帧头
    25. localparam  st_arp_data = 5'b0_1000; //接收ARP数据
    26. localparam  st_rx_end   = 5'b1_0000; //接收结束
    27.  
    28. localparam  ETH_TPYE = 16'h0806;     //以太网帧类型ARP
    29.  
    30. //reg define
    31. reg    [4:0]   cur_state ;
    32. reg    [4:0]   next_state;
    33.                          
    34. reg            skip_en   ; //控制状态跳转使能信号
    35. reg            error_en  ; //解析错误使能信号
    36. reg    [4:0]   cnt       ; //解析数据计数器
    37. reg    [47:0]  des_mac_t ; //接收到的目的MAC地址
    38. reg    [31:0]  des_ip_t  ; //接收到的目的IP地址
    39. reg    [47:0]  src_mac_t ; //接收到的源MAC地址
    40. reg    [31:0]  src_ip_t  ; //接收到的源IP地址
    41. reg    [15:0]  eth_type  ; //以太网类型
    42. reg    [15:0]  op_data   ; //操作码
    43. reg            rx_done_t ; //ARP接收完成信号
    44.  
    45. //*****************************************************
    46. //**                    main code
    47. //*****************************************************
    48.  
    49. //(三段式状态机)同步时序描述状态转移
    50. always @(posedge clk or negedge rst_n) begin
    51.     if(!rst_n)
    52.         cur_state <= st_idle;  
    53.     else
    54.         cur_state <= next_state;
    55. end
    56.  
    57. //组合逻辑判断状态转移条件
    58. always @(*) begin
    59.     next_state = st_idle;                   //默认在空闲状态
    60.     case(cur_state)
    61.         st_idle : begin                     //等待接收前导码
    62.             if(skip_en)                     //当控制状态跳转使能信号有效，跳转到接收前导码
    63.                 next_state = st_preamble;
    64.             else
    65.                 next_state = st_idle;       //否则一直保持在空闲状态
    66.         end
    67.         st_preamble : begin                 //接收前导码
    68.             if(skip_en) 
    69.                 next_state = st_eth_head;
    70.             else if(error_en) 
    71. 				//在中间状态如前导码错误、MAC地址错误以及IP地址等错误时跳转到st_rx_end状态，而不是跳转到st_idle状态
    72. 				//因为中间状态在解析到数据错误时，单包数据的接收还没有结束，如果此时跳转到st_idle状态会误把有效数据当成前导码来解析
    73.                 next_state = st_rx_end;
    74.             else
    75.                 next_state = st_preamble;   
    76.         end
    77.         st_eth_head : begin                 //接收以太网帧头
    78.             if(skip_en) 
    79.                 next_state = st_arp_data;
    80.             else if(error_en) 
    81.                 next_state = st_rx_end;     //跳转到st_rx_end状态，而非跳转到st_idle状态
    82.             else
    83.                 next_state = st_eth_head;   
    84.         end  
    85.         st_arp_data : begin                 //接收ARP数据
    86.             if(skip_en)
    87.                 next_state = st_rx_end;
    88.             else if(error_en)
    89.                 next_state = st_rx_end;     //跳转到st_rx_end状态，而非跳转到st_idle状态
    90.             else
    91.                 next_state = st_arp_data;   
    92.         end                  
    93.         st_rx_end : begin                   //接收结束
    94.             if(skip_en)
    95.                 next_state = st_idle;
    96.             else
    97.                 next_state = st_rx_end;          
    98.         end
    99.         default : next_state = st_idle;
    100.     endcase                                          
    101. end    
    102.  
    103. //时序电路描述状态输出,解析以太网数据
    104. always @(posedge clk or negedge rst_n) begin
    105.     if(!rst_n) begin
    106.         skip_en <= 1'b0;
    107.         error_en <= 1'b0;
    108.         cnt <= 5'd0;
    109.         des_mac_t <= 48'd0;
    110.         des_ip_t <= 32'd0;
    111.         src_mac_t <= 48'd0;
    112.         src_ip_t <= 32'd0;        
    113.         eth_type <= 16'd0;
    114.         op_data <= 16'd0;
    115.         rx_done_t <= 1'b0;
    116.         arp_rx_type <= 1'b0;
    117.         src_mac <= 48'd0;
    118.         src_ip <= 32'd0;
    119.     end
    120.     else begin
    121.         skip_en <= 1'b0;
    122.         error_en <= 1'b0; 
    123.         rx_done_t <= 1'b0;
    124.         case(next_state)
    125.             st_idle : begin                                  //检测到第一个8'h55
    126.                 if((gmii_rx_dv == 1'b1) && (gmii_rxd == 8'h55))   //gmii_rx_dv信号拉高表示此时有输入的数据，根据gmii_rxd来解析数据
    127.                     skip_en <= 1'b1;
    128.             end
    129.             st_preamble : begin
    130.                 if(gmii_rx_dv) begin                         //解析前导码
    131.                     cnt <= cnt + 5'd1;
    132.                     if((cnt < 5'd6) && (gmii_rxd != 8'h55))  //如果不是连续7个字节的0x55则出现错误
    133.                         error_en <= 1'b1;
    134.                     else if(cnt==5'd6) begin                 //计数到6，即连续7个字节的0x55，前导码正确
    135.                         cnt <= 5'd0;
    136.                         if(gmii_rxd==8'hd5)                  //接下来的数据是8'hd5，说明帧起始定界符正确
    137.                             skip_en <= 1'b1;                 //前导码和起始定界符解析完毕，可以跳转
    138.                         else
    139.                             error_en <= 1'b1;    
    140.                     end  
    141.                 end  
    142.             end
    143.             st_eth_head : begin                              //解析帧头
    144.                 if(gmii_rx_dv) begin
    145.                     cnt <= cnt + 5'b1;
    146.                     if(cnt < 5'd6)                           //目的MAC地址小于6个字节，则将GMII输入数据添加到目标MAC地址寄存器
    147.                         des_mac_t <= {des_mac_t[39:0],gmii_rxd};  //取des_mac_t的低40位与8位的gmii_rxd拼接，将gmii_rxd放在低八位形成左移
    148.                     else if(cnt == 5'd6) begin
    149.                         //判断MAC地址是否为开发板MAC地址或者公共地址
    150.                         if((des_mac_t != BOARD_MAC)
    151.                             && (des_mac_t != 48'hff_ff_ff_ff_ff_ff))           
    152.                             error_en <= 1'b1;
    153.                     end
    154.                     else if(cnt == 5'd12)                    //计数到12，即该解析类型/长度
    155.                         eth_type[15:8] <= gmii_rxd;
    156.                     else if(cnt == 5'd13) begin
    157.                         eth_type[7:0] <= gmii_rxd;
    158.                         cnt <= 5'd0;
    159.                         if(eth_type[15:8] == ETH_TPYE[15:8]  //判断是否为ARP协议
    160.                             && gmii_rxd == ETH_TPYE[7:0])
    161.                             skip_en <= 1'b1; 
    162.                         else
    163.                             error_en <= 1'b1;                       
    164.                     end        
    165.                 end  
    166.             end
    167.             st_arp_data : begin                              //解析数据
    168.                 if(gmii_rx_dv) begin
    169.                     cnt <= cnt + 5'd1;
    170.                     if(cnt == 5'd6) 
    171.                         op_data[15:8] <= gmii_rxd;           //操作码      
    172.                     else if(cnt == 5'd7)
    173.                         op_data[7:0] <= gmii_rxd;
    174.                     else if(cnt >= 5'd8 && cnt < 5'd14)      //源MAC地址
    175.                         src_mac_t <= {src_mac_t[39:0],gmii_rxd};
    176.                     else if(cnt >= 5'd14 && cnt < 5'd18)     //源IP地址
    177.                         src_ip_t<= {src_ip_t[23:0],gmii_rxd};
    178.                     else if(cnt >= 5'd24 && cnt < 5'd28)     //目标IP地址
    179.                         des_ip_t <= {des_ip_t[23:0],gmii_rxd};
    180.                     else if(cnt == 5'd28) begin
    181.                         cnt <= 5'd0;
    182.                         if(des_ip_t == BOARD_IP) begin       //判断目的IP地址和OP操作码是否正确
    183.                             if((op_data == 16'd1) || (op_data == 16'd2)) begin
    184.                                 skip_en <= 1'b1;
    185.                                 rx_done_t <= 1'b1;
    186.                                 src_mac <= src_mac_t;
    187.                                 src_ip <= src_ip_t;
    188.                                 src_mac_t <= 48'd0;
    189.                                 src_ip_t <= 32'd0;
    190.                                 des_mac_t <= 48'd0;
    191.                                 des_ip_t <= 32'd0;
    192.                                 if(op_data == 16'd1)         
    193.                                     arp_rx_type <= 1'b0;     //ARP请求
    194.                                 else
    195.                                     arp_rx_type <= 1'b1;     //ARP应答
    196.                             end
    197.                             else
    198.                                 error_en <= 1'b1;
    199.                         end 
    200.                         else
    201.                             error_en <= 1'b1;
    202.                     end
    203.                 end                                
    204.             end
    205.             st_rx_end : begin     
    206.                 cnt <= 5'd0;
    207.                 //单包数据接收完成   
    208.                 if(gmii_rx_dv == 1'b0 && skip_en == 1'b0)
    209.                     skip_en <= 1'b1; 
    210.             end    
    211.             default : ;
    212.         endcase                                                        
    213.     end
    214. end
    215.  
    216. 当解析到正确的ARP数据包后，拉高arp_rx_done信号，持续一个时钟周期
    217. always @(posedge clk or negedge rst_n) begin
    218.     if(!rst_n)
    219.         arp_rx_done <= 1'b0;
    220.     else
    221.         arp_rx_done <= rx_done_t;
    222. end
    223.  
    224. endmodule

    1.3.2 ARP发送模块 

     

    1. //ARP发送模块根据以太网格式和ARP协议发送ARP请求或者ARP应答数据
    2. module arp_tx( 
    3.     input                clk        , //时钟信号
    4.     input                rst_n      , //复位信号，低电平有效
    5.     
    6.     input                arp_tx_en  , //ARP发送使能信号
    7.     input                arp_tx_type, //ARP发送类型 0:请求  1:应答
    8.     input        [47:0]  des_mac    , //发送的目标MAC地址
    9.     input        [31:0]  des_ip     , //发送的目标IP地址
    10.     input        [31:0]  crc_data   , //CRC校验数据
    11.     input         [7:0]  crc_next   , //CRC下次校验完成数据
    12.     output  reg          tx_done    , //以太网发送完成信号
    13.     output  reg          gmii_tx_en , //GMII输出数据有效信号
    14.     output  reg  [7:0]   gmii_txd   , //GMII输出数据
    15.     output  reg          crc_en     , //CRC开始校验使能
    16.     output  reg          crc_clr      //CRC数据复位信号 
    17.     );
    18.  
    19. //parameter define
    20. //开发板MAC地址 00-11-22-33-44-55
    21. parameter BOARD_MAC = 48'h00_11_22_33_44_55;
    22. //开发板IP地址 192.168.1.10
    23. parameter BOARD_IP  = {8'd192,8'd168,8'd1,8'd10}; 
    24. //目的MAC地址 ff_ff_ff_ff_ff_ff
    25. parameter  DES_MAC   = 48'hff_ff_ff_ff_ff_ff;
    26. //目的IP地址 192.168.1.102     
    27. parameter  DES_IP    = {8'd192,8'd168,8'd1,8'd102};
    28.  
    29. localparam  st_idle      = 5'b0_0001; //初始状态，等待开始发送信号
    30. localparam  st_preamble  = 5'b0_0010; //发送前导码+帧起始界定符
    31. localparam  st_eth_head  = 5'b0_0100; //发送以太网帧头
    32. localparam  st_arp_data  = 5'b0_1000; //发送arp数据
    33. localparam  st_crc       = 5'b1_0000; //发送CRC校验值
    34.  
    35. localparam  ETH_TYPE     = 16'h0806 ; //以太网帧类型 ARP协议
    36. localparam  HD_TYPE      = 16'h0001 ; //硬件类型 以太网
    37. localparam  PROTOCOL_TYPE= 16'h0800 ; //上层协议为IP协议
    38. //以太网数据最小为46个字节,不足部分填充数据
    39. localparam  MIN_DATA_NUM = 16'd46   ;    
    40.  
    41. //reg define
    42. reg  [4:0]  cur_state     ;
    43. reg  [4:0]  next_state    ;
    44.                           
    45. reg  [7:0]  preamble[7:0] ; //前导码+SFD
    46. reg  [7:0]  eth_head[13:0]; //以太网首部
    47. reg  [7:0]  arp_data[27:0]; //ARP数据
    48.                             
    49. reg         tx_en_d0      ; //arp_tx_en信号延时
    50. reg         tx_en_d1      ; 
    51. reg         skip_en       ; //控制状态跳转使能信号
    52. reg  [5:0]  cnt           ; 
    53. reg  [4:0]  data_cnt      ; //发送数据个数计数器
    54. reg         tx_done_t     ; 
    55.                                 
    56. //wire define                   
    57. wire        pos_tx_en     ; //arp_tx_en信号上升沿
    58.  
    59. //*****************************************************
    60. //**                    main code
    61. //*****************************************************
    62.  
    63. assign  pos_tx_en = (~tx_en_d1) & tx_en_d0;
    64.                            
    65. //对arp_tx_en信号延时打拍两次,用于采arp_tx_en的上升沿
    66. always @(posedge clk or negedge rst_n) begin
    67.     if(!rst_n) begin
    68.         tx_en_d0 <= 1'b0;
    69.         tx_en_d1 <= 1'b0;
    70.     end    
    71.     else begin
    72.         tx_en_d0 <= arp_tx_en;
    73.         tx_en_d1 <= tx_en_d0;
    74.     end
    75. end 
    76.  
    77. //(三段式状态机)同步时序描述状态转移
    78. always @(posedge clk or negedge rst_n) begin
    79.     if(!rst_n)
    80.         cur_state <= st_idle;  
    81.     else
    82.         cur_state <= next_state;
    83. end
    84.  
    85. //组合逻辑判断状态转移条件
    86. always @(*) begin
    87.     next_state = st_idle;
    88.     case(cur_state)
    89.         st_idle : begin                     //空闲状态
    90.             if(skip_en)                
    91.                 next_state = st_preamble;
    92.             else
    93.                 next_state = st_idle;
    94.         end                          
    95.         st_preamble : begin                 //发送前导码+帧起始界定符
    96.             if(skip_en)
    97.                 next_state = st_eth_head;
    98.             else
    99.                 next_state = st_preamble;      
    100.         end
    101.         st_eth_head : begin                 //发送以太网首部
    102.             if(skip_en)
    103.                 next_state = st_arp_data;
    104.             else
    105.                 next_state = st_eth_head;      
    106.         end              
    107.         st_arp_data : begin                 //发送ARP数据                      
    108.             if(skip_en)
    109.                 next_state = st_crc;
    110.             else
    111.                 next_state = st_arp_data;      
    112.         end
    113.         st_crc: begin                       //发送CRC校验值
    114.             if(skip_en)
    115.                 next_state = st_idle;
    116.             else
    117.                 next_state = st_crc;      
    118.         end
    119.         default : next_state = st_idle;   
    120.     endcase
    121. end                      
    122.  
    123. //时序电路描述状态输出，发送以太网数据
    124. always @(posedge clk or negedge rst_n) begin
    125.     if(!rst_n) begin
    126.         skip_en <= 1'b0; 
    127.         cnt <= 6'd0;
    128.         data_cnt <= 5'd0;
    129.         crc_en <= 1'b0;
    130.         gmii_tx_en <= 1'b0;
    131.         gmii_txd <= 8'd0;
    132.         tx_done_t <= 1'b0; 
    133.         
    134.         //在复位时初始化数组    
    135.         //前导码 7个8'h55 + 1个8'hd5 
    136.         preamble[0] <= 8'h55;                
    137.         preamble[1] <= 8'h55;
    138.         preamble[2] <= 8'h55;
    139.         preamble[3] <= 8'h55;
    140.         preamble[4] <= 8'h55;
    141.         preamble[5] <= 8'h55;
    142.         preamble[6] <= 8'h55;
    143.         preamble[7] <= 8'hd5;
    144.         //以太网帧头 
    145.         eth_head[0] <= DES_MAC[47:40];      //目的MAC地址
    146.         eth_head[1] <= DES_MAC[39:32];
    147.         eth_head[2] <= DES_MAC[31:24];
    148.         eth_head[3] <= DES_MAC[23:16];
    149.         eth_head[4] <= DES_MAC[15:8];
    150.         eth_head[5] <= DES_MAC[7:0];        
    151.         eth_head[6] <= BOARD_MAC[47:40];    //源MAC地址
    152.         eth_head[7] <= BOARD_MAC[39:32];    
    153.         eth_head[8] <= BOARD_MAC[31:24];    
    154.         eth_head[9] <= BOARD_MAC[23:16];    
    155.         eth_head[10] <= BOARD_MAC[15:8];    
    156.         eth_head[11] <= BOARD_MAC[7:0];     
    157.         eth_head[12] <= ETH_TYPE[15:8];     //以太网帧类型
    158.         eth_head[13] <= ETH_TYPE[7:0];      
    159.         //ARP数据                           
    160.         arp_data[0] <= HD_TYPE[15:8];       //硬件类型
    161.         arp_data[1] <= HD_TYPE[7:0];
    162.         arp_data[2] <= PROTOCOL_TYPE[15:8]; //上层协议类型
    163.         arp_data[3] <= PROTOCOL_TYPE[7:0];
    164.         arp_data[4] <= 8'h06;               //硬件地址长度,6
    165.         arp_data[5] <= 8'h04;               //协议地址长度,4
    166.         arp_data[6] <= 8'h00;               //OP,操作码 8'h01：ARP请求 8'h02:ARP应答
    167.         arp_data[7] <= 8'h01;
    168.         arp_data[8] <= BOARD_MAC[47:40];    //发送端(源)MAC地址
    169.         arp_data[9] <= BOARD_MAC[39:32];
    170.         arp_data[10] <= BOARD_MAC[31:24];
    171.         arp_data[11] <= BOARD_MAC[23:16];
    172.         arp_data[12] <= BOARD_MAC[15:8];
    173.         arp_data[13] <= BOARD_MAC[7:0];
    174.         arp_data[14] <= BOARD_IP[31:24];    //发送端(源)IP地址
    175.         arp_data[15] <= BOARD_IP[23:16];
    176.         arp_data[16] <= BOARD_IP[15:8];
    177.         arp_data[17] <= BOARD_IP[7:0];
    178.         arp_data[18] <= DES_MAC[47:40];     //接收端(目的)MAC地址
    179.         arp_data[19] <= DES_MAC[39:32];
    180.         arp_data[20] <= DES_MAC[31:24];
    181.         arp_data[21] <= DES_MAC[23:16];
    182.         arp_data[22] <= DES_MAC[15:8];
    183.         arp_data[23] <= DES_MAC[7:0];  
    184.         arp_data[24] <= DES_IP[31:24];      //接收端(目的)IP地址
    185.         arp_data[25] <= DES_IP[23:16];
    186.         arp_data[26] <= DES_IP[15:8];
    187.         arp_data[27] <= DES_IP[7:0];
    188.     end
    189.     else begin
    190.         skip_en <= 1'b0;
    191.         crc_en <= 1'b0;
    192.         gmii_tx_en <= 1'b0;
    193.         tx_done_t <= 1'b0;
    194.         case(next_state)
    195.             st_idle : begin
    196.                 if(pos_tx_en) begin
    197.                     skip_en <= 1'b1;  
    198.                     //如果目标MAC地址和IP地址已经更新,则发送正确的地址
    199.                     if((des_mac != 48'b0) || (des_ip != 32'd0)) begin  //根据输入的发送类型、目的MAC地址和IP地址，更新数组里的值
    200.                         eth_head[0] <= des_mac[47:40];
    201.                         eth_head[1] <= des_mac[39:32];
    202.                         eth_head[2] <= des_mac[31:24];
    203.                         eth_head[3] <= des_mac[23:16];
    204.                         eth_head[4] <= des_mac[15:8];
    205.                         eth_head[5] <= des_mac[7:0];  
    206.                         arp_data[18] <= des_mac[47:40];
    207.                         arp_data[19] <= des_mac[39:32];
    208.                         arp_data[20] <= des_mac[31:24];
    209.                         arp_data[21] <= des_mac[23:16];
    210.                         arp_data[22] <= des_mac[15:8];
    211.                         arp_data[23] <= des_mac[7:0];  
    212.                         arp_data[24] <= des_ip[31:24];
    213.                         arp_data[25] <= des_ip[23:16];
    214.                         arp_data[26] <= des_ip[15:8];
    215.                         arp_data[27] <= des_ip[7:0];
    216.                     end
    217.                     if(arp_tx_type == 1'b0)
    218.                         arp_data[7] <= 8'h01;            //ARP请求 
    219.                     else 
    220.                         arp_data[7] <= 8'h02;            //ARP应答
    221.                 end    
    222.             end                                                                   
    223.             st_preamble : begin                          //发送前导码+帧起始界定符
    224.                 gmii_tx_en <= 1'b1;
    225.                 gmii_txd <= preamble[cnt];
    226.                 if(cnt == 6'd7) begin                        
    227.                     skip_en <= 1'b1;
    228.                     cnt <= 1'b0;    
    229.                 end
    230.                 else    
    231.                     cnt <= cnt + 1'b1;                     
    232.             end
    233.             st_eth_head : begin                          //发送以太网首部
    234.                 gmii_tx_en <= 1'b1;
    235.                 crc_en <= 1'b1;
    236.                 gmii_txd <= eth_head[cnt];
    237.                 if (cnt == 6'd13) begin
    238.                     skip_en <= 1'b1;
    239.                     cnt <= 1'b0;
    240.                 end    
    241.                 else    
    242.                     cnt <= cnt + 1'b1;    
    243.             end                    
    244.             st_arp_data : begin                          //发送ARP数据  
    245.                 crc_en <= 1'b1;
    246.                 gmii_tx_en <= 1'b1;
    247.                 //至少发送46个字节
    248.                 if (cnt == MIN_DATA_NUM - 1'b1) begin    
    249.                     skip_en <= 1'b1;
    250.                     cnt <= 1'b0;
    251.                     data_cnt <= 1'b0;
    252.                 end    
    253.                 else    
    254.                     cnt <= cnt + 1'b1;  
    255.                 if(data_cnt <= 6'd27) begin
    256.                     data_cnt <= data_cnt + 1'b1;
    257.                     gmii_txd <= arp_data[data_cnt];
    258.                 end    
    259.                 else
    260.                     gmii_txd <= 8'd0;                    //Padding,填充0
    261.             end
    262.             st_crc      : begin                          //发送CRC校验值
    263.                 gmii_tx_en <= 1'b1;
    264.                 cnt <= cnt + 1'b1;
    265.                 if(cnt == 6'd0)    //将输入的crc的计算结果每4位高低位互换
    266.                     gmii_txd <= {~crc_next[0], ~crc_next[1], ~crc_next[2],~crc_next[3],
    267.                                  ~crc_next[4], ~crc_next[5], ~crc_next[6],~crc_next[7]};
    268.                 else if(cnt == 6'd1)
    269.                     gmii_txd <= {~crc_data[16], ~crc_data[17], ~crc_data[18],
    270.                                  ~crc_data[19], ~crc_data[20], ~crc_data[21], 
    271.                                  ~crc_data[22],~crc_data[23]};
    272.                 else if(cnt == 6'd2) begin
    273.                     gmii_txd <= {~crc_data[8], ~crc_data[9], ~crc_data[10],
    274.                                  ~crc_data[11],~crc_data[12], ~crc_data[13], 
    275.                                  ~crc_data[14],~crc_data[15]};                              
    276.                 end
    277.                 else if(cnt == 6'd3) begin
    278.                     gmii_txd <= {~crc_data[0], ~crc_data[1], ~crc_data[2],~crc_data[3],
    279.                                  ~crc_data[4], ~crc_data[5], ~crc_data[6],~crc_data[7]};  
    280.                     tx_done_t <= 1'b1;
    281.                     skip_en <= 1'b1;
    282.                     cnt <= 1'b0;
    283.                 end                                                
    284.             end                          
    285.             default :;  
    286.         endcase                                             
    287.     end
    288. end            
    289.  
    290. //发送完成信号及crc值复位信号
    291. always @(posedge clk or negedge rst_n) begin
    292.     if(!rst_n) begin
    293.         tx_done <= 1'b0;
    294.         crc_clr <= 1'b0;
    295.     end
    296.     else begin
    297.         tx_done <= tx_done_t;
    298.         crc_clr <= tx_done_t;
    299.     end
    300. end
    301.  
    302. endmodule

    1.3.3 CRC校验模块 

    1. //CRC校验模块是对ARP发送模块的数据(不包括前导码和起始界定符)做校验，把校验结果值拼在以太网顿格式的FCS字段
    2. //如果CRC校验值计算错误或者没有的话，那么电脑网卡会直接丢弃该倾导致收不到数据
    3. //CRC32校验在FPGA实现的原理是LFSR (Linear Feedback Shift Register，线性反馈移位寄存器)
    4. //其思想是各个寄存器储存着上一次CRC32运算的结果，寄存器的输出即为CRC32的值
    5. //本次实验只对发送模块做校验，没有对接收模块做校验。
    6. //因为可以直接通过解析出的数据来大致判断接收是否正确，而发送模块必须发送正确的校验数据，否则发送的数据直接丢弃，导致ARP请求或者应答失败
    7. //可通过http://www.easics.com/webtools/crctool生成CRC校验的源代码
    8. module crc32_d8(
    9.     input                 clk     ,  //时钟信号
    10.     input                 rst_n   ,  //复位信号，低电平有效
    11.     input         [7:0]   data    ,  //输入待校验8位数据
    12.     input                 crc_en  ,  //crc使能，开始校验标志
    13.     input                 crc_clr ,  //crc数据复位信号            
    14.     output   reg  [31:0]  crc_data,  //CRC校验数据
    15.     output        [31:0]  crc_next   //CRC下次校验完成数据
    16.     );
    17.  
    18. //*****************************************************
    19. //**                    main code
    20. //*****************************************************
    21.  
    22. //输入待校验8位数据,需要先将高低位互换
    23. wire    [7:0]  data_t;
    24.  
    25. assign data_t = {data[0],data[1],data[2],data[3],data[4],data[5],data[6],data[7]};
    26.  
    27. //CRC32的生成多项式为：G(x)= x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 
    28. //+ x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x^1 + 1
    29.  
    30. assign crc_next[0] = crc_data[24] ^ crc_data[30] ^ data_t[0] ^ data_t[6];
    31. assign crc_next[1] = crc_data[24] ^ crc_data[25] ^ crc_data[30] ^ crc_data[31] 
    32.                      ^ data_t[0] ^ data_t[1] ^ data_t[6] ^ data_t[7];
    33. assign crc_next[2] = crc_data[24] ^ crc_data[25] ^ crc_data[26] ^ crc_data[30] 
    34.                      ^ crc_data[31] ^ data_t[0] ^ data_t[1] ^ data_t[2] ^ data_t[6] 
    35.                      ^ data_t[7];
    36. assign crc_next[3] = crc_data[25] ^ crc_data[26] ^ crc_data[27] ^ crc_data[31] 
    37.                      ^ data_t[1] ^ data_t[2] ^ data_t[3] ^ data_t[7];
    38. assign crc_next[4] = crc_data[24] ^ crc_data[26] ^ crc_data[27] ^ crc_data[28] 
    39.                      ^ crc_data[30] ^ data_t[0] ^ data_t[2] ^ data_t[3] ^ data_t[4] 
    40.                      ^ data_t[6];
    41. assign crc_next[5] = crc_data[24] ^ crc_data[25] ^ crc_data[27] ^ crc_data[28] 
    42.                      ^ crc_data[29] ^ crc_data[30] ^ crc_data[31] ^ data_t[0] 
    43.                      ^ data_t[1] ^ data_t[3] ^ data_t[4] ^ data_t[5] ^ data_t[6] 
    44.                      ^ data_t[7];
    45. assign crc_next[6] = crc_data[25] ^ crc_data[26] ^ crc_data[28] ^ crc_data[29] 
    46.                      ^ crc_data[30] ^ crc_data[31] ^ data_t[1] ^ data_t[2] ^ data_t[4] 
    47.                      ^ data_t[5] ^ data_t[6] ^ data_t[7];
    48. assign crc_next[7] = crc_data[24] ^ crc_data[26] ^ crc_data[27] ^ crc_data[29] 
    49.                      ^ crc_data[31] ^ data_t[0] ^ data_t[2] ^ data_t[3] ^ data_t[5] 
    50.                      ^ data_t[7];
    51. assign crc_next[8] = crc_data[0] ^ crc_data[24] ^ crc_data[25] ^ crc_data[27] 
    52.                      ^ crc_data[28] ^ data_t[0] ^ data_t[1] ^ data_t[3] ^ data_t[4];
    53. assign crc_next[9] = crc_data[1] ^ crc_data[25] ^ crc_data[26] ^ crc_data[28] 
    54.                      ^ crc_data[29] ^ data_t[1] ^ data_t[2] ^ data_t[4] ^ data_t[5];
    55. assign crc_next[10] = crc_data[2] ^ crc_data[24] ^ crc_data[26] ^ crc_data[27] 
    56.                      ^ crc_data[29] ^ data_t[0] ^ data_t[2] ^ data_t[3] ^ data_t[5];
    57. assign crc_next[11] = crc_data[3] ^ crc_data[24] ^ crc_data[25] ^ crc_data[27] 
    58.                      ^ crc_data[28] ^ data_t[0] ^ data_t[1] ^ data_t[3] ^ data_t[4];
    59. assign crc_next[12] = crc_data[4] ^ crc_data[24] ^ crc_data[25] ^ crc_data[26] 
    60.                      ^ crc_data[28] ^ crc_data[29] ^ crc_data[30] ^ data_t[0] 
    61.                      ^ data_t[1] ^ data_t[2] ^ data_t[4] ^ data_t[5] ^ data_t[6];
    62. assign crc_next[13] = crc_data[5] ^ crc_data[25] ^ crc_data[26] ^ crc_data[27] 
    63.                      ^ crc_data[29] ^ crc_data[30] ^ crc_data[31] ^ data_t[1] 
    64.                      ^ data_t[2] ^ data_t[3] ^ data_t[5] ^ data_t[6] ^ data_t[7];
    65. assign crc_next[14] = crc_data[6] ^ crc_data[26] ^ crc_data[27] ^ crc_data[28] 
    66.                      ^ crc_data[30] ^ crc_data[31] ^ data_t[2] ^ data_t[3] ^ data_t[4]
    67.                      ^ data_t[6] ^ data_t[7];
    68. assign crc_next[15] =  crc_data[7] ^ crc_data[27] ^ crc_data[28] ^ crc_data[29]
    69.                      ^ crc_data[31] ^ data_t[3] ^ data_t[4] ^ data_t[5] ^ data_t[7];
    70. assign crc_next[16] = crc_data[8] ^ crc_data[24] ^ crc_data[28] ^ crc_data[29] 
    71.                      ^ data_t[0] ^ data_t[4] ^ data_t[5];
    72. assign crc_next[17] = crc_data[9] ^ crc_data[25] ^ crc_data[29] ^ crc_data[30] 
    73.                      ^ data_t[1] ^ data_t[5] ^ data_t[6];
    74. assign crc_next[18] = crc_data[10] ^ crc_data[26] ^ crc_data[30] ^ crc_data[31] 
    75.                      ^ data_t[2] ^ data_t[6] ^ data_t[7];
    76. assign crc_next[19] = crc_data[11] ^ crc_data[27] ^ crc_data[31] ^ data_t[3] ^ data_t[7];
    77. assign crc_next[20] = crc_data[12] ^ crc_data[28] ^ data_t[4];
    78. assign crc_next[21] = crc_data[13] ^ crc_data[29] ^ data_t[5];
    79. assign crc_next[22] = crc_data[14] ^ crc_data[24] ^ data_t[0];
    80. assign crc_next[23] = crc_data[15] ^ crc_data[24] ^ crc_data[25] ^ crc_data[30] 
    81.                       ^ data_t[0] ^ data_t[1] ^ data_t[6];
    82. assign crc_next[24] = crc_data[16] ^ crc_data[25] ^ crc_data[26] ^ crc_data[31] 
    83.                       ^ data_t[1] ^ data_t[2] ^ data_t[7];
    84. assign crc_next[25] = crc_data[17] ^ crc_data[26] ^ crc_data[27] ^ data_t[2] ^ data_t[3];
    85. assign crc_next[26] = crc_data[18] ^ crc_data[24] ^ crc_data[27] ^ crc_data[28] 
    86.                       ^ crc_data[30] ^ data_t[0] ^ data_t[3] ^ data_t[4] ^ data_t[6];
    87. assign crc_next[27] = crc_data[19] ^ crc_data[25] ^ crc_data[28] ^ crc_data[29] 
    88.                       ^ crc_data[31] ^ data_t[1] ^ data_t[4] ^ data_t[5] ^ data_t[7];
    89. assign crc_next[28] = crc_data[20] ^ crc_data[26] ^ crc_data[29] ^ crc_data[30] 
    90.                       ^ data_t[2] ^ data_t[5] ^ data_t[6];
    91. assign crc_next[29] = crc_data[21] ^ crc_data[27] ^ crc_data[30] ^ crc_data[31] 
    92.                       ^ data_t[3] ^ data_t[6] ^ data_t[7];
    93. assign crc_next[30] = crc_data[22] ^ crc_data[28] ^ crc_data[31] ^ data_t[4] ^ data_t[7];
    94. assign crc_next[31] = crc_data[23] ^ crc_data[29] ^ data_t[5];
    95.  
    96. always @(posedge clk or negedge rst_n) begin
    97.     if(!rst_n)
    98.         crc_data <= 32'hff_ff_ff_ff;
    99.     else if(crc_clr)                             //CRC校验值复位
    100.         crc_data <= 32'hff_ff_ff_ff;
    101.     else if(crc_en)
    102.         crc_data <= crc_next;
    103. end
    104.  
    105. endmodule

    1.4 ARP控制模块

    ARP控制模块首先检测输入触摸按键的上升沿，当检测到上升沿之后，触发ARP顶层模块发起 ARP请求信号；同时检测输入的arp_rx_done和arp_rx_type_信号，当接收上位机的ARP请求信号后，触发ARP顶层模块发送ARP应答信号，将开发板的MAC地址发送给上位机。

    1. module arp_ctrl(
    2.     input                clk        , //输入时钟   
    3.     input                rst_n      , //复位信号，低电平有效
    4.     
    5.     input                touch_key  , //触摸按键,用于触发开发板发出ARP请求
    6.     input                arp_rx_done, //ARP接收完成信号
    7.     input                arp_rx_type, //ARP接收类型 0:请求  1:应答 
    8.     output  reg          arp_tx_en  , //ARP发送使能信号
    9.     output  reg          arp_tx_type  //ARP发送类型 0:请求  1:应答
    10.     );
    11.  
    12. //reg define
    13. reg         touch_key_d0;
    14. reg         touch_key_d1;
    15.  
    16. //wire define
    17. wire        pos_touch_key;  //touch_key信号上升沿
    18.  
    19. //*****************************************************
    20. //**                    main code
    21. //*****************************************************
    22.  
    23. assign pos_touch_key = ~touch_key_d1 & touch_key_d0;
    24.  
    25. //对arp_tx_en信号延时打拍两次,用于采touch_key的上升沿
    26. always @(posedge clk or negedge rst_n) begin
    27.     if(!rst_n) begin
    28.         touch_key_d0 <= 1'b0;
    29.         touch_key_d1 <= 1'b0;
    30.     end
    31.     else begin
    32.         touch_key_d0 <= touch_key;
    33.         touch_key_d1 <= touch_key_d0;
    34.     end
    35. end
    36.  
    37. //为arp_tx_en和arp_tx_type赋值
    38. always @(posedge clk or negedge rst_n) begin
    39.     if(!rst_n) begin
    40.         arp_tx_en <= 1'b0;
    41.         arp_tx_type <= 1'b0;
    42.     end
    43.     else begin
    44.         if(pos_touch_key == 1'b1) begin  //检测到输入触摸按键上升沿
    45.             arp_tx_en <= 1'b1;           
    46.             arp_tx_type <= 1'b0;
    47.         end
    48.         //接收到ARP请求,开始控制ARP发送模块应答
    49.         else if((arp_rx_done == 1'b1) && (arp_rx_type == 1'b0)) begin
    50.             arp_tx_en <= 1'b1;
    51.             arp_tx_type <= 1'b1;
    52.         end
    53.         else
    54.             arp_tx_en <= 1'b0;
    55.     end
    56. end
    57.  
    58. endmodule

    参考文献：

    《开拓者之FPGA开发指南》

    《FPGA Verilog开发实战指南》

  • 相关阅读:
    NANK南卡和松下护眼台灯哪款好？最全面对比两款热门护眼台灯
    智慧电网解决方案-最新全套文件
    数据集笔记：Beijing-BRT-dataset
    基于.NET6的简单三层管理系统
    【时间预测+速度规划+ADRC】移动机器人高精度轨迹跟踪控制
    Docker Compose使用教程
    自动化运维工具——ansible概述和部署
    扩展的以太网
    【牛客刷题】——Python入门 06 条件语句
    Java的集合框架
  • 原文地址：https://blog.csdn.net/STATEABC/article/details/132159648