Renode 入门学习指南：从零理解嵌入式系统仿真

本文面向零基础读者，系统介绍 Renode —— 一款由 Antmicro 开发的开源嵌入式系统仿真框架。你将了解它的核心概念、架构设计、安装方法、基本用法以及自动化测试流程，并能动手搭建自己的第一个仿真平台。

Renode 官方网站

一、什么是 Renode？

Renode 是一款由波兰公司 Antmicro 自 2010 年起开发、并于 2015 年开源的嵌入式系统仿真框架。它能够让你在 PC 上创建虚拟的片上系统（SoC），运行未经修改的嵌入式固件，进行开发、调试和测试，而无需依赖真实硬件Renode。

简单来说，Renode 就像是"嵌入式世界的 Docker"——你用文本文件描述硬件平台（CPU、内存、外设），然后加载固件二进制文件，就能在虚拟硬件上运行和测试你的嵌入式软件Antmicro · Renode。

一句话理解：Renode 让你在电脑上模拟出一块嵌入式开发板，运行真实固件，做开发、调试和自动化测试。

1.1 为什么需要 Renode？

嵌入式开发面临几个常见痛点：

1.2 谁在使用 Renode？

Renode 已被众多知名项目和公司采用Renode：

• Google — TensorFlow Lite Micro 的 CI 测试依赖 Renode 进行 Arm 和 RISC-V 设备仿真

• Zephyr RTOS — 通过 Twister + Renode + Robot Framework 构建高级测试套件

• Microchip — PolarFire SoC FPGA 的预硅片软件开发和 RISC-V 平台仿真

• OpenTitan — 开源安全芯片的完整 SoC 仿真验证

• QuickLogic — FPGA 低功耗嵌入式平台的仿真开发

"Renode gives us integrated software emulation for a lot of Arm and RISC-V devices, and we rely it for our testing."

— Pete Warden, TensorFlow Mobile/Embedded Team Lead, Google

二、Renode 的核心特性

完全确定性

同一仿真脚本 + 同一输入，永远产生相同输出。偶发 bug 可 100% 复现。

文本化平台描述

用 .repl 文件描述硬件拓扑，无需修改源码即可搭建自定义 SoC。

多节点仿真

一台 PC 模拟多个互连设备，支持有线/无线网络组网测试。

透明调试

支持 GDB 连接、执行追踪、覆盖率分析、性能指标采集。

2.1 支持的 CPU 架构

2.2 支持的外设类型

Renode 内置了大量外设模型，并支持通过 Python 自定义外设行为Renode 文档：

2.3 关键能力一览

三、核心概念与架构

3.1 Renode 的世界模型

理解 Renode 需要掌握几个核心概念：

3.2 文件类型速查

3.3 仿真执行流程

四、安装 Renode

前置要求：Renode 基于 .NET 运行，需要安装 .NET 8.0 或更高版本。Python 3 用于自定义外设和 Robot Framework 测试。

4.1 Linux 安装

Antmicro 提供了多种 Linux 安装包Renode GitHub：

安装完成后验证：

renode --version

4.2 Windows 安装

下载 renode-latest.setup.exe 安装程序，双击安装即可。安装包可从 builds.renode.io 获取Renode GitHub。

4.3 从源码构建

git clone https://github.com/renode/renode.git
cd renode
dotnet build src/Renode/Renode.csproj

4.4 Docker 方式运行

docker run --rm -it -v $(pwd):/data ghcr.io/renode/renode:latest \
  renode --console /data/run.resc

五、快速上手：运行第一个 Demo

5.1 启动 Renode

renode

你将看到 Renode Monitor 的命令行提示符 (monitor)。这里可以输入各种命令来创建和控制仿真环境。

5.2 加载内置 Demo 平台

Renode 内置了大量预置平台脚本，可以直接运行。例如启动一个 STM32F4 Discovery 板的仿真：

(monitor) start @scripts/single-node/stm32f4discovery.resc

这条命令会：

1. 创建一个新的虚拟机器

2. 加载 STM32F4 的平台描述（CPU、Flash、RAM、UART 等）

3. 加载示例固件

4. 启动仿真执行

5.3 查看 UART 输出

