单片机代码解耦

模块层如何解耦

在单片机工程中，为了程序的可移植性、低耦合性，以及更好的阅读性，会将不同的功能进行模块化编写。每个模块在自己的源文件中实现自身的功能，在头文件中提供各种接口函数，以供调用。

一般我们会这么使用模块的源文件和头文件

• 将模块源文件加入编译
• 在需要使用模块函数之处，包含模块头文件
• 在main函数内，显性调用模块初始化函数
• 在实际使用处，显性调用模块的具体函数

这样做的结果

• 所有功能模块的初始化函数都耦合到main函数内
• 所有调用了模块函数的源文件内，都先要包含模块的头文件
• 模块的具体函数，在源文件内四处显性调用，各源文件之间的耦合性很高

对于嵌入式项目，经常一个工程要针对多个方案，每个方案可能因为硬件不同、功能不同，存在模块初始化上的差异。按照上述常规的方法，当需要修改、删除、增加一个功能模块时

• 麻烦1：要修改main函数的初始化部分
• 麻烦2：要修改头文件的包含
• 麻烦3：要修改所有具体函数显性调用之处

要解决麻烦1，最好能将模块的初始化写在它自身的源文件内时，main函数也可以自动调用模块初始化函数。
要解决麻烦2和3，最好模块的功能函数可以被隐式调用，而且调用的入口也统一。

一、实现函数自动执行

我们可以这么做，参考Linux的initcall机制
将要调用的函数名（函数指针）放到某个已知的内存段中，在初始化函数内，遍历内存段。通过存放的函数指针，调用函数原型，实现函数的依次执行

第1步：存放函数指针

Linux几乎每个驱动模块的结尾都要使用module_init这个宏

#define  __used  __attribute__((__used__)) //使用__used__属性
typedef void (*initcall_t)(void);   //定义函数指针类型
#define __define_initcall(fn, id) \   //定义注册函数宏

// 定义函数指针,函数指针名为:__initcall_##fn##id ，例如fn = test，id = 0; 
//则函数指针名为__initcalltest0;
    static const initcall_t __initcall_##fn##id __used \ 
