编译了 BLE_p2pServer 这个工程以后，我就可以用GDB进行跟踪调试了。跟踪跟踪，姑且看看这个软件框架是什么样的，不作详细分析了（时间也不允许）。

从 main.c 入手，主函数 main() 就写了一些函数调用而已：
& `6 [0 D7 d) X* ^int main(void)
" d: S+ h  C. c1 u3 P9 Y{
: T3 g3 l# R9 ?! [) a+ cHAL_Init();
+ @$ m( k- R4 k4 c8 z1 \- NReset_Device();
, l1 Z! H5 j# SConfig_HSE();
" Q. m0 e) x, V3 r$ `SystemClock_Config();
PeriphClock_Config();
  ?; X4 J% _& H& P4 M; ^" bInit_Exti();
8 t) M( E3 A3 p, E' `* V* SMX_GPIO_Init();
MX_DMA_Init();
MX_RF_Init();
% h( d* I0 f* F4 |MX_RTC_Init();
% Q0 l: k# ]% e. A* v) jAPPE_Init();
$ }. }: S5 \; h. u3 D+ zwhile(1)
{
+ m; ^5 Z6 N1 K% z$ tSCH_Run(~0);
}
}

首先是 HAL_Init() 这个库函数, 起初始化 HAL 库的作用，其中又调用了 stm32wbxx_hal_msp.c 中写的用户初始化代码 HAL_MspInit(), 执行工程相关的初始化。本工程执行了一个 __HAL_RCC_HSEM_CLK_ENABLE();
　　然后是 Reset_Device(), 这个函数就在 main.c 中，里面执行的是 Reset_BackupDomain() 和 Reset_IPCC() ——可能是这部分硬件并不是和CPU一起复位的，所以需要单独处理下。
! i! E5 X' J0 n0 Y) C; T- b" y+ e5 @　　接下来的 Config_HSE(), SystemClock_Config() 和 PeriphClock_Config() 是配置系统各种时钟的，根据程序运行的需要设置。
　　Init_Exti(), MX_GPIO_Init(), MX_DMA_Init(), MX_RF_Init(), MX_RTC_Init() 这几个函数配置 EXTI, GPIO, DMA, RTC 这几个基本的硬件。不过 MX_RF_Init() 函数里面是空的，硬件初始化并不在这里（估计是由另外那个CPU2做的）。以上这些函数都容易看懂，就是在使用无线功能以前做好其它片上设备的准备工作。HSEM 和 IPCC 是 STM32WB55 的两个特殊硬件，双核通信要用到。
　　然后，就到了 APPE_Init() 函数了，它在 app_entry.c 中定义。函数名的意思是初始化应用程序（前面的初始化只是硬件），它里面的函数会跟 WPAN 库打交道。

