xiaozhengsheng/HL-PDJ-1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始版本

Browse Source
This commit is contained in:
xiaozhengsheng
2025-08-19 09:49:41 +08:00
parent 10f1ddf1c1
commit 6df0f7d96e
2974 changed files with 1712873 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
components/ble/ble_services/experimental_ble_lns/ble_ln_common.h Normal file
View File

@@ -0,0 +1,94 @@
/**
* Copyright (c) 2015 - 2020, 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_sdk_srv_ln_common Location and Navigation common defines
* @{
* @ingroup ble_sdk_srv
* @brief Location and Navigation common defines
*
* @details This module contains define values common to LNS and LNCP
*/
#ifndef BLE_LNS_COMMON_H__
#define BLE_LNS_COMMON_H__
#ifdef __cplusplus
extern "C" {
#endif
#define BLE_LNS_INVALID_ROUTE 0xFFFF
#define BLE_LNS_NO_FIX 0xFF
#define BLE_LNS_MAX_NUM_ROUTES 10 /**< The maximum number of routes. This affects memory usage only. */
#define BLE_LNS_MAX_ROUTE_NAME_LEN BLE_GATT_ATT_MTU_DEFAULT - 5 /**< The maximum length of length of a route name. */
#define MAX_CTRL_POINT_RESP_PARAM_LEN BLE_LNS_MAX_ROUTE_NAME_LEN + 3 /**< Maximum length of a control point response. */
// Location and Navigation Service feature bits
#define BLE_LNS_FEATURE_INSTANT_SPEED_SUPPORTED (0x01 << 0) /**< Instaneous Speed Supported bit. */
#define BLE_LNS_FEATURE_TOTAL_DISTANCE_SUPPORTED (0x01 << 1) /**< Total Distance Supported bit. */
#define BLE_LNS_FEATURE_LOCATION_SUPPORTED (0x01 << 2) /**< Location Supported bit. */
#define BLE_LNS_FEATURE_ELEVATION_SUPPORTED (0x01 << 3) /**< Elevation Supported bit. */
#define BLE_LNS_FEATURE_HEADING_SUPPORTED (0x01 << 4) /**< Heading Supported bit. */
#define BLE_LNS_FEATURE_ROLLING_TIME_SUPPORTED (0x01 << 5) /**< Rolling Time Supported bit. */
#define BLE_LNS_FEATURE_UTC_TIME_SUPPORTED (0x01 << 6) /**< UTC Time Supported bit. */
#define BLE_LNS_FEATURE_REMAINING_DISTANCE_SUPPORTED (0x01 << 7) /**< Remaining Distance Supported bit. */
#define BLE_LNS_FEATURE_REMAINING_VERT_DISTANCE_SUPPORTED (0x01 << 8) /**< Remaining Vertical Distance Supported bit. */
#define BLE_LNS_FEATURE_EST_TIME_OF_ARRIVAL_SUPPORTED (0x01 << 9) /**< Estimated Time of Arrival Supported bit. */
#define BLE_LNS_FEATURE_NUM_SATS_IN_SOLUTION_SUPPORTED (0x01 << 10) /**< Number of Satellites in Solution Supported bit. */
#define BLE_LNS_FEATURE_NUM_SATS_IN_VIEW_SUPPORTED (0x01 << 11) /**< Number of Satellites in View Supported bit. */
#define BLE_LNS_FEATURE_TIME_TO_FIRST_FIX_SUPPORTED (0x01 << 12) /**< Time to First Fix Supported bit. */
#define BLE_LNS_FEATURE_EST_HORZ_POS_ERROR_SUPPORTED (0x01 << 13) /**< Estimated Horizontal Position Error Supported bit. */
#define BLE_LNS_FEATURE_EST_VERT_POS_ERROR_SUPPORTED (0x01 << 14) /**< Estimated Vertical Position Error Supported bit. */
#define BLE_LNS_FEATURE_HORZ_DILUTION_OF_PRECISION_SUPPORTED (0x01 << 15) /**< Horizontal Dilution of Precision Supported bit. */
#define BLE_LNS_FEATURE_VERT_DILUTION_OF_PRECISION_SUPPORTED (0x01 << 16) /**< Vertical Dilution of Precision Supported bit. */
#define BLE_LNS_FEATURE_LOC_AND_SPEED_CONTENT_MASKING_SUPPORTED (0x01 << 17) /**< Location and Speed Characteristic Content Masking Supported bit. */
#define BLE_LNS_FEATURE_FIX_RATE_SETTING_SUPPORTED (0x01 << 18) /**< Fix Rate Setting Supported bit. */
#define BLE_LNS_FEATURE_ELEVATION_SETTING_SUPPORTED (0x01 << 19) /**< Elevation Setting Supported bit. */
#define BLE_LNS_FEATURE_POSITION_STATUS_SUPPORTED (0x01 << 20) /**< Position Status Supported bit. */
#ifdef __cplusplus
}
#endif
#endif /* BLE_LNS_COMMON_H__ */
/** @} */

806
components/ble/ble_services/experimental_ble_lns/ble_ln_cp.c Normal file
View File

