An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

Sigurd — Mon, 15 May 2023 09:00:26 GMT

[quote user="ahmed560"]I tested ble_app_gls example and it works good [/quote]

Good! (If it still does not work in your exmaple, then maybe check if SEC_PARAM_MIN_KEY_SIZE and SEC_PARAM_MAX_KEY_SIZE is set as per ble_app_gls example in your example as well)

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

ahmed560 — Wed, 10 May 2023 07:58:33 GMT

hello,

I tested ble_app_gls example and it works good

#define SEC_PARAM_BOND                  1                                           /**< Perform bonding. */
#define SEC_PARAM_MITM                  1                                           /**< Man In The Middle protection not required. */
#define SEC_PARAM_LESC                  0                                           /**< LE Secure Connections not enabled. */
#define SEC_PARAM_KEYPRESS              0                                           /**< Keypress notifications not enabled. */
#define SEC_PARAM_IO_CAPABILITIES       BLE_GAP_IO_CAPS_DISPLAY_ONLY  

static void pm_evt_handler(pm_evt_t const * p_evt)
{
    ret_code_t err_code;

    switch (p_evt->evt_id)
    {
        case PM_EVT_BONDED_PEER_CONNECTED:
        {   err_code = app_timer_start(m_sec_req_timer_id, SECURITY_REQUEST_DELAY, NULL);
            NRF_LOG_INFO("Connected to a previously bonded device.");
        } break;

        case PM_EVT_CONN_SEC_SUCCEEDED:
        {    IsConnectedFlag=1;
             IsConnected=1;
             pm_conn_sec_status_t conn_sec_status;

            // Check if the link is authenticated (meaning at least MITM).
            err_code = pm_conn_sec_status_get(p_evt->conn_handle, &conn_sec_status);
            if (conn_sec_status.mitm_protected)
            {
                NRF_LOG_INFO("Link secured. Role: %d. conn_handle: %d, Procedure: %d",
                             ble_conn_state_role(p_evt->conn_handle),
                             p_evt->conn_handle,
                             p_evt->params.conn_sec_succeeded.procedure);
            }
            else
            {
                // The peer did not use MITM, disconnect.
                NRF_LOG_INFO("Collector did not use MITM, disconnecting");
                err_code = pm_peer_id_get(c_conn_handle, &m_peer_to_be_deleted);
               
                err_code = sd_ble_gap_disconnect(c_conn_handle,
                                                 BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
             
            }
        } break;

        case PM_EVT_CONN_SEC_FAILED:
        {
            /* Often, when securing fails, it shouldn't be restarted, for security reasons.
             * Other times, it can be restarted directly.
             * Sometimes it can be restarted, but only after changing some Security Parameters.
             * Sometimes, it cannot be restarted until the link is disconnected and reconnected.
             * Sometimes it is impossible, to secure the link, or the peer device does not support it.
             * How to handle this error is highly application dependent. */
              c_conn_handle = BLE_CONN_HANDLE_INVALID;
        } break;

        case PM_EVT_CONN_SEC_CONFIG_REQ:
        {
            // Reject pairing request from an already bonded peer.
            pm_conn_sec_config_t conn_sec_config = {.allow_repairing = false};
            pm_conn_sec_config_reply(p_evt->conn_handle, &conn_sec_config);
        } break;

        case PM_EVT_STORAGE_FULL:
        {
            // Run garbage collection on the flash.
            err_code = fds_gc();
            if (err_code == FDS_ERR_BUSY || err_code == FDS_ERR_NO_SPACE_IN_QUEUES)
            {
                // Retry.
            }
            else
            {
                
            }
        } break;

        case PM_EVT_PEERS_DELETE_SUCCEEDED:
        {
            adv_scan_start();
        } break;

        case PM_EVT_LOCAL_DB_CACHE_APPLY_FAILED:
        {
            // The local database has likely changed, send service changed indications.
            pm_local_database_has_changed();
        } break;

        case PM_EVT_PEER_DATA_UPDATE_FAILED:
        {
            // Assert.
            
        } break;

        case PM_EVT_PEER_DELETE_FAILED:
        {
            // Assert.
           
        } break;

        case PM_EVT_PEERS_DELETE_FAILED:
        {
            // Assert.
           
        } break;

        case PM_EVT_ERROR_UNEXPECTED:
        {
            // Assert.
            
        } break;

        case PM_EVT_CONN_SEC_START:
        case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED:
        case PM_EVT_PEER_DELETE_SUCCEEDED:
        case PM_EVT_LOCAL_DB_CACHE_APPLIED:
        case PM_EVT_SERVICE_CHANGED_IND_SENT:
        case PM_EVT_SERVICE_CHANGED_IND_CONFIRMED:
        default:
            break;
    }
}

static void sec_req_timeout_handler(void * p_context)
{
    ret_code_t err_code;

    if (c_conn_handle != BLE_CONN_HANDLE_INVALID)
    {
        // Initiate bonding.
        NRF_LOG_DEBUG("Start encryption");
        err_code = pm_conn_secure(c_conn_handle, false);
       
    }
}

/**@brief Function for handling BLE events.
 *
 * @param[in]   p_ble_evt   Bluetooth stack event.
 * @param[in]   p_context   Unused.
 */
static void on_ble_peripheral_evt(ble_evt_t const * p_ble_evt)
{
    uint32_t err_code;
    switch (p_ble_evt->header.evt_id)
    {
     case BLE_GAP_EVT_DISCONNECTED:

          {  NRF_LOG_INFO("Disconnected");
            IsConnectedFlag=0; //FOR UART SEND
            IsConnected=0;
            // LED indication will be changed when advertising starts.
            c_conn_handle = BLE_CONN_HANDLE_INVALID;
             if (m_peer_to_be_deleted != PM_PEER_ID_INVALID)
            {
                err_code = pm_peer_delete(m_peer_to_be_deleted);
               
                NRF_LOG_DEBUG("Collector's bond deleted");
                m_peer_to_be_deleted = PM_PEER_ID_INVALID;
            }
           } break;
        case BLE_GAP_EVT_CONNECTED:
            NRF_LOG_INFO("Connected");
            m_peer_to_be_deleted = PM_PEER_ID_INVALID;
            IsConnectedFlag=1; //FOR UART SEND
            IsConnected=1;
            //err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
           // APP_ERROR_CHECK(err_code);
            c_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
            err_code = app_timer_start(m_sec_req_timer_id, SECURITY_REQUEST_DELAY, NULL);
            break;
        case BLE_GATTC_EVT_TIMEOUT:
            // Disconnect on GATT Client timeout event.
            err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
                                             BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
           
            break;

        case BLE_GATTS_EVT_TIMEOUT:
            // Disconnect on GATT Server timeout event.
            err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
                                             BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
           
            break;

        case BLE_EVT_USER_MEM_REQUEST:
            err_code = sd_ble_user_mem_reply(p_ble_evt->evt.gattc_evt.conn_handle, NULL);
           
            break;

        case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
        {
            ble_gatts_evt_rw_authorize_request_t  req;
            ble_gatts_rw_authorize_reply_params_t auth_reply;

            req = p_ble_evt->evt.gatts_evt.params.authorize_request;

            if (req.type != BLE_GATTS_AUTHORIZE_TYPE_INVALID)
            {
                if ((req.request.write.op == BLE_GATTS_OP_PREP_WRITE_REQ)     ||
                    (req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) ||
                    (req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL))
                {
                    if (req.type == BLE_GATTS_AUTHORIZE_TYPE_WRITE)
                    {
                        auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE;
                    }
                    else
                    {
                        auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_READ;
                    }
                    auth_reply.params.write.gatt_status = APP_FEATURE_NOT_SUPPORTED;
                    err_code = sd_ble_gatts_rw_authorize_reply(p_ble_evt->evt.gatts_evt.conn_handle,
                                                               &auth_reply);
                   
                }
            }
        } break; // BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST
       case BLE_GAP_EVT_PASSKEY_DISPLAY:
        {
            char passkey[PASSKEY_LENGTH + 1] = "12345" ;
            memcpy(passkey, p_ble_evt->evt.gap_evt.params.passkey_display.passkey, PASSKEY_LENGTH);
            passkey[PASSKEY_LENGTH] = 0;
            err_code = app_timer_stop(m_sec_req_timer_id);
            // Don't send delayed Security Request if security procedure is already in progress.            
        } break;
        default:
            // No implementation needed.
            break;
    }
}

int main(void)
{
    uint32_t err_code;
    bool     erase_bonds;
    tret     testret;
    // Initialize.
    err_code = app_timer_init();
    err_code = app_timer_create(&m_sec_req_timer_id,
                                APP_TIMER_MODE_SINGLE_SHOT,
                                sec_req_timeout_handler);

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

Sigurd — Tue, 09 May 2023 14:13:29 GMT

Ok, what about 1) and 3)?

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

