BLEモジュールnRF52シリーズにおけるCentral機能とPeripheral機能の両方を実装する仕組み

# 記事の概要
Noridic社のBLEモジュールnRF52シリーズにCentral機能とPeripheral機能の両方を実装します。

SDKのバージョンにはnRF5_SDK_17.0.2を使用しました。

実際に作成したプロジェクトは以下を参照ください。
https://github.com/matsuikosuke/nRF52_Central_and_Peripheral

# 参照したサンプルプロジェクト
SDK17.0.2の\examples\ble_central_and_peripheral\experimentalの階層にある以下2つのサンプルプロジェクトを参照しました。

- ble_app_hrs_rscs_relay
- ble_app_multirole_lesc

これらのサンプルプロジェクトで使用されている変数や関数を説明することで、読者さんがこれらのサンプルプロジェクトからオリジナルのアプリケーションを作成できるようにするのが本記事の目的です。

本記事ではCentral機能のサービスの名称をorange_cとして、Peripheral機能のサービスの名称をorangeとします。

# static変数

## サービスの実体(instance)
サービスの実体(instance)を作成します。

例えばPeripheral機能のサービスorangeについて、includeファイルにinstance定義用のマクロを作成しておきます

```C:orange_service.h
#define BLE_ORANGE_DEF(_name) 
static ble_orange_t _name;    
NRF_SDH_BLE_OBSERVER(_name ## _obs,   
                     BLE_ORANGE_BLE_OBSERVER_PRIO,  
                     ble_orange_on_ble_evt, &_name)
```

`NRF_SDH_BLE_OBSERVER`はinstanceによるBLEイベントを`ble_orange_on_ble_evt`と関連付けるマクロです。
`BLE_ORANGE_BLE_OBSERVER_PRIO`はイベントの優先度で、sdk_define.hに設定しておきます。

```C:sdk_define.h
// <o> BLE_ORANGE_BLE_OBSERVER_PRIO
// <i> Priority with which BLE events are dispatched to the Orange Service.

#ifndef BLE_ORANGE_BLE_OBSERVER_PRIO
#define BLE_ORANGE_BLE_OBSERVER_PRIO2
#endif
```

Central機能も同様に定義します。

```C:orange_c_service.h
#define BLE_ORANGE_C_DEF(_name)                                                                        \
static ble_orange_c_t _name;                                                                           \
NRF_SDH_BLE_OBSERVER(_name ## _obs,
                     BLE_ORANGE_C_BLE_OBSERVER_PRIO,
                     ble_orange_c_on_ble_evt, &_name)
```

このマクロを用いてinstanceを実装します。
Nordicのサンプルプロジェクトではmain.cに実装していますが、私はBLE関連の設定はble_ctrl.cファイルに整理しています。

```C:ble_ctrl.c
static ble_orange_t m_orange;
static ble_orange_c_t m_orange_c;
```

もしくは

```C:ble_ctrl.c
BLE_ORANGE_DEF(m_orange);                    
BLE_ORANGE_C_DEF(m_orange_c); 
```

により実装します。

ただし`ble_orange_t `や`ble_orange_c_t`を使用した場合はBLEイベント割り込み処理`ble_evt_handler`において、サービス用の割り込み処理`ble_orange_on_ble_evt`や`ble_orange_c_on_ble_evt`を実行しないといけません。

`BLE_ORANGE_DEF`や`BLE_ORANGE_C_DEF`を使用した場合はBLEイベント割り込み発生時に、`BLE_ORANGE_DEF`や`BLE_ORANGE_C_DEF`で一緒に定義したサービス用の割り込み処理`ble_orange_on_ble_evt`や`ble_orange_c_on_ble_evt`が自動的に実行されます。

今回は明示的にサービス用の割り込み処理を実行したいので前者を使用します。

## BLEの変数

### 両機能共通

GATT module instanceを作成します。

```C:ble_ctrl.c
NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */
```

使用するUUIDを配列に格納しておきます。
配列使用時に分かりやすいように、配列のインデックス番号も定義しておきます。

```C:ble_ctrl.c
#define ORANGE_SERVICE_UUID_IDX      0 /**< ORANGE service UUID index in array. */
#define PEACH_SERVICE_UUID_IDX       1 /**< PEACH service UUID index in array. */

static ble_uuid_t m_adv_uuids[] =
{
    {ORANGE_UUID_SERVICE, BLE_UUID_TYPE_VENDOR_BEGIN},
    {PEACH_UUID_SERVICE,  BLE_UUID_TYPE_VENDOR_BEGIN}
};
```

Queued Write moduleを作成します。
`NRF_SDH_BLE_TOTAL_LINK_COUNT`はsdk_config.cにおいて定義する定位数で、Centralサービスの数とPeripheralサービスの数を足した総数です。

```C:ble_ctrl.c
NRF_BLE_QWRS_DEF(m_qwr, NRF_SDH_BLE_TOTAL_LINK_COUNT);                      /**< Context for the Queued Write module.*/
```

### Peripheral機能用
Advertising module instanceを作成します。

```C:ble_ctrl.c
BLE_ADVERTISING_DEF(m_advertising);                                 /**< Advertising module instance. */
```

PeripheralサービスのBLE接続時の`conn_handle`を記録する変数を作成します。
複数のPeripheralサービスがある場合も、Peripheralサービスは同時に１つしかBLE接続できないので全て共通の変数を使用します。

```C:ble_ctrl.c
static uint16_t m_conn_handle_peripheral  = BLE_CONN_HANDLE_INVALID;     
```

### Central機能用
BLE GATT Queue instanceを作成します。

```C:ble_ctrl.c
NRF_BLE_GQ_DEF(m_ble_gatt_queue,                                    
               NRF_SDH_BLE_CENTRAL_LINK_COUNT,
               NRF_BLE_GQ_QUEUE_SIZE);
```

discovery module instanceを作成します。
サービスが１つの場合は`BLE_DB_DISCOVERY_DEF`を使用します。

```C:ble_ctrl.c
BLE_DB_DISCOVERY_DEF(m_db_discovery);                         /**< Database discovery module instance. */
```

もしorange_cサービス以外にpeach_cサービスなど複数のサービス実装をする場合は`BLE_DB_DISCOVERY_ARRAY_DEF`を使用して、第2引数にサービスの数を設定します。

```C:ble_ctrl.c
BLE_DB_DISCOVERY_ARRAY_DEF(m_db_discovery, 2);                         /**< Database discovery module instances. */
```

Scanning module instanceを作成します。

```C:ble_ctrl.c
NRF_BLE_SCAN_DEF(m_scan);                                           /**< Scanning module instance. */
```

sdk_config.hに`NRF_BLE_SCAN_UUID_CNT`に使用するサービス数を設定します。
orange_cサービスだけならば1ですが、それ以外のサービスも使用する場合はサービス総数を設定してください。


```C:sdk_config.h
// <o> NRF_BLE_SCAN_UUID_CNT - Number of filters for UUIDs. 
#ifndef NRF_BLE_SCAN_UUID_CNT
#define NRF_BLE_SCAN_UUID_CNT 2
#endif
```

CentralサービスのBLE接続時の`conn_handle`を記録する変数を作成します。
Peripheralサービスと異なり、Centralサービスは同時に複数のBLE接続が可能なので、複数のCentralサービスがある場合はCentralサービスごとに変数を作成します。

```C:ble_ctrl.c
static uint16_t m_conn_handle_orange_c  = BLE_CONN_HANDLE_INVALID;     /**< Connection handle for the ORANGE central application */
```


# 両機能共通：GAPパラメータの設定
BLEに必須のGAPパラメータ設定処理です。
デバイス名の設定、接続パラメータの設定を行っています。

