nRF5 SDK从版本14开始,对事件回调机制做了更新,引入了观察者模式,以解耦不同BLE Layer对BLE事件的回调函数。

实现这套机制用到了Flash的段(Section),将RAM中的函数调用与Flash中的段操作结合到一起,这个想法很新颖。

本文尝试理解和追踪整个回调过程,并写一段代码验证我们的思路。

一、观察者模式简介

面向对象编程世界里有许多著名的设计模式,其中一种叫观察者模式,它解决的问题是:在某场景下对象之间存在一对多的依赖关系,当中心对象的状态发生改变,其他所有依赖于它的对象都能得到通知并自动更新。

观察者模式中有几种角色:观察者(Observer),主题(Subject)和发布者(Publisher)。

多个观察者可以独立的订阅(Subscribe)一个主题,当该主题收到发布者推送的数据,将数据通知(Notify)给各个观察者进行后续处理。

实现观察者模式,观察者端需要实现一个订阅功能,将自己的句柄和回调函数传递给主题。主机端应该有一个列表,所有订阅它的观察者句柄和回调函数都保存在该列表中,当需要通知时,则遍历列表中的各个句柄,分别执行各自的回调函数。发布者给主题发数据,则简单的暴露一个接口即可。

更进一步的,在代码中要将句柄和回调函数封装成一个结构体,这样就可以方便传参。观察者准备一个函数,将该结构体保存到一个列表中,这个函数称为订阅。主题准备一个函数,读取该列表,遍历获得各个结构体,并执行回调,这个函数称为通知。

设计这个列表是关键。

Implement an observer pattern

最简单的办法是准备一个内存数组,订阅函数即写数组,通知函数即读数组。

nRF5 SDK选择了另一种方式,使用Flash的段。

二、Flash段简介

本文使用SEGGER Embedded Studio开发工具进行介绍,它后端使用arm gcc编译器,需要用到它的链接文件(.ld)和map文件(.map)。

Flash的段是指在Flash中指定一块空间,包含首地址和空间长度,并设定一个段名。段名以点(.)开头。

C语言开发中经常提及的段有代码段.text,常量段.rodata等。

Section of C language

利用__attribute__关键字,可以为变量指定段名,以下代码将变量my_var存放在段.my_section中:

static my_type_t my_var __attribute__ ((section(".my_section"))) __attribute__((used)) = 
{
    .handler    = handler,
    .p_context  = NULL
};

还需要在内存布局文件中,设定好该段的起始地址和长度。编译SES工程,将生成链接文件(.ld),可以看到诸如以下代码:

.sdh_ble_observers ALIGN(__pwr_mgmt_data_end__ , 4) : AT(ALIGN(__pwr_mgmt_data_end__ , 4))
{
__sdh_ble_observers_start__ = .;
__start_sdh_ble_observers =   __sdh_ble_observers_start__;
KEEP(*(SORT(.sdh_ble_observers*)))
}
__sdh_ble_observers_end__ = __sdh_ble_observers_start__ + SIZEOF(.sdh_ble_observers);
__sdh_ble_observers_size__ = SIZEOF(.sdh_ble_observers);

其中xx_start__表示起始地址, xx_size__表示长度,xx_end__表示结束地址。

注意到一个关键行:KEEP(*(SORT(.sdh_ble_observers*)))。

该行使用了通配符,.sdh_ble_observers*末尾的星号表示任意字符,所以我们可能在代码中看到形如.sdh_ble_observers1这种段名。SORT表示将这些通配符所匹配的段按名称增序排列。

查看map文件,可以看到如下记录:

.sdh_ble_observers
                0x0000000000030ae4       0x30
                0x0000000000030ae4                __sdh_ble_observers_start__ = .
                0x0000000000030ae4                __start_sdh_ble_observers = __sdh_ble_observers_start__
 *(SORT_BY_NAME(.sdh_ble_observers*))
 .sdh_ble_observers0
                0x0000000000030ae4        0x8 Output/ble_app_blinky_pca10040_s132 Debug/Obj/ble_conn_state.o
 .sdh_ble_observers1
                0x0000000000030aec        0x8 Output/ble_app_blinky_pca10040_s132 Debug/Obj/main.o
 .sdh_ble_observers1
                0x0000000000030af4        0x8 Output/ble_app_blinky_pca10040_s132 Debug/Obj/ble_conn_params.o
 .sdh_ble_observers2
                0x0000000000030afc       0x10 Output/ble_app_blinky_pca10040_s132 Debug/Obj/main.o

在map文件中,我们看到了多个名字相似的段.sdh_ble_observers[0, 1, 2],它们摆列在一起,Flash地址前后相接,并且它们长度之和等于.sdh_ble_observers段长度。

可以认为.sdh_ble_observers*是 .sdh_ble_observers的子段。

如何获取段内的数据呢?

