Configuring SAADC on NRF9160 using the lower level driver instead of Zephyr

[matt.heins]

I've gotten the SAADC working in a blocking fashion and been able to evaluate sample times. Now, I'd like to set it up to automatically read three inputs in a row to see how fast I can get three reads in a row. Something isn't right. I don't ever see the callback function getting called. I know that I'm calling the nrfx_saadc_sample() function as I see my debug output. 

/*
 * Copyright (c) 2018 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-BSD-5-Clause-Nordic
 */

#include <gpio.h>
#include <net/socket.h>
#include <nrf9160.h>
#include <stdio.h>
#include <string.h>
#include <uart.h>
#include <adc.h>
#include <zephyr.h>
#include <nrfx.h>
#include <nrfx_saadc.h>
#include <misc/printk.h>
//#include <hal/nrf_saadc.h>
//#include <nrfx_dppi.h> 


struct device *gpio_dev;

#define SAADC_DEFAULT_CONFIG                                               \
{                                                                               \
    .resolution         = (nrf_saadc_resolution_t)NRFX_SAADC_CONFIG_RESOLUTION, \
    .oversample         = (nrf_saadc_oversample_t)NRFX_SAADC_CONFIG_OVERSAMPLE, \
    .interrupt_priority = NRFX_SAADC_CONFIG_IRQ_PRIORITY,                       \
    .low_power_mode     = NRFX_SAADC_CONFIG_LP_MODE                             \
}

#define SAADC_DEFAULT_CHANNEL_CONFIG_SE(PIN_P) \
{                                                   \
    .resistor_p = NRF_SAADC_RESISTOR_DISABLED,      \
    .resistor_n = NRF_SAADC_RESISTOR_DISABLED,      \
    .gain       = NRF_SAADC_GAIN1_6,                \
    .reference  = NRF_SAADC_REFERENCE_INTERNAL,     \
    .acq_time   = NRF_SAADC_ACQTIME_3US,           \
    .mode       = NRF_SAADC_MODE_SINGLE_ENDED,      \
    .burst      = NRF_SAADC_BURST_DISABLED,         \
    .pin_p      = (nrf_saadc_input_t)(PIN_P),       \
    .pin_n      = NRF_SAADC_INPUT_DISABLED          \
}

nrf_saadc_channel_config_t saadc_channel_config_1 = SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN0);
nrf_saadc_channel_config_t saadc_channel_config_2 = SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN1);
nrf_saadc_channel_config_t saadc_channel_config_3 = SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN2);
static bool adcCalibrateDone;


#define BUFFER_SIZE 3
static nrf_saadc_value_t m_sample_buffer[BUFFER_SIZE];

static void saadc_callback(nrfx_saadc_evt_t const * p_event){

    if ( p_event->type == NRFX_SAADC_EVT_DONE )
    {
      gpio_pin_write(gpio_dev, 10, 0);
       printk("ADC raw value: %d\n", m_sample_buffer[0]);
    }
    else if( p_event->type == NRFX_SAADC_EVT_CALIBRATEDONE )
    {
      adcCalibrateDone = true;
    }
}

void adc_module_init(void)
{
    nrfx_err_t err_code;
    nrfx_saadc_config_t drv_saadc_cfg = SAADC_DEFAULT_CONFIG;
		
    err_code = nrfx_saadc_init( &drv_saadc_cfg, saadc_callback );
    if(err_code != NRFX_SUCCESS){
        //Blah error
    }

    err_code = nrfx_saadc_channel_init(0, &saadc_channel_config_1);
    err_code = nrfx_saadc_channel_init(1, &saadc_channel_config_2);
    err_code = nrfx_saadc_channel_init(2, &saadc_channel_config_3);
	
}

