RE: Interfacing SAADC with BLE: Timer issue?

Moritz_S — Tue, 02 May 2023 09:43:14 GMT

I changed everything to continuous mode, so I could remove the nrf_drv_timer library. Everything works fine now.

RE: Interfacing SAADC with BLE: Timer issue?

Sigurd — Tue, 02 May 2023 08:58:44 GMT

Hi,

[quote user="Moritz_S"]I'm thinking about switching the code to the ADC's continuous mode. In my opinion this would avoid the problem we discuss here [/quote]

I believe continuous mode should improve this situation. Let me know if that was not case.

RE: Interfacing SAADC with BLE: Timer issue?

Moritz_S — Thu, 23 Mar 2023 13:23:15 GMT

Hi,

yes, absolutely. I'm using the m_adc_evt_counter provided in the SDK's SAADC example. You can check the code below (I included all the includes but removed irrelevant code).

I'm thinking about switching the code to the ADC's continuous mode. In my opinion this would avoid the problem we discuss here or do you think this problem is caused by something else and that I would face it also in the continuous mode?

#include "nordic_common.h"
#include "nrf.h"

#include "app_error.h"
#include "app_timer.h"
#include "app_util_platform.h"

#include "ble.h"
#include "ble_hci.h"
#include "ble_srv_common.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 "fds.h"
#include "peer_manager.h"
#include "peer_manager_handler.h"
#include "bsp_btn_ble.h"
#include "sensorsim.h"
#include "ble_conn_state.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "nrf_pwr_mgmt.h"
#include "nrf_gpio.h"

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

#include "boards.h"
#include "nrf_queue.h"

// FROM SAADC EXAMPLE
#include "nrf_drv_saadc.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"

static const nrf_drv_timer_t m_timer = NRF_DRV_TIMER_INSTANCE(2);
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 const nrf_drv_saadc_config_t saadc_config = {
    .resolution = NRF_SAADC_RESOLUTION_12BIT,
    .oversample = NRF_SAADC_OVERSAMPLE_DISABLED,
    .interrupt_priority = 6,
    .low_power_mode = false
};

void timer_handler(nrf_timer_event_t event_type, void * p_context)
{
    NRF_LOG_INFO("Timer called");
}

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 4 ms */
    uint32_t ticks = nrf_drv_timer_ms_to_ticks(&m_timer, SAMPLING_INTERVAL_MS);

    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);
}


static int saadc_sampling_event_enable(void)
{
    uint32_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
    APP_ERROR_CHECK(err_code);

    return err_code;
}

static int saadc_sampling_event_disable(void)
{
    uint32_t err_code = nrf_drv_ppi_channel_disable(m_ppi_channel);
    APP_ERROR_CHECK(err_code);

    return err_code;
}


void saadc_callback(nrf_drv_saadc_evt_t const * p_event)
{
    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);

        bytes_recv += (SAMPLES_IN_BUFFER * 2);
        sample_no += SAMPLES_IN_BUFFER;

        err_code = nrf_queue_write(&m_queue, &p_event->data.done.p_buffer, (size_t) SAMPLES_IN_BUFFER);
        if (err_code != NRF_SUCCESS)
        {
            if (err_code == NRF_ERROR_NO_MEM)
            {
                NRF_LOG_DEBUG("Queue full");
            }
            else
            {
                APP_ERROR_CHECK(err_code);
            }
        }

        m_adc_evt_counter++;

        if ((m_adc_evt_counter%21) == 0) {
            NRF_LOG_INFO("Bytes added to queue: %d", bytes_recv);
            NRF_LOG_INFO("ADC events: %d", m_adc_evt_counter);
            NRF_LOG_INFO("SAADC Callback: Current queue utilization: %d", ((int) nrf_queue_utilization_get(&m_queue)));
        }
    }
}


static int saadc_init(void)
{
    uint32_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);
    err_code = nrf_drv_saadc_init(&saadc_config, 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);

    return err_code;
}

/**@brief Function for application main entry.
 */
