C语言实现信号槽的项目实践

目录

• 一.前言
• 二.平台及运行环境
• 三.代码实现
• 1.定义相关数据类型
• 2.信号定义相关
• 3.相关函数实现
• 四.moc脚本实现
• 五.使用
• 1.测试程序编写
• 2.执行结果
• 六.总结

一.前言

前段时间使用qt做了个项目,了解到信号槽这种机制,在解耦合和程序设计的方便程度上体现出极度的优雅与从容.

现在回到单片机程序开发上来,感受到之前的单片机程序写的还不够优雅,使用函数指针能够实现解耦合,但需要设置回调函数,而且不同的模块设计的回调函数不尽相同,最大的痛点是实现异步调用非常复杂,与优雅二字基本是毫无关联了.

网上查阅了一遍,发现别人设计的信号槽要么只支持同步调用,要么实现过程复杂,代码量巨大,要么代码量巨大还只支持同步调用,要么居然还要自己去实现信号,信号不是给个函数声明就行了吗?还有的是闭源代码,好像是需要购买?

介于以上原因,本人打算自己实现信号槽机制,应用于单片机编程.实现的完整代码不到300行,支持同步异步混合调用,一对多多对一多对多等.当然,本文程序也有局限性,就是只支持单片机.因为只测试了单片机.

二.平台及运行环境

对单片机的配置还是有一定的要求,内存太小的话能支持的信号和槽的数量就会有限制,使用体验上就会捉襟见肘;由于信号槽调用比回调函数速度慢,在信号槽数量多的情况下如果CPU算力不够可能会影响业务逻辑.本文代码不会限制信号和槽的数量,只要内存够.
由于异步调用需要操作系统支持,本文程序基于rt-thread,如需支持其他操作系统,需要做相应修改

三.代码实现

1.定义相关数据类型

在 signal.h 文件中声明数据类型如下:

// 声明信号和发送宏
#define signal void
#define emit

// 槽列表
typedef struct _slot_list{
  struct _slot_list *next;// 下一个槽
  void *fun;// 槽函数
  void *mb;// 槽函数运行的线程
  void *obj;// 槽函数所在类
}slot_list;

// 信号
typedef struct{
  const char *name;// 信号名
  const char *file;// 信号所在文件
  void *signal_;// 信号
  slot_list *head;// 槽列表
}signal_def;

// 消息
typedef struct{
  void *fun;// 要执行的函数
  void *src;// 消息源
  int param_num;// 参数个数
  uint32_t param[0];// 参数列表
}slot_msg_def;

// 异步调用
typedef struct{
  void *mb;
  int run;
}slot_run_def;

// 线程
typedef void * sig_thread;

2.信号定义相关

为了使系统知道程序中有哪些信号,还需要在信号的定义上下功夫,既要使程序能正常执行,又需要使用户在编程使又只需要声明信号,而不需要去实现.本文程序仿照qt中的做法,使用moc脚本来自动生成信号的实现.
在 signal.h 中声明宏:

// 这个宏用于声明信号,声明了之后系统就能找到这个信号
// 这个宏用户编程时不需要使用
#define signal_export(name_) \

  const static char __sig_##name_##_name[] SECTION(".rodata.sigstr") = #name_; \

  const static char __sig_##name_##_file[] SECTION(".rodata.sigstr") = __FILE__; \

  RT_USED static signal_def _signal_##name_ SECTION("signalstruct")= \

  {\

    .name=__sig_##name_##_name,\

    .file=__sig_##name_##_file,\

    .signal_=name_,\

    .head=0,\

  };

信号声明示例:
用户编程时只需要在需要使用信号的头文件中,使用 signal 关键字声明信号原型即可,moc脚本会自动生成信号的实现,保证c语言程序结构正常.如下:

#include "signal.h"

signal pmcu_test_signal(int *a,int b);

信号实现示例:
在此展示一下moc脚本生成的信号实现长什么样,这部分用户使用过程中无需关心:

#include "stdlib.h"
#include "signal.h"

