Lumenth

RV32I 单周期数据通路

Thu, 24 Sep 2026 00:00:00 +0000

逐指令数据通路说明（配图版）

本文是单周期 RV32I CPU的配套篇：不再用文字画框图，而是逐类说明每条指令的数据通路走向，并标注对应的数据通路图应放在哪里。请将绘制的图片统一放在本目录 Datapath/ 下，文件名按下方标注命名即可直接渲染。

同 opcode 的指令共享同一套数据通路，区别仅在于 ALU 具体运算（由 funct3/funct7 决定）与立即数格式（imm_sel）。因此按 9 类 opcode 组织，每类列出覆盖的全部指令。

公共部分（所有指令共用）

在取指阶段 PC 给出地址从 IMEM 读出 32 位指令；指令字经字段提取得到 opcode / funct3 / funct7 / rs1 / rs2 / rd，其中 opcode/funct3/funct7 送 Control 译码，rs1/rs2 送 RegFile 读端口，rd 作为写回地址。同时 ImmGen 按类型生成符号扩展立即数。执行阶段 ALU 的 A 端由 alu_a_sel 选 rdata1 或 PC，B 端由 alu_src 选 rdata2 或 imm；ALU 输出 alu_result（及 zero 标志）。结果经 WBMUX（wb_sel 选择）写回 RegFile，访存类经 DMEM，下一条 PC 由 pc_next 选择逻辑决定。

1. R-type —— 寄存器-寄存器运算（10 条）

覆盖指令：add sub and or xor sll srl sra slt sltu

数据通路为 RegFile.rdata1 → ALU.A、RegFile.rdata2 → ALU.B（因 alu_src=0，B 端取 rs2）。ALU 运算结果直接经 WBMUX（wb_sel=00）写回 RegFile.rd（reg_write=1）。不经过 DMEM，不改变 PC 流向，PC_next = PC + 4。ALU 运算由 {funct7[5], funct3} 选择：0000 ADD / 1000 SUB / 0111 AND / 0110 OR / 0100 XOR / 0001 SLL / 0101 SRL / 1101 SRA / 0010 SLT / 0011 SLTU。

关键控制信号：reg_write=1, alu_src=0, mem_read=0, mem_write=0, branch=0, jump=0, wb_sel=00, alu_a_sel=0, imm_sel=000，alu_op根据命令取值

2. I-type —— 寄存器-立即数运算（9 条）

覆盖指令：addi andi ori xori slti sltiu slli srli srai

数据通路与 R-type 几乎一致，唯一区别是 ALU.B 由 alu_src=1 改为取 ImmGen 输出的立即数（rdata2 不再参与）。ALU 结果经 WBMUX（wb_sel=00）写回 rd。不访存，PC_next = PC + 4。ALU 运算由 funct3 选择；slli/srli/srai 移位量来自立即数低 5 位，其中 srli 与 srai 再靠 funct7[5] 区分逻辑/算术右移。注意没有 subi，减法用 addi 传负数实现。

关键控制信号：reg_write=1, alu_src=1, mem_read=0, mem_write=0, branch=0, jump=0, wb_sel=00, alu_a_sel=0, imm_sel=000

3. LOAD —— 从存储器加载（5 条）

覆盖指令：lw lh lb lhu lbu

ALU 计算地址（A=rdata1，B=imm，alu_src=1，即 rs1 + imm），地址送 DMEM；DMEM 在 mem_read=1 时输出 rdata。rdata 经 WBMUX（wb_sel=01，选 MEM）写回 RegFile.rd（reg_write=1）。不写存储器，PC_next = PC + 4。读写宽度/符号扩展由 funct3 决定：000 LB(符号) / 001 LH(符号) / 010 LW / 100 LBU(零扩展) / 101 LHU(零扩展)。

关键控制信号：reg_write=1, alu_src=1, mem_read=1, mem_write=0, branch=0, jump=0, wb_sel=01, alu_a_sel=0, imm_sel=000

4. STORE —— 写入存储器（3 条）

覆盖指令：sw sh sb

ALU 计算地址（rs1 + imm，alu_src=1），地址送 DMEM。待写入的数据来自 rs2（RegFile.rdata2），在 mem_write=1 时写入 DMEM。STORE 不写回寄存器（reg_write=0），也不经过 WBMUX 写回。PC_next = PC + 4。宽度由 funct3 决定：000 SB / 001 SH / 010 SW。画图时注意区分：地址用 rs1，数据是 rs2。

关键控制信号：reg_write=0, alu_src=1, mem_read=0, mem_write=1, branch=0, jump=0, wb_sel=—, alu_a_sel=0, imm_sel=001

5. BRANCH —— 条件分支（6 条）

覆盖指令：beq bne blt bge bltu bgeu

ALU 对 rs1/rs2 做比较（alu_src=0，不访存、不写回）。ALU 输出的 zero 或 result[0] 送「分支判断」逻辑，结合 branch=1 与 funct3 得到 branch_taken。下一条 PC 选择：branch_taken ? PC + imm(B型) : PC + 4。BRANCH 既不写寄存器也不访存。ALU 固定执行减/比较：beq/bne → SUB 看 zero；blt/bge → SLT(有符号)；bltu/bgeu → SLTU(无符号)，由 funct3[2:1] 与 funct3[0] 区分相等/大小比较及是否取反。

关键控制信号：reg_write=0, alu_src=0, mem_read=0, mem_write=0, branch=1, jump=0, wb_sel=—, alu_a_sel=0, imm_sel=010

6. JAL —— 无条件跳转并链接（1 条）

覆盖指令：jal

跳转目标 = PC + imm（J 型立即数），不经过 ALU 做地址运算，直接送「下一条 PC 选择」逻辑（jump=1 → pc_next = PC + imm）。同时 PC + 4 经 WBMUX（wb_sel=10，选 PC+4）写回 RegFile.rd（reg_write=1）作为返回地址。不访存，ALU 在此类指令中可闲置。

关键控制信号：reg_write=1, alu_src=0, mem_read=0, mem_write=0, branch=0, jump=1, wb_sel=10, alu_a_sel=0, imm_sel=100

7. JALR —— 寄存器间接跳转并链接（1 条）

覆盖指令：jalr

文字描述：跳转地址 = rs1 + imm，由 ALU 计算（alu_src=1，A=rdata1，B=imm），结果清最低位（[0]=0）后作为 pc_next（jump=1）。同时 PC + 4 经 WBMUX（wb_sel=10）写回 rd（reg_write=1）作为返回地址。最常用形式 jalr x0, 0(x1) 不保存返回地址（rd=x0）。不访存。

关键控制信号：reg_write=1, alu_src=1, mem_read=0, mem_write=0, branch=0, jump=1, wb_sel=10, alu_a_sel=0, imm_sel=000

8. LUI —— 载入高位立即数（1 条）

覆盖指令：lui

U 型立即数（高 20 位，低 12 位清零）直接经 WBMUX（wb_sel=11，选立即数）写回 RegFile.rd（reg_write=1）。不经过 ALU 运算，也不访存，不访存。PC_next = PC + 4。画图时只需把 ImmGen 输出接到 WBMUX 的 imm 输入端即可。

关键控制信号：reg_write=1, alu_src=—, mem_read=0, mem_write=0, branch=0, jump=0, wb_sel=11, alu_a_sel=0, imm_sel=011

9. AUIPC —— 地址无关高位立即数（1 条）

覆盖指令：auipc

文字描述：ALU 的 A 端由 alu_a_sel=1 改为取 PC，B 端由 alu_src=1 取 U 型立即数，执行 ADD 得到 PC + (imm << 12)。结果经 WBMUX（wb_sel=00）写回 RegFile.rd（reg_write=1）。不访存，PC_next = PC + 4。常用于与 jal 配合构造任意 32 位跳转/PC 相对地址。

关键控制信号：reg_write=1, alu_src=1, mem_read=0, mem_write=0, branch=0, jump=0, wb_sel=00, alu_a_sel=1, imm_sel=011

控制信号速查表（9 类汇总，供画图对照）

opcode	类型	reg_write	alu_src	mem_read	mem_write	branch	jump	wb_sel	alu_a_sel	imm_sel
`0110011`	R-type	1	0	0	0	0	0	00	0	—
`0010011`	I-type	1	1	0	0	0	0	00	0	000
`0000011`	LOAD	1	1	1	0	0	0	01	0	000
`0100011`	STORE	0	1	0	1	0	0	—	0	001
`1100011`	BRANCH	0	0	0	0	1	0	—	0	010
`1101111`	JAL	1	0	0	0	0	1	10	0	100
`1100111`	JALR	1	1	0	0	0	1	10	0	000
`0110111`	LUI	1	—	0	0	0	0	11	0	011
`0010111`	AUIPC	1	1	0	0	0	0	00	1	011

该表与单周期 RV32I CPU中 Control 模块的译码表完全一致，可作为画图时每个 MUX 选择位的标注依据。

深度学习笔记3-反向传播

Sat, 19 Sep 2026 00:00:00 +0000

反向传播

我在多层感知机笔记中提到，感知机的学习规则只适用于单层网络，一旦引入隐藏层，隐藏层神经元的参数该调整多少就无从得知。反向传播（Backpropagation）就是解决这个问题的方法。谦行AIing老师的视频讲解非常好，这里十分推荐。

在学习反向传播前建议先理清几个后面会反复出现的关键概念。

一次训练的总体流程

初始化参数

首先随机初始化所有权重 W 和偏置 b。

权重不能全部取 0，也不能全部取成同一个值：那样同一层的每个神经元接收到的输入、算出的输出、得到的梯度都完全一样，无论训练多久都学不出不同的特征（对称性问题）。
常见做法是取接近 0 的小随机数，并按该层的输入维度做缩放（如 Xavier 初始化、配合 ReLU 的 He 初始化），避免信号在一开始就被放大或衰减得太厉害。
偏置通常直接初始化为 0 即可。

同时还要定好学习率 η、迭代轮数等超参数。

前向传播

从输入层开始，沿着 l = 1, 2, …, L 逐层往后算：

第 l 层的净输入：z^(l) = W^(l)a^(l−1) + b^(l)
第 l 层的输出：a^(l) = σ(z^(l))
输入层 a⁽⁰⁾ = x，最后一层的输出就是预测值 ŷ = a^(L)

这一步不更新任何参数，只是把输入一路算到预测值。每一层的 z 和 a 都要先存下来，反向计算梯度时会直接复用这些数。

计算损失函数

把预测值 ŷ 和真实标签 y 代入损失函数，得到一个标量 L，用来衡量这次预测有多差：

回归任务：均方误差 L = ½ ‖ŷ − y‖²
二分类任务：Sigmoid 输出 + 交叉熵 L = −[y·log ŷ + (1−y)·log(1−ŷ)]
多分类任务：Softmax 输出 + 交叉熵 L = −Σᵢ yᵢ·log ŷᵢ

反向传播求的是"L 对每个参数的变化率"，所以损失函数必须可导。这也是为什么要用 Sigmoid、ReLU 这类激活函数，而不是感知机里的阶跃函数——后者处处导数为 0、在 0 处还不可导，梯度根本传不下去。

反向传播

这一步的目标是求出所有参数的梯度 ∂L/∂W^(l) 和 ∂L/∂b^(l)。

做法是从输出层开始，把误差往输入层方向逐层回传：先算输出层该为误差负多少责任，再把这个责任按权重大小分摊给前一层，如此一直推到第一层。每到一层，就顺手记下该层参数的梯度。

更新参数

拿到梯度后，让每个参数沿梯度的反方向走一小步：

1
2

W^(l) ← W^(l) − η · ∂L/∂W^(l)
b^(l) ← b^(l) − η · ∂L/∂b^(l)

η 是学习率，控制每一步走多大：太小收敛慢，太大容易在最优附近来回震荡甚至发散。

到了这里，一次完整的训练迭代就走完了。之后回到前向传播反复循环，直到损失降到足够低或达到设定的轮数。实际的训练通常还会把训练数据切成小批量（mini-batch）分批送入，用批内样本梯度的平均值来更新。

总结与引入反向传播

回头看这一轮：初始化参数 → 前向传播 → 计算损失 → 反向传播 → 更新参数。

这几步里，除了反向传播，其余四步都是直观的计算：初始化只是给一组初值，前向传播是一层层代入公式，损失函数是把预测值和真实值套进一个公式得到一个数，更新参数则是把梯度乘上学习率减掉。它们都不需要额外的技巧。

现在仅缺少每个参数需要调整的梯度的计算方法，反向传播就是用来解决这个问题的。

误差虽然只在输出层显现，但它正是沿着刚才前向传播那条路一层层传过来才形成的。既然如此，只要沿着同一条路倒着走回去，就能把误差再传回去，从而得到每个参数的梯度。

反向传播的原理

反向传播就是通过计算每个权重对结果的影响大小来进行权重更新的，也就是权重对错误结果的贡献越大，调整幅度就要越大。这个"影响大小"在数学上就是损失函数对每个参数的偏导数（梯度）。

具体做法仍是从输出层开始往输入层回传：先算出损失对最后一层输出的梯度，再逐层往前推，每到一层就把该层参数的梯度 ∂L/∂W^(l) 和 ∂L/∂b^(l) 记下来。

链式法则

反向传播能成立，靠的就是链式求导法则。

对一条标量链 L ← a ← z ← w，想知道 w 变一点会让 L 变多少，就把三段的导数连乘起来：

`1`	`∂L/∂w = ∂L/∂a · ∂a/∂z · ∂z/∂w`

代入该神经元：z = wx + b，a = σ(z)，L = ½(y − a)²：

∂L/∂a = (a − y)
∂a/∂z = σ'(z)
∂z/∂w = x
∂L/∂w = (a − y) · σ'(z) · x

三层连乘正好对应"损失函数 → 激活函数 → 加权求和"这条路径，网络更深时这条链只是更长，本质不变。

把网络看成计算图时，每个节点在反向时只做两件事：接收上游传回来的梯度，乘上自己这个运算的局部导数，再往下传：

加法节点（z = wx + b）：上游梯度原样分给各条支路；
乘法节点（w 乘 x）：对 w 的梯度 = 上游梯度 × x，对 x 的梯度 = 上游梯度 × w，两者只是交换乘数；
激活节点（a = σ(z)）：上游梯度 × σ’(z)。

对于多层网络，损失L需要对每一层的每一个权重参数 w 进行求导，看似计算冗杂，但大部分导数属于局部导数，可以并行计算：如每个神经元的∂a/∂z，∂z/∂w，∂z/∂x(x为前层某个神经元传入的值)等均不依赖损失L，仅有权重参数梯度∂L/∂w需要最后一层的梯度信号∂L/∂a沿计算图逐层反向传导计算得到。

举例计算

下面举例计算倒数第三层的权重梯度：

1.前向传播：算出每一层每个神经元的线性预激活 z 、神经元输出 (j/k/l/m/n/v/u)，缓存所有中间值。

2.预计算（可并行）算出所有神经元的局部导数：
∂a/∂z（激活函数导数）
∂z/∂w（预激活对权重的偏导）
∂z/∂x（预激活对输入的偏导）

3.反向传播开始，先算出L对最后一层输出的梯度，即把输出代入损失函数的导数：
∂L/∂u（如均方误差下 ∂L/∂u = u − y）

4.再算出L对倒数第二层输出的梯度：
如：∂L/∂j（L对j神经元输出的偏导）= ∂L/∂u · ∂u/∂z · ∂z/∂j（这里的z是对应u神经元的预激活）
同理算出：∂L/∂k、∂L/∂l、∂L/∂m、∂L/∂n

5.再算出L对倒数第三层输出的梯度：
∂L/∂v = ∂L/∂j · ∂j/∂z · ∂z/∂v
        + ∂L/∂k · ∂k/∂z · ∂z/∂v
        + ∂L/∂l · ∂l/∂z · ∂z/∂v
        + ∂L/∂m · ∂m/∂z · ∂z/∂v
        + ∂L/∂n · ∂n/∂z · ∂z/∂v
（这里的z是对应j、k、l、m、n神经元的预激活）

6.这时就能算出L对倒数第三层权重w的梯度：
∂L/∂w = ∂L/∂v · ∂v/∂z · ∂z/∂w
（这里的z是对应v神经元的预激活）

小结

反向传播求的是损失对每个参数的梯度，贡献越大的参数调整幅度越大；
一轮完整的流程是：初始化参数 → 前向传播 → 计算损失 → 反向传播 → 更新参数，然后反复循环；
反向传播的数学基础是链式法则，梯度沿计算图从后往前传，每个节点只需乘上自己的局部导数；
反向传播只负责算出梯度，真正改变参数的是梯度下降那一步。

深度学习笔记-关键概念

Fri, 18 Sep 2026 00:00:00 +0000

关键概念

这篇整理几个后面会反复出现的名词：前向传播、激活函数、损失函数、梯度下降、学习率。它们不是某个具体模型，而是所有神经网络训练时都要用到的共同零件。

一个神经网络的训练过程，本质上就是这五样东西的配合：先前向传播算出预测值，用损失函数衡量它和正确答案差多少，再靠梯度下降把参数往误差减小的方向挪一点，每次挪多大由学习率决定；而激活函数决定了每一层的输出长什么样，也决定了整个网络能不能表达非线性。

前向传播

数据从输入层进入，沿着网络逐层往后算，直到输出层给出预测值，这个过程就叫前向传播（Forward Propagation）。(简单理解就是将上一层的输出作为下一层的输入，并计算下一层的输出，一直到运算到输出层为止。)

沿用多层感知机笔记的记号，i 表示层号：

第 i 层的净输入：z_(i) = W_(i)a_(i−1) + b_(i)
第 i 层的输出：a_(i) = σ(z_(i))
输入层 a₍₀₎ = x，最后一层的输出就是预测值 ŷ

需要强调两点：

前向传播不更新任何参数，它只是拿着当前这组参数做一次预测，看结果怎么样；
但每一层的 z 和 a 必须保存下来，因为反向传播算梯度时要直接复用这些中间结果，重算一遍代价太大。

激活函数

激活函数套在每一层"加权求和之后、往下传递之前"，负责把 z_(i) 变成该层的输出 a_(i)。

它最重要的作用是引入非线性。如果去掉激活函数、每层只做线性变换，那么无论堆多少层，最终都等价于一层线性模型（推导见多层感知机笔记），网络就失去了拟合复杂函数的能力。

常见选择：

阶跃函数：最朴素的激活函数，感知机用的就是它；但处处导数为 0、在 0 处不可导，梯度传不下去，因此只能用于单层模型。

ReLU：正区间导数为 1、负区间为 0，计算极快且不饱和，是目前隐藏层的默认选择；缺点是可能出现"死亡 ReLU"（神经元永久输出 0）。

Sigmoid：把输出压到 (0,1)，适合二分类的输出层；缺点是两端饱和后梯度趋近 0，容易梯度消失，且输出非零均值。

Tanh：把输出压到 (−1,1)，零均值，隐藏层比 Sigmoid 好用一些；同样存在梯度消失。

Softmax：不属于单个神经元的激活函数，而是作用在输出层的一整组神经元上，把它们的输出归一化成总和为 1 的概率，专用于多分类的输出层。

一句话总结：隐藏层默认用 ReLU，二分类输出用 Sigmoid，多分类输出用 Softmax。

损失函数

损失函数（Loss Function）用来衡量预测值 ŷ 和真实标签 y 之间的差距，输出一个标量 L 代表损失。

它是训练的目标：模型训练得好不好，就看损失能不能降下来。常见形式：

回归任务：均方误差 L = ½ ‖ŷ − y‖<sup>2</sup>
二分类任务：交叉熵，配合 Sigmoid 输出使用
多分类任务：交叉熵，配合 Softmax 输出使用

损失函数有两个要求：一是能真实反映"错得多离谱"，二是必须可导——因为后面要根据它对每个参数求偏导，参数才知道该往哪调。这也是为什么要选用 Sigmoid、ReLU 而不是阶跃函数的原因之一。

在整个训练流程里，损失函数正好卡在中间：前向传播算出 ŷ，损失函数把它变成一个可以求导的标量 L，反向传播再由这个 L 出发往回算梯度（反向传播）。

梯度下降

有了损失，接下来要让损失 L 变小。梯度（偏导数组成的向量）指向的是 L 上升最快的方向，那么每个参数的更新方向就很自然了——沿着梯度的反方向走：

1
2

W ← W − η · ∂L/∂W
b ← b − η · ∂L/∂b

这就是梯度下降（Gradient Descent），可以想象成站在山坡上蒙着眼往下山走：每次用脚探一下周围哪个方向最陡（求梯度），然后朝最陡的下坡方向迈一小步（更新参数），重复若干次就到了山谷附近。

按每次用多少样本来算梯度，分成三种：

批量梯度下降：用全部训练样本算一次梯度再更新，方向稳但慢；
随机梯度下降（SGD）：每次只用一个样本，更新快但抖动大；
小批量梯度下降：每次用一小批样本（如 32、64 个），兼顾稳定与速度，实际最常用。

需要注意的是，梯度下降拿到的是当前点的局部信息，它不保证走到全局最低点：遇到局部极小值或鞍点都可能卡住或减速。

学习率

学习率（Learning Rate）η 就是上面公式里那个"步长"，控制每次参数更新的幅度。

