pinebuds/services/ble_profiles/prf/prf_utils_128.c

165 lines
6.1 KiB
C
Raw Normal View History

2022-08-15 04:20:27 -05:00
/**
****************************************************************************************
* @addtogroup PRF_UTILS
* @{
****************************************************************************************
*/
/*
* INCLUDE FILES
****************************************************************************************
*/
#include "rwip_config.h"
#if (BLE_CLIENT_PRF)
#include <stdint.h>
#include <stdbool.h>
#include "ke_task.h"
#include "co_error.h"
#include "attm.h"
#include "gattc_task.h"
#include "prf_utils_128.h"
#include "ke_mem.h"
#include "gap.h"
#include "gapc.h"
#endif //(BLE_CLIENT_PRF)
#if (BLE_CLIENT_PRF)
void prf_disc_svc_send_128(prf_env_t *prf_env, uint8_t conidx, uint8_t *uuid_128)
{
//send GATT discover primary services by UUID request: find by type request
struct gattc_disc_cmd * svc_req = KE_MSG_ALLOC_DYN(GATTC_SDP_SVC_DISC_CMD,
KE_BUILD_ID(TASK_GATTC, conidx), prf_src_task_get(prf_env, conidx),
gattc_disc_cmd, ATT_UUID_128_LEN);
//gatt request type: by UUID
svc_req->operation = GATTC_SDP_DISC_SVC;
//start handle;
svc_req->start_hdl = ATT_1ST_REQ_START_HDL;
//end handle
svc_req->end_hdl = ATT_1ST_REQ_END_HDL;
// UUID search
svc_req->uuid_len = ATT_UUID_128_LEN;
// set 128 bit UUID for searching
memcpy(&svc_req->uuid[0], uuid_128, (sizeof(uint8_t) * ATT_UUID_128_LEN));
//send the message to GATT, which will send back the response when it gets it
ke_msg_send(svc_req);
}
uint8_t prf_check_svc_char_validity_128(uint8_t nb_chars,
const struct prf_char_inf* chars,
const struct prf_char_def_128* chars_req)
{
uint8_t status = GAP_ERR_NO_ERROR;
uint8_t i;
for(i = 0; ((i < nb_chars) && (status == GAP_ERR_NO_ERROR)); i++)
{
if (chars[i].char_hdl == ATT_INVALID_HANDLE)
{
//If Characteristic is not present, check requirements
if (chars_req[i].req_flag == ATT_MANDATORY)
{
status = PRF_ERR_STOP_DISC_CHAR_MISSING;
}
}
else
{
//If Characteristic is present, check properties
if((chars[i].prop & chars_req[i].prop_mand) != chars_req[i].prop_mand)
{
status = PRF_ERR_STOP_DISC_WRONG_CHAR_PROP;
}
}
}
return status;
}
void prf_extract_svc_info_128(const struct gattc_sdp_svc_ind* param,
uint8_t nb_chars, const struct prf_char_def_128* chars_req, struct prf_char_inf* chars,
uint8_t nb_descs, const struct prf_char_desc_def* descs_req, struct prf_char_desc_inf* descs)
{
//Counters
uint8_t svc_char;
uint8_t svc_desc;
uint8_t fnd_att;
for (fnd_att=0; fnd_att< (param->end_hdl - param->start_hdl); fnd_att++)
{
if(param->info[fnd_att].att_type == GATTC_SDP_ATT_CHAR)
{
uint16_t char_hdl = param->start_hdl+ 1 + fnd_att;
uint16_t val_hdl = param->info[fnd_att].att_char.handle;
uint8_t val_prop = param->info[fnd_att].att_char.prop;
uint8_t char_idx = fnd_att;
// check that value handle is in a valid range
if((val_hdl <= param->end_hdl) && (val_hdl > (param->start_hdl + fnd_att)))
{
// retrieve value index
uint8_t val_idx = (val_hdl - param->start_hdl - 1);
//Look over requested characteristics
for (svc_char=0; svc_char<nb_chars ; svc_char++)
{
// check if attribute is valid
if((chars[svc_char].char_hdl == ATT_INVALID_HDL)
&& attm_uuid_comp((uint8_t*)param->info[val_idx].att.uuid, ATT_UUID_128_LEN,
(uint8_t*)chars_req[svc_char].uuid, ATT_UUID_128_LEN))
{
//Save properties and handles
chars[svc_char].char_hdl = char_hdl;
chars[svc_char].val_hdl = val_hdl;
chars[svc_char].prop = val_prop;
// find end of characteristic handle and discover descriptors
do
{
fnd_att++;
// found a descriptor
if(param->info[fnd_att].att_type == GATTC_SDP_ATT_DESC)
{
//Retrieve characteristic descriptor handle using UUID
for(svc_desc = 0; svc_desc<nb_descs; svc_desc++)
{
// check if it's expected descriptor
if ((descs[svc_desc].desc_hdl == ATT_INVALID_HANDLE)
&& (descs_req[svc_desc].char_code == svc_char)
&& (attm_uuid16_comp((uint8_t*)param->info[fnd_att].att.uuid,
param->info[fnd_att].att.uuid_len, descs_req[svc_desc].uuid)))
{
descs[svc_desc].desc_hdl = param->start_hdl + 1 + fnd_att;
// search for next descriptor
break;
}
}
}
} while(((param->start_hdl+ 1 + fnd_att) <= param->end_hdl)
&& (param->info[fnd_att].att_type != GATTC_SDP_ATT_CHAR)
&& (param->info[fnd_att].att_type != GATTC_SDP_INC_SVC));
// return to previous valid value
fnd_att--;
// previous handle was end of the characteristic
chars[svc_char].char_ehdl_off = fnd_att - char_idx;
// search next characteristic
break;
}
}
}
}
}
}
#endif /*(BLE_SAMPLE128_CLIENT) */
/// @} PRF_UTILS