[蓝牙] 5、Battery Service module

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

Detailed Description

This module implements the Battery Service with the Battery Level characteristic. During initialization it adds the Battery Service and Battery Level characteristic to the BLE stack database. Optionally随意地 it can also add a Report Reference descriptor to the Battery Level characteristic (used when including the Battery Service in the HID service).

If specified, the module will support notification of the Battery Level characteristic through the ble_bas_battery_level_update() function. If an event handler is supplied by the application, the Battery Service will generate Battery Service events to the application.

Note

The application must propagate BLE stack events to the Battery Service module by calling ble_bas_on_ble_evt() from the from the ble_stack_handler callback.

Attention! To maintain compliance with Nordic Semiconductor ASA Bluetooth profile qualification listings, this section of source code must not be modified.

注：

这个电量服务和心率有点类似，通过定时器产生一个周期性的timeout回调函数battery_level_meas_timeout_handler，在其中调用battery_start()实现making the ADC start a battery level conversion。

概述：

In addition, the use of the ADC to measure the battery level is also demonstrated论证.

When the application starts, two timers are started which control when the heart rate value and battery level should be sent

Battery level measurement:

When the peer has enabled notification for Battery Level, the application begins sending the battery level as notifications.

Note that the measurement is made every 2 seconds. But as per the Battery Service Specification, the notification of battery level will be sent only if the it has changed.

The ADC is used to measure the battery level. Every time a new battery measurement has to be sent, a fresh measurement is made.

Note

The application will stop advertising after 180 seconds and go to system-off mode. Push the button 0 or button 1 to restart advertising.

timers_init产生电量测量定时器

// Create timers
err_code = app_timer_create(&m_battery_timer_id,
APP_TIMER_MODE_REPEATED,
battery_level_meas_timeout_handler);
APP_ERROR_CHECK(err_code);

上面代码生成电量超时检测定时器，每隔一定时期触发battery_level_meas_timeout_handler：

/**@brief Function for handling the Battery measurement timer timeout.
*
* @details This function will be called each time the battery level measurement timer expires.
* This function will start the ADC.
*
* @param[in] p_context Pointer used for passing some arbitrary information (context) from the
* app_start_timer() call to the timeout handler.
*/
static void battery_level_meas_timeout_handler(void * p_context)
{
UNUSED_PARAMETER(p_context);
battery_start();
}

其中第11行是一个类似于uc-os里面的东西~宏定义如下：

#define UNUSED_VARIABLE(X) ((void)(X))

#define UNUSED_PARAMETER(X) UNUSED_VARIABLE(X)

battery_start()电量测量的AD配置及使能ADC_IRQn外部中断

/**@brief Function for making the ADC start a battery level conversion.
*/
void battery_start(void)
{
uint32_t err_code; // Configure ADC
NRF_ADC->INTENSET = ADC_INTENSET_END_Msk;
NRF_ADC->CONFIG = (ADC_CONFIG_RES_8bit << ADC_CONFIG_RES_Pos) |//后一个是位置，前一个是设置，在下面讲解中在一起的
(ADC_CONFIG_INPSEL_SupplyOneThirdPrescaling << ADC_CONFIG_INPSEL_Pos) |
(ADC_CONFIG_REFSEL_VBG << ADC_CONFIG_REFSEL_Pos) |
(ADC_CONFIG_PSEL_Disabled << ADC_CONFIG_PSEL_Pos) |
(ADC_CONFIG_EXTREFSEL_None << ADC_CONFIG_EXTREFSEL_Pos);
NRF_ADC->EVENTS_END = ;
NRF_ADC->ENABLE = ADC_ENABLE_ENABLE_Enabled; // Enable ADC interrupt
err_code = sd_nvic_ClearPendingIRQ(ADC_IRQn);
APP_ERROR_CHECK(err_code); err_code = sd_nvic_SetPriority(ADC_IRQn, NRF_APP_PRIORITY_LOW);
APP_ERROR_CHECK(err_code); err_code = sd_nvic_EnableIRQ(ADC_IRQn);
APP_ERROR_CHECK(err_code); NRF_ADC->EVENTS_END = ; // Stop any running conversions.
NRF_ADC->TASKS_START = ;
}

