RT-Thread-《RT-Thread设备驱动开发指南》—— 基础篇之第1章RT-Thread与设备驱动框架简介RT-Thread问答社区

《RT-Thread设备驱动开发指南》—— 基础篇之第1章RT-Thread与设备驱动框架简介

发布于 2023-06-13 11:33:33 浏览：6578 订阅该版

[tocm]

### 感谢
  感谢**架构师李肯**的赠书！！！
### RT-Thread设备驱动开发指南内容简介
  RT-Thread设备驱动开发指南是由RT-Thread核心开发者撰写，专业性强。该书系统系统讲解了RT-Thread设备驱动开发方法，助力开发者快速掌握RT-Thread设备驱动开发技能。
  该书内容共27章，分为三篇。
  基础篇（第1~11章），对RT-Thread以及设备驱动框架进行总体介绍，再分别介绍RT-Thread中常用的设备包括PIN，I2C，SPI等，适合刚接触驱动开发的人学习。
  进阶篇（第12~20章），介绍稍复杂一些的外设驱动，如SDIO、触摸、显示、传感器、加解密设备等。
  高级篇（第21~27章），介绍复杂的驱动，如网络、音频、USB、CAN等，开发此类设备驱动要求开发者本身对相应的外设协议比较熟悉。
### 基础篇
  第1章 RT-Thread与设备框架简介
  第2章 UART设备驱动开发
  第3章 PIN设备驱动开发
  第4章 I2C总线设备驱动开发
  第5章 SPI/QSPI总线设备驱动开发
  第6章 HWTIMER设备驱动开发
  第7章 PWM设备驱动开发
  第8章 RTC设备驱动开发
  第9章 ADC设备驱动开发
  第10章 DAC设备驱动开发
  第11章 WDT设备驱动开发
#### 第1章 RT-Thread与设备框架简介
**RT-Thread的架构**

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230613/5a7a34e525fda7fc361c1bb7ee6c8235.png.webp)
RT-Thread架构具体包括以下部分：
1.硬实时内核层；
2.组件与服务层；
3.软件包层；

**RT-Thread源码获取**
RT-Thread源码获取有几种途径。
GitHub: https://github.com/RT-Thread/rt-thread。
Gitee: https://gitee.com/rtthread/rt-thread。
另外，读者还可通过RT-Thread Studio创建RT-Thread工程，通过IDE下载源码并将其加入工程中。

**芯片对接RT-Thread流程**

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230613/448aed186d9cb41c16fa59076b4c0d60.png.webp)

**RT-Thread I/O设备框架**
  “设备框架”就是针对某一类外设，抽象出来一套统一的操作方法以及接入标准。有了这一层抽象，框架上层的应用要访问具体外设（比如摄像头）时，就不用关心具体的厂家或者产地了。只要按照框架提供的操作方法，就可以控制摄像头拍照、摄像了。这套设备框架也为生产厂家提供了方便，他们不需要关心应用具体会怎么使用，只要按照设备框架提供的接入标准设计产品，生产出来就可以在市面上销售了。
  在嵌入式领域，RT-Thread也提供了这样的一层抽象，用于屏蔽嵌入式上的硬件差异，为应用层提供统一的操作方法，也为底层硬件提供统一的接入标准。
  RT-Thread提供了一套简单的I/O设备模型框架，简称设备框架。*RT-Thread设备框架位于硬件和应用程序之间，共分成3层，从上到下分别是I/O设备管理层、设备驱动框架层、设备驱动层*。
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230613/2271fe28b1a24c1e860d575f0a7550fe.png.webp)
 ** I/O设备管理层**实现了对设备驱动程序的封装。应用程序通过I/O设备层提供的标准接口访问底层设备，因此设备驱动程序的升级、更替不会对上层应用产生影响。I/O设备管理层所包含的I/O设备管理接口有rt_device_find、open、read、write、close、register等。
  **设备驱动框架层**是对同类硬件设备驱动的抽象，将不同厂家的同类硬件设备驱动中相同的部分抽取出来，将不同部分留出接口，由驱动程序实现。
  **设备驱动层**是一组驱使硬件设备工作的程序，实现了访问硬件设备的功能，它负责创建和注册I/O设备。设备驱动层注册设备有以下两种方式。
  **第一种方式**，使用I/O设备管理接口直接注册，在设备驱动文件中通过rt_device_register()接口注册到I/O设备管理器中。*这种方式是针对操作逻辑简单的设备，可以不经过设备驱动框架层，直接将设备注册到I/O设备管理器中。*
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230613/31042a1446c00f214f886329b7fae21d.png.webp)
  **第二种方式**，通过设备驱动框架层提供的注册函数进行注册，注册函数名一般命名为rt_hw_xxx_register()，设备驱动框架层的注册函数又调用了I/O设备管理接口的注册函数rt_device_register()，从而进行设备注册。此种注册方式是针对一些不能使用I/O设备管理接口完成操作的设备，如看门狗等。看门狗设备注册的主要步骤如下。
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230613/3488285a0c65e0e89b20797584bb2286.png.webp)