一个是直接调用变量名,比如上面的my_var,另一种是通过段名,索引出其中的子段内容。SDK中提供了段操作的函数库nrf_section_iter, 如果已知一个段名,可以利用以下代码获取其中的子段内容:

nrf_section_iter_t  iter;
for (nrf_section_iter_init(&iter, &my_section);
        nrf_section_iter_get(&iter) != NULL;
        nrf_section_iter_next(&iter))
{
    my_type_t     * p_section;
    p_section = (my_type_t *)nrf_section_iter_get(&iter);
}

三、BLE事件回调

以SDK15.1/ble_app_blinky工程为例, 追踪它的BLE回调事件的调用逻辑。

在main.c –> ble_stack_init()中,调用了:

NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);

其中ble_evt_handler是我们设定的BLE事件回调函数。

NRF_SDH_BLE_OBSERVER是一个异常复杂嵌套宏,经过层层解剖,该代码变成如下形式:

static nrf_sdh_ble_evt_observer_t m_ble_observer __attribute__ ((section(".sdh_ble_observers3"))) __attribute__((used)) =
{
    .handler    =ble_evt_handler,
    .p_context  = NULL
};

这个代码在.sdh_ble_observers3段中定义一个结构体变量,并且将回调函数设定为参数。

那ble_evt_handler()是在什么地方调用的呢?

找到nrf_sdh_ble.c -> nrf_sdh_ble_evts_poll(),看见关键代码:

nrf_section_iter_t  iter;
for (nrf_section_iter_init(&iter, &sdh_ble_observers);
        nrf_section_iter_get(&iter) != NULL;
        nrf_section_iter_next(&iter))
{
    nrf_sdh_ble_evt_observer_t * p_observer;
    nrf_sdh_ble_evt_handler_t    handler;

    p_observer = (nrf_sdh_ble_evt_observer_t *)nrf_section_iter_get(&iter);
    handler    = p_observer->handler;

    handler(p_ble_evt, p_observer->p_context);
}

这正是我们上面分析的,通过段名来获取所有的子段内容,然后执行其回调函数。

仍然在该文件中,进一步找到关键代码:

NRF_SDH_STACK_OBSERVER(m_nrf_sdh_ble_evts_poll, NRF_SDH_BLE_STACK_OBSERVER_PRIO) =
{
    .handler   = nrf_sdh_ble_evts_poll,
    .p_context = NULL,
};

与上面类似,这是个嵌套宏,经过层层解剖,得到如下代码:

static nrf_sdh_stack_observer_t m_nrf_sdh_ble_evts_poll __attribute__ ((section(".sdh_stack_observers2"))) __attribute__((used)) =
{
    .handler    =nrf_sdh_ble_evts_poll,
    .p_context  = NULL
};

那 nrf_sdh_ble_evts_poll()是在什么地方调用的呢?

找到nrf_sdh.c -> nrf_sdh_evts_poll(),看见关键代码:

for (nrf_section_iter_init(&iter, &sdh_stack_observers);
        nrf_section_iter_get(&iter) != NULL;
        nrf_section_iter_next(&iter))
{
    nrf_sdh_stack_observer_t    * p_observer;
    nrf_sdh_stack_evt_handler_t   handler;

    p_observer = (nrf_sdh_stack_observer_t *) nrf_section_iter_get(&iter);
    handler    = p_observer->handler;

    handler(p_observer->p_context);
}

进一步,看到该函数的调用地点:

void SD_EVT_IRQHandler(void)
{
    nrf_sdh_evts_poll();
}

SD_EVT_IRQHandler是BLE事件的中断处理函数,一旦芯片产生BLE事件,都会进入到这个中断处理函数中。按照上面的追踪思路反向推导,就能够调用到最初的ble_evt_handler回调函数。

至此我们搞清楚了BLE事件回调的跳转逻辑。

四、几处细节

(1)SD_EVT_IRQHandler 是什么

它是BLE事件中断。

经过多次重定义跳转,我们找到它最初的名字: SWI2_EGU2_IRQHandler。

在ses_startup_nrf52.s文件中,看出它是一个中断向量:

/* External Interrupts */
  .word   POWER_CLOCK_IRQHandler
  .word   RADIO_IRQHandler
  .word   UARTE0_UART0_IRQHandler
// ....
  .word   COMP_LPCOMP_IRQHandler
  .word   SWI0_EGU0_IRQHandler
  .word   SWI1_EGU1_IRQHandler
  .word   SWI2_EGU2_IRQHandler
  .word   SWI3_EGU3_IRQHandler

为什么它就代表了BLE的事件中断呢?

在芯片手册的Memory章节,找到Instantiation小节,列出了全部的中断向量地址:

Instantiation Table