NRF_ADC的结构体为：

typedef struct { /*!< ADC Structure */
__O uint32_t TASKS_START; /*!< Start an ADC conversion. */
__O uint32_t TASKS_STOP; /*!< Stop ADC. */
__I uint32_t RESERVED0[];
__IO uint32_t EVENTS_END; /*!< ADC conversion complete. */
__I uint32_t RESERVED1[];
__IO uint32_t INTENSET; /*!< Interrupt enable set register. */
__IO uint32_t INTENCLR; /*!< Interrupt enable clear register. */
__I uint32_t RESERVED2[];
__I uint32_t BUSY; /*!< ADC busy register. */
__I uint32_t RESERVED3[];
__IO uint32_t ENABLE; /*!< ADC enable. */
__IO uint32_t CONFIG; /*!< ADC configuration register. */
__I uint32_t RESULT; /*!< Result of ADC conversion. */
__I uint32_t RESERVED4[];
__IO uint32_t POWER; /*!< Peripheral power control. */
} NRF_ADC_Type;

黄色部分AD中断使能的意义：

/* Register: ADC_INTENSET */
/* Description: Interrupt enable set register. */ /* Bit 0 : Enable interrupt on END event. */
#define ADC_INTENSET_END_Pos (0UL) /*!< Position of END field. */
#define ADC_INTENSET_END_Msk (0x1UL << ADC_INTENSET_END_Pos) /*!< Bit mask of END field. */
#define ADC_INTENSET_END_Disabled (0UL) /*!< Interrupt disabled. */
#define ADC_INTENSET_END_Enabled (1UL) /*!< Interrupt enabled. */
#define ADC_INTENSET_END_Set (1UL) /*!< Enable interrupt on write. */

绿色部分AD初始化的意义：