void pmcu_test_signal(int *a,int b)
{
  uint32_t *param=malloc(sizeof(uint32_t)*2);
  param[0]=(uint32_t)a;
  param[1]=(uint32_t)b;
  _signal_emit(pmcu_test_signal,param,2);
  free(param);
}
signal_export(pmcu_test_signal);

3.相关函数实现

signal.c 文件实现如下:
其中 param_check(s) 是断言 参数s是否为0的宏

#include "signal.h"
#include "board.h"
#include "stdlib.h"
#include "stdio.h"

typedef struct{
  void *mutex;
}self_def;

static self_def g_self;

// 在系统启动时初始化信号量系统
int signal_init(void)
{
  self_def *s=&g_self;
  if(s->mutex==0)
  {
    s->mutex=rt_mutex_create("signal_",RT_IPC_FLAG_FIFO);
  }
  return 0;
}

// 4字节拷贝
static void cpy4byte(uint32_t *dst,uint32_t *src,int num_4byte)
{
  for(int i=0;i<num_4byte;i++)
  {
    dst[i]=src[i];
  }
}

// 调用这个宏执行槽函数
#define SLOT_FUN_RUN(fun,param) \

  ((slot_fun_def)(fun))(param[0],param[1],param[2],\

    param[3],param[4],param[5],param[6],param[7])

// 槽函数定义
typedef void (*slot_fun_def)(uint32_t a,uint32_t b,uint32_t c,uint32_t d,uint32_t e,uint32_t f,uint32_t g,uint32_t h);

// 异步调用线程
static void slot_run(void *t)
{
  param_check(t);
  slot_run_def *s=t;
  int msg_size=sizeof(slot_msg_def)+sizeof(uint32_t)*8;
  slot_msg_def *msg=malloc(msg_size);
  while(s->run)
  {
    rt_mq_recv(s->mb,msg,msg_size,RT_WAITING_FOREVER);
    SLOT_FUN_RUN(msg->fun,msg->param);
  }
  free(msg);
}

// 创建一个线程
sig_thread thread_creat(int pro)
{
  static int count=0;
  char name[20]={0};
  slot_run_def *run=malloc(sizeof(slot_run_def));
  run->run=1;
  sprintf(name,"sig_mq#%d",count);
  run->mb=rt_mq_create(name,(sizeof(slot_msg_def)+sizeof(uint32_t)*8),20,RT_IPC_FLAG_FIFO);
  sprintf(name,"sig_t#%d",count);
  rt_thread_t rt_t=rt_thread_create(name,slot_run,run,2048,pro,20);
  rt_thread_startup(rt_t);
  count++;
  return run->mb;
}

void thread_delete(sig_thread t)
{
  // 删除线程需要删除与此线程相关的所有信号槽
  // 删除消息队列
  param_check(0);
}

// 连接信号和槽参数分别为:信号,槽线程,槽所在类,槽函数
int connect(void *signal_,sig_thread t,void *slot_obj,void *slot)
{
  self_def *s=&g_self;
  signal_def *sig;
  sig=signal_find(signal_);
  if(sig==0) return -1;
  rt_mutex_take(s->mutex,RT_WAITING_FOREVER);
  slot_list *slo=malloc(sizeof(slot_list));
  param_check(slo);
  slo->fun=slot;
  slo->mb=t;
  slo->next=0;
  slo->obj=slot_obj;
  if(sig->head==0)
  {
    sig->head=slo;
  }
  else{
    slot_list *next=sig->head;
    while(next->next!=0)
    {
      next=next->next;
    }
    next->next=slo;
  }
  rt_mutex_release(s->mutex);
  return 0;
}

// 信号和槽断开连接,参数同上
int disconnect(void *signal_,sig_thread t,void *slot_obj,void *slot)
{
  self_def *s=&g_self;
  signal_def *sig;
  sig=signal_find(signal_);
  if(sig==0) return -1;
  rt_mutex_take(s->mutex,RT_WAITING_FOREVER);
  slot_list *next=sig->head;
  slot_list *prev=0;
  while(next!=0)
  {
    if(next->fun==slot&&next->mb==t&&next->obj==slot_obj)
    {
      if(prev) prev->next=next->next;
      else sig->head=next->next;
      free(next);
    }
    prev=next;
    next=next->next;
  }
  rt_mutex_release(s->mutex);
  return -1;
}