(monitor) showAnalyzer sysbus.uart2

这将打开一个 UART 输出窗口，你可以看到固件通过串口打印的日志信息。

5.4 常用 Monitor 命令

六、平台描述文件 (.repl)

.repl 文件是 Renode 的核心——它用简洁的文本语法描述了整个虚拟硬件平台。你不需要写 C 代码，只需用声明式语法"组装"你的 SoCRenode 文档 - Describing Platforms。

6.1 基本语法结构

uart0: UART.PL011 @ sysbus 0x40002000
    IRQ -> gic@0  # 中断连接
    frequency: 100000000

gic: IRQController.GIC @ sysbus 0x40001000

timer0: Timers.SP804 @ sysbus 0x40004000
    IRQ -> gic@1
    frequency: 100000000

flash: Memory.MappedMemory @ sysbus 0x08000000
    size: 0x100000

ram: Memory.MappedMemory @ sysbus 0x20000000
    size: 0x40000

6.2 语法要素解析

6.3 一个最小 RISC-V 平台示例

cpu: CPU.RiscV32 @ sysbus
    cpuType: "rv32i"
    timeProvider: "clint"

clint: IRQController.RISC-V_CLINT @ sysbus 0x02000000
    frequency: 100000000

ram: Memory.MappedMemory @ sysbus 0x80000000
    size: 0x1000000

uart: UART.NS16550A @ sysbus 0x10000000
    IRQ -> plic@10
    frequency: 1843200

plic: IRQController.RISC-V_PLIC @ sysbus 0x0c000000

解读：这个平台包含一个 RV32I CPU、一个 CLINT 定时器、一个 PLIC 中断控制器、16MB RAM 和一个 NS16550A 串口。固件加载到 0x80000000 处运行，通过 0x10000000 的串口输出日志。

七、启动脚本 (.resc)

.resc 文件是 Renode 的"一键启动"脚本，把加载平台、加载固件、打开分析器等操作串联起来Renode 文档 - Using Renode。

:name: My RISC-V Demo
:description: 最小 RISC-V 平台演示

mach create
machine LoadPlatformDescription @platform.repl

sysbus LoadELF @hello.elf
showAnalyzer uart

start

运行方式：

renode run.resc

或从 Monitor 中执行：

(monitor) i @run.resc

八、GDB 调试

Renode 内置 GDB server，可以让你用 GDB 或 VS Code 连接仿真环境进行调试Renode 文档 - GDB。

8.1 启动 GDB Server

(monitor) machine StartGdbServer 3333

8.2 用 GDB 连接

riscv64-unknown-elf-gdb hello.elf
(gdb) target remote :3333
(gdb) break main
(gdb) continue
(gdb) info registers
(gdb) x/16x 0x80000000
(gdb) stepi

8.3 VS Code 集成

Renode 也支持在 VS Code 中进行可视化调试，配置 launch.json 中的 remote target 即可连接 Renode 的 GDB ServerRenode 文档 - VS Code。

九、自动化测试：Robot Framework

这是 Renode 最强大的能力之一——内置 Robot Framework 集成，让嵌入式固件测试像 Web 测试一样自动化、可 CIRenode 文档 - Testing。

9.1 为什么用 Robot Framework？

传统方式

人工接板子 → 烧录固件 → 肉眼看串口 → 手动判断结果

Renode + Robot

自动加载平台 → 加载固件 → 监听 UART → 自动断言 PASS/FAIL

9.2 编写测试脚本

*** Settings ***
Suite Setup       Setup
Suite Teardown    Teardown

*** Test Cases ***
Should Print Hello
    Execute Command          mach create
    Execute Command          machine LoadPlatformDescription @platform.repl
    Execute Command          sysbus LoadELF @hello.elf
    Create Terminal Tester   sysbus.uart
    Start Emulation
    Wait For Line On Uart    Hello, Renode!

9.3 运行测试

renode-test hello_test.robot

输出示例：

==============================================================================
hello_test :: Should Print Hello
==============================================================================
Should Print Hello                                                  | PASS |
------------------------------------------------------------------------------
hello_test :: Should Print Hello                                    | PASS |
1 critical test, 1 passed, 0 failed
==============================================================================