int main(void)
{
    bool erase_bonds;
    uint32_t err_code;
    uint32_t reading_from_queue = 0;
    uint8_t len_m16_array = (sizeof(m16_array) / sizeof(uint16_t));

    // Initialize.
    log_init();
    timers_init();
    buttons_leds_init(&erase_bonds);
    power_management_init();

    // Go to system-off mode (this function will not return; wakeup will cause a reset).
    uint32_t wdt_reset;
    wdt_reset = NRF_POWER->RESETREAS;
    NRF_LOG_INFO("reset: 0x%08x", wdt_reset);
    if (NRF_POWER->RESETREAS == (0x00000004))
    {
        nrf_pwr_mgmt_shutdown(NRF_PWR_MGMT_SHUTDOWN_GOTO_SYSOFF);
    }

    // Initialize BLE
    ble_stack_init();
    gap_params_init();
    gatt_init();
    services_init();
    advertising_init();
    conn_params_init();
    peer_manager_init();

    // Initialize SAADC
    err_code = saadc_init();
    if (err_code == NRF_SUCCESS)
    {
        NRF_LOG_INFO("SAADC successfully initialized.");
    }
    else
    {
        NRF_LOG_INFO("Error initializing SAADC.");
    }

    saadc_sampling_event_init();
    
    // Start advertising
    advertising_start(erase_bonds);

    for (;;)
    {
        if (audio_transfer)
        {
            if (saadc_active != true)
            {
                err_code = saadc_sampling_event_enable();

                if (err_code == NRF_SUCCESS)
                {
                    saadc_active = true;
                    NRF_LOG_INFO("SAADC started.\n");
                } 
                else
                {
                    NRF_LOG_INFO("Error starting SAADC.\n");
                }
            }

            #ifdef SsRF01
                nrf_gpio_pin_toggle(LED_1);
            #elif BOARD_PCA10040
                nrf_gpio_pin_toggle(LED_3);
            #endif

            // set back err_code
            err_code = NRF_SUCCESS;

            if (nrf_queue_utilization_get(&m_queue) > len_m16_array)
            {
                err_code = nrf_queue_read(&m_queue, &m16_array, (size_t) len_m16_array);
                reading_from_queue += 1;

                uint8_t x = sizeof(m16_array);

                if (err_code == NRF_SUCCESS)
                {
                    for (int i = 0; i < len_m16_array; i+=2)
                    {
                        m_array[i] = (uint8_t)((m16_array[i] & 0xFF00) >> 8);
                        m_array[i+1] = (uint8_t)(m16_array[i] & 0x00FF);
                    }

                    err_code = send_m_array();
                    bytes_read_from_buffer += data_length;
                }
                else if (err_code == NRF_ERROR_NOT_FOUND)
                {
                    NRF_LOG_DEBUG("Not enough data in queue.");
                    NRF_LOG_INFO("Current queue utilization: %d", ((int) nrf_queue_utilization_get(&m_queue)));
                }
                else
                {
                    APP_ERROR_CHECK(err_code);
                }
            }
        }

        if ((!audio_transfer) &&
            (saadc_active)
           )
        {
            saadc_sampling_event_disable();
            saadc_active = false;

            NRF_LOG_INFO("ADC events: %d", m_adc_evt_counter);
        }

        idle_state_handle();
        NRF_LOG_FLUSH();
    }

    bsp_board_leds_off();
}

RE: Interfacing SAADC with BLE: Timer issue?

Sigurd — Thu, 23 Mar 2023 13:04:20 GMT

Only 40 calls seems low.

Could you post how your code looks like now?

How are you measuring the number of calls?

RE: Interfacing SAADC with BLE: Timer issue?

Moritz_S — Tue, 21 Mar 2023 14:24:38 GMT

over 10 seconds

RE: Interfacing SAADC with BLE: Timer issue?

Sigurd — Tue, 21 Mar 2023 14:17:55 GMT

[quote user="Moritz_S"]I'm only getting ~ 40 calls to saadc_callback(). [/quote]

Over how long time?

RE: Interfacing SAADC with BLE: Timer issue?

Moritz_S — Tue, 21 Mar 2023 14:06:32 GMT

Hi,
thanks for the quick response. Using your suggestion, I'm only getting ~ 40 calls to saadc_callback(). The calculated number of ticks seems correct when using a 16 MHz clock, but why does this not reflect in the number of calls?

RE: Interfacing SAADC with BLE: Timer issue?

Sigurd — Tue, 21 Mar 2023 13:51:25 GMT

Hi,

Try this:

    /* setup m_timer for compare event every 4 ms */
    uint32_t ticks = nrf_drv_timer_ms_to_ticks(&m_timer, SAMPLING_INTERVAL_MS);          // yields 64.000
    //uint32_t ticks_us = nrf_drv_timer_us_to_ticks(&m_timer, SAMPLING_INTERVAL_US);
    //uint32_t ticks = APP_TIMER_TICKS(SAMPLING_INTERVAL_MS);                                 // yields 66
    
    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);

APP_TIMER_TICKS() is for the application timer, "app_timer",(it uses the RTC peripheral), but you are using nrf_drv_timer here(it uses the TIMER peripheral), so you cannot use app_timer macros for the nrf_driver_timer, it's 2 different libraries.