LE Scatternet

The ble_scatternet sample demonstrates how to develop an application which supports the Peripheral Role and the Central Role at the same time.

Scatternet topology features:

Peripherals are permitted to establish physical links to more than one Central at a time.
A device is permitted to be Central and Peripheral at the same time.
Does not support role switch.

Requirements

The sample supports the following development kits:

Development Kits
Hardware Platforms	Board Name
RTL87x2G HDK	RTL87x2G EVB

To quickly set up the development environment, please refer to the detailed instructions provided in Quick Start.

Wiring

Please refer to RTL87x2G EVB Interfaces and Modules in Quick Start.

The sample requires support for a user command interface. For specific wiring instructions, please refer to Data UART Connection in User Command Interface.

Configurations

Configurable Items

All contents that can be configured for the sample are in samples\bluetooth\ble_scatternet\src\app_flags.h, developers can configure according to actual needs.

/** @brief  Config APP LE link number */
#define APP_MAX_LINKS  2
/** @brief  Config airplane mode support: 0-Not built in, 1-built in, use user command to set*/
#define F_BT_AIRPLANE_MODE_SUPPORT          0
/** @brief  Config device name characteristic and appearance characteristic property: 0-Not writeable, 1-writeable, save to flash*/
#define F_BT_GAPS_CHAR_WRITEABLE            0
/** @brief  Config set physical: 0-Not built in, 1-built in, use user command to set*/
#define F_BT_LE_5_0_SET_PHY_SUPPORT         0
/** @brief  Config local address type: 0-public address, 1-static random address */
#define F_BT_LE_USE_STATIC_RANDOM_ADDR      0

Set airplane mode:

To open airplane mode, F_BT_AIRPLANE_MODE_SUPPORT should be configured. After turning on airplane mode, the Bluetooth function will be disabled. For more information, please refer to Airplane Mode Setting of Code Overview.
GAP service characteristic writeable:

Need to configure F_BT_GAPS_CHAR_WRITEABLE to open. More information can be found in the chapter GAP Service Characteristic Writeable of LE Host.
Use static random address:

Need to configure F_BT_LE_USE_STATIC_RANDOM_ADDR to open. More information can be found in the chapter Local Static Random Address of LE Host.
PHY setting:

Need to configure F_BT_LE_5_0_SET_PHY_SUPPORT to open. More information can be found in the chapter Physical (PHY) Setting of LE Host.

Generating System Config File

Developers shall configure the following items through MP Tool:

MP Tool Configuration
Configurable Item	Value
LE Master Link Num	≥1
LE Slave Link Num	≥1

Note

The sum of the LE Master Link Num value and LE Slave Link Num value configured by the developers should be greater than or equal to the APP_MAX_LINKS value configured in app_flags.h.

For more information about MP Tool Configuration, please refer to Generating System Config File in Quick Start.

Building and Downloading

This sample can be found in the SDK folder:

Keil

Project file: samples\bluetooth\ble_scatternet\proj\rtl87x2g\mdk

GCC

Project file: samples\bluetooth\ble_scatternet\proj\rtl87x2g\gcc

To build and run the sample, follow the steps listed below:

Open project file.
To build the target, follow the steps listed on the Generating App Image in Quick Start.
After a successful compilation, the APP bin app_MP_sdk_xxx.bin will be generated in the directory samples\bluetooth\ble_scatternet\proj\rtl87x2g\mdk\bin.
To download APP bin into EVB, follow the steps listed on the MP Tool Download in Quick Start.
Press reset button on EVB and it will start running.

Experimental Verification

After downloading the sample bin to the EVB, developers can test it by using 2 kits running the LE Peripheral sample and the LE Central sample respectively.

Testing with Other Kits

Prepare three development boards named DUT, Tester 1 and Tester 2 respectively, and use Debug Analyzer tool to Log Verification .

Preparation Phase