```C:ble_ctrl.c
static void gap_params_init(void)
{
    ret_code_t              err_code;
    ble_gap_conn_params_t   gap_conn_params;
    ble_gap_conn_sec_mode_t sec_mode;

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);

    err_code = sd_ble_gap_device_name_set(&sec_mode,
                                          (const uint8_t *)DEVICE_NAME,
                                          strlen(DEVICE_NAME));
    APP_ERROR_CHECK(err_code);

    memset(&gap_conn_params, 0, sizeof(gap_conn_params));

    gap_conn_params.min_conn_interval = m_scan.conn_params.min_conn_interval;
    gap_conn_params.max_conn_interval = m_scan.conn_params.max_conn_interval;
    gap_conn_params.slave_latency     = m_scan.conn_params.slave_latency;
    gap_conn_params.conn_sup_timeout  = m_scan.conn_params.conn_sup_timeout;

    err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
    APP_ERROR_CHECK(err_code);
}
```

# 両機能共通：GATTモジュールの設定

## GATTモジュールの初期化
BLEに必須のGATTモジュールの初期化処理です。

`nrf_ble_gatt_init`関数の第2引数にはGATT割り込み処理へのポインタを代入します。
割り込み処理がない場合はNULLにします。

```C:ble_ctrl.c
static void gatt_init(void)
{
    ret_code_t err_code = nrf_ble_gatt_init(&m_gatt, gatt_evt_handler);
    APP_ERROR_CHECK(err_code);
}
```

## GATTの割り込み処理

GATTの割り込み処理ではMTUを取得します。
つまり、PeripheralサービスがCentral機器とBLE接続した時に1パケットに最大何バイトのデータを乗せることができるかを確認します。

```
static void gatt_evt_handler(nrf_ble_gatt_t * p_gatt, nrf_ble_gatt_evt_t const * p_evt)
{
    if ((m_conn_handle_peripheral == p_evt->conn_handle) && (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED))
    {
        mtu_max_size = p_evt->params.att_mtu_effective - OPCODE_LENGTH - HANDLE_LENGTH;
    }
}

```


# 両機能共通：Peer Managerの設定
## Peer Manager初期化処理
BLEに必須のPeer Manageの初期化処理です。

[Peer Managerの説明](https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.sdk5.v15.0.0%2Flib_peer_manager.html)

```C:
static void peer_manager_init(void)
{
    ble_gap_sec_params_t sec_param;
    ret_code_t err_code;

    err_code = pm_init();
    APP_ERROR_CHECK(err_code);

    memset(&sec_param, 0, sizeof(ble_gap_sec_params_t));

    // Security parameters to be used for all security procedures.
    sec_param.bond           = SEC_PARAM_BOND;
    sec_param.mitm           = SEC_PARAM_MITM;
    sec_param.lesc           = SEC_PARAM_LESC;
    sec_param.keypress       = SEC_PARAM_KEYPRESS;
    sec_param.io_caps        = SEC_PARAM_IO_CAPABILITIES;
    sec_param.oob            = SEC_PARAM_OOB;
    sec_param.min_key_size   = SEC_PARAM_MIN_KEY_SIZE;
    sec_param.max_key_size   = SEC_PARAM_MAX_KEY_SIZE;
    sec_param.kdist_own.enc  = 1;
    sec_param.kdist_own.id   = 1;
    sec_param.kdist_peer.enc = 1;
    sec_param.kdist_peer.id  = 1;

    err_code = pm_sec_params_set(&sec_param);
    APP_ERROR_CHECK(err_code);

    err_code = pm_register(pm_evt_handler);
    APP_ERROR_CHECK(err_code);
}
```

## Peer Managerの割り込み処理
ホワイトリストを使用しないのならば`pm_handler_disconnect_on_sec_failure`を削除してください。

```C:
static void pm_evt_handler(pm_evt_t const * p_evt)
{
    pm_handler_on_pm_evt(p_evt);
    //pm_handler_disconnect_on_sec_failure(p_evt);
    pm_handler_flash_clean(p_evt);

    switch (p_evt->evt_id)
    {
        case PM_EVT_PEERS_DELETE_SUCCEEDED:
            adv_scan_start();
            break;

        default:
            break;
    }
}
```

## ボンディング削除処理
Peer Mangerで確立したボンディングを全て削除する処理です。

```C:
static void delete_bonds(void)
{
    ret_code_t err_code;

    NRF_LOG_INFO("Erase bonds!");

    err_code = pm_peers_delete();
    APP_ERROR_CHECK(err_code);
}
```

# 両機能共通：BLE stackの設定
ソフトデバイス設定の初期化とBLEイベント割り込みの設定を行います。
アプリケーションに依らずに共通して使用される必須の関数です。

`NRF_SDH_BLE_OBSERVER`を用いて、BLEイベント時に発生させる割り込み処理に`ble_evt_handler`関数を指定しています。

```C:ble_ctrl.c
#define APP_BLE_OBSERVER_PRIO           3

static void ble_stack_init(void)
{
    ret_code_t err_code;

    err_code = nrf_sdh_enable_request();
    APP_ERROR_CHECK(err_code);

    // Configure the BLE stack using the default settings.
    // Fetch the start address of the application RAM.
    uint32_t ram_start = 0;
    err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
    APP_ERROR_CHECK(err_code);

    // Enable BLE stack.
    err_code = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(err_code);

    // Register a handler for BLE events.
    NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
}
```

BLEイベント割り込みの優先度は`APP_BLE_OBSERVER_PRIO`で指定します。この値は3から変更しないでください。       

# 両機能共通：BLEイベント割り込み
BLEイベント割り込み処理を作成します。
両機能を実装するので、Central機能のイベントなのか、それともPeripheral機能のイベントなのかを識別する必要があります。

`ble_conn_state_role`関数により、イベントがCentralかPeripheralかを取得します。

`role`がPeripheralになるか、アドバタイジングパケット発信タイムアウト時にPeripheral用のBLEイベント処理を実行します。

`role`がCentralになるか、`BLE_GAP_EVT_ADV_REPORT`発生時にCentral用のBLEイベント処理を実行します。
`BLE_GAP_EVT_ADV_REPORT`はアドバタイジングパケット受信時かスキャンレスポンス受信時に発生するイベントです。

```C:ble_ctrl.c
static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
    uint16_t conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
    uint16_t role        = ble_conn_state_role(conn_handle);

    // Based on the role this device plays in the connection, dispatch to the right handler.
    if (role == BLE_GAP_ROLE_PERIPH || ble_evt_is_advertising_timeout(p_ble_evt))
    {
        ble_orange_on_ble_evt(p_ble_evt, &m_orange);
        on_ble_peripheral_evt(p_ble_evt);
    }
    else if ((role == BLE_GAP_ROLE_CENTRAL) || (p_ble_evt->header.evt_id == BLE_GAP_EVT_ADV_REPORT))
    {
        ble_orange_c_on_ble_evt(p_ble_evt, &m_orange_c);
        on_ble_central_evt(p_ble_evt);
    }
}
```

static変数で説明したように、`BLE_ORANGE_DEF`や`BLE_ORANGE_C_DEF`を使用した場合は`ble_orange_on_ble_evt`と`ble_orange_c_on_ble_evt`は削除します。
`BLE_ORANGE_DEF`や`BLE_ORANGE_C_DEF`においてこれらの割り込み処理の優先度を2に設定しているので、割り込み優先度3の`ble_evt_handler`より先に実行されます。

## アドバタイジングパケット発信タイムアウト
`ble_evt_handler`割り込み処理において、Peripheral用BLEイベント割り込みを実行するかどうかの判定に、BLEイベントがアドバタイジングパケット発信タイムアウトイベントかどうかを検知する関数を使用しています。

```C:ble_ctrl.c
static bool ble_evt_is_advertising_timeout(ble_evt_t const * p_ble_evt)
{
    return (p_ble_evt->header.evt_id == BLE_GAP_EVT_ADV_SET_TERMINATED);
}
```

## BLE GAPイベントとBLE GATTイベント
`p_ble_evt->header.evt_id`にはBLE GAPイベントもしくはBLE GATTイベントが格納されています。
BLE GATTイベントの定義には以下の種類があります。

[BLE GAPイベントの定義](https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.s132.api.v6.0.0%2Fgroup___b_l_e___g_a_p___e_n_u_m_e_r_a_t_i_o_n_s.html&anchor=gada486dd3c0cce897b23a887bed284fef)