9.4 常用 Robot 关键词

9.5 在 GitHub Actions 中使用

Antmicro 提供了官方 GitHub Action，可以在 CI 中直接运行 Renode 测试renode-test-action：

steps:
- uses: actions/checkout@v4
- uses: antmicro/renode-test-action@v5
  with:
    renode-revision: 'master'
    tests: 'tests/hello_test.robot'
    results-dir: 'test-results'

十、高级功能

10.1 执行追踪与性能分析

Renode 可以记录仿真执行过程中的指令级追踪信息，用于性能分析和调试Renode 文档 - Execution Tracing：

(monitor) cpu EnableExecutionTracing "trace.txt" PC
(cpu) start
# ... 运行一段时间 ...
(cpu) pause

追踪数据包括：

• 每条指令的 PC 地址和反汇编

• 寄存器读写

• 内存访问

• 外设访问

10.2 指标采集

(monitor) cpu EnableMetricsCounting
(cpu) start
# ... 运行程序 ...
(cpu) pause
(cpu) cpu GetMetrics

可采集的指标包括Renode 文档 - Metrics：

• 已执行指令总数

• 内存访问次数（按区域分类）

• 外设访问次数

• 中断处理次数和耗时

10.3 覆盖率报告

Renode 可以生成代码覆盖率报告，帮助评估测试完备性Renode 文档 - Coverage：

(monitor) cpu EnableExecutionTracing "trace.txt" PC
(cpu) start
# ... 运行全部测试 ...
(cpu) pause
(cpu) cpu SaveCoverageReport "coverage.xml"

10.4 多节点仿真

Renode 支持在一台 PC 上同时运行多个互连的虚拟设备，模拟无线/有线网络场景Renode 文档 - Networking：

(monitor) mach create "device1"
(monitor) machine LoadPlatformDescription @device1.repl
(monitor) mach create "device2"
(monitor) machine LoadPlatformDescription @device2.repl
(monitor) connector connect device1.uart device2.uart

10.5 传感器数据注入 (RESD)

Renode 支持 RESD（Renode Sensor Data Format），可以向仿真环境注入预录的传感器数据流Renode 文档 - RESD：

accelerometer: Sensors.Accelerometer @ sysbus 0x40008000
    sampleFile: @sensor_data.resd

10.6 Co-simulation（联合仿真）

Renode 支持与 Verilator 联合仿真，将 RTL 模块接入 Renode 的系统环境。这使得硬件/软件协同开发成为可能——软件团队用 Renode 跑固件，硬件团队用 Verilator 验证 RTL，两者在同一仿真环境中交互Renode 文档。

十一、实战：搭建最小 RISC-V 仿真平台

目标：搭建一个最小 RV32I 平台，运行 Hello World 固件，并用 Robot Framework 做自动化测试。

11.1 项目结构

riscv-renode-hello/
├── platform.repl      # 平台描述文件
├── run.resc           # 启动脚本
├── firmware/
│   ├── start.S        # 启动汇编
│   ├── hello.c        # Hello World C 代码
│   ├── linker.ld      # 链接脚本
│   └── Makefile       # 编译脚本
└── tests/
    └── hello.robot    # Robot Framework 测试

11.2 平台描述文件

cpu: CPU.RiscV32 @ sysbus
    cpuType: "rv32i"

ram: Memory.MappedMemory @ sysbus 0x80000000
    size: 0x1000000

uart: UART.NS16550A @ sysbus 0x10000000
    frequency: 1843200

11.3 启动脚本

:name: RISC-V Hello Demo
:description: 最小 RV32I 平台 Hello World

mach create
machine LoadPlatformDescription @platform.repl
sysbus LoadELF @firmware/hello.elf
showAnalyzer uart
start

11.4 最小固件

#define UART_TX  (*(volatile unsigned int *)0x10000000)

void putchar(char c) {
    UART_TX = c;
}

void puts(const char *s) {
    while (*s) putchar(*s++);
}

void main() {
    puts("Hello, Renode!\n");
    while (1) {}
}

.section .text.start
.global _start
_start:
    la sp, _stack_top
    call main
1:  j 1b