ahmed560 — Tue, 09 May 2023 09:13:56 GMT

Hi,

I compared both main codes, I think that I made the same implementation

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

Sigurd — Tue, 09 May 2023 09:03:02 GMT

Hi,

1) It works as expected for you with the ble_app_gls example, correct?

2) Can you compare your implementation with ble_app_gls example, maybe you missed something?

3) Could you post your main.c code?

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

ahmed560 — Mon, 08 May 2023 15:24:09 GMT

yes I remove the bond/pairing from both devices

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

Sigurd — Mon, 08 May 2023 15:08:33 GMT

Did you remove the bond/pairing from both devices? If you are already bonded, then you will not get this pop-up.

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

ahmed560 — Mon, 08 May 2023 13:44:20 GMT

the pop-up is where you can write a password in the nRF connect

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

Sigurd — Mon, 08 May 2023 13:30:46 GMT

[quote user="ahmed560"]I want to show the pop-up but it doesn't work[/quote]

What pop-up?

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

ahmed560 — Mon, 08 May 2023 10:54:04 GMT

I try it one more time but it's not done I want to show the pop-up but it doesn't work

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

ahmed560 — Mon, 08 May 2023 10:35:53 GMT

thank you, I will try it now

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

Sigurd — Mon, 08 May 2023 10:32:25 GMT

