[blog-MT-07] 博客主题页面更新啦, 浅浅介绍一下本次更新的内容吧

2026-10-22T10:32:43.000Z

主要更新内容

最明显的变化莫过于主题了，主题由原来的 Fuwari 换成了毛玻璃质感，感觉这样很简约又有高级感。
窄屏下的顶部导航栏会变成汉堡菜单，点击后从右侧弹出。
文章搜索支持拼音输入
草稿文章在 dev 环境下预览时, 会在顶部生成一个提示
右侧的侧边栏增加了数据统计，评论数量、总访问量、访客数量 (为了防止对服务器造成压力，数据每 1 小时更新一次).

大致的新增内容就是这么多了, 99.99% 的内容都是使用 deepseek v4 pro 对话生成的产物, 也有一些是用的 deepseek v4 flash, 本人只对部分功能进行了细化和微调。

(OS: 不得不感慨一下现在的 AI 真的是非常非常的强大啊 |´・ω・)ノ)

关于开源

这个主题目前仍然在修改和添加一些小功能中, 待到时机合适和完善时会考虑开源.

[blog-MT-06] - 将 TTF 字体压缩至几百 KB 的 woff2 字体, 一套网页字体轻量化的完整解决方案

2026-06-06T21:26:18.000Z

这篇解决方案适用于任何以 Node.js 构建的站点，是一篇通用教程。

前言

今天我为博客更换了主要字体: 一款开源字体霞鹜文楷 GB。

lxgw / LxgwWenKaiGB An open-source Simplified Chinese font derived from Klee One. 1.6K36OFL-1.1

然而下载下来的完整字体文件接近 25 MB。如果直接原封不动地用于博客, 加载速度会极其缓慢。于是我开始探索字体文件大小的优化方法。

(图为原始 ttf 字体文件的大小)

优化方法

起初, 我尝试了最直接的方式: 利用在线工具将 TTF 格式转换为更适合网页的 woff2 格式。
25 MB 的 TTF 转换后仍接近 10 MB。虽然体积已经减少了大约 60%, 但对一个网页来说, 10 MB 的字体资源依然过于庞大。

(图为转换为 woff2 格式后的文件大小)

随后, 借助 AI 工具检索资料后发现: 字体文件中只有一小部分字符是网站实际会用到的。因此, 我们可以先收集所有页面中用到的字符, 形成一个字符集合, 然后基于这个集合从原字体中生成一个「子集」 (subset) 。
这样一来, 原本 10 MB 左右的 woff2 字体还能进一步压缩 (当然也可以直接从 TTF 生成子集) 。

字体子集化过程

Step.1 安装 Node 工具

使用以下命令安装字体子集化所需的依赖:

$ npm install -D subset-font glob jsdom

subset-font: 字体子集化的主要工具
glob: 用于遍历构建后生成的 HTML 文件
jsdom: 从 HTML 页面中提取纯文本内容

Step2. 存放完整字体文件

将原始 TTF 字体放在任意位置, 只要后续脚本能够加载到即可。

如果你存放到了 public 文件夹下, 并且在意构建后 dist 文件夹的体积, 则需要额外的代码对完整字体进行清理。
如果你存放到了 src/assets 文件夹下, 并且在意构建后 dist 文件夹的体积, 那么推荐你将其移动到其它路径。因为 Astro 在构建时会为 src/assets 路径下所有文件添加哈希值, 它可能是动态变化的, 而我目前不知道这个哈希值如何获取。因此不推荐放在 src/assets 这个路径下。

我的存放位置是 public/fonts 文件夹下, 目录结构如下所示

public/
    fonts/
        jetbrains-mono/
            *.ttf
        lxgw-wenkai-gb/
            *.ttf

Step3. 创建构建后脚本

该脚本会从构建好的页面 (即 dist 文件夹中的所有 HTML) 收集所有字符, 然后根据原始完整字体生成对应的字体子集, 并输出为 woff2 格式。将脚本保存到项目根目录的 scripts 文件夹中, 文件后缀为 .mjs。

// scripts/subset-font.mjs
import fs from 'fs';
import path from 'path';
import crypto from 'crypto';
import { glob } from 'glob';
import { JSDOM } from 'jsdom';
import subsetFont from 'subset-font';

// 字体存放的根目录
const fontRoot = "public/fonts";
// 构建后 dist 文件夹内的 fonts 目录, 用于额外清理
const distFontRoot = "dist/fonts"
// 字体子集的输出目录
const outputDir = "dist/_astro/fonts";
// 字体类型配置, in: 字体的输入格式, out: 字体的输出格式
const fontTypeConfig = {in: "ttf", out: "woff2"};

// font lists
const fontConfigs = [
    // family: font-family, 
    // file: 完整字体的文件地址, 相对于 fontRoot, 不要添加后缀名, 
    // weight: 字体的字重, 控制字体粗细, 
    // style: normal, 正常, italic, 斜体
    { family: 'Yozai'               , file: 'yozai/Yozai-Regular'                    , weight: 400, style: "normal", },
    { family: 'LXGWWenKaiMonoGB'    , file: 'lxgw-wenkai-gb/LXGWWenKaiMonoGB-Regular', weight: 400, style: "normal", },
    { family: 'JetBrainsMono'       , file: 'jetbrains-mono/JetBrainsMono-Regular'   , weight: 400, style: "normal", },
    { family: 'JetBrainsMono-Italic', file: 'jetbrains-mono/JetBrainsMono-Italic'    , weight: 400, style: "italic", },
];

// 收集 html 中的所有文本字符。
async function collectChars(dir) {
    const htmlFiles = await glob(`${dir}/**/*.html`);
    const charSet = new Set();
    for (const file of htmlFiles) {
        const html = fs.readFileSync(file, 'utf-8');
        const dom = new JSDOM(html);
        const text = dom.window.document.body?.textContent || '';
        for (const c of text) charSet.add(c);
    }
    return [...charSet].join('');
}

// 计算最终字体子集的哈希值, 并保留前 16 位结果。
function contentHash(buffer) {
    return crypto.createHash('sha256').update(buffer).digest('hex').slice(0, 16);
}

// 主处理流程
async function run() {
    console.log('🔍 Collecting characters...');
    const chars = await collectChars('dist');
    if (!chars) {
        console.warn('⚠ An empty result is returned, skipping.');
        return;
    }
    console.log(`✅ Collected ${chars.length} characters.`);

    // 确保输出路径存在
    if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });

    const hashMap = {}; // family -> hash

    for (const { family, file } of fontConfigs) {
        const inputPath = `${fontRoot}/${file}.${fontTypeConfig.in}`;
        if (!fs.existsSync(inputPath)) {
            console.error(`❌ Full font file is not exists: ${inputPath}`);
            process.exit(1);
        }
        const fontBuffer = fs.readFileSync(inputPath);

        console.log(`⏳ Generating subset font for '${family}' ...`);
        const subsetBuffer = await subsetFont(fontBuffer, chars, {
            targetFormat: `${fontTypeConfig.out}`,
            preserveNameTable: true,
        });

        const hash = contentHash(subsetBuffer);
        const outFile = path.join(outputDir, `${hash}.${fontTypeConfig.out}`);
        fs.writeFileSync(outFile, subsetBuffer);
        console.log(`   → ${hash}.${fontTypeConfig.out} (${(subsetBuffer.length / 1024).toFixed(1)} KB)`);

        hashMap[family] = hash;
    }

    // 替换 css 中的占位符
    console.log('🔄 Replacing placeholders in css...');
    const cssFiles = await glob('dist/**/*.css');
    for (const cssFile of cssFiles) {
        let content = fs.readFileSync(cssFile, 'utf-8');
        let replaced = false;
        for (const [family, hash] of Object.entries(hashMap)) {
            const placeholder = `__FONT_HASH_${family}__`;
            if (content.includes(placeholder)) {
                content = content.replaceAll(placeholder, `/_astro/fonts/${hash}.${fontTypeConfig.out}`);
                replaced = true;
            }
        }
        if (replaced) {
            fs.writeFileSync(cssFile, content);
            console.log(`   ✔ Updated: ${cssFile}`);
        }
    }

    // 额外操作: 清理 dist/fonts 文件夹
    if (distFontRoot && fs.existsSync('dist/fonts')) {
        fs.rmSync('dist/fonts', { recursive: true, force: true });
        console.log('🗑 cleaned dist font');
    }

    console.log('✨ Font subsets generated done!');
}

run().catch(err => {
    console.error(err);
    process.exit(1);
});