- BLE_GAP_EVT_CONNECTED = 0x10
- BLE_GAP_EVT_DISCONNECTED = 0x10 + 1
- BLE_GAP_EVT_CONN_PARAM_UPDATE = 0x10 + 2
- BLE_GAP_EVT_SEC_PARAMS_REQUEST = 0x10 + 3
- BLE_GAP_EVT_SEC_INFO_REQUEST = 0x10 + 4
- BLE_GAP_EVT_PASSKEY_DISPLAY = 0x10 + 5
- BLE_GAP_EVT_KEY_PRESSED = 0x10 + 6
- BLE_GAP_EVT_AUTH_KEY_REQUEST = 0x10 + 7
- BLE_GAP_EVT_LESC_DHKEY_REQUEST = 0x10 + 8
- BLE_GAP_EVT_AUTH_STATUS = 0x10 + 9
- BLE_GAP_EVT_CONN_SEC_UPDATE = 0x10 + 10
- BLE_GAP_EVT_TIMEOUT = 0x10 + 11
- BLE_GAP_EVT_RSSI_CHANGED = 0x10 + 12
- BLE_GAP_EVT_ADV_REPORT = 0x10 + 13
- BLE_GAP_EVT_SEC_REQUEST = 0x10 + 14
- BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST = 0x10 + 15
- BLE_GAP_EVT_SCAN_REQ_REPORT = 0x10 + 16
- BLE_GAP_EVT_PHY_UPDATE_REQUEST = 0x10 + 17
- BLE_GAP_EVT_PHY_UPDATE = 0x10 + 18
- BLE_GAP_EVT_DATA_LENGTH_UPDATE_REQUEST = 0x10 + 19
- BLE_GAP_EVT_DATA_LENGTH_UPDATE = 0x10 + 20
- BLE_GAP_EVT_QOS_CHANNEL_SURVEY_REPORT = 0x10 + 21
- BLE_GAP_EVT_ADV_SET_TERMINATED = 0x10 + 22


[BLE GATTイベントの定義](https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.s132.api.v0.9.0%2Fgroup___b_l_e___g_a_t_t_c___e_n_u_m_e_r_a_t_i_o_n_s.html&anchor=gafd9b8b42eeb832d688e33f4561f97efc)

- BLE_GATTC_EVT_PRIM_SRVC_DISC_RSP = 0x30
- BLE_GATTC_EVT_REL_DISC_RSP
- BLE_GATTC_EVT_CHAR_DISC_RSP
- BLE_GATTC_EVT_DESC_DISC_RSP
- BLE_GATTC_EVT_CHAR_VAL_BY_UUID_READ_RSP
- BLE_GATTC_EVT_READ_RSP
- BLE_GATTC_EVT_CHAR_VALS_READ_RSP
- BLE_GATTC_EVT_WRITE_RSP
- BLE_GATTC_EVT_HVX
- BLE_GATTC_EVT_TIMEOUT

## Peripheral用BLEイベント割り込み

```C:ble_ctrl.c
static void on_ble_peripheral_evt(ble_evt_t const * p_ble_evt)
{
    ret_code_t err_code;
    switch (p_ble_evt->header.evt_id)
    {
        /*
        BLE GATTイベントに対応した処理を実行する
　　　　*/

        default:
            // No implementation needed.
            break;
    }
}
```

### BLE_GAP_EVT_CONNECTED
BLE接続時に実行されるイベントです。

必須の処理は、`multi_qwr_conn_handle_assign`関数を実行してQWRモジュールに接続ハンドルを割り当てることです。

```C:ble_ctrl.c
/** @brief The maximum number of peripheral and central links combined. */
#define NRF_BLE_LINK_COUNT              (NRF_SDH_BLE_PERIPHERAL_LINK_COUNT + NRF_SDH_BLE_CENTRAL_LINK_COUNT)


static void multi_qwr_conn_handle_assign(uint16_t conn_handle)
{
    for (uint32_t i = 0; i < NRF_BLE_LINK_COUNT; i++)
    {
        if (m_qwr[i].conn_handle == BLE_CONN_HANDLE_INVALID)
        {
            ret_code_t err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr[i], conn_handle);
            APP_ERROR_CHECK(err_code);
            break;
        }
    }
}
```

また`m_conn_handle_peripheral`に`conn_handle`を格納しておきます。


```C:ble_ctrl.c
case BLE_GAP_EVT_CONNECTED
    // Assign connection handle to the QWR module.
    multi_qwr_conn_handle_assign(p_ble_evt->evt.gap_evt.conn_handle);

    m_conn_handle_peripheral = p_ble_evt->evt.gap_evt.conn_handle;
    break;
```

### BLE_GAP_EVT_DISCONNECTED
BLE切断時に実行されるイベントです。
特に必須の処理はありませんが、`m_conn_handle_peripheral`を`BLE_CONN_HANDLE_INVALID`に初期化しておきます。

```C:ble_ctrl.c
case BLE_GAP_EVT_DISCONNECTED
    m_conn_handle_peripheral = BLE_CONN_HANDLE_INVALID;
    break;
```

### BLE_GAP_EVT_PHY_UPDATE_REQUEST
PHY更新要求イベントです。
`sd_ble_gap_phy_update`関数によりPHYを更新します。

```C:ble_ctrl.c
case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
{
    NRF_LOG_DEBUG("PHY update request.");
    ble_gap_phys_t const phys =
    {
        .rx_phys = BLE_GAP_PHY_AUTO,
        .tx_phys = BLE_GAP_PHY_AUTO,
    };
    err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
    APP_ERROR_CHECK(err_code);
} break;
```

### BLE_GATTC_EVT_TIMEOUT
GATT Clientのタイムアウトイベントです。
`sd_ble_gap_disconnect`関数によりBLE切断を実行します。

```C:ble_ctrl.c
case BLE_GATTC_EVT_TIMEOUT:
    // Disconnect on GATT Client timeout event.
    NRF_LOG_DEBUG("GATT Client Timeout.");
    err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
                                     BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
    APP_ERROR_CHECK(err_code);
    break;
```
### BLE_GATTS_EVT_TIMEOUT
GATT Serverのタイムアウトイベントです。
`sd_ble_gap_disconnect`関数によりBLE切断を実行します。


```C:ble_ctrl.c
case BLE_GATTC_EVT_TIMEOUT:
    // Disconnect on GATT Server timeout event.
    NRF_LOG_DEBUG("GATT Client Timeout.");
    err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
                                     BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
    APP_ERROR_CHECK(err_code);
    break;
```

## Central用BLEイベント割り込み

```C:ble_ctrl.c
static void on_ble_central_evt(ble_evt_t const * p_ble_evt)
{
    ret_code_t            err_code;
    ble_gap_evt_t const * p_gap_evt = &p_ble_evt->evt.gap_evt;
    ble_gap_evt_adv_report_t const * p_adv_report = &p_ble_evt->evt.gap_evt.params.adv_report;

    switch (p_ble_evt->header.evt_id)
    {
        /*
        BLE GATTイベントに対応した処理を実行する
　　　　*/        

        default:
            // No implementation needed.
            break;
    }
}
```

### BLE_GAP_EVT_ADV_REPORT
アドバタイジングパケット検知時に発生するイベントです。
アドバタイジングパケットかスキャンパケットかを`p_adv_report->type.scan_response`で識別しています。

以下ではスキャンで検知したアドバタイジングパケットとスキャンパケットを保存しています。
また、どちらにも該当しない場合はBeaconのアドバタイジングパケットと判定しています。

```C            
case BLE_GAP_EVT_ADV_REPORT:
{
        uint16_t length;
                
        length = p_adv_report->data.len;
        for (int i=0; i<length; i++)
        {
                if((1 == p_adv_report->type.connectable 
                        || 1 == p_adv_report->type.directed
                        || 1 == p_adv_report->type.scannable
                        || 1 == p_adv_report->type.extended_pdu)
                        && 0 == p_adv_report->type.scan_response)
                {
                        adv_buf[i] = p_adv_report->data.p_data[i];
                }
                else if(1 == p_adv_report->type.scan_response)
                {
                        scan_buf[i] = p_adv_report->data.p_data[i];
                }
                else if(0 == p_adv_report->type.connectable 
                    && 0 == p_adv_report->type.directed
                    && 0 == p_adv_report->type.scannable
                    && 0 == p_adv_report->type.extended_pdu
                    && 0 == p_adv_report->type.scan_response)
                {
                    beacon_buf[i] = p_adv_report->data.p_data[i];
                }
        }
}
break;
```