/* Register: ADC_CONFIG */
/* Description: ADC configuration register. */ /* Bits 17..16 : ADC external reference pin selection. */
#define ADC_CONFIG_EXTREFSEL_Pos (16UL) /*!< Position of EXTREFSEL field. */
#define ADC_CONFIG_EXTREFSEL_Msk (0x3UL << ADC_CONFIG_EXTREFSEL_Pos) /*!< Bit mask of EXTREFSEL field. */
#define ADC_CONFIG_EXTREFSEL_None (0UL) /*!< Analog external reference inputs disabled. */
#define ADC_CONFIG_EXTREFSEL_AnalogReference0 (1UL) /*!< Use analog reference 0 as reference. */
#define ADC_CONFIG_EXTREFSEL_AnalogReference1 (2UL) /*!< Use analog reference 1 as reference. */ /* Bits 15..8 : ADC analog pin selection. */
#define ADC_CONFIG_PSEL_Pos (8UL) /*!< Position of PSEL field. */
#define ADC_CONFIG_PSEL_Msk (0xFFUL << ADC_CONFIG_PSEL_Pos) /*!< Bit mask of PSEL field. */
#define ADC_CONFIG_PSEL_Disabled (0UL) /*!< Analog input pins disabled. */
#define ADC_CONFIG_PSEL_AnalogInput0 (1UL) /*!< Use analog input 0 as analog input. */
#define ADC_CONFIG_PSEL_AnalogInput1 (2UL) /*!< Use analog input 1 as analog input. */
#define ADC_CONFIG_PSEL_AnalogInput2 (4UL) /*!< Use analog input 2 as analog input. */
#define ADC_CONFIG_PSEL_AnalogInput3 (8UL) /*!< Use analog input 3 as analog input. */
#define ADC_CONFIG_PSEL_AnalogInput4 (16UL) /*!< Use analog input 4 as analog input. */
#define ADC_CONFIG_PSEL_AnalogInput5 (32UL) /*!< Use analog input 5 as analog input. */
#define ADC_CONFIG_PSEL_AnalogInput6 (64UL) /*!< Use analog input 6 as analog input. */
#define ADC_CONFIG_PSEL_AnalogInput7 (128UL) /*!< Use analog input 7 as analog input. */ /* Bits 6..5 : ADC reference参照 selection. */
#define ADC_CONFIG_REFSEL_Pos (5UL) /*!< Position of REFSEL field. */
#define ADC_CONFIG_REFSEL_Msk (0x3UL << ADC_CONFIG_REFSEL_Pos) /*!< Bit mask of REFSEL field. */
#define ADC_CONFIG_REFSEL_VBG (0x00UL) /*!< Use internal 1.2V bandgap频带间隙 voltage as reference for conversion. */
#define ADC_CONFIG_REFSEL_External (0x01UL) /*!< Use external source configured by EXTREFSEL as reference for conversion. */
#define ADC_CONFIG_REFSEL_SupplyOneHalfPrescaling (0x02UL) /*!< Use supply voltage with 1/2 prescaling as reference for conversion. Only usable when supply voltage is between 1.7V and 2.6V. */
#define ADC_CONFIG_REFSEL_SupplyOneThirdPrescaling (0x03UL) /*!< Use supply voltage with 1/3 prescaling as reference for conversion. Only usable when supply voltage is between 2.5V and 3.6V. */ /* Bits 4..2 : ADC input selection. */
#define ADC_CONFIG_INPSEL_Pos (2UL) /*!< Position of INPSEL field. */
#define ADC_CONFIG_INPSEL_Msk (0x7UL << ADC_CONFIG_INPSEL_Pos) /*!< Bit mask of INPSEL field. */
#define ADC_CONFIG_INPSEL_AnalogInputNoPrescaling (0x00UL) /*!< Analog input specified by PSEL with no prescaling used as input for the conversion. */
#define ADC_CONFIG_INPSEL_AnalogInputTwoThirdsPrescaling (0x01UL) /*!< Analog input specified by PSEL with 2/3 prescaling used as input for the conversion. */
#define ADC_CONFIG_INPSEL_AnalogInputOneThirdPrescaling (0x02UL) /*!< Analog input specified by PSEL with 1/3 prescaling used as input for the conversion. */
#define ADC_CONFIG_INPSEL_SupplyTwoThirdsPrescaling (0x05UL) /*!< Supply voltage with 2/3 prescaling used as input for the conversion. */
#define ADC_CONFIG_INPSEL_SupplyOneThirdPrescaling (0x06UL) /*!< Supply voltage with 1/3 prescaling 预分频 used as input for the conversion. */ /* Bits 1..0 : ADC resolution. */
#define ADC_CONFIG_RES_Pos (0UL) /*!< Position of RES field. */
#define ADC_CONFIG_RES_Msk (0x3UL << ADC_CONFIG_RES_Pos) /*!< Bit mask of RES field. */
#define ADC_CONFIG_RES_8bit (0x00UL) /*!< 8bit ADC resolution分辨率. */
#define ADC_CONFIG_RES_9bit (0x01UL) /*!< 9bit ADC resolution. */
#define ADC_CONFIG_RES_10bit (0x02UL) /*!< 10bit ADC resolution. */

综上：AD的配置为——

44>8bit分辨率+39>1/3预分频用于转换输入电源电压+27>用内联1.2V频带间隙电压作为参照电压+14>总共有8个模拟输入通道，测量电量不用选择任何一个+7>ADC额外输入参考失能

18 err_code = sd_nvic_ClearPendingIRQ(ADC_IRQn);
19 APP_ERROR_CHECK(err_code);

X清除正在进行的中断

21 err_code = sd_nvic_SetPriority(ADC_IRQn, NRF_APP_PRIORITY_LOW);
22 APP_ERROR_CHECK(err_code);

X设置中断优先级

24 err_code = sd_nvic_EnableIRQ(ADC_IRQn);
25 APP_ERROR_CHECK(err_code);

X使能外部中断ADC

那么，综上定时器触发timeout周期性执行battery_start()。在该函数中对AD进行配置然后使能~

接下来深入分析这个AD中断时怎么执行的！

AD中断执行，深入m0内核

顺着ADC_IRQn并不是一个中断回调函数，而是：

