一篇学会回调函数-什么是回调函数

函数指针

学习回调函数，其实就是函数指针的应用，关于函数指针在之前的文章《指针与函数》中有详细的讲解，这里不再展开详解，重新贴一下之前文章中函数指针的示例代码：

#include <stdio.h>
void MyFun1(int x);
void MyFun2(int x);
void MyFun3(int x);
typedef void (*FunType)(int); /* ②. 定义一个函数指针类型FunType,与①函数类型一致 */
void CallMyFun(FunType fp, int x);
int main(int argc, char *argv[])
{
    CallMyFun(MyFun1, 10); /* ⑤. 通过CallMyFun函数分别调用三个不同的函数 */
    CallMyFun(MyFun2, 20);
    CallMyFun(MyFun3, 30);
}
void CallMyFun(FunType fp, int x) /* ③. 参数fp的类型是FunType。*/
{
    fp(x); /* ④. 通过fp的指针执行传递进来的函数，注意fp所指的函数是有一个参数的。 */
}
void MyFun1(int x) /* ①. 这是个有一个参数的函数，以下两个函数也相同。 */
{
    printf("MyFun1:%d\n", x);
}
void MyFun2(int x)
{
    printf("MyFun2:%d\n", x);
}
void MyFun3(int x)
{
    printf("MyFun3:%d\n", x);
}

运行结果如下：

为什么需要回调函数

这里先说一下软件分层的问题，软件分层的一般原则是：上层可以直接调用下层的函数，下层则不能直接调用上层的函数。这句话说来简单，在现实中，下层常常要反过来调用上层的函数。

比如你在拷贝文件时，在界面层调用一个拷贝文件函数。界面层是上层，拷贝文件函数是下层，上层调用下层，理所当然。但是如果你想在拷贝文件时还要更新进度条，问题就来了。

一方面，只有拷贝文件函数才知道拷贝的进度，但它不能去更新界面的进度条。另外一方面，界面知道如何去更新进度条，但它又不知道拷贝的进度。怎么办?

常见的做法，就是界面设置一个回调函数给拷贝文件函数，拷贝文件函数在适当的时候调用这个回调函数来通知界面更新状态。

上面主要说的一个大型软件分层理念，作为嵌入式开发程序员，特别是单片机的开发中，由于和硬件结合紧密且需要快速响应，软件结构大部分是面向过程开发的，回调函数使用频率并不高。但在软件中使用回调函数，可以让软件更加模块化。

上图形象展示了回调函数的作用，上面说到了软件分层，在嵌入式代码中我们一般将和硬件交互的代码称为硬件层，业务逻辑代码称为应用层代码，对于优秀的的嵌入式代码，一般要求硬件层和应用层代码分开。

一般的回调函数代码结构如下：


typedef void (*ReceiveFarmDataFun)();

static CallbackReceive_t HandlerCompleted;

/*用来注册回调函数的功能函数*/
void CallbackRegister (CallbackFunc_t callback_func) {
     HandlerCompleted = callback_func;
}

串口应用

在嵌入式应用中，串口通信是很经典且常用的外设，举一个简单的栗子，接收的串口数据帧头是@，帧尾是*。中间数据不可能出现@和*。那么一般情况下代码如下编写。


/*串口中断函数*/
uint8_t receive_flg = 0;
uint8_t receive_data[100];
uint8_t USART1_data = 0;
uint8_t USART1_data_len = 0;
uint8_t USART1_receive_sta = 0;
void USART1_IRQHandler(void)
{
  uint8_t data_tmp;
  if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE))
  {
    data_tmp = USART_ReceiveData(USART1);
    if((data_tmp == '*')&&(USART1_receive_sta == 1))
    {
      receive_flg = 1;
      USART1_receive_sta = 0;
      receive_data[USART1_data_len++] = data_tmp;
    }
    if(receive_flg == 0){
      if(data_tmp == '@')
      {
        USART1_receive_sta = 1;
        USART1_data_len = 0;
      }
      if(USART1_receive_sta)
        receive_data[USART1_data_len++] = data_tmp;
      if(USART1_data_len > (100-1))
      {
        receive_flg = 0;
        USART1_receive_sta = 0;
      }
    }
    USART_ClearFlag(USART1, USART_FLAG_RXNE);
  }
}
/*应用层代码，简单化->在main函数*/
void main()
{
    /*省略其他代码*/
    while(1)
    {
        if(receive_flg == 1)//通过检查receive_data判断是否接收到函数
        {
          /*通过receive_data数组处理数据*/
          receive_flg = 0;
        }
    }
}