// 查找信号结构体
signal_def *signal_find(void *signal_)
{
  extern const int signalstruct$$Base;
  extern const int signalstruct$$Limit;
  signal_def *start=(signal_def *)&signalstruct$$Base;
  signal_def *end=(signal_def *)&signalstruct$$Limit;
  for(signal_def *t=start;t<end;t++)
  {
    if(t->signal_==signal_)
    {
      return t;
    }
  }
  return 0;
}

// 发送信号,这个函数用户无需关心
// 用户编程发送信号使用 emit signal_fun(); 语法即可
int _signal_emit(void *signal_,uint32_t *param,int param_num)
{
  self_def *s=&g_self;
  signal_def *sig=signal_find(signal_);
  if(sig==0) return -1;
  if(param_num>7) return -2;
  int size=sizeof(slot_msg_def)+sizeof(uint32_t)*(8);
  slot_msg_def *m=malloc(size);
  rt_mutex_take(s->mutex,RT_WAITING_FOREVER);
  slot_list *h=sig->head;
  m->param_num=param_num;
  m->src=signal_;
  while(h)
  {
    m->fun=h->fun;
    if(h->obj)
    {
      cpy4byte(m->param+1,param,param_num);
      m->param[0]=(uint32_t)h->obj;
    }else{
      cpy4byte(m->param,param,param_num);
    }
    if(h->mb){
      rt_mq_send(h->mb,m,size);
    }else{
      SLOT_FUN_RUN(m->fun,m->param);
    }
    h=h->next;
  }
  rt_mutex_release(s->mutex);
  free(m);
  return 0;
}

signal.h 文件中添加函数声明:

sig_thread thread_creat(int pro);
void thread_delete(sig_thread t);
signal_def *signal_find(void *signal_);
int connect(void *signal_,sig_thread t,void *slot_obj,void *slot);
int disconnect(void *signal_,sig_thread t,void *slot_obj,void *slot);
int signal_init(void);

// 这个函数用户无需关心
int _signal_emit(void *signal_,uint32_t *param,int param_num);

四.moc脚本实现

moc脚本的工作就是定义信号函数,在每次编译之前必须调用moc脚本,否则编译报错.完整代码如下:

import os

MOD_FILE="mod_signals.c"
MOD_PATH="./source/task/"

def find_file(path:str,fix:str):
    file_list=[]
    for file_name in os.listdir(path):
        if file_name.endswith(fix):
            file_list.append(os.path.join(path, file_name))
    return file_list

def find_signal_def(file):
    list_signal=[]
    with open(file) as f:
        list_str=f.readlines()
        for i in list_str:
            if(i[0:6]=="signal"):
                list_signal.append(i)
    return list_signal

# 截取变量名
def split_par_name(par_str:str):
    ret_str=""
    if(par_str.count('*')>0):
        ret_str=par_str.split("*")[1].strip()
    else:
        ret_str=par_str.split(" ")[1]
    return ret_str

