void ble_agsensor_create_sensor_read_data_msg(void) {
hvx_p_config_len = 0;
(hvx_p_config_len) += uint16_encode(BLE_AGSENSOR_CONFIGURATION_OPCODE_START_MEASUREMENT, &hvx_encoded_buffer[hvx_p_config_len]);
// Add the sensor count in the sending msg
uint8_t indice = sentek_measurement_get_Indice_toSend();
hvx_encoded_buffer[hvx_p_config_len] = indice;
hvx_p_config_len ++;
// Add the time-stamp value in the sending msg
(hvx_p_config_len) += uint32_encode(sentek_get_measurement(indice, SENTEK_RESULT_DATA_TIMESTAMP), &hvx_encoded_buffer[hvx_p_config_len]);
// Add the temperature value in the sending msg
uint32_t temp = sentek_get_measurement_float(indice, SENTEK_RESULT_DATA_TEMPERATURE);
// char* tempfloat = &temp;
(hvx_p_config_len) += uint32_encode(temp, &hvx_encoded_buffer[hvx_p_config_len]);
// Add the moisture value in the sending msg
// (hvx_p_config_len) += uint32_encode(sentek_get_measurement(indice, SENTEK_RESULT_DATA_MOISTURE), &hvx_encoded_buffer[hvx_p_config_len]);
(hvx_p_config_len) += uint32_encode(sentek_get_measurement_float(indice, SENTEK_RESULT_DATA_MOISTURE), &hvx_encoded_buffer[hvx_p_config_len]);
// Add the salinity value in the sending msg
// (hvx_p_config_len) += uint32_encode(sentek_get_measurement(indice, SENTEK_RESULT_DATA_SALINITY), &hvx_encoded_buffer[hvx_p_config_len]);
(hvx_p_config_len) += uint32_encode(sentek_get_measurement_float(indice, SENTEK_RESULT_DATA_SALINITY), &hvx_encoded_buffer[hvx_p_config_len]);
}
/**@brief Function for encoding a ITU Sensor Service Measurement.
*
* @param[in] p_iss ITU Sensor Service structure.
* @param[in] measurement Measurement to be encoded.
* @param[out] p_encoded_buffer Buffer where the encoded data will be written.
*
* @return Size of encoded data.
*/
static uint8_t iss_measurement_encode(iss_t * p_iss, int32_t * measurement,uint8_t * p_encoded_buffer,uint32_t * value)
{
uint8_t flags = 0;
uint8_t len = 1;
//Value always present
*value = (((p_iss->IEEE_exponent << 24) & 0xFF000000) | (*measurement & 0x00FFFFFF));
len += uint32_encode(*value, &p_encoded_buffer[len]);
//Remember, to increament the seq nr so we have a continuous flow
++(p_iss->curr_seq_nr);
// Space + Time value
if (p_iss->space_time_present)
{
flags |= ITS_MEAS_FLAG_SPACE_TIME_BIT;
p_encoded_buffer[len++] = p_iss->coord;
len += uint16_encode(p_iss->curr_seq_nr, &p_encoded_buffer[len]);
}
// Unit value
if (p_iss->unit_present)
{
flags |= ITS_MEAS_FLAG_UNIT_BIT;
len += uint16_encode(p_iss->unit, &p_encoded_buffer[len]);
}
// Type value
if (p_iss->type_make_present)
{
flags |= ITS_MEAS_FLAG_TYPE_MAKE_BIT;
p_encoded_buffer[len++] = p_iss->type;
p_encoded_buffer[len++] = p_iss->make;
}
// ID field
if (p_iss->ID_present)
{
flags |= ITS_MEAS_FLAG_ID_BIT;
len += uint16_encode(p_iss->ID, &p_encoded_buffer[len]);
}
// Sampling Frequency field
if (p_iss->samp_freq_present)
{
flags |= ITS_MEAS_FLAG_SAMP_FREQ_BIT;
len += uint32_encode(p_iss->samp_freq_in_m_sec, &p_encoded_buffer[len]);
}
// Flags field
p_encoded_buffer[0] = flags;
return len;
}
static void response_send(serial_dfu_t * p_dfu,
serial_dfu_response_t * p_response)
{
uint8_t response_buffer[MAX_RESPONSE_SIZE];
uint8_t encoded_response[MAX_RESPONSE_SIZE*2 + 1];
uint32_t encoded_response_length;
uint16_t index = 0;
NRF_LOG_DEBUG("Sending Response: [0x%01x, 0x%01x]\r\n", p_response->op_code, p_response->resp_val);
response_buffer[index++] = SERIAL_DFU_OP_CODE_RESPONSE;
// Encode the Request Op code
response_buffer[index++] = p_response->op_code;
// Encode the Response Value.
response_buffer[index++] = (uint8_t)p_response->resp_val;
if (p_response->resp_val == NRF_DFU_RES_CODE_SUCCESS)
{
switch (p_response->op_code)
{
case SERIAL_DFU_OP_CODE_CALCULATE_CRC:
index += uint32_encode(p_response->crc_response.offset, &response_buffer[index]);
index += uint32_encode(p_response->crc_response.crc, &response_buffer[index]);
break;
case SERIAL_DFU_OP_CODE_SELECT_OBJECT:
index += uint32_encode(p_response->select_response.max_size, &response_buffer[index]);
index += uint32_encode(p_response->select_response.offset, &response_buffer[index]);
index += uint32_encode(p_response->select_response.crc, &response_buffer[index]);
break;
case SERIAL_DFU_OP_CODE_GET_SERIAL_MTU:
index += uint16_encode(p_response->serial_mtu_response.mtu, &response_buffer[index]);
break;
default:
// no implementation
break;
}
}
// encode into slip
(void)slip_encode(encoded_response, response_buffer, index, &encoded_response_length);
// send
(void)nrf_drv_uart_tx(&p_dfu->uart_instance, encoded_response, encoded_response_length);
}
/**@brief Function for encoding a CSCS Measurement.
*
* @param[in] p_cscs Cycling Speed and Cadence Service structure.
* @param[in] p_csc_measurement Measurement to be encoded.
* @param[out] p_encoded_buffer Buffer where the encoded data will be written.
*
* @return Size of encoded data.
*/
static uint8_t csc_measurement_encode(ble_cscs_t * p_cscs,
ble_cscs_meas_t * p_csc_measurement,
uint8_t * p_encoded_buffer)
{
uint8_t flags = 0;
uint8_t len = 1;
// Cumulative Wheel Revolutions and Last Wheel Event Time Fields
if (p_cscs->feature & BLE_CSCS_FEATURE_WHEEL_REV_BIT)
{
if (p_csc_measurement->is_wheel_rev_data_present)
{
flags |= CSC_MEAS_FLAG_MASK_WHEEL_REV_DATA_PRESENT;
len += uint32_encode(p_csc_measurement->cumulative_wheel_revs, &p_encoded_buffer[len]);
len += uint16_encode(p_csc_measurement->last_wheel_event_time, &p_encoded_buffer[len]);
}
}
// Cumulative Crank Revolutions and Last Crank Event Time Fields
if (p_cscs->feature & BLE_CSCS_FEATURE_CRANK_REV_BIT)
{
if (p_csc_measurement->is_crank_rev_data_present)
{
flags |= CSC_MEAS_FLAG_MASK_CRANK_REV_DATA_PRESENT;
len += uint16_encode(p_csc_measurement->cumulative_crank_revs, &p_encoded_buffer[len]);
len += uint16_encode(p_csc_measurement->last_crank_event_time, &p_encoded_buffer[len]);
}
}
// Flags Field
p_encoded_buffer[0] = flags;
return len;
}
uint32_t ble_dfu_pkts_rcpt_notify(ble_dfu_t * p_dfu, uint32_t num_of_firmware_bytes_rcvd)
{
if (p_dfu == NULL)
{
return NRF_ERROR_NULL;
}
if ((p_dfu->conn_handle == BLE_CONN_HANDLE_INVALID) || !m_is_dfu_service_initialized)
{
return NRF_ERROR_INVALID_STATE;
}
ble_gatts_hvx_params_t hvx_params;
uint16_t index = 0;
m_notif_buffer[index++] = OP_CODE_PKT_RCPT_NOTIF;
index += uint32_encode(num_of_firmware_bytes_rcvd, &m_notif_buffer[index]);
memset(&hvx_params, 0, sizeof(hvx_params));
hvx_params.handle = p_dfu->dfu_ctrl_pt_handles.value_handle;
hvx_params.type = BLE_GATT_HVX_NOTIFICATION;
hvx_params.offset = 0;
hvx_params.p_len = &index;
hvx_params.p_data = m_notif_buffer;
return sd_ble_gatts_hvx(p_dfu->conn_handle, &hvx_params);
}
uint32_t ble_rpc_cmd_resp_send(uint8_t op_code, uint32_t status)
{
uint8_t * p_buffer;
uint32_t err_code;
uint32_t index = 0;
// Allocate a memory buffer from HCI transport layer for transmitting the Command Response.
// Loop until a buffer is available.
do
{
err_code = hci_transport_tx_alloc(&p_buffer);
}
while (err_code == NRF_ERROR_NO_MEM);
if (err_code == NRF_SUCCESS)
{
// Encode packet type.
p_buffer[index++] = BLE_RPC_PKT_RESP;
// Encode Op Code.
p_buffer[index++] = op_code;
// Encode Status.
index += uint32_encode(status, &(p_buffer[RPC_CMD_RESP_STATUS_POS]));
return hci_transport_pkt_write(p_buffer, index);
}
return err_code;
}
void ant_sdm_page_16_encode(uint8_t * p_page_buffer,
ant_sdm_common_data_t const * p_common_data)
{
ant_sdm_page16_data_layout_t * p_outcoming_data = (ant_sdm_page16_data_layout_t *)p_page_buffer;
UNUSED_PARAMETER(uint24_encode(p_common_data->strides, p_outcoming_data->strides));
UNUSED_PARAMETER(uint32_encode(p_common_data->distance << 4, p_outcoming_data->distance));
page_16_data_log(p_common_data);
}
/**@brief Function for encoding a ITU Sensor Service Configuration.
*
* @param[in] p_iss ITU Sensor Service structure.
* @param[out] p_encoded_buffer Buffer where the encoded data will be written.
*
* @return Size of encoded data.
*/
static uint8_t its_conf_encode(iss_t * p_iss, uint8_t * p_encoded_buffer)
{
uint8_t pres_flags = 0;
uint8_t len = 1;
/*
// Sequence number field
if (p_iss->space_time_present)
{
pres_flags |= ITS_MEAS_FLAG_SPACE_TIME_BIT;
}
// Unit value
if (p_iss->unit_present)
{
pres_flags |= ITS_MEAS_FLAG_UNIT_BIT;
}
// Type value
if (p_iss->type_make_present)
{
pres_flags |= ITS_MEAS_FLAG_TYPE_MAKE_BIT;
}
// ID field
if (p_iss->ID_present)
{
pres_flags |= ITS_MEAS_FLAG_ID_BIT;
}
// Sampling Frequency field
if (p_iss->samp_freq_present)
{
pres_flags |= ITS_MEAS_FLAG_SAMP_FREQ_BIT;
}*/
pres_flags |= ITS_MEAS_FLAG_SPACE_TIME_BIT;
pres_flags |= ITS_MEAS_FLAG_UNIT_BIT;
pres_flags |= ITS_MEAS_FLAG_TYPE_MAKE_BIT;
pres_flags |= ITS_MEAS_FLAG_ID_BIT;
pres_flags |= ITS_MEAS_FLAG_SAMP_FREQ_BIT;
// Presentation Flag field
p_encoded_buffer[0] = pres_flags;
p_encoded_buffer[len++] = p_iss->coord;
len += uint16_encode(p_iss->curr_seq_nr, &p_encoded_buffer[len]);
len += uint16_encode(p_iss->unit, &p_encoded_buffer[len]);
p_encoded_buffer[len++] = p_iss->type;
p_encoded_buffer[len++] = p_iss->make;
len += uint16_encode(p_iss->ID, &p_encoded_buffer[len]);
len += uint32_encode(p_iss->samp_freq_in_m_sec, &p_encoded_buffer[len]);
return len;
}
/**@brief Encode a Health Thermometer Measurement.
*
* @param[in] p_hts Health Thermometer Service structure.
* @param[in] p_hts_meas Measurement to be encoded.
* @param[out] p_encoded_buffer Buffer where the encoded data will be written.
*
* @return Size of encoded data.
*/
static uint8_t hts_measurement_encode(ble_hts_t * p_hts,
ble_hts_meas_t * p_hts_meas,
uint8_t * p_encoded_buffer)
{
uint8_t flags = 0;
uint8_t len = 1;
uint32_t encoded_temp;
// Flags field
if (p_hts_meas->temp_in_fahr_units)
{
flags |= HTS_MEAS_FLAG_TEMP_UNITS_BIT;
}
if (p_hts_meas->time_stamp_present)
{
flags |= HTS_MEAS_FLAG_TIME_STAMP_BIT;
}
// Temperature Measurement Value field
if (p_hts_meas->temp_in_fahr_units)
{
flags |= HTS_MEAS_FLAG_TEMP_UNITS_BIT;
encoded_temp = ((p_hts_meas->temp_in_fahr.exponent << 24) & 0xFF000000) |
((p_hts_meas->temp_in_fahr.mantissa << 0) & 0x00FFFFFF);
}
else
{
encoded_temp = ((p_hts_meas->temp_in_celcius.exponent << 24) & 0xFF000000) |
((p_hts_meas->temp_in_celcius.mantissa << 0) & 0x00FFFFFF);
}
len += uint32_encode(encoded_temp, &p_encoded_buffer[len]);
// Time Stamp field
if (p_hts_meas->time_stamp_present)
{
flags |= HTS_MEAS_FLAG_TIME_STAMP_BIT;
len += ble_date_time_encode(&p_hts_meas->time_stamp, &p_encoded_buffer[len]);
}
// Temperature Type field
if (p_hts_meas->temp_type_present)
{
flags |= HTS_MEAS_FLAG_TEMP_TYPE_BIT;
p_encoded_buffer[len++] = p_hts_meas->temp_type;
}
// Flags field
p_encoded_buffer[0] = flags;
return len;
}
static uint32_t response_select_object_cmd_send(ble_dfu_t * p_dfu,
uint32_t max_size,
uint32_t offset,
uint32_t crc)
{
uint16_t index = 0;
NRF_LOG_INFO("Sending Object Info: [0x60, 0x06, 0x01 max: 0:x%08x 0:x%08x, CRC:0x%08x]\r\n", max_size, offset, crc);
#ifndef NRF51
if (p_dfu == NULL)
{
return NRF_ERROR_NULL;
}
#endif
if ((m_conn_handle == BLE_CONN_HANDLE_INVALID) || (m_flags & DFU_BLE_FLAG_SERVICE_INITIALIZED) == 0)
{
return NRF_ERROR_INVALID_STATE;
}
m_notif_buffer[index++] = BLE_DFU_OP_CODE_RESPONSE;
// Encode the Request Op code
m_notif_buffer[index++] = BLE_DFU_OP_CODE_SELECT_OBJECT;
// Encode the Success Response Value.
m_notif_buffer[index++] = (uint8_t)NRF_DFU_RES_CODE_SUCCESS;
// Encode the Max Size Value.
index += uint32_encode(max_size, &m_notif_buffer[index]);
// Encode the Offset Value.
index += uint32_encode(offset, &m_notif_buffer[index]);
// Encode the Crc Value.
index += uint32_encode(crc, &m_notif_buffer[index]);
return send_hvx(m_conn_handle, p_dfu->dfu_ctrl_pt_handles.value_handle, index);
}
static void antfs_ota_update_information_file_update(void)
{
uint32_t u32_temp, err_code;
m_ota_update_info_file[OTA_INFO_FILE_STRUCTURE_VERSION_OFFSET] = OTA_INFO_FILE_STRUCTURE_VERSION; /* File Structure Version */
m_ota_update_info_file[OTA_INFO_HARDWARE_VERSION_OFFSET] = OTA_INFO_HARDWARE_VERSION; /* Hardware Version */
m_ota_update_info_file[OTA_INFO_REGION_PRODUCT_ID_OFFSET] = OTA_INFO_REGION_PRODUCT_ID; /* Region/Product Identifier*/
u32_temp = DFU_IMAGE_MAX_SIZE_FULL; /* Maximum swap space */
(void)uint32_encode(u32_temp, &m_ota_update_info_file[OTA_INFO_MAXIMUM_SWAP_SPACE_OFFSET]);
u32_temp = OTA_INFO_WIRELESS_STACK_VERSION_ID;
(void)uint32_encode(u32_temp, &m_ota_update_info_file[OTA_INFO_WIRELESS_STACK_VERSION_ID_OFFSET]); /* Wireless Protocol Stack Version Identifier*/
m_ota_update_info_file[OTA_INFO_WIRELESS_STACK_VERSION_LENGTH_OFFSET] = OTA_INFO_WIRELESS_STACK_VERSION_STRING_BYTES; /* Wireless Protocol Stack Version String Length*/
err_code = sd_ant_version_get(&m_ota_update_info_file[OTA_INFO_WIRELESS_STACK_VERSION_STRING_OFFSET]); /* Wireless Protocol Stack Version String*/
APP_ERROR_CHECK(err_code);
u32_temp = OTA_INFO_BOOTLOADER_VERSION_ID;
(void)uint32_encode(u32_temp, &m_ota_update_info_file[OTA_INFO_BOOTLOADER_VERSION_ID_OFFSET]); /* Bootloader Version Identifier*/
m_ota_update_info_file[OTA_INFO_BOOTLOADER_VERSION_LENGTH_OFFSET] = OTA_INFO_BOOTLOADER_VERSION_STRING_BYTES; /* Bootloader Version String Length*/
memcpy(&m_ota_update_info_file[OTA_INFO_BOOTLOADER_VERSION_STRING_OFFSET], /* Bootloader Version String*/
ac_bootloader_version,
sizeof(ac_bootloader_version));
u32_temp = OTA_INFO_APPLICATION_VERSION_ID;
(void)uint32_encode(u32_temp, &m_ota_update_info_file[OTA_INFO_APPLICATION_VERSION_ID_OFFSET]); /* Application Version Identifier*/
m_ota_update_info_file[OTA_INFO_APPLICATION_VERSION_LENGTH_OFFSET] = OTA_INFO_APPLICATION_VERSION_STRING_BYTES; /* Application Version String Length*/
memcpy(&m_ota_update_info_file[OTA_INFO_APPLICATION_VERSION_STRING_OFFSET], /* Application Version String*/
ANT_BOOT_APP_VERSION,
OTA_INFO_APPLICATION_VERSION_STRING_BYTES);
}
void ant_common_page_81_encode(uint8_t * p_page_buffer,
volatile ant_common_page81_data_t const * p_page_data)
{
ant_common_page81_data_layout_t * p_outcoming_data =
(ant_common_page81_data_layout_t *)p_page_buffer;
p_outcoming_data->reserved = UINT8_MAX;
p_outcoming_data->sw_revision_minor = p_page_data->sw_revision_minor;
p_outcoming_data->sw_revision_major = p_page_data->sw_revision_major;
UNUSED_PARAMETER(uint32_encode(p_page_data->serial_number, p_outcoming_data->serial_number));
page81_data_log(p_page_data);
}
uint32_t ble_ancs_get_notif_attrs(const ble_ancs_c_t * p_ancs,
const uint32_t p_uid)
{
tx_message_t * p_msg;
uint32_t index = 0;
uint32_t number_of_requested_attr = 0;
p_msg = &m_tx_buffer[m_tx_insert_index++];
m_tx_insert_index &= TX_BUFFER_MASK;
p_msg->req.write_req.gattc_params.handle = m_service.control_point.handle_value;
p_msg->req.write_req.gattc_params.p_value = p_msg->req.write_req.gattc_value;
p_msg->req.write_req.gattc_params.offset = 0;
p_msg->req.write_req.gattc_params.write_op = BLE_GATT_OP_WRITE_REQ;
//Encode Command ID.
p_msg->req.write_req.gattc_value[index++] = BLE_ANCS_COMMAND_ID_GET_NOTIF_ATTRIBUTES;
//Encode Notification UID.
index += uint32_encode(p_uid, &p_msg->req.write_req.gattc_value[index]);
//Encode Attribute ID.
for (uint32_t attr = 0; attr < BLE_ANCS_NB_OF_ATTRS; attr++)
{
if (m_ancs_attr_list[attr].get == true)
{
p_msg->req.write_req.gattc_value[index++] = attr;
if ((attr == BLE_ANCS_NOTIF_ATTR_ID_TITLE) ||
(attr == BLE_ANCS_NOTIF_ATTR_ID_SUBTITLE) ||
(attr == BLE_ANCS_NOTIF_ATTR_ID_MESSAGE))
{
//Encode Length field, only applicable for Title, Subtitle and Message
index += uint16_encode(m_ancs_attr_list[attr].attr_len,
&p_msg->req.write_req.gattc_value[index]);
}
number_of_requested_attr++;
}
}
p_msg->req.write_req.gattc_params.len = index;
p_msg->conn_handle = p_ancs->conn_handle;
p_msg->type = WRITE_REQ;
m_expected_number_of_attrs = number_of_requested_attr;
tx_buffer_process();
return NRF_SUCCESS;
}
/**@brief Function for encoding configuration.
*
* @param[in] p_configuration configuration characteristic structure to be encoded.
* @param[out] p_encoded_buffer Buffer where the encoded data will be written.
*
* @return Size of encoded data.
*/
static uint8_t configuration_encode(ble_agsensor_configuration_t * p_configuration, uint8_t * encoded_buffer)
{
uint8_t len = 0;
(len) += uint16_encode(p_configuration->ble_agsensor_code, &encoded_buffer[len]);
(len) += uint32_encode(p_configuration->data.ble_agsensor_date_time_Sec, &encoded_buffer[len]);
// uint8_t test = sizeof(p_configuration->ble_agsensor_data);
// // Encode additional manufacturer specific data.
// if (p_configuration->ble_agsensor_data != NULL && sizeof(p_configuration->ble_agsensor_data) > 0)
// {
// memcpy(&encoded_buffer[len], p_configuration->ble_agsensor_data, 6);
// (len) += sizeof(p_configuration->ble_agsensor_data);
// }
return len;
}
uint32_t uint32_t_enc(void const * const p_field,
uint8_t * const p_buf,
uint32_t buf_len,
uint32_t * const p_index)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_field);
SER_ASSERT_NOT_NULL(p_index);
uint32_t * p_uint32 = (uint32_t *)p_field;
SER_ASSERT_LENGTH_LEQ(4, buf_len - *p_index);
*p_index += uint32_encode(*p_uint32, &p_buf[*p_index]);
return NRF_SUCCESS;
}
uint32_t ser_ble_cmd_rsp_status_code_enc(uint8_t op_code,
uint32_t command_status,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint32_t index = 0;
SER_ASSERT_LENGTH_LEQ(SER_CMD_RSP_HEADER_SIZE, *p_buf_len);
//Encode Op Code.
p_buf[index++] = op_code;
//Encode Status.
index += uint32_encode(command_status, &(p_buf[index]));
*p_buf_len = index;
return NRF_SUCCESS;
}
uint32_t op_status_enc(uint8_t op_code,
uint32_t return_code,
uint8_t * const p_buff,
uint32_t * const p_buff_len,
uint32_t * const p_index)
{
SER_ASSERT_NOT_NULL(p_buff);
SER_ASSERT_NOT_NULL(p_buff_len);
SER_ASSERT_NOT_NULL(p_index);
SER_ASSERT_LENGTH_LEQ(SER_CMD_RSP_HEADER_SIZE, *p_buff_len - *p_index);
//Encode Op Code.
p_buff[(*p_index)++] = op_code;
//Encode Status.
*p_index += uint32_encode(return_code, &(p_buff[*p_index]));
//update size of used buffer
*p_buff_len = *p_index;
return NRF_SUCCESS;
}
uint32_t ble_rpc_cmd_resp_data_send(uint8_t op_code,
uint8_t status,
const uint8_t * const p_data,
uint16_t data_len)
{
uint8_t * p_buffer;
uint32_t err_code;
uint32_t index = 0;
// Allocate a memory buffer from HCI transport layer for transmitting the Command Response.
// Loop until a buffer is available.
do
{
err_code = hci_transport_tx_alloc(&p_buffer);
}
while (err_code == NRF_ERROR_NO_MEM);
if (err_code == NRF_SUCCESS)
{
// Encode packet type.
p_buffer[index++] = BLE_RPC_PKT_RESP;
// Encode Op Code.
p_buffer[index++] = op_code;
// Encode Status.
index += uint32_encode(status, &(p_buffer[index]));
// Additional data in response packet.
memcpy(&p_buffer[index], p_data, data_len);
index += data_len;
return hci_transport_pkt_write(p_buffer, index);
}
return err_code;
}
uint32_t ble_dfu_bytes_rcvd_report(ble_dfu_t * p_dfu, uint32_t num_of_firmware_bytes_rcvd)
{
if (p_dfu == NULL)
{
return NRF_ERROR_NULL;
}
if ((p_dfu->conn_handle == BLE_CONN_HANDLE_INVALID) || !m_is_dfu_service_initialized)
{
return NRF_ERROR_INVALID_STATE;
}
ble_gatts_hvx_params_t hvx_params;
uint16_t index = 0;
// Encode the Op Code.
m_notif_buffer[index++] = OP_CODE_RESPONSE;
// Encode the Reqest Op Code.
m_notif_buffer[index++] = OP_CODE_IMAGE_SIZE_REQ;
// Encode the Response Value.
m_notif_buffer[index++] = (uint8_t)BLE_DFU_RESP_VAL_SUCCESS;
index += uint32_encode(num_of_firmware_bytes_rcvd, &m_notif_buffer[index]);
memset(&hvx_params, 0, sizeof(hvx_params));
hvx_params.handle = p_dfu->dfu_ctrl_pt_handles.value_handle;
hvx_params.type = BLE_GATT_HVX_NOTIFICATION;
hvx_params.offset = 0;
hvx_params.p_len = &index;
hvx_params.p_data = m_notif_buffer;
return sd_ble_gatts_hvx(p_dfu->conn_handle, &hvx_params);
}
void ble_agsensor_process_request(uint8_t data_len, uint8_t * p_data, uint16_t op_code, bool read_start, bool app_request, bool write)
{
APPL_LOG("ble_agsensor_process_request opcode %d \r\n", (int)op_code);
if (isConfigSendWaiting == true && write == false && app_request == false)
{
APPL_LOG("ble_agsensor_process_request 1 \r\n");
return;
}
// APPL_LOG("ble_agsensor_process_request 2 \r\n");
uint8_t sensor_depth;
uint32_t tempData32 = 0;
uint16_t tempData16 = 0;
// Asked for stop sending the Data for specific opcode
if (app_request == true && read_start == false && opcode_inRead == op_code && write == false){
// Set to date time as they count as the ping message
opcode_inRead = BLE_AGSENSOR_CONFIGURATION_OPCODE_DATETIME;
APPL_LOG("ble_agsensor_process_request 2 \r\n");
return;
}
hvx_p_config_len = 0;
(hvx_p_config_len) += uint16_encode(op_code, &hvx_encoded_buffer[hvx_p_config_len]);
switch (op_code)
{
case BLE_AGSENSOR_CONFIGURATION_OPCODE_DATETIME:
if (write && data_len >=4 && p_data != NULL) {
tempData32 = (((uint32_t)((uint8_t *)p_data)[0]) << 0) |
(((uint32_t)((uint8_t *)p_data)[1]) << 8) |
(((uint32_t)((uint8_t *)p_data)[2]) << 16) |
(((uint32_t)((uint8_t *)p_data)[3]) << 24 );
setOffsetTime(tempData32);
APPL_LOG("Date time offset update \r\n");
return;
}
else {
// APPL_LOG("Date time msg created \r\n");
datetimeReadEnable = read_start;
tempData32 = getTimeInSec();
// tempData32 = SwapByte4(tempData32);
(hvx_p_config_len) += uint32_encode(tempData32, &hvx_encoded_buffer[hvx_p_config_len]);
}
break;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_BATTERY_LEVEL: // read only
batteryLevelReadEnable = read_start;
break;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_LONGITUDE_LATITUDE:
break;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_BONDED_DONGLE_RSSI: // read only
bondedDongleRssiReadEnable = read_start;
break;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_BONDED_DONGLE_MAC_ADDRESS: // read only
break;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_TIME_SYNC_OFFSET:
break;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_UPDATE_RATE:
break;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_DATUM:
break;
/*Mosture */
case BLE_AGSENSOR_CONFIGURATION_OPCODE_MOSTURE_AIRWATER:
if (write && data_len >= 5 && p_data != NULL)
{
APPL_LOG("Moisture sensor AirWater write request\r\n");
sensor_depth = p_data[0];
// Write the Air value in the config
tempData16 = uint16_decode(&p_data[1]);
cfgWriteConfig(&moisture_air[sensor_depth], &tempData16, sizeof(tempData16));
// Write the Water value in the config
tempData16 = uint16_decode(&p_data[3]);
cfgWriteConfig(&moisture_water[sensor_depth], &tempData16, sizeof(tempData16));
// Need to create response msg so application get the response to update the UI.
ble_agsensor_create_temp_msg(op_code, p_data, data_len);
return;
}
else
{
if(read_start)
{
msg_sensor_depth = MAX_SENSOR_COUNT;
APPL_LOG("moisture sensor air Water read request\r\n");
// Job is done so need to return msg will be created on the ACK call back
return;
}
else
{
msg_sensor_depth--;
if (msg_sensor_depth == 0) {
opcode_inRead = BLE_AGSENSOR_CONFIGURATION_OPCODE_DATETIME;
}
}
// Add the sensor count in the sending msg
hvx_encoded_buffer[hvx_p_config_len] = msg_sensor_depth;
hvx_p_config_len ++;
// Add the Air value in the sending msg
cfgReadConfig(&moisture_air[msg_sensor_depth], &tempData16, sizeof(tempData16));
(hvx_p_config_len) += uint16_encode(tempData16, &hvx_encoded_buffer[hvx_p_config_len]);
// Add the Water value in the sending msg
cfgReadConfig(&moisture_water[msg_sensor_depth], &tempData16, sizeof(tempData16));
(hvx_p_config_len) += uint16_encode(tempData16, &hvx_encoded_buffer[hvx_p_config_len]);
// If app have requested specific data which is not read start then need to create the temp msg
if(app_request == true) {
ble_agsensor_create_temp_msg(0, &hvx_encoded_buffer, hvx_p_config_len);
}
APPL_LOG("moisture sensor Air Water data created %d\r\n", msg_sensor_depth);
}
break;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_MOSTURE_ABCD:
if (write && data_len >=17 && p_data != NULL)
{
APPL_LOG("Moisture sensor ABCD write request\r\n");
sensor_depth = p_data[0];
// Write the A value in the config
tempData32 = uint32_decode(&p_data[1]);
cfgWriteConfig(&moisture_A[sensor_depth], &tempData32, sizeof(tempData32));
// Write the B value in the config
tempData32 = uint32_decode(&p_data[5]);
cfgWriteConfig(&moisture_B[sensor_depth], &tempData32, sizeof(tempData32));
// Write the B value in the config
tempData32 = uint32_decode(&p_data[9]);
cfgWriteConfig(&moisture_C[sensor_depth], &tempData32, sizeof(tempData32));
// Write the B value in the config
tempData32 = uint32_decode(&p_data[13]);
cfgWriteConfig(&moisture_D[sensor_depth], &tempData32, sizeof(tempData32));
// Need to create response msg so application get the response to update the UI.
ble_agsensor_create_temp_msg(op_code, p_data, data_len);
return;
}
else
{
if(read_start)
{
msg_sensor_depth = MAX_SENSOR_COUNT;
APPL_LOG("moisture sensor ABCD read request\r\n");
// Job is done so need to return msg will be created on the ACK call back
return;
}
else
{
msg_sensor_depth--;
if (msg_sensor_depth == 0) {
opcode_inRead = BLE_AGSENSOR_CONFIGURATION_OPCODE_DATETIME;
}
}
// Add the sensor count in the sending msg
hvx_encoded_buffer[hvx_p_config_len] = msg_sensor_depth;
hvx_p_config_len ++;
// Add the A value in the sending msg
cfgReadConfig(&moisture_A[msg_sensor_depth], &tempData32, sizeof(tempData32));
(hvx_p_config_len) += uint32_encode(tempData32, &hvx_encoded_buffer[hvx_p_config_len]);
// Add the B value in the sending msg
cfgReadConfig(&moisture_B[msg_sensor_depth], &tempData32, sizeof(tempData32));
(hvx_p_config_len) += uint32_encode(tempData32, &hvx_encoded_buffer[hvx_p_config_len]);
// Add the C value in the sending msg
cfgReadConfig(&moisture_C[msg_sensor_depth], &tempData32, sizeof(tempData32));
(hvx_p_config_len) += uint32_encode(tempData32, &hvx_encoded_buffer[hvx_p_config_len]);
// Add the D value in the sending msg
cfgReadConfig(&moisture_D[msg_sensor_depth], &tempData32, sizeof(tempData32));
(hvx_p_config_len) += uint32_encode(tempData32, &hvx_encoded_buffer[hvx_p_config_len]);
// If app have requested specific data which is not read start then need to create the temp msg
if(app_request == true) {
ble_agsensor_create_temp_msg(0, &hvx_encoded_buffer, hvx_p_config_len);
}
APPL_LOG("moisture sensor ABCD data created %d\r\n", msg_sensor_depth);
}
break;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_TEMPERATURE_AB:
if (write && data_len >=9 && p_data != NULL)
{
APPL_LOG("temperature sensor AB write request\r\n");
sensor_depth = p_data[0];
// Write the A value in the config
tempData32 = uint32_decode(&p_data[1]);
cfgWriteConfig(&temperature_A[sensor_depth], &tempData32, sizeof(tempData32));
// Write the B value in the config
tempData32 = uint32_decode(&p_data[5]);
cfgWriteConfig(&temperature_B[sensor_depth], &tempData32, sizeof(tempData32));
// Need to create response msg so application get the response to update the UI.
ble_agsensor_create_temp_msg(op_code, p_data, data_len);
return;
}
else
{
if(read_start)
{
msg_sensor_depth = MAX_SENSOR_COUNT;
APPL_LOG("temperature sensor AB read request\r\n");
// Job is done so need to return msg will be created on the ACK call back
return;
}
else
{
msg_sensor_depth--;
if (msg_sensor_depth == 0) {
opcode_inRead = BLE_AGSENSOR_CONFIGURATION_OPCODE_DATETIME;
}
}
// Add the sensor count in the sending msg
hvx_encoded_buffer[hvx_p_config_len] = msg_sensor_depth;
hvx_p_config_len ++;
// Add the A value in the sending msg
cfgReadConfig(&temperature_A[msg_sensor_depth], &tempData32, sizeof(tempData32));
(hvx_p_config_len) += uint32_encode(tempData32, &hvx_encoded_buffer[hvx_p_config_len]);
// Add the B value in the sending msg
cfgReadConfig(&temperature_B[msg_sensor_depth], &tempData32, sizeof(tempData32));
(hvx_p_config_len) += uint32_encode(tempData32, &hvx_encoded_buffer[hvx_p_config_len]);
// If app have requested specific data which is not read start then need to create the temp msg
if(app_request == true) {
ble_agsensor_create_temp_msg(0, &hvx_encoded_buffer, hvx_p_config_len);
}
APPL_LOG("temperature sensor AB data created %d\r\n", msg_sensor_depth);
}
break;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_SALINITY_AIRWATER:
if (write && data_len >=5 && p_data != NULL)
{
APPL_LOG("Salinity sensor AirWater write request\r\n");
sensor_depth = p_data[0];
// Write the Air value in the config
tempData16 = uint16_decode(&p_data[1]);
cfgWriteConfig(&salinity_air[sensor_depth], &tempData16, sizeof(tempData16));
// Write the Water value in the config
tempData16 = uint16_decode(&p_data[3]);
cfgWriteConfig(&salinity_water[sensor_depth], &tempData16, sizeof(tempData16));
// Need to create response msg so application get the response to update the UI.
ble_agsensor_create_temp_msg(op_code, p_data, data_len);
return;
}
else
{
if(read_start)
{
msg_sensor_depth = MAX_SENSOR_COUNT;
APPL_LOG("Salinity sensor AirWater read request\r\n");
// Job is done so need to return msg will be created on the ACK call back
return;
}
else
{
msg_sensor_depth--;
if (msg_sensor_depth == 0) {
opcode_inRead = BLE_AGSENSOR_CONFIGURATION_OPCODE_DATETIME;
}
}
// Add the sensor count in the sending msg
hvx_encoded_buffer[hvx_p_config_len] = msg_sensor_depth;
hvx_p_config_len ++;
// Add the Air value in the sending msg
cfgReadConfig(&salinity_air[msg_sensor_depth], &tempData16, sizeof(tempData16));
(hvx_p_config_len) += uint16_encode(tempData16, &hvx_encoded_buffer[hvx_p_config_len]);
// Add the Water value in the sending msg
cfgReadConfig(&salinity_water[msg_sensor_depth], &tempData16, sizeof(tempData16));
(hvx_p_config_len) += uint16_encode(tempData16, &hvx_encoded_buffer[hvx_p_config_len]);
// If app have requested specific data which is not read start then need to create the temp msg
if(app_request == true) {
ble_agsensor_create_temp_msg(0, &hvx_encoded_buffer, hvx_p_config_len);
}
APPL_LOG("Salinity sensor AirWater data created %d\r\n", msg_sensor_depth);
}
break;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_SALINITY_D:
if (write && data_len >=5 && p_data != NULL)
{
APPL_LOG("Salinity sensor D write request\r\n");
sensor_depth = p_data[0];
// Write the D value in the config
tempData32 = uint32_decode(&p_data[1]);
cfgWriteConfig(&salinity_D[sensor_depth], &tempData32, sizeof(tempData32));
// Need to create response msg so application get the response to update the UI.
ble_agsensor_create_temp_msg(op_code, p_data, data_len);
return;
}
else
{
if(read_start)
{
msg_sensor_depth = MAX_SENSOR_COUNT;
APPL_LOG("Salinity sensor D read request\r\n");
// Job is done so need to return msg will be created on the ACK call back
return;
}
else
{
msg_sensor_depth--;
if (msg_sensor_depth == 0) {
opcode_inRead = BLE_AGSENSOR_CONFIGURATION_OPCODE_DATETIME;
}
}
// Add the sensor count in the sending msg
hvx_encoded_buffer[hvx_p_config_len] = msg_sensor_depth;
hvx_p_config_len ++;
// Add the D value in the sending msg
cfgReadConfig(&salinity_D[msg_sensor_depth], &tempData32, sizeof(tempData32));
(hvx_p_config_len) += uint32_encode(tempData32, &hvx_encoded_buffer[hvx_p_config_len]);
// If app have requested specific data which is not read start then need to create the temp msg
if(app_request == true) {
ble_agsensor_create_temp_msg(0, &hvx_encoded_buffer, hvx_p_config_len);
}
APPL_LOG("Salinity sensor D data created %d\r\n", msg_sensor_depth);
}
break;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_START_MEASUREMENT:
isMeasuringSensor = true;
sentek_sensor_measurement_type_set(SENSOR_MEASUREMENT_CONTINUOUS);
APPL_LOG("Start Measurement\r\n");
return;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_STOP_MEASUREMENT:
isMeasuringSensor = false;
sentek_sensor_measurement_type_set(SENSOR_MEASUREMENT_NONE);
APPL_LOG("Stop doing Measurement\r\n");
return;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_AIR_NORMALIZE:
sentek_sensor_measurement_type_set(SENSOR_MEASUREMENT_AIR_NORMALIZATION);
airNormalizationInProgress = true;
APPL_LOG("Air Normalization Request\r\n");
return;
case BLE_AGSENSOR_CONFIGURATION_OPCODE_WATER_NORMALIZE:
sentek_sensor_measurement_type_set(SENSOR_MEASUREMENT_WATER_NORMALIZATION);
waterNormalizationInProgress = true;
APPL_LOG("Water Normalization Request\r\n");
return;
default:
APPL_LOG("Default msg created %d\r\n", (int)op_code);
datetimeReadEnable = read_start;
opcode_inRead = BLE_AGSENSOR_CONFIGURATION_OPCODE_DATETIME;
tempData32 = getTimeInSec();
// tempData32 = SwapByte4(tempData32);
(hvx_p_config_len) += uint32_encode(tempData32, &hvx_encoded_buffer[hvx_p_config_len]);
break;
}
if (isConnected == true && configIndicationEnable == true) {
isConfigSendWaiting = true;
return;
}
// APPL_LOG("read_request 6 \r\n");
return;
}
/**@brief Timer callback used for transmitting Echo Request and UDP6 packets depending on
* application state.
*
* @param[in] p_context Pointer used for passing context. No context used in this application.
*/
static void tx_timeout_handler(void * p_context)
{
uint32_t err_code;
switch (m_node_state)
{
case APP_STATE_IPV6_IF_DOWN:
{
return;
}
case APP_STATE_IPV6_IF_UP:
{
APPL_LOG("[APPL]: Ping remote node. \r\n");
iot_pbuffer_alloc_param_t pbuff_param;
iot_pbuffer_t * p_buffer;
pbuff_param.flags = PBUFFER_FLAG_DEFAULT;
pbuff_param.type = ICMP6_PACKET_TYPE;
pbuff_param.length = ICMP6_ECHO_REQUEST_PAYLOAD_OFFSET + 10;
// Allocate packet buffer.
err_code = iot_pbuffer_allocate(&pbuff_param, &p_buffer);
APP_ERROR_CHECK(err_code);
ipv6_addr_t dest_ipv6_addr;
memcpy(&dest_ipv6_addr.u8[0], (uint8_t[]){SERVER_IPV6_ADDRESS}, IPV6_ADDR_SIZE);
iot_interface_t * p_interface;
ipv6_addr_t src_ipv6_addr;
err_code = ipv6_address_find_best_match(&p_interface,
&src_ipv6_addr,
&dest_ipv6_addr);
APP_ERROR_CHECK(err_code);
memset(p_buffer->p_payload + ICMP6_ECHO_REQUEST_PAYLOAD_OFFSET, 'A', 10);
// Send Echo Request to peer.
err_code = icmp6_echo_request(p_interface, &src_ipv6_addr, &dest_ipv6_addr, p_buffer);
APP_ERROR_CHECK(err_code);
err_code = app_timer_start(m_tx_node_timer, APP_PING_INTERVAL, NULL);
APP_ERROR_CHECK(err_code);
break;
}
case APP_STATE_PEER_REACHABLE:
{
uint32_t ind_buff = 0;
err_code = get_packet_buffer_index(&ind_buff, (uint32_t *)&m_invalid_pkt_seq_num);
if (err_code == NRF_ERROR_NOT_FOUND)
{
// Buffer of expected packets full, checking if peer is reachable.
APPL_LOG("[APPL]: %ld packets transmitted, %d packets lost. Resetting counter. \r\n", \
m_pkt_seq_num, PACKET_BUFFER_LEN);
m_node_state = APP_STATE_IPV6_IF_UP;
m_display_state = LEDS_TX_ECHO_REQUEST;
m_pkt_seq_num = 0;
memset(&m_packet_buffer[0][0], 0x00, sizeof(m_packet_buffer));
err_code = app_timer_start(m_tx_node_timer, APP_PING_INTERVAL, NULL);
APP_ERROR_CHECK(err_code);
return;
}
++m_pkt_seq_num;
if (m_pkt_seq_num == INVALID_PACKET_SEQ_NUMBER)
{
++m_pkt_seq_num;
}
test_packet_payload_t packet;
uint8_t encoded_seq_num[TEST_PACKET_NUM_LEN];
UNUSED_VARIABLE(uint32_encode(m_pkt_seq_num, &encoded_seq_num[0]));
// The first 4 bytes of the payload is the packet sequence number.
memcpy(&packet.packet_seq_num[0], &encoded_seq_num[0], TEST_PACKET_NUM_LEN);
// The rest of the payload is random bytes.
do
{
err_code = sd_rand_application_vector_get(&packet.packet_data[0], \
sizeof(packet.packet_data));
}
while (err_code == NRF_ERROR_SOC_RAND_NOT_ENOUGH_VALUES);
APP_ERROR_CHECK(err_code);
iot_pbuffer_alloc_param_t pbuff_param;
iot_pbuffer_t * p_buffer;
pbuff_param.flags = PBUFFER_FLAG_DEFAULT;
pbuff_param.type = UDP6_PACKET_TYPE;
pbuff_param.length = TEST_PACKET_PAYLOAD_LEN;
// Allocate packet buffer.
err_code = iot_pbuffer_allocate(&pbuff_param, &p_buffer);
APP_ERROR_CHECK(err_code);
memcpy(p_buffer->p_payload, &packet.packet_seq_num[0], TEST_PACKET_NUM_LEN);
memcpy(p_buffer->p_payload+TEST_PACKET_NUM_LEN, &packet.packet_data[0], TEST_PACKET_DATA_LEN);
ipv6_addr_t dest_ipv6_addr;
memset(&dest_ipv6_addr, 0x00, sizeof(ipv6_addr_t));
memcpy(&dest_ipv6_addr.u8[0], (uint8_t[]){SERVER_IPV6_ADDRESS}, IPV6_ADDR_SIZE);
// Transmit UDP6 packet.
err_code = udp6_socket_sendto(&m_udp_socket, &dest_ipv6_addr, HTONS(UDP_PORT), p_buffer);
APP_ERROR_CHECK(err_code);
APPL_LOG("[APPL]: Transmitted UDP packet sequence number: %ld\r\n", m_pkt_seq_num);
// Store sent packet amongst expected packets.
memcpy(&m_packet_buffer[ind_buff][0], &packet.packet_seq_num[0], TEST_PACKET_NUM_LEN);
memcpy(&m_packet_buffer[ind_buff][TEST_PACKET_NUM_LEN], &packet.packet_data[0], TEST_PACKET_DATA_LEN);
if (m_pkt_seq_num == 1)
{
err_code = app_timer_start(m_tx_node_timer, (TX_INTERVAL*5), NULL); // Slow start.
APP_ERROR_CHECK(err_code);
}
else
{
err_code = app_timer_start(m_tx_node_timer, TX_INTERVAL, NULL);
APP_ERROR_CHECK(err_code);
}
break;
}
default:
{
break;
}
}
}
