21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 嵌入式软件分层模块封装例子
返回列表 发新帖我要提问

[开发工具] 嵌入式软件分层模块封装例子

[复制链接]
1727|1
 楼主| LOVEEVER 发表于 2024-9-12 14:32 | 显示全部楼层 |阅读模式
ICE, ic, ev, 嵌入式软件, 封装, 模块
一、前言

以STM32为例，打开网络上下载的例程或者是购买开发板自带的例程，都会发现应用层中会有stm32f10x.h或者stm32f10x_gpio.h，这些文件严格来时属于硬件层的，如果软件层出现这些文件会显得很乱。

使用过Linux的童鞋们肯定知道linux系统无法直接操作硬件层，打开linux或者rt_thread代码会发现代码中都会有device的源文件，没错，这就是驱动层。

1.png

二、实现原理

原理就是将硬件操作的接口全都放到驱动链表上，在驱动层实现device的open、read、write等操作。当然这样做也有弊端，就是驱动find的时候需要遍历一遍驱动链表，这样会增加代码运行时间。

三、代码实现

国际惯例，写代码先写头文件。rt_thread中使用的是双向链表，为了简单在这我只用单向链表。有兴趣的可以自行研究rt_thread

头文件接口:

本次只实现如下接口，device_open  和device_close等剩下的接口可以自行研究。这样就可以在应用层中只调用如下接口可实现：

复制
  1. /*
    

  2.     驱动注册
    

  3. */
    

  4. int cola_device_register(cola_device_t *dev);
    

  5. /*
    

  6.     驱动查找
    

  7. */
    

  8. cola_device_t *cola_device_find(const char *name);
    

  9. /*
    

  10.     驱动读
    

  11. */
    

  12. int cola_device_read(cola_device_t *dev,  int pos, void *buffer, int size);
    

  13. /*
    

  14.     驱动写
    

  15. */
    

  16. int cola_device_write(cola_device_t *dev, int pos, const void *buffer, int size);
    

  17. /*
    

  18.     驱动控制
    

  19. */
    

  20. int cola_device_ctrl(cola_device_t *dev,  int cmd, void *arg);;
    

  21. 头文件cola_device.h：
    


  22. 

  23. #ifndef _COLA_DEVICE_H_
    

  24. #define _COLA_DEVICE_H_
    


  25. 


  26. 

  27. enum LED_state
    

  28. {
    

  29.     LED_OFF,
    

  30.     LED_ON,
    

  31.     LED_TOGGLE,
    


  32. 

  33. };
    


  34. 

  35. typedef struct cola_device  cola_device_t;
    


  36. 

  37. struct cola_device_ops
    

  38. {
    

  39.     int  (*init)   (cola_device_t *dev);
    

  40.     int  (*open)   (cola_device_t *dev, int oflag);
    

  41.     int  (*close)  (cola_device_t *dev);
    

  42.     int  (*read)   (cola_device_t *dev, int pos, void *buffer, int size);
    

  43.     int  (*write)  (cola_device_t *dev, int pos, const void *buffer, int size);
    

  44.     int  (*control)(cola_device_t *dev, int cmd, void *args);
    


  45. 

  46. };
    


  47. 

  48. struct cola_device
    

  49. {
    

  50.     const char * name;
    

  51.     struct cola_device_ops *dops;
    

  52.     struct cola_device *next;
    

  53. };
    


  54. 

  55. /*
    

  56.     驱动注册
    

  57. */
    

  58. int cola_device_register(cola_device_t *dev);
    

  59. /*
    

  60.     驱动查找
    

  61. */
    

  62. cola_device_t *cola_device_find(const char *name);
    

  63. /*
    

  64.     驱动读
    

  65. */
    

  66. int cola_device_read(cola_device_t *dev,  int pos, void *buffer, int size);
    

  67. /*
    

  68.     驱动写
    

  69. */
    

  70. int cola_device_write(cola_device_t *dev, int pos, const void *buffer, int size);
    

  71. /*
    

  72.     驱动控制
    

  73. */
    

  74. int cola_device_ctrl(cola_device_t *dev,  int cmd, void *arg);
    


  75. 

  76. #endif


源文件cola_device.c：

