RE: ADC on multiple pins with PPI - nRF52832

helsing — Tue, 05 Nov 2024 09:06:29 GMT

It sounds strange that the this change should impact debugging/stepping through the code. As far as I know, the timer is not used in SW, it only runs in HW and DPPI is used for trigging SAADC samploing. Would you be able to provide some more context regarding how you are debugging?

[quote user="jablackann"]the debugger/IDE would seem to get stuck and not be able to step through the code. [/quote]

Could you please share some more details from this situation?

RE: ADC on multiple pins with PPI - nRF52832

jablackann — Fri, 01 Nov 2024 13:48:31 GMT

I did find that if I used a value of

#define SAADC_SAMPLE_INTERVAL_US 50

and I tried to breakpoint and step through the code (using Ozone) that the debugger/IDE would seem to get stuck and not be able to step through the code.

Using a value of

#define SAADC_SAMPLE_INTERVAL_US 500

seemed to work much better for being able to step through the code while debugging.

This will definitely change how often the device processes the A to D pins but I willing to set it slower while I do my development.

Any insight into why this would make debugging problematic?

RE: ADC on multiple pins with PPI - nRF52832

helsing — Fri, 01 Nov 2024 12:26:12 GMT

By the way, it looks like you are using a 50μs sample interval. If T_ACQ is low enough it should be fine but one cannot trigger sampling more often than N_channels*(T_ACQ+T_CONV). It looks like 10μs is default for ADC_ACQ_TIME_DEFAULT, so it should be just enough with 50μs for 4 channels. Thought it might be good to be aware of this.
https://github.com/nrfconnect/sdk-zephyr/blob/25f14b4f8ecba7423f39ead3c117c0d86a096c5b/drivers/adc/adc_nrfx_saadc.c#L130-L133

RE: ADC on multiple pins with PPI - nRF52832

helsing — Fri, 01 Nov 2024 12:02:02 GMT

Looks like it is working now. Thank you for posting the code!

RE: ADC on multiple pins with PPI - nRF52832

jablackann — Thu, 31 Oct 2024 15:15:23 GMT

I took inspiration from this related post.

Sampling ADC with PPI and Timer on nrf connect sdk

In my application, I wanted to monitor AN2, AN3, AN5, and AN6.

Above is the modifications that I made. I have placed my code on here as well. At the bottom of the application is the previous way the device was calculating using a method of just capturing one reading at a time for each of the analog pins the circuit was using.

devzone.nordicsemi.com/.../a_5F00_to_5F00_d.c devzone.nordicsemi.com/.../a_5F00_to_5F00_d.h

Screenshot of the output via terminal.