//说明函数指针存储位置，在自定义段中。
    __attribute__((__section__("initcall" #id "init"))) = fn;  
    
#define CORE_INITCALL(fn)     __define_initcall(fn, 0)//比如log或 RTT等。方便下级服务初始化时，能够调试，KV键值
#define BASIC_INITCALL(fn)    __define_initcall(fn, 1)//gpio配置 bsp层
#define DRIVER_INITCALL(fn)   __define_initcall(fn, 2)//驱动层 比如总功能模组
#define SUBSYS_INITCALL(fn)   __define_initcall(fn, 3)//子系统，比如文件系统/USB/网络
#define DEVICE_INITCALL(fn)   __define_initcall(fn, 4)//设备层 各类传感器和外设模组
#define APP_INITCALL(fn)      __define_initcall(fn, 5)//APP层 功能初始化

void sys_do_init_call(void);

例如DEVICE_INITCALL(led_init)就能展开为：

static initcall_t __initcall_led_initinit2 __used \
__attribute__((__section__(".initcall2.init"))) = led_init;

定义一个静态函数指针__initcall_led_initinit2指向初始化函数led_init，并且利用__attribute__把__initcall_led_initinit2链接到.initcall2.init这个内存数据段里。简单来说就是把函数名丢到名为.initcall2.init的内存段里。

第2步：遍历函数指针

在c文件中定义一个入口sys_do_init_call()

void sys_do_init_call(void)
{
    extern initcall_t initcall0init$$Base[];
    extern initcall_t initcall0init$$Limit[];
    extern initcall_t initcall1init$$Base[];
    extern initcall_t initcall1init$$Limit[];
    extern initcall_t initcall2init$$Base[];
    extern initcall_t initcall2init$$Limit[];
    extern initcall_t initcall3init$$Base[];
    extern initcall_t initcall3init$$Limit[];
    extern initcall_t initcall4init$$Base[];
    extern initcall_t initcall4init$$Limit[];
    extern initcall_t initcall5init$$Base[];
    extern initcall_t initcall5init$$Limit[];
    
    initcall_t *fn;
    for (fn = initcall0init$$Base; fn < initcall0init$$Limit; fn++){
        if(fn)
            (*fn)();
    }
    for (fn = initcall1init$$Base; fn < initcall1init$$Limit; fn++){
        if(fn)
            (*fn)();
    }
    for (fn = initcall2init$$Base; fn < initcall2init$$Limit; fn++){
        if(fn)
            (*fn)();
    }
    for (fn = initcall3init$$Base; fn < initcall3init$$Limit; fn++){
        if(fn)
            (*fn)();
    }
    for (fn = initcall4init$$Base; fn < initcall4init$$Limit; fn++){
        if(fn)
            (*fn)();
    }
    for (fn = initcall5init$$Base; fn < initcall5init$$Limit; fn++){
        if(fn)
            (*fn)();
    }   
}

二、实现入口统一

通过initcall，我们可以实现模块的init函数自动执行。但模块还有很多其他操作函数，该如何在应用程序中无需声明即可调用，可以参考Linux中的file operation类型。
我们可以创建一个operation结构体，内含open、close、write、read等成员，当打开某个模块后调用这些入口，实际上使用的是模块源文件中具体实现的各个函数原型。如此，应用程序无需包含模块的头文件，也无需显性的调用模块的函数，实现了应用程序与模块之间的解耦。

1. 创建operation结构体

struct file_operations{
    char *name;
    int fd;
    int (*open)(const char * name, int flags);	//
    int (*read)(int fd, void * buf, int count);
    int (*write)(int fd, void * buf, int count);
    int (*close)(int fd);						        //
	int (*msg)(int fd, void * buf, int count, int src);	//用于消息处理
	void (*proc)(void);						        	//用于做轮询工作
};

1. 构造用于存放设备注册信息的结构体，包含设备信息、注册设备数量等等。存放设备信息的可以是数组、链表，在单片机中使用数组比较方便。

#define FILE_LIST_NUM 							5
struct file_list{
    struct file_operations *list[FILE_LIST_NUM];
    int listNum;
};
static struct file_list g_file_list = {0};

1. 实现一个用于把设备添加到表里的注册函数

int file_register(struct file_operations *file)
{
    int index;
    for(index = 0; index < FILE_LIST_NUM; index++)
    {
        if(g_file_list.list[index] == NULL)
        {
            g_file_list.list[index] = file;
            g_file_list.listNum++;
            return index;
        }
    }
    return -1;
}

1. 实现从表内查找设备的函数

static int file_find(const char* file_name)
{
    int index;
    for(index = 0; index < FILE_LIST_NUM; index++)
    {
        if(strcmp(g_file_list.list[index]->name, file_name) == 0)
        {
            return index;
        }
    }
    return -1;
}

1. 实现移除设备的函数

int file_unregister(struct file_operations *file)
{
    int index;
    index = file_find(file->name);
    if(index != -1)
    {
        g_file_list.list[index] = NULL;
        g_file_list.listNum--;
    }
	return -1;
}

1. 然后实现file_operation结构体成员函数

int file_open(const char *file_name, int flags)
{   
    int fd = file_find(file_name);
    if(g_file_list.list[fd]->open != 0)
        g_file_list.list[fd]->open(file_name, flags);
    return fd;
}

int file_read(int fd, void * buf, int count)
{
	if(g_file_list.list[fd]->read == 0)
	    return -1;
	return g_file_list.list[fd]->read(fd, buf, count);
}

int file_write(int fd, void * buf, int count)
{
	if(g_file_list.list[fd]->write == 0)
		return -1;
	return g_file_list.list[fd]->write(fd, buf, count);
}

int file_close(int fd)
{
	if(g_file_list.list[fd]->close == 0)
		return -1;
	return g_file_list.list[fd]->close(fd);
}

1. 针对单片机程序的特点，添加两个特殊的成员函数。
   一个是用于是实现轮询工作的函数。这个函数会在主函数里轮询，这样可以实现所有注册设备需要反复执行的代码，一次性添加到主循环。

void file_process_poll(void)
{
    int index;
    for(index = 0; index < FILE_LIST_NUM; index++)
    {
        if(g_file_list.list[index] != NULL)
        {
            if(g_file_list.list[index]->proc)
                g_file_list.list[index]->proc();
        }
    }
}

另一个是用于处理数据的函数。实际上数据的处理需求很复杂，比如数据是否独占、是否分发多处、不同类型的数据粘包等等，此处不能满足所有需求

int file_msg_handle_poll(void * buf, int count, int src)
{
    int ret = 0;
    int index;
    for(index = 0; index < FILE_LIST_NUM; index++)
    {
        if(g_file_list.list[index] != NULL)
            if(g_file_list.list[index]->msg)
                if(g_file_list.list[index]->msg(index, buf, count, src) == 1)
                    BIT_SET(ret, g_file_list.list[index]->fd);//通过ret置位，来记录哪个file成功处理了数据
    }
    return ret;
}

1. 综上，

三、结合使用

我们可以在编写模块代码时，将其抽象为一个设备。其初始化函数，可以通过module_init来修饰，使之可以自动执行。而在其初始化函数内，可以初始化open、close、write、read等函数指针，并将设备注册到设备表内。
如此，该设备的proc函数就可以在主循环内执行，msg函数就可以接收到数据，同时也支持应用层对其进行读写等操作。同时，工程不需要增加头文件的包含，不需要增加函数的声明，该设备代码的增减不影响编译，不会产生报错。应用层对模块的操作入口统一。

实例

设备的源文件

static struct file_operations device_lcd_t = {0};
static void lcd_proc(void)
{	
    //负责根据framebuffer，刷新lcd
}
static int dev_lcd_write(int fd, void * buf, int count)
{
    //写lcd的framebuffer
    return 0;
}

static void lcd_dev_init(void)
{
	device_lcd_t.name = "lcd";
	device_lcd_t.proc = lcd_proc;
	device_lcd_t.fd = file_register(&device_lcd_t);
	device_lcd_t.write = dev_lcd_write;
}

module_init(lcd_dev_init);//自动执行

应用内操作设备

int fd = file_open("lcd", NULL);
if(fd != -1)
{
	char string_buf[21] = {0};
	sprintf(string_buf + 1, "H%.1f%% P%.2fkPa", ((float)meteor_t.hum / 100),((float)meteor_t.pressure / 100));
	string_buf[0] = 2;//第二行
	file_write(fd, string_buf, 21);
}

参考连接
https://blog.youkuaiyun.com/baidu_23858427/article/details/128680812
https://blog.youkuaiyun.com/qq_39280795/article/details/123073781
https://blog.youkuaiyun.com/tiantangmoke/article/details/103032612