typedef enum {
/* ------------------- Cortex-M0 Processor Exceptions Numbers ------------------- */
Reset_IRQn = -, /*!< 1 Reset Vector, invoked on Power up and warm reset */
NonMaskableInt_IRQn = -, /*!< 2 Non maskable Interrupt, cannot be stopped or preempted */
HardFault_IRQn = -, /*!< 3 Hard Fault, all classes of Fault */
SVCall_IRQn = -, /*!< 11 System Service Call via SVC instruction */
DebugMonitor_IRQn = -, /*!< 12 Debug Monitor */
PendSV_IRQn = -, /*!< 14 Pendable request for system service */
SysTick_IRQn = -, /*!< 15 System Tick Timer */
/* ---------------------- nRF51 Specific Interrupt Numbers ---------------------- */
POWER_CLOCK_IRQn = , /*!< 0 POWER_CLOCK */
RADIO_IRQn = , /*!< 1 RADIO */
UART0_IRQn = , /*!< 2 UART0 */
SPI0_TWI0_IRQn = , /*!< 3 SPI0_TWI0 */
SPI1_TWI1_IRQn = , /*!< 4 SPI1_TWI1 */
GPIOTE_IRQn = , /*!< 6 GPIOTE */
ADC_IRQn = , /*!< 7 ADC */
TIMER0_IRQn = , /*!< 8 TIMER0 */
TIMER1_IRQn = , /*!< 9 TIMER1 */
TIMER2_IRQn = , /*!< 10 TIMER2 */
RTC0_IRQn = , /*!< 11 RTC0 */
TEMP_IRQn = , /*!< 12 TEMP */
RNG_IRQn = , /*!< 13 RNG */
ECB_IRQn = , /*!< 14 ECB */
CCM_AAR_IRQn = , /*!< 15 CCM_AAR */
WDT_IRQn = , /*!< 16 WDT */
RTC1_IRQn = , /*!< 17 RTC1 */
QDEC_IRQn = , /*!< 18 QDEC */
LPCOMP_COMP_IRQn = , /*!< 19 LPCOMP_COMP */
SWI0_IRQn = , /*!< 20 SWI0 */
SWI1_IRQn = , /*!< 21 SWI1 */
SWI2_IRQn = , /*!< 22 SWI2 */
SWI3_IRQn = , /*!< 23 SWI3 */
SWI4_IRQn = , /*!< 24 SWI4 */
SWI5_IRQn = /*!< 25 SWI5 */
} IRQn_Type;

哪里会用IRQn_Type呢？

是内核的中断向量部分——