ここで[type](https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.s132.api.v6.0.0%2Fstructble__gap__evt__adv__report__t.html)には以下の種類があります。

- connectable:
    - BLE接続可能なアドバタイジングパケット
- scannable
    - スキャン専用のアドバタイジングパケット。BLE接続する必要のないBeaconに使用される。
- directed
    - ダイレクトアドバタイジングパケット
- scan_response
    - スキャンレスポンス
- extended_pdu
    - 拡張アドバタイジングパケット
- status
    - BLE_GAP_ADV_DATA_STATUS_COMPLETE   0x00
        - アドバタイジングパケットデータを全て受信した状態
    - BLE_GAP_ADV_DATA_STATUS_INCOMPLETE_MORE_DATA   0x01
        - 未受信のアドバタイジングパケットデータがある状態
    - BLE_GAP_ADV_DATA_STATUS_INCOMPLETE_TRUNCATED   0x02
        - アドバタイジングパケットデータ受信バッファサイズが不足している状態
    - BLE_GAP_ADV_DATA_STATUS_INCOMPLETE_MISSED   0x03
        - アドバタイジングパケットを全て受信するのに失敗した状態

### BLE_GAP_EVT_CONNECTED
BLE接続時に実行されるイベントです。

必須の処理は、`multi_qwr_conn_handle_assign`関数を実行してQWRモジュールに接続ハンドルを割り当てることです。

`m_conn_handle_orange_c`が使用されているかを確認して、使用されていなければorange_cサービスのDiscovery処理を開始させます。

```C:
case BLE_GAP_EVT_CONNECTED:
{
    // If no Orange Central service is currently connected, try to find them on this peripheral.
    if (m_conn_handle_orange_c == BLE_CONN_HANDLE_INVALID)
    {
        NRF_LOG_INFO("CENTRAL: Searching for Orange on conn_handle 0x%x", p_gap_evt->conn_handle);

        err_code = ble_db_discovery_start(&m_db_disc, p_gap_evt->conn_handle);
        APP_ERROR_CHECK(err_code);
    }

    // Assign connection handle to the QWR module.
    multi_qwr_conn_handle_assign(p_gap_evt->conn_handle);
} break
```

### BLE_GAP_EVT_DISCONNECTED
BLE切断時に実行されるイベントです。
`m_conn_handle_orange_c`を`BLE_CONN_HANDLE_INVALID`に初期化し、`filter_settings_change`関数によりSCAN設定も更新します。
（サンプルプロジェクトでは`nrf_ble_scan_filter_set`関数だけを実行していましたが、`nrf_ble_scan_all_filter_remove`を実行せずにその関数を実行するとエラーになりました。）
`m_conn_handle_orange_c`が使用されているかを確認して、使用されていなければorange_cサービスのSCAN処理を開始させます。

（追記）
Peripheral機器とのBLE切断時に`filter_settings_change`を実行すると、リセットしない限り、2度とPeripheral機器と再接続しなくなりました。
この処理を削除すると何度もPeripheral機器とBLE接続できるようになりました。

```C:ble_ctrl.c
case BLE_GAP_EVT_DISCONNECTED:
{
    if (p_gap_evt->conn_handle == m_conn_handle_orange_c)
    {
        NRF_LOG_INFO("Orange central disconnected (reason: %d)",
                             p_gap_evt->params.disconnected.reason);

        m_conn_handle_orange_c = BLE_CONN_HANDLE_INVALID;
                
        //filter_settings_change();
    }

    if (m_conn_handle_orange_c == BLE_CONN_HANDLE_INVALID)
    {
        // Start scanning.
        scan_start();
    }
} break
```

### BLE_GAP_EVT_TIMEOUT
GATT Clientのタイムアウトイベントです。
SCANがタイムアウトになった場合か接続要求がタイムアウトになった場合に発生します。
前者と後者を区別するには`p_gap_evt->params.timeout.src`を確認します。

```C:ble_ctrl.c
case BLE_GAP_EVT_TIMEOUT:
{
    // scanning time out.
    if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_SCAN)
    {
        NRF_LOG_DEBUG("CENTRAL: Scanning timed out.");
    }
    // connection attemps time out.
    else if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN)
    {
        NRF_LOG_DEBUG("CENTRAL: Connection Request timed out.");
    }
} break;
```

GAPタイムアウト要因には以下の種類があります。

- BLE_GAP_TIMEOUT_SRC_SCAN   0x01
- BLE_GAP_TIMEOUT_SRC_CONN   0x02
- BLE_GAP_TIMEOUT_SRC_AUTH_PAYLOAD   0x03

### BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST
接続パラメータ更新要求イベントです。
`sd_ble_gap_conn_param_update`関数により接続パラメータ更新します。

```C:ble_ctrl.c
case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST:
{
    // Accept parameters requested by peer.
    err_code = sd_ble_gap_conn_param_update(p_gap_evt->conn_handle,
                                &p_gap_evt->params.conn_param_update_request.conn_params);
    APP_ERROR_CHECK(err_code);
} break;
```

### BLE_GAP_EVT_PHY_UPDATE_REQUEST
PHY更新要求イベントです。
Peripheral側と同様に`sd_ble_gap_phy_update`関数によりPHYを更新します。

### BLE_GATTC_EVT_TIMEOUT
GATT Clientのタイムアウトイベントです。
Peripheral側と同様に`sd_ble_gap_disconnect`関数によりBLE切断を実行します。

### BLE_GATTS_EVT_TIMEOUT
GATT Serverのタイムアウトイベントです。
Peripheral側と同様に`sd_ble_gap_disconnect`関数によりBLE切断を実行します。

## PASS KEYを使用する場合
PASS KEYを使用する場合は、Central機能とPeripheral機能の両方共通のBLEイベント処理を実行します。

Central側はPASS KEYをPeripheral側に送信し、Peripheral側の入力デバイスでPASS KEYを入力して一致すればBLE接続されます。

