Continuous reading/sampling the ADC

[Jagbir]

Does the 2nd argument in the following function SAADC example controls the sampling frequency? If this is not the case then can this saadc example program be modified to be used for continuously. Is there a better way to continuously read the ADC for nRF52 chip instead of using the saadc example.

/* setup m_timer for compare event every 400ms */
uint32_t ticks = nrf_drv_timer_ms_to_ticks(&m_timer, 400);

[Jared]

Hi,

Yes, this is indirectly the sampling frequency + the delay it takes to trigger a task by PPI. SAADC in continuous mode is covered in the product specification here.

regards

Jared 

[Jagbir]

Jared,

I am using nRF52840-DK (SES,nRF5_SDK_15.3.0_59ac345) to read analog input on ADC pin AIN0. I want to continuously read the adc after pairing is established and then broadcast the data over UART/Bluetooth. In order to achieve my objective, I am trying to run example by combining the SAADC example with it.

I am having issues with  saadc_callback() which uses a legacy function ble_nus_string_send().This legacy function is replaced by a new function uint32_t ble_nus_data_send().The number of arguments in each function are different .I am attaching the project files.

[Jagbir]

Jared,

I was able to use the new function but I my program always ends up in a break point condition after log_init(). Am I initializing something multiple times ?

/**
 * Copyright (c) 2014 - 2019, Nordic Semiconductor ASA
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 *
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
/** @file
 *
 * @defgroup ble_sdk_uart_over_ble_main main.c
 * @{
 * @ingroup  ble_sdk_app_nus_eval
 * @brief    UART over BLE application main file.
 *
 * This file contains the source code for a sample application that uses the Nordic UART service.
 * This application uses the @ref srvlib_conn_params module.
 */


#include <stdint.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "ble_hci.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "app_timer.h"
#include "ble_nus.h"
#include "app_uart.h"
#include "app_util_platform.h"
#include "bsp_btn_ble.h"
#include "nrf_pwr_mgmt.h"

// Includes for ADC
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "nrf_drv_saadc.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "boards.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
//  End of ADC includes

#if defined (UART_PRESENT)
#include "nrf_uart.h"
#endif
#if defined (UARTE_PRESENT)
#include "nrf_uarte.h"
#endif

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

#define APP_BLE_CONN_CFG_TAG            1                                           /**< A tag identifying the SoftDevice BLE configuration. */

#define DEVICE_NAME                     "Nordic_UART"                               /**< Name of device. Will be included in the advertising data. */
#define NUS_SERVICE_UUID_TYPE           BLE_UUID_TYPE_VENDOR_BEGIN                  /**< UUID type for the Nordic UART Service (vendor specific). */

#define APP_BLE_OBSERVER_PRIO           3                                           /**< Application's BLE observer priority. You shouldn't need to modify this value. */

#define APP_ADV_INTERVAL                64                                          /**< The advertising interval (in units of 0.625 ms. This value corresponds to 40 ms). */

#define APP_ADV_DURATION                18000                                       /**< The advertising duration (180 seconds) in units of 10 milliseconds. */

#define MIN_CONN_INTERVAL               MSEC_TO_UNITS(20, UNIT_1_25_MS)             /**< Minimum acceptable connection interval (20 ms), Connection interval uses 1.25 ms units. */
#define MAX_CONN_INTERVAL               MSEC_TO_UNITS(75, UNIT_1_25_MS)             /**< Maximum acceptable connection interval (75 ms), Connection interval uses 1.25 ms units. */
#define SLAVE_LATENCY                   0                                           /**< Slave latency. */
#define CONN_SUP_TIMEOUT                MSEC_TO_UNITS(4000, UNIT_10_MS)             /**< Connection supervisory timeout (4 seconds), Supervision Timeout uses 10 ms units. */
#define FIRST_CONN_PARAMS_UPDATE_DELAY  APP_TIMER_TICKS(5000)                       /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
#define NEXT_CONN_PARAMS_UPDATE_DELAY   APP_TIMER_TICKS(30000)                      /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
#define MAX_CONN_PARAMS_UPDATE_COUNT    3                                           /**< Number of attempts before giving up the connection parameter negotiation. */

#define DEAD_BEEF                       0xDEADBEEF                                  /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */

#define UART_TX_BUF_SIZE                256                                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE                256                                         /**< UART RX buffer size. */

//Start of defines for ADC
#define SAMPLES_IN_BUFFER 5
volatile uint8_t state = 1;

static const nrf_drv_timer_t m_timer = NRF_DRV_TIMER_INSTANCE(0);
static nrf_saadc_value_t     m_buffer_pool[2][SAMPLES_IN_BUFFER];
static nrf_ppi_channel_t     m_ppi_channel;
static uint32_t              m_adc_evt_counter;
static ble_nus_t             m_nus;                                      /**< Structure to identify the Nordic UART Service. */
static uint16_t              m_conn_handle = BLE_CONN_HANDLE_INVALID;    /**< Handle of the current connection. */
static nrf_ble_gatt_t        m_gatt;                                     /**< GATT module instance. */
static ble_uuid_t            m_adv_uuids[] = {{BLE_UUID_NUS_SERVICE, NUS_SERVICE_UUID_TYPE}};  /**< Universally unique service identifier. */
static uint16_t              m_ble_nus_max_data_len = BLE_GATT_ATT_MTU_DEFAULT - 3;  /**< Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */

//End of defines for ADC

//Prototype of function for ADC support
void timer_handler(nrf_timer_event_t event_type, void * p_context)
{

}//End of timer handler