/* ########################## NVIC functions #################################### */
/** \ingroup CMSIS_Core_FunctionInterface
\defgroup CMSIS_Core_NVICFunctions NVIC Functions
\brief Functions that manage interrupts and exceptions via the NVIC.
@{
*/ /* Interrupt Priorities are WORD accessible only under ARMv6M */
/* The following MACROS handle generation of the register offset and byte masks */
#define _BIT_SHIFT(IRQn) ( (((uint32_t)(IRQn) ) & 0x03) * 8 )
#define _SHP_IDX(IRQn) ( ((((uint32_t)(IRQn) & 0x0F)-8) >> 2) )
#define _IP_IDX(IRQn) ( ((uint32_t)(IRQn) >> 2) ) /** \brief Enable External Interrupt The function enables a device-specific特殊 interrupt in the NVIC interrupt controller中断向量控制器. \param [in] IRQn External interrupt number. Value cannot be negative.
*/
__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)//被动函数
{
NVIC->ISER[] = ( << ((uint32_t)(IRQn) & 0x1F));
} /** \brief Disable External Interrupt The function disables a device-specific interrupt in the NVIC interrupt controller. \param [in] IRQn External interrupt number. Value cannot be negative.
*/
__STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)//被动函数
{
NVIC->ICER[] = ( << ((uint32_t)(IRQn) & 0x1F));
} /** \brief Get Pending Interrupt The function reads the pending register in the NVIC and returns the pending bit
for the specified interrupt. \param [in] IRQn Interrupt number. \return 0 Interrupt status is not pending.
\return 1 Interrupt status is pending.
*/
__STATIC_INLINE uint32_t NVIC_GetPendingIRQ(IRQn_Type IRQn)//判断中断是否正在进行
{
return((uint32_t) ((NVIC->ISPR[] & ( << ((uint32_t)(IRQn) & 0x1F)))?:));
} /** \brief Set Pending Interrupt The function sets the pending bit of an external interrupt. \param [in] IRQn Interrupt number. Value cannot be negative.
*/
__STATIC_INLINE void NVIC_SetPendingIRQ(IRQn_Type IRQn)//设置正在进行中断为IRQn
{
NVIC->ISPR[] = ( << ((uint32_t)(IRQn) & 0x1F));
} /** \brief Clear Pending Interrupt The function clears the pending bit of an external interrupt. \param [in] IRQn External interrupt number. Value cannot be negative.
*/
__STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn)//清除正在进行中断
{
NVIC->ICPR[] = ( << ((uint32_t)(IRQn) & 0x1F)); /* Clear pending interrupt */
} /** \brief Set Interrupt Priority The function sets the priority of an interrupt. \note The priority cannot be set for every core interrupt. \param [in] IRQn Interrupt number.
\param [in] priority Priority to set.
*/
__STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)//设置中断优先级
{
if(IRQn < ) {
SCB->SHP[_SHP_IDX(IRQn)] = (SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFF << _BIT_SHIFT(IRQn))) |
(((priority << ( - __NVIC_PRIO_BITS)) & 0xFF) << _BIT_SHIFT(IRQn)); }
else {
NVIC->IP[_IP_IDX(IRQn)] = (NVIC->IP[_IP_IDX(IRQn)] & ~(0xFF << _BIT_SHIFT(IRQn))) |
(((priority << ( - __NVIC_PRIO_BITS)) & 0xFF) << _BIT_SHIFT(IRQn)); }
} /** \brief Get Interrupt Priority The function reads the priority of an interrupt. The interrupt
102 number can be positive to specify an external (device specific)
103 interrupt, or negative to specify an internal (core) interrupt.
\param [in] IRQn Interrupt number.
\return Interrupt Priority. Value is aligned automatically to the implemented
priority bits of the microcontroller.
*/
__STATIC_INLINE uint32_t NVIC_GetPriority(IRQn_Type IRQn)//读取一个中断的优先级，如果为正表示是外部中断，为负表示为内部中断
{ if(IRQn < ) {
return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & 0xFF) >> ( - __NVIC_PRIO_BITS))); } /* get priority for Cortex-M0 system interrupts */
else {
return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & 0xFF) >> ( - __NVIC_PRIO_BITS))); } /* get priority for device specific interrupts */
} /** \brief System Reset The function initiates发起 a system reset request to reset the MCU.
*/
__STATIC_INLINE void NVIC_SystemReset(void)
{
__DSB(); /* Ensure all outstanding memory accesses included
buffered write are completed before reset */
SCB->AIRCR = ((0x5FA << SCB_AIRCR_VECTKEY_Pos) |
SCB_AIRCR_SYSRESETREQ_Msk);
__DSB(); /* Ensure completion of memory access */
while(); /* wait until reset */
} /*@} end of CMSIS_Core_NVICFunctions */

绕了一圈最后反推找到ADC中断回调函数在start上面！（瞎了~）