@@ -0,0 +1,806 @@
/**
* Copyright (c) 2015 - 2020, 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 "ble_ln_cp.h"
#include "ble_ln_db.h"
#include "ble_ln_common.h"
#include "sdk_common.h"
#define NRF_LOG_MODULE_NAME ble_ln_cp
#include "nrf_log.h"
NRF_LOG_MODULE_REGISTER();
// Feature Mask bits
#define FEATURE_MASK_INSTANTANEOUS_SPEED (0x01 << 0) /**< Instantaneous Speed mask bit. */
#define FEATURE_MASK_TOTAL_DISTANCE (0x01 << 1) /**< Total Distance mask bit. */
#define FEATURE_MASK_LOCATION (0x01 << 2) /**< Location mask bit. */
#define FEATURE_MASK_ELEVATION (0x01 << 3) /**< Elevation mask bit. */
#define FEATURE_MASK_HEADING (0x01 << 4) /**< Heading mask bit. */
#define FEATURE_MASK_ROLLING_TIME (0x01 << 5) /**< Rolling Time mask bit. */
#define FEATURE_MASK_UTC_TIME (0x01 << 6) /**< UTC Time mask bit. */
// Data Control point parameter type lengths.
#define INT8_LEN 1
#define INT16_LEN 2
#define INT24_LEN 3
#define INT32_LEN 4
#define OPCODE_LENGTH 1 /**< Length of opcode inside Location and Navigation Measurement packet. */
#define HANDLE_LENGTH 2 /**< Length of handle inside Location and Navigation Measurement packet. */
/**@brief Function for interception of GATT errors and @ref nrf_ble_gq errors.
*
* @param[in] nrf_error Error code.
* @param[in] p_ctx Parameter from the event handler.
* @param[in] conn_handle Connection handle.
*/
static void gatt_error_handler(uint32_t nrf_error,
void * p_ctx,
uint16_t conn_handle)
{
ble_lncp_t * p_lncp = (ble_lncp_t *)p_ctx;
if (p_lncp->error_handler != NULL)
{
p_lncp->error_handler(nrf_error);
}
}
static ble_lncp_rsp_code_t notify_app(ble_lncp_t const * p_lncp, ble_lncp_evt_t const * p_evt)
{
ble_lncp_rsp_code_t rsp = LNCP_RSP_SUCCESS;
if (p_lncp->evt_handler != NULL)
{
rsp = p_lncp->evt_handler(p_lncp, p_evt);
}
return rsp;
}
static void resp_send(ble_lncp_t * p_lncp)
{
// Send indication
uint16_t hvx_len;
uint8_t hvx_data[MAX_CTRL_POINT_RESP_PARAM_LEN];
uint32_t err_code;
nrf_ble_gq_req_t lncp_req;
memset(&lncp_req, 0, sizeof(nrf_ble_gq_req_t));
hvx_len = 3 + p_lncp->pending_rsp.rsp_param_len;
hvx_data[0] = LNCP_OP_RESPONSE_CODE;
hvx_data[1] = p_lncp->pending_rsp.op_code;
hvx_data[2] = p_lncp->pending_rsp.rsp_code;
memcpy(&hvx_data[3], &p_lncp->pending_rsp.rsp_param[0], p_lncp->pending_rsp.rsp_param_len);
lncp_req.type = NRF_BLE_GQ_REQ_GATTS_HVX;
lncp_req.error_handler.cb = gatt_error_handler;
lncp_req.error_handler.p_ctx = p_lncp;
lncp_req.params.gatts_hvx.handle = p_lncp->ctrlpt_handles.value_handle;
lncp_req.params.gatts_hvx.offset = 0;
lncp_req.params.gatts_hvx.p_data = hvx_data;
lncp_req.params.gatts_hvx.p_len = &hvx_len;
lncp_req.params.gatts_hvx.type = BLE_GATT_HVX_INDICATION;
p_lncp->is_indication_pending = true;
err_code = nrf_ble_gq_item_add(p_lncp->p_gatt_queue, &lncp_req, p_lncp->conn_handle);
if ((p_lncp->error_handler != NULL) &&
(err_code != NRF_SUCCESS))
{
p_lncp->error_handler(err_code);
}
}
static void on_connect(ble_lncp_t * p_lncp, ble_evt_t const * p_ble_evt)
{
memset(&p_lncp->mask, 0, sizeof(ble_lncp_mask_t));
p_lncp->conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
}
static void on_disconnect(ble_lncp_t * p_lncp, ble_evt_t const * p_ble_evt)
{
UNUSED_PARAMETER(p_ble_evt);
p_lncp->conn_handle = BLE_CONN_HANDLE_INVALID;
}
static void on_hvc_confirm(ble_lncp_t * p_lncp, ble_evt_t const * p_ble_evt)
{
if (p_ble_evt->evt.gatts_evt.params.hvc.handle == p_lncp->ctrlpt_handles.value_handle)
{
if (p_lncp->is_indication_pending)
{
p_lncp->is_indication_pending = false;
}
else
{
if (p_lncp->error_handler != NULL)
{
p_lncp->error_handler(NRF_ERROR_INVALID_STATE);
}
}
}
}
/**@brief Handle write events to the control point cccd.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_evt_write Write event received from the BLE stack.
*/
static void on_lncp_cccd_write(ble_lncp_t * p_lncp, ble_gatts_evt_write_t const * p_evt_write)
{
if (p_evt_write->len == BLE_CCCD_VALUE_LEN)
{
// CCCD written, update indications state
p_lncp->is_ctrlpt_indication_enabled = ble_srv_is_indication_enabled(p_evt_write->data);
}
}
/**@brief Handle write events to the navigation cccd.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_evt_write Write event received from the BLE stack.
*/
static void on_nav_cccd_write(ble_lncp_t * p_lncp, ble_gatts_evt_write_t const * p_evt_write)
{
if (p_evt_write->len == BLE_CCCD_VALUE_LEN)
{
// CCCD written, update notification state
p_lncp->is_nav_notification_enabled = ble_srv_is_notification_enabled(p_evt_write->data);
}
}
/**@brief Event handler for control point write.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_set_cumulative_value(ble_lncp_t * p_lncp, ble_gatts_evt_write_t const * p_evt_write)
{
if ( !(p_lncp->available_features & BLE_LNS_FEATURE_TOTAL_DISTANCE_SUPPORTED) )
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_OP_CODE_NOT_SUPPORTED;
return;
}
if (p_evt_write->len != OPCODE_LENGTH + INT24_LEN)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_INVALID_PARAMETER;
return;
}
const uint32_t total_distance = uint24_decode(&p_evt_write->data[1]);
const ble_lncp_evt_t evt = {
.evt_type = LNCP_EVT_TOTAL_DISTANCE_SET,
.params.total_distance = total_distance
};
p_lncp->pending_rsp.rsp_code = notify_app(p_lncp, &evt);
if (p_lncp->pending_rsp.rsp_code == LNCP_RSP_SUCCESS)
{
p_lncp->total_distance = total_distance;
}
}
/**@brief Event handler for control point write.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_mask_loc_speed_content(ble_lncp_t * p_lncp, ble_gatts_evt_write_t const * p_evt_write)
{
if ( !(p_lncp->available_features & BLE_LNS_FEATURE_LOC_AND_SPEED_CONTENT_MASKING_SUPPORTED) )
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_OP_CODE_NOT_SUPPORTED;
return;
}
if (p_evt_write->len != OPCODE_LENGTH + INT16_LEN)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_INVALID_PARAMETER;
return;
}
uint16_t rcvd_mask = uint16_decode(&p_evt_write->data[1]);
if (rcvd_mask > 0x7F)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_INVALID_PARAMETER;
return;
}
const ble_lncp_evt_t evt = {
.evt_type = LNCP_EVT_MASK_SET,
.params.mask.flags = rcvd_mask
};
p_lncp->pending_rsp.rsp_code = notify_app(p_lncp, &evt);
if (p_lncp->pending_rsp.rsp_code == LNCP_RSP_SUCCESS)
{
p_lncp->mask.flags = rcvd_mask;
}
}
/**@brief Event handler for control point write.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_nav_control(ble_lncp_t * p_lncp, ble_gatts_evt_write_t const * p_evt_write)
{
if ( !(p_lncp->is_navigation_present) )
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_OP_CODE_NOT_SUPPORTED;
return;
}
if (p_evt_write->len != LNCP_NAV_CMD_LEN)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_INVALID_PARAMETER;
return;
}
/*lint --e{415} --e{416} -save suppress Warning 415: possible access out of bond */
const uint8_t data_buf = p_evt_write->data[1];
/*lint -restore*/
if (data_buf > LNCP_NAV_CMD_MAX)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_INVALID_PARAMETER;
return;
}
const ble_lncp_nav_cmd_t cmd = (ble_lncp_nav_cmd_t) data_buf;
if (cmd == LNCP_CMD_NAV_START || cmd == LNCP_CMD_NAV_CONTINUE || cmd == LNCP_CMD_NAV_NEAREST)
{
p_lncp->is_navigation_running = true;
}
else if (cmd == LNCP_CMD_NAV_STOP || cmd == LNCP_CMD_NAV_PAUSE)
{
p_lncp->is_navigation_running = false;
}
const ble_lncp_evt_t evt = {
.evt_type = LNCP_EVT_NAV_COMMAND,
.params.nav_cmd = cmd
};
p_lncp->pending_rsp.rsp_code = notify_app(p_lncp, &evt);
}
/**@brief Event handler for control point write.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_req_num_routes(ble_lncp_t * p_lncp, ble_gatts_evt_write_t const * p_evt_write)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_SUCCESS;
if ( !(p_lncp->is_navigation_present) )
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_OP_CODE_NOT_SUPPORTED;
return;
}
if (p_evt_write->len != OPCODE_LENGTH)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_INVALID_PARAMETER;
return;
}
const uint8_t num_records = ble_ln_db_num_records_get();
p_lncp->pending_rsp.rsp_param_len = uint16_encode(num_records, &p_lncp->pending_rsp.rsp_param[0]);
}
/**@brief Event handler for control point write.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_req_name_of_route(ble_lncp_t * p_lncp, ble_gatts_evt_write_t const * p_evt_write)
{
uint8_t * p_name;
uint32_t err_code;
p_lncp->pending_rsp.rsp_code = LNCP_RSP_SUCCESS;
if ( !(p_lncp->is_navigation_present) )
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_OP_CODE_NOT_SUPPORTED;
return;
}
if (p_evt_write->len != OPCODE_LENGTH + INT16_LEN)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_INVALID_PARAMETER;
return;
}
/*lint --e{415} --e{416} -save suppress Warning 415: possible access out of bond */
const uint16_t route_num = uint16_decode(&p_evt_write->data[1]);
/*lint -restore*/
err_code = ble_ln_db_record_name_get(route_num, &p_name);
if (err_code != NRF_SUCCESS)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_OPERATION_FAILED;
return;
}
memcpy(&p_lncp->pending_rsp.rsp_param[0], p_name, BLE_LNS_MAX_ROUTE_NAME_LEN);
p_lncp->pending_rsp.rsp_param_len = BLE_LNS_MAX_ROUTE_NAME_LEN;
}
/**@brief Event handler for control point write.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_select_route(ble_lncp_t * p_lncp, ble_gatts_evt_write_t const * p_evt_write)
{
if ( !(p_lncp->is_navigation_present))
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_OP_CODE_NOT_SUPPORTED;
return;
}
if (p_evt_write->len != OPCODE_LENGTH + INT16_LEN)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_INVALID_PARAMETER;
return;
}
const uint16_t route_num = uint16_decode(&p_evt_write->data[1]);
const uint16_t stored_num = ble_ln_db_num_records_get();
if (route_num >= stored_num)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_INVALID_PARAMETER;
return;
}
const ble_lncp_evt_t evt = {
.evt_type = LNCP_EVT_ROUTE_SELECTED,
.params.selected_route = route_num
};
p_lncp->pending_rsp.rsp_code = notify_app(p_lncp, &evt);
if (p_lncp->pending_rsp.rsp_code == LNCP_RSP_SUCCESS)
{
p_lncp->selected_route = route_num;
}
}
/**@brief Event handler for control point write.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_set_fix_rate(ble_lncp_t * p_lncp, ble_gatts_evt_write_t const * p_evt_write)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_SUCCESS;
if ( !(p_lncp->available_features & BLE_LNS_FEATURE_FIX_RATE_SETTING_SUPPORTED) )
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_OP_CODE_NOT_SUPPORTED;
return;
}
if (p_evt_write->len != OPCODE_LENGTH + INT8_LEN)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_INVALID_PARAMETER;
return;
}
/*lint --e{415} --e{416} -save suppress Warning 415: possible access out of bond */
const uint8_t fix_rate = p_evt_write->data[1];
/*lint -restore*/
const ble_lncp_evt_t evt = {
.evt_type = LNCP_EVT_FIX_RATE_SET,
.params.fix_rate = fix_rate
};
p_lncp->pending_rsp.rsp_code = notify_app(p_lncp, &evt);
if (p_lncp->pending_rsp.rsp_code == LNCP_RSP_SUCCESS)
{
p_lncp->fix_rate = fix_rate;
}
}
/**@brief Event handler for control point write.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_set_elevation(ble_lncp_t * p_lncp, ble_gatts_evt_write_t const * p_evt_write)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_SUCCESS;
if ( !(p_lncp->available_features & BLE_LNS_FEATURE_ELEVATION_SETTING_SUPPORTED) )
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_OP_CODE_NOT_SUPPORTED;
return;
}
if (p_evt_write->len != OPCODE_LENGTH + INT24_LEN)
{
p_lncp->pending_rsp.rsp_code = LNCP_RSP_INVALID_PARAMETER;
return;
}
const uint32_t elevation = uint24_decode(&p_evt_write->data[1]);
ble_lncp_evt_t evt = {
.evt_type = LNCP_EVT_ELEVATION_SET,
.params.elevation = elevation
};
p_lncp->pending_rsp.rsp_code = notify_app(p_lncp, &evt);
if (p_lncp->pending_rsp.rsp_code == LNCP_RSP_SUCCESS)
{
p_lncp->elevation = elevation;
}
}
/**@brief Handle write events to the Location and Navigation Service Control Point characteristic.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_evt_write Write event received from the BLE stack.
*/
static void on_ctrlpt_write(ble_lncp_t * p_lncp, ble_gatts_evt_write_t const * p_evt_write)
{
uint32_t err_code;
p_lncp->pending_rsp.rsp_param_len = 0;
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;
if (p_lncp->is_ctrlpt_indication_enabled)
{
if (!p_lncp->is_indication_pending)
{
write_authorize_reply.params.write.update = 1;
write_authorize_reply.params.write.gatt_status = BLE_GATT_STATUS_SUCCESS;
// if the op code is navigation control, its cccd must be checked
if (p_evt_write->len > 0 && p_lncp->is_navigation_present)
{
if ( p_evt_write->data[0] == LNCP_OP_NAV_CONTROL
|| p_evt_write->data[0] == LNCP_OP_REQ_NAME_OF_ROUTE
|| p_evt_write->data[0] == LNCP_OP_REQ_NUM_ROUTES)
{
if (!p_lncp->is_nav_notification_enabled)
{
write_authorize_reply.params.write.gatt_status = BLE_GATT_STATUS_ATTERR_CPS_CCCD_CONFIG_ERROR;
}
}
}
}
else
{
write_authorize_reply.params.write.gatt_status = BLE_GATT_STATUS_ATTERR_CPS_PROC_ALR_IN_PROG;
}
}
else
{
write_authorize_reply.params.write.gatt_status = BLE_GATT_STATUS_ATTERR_CPS_CCCD_CONFIG_ERROR;
}
// reply to the write authorization
do {
err_code = sd_ble_gatts_rw_authorize_reply(p_lncp->conn_handle, &write_authorize_reply);
if (err_code != NRF_SUCCESS && err_code != NRF_ERROR_BUSY)
{
if (p_lncp->error_handler != NULL)
{
p_lncp->error_handler(err_code);
}
}
} while (err_code == NRF_ERROR_BUSY);
if (write_authorize_reply.params.write.gatt_status != BLE_GATT_STATUS_SUCCESS)
{
return;
}
// Start executing the control point write action
if (p_evt_write->len > 0)
{
p_lncp->pending_rsp.op_code = (ble_lncp_op_code_t) p_evt_write->data[0];
switch (p_lncp->pending_rsp.op_code)
{
case LNCP_OP_SET_CUMULATIVE_VALUE:
on_set_cumulative_value(p_lncp, p_evt_write);
break;
case LNCP_OP_MASK_LOC_SPEED_CONTENT:
on_mask_loc_speed_content(p_lncp, p_evt_write);
break;
case LNCP_OP_NAV_CONTROL:
on_nav_control(p_lncp, p_evt_write);
break;
case LNCP_OP_REQ_NUM_ROUTES:
on_req_num_routes(p_lncp, p_evt_write);
break;
case LNCP_OP_REQ_NAME_OF_ROUTE:
on_req_name_of_route(p_lncp, p_evt_write);
break;
case LNCP_OP_SELECT_ROUTE:
on_select_route(p_lncp, p_evt_write);
break;
case LNCP_OP_SET_FIX_RATE:
on_set_fix_rate(p_lncp, p_evt_write);
break;
case LNCP_OP_SET_ELEVATION:
on_set_elevation(p_lncp, p_evt_write);
break;
// Unrecognized Op Code
default:
p_lncp->pending_rsp.rsp_code = LNCP_RSP_OP_CODE_NOT_SUPPORTED;
break;
}
resp_send(p_lncp);
}
}
/**@brief Write authorization request event handler.
*
* @details The write authorization request event handler is only called when writing to the control point.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_rw_authorize_req(ble_lncp_t * p_lncp, ble_evt_t const * p_ble_evt)
{
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 == p_lncp->ctrlpt_handles.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_lncp, &p_auth_req->request.write);
}
}
/**@brief Write event handler.
*
* @param[in] p_lncp Location and Navigation Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_write(ble_lncp_t * p_lncp, ble_evt_t const * p_ble_evt)
{
const ble_gatts_evt_write_t * p_evt_write = &p_ble_evt->evt.gatts_evt.params.write;
if (p_evt_write->handle == p_lncp->ctrlpt_handles.cccd_handle)
{
on_lncp_cccd_write(p_lncp, p_evt_write);
}
else if (p_evt_write->handle == p_lncp->navigation_handles.cccd_handle)
{
on_nav_cccd_write(p_lncp, p_evt_write);
}
}
void ble_lncp_on_ble_evt(ble_lncp_t * p_lncp, ble_evt_t const * p_ble_evt)
{
VERIFY_PARAM_NOT_NULL_VOID(p_lncp);
VERIFY_PARAM_NOT_NULL_VOID(p_ble_evt);
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_lncp, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
if (p_ble_evt->evt.gap_evt.conn_handle == p_lncp->conn_handle)
{
on_disconnect(p_lncp, p_ble_evt);
}
break;
case BLE_GATTS_EVT_WRITE:
if (p_ble_evt->evt.gatts_evt.conn_handle == p_lncp->conn_handle)
{
on_write(p_lncp, p_ble_evt);
}
break;
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
if (p_ble_evt->evt.gatts_evt.conn_handle == p_lncp->conn_handle)
{
on_rw_authorize_req(p_lncp, p_ble_evt);
}
break;
case BLE_GATTS_EVT_HVC:
if (p_ble_evt->evt.gatts_evt.conn_handle == p_lncp->conn_handle)
{
on_hvc_confirm(p_lncp, p_ble_evt);
}
break;
default:
// no implementation
break;
}
}
uint32_t ble_lncp_total_distance_get(ble_lncp_t const * p_lncp)
{
if (p_lncp == NULL)
{
return 0;
}
return p_lncp->total_distance;
}
uint32_t ble_lncp_elevation_get(ble_lncp_t const * p_lncp)
{
if (p_lncp == NULL)
{
return 0;
}
return p_lncp->elevation;
}
ble_lncp_mask_t ble_lncp_mask_get(ble_lncp_t const * p_lncp)
{
if (p_lncp == NULL)
{
const ble_lncp_mask_t empty_mask = {0};
return empty_mask;
}
return p_lncp->mask;
}
bool ble_lncp_is_navigation_running(ble_lncp_t const * p_lncp)
{
if (p_lncp == NULL)
{
return false;
}
return p_lncp->is_navigation_running;
}
ret_code_t ble_lncp_init(ble_lncp_t * p_lncp, ble_lncp_init_t const * p_lncp_init)
{
VERIFY_PARAM_NOT_NULL(p_lncp);
VERIFY_PARAM_NOT_NULL(p_lncp_init);
VERIFY_PARAM_NOT_NULL(p_lncp_init->p_gatt_queue);
ble_add_char_params_t add_char_params;
memset(&add_char_params, 0, sizeof(add_char_params));
p_lncp->service_handle = p_lncp_init->service_handle;
p_lncp->evt_handler = p_lncp_init->evt_handler;
p_lncp->error_handler = p_lncp_init->error_handler;
p_lncp->p_gatt_queue = p_lncp_init->p_gatt_queue;
p_lncp->available_features = p_lncp_init->available_features;
p_lncp->is_position_quality_present = p_lncp_init->is_position_quality_present;
p_lncp->is_navigation_present = p_lncp_init->is_navigation_present;
p_lncp->total_distance = p_lncp_init->total_distance;
p_lncp->elevation = p_lncp_init->elevation;
p_lncp->navigation_handles = p_lncp_init->navigation_handles;
p_lncp->fix_rate = BLE_LNS_NO_FIX;
p_lncp->selected_route = BLE_LNS_INVALID_ROUTE;
p_lncp->conn_handle = BLE_CONN_HANDLE_INVALID;
p_lncp->is_navigation_running = false;
p_lncp->is_nav_notification_enabled = false;
p_lncp->is_ctrlpt_indication_enabled = false;
memset(&p_lncp->mask, 0, sizeof(ble_lncp_mask_t));
add_char_params.uuid = BLE_UUID_LN_CONTROL_POINT_CHAR;
add_char_params.max_len = 0;
add_char_params.char_props.indicate = true;
add_char_params.char_props.write = true;
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.write_access = p_lncp_init->write_perm;
add_char_params.cccd_write_access = p_lncp_init->cccd_write_perm;
NRF_LOG_DEBUG("Initialized");
return characteristic_add(p_lncp->service_handle,
&add_char_params,
&p_lncp->ctrlpt_handles);
}

250
components/ble/ble_services/experimental_ble_lns/ble_ln_cp.h Normal file
View File

@@ -0,0 +1,250 @@
/**
* Copyright (c) 2015 - 2020, 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_sdk_srv_lncp Location and Navigation Service Control Point
* @{
* @ingroup ble_sdk_srv
* @brief Location and Navigation Service Control Point module
*
* @details This module implements the Location and Navigation Service Control Point behavior.
*/
#ifndef BLE_LN_CTRLPT_H__
#define BLE_LN_CTRLPT_H__
#include "ble_srv_common.h"
#include "sdk_common.h"
#include "nrf_ble_gq.h"
#ifdef __cplusplus
extern "C" {
#endif
#define BLE_LNS_MAX_ROUTE_NAME_LEN BLE_GATT_ATT_MTU_DEFAULT - 5 /**< The maximum length of length of a route name. */
#define MAX_CTRL_POINT_RESP_PARAM_LEN BLE_LNS_MAX_ROUTE_NAME_LEN + 3 /**< Maximum length of a control point response. */
typedef struct ble_lncp_s ble_lncp_t;
/** @brief Location and Navigation event type. This list defines the possible events types from the Location and Navigation Service. */
typedef enum
{
LNCP_EVT_ELEVATION_SET, /**< Location and Navigation elevation was set. */
LNCP_EVT_FIX_RATE_SET, /**< Fix rate was set. */
LNCP_EVT_ROUTE_SELECTED, /**< A route was selected. */
LNCP_EVT_NAV_COMMAND, /**< A navigation command was issued. */
LNCP_EVT_MASK_SET, /**< Location and Speed feature mask was set. */
LNCP_EVT_TOTAL_DISTANCE_SET /**< Location and Navigation total distance was set. */
} ble_lncp_evt_type_t;
/** @brief Navigation commands. These commands can be sent to the control point and returned by an event callback. */
typedef enum
{
LNCP_CMD_NAV_STOP = 0x00, /**< When received, is_navigation_running in @ref ble_lns_s will be set to false. */
LNCP_CMD_NAV_START = 0x01, /**< When received, is_navigation_running in @ref ble_lns_s will be set to true. */
LNCP_CMD_NAV_PAUSE = 0x02, /**< When received, is_navigation_running in @ref ble_lns_s will be set to false. */
LNCP_CMD_NAV_CONTINUE = 0x03, /**< When received, is_navigation_running in @ref ble_lns_s will be set to true. */
LNCP_CMD_NAV_SKIP_WAYPOINT = 0x04, /**< When received, is_navigation_running in @ref ble_lns_s will not be affected. */
LNCP_CMD_NAV_NEAREST = 0x05, /**< When received, is_navigation_running in @ref ble_lns_s will be set to true. */
} ble_lncp_nav_cmd_t;
#define LNCP_NAV_CMD_MAX 0x05
#define LNCP_NAV_CMD_LEN (OPCODE_LENGTH + 1)
#if defined(__CC_ARM)
#pragma push
#pragma anon_unions
#elif defined(__ICCARM__)
#pragma language=extended
#elif defined(__GNUC__)
/* anonymous unions are enabled by default */
#endif
/** @brief A mask can be used to temporarily enable and disable features of the Location and Speed characteristic.*/
typedef union
{
uint8_t flags;
struct
{
uint8_t instantaneous_speed :1;
uint8_t total_distance :1;
uint8_t location :1;
uint8_t elevation :1;
uint8_t heading :1;
uint8_t rolling_time :1;
uint8_t utc_time :1;
};
} ble_lncp_mask_t;
#if defined(__CC_ARM)
#pragma pop
#elif defined(__ICCARM__)
/* leave anonymous unions enabled */
#elif defined(__GNUC__)
/* anonymous unions are enabled by default */
#endif
typedef struct
{
ble_lncp_evt_type_t evt_type;
union
{
ble_lncp_mask_t mask;
ble_lncp_nav_cmd_t nav_cmd;
uint32_t total_distance;
uint8_t fix_rate;
uint16_t selected_route;
uint32_t elevation;
} params;
} ble_lncp_evt_t;
// Location and Navigation Control Point response values
typedef enum
{
LNCP_RSP_RESERVED = 0x00, /**< Reserved for future use. */
LNCP_RSP_SUCCESS = 0x01, /**< Success. */
LNCP_RSP_OP_CODE_NOT_SUPPORTED = 0x02, /**< Op Code not supported. */
LNCP_RSP_INVALID_PARAMETER = 0x03, /**< Invalid Parameter. */
LNCP_RSP_OPERATION_FAILED = 0x04, /**< Operation Failed. */
} ble_lncp_rsp_code_t;
typedef ble_lncp_rsp_code_t (*ble_lncp_evt_handler_t) (ble_lncp_t const * p_lncp, ble_lncp_evt_t const * p_evt);
// Location and Navigation Control Point Op Code values
typedef enum
{
LNCP_OP_RESERVED = 0x00, /**< Reserved for future use. */
LNCP_OP_SET_CUMULATIVE_VALUE = 0x01, /**< Set Cumulative Value. */
LNCP_OP_MASK_LOC_SPEED_CONTENT = 0x02, /**< Mask Location and Speed Characteristic Content. */
LNCP_OP_NAV_CONTROL = 0x03, /**< Navigation Control. */
LNCP_OP_REQ_NUM_ROUTES = 0x04, /**< Request Number of Routes. */
LNCP_OP_REQ_NAME_OF_ROUTE = 0x05, /**< Request Name of Route. */
LNCP_OP_SELECT_ROUTE = 0x06, /**< Select Route. */
LNCP_OP_SET_FIX_RATE = 0x07, /**< Set Fix Rate. */
LNCP_OP_SET_ELEVATION = 0x08, /**< Set Elevation. */
LNCP_OP_RESPONSE_CODE = 0x20 /**< Response code. */
} ble_lncp_op_code_t;
/** @brief Information included in a control point write response indication. */
typedef struct
{
ble_lncp_op_code_t op_code; /**< Opcode of the control point write action. */
ble_lncp_rsp_code_t rsp_code; /**< Response code of the control point write action. */
uint8_t rsp_param_len;
uint8_t rsp_param[MAX_CTRL_POINT_RESP_PARAM_LEN];
} ble_lncp_rsp_t;
typedef struct
{
uint16_t service_handle;
ble_lncp_evt_handler_t evt_handler;
ble_srv_error_handler_t error_handler;
nrf_ble_gq_t * p_gatt_queue; /**< Pointer to BLE GATT queue instance. */
uint32_t available_features; /**< Value of the LN feature. */
bool is_position_quality_present; /**< If set to true, the position quality characteristic will be added. Else not. */
bool is_control_point_present; /**< If set to true, the control point characteristic will be added. Else not. */
bool is_navigation_present; /**< If set to true, the navigation characteristic will be added. Else not. */
ble_gatts_char_handles_t navigation_handles;
uint32_t total_distance;
uint32_t elevation;
security_req_t write_perm;
security_req_t cccd_write_perm;
} ble_lncp_init_t;
struct ble_lncp_s
{
uint16_t conn_handle;
uint16_t service_handle;
ble_gatts_char_handles_t ctrlpt_handles;
ble_gatts_char_handles_t navigation_handles;
ble_lncp_evt_handler_t evt_handler;
ble_srv_error_handler_t error_handler;
ble_lncp_rsp_t pending_rsp;
nrf_ble_gq_t * p_gatt_queue; /**< Pointer to BLE GATT queue instance. */
ble_lncp_mask_t mask;
uint32_t total_distance;
uint32_t elevation;
uint8_t fix_rate;
uint16_t selected_route;
uint32_t available_features; /**< Value of the LN feature. */
bool is_position_quality_present; /**< If set to true, the position quality characteristic will be added. Else not. */
bool is_control_point_present; /**< If set to true, the control point characteristic will be added. Else not. */
bool is_navigation_present; /**< If set to true, the navigation characteristic will be added. Else not. */
bool is_navigation_running; /**< This variable can be set using the control point. Must be true to be able to send navigation updates. */
bool is_ctrlpt_indication_enabled; /**< True if indication is enabled on the Control Point characteristic. */
bool is_nav_notification_enabled; /**< True if notification is enabled on the Navigation characteristic. */
bool is_indication_pending; /**< True if Control Point indication is pending. */
};
void ble_lncp_on_ble_evt(ble_lncp_t * p_lncp, ble_evt_t const * p_ble_evt);
uint32_t ble_lncp_total_distance_get(ble_lncp_t const * p_lncp);
uint32_t ble_lncp_elevation_get(ble_lncp_t const * p_lncp);
ble_lncp_mask_t ble_lncp_mask_get(ble_lncp_t const * p_lncp);
bool ble_lncp_is_navigation_running(ble_lncp_t const * p_lncp);
ret_code_t ble_lncp_init(ble_lncp_t * p_lncp, ble_lncp_init_t const * p_lncp_init);
#ifdef __cplusplus
}
#endif
#endif //BLE_LN_CTRLPT_H__
/** @} */

