RT-Thread pin设备驱动代码结构剖析

刺骨的言语ヽ痛彻心扉 2022-10-25 01:26 156阅读 0赞

硬件测试平台：正点原子潘多拉STM32L4开发板  
OS内核版本：4.0.0

**注意：下面的示例代码是从原子提供的例程中摘录，因此可能与最新的RT-Thread源码有出入**(因为RT-Thread源码在不断的开发维护中)  
**下面摘录的例程中，关键位置我给出了注释**

本文涉及内容对初学者可能较为晦涩难懂，如只是想先简单学习Pin设备驱动的API使用可以参考：[RT-Thread Pin设备驱动API应用介绍][RT-Thread Pin_API]

首先看main.c，可见main函数主要实现了LED闪烁，以及打印LED状态的功能

#include <rtthread.h>
    #include <rtdevice.h>
    #include <board.h>
    
    /* using RED LED in RGB */
    #define LED_PIN PIN_LED_R
    
    int main(void)
    { 
        unsigned int count = 1;
        /* set LED pin mode to output */
        rt_pin_mode(LED_PIN, PIN_MODE_OUTPUT);
    
        while (count > 0)
        { 
            /* led on */
            rt_pin_write(LED_PIN, PIN_LOW);
            rt_kprintf("led on, count: %d\n", count);
            rt_thread_mdelay(500);
    
            /* led off */
            rt_pin_write(LED_PIN, PIN_HIGH);
            rt_kprintf("led off\n");
            rt_thread_mdelay(500);
    
            count++;
        }
    
        return 0;
    }

PIN\_LED\_R在硬件驱动层的drv\_gpio.h中定义了

#define PIN_LED_R 38 // PE7 : LED_R --> LED

剖析顺序从上到下，从应用层深入到驱动层。(pin驱动相关的源文件主要包括drv\_gpio.c 、pin.c、 device.c)  
代码框架如下图：  
![在这里插入图片描述][20210130155640957.png]  
**接口层的pin.c往上对接用户，往下对接底层驱动。**  
![在这里插入图片描述][20210203101503217.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]

对于不同芯片，用户层的接口是统一的，而对于驱动层来说，只需要对接好相应的回调函数。  
通过统一的接口，应用开发不需要知道底层驱动，减少重复造轮子的时间。

按照点灯裸机的编程思路，先是开启GPIO时钟，然后初始化控制LED的GPIO为输出，最后写GPIO输出高或低电平。

main函数中先是rt\_pin\_mode函数，从字面上看也知道这是设置pin工作模式。下面追踪代码：

/* RT-Thread Hardware PIN APIs */
    void rt_pin_mode(rt_base_t pin, rt_base_t mode)
    { 
        RT_ASSERT(_hw_pin.ops != RT_NULL); //断言 检查_hw_pin.ops不为空
        _hw_pin.ops->pin_mode(&_hw_pin.parent, pin, mode); //调用底层回调函数
    }

结构体\_hw\_pin 定义在pin.c中

static struct rt_device_pin _hw_pin;

进一步追踪struct rt\_device\_pin 这个结构体类型

/* pin device and operations for RT-Thread */
    struct rt_device_pin
    { 
        struct rt_device parent;
        const struct rt_pin_ops *ops;
    };
    
    //在rtdef.h
    /** * 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_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);
    #endif
    
    #if defined(RT_USING_POSIX)
        const struct dfs_file_ops *fops;
        struct rt_wqueue wait_queue;
    #endif
    
        void                     *user_data;                /**< device private data */
    };
    
    //在pin.h
    struct rt_pin_ops
    { 
        void (*pin_mode)(struct rt_device *device, rt_base_t pin, rt_base_t mode);
        void (*pin_write)(struct rt_device *device, rt_base_t pin, rt_base_t value);
        int (*pin_read)(struct rt_device *device, rt_base_t pin);
    
        /* TODO: add GPIO interrupt */
        rt_err_t (*pin_attach_irq)(struct rt_device *device, rt_int32_t pin,
                          rt_uint32_t mode, void (*hdr)(void *args), void *args);
        rt_err_t (*pin_detach_irq)(struct rt_device *device, rt_int32_t pin);
        rt_err_t (*pin_irq_enable)(struct rt_device *device, rt_base_t pin, rt_uint32_t enabled);
    };

