/** This is where it all starts ++++++++++++++++++++++++++++++++++++++++++
main is entered as a result of one of SEVERAL events:
- Normal startup from press of reset button.
- Battery inserted.
- After DFU (Device Firmware Upgrade) at manufacturing Quality Assurance or user DFU.
- WatchDogTimer expiration and its interrupt handler didn't feed new value.
- Some error occured and
- Spontenous unknown reset.
All subsystems are initalized and any failures are noted and available later in init_status
Since some events occur after tag is deployed and no one can see the LEDs the system continues operating.
After initalizition (including setting up interrupts)
we loop here calling app_sched_execute and sd_app_evt_wait
*/
int main(void)
{
// LEDs first (they're easy and cannot fail) drivers/init/init.c
init_leds();
RED_LED_ON;
if( init_log() ) { init_status |=LOG_FAILED_INIT; }
else { NRF_LOG_INFO("LOG initalized \r\n"); } // subsequent initalizations assume log is working
// start watchdog now in case program hangs up.
// watchdog_default_handler logs error and resets the tag.
init_watchdog(NULL);
// Battery voltage initialization cannot fail under any reasonable circumstance.
battery_voltage_init();
vbat = getBattery();
if( vbat < BATTERY_MIN_V ) { init_status |=BATTERY_FAILED_INIT; }
else NRF_LOG_INFO("BATTERY initalized \r\n");
if(init_sensors() == NRF_SUCCESS )
{
model_plus = true;
NRF_LOG_INFO("Sensors initialized \r\n");
}
// Init NFC ASAP in case we're waking from deep sleep via NFC (todo)
// outputs ID:DEVICEID ,MAC:DEVICEADDR, SW:REVision
set_nfc_callback(app_nfc_callback);
if( init_nfc() ) { init_status |= NFC_FAILED_INIT; }
else { NRF_LOG_INFO("NFC init \r\n"); }
pin_interrupt_init();
if( pin_interrupt_enable(BSP_BUTTON_0, NRF_GPIOTE_POLARITY_TOGGLE, NRF_GPIO_PIN_PULLUP, button_press_handler) )
{
init_status |= BUTTON_FAILED_INIT;
}
// Initialize BLE Stack. Starts LFCLK required for timer operation.
if( init_ble() ) { init_status |= BLE_FAILED_INIT; }
bluetooth_configure_advertisement_type(STARTUP_ADVERTISEMENT_TYPE);
bluetooth_tx_power_set(BLE_TX_POWER);
bluetooth_configure_advertising_interval(ADVERTISING_INTERVAL_STARTUP);
advertisement_delay = NRF_FICR->DEVICEID[0]&0x0F;
// Priorities 2 and 3 are after SD timing critical events.
// 6, 7 after SD non-critical events.
// Triggers ADC, so use 3.
ble_radio_notification_init(3,
NRF_RADIO_NOTIFICATION_DISTANCE_800US,
on_radio_evt);
// If GATT is enabled BLE init inits peer manager which uses flash.
// BLE init should handle insufficient space gracefully (i.e. erase flash and proceed).
// Flash must be initialized after softdevice.
if(flash_init())
{
NRF_LOG_ERROR("Failed to init flash \r\n");
}
size_t flash_space_remaining = 0;
flash_free_size_get(&flash_space_remaining);
NRF_LOG_INFO("Largest continuous space remaining %d bytes\r\n", flash_space_remaining);
if(4000 > flash_space_remaining)
{
NRF_LOG_INFO("Flash space is almost used, running gc\r\n")
flash_gc_run();
flash_free_size_get(&flash_space_remaining);
NRF_LOG_INFO("Continuous space remaining after gc %d bytes\r\n", flash_space_remaining);
}
else if (flash_record_get(FDS_FILE_ID, FDS_RECORD_ID, sizeof(tag_mode), &tag_mode))
{
NRF_LOG_INFO("Did not find mode in flash, is this first boot? \r\n");
}
else
{
NRF_LOG_INFO("Loaded mode %d from flash\r\n", tag_mode);
}
if( init_rtc() ) { init_status |= RTC_FAILED_INIT; }
else { NRF_LOG_INFO("RTC initialized \r\n"); }
// Initialize lis2dh12 and BME280 - TODO: Differentiate LIS2DH12 and BME280
if (model_plus)
{
lis2dh12_reset(); // Clear memory.
// Enable Low-To-Hi rising edge trigger interrupt on nRF52 to detect acceleration events.
if (pin_interrupt_enable(INT_ACC2_PIN, NRF_GPIOTE_POLARITY_LOTOHI, NRF_GPIO_PIN_NOPULL, lis2dh12_int2_handler) )
{
init_status |= ACC_INT_FAILED_INIT;
}
nrf_delay_ms(10); // Wait for LIS reboot.
// Enable XYZ axes.
lis2dh12_enable();
lis2dh12_set_scale(LIS2DH12_SCALE);
lis2dh12_set_sample_rate(LIS2DH12_SAMPLERATE_RAWv1);
lis2dh12_set_resolution(LIS2DH12_RESOLUTION);
lis2dh12_set_activity_interrupt_pin_2(LIS2DH12_ACTIVITY_THRESHOLD);
NRF_LOG_INFO("Accelerometer configuration done \r\n");
// oversampling must be set for each used sensor.
bme280_set_oversampling_hum (BME280_HUMIDITY_OVERSAMPLING);
bme280_set_oversampling_temp (BME280_TEMPERATURE_OVERSAMPLING);
bme280_set_oversampling_press(BME280_PRESSURE_OVERSAMPLING);
bme280_set_iir(BME280_IIR);
bme280_set_interval(BME280_DELAY);
bme280_set_mode(BME280_MODE_NORMAL);
NRF_LOG_INFO("BME280 configuration done \r\n");
}
// Enter stored mode after boot - or default mode if store mode was not found
app_sched_event_put (&tag_mode, sizeof(&tag_mode), change_mode);
// Initialize repeated timer for sensor read and single-shot timer for button reset
if( init_timer(main_timer_id, APP_TIMER_MODE_REPEATED, MAIN_LOOP_INTERVAL_RAW, main_timer_handler) )
{
init_status |= TIMER_FAILED_INIT;
}
if( init_timer(reset_timer_id, APP_TIMER_MODE_SINGLE_SHOT, BUTTON_RESET_TIME, reboot) )
{
init_status |= TIMER_FAILED_INIT;
}
// Init starts timers, stop the reset
app_timer_stop(reset_timer_id);
// Log errors, add a note to NFC, blink RED to visually indicate the problem
if (init_status)
{
snprintf((char* )NFC_message, NFC_message_length, "Error: %X", init_status);
NRF_LOG_WARNING (" -- Initalization error : %X \r\n", init_status);
for ( int16_t i=0; i<13; i++)
{
RED_LED_ON;
nrf_delay_ms(500u);
RED_LED_OFF;
nrf_delay_ms(500u);
}
}
// Turn green led on if model+ with no errors.
// Power manage turns led off
if (model_plus & !init_status)
{
GREEN_LED_ON;
}
// Turn off red led, leave green on to signal model+ without errors
RED_LED_OFF;
// Wait for sensors to take first sample
nrf_delay_ms(1000);
// Get first sample from sensors
app_sched_event_put (NULL, 0, main_sensor_task);
app_sched_execute();
// Start advertising
bluetooth_advertising_start();
NRF_LOG_INFO("Advertising started\r\n");
// Enter main loop. Executes tasks scheduled by timers and interrupts.
for (;;)
{
app_sched_execute();
// Sleep until next event.
power_manage();
}
}
uint32_t nrf_dfu_find_cache(uint32_t size_req, bool dual_bank_only, uint32_t * p_address)
{
// TODO: Prevalidate p_address and p_bank
uint32_t free_size = DFU_REGION_TOTAL_SIZE - DFU_APP_DATA_RESERVED;
nrf_dfu_bank_t * p_bank;
NRF_LOG_INFO("Enter nrf_dfu_find_cache\r\n");
// Simple check if size requirement can me met
if(free_size < size_req)
{
NRF_LOG_INFO("No way to fit the new firmware on device\r\n");
return NRF_ERROR_NO_MEM;
}
NRF_LOG_INFO("Bank content\r\n");
NRF_LOG_INFO("Bank type: %d\r\n", s_dfu_settings.bank_layout);
NRF_LOG_INFO("Bank 0 code: 0x%02x: Size: %d\r\n", s_dfu_settings.bank_0.bank_code, s_dfu_settings.bank_0.image_size);
NRF_LOG_INFO("Bank 1 code: 0x%02x: Size: %d\r\n", s_dfu_settings.bank_1.bank_code, s_dfu_settings.bank_1.image_size);
// Setting bank_0 as candidate
p_bank = &s_dfu_settings.bank_0;
// Setting candidate address
(*p_address) = MAIN_APPLICATION_START_ADDR;
// Calculate free size
if (s_dfu_settings.bank_0.bank_code == NRF_DFU_BANK_VALID_APP)
{
// Valid app present.
NRF_LOG_INFO("free_size before bank select: %d\r\n", free_size);
free_size -= align_to_page(p_bank->image_size, CODE_PAGE_SIZE);
NRF_LOG_INFO("free_size: %d, size_req: %d\r\n", free_size, size_req);
// Check if we can fit the new in the free space or if removal of old app is required.
if(size_req > free_size)
{
// Not enough room in free space (bank_1)
if ((dual_bank_only))
{
NRF_LOG_INFO("Failure: dual bank restriction\r\n");
return NRF_ERROR_NO_MEM;
}
// Can only support single bank update, clearing old app.
s_dfu_settings.bank_layout = NRF_DFU_BANK_LAYOUT_SINGLE;
s_dfu_settings.bank_current = NRF_DFU_CURRENT_BANK_0;
p_bank = &s_dfu_settings.bank_0;
NRF_LOG_INFO("Enforcing single bank\r\n");
}
else
{
// Room in bank_1 for update
// Ensure we are using dual bank layout
s_dfu_settings.bank_layout = NRF_DFU_BANK_LAYOUT_DUAL;
s_dfu_settings.bank_current = NRF_DFU_CURRENT_BANK_1;
p_bank = &s_dfu_settings.bank_1;
// Set to first free page boundry after previous app
(*p_address) += align_to_page(s_dfu_settings.bank_0.image_size, CODE_PAGE_SIZE);
NRF_LOG_INFO("Using second bank\r\n");
}
}
else
{
// No valid app present. Promoting dual bank.
s_dfu_settings.bank_layout = NRF_DFU_BANK_LAYOUT_DUAL;
s_dfu_settings.bank_current = NRF_DFU_CURRENT_BANK_0;
p_bank = &s_dfu_settings.bank_0;
NRF_LOG_INFO("No previous, using bank 0\r\n");
}
// Set the bank-code to invalid, and reset size/CRC
memset(p_bank, 0, sizeof(nrf_dfu_bank_t));
// Store the Firmware size in the bank for continuations
p_bank->image_size = size_req;
return NRF_SUCCESS;
}
/** @brief Function to continue App update
*
* @details This function will be called after reset if there is a valid application in Bank1
* required to be copied down to bank0.
*
* @param[in] src_addr Source address of the application to copy from Bank1 to Bank0.
*
* @retval NRF_SUCCESS Continuation was successful.
* @retval NRF_ERROR_NULL Invalid data during compare.
* @retval FS_ERR_UNALIGNED_ADDR A call to fstorage was not aligned to a page boundary or the address was not word aliged.
* @retval FS_ERR_INVALID_ADDR The destination of a call to fstorage does not point to
* the start of a flash page or the operation would
* go beyond the flash memory boundary.
* @retval FS_ERR_NOT_INITIALIZED The fstorage module is not initialized.
* @retval FS_ERR_INVALID_CFG The initialization of the fstorage module is invalid.
* @retval FS_ERR_NULL_ARG A call to fstorage had an invalid NULL argument.
* @retval FS_ERR_INVALID_ARG A call to fstorage had invalid arguments.
* @retval FS_ERR_QUEUE_FULL If the internal operation queue of the fstorage module is full.
* @retval FS_ERR_FAILURE_SINCE_LAST If an error occurred in another transaction and fstorage cannot continue before
* the event has been dealt with.
*/
static uint32_t nrf_dfu_app_continue(uint32_t src_addr)
{
// This function only in use when new app is present in bank 1
uint32_t const image_size = s_dfu_settings.bank_1.image_size;
uint32_t const split_size = CODE_PAGE_SIZE; // Arbitrary number that must be page aligned
uint32_t ret_val = NRF_SUCCESS;
uint32_t target_addr = MAIN_APPLICATION_START_ADDR + s_dfu_settings.write_offset;
uint32_t length_left = (image_size - s_dfu_settings.write_offset);
uint32_t cur_len;
uint32_t crc;
NRF_LOG_INFO("Enter nrf_dfu_app_continue\r\n");
// Copy the application down safely
do
{
cur_len = (length_left > split_size) ? split_size : length_left;
// Erase the target page
ret_val = nrf_dfu_flash_erase((uint32_t*) target_addr, split_size / CODE_PAGE_SIZE, NULL);
if (ret_val != NRF_SUCCESS)
{
return ret_val;
}
// Flash one page
ret_val = nrf_dfu_flash_store((uint32_t*)target_addr, (uint32_t*)src_addr, cur_len, NULL);
if (ret_val != NRF_SUCCESS)
{
return ret_val;
}
ret_val = nrf_dfu_mbr_compare((uint32_t*)target_addr, (uint32_t*)src_addr, cur_len);
if (ret_val != NRF_SUCCESS)
{
// We will not retry the copy
NRF_LOG_INFO("Invalid data during compare: target: 0x%08x, src: 0x%08x\r\n", target_addr, src_addr);
return ret_val;
}
// Erase the head (to handle growing bank 0)
ret_val = nrf_dfu_flash_erase((uint32_t*) src_addr, split_size / CODE_PAGE_SIZE, NULL);
if (ret_val != NRF_SUCCESS)
{
NRF_LOG_INFO("App update: Failure erasing page at addr: 0x%08x\r\n", src_addr);
return ret_val;
}
s_dfu_settings.write_offset += cur_len;
(void)nrf_dfu_settings_write(NULL);
target_addr += cur_len;
src_addr += cur_len;
length_left -= cur_len;
}
while(length_left > 0);
// Check the crc of the copied data. Enable if so.
crc = crc32_compute((uint8_t*)MAIN_APPLICATION_START_ADDR, image_size, NULL);
if (crc == s_dfu_settings.bank_1.image_crc)
{
NRF_LOG_INFO("Setting app as valid\r\n");
s_dfu_settings.bank_0.bank_code = NRF_DFU_BANK_VALID_APP;
s_dfu_settings.bank_0.image_crc = crc;
s_dfu_settings.bank_0.image_size = image_size;
}
else
{
NRF_LOG_INFO("CRC computation failed for copied app: src crc: 0x%08x, res crc: 0x08x\r\n", s_dfu_settings.bank_1.image_crc, crc);
}
nrf_dfu_invalidate_bank(&s_dfu_settings.bank_1);
(void)nrf_dfu_settings_write(NULL);
return ret_val;
}
uint32_t bsp_init(uint32_t type, uint32_t ticks_per_100ms, bsp_event_callback_t callback)
{
uint32_t err_code = NRF_SUCCESS;
#if LEDS_NUMBER > 0 && !(defined BSP_SIMPLE)
m_app_ticks_per_100ms = ticks_per_100ms;
m_indication_type = type;
#else
UNUSED_VARIABLE(ticks_per_100ms);
#endif // LEDS_NUMBER > 0 && !(defined BSP_SIMPLE)
#if (BUTTONS_NUMBER > 0) && !(defined BSP_SIMPLE)
m_registered_callback = callback;
NRF_LOG_INFO("START BUTTON INIT\r\n");
// BSP will support buttons and generate events
if (type & BSP_INIT_BUTTONS)
{
uint32_t num;
for (num = 0; ((num < BUTTONS_NUMBER) && (err_code == NRF_SUCCESS)); num++)
{
NRF_LOG_INFO("ASSIGN %d\r\n", num);
err_code = bsp_event_to_button_action_assign(num, BSP_BUTTON_ACTION_PUSH, BSP_EVENT_DEFAULT);
}
if (err_code == NRF_SUCCESS)
{
NRF_LOG_INFO("INIT \r\n");
err_code = app_button_init((app_button_cfg_t *)app_buttons,
BUTTONS_NUMBER,
ticks_per_100ms / 2);
}
if (err_code == NRF_SUCCESS)
{
NRF_LOG_INFO("Enable \r\n");
err_code = app_button_enable();
}
if (err_code == NRF_SUCCESS)
{
NRF_LOG_INFO("Create \r\n");
err_code = app_timer_create(&m_button_timer_id,
APP_TIMER_MODE_SINGLE_SHOT,
button_timer_handler);
}
}
#elif (BUTTONS_NUMBER > 0) && (defined BSP_SIMPLE)
if (type & BSP_INIT_BUTTONS)
{
bsp_board_buttons_init();
}
#endif // (BUTTONS_NUMBER > 0) && !(defined BSP_SIMPLE)
#if LEDS_NUMBER > 0 && !(defined BSP_SIMPLE)
if (type & BSP_INIT_LED)
{
bsp_board_leds_init();
}
// timers module must be already initialized!
if (err_code == NRF_SUCCESS)
{
err_code =
app_timer_create(&m_leds_timer_id, APP_TIMER_MODE_SINGLE_SHOT, leds_timer_handler);
}
if (err_code == NRF_SUCCESS)
{
err_code =
app_timer_create(&m_alert_timer_id, APP_TIMER_MODE_REPEATED, alert_timer_handler);
}
#endif // LEDS_NUMBER > 0 && !(defined BSP_SIMPLE)
return err_code;
}
/** @brief Function to execute the continuation of a SoftDevice update.
*
* @param[in] src_addr Source address of the SoftDevice to copy from.
* @param[in] p_bank Pointer to the bank where the SoftDevice resides.
*
* @retval NRF_SUCCESS Continuation was successful.
* @retval NRF_ERROR_INVALID_LENGTH Invalid len
* @retval NRF_ERROR_NO_MEM if UICR.NRFFW[1] is not set (i.e. is 0xFFFFFFFF).
* @retval NRF_ERROR_INVALID_PARAM if an invalid command is given.
* @retval NRF_ERROR_INTERNAL indicates that the contents of the memory blocks where not verified correctly after copying.
* @retval NRF_ERROR_NULL If the content of the memory blocks differs after copying.
*/
static uint32_t nrf_dfu_sd_continue_impl(uint32_t src_addr,
nrf_dfu_bank_t * p_bank)
{
uint32_t ret_val = NRF_SUCCESS;
uint32_t target_addr = SOFTDEVICE_REGION_START + s_dfu_settings.write_offset;
uint32_t length_left = align_to_page(s_dfu_settings.sd_size - s_dfu_settings.write_offset, CODE_PAGE_SIZE);
uint32_t split_size = align_to_page(length_left / 4, CODE_PAGE_SIZE);
NRF_LOG_INFO("Enter nrf_bootloader_dfu_sd_continue\r\n");
// This can be a continuation due to a power failure
src_addr += s_dfu_settings.write_offset;
if (s_dfu_settings.sd_size != 0 && s_dfu_settings.write_offset == s_dfu_settings.sd_size)
{
NRF_LOG_INFO("SD already copied\r\n");
return NRF_SUCCESS;
}
NRF_LOG_INFO("Updating SD. Old SD ver: 0x%04x\r\n", SD_FWID_GET(MBR_SIZE));
do
{
NRF_LOG_INFO("Copying [0x%08x-0x%08x] to [0x%08x-0x%08x]: Len: 0x%08x\r\n", src_addr, src_addr + split_size, target_addr, target_addr + split_size, split_size);
// Copy a chunk of the SD. Size in words
ret_val = nrf_dfu_mbr_copy_sd((uint32_t*)target_addr, (uint32_t*)src_addr, split_size);
if (ret_val != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to copy SD: target: 0x%08x, src: 0x%08x, len: 0x%08x\r\n", target_addr, src_addr, split_size);
return ret_val;
}
NRF_LOG_INFO("Finished copying [0x%08x-0x%08x] to [0x%08x-0x%08x]: Len: 0x%08x\r\n", src_addr, src_addr + split_size, target_addr, target_addr + split_size, split_size);
// Validate copy. Size in words
ret_val = nrf_dfu_mbr_compare((uint32_t*)target_addr, (uint32_t*)src_addr, split_size);
if (ret_val != NRF_SUCCESS)
{
NRF_LOG_INFO("Failed to Compare SD: target: 0x%08x, src: 0x%08x, len: 0x%08x\r\n", target_addr, src_addr, split_size);
return ret_val;
}
NRF_LOG_INFO("Validated 0x%08x-0x%08x to 0x%08x-0x%08x: Size: 0x%08x\r\n", src_addr, src_addr + split_size, target_addr, target_addr + split_size, split_size);
target_addr += split_size;
src_addr += split_size;
if (split_size > length_left)
{
length_left = 0;
}
else
{
length_left -= split_size;
}
NRF_LOG_INFO("Finished with the SD update.\r\n");
// Save the updated point of writes in case of power loss
s_dfu_settings.write_offset = s_dfu_settings.sd_size - length_left;
(void)nrf_dfu_settings_write(NULL);
}
while (length_left > 0);
return ret_val;
}
void nrf_drv_timer_pause(nrf_drv_timer_t const * const p_instance)
{
ASSERT(m_cb[p_instance->instance_id].state == NRF_DRV_STATE_POWERED_ON);
nrf_timer_task_trigger(p_instance->p_reg, NRF_TIMER_TASK_STOP);
NRF_LOG_INFO("Paused instance: %d.\r\n", p_instance->instance_id);
}
ret_code_t ant_bpwr_disp_open(ant_bpwr_profile_t * p_profile)
{
NRF_LOG_INFO("ANT B-PWR %u open\r\n", p_profile->channel_number);
return sd_ant_channel_open(p_profile->channel_number);
}
/** @brief Internal function to initialize DFU BLE transport
*/
fs_ret_t nrf_dfu_flash_erase(uint32_t const * p_dest, uint32_t num_pages, dfu_flash_callback_t callback)
{
fs_ret_t ret_val = FS_SUCCESS;
NRF_LOG_INFO("Erasing: 0x%08x, num: %d\r\n", (uint32_t)p_dest, num_pages);
#ifdef BLE_STACK_SUPPORT_REQD
if ((m_flags & FLASH_FLAG_SD_ENABLED) != 0)
{
// Check if there is a pending error
if ((m_flags & FLASH_FLAG_FAILURE_SINCE_LAST) != 0)
{
NRF_LOG_ERROR("Erase: Failure since last\r\n");
return FS_ERR_FAILURE_SINCE_LAST;
}
m_flags |= FLASH_FLAG_OPER;
ret_val = fs_erase(&fs_dfu_config, p_dest, num_pages, (void*)callback);
if (ret_val != FS_SUCCESS)
{
NRF_LOG_ERROR("Erase failed: %d\r\n", ret_val);
m_flags &= ~FLASH_FLAG_OPER;
return ret_val;
}
// Set the flag to indicate ongoing operation
m_flags |= FLASH_FLAG_OPER;
}
else
#endif
{
#ifndef NRF51
// Softdevice is not present or activated. Run the NVMC instead
if (((uint32_t)p_dest & (CODE_PAGE_SIZE-1)) != 0)
{
NRF_LOG_ERROR("Invalid address\r\n");
return FS_ERR_UNALIGNED_ADDR;
}
#endif
uint16_t first_page = ((uint32_t)p_dest / CODE_PAGE_SIZE);
do
{
nrf_nvmc_page_erase((uint32_t)p_dest);
p_dest += CODE_PAGE_SIZE/sizeof(uint32_t);
}
while(--num_pages > 0);
if (callback)
{
#if (__LINT__ != 1)
fs_evt_t evt =
{
.id = FS_EVT_ERASE,
.p_context = (void*)callback,
.erase =
{
.first_page = first_page,
.last_page = ((uint32_t)p_dest / CODE_PAGE_SIZE)
}
};
callback(&evt, FS_SUCCESS);
#else
(void)first_page;
#endif
}
}
return ret_val;
}
/**@brief Function for tracing page 4 and common data.
*
* @param[in] p_common_data Pointer to the common data.
* @param[in] p_page_data Pointer to the page 4 data.
*/
static void page4_data_log(ant_hrm_page4_data_t const * p_page_data)
{
NRF_LOG_INFO("Previous heart beat event time: %u.%03us\r\n\n",
(unsigned int)ANT_HRM_BEAT_TIME_SEC(p_page_data->prev_beat),
(unsigned int)ANT_HRM_BEAT_TIME_MSEC(p_page_data->prev_beat));
}
/**@brief Function for handling Peer Manager events.
*
* @param[in] p_evt Peer Manager event.
*/
static void pm_evt_handler(pm_evt_t const * p_evt)
{
ret_code_t err_code;
switch (p_evt->evt_id)
{
case PM_EVT_BONDED_PEER_CONNECTED:
{
NRF_LOG_INFO("Connected to a previously bonded device.\r\n");
} break;
case PM_EVT_CONN_SEC_SUCCEEDED:
{
NRF_LOG_INFO("Link secured. Role: %d. conn_handle: %d, Procedure: %d\r\n",
ble_conn_state_role(p_evt->conn_handle),
p_evt->conn_handle,
p_evt->params.conn_sec_succeeded.procedure);
} break;
case PM_EVT_CONN_SEC_FAILED:
{
/* Often, when securing fails, it shouldn't be restarted, for security reasons.
* Other times, it can be restarted directly.
* Sometimes it can be restarted, but only after changing some Security Parameters.
* Sometimes, it cannot be restarted until the link is disconnected and reconnected.
* Sometimes it is impossible, to secure the link, or the peer device does not support it.
* How to handle this error is highly application dependent. */
} break;
case PM_EVT_CONN_SEC_CONFIG_REQ:
{
// Reject pairing request from an already bonded peer.
pm_conn_sec_config_t conn_sec_config = {.allow_repairing = false};
pm_conn_sec_config_reply(p_evt->conn_handle, &conn_sec_config);
} break;
case PM_EVT_STORAGE_FULL:
{
// Run garbage collection on the flash.
err_code = fds_gc();
if (err_code == FDS_ERR_BUSY || err_code == FDS_ERR_NO_SPACE_IN_QUEUES)
{
// Retry.
}
else
{
APP_ERROR_CHECK(err_code);
}
} break;
case PM_EVT_PEERS_DELETE_SUCCEEDED:
{
advertising_start();
} break;
case PM_EVT_LOCAL_DB_CACHE_APPLY_FAILED:
{
// The local database has likely changed, send service changed indications.
pm_local_database_has_changed();
} break;
case PM_EVT_PEER_DATA_UPDATE_FAILED:
{
// Assert.
APP_ERROR_CHECK(p_evt->params.peer_data_update_failed.error);
} break;
case PM_EVT_PEER_DELETE_FAILED:
{
// Assert.
APP_ERROR_CHECK(p_evt->params.peer_delete_failed.error);
} break;
case PM_EVT_PEERS_DELETE_FAILED:
{
// Assert.
APP_ERROR_CHECK(p_evt->params.peers_delete_failed_evt.error);
} break;
case PM_EVT_ERROR_UNEXPECTED:
{
// Assert.
APP_ERROR_CHECK(p_evt->params.error_unexpected.error);
} break;
case PM_EVT_CONN_SEC_START:
case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED:
case PM_EVT_PEER_DELETE_SUCCEEDED:
case PM_EVT_LOCAL_DB_CACHE_APPLIED:
case PM_EVT_SERVICE_CHANGED_IND_SENT:
case PM_EVT_SERVICE_CHANGED_IND_CONFIRMED:
default:
break;
}
}
/**@brief Callback function for errors in the Location Navigation Service.
*
* @details This function will be called in case of an error in the Location Navigation Service.
*
* @warning This handler is an example only and does not fit a final product. You need to analyze
* how your product is supposed to react in case of Assert.
*/
static void lns_error_handler(uint32_t err_code)
{
app_error_handler(DEAD_BEEF, 0, 0);
}
/**@brief Application's BLE Stack event handler.
*
* @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_CONNECTED:
NRF_LOG_INFO("Connected.\r\n");
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break; // BLE_GAP_EVT_CONNECTED
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected.\r\n");
err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
break; // BLE_GAP_EVT_DISCONNECTED
case BLE_GATTC_EVT_TIMEOUT:
// Disconnect on GATT Client timeout event.
NRF_LOG_DEBUG("GATT Client Timeout.\r\n");
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
case BLE_EVT_USER_MEM_REQUEST:
err_code = sd_ble_user_mem_reply(m_conn_handle, NULL);
APP_ERROR_CHECK(err_code);
break; // BLE_EVT_USER_MEM_REQUEST
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
{
ble_gatts_evt_rw_authorize_request_t req;
ble_gatts_rw_authorize_reply_params_t auth_reply;
req = p_ble_evt->evt.gatts_evt.params.authorize_request;
if (req.type != BLE_GATTS_AUTHORIZE_TYPE_INVALID)
{
if ((req.request.write.op == BLE_GATTS_OP_PREP_WRITE_REQ) ||
(req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) ||
(req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL))
{
if (req.type == BLE_GATTS_AUTHORIZE_TYPE_WRITE)
{
auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE;
}
else
{
auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_READ;
}
auth_reply.params.write.gatt_status = APP_FEATURE_NOT_SUPPORTED;
err_code = sd_ble_gatts_rw_authorize_reply(p_ble_evt->evt.gatts_evt.conn_handle,
&auth_reply);
APP_ERROR_CHECK(err_code);
}
}
} break; // BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST
#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:
break;
}
APP_ERROR_CHECK(err_code);
}
void rust_begin_unwind(void* args, char** file_slice, uint32_t line)
{
NRF_LOG_INFO("Rust stack unwind. Excessive memory usage? Invalid parameters to Rust?\r\n");
//Add your own crash handler here
}
uint32_t ser_conn_command_process(uint8_t * p_command, uint16_t command_len)
{
SER_ASSERT_NOT_NULL(p_command);
SER_ASSERT_LENGTH_LEQ(SER_OP_CODE_SIZE, command_len);
uint32_t err_code = NRF_SUCCESS;
uint8_t * p_tx_buf = NULL;
uint32_t tx_buf_len = 0;
uint8_t opcode = p_command[SER_CMD_OP_CODE_POS];
uint32_t index = 0;
/* Allocate a memory buffer from HAL Transport layer for transmitting the Command Response.
* Loop until a buffer is available. */
NRF_LOG_INFO("Command process start");
do
{
err_code = ser_hal_transport_tx_pkt_alloc(&p_tx_buf, (uint16_t *)&tx_buf_len);
if (err_code == NRF_ERROR_NO_MEM)
{
ser_conn_on_no_mem_handler();
}
}
while (NRF_ERROR_NO_MEM == err_code);
NRF_LOG_INFO("Tx buffer allocated");
if (NRF_SUCCESS == err_code)
{
/* Create a new response packet. */
p_tx_buf[SER_PKT_TYPE_POS] = SER_PKT_TYPE_RESP;
tx_buf_len -= SER_PKT_TYPE_SIZE;
/* Decode a request, pass a memory for a response command (opcode + data) and encode it. */
err_code = conn_mw_handler
(p_command, command_len, &p_tx_buf[SER_PKT_OP_CODE_POS], &tx_buf_len);
/* Command decoder not found. */
if (NRF_ERROR_NOT_SUPPORTED == err_code)
{
NRF_LOG_ERROR("Command not supported opcode:%d", p_tx_buf[SER_PKT_OP_CODE_POS]);
APP_ERROR_CHECK(SER_WARNING_CODE);
err_code = op_status_enc
(opcode, NRF_ERROR_NOT_SUPPORTED,
&p_tx_buf[SER_PKT_OP_CODE_POS], &tx_buf_len, &index);
if (NRF_SUCCESS == err_code)
{
tx_buf_len += SER_PKT_TYPE_SIZE;
err_code = ser_hal_transport_tx_pkt_send(p_tx_buf, (uint16_t)tx_buf_len);
/* TX buffer is going to be freed automatically in the HAL Transport layer. */
if (NRF_SUCCESS != err_code)
{
err_code = NRF_ERROR_INTERNAL;
}
}
else
{
err_code = NRF_ERROR_INTERNAL;
}
}
else if (NRF_SUCCESS == err_code) /* Send a response. */
{
tx_buf_len += SER_PKT_TYPE_SIZE;
err_code = ser_hal_transport_tx_pkt_send(p_tx_buf, (uint16_t)tx_buf_len);
/* TX buffer is going to be freed automatically in the HAL Transport layer. */
if (NRF_SUCCESS != err_code)
{
err_code = NRF_ERROR_INTERNAL;
}
}
else
{
NRF_LOG_ERROR("Internal error during command decoding.");
err_code = NRF_ERROR_INTERNAL;
}
}
else
{
err_code = NRF_ERROR_INTERNAL;
}
return err_code;
}
ret_code_t nrf_drv_timer_init(nrf_drv_timer_t const * const p_instance,
nrf_drv_timer_config_t const * p_config,
nrf_timer_event_handler_t timer_event_handler)
{
timer_control_block_t * p_cb = &m_cb[p_instance->instance_id];
ASSERT(((p_instance->p_reg == NRF_TIMER0) && TIMER0_ENABLED) || (p_instance->p_reg != NRF_TIMER0));
ASSERT(((p_instance->p_reg == NRF_TIMER1) && TIMER1_ENABLED) || (p_instance->p_reg != NRF_TIMER1));
ASSERT(((p_instance->p_reg == NRF_TIMER2) && TIMER2_ENABLED) || (p_instance->p_reg != NRF_TIMER2));
#if TIMER_COUNT == 5
ASSERT(((p_instance->p_reg == NRF_TIMER3) && TIMER3_ENABLED) || (p_instance->p_reg != NRF_TIMER3));
ASSERT(((p_instance->p_reg == NRF_TIMER4) && TIMER4_ENABLED) || (p_instance->p_reg != NRF_TIMER4));
#endif //TIMER_COUNT
#ifdef SOFTDEVICE_PRESENT
ASSERT(p_instance->p_reg != NRF_TIMER0);
ASSERT(p_config);
#endif
ret_code_t err_code;
if (p_cb->state != NRF_DRV_STATE_UNINITIALIZED)
{
err_code = NRF_ERROR_INVALID_STATE;
NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
if (timer_event_handler == NULL)
{
err_code = NRF_ERROR_INVALID_PARAM;
NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
/* Warning 685: Relational operator '<=' always evaluates to 'true'"
* Warning in NRF_TIMER_IS_BIT_WIDTH_VALID macro. Macro validate timers resolution.
* Not necessary in nRF52 based systems. Obligatory in nRF51 based systems.
*/
/*lint -save -e685 */
ASSERT(NRF_TIMER_IS_BIT_WIDTH_VALID(p_instance->p_reg, p_config->bit_width));
//lint -restore
p_cb->handler = timer_event_handler;
p_cb->context = p_config->p_context;
uint8_t i;
for (i = 0; i < p_instance->cc_channel_count; ++i)
{
nrf_timer_event_clear(p_instance->p_reg,
nrf_timer_compare_event_get(i));
}
nrf_drv_common_irq_enable(nrf_drv_get_IRQn(p_instance->p_reg),
p_config->interrupt_priority);
nrf_timer_mode_set(p_instance->p_reg, p_config->mode);
nrf_timer_bit_width_set(p_instance->p_reg, p_config->bit_width);
nrf_timer_frequency_set(p_instance->p_reg, p_config->frequency);
p_cb->state = NRF_DRV_STATE_INITIALIZED;
err_code = NRF_SUCCESS;
NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
/**@brief Function for handling Peer Manager events.
*
* @param[in] p_evt Peer Manager event.
*/
static void pm_evt_handler(pm_evt_t const * p_evt)
{
ret_code_t err_code;
switch (p_evt->evt_id)
{
case PM_EVT_BONDED_PEER_CONNECTED:
err_code = pm_peer_rank_highest(p_evt->peer_id);
if (err_code != NRF_ERROR_BUSY)
{
APP_ERROR_CHECK(err_code);
}
break; // PM_EVT_BONDED_PEER_CONNECTED
case PM_EVT_CONN_SEC_START:
break; // PM_EVT_CONN_SEC_START
case PM_EVT_CONN_SEC_SUCCEEDED:
{
NRF_LOG_INFO("Link secured. Role: %d. conn_handle: %d, Procedure: %d\r\n",
ble_conn_state_role(p_evt->conn_handle),
p_evt->conn_handle,
p_evt->params.conn_sec_succeeded.procedure);
err_code = pm_peer_rank_highest(p_evt->peer_id);
if (err_code != NRF_ERROR_BUSY)
{
APP_ERROR_CHECK(err_code);
}
} break; // PM_EVT_CONN_SEC_SUCCEEDED
case PM_EVT_CONN_SEC_FAILED:
{
/** In some cases, when securing fails, it can be restarted directly. Sometimes it can
* be restarted, but only after changing some Security Parameters. Sometimes, it cannot
* be restarted until the link is disconnected and reconnected. Sometimes it is
* impossible, to secure the link, or the peer device does not support it. How to
* handle this error is highly application dependent. */
switch (p_evt->params.conn_sec_failed.error)
{
case PM_CONN_SEC_ERROR_PIN_OR_KEY_MISSING:
// Rebond if one party has lost its keys.
err_code = pm_conn_secure(p_evt->conn_handle, true);
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
break; // PM_CONN_SEC_ERROR_PIN_OR_KEY_MISSING
default:
break;
}
} break; // PM_EVT_CONN_SEC_FAILED
case PM_EVT_CONN_SEC_CONFIG_REQ:
{
// Reject pairing request from an already bonded peer.
pm_conn_sec_config_t conn_sec_config = {.allow_repairing = false};
pm_conn_sec_config_reply(p_evt->conn_handle, &conn_sec_config);
} break; // PM_EVT_CONN_SEC_CONFIG_REQ
case PM_EVT_STORAGE_FULL:
{
// Run garbage collection on the flash.
err_code = fds_gc();
if (err_code == FDS_ERR_BUSY || err_code == FDS_ERR_NO_SPACE_IN_QUEUES)
{
// Retry.
}
else
{
APP_ERROR_CHECK(err_code);
}
} break; // PM_EVT_STORAGE_FULL
case PM_EVT_ERROR_UNEXPECTED:
// Assert.
APP_ERROR_CHECK(p_evt->params.error_unexpected.error);
break; // PM_EVT_ERROR_UNEXPECTED
case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED:
break; // PM_EVT_PEER_DATA_UPDATE_SUCCEEDED
case PM_EVT_PEER_DATA_UPDATE_FAILED:
// Assert.
APP_ERROR_CHECK_BOOL(false);
break; // PM_EVT_PEER_DATA_UPDATE_FAILED
case PM_EVT_PEER_DELETE_SUCCEEDED:
break; // PM_EVT_PEER_DELETE_SUCCEEDED
case PM_EVT_PEER_DELETE_FAILED:
// Assert.
APP_ERROR_CHECK(p_evt->params.peer_delete_failed.error);
break; // PM_EVT_PEER_DELETE_FAILED
case PM_EVT_PEERS_DELETE_SUCCEEDED:
advertising_start();
break; // PM_EVT_PEERS_DELETE_SUCCEEDED
case PM_EVT_PEERS_DELETE_FAILED:
// Assert.
APP_ERROR_CHECK(p_evt->params.peers_delete_failed_evt.error);
break; // PM_EVT_PEERS_DELETE_FAILED
case PM_EVT_LOCAL_DB_CACHE_APPLIED:
break; // PM_EVT_LOCAL_DB_CACHE_APPLIED
case PM_EVT_LOCAL_DB_CACHE_APPLY_FAILED:
// The local database has likely changed, send service changed indications.
pm_local_database_has_changed();
break; // PM_EVT_LOCAL_DB_CACHE_APPLY_FAILED
case PM_EVT_SERVICE_CHANGED_IND_SENT:
break; // PM_EVT_SERVICE_CHANGED_IND_SENT
case PM_EVT_SERVICE_CHANGED_IND_CONFIRMED:
break; // PM_EVT_SERVICE_CHANGED_IND_CONFIRMED
default:
// No implementation needed.
break;
}
}
/**@brief Function for handling the security request timer time-out.
*
* @details This function is called each time the security request timer expires.
*
* @param[in] p_context Pointer used for passing context information from the
* app_start_timer() call to the time-out handler.
*/
static void sec_req_timeout_handler(void * p_context)
{
uint32_t err_code;
pm_conn_sec_status_t status;
if (m_cur_conn_handle != BLE_CONN_HANDLE_INVALID)
{
err_code = pm_conn_sec_status_get(m_cur_conn_handle, &status);
APP_ERROR_CHECK(err_code);
// If the link is still not secured by the peer, initiate security procedure.
if (!status.encrypted)
{
NRF_LOG_INFO("Start encryption\r\n");
err_code = pm_conn_secure(m_cur_conn_handle, false);
APP_ERROR_CHECK(err_code);
}
}
}
/**@brief Function for printing speed or cadence page3 data. */
static void page3_data_log(ant_bsc_page3_data_t const * p_page_data)
{
NRF_LOG_INFO("Hardware Rev ID: %u\r\n", (unsigned int)p_page_data->hw_version);
NRF_LOG_INFO("Model Number: %u\r\n", (unsigned int)p_page_data->model_num);
NRF_LOG_INFO("Software Ver ID: %u\r\n", (unsigned int)p_page_data->sw_version);
}
/**@brief Function for handling Peer Manager events.
*
* @param[in] p_evt Peer Manager event.
*/
static void pm_evt_handler(pm_evt_t const * p_evt)
{
ret_code_t err_code;
switch (p_evt->evt_id)
{
case PM_EVT_BONDED_PEER_CONNECTED:
{
NRF_LOG_INFO("Connected to a previously bonded device.\r\n");
} break;
case PM_EVT_CONN_SEC_SUCCEEDED:
{
NRF_LOG_INFO("Connection secured. Role: %d. conn_handle: %d, Procedure: %d\r\n",
ble_conn_state_role(p_evt->conn_handle),
p_evt->conn_handle,
p_evt->params.conn_sec_succeeded.procedure);
} break;
case PM_EVT_CONN_SEC_FAILED:
{
/* Often, when securing fails, it shouldn't be restarted, for security reasons.
* Other times, it can be restarted directly.
* Sometimes it can be restarted, but only after changing some Security Parameters.
* Sometimes, it cannot be restarted until the link is disconnected and reconnected.
* Sometimes it is impossible, to secure the link, or the peer device does not support it.
* How to handle this error is highly application dependent. */
} break;
case PM_EVT_CONN_SEC_CONFIG_REQ:
{
// Reject pairing request from an already bonded peer.
pm_conn_sec_config_t conn_sec_config = {.allow_repairing = false};
pm_conn_sec_config_reply(p_evt->conn_handle, &conn_sec_config);
} break;
case PM_EVT_STORAGE_FULL:
{
// Run garbage collection on the flash.
err_code = fds_gc();
if (err_code == FDS_ERR_BUSY || err_code == FDS_ERR_NO_SPACE_IN_QUEUES)
{
// Retry.
}
else
{
APP_ERROR_CHECK(err_code);
}
} break;
case PM_EVT_PEERS_DELETE_SUCCEEDED:
{
err_code = ble_advertising_start(BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(err_code);
} break;
case PM_EVT_LOCAL_DB_CACHE_APPLY_FAILED:
{
// The local database has likely changed, send service changed indications.
pm_local_database_has_changed();
} break;
case PM_EVT_PEER_DATA_UPDATE_FAILED:
{
// Assert.
APP_ERROR_CHECK(p_evt->params.peer_data_update_failed.error);
} break;
case PM_EVT_PEER_DELETE_FAILED:
{
// Assert.
APP_ERROR_CHECK(p_evt->params.peer_delete_failed.error);
} break;
case PM_EVT_PEERS_DELETE_FAILED:
{
// Assert.
APP_ERROR_CHECK(p_evt->params.peers_delete_failed_evt.error);
} break;
case PM_EVT_ERROR_UNEXPECTED:
{
// Assert.
APP_ERROR_CHECK(p_evt->params.error_unexpected.error);
} break;
case PM_EVT_CONN_SEC_START:
case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED:
case PM_EVT_PEER_DELETE_SUCCEEDED:
case PM_EVT_LOCAL_DB_CACHE_APPLIED:
case PM_EVT_SERVICE_CHANGED_IND_SENT:
case PM_EVT_SERVICE_CHANGED_IND_CONFIRMED:
default:
break;
}
}
/**@brief Function for the GAP initialization.
*
* @details This function sets up all the necessary GAP (Generic Access Profile) parameters of the
* device including the device name, appearance, and the preferred connection parameters.
*/
static void gap_params_init(void)
{
uint32_t err_code;
ble_gap_conn_params_t gap_conn_params;
ble_gap_conn_sec_mode_t sec_mode;
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);
err_code = sd_ble_gap_device_name_set(&sec_mode,
(const uint8_t *)DEVICE_NAME,
strlen(DEVICE_NAME));
APP_ERROR_CHECK(err_code);
/* YOUR_JOB: Use an appearance value matching the application's use case.
err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_);
APP_ERROR_CHECK(err_code); */
memset(&gap_conn_params, 0, sizeof(gap_conn_params));
gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
gap_conn_params.slave_latency = SLAVE_LATENCY;
gap_conn_params.conn_sup_timeout = CONN_SUP_TIMEOUT;
err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
APP_ERROR_CHECK(err_code);
}
/**
* @brief Class specific request data stage setup.
*
* @param[in] p_inst Generic class instance.
* @param[in] p_setup_ev Setup event.
*
* @return Standard error code.
*/
static ret_code_t cdc_acm_req_out_datastage(app_usbd_class_inst_t const * p_inst,
app_usbd_setup_evt_t const * p_setup_ev)
{
app_usbd_cdc_acm_t const * p_cdc_acm = cdc_acm_get(p_inst);
app_usbd_cdc_acm_ctx_t * p_cdc_acm_ctx = cdc_acm_ctx_get(p_cdc_acm);
p_cdc_acm_ctx->request.type = p_setup_ev->setup.bmRequest;
p_cdc_acm_ctx->request.len = p_setup_ev->setup.wLength.w;
/*Request setup data*/
NRF_DRV_USBD_TRANSFER_OUT(transfer,
&p_cdc_acm_ctx->request.payload,
p_cdc_acm_ctx->request.len);
ret_code_t ret;
CRITICAL_REGION_ENTER();
ret = app_usbd_core_setup_data_transfer(NRF_DRV_USBD_EPOUT0, &transfer);
if (ret == NRF_SUCCESS)
{
const app_usbd_core_setup_data_handler_desc_t desc = {
.handler = cdc_acm_req_out_data_cb,
.p_context = (void*)p_cdc_acm
};
ret = app_usbd_core_setup_data_handler_set(NRF_DRV_USBD_EPOUT0, &desc);
}
CRITICAL_REGION_EXIT();
return ret;
}
/**
* @brief Internal SETUP class OUT request handler.
*
* @param[in] p_inst Generic class instance.
* @param[in] p_setup_ev Setup event.
*
* @return Standard error code.
*/
static ret_code_t setup_req_class_out(app_usbd_class_inst_t const * p_inst,
app_usbd_setup_evt_t const * p_setup_ev)
{
app_usbd_cdc_acm_t const * p_cdc_acm = cdc_acm_get(p_inst);
app_usbd_cdc_acm_ctx_t * p_cdc_acm_ctx = cdc_acm_ctx_get(p_cdc_acm);
switch (p_setup_ev->setup.bmRequest)
{
case APP_USBD_CDC_REQ_SET_LINE_CODING:
{
if (p_setup_ev->setup.wLength.w != sizeof(app_usbd_cdc_line_coding_t))
{
return NRF_ERROR_NOT_SUPPORTED;
}
return cdc_acm_req_out_datastage(p_inst, p_setup_ev);
}
case APP_USBD_CDC_REQ_SET_CONTROL_LINE_STATE:
{
if (p_setup_ev->setup.wLength.w != 0)
{
return NRF_ERROR_NOT_SUPPORTED;
}
NRF_LOG_INFO("REQ_SET_CONTROL_LINE_STATE: 0x%x", p_setup_ev->setup.wValue.w);
bool old_dtr = (p_cdc_acm_ctx->line_state & APP_USBD_CDC_ACM_LINE_STATE_DTR) ?
true : false;
p_cdc_acm_ctx->line_state = p_setup_ev->setup.wValue.w;
bool new_dtr = (p_cdc_acm_ctx->line_state & APP_USBD_CDC_ACM_LINE_STATE_DTR) ?
true : false;
if (old_dtr == new_dtr)
{
return NRF_SUCCESS;
}
const app_usbd_cdc_acm_user_event_t ev = new_dtr ?
APP_USBD_CDC_ACM_USER_EVT_PORT_OPEN : APP_USBD_CDC_ACM_USER_EVT_PORT_CLOSE;
user_event_handler(p_inst, ev);
if (!new_dtr)
{
/*Abort DATA endpoints on port close */
nrf_drv_usbd_ep_t ep;
ep = data_ep_in_addr_get(p_inst);
usbd_drv_ep_abort(ep);
ep = data_ep_out_addr_get(p_inst);
usbd_drv_ep_abort(ep);
}
return NRF_SUCCESS;
}
default:
break;
}
return NRF_ERROR_NOT_SUPPORTED;
}