Use MP Tool set DUT address to [00:11:22:33:44:80], and then build the ble_scatternet sample, and download images into DUT. Developers can enter the user command in serial port assistant tool in PC. Please refer to How to Use Commands in User Command Interface.
Use MP Tool set Tester 1 address to [00:11:22:33:44:81], and then build the ble_peripheral sample, and download images into Tester 1. For more information, please refer to Building and Downloading in LE Peripheral.
Use MP Tool set Tester 2 address to [00:11:22:33:44:85], and then build the ble_central sample, and download images into Tester 2. For more information, please refer to Building and Downloading in LE Central.

For details about how to change the Bluetooth Address, please refer to Generating System Config File in Quick Start.

Testing Phase

Due to support of Peripheral Role and Central Role, test procedure is the combination of test procedures in LE Peripheral and LE Central.

Connect with Tester 1

Press the reset button on Tester 1 and Tester 1 will start sending connectable undirected advertising events.

If the advertisement is successfully enabled, the following Debug Analyzer log will be printed. If developers do not see the following log, it means that the advertisement failed to start. Please check if the software and hardware environment is configured correctly.
[APP] !**GAP adv start

Press reset button on DUT. Developers can enter the user command in the serial port assistant tool on the PC.

If the DUT successfully boots up and the serial port assistant tool configuration is successful, developers will see the following log. The serial port assistant tool will display the local address. If developers do not see the following log, please check if the software and hardware environment is configured correctly.
local bd addr: xx:xx:xx:xx:xx:xx
Test flow between DUT and Tester 1 of this part is shown as below:

Step

DUT User Command

Description

DUT Log

1

bondclear

Clear bonding information on DUT-end.

Debug Analyzer shows:

[GAP] !**le_clear_all_keys

2

scan

DUT starts scanning and viewing information on LE device nearby discovered.

Debug Analyzer shows:

[APP] !**GAP scan start

[APP] GAP_MSG_LE_SCAN_INFO: bd_addr 00::11::22::33::44::80, bdtype 0, adv_type 0x0, rssi -17, data_len 23

3

stopscan

Stop scanning.

Debug Analyzer shows:

[APP] !**GAP scan stop

4

showdev

Show scan device list, the device list is filtered by simple LE service UUID.

Serial port assistant tool shows:

Advertising and Scan response: filter uuid = 0xA00A dev list

RemoteBd[0] = [00:11:22:33:44:81] type = 0

5

condev 0

Initiate connection as Central role.

Serial port assistant tool shows:

Connected success conn_id 0

Connect with Tester 2

Press the reset button on Tester 2 and developers can enter the user command in the serial port assistant tool on the PC.

If the Tester 2 successfully boots up and the serial port assistant tool configuration is successful, developers will see the following log. The serial port assistant tool will display the local address. If developers do not see the following log, please check if the software and hardware environment is configured correctly.

local bd addr: xx:xx:xx:xx:xx:xx

The test flow between DUT and Tester 2 of this part is shown as below:

Step	DUT User Command	Tester 2 User Command	Description	Tester 2 Log	DUT Log
6		bond clear	Clear bonding information on Tester 2-end.	Debug Analyzer shows: [GAP] !**le_clear_all_keys
7	startadv		DUT sends connectable and scannable undirected advertising events.		Debug Analyzer shows: [APP] !**GAP adv start
8		scan	Tester 2 starts scanning and viewing information on LE devices nearby discovered.	Debug Analyzer shows: [APP] !**GAP scan start [APP] GAP_MSG_LE_SCAN_INFO: bd_addr 00::11::22::33::44::80, bdtype 0, adv_type 0x0, rssi -17, data_len 23
9		stopscan	Tester 2 stops scanning.	Debug Analyzer shows: [APP] !**GAP scan stop
10		showdev	Show scan device list, the device list is filtered by simple LE service UUID.	Serial port assistant tool shows: Advertising and Scan response: filter uuid = 0xA00A dev list RemoteBd[0] = [00:11:22:33:44:80] type = 0
11		condev 0	Tester 2 initiates the connection establishment with DUT, `0` indicates the index of DUT.	Serial port assistant tool shows: Connected success conn_id 0
12	showcon		Shows the established connections on DUT-end.		Serial port assistant tool shows: ShowCon conn_id 0 state 0x00000002 role 1 RemoteBd = [00:11:22:33:44:81] type = 0 ShowCon conn_id 1 state 0x00000002 role 2 RemoteBd = [00:11:22:33:44:85] type = 0 active link num 2, idle link num 0