struct rt\_device\_pin 这个类型中的成员ops，是接口层与硬件驱动层的媒介。  
从struct rt\_pin\_ops类型可以看到里面是六个函数指针分别对应设置pin模式，写pin，读pin，以及三个与中断有关的。

那问题是，在哪里把ops变量初始化了，也就是把pin接口层和底层连接起来呢？  
答案是在初始化阶段里面实现了，关于RT-Thread的初始化流程可查看：[RT-Thread启动流程][RT-Thread]  
初始化流程中的调用关系如下：  
$ Sub $ $main(void) =》 rtthread\_startup() =》 rt\_hw\_board\_init() =》 rt\_hw\_pin\_init()  
（对 $ Sub $ $不明白的可以参考：[关于 $ Super $ $ 和 $ Sub $ $ 的用法][_ Super _ _ _ _ Sub _ _]）  
前面的函数就不放出来了，直接从rt\_hw\_pin\_init() 开始看：

//这是drv_gpio.c的
    const static struct rt_pin_ops _stm32_pin_ops =
    { 
        stm32_pin_mode,
        stm32_pin_write,
        stm32_pin_read,
        stm32_pin_attach_irq,
        stm32_pin_dettach_irq,
        stm32_pin_irq_enable,
    };
    int rt_hw_pin_init(void)
    { 
        return rt_device_pin_register("pin", &_stm32_pin_ops, RT_NULL);
    }
    
    //这是pin.c的
    int rt_device_pin_register(const char *name, const struct rt_pin_ops *ops, void *user_data)
    { 
        _hw_pin.parent.type         = RT_Device_Class_Miscellaneous;
        _hw_pin.parent.rx_indicate  = RT_NULL;
        _hw_pin.parent.tx_complete  = RT_NULL;
    
    #ifdef RT_USING_DEVICE_OPS
        _hw_pin.parent.ops          = &pin_ops;
    #else
        _hw_pin.parent.init         = RT_NULL;
        _hw_pin.parent.open         = RT_NULL;
        _hw_pin.parent.close        = RT_NULL;
        _hw_pin.parent.read         = _pin_read;
        _hw_pin.parent.write        = _pin_write;
        _hw_pin.parent.control      = _pin_control;
    #endif
    
        _hw_pin.ops                 = ops;   //这里把_stm32_pin_ops和 _hw_pin.ops 连接起来了
        _hw_pin.parent.user_data    = user_data;
    
        /* register a character device */
        rt_device_register(&_hw_pin.parent, name, RT_DEVICE_FLAG_RDWR);
    
        return 0;
    }

从上面的代码可以看出，底层驱动只要实现\_stm32\_pin\_ops 里的6个接口函数即可。

至此我们已初步理清了RT-Thread Pin设备驱动的框架关系了：  
![在这里插入图片描述][20210203100120403.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]  
如上图，我们在应用层需要学会rt\_pin\_mode等6个API接口的使用，在底层需要实现GPIO驱动的回调函数。  
从上图可以直观地看到 Pin 设备驱动框架和 GPIO 驱动是如果对接到一起的。  
如上图所示：

1.  左侧为 Pin 设备驱动框架封装的 API 接口，向上提供给应用层使用；
2.  右侧为具体芯片平台对接 Pin 设备的驱动程序，与 Pin 设备框架提供的 API 接口一一对应，通过 rt\_pin\_ops 结构体关联到一起，驱动框架层接口最终会回调驱动层接口；
3.  最后通过 rt\_device\_pin\_register 函数接口，将底层驱动与 Pin 设备框架绑定到一起，注册到 RT-Thread 的设备框架中。

在对接 RT-Thread Pin 设备框架的时候，仅需要实现上图右侧 rt\_pin\_ops 结构体中的所有 callback 回调函数即可，然后通过 rt\_device\_pin\_register 注册到系统，最后使用 rt\_hw\_pin\_init 调用以进行初始化。  
rt\_hw\_pin\_init 在系统启动过程中被 rt\_hw\_board\_init 调用。