static int adc_sample_blocking(void)
{
	int ret;

        gpio_pin_write(gpio_dev, 10, 1);
	ret = nrfx_saadc_sample_convert(0, m_sample_buffer);
        ret = nrfx_saadc_sample_convert(1, m_sample_buffer);
        ret = nrfx_saadc_sample_convert(2, m_sample_buffer);
        gpio_pin_write(gpio_dev, 10, 0);

        if (ret != NRFX_SUCCESS) {
          printk("Error in adc sampling: %d\n", ret);
        }

	/* Print the AIN0 values */
	for (int i = 0; i < BUFFER_SIZE; i++) {
		float adc_voltage = 0;
		adc_voltage = (float)(((float)m_sample_buffer[i] / 1023.0f) *
				      3600.0f);
		printk("ADC raw value: %d\n", m_sample_buffer[i]);
		printf("Measured voltage: %f mV\n", adc_voltage);
	}

	return ret;
}


static int adc_sample_nonblocking(void)
{
	int ret;

        gpio_pin_write(gpio_dev, 10, 1);
        nrfx_saadc_buffer_convert(m_sample_buffer, 3);
        ret = nrfx_saadc_sample();

        if(ret == NRFX_SUCCESS){
          printk("Sampling Triggered!\n");
        }

        return ret;

}

int main(void)
{
	nrfx_err_t err;

	printk("nrf91 saadc sampling AIN0 (P0.13)\n");
	printk("Example requires secure_boot to have ");
	printk("SAADC set to non-secure!\n");
	printk("If not; BusFault/UsageFault will be triggered\n");

        gpio_dev = device_get_binding(DT_GPIO_P0_DEV_NAME);

        if (!gpio_dev) {
		printk("Cannot bind gpio device");
		return -ENODEV;
	}

        err = gpio_pin_configure(gpio_dev, 10, GPIO_DIR_OUT);//Set pin 0 to output

        adc_module_init();
    

	while (1) {

          //adc_sample_blocking();
          adc_sample_nonblocking();
          
          k_sleep(500);

	}
}

[Håkon Alseth]

Hi,

 

There are missing components in the integration of nrfx directly into NCS, which we are working on solving. One of these is the interrupt handling. Since there's an RTOS running in the background, we cannot use the NVIC functions directly, so we'll have to declare the interrupt vector for the SAADC in a specific way, similar to what is done here for the PDM (see the last section of that answer):

https://devzone.nordicsemi.com/f/nordic-q-a/50656/using-pdm-mic-on-nrf9160dk/204715#204715

 

You have to do the same with the SAADC IRQHandler when using it in non-blocking mode using nrfx directly:

ISR_DIRECT_DECLARE(adc_isr_handler)
{
    nrfx_saadc_irq_handler();
    ISR_DIRECT_PM();
    
    return 1;
}

void main(void)
{
    IRQ_DIRECT_CONNECT(SAADC_IRQn, 0,
    adc_isr_handler, 0);
    /* Rest of main */

 

We are looking into how to do this in a more streamlined way.

 

Kind regards,

Håkon

[Marciano-PL]

Hello Hakon!

I am facing the same problem, but on the nRF5340. When I attempt this solution, I get a compiler error

conflicting types for saadc_handler

as it follows the signature of 

typedef void (* nrfx_saadc_event_handler_t)(nrfx_saadc_evt_t const * p_event);

instead of

__attribute__ ((interrupt ("IRQ"))) void name(void)

How should I write my handler to compensate for the differences in the implementation method you provided above and still be able to have the same functionality?

[Håkon Alseth]

Hi,

 

Sorry for the late answer.

 

saadc_handler, is that in your main.c? How is that implemented? It should be "void saadc_handler(nrfx_saadc_evt_t const * p_event)".

The code posted in my former answer should add the interrupt through zephyr's APIs, but could it be that the nrfx_saadc needs to be enabled using a preprocessor flag?

Could you try appending this to your prj.conf?

CONFIG_COMPILER_OPT="-DNRFX_SAADC_ENABLED=1"

 

Kind regards,

Håkon

[Marciano-PL]

I misunderstood your answer! It worked perfectly for me. I hadn't realized that your proposed solution enabled me to use the original nrfx_saadc_event_handler_t the way the api intended. I thought I had to do it differently. Thanks for the help!