RE: nRF9160 SAADC nrfx api: high power consumption after uninit

Håkon Alseth — Thu, 29 Sep 2022 14:01:27 GMT

Hi Johannes,

Thank you for updating with your findings!

[quote user="Johannes"]

what a timing. I just wanted to post my findings. ^^

What I found is that in the zephyr implementation after a blocking adc measurement is triggered the adc is stopped with exactly this call.
When issuing a stop task after the measurement has finished the power consumption is down to what I was expecting.

Another thing that needs to be done is to add the saadc_channels_disable function to the SDK version 1.8.0. Without it the pin cannot be used for anything else.

[/quote]

Yes, this is similar to the fix that we added ~6 months ago:

https://github.com/zephyrproject-rtos/hal_nordic/blob/master/nrfx/drivers/src/nrfx_saadc.c#L295

Kind regards,

Håkon

RE: nRF9160 SAADC nrfx api: high power consumption after uninit

JoEi — Wed, 28 Sep 2022 14:12:00 GMT

Hi Håkon,

what a timing. I just wanted to post my findings. ^^

Another thing that needs to be done is to add the saadc_channels_disable function to the SDK version 1.8.0. Without it the pin cannot be used for anything else.

Here are the functions with my changes:

nrfx_err_t nrfx_saadc_mode_trigger(void)
{
    NRFX_ASSERT(m_cb.saadc_state != NRF_SAADC_STATE_UNINITIALIZED);
    NRFX_ASSERT(m_cb.saadc_state != NRF_SAADC_STATE_IDLE);

    if (!m_cb.p_buffer_primary)
    {
        return NRFX_ERROR_NO_MEM;
    }

    nrfx_err_t result = NRFX_SUCCESS;
    switch (m_cb.saadc_state)
    {
        case NRF_SAADC_STATE_SIMPLE_MODE:
            nrf_saadc_enable(NRF_SAADC);
            // When in simple blocking or non-blocking mode, buffer size is equal to activated channel count.
            // Single SAMPLE task is enough to obtain one sample on each activated channel.
            // This will result in buffer being filled with samples and therefore END event will appear.
            nrf_saadc_buffer_init(NRF_SAADC, m_cb.p_buffer_primary, m_cb.size_primary);
            if (m_cb.event_handler)
            {
                m_cb.saadc_state = NRF_SAADC_STATE_SIMPLE_MODE_SAMPLE;
                nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_START);
            }
            else
            {
                nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_START);
                while (!nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_STARTED))
                {}
                nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_STARTED);

                nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_SAMPLE);
                while (!nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_END))
                {}
                nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_END);
                nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_STOP);
                nrf_saadc_disable(NRF_SAADC);
            }
            break;

        case NRF_SAADC_STATE_ADV_MODE:
            nrf_saadc_enable(NRF_SAADC);
            if (m_cb.event_handler)
            {
                // When in advanced non-blocking mode, latch whole buffer in EasyDMA.
                // END event will arrive when whole buffer is filled with samples.
                m_cb.saadc_state = NRF_SAADC_STATE_ADV_MODE_SAMPLE;
                nrf_saadc_buffer_init(NRF_SAADC, m_cb.p_buffer_primary, m_cb.size_primary);
                nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_START);
                break;
            }

            // When in advanced blocking mode, latch single chunk of buffer in EasyDMA.
            // Each chunk consists of single sample from each activated channels.
            // END event will arrive when single chunk is filled with samples.
            nrf_saadc_buffer_init(NRF_SAADC,
                                  &m_cb.p_buffer_primary[m_cb.samples_converted],
                                  m_cb.channels_activated_count);

            nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_START);
            while (!nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_STARTED))
            {}
            nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_STARTED);

            if (m_cb.oversampling_without_burst)
            {
                // Oversampling without burst is possible only on single channel.
                // In this configuration more than one SAMPLE task is needed to obtain single sample.
                uint32_t samples_to_take =
                    nrf_saadc_oversample_sample_count_get(nrf_saadc_oversample_get(NRF_SAADC));

                for (uint32_t sample_idx = 0; sample_idx < samples_to_take; sample_idx++)
                {
                    nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_DONE);
                    nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_SAMPLE);
                    while (!nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_DONE))
                    {}
                }
            }
            else
            {
                // Single SAMPLE task is enough to obtain one sample on each activated channel.
                // This will result in chunk being filled with samples and therefore END event will appear.
                nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_SAMPLE);
            }
            while (!nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_END))
            {}
            nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_END);
            nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_STOP);

            m_cb.samples_converted += m_cb.channels_activated_count;
            if (m_cb.samples_converted < m_cb.size_primary)
            {
                result = NRFX_ERROR_BUSY;
            }
            else
            {
                m_cb.samples_converted  = 0;
                m_cb.p_buffer_primary   = m_cb.p_buffer_secondary;
                m_cb.size_primary       = m_cb.size_secondary;
                m_cb.p_buffer_secondary = NULL;
            }
            nrf_saadc_disable(NRF_SAADC);
            break;

        default:
            result = NRFX_ERROR_INVALID_STATE;
            break;
    }

    return result;
}

static void saadc_channels_disable(uint32_t channel_mask)
{
    while (channel_mask)
    {
        uint8_t channel = __CLZ(__RBIT(channel_mask));
        channel_mask &= ~(1 << channel);
        m_cb.channels_configured &= ~(1 << channel);
        m_cb.channels_activated &= ~(1 << channel);

        m_cb.channels_pselp[channel] = NRF_SAADC_INPUT_DISABLED;
        m_cb.channels_pseln[channel] = NRF_SAADC_INPUT_DISABLED;
        nrf_saadc_channel_input_set(NRF_SAADC, channel,
                                    NRF_SAADC_INPUT_DISABLED, NRF_SAADC_INPUT_DISABLED);
    }
    m_cb.channels_activated_count = 0;
    for(int i = 0; i < SAADC_CH_NUM; i++)
    {
        if(m_cb.channels_activated & (1 << i))
        {
            m_cb.channels_activated_count++;
        }
    }
}

void nrfx_saadc_uninit(void)
{
    nrfx_saadc_abort();
    NRFX_IRQ_DISABLE(SAADC_IRQn);
    nrf_saadc_disable(NRF_SAADC);
    saadc_channels_disable(m_cb.channels_configured | m_cb.channels_activated);
    m_cb.saadc_state = NRF_SAADC_STATE_UNINITIALIZED;
}

Kind regards,
Johannes

RE: nRF9160 SAADC nrfx api: high power consumption after uninit

Håkon Alseth — Wed, 28 Sep 2022 13:38:54 GMT

Hi,

Could you try issuing a _STOP task before uninit()?

nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_STOP);

Kind regards,

Håkon