def def_signal_fun(line:str):
    # 删除多余空格
    line=' '.join(line.split())
    # print(line)
    list_str=line.split('(')
    fun_name=list_str[0].split(' ')[1]
    param_str=list_str[1].split(')')[0]
    params=[]
    # 有","则至少有两个参数否则可能有一个参数,可能没有
    if(param_str.count(',')>0):
        params=param_str.split(',')
        for i in range(len(params)):
            params[i]=params[i].strip()
    else:
        t_str=param_str.strip()
        if(len(t_str)>0)and(t_str!="void"):
            params.append(t_str)
    # print(fun_name,params)
    params_num=len(params)
    fun_str=""
    fun_str+="void "+fun_name+"("
    for i in range(params_num):
        fun_str+=params[i]
        if(i<len(params)-1):
            fun_str+=","
    fun_str+=")\n{\n"
    fun_str+="  uint32_t *param=malloc(sizeof(uint32_t)*{d});\n".format(d=params_num)
    for i in range(params_num):
        fun_str+="  param[{d1}]=(uint32_t){d2};\n".format(d1=i,d2=split_par_name(params[i]))
    fun_str+="  _signal_emit({d1},param,{d2});\n".format(d1=fun_name,d2=params_num)
    fun_str+="  free(param);\n}\n"
    fun_str+="signal_export({d});\r\n\r\n\r\n\r\n".format(d=fun_name)
    # print(fun_str)
    return fun_str

def ergodic_signal_fun(path):
    fun_str=""
    list_file=find_file(path,".h")
    for i in list_file:
        list_signal=find_signal_def(i)
        for j in list_signal:
            fun_str+=def_signal_fun(j)
    return fun_str

def mod_fine_creat(file_path):
    with open(file_path,"w+") as f:
        f.write("#include \"stdlib.h\"\n")
        f.write("#include \"signal.h\"\r\n\r\n\r\n\r\n")
        f.write(ergodic_signal_fun(MOD_PATH))

mod_fine_creat(MOD_PATH+MOD_FILE)
print("mod_file creat success.\n")

使用moc脚本:
keil中做如下设置,可在每次编译前自动调用moc脚本:

五.使用

1.测试程序编写

编写 main.c 如下:

// 使用信号槽功能需要包含此文件
#include "signal.h"
// 此文件声明了pmcu_test_signal 信号,如前文所述
#include "prot_mcu.h"

// 定义槽函数
void slot_test(int *a,int b)
{
  int int_array[20]={0};
  int_array[0]=a[0];
  int_array[1]=a[1];
  int_array[2]=a[2];
  int_array[3]=a[3];
  int_array[4]=a[4];
  int_array[5]=b;
}
// 定义槽函数,假设a是函数所在类
void slot_test2(int *a,int *b,int c)
{
  int int_array[20]={0};
  int_array[0]=a[0];
  int_array[1]=a[1];
  int_array[2]=a[2];
  int_array[3]=a[3];
  int_array[4]=a[4];
  int_array[5]=c;
}

int main()
{
  // 定义数据,异步调用时需保证数据在函数执行时还有效
  int int_array[20]={4,3,5,2,1};
  // 创建异步调用线程,如不需要异步调用,则无需创建线程
  sig_thread t=thread_creat(20);
  // 连接信号和槽,异步调用,这个槽将在线程t中运行
  connect(pmcu_test_signal,t,0,slot_test);
  // 同步调用,这个槽将在调用信号的线程中运行
  connect(pmcu_test_signal,0,0,slot_test);
  // 异步调用,假设int_array是槽函数所在类
  connect(pmcu_test_signal,t,int_array,slot_test2);
  while(1)
  {
    rt_thread_mdelay(1000);
    // 发送信号,emit不是必须的,但出于可读性要求,还是加上比较好
    emit pmcu_test_signal(int_array,8);
  }
  
}

程序中 pmcu_test_signal 信号连接了3个槽,因此发送信号时,每个槽都会执行一遍,其中没有所属类的槽函数 slot_test 会执行两遍,一次在main函数线程,一次在异步线程; slot_test2函数有所属类,其第一个参数就是所属类的指针,执行在异步线程.

2.执行结果

进入调试界面:

通过调试信息分析:
此时槽 slot_test 在异步线程中执行,并且参数传入正常

此时槽 slot_test 在同步线程中执行,并且参数传入正常

此时槽 slot_test2 在异步线程中执行,并且参数传入正常

六.总结

寥寥几行就实现了类于类之间的解耦合,异步调用实现更是简单,基于此模型的编程各模块只需要关注自己内部的业务逻辑,在合适的时候发出信号就行了,至于有没有模块需要,哪些模块需要,就不需要关心了.