void saadc_sampling_event_init(void)
{
    ret_code_t err_code;

    err_code = nrf_drv_ppi_init();
    APP_ERROR_CHECK(err_code);

    nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
    timer_cfg.bit_width = NRF_TIMER_BIT_WIDTH_32;
    err_code = nrf_drv_timer_init(&m_timer, &timer_cfg, timer_handler);
    APP_ERROR_CHECK(err_code);

    /* setup m_timer for compare event every 400ms */
    uint32_t ticks = nrf_drv_timer_ms_to_ticks(&m_timer, 400);
    nrf_drv_timer_extended_compare(&m_timer,
                                   NRF_TIMER_CC_CHANNEL0,
                                   ticks,
                                   NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK,
                                   false);
    nrf_drv_timer_enable(&m_timer);

    uint32_t timer_compare_event_addr = nrf_drv_timer_compare_event_address_get(&m_timer,
                                                                                NRF_TIMER_CC_CHANNEL0);
    uint32_t saadc_sample_task_addr   = nrf_drv_saadc_sample_task_get();

    /* setup ppi channel so that timer compare event is triggering sample task in SAADC */
    err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
                                          timer_compare_event_addr,
                                          saadc_sample_task_addr);
    APP_ERROR_CHECK(err_code);
}


void saadc_sampling_event_enable(void)
{
    ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);

    APP_ERROR_CHECK(err_code);
}

////////////////////////////////////////////
// saadc_callback new implementation ///////
////////////////////////////////////////////

void saadc_callback(nrf_drv_saadc_evt_t const * p_event)
{
		static uint8_t my_data_array[BLE_NUS_MAX_DATA_LEN];
		uint8_t index;
		char	out_str[256];
		int total = 0;
		int average = 0;
	
	if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {
        ret_code_t err_code;

        err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SAMPLES_IN_BUFFER);
        APP_ERROR_CHECK(err_code);

        int i;
        NRF_LOG_INFO("ADC event number: %d\r\n", (int)m_adc_evt_counter);

        for (i = 0; i < SAMPLES_IN_BUFFER; i++)
        {
            NRF_LOG_INFO("%d\r\n", p_event->data.done.p_buffer[i]);
						total += p_event->data.done.p_buffer[i];
        }
        m_adc_evt_counter++;
				average = total / SAMPLES_IN_BUFFER;
				
				// display adc average once every 5 samples
				memset(my_data_array, 0x0, BLE_NUS_MAX_DATA_LEN);
				sprintf(out_str,"ADC val = %d",average);
				for (i=0;i<strlen(out_str);i++)
				{
					my_data_array[i] = (uint8_t)out_str[i];
				}
				//err_code = ble_nus_string_send(&m_nus, my_data_array, BLE_NUS_MAX_DATA_LEN);
                                err_code = ble_nus_data_send(&m_nus, my_data_array, BLE_NUS_MAX_DATA_LEN,m_conn_handle);
                                
                                        
        NRF_LOG_INFO("ADC val sent: %d\r\n", (int)m_adc_evt_counter);
				memset(my_data_array, 0x0, BLE_NUS_MAX_DATA_LEN);
				
				// get button status and display
				for (index=0;index<=3;index++)
					{
						if (app_button_is_pushed(index))
						{
							sprintf(out_str,"Button %1d = 0",index);
							for (i=0;i<strlen(out_str);i++)
							{
								my_data_array[i] = (uint8_t)out_str[i];
							}
						//err_code = ble_nus_string_send(&m_nus, my_data_array, BLE_NUS_MAX_DATA_LEN);
                                                 err_code = ble_nus_data_send(&m_nus, my_data_array, BLE_NUS_MAX_DATA_LEN,m_conn_handle);
						NRF_LOG_INFO("Button val sent: %d\r\n", index);
						memset(my_data_array, 0x0, BLE_NUS_MAX_DATA_LEN);
						}
						else
						{
							sprintf(out_str,"Button %1d = 1",index);
							for (i=0;i<strlen(out_str);i++)
							{
								my_data_array[i] = (uint8_t)out_str[i];
							}
						//err_code = ble_nus_string_send(&m_nus, my_data_array, BLE_NUS_MAX_DATA_LEN);
                                                 err_code = ble_nus_data_send(&m_nus, my_data_array, BLE_NUS_MAX_DATA_LEN,m_conn_handle);
						NRF_LOG_INFO("Button val sent: %d\r\n", index);
						memset(my_data_array, 0x0, BLE_NUS_MAX_DATA_LEN);
						}
						
					}	
				
    }
}// End saadc new implementation

void saadc_init(void)
{
    ret_code_t err_code;
    nrf_saadc_channel_config_t channel_config =
        NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN0);

    err_code = nrf_drv_saadc_init(NULL, saadc_callback);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_channel_init(0, &channel_config);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[0], SAMPLES_IN_BUFFER);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[1], SAMPLES_IN_BUFFER);
    APP_ERROR_CHECK(err_code);

}





BLE_NUS_DEF(m_nus, NRF_SDH_BLE_TOTAL_LINK_COUNT);                                   /**< BLE NUS service instance. */
NRF_BLE_GATT_DEF(m_gatt);                                                           /**< GATT module instance. */
NRF_BLE_QWR_DEF(m_qwr);                                                             /**< Context for the Queued Write module.*/
BLE_ADVERTISING_DEF(m_advertising);                                                 /**< Advertising module instance. */

//static uint16_t   m_conn_handle          = BLE_CONN_HANDLE_INVALID;                 /**< Handle of the current connection. */
//static uint16_t   m_ble_nus_max_data_len = BLE_GATT_ATT_MTU_DEFAULT - 3;            /**< Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */
//static ble_uuid_t m_adv_uuids[]          =                                          /**< Universally unique service identifier. */
//{
//   {BLE_UUID_NUS_SERVICE, NUS_SERVICE_UUID_TYPE}
//};


