📚 课程目录第4章外设建模基础

4. 外设建模基础：GPIO外设的建模，寄存器映射与读写回调

好，我们开始进入外设建模的实战环节。这一章，我打算拿GPIO开刀。为什么选GPIO？因为它简单，又足够典型。你想想看，几乎每个嵌入式系统都有GPIO，它麻雀虽小五脏俱全——有寄存器、有中断、有输入输出状态。搞懂了GPIO的建模，其他外设无非是寄存器更多、逻辑更复杂而已。

我个人习惯，建模一个新外设之前，先画一张图，把脑子里面的结构理清楚。下面这张图，就是GPIO外设在Renode里的核心模型。

4.1 从寄存器映射开始

在Renode里建模外设，第一步就是定义寄存器映射。说白了，就是告诉模拟器：这个外设占用哪段地址空间，每个地址对应什么寄存器。

我早期犯过一个错误——把寄存器地址写死在一个大数组里，结果调试的时候发现地址对不上，查了半天。后来我学乖了，用Renode提供的 RegisterCollection 来管理，清晰又不容易出错。

来看一个典型的GPIO寄存器定义：

// GPIO寄存器偏移定义
public class GpioRegisters
{
    // 数据寄存器：0x00
    public const long Data = 0x00;
    // 方向寄存器：0x04，0=输入，1=输出
    public const long Direction = 0x04;
    // 上拉使能寄存器：0x08
    public const long PullUp = 0x08;
    // 中断使能寄存器：0x0C
    public const long InterruptEnable = 0x0C;
    // 中断状态寄存器：0x10
    public const long InterruptStatus = 0x10;
}

我的习惯：寄存器偏移用 const long 定义，而不是 enum。因为 Renode 的 RegisterCollection 索引需要 long 类型，用 enum 还得强转，多此一举。

有了偏移定义，接下来就是注册这些寄存器到外设的总线空间。这一步通常在构造方法里完成：

public class GpioPeripheral : IPeripheral
{
    private readonly RegisterCollection _registers;

    public GpioPeripheral(Machine machine)
    {
        // 定义寄存器集合：每个寄存器32位，小端模式
        _registers = new RegisterCollection(
            new[] {
                new Register(GpioRegisters.Data, 32, Endianess.LittleEndian),
                new Register(GpioRegisters.Direction, 32, Endianess.LittleEndian),
                new Register(GpioRegisters.PullUp, 32, Endianess.LittleEndian),
                new Register(GpioRegisters.InterruptEnable, 32, Endianess.LittleEndian),
                new Register(GpioRegisters.InterruptStatus, 32, Endianess.LittleEndian)
            }
        );
    }
}

4.2 读写回调：让寄存器“活”起来

寄存器映射只是搭了个架子。真正让外设工作的，是读写回调。你想想看，如果写一个寄存器只是存个值，那跟内存有什么区别？外设的精髓在于——写寄存器要触发动作，读寄存器要返回状态。

Renode里实现回调很简单，注册 ReadHandler 和 WriteHandler 就行。我拿方向寄存器举个例子：

// 在构造方法中注册回调
_registers[GpioRegisters.Direction].WriteHandler = (offset, value) =>
{
    // 保存方向值
    _direction = (uint)value;
    
    // 遍历每个引脚，更新方向
    for (int i = 0; i < 32; i++)
    {
        bool isOutput = ((_direction >> i) & 0x1) == 1;
        _pins[i].SetDirection(isOutput);
    }
    
    // 输出调试信息
    Log.Info($"GPIO方向寄存器更新: 0x{_direction:X8}");
};

_registers[GpioRegisters.Direction].ReadHandler = (offset) =>
{
    // 读方向寄存器，返回当前方向值
    return _direction;
};

  关键点：写回调里一定要做“副作用”——更新引脚状态、触发中断、改变输出电平。如果写回调只是存个值，那你的外设就是个假外设。

4.3 引脚状态管理

GPIO的核心是引脚。每个引脚有方向、有电平、还可能触发中断。我习惯用一个 Pin 类来封装：

public class GpioPin
{
    public int Index { get; }
    public bool IsOutput { get; private set; }
    public bool Level { get; private set; }  // true=高, false=低
    public bool InterruptEnabled { get; set; }
    
    // 中断触发模式
    public InterruptTrigger TriggerMode { get; set; }
    
