jh.chun/VesiScan-Basic_imu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
jhchun
2026-04-24 10:52:47 +09:00
commit 1707dc6349
1423 changed files with 1161776 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/ble/ble_services/ble_dfu/ble_dfu.c
+323
View File
@@ -0,0 +1,323 @@
/**
* Copyright (c) 2017 - 2021, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/* Attention!
* To maintain compliance with Nordic Semiconductor ASA's Bluetooth profile
* qualification listings, this section of source code must not be modified.
*/
#include "ble_dfu.h"
#include <string.h>
#include "ble_hci.h"
#include "sdk_macros.h"
#include "ble_srv_common.h"
#include "nrf_nvic.h"
#include "nrf_sdm.h"
#include "nrf_soc.h"
#include "nrf_log.h"
#include "nrf_dfu_ble_svci_bond_sharing.h"
#include "nrf_bootloader_info.h"
#include "nrf_svci_async_function.h"
#include "nrf_pwr_mgmt.h"
#include "peer_manager.h"
#include "gatts_cache_manager.h"
#include "peer_id.h"
#define MAX_CTRL_POINT_RESP_PARAM_LEN 3 /**< Max length of the responses. */
#define BLE_DFU_SERVICE_UUID 0xFE59 /**< The 16-bit UUID of the Secure DFU Service. */
static ble_dfu_buttonless_t m_dfu; /**< Structure holding information about the Buttonless Secure DFU Service. */
NRF_SDH_BLE_OBSERVER(m_dfus_obs, BLE_DFU_BLE_OBSERVER_PRIO, ble_dfu_buttonless_on_ble_evt, &m_dfu);
/**@brief Function that is called if no event handler is provided.
*/
static void dummy_evt_handler(ble_dfu_buttonless_evt_type_t evt)
{
NRF_LOG_DEBUG("Dummy event handler received event 0x%x", evt);
}
/**@brief Function for handling write events to the Buttonless Secure DFU Service Service Control Point characteristic.
*
* @param[in] p_evt_write Write event received from the BLE stack.
*/
static void on_ctrlpt_write(ble_gatts_evt_write_t const * p_evt_write)
{
uint32_t err_code;
ble_gatts_rw_authorize_reply_params_t write_authorize_reply;
memset(&write_authorize_reply, 0, sizeof(write_authorize_reply));
write_authorize_reply.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE;
uint8_t cccd_val[2];
ble_gatts_value_t value = {.p_value = cccd_val, .len = 2, .offset = 0};
err_code = sd_ble_gatts_value_get(m_dfu.conn_handle, m_dfu.control_point_char.cccd_handle, &value);
if (err_code == NRF_SUCCESS && ble_srv_is_indication_enabled(cccd_val))
{
write_authorize_reply.params.write.update = 1;
write_authorize_reply.params.write.gatt_status = BLE_GATT_STATUS_SUCCESS;
}
else
{
write_authorize_reply.params.write.gatt_status = BLE_GATT_STATUS_ATTERR_CPS_CCCD_CONFIG_ERROR;
}
// Authorize the write request
do {
err_code = sd_ble_gatts_rw_authorize_reply(m_dfu.conn_handle, &write_authorize_reply);
} while (err_code == NRF_ERROR_BUSY);
if (write_authorize_reply.params.write.gatt_status != BLE_GATT_STATUS_SUCCESS)
{
return;
}
// Forward the write event to the Buttonless DFU module.
ble_dfu_buttonless_on_ctrl_pt_write(p_evt_write);
}
/**@brief Write authorization request event handler.
*
* @details The write authorization request event handler is called when writing to the control point.
*
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_rw_authorize_req(ble_evt_t const * p_ble_evt)
{
if (p_ble_evt->evt.gatts_evt.conn_handle != m_dfu.conn_handle)
{
return;
}
const ble_gatts_evt_rw_authorize_request_t * p_auth_req =
&p_ble_evt->evt.gatts_evt.params.authorize_request;
if (
(p_auth_req->type == BLE_GATTS_AUTHORIZE_TYPE_WRITE) &&
(p_auth_req->request.write.handle == m_dfu.control_point_char.value_handle) &&
(p_auth_req->request.write.op != BLE_GATTS_OP_PREP_WRITE_REQ) &&
(p_auth_req->request.write.op != BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) &&
(p_auth_req->request.write.op != BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL)
)
{
on_ctrlpt_write(&p_auth_req->request.write);
}
}
/**@brief Connect event handler.
*
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_connect(ble_evt_t const * p_ble_evt)
{
m_dfu.conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
}
/**@brief Disconnect event handler.
*
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_disconnect(ble_evt_t const * p_ble_evt)
{
if (m_dfu.conn_handle != p_ble_evt->evt.gap_evt.conn_handle)
{
return;
}
m_dfu.conn_handle = BLE_CONN_HANDLE_INVALID;
}
/**@brief Function for handling the HVC events.
*
* @details Handles HVC events from the BLE stack.
*
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_hvc(ble_evt_t const * p_ble_evt)
{
uint32_t err_code;
ble_gatts_evt_hvc_t const * p_hvc = &p_ble_evt->evt.gatts_evt.params.hvc;
if (p_hvc->handle == m_dfu.control_point_char.value_handle)
{
// Enter bootloader if we were waiting for reset after hvc indication confimation.
if (m_dfu.is_waiting_for_reset)
{
err_code = ble_dfu_buttonless_bootloader_start_prepare();
if (err_code != NRF_SUCCESS)
{
m_dfu.evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
}
}
}
void ble_dfu_buttonless_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context)
{
VERIFY_PARAM_NOT_NULL_VOID(p_ble_evt);
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_ble_evt);
break;
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
on_rw_authorize_req(p_ble_evt);
break;
case BLE_GATTS_EVT_HVC:
on_hvc(p_ble_evt);
break;
default:
// no implementation
break;
}
}
uint32_t ble_dfu_buttonless_resp_send(ble_dfu_buttonless_op_code_t op_code, ble_dfu_buttonless_rsp_code_t rsp_code)
{
// Send indication
uint32_t err_code;
const uint16_t len = MAX_CTRL_POINT_RESP_PARAM_LEN;
uint16_t hvx_len;
uint8_t hvx_data[MAX_CTRL_POINT_RESP_PARAM_LEN];
ble_gatts_hvx_params_t hvx_params;
memset(&hvx_params, 0, sizeof(hvx_params));
hvx_len = len;
hvx_data[0] = DFU_OP_RESPONSE_CODE;
hvx_data[1] = (uint8_t)op_code;
hvx_data[2] = (uint8_t)rsp_code;
hvx_params.handle = m_dfu.control_point_char.value_handle;
hvx_params.type = BLE_GATT_HVX_INDICATION;
hvx_params.offset = 0;
hvx_params.p_len = &hvx_len;
hvx_params.p_data = hvx_data;
err_code = sd_ble_gatts_hvx(m_dfu.conn_handle, &hvx_params);
if ((err_code == NRF_SUCCESS) && (hvx_len != len))
{
err_code = NRF_ERROR_DATA_SIZE;
}
return err_code;
}
uint32_t ble_dfu_buttonless_bootloader_start_finalize(void)
{
uint32_t err_code;
NRF_LOG_DEBUG("In ble_dfu_buttonless_bootloader_start_finalize\r\n");
err_code = sd_power_gpregret_clr(0, 0xffffffff);
VERIFY_SUCCESS(err_code);
err_code = sd_power_gpregret_set(0, BOOTLOADER_DFU_START);
VERIFY_SUCCESS(err_code);
// Indicate that the Secure DFU bootloader will be entered
m_dfu.evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER);
// Signal that DFU mode is to be enter to the power management module
nrf_pwr_mgmt_shutdown(NRF_PWR_MGMT_SHUTDOWN_GOTO_DFU);
return NRF_SUCCESS;
}
uint32_t ble_dfu_buttonless_init(const ble_dfu_buttonless_init_t * p_dfu_init)
{
uint32_t err_code;
ble_uuid_t service_uuid;
ble_uuid128_t nordic_base_uuid = BLE_NORDIC_VENDOR_BASE_UUID;
VERIFY_PARAM_NOT_NULL(p_dfu_init);
// Initialize the service structure.
m_dfu.conn_handle = BLE_CONN_HANDLE_INVALID;
m_dfu.evt_handler = p_dfu_init->evt_handler;
m_dfu.is_waiting_for_reset = false;
if (m_dfu.evt_handler == NULL)
{
m_dfu.evt_handler = dummy_evt_handler;
}
err_code = ble_dfu_buttonless_backend_init(&m_dfu);
VERIFY_SUCCESS(err_code);
BLE_UUID_BLE_ASSIGN(service_uuid, BLE_DFU_SERVICE_UUID);
// Add the DFU service declaration.
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
&service_uuid,
&(m_dfu.service_handle));
VERIFY_SUCCESS(err_code);
// Add vendor specific base UUID to use with the Buttonless DFU characteristic.
err_code = sd_ble_uuid_vs_add(&nordic_base_uuid, &m_dfu.uuid_type);
VERIFY_SUCCESS(err_code);
// Add the Buttonless DFU Characteristic (with bonds/without bonds).
err_code = ble_dfu_buttonless_char_add(&m_dfu);
VERIFY_SUCCESS(err_code);
return NRF_SUCCESS;
}
components/ble/ble_services/ble_dfu/ble_dfu.h
+249
View File
@@ -0,0 +1,249 @@
/**
* Copyright (c) 2012 - 2021, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/** @file
*
* @defgroup ble_dfu Buttonless DFU Service
* @{
* @ingroup ble_sdk_srv
* @brief Buttonless DFU Service module.
*
* @details This module implements a proprietary Buttonless Secure DFU Service. The service can
* be configured to support bonds or not. The bond support configuration must correspond to the
* requirement of Secure DFU bootloader.
*
* @note Attention!
* To maintain compliance with Nordic Semiconductor ASA Bluetooth profile
* qualification listings, this section of source code must not be modified.
*/
#ifndef BLE_DFU_H__
#define BLE_DFU_H__
#include <stdint.h>
#include "ble_srv_common.h"
#include "nrf_sdh_ble.h"
#ifdef __cplusplus
extern "C" {
#endif
/**@brief SoC observer priority.
* @details Priority of this module's SoC event handler.
*/
#define BLE_DFU_SOC_OBSERVER_PRIO 1
#define BLE_DFU_BUTTONLESS_CHAR_UUID (0x0003) /**< Value combined with vendor-specific base to create Unbonded Buttonless characteristic UUID. */
#define BLE_DFU_BUTTONLESS_BONDED_CHAR_UUID (0x0004) /**< Value combined with vendor-specific base to create Bonded Buttonless characteristic UUID. */
/**@brief Nordic vendor-specific base UUID.
*/
#define BLE_NORDIC_VENDOR_BASE_UUID \
{{ \
0x50, 0xEA, 0xDA, 0x30, 0x88, 0x83, 0xB8, 0x9F, \
0x60, 0x4F, 0x15, 0xF3, 0x00, 0x00, 0xC9, 0x8E \
}}
/**@brief Nordic Buttonless DFU Service event type .
*/
typedef enum
{
BLE_DFU_EVT_BOOTLOADER_ENTER_PREPARE, /**< Event indicating that the device is preparing to enter bootloader.*/
BLE_DFU_EVT_BOOTLOADER_ENTER, /**< Event indicating that the bootloader will be entered after return of this event.*/
BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED, /**< Failure to enter bootloader mode.*/
BLE_DFU_EVT_RESPONSE_SEND_ERROR, /**< Failure to send response.*/
} ble_dfu_buttonless_evt_type_t;
/**@brief Nordic Buttonless DFU Service event handler type.
*/
typedef void (*ble_dfu_buttonless_evt_handler_t) (ble_dfu_buttonless_evt_type_t p_evt);
/**@brief Enumeration of Bootloader DFU response codes.
*/
typedef enum
{
DFU_RSP_INVALID = 0x00, /**< Invalid op code. */
DFU_RSP_SUCCESS = 0x01, /**< Success. */
DFU_RSP_OP_CODE_NOT_SUPPORTED = 0x02, /**< Op code not supported. */
DFU_RSP_OPERATION_FAILED = 0x04, /**< Operation failed. */
DFU_RSP_ADV_NAME_INVALID = 0x05, /**< Requested advertisement name is too short or too long. */
DFU_RSP_BUSY = 0x06, /**< Ongoing async operation. */
DFU_RSP_NOT_BONDED = 0x07, /**< Buttonless unavailable due to device not bonded. */
} ble_dfu_buttonless_rsp_code_t;
/**@brief Enumeration of Bootloader DFU Operation codes.
*/
typedef enum
{
DFU_OP_RESERVED = 0x00, /**< Reserved for future use. */
DFU_OP_ENTER_BOOTLOADER = 0x01, /**< Enter bootloader. */
DFU_OP_SET_ADV_NAME = 0x02, /**< Set advertisement name to use in DFU mode. */
DFU_OP_RESPONSE_CODE = 0x20 /**< Response code. */
} ble_dfu_buttonless_op_code_t;
/**@brief Type holding memory used by Secure DFU Buttonless Service.
*/
typedef struct
{
uint8_t uuid_type; /**< UUID type for DFU UUID. */
uint16_t service_handle; /**< Service Handle of DFU (as provided by the SoftDevice). */
uint16_t conn_handle; /**< Connection handle for the current peer. */
ble_gatts_char_handles_t control_point_char; /**< Handles related to the DFU Control Point characteristic. */
uint32_t peers_count; /**< Counter to see how many persistently stored peers must be updated for Service Changed indication. This value will be counted down when comparing write requests. */
ble_dfu_buttonless_evt_handler_t evt_handler; /**< Event handler that is called upon Buttonless DFU events. See @ref ble_dfu_buttonless_evt_type_t. */
bool is_waiting_for_reset; /**< Flag indicating that the device will enter bootloader. */
bool is_waiting_for_svci; /**< Flag indicating that the device is waiting for async SVCI operation */
} ble_dfu_buttonless_t;
/**@brief Type used to initialize the Secure DFU Buttonless Service.
*/
typedef struct
{
ble_dfu_buttonless_evt_handler_t evt_handler; /**< Bootloader event handler. */
} ble_dfu_buttonless_init_t;
/**@brief Function for initializing the Device Firmware Update module.
*
* @param[in] p_dfu_init Structure containing the values of characteristics needed by the
* service.
* @retval NRF_SUCCESS on successful initialization of the service.
*/
uint32_t ble_dfu_buttonless_init(const ble_dfu_buttonless_init_t * p_dfu_init);
/**@brief Function for initializing the async SVCI interface.
*
* @warning Ensure that no interrupts are triggered when calling this functions as
* interrupts and exceptions are forwarded to the bootloader for the period
* of the call and may be lost.
*
* @details This configures the async interface for calling to the
* bootloader through SVCI interface.
*
* @retval NRF_SUCCESS on success, otherwise an error code.
*/
uint32_t ble_dfu_buttonless_async_svci_init(void);
/**@brief Function to initialize the backend Secure DFU Buttonless service which is either
* supports bonds or not.
*
* @note Do not call this function directly. It is called internally by @ref ble_dfu_buttonless_init.
*
* @param[in] p_dfu Nordic DFU Service structure.
*
* @return NRF_SUCCESS On sucessfully initializing, otherwise an error code.
*/
uint32_t ble_dfu_buttonless_backend_init(ble_dfu_buttonless_t * p_dfu);
/**@brief Function for adding the buttonless characteristic.
*
* @note This will be implemented differently on bonded/unbonded Buttonless DFU service.
*
* @param[in] p_dfu Nordic DFU Service structure.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
uint32_t ble_dfu_buttonless_char_add(ble_dfu_buttonless_t * p_dfu);
/**@brief Function for sending a response back to the client.
*
* @param[in] op_code Operation code to send the response for.
* @param[in] rsp_code Response code for the operation.
*
* @retval NRF_SUCCESS on success, otherwise an error code.
*/
uint32_t ble_dfu_buttonless_resp_send(ble_dfu_buttonless_op_code_t op_code, ble_dfu_buttonless_rsp_code_t rsp_code);
/**@brief Function for handling the application's BLE stack events.
*
* @details Handles all events from the BLE stack of interest to the DFU buttonless service.
*
* @param[in] p_ble_evt Event received from the BLE stack.
* @param[in] p_context BLE context structure.
*/
void ble_dfu_buttonless_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context);
/**@brief Function for handling control point write requests.
*
* @details Handles write requests to the control point in
* DFU with bonds or without bonds.
*
* @param[in] p_evt_write GATTS write event.
*/
void ble_dfu_buttonless_on_ctrl_pt_write(ble_gatts_evt_write_t const * p_evt_write);
/**@brief Function for preparing to enter the bootloader.
*
* @warning This function is called directly. (It is called internally).
*
* @retval Any error code from calling @ref sd_ble_gap_disconnect.
*/
uint32_t ble_dfu_buttonless_bootloader_start_prepare(void);
/**@brief Function for finalizing entering the bootloader.
*
* @warning This function is not to be called. (It is called internally).
*
* @retval NRF_SUCCESS Finalize was started correctly.
*/
uint32_t ble_dfu_buttonless_bootloader_start_finalize(void);
#ifdef __cplusplus
}
#endif
#endif // BLE_DIS_H__
/** @} */
components/ble/ble_services/ble_dfu/ble_dfu_bonded.c
+367
View File
@@ -0,0 +1,367 @@
/**
* Copyright (c) 2017 - 2021, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "nrf_dfu_ble_svci_bond_sharing.h"
#include "nordic_common.h"
#include "nrf_error.h"
#include "ble_dfu.h"
#include "nrf_log.h"
#include "peer_manager.h"
#include "gatts_cache_manager.h"
#include "peer_id.h"
#include "nrf_sdh_soc.h"
#include "nrf_strerror.h"
#if (NRF_DFU_BLE_BUTTONLESS_SUPPORTS_BONDS)
void ble_dfu_buttonless_on_sys_evt(uint32_t, void * );
uint32_t nrf_dfu_svci_vector_table_set(void);
uint32_t nrf_dfu_svci_vector_table_unset(void);
/**@brief Define function for async interface to set peer data. */
NRF_SVCI_ASYNC_FUNC_DEFINE(NRF_DFU_SVCI_SET_PEER_DATA, nrf_dfu_set_peer_data, nrf_dfu_peer_data_t);
// Register SoC observer for the Buttonless Secure DFU service
NRF_SDH_SOC_OBSERVER(m_dfu_buttonless_soc_obs, BLE_DFU_SOC_OBSERVER_PRIO, ble_dfu_buttonless_on_sys_evt, NULL);
ble_dfu_buttonless_t * mp_dfu;
static nrf_dfu_peer_data_t m_peer_data;
/**@brief Function for handling Peer Manager events.
*
* @param[in] p_evt Peer Manager event.
*/
static void pm_evt_handler(pm_evt_t const * p_evt)
{
uint32_t ret;
if (mp_dfu == NULL)
{
return;
}
// Only handle this when we are waiting to reset into DFU mode
if (!mp_dfu->is_waiting_for_reset)
{
return;
}
switch(p_evt->evt_id)
{
case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED:
if (p_evt->params.peer_data_update_succeeded.data_id == PM_PEER_DATA_ID_SERVICE_CHANGED_PENDING)
{
mp_dfu->peers_count--;
NRF_LOG_DEBUG("Updating Service Changed indication for peers, %d left", mp_dfu->peers_count);
if (mp_dfu->peers_count == 0)
{
NRF_LOG_DEBUG("Finished updating Service Changed indication for peers");
// We have updated Service Changed Indication for all devices.
ret = ble_dfu_buttonless_bootloader_start_finalize();
if (ret != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
}
}
break;
case PM_EVT_PEER_DATA_UPDATE_FAILED:
// Failure to update data. Service Changed cannot be sent but DFU mode is still possible
ret = ble_dfu_buttonless_bootloader_start_finalize();
if (ret != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
break;
default:
break;
}
}
static uint32_t retrieve_peer_data(void)
{
ret_code_t ret;
pm_peer_data_bonding_t bonding_data = {0};
pm_peer_id_t peer_id;
ret = pm_peer_id_get(mp_dfu->conn_handle, &peer_id);
VERIFY_SUCCESS(ret);
if (peer_id == PM_PEER_ID_INVALID)
{
return NRF_ERROR_FORBIDDEN;
}
ret = pm_peer_data_bonding_load(peer_id, &bonding_data);
VERIFY_SUCCESS(ret);
memcpy(&m_peer_data.ble_id, &bonding_data.peer_ble_id, sizeof(ble_gap_id_key_t));
memcpy(&m_peer_data.enc_key, &bonding_data.own_ltk, sizeof(ble_gap_enc_key_t));
uint16_t len = SYSTEM_SERVICE_ATT_SIZE;
ret = sd_ble_gatts_sys_attr_get(mp_dfu->conn_handle,
m_peer_data.sys_serv_attr,
&len,
BLE_GATTS_SYS_ATTR_FLAG_SYS_SRVCS);
NRF_LOG_DEBUG("system attribute table len: %d", len);
return ret;
}
/**@brief Function for entering the bootloader.
*
* @details This starts forwarding peer data to the Secure DFU bootloader.
*/
static uint32_t enter_bootloader(void)
{
uint32_t ret;
NRF_LOG_INFO("Writing peer data to the bootloader...");
if (mp_dfu->is_waiting_for_svci)
{
return ble_dfu_buttonless_resp_send(DFU_OP_ENTER_BOOTLOADER, DFU_RSP_BUSY);
}
// If retrieve_peer_data returns NRF_ERROR_FORBIDDEN, then the device was not bonded.
ret = retrieve_peer_data();
VERIFY_SUCCESS(ret);
ret = nrf_dfu_set_peer_data(&m_peer_data);
if (ret == NRF_SUCCESS)
{
// The request was accepted. Waiting for sys events to progress.
mp_dfu->is_waiting_for_svci = true;
}
else if (ret == NRF_ERROR_FORBIDDEN)
{
NRF_LOG_ERROR("The bootloader has write protected its settings page. This prohibits setting the peer data. "\
"The bootloader must be compiled with NRF_BL_SETTINGS_PAGE_PROTECT=0 to allow setting the peer data.");
}
return ret;
}
uint32_t ble_dfu_buttonless_backend_init(ble_dfu_buttonless_t * p_dfu)
{
VERIFY_PARAM_NOT_NULL(p_dfu);
// Set the memory used by the backend.
mp_dfu = p_dfu;
// Initialize the Peer manager handler.
return pm_register(pm_evt_handler);
}
uint32_t ble_dfu_buttonless_async_svci_init(void)
{
uint32_t ret;
// Set the vector table base address to the bootloader.
ret = nrf_dfu_svci_vector_table_set();
NRF_LOG_DEBUG("nrf_dfu_svci_vector_table_set() -> %s",
(ret == NRF_SUCCESS) ? "success" : nrf_strerror_get(ret));
VERIFY_SUCCESS(ret);
// Initialize the asynchronous SuperVisor interface to set peer data in Secure DFU bootloader.
ret = nrf_dfu_set_peer_data_init();
NRF_LOG_DEBUG("nrf_dfu_set_peer_data_init() -> %s",
(ret == NRF_SUCCESS) ? "success" : nrf_strerror_get(ret));
VERIFY_SUCCESS(ret);
// Set the vector table base address back to main application.
ret = nrf_dfu_svci_vector_table_unset();
NRF_LOG_DEBUG("nrf_dfu_svci_vector_table_unset() -> %s",
(ret == NRF_SUCCESS) ? "success" : nrf_strerror_get(ret));
return ret;
}
void ble_dfu_buttonless_on_sys_evt(uint32_t sys_evt, void * p_context)
{
uint32_t ret;
if (!nrf_dfu_set_peer_data_is_initialized())
{
return;
}
ret = nrf_dfu_set_peer_data_on_sys_evt(sys_evt);
if (ret == NRF_ERROR_INVALID_STATE)
{
// The system event is not from an operation started by buttonless DFU.
// No action is taken, and nothing is reported.
}
else if (ret == NRF_SUCCESS)
{
// Peer data was successfully forwarded to the Secure DFU bootloader.
// Set the flag indicating that we are waiting for indication response
// to activate the reset.
mp_dfu->is_waiting_for_reset = true;
mp_dfu->is_waiting_for_svci = false;
// Report back the positive response
ret = ble_dfu_buttonless_resp_send(DFU_OP_ENTER_BOOTLOADER, DFU_RSP_SUCCESS);
if (ret != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
mp_dfu->is_waiting_for_reset = false;
}
}
else
{
// Failed to set peer data. Report this.
mp_dfu->is_waiting_for_reset = false;
mp_dfu->is_waiting_for_svci = false;
ret = ble_dfu_buttonless_resp_send(DFU_OP_ENTER_BOOTLOADER, DFU_RSP_BUSY);
// Report the failure to send the response to the client
if (ret != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
}
// Report the failure to enter DFU mode
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
}
uint32_t ble_dfu_buttonless_char_add(ble_dfu_buttonless_t * p_dfu)
{
ble_add_char_params_t add_char_params;
memset(&add_char_params, 0, sizeof(add_char_params));
add_char_params.uuid = BLE_DFU_BUTTONLESS_BONDED_CHAR_UUID;
add_char_params.uuid_type = p_dfu->uuid_type;
add_char_params.char_props.indicate = 1;
add_char_params.char_props.write = 1;
add_char_params.is_defered_write = true;
add_char_params.is_var_len = true;
add_char_params.max_len = BLE_GATT_ATT_MTU_DEFAULT;
add_char_params.cccd_write_access = SEC_JUST_WORKS;
add_char_params.write_access = SEC_JUST_WORKS;
add_char_params.read_access = SEC_OPEN;
return characteristic_add(p_dfu->service_handle, &add_char_params, &p_dfu->control_point_char);
}
void ble_dfu_buttonless_on_ctrl_pt_write(ble_gatts_evt_write_t const * p_evt_write)
{
uint32_t ret;
ble_dfu_buttonless_rsp_code_t rsp_code = DFU_RSP_OPERATION_FAILED;
// Start executing the control point write action
switch (p_evt_write->data[0])
{
case DFU_OP_ENTER_BOOTLOADER:
ret = enter_bootloader();
if (ret == NRF_SUCCESS)
{
rsp_code = DFU_RSP_SUCCESS;
}
else if (ret == NRF_ERROR_BUSY)
{
rsp_code = DFU_RSP_BUSY;
}
else if (ret == NRF_ERROR_FORBIDDEN)
{
rsp_code = DFU_RSP_NOT_BONDED;
}
break;
default:
rsp_code = DFU_RSP_OP_CODE_NOT_SUPPORTED;
break;
}
// Report back in case of error
if (rsp_code != DFU_RSP_SUCCESS)
{
ret = ble_dfu_buttonless_resp_send((ble_dfu_buttonless_op_code_t)p_evt_write->data[0],
rsp_code);
if (ret != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
}
// Report the error to the main application
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
}
uint32_t ble_dfu_buttonless_bootloader_start_prepare(void)
{
NRF_LOG_DEBUG("In ble_dfu_buttonless_bootloader_start_prepare");
// Indicate to main app that DFU mode is starting.
// This event can be used to let the device take down any connection to
// bonded devices.
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_PREPARE);
// Store the number of peers for which Peer Manager is expected to successfully write events.
mp_dfu->peers_count = peer_id_n_ids();
// Set local database changed to get Service Changed indication for all bonded peers
// on next bootup (either because of a successful or aborted DFU).
gscm_local_database_has_changed();
return NRF_SUCCESS;
}
#endif // NRF_DFU_BLE_BUTTONLESS_SUPPORTS_BONDS
components/ble/ble_services/ble_dfu/ble_dfu_unbonded.c
+299
View File
@@ -0,0 +1,299 @@
/**
* Copyright (c) 2017 - 2021, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "nrf_dfu_ble_svci_bond_sharing.h"
#include "nordic_common.h"
#include "nrf_error.h"
#include "ble_dfu.h"
#include "nrf_log.h"
#include "nrf_sdh_soc.h"
#if (!NRF_DFU_BLE_BUTTONLESS_SUPPORTS_BONDS)
#define NRF_DFU_ADV_NAME_MAX_LENGTH (20)
void ble_dfu_buttonless_on_sys_evt(uint32_t, void * );
uint32_t nrf_dfu_svci_vector_table_set(void);
uint32_t nrf_dfu_svci_vector_table_unset(void);
/**@brief Define functions for async interface to set new advertisement name for DFU mode. */
NRF_SVCI_ASYNC_FUNC_DEFINE(NRF_DFU_SVCI_SET_ADV_NAME, nrf_dfu_set_adv_name, nrf_dfu_adv_name_t);
// Register SoC observer for the Buttonless Secure DFU service
NRF_SDH_SOC_OBSERVER(m_dfu_buttonless_soc_obs, BLE_DFU_SOC_OBSERVER_PRIO, ble_dfu_buttonless_on_sys_evt, NULL);
ble_dfu_buttonless_t * mp_dfu = NULL;
static nrf_dfu_adv_name_t m_adv_name;
/**@brief Function for setting an advertisement name.
*
* @param[in] adv_name The new advertisement name.
*
* @retval NRF_SUCCESS Advertisement name was successfully set.
* @retval DFU_RSP_BUSY Advertisement name was not set because of an ongoing operation.
* @retval Any other errors from the SVCI interface call.
*/
static uint32_t set_adv_name(nrf_dfu_adv_name_t * p_adv_name)
{
uint32_t err_code;
if (mp_dfu->is_waiting_for_svci)
{
return DFU_RSP_BUSY;
}
err_code = nrf_dfu_set_adv_name(p_adv_name);
if (err_code == NRF_SUCCESS)
{
// The request was accepted.
mp_dfu->is_waiting_for_svci = true;
}
else if (err_code == NRF_ERROR_FORBIDDEN)
{
NRF_LOG_ERROR("The bootloader has write protected its settings page. This prohibits setting the advertising name. "\
"The bootloader must be compiled with NRF_BL_SETTINGS_PAGE_PROTECT=0 to allow setting the advertising name.");
}
return err_code;
}
/**@brief Function for entering the bootloader.
*/
static uint32_t enter_bootloader()
{
uint32_t err_code;
if (mp_dfu->is_waiting_for_svci)
{
// We have an ongoing async operation. Entering bootloader mode is not possible at this time.
err_code = ble_dfu_buttonless_resp_send(DFU_OP_ENTER_BOOTLOADER, DFU_RSP_BUSY);
if (err_code != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
}
return NRF_SUCCESS;
}
// Set the flag indicating that we expect DFU mode.
// This will be handled on acknowledgement of the characteristic indication.
mp_dfu->is_waiting_for_reset = true;
err_code = ble_dfu_buttonless_resp_send(DFU_OP_ENTER_BOOTLOADER, DFU_RSP_SUCCESS);
if (err_code != NRF_SUCCESS)
{
mp_dfu->is_waiting_for_reset = false;
}
return err_code;
}
uint32_t ble_dfu_buttonless_backend_init(ble_dfu_buttonless_t * p_dfu)
{
VERIFY_PARAM_NOT_NULL(p_dfu);
mp_dfu = p_dfu;
return NRF_SUCCESS;
}
uint32_t ble_dfu_buttonless_async_svci_init(void)
{
uint32_t ret_val;
ret_val = nrf_dfu_svci_vector_table_set();
VERIFY_SUCCESS(ret_val);
ret_val = nrf_dfu_set_adv_name_init();
VERIFY_SUCCESS(ret_val);
ret_val = nrf_dfu_svci_vector_table_unset();
return ret_val;
}
void ble_dfu_buttonless_on_sys_evt(uint32_t sys_evt, void * p_context)
{
uint32_t err_code;
if (!nrf_dfu_set_adv_name_is_initialized())
{
return;
}
err_code = nrf_dfu_set_adv_name_on_sys_evt(sys_evt);
if (err_code == NRF_ERROR_INVALID_STATE)
{
// The system event is not from an operation started by buttonless DFU.
// No action is taken, and nothing is reported.
}
else if (err_code == NRF_SUCCESS)
{
// The async operation is finished.
// Set the flag indicating that we are waiting for indication response
// to activate the reset.
mp_dfu->is_waiting_for_svci = false;
// Report back the positive response
err_code = ble_dfu_buttonless_resp_send(DFU_OP_SET_ADV_NAME, DFU_RSP_SUCCESS);
if (err_code != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
}
}
else
{
// Invalid error code reported back.
mp_dfu->is_waiting_for_svci = false;
err_code = ble_dfu_buttonless_resp_send(DFU_OP_SET_ADV_NAME, DFU_RSP_BUSY);
if (err_code != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
}
// Report the failure to enter DFU mode
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
}
uint32_t ble_dfu_buttonless_char_add(ble_dfu_buttonless_t * p_dfu)
{
ble_add_char_params_t add_char_params;
memset(&add_char_params, 0, sizeof(add_char_params));
add_char_params.uuid = BLE_DFU_BUTTONLESS_CHAR_UUID;
add_char_params.uuid_type = p_dfu->uuid_type;
add_char_params.char_props.indicate = 1;
add_char_params.char_props.write = 1;
add_char_params.is_defered_write = true;
add_char_params.is_var_len = true;
add_char_params.max_len = BLE_GATT_ATT_MTU_DEFAULT;
add_char_params.cccd_write_access = SEC_OPEN;
add_char_params.write_access = SEC_OPEN;
add_char_params.read_access = SEC_OPEN;
return characteristic_add(p_dfu->service_handle, &add_char_params, &p_dfu->control_point_char);
}
void ble_dfu_buttonless_on_ctrl_pt_write(ble_gatts_evt_write_t const * p_evt_write)
{
uint32_t err_code;
ble_dfu_buttonless_rsp_code_t rsp_code = DFU_RSP_OPERATION_FAILED;
// Start executing the control point write operation
/*lint -e415 -e416 -save "Out of bounds access"*/
switch (p_evt_write->data[0])
{
case DFU_OP_ENTER_BOOTLOADER:
err_code = enter_bootloader();
if (err_code == NRF_SUCCESS)
{
rsp_code = DFU_RSP_SUCCESS;
}
else if (err_code == NRF_ERROR_BUSY)
{
rsp_code = DFU_RSP_BUSY;
}
break;
case DFU_OP_SET_ADV_NAME:
if( (p_evt_write->data[1] > NRF_DFU_ADV_NAME_MAX_LENGTH)
|| (p_evt_write->data[1] == 0))
{
// New advertisement name too short or too long.
rsp_code = DFU_RSP_ADV_NAME_INVALID;
}
else
{
memcpy(m_adv_name.name, &p_evt_write->data[2], p_evt_write->data[1]);
m_adv_name.len = p_evt_write->data[1];
err_code = set_adv_name(&m_adv_name);
if (err_code == NRF_SUCCESS)
{
rsp_code = DFU_RSP_SUCCESS;
}
}
break;
default:
rsp_code = DFU_RSP_OP_CODE_NOT_SUPPORTED;
break;
}
/*lint -restore*/
// Report back in case of error
if (rsp_code != DFU_RSP_SUCCESS)
{
err_code = ble_dfu_buttonless_resp_send((ble_dfu_buttonless_op_code_t)p_evt_write->data[0], rsp_code);
if (err_code != NRF_SUCCESS)
{
mp_dfu->evt_handler(BLE_DFU_EVT_RESPONSE_SEND_ERROR);
}
// Report the error to the main application
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED);
}
}
uint32_t ble_dfu_buttonless_bootloader_start_prepare(void)
{
uint32_t err_code;
// Indicate to main app that DFU mode is starting.
mp_dfu->evt_handler(BLE_DFU_EVT_BOOTLOADER_ENTER_PREPARE);
err_code = ble_dfu_buttonless_bootloader_start_finalize();
return err_code;
}
#endif // NRF_DFU_BOTTONLESS_SUPPORT_BOND
components/ble/ble_services/ble_nus/ble_nus.c
+354
View File
@@ -0,0 +1,354 @@
/**
* Copyright (c) 2012 - 2021, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include "sdk_common.h"
#if NRF_MODULE_ENABLED(BLE_NUS)
#include "ble.h"
#include "ble_nus.h"
#include "ble_srv_common.h"
#define NRF_LOG_MODULE_NAME ble_nus
#if BLE_NUS_CONFIG_LOG_ENABLED
#define NRF_LOG_LEVEL BLE_NUS_CONFIG_LOG_LEVEL
#define NRF_LOG_INFO_COLOR BLE_NUS_CONFIG_INFO_COLOR
#define NRF_LOG_DEBUG_COLOR BLE_NUS_CONFIG_DEBUG_COLOR
#else // BLE_NUS_CONFIG_LOG_ENABLED
#define NRF_LOG_LEVEL 0
#endif // BLE_NUS_CONFIG_LOG_ENABLED
#include "nrf_log.h"
NRF_LOG_MODULE_REGISTER();
#define BLE_UUID_NUS_TX_CHARACTERISTIC 0x0003 /**< The UUID of the TX Characteristic. */
#define BLE_UUID_NUS_RX_CHARACTERISTIC 0x0002 /**< The UUID of the RX Characteristic. */
#define BLE_NUS_MAX_RX_CHAR_LEN BLE_NUS_MAX_DATA_LEN /**< Maximum length of the RX Characteristic (in bytes). */
#define BLE_NUS_MAX_TX_CHAR_LEN BLE_NUS_MAX_DATA_LEN /**< Maximum length of the TX Characteristic (in bytes). */
#define NUS_BASE_UUID {{0x9E, 0xCA, 0xDC, 0x24, 0x0E, 0xE5, 0xA9, 0xE0, 0x93, 0xF3, 0xA3, 0xB5, 0x00, 0x00, 0x40, 0x6E}} /**< Used vendor specific UUID. */
/**@brief Function for handling the @ref BLE_GAP_EVT_CONNECTED event from the SoftDevice.
*
* @param[in] p_nus Nordic UART Service structure.
* @param[in] p_ble_evt Pointer to the event received from BLE stack.
*/
static void on_connect(ble_nus_t * p_nus, ble_evt_t const * p_ble_evt)
{
ret_code_t err_code;
ble_nus_evt_t evt;
ble_gatts_value_t gatts_val;
uint8_t cccd_value[2];
ble_nus_client_context_t * p_client = NULL;
err_code = blcm_link_ctx_get(p_nus->p_link_ctx_storage,
p_ble_evt->evt.gap_evt.conn_handle,
(void *) &p_client);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Link context for 0x%02X connection handle could not be fetched.",
p_ble_evt->evt.gap_evt.conn_handle);
}
/* Check the hosts CCCD value to inform of readiness to send data using the RX characteristic */
memset(&gatts_val, 0, sizeof(ble_gatts_value_t));
gatts_val.p_value = cccd_value;
gatts_val.len = sizeof(cccd_value);
gatts_val.offset = 0;
err_code = sd_ble_gatts_value_get(p_ble_evt->evt.gap_evt.conn_handle,
p_nus->tx_handles.cccd_handle,
&gatts_val);
if ((err_code == NRF_SUCCESS) &&
(p_nus->data_handler != NULL) &&
ble_srv_is_notification_enabled(gatts_val.p_value))
{
if (p_client != NULL)
{
p_client->is_notification_enabled = true;
}
memset(&evt, 0, sizeof(ble_nus_evt_t));
evt.type = BLE_NUS_EVT_COMM_STARTED;
evt.p_nus = p_nus;
evt.conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
evt.p_link_ctx = p_client;
p_nus->data_handler(&evt);
}
}
/**@brief Function for handling the @ref BLE_GATTS_EVT_WRITE event from the SoftDevice.
*
* @param[in] p_nus Nordic UART Service structure.
* @param[in] p_ble_evt Pointer to the event received from BLE stack.
*/
static void on_write(ble_nus_t * p_nus, ble_evt_t const * p_ble_evt)
{
ret_code_t err_code;
ble_nus_evt_t evt;
ble_nus_client_context_t * p_client;
ble_gatts_evt_write_t const * p_evt_write = &p_ble_evt->evt.gatts_evt.params.write;
err_code = blcm_link_ctx_get(p_nus->p_link_ctx_storage,
p_ble_evt->evt.gatts_evt.conn_handle,
(void *) &p_client);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Link context for 0x%02X connection handle could not be fetched.",
p_ble_evt->evt.gatts_evt.conn_handle);
}
memset(&evt, 0, sizeof(ble_nus_evt_t));
evt.p_nus = p_nus;
evt.conn_handle = p_ble_evt->evt.gatts_evt.conn_handle;
evt.p_link_ctx = p_client;
if ((p_evt_write->handle == p_nus->tx_handles.cccd_handle) &&
(p_evt_write->len == 2))
{
if (p_client != NULL)
{
if (ble_srv_is_notification_enabled(p_evt_write->data))
{
p_client->is_notification_enabled = true;
evt.type = BLE_NUS_EVT_COMM_STARTED;
}
else
{
p_client->is_notification_enabled = false;
evt.type = BLE_NUS_EVT_COMM_STOPPED;
}
if (p_nus->data_handler != NULL)
{
p_nus->data_handler(&evt);
}
}
}
else if ((p_evt_write->handle == p_nus->rx_handles.value_handle) &&
(p_nus->data_handler != NULL))
{
evt.type = BLE_NUS_EVT_RX_DATA;
evt.params.rx_data.p_data = p_evt_write->data;
evt.params.rx_data.length = p_evt_write->len;
p_nus->data_handler(&evt);
}
else
{
// Do Nothing. This event is not relevant for this service.
}
}
/**@brief Function for handling the @ref BLE_GATTS_EVT_HVN_TX_COMPLETE event from the SoftDevice.
*
* @param[in] p_nus Nordic UART Service structure.
* @param[in] p_ble_evt Pointer to the event received from BLE stack.
*/
static void on_hvx_tx_complete(ble_nus_t * p_nus, ble_evt_t const * p_ble_evt)
{
ret_code_t err_code;
ble_nus_evt_t evt;
ble_nus_client_context_t * p_client;
err_code = blcm_link_ctx_get(p_nus->p_link_ctx_storage,
p_ble_evt->evt.gatts_evt.conn_handle,
(void *) &p_client);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Link context for 0x%02X connection handle could not be fetched.",
p_ble_evt->evt.gatts_evt.conn_handle);
return;
}
if ((p_client->is_notification_enabled) && (p_nus->data_handler != NULL))
{
memset(&evt, 0, sizeof(ble_nus_evt_t));
evt.type = BLE_NUS_EVT_TX_RDY;
evt.p_nus = p_nus;
evt.conn_handle = p_ble_evt->evt.gatts_evt.conn_handle;
evt.p_link_ctx = p_client;
p_nus->data_handler(&evt);
}
}
void ble_nus_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context)
{
if ((p_context == NULL) || (p_ble_evt == NULL))
{
return;
}
ble_nus_t * p_nus = (ble_nus_t *)p_context;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_nus, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_nus, p_ble_evt);
break;
case BLE_GATTS_EVT_HVN_TX_COMPLETE:
on_hvx_tx_complete(p_nus, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
uint32_t ble_nus_init(ble_nus_t * p_nus, ble_nus_init_t const * p_nus_init)
{
ret_code_t err_code;
ble_uuid_t ble_uuid;
ble_uuid128_t nus_base_uuid = NUS_BASE_UUID;
ble_add_char_params_t add_char_params;
VERIFY_PARAM_NOT_NULL(p_nus);
VERIFY_PARAM_NOT_NULL(p_nus_init);
// Initialize the service structure.
p_nus->data_handler = p_nus_init->data_handler;
/**@snippet [Adding proprietary Service to the SoftDevice] */
// Add a custom base UUID.
err_code = sd_ble_uuid_vs_add(&nus_base_uuid, &p_nus->uuid_type);
VERIFY_SUCCESS(err_code);
ble_uuid.type = p_nus->uuid_type;
ble_uuid.uuid = BLE_UUID_NUS_SERVICE;
// Add the service.
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
&ble_uuid,
&p_nus->service_handle);
/**@snippet [Adding proprietary Service to the SoftDevice] */
VERIFY_SUCCESS(err_code);
// Add the RX Characteristic.
memset(&add_char_params, 0, sizeof(add_char_params));
add_char_params.uuid = BLE_UUID_NUS_RX_CHARACTERISTIC;
add_char_params.uuid_type = p_nus->uuid_type;
add_char_params.max_len = BLE_NUS_MAX_RX_CHAR_LEN;
add_char_params.init_len = sizeof(uint8_t);
add_char_params.is_var_len = true;
add_char_params.char_props.write = 1;
add_char_params.char_props.write_wo_resp = 1;
add_char_params.read_access = SEC_OPEN;
add_char_params.write_access = SEC_OPEN;
err_code = characteristic_add(p_nus->service_handle, &add_char_params, &p_nus->rx_handles);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add the TX Characteristic.
/**@snippet [Adding proprietary characteristic to the SoftDevice] */
memset(&add_char_params, 0, sizeof(add_char_params));
add_char_params.uuid = BLE_UUID_NUS_TX_CHARACTERISTIC;
add_char_params.uuid_type = p_nus->uuid_type;
add_char_params.max_len = BLE_NUS_MAX_TX_CHAR_LEN;
add_char_params.init_len = sizeof(uint8_t);
add_char_params.is_var_len = true;
add_char_params.char_props.notify = 1;
add_char_params.read_access = SEC_OPEN;
add_char_params.write_access = SEC_OPEN;
add_char_params.cccd_write_access = SEC_OPEN;
return characteristic_add(p_nus->service_handle, &add_char_params, &p_nus->tx_handles);
/**@snippet [Adding proprietary characteristic to the SoftDevice] */
}
uint32_t ble_nus_data_send(ble_nus_t * p_nus,
uint8_t * p_data,
uint16_t * p_length,
uint16_t conn_handle)
{
ret_code_t err_code;
ble_gatts_hvx_params_t hvx_params;
ble_nus_client_context_t * p_client;
VERIFY_PARAM_NOT_NULL(p_nus);
err_code = blcm_link_ctx_get(p_nus->p_link_ctx_storage, conn_handle, (void *) &p_client);
VERIFY_SUCCESS(err_code);
if ((conn_handle == BLE_CONN_HANDLE_INVALID) || (p_client == NULL))
{
return NRF_ERROR_NOT_FOUND;
}
if (!p_client->is_notification_enabled)
{
return NRF_ERROR_INVALID_STATE;
}
if (*p_length > BLE_NUS_MAX_DATA_LEN)
{
return NRF_ERROR_INVALID_PARAM;
}
memset(&hvx_params, 0, sizeof(hvx_params));
hvx_params.handle = p_nus->tx_handles.value_handle;
hvx_params.p_data = p_data;
hvx_params.p_len = p_length;
hvx_params.type = BLE_GATT_HVX_NOTIFICATION;
return sd_ble_gatts_hvx(conn_handle, &hvx_params);
}
#endif // NRF_MODULE_ENABLED(BLE_NUS)
components/ble/ble_services/ble_nus/ble_nus.h
+244
View File
@@ -0,0 +1,244 @@
/**
* Copyright (c) 2012 - 2021, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**@file
*
* @defgroup ble_nus Nordic UART Service
* @{
* @ingroup ble_sdk_srv
* @brief Nordic UART Service implementation.
*
* @details The Nordic UART Service is a simple GATT-based service with TX and RX characteristics.
* Data received from the peer is passed to the application, and the data received
* from the application of this service is sent to the peer as Handle Value
* Notifications. This module demonstrates how to implement a custom GATT-based
* service and characteristics using the SoftDevice. The service
* is used by the application to send and receive ASCII text strings to and from the
* peer.
*
* @note The application must register this module as BLE event observer using the
* NRF_SDH_BLE_OBSERVER macro. Example:
* @code
* ble_nus_t instance;
* NRF_SDH_BLE_OBSERVER(anything, BLE_NUS_BLE_OBSERVER_PRIO,
* ble_nus_on_ble_evt, &instance);
* @endcode
*/
#ifndef BLE_NUS_H__
#define BLE_NUS_H__
#include <stdint.h>
#include <stdbool.h>
#include "sdk_config.h"
#include "ble.h"
#include "ble_srv_common.h"
#include "nrf_sdh_ble.h"
#include "ble_link_ctx_manager.h"
#ifdef __cplusplus
extern "C" {
#endif
/**@brief Macro for defining a ble_nus instance.
*
* @param _name Name of the instance.
* @param[in] _nus_max_clients Maximum number of NUS clients connected at a time.
* @hideinitializer
*/
#define BLE_NUS_DEF(_name, _nus_max_clients) \
BLE_LINK_CTX_MANAGER_DEF(CONCAT_2(_name, _link_ctx_storage), \
(_nus_max_clients), \
sizeof(ble_nus_client_context_t)); \
static ble_nus_t _name = \
{ \
.p_link_ctx_storage = &CONCAT_2(_name, _link_ctx_storage) \
}; \
NRF_SDH_BLE_OBSERVER(_name ## _obs, \
BLE_NUS_BLE_OBSERVER_PRIO, \
ble_nus_on_ble_evt, \
&_name)
#define BLE_UUID_NUS_SERVICE 0x0001 /**< The UUID of the Nordic UART Service. */
#define OPCODE_LENGTH 1
#define HANDLE_LENGTH 2
/**@brief Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */
#if defined(NRF_SDH_BLE_GATT_MAX_MTU_SIZE) && (NRF_SDH_BLE_GATT_MAX_MTU_SIZE != 0)
#define BLE_NUS_MAX_DATA_LEN (NRF_SDH_BLE_GATT_MAX_MTU_SIZE - OPCODE_LENGTH - HANDLE_LENGTH)
#else
#define BLE_NUS_MAX_DATA_LEN (BLE_GATT_MTU_SIZE_DEFAULT - OPCODE_LENGTH - HANDLE_LENGTH)
#warning NRF_SDH_BLE_GATT_MAX_MTU_SIZE is not defined.
#endif
/**@brief Nordic UART Service event types. */
typedef enum
{
BLE_NUS_EVT_RX_DATA, /**< Data received. */
BLE_NUS_EVT_TX_RDY, /**< Service is ready to accept new data to be transmitted. */
BLE_NUS_EVT_COMM_STARTED, /**< Notification has been enabled. */
BLE_NUS_EVT_COMM_STOPPED, /**< Notification has been disabled. */
} ble_nus_evt_type_t;
/* Forward declaration of the ble_nus_t type. */
typedef struct ble_nus_s ble_nus_t;
/**@brief Nordic UART Service @ref BLE_NUS_EVT_RX_DATA event data.
*
* @details This structure is passed to an event when @ref BLE_NUS_EVT_RX_DATA occurs.
*/
typedef struct
{
uint8_t const * p_data; /**< A pointer to the buffer with received data. */
uint16_t length; /**< Length of received data. */
} ble_nus_evt_rx_data_t;
/**@brief Nordic UART Service client context structure.
*
* @details This structure contains state context related to hosts.
*/
typedef struct
{
bool is_notification_enabled; /**< Variable to indicate if the peer has enabled notification of the RX characteristic.*/
} ble_nus_client_context_t;
/**@brief Nordic UART Service event structure.
*
* @details This structure is passed to an event coming from service.
*/
typedef struct
{
ble_nus_evt_type_t type; /**< Event type. */
ble_nus_t * p_nus; /**< A pointer to the instance. */
uint16_t conn_handle; /**< Connection handle. */
ble_nus_client_context_t * p_link_ctx; /**< A pointer to the link context. */
union
{
ble_nus_evt_rx_data_t rx_data; /**< @ref BLE_NUS_EVT_RX_DATA event data. */
} params;
} ble_nus_evt_t;
/**@brief Nordic UART Service event handler type. */
typedef void (* ble_nus_data_handler_t) (ble_nus_evt_t * p_evt);
/**@brief Nordic UART Service initialization structure.
*
* @details This structure contains the initialization information for the service. The application
* must fill this structure and pass it to the service using the @ref ble_nus_init
* function.
*/
typedef struct
{
ble_nus_data_handler_t data_handler; /**< Event handler to be called for handling received data. */
} ble_nus_init_t;
/**@brief Nordic UART Service structure.
*
* @details This structure contains status information related to the service.
*/
struct ble_nus_s
{
uint8_t uuid_type; /**< UUID type for Nordic UART Service Base UUID. */
uint16_t service_handle; /**< Handle of Nordic UART Service (as provided by the SoftDevice). */
ble_gatts_char_handles_t tx_handles; /**< Handles related to the TX characteristic (as provided by the SoftDevice). */
ble_gatts_char_handles_t rx_handles; /**< Handles related to the RX characteristic (as provided by the SoftDevice). */
blcm_link_ctx_storage_t * const p_link_ctx_storage; /**< Pointer to link context storage with handles of all current connections and its context. */
ble_nus_data_handler_t data_handler; /**< Event handler to be called for handling received data. */
};
/**@brief Function for initializing the Nordic UART Service.
*
* @param[out] p_nus Nordic UART Service structure. This structure must be supplied
* by the application. It is initialized by this function and will
* later be used to identify this particular service instance.
* @param[in] p_nus_init Information needed to initialize the service.
*
* @retval NRF_SUCCESS If the service was successfully initialized. Otherwise, an error code is returned.
* @retval NRF_ERROR_NULL If either of the pointers p_nus or p_nus_init is NULL.
*/
uint32_t ble_nus_init(ble_nus_t * p_nus, ble_nus_init_t const * p_nus_init);
/**@brief Function for handling the Nordic UART Service's BLE events.
*
* @details The Nordic UART Service expects the application to call this function each time an
* event is received from the SoftDevice. This function processes the event if it
* is relevant and calls the Nordic UART Service event handler of the
* application if necessary.
*
* @param[in] p_ble_evt Event received from the SoftDevice.
* @param[in] p_context Nordic UART Service structure.
*/
void ble_nus_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context);
/**@brief Function for sending a data to the peer.
*
* @details This function sends the input string as an RX characteristic notification to the
* peer.
*
* @param[in] p_nus Pointer to the Nordic UART Service structure.
* @param[in] p_data String to be sent.
* @param[in,out] p_length Pointer Length of the string. Amount of sent bytes.
* @param[in] conn_handle Connection Handle of the destination client.
*
* @retval NRF_SUCCESS If the string was sent successfully. Otherwise, an error code is returned.
*/
uint32_t ble_nus_data_send(ble_nus_t * p_nus,
uint8_t * p_data,
uint16_t * p_length,
uint16_t conn_handle);
#ifdef __cplusplus
}
#endif
#endif // BLE_NUS_H__
/** @} */