```C:
/**@brief Function for checking whether a link already exists with a newly connected peer.
 *
 * @details This function checks whether the newly connected device is already connected.
 *
 * @param[in]   p_connected_evt Bluetooth connected event.
 * @return                      True if the peer's address is found in the list of connected peers,
 *                              false otherwise.
 */
static bool is_already_connected(ble_gap_addr_t const * p_connected_adr)
{
    for (uint32_t i = 0; i < NRF_BLE_LINK_COUNT; i++)
    {
        if (m_connected_peers[i].is_connected)
        {
            if (m_connected_peers[i].address.addr_type == p_connected_adr->addr_type)
            {
                if (memcmp(m_connected_peers[i].address.addr,
                           p_connected_adr->addr,
                           sizeof(m_connected_peers[i].address.addr)) == 0)
                {
                    return true;
                }
            }
        }
    }
    return false;
}


/** @brief Function for handling a numeric comparison match request. */
static void on_match_request(uint16_t conn_handle, uint8_t role)
{
    // Mark the appropriate conn_handle as pending. The rest is handled on button press.
    NRF_LOG_INFO("Press Button 1 to confirm, Button 2 to reject");
    if (role == BLE_GAP_ROLE_CENTRAL)
    {
        m_conn_handle_num_comp_central = conn_handle;
    }
    else if (role == BLE_GAP_ROLE_PERIPH)
    {
        m_conn_handle_num_comp_peripheral = conn_handle;
    }
}

static void on_ble_evt(uint16_t conn_handle, ble_evt_t const * p_ble_evt)
{
    char        passkey[BLE_GAP_PASSKEY_LEN + 1];
    uint16_t    role = ble_conn_state_role(conn_handle);

    pm_handler_secure_on_connection(p_ble_evt);

    switch (p_ble_evt->header.evt_id)
    {
        case BLE_GAP_EVT_CONNECTED:
            m_connected_peers[conn_handle].is_connected = true;
            m_connected_peers[conn_handle].address = p_ble_evt->evt.gap_evt.params.connected.peer_addr;
            multi_qwr_conn_handle_assign(conn_handle);
            break;

        case BLE_GAP_EVT_DISCONNECTED:
            memset(&m_connected_peers[conn_handle], 0x00, sizeof(m_connected_peers[0]));
            break;

        case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
            NRF_LOG_INFO("%s: BLE_GAP_EVT_SEC_PARAMS_REQUEST", nrf_log_push(roles_str[role]));
            break;

        case BLE_GAP_EVT_PASSKEY_DISPLAY:
            memcpy(passkey, p_ble_evt->evt.gap_evt.params.passkey_display.passkey, BLE_GAP_PASSKEY_LEN);
            passkey[BLE_GAP_PASSKEY_LEN] = 0x00;
            NRF_LOG_INFO("%s: BLE_GAP_EVT_PASSKEY_DISPLAY: passkey=%s match_req=%d",
                         nrf_log_push(roles_str[role]),
                         nrf_log_push(passkey),
                         p_ble_evt->evt.gap_evt.params.passkey_display.match_request);

            if (p_ble_evt->evt.gap_evt.params.passkey_display.match_request)
            {
                on_match_request(conn_handle, role);
            }
            break;

        case BLE_GAP_EVT_AUTH_KEY_REQUEST:
            NRF_LOG_INFO("%s: BLE_GAP_EVT_AUTH_KEY_REQUEST", nrf_log_push(roles_str[role]));
            break;

        case BLE_GAP_EVT_LESC_DHKEY_REQUEST:
            NRF_LOG_INFO("%s: BLE_GAP_EVT_LESC_DHKEY_REQUEST", nrf_log_push(roles_str[role]));
            break;

         case BLE_GAP_EVT_AUTH_STATUS:
             NRF_LOG_INFO("%s: BLE_GAP_EVT_AUTH_STATUS: status=0x%x bond=0x%x lv4: %d kdist_own:0x%x kdist_peer:0x%x",
                          nrf_log_push(roles_str[role]),
                          p_ble_evt->evt.gap_evt.params.auth_status.auth_status,
                          p_ble_evt->evt.gap_evt.params.auth_status.bonded,
                          p_ble_evt->evt.gap_evt.params.auth_status.sm1_levels.lv4,
                          *((uint8_t *)&p_ble_evt->evt.gap_evt.params.auth_status.kdist_own),
                          *((uint8_t *)&p_ble_evt->evt.gap_evt.params.auth_status.kdist_peer));
            break;

        default:
            // No implementation needed.
            break;
    }
}
```

詳細はサンプルプロジェクトble_app_multirole_lescの設定を参照してください。


# Central機能：SCANの設定

## SCAN初期化関数

```C:ble_ctrl.c
static char const m_target_periph_name[] = "My_Customer";

static void scan_init(void)
{
    ret_code_t          err_code;
    nrf_ble_scan_init_t init_scan;

    memset(&init_scan, 0, sizeof(init_scan));

    init_scan.p_scan_param = &m_scan_param;

    err_code = nrf_ble_scan_init(&m_scan, &init_scan, scan_evt_handler);
    APP_ERROR_CHECK(err_code);

    if (strlen(m_target_periph_name) != 0)
    {
        err_code = nrf_ble_scan_filter_set(&m_scan, 
                                           SCAN_NAME_FILTER, 
                                           m_target_periph_name);
        APP_ERROR_CHECK(err_code);
    }

    err_code = nrf_ble_scan_filter_set(&m_scan, 
                                       SCAN_UUID_FILTER, 
                                       &m_adv_uuids[ORANGE_SERVICE_UUID_IDX]);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_ble_scan_filter_set(&m_scan, 
                                       SCAN_UUID_FILTER, 
                                       &m_adv_uuids[PEACH_SERVICE_UUID_IDX]);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_ble_scan_filters_enable(&m_scan, 
                                           NRF_BLE_SCAN_ALL_FILTER, 
                                           false);
    APP_ERROR_CHECK(err_code);

}
```

`nrf_ble_scan_init`関数は必ず実行します。


`nrf_ble_scan_filter_set`関数は、第2引数にはSCANフィルタモードを指定した上で、第3引数にフィルタ対象を代入します。

例えば特定のDevice Nameをスキャンしたい場合は、`nrf_ble_scan_filter_set`関数の第2引数に`SCAN_NAME_FILTER`を指定し、第3引数の`m_target_periph_name`にDevice Nameを代入するとスキャンフィルタが設定されます。

Device Nameによるスキャンが不要でしたら、`m_target_periph_name`を空にしておけば`nrf_ble_scan_filter_set`関数は実行されません。

UUIDをスキャンしたい場合は、`nrf_ble_scan_filter_set`関数の第2引数に`SCAN_UUID_FILTER`を指定し、第3引数にUUIDを代入するとスキャンフィルタが設定されます。

複数のUUIDを設定した場合は、UUIDごとに`nrf_ble_scan_filter_set`関数を実行します。

最後に`nrf_ble_scan_filters_enable`関数を実行して、どのフィルタを有効にするかを決めます。
第2引数にはSCANフィルタモードを指定します。

例えば第2引数にSCAN_NAME_FILTERを設定すると、DEVICE NAMEによるスキャンのみが有効になり、UUIDによるスキャンは実行されません。
両方を有効にしたい場合は、第2引数にSCAN_NAME_FILTER | SCAN_UUID_FILTERを設定するか、全てを有効化にするNRF_BLE_SCAN_ALL_FILTERを設定します。

`nrf_ble_scan_filters_enable`関数の第3引数ではmatch_allを指定します。falseにすれば設定したフィルタのどれか1つが一致すればスキャンイベントを発生させます。
trueにすれば全てのフィルタが一致しないとスキャンイベントが発生しません。

### SCANフィルタモードの定義
SCANフィルタのモードには以下の種類があります。

- NRF_BLE_SCAN_NAME_FILTER   (0x01)
    - デバイス名によるフィルタ
- NRF_BLE_SCAN_ADDR_FILTER   (0x02)
    - デバイスアドレスによるフィルタ
- NRF_BLE_SCAN_UUID_FILTER   (0x04)
    - UUIDによるフィルタ
- NRF_BLE_SCAN_APPEARANCE_FILTER   (0x08)
    - APPEARANCE（外部装置）によるフィルタ
- NRF_BLE_SCAN_SHORT_NAME_FILTER   (0x10)
    - デバイス短縮名によるフィルタ
- NRF_BLE_SCAN_ALL_FILTER   (0x1F)
    - 上記全てのフィルタ

https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.sdk5.v15.2.0%2Flib_ble_scan.html

## SCANパラメータ
SCAN初期化関数においてスキャンパラメータを設定しています。

```C:ble_ctrl.c
init_scan.p_scan_param = &m_scan_param;
```

この設定は省略できます。
省略するとsdk_config.hに設定されている値が自動的に使用されます。

スキャンパラメータを独自に設定する場合はm_scan_paramを作成します。

```C:ble_ctrl.c
static ble_gap_scan_params_t m_scan_param =                 /**< Scan parameters requested for scanning and connection. */
{
    .active        = 0x01,
    .interval      = NRF_BLE_SCAN_SCAN_INTERVAL,
    .window        = NRF_BLE_SCAN_SCAN_WINDOW,
    .filter_policy = BLE_GAP_SCAN_FP_ACCEPT_ALL,
    .timeout       = NRF_BLE_SCAN_SCAN_DURATION,
    .scan_phys     = BLE_GAP_PHY_1MBPS,
    .extended      = true,
};
```

[ble_gap_scan_params_tの構造](https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.s132.api.v6.0.0%2Fstructble__gap__scan__params__t.html)は以下になります。

- interval
    - スキャン間隔。スキャン実行間隔を設定します。
- window
    - スキャンウィンドウ。スキャン実行時間を設定します。
- filter_policy
    - フィルタポリシー。スキャンを許可するアドバタイジングパケットを設定します。
- timeout
    - スキャン実行タイムアウト。スキャン実行時間を設定します。
- scan_phys
    - GAP PHYsです。主なアドバタイジングパケットのスキャンに使用するPHYを設定します。
- extended
    -  拡張アドバタイジングパケットもスキャンする場合はtrueに設定します。

