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 & HTPT_FLAG_TIME) == HTPT_FLAG_TIME)
{
cursor += prf_pack_date_time(packed_temp + cursor, &(temp_meas.time_stamp));
}
//Type flag set
if ((temp_meas.flags & HTPT_FLAG_TYPE) == HTPT_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;
}
/**
****************************************************************************************
* @brief Handles reception of the @ref CSCPC_CFG_NTFIND_CMD message.
* @param[in] msgid Id of the message received.
* @param[in] param Pointer to the parameters of the message.
* @param[in] dest_id ID of the receiving task instance.
* @param[in] src_id ID of the sending task instance.
* @return If the message was consumed or not.
****************************************************************************************
*/
static int cscpc_ctnl_pt_cfg_cmd_handler(ke_msg_id_t const msgid,
struct cscpc_ctnl_pt_cfg_cmd *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
// Message status
uint8_t msg_status = KE_MSG_CONSUMED;
// Get the address of the environment
struct cscpc_env_tag *cscpc_env = PRF_CLIENT_GET_ENV(dest_id, cscpc);
if (cscpc_env != NULL)
{
// Status
uint8_t status = PRF_ERR_OK;
do
{
// State is Connected or Busy
ASSERT_ERR(ke_state_get(dest_id) > CSCPC_IDLE);
// Check the provided connection handle
if (param->conhdl != cscpc_env->con_info.conhdl)
{
status = PRF_ERR_INVALID_PARAM;
break;
}
if (ke_state_get(dest_id) == CSCPC_BUSY)
{
// Another procedure is pending, keep the command for later
msg_status = KE_MSG_SAVED;
// Status is PRF_ERR_OK, no message will be sent to the application
break;
}
// Check if the characteristic has been found
if (cscpc_env->cscs.descs[CSCPC_DESC_SC_CTNL_PT_CL_CFG].desc_hdl != ATT_INVALID_SEARCH_HANDLE)
{
// Packed request
uint8_t req[CSCP_SC_CNTL_PT_REQ_MAX_LEN];
// Request Length
uint8_t req_len = CSCP_SC_CNTL_PT_REQ_MIN_LEN;
// Set the operation code
req[0] = param->sc_ctnl_pt.op_code;
// Fulfill the message according to the operation code
switch (param->sc_ctnl_pt.op_code)
{
case (CSCP_CTNL_PT_OP_SET_CUMUL_VAL):
{
// Set the cumulative value
co_write32p(&req[1], param->sc_ctnl_pt.value.cumul_val);
// Update length
req_len += 4;
} break;
case (CSCP_CTNL_PT_OP_UPD_LOC):
{
// Set the sensor location
req[1] = param->sc_ctnl_pt.value.sensor_loc;
// Update length
req_len++;
} break;
case (CSCP_CTNL_PT_OP_RESERVED):
case (CSCP_CTNL_PT_OP_START_CALIB):
case (CSCP_CTNL_PT_OP_REQ_SUPP_LOC):
{
// Nothing more to do
} break;
default:
{
status = PRF_ERR_INVALID_PARAM;
} break;
}
if (status == PRF_ERR_OK)
{
// Set the operation code
param->operation = CSCPC_CTNL_PT_CFG_WR_OP_CODE;
// Store the command structure
cscpc_env->operation = param;
// Store the command information
msg_status = KE_MSG_NO_FREE;
// Go to the Busy state
ke_state_set(dest_id, CSCPC_BUSY);
// Send the write request
prf_gatt_write(&(cscpc_env->con_info), cscpc_env->cscs.chars[CSCP_CSCS_SC_CTNL_PT_CHAR].val_hdl,
(uint8_t *)&req[0], req_len, GATT_WRITE_CHAR);
}
}
else
{
status = PRF_ERR_INEXISTENT_HDL;
}
} while (0);
if (status != PRF_ERR_OK)
{
// Send a complete event status to the application
cscpc_send_cmp_evt(cscpc_env, CSCPC_CTNL_PT_CFG_WR_OP_CODE, status);
}
}
else
{
// No connection
cscpc_send_no_conn_cmp_evt(dest_id, src_id, param->conhdl, CSCPC_CTNL_PT_CFG_WR_OP_CODE);
}
return (int)msg_status;
}