Step4. 修改 `package.json` 构建命令

修改后 scripts 字段内容如下所示

{
    "scripts": {
        "build": "astro build && node scripts/subset-font.mjs && pagefind --site dist",
    },
}

其中 node scripts/subset-font.mjs 为新增命令, 其余两条命令为 astro 构建命令和 Fuwari 主题中的原有命令

命令运行顺序: astro build -> node scripts/subset-font.mjs -> pagefind --site dist

Step5. 在 Astro 布局中动态切换字体路径

在 dev 模式下预览页面时需要使用完整字体来显示页面, 保证新输入的字符不会缺少字体。在这里使用端点 css 文件来实现这个功能, 这份 css 端点文件用于生成站点中所有用到的字体, 注意文件名格式必须是 *.css.ts 格式。

// pages/fonts.css.ts
export async function GET() {
    const isDev = import.meta.env.DEV 

    // 完整字体和子集字体的格式
    const fullFontType = "ttf";
    const subSetType = "woff2";

    // 字体配置, 可直接从脚本中复制过来
    const fontWeights = [
        { family: 'Yozai'               , file: 'yozai/Yozai-Regular'                    , weight: 400, style: "normal", },
        { family: 'LXGWWenKaiMonoGB'    , file: 'lxgw-wenkai-gb/LXGWWenKaiMonoGB-Regular', weight: 400, style: "normal", },
        { family: 'JetBrainsMono'       , file: 'jetbrains-mono/JetBrainsMono-Regular'   , weight: 400, style: "normal", },
        { family: 'JetBrainsMono-Italic', file: 'jetbrains-mono/JetBrainsMono-Italic'    , weight: 400, style: "italic", },
    ];

    const fontFaces = fontWeights.map(({ family, file, weight, style }) => {
        const url = isDev
            ? `/fonts/${file}.${fullFontType}`
            : `__FONT_HASH_${family}__`;
        return `@font-face {
    font-family: '${family}';
    src: url('${url}') format('${subSetType}');
    font-weight: ${weight};
    font-style: ${style};
    font-display: swap;
}`;
    }).join('\n');

    const css = `/* 自动生成的全局字体声明 */
${fontFaces}
/* (保留内容) 可以继续添加 css 样式 */

/* 应用全局字体 */
* {
    font-family: 'JetBrainsMono', 'JetBrainsMono-Italic', 'LXGWWenKaiMonoGB';
    line-height: 1.5rem
}
`;

    return new Response(css, {
        headers: { 'Content-Type': 'text/css' },
    });
}

Step6. 功能验证

开发环境: 运行 npm run dev, 浏览器会加载完整的字体文件, 在这时可以自由输入汉字, 不会存在某一字符字体缺失的情况。
生产环境:
- 运行 npm run build, 脚本会自动扫描 dist 文件夹中所有 HTML 文档, 生成仅包含所需字符的字体子集。配合 woff2 压缩, 最终字体文件大小可以控制在 100–300 KB。
- 相比于未子集化的 woff2 字体，体积优化了约 46 倍；相比于原始 TTF 字体，优化了约 116 倍。最终文件的输出路径可由 scripts/subset-font.mjs 脚本中 outputDir 这个参数设置。

图为生成好的子集字体文件, 可以看到文件大小来到了 203KB 和 235KB, 由于脚本中对文件进行了取哈希值操作, 所以文件名为 16 位哈希结果。

Step7. 应用 CSS 样式

在 <head>...</head> 标签中, 引用端点 css, 使网站能够使用定义的 font-family。

<link rel="stylesheet" href="https://blog.tyh123.top/fonts.css" />

补充说明

关于优化后的体积倍数计算:

原始 ttf 体积取 25MB
在线工具转换后的 woff2 体积: 取 10MB, 10/25*100%=40%, 即转换后 woff2 格式的字体文件相比于原始 ttf 压缩了将近 60%, 文件体积变为原始 ttf 文件体积的 40%。
子集化 + woff2 最终体积: 按截图取 203 KB 和 235 KB, 取中间值约 220 KB, 即 0.215 MB. 25MB/0.215MB ≈ 116 倍。

进阶: 从「子集化」到「unicode-range 分片」

问题的暴露：评论区的动态文字

上面这套子集化方案上线后一直很稳定, 直到我给博客接入评论区 (Artalk) 后才暴露了一个盲区。

子集化的核心逻辑是「基于构建期已知的字符」—— subset-font.mjs 只扫描构建好的静态 HTML, 收集里面的文字。但 Artalk 评论区是页面加载完成后由前端脚本再渲染的, 评论内容在构建时完全不可预知。

于是出现这样的现象: 当访客的评论里出现了子集未收录的字符 (比如某个生僻字、特殊符号), 这个字符就没有对应的字形, 浏览器会回退到系统默认字体, 和周围的霞鹜文楷混排在一起, 观感十分割裂。

两种方案的区别

维度	子集化方案 (上文)	unicode-range 分片方案 (本章节)
原理	收集静态页面用到的字符, 只保留这些字形	把完整字体按 Unicode 区间切成几百个小块
覆盖范围	仅构建期已知字符	完整字体的全部字形
动态文本	覆盖不到(回退到默认字体)	浏览器按需补加载
单个文件体积	极小 (100–300 KB)	每块几十 KB, 但块数多
实际加载量	一个子集一次性加载	只加载用到的字符所在的分片
最适合的字体	拉丁小字体	中文大字体

简单而言就是, 字体的子集化是「只装我用到的字」, 分片则是「全部切好、按需取件」。

为什么换到分片方案

其实两种方案并不冲突, 我在项目里是混合使用的:

拉丁字体 (JetBrains Mono): 体积本来就小, 而且评论里的字母、数字、符号永远都在 ASCII 范围内, 子集化一定覆盖得到 → 继续用子集化。
中文大字体 (霞鹜文楷 GB): 完整字体有上万个字形, 而且评论里的汉字是动态、不可预知的 → 改用分片。

分片后, 中文大字体被切成几百个几十 KB 的 woff2 分片, 每条 @font-face 规则都带上了 unicode-range。浏览器渲染某个字符时, 会自动去加载「含该字符的那几个分片」——包括后来才渲染进 DOM 的评论文字。评论里出现任何汉字, 都能被浏览器自动补加载, 彻底解决了回退问题。

具体实现

Step1. 安装 cn-font-split

$ npm install -D cn-font-split

cn-font-split 是「中文网字计划」使用的字体分包工具, Rust 内核, 分包速度极快。

Step2. 创建分片脚本

将脚本保存到 scripts/split-font.mjs:

// scripts/split-font.mjs
import fs from 'fs';
import path from 'path';
import { fontSplit } from 'cn-font-split';

// 需要分片的中文字体 (拉丁字体体积小, 继续走 subset-font.mjs 的内容子集即可)
const cjkFonts = [
    {
        family: 'LXGWWenKaiMonoGB', // 与 fonts.css.ts / 全局 font-family 保持一致
        file: 'public/fonts/lxgw-wenkai-gb/LXGWWenKaiMonoGB-Regular.ttf',
    },
];

const distRoot = 'dist/_astro/fonts';

async function run() {
    for (const { family, file } of cjkFonts) {
        if (!fs.existsSync(file)) {
            console.error(`❌ 字体文件不存在: ${file}`);
            process.exit(1);
        }

        const outDir = path.join(distRoot, family);
        const input = new Uint8Array(fs.readFileSync(file).buffer);

        console.log(`⏳ 分片字体 '${family}' ...`);
        await fontSplit({
            input,
            outDir,
            css: {
                fontFamily: family,
                fontWeight: '400',
                fontStyle: 'normal',
                fontDisplay: 'swap',
                localFamily: ['LXGW WenKai Mono GB'],
            },
            chunkSize: 70 * 1024, // 单个分片目标大小 (~70KB)
            testHtml: false,
            reporter: false,
            silent: true,
        });

        // 清理辅助文件, 只保留分片 woff2 和 result.css
        for (const name of fs.readdirSync(outDir)) {
            if (!name.endsWith('.woff2') && name !== 'result.css') {
                fs.rmSync(path.join(outDir, name), { force: true });
            }
        }

        console.log(`✅ 分片完成: ${family}`);
    }
}

run()
    .then(() => process.exit(0)) // 规避 cn-font-split Rust DLL 卸载时的访问冲突
    .catch((err) => {
        console.error(err);
        process.exit(1);
    });

运行后, dist/_astro/fonts/LXGWWenKaiMonoGB/ 下会生成几百个 woff2 分片和一个 result.css (内含大量带 unicode-range 的 @font-face)。

