Chisel UART设计实战：从协议原理到FPGA验证的完整工程实现

ChiselUARTFPGA

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

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

如果你正在学习 Chisel 硬件设计语言，可能会遇到一个关键问题：如何将抽象的硬件描述转化为实际可用的功能模块？特别是当涉及到像 UART 这样基础但至关重要的通信接口时，很多教程要么停留在理论层面，要么直接给出最终代码而缺乏完整的工程化视角。

这篇文章将带你完成一个完整的 Chisel UART 设计实战，重点不是简单实现功能，而是展示如何构建一个工程可用的 UART 模块。你将学会如何从协议分析开始，逐步设计发送器和接收器，处理常见的时序问题，最终在 FPGA 上验证整个通信链路。更重要的是，我们会讨论 Chisel 相比传统 Verilog 在模块化设计和验证方面的独特优势。

1. 为什么 Chisel + UART 是硬件设计入门的绝佳组合

UART（Universal Asynchronous Receiver/Transmitter）作为最基础的串行通信协议，几乎是每个嵌入式系统和 FPGA 项目的必备模块。但传统的 Verilog 实现往往面临几个痛点：状态机难以维护、参数化配置繁琐、验证代码冗长。这正是 Chisel 发挥价值的地方。

Chisel 通过高级语言特性让硬件设计更接近软件开发体验。比如，你可以用 Scala 的面向对象特性构建可复用的 UART 组件，用函数式编程简化状态机设计，用类型系统在编译期捕获硬件描述错误。更重要的是，Chisel 的测试框架让验证工作变得系统化。

在实际项目中，一个设计良好的 UART 模块需要解决几个关键问题：波特率自适应、帧错误处理、流量控制支持。我们将从最简单的版本开始，逐步添加这些工程化特性。

2. UART 协议核心要点与设计目标

2.1 UART 帧格式详解

UART 通信的基本单位是"帧"，每帧包含：

1个起始位（低电平）
5-9个数据位（通常为8位）
可选的奇偶校验位
1-2个停止位（高电平）

以最常见的 8N1 配置（8数据位、无校验、1停止位）为例，一帧数据的时序如下：

TEXT

空闲状态(高电平) → 起始位(低电平) → D0 → D1 → ... → D7 → 停止位(高电平)

2.2 波特率与采样时机

波特率决定了数据传输速度，如 115200 表示每秒传输 115200 位。关键设计挑战在于接收端需要在每个数据位的中间点采样，以避免边沿抖动带来的误码。

计算采样点的方法：

SCALA

// 假设系统时钟频率为 100MHz，波特率为 115200

val clockFreq = 100000000 // 100 MHz

val baudRate = 115200

val cyclesPerBit = clockFreq / baudRate // 约 868 个时钟周期每比特

val samplePoint = cyclesPerBit / 2 // 在比特中间采样

2.3 设计目标分解

我们的 Chisel UART 模块需要实现以下功能：

可配置的波特率（支持常见值：9600, 115200 等）
可配置的数据位宽（5-9位）
完整的错误检测（帧错误、溢出错误）
发送和接收缓冲机制
易于集成的 Wishbone 或 AXI 接口

3. 环境准备与项目结构规划

3.1 开发环境要求

在开始编码前，需要准备以下环境：

Scala 2.12+ 和 sbt 构建工具
Chisel 3.5+
FPGA 开发工具（Vivado 或 Quartus）
串口调试工具（如 minicom、putty）

3.2 项目目录结构

一个规范的 Chisel 项目应该这样组织：

TEXT

uart_project/

├── build.sbt # 项目构建配置

├── src/main/scala/uart/

│ ├── UARTParams.scala # 参数配置类

│ ├── UARTTx.scala # 发送器模块

│ ├── UARTRx.scala # 接收器模块

│ ├── UART.scala # 顶层模块

│ └── UARTTop.scala # 测试顶层模块

├── src/test/scala/uart/

│ └── UARTUnitTests.scala # 单元测试

└── generated/ # Chisel 生成的 Verilog

3.3 build.sbt 基础配置

SCALA

// build.sbt

name := "chisel-uart"

version := "1.0"

scalaVersion := "2.12.13"

val chiselVersion = "3.5.4"

libraryDependencies ++= Seq(

"edu.berkeley.cs" %% "chisel3" % chiselVersion,

"edu.berkeley.cs" %% "chiseltest" % "0.5.4" % "test"

)

addCompilerPlugin("edu.berkeley.cs" % "chisel3-plugin" % chiselVersion cross CrossVersion.full)

4. UART 参数化配置设计

在 Chisel 中，参数化配置是提升代码复用性的关键。我们首先设计一个配置类：

SCALA

// UARTParams.scala