ENTRY(_start)
MEMORY {
    RAM (rwx) : ORIGIN = 0x80000000, LENGTH = 16M
}
SECTIONS {
    .text : { *(.text.start) *(.text*) } > RAM
    .rodata : { *(.rodata*) } > RAM
    .data : { *(.data*) } > RAM
    .bss : { *(.bss*) *(COMMON) } > RAM
}

11.5 编译固件

riscv64-unknown-elf-gcc -march=rv32i -mabi=ilp32 \
  -nostdlib -T linker.ld start.S hello.c -o hello.elf

11.6 运行和测试

renode run.resc

*** Settings ***
Suite Setup       Setup
Suite Teardown    Teardown

*** Test Cases ***
Should Print Hello
    Execute Command          mach create
    Execute Command          machine LoadPlatformDescription @platform.repl
    Execute Command          sysbus LoadELF @firmware/hello.elf
    Create Terminal Tester   sysbus.uart
    Start Emulation
    Wait For Line On Uart    Hello, Renode!

renode-test tests/hello.robot

十二、学习路径与资源推荐

12.1 推荐学习路径

12.2 官方资源

12.3 社区与学习材料

• Antmicro 博客 — 定期发布 Renode 新版本和新功能文章：antmicro.com/blog

• Renode 示例仓库 — 简单的 STM32 + Robot Framework 测试示例：renode-example

• Firmware Testing with Renode — 详细的入门教程：Interrupt 博客

• 内置平台脚本 — Renode 安装后自带大量 .resc 脚本，位于 scripts/single-node/ 和 scripts/multi-node/ 目录

12.4 常见问题

Q: Renode 是周期精确的仿真器吗？

A: 不是。Renode 是功能级仿真器，不模拟时钟周期的精确时序。但它提供确定性的执行和指令级追踪，可以通过 TBM 等工具进行性能估计。

Q: Renode 和 QEMU 有什么区别？

A: Renode 更侧重于系统级仿真和自动化测试，原生支持多节点组网、Robot Framework 集成和 CI 工作流。QEMU 更侧重于运行完整操作系统和性能。两者可以互补使用。

Q: Renode 能仿真我自己设计的 CPU 吗？

A: 可以通过 Co-simulation 方式将你的 RTL（通过 Verilator）接入 Renode 系统。也可以用 Python 自定义外设模型。Renode 内置的 CPU 模型是功能级的，不包含你自定义的微结构细节。

Q: Renode 支持运行 Linux 吗？

A: 支持。例如 PolarFire SoC Icicle Kit 的仿真可以运行完整的 Yocto-based Linux，包括 bootloader 流程。

十三、总结

Renode 是一款强大的开源嵌入式系统仿真框架，它的核心价值在于：

如果你正在做嵌入式开发、RISC-V CPU 验证或 IoT 设备测试，Renode 是一个非常值得学习和使用的工具。从运行内置 Demo 开始，逐步学会自定义平台、编写固件、搭建自动化测试，你会发现嵌入式开发也可以像 Web 开发一样高效和可自动化。

十四、深入理解：Renode 的 SoC 仿真机制

本章节深入剖析 Renode 如何模拟 SoC 中的 CPU、RAM、系统总线和外设，并详细对比 Renode 指令仿真与 QEMU TCG 的技术差异，帮助读者理解 Renode 的内部工作原理。

14.1 Renode 如何模拟 CPU

Renode 的 CPU 仿真核心是一个名为 tlib（Translation Library）的 C 语言库，它负责目标架构指令的解码、翻译和执行。tlib 与 Renode 的 C# 框架层通过 FFI（Foreign Function Interface）交互，形成一个分层的执行架构[1](https://github.com/renode/renode/issues/242)。

14.1.1 tlib 的工作流程

tlib 采用动态二进制翻译（DBT）方式执行目标指令，其流程分为以下阶段：

值得注意的是，tlib 的取指操作通过 MappedMemory 的原始 C 指针直接读取，不经过 C# 层，因此不存在副作用和时序问题。只有当 CPU 访问的地址不在 MappedMemory 范围内时，请求才会被转发到 C# 层的系统总线，由外设模型处理[2](https://github.com/renode/renode/issues/242#issuecomment-915979230)。

