From 3061ecca3d0fdfb87dabbf5f63c9e06c2a30f53a Mon Sep 17 00:00:00 2001 From: Trygve Laugstøl Date: Thu, 23 Aug 2018 17:08:59 +0200 Subject: o Initial import. --- .../ble/ble_services/ble_ias_c/ble_ias_c.c | 214 +++++++++++++++++++ .../ble/ble_services/ble_ias_c/ble_ias_c.h | 237 +++++++++++++++++++++ 2 files changed, 451 insertions(+) create mode 100644 thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ias_c/ble_ias_c.c create mode 100644 thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ias_c/ble_ias_c.h (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ias_c') diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ias_c/ble_ias_c.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ias_c/ble_ias_c.c new file mode 100644 index 0000000..c303cd6 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ias_c/ble_ias_c.c @@ -0,0 +1,214 @@ +/** + * Copyright (c) 2012 - 2018, 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_IAS_C) +#include "ble_ias_c.h" + +#include +#include "ble.h" +#include "ble_srv_common.h" +#include "ble_gattc.h" +#include "ble_db_discovery.h" + + +void ble_ias_c_on_db_disc_evt(ble_ias_c_t * p_ias_c, ble_db_discovery_evt_t const * p_evt) +{ + ble_ias_c_evt_t evt; + + memset(&evt, 0, sizeof(ble_ias_c_evt_t)); + evt.evt_type = BLE_IAS_C_EVT_DISCOVERY_FAILED; + evt.conn_handle = p_evt->conn_handle; + + ble_gatt_db_char_t const * p_chars = p_evt->params.discovered_db.charateristics; + + // Check if the Immediate Alert Service was discovered. + if ( (p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE) + && (p_evt->params.discovered_db.srv_uuid.uuid == BLE_UUID_IMMEDIATE_ALERT_SERVICE) + && (p_evt->params.discovered_db.srv_uuid.type == BLE_UUID_TYPE_BLE)) + { + for (uint32_t i = 0; i < p_evt->params.discovered_db.char_count; i++) + { + // The Alert Level characteristic in the Immediate Alert Service instance is found + // on peer. Check if it has the correct property 'Write without response'. + switch (p_chars[i].characteristic.uuid.uuid) + { + case BLE_UUID_ALERT_LEVEL_CHAR: + if (p_chars[i].characteristic.char_props.write_wo_resp) + { + // Found Alert Level characteristic inside the Immediate Alert Service. + memcpy(&evt.alert_level, + &p_chars[i].characteristic, + sizeof(ble_gattc_char_t)); + } + break; + + default: + break; + } + } + } + if (evt.alert_level.handle_value != BLE_GATT_HANDLE_INVALID) + { + evt.evt_type = BLE_IAS_C_EVT_DISCOVERY_COMPLETE; + } + + p_ias_c->evt_handler(p_ias_c, &evt); +} + + +uint32_t ble_ias_c_init(ble_ias_c_t * p_ias_c, ble_ias_c_init_t const * p_ias_c_init) +{ + VERIFY_PARAM_NOT_NULL(p_ias_c); + VERIFY_PARAM_NOT_NULL(p_ias_c_init->evt_handler); + VERIFY_PARAM_NOT_NULL(p_ias_c_init); + + p_ias_c->evt_handler = p_ias_c_init->evt_handler; + p_ias_c->error_handler = p_ias_c_init->error_handler; + p_ias_c->conn_handle = BLE_CONN_HANDLE_INVALID; + p_ias_c->alert_level_char.handle_value = BLE_GATT_HANDLE_INVALID; + + BLE_UUID_BLE_ASSIGN(p_ias_c->alert_level_char.uuid, BLE_UUID_ALERT_LEVEL_CHAR); + BLE_UUID_BLE_ASSIGN(p_ias_c->service_uuid, BLE_UUID_IMMEDIATE_ALERT_SERVICE); + + return ble_db_discovery_evt_register(&p_ias_c->service_uuid); +} + + + +/**@brief Function for handling the Disconnect event. + * + * @param[in] p_ias_c Immediate Alert Service client structure. + * @param[in] p_ble_evt Event received from the BLE stack. + */ +static void on_disconnect(ble_ias_c_t * p_ias_c, ble_evt_t const * p_ble_evt) +{ + // The following values will be re-initialized when a new connection is made. + p_ias_c->conn_handle = BLE_CONN_HANDLE_INVALID; + + if (ble_ias_c_is_discovered(p_ias_c)) + { + // There was a valid instance of IAS on the peer. Send an event to the + // application, so that it can do any clean up related to this module. + ble_ias_c_evt_t evt; + + evt.evt_type = BLE_IAS_C_EVT_DISCONN_COMPLETE; + + p_ias_c->evt_handler(p_ias_c, &evt); + p_ias_c->alert_level_char.handle_value = BLE_GATT_HANDLE_INVALID; + } +} + + +void ble_ias_c_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context) +{ + uint32_t err_code = NRF_SUCCESS; + ble_ias_c_t * p_ias_c = (ble_ias_c_t *)p_context; + + switch (p_ble_evt->header.evt_id) + { + case BLE_GAP_EVT_DISCONNECTED: + on_disconnect(p_ias_c, p_ble_evt); + break; + + default: + // No implementation needed. + break; + } + + if ((err_code != NRF_SUCCESS) && (p_ias_c->error_handler != NULL)) + { + p_ias_c->error_handler(err_code); + } +} + + +/**@brief Function for performing a Write procedure. + * + * @param[in] conn_handle Handle of the connection on which to perform the write operation. + * @param[in] write_handle Handle of the attribute to be written. + * @param[in] length Length of data to be written. + * @param[in] p_value Data to be written. + * + * @return NRF_SUCCESS on success, otherwise an error code. + */ +static uint32_t write_characteristic_value(uint16_t conn_handle, + uint16_t write_handle, + uint16_t length, + uint8_t * p_value) +{ + ble_gattc_write_params_t write_params; + + memset(&write_params, 0, sizeof(write_params)); + + write_params.handle = write_handle; + write_params.write_op = BLE_GATT_OP_WRITE_CMD; + write_params.offset = 0; + write_params.len = length; + write_params.p_value = p_value; + + return sd_ble_gattc_write(conn_handle, &write_params); +} + + +uint32_t ble_ias_c_send_alert_level(ble_ias_c_t const * p_ias_c, uint8_t alert_level) +{ + if (!ble_ias_c_is_discovered(p_ias_c)) + { + return NRF_ERROR_NOT_FOUND; + } + + return write_characteristic_value(p_ias_c->conn_handle, + p_ias_c->alert_level_char.handle_value, + sizeof(uint8_t), + &alert_level); +} + + +uint32_t ble_ias_c_handles_assign(ble_ias_c_t * p_ias_c, + const uint16_t conn_handle, + const uint16_t alert_level_handle) +{ + VERIFY_PARAM_NOT_NULL(p_ias_c); + + p_ias_c->conn_handle = conn_handle; + p_ias_c->alert_level_char.handle_value = alert_level_handle; + return NRF_SUCCESS; +} +#endif //NRF_MODULE_ENABLED(BLE_IAS_C) diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ias_c/ble_ias_c.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ias_c/ble_ias_c.h new file mode 100644 index 0000000..5d46d93 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/ble/ble_services/ble_ias_c/ble_ias_c.h @@ -0,0 +1,237 @@ +/** + * Copyright (c) 2012 - 2018, 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_ias_c Immediate Alert Service Client + * @{ + * @ingroup ble_sdk_srv + * @brief Immediate Alert Service Client module + * + * @details This module implements the Immediate Alert Service client - locator role of the Find Me + * profile. On @ref BLE_GAP_EVT_CONNECTED event, this module starts discovery of the + * Immediate Alert Service with Alert Level characteristic at the peer. This module will + * indicate the application about a successful service & characteristic discovery using + * @ref BLE_IAS_C_EVT_DISCOVERY_COMPLETE event. The application can use @ref + * ble_ias_c_send_alert_level function to signal alerts to the peer. + * + * @note The application must register this module as BLE event observer using the + * NRF_SDH_BLE_OBSERVER macro. Example: + * @code + * ble_ias_c_t instance; + * NRF_SDH_BLE_OBSERVER(anything, BLE_IAS_C_BLE_OBSERVER_PRIO, + * ble_ias_c_on_ble_evt, &instance); + * @endcode + */ + +#ifndef BLE_IAS_C_H__ +#define BLE_IAS_C_H__ + +#include +#include "ble_srv_common.h" +#include "ble_gattc.h" +#include "ble.h" +#include "ble_db_discovery.h" +#include "nrf_sdh_ble.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/**@brief Macro for defining a ble_ias_c instance. + * + * @param _name Name of the instance. + * @hideinitializer + */ +#define BLE_IAS_C_DEF(_name) \ +static ble_ias_c_t _name; \ +NRF_SDH_BLE_OBSERVER(_name ## _obs, \ + BLE_IAS_C_BLE_OBSERVER_PRIO, \ + ble_ias_c_on_ble_evt, &_name) + +/** @brief Macro for defining multiple ble_ias_c instances. + * + * @param _name Name of the array of instances. + * @param _cnt Number of instances to define. + * @hideinitializer + */ +#define BLE_IAS_C_ARRAY_DEF(_name, _cnt) \ +static ble_ias_c_t _name[_cnt]; \ +NRF_SDH_BLE_OBSERVERS(_name ## _obs, \ + BLE_IAS_C_BLE_OBSERVER_PRIO, \ + ble_ias_c_on_ble_evt, &_name, _cnt) + + +// Forward declaration of the ble_ias_c_t type. +typedef struct ble_ias_c_s ble_ias_c_t; + +/**@brief Immediate Alert Service client event type. */ +typedef enum +{ + BLE_IAS_C_EVT_DISCOVERY_COMPLETE, /**< Event indicating that the Immediate Alert Service is found at the peer. */ + BLE_IAS_C_EVT_DISCOVERY_FAILED, /**< Event indicating that the Immediate Alert Service is not found at the peer. */ + BLE_IAS_C_EVT_DISCONN_COMPLETE /**< Event indicating that the Immediate Alert Service client module has completed the processing of BLE_GAP_EVT_DISCONNECTED event. This event is raised only if a valid instance of IAS was found at the peer during the discovery phase. This event can be used the application to do clean up related to the IAS Client.*/ +} ble_ias_c_evt_type_t; + +/**@brief Immediate Alert Service client event. */ +typedef struct +{ + ble_ias_c_evt_type_t evt_type; /**< Type of event. */ + uint16_t conn_handle; /**< Connection handle on which the IAS service was discovered on the peer device. This will be filled if the evt_type is @ref BLE_IAS_C_EVT_DISCOVERY_COMPLETE.*/ + ble_gattc_char_t alert_level; /**< Info on the discovered Alert Level characteristic discovered. This will be filled if the evt_type is @ref BLE_IAS_C_EVT_DISCOVERY_COMPLETE.*/ +} ble_ias_c_evt_t; + +/**@brief Immediate Alert Service client event handler type. */ +typedef void (*ble_ias_c_evt_handler_t) (ble_ias_c_t * p_ias_c, ble_ias_c_evt_t * p_evt); + +/**@brief IAS Client structure. This contains various status information for the client. */ +struct ble_ias_c_s +{ + ble_ias_c_evt_handler_t evt_handler; /**< Event handler to be called for handling events in the Immediate Alert Service client. */ + ble_srv_error_handler_t error_handler; /**< Function to be called in case of an error. */ + uint16_t conn_handle; /**< Handle of the current connection. Set with @ref ble_ias_c_handles_assign when connected. */ + ble_uuid_t service_uuid; /**< The GATT Service holding the discovered Immediate Service. */ + ble_gattc_char_t alert_level_char; /**< IAS Alert Level Characteristic. Stores data about the alert characteristic found on the peer. */ +}; + +/**@brief IAS Client init structure. This contains all options and data needed for initialization of + * the client.*/ +typedef struct +{ + ble_ias_c_evt_handler_t evt_handler; /**< Event handler to be called for handling events from the Immediate Alert Service client. */ + ble_srv_error_handler_t error_handler; /**< Function to be called in case of an error. */ +} ble_ias_c_init_t; + + +/**@brief Function for initializing the Immediate Alert Service client. + * + * @details This call allows the application to initialize the Immediate Alert Service client. + * + * @param[out] p_ias_c Immediate Alert Service client structure. This structure will have to + * be supplied by the application. It will be initialized by this + * function, and will later be used to identify this particular client + * instance. + * @param[in] p_ias_c_init Information needed to initialize the Immediate Alert Service client. + * + * @return NRF_SUCCESS on successful initialization of service. + */ +uint32_t ble_ias_c_init(ble_ias_c_t * p_ias_c, ble_ias_c_init_t const * p_ias_c_init); + + +/**@brief Function for sending alert level to the peer. + * + * @details This function allows the application to send an alert to the peer. + * + * @param[in] p_ias_c Immediate Alert Service client structure. + * @param[in] alert_level Required alert level to be sent to the peer. + * + * @return NRF_SUCCESS on success, otherwise an error code. + */ +uint32_t ble_ias_c_send_alert_level(ble_ias_c_t const * p_ias_c, uint8_t alert_level); + + +/**@brief Function for handling the Application's BLE Stack events for Immediate Alert Service client. + * + * @details Handles all events from the BLE stack of interest to the Immediate Alert Service client. + * + * @param[in] p_ble_evt Event received from the BLE stack. + * @param[in] p_context Immediate Alert Service client structure. + */ +void ble_ias_c_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context); + + +/**@brief Function for checking whether the peer's Immediate Alert Service instance and the alert level + * characteristic have been discovered. + * + * @param[in] p_ias_c Immediate Alert Service client structure. + * + * @return TRUE if a handle has been assigned to alert_level_handle, meaning it must have been + * discovered. FALSE if the handle is invalid. + */ +static __INLINE bool ble_ias_c_is_discovered(ble_ias_c_t const * p_ias_c) +{ + return (p_ias_c->alert_level_char.handle_value != BLE_GATT_HANDLE_INVALID); +} + + +/**@brief Function for handling events from the database discovery module. + * + * @details Call this function when getting a callback event from the DB discovery modue. + * This function will handle an event from the database discovery module, and determine + * if it relates to the discovery of heart rate service at the peer. If so, it will + * call the application's event handler indicating that the heart rate service has been + * discovered at the peer. It also populates the event with the service related + * information before providing it to the application. + * + * @param[in] p_ias_c Pointer to the immediate alert client structure instance that will handle + * the discovery. + * @param[in] p_evt Pointer to the event received from the database discovery module. + * + */ +void ble_ias_c_on_db_disc_evt(ble_ias_c_t * p_ias_c, ble_db_discovery_evt_t const * p_evt); + + +/**@brief Function for assigning handles to an instance of ias_c. + * + * @details Call this function when a link has been established with a peer to + * associate this link to this instance of the module. This makes it + * possible to handle several links and associate each link to a particular + * instance of this module. The connection handle and attribute handles will be + * provided from the discovery event @ref BLE_IAS_C_EVT_DISCOVERY_COMPLETE. + * + * @param[in] p_ias_c Pointer to the IAS client structure instance to associate. + * @param[in] conn_handle Connection handle to associated with the given IAS Instance. + * @param[in] alert_level_handle Attribute handle on the IAS server that you want this IAS_C client to + * interact with. + * + * @retval NRF_SUCCESS If the operation was successful. + * @retval NRF_ERROR_NULL If a p_ias_c was a NULL pointer. + */ +uint32_t ble_ias_c_handles_assign(ble_ias_c_t * p_ias_c, + uint16_t conn_handle, + uint16_t alert_level_handle); + + +#ifdef __cplusplus +} +#endif + +#endif // BLE_IAS_C_H__ + +/** @} */ -- cgit v1.2.3