RT-Thread-浅析RT-Thread设备驱动框架RT-Thread问答社区

浅析RT-Thread设备驱动框架

发布于 2023-06-10 16:48:20 浏览：3286 订阅该版

[tocm]

# 浅析RT-Thread设备驱动框架

## 前言介绍

RT-Thread 设备框架属于**组件**和服务层，是基于 RT-Thread 内核之上的上层软件。设备框架是针对某一类外设，抽象出来的一套**统一的操作方法及接入标准**，可以屏蔽硬件差异，为应用层提供统一的操作方法。

RT-Thread 设备框架分为三层：**设备驱动层**、**设备驱动框架层**、**I/O 设备管理层**。其中设备驱动层直接对接底层硬件设备；I/O 设备管理层向应用层提供了rt_device_find、open、read、write、close、register等访问设备的统一标准接口。而设备驱动框架层就是就是将同类型硬件设备的共同特特征提取抽象出来，并且还预留了接口，可以添加不同设备的独有特性。

其中的设备模型被认为是一类对象，每个设备对象都是由基对象派生的，每个设备都可以继承其父类对象的属性，并派生其私有属性。

正是这样的框架，使得 RT-Thread 设备框架中各模块高内聚低耦合，对于已有的设备类型，只要将底层硬件的驱动对接到设备驱动层，就可以在应用程序中，调用统一的标准接口，使用的不同厂家不同类型的硬件设备。

## 示例分析

下文将以 CAN 设备为例，并从 void 类型指针、结构体等方向，分析 RT-Thread 设备驱动框架。

### 设备对象

以下是设备对象在 `rt-thread\include\rtdef.h` 中的具体定义：（去除了其中一些扩展的功能，方便理解）

```c
/**
 * Device structure
 */
struct rt_device
{
    struct rt_object          parent;                   /**< inherit from rt_object */
    enum rt_device_class_type type;                     /**< device type */
    rt_uint16_t               flag;                     /**< device flag */
    rt_uint16_t               open_flag;                /**< device open flag */
    rt_uint8_t                ref_count;                /**< reference count */
    rt_uint8_t                device_id;                /**< 0 - 255 */

/* device call back */
    rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
    rt_err_t (*tx_complete)(rt_device_t dev, void *buffer);

#ifdef RT_USING_DEVICE_OPS
    const struct rt_device_ops *ops;
#else
    /* common device interface */
    rt_err_t  (*init)   (rt_device_t dev);
    rt_err_t  (*open)   (rt_device_t dev, rt_uint16_t oflag);
    rt_err_t  (*close)  (rt_device_t dev);
    rt_ssize_t (*read)  (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
    rt_ssize_t (*write) (rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
    rt_err_t  (*control)(rt_device_t dev, int cmd, void *args);
#endif /* RT_USING_DEVICE_OPS */

void                     *user_data;                /**< device private data */
};
```

然后从 `struct rt_device` 中派生出新的 CAN 设备类型 `struct rt_can_device` ，其中依据 CAN 类型设备共有的特性新增了一些结构体成员，位于`rt-thread\components\drivers\include\drivers\can.h` 中：

```c
struct rt_can_device
{
    struct rt_device parent;

const struct rt_can_ops *ops;
    struct can_configure config;
    struct rt_can_status status;

rt_uint32_t timerinitflag;
    struct rt_timer timer;

struct rt_can_status_ind_type status_indicate;
#ifdef RT_CAN_USING_HDR
    struct rt_can_hdr *hdr;
#endif
#ifdef RT_CAN_USING_BUS_HOOK
    rt_can_bus_hook bus_hook;
#endif /*RT_CAN_USING_BUS_HOOK*/
    struct rt_mutex lock;
    void *can_rx;
    void *can_tx;
};
```

在 stm32 的 CAN 设备驱动中，又从 `struct rt_can_device` 中派生出了新的 CAN 设备模型 `struct stm32_can` 其中添加了这个设备类型的私有数据，便于底层驱动的对接：

```C
/* stm32 can device */
struct stm32_can
{
    char *name;
    CAN_HandleTypeDef CanHandle;
    CAN_FilterTypeDef FilterConfig;
    struct rt_can_device device;     /* inherit from can device */
};
```

可以看出，RT-Thread 通过结构体和函数指针使用 C 语言实现了一些面向对象编程的特性，如封装和继承等，这样面向对象、模块化的思维框架，有助于实现各模块之间高内聚低耦合，提高开发效率。

### 操作方法

在 `rt-thread\components\drivers\include\drivers\can.h` 中可以看到针对 CAN 设备有以下操作方法，这些操作方法是需要我们在设备驱动层去针对不同的硬件设备进行对接实现的。对于一些特殊的设备类型，可以不用对接其所有的操作方法。

```c
struct rt_can_ops
{
    rt_err_t (*configure)(struct rt_can_device *can, struct can_configure *cfg);
    rt_err_t (*control)(struct rt_can_device *can, int cmd, void *arg);
    int (*sendmsg)(struct rt_can_device *can, const void *buf, rt_uint32_t boxno);
    int (*recvmsg)(struct rt_can_device *can, void *buf, rt_uint32_t boxno);
};
```

在`libraries\HAL_Drivers\drv_can.c`中，就实现了所有 CAN 设备的操作方法，并赋值给对应的函数指针，可以直接调用。并且通过 `static const` 修饰符，使结构体变量`_can_ops`的值在编译时被确定，并且不能在程序运行时修改。这样可以确保该结构体变量的内容是固定的，提高了代码的安全性和可维护性。然后通过`rt_hw_can_register`注册。

```c
static const struct rt_can_ops _can_ops =
{
    _can_config,
    _can_control,
    _can_sendmsg,
    _can_recvmsg,
};

/* register CAN1 device */
rt_hw_can_register(&drv_can1.device,
                       drv_can1.name,
                       &_can_ops,
                       &drv_can1);
```

可以看一下`rt_hw_can_register`函数的具体声明：

```
rt_err_t rt_hw_can_register(struct rt_can_device    *can,
                            const char              *name,
                            const struct rt_can_ops *ops,
                            void                    *data);
```

其中最后一个参数为 void 类型指针，在注册同类型的不同设备时，就可以通过最后一个参数，在注册时传入其特有的私有数据。例如 STM32 的 drv_can 中传入的就是 `stm32_can`结构体类型，其中就包含了 stm32 can 的私有数据域，在对接底层硬件驱动的时候就会方便很多。

## 总结

可以感受到，其中结构体和指针的运用是非常重要的。尽管C语言是一种面向过程的语言，但通过使用结构体和函数指针，可以模拟实现封装、继承和多态这三个面向对象编程的特性，享受面向对象编程的好处。

对于指针的运用，主要是 **void 类型指针**和**函数指针**。由于 void 指针没有特定的类型，因此它可以指向任何类型的数据。也就是说，任何类型的指针都可以直接赋值给 void 指针，而无需进行其他相关的强制类型转换，便于传递同类型的不同设备的私有数据。通过函数指针，也就是回调函数，可以大大提高程序的灵活性和并起到封装的作用。

这些优秀的思想是值得我们学习和借鉴的。

## 题外话

最近写了一个可以生成 RT-Thread 外设驱动模板文件的脚本，并且**开源**啦！

欢迎各位想要对接外设驱动的小伙伴们使用体验，还有很多的不足的地方，欢迎大家贡献PR

仓库链接：[RTT_drv_template_generator ](https://github.com/Z8MAN8/RTT_drv_template_generator)

要是觉得做的还不错，请给个小星星支持一下！