硬件日记

[blog-MT-02] - 使用 cloudflare pages 托管博客网页的静态资源

Wed, 20 May 2026 09:43:19 GMT

前言

由于 github pages 在国内的访问速度实在是不稳定，在查询资料的时候发现 cloudflare 可以提供静态资源部署服务，并且访问速度还是不错的。所以本篇文章基于此而诞生。

部署步骤

在这之前请注册 cloudflare 账号。关于账号注册本篇不再赘述，跟着提示一步步走即可，或者直接使用 github 账号登陆，登陆后验证一下邮箱就行了。

创建页面

在注册好并成功登录之后，我们会来到如图所示的界面，然后根据图中箭头所示进入对应的页面。来到这个页面之后，我们点击右上角的 Create Application 然后就来到了这个页面，注意要选择下方的 Get started 选择从 git 导入选择你的 hexo 源码仓库，即包含文章 markdown 源码的仓库。 (注意：不是 github pages 仓库，你可以前往我图中的这个仓库查看一下：ed333a/hexo_repo)选择完毕后点击右下角的 Begining setup 蓝色按钮。之后我们会来到这个页面，相关选项已在图中表示，配置好后往下翻找到 Save and Deploy 蓝色按钮，点击保存后开始自动部署。之后自动部署好的静态网页将可以通过 hexo-repo-e1a.pages.dev 这个链接访问。在这之前我已经创建好了一个静态资源网页，它的地址是 hexo-repo-1qi.pages.dev。

[blog-MT-01] - 博客建站过程

Tue, 19 May 2026 22:33:31 GMT

关于 Hexo

Hexo 是一个基于 Node.js 编写的快速、简洁且高效的博客框架。它通过解析 Markdown 格式的源文件，结合主题模板，一键生成静态网页资源；用户可以将这些静态资源文件部署到如 Github Pages 的静态资源托管服务站点上，无需后端环境或数据库，即可拥有高性能、易于维护的个人博客站点。

配置 Node.js 环境

在安装 Hexo 之前，首先要配置 Node.js 环境，前往 Node.js 中文网下载页面下载适合你当前所使用的系统的 Node.js 安装包。

:::warning 使用 Windows 10 或更高版本的系统时，通常建议 直接下载安装包 [Windows 安装包(.msi)] 进行安装，以免因 PowerShell 执行策略阻止未签名脚本运行，造成 npm 脚本无法正常执行。 :::

安装 Hexo

安装好 Node.js 后，使用以下命令来全局安装 hexo

$ npm install hexo-cli -g

安装完成后，在控制台中输入以下命令后，控制台中应出现 hexo-cli 的安装版本

$ hexo -v

在此次安装过程中，我的控制台中提示了以下内容，这种情况一般是在安装 Node.js 时没有配置好系统变量。将 %appdata%/npm 这个路径添加到系统变量中即可 (复制到文件资源管理器中的地址栏，然后获得绝对路径)。

$ hexo: 无法将 “hexo” 项识别为 cmdlet、函数、脚本文件或可运行程序的名称。请检查名称的拼写，如果包括路径，请确保路径正确，然后再试一次。

初始化 Hexo 目录

完成 Hexo 的安装后，在适当的位置创建一个文件夹，用来存放 hexo 的项目文件。

:::tip 这里的文件夹仅作为演示使用，无须严格按照图中所示的路径创建，你可以依照自己的文件管理习惯自己创建 :::

进入这个文件夹，然后执行以下命令

$ hexo init

之后 Hexo 将会在文件夹下初始化一些必要文件，如图所示。

:::warning Hexo 初始化时会从 Github 克隆一个模板仓库，有时受限于网络波动等因素，你可能无法完成初始化，此时请考虑使用网络代理或其它方式完成初始化。 :::

初始化完成后，使用以下命令安装 Node.js 模块

$ npm install

至此，你已完成 Hexo 建站的所有前置条件，使用以下命令即可开启一个本地服务器用来预览你的 Hexo 页面

$ hexo s

然后在浏览器中输入控制台输出的地址 localhost:4000 即可预览你的 hexo 页面

:::tip 当默认端口被占用时，你可以在命令后面增加参数 -p [端口号] 来指定一个未占用的端口。

命令如下

$ hexo s -p 4001

:::

生成静态资源

使用以下命令可以生成部署到 Github Pages 的静态资源

$ hexo g

生成好的静态资源位于 public 文件夹下

ceshi

Thu, 14 May 2026 00:00:00 GMT

nihao

FPGA SPI 通信

Sun, 19 Apr 2026 14:38:34 GMT

简介

在之前讲 {% post_link 'FPGA 串口通信' %} 的时候，有讲到过串口通信是异步通信，而 SPI 通信是一个典型的同步通信。它需要主设备驱动时钟信号线，所有数据位的发送和接收都在时钟的边沿触发，收发双方不再需要各自校准波特率，也不用起始位/停止位等操作，因此相比于异步的串口通信，这种通信方式效率更高，时序更稳定。缺点则是占用了更多的管脚，在 PCB 的布局布线上相比于串口复杂一些。

标准 SPI(四线式) 接口

标准 SPI 接口采用的是四线式接线方式，有 SCLK、MOSI、MISO 以及 SS#/CS# 四根信号线。这种方式的 SPI 接口支持全双工通信，即同时接收和发送。

SCK/SCLK：SPI 的串行时钟，由主设备 (Master) 驱动。
MOSI：全称：Master Out Slave In，是标准 SPI 的一根数据线，由主机输出，从机输入
MISO：全称：Master In Slave Out，是标准 SPI 的一根数据线，由从机输出，主机输入
SS#/CS#：全称：Slave Select/Chip Select 由主机驱动的片选信号线，用于多设备共享一个 SPI 总线时，选定指定设备有效的信号。该信号低电平有效。

关于片选信号线：从机设备片选信号线为高电平时，不会接收来自 MOSI 数据线上的数据，同时设备本身也不会输出任何数据。

下面是一张多设备共享 SPI 通信的连接方式图

半双工 SPI (三线式) 通信

该种接线方式将数据接口 (MISO、MOSI) 整合成了一个双向数据接口 (SDIO)，不是标准的 SPI 形式，这种 SPI 通信只支持半双工通信，但这是一种常用和被广泛支持的变体，通常称为 "三线 SPI" 或 "半双工 SPI"。三线式 SPI 通信同样支持多设备共享 SDIO 总线。

用一张表格来对比四线式 SPI 和三线式 SPI 的区别：

对比项	标准 SPI (四线式)	三线 SPI (四线式)
信号线	4根，SCLK, MOSI, MISO, CS	3根：SCLK, SDIO, CS
数据线	两根独立：发送 (MOSI) 和接收 (MISO) 分开	一根共用：发送和接收都通过同一条 SDIO 线
传输模式	全双工：可同时发送和接收	半双工：同一时刻只能发送或接收，不能同时进行
引脚数量	较多	较少，节省I/O资源

关于 SDIO 如何切换数据方向：这个要看具体的芯片数据手册，每款芯片的数据手册对于换向的时机都是不一样的。如我调试时的某款 ADC 芯片 SDIO 通信时序如下 (高位先发)：

bit 功能功能介绍

23 R/W# 读写控制位，读操作时写 1，写操作时写 0

[22:08] A0 to A14 15 位寄存器地址

[07:00] Do to D7 7 位数据，读操作时为向寄存器写入该数据，写操作时为读回指定地址的寄存器数据，读操作时此时的 SDIO 方向为输入

bit	功能	功能介绍
23	R/W#	读写控制位，读操作时写 1，写操作时写 0
[22:08]	A0 to A14	15 位寄存器地址
[07:00]	Do to D7	7 位数据，读操作时为向寄存器写入该数据，写操作时为读回指定地址的寄存器数据，读操作时此时的 SDIO 方向为输入

SPI 的四种通信模式

由 CPOL(时钟极性) 和 CPHA(时钟相位) 控制

CPOL(时钟极性): 控制 SCLK 电平在空闲时的状态
- 若 CPOL=0 则当 SPI 总线空闲时, SCLK 处于低电平状态
- 若 CPOL=1 则当 SPI 总线空闲时, SCLK 处于高电平状态
CPHA(时钟相位): 控制数据的采样边沿
- 若 CPHA=0 则在时钟信号的第一个跳变沿 (通常是上升沿) 进行数据采样
- 若 CPHA=1 则在时钟信号的第二个跳变沿 (通常是下降沿) 进行数据采样

模式	CPOL<br>(时钟极性)	CPHA<br>(时钟相位)	说明
0	0	0	空闲时低电平, 上升沿采集
1	0	1	空闲时低电平, 下降沿采集
2	1	0	空闲时高电平, 上升沿采集
3	1	1	空闲时高电平, 下降沿采集

SPI 模块参数以及端口定义

参数	功能描述
DATA_WIDTH	数据位宽
CPOL	时钟极性
CPHA	时钟相位
DLK_DIV	SCLK 的时钟分频系数
MOSI_IDLE_STATE	MOSI 信号线在空闲时的状态
CONTINUOUS_CLK	是否产生连续的时钟信号，若设置为 1'b0，则表示时钟仅在 SPI 活跃时产生。若设置为 1'b1，则表示时钟信号始终产生

端口	I/O	作用
clk	I	模块的时钟输入
rst_n	I	模块复位信号，低电平有效
dat_tx[N-1:0]	I	要通过 SPI 总线发送的数据（N 为数据位宽）
dat_rx[N-1:0]	O	由从机接收到的数据（N 为数据位宽）
start_op	I	一个时钟周期的脉冲信号，用于开始 SPI 通信
spi_end	O	一个时钟周期的脉冲信号，表示 SPI 发送或接收完成
spi_sclk	O	spi 的时钟信号线
spi_cs_n	O	spi 的片选信号线
spi_miso	I	SPI 的一根数据线，由从机输出，主机输入
spi_mosi	O	SPI 的一根数据线，由主机输出，从机输入
data_bit_cnt	O	发送的比特位计数器，用于在其顶层实现 SDIO 通信

module spi_master #(
    parameter                       DATA_WIDTH          = 4'd8             , // data width
    parameter                       CPOL                = 1'b0              , // Clock polarity
    parameter                       CPHA                = 1'b0              , // Clock phase
    parameter                       CLK_DIV             = 8'd10             , // input clk division, used to generate SCLK.
    parameter                       MOSI_IDLE_STATE     = 1'b0              , // when module goes to idle. the MOSI line logic level will be set to this value  
    parameter                       CONTINUOUS_CLK      = 1'b0                // when set to 1'b1, the SCLK line will continouous or only toggle when cs is low logic if it sets to 1'b0.
)(
    input                           clk                                     , // module clock
    input                           rst_n                                   , // module reset signal, active low
    
    input       [DATA_WIDTH-1:0]    dat_tx                                  , // the data to be transmitted to slave device
    output  reg [DATA_WIDTH-1:0]    dat_rx                                  , // the data received from the slave device
    input                           start_op                                , // pulse, trigger transfer dat operation

    output  reg                     spi_end                                 , // signal is high when transferring data
    
    // PHY signals      
    output                          spi_sclk                                , // serial clock
    output  reg                     spi_cs_n                                , // chip select signal, active low
    input                           spi_miso                                , // master in slave out
    output  reg                     spi_mosi                                , // master out slave in
    output  reg [7:0           ]    data_bit_cnt                              // bit transmit counter
);
// ...

endmodule

串行时钟的产生

通过计数器产生 sclk_inv 信号，该信号为一个时钟周期的脉冲信号，每一次脉冲信号都代表着 SCLK 信号将会在下一个时钟周期跳变一次。

// REGION_HEADER------------------------------------------------------------------------------------
reg                         spi_sclk_inv                ; // This signal is a pulse signal with a clk period, and on its rising edge, the SCLK signal will invert once.
reg                         spi_sclk_internal           ; // internal serial clock divied from module clock