static nrfx_saadc_channel_t m_multiple_channels[] =
{
    NRFX_SAADC_DEFAULT_CHANNEL_SE(NRF_SAADC_INPUT_AIN2, 0),
    NRFX_SAADC_DEFAULT_CHANNEL_SE(NRF_SAADC_INPUT_AIN3, 1),
    NRFX_SAADC_DEFAULT_CHANNEL_SE(NRF_SAADC_INPUT_AIN5, 2),
    NRFX_SAADC_DEFAULT_CHANNEL_SE(NRF_SAADC_INPUT_AIN6, 3)
};
static void configure_saadc(void)
{
    nrfx_err_t err;

    /* STEP 4.4 - Connect ADC interrupt to nrfx interrupt handler */
    IRQ_CONNECT(DT_IRQN(DT_NODELABEL(adc)),
                DT_IRQ(DT_NODELABEL(adc), priority),
                nrfx_isr, nrfx_saadc_irq_handler, 0);
    
    /* STEP 4.5 - Initialize the nrfx_SAADC driver */
    err = nrfx_saadc_init(DT_IRQ(DT_NODELABEL(adc), priority));
    if(err != NRFX_SUCCESS)
    {
        printk("nrfx_saadc_init error\r\n");
        // LOG_ERR("nrfx_saadc_init error: %08x", err);
        return;
    }

    /* STEP 4.6 - Declare the struct to hold the configuration for the SAADC channel used to sample the battery voltage */
    // nrfx_saadc_channel_t channel_2 = NRFX_SAADC_DEFAULT_CHANNEL_SE(NRF_SAADC_INPUT_AIN2, 0);
    // nrfx_saadc_channel_t channel_3 = NRFX_SAADC_DEFAULT_CHANNEL_SE(NRF_SAADC_INPUT_AIN3, 0);

#define NRFX_SAADC_CHANNEL_COUNT 4

    /* STEP 4.7 - Change gain config in default config and apply channel configuration */
    /* for my application the max that can be applied to an input is 3.3V*/
    m_multiple_channels[0].channel_config.gain = NRF_SAADC_GAIN1_5;
    m_multiple_channels[1].channel_config.gain = NRF_SAADC_GAIN1_5;
    m_multiple_channels[2].channel_config.gain = NRF_SAADC_GAIN1_5;
    m_multiple_channels[3].channel_config.gain = NRF_SAADC_GAIN1_5;
 
    nrfx_saadc_channels_config(m_multiple_channels,NRFX_SAADC_CHANNEL_COUNT);
    if(err != NRFX_SUCCESS)
    {
        printk("nrfx_saadc_channels_config error\r\n");
        // LOG_ERR("nrfx_saadc_channels_config error: %08x", err);
        return; 
    }

    uint32_t channels_mask = nrfx_saadc_channels_configured_get();

    /* STEP 4.8 - Configure channel 0 in advanced mode with event handler (non-blocking mode) */
    nrfx_saadc_adv_config_t saadc_adv_config = NRFX_SAADC_DEFAULT_ADV_CONFIG;
    err = nrfx_saadc_advanced_mode_set(channels_mask, 
                                        NRF_SAADC_RESOLUTION_12BIT,
                                        &saadc_adv_config, 
                                        saadc_event_handler);
    if(err != NRFX_SUCCESS)
    {
        printk("nrfx_saadc_advanced_mode_set error %08x\r\n", err);
        // LOG_ERR("nrfx_saadc_advanced_mode_set error: %08x", err);
        return;
    }
                                            
    /* STEP 4.9 - Configure two buffers to make use of double-buffering feature of SAADC */
    err  = nrfx_saadc_buffer_set(saadc_sample_buffer[0], SAADC_BUFFER_SIZE);
    if(err != NRFX_SUCCESS)
    {
        printk("nrfx_saadc_buffer_set error %08x\r\n", err);
        // LOG_ERR("nrfx_saadc_buffer_set error %08x", err);
        return;
    }

    err  = nrfx_saadc_buffer_set(saadc_sample_buffer[1], SAADC_BUFFER_SIZE);
    if(err != NRFX_SUCCESS)
    {
        printk("nrfx_saadc_buffer_set error %08x\r\n", err);
        // LOG_ERR("nrfx_saadc_buffer_set error %08x", err);
        return;
    }

    /* STEP 4.10 - Trigger the SAADC. This will not start sampling, but will prepare buffer for sampling triggered through PPI */
    err = nrfx_saadc_mode_trigger();
    if(err != NRFX_SUCCESS)
    {
        printk("nrfx_saadc_mode_trigger error %08x\r\n", err);
        // LOG_ERR("nrfx_saadc_mode_trigger error: %08x", err);
        return; 
    }

}
static void saadc_event_handler(nrfx_saadc_evt_t const * p_event)
{
    nrfx_err_t err;
    switch (p_event->type)
    {
        case NRFX_SAADC_EVT_READY:
        
           /* STEP 5.1 - Buffer is ready, timer (and sampling) can be started. */
            nrfx_timer_enable(&timer_instance);

            break;                        
            
        case NRFX_SAADC_EVT_BUF_REQ:
        
            /* STEP 5.2 - Set up the next available buffer. Alternate between buffer 0 and 1 */
            err = nrfx_saadc_buffer_set(saadc_sample_buffer[(saadc_current_buffer++)%2], SAADC_BUFFER_SIZE);
            if(err != NRFX_SUCCESS)
            {
                printk("nrf_saadc_buffer_set error %08x\r\n", err);
                // LOG_ERR("nrf_saadc_buffer_set error: %08x", err);
                return;
            }
            break;

        case NRFX_SAADC_EVT_DONE:

            /* STEP 5.3 - Buffer has been filled. Do something with the data and proceed */
            int64_t average_AN2 = 0;
            int16_t max_AN2 = INT16_MIN;
            int16_t min_AN2 = INT16_MAX; 
            int16_t current_value;

            int64_t average_AN3 = 0;
            int16_t max_AN3 = INT16_MIN;
            int16_t min_AN3 = INT16_MAX; 

            int64_t average_AN5 = 0;
            int16_t max_AN5 = INT16_MIN;
            int16_t min_AN5 = INT16_MAX; 

            int64_t average_AN6 = 0;
            int16_t max_AN6 = INT16_MIN;
            int16_t min_AN6 = INT16_MAX; 
            
            for(int i = 0; i < p_event->data.done.size;i++)
            {
                current_value = ((int16_t *)(p_event->data.done.p_buffer))[i];
                average_AN2 += current_value;
                if(current_value > max_AN2)
                {
                    max_AN2 = current_value;
                }
                if(current_value < min_AN2)
                {
                    min_AN2 = current_value;
                }

                i++;
                current_value = ((int16_t *)(p_event->data.done.p_buffer))[i];
                average_AN3 += current_value;
                if(current_value > max_AN3)
                {
                    max_AN3 = current_value;
                }
                if(current_value < min_AN3)
                {
                    min_AN3 = current_value;
                }

                i++;
                current_value = ((int16_t *)(p_event->data.done.p_buffer))[i];
                average_AN5 += current_value;
                if(current_value > max_AN5)
                {
                    max_AN5 = current_value;
                }
                if(current_value < min_AN5)
                {
                    min_AN5 = current_value;
                }

                i++;
                current_value = ((int16_t *)(p_event->data.done.p_buffer))[i];
                average_AN6 += current_value;
                if(current_value > max_AN6)
                {
                    max_AN6 = current_value;
                }
                if(current_value < min_AN6)
                {
                    min_AN6 = current_value;
                }
            }
            average_AN2 = average_AN2 /(p_event->data.done.size /4);

            average_AN3 = average_AN3 /(p_event->data.done.size / 4);

            average_AN5 = average_AN5 /(p_event->data.done.size / 4);

            average_AN6 = average_AN6 /(p_event->data.done.size / 4);
        
            // LOG_INF("SAADC buffer at 0x%x filled with %d samples", (uint32_t)p_event->data.done.p_buffer, p_event->data.done.size);
            // LOG_INF("AVG=%d, MIN=%d, MAX=%d", (int16_t)average, min, max);
            //printk("SAADC buffer at 0x%x filled with %d samples\r\n", (uint32_t)p_event->data.done.p_buffer, p_event->data.done.size);
            printk("AVG_AN2=%d, MIN_AN2=%d, MAX_AN2=%d\t", (int16_t)average_AN2, min_AN2, max_AN2);

            printk("AVG_AN3=%d, MIN_AN3=%d, MAX_AN3=%d\t", (int16_t)average_AN3, min_AN3, max_AN3);

            printk("AVG_AN5=%d, MIN_AN5=%d, MAX_AN5=%d\t", (int16_t)average_AN5, min_AN5, max_AN5);

            printk("AVG_AN6=%d, MIN_AN6=%d, MAX_AN6=%d\r\n", (int16_t)average_AN6, min_AN6, max_AN6);

            break;

        default:
            // LOG_INF("Unhandled SAADC evt %d", p_event->type);
            printk("Unhandled SAADC evt %d", p_event->type);
            break;
    }
}

RE: ADC on multiple pins with PPI - nRF52832

helsing — Thu, 31 Oct 2024 14:05:58 GMT

Hi jablackann,

One thing I have spotted so far is that you should probably put it like this instead:

nrfx_saadc_channel_t channel_2 = NRFX_SAADC_DEFAULT_CHANNEL_SE(NRF_SAADC_INPUT_AIN2, 0);
nrfx_saadc_channel_t channel_3 = NRFX_SAADC_DEFAULT_CHANNEL_SE(NRF_SAADC_INPUT_AIN3, 1);

Each channel shoud have a unique index number.

Just letting you know we have started working on this. I will get back to you when I have had a closer look.