Interact with Tester 1 and Tester 2

At this point, DUT has successfully established connections with Tester 1 and Tester 2 as the Central and Peripheral roles respectively. Next, the following test items will be executed:

Step

DUT User Command

Tester 2 User Command

Description

Tester 2 Log

DUT Log

13

sauth 0

DUT send pairing request to Tester 1.

Serial port assistant tool shows:

Pair succes

14

disc 0

Terminate the connection with Tester 1.

Serial port assistant tool shows:

Disconnect conn_id 0

15

disc 1

Terminate the connection with Tester 2.

Serial port assistant tool shows:

Disconnect conn_id 1

16

condev 0

DUT reconnect with Tester 1.

Serial port assistant tool shows:

Connected success conn_id 0

17

startadv

DUT send connectable and scannable undirected advertising events.

Serial port assistant tool shows:

GAP adv start

18

condev 0

Tester 2 reconnect with DUT.

Serial port assistant tool shows:

Connected success conn_id 0

Pair success

19

sauth 0

DUT send pairing request to Tester 1.

Serial port assistant tool shows:

Pair success

20

conupdreq 1 x30 x40 0 1000

DUT send connection parameters update request to Tester 2.

Debug Analyzer shows:

[APP] !**app_handle_conn_param_update_evt update success:conn_id 0, conn_interval 0x3c, conn_slave_latency 0x0, conn_supervision_timeout 0x3e8

Debug Analyzer shows:

[APP] !**app_handle_conn_param_update_evt update success:conn_id 1, conn_interval 0x3c, conn_slave_latency 0x0, conn_supervision_timeout 0x3e8

21

conupdreq 0 x30 x40 0 1000

DUT sends connection parameters update request to Tester 1.

Debug Analyzer shows:

[APP] !**app_handle_conn_param_update_evt update success:conn_id 0, conn_interval 0x3c, conn_slave_latency 0x0, conn_supervision_timeout 0x3e8

22

setphy 1 1

DUT sets the PHY with Tester 2 to 2M.

Debug Analyzer shows:

[BTIFMSG] ↗BTIF_MSG_LE_PHY_UPDATE_INFO (CMD:0x01AB) cause:0x0000 link_id:0x000A tx_phy:0x02(BTIF_LE_PHY_2M) rx_phy:0x02(BTIF_LE_PHY_2M)

Debug Analyzer shows:

[BTIFMSG] ↗BTIF_MSG_LE_PHY_UPDATE_INFO (CMD:0x01AB) cause:0x0000 link_id:0x0012 tx_phy:0x02(BTIF_LE_PHY_2M) rx_phy:0x02(BTIF_LE_PHY_2M)

[APP] !**GAP_MSG_LE_PHY_UPDATE_INFO:conn_id 1, cause 0x0, rx_phy 2, tx_phy 2

23

setphy 0 1

DUT sets the PHY with Tester 1 to 2M.

Debug Analyzer shows:

[BTIFMSG] ↗BTIF_MSG_LE_PHY_UPDATE_INFO (CMD:0x01AB) cause:0x0000 link_id:0x000A tx_phy:0x02(BTIF_LE_PHY_2M) rx_phy:0x02(BTIF_LE_PHY_2M)

[APP] !**GAP_MSG_LE_PHY_UPDATE_INFO:conn_id 0, cause 0x0, rx_phy 2, tx_phy 2

24

simpdis 0

DUT initiates the discovery procedure to get Simple LE Service information.

Debug Analyzer shows:

[APP] !**app_client_callback: discover simp procedure done

25

gapdis 0

DUT initiates the discovery procedure to get GAP Service information.

Debug Analyzer shows:

[APP] !**GAPS_READ_DEVICE_NAME: device name BLE_PERIPHERAL

Code Overview

This chapter will be introduced according to the following several parts:

The directories of the project and source code files will be introduced in chapter Source Code Directory.
The Bluetooth Host will be introduced in chapter Bluetooth Host Overview.
The main function and configurable GAP parameters of this sample will be introduced in chapter Initialization.
The link control block will be introduced in chapter Multilink Manager.
The GAP message handler of this sample will be introduced in chapter GAP Message Handler.
The GAP callback handler of this sample will be introduced in chapter GAP Callback Handler.
The profile client message callback of this sample will be introduced in chapter Profile Client Message Callback.
The profile service message callback of this sample will be introduced in chapter Profile Service Message Callback.
The procedure of setting airplane mode will be introduced in chapter Airplane Mode Setting.

Source Code Directory

Project directory: samples\bluetooth\ble_scatternet\proj.
Source code directory: samples\bluetooth\ble_scatternet\src.

Source files in ble_scatternet sample project are currently categorized into several groups as below.

└── Project: scatternet
    └── secure_only_app
        └── Device                   includes startup code
        ├── CMSE Library             Non-secure callable library
        ├── Lib                      includes all binary symbol files that user application is built on
            ├── ROM_NS.lib
            ├── lowerstack.lib
            └── rtl87x2g_sdk.lib
            └── gap_utils.lib
        ├── peripheral               includes all peripheral drivers and module code used by the application
        ├── Profile                  includes LE profiles or services used by the sample application
        └── APP                      includes the ble_scatternet user application implementation
            ├── app_task.c
            ├── main.c
            ├── link_mgr.c
            ├── scatternet_app.c
            ├── user_cmd.c
            ├── user_cmd_parse.c
            └── data_uart.c

The sample uses default GAP LIB that matches with bt_host_0_0, please refer to Usage of GAP LIB in Host Image for more information.

Bluetooth Host Overview

The sample uses default Bluetooth Host image in bt_host_0_0, please refer to Host Image for more information.

For the details of Bluetooth technology features supported by the Bluetooth Host, please refer to the file bin\rtl87x2g\bt_host_image\bt_host_0_0\bt_host_config.h.

Initialization

main() function is invoked when the EVB is powered on and the chip is reset, and it performs the following initialization functions:

int main(void)
{
    board_init();
    le_gap_init(APP_MAX_LINKS);
    gap_lib_init();
    app_le_gap_init();
    app_le_profile_init();
    pwr_mgr_init();
    task_init();
    os_sched_start();

    return 0;
}

le_gap_init() function is used to initialize GAP and configure the link number.
app_le_profile_init() function is used to initialize the Profile.
app_le_gap_init() function is used to initialize the GAP parameters. Developers can configure the following parameters: Device name and device appearance, Scan parameters, Advertising parameters, GAP Bond Manager parameters (Please refer to the chapter Configure Device Name and Device Appearance, Configure Scan Parameters, Configure Advertising Parameters, Configure Bond Manager Parameters of LE Host).