Step3. 修改原有子集化脚本

从 scripts/subset-font.mjs 的 fontConfigs 里移除中文大字体, 只保留拉丁字体:

const fontConfigs = [
    // 中文大字体 LXGWWenKaiMonoGB 改由 scripts/split-font.mjs 分片, 不在这里子集化。
    { family: 'JetBrainsMono'        , file: 'jetbrains-mono/JetBrainsMono-Regular' , weight: 400, style: "normal", },
    { family: 'JetBrainsMono-Italic' , file: 'jetbrains-mono/JetBrainsMono-Italic'  , weight: 400, style: "italic", },
];

Step4. 修改端点 css

pages/fonts.css.ts 里, 中文大字体只在 dev 环境下用完整的 TTF 字体, prod 环境下不再生成占位符:

const fontWeights = [
    ...(isDev
        ? [{ family: 'LXGWWenKaiMonoGB', file: 'lxgw-wenkai-gb/LXGWWenKaiMonoGB-Regular', weight: 400, style: "normal" }]
        : []),
    { family: 'JetBrainsMono'       , file: 'jetbrains-mono/JetBrainsMono-Regular'  , weight: 400, style: "normal", },
    { family: 'JetBrainsMono-Italic', file: 'jetbrains-mono/JetBrainsMono-Italic'   , weight: 400, style: "italic", },
];

Step5. 在布局中引入分片 CSS

在 Layout.astro 的 <head> 中, 于 /fonts.css 之后引入分片 CSS (只在生产环境引入):

<link rel="stylesheet" href="https://blog.tyh123.top/fonts.css" />
{import.meta.env.PROD && <link rel="stylesheet" href="https://blog.tyh123.top/_astro/fonts/LXGWWenKaiMonoGB/result.css" />}

Step6. 修改构建命令

在原有构建命令里插入分片脚本:

{
    "scripts": {
        "build": "astro build && node scripts/split-font.mjs && node scripts/subset-font.mjs"
    }
}

命令运行顺序: astro build -> node scripts/split-font.mjs -> node scripts/subset-font.mjs

三个需要注意的坑

1. 二进制不随 npm 包分发, 需要放行 postinstall

cn-font-split 的 FFI 二进制 (libffi-*.dll / .so) 不随 npm 包分发, 靠安装时的 postinstall 脚本从 GitHub 下载。而 pnpm 默认会阻止依赖的 postinstall 脚本, 需要在 pnpm-workspace.yaml 里显式放行:

# pnpm 版本 11+
allowBuilds:
  cn-font-split: true

# pnpm 版本 10
onlyBuiltDependencies:
  - cn-font-split

否则构建时加载二进制会报 cannot open shared object file: No such file or directory (Linux) 或 win32=193 (Windows)。

2. 国内网络下载二进制可能被截断

postinstall 从 GitHub 下载二进制, 国内直连极慢, 下载可能被截断 (DLL 只剩约 1.9MB), 运行时加载报 win32=193 (不是有效的 Win32 应用程序)。用镜像重新下载即可:

set CN_FONT_SPLIT_GH_HOST=https://ik.imagekit.io/github
npx cn-font-split i default

3. Windows 下进程退出时的访问冲突

cn-font-split 在 Windows 上退出进程时, Rust DLL 的卸载阶段会触发访问冲突 (退出码 0xC0000005)。分片本身其实已经完成, 只需在脚本末尾用 process.exit(0) 显式退出即可规避 (见上面的 split-font.mjs 代码)。

[blog-MT-05] 使用 Obsidian 来编写笔记

2026-06-05T09:13:26.000Z

为什么用 Obsidian 写笔记

博客的文章都是一个个本地 Markdown 文件, 用 Obsidian 直接打开项目目录来写作, 可以省掉「在编辑器里写一遍, 再去浏览器里预览」的来回切换:

直接打开本地文件夹作为仓库, 不需要导入或转换;
原生支持 Markdown、代码块与相对路径图片, 和博客的写作格式一致;
可以用 CSS 片段调整界面, 把与写作无关的工程目录隐藏掉。

下面记录一下具体的配置过程。

准备工作

下文的 [ROOT] 指项目根目录 (即包含 package.json 的那一层)。

创建 Obsidian 仓库

在 Obsidian 中选择「打开本地仓库」, 然后选中项目的 src 目录即可:

打开之后, 左侧会列出 src 下的所有子目录:

隐藏与写作无关的目录

写作时其实只关心 assets 和 contents 两个目录 (图中红框圈出来的部分), 其余目录 (components、layouts、objects 等) 都可以隐藏。把下面这段 CSS 保存到 .obsidian/snippets/ 目录下:

.nav-folder:has([data-path="components"]),
.nav-folder:has([data-path="icons"]),
.nav-folder:has([data-path="layouts"]),
.nav-folder:has([data-path="loaders"]),
.nav-folder:has([data-path="objects"]),
.nav-folder:has([data-path="pages"]),
.nav-folder:has([data-path="styles"]) {
  display: none;
}

保存后, 到 设置 -> 外观 -> CSS 代码片段 里启用即可。找不到 .obsidian/snippets 目录时, 可以在同一设置页点右上角的「打开目录」:

启用后, 左侧的文件树会清爽很多:

把文章图片迁移到 assets 目录

之前文章的图片都放在 [ROOT]/public 下, 而 public 里的文件会被原样复制到站点根目录, 所以 Markdown 里应该按站点根路径引用:

/img/posts/blog/05/xxx.png

如果写成带 public 前缀的 /public/img/posts/blog/05/xxx.png, Vite 会报警告, 提示去掉 public 前缀。

但站点根路径 (/img/...) 在 Obsidian 里是找不到的 —— Obsidian 按本地文件系统的相对路径解析图片, 预览时会直接断图。

把图片迁到 [ROOT]/src/assets 下就能同时满足两边: Markdown 用相对路径引用, Obsidian 能正常预览, 构建时 Vite 也会正常处理这些图片资源。

相对路径按文章所在目录的层级向上推:

../../../(有多少层就向上推多少层)/assets/.../xxx.png

以这篇为例, 文章在 src/contents/posts/博客维护日记/ 下, 向上三层到 src/, 图片在 src/assets/img/posts/blog/05/ 下, 所以写成:

../../../assets/img/posts/blog/05/obsidian-open-folder.png

这样图片在 Obsidian 里能正常显示, 构建出来的 HTML 页面也不受影响。

小结

用 Obsidian 打开项目的 src 目录, 直接复用现有的 Markdown 文件;
在 .obsidian/snippets 里放一段 CSS, 隐藏与写作无关的工程目录;
图片统一放在 src/assets 下, Markdown 用相对路径引用, Obsidian 预览和 Vite 构建都能正常工作。

ETH-05 以太网 IP 协议介绍以及 Verilog 实现代码

2026-06-04T16:51:35.000Z

IP 协议简介

IP 协议（Internet Protocol）是互联网的核心网络层协议。它负责为数据包分配源(Source) IP 地址 和目标 (Destination) IP 地址, 并通过路由功能在不同网络节点间转发数据。它采用“尽力而为”的不可靠、无连接传输模式, 不保证数据包顺序或可靠性。而保证数据报顺序或可靠性的任务是由其上层协议 (如 TCP) 处理的。当前主要的 IP 协议版本为 IPv4 和 IPv6。

IP 协议目前常用的上层协议如下:

ICMP: 全称: Internet Control Message Protocol, 互联网控制报文协议。主要作用是帮助管理和控制网络通信, 提供网络诊断功能, 以及报告错误信息和网络是否可达等。
UDP: 全称: User Datagram Protocol, 用户数据协议。这是一种无连接、简单高效的传输层协议。
TCP: 全称: Transmission Control Protocol, 传输控制协议。是一种面向连接的、可靠的字节流传输协议, 广泛应用于互联网数据传输。以上三种协议都是基于 IP 协议 运行的。

IP 协议格式

MAC 帧

IP 首部格式