比较这个列表与上面的中断向量定义,发现它们是一一对应,严格按顺序排列的。所以排到SWI2_EGU2_IRQHandler所在的位置,就代表了SWI2和EGU2的中断向量,无论它取什么名字。

注意,SWI2和EGU2使用了同样的向量地址,所以它们共享一个中断向量,于是向量名称写成SWI2_EGU2_IRQHandler。

(2)为什么要索引两次

在nrf_sdh_evts_poll函数中,调用了 nrf_sdh_ble_evts_poll(),然后再调用我们的ble_evt_handler,为什么要索引两次呢?

仔细看代码发现,nrf_sdh_evts_poll处理了BLE和SOC两种事件。而ble_evt_handler只是BLE事件。

这是因为SWI2和EGU2这二者共享一个中断向量,它们出了给出BLE事件中断,还会给出SOC相关的中断,比如时钟Clock等。

(3)APP_BLE_OBSERVER_PRIO是什么

它代表了优先级。

前面提到.ld文件中使用了SORT对所有子段进行增序排列,优先级数值小的排前面,大的排后面,在索引子段内容时候,总是先执行高优先级(数值小)的回调函数,后执行低优先级(数值大)的回调函数,相同优先级的回调则不能确定执行顺序。

(4)观察者角色

在上面的分析中,NRF_SDH_BLE_OBSERVER意味着订阅函数,main.c中的BLE处理相当于一个观察者。

SDK中将订阅函数进一步封装成BLE_XXX_DEF()的宏形式,比如GATT的订阅函数宏:

NRF_BLE_GATT_DEF(_name)

许多BLE库都提供了订阅函数宏,使用时候只需在main.c中声明它们。

BLE通用订阅函数宏:
#define BLE_ADVERTISING_DEF(_name)
#define BLE_DB_DISCOVERY_DEF(_name)
#define BLE_LINK_CTX_MANAGER_DEF()
#define NRF_BLE_SCAN_DEF(_name)
#define NRF_BLE_GATT_DEF(_name)
#define NRF_BLE_QWR_DEF(_name)

BLE Profile订阅函数宏:
#define BLE_BAS_DEF(_name)
#define BLE_BPS_DEF(_name)
#define BLE_CSCS_DEF(_name)
#define BLE_GLS_DEF(_name)
#define BLE_HIDS_DEF()
#define BLE_HRS_DEF(_name)
#define BLE_HTS_DEF(_name)
#define BLE_LBS_DEF(_name)
...

如果我们创建一个自定义的Profile,也应该提供一个这样的订阅函数宏。

nrf_sdh_ble_evts_poll和nrf_sdh_evts_poll相当于通知函数,nrf_sdh.c和nrf_sdh_ble.c充当主题角色。

发布者是芯片, SD_EVT_IRQHandler中断就是发布者向主题推送数据接口。

五、验证

尝试写一段代码,验证这种段操作的观察者模式。

先定义一个段:syq_sections

typedef void (*syq_handler_t)(uint8_t const evt_code, void * p_context);

typedef struct
{
    syq_handler_t         handler;      //!< BLE event handler.
    void *                p_context;    //!< A parameter to the event handler.
} const syq_type_t;

NRF_SECTION_SET_DEF(syq_sections, syq_type_t, NRF_SDH_BLE_OBSERVER_PRIO_LEVELS);

设定三个不同优先级的段变量:

void syq_handler1(uint8_t const evt_code, void * p_context)
{
    NRF_LOG_INFO("handler1 is triggered");
}

static syq_type_t m_syq_1 __attribute__ ((section(".syq_sections1"))) __attribute__((used)) = 
{
    .handler    = syq_handler1,
    .p_context  = NULL
};

void syq_handler2(uint8_t const evt_code, void * p_context)
{
    NRF_LOG_INFO("handler2 is triggered");
}

static syq_type_t m_syq_2 __attribute__ ((section(".syq_sections2"))) __attribute__((used)) = 
{
    .handler    = syq_handler2,
    .p_context  = NULL
};

void syq_handler3(uint8_t const evt_code, void * p_context)
{
    NRF_LOG_INFO("handler3 is triggered");
}

static syq_type_t m_syq_3 __attribute__ ((section(".syq_sections3"))) __attribute__((used)) = 
{
    .handler    = syq_handler3,
    .p_context  = NULL
};

在主函数中执行索引:

nrf_section_iter_t  iter;
for (nrf_section_iter_init(&iter, &syq_sections);
        nrf_section_iter_get(&iter) != NULL;
        nrf_section_iter_next(&iter)) {
    syq_type_t * p_observer;
    syq_handler_t    handler;

    p_observer = (syq_type_t *)nrf_section_iter_get(&iter);
    handler    = p_observer->handler;

    handler(1, p_observer->p_context);
}

这样就可以依次执行三个不同优先级的回调函数,打印结果如下:

利用这套做法,实现了一个简单的观察者模式。

(完)