点灯主要关注stm32\_pin\_mode和stm32\_pin\_write这两个函数即可实现：(两个函数都在驱动层也就是drv\_gpio.c中实现)

static void stm32_pin_mode(rt_device_t dev, rt_base_t pin, rt_base_t mode)
    { 
        const struct pin_index *index;
        GPIO_InitTypeDef GPIO_InitStruct;
    
        index = get_pin(pin);
        if (index == RT_NULL)
        { 
            return;
        }
    
        /* GPIO Periph clock enable */
        index->rcc();
    
        /* Configure GPIO_InitStructure */
        GPIO_InitStruct.Pin = index->pin;
        GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    
        if (mode == PIN_MODE_OUTPUT)
        { 
            /* output setting */
            GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
            GPIO_InitStruct.Pull = GPIO_NOPULL;
        }
        else if (mode == PIN_MODE_INPUT)
        { 
            /* input setting: not pull. */
            GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
            GPIO_InitStruct.Pull = GPIO_NOPULL;
        }
        else if (mode == PIN_MODE_INPUT_PULLUP)
        { 
            /* input setting: pull up. */
            GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
            GPIO_InitStruct.Pull = GPIO_PULLUP;
        }
        else if (mode == PIN_MODE_INPUT_PULLDOWN)
        { 
            /* input setting: pull down. */
            GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
            GPIO_InitStruct.Pull = GPIO_PULLDOWN;
        }
        else if (mode == PIN_MODE_OUTPUT_OD)
        { 
            /* output setting: od. */
            GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
            GPIO_InitStruct.Pull = GPIO_NOPULL;
        }
    
        HAL_GPIO_Init(index->gpio, &GPIO_InitStruct);
    }
    
    static void stm32_pin_write(rt_device_t dev, rt_base_t pin, rt_base_t value)
    { 
        const struct pin_index *index;
    
        index = get_pin(pin);
        if (index == RT_NULL)
        { 
            return;
        }
    
        HAL_GPIO_WritePin(index->gpio, index->pin, (GPIO_PinState)value);//调用HAL库函数控制GPIO输出高低电平
    }

关于stm32\_pin\_mode函数有一个问题，我们知道GPIO\_InitStruct需要初始化四个成员变量分别是选择pin，选择GPIO模式，选择是否加上下拉，选择GPIO速度，上述代码从对上层的通用性考虑(不是每个芯片都可以控制速率等)，只往上提供了mode，而速度固定在了GPIO\_SPEED\_FREQ\_HIGH，上拉下拉则根据mode固定变化。如果有特殊需求对某个GPIO要做一些特殊配置，比如要降低某个GPIO的速率以降低功耗，这就得另外去改了。

下面关于stm32\_pin\_write()函数单独拉出来对相关代码分析一下：