/**@brief Function for assert macro callback.
 *
 * @details This function will be called in case of an assert in the SoftDevice.
 *
 * @warning This handler is an example only and does not fit a final product. You need to analyse
 *          how your product is supposed to react in case of Assert.
 * @warning On assert from the SoftDevice, the system can only recover on reset.
 *
 * @param[in] line_num    Line number of the failing ASSERT call.
 * @param[in] p_file_name File name of the failing ASSERT call.
 */
void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
{
    app_error_handler(DEAD_BEEF, line_num, p_file_name);
}

/**@brief Function for initializing the timer module.
 */
static void timers_init(void)
{
    ret_code_t err_code = app_timer_init();
    APP_ERROR_CHECK(err_code);
}

/**@brief Function for the GAP initialization.
 *
 * @details This function will set up all the necessary GAP (Generic Access Profile) parameters of
 *          the device. It also sets the permissions and appearance.
 */
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);

    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 Function for handling Queued Write Module errors.
 *
 * @details A pointer to this function will be passed to each service which may need to inform the
 *          application about an error.
 *
 * @param[in]   nrf_error   Error code containing information about what went wrong.
 */
static void nrf_qwr_error_handler(uint32_t nrf_error)
{
    APP_ERROR_HANDLER(nrf_error);
}


/**@brief Function for handling the data from the Nordic UART Service.
 *
 * @details This function will process the data received from the Nordic UART BLE Service and send
 *          it to the UART module.
 *
 * @param[in] p_evt       Nordic UART Service event.
 */
/**@snippet [Handling the data received over BLE] */
static void nus_data_handler(ble_nus_evt_t * p_evt)
{

    if (p_evt->type == BLE_NUS_EVT_RX_DATA)
    {
        uint32_t err_code;

        NRF_LOG_DEBUG("Received data from BLE NUS. Writing data on UART.");
        NRF_LOG_HEXDUMP_DEBUG(p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);

        for (uint32_t i = 0; i < p_evt->params.rx_data.length; i++)
        {
            do
            {
                err_code = app_uart_put(p_evt->params.rx_data.p_data[i]);
                if ((err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY))
                {
                    NRF_LOG_ERROR("Failed receiving NUS message. Error 0x%x. ", err_code);
                    APP_ERROR_CHECK(err_code);
                }
            } while (err_code == NRF_ERROR_BUSY);
        }
        if (p_evt->params.rx_data.p_data[p_evt->params.rx_data.length - 1] == '\r')
        {
            while (app_uart_put('\n') == NRF_ERROR_BUSY);
        }
    }

}
/**@snippet [Handling the data received over BLE] */


/**@brief Function for initializing services that will be used by the application.
 */
static void services_init(void)
{
    uint32_t           err_code;
    ble_nus_init_t     nus_init;
    nrf_ble_qwr_init_t qwr_init = {0};

    // Initialize Queued Write Module.
    qwr_init.error_handler = nrf_qwr_error_handler;

    err_code = nrf_ble_qwr_init(&m_qwr, &qwr_init);
    APP_ERROR_CHECK(err_code);

    // Initialize NUS.
    memset(&nus_init, 0, sizeof(nus_init));

    nus_init.data_handler = nus_data_handler;

    err_code = ble_nus_init(&m_nus, &nus_init);
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling an event from the Connection Parameters Module.
 *
 * @details This function will be called for all events in the Connection Parameters Module
 *          which are passed to the application.
 *
 * @note All this function does is to disconnect. This could have been done by simply setting
 *       the disconnect_on_fail config parameter, but instead we use the event handler
 *       mechanism to demonstrate its use.
 *
 * @param[in] p_evt  Event received from the Connection Parameters Module.
 */
static void on_conn_params_evt(ble_conn_params_evt_t * p_evt)
{
    uint32_t err_code;

    if (p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED)
    {
        err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE);
        APP_ERROR_CHECK(err_code);
    }
}


/**@brief Function for handling errors from the Connection Parameters module.
 *
 * @param[in] nrf_error  Error code containing information about what went wrong.
 */
static void conn_params_error_handler(uint32_t nrf_error)
{
    APP_ERROR_HANDLER(nrf_error);
}


/**@brief Function for initializing the Connection Parameters module.
 */