**I/O设备模型与分类**
  RT-Thread的I/O设备模型（以下简称“设备模型”）是建立在内核对象模型基础之上的，设备被认为是一类对象，被纳入对象管理器的范畴。每个设备对象都是由基对象派生而来的，每个具体设备都可以继承其父类对象的属性，并派生出其私有属性。
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230613/d22e88879610ef4f45bf5d631286bc31.png.webp)

**I/O设备管理接口**
  应用程序通过I/O设备管理接口来访问硬件设备，当设备驱动实现后，应用程序就可以访问该硬件。I/O设备管理接口与I/O设备的操作方法的映射关系如图
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230613/886de38a6d47e1f2447aa995f6d4537e.png.webp)

#### 学习效果-添加一个简单驱动
根据方式一添加一个简单驱动，过程如下。
查看结构体struct rt_device的定义。
```
struct rt_device
{
    struct rt_object          parent;                   /**< inherit from rt_object */
#ifdef RT_USING_DM
    struct rt_driver *drv;
    void *dtb_node;
#endif
    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 */

#ifdef RT_USING_POSIX_DEVIO
    const struct dfs_file_ops *fops;
    struct rt_wqueue wait_queue;
#endif /* RT_USING_POSIX_DEVIO */

void                     *user_data;                /**< device private data */
};
```
编写测试代码：

```c
#include <driver_demo.h>
#include <rtdevice.h>

struct rt_device devDemo;//定义设备变量
const char *name="myDriver";//设备名
rt_uint16_t flags=RT_DEVICE_FLAG_RDWR;
//初始化
static rt_err_t myDriverInit(rt_device_t dev)
{
    if(dev==RT_NULL)
    {
        return -1;
    }
    rt_kprintf("\r\n myDriverInit \r\n");
    return 0;
}
//打开
static rt_err_t  myDriverOpen(rt_device_t dev, rt_uint16_t oflag)
{
    if(dev==RT_NULL)
    {
        return -1;
    }
    rt_kprintf("\r\n myDriverOpen \r\n");
    return 0;
}
//读
static rt_ssize_t myDriverRead(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
{
    int i=0;
    char *buf=buffer;
    if(dev==RT_NULL || buffer==RT_NULL)
    {
        return -1;
    }
    
    rt_kprintf("\r\n myDriverRead \r\n");
    if(size>255)
    {
        size=255;
    }
    for(i=0;i<size;i++)
    {
        buf[i]=i;
    }
    return size;
}
//写
static rt_ssize_t myDriverWrite(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
{
    if(dev==RT_NULL || buffer==RT_NULL)
    {
        return -1;
    }
    
    rt_kprintf("\r\n myDriverWrite \r\n");
    rt_kprintf("\r\n Write:%s \r\n",(char *)buffer);
    
    return size;
}
//控制
static rt_err_t  myDriverControl(rt_device_t dev, int cmd, void *args)
{
    if(dev==RT_NULL )
    {
        return -1;
    }
    
    rt_kprintf("\r\n myDriverControl \r\n");
}
//关闭
static rt_err_t myDriverClose(rt_device_t dev)
{
    if(dev==RT_NULL)
    {
        return -1;
    }
    rt_kprintf("\r\n myDriverClose \r\n");
    return 0;
}
//设备注册
int myDriverResiger(void)
{
    rt_device_t dev1=&devDemo;
    dev1->init=myDriverInit;
    dev1->open=myDriverOpen;
    dev1->read=myDriverRead;
    dev1->write=myDriverWrite;
    dev1->control=myDriverControl;
    dev1->close=myDriverClose;
    
    rt_device_register(dev1,name,flags);
    return 0;
}
```
编写测试函数
```
int myDriverTest(void)
{
    int err;
    int i=0;
    char buf[]="hello world!";
    rt_device_t dev_t;
    dev_t=rt_device_find("myDriver");
    if(dev_t == RT_NULL)
    {
        rt_kprintf("not find myDriver\r\n");
    }
    rt_device_open(dev_t,RT_DEVICE_FLAG_RDWR);
    rt_device_control(dev_t,RT_NULL,RT_NULL);
    rt_device_write(dev_t,-1,buf,sizeof(buf));
    rt_device_read(dev_t,0,buf,sizeof(buf));
    for(i=0;i<sizeof(buf);i++)
        rt_kprintf("buf:%2x\r\n",buf[i]);
    rt_kprintf("\r\n");
    rt_device_close(dev_t);
    return 0;
}
```
主函数中调用，如下：
```
    myDriverResiger();//先注册设备
    myDriverTest();//测试
```
运行效果：

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230613/446f74bd7e17325bcb91b1df0ffda7be.png)