14.1.2 CPU 状态管理

Renode 的 CPU 模型维护完整的处理器状态：

14.1.3 自定义指令与扩展

Renode 允许用户通过 Python 或 C# 添加自定义 RISC-V 指令和 CSR，甚至可以通过 Verilator 直接从 RTL 代码仿真 CPU 核心[3](https://renode.io/news/cpu-rtl-co-simulation-in-renode/)。这种灵活性使 Renode 能够支持尚未标准化的 ISA 扩展和自定义处理器 IP。

14.2 Renode 如何模拟 RAM（内存）

Renode 的内存模型采用双接口设计，根据访问来源不同提供不同路径：

14.2.1 MappedMemory：执行接口

当 CPU 需要取指或执行内存访问时，tlib 通过 MappedMemory 提供的原始 C 指针直接读取内存数据。这条路径完全在 C 层完成，不经过 C# 运行时，保证了指令执行的高效性[4](https://github.com/renode/renode/issues/242)。

14.2.2 C# 读写接口：外设交互接口

当其他外设（如 DMA 控制器）或调试器需要访问内存时，请求通过 C# 层的 IBytePeripheral / IWordPeripheral / IDoubleWordPeripheral 接口完成。这条路径经过完整的 Renode 框架，支持日志记录、断点检查等功能。

14.2.3 内存类型支持

14.3 Renode 如何模拟 SysBus（系统总线）