#define LED_PIN PIN_LED_R
    #define PIN_LED_R 38 // PE7 : LED_R --> LED
    
    #define PIN_LOW 0x00
    #define PIN_HIGH 0x01
    
    rt_pin_write(LED_PIN, PIN_LOW);
    
    void rt_pin_write(rt_base_t pin, rt_base_t value)
    { 
        RT_ASSERT(_hw_pin.ops != RT_NULL);
        _hw_pin.ops->pin_write(&_hw_pin.parent, pin, value); //以上分析我们知道，pin_write实际上就是指向了stm32_pin_write函数
    }
    
    static void stm32_pin_write(rt_device_t dev, rt_base_t pin, rt_base_t value)
    { 
        const struct pin_index *index;
    
        index = get_pin(pin);
        if (index == RT_NULL)
        { 
            return;
        }
    
        HAL_GPIO_WritePin(index->gpio, index->pin, (GPIO_PinState)value);//调用HAL库函数控制GPIO输出高低电平
    }
    
    static void stm32_pin_write(rt_device_t dev, rt_base_t pin, rt_base_t value)
    { 
        const struct pin_index *index;
    
        index = get_pin(pin);
        if (index == RT_NULL)
        { 
            return;
        }
    
        HAL_GPIO_WritePin(index->gpio, index->pin, (GPIO_PinState)value);//(GPIO_PinState)这里用了强制转换是防止上层传下来0或1会编译报警
    }
    
    #define ITEM_NUM(items) sizeof(items) / sizeof(items[0])
    static const struct pin_index *get_pin(uint8_t pin)
    { 
        const struct pin_index *index;
    
        if (pin < ITEM_NUM(pins))
        { 
            index = &pins[pin];
            if (index->index == -1)
                index = RT_NULL;
        }
        else
        { 
            index = RT_NULL;
        }
    
        return index;
    };
    
    static const struct pin_index pins[] =
    { 
        __STM32_PIN_DEFAULT,
        __STM32_PIN(1, E, 2),       // PE2 : SAI1_MCLK_A --> ES8388
        __STM32_PIN(2, E, 3),       // PE3 : SAI1_SD_B --> ES8388
        ...//省略
        __STM32_PIN(38, E, 7),      // PE7 : LED_R --> LED //这是我们要用到的红色LED脚
        ...//省略
        __STM32_PIN(98, E, 1),      // PE1 : IO_PE1 --> EXTERNAL MODULE
        __STM32_PIN_DEFAULT,        // : VSS
        __STM32_PIN_DEFAULT,        // : VDD
    };
    
    /* STM32 GPIO driver */
    struct pin_index
    { 
        int index;
        void (*rcc)(void);
        GPIO_TypeDef *gpio;
        uint32_t pin;
    };
    
    //这里用到了##连接符 这个符号在RT-Thread里用得很多
    #define __STM32_PIN(index, gpio, gpio_index) \ { \ index, GPIO##gpio##_CLK_ENABLE, GPIO##gpio, GPIO_PIN_##gpio_index \ }

调用rt\_pin\_write时第一个参数传入38实际上就在struct pin\_index pins\[\] 这里面索引到\_\_STM32\_PIN(38, E, 7),  
查看原理图发现，这个表对应了芯片的引脚序号，比如38脚就是PE7，也就是我们要用的红色LED控制脚  
![在这里插入图片描述][20210130165547881.png]  
rt\_pin\_write(38, 1)实际到了底层就是HAL\_GPIO\_WritePin(GPIOE, GPIO\_PIN\_7, (GPIO\_PinState)1);  
//(GPIO\_PinState)这里用了强制转换是防止上层传下来0或1会编译报警 （细节到位）

最后还剩一个问题，在哪里使能了该GPIO时钟？  
在stm32\_pin\_mode函数里面使能了对应的GPIO时钟，  
/\* GPIO Periph clock enable \*/  
index->rcc();  
rcc是一个函数指针，实际上是执行了 GPIOE\_CLK\_ENABLE()；  
看到struct pin\_index类型第二个成员void (\*rcc)(void);  
pins是struct pin\_index类型的结构体数组  
我们用到的红色LED对应的\_\_STM32\_PIN(38, E, 7)  
第二个宏参数E通过GPIO\#\#gpio\#\#\_CLK\_ENABLE ==》就变成了GPIOE\_CLK\_ENABLE  
对\#\#和\#的用法不熟悉可参考： [详解C语言中 \#\#和\# 的用法][C_ _]

## 通过设备驱动框架访问pin设备 ##

1.  RTT设备驱动框架提供了统一的API：

<table> 
 <thead> 
  <tr> 
   <th>API</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>rt_err_t rt_device_init (rt_device_t dev)</td> 
   <td>设备初始化</td> 
  </tr> 
  <tr> 
   <td>rt_err_t rt_device_open (rt_device_t dev, rt_uint16_t oflag)</td> 
   <td>打开设备</td> 
  </tr> 
  <tr> 
   <td>rt_err_t rt_device_close(rt_device_t dev)</td> 
   <td>关闭设备</td> 
  </tr> 
  <tr> 
   <td>rt_size_t rt_device_read (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)</td> 
   <td>读设备</td> 
  </tr> 
  <tr> 
   <td>rt_size_t rt_device_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)</td> 
   <td>写设备</td> 
  </tr> 
  <tr> 
   <td>rt_err_t rt_device_control(rt_device_t dev, int cmd, void *arg)</td> 
   <td>控制设备</td> 
  </tr> 
 </tbody> 