/**@brief Function for handling the ADC interrupt.
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
void ADC_IRQHandler(void)
{
if (NRF_ADC->EVENTS_END != )
{
uint8_t adc_result;
uint16_t batt_lvl_in_milli_volts;
uint8_t percentage_batt_lvl;
uint32_t err_code; NRF_ADC->EVENTS_END = ;
adc_result = NRF_ADC->RESULT;
NRF_ADC->TASKS_STOP = ; batt_lvl_in_milli_volts = ADC_RESULT_IN_MILLI_VOLTS(adc_result) +
DIODE_FWD_VOLT_DROP_MILLIVOLTS;
percentage_batt_lvl = battery_level_in_percent(batt_lvl_in_milli_volts); err_code = ble_bas_battery_level_update(&bas, percentage_batt_lvl);
if (
(err_code != NRF_SUCCESS)
&&
(err_code != NRF_ERROR_INVALID_STATE)
&&
(err_code != BLE_ERROR_NO_TX_BUFFERS)
&&
(err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
)
{
APP_ERROR_HANDLER(err_code);
}
}
}

上面函数先从AD中获得读取值，然后调用updata函数。

其中重点也就是这个ble_bas_battery_level_update函数~

该函数是最上面简介中谈到的一个——

If specified, the module will support notification of the Battery Level characteristic through the ble_bas_battery_level_update() function. If an event handler is supplied by the application, the Battery Service will generate Battery Service events to the application.

该函数首先判断老的电量值和新的是否一样，不一样则更新老的

uint32_t ble_bas_battery_level_update(ble_bas_t * p_bas, uint8_t battery_level)
{
uint32_t err_code = NRF_SUCCESS; if (battery_level != p_bas->battery_level_last)
{
uint16_t len = sizeof(uint8_t); // Save new battery value
p_bas->battery_level_last = battery_level; // Update database
err_code = sd_ble_gatts_value_set(p_bas->battery_level_handles.value_handle,
,
&len,
&battery_level);
if (err_code != NRF_SUCCESS)
{
return err_code;
} // Send value if connected and notifying
if ((p_bas->conn_handle != BLE_CONN_HANDLE_INVALID) && p_bas->is_notification_supported)
{
ble_gatts_hvx_params_t hvx_params; memset(&hvx_params, , sizeof(hvx_params));
len = sizeof(uint8_t); hvx_params.handle = p_bas->battery_level_handles.value_handle;
hvx_params.type = BLE_GATT_HVX_NOTIFICATION;
hvx_params.offset = ;
hvx_params.p_len = &len;
hvx_params.p_data = &battery_level; err_code = sd_ble_gatts_hvx(p_bas->conn_handle, &hvx_params);
}
else
{
err_code = NRF_ERROR_INVALID_STATE;
}
} return err_code;
}

然后调用gatts_value_set更新database

其中——

12 // Update database
13 err_code = sd_ble_gatts_value_set(p_bas->battery_level_handles.value_handle,
14 0,
15 &len,
16 &battery_level);

36 err_code = sd_ble_gatts_hvx(p_bas->conn_handle, &hvx_params);

该函数在上一篇中的timer部分的最后已经详细讲过——

This function checks for the relevant相关的 Client Characteristic Configuration descriptor描述符 value to verify判定 that the relevant operation (notification or indication) has been enabled by the client.

It is also able to update the attribute 属性 value before issuing发出 the PDU(protocol data unit:https://en.wikipedia.org/wiki/Protocol_data_unit && BLE 包结构及传输速率), so that the application can atomically原子级地 perform a value update and a server initiated开始 transaction事务 with a single API call. （仅仅调用一个API就能够将attribute的value有效地发出）If the application chooses to indicate an attribute value, a BLE_GATTS_EVT_HVC will be sent up as soon as the confirmation arrives from the peer.

这样，终于搞通了AD的测量电量和利用BLE发送的全过程！

具体为——

1、首先在timer初始化中产生一个电量测量timer,

2、在timeout的回调函数battery_level_meas_timeout_handler中对AD进行配置并启动AD转换中断

3、在AD中断回调函数ADC_IRQHandler中获取转换的AD值，

4、并调用ble_bas_battery_level_update与老的电量值对比更新database，

5、最后调用sd_ble_gatts_hvx系统API在原子级操作将attribute的value有效地发出。

此外~再来补一下少说的services_init部分

services_init

// Initialize Battery Service
memset(&bas_init, , sizeof(bas_init)); // Here the sec level for the Battery Service can be changed/increased.
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&bas_init.battery_level_char_attr_md.cccd_write_perm);
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&bas_init.battery_level_char_attr_md.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&bas_init.battery_level_char_attr_md.write_perm); BLE_GAP_CONN_SEC_MODE_SET_OPEN(&bas_init.battery_level_report_read_perm); bas_init.evt_handler = NULL;
bas_init.support_notification = true;
bas_init.p_report_ref = NULL;
bas_init.initial_batt_level = ; err_code = ble_bas_init(&bas, &bas_init);
APP_ERROR_CHECK(err_code);

同上一篇一样——

最后一个黄线部分阐明了事件如何关联——

The application must propagate BLE stack events to the Battery Service module by calling ble_bas_on_ble_evt() from the from the ble_stack_handler callback.

应用需要把BLE stack events传送给BAS，黄线部分说可以通过在ble_stack_handler的回调函数中调用ble_bas_on_ble_evt来实现~

下面就是初始化并设置ble_stack_handler的回调函数的：ble_evt_dispatch

/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
uint32_t err_code; // Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, false); // Register with the SoftDevice handler module for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code); // Register with the SoftDevice handler module for BLE events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
}

下面这个函数负责将BLE stack事件分派给所有模块

该函数是由ble_stack_handler的回调函数调用的，发生在：This function is called from the BLE Stack event interrupt handler after a BLE sta

/**@brief Function for dispatching a BLE stack event to all modules with a BLE stack event handler.
*
* @details This function is called from the BLE Stack event interrupt handler after a BLE stack
* event has been received.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void ble_evt_dispatch(ble_evt_t * p_ble_evt)
{
ble_bondmngr_on_ble_evt(p_ble_evt);
ble_hrs_on_ble_evt(&m_hrs, p_ble_evt);
ble_bas_on_ble_evt(&bas, p_ble_evt);
ble_conn_params_on_ble_evt(p_ble_evt);
on_ble_evt(p_ble_evt);
}

也就是说当应用初始了ble_stack_init之后，一旦有ble协议栈的事件就会通过ble_evt_dispatch分派给每个模块

对于电量检测的ble_bas_on_ble_evt模块有（其他也类似）——

其中on_write(p_bas, p_ble_evt)是手机等客户端向BAS服务写数据时触发的操作~这里先不讲！

/**@brief Function for handling the Application's BLE Stack events.
*
* @details Handles all events from the BLE stack of interest to the Battery Service.
*
* @note For the requirements in the BAS specification to be fulfilled,
* ble_bas_battery_level_update() must be called upon reconnection if the
* battery level has changed while the service has been disconnected from a bonded
* client.
*
* @param[in] p_bas Battery Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
void ble_bas_on_ble_evt(ble_bas_t * p_bas, ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_bas, p_ble_evt);
break; case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_bas, p_ble_evt);
break; case BLE_GATTS_EVT_WRITE:
on_write(p_bas, p_ble_evt);
break; default:
// No implementation needed.
break;
}
}

/**@brief Function for handling the Connect event.
*
* @param[in] p_bas Battery Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_connect(ble_bas_t * p_bas, ble_evt_t * p_ble_evt)
{
p_bas->conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
} /**@brief Function for handling the Disconnect event.
*
* @param[in] p_bas Battery Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_disconnect(ble_bas_t * p_bas, ble_evt_t * p_ble_evt)
{
UNUSED_PARAMETER(p_ble_evt);
p_bas->conn_handle = BLE_CONN_HANDLE_INVALID;
} /**@brief Function for handling the Write event.
*
* @param[in] p_bas Battery Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_write(ble_bas_t * p_bas, ble_evt_t * p_ble_evt)
{
if (p_bas->is_notification_supported)
{
ble_gatts_evt_write_t * p_evt_write = &p_ble_evt->evt.gatts_evt.params.write; if (
(p_evt_write->handle == p_bas->battery_level_handles.cccd_handle)
&&
(p_evt_write->len == )
)
{
// CCCD written, call application event handler
if (p_bas->evt_handler != NULL)
{
ble_bas_evt_t evt; if (ble_srv_is_notification_enabled(p_evt_write->data))
{
evt.evt_type = BLE_BAS_EVT_NOTIFICATION_ENABLED;
}
else
{
evt.evt_type = BLE_BAS_EVT_NOTIFICATION_DISABLED;
} p_bas->evt_handler(p_bas, &evt);
}
}
}
}