系统总线（sysbus）是 Renode SoC 模型的核心枢纽。当虚拟机创建后，它首先只包含一个组件——sysbus，此时没有 CPU 也没有内存，机器无法执行任何代码[5](https://www.mdpi.com/2673-4591/79/1/52)。

14.3.1 sysbus 的角色与职责

sysbus 在 Renode 中承担以下核心职责：

14.3.2 单总线简化模型

真实 SoC 可能使用复杂的总线层次结构（如 AHB/APB 分离、多层总线矩阵）。Renode 将其简化为单一 sysbus，所有外设都连接到这一个总线上。这种简化不影响仿真行为的正确性，因为总线互联结构对软件是透明的——软件只关心地址映射，不关心总线拓扑[6](https://renode.io/news/simulating-socs-with-isolated-address-spaces-in-renode/)。

14.3.3 地址隔离（高级特性）

对于需要安全隔离的场景，Renode 也支持地址空间隔离——为不同 CPU 核心创建各自专属的内存区域，通过 BusPointRegistration 指定 CPU 绑定关系，确保只有特定 CPU 才能访问对应内存[7](https://renode.io/news/simulating-socs-with-isolated-address-spaces-in-renode/)。

14.4 Renode 如何模拟外设

外设是 SoC 仿真的重要组成部分。Renode 的外设模型用 C# 编写，实现标准的读写接口，并可以模拟寄存器行为、中断生成、状态机等复杂逻辑[8](https://renode.readthedocs.io/en/latest/advanced/writing-peripherals.html)。

14.4.1 外设的接口层级

14.4.2 寄存器建模

Renode 提供了强大的寄存器描述框架，允许开发者以声明式方式定义寄存器的位域行为：

14.4.3 中断机制

外设通过 GPIO（General Purpose I/O） 连接向 CPU 传递中断：

1. 外设在 .repl 中声明 IRQ 输出：-> cpu@0

2. 外设 C# 代码中通过 irq.Set(true) 触发中断

3. CPU 收到中断信号后，根据中断向量表跳转到中断处理程序

4. 处理完成后，外设清除中断：irq.Set(false)

14.4.4 外设模型自动生成

为避免手工编写寄存器布局，Renode 提供了 peakrdl-renode 工具，可以从 SystemRDL 文件自动生成外设的 C# 骨架代码，开发者只需补充行为逻辑[9](https://github.com/renode/renode-docs/blob/master/source/advanced/writing-peripherals.md)。

14.4.5 外设仿真的深度建模

14.5 Renode 指令仿真 vs QEMU TCG：技术对比

Renode 和 QEMU 都支持跨架构 CPU 仿真，但两者的指令执行引擎在设计哲学上有根本差异。Renode 使用自研的 tlib（C 语言翻译库），而 QEMU 使用 TCG（Tiny Code Generator）作为其动态翻译后端[10](https://www.qemu.org/docs/master/devel/tcg.html)。

14.5.1 QEMU TCG 的工作原理

QEMU 的 TCG 是一个JIT（Just-In-Time）编译器，其工作流程为：

TCG 的核心特点是生成宿主机原生机器码并直接执行。翻译后的代码被缓存在内存中，后续再次执行同一代码块时直接跳转到缓存的机器码，无需重新翻译[11](https://airbus-seclab.github.io/qemu_blog/tcg_p2.html)。

14.5.2 Renode tlib 的工作原理

Renode 的 tlib 同样使用动态二进制翻译，但翻译结果和执行方式有所不同：

14.5.3 核心差异对比

14.5.4 为什么 Renode 选择不使用 JIT？

设计哲学差异：QEMU 的目标是最大化执行速度，适合运行完整操作系统和复杂应用。Renode 的目标是精确仿真和可调试性，适合嵌入式固件开发、测试和验证。两者的目标用户和使用场景不同，导致了技术路线的分歧。

Renode 选择解释执行而非 JIT 编译的原因包括：

1. 确定性优先：嵌入式系统测试要求每次执行结果完全一致。JIT 编译的 TB 缓存命中顺序、多线程调度等因素会引入不确定性，而 Renode 的解释执行保证了完全可重现的仿真行为[12](https://renode.io/)。

2. 调试粒度：解释执行允许在每条指令执行前后检查 CPU 状态、内存内容和外设寄存器。QEMU 的 JIT 代码一旦生成，单步调试的粒度只能到 TB 级别。

3. 外设交互精度：嵌入式系统频繁访问外设寄存器，每次访问都可能产生副作用。Renode 的架构确保每个外设访问都经过完整的框架处理，不会因 JIT 优化而遗漏副作用。

4. 跨平台一致性：不生成宿主机机器码意味着 Renode 在不同宿主机架构上的行为完全一致，这对于 CI/CD 中的可重现测试至关重要。

5. 安全性：JIT 编译需要分配可执行内存（W^X 策略的例外），在某些受限环境中不被允许。Renode 无此限制。

14.6 Renode vs QEMU：全面对比

除了指令仿真引擎的差异，Renode 和 QEMU 在定位、功能和使用场景上也存在显著区别。

14.6.1 定位与设计目标

14.6.2 功能对比

14.6.3 SoC 建模方式对比

14.6.4 架构图对比

14.6.5 何时选择 Renode，何时选择 QEMU？

选择 Renode 的场景：Cortex-M / RISC-V MCU 固件开发；需要精确外设仿真和中断行为；需要完全确定性的 CI 测试；多节点设备网络仿真；芯片预研阶段需要快速搭建 SoC 原型；需要从 SVD/SystemRDL 自动生成外设模型。

选择 QEMU 的场景：运行完整 Linux 系统；需要高性能虚拟化（KVM）；Cortex-A 级别的 SoC 仿真；桌面/服务器操作系统开发；需要运行大型软件栈；需要硬件虚拟化加速。

14.7 小结

Renode 的 SoC 仿真机制可以概括为：tlib 负责指令翻译和执行，MappedMemory 提供高效内存访问，sysbus 作为中央枢纽连接所有组件，C# 外设模型提供丰富的行为模拟。这种分层设计在保证仿真精度的同时提供了足够的灵活性。

与 QEMU TCG 相比，Renode 牺牲了执行速度，换来了完全的确定性、指令级调试可见性和精确的外设交互。这使得 Renode 在嵌入式固件开发、MCU 测试和芯片预研等场景中具有不可替代的价值，而 QEMU 仍然是运行完整操作系统和高性能虚拟化的首选工具[13](https://renode.io/)。

两者并非竞争关系，而是互补关系：Renode 负责 MCU 级固件仿真和测试，QEMU 负责系统级 OS 仿真。在完整的嵌入式开发流程中，两者可以协同使用，覆盖从固件到操作系统的全栈仿真需求。

（注：部分内容可能由 AI 生成）

Share on: Twitter ❄ Facebook ❄ Email