Take a look at how it's used in e.g. the ble_app_gls example.

Some snippets from that example:

/**@brief Function for handling the Security Request timer timeout.
 *
 * @details This function will be called each time the Security Request timer expires.
 *
 * @param[in] p_context  Pointer used for passing some arbitrary information (context) from the
 *                       app_start_timer() call to the timeout handler.
 */
static void sec_req_timeout_handler(void * p_context)
{
    ret_code_t err_code;

    if (m_conn_handle != BLE_CONN_HANDLE_INVALID)
    {
        // Initiate bonding.
        NRF_LOG_DEBUG("Start encryption");
        err_code = pm_conn_secure(m_conn_handle, false);
        if (err_code != NRF_ERROR_INVALID_STATE)
        {
            APP_ERROR_CHECK(err_code);
        }
    }
}

static void pm_evt_handler(pm_evt_t const * p_evt)
{
    ret_code_t err_code;

    switch (p_evt->evt_id)
    {
        case PM_EVT_BONDED_PEER_CONNECTED:
        {
            NRF_LOG_INFO("Connected to a previously bonded device.");
            // Start Security Request timer.
            err_code = app_timer_start(m_sec_req_timer_id, SECURITY_REQUEST_DELAY, NULL);
            APP_ERROR_CHECK(err_code);
        } break;

/**@brief Function for the Timer initialization.
 *
 * @details Initializes the timer module. This creates and starts application timers.
 */
static void timers_init(void)
{
    ret_code_t err_code;

    // Initialize timer module.
    err_code = app_timer_init();
    APP_ERROR_CHECK(err_code);

    // 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);

    // Create Security Request timer.
    err_code = app_timer_create(&m_sec_req_timer_id,
                                APP_TIMER_MODE_SINGLE_SHOT,
                                sec_req_timeout_handler);
    APP_ERROR_CHECK(err_code);
}

static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
    ret_code_t err_code;

    switch (p_ble_evt->header.evt_id)
    {
        case BLE_GAP_EVT_DISCONNECTED:
        {
            NRF_LOG_INFO("Disconnected");
            m_conn_handle = BLE_CONN_HANDLE_INVALID;
            // Check if the last connected peer had not used MITM, if so, delete its bond information.
            if (m_peer_to_be_deleted != PM_PEER_ID_INVALID)
            {
                err_code = pm_peer_delete(m_peer_to_be_deleted);
                APP_ERROR_CHECK(err_code);
                NRF_LOG_DEBUG("Collector's bond deleted");
                m_peer_to_be_deleted = PM_PEER_ID_INVALID;
            }
        } break;

        case BLE_GAP_EVT_CONNECTED:
        {
            NRF_LOG_INFO("Connected");
            m_peer_to_be_deleted = PM_PEER_ID_INVALID;
            err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
            APP_ERROR_CHECK(err_code);
            m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
            // Start Security Request timer.
            err_code = app_timer_start(m_sec_req_timer_id, SECURITY_REQUEST_DELAY, NULL);
            APP_ERROR_CHECK(err_code);
        } break;

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

ahmed560 — Mon, 08 May 2023 10:12:53 GMT

I try it but it doesn't work

RE: An alternative API from sdkv16.0.0 softdevice V7 to sdkv14.2.0 softdevice V5

Sigurd — Mon, 08 May 2023 09:22:22 GMT

Hi,

Use pm_conn_secure()

https://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v14.2.0/lib_pm_functionality.html