版本 (4 bits): IP 版本号, IPv4 = 4, IPv6 = 6.
首部长度 (4 bits): 以 32bit (4 字节) 为一个单位的首部长度, 首部长度一般填 5, 即 20 字节的长度.
服务类型 (8 bits): 默认为 0 就行, 用于一般服务.
总长度 (16 bits): 整个 IP 数据报的长度 (首部 + 数据段), 以字节为单位.
标识 (16 bits): 标识符, 用于分片重组
标志 (3 bits):
- bit2: 保留位
- bit1: 填 1 表示禁止分片, 填 0 表示允许分片
- bit0: 若为分片包的最后一个包就填0, 否则为 1
片偏移 (13 bits): 用于接收端重组报文
生存时间 (8 bits): 英文简称 TTL(Time To Live), 指 IP 报文在网络传输中可以通过网络交换机的次数, 若超过这个次数则交换机会将本次的 IP 报丢弃。作用是防止 IP 数据报在网络中长时间传输导致网络瘫痪。常用值: 64/128
协议 (4 bits): 上层协议 (ICMP=1, TCP=6, UDP=17)
首部校验和: 首部校验和, 计算方式在下文, 快捷链接: [首部校验和计算方法]
源 IP 地址: 发送方的 IP 地址
目的 IP 地址: 接收方的 IP 地址
可选字段: 可变, 0-40 字节的长度, 需对齐至 32 位 (4字节) 边界。但在现代网络通信中这段内容几乎用不到。
负载数据: 用户传输的负载数据, ICMP、UDP、TCP 的首部数据和负载数据均在这段内容中。

首部校验和计算方法

IP 首部校验和用于检测 IP 数据报首部在传输过程中是否出现错误。它只覆盖 IP 首部（不包括数据部分）, 且采用 16 位反码求和 算法。

假设我们的 IP 首部数据经过填充后如下图所示。

计算前的准备

将校验和字段清零: 在计算校验和之前, IP 首部中的 “首部校验和” 字段 (16 位) 必须设置为 0x0000, 保证此段不参与计算。
将所有数据按照每 16-bit(2 字节) 为划分为一个半字(Half-Word): 将整个 IP 首部 (通常是 20 字节, 不含选项, 或更多带选项的情况) 按每 2 字节为一个单位, 拆分成若干个半字。

计算步骤

累加所有的半字: 将所有这些 16 位数值进行普通的二进制加法 (允许进位到 17 位或更高, 并非取模值)。

以下是计算示例 (箭头所指的值为上一步骤的计算结果):

0x4500 + 0x003C = 0x453C
-> 0x453C + 0x0000 = 0x453C
-> 0x453C + 0x4000 = 0x853C
-> 0x853C + 0x4001 = 0xC53D
-> 0xC53D + 0x0000 = 0xC53D
-> 0xC53D + 0xC0A8 = 0x185E5   (产生进位, 结果是 0x185E5, 即高 16 位 = 0x0001, 低 16 位 = 0x85E5)
-> 0x185E5 + 0x0166 = 0x1874B   (高 16 位 = 0x0001, 低 16 位 = 0x874B)
-> 0x1874B + 0xC0A8 = 0x247F3   (高 16 位 = 0x0002, 低 16 位 = 0x47F3)
-> 0x247F3 + 0x010A = 0x248FD   (高 16 位 = 0x0002, 低 16 位 = 0x48FD)

最终累加结果为 0x2_48FD (即高 16 位 0x0002, 低 16 位 0x48FD)。

处理进位: 如果高 16 位不为 0, 则将其与低 16 位相加, 重复此步骤直到高 16 位结果为 0。

0x0002 + 0x48FD = 0x48FF

此时高 16 位为 0x0000, 停止计算。中间结果 0x48FF 称为 反码求和 的中间值。

按位取反: 将最终的 16 位中间值 0x48FF 按位取反: ~0x48FF = 0xB700, 由此我们得到了最终的校验和 0xB700, 这个值就是需要填入 IP 首部校验和字段的值。

为什么要折叠进位？

普通的加法会产生进位, 而反码求和算法通过把进位加回到低位, 保证了最终结果是一个 16 位数, 并且这种操作等价于 以 65535 为模的补码加法。
这样设计的好处是: 接收方可以用同样的方法计算 (包括校验和字段在内), 如果最终结果是 0xFFFF, 则说明首部无错。

接收方的验证方法

接收方收到 IP 数据报后, 也将整个首部 (包含校验和字段在内) 用相同的方法进行 16 位反码求和。

若首部没有错误, 计算得到的最终结果应该是 0xFFFF。
如果不是 0xFFFF, 则接收方应该丢弃这个数据报 (或通知上层)。

下面是接收方计算示例:

0x4500 + 0x003C = 0x453C
-> 0x453C + 0x0000 = 0x453C
-> 0x453C + 0x4000 = 0x853C
-> 0x853C + 0x4001 = 0xC53D
-> 0xC53D + 0xB700 = 0x17C3D   (0xB700: 在接收方参与和计算, 高 16 位 = 0x0001, 低 16 位 = 0x7C3D)
-> 0x17C3D + 0xC0A8 = 0x23CE5  (高 16 位 = 0x0002, 低 16 位 = 0x3CE5)
-> 0x23CE5 + 0x0166 = 0x23E4B  (高 16 位 = 0x0002, 低 16 位 = 0x3E4B)
-> 0x23E4B + 0xC0A8 = 0x2FEF3  (高 16 位 = 0x0002, 低 16 位 = 0xFEF3)
-> 0x2FEF3 + 0x010A = 0x2FFFD  (高 16 位 = 0x0002, 低 16 位 = 0xFFFD)

将高 16 位结果和低 16 位结果相加取和得到最终结果 0xFFFF, 表明首部数据没有错误。

0x0002 + 0xFFFD = 0xFFFF

实现代码

IP 解包模块

其工作方式同样是流式握手控制协议。从这部分开始的模块有两个握手接口, 一个是与上游的网络解包模块接口握手来接收包含 IP 首部和负载的数据, 模块负责从中分离 IP 首部并解析; 另外一个握手接口是与下游模块 (通常是 IP 协议的上层协议模块, 如 UDP、TCP) 握手发送数据, 将 IP 数据段中的负载数据发送给下游模块。

这里偷懒了没做接收方的数据校验😜。有能力的朋友可以自己做一下, 后面有时间的话我再实现吧。

module ip_decap(
    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
    input   wire    [31:00] board_ip            ,   //  [I] [31:00] board ip address, for comparison whith received destination ip address
    
    // upstream: ethernet pack decapsulation
    input   wire            decap_busy          ,   //  [I] [     ] decapsulation module busy state input
    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  reg             s_axis_rrdy         ,   //  [O] [     ] axis receive ready signal

    // Received IP payload output, to downstream: tcp/udp/icmp
    input   wire            s_ip_axis_rrdy      ,   //  [I] [     ] IP downstream rx ready
    output  reg     [07:00] s_ip_axis_rd        ,   //  [O] [07:00] IP data received output
    output  reg             s_ip_axis_rdv       ,   //  [O] [     ] IP data valid output, active-high
    output  reg             s_ip_axis_rend      ,   //  [O] [     ] IP data output end

    // IP Header output
    output  reg             ip_valid            ,   //  [O] [     ] Active-high only received destination ip address is board-ip
    output  reg     [03:00] ip_version          ,   //  [O] [03:00] IP version, 4'b4: ipv4, 4'b6: ipv6
    output  reg     [03:00] ip_header_len       ,   //  [O] [03:00] IP header length, In units of 32 bits (4 bytes).
    output  reg     [07:00] ip_tos              ,   //  [O] [07:00] IP type of service
    output  reg     [15:00] ip_total_len        ,   //  [O] [15:00] IP total length (include payload)
    output  reg     [15:00] ip_id               ,   //  [O] [15:00] IP identification
    output  reg     [02:00] ip_flag             ,   //  [O] [02:00] IP Flag, bit2: reserved, bit1: 1'b1 is allowing fragmentation, else disallowing. bit0: 1'b1 is more frame, 1'b0 is the last frame.
    output  reg     [12:00] ip_fragment_offset  ,   //  [O] [12:00] IP fragment offset
    output  reg     [07:00] ip_ttl              ,   //  [O] [07:00] IP time to live
    output  reg     [07:00] ip_ul_protocol      ,   //  [O] [07:00] IP upper-layer protocol (ICMP = 8'd1, TCP=8'd6, UDp=8'd17)
    output  reg     [15:00] ip_checksum         ,   //  [O] [15:00] IP checksum
    output  reg     [31:00] ip_src_addr         ,   //  [O] [31:00] Source ip address
    output  reg     [31:00] ip_dst_addr             //  [O] [31:00] Destination ip address
);

//================================================================================
// Local Parameter Declarations
//================================================================================
localparam  IP_ETH_TYPE =   16'h0800    ;

// state defines
localparam  ST_IDLE         =   3'd0    ;
localparam  ST_IP_HEADER    =   3'd1    ;
localparam  ST_IP_PAYLOAD   =   3'd2    ;
localparam  ST_IP_END       =   3'd3    ;

