小白初探RT-Thread驱动注册机制套路......

发布于 2019-11-15 14:43:15 浏览：3183 订阅该版

RTT设备驱动的注册需要了解2个结构体和1个注册函数。

```c
struct rt_device
{
    struct rt_object          parent;      //继承rt_object对象，不用管
    enum rt_device_class_type type; //设备类型
    rt_uint16_t               flag;             //设备标志，设备允许访问权限
    rt_uint16_t               open_flag;   //当前设备的打开方式，当关闭时会根据这个标志去关闭设备
    rt_uint8_t                ref_count;      //打开次数 打开+1  关闭-1，到0时才会调用close函数
    rt_uint8_t                device_id;     //设备的ID号，感觉没用到,应该是系统自动分配ID号吧
    rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);  //接收回调函数
    rt_err_t (*tx_complete)(rt_device_t dev, void *buffer);  //发送回调函数
    const struct rt_device_ops *ops; //设备操作方法
}

struct rt_device_ops
{
    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_size_t (*read)   (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);        //读
    rt_size_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);                                        //配置设备
};
```

注册函数
```c
rt_err_t rt_device_register(        rt_device_t dev,              //设备结构体指针
                                                    const char *name,         //设备名称
                                                   rt_uint16_t flags)         // 设备可以以哪种方式打开设备

/************************实现OPS结构里边的函数************************************************************/
ops结构体里边的函数都是自行编写 实现对硬件的操作,当应用层调用 rt_device_xxx时会根据参数dev自行找到这些函数。
/* 
 初始化函数
*/ 
rt_err_t test_init(rt_device_t dev) 
{
 rt_kprintf("Init_func... "); 
 /*
 *初始化硬件设备 ...........
 */ 
 return 0;
}
/* 
 打开函数
 oflag:打开方式
 <在找到这个函数前 设备驱动框架会查看这个设备是否已经打开过，没有打开过就自动先调用init才进入这个函数>
*/ 
rt_err_t test_open(rt_device_t dev,rt_uint16_t oflag)
{
 rt_kprintf("open_func... ");
 rt_kprintf("Type:0x%x ",oflag);
 /*
 **判断oflag是否正确，错误则返回错误码 <比如 设备flag 没有读方式，用读方式打开就是错误>
 其他操作。。。。。
 */
 return 0;
}
```

关闭函数
 这个对应裸机的编写时初始化硬件的函数，当应用层调用`rt_device_close(dev)`，系统会根据`dev`找到这个函数,在函数里边清除掉已经打开的标志并DISABLE硬件
```c
rt_err_t test_close(rt_device_t dev)
{ 
 rt_kprintf(" close_func... ");
 return 0;
 /*
 *清打开标志
 *根据已打开标志去disable硬件
 */
}
/*
读函数
 pos: 偏移量，字符设备用不到
 buffer:用来装从寄存器读出来的数据
 size:读取字节大小，字符设备是1，如果是块设备就是整块读那就非1
返回读取数据大小。
*/ 
rt_size_t test_read(rt_device_t dev,rt_off_t pos,void *buffer, rt_size_t size)
{
 char data=0xff;
 rt_memcpy(buffer,(void*)&data,size);
 return size;
}
/*
写数据
 和读一样，只不过buffer是装有要往寄存器写的数据
*/
rt_size_t test_write(rt_device_t dev,rt_off_t pos, const void *buffer, rt_size_t size)
{
 char *buf = (char*)buffer;
 for(int i = 0;i<size;i++)
 { 
 }
 rt_kprintf(" ");
 return size;
}
/*
 控制/配置函数
cmd：控制命令，这个是自定义命令
*args: 用来配置设备的数据，这个数据可以自定义封装成结构体，应用层需要配置则向这个结构体赋 
 值，通过void指针方式传进来,强制转成配置结构体类型，这样驱动层就能得到应用层要配置的参数，根据参数去配置驱动。
*/
rt_err_t test_control(rt_device_t dev, int cmd, void *args)
{
 rt_kprintf("CMD:%x ",cmd);
 rt_kprintf("private:%x ",*(uint16_t*)args);
 return 0;
}

/*定义rt_device_ops类型变量 并拿上边的函数去初始化ops结构体变量*/
static const struct rt_device_ops ops = \{test_init,test_open,test_close,test_read,test_write,test_control};

/*定义一个rt_device 变量*/
static struct rt_device    dev ;

/*
注册函数。
这个函数将设备注册到设备驱动框架
*/
void test_register(void)
{    
/*****模拟设备的注册*********/
  uint16_t Private_data=0xFF;//私有数据可以是任何类型的变量，这个可以用来存储设备私有的数据
   rt_device_t        device = &dev;// 定义一个rt_device_t类型变量，让它指向dev全局变量
    device->rx_indicate = RT_NULL; //回调函数没有，这2个函数在应用层通过一条API设置
    device->tx_complete = RT_NULL;
                device ->type=RT_Device_Class_Char;  // 字符设备
                device->ops = &ops;          //指向操作方法结构体，这样才能找到读、写、打开 等等函数
                device->user_data = &Private_data; //设备私有数据，随便保存个值
                /*调用注册函数*/
                 rt_device_register(device,     //设备结构体指针          
 "test_dev",//设备名字
                                             RT_DEVICE_FLAG_RDW  //设备所拥有的打开方式，多种方式用“|”。
 );
}

/******************写一个函数，导出到控制台方便测试*********************/
static void test_cmd(int argc,char **argv)
{

rt_device_t dev = rt_device_find("test_dev"); //查找设备，设备名称是注册的设备名称
        uint16_t buf=0x1234;     //备用

if( *argv[1]== 'i') //输入 “tset_cmd i ” 初始化设备 
 {
 rt_device_init(dev); // 调用rt_dev_init初始化设备，它将调用底层驱动的 test_init
 }
 if( *argv[1]== 'o')
 {
 rt_device_open(dev,RT_DEVICE_FLAG_INT_TX); //打开
 }
 if( *argv[1]== 'c')
 {
 rt_device_close(dev); //关闭
 }
 if( *argv[1]== 'r') //读
 { 
 rt_device_read(dev,0,&buf,1); 
 rt_kprintf("0x%x ",buf);
 }
 if( *argv[1]== 'w')
 {
 rt_device_write(dev,0,&buf,2); //写
 }
 if( *argv[1]== 't')
 {
 rt_device_control(dev,0x11FF,&buf); //配置
 }
}
MSH_CMD_EXPORT(test_cmd,"deviceTest");
```

![1.jpg](https://oss-club.rt-thread.org/uploads/201911/15/144412tbtwiizoicmo5ucn.jpg)
 
 
![2.jpg](https://oss-club.rt-thread.org/uploads/201911/15/144412yt3lu1xj09899i39.jpg)
 
 
![3.jpg](https://oss-club.rt-thread.org/uploads/201911/15/144412d5d678za527f28n2.jpg)
 
 
![4.jpg](https://oss-club.rt-thread.org/uploads/201911/15/144412ijnr7m637gdgi8je.jpg)