复制
  1. #include "cola_device.h"
    

  2. #include <string.h>
    

  3. #include <stdbool.h>
    


  4. 


  5. 

  6. struct cola_device *device_list = NULL;
    


  7. 

  8. /*
    

  9.     查找任务是否存在
    

  10. */
    

  11. static bool cola_device_is_exists( cola_device_t *dev )
    

  12. {
    

  13.     cola_device_t* cur = device_list;
    

  14.     while( cur != NULL )
    

  15.     {
    

  16.         if( strcmp(cur->name,dev->name)==0)
    

  17.         {
    

  18.             return true;
    

  19.         }
    

  20.         cur = cur->next;
    

  21.     }
    

  22.     return false;
    

  23. }
    


  24. 


  25. 

  26. static int device_list_inster(cola_device_t *dev)
    

  27. {
    

  28.     cola_device_t *cur = device_list;
    

  29.     if(NULL == device_list)
    

  30.     {
    

  31.         device_list = dev;
    

  32.         dev->next   = NULL;
    

  33.     }
    

  34.     else
    

  35.     {
    

  36.         while(NULL != cur->next)
    

  37.         {
    

  38.             cur = cur->next;
    

  39.         }
    

  40.         cur->next = dev;
    

  41.         dev->next = NULL;
    

  42.     }
    

  43.     return 1;
    

  44. }
    


  45. 

  46. /*
    

  47.     驱动注册
    

  48. */
    

  49. int cola_device_register(cola_device_t *dev)
    

  50. {
    

  51.     if((NULL == dev) || (cola_device_is_exists(dev)))
    

  52.     {
    

  53.         return 0;
    

  54.     }
    


  55. 

  56.     if((NULL == dev->name) ||  (NULL == dev->dops))
    

  57.     {
    

  58.         return 0;
    

  59.     }
    

  60.     return device_list_inster(dev);
    


  61. 

  62. }
    

  63. /*
    

  64.     驱动查找
    

  65. */
    

  66. cola_device_t *cola_device_find(const char *name)
    

  67. {
    

  68.     cola_device_t* cur = device_list;
    

  69.     while( cur != NULL )
    

  70.     {
    

  71.         if( strcmp(cur->name,name)==0)
    

  72.         {
    

  73.             return cur;
    

  74.         }
    

  75.         cur = cur->next;
    

  76.     }
    

  77.     return NULL;
    

  78. }
    

  79. /*
    

  80.     驱动读
    

  81. */
    

  82. int cola_device_read(cola_device_t *dev,  int pos, void *buffer, int size)
    

  83. {
    

  84.     if(dev)
    

  85.     {
    

  86.         if(dev->dops->read)
    

  87.         {
    

  88.             return dev->dops->read(dev, pos, buffer, size);
    

  89.         }
    

  90.     }
    

  91.     return 0;
    

  92. }
    

  93. /*
    

  94.     驱动写
    

  95. */
    

  96. int cola_device_write(cola_device_t *dev, int pos, const void *buffer, int size)
    

  97. {
    

  98.     if(dev)
    

  99.     {
    

  100.         if(dev->dops->write)
    

  101.         {
    

  102.             return dev->dops->write(dev, pos, buffer, size);
    

  103.         }
    

  104.     }
    

  105.     return 0;
    

  106. }
    

  107. /*
    

  108.     驱动控制
    

  109. */
    

  110. int cola_device_ctrl(cola_device_t *dev,  int cmd, void *arg)
    

  111. {
    

  112.     if(dev)
    

  113.     {
    

  114.         if(dev->dops->control)
    

  115.         {
    

  116.             return dev->dops->control(dev, cmd, arg);
    

  117.         }
    

  118.     }
    

  119.     return 0;
    

  120. }


回复

收藏 举报

相关帖子
 楼主| LOVEEVER 发表于 2024-9-12 14:33 | 显示全部楼层
硬件注册方式:以LED为例，初始化接口void led_register(void)，需要在初始化中调用。


复制
  1. #include "stm32f0xx.h"
    

  2. #include "led.h"
    

  3. #include "cola_device.h"
    


  4. 


  5. 

  6. #define PORT_GREEN_LED                 GPIOC                   
    

  7. #define PIN_GREENLED                   GPIO_Pin_13              
    


  8. 

  9. /* LED亮、灭、变化 */
    

  10. #define LED_GREEN_OFF                  (PORT_GREEN_LED->BSRR = PIN_GREENLED)
    

  11. #define LED_GREEN_ON                   (PORT_GREEN_LED->BRR  = PIN_GREENLED)
    

  12. #define LED_GREEN_TOGGLE               (PORT_GREEN_LED->ODR ^= PIN_GREENLED)
    


  13. 


  14. 

  15. static cola_device_t led_dev;
    


  16. 

  17. static void led_gpio_init(void)
    

  18. {
    

  19.     GPIO_InitTypeDef GPIO_InitStructure;
    

  20.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
    

  21.     GPIO_InitStructure.GPIO_Pin = PIN_GREENLED;                            
    

  22.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;                     
    

  23.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                  
    

  24.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;                     
    

  25.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;                  
    

  26.     GPIO_Init(PORT_GREEN_LED, &GPIO_InitStructure);
    

  27.     LED_GREEN_OFF;
    

  28. }
    


  29. 

  30. static int led_ctrl(cola_device_t *dev, int cmd, void *args)
    

  31. {
    

  32.     if(LED_TOGGLE == cmd)
    

  33.     {
    

  34.         LED_GREEN_TOGGLE;
    

  35.     }
    

  36.     else 
    

  37.     {
    


  38. 

  39.     }
    

  40.     return 1;
    

  41. }
    


  42. 


  43. 

  44. static struct cola_device_ops ops =
    

  45. {
    

  46.     .control = led_ctrl,
    

  47. };
    


  48. 

  49. void led_register(void)
    

  50. {
    

  51.     led_gpio_init();
    

  52.     led_dev.dops = &ops;
    

  53.     led_dev.name = "led";
    

  54.     cola_device_register(&led_dev);
    

  55. }

应用层app代码:

复制
  1. #include <string.h>
    

  2. #include "app.h"
    

  3. #include "config.h"
    

  4. #include "cola_device.h"
    

  5. #include "cola_os.h"
    


  6. 

  7. static task_t timer_500ms;
    

  8. static cola_device_t *app_led_dev;
    


  9. 

  10. //led每500ms状态改变一次
    

  11. static void timer_500ms_cb(uint32_t event)
    

  12. {
    

  13.     cola_device_ctrl(app_led_dev,LED_TOGGLE,0);
    

  14. }
    


  15. 

  16. void app_init(void)
    

  17. {
    

  18.     app_led_dev = cola_device_find("led");
    

  19.     assert(app_led_dev);
    

  20.     cola_timer_create(&timer_500ms,timer_500ms_cb);
    

  21.     cola_timer_start(&timer_500ms,TIMER_ALWAYS,500);
    

  22. }

这样app.c文件中就不需要调用led.h头文件了，rtt就是这样实现的。

回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

LOVEEVER

350

主题

2689

帖子

6

粉丝
快速回复 在线客服 返回列表 返回顶部