### スキャン間隔とスキャンウィンドウ

例えばNRF_BLE_SCAN_SCAN_INTERVALを1秒、NRF_BLE_SCAN_SCAN_WINDOWを100msecに設定すると、100secスキャン実行するとスキャン停止し、1秒後にスキャン再開、100msec経過後にスキャン停止というスキャン動作を繰り返します。

スキャンによる消費電力を抑えたい場合はスキャン間隔を増やし、スキャンウィンドウを短くします。
その代わりスキャン間隔を増やすとアドバタイジングパケットを探す頻度が減るのでBLE接続に要する時間が長くなります。
スキャンウィンドウを短くするとアドバタイジングパケットを探す時間が減るので、アドバタイジングパケット発信周期が長いデバイスを発見することができなくなります。

スキャンウィンドウの長さは、最低でもアドバタイジングパケット5周期分より長くすべきでしょう。
アドバタイジングパケットは複数のチャンネル周期を使用しており、それらのいずれかがスキャンに引っかかるからです。

### フィルタポリシー
[フィルタポリシーの定義](https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.s132.api.v6.0.0%2Fgroup___b_l_e___g_a_p___s_c_a_n___f_i_l_t_e_r___p_o_l_i_c_i_e_s.html)には以下の種類があります。

- BLE_GAP_SCAN_FP_ACCEPT_ALL   0x00
    - アドレス指定したダイレクトアドバタイジングパケットを除く、全てのアドバタイジングパケットをスキャンします
- BLE_GAP_SCAN_FP_WHITELIST   0x01
    - アドレス指定したダイレクトアドバタイジングパケットを除く、ホワイトリストに登録されたアドバタイジングパケットをスキャンします
- BLE_GAP_SCAN_FP_ALL_NOT_RESOLVED_DIRECTED   0x02
    - ダイレクトアドバタイジングパケットを含めた全てのアドバタイジングパケットをスキャンします
- BLE_GAP_SCAN_FP_WHITELIST_NOT_RESOLVED_DIRECTED   0x03
    - ダイレクトアドバタイジングパケットを含めたホワイトリストに登録されたアドバタイジングパケットをスキャンします

ダイレクトアドバタイジングパケットとは、ランダムなMACアドレスを使用しないアドバタイジングパケットです。
ダイレクトアドバタイジングパケットについては以下の記事を参照してください。
https://ednjapan.com/edn/articles/1509/18/news045_3.html

### スキャン実行タイムアウト
スキャン開始後、スキャン実行タイムアウトで設定した時間が経過すると自動でスキャンが停止します。
一度スキャン停止すると再度スキャン開始を指示しない限りスキャンを実行しません。

スキャンを自動停止させたくない場合はnullを設定します。

### GAP PHYs

[GAP PHYsの定義](https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.s140.api.v6.0.0%2Fgroup___b_l_e___g_a_p___p_h_y_s.html)には以下の種類があります。


- BLE_GAP_PHY_AUTO   0x00
- BLE_GAP_PHY_1MBPS   0x01
- BLE_GAP_PHY_2MBPS   0x02
- BLE_GAP_PHY_CODED   0x04
- BLE_GAP_PHY_NOT_SET   0xFF
- BLE_GAP_PHYS_SUPPORTED
    - (BLE_GAP_PHY_1MBPS | BLE_GAP_PHY_2MBPS | BLE_GAP_PHY_CODED)


extendsがfalseに設定されている場合、サポートされるPHYはBLE_GAP_PHY_1MBPSのみです。

## SCAN設定の削除と再設定
SCAN設定は初期化時以外でも更新できます。
`nrf_ble_scan_all_filter_remove`関数で設定を削除してから、SCAN初期化時と同様にnrf_ble_scan_filter_set関数を実行してください。

```C:ble_ctrl.c
static void filter_settings_change(void)
{
    ret_code_t err_code;

    err_code = nrf_ble_scan_all_filter_remove(&m_scan);
    APP_ERROR_CHECK(err_code);

    /*
    SCAN初期化時と同様にnrf_ble_scan_filter_set関数を実行する。
　　対象のSCANフィルタモードを既に有効化しているならばnrf_ble_scan_filters_enable関数は実行しなくていい。
    */
}
```


対象のSCANフィルタモードを既に有効化しているならば`nrf_ble_scan_filters_enable`関数を再実行する必要はありません。


## SCAN開始と停止
`scan_start`関数を実行するとSCAN開始します。

```C:ble_ctrl.c
static void scan_start(void)
{
    ret_code_t err_code;

    err_code = nrf_ble_scan_start(&m_scan);
    APP_ERROR_CHECK(err_code);

    NRF_LOG_INFO("Scanning");
}
```

SCAN停止する時は`nrf_ble_scan_stop`を実行します。

```C:ble_ctrl.c
static void scan_stop(void)
{
    nrf_ble_scan_stop();

    NRF_LOG_INFO("Stop Scan");
}
```

## SCANイベント割り込み処理
SCANフィルタに設定した条件のアドバタイジングパケットを検知するとSCANイベントが発生します。

`p_adv `にスキャンしたアドバタイジングパケットのデータが格納されています。
`p_scan_param`にスキャンパラメータのデータが格納されています。

```C:
static void scan_evt_handler(scan_evt_t const * p_scan_evt)
{
    ret_code_t err_code;
    ble_gap_evt_adv_report_t const * p_adv = 
                   p_scan_evt->params.filter_match.p_adv_report;
    ble_gap_scan_params_t    const * p_scan_param = 
                   p_scan_evt->p_scan_params;

    switch(p_scan_evt->scan_evt_id)
    {
        case NRF_BLE_SCAN_EVT_FILTER_MATCH:
        {
            // Initiate connection.
            err_code = sd_ble_gap_connect(&p_adv->peer_addr,
                                          p_scan_param,
                                          &m_scan.conn_params,
                                          APP_BLE_CONN_CFG_TAG);
            APP_ERROR_CHECK(err_code);
        } break;

        default:
            break;
    }
}
```

`NRF_BLE_SCAN_EVT_FILTER_MATCH`はSCANフィルタ一致イベントです。
このイベント発生時に`sd_ble_gap_connect`関数により対象のデバイスとBLE接続しています。

### SCANイベントの定義
SCANイベントの定義には以下の種類があります。

- NRF_BLE_SCAN_EVT_FILTER_MATCH
    - SCANデータがフィルタと一致した
- NRF_BLE_SCAN_EVT_WHITELIST_REQUEST
    - アプリからのホワイトリスト要求
- NRF_BLE_SCAN_EVT_WHITELIST_ADV_REPORT
    - ホワイトリストのデバイスを発見してNotification送信
- NRF_BLE_SCAN_EVT_NOT_FOUND
    - SCANデータがフィルタと一致しなかった
- NRF_BLE_SCAN_EVT_SCAN_TIMEOUT
    - SCAN検知せずにDurationで設定したSCANタイムアウト時間が経過した
- NRF_BLE_SCAN_EVT_SCAN_REQ_REPORT
    - SCAN要求レポート
- NRF_BLE_SCAN_EVT_CONNECTING_ERROR
    - BLE接続中にエラーが発生した
- NRF_BLE_SCAN_EVT_CONNECTED
    - デバイスとBLE接続した


# Central機能：BLE接続パラメータの設定

```C:ble_ctrl.c
static void conn_params_error_handler(uint32_t nrf_error)
{
    APP_ERROR_HANDLER(nrf_error);
}

static void conn_params_init(void)
{
    ret_code_t             err_code;
    ble_conn_params_init_t cp_init;

    memset(&cp_init, 0, sizeof(cp_init));

    cp_init.p_conn_params                  = NULL;
    cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
    cp_init.next_conn_params_update_delay  = NEXT_CONN_PARAMS_UPDATE_DELAY;
    cp_init.max_conn_params_update_count   = MAX_CONN_PARAMS_UPDATE_COUNT;
    cp_init.start_on_notify_cccd_handle    = BLE_GATT_HANDLE_INVALID; // Start upon connection.
    cp_init.disconnect_on_fail             = true;
    cp_init.evt_handler                    = NULL;  // Ignore events.
    cp_init.error_handler                  = conn_params_error_handler;

    err_code = ble_conn_params_init(&cp_init);
    APP_ERROR_CHECK(err_code);
}
```


