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(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);
}
/**@brief Function for processing a write to the Control Point.
*
* @param[in] p_bms Bond Management Service structure.
* @param[in] p_rcvd_val Received write value.
* @param[in] len Value length.
* @param[out] p_ctrlpt Decoded control point structure.
*/
static uint16_t ctrlpt_process(nrf_ble_bms_t * p_bms,
uint8_t * p_rcvd_val,
uint16_t len,
nrf_ble_bms_ctrlpt_t * p_ctrlpt)
{
ret_code_t err_code;
/* Decode operation */
err_code = ctrlpt_decode(p_rcvd_val, len, p_ctrlpt);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Control point write: Operation failed.\r\n");
return NRF_BLE_BMS_OPERATION_FAILED;
}
/* Verify that the operation is allowed. */
if (!ctrlpt_validate(p_ctrlpt, &p_bms->feature))
{
NRF_LOG_ERROR("Control point write: Invalid op code.\r\n");
return NRF_BLE_BMS_OPCODE_NOT_SUPPORTED;
}
/* Request authorization */
ctrlpt_auth(p_bms, p_ctrlpt);
if (p_bms->auth_status != NRF_BLE_BMS_AUTH_STATUS_ALLOWED)
{
NRF_LOG_ERROR("Control point long write: Invalid auth.\r\n");
return BLE_GATT_STATUS_ATTERR_INSUF_AUTHORIZATION;
}
return BLE_GATT_STATUS_SUCCESS;
}
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;
}
nrf_dfu_result_t nrf_dfu_ver_validation_check(dfu_init_command_t const * p_init)
{
nrf_dfu_result_t ret_val = NRF_DFU_RES_CODE_SUCCESS;
if (!fw_type_ok(p_init))
{
NRF_LOG_ERROR("Invalid firmware type.");
ret_val = EXT_ERR(NRF_DFU_EXT_ERROR_INIT_COMMAND_INVALID);
}
else if (!fw_hash_type_ok(p_init))
{
NRF_LOG_ERROR("Invalid hash type.");
ret_val = EXT_ERR(NRF_DFU_EXT_ERROR_WRONG_HASH_TYPE);
}
else if (!NRF_DFU_DEBUG ||
(NRF_DFU_DEBUG && ((p_init->has_is_debug == false) || (p_init->is_debug == false))))
{
if (p_init->has_hw_version == false)
{
NRF_LOG_ERROR("No HW version.");
ret_val = EXT_ERR(NRF_DFU_EXT_ERROR_INIT_COMMAND_INVALID);
}
else if (p_init->hw_version != NRF_DFU_HW_VERSION)
{
NRF_LOG_WARNING("Faulty HW version.");
ret_val = EXT_ERR( NRF_DFU_EXT_ERROR_HW_VERSION_FAILURE);
}
else if (!sd_req_ok(p_init))
{
NRF_LOG_WARNING("SD req not met.");
ret_val = EXT_ERR(NRF_DFU_EXT_ERROR_SD_VERSION_FAILURE);
}
else if (p_init->has_fw_version)
{
if (!fw_version_ok(p_init))
{
NRF_LOG_WARNING("FW version too low.");
ret_val = EXT_ERR(NRF_DFU_EXT_ERROR_FW_VERSION_FAILURE);
}
}
else
{
if (fw_version_required(p_init->type))
{
NRF_LOG_ERROR("FW version missing.");
ret_val = EXT_ERR(NRF_DFU_EXT_ERROR_INIT_COMMAND_INVALID);
}
}
}
return ret_val;
}
/**
* Execute LIS2DH12 Selftest
* TODO: Run the self-test internal to device
*
* @return LIS2DH12_RET_OK Selftest passed
* @return LIS2DH12_RET_ERROR_SELFTEST Selftest failed
*/
static lis2dh12_ret_t selftest(void)
{
uint8_t value[1] = {0};
lis2dh12_read_register(LIS2DH12_WHO_AM_I, value, 1);
if(LIS2DH12_I_AM_MASK != value[0]) { NRF_LOG_ERROR("WHO_AM_I: %x\r\n", value[0])}
return (LIS2DH12_I_AM_MASK == value[0]) ? LIS2DH12_RET_OK : LIS2DH12_RET_ERROR;
}
/**@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);
}
}
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 BLE_GAP_ADV_REPORT events.
* Search for a peer with matching device name.
* If found, stop advertising and send a connection request to the peer.
*/
void on_ble_gap_evt_adv_report(ble_gap_evt_t const * p_gap_evt)
{
if (!find_adv_name(&p_gap_evt->params.adv_report, m_target_periph_name))
{
return;
}
NRF_LOG_INFO("Device \"%s\" found, sending a connection request.\r\n",
(uint32_t) m_target_periph_name);
// Stop advertising.
(void) sd_ble_gap_adv_stop();
// Initiate connection.
m_conn_param.min_conn_interval = CONN_INTERVAL_DEFAULT;
m_conn_param.max_conn_interval = CONN_INTERVAL_DEFAULT;
ret_code_t err_code;
err_code = sd_ble_gap_connect(&p_gap_evt->params.adv_report.peer_addr,
&m_scan_param,
&m_conn_param);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("sd_ble_gap_connect() failed: 0x%x.\r\n", err_code);
}
}
uint32_t serial_dfu_transport_init(void)
{
uint32_t err_code;
leds_init();
m_dfu.slip.p_buffer = m_dfu.recv_buffer;
m_dfu.slip.current_index = 0;
m_dfu.slip.buffer_len = sizeof(m_dfu.recv_buffer);
m_dfu.slip.state = SLIP_STATE_DECODING;
nrf_drv_uart_config_t uart_config = NRF_DRV_UART_DEFAULT_CONFIG;
uart_config.pseltxd = TX_PIN_NUMBER;
uart_config.pselrxd = RX_PIN_NUMBER;
uart_config.pselcts = CTS_PIN_NUMBER;
uart_config.pselrts = RTS_PIN_NUMBER;
uart_config.hwfc = NRF_UART_HWFC_ENABLED;
uart_config.p_context = &m_dfu;
nrf_drv_uart_t instance = NRF_DRV_UART_INSTANCE(0);
memcpy(&m_dfu.uart_instance, &instance, sizeof(instance));
err_code = nrf_drv_uart_init(&m_dfu.uart_instance,
&uart_config,
uart_event_handler);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Failed initializing uart\n");
return err_code;
}
nrf_drv_uart_rx_enable(&m_dfu.uart_instance);
err_code = nrf_drv_uart_rx(&m_dfu.uart_instance, &m_dfu.uart_buffer, 1);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Failed initializing rx\n");
}
NRF_LOG_DEBUG("UART initialized\n");
return err_code;
}
void nrf_esb_error_handler(uint32_t err_code, uint32_t line)
{
NRF_LOG_ERROR("App failed at line %d with error code: 0x%08x\r\n",
line, err_code);
#if DEBUG //lint -e553
while (true);
#else
NVIC_SystemReset();
#endif
}
uint32_t nrf_dfu_svci_vector_table_set(void)
{
uint32_t err_code;
if (NRF_UICR->NRFFW[0] != 0xFFFFFFFF)
{
NRF_LOG_INFO("Setting vector table to bootloader: 0x%08x", NRF_UICR->NRFFW[0]);
err_code = sd_softdevice_vector_table_base_set(NRF_UICR->NRFFW[0]);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Failed running sd_softdevice_vector_table_base_set");
return err_code;
}
return NRF_SUCCESS;
}
NRF_LOG_ERROR("No bootloader was found");
return NRF_ERROR_NO_MEM;
}
/**
* Function is implemented as weak so that it can be overwritten by custom application error handler
* when needed.
*/
__WEAK void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info)
{
__disable_irq();
NRF_LOG_FINAL_FLUSH();
#ifndef DEBUG
NRF_LOG_ERROR("Fatal error");
#else
switch (id)
{
#if defined(SOFTDEVICE_PRESENT) && SOFTDEVICE_PRESENT
case NRF_FAULT_ID_SD_ASSERT:
NRF_LOG_ERROR("SOFTDEVICE: ASSERTION FAILED");
break;
case NRF_FAULT_ID_APP_MEMACC:
NRF_LOG_ERROR("SOFTDEVICE: INVALID MEMORY ACCESS");
break;
#endif
case NRF_FAULT_ID_SDK_ASSERT:
{
assert_info_t * p_info = (assert_info_t *)info;
NRF_LOG_ERROR("ASSERTION FAILED at %s:%u",
p_info->p_file_name,
p_info->line_num);
break;
}
case NRF_FAULT_ID_SDK_ERROR:
{
error_info_t * p_info = (error_info_t *)info;
NRF_LOG_ERROR("ERROR %u [%s] at %s:%u\r\nPC at: 0x%08x",
p_info->err_code,
nrf_strerror_get(p_info->err_code),
p_info->p_file_name,
p_info->line_num,
pc);
NRF_LOG_ERROR("End of error report");
break;
}
default:
NRF_LOG_ERROR("UNKNOWN FAULT at 0x%08X", pc);
break;
}
#endif
NRF_BREAKPOINT_COND;
// On assert, the system can only recover with a reset.
#ifndef DEBUG
NRF_LOG_WARNING("System reset");
NVIC_SystemReset();
#else
app_error_save_and_stop(id, pc, info);
#endif // DEBUG
}
/**
* Function is implemented as weak so that it can be overwritten by custom application error handler
* when needed.
*/
__WEAK void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info)
{
static volatile struct
{
uint32_t fault_id;
uint32_t pc;
uint32_t error_info;
assert_info_t * p_assert_info;
error_info_t * p_error_info;
ret_code_t err_code;
uint32_t line_num;
const uint8_t * p_file_name;
} m_error_data = {0};
// The following variable helps Keil keep the call stack visible, in addition, it can be set to
// 0 in the debugger to continue executing code after the error check.
volatile bool loop = true;
UNUSED_VARIABLE(loop);
m_error_data.fault_id = id;
m_error_data.pc = pc;
m_error_data.error_info = info;
switch (id)
{
case NRF_FAULT_ID_SDK_ASSERT:
m_error_data.p_assert_info = (assert_info_t *)info;
m_error_data.line_num = m_error_data.p_assert_info->line_num;
m_error_data.p_file_name = m_error_data.p_assert_info->p_file_name;
rt_kprintf("app Assert fault handler:Line(%d)-File(%s)\n",
m_error_data.line_num, m_error_data.p_file_name);
break;
case NRF_FAULT_ID_SDK_ERROR:
m_error_data.p_error_info = (error_info_t *)info;
m_error_data.err_code = m_error_data.p_error_info->err_code;
m_error_data.line_num = m_error_data.p_error_info->line_num;
m_error_data.p_file_name = m_error_data.p_error_info->p_file_name;
rt_kprintf("app error fault handler:Line(%d)-File(%s)\n",
m_error_data.line_num, m_error_data.p_file_name);
break;
}
NRF_LOG_ERROR("Fatal\r\n");
NRF_LOG_FINAL_FLUSH();
// On assert, the system can only recover with a reset.
#ifndef DEBUG
NRF_LOG_INFO("Hit weak handler\r\n");
NVIC_SystemReset();
#else
app_error_save_and_stop(id, pc, info);
#endif // DEBUG
}
void nrf_dfu_settings_init(bool sd_irq_initialized)
{
NRF_LOG_DEBUG("Running nrf_dfu_settings_init(sd_irq_initialized=%s).",
sd_irq_initialized ? (uint32_t)"true" : (uint32_t)"false");
ret_code_t rc = nrf_dfu_flash_init(sd_irq_initialized);
if (rc != NRF_SUCCESS)
{
NRF_LOG_ERROR("nrf_dfu_flash_init() failed with error: %x", rc);
APP_ERROR_HANDLER(rc);
}
// Copy the DFU settings out of flash and into a buffer in RAM.
memcpy((void*)&s_dfu_settings, m_dfu_settings_buffer, sizeof(nrf_dfu_settings_t));
if (s_dfu_settings.crc != 0xFFFFFFFF)
{
// CRC is set. Content must be valid
uint32_t crc = nrf_dfu_settings_crc_get();
if (crc == s_dfu_settings.crc)
{
return;
}
}
// Reached if the page is erased or CRC is wrong.
NRF_LOG_DEBUG("Resetting bootloader settings.");
memset(&s_dfu_settings, 0x00, sizeof(nrf_dfu_settings_t));
s_dfu_settings.settings_version = NRF_DFU_SETTINGS_VERSION;
rc = nrf_dfu_settings_write(NULL);
if (rc != NRF_SUCCESS)
{
NRF_LOG_ERROR("nrf_dfu_flash_write() failed with error: %x", rc);
APP_ERROR_HANDLER(rc);
}
}
uint32_t nrf_dfu_svci_vector_table_unset(void)
{
uint32_t err_code;
NRF_LOG_INFO("Setting vector table to main app: 0x%08x", APP_START_ADDR);
err_code = sd_softdevice_vector_table_base_set(APP_START_ADDR);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Failed running sd_softdevice_vector_table_base_set");
return err_code;
}
return NRF_SUCCESS;
}
uint32_t nrf_dfu_flash_init(bool sd_enabled)
{
uint32_t err_code = NRF_SUCCESS;
#ifdef BLE_STACK_SUPPORT_REQD
// Only run this initialization if SD is enabled
if(sd_enabled)
{
NRF_LOG_INFO("------- nrf_dfu_flash_init-------\r\n");
if (fs_fake_init() != FS_SUCCESS)
{
NRF_LOG_ERROR("Not initializing the thing\r\n");
return NRF_ERROR_INVALID_STATE;
}
// Enable access to the whole range
err_code = softdevice_sys_evt_handler_set(fs_sys_event_handler);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Not initializing the thing 2\r\n");
return NRF_ERROR_INVALID_STATE;
}
// Setting flag to indicate that SD is enabled to ensure fstorage is use in calls
// to do flash operations.
m_flags = FLASH_FLAG_SD_ENABLED;
}
else
#endif
{
m_flags = FLASH_FLAG_NONE;
}
return err_code;
}
/**@brief Handle execute write events to from the Queued Write module.
*
* @param[in] p_bms Bond Management Service structure.
* @param[in] p_qwr Queued Write Structure.
* @param[in] p_evt Event received from the Queued Writes module.
*
* @retval BLE_GATT_STATUS_SUCCESS If the received event is accepted.
* @retval BLE_BMS_OPCODE_OPERATION_FAILED If the received event is not relevant for any of this module's attributes.
* @retval BLE_BMS_OPCODE_NOT_SUPPORTED If the received opcode is not supported.
*/
uint16_t on_qwr_exec_write(nrf_ble_bms_t * p_bms, nrf_ble_qwr_t * p_qwr, nrf_ble_qwr_evt_t * p_evt)
{
ret_code_t err_code;
uint16_t len = NRF_BLE_BMS_CTRLPT_MAX_LEN;
uint8_t mem_buffer[NRF_BLE_BMS_CTRLPT_MAX_LEN];
nrf_ble_bms_ctrlpt_t ctrlpt;
ble_gatts_value_t ctrlpt_value;
ctrlpt_value.len = NRF_BLE_BMS_CTRLPT_MAX_LEN;
ctrlpt_value.offset = 0;
ctrlpt_value.p_value = mem_buffer;
const uint16_t ctrlpt_handle = p_bms->ctrlpt_handles.value_handle;
err_code = sd_ble_gatts_value_get(p_bms->conn_handle, ctrlpt_handle, &ctrlpt_value);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Control point write: Operation failed.\r\n");
return NRF_BLE_BMS_OPERATION_FAILED;
}
/* Decode operation */
err_code = ctrlpt_decode(ctrlpt_value.p_value, len, &ctrlpt);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Control point write: Operation failed.\r\n");
return NRF_BLE_BMS_OPERATION_FAILED;
}
/* Execute the requested operation. */
ctrlpt_execute(p_bms, ctrlpt.op_code);
/* Reset authorization status */
p_bms->auth_status = NRF_BLE_BMS_AUTH_STATUS_DENIED;
return BLE_GATT_STATUS_SUCCESS;
}
/**@brief Handle authorization request events from the Queued Write module.
*
* @param[in] p_bms Bond Management Service structure.
* @param[in] p_qwr Queued Write Structure.
* @param[in] p_evt Event received from the Queued Writes module.
*
* @retval BLE_GATT_STATUS_SUCCESS If the received event is accepted.
* @retval BLE_BMS_OPCODE_OPERATION_FAILED If the received event is not relevant for any of this module's attributes.
* @retval BLE_BMS_OPCODE_NOT_SUPPORTED If the received opcode is not supported.
* @retval BLE_GATT_STATUS_ATTERR_INSUF_AUTHORIZATION If the application handler returns that the authorization code is not valid.
*/
uint16_t on_qwr_auth_req(nrf_ble_bms_t * p_bms, nrf_ble_qwr_t * p_qwr, nrf_ble_qwr_evt_t * p_evt)
{
ret_code_t err_code;
uint16_t len = NRF_BLE_BMS_CTRLPT_MAX_LEN;
uint8_t mem_buffer[NRF_BLE_BMS_CTRLPT_MAX_LEN];
nrf_ble_bms_ctrlpt_t ctrlpt;
err_code = nrf_ble_qwr_value_get(p_qwr, p_evt->attr_handle, mem_buffer, &len);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Control point write: Operation failed.\r\n");
return NRF_BLE_BMS_OPERATION_FAILED;
}
return ctrlpt_process(p_bms, mem_buffer, len, &ctrlpt);
}
/*lint -save -e14 */
void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info)
{
// disable INTs
CRITICAL_REGION_ENTER();
NRF_LOG_ERROR("Fatal error");
NRF_LOG_FINAL_FLUSH();
#if LEDS_NUMBER > 0
/* Light a LED on error or warning. */
// nrf_gpio_cfg_output(SER_CONN_ASSERT_LED_PIN);
// nrf_gpio_pin_set(SER_CONN_ASSERT_LED_PIN);
#endif
// m_p_error_file_name = p_file_name;
// m_error_code = error_code;
// m_error_line_num = line_num;
/* Do not reset when warning. */
if (SER_WARNING_CODE != id)
{
/* This call can be used for debug purposes during application development.
* @note CAUTION: Activating code below will write the stack to flash on an error.
* This function should NOT be used in a final product.
* It is intended STRICTLY for development/debugging purposes.
* The flash write will happen EVEN if the radio is active, thus interrupting any communication.
* Use with care. Un-comment the line below to use. */
/* ble_debug_assert_handler(error_code, line_num, p_file_name); */
#ifndef DEBUG
/* Reset the chip. Should be used in the release version. */
NVIC_SystemReset();
#else /* Debug version. */
/* To be able to see function parameters in a debugger. */
uint32_t temp = 1;
while (temp);
#endif
}
CRITICAL_REGION_EXIT();
}
dsp_filter_t dsp_init(ruuvi_dsp_function_t type, uint8_t dsp_parameter)
{
dsp_filter_t filter;
memset(&filter, 0, sizeof(filter));
switch(type)
{
case DSP_STDEV:
filter.process = dsp_process_stdev;
filter.read = dsp_read_stdev;
filter.dsp_parameter = dsp_parameter;
ringbuffer_init(&filter.z, dsp_parameter, sizeof(float));
break;
default:
NRF_LOG_ERROR("Unknown filter type\r\n");
break;
}
return filter;
}
void HardFault_c_handler(uint32_t * p_stack_address)
{
#if defined(DEBUG_NRF)
HardFault_p_stack = (HardFault_stack_t *)p_stack_address;
(void)HardFault_p_stack;
// Debugger detection is only possible on NRF52 (Cortex-M4), on NRF51
// (Cortex-M0) the processor has no access to CoreDebug registers.
#if __CORTEX_M == 0x04
// C_DEBUGEN == 1 -> Debugger Connected
if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
{
/* Generate breakpoint if debugger is connected */
NRF_BREAKPOINT;
}
#endif // __CORTEX_M == 0x04
#endif // DEBUG_NRF
NRF_LOG_ERROR("Hardfault PC:%x\r\n", ((HardFault_stack_t *)p_stack_address)->pc);
NRF_LOG_FINAL_FLUSH();
HardFault_process((HardFault_stack_t *)p_stack_address);
}
uint32_t nrf_dfu_init(nrf_dfu_observer_t observer)
{
uint32_t ret_val;
m_user_observer = observer;
NRF_LOG_INFO("Entering DFU mode.");
dfu_observer(NRF_DFU_EVT_DFU_INITIALIZED);
// Initializing transports
ret_val = nrf_dfu_transports_init(dfu_observer);
if (ret_val != NRF_SUCCESS)
{
NRF_LOG_ERROR("Could not initalize DFU transport: 0x%08x", ret_val);
return ret_val;
}
ret_val = nrf_dfu_req_handler_init(dfu_observer);
return ret_val;
}
static void fs_evt_handler(fs_evt_t const * const evt, fs_ret_t result)
{
// Clear the operation flag
m_flags &= ~FLASH_FLAG_OPER;
if (result == FS_SUCCESS)
{
// Clear flag for ongoing operation and failure since last
m_flags &= ~FLASH_FLAG_FAILURE_SINCE_LAST;
}
else
{
NRF_LOG_ERROR("Generating failure\r\n");
m_flags |= FLASH_FLAG_FAILURE_SINCE_LAST;
}
if (evt->p_context)
{
//lint -e611
((dfu_flash_callback_t)evt->p_context)(evt, result);
}
}
uint32_t softdevice_enable(ble_enable_params_t * p_ble_enable_params)
{
#if (defined(S130) || defined(S132) || defined(S332))
uint32_t err_code;
uint32_t app_ram_base;
#if defined ( __CC_ARM )
extern uint32_t Image$$RW_IRAM1$$Base;
const volatile uint32_t ram_start = (uint32_t) &Image$$RW_IRAM1$$Base;
#elif defined ( __ICCARM__ )
extern uint32_t __ICFEDIT_region_RAM_start__;
volatile uint32_t ram_start = (uint32_t) &__ICFEDIT_region_RAM_start__;
#elif defined ( __GNUC__ )
extern uint32_t __data_start__;
volatile uint32_t ram_start = (uint32_t) &__data_start__;
#endif
app_ram_base = ram_start;
NRF_LOG_DEBUG("sd_ble_enable: RAM start at 0x%x\r\n",
app_ram_base);
err_code = sd_ble_enable(p_ble_enable_params, &app_ram_base);
if (app_ram_base != ram_start)
{
NRF_LOG_WARNING("sd_ble_enable: RAM start should be adjusted to 0x%x\r\n",
app_ram_base);
NRF_LOG_WARNING("RAM size should be adjusted to 0x%x \r\n",
ram_end_address_get() - app_ram_base);
}
else if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("sd_ble_enable: error 0x%x\r\n", err_code);
}
return err_code;
#else
return NRF_SUCCESS;
#endif //defined(S130) || defined(S132) || defined(S332)
}
void test_terminate(void)
{
m_run_test = false;
m_notif_enabled = false;
m_mtu_exchanged = false;
m_conn_interval_configured = false;
if (m_conn_handle != BLE_CONN_HANDLE_INVALID)
{
NRF_LOG_INFO("Disconnecting...\r\n");
ret_code_t err_code;
err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("sd_ble_gap_disconnect() failed: 0x%0x.\r\n", err_code);
}
}
else
{
if (m_board_role == BOARD_TESTER)
{
m_print_menu = true;
}
if (m_board_role == BOARD_DUMMY)
{
if (m_gap_role == BLE_GAP_ROLE_PERIPH)
{
advertising_start();
}
else
{
scan_start();
}
}
}
}
fs_ret_t nrf_dfu_flash_wait(void)
{
NRF_LOG_INFO("Waiting for finished...\r\n");
#ifdef BLE_STACK_SUPPORT_REQD
if ((m_flags & FLASH_FLAG_SD_ENABLED) != 0)
{
while ((m_flags & FLASH_FLAG_OPER) != 0)
{
(void)sd_app_evt_wait();
}
if ((m_flags & FLASH_FLAG_FAILURE_SINCE_LAST) != 0)
{
NRF_LOG_ERROR("Failure since last\r\n");
return FS_ERR_FAILURE_SINCE_LAST;
}
}
#endif
NRF_LOG_INFO("After wait!\r\n");
return FS_SUCCESS;
}
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;
// Disable interrupts
NRF_LOG_DEBUG("Disabling interrupts");
NVIC->ICER[0]=0xFFFFFFFF;
#if defined(__NRF_NVIC_ISER_COUNT) && __NRF_NVIC_ISER_COUNT == 2
NVIC->ICER[1]=0xFFFFFFFF;
#endif
NRF_LOG_DEBUG("Setting MBR irq forward address: 0x%08x", start_addr);
err_code = nrf_dfu_mbr_irq_forward_address_set(start_addr);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("Failed running nrf_dfu_mbr_irq_forward_address_set");
return;
}
// Run application
nrf_bootloader_app_start_impl(start_addr);
}
/**@brief AMT Service Handler.
*/
static void amts_evt_handler(nrf_ble_amts_evt_t evt)
{
ret_code_t err_code;
switch (evt.evt_type)
{
case SERVICE_EVT_NOTIF_ENABLED:
{
NRF_LOG_INFO("Notifications enabled.\r\n");
bsp_board_led_on(LED_READY);
m_notif_enabled = true;
if (m_board_role != BOARD_TESTER)
{
return;
}
if (m_gap_role == BLE_GAP_ROLE_PERIPH)
{
m_conn_interval_configured = false;
m_conn_param.min_conn_interval = m_test_params.conn_interval;
m_conn_param.max_conn_interval = m_test_params.conn_interval + 1;
err_code = ble_conn_params_change_conn_params(&m_conn_param);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("ble_conn_params_change_conn_params() failed: 0x%x.\r\n",
err_code);
}
}
if (m_gap_role == BLE_GAP_ROLE_CENTRAL)
{
m_conn_interval_configured = true;
m_conn_param.min_conn_interval = m_test_params.conn_interval;
m_conn_param.max_conn_interval = m_test_params.conn_interval;
err_code = sd_ble_gap_conn_param_update(m_conn_handle, &m_conn_param);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("sd_ble_gap_conn_param_update() failed: 0x%x.\r\n", err_code);
}
}
} break;
case SERVICE_EVT_NOTIF_DISABLED:
{
NRF_LOG_INFO("Notifications disabled.\r\n");
bsp_board_led_off(LED_READY);
} break;
case SERVICE_EVT_TRANSFER_1KB:
{
NRF_LOG_INFO("Sent %u KBytes\r\n", (evt.bytes_transfered_cnt / 1024));
bsp_board_led_invert(LED_PROGRESS);
} break;
case SERVICE_EVT_TRANSFER_FINISHED:
{
// Stop counter as soon as possible.
counter_stop();
bsp_board_led_off(LED_PROGRESS);
bsp_board_led_on(LED_FINISHED);
uint32_t time_ms = counter_get();
uint32_t bit_count = (evt.bytes_transfered_cnt * 8);
float throughput = (((float)(bit_count * 100) / time_ms) / 1024);
NRF_LOG_INFO("Done.\r\n\r\n");
NRF_LOG_INFO("=============================\r\n");
NRF_LOG_INFO("Time: %u.%.2u seconds elapsed.\r\n",
(counter_get() / 100), (counter_get() % 100));
NRF_LOG_INFO("Throughput: " NRF_LOG_FLOAT_MARKER " Kbits/s.\r\n",
NRF_LOG_FLOAT(throughput));
NRF_LOG_INFO("=============================\r\n");
NRF_LOG_INFO("Sent %u bytes of ATT payload.\r\n", evt.bytes_transfered_cnt);
NRF_LOG_INFO("Retrieving amount of bytes received from peer...\r\n");
err_code = nrf_ble_amtc_rcb_read(&m_amtc);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("nrf_ble_amtc_rcb_read() failed: 0x%x.\r\n", err_code);
test_terminate();
}
} break;
}
}
static void on_packet_received(serial_dfu_t * p_dfu)
{
nrf_dfu_req_t dfu_req;
nrf_dfu_res_t dfu_res = {{{0}}};
serial_dfu_response_t serial_response;
memset(&dfu_req, 0, sizeof(nrf_dfu_req_t));
const serial_dfu_op_code_t op_code = (serial_dfu_op_code_t)p_dfu->recv_buffer[0];
const uint16_t packet_payload_len = p_dfu->slip.current_index - 1;
uint8_t * p_payload = &p_dfu->recv_buffer[1];
serial_response.op_code = op_code;
nrf_gpio_pin_clear(CONNECTED_LED_PIN_NO);
nrf_gpio_pin_set(AVAILABLE_LED_PIN_NO);
switch (op_code)
{
case SERIAL_DFU_OP_CODE_CREATE_OBJECT:
if (packet_payload_len != CREATE_OBJECT_REQUEST_LEN)
{
serial_response.resp_val = NRF_DFU_RES_CODE_INVALID_PARAMETER;
break;
}
NRF_LOG_DEBUG("Received create object\r\n");
// Reset the packet receipt notification on create object
p_dfu->pkt_notif_target_count = p_dfu->pkt_notif_target;
// Get type parameter
dfu_req.obj_type = p_payload[0];
// Get length value
dfu_req.object_size = uint32_decode(&p_payload[1]);
// Set req type
dfu_req.req_type = NRF_DFU_OBJECT_OP_CREATE;
serial_response.resp_val = nrf_dfu_req_handler_on_req(NULL, &dfu_req, &dfu_res);
break;
case SERIAL_DFU_OP_CODE_SET_RECEIPT_NOTIF:
NRF_LOG_DEBUG("Set receipt notif\r\n");
if (packet_payload_len != SET_RECEIPT_NOTIF_REQUEST_LEN)
{
serial_response.resp_val = NRF_DFU_RES_CODE_INVALID_PARAMETER;
break;
}
p_dfu->pkt_notif_target = uint16_decode(&p_payload[0]);
p_dfu->pkt_notif_target_count = p_dfu->pkt_notif_target;
serial_response.resp_val = NRF_DFU_RES_CODE_SUCCESS;
break;
case SERIAL_DFU_OP_CODE_CALCULATE_CRC:
NRF_LOG_DEBUG("Received calculate CRC\r\n");
dfu_req.req_type = NRF_DFU_OBJECT_OP_CRC;
serial_response.resp_val = nrf_dfu_req_handler_on_req(NULL, &dfu_req, &dfu_res);
serial_response.crc_response.offset = dfu_res.offset;
serial_response.crc_response.crc = dfu_res.crc;
break;
case SERIAL_DFU_OP_CODE_EXECUTE_OBJECT:
NRF_LOG_DEBUG("Received execute object\r\n");
// Set req type
dfu_req.req_type = NRF_DFU_OBJECT_OP_EXECUTE;
serial_response.resp_val = nrf_dfu_req_handler_on_req(NULL, &dfu_req, &dfu_res);
break;
case SERIAL_DFU_OP_CODE_SELECT_OBJECT:
NRF_LOG_DEBUG("Received select object\r\n");
if (packet_payload_len != SELECT_OBJECT_REQUEST_LEN)
{
serial_response.resp_val = NRF_DFU_RES_CODE_INVALID_PARAMETER;
break;
}
// Set object type to read info about
dfu_req.obj_type = p_payload[0];
dfu_req.req_type = NRF_DFU_OBJECT_OP_SELECT;
serial_response.resp_val = nrf_dfu_req_handler_on_req(NULL, &dfu_req, &dfu_res);
serial_response.select_response.max_size = dfu_res.max_size;
serial_response.select_response.offset = dfu_res.offset;
serial_response.select_response.crc = dfu_res.crc;
break;
case SERIAL_DFU_OP_CODE_GET_SERIAL_MTU:
NRF_LOG_DEBUG("Received get serial mtu\r\n");
serial_response.resp_val = NRF_DFU_RES_CODE_SUCCESS;
serial_response.serial_mtu_response.mtu = sizeof(p_dfu->recv_buffer);
break;
case SERIAL_DFU_OP_CODE_WRITE_OBJECT:
// Set req type
dfu_req.req_type = NRF_DFU_OBJECT_OP_WRITE;
// Set data and length
dfu_req.p_req = &p_payload[0];
dfu_req.req_len = packet_payload_len;
serial_response.resp_val = nrf_dfu_req_handler_on_req(NULL, &dfu_req, &dfu_res);
if(serial_response.resp_val != NRF_DFU_RES_CODE_SUCCESS)
{
NRF_LOG_ERROR("Failure to run packet write\r\n");
}
// Check if a packet receipt notification is needed to be sent.
if (p_dfu->pkt_notif_target != 0 && --p_dfu->pkt_notif_target_count == 0)
{
serial_response.op_code = SERIAL_DFU_OP_CODE_CALCULATE_CRC;
serial_response.crc_response.offset = dfu_res.offset;
serial_response.crc_response.crc = dfu_res.crc;
// Reset the counter for the number of firmware packets.
p_dfu->pkt_notif_target_count = p_dfu->pkt_notif_target;
}
break;
default:
// Unsupported op code.
NRF_LOG_WARNING("Received unsupported OP code\r\n");
serial_response.resp_val = NRF_DFU_RES_CODE_INVALID_PARAMETER;
break;
}
if (op_code != SERIAL_DFU_OP_CODE_WRITE_OBJECT)
{
response_send(p_dfu, &serial_response);
}
}
