从各层实现的对象上来看分层思想

1970-01-01

字数统计: 696字 | 阅读时长≈ 2分

从各层实现的对象上来看分层思想

/* 底层驱动设备对象 */
struct stm32_uart
{
    UART_HandleTypeDef handle;
    struct stm32_uart_config *config;  // stm32串口的差异化特性，与其它MCU的串口不同的地方：比如串口的寄存器地址、配置串口时操作的寄存器代码

#ifdef RT_SERIAL_USING_DMA
    struct
    {
        DMA_HandleTypeDef handle;
        rt_size_t last_index;
    } dma_rx;
    struct
    {
        DMA_HandleTypeDef handle;
    } dma_tx;
#endif
    rt_uint16_t uart_dma_flag; // dma也是差异化代码
    
    struct rt_serial_device serial; // 设备框架层基类：是所有串口设备的共性
};

/* 串口设备框架对象 */
struct rt_serial_device
{
    struct rt_device          parent; /* 设备基类：所有设备都具有的共性，不管是串口设备，spi设备、iic设备都有 */

    const struct rt_uart_ops *ops; // 串口都有getc、putc等操作方法
    struct serial_configure   config; // 串口都有配置串口的信息：波特率、是否奇偶校验等配置

    void *serial_rx;
    void *serial_tx;
};
typedef struct rt_serial_device rt_serial_t;

/* 设备对象 */
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);

    const struct rt_device_ops *ops;

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

IO设备管理层、设备驱动框架层、设备驱动层：三层定义的对象是一级一级增大，从抽象到具体，设备的实例化必须在最底层进行也就是驱动层，底层初始化好设备的差异性，然后通过注册的形式给到上层，上层在初始化本次的差异性，然后再通过注册给到上层，上层再初始化，初始化是一级一级从下往上初始化，最终这个设备就初始化好了，应用程序就可以使用这个设备了。

对象基类和父类首地址相同的使用

// 孙类最大占用空间，派生了 struct yl_led_device 基类
struct hw_chip_device
{
    struct yl_led_device            led_device;
    struct rt_spi_device *          rt_spi_device;
    struct chip_ops *               ops;
    void *                          user_data;
};

// 子类，派生了 struct rt_device  基类
struct yl_led_device
{
    struct rt_device                obj_device;
    void *                          user_data;
};

// 父类最小占用空间
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 */

.......

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

// 由于各个基类在类的结构体都是在第一个位置，所以以上三个类的实例化对象地址一样，但类型不一样
// 只有父类注册到了obj容器，所有站到obj里面的对象，强制转换下对象类型就可以得到各个对象
rt_size_t _write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
{
    struct hw_chip_device * chip_dev = (struct hw_chip_device *)dev; // 地址一样，类型不一样：从obj父对象转换成 hw_chip_device 孙对象，可直接操作孙对象里面的所有成员
    
    _chip_write(chip_dev, buffer, size);
    
    return RT_EOK;
}

本文作者： 龙兄嵌入式
本文链接： https://hexo.880755.xyz/1970/01/01/zblog/download/82.从各层实现的对象上来看分层思想/