/**@brief Function for handling the rx packets comming from hal_transport.
*
* @details
* This function is called in serial peripheral interrupt context. Response packets are handled in
* this context. Events are passed to the application and it is up to application in which context
* they are handled.
*
* @param[in] p_data Pointer to received data.
* @param[in] length Size of data.
*/
static void ser_sd_transport_rx_packet_handler(uint8_t * p_data, uint16_t length)
{
if (p_data && (length >= SER_PKT_TYPE_SIZE))
{
const uint8_t packet_type = p_data[SER_PKT_TYPE_POS];
p_data += SER_PKT_TYPE_SIZE;
length -= SER_PKT_TYPE_SIZE;
switch (packet_type)
{
case SER_PKT_TYPE_RESP:
case SER_PKT_TYPE_DTM_RESP:
#ifdef ANT_STACK_SUPPORT_REQD
case SER_PKT_TYPE_ANT_RESP:
#endif // ANT_STACK_SUPPORT_REQD
if (m_rsp_wait)
{
m_return_value = m_rsp_dec_handler(p_data, length);
(void)ser_sd_transport_rx_free(p_data);
/* Reset response flag - cmd_write function is pending on it.*/
m_rsp_wait = false;
/* If os handler is set, signal os that response has arrived.*/
if (m_os_rsp_set_handler)
{
m_os_rsp_set_handler();
}
}
else
{
/* Unexpected packet. */
(void)ser_sd_transport_rx_free(p_data);
APP_ERROR_HANDLER(packet_type);
}
break;
#ifdef BLE_STACK_SUPPORT_REQD
case SER_PKT_TYPE_EVT:
/* It is ensured during opening that handler is not NULL. No check needed. */
NRF_LOG_DEBUG("[EVT]: %s ", (uint32_t)ser_dbg_sd_evt_str_get(uint16_decode(&p_data[SER_EVT_ID_POS]))); // p_data points to EVT_ID
m_ble_evt_handler(p_data, length);
break;
#endif // BLE_STACK_SUPPORT_REQD
#ifdef ANT_STACK_SUPPORT_REQD
case SER_PKT_TYPE_ANT_EVT:
/* It is ensured during opening that handler is not NULL. No check needed. */
NRF_LOG_DEBUG("[ANT_EVT_ID]: %s ", (uint32_t)ser_dbg_sd_evt_str_get(uint16_decode(&p_data[SER_EVT_ID_POS]))); // p_data points to EVT_ID
m_ant_evt_handler(p_data, length);
break;
#endif // ANT_STACK_SUPPORT_REQD
default:
(void)ser_sd_transport_rx_free(p_data);
APP_ERROR_HANDLER(packet_type);
break;
}
}
}
void nrf_free(void * p_mem)
{
VERIFY_MODULE_INITIALIZED_VOID();
NULL_PARAM_CHECK_VOID(p_mem);
NRF_LOG_DEBUG("[MM]: >> nrf_free %p.\r\n", (uint32_t)p_mem);
MM_MUTEX_LOCK();
uint32_t index;
uint32_t memory_index = 0;
for (index = 0; index < TOTAL_BLOCK_COUNT; index++)
{
if (&m_memory[memory_index] == p_mem)
{
// Found a free block of memory, assign.
NRF_LOG_DEBUG("[MM]: << Freeing block %d.\r\n", index);
block_init(index);
break;
}
memory_index += get_block_size(index);
}
MM_MUTEX_UNLOCK();
NRF_LOG_DEBUG("[MM]: << nrf_free.\r\n");
return;
}
uint32_t nrf_mem_init(void)
{
NRF_LOG_DEBUG("[MM]: >> nrf_mem_init.\r\n");
SDK_MUTEX_INIT(m_mm_mutex);
MM_MUTEX_LOCK();
uint32_t block_index = 0;
for (block_index = 0; block_index < TOTAL_BLOCK_COUNT; block_index++)
{
block_init(block_index);
}
#if (MEM_MANAGER_DISABLE_API_PARAM_CHECK == 0)
m_module_initialized = true;
#endif // MEM_MANAGER_DISABLE_API_PARAM_CHECK
#ifdef MEM_MANAGER_ENABLE_DIAGNOSTICS
nrf_mem_diagnose();
#endif // MEM_MANAGER_ENABLE_DIAGNOSTICS
MM_MUTEX_UNLOCK();
NRF_LOG_DEBUG("[MM]: << nrf_mem_init.\r\n");
return NRF_SUCCESS;
}
ret_code_t nrf_dfu_settings_write(dfu_flash_callback_t callback)
{
ret_code_t err_code;
NRF_LOG_DEBUG("Writing settings...");
NRF_LOG_DEBUG("Erasing old settings at: 0x%08x", (uint32_t)m_dfu_settings_buffer);
// Not setting the callback function because ERASE is required before STORE
// Only report completion on successful STORE.
err_code = nrf_dfu_flash_erase((uint32_t)m_dfu_settings_buffer, 1, NULL);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Could not erase the settings page!");
return NRF_ERROR_INTERNAL;
}
s_dfu_settings.crc = nrf_dfu_settings_crc_get();
static nrf_dfu_settings_t temp_dfu_settings;
memcpy(&temp_dfu_settings, &s_dfu_settings, sizeof(nrf_dfu_settings_t));
err_code = nrf_dfu_flash_store((uint32_t)m_dfu_settings_buffer,
&temp_dfu_settings,
sizeof(nrf_dfu_settings_t),
callback);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Could not write the DFU settings page!");
return NRF_ERROR_INTERNAL;
}
return NRF_SUCCESS;
}
void nrf_bootloader_app_start(void)
{
uint32_t start_addr = MBR_SIZE; // Always boot from end of MBR. If a SoftDevice is present, it will boot the app.
NRF_LOG_DEBUG("Running nrf_bootloader_app_start with address: 0x%08x", start_addr);
uint32_t err_code;
// Disable and clear interrupts
// Notice that this disables only 'external' interrupts (positive IRQn).
NRF_LOG_DEBUG("Disabling interrupts. NVIC->ICER[0]: 0x%x", NVIC->ICER[0]);
NVIC->ICER[0]=0xFFFFFFFF;
NVIC->ICPR[0]=0xFFFFFFFF;
#if defined(__NRF_NVIC_ISER_COUNT) && __NRF_NVIC_ISER_COUNT == 2
NVIC->ICER[1]=0xFFFFFFFF;
NVIC->ICPR[1]=0xFFFFFFFF;
#endif
err_code = nrf_dfu_mbr_irq_forward_address_set();
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Failed running nrf_dfu_mbr_irq_forward_address_set()");
}
NRF_LOG_FLUSH();
nrf_bootloader_app_start_final(start_addr);
}
/**@brief Function for handling the Write event.
*
* @param[in] p_si7021 si7021 Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_write(ble_si7021_t * p_si7021, ble_evt_t * p_ble_evt) {
ble_gatts_evt_write_t * p_evt_write = &p_ble_evt->evt.gatts_evt.params.write;
NRF_LOG_DEBUG("on_write %x\n\r",p_evt_write->handle);
if (p_evt_write->handle == p_si7021->value_char_handles.cccd_handle) {
if (p_evt_write->len == 2 && p_si7021->evt_handler != NULL) {
ble_si7021_evt_t evt;
if (ble_srv_is_notification_enabled(p_evt_write->data)) {
evt.evt_type = BLE_si7021_EVT_NOTIFICATION_ENABLED;
NRF_LOG_DEBUG("BLE_si7021_EVT_NOTIFICATION_ENABLED\n\r");
} else {
evt.evt_type = BLE_si7021_EVT_NOTIFICATION_DISABLED;
NRF_LOG_DEBUG("BLE_si7021_EVT_NOTIFICATION_DISABLED\n\r");
}
p_si7021->evt_handler(p_si7021, &evt);
}
} else if (p_evt_write->handle == p_si7021->com_char_handles.value_handle) {
p_si7021->interval = uint16_decode(&p_evt_write->data[0]);
if (p_si7021->interval<100) {
p_si7021->interval=100; // min 100ms
}
ble_si7021_evt_t evt;
evt.evt_type = BLE_si7021_EVT_INTERVAL_CHANGE;
NRF_LOG_DEBUG("BLE_si7021_EVT_INTERVAL_CHANGE %d\n\r",p_si7021->interval);
p_si7021->evt_handler(p_si7021, &evt);
} else {
// No implementation needed.
}
}
void nrf_bootloader_app_start(uint32_t start_addr)
{
NRF_LOG_DEBUG("Running nrf_bootloader_app_start with address: 0x%08x", start_addr);
uint32_t err_code;
//NRF_LOG_INFO("Initializing SD in mbr");
err_code = nrf_dfu_mbr_init_sd();
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Failed running nrf_dfu_mbr_init_sd");
return;
}
// Disable and clear interrupts
NRF_LOG_DEBUG("Disabling interrupts");
NVIC->ICER[0]=0xFFFFFFFF;
NVIC->ICPR[0]=0xFFFFFFFF;
#if defined(__NRF_NVIC_ISER_COUNT) && __NRF_NVIC_ISER_COUNT == 2
NVIC->ICER[1]=0xFFFFFFFF;
NVIC->ICPR[1]=0xFFFFFFFF;
#endif
// Set the sd softdevice vector table base address
NRF_LOG_DEBUG("Setting SD vector table base: 0x%08x", start_addr);
err_code = sd_softdevice_vector_table_base_set(start_addr);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Failed running sd_softdevice_vector_table_base_set");
return;
}
// Run application
nrf_bootloader_app_start_impl(start_addr);
}
static void mpulib_orient_cb(unsigned char orientation)
{
BleSrvcCharNotify(GetImuSrvcInstance(), 2, &orientation, 1);
/* if (m_motion.features & DRV_MOTION_FEATURE_MASK_ORIENTATION)
{
drv_motion_evt_t evt = DRV_MOTION_EVT_ORIENTATION;
m_motion.evt_handler(&evt, &orientation, 1);
}
*/
#ifdef MOTION_DEBUG
switch (orientation)
{
case ANDROID_ORIENT_PORTRAIT:
NRF_LOG_DEBUG("Portrait\r\n");
break;
case ANDROID_ORIENT_LANDSCAPE:
NRF_LOG_DEBUG("Landscape\r\n");
break;
case ANDROID_ORIENT_REVERSE_PORTRAIT:
NRF_LOG_DEBUG("Reverse Portrait\r\n");
break;
case ANDROID_ORIENT_REVERSE_LANDSCAPE:
NRF_LOG_DEBUG("Reverse Landscape\r\n");
break;
default:
return;
}
#endif
}
/**
* Read registers
*
* Read one or more registers from the sensor
*
* @param[in] address Start address to read from
* @param[out] p_toRead Pointer to result buffer
* @param[in] cound Number of bytes to read
*
* @return LIS2DH12_RET_OK No Error
* @return LIS2DH12_RET_NULL Result buffer is NULL Pointer
* @return LIS2DH12_RET_ERROR Read attempt was not successful
*/
lis2dh12_ret_t lis2dh12_read_register(const uint8_t address, uint8_t* const p_toRead, const size_t count)
{
NRF_LOG_DEBUG("LIS2DH12 Register read started'\r\n");
lis2dh12_ret_t err_code = LIS2DH12_RET_OK;
uint8_t* write_buffer = calloc(count+1, sizeof(uint8_t));
//Separate buffer to read data, includes room for response to address byte.
//This is pretty ineficient, TODO
uint8_t* read_buffer = calloc(count+1, sizeof(uint8_t));
if (NULL == p_toRead)
{
err_code |= LIS2DH12_RET_NULL;
}
else
{
write_buffer[0] = address | SPI_READ | SPI_ADR_INC;
err_code |= spi_transfer_lis2dh12(write_buffer, (count + 1U), read_buffer);
if (SPI_RET_OK == (SPI_Ret)err_code)
{
/* Transfer was ok, copy result */
memcpy(p_toRead, &(read_buffer[1]), count);
}
}
NRF_LOG_DEBUG("LIS2DH12 Register read complete'\r\n");
free(read_buffer);
free(write_buffer);
return err_code;
}
void nrf_esb_event_handler(nrf_esb_evt_t const * p_event)
{
switch (p_event->evt_id)
{
case NRF_ESB_EVENT_TX_SUCCESS:
NRF_LOG_DEBUG("TX SUCCESS EVENT\r\n");
break;
case NRF_ESB_EVENT_TX_FAILED:
NRF_LOG_DEBUG("TX FAILED EVENT\r\n");
(void) nrf_esb_flush_tx();
(void) nrf_esb_start_tx();
break;
case NRF_ESB_EVENT_RX_RECEIVED:
NRF_LOG_DEBUG("RX RECEIVED EVENT\r\n");
while (nrf_esb_read_rx_payload(&rx_payload) == NRF_SUCCESS)
{
if (rx_payload.length > 0)
{
NRF_LOG_DEBUG("RX RECEIVED PAYLOAD\r\n");
}
}
break;
}
NRF_GPIO->OUTCLR = 0xFUL << 12;
NRF_GPIO->OUTSET = (p_event->tx_attempts & 0x0F) << 12;
}
/**@brief Function for passing any pending request from the buffer to the stack.
*/
static void tx_buffer_process(void)
{
if (m_tx_index != m_tx_insert_index)
{
uint32_t err_code;
if (m_tx_buffer[m_tx_index].type == READ_REQ)
{
err_code = sd_ble_gattc_read(m_tx_buffer[m_tx_index].conn_handle,
m_tx_buffer[m_tx_index].req.read_handle,
0);
}
else
{
err_code = sd_ble_gattc_write(m_tx_buffer[m_tx_index].conn_handle,
&m_tx_buffer[m_tx_index].req.write_req.gattc_params);
}
if (err_code == NRF_SUCCESS)
{
NRF_LOG_DEBUG("SD Read/Write API returns Success..\r\n");
m_tx_index++;
m_tx_index &= TX_BUFFER_MASK;
}
else
{
NRF_LOG_DEBUG("SD Read/Write API returns error. This message sending will be "
"attempted again..\r\n");
}
}
}
/**@brief Function for parsing the id of an iOS attribute.
* Used in the @ref parse_get_notif_attrs_response state machine.
*
* @details We only request attributes that are registered with @ref ble_ancs_c_attr_add
* once they have been reveiced we stop parsing.
*
* @param[in] p_ancs Pointer to an ANCS instance to which the event belongs.
* @param[in] p_data_src Pointer to data that was received from the Notification Provider.
* @param[in] index Pointer to an index that helps us keep track of the current data to be parsed.
*
* @return The next parse state.
*/
static ble_ancs_c_parse_state_t attr_id_parse(ble_ancs_c_t * p_ancs,
const uint8_t * p_data_src,
uint32_t * index)
{
p_ancs->evt.attr.attr_id = p_data_src[(*index)++];
if (p_ancs->evt.attr.attr_id >= p_ancs->parse_info.nb_of_attr)
{
NRF_LOG_DEBUG("Attribute ID Invalid.");
return DONE;
}
p_ancs->evt.attr.p_attr_data = p_ancs->parse_info.p_attr_list[p_ancs->evt.attr.attr_id].p_attr_data;
if (all_req_attrs_parsed(p_ancs))
{
NRF_LOG_DEBUG("All requested attributes received. ");
return DONE;
}
else
{
if (attr_is_requested(p_ancs, p_ancs->evt.attr))
{
p_ancs->parse_info.expected_number_of_attrs--;
}
NRF_LOG_DEBUG("Attribute ID %i ", p_ancs->evt.attr.attr_id);
return ATTR_LEN1;
}
}
/**@brief Function for handling BLE events.
*
* @param[in] p_ble_evt Bluetooth stack event.
* @param[in] p_context Unused.
*/
static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
ret_code_t err_code = NRF_SUCCESS;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected.");
// LED indication will be changed when advertising starts.
break;
case BLE_GAP_EVT_CONNECTED:
NRF_LOG_INFO("Connected.");
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr, m_conn_handle);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
{
NRF_LOG_DEBUG("PHY update request.");
ble_gap_phys_t const phys =
{
.rx_phys = BLE_GAP_PHY_AUTO,
.tx_phys = BLE_GAP_PHY_AUTO,
};
err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
APP_ERROR_CHECK(err_code);
} break;
case BLE_GATTC_EVT_TIMEOUT:
// Disconnect on GATT Client timeout event.
NRF_LOG_DEBUG("GATT Client Timeout.");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server timeout event.
NRF_LOG_DEBUG("GATT Server Timeout.");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
default:
// No implementation needed.
break;
}
}
uint32_t nrf_dfu_mbr_compare(uint32_t * p_ptr1, uint32_t * p_ptr2, uint32_t len)
{
uint32_t ret_val;
uint32_t const len_words = len / sizeof(uint32_t);
sd_mbr_command_t command =
{
.command = SD_MBR_COMMAND_COMPARE,
.params.compare.ptr1 = p_ptr1,
.params.compare.ptr2 = p_ptr2,
.params.compare.len = len_words
};
ret_val = sd_mbr_command(&command);
return ret_val;
}
uint32_t nrf_dfu_mbr_vector_table_set(uint32_t address)
{
uint32_t ret_val;
NRF_LOG_DEBUG("running vector table set");
sd_mbr_command_t command =
{
.command = SD_MBR_COMMAND_VECTOR_TABLE_BASE_SET,
.params.base_set.address = address,
};
ret_val = sd_mbr_command(&command);
NRF_LOG_DEBUG("After running vector table set");
return ret_val;
}
#ifndef SOFTDEVICE_PRESENT
uint32_t nrf_dfu_mbr_irq_forward_address_set(uint32_t address)
{
uint32_t ret_val;
NRF_LOG_DEBUG("running irq table set");
sd_mbr_command_t command =
{
.command = SD_MBR_COMMAND_IRQ_FORWARD_ADDRESS_SET,
.params.irq_forward_address_set.address = address,
};
ret_val = sd_mbr_command(&command);
NRF_LOG_DEBUG("After running irq table set");
return ret_val;
}
/**@brief Function for handling the Disconnect event.
*
* @param[in] p_si7021 si7021 Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_disconnect(ble_si7021_t * p_si7021, ble_evt_t * p_ble_evt) {
UNUSED_PARAMETER(p_ble_evt);
NRF_LOG_DEBUG("on_disconnect\n\r");
p_si7021->conn_handle = BLE_CONN_HANDLE_INVALID;
if (p_si7021->evt_handler != NULL) {
ble_si7021_evt_t evt;
evt.evt_type = BLE_si7021_EVT_DISCONNECTED;
p_si7021->evt_handler(p_si7021, &evt);
}
NRF_LOG_DEBUG("on_disconnect %x\n\r",p_si7021->conn_handle);
}
/**@brief Function for handling the Application's BLE Stack events.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
uint32_t err_code = NRF_SUCCESS;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected\r\n");
err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
break; // BLE_GAP_EVT_DISCONNECTED
case BLE_GAP_EVT_CONNECTED:
NRF_LOG_INFO("Connected\r\n");
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
m_cur_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
err_code = ble_db_discovery_start(&m_ble_db_discovery, m_cur_conn_handle);
APP_ERROR_CHECK(err_code);
err_code = app_timer_start(m_sec_req_timer_id, SECURITY_REQUEST_DELAY, NULL);
APP_ERROR_CHECK(err_code);
break; // BLE_GAP_EVT_CONNECTED
case BLE_GATTC_EVT_TIMEOUT:
// Disconnect on GATT Client timeout event.
NRF_LOG_DEBUG("GATT Client Timeout.\r\n");
m_cur_conn_handle = BLE_CONN_HANDLE_INVALID;
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break; // BLE_GATTC_EVT_TIMEOUT
case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server timeout event.
NRF_LOG_DEBUG("GATT Server Timeout.\r\n");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break; // BLE_GATTS_EVT_TIMEOUT
#if (NRF_SD_BLE_API_VERSION == 3)
case BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST:
err_code = sd_ble_gatts_exchange_mtu_reply(p_ble_evt->evt.gatts_evt.conn_handle,
NRF_BLE_MAX_MTU_SIZE);
APP_ERROR_CHECK(err_code);
break; // BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST
#endif
default:
// No implementation needed.
break;
}
}
static void spis_irq_handler(NRF_SPIS_Type * p_spis, spis_cb_t * p_cb)
{
// @note: as multiple events can be pending for processing, the correct event processing order
// is as follows:
// - SPI semaphore acquired event.
// - SPI transaction complete event.
// Check for SPI semaphore acquired event.
if (nrf_spis_event_check(p_spis, NRF_SPIS_EVENT_ACQUIRED))
{
nrf_spis_event_clear(p_spis, NRF_SPIS_EVENT_ACQUIRED);
NRF_LOG_DEBUG("SPIS: Event: %s.\r\n", (uint32_t)EVT_TO_STR(NRF_SPIS_EVENT_ACQUIRED));
switch (p_cb->spi_state)
{
case SPIS_BUFFER_RESOURCE_REQUESTED:
nrf_spis_tx_buffer_set(p_spis, (uint8_t *)p_cb->tx_buffer, p_cb->tx_buffer_size);
nrf_spis_rx_buffer_set(p_spis, (uint8_t *)p_cb->rx_buffer, p_cb->rx_buffer_size);
nrf_spis_task_trigger(p_spis, NRF_SPIS_TASK_RELEASE);
spis_state_change(p_spis, p_cb, SPIS_BUFFER_RESOURCE_CONFIGURED);
break;
default:
// No implementation required.
break;
}
}
// Check for SPI transaction complete event.
if (nrf_spis_event_check(p_spis, NRF_SPIS_EVENT_END))
{
nrf_spis_event_clear(p_spis, NRF_SPIS_EVENT_END);
NRF_LOG_DEBUG("SPIS: Event: %s.\r\n", (uint32_t)EVT_TO_STR(NRF_SPIS_EVENT_END));
switch (p_cb->spi_state)
{
case SPIS_BUFFER_RESOURCE_CONFIGURED:
spis_state_change(p_spis, p_cb, SPIS_XFER_COMPLETED);
break;
default:
// No implementation required.
break;
}
}
}
uint32_t ble_lbs_led_status_send(ble_lbs_c_t * p_ble_lbs_c, uint8_t status)
{
VERIFY_PARAM_NOT_NULL(p_ble_lbs_c);
if (p_ble_lbs_c->conn_handle == BLE_CONN_HANDLE_INVALID)
{
return NRF_ERROR_INVALID_STATE;
}
NRF_LOG_DEBUG("writing LED status 0x%x", status);
tx_message_t * p_msg;
p_msg = &m_tx_buffer[m_tx_insert_index++];
m_tx_insert_index &= TX_BUFFER_MASK;
p_msg->req.write_req.gattc_params.handle = p_ble_lbs_c->peer_lbs_db.led_handle;
p_msg->req.write_req.gattc_params.len = sizeof(status);
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_CMD;
p_msg->req.write_req.gattc_value[0] = status;
p_msg->conn_handle = p_ble_lbs_c->conn_handle;
p_msg->type = WRITE_REQ;
tx_buffer_process();
return NRF_SUCCESS;
}
/**@brief Function for parsing command id and notification id.
* Used in the @ref parse_get_notif_attrs_response state machine.
*
* @details UID and command ID will be received only once at the beginning of the first
* GATTC notification of a new attribute request for a given iOS notification.
*
* @param[in] p_ancs Pointer to an ANCS instance to which the event belongs.
* @param[in] p_data_src Pointer to data that was received from the Notification Provider.
* @param[in] index Pointer to an index that helps us keep track of the current data to be parsed.
*
* @return The next parse state.
*/
static ble_ancs_c_parse_state_t command_id_parse(ble_ancs_c_t * p_ancs,
const uint8_t * p_data_src,
uint32_t * index)
{
ble_ancs_c_parse_state_t parse_state;
p_ancs->parse_info.command_id = (ble_ancs_c_cmd_id_val_t) p_data_src[(*index)++];
switch (p_ancs->parse_info.command_id)
{
case BLE_ANCS_COMMAND_ID_GET_NOTIF_ATTRIBUTES:
p_ancs->evt.evt_type = BLE_ANCS_C_EVT_NOTIF_ATTRIBUTE;
p_ancs->parse_info.p_attr_list = p_ancs->ancs_notif_attr_list;
p_ancs->parse_info.nb_of_attr = BLE_ANCS_NB_OF_NOTIF_ATTR;
parse_state = NOTIF_UID;
break;
case BLE_ANCS_COMMAND_ID_GET_APP_ATTRIBUTES:
p_ancs->evt.evt_type = BLE_ANCS_C_EVT_APP_ATTRIBUTE;
p_ancs->parse_info.p_attr_list = p_ancs->ancs_app_attr_list;
p_ancs->parse_info.nb_of_attr = BLE_ANCS_NB_OF_APP_ATTR;
parse_state = APP_ID;
break;
default:
//no valid command_id, abort the rest of the parsing procedure.
NRF_LOG_DEBUG("Invalid Command ID");
parse_state = DONE;
break;
}
return parse_state;
}
/**@snippet [Handling the data received over BLE] */
static void nus_data_handler(ble_nus_t * p_nus, uint8_t * p_data, uint16_t length)
{
uint32_t err_code;
NRF_LOG_DEBUG("Received data from BLE NUS. Writing data on UART.\r\n");
NRF_LOG_HEXDUMP_DEBUG(p_data, length);
for (uint32_t i = 0; i < length; i++)
{
do
{
err_code = app_uart_put(p_data[i]);
if ((err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY))
{
NRF_LOG_ERROR("Failed receiving NUS message. Error 0x%x. \r\n", err_code);
APP_ERROR_CHECK(err_code);
}
} while (err_code == NRF_ERROR_BUSY);
}
if (p_data[length-1] == '\r')
{
while (app_uart_put('\n') == NRF_ERROR_BUSY);
}
}
/**@brief Function for application main entry.
*/
int main(void)
{
uint32_t err_code;
bool erase_bonds;
// Initialize.
err_code = NRF_LOG_INIT();
APP_ERROR_CHECK(err_code);
timers_init();
buttons_leds_init(&erase_bonds);
ble_stack_init();
peer_manager_init(erase_bonds);
if (erase_bonds == true)
{
NRF_LOG_DEBUG("Bonds erased!\r\n");
}
gap_params_init();
advertising_init();
db_discovery_init();
alert_notification_init();
conn_params_init();
// Start execution.
advertising_start();
// Enter main loop.
for (;;)
{
power_manage();
}
}
/**@brief Function for handling File Data Storage events.
*
* @param[in] p_evt Peer Manager event.
* @param[in] cmd
*/
static void fds_evt_handler(fds_evt_t const * const p_evt)
{
if (p_evt->id == FDS_EVT_GC)
{
NRF_LOG_DEBUG("GC completed\n");
}
}
uint32_t ser_sd_transport_cmd_write(const uint8_t * p_buffer,
uint16_t length,
ser_sd_transport_rsp_handler_t cmd_rsp_decode_callback)
{
uint32_t err_code = NRF_SUCCESS;
m_rsp_wait = true;
m_rsp_dec_handler = cmd_rsp_decode_callback;
err_code = ser_hal_transport_tx_pkt_send(p_buffer, length);
APP_ERROR_CHECK(err_code);
/* Execute callback for response decoding only if one was provided.*/
if ((err_code == NRF_SUCCESS) && cmd_rsp_decode_callback)
{
if (m_ot_rsp_wait_handler)
{
m_ot_rsp_wait_handler();
m_ot_rsp_wait_handler = NULL;
}
m_os_rsp_wait_handler();
err_code = m_return_value;
}
else
{
m_rsp_wait = false;
}
NRF_LOG_DEBUG("[SD_CALL]:%s, err_code= 0x%X\r\n", (uint32_t)ser_dbg_sd_call_str_get(p_buffer[1]), err_code);
return err_code;
}
/**@brief Function for checking if the erase bond button press sequence is detected.
*
* @param[out] p_erase_bonds Will be true if the clear bonding button was pressed to wake the application up.
*/
static void detect_erase_bond_pressed(bool * p_erase_bonds)
{
uint32_t err_code;
bool button;
*p_erase_bonds = false;
err_code = app_button_is_pushed(0, &button);
APP_ERROR_CHECK(err_code);
uint8_t count = 0;
while (button) {
nrf_delay_ms(100);
count++;
if (count > 20) {
*p_erase_bonds = true;
NRF_LOG_DEBUG("Erasing bonds button press detected!\r\n");
break;
}
err_code = app_button_is_pushed(0, &button);
APP_ERROR_CHECK(err_code);
}
while (button) {
nrf_gpio_pin_clear(LED_1);
nrf_delay_ms(200);
nrf_gpio_pin_set(LED_1);
nrf_delay_ms(200);
err_code = app_button_is_pushed(0, &button);
APP_ERROR_CHECK(err_code);
}
}
void ble_bas_on_db_disc_evt(ble_bas_c_t * p_ble_bas_c, const ble_db_discovery_evt_t * p_evt)
{
// Check if the Battery Service was discovered.
if (p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE
&&
p_evt->params.discovered_db.srv_uuid.uuid == BLE_UUID_BATTERY_SERVICE
&&
p_evt->params.discovered_db.srv_uuid.type == BLE_UUID_TYPE_BLE)
{
// Find the CCCD Handle of the Battery Level characteristic.
uint8_t i;
ble_bas_c_evt_t evt;
evt.evt_type = BLE_BAS_C_EVT_DISCOVERY_COMPLETE;
evt.conn_handle = p_evt->conn_handle;
for (i = 0; i < p_evt->params.discovered_db.char_count; i++)
{
if (p_evt->params.discovered_db.charateristics[i].characteristic.uuid.uuid ==
BLE_UUID_BATTERY_LEVEL_CHAR)
{
// Found Battery Level characteristic. Store CCCD handle and break.
evt.params.bas_db.bl_cccd_handle =
p_evt->params.discovered_db.charateristics[i].cccd_handle;
evt.params.bas_db.bl_handle =
p_evt->params.discovered_db.charateristics[i].characteristic.handle_value;
break;
}
}
NRF_LOG_DEBUG("Battery Service discovered at peer.\r\n");
//If the instance has been assigned prior to db_discovery, assign the db_handles
if (p_ble_bas_c->conn_handle != BLE_CONN_HANDLE_INVALID)
{
if ((p_ble_bas_c->peer_bas_db.bl_cccd_handle == BLE_GATT_HANDLE_INVALID)&&
(p_ble_bas_c->peer_bas_db.bl_handle == BLE_GATT_HANDLE_INVALID))
{
p_ble_bas_c->peer_bas_db = evt.params.bas_db;
}
}
p_ble_bas_c->evt_handler(p_ble_bas_c, &evt);
}
else
{
NRF_LOG_DEBUG("Battery Service discovery failure at peer. \r\n");
}
}
void ringbuffer_peek_at(ringbuffer_t* buffer, size_t index, void* element)
{
//Calculate element position at X, relative to ringbuffer start
size_t position = (buffer->start)+index;
if(position >= buffer->element_max) { position = position - buffer->element_max; }
NRF_LOG_DEBUG("Copying %d bytes to %d\r\n", buffer->element_size, (uint32_t)((buffer->element) + (position * buffer->element_size)));
memcpy(element, (buffer->element) + (position * buffer->element_size), buffer->element_size);
}
/**@brief Function for handling advertising events.
*
* @details This function will be called for advertising events which are passed to the application.
*
* @param[in] ble_adv_evt Advertising event.
*/
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
uint32_t err_code;
switch (ble_adv_evt)
{
case BLE_ADV_EVT_FAST:
NRF_LOG_INFO("BLE_ADV_EVT_FAST\r\n");
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_IDLE:
sleep_mode_enter();
break;
case BLE_ADV_EVT_WHITELIST_REQUEST:
{
NRF_LOG_DEBUG("BLE_ADV_EVT_WHITELIST_REQUEST\r\n");
ble_gap_addr_t whitelist_addrs[BLE_GAP_WHITELIST_ADDR_MAX_COUNT];
ble_gap_irk_t whitelist_irks[BLE_GAP_WHITELIST_ADDR_MAX_COUNT];
uint32_t addr_cnt = BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
uint32_t irk_cnt = BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
err_code = pm_whitelist_get(whitelist_addrs, &addr_cnt,
whitelist_irks, &irk_cnt);
APP_ERROR_CHECK(err_code);
NRF_LOG_DEBUG("pm_whitelist_get returns %d addr in whitelist and %d irk whitelist\r\n",
addr_cnt,
irk_cnt);
// Apply the whitelist.
err_code = ble_advertising_whitelist_reply(whitelist_addrs, addr_cnt,
whitelist_irks, irk_cnt);
APP_ERROR_CHECK(err_code);
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_WHITELIST);
APP_ERROR_CHECK(err_code);
}
break;
default:
break;
}
}
uint32_t ble_si7021_init(ble_si7021_t * p_si7021, const ble_si7021_init_t * p_si7021_init) {
uint32_t err_code;
ble_uuid_t ble_uuid;
// Initialize service structure.
p_si7021->conn_handle = BLE_CONN_HANDLE_INVALID;
p_si7021->evt_handler = p_si7021_init->evt_handler;
p_si7021->last_humraw = 0;
p_si7021->last_tempraw = 0;
p_si7021->running = 0;
p_si7021->interval = 1000; // i.e. 1000ms
// Add a Vendor Specific UUID 128-Bit
ble_uuid128_t base_uuid = {BLE_si7021_UUID_BASE};
err_code = sd_ble_uuid_vs_add(&base_uuid, &p_si7021->uuid_type);
if (err_code != NRF_SUCCESS) {
return err_code;
}
ble_uuid.type = p_si7021->uuid_type;
ble_uuid.uuid = BLE_si7021_UUID_SERVICE;
// Add a service declaration to the Attribute Table
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_si7021->service_handle);
if (err_code != NRF_SUCCESS) {
return err_code;
}
NRF_LOG_DEBUG("sd_ble_gatts_service_add %x,%x\n\r",p_si7021->conn_handle,p_si7021->value_char_handles.value_handle);
//
err_code = ble_si7021_com_char_add(p_si7021, p_si7021_init);
if (err_code != NRF_SUCCESS) {
return err_code;
}
NRF_LOG_DEBUG("ble_si7021_com_char_add %x,%x\n\r",p_si7021->conn_handle,p_si7021->com_char_handles.value_handle);
//
err_code = ble_si7021_value_char_add(p_si7021, p_si7021_init);
if (err_code != NRF_SUCCESS) {
return err_code;
}
NRF_LOG_DEBUG("ble_si7021_value_char_add %x,%x\n\r",p_si7021->conn_handle,p_si7021->value_char_handles.value_handle);
return NRF_SUCCESS;
}
/**@brief Function for handling events from the GATT library. */
void gatt_evt_handler(nrf_ble_gatt_t * p_gatt, const nrf_ble_gatt_evt_t * p_evt)
{
if ((m_conn_handle == p_evt->conn_handle) && (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED))
{
m_ble_nus_max_data_len = p_evt->params.att_mtu_effective - OPCODE_LENGTH - HANDLE_LENGTH;
NRF_LOG_INFO("Data len is set to 0x%X(%d)\r\n", m_ble_nus_max_data_len, m_ble_nus_max_data_len);
}
NRF_LOG_DEBUG("ATT MTU exchange completed. central 0x%x peripheral 0x%x\r\n", p_gatt->att_mtu_desired_central, p_gatt->att_mtu_desired_periph);
}
int32_t VL53L0X_comms_initialise(uint8_t comms_type, uint16_t comms_speed_khz){
if(comms_type == SPI){
NRF_LOG_ERROR("SPI not supported. Use I2C.\r\n");
return 1;
} else if(comms_type != I2C){
NRF_LOG_ERROR("Invalid communication protocol with VL53L0X. Use I2C.\r\n");
return 1;
}
uint32_t nrf_speed;
if(comms_speed_khz == 400){
nrf_speed = NRF_TWI_FREQ_400K;
} else if(comms_speed_khz == 250){
nrf_speed = NRF_TWI_FREQ_250K;
} else if(comms_speed_khz == 100){
nrf_speed = NRF_TWI_FREQ_100K;
} else {
NRF_LOG_ERROR("Invalid TWI comms speed.");
return 1;
}
ret_code_t ret;
const nrf_drv_twi_config_t config =
{
.scl = TWI_SCL_M,
.sda = TWI_SDA_M,
.frequency = nrf_speed,
.interrupt_priority = APP_IRQ_PRIORITY_HIGH,
.clear_bus_init = false
};
ret = nrf_drv_twi_init(&m_twi_master, &config, NULL, NULL);
if (NRF_SUCCESS == ret)
{
nrf_drv_twi_enable(&m_twi_master);
NRF_LOG_DEBUG("TWI init successful\r\n");
} else {
NRF_LOG_ERROR("TWI init failed\r\n");
}
return ret;
};
/**
* @brief Close platform comms.
*
* @return status - status 0 = ok, 1 = error
*
*/
int32_t VL53L0X_comms_close(void){
nrf_drv_twi_disable(&m_twi_master);
return 0;
}