void app_le_gap_init(void)
{
    /* Device name and device appearance */
    ......

    /* Scan parameters */
    ......

    /* GAP Bond Manager parameters */
    ......

    /* Set device name and device appearance */
    le_set_gap_param(GAP_PARAM_DEVICE_NAME, GAP_DEVICE_NAME_LEN, device_name);
    le_set_gap_param(GAP_PARAM_APPEARANCE, sizeof(appearance), &appearance);

    /* Set scan parameters */
    le_scan_set_param(GAP_PARAM_SCAN_MODE, sizeof(scan_mode), &scan_mode);
    le_scan_set_param(GAP_PARAM_SCAN_INTERVAL, sizeof(scan_interval), &scan_interval);
    le_scan_set_param(GAP_PARAM_SCAN_WINDOW, sizeof(scan_window), &scan_window);
    le_scan_set_param(GAP_PARAM_SCAN_FILTER_POLICY, sizeof(scan_filter_policy),
                    &scan_filter_policy);
    le_scan_set_param(GAP_PARAM_SCAN_FILTER_DUPLICATES, sizeof(scan_filter_duplicate),
                    &scan_filter_duplicate);

    /* Set advertising parameters */
    le_adv_set_param(GAP_PARAM_ADV_EVENT_TYPE, sizeof(adv_evt_type), &adv_evt_type);
    le_adv_set_param(GAP_PARAM_ADV_DIRECT_ADDR_TYPE, sizeof(adv_direct_type), &adv_direct_type);
    le_adv_set_param(GAP_PARAM_ADV_DIRECT_ADDR, sizeof(adv_direct_addr), adv_direct_addr);
    le_adv_set_param(GAP_PARAM_ADV_CHANNEL_MAP, sizeof(adv_chann_map), &adv_chann_map);
    le_adv_set_param(GAP_PARAM_ADV_FILTER_POLICY, sizeof(adv_filter_policy), &adv_filter_policy);
    le_adv_set_param(GAP_PARAM_ADV_INTERVAL_MIN, sizeof(adv_int_min), &adv_int_min);
    le_adv_set_param(GAP_PARAM_ADV_INTERVAL_MAX, sizeof(adv_int_max), &adv_int_max);
    le_adv_set_param(GAP_PARAM_ADV_DATA, sizeof(adv_data), (void *)adv_data);
    le_adv_set_param(GAP_PARAM_SCAN_RSP_DATA, sizeof(scan_rsp_data), (void *)scan_rsp_data);

    /* Setup the GAP Bond Manager */
    gap_set_param(GAP_PARAM_BOND_PAIRING_MODE, sizeof(auth_pair_mode), &auth_pair_mode);
    gap_set_param(GAP_PARAM_BOND_AUTHEN_REQUIREMENTS_FLAGS, sizeof(auth_flags), &auth_flags);
    gap_set_param(GAP_PARAM_BOND_IO_CAPABILITIES, sizeof(auth_io_cap), &auth_io_cap);
    gap_set_param(GAP_PARAM_BOND_OOB_ENABLED, sizeof(auth_oob), &auth_oob);
    le_bond_set_param(GAP_PARAM_BOND_FIXED_PASSKEY, sizeof(auth_fix_passkey), &auth_fix_passkey);
    le_bond_set_param(GAP_PARAM_BOND_FIXED_PASSKEY_ENABLE, sizeof(auth_use_fix_passkey),
                    &auth_use_fix_passkey);
    le_bond_set_param(GAP_PARAM_BOND_SEC_REQ_REQUIREMENT, sizeof(auth_sec_req_flags),
                    &auth_sec_req_flags);

    /* register gap message callback */
    le_register_app_cb(app_gap_callback);
    ......
}

More information on LE GAP initialization and startup flow can be found in the chapter GAP Parameters Initialization of LE Host.

Multilink Manager

The sample link control block is defined in link_mgr.h.

typedef struct
{
   T_GAP_CONN_STATE        conn_state;          /**< Connection state. */
   T_GAP_REMOTE_ADDR_TYPE  bd_type;             /**< remote BD type */
   uint8_t                 bd_addr[GAP_BD_ADDR_LEN]; /**< remote BD */
} T_APP_LINK;
extern T_APP_LINK app_link_table[APP_MAX_LINKS];

app_link_table is used to save the connection link related information.

GAP Message Handler

app_handle_gap_msg() function is invoked whenever a GAP message is received from the Bluetooth Host. When receiving GAP_MSG_LE_CONN_STATE_CHANGE message, function app_handle_conn_state_evt() will update data in app_link_table.

void app_handle_conn_state_evt(uint8_t conn_id, T_GAP_CONN_STATE new_state, uint16_t disc_cause)
{
   if (conn_id >= APP_MAX_LINKS)
   {
      return;
   }
   APP_PRINT_INFO4("app_handle_conn_state_evt: conn_id %d, conn_state(%d -> %d), disc_cause 0x%x",
                  conn_id, app_link_table[conn_id].conn_state, new_state, disc_cause);
   app_link_table[conn_id].conn_state = new_state;
   switch (new_state)
   {
   case GAP_CONN_STATE_DISCONNECTED:
      {
            if ((disc_cause != (HCI_ERR | HCI_ERR_REMOTE_USER_TERMINATE))
               && (disc_cause != (HCI_ERR | HCI_ERR_LOCAL_HOST_TERMINATE)))
            {
               APP_PRINT_ERROR2("app_handle_conn_state_evt: connection lost, conn_id %d, cause 0x%x", conn_id,
                                 disc_cause);
            }
            data_uart_print("Disconnect conn_id %d\r\n", conn_id);
            memset(&app_link_table[conn_id], 0, sizeof(T_APP_LINK));
      }
      break;
   case GAP_CONN_STATE_CONNECTED:
      {
            le_get_conn_addr(conn_id, app_link_table[conn_id].bd_addr,
                           &app_link_table[conn_id].bd_type);
            data_uart_print("Connected success conn_id %d\r\n", conn_id);
      }
      break;
   default:
      break;
   }
}

