ADC interupt based on SAADC limit monitoring or LPCOMP

RE: ADC interupt based on SAADC limit monitoring or LPCOMP

Tjaz — Thu, 29 Oct 2020 10:14:18 GMT

Hey,

ignore the above. I have made some progress, but my code gets stuck.

I have:

NOTE: I am using nrf-sdk v1.3.0

prj.conf:

# ADC
CONFIG_ADC=y
CONFIG_ADC_NRFX_SAADC=y
CONFIG_NRFX_SAADC=y

main:

#include <zephyr.h>

#include <drivers/adc.h>

#include <nrfx_saadc.h>

#include <logging/log.h>
LOG_MODULE_REGISTER(main);

#define SAADC_BUFFER_LEN 1
static int16_t saadc_results_buffer[SAADC_BUFFER_LEN];

void saadc_event_handler(nrfx_saadc_evt_t const *p_event)
{
    LOG_INF("SAADC EVENT: %d", p_event->type);
}

void main(void)
{
#define CHANNEL 0
#define AIN_50HZ_AMP NRF_SAADC_INPUT_AIN0
#define LIMIT_LOW 0
#define LIMIT_HIGH 50

    LOG_INF("OPT 2");
    LOG_INF("INIT SAADC");
    nrfx_err_t nrfx_err = nrfx_saadc_init(0);
    if (nrfx_err != NRFX_SUCCESS)
    {
        LOG_ERR("nrfx_saadc_init, err: %d", nrfx_err);
    }

    nrfx_err = nrfx_saadc_offset_calibrate(NULL);
    if (nrfx_err != NRFX_SUCCESS)
    {
        LOG_ERR("nrfx_saadc_offset_calibrate, err: %d", nrfx_err);
    }

    nrfx_saadc_channel_t saacd_channel_cfg = NRFX_SAADC_DEFAULT_CHANNEL_SE(AIN_50HZ_AMP, CHANNEL); // AIN 0 and channel 1
    nrfx_saadc_adv_config_t saadc_adv_config = NRFX_SAADC_DEFAULT_ADV_CONFIG;
    saadc_adv_config.internal_timer_cc = 200;

    nrfx_err = nrfx_saadc_channels_config(&saacd_channel_cfg, 1);
    if (nrfx_err != NRFX_SUCCESS)
    {
        LOG_ERR("nrfx_saadc_channels_config, err: %d", nrfx_err);
    }

    nrfx_err = nrfx_saadc_advanced_mode_set(BIT(CHANNEL), NRF_SAADC_RESOLUTION_12BIT, &saadc_adv_config, saadc_event_handler);
    if (nrfx_err != NRFX_SUCCESS)
    {
        LOG_ERR("nrfx_saadc_advanced_mode_set, err: %d", nrfx_err);
    }

    nrfx_err = nrfx_saadc_buffer_set(saadc_results_buffer, SAADC_BUFFER_LEN);
    if (nrfx_err != NRFX_SUCCESS)
    {
        LOG_ERR("nrfx_saadc_buffer_set, err: %d", nrfx_err);
    }

    nrfx_err = nrfx_saadc_limits_set(CHANNEL, LIMIT_LOW, LIMIT_HIGH);
    if (nrfx_err != NRFX_SUCCESS)
    {
        LOG_ERR("nrfx_saadc_limits_set, err: %d", nrfx_err);
    }
    LOG_INF("AFTER INIT SAADC");

    LOG_INF("START SAADC SAMPLING");
    nrfx_err = nrfx_saadc_mode_trigger();  // !!code gets stuck here!!
    if (nrfx_err != NRFX_SUCCESS)
    {
        LOG_ERR("nrfx_saadc_mode_trigger, err: %d", nrfx_err);
    }

    LOG_INF("sleep 5 s");
    k_sleep(K_SECONDS(5));
    LOG_INF("STOP SAADC SAMPLING");
    nrfx_saadc_abort();
    
    // main goes to sleep;
    while (1)
    {
        k_sleep(K_SECONDS(3600));
    }
}

