RE: Turn off BLE for optimal ADC readings

Kenneth — Thu, 26 Apr 2018 19:23:31 GMT

The accuracy depend on an accurate internal clock for sampling, the best accuracy is ensured by starting the external high frequency crystal.

RE: Turn off BLE for optimal ADC readings

Mason — Wed, 25 Apr 2018 14:57:11 GMT

Can you provide some clarification as to what this will accomplish?

RE: Turn off BLE for optimal ADC readings

Kenneth — Wed, 25 Apr 2018 13:59:21 GMT

If you are not using timeslot, then you should make sure to request HFCLK by calling sd_clock_hfclk_request() and wait sd_clock_hfclk_is_running() for before starting ADC measurements. When all ADC measurements are done you can call sd_clock_hfclk_release().

RE: Turn off BLE for optimal ADC readings

Mason — Wed, 11 Apr 2018 22:37:24 GMT

I've attempted using both the timeslot API to request a timeslot in which the radio is inactive. I've tried to request a period of 10.5 seconds, but it seems that the connection interval takes priority and the radio starts chatting again.

To aid in this, I've configured a radio notification event to set a volatile flag before and after radio events, such that I'll omit capturing a reading when a radio is about to occur, and request another timeslot instead.

I based my timeslot code on Ole Bauck's timeslot.c from https://devzone.nordicsemi.com/f/nordic-q-a/19200/timeslot-extension/74376#74376

#include <stdint.h>
#include <stdbool.h>
#include "nrf.h"
#include "app_error.h"
#include "nrf_sdh.h"
#include "nrf_soc.h"
#include "boards.h"

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

/**Constants for timeslot API
*/
static nrf_radio_request_t  m_timeslot_request;
static uint32_t             m_slot_length;

volatile uint32_t total_timeslot_length;
volatile uint32_t extend_success_count;
volatile uint32_t fail_count;

static nrf_radio_signal_callback_return_param_t signal_callback_return_param;

#define TIMESLOT_EXTEND_LENGTH 200//was 200
#define TIMESLOT_TIMER_INTERRUPT_END_MARGIN		50		//margin in us on timer 0 interrupt before the timeslot ends
#define QUIET_TIME 10500000 //10.5 seconds

/**@brief Request next timeslot event in earliest configuration
 */
uint32_t request_next_event_earliest(void)
{
    m_slot_length                                  = 15000;
    m_timeslot_request.request_type                = NRF_RADIO_REQ_TYPE_EARLIEST;
    m_timeslot_request.params.earliest.hfclk       = NRF_RADIO_HFCLK_CFG_XTAL_GUARANTEED;
    m_timeslot_request.params.earliest.priority    = NRF_RADIO_PRIORITY_NORMAL;
    m_timeslot_request.params.earliest.length_us   = m_slot_length;
    m_timeslot_request.params.earliest.timeout_us  = 1000000;
    return sd_radio_request(&m_timeslot_request);
}


/**@brief Configure next timeslot event in earliest configuration
 */
void configure_next_event_earliest(void)
{
    m_slot_length                                  = 15000;
    m_timeslot_request.request_type                = NRF_RADIO_REQ_TYPE_EARLIEST;
    m_timeslot_request.params.earliest.hfclk       = NRF_RADIO_HFCLK_CFG_XTAL_GUARANTEED;
    m_timeslot_request.params.earliest.priority    = NRF_RADIO_PRIORITY_NORMAL;
    m_timeslot_request.params.earliest.length_us   = m_slot_length;
    m_timeslot_request.params.earliest.timeout_us  = 1000000;
}


/**@brief Configure next timeslot event in normal configuration
 */
void configure_next_event_normal(void)
{
    m_slot_length                                 = 15000;
    m_timeslot_request.request_type               = NRF_RADIO_REQ_TYPE_NORMAL;
    m_timeslot_request.params.normal.hfclk        = NRF_RADIO_HFCLK_CFG_XTAL_GUARANTEED;
    m_timeslot_request.params.normal.priority     = NRF_RADIO_PRIORITY_HIGH;
    m_timeslot_request.params.normal.distance_us  = 100000;
    m_timeslot_request.params.normal.length_us    = m_slot_length;
}


/**@brief Timeslot signal handler
 */
void nrf_evt_signal_handler(uint32_t evt_id, void * p_context)
{
	UNUSED_PARAMETER(p_context);
    uint32_t err_code;

    switch (evt_id)
    {
        case NRF_EVT_RADIO_SIGNAL_CALLBACK_INVALID_RETURN:
            //No implementation needed
            break;
        case NRF_EVT_RADIO_SESSION_IDLE:
            //No implementation needed
            break;
        case NRF_EVT_RADIO_SESSION_CLOSED:
            //No implementation needed, session ended
            break;
        case NRF_EVT_RADIO_BLOCKED:
            //Fall through
        case NRF_EVT_RADIO_CANCELED:
            err_code = request_next_event_earliest();
            APP_ERROR_CHECK(err_code);
            break;
        default:
            break;
    }
}


/**@brief Timeslot event handler
 */
