rudism
/
pinebuds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pinebuds/services/ble_profiles/cpp/cppc/src/cppc.c

685 lines
22 KiB
C
Raw Blame History

/**
****************************************************************************************
* @addtogroup CPPC
* @{
****************************************************************************************
*/
/*
* INCLUDE FILES
****************************************************************************************
*/
#include "rwip_config.h"
#if (BLE_CP_COLLECTOR)
#include "cpp_common.h"
#include "cppc.h"
#include "cppc_task.h"
#include "ke_timer.h"
#include "co_utils.h"
#include "ke_mem.h"
/*
* GLOBAL VARIABLES DECLARATION
****************************************************************************************
*/
/*
* LOCAL FUNCTION DEFINITIONS
****************************************************************************************
*/
/**
****************************************************************************************
* @brief Initialization of the CPPC module.
* This function performs all the initializations of the Profile module.
* - Creation of database (if it's a service)
* - Allocation of profile required memory
* - Initialization of task descriptor to register application
* - Task State array
* - Number of tasks
* - Default task handler
*
* @param[out] env Collector or Service allocated environment data.
* @param[in|out] start_hdl Service start handle (0 - dynamically allocated),
*only applies for services.
* @param[in] app_task Application task number.
* @param[in] sec_lvl Security level (AUTH, EKS and MI field of @see enum
*attm_value_perm_mask)
* @param[in] param Configuration parameters of profile collector or
*service (32 bits aligned)
*
* @return status code to know if profile initialization succeed or not.
****************************************************************************************
*/
static uint8_t cppc_init(struct prf_task_env *env, uint16_t *start_hdl,
uint16_t app_task, uint8_t sec_lvl, void *params) {
uint8_t idx;
//-------------------- allocate memory required for the profile
//---------------------
struct cppc_env_tag *cppc_env = (struct cppc_env_tag *)ke_malloc(
sizeof(struct cppc_env_tag), KE_MEM_ATT_DB);
// allocate CPPC required environment variable
env->env = (prf_env_t *)cppc_env;
cppc_env->prf_env.app_task =
app_task | (PERM_GET(sec_lvl, SVC_MI) ? PERM(PRF_MI, ENABLE)
: PERM(PRF_MI, DISABLE));
cppc_env->prf_env.prf_task = env->task | PERM(PRF_MI, ENABLE);
// initialize environment variable
env->id = TASK_ID_CPPC;
cppc_task_init(&(env->desc));
for (idx = 0; idx < CPPC_IDX_MAX; idx++) {
cppc_env->env[idx] = NULL;
// service is ready, go into an Idle state
ke_state_set(KE_BUILD_ID(env->task, idx), CPPC_FREE);
}
return GAP_ERR_NO_ERROR;
}
/**
****************************************************************************************
* @brief Clean-up connection dedicated environment parameters
* This function performs cleanup of ongoing operations
* @param[in|out] env Collector or Service allocated environment data.
* @param[in] conidx Connection index
* @param[in] reason Detach reason
****************************************************************************************
*/
static void cppc_cleanup(struct prf_task_env *env, uint8_t conidx,
uint8_t reason) {
struct cppc_env_tag *cppc_env = (struct cppc_env_tag *)env->env;
// clean-up environment variable allocated for task instance
if (cppc_env->env[conidx] != NULL) {
if (cppc_env->env[conidx]->operation != NULL) {
ke_free(ke_param2msg(cppc_env->env[conidx]->operation));
}
ke_timer_clear(CPPC_TIMEOUT_TIMER_IND,
prf_src_task_get(&cppc_env->prf_env, conidx));
ke_free(cppc_env->env[conidx]);
cppc_env->env[conidx] = NULL;
}
/* Put CPP Client in Free state */
ke_state_set(KE_BUILD_ID(env->task, conidx), CPPC_FREE);
}
/**
****************************************************************************************
* @brief Destruction of the CPPC module - due to a reset for instance.
* This function clean-up allocated memory (attribute database is destroyed by
*another procedure)
*
* @param[in|out] env Collector or Service allocated environment data.
****************************************************************************************
*/
static void cppc_destroy(struct prf_task_env *env) {
uint8_t idx;
struct cppc_env_tag *cppc_env = (struct cppc_env_tag *)env->env;
// cleanup environment variable for each task instances
for (idx = 0; idx < CPPC_IDX_MAX; idx++) {
cppc_cleanup(env, idx, 0);
}
// free profile environment variables
env->env = NULL;
ke_free(cppc_env);
}
/**
****************************************************************************************
* @brief Handles Connection creation
*
* @param[in|out] env Collector or Service allocated environment data.
* @param[in] conidx Connection index
****************************************************************************************
*/
static void cppc_create(struct prf_task_env *env, uint8_t conidx) {
/* Put CPP Client in Idle state */
ke_state_set(KE_BUILD_ID(env->task, conidx), CPPC_IDLE);
}
/// CPPC Task interface required by profile manager
const struct prf_task_cbs cppc_itf = {
cppc_init,
cppc_destroy,
cppc_create,
cppc_cleanup,
};
/*
* GLOBAL FUNCTIONS DEFINITIONS
****************************************************************************************
*/
const struct prf_task_cbs *cppc_prf_itf_get(void) { return &cppc_itf; }
void cppc_enable_rsp_send(struct cppc_env_tag *cppc_env, uint8_t conidx,
uint8_t status) {
// Send to APP the details of the discovered attributes on CPPS
struct cppc_enable_rsp *rsp = KE_MSG_ALLOC(
CPPC_ENABLE_RSP, prf_dst_task_get(&(cppc_env->prf_env), conidx),
prf_src_task_get(&(cppc_env->prf_env), conidx), cppc_enable_rsp);
rsp->status = status;
if (status == GAP_ERR_NO_ERROR) {
rsp->cps = cppc_env->env[conidx]->cps;
// Register CPPC task in gatt for indication/notifications
prf_register_atthdl2gatt(&(cppc_env->prf_env), conidx,
&(cppc_env->env[conidx]->cps.svc));
// Go to connected state
ke_state_set(prf_src_task_get(&(cppc_env->prf_env), conidx), CPPC_IDLE);
}
ke_msg_send(rsp);
}
void cppc_send_no_conn_cmp_evt(uint8_t src_id, uint8_t dest_id,
uint8_t operation) {
// Send the message
struct cppc_cmp_evt *evt =
KE_MSG_ALLOC(CPPC_CMP_EVT, dest_id, src_id, cppc_cmp_evt);
evt->operation = operation;
evt->status = PRF_ERR_REQ_DISALLOWED;
ke_msg_send(evt);
}
void cppc_send_cmp_evt(struct cppc_env_tag *cppc_env, uint8_t conidx,
uint8_t operation, uint8_t status) {
// Free the stored operation if needed
if (cppc_env->env[conidx]->operation != NULL) {
ke_msg_free(ke_param2msg(cppc_env->env[conidx]->operation));
cppc_env->env[conidx]->operation = NULL;
}
// Go back to the IDLE state if the state is busy
if (ke_state_get(prf_src_task_get(&(cppc_env->prf_env), conidx)) ==
CPPC_BUSY) {
ke_state_set(prf_src_task_get(&cppc_env->prf_env, conidx), CPPC_IDLE);
}
// Send the message
struct cppc_cmp_evt *evt = KE_MSG_ALLOC(
CPPC_CMP_EVT, prf_dst_task_get(&(cppc_env->prf_env), conidx),
prf_src_task_get(&(cppc_env->prf_env), conidx), cppc_cmp_evt);
evt->operation = operation;
evt->status = status;
ke_msg_send(evt);
}
/*
* LOCAL FUNCTIONS DEFINITIONS
****************************************************************************************
*/
uint16_t cppc_get_read_handle_req(struct cppc_env_tag *cppc_env, uint8_t conidx,
struct cpps_read_cmd *param) {
// Attribute Handle
uint16_t handle = ATT_INVALID_SEARCH_HANDLE;
switch (param->read_code) {
// Read CP Feature
case (CPPC_RD_CP_FEAT): {
handle = cppc_env->env[conidx]->cps.chars[CPP_CPS_FEAT_CHAR].val_hdl;
} break;
// Read Sensor Location
case (CPPC_RD_SENSOR_LOC): {
handle = cppc_env->env[conidx]->cps.chars[CPP_CPS_SENSOR_LOC_CHAR].val_hdl;
} break;
// Read CP Measurement Characteristic Client Char. Cfg. Descriptor Value
case (CPPC_RD_WR_CP_MEAS_CL_CFG): {
handle =
cppc_env->env[conidx]->cps.descs[CPPC_DESC_CP_MEAS_CL_CFG].desc_hdl;
} break;
// Read CP Measurement Characteristic Server Char. Cfg. Descriptor Value
case (CPPC_RD_WR_CP_MEAS_SV_CFG): {
handle =
cppc_env->env[conidx]->cps.descs[CPPC_DESC_CP_MEAS_SV_CFG].desc_hdl;
} break;
// Read CP Vector Characteristic Server Char. Cfg. Descriptor Value
case (CPPC_RD_WR_VECTOR_CFG): {
handle = cppc_env->env[conidx]->cps.descs[CPPC_DESC_VECTOR_CL_CFG].desc_hdl;
} break;
// Read Unread Alert Characteristic Client Char. Cfg. Descriptor Value
case (CPPC_RD_WR_CTNL_PT_CFG): {
handle =
cppc_env->env[conidx]->cps.descs[CPPC_DESC_CTNL_PT_CL_CFG].desc_hdl;
} break;
default: {
handle = ATT_INVALID_SEARCH_HANDLE;
} break;
}
return handle;
}
uint8_t cppc_get_write_desc_handle_req(uint8_t conidx,
struct cppc_cfg_ntfind_cmd *param,
struct cppc_env_tag *cppc_env,
uint16_t *handle) {
// Status
uint8_t status = GAP_ERR_NO_ERROR;
switch (param->desc_code) {
// Write CP Measurement Characteristic Client Char. Cfg. Descriptor Value
case (CPPC_RD_WR_CP_MEAS_CL_CFG): {
if (param->ntfind_cfg <= PRF_CLI_START_NTF) {
*handle =
cppc_env->env[conidx]->cps.descs[CPPC_DESC_CP_MEAS_CL_CFG].desc_hdl;
// The descriptor is mandatory
ASSERT_ERR(*handle != ATT_INVALID_SEARCH_HANDLE);
} else {
status = PRF_ERR_INVALID_PARAM;
}
} break;
// Write CP Measurement Characteristic Server Char. Cfg. Descriptor Value
case (CPPC_RD_WR_CP_MEAS_SV_CFG): {
if (param->ntfind_cfg <= PRF_SRV_START_BCST) {
*handle =
cppc_env->env[conidx]->cps.descs[CPPC_DESC_CP_MEAS_SV_CFG].desc_hdl;
if (*handle == ATT_INVALID_SEARCH_HANDLE) {
// The descriptor has not been found.
status = PRF_ERR_INEXISTENT_HDL;
}
} else {
status = PRF_ERR_INVALID_PARAM;
}
} break;
// Write CP Vector Characteristic Client Char. Cfg. Descriptor Value
case (CPPC_RD_WR_VECTOR_CFG): {
if (param->ntfind_cfg <= PRF_CLI_START_NTF) {
*handle =
cppc_env->env[conidx]->cps.descs[CPPC_DESC_VECTOR_CL_CFG].desc_hdl;
if (*handle == ATT_INVALID_SEARCH_HANDLE) {
// The descriptor has not been found.
status = PRF_ERR_INEXISTENT_HDL;
}
} else {
status = PRF_ERR_INVALID_PARAM;
}
} break;
// Write SC Control Point Characteristic Client Char. Cfg. Descriptor Value
case (CPPC_RD_WR_CTNL_PT_CFG): {
if ((param->ntfind_cfg == PRF_CLI_STOP_NTFIND) ||
(param->ntfind_cfg == PRF_CLI_START_IND)) {
*handle =
cppc_env->env[conidx]->cps.descs[CPPC_DESC_CTNL_PT_CL_CFG].desc_hdl;
if (*handle == ATT_INVALID_SEARCH_HANDLE) {
// The descriptor has not been found.
status = PRF_ERR_INEXISTENT_HDL;
}
} else {
status = PRF_ERR_INVALID_PARAM;
}
} break;
default: {
status = PRF_ERR_INVALID_PARAM;
} break;
}
return (status);
}
uint8_t cppc_unpack_meas_ind(uint8_t conidx,
struct gattc_event_ind const *param,
struct cppc_env_tag *cppc_env) {
// CP Measurement value has been received
struct cppc_value_meas_ind *ind = KE_MSG_ALLOC(
CPPC_VALUE_IND, prf_dst_task_get(&(cppc_env->prf_env), conidx),
prf_src_task_get(&(cppc_env->prf_env), conidx), cppc_value_meas_ind);
// Offset
uint8_t offset = CPP_CP_MEAS_NTF_MIN_LEN;
// Attribute code
ind->att_code = CPPC_NTF_CP_MEAS;
// Flags
ind->value.cp_meas.flags = co_read16p(&param->value[0]);
// Instant power
ind->value.cp_meas.inst_power = co_read16p(&param->value[2]);
if (ind->value.cp_meas.flags & CPP_MEAS_PEDAL_POWER_BALANCE_PRESENT) {
// Unpack Pedal Power Balance info
ind->value.cp_meas.pedal_power_balance = param->value[offset];
offset++;
}
if (ind->value.cp_meas.flags & CPP_MEAS_ACCUM_TORQUE_PRESENT) {
// Unpack Accumulated Torque info
ind->value.cp_meas.accum_torque = co_read16p(&param->value[offset]);
offset += 2;
}
if (ind->value.cp_meas.flags & CPP_MEAS_WHEEL_REV_DATA_PRESENT) {
// Unpack Wheel Revolution Data (Cumulative Wheel & Last Wheel Event Time)
ind->value.cp_meas.cumul_wheel_rev = co_read32p(&param->value[offset]);
offset += 4;
ind->value.cp_meas.last_wheel_evt_time = co_read16p(&param->value[offset]);
offset += 2;
}
if (ind->value.cp_meas.flags & CPP_MEAS_CRANK_REV_DATA_PRESENT) {
// Unpack Crank Revolution Data (Cumulative Crank & Last Crank Event Time)
ind->value.cp_meas.cumul_crank_rev = co_read16p(&param->value[offset]);
offset += 2;
ind->value.cp_meas.last_crank_evt_time = co_read16p(&param->value[offset]);
offset += 2;
}
if (ind->value.cp_meas.flags & CPP_MEAS_EXTREME_FORCE_MAGNITUDES_PRESENT) {
// Unpack Extreme Force Magnitudes (Maximum Force Magnitude & Minimum Force
// Magnitude)
ind->value.cp_meas.max_force_magnitude = co_read16p(&param->value[offset]);
offset += 2;
ind->value.cp_meas.min_force_magnitude = co_read16p(&param->value[offset]);
offset += 2;
}
else if (ind->value.cp_meas.flags &
CPP_MEAS_EXTREME_TORQUE_MAGNITUDES_PRESENT) {
// Unpack Extreme Force Magnitudes (Maximum Force Magnitude & Minimum Force
// Magnitude)
ind->value.cp_meas.max_torque_magnitude = co_read16p(&param->value[offset]);
offset += 2;
ind->value.cp_meas.min_torque_magnitude = co_read16p(&param->value[offset]);
offset += 2;
}
if (ind->value.cp_meas.flags & CPP_MEAS_EXTREME_ANGLES_PRESENT) {
// Unpack Extreme Angles (Maximum Angle & Minimum Angle)
uint32_t angle = co_read24p(&param->value[offset]);
offset += 3;
// Force to 12 bits
ind->value.cp_meas.max_angle = (angle & (0x0FFF));
ind->value.cp_meas.min_angle = ((angle >> 12) & 0x0FFF);
}
if (ind->value.cp_meas.flags & CPP_MEAS_TOP_DEAD_SPOT_ANGLE_PRESENT) {
// Unpack Top Dead Spot Angle
ind->value.cp_meas.top_dead_spot_angle = co_read16p(&param->value[offset]);
offset += 2;
}
if (ind->value.cp_meas.flags & CPP_MEAS_BOTTOM_DEAD_SPOT_ANGLE_PRESENT) {
// Unpack Bottom Dead Spot Angle
ind->value.cp_meas.bot_dead_spot_angle = co_read16p(&param->value[offset]);
offset += 2;
}
if (ind->value.cp_meas.flags & CPP_MEAS_ACCUM_ENERGY_PRESENT) {
// Unpack Accumulated Energy
ind->value.cp_meas.accum_energy = co_read16p(&param->value[offset]);
offset += 2;
}
// Send the message
ke_msg_send(ind);
return offset;
}
uint8_t cppc_unpack_vector_ind(uint8_t conidx,
struct gattc_event_ind const *param,
struct cppc_env_tag *cppc_env) {
// CP Measurement value has been received
struct cppc_value_ind *ind = KE_MSG_ALLOC_DYN(
CPPC_VALUE_IND, prf_dst_task_get(&cppc_env->prf_env, conidx),
prf_src_task_get(&cppc_env->prf_env, conidx), cppc_value_ind,
param->length);
// Offset
uint8_t offset = CPP_CP_VECTOR_MIN_LEN;
// Attribute code
ind->att_code = CPPC_NTF_CP_VECTOR;
// Flags
ind->value.cp_vector.flags = param->value[0];
if (ind->value.cp_vector.flags & CPP_VECTOR_CRANK_REV_DATA_PRESENT) {
// Unpack Crank Revolution Data
ind->value.cp_vector.cumul_crank_rev = co_read16p(&param->value[offset]);
offset += 2;
// Unpack Last Crank Evt time
ind->value.cp_vector.last_crank_evt_time =
co_read16p(&param->value[offset]);
offset += 2;
}
if (ind->value.cp_vector.flags & CPP_VECTOR_FIRST_CRANK_MEAS_ANGLE_PRESENT) {
// Unpack First Crank Measurement Angle
ind->value.cp_vector.first_crank_meas_angle =
co_read16p(&param->value[offset]);
offset += 2;
}
if (!(ind->value.cp_vector.flags &
CPP_VECTOR_INST_FORCE_MAGNITUDE_ARRAY_PRESENT) !=
!(ind->value.cp_vector.flags &
CPP_VECTOR_INST_TORQUE_MAGNITUDE_ARRAY_PRESENT)) {
// Unpack Force or Torque magnitude (mutually excluded)
ind->value.cp_vector.nb = (param->length - offset) / 2;
if (ind->value.cp_vector.nb) {
for (int i = 0; i < ind->value.cp_vector.nb; i++) {
// Handle the array buffer to extract parameters
ind->value.cp_vector.force_torque_magnitude[i] =
co_read16p(&param->value[offset]);
offset += 2;
}
}
}
// if ((ind->value.cp_vector.flags & CPP_VECTOR_INST_MEAS_DIRECTION_LSB) ||
// (ind->value.cp_vector.flags &
// CPP_VECTOR_INST_MEAS_DIRECTION_MSB))
// {
//
// }
// Send the message
ke_msg_send(ind);
return offset;
}
uint8_t cppc_pack_ctnl_pt_req(struct cppc_ctnl_pt_cfg_req *param, uint8_t *req,
uint8_t *status) {
// Request Length
uint8_t req_len = CPP_CP_CNTL_PT_REQ_MIN_LEN;
// Set the operation code
req[0] = param->ctnl_pt.op_code;
// Fulfill the message according to the operation code
switch (param->ctnl_pt.op_code) {
case (CPP_CTNL_PT_SET_CUMUL_VAL): {
// Set the cumulative value
co_write32p(&req[req_len], param->ctnl_pt.value.cumul_val);
// Update length
req_len += 4;
} break;
case (CPP_CTNL_PT_UPD_SENSOR_LOC): {
// Set the sensor location
req[req_len] = param->ctnl_pt.value.sensor_loc;
// Update length
req_len++;
} break;
case (CPP_CTNL_PT_SET_CRANK_LENGTH): {
// Set the crank length
co_write16p(&req[req_len], param->ctnl_pt.value.crank_length);
// Update length
req_len += 2;
} break;
case (CPP_CTNL_PT_SET_CHAIN_LENGTH): {
// Set the chain length
co_write16p(&req[req_len], param->ctnl_pt.value.chain_length);
// Update length
req_len += 2;
} break;
case (CPP_CTNL_PT_SET_CHAIN_WEIGHT): {
// Set the chain weight
co_write16p(&req[req_len], param->ctnl_pt.value.chain_weight);
// Update length
req_len += 2;
} break;
case (CPP_CTNL_PT_SET_SPAN_LENGTH): {
// Set the span length
co_write16p(&req[req_len], param->ctnl_pt.value.span_length);
// Update length
req_len += 2;
} break;
case (CPP_CTNL_MASK_CP_MEAS_CH_CONTENT): {
// Set the Content Mask
co_write16p(&req[req_len], param->ctnl_pt.value.mask_content);
// Update length
req_len += 2;
} break;
case (CPP_CTNL_PT_REQ_SUPP_SENSOR_LOC):
case (CPP_CTNL_PT_REQ_CRANK_LENGTH):
case (CPP_CTNL_PT_REQ_CHAIN_LENGTH):
case (CPP_CTNL_PT_REQ_CHAIN_WEIGHT):
case (CPP_CTNL_PT_REQ_SPAN_LENGTH):
case (CPP_CTNL_PT_START_OFFSET_COMP):
case (CPP_CTNL_REQ_SAMPLING_RATE):
case (CPP_CTNL_REQ_FACTORY_CALIBRATION_DATE): {
// Nothing more to do
} break;
default: {
*status = PRF_ERR_INVALID_PARAM;
} break;
}
return req_len;
}
uint8_t cppc_unpack_ctln_pt_ind(uint8_t conidx,
struct gattc_event_ind const *param,
struct cppc_env_tag *cppc_env) {
// Offset
uint8_t offset = CPP_CP_CNTL_PT_RSP_MIN_LEN;
// Control Point value has been received
struct cppc_ctnl_pt_rsp *ind = KE_MSG_ALLOC(
CPPC_CTNL_PT_RSP, prf_dst_task_get(&cppc_env->prf_env, conidx),
prf_src_task_get(&cppc_env->prf_env, conidx), cppc_ctnl_pt_rsp);
// Requested operation code
ind->rsp.req_op_code = param->value[1];
// Response value
ind->rsp.resp_value = param->value[2];
if ((ind->rsp.resp_value == CPP_CTNL_PT_RESP_SUCCESS) &&
(param->length >= 3)) {
switch (ind->rsp.req_op_code) {
case (CPP_CTNL_PT_REQ_SUPP_SENSOR_LOC): {
// Get the number of supported locations that have been received
uint8_t nb_supp_loc = (param->length - 3);
// Location
uint8_t loc;
for (uint8_t counter = 0; counter < nb_supp_loc; counter++) {
loc = param->value[counter + CPP_CP_CNTL_PT_RSP_MIN_LEN];
// Check if valid
if (loc < CPP_LOC_MAX) {
ind->rsp.value.supp_loc |= (1 << loc);
}
offset++;
}
} break;
case (CPP_CTNL_PT_REQ_CRANK_LENGTH): {
ind->rsp.value.crank_length = co_read16p(&param->value[offset]);
offset += 2;
} break;
case (CPP_CTNL_PT_REQ_CHAIN_LENGTH): {
ind->rsp.value.chain_length = co_read16p(&param->value[offset]);
offset += 2;
} break;
case (CPP_CTNL_PT_REQ_CHAIN_WEIGHT): {
ind->rsp.value.chain_weight = co_read16p(&param->value[offset]);
offset += 2;
} break;
case (CPP_CTNL_PT_REQ_SPAN_LENGTH): {
ind->rsp.value.span_length = co_read16p(&param->value[offset]);
offset += 2;
} break;
case (CPP_CTNL_PT_START_OFFSET_COMP): {
ind->rsp.value.offset_comp = co_read16p(&param->value[offset]);
offset += 2;
} break;
case (CPP_CTNL_REQ_SAMPLING_RATE): {
ind->rsp.value.sampling_rate = param->value[offset];
offset++;
} break;
case (CPP_CTNL_REQ_FACTORY_CALIBRATION_DATE): {
offset += prf_unpack_date_time((uint8_t *)&(param->value[offset]),
&(ind->rsp.value.factory_calibration));
} break;
case (CPP_CTNL_PT_SET_CUMUL_VAL):
case (CPP_CTNL_PT_UPD_SENSOR_LOC):
case (CPP_CTNL_PT_SET_CRANK_LENGTH):
case (CPP_CTNL_PT_SET_CHAIN_LENGTH):
case (CPP_CTNL_PT_SET_CHAIN_WEIGHT):
case (CPP_CTNL_PT_SET_SPAN_LENGTH):
case (CPP_CTNL_MASK_CP_MEAS_CH_CONTENT): {
// No parameters
} break;
default: {
} break;
}
}
// Send the message
ke_msg_send(ind);
return offset;
}
#endif //(BLE_CP_COLLECTOR)
/// @} CPP
Reference in New Issue View Git Blame Copy Permalink