void APPE_Init( void )
) z2 d0 }& [( Y/ ?% e{
SystemPower_Config();
7 F' J6 f. y' H9 @+ f1 ?* n+ [HW_TS_Init(hw_ts_InitMode_Full, &hrtc);
Init_Debug();
; }$ Z& d- j3 U1 p/ l1 A8 cLPM_SetOffMode(1 << CFG_LPM_APP, LPM_OffMode_Dis);
: M# z0 v6 {5 l1 Q. z4 W7 F& MLed_Init();
4 t# I8 ?: |- U" f8 J% DButton_Init();
appe_Tl_Init();
}

这其中 HW_TS_Init() 在 hw_timerserver.c 中定义，顾名思义是初始化软件定时器(服务)。瞅了瞅代码，这是基于RTC实现的功能，至于软件定时器提供给谁用的？姑且发现在 app_ble.c 中调用了 HW_TS_Create.
: b8 y1 X3 L4 `: ~　　Init_Debug() 函数用了 dbg_trace.c 中的 DbgTraceInit(), 初始化了 USART1. 运行这个程序时通过串口输出的信息就是软件自带的 Debug 支持。
　　最后的 appe_Tl_Init() 又是重头戏了, 函数名中 “Tl” 是 Transport layer 的缩写，这个函数在 appe_entry.c 中，不过调用的是 WPAN 库里面的函数。由于我没有找到这个库的手册，这里需要如何初始化不清楚，从代码只能略猜一二。

APPE_Init() 执行完毕之后，回到 main() 当中，开始一个死循环：重复调用 SCH_Run(). 这个函数定义在 scheduler.c 中，也就是执行调度器的意思。但是这里的调度器和我熟悉的 FreeRTOS 的调度器不同，后者是不会返回的，因此不需要放在循环里面。为了确认这一点，我在 SCH_Run() 函数入口设置断点，然后恢复执行，CPU仍然会再次遇到断点。在 SCH_Run() 函数体中，执行每个任务是通过一条语句：
  P$ N& X3 e% l' Y+ f* r( |, R/** Execute the task */
- i' a( a" J0 q  ~- O8 ^  ^TaskCb31 - bit_nbr;
这里有一个数组 TaskCb 存放任务对应的函数，不妨看看里面有什么：
3 z6 q  }1 l3 G" K& Z, w9 C(gdb) print TaskCb
, L; n) E, g0 I8 ^$1 = {0x8001eb9 , 0x8002371 ,
8 t8 u0 u) l/ f+ `0x80058ed , 0x8005f5d }
. ]9 b; I6 }* X) G* r2 W3 ?* O里面有四个“任务”，不过从我对 scheduler.c 的观察看来，这不是真正的 RTOS ——每个任务没有独立的堆栈，不能嵌套执行。

