553 lines
17 KiB
C
553 lines
17 KiB
C
/**
|
|
****************************************************************************************
|
|
* @addtogroup HTPT
|
|
* @{
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/*
|
|
* INCLUDE FILES
|
|
****************************************************************************************
|
|
*/
|
|
#include "rwip_config.h"
|
|
|
|
#if (BLE_HT_THERMOM)
|
|
#include "attm.h"
|
|
#include "co_utils.h"
|
|
#include "htpt.h"
|
|
#include "htpt_task.h"
|
|
#include "prf_utils.h"
|
|
|
|
#include "co_utils.h"
|
|
#include "ke_mem.h"
|
|
|
|
/*
|
|
* HTPT PROFILE ATTRIBUTES
|
|
****************************************************************************************
|
|
*/
|
|
/// Full HTS Database Description - Used to add attributes into the database
|
|
const struct attm_desc htpt_att_db[HTS_IDX_NB] = {
|
|
// Health Thermometer Service Declaration
|
|
[HTS_IDX_SVC] = {ATT_DECL_PRIMARY_SERVICE, PERM(RD, ENABLE), 0, 0},
|
|
|
|
// Temperature Measurement Characteristic Declaration
|
|
[HTS_IDX_TEMP_MEAS_CHAR] = {ATT_DECL_CHARACTERISTIC, PERM(RD, ENABLE), 0,
|
|
0},
|
|
// Temperature Measurement Characteristic Value
|
|
[HTS_IDX_TEMP_MEAS_VAL] = {ATT_CHAR_TEMPERATURE_MEAS, PERM(IND, ENABLE),
|
|
PERM(RI, ENABLE), 0},
|
|
// Temperature Measurement Characteristic - Client Characteristic
|
|
// Configuration Descriptor
|
|
[HTS_IDX_TEMP_MEAS_IND_CFG] = {ATT_DESC_CLIENT_CHAR_CFG,
|
|
PERM(RD, ENABLE) | PERM(WRITE_REQ, ENABLE),
|
|
0, 0},
|
|
|
|
// Temperature Type Characteristic Declaration
|
|
[HTS_IDX_TEMP_TYPE_CHAR] = {ATT_DECL_CHARACTERISTIC, PERM(RD, ENABLE), 0,
|
|
0},
|
|
// Temperature Type Characteristic Value
|
|
[HTS_IDX_TEMP_TYPE_VAL] = {ATT_CHAR_TEMPERATURE_TYPE, PERM(RD, ENABLE),
|
|
PERM(RI, ENABLE), 0},
|
|
|
|
// Intermediate Measurement Characteristic Declaration
|
|
[HTS_IDX_INTERM_TEMP_CHAR] = {ATT_DECL_CHARACTERISTIC, PERM(RD, ENABLE), 0,
|
|
0},
|
|
// Intermediate Measurement Characteristic Value
|
|
[HTS_IDX_INTERM_TEMP_VAL] = {ATT_CHAR_INTERMED_TEMPERATURE,
|
|
PERM(NTF, ENABLE), PERM(RI, ENABLE), 0},
|
|
// Intermediate Measurement Characteristic - Client Characteristic
|
|
// Configuration Descriptor
|
|
[HTS_IDX_INTERM_TEMP_CFG] = {ATT_DESC_CLIENT_CHAR_CFG,
|
|
PERM(RD, ENABLE) | PERM(WRITE_REQ, ENABLE), 0,
|
|
0},
|
|
|
|
// Measurement Interval Characteristic Declaration
|
|
[HTS_IDX_MEAS_INTV_CHAR] = {ATT_DECL_CHARACTERISTIC, PERM(RD, ENABLE), 0,
|
|
0},
|
|
// Measurement Interval Characteristic Value
|
|
[HTS_IDX_MEAS_INTV_VAL] = {ATT_CHAR_MEAS_INTERVAL, PERM(RD, ENABLE),
|
|
PERM(RI, ENABLE), HTPT_MEAS_INTV_MAX_LEN},
|
|
// Measurement Interval Characteristic - Client Characteristic Configuration
|
|
// Descriptor
|
|
[HTS_IDX_MEAS_INTV_CFG] = {ATT_DESC_CLIENT_CHAR_CFG,
|
|
PERM(RD, ENABLE) | PERM(WRITE_REQ, ENABLE), 0,
|
|
0},
|
|
// Measurement Interval Characteristic - Valid Range Descriptor
|
|
[HTS_IDX_MEAS_INTV_VAL_RANGE] = {ATT_DESC_VALID_RANGE, PERM(RD, ENABLE),
|
|
PERM(RI, ENABLE), 0},
|
|
};
|
|
|
|
static uint16_t htpt_compute_att_table(uint16_t features);
|
|
|
|
/*
|
|
* LOCAL FUNCTION DEFINITIONS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
static uint8_t htpt_init(struct prf_task_env *env, uint16_t *start_hdl,
|
|
uint16_t app_task, uint8_t sec_lvl,
|
|
struct htpt_db_cfg *params) {
|
|
// Service content flag
|
|
uint16_t cfg_flag;
|
|
// DB Creation Status
|
|
uint8_t status = ATT_ERR_NO_ERROR;
|
|
|
|
BLE_PRF_HP_FUNC_ENTER();
|
|
|
|
cfg_flag = htpt_compute_att_table(params->features);
|
|
|
|
status = attm_svc_create_db(
|
|
start_hdl, ATT_SVC_HEALTH_THERMOM, (uint8_t *)&cfg_flag, HTS_IDX_NB, NULL,
|
|
env->task, &htpt_att_db[0],
|
|
(sec_lvl & (PERM_MASK_SVC_DIS | PERM_MASK_SVC_AUTH | PERM_MASK_SVC_EKS)) |
|
|
PERM(SVC_MI, DISABLE));
|
|
|
|
if (status == ATT_ERR_NO_ERROR) {
|
|
//-------------------- allocate memory required for the profile
|
|
//---------------------
|
|
struct htpt_env_tag *htpt_env = (struct htpt_env_tag *)ke_malloc(
|
|
sizeof(struct htpt_env_tag), KE_MEM_ATT_DB);
|
|
|
|
// allocate PROXR required environment variable
|
|
env->env = (prf_env_t *)htpt_env;
|
|
|
|
htpt_env->shdl = *start_hdl;
|
|
htpt_env->prf_env.app_task =
|
|
app_task | (PERM_GET(sec_lvl, SVC_MI) ? PERM(PRF_MI, ENABLE)
|
|
: PERM(PRF_MI, DISABLE));
|
|
htpt_env->prf_env.prf_task = env->task | PERM(PRF_MI, DISABLE);
|
|
|
|
// initialize environment variable
|
|
env->id = TASK_ID_HTPT;
|
|
htpt_task_init(&(env->desc));
|
|
|
|
// Save features on the environment
|
|
htpt_env->features = params->features;
|
|
htpt_env->meas_intv = params->meas_intv;
|
|
htpt_env->meas_intv_min = params->valid_range_min;
|
|
htpt_env->meas_intv_max = params->valid_range_max;
|
|
htpt_env->temp_type = params->temp_type;
|
|
htpt_env->operation = NULL;
|
|
memset(htpt_env->ntf_ind_cfg, 0, sizeof(htpt_env->ntf_ind_cfg));
|
|
|
|
// Update measurement interval permissions
|
|
if (HTPT_IS_FEATURE_SUPPORTED(params->features, HTPT_MEAS_INTV_CHAR_SUP)) {
|
|
uint16_t perm = PERM(RD, ENABLE);
|
|
|
|
// Check if Measurement Interval Char. supports indications
|
|
if (HTPT_IS_FEATURE_SUPPORTED(params->features, HTPT_MEAS_INTV_IND_SUP)) {
|
|
perm |= PERM(IND, ENABLE);
|
|
}
|
|
|
|
// Check if Measurement Interval Char. is writable
|
|
if (HTPT_IS_FEATURE_SUPPORTED(params->features, HTPT_MEAS_INTV_WR_SUP)) {
|
|
perm |= PERM(WP, UNAUTH) | PERM(WRITE_REQ, ENABLE);
|
|
}
|
|
|
|
attm_att_set_permission(HTPT_HANDLE(HTS_IDX_MEAS_INTV_VAL), perm, 0);
|
|
}
|
|
|
|
// service is ready, go into an Idle state
|
|
ke_state_set(env->task, HTPT_IDLE);
|
|
}
|
|
|
|
BLE_PRF_HP_FUNC_LEAVE();
|
|
|
|
return (status);
|
|
}
|
|
|
|
static void htpt_destroy(struct prf_task_env *env) {
|
|
struct htpt_env_tag *htpt_env = (struct htpt_env_tag *)env->env;
|
|
|
|
BLE_PRF_HP_FUNC_ENTER();
|
|
|
|
// free profile environment variables
|
|
if (htpt_env->operation != NULL) {
|
|
ke_free(htpt_env->operation);
|
|
}
|
|
|
|
env->env = NULL;
|
|
ke_free(htpt_env);
|
|
|
|
BLE_PRF_HP_FUNC_LEAVE();
|
|
}
|
|
|
|
static void htpt_create(struct prf_task_env *env, uint8_t conidx) {
|
|
BLE_PRF_HP_FUNC_ENTER();
|
|
|
|
/* Clear configuration for this connection */
|
|
struct htpt_env_tag *htpt_env = (struct htpt_env_tag *)env->env;
|
|
htpt_env->ntf_ind_cfg[conidx] = 0;
|
|
|
|
BLE_PRF_HP_FUNC_LEAVE();
|
|
}
|
|
|
|
static void htpt_cleanup(struct prf_task_env *env, uint8_t conidx,
|
|
uint8_t reason) {
|
|
BLE_PRF_HP_FUNC_ENTER();
|
|
|
|
/* Clear configuration for this connection */
|
|
struct htpt_env_tag *htpt_env = (struct htpt_env_tag *)env->env;
|
|
htpt_env->ntf_ind_cfg[conidx] = 0;
|
|
|
|
BLE_PRF_HP_FUNC_LEAVE();
|
|
}
|
|
|
|
/**
|
|
****************************************************************************************
|
|
* @brief Compute a flag allowing to know attributes to add into the database
|
|
*
|
|
* @return a 16-bit flag whose each bit matches an attribute. If the bit is set
|
|
*to 1, the attribute will be added into the database.
|
|
****************************************************************************************
|
|
*/
|
|
static uint16_t htpt_compute_att_table(uint16_t features) {
|
|
BLE_PRF_HP_FUNC_ENTER();
|
|
|
|
// Temperature Measurement Characteristic is mandatory
|
|
uint16_t att_table = HTPT_TEMP_MEAS_MASK;
|
|
|
|
// Check if Temperature Type Char. is supported
|
|
if (HTPT_IS_FEATURE_SUPPORTED(features, HTPT_TEMP_TYPE_CHAR_SUP)) {
|
|
att_table |= HTPT_TEMP_TYPE_MASK;
|
|
}
|
|
|
|
// Check if Intermediate Temperature Char. is supported
|
|
if (HTPT_IS_FEATURE_SUPPORTED(features, HTPT_INTERM_TEMP_CHAR_SUP)) {
|
|
att_table |= HTPT_INTM_TEMP_MASK;
|
|
}
|
|
|
|
// Check if Measurement Interval Char. is supported
|
|
if (HTPT_IS_FEATURE_SUPPORTED(features, HTPT_MEAS_INTV_CHAR_SUP)) {
|
|
att_table |= HTPT_MEAS_INTV_MASK;
|
|
|
|
// Check if Measurement Interval Char. supports indications
|
|
if (HTPT_IS_FEATURE_SUPPORTED(features, HTPT_MEAS_INTV_IND_SUP)) {
|
|
att_table |= HTPT_MEAS_INTV_CCC_MASK;
|
|
}
|
|
|
|
// Check if Measurement Interval Char. is writable
|
|
if (HTPT_IS_FEATURE_SUPPORTED(features, HTPT_MEAS_INTV_WR_SUP)) {
|
|
att_table |= HTPT_MEAS_INTV_VALID_RGE_MASK;
|
|
}
|
|
}
|
|
|
|
BLE_PRF_HP_FUNC_LEAVE();
|
|
|
|
return att_table;
|
|
}
|
|
|
|
/*
|
|
* GLOBAL VARIABLE DEFINITIONS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
/// HTPT Task interface required by profile manager
|
|
const struct prf_task_cbs htpt_itf = {
|
|
(prf_init_fnct)htpt_init,
|
|
htpt_destroy,
|
|
htpt_create,
|
|
htpt_cleanup,
|
|
};
|
|
|
|
/*
|
|
* FUNCTION DEFINITIONS
|
|
****************************************************************************************
|
|
*/
|
|
|
|
uint8_t htpt_get_valid_rge_offset(uint16_t features) {
|
|
uint8_t offset = 0;
|
|
|
|
if (HTPT_IS_FEATURE_SUPPORTED(features, HTPT_MEAS_INTV_WR_SUP)) {
|
|
offset += 1;
|
|
|
|
if (HTPT_IS_FEATURE_SUPPORTED(features, HTPT_MEAS_INTV_IND_SUP)) {
|
|
offset += 1;
|
|
}
|
|
}
|
|
|
|
return offset;
|
|
}
|
|
|
|
uint8_t htpt_pack_temp_value(uint8_t *packed_temp,
|
|
struct htp_temp_meas temp_meas) {
|
|
uint8_t cursor = 0;
|
|
|
|
*(packed_temp + cursor) = temp_meas.flags;
|
|
cursor += 1;
|
|
|
|
co_write32p(packed_temp + cursor, temp_meas.temp);
|
|
cursor += 4;
|
|
|
|
// Time Flag Set
|
|
if ((temp_meas.flags & HTP_FLAG_TIME) == HTP_FLAG_TIME) {
|
|
cursor += prf_pack_date_time(packed_temp + cursor, &(temp_meas.time_stamp));
|
|
}
|
|
|
|
// Type flag set
|
|
if ((temp_meas.flags & HTP_FLAG_TYPE) == HTP_FLAG_TYPE) {
|
|
*(packed_temp + cursor) = temp_meas.type;
|
|
cursor += 1;
|
|
}
|
|
|
|
// Clear unused packet data
|
|
if (cursor < HTPT_TEMP_MEAS_MAX_LEN) {
|
|
memset(packed_temp + cursor, 0, (HTPT_TEMP_MEAS_MAX_LEN - cursor));
|
|
}
|
|
|
|
return cursor;
|
|
}
|
|
|
|
void htpt_exe_operation(void) {
|
|
BLE_PRF_HP_FUNC_ENTER();
|
|
|
|
struct htpt_env_tag *htpt_env = PRF_ENV_GET(HTPT, htpt);
|
|
|
|
ASSERT_ERR(htpt_env->operation != NULL);
|
|
|
|
bool finished = true;
|
|
|
|
while (htpt_env->operation->cursor < BLE_CONNECTION_MAX) {
|
|
// check if this type of event is enabled
|
|
if (((htpt_env->ntf_ind_cfg[htpt_env->operation->cursor] &
|
|
htpt_env->operation->op) != 0)
|
|
// and event not filtered on current connection
|
|
&& (htpt_env->operation->conidx != htpt_env->operation->cursor)) {
|
|
// trigger the event
|
|
struct gattc_send_evt_cmd *evt =
|
|
KE_MSG_ALLOC_DYN(GATTC_SEND_EVT_CMD,
|
|
KE_BUILD_ID(TASK_GATTC, htpt_env->operation->cursor),
|
|
prf_src_task_get(&htpt_env->prf_env, 0),
|
|
gattc_send_evt_cmd, htpt_env->operation->length);
|
|
|
|
evt->operation = (htpt_env->operation->op != HTPT_CFG_INTERM_MEAS_NTF)
|
|
? GATTC_INDICATE
|
|
: GATTC_NOTIFY;
|
|
evt->length = htpt_env->operation->length;
|
|
evt->handle = htpt_env->operation->handle;
|
|
memcpy(evt->value, htpt_env->operation->data, evt->length);
|
|
|
|
ke_msg_send(evt);
|
|
|
|
finished = false;
|
|
htpt_env->operation->cursor++;
|
|
break;
|
|
}
|
|
htpt_env->operation->cursor++;
|
|
}
|
|
|
|
// check if operation is finished
|
|
if (finished) {
|
|
// do not send response if operation has been locally requested
|
|
if (htpt_env->operation->dest_id !=
|
|
prf_src_task_get(&htpt_env->prf_env, 0)) {
|
|
// send response to requester
|
|
struct htpt_meas_intv_upd_rsp *rsp = KE_MSG_ALLOC(
|
|
((htpt_env->operation->op == HTPT_CFG_MEAS_INTV_IND)
|
|
? HTPT_MEAS_INTV_UPD_RSP
|
|
: HTPT_TEMP_SEND_RSP),
|
|
htpt_env->operation->dest_id, prf_src_task_get(&htpt_env->prf_env, 0),
|
|
htpt_meas_intv_upd_rsp);
|
|
rsp->status = GAP_ERR_NO_ERROR;
|
|
ke_msg_send(rsp);
|
|
}
|
|
|
|
// free operation
|
|
ke_free(htpt_env->operation);
|
|
htpt_env->operation = NULL;
|
|
// go back to idle state
|
|
ke_state_set(prf_src_task_get(&(htpt_env->prf_env), 0), HTPT_IDLE);
|
|
}
|
|
|
|
BLE_PRF_HP_FUNC_LEAVE();
|
|
}
|
|
|
|
uint8_t htpt_update_ntf_ind_cfg(uint8_t conidx, uint8_t cfg, uint16_t valid_val,
|
|
uint16_t value) {
|
|
struct htpt_env_tag *htpt_env = PRF_ENV_GET(HTPT, htpt);
|
|
uint8_t status = GAP_ERR_NO_ERROR;
|
|
|
|
BLE_PRF_HP_FUNC_ENTER();
|
|
|
|
if ((value != valid_val) && (value != PRF_CLI_STOP_NTFIND)) {
|
|
status = PRF_APP_ERROR;
|
|
|
|
} else if (value == valid_val) {
|
|
htpt_env->ntf_ind_cfg[conidx] |= cfg;
|
|
} else {
|
|
htpt_env->ntf_ind_cfg[conidx] &= ~cfg;
|
|
}
|
|
|
|
if (status == GAP_ERR_NO_ERROR) {
|
|
// inform application that notification/indication configuration has changed
|
|
struct htpt_cfg_indntf_ind *ind = KE_MSG_ALLOC(
|
|
HTPT_CFG_INDNTF_IND, prf_dst_task_get(&htpt_env->prf_env, conidx),
|
|
prf_src_task_get(&htpt_env->prf_env, conidx), htpt_cfg_indntf_ind);
|
|
ind->conidx = conidx;
|
|
ind->ntf_ind_cfg = htpt_env->ntf_ind_cfg[conidx];
|
|
ke_msg_send(ind);
|
|
}
|
|
|
|
BLE_PRF_HP_FUNC_LEAVE();
|
|
|
|
return (status);
|
|
}
|
|
|
|
const struct prf_task_cbs *htpt_prf_itf_get(void) { return &htpt_itf; }
|
|
|
|
uint16_t htpt_att_hdl_get(struct htpt_env_tag *htpt_env, uint8_t att_idx) {
|
|
uint16_t handle = htpt_env->shdl;
|
|
|
|
do {
|
|
// Mandatory attribute handle
|
|
if (att_idx > HTS_IDX_TEMP_MEAS_IND_CFG) {
|
|
handle += HTPT_TEMP_MEAS_ATT_NB;
|
|
} else {
|
|
handle += att_idx;
|
|
break;
|
|
}
|
|
|
|
// Temperature Type
|
|
if ((HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_TEMP_TYPE_CHAR_SUP)) &&
|
|
(att_idx > HTS_IDX_TEMP_TYPE_VAL)) {
|
|
handle += HTPT_TEMP_TYPE_ATT_NB;
|
|
} else if (!HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_TEMP_TYPE_CHAR_SUP)) {
|
|
handle = ATT_INVALID_HANDLE;
|
|
break;
|
|
} else {
|
|
handle += att_idx - HTS_IDX_TEMP_TYPE_CHAR;
|
|
break;
|
|
}
|
|
|
|
// Intermediate Temperature Measurement
|
|
if ((HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_INTERM_TEMP_CHAR_SUP)) &&
|
|
(att_idx > HTS_IDX_INTERM_TEMP_CFG)) {
|
|
handle += HTPT_INTERM_MEAS_ATT_NB;
|
|
} else if (!HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_INTERM_TEMP_CHAR_SUP)) {
|
|
handle = ATT_INVALID_HANDLE;
|
|
break;
|
|
} else {
|
|
handle += att_idx - HTS_IDX_INTERM_TEMP_CHAR;
|
|
break;
|
|
}
|
|
|
|
// Measurement Interval
|
|
if (!HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_MEAS_INTV_CHAR_SUP) ||
|
|
(att_idx >= HTS_IDX_NB)) {
|
|
handle = ATT_INVALID_HANDLE;
|
|
break;
|
|
}
|
|
|
|
if (att_idx <= HTS_IDX_MEAS_INTV_VAL) {
|
|
handle += att_idx - HTS_IDX_MEAS_INTV_CHAR;
|
|
break;
|
|
} else {
|
|
handle += HTPT_MEAS_INTV_ATT_NB;
|
|
}
|
|
|
|
// Measurement Interval Indication
|
|
if (att_idx == HTS_IDX_MEAS_INTV_CFG) {
|
|
if (!HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_MEAS_INTV_IND_SUP)) {
|
|
handle = ATT_INVALID_HANDLE;
|
|
break;
|
|
}
|
|
}
|
|
// Measurement Interval Write permission
|
|
else if (HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_MEAS_INTV_WR_SUP)) {
|
|
handle += HTPT_MEAS_INTV_CCC_ATT_NB;
|
|
|
|
if (!HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_MEAS_INTV_WR_SUP)) {
|
|
handle = ATT_INVALID_HANDLE;
|
|
break;
|
|
}
|
|
}
|
|
} while (0);
|
|
|
|
return handle;
|
|
}
|
|
|
|
uint8_t htpt_att_idx_get(struct htpt_env_tag *htpt_env, uint16_t handle) {
|
|
uint16_t handle_ref = htpt_env->shdl;
|
|
uint8_t att_idx = ATT_INVALID_IDX;
|
|
|
|
do {
|
|
// not valid hande
|
|
if (handle < handle_ref) {
|
|
break;
|
|
}
|
|
|
|
// Mandatory attribute handle
|
|
handle_ref += HTPT_TEMP_MEAS_ATT_NB;
|
|
|
|
if (handle < handle_ref) {
|
|
att_idx = HTS_IDX_TEMP_TYPE_CHAR - (handle_ref - handle);
|
|
break;
|
|
}
|
|
|
|
// Temperature Type
|
|
if (HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_TEMP_TYPE_CHAR_SUP)) {
|
|
handle_ref += HTPT_TEMP_TYPE_ATT_NB;
|
|
|
|
if (handle < handle_ref) {
|
|
att_idx = HTS_IDX_INTERM_TEMP_CHAR - (handle_ref - handle);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Intermediate Temperature Measurement
|
|
if (HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_INTERM_TEMP_CHAR_SUP)) {
|
|
handle_ref += HTPT_INTERM_MEAS_ATT_NB;
|
|
|
|
if (handle < handle_ref) {
|
|
att_idx = HTS_IDX_MEAS_INTV_CHAR - (handle_ref - handle);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Measurement Interval
|
|
if (HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_MEAS_INTV_CHAR_SUP)) {
|
|
handle_ref += HTPT_MEAS_INTV_ATT_NB;
|
|
|
|
if (handle < handle_ref) {
|
|
att_idx = HTS_IDX_MEAS_INTV_CFG - (handle_ref - handle);
|
|
break;
|
|
}
|
|
|
|
if (HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_MEAS_INTV_IND_SUP)) {
|
|
if (handle == handle_ref) {
|
|
att_idx = HTS_IDX_MEAS_INTV_CFG;
|
|
break;
|
|
}
|
|
|
|
handle_ref += HTPT_MEAS_INTV_CCC_ATT_NB;
|
|
}
|
|
|
|
if (HTPT_IS_FEATURE_SUPPORTED(htpt_env->features,
|
|
HTPT_MEAS_INTV_WR_SUP)) {
|
|
if (handle == handle_ref) {
|
|
att_idx = HTS_IDX_MEAS_INTV_VAL_RANGE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} while (0);
|
|
|
|
return att_idx;
|
|
}
|
|
|
|
#endif // BLE_HT_THERMOM
|
|
|
|
/// @} HTPT
|