//================================================================================
// Register Declarations
//================================================================================
reg [03:00] state           ;
reg [15:00] bytes_rx_cnt    ; 

//================================================================================
// Wire Declarations
//================================================================================

//================================================================================
// Assign Declarations
//================================================================================

//================================================================================
// implements
//================================================================================

//================================================================================
// MAIN CODE
//================================================================================
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        state               <= ST_IDLE  ;
        bytes_rx_cnt        <=  16'd0   ;
        ip_version          <=  4'b0    ;
        ip_header_len       <=  4'b0    ;
        ip_tos              <=  8'b0    ;
        ip_total_len        <=  16'b0   ;
        ip_id               <=  16'b0   ;
        ip_flag             <=  3'b0    ;
        ip_fragment_offset  <=  13'b0   ;
        ip_ttl              <=  8'b0    ;
        ip_ul_protocol      <=  8'b0    ;
        ip_checksum         <=  16'b0   ;
        ip_src_addr         <=  32'b0   ;
        ip_dst_addr         <=  32'b0   ;

        s_axis_rrdy         <=  1'b0    ;
        s_ip_axis_rend      <=  1'b0    ;
        s_ip_axis_rd        <=  8'b0    ;
        s_ip_axis_rdv       <=  1'b0    ;
        ip_valid            <=  1'b0    ;
    end else begin
        case (state)
            ST_IDLE: begin
                bytes_rx_cnt        <=  16'd0   ;

                s_axis_rrdy         <=  1'b1    ;
                s_ip_axis_rend      <=  1'b0    ;
                s_ip_axis_rd        <=  8'b0    ;
                s_ip_axis_rdv       <=  1'b0    ;
                ip_valid            <=  1'b0    ;
                
                if (
                    eth_type == IP_ETH_TYPE &&      //  upstream received ip packet
                    s_axis_rdv == 1'b1
                ) begin
                    state   <=  ST_IP_HEADER                ;

                    ip_version      <=  s_axis_rd[7:4]      ;   // pre receive 1 bytes
                    ip_header_len   <=  s_axis_rd[3:0]      ;
                    bytes_rx_cnt    <= bytes_rx_cnt + 1'b1  ;
                end else begin
                    state   <=  ST_IDLE                     ;
                end
            end

            ST_IP_HEADER: begin
                bytes_rx_cnt <= bytes_rx_cnt + 1'b1 ;
                case (bytes_rx_cnt) 
                    16'd1: ip_tos               <=  s_axis_rd       ;
                    16'd2: ip_total_len[15:8]   <=  s_axis_rd       ;
                    16'd3: ip_total_len[07:0]   <=  s_axis_rd       ;
                    16'd4: ip_id[15:08]         <=  s_axis_rd       ;
                    16'd5: ip_id[07:00]         <=  s_axis_rd       ;

                    16'd6: begin
                        ip_flag                 <=  s_axis_rd[7:4]  ;
                        ip_fragment_offset[12:8]<=  s_axis_rd[4:0]  ;
                    end

                    16'd7: ip_fragment_offset[7:0]  <=  s_axis_rd   ;
                    16'd8: ip_ttl                   <=  s_axis_rd   ;
                    16'd9: ip_ul_protocol           <=  s_axis_rd   ;
                    16'd10: ip_checksum[15:08]      <=  s_axis_rd   ;
                    16'd11: ip_checksum[07:00]      <=  s_axis_rd   ;
                    16'd12: ip_src_addr[31:24]      <=  s_axis_rd   ;
                    16'd13: ip_src_addr[23:16]      <=  s_axis_rd   ;
                    16'd14: ip_src_addr[15:08]      <=  s_axis_rd   ;
                    16'd15: ip_src_addr[07:00]      <=  s_axis_rd   ;
                    16'd16: ip_dst_addr[31:24]      <=  s_axis_rd   ;
                    16'd17: ip_dst_addr[23:16]      <=  s_axis_rd   ;
                    16'd18: ip_dst_addr[15:08]      <=  s_axis_rd   ;
                    16'd19: ip_dst_addr[07:00]      <=  s_axis_rd   ;

                    default: begin  //  26.4.8 add: dest ip check
                        if (ip_dst_addr == board_ip) begin
                            state           <=  ST_IP_PAYLOAD   ;   // 1if received dst ip is board ip, receive payload
                            ip_valid        <=  1'b1            ;
                            s_ip_axis_rdv   <=  1'b1            ;
                            s_ip_axis_rd    <=  s_axis_rd       ;   //  pre-fill 1 byte
                        end else begin
                            state           <= ST_IP_END        ;   // or else, drop this packet
                            ip_valid        <=  1'b0            ;
                        end
                    end
                endcase
            end

            ST_IP_PAYLOAD: begin
                s_ip_axis_rd        <=  s_axis_rd   ;
                if (s_axis_rdv == 1'b0 ) begin
                    s_ip_axis_rd    <=  8'b0    ;
                    s_ip_axis_rdv   <=  1'b0    ;
                    s_ip_axis_rend  <=  1'b1    ;
                    state           <=  ST_IP_END   ;
                end
            end

            ST_IP_END: begin
                s_ip_axis_rend  <=  1'b0    ;
                state           <=  ST_IDLE ;
            end
        endcase
    end
end

endmodule

IP 封包模块

同样是两个握手接口, 一个接口负责接收来自上游模块 (UDP、TCP模块) 的数据, 一个接口用来将封装好的数据发送到下游模块 (以太网封包模块)。

module ip_encap (
    input   wire            clk             ,   //  [I] [     ] Module clock
    input   wire            rst_n           ,   //  [I] [     ] Module reset signal, active-low
    
    // downstream: ethernet pack encapsulation
    input   wire            encap_busy      ,   //  [I] [     ] encapsulation module busy state input, we only send packet when this signal is 1'b0    
    output  reg     [07:00] 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  wire            s_axis_tend     ,   //  [O] [     ] axis send tend output to encapsulation module
    input   wire            s_axis_trdy     ,   //  [I] [     ] axis send ready signal

    // upstream: tcp/udp/icmp tx output
    input   wire    [07:00] s_ip_axis_td    ,   //  [I] [07:00] IP data AXI-Stream input
    input   wire            s_ip_axis_tdv   ,   //  [I] [     ] IP data send valid, active-high
    input   wire            s_ip_axis_tend  ,   //  [I] [     ] IP data send end
    output  reg             s_ip_axis_trdy  ,   //  [O] [     ] IP data send ready

    // IP header
    input   wire    [15:00] data_length     ,   //  [I] [15:00] Data segment length in bytes
    input   wire    [07:00] ip_ttl          ,   //  [I] [07:00] Time to live.
    input   wire    [07:00] ip_ul_protocol  ,   //  [I] [07:00] Upper-layer protocol, (ICMP=8'd1, TCP=8'd6, UDP=8'd17)
    input   wire    [31:00] ip_src_ip       ,   //  [I] [31:00] Source ip address
    input   wire    [31:00] ip_dst_ip       ,   //  [I] [31:00] Destination ip address

    // States output
    output  reg             ip_tx_err_busy      //  [O] [     ] TX error when dowmstream encapsulation module is busy, at this time, upstream must stop transmission.
);

//================================================================================
// Local Parameter Declarations
//================================================================================
localparam  IP_VERSION          =   4'h4        ;   // ipv4
localparam  IP_HEADER_LENGTH    =   4'h5        ;   // header length 5, 20 bytes in total.
localparam  IP_TOS              =   8'h00       ;

// state defines
localparam  ST_IDLE             =   4'b0        ;
localparam  ST_CHECKSUM         =   4'd1        ;
localparam  ST_CHECKSUM_CHECK   =   4'd2        ;
localparam  ST_IP_TX_TRIG       =   4'd3        ;
localparam  ST_IP_PAYLOAD       =   4'd4        ;
localparam  ST_IP_END           =   4'd5        ;

//================================================================================
// Register Declarations
//================================================================================
reg     [03:00] state               ;
reg     [31:00] ip_header   [4:0]   ;   //  ip header: 20 bytes
reg     [04:00] ip_header_index     ;   //  for checksum and header transmission
reg     [31:00] checksum_buffer     ;
reg     [15:00] cnt                 ;   //  a counter

//================================================================================
// Wire Declarations
//================================================================================
wire    [15:00] total_length    ;   // total ip packet length, include header and data segment

//================================================================================
// Assign Declarations
//================================================================================
assign  total_length    =   ((IP_HEADER_LENGTH*4) + data_length)    ;
assign  s_axis_tend     =   s_ip_axis_tend                          ;

//================================================================================
// implements
//================================================================================

//================================================================================
// MAIN CODE
//================================================================================
always  @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        state           <=  ST_IDLE ;
        cnt             <=  16'd0   ;

        ip_header[0]    <=  32'b0   ;
        ip_header[1]    <=  32'b0   ;
        ip_header[2]    <=  32'b0   ;
        ip_header[3]    <=  32'b0   ;
        ip_header[4]    <=  32'b0   ;
        ip_header_index <=  5'd00   ;
        checksum_buffer <=  32'b0   ;

        s_axis_tdv      <=  1'b0    ;
        s_axis_td       <=  8'b0    ;
        s_ip_axis_trdy  <=  1'b0    ;

        ip_tx_err_busy  <=  1'b0    ;
    end else begin
        case(state)
            ST_IDLE: begin
                s_ip_axis_trdy  <=  1'b0    ;
                if (encap_busy == 1'b1) begin
                    ip_tx_err_busy  <=  1'b1    ;
                end else if (s_ip_axis_tdv == 1'b1) begin
                    ip_tx_err_busy  <=  1'b0    ;
                    // pre fill buffer, in order to calculate checksum.
                    ip_header[0]        <=  {IP_VERSION, IP_HEADER_LENGTH, IP_TOS, total_length};
                    ip_header[1][31:16] <=  ip_header[1][31:16] + 1'b1  ;   //  id, auto increment by 1
                    ip_header[1][15:13] <=  3'b010                      ;   //  No fragment
                    ip_header[1][12:00] <=  13'd00                      ;   //  Fragment offset
                    ip_header[2][31:24] <=  ip_ttl                      ;   //  TTL
                    ip_header[2][23:16] <=  ip_ul_protocol              ;   //  Upper-layer protocol, (ICMP=8'd1, TCP=8'd6, UDP=8'd17)
                    ip_header[2][15:00] <=  16'h0000                    ;   //  IP header checksum, temporarily is 0
                    ip_header[3]        <=  ip_src_ip                   ;   //  Source ip address
                    ip_header[4]        <=  ip_dst_ip                   ;   //  Destination ip address

                    state   <=  ST_CHECKSUM ;
                end
            end

            ST_CHECKSUM: begin
                checksum_buffer <=  ip_header[0][31:16] + ip_header[0][15:00] +
                                    ip_header[1][31:16] + ip_header[1][15:00] +
                                    ip_header[2][31:16] + ip_header[2][15:00] +
                                    ip_header[3][31:16] + ip_header[3][15:00] +
                                    ip_header[4][31:16] + ip_header[4][15:00] ;
                state   <=  ST_CHECKSUM_CHECK   ;
            end

            ST_CHECKSUM_CHECK: begin
                if (checksum_buffer[31:16] == 16'h0000) begin           // Accumulate until the high 16 bits are 0.
                    ip_header[2][15:00] <=  ~checksum_buffer[15:00] ;   //  The final result is bitwise negated.
                    state               <=  ST_IP_TX_TRIG           ;   //  Goto next state

                    s_axis_tdv          <=  1'b1                    ;   //  downstream: frame encapsulation tx valid, then wait trdy signal
                    // s_axis_td           <=  ip_header[0][31:24]     ;
                    // cnt                 <=  15'd1                   ;
                end else begin
                    checksum_buffer <=  checksum_buffer[31:16] + checksum_buffer[15:00];
                end
            end

            ST_IP_TX_TRIG: begin
                if (s_axis_trdy == 1'b1) begin
                    cnt         <=  cnt + 1'b1          ;
                    s_axis_td   <=  ip_header[cnt[15:2]][((3 - cnt[1:0])*8)+:8];
                    if (cnt == IP_HEADER_LENGTH*4 - 1) begin
                        cnt         <=  16'd0           ;
                        state       <=  ST_IP_PAYLOAD   ;
                        // s_axis_td   <=  s_ip_axis_td    ;
                    end else if (cnt == IP_HEADER_LENGTH*4 - 2) begin
                        s_ip_axis_trdy  <=  1'b1            ;
                    end
                end
            end

            ST_IP_PAYLOAD: begin
                s_axis_td           <=  s_ip_axis_td    ;
                if (s_ip_axis_tend == 1'b1) begin
                    s_axis_tdv      <=  1'b0            ;
                    s_axis_td           <=  8'b00       ;
                    s_ip_axis_trdy      <=  1'b0        ;
                    state           <=  ST_IP_END       ;
                end
            end

            ST_IP_END: begin
                state               <=  ST_IDLE             ;
            end
        endcase
    end
end

endmodule

IP 协议顶层

这个模块作为一个顶层例化了封包和解包两个子模块, 方便在其它上层模块中进行调用。

module ip(
    input   wire            tx_clk                      ,   //  [I] [     ] Module tx clock
    input   wire            rx_clk                      ,   //  [I] [     ] Module rx clock
    input   wire            rst_n                       ,   //  [I] [     ] Module reset signal, active-low

    input   wire    [15:00] ip_rx_eth_type              ,   //  [I] [15:00] received ethertype
    input   wire    [31:00] board_ip                    ,   //  [I] [31:00] board ip address, for comparison whith received destination ip address

    // ip encap
    // downstream: ethernet pack encapsulation
    input   wire            encap_busy                  ,   //  [I] [     ] encapsulation module busy state input, we only send packet when this signal is 1'b0
    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

    // IP payload output, to downstream: tcp/udp/icmp
    output  wire            s_ip_axis_trdy              ,   //  [I] [     ] IP downstream rx ready
    input   wire    [07:00] s_ip_axis_td                ,   //  [O] [07:00] IP data AXI-Stream output
    input   wire            s_ip_axis_tdv               ,   //  [O] [     ] IP data output valid, active-high
    input   wire            s_ip_axis_tend              ,   //  [O] [     ] IP data output end

    input   wire    [15:00] ip_encap_data_length        ,   //  [I] [15:00] Data segment length in bytes
    input   wire    [07:00] ip_encap_ttl                ,   //  [I] [07:00] Time to live.
    input   wire    [07:00] ip_encap_ul_protocol        ,   //  [I] [07:00] Upper-layer protocol, (ICMP=8'd1, TCP=8'd6, UDP=8'd17)
    input   wire    [31:00] ip_encap_src_ip             ,   //  [I] [31:00] Source ip address
    input   wire    [31:00] ip_encap_dst_ip             ,   //  [I] [31:00] Destination ip address

    output  wire            ip_encap_tx_err_busy        ,   //  [O] [     ] TX error when dowmstream encapsulation module is busy, at this time, upstream must stop transmission.

    // ip decap
    // upstream: ethernet pack decapsulation
    input   wire            decap_busy                  ,   //  [I] [     ] decapsulation module busy state input
    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

    input   wire            s_ip_axis_rrdy              ,   //  [I] [     ] IP downstream rx ready
    output  wire    [07:00] s_ip_axis_rd                ,   //  [O] [07:00] IP data received output
    output  wire            s_ip_axis_rdv               ,   //  [O] [     ] IP data valid output, active-high
    output  wire            s_ip_axis_rend              ,   //  [O] [     ] IP data output end

    // output received ip header
    output  wire            ip_valid                    ,   //  [O] [     ] Active-high only received destination ip address is board-ip
    output  wire    [03:00] ip_decap_version            ,   //  [O] [03:00] IP version, 4'b4: ipv4, 4'b6: ipv6
    output  wire    [03:00] ip_decap_header_len         ,   //  [O] [03:00] IP header length, In units of 32 bits (4 bytes).
    output  wire    [07:00] ip_decap_tos                ,   //  [O] [07:00] IP type of service
    output  wire    [15:00] ip_decap_total_len          ,   //  [O] [15:00] IP total length (include payload)
    output  wire    [15:00] ip_decap_id                 ,   //  [O] [15:00] IP identification
    output  wire    [02:00] ip_decap_flag               ,   //  [O] [02:00] IP Flag, bit2: reserved, bit1: 1'b1 is allowing fragmentation, else disallowing. bit0: 1'b1 is more frame, 1'b0 is the last frame.
    output  wire    [12:00] ip_decap_fragment_offset    ,   //  [O] [12:00] IP fragment offset
    output  wire    [07:00] ip_decap_ttl                ,   //  [O] [07:00] IP time to live
    output  wire    [07:00] ip_decap_ul_protocol        ,   //  [O] [07:00] IP upper-layer protocol (ICMP = 8'd1, TCP=8'd6, UDp=8'd17)
    output  wire    [15:00] ip_decap_checksum           ,   //  [O] [15:00] IP checksum
    output  wire    [31:00] ip_decap_src_addr           ,   //  [O] [31:00] Source ip address
    output  wire    [31:00] ip_decap_dst_addr               //  [O] [31:00] Destination ip address
);

ip_encap ip_encap_inst (
    .clk                (   tx_clk                      ),  //  [I] [     ] Module clock
    .rst_n              (   rst_n                       ),  //  [I] [     ] Module reset signal, active-low
    
    // downstream: ethernet pack encapsulation
    .encap_busy         (   encap_busy                  ),  //  [I] [     ] encapsulation module busy state input, we only send 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
    
    // upstream: tcp/udp/icmp tx output
    .s_ip_axis_td       (   s_ip_axis_td                ),  //  [I] [07:00] IP data AXI-Stream input
    .s_ip_axis_tdv      (   s_ip_axis_tdv               ),  //  [I] [     ] IP data receive valid, active-high
    .s_ip_axis_tend     (   s_ip_axis_tend              ),  //  [I] [     ] IP data receive end
    .s_ip_axis_trdy     (   s_ip_axis_trdy              ),  //  [O] [     ] IP data receive ready

    // IP header
    .data_length        (   ip_encap_data_length        ),  //  [I] [15:00] Data segment length in bytes
    .ip_ttl             (   ip_encap_ttl                ),  //  [I] [07:00] Time to live.
    .ip_ul_protocol     (   ip_encap_ul_protocol        ),  //  [I] [07:00] Upper-layer protocol, (ICMP=8'd1, TCP=8'd6, UDP=8'd17)
    .ip_src_ip          (   ip_encap_src_ip             ),  //  [I] [31:00] Source ip address
    .ip_dst_ip          (   ip_encap_dst_ip             ),  //  [I] [31:00] Destination ip address

    // States output
    .ip_tx_err_busy     (   ip_encap_tx_err_busy        )   //  [O] [     ] TX error when dowmstream encapsulation module is busy, at this time, upstream must stop transmission.
);

ip_decap ip_decap_inst (
    .clk                (   rx_clk                      ),  //  [I] [     ] Module clock
    .rst_n              (   rst_n                       ),  //  [I] [     ] Module reset signal, active-low
    .eth_type           (   ip_rx_eth_type              ),  //  [I] [15:00] received ethertype
    .board_ip           (   board_ip                    ),  //  [I] [31:00] board ip address, for comparison whith received destination ip address
    // upstream: ethernet pack decapsulation
    .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

    // IP payload output, to downstream: tcp/udp/icmp
    .s_ip_axis_rrdy     (   s_ip_axis_rrdy              ),  //  [I] [     ] IP downstream rx ready
    .s_ip_axis_rd       (   s_ip_axis_rd                ),  //  [O] [07:00] IP data AXI-Stream output
    .s_ip_axis_rdv      (   s_ip_axis_rdv               ),  //  [O] [     ] IP data output valid, active-high
    .s_ip_axis_rend     (   s_ip_axis_rend              ),  //  [O] [     ] IP data output end

    // output received ip header
    .ip_valid           (   ip_valid                    ),  //  [O] [     ] Active-high only received destination ip address is board-ip
    .ip_version         (   ip_decap_version            ),  //  [O] [03:00] IP version, 4'b4: ipv4, 4'b6: ipv6
    .ip_header_len      (   ip_decap_header_len         ),  //  [O] [03:00] IP header length, In units of 32 bits (4 bytes).
    .ip_tos             (   ip_decap_tos                ),  //  [O] [07:00] IP type of service
    .ip_total_len       (   ip_decap_total_len          ),  //  [O] [15:00] IP total length (include payload)
    .ip_id              (   ip_decap_id                 ),  //  [O] [15:00] IP identification
    .ip_flag            (   ip_decap_flag               ),  //  [O] [02:00] IP Flag, bit2: reserved, bit1: 1'b1 is allowing fragmentation, else disallowing. bit0: 1'b1 is more frame, 1'b0 is the last frame.
    .ip_fragment_offset (   ip_decap_fragment_offset    ),  //  [O] [12:00] IP fragment offset
    .ip_ttl             (   ip_decap_ttl                ),  //  [O] [07:00] IP time to live
    .ip_ul_protocol     (   ip_decap_ul_protocol        ),  //  [O] [07:00] IP upper-layer protocol (ICMP = 8'd1, TCP=8'd6, UDp=8'd17)
    .ip_checksum        (   ip_decap_checksum           ),  //  [O] [15:00] IP checksum
    .ip_src_addr        (   ip_decap_src_addr           ),  //  [O] [31:00] Source ip address
    .ip_dst_addr        (   ip_decap_dst_addr           )   //  [O] [31:00] Destination ip address
);

endmodule

[blog-MT-04] - 用 Umami 为博客搭建数据统计服务

2026-05-29T14:42:31.000Z

需要做的工作

拥有一台云服务器
拥有一个已经部署好的 umami 实例，本篇会介绍如何部署 umami 实例

部署 umami 实例

这里采用 docker 安装，在这之前你需要在云服务器上安装好 docker 服务，推荐使用宝塔面板来一键安装 docker 服务，本篇基于宝塔面板来介绍。

首先需要将 umami 的 github 仓库克隆下来

$ git clone https://github.com/umami-software/umami.git

然后进入刚刚克隆好的仓库目录下，找到 docker-compose.yml, 修改数据库的名字

以下内容不修改也是可以的，但是为了安全起见建议修改

ports: umami 实例的端口映射，建议修改一下宿主机的端口(冒号前面的)，不要用默认的端口。
DATABASE_URL: 格式为 postgresql://用户名:密码@db:端口号/数据库名 这里的用户名、密码、数据库名对应 db 中的 POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB 这三个值，端口号目前我不知道怎么改，如果有知道的大佬可以在评论区评论一下（
APP_SECRET: 改成一串随机的字符串
POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB: 在上面已经提到了，是数据库的用户名、密码、数据库名。

改完配置之后运行下面的命令:

$ docker compose up -d

之后在宝塔面板的 Docker 服务中就可以看到我们刚刚创建好的两个容器了，一个是 umami，另外一个是数据库。

进入 umami 后台

部署完成后，可以访问 http://服务器公网ip:端口(宿主机) 进入 umami 后台了，默认用户名和密码为 admin 和 umami,

也可以使用反向代理将域名解析到你的服务器 ip 上去掉端口，之前有介绍过这里就不说了。

创建网站

在 umami 后台中依次点击 网站 -> 添加网站，之后输入网站名称和网站的 域名(不带 https://) 就好了

初次进入界面时语言可能是英文，这时可以点击左下角 admin -> Language -> 往下滑找到中文 就可以改成中文了。

开始统计数据

点击右侧的 “编辑” 图标找到 “跟踪代码” 块, 将这部分代码复制到 <header> ... </header> 标签页内即可开始跟踪数据。

分享数据

在编辑网站页面找到 “分享” 块，点击添加，然后选择你要分享的数据，选择好后点击保存会生成一个分享链接，将这个链接放置到你的博客网站上，这样访客就可以直接查看到你的网站统计数据，而无需登录到 umami 后台，确保数据安全。

[blog-MT-03] - 通过域名访问宝塔面板，并设置反向代理来移除端口号

2026-05-27T21:34:08.000Z

前言

为了给博客搭建评论系统，我购买了一台云服务器来托管评论，选用的评论系统是 Artalk, 在折腾服务器的过程中，自然少不了配置宝塔面板。但通过 IP + 端口的方式访问面实在是不太优雅。因此在这篇记录中，我会介绍如何将域名解析到宝塔面板，并通过反向代理去掉端口号，实现更简洁的访问方式。

为域名添加 DNS 解析记录

添加记录很简单，我这里使用的是 cloudflare dns 解析，添加一个 A 记录解析到云服务器的公网 ip 即可。

宝塔面板设置

首先来到 网站 -> 反向代理 页面，然后点击添加反代。

然后配置内容如下图所示

URL 地址就是 127.0.0.1:[宝塔端口]
发送域名不用管，就用 $http_host 就可以，这部分在你填写 URL 地址时就已经填好了

踩坑记录

设置好后，浏览器依旧显示不安全的网站，但是证书有效

这是因为浏览器缓存的原因，清除浏览记录，使用 inprivate 页面访问，或者换个设备尝试一下或许就正常了。我当时就是因为这个原因卡了有几个小时，结果居然就是这么个离谱的原因……

设置好后，访问提示 Invalid SSL Certificate

这是因为没有配置 ssl 证书，可以在宝塔中申请一个 ssl 证书，之后就可以正常访问了。

或者使用 CF 的源端服务器证书，有效期 15 年。下面介绍 CF 源端服务器证书申请方式：

依次进入 域名(Domain) -> 概览(Overview) -> 你的域名 -> SSL/TLS -> 源服务器 -> 创建证书 创建后会显示出证书和密钥，复制下来保存好，然后将 SSL 证书上传到宝塔即可。生成好的证书是统配的，以后再需要创建反代或者站点的话直接使用同一个证书就行，很方便。

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

2026-05-20T09:43:19.000Z

前言

由于 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] - 使用 Astro/Hexo 框架的博客建站过程

2026-05-19T22:33:31.000Z

注意: 文章中关于使用 hexo 框架建站的内容已不再适用于本站, 本站采用 Astro 框架搭建。相关内容仅作参考, 请勿直接用于 Astro 框架的博客网站。

关于 Hexo

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

配置 Node.js 环境

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

使用 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 的项目文件。

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

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

$ hexo init

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

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

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

$ npm install

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

$ hexo s

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

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

命令如下

$ hexo s -p 4001

生成静态资源

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

$ hexo g

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

FPGA SPI 通信

2026-04-19T14:38:34.000Z

简介

在之前讲 ${post 96d23a91} 的时候，有讲到过串口通信是异步通信，而 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 (时钟极性)	CPHA (时钟相位)	说明
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

仿真测试平台

`timescale 1ns/1ps

module spi_master_tb;

// 产生 100MHz 的时钟
localparam CLOCK_PERIOD = 10;

reg clk;
initial clk = 0;
always #(CLOCK_PERIOD/2) clk=~clk;

reg             rst_n           ;
reg     [23:0]  dat_tx          ;
wire    [23:0]  dat_rx          ;
reg             start_op        ;
wire            spi_end         ;
wire            spi_sclk        ;
wire            spi_cs_n        ;
reg             spi_miso        ;
wire            spi_mosi        ;
wire    [ 7:0]  data_bit_cnt    ;

initial begin
    rst_n       <=  1'b0        ;
    dat_tx      <=  24'h79BC    ;   //  待发送数据
    start_op    <=  1'b0        ;
    spi_miso    <=  1'b0        ;
    #(CLOCK_PERIOD*10)
    rst_n       <=  1'b1        ;   //  释放复位信号
    #(CLOCK_PERIOD*10)
    start_op    <=  1'b1        ;   //  等待 10 个时钟周期后触发发送信号
    #CLOCK_PERIOD
    start_op    <=  1'b0        ;   //  释放发送信号

end

//  实例例化
spi_master # (
    .DATA_WIDTH         (   8'd24   ),
    .CPOL               (   1'b0    ),
    .CPHA               (   1'b0    ),
    .CLK_DIV            (   8'd10   ),  // 输入的 100MHz 时钟进行 10 分频, 得到 10MHz 的 SPI 时钟
    .MOSI_IDLE_STATE    (   1'b0    ), 
    .CONTINUOUS_CLK     (   1'b0    )
) dut (
    .clk                (   clk             ),
    .rst_n              (   rst_n           ),
    .dat_tx             (   dat_tx          ),
    .dat_rx             (   dat_rx          ),
    .start_op           (   start_op        ),
    .spi_end            (   spi_end         ),
    .spi_sclk           (   spi_sclk        ),
    .spi_cs_n           (   spi_cs_n        ),
    .spi_miso           (   spi_miso        ),
    .spi_mosi           (   spi_mosi        ),
    .data_bit_cnt       (   data_bit_cnt    )
);
    
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 的学习与应用

2026-04-18T15:18:25.000Z

前言

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 的逻辑等等

时钟信号的产生

和之前有一篇讲 ${post 52a1f482} 文章中的代码类似，也是产生一个双边沿的脉冲信号，然后根据这个双边沿脉冲信号去翻转 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 串口通信

2026-04-17T14:08:17.000Z

简介

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

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

串口通信方式

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

实现代码

串口发送模块

该模块负责串口数据的发送，已折叠部分代码 (点击折叠内容即可打开)

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

串口接收模块

该模块负责串口数据的接收，已折叠部分代码 (点击折叠内容即可打开)

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

封装后的串口顶层

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

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，时钟输入为差分信号输入

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 通信协议简介及实现代码

2026-04-16T11:25:17.000Z

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 实现代码

2026-04-15T10:47:26.000Z

什么是以太网帧

以太网帧是指在网络中传输数据的基本单位。以太网帧按照一定的格式组成了以太网数据包。简单来讲，它类似于 “数据包裹(就像快递一样)“，包裹中包含了 “寄件人 (发送方 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 ( 十六进制 )	协议
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）反向地址解析协议（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 接口的互相转换

2026-04-14T14:26:09.000Z

在 ${post 4a0bb95d} 中我讲到了 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 (上升沿)	RGMII: TX_CTL (下降沿)	状态描述
正常帧间隙 (空闲)	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 初识以太网的硬件组成

2026-04-13T15:14:06.000Z

以太网通信的硬件组成

下面是一张硬件组成图例主要由 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 设计，从而在性能、成本与布线复杂度之间取得平衡。

关于点阵字库数据的生成, 以及对应偏移地址的计算方法

2026-03-17T09:18:06.000Z

前言

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

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

GBK 汉字字符集的生成

什么是 GBK 汉字字符集？

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

通俗的来讲就是所有汉字的一个集合，这个集合按照先后顺序被排列组合起来，就形成了 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()

生成点阵字库

将我们生成好的 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。

小结

若位码小于等于 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 驱动程序)。在这里就不详细展开说明了。

[blog-MT-07] 博客主题页面更新啦, 浅浅介绍一下本次更新的内容吧

[blog-MT-07] 博客主题页面更新啦, 浅浅介绍一下本次更新的内容吧

主要更新内容

关于开源

[blog-MT-06] - 将 TTF 字体压缩至几百 KB 的 woff2 字体, 一套网页字体轻量化的完整解决方案

前言

优化方法

字体子集化过程

Step.1 安装 Node 工具

Step2. 存放完整字体文件

Step3. 创建构建后脚本

Step4. 修改 package.json 构建命令

Step5. 在 Astro 布局中动态切换字体路径

Step6. 功能验证

Step7. 应用 CSS 样式

补充说明

进阶: 从「子集化」到「unicode-range 分片」

问题的暴露：评论区的动态文字

两种方案的区别

为什么换到分片方案

具体实现

Step1. 安装 cn-font-split

Step2. 创建分片脚本

Step3. 修改原有子集化脚本

Step4. 修改端点 css

Step5. 在布局中引入分片 CSS

Step6. 修改构建命令

三个需要注意的坑

[blog-MT-05] 使用 Obsidian 来编写笔记

为什么用 Obsidian 写笔记

准备工作

创建 Obsidian 仓库

隐藏与写作无关的目录

把文章图片迁移到 assets 目录

小结

ETH-05 以太网 IP 协议介绍以及 Verilog 实现代码

IP 协议简介

IP 协议格式

MAC 帧

IP 首部格式

首部校验和计算方法

计算前的准备

计算步骤

为什么要折叠进位？

接收方的验证方法

实现代码

IP 解包模块

IP 封包模块

IP 协议顶层

[blog-MT-04] - 用 Umami 为博客搭建数据统计服务

需要做的工作

部署 umami 实例

进入 umami 后台

创建网站

开始统计数据

分享数据

[blog-MT-03] - 通过域名访问宝塔面板，并设置反向代理来移除端口号

前言

为域名添加 DNS 解析记录

宝塔面板设置

踩坑记录

设置好后，浏览器依旧显示不安全的网站，但是证书有效

设置好后，访问提示 Invalid SSL Certificate

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

前言

部署步骤

创建页面

[blog-MT-01] - 使用 Astro/Hexo 框架的博客建站过程

关于 Hexo

配置 Node.js 环境

安装 Hexo

初始化 Hexo 目录

生成静态资源

FPGA SPI 通信

简介

标准 SPI(四线式) 接口

半双工 SPI (三线式) 通信

SPI 的四种通信模式

SPI 模块参数以及端口定义

串行时钟的产生

Step4. 修改 `package.json` 构建命令