static void conn_params_init(void)
{
    uint32_t               err_code;
    ble_conn_params_init_t cp_init;

    memset(&cp_init, 0, sizeof(cp_init));

    cp_init.p_conn_params                  = NULL;
    cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
    cp_init.next_conn_params_update_delay  = NEXT_CONN_PARAMS_UPDATE_DELAY;
    cp_init.max_conn_params_update_count   = MAX_CONN_PARAMS_UPDATE_COUNT;
    cp_init.start_on_notify_cccd_handle    = BLE_GATT_HANDLE_INVALID;
    cp_init.disconnect_on_fail             = false;
    cp_init.evt_handler                    = on_conn_params_evt;
    cp_init.error_handler                  = conn_params_error_handler;

    err_code = ble_conn_params_init(&cp_init);
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for putting the chip into sleep mode.
 *
 * @note This function will not return.
 */
static void sleep_mode_enter(void)
{
    uint32_t err_code = bsp_indication_set(BSP_INDICATE_IDLE);
    APP_ERROR_CHECK(err_code);

    // Prepare wakeup buttons.
    err_code = bsp_btn_ble_sleep_mode_prepare();
    APP_ERROR_CHECK(err_code);

    // Go to system-off mode (this function will not return; wakeup will cause a reset).
    err_code = sd_power_system_off();
    APP_ERROR_CHECK(err_code);
}


/**@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:
            err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
            APP_ERROR_CHECK(err_code);
            break;
        case BLE_ADV_EVT_IDLE:
            sleep_mode_enter();
            break;
        default:
            break;
    }
}


/**@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)
{
    uint32_t err_code;

    switch (p_ble_evt->header.evt_id)
    {
        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_DISCONNECTED:
            NRF_LOG_INFO("Disconnected");
            // LED indication will be changed when advertising starts.
            m_conn_handle = BLE_CONN_HANDLE_INVALID;
            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_GAP_EVT_SEC_PARAMS_REQUEST:
            // Pairing not supported
            err_code = sd_ble_gap_sec_params_reply(m_conn_handle, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL);
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_GATTS_EVT_SYS_ATTR_MISSING:
            // No system attributes have been stored.
            err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0);
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_GATTC_EVT_TIMEOUT:
            // Disconnect on GATT Client timeout event.
            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.
            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;
    }
}


/**@brief Function for the SoftDevice initialization.
 *
 * @details This function initializes the SoftDevice and the BLE event interrupt.
 */
static void ble_stack_init(void)
{
    ret_code_t err_code;

    err_code = nrf_sdh_enable_request();
    APP_ERROR_CHECK(err_code);

    // Configure the BLE stack using the default settings.
    // Fetch the start address of the application RAM.
    uint32_t ram_start = 0;
    err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
    APP_ERROR_CHECK(err_code);

    // Enable BLE stack.
    err_code = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(err_code);

    // Register a handler for BLE events.
    NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
}


/**@brief Function for handling events from the GATT library. */
void gatt_evt_handler(nrf_ble_gatt_t * p_gatt, nrf_ble_gatt_evt_t const * 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)", 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",
                  p_gatt->att_mtu_desired_central,
                  p_gatt->att_mtu_desired_periph);
}


