Chisel实战：从UART模块看现代硬件设计的验证效率与代码复用

Chisel硬件描述语言FPGA开发

于 2026-08-01 04:03:37 修改

·本内容遵循CC 4.0 BY-SA版权协议

第一次接触 Chisel 时，很多人会被它 Scala 语言的外壳吓到，觉得这又是一个“学术玩具”。但真正在 FPGA 项目里用 Chisel 实现一个基础 UART 模块后，你会发现它的价值远不止“用 Scala 写硬件”这么简单——它真正改变的是硬件设计的验证效率和代码可维护性。

就拿 UART 来说，用 Verilog 写一个基础收发器可能只要一两百行，但加上测试用例、参数化配置、异常处理，代码量会迅速膨胀。而 Chisel 的类型安全、高阶函数和面向对象特性，让一个可配置、可测试的 UART 模块能在保持代码简洁的同时，直接生成可综合的 Verilog。更重要的是，你可以在同一个语言环境下完成模块设计、测试激励生成和仿真验证，不用在 Verilog、SystemVerilog、Python 脚本和 Makefile 之间反复切换。

但 Chisel 的学习曲线也确实存在。如果你直接从一个复杂项目开始，很容易被 Scala 语法、Chisel 的隐式转换和函数式编程风格劝退。UART 之所以适合作为 Chisel 工程实战的第一个项目，是因为它的协议简单（起始位、数据位、校验位、停止位），时序清晰，但又包含了状态机、计数器、移位寄存器等基础硬件元素，能完整体现 Chisel 在“描述硬件行为”和“生成硬件结构”上的优势。

1. 先理解 Chisel 解决的不是语法问题，而是硬件设计流程问题

很多人第一次用 Chisel 时，会纠结“为什么要把简单的 always @(posedge clk) 写成 when(io.clockEdge) { ... }”。这种语法差异只是表面，Chisel 的核心价值在于把硬件设计从“线级连接”提升到“组件级抽象”。

1.1 传统 UART 设计的痛点：验证成本高且难以复用

用 Verilog 写一个最简单的 UART 发送模块，你可能会这样写：

VERILOG

module uart_tx (

input clk,

input rst,

input [7:0] data_in,

input send_en,

output reg tx_out,

output reg busy

);

reg [3:0] state;

reg [7:0] shift_reg;

reg [3:0] bit_count;

// ... 状态机逻辑

endmodule

这段代码看起来直接，但存在几个问题：