它是最重要也最容易调错的超参数：

太大：一步跨过头，损失在最低点附近来回震荡，甚至越更新越大直接发散；
太小：每步都几乎没有进展，收敛极慢，还容易停在半路上；
比较稳妥的做法是让学习率随训练衰减：前期大步靠近，后期小步微调。也可以交给 Adam 这类自适应优化器，让每个参数各自拥有动态调整的步长。

小结

前向传播：拿着当前参数算出预测值，并把每层的中间结果存下来备用；
激活函数：给线性变换加非线性，否则多层网络等价于单层；隐藏层默认 ReLU，输出层按任务选 Sigmoid 或 Softmax；
损失函数：量化预测与真实的差距，必须可导，是前向与反向之间的分界点；
梯度下降：沿梯度反方向更新参数来减小损失，实践中多用小批量；
学习率：控制每一步走多大，太大发散、太慢卡住，通常随训练衰减。

深度学习笔记2-多层感知机

Thu, 17 Sep 2026 00:00:00 +0000

多层感知机

我在感知机笔记中，记录了单层感知机，它是二分类的线性分类模型，在数据线性可分时，由 Novikoff 定理能够保证在有限步中能做到完全收敛。但无法解决 XOR 等线性不可分问题，这些问题需要多层感知机。

引入隐藏层

异或电路如下图所示：

可以看到异或是由两次任务来完成：

在第一部分输入后，输入信号输入到第二部分进行与非和或运算。
完成两个运算后，同时输入到第三部分完成与的运算从而做到异或。

把它转换成感知机表示如下：

可以分析出任务的完成方式:

在输入层接收两个输入x₁，x₂。
在隐藏层可以做两个并行的感知机，一个做OR运算，一个做NAND运算。
在输出层将两个隐藏层的运算输出的结果做AND运算，从而实现异或逻辑。

通过引入隐藏层，大量感知机的组合可以完成各种各样的复杂任务

多层感知机

MLP是层级化、全连接的神经网络结构，层与层之间无跳过、无循环，相邻层神经元之间全连接（相邻层的任意两个神经元都有连接），整体分为3类核心层（输入层->隐藏层->输出层），结构如下：

输入层：

仅负责接收原始数据/特征，不做任何计算，神经元数量 = 数据的特征维度（如输入是 28×28 的图片，展平后神经元数为784）。
无激活函数，仅传递数据。

隐藏层

MLP 的核心层，可设置1层或多层（多层时称为深度多层感知机），层数/神经元数是关键超参数。
同一层神经元并行提取不同的特征或规则。
后续层的输入为前一层的输出，逐层进行抽象构造出更有效的特征。

输出层（最终预测结果，神经元数量由任务类型决定）

二分类任务：1个神经元（输出0/1）
多分类任务：神经元数 = 类别数（如MNIST手写数字分类，设10个神经元）；
回归任务：1个神经元（输出连续值）

多层线性变换

多层感知机如果在每一层只做线性变换，那么无论多少层隐藏层，MLP 最终等价于单层线性模型。

例如：

第一层输出h = W₁x + b₁。
第二层输出y = W₂h + b₂。代入第一层输出得到y = W₂(W₁x + b₁) + b₂。

可以看出来仍然是一个一阶线性函数，所以无论堆叠多少层感知机仍然是线性模型。

引入激活函数

在每一层神经元加权求和的输出后，套一个非线性函数再输出，该非线性函数称为激活函数（Activation Function）。

单层感知机中，激活函数为阶跃函数(Step Function)如下图。

一些常用的激活函数

ReLU（Rectified Linear Unit） ✅ 最常用：优点：计算快、缓解梯度消失，适合隐藏层；缺点：存在“死亡ReLU”问题。

Sigmoid：优点：输出映射到(0,1)，适合二分类输出层；缺点：梯度消失、输出非零均值。

Tanh：优点：输出映射到(-1,1)，零均值；缺点：仍存在梯度消失。

Softmax ✅ 多分类输出层专用，将多个神经元的输出归一化到(0,1)，且总和为1，代表样本属于各类别的概率。

万能逼近定理

万能逼近定理（Universal Approximation Theorem, UAT）：一个含有足够多神经元的单隐藏层MLP，可以以任意精度逼近任意连续函数。

意味着MLP在理论上具备表达任意连续函数的能力
但实际中，定理只保证存在这样一组参数，不保证梯度下降能学到；且所需神经元数可能随精度指数级增长。

多层感知机的数学表达

由于每一层感知机神经元的输出结果都是上一层输入的组合运算，所以最终结果在数学计算上可以用函数的嵌套来进行表示，即：

层函数：h_i(u)= σ_i(W_iu + b_i) （u 为上一层的输出，i 为层号）
输出函数：output = h_n(h_n-1(…h₂(h₁(X))))，其中 h₁(X) 即输入层到第一层的结果，逐层向后传递。

多层感知机遇到的问题

感知机的学习规则只适用于单层网络
隐藏层神经元需要调整的梯度无从得知
下一次会写反向传播算法的笔记，反向传播算法的作用是得到各个神经元参数需要修改的梯度

可编程时钟分频器

Tue, 15 Sep 2026 00:00:00 +0000

可编程时钟分频器

固定分频器只能产生一个预先写死的频率；可编程（动态）时钟分频器把分频比做成输入，允许电路在运行过程中随时改变输出时钟频率，并且要求切换过程不产生毛刺、不出现畸形脉冲。

本文给出一个基于"半周期翻转法"的 Verilog 实现：输入系统时钟与半周期计数值，输出 50% 占空比方波，支持运行中动态切换分频比。

分频原理

利用计数器进行分频：用被分频时钟驱动计数器计数，数到设定值就改变输出电平，从而得到按比例降低的频率。下面先讲清分频的通用本质，再说明本文采用的半周期翻转法。

分频的本质：用计数器"数"出更慢的时钟

时钟分频要解决的问题只有一件：从一个固定的高频时钟 f_clk 得到一个更低的频率 f_out。实现它的基本手段也只有一个——计数：用一个计数器数输入时钟的周期，每数满 N 个输入周期就产生一个输出周期。这个 N 称为分频比（分频系数）：

`1`	`N = f_clk / f_out f_out = f_clk / N`

于是"分频"就归结为两个问题：数到几（决定频率），以及数到之后做什么（决定占空比）。对"数到之后做什么"的不同选择，区分出了两种最基本的整数分频方法：翻转法和计数取段法。

半周期翻转法：天然 50% 占空比

设系统时钟频率为 f_clk，期望输出频率为 f_out。一个完整的输出周期（高电平部分+低电平部分）需要 f_clk / f_out 个系统时钟；因为输出是 50% 占空比的方波，所以半个周期只需要计数 half = f_clk / (2 * f_out) 个系统时钟。让计数器每过 half 个时钟就把输出翻转一次，就能得到 50% 占空比的 f_out 方波——这就是半周期翻转法。

以 half = 3（即 6 分频，f_out = f_clk / 6）为例，各信号的关系如下，每个格子代表一个系统时钟周期，计数器从 0 数到 2 后归零并翻转输出：

上升沿触发
cnt      0   1   2   0   1   2   0   1   2   0   1   2
sys_clk |‾|_|‾|_|‾|_|‾|_|‾|_|‾|_|‾|_|‾|_|‾|_|‾|_|‾|_|‾|_
                    ↑           ↑           ↑
sys_div ____________‾‾‾‾‾‾‾‾‾‾‾‾____________‾‾‾‾‾‾‾‾‾‾‾‾
        |← half=3 →|← half=3 →|

从波形可以看出两件事：

占空比恒为 50%：高、低电平各占 half 个完整的系统时钟周期，长度完全相等，与 half 取多少无关；
输出时钟周期 = 2 × half 个系统时钟，即 f_out = f_clk / (2 × half)，分频比 N = 2 × half。

为什么端口直接给"半周期计数值"

模块对外暴露的是半周期计数值 half_cnt，而不是完整分频比 N，两者的关系是 N = 2 × half_cnt。这样设计有三个原因：

省掉除法器。若端口给完整分频比 N，模块内部还要算 half = N / 2（或 f_clk / f_out），变量除法会综合出面积和时序开销都不小的除法逻辑。把除法搬到软件端（或配置寄存器写入前）预计算好，模块内部只剩比较和加法，资源占用大幅下降。
保证 50% 占空比。翻转法要求高、低电平各占相同的时钟数。如果端口传入的是完整分频比 N，当 N 为奇数时无法把 N 均分成两个整数半周期，占空比必然偏离 50%；而直接给半周期值天然避免了这个问题。
语义直观。half_cnt 就是"计到多少翻转一次"，与模块内部行为一一对应。

只支持偶数分频比

f_out = f_clk / (2 × half_cnt) 说明本设计能实现的分频比只有 2, 4, 6, … 这些偶数。例如 100MHz 输入时，能得到 50MHz（half = 1）、25MHz（half = 2）、16.67MHz（half = 3）……却无法产生 f_clk / 3 ≈ 33.3MHz 这类奇数分频比。

这是"半周期翻转 + 恒 50% 占空比"的固有取舍：一次翻转只能把输出周期二等分，而奇数个时钟无法均分成两个长度相等的整数半周期。若确实需要奇数分频，通常有三条路，代价各不相同：

方法	50% 占空比	说明
计数取段法：高、低电平各数固定的时钟数	否，N 为奇数时两边相差 1 个时钟	只用上升沿，结构最简单；N 越大占空比越接近 50%
双沿法：上升沿、下降沿各产生一路再组合（相位相或）	是	需要 `negedge` 采样，组合输出容易带毛刺，且结果依赖输入时钟自身的占空比
小数分频 / 相位累加器（DDS）	是	电路最复杂，输出存在周期性抖动

本设计相当于取了第一条路的对称特例：既然端口直接给半周期值，“高、低各数 half 个时钟"就退化成"数到 half 就翻转”，结构最简单、占空比最准，代价是分频比只能是偶数。

频率范围

输出频率在两头各有一个约束，两个约束都来自计数器本身：

上限：翻转法要求一个半周期至少包含 1 个完整的系统时钟，故 half_cnt >= 1，最高输出频率为 f_clk / 2（100MHz 输入时为 50MHz）。这也是单沿计数能达到的极限——再快就只能直接引用 sys_clk，或者改用双沿。
下限：计数器位宽为 HALF_CNT_WIDTH = W 时，能表达的最大计数值是 2^W − 1，所以最低输出频率为 f_clk / (2 × HALF_CNT_MAX)，而 HALF_CNT_MAX 默认就等于 2^W − 1。

例如 100MHz 输入、HALF_CNT_MAX 取默认满量程（W = 27）时，最低输出约 0.37Hz；把源码里的 HALF_CNT_MAX 改为 50_000_000，最低输出就是 1Hz。反过来看，如果只需要支持到 1Hz，W = 26 就够用，还能省下几位寄存器。

关于精度

half_cnt 是整数，因此输出频率只能取 f_clk / (2 × half_cnt) 这一系列离散值。当期望频率无法整除时（例如 100MHz 下想要 3MHz，理想半周期 half = 100 / 6 ≈ 16.67），只能在软件端取整为 16，实际得到 3.125MHz，存在约 4% 的偏差。

这个量化误差可以估算：设理想半周期为 H、取整后的整数为 h，则相对误差为

`1`	`\|f_out' − f_out\| / f_out = \|H − h\| / h`

截断取整时 |H − h| < 1，所以相对误差小于 1 / half_cnt：半周期计数值越大，误差越小。本例 h = 16，误差上界约 6.3%，实测约 4.2%。

结论是：输出频率越接近 f_clk / 2，精度越差。half_cnt = 2 附近只有 50MHz（half = 1）和 25MHz（half = 2）两档，中间的 40MHz 根本取不到；而当 half_cnt 到了几百量级，相邻两档的间隔已经小到可以忽略。若应用对频率精度要求高，建议直接调用ip核。

本文设计目标

输入 sys_clk（如 100MHz）与低有效异步复位 sys_rst_n；
通过输入端口 half_cnt 直接给定分频参数（半周期计数值），模块内部不做除法；
输出 sys_div 为 50% 占空比方波；
运行中改变 half_cnt 时，输出无毛刺，不出现被截断的短脉冲；
对分频参数做上下限保护：下限避免为 0 导致的非法输出，上限避免意外调节输出频率过低导致卡死。

参数与常量定义

参数	默认值	说明
`HALF_CNT_WIDTH`	27	半周期计数值位宽，决定可支持的最低输出频率

模块内部还有三个与端口同宽的局部常量（localparam），只能通过修改源码调整：

常量	值	说明
`HALF_CNT_MAX`	`{HALF_CNT_WIDTH{1'b1}}`（满量程）	半周期计数值上限，用于限制最低输出频率
`HALF_CNT_ZERO`	`{HALF_CNT_WIDTH{1'b0}}`	位宽与 `half_cnt` 一致的常量 0
`HALF_CNT_ONE`	`{{(HALF_CNT_WIDTH-1){1'b0}}, 1'b1}`	位宽与 `half_cnt` 一致的常量 1

HALF_CNT_MAX 默认取位宽满量程，也就是用尽端口能表达的全部范围；把它改小即可抬高最低输出频率（例如希望输出不低于 1Hz，令 HALF_CNT_MAX = f_clk / 2）。它被定义为局部常量而不是参数，好处是位宽始终与 HALF_CNT_WIDTH 自洽，也不会被上层实例化时误覆盖；代价是无法按实例定制，需要按项目直接改源码，或者把它改回 parameter 以支持实例化配置。

HALF_CNT_ZERO / HALF_CNT_ONE 用来替代 0、1 这类裸字面量，这样复位值、比较值和加减运算的操作数都带着明确的位宽，不依赖隐式零扩展。这里刻意没有用 HALF_CNT_WIDTH'd0 这种"以参数作 size"的字面量形式——部分工具（如 Vivado）不接受参数出现在字面量的位宽位置，而位拼接是标准且各工具通用的写法。

端口定义

信号	方向	位宽	说明
`sys_clk`	input	1	系统时钟
`sys_rst_n`	input	1	异步复位，低有效
`half_cnt`	input	`HALF_CNT_WIDTH`	半周期计数值：一个输出周期 = `2 × half_cnt` 个系统时钟
`sys_div`	output	1	分频输出，50% 占空比

输出频率与端口值的关系为：

`1`	`f_out = f_clk / (2 × half_cnt)`

half_cnt 的取值被夹在 [1, HALF_CNT_MAX] 之间，输出频率的上下限由位宽 HALF_CNT_WIDTH 与上限常量共同决定，推导见 §分频原理的"频率范围"一节。

Verilog 实现

module clk_div#(
    parameter HALF_CNT_WIDTH = 27      // 半周期计数值位宽，决定可支持的最低输出频率
)(
    input sys_clk,
    input sys_rst_n,
    input [HALF_CNT_WIDTH-1:0] half_cnt,  // 半周期计数值：输出分频时钟周期 = 2*half_cnt 个系统时钟
    output reg sys_div
    );