More information on GAP messages can be found in the chapter Bluetooth LE GAP Message of LE Host.

GAP Callback Handler

app_gap_callback() function is used to handle GAP callback messages. More information on GAP callback can be found in the chapter Bluetooth LE GAP Callback of LE Host.

T_APP_RESULT app_gap_callback(uint8_t cb_type, void *p_cb_data)
{
   T_APP_RESULT result = APP_RESULT_SUCCESS;
   T_LE_CB_DATA *p_data = (T_LE_CB_DATA *)p_cb_data;

   switch (cb_type)
   {
   /* common msg*/
   case GAP_MSG_LE_READ_RSSI:
   .......
}

Profile Client Message Callback

When APP uses xxx_add_client to register a specific client, the APP shall register the callback function to handle the message from the specific client. APP can register different callback functions to handle different clients or register the common callback function to handle all messages from specific clients.

app_client_callback() function is the common callback function. app_client_callback() can distinguish different clients by client ID.

void app_le_profile_init(void)
{
   client_init(3);
   gaps_client_id  = gaps_add_client(app_client_callback, APP_MAX_LINKS);
   simple_ble_client_id = simp_ble_add_client(app_client_callback, APP_MAX_LINKS);
   bas_client_id = bas_add_client(app_client_callback, APP_MAX_LINKS);
   client_register_general_client_cb(app_client_callback);
}
T_APP_RESULT app_client_callback(T_CLIENT_ID client_id, uint8_t conn_id, void *p_data)
{
   T_APP_RESULT  result = APP_RESULT_SUCCESS;
   APP_PRINT_INFO2("app_client_callback: client_id %d, conn_id %d",
                   client_id, conn_id);
   if (client_id == CLIENT_PROFILE_GENERAL_ID)
   {
       T_CLIENT_APP_CB_DATA *p_client_app_cb_data = (T_CLIENT_APP_CB_DATA *)p_data;
       switch (p_client_app_cb_data->cb_type)
       {
       case CLIENT_APP_CB_TYPE_DISC_STATE:
       ......
   }
   else if (client_id == gaps_client_id)
   {
       T_GAPS_CLIENT_CB_DATA *p_gaps_cb_data = (T_GAPS_CLIENT_CB_DATA *)p_data;
       switch (p_gaps_cb_data->cb_type)
       {
       case GAPS_CLIENT_CB_TYPE_DISC_STATE:
       ......
   }
}

ble_scatternet sample supports several GATT profile clients including GAP Service Client, Simple LE Service Client and Battery Service Client.

Profile Service Message Callback

When APP uses xxx_add_service to register a specific service, the APP shall register the callback function to handle the message from the specific service. APP shall call server_register_app_cb() to register the callback function used to handle the message from the profile server layer.

APP can register different callback functions to handle different services or register the general callback function to handle all messages from specific services and profile server layer.

app_profile_callback() function is the general callback function. app_profile_callback() can distinguish different services by service ID.

void app_le_profile_init(void)
{
   server_init(2);
   simp_srv_id = simp_ble_service_add_service(app_profile_callback);
   bas_srv_id  = bas_add_service(app_profile_callback);
   server_register_app_cb(app_profile_callback);
 }

More information can be found in the chapter GATT Profile Server EN of LE Host.

General profile server callback

SERVICE_PROFILE_GENERAL_ID is the service ID used by the profile server layer. Message used by the profile server layer contains two message types:

PROFILE_EVT_SRV_REG_COMPLETE

This message is used to inform that the service registration process has been completed in GAP Start Flow.
PROFILE_EVT_SEND_DATA_COMPLETE

This message is used to inform the result of sending the notification or indication.

T_APP_RESULT app_profile_callback(T_SERVER_ID service_id, void *p_data)
{
    T_APP_RESULT app_result = APP_RESULT_SUCCESS;
    if (service_id == SERVICE_PROFILE_GENERAL_ID)
    {
        T_SERVER_APP_CB_DATA *p_param = (T_SERVER_APP_CB_DATA *)p_data;
        switch (p_param->eventId)
        {
        case PROFILE_EVT_SRV_REG_COMPLETE:// srv register result event.
            APP_PRINT_INFO1("PROFILE_EVT_SRV_REG_COMPLETE: result %d",
                            p_param->event_data.service_reg_result);
            break;

        case PROFILE_EVT_SEND_DATA_COMPLETE:
            ......
            break;
        ......
}

Battery Service

bas_srv_id is the service ID of battery service.

T_APP_RESULT app_profile_callback(T_SERVER_ID service_id, void *p_data)
{
    T_APP_RESULT app_result = APP_RESULT_SUCCESS;
    ......
    else if (service_id == bas_srv_id)
    {
      T_BAS_CALLBACK_DATA *p_bas_cb_data = (T_BAS_CALLBACK_DATA *)p_data;
      switch (p_bas_cb_data->msg_type)
      {
      case SERVICE_CALLBACK_TYPE_INDIFICATION_NOTIFICATION:
            ......
}

Simple LE Service

simp_srv_id is the service ID of the simple LE service.

T_APP_RESULT app_profile_callback(T_SERVER_ID service_id, void *p_data)
{
    T_APP_RESULT app_result = APP_RESULT_SUCCESS;
    ......
    if (service_id == simp_srv_id)
    {
      TSIMP_CALLBACK_DATA *p_simp_cb_data = (TSIMP_CALLBACK_DATA *)p_data;
      switch (p_simp_cb_data->msg_type)
      {
      case SERVICE_CALLBACK_TYPE_INDIFICATION_NOTIFICATION:
          ......
}

Airplane Mode Setting

Register GAP Common Callback

APP needs to call gap_register_app_cb() to register the callback function.

void app_le_gap_init(void)
{
    ......
    gap_register_app_cb(app_gap_common_callback);
}

GAP Common Callback Handler

void app_gap_common_callback(uint8_t cb_type, void *p_cb_data)
{
    T_GAP_CB_DATA cb_data;
    memcpy(&cb_data, p_cb_data, sizeof(T_GAP_CB_DATA));
    APP_PRINT_INFO1("app_gap_common_callback: cb_type = %d", cb_type);
    switch (cb_type)
    {
    case GAP_MSG_WRITE_AIRPLAN_MODE:
      APP_PRINT_INFO1("GAP_MSG_WRITE_AIRPLAN_MODE: cause 0x%x",
                        cb_data.p_gap_write_airplan_mode_rsp->cause);
      break;
    case GAP_MSG_READ_AIRPLAN_MODE:
      APP_PRINT_INFO2("GAP_MSG_READ_AIRPLAN_MODE: cause 0x%x, mode %d",
                        cb_data.p_gap_read_airplan_mode_rsp->cause,
                        cb_data.p_gap_read_airplan_mode_rsp->mode);
      break;
    default:
      break;
    }
    return;
}

This callback function is used to handle the message GAP_MSG_WRITE_AIRPLAN_MODE and GAP_MSG_READ_AIRPLAN_MODE.

Related APIs

gap_write_airplan_mode() is used to write airplane mode.
gap_read_airplan_mode() is used to read airplane mode.

static T_USER_CMD_PARSE_RESULT cmd_wairplane(T_USER_CMD_PARSED_VALUE *p_parse_value)
{
   T_GAP_CAUSE cause;
   uint8_t mode = p_parse_value->dw_param[0];
   cause = gap_write_airplan_mode(mode);
   return (T_USER_CMD_PARSE_RESULT)cause;
}
static T_USER_CMD_PARSE_RESULT cmd_rairplane(T_USER_CMD_PARSED_VALUE *p_parse_value)
{
   T_GAP_CAUSE cause;
   cause = gap_read_airplan_mode();
   return (T_USER_CMD_PARSE_RESULT)cause;
}