参数化困难：如果想支持不同的波特率、数据位宽、校验位，需要修改代码或使用 `ifdef。
测试验证麻烦：需要另外写 Verilog 或 SystemVerilog 的 testbench，仿真调试周期长。
代码重复：接收模块和发送模块的状态机、计数器逻辑类似，但很难直接复用。

在中小规模项目中，这些痛点可能还不明显。但当项目复杂度上升，需要支持多种配置、频繁迭代验证时，Verilog 的设计效率瓶颈就会暴露。

1.2 Chisel 的解决方案：用高级语言抽象硬件组件

Chisel 允许你像写软件一样定义硬件组件的行为和接口：

SCALA

class UARTParams(

val baudRate: Int = 115200,

val dataBits: Int = 8,

val hasParity: Boolean = false,

val parityType: String = "even" // "even" or "odd"

) {

require(dataBits >= 5 && dataBits <= 8, "Data bits must be between 5 and 8")

}

class UARTTx(params: UARTParams) extends Module {

val io = IO(new Bundle {

val txData = Input(UInt(params.dataBits.W))

val send = Input(Bool())

val tx = Output(Bool())

val busy = Output(Bool())

})

// ... 实现逻辑

}

这种写法的优势在于：

类型安全：UInt(params.dataBits.W) 确保数据宽度与参数一致，编译时就能发现错误。
参数化内置：通过 UARTParams 类封装所有配置，修改配置不需要触及核心逻辑。
接口明确：IO(new Bundle { ... }) 定义了清晰的模块边界，便于集成测试。

更重要的是，Chisel 的测试框架允许你在 Scala 环境下直接编写测试用例：

SCALA

test(new UARTTx(defaultParams)) { c =>

// 设置输入信号

c.io.txData.poke(0x55.U)

c.io.send.poke(true.B)

// 检查输出信号

c.io.busy.expect(true.B)

// ... 模拟时钟推进，验证波形

}

这种“设计-测试”一体化的流程，大幅减少了上下文切换成本。

1.3 什么时候适合用 Chisel：从学习到生产的判断标准

Chisel 不是万能的，在选择是否使用 Chisel 时，可以考虑以下几个维度：

场景	推荐程度	理由
学习硬件设计基础	★★★☆☆	Verilog/VHDL 更接近硬件底层，适合理解基础概念
中小规模 FPGA 项目	★★★★☆	Chisel 能提升代码质量和验证效率
需要参数化设计的 IP 核	★★★★★	Chisel 的面向对象特性非常适合 IP 核开发
算法密集型设计	★★★★★	Scala 的函数式编程适合描述复杂算法
与软件协同设计	★★★★★	同一语言环境下实现硬件/软件协同验证

对于 UART 这类基础外设，用 Chisel 实现的价值不仅在于模块本身，更在于为后续更复杂的设计建立了一套可扩展的框架。

2. UART 协议在 Chisel 中的实现思路：从状态机到可配置组件

UART 协议看似简单，但实现一个稳健的收发器需要考虑时钟域交叉、亚稳态处理、错误检测等细节。Chisel 提供了更抽象的方式来表达这些硬件概念。

2.1 波特率生成：用计数器替代分频器思维

在 Verilog 中，波特率生成通常用分频计数器实现：

VERILOG

reg [15:0] baud_counter;

always @(posedge clk) begin

if (baud_counter == CLKS_PER_BIT) begin

baud_tick <= 1'b1;

baud_counter <= 0;

end else begin

baud_tick <= 1'b0;

baud_counter <= baud_counter + 1;

end

Chisel 可以用更声明式的方式表达同样的逻辑：

SCALA

val baudCounter = RegInit(0.U(16.W))

val baudTick = baudCounter === (clockFreq / params.baudRate - 1).U

baudCounter := Mux(baudTick, 0.U, baudCounter + 1.U)

这种写法的优势是逻辑更清晰：baudTick 直接定义为计数器达到特定值的条件，而不是通过时序逻辑赋值。

2.2 发送状态机：用枚举类型替代魔数

Verilog 中常用参数定义状态：

VERILOG

localparam IDLE = 2'b00;

localparam START = 2'b01;

localparam DATA = 2'b10;

localparam STOP = 2'b11;

Chisel 提供了类型安全的状态定义：

SCALA

object TxState extends ChiselEnum {

val idle, start, data, parity, stop = Value

}

val stateReg = RegInit(TxState.idle)

这样定义的状态机在仿真和调试时更有可读性，编译器也能检查状态转移的完整性。

2.3 完整的 UART 发送模块实现

SCALA

class UARTTx(params: UARTParams) extends Module {

val io = IO(new Bundle {

val txData = Input(UInt(params.dataBits.W))

val send = Input(Bool())

val tx = Output(Bool())

val busy = Output(Bool())

})

// 波特率生成

val clockFreq = 100000000 // 100MHz

val baudDivisor = (clockFreq / params.baudRate).toInt

val counter = RegInit(0.U(32.W))

val baudTick = counter === (baudDivisor - 1).U

counter := Mux(baudTick, 0.U, counter + 1.U)

// 发送状态机

val stateReg = RegInit(TxState.idle)

val dataReg = RegInit(0.U(params.dataBits.W))

val bitCount = RegInit(0.U(3.W))

io.tx := true.B // 默认高电平（空闲状态）

io.busy := stateReg =/= TxState.idle

switch(stateReg) {

is(TxState.idle) {

when(io.send) {

stateReg := TxState.start

dataReg := io.txData

bitCount := 0.U

counter := 0.U

}

is(TxState.start) {

io.tx := false.B // 起始位

when(baudTick) {

stateReg := TxState.data

}

is(TxState.data) {

io.tx := dataReg(bitCount) // 从LSB开始发送

when(baudTick) {

when(bitCount === (params.dataBits - 1).U) {

if (params.hasParity) {

stateReg := TxState.parity

} else {

stateReg := TxState.stop

}

bitCount := 0.U

}.otherwise {

bitCount := bitCount + 1.U

}

// ... 校验位和停止位状态

}

这个实现展示了 Chisel 的几个关键特性：

模式匹配：switch/is 语句比 Verilog 的 case 语句更类型安全。
条件编译：if (params.hasParity) 在生成硬件时会被静态求值，不会产生额外的硬件开销。
参数化位宽：UInt(params.dataBits.W) 确保硬件位宽与参数一致。

2.4 接收模块的同步化处理

UART 接收的关键在于正确采样异步输入信号。Chisel 提供了 RegNext 和 ShiftRegister 等原语来简化同步链的实现：

SCALA

class UARTRx(params: UARTParams) extends Module {

val io = IO(new Bundle {

val rx = Input(Bool())

val data = Output(UInt(params.dataBits.W))

val valid = Output(Bool())

})

// 输入同步化：两级寄存器避免亚稳态

val syncReg = RegNext(RegNext(io.rx))

// 边沿检测

val prevRx = RegNext(syncReg)

val startEdge = !syncReg && prevRx // 检测起始位下降沿

// 采样点在比特中间（16倍过采样）

val samplePoint = counter === (baudDivisor / 2 - 1).U

// 多数表决滤波

val samples = ShiftRegister(syncReg, 3) // 3个周期的采样窗口

val filteredBit = samples.asBools.count(_ === true.B) > 1

这种实现方式比传统的 Verilog 写法更易读，而且 Chisel 会在生成 Verilog 时优化掉不必要的中间信号。

3. Chisel UART 的测试策略：从单元测试到系统验证

Chisel 的测试能力是其最大优势之一。传统的 FPGA 验证流程中，仿真往往是最耗时的环节，而 Chisel 的测试框架可以大幅提升验证效率。

3.1 基于 poke/expect 的单元测试

对于 UART 发送模块，可以编写针对性的测试用例：

SCALA

class UARTTxTest extends AnyFlatSpec with ChiselScalatestTester {

"UARTTx" should "correctly send a byte" in {

test(new UARTTx(defaultParams)).withAnnotations(Seq(WriteVcdAnnotation)) { c =>

// 初始状态检查

c.io.busy.expect(false.B)

c.io.tx.expect(true.B) // 空闲状态应为高电平

// 发送数据 0x55 (01010101b)

c.io.txData.poke(0x55.U)

c.io.send.poke(true.B)

c.clock.step(1)

c.io.send.poke(false.B)

// 检查起始位

c.io.tx.expect(false.B)

c.io.busy.expect(true.B)

// 等待起始位结束

while (!c.io.tx.peek().litToBoolean) {

c.clock.step(baudDivisor)

}

// 检查数据位

for (i <- 0 until 8) {

val expectedBit = (0x55 >> i) & 0x1

c.io.tx.expect(expectedBit.B)

c.clock.step(baudDivisor)

}

// 检查停止位

c.io.tx.expect(true.B)

c.clock.step(baudDivisor)

c.io.busy.expect(false.B)

}

这种测试的优点是：

执行速度快：在 JVM 上运行，比 Verilog 仿真快几个数量级。
调试方便：可以直接在 Scala IDE 中设置断点，查看信号值。
可自动化：可以集成到 CI/CD 流程中。

3.2 基于事务级的系统测试

对于完整的 UART 环回测试，可以构建更抽象的测试环境：

SCALA

class UARTLoopbackTest extends AnyFlatSpec with ChiselScalatestTester {

"UART loopback" should "correctly transmit and receive data" in {

test(new UARTLoopback(defaultParams)).withAnnotations(Seq(WriteVcdAnnotation)) { c =>

val testVectors = Seq(0x00, 0x55, 0xAA, 0xFF)

for (testByte <- testVectors) {

// 发送数据

c.io.txData.poke(testByte.U)

c.io.send.poke(true.B)

c.clock.step(1)

c.io.send.poke(false.B)

// 等待接收完成

var timeout = 0

while (!c.io.valid.peek().litToBoolean && timeout < 1000) {

c.clock.step(1)

timeout += 1

}

// 检查接收数据

c.io.valid.expect(true.B)

c.io.rxData.expect(testByte.U)

c.clock.step(1)

c.io.valid.expect(false.B)

}

3.3 基于随机测试的边界情况覆盖

ChiselTest 支持随机测试，可以自动发现边界情况：

SCALA

"UARTTx" should "handle random data correctly" in {

test(new UARTTx(defaultParams)).withAnnotations(Seq(WriteVcdAnnotation)) { c =>

val rng = new scala.util.Random(42) // 固定种子便于重现

for (_ <- 0 until 100) {

val randomData = rng.nextInt(256)

c.io.txData.poke(randomData.U)

c.io.send.poke(true.B)

c.clock.step(1)

c.io.send.poke(false.B)

// 等待发送完成

while (c.io.busy.peek().litToBoolean) {

c.clock.step(1)

}

// 可以添加更多的自动检查逻辑

}

3.4 测试覆盖率收集和分析

虽然 Chisel 本身不直接提供代码覆盖率工具，但可以通过以下方式确保测试质量：

路径覆盖：确保状态机的所有状态和转移都被测试到。
边界值测试：测试数据位宽、波特率的边界情况。
错误注入：模拟线路噪声、波特率偏差等异常情况。
性能验证：验证最大可持续波特率。

4. 从 Chisel 到 FPGA 实战：工程化考虑和优化策略

生成 Verilog 只是第一步，将 Chisel 设计部署到实际 FPGA 中还需要考虑资源占用、时序约束、调试支持等工程问题。

4.1 生成优化的 Verilog 代码

Chisel 默认生成的 Verilog 代码比较直接，可能包含一些优化空间。可以通过以下方式改进：

SCALA

// 使用 Chisel 的内置优化

class OptimizedUARTTx(params: UARTParams) extends Module {

// 使用 Mem 而不是 Reg 存储大数据

val buffer = Mem(16, UInt(params.dataBits.W))

// 使用 Log2 计算地址位宽，避免资源浪费

val addrWidth = log2Ceil(16)

val writeAddr = RegInit(0.U(addrWidth.W))

// 使用 Chisel 的优化原语

val baudCounter = Counter(baudDivisor)

val baudTick = baudCounter.value === (baudDivisor - 1).U

}

生成 Verilog 时，可以添加优化选项：

BASH

sbt "runMain uart.UARTGenerator --target-dir generated --inline"

4.2 时序约束和时钟域处理

在 FPGA 项目中，需要为生成的 Verilog 添加适当的时序约束：

TCL

# 时钟约束

create_clock -period 10.000 -name clk [get_ports clk]

# 输入延迟约束（针对 UART RX 输入）

set_input_delay -clock clk -max 2.000 [get_ports rx]

# 虚假路径（异步信号）

set_false_path -from [get_ports rx] -to [get_clocks clk]

对于多时钟域设计，Chisel 提供了 withClock、withReset 等域安全操作：

SCALA

// 如果接收端需要独立的过采样时钟

val oversampleClock = Wire(Clock())

withClock(oversampleClock) {

val oversampleCounter = RegInit(0.U(4.W))

// ... 过采样逻辑

}

4.3 调试和观测性设计

在实际部署中，需要添加调试接口来观测内部状态：

SCALA

class DebugUARTTx(params: UARTParams) extends Module {

val io = IO(new Bundle {

// 原有接口

val txData = Input(UInt(params.dataBits.W))

val send = Input(Bool())

val tx = Output(Bool())

val busy = Output(Bool())

// 调试接口

val debugState = Output(UInt(3.W))

val debugBitCount = Output(UInt(3.W))

val debugBaudTick = Output(Bool())

})

// 将内部信号连接到调试输出

io.debugState := stateReg.asUInt

io.debugBitCount := bitCount

io.debugBaudTick := baudTick

}

这些调试信号可以通过 FPGA 的 JTAG 或嵌入式逻辑分析仪（如 Xilinx ILA）来观测。

4.4 资源使用估算和优化

对于 UART 这种简单外设，资源占用通常不是问题，但了解估算方法对复杂设计很重要：

资源类型	估计用量	优化策略
LUT	50-100	使用共享计数器，优化状态编码
FF	30-60	减少不必要的寄存器
BRAM	0	小容量 FIFO 用分布式 RAM 实现

可以通过 Chisel 的 firrtl 后端生成资源报告，或者在综合后查看 FPGA 工具的报告。

4.5 与现有 IP 核的集成

在实际项目中，UART 可能需要与已有的 Verilog IP 核集成。Chisel 支持黑盒（BlackBox）机制：

SCALA

class VerilogFIFO extends BlackBox with HasBlackBoxResource {

val io = IO(new Bundle {

val clk = Input(Clock())

val rst = Input(Bool())

val wr_en = Input(Bool())

val din = Input(UInt(8.W))

val rd_en = Input(Bool())

val dout = Output(UInt(8.W))

val full = Output(Bool())

val empty = Output(Bool())

})

// 关联 Verilog 源文件

addResource("/verilog/fifo.v")

}

class UARTWithFIFO(params: UARTParams) extends Module {

val fifo = Module(new VerilogFIFO)

val uart = Module(new UARTTx(params))

// 连接 FIFO 和 UART

fifo.io.rd_en := uart.io.send && !fifo.io.empty

uart.io.txData := fifo.io.dout

// ... 其他连接

}

这种机制使得 Chisel 可以逐步引入到现有项目中，而不是要求一次性重写所有代码。

5. Chisel UART 设计的进阶应用和扩展思路

掌握了基础 UART 实现后，可以进一步探索 Chisel 在更复杂场景下的应用。

5.1 支持高级特性的可配置 UART

一个生产级的 UART IP 核需要支持更多特性：

SCALA

class AdvancedUARTParams(

val baudRate: Int = 115200,

val dataBits: Int = 8,

val hasParity: Boolean = false,

val parityType: String = "even",

val stopBits: Int = 1, // 支持 1, 1.5, 2 停止位

val flowControl: Boolean = false, // 支持硬件流控

val fifoDepth: Int = 16 // 内置 FIFO 深度

) {

require(stopBits == 1 || stopBits == 2, "Stop bits must be 1 or 2")

}

class AdvancedUART(params: AdvancedUARTParams) extends Module {

val io = IO(new Bundle {

// 基础 UART 接口

val tx = Output(Bool())

val rx = Input(Bool())

// 流控信号

val rts = Output(Bool()) // 请求发送

val cts = Input(Bool()) // 清除发送

// 中断信号

val txIrq = Output(Bool()) // 发送完成中断

val rxIrq = Output(Bool()) // 接收完成中断

})

// 使用 Chisel 的 Diplomatic 接口标准

val regSlave = TLIdentityNode()

val intNode = IntSourceNode(IntSourcePortSimple())

}

5.2 基于 Chisel 的验证组件开发

可以开发专门的验证组件来构建复杂的测试环境：

SCALA

class UARTSource(dut: UARTTx, clock: Clock) {

def send(data: Int): Unit = {

dut.io.txData.poke(data.U)

dut.io.send.poke(true.B)

clock.step(1)

dut.io.send.poke(false.B)

// 等待发送完成

while (dut.io.busy.peek().litToBoolean) {

clock.step(1)

}

class UARTSink(dut: UARTRx, clock: Clock) {

def expect(data: Int, timeout: Int = 1000): Boolean = {

var cycles = 0

while (!dut.io.valid.peek().litToBoolean && cycles < timeout) {

clock.step(1)

cycles += 1

}

if (cycles >= timeout) false

else {

val received = dut.io.data.peek().litValue

clock.step(1)

received == data

}

5.3 性能分析和优化

对于高速 UART 应用，需要关注时序性能：

SCALA

class PerformanceUART(params: UARTParams) extends Module {

// 使用流水线提高时序

val txPipeline = Module(new Pipeline(UInt(params.dataBits.W), 2))

// 使用预计算优化关键路径

val baudDivisorReg = RegInit((clockFreq / params.baudRate).U(32.W))

val nextBaudTick = Wire(Bool())

// 关键路径优化

when(baudTick) {

baudCounter := 0.U

}.otherwise {

baudCounter := baudCounter + 1.U

}

nextBaudTick := baudCounter === baudDivisorReg

baudTick := RegNext(nextBaudTick)

}

5.4 从 UART 到更复杂的通信协议

掌握了 UART 的 Chisel 实现后，可以扩展到更复杂的协议：

SPI 控制器：状态机更简单，但需要处理主从模式和时钟相位。
I2C 控制器：需要处理总线仲裁和时钟拉伸。
自定义串行协议：利用 Chisel 的灵活性快速实现项目特定协议。

这些协议在 Chisel 中的实现思路类似，都是通过状态机、计数器和移位寄存器的组合，但每个协议都有其独特的时序和错误处理要求。

通过 UART 这个相对简单但完整的项目，我们看到了 Chisel 在硬件设计现代化中的价值：它不仅仅是一种新的硬件描述语言，更是一种提升设计质量、验证效率和代码复用性的工程方法。对于想要在数字设计领域保持竞争力的工程师来说，掌握 Chisel 这类现代硬件构造语言正在从"加分项"变成"必备技能"。