# Central機能：Discoveryの設定

## Discovery初期化関数

```C:
static void db_discovery_init(void)
{
    ble_db_discovery_init_t db_init;

    memset(&db_init, 0, sizeof(db_init));

    db_init.evt_handler =  db_disc_handler;
    db_init.p_gatt_queue = &m_ble_gatt_queue;

    ret_code_t err_code = ble_db_discovery_init(&db_init);
    APP_ERROR_CHECK(err_code);
}
```

## Discovery割り込み処理
必須の処理は`ble_orange_on_db_disc_evt`関数になります。

以下では`p_evt->params.p_db_instance`を取得してDiscovery可能なinstanceの確認をしています。

```C:
static void db_disc_handler(ble_db_discovery_evt_t * p_evt)
{
    ble_db_discovery_t const * p_db = (ble_db_discovery_t *)p_evt->params.p_db_instance;

    ble_orange_on_db_disc_evt(&m_orange_c, p_evt);

    if (p_evt->evt_type == BLE_DB_DISCOVERY_AVAILABLE) {
        NRF_LOG_INFO("DB Discovery instance %p available on conn handle: %d",
                     p_db,
                     p_evt->conn_handle);
        NRF_LOG_INFO("Found %d services on conn_handle: %d",
                     p_db->srv_count,
                     p_evt->conn_handle);
    }
}
```

# Peripheral機能：アドバタイジングの設定

## アドバタイジング初期化処理

```C:
#define		MY_COMPANY_IDENTIFIER           0xFFFF

static void advertising_init(void)
{
    ret_code_t             err_code;
    ble_advertising_init_t init;

    uint8_t some_data[6] = "Hello!";
    ble_advdata_manuf_data_t manuf_buf;
    manuf_buf.company_identifier = MY_COMPANY_IDENTIFIER;
    manuf_buf.data.p_data = (uint8_t*) &some_data;
    manuf_buf.data.size   = sizeof(some_data);

    memset(&init, 0, sizeof(init));

    init.srdata.p_manuf_specific_data = &manuf_buf;
    init.advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    init.advdata.include_appearance      = true;
    init.advdata.flags                   = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
    init.advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
    init.advdata.uuids_complete.p_uuids  = m_adv_uuids;

    init.config.ble_adv_fast_enabled  = true;
    init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
    init.config.ble_adv_fast_timeout  = APP_ADV_DURATION;

    init.evt_handler = on_adv_evt;

    err_code = ble_advertising_init(&m_advertising, &init);
    APP_ERROR_CHECK(err_code);

    ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}
```

### アドバタイジングパケットとスキャンパケット
アドバタイジングパケットのデータサイズには制限があります。
アドバタイジングパケットにデータが入りきらない場合はスキャンパケットを使用できます。
スキャンパケットに格納するデータには`srdata`を使います。

例えばアドバタイジングパケットに格納していたデバイス名をスキャンパケットに格納したい場合は、`init.advdata.name_type`を`init.srdata.name_type`に修正します。

## アドバタイジングパケットの設定
アドバタイジングパケットの設定方法について以下に解説します。

### デバイス名
`gap_params_init`において設定したDevice名が使用されます。

Device名については、アドバタイジングパケットには格納しないか、Device名を全て格納するか、Device名の先頭の数byteのみを短縮名として格納するかを選択できます。

`name_type`に設定可能な定義は以下になります。
今回はDevice名を省略せずに使用するので`BLE_ADVDATA_FULL_NAME`に設定します。

- BLE_ADVDATA_NO_NAME
    - アドバタイジングパケットには格納しない
- BLE_ADVDATA_SHORT_NAME
    - Device名を全て格納する
- BLE_ADVDATA_FULL_NAME
    - 先頭の数byteのみを短縮名として格納する


### UUID
UUIDには短縮UUIDとユーザが自由に設定できるオリジナルのUUIDがあります。
短縮UUIDはデータサイズが小さいという利点がありますが、使用するにはBLE SIGへの登録が必要です。勝手に好きな短縮UUIDを使用しないようにご注意ください。

UUIDは変数`m_adv_uuids`において設定したものを使用します。

```C
static ble_uuid_t m_adv_uuids[] =
{
    {ORANGE_UUID_SERVICE, BLE_UUID_TYPE_VENDOR_BEGIN},
    {PEACH_UUID_SERVICE,  BLE_UUID_TYPE_VENDOR_BEGIN}
};
```

- ble_uuid_t の要素
    - uint16_t 	uuid 
    - uint8_t 	type

uuid にはサービスUUIDを設定します。
サービス作成時に以下のように作成したものを使用します。

```C:orange_service.h
//BASE-UUID:4ab4xxxx-65bc-126e-3b8c-8345de91b0d3
#define ORANGE_UUID_BASE {0xd3, 0xb0, 0x91, 0xde, 0x45, 0x83, 0x8c, 0x3b, \
                              0x6e, 0x12, 0xbc, 0x65, 0x00, 0x00, 0xb4, 0x4a}
#define ORANGE_UUID_SERVICE            0xABC0
```

type には短縮UUIDを使用する場合には`BLE_UUID_TYPE_BLE`を設定し、オリジナルUUIDを使用する場合には`BLE_UUID_TYPE_VENDOR_BEGIN`を設定します。

- BLE_UUID_TYPE_UNKNOWN   0x00
- BLE_UUID_TYPE_BLE   0x01
- BLE_UUID_TYPE_VENDOR_BEGIN   0x02

### flag
flagsに設定可能な定義は以下になります。
今回はGAP Advertisement Flagsを『BLEのみに対応しているGeneral Discoverable Mode』に設定しています。

| 定義名       |  値 |    意味    |
|:-----------------|:------------------:|:------------------|
| BLE_GAP_ADV_FLAG_LE_LIMITED_DISC_MODE |   (0x01)| Limited Discoverable Mode |
| BLE_GAP_ADV_FLAG_LE_GENERAL_DISC_MODE |   (0x02)| General Discoverable Mode |
| BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED |   (0x04)| BLE(Bluetooth Low Energy)のみに対応し、Bluetooth 3.0には対応していない |
| BLE_GAP_ADV_FLAG_LE_BR_EDR_CONTROLLER |   (0x08)| BLE(Bluetooth Low Energy)とBluetooth 3.0 コントロール側に対応している |
| BLE_GAP_ADV_FLAG_LE_BR_EDR_HOST |   (0x10)| BLE(Bluetooth Low Energy)とBluetooth 3.0 ホスト側に対応している |
| BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE |  |BLE_GAP_ADV_FLAG_LE_LIMITED_DISC_MODEかつBLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED  |
| BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE || BLE_GAP_ADV_FLAG_LE_GENERAL_DISC_MODEかつBLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED | 

### アドバタイジングパケット発信周期
`ble_adv_fast_interval `にはアドバタイジングパケット発信周期を設定します。
アドバタイジングパケット発信には複数のチャンネルを使用するので、セントラル機器に発見されるには、アドバタイジングパケット発信周期の5倍くらいの時間がかかることを念頭に置いて設定ください。

###アドバタイジングパケットタイムアウト
アドバタイジングパケット発信開始後、一定時間経過すると自動で発信停止にする場合、`ble_adv_fast_timeout`を設定します。
一度停止すれば、アドバタイジングパケット発信開始命令を再実行しない限り、発信は開始されません。

自動で発信停止にしない場合は`BLE_GAP_ADV_TIMEOUT_GENERAL_UNLIMITED`を設定してください。

```C
#define APP_ADV_DURATION                BLE_GAP_ADV_TIMEOUT_GENERAL_UNLIMITED
```

### マニファクチャ・データ
マニファクチャ・データ`ble_advdata_manuf_data_t`には製造上の様々なデータを格納できます。

```C
uint8_t some_data[6] = "Hello!";
ble_advdata_manuf_data_t manuf_buf;
manuf_buf.company_identifier = MY_COMPANY_IDENTIFIER;
manuf_buf.data.p_data = (uint8_t*) &some_data;
manuf_buf.data.size   = sizeof(some_data);
```