这四个任务分别在什么时候注册的呢？我在 SCH_RegTask() 函数入口设断点，再来跟踪一次。
6 y' y- X: W# Y! t8 e9 H% @1 L3 U　　第一次调用：appe_Il_Init() 里面, task_id=3
SCH_RegTask( CFG_TASK_SYSTEM_HCI_ASYNCH_EVT_ID, shci_user_evt_proc );
: |5 C! _. m* }4 f% y3 }4 o　　第二次调用：APP_BLE_Init() 里（app_ble.c），task_id=2
: t* Q) J; {& _$ j: l9 @) LSCH_RegTask(CFG_TASK_HCI_ASYNCH_EVT_ID, hci_user_evt_proc);
　　第三次调用：仍然在 APP_BLE_Init() 里，task_id=0
+ K* G3 N( [# \; gSCH_RegTask(CFG_TASK_ADV_CANCEL_ID, Adv_Cancel);
  P. A- v$ Z( P, M5 h' `" K0 [8 K　　第四次调用：在 p2p_server_app.c 的 P2PS_APP_Init() 函数里，task_id=1
# U" K, Z% E  n; T( E! q0 }SCH_RegTask( CFG_TASK_SW1_BUTTON_PUSHED_ID, P2PS_Send_Notification );

这里 CFG_TASK…ID 的定义在 app_conf.h 中可以找到。p2p Server程序一共注册了如上这四个任务。与其说是任务，不如说是事件处理子程序吧。从名称上看，task_id 3,4这两个分别是 hci 和 shci 的用户事件处理程序（HCI是 Host Controller Interface的话，SHCI又是什么呢？），分别在 hci_tl.c 和 shci_tl.c 中定义，结构也相似。task_id为0的这个是停止广播。task_id为1的这个子程序是向BLE client发送通知的，即按键触发的事件处理。
　　到这里，大概了解到 STM32WB55 的 demo 应用程序是“事件驱动”组织的。在初始化过程中建立起调度器，将处理不同事件的“任务”交由调度器管理。调度器在有任务需要处理的时候调用相应任务的函数。这背后当然还得有硬件中断(IRQ)来驱动。

不妨就跟踪一下按键引发的中断：EXTI的 IRQ 处理过程。按下SW1时，EXTI中断服务程序被硬件执行void PUSH_BUTTON_SW1_EXTI_IRQHandler(void)
& q1 A: `  ], a$ n" g/ A4 U  e{
HAL_GPIO_EXTI_IRQHandler(BUTTON_SW1_PIN);
}
　　就直接调用 HAL 库的中断处理函数
4 I* W% G! X4 ~# A0 }void HAL_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin)
% K6 \' Y7 B3 L8 I; ~3 y5 \{
/* EXTI line interrupt detected */
if(__HAL_GPIO_EXTI_GET_IT(GPIO_Pin) != 0x00u)
{
2 o! |( A) I$ m% ?. C2 m__HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin);
HAL_GPIO_EXTI_Callback(GPIO_Pin);
6 s" g/ C. T3 V; X& _}
}
　　它调用用户编写的中断处理函数
- O7 h2 |0 ?$ Cvoid HAL_GPIO_EXTI_Callback( uint16_t GPIO_Pin )
{
switch (GPIO_Pin)
{
case BUTTON_SW1_PIN:
3 L$ r- b, L, u. o9 y1 SAPP_BLE_Key_Button1_Action();
break;
% a0 S2 C. ^$ u5 }5 ccase BUTTON_SW2_PIN:
APP_BLE_Key_Button2_Action();
4 N5 ^8 B6 ~% y8 N: \/ g# D) H6 Fbreak;
0 ?. |1 E1 t/ C. e9 W9 \; ncase BUTTON_SW3_PIN:
" f# I  y. x( F  ~5 oAPP_BLE_Key_Button3_Action();
break;
default:
break;
) ~- `& x" j2 k" k}
return;
! D% r, M" Z  I  X, o' L& F( y6 M}
　　结果就是选择调用了
void APP_BLE_Key_Button1_Action(void)
) F3 k; \" u" ^3 n3 N! ^/ j{
* c! b$ Q3 _( G  }+ \P2PS_APP_SW1_Button_Action();
}
　　最终是到这里
6 h" l# \/ P9 o8 nvoid P2PS_APP_SW1_Button_Action(void)
{
; J' U8 y, I. g4 @" |SCH_SetTask( 1<
return;
}

层层嵌套调用很冗长吧，除去简单判断，就是做了个触发事件处理(任务)的操作。对按键的响应转移到了一个任务函数中，而不是在中断服务里面处理，这个特点又和RTOS一致。

再看另外一个，我跟踪了一次 IPCC接收中断（和CPU2通信使用）的响应过程：
% B$ j, x! u  W' Ivoid IPCC_C1_RX_IRQHandler(void)
$ Q1 c, X* Y& Y! F0 V{
$ b4 {  c7 R2 yHW_IPCC_Rx_Handler();
return;
}
. {4 G. H0 j+ |# U1 a, [* B% e0 a　　调用的是 hw_ipcc.c 中的 HW_IPCC_Rx_Handler 来处理
void HW_IPCC_Rx_Handler( void )
{
if (HW_IPCC_RX_PENDING( HW_IPCC_THREAD_NOTIFICATION_ACK_CHANNEL ))
{
HW_IPCC_THREAD_NotEvtHandler();
}
/ i+ A, V: o. T7 E9 S- W5 ~& Zelse if (HW_IPCC_RX_PENDING( HW_IPCC_BLE_EVENT_CHANNEL ))
0 |5 A6 o9 v* A4 z1 J" d! K4 ^1 ^{
HW_IPCC_BLE_EvtHandler();
}
0 ~2 ~4 V/ ^! R/ F" E- ?else if (HW_IPCC_RX_PENDING( HW_IPCC_SYSTEM_EVENT_CHANNEL ))
{
4 ], x. c; x& T8 gHW_IPCC_SYS_EvtHandler();
, b' G% V: ]1 M# y  D8 f; |- G9 @}
else if (HW_IPCC_RX_PENDING( HW_IPCC_TRACES_CHANNEL ))
{
5 y, E1 ?, U! x1 d% b. iHW_IPCC_TRACES_EvtHandler();
: J' i! e$ K3 @7 ^4 T) a}
else if (HW_IPCC_RX_PENDING( HW_IPCC_THREAD_CLI_NOTIFICATION_ACK_CHANNEL ))
{
HW_IPCC_THREAD_CliNotEvtHandler();
}
return;
' W6 V5 d3 A- `}
　　根据硬件寄存器标志位，选择了调用 HW_IPCC_BLE_EvtHandler 函数
static void HW_IPCC_BLE_EvtHandler( void )
{
HW_IPCC_BLE_RxEvtNot();
' @3 z% b4 o4 B0 _LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_BLE_EVENT_CHANNEL );
return;
}
9 O6 ~' m. {8 [! E) d　　在清除 IPCC 寄存器相关标志位之前，调用 tl_mbox.c 中的 HW_IPCC_BLE_RxEvtNot 函数
. f. F5 T: X# R* W. |' H" }void HW_IPCC_BLE_RxEvtNot(void)
" x+ ~) S( [; |. a) O{
  }: i: ]7 K& j) ^+ Y3 tTL_EvtPacket_t *phcievt;

while(LST_is_empty(&EvtQueue) == FALSE)
( \' {& D+ Q1 K9 E$ f4 t{
LST_remove_head (&EvtQueue, (tListNode )&phcievt);
. |  N1 c4 j$ `* O- P9 H3 KBLE_IoBusEvtCallBackFunction(phcievt);
}
return;
}
　　上面这个函数要处理一个列表，对每个 HCI 事件，调用回调函数 BLE_IoBusEvtCallBackFunction, 但这是一个函数指针
' \6 Z/ `, ]0 Ostatic void ( BLE_IoBusEvtCallBackFunction) (TL_EvtPacket_t *phcievt);
0 P( h) k7 l0 R( m还需要找到它指向的函数。不难找到，在 TL_BLE_Init() 函数里面有这一行：
BLE_IoBusEvtCallBackFunction = pInitHciConf->IoBusEvtCallBack;
/ _7 ]+ {% _* N也就是 TL_BLE_Init() 传入参数——一个 TL_BLE_InitConf_t 类型的指针所指定的函数。TL_BLE_Init() 又是被间接调用的，在 TlInit() 函数中有如下代码：
Conf.IoBusEvtCallBack = TlEvtReceived;
hciContext.io.Init(&Conf);
　　所以，BLE_IoBusEvtCallBackFunction 实际上是 TlEvtReceived 的入口地址
static void TlEvtReceived(TL_EvtPacket_t *hcievt)
( V- E# s0 Z7 p% w' \6 G{
if ( ((hcievt->evtserial.evt.evtcode) == TL_BLEEVT_CS_OPCODE) || ((hcievt->evtserial.evt.evtcode) == TL_BLEEVT_CC_OPCODE ) )
# m' n) ]3 G- E9 Y; K2 @{
LST_insert_tail(&HciCmdEventQueue, (tListNode *)hcievt);
hci_cmd_resp_release(0); /< Notify the application a full Cmd Event has been received */
) q. |8 \) z% v- o}
( q/ n: H5 p- q+ m/ F$ r9 a- xelse
; g& n! H% g9 w7 m{
$ a# F7 h: M8 D2 zLST_insert_tail(&HciAsynchEventQueue, (tListNode )hcievt);
/ o! \7 Y: j' d8 g, W: P3 Qhci_notify_asynch_evt((void) &HciAsynchEventQueue); /*< Notify the application a full HCI event has been received /
}
return;
8 r- V* X( f/ ?. Z: w. X}
　　它里面的两个函数与调度器有关：
void hci_notify_asynch_evt(void pdata)
{
; |- H* }# _4 ?; ?0 K4 r' q% K' CSCH_SetTask(1 << CFG_TASK_HCI_ASYNCH_EVT_ID, CFG_SCH_PRIO_0);
8 _6 k$ c9 m  W  W! Q# j1 Kreturn;
3 G. S" ~6 _2 y7 x$ A. a8 h, {+ u}

void hci_cmd_resp_release(uint32_t flag)
! p7 @. O" l  h! J5 s{
SCH_SetEvt(1 << CFG_IDLEEVT_SYSTEM_HCI_CMD_EVT_RSP_ID);
+ s+ p! k; u" \return;
$ p4 n9 r6 z% r" C- R" U}
　　所以，这个中断也触发了事件，后面的处理工作还是由调度器管理的。

分析到这里，对 demo 程序的软件结构大概有了个了解。这是事件驱动的写法，可是嵌套的调用太多，分析起来不直观。不知道作为这上面软件的开发者感觉又如何。