case class UARTParams(

dataBits: Int = 8, // 数据位宽度

stopBits: Int = 1, // 停止位数量

hasParity: Boolean = false, // 是否使能奇偶校验

oddParity: Boolean = false, // 奇校验(true)还是偶校验(false)

baudRate: Int = 115200, // 波特率

clockFreq: Int = 100000000 // 系统时钟频率(100MHz)

) {

require(dataBits >= 5 && dataBits <= 9, "数据位宽必须在5-9之间")

require(stopBits == 1 || stopBits == 2, "停止位只能是1或2")

// 计算每个比特的时钟周期数

val cyclesPerBit: Int = clockFreq / baudRate

require(cyclesPerBit > 0, "波特率不能超过系统时钟频率")

}

这种设计允许我们在实例化 UART 时灵活配置参数：

SCALA

// 标准115200波特率配置

val standardParams = UARTParams(baudRate = 115200)

// 低速9600波特率配置

val lowSpeedParams = UARTParams(baudRate = 9600, dataBits = 7, hasParity = true)

5. UART 发送器 (UARTTx) 详细实现

发送器负责将并行数据转换为符合 UART 协议的串行数据流。核心是一个状态机，控制数据帧的各个阶段。

5.1 发送器接口定义

SCALA

// UARTTx.scala