- 任意のデータ：data
    - p_data：データのポインタを指定
    - size：データサイズを設定
- 会社識別コード：company_identifier 

今回はデータサイズがアドバタイジングパケットにではなくスキャンパケットに格納しました。

```C
init.srdata.p_manuf_specific_data = &manuf_buf;
```

## アドバタイジングパケット発信開始

```C:
void advertising_start(void)
{
    ret_code_t err_code;
    err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
    APP_ERROR_CHECK(err_code);
}
```

## アドバタイジングパケット発信停止

```C:
//advertising_stop
static void advertising_stop(void)
{
    ret_code_t err_code;
    err_code=sd_ble_gap_adv_stop(m_advertising.adv_handle);
    APP_ERROR_CHECK(err_code);
}
```

## アドバタイジングイベント割り込み処理
アドバタイジングイベントにおいて特に必須の処理はありませんが、`BLE_ADV_EVT_IDLE`イベントで不意にアドバタイジングパケット発信が停止した時に発信開始処理を入れると便利かもしれません。

```C
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
    switch (ble_adv_evt)
    {
        case BLE_ADV_EVT_FAST:
        {
            NRF_LOG_INFO("Fast advertising.");
        } break;

        case BLE_ADV_EVT_IDLE:
        {
            ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
            APP_ERROR_CHECK(err_code);
        } break;

        default:
            // No implementation needed.
            break;
    }
}
```


# 両機能共通：アドバタイジングパケット発信開始およびSCAN開始
内蔵FLASHが動作中でないことを確認した上で、アドバタイジングパケット発信開始とSCAN開始を実行します。
アプリケーションの仕様によっては別々に開始と停止を行います。

```C:
static void adv_scan_start(void)
{
    ret_code_t err_code;

    //check if there are no flash operations in progress
    if (!nrf_fstorage_is_busy(NULL))
    {
        // Start scanning for peripherals and initiate connection to devices which
        // advertise Heart Rate or Running speed and cadence UUIDs.
        scan_start();

        // Start advertising.
        err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
        APP_ERROR_CHECK(err_code);
    }
}
```


# Peripheral機能：Peripheralサービス
Peripheralサービスの作成方法は別途記事にする予定です。
以下は既に作成済みのPeripheralサービスの関数や定義を使用します。

## Peripheralサービス初期化処理

```C:
static void services_init(void)
{
    ret_code_t err_code;
    ble_orange_init_t orange_init;
    nrf_ble_qwr_init_t qwr_init = { 0 };

    // Initialize Queued Write Module.
    qwr_init.error_handler = nrf_qwr_error_handler;

    for (uint32_t i = 0; i < NRF_SDH_BLE_TOTAL_LINK_COUNT; i++)
    {
        err_code = nrf_ble_qwr_init(&m_qwr[i], &qwr_init);
        APP_ERROR_CHECK(err_code);
    }

    // Initialize the Orange Service.
    memset(&orange_init, 0, sizeof(orange_init));
    smartlock_init.orange_write_handler = orange_write_handler;

    err_code = ble_orange_init(&m_orange, &orange_init);
    APP_ERROR_CHECK(err_code);
}
```

# Central機能：Centralサービス
Centralサービスの作成方法は以下をご参照ください。

[BLEモジュールnRF52シリーズにおけるCentralサービスを実装する仕組み](https://qiita.com/Kosuke_Matsui/private/f0ae02aa1fdc5494c332)


以下は既に作成済みのCentralサービスの関数や定義を使用します。

## Centralサービス初期化処理

```C:
static void service_error_handler(uint32_t nrf_error)
{
    APP_ERROR_HANDLER(nrf_error);
}

static void orange_c_init(void)
{
    ret_code_t       err_code;
    ble_orange_c_init_t orange_c_init_obj;

    orange_c_init_obj.evt_handler   = orange_c_evt_handler;
    orange_c_init_obj.error_handler = service_error_handler;
    orange_c_init_obj.p_gatt_queue  = &m_ble_gatt_queue;

    err_code = ble_orange_c_init(&m_orange_c, &orange_c_init_obj);
    APP_ERROR_CHECK(err_code);
}
```

## Centralサービスの割り込み処理
BLE接続が確立するとイベントBLE_ORANGE_C_EVT_DISCOVERY_COMPLETEが発生します。
イベント発生時に`m_conn_handle_orange_c`に`p_orange_c_evt->conn_handle`を格納します。

他にはNotificationやIndication、readの受信イベントにはアプリケーションの仕様に基づいて処理を追加ください。

Peripheral側と正常にBLE接続できなくなるので`pm_conn_secure`は無効化しています。

```C:
static void orange_c_evt_handler(ble_orange_c_t * p_orange_c, ble_orange_c_evt_t * p_orange_c_evt)
{
    switch (p_orange_c_evt->evt_type)
    {
        case BLE_ORANGE_C_EVT_DISCOVERY_COMPLETE:
        {
            if (m_conn_handle_orange_c == BLE_CONN_HANDLE_INVALID)
            {
                ret_code_t err_code;

                m_conn_handle_orange_c = p_orange_c_evt->conn_handle;
                NRF_LOG_INFO("ORANGE discovered on conn_handle 0x%x", m_conn_handle_orange_c );

                filter_settings_change();

                err_code = ble_orange_c_handles_assign(p_orange_c,
                                                    m_conn_handle_orange_c ,
                                                    &p_orange_c_evt->params.peer_db);
                APP_ERROR_CHECK(err_code);
                // Initiate bonding.
                /*err_code = pm_conn_secure(m_conn_handle_orange_c , false);
                if (err_code != NRF_ERROR_BUSY)
                {
                    APP_ERROR_CHECK(err_code);
                }*/

                // Orange service discovered. Enable notification.
                err_code = ble_orange_c_orange_notification_enable(p_orange_c);
                APP_ERROR_CHECK(err_code);

                // Orange service discovered. Enable indication.
                err_code = ble_orange_c_orange_indication_enable(p_orange_c);
                APP_ERROR_CHECK(err_code);
            }
        } break; // BLE_ORANGE_C_EVT_DISCOVERY_COMPLETE

        case BLE_ORANGE_C_EVT_NOTIFICATION:
        {
        } break; // BLE_ORANGE_C_EVT_NOTIFICATION

        case BLE_ORANGE_C_EVT_INDICATION:
        {
        } break; // BLE_ORANGE_C_EVT_INDICATION

        case BLE_ORANGE_C_EVT_READ:
        {
        } break; // BLE_ORANGE_C_EVT_READ

        default:
            // No implementation needed.
            break;
    }
}
```

# BLE初期化処理

以上の設定を有効化するBLE初期化関数を作成しました。

```C:
void ble_init(void)
{
    ble_stack_init();
    scan_init();
    gap_params_init();
    gatt_init();
    conn_params_init();
    db_discovery_init();
    peer_manager_init();
    orange_c_init();
    services_init();
    advertising_init();
    data_len_set(DATA_LENGTH_MAX);

    adv_scan_start();
}
```

このBLE初期化関数をmain関数において実行します。

```C:main.c
int main(void)
{
    cpu_init();
    power_management_init();
    ble_init();
    system_timer_start();

    for (;;)
    {
        idle_state_handle();
    }
}
```

# 次にすること
次は実際にnRF52832の開発ボードに実装して動かしてみます。
サンプルコードをGitHubで公開し、それを元にして簡単に自分用のオリジナルアプリケーション作成できるようにします。
またアドバタイジング、スキャン、BLE接続の消費電力を測定して比較する予定です。

# 参照
- [BLEモジュールnRF52シリーズにおけるCentral機能とPeripheral機能の両方を実装する仕組み](https://qiita.com/Kosuke_Matsui/items/13da1b5df710b4b0a3ab)
- [BLEモジュールnRF52シリーズにおけるCentralサービスを実装する仕組み](https://qiita.com/Kosuke_Matsui/private/f0ae02aa1fdc5494c332)
- [誰でもすぐにBLE通信機器が作れるnRF52用サンプルプログラム](https://qiita.com/Kosuke_Matsui/items/999ad6d1463dbad914d3)