</table>

RTT提供的设备驱动API使用了类似Linux的设计思路，对设备的访问都通过如下接口open，read，write，close等来完成操作。  
其中，pin设备的接口关系如下：  
![在这里插入图片描述][20210206172231121.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]  
目前我的这套代码中\_pin\_control()只实现了GPIO的模式设置，如果要使用这组API需要自己增加相关代码实现对中断的控制：

static rt_err_t  _pin_control(rt_device_t dev, int cmd, void *args)
    { 
        struct rt_device_pin_mode *mode;
        struct rt_device_pin *pin = (struct rt_device_pin *)dev;
     
        /* check parameters */
        RT_ASSERT(pin != RT_NULL);
     
        mode = (struct rt_device_pin_mode *) args;
        if (mode == RT_NULL) return -RT_ERROR;
     
        pin->ops->pin_mode(dev, (rt_base_t)mode->pin, (rt_base_t)mode->mode);
     
        return 0;
    }

**下面的示例代码从调用设备驱动框架的接口来实现对LED的控制**：  
![在这里插入图片描述][20210206173011116.png]

int main(void)
    { 
        int count = 1;
        struct rt_device_pin *pin_dev = RT_NULL;
        struct rt_device_pin_mode rt_device_pin_mode_led = { LED_PIN, PIN_MODE_OUTPUT};
        struct rt_device_pin_status rt_device_pin_status_led = { LED_PIN, PIN_HIGH};
            
        pin_dev = (struct rt_device_pin *)rt_device_find("pin");
        rt_device_open((rt_device_t)pin_dev, RT_DEVICE_OFLAG_RDWR);
        
        rt_device_control(&pin_dev->parent, 0, &rt_device_pin_mode_led);
        while (count++)
        { 
            rt_device_pin_status_led.status = PIN_HIGH;
            rt_device_write((rt_device_t)pin_dev, 0, &rt_device_pin_status_led, sizeof(rt_device_pin_status_led));
            rt_thread_mdelay(1000);
    
            rt_device_pin_status_led.status = PIN_LOW;
            rt_device_write((rt_device_t)pin_dev, 0, &rt_device_pin_status_led, sizeof(rt_device_pin_status_led));
            rt_thread_mdelay(1000);
        }
     
        return RT_EOK;
    }

## 最后 ##

唠一句：  
RT-Thread的代码还是不错的，初学者可能会对这种分层思想有点懵，但是实际项目中，这种思想一定要运用起来，只有真正的去解耦合，把应用层和驱动层尽可能分开，才能把应用层的代码做到方便在不同平台移植，这可能试着把这种工程代码移植一下平台，再对比一下不分层，应用和驱动相互交错的工程移植一下，就明白到底这种编程思想强在哪里了。重复地造轮子只会让人越来越累，降低工作效率。

[RT-Thread Pin_API]: https://blog.csdn.net/weixin_44788542/article/details/113643750
[20210130155640957.png]: /images/20221024/db74837ae4704471b15fa32056faa6d1.png
[20210203101503217.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]: /images/20221024/b7b83691d0fd4822b5676b40ab0846ad.png
[RT-Thread]: https://blog.csdn.net/weixin_44788542/article/details/113189214
[_ Super _ _ _ _ Sub _ _]: https://blog.csdn.net/weixin_44788542/article/details/113241596
[20210203100120403.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]: /images/20221024/f7ee3149bb9a42cea0f29a2e8d33bc08.png
[20210130165547881.png]: /images/20221024/277a5eca3f22435faa393d6a25391a7a.png
[C_ _]: https://blog.csdn.net/weixin_44788542/article/details/113601856
[20210206172231121.png_x-oss-process_image_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc4ODU0Mg_size_16_color_FFFFFF_t_70]: /images/20221024/7e5a2f1b7a624f31a187ed4e1e9717c7.png
[20210206173011116.png]: /images/20221024/6d7205cee8ad43fb93f3c010d20575ce.png