151
components/ble/ble_services/experimental_ble_lns/ble_ln_db.c Normal file
View File

@@ -0,0 +1,151 @@
/**
* Copyright (c) 2015 - 2020, 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 "ble_ln_db.h"
#include "ble_ln_common.h"
typedef struct
{
bool in_use_flag;
ble_lns_route_t record;
} database_entry_t;
static database_entry_t m_database[BLE_LNS_MAX_NUM_ROUTES];
static uint8_t m_database_crossref[BLE_LNS_MAX_NUM_ROUTES];
static uint16_t m_num_records;
void ble_ln_db_init(void)
{
int i;
for (i = 0; i < BLE_LNS_MAX_NUM_ROUTES; i++)
{
m_database[i].in_use_flag = false;
m_database_crossref[i] = 0xFF;
}
m_num_records = 0;
}
uint16_t ble_ln_db_num_records_get(void)
{
return m_num_records;
}
ret_code_t ble_ln_db_record_get(uint8_t rec_ndx, ble_lns_route_t * p_rec)
{
if (rec_ndx >= m_num_records)
{
return NRF_ERROR_INVALID_PARAM;
}
// copy record to the specified memory
*p_rec = m_database[m_database_crossref[rec_ndx]].record;
return NRF_SUCCESS;
}
ret_code_t ble_ln_db_record_name_get(uint8_t rec_ndx, uint8_t ** p_buf)
{
if (rec_ndx >= m_num_records)
{
return NRF_ERROR_INVALID_PARAM;
}
// copy record to the specified memory
*p_buf = m_database[m_database_crossref[rec_ndx]].record.route_name;
return NRF_SUCCESS;
}
ret_code_t ble_ln_db_record_add(ble_lns_route_t * p_rec)
{
int i;
if (m_num_records == BLE_LNS_MAX_NUM_ROUTES)
{
return NRF_ERROR_NO_MEM;
}
// find next available database entry
for (i = 0; i < BLE_LNS_MAX_NUM_ROUTES; i++)
{
if (!m_database[i].in_use_flag)
{
m_database[i].in_use_flag = true;
m_database[i].record = *p_rec;
m_database[i].record.route_id = i;
m_database_crossref[m_num_records] = i;
p_rec->route_id = i;
m_num_records++;
return NRF_SUCCESS;
}
}
return NRF_ERROR_NO_MEM;
}
ret_code_t ble_ln_db_record_delete(uint8_t rec_ndx)
{
int i;
if (rec_ndx >= m_num_records)
{
return NRF_ERROR_NOT_FOUND;
}
// free entry
m_database[m_database_crossref[rec_ndx]].in_use_flag = false;
// decrease number of records
m_num_records--;
// remove cross reference index
for (i = rec_ndx; i < m_num_records; i++)
{
m_database_crossref[i] = m_database_crossref[i + 1];
}
return NRF_SUCCESS;
}

122
components/ble/ble_services/experimental_ble_lns/ble_ln_db.h Normal file
View File

@@ -0,0 +1,122 @@
/**
* Copyright (c) 2015 - 2020, 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_sdk_srv_ln_db Location and Navigation database
* @{
* @ingroup ble_sdk_srv
* @brief Location and Navigation route database
*/
#ifndef BLE_LN_DB__
#define BLE_LN_DB__
#include "ble_lns.h"
#ifdef __cplusplus
extern "C" {
#endif
/**@brief Function for initializing the route database.
*
* @details This call initializes the database holding route records.
*
* @return NRF_SUCCESS on success.
*/
void ble_ln_db_init(void);
/**@brief Function for getting the number of records in the database.
*
* @details This call returns the number of records in the database.
*
* @return Number of records in the database.
*/
uint16_t ble_ln_db_num_records_get(void);
/**@brief Function for getting a record from the database.
*
* @details This call returns a specified record from the database.
*
* @param[in] record_num Index of the record to retrieve.
* @param[out] p_rec Pointer to record structure where retrieved record is copied to.
*
* @return NRF_SUCCESS on success.
*/
ret_code_t ble_ln_db_record_get(uint8_t record_num, ble_lns_route_t * p_rec);
/**@brief Function for getting a record name from the database.
*
* @details This call returns a specified record name from the database.
*
* @param[in] rec_ndx Index of the record to retrieve.
* @param[out] p_buf Pointer to array where retrieved record name is copied to.
*
* @return NRF_SUCCESS on success.
*/
ret_code_t ble_ln_db_record_name_get(uint8_t rec_ndx, uint8_t ** p_buf);
/**@brief Function for adding a record at the end of the database.
*
* @details This call adds a record as the last record in the database.
*
* @param[in] p_rec Pointer to record to add to database.
*
* @return NRF_SUCCESS on success.
*/
ret_code_t ble_ln_db_record_add(ble_lns_route_t * p_rec);
/**@brief Function for deleting a database entry.
*
* @details This call deletes an record from the database.
*
* @param[in] record_num Index of record to delete.
*
* @return NRF_SUCCESS on success.
*/
ret_code_t ble_ln_db_record_delete(uint8_t record_num);
#ifdef __cplusplus
}
#endif
#endif // BLE_LN_DB_H__
/** @} */