class UARTTx(params: UARTParams) extends Module {

val io = IO(new Bundle {

val txd = Output(Bool()) // 串行数据输出

val valid = Input(Bool()) // 数据有效信号

val bits = Input(UInt(params.dataBits.W)) // 待发送数据

val ready = Output(Bool()) // 发送器就绪信号

})

// 状态定义

val sIdle :: sStart :: sData :: sParity :: sStop :: Nil = Enum(5)

val state = RegInit(sIdle)

// 比特计数器

val bitCount = RegInit(0.U(log2Ceil(params.dataBits).W))

// 时钟周期计数器

val cycleCount = RegInit(0.U(log2Ceil(params.cyclesPerBit + 1).W))

// 数据移位寄存器

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

// 奇偶校验位计算

val parityBit = if (params.hasParity) {

val dataParity = Mux(params.oddParity,

~(io.bits.xorR()).asBool(),

io.bits.xorR().asBool())

RegInit(false.B)

} else {

false.B

}

5.2 发送器状态机实现

SCALA

// 续 UARTTx.scala

io.ready := (state === sIdle)

switch(state) {

is(sIdle) {

io.txd := true.B // 空闲状态为高电平

when(io.valid) {

state := sStart

shifter := io.bits

cycleCount := 0.U

// 计算奇偶校验位（如果使能）

if (params.hasParity) {

parityBit := Mux(params.oddParity,

~(io.bits.xorR()).asBool(),

io.bits.xorR().asBool())

}

is(sStart) {

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

when(cycleCount === (params.cyclesPerBit - 1).U) {

cycleCount := 0.U

state := sData

bitCount := 0.U

}.otherwise {

cycleCount := cycleCount + 1.U

}

is(sData) {

// 按LSB优先顺序发送数据

io.txd := shifter(0)

when(cycleCount === (params.cyclesPerBit - 1).U) {

cycleCount := 0.U

shifter := shifter >> 1

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

bitCount := 0.U

if (params.hasParity) {

state := sParity

} else {

state := sStop

}

}.otherwise {

bitCount := bitCount + 1.U

}

}.otherwise {

cycleCount := cycleCount + 1.U

}

is(sParity) {

io.txd := parityBit

when(cycleCount === (params.cyclesPerBit - 1).U) {

cycleCount := 0.U

state := sStop

}.otherwise {

cycleCount := cycleCount + 1.U

}

is(sStop) {

io.txd := true.B // 停止位

when(cycleCount === (params.cyclesPerBit * params.stopBits - 1).U) {

cycleCount := 0.U

state := sIdle

}.otherwise {

cycleCount := cycleCount + 1.U

}

这个状态机完整实现了 UART 发送的所有阶段，关键设计点包括：

使用 cycleCount 精确控制每个比特的持续时间
支持可配置的停止位数量
灵活的奇偶校验生成逻辑

6. UART 接收器 (UARTRx) 详细实现

接收器设计比发送器更复杂，需要处理异步信号同步和精确的采样时机判断。

6.1 接收器接口与亚稳态处理

SCALA

// UARTRx.scala

class UARTRx(params: UARTParams) extends Module {

val io = IO(new Bundle {

val rxd = Input(Bool()) // 串行数据输入

val valid = Output(Bool()) // 数据接收完成信号

val bits = Output(UInt(params.dataBits.W)) // 接收到的数据

val error = Output(Bool()) // 帧错误信号

val ready = Input(Bool()) // 数据已读取确认

})

// 亚稳态处理：两级同步器

val rxdSync = RegNext(RegNext(io.rxd))

// 状态定义

val sIdle :: sStart :: sData :: sParity :: sStop :: Nil = Enum(5)

val state = RegInit(sIdle)

// 边沿检测：检测起始位的下降沿

val rxdPrev = RegNext(rxdSync)

val startEdge = !rxdSync && rxdPrev

}

6.2 接收器状态机与多数表决采样

为了抗干扰，我们在每个数据位的中间点附近进行多次采样，采用多数表决机制：

SCALA

// 续 UARTRx.scala

// 采样逻辑：每个比特采样3次，多数表决

val sampleCount = RegInit(0.U(2.W))

val sampleBits = Reg(Vec(3, Bool()))

// 比特采样状态机

switch(state) {

is(sIdle) {

io.valid := false.B

io.error := false.B

when(startEdge) {

state := sStart

cycleCount := (params.cyclesPerBit / 2).U // 起始位中间点开始采样

sampleCount := 0.U

}

is(sStart) {

when(cycleCount === (params.cyclesPerBit - 1).U) {

// 在起始位中间点采样，应该是低电平

val startBitValid = !sampleBits.asUInt().orR() // 多数表决应该是0

when(startBitValid) {

state := sData

cycleCount := 0.U

bitCount := 0.U

shifter := 0.U

}.otherwise {

state := sIdle // 起始位无效，返回空闲

}

}.otherwise {

// 在接近中间点时进行采样

when(cycleCount === (params.cyclesPerBit / 2 - 1).U ||

cycleCount === (params.cyclesPerBit / 2).U ||

cycleCount === (params.cyclesPerBit / 2 + 1).U) {

sampleBits(sampleCount) := rxdSync

sampleCount := sampleCount + 1.U

}

cycleCount := cycleCount + 1.U

}

is(sData) {

when(cycleCount === (params.cyclesPerBit - 1).U) {

// 数据位采样，采用多数表决

val bitValue = sampleBits.asUInt().popCount() > 1.U

shifter := Cat(bitValue, shifter(params.dataBits-1, 1))

cycleCount := 0.U

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

bitCount := 0.U

if (params.hasParity) {

state := sParity

} else {

state := sStop

}

}.otherwise {

bitCount := bitCount + 1.U

}

sampleCount := 0.U

}.otherwise {

// 采样时机控制

when(cycleCount === (params.cyclesPerBit / 2 - 1).U ||

cycleCount === (params.cyclesPerBit / 2).U ||

cycleCount === (params.cyclesPerBit / 2 + 1).U) {

sampleBits(sampleCount) := rxdSync

sampleCount := sampleCount + 1.U

}

cycleCount := cycleCount + 1.U

}

// 奇偶校验和停止位状态类似实现...

}

接收器的关键设计特点：

两级同步器消除亚稳态
多数表决采样提高抗干扰能力
精确的采样时机控制
完整的错误检测机制

7. 顶层 UART 模块集成

将发送器和接收器组合成完整的 UART 模块，并添加缓冲机制：

SCALA

// UART.scala

class UART(params: UARTParams) extends Module {

val io = IO(new Bundle {

// 外部串行接口

val txd = Output(Bool())

val rxd = Input(Bool())

// 控制接口

val txValid = Input(Bool())

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

val txReady = Output(Bool())

val rxValid = Output(Bool())

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

val rxError = Output(Bool())

val rxReady = Input(Bool())

})

val tx = Module(new UARTTx(params))

val rx = Module(new UARTRx(params))

// 发送器连接

io.txd := tx.io.txd

tx.io.valid := io.txValid

tx.io.bits := io.txData

io.txReady := tx.io.ready

// 接收器连接

rx.io.rxd := io.rxd

io.rxValid := rx.io.valid

io.rxData := rx.io.bits

io.rxError := rx.io.error

rx.io.ready := io.rxReady

// 可选的环回测试模式

val loopback = RegInit(false.B)

when(loopback) {

rx.io.rxd := tx.io.txd

}

8. ChiselTest 单元测试实现

Chisel 的强大测试框架让我们能够构建全面的验证环境：

SCALA

// UARTUnitTests.scala

class UARTUnitTests extends AnyFlatSpec with ChiselScalatestTester {

"UART Tx" should "correctly transmit data" in {

test(new UARTTx(UARTParams(baudRate = 115200, clockFreq = 100000000))) { dut =>

// 测试初始化

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

dut.clock.step(10)

// 发送测试数据 0x55 (01010101)

dut.io.bits.poke(0x55.U)

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

// 等待发送器就绪信号变低

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

dut.clock.step(1)

}

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

// 验证起始位

dut.clock.step(434) // 半个比特周期

dut.io.txd.expect(false.B) // 应该是起始位

// 验证数据位传输

val expectedBits = "01010101" // LSB first

for (i <- 0 until 8) {

dut.clock.step(868) // 一个完整的比特周期

val expectedBit = expectedBits(i) == '1'

dut.io.txd.expect(expectedBit.B)

}

// 验证停止位

dut.clock.step(868)

dut.io.txd.expect(true.B)

}

"UART Rx" should "correctly receive data with noise" in {

test(new UARTRx(UARTParams(baudRate = 115200, clockFreq = 100000000))) { dut =>

// 模拟带噪声的UART信号

def sendBitWithNoise(bit: Boolean, noise: List[Int] = Nil): Unit = {

val baseValue = if (bit) 1 else 0

for (cycle <- 0 until 868) {

val value = if (noise.contains(cycle)) !bit else bit

dut.io.rxd.poke(value.B)

dut.clock.step(1)

}

// 发送起始位 + 数据 0xAA + 停止位

sendBitWithNoise(false) // 起始位

sendBitWithNoise(false, List(100, 200, 300)) // D0 with noise

sendBitWithNoise(true, List(150)) // D1 with noise

// ... 继续其他数据位

sendBitWithNoise(true) // 停止位

// 验证接收结果

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

dut.io.bits.expect(0xAA.U)

dut.io.error.expect(false.B) // 多数表决应该能纠正噪声

}

9. FPGA 实测与调试技巧

9.1 引脚约束与时钟管理

在 FPGA 项目中，正确的引脚约束至关重要：

TCL

# XDC 约束文件示例

set_property PACKAGE_PIN AB12 [get_ports {txd}]

set_property IOSTANDARD LVCMOS33 [get_ports {txd}]

set_property PACKAGE_PIN AB13 [get_ports {rxd}]

set_property IOSTANDARD LVCMOS33 [get_ports {rxd}]

# 时钟约束

create_clock -name sys_clk -period 10.000 [get_ports clk]

9.2 在线调试技巧

使用 FPGA 的 ILA（集成逻辑分析仪）进行调试：

VERILOG

// 添加 ILA 核用于调试

ila_0 u_ila (

.clk(clk),

.probe0(tx_state), // 发送器状态

.probe1(rx_state), // 接收器状态

.probe2(txd), // 发送数据线

.probe3(rxd), // 接收数据线

.probe4(tx_valid), // 发送有效信号

.probe5(rx_valid) // 接收有效信号

);

9.3 常见问题排查指南

问题现象	可能原因	排查方法
发送数据正确但接收不到	波特率不匹配	检查时钟频率和分频系数
接收数据出现帧错误	采样点偏移	调整采样点位置，检查时钟稳定性
随机误码	信号完整性问题	添加施密特触发器，检查PCB布局
只能单向通信	流控信号配置错误	检查RTS/CTS连接状态

10. 性能优化与扩展功能

10.1 FIFO 缓冲集成

为提升吞吐量，可以添加 FIFO 缓冲：

SCALA

class UARTWithFIFO(params: UARTParams, fifoDepth: Int = 16) extends Module {

val txFIFO = Module(new Queue(UInt(params.dataBits.W), fifoDepth))

val rxFIFO = Module(new Queue(UInt(params.dataBits.W), fifoDepth))

// FIFO 与 UART 核心的连接

txFIFO.io.enq <> io.txInterface

uart.io.txValid := txFIFO.io.deq.valid

uart.io.txData := txFIFO.io.deq.bits

txFIFO.io.deq.ready := uart.io.txReady

uart.io.rxReady := rxFIFO.io.enq.ready

rxFIFO.io.enq.valid := uart.io.rxValid

rxFIFO.io.enq.bits := uart.io.rxData

}

10.2 自动波特率检测

高级功能：实现自动波特率检测：

SCALA

class AutoBaudDetector extends Module {

// 通过测量起始位宽度自动检测波特率

def detectBaudRate(startPulseWidth: UInt): UInt = {

// 根据起始位宽度计算波特率

val clockCycles = startPulseWidth * 2 // 起始位是半个比特周期

val calculatedBaud = io.clockFreq / clockCycles

calculatedBaud

}

这个完整的 Chisel UART 实现展示了硬件设计语言在现代数字设计中的优势。通过参数化配置、强大的测试框架和模块化设计，我们构建了一个工程可用的通信核心。相比传统 Verilog，Chisel 让硬件设计更接近软件开发体验，同时保持了生成代码的性能和效率。

实际项目中，你可以基于这个基础框架继续扩展，比如添加 DMA 支持、多通道配置、或者更高级的错误纠正功能。这种设计方法也适用于其他通信协议如 SPI、I2C 的实现。