    // 中断回调
    public Action<int> InterruptTriggered;
    
    public GpioPin(int index)
    {
        Index = index;
        IsOutput = false;
        Level = false;
    }
    
    public void SetDirection(bool output)
    {
        IsOutput = output;
        // 如果是输出引脚，初始化为低电平
        if (output) Level = false;
    }
    
    public void SetLevel(bool level)
    {
        bool previous = Level;
        Level = level;
        
        // 检查是否触发中断
        if (InterruptEnabled)
        {
            CheckInterrupt(previous, level);
        }
    }
    
    private void CheckInterrupt(bool oldLevel, bool newLevel)
    {
        bool shouldTrigger = false;
        
        switch (TriggerMode)
        {
            case InterruptTrigger.RisingEdge:
                shouldTrigger = !oldLevel && newLevel;
                break;
            case InterruptTrigger.FallingEdge:
                shouldTrigger = oldLevel && !newLevel;
                break;
            case InterruptTrigger.BothEdges:
                shouldTrigger = oldLevel != newLevel;
                break;
            case InterruptTrigger.LevelHigh:
                shouldTrigger = newLevel;
                break;
            case InterruptTrigger.LevelLow:
                shouldTrigger = !newLevel;
                break;
        }
        
        if (shouldTrigger)
        {
            InterruptTriggered?.Invoke(Index);
        }
    }
}

我曾经踩过的坑：中断触发条件判断时，一定要用旧值和新值做比较，而不是直接用当前值。特别是边沿触发，必须知道电平变化的方向。我第一次写的时候忘了保存旧值，结果上升沿和下降沿都触发了，调试了半天才发现。

4.4 完整的数据流：从写寄存器到引脚变化

把上面几块拼起来，一个完整的GPIO写操作流程是这样的：

步骤	动作	说明
1	CPU写地址 0x04	写方向寄存器，value=0x00000001
2	Renode总线解码	匹配到GPIO外设地址范围
3	调用WriteHandler	触发方向寄存器的写回调
4	更新_direction变量	保存方向值
5	遍历引脚设置方向	引脚0设为输出，其余为输入
6	引脚状态变化	输出引脚初始化为低电平
7	（可选）触发中断	如果中断使能且条件满足

你看，一个简单的写操作，背后是一连串的连锁反应。这就是外设建模的魅力——你写的每一行回调代码，都在模拟真实硬件的行为。

4.5 注册外设到系统总线

模型写好了，怎么让Renode知道它？需要在平台描述文件（.repl或.cs）里注册：

// 在平台初始化代码中
machine.PeripheralsBus.Register(
    new GpioPeripheral(machine),
    new BusRangeRegistration(0x40020000, 0x1000)  // 占用4KB地址空间
);

地址范围怎么定？我建议参考真实芯片的手册。比如STM32的GPIOA基址是0x40020000，我就用这个地址。这样驱动代码不用改，直接跑在模拟器上。

小技巧：地址范围不要只给寄存器需要的空间，稍微多给一点（比如4KB），方便以后扩展。反正模拟器里不浪费物理内存。

4.6 验证你的模型

模型建好了，怎么知道对不对？我的做法是写一个简单的测试脚本：

// 测试：写方向寄存器，然后读回来验证
machine.PeripheralsBus.WriteDoubleWord(0x40020004, 0x00000001);
uint value = machine.PeripheralsBus.ReadDoubleWord(0x40020004);
Assert.AreEqual(0x00000001, value, "方向寄存器读写不一致");

// 测试：写数据寄存器，检查引脚状态
machine.PeripheralsBus.WriteDoubleWord(0x40020000, 0x000000FF);
// 这里应该看到引脚0-7输出高电平

嗯，这一步很重要。我见过太多人模型写完了直接跑驱动，出了问题都不知道是模型的问题还是驱动的问题。先单独测模型，再联调驱动，能省一半的调试时间。

4.7 本章小结

GPIO建模的核心就三件事：寄存器映射、读写回调、引脚状态管理。你把这个流程走通了，其他外设——UART、SPI、I2C——无非是寄存器更多、回调逻辑更复杂。底子是一样的。

我个人觉得，外设建模最难的不是写代码，而是想清楚“真实硬件在这个时刻做了什么”。你模拟的不是寄存器值的变化，而是硬件行为的变化。把这个想明白了，你就是半个芯片设计工程师了。