// generate spi_sclk_inv signal
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        clk_cnt         <=  8'd0                    ;
        spi_sclk_inv     <=  1'b0                   ;
    end
    else if (clk_cnt == CLK_DIV - 1'b1) begin
        clk_cnt         <=  8'd0                    ;
        spi_sclk_inv     <=  1'b1                   ;
    end
    else if (clk_cnt == CLK_DIV[7:1] - 1'b1) begin
        clk_cnt         <=  clk_cnt + 1'b1          ;
        spi_sclk_inv     <=  1'b1                   ;
    end
    else begin
        clk_cnt         <=  clk_cnt + 1'b1          ;
        spi_sclk_inv     <=  1'b0                   ;
    end
end

// generate spi_sclk_internal signal
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        spi_sclk_internal   <=  1'b0                ;
    end else if (spi_sclk_inv) begin
        spi_sclk_internal   <=  !spi_sclk_internal  ;
    end else begin
        spi_sclk_internal   <=   spi_sclk_internal  ;
    end
end

// assign continouous clock
generate
    if (CONTINUOUS_CLK == 1'b1)
        assign spi_sclk = spi_sclk_internal ^ CPOL                                  ;
    else
        assign spi_sclk = (spi_cs_n == 1'b1) ? CPOL : (spi_sclk_internal ^ CPOL)    ;
endgenerate
// REGION_FOOTER------------------------------------------------------------------------------------

时钟边沿的判断

根据内部的 sclk_internal 信号，即可判断上升沿和下降沿。

当 sclk_internal 是高电平且 spi_sclk_inv 产生了脉冲信号的时候，表示 sclk_internal 将会在下个时钟周期跳变到低电平，此时则为 sclk_internal 的下降沿。
当 sclk_internal 是低电平且 spi_sclk_inv 产生了脉冲信号的时候，表示 sclk_internal 将会在下个时钟周期跳变到高电平，此时则为 sclk_internal 的上升沿。
update_edge 和 sample_edge 则表示 SPI 数据的更新边沿和采样边沿，依照 CPHA 参数的设置在上升沿或下降沿更新/采样数据。

wire    spi_sclk_negedge    =   spi_sclk_internal & spi_sclk_inv                ; // pulse signal, indicates SCLK negedge
wire    spi_sclk_posedge    =  !spi_sclk_internal & spi_sclk_inv                ;
wire    update_edge         = (CPHA == 0) ? spi_sclk_negedge : spi_sclk_posedge ; // Select update and sample edges based on CPHA
wire    sample_edge         = (CPHA == 0) ? spi_sclk_posedge : spi_sclk_negedge ;

完整的 SPI 代码

module spi_master #(
    parameter                       DATA_WIDTH          = 5'd24             , // data width, [1bit RW ctrl, 15 bits register addr, 8 bits data]
    parameter                       CPOL                = 1'b0              , // Clock polarity
    parameter                       CPHA                = 1'b0              , // Clock phase
    parameter                       CLK_DIV             = 8'd10             , // input clk division, used to generate SCLK.
    parameter                       MOSI_IDLE_STATE     = 1'b0              , // when module goes to idle. the MOSI line logic level will be set to this value   
    parameter                       CONTINUOUS_CLK      = 1'b0                // when set to 1'b1, the SCLK line will continouous or only toggle when cs is low logic if it sets to 1'b0.
)(
    input                           clk                                     , // module clock
    input                           rst_n                                   , // module reset signal, active low

    input       [DATA_WIDTH-1:0]    dat_tx                                  , // the data to be transmitted to slave device
    output  reg [DATA_WIDTH-1:0]    dat_rx                                  , // the data received from the slave device

    input                           start_op                                , // pulse, trigger transfer dat operation
    output  reg                     spi_end                                 , // signal is high when transferring data

    // PHY signals      
    output                          spi_sclk                                , // serial clock
    output  reg                     spi_cs_n                                , // chip select signal, active low
    input                           spi_miso                                , // master in slave out
    output  reg                     spi_mosi                                , // master out slave in
    output  reg [7:0           ]    data_bit_cnt                              // bit transmit counter
);

// NOTE_HEADER--------------------------------------------------------------------------------------
// SPI Modes | CPOL             | CPHA          | Note
//           | (Clock Polarity) | (Clock Phase) | 
// ==========+==================+===============+===================================================
//         0 |                0 |             0 | Clock low  level when idle, data sampled on rising  edge
//         1 |                0 |             1 | Clock low  level when idle, data sampled on falling edge
//         2 |                1 |             0 | Clock high level when idle, data sampled on rising  edge
//         3 |                1 |             1 | Clock high level when idle, data sampled on falling edge
// NOTE_FOOTER--------------------------------------------------------------------------------------

//================================================================================
// local parameter declarations
//================================================================================

//================================================================================
// reg declarations
//================================================================================
reg [DATA_WIDTH-1:0 ]       data_tx_buffer              ; // tx data buffer, shift out to mosi
reg [DATA_WIDTH-1:0 ]       data_rx_buffer              ; // rx data buffer, shift in from miso
reg [7:0            ]       clk_cnt                     ; // a counter for frequency division

reg                         spi_sclk_inv                ; // This signal is a pulse signal with a clk period, and on its rising edge, the SCLK signal will invert once.
reg                         spi_sclk_internal           ; // internal serial clock divied from module clock

reg                         trans_end_d                 ;
reg                         trans_start                 ;
reg                         spi_start_op_d0             ;
reg                         spi_start_op_d1             ;
reg                         spi_busy                    ; // internal busy signal
//================================================================================
// wire declarations
//================================================================================
wire    spi_sclk_negedge    =   spi_sclk_internal & spi_sclk_inv                ; // pulse signal, indicates SCLK negedge
wire    spi_sclk_posedge    =  !spi_sclk_internal & spi_sclk_inv                ;
wire    update_edge         = (CPHA == 0) ? spi_sclk_negedge : spi_sclk_posedge ; // Select update and sample edges based on CPHA
wire    sample_edge         = (CPHA == 0) ? spi_sclk_posedge : spi_sclk_negedge ;

wire    spi_start_op_pulse                                          ;

//================================================================================
// assign declarations
//================================================================================
assign  spi_start_op_pulse  =   !spi_start_op_d0 & spi_start_op_d1  ;

//================================================================================
// MAIN CODE
//================================================================================

// sync start_op signal
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        spi_start_op_d0 <=  1'b0            ;
        spi_start_op_d1 <=  1'b0            ;
    end else begin
        spi_start_op_d0 <=  start_op        ;
        spi_start_op_d1 <=  spi_start_op_d0 ;
    end
end

// spi busy indicator
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        spi_busy    <=  1'b0                ;
    end else if (spi_start_op_pulse) begin
        spi_busy    <=  1'b1                ;
    end else if (spi_end) begin
        spi_busy    <=  1'b0                ;
    end else begin
        spi_busy    <=  spi_busy            ;
    end
end

// REGION_HEADER------------------------------------------------------------------------------------
// generate spi_sclk_inv signal
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        clk_cnt         <=  8'd0                    ;
        spi_sclk_inv     <=  1'b0                   ;
    end
    else if (clk_cnt == CLK_DIV - 1'b1) begin
        clk_cnt         <=  8'd0                    ;
        spi_sclk_inv     <=  1'b1                   ;
    end
    else if (clk_cnt == CLK_DIV[7:1] - 1'b1) begin
        clk_cnt         <=  clk_cnt + 1'b1          ;
        spi_sclk_inv     <=  1'b1                   ;
    end
    else begin
        clk_cnt         <=  clk_cnt + 1'b1          ;
        spi_sclk_inv     <=  1'b0                   ;
    end
end

// generate spi_sclk_internal signal
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        spi_sclk_internal   <=  1'b0                ;
    end else if (spi_sclk_inv) begin
        spi_sclk_internal   <=  !spi_sclk_internal  ;
    end else begin
        spi_sclk_internal   <=   spi_sclk_internal  ;
    end
end

// assign continouous clock
generate
    if (CONTINUOUS_CLK == 1'b1)
        assign spi_sclk = spi_sclk_internal ^ CPOL                                  ;
    else
        assign spi_sclk = (spi_cs_n == 1'b1) ? CPOL : (spi_sclk_internal ^ CPOL)    ;
endgenerate
// REGION_FOOTER------------------------------------------------------------------------------------

// count data bit
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        data_bit_cnt    <=  8'd0                            ;
    end 
    else if (
        spi_busy        && 
        update_edge     && 
        (data_bit_cnt  < DATA_WIDTH)
    ) begin
        data_bit_cnt    <=  data_bit_cnt + 1'b1             ;
    end else if (update_edge && data_bit_cnt == DATA_WIDTH) begin
        data_bit_cnt    <=  8'd0                            ;
    end else begin
        data_bit_cnt    <=  data_bit_cnt                    ;
    end
end

// send data
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        spi_mosi        <=  MOSI_IDLE_STATE                 ;
        data_tx_buffer  <=  {DATA_WIDTH{1'b0}}              ;
    end else if (spi_start_op_pulse) begin
        data_tx_buffer  <=  dat_tx                          ;
    end 
    else if (
        spi_busy                        &&
        update_edge                     &&
        (data_bit_cnt < DATA_WIDTH)
    ) begin
        spi_mosi        <=  data_tx_buffer[DATA_WIDTH-1]    ;   // output data, MSB First
        data_tx_buffer  <=  {                                   // left-shift data
            data_tx_buffer[DATA_WIDTH-2:0]  ,
            data_tx_buffer[DATA_WIDTH-1]     
        };
    end else if (
        spi_busy                        &&
        update_edge                     &&
        (data_bit_cnt >= DATA_WIDTH)
    ) begin
        spi_mosi        <=  MOSI_IDLE_STATE                 ;
        data_tx_buffer  <=  {DATA_WIDTH{1'b0}}              ;
    end
end

// receive data
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        data_rx_buffer      <=  {DATA_WIDTH{1'b0}}  ;
    end else if (spi_cs_n == 1'b0 && sample_edge) begin
        data_rx_buffer[0]   <=  spi_miso            ;   // sample data
        data_rx_buffer[DATA_WIDTH-1:1] <= data_rx_buffer[DATA_WIDTH-2:0];   // right-shif in sampled data to buffer
    end else begin
        data_rx_buffer      <=  data_rx_buffer      ;
    end
end

// move data from data_rx_buffer to data_rx output and generate spi_end signal 
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        spi_end <=  1'b0                ;
        dat_rx  <=  {DATA_WIDTH{1'b0}}  ;
    end else if (update_edge && (data_bit_cnt == DATA_WIDTH)) begin
        spi_end <=  1'b1                ;
        dat_rx  <=  data_rx_buffer      ;
    end else begin
        spi_end <=  1'b0                ;
    end
end

always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        trans_end_d <=  1'b0            ;
    end else begin
        trans_end_d <=  spi_end         ;
    end
end

always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        trans_start <=  1'b0            ;
    end else if (spi_busy & update_edge) begin
        trans_start <=  1'b1            ;
    end else begin
        trans_start <=  1'b0            ;
    end
end

always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        spi_cs_n <=  1'b1               ;
    end else if (trans_start) begin
        spi_cs_n <=  1'b0               ;
    end else if (trans_end_d) begin // used a extended version to meet the timing requirements(clock to enable low time) of some device
        spi_cs_n <=  1'b1               ;
    end
end

endmodule

实现三线式 SPI 通信

SDIO 通信完全不需要从头开始编写代码，以上方提供的 spi_master 模块的代码作为基础，将其作为一个子模块封装到顶层模块，再用 IOBUF 原语实现一个双向 IO 即可。

完整代码如下：

module sdio_interface (
	input   wire            clk             ,   //  模块的时钟信号
    input   wire            rst_n           ,   //  模块的复位信号，低电平有效
    
    input   wire            rh_wl           ,   //  读写控制信号, 读为高电平，写为低电平
    input   wire            sdio_start_op   ,   //  操作使能的脉冲信号
    input   wire    [15:00] register_addr   ,   //  16 位寄存器地址
    input   wire    [07:00] dat_tx          ,   //  要发送的数据
    output  wire    [07:00] dat_rx          ,   //  从 sdio 接口读取到的 8 位寄存器数据
    
    output  wire            spi_sclk        ,   //  串行时钟信号
    output  wire            spi_cs_n        ,   //  片选信号
    inout   wire            sdio            ,   //  双向 IO 端口
);

// 例化 spi_master 模块
wire            spi_mosi    ;
wire            spi_miso    ;
wire    [23:00] dat_rx_t    ;   //  将 spi_master 模块接收到的 24 位数据暂存到此处，我们只需要低八位的寄存器数据
wire    [07:00] data_bit_cnt;
wire    sdio_dir = (data_bit_cnt <= 16) ? 1'b0 : rh_wl; // 前 16 位：读写控制位和寄存器地址，固定为输出方向，低 8 位根据读写控制来调整方向
assign  dat_rx  =   dat_rx_t[07:00] ;   //  只取出低八位数据
spi_master # (
    .DATA_WIDTH             (   24                              ),  // data width, [1bit RW ctrl, 15 bits register addr, 8 bits data]
    .CPOL                   (   1'b0                            ),  // Clock polarity
    .CPHA                   (   1'b0                            ),  // Clock phase
    .CLK_DIV                (   8'd10                           ),  // input clk division, used to generate SCLK.
    .MOSI_IDLE_STATE        (   1'b0                            ),  // when module goes to idle. the MOSI line logic level will be set to this value   
    .CONTINUOUS_CLK         (   1'b0                            )   // when set to 1'b1, the SCLK line will continouous or only toggle when cs is low logic if it sets to 1'b0.
) spi_master (                   
    .clk                    (   clk                             ),  // [I] [      ] module clock
    .rst_n                  (   rst_n                           ),  // [I] [      ] module reset signal, active-low

    .dat_tx                 (   {rh_wl, register_addr, dat_tx}  ),  // [I] [DW-1:0] the data to be transmitted to slave device
    .dat_rx                 (   dat_rx                          ),  // [O] [DW-1:0] the data received from the slave device

    .start_op               (   sdio_start_op                   ),  // [I] [      ] pulse, trigger SPI transfer
    .spi_end                (   spi_end                         ),  // [O] [      ] busy is high level when transferring data

    .spi_sclk               (   spi_sclk                        ),  // [O] [   0:0] serial clock
    .spi_cs_n               (   spi_cs_n                        ),  // [O] [   0:0] chip select signal, active low
    .spi_mosi               (   spi_mosi                        ),  // [I] [   0:0] master in slave out
    .spi_miso               (   spi_miso                        ),  // [O] [   0:0] master out slave in
    .data_bit_cnt           (   data_bit_cnt                    )   // [O] [   7:0] bit transmit counter
);

// 例化 IOBUF 原语
IOBUF # (
    .DRIVE          (   12              ),
    .IBUF_LOW_PWR   (   "TRUE"          ),
    .IOSTANDARD     (   "DEFAULT"       ),
    .SLEW           (   "SLOW"          )
) ms14d2600_spi_iobuf (
    .O              (   spi_miso        ),  //  IOBUF 原语的输出端口，接到 spi_miso 中
    .IO             (   sdio            ),  //  IOBUF 原语的双向端口，输出到模块端口
    .I              (   spi_mosi        ),  //  IOBUF 原语的输入端口，接到 spi_mosi 中
    .T              (   sdio_dir        )   //  IOBUF 原语的方向控制端口，low: output, high: input
);

endmodule

这里我实现的三线式 SPI 通信适用于我上面提到的某款 ADC 芯片通信时序，对于 sdio 方向的更改时机可以通过修改代码中第 21 行：

wire    sdio_dir = (data_bit_cnt <= 16) ? 1'b0 : rh_wl; // 前 16 位：读写控制位和寄存器地址，固定为输出方向，低 8 位根据读写控制来调整方向

将判断条件设置为你需要的值即可。

FPGA 实现以太网 PHY 芯片配置接口 —— MDIO 的学习与应用

Sat, 18 Apr 2026 15:18:25 GMT

前言

MDIO 接口是配置以太网 PHY 芯片片上寄存器的一种通用接口，几乎所有的以太网 PHY 芯片使用的都是 MDIO 接口来配置寄存器。

接线方式

ETH_MDC: 时钟信号线，频率不大于 12.5MHz
ETH_MDIO: 双向数据线主从式、半双工通信，所有通信都是由主设备发起，从设备被动响应（和 IIC 类似）

数据帧格式

读数据

Preamble	ST	OP	PHYAD	REGAD	TA	DATA	IDLE
1...1	01	10	AAAAA	RRRRR	Z0	DDDDDDDDDDDDDDDD	Z

Preamble: 前导码，由主设备发送的连续的 32 个逻辑 1，用于与从设备建立同步
ST: 数据帧的开始，固定为 2位数据 01，代表有效数据的起始位置
OP: 操作码，定义操作类型，01：写操作，10：读操作
PHYAD：5 位 PHY 芯片地址，用于选择总线上的目标 PHY 芯片
REGAD：片上寄存器地址
TA：转向域，2 位的空闲周期，用于读写方向切换；写操作：主设备持续驱动总线输出 "10"; 读操作：第一个时钟周期 MDIO 程高阻态 (主、从设备均释放总线), 在第二个时钟周期下，从设备将接管 MDIO 总线，开始驱动 MDIO 输出数据。
DATA：16 位即将要写入或读取的数据
IDLE：空闲状态位，帧结束后 MDIO 总线拉高进入高阻态表中的 Z 高阻态，在外部上拉电阻的情况下最终信号体现为高电平

在读数据操作时，直到 TA 阶段之前，数均由主设备(FPGA)驱动，TA 阶段第一个时钟周期主设备控制 MDIO 为高阻态，释放总线，从第二个时钟周期开始，从设备接管 MDIO，数据为低电平，表示数据将在下一个时钟周期开始发送。

写数据

Preamble	ST	OP	PHYAD	REGAD	TA	DATA	IDLE
1...1	01	01	AAAAA	RRRRR	10	DDDDDDDDDDDDDDDD	Z

在写数据时，MDIO 总线全程由主设备控制

实现代码

双向 IO 口的驱动

在这里使用 IOBUF 原语驱动双向 IO 口。

IOBUF # (
    .DRIVE          (   12              ),
    .IBUF_LOW_PWR   (   "TRUE"          ),
    .IOSTANDARD     (   "DEFAULT"       ),
    .SLEW           (   "SLOW"          )
) mdio_obuf (
    .O              (   eth_mdio_in     ),
    .IO             (   eth_mdio        ),
    .I              (   eth_mdio_out    ),
    .T              (   eth_mdio_dir    )   //  1'b1: input, 1'b0: output
);

或者使用三态门进行逻辑判断。

module eth_mdio (
	//...
	inout eth_mdio; // 双向 io 口
	//...
);

wire eth_mdio_in ; // MDIO 从机输入的比特位数据
wire eth_mdio_out; // MDIO 主机输出的比特位数据
reg  eth_mdio_dir; // 控制 MDIO 的输入/输出方向, 1'b1: 输入, 1'b0:输出

assign eth_mdio = eth_mdio_dir ? eth_mdio_in : eth_mdio_out; // 三态门根据内部的 dir 信号控制端口的输入输出方向

//... 其它代码 ... 如时钟信号、驱动 eth_mdio_dir 的逻辑等等

时钟信号的产生

和之前有一篇讲 SPI 通信文章中的代码类似，也是产生一个双边沿的脉冲信号，然后根据这个双边沿脉冲信号去翻转 MDC 信号就得到了驱动时钟。

// MDC inv Generation, inv pulse signal is active-high when MDC rising edge and falling edge
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        eth_mdc_cnt <=  32'd0               ;
        eth_mdc_inv <=   1'b0               ;
    end
    else if (eth_mdc_cnt == (CLK_DIV - 1'd1)) begin         // MDC falling edge
        eth_mdc_cnt <=  8'd0                ;
        eth_mdc_inv <=  1'b1                ;
    end
    else if (eth_mdc_cnt == (CLK_DIV[7:1] - 1'd1)) begin    // MDC rising  edge
        eth_mdc_cnt <=  eth_mdc_cnt + 1'd1  ;
        eth_mdc_inv <=   1'b1               ;
    end
    else begin
        eth_mdc_cnt <=  eth_mdc_cnt + 1'd1  ;
        eth_mdc_inv <=  1'b0                ;
    end
end

// generate MDC
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        eth_mdc     <=  1'b0                ;
    end else if (eth_mdc_inv) begin
        eth_mdc     <=  ~eth_mdc            ;
    end else begin
        eth_mdc     <=   eth_mdc            ;
    end
end

上升沿和下降沿的判断

判断逻辑如下：

当 eth_mdc 为高电平并且产生了 eth_mdc_inv 的脉冲信号，表示 eth_mdc 将会在下一个时钟周期跳变到低电平，此时则为 eth_mdc 的下降沿
当 eth_mdc 为低电平并且产生了 eth_mdc_inv 的脉冲信号，表示 eth_mdc 将会在下一个时钟周期跳变到高电平，此时则为 eth_mdc 的上升沿

wire eth_mdc_negedge =  eth_mdc & eth_mdc_inv;   // indicates MDC negedge
wire eth_mdc_posedge = !eth_mdc & eth_mdc_inv;   // indicates MDC posedge

完整的 MDIO 驱动代码

module mdio_dri # (
    parameter   CLK_DIV = 8'd10                 // for MDC generation, The max frequency of MDC is 12.500MHz
)(
    input                   clk             ,   // [ I] [    ] module clock, 100.000MHz is recommended
    input                   rst_n           ,   // [ I] [    ] reset signal, active-low
    input                   eth_start_op    ,   // [ I] [    ] start MDIO configuration pulse

    input   wire            rh_wl           ,   // [ I] [    ] high level for read, and low level for write.
    input   wire    [ 4:0]  phy_addr        ,   // [ I] [ 4:0] 5-bit phy address
    input   wire    [ 4:0]  reg_addr        ,   // [ I] [ 4:0] 5-bit register address 
    input   wire    [15:0]  dat_tx          ,   // [ I] [15:0] 16-bit tx data
    output  reg     [15:0]  dat_rx          ,   // [ O] [15:0] 16-bit rx data

    output  reg             eth_end         ,   // [ O] [    ] pulse signal when transmit done, active-high
    output  reg             eth_module_busy ,   // [ O] [    ] module busy siganl
    output  reg             eth_mdc         ,   // [ O] [    ] serial clock
    inout   wire            eth_mdio            // [IO] [    ] data port 
);
//================================================================================
// Local Parameter Declarations
//================================================================================
// 32-bit preamble  , 2-bit ST      , 2-bit OP  , 
//  5-bit PHYAD     , 5-bit REGAD   , 2-bit TA  ,
// 16-bit DATA      , Then higi-impedance IDLE state.
localparam  DAT_WIDTH       =   7'd64       ;

//================================================================================
// Register Declarations
//================================================================================
reg [7:0]   eth_mdc_cnt     ;
reg         eth_mdc_inv     ;

reg         eth_start_op_d0 ;
reg         eth_start_op_d1 ;

reg [ 7:0]  data_bit_cnt    ;

reg [31:0]  dat_tx_buffer   ;
reg [15:0]  dat_rx_buffer   ;

reg         eth_mdio_out    ; 
//================================================================================
// Wire Declarations
//================================================================================
wire        eth_mdio_in                                                 ;   // mdio data in
wire        eth_mdio_dir                                                ;

wire        eth_start_op_pulse  =  !eth_start_op_d0 & eth_start_op_d1   ;   
wire        eth_mdc_negedge     =   eth_mdc & eth_mdc_inv               ;   // indicates MDC negedge
wire        eth_mdc_posedge     =  !eth_mdc & eth_mdc_inv               ;   // indicates MDC posedge

//================================================================================
// Assign Declarations
//================================================================================
// always output until we transmit/receive 16-bit data stage
assign  eth_mdio_dir    =   (data_bit_cnt <= (8'd48)) ? 1'b0 : rh_wl;

//================================================================================
// implements
//================================================================================
IOBUF # (
    .DRIVE          (   12              ),
    .IBUF_LOW_PWR   (   "TRUE"          ),
    .IOSTANDARD     (   "DEFAULT"       ),
    .SLEW           (   "SLOW"          )
) mdio_obuf (
    .O              (   eth_mdio_in     ),
    .IO             (   eth_mdio        ),
    .I              (   eth_mdio_out    ),
    .T              (   eth_mdio_dir    )   //  1'b1: input, 1'b0: output
);

//================================================================================
// MAIN CODE
//================================================================================
// sync eth_start_op signal
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        eth_start_op_d0 <=  1'b0            ;
        eth_start_op_d1 <=  1'b0            ;
    end else begin
        eth_start_op_d0 <=  eth_start_op    ;
        eth_start_op_d1 <=  eth_start_op_d0 ;
    end
end

// module busy indicator
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        eth_module_busy <=  1'b0            ;
    end else if (eth_start_op_pulse) begin
        eth_module_busy <=  1'b1            ;
    end else if (eth_end) begin
        eth_module_busy <=  1'b0            ;
    end else begin
        eth_module_busy <=  eth_module_busy ;
    end
end

// MDC inv Generation, inv pulse signal is active-high when MDC rising edge and falling edge
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        eth_mdc_cnt <=  32'd0               ;
        eth_mdc_inv <=   1'b0               ;
    end
    else if (eth_mdc_cnt == (CLK_DIV - 1'd1)) begin         // MDC falling edge
        eth_mdc_cnt <=  8'd0                ;
        eth_mdc_inv <=  1'b1                ;
    end
    else if (eth_mdc_cnt == (CLK_DIV[7:1] - 1'd1)) begin    // MDC rising  edge
        eth_mdc_cnt <=  eth_mdc_cnt + 1'd1  ;
        eth_mdc_inv <=   1'b1               ;
    end
    else begin
        eth_mdc_cnt <=  eth_mdc_cnt + 1'd1  ;
        eth_mdc_inv <=  1'b0                ;
    end
end

// generate MDC
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        eth_mdc     <=  1'b0                ;
    end else if (eth_mdc_inv) begin
        eth_mdc     <=  ~eth_mdc            ;
    end else begin
        eth_mdc     <=   eth_mdc            ;
    end
end

// count data bit
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        data_bit_cnt    <=  8'd0            ;
    end else if (
        eth_module_busy     &&
        eth_mdc_negedge     &&
        (data_bit_cnt < DAT_WIDTH)
    ) begin
        data_bit_cnt <=  data_bit_cnt + 1'b1;
    end else if (eth_mdc_negedge && data_bit_cnt == DAT_WIDTH) begin
        data_bit_cnt    <=  8'd0            ;
    end else begin
        data_bit_cnt    <=  data_bit_cnt    ;
    end
end

// send data
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        eth_mdio_out    <=  1'b0            ;
        dat_tx_buffer   <=  32'b0           ;
    end else if (eth_start_op_pulse) begin 
        dat_tx_buffer   <=  {
            2'b01                       ,   // start of frame
            rh_wl                       ,   // Operation code bit 1
            !rh_wl                      ,   // Operation code bit 2
            phy_addr                    ,   // PHY address
            reg_addr                    ,   // Register address
            (rh_wl) ?  2'b00  : 2'b10   ,   // Turnaround
            (rh_wl) ? 16'b0000: dat_tx      // 16-bit data
        };
    end else if (
        eth_module_busy     &&
        eth_mdc_negedge     &&
        (data_bit_cnt < 8'd32)                      
    ) begin
        eth_mdio_out    <=  1'b1                ;   // 32-bit preamble
    end else if (
        eth_module_busy     &&
        eth_mdc_negedge     &&
        (data_bit_cnt < DAT_WIDTH)
    ) begin
        eth_mdio_out    <=  dat_tx_buffer[31]   ;   // MSB First
        dat_tx_buffer   <=  {
            dat_tx_buffer[30:0],
            dat_tx_buffer[  31]
        };
    end else if (
        eth_module_busy     &&
        eth_mdc_negedge     &&
        (data_bit_cnt >= DAT_WIDTH)
    ) begin
        eth_mdio_out    <=  1'b0                ;
        dat_tx_buffer   <=  {32{1'b0}}          ;
    end
end

// receive data
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        dat_rx_buffer       <=  16'b0               ;
    end else if (eth_mdio_dir && eth_mdc_posedge) begin
        dat_rx_buffer[0]    <=  eth_mdio_in         ;
        dat_rx_buffer[15:1] <=  dat_rx_buffer[14:0] ;
    end else begin
        dat_rx_buffer       <=  dat_rx_buffer       ;
    end
end

// move data from dat_rx_buffer to dat_rx output and generate eth_end signal
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        eth_end     <=      1'b0                    ;
        dat_rx      <=      16'b0                   ;
    end else if (eth_mdc_negedge && (data_bit_cnt == DAT_WIDTH)) begin
        eth_end     <=      1'b1                    ;
        dat_rx      <=      dat_rx_buffer           ;
    end else begin
        eth_end     <=      1'b0                    ;
    end
end

endmodule

FPGA 串口通信

Fri, 17 Apr 2026 14:08:17 GMT

简介

串口，即 UART(全称 Universal Asynchronous Receiver/Transmitter，中文正式名称为通用异步收发器)，是采用串行通信方式的接口。串行通信将字节数据按比特在一条数据线上逐个传输，其特点是线路简单，但传输速度较慢。

对于传输速度要求不高的场合，如工业控制、嵌入式开发等领域，串口通信是常客。

串口通信方式

UART 通信需要两根信号线来实现，分别是 TXD 和 RXD。TXD 用来发送数据；RXD 用来接收数据。在发送数据时，将并行的 8 比特数据按比特在一条数据线上逐个传输。在接收数据时，将接收到的串行数据按比特解串成并行数据。发送时低位先发。

需要注意的是，两个串口设备通信时，不能把各自的 TXD 和 RXD 直接对应相连（即 TXD 接 TXD、RXD 接 RXD），而应该交叉连接：一个设备的 TXD 接另一个设备的 RXD，同时这个设备的 RXD 接另一个设备的 TXD。具体连接方式如下图所示。

串口通信数据格式

如下图所示，下图为一个字节数据 (字符帧) 的传输格式

起始位：标志着一帧数据的开始，该位固定为 0
数据位：一帧数据中的有效数据，在串口设置中可配置为 5、6、7、8 位
校验位：分为奇校验和偶校验。为了使得整体 1 的个数为对应的奇数/偶数，在该位补齐对应的 0 或 1，例图如下：
- 总结一下就是：奇偶校验是为了让传输的数据（包含校验位）中 1 的个数为奇数/偶数。如果传输字节中 1 的个数为偶数/奇数，则校验位的数据为 1，否则为 0。
停止位：标志着一个数据帧的结束。该位固定为 1

波特率

串口通信中，我们用波特率表示数据传输的快慢。波特率表示每秒传输了多少个二进制位（bit）。通信双方各自使用本地时钟源，通过分频得到所需的波特率时钟信号。这种不需要额外传输时钟信号的方式，就是异步通信——其本质是双方各自依赖本地时钟，依靠起始位来完成字符同步。

常见的波特率有 9600、19200 以及 115200 等。波特率是人为规定的，理论上你可以设置任何速度的波特率，只要通信双方波特率一致，就可以正常通信。但实际硬件和软件通常只支持有限个常用值，这受限于系统时钟的分频：分频只能得到某些特定的数值，例如前面提到的常见波特率。此外，常见的操作系统和串口软件通常也只在常用波特率列表中提供选择，支持手动输入任意波特率的情况并不多。

实现代码

串口发送模块

该模块负责串口数据的发送

// FILE_HEADER_HEADER-------------------------------------------------------------------------------
// Copyright (c) 2026, Mr. Tian. All rights reserved.
//--------------------------------------------------------------------------------------------------
// FILE NAME        : uart_tx.v
// AUTHOR           : Mr. Tian
// DESCRIPTION      : UART transmitter
//--------------------------------------------------------------------------------------------------
// REVISION HISTORY :
//  Rev: (2026-05-06) - Mr. Tian
//          Initial release.
// FILE_HEADER_FOOTER-------------------------------------------------------------------------------

module uart_tx # (
    parameter   CLOCK_FREQ  =   32'd100_000_000 ,   //  输入时钟频率 (200MHz)
    parameter   BAUD_RATE   =   32'd115200      ,   //  波特率
    parameter   DATA_BITS   =   8               ,   //  数据位
    parameter   PARITY      =   "ODD"           ,   //  校验方式，有 ODD(奇校验)、EVEN(偶校验)、SPACE(始终为 0)、MARK(始终为 1)、NONE(无校验)
    parameter   STOP_BITS   =   "1"                 //  停止位: 1, 1.5, 2，输入其它值则默认为 1 停止位
) (
    input                   clk     ,   //  [I][     ] 输入的模块时钟，推荐 100.000 MHz
    input                   rst_n   ,   //  [I][     ] 模块复位信号，低电平有效

    input   wire            tx_en   ,   //  [I][     ] 发送使能信号，高脉冲有效
    input   wire    [07:00] tx_data ,   //  [I][07:00] 要发送的数据
    
    output  reg             tx_busy ,   //  [O][     ] 发送机忙信号
    output  reg             txd         //  [O][     ] TXD 信号线
);
    
localparam  BAUD_CNT_MAX        =   CLOCK_FREQ / BAUD_RATE  ;   //  计数器的最大计数值
localparam  BAUD_CNT_MID        =   BAUD_CNT_MAX / 2        ;   //  计数器值的中点
localparam  HAS_PARITY          =   (PARITY != "NONE")      ;   //  是否使用了校验位
localparam  STOP_BIT_INDEX      =   DATA_BITS + (HAS_PARITY ? 1 : 0) + 1 ;  // 停止位在 bit_cnt 中的位置

// 根据停止位长度计算停止位结束时刻的 baud_cnt 计数值
// 1   -> 在停止位中点（BAUD_CNT_MAX/2 - 1）结束
// 1.5 -> 在停止位中点后继续 1 个位周期（BAUD_CNT_MAX + BAUD_CNT_MAX/2 - 1）
// 2   -> 在停止位中点后继续 1.5 个位周期（2*BAUD_CNT_MAX - 1）
// 为了保持代码一致，减 1 的操作在 always 语句中进行
localparam  STOP_BITS1_CNT      =   BAUD_CNT_MAX/2                  ;   //  停止位为 1   时计数器的值
localparam  STOP_BITS1_5_CNT    =   BAUD_CNT_MAX + BAUD_CNT_MAX/2   ;   //  停止位为 1.5 时计数器的值
localparam  STOP_BITS2_CNT      =   (2 * BAUD_CNT_MAX)              ;   //  停止位为 2   时计数器的值

localparam  STOP_END_CNT        =   (STOP_BITS == "1"  ) ? (STOP_BITS1_CNT  ) :
                                    (STOP_BITS == "1.5") ? (STOP_BITS1_5_CNT) :
                                    (STOP_BITS == "2"  ) ? (STOP_BITS2_CNT  ) :
                                     STOP_BITS1_CNT                             ;   // 停止位计数器的值，默认按停止位 1 处理

reg [31:00] baud_cnt    ;
reg [03:00] bit_cnt     ;
reg [07:00] data_reg    ;

wire        parity_bit  ;

// 校验位计算，使用的是缩位异或运算
// 缩位异或运算用来检查数据中 1 的个数是否为奇数，对其计算结果取反后可用于检查数据中 1 的个数是否为偶数
assign      parity_bit  =  (PARITY == "ODD"  ) ? ~(^tx_data[DATA_BITS-1:0]) :
                           (PARITY == "EVEN" ) ?   ^tx_data[DATA_BITS-1:0]  :
                           (PARITY == "MARK" ) ? 1'b1 :
                           (PARITY == "SPACE") ? 1'b0 :
                           (PARITY == "NONE" ) ? 1'b0 :
                           1'bz;

// 判断校验位的参数是否正确
initial begin
    if (
        !((PARITY == "ODD"  ) ||
          (PARITY == "EVEN" ) ||
          (PARITY == "MARK" ) ||
          (PARITY == "SPACE") ||
          (PARITY == "NONE" ))
    ) begin
        $error("Unknown PARITY value: [%s], for parameter PARITY, its value must be one of these values: ODD,EVEN,MARK,SPACE or NONE.", PARITY);
    end
end

// 打拍同步 tx_en 信号，检测上升沿
reg [2:0] tx_en_sr;
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) tx_en_sr <= 3'b111;
    else        tx_en_sr <= {tx_en_sr[1:0], tx_en};
end
wire tx_en_rising_edge = (tx_en_sr[2:1] == 2'b01); // 上升降沿检测

//  当 tx_en 检测到上升沿时, 寄存输入的并行数据, 并拉高 busy 信号
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        data_reg    <=  8'b0        ;
        tx_busy     <=  1'b0        ;
    end else if (tx_en_rising_edge) begin
        data_reg    <=  tx_data     ;   //  检测到上升沿, 寄存输入的并行数据
        tx_busy     <=  1'b1        ;   //  拉高 busy 信号
    end else if (bit_cnt == STOP_BIT_INDEX && baud_cnt == STOP_END_CNT - 1'b1) begin
        data_reg    <=  8'b0        ;   //  计数到停止位时清空发送数据寄存器
        tx_busy     <=  1'b0        ;   //  拉低 busy 信号
    end else begin
        data_reg    <=  data_reg    ;
        tx_busy     <=  tx_busy     ;
    end
end

//  波特率计数器
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        baud_cnt    <=  16'd0           ;
    end else if (tx_busy) begin 
        if(bit_cnt == STOP_BIT_INDEX) begin             //  停止位阶段
            if(baud_cnt < STOP_END_CNT)         
                baud_cnt <= baud_cnt + 1'b1     ;       //  计数器计数到结束时刻
            else
                baud_cnt <= 16'd0               ;       // 到达停止位结束时刻，清零（随后rx_flag变低）
        end else begin
            if (baud_cnt < BAUD_CNT_MAX - 1'b1) begin   //  正常阶段，非停止位正常循环计数
                baud_cnt    <=  baud_cnt + 1'b1 ;       //  接收过程时计数器循环计数
            end else begin
                baud_cnt <= 16'd0               ;       // 完成了一个计数周期后清零
            end
        end
    end else begin
        baud_cnt    <=  16'd0                   ;       //  空闲状态清零
    end
end

//  接收数据计数器
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        bit_cnt         <=  4'd0            ;
    end else if (tx_en_rising_edge) begin 
        bit_cnt         <=  4'd0            ;
    end else if (tx_busy) begin 
        if (bit_cnt < STOP_BIT_INDEX) begin
            if(baud_cnt == BAUD_CNT_MAX - 1'b1) begin  // 每个位周期结束时自增
                bit_cnt <=  bit_cnt + 1'b1  ;
            end else begin
                bit_cnt <=  bit_cnt         ;
            end
        end else begin      // 已到达停止位索引，保持不变，等待 rx_flag 拉低
            bit_cnt     <=  bit_cnt         ;
        end
    end else begin
        bit_cnt <= 4'd0 ;   //  空闲状态清零
    end
end

//  根据 bit_cnt 来发送数据到 txd 端口
always @(posedge clk or negedge rst_n) begin
    if(!rst_n) 
        txd <=  1'b1    ;
    else if(tx_busy) begin                          // 系统发送忙状态时
        if(baud_cnt == BAUD_CNT_MID - 1'b1) begin   // 判断 baud_cnt 是否计数到数据位的中间
            if (bit_cnt == 0) begin
                txd <=  1'b0                ;   //  起始位
            end else if((bit_cnt >= 1) && (bit_cnt <= DATA_BITS)) begin
                txd <=  data_reg[bit_cnt-1] ;   //  由低到高位发送数据
            end else if (HAS_PARITY == 1'b1 && bit_cnt == STOP_BIT_INDEX - 1) begin
                txd <=  parity_bit          ;   //  发送校验位
            end
        end else begin
            txd <=  txd ;
        end
    end else begin
        txd <=  1'b1    ;   // 空闲时清零（不保留残余）
    end
end

endmodule

串口接收模块

该模块负责串口数据的接收

// FILE_HEADER_HEADER-------------------------------------------------------------------------------
// Copyright (c) 2026, Mr. Tian. All rights reserved.
//--------------------------------------------------------------------------------------------------
// FILE NAME        : uart_rx.v
// AUTHOR           : Mr. Tian
// DESCRIPTION      : UART receiver
//--------------------------------------------------------------------------------------------------
// REVISION HISTORY :
//  Rev: (2026-05-06) - Mr. Tian
//          Initial release.
// FILE_HEADER_FOOTER-------------------------------------------------------------------------------
module uart_rx # (
    parameter   CLOCK_FREQ  =   32'd100_000_000 ,   //  输入时钟频率 (200MHz)
    parameter   BAUD_RATE   =   32'd115200      ,   //  波特率
    parameter   DATA_BITS   =   8               ,   //  数据位
    parameter   PARITY      =   "ODD"           ,   //  校验方式，有 ODD(奇校验)、EVEN(偶校验)、SPACE(始终为 0)、MARK(始终为 1)、NONE(无校验)
    parameter   STOP_BITS   =   "1"                 //  停止位: 1, 1.5, 2，输入其它值则默认为 1 停止位
) (
    input                   clk     ,   //  [I][     ] 模块时钟
    input                   rst_n   ,   //  [I][     ] 复位信号，低有效

    input   wire            rxd     ,   //  [I][     ] RXD 信号线
    
    output  reg     [07:00] rx_data ,   //  [O][07:00] 接收到的数据
    output  reg             rx_done ,   //  [O][     ] 接收完成标志（高脉冲）
    output  reg             rx_err      //  [O][     ] 错误标志（校验错误或帧错误）
);

localparam  BAUD_CNT_MAX        =   CLOCK_FREQ / BAUD_RATE  ;   //  计数器的最大计数值
localparam  BAUD_CNT_MID        =   BAUD_CNT_MAX / 2        ;   //  计数器值的中点
localparam  HAS_PARITY          =   (PARITY != "NONE")      ;   //  是否使用了校验位
localparam  STOP_BIT_INDEX      =   DATA_BITS + (HAS_PARITY ? 1 : 0) + 1 ;  // 停止位在 bit_cnt 中的位置

// 根据停止位长度计算停止位结束时刻的 baud_cnt 计数值
// 1   -> 在停止位中点（BAUD_CNT_MAX/2 - 1）结束
// 1.5 -> 在停止位中点后继续 1 个位周期（BAUD_CNT_MAX + BAUD_CNT_MAX/2 - 1）
// 2   -> 在停止位中点后继续 1.5 个位周期（2*BAUD_CNT_MAX - 1）
// 为了保持代码一致，减 1 的操作在 always 语句中进行
localparam  STOP_BITS1_CNT      =   BAUD_CNT_MAX/2                  ;   //  停止位为 1   时计数器的值
localparam  STOP_BITS1_5_CNT    =   BAUD_CNT_MAX + BAUD_CNT_MAX/2   ;   //  停止位为 1.5 时计数器的值
localparam  STOP_BITS2_CNT      =   (2 * BAUD_CNT_MAX)              ;   //  停止位为 2   时计数器的值

localparam  STOP_END_CNT        =   (STOP_BITS == "1"  ) ? (STOP_BITS1_CNT  ) :
                                    (STOP_BITS == "1.5") ? (STOP_BITS1_5_CNT) :
                                    (STOP_BITS == "2"  ) ? (STOP_BITS2_CNT  ) :
                                     STOP_BITS1_CNT                             ;   // 停止位计数器的值，默认按停止位 1 处理

reg [31:00] baud_cnt    ;
reg [03:00] bit_cnt     ;
reg [07:00] rx_reg      ;
reg         rx_parity   ;   //  接收到的校验位

// 打拍同步 rxd 信号，检测下降沿
reg [2:0] rxd_sync;
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) rxd_sync <= 3'b111;
    else        rxd_sync <= {rxd_sync[1:0], rxd};
end
wire rxd_fall = (rxd_sync[2:1] == 2'b10); // 下降沿检测
wire rxd_s    = rxd_sync[2];              // 同步后的电平

// 校验计算逻辑
wire    parity_check;
assign  parity_check    =  (PARITY == "ODD"  ) ? ~(^rx_reg[DATA_BITS-1:0]) :
                           (PARITY == "EVEN" ) ?   ^rx_reg[DATA_BITS-1:0]  :
                           (PARITY == "MARK" ) ? 1'b1 :
                           (PARITY == "SPACE") ? 1'b0 :
                           (PARITY == "NONE" ) ? 1'b0 :
                           1'bz;
initial begin
    if (
        !((PARITY == "ODD"  ) ||
          (PARITY == "EVEN" ) ||
          (PARITY == "MARK" ) ||
          (PARITY == "SPACE") ||
          (PARITY == "NONE" ))
    ) begin
        $error("Unknown PARITY value: [%s], for parameter PARITY, its value must be one of these values: ODD,EVEN,MARK,SPACE or NONE.", PARITY);
    end
end

// 接收标志指示器
reg     rx_flag;
wire    start_en = rxd_fall & ~rx_flag;
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        rx_flag <=  1'b0    ;
    end else if (start_en) begin    //  检测到起始位
        rx_flag <=  1'b1    ;       //  接收过程中，标志信号 rx_flag 拉高
        // 根据停止位长度，在指定时刻结束接收
    end else if (bit_cnt == STOP_BIT_INDEX && baud_cnt == STOP_END_CNT - 1'b1) begin
        rx_flag <=  1'b0    ;
    end else begin
        rx_flag <= rx_flag  ;
    end
end

//  波特率计数器
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        baud_cnt    <=  16'd0           ;
    end else if (rx_flag) begin 
        if(bit_cnt == STOP_BIT_INDEX) begin             //  停止位阶段
            if(baud_cnt < STOP_END_CNT)         
                baud_cnt <= baud_cnt + 1'b1     ;       //  计数器计数到结束时刻
            else
                baud_cnt <= 16'd0               ;       // 到达停止位结束时刻，清零（随后rx_flag变低）
        end else begin
            if (baud_cnt < BAUD_CNT_MAX - 1'b1) begin   //  正常阶段，非停止位正常循环计数
                baud_cnt    <=  baud_cnt + 1'b1 ;       //  接收过程时计数器循环计数
            end else begin
                baud_cnt <= 16'd0               ;       // 完成了一个计数周期后清零
            end
        end
    end else begin
        baud_cnt    <=  16'd0                   ;       //  空闲状态清零
    end
end

//  接收数据计数器
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        bit_cnt         <=  4'd0            ;
    end else if (rx_flag) begin 
        if (bit_cnt < STOP_BIT_INDEX) begin
            if(baud_cnt == BAUD_CNT_MAX - 1'b1) begin  // 每个位周期结束时自增
                bit_cnt <=  bit_cnt + 1'b1  ;
            end else begin
                bit_cnt <=  bit_cnt         ;
            end
        end else begin      // 已到达停止位索引，保持不变，等待 rx_flag 拉低
            bit_cnt     <=  bit_cnt         ;
        end
    end else begin
        bit_cnt <= 4'd0 ;   //  空闲状态清零
    end
end

//  根据 bit_cnt 来寄存 rxd 端口数据
always @(posedge clk or negedge rst_n) begin
    if(!rst_n) begin
        rx_reg      <= 8'b0                     ;
        rx_parity   <=  1'b0                    ;
    end else if(rx_flag) begin                          // 系统处于接收过程时
        if(baud_cnt == BAUD_CNT_MID - 1'b1) begin   // 判断 baud_cnt 是否计数到数据位的中间
            if((bit_cnt >= 1) && (bit_cnt <= DATA_BITS)) begin
                rx_reg[bit_cnt-1]   <= rxd_s    ;   //  数据位采样 (按位索引写入)
            end else if (HAS_PARITY == 1'b1 && bit_cnt == STOP_BIT_INDEX - 1'b1) begin
                rx_parity           <=  rxd_s   ;   //  采样校验位
            end
        end else begin
            rx_reg <= rx_reg;
        end
    end else begin
        rx_reg <= 8'b0;   // 空闲时清零（不保留残余）
    end
end

//  校验位判断, 若校验位不通过则将 rx_err 置 1
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        rx_err  <=  1'b0    ;
    end else if ((HAS_PARITY == 1'b1) && (rx_parity == parity_check)) begin
        rx_err  <=  1'b0    ;
    end else begin
        rx_err  <=  1'b1    ;
    end
end

//  赋值接收完成信号和接收到的数据
always @(posedge clk or negedge rst_n) begin
    if(!rst_n) begin
        rx_done <= 1'b0;
        rx_data <= 8'b0;
    end
    // 在停止位中点采样完毕时输出数据
    else if((bit_cnt == STOP_BIT_INDEX) && (baud_cnt == BAUD_CNT_MID - 1'b1)) begin
        rx_done <= 1'b1     ;  // 拉高接收完成信号
        rx_data <= rx_reg   ;  // 并对UART接收到的数据进行赋值
    end    
    else begin
        rx_done <= 1'b0     ;
        rx_data <= rx_data  ;
    end
end

endmodule

封装后的串口顶层

为了方便使用，直接将发送模块和接收模块作为两个子模块封装到一个顶层模块中。

// FILE_HEADER_HEADER-------------------------------------------------------------------------------
// Copyright (c) 2026, Mr. Tian. All rights reserved.
//--------------------------------------------------------------------------------------------------
// FILE NAME        : uart.v
// AUTHOR           : Mr. Tian
// DESCRIPTION      : Top level UART module encapsulating TX and RX
//--------------------------------------------------------------------------------------------------
// REVISION HISTORY :
//  Rev: (2026-05-06) - Mr. Tian
//          Initial release.
// FILE_HEADER_FOOTER-------------------------------------------------------------------------------
module uart # (
    parameter               CLOCK_FREQ  =   32'd100_000_000 ,   //  输入时钟频率 (200MHz)
    parameter               BAUD_RATE   =   32'd115200      ,   //  波特率
    parameter               DATA_BITS   =   8               ,   //  数据位
    parameter   [8*8-1:0]   PARITY      =   "ODD"           ,   //  校验方式，有 ODD(奇校验)、EVEN(偶校验)、SPACE(始终为 0)、MARK(始终为 1)、NONE(无校验)
    parameter   [8*8-1:0]   STOP_BITS   =   "1"                 //  停止位: 1, 1.5, 2，输入其它值则默认为 1 停止位
) (
    input                   clk     ,
    input                   rst_n   ,

    // TX 接口
    input   wire            tx_en   ,
    input   wire    [07:00] tx_data ,
    output  wire            tx_busy ,
    output  wire            txd     ,

    // RX 接口
    input   wire            rxd     ,
    output  wire    [07:00] rx_data ,
    output  wire            rx_done ,
    output  wire            rx_err
);

// 实例化发送模块
uart_tx #(
    .CLOCK_FREQ (CLOCK_FREQ ),
    .BAUD_RATE  (BAUD_RATE  ),
    .DATA_BITS  (DATA_BITS  ),
    .PARITY     (PARITY     ),
    .STOP_BITS  (STOP_BITS  )
) uart_tx_inst (
    .clk        (clk        ),
    .rst_n      (rst_n      ),
    .tx_en      (tx_en      ),
    .tx_data    (tx_data    ),
    .tx_busy    (tx_busy    ),
    .txd        (txd        )
);

// 实例化接收模块
uart_rx #(
    .CLOCK_FREQ (CLOCK_FREQ ),
    .BAUD_RATE  (BAUD_RATE  ),
    .DATA_BITS  (DATA_BITS  ),
    .PARITY     (PARITY     ),
    .STOP_BITS  (STOP_BITS  )
) uart_rx_inst (
    .clk        (clk        ),
    .rst_n      (rst_n      ),
    .rxd        (rxd        ),
    .rx_data    (rx_data    ),
    .rx_done    (rx_done    ),
    .rx_err     (rx_err     )
);

endmodule

回环测试(工程顶层)代码

在这里我使用的开发板型号为 XC7K325TFFG900-2，时钟输入为差分信号输入

// FILE_HEADER_HEADER-------------------------------------------------------------------------------
// Copyright (c) 2026, Mr. Tian. All rights reserved.
//--------------------------------------------------------------------------------------------------
// FILE NAME        : uart_loopback_top.v
// AUTHOR           : Mr. Tian.
// DESCRIPTION      : Top module for uart loopback
//--------------------------------------------------------------------------------------------------
// REVISION HISTORY :
//  Rev: (2026-05-06) - Mr. Tian.
//          Initial release.
// FILE_HEADER_FOOTER-------------------------------------------------------------------------------
module uart_loopback_top # (
    parameter   CLOCK_FREQ  =   32'd200_000_000 ,   //  输入时钟频率 (200MHz)
    parameter   BAUD_RATE   =   32'd115200      ,   //  波特率
    parameter   DATA_BITS   =   8               ,   //  数据位
    parameter   PARITY      =   "NONE"           ,   //  校验方式，有 ODD(奇校验)、EVEN(偶校验)、SPACE(始终为 0)、MARK(始终为 1)、NONE(无校验)
    parameter   STOP_BITS   =   "1"                 //  停止位: 1, 1.5, 2，输入其它值则默认为 1 停止位
) (
    input                   sys_clk_p,              // 200MHz 差分时钟 P 端
    input                   sys_clk_n,              // 200MHz 差分时钟 N 端
    input                   rst_n   ,               // 复位信号（低有效）

    // 硬件引脚连接到串口芯片
    input                   uart_rxd,               // UART 接收引脚
    output                  uart_txd,               // UART 发送引脚
    
    // 连接到 LED 的状态指示
    output                  led_rx_done,
    output                  led_err
);

// 差分时钟输入转单端时钟输出
wire clk_200m_single;
IBUFDS ibufds_inst (
    .I  (   sys_clk_p       ),
    .IB (   sys_clk_n       ),
    .O  (   clk_200m_single )
);

// 例化串口模块
wire            tx_en   ;
wire    [07:00] tx_data ;
wire    [07:00] rx_data ;
wire            tx_busy ;
wire            rx_done ;
uart # (
    .CLOCK_FREQ (CLOCK_FREQ ),
    .BAUD_RATE  (BAUD_RATE  ),
    .DATA_BITS  (DATA_BITS  ),
    .PARITY     (PARITY     ),
    .STOP_BITS  (STOP_BITS  )
) uart_inst (
    .clk        (   clk_200m_single ),
    .rst_n      (   rst_n           ),

    // TX interface
    .tx_en      (   tx_en           ),
    .tx_data    (   tx_data         ),
    .tx_busy    (   tx_busy         ),
    .txd        (   uart_txd        ),

    // RX interface
    .rxd        (   uart_rxd        ),
    .rx_data    (   rx_data         ),
    .rx_done    (   rx_done         ),
    .rx_err     (   led_err         )
);

assign tx_data      = rx_data; // 回环测试：发送的数据为接收到的数据
assign tx_en        = rx_done; // 回环测试：发送使能信号为接收完成信号
assign led_rx_done  = rx_done; // 将接收完成信号输出到板载的一颗 led 上

endmodule

ETH-04 ARP 通信协议简介及实现代码

Thu, 16 Apr 2026 11:25:17 GMT

ARP 协议简介

ARP（Address Resolution Protocol，地址解析协议） 是一种根据 IP 地址 (逻辑地址) 获取 MAC 地址 (物理地址) 的 TCP/IP 协议。

在以太网环境中，设备之间的通信依赖于 MAC 地址，但上层应用通常只知道目标设备的 IP 地址。ARP 协议通过 "一问一答" 的机制，解决了 "已知 IP 地址，如何找到对应 MAC 地址" 的问题，确保数据能够正确封装并送达目标设备。

其工作过程简述如下：主机 A 发送数据时，按照以太网帧格式封装，但将目标 MAC 地址设置为广播地址（FF:FF:FF:FF:FF:FF）。这样，局域网内所有主机都会收到该数据包。只有 IP 地址与目标匹配的主机 B 会响应，将自己的 MAC 地址发送给主机 A，从而完成地址解析。其他非对应 IP 的主机则自动忽略该广播包。

补充说明：TCP/IP 协议簇
TCP/IP 是互联网的核心通信协议，它并非单一的协议，而是一个协议簇 (协议集合) ，定义了设备之间如何联网和通信。其名称来源于其中最著名的两个协议：TCP (传输控制协议) 和 IP (互联网协议)。ARP 正是这个协议簇中的一员。

ARP 请求

当主机需要与目标 IP 通信，但不知道目标 IP 的 MAC 地址时，会构造 ARP 请求报文，并以广播的方式（目标 MAC 地址为 FF:FF:FF:FF:FF:FF）发送到整个局域网

特点：广播发送，局域网内所有的设备都会收到这个数据包，但只有目标 IP 地址匹配的设备才会处理

ARP 应答

当目标设备收到 ARP 请求后，发现目标 IP 与自己的 IP 匹配，会构造 ARP 应答报文，并以单播的方式直接回复给请求方。

特点：单播发送，同时目标设备也会将请求方的 IP-MAC 映射记录到自己的 ARP 缓存中。

ARP 协议数据格式

以太网帧格式

ARP 协议的以太网帧数据格式如下图所示，ARP 数据位于以太网数据帧中的数据段部分。

ARP 数据报格式

ARP 数据报位于以太网帧中的数据段中，它的格式如下图所示。

硬件类型：指定底层网络硬件类型。对于以太网，值为 1 (0x0001)。
协议类型：要映射的协议地址类型，ARP协议的上层协议为IP协议，因此该协议类型为IP协议，其值为 0x0800。
硬件地址长度：硬件地址（MAC地址）的长度，以字节为单位。对于以太网上 IP 地址的 ARP 请求或者应答来说，该值为6。
协议地址长度：IP 地址的长度，以字节为单位。对于以太网上 IP 地址的 ARP 请求或者应答来说，该值为4。
操作码 (OP)：用于表示该数据包为 ARP 请求或者 ARP 应答。1 表示 ARP 请求，2 表示ARP 应答。
源 MAC 地址：发送端的 MAC 地址，即硬件地址
源 IP 地址： 发送端的 IP 地址，即协议地址
目的 MAC 地址：接收端的 MAC 地址，即硬件地址
目的 IP 地址： 接收端的 IP 地址，即协议地址

实现代码

基于之前文章 ETH-03 以太网帧结构介绍以及 Verilog 实现代码中的以太网帧封包模块，我们只需要向模块中发送数据段的 ARP 数据即可。

ARP 发送模块

只需要发送 ARP 数据段的内容给以太网封包模块即可。

模块工作过程：

上游控制模块为端口arp_tx_en 产生一个高电平脉冲。之后模块将在端口 s_axis_tdv 产生持续的高电平信号，给下游的以太网封包模块。
模块等待下游以太网封包模块拉高 s_axis_trdy 信号，之后开始发送 ARP 数据。
发送到最后一个字节的 ARP 数据时，产生 s_axis_tend 信号。

完整的实现代码如下：

module arp_tx (
    input   wire            clk             ,   //  [I] [     ] module clock
    input   wire            rst_n           ,   //  [I] [     ] module reset, active-low
    input   wire            arp_tx_en       ,   //  [I] [     ] ARP TX enable signal, active-high pulse signal
    input   wire            arp_tx_type     ,   //  [I] [     ] ARP TX type, 1'b0: ARP req, 1'b1: ARP ack

    input   wire    [47:0]  tx_src_mac      ,   //  [I] [47:00] Source MAC address to be send
    input   wire    [47:0]  tx_dst_mac      ,   //  [I] [47:00] Destination MAC address to be send
    input   wire    [31:0]  tx_src_ip       ,   //  [I] [31:00] Source IP address to be send
    input   wire    [31:0]  tx_dst_ip       ,   //  [I] [31:00] Destination IP address to be send

    // downstream: ethernet pack encapsulation
    input   wire            encap_busy      ,   //  [I] [     ] encapsulation module busy state input, we only send arp packet when this signal is 1'b0    
    output  reg     [7:0]   s_axis_td       ,   //  [O] [07:00] axis send data output to encapsulation module
    output  reg             s_axis_tdv      ,   //  [O] [     ] axis send data valid output to encapsulation module
    output  reg             s_axis_tend     ,   //  [O] [     ] axis send tend output to encapsulation module
    input   wire            s_axis_trdy         //  [I] [     ] axis send ready signal
);

//================================================================================
// Local Parameter Declarations
//================================================================================
// states define
localparam  ST_IDLE         =   2'd0        ;
localparam  ST_ARP_DATA     =   2'd1        ;
localparam  ST_ARP_END      =   2'd2        ;

// local parameters
localparam  ETH_TYPE        =   16'h0806    ;
localparam  HD_TYPE         =   16'h0001    ;
localparam  PROTOCOL_TYPE   =   16'h0800    ;
localparam  MAC_ADD_LEN     =   8'h06       ;
localparam  IP_ADD_LEN      =   8'h04       ;
localparam  OP_CODE         =   16'h0001    ;

localparam  PREAMBLE_WORD   =   8'h55       ;
localparam  SFD_WORD        =   8'hd5       ;

//================================================================================
// Register Declarations
//================================================================================
reg [1:0]   state               ;
reg [7:0]   arp_data    [27:0]  ;
reg [4:0]   arp_cnt             ;

reg [2:0]   arp_tx_en_sr        ;
reg         arp_tx_en_latch     ;

//================================================================================
// Wire Declarations
//================================================================================
wire        arp_tx_en_pulse     ;

//================================================================================
// Assign Declarations
//================================================================================
assign  arp_tx_en_pulse = {arp_tx_en_sr[0] & !arp_tx_en_sr[1]};

//================================================================================
// MAIN CODE
//================================================================================

// sync arp_tx_en signal
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        arp_tx_en_sr <= 3'b000  ;
    end else begin
        arp_tx_en_sr <= {arp_tx_en_sr[1:0], arp_tx_en}  ;
    end
end

always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        arp_data[00]    <=  HD_TYPE[15:08]      ;
        arp_data[01]    <=  HD_TYPE[07:00]      ;
        arp_data[02]    <=  PROTOCOL_TYPE[15:08];
        arp_data[03]    <=  PROTOCOL_TYPE[07:00];
        arp_data[04]    <=  MAC_ADD_LEN         ;
        arp_data[05]    <=  IP_ADD_LEN          ;
        arp_data[06]    <=  OP_CODE[15:08]      ;
        arp_data[07]    <=  OP_CODE[07:00]      ;
        arp_data[08]    <=  8'b00   ;
        arp_data[09]    <=  8'b00   ;
        arp_data[10]    <=  8'b00   ;
        arp_data[11]    <=  8'b00   ;
        arp_data[12]    <=  8'b00   ;
        arp_data[13]    <=  8'b00   ;
        arp_data[14]    <=  8'b00   ;
        arp_data[15]    <=  8'b00   ;
        arp_data[16]    <=  8'b00   ;
        arp_data[17]    <=  8'b00   ;
        arp_data[18]    <=  8'b00   ;
        arp_data[19]    <=  8'b00   ;
        arp_data[20]    <=  8'b00   ;
        arp_data[21]    <=  8'b00   ;
        arp_data[22]    <=  8'b00   ;
        arp_data[23]    <=  8'b00   ;
        arp_data[24]    <=  8'b00   ;
        arp_data[25]    <=  8'b00   ;
        arp_data[26]    <=  8'b00   ;
        arp_data[27]    <=  8'b00   ;

        s_axis_tdv      <=  1'b0    ;
        arp_tx_en_latch <=  1'b0    ;
        s_axis_tend     <=  1'b0    ;
        s_axis_td       <=  8'b0    ;
        arp_cnt         <=  5'd0    ;
        state           <=  ST_IDLE ;
    end else begin
        if (arp_tx_en_pulse) arp_tx_en_latch  <=  1'b1        ;

        case (state)
            ST_IDLE: begin
                s_axis_tend <=  1'b0    ;
                s_axis_td   <=  8'b0    ;
                arp_cnt     <=  5'd0    ;
                s_axis_tdv  <=  1'b0    ;
                if ((arp_tx_en_latch == 1'b1) && (encap_busy == 1'b0)) begin
                    arp_tx_en_latch <=  1'b0                ;
                    arp_data[08]    <=  tx_src_mac[47:40]   ;
                    arp_data[09]    <=  tx_src_mac[39:32]   ;
                    arp_data[10]    <=  tx_src_mac[31:24]   ;
                    arp_data[11]    <=  tx_src_mac[23:16]   ;
                    arp_data[12]    <=  tx_src_mac[15:08]   ;
                    arp_data[13]    <=  tx_src_mac[07:00]   ;
                    arp_data[14]    <=  tx_src_ip [31:24]   ;
                    arp_data[15]    <=  tx_src_ip [23:16]   ;
                    arp_data[16]    <=  tx_src_ip [15:08]   ;
                    arp_data[17]    <=  tx_src_ip [07:00]   ;
                    arp_data[18]    <=  tx_dst_mac[47:40]   ;
                    arp_data[19]    <=  tx_dst_mac[39:32]   ;
                    arp_data[20]    <=  tx_dst_mac[31:24]   ;
                    arp_data[21]    <=  tx_dst_mac[23:16]   ;
                    arp_data[22]    <=  tx_dst_mac[15:08]   ;
                    arp_data[23]    <=  tx_dst_mac[07:00]   ;
                    arp_data[24]    <=  tx_dst_ip [31:24]   ;
                    arp_data[25]    <=  tx_dst_ip [23:16]   ;
                    arp_data[26]    <=  tx_dst_ip [15:08]   ;
                    arp_data[27]    <=  tx_dst_ip [07:00]   ;

                    if (arp_tx_type == 1'b0) begin
                        arp_data[7]     <=  8'h01   ;
                        arp_data[18]    <=  8'h00   ;
                        arp_data[19]    <=  8'h00   ;
                        arp_data[20]    <=  8'h00   ;
                        arp_data[21]    <=  8'h00   ;
                        arp_data[22]    <=  8'h00   ;
                        arp_data[23]    <=  8'h00   ;
                    end else begin
                        arp_data[7]     <=  8'h02   ;
                    end

                    state           <=  ST_ARP_DATA     ;
                    s_axis_tdv      <=  1'b1            ;
                end
            end

            ST_ARP_DATA: begin
                if (s_axis_trdy == 1'b1) begin
                    s_axis_td   <=  arp_data[arp_cnt]   ;
                    arp_cnt     <=  arp_cnt + 1'b1      ;
                    if (arp_cnt == 5'd27) begin
                        s_axis_tend <=  1'b1            ;
                        state       <=  ST_ARP_END      ;
                    end
                end
            end

            ST_ARP_END: begin
                s_axis_tend <=  1'b0    ;
                s_axis_td   <=  8'd0    ;
                s_axis_tdv  <=  1'b0    ;
                arp_cnt     <=  5'd0    ;
                state       <=  ST_IDLE ;
            end
        endcase
    end
end

endmodule

ARP 接收模块

接收模块同样从以太网帧解包模块中接收负载数据，负载数据即为 ARP 数据内容。

模块工作过程：

从上游以太网帧解包模块中等待 s_axis_rdv 信号，表明负载数据有效。
开始按字节计数，将接收到的数据寄存
判断目的 IP 地址是否为板卡 IP 地址，如果是板卡的 IP 地址，则将寄存的源 MAC 地址输出到模块的端口，方便其它模块调用，否则将接收到的数据丢弃。

module arp_rx (
    input   wire            clk             ,   //  [I] [     ] Module clock
    input   wire            rst_n           ,   //  [I] [     ] Module reset signal, active-low

    input   wire    [15:00] eth_type        ,   //  [I] [15:00] received ethertype
    output  reg     [47:00] src_mac         ,   //  [O] [47:00] Received source MAC address
    output  reg     [31:00] src_ip          ,   //  [O] [31:00] Received source IP address
    input   wire    [31:00] board_ip        ,   //  [I] [31:00] Input board IP address, for comparison with received destination IP address

    // upstream: ethernet pack decapsulation
    input   wire            decap_busy      ,   //  [I] [     ] decapsulation module busy state input
    input   wire    [7:0]   s_axis_rd       ,   //  [I] [07:00] axis receive data input from decapsulation module
    input   wire            s_axis_rdv      ,   //  [I] [     ] axis receive data valid input from decapsulation module
    input   wire            s_axis_rend     ,   //  [I] [     ] axis receive tend input from decapsulation module
    output  reg             s_axis_rrdy     ,   //  [O] [     ] axis receive ready signal
    
    output  reg             arp_rx_done     ,   //  [O] [     ] ARP receive done signal, active-high
    output  reg             arp_rx_type         //  [O] [     ] ARP receive type, 1'b1: ack, 1'b0: req
);

//================================================================================
// Local Parameter Declarations
//================================================================================
localparam  ST_IDLE         =   2'b00   ;
localparam  ST_ARP_DATA     =   2'b01   ;
localparam  ST_ARP_END      =   2'b10   ;

localparam  ETH_TYPE_ARP    =   16'h0806;

//================================================================================
// Register Declarations
//================================================================================
reg [47:00] dst_mac_t       ;
reg [31:00] dst_ip_t        ;
reg [47:00] src_mac_t       ;
reg [31:00] src_ip_t        ;
reg [15:00] op_data         ;

reg [01:00] state           ;
reg [04:00] data_bytes_cnt  ;

//================================================================================
// MAIN CODE
//================================================================================
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        state           <=  ST_IDLE ;
        data_bytes_cnt  <=  5'b0    ;
        s_axis_rrdy     <=  1'b0    ;
        op_data         <=  16'b0   ;
        dst_mac_t       <=  48'b0   ;
        dst_ip_t        <=  32'b0   ;
        src_mac_t       <=  48'b0   ;
        src_ip_t        <=  32'b0   ;
        src_mac         <=  48'b0   ;
        src_ip          <=  32'b0   ;
        arp_rx_done     <=  1'b0    ;
        arp_rx_type     <=  1'b0    ;
    end else begin 
        case(state) 
            ST_IDLE: begin
                data_bytes_cnt  <=  5'b0        ;
                s_axis_rrdy     <=  1'b1        ;
                arp_rx_done     <=  1'b0        ;
                
                if (
                    eth_type    ==  ETH_TYPE_ARP &&
                    s_axis_rdv  ==  1'b1        
                ) begin
                    state       <=  ST_ARP_DATA ;
                    data_bytes_cnt  <=  data_bytes_cnt + 1'b1   ;
                end else begin
                    state       <=  ST_IDLE     ;
                end
            end

            ST_ARP_DATA: begin
                data_bytes_cnt  <=  data_bytes_cnt + 1'b1           ;
                if (data_bytes_cnt >= 5'd6 && data_bytes_cnt < 5'd8) begin
                    op_data     <=  {op_data[7:0], s_axis_rd}       ;                   // OP code
                end else if (data_bytes_cnt >= 5'd8  && data_bytes_cnt < 5'd14) begin   
                    src_mac_t   <=  {src_mac_t[39:0], s_axis_rd}    ;                   // So urce MAC address
                end else if (data_bytes_cnt >= 5'd14 && data_bytes_cnt < 5'd18) begin
                    src_ip_t    <=  {src_ip_t[23:0], s_axis_rd}     ;                   // Source IP address
                end else if (data_bytes_cnt >= 5'd18 && data_bytes_cnt < 5'd24) begin
                    dst_mac_t   <=  {dst_mac_t[39:0], s_axis_rd}    ;                   // Destination MAC address
                end else if (data_bytes_cnt >= 5'd24 && data_bytes_cnt < 5'd28) begin
                    dst_ip_t    <=  {dst_ip_t[23:0], s_axis_rd}     ;                   // Destination IP address
                end else if (data_bytes_cnt >= 5'd28) begin
                    if (
                        dst_ip_t    == board_ip && 
                        ((op_data == 16'd1) || (op_data == 16'd2))
                    ) begin
                        arp_rx_done <=  1'b1        ;
                        src_mac     <=  src_mac_t   ;
                        src_ip      <=  src_ip_t    ;
                        dst_mac_t   <=  48'b0       ;
                        dst_ip_t    <=  32'b0       ;
                        src_mac_t   <=  48'b0       ;
                        src_ip_t    <=  32'b0       ;
                        if (op_data == 16'd1) begin
                            arp_rx_type <= 1'b0     ;   //  arp request
                        end else begin
                            arp_rx_type <= 1'b1     ;   //  arp ack
                        end
                        state   <=  ST_ARP_END      ;
                    end else begin
                        state   <= ST_ARP_END       ;
                    end
                end
            end

            ST_ARP_END: begin
                s_axis_rrdy     <=  1'b0            ;
                if (decap_busy == 1'b0) begin
                    state       <=  ST_IDLE         ;
                end
            end
        endcase
    end
end

endmodule

ARP 模块

这个模块是将两个模块进行整合封装到一个顶层，方便后续的例化

module arp (
    input                   rst_n       ,   //  [I] [     ] Module reset signal, active-low
    input                   gmii_tx_clk ,   //  [I] [     ] GMII TX clock
    input                   gmii_rx_clk ,   //  [I] [     ] GMII RX clock
    
    input   wire    [47:00] board_mac   ,   //  [I] [47:00] Input board MAC address, for comparison with received destination MAC address.
    input   wire    [31:00] board_ip    ,   //  [I] [31:00] Input board IP address, for comparison with received destination IP address.

    input   wire            decap_busy  ,   //  [I] [     ] Upstream decapsulation module busy state input
    input   wire            encap_busy  ,   //  [I] [     ] Downstream encapsulation module busy state input

    // arp rx
    input   wire    [07:00] s_axis_rd   ,   //  [I] [07:00] axis receive data input from decapsulation module
    input   wire            s_axis_rdv  ,   //  [I] [     ] axis receive data valid input from decapsulation module
    input   wire            s_axis_rend ,   //  [I] [     ] axis receive tend input from decapsulation module
    output  wire            s_axis_rrdy ,   //  [O] [     ] axis receive ready signal
    output  wire            arp_rx_done ,   //  [O] [     ] ARP receive done signal, active-high
    output  wire            arp_rx_type ,   //  [O] [     ] ARP receive type, 1'b1: ack, 1'b0: req
    input   wire    [15:00] eth_type    ,   //  [I] [15:00] received ethertype
    output  wire    [47:00] rx_src_mac  ,   //  [O] [47:00] Received source MAC address
    output  wire    [31:00] rx_src_ip   ,   //  [O] [31:00] Received source IP address

    // arp tx
    input   wire            arp_tx_en   ,   //  [I] [     ] ARP TX enable signal, active-high pulse signal
    input   wire            arp_tx_type ,   //  [I] [     ] ARP TX type, 1'b0: ARP req, 1'b1: ARP ack
    input   wire    [47:00] tx_dst_mac  ,   //  [I] [47:00] Destination MAC address to be send
    input   wire    [31:00] tx_dst_ip   ,   //  [I] [31:00] Destination IP address to be send
    output  wire    [07:00] s_axis_td   ,   //  [O] [07:00] axis send data output to encapsulation module
    output  wire            s_axis_tdv  ,   //  [O] [     ] axis send data valid output to encapsulation module
    output  wire            s_axis_tend ,   //  [O] [     ] axis send tend output to encapsulation module
    input   wire            s_axis_trdy     //  [I] [     ] axis send ready signal
);

arp_rx arp_rx_inst (
    .clk            (   gmii_rx_clk ),  //  [I] [     ] Module clock
    .rst_n          (   rst_n       ),  //  [I] [     ] Module reset signal, active-low
    
    .eth_type       (   eth_type    ),  //  [I] [15:00] received ethertype
    .src_mac        (   rx_src_mac  ),  //  [O] [47:00] Received source MAC address
    .src_ip         (   rx_src_ip   ),  //  [O] [31:00] Received source IP address
    .board_ip       (   board_ip    ),  //  [I] [31:00] Input board IP address, for comparison with received destination IP address

    .decap_busy     (   decap_busy  ),  //  [I] [     ] decapsulation module busy state input
    .s_axis_rd      (   s_axis_rd   ),  //  [I] [07:00] axis receive data input from decapsulation module
    .s_axis_rdv     (   s_axis_rdv  ),  //  [I] [     ] axis receive data valid input from decapsulation module
    .s_axis_rend    (   s_axis_rend ),  //  [I] [     ] axis receive tend input from decapsulation module
    .s_axis_rrdy    (   s_axis_rrdy ),  //  [O] [     ] axis receive ready signal
    .arp_rx_done    (   arp_rx_done ),  //  [O] [     ] ARP receive done signal, active-high
    .arp_rx_type    (   arp_rx_type )   //  [O] [     ] ARP receive type, 1'b1: ack, 1'b0: req
);

arp_tx arp_tx_inst (
    .clk            (   gmii_tx_clk ),  //  [I] [     ] Module clock
    .rst_n          (   rst_n       ),  //  [I] [     ] Module reset signal, active-low

    .tx_src_mac     (   board_mac   ),  //  [I] [47:00] Source MAC address to be send
    .tx_src_ip      (   board_ip    ),  //  [I] [31:00] Source IP address to be send
    .tx_dst_mac     (   tx_dst_mac  ),  //  [I] [47:00] Destination MAC address to be send
    .tx_dst_ip      (   tx_dst_ip   ),  //  [I] [31:00] Destination IP address to be send
    
    .encap_busy     (   encap_busy  ),  //  [I] [     ] encapsulation module busy state input, we only send arp packet when this signal is 1'b0    
    .s_axis_td      (   s_axis_td   ),  //  [O] [07:00] axis send data output to encapsulation module
    .s_axis_tdv     (   s_axis_tdv  ),  //  [O] [     ] axis send data valid output to encapsulation module
    .s_axis_tend    (   s_axis_tend ),  //  [O] [     ] axis send tend output to encapsulation module
    .s_axis_trdy    (   s_axis_trdy ),  //  [I] [     ] axis send ready signal
    .arp_tx_en      (   arp_tx_en   ),  //  [I] [     ] ARP TX enable signal, active-high pulse signal
    .arp_tx_type    (   arp_tx_type )   //  [I] [     ] ARP TX type, 1'b0: ARP req, 1'b1: ARP ack
);

ETH-03 以太网帧结构介绍以及 Verilog 实现代码

Wed, 15 Apr 2026 10:47:26 GMT

什么是以太网帧

以太网帧是指在网络中传输数据的基本单位。以太网帧按照一定的格式组成了以太网数据包。简单来讲，它类似于 "数据包裹(就像快递一样)"，包裹中包含了 "寄件人 (发送方 MAC 地址)"、"收件人 (接收方 MAC 地址)" 和 "包裹内容 (有效数据)"。以太网帧指的就是这个数据包本身。

理解以太网帧的组成是我们开始学习以太网 ARP、ICMP、UDP 等上层协议的基础。

以太网帧的组成 (格式)

数据格式如下图所示。

前导码 (Preamble)：固定的 7 字节 0x55，二进制表现为 0 和 1 交替。
帧起始界定符 (SFD)：全称：Start Frame Delimiter。固定的 1 字节 0xD5，二进制表现为 1101_1010
目的 MAC 地址：即接收端的物理 MAC 地址，占用 6 个字节，MAC 地址从应用上可分为以下三种类型
- 单播地址：第一个字节的最低位为 0，比如 00:00:00:11:11:11一般用于标志唯一的设备
- 组播地址：第一个字节的最低位为 1，比如01:00:00:11:11:11一般用于标志同属一组的多个设备
- 广播地址：所有的 48 bit 全部为 1，即FF:FF:FF:FF:FF:FF，它用于标志同一网段中的所有设备
源 MAC 地址：即发送端的 MAC 地址，占用 6 个字节
长度/类型：当这两个字节的值小于 1500 (对应十六进制 0x05DC) 时，代表该以太网数据包中的数据段长度；大于 1500 (对应十六进制 0x05DC) 时，代表以太网中的数据属于某个上层协议。例如，0x0800 代表 IP 协议 (国际协议)、0x0806 代表 ARP 协议 (地址解析协议) 等，其余内容会在以太网数据类型这个表中列出
数据段：长度最小46个字节，最大1500个字节。
- 最大值 1500 称为以太网的最大传输单元（MTU，Maximum Transmission Unit），之所以限制最大传输单元是因为在多个计算机的数据帧排队等待传输时，如果某个数据帧太大的话，接收这一帧的数据所带来的时间开销将会变高，从而导致体验变差。另外还要考虑网络I/O控制器缓存区资源以及网络最大的承载能力等因素，因此最大传输单元是由各种综合因素决定的。
- 为了避免增加额外的配置，通常以太网的有效数据字段都会小于1500个字节，现在电脑的配置已经足够接收巨型帧，巨型帧可以超过 1500 个字节。但是，要成功使用巨型帧，网络中的所有设备（包括交换机、路由器和主机）都必须支持巨型帧，并且 MTU 的大小必须一致。如果网络中的任何设备不支持巨型帧，或者 MTU 的大小不一致，那么数据包可能会被丢弃或者分片，从而影响网络性能。
帧检验序列（FCS）：全称：Frame Check Sequence。4 个字节的循环冗余校验码 (通常是CRC-32 校验)
- CRC 数据校验从目的 MAC 地址开始计算，直到数据段最后一个数据结束。通用的CRC标准有 CRC-8、CRC-16、CRC-32、CRC-CCIT，其中在网络通信系统中应用最广泛的是 CRC-32 标准。
帧间隙（IFG）：全称：Interpack Gap。即两帧之间的时间间隔，最小为 96bit time。
- IFG 的最小值是 96 bit time ，即在媒介中发送 96 位原始数据所需要的时间，在不同媒介中 IFG 的最小值是不一样的。不管 10M/100M/1000M 的以太网，两帧之间最少要有 96bit time，IFG 的最少间隔时间计算方法如下：
  - 10 Mbps 最小时间是 96*100ns = 9600ns
  - 100 Mbps 最小时间是 96*10ns = 960ns
  - 1000 Mbps 最小时间是 96*1ns = 96ns

以太网数据类型

在以太网数据包结构中，2 字节类型字段的内容如下表，其中加粗的类型为常用类型。

Ethertype <br>( 十六进制 )	协议
0x0800	网际协议（IP）
0x0806	地址解析协议（ARP ： Address Resolution Protocol）
0x0000 - 0x05DC	IEEE 802.3 长度
0x0101 – 0x01FF	实验
0x0600	XEROX NS IDP
0x0660, 0x0661	DLOG
0x0801	X.75 Internet
0x0802	NBS Internet
0x0803	ECMA Internet
0x0804	Chaosnet
0x0805	X.25 Level 3
0x0808	帧中继 ARP （Frame Relay ARP） [RFC1701]
0x6559	原始帧中继（Raw Frame Relay） [RFC1701]
0x8035	动态 DARP （DRARP：Dynamic RARP）<br>反向地址解析协议（RARP：Reverse Address Resolution Protocol）
0x8037	Novell Netware IPX
0x809B	EtherTalk
0x80D5	IBM SNA Services over Ethernet
0x 80F 3	AppleTalk 地址解析协议（AARP：AppleTalk Address Resolution Protocol）
0x8100	以太网自动保护开关（EAPS：Ethernet Automatic Protection Switching）
0x8137	因特网包交换（IPX：Internet Packet Exchange）
0x 814C	简单网络管理协议（SNMP：Simple Network Management Protocol）
0x86DD	网际协议v6 （IPv6，Internet Protocol version 6）
0x880B	点对点协议（PPP：Point-to-Point Protocol）
0x 880C	通用交换管理协议（GSMP：General Switch Management Protocol）
0x8847	多协议标签交换（单播） MPLS：Multi-Protocol Label Switching [unicast]）
0x8848	多协议标签交换（组播）（MPLS, Multi-Protocol Label Switching [multicast]）
0x8863	以太网上的 PPP（发现阶段）（PPPoE：PPP Over Ethernet [Discovery Stage]）
0x8864	以太网上的 PPP（PPP 会话阶段）（PPPoE，PPP Over Ethernet[PPP Session Stage]）
0x88BB	轻量级访问点协议（LWAPP：Light Weight Access Point Protocol）
0x88CC	链接层发现协议（LLDP：Link Layer Discovery Protocol）
0x8E88	局域网上的 EAP（EAPOL：EAP over LAN）
0x9000	配置测试协议（Loopback）
0x9100	VLAN 标签协议标识符（VLAN Tag Protocol Identifier）
0x9200	VLAN 标签协议标识符（VLAN Tag Protocol Identifier）
0xFFFF	保留

实现代码

以太网帧封包模块

该模块负责将来自上层协议的数据，如 ARP、UDP 协议 (包含上层协议的数据头) 等打包成标准的以太网帧，通过 GMII 接口输出。

模块工作方式：

上层协议模块将端口s_axis_tdv 拉高，此时封包模块开始发送前导码、SFD、目的 MAC 地址、源 MAC 地址以及以太网帧类型。
当前导内容发送完成后，s_axis_trdy 端口会被拉高，此时可以通过 s_axis_td 端口写入负载数据。
当负载数据写入最后一个字节时，上层协议模块给端口 s_axis_tend 一个时钟周期的脉冲信号，结束发送。
需要注意的是，上层协议模块给端口 s_axis_tend 产生脉冲后，封包模块并不会立即结束发送，而是继续发送 FCS 和等待帧间隙。
module_busy 信号在发送数据时 (从前导码开始，到 IFG 结束) 始终为高电平状态。

// NOTE_HEADER--------------------------------------------------------------------------------------
// Useage of this module:
//  - Port s_axis_tdv set to 1'b1
//  - Wait s_axis_rdy goes to 1'b1, write data to port s_axis_td
//  - When data write done, give an pulse signal to s_axis_tend
// NOTE_FOOTER--------------------------------------------------------------------------------------

module eth_frame_encap # (
    parameter   USE_DEBUG   =   1'b0        
) (
    input   wire            rst_n           ,   //  [I] [    ] reset signal, active-low

    // user input interface, (AXI-Stream)
    input   wire    [ 7:0]  s_axis_td       ,   //  [I] [ 7:0] tx data input
    input   wire            s_axis_tdv      ,   //  [I] [    ] tx data valid
    input   wire            s_axis_tend     ,   //  [I] [    ] the last data input,
    output  reg             s_axis_trdy     ,   //  [O] [    ] tx data ready signal, high logic when module can send data

    input   wire    [47:0]  src_mac         ,   //  [I] [47:0] Source MAC address to be send
    input   wire    [47:0]  dst_mac         ,   //  [I] [47:0] Destination MAC address to be send
    input   wire    [15:0]  eth_type        ,   //  [I] [15:0] Ethernet type (or data length, but we don't need this), 
                                                //             when its value is less than 1500(Decimal, 0x05DC in hex), it refers to IEEE 802.3 data length (we don't need this)
                                                //             when its value is bigger than 1500(Decimal, 0x05DC in hex), it refers to ethernet type
    output  wire            module_busy     ,   //  [O] [    ] module busy signal when sending data, active-high
    
    // GMII output interface
    input   wire            gmii_txc        ,   //  [I]
    output  reg     [7:0]   gmii_txd        ,   //  [O]
    output  reg             gmii_tx_en          //  [O]
);

//================================================================================
// Local Parameter Declarations
//================================================================================
localparam  PADDING_DATA    =   8'h00       ;   //  If data segment length is less than 46, padding this data until its length reach to 46.
localparam  PREAMBLE_WORD   =   8'h55       ;
localparam  SFD_WORD        =   8'hD5       ;
localparam  MIN_FRAME_LEN   =   8'd64       ;   //  Minimum frame length in bytes, includes 6 bytes dest_mac, 6 bytes src_mac, 2 bytes type/length, minum 46 bytes data segment and 4 bytes FCS
localparam  HEADER_LENGTH   =   8'd14       ;   //  Ethernet pack header length in bytes, 6 bytes dest_mac, 6 bytes src_mac and 2 bytes type/length
localparam  CRC_LENGTH      =   8'd4        ;   //  CRC data length in bytes
localparam  MIN_PAYLOAD     =   8'd46       ;   //  Minimum payload length
localparam  MAX_PAYLOAD     =   16'd1500    ;   //  Maximum payload length
localparam  IFG_CNT         =   4'd12       ;

// states defines
localparam  ST_IDLE         =   4'd0    ;   //  IDLE state
localparam  ST_PREAMBLE     =   4'd1    ;   //  State of sending preamble code, 7 bytes of 0x55
localparam  ST_SFD          =   4'd2    ;   //  State of sending SFD, Start Frame Delimiter, 1 byte of 0xd5
localparam  ST_DST_MAC      =   4'd3    ;   //  State of sending destination MAC Address
localparam  ST_SRC_MAC      =   4'd4    ;   //  State of sending source MAC Address
localparam  ST_ETH_TYPE     =   4'd5    ;   //  State of sending Ethernet type
localparam  ST_PAYLOAD      =   4'd6    ;   //  State of sending payload, the data content of this packet
localparam  ST_PADDING      =   4'd7    ;   //  State of padding data, if data content length is less than 46, then fill data.
localparam  ST_CRC          =   4'd8    ;   //  State of sending CRC result
localparam  ST_IFG          =   4'd9    ;   //  State of Interpacket GAP, 10Mbps min: 9600ns, 100Mbps min: 960ns, 1000Mbps min: 96ns

//================================================================================
// Register Declarations
//================================================================================
reg     [ 3:0]  state           ;
reg     [15:0]  byte_cnt        ;   // counter
reg     [15:0]  payload_len     ;   
reg     [ 3:0]  ifg_cnt         ;   //  IFG counter
reg     [ 7:0]  crc_data_in     ;
reg             crc_en          ;
reg             crc_clr         ;

//================================================================================
// Wire Declarations
//================================================================================
wire    [31:0]  crc_inv         ;
wire    [31:0]  crc_next_inv    ;

//================================================================================
// Assign Declarations
//================================================================================
assign  module_busy =   (state == ST_IDLE) ? 1'b0 : 1'b1    ;

//================================================================================
// implements
//================================================================================
crc32_d8 crc32_d8_inst (
    .clk            (   gmii_txc        ),  // [I] [    ] Module clock
    .rst_n          (   rst_n           ),  // [I] [    ] Reset signal, active-low
    .data           (   crc_data_in     ),  // [I] [ 7:0] The 8-bit data to be validated
    .crc_en         (   crc_en          ),  // [I] [    ] CRC enable
    .crc_clr        (   crc_clr         ),  // [I] [    ] CRC Result Clear
    .crc_next_inv   (   crc_next_inv    ),  // [O] [31:0] CRC data
    .crc_inv        (   crc_inv         )   // [O] [31:0] Inversed crc data
);

//================================================================================
// MAIN CODE
//================================================================================
generate
    if (USE_DEBUG == 1'b1) begin: ila_frame_encap
        ila_frame_encap ila_frame_encap_inst (
            .clk    (   gmii_txc    ),
            .probe0 (   state       ),  //  4b
            .probe1 (   byte_cnt    ),  //  16b
            .probe2 (   payload_len ),  //  16b
            .probe3 (   gmii_txd    ),  //  8b
            .probe4 (   gmii_tx_en  )   //  1b
        );
    end
endgenerate

always  @(posedge gmii_txc or negedge rst_n) begin
    if (!rst_n) begin
        state       <=  ST_IDLE ;
        crc_en      <=  1'b0    ;
        crc_clr     <=  1'b1    ;
        crc_data_in <=  8'b0    ;
        s_axis_trdy <=  1'b0    ;
        byte_cnt    <=  16'b0   ;
        ifg_cnt     <=  4'b0    ;
        gmii_txd    <=  8'b0    ;
        gmii_tx_en  <=  1'd0    ;
        payload_len <=  16'd0   ;
    end else begin
        case(state)
            ST_IDLE: begin
                payload_len <=  16'd0       ;
                crc_en      <=  1'b0        ;
                crc_clr     <=  1'b1        ;
                crc_data_in <=  8'b0        ;
                byte_cnt    <=  16'd0       ;
                ifg_cnt     <=  4'd0        ;
                gmii_txd    <=  8'b0        ;
                gmii_tx_en  <=  1'b0        ;
                s_axis_trdy <=  1'b0        ;   //  Stop receive upstream data
                if (s_axis_tdv) begin
                    state   <=  ST_PREAMBLE ;
                end
            end

            ST_PREAMBLE: begin
                s_axis_trdy     <=  1'b0            ;
                crc_clr         <=  1'b1            ;
                crc_en          <=  1'b0            ;
                gmii_txd        <=  PREAMBLE_WORD   ;
                gmii_tx_en      <=  1'b1            ;

                if (byte_cnt == 7-1) begin
                    state       <= ST_SFD           ;
                    byte_cnt    <=  16'd0           ;
                end else begin
                    byte_cnt        <=  byte_cnt + 1'b1 ;
                end
                // ... Preamble does not participate in CRC
            end

            ST_SFD: begin
                crc_clr     <=  1'b1                    ;
                crc_en      <=  1'b0                    ;

                s_axis_trdy <=  1'b0                    ;
                state       <=  ST_DST_MAC              ;
                gmii_txd    <=  SFD_WORD                ;
                byte_cnt    <=  16'd0                   ;
                // ... SFD does not participate in CRC
            end

            ST_DST_MAC: begin                               //  Send destination MAC address
                crc_clr     <=  1'b0                    ;
                crc_en      <=  1'b1                    ;   //  enable crc
                s_axis_trdy <=  1'b0                    ;
                
                case (byte_cnt)
                    0: begin gmii_txd <= dst_mac[47:40] ; crc_data_in <=  dst_mac[47:40]; end
                    1: begin gmii_txd <= dst_mac[39:32] ; crc_data_in <=  dst_mac[39:32]; end
                    2: begin gmii_txd <= dst_mac[31:24] ; crc_data_in <=  dst_mac[31:24]; end
                    3: begin gmii_txd <= dst_mac[23:16] ; crc_data_in <=  dst_mac[23:16]; end
                    4: begin gmii_txd <= dst_mac[15:08] ; crc_data_in <=  dst_mac[15:08]; end
                    5: begin gmii_txd <= dst_mac[07:00] ; crc_data_in <=  dst_mac[07:00]; end
                endcase

                // turn to next state
                if (byte_cnt == 6 - 1) begin
                    state       <= ST_SRC_MAC           ;
                    byte_cnt    <=  16'd0               ;
                end else begin
                    byte_cnt    <=  byte_cnt + 1'b1     ;
                end
            end

            ST_SRC_MAC: begin                               //  Send destination MAC address
                crc_clr     <=  1'b0                    ;
                crc_en      <=  1'b1                    ;   //  enable crc
                s_axis_trdy <=  1'b0                    ;
                
                case (byte_cnt)
                    0: begin gmii_txd <= src_mac[47:40] ; crc_data_in <=  src_mac[47:40]; end
                    1: begin gmii_txd <= src_mac[39:32] ; crc_data_in <=  src_mac[39:32]; end
                    2: begin gmii_txd <= src_mac[31:24] ; crc_data_in <=  src_mac[31:24]; end
                    3: begin gmii_txd <= src_mac[23:16] ; crc_data_in <=  src_mac[23:16]; end
                    4: begin gmii_txd <= src_mac[15:08] ; crc_data_in <=  src_mac[15:08]; end
                    5: begin gmii_txd <= src_mac[07:00] ; crc_data_in <=  src_mac[07:00]; end
                endcase

                // turn to next state
                if (byte_cnt == 6 - 1) begin
                    state       <= ST_ETH_TYPE          ;
                    byte_cnt    <=  16'd0               ;
                end else begin
                    byte_cnt    <=  byte_cnt + 1'b1     ;
                end
            end

            ST_ETH_TYPE: begin
                crc_clr     <=  1'b0                    ;
                crc_en      <=  1'b1                    ;   //  enable crc
                s_axis_trdy <=  1'b0                    ;

                case (byte_cnt)
                    0: begin 
                        gmii_txd    <= eth_type[15:08]  ; 
                        crc_data_in <= eth_type[15:08]  ;
                        s_axis_trdy <=  1'b1            ;   //  we can receive user data at next clock period
                    end
                    1: begin 
                        gmii_txd    <= eth_type[07:00]  ; 
                        crc_data_in <= eth_type[07:00]  ;
                    end
                endcase

                // turn to next state
                if (byte_cnt == 2 - 1) begin
                    s_axis_trdy <=  1'b1                ;   //  we can receive user data at next clock period
                    state       <= ST_PAYLOAD           ;
                end else begin
                    byte_cnt    <=  byte_cnt + 1'b1     ;
                end
            end

            ST_PAYLOAD: begin                               // axi-stream data in at this time.
                if (s_axis_tdv && s_axis_trdy) begin
                    s_axis_trdy <=  1'b1                ;
                    crc_clr     <=  1'b0                ;
                    crc_en      <=  1'b1                ;

                    gmii_txd    <=  s_axis_td           ;
                    crc_data_in <=  s_axis_td           ;
                    payload_len <=  byte_cnt + 1'b1     ;
                    byte_cnt    <=  byte_cnt + 1'b1     ;
                end

                // turn to next state
                if (    
                    s_axis_tdv      == 1'b1 && 
                    s_axis_trdy     == 1'b1 && 
                    s_axis_tend     == 1'b1
                ) begin

                    if (payload_len < MIN_PAYLOAD) begin
                        s_axis_trdy <=  1'b0            ;   //  Stop receive upstream data
                        state       <=  ST_PADDING      ;
                        byte_cnt    <=  16'd0           ;
                    end else begin
                        s_axis_trdy <=  1'b0            ;   //  Stop receive upstream data
                        state       <=  ST_CRC          ;
                        byte_cnt    <=  16'd0           ;
                    end
                end
            end

            ST_PADDING: begin                               //  if data in is less than MIN_PAYLOAD, padding data
                crc_clr         <=  1'b0                ;
                crc_en          <=  1'b1                ;
                s_axis_trdy     <=  1'b0                ;   //  Stop receive upstream data
                
                // turn to next state
                if (byte_cnt == MIN_PAYLOAD - payload_len) begin
                    state       <=  ST_CRC              ;
                    byte_cnt    <=  16'd0               ;
                end else begin
                    byte_cnt    <=  byte_cnt + 1'b1     ;
                    gmii_txd    <=  PADDING_DATA        ;
                    crc_data_in <=  PADDING_DATA        ;
                end
            end

            ST_CRC: begin
                s_axis_trdy     <=  1'b0                ;   //  Stop receive upstream data
                crc_en          <=  1'b0                ;
                case(byte_cnt)
                    0: gmii_txd <=  crc_next_inv[07:00] ;
                    1: gmii_txd <=  crc_inv[15:08]      ;
                    2: gmii_txd <=  crc_inv[23:16]      ;
                    3: gmii_txd <=  crc_inv[31:24]      ;
                endcase
                if (byte_cnt == 4 - 1) begin
                    state       <=  ST_IFG              ;
                end else begin
                    byte_cnt    <=  byte_cnt + 1'b1     ;
                end
            end

            ST_IFG: begin
                ifg_cnt     <=  ifg_cnt + 1'b1          ;
                crc_clr     <=  1'b1                    ;
                gmii_tx_en  <=  1'b0                    ;
                if (ifg_cnt >= (IFG_CNT - 1)) begin
                    state   <=  ST_IDLE                 ;
                end
            end

            default: state  <= ST_IDLE;
        endcase
    end
end

endmodule

以太网帧解包模块

该模块负责将以太网帧进行解包，从中分离出负载数据供下游模块使用。

模块工作方式：

模块接收来自网络中的以太网帧，当接收到以太网帧的前导码时，模块开始工作，拉高 module_busy 信号。
之后就开始接收前导码、起始帧界定符、目的 MAC、源 MAC 以及以太网类型。
接收完毕后比对接收到的目的 MAC 是否与板卡上的 MAC 一致，若一致则进入接收负载数据阶段。否则直接丢弃这个数据包。
接收负载阶段，s_axis_rdv 信号将会被拉高，直到负载阶段结束。负载阶段结束时 s_axis_rend 会产生一个时钟周期的高电平脉冲信号。

注意：为了能够完整的接收 FCS(帧校验序列)，模块中的做法制是制作一个 4 字节的缓冲区，将来自 gmii_rxd 的数据延迟 4 个字节发送到 s_axis_rd 端口上，这样直到 FCS 阶段结束，缓冲区内的 4 字节数据刚好就是接收到的 FCS 数据。

// NOTE_HEADER--------------------------------------------------------------------------------------
// HOW TO USE:
//  1. Set s_axis_rrdy to 1'b1, for enable receive data from RGMII interface.
//  2. Wait s_axis_rdv signal goes to 1'b1
//  3. Downstream receive data from s_axis_rd.
//  4. Wait active-high pulse signal from port s_axis_rend  
//  5. Receive finished
// NOTE_FOOTER--------------------------------------------------------------------------------------

module eth_frame_decap (
    input   wire            rst_n           ,   //  [I] [    ] reset signal, active-low

    // module output interface, (it likes AXI-Stream)
    output  reg     [7:0]   s_axis_rd       ,   //  [O] [ 7:0] rx data output
    output  reg             s_axis_rdv      ,   //  [O] [    ] rx data valid
    output  reg             s_axis_rend     ,   //  [O] [    ] the last data output
    input   wire            s_axis_rrdy     ,   //  [I] [    ] downstream ready to receive data

    input   wire    [47:0]  board_mac       ,   //  [I] [47:0] Board MAC address, for comparison with the received destination MAC address
    output  reg     [47:0]  src_mac         ,   //  [O] [47:0] Received source MAC address
    output  reg     [15:0]  eth_type        ,   //  [O] [15:0] Received ethernet type (or data length, but we don't need this), 
                                                //             when its value is less than 1500(Decimal, 0x05DC in hex), it refers to IEEE 802.3 data length (we don't need this)
                                                //             when its value is bigger than 1500(Decimal, 0x05DC in hex), it refers to ethernet type
    output  wire            module_busy     ,   //  [O] [    ] module busy signal when receiving data, active-high
    output  reg             rx_frame_valid  ,   //  [O] [    ] active-high if crc validation passed
    output  reg             rx_frame_error  ,   //  [O] [    ] active-high when some error occurred on receive data, or CRC is not passed
    output  reg     [15:0]  rx_payload_len  ,   //  [O] [15:0] Received payload length
    
    // GMII input interface
    input   wire            gmii_rxc        ,   //  [I] [    ] GMII RX Clock
    input   wire            gmii_rx_dv      ,   //  [I] [    ] GMII RX Data valid
    input   wire    [ 7:0]  gmii_rxd            //  [I] [    ] GMII RX data
);

//================================================================================
// Local Parameter Declarations
//================================================================================
localparam  MIN_FRAME_LEN   =   8'd64   ;   //  Minimum frame length in bytes, includes 6 bytes dest_mac, 6 bytes src_mac, 2 bytes type/length, minum 46 bytes data segment and 4 bytes FCS
localparam  CRC_LENGTH      =   8'd4    ;
localparam  HEADER_LENGTH   =   8'd14   ;   //  Ethernet pack header length in bytes, 6 bytes dest_mac, 6 bytes src_mac and 2 bytes type/length
localparam  PREAMBLE_WORD   =   8'h55   ;
localparam  SFD_WORD        =   8'hD5   ;

// states
localparam  ST_IDLE         =   4'd0    ;   //  IDLE state
localparam  ST_PREAMBLE     =   4'd1    ;   //  State of receiving preamble code, 7 bytes of 0x55
localparam  ST_SFD          =   4'd2    ;   //  State of receiving SFD, Start Frame Delimiter, 1 byte of 0xd5
localparam  ST_HEADER       =   4'd3    ;   //  State of receiving header, includes destination MAC, src MAC, and ethertype
localparam  ST_PAYLOAD      =   4'd4    ;   //  State of receiving payload, the data content of this packet
localparam  ST_CRC          =   4'd5    ;   //  State of receiving CRC result
localparam  ST_ERR          =   4'd6    ;   //  State of receiving error, drop frame until end
localparam  ST_DROP         =   4'd7    ;   //  State of drop frame   

//================================================================================
// Register Declarations
//================================================================================
reg     [ 3:0]  state                   ;
reg     [ 7:0]  header_buf      [13:0]  ;   //  Ethernet pack header buffer, includes 6 bytes src MAC address, 6 bytes dst MAC address and 2 bytes ethtype. 
reg     [47:0]  recv_dst_mac            ;   //  Received destination MAC address
reg     [47:0]  recv_src_mac            ;   //  Received source MAC address
reg     [16:0]  recv_eth_type           ;   //  Received ethertype

// crc
reg     [ 7:0]  crc_data_in             ;
reg             crc_en                  ;
reg             crc_clr                 ;

// output ctrl (4-byte delay)
reg     [31:0]  delay_buf               ;
reg     [ 2:0]  delay_cnt               ;
reg     [15:0]  bytes_rec_cnt           ;   //  Total bytes received (Preamble and SFD is not included)
reg             payload_active          ;   //  indicator indicates that payload is received, not an error

//================================================================================
// Wire Declarations
//================================================================================
wire    [31:0]  crc_inv                 ;
wire    [31:0]  crc_next_inv            ;

//================================================================================
// Assign Declarations
//================================================================================
assign  module_busy =   (state == ST_IDLE) ? 1'b0 : 1'b1                    ;

//================================================================================
// implements
//================================================================================
crc32_d8 crc32_d8_inst (
    .clk            (   gmii_rxc        ),  // [I] [    ] Module clock
    .rst_n          (   rst_n           ),  // [I] [    ] Reset signal, active-low
    .data           (   crc_data_in     ),  // [I] [ 7:0] The 8-bit data to be validated
    .crc_en         (   crc_en          ),  // [I] [    ] CRC enable
    .crc_clr        (   crc_clr         ),  // [I] [    ] CRC Result Clear
    .crc_next_inv   (   crc_next_inv    ),  // [O] [31:0] CRC data
    .crc_inv        (   crc_inv         )   // [O] [31:0] Inversed crc data
);

//================================================================================
// MAIN CODE
//================================================================================
always  @(posedge gmii_rxc or negedge rst_n) begin
    if (!rst_n) begin
        state                       <=  ST_IDLE                 ;
        rx_payload_len              <=  16'd0                   ;
        bytes_rec_cnt               <=  16'd0                   ;
        crc_data_in                 <=  8'd0                    ;
        crc_en                      <=  1'b0                    ;
        crc_clr                     <=  1'b1                    ;

        delay_buf                   <=  32'd0                   ;
        delay_cnt                   <=  3'd0                    ;

        header_buf[00]              <=  8'h0                    ;
        header_buf[01]              <=  8'h0                    ;
        header_buf[02]              <=  8'h0                    ;
        header_buf[03]              <=  8'h0                    ;
        header_buf[04]              <=  8'h0                    ;
        header_buf[05]              <=  8'h0                    ;
        header_buf[06]              <=  8'h0                    ;
        header_buf[07]              <=  8'h0                    ;
        header_buf[08]              <=  8'h0                    ;
        header_buf[09]              <=  8'h0                    ;
        header_buf[10]              <=  8'h0                    ;
        header_buf[11]              <=  8'h0                    ;
        header_buf[12]              <=  8'h0                    ;
        header_buf[13]              <=  8'h0                    ;

        recv_dst_mac                <=  48'h0                   ;
        recv_src_mac                <=  48'h0                   ;
        recv_eth_type               <=  16'b0                   ;
        src_mac                     <=  48'h0                   ;
        eth_type                    <=  16'b0                   ;

        payload_active              <=  1'b0                    ;
        s_axis_rd                   <=  8'b0                    ;
        s_axis_rdv                  <=  1'b0                    ;
        s_axis_rend                 <=  1'b0                    ;
        rx_frame_valid              <=  1'b0                    ;
        rx_frame_error               <=  1'b0                    ;
    end else begin
        case (state)
            ST_IDLE: begin
                bytes_rec_cnt       <=  16'd0                   ;
                crc_en              <=  1'b0                    ;
                delay_cnt           <=  3'd0                    ;
                delay_buf           <=  32'd0                   ;
                rx_frame_error       <=  1'b0                    ;
                s_axis_rdv          <=  1'b0                    ;
                s_axis_rend         <=  1'b0                    ;
                if (gmii_rx_dv == 1'b1 && gmii_rxd == PREAMBLE_WORD) begin
                    state           <=  ST_PREAMBLE             ;
                    bytes_rec_cnt   <=  bytes_rec_cnt + 1'b1    ;
                end
            end

            // receive 7 bytes preamble (Standard Ethernet is 7 bytes 0x55)
            ST_PREAMBLE: begin
                if ((gmii_rx_dv == 1'b1) && (gmii_rxd == PREAMBLE_WORD)) begin
                    bytes_rec_cnt   <=  bytes_rec_cnt + 1'b1    ;
                    if (bytes_rec_cnt == 8'd7 - 1) begin
                        state       <=  ST_SFD                  ;
                    end
                end else begin
                    state           <= ST_ERR                   ;
                end

                // ... Preamble does not participate in CRC
            end

            // receive 1 byte SFD
            ST_SFD: begin
                if ((gmii_rx_dv == 1'b1) && (gmii_rxd == SFD_WORD)) begin
                    state                   <=  ST_HEADER       ;
                    bytes_rec_cnt           <=  16'd0           ;
                    crc_data_in             <=  8'd0            ;
                    crc_clr                 <=  1'b1            ;
                end else begin
                    state                   <=  ST_ERR          ;
                end
                
                // ... SFD does not participate in CRC
            end

            ST_HEADER: begin
                if (gmii_rx_dv == 1'b1) begin
                    delay_buf   <=  {delay_buf[23:0], gmii_rxd};

                    if (delay_cnt < 4) begin                        //  do 4 bytes delay
                        delay_cnt   <=  delay_cnt + 1   ;
                    end else begin
                        crc_en      <=  1'b1            ;
                        crc_clr     <=  1'b0            ;
                        crc_data_in <=  delay_buf[31:24];

                        // receive header
                        header_buf[bytes_rec_cnt]   <=  delay_buf[31:24]        ;
                        bytes_rec_cnt               <=  bytes_rec_cnt + 1'b1    ;

                        // receive header finish
                        if (bytes_rec_cnt == HEADER_LENGTH - 1) begin
                            recv_dst_mac  <= {header_buf[0], header_buf[1], header_buf[2], header_buf[3], header_buf[4], header_buf[5]};
                            recv_src_mac  <= {header_buf[6], header_buf[7], header_buf[8], header_buf[9], header_buf[10], header_buf[11]};
                            recv_eth_type <= {header_buf[12], delay_buf[31:24]};

                            if(({header_buf[0], header_buf[1], header_buf[2], header_buf[3], header_buf[4], header_buf[5]} == board_mac) || 
                            ({header_buf[0], header_buf[1], header_buf[2], header_buf[3], header_buf[4], header_buf[5]} == 48'hFF_FF_FF_FF_FF_FF)) begin
                                // MAC address is match
                                state           <=  ST_PAYLOAD      ;
                                rx_payload_len  <=  16'd0           ;
                                bytes_rec_cnt   <=  16'd0           ;
                                delay_cnt       <=  2'd0            ;

                                // output src MAC and ethertype to upstream
                                src_mac         <=  recv_src_mac    ;
                                eth_type        <=  {header_buf[12], delay_buf[31:24]};
                            end else begin
                                // MAC address is not match, drop this pack directly.
                                state           <=  ST_DROP         ;
                            end
                        end
                    end
                end else begin
                    state                   <=  ST_ERR          ;
                end
            end 

            ST_PAYLOAD: begin
                if (gmii_rx_dv) begin
                    bytes_rec_cnt   <=  bytes_rec_cnt + 1'b1    ;

                    // crc
                    crc_en          <=  1'b1                    ;
                    crc_clr         <=  1'b0                    ;
                    delay_buf       <=  {delay_buf[23:0], gmii_rxd};
                    crc_data_in     <=  delay_buf[31:24]        ;

                    s_axis_rdv  <=  1'b1                        ;
                    if (s_axis_rrdy == 1'b1) begin                      //  Dowmstream is ready to receive data
                        s_axis_rd       <=  delay_buf[31:24]        ;
                        rx_payload_len  <=  rx_payload_len + 1'b1   ;   //  record payload length (FCS is not included)
                        payload_active  <=  1'b1                    ;
                    end else begin
                        state       <=  ST_DROP             ;   //  Downstream is not ready to receive data, drop this frame
                    end
                end else begin
                    s_axis_rdv      <=  1'b0                ;
                    s_axis_rd       <=  8'b0                ;
                    s_axis_rend     <=  1'b1                ; // send end pulse
                    // gmii_rx_dv goes to 1'b0, frame end, mark s_axis_rend sig
                    if (payload_active == 1'b1) begin
                        payload_active  <=  1'b0                ;
                        state           <=  ST_CRC              ;
                    end
                end
            end

            ST_CRC: begin
                crc_en          <=  1'b0                ;
                s_axis_rend     <=  1'b0                ;
                if (crc_inv == delay_buf) begin
                    rx_frame_valid  <=  1'b1            ;
                    state           <=  ST_IDLE         ;
                end else begin
                    rx_frame_valid  <=  1'b0            ;
                    state           <=  ST_ERR          ;
                end
            end

            ST_ERR: begin      
                rx_frame_error  <=  1'b1                ;
                state           <=  ST_DROP             ;
            end

            ST_DROP: begin
                if(gmii_rx_dv == 1'b0) begin                //  Drop this frame until frame end.
                    state   <=  ST_IDLE                ;
                end
            end
        endcase
    end
end
    
endmodule

以太网帧模块

这个模块的作用是将两个模块进行整合封装到一个顶层，方便后续的例化

module eth_frame # (
    parameter   USE_DEBUG   =   1'b0
) (
    input   wire            rst_n           ,

    input   wire    [47:00] board_mac       ,   //  [I] [47:0] Board MAC address, for comparison with the received destination MAC address
    input   wire    [47:00] dst_mac         ,   //  [I] [47:0] Destination MAC address to be send

    // frame decap AXI-Stream output
    output  wire    [07:00] s_axis_rd       ,   //  [O] [ 7:0] rx data output
    output  wire            s_axis_rdv      ,   //  [O] [    ] rx data valid
    output  wire            s_axis_rend     ,   //  [O] [    ] the last data output
    input   wire            s_axis_rrdy     ,   //  [I] [    ] downstream ready to receive data

    output  wire    [15:00] rx_eth_type     ,   //  [O] [15:0] Received ethernet type
    output  wire            decap_busy      ,   //  [O] [    ] decapsulation busy signal when receiving data, active-high
    output  wire            rx_frame_valid  ,   //  [O] [    ] active-high if crc validation passed
    output  wire            rx_frame_error  ,   //  [O] [    ] active-high when some error occurred on receive data, or CRC is not passed
    output  wire    [15:0]  rx_payload_len  ,   //  [O] [15:0] Received payload length

    // gmii rx interface
    input   wire            gmii_rxc        ,   //  [I] [    ] GMII RX Clock
    input   wire            gmii_rx_dv      ,   //  [I] [    ] GMII RX Data valid
    input   wire    [07:00] gmii_rxd        ,   //  [I] [07:0] GMII RX data

    // frame encap AXI-Stream input
    input   wire    [07:00] s_axis_td       ,   //  [I] [ 7:0] tx data input
    input   wire            s_axis_tdv      ,   //  [I] [    ] tx data valid
    input   wire            s_axis_tend     ,   //  [I] [    ] the last data input,
    output  wire            s_axis_trdy     ,   //  [O] [    ] tx data ready signal, high logic when module can send data
    
    input   wire    [15:00] tx_eth_type     ,   //  [I] [15:0] Ethernet type
    output  wire            encap_busy      ,   //  [O] [    ] encapsulation busy signal when sending data, active-high

    // gmii TX interface
    input   wire            gmii_txc        ,   //  [I] [    ] clock input
    output  wire    [07:00] gmii_txd        ,   //  [O] [07:0]
    output  wire            gmii_tx_en          //  [O] [    ]  
); 

eth_frame_decap eth_frame_decap_inst (
    .rst_n  (rst_n),

    // AXI-Stream output
    .s_axis_rd      (   s_axis_rd       ),  //  [O] [ 7:0] rx data output
    .s_axis_rdv     (   s_axis_rdv      ),  //  [O] [    ] rx data valid
    .s_axis_rend    (   s_axis_rend     ),  //  [O] [    ] the last data output
    .s_axis_rrdy    (   s_axis_rrdy     ),  //  [I] [    ] downstream ready to receive data

    .board_mac      (   board_mac       ),  //  [I] [47:0] Board MAC address, for comparison with the received destination MAC address
    .src_mac        (                   ),  //  [O] [47:0] Received source MAC address, unused, 
    .eth_type       (   rx_eth_type     ),  //  [O] [15:0] Received ethernet type
    .module_busy    (   decap_busy      ),  //  [O] [    ] module busy signal when receiving data, active-high
    .rx_frame_valid (   rx_frame_valid  ),  //  [O] [    ] active-high if crc validation passed
    .rx_frame_error (   rx_frame_error  ),  //  [O] [    ] active-high when some error occurred on receive data, or CRC is not passed
    .rx_payload_len (   rx_payload_len  ),  //  [O] [15:0] Received payload length

    .gmii_rxc       (   gmii_rxc        ),  //  [I] [    ] GMII RX Clock
    .gmii_rx_dv     (   gmii_rx_dv      ),  //  [I] [    ] GMII RX Data valid
    .gmii_rxd       (   gmii_rxd        )   //  [I] [07:0] GMII RX data
);

eth_frame_encap # (
    .USE_DEBUG      (   USE_DEBUG       )
) eth_frame_encap_inst(
    .rst_n          (   rst_n           ),  //  [I] [    ] reset signal, active-low

    // user input interface, (AXI-Stream)
    .s_axis_td      (   s_axis_td       ),  //  [I] [ 7:0] tx data input
    .s_axis_tdv     (   s_axis_tdv      ),  //  [I] [    ] tx data valid
    .s_axis_tend    (   s_axis_tend     ),  //  [I] [    ] the last data input,
    .s_axis_trdy    (   s_axis_trdy     ),  //  [O] [    ] tx data ready signal, high logic when module can send data

    .src_mac        (   board_mac       ),  //  [I] [47:0] Source MAC address to be send
    .dst_mac        (   dst_mac         ),  //  [I] [47:0] Destination MAC address to be send
    .eth_type       (   tx_eth_type     ),  //  [I] [15:0] Ethernet type
    .module_busy    (   encap_busy      ),  //  [O] [    ] module busy signal when sending data, active-high
    
    // GMII interface
    .gmii_txc       (   gmii_txc        ),  //  [I] [    ] clock input
    .gmii_txd       (   gmii_txd        ),  //  [O] [07:0]
    .gmii_tx_en     (   gmii_tx_en      )   //  [O] [    ]
);

ETH-02 RGMII 接口和 GMII 接口的互相转换

Tue, 14 Apr 2026 14:26:09 GMT

在 ETH-01 初识以太网的硬件组成中我讲到了 RGMII 接口和 GMII 的两种数据接口。本篇则围绕这两种数据接口的互相转换展开。

前言

在 FPGA 中，数据通常只在时钟的上升沿被采集。对于采用双边沿数据有效的 RGMII 接口而言，若仅使用上升沿进行采样，就会丢失下降沿所对应的数据。同理，FPGA 在输出数据时，也只能在上升沿发生变化。为解决这一问题，Xilinx 提供了 IDDR 和 ODDR 两个原语，分别用于接收和发送双边沿数据。

下方所有配图均来自 7Series FPGAs SelectIO Resources User Guide (UG471) 你可以打开 DOCNav 来搜索对应的文档名称

IDDR (Input Double Data Rate)

IDDR 的作用是将 RGMII 接口中的双边沿数据 (DDR) 转换为 FPGA 内部可以处理的单边沿数据，IDDR 将双边沿变化的数据通过寄存器输出到了 Q1/Q2 两个端口上，分别代表上升沿的数据和下降沿的数据。

下面是 IDDR 原语的语言模板

IDDR #(
  .DDR_CLK_EDGE (   "OPPOSITE_EDGE" ), // 数据对齐参数，有 "OPPOSITE_EDGE", "SAME_EDGE" or "SAME_EDGE_PIPELINED" 
  .INIT_Q1      (   1'b0            ), // Q1 的初始值: 1'b0 or 1'b1
  .INIT_Q2      (   1'b0            ), // Q2 的初始值: 1'b0 or 1'b1
  .SRTYPE       (   "SYNC"          ) // Set/Reset type: "SYNC" or "ASYNC" 
) IDDR_inst (
  .Q1   (   Q1  ),  // 1-bit 时钟上升沿输出的值
  .Q2   (   Q2  ),  // 1-bit 时钟下降沿输出的值
  .C    (   C   ),  // 1-bit 时钟输入
  .CE   (   CE  ),  // 1-bit 时钟使能信号
  .D    (   D   ),  // 1-bit DDR 信号输入
  .R    (   R   ),  // 1-bit 复位信号
  .S    (   S   )   // 1-bit 置位信号，优先级低于复位信号
);

参数介绍

DDR_CLK_EDGE：数据对齐方式，该参数将在下文介绍。
INIT_Q1/Q2：初始化 Q1、Q2 的初始值。
SRTYPE：配置复位/置位信号为同步/异步。建议是使用同步复位驱动 R/S，以避免亚稳态的产生。

端口介绍

Q1/Q2：数据的输出端口，Q1 输出时钟上升沿的数据，Q2 输出时钟下降沿的数据。
C：时钟的输入端口。
CE：时钟的使能信号，高电平有效。
D：DDR 信号的输入端口。
R/S：复位/置位信号，只能使用其中之一 (置1)，或全部不使用 (置 0)。复位信号使得 Q1/Q2 输出 0，置位信号使得 Q1/Q2 输出 1。

IDDR 数据对齐方式

OPPOSITE_EDGE：数据对齐的基本模式，该模式实现了基本的 DDR 功能，但是输出的数据 Q1/Q2 在单个时钟周期内不能同时有效，对逻辑设计不友好，已经较少使用。下图为该模式下的时序图例。
SAME_EDGE：数据在同一个时钟沿提供给内部逻辑，能有效避免时序冲突。缺点是两个数据之间有一个时钟周期的延迟差异，在逻辑上需要处理 "错位"。下图为该模式下的时序图例。
SAME_EDGE_PIPELINED：完美的数据对齐，两个输出 Q1/Q2 在相同的钟沿同时有效。代价则是引入了额外的延时，通常是 2 个时钟周期。下图为该模式下的时序图例。
通过时序图我们可以看到 IDDR 原语在 SAME_EDGE_PIPELINED 对齐模式下满足了我们的数据对齐要求，所以在这里我们使用 SAME_EDGE_PIPELINED 对齐方式。

ODDR (Output Double Data Rate)

ODDR 的作用正好与 IDDR 是相反的，它通过在时钟的上升沿更新 Q1/Q2 的值，之后输出双边沿变化的 DDR 信号。

下面是 ODDR 的语言模板

ODDR #(
  .DDR_CLK_EDGE ("OPPOSITE_EDGE"),  // "OPPOSITE_EDGE" or "SAME_EDGE" 
  .INIT         (1'b0           ),  // Initial value of Q: 1'b0 or 1'b1
  .SRTYPE       ("SYNC"         )   // Set/Reset type: "SYNC" or "ASYNC" 
) ODDR_inst (
  .Q            (   Q           ),  // 1-bit DDR output
  .C            (   C           ),  // 1-bit clock input
  .CE           (   CE          ),  // 1-bit clock enable input
  .D1           (   D1          ),  // 1-bit data input (positive edge)
  .D2           (   D2          ),  // 1-bit data input (negative edge)
  .R            (   R           ),  // 1-bit reset
  .S            (   S           )   // 1-bit set
);

参数介绍

DDR_CLK_EDGE：数据对齐方式，该参数将在下文介绍。
INIT：初始化端口 Q 的初始值。
SRTYPE：配置复位/置位信号为同步/异步。建议是使用同步复位驱动 R/S，以避免亚稳态的产生。

端口介绍

D1/D2：数据的输入端口，D1 将会被输出到时钟的上升沿，D2 将会被输出到时钟的下降沿。
C：时钟的输入端口。
CE：时钟的使能信号，高电平有效。
Q：DDR 信号的输出端口。
R/S：复位/置位信号，只能使用其中之一 (置1)，或全部不使用 (置 0)。复位信号使得 Q1/Q2 输出置 0，置位信号使得 Q1/Q2 输出置 1。

ODDR 数据对齐方式

OPPOSITE_EDGE：在该模式下时钟的两个边沿都用于从 FPGA 逻辑捕获数据，从而实现两倍数据的吞吐量。这种方式要求内部逻辑必须提供两个数据流：D1 数据流与上升沿对齐，D2 数据流与下降沿对齐, (或提前半个周期来保持数据的稳定)。该方式通常要求使用下降沿的触发器来驱动，容易导致时序违例。该模式的时序图例如下。
SAME_EDGE：在该模式下，D1/D2 都可以由上升沿触发的逻辑产生，DDR 内部会自动把 D2 对齐到下降沿进行输出，从而避免了跨边沿的约束，时序宽松，设计更加简单。该模式的图例如下。

TX_CTRL 的转换

在 RGMII 接口中，TX_CTL是一个集成了 GMII 接口中 TX_EN(发送使能) 和 TX_ER(发送错误) 功能的符合信号，通过将这两个信号编码在了同一个时钟周期内，传递了两个控制信息。

TX_CTL 采用的同样也是双边沿采样 (DDR)，配合发送时钟 TXC 一起传输。它的编码规则如下：

上升沿：传输 TX_EN 信号，表示该时钟周期内的数据是否有效。
下降沿：传输 TX_EN ^ TX_ER，即 TX_EN ^ TX_ER 的异或 (XOR) 结果。这种编码方式定义了四种明确的状态：

组合场景	GMII: TX_EN	GMII_TX_ER	RGMII: TX_CTL<br>(上升沿)	RGMII: TX_CTL<br>(下降沿)	状态描述
正常帧间隙<br>(空闲)	0	0	0	0	空闲状态。链路无数据传输，`TX_CTL`保持低电平
正常帧传输	1	0	1	1	正常数据传输。表示当前时钟周期的 8 位数据全部有效
数据错误	1	1	1	0	发送错误。指示当前传输帧中存在错误，通常由MAC层发起
保留/异常	0	1	0	1	无效的组合，实际过程中用不到

在标准操作中，大多数应用只需要关注正常帧传输（上升沿=1，下降沿=1）和数据错误（上升沿=1，下降沿=0）这两种情况。

关于 TX_CTL 信号的产生方式，代码如下：

ODDR #(
    .DDR_CLK_EDGE   (   "SAME_EDGE"     ),  //  "OPPOSITE_EDGE" or "SAME_EDGE" 
    .INIT           (   1'b0            ),  //  Initial value of Q: 1'b0 or 1'b1
    .SRTYPE         (   "SYNC"          )   //  Set/Reset type: "SYNC" or "ASYNC" 
) rgmii_tdv_oddr_inst (
    .Q              (   rgmii_tx_ctl    ),  //  1-bit DDR output
    .C              (   gmii_txc        ),  //  1-bit clock input
    .CE             (   1'b1            ),  //  1-bit clock enable input
    .D1             (   gmii_tx_en      ),  //  1-bit data input (positive edge)
    .D2             (   gmii_tx_en      ),  //  1-bit data input (negative edge) 实际上发送时 tx_ctl 信号一致都是拉高的，所以下降沿也接到了 gmii_tx_en 信号上。
    .R              (   1'b0            ),  //  1-bit reset
    .S              (   1'b0            )   //  1-bit set
);

RGMII 接口与 GMII 接口互相转换的代码实现

GMII 转 RGMII

首先来实现 GMII 转 RGMII 接口，这样 FPGA 侧的逻辑就可以通过 GMII 接口发送，再由该模块转换成 RGMII 接口的数据传递到 PHY 芯片了。

module rgmii_tx (
    // GMII
    input   wire            gmii_txc        ,   //  [I] [   ] gmii rx clock
    input   wire            gmii_tx_en      ,   //  [I] [   ] gmii rx control
    input   wire    [7:0]   gmii_txd        ,   //  [I] [7:0] gmii rx data

    // RGMII
    output  wire            rgmii_txc       ,   //  [O] [   ] rgmii rx clock
    output  wire            rgmii_tx_ctl    ,   //  [O] [   ] rgmii rx control
    output  wire    [3:0]   rgmii_txd           //  [O] [3:0] rgmii rx data
);

// RGMII 接口 tx_ctl 信号的产生
ODDR #(
    .DDR_CLK_EDGE   (   "SAME_EDGE"     ),  //  "OPPOSITE_EDGE" or "SAME_EDGE" 
    .INIT           (   1'b0            ),  //  Initial value of Q: 1'b0 or 1'b1
    .SRTYPE         (   "SYNC"          )   //  Set/Reset type: "SYNC" or "ASYNC" 
) rgmii_tdv_oddr_inst (
    .Q              (   rgmii_tx_ctl    ),  //  1-bit DDR output
    .C              (   gmii_txc        ),  //  1-bit clock input
    .CE             (   1'b1            ),  //  1-bit clock enable input
    .D1             (   gmii_tx_en      ),  //  1-bit data input (positive edge)
    .D2             (   gmii_tx_en      ),  //  1-bit data input (negative edge)
    .R              (   1'b0            ),  //  1-bit reset
    .S              (   1'b0            )   //  1-bit set
);

// generate 语句为每一条数据线都生成 ODDR 原语
genvar i;
generate 
    for (i=0; i<4; i=i+1) 
    begin: txd_bus
        ODDR #(
            .DDR_CLK_EDGE  (    "SAME_EDGE"     ),  //  "OPPOSITE_EDGE" or "SAME_EDGE" 
            .INIT          (    1'b0            ),  //  Initial value of Q: 1'b0 or 1'b1
            .SRTYPE        (    "SYNC"          )   //  Set/Reset type: "SYNC" or "ASYNC" 
        ) rgmii_txd_oddr_inst (
            .Q             (    rgmii_txd[i]    ),  //  1-bit DDR output
            .C             (    gmii_txc        ),  //  1-bit clock input
            .CE            (    1'b1            ),  //  1-bit clock enable input
            .D1            (    gmii_txd[i  ]   ),  //  1-bit data input (positive edge)
            .D2            (    gmii_txd[i+4]   ),  //  1-bit data input (negative edge) 在 RGMII 接口的要求中，时钟的上升沿发送高 4 位，下降沿发送低 4 位。
            .R             (    1'b0            ),  //  1-bit reset
            .S             (    1'b0            )   //  1-bit set
        );   
    end
endgenerate

// 使用 ODDR 原语生成 rgmii_txc 来匹配延迟
ODDR #(
    .DDR_CLK_EDGE   (   "SAME_EDGE"     ),  //  "OPPOSITE_EDGE" or "SAME_EDGE" 
    .INIT           (   1'b0            ),  //  Initial value of Q: 1'b0 or 1'b1
    .SRTYPE         (   "SYNC"          )   //  Set/Reset type: "SYNC" or "ASYNC" 
) rgmii_clk_oddr_inst (
    .Q              (   rgmii_txc       ),  //  1-bit DDR output
    .C              (   gmii_txc        ),  //  1-bit clock input
    .CE             (   1'b1            ),  //  1-bit clock enable input
    .D1             (   1'b1            ),  //  1-bit data input (positive edge)
    .D2             (   1'b0            ),  //  1-bit data input (negative edge)
    .R              (   1'b0            ),  //  1-bit reset
    .S              (   1'b0            )   //  1-bit set
);

RGMII 转 GMII

module rgmii_rx (
    // RGMII
    input   wire            rgmii_rxc       ,   //  [I] [   ] rgmii rx clock
    input   wire            rgmii_rx_ctl    ,   //  [I] [   ] rgmii rx control
    input   wire    [3:0]   rgmii_rxd       ,   //  [I] [3:0] rgmii rx data

    // GMII
    output  wire            gmii_rxc        ,   //  [O] [   ] gmii rx clock
    output  wire            gmii_rx_dv      ,   //  [O] [   ] gmii rx data valid
    output  wire    [7:0]   gmii_rxd            //  [O] [7:0] gmii rx data
);

wire            rgmii_rxc_bufio     ;
wire            rgmii_rxc_bufg      ;
wire    [1:0]   gmii_rx_dv_t        ;
assign gmii_rxc     = rgmii_rxc_bufg                    ;
assign gmii_rx_dv   = gmii_rx_dv_t[0] & gmii_rx_dv_t[1] ;

BUFG BUFG_inst (
    .I              (   rgmii_rxc               ),
    .O              (   rgmii_rxc_bufg          )
);

BUFIO BUFIO_inst (
    .I              (   rgmii_rxc               ),
    .O              (   rgmii_rxc_bufio         )
);

genvar i;
generate
    for (i = 0; i < 4; i = i+1)
    begin: rxd_bus
        // input delay
        IDDR #(
            .DDR_CLK_EDGE   (   "SAME_EDGE_PIPELINED"   ),  //  "OPPOSITE_EDGE", "SAME_EDGE" or "SAME_EDGE_PIPELINED" 
            .INIT_Q1        (   1'b0                    ),  //  Initial value of Q1: 1'b0 or 1'b1
            .INIT_Q2        (   1'b0                    ),  //  Initial value of Q2: 1'b0 or 1'b1
            .SRTYPE         (   "SYNC"                  )   //  Set/Reset type: "SYNC" or "ASYNC" 
        ) gmii_rxd_iddr (
            .Q1             (   gmii_rxd[i  ]           ),  // [O] 1-bit output for positive edge of clock
            .Q2             (   gmii_rxd[i+4]           ),  // [O] 1-bit output for negative edge of clock
            .C              (   rgmii_rxc_bufio         ),  // [I] 1-bit clock input
            .CE             (   1'b1                    ),  // [I] 1-bit clock enable input
            .D              (   rgmii_rxd[i]            ),  // [I] 1-bit DDR data input
            .R              (   1'b0                    ),  // [I] 1-bit reset
            .S              (   1'b0                    )   // [I] 1-bit set
        );
    end
endgenerate

ETH-01 初识以太网的硬件组成

Mon, 13 Apr 2026 15:14:06 GMT

以太网通信的硬件组成

下面是一张硬件组成图例主要由 MAC (Media Access Control，媒体访问控制器) 和 PHY(Physical Layer，物理层接口) 两大部分组成。

MAC：通常由嵌入式设备（如单片机、FPGA 等）实现，负责数据的打包、寻址、CRC 校验等逻辑控制功能。
PHY：一般作为一颗独立的板载芯片，负责网络自协商、数据编解码等物理层相关工作。

通信设备之间通过 RJ45 接口进行连接。需要注意的是，接口本身不具备通信功能，仅起到连接信号的作用。

RGMII 和 GMII 接口

RGMII 和 GMII 都是连接 MAC 层与 PHY 层的芯片间接口，主要区别在于引脚数量和传输效率。

GMII (Gigabit Media Independent Interface)

GMII 是千兆以太网接口的完整实现，也是早期 MII 接口的升级版（MII 最高支持 100Mbps）。

数据宽度：8 位（发送和接收各 8 条数据线）
时钟频率：
- 1000 Mbps 模式：125 MHz
- 100 Mbps 模式：25 MHz
- 10 Mbps 模式：2.5 MHz
关键信号：
- TXD[7:0]（发送数据）、RXD[7:0]（接收数据）
- TX_CLK / RX_CLK（时钟，由 PHY 提供或从数据中恢复）
- TX_EN（发送使能）、RX_DV（接收数据有效）
- TX_ER / RX_ER（错误指示）
- CRS（载波侦听）、COL（冲突检测，仅半双工用）
优点：时序简单，兼容性好，支持全双工和半双工。
缺点：引脚数量多，约 24 根，PCB 布线复杂，成本高。
应用场景：早期千兆交换芯片、FPGA 开发板、对时序要求极高的场合。

注意：GMII 的发送时钟 TX_CLK 可能来自 MAC，也可能来自 PHY（取决于模式），这一点与 MII 略有差异。

RGMII (Reduced GMII)

RGMII 是为了解决 GMII 引脚过多问题而设计的精简版接口，是目前大多数 SoC、交换芯片和 PHY 芯片的首选。它采用的是 DDR(Double Data Rate) 模式传输的数据，即时钟的上升沿和下降沿均为有效数据。

数据宽度：4 位（发送和接收各 4 条数据线）
时钟频率：
- 1000 Mbps 模式：125 MHz（双沿采样，等效 250 Mbps per pin）
- 100 Mbps 模式：25 MHz（双沿采样，等效 50 Mbps per pin）
- 10 Mbps 模式：2.5 MHz（双沿采样，等效 5 Mbps per pin）
核心技术：DDR(Double Data Rate)——时钟的上升沿和下降沿均传输数据。其中上升沿传递数据的高 4 位，下降沿传递数据的低 4 位。所以 4 位数据线 x 双边沿 x 125MHz = 1000Mbps。
关键信号：
- TXD[3:0]（发送数据）、RXD[3:0]（接收数据）
- TX_CLK（125MHz 时钟，由 MAC 或 PHY 提供）
- RX_CLK（125MHz 时钟，由 PHY 恢复）
- TX_CTL（发送控制，上升沿 = TX_EN，下降沿 = TX_ER 或其它编码）
- RX_CTL（接收控制，上升沿 = RX_DV，下降沿 = RX_ER）
优点：引脚数少，约 12 根，仅为 GMII 的一半，PCB 布局更轻松。
缺点：
- 时序要求严格，因为用到了双沿和信号编码。
- 通常需要 PCB 上做等长走线，并且 MAC/PHY 内部要有时钟延迟调整功能（一般通过 RGMII TX/RX Delay 配置）。
应用场景：绝大多数现代嵌入式处理器、以太网交换机芯片、路由器、网卡。

实现以太网通信的模块框图 (UDP 通信)

模块以实现 UDP 回环测试为目标，整体模块框图如下图所示。接下来的系列文章根据以下模块框图逐步推进。注意：Protocol SW 模块的作用是在 ARP 协议与 IP 协议之间进行切换。若将 ARP 协议和 IP 协议直接连接到 MAC 发送层，会导致多重驱动问题，这在 FPGA 设计中是不允许的。

简单来说，Protocol SW 模块正是为了避免因多重驱动而引发时序违例所设计的。

小结

以太网的硬件设计离不开 MAC 与 PHY 的协同工作，而 GMII 与 RGMII 作为两者之间的主流接口，分别在高性能与高集成度之间提供了不同的选择。GMII 以完整的 8 位数据线和简单的时序控制，适合对时序要求严苛的早期设备或开发平台；RGMII 则通过 DDR 技术和引脚精简，成为当前嵌入式系统中最常用的接口标准。理解这些接口的特性，有助于在实际项目中进行合理的芯片选型和 PCB 设计，从而在性能、成本与布线复杂度之间取得平衡。

将字库数据烧录到 Flash 芯片内的方法

Tue, 17 Mar 2026 09:18:06 GMT

:::note 本文旨在提供思路和方法，同时作为一篇开发笔记分享给大家。本文中所有的软件资源、代码等可以在 Gitee 仓库: Stm32_HZK 中获取。

本文中所使用的 Flash 芯片型号为华邦(WINBOND) 生产的 W25Q 系列的芯片，它是一款非易失性存储芯片，通信方式支持有 SPI, Dual SPI, QUAD SPI 这三种方式。支持的最大时钟频率为 133MHz。 :::

GBK 汉字字符集的生成

什么是 GBK 汉字字符集？

GBK 汉字字符集 是一种用于表示中文字符的字符编码。它包含了所有的中文字符，每个中文字符都有一个唯一的编码值。

:::note 通俗的来讲就是所有汉字的一个集合，这个集合按照先后顺序被排列组合起来，就形成了 GBK 汉字字符集。 :::

GBK 字符集的编码格式

与 ASCII 码不同的是，GBK 编码是一个 16 位的编码，每个汉字需要 2 个字节来表示。GBK 编码的双字节结构，具体分为:

区码（高字节）: 范围 0x81-0xFE
位码（低字节）: 范围 0x40-0xFE（0x7F 除外）

所以，经过计算后可以得出GBK 理论编码位置有 23940 个。计算过程如下:

区码（高字节）长度: 0x81-0xFE+0x01=0x7E，加上 1 则是算上起始位置。
位码（低字节）长度: 又称为每个区的字码数量 0x40-0xFE-0x01+0x01=0xBE，减去的 1 是被除掉的 0x7F，加上的 1 则是算上起始位置。
所以总的可用的编码位置一共有: 0x7E*0xBE=0x5D84 个，十进制下为 23940 个。

举个例子说明为什么计算结果要加 1，比如有 2 3 4 5 6 这几个数字，那么数字的数量就是 (6-2)+1=5，小学数学问题，但是防止不懂还是提一下(doge)

为什么要生成它？

在这之前，我尝试在网络上搜索现有的 GBK 汉字字符集，但是搜索到的都是已经收录到 GBK 字符集的字库文件，而我需要的是一个完整的 GBK 字符集文件，包含所有理论上的中文字符。所以我就打算自己生成一个 GBK 汉字字符集文件。

生成 GBK 汉字字符集

本次使用 python 生成 GBK 汉字字符集。代码如下:

# 生成的索引文件会被保存到当前目录下的 GBK_INDEX.txt 中
file = open("GBK_INDEX.txt", "wb")

highByte = 0x81 # 高字节起始位置
lowByte = 0x40  # 低字节起始位置

# 文件头写入 ascii 码
# 也可以把这部分放到下一部分中，在文件尾写入 ascii 码
asciiCode = 20 # ascii 码起始字符位置
while True:
    asciiCode += 1
    if asciiCode > 0x7E: # 终止字符位置为 0x7E
        break
    file.write(bytes([asciiCode]))

while True:
    # 跳过 0x7F（GBK 编码中该位码无效）
    if lowByte == 0x7F:
        lowByte += 1
        continue
    
    # 写入当前高低字节
    file.write(bytes([highByte, lowByte]))

    # 低位字节自增
    lowByte += 1

    # 检查低位是否溢出，即达到最大值 0xFE
    if lowByte > 0xFE:
        # 重置低位并增加高位
        lowByte = 0x40
        highByte += 1

        # 检查高位是否达到终止条件
        if highByte > 0xFE:
            break

file.close()

<!-- ### 避免存储空间的浪费实际上，有些编码值在经过取模软键取模之后，其中的字模数据表现为空白数据 0x00，为什么会出现这种情况？

问题分析

这 23940 个理论编码位置中，实际收录的汉字和符号一共是 21003{% ref 1 来源于百度百科 https://baike.baidu.com/item/GBK字库 %} 个，所以还有 23940-21003=2937 个编码位置是空白编码，在这些编码上是没有汉字收录的，取模软件会为这些空白编码生成空白的字模数据 0x00。白白占用 Flash 的存储空间。

以 16x16 的点阵字库为例，每个汉字字模占 32 个字节，23940 个位置全部占满，那么需要的 Flash 存储空间就是 23940*32=766080 字节。大约需要 766KB 的 Flash 存储空间。但实际上，除去空白编码，实际需要的 Flash 存储空间就是 21003*32=672096 字节。大约需要 672KB 的 Flash 存储空间。浪费了将近 766-672=94KB 的 Flash 存储空间。对于 32x32 的点阵字库，空间浪费现象会更严重。 -->

生成点阵字库

将我们生成好的 GBK 汉字字符集导入到 PCtoLCD2002 软件中去生成我们的点阵字库数据就可以了。图中配置的是每个中文字符的字模数据为 16x16 大小，占用 32 个字节。

首先打开 PCtoLCD2002 软件，对应的软件资源位于 Stm32/_HZK 仓库中 PCtoLCD2002 完美版 文件夹内。
点击 导入大量文本 按钮，选择 打开文本文件
选择我们之前生成的 GBK_INDEX.txt 文件
点击 开始生成 按钮，选择好保存路径后，等待软件生成完成。

计算汉字字模数据的偏移地址

在这之前，我们已经生成了连续的 23940 个 GBK 编码的中文字符，并且对每个字符都取模生成了对应的字模数据，每个中文字符的字模数据都是 32 个字节。所以在生成的字库数据中，每个汉字的字模数据都是连续存储的，我们需要根据汉字的编码值来计算出它的字模数据在 Flash 中的偏移地址。

以汉字 "啊" 为例子，它的 GBK 编码为 0xB0A1，根据 GBK 编码的规则，计算过程如下：

它的区码为 0xB0，由于区码的起始位置为 0x81，所以区码偏移为 0xB0-0x81=0x2F。
它的位码为 0xA1，由于位码的起始位置为 0x40，并且它的值大于了 0x7F，要在最终的结果上减去 1，所以位码偏移为 0xA1-0x40-0x01=0x60。
将汉字的区码偏移和位码长度相乘，再加上位码偏移，就得到了汉字偏移量：0x2F*0xBE+0x60=0x2342。
再将汉字偏移量乘以每个中文字符的字模数据大小 32 字节，就得到了汉字字模数据在 Flash 中的偏移地址：0x2342*0x20=0x046840。

下面用一张流程图来展示计算过程(你可以自由的缩放、移动这个流程图)： {% mermaid %} flowchart TD A[开始] --> B[输入任意汉字] B --> C[获取该汉字的 GBK 编码<br>（双字节）] C --> D[分离区码和位码<br>区码 = 高字节，位码 = 低字节] D --> E[计算区码偏移<br>区码偏移 = 区码 - 0x81] E --> F{位码 > 0x7F ?} F -- 是 --> G[位码偏移 = 位码 - 0x40 - 0x01] F -- 否 --> H[位码偏移 = 位码 - 0x40] G --> I[计算汉字偏移量<br>偏移量 = 区码偏移 × 每区汉字数 + 位码偏移<br>其中每区汉字数 = 0xBE] H --> I I --> J[计算字模数据在 Flash 中的地址<br>地址 = 偏移量 × 每个字模大小<br>每个字模大小 = 32 字节] J --> K[结束] {% endmermaid %}

小结

若位码小于等于 0x7F，则地址计算为:

地址 = (区码 - 0x81) * 0xBE + (位码 - 0x40) * 32

若位码大于 0x7F，则地址计算为:

地址 = (区码 - 0x81) * 0xBE + (位码 - 0x40 - 0x01) * 32

其中，0x81 是区码的起始位置，0xBE 是每个区的字码数量，0x40 是位码的起始位置，0x01 是为了修正位码的偏移量。

验证计算结果

使用十六进制编辑器打开我们生成的字库文件，按下 Ctrl+G 输入 0x046840 这个位置，之后按下回车跳转到这个位置，从这个位置开始，连续读取 32 个字节，就是汉字 "啊" 的字模数据了。

选中这些数据，把它复制下来，粘贴到字模验证工具网站中 (注意选择对应的取模参数，数据排列和取模方式)，从图中可以看到我们的字模数据是正确的。

刚刚验证的是汉字 "啊" 的字模数据，它的位码大于了 0x7F，验证的是小结中 "若位码大于 0x7F" 这一部分的计算结果。下面以汉字 "丢" 为例子验证 "位码小于 0x7F" 这一部分的计算结果。汉字 "丢" 的 GBK 编码为 0x8147，根据 GBK 编码的规则，计算过程如下：

它的区码为 0x81，由于区码的起始位置为 0x81，所以区码偏移为 0x81-0x81=0x00。

它的位码为 0x47，由于位码的起始位置为 0x40，并且它的值小于等于 0x7F，所以位码偏移为 0x47-0x40=0x07。

所以它的偏移地址为 0x00*0xBE+0x07*0x20=0xE0。跳转到 0xE0 这个位置就可以看到汉字 "丢" 的字模数据了。在这里不再赘述验证过程。

烧录字库数据到 Flash 芯片内

这部分内容你可以用任何方式包括但不限于 ST-LINK、J-LINK、SWD 调试器、以及最基本的串口烧录(配合 Flash 驱动程序)。在这里就不详细展开说明了。

Markdown Extended Features

Wed, 01 May 2024 00:00:00 GMT

GitHub Repository Cards

You can add dynamic cards that link to GitHub repositories, on page load, the repository information is pulled from the GitHub API.

::github{repo="Fabrizz/MMM-OnSpotify"}

Create a GitHub repository card with the code ::github{repo="<owner>/<repo>"}.

::github{repo="saicaca/fuwari"}

Admonitions

Following types of admonitions are supported: note tip important warning caution

:::note Highlights information that users should take into account, even when skimming. :::

:::tip Optional information to help a user be more successful. :::

:::important Crucial information necessary for users to succeed. :::

:::warning Critical content demanding immediate user attention due to potential risks. :::

:::caution Negative potential consequences of an action. :::

Basic Syntax

:::note
Highlights information that users should take into account, even when skimming.
:::

:::tip
Optional information to help a user be more successful.
:::

Custom Titles

The title of the admonition can be customized.

:::note[MY CUSTOM TITLE] This is a note with a custom title. :::

:::note[MY CUSTOM TITLE]
This is a note with a custom title.
:::

GitHub Syntax

[!TIP] The GitHub syntax is also supported.

> [!NOTE]
> The GitHub syntax is also supported.

> [!TIP]
> The GitHub syntax is also supported.

Spoiler

You can add spoilers to your text. The text also supports Markdown syntax.

The content :spoiler[is hidden ayyy]!

The content :spoiler[is hidden **ayyy**]!

Expressive Code Example

Wed, 10 Apr 2024 00:00:00 GMT

Here, we'll explore how code blocks look using Expressive Code. The provided examples are based on the official documentation, which you can refer to for further details.

Expressive Code

Syntax Highlighting

Regular syntax highlighting

console.log('This code is syntax highlighted!')

Rendering ANSI escape sequences

ANSI colors:
- Regular: [31mRed[0m [32mGreen[0m [33mYellow[0m [34mBlue[0m [35mMagenta[0m [36mCyan[0m
- Bold:    [1;31mRed[0m [1;32mGreen[0m [1;33mYellow[0m [1;34mBlue[0m [1;35mMagenta[0m [1;36mCyan[0m
- Dimmed:  [2;31mRed[0m [2;32mGreen[0m [2;33mYellow[0m [2;34mBlue[0m [2;35mMagenta[0m [2;36mCyan[0m

256 colors (showing colors 160-177):
[38;5;160m160 [38;5;161m161 [38;5;162m162 [38;5;163m163 [38;5;164m164 [38;5;165m165[0m
[38;5;166m166 [38;5;167m167 [38;5;168m168 [38;5;169m169 [38;5;170m170 [38;5;171m171[0m
[38;5;172m172 [38;5;173m173 [38;5;174m174 [38;5;175m175 [38;5;176m176 [38;5;177m177[0m

Full RGB colors:
[38;2;34;139;34mForestGreen - RGB(34, 139, 34)[0m

Text formatting: [1mBold[0m [2mDimmed[0m [3mItalic[0m [4mUnderline[0m

Editor & Terminal Frames

Code editor frames

console.log('Title attribute example')

<!-- src/content/index.html -->
<div>File name comment example</div>

Terminal frames

echo "This terminal frame has no title"

Write-Output "This one has a title!"

Overriding frame types

echo "Look ma, no frame!"

# Without overriding, this would be a terminal frame
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
New-Alias tail Watch-Tail

Text & Line Markers

Marking full lines & line ranges

// Line 1 - targeted by line number
// Line 2
// Line 3
// Line 4 - targeted by line number
// Line 5
// Line 6
// Line 7 - targeted by range "7-8"
// Line 8 - targeted by range "7-8"

Selecting line marker types (mark, ins, del)

function demo() {
  console.log('this line is marked as deleted')
  // This line and the next one are marked as inserted
  console.log('this is the second inserted line')

  return 'this line uses the neutral default marker type'
}

Adding labels to line markers

// labeled-line-markers.jsx
<button
  role="button"
  {...props}
  value={value}
  className={buttonClassName}
  disabled={disabled}
  active={active}
>
  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Adding long labels on their own lines

// labeled-line-markers.jsx
<button
  role="button"
  {...props}

  value={value}
  className={buttonClassName}

  disabled={disabled}
  active={active}
>

  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Using diff-like syntax

+this line will be marked as inserted
-this line will be marked as deleted
this is a regular line

--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+this is an actual diff file
-all contents will remain unmodified
 no whitespace will be removed either

Combining syntax highlighting with diff-like syntax

  function thisIsJavaScript() {
    // This entire block gets highlighted as JavaScript,
    // and we can still add diff markers to it!
-   console.log('Old code to be removed')
+   console.log('New and shiny code!')
  }

Marking individual text inside lines

function demo() {
  // Mark any given text inside lines
  return 'Multiple matches of the given text are supported';
}

Regular expressions

console.log('The words yes and yep will be marked.')

Escaping forward slashes

echo "Test" > /home/test.txt

Selecting inline marker types (mark, ins, del)

function demo() {
  console.log('These are inserted and deleted marker types');
  // The return statement uses the default marker type
  return true;
}

Word Wrap

Configuring word wrap per block

// Example with wrap
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with wrap=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Configuring indentation of wrapped lines

// Example with preserveIndent (enabled by default)
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with preserveIndent=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Collapsible Sections

// All this boilerplate setup code will be collapsed
import { someBoilerplateEngine } from '@example/some-boilerplate'
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'

const engine = someBoilerplateEngine(evenMoreBoilerplate())

// This part of the code will be visible by default
engine.doSomething(1, 2, 3, calcFn)

function calcFn() {
  // You can have multiple collapsed sections
  const a = 1
  const b = 2
  const c = a + b

  // This will remain visible
  console.log(`Calculation result: ${a} + ${b} = ${c}`)
  return c
}

// All this code until the end of the block will be collapsed again
engine.closeConnection()
engine.freeMemory()
engine.shutdown({ reason: 'End of example boilerplate code' })

Line Numbers

Displaying line numbers per block

// This code block will show line numbers
console.log('Greetings from line 2!')
console.log('I am on line 3')

// Line numbers are disabled for this block
console.log('Hello?')
console.log('Sorry, do you know what line I am on?')

Changing the starting line number

console.log('Greetings from line 5!')
console.log('I am on line 6')

Simple Guides for Fuwari

Mon, 01 Apr 2024 00:00:00 GMT

Cover image source: Source

This blog template is built with Astro. For the things that are not mentioned in this guide, you may find the answers in the Astro Docs.

Front-matter of Posts

---
title: My First Blog Post
published: 2023-09-09
description: This is the first post of my new Astro blog.
image: ./cover.jpg
tags: [Foo, Bar]
category: Front-end
draft: false
---

Attribute	Description
`title`	The title of the post.
`published`	The date the post was published.
`description`	A short description of the post. Displayed on index page.
`image`	The cover image path of the post.<br/>1. Start with `http://` or `https://`: Use web image<br/>2. Start with `/`: For image in `public` dir<br/>3. With none of the prefixes: Relative to the markdown file
`tags`	The tags of the post.
`category`	The category of the post.
`draft`	If this post is still a draft, which won't be displayed.

Where to Place the Post Files

Your post files should be placed in src/content/posts/ directory. You can also create sub-directories to better organize your posts and assets.

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

Markdown Example

Sun, 01 Oct 2023 00:00:00 GMT

An h1 header

Paragraphs are separated by a blank line.

2nd paragraph. Italic, bold, and monospace. Itemized lists look like:

this one
that one
the other one

Note that --- not considering the asterisk --- the actual text content starts at 4-columns in.

Block quotes are written like so.

They can span multiple paragraphs, if you like.

Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all in chapters 12--14"). Three dots ... will be converted to an ellipsis. Unicode is supported. ☺

An h2 header

Here's a numbered list:

first item
second item
third item

Note again how the actual text starts at 4 columns in (4 characters from the left side). Here's a code sample:

# Let me re-iterate ...
for i in 1 .. 10 { do-something(i) }

As you probably guessed, indented 4 spaces. By the way, instead of indenting the block, you can use delimited blocks, if you like:

define foobar() {
    print "Welcome to flavor country!";
}

(which makes copying & pasting easier). You can optionally mark the delimited block for Pandoc to syntax highlight it:

import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print i

An h3 header

Now a nested list:

First, get these ingredients:
- carrots
- celery
- lentils
Boil some water.

Dump everything in the pot and follow this algorithm:

 find wooden spoon
 uncover pot
 stir
 cover pot
 balance wooden spoon precariously on pot handle
 wait 10 minutes
 goto first step (or shut off burner when done)

Do not bump wooden spoon or it will fall.

Notice again how text always lines up on 4-space indents (including that last line which continues item 3 above).

Here's a link to a website, to a local doc, and to a section heading in the current doc. Here's a footnote [^1].

[^1]: Footnote text goes here.

Tables can look like this:

size material color

9 leather brown 10 hemp canvas natural 11 glass transparent

Table: Shoes, their sizes, and what they're made of

(The above is the caption for the table.) Pandoc also supports multi-line tables:

keyword text

red Sunsets, apples, and other red or reddish things.

green Leaves, grass, frogs and other things it's not easy being.

A horizontal rule follows.

Here's a definition list:

apples : Good for making applesauce. oranges : Citrus! tomatoes : There's no "e" in tomatoe.

Again, text is indented 4 spaces. (Put a blank line between each term/definition pair to spread things out more.)

Here's a "line block":

| Line one | Line too | Line tree

and images can be specified like so:

Inline math equations go in like so: $\omega = d\phi / dt$. Display math should get its own line and be put in in double-dollarsigns:

$$I = \int \rho R^{2} dV$$

$$ \begin{equation*} \pi =3.1415926535 ;8979323846;2643383279;5028841971;6939937510;5820974944 ;5923078164;0628620899;8628034825;3421170679;\ldots \end{equation*} $$

And note that you can backslash-escape any punctuation characters which you wish to be displayed literally, ex.: `foo`, *bar*, etc.

Include Video in the Posts

Tue, 01 Aug 2023 00:00:00 GMT

Just copy the embed code from YouTube or other platforms, and paste it in the markdown file.

---
title: Include Video in the Post
published: 2023-10-19
// ...
---

<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

YouTube

Bilibili