/**@brief Function for initializing the GATT library. */
void gatt_init(void)
{
    ret_code_t err_code;

    err_code = nrf_ble_gatt_init(&m_gatt, gatt_evt_handler);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_ble_gatt_att_mtu_periph_set(&m_gatt, NRF_SDH_BLE_GATT_MAX_MTU_SIZE);
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling events from the BSP module.
 *
 * @param[in]   event   Event generated by button press.
 */
void bsp_event_handler(bsp_event_t event)
{
    uint32_t err_code;
    switch (event)
    {
        case BSP_EVENT_SLEEP:
            sleep_mode_enter();
            break;

        case BSP_EVENT_DISCONNECT:
            err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
            if (err_code != NRF_ERROR_INVALID_STATE)
            {
                APP_ERROR_CHECK(err_code);
            }
            break;

        case BSP_EVENT_WHITELIST_OFF:
            if (m_conn_handle == BLE_CONN_HANDLE_INVALID)
            {
                err_code = ble_advertising_restart_without_whitelist(&m_advertising);
                if (err_code != NRF_ERROR_INVALID_STATE)
                {
                    APP_ERROR_CHECK(err_code);
                }
            }
            break;

        default:
            break;
    }
}


/**@brief   Function for handling app_uart events.
 *
 * @details This function will receive a single character from the app_uart module and append it to
 *          a string. The string will be be sent over BLE when the last character received was a
 *          'new line' '\n' (hex 0x0A) or if the string has reached the maximum data length.
 */
/**@snippet [Handling the data received over UART] */
void uart_event_handle(app_uart_evt_t * p_event)
{
    static uint8_t data_array[BLE_NUS_MAX_DATA_LEN];
    static uint8_t index = 0;
    uint32_t       err_code;

    switch (p_event->evt_type)
    {
        case APP_UART_DATA_READY:
            UNUSED_VARIABLE(app_uart_get(&data_array[index]));
            index++;

            if ((data_array[index - 1] == '\n') ||
                (data_array[index - 1] == '\r') ||
                (index >= m_ble_nus_max_data_len))
            {
                if (index > 1)
                {
                    NRF_LOG_DEBUG("Ready to send data over BLE NUS");
                    NRF_LOG_HEXDUMP_DEBUG(data_array, index);

                    do
                    {
                        uint16_t length = (uint16_t)index;
                        err_code = ble_nus_data_send(&m_nus, data_array, &length, m_conn_handle);
                        if ((err_code != NRF_ERROR_INVALID_STATE) &&
                            (err_code != NRF_ERROR_RESOURCES) &&
                            (err_code != NRF_ERROR_NOT_FOUND))
                        {
                            APP_ERROR_CHECK(err_code);
                        }
                    } while (err_code == NRF_ERROR_RESOURCES);
                }

                index = 0;
            }
            break;

        case APP_UART_COMMUNICATION_ERROR:
            APP_ERROR_HANDLER(p_event->data.error_communication);
            break;

        case APP_UART_FIFO_ERROR:
            APP_ERROR_HANDLER(p_event->data.error_code);
            break;

        default:
            break;
    }
}
/**@snippet [Handling the data received over UART] */


/**@brief  Function for initializing the UART module.
 */
/**@snippet [UART Initialization] */
static void uart_init(void)
{
    uint32_t                     err_code;
    app_uart_comm_params_t const comm_params =
    {
        .rx_pin_no    = RX_PIN_NUMBER,
        .tx_pin_no    = TX_PIN_NUMBER,
        .rts_pin_no   = RTS_PIN_NUMBER,
        .cts_pin_no   = CTS_PIN_NUMBER,
        .flow_control = APP_UART_FLOW_CONTROL_DISABLED,
        .use_parity   = false,
#if defined (UART_PRESENT)
        .baud_rate    = NRF_UART_BAUDRATE_115200
#else
        .baud_rate    = NRF_UARTE_BAUDRATE_115200
#endif
    };

    APP_UART_FIFO_INIT(&comm_params,
                       UART_RX_BUF_SIZE,
                       UART_TX_BUF_SIZE,
                       uart_event_handle,
                       APP_IRQ_PRIORITY_LOWEST,
                       err_code);
    APP_ERROR_CHECK(err_code);
}
/**@snippet [UART Initialization] */


/**@brief Function for initializing the Advertising functionality.
 */
static void advertising_init(void)
{
    uint32_t               err_code;
    ble_advertising_init_t init;

    memset(&init, 0, sizeof(init));

    init.advdata.name_type          = BLE_ADVDATA_FULL_NAME;
    init.advdata.include_appearance = false;
    init.advdata.flags              = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;

    init.srdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
    init.srdata.uuids_complete.p_uuids  = m_adv_uuids;

    init.config.ble_adv_fast_enabled  = true;
    init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
    init.config.ble_adv_fast_timeout  = APP_ADV_DURATION;
    init.evt_handler = on_adv_evt;

    err_code = ble_advertising_init(&m_advertising, &init);
    APP_ERROR_CHECK(err_code);

    ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}


/**@brief Function for initializing buttons and leds.
 *
 * @param[out] p_erase_bonds  Will be true if the clear bonding button was pressed to wake the application up.
 */
static void buttons_leds_init(bool * p_erase_bonds)
{
    bsp_event_t startup_event;

    uint32_t err_code = bsp_init(BSP_INIT_LEDS | BSP_INIT_BUTTONS, bsp_event_handler);
    APP_ERROR_CHECK(err_code);

    err_code = bsp_btn_ble_init(NULL, &startup_event);
    APP_ERROR_CHECK(err_code);

    *p_erase_bonds = (startup_event == BSP_EVENT_CLEAR_BONDING_DATA);
}


/**@brief Function for initializing the nrf log module.
 */
static void log_init(void)
{
    ret_code_t err_code = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(err_code);

    NRF_LOG_DEFAULT_BACKENDS_INIT();
}


/**@brief Function for initializing power management.
 */
static void power_management_init(void)
{
    ret_code_t err_code;
    err_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling the idle state (main loop).
 *
 * @details If there is no pending log operation, then sleep until next the next event occurs.
 */
static void idle_state_handle(void)
{
    if (NRF_LOG_PROCESS() == false)
    {
        nrf_pwr_mgmt_run();
    }
}


/**@brief Function for starting advertising.
 */
static void advertising_start(void)
{
    uint32_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
    APP_ERROR_CHECK(err_code);
}


/**@brief Application main function.
 */
int main(void)
{
    bool erase_bonds;
    // Initialize.
    uart_init();
    log_init();
    timers_init();
    buttons_leds_init(&erase_bonds);
    power_management_init();
    ble_stack_init();
    gap_params_init();
    gatt_init();
    services_init();
    advertising_init();
    conn_params_init();

    // Start execution.
   ret_code_t ret_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(ret_code);

    saadc_init();
    saadc_sampling_event_init();
    saadc_sampling_event_enable();
    NRF_LOG_INFO("UART SAADC HAL simple example started.");

    advertising_start();

    // Enter main loop.
    for (;;)
    {
        nrf_pwr_mgmt_run();
        NRF_LOG_FLUSH();
    }
}


/**
 * @}
 */

[Jared]

Hi,

Is any error code thrown? Where exactly after log_init() does the program stop?

regards

Jared

[Jagbir]

Adding disassembly.

NRF_BREAKPOINT_COND;
// On assert, the system can only recover with a reset.

    E003        b 0x00027FC2
--- app_button.c -- 270 ------------------------------------
}
if (!nrf_drv_gpiote_is_init())
{
err_code = nrf_drv_gpiote_init();
    F001FCA3    bl 0x00029904 <nrfx_gpiote_init>
--- app_button.c -- 275 ------------------------------------
VERIFY_SUCCESS(err_code);
    2800        cmp r0, #0
    D0DF        beq 0x00027F82
--- app_button.c -- 301 ------------------------------------
/* Create polling timer. */
return app_timer_create(&m_detection_delay_timer_id,
APP_TIMER_MODE_SINGLE_SHOT,
detection_delay_timeout_handler);
}
    B003        add sp, sp, #12
    BDF0        pop {r4-r7, pc}
--- app_button.c -- 288 ------------------------------------
app_button_cfg_t const * p_btn = &p_buttons[button_count];
    B220        sxth r0, r4
--- app_button.c -- 289 ------------------------------------
#if defined(BUTTON_HIGH_ACCURACY_ENABLED) && (BUTTON_HIGH_ACCURACY_ENABLED == 1)
nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(p_btn->hi_accuracy);
#else
nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(false);
    F89D3006    ldrb.w r3, [sp, #6]
    F88D6004    strb.w r6, [sp, #4]
--- app_button.c -- 288 ------------------------------------
app_button_cfg_t const * p_btn = &p_buttons[button_count];
    EB0502C0    add.w r2, r5, r0, lsl #3
--- app_button.c -- 289 ------------------------------------
#if defined(BUTTON_HIGH_ACCURACY_ENABLED) && (BUTTON_HIGH_ACCURACY_ENABLED == 1)
nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(p_btn->hi_accuracy);
#else
nrf_drv_gpiote_in_config_t config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(false);
    F0230307    bic r3, r3, #7
    F88D3006    strb.w r3, [sp, #6]
--- app_button.c -- 294 ------------------------------------
#endif
config.pull = p_btn->pull_cfg;
err_code = nrf_drv_gpiote_in_init(p_btn->pin_no, &config, gpiote_event_handler);
    A901        add r1, sp, #4
--- app_button.c -- 295 ------------------------------------
config.pull = p_btn->pull_cfg;
    7893        ldrb r3, [r2, #2]
--- app_button.c -- 296 ------------------------------------
err_code = nrf_drv_gpiote_in_init(p_btn->pin_no, &config, gpiote_event_handler);
    F8150030    ldrb.w r0, [r5, r0, lsl #3]
--- app_button.c -- 295 ------------------------------------
config.pull = p_btn->pull_cfg;
    F88D3005    strb.w r3, [sp, #5]
--- app_button.c -- 296 ------------------------------------
err_code = nrf_drv_gpiote_in_init(p_btn->pin_no, &config, gpiote_event_handler);
    463A        mov r2, r7
    F001FCCD    bl 0x00029988 <nrfx_gpiote_in_init>
--- app_button.c -- 298 ------------------------------------
VERIFY_SUCCESS(err_code);
    3C01        subs r4, #1
    B2E4        uxtb r4, r4
    2800        cmp r0, #0
    D0D9        beq 0x00027FAA
    E7E4        b 0x00027FC2
    2007        movs r0, #7
--- app_button.c -- 269 ------------------------------------
return NRF_ERROR_INVALID_PARAM;
    E7E2        b 0x00027FC2
    3180        adds r1, #0x80
    2000        movs r0, #0
    3160        adds r1, #0x60
    2000        movs r0, #0
    3132        adds r1, #0x32
    2000        movs r0, #0
    7DF9        ldrb r1, [r7, #23]
    0002        movs r2, r0
    3134        adds r1, #0x34
    2000        movs r0, #0
    3158        adds r1, #0x58
    2000        movs r0, #0
    7F15        ldrb r5, [r2, #28]
    0002        movs r2, r0
    E150        b 0x000282BC
    0002        movs r2, r0
--- app_button.c -- 308 ------------------------------------
{
ASSERT(mp_buttons);
uint32_t i;
for (i = 0; i < m_button_count; i++)
    B570        push {r4-r6, lr}
    4D08        ldr r5, =0x20003132 <m_button_count>
--- app_button.c -- 313 ------------------------------------
{
nrf_drv_gpiote_in_event_enable(mp_buttons[i].pin_no, true);
    4E08        ldr r6, =0x20003180 <mp_buttons>
--- app_button.c -- 312 ------------------------------------
for (i = 0; i < m_button_count; i++)
    2400        movs r4, #0
    782B        ldrb r3, [r5]
    429C        cmp r4, r3
    D301        bcc 0x0002802E
--- app_button.c -- 314 ------------------------------------
nrf_drv_gpiote_in_event_enable(mp_buttons[i].pin_no, true);
}
return NRF_SUCCESS;
}
    2000        movs r0, #0
    BD70        pop {r4-r6, pc}
--- app_button.c -- 314 ------------------------------------
nrf_drv_gpiote_in_event_enable(mp_buttons[i].pin_no, true);
    6833        ldr r3, [r6]
    2101        movs r1, #1
    F8130034    ldrb.w r0, [r3, r4, lsl #3]
    F001FD23    bl 0x00029A80 <nrfx_gpiote_in_event_enable>
--- app_button.c -- 312 ------------------------------------
for (i = 0; i < m_button_count; i++)
    3401        adds r4, #1
    E7F2        b 0x00028024
    BF00        nop
    20003132    .word 0x20003132
    20003180    .word 0x20003180
--- app_button.c -- 340 ------------------------------------
{
ASSERT(button_id <= m_button_count);
ASSERT(mp_buttons != NULL);
app_button_cfg_t const * p_btn = &mp_buttons[button_id];
    B510        push {r4, lr}
    4B08        ldr r3, =0x20003180 <mp_buttons>
    681B        ldr r3, [r3]
    EB0304C0    add.w r4, r3, r0, lsl #3
--- app_button.c -- 345 ------------------------------------
bool is_set = nrf_drv_gpiote_in_is_set(p_btn->pin_no);
    F8130030    ldrb.w r0, [r3, r0, lsl #3]
    F001FD5D    bl 0x00029B14 <nrfx_gpiote_in_is_set>
--- app_button.c -- 346 ------------------------------------
return !(is_set ^ (p_btn->active_state == APP_BUTTON_ACTIVE_HIGH));
    7863        ldrb r3, [r4, #1]
    1E5A        subs r2, r3, #1
    4253        rsbs r3, r2, #0
    4153        adcs r3, r2
--- app_button.c -- 348 ------------------------------------
}
    1A19        subs r1, r3, r0
    4248        rsbs r0, r1, #0
    4148        adcs r0, r1
    BD10        pop {r4, pc}
    BF00        nop
    20003180    .word 0x20003180
--- app_error.c -- 62 --------------------------------------
* @param[in] p_file_name Pointer to the file name.
*/
void app_error_handler_bare(ret_code_t error_code)
{
error_info_t error_info =
    B51F        push {r0-r4, lr}
    2100        movs r1, #0
    9003        str r0, [sp, #12]
--- app_error.c -- 69 --------------------------------------
.p_file_name = NULL,
.err_code = error_code,
};
app_error_fault_handler(NRF_FAULT_ID_SDK_ERROR, 0, (uint32_t)(&error_info));
    AA01        add r2, sp, #4
    F2440001    movw r0, #0x4001
--- app_error.c -- 66 --------------------------------------
error_info_t error_info =
    E9CD1101    strd r1, r1, [sp, #4]
--- app_error.c -- 69 --------------------------------------
.p_file_name = NULL,
.err_code = error_code,
};
app_error_fault_handler(NRF_FAULT_ID_SDK_ERROR, 0, (uint32_t)(&error_info));
    F000F804    bl 0x0002808C <app_error_fault_handler>
--- app_error.c -- 74 --------------------------------------
UNUSED_VARIABLE(error_info);
}
    B005        add sp, sp, #20
    F85DFB04    pop.w {pc}
    0000        movs r0, r0
--- app_error_weak.c -- 54 ---------------------------------
* when needed.
*/
__WEAK void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info)
{
__disable_irq();
    B510        push {r4, lr}
--- cmsis_gcc.h -- 67 --------------------------------------
Can only be executed in Privileged modes.
*/
__attribute__( ( always_inline ) ) __STATIC_INLINE void __disable_irq(void)
{
__ASM volatile ("cpsid i" : : : "memory");
    B672        cpsid i
--- app_error_weak.c -- 55 ---------------------------------
*/
__WEAK void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info)
{
__disable_irq();
NRF_LOG_FINAL_FLUSH();
    F7FFFCC6    bl 0x00027A20 <nrf_log_panic>
    F7FFFB20    bl 0x000276D8 <nrf_log_frontend_dequeue>
    2800        cmp r0, #0
    D1FB        bne 0x00028094
--- app_error_weak.c -- 60 ---------------------------------
#ifndef DEBUG
NRF_LOG_ERROR("Fatal error");
    4B10        ldr r3, =0x0002DF7C <__log_const_data_start__>
    4C11        ldr r4, =0x0002DFBC <m_nrf_log_app_logs_data_const>
    4911        ldr r1, =0x0002E15F
    1AE4        subs r4, r4, r3
    08E4        lsrs r4, r4, #3
    0424        lsls r4, r4, #16
    F0440001    orr r0, r4, #1
    F7FFFC7E    bl 0x000279AC <nrf_log_frontend_std_0>
--- app_error_weak.c -- 96 ---------------------------------
break;
}
#endif
NRF_BREAKPOINT_COND;
    4B0E        ldr r3, =0xE000EDF0
    681B        ldr r3, [r3]
    07DB        lsls r3, r3, #31
    D500        bpl 0x000280BA
    BE00        bkpt #0
--- app_error_weak.c -- 101 --------------------------------
// On assert, the system can only recover with a reset.
#ifndef DEBUG
NRF_LOG_WARNING("System reset");
    490D        ldr r1, =0x0002E16B
    F0440002    orr r0, r4, #2
    F7FFFC74    bl 0x000279AC <nrf_log_frontend_std_0>
--- app_error_weak.c -- 105 --------------------------------
NVIC_SystemReset();
    F3BF8F4F    dsb sy
--- core_cm4.h -- 1791 -------------------------------------
{
__DSB(); /* Ensure all outstanding memory accesses included
buffered write are completed before reset */
SCB->AIRCR = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
(SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) |
    490A        ldr r1, =0xE000ED00
    4B0B        ldr r3, =0x05FA0004
    68CA        ldr r2, [r1, #12]
    F40262E0    and r2, r2, #0x700
    4313        orrs r3, r2
--- core_cm4.h -- 1794 -------------------------------------
SCB->AIRCR = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
    60CB        str r3, [r1, #12]
--- core_cm4.h -- 1795 -------------------------------------
(SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) |
SCB_AIRCR_SYSRESETREQ_Msk ); /* Keep priority group unchanged */
__DSB(); /* Ensure completion of memory access */
    F3BF8F4F    dsb sy
--- core_cm4.h -- 1798 -------------------------------------
for (;;) /* wait until reset */
{
__NOP();
    BF00        nop
    E7FD        b 0x000280DA
    BF00        nop
    0002DF7C    .word 0x0002DF7C
    0002DFBC    .word 0x0002DFBC
    0002E15F    .word 0x0002E15F
    E000EDF0    .word 0xE000EDF0
    0002E16B    .word 0x0002E16B
    E000ED00    .word 0xE000ED00
    05FA0004    .word 0x05FA0004
--- app_timer2.c -- 133 ------------------------------------
app_timer_t * p1 = CONTAINER_OF(p_item1, app_timer_t, list_item);
uint64_t p0_end = p0->end_val;
uint64_t p1_end = p1->end_val;
return (p0_end <= p1_end) ? true : false;
    E9D02302    ldrd r2, r3, [r0, #8]
    E9D10102    ldrd r0, r1, [r1, #8]
    4299        cmp r1, r3
    BF08        it eq
    4290        cmpeq r0, r2
--- app_timer2.c -- 138 ------------------------------------
}
    BF2C        ite cs
    2001        movcs r0, #1
    2000        movcc r0, #0
    4770        bx lr
    0000        movs r0, r0
--- app_timer2.c -- 115 ------------------------------------
uint64_t now = m_base_counter + drv_rtc_counter_get(&m_rtc_inst);
    E92D4800    push.w {r11, lr}
    480C        ldr r0, =0x20002B04 <m_rtc_inst>
    F000FC02    bl 0x00028922 <drv_rtc_counter_get>
    4B0C        ldr r3, =0x20003188 <m_base_counter>
    E9D32300    ldrd r2, r3, [r3, #0]
    EB120B00    adds.w r11, r2, r0
    F1430C00    adc r12, r3, #0
--- app_timer2.c -- 117 ------------------------------------
/* it is possible that base was not updated and overflow occured, in that case 'now' will be
* 24bit value behind. Additional timestamp updated on every 24 bit period is used to detect
* that case. Apart from that 'now' should never be behind previously read timestamp.
*/
if (now < m_stamp64) {
    4B09        ldr r3, =0x20003200 <m_stamp64>
    E9D32300    ldrd r2, r3, [r3, #0]
    459C        cmp r12, r3
    BF08        it eq
    4593        cmpeq r11, r2
--- app_timer2.c -- 115 ------------------------------------
uint64_t now = m_base_counter + drv_rtc_counter_get(&m_rtc_inst);
    4658        mov r0, r11
    4661        mov r1, r12
--- app_timer2.c -- 117 ------------------------------------
/* it is possible that base was not updated and overflow occured, in that case 'now' will be
* 24bit value behind. Additional timestamp updated on every 24 bit period is used to detect
* that case. Apart from that 'now' should never be behind previously read timestamp.
*/
if (now < m_stamp64) {
    D203        bcs 0x00028146
--- app_timer2.c -- 122 ------------------------------------
now += (DRV_RTC_MAX_CNT + 1);
    F11B7080    adds.w r0, r11, #0x1000000
    F14C0100    adc r1, r12, #0
--- app_timer2.c -- 123 ------------------------------------
}
return now;
}
    E8BD8800    pop.w {r11, pc}
    BF00        nop
    20002B04    .word 0x20002B04
    20003188    .word 0x20003188
    20003200    .word 0x20003200
--- app_timer2.c -- 492 ------------------------------------
timer_req_t * p_req;
#if APP_TIMER_WITH_PROFILER
CRITICAL_REGION_ENTER();
#endif
p_req = nrf_atfifo_item_alloc(m_req_fifo, &fifo_ctx);
    B537        push {r0-r2, r4-r5, lr}
--- app_timer2.c -- 490 ------------------------------------
{
    4605        mov r5, r0
    460C        mov r4, r1
--- app_timer2.c -- 492 ------------------------------------
timer_req_t * p_req;
#if APP_TIMER_WITH_PROFILER
CRITICAL_REGION_ENTER();
#endif
p_req = nrf_atfifo_item_alloc(m_req_fifo, &fifo_ctx);
    480A        ldr r0, =0x200031EC <m_req_fifo_inst>
    A901        add r1, sp, #4
    F000FC10    bl 0x00028986 <nrf_atfifo_item_alloc>
--- app_timer2.c -- 500 ------------------------------------
++m_current_user_op_queue_utilization;
}
CRITICAL_REGION_EXIT();
#endif /* APP_TIMER_WITH_PROFILER */
if (p_req)
    B160        cbz r0, 0x00028182
--- app_timer2.c -- 505 ------------------------------------
{
p_req->type = type;
    7005        strb r5, [r0]
--- app_timer2.c -- 507 ------------------------------------
p_req->p_timer = p_timer;
    6044        str r4, [r0, #4]
--- app_timer2.c -- 508 ------------------------------------
if (nrf_atfifo_item_put(m_req_fifo, &fifo_ctx))
    A901        add r1, sp, #4
    4806        ldr r0, =0x200031EC <m_req_fifo_inst>
    F000FC33    bl 0x000289DA <nrf_atfifo_item_put>
    B118        cbz r0, 0x0002817E
--- app_timer2.c -- 509 ------------------------------------
{
timer_request_proc_trigger();
    4805        ldr r0, =0x20002B04 <m_rtc_inst>
    F000FBD8    bl 0x0002892C <drv_rtc_irq_trigger>
--- app_timer2.c -- 512 ------------------------------------
else
{
NRF_LOG_WARNING("Scheduling interrupted another scheduling.");
}
return NRF_SUCCESS;
    2000        movs r0, #0
--- app_timer2.c -- 518 ------------------------------------
else
{
return NRF_ERROR_NO_MEM;
}
}
    B003        add sp, sp, #12
    BD30        pop {r4-r5, pc}
--- app_timer2.c -- 520 ------------------------------------
return NRF_ERROR_NO_MEM;
    2004        movs r0, #4
    E7FB        b 0x0002817E
    BF00        nop
    200031EC    .word 0x200031EC
    20002B04    .word 0x20002B04
--- app_timer2.c -- 165 ------------------------------------
if ((m_global_active == true) && (p_timer != NULL) && (p_timer->active))
    4B19        ldr r3, =0x20003190 <m_global_active>
    781B        ldrb r3, [r3]
--- app_timer2.c -- 161 ------------------------------------
{
    E92D4830    push.w {r4-r5, r11, lr}
    4604        mov r4, r0
--- app_timer2.c -- 162 ------------------------------------
ASSERT(p_timer->handler);
bool ret = false;
if ((m_global_active == true) && (p_timer != NULL) && (p_timer->active))
    B91B        cbnz r3, 0x000281A4
--- app_timer2.c -- 163 ------------------------------------
bool ret = false;
    2500        movs r5, #0
--- app_timer2.c -- 197 ------------------------------------
ret = true;
}
}
return ret;
}
    4628        mov r0, r5
    E8BD8830    pop.w {r4-r5, r11, pc}
--- app_timer2.c -- 165 ------------------------------------
if ((m_global_active == true) && (p_timer != NULL) && (p_timer->active))
    2800        cmp r0, #0
    D0F9        beq 0x0002819C
    7F03        ldrb r3, [r0, #28]
    F00305FF    and r5, r3, #0xFF
    2B00        cmp r3, #0
    D0F4        beq 0x0002819C
--- app_timer2.c -- 166 ------------------------------------
{
if (get_now() >= p_timer->end_val) {
    F7FFFFAF    bl 0x00028114 <get_now>