// 模块内部常量：位宽与 half_cnt 一致，用位拼接表示，兼顾显式位宽与工具兼容性
localparam [HALF_CNT_WIDTH-1:0] HALF_CNT_MAX  = {HALF_CNT_WIDTH{1'b1}};              // 半周期计数值上限，限制最低输出频率
localparam [HALF_CNT_WIDTH-1:0] HALF_CNT_ZERO = {HALF_CNT_WIDTH{1'b0}};              // 半周期计数值的常量0
localparam [HALF_CNT_WIDTH-1:0] HALF_CNT_ONE  = {{(HALF_CNT_WIDTH-1){1'b0}}, 1'b1};  // 半周期计数值的常量1

reg [HALF_CNT_WIDTH-1:0] cnt;             // 半周期计数器
reg [HALF_CNT_WIDTH-1:0] cnt_term;        // 当前生效的计数终值（半周期计数值-1）
reg [HALF_CNT_WIDTH-1:0] half_cnt_r;      // 当前生效的半周期计数值
reg [HALF_CNT_WIDTH-1:0] half_cnt_meta;   // 输入同步器第一级
reg [HALF_CNT_WIDTH-1:0] half_cnt_sync;   // 输入同步器第二级（同步后的目标值）
reg [HALF_CNT_WIDTH-1:0] half_cnt_eff;    // 经上下限保护后的目标半周期计数值
reg [HALF_CNT_WIDTH-1:0] half_cnt_latch;  // req置位时寄存的目标值，装载边界使用
wire change;                              // 半周期计数值发生改变
reg change_r;                             // change延迟一拍，连续两拍都有变化请求才锁存
reg         req;                          // 请求锁存

// 两级同步器：隔离异步输入，抑制亚稳态向后级传播
always@(posedge sys_clk or negedge sys_rst_n) begin
    if(!sys_rst_n) begin
        half_cnt_meta <= HALF_CNT_ZERO;
        half_cnt_sync <= HALF_CNT_ZERO;
    end
    else begin
        half_cnt_meta <= half_cnt;        // 第一级：先打一拍
        half_cnt_sync <= half_cnt_meta;   // 第二级：输出同步后的稳定值
    end
end

// 上下限保护：下限为1，对应最高输出频率 sys_clk的频率/2；上限为HALF_CNT_MAX，限制最低输出频率
always @(*) begin
    half_cnt_eff = half_cnt_sync;                // 默认赋值：先给默认值，避免产生锁存器
    if(half_cnt_sync == HALF_CNT_ZERO) begin
        half_cnt_eff = HALF_CNT_ONE;             // 下限保护：半周期计数值不能小于1
    end
    else if(half_cnt_sync > HALF_CNT_MAX) begin
        half_cnt_eff = HALF_CNT_MAX;             // 上限保护：超过最大值时钳位
    end
end

assign change = half_cnt_r != half_cnt_eff;    // 目标值有无变化：有变化才请求更新
always@(posedge sys_clk or negedge sys_rst_n) begin
    if(!sys_rst_n) begin
        cnt <= HALF_CNT_ZERO;
        sys_div <= 1'b0;
        half_cnt_r <= HALF_CNT_ONE;
        cnt_term <= HALF_CNT_ZERO;
        half_cnt_latch <= HALF_CNT_ONE;
        change_r <= 1'b0;
        req <= 1'b0;
    end
    else begin
        change_r <= change;

        // 连续两拍都检测到变化请求：锁存req（脉冲转电平），并寄存当拍已钳位的目标值
        if(!req && change && change_r) begin
            half_cnt_latch <= half_cnt_eff;   // 固定目标值：装载边界不再采样组合逻辑
            req <= 1'b1;
        end

        if(cnt < cnt_term) begin // 当前半周期未计满
            cnt <= cnt + HALF_CNT_ONE;
        end
        else begin // 半周期计满：翻转输出，并在半周期边界更新分频比
            cnt <= HALF_CNT_ZERO;
            sys_div <= ~sys_div;
            if(req) begin // 用 req 置位时寄存的目标值装载，不采样组合逻辑
                half_cnt_r <= half_cnt_latch;
                cnt_term <= half_cnt_latch - HALF_CNT_ONE;
                req <= 1'b0;
            end
        end
    end
end

endmodule

关键实现点

1. 输入同步：两级同步器 + 一拍确认

half_cnt 若来自其它时钟域，直接使用会把亚稳态引入本模块，所以先经过 half_cnt_meta、half_cnt_sync 两级触发器同步。第一级负责"隔离"（即使采到亚稳态，也有一个周期的恢复时间），第二级输出即可认为稳定。

需要额外注意：两级同步器只能保证每个 bit 不产生亚稳态，不能保证多位向量的各个 bit 同时更新。half_cnt 是 HALF_CNT_WIDTH 位（默认 27 位）的向量，在切换瞬间同步器输出的第一拍可能出现"部分 bit 已是新值、部分还是旧值"的混合值。因此代码在同步之后又保留了 change_r 做一拍确认（change && change_r）：要求同步后的目标值连续两拍都不同于当前生效值，才认为输入真正稳定并置位 req，从而避开那拍混合值；置位的同时会把这份已确认的值寄存到 half_cnt_latch（见"边界装载"一节）。

2. 分频参数的上下限保护与默认赋值

组合逻辑采用"先默认、后覆盖"的写法：

half_cnt_eff = half_cnt_sync;                // 默认赋值
if(half_cnt_sync == HALF_CNT_ZERO) begin
    half_cnt_eff = HALF_CNT_ONE;             // 下限：不能小于1
end
else if(half_cnt_sync > HALF_CNT_MAX) begin
    half_cnt_eff = HALF_CNT_MAX;             // 上限：钳位到最大值
end

好处是任何情况下 half_cnt_eff 都有确定值（不会因遗漏分支而综合出锁存器），而且后续再增加保护条件时只需追加 if，不必改动原有分支。

下限保护取 1，对应最高输出 f_clk / 2（100MHz 输入即 50MHz）。上限用常量 HALF_CNT_MAX 表达，用来限制最低输出频率。

这里有一个容易混淆的点：上限约束的目的不是防溢出。端口 half_cnt 本身就是 HALF_CNT_WIDTH 位，数值天然不会超过 2^W − 1；计数器 cnt 也够宽，最大只计到 cnt_term = half_cnt − 1 ≤ 2^W − 2。因此把 HALF_CNT_MAX 保持默认满量程（{HALF_CNT_WIDTH{1'b1}}）时，判断式恒为假，综合器会直接把这段逻辑优化掉——写了等于没写。它默认取满量程的意义在于提供一个可修改的"业务上限"接口：需要抬高最低输出频率时改小这个常量即可，例如改为 50_000_000（100MHz 输入）就保证输出不低于 1Hz。

3. 计数终值 `cnt_term`：把减法移出计数路径

如果直接写 if(cnt < half_cnt_r - HALF_CNT_ONE)，那么每个时钟周期都要经过一条"寄存器 half_cnt_r → 减法器 → 比较器 → cnt 的 D 端"的组合路径，减法器一直挂在计数路径上。

改进做法是用一个寄存器保存计数终值：

1
2
3

cnt_term  <= half_cnt_latch - HALF_CNT_ONE;  // 只在切换（半周期边界）时计算一次
...
if(cnt < cnt_term) begin           // 每周期只做一次比较

减法只在分频比更新时执行一次，计数路径上只剩比较器，逻辑更短、时序更宽松，意图也更清晰：cnt_term 就是"这个半周期最后计到几"。

4. 边界装载：无毛刺切换的核心

req 是电平型请求标志（脉冲转电平），置位后一直保持到新分频比真正装载，避免切换请求在等待期间丢失。置位的同时，把经过上下限保护的目标值寄存到 half_cnt_latch：

// 确认通过：寄存稳定值 + 锁存请求
if(!req && change && change_r) begin
    half_cnt_latch <= half_cnt_eff;   // 只在这一拍采样组合逻辑
    req <= 1'b1;
end

计数器只在当前半周期计满（cnt == cnt_term，即输出即将翻转的时刻）才用这份寄存值更新 half_cnt_r 与 cnt_term，并清除 req：

// 半周期边界：用寄存值装载
if(req) begin
    half_cnt_r <= half_cnt_latch;
    cnt_term  <= half_cnt_latch - HALF_CNT_ONE;
    req       <= 1'b0;
end

为什么不直接在装载那一拍采样 half_cnt_eff？ 它是纯组合信号（同步器 → 钳位比较器），而 req 的"两拍确认"只能保证置位那一刻的值是稳定的。若在等待装载期间输入再次变化，half_cnt_eff 会跟着变，装载沿就可能采到正在跳变、甚至各 bit 不一致的值。用 half_cnt_latch 把已确认的目标值固定下来，装载路径读到的始终是寄存器输出：既消除了这个窗口，也让装载路径少经过一级钳位比较器，时序更宽裕。

另外 change 比较的仍然是 half_cnt_r 与 half_cnt_eff：若等待期间输入又变了，装载完成后二者不相等，change 会再次拉高，req 清除后的下一拍就能重新请求，新的目标值不会被漏掉。

正因为新分频比只在半周期边界生效，输出的高、低电平不会被中途截断，也就不会产生毛刺或宽窄异常的脉冲。如果在计数中途直接改分频比，就会出现"半个周期被拉长或截断"，在波形上表现为一个明显偏窄或偏宽的脉冲。

需要留意这个方案的代价：新分频比不是立即生效，而是等当前半周期结束。从输入被确认（req 置位）到真正装载，最坏要等满一个半周期；低频时这段时间可能长达数百毫秒甚至秒级。对切换实时性有要求的场景，需要在这份"无毛刺"与响应速度之间权衡——若要立即生效，就只能在计数中途直接改 cnt_term，并接受输出出现一个宽窄异常的周期。

5. 占空比与复位

每次翻转的时间间隔都是固定的 cnt_term + 1 个时钟，高、低电平各占一半，因此输出始终是 50% 占空比（包括最高频的 f_clk / 2 情形）。

异步低有效复位把计数器 cnt、计数终值 cnt_term、输出 sys_div、change_r 与 req 全部清零，已生效值 half_cnt_r 与暂存值 half_cnt_latch 都复位为下限值 1，逻辑直接回到确定状态（cnt_term 复位为 0 恰好对应 half_cnt_r = 1 时的计数终值）。

仿真验证

TB 采用"半周期宽度白名单"自检：把当前允许的半周期宽度记录在案（切换期间允许新旧两种值，稳定后收紧为单一值），在每个 sys_div 翻转沿测量半周期宽度，出现白名单之外的宽度就报错。这样不必人眼看波形，就能直接证明切换过程没有产生被截断或拉长的脉冲；稳定段白名单只剩一个值，高、低半周期都必须等于它，也就同时验证了 50% 占空比。

`timescale 1ns / 1ps

module tb_clk_div;

    localparam     HALF_CNT_WIDTH = 27;
    localparam real T_CLK = 10.0;     // 100MHz 系统时钟周期（ns）
    localparam real EPS   = 0.01;     // 时间比较容差（ns）

    reg                       sys_clk   = 1'b0;
    reg                       sys_rst_n = 1'b0;
    reg  [HALF_CNT_WIDTH-1:0] half_cnt  = 5;
    wire                      sys_div;

    // TB 侧跟踪的"当前已生效半周期计数值"，与 DUT 的 half_cnt_r 同步（复位后为下限 1）
    integer cur_val = 1;

    // 半周期宽度白名单（ns）：切换期间给出旧值与新值两种，生效后收紧为单一值
    real exp_half_a = T_CLK;
    real exp_half_b = T_CLK;

    integer errors  = 0;              // 非法半周期计数
    integer checked = 0;              // 已检查的半周期数
    reg     armed   = 1'b0;           // 复位释放之后才开始测量
    reg     primed  = 1'b0;           // 复位后的第一个沿只建立时间基准

    real t_ref;                       // 上一次翻转沿时刻
    real width;                       // 实测半周期宽度

    clk_div #(
        .HALF_CNT_WIDTH(HALF_CNT_WIDTH)
    ) u_dut (
        .sys_clk  (sys_clk),
        .sys_rst_n(sys_rst_n),
        .half_cnt (half_cnt),
        .sys_div  (sys_div)
    );

    // 100MHz 系统时钟
    always #(T_CLK / 2.0) sys_clk = ~sys_clk;

    // 设置白名单：允许的半周期宽度（参数是 half_cnt 值，内部换算为 ns）
    task allow;
        input integer a;
        input integer b;
        begin
            exp_half_a = a * T_CLK;
            exp_half_b = b * T_CLK;
        end
    endtask

    // 已生效值变为 eff_val：更新当前值，并把白名单收紧为单一允许值
    task settled;
        input integer eff_val;
        begin
            cur_val    = eff_val;
            exp_half_a = eff_val * T_CLK;
            exp_half_b = eff_val * T_CLK;
        end
    endtask

    // 发起一次切换：在输出高电平中段写入新值，等待其生效后收紧白名单
    task switch_to;
        input integer new_val;
        begin
            @(posedge sys_div) #(T_CLK * 0.3);        // 刻意避开翻转沿：请求落在高电平中段
            allow(cur_val, new_val);                  // 切换期间旧值与新值都合法
            half_cnt = new_val;
            $display("[%0t ns] 切换 half_cnt %0d -> %0d，期望输出 %f MHz",
                     $realtime, cur_val, new_val, 1.0e3 / (2.0 * new_val * T_CLK));
            #(T_CLK * (8 + cur_val + 8 * new_val));   // 两拍同步 + 最坏一个旧半周期 + 八个新半周期
            settled(new_val);
        end
    endtask

    // 在当前（已收紧的）白名单下继续观察 n 个半周期
    task hold;
        input integer n;
        begin
            #(T_CLK * n * cur_val);
        end
    endtask

    // 每个翻转沿检查一次：实测半周期必须落在白名单内
    always @(posedge sys_div or negedge sys_div) begin
        if (armed) begin
            if (!primed) begin
                primed = 1'b1;                        // 复位后的第一个沿只建立基准
                t_ref  = $realtime;
            end
            else begin
                width   = $realtime - t_ref;
                t_ref   = $realtime;
                checked = checked + 1;
                if (!((width > exp_half_a - EPS && width < exp_half_a + EPS) ||
                      (width > exp_half_b - EPS && width < exp_half_b + EPS))) begin
                    errors = errors + 1;
                    $display("[ERROR] time = %0t ns: 半周期 = %f ns，期望 %f ns 或 %f ns",
                             $realtime, width, exp_half_a, exp_half_b);
                end
            end
        end
    end

    initial begin
        $display("=== clk_div 自检 TB：sys_clk = 100MHz ===");

        // 1) 复位释放后自动装载目标值 5（10MHz）
        half_cnt = 5;
        allow(1, 5);                                  // 复位后已生效值为 1，目标值为 5
        #(T_CLK * 20);
        @(negedge sys_clk) sys_rst_n = 1'b1;          // 与时钟相位对齐地释放复位
        armed = 1'b1;                                 // 释放复位之后才开始测量
        $display("[%0t ns] 释放复位，half_cnt = 5，期望输出 %f MHz", $realtime, 1.0e3 / (2.0 * 5 * T_CLK));
        #(T_CLK * (8 + 1 + 8 * 5));
        settled(5);
        hold(20);

        // 2) 切到 25（2MHz）：大跨度、多位同时变化
        switch_to(25);
        hold(20);

        // 3) 写入 0：下限保护应把半周期钳位为 1（50MHz）
        @(posedge sys_div) #(T_CLK * 0.3);
        allow(cur_val, 1);                            // 白名单按钳位后的 1 给出
        half_cnt = 0;
        $display("[%0t ns] 写入 half_cnt = 0，期望被钳位为 1（50MHz）", $realtime);
        #(T_CLK * (8 + cur_val + 8 * 1));
        settled(1);
        hold(200);

        // 4) 切到 2（25MHz）：相邻值切换
        switch_to(2);
        hold(100);

        if (errors == 0)
            $display("\n[PASS] 共检查 %0d 个半周期，未出现非法宽度（无截断、无拉长）", checked);
        else
            $display("\n[FAIL] 共发现 %0d 处非法半周期宽度", errors);

        $finish;
    end

endmodule

几点说明：

检查点在翻转沿上，看的是"相邻两次翻转的间隔"，所以白名单里出现第三种宽度，就意味着某个半周期被截断或拉长——这正是切换毛刺的波形特征。
复位释放后才置 armed 开始测量：复位期间 sys_div 会从不定态变 0，这个 x -> 0 在仿真中同样算一次 negedge，不屏蔽的话它会被当成第一个翻转沿，使首次测量就误报。
每次切换都先用 allow(旧值, 新值) 放宽白名单，生效后再用 settled() 收紧为单一值；switch_to() 把"等相位 → 写值 → 等生效 → 收紧"封装成一行调用，hold(n) 再观察 n 个已生效的半周期，保证检查不会长期处于放宽状态而形同虚设。
切换请求都安排在 @(posedge sys_div) 之后 0.3 × T_CLK 处，刻意落在输出高电平的中段，用来验证"当前半周期不会被截断"。
上限钳位（half_cnt 大于 HALF_CNT_MAX）无法在本 TB 中触发：HALF_CNT_MAX 是模块内 localparam 且默认为满量程，任何端口值都不会超限。要验证这条分支，需要先把源码里的 HALF_CNT_MAX 改小，再把白名单期望值改成钳位后的值。

综合与使用注意事项

多 bit 跨时钟域传输：两级同步器解决的是亚稳态，不是位偏斜。代码用"一拍确认 + 稳定值寄存"缓解了这个问题，前提是目标值在变化后会保持稳定；若 half_cnt 可能被连续高频改写，应改用握手（req/ack）或双口 RAM/FIFO 等标准 CDC 方案。
只支持偶数分频比：输出频率只能是 f_clk / (2 × half_cnt)，无法实现 f_clk / 3 这类奇数分频。需要奇分频时要在本模块之外另加双沿/相位组合逻辑。
位宽与上限的配合：HALF_CNT_WIDTH 按"最低输出频率"反推，满足 2^W − 1 ≥ f_clk / (2 × f_out_min)；若只想抬高最低频率而不想加位宽，把源码里的局部常量 HALF_CNT_MAX 调小即可（它是 localparam，实例化时无法覆盖，需要按实例配置就把它改回 parameter）。注意 HALF_CNT_MAX 至少要 ≥ 1，否则钳位结果退化为 0，反而会把半周期拉得极长。
复位初值的选择：half_cnt_r 复位为最小值 1，意味着复位释放后、真正装载目标值之前，输出会以 f_clk / 2 的高频翻转几拍。若下游对这几拍敏感，可以把复位值改成一个更温和的默认分频比，或在装载完成前把 sys_div 屏蔽（输出保持 0）。
分频时钟的使用：sys_div 是真实时钟，用它驱动大量逻辑会额外占用时钟资源并引入新的时钟域。在 FPGA 内更常见的做法是保留系统时钟，把分频结果当作**时钟使能（Clock Enable）**使用：低频逻辑每 N 个周期使能一次，从而避免门控时钟带来的时序与资源问题。分频器更适合用于驱动外设时钟引脚或低速接口的时钟输入。
端口语义：对外暴露的是半周期计数值，软件端（或配置逻辑）负责先算出 half_cnt = f_clk / (2 × f_out) 再写入，模块内部因此不含任何除法运算，资源与时序都更友好。

小结

采用"半周期翻转法"，输出天然为 50% 占空比；
分频比由端口 half_cnt 直接给定，模块内无除法器，运行中可动态切换；
输入经两级同步器 + 一拍确认处理，兼顾亚稳态与多 bit 位偏斜；
用 cnt_term 保存计数终值，把减法移出每周期的计数路径，只剩一次比较；
组合逻辑采用"先默认赋值、后覆盖"写法，结构清晰且不会综合出锁存器；
上下限保护：下限固定为 1（最高 f_clk / 2），上限由局部常量 HALF_CNT_MAX 给定（限制最低输出频率）；
确认通过后先把稳定值寄存为 half_cnt_latch，再由"请求锁存 + 半周期末装载"完成切换，保证无毛刺，代价是最坏要等满一个半周期才生效；
只能实现偶数分频比，且频率精度受整数分频限制，高精度或奇数分频需另寻方案。

深度学习笔记1-感知机

Thu, 10 Sep 2026 00:00:00 +0000

深度学习基础-感知机

感知机（perceptron）是二分类的线性分类模型，属于监督学习算法，也是神经网络与支持向量机的共同前身。

感知机起源于对生物神经元细胞的抽象建模，其工作原理与生物神经元细胞类似。（如下图）

生物神经元通过树突接收其他神经元轴突传递过来的信号；当累积信号强度超过激发阈值时，神经元经由自身轴突向外输出神经脉冲。
感知机仿照生物神经元机制，对多路输入信号做加权求和，再与阈值进行比较，最终输出 0 或 1。

感知机模型

感知机计算模型如图：

工作原理：

对输入进行加权求和，与阈值进行比较并输出；得到输出后与真实标签比较，若预测错误则按误差修正权重与偏置，反复迭代，直到所有训练样本都被正确分类（数据线性可分时）。

第一步：输入加权求和

接收一组信号 x₁, x₂, …, x_m，每一个 x_i 代表数据的一个特征。

每一个输入对应一个权重 w_i，代表该特征对最终结果的影响程度；图中还有一个恒为 1 的输入，其权重记为 w₀，也就是偏置 b(第二步介绍)。

将输入 x_i 与对应权重 w_i 相乘后求和，得到加权求和结果（净输入）：

`1`	`z = Σ xi · wi`

第二步：判断并输出

设定一个阈值 θ，该阈值用于划定分类的界限：加权求和的结果大于阈值时输出 1，否则输出 0。

令偏置 b = −θ，这样处理过后、与阈值的比较就变成了加入偏置和0进行比较，遮掩就能采用阶跃函数进行输出。判据就统一成了"加权求和加偏置后送入阶跃函数"的形式（即判断净输入 z 是否大于等于 0），如下图公式：

其中 z = Σ x_i · w_i + b，z = 0 落在边界上，约定输出 1。

第三步：错误修正

每做出一次预测，感知机就与正确答案进行对比：若预测正确则不做任何修改；若预测错误，则按下面规律进行权重调整：

符号释义：

w_i：第 i 个权重（w₀ 即偏置 b，对应恒为 1 的输入）；
η：学习率，控制每次修正的步长；
y：真实标签（0 或 1）；
ŷ：感知机预测输出（0 或 1）；
x_i：第 i 路输入。

因为 (y − ŷ) 只在预测错误时才非零，取值为 +1（漏报）或 −1（误报），所以该式只在误分类样本上生效：

y = 1、ŷ = 0 时，w_i ← w_i + η·x_i，把权重往"更容易输出 1"的方向推；
y = 0、ŷ = 1 时，w_i ← w_i − η·x_i，把权重往"更容易输出 0"的方向推。

若把偏置看作权重 w₀、把恒为 1 的输入看作 x₀ = 1，则上式同时覆盖了偏置更新 b ← b + η(y − ŷ)。

几何意义与收敛性

把权重与偏置看作一组参数，z = 0（即 w·x + b = 0）在特征空间中是一条直线，在高维下则是超平面，它把空间分成两侧，分别对应输出 0 与输出 1。所谓"训练"，就是不断旋转、平移这条分界线，直到所有训练样本都落在正确的一侧。

Novikoff 定理：若训练集线性可分且学习率 η > 0，感知机学习算法一定能在有限步内收敛，得到一个能把所有样本正确划分的超平面。

反之，如果数据线性不可分，权重会被反复修正而始终无法稳定下来，此时算法不保证收敛。

以与门（AND）为例：取 w₁ = w₂ = 1、b = −1.5，则只有输入 (1, 1) 时 z = 0.5 ≥ 0 输出 1，其余组合 z 均小于 0 输出 0，正好实现了与逻辑。

感知机的劣势

感知机只能解决线性可分的任务。以逻辑门为例：

与（AND）、或（OR）：样本线性可分，感知机可以学会（见上例）；
异或（XOR）：同一类别的点交错分布在直线两侧，无法用单个超平面分开，感知机无法解决。

XOR 问题的本质是它不属于线性可分函数，这正是单层感知机的根本局限。解决思路是引入隐藏层，把单层感知机堆叠为多层感知机（MLP）——借助多层的非线性变换去逼近任意复杂的决策边界，这也是后续深度神经网络的基本思路。

小结

感知机是二分类的线性模型：对输入加权求和并加上偏置，经阶跃函数输出 0 或 1；
学习规则是"误分类驱动"的误差修正：w_i ← w_i + η(y − ŷ)x_i，偏置同步更新；
只对误分类样本更新权值，预测正确时不做任何修改；
数据线性可分时，由 Novikoff 定理保证有限步收敛；
无法解决 XOR 等线性不可分问题，需要多层感知机。

RV32I单周期CPU

Tue, 08 Sep 2026 00:00:00 +0000

本文介绍单周期RV32I CPU的实现方式

在RV32I指令详解中展示了完整的指令集。本文基于一套可运行的 Verilog 代码，实现一个单周期（Single-Cycle）RV32I 处理器：每一条指令在一个完整时钟周期内完成「取指 → 译码 → 执行 → 访存 → 写回」全过程，因此不存在流水线冒险，也没有数据/控制冒险的问题。

下图为单周期数据通路结构，本项目的模块划分与此一一对应。所有源码均位于此处：

文件	模块	作用
`rtl/core_single_period.v`	core_single_period	顶层模块，组合所有数据通路
`rtl/pc.v`	pc	程序计数器（PC）
`rtl/imem.v`	imem	指令存储器（ROM）
`rtl/control.v`	control	控制单元（译码）
`rtl/regfile.v`	regfile	寄存器堆 x0~x31
`rtl/immgen.v`	immgen	立即数生成器
`rtl/alu.v`	alu	算术逻辑单元
`rtl/dmem.v`	dmem	数据存储器（RAM）
`rtl/program.hex`	—	覆盖全部 37 条 RV32I 指令的测试程序

数据通路整体结构

顶层模块 core_single_period 把各子模块连接起来，形成如下数据流：

PC ──▶ IMEM ──▶ (指令字段提取) ──▶ Control / RegFile / ImmGen
                                        │
                                        ▼
                                     ALU ──▶ DMEM
                                        │        │
                                        ▼        ▼
                                    wb_data 选择  ──▶ RegFile (写回)

首先从指令中提取各字段，供后续模块使用：

wire [6:0] opcode = instr[6:0];
wire [2:0] funct3 = instr[14:12];
wire [6:0] funct7 = instr[31:25];
wire [4:0] rs1    = instr[19:15];
wire [4:0] rs2    = instr[24:20];
wire [4:0] rd     = instr[11:7];

其中 opcode、funct3、funct7 送给控制单元译码，rs1/rs2 作为寄存器堆读地址，rd 作为写回地址。

模块功能介绍

PC —— 程序计数器

pc.v：32 位寄存器，同步复位（低电平有效）。下一拍将 pc_next 写入 pc，pc 作为指令存储器的地址。

module pc (
    input  wire        clk,
    input  wire        rst_n,       // 低电平复位
    input  wire [31:0] pc_next,
    output reg  [31:0] pc
);
    always @(posedge clk) begin
        if (!rst_n) pc <= 32'h0000_0000;
        else     pc <= pc_next;
    end
endmodule

IMEM —— 指令存储器

imem.v：组合逻辑 ROM，按字节寻址，可存 256 条指令（1 KB）。字对齐取指：将字节地址右移 2 位得到字索引。仿真时通过 $readmemh("program.hex", mem) 载入指令。

module imem #(parameter DEPTH = 256) (
    input  wire [31:0] addr,   // PC按字节寻址
    output wire [31:0] instr
);
    reg [31:0] mem [0:DEPTH-1];
    wire [7:0] word_idx = addr[9:2];

    initial $readmemh("program.hex", mem);
    assign instr = mem[word_idx];
endmodule

Control —— 控制单元

control.v：核心译码模块，根据 opcode（以及 funct3、funct7）生成所有控制信号。

信号	位宽	作用
`reg_write`	1	寄存器堆写使能
`alu_src`	1	ALU B 端选择：0=rs2，1=立即数
`mem_read`	1	数据存储器读使能
`mem_write`	1	数据存储器写使能
`branch`	1	是否是分支指令
`jump`	1	是否是跳转指令（JAL/JALR）
`wb_sel`	2	写回数据选择：00=ALU，01=MEM，10=PC+4，11=U型立即数
`alu_a_sel`	1	ALU A 端选择：0=rdata1，1=PC（AUIPC 用）
`alu_op`	4	选择 ALU 具体运算
`imm_sel`	3	立即数格式选择

各 opcode 译码结果如下：

opcode	指令	reg_write	alu_src	mem_read	mem_write	branch	jump	wb_sel	alu_a_sel	imm_sel
`0110011`	R-type	1	0	0	0	0	0	00	0	—
`0010011`	I-type	1	1	0	0	0	0	00	0	000
`0000011`	LOAD	1	1	1	0	0	0	01	0	000
`0100011`	STORE	0	1	0	1	0	0	—	0	001
`1100011`	BRANCH	0	0	0	0	1	0	—	0	010
`1101111`	JAL	1	0	0	0	0	1	10	0	100
`1100111`	JALR	1	1	0	0	0	1	10	0	000
`0110111`	LUI	1	0	0	0	0	0	11	0	011
`0010111`	AUIPC	1	1	0	0	0	0	00	1	011

R 型、算术 I 型指令需要 ALU 完成不同算术逻辑运算，因此译码时结合funct7、funct3产生 ALU 控制信号，选择对应的运算功能；

B 类分支指令 ALU 固定执行rs1−rs2比较操作，ALU 运算功能无需更改，funct3仅用于判别比较结果、决定是否发生分支跳转。

R-type 指令根据 {funct7[5], funct3} 进一步区分运算：

case({funct7[5],funct3})
    4'b0000: alu_op=4'b0000; // ADD
    4'b1000: alu_op=4'b0001; // SUB
    4'b0111: alu_op=4'b0010; // AND
    4'b0110: alu_op=4'b0011; // OR
    4'b0100: alu_op=4'b0100; // XOR
    4'b0010: alu_op=4'b0101; // SLT
    4'b0011: alu_op=4'b0110; // SLTU
    4'b0001: alu_op=4'b0111; // SLL
    4'b0101: alu_op=4'b1000; // SRL
    4'b1101: alu_op=4'b1001; // SRA
endcase

I-type指令根据 funct3 进一步区分运算：

case(funct3)
  3'h0: alu_op=4'b0000; // ADDI
  3'h7: alu_op=4'b0010; // ANDI
  3'h6: alu_op=4'b0011; // ORI
  3'h4: alu_op=4'b0100; // XORI
  3'h2: alu_op=4'b0101; // SLTI
  3'h3: alu_op=4'b0110; // SLTIU
  3'h1: alu_op=4'b0111; // SLLI
  3'h5: alu_op=(funct7[5])?4'b1001:4'b1000; // SRAI/SRLI
  default: alu_op=4'b0000;
endcase

B-type指令根据 funct3 进一步区分运算：

case(funct3)
    3'h0,3'h1: alu_op=4'b0001; // BEQ/BNE: SUB
    3'h4,3'h5: alu_op=4'b0101; // BLT/BGE: SLT
    3'h6,3'h7: alu_op=4'b0110; // BLTU/BGEU: SLTU
    default:   alu_op=4'b0001;
endcase end

RegFile —— 寄存器堆

regfile.v：32 × 32-bit，2 个异步读端口、1 个同步写端口。x0 恒为 0，写入 x0 被忽略，读取 x0 也始终返回 0。

module regfile (
    input  wire        clk,
    input  wire        we,
    input  wire [4:0]  waddr,
    input  wire [31:0] wdata,
    input  wire [4:0]  raddr1,
    output wire [31:0] rdata1,
    input  wire [4:0]  raddr2,
    output wire [31:0] rdata2
);
    reg [31:0] regs [0:31];
    integer i;
    initial for(i=0;i<32;i=i+1) regs[i]=32'b0;

    always @(posedge clk)
        if (we && waddr != 5'd0) regs[waddr] <= wdata;

    assign rdata1 = (raddr1 == 5'd0) ? 32'd0 : regs[raddr1];
    assign rdata2 = (raddr2 == 5'd0) ? 32'd0 : regs[raddr2];
endmodule

ImmGen —— 立即数生成器

immgen.v：按指令类型从指令中提取立即数并做符号扩展。imm_sel 的映射关系为 000=I, 001=S, 010=B, 011=U, 100=J。

always @(*) begin
    case (imm_sel)
        3'b000: imm = {{20{instr[31]}}, instr[31:20]};              // I
        3'b001: imm = {{20{instr[31]}}, instr[31:25], instr[11:7]}; // S
        3'b010: imm = {{19{instr[31]}}, instr[31], instr[7],
                       instr[30:25], instr[11:8], 1'b0};            // B
        3'b011: imm = {instr[31:12], 12'b0};                        // U
        3'b100: imm = {{11{instr[31]}}, instr[31], instr[19:12],
                       instr[20], instr[30:21], 1'b0};              // J
        default: imm = 32'd0;
    endcase
end

各格式立即数的位序对照（均以 instr[31] 符号位扩展）：

类型	立即数构成
I	`imm[11:0] = instr[31:20]`，符号扩展
S	`imm[11:5] = instr[31:25]`，`imm[4:0] = instr[11:7]`，符号扩展
B	`imm[12] = instr[31]`，`imm[11] = instr[7]`，`imm[10:5] = instr[30:25]`，`imm[4:1] = instr[11:8]`，`imm[0]=0`，符号扩展
U	`imm[31:12] = instr[31:12]`，低 12 位清零
J	`imm[20] = instr[31]`，`imm[19:12] = instr[19:12]`，`imm[11] = instr[20]`，`imm[10:1] = instr[30:21]`，`imm[0]=0`，符号扩展

ALU —— 算术逻辑单元

alu.v：支持 10 种运算，输出 result 和 zero（结果为 0 时置 1，供分支指令判断）。移位量取自 B 端低 5 位 shamt = b[4:0]。

alu_op	运算	说明
`0000`	`a + b`	ADD / ADDI
`0001`	`a - b`	SUB
`0010`	`a & b`	AND
`0011`	`a \| b`	OR
`0100`	`a ^ b`	XOR
`0101`	`$signed(a) < $signed(b)`	SLT（有符号）
`0110`	`a < b`	SLTU（无符号）
`0111`	`a << shamt`	SLL
`1000`	`a >> shamt`	SRL
`1001`	`$signed(a) >>> shamt`	SRA（算术右移）

module alu (
    input  wire [31:0] a,        // 操作数A (rs1)
    input  wire [31:0] b,        // 操作数B (rs2 or imm)
    input  wire [3:0]  alu_op,   // 选择操作
    output reg  [31:0] result,   // 计算结果
    output wire        zero      // 结果为0时置1(分支指令使用)
);
    wire [4:0] shamt = b[4:0];   // 移位的量为B的低5位

    always @(*) begin
        case (alu_op)
            4'b0000: result = a + b;                          // ADD
            4'b0001: result = a - b;                          // SUB
            4'b0010: result = a & b;                          // AND
            4'b0011: result = a | b;                          // OR
            4'b0100: result = a ^ b;                          // XOR
            4'b0101: result = ($signed(a) < $signed(b)) ? 32'd1 : 32'd0; // SLT
            4'b0110: result = (a < b)                 ? 32'd1 : 32'd0; // SLTU
            4'b0111: result = a << shamt;                     // SLL
            4'b1000: result = a >> shamt;                     // SRL
            4'b1001: result = $signed(a) >>> shamt;           // SRA
            default: result = 32'd0;
        endcase
    end

    assign zero = (result == 32'd0);
endmodule

DMEM —— 数据存储器

dmem.v：256 × 32-bit（1 KB），同步写、组合逻辑读，支持字节/半字/字三种读写宽度。

mem_read：读使能，来自控制单元（仅 load 指令为 1）；为 0 时 rdata 输出 0；
mem_width：00=字节, 01=半字, 10=字，来自 funct3[1:0]；
mem_sign：加载时是否符号扩展，来自 !funct3[2]（funct3[2]=0 表示有符号）；
字节内偏移 byte_off = addr[1:0]，用于确定字节/半字在字内的位置。

always @(posedge clk) begin
    if (we) begin
        case (mem_width)
            2'b00: begin  // SB
                case (byte_off)
                    2'b00: mem[word_idx][7:0]   <= wdata[7:0];
                    2'b01: mem[word_idx][15:8]  <= wdata[7:0];
                    2'b10: mem[word_idx][23:16] <= wdata[7:0];
                    2'b11: mem[word_idx][31:24] <= wdata[7:0];
                endcase
            end
            2'b01: begin  // SH
                if (byte_off[1]) mem[word_idx][31:16] <= wdata[15:0];
                else             mem[word_idx][15:0]  <= wdata[15:0];
            end
            2'b10: mem[word_idx] <= wdata;  // SW
        endcase
    end
end

读取端根据 mem_read、mem_width 和 mem_sign 生成 rdata（mem_read=0 时输出 0，避免非 load 指令读到无意义的数据）：

wire [31:0] rdata_b = mem_sign ? {{24{b[7]}}, b}        : {24'd0, b};    // LB / LBU
wire [31:0] rdata_h = mem_sign ? {{16{half[15]}}, half} : {16'd0, half}; // LH / LHU
wire [31:0] rdata_w = word;                                               // LW

// 读使能门控
assign rdata = mem_read ? ((mem_width == 2'b00) ? rdata_b :
                           (mem_width == 2'b01) ? rdata_h : rdata_w)
                        : 32'd0;

ALU 输入与写回数据选择

在顶层 core_single_period 中，ALU 的两个操作数由控制信号二选一：

1
2

wire [31:0] alu_a = alu_a_sel ? pc : rdata1;   // AUIPC 用 PC, 其余用 rs1
wire [31:0] alu_b = alu_src  ? imm : rdata2;   // I-type/load/store 用 imm, R-type 用 rs2

写回寄存器数据由 wb_sel 从四个来源中选择：

assign wb_data = (wb_sel == 2'b00) ? alu_result :
                 (wb_sel == 2'b01) ? mem_rdata  :
                 (wb_sel == 2'b10) ? (pc + 32'd4):
                                     imm;        // 2'b11: U-type immediate

分支 / 跳转 / 下一 PC

分支判断利用了 ALU 输出的 zero 和 result[0]。funct3[2:1] 区分相等比较与大小比较，funct3[0] 区分是否取反：

// funct3[2:1]: 00=BEQ/BNE(看zero), 10/11=BLT/BGE/BLTU/BGEU(看result[0])
// funct3[0]:   0=相等/小于时跳转, 1=不等/不小于时跳转
wire branch_cond = (funct3[2:1] == 2'b00) ? (funct3[0] ^ alu_zero)
                                          : (funct3[0] ^ alu_result[0]);
wire branch_taken = branch && branch_cond;

数据存储器地址与写使能：

1
2

wire [1:0] mem_width = funct3[1:0];   // 00=byte, 01=half, 10=word
wire       mem_sign  = !funct3[2];    // 0=unsigned, 1=signed

最后一拍根据 jump、alu_src、branch_taken 计算 pc_next：

wire [31:0] pc_plus_4 = pc + 32'd4;
wire [31:0] pc_branch = pc + imm;                 // B-type / J-type
wire [31:0] pc_jalr   = {alu_result[31:1], 1'b0}; // JALR 清最低位

// JAL: alu_src=0 → 用 PC+imm;  JALR: alu_src=1 → 用 ALU 结果
assign pc_next = jump      ? (alu_src ? pc_jalr : pc_branch) :
                 branch_taken ? pc_branch :
                 pc_plus_4;

测试程序

rtl/program.hex 是一条覆盖本处理器所支持的全部 37 条 RV32I 数据通路指令的测试程序（不含 FENCE/ECALL/EBREAK 等系统指令），包含 R-type ×10、I-type ALU ×9、LOAD ×5、STORE ×3、BRANCH ×6、JAL、JALR、LUI、AUIPC。由于是单周期实现，不存在冒险，可直接顺序验证。

部分测试片段：

// 初始化 x5=10, x6=7, x7=-1
00A00293   // PC=0x00  ADDI x5,  x0, 10   | x5  = 10
00700313   // PC=0x04  ADDI x6,  x0, 7    | x6  = 7
FFF00393   // PC=0x08  ADDI x7,  x0, -1   | x7  = -1 = 0xFFFFFFFF

// R-type
00628433   // PC=0x10  ADD  x8,  x5, x6   | x8  = 17
406284B3   // PC=0x14  SUB  x9,  x5, x6   | x9  = 3

// STORE / LOAD
008A2023   // PC=0x70  SW   x8,  0(x20)   | mem[0x50] = 40
000A2E83   // PC=0x7C  LW   x29, 0(x20)   | x29 = 40

// 停机：BEQ x0,x0,0 进入无限循环
00000063   // PC=0xFC  BEQ  x0,  x0,  0

完整测试程序细节可查看 rtl/program.hex 文件中的注释。

小结

通过这套单周期 RV32I 实现，可以看到处理器的基本骨架：取指（PC+IMEM）→ 译码（Control）→ 执行（ALU）→ 访存（DMEM）→ 写回（RegFile）。单周期实现结构简单、无冒险，但每个时钟周期都要走完最长路径（寄存器堆读出 → ALU → 访存 → 写回），时钟频率因此受限；实际处理器多在此基础上加入流水线，把执行拆成多个流水级来提升吞吐率。极度建议自己在数据通路图中标注信号，逐条跑一下各类指令加深理解。

Risc-V 基本知识

Tue, 28 Jul 2026 00:00:00 +0000

本人数字IC小白，一直对Risc-V处理器很感兴趣，打算仔细学习一下，并将学习过程记录下来，顺便敦促自己学习。

文章内容基于该网站教学。

Risc-V 基本知识

我要实现一个RV32I的CPU，因此需要了解RV32I的指令集架构以及内部结构。

指令集架构

基础整数指令集(I)提供了运算所需的全部基础指令，包含了加法、减法、逻辑运算、移位、跳转等指令。

部分指令如下表所示

类别	作用	RV32I包含指令
计算(Arithmetic)	整数加减法	add, sub, addi
逻辑(Logic)	按位与、或、异或、移位	and, or, xor, sll, srl
比较（Compare）	比较大小，结果1/0写入目标寄存器	slt, slti
加载/存储(Load/Store)	从存储器中加载 / 存储数据到寄存器	lw, sw, lb, sb
分支(Branch)	判断条件成立（if 判断、循环）	beq, bne, blt, bge
跳转(Jump)	固定跳转并保存返回地址，多用于函数调用、函数返回	jal, jalr

理解指令的构成

RISC-V指令由少量字段构成。掌握这七种字段，就能看懂几乎所有指令：

字段	位数	表示了什么
opcode	7bit	指令类型（属于算术运算指令？读取加载指令？还是分支跳转指令？）
rd	5bit	目标寄存器（运算结果的存储位置）
rs1	5bit	源寄存器1
rs2	5bit	源寄存器2
funct3	3bit	指令的子类型（选取opcode组别内具体的运算指令）
funct7	7bit	指令的子类型（用于区分共用同一个 funct3 字段的运算指令）
imm	视情况	立即数（自己输入常量数值，如“add 1”里的数字 “1”）

并非每条指令都需要占用所有字段单元。加法指令（add）需要三个寄存器，无需常量；立即数加法指令（addi）需要一个寄存器搭配一个常量；跳转指令则需要一个大范围偏移量。

六种格式一览

每种格式的用途

R-type (Register)：两个源寄存器 → 一个输出寄存器。仅寄存器之间的计算，例如add x7, x5, x6 sub and xor sll
I-type (Immediate)：一个源寄存器、12位立即数 → 一个输出寄存器。该指令格式同样适用于加载指令等操作，例如：jalr、addi x6, x6, 1、lw x5, 0 (x10)
S-type (Store)：两个源寄存器（作为基址和要写入的数据）、12位立即数作为地址偏移量 → 写入存储器（地址rs1 + imm）。例如：sw x5, 8(x10)
B-type (Branch)：比较两个寄存器，若满足判定条件，则依据有符号偏移量完成跳转。该指令格式与 S 型指令相似，但其立即数用于跳转目标的地址。例如：beq x6, x7, loop
U-type (Upper Immediate)：20位立即数 → 一个输出寄存器。将立即数存储到寄存器中，例如lui x7, 1000
J-type (Jump)：20位立即数 → 程序计数器。将立即数存储到程序计数器中，并跳转到指定位置，例如：jal x1, 0x100 # 跳转到PC+0x100，同时x1保存PC+4

所有指令详解见本文

寄存器

采用寄存器不直接采用数据存储器的原因：寄存器访问速度快，内存访问速度慢

32个寄存器：x0–x31

RV32I给出了32个通用寄存器，分别命名为x0、x1、x2、……x31，每个寄存器宽度为32位。

寄存器x0

x0寄存器最特别，x0读出端恒接0电平，写入无效。对零寄存器x0的巧妙复用，这样能设计出很多高效指令写法，使RISC-V架构所需的实际指令数量更少：

恒定的0寄存器:任何需要0时，直接从x0中取。
复制寄存器:如将x6复制到x5时，可以直接add x5, x6, x0，将x6+0存入x5。
丢弃一个结果:如果只需要一个指令带来的其他效益而不需计算结果，可以将结果直接写入x0。

寄存器的ABI名称与作用

寄存器编号	ABI 名称功能说明
x0	zero	硬件固化常量 0 寄存器
x1	ra	返回地址（函数执行完毕的返回跳转地址）
x2	sp	栈指针
x3	gp	全局指针
x4	tp	线程指针
x5–x7	t0 – t2	临时寄存器（暂存寄存器，调用者保存）
x8	s0 / fp	保存寄存器 / 栈帧指针
x9	s1	保存寄存器（被调用者保存）
x10–x11	a0 – a1	函数参数、函数返回值
x12–x17	a2 – a7	其余函数入参
x18–x27	s2 – s11	保存寄存器（被调用者保存）
x28–x31	t3 – t6	扩展临时寄存器（调用者保存）

PC程序计数器

程序计数器（PC）并不包含在32个通用寄存器之中，但至关重要。该寄存器存储着当前正在执行指令的内存地址，PC的变化也决定接下来执行什么指令。正常情况下，CPU执行完一条指令后，程序计数器数值会自增4（因为每条指令占用4字节，也就是32位），从而指向下一条待执行指令；而分支指令或跳转指令会改写程序计数器的数值，这也是循环语句与条件判断语句实现的原理。

内存、栈

内存

寄存器运行速度快，但数量稀少，仅有32个。实际运行的程序需要存储的数据量要大得多，同时程序还会调用层层嵌套的函数。想要实现这些需求，就必须依靠内存、栈结构，以及一套被称为调用约定的通用规范。

在RV32架构中，地址为32位长度，因此最多拥有4GB的字节存储单元（总数量为2的32次方个）。想要操作内存，只需提供对应地址，执行读取或是写入操作。

RISC-V架构在内存中采用小端序存放数据：一个32位字数据存储时，最低有效字节存放在最低内存地址。

内存对齐：32位字数据的存放地址通常必须是4的整数倍（半字数据地址需为2的整数倍）。对齐式内存访问对硬件而言处理逻辑最为简洁。

映射：

Text — 程序代码
Data — 全局变量
Heap — 动态分配的内存（向上扩展）
Stack — 函数调用栈（向上扩展）

栈

栈是一块专用内存区域，工作原理如同一摞盘子：遵循后进先出规则。内存中栈的特性：

栈地址向低地址方向增长：执行入栈操作时，sp 寄存器数值会减小。
处理器没有专用的push（入栈）指令：需要手动实现入栈流程，先减小sp的值，再完成数据存入；出栈则先读取数据，再将sp数值恢复增加。

栈存在的意义：

执行嵌套函数调用————jal指令调用函数时会将返回地址存入ra寄存器。但倘若该函数内部又调用了另一个函数，第二条jal指令就会覆盖ra寄存器中的原有数据，致使外层函数丢失返回地址。
对应的解决办法为：每个函数在发起嵌套调用前，先将ra寄存器的值存入堆栈，调用结束后再从堆栈中恢复该数值。依托堆栈机制，函数能够实现任意深度的嵌套调用，且每一层调用都可保存自身对应的返回地址。入栈操作等价于先执行addi sp,sp,-N再执行sw存储指令，出栈操作等价于先执行lw加载指令再执行addi sp,sp,N。

调用约定（The calling convention）

不同人员（或编译器）编写的函数想要能够协同运行，所有参与方必须就参数传递方式、返回值存放位置以及需要保留的寄存器达成统一标准。这套统一标准即为调用约定（The calling convention）（RISC-V 架构的调用约定与 ARM 的 AAPCS 规范相近）。沿用上一节寄存器的ABI名称与作用命名规则说明如下：

寄存器	作用	保存责任方
a0 ～ a7	函数入参；a0（搭配a1可存放多字节返回值）用作函数返回值	调用方保存
ra	函数返回地址	调用方保存（嵌套调用前务必手动保存）
t0 ～ t6	临时寄存器（临时计算值，随意覆写）	调用方保存
s0 ～ s11	保留寄存器（存放函数局部变量）	被调用方保存
sp	栈指针寄存器	被调用方保存（函数返回前必须复原栈指针数值）

调用方保存寄存器（t、a、ra）—— 被调用函数可随意覆盖这类寄存器的值。若调用函数后续还需要使用这些寄存器的数据，必须提前自行完成数据保存。
被调用方保存寄存器（s0 至 s11、栈指针 sp）—— 被调用函数执行完毕后，这类寄存器的数值必须和调用之初保持一致；因此函数若要使用该类寄存器，需先将数据入栈保存，在函数返回前再将数据出栈恢复。

CPU的本质操作

按照五级流水线来划分RV-CPU的工作可以分为以下五步：

Fetch(IF) ———— 从程序计数器（PC）指向的指令存储器（IMEM）中读取 32 位指令，计算 PC 值加 4 的结果。
Decode(ID) ———— 将指令拆分为各个字段。从寄存器堆中读取源寄存器 1、源寄存器 2 的数据。对立即数进行符号扩展。
Execute(EX) ———— 算术逻辑单元计算运算结果或分支目标地址。执行分支指令时，对操作数进行比对。
Memory(MEM) ———— Load: 读取内存数据。Store: 数据存入内存。非存储器类指令直接跳过此步骤。
Write-back(WB) ———— 结果写回目标寄存器

执行CPU数据通路所需的组成结构

结构	缩写	作用
程序计数器(Program Counter)	PC	用于存放待读取下一条指令地址的32位寄存器
指令存储器(Instruction Memory)IMEM	存储程序的只读存储器(组合逻辑电路，无需时钟信号)
指令译码器(Instruction Decoder)	DECODE	用于将指令拆分为各个字段
寄存器堆(Register File)	REGFILE	32个32位寄存器，两组异步读取端口与一组同步写入端口
立即数生成器(Immediate Generator)	IMMGEN	根据指令格式对指令中的立即数字段进行符号扩展处理。
算数逻辑单元(ALU)	ALU	接收两个32位操作数，计算后输出32位运算结果以及用于分支判断的零标志位。
算术逻辑单元多路选择器(ALU MUX)	ALUMUX	选择ALU的第二个操作数取值为寄存器rs2或是立即数。
数据存储器(Data Memory)	DMEM	暂存数据的存储器，可控制寄存器写入或读出。
写回多路选择器(Write-back MUX)	WBMUX	选择写入目标寄存器rd的数据来源。
分支处理单元(Branch Unit)	BRANCH	判断是否执行分支跳转，随后计算分支目标地址
程序计数器多路选择器(PC MUX)	PCMUX	选择下一个程序计数器数值，也就是是否跳转
控制单元(Control Unit)	CTRL	为内部单元提供控制信号

术语词表

记录在学习过程中遇到的专业名词

ABI

ABI(Application Binary Interface)，应用二进制接口

ALU

ALU(Arithmetic Logic Unit)，算术逻辑单元。包含加法器、减法器、移位器、逻辑运算器等功能。

CISC

CISC（Complex Instruction Set Computer），复杂指令集计算机。

CSR

CSR（Control and Status Register），控制和状态寄存器。

Immediate

立即数,表示CPU能直接调用的常量数值。

ISA

ISA（Instruction Set Architecture），指令集架构。

Pseudo-instruction

伪指令，不是汇编指令，在编译的时候会被编译器转换为对应的汇编指令。

RISC

RISC（Reduced Instruction Set Computer），精简指令集计算机。

RISC-V就是一种基于精简指令集（RISC）原则的开源指令集架构（ISA）

RV32I

RV -> RISC-V 32 -> 指令集长度32bit I -> base Integer instruction set 即整数型指令集

可扩展为RV32IMAFDC

RV -> RISC-V 32 -> 指令集长度32bit I -> base Integer instruction set 即整数型指令集 M -> multiply & divide 即乘除指令 A -> atomic operations 即原子操作 F/D -> floating-point 即浮点型 C -> compressed 16-bit instructions 即压缩指令

RV32I指令详解

Tue, 28 Jul 2026 00:00:00 +0000

本文介绍完整的Risc-V指令集

文章内容基于该网站教学。

整套RV32I基础指令集仅需大约40多条指令，也是处理器必须识别的全部 “指令词汇”。这些指令可划归为下面这几大类：

依次为算术与逻辑运算指令、立即数运算指令、加载/存储指令、分支指令、跳转指令、高位立即数指令、系统类指令。

算术与逻辑运算（寄存器 - 寄存器型）——R-type指令（10条）

选取两个寄存器中的数据执行运算操作，并存储运算结果。这类指令是处理器最常用的基础指令：

指令	含义
add / sub	rd = rs1 + rs2 / rd = rs1 − rs2
and / or / xor	按位与 / 按位或 / 按位异或
sll / srl / sra	逻辑左移 / 逻辑右移 / 算术右移（保留符号位）
slt / sltu	（对应有符号/无符号）rd = （rs1 < rs2） ? 1 : 0

# 用法
add rd, rs1, rs2  表示 rd = rs1 + rs2
sub rd, rs1, rs2  表示 rd = rs1 - rs2
and rd, rs1, rs2  表示 rd = rs1 & rs2
or rd, rs1, rs2  表示 rd = rs1 | rs2
xor rd, rs1, rs2  表示 rd = rs1 ^ rs2
sll rd, rs1, rs2  表示 rd = rs1 << rs2
srl rd, rs1, rs2  表示 rd = rs1 >> rs2
sra rd, rs1, rs2  表示 rd = rs1 >>> rs2
slt rd, rs1, rs2  表示 rd = (rs1 < rs2) ? 1 : 0
sltu rd, rs1, rs2  表示 rd = (rs1 < rs2) ? 1 : 0

算术与逻辑运算（寄存器 - 立即数型）（9条）

指令	含义
addi	rd = rs1 + 立即数 (不存在 “立即数减法 subi” 指令，只需传入负数即可实现减法)
andi / ori / xori	与常量按位与 / 按位或 / 按位异或
slli / srli / srai	逻辑左移 / 逻辑右移 / 算术右移常量位
slti / sltiu	（对应有符号/无符号）rd = （rs1 < 立即数） ? 1 : 0

#用法
addi rd, rs1, imm  表示 rd = rs1 + imm
andi rd, rs1, imm  表示 rd = rs1 & imm
ori rd, rs1, imm  表示 rd = rs1 | imm
xori rd, rs1, imm  表示 rd = rs1 ^ imm
slli rd, rs1, imm  表示 rd = rs1 << imm
srli rd, rs1, imm  表示 rd = rs1 >> imm
srai rd, rs1, imm  表示 rd = rs1 >>> imm
slti rd, rs1, imm  表示 rd = (rs1 < imm) ? 1 : 0
sltiu rd, rs1, imm  表示 rd = (rs1 < imm) ? 1 : 0

与存储器交互（8条）

指令	含义
lw	将内存中的一个32位字加载至目标寄存器rd
lh / lb	加载半字（16位）/字节（8位）到rd（带符号位扩展）
lhu / lbu	加载半字/字节数据到rd，（无符号位零扩展）
sw / sh / sb	将寄存器rs2中的字数据/半字数据/字节数据存入存储器

# 用法
lw rd, imm(rs1)  表示 rd = MEM[rs1 + imm]
lh rd, imm(rs1)  表示 rd = MEM[rs1 + imm]（高位扩展符号位）
lb rd, imm(rs1)  表示 rd = MEM[rs1 + imm]（高位扩展符号位）
lhu rd, imm(rs1)  表示 rd = MEM[rs1 + imm]（高位扩展0）
lbu rd, imm(rs1)  表示 rd = MEM[rs1 + imm]（高位扩展0）
sw rs2, imm(rs1)  表示 MEM[rs1 + imm] = rs2
sh rs2, imm(rs1)  表示 MEM[rs1 + imm] = rs2的低 16 位
sb rs2, imm(rs1)  表示 MEM[rs1 + imm] = rs2的低 8 位

分支指令（6条）

CPU执行“if（条件判断）”语句：分支指令会对比两个寄存器的值，仅当判定条件成立时才执行跳转操作，若条件不成立，程序则直接顺序向下执行。

指令	表达式（成立则跳转）
beq / bne	rs1 == rs2 / rs1 != rs2
blt / bge	rs1 < rs2 / rs1 ≥ rs2 (有符号数)
bltu / bgeu	rs1 < rs2 / rs1 ≥ rs2 (无符号数)

# 用法
beq rs1, rs2, imm  表示 if (rs1 == rs2) 跳转到 PC + 偏移地址
bne rs1, rs2, imm  表示 if (rs1 != rs2) 跳转到 PC + 偏移地址
blt rs1, rs2, imm  表示 if (rs1 < rs2) 跳转到 PC + 偏移地址
bge rs1, rs2, imm  表示 if (rs1 >= rs2) 跳转到 PC + 偏移地址
bltu rs1, rs2, imm  表示 if (rs1 < rs2) 跳转到 PC + 偏移地址
bgeu rs1, rs2, imm  表示 if (rs1 >= rs2) 跳转到 PC + 偏移地址

高位立即数指令（2条）

指令	含义
lui	把指令内的20位立即数放置到寄存器高20位，寄存器低12位清零。
auipc	20位立即数左移12位后与当前PC值相加，结果存入目标寄存器；常用于生成PC相对地址，实现位置无关寻址

1
2
3

# 用法
lui rd, imm  表示 rd = imm << 12
auipc rd, imm  表示 rd = (imm << 12) + PC

跳转指令（2条）

指令	含义
jal	Jump and link，PC 相对跳转。跳转目标 = PC + 符号扩展后的立即数，自动把当前 PC+4（下一条指令地址）写入 rd 寄存器，主要用于函数调用
jalr	寄存器间接跳转。跳转地址由「rs1 寄存器值 + 12 位符号扩展立即数」给出，同样会将 PC+4 存入 rd；最常用格式 jalr x0,0(x1) 实现函数返回，也可用于动态计算地址跳转

1
2
3

# 用法
jal rd, imm  表示 PC = PC + imm，rd = PC_old + 4
jalr rd, imm(rs1)  表示 PC = rs1 + imm，rd = PC_old + 4

伪指令

伪指令没有对应的独立机器码，汇编器在编译阶段，会自动把一条伪指令翻译成一条或多条真实硬件指令执行。只是为了编写汇编代码更简洁、好理解。

伪指令	翻译后指令	补充说明
li rd, 5	addi rd, x0, 5	12位范围内小立即数赋值；32位大数会编译为 lui + addi 组合
mv rd, rs	addi rd, rs, 0	复制寄存器
nop	addi x0, x0, 0	不做任何操作
j label	jal x0, label	跳转不保存返回地址
ret	jalr x0, 0(x1)	在跳转操作后，返回x1寄存器内的返回地址

特殊指令（10条）

CSR（控制状态寄存器）属于独立硬件寄存器组，和通用寄存器 x0~x31 物理分离，仅能使用以上 CSR 专用指令访问，普通运算指令无法读写。

指令	含义
ecall	环境调用，触发系统调用异常，向内核申请服务
ebreak	断点指令，触发调试异常，用于 GDB 程序调试暂停
fence	数据内存屏障，管控 Load/Store 访存乱序
fence.i	指令流水线屏障，清空指令缓存、刷新指令流
csrrw	CSR 读写：读出旧值到 rd，写入 rs 数据至 CSR
csrrs	CSR 读置位：读出旧值到 rd，使用 rs 按位或置 1 寄存器 bit
csrrc	CSR 读清零：读出旧值到 rd，使用 rs 按位与清零寄存器 bit
csrrwi	csrrw 立即数版本，使用 5 位立即数写入 CSR
csrrsi	csrrs 立即数版本，使用立即数做按位置位
csrrci	csrrc 立即数版本，使用立即数做按位清零

# 用法
ecall        # 发起系统调用
ebreak       # 触发调试断点异常
fence        # 数据内存屏障
fence.i      # 指令流水线刷新屏障
csrrw rd, csr, rs1  表示 rd = csr，csr = rs1
csrrs rd, csr, rs1  表示 rd = csr，csr = csr | rs1
csrrc rd, csr, rs1  表示 rd = csr，csr = csr & ~rs1
csrrwi rd, csr, imm  表示 rd = csr，csr = imm
csrrsi rd, csr, imm  表示 rd = csr，csr = csr | imm
csrrci rd, csr, imm  表示 rd = csr，csr = csr & ~imm

参考指令字段格式：

opcode对照表

IIC总线

Thu, 16 Jul 2026 00:00:00 +0000

本文讲解 IIC 总线协议，并给出可直接参考的 Verilog 主从机代码样例。

文章时序解析内容基于该视频。

IIC总线介绍

IIC（Inter-Integrated Circuit，常写作 I2C）是一种同步串行总线协议，由 Philips 提出由一个主机和若干从机构成，一个主机和多个从机共享同一对 SDA/SCL 信号线。

IIC总线仅使用两根线工作：SCL（Serial Clock，时钟线）与 SDA（Serial Data，数据线），二者均为开漏结构、靠上拉电阻拉高，主从机控制拉低。本文采用7位地址表示法。同一条总线上，每个从机地址必须唯一，主机通过地址选中特定从机进行通信。

IIC协议

上图为 IIC 标准传输格式，图中区分了"主机发出"与"从机发出"的信号。一次完整传输由起始条件开始、停止条件结束，中间按"地址 → 寄存器地址 → 数据"的顺序交互：

读时序：起始位 → 地址+W → ACK(从机) → 寄存器地址 → ACK(从机) → 地址+R → ACK(从机) → 数据 → ACK → … → 停止位
写时序：起始位 → 地址+W → ACK(从机) → 寄存器地址 → ACK(从机) → 写入数据 → ACK → … → 停止位

时序解析

IIC 是同步时序：SDA 上的数据在 SCL 高电平期间必须保持稳定，接收方通常在 SCL 上升沿附近采样；而 SDA 的电平翻转只能发生在 SCL 低电平期间。

这一约束是为了使得 SCL 高电平期间的 SDA 跳变被专门保留给"起始/停止条件"。

起始位（START, S）

总线空闲时，外接的上拉电阻将 SDA 与 SCL 都维持在高电平（IDLE 状态）。当主机准备通信时，在 SCL 为高电平期间将 SDA 拉低，即产生起始条件，标志一次传输开始。

地址位 + W/R

起始条件之后的第一个字节用于寻址：主机在 SCL 上升沿逐位送出 8 位数据，其中前 7 位为从机地址，第 8 位为读写标志 R/W（0 = 写，1 = 读）。

对于"读"操作，主机之所以先发"地址+W"，是为了先把要读取的寄存器地址写进从机；随后再用 repeated START 切换为"地址+R"，从机才据此把对应寄存器的数据发回来。

应答位（ACK）

图中白色信号即应答位，ACK 由当前字节的接收方产生。每传输完 8 位数据后，接收方需在紧跟的第 9 个 SCL 周期给出应答：ACK = SDA 被拉低（低电平），NACK = SDA 释放（高电平）。

NACK 表示发送方未收到应答。在主机读数据时，主机通常会在最后一个字节返回 NACK，通知从机停止继续发送；在其他场景下，NACK 也可能表示地址不存在、设备忙或通信异常。只有收到有效 ACK，通信才会继续。

停止位（STOP, P）

当前一次传输结束后，主机在 SCL 为高电平期间将 SDA 由低释放为高，产生停止条件，总线回到 IDLE 状态。

Verilog代码

本文实现的是标准模式（Standard-mode，≤100 kHz）下的 IIC 主从通信，覆盖 7 位地址、读写双方向、寄存器地址 + 连续多字节数据等最常见的外设访问场景，可作为学习与原型验证的基础 IP。

本文实现代码范围

类别	支持内容	说明
通信模式	标准模式 Standard-mode（默认 100 kHz）	主从双机，单主机结构
寻址	7 位从机地址	主机 `addr` 输入、从机 `SLAVE_ADDR` 参数
传输方向	写（主机→从机）/ 读（主机←从机）	均支持连续多字节
寄存器访问	先写寄存器地址，再读写数据	指针自增，支持跨寄存器连续访问
起止条件	START / STOP	读操作支持 repeated START（不发 STOP 直接重启）
应答机制	每字节后 ACK	从机回 ACK；读末字节主机回 NACK
时钟延长	主机侧支持	检测到 SCL 被从机拉低即等待（clock stretching）
总线建模	SDA/SCL 开漏	逻辑 1 = 释放、逻辑 0 = 拉低，板级外接上拉
错误处理	`error` 标志	地址或数据被 NACK 时置位

未覆盖的部分（如需可在此基础上扩展）：10 位地址、Fast-mode / Fast-mode Plus / High-speed 等高速模式、从机主动时钟延长（本从机不拉低 SCL）、广播呼叫/设备复位等保留地址、多主机仲裁与同步。

主机

主机驱动模块用状态机完成一次完整 IIC 传输：IDLE → START → ADDR_DEVICE(设备地址+W) → ADDR_REG(寄存器地址) → [读时 repeated START + ADDR_RD(设备地址+R)] → DATA(收发数据) → STOP。

SDA/SCL 均为开漏建模：输出逻辑 0 表示主动拉低总线，输出逻辑 1 并不会驱动高电平来实现，而是直接释放引脚，由片外上拉电阻恢复为高电平。因此 SDA_OE 与 SCL_OE 仅控制"是否拉低"总线。

SCL 由检测SCL边沿的计数器驱动——每检测到一次 SCL 实际边沿就重触发半周期计时，数满 T_HALF 翻转 SCL_OE。每 8 位数据后跟 1 拍 ACK：从机拉低为 ACK，释放为高即为 NACK。

当从机把 SCL 拉低时主机检测不到上升沿，计数器不被重触发，于是停在原位等待，直到从机释放产生上升沿才继续，这便实现了时钟延长（clock stretching）。因此主机并不是"按固定时间翻转 SCL"，而是"等待 SCL 实际发生边沿后再开始下一段计时"。

len 表示 DATA 阶段收发的字节数；写时主机连续发送、从机每字节回 ACK，末字节后进入 STOP；读时从机发送、主机对末字节回 NACK 后进入 STOP。与外部的握手复用单个 req 位——写时表示"本字节已发完、请准备下一字节"，读时表示"本字节已收满、请锁存 rd_data"；由于读写不可能同时发生，二者共用一位即可。

module IIC_Master #(
    parameter CLK_FREQ = 100_000_000,   // 系统时钟 100MHz
    parameter IIC_FREQ = 100_000       // IIC 速率 100kHz
)(
    input  wire       clk,        // 100MHz 系统时钟
    input  wire       rst_n,      // 异步复位（低有效）

    // 用户接口
    input  wire       start,      // 启动一次传输
    input  wire       rw,         // 1=读, 0=写
    input  wire [6:0] addr,       // 从机地址
    input  wire [7:0] reg_addr,   // 寄存器地址(ADDR_REG 发送)
    input  wire [7:0] len,        // 本次传输字节数 n（len>=1，0 视为 1）
    input  wire [7:0] wr_data,    // 待写数据（写模式：被 req 请求时由外部更新）
    output reg  [7:0] rd_data,    // 读到的数据（读模式：被 req 通知后由外部锁存）
    output reg        req,        // 单 bit 握手：写=本字节已发完、请求下一字节；读=本字节已收满、通知可锁存
    output reg        busy,       // 传输进行中
    output reg        done,       // 传输完成
    output reg        error,       // 错误标志：从机 NACK 地址或写数据时置 1，保持到下次 start 或成功完成才清零

    // IIC 双线（片外总线，开漏：逻辑1=释放引脚、由板级外接上拉拉高，逻辑0=本模块拉低）
    inout  wire       sda,
    inout  wire       scl
);

    // 时序参数
    localparam DIV    = CLK_FREQ / (2 * IIC_FREQ);   // 半周期 clk 数
    localparam T_HALF = DIV;                          // 每半周期固定计数
    localparam T_BUF  = CLK_FREQ / 200_000;           // STOP 后总线空闲时间
    localparam T_STOP  = CLK_FREQ / 250_000;
    localparam T_HDSTA = CLK_FREQ / 250_000;       // (repeated) START 后 SDA 保持低的保持时间 t_HD:STA(标准模式 4.0us)
    reg [$clog2(DIV):0] scl_cnt;
    reg [$clog2(T_STOP):0] stop_cnt;
    //SCL和SDA的OUTPUT ENABLE
    //起的是下拉作用，为1就是把SCL或SDA拉到0
    reg SCL_OE,SDA_OE;
    assign sda = SDA_OE ? 1'd0 : 1'dz;
    assign scl = SCL_OE ? 1'd0 : 1'dz;
    
    // 状态机
    localparam  IDLE  = 3'd0,
                START = 3'd1,
                ADDR_DEVICE  = 3'd2,
                ADDR_REG     = 3'd3,
                ADDR_RD      = 3'd4,
                DATA         = 3'd5,
                DATA_NEXT    = 3'd7,
                STOP         = 3'd6;
    reg [2:0] state;

    // 收发/计时寄存器
    reg [7:0] shift_reg;   // 发送移位 / 接收收集
    reg [3:0] bit_cnt;     // 0~7 数据位, 8=第9拍(ACK/NACK)
    reg [7:0] remain;      // 剩余待传字节数(含当前)
    reg       is_last;     // 当前读字节是否末字节(决定回 ACK 还是 NACK)
    reg       ack_phase;   // 读：ACK 拍已在上升沿被从机采样，待低电平释放
    reg       scl_run;     // 1=通信中生成 SCL；0=释放 SCL(高)
    reg       scl_run_d;
    wire      scl_run_pos = scl_run && !scl_run_d;   // 刚进入通信，产生首拍下降沿
    reg [$clog2(T_HDSTA):0] hd_cnt;    // t_HD:STA 保持计时
    reg       first_bit;               // 1=当前首字节首位需遵守 t_HD:STA(START 后保持 SDA 低)
    reg       start_fell;              // 1=已检测到 START 的 SCL 下降沿
    
    // 同步 SCL/SDA（异步于 clk），打拍检测边沿与读取实际电平
    reg [2:0] scl_sync, sda_sync;
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            scl_sync <= 3'b111;
            sda_sync <= 3'b111;
        end 
        else begin
            scl_sync <= {scl_sync[1:0], scl};
            sda_sync <= {sda_sync[1:0], sda};
        end
    end
    wire scl_in   = scl_sync[1];                 // 同步后的 SCL 电平
    wire sda_in   = sda_sync[1];                 // 同步后的 SDA 电平
    wire scl_rise = (scl_sync[2:1] == 2'b01);    // SCL 上升沿
    wire scl_fall = (scl_sync[2:1] == 2'b10);    // SCL 下降沿

    // SCL 生成（边沿触发 + 支持从机时钟延长）
    //   每检测到一次 SCL 实际边沿，重触发半周期计时；数到 T_HALF-1 翻转 SCL_OE。
    //   从机把 SCL 拉低时不会检测到上升沿 → 计数器不被重触发 → 主机停在原位等待，
    //   直到从机释放产生上升沿才继续，即时钟延长。
    //   scl_run_pos 时直接拉低，产生通信的第一个下降沿(START 之后的首个 SCL 跳变)。
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            scl_cnt   <= 0;
            SCL_OE    <= 1'b0;
            scl_run_d <= 1'b0;
        end
        else begin
            scl_run_d <= scl_run;
            if (!scl_run) begin
                scl_cnt <= 0;
                SCL_OE  <= 1'b0;          // 空闲/START/STOP：释放 SCL，保持高
            end
            else begin
                if (scl_run_pos) begin
                    SCL_OE  <= 1'b1;      // 刚启动：直接拉低，产生首拍下降沿
                    scl_cnt <= 0;
                end
                else if (scl_rise || scl_fall) begin
                    scl_cnt <= 0;         // 边沿重触发半周期计时
                end
                else if (scl_cnt < T_HALF) begin
                    scl_cnt <= scl_cnt + 1'b1;
                end
                if (scl_cnt == (T_HALF - 1))
                    SCL_OE <= ~SCL_OE;    // 半周期到，翻转驱动(释放<->拉低)
            end
        end
    end
    
    // SDA/状态机：基于 SCL 边沿收发
    //   scl_fall（进入低电平）：发送方设置下一位 SDA；第9拍释放 SDA 让从机回 ACK
    //   scl_rise（进入高电平）：采样 SDA（ACK / 数据位）
    //   每 8 位数据后跟 1 拍 ACK（从机拉低=ACK，释放=NACK）
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            state    <= IDLE;
            SDA_OE   <= 1'b0;
            scl_run  <= 1'b0;
            busy     <= 1'b0;
            done     <= 1'b0;
            req      <= 1'b0;
            error    <= 1'b0;
            shift_reg<= 8'h00;
            bit_cnt  <= 4'd0;
            remain   <= 8'd0;
            is_last  <= 1'b0;
            ack_phase<= 1'b0;
            stop_cnt <= 0;
            hd_cnt   <= 0;
            first_bit<= 1'b0;
            start_fell<= 1'b0;
        end
        else begin
            req <= 1'b0;   // 默认不请求；字节边界处脉冲置 1
            case (state)
                // 空闲：SDA/SCL 均释放(高)。start 拉低 SDA 形成 START
                IDLE: begin
                    SDA_OE  <= 1'b0;
                    scl_run <= 1'b0;
                    if (start) begin
                        busy    <= 1'b1;
                        done    <= 1'b0;
                        error   <= 1'b0;
                        SDA_OE  <= 1'b1;             // SCL 高时拉低 SDA = START
                        state   <= START;
                    end
                end

                // START：拉低 SDA(SCL 仍高)形成 START 条件，装载地址+W。
                // 首字节首位需遵守 t_HD:STA：ADDR_DEVICE 会等 SCL 落下后保持 SDA 低 t_HD:STA，再驱动地址 MSB。
                START: begin
                    SDA_OE    <= 1'b1;               // 维持 START(SDA 低)
                    shift_reg <= {addr, 1'b0};       // 设备地址 + W
                    bit_cnt   <= 4'd0;
                    scl_run   <= 1'b1;               // 触发首拍下降沿(scl_run_pos)
                    first_bit <= 1'b1;               // 首位需 t_HD:STA 保持
                    hd_cnt    <= 0;
                    start_fell<= 1'b0;
                    state     <= ADDR_DEVICE;
                end

                // 设备地址 + W：主机发 8 位，第9拍采样从机 ACK
                ADDR_DEVICE: begin
                    if (first_bit) begin
                        // t_HD:STA：START 的 SCL 落下后，SDA 继续维持低 t_HD:STA，再驱动首位(地址 MSB)
                        if (!start_fell) begin
                            if (scl_fall) start_fell <= 1'b1;   // 等 START 的 SCL 下降沿
                            SDA_OE <= 1'b1;                      // 维持 START 低
                        end
                        else if (hd_cnt < T_HDSTA) begin
                            hd_cnt  <= hd_cnt + 1'b1;            // 计 t_HD:STA
                            SDA_OE <= 1'b1;
                        end
                        else begin
                            SDA_OE   <= ~shift_reg[7];           // t_HD:STA 满足，驱动地址 MSB
                            first_bit<= 1'b0;
                            start_fell<= 1'b0;
                        end
                    end
                    else if (scl_fall) begin
                        if (bit_cnt < 4'd8) SDA_OE <= ~shift_reg[7];
                        else                SDA_OE <= 1'b0;   // 第9拍：释放等 ACK
                    end
                    else if (scl_rise) begin
                        if (bit_cnt < 4'd8) begin
                            shift_reg <= {shift_reg[6:0], 1'b0};
                            bit_cnt   <= bit_cnt + 1'b1;
                        end
                        else begin
                            if (sda_in) begin        // 从机 NACK 地址
                                error <= 1'b1; busy <= 1'b0; done <= 1'b1;
                                scl_run <= 1'b0; state <= IDLE;
                            end
                            else begin
                                shift_reg <= reg_addr;   // 装载寄存器地址
                                bit_cnt   <= 4'd0;
                                state     <= ADDR_REG;
                            end
                        end
                    end
                end

                // 寄存器地址：主机发 8 位，第9拍采样 ACK；写则进 DATA，读则 repeated START
                ADDR_REG: begin
                    if (scl_fall) begin
                        if (bit_cnt < 4'd8) SDA_OE <= ~shift_reg[7];
                        else                SDA_OE <= 1'b0;
                    end
                    else if (scl_rise) begin
                        if (bit_cnt < 4'd8) begin
                            shift_reg <= {shift_reg[6:0], 1'b0};
                            bit_cnt   <= bit_cnt + 1'b1;
                        end
                        else begin
                            if (sda_in) begin        // 从机 NACK
                                error <= 1'b1; busy <= 1'b0; done <= 1'b1;
                                scl_run <= 1'b0; state <= IDLE;
                            end
                            else if (rw == 1'b0) begin
                                // 写：进入 DATA 发送 len 字节（首字节 wr_data 在 start 时已备好）
                                shift_reg <= wr_data;
                                remain   <= (len == 8'd0) ? 8'd1 : len;
                                is_last  <= ((len == 8'd0) ? 8'd1 : len) == 8'd1;
                                bit_cnt  <= 4'd0;
                                state    <= DATA;
                            end
                            else begin
                                // 读：SCL 高时拉低 SDA = repeated START，随后发 地址+R
                                // repeated START 与 START 一样需要保持 t_HD:STA，
                                // 因此进入 ADDR_RD 时置位 first_bit 等标志，由其完成保持后再驱动首位。
                                SDA_OE    <= 1'b1;
                                shift_reg <= {addr, 1'b1};   // 设备地址 + R
                                bit_cnt   <= 4'd0;
                                first_bit <= 1'b1;           // 首位需 t_HD:STA 保持
                                start_fell<= 1'b0;
                                hd_cnt    <= 0;
                                state     <= ADDR_RD;
                            end
                        end
                    end
                end

                // 设备地址 + R（仅读）：repeated START 后的首位同样需保持 t_HD:STA，
                // 然后主机发 8 位，第9拍采样 ACK 后进入 DATA 接收
                ADDR_RD: begin
                    if (first_bit) begin
                        // t_HD:STA：repeated START 的 SCL 落下后，SDA 继续维持低 t_HD:STA，再驱动首位(地址 MSB)
                        if (!start_fell) begin
                            if (scl_fall) start_fell <= 1'b1;   // 等 repeated START 的 SCL 下降沿
                            SDA_OE <= 1'b1;                      // 维持 START 低
                        end
                        else if (hd_cnt < T_HDSTA) begin
                            hd_cnt  <= hd_cnt + 1'b1;            // 计 t_HD:STA
                            SDA_OE <= 1'b1;
                        end
                        else begin
                            SDA_OE   <= ~shift_reg[7];           // t_HD:STA 满足，驱动地址 MSB
                            first_bit<= 1'b0;
                            start_fell<= 1'b0;
                        end
                    end
                    else if (scl_fall) begin
                        if (bit_cnt < 4'd8) SDA_OE <= ~shift_reg[7];
                        else                SDA_OE <= 1'b0;
                    end
                    else if (scl_rise) begin
                        if (bit_cnt < 4'd8) begin
                            shift_reg <= {shift_reg[6:0], 1'b0};
                            bit_cnt   <= bit_cnt + 1'b1;
                        end
                        else begin
                            if (sda_in) begin        // 从机 NACK
                                error <= 1'b1; busy <= 1'b0; done <= 1'b1;
                                scl_run <= 1'b0; state <= IDLE;
                            end
                            else begin
                                shift_reg <= 8'h00;
                                remain   <= (len == 8'd0) ? 8'd1 : len;
                                is_last  <= ((len == 8'd0) ? 8'd1 : len) == 8'd1;
                                bit_cnt  <= 4'd0;
                                state    <= DATA;
                            end
                        end
                    end
                end

                // 数据阶段：写=主机发+从机ACK；读=从机发+主机ACK/NACK
                DATA: begin
                    // —— 写 ——
                    if (rw == 1'b0) begin
                        if (scl_fall) begin
                            if (bit_cnt < 4'd8) SDA_OE <= ~shift_reg[7];
                            else                SDA_OE <= 1'b0;
                        end
                        else if (scl_rise) begin
                            if (bit_cnt < 4'd8) begin
                                shift_reg <= {shift_reg[6:0], 1'b0};
                                bit_cnt   <= bit_cnt + 1'b1;
                            end
                            else begin
                                if (sda_in) begin    // 从机 NACK 数据
                                    error <= 1'b1; busy <= 1'b0; done <= 1'b1;
                                    scl_run <= 1'b0; state <= IDLE;
                                end
                                else if (remain > 8'd1) begin
                                    req      <= 1'b1;       // 请求外部准备下一字节
                                    remain   <= remain - 1'b1;
                                    is_last  <= (remain - 1'b1) == 8'd1;
                                    bit_cnt  <= 4'd0;
                                    state    <= DATA_NEXT;   // 等 wr_data 更新后再装载
                                end
                                else begin
                                    state <= STOP;          // 全部发完
                                end
                            end
                        end
                    end
                    // —— 读 ——
                    else begin
                        if (scl_fall) begin
                            if (bit_cnt < 4'd8) SDA_OE <= 1'b0;   // 接收期间释放
                            else if (!ack_phase) SDA_OE <= is_last ? 1'b0 : 1'b1; // ACK/NACK
                            else begin
                                SDA_OE   <= 1'b0;
                                if (!is_last) begin
                                    remain   <= remain - 1'b1;
                                    shift_reg<= 8'h00;
                                    bit_cnt  <= 4'd0;
                                    is_last  <= (remain - 1'b1) == 8'd1;
                                end
                                ack_phase <= 1'b0;
                            end
                        end
                        else if (scl_rise) begin
                            if (bit_cnt < 4'd8) begin
                                shift_reg <= {shift_reg[6:0], sda_in};
                                if (bit_cnt == 4'd7) begin
                                    rd_data <= {shift_reg[6:0], sda_in};  // 收满 8 位
                                    req     <= 1'b1;                     // 通知外部锁存
                                    bit_cnt <= 4'd8;                     // 进入第9拍
                                end
                                else bit_cnt <= bit_cnt + 1'b1;
                            end
                            else begin
                                // 第9拍上升沿：从机已采样到本字节 ACK/NACK
                                if (is_last) state <= STOP;
                                else          ack_phase <= 1'b1;
                            end
                        end
                    end
                end

                // 字节边界缓冲：本拍外部已在 req 后把 wr_data 更新为新字节，
                // 此刻再装入 shift_reg，确保下一个字节发出的是"新值"而非刚发完的旧值。
                DATA_NEXT: begin
                    shift_reg <= wr_data;
                    state     <= DATA;
                end

                // 停止位：先停 SCL(释放→高)，SCL 高时拉低 SDA，保持 T_STOP 后释放 SDA=STOP
                STOP: begin
                    scl_run <= 1'b0;                 // 释放 SCL，等待变高
                    SDA_OE  <= 1'b1;                 // 保持 SDA 低，等 SCL 高
                    if (scl_in) begin
                        if (stop_cnt < T_STOP) stop_cnt <= stop_cnt + 1'b1;
                        else begin
                            SDA_OE <= 1'b0;          // 释放 SDA→高：SCL 高时 SDA 上升 = STOP
                            done    <= 1'b1;
                            error   <= 1'b0;
                            busy    <= 1'b0;
                            state   <= IDLE;
                        end
                    end
                    else stop_cnt <= 0;
                end

                default: state <= IDLE;
            endcase
        end
    end
    

endmodule

从机

从机作为总线外设，通过一组片内接口与内部逻辑交互。本从机仅实现 IIC 协议，不包含具体设备功能（例如 EEPROM、RTC 等寄存器逻辑），因此可以作为通用 IIC Slave IP 复用。

端口分为三组：片内总线侧 clk/rst_n，IIC 侧 scl/sda，以及内部交互接口 reg_addr / data_out / data_in / req / busy / done / error / rw。

IIC 侧先把 scl/sda 打两拍同步以消除亚稳态，再据此检测边沿与起始/停止条件，用状态机完成与主机对齐的标准 IIC 从机协议：先匹配 7 位地址 → 收 1 字节寄存器地址（reg_addr）→ 进入数据收发。寄存器指针 reg_ptr 取自主机发来的寄存器地址字节（8 位），每收发 1 字节指针自增，因此天然支持跨多个寄存器的连续读写：

写：主机先写 reg_addr，随后连发 N 字节；从机每收到 1 字节，就把 data_out 连同当前 reg_addr 通过 req 脉冲交给内部锁存，并使指针自增。
读：主机先写 reg_addr，再发 repeated START + 地址+R；从机在每个读字节开始前提前一拍用 req 请求内部把 reg_addr 处数据放到 data_in，随后从 data_in 取数连续送出，每字节后指针自增。

SDA 采用开漏建模：仅在需要拉低（回 ACK、或发送的数据位为 0）时驱动 0，其余时刻释放为高阻，由片外引脚上的上拉电阻拉高；从机只在 SCL 低电平期间更新 SDA、在高电平期间保持稳定，因此自身的跳变不会被误判为起始/停止条件。

module iic_slave #(
    parameter [6:0] SLAVE_ADDR = 7'h50    // 本从机地址（由上层指定）
)(
    input  wire       clk,       // 片内总线时钟
    input  wire       rst_n,     // 异步复位（低有效）

    input  wire       scl,       // IIC 时钟（主机驱动，异步于 clk）
    inout  wire       sda,       // IIC 数据（开漏，双向）

    // ===== 内部交互接口（片内逻辑侧）=====
    output wire [7:0] reg_addr,  // 当前访问的寄存器地址（字节偏移），输出给内部
    output reg  [7:0] data_out,  // 写方向：主机写来的数据，输出给内部锁存
    input  wire [7:0] data_in,   // 读方向：内部给从机的数据，由内部按 reg_addr 提供
    output reg        req,       // 单 bit 握手：
                                 //   写=收到 1 字节、请求内部把 data_out 锁存到 reg_addr；
                                 //   读=即将发送 1 字节、请求内部把 reg_addr 处数据放到 data_in
    output reg        busy,      // 从机正处于一次传输中（START 到 STOP）
    output reg        done,      // 一次传输完成（检测到 STOP）
    output reg        error,     // 错误标志（保留/可扩展：如内部 NACK、越界等，正常为 0）
    output reg        rw         // 当前传输方向：1=读（从机发，数据来自 data_in），0=写（从机收，给 data_out）
);

    // ============================================================
    // 一、SCL/SDA 打两拍同步 + 边沿 / 起止条件检测
    // ============================================================
    reg [2:0] scl_sync, sda_sync;
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            scl_sync <= 3'b111;
            sda_sync <= 3'b111;
        end else begin
            scl_sync <= {scl_sync[1:0], scl};
            sda_sync <= {sda_sync[1:0], sda};
        end
    end
    wire scl_rise = (scl_sync[2:1] == 2'b01);
    wire scl_fall = (scl_sync[2:1] == 2'b10);
    wire scl_high =  scl_sync[1];
    wire sda_in   =  sda_sync[1];
    wire start_cond = scl_high && (sda_sync[2:1] == 2'b10);
    wire stop_cond  = scl_high && (sda_sync[2:1] == 2'b01);

    // ============================================================
    // 二、SDA 开漏输出（片外总线）：仅在需要"拉低"时驱动 0，其余释放为高阻。
    // ============================================================
    reg sda_oe, sda_d;
    assign sda = (sda_oe && (sda_d == 1'b0)) ? 1'b0 : 1'bz;

    // ============================================================
    // 三、IIC 从机状态机（与主机协议对齐：地址+W → 寄存器地址 → [repeated START+地址+R] → 数据）
    //     寄存器地址 reg_ptr 取自主机发来的寄存器地址字节（8 位），收发后自增；
    //     写：每收到 1 字节经 req 交给内部（data_out + reg_addr）；
    //     读：每发 1 字节前经 req 向内部要数（data_in），从 data_in 取出连续送出。
    // ============================================================
    localparam S_IDLE  = 3'd0,
               S_START = 3'd1,
               S_ADDR  = 3'd2,
               S_ACK   = 3'd3,
               S_DATA  = 3'd4,
               S_STOP  = 3'd5;
    reg [2:0] state;

    reg [3:0] bit_cnt;
    reg [7:0] shift_rx;
    reg [7:0] addr_byte;
    reg [7:0] shift_tx;
    reg [7:0] reg_ptr;   // 寄存器地址指针（8 位，主机发来的寄存器地址字节），收发后自增
    reg       mack;
    reg       got_addr;
    reg       reg_done;
    reg       slave_tx;

    assign reg_addr = reg_ptr;   // 当前寄存器地址直接给内部

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            state     <= S_IDLE;
            sda_oe    <= 1'b0;
            sda_d     <= 1'b1;
            bit_cnt   <= 4'd0;
            shift_rx  <= 8'd0;
            shift_tx  <= 8'd0;
            reg_ptr   <= 8'd0;
            rw        <= 1'b0;
            mack      <= 1'b0;
            got_addr  <= 1'b0;
            reg_done  <= 1'b0;
            slave_tx  <= 1'b0;
            data_out  <= 8'd0;
            req       <= 1'b0;
            busy      <= 1'b0;
            done      <= 1'b0;
            error     <= 1'b0;
        end
        else begin
            req  <= 1'b0;   // 默认不请求；需要时脉冲置 1
            done <= 1'b0;   // 默认非完成；STOP 时脉冲置 1

            // 起始/停止条件最高优先级：随时重定位状态机
            if (start_cond) begin
                state     <= S_START;
                bit_cnt   <= 4'd0;
                sda_oe    <= 1'b0;
                got_addr  <= 1'b0;
                reg_done  <= 1'b0;
                slave_tx  <= 1'b0;
                busy      <= 1'b1;
                // reg_ptr 保留，repeated START 后读仍从已设 reg_addr 起
            end
            else if (stop_cond) begin
                state  <= S_STOP;
                sda_oe <= 1'b0;
                busy   <= 1'b0;
                done   <= 1'b1;   // 传输完成脉冲
            end
            else begin
                case (state)
                    S_IDLE: begin
                        sda_oe <= 1'b0;
                    end

                    S_START: begin
                        bit_cnt <= 4'd0;
                        sda_oe  <= 1'b0;
                        state   <= S_ADDR;
                    end

                    // ADDR：收 8 位地址字节（MSB 先入）。收满后在 ACK 拍回 ACK 并判匹配/R-W。
                    S_ADDR: begin
                        if (scl_rise) begin
                            if (bit_cnt < 4'd8) begin
                                shift_rx <= {shift_rx[6:0], sda_in};
                                bit_cnt  <= bit_cnt + 1'b1;
                                if (bit_cnt == 4'd7)
                                    addr_byte <= {shift_rx[6:0], sda_in};
                            end
                        end
                        else if (scl_fall) begin
                            if (bit_cnt == 4'd8) begin
                                if (addr_byte[7:1] == SLAVE_ADDR) begin
                                    rw     <= addr_byte[0];
                                    sda_oe <= 1'b1;
                                    sda_d  <= 1'b0;
                                    // 读方向：提前一拍请求内部提供 reg_ptr 指向的数据（下一字节即读首字节）
                                    if (addr_byte[0] == 1'b1) req <= 1'b1;
                                    state  <= S_ACK;
                                end else begin
                                    sda_oe <= 1'b0;
                                    state  <= S_IDLE;
                                end
                            end
                        end
                    end

                    // ACK：每字节后的应答拍。
                    //   从机发送方向(slave_tx=1，读数据)：释放 SDA，SCL 高采样主机 ACK/NACK，下降沿续传/结束；
                    //   从机接收方向(slave_tx=0)：本低电平已驱动 ACK，下降沿释放并按子阶段决定去向。
                    S_ACK: begin
                        if (slave_tx == 1'b1) begin
                            if (scl_rise) begin
                                mack <= sda_in;             // 0=ACK 续传，1=NACK 结束
                            end
                            else if (scl_fall) begin
                                if (mack == 1'b0) begin
                                    // 主机 ACK：续传下一字节（数据已在上一字节末经 req 请求）
                                    bit_cnt <= 4'd0;
                                    state   <= S_DATA;
                                end else begin
                                    sda_oe <= 1'b0;         // NACK：主机结束读
                                    state  <= S_IDLE;
                                end
                            end
                        end
                        else begin
                            if (scl_fall) begin
                                sda_oe  <= 1'b0;            // 释放 ACK
                                bit_cnt <= 4'd0;
                                if (got_addr == 1'b0) begin
                                    // 刚 ACK 的是"地址字节"
                                    got_addr <= 1'b1;
                                    if (rw == 1'b1) begin
                                        // 读：进入发送（reg_ptr 已由前面 reg_addr 字节设好，数据经 req 已请求）
                                        slave_tx <= 1'b1;
                                        reg_done <= 1'b1;
                                        bit_cnt  <= 4'd0;
                                        state    <= S_DATA;
                                    end else begin
                                        // 写：进入 DATA 收寄存器地址
                                        slave_tx <= 1'b0;
                                        reg_done <= 1'b0;
                                        state    <= S_DATA;
                                    end
                                end
                                else if (reg_done == 1'b0) begin
                                    // 刚 ACK 的是"寄存器地址字节"：锁存寄存器地址
                                    reg_ptr  <= shift_rx;
                                    reg_done <= 1'b1;
                                    slave_tx <= 1'b0;
                                    state    <= S_DATA;
                                end
                                else begin
                                    // 刚 ACK 的是"写数据字节"：交给内部锁存
                                    data_out <= shift_rx;          // 写来的数据给内部
                                    req      <= 1'b1;             // 请求内部锁存到当前 reg_addr
                                    reg_ptr  <= reg_ptr + 1'b1;   // 指针自增
                                    slave_tx <= 1'b0;
                                    state    <= S_DATA;
                                end
                            end
                        end
                    end

                    // DATA：收发一个字节（MSB 先）。
                    //   发(slave_tx=1，读数据)：首拍从 data_in 装载，SCL 低电平驱动位，发满 8 位后释放供主机应答；
                    //   收(slave_tx=0，含 reg_addr 与写数据)：SCL 上升沿移位，收满 8 位后本低电平驱动 ACK。
                    S_DATA: begin
                        if (slave_tx == 1'b1) begin
                            if (scl_fall) begin
                                if (bit_cnt == 4'd0) begin
                                    // 首拍：装载内部提供的读数据（req 已提前一拍请求）
                                    shift_tx <= {data_in[6:0], 1'b0};
                                    sda_oe   <= 1'b1;
                                    sda_d    <= data_in[7];
                                    bit_cnt  <= 4'd1;
                                end
                                else if (bit_cnt < 4'd8) begin
                                    sda_oe   <= 1'b1;
                                    sda_d    <= shift_tx[7];
                                    shift_tx <= {shift_tx[6:0], 1'b0};
                                    bit_cnt  <= bit_cnt + 1'b1;
                                end
                                else begin
                                    // 8 位发完，释放供主机 ACK/NACK；自增指针并提前请求下一字节
                                    sda_oe   <= 1'b0;
                                    reg_ptr  <= reg_ptr + 1'b1;
                                    req      <= 1'b1;
                                    state    <= S_ACK;
                                end
                            end
                        end
                        else begin
                            if (scl_rise) begin
                                if (bit_cnt < 4'd8) begin
                                    shift_rx <= {shift_rx[6:0], sda_in};
                                    bit_cnt  <= bit_cnt + 1'b1;
                                end
                            end
                            else if (scl_fall) begin
                                if (bit_cnt == 4'd8) begin
                                    sda_oe <= 1'b1;         // 驱动 ACK
                                    sda_d  <= 1'b0;
                                    state  <= S_ACK;
                                end
                            end
                        end
                    end

                    S_STOP: begin
                        sda_oe <= 1'b0;
                        state  <= S_IDLE;
                    end

                    default: state <= S_IDLE;
                endcase
            end
        end
    end

endmodule

Verilog语法教程

Mon, 22 Jun 2026 00:00:00 +0000

Verilog 语法教程

Verilog HDL（简称 Verilog）是一种硬件描述语言（Hardware Description Language, HDL），用于数字电路的系统设计。它能在算法级、门级、开关级等多种抽象层次上对硬件进行建模。

阅读本教程前，你需要了解基本的数字电路知识，包括组合逻辑、时序逻辑与时钟/复位的概念。

如果想要动手练习 Verilog，建议在 HDLBits 网站进行练习。

一个完整例子

下面先看一个完整的计数器模块，再逐块拆解它用到的语法：

module counter10(
    input         rstn,        // 复位端，低有效
    input         clk,         // 输入时钟
    output [3:0]  cnt,         // 4 位计数输出
    output        cout         // 溢出进位
);

    reg [3:0] cnt_temp;        // 计数寄存器

    always @(posedge clk or negedge rstn) begin
        if (!rstn)
            cnt_temp <= 4'b0;                       // 复位时归零
        else if (cnt_temp == 4'd9)
            cnt_temp <= 4'b0;                       // 计到 9 后归零
        else
            cnt_temp <= cnt_temp + 1'b1;            // 否则加 1
    end

    assign cout = (cnt_temp == 4'd9);  // 进位：计到 9 时拉高
    assign cnt  = cnt_temp;            // 实时计数输出
endmodule

一、module 与文件结构

一个 Verilog 设计由若干 module（模块） 组成，每个模块用 module ... endmodule 包裹：

module 后跟模块名与端口列表，endmodule 表示模块结束（结尾没有分号）。
模块名应使用有意义的英文，不能是 Verilog 关键字，也不能含空格。
工程中通常一个 .v 文件只放一个 module，且文件名与模块名保持一致，方便工具管理。
模块内部由**端口声明、数据类型定义、连续赋值（assign）、过程块（always）**等部分构成。

module 模块名 ( 端口列表 );
    // 端口声明
    // 信号/寄存器定义
    // assign 连续赋值
    // always 过程块
endmodule

注释

Verilog 支持两种注释，与 C 语言相同：

行注释 //：从 // 到本行行尾。
块注释 /* ... */：可跨越多行。

// 这是一行注释
reg [3:0] cnt;   // 行尾也可以写注释
/* 这是
   跨行块注释 */

注释会被综合器忽略，仅用于提升可读性。建议对关键信号含义、状态编码、时序/约束意图加上注释。

二、端口定义

端口是模块与外部电路的接口，必须声明方向与（可选的）类型/位宽。

1. 三种方向

方向	含义	典型用途
`input`	模块输入，由外部驱动	时钟、复位、数据输入
`output`	模块输出	数据/状态输出
`inout`	双向（三态）	开漏总线，如 IIC 的 `sda`/`scl`

2. 端口默认是 wire

端口声明时若只写方向（不写 reg），默认类型为 wire。因此：

input 永远是外部驱动的 wire，不能被 always 赋值。
output 若要在 always 块里被赋值，必须显式声明为 reg（即 output reg）；若仅由 assign 驱动则保持 wire。

3. 两种声明风格

现代 ANSI 风格（推荐）：方向与类型直接写在端口列表中，直观不易出错。

module counter10(
    input         rstn,
    input         clk,
    output [3:0]  cnt,      // 默认 wire，用 assign 驱动
    output        cout      // 默认 wire
);
    // ...
endmodule

传统非 ANSI 风格：端口列表只列名字，类型/方向再到模块体内声明（旧代码常见，但容易遗漏）：

module counter10(rstn, clk, cnt, cout);
    input  rstn;
    input  clk;
    output [3:0] cnt;
    output       cout;
    // ...
endmodule

三、数据类型：wire 与 reg

Verilog 中最常用的两种变量类型是 线网（wire） 与 寄存器（reg）。

1. wire（线网类型）

顾名思义表示一根"导线"，自身不能存储状态，必须由外部驱动才能呈现 0 或 1（驱动源可以是 assign、模块端口或基本门）。常用于组合逻辑的输出与模块间的连线。

1
2
3

wire        interrupt;
wire        flag1, flag2;
wire        gnd = 1'b0;      // 常接地的线

2. reg（寄存器类型）

reg 类型变量可以在过程块（always）中被赋值。从硬件角度看，它名字里的"寄存器"容易误导——它不一定综合成真正的触发器，最终变成什么电路，完全取决于它写在哪种 always 里：

写在 always @(posedge clk) 里 → 综合成 D 触发器（Flip-Flop）：每位都是一个小存储单元，只在时钟上升沿"啪"地记住新值，平时保持不动。这是 reg 最常见的硬件形态。
写在 always @(*) 里 → 综合成组合门电路（如与门、或门、选择器），没有记忆，输出随输入即时变化。此时 reg 只是"过程中暂存变量"，并不是真正的寄存器。
若分支没写全（缺 else / default）→ 综合器为"保持原值"会悄悄生成锁存器（latch），一般要尽量避免。

一句话：reg 在时序块里 = 触发器（有记忆），在组合块里 = 组合门（无记忆），关键在于它所在的 always。

1
2
3

reg         clk_temp;
reg         flag1, flag2;
reg  [3:0]  counter;

简单记忆：assign 驱动的用 wire，always 块里被赋值的用 reg。

3. signed 有符号类型（仅介绍）

入门阶段极少用到，这里只做概念性介绍，不要求掌握，知道有这回事即可。

默认情况下 wire / reg 是无符号的，算术与比较都按无符号处理。在类型后加 signed 关键字可声明为有符号（二进制补码），此时算术、关系运算以及 >>> 算术右移都会按正负来解释：

reg signed [7:0] a;     // 有符号 8 位，范围 -128 ~ +127
reg        [7:0] b;     // 无符号 8 位，范围 0 ~ 255

a = -8'sd10;            // 注意：字面量也要带 s 才是"有符号字面量"

要点：有符号只改变"如何解释这些 bit"与运算规则；线网/寄存器里存的仍是普通 bit。当有符号与无符号操作数混用时，结果按无符号处理，需要特别小心。

四、位宽与向量

1. 标量 vs 向量

从硬件角度看，Verilog 里的一个信号其实就是一根导线；指定位宽后，它就变成一捆并排的多根导线，这捆"导线束"就叫做向量（vector）。

标量（scalar）：没有指定位宽，本质是 1 根导线，只能表示 0 或 1 一个 bit。
向量（vector）：位宽大于 1，本质是 N 根并排的导线，可一次性承载 N 个 bit，做多位运算（[3:0] 就是 4 根导线，编号 0~3）。

1
2
3

wire        a;          // 1 根导线（1 位标量）
reg  [3:0]  counter;    // 4 根并排导线（4 位向量），位宽 = 3-0+1 = 4
wire [31:0] data;       // 32 根并排导线（32 位向量/总线）

可以想象 wire [31:0] data; 在电路里并不是一根"粗线"，而是 data[0]、data[1] … data[31] 共 32 根独立的导线捆在一起，平时统一叫 data 来批量操作。这种"多根导线"的视角，对理解后面的位选、拼接、移位都很关键。

2. 向量声明与高低位

向量格式为 [msb : lsb]（高位在前、低位在后），位宽 = msb - lsb + 1：

1
2
3

reg  [3:0]   counter;     // 大端：bit3 为最高位 MSB，bit0 为最低位 LSB
wire [8:2]   addr;        // 7 位向量，编号从 8 到 2
reg  [0:31]  data;        // 小端：bit0 为 MSB（不推荐，易混淆，尽量统一用 [msb:lsb]）

3. 位选与域选

可以对向量做单 bit 选择或连续段选择：

1
2

counter[0]        // 取最低位
counter[3:1]      // 取 bit3、bit2、bit1 共 3 位

4. 拼接与复制

拼接运算符 {}：把多个信号拼成更宽的总线。
复制 {n{ }}：把某值重复 n 次。

1
2

wire [7:0] bus = {cnt, 4'b0000};     // 把 4 位 cnt 拼到高 4 位，低 4 位补 0
wire [3:0] zero = {4{1'b0}};         // 等价于 4'b0000

5. 向量的数组（存储器）

前面说的 reg [3:0] counter 是一个"4 位宽的向量"。如果再加一对方括号，就声明了一组相同宽度的向量，也就是存储器（memory） —— 常用于寄存器堆、RAM、FIFO 等：

1
2
3

reg [7:0] byte1 [3:0];    // 声明一个"4 个字、每字 8 位"的存储器
                           // 左侧 [7:0] = 每个字的位宽
                           // 右侧 [3:0] = 字的个数（地址范围 0~3）

读法要分清两个维度：

左侧 [7:0] 是"每个元素的位宽"（数据宽度）。
右侧 [3:0] 是"元素的个数/地址范围"（深度）。

1
2
3

byte1[0]           // 取第 0 个字（一个 8 位向量）
byte1[2][7:0]      // 取第 2 个字的全部 8 位
byte1[addr][3]     // 取第 addr 个字的第 3 位

注意几个常见限制：
不能一次性对整个存储器赋值，只能按字逐一赋值（通常写在带下标的 always 块里）：
1
2
3
4
integer i;
always @(posedge clk) begin
    if (wen) byte1[waddr] <= wdata;  // 只写某一个字
end
存储器元素（byte1[addr]）在传统的连续赋值 assign 中不能直接整体驱动，一般放在 always 块里用 reg 描述，或用 for 循环初始化。

wire 也可以声明成数组（如 wire [7:0] bus [3:0]），但在可综合设计中存储器几乎都用 reg。

五、数值的表示方式

1. 四种逻辑值

Verilog 用下列四种基本值表示硬件电平：

值	含义
`0`	逻辑 0 或"假"
`1`	逻辑 1 或"真"
`x` / `X`	未知（未初始化 / 多驱动冲突）
`z` / `Z`	高阻（常用于 `inout` 三态/开漏释放）

2. 基数格式

数字语法为 <位宽>'<基数><数值>，合法的基数有四种：

二进制 'b / 'B
十进制 'd / 'D
十六进制 'h / 'H
八进制 'o / 'O

为严谨，实际编码中一般始终指定位宽：

1
2
3

4'b1011             // 4 位二进制
32'h3022_c0de       // 32 位十六进制，下划线仅便于阅读、无实际意义
4'd9                // 4 位十进制 9

3. 不定宽、负数与实数

不指定位宽时，编译器通常按宿主字长（常见 32 位）处理：counter = 'd100; 或 counter = 100;。
负数在位宽之前加减号：counter = -6'd15; 是合法的；- 放在数值之后（如 4'd-2）则非法。
Verilog 还有 real 实数类型，支持科学计数法（如 1.2e4、1E-3），但不参与综合，只用于测试/建模。

六、运算符与基础计算

Verilog 提供丰富的运算符。下面按"算术前先补一句：所有运算都在位上按位宽进行，结果位宽不够会截断高位、不够会补符号/零"来分类介绍最常用的几类。

1. 算术运算符

运算符	含义	说明
`+`	加	按位宽相加，溢出则截断高位
`-`	减	按位宽相减
`*`	乘	综合为乘法器，结果位宽通常为两操作数位宽之和
`/`	除	综合资源开销大，尽量少用（2 的幂建议用移位代替）
`%`	取模	同 `/`，综合代价高，慎用

reg [7:0] a, b;
reg [8:0] sum;        // 进位位宽多留 1 位
reg [15:0] prod;

sum  = a + b;         // 8 位 + 8 位，结果用 9 位接住进位
prod = a * b;         // 8×8 = 16 位

注意：Verilog 中的 + - * 是无符号按位宽计算；若操作数带 signed 声明则为有符号运算。位宽不匹配时，窄的操作数会零扩展（无符号）或符号扩展（有符号）到宽的位宽后参与运算。

2. 移位运算符

运算符	含义	说明
`<<`	逻辑左移	右侧补 0，等价于 ×2ⁿ
`>>`	逻辑右移	左侧补 0，等价于 ÷2ⁿ
`<<<`	算术左移	有符号场景下同逻辑左移
`>>>`	算术右移	有符号时左侧补符号位（保持正负）

reg [7:0] x;
x = x << 1;           // 左移 1 位（乘 2），低位补 0
x = x >> 2;           // 右移 2 位（除 4），高位补 0
x = x <<< 1;          // 算术左移

硬件视角：移位在综合后几乎不消耗逻辑资源——它并不是"计算"，而是把导线重新连了一下。例如 x << 1 综合出来就是：把 x[6:0] 接到输出 [7:1]、输出最低位 [0] 接地（补 0）。正因为只是"改接线"，所以比乘除法器便宜得多。

因此，对 2 的整数次幂的乘除，优先用移位实现，比 /、* 更省逻辑资源。例如 addr * 4 写成 addr << 2。

3. 位运算与归约运算符

运算符	含义	说明
`~`	按位取反	每一位取反
`&`	按位与	对应位相与
`\|`	按位或	对应位相或
`^`	按位异或	不同为 1
`~^` / `^~`	同或	相同为 1
`&`(单目)	归约与	把所有位"与"起来，得 1 位
`\|`(单目)	归约或	把所有位"或"起来，得 1 位
`^`(单目)	归约异或	奇偶校验常用

reg [3:0] v;
reg       all_one, any_one, parity;

all_one  = &v;        // 归约与：v 全 1 时为 1
any_one  = |v;        // 归约或：v 任意位为 1 时为 1
parity   = ^v;        // 归约异或：v 中 1 的个数为奇数时为 1

4. 关系与等式运算符

运算符	含义
`>` `>=` `<` `<=`	大小比较，结果为 1 位
`==` `!=`	相等 / 不等
`===` `!==`	全等 / 不全等（会区分 `x`/`z`，仅用于仿真，不可综合）

`1`	`if (cnt == 4'd9) ... // 组合/时序里常用 == 做判断`

5. 拼接、复制与条件运算符

拼接 {}：已在"位宽与向量"一节介绍，可把多个信号拼成更宽总线。
复制 {n{ }}：重复某值 n 次。
条件运算符 ?:：条件 ? 真值 : 假值，常用于 assign 中做二选一。

1
2
3

assign sel_out = sel ? a : b;          // 二选一多路器
assign bus     = {hi, 8'b0, lo};       // 拼接
assign mask    = {8{1'b1}};            // 8 位全 1

运算符优先级与 C 语言类似（乘除移位 > 加减 > 比较 > 位运算 > 条件），写复杂表达式时多用括号避免歧义。

七、always 过程块

always 是描述硬件行为的过程块，内部可以写 if/else、case、for 等控制语句。它的行为完全由**敏感表（sensitivity list）**决定——敏感表里写什么事件，块就在什么事件发生时执行。

实际工程中，绝大多数的 always 只有两种"标准写法"，分别对应时序逻辑和组合逻辑：

写法	触发方式	综合出	典型用途	赋值方式
`always @(posedge clk or negedge rst_n)`	时钟 / 复位边沿	触发器（带复位）	打拍、计数、状态机	非阻塞 `<=`
`always @(*)`	任意输入信号变化	组合逻辑（门电路）	译码、多选一、运算	阻塞 `=`

下面分别介绍这两种写法。

1. 时序逻辑：`always @(posedge clk or negedge rst_n)`

敏感表里写的是边沿事件，块只在边沿到来的那一时刻执行一次。这是描述触发器（Flip-Flop）与寄存器的最标准形式，几乎总是写成"时钟上升沿 + 复位下降沿"：

always @(posedge clk or negedge rst_n) begin
    if (!rst_n)
        q <= 1'b0;          // 复位有效（低有效）时，值清零
    else
        q <= d;             // 否则在时钟上升沿把 d 锁存到 q
end

posedge clk：时钟上升沿触发——每个时钟沿把输入"打一拍"。
negedge rst_n：复位下降沿也触发，因此复位是异步的（复位一拉低立刻生效，不等待时钟）。
若要做同步复位，就把复位写进 if 判断、且不列入敏感表：always @(posedge clk) if (!rst_n) ...。
这种写法综合出来的是带复位的 D 触发器；块内使用非阻塞 <= 赋值（见 §八）。

2. 组合逻辑：`always @(*)`

组合逻辑的输出只取决于当前输入（没有时钟、没有记忆），所以只要右侧用到的任何信号变化，输出就该立刻更新。敏感表用通配符 * 表示"自动包含所有用到的信号"，既省事又不会漏写：

always @(*) begin
    case (sel)
        2'b00:   y = a;
        2'b01:   y = b;
        2'b10:   y = c;
        default: y = 1'b0;
    endcase
end

* 等价于手动列出 always @(a or b or c or sel)，但不用手列，避免漏写敏感信号导致仿真与综合行为不一致。
组合逻辑块内使用阻塞 = 赋值（见 §八）。
一定要把分支写全（加 default），否则综合器会推断出锁存器（见 §3）。

硬件视角：上面这段 case 综合后，本质就是一个多路选择器（MUX）——sel 是选择信号，它控制把 a / b / c / 0 中的哪一路"连"到输出 y。所以 case、或者 ?: 条件运算符，在硬件里都是同一个东西：一个被选择信号控制的多路开关。

3. 避免意外锁存器（latch）

组合逻辑里，如果 if 缺少 else、或 case 缺少 default，综合器会认为"条件不满足时输出应保持原值"，从而推断出锁存器。通常我们不希望出现锁存器，所以组合 always 要分支写全：

always @(*) begin
    if (sel)
        y = a;
    else                // 必须有 else，否则 y 在 sel=0 时被锁存
        y = b;
end

4. begin / end 语句块

begin ... end 把多条语句组织成一个顺序语句块，相当于 C 的 { }。在 always、if、case、for 等结构里，当分支包含多条语句时必须用 begin/end 包裹（单条语句可省略）：

always @(posedge clk) begin
    if (en) begin
        a <= 1'b1;
        b <= 1'b0;   // 多条语句必须包在 begin/end 中
    end
    else
        a <= 1'b0;   // 单条语句可省略 begin/end
end

5. case 语句

case 是多分支选择，常用于译码、状态机跳转。语法：case (表达式) 分支1: 语句; 分支2: 语句; default: 语句; endcase。从硬件角度看它就是一个多路选择器（MUX）：选择信号决定把哪一路输入接到输出。注意：

各分支按全等比较（===）匹配，且分支值之间不应重叠。
组合逻辑务必写 default，否则未覆盖的情况会被综合成锁存器。

always @(*) begin
    case (sel)
        2'b00:   y = a;
        2'b01:   y = b;
        2'b10:   y = c;
        default: y = 1'b0;     // 防止 latch
    endcase
end

相关变体：casez（把 ? / z 当作"不关心"通配）、casex（把 x 与 z 都当通配）。可综合设计里优先用 casez + ? 表示无关位。

6. for 循环

for 循环用于在同一时刻展开重复操作（如批量初始化数组、按位处理）。注意它是在综合/展开（elaboration）阶段被展开成多份并行硬件，因此循环次数必须是常量，不能依赖运行时的变量：

integer i;
always @(posedge clk) begin
    for (i = 0; i < 4; i = i + 1)
        byte1[i] <= 8'b0;   // 4 个字同时清零
end

因为循环会被展开，所以它常用于对存储器/向量做批量赋值、或实现移位寄存器等多位重复结构。循环变量一般用 integer 声明。

7. initial 块

initial 与 always 类似也是过程块，但它只在上电/仿真开始时执行一次（没有敏感表）：

reg [3:0] cnt;
initial begin
    cnt = 4'b0;          // 仿真初值
end

绝大多数非测试平台的 FPGA/ASIC RTL 中，不要依赖 initial 完成寄存器初始化，应使用复位逻辑。initial 主要用于**测试平台（testbench）**设置初值与激励；在可综合的 RTL 中多数综合器不支持（或忽略），变量初值应交给复位信号来完成。

八、阻塞赋值与非阻塞赋值

always 块内的赋值有两种符号，初学者最容易混淆：

赋值	符号	行为
阻塞赋值	`=`	立即生效，语句顺序执行（像软件一行行跑）
非阻塞赋值	`<=`	在块结束时统一更新，语句间并行（像硬件同时打拍）

硬件视角：电路是并行工作的——一个时钟上升沿到来，所有 D 触发器同时把各自的新值锁存进去。非阻塞 <= 正是这种"并行同时打拍"的建模：同一条 always 里的多条 <= 都基于进入本周期时的旧值计算，并在块结束时一起更新，互不干扰。而阻塞 = 是"算完一个再算下一个"的串行思路，适合描述组合逻辑里"前一句的结果立刻给后一句用"的依赖关系。记住这个"并行 vs 串行"的差别，就抓住了两种赋值的本质。

1. 黄金规则

时序逻辑（posedge clk 等）一律用非阻塞 <=：保证同一时钟沿上各语句基于"旧值"同时更新。
组合逻辑（always @(*)）一律用阻塞 =：保证前后语句按顺序、即时生效。

2. 反例：时序块里用错会出 bug

意图：把输入 d 打两拍（两级流水），正确的 q2 应等于上一周期的 q1。

// 非阻塞（正确）：两条语句都基于进入本周期时的旧值计算，q2 得到上一拍的 q1
always @(posedge clk) begin
    q1 <= d;
    q2 <= q1;
end

// 阻塞（错误）：q1 立即被更新，随后 q2 读到的是"刚更新的 q1"，
// 结果 q1、q2 同一拍都变成 d，退化为直通，没有延迟效果
always @(posedge clk) begin
    q1 = d;
    q2 = q1;
end

3. 反例：组合块里用错也会出错

// 阻塞（正确）：y 先算出，z 用到的是刚算出的 y
always @(*) begin
    y = a & b;
    z = y | c;
end

// 非阻塞（错误）：块结束时才统一更新，z 用到的是"上一轮"的 y，并非本次结果
always @(*) begin
    y <= a & b;
    z <= y | c;
end

牢记：“时序用 <=、组合用 =”，几乎能避免所有赋值类时序 bug。

九、parameter 与 localparam

两者都用于定义常量，可在模块内作为位宽、分频系数、地址等"可配置参数"使用。

parameter：可被上层在实例化时覆盖的常量，用来做模块参数化（如数据位宽、从机地址）。
localparam：仅模块内部使用的常量，不能被实例化覆盖（如状态机的状态编码、分频系数）。

module uart_tx #(parameter DATA_W = 8, parameter BAUD = 115200) (
    input clk, ...
);
    localparam IDLE    = 2'b00;            // 状态编码，不对外暴露
    localparam CNT_MAX = 100_000_000 / BAUD - 1;
    reg [DATA_W-1:0] shift_reg;
endmodule

现代模块推荐用 #(parameter ...) 的 ANSI 风格在端口前声明参数；实例化时可按名覆盖，如 uart_tx #(.DATA_W(16)) u_tx (...)。

十、模块实例化

Verilog 通过实例化把若干子模块"连起来"构成更大系统。可以类比成**“搭电路板 / 插元件”**：每个子模块是一颗现成的芯片，实例化就是把它焊到板子上，而 .端口(信号) 就是用导线把外部信号连到这个元件对应的引脚上。

实例化语法：模块名实例名 ( .端口名(连接信号), ... );，推荐用按名连接（.port(signal)），顺序可乱、可读性好：

wire [3:0] cnt_w;
wire       cout_w;

counter10 u_counter (          // u_counter 是把 counter10 这个"芯片"焊到板子上的实例
    .rstn (rstn),              // 用导线把外部 rstn 连到它的 rstn 脚
    .clk  (clk),               // 把 clk 连到它的 clk 脚
    .cnt  (cnt_w),             // 它的 cnt 输出脚，引到板上的 cnt_w 这根导线
    .cout (cout_w)
);

一个模块可以实例化多次（同一颗芯片焊多颗，只要取不同实例名）。也可用按位置连接（省略 .端口名，按模块定义顺序填实参），但易错、可读性差，不推荐。参数化模块实例化时还可按名覆盖参数，如 uart_tx #(.DATA_W(16)) u_tx (...)（见 §九）。

Markdown语法指南

Sat, 06 Dec 2025 00:00:00 +0000

本文提供了一个可用于 Hugo 内容文件的基本 Markdown 语法示例，同时还展示了 Hugo 主题中基本 HTML 元素是否被 CSS 装饰。

标题

以下 HTML <h1> 到 <h6> 元素表示六级标题。<h1> 是最高级别的标题，而 <h6> 是最低级别的标题。

H1

H2

H3

H4

H5

H6

段落

这里可以放一段话

这样换行两次是新开一段

引用块

引用块 (blockquote) 元素表示引用自其他来源的内容，可以选择性地带有引用来源，这些引用必须放在 footer 或 cite 元素中，并且可以选择性地带有行内修改，如注释和缩写。

引用段落（未注明来源）

Tiam, ad mint andaepu dandae nostion secatur sequo quae. 注意你可以在引用块中使用Markdown语法 。

带出处的引用

Don’t communicate by sharing memory, share memory by communicating.
— Rob Pike¹

表格

表格不是核心 Markdown 规范的一部分, 但是 Hugo 支持使用。

Name	Age
Bob	27
Alice	23

表格内的内联 Markdown

Italics	Bold	Code
italics	bold	`code`

A	B	C	D	E	F
Lorem ipsum dolor sit amet, consectetur adipiscing elit.	Phasellus ultricies, sapien non euismod aliquam, dui ligula tincidunt odio, at accumsan nulla sapien eget ex.	Proin eleifend dictum ipsum, non euismod ipsum pulvinar et. Vivamus sollicitudin, quam in pulvinar aliquam, metus elit pretium purus	Proin sit amet velit nec enim imperdiet vehicula.	Ut bibendum vestibulum quam, eu egestas turpis gravida nec	Sed scelerisque nec turpis vel viverra. Vivamus vitae pretium sapien

代码块

带反引号的代码块

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Example HTML5 Document</title>
</head>
<body>
  <p>Test</p>
</body>
</html>

缩进四个空格的代码块

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Example HTML5 Document</title>
</head>
<body>
  <p>Test</p>
</body>
</html>

使用 Hugo 内置 highlight shortcode 的代码块

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Example HTML5 Document</title>
</head>
<body>
  <p>Test</p>
</body>
</html>

Diff 代码块

[dependencies.bevy]
git = "https://github.com/bevyengine/bevy"
rev = "11f52b8c72fc3a568e8bb4a4cd1f3eb025ac2e13"
- features = ["dynamic"]
+ features = ["jpeg", "dynamic"]

列表类型

有序列表

First item
Second item
Third item

无序列表

List item
Another item
And another item

嵌套列表

Fruit
- Apple
- Orange
- Banana
Dairy
- Milk
- Cheese

其他元素 — abbr, sub, sup, kbd, mark

GIF 是一种位图图像格式。

H₂O

Xⁿ + Yⁿ = Zⁿ

按下 CTRL + ALT + Delete 以结束会话。

大多数蝾螈是夜行性的，以昆虫、蠕虫和其他小型生物为食。

超链接图片

The above quote is excerpted from Rob Pike’s talk during Gopherfest, November 18, 2015. ↩︎

Python指南

Sat, 06 Dec 2025 00:00:00 +0000

本文提供了Ptthon语法指南，仅供参考。（参考菜鸟教程Python3）

Python

数据类型

Python3 的六个标准数据类型：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

python的变量可以直接赋值：

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

print (counter)
print (miles)
print (name)

执行以上程序会输出如下结果：

1
2
3

100
1000.0
runoob

Number（数字）

Python3 支持 int、float、bool、complex（复数）

type() 函数可以用来查询变量所指的对象类型

1
2
3

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

String（字符串）

字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠转义特殊字符。

索引值以 0 为开始值，-1 为从末尾的开始位置。

bool（布尔类型）

即 True 或 False。

List（列表）

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

`1`	`变量[头下标:尾下标]`

索引值以 0 为开始值，-1 为从末尾的开始位置。

Python 列表截取可以接收第三个参数，参数作用是截取的步长:

变量[头下标:尾下标：步长]
letters = ['a','e','i','o','u']
letters[1:4:2]
-------------------------------
['e', 'o']

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组
---------------------------------------------------------
('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组较特殊，有一些额外的语法规则：

tup1 = () # 空元组

tup2 = (20,) # 一个元素，需要在元素后添加逗号，只有一个元素的元组需要在元素后面添加一个逗号，以区分它是一个元组而不是一个普通的值，在没有逗号的情况下，Python会将括号解释为数学运算中的括号。

Set（集合）

Python 中的集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

在 Python 中，集合使用大括号 {} 表示，元素之间用逗号 , 分隔。

另外，也可以使用 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,…}或者set(value)

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

print(sites)   # 输出集合，重复的元素被自动去掉

成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')


set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)

print(a - b)     # a 和 b 的差集

print(a | b)     # a 和 b 的并集

print(a & b)     # a 和 b 的交集

print(a ^ b)     # a 和 b 中不同时存在的元素

Dictionary（字典）

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

dict = {}
dict['one'] = "1"
dict[2]     = "two"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}


print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值
-------------------------------------------------
1
two
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])

bytes 类型

在 Python3 中，bytes 类型表示的是不可变的二进制序列（byte sequence）。

与字符串类型不同的是，bytes 类型中的元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。

bytes 类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等等。在网络编程中，也经常使用 bytes 类型来传输二进制数据。

创建 bytes 对象的方式有多种，最常见的方式是使用 b 前缀：

此外，也可以使用 bytes() 函数将其他类型的对象转换为 bytes 类型。bytes() 函数的第一个参数是要转换的对象，第二个参数是编码方式，如果省略第二个参数，则默认使用 UTF-8 编码：

x = bytes(“hello”, encoding=“utf-8”)

与字符串类型类似，bytes 类型也支持许多操作和方法，如切片、拼接、查找、替换等等。同时，由于 bytes 类型是不可变的，因此在进行修改操作时需要创建一个新的 bytes 对象。例如：

x = b"hello"
y = x[1:3]  # 切片操作，得到 b"el"
z = x + b"world"  # 拼接操作，得到 b"helloworld"

x = b"hello"
if x[0] == ord("h"):
    print("The first element is 'h'") 
    #其中 ord() 函数用于将字符转换为相应的整数值。

条件控制

条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。

if 语句

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

循环语句

while 循环

while 语句的一般形式：

1
2

while 判断条件(condition)：
    执行语句(statements)……

while 循环使用 else 语句

如果 while 后面的条件语句为 false 时，则执行 else 的语句块。

语法格式如下：

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

for 语句

for循环的一般格式如下：

for <variable> in <sequence>:
    <statements>
else:
    <statements>

当循环执行完毕（即遍历完 iterable 中的所有元素）后，会执行 else 子句中的代码，如果在循环过程中遇到了 break 语句，则会中断循环，此时不会执行 else 子句。

range() 函数

如果你需要遍历数字序列，可以使用内置 range() 函数。它会生成数列，例如:
>>>for i in range(5):
...     print(i)
...
0
1
2
3
4

使用 range() 指定区间的值：
>>>for i in range(5,9) :
    print(i)
 
    
5
6
7
8
>>>

也可以使 range() 以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做'步长'):
>>>for i in range(0, 10, 3) :
    print(i)
 
    
0
3
6
9
>>>

负数：
>>>for i in range(-10, -100, -30) :
    print(i)
 
    
-10
-40
-70
>>>

结合 range() 和 len() 函数以遍历一个序列的索引,如下所示:
>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
...     print(i, a[i])
... 
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>

还可以使用 range() 函数来创建一个列表：
>>>list(range(5))
[0, 1, 2, 3, 4]
>>>

break 和 continue 语句及循环中的 else 子句

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

pass 语句

pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句

Python 推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

列表推导式

列表推导式格式为：

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]

或者 

[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

字典推导式

字典推导基本格式：

{ key_expr: value_expr for value in collection }

或

{ key_expr: value_expr for value in collection if condition }

集合推导式

集合推导式基本格式：

1
2
3

{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }

元组推导式

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式基本格式：

1
2
3

(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

迭代器与生成器

迭代器

迭代是是访问集合元素的一种方式,可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

迭代器对象可以使用常规for语句进行遍历：

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")

next() 函数：

import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

生成器

yield 的函数被称为生成器（generator）。

yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。

生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

下面是一个简单的示例，展示了生成器函数的使用：

def countdown(n):
    while n > 0:
        yield n
        n -= 1

创建生成器对象
generator = countdown(5)

通过迭代生成器获取值
print(next(generator))  # 输出: 5
print(next(generator))  # 输出: 4
print(next(generator))  # 输出: 3
 
使用 for 循环迭代生成器
for value in generator:
    print(value)  # 输出: 2 1

StopIteration

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

在 20 次迭代后停止执行：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x)

函数

定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号 : 起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

面向对象

简介：

类(Class): 描述具有相同的属性和方法的对象的集合。
方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的，定义在类中且在函数体之外。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。
实例化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

类

类定义：

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

类对象

类对象支持两种操作：属性引用和实例化。

 
class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
 实例化类
x = MyClass()
 
 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())
------------------------------------------
MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

构造方法

类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：

1
2

def __init__(self):
    self.data = []

我的第一个博客

Sat, 06 Dec 2025 00:00:00 +0000

Hello world

正文

已经不想在经历硬盘崩溃导致的数据文本丢失了，因此我决定开一个博客来记录我的学习经历，博客使用Hugo搭建。

博客搭建方法来自Letere-莱特雷

主题来自Stack

以后我会在这里不定期更新学习经验

图片

归档

Tue, 28 May 2019 00:00:00 +0000

Mon, 01 Jan 0001 00:00:00 +0000

content文件夹目录

page

作用：存放独立页面（常用于关于页、链接页、搜索页、归档页等）。

post

作用：存放博客文章或帖子内容。

关于

Mon, 01 Jan 0001 00:00:00 +0000

大连理工大学集成电路学院硕士在读

硬件牛马，数字ic，深度学习小白,宝可梦爱好者

联系我：lumenth@126.com

技术链接

Mon, 01 Jan 0001 00:00:00 +0000

搜索

Mon, 01 Jan 0001 00:00:00 +0000

Lumenth

RV32I 单周期数据通路

逐指令数据通路说明（配图版）

公共部分（所有指令共用）

1. R-type —— 寄存器-寄存器运算（10 条）

2. I-type —— 寄存器-立即数运算（9 条）

3. LOAD —— 从存储器加载（5 条）

4. STORE —— 写入存储器（3 条）

5. BRANCH —— 条件分支（6 条）

6. JAL —— 无条件跳转并链接（1 条）

7. JALR —— 寄存器间接跳转并链接（1 条）

8. LUI —— 载入高位立即数（1 条）

9. AUIPC —— 地址无关高位立即数（1 条）

控制信号速查表（9 类汇总，供画图对照）

深度学习笔记3-反向传播

反向传播

一次训练的总体流程

初始化参数

前向传播

计算损失函数

反向传播

更新参数

总结与引入反向传播

反向传播的原理

链式法则

举例计算

小结

深度学习笔记-关键概念

关键概念

前向传播

激活函数

损失函数

梯度下降

学习率

小结

深度学习笔记2-多层感知机

多层感知机

引入隐藏层

多层感知机

多层线性变换

引入激活函数

一些常用的激活函数

万能逼近定理

多层感知机的数学表达

多层感知机遇到的问题

可编程时钟分频器

可编程时钟分频器

分频原理

分频的本质：用计数器"数"出更慢的时钟

半周期翻转法：天然 50% 占空比

为什么端口直接给"半周期计数值"

只支持偶数分频比

频率范围

关于精度

本文设计目标

参数与常量定义

端口定义

Verilog 实现

关键实现点

1. 输入同步：两级同步器 + 一拍确认

2. 分频参数的上下限保护与默认赋值

3. 计数终值 cnt_term：把减法移出计数路径

4. 边界装载：无毛刺切换的核心

5. 占空比与复位

仿真验证

综合与使用注意事项

小结

深度学习笔记1-感知机

深度学习基础-感知机

感知机模型

第一步：输入加权求和

第二步：判断并输出

第三步：错误修正

几何意义与收敛性

感知机的劣势

小结

RV32I单周期CPU

本文介绍单周期RV32I CPU的实现方式

数据通路整体结构

模块功能介绍

3. 计数终值 `cnt_term`：把减法移出计数路径