nrf_radio_signal_callback_return_param_t * radio_callback(uint8_t signal_type)
{
    switch(signal_type)
    {
        case NRF_RADIO_CALLBACK_SIGNAL_TYPE_START:
			NRF_TIMER0->INTENSET = TIMER_INTENSET_COMPARE0_Msk;
			NRF_TIMER0->BITMODE = (TIMER_BITMODE_BITMODE_32Bit << TIMER_BITMODE_BITMODE_Pos);
			NRF_TIMER0->PRESCALER = (4 << TIMER_PRESCALER_PRESCALER_Pos);
            NRF_TIMER0->CC[0] = m_slot_length - TIMESLOT_TIMER_INTERRUPT_END_MARGIN;
            NVIC_EnableIRQ(TIMER0_IRQn);

			total_timeslot_length = m_slot_length;

			signal_callback_return_param.params.request.p_next = NULL;
            signal_callback_return_param.params.extend.length_us = TIMESLOT_EXTEND_LENGTH;
            signal_callback_return_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_EXTEND;

            break;

        case NRF_RADIO_CALLBACK_SIGNAL_TYPE_RADIO:
            signal_callback_return_param.params.request.p_next = NULL;
            signal_callback_return_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_NONE;
            break;

        case NRF_RADIO_CALLBACK_SIGNAL_TYPE_TIMER0:
			//timeslot is ending, signal the end action
            NRF_LOG_INFO("Timeslot ending after %d microseconds\n", NRF_TIMER0->CC[0]);
			signal_callback_return_param.params.request.p_next = NULL;
			signal_callback_return_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_END;
            break;
        case NRF_RADIO_CALLBACK_SIGNAL_TYPE_EXTEND_SUCCEEDED:

			extend_success_count++;

            if(total_timeslot_length >= QUIET_TIME)
			{
				signal_callback_return_param.params.request.p_next = NULL;
				signal_callback_return_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_NONE;
			}
			else
			{
				total_timeslot_length += TIMESLOT_EXTEND_LENGTH;

				NRF_TIMER0->CC[0] = total_timeslot_length - TIMESLOT_TIMER_INTERRUPT_END_MARGIN;
				signal_callback_return_param.params.request.p_next = NULL;
				signal_callback_return_param.params.extend.length_us = TIMESLOT_EXTEND_LENGTH;
				signal_callback_return_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_EXTEND;
			}
            break;
        case NRF_RADIO_CALLBACK_SIGNAL_TYPE_EXTEND_FAILED:

            fail_count++;

			signal_callback_return_param.params.request.p_next = NULL;
            signal_callback_return_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_END;
            break;
        default:
            //No implementation needed
            break;
    }
    return (&signal_callback_return_param);
}


/**@brief Function for initializing the timeslot API.
 */
uint32_t timeslot_sd_init(void)
{
    uint32_t err_code;

    err_code = sd_radio_session_open(radio_callback);
    if (err_code != NRF_SUCCESS)
    {
        return err_code;
    }

    err_code = request_next_event_earliest();
    if (err_code != NRF_SUCCESS)
    {
        (void)sd_radio_session_close();
        return err_code;
    }
    return NRF_SUCCESS;
}

This is what I've done to set up a Radio notification to set a flag to True when the radio is inactive, and false when the radio is active:

void SWI1_IRQHandler(bool radio_evt)
{
    radio_flag = !radio_flag;
}

/**@brief Function for initializing Radio Notification Software Interrupts.
 */
uint32_t radio_notification_init(uint32_t irq_priority, uint8_t notification_type, uint8_t notification_distance)
{
    uint32_t err_code;

    err_code = sd_nvic_ClearPendingIRQ(SWI1_IRQn);
    if (err_code != NRF_SUCCESS)
    {
        return err_code;
    }

    err_code = sd_nvic_SetPriority(SWI1_IRQn, irq_priority);
    if (err_code != NRF_SUCCESS)
    {
        return err_code;
    }

    err_code = sd_nvic_EnableIRQ(SWI1_IRQn);
    if (err_code != NRF_SUCCESS)
    {
        return err_code;
    }

    // Configure the event
    return sd_radio_notification_cfg_set(notification_type, notification_distance);
}

Which I enable with

err_code = radio_notification_init(3, NRF_RADIO_NOTIFICATION_TYPE_INT_ON_BOTH, NRF_RADIO_NOTIFICATION_DISTANCE_5500US);
APP_ERROR_CHECK(err_code);

after I call ble_stack_init();

Within my adc callback, I have the following:

					if ( get_radio_flag() )
					{
						set_value_in_array( adc_counter, adc_value[1]);

						adc_counter++;

						if (adc_counter >= get_max_readings())
						{
							end_reading_routine();
						}
					}

					else
					{
					//error code should be checked here
						request_next_event_earliest();
					}

EDIT: by accessing radio_flag directly as a global volatile instead of using a getter, and toggling the value of radio_flag as the sole task of SWI1_IRQHandler, I was able to see some reduction in noise in my readings.

I'd like to make use of the timeslot API to further reduce the noise in my signal, as the approach I'm taking doesn't always prevent noise from affecting my readings (this is on a custom board, in which a battery is the voltage source)

Please let me know if you need any additional information or if I'm doing anything that's obviously incorrect.

RE: Turn off BLE for optimal ADC readings

Kenneth — Tue, 03 Apr 2018 13:36:44 GMT

You can either request a timeslot, then you will get an un-interrupted timeslot that you can do what you like. Or you can use radio notifications, and plan your ADC operations after or between radio events.

RE: Turn off BLE for optimal ADC readings

Mason — Mon, 02 Apr 2018 21:39:12 GMT

For clarification:

Can I disable the link layer temporarily?