目录

    • 1.设备基类
    • 2.rtt基类
      • 2.1 rtt基类定义
      • 2.2 对象容器定义
      • 2.3 rtt基类构造函数
    • 3.io设备管理接口
    • 4.总结

这层我的理解就是rtt基类和设备基类所在,所以抽离出来好点,不然每个设备类都要重复它。
诺,rtt基类和设备基类如下对象图,这也是io管理层的类。

rtt的io设备框架面向对象学习-io设备管理层-LMLPHP

1.设备基类

/include/rtdef.h中定义了设备基类struct rt_device。

在/ components / drivers / core 下的device.c中实现了设备基类的构造函数rt_device_register。

rt_err_t rt_device_register(rt_device_t dev,
                            const char *name,
                            rt_uint16_t flags)
{
    if (dev == RT_NULL)
        return -RT_ERROR;

    if (rt_device_find(name) != RT_NULL)
        return -RT_ERROR;

    rt_object_init(&(dev->parent), RT_Object_Class_Device, name);
    dev->flag = flags;
    dev->ref_count = 0;
    dev->open_flag = 0;

#ifdef RT_USING_POSIX_DEVIO
    dev->fops = RT_NULL;
    rt_wqueue_init(&(dev->wait_queue));
#endif /* RT_USING_POSIX_DEVIO */

    return RT_EOK;
}

我关注的主要点是调用了rtt基类的构造函数rt_object_init。详见下面。

2.rtt基类

2.1 rtt基类定义

/include/rtdef.h中定义了rtt基类。类似python,rtt定义了所有类的基类——struct rt_object。

struct rt_object
{
#if RT_NAME_MAX > 0
    char        name[RT_NAME_MAX]; /**< dynamic name of kernel object */
#else
    const char *name;  /**< static name of kernel object */
#endif /* RT_NAME_MAX > 0 */
    rt_uint8_t  type;    /**< type of kernel object */
    rt_uint8_t  flag;    /**< flag of kernel object */

#ifdef RT_USING_MODULE
    void      * module_id;  /**< id of application module */
#endif /* RT_USING_MODULE */

#ifdef RT_USING_SMART
    rt_atomic_t lwp_ref_count;   /**< ref count for lwp */
#endif /* RT_USING_SMART */

    rt_list_t   list;  /**< list node of kernel object */
};
typedef struct rt_object *rt_object_t;  /**< Type for kernel objects. */

简化对象图如下
rtt的io设备框架面向对象学习-io设备管理层-LMLPHP

2.2 对象容器定义

在/src/object.c中还定义了对象容器:
static struct rt_object_information _object_container[RT_Object_Info_Unknown];

所谓对象容器其实就是个静态数组
数组的类型是struct rt_object_information,其对象图如下
rtt的io设备框架面向对象学习-io设备管理层-LMLPHP
它在对象容器中的作用之一是:作为该类双向链表的链表头,管理系统中该类的所有对象。

这个数组有多大?如下定义:

enum rt_object_info_type
{    
RT_Object_Info_Thread = 0,             
           
#ifdef RT_USING_SEMAPHORE    
RT_Object_Info_Semaphore,                          
#endif

#ifdef RT_USING_MUTEX    
RT_Object_Info_Mutex,                             
#endif

#ifdef RT_USING_EVENT    
RT_Object_Info_Event,                             
#endif

#ifdef RT_USING_MAILBOX    
RT_Object_Info_MailBox,                           
#endif

#ifdef RT_USING_MESSAGEQUEUE  
 RT_Object_Info_MessageQueue,                    
#endif

#ifdef RT_USING_MEMHEAP    
RT_Object_Info_MemHeap,                          
#endif

#ifdef RT_USING_MEMPOOL    
RT_Object_Info_MemPool,                           
#endif

#ifdef RT_USING_DEVICE    
RT_Object_Info_Device,                          
#endif    

RT_Object_Info_Timer,              
              
#ifdef RT_USING_MODULE    
RT_Object_Info_Module,                            
#endif

#ifdef RT_USING_HEAP    
RT_Object_Info_Memory,                          
#endif

#ifdef RT_USING_SMART    
RT_Object_Info_Channel,                           
#endif

#ifdef RT_USING_HEAP    
RT_Object_Info_Custom,                             
#endif    

RT_Object_Info_Unknown,                         
};

可以看到开启多少类,这个数组(对象容器)就有多大——另外还可以看到rtt内核的可裁剪性,最少可以只保留线程类和定时器类,其他类都可以裁剪掉的。

2.3 rtt基类构造函数

在/src/object.c中实现了如下rtt基类的构造函数:
静态rtt基类的构造函数 rt_object_init 与析构函数 rt_object_detach。
动态创建的rtt基类构造函数 rt_object_allocate 与析构函数 rt_object_delete。

不管动态还是静态构造函数,它最终的目的是把该对象的rtt基类rt_object成员list的地址挂到对象容器里——可以理解为把对象放到对象容器中去管理。

关键代码如下

void rt_object_init(struct rt_object         *object,
                    enum rt_object_class_type type,                    const char               *name)
 {
 …
//根据对象类型在对象容器里查找对应位置的链表头
struct rt_object_information *information;
information = rt_object_get_information(type);
…
//information->object_list是管理该类的链表头-哨兵
//把传入的rtt基类对象成员list的地址插入到该类对象链表的队尾
rt_list_insert_after(&(information->object_list), &(object->list));
…
}

代码对象图如下:
rtt的io设备框架面向对象学习-io设备管理层-LMLPHP
前面说了对象容器就是个静态数组而已,每个数组成员代表一类(线程、定时器等),我们这里是设备类,自然挂到设备类成员管理的链表中,它是个双向循环链表,插入的方式是新的设备对象的基类插入到队尾。

为了好绘制链表,我就把rt_object的list成员展开成了struct rt_list_node *next;和struct rt_list_node *prev。如下
rtt的io设备框架面向对象学习-io设备管理层-LMLPHP
同样rt_object_information的list成员也展开成了struct rt_list_node *next;和struct rt_list_node *prev。如下
rtt的io设备框架面向对象学习-io设备管理层-LMLPHP

官网文档里的对容器图(又高度抽象了——其实是它的指导思想,具体实现随着演变可能会发生变化):
rtt的io设备框架面向对象学习-io设备管理层-LMLPHP
但是如果对象太多,查找效率是个问题。

3.io设备管理接口

io设备管理接口是用户可以直接调用的接口,如下
rt_device_find
rt_device_init
rt_device_open
rt_device_close
rt_device_read
rt_device_write
rt_device_control

一般,我们定义完一个结构体,实例化一个对象后,直接“对象指针->属性或方法”、或者采用“对象.属性或方法”的方式来调用,但是如果太复杂,需要if判断一对上下限才能调用的话,最好封成函数,上面的管理接口干的事就是如此。

4.总结

从构造函数的流程来看,是子类调用父类的构造函数,所以章节1设为了设备基类,章节2为rtt基类。
每类都有各自的构造函数,其实质是各自结构体的初始化。
这样,构造函数的流程结果最终是把对象放到对象容器里进行管理。

03-04 13:38