1028
components/ble/ble_services/experimental_ble_lns/ble_lns.c Normal file
View File

File diff suppressed because it is too large Load Diff

386
components/ble/ble_services/experimental_ble_lns/ble_lns.h Normal file
View File

@@ -0,0 +1,386 @@
/**
* Copyright (c) 2015 - 2020, 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_lns Location and Navigation Service
* @{
* @ingroup ble_sdk_srv
* @brief Location and Navigation Service module.
*
* @details This module implements the Location and Navigation Service with the Location and Speed, Position
* Quality, Feature, Control Point, and Navigation characteristics.
*
* If an event handler is supplied by the application, the Location and Navigation Service will
* generate Location and Navigation Service events to the application.
*
* @note The application must register this module as BLE event observer using the
* NRF_SDH_BLE_OBSERVER macro. Example:
* @code
* ble_lns_t instance;
* NRF_SDH_BLE_OBSERVER(anything, BLE_LNS_BLE_OBSERVER_PRIO,
* ble_lns_on_ble_evt, &instance);
* @endcode
*/
#ifndef BLE_LNS_H__
#define BLE_LNS_H__
#include "ble_srv_common.h"
#include "ble_date_time.h"
#include "ble_ln_common.h"
#include "ble_ln_cp.h"
#include "sdk_common.h"
#include "nrf_sdh_ble.h"
#include "nrf_ble_gq.h"
#ifdef __cplusplus
extern "C" {
#endif
/**@ Macro for defining a ble_lns instance.
*
* @param _name Name of the instance.
* @hideinitializer
*/
#define BLE_LNS_DEF(_name) \
static ble_lns_t _name; \
NRF_SDH_BLE_OBSERVER(_name ## _obs, \
BLE_LNS_BLE_OBSERVER_PRIO, \
ble_lns_on_ble_evt, &_name)
/**@brief Location and Navigation event type. This list defines the possible events types from the Location and Navigation Service. */
typedef enum
{
BLE_LNS_CTRLPT_EVT_INDICATION_ENABLED, /**< Control Point value indication was enabled. */
BLE_LNS_CTRLPT_EVT_INDICATION_DISABLED, /**< Control Point value indication was disabled. */
BLE_LNS_LOC_SPEED_EVT_NOTIFICATION_ENABLED, /**< Location and Speed value notification was enabled. */
BLE_LNS_LOC_SPEED_EVT_NOTIFICATION_DISABLED, /**< Location and Speed value notification was disabled. */
BLE_LNS_NAVIGATION_EVT_NOTIFICATION_ENABLED, /**< Navigation value notification was enabled. */
BLE_LNS_NAVIGATION_EVT_NOTIFICATION_DISABLED, /**< Navigation value notification was disabled. */
} ble_lns_evt_type_t;
/**@brief Location and Navigation event structure. When an event occurs, the data structures of the module are automatically updated. */
typedef struct
{
ble_lns_evt_type_t evt_type;
} ble_lns_evt_t;
// Forward declarations of the ble_lns types.
typedef struct ble_lns_init_s ble_lns_init_t;
typedef struct ble_lns_s ble_lns_t;
typedef struct ble_lns_loc_speed_s ble_lns_loc_speed_t;
typedef struct ble_lns_pos_quality_s ble_lns_pos_quality_t;
typedef struct ble_lns_navigation_s ble_lns_navigation_t;
typedef struct
{
bool is_pending;
uint16_t handle;
uint16_t len;
uint8_t data[BLE_GATT_ATT_MTU_DEFAULT];
} notification_t;
/**@brief Location and Navigation Service event handler type. */
typedef void (*ble_lns_evt_handler_t) (ble_lns_t const * p_lns, ble_lns_evt_t const * p_evt);
/**@brief Location and Navigation Service init structure. This structure contains all options
* and data needed to initialize the service.
*/
struct ble_lns_init_s
{
ble_lns_evt_handler_t evt_handler; /**< Event handler to be called for handling events in the Location and Navigation Service. */
ble_lncp_evt_handler_t lncp_evt_handler;
ble_srv_error_handler_t error_handler; /**< Errors will be sent back to this function. */
nrf_ble_gq_t * p_gatt_queue; /**< Pointer to BLE GATT queue instance. */
bool is_position_quality_present; /**< If set to true, the position quality characteristic will be added. Else not. */
bool is_control_point_present; /**< If set to true, the control point characteristic will be added. Else not. */
bool is_navigation_present; /**< If set to true, the navigation characteristic will be added. Else not. */
security_req_t loc_nav_feature_security_req_read_perm; /**< Read security level of the LN Feature characteristic. */
security_req_t loc_speed_security_req_cccd_write_perm; /**< CCCD write security level of the Write Location and Speed characteristic. */
security_req_t position_quality_security_req_read_perm; /**< Read security level of the Position Quality characteristic. */
security_req_t navigation_security_req_cccd_write_perm; /**< CCCD write security level of the Navigation characteristic. */
security_req_t ctrl_point_security_req_write_perm; /**< Read security level of the LN Control Point characteristic. */
security_req_t ctrl_point_security_req_cccd_write_perm; /**< CCCD write security level of the LN Control Point characteristic. */
uint32_t available_features; /**< Value of the LN feature. */
ble_lns_loc_speed_t * p_location_speed; /**< Initial Location and Speed. */
ble_lns_pos_quality_t * p_position_quality; /**< Initial Position Quality. */
ble_lns_navigation_t * p_navigation; /**< Initial Navigation data structure. */
};
/**@brief Definition of a navigation route.*/
typedef struct
{
uint16_t route_id;
uint8_t route_name[BLE_LNS_MAX_ROUTE_NAME_LEN];
} ble_lns_route_t;
/**@brief Location and Navigation Service structure. This structure contains various status information for the service. */
struct ble_lns_s
{
ble_lns_evt_handler_t evt_handler; /**< Event handler to be called for handling events in the Location and Navigation Service. */
ble_srv_error_handler_t error_handler; /**< Error handler. */
nrf_ble_gq_t * p_gatt_queue; /**< Pointer to BLE GATT queue instance. */
bool is_navigation_present; /**< If set to true, the navigation characteristic is present. Else not. */
uint16_t conn_handle; /**< Handle of the current connection (as provided by the BLE stack; BLE_CONN_HANDLE_INVALID if not in a connection). */
uint16_t service_handle; /**< Handle of Location and Navigation Service (as provided by the BLE stack). */
ble_gatts_char_handles_t loc_speed_handles; /**< Handles related to the Location and Speed characteristic. */
ble_gatts_char_handles_t feature_handles; /**< Handles related to the Location and Navigation Feature characteristic. */
ble_gatts_char_handles_t navigation_handles; /**< Handles related to the Navigation characteristic. */
ble_gatts_char_handles_t pos_qual_handles; /**< Handles related to the Position Quality characteristic. */
ble_gatts_char_handles_t ctrlpt_handles;
uint32_t available_features; /**< Value of Location and Navigation feature. */
bool is_loc_speed_notification_enabled; /**< True if notification is enabled on the Location and Speed characteristic. */
bool is_nav_notification_enabled; /**< True if notification is enabled on the Navigation characteristic. */
notification_t pending_loc_speed_notifications[2]; /**< This buffer holds location and speed notifications. */
notification_t pending_navigation_notification; /**< This buffer holds navigation notifications. */
ble_lns_loc_speed_t * p_location_speed; /**< Location and Speed. */
ble_lns_pos_quality_t * p_position_quality; /**< Position measurement quality. */
ble_lns_navigation_t * p_navigation; /**< Navigation data structure. */
ble_lncp_t ctrl_pt;
};
/**@brief Position status. This enumeration defines how to interpret the position data. */
typedef enum
{
BLE_LNS_NO_POSITION = 0,
BLE_LNS_POSITION_OK = 1,
BLE_LNS_ESTIMATED = 2,
BLE_LNS_LAST_KNOWN_POSITION = 3
} ble_lns_pos_status_type_t;
/**@brief The format of the position and speed measurements. */
typedef enum
{
BLE_LNS_SPEED_DISTANCE_FORMAT_2D = 0,
BLE_LNS_SPEED_DISTANCE_FORMAT_3D = 1
} ble_lns_speed_distance_format_t;
/**@brief Elevation source. */
typedef enum
{
BLE_LNS_ELEV_SOURCE_POSITIONING_SYSTEM = 0,
BLE_LNS_ELEV_SOURCE_BAROMETRIC = 1,
BLE_LNS_ELEV_SOURCE_DATABASE_SERVICE = 2,
BLE_LNS_ELEV_SOURCE_OTHER = 3
} ble_lns_elevation_source_t;
/**@brief Heading source. */
typedef enum
{
BLE_LNS_HEADING_SOURCE_MOVEMENT = 0,
BLE_LNS_HEADING_SOURCE_COMPASS = 1
} ble_lns_heading_source_t;
/**@brief Location and Speed data structure. */
struct ble_lns_loc_speed_s
{
bool instant_speed_present; /**< Instantaneous Speed present (0=not present, 1=present). */
bool total_distance_present; /**< Total Distance present (0=not present, 1=present). */
bool location_present; /**< Location present (0=not present, 1=present). */
bool elevation_present; /**< Elevation present (0=not present, 1=present). */
bool heading_present; /**< Heading present (0=not present, 1=present). */
bool rolling_time_present; /**< Rolling Time present (0=not present, 1=present). */
bool utc_time_time_present; /**< UTC Time present (0=not present, 1=present). */
ble_lns_pos_status_type_t position_status; /**< Status of current position */
ble_lns_speed_distance_format_t data_format; /**< Format of data (either 2D or 3D). */
ble_lns_elevation_source_t elevation_source; /**< Source of the elevation measurement. */
ble_lns_heading_source_t heading_source; /**< Source of the heading measurement. */
uint16_t instant_speed; /**< Instantaneous Speed (1/10 meter per sec). */
uint32_t total_distance; /**< Total Distance (meters), size=24 bits. */
int32_t latitude; /**< Latitude (10e-7 degrees). */
int32_t longitude; /**< Longitude (10e-7 degrees). */
int32_t elevation; /**< Elevation (1/100 meters), size=24 bits. */
uint16_t heading; /**< Heading (1/100 degrees). */
uint8_t rolling_time; /**< Rolling Time (seconds). */
ble_date_time_t utc_time; /**< UTC Time. */
};
/**@brief Position quality structure. */
struct ble_lns_pos_quality_s
{
bool number_of_satellites_in_solution_present; /**< The number of satellites present in solution (0=not present, 1=present). */
bool number_of_satellites_in_view_present; /**< The number of satellites present in solution (0=not present, 1=present). */
bool time_to_first_fix_present; /**< Time to the first position fix present (0=not present, 1=present). */
bool ehpe_present; /**< Error in horizontal position estimate present (0=not present, 1=present). */
bool evpe_present; /**< Error in vertical position estimate present (0=not present, 1=present). */
bool hdop_present; /**< Horizontal dilution of precision present (0=not present, 1=present). */
bool vdop_present; /**< Vertical dilution of precision present (0=not present, 1=present). */
ble_lns_pos_status_type_t position_status; /**< Status of last measured position. */
uint8_t number_of_satellites_in_solution; /**< The number of satellites in solution (unitless, with a resolution of 1). */
uint8_t number_of_satellites_in_view; /**< The number of satellites in view (unitless, with a resolution of 1). */
uint16_t time_to_first_fix; /**< Time to the first position fix (seconds, with a resolution of 1/10). */
uint32_t ehpe; /**< Error in horizontal position estimate (meters, with a resolution of 1/100). */
uint32_t evpe; /**< Error in vertical position estimate (meters, with a resolution of 1/100). */
uint8_t hdop; /**< Horizontal dilution of precision (unitless, with a resolution of 2/10). */
uint8_t vdop; /**< Vertical dilution of precision (unitless, with a resolution of 2/10). */
};
/**@brief Navigation indicator type. */
typedef enum
{
BLE_LNS_NAV_TO_WAYPOINT = 0,
BLE_LNS_NAV_TO_DESTINATION = 1
} ble_lns_nav_indicator_type_t;
/**@brief Navigation data structure. */
struct ble_lns_navigation_s
{
bool remaining_dist_present; /**< Remaining Distance present (0=not present, 1=present). */
bool remaining_vert_dist_present; /**< Remaining Vertical Distance present (0=not present, 1=present). */
bool eta_present; /**< Estimated Time of Arrival present (0=not present, 1=present). */
ble_lns_pos_status_type_t position_status; /**< Status of last measured position. */
ble_lns_heading_source_t heading_source; /**< Source of the heading measurement. */
ble_lns_nav_indicator_type_t navigation_indicator_type; /**< Navigation indicator type. */
bool waypoint_reached; /**< Waypoint Reached (0=not reached, 1=reached). */
bool destination_reached; /**< Destination Reached (0=not reached, 1=reached). */
uint16_t bearing; /**< Bearing (1/100 degrees).*/
uint16_t heading; /**< Heading (1/100 degrees), size=24 bit. */
uint32_t remaining_distance; /**< Remaining Distance (1/10 meters), size=24 bit. */
int32_t remaining_vert_distance; /**< Remaining Vertical Distance (1/100 meters), size=24 bit. */
ble_date_time_t eta; /**< Estimated Time of Arrival. */
};
/**@brief Function for initializing the Location and Navigation Service.
*
* @param[out] p_lns Location and Navigation 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_lns_init Information needed to initialize the service.
*
* @retval NRF_SUCCESS If the service was initialized successfully.
* @retval NRF_ERROR_NULL If a NULL parameter was provided.
* @retval NRF_INVALID_PARAMS If there is an inconsistency in the initialization structure.
* @return Otherwise, an error code from either sd_ble_gatts_service_add() or sd_ble_gatts_characteristic_add() is returned.
*/
ret_code_t ble_lns_init(ble_lns_t * p_lns, ble_lns_init_t const * p_lns_init);
/**@brief Function for handling Location and Navigation Service BLE stack events.
*
* @details This function handles all events from the BLE stack that are of interest to the
* Location and Navigation Service.
*
* @note The function returns when a NULL parameter is provided.
*
* @param[in] p_ble_evt Event received from the BLE stack.
* @param[in] p_context Location and Navigation Service structure.
*/
void ble_lns_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context);
/**@brief Function for sending location and speed data if notification has been enabled.
*
* @details The application calls this function after having performed a location and speed determination.
* If notification has been enabled, the location and speed data is encoded and sent to
* the client.
*
* @param[in] p_lns Location and Navigation Service structure holding the location and speed data.
*
* @retval NRF_SUCCESS If the data was sent successfully.
* @retval NRF_ERROR_NULL If a NULL parameter was provided.
* @retval NRF_ERROR_INVALID_STATE If notification is disabled.
*/
ret_code_t ble_lns_loc_speed_send(ble_lns_t * p_lns);
/**@brief Function for sending navigation data if notification has been enabled.
*
* @details The application calls this function after having performed a navigation determination.
* If notification has been enabled, the navigation data is encoded and sent to
* the client.
*
* @param[in] p_lns Location and Navigation Service structure holding the navigation data.
*
* @retval NRF_SUCCESS If the data was sent successfully.
* @retval NRF_ERROR_NULL If a NULL parameter was provided.
* @retval NRF_ERROR_NOT_SUPPORTED If the navigation characteristic is absent.
* @retval NRF_ERROR_INVALID_STATE If navigation is not running or notification is disabled.
*/
ret_code_t ble_lns_navigation_send(ble_lns_t * p_lns);
/**@brief Function for adding a route to the Location and Navigation Service.
*
* @param[in] p_lns Location and Navigation Service structure.
* @param[in,out] p_route The new route to be added. The route ID is updated.
*
* @retval NRF_SUCCESS If the route was added successfully.
* @retval NRF_ERROR_NULL If a NULL parameter was provided.
* @retval NRF_ERROR_NOT_SUPPORTED If the navigation characteristic is absent.
* @retval NRF_ERROR_NO_MEM If there is no memory left.
* @retval NRF_ERROR_INTERNAL If there is an inconsistency in the routes table.
*/
ret_code_t ble_lns_add_route(ble_lns_t * p_lns, ble_lns_route_t * p_route);
/**@brief Function for removing a route from the Location and Navigation Service.
*
* @param[in] p_lns Location and Navigation Service structure.
* @param[in] route_id The ID of the route to be removed.
*
* @retval NRF_SUCCESS If the route was removed successfully.
* @retval NRF_ERROR_NULL If a NULL parameter was provided.
* @retval NRF_ERROR_NOT_SUPPORTED If the navigation characteristic is absent.
* @retval NRF_INVALID_PARAM If the route ID does not exist.
*/
ret_code_t ble_lns_remove_route(ble_lns_t * p_lns, uint16_t route_id);
#ifdef __cplusplus
}
#endif
#endif // BLE_LNS_H__
/** @} */