这样实现功能是没有问题的，在我接触到很多的项目中的确是类似的架构，但是它的移植性较差。

还有一种情况，那就是如果你接到需求把硬件层封装给客户使用，不让客户看到源码，封装成库，起到"保护通讯协议"的目的，那么你要告诉客户，需要判断receive_flg变量，然后读取receive_data数组的内容???

不得不说，你这样干是可以的，但是大部分公司不会这样干的。这时候可以使用回调函数来解决这个问题。

/*开放给客户的头文件*/
/* Includes ------------------------------------------------------------------*/
#include <stdio.h>
typedef void (*ReceiveFarmDataFun)(uint8_t *buff,uint32_t bufferlen);
extern void CallbackRegister (CallbackFunc_t callback_func)；

/*封装的函数*/
static CallbackReceive_t HandlerCompleted;
void CallbackRegister (CallbackFunc_t callback_func) {
     HandlerCompleted = callback_func;
}
uint8_t receive_flg = 0;
uint8_t receive_data[100];
uint8_t USART1_data = 0;
uint8_t USART1_data_len = 0;
uint8_t USART1_receive_sta = 0;
void USART1_IRQHandler(void)
{
  uint8_t data_tmp;
  if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE))
  {
    data_tmp = USART_ReceiveData(USART1);
    if((data_tmp == '*')&&(USART1_receive_sta == 1))
    {
      receive_flg = 1;
      USART1_receive_sta = 0;
      HandlerCompleted(receive_data,USART1_data_len);
    }
    if(receive_flg == 0){
      if(data_tmp == '@')
      {
        USART1_receive_sta = 1;
        USART1_data_len = 0;
      }
      if(USART1_receive_sta)
        receive_data[USART1_data_len++] = data_tmp;
      if(USART1_data_len > (100-1))
      {
        receive_flg = 0;
        USART1_receive_sta = 0;
      }
    }
    USART_ClearFlag(USART1, USART_FLAG_RXNE);
  }
}

那么客户拿到的有用信息如下：

typedef void (*ReceiveFarmDataFun)(uint8_t *buff,uint32_t bufferlen);
extern void CallbackRegister (CallbackFunc_t callback_func)；

客户可以写如下代码：

void uartdatadeal(uint8_t *buff,uint32_t bufferlen)
{
    /*buff指针存储了串口数据，bufferlen存储数据长度*/
    /*客户的应用层代码*/
}
void main()
{
    /*省略其他代码*/
    CallbackRegister (uartdatadeal);
    while(1)
    {
    }
}

这样的话，就可以解决上述问题，客户只要注册一下串口接收的函数，当接收到有效数据后，就可以跳转到用户的代码，而你可以将自己的硬件层封装起来。

看到这里可能有嵌入式大佬意识到某些问题了，这样写代码，数据处理的函数就等于在中断里了，这是不合理的啊。

是的，是有这个问题，所以给客户的库文件必须说明这一点，让客户自行选择，客户不想在中断中执行，可以再按照我们一开始的逻辑写啊，如下：

void uartdatadeal(uint8_t *buff,uint32_t bufferlen)
{
    /*buff指针存储了串口数据，bufferlen存储数据长度*/
    receive_flg = 1;
}
void main()
{
    /*省略其他代码*/
    CallbackRegister (uartdatadeal);
    while(1)
    {
        if(receive_flg == 1)
        {
            /*处理数据*/
           receive_flg = 0;         
        }
    }
}

事实上，芯片/模块厂家写SDK经常这样做，一些大型的开源库也会这样用，典型的如lwip库。

后记

读到这里的同学可能觉得这完全是“脱裤子放屁”啊，这属于“炫技”啊，没什么用啊。诚然在很多应用中，特别是一些单片机项目中，代码量不大，使用类似receive_flg全局变量控制，代码结构也清晰啊。

并且项目不需封装库给客户，一个单片机软件开发工程师可以吃透整个项目的代码，根本不需要这样的“骚操作”。

关于回调函数，我的态度是：回调函数可以使我们的代码更高效且更易于维护，降低耦合。明智地使用它们很重要，否则过度使用回调(函数指针)会使代码难以进行排查和调试。