The code gets stuck on line 69.

Tracing this further into the called function (nrfx_saadc_mode_trigger), is gets tuck at line 509 in nrfx_saadc.c, where it calls:
nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_START);
wich is just a simple function setting a register (in nrf_saadc.h):

NRF_STATIC_INLINE void nrf_saadc_task_trigger(NRF_SAADC_Type * p_reg, nrf_saadc_task_t task)
{
    *((volatile uint32_t *)((uint8_t *)p_reg + (uint32_t)task)) = 0x1UL;
}

Any suggestions on how to debug this?

Regards,
Tjaž

RE: ADC interupt based on SAADC limit monitoring or LPCOMP

Tjaz — Wed, 28 Oct 2020 13:49:13 GMT

Ok.

Based on your reply I ahve abandoned RTC/Timer, and am now trying to set up SAADC internal timer.

I have the following code:

LOG_INF("INIT SAADC");
    nrfx_err_t nrfx_err = nrfx_saadc_init(0);
    if (nrfx_err != NRFX_SUCCESS)
    {
        LOG_ERR("nrfx_saadc_init, err: %d", nrfx_err);
    }

    // ...
    nrfx_saadc_channel_t saacd_channel_cfg[1] = {NRFX_SAADC_DEFAULT_CHANNEL_SE(0, 0)}; // AIN 0 and channel 1
    nrfx_saadc_adv_config_t saadc_adv_config = NRFX_SAADC_DEFAULT_ADV_CONFIG;

    nrfx_err = nrfx_saadc_channels_config(saacd_channel_cfg, 1);
    if (nrfx_err != NRFX_SUCCESS)
    {
        LOG_ERR("nrfx_saadc_channels_config, err: %d", nrfx_err);
    }

    nrfx_err = nrfx_saadc_advanced_mode_set(BIT(0), NRF_SAADC_RESOLUTION_12BIT, &saadc_adv_config, saadc_event_handler);
    if (nrfx_err != NRFX_SUCCESS)
    {
        LOG_ERR("nrfx_saadc_advanced_mode_set, err: %d", nrfx_err);
    }

    nrfx_err = nrfx_saadc_buffer_set(saadc_results_buffer, 100);

    LOG_INF("AFTER INIT SAADC");

The code crashed in nrfx_saadc_channels_config with:

ASSERTION FAIL [p_channels[i].pin_p] @ /home/comemaster/Synology-Drive/IRNAS-Users/tjaz/Nordic/ncs_v1.3.0/modules/hal/nordic/nrfx/drivers/src/nrfx_saadc.c:289
[00:00:00.224,060] <err> os: r0/a1:  0x00000004  r1/a2:  0x00000121  r2/a3:  0x00000001
[00:00:00.232,788] <err> os: r3/a4:  0x00000000 r12/ip:  0x00020000 r14/lr:  0x000383eb
[00:00:00.241,516] <err> os:  xpsr:  0x61000000
[00:00:00.246,765] <err> os: s[ 0]:  0x00000000  s[ 1]:  0x00000000  s[ 2]:  0x00000000  s[ 3]:  0x00000000
[00:00:00.257,263] <err> os: s[ 4]:  0x00000000  s[ 5]:  0x00000000  s[ 6]:  0x00000000  s[ 7]:  0x00000000
[00:00:00.267,761] <err> os: s[ 8]:  0x00000000  s[ 9]:  0x00000000  s[10]:  0x00000000  s[11]:  0x00000000
[00:00:00.278,228] <err> os: s[12]:  0x00000000  s[13]:  0x00000000  s[14]:  0x00000000  s[15]:  0x00000000
[00:00:00.288,726] <err> os: fpscr:  0x00039e39
[00:00:00.293,975] <err> os: Faulting instruction address (r15/pc): 0x0001f9c8

At the line specified there is an assert statement: NRFX_ASSERT(p_channels[i].pin_p);
So it seems like nrf_saadc_channel_init that is called before it does not set up the channel correctly.

How can I fix this?

Regards,
Tjaž

RE: ADC interupt based on SAADC limit monitoring or LPCOMP

Øyvind — Tue, 27 Oct 2020 15:46:14 GMT

And by the way, I just realized in regards to your last comment / error:

[quote user="Tjaz"]I get the following runtime error when the interrupt should happen (there are no compile errors or warnings):[/quote]

Have you configured SPM correctly?

RE: ADC interupt based on SAADC limit monitoring or LPCOMP

Øyvind — Tue, 27 Oct 2020 13:59:47 GMT

Hello ,

You need to use nrfx_saadc in continous mode to sample on an interval:

Continuous mode

Continuous sampling can be achieved by using the internal timer in the ADC, or triggering the SAMPLE task from one of the general purpose timers through the PPI system.

Care shall be taken to ensure that the sample rate fulfils the following criteria, depending on how many channels are active:

f_SAMPLE< 1/(t_ACQ + t_conv)

The SAMPLERATE register can be used as a local timer instead of triggering individual SAMPLE tasks. When SAMPLERATE.MODE is set to Timers, it is sufficient to trigger SAMPLE task only once in order to start the SAADC and triggering the STOP task will stop sampling. The SAMPLERATE.CC field controls the sample rate.

The SAMPLERATE timer mode cannot be combined with SCAN mode, and only one channel can be enabled in this mode.

A DONE event signals that one sample has been taken.

In this mode, the RESULTDONE event has the same meaning as DONE when no oversampling takes place. Note that both events may occur before the actual value has been transferred into RAM by EasyDMA.

/**
 * @brief Function for setting the SAADC driver in the advanced mode.
 *
 * The advanced mode allows performing double-buffered conversions of arbitrary length.
 * The conversions can be done in a blocking or non-blocking manner. When performing conversions
 * in the non-blocking manner and @ref nrfx_saadc_adv_config_t.internal_timer_cc is set to 0,
 * sampling needs to be done by triggering @ref NRF_SAADC_TASK_SAMPLE externally
 * (for example by using the TIMER and/or the PPI/DPPI).
 * When performing conversions in the non-blocking manner and @ref nrfx_saadc_adv_config_t.start_on_end
 * is false, the @ref NRF_SAADC_TASK_START needs to be triggered on @ref NRF_SAADC_EVENT_END
 * externally (for example by using the PPI/DPPI).
 * Sampling is initiated by calling @ref nrfx_saadc_mode_trigger(). In case of performing
 * conversions in the blocking manner, @ref nrfx_saadc_mode_trigger() may need to be called several
 * times as each call sample each requested channel once.
 *
 * @note The internal timer can only be used when a single input channel is enabled.
 * @note The internal timer can only be used in the non-blocking mode.
 *
 * @param[in] channel_mask  Bitmask of channels to be used in the advanced mode.
 * @param[in] resolution    Resolution configuration.
 * @param[in] p_config      Pointer to the structure with the advanced mode configuration.
 * @param[in] event_handler Event handler provided by the user. In case of providing NULL,
 *                          the conversion will be performed in the blocking manner.
 *
 * @retval NRFX_SUCCESS             Initialization was successful.
 * @retval NRFX_ERROR_BUSY          There is a conversion or calibration ongoing.
 * @retval NRFX_ERROR_INVALID_PARAM Attempt to activate channel that is not configured.
 * @retval NRFX_ERROR_NOT_SUPPORTED Attempt to activate internal timer or oversampling without burst
 *                                  with multiple channels enabled.
 */
nrfx_err_t nrfx_saadc_advanced_mode_set(uint32_t                        channel_mask,
                                        nrf_saadc_resolution_t          resolution,
                                        nrfx_saadc_adv_config_t const * p_config,
                                        nrfx_saadc_event_handler_t      event_handler);

[quote user="Tjaz"]It would be nice, as I have asked before, to get a working example of at lease each element on its own - so rtc configuration, adc configuration and dppi configuration to link them together[/quote]

Yes, unfortunately, there are very few samples available for this. Zephyr does have some samples available, e.g. nRF91 nrfx sample

Kind regards,

Øyvind

RE: ADC interupt based on SAADC limit monitoring or LPCOMP

Tjaz — Tue, 27 Oct 2020 08:27:56 GMT

Before configuring this "link" via DPPI, I have to get the rtc to work first tho...

Using nrfx_rtc.h and writing code as such:

prj.conf

CONFIG_NRFX_RTC0=y
CONFIG_NRFX_DPPI=y

main.c

#include <nrfx_saadc.h>
#include <nrfx_rtc.h>

#include <logging/log.h>
LOG_MODULE_REGISTER(main);

void rtc_handler(nrfx_rtc_int_type_t int_type)
{
    LOG_INF("RTC HANDLER");
}


void main(void)
{ 
    LOG_INF("INIT NRFX RTC");
    nrfx_rtc_t rtc_dev = NRFX_RTC_INSTANCE(0);
    // copy of default config
    nrfx_rtc_config_t rtc_conf = {
        .prescaler = RTC_FREQ_TO_PRESCALER(32768),
        .interrupt_priority = NRFX_RTC_DEFAULT_CONFIG_IRQ_PRIORITY,
        .tick_latency = NRFX_RTC_US_TO_TICKS(2000, 32768),
        .reliable = false,
    };
    nrfx_err_t nerr = nrfx_rtc_init(&rtc_dev, &rtc_conf, rtc_handler);
    if (nerr != NRFX_SUCCESS)
    {
        LOG_ERR("err: %d", nerr);
    }

    nrfx_rtc_cc_set(&rtc_dev,
                    0,
                    1000000,
                    true);

    nrfx_rtc_enable(&rtc_dev);
    
    LOG_INF("AFTER INIT NRFX RTC");

    // main goes to sleep;
    while (1)
    {
        k_sleep(K_SECONDS(3600));
    }
}

I get the following runtime error when the interrupt should happen (there are no compile errors or warnings):

<err> os: >>> ZEPHYR FATAL ERROR 1: Unhandled interrupt on CPU 0
<err> os: Current thread: 0x200238c8 (unknown)
<err> os: Halting system

How do I make zephyr aware of my interupt?

In the final set up, i will probably have to pass false as the last param to nrfx_rtc_cc_set, since I only want ADC to trigger an interupt. But If the adc interupt is configured only using the nrfx layer, wont a similar error occur?

Finaly, lets say I add this to the code, as you suggested, to set up DPPI:

    NRF_RTC0->PUBLISH_COMPARE[0] = (DPPI_PUB_CHIDX_Ch0) |
                                   (DPPI_PUB_EN_Msk);
    NRF_SAADC->SUBSCRIBE_START = (DPPI_SUB_CHIDX_Ch0) |
                                 (DPPI_SUB_EN_Msk);

    NRF_DPPIC->CHENSET = (DPPI_CHENSET_CH0_Set << DPPI_CHENSET_CH0_Pos);

This does not compile, with the following errors:

../src/main.c: In function 'main':
../src/main.c:311:37: error: 'DPPI_PUB_CHIDX_Ch0' undeclared (first use in this function)
     NRF_RTC0->PUBLISH_COMPARE[0] = (DPPI_PUB_CHIDX_Ch0) |
                                     ^~~~~~~~~~~~~~~~~~
../src/main.c:311:37: note: each undeclared identifier is reported only once for each function it appears in
../src/main.c:312:37: error: 'DPPI_PUB_EN_Msk' undeclared (first use in this function); did you mean 'DPPIC_CHG_CH2_Msk'?
                                    (DPPI_PUB_EN_Msk);
                                     ^~~~~~~~~~~~~~~
                                     DPPIC_CHG_CH2_Msk
../src/main.c:313:35: error: 'DPPI_SUB_CHIDX_Ch0' undeclared (first use in this function); did you mean 'DPPI_PUB_CHIDX_Ch0'?
     NRF_SAADC->SUBSCRIBE_START = (DPPI_SUB_CHIDX_Ch0) |
                                   ^~~~~~~~~~~~~~~~~~
                                   DPPI_PUB_CHIDX_Ch0
../src/main.c:314:35: error: 'DPPI_SUB_EN_Msk' undeclared (first use in this function); did you mean 'DPPI_PUB_EN_Msk'?
                                  (DPPI_SUB_EN_Msk);
                                   ^~~~~~~~~~~~~~~
                                   DPPI_PUB_EN_Msk
../src/main.c:316:27: error: 'DPPI_CHENSET_CH0_Set' undeclared (first use in this function); did you mean 'DPPIC_CHENSET_CH0_Set'?
     NRF_DPPIC->CHENSET = (DPPI_CHENSET_CH0_Set << DPPI_CHENSET_CH0_Pos);
                           ^~~~~~~~~~~~~~~~~~~~
                           DPPIC_CHENSET_CH0_Set
../src/main.c:316:51: error: 'DPPI_CHENSET_CH0_Pos' undeclared (first use in this function); did you mean 'DPPIC_CHENSET_CH0_Pos'?
     NRF_DPPIC->CHENSET = (DPPI_CHENSET_CH0_Set << DPPI_CHENSET_CH0_Pos);
                                                   ^~~~~~~~~~~~~~~~~~~~
                                                   DPPIC_CHENSET_CH0_Pos
ninja: build stopped: subcommand failed.
FATAL ERROR: command exited with status 1: /home/comemaster/.local/bin/cmake --build /home/comemaster/Synology-Drive/IRNAS-Users/tjaz/Nordic/ncs_v1.3.0/nrf/applications/saadc-test/build

Looking at nrf9160_bitfields.h I can see that some of these identifiers have changed (like DPPI_CHENSET_CH0_Set -> DPPIC_CHENSET_CH0_Set), while others I can not find at all (like DPPI_PUB_CHIDX_Ch0 or DPPI_PUB_EN_Msk).

It would be nice, as I have asked before, to get a working example of at lease each element on its own - so rtc configuration, adc configuration and dppi configuration to link them together

Regards,
Tjaž

RE: ADC interupt based on SAADC limit monitoring or LPCOMP

Øyvind — Tue, 20 Oct 2020 12:58:44 GMT

[quote user="Tjaz"]1. Is there a driver for setting RTC to trigger SAADC sampling on an interval?[/quote]

Yes, I believe the DPPI can be used for this purpose. Have a look here. Just change TIMER0 to RTC.

One-to-one connection

This example shows how to create a one-to-one connection between TIMER compare register and SAADC start task.

The channel configuration is set up first. TIMER0 will publish its COMPARE0 event on channel 0, and SAADC will subscribe its START task to events on the same channel. After that, the channel is enabled through the DPPIC.


NRF_TIMER0->PUBLISH_COMPARE0 = (DPPI_PUB_CHIDX_Ch0) | 
                               (DPPI_PUB_EN_Msk);
NRF_SAADC->SUBSCRIBE_START   = (DPPI_SUB_CHIDX_Ch0) | 
                               (DPPI_SUB_EN_Msk);
  
NRF_DPPIC->CHENSET = (DPPI_CHENSET_CH0_Set << DPPI_CHENSET_CH0_Pos);

[quote user="Tjaz"]2. Can I use this driver you linked in addition to my existing code, that uses zephyrs driver (#include <drivers/adc.h>)? Or will using nrfx_saadc.h directly mess up things that I configure with adc.h?[/quote]

The Zephyr ADC (zephyr\include\drivers\adc.h-->zephyr\drivers\adc\adc_nrfx_saadc.c) uses the functions from hal/nrf_saadc.h. If you configure stuff on the lowest level first (nrf_saadc.h.) the Zephyr layer will not know about it. I would recommend sticking to one layer. But if you know what you're doing, I think it should be possible to mix them

RE: ADC interupt based on SAADC limit monitoring or LPCOMP

Tjaz — Mon, 19 Oct 2020 09:26:26 GMT

Thank you for the link.

I have some further questions:

1. Is there a driver for setting RTC to trigger SAADC sampling on an interval?

2. Can I use this driver you linked in addition to my existing code, that uses zephyrs driver (#include <drivers/adc.h>)? Or will using nrfx_saadc.h directly mess up things that I configure with adc.h?

Regards,
Tjaž

RE: ADC interupt based on SAADC limit monitoring or LPCOMP

Øyvind — Mon, 12 Oct 2020 13:31:23 GMT

[quote user=""]Reading this thread:
https://devzone.nordicsemi.com/f/nordic-q-a/20895/saadc-low-power-scan-mode[/quote]

Note that this is a 4 year old answer which is not related to nRF Connect SDK.

[quote user="Tjaz"]Regardless of the wrong links, the question remains the same: how to register a handler to run when adc sample is "out of range", and to consume as little power as possible?[/quote]

There is currently no API for this in Zephyr, but you can use the nrfx saadc driver directly (modules\hal\nordic\nrfx\drivers\include\nrfx_saadc.h)

/**
 * @brief Function for setting the SAADC channel limits.
 *
 * When limits are enabled and the conversion result exceeds the defined bounds,
 * the handler function is called with the corresponding event as parameter.
 *
 * @note Before the limits are set, the driver operation mode (simple or advanced) has
 *       to be configured. Only non-blocking conversions can be monitored.
 *
 * @note Changing of the driver operation mode disables all configured limits.
 *
 * @param[in] channel    Channel index.
 * @param[in] limit_low  Limit low value to generate interrupt. Use @c INT16_MIN
 *                       to disable interrupt generation.
 * @param[in] limit_high Limit high value to generate interrupt. Use @c INT16_MAX
 *                       to disable interrupt generation.
 *
 * @retval NRFX_SUCCESS             Requested channel limits were set.
 * @retval NRFX_ERROR_INVALID_PARAM Attempt to activate the limits on disabled channel.
 * @retval NRFX_ERROR_FORBIDDEN     Attempt to activate the limits for blocking conversions.
 * @retval NRFX_ERROR_INVALID_STATE Attempt to activate the limits without configured mode.
 */
nrfx_err_t nrfx_saadc_limits_set(uint8_t channel, int16_t limit_low, int16_t limit_high);

RE: ADC interupt based on SAADC limit monitoring or LPCOMP

Tjaz — Wed, 07 Oct 2020 12:19:10 GMT

Yes, sorry.

We are trying to do this using nrf9160.

The docs are these:
https://infocenter.nordicsemi.com/index.jsp?topic=%2Fps_nrf9160%2Fsaadc.html&cp=2_0_0_5_11_8&anchor=saadc_limits

Regardless of the wrong links, the question remains the same: how to register a handler to run when adc sample is "out of range", and to consume as little power as possible?

If this can not be done through zephyrs APIs, is it possible in some other way?

RE: ADC interupt based on SAADC limit monitoring or LPCOMP

Øyvind — Wed, 07 Oct 2020 12:15:45 GMT

Hello,

There are some ADC samples in Zephyr e.g. Battery Voltage Measurement. Unfortunately, there are very few for ADC.

You are referring to nRF52840 documentation, while the DevZone tags show nRF9160. Can you please elaborate?

Kind regards,
Øyvind