SAADC scan mode of 3 channels --> buffer order swap

RE: SAADC scan mode of 3 channels --> buffer order swap

Jørgen Holmefjord — Fri, 13 Sep 2019 15:22:55 GMT

Why do you trigger the START task in main after calibration? This should be done by nrf_drv_saadc_buffer_convert() in the CALIBRATEDONE event in the handler, so there should be no need to trigger this manually. You should also be able to restart the PPI/sampling event from the callback, after setting up the new buffers.

RE: SAADC scan mode of 3 channels --> buffer order swap

Manuel55 — Thu, 22 Aug 2019 07:18:20 GMT

Hi Jorgen,

Sorry for the late answer. I have now implemented your suggestion and here is my new code:

PPI:

void saadc_sampling_event_init(void)
{
    ret_code_t err_code;

    err_code = nrf_drv_ppi_init();
    APP_ERROR_CHECK(err_code);

    uint32_t rtc_compare_event_addr = nrf_drv_rtc_event_address_get(&rtc, NRF_RTC_EVENT_COMPARE_0);//nrf_drv_timer_compare_event_address_get(&m_timer, NRF_TIMER_CC_CHANNEL0);
    uint32_t saadc_sample_task_addr   = nrf_drv_saadc_sample_task_get();

    /* setup ppi channel so that timer compare event is triggering sample task in SAADC */
    err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel_1);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_ppi_channel_assign(m_ppi_channel_1,
                                          rtc_compare_event_addr,
                                          saadc_sample_task_addr);
																					
    APP_ERROR_CHECK(err_code);
}

SAADC:

#define SAMPLES_IN_BUFFER 10
#define ADC_CHANNEL_COUNT 3

void saadc_sampling_event_enable(void)
{
    ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel_1);

    APP_ERROR_CHECK(err_code);
	
	nrf_drv_rtc_counter_clear(&rtc);
	//reactivate compare irq! 
	nrf_drv_rtc_cc_set(&rtc,0,COMPARE_COUNTERTIME * 8,true);
}

void saadc_sampling_event_disable(void)
{
    ret_code_t err_code = nrf_drv_ppi_channel_disable(m_ppi_channel_1);

    APP_ERROR_CHECK(err_code);
}


void saadc_callback(nrf_drv_saadc_evt_t const * p_event)
{
	int value = 0;
	int i;
	ret_code_t err_code;

    if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {
		nrf_gpio_pin_toggle(LED);
		
		if((m_adc_evt_counter % SAADC_CALIBRATION_INTERVAL) == 0)       //Evaluate if offset calibration should be performed. Configure the SAADC_CALIBRATION_INTERVAL constant to change the calibration frequency
        {
            nrf_drv_saadc_abort();                                      // Abort all ongoing conversions. Calibration cannot be run if SAADC is busy
            m_saadc_calibrate = true;                                   // Set flag to trigger calibration in main context when SAADC is stopped
        }
    
        NRF_LOG_INFO("ADC event number: %d", (int)m_adc_evt_counter);
			
		for (i = 0; i < ADC_CHANNEL_COUNT; i++)
		{
			//NRF_LOG_INFO("%d", p_event->data.done.p_buffer[i]);
			switch(i%4)
			{

				case 0: thermistor_1_sum = p_event->data.done.p_buffer[i];
								break;
				case 1: thermistor_2_sum = p_event->data.done.p_buffer[i];
								break;	
				case 2: battery_voltage_sum = p_event->data.done.p_buffer[i];
								break;	
			}
		}
						
		if(m_saadc_calibrate == false)
        {
            err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, ADC_CHANNEL_COUNT); //Set buffer so the SAADC can write to it again. This is either "buffer 1" or "buffer 2"
			APP_ERROR_CHECK(err_code);
			
			measDone = 1;
        }
		
		m_adc_evt_counter++;
		
		nrf_gpio_pin_clear(THERMISTOR_VREF);
    }
	
	else if (p_event->type == NRF_DRV_SAADC_EVT_CALIBRATEDONE)
    {
		nrf_saadc_task_trigger(NRF_SAADC_TASK_STOP);
		while(NRF_SAADC->EVENTS_STOPPED == 0);
		NRF_SAADC->EVENTS_STOPPED = 0;
		
        err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[0], ADC_CHANNEL_COUNT);             //Set buffer so the SAADC can write to it again. 
        APP_ERROR_CHECK(err_code);
        err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[1], ADC_CHANNEL_COUNT);             //Need to setup both buffers, as they were both removed with the call to nrf_drv_saadc_abort before calibration.
        APP_ERROR_CHECK(err_code);
    
        NRF_LOG_INFO("SAADC calibration complete !");                                              //Print on UART    

		battery_voltage_sum = 0;
		voltage_sum = 0;
		thermistor_1_sum = 0;
		thermistor_2_sum = 0;			
    }
}

void saadc_init(void)
{
    ret_code_t err_code;
    
    //Configure SAADC
    nrf_drv_saadc_config_t  config = NRF_DRV_SAADC_DEFAULT_CONFIG;
    config.resolution = NRF_SAADC_RESOLUTION_14BIT;  
    config.oversample = SAADC_OVERSAMPLE_OVERSAMPLE_Over256x;
    //config.low_power_mode = true; 
    
    //Initialize SAADC
    err_code = nrf_drv_saadc_init(&config, saadc_callback);                       
    APP_ERROR_CHECK(err_code);
    
    //Configure SAADC channel 0
    nrf_saadc_channel_config_t channel_config = NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN7);
    channel_config.gain = NRF_SAADC_GAIN1_4;
    channel_config.acq_time = SAADC_CH_CONFIG_TACQ_3us; //needed for maximum source resistance of 800kOhm (Datasheet) --> 40us. With additional C --> 3us
    channel_config.burst = NRF_SAADC_BURST_ENABLED;
                                        
    //Initialize SAADC channel 0
    err_code = nrf_drv_saadc_channel_init(2, &channel_config);
    APP_ERROR_CHECK(err_code);
    
    //Configure SAADC channel 1
    channel_config.pin_p = NRF_SAADC_INPUT_AIN0;
    channel_config.reference = NRF_SAADC_REFERENCE_VDD4;
    channel_config.gain = NRF_SAADC_GAIN1_4;
    channel_config.acq_time = SAADC_CH_CONFIG_TACQ_40us;
    channel_config.burst = NRF_SAADC_BURST_ENABLED;
    
    //Initialize SAADC channel 1
    err_code = nrf_drv_saadc_channel_init(0, &channel_config);
    APP_ERROR_CHECK(err_code);
    
    //Configure SAADC channel 2
    channel_config.pin_p = NRF_SAADC_INPUT_AIN1;
    channel_config.acq_time = SAADC_CH_CONFIG_TACQ_40us;
    
    //Initialize SAADC channel 2
    err_code = nrf_drv_saadc_channel_init(1, &channel_config);
    APP_ERROR_CHECK(err_code);
    
    //Set SAADC buffer 1. The SAADC will start to write to this buffer
    err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[0], ADC_CHANNEL_COUNT);
    APP_ERROR_CHECK(err_code);
    
    //Set SAADC buffer 2. The SAADC will write to this buffer when buffer 1 is full. This will give the applicaiton time to process data in buffer 1.
    err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[1], ADC_CHANNEL_COUNT);
    APP_ERROR_CHECK(err_code);
}

RTC:

static void rtc_handler(nrf_drv_rtc_int_type_t int_type)
{
    if (int_type == NRF_DRV_RTC_INT_COMPARE0)
    {
		nrf_gpio_pin_set(THERMISTOR_VREF);
        //nrf_gpio_pin_toggle(LED);
		nrf_drv_rtc_counter_clear(&rtc);
		//reactivate compare irq! 
		nrf_drv_rtc_cc_set(&rtc,0,COMPARE_COUNTERTIME * 8,true);
    }
		
    else if (int_type == NRF_DRV_RTC_INT_TICK)
    {
        rtcCounter++;
    }	
}


static void lfclk_config(void)
{
    ret_code_t err_code = nrf_drv_clock_init();
    APP_ERROR_CHECK(err_code);

    nrf_drv_clock_lfclk_request(NULL);
}


static void rtc_config(void)
{
	uint32_t err_code;

	//Initialize RTC instance
	nrf_drv_rtc_config_t config = NRF_DRV_RTC_DEFAULT_CONFIG;
	config.prescaler = 4095; // fRTC [kHz] = 32.768 / (PRESCALER + 1 ) --> 8Hz (minimum because prescsaler is 12bit)
	err_code = nrf_drv_rtc_init(&rtc, &config, rtc_handler);
	APP_ERROR_CHECK(err_code);

	//Enable tick event & interrupt
	nrf_drv_rtc_tick_enable(&rtc,true);

	//Set compare channel 0 to trigger interrupt after COMPARE_COUNTERTIME seconds
	err_code = nrf_drv_rtc_cc_set(&rtc,0,COMPARE_COUNTERTIME * 8,true); //1Hz
	APP_ERROR_CHECK(err_code);

	//Power on RTC instance
	nrf_drv_rtc_enable(&rtc);
}

void timer_handler(nrf_timer_event_t event_type, void * p_context)
{

}

Main:

int main(void)
{
	/* Configure board. */
    bsp_board_init(BSP_INIT_LEDS);
	bsp_board_leds_on();
	bsp_board_init(BSP_INIT_BUTTONS);

    APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
    NRF_LOG_DEFAULT_BACKENDS_INIT();
	
	NRF_POWER->DCDCEN = 1;	//Enabling the DCDC converter for lower current consumption
	
	lfclk_config();
	rtc_config();
	
	nrf_gpio_cfg_output(THERMISTOR_VREF);
	nrf_gpio_pin_set(THERMISTOR_VREF);
		
    saadc_init();
	saadc_sampling_event_init();
    saadc_sampling_event_enable();
		
	while(1)
    {
        if(m_saadc_calibrate == true)
		{
			// Disable the PPI triggering of the sample task
			saadc_sampling_event_disable();

			while(nrf_drv_saadc_calibrate_offset() != NRF_SUCCESS); //Trigger calibration task
			while(!NRF_SAADC->EVENTS_CALIBRATEDONE);
			NRF_SAADC->EVENTS_CALIBRATEDONE = 0;
			
			NRF_SAADC->EVENTS_STARTED = 0;
			NRF_SAADC->TASKS_START = 1;
			while(!NRF_SAADC->EVENTS_STARTED);
			NRF_SAADC->EVENTS_STARTED = 0;
			
			// Enable the PPI triggering of the sample task
			saadc_sampling_event_enable();

			m_saadc_calibrate = false;
		}
		
        if(measDone == 1)
        {
            //LOG VALUES
        }

Indeed it works much better now! But still, in the first measurement after a calibration, there is a false value in the first buffer index. Here is the RTT output (error is marked yellow):

I am still not able to solve this problem...

Thank you and best regards,
Manuel

RE: SAADC scan mode of 3 channels --> buffer order swap

Jørgen Holmefjord — Wed, 31 Jul 2019 16:55:04 GMT

Hi,

I checked over your code and found an issue with how you trigger the tasks.

You need to write '1' to the tasks in order to trigger the task. In your code you do this:

NRF_SAADC->TASKS_START;

While you should do this:

NRF_SAADC->TASKS_START = 1;

I see that this is what Håkon posted below as well.

Effectively, the workaround is in implemented, and you will get stuck waiting for events that will never arrive.

Best regards,
Jørgen

RE: SAADC scan mode of 3 channels --> buffer order swap

Manuel55 — Tue, 02 Jul 2019 10:39:42 GMT

Thanks haakonsh. But this is intended. I'm using oversampling on three channels. Therfore I will have three values (each is an average of 256 samples) in the buffer after DONE event.

I also found this: https://devzone.nordicsemi.com/f/nordic-q-a/48462/questions-on-saadc-calibration-gain-best-use

Same code as I have except that I have three channels and I'm using higher oversampling. But it is still not working.

My console output:

Event number 6 is the calibration measurement which is always the same three values? Is this normal? And after this, the values start jumping.

RE: SAADC scan mode of 3 channels --> buffer order swap

haakonsh — Tue, 02 Jul 2019 10:25:01 GMT

Well I see one potential issue in your code:

you call nrf_drv_saadc_buffer_convert(m_buffer_pool[0], ADC_CHANNEL_COUNT), where you probably want to use SAMPLES_IN_BUFFER instead of ADC_CHANNEL_COUNT as the size of your buffers.

RE: SAADC scan mode of 3 channels --> buffer order swap

Manuel55 — Tue, 02 Jul 2019 06:22:24 GMT

Unfortunately it starts to be very urgent. Any other ideas or suggestions?

Thank you!

RE: SAADC scan mode of 3 channels --> buffer order swap

Manuel55 — Fri, 28 Jun 2019 15:08:00 GMT

Could you please point out the difference to my code? I also prepare the next buffer as soon as the calibration interrupt has occured. In the exampe, the RTC frequency is even faster so I can't understand, why this isn't happening there?

RE: SAADC scan mode of 3 channels --> buffer order swap

haakonsh — Fri, 28 Jun 2019 14:48:28 GMT

That example does not prepare the next buffer until the calibration is complete.

RE: SAADC scan mode of 3 channels --> buffer order swap

Manuel55 — Wed, 26 Jun 2019 13:38:15 GMT

That means you were not able to get it working with RTC, SCAN and OVERSAMPLING in combination with CALIBRATION?

Revert to what exactly? I was not able to manage this in one of the approaches.

In my opinion i implemented it exactly like described here:
https://github.com/NordicPlayground/nRF52-ADC-examples/blob/master/saadc_low_power/main.c#L286

Regards,
Manuel

RE: SAADC scan mode of 3 channels --> buffer order swap

haakonsh — Wed, 26 Jun 2019 09:37:20 GMT

I think we should revert to https://devzone.nordicsemi.com/support-private/support/231167#permalink=471722

if(m_saadc_calibrate == true)
{
    // Disable any source that triggers the sample task.
    
	NRF_LOG_INFO("SAADC calibration starting...");    //Print on UART
	while(nrf_drv_saadc_calibrate_offset() != NRF_SUCCESS); //Trigger calibration task
	while(!NRF_SAADC->EVENTS_CALIBRATEDONE);
	m_saadc_calibrate = false;
	
	// Enable the source/s for that triggers the sample task.
}

I believe the problem is that the sample task is getting triggered during the calibration procedure.

The saadc driver does not have any awareness of HW triggering of the sample task and it will therefore not be able to handle this scenario.

RE: SAADC scan mode of 3 channels --> buffer order swap

Manuel55 — Wed, 26 Jun 2019 08:49:55 GMT

devzone.nordicsemi.com/.../Firmware_5F00_Nordic_5F00_Devzone.7z

Thank you. Here I send you a compilable version of my code. Its for my custom board but it should be easy to change it to the default devkits.

Regards,
Manuel

RE: SAADC scan mode of 3 channels --> buffer order swap

haakonsh — Wed, 26 Jun 2019 08:33:23 GMT

I'd like to try to reproduce it on my end, but I need a compilable code. I'm missing the definitions of about 20 variables and definitions.

RE: SAADC scan mode of 3 channels --> buffer order swap

Manuel55 — Tue, 25 Jun 2019 14:48:21 GMT

Still hanging on while(!NRF_SAADC->EVENTS_STOPPED)

Here is my current codeif this helps for further debugging

void saadc_sampling_event_init(void)
{
    ret_code_t err_code;

    err_code = nrf_drv_ppi_init();
    APP_ERROR_CHECK(err_code);
	
    uint32_t rtc_compare_event_addr = nrf_drv_rtc_event_address_get(&rtc, NRF_RTC_EVENT_COMPARE_0);//nrf_drv_timer_compare_event_address_get(&m_timer, NRF_TIMER_CC_CHANNEL0);
    uint32_t saadc_sample_task_addr   = nrf_drv_saadc_sample_task_get();

    /* setup ppi channel so that timer compare event is triggering sample task in SAADC */
    err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel_1);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_ppi_channel_assign(m_ppi_channel_1,
                                          rtc_compare_event_addr,
                                          saadc_sample_task_addr);
																					
    APP_ERROR_CHECK(err_code);
}


void saadc_sampling_event_enable(void)
{
    ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel_1);

    APP_ERROR_CHECK(err_code);
}

void saadc_sampling_event_disable(void)
{
    ret_code_t err_code = nrf_drv_ppi_channel_disable(m_ppi_channel_1);

    APP_ERROR_CHECK(err_code);
}


void saadc_callback(nrf_drv_saadc_evt_t const * p_event)
{
	int value = 0;
	int i;
	ret_code_t err_code;
	
    if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {
		nrf_gpio_pin_toggle(LED);
		
		if((m_adc_evt_counter % SAADC_CALIBRATION_INTERVAL) == 0)       //Evaluate if offset calibration should be performed. Configure the SAADC_CALIBRATION_INTERVAL constant to change the calibration frequency
        {
            nrf_drv_saadc_abort();                                      // Abort all ongoing conversions. Calibration cannot be run if SAADC is busy
            m_saadc_calibrate = true;                                   // Set flag to trigger calibration in main context when SAADC is stopped
        }
				
        NRF_LOG_INFO("ADC event number: %d", (int)m_adc_evt_counter);
				
		for (i = 0; i < ADC_CHANNEL_COUNT; i++)
		{
			NRF_LOG_INFO("%d", p_event->data.done.p_buffer[i]);
			switch(i%4)
			{
				case 0: thermistor_1_sum = p_event->data.done.p_buffer[i];
								break;
				case 1: thermistor_2_sum = p_event->data.done.p_buffer[i];
								break;	
				case 2: voltage_sum = p_event->data.done.p_buffer[i];
								break;	
			}
		}
		
		if(m_saadc_calibrate == false)
        {
            err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, ADC_CHANNEL_COUNT); //Set buffer so the SAADC can write to it again. This is either "buffer 1" or "buffer 2"
	        APP_ERROR_CHECK(err_code);
					
					measDone = 1;
        }
				
		m_adc_evt_counter++;
		
		nrf_gpio_pin_clear(THERMISTOR_VREF);
    }
    
    else if (p_event->type == NRF_DRV_SAADC_EVT_CALIBRATEDONE)
    {
				//nrfx_saadc_abort();
			
        err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[0], ADC_CHANNEL_COUNT);             //Set buffer so the SAADC can write to it again. 
        APP_ERROR_CHECK(err_code);
        err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[1], ADC_CHANNEL_COUNT);             //Need to setup both buffers, as they were both removed with the call to nrf_drv_saadc_abort before calibration.
        APP_ERROR_CHECK(err_code);
        
        NRF_LOG_INFO("SAADC calibration complete !");                                              //Print on UART        
    }
}

void saadc_init(void)
{
    ret_code_t err_code;

	//Configure SAADC
	nrf_drv_saadc_config_t  config = NRF_DRV_SAADC_DEFAULT_CONFIG;
	config.resolution = NRF_SAADC_RESOLUTION_14BIT;  
    config.oversample = SAADC_OVERSAMPLE_OVERSAMPLE_Over256x;
	//config.low_power_mode = true; 

	//Initialize SAADC
    err_code = nrf_drv_saadc_init(&config, saadc_callback);                       
    APP_ERROR_CHECK(err_code);
	
    //Configure SAADC channel 1
    nrf_saadc_channel_config_t channel_config = NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN0);
    channel_config.reference = NRF_SAADC_REFERENCE_VDD4;
    channel_config.gain = NRF_SAADC_GAIN1_4;
    channel_config.acq_time = SAADC_CH_CONFIG_TACQ_40us;
    channel_config.burst = NRF_SAADC_BURST_ENABLED;
    
    //Initialize SAADC channel 1
    err_code = nrf_drv_saadc_channel_init(0, &channel_config);
    APP_ERROR_CHECK(err_code);
    
    //Configure SAADC channel 2
    channel_config.pin_p = NRF_SAADC_INPUT_AIN1;
    channel_config.acq_time = SAADC_CH_CONFIG_TACQ_40us;
    
    //Initialize SAADC channel 2
    err_code = nrf_drv_saadc_channel_init(1, &channel_config);
    APP_ERROR_CHECK(err_code);
    
    //Configure SAADC channel 3
    channel_config.pin_p = NRF_SAADC_INPUT_AIN2;
    channel_config.reference = NRF_SAADC_REFERENCE_INTERNAL;
    channel_config.gain = NRF_SAADC_GAIN4;
    channel_config.acq_time = SAADC_CH_CONFIG_TACQ_40us;
    
    //Initialize SAADC channel 3
    err_code = nrf_drv_saadc_channel_init(2, &channel_config);
    APP_ERROR_CHECK(err_code);
    
    //Set SAADC buffer 1. The SAADC will start to write to this buffer
    err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[0], ADC_CHANNEL_COUNT);
    APP_ERROR_CHECK(err_code);
    
    //Set SAADC buffer 2. The SAADC will write to this buffer when buffer 1 is full. This will give the applicaiton time to process data in buffer 1.
    err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[1], ADC_CHANNEL_COUNT);
    APP_ERROR_CHECK(err_code);
}


static void rtc_handler(nrf_drv_rtc_int_type_t int_type)
{
	static int i = 2;
    if (int_type == NRF_DRV_RTC_INT_COMPARE0)
    {
		nrf_gpio_pin_set(THERMISTOR_VREF);
		nrf_drv_rtc_counter_clear(&rtc);
		//reactivate compare irq! 
	    nrf_drv_rtc_cc_set(&rtc,0,COMPARE_COUNTERTIME * 8,true);
    }
		
    else if (int_type == NRF_DRV_RTC_INT_TICK)
    {
        rtcCounter++;
    }
		
}


static void lfclk_config(void)
{
    ret_code_t err_code = nrf_drv_clock_init();
    APP_ERROR_CHECK(err_code);

    nrf_drv_clock_lfclk_request(NULL);
}


static void rtc_config(void)
{
	uint32_t err_code;

	//Initialize RTC instance
	nrf_drv_rtc_config_t config = NRF_DRV_RTC_DEFAULT_CONFIG;
	config.prescaler = 4095; // fRTC [kHz] = 32.768 / (PRESCALER + 1 ) --> 8Hz (minimum because prescsaler is 12bit)
	err_code = nrf_drv_rtc_init(&rtc, &config, rtc_handler);
	APP_ERROR_CHECK(err_code);

	//Enable tick event & interrupt
	nrf_drv_rtc_tick_enable(&rtc,true);

	//Set compare channel 0 to trigger interrupt after COMPARE_COUNTERTIME seconds
	err_code = nrf_drv_rtc_cc_set(&rtc,0,COMPARE_COUNTERTIME * 8,true); //1Hz
	APP_ERROR_CHECK(err_code);

	//Power on RTC instance
	nrf_drv_rtc_enable(&rtc);
}

void timer_handler(nrf_timer_event_t event_type, void * p_context)
{

}

int main(void)
{
    /* Configure board. */
    bsp_board_init(BSP_INIT_LEDS);
    bsp_board_leds_on();
    bsp_board_init(BSP_INIT_BUTTONS);
    
    APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
    NRF_LOG_DEFAULT_BACKENDS_INIT();
    
    NRF_POWER->DCDCEN = 1;	//Enabling the DCDC converter for lower current consumption
    
    NRF_LOG_INFO("Zirbel Datalogger successfuly started...");
    
    lfclk_config();
    rtc_config();
    
    nrf_gpio_cfg_output(THERMISTOR_VREF);
    nrf_gpio_pin_set(THERMISTOR_VREF);
    
    saadc_init();
    saadc_sampling_event_init();
    saadc_sampling_event_enable();
    
    while(1)
    {	
        if(m_saadc_calibrate == true)
        {
            // Disable the PPI triggering of the sample task
            saadc_sampling_event_disable();
            
            NRF_SAADC->EVENTS_STOPPED = 0;
            NRF_SAADC->TASKS_STOP;
            while(!NRF_SAADC->EVENTS_STOPPED);
            NRF_SAADC->EVENTS_STOPPED = 0;
            
            NRF_LOG_INFO("SAADC calibration starting...");    //Print on UART
            while(nrf_drv_saadc_calibrate_offset() != NRF_SUCCESS); //Trigger calibration task
            while(!NRF_SAADC->EVENTS_CALIBRATEDONE);
            NRF_SAADC->EVENTS_CALIBRATEDONE = 0;
            
            NRF_SAADC->EVENTS_STOPPED = 0;
            NRF_SAADC->TASKS_STOP;
            while(!NRF_SAADC->EVENTS_STOPPED);
            NRF_SAADC->EVENTS_STOPPED = 0;
            
            NRF_SAADC->EVENTS_STARTED = 0;
            NRF_SAADC->TASKS_START;
            while(!NRF_SAADC->EVENTS_STARTED);
            NRF_SAADC->EVENTS_STARTED = 0;
            
            // Enable the PPI triggering of the sample task
            saadc_sampling_event_enable();
            
            m_saadc_calibrate = false;
        }

        if(measDone == 1)
        {
            ...
        }

Thank you for your help, I appreciate that very much!

Manuel

RE: SAADC scan mode of 3 channels --> buffer order swap

haakonsh — Tue, 25 Jun 2019 13:34:24 GMT

Try this:

if(m_saadc_calibrate == true)
{
    // Disable the PPI triggering of the sample task
    
    NRF_SAADC->EVENTS_STOPPED = 0;
	NRF_SAADC->TASKS_STOP;
	while(!NRF_SAADC->EVENTS_STOPPED);
	NRF_SAADC->EVENTS_STOPPED = 0;

	NRF_LOG_INFO("SAADC calibration starting...");    //Print on UART
	while(nrf_drv_saadc_calibrate_offset() != NRF_SUCCESS); //Trigger calibration task
	while(!NRF_SAADC->EVENTS_CALIBRATEDONE);
	NRF_SAADC->EVENTS_CALIBRATEDONE = 0;
	
	NRF_SAADC->EVENTS_STOPPED = 0;
	NRF_SAADC->TASKS_STOP;
	while(!NRF_SAADC->EVENTS_STOPPED);
	NRF_SAADC->EVENTS_STOPPED = 0;
	
	NRF_SAADC->EVENTS_STARTED = 0;
	NRF_SAADC->TASKS_START;
	while(!NRF_SAADC->EVENTS_STARTED);
	NRF_SAADC->EVENTS_STARTED = 0;
	
	// Enable the PPI triggering of the sample task
	
	m_saadc_calibrate = false;
}

The PPI system will operate even though you've halted the CPU with the debugger, and the SAADC will also operate when the CPU is halted.

RE: SAADC scan mode of 3 channels --> buffer order swap

Manuel55 — Tue, 25 Jun 2019 13:02:31 GMT

Thank you, but this is also not working together with my code. It stops and hangs on:

while(!NRF_SAADC->EVENTS_STARTED);

PPI is still active for the SAMPLE task.

I'm really confused now about this START, STARTED, END, DONE- things...
I'm not able to comprehend this procedure of events and tasks while debugging.

RE: SAADC scan mode of 3 channels --> buffer order swap

haakonsh — Tue, 25 Jun 2019 12:27:10 GMT

Then you've triggered the start task before the calibration task, use:

if(m_saadc_calibrate == true)
{
	NRF_LOG_INFO("SAADC calibration starting...");    //Print on UART
	while(nrf_drv_saadc_calibrate_offset() != NRF_SUCCESS); //Trigger calibration task
	while(!NRF_SAADC->EVENTS_CALIBRATEDONE);
	NRF_SAADC->EVENTS_CALIBRATEDONE = 0;
	
	NRF_SAADC->EVENTS_STARTED = 0;
	NRF_SAADC->TASKS_START;
	while(!NRF_SAADC->EVENTS_STARTED);
	NRF_SAADC->EVENTS_STARTED = 0;
	
	m_saadc_calibrate = false;
}

in order to re-trigger the start task, as this will reload the PTR and MAXCNT registers.

RE: SAADC scan mode of 3 channels --> buffer order swap

Manuel55 — Tue, 25 Jun 2019 12:23:10 GMT

It's 0x0003

RE: SAADC scan mode of 3 channels --> buffer order swap

haakonsh — Tue, 25 Jun 2019 11:35:15 GMT

What's the state of the RESULT.AMOUNT register after the first calibration has completed?

RE: SAADC scan mode of 3 channels --> buffer order swap

Manuel55 — Tue, 25 Jun 2019 10:18:16 GMT

OK, I added this to my main:

if(m_saadc_calibrate == true)
{
	NRF_LOG_INFO("SAADC calibration starting...");    //Print on UART
	while(nrf_drv_saadc_calibrate_offset() != NRF_SUCCESS); //Trigger calibration task
	while(!NRF_SAADC->EVENTS_CALIBRATEDONE);
	m_saadc_calibrate = false;
}

The problem is still there. After the first calibration, the samples in the buffer are somehow swapped.

It seems to be the same error like in the beginning of the thread. Anyone can show me some tested samplecode? I really can not go any further..

Thanks,
Manuel

RE: SAADC scan mode of 3 channels --> buffer order swap

haakonsh — Tue, 25 Jun 2019 10:04:09 GMT

You're getting calibration data in your samples.

After you've triggered the calibrate offset task with the call to nrf_drv_saadc_calibrate_offset() you need to wait until it's complete:

While(!NRF_SAADC->EVENTS_CALIBRATEDONE);

RE: SAADC scan mode of 3 channels --> buffer order swap

Manuel55 — Tue, 25 Jun 2019 08:29:10 GMT

Thank you haakonsh.

Unfotunately I was not able to implement this without swaps in the buffer. I switched now to your suggested approach. SCAN mode of multiple channels with oversampling (256x). Burst mode is activated on every channel.

I need a high accuracy of the thermistor measurements. Therefore I wanted to add a periodical offset calibration. Because a change in temperature will be very likely in my application.

Therefore I added the following to my code:

SAADC interrupt routine:

void saadc_callback(nrf_drv_saadc_evt_t const * p_event)
{
	int value = 0;
	int i;
	ret_code_t err_code;

    if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {
		nrf_gpio_pin_toggle(LED);
		
		if((m_adc_evt_counter % SAADC_CALIBRATION_INTERVAL) == 0)       //Evaluate if offset calibration should be performed. Configure the SAADC_CALIBRATION_INTERVAL constant to change the calibration frequency
        {
            nrf_drv_saadc_abort();                                      // Abort all ongoing conversions. Calibration cannot be run if SAADC is busy
            m_saadc_calibrate = true;                                   // Set flag to trigger calibration in main context when SAADC is stopped
        }
        
        NRF_LOG_INFO("ADC event number: %d", (int)m_adc_evt_counter);
				
		for (i = 0; i < ADC_CHANNEL_COUNT; i++)
		{
			NRF_LOG_INFO("%d", p_event->data.done.p_buffer[i]);
			switch(i%4)
			{
				case 0: battery_voltage_sum = p_event->data.done.p_buffer[i];
								break;
				case 1: thermistor_1_sum = p_event->data.done.p_buffer[i];
								break;
				case 2: thermistor_2_sum = p_event->data.done.p_buffer[i];
								break;	
				case 3: voltage_sum = p_event->data.done.p_buffer[i];
								break;	
			}
		}
		
		if(m_saadc_calibrate == false)
        {
            err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, ADC_CHANNEL_COUNT); //Set buffer so the SAADC can write to it again. This is either "buffer 1" or "buffer 2"
			APP_ERROR_CHECK(err_code);
			
			measDone = 1;
        }
				
		m_adc_evt_counter++;
		
		nrf_gpio_pin_clear(THERMISTOR_VREF);
    }
		
	else if (p_event->type == NRF_DRV_SAADC_EVT_CALIBRATEDONE)
    {
        err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[0], ADC_CHANNEL_COUNT);             //Set buffer so the SAADC can write to it again. 
        APP_ERROR_CHECK(err_code);
        err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[1], ADC_CHANNEL_COUNT);             //Need to setup both buffers, as they were both removed with the call to nrf_drv_saadc_abort before calibration.
        APP_ERROR_CHECK(err_code);
        
        NRF_LOG_INFO("SAADC calibration complete !");                                              //Print on UART        
    }
}

main:

while(1)
{	
	if(m_saadc_calibrate == true)
	{
		NRF_LOG_INFO("SAADC calibration starting...");    //Print on UART
		while(nrf_drv_saadc_calibrate_offset() != NRF_SUCCESS); //Trigger calibration task
		m_saadc_calibrate = false;
	}

	if(measDone == 1)
	{
	    ...
	}

I think I did everythink like described in this link:
https://github.com/NordicPlayground/nRF52-ADC-examples/tree/master/saadc_low_power

But as soon as I perform the first calibration, the buffer data is rubbish. I can't even recognize a pattern of buffer swap or something like this.

Could you please help me with this behaviour?

Thank you and best regards,
Manuel

RE: SAADC scan mode of 3 channels --> buffer order swap

haakonsh — Mon, 24 Jun 2019 11:23:44 GMT

[quote user="Manuel55"]Thank you for your answer. But I do not fully understand it. How can I catch this STARTED event for calling nrf_drv_saadc_buffer_convert() then. Is there some samplecode for that?[/quote]

No, I'm afraid there's no sample code that does that for you. You will need to modify the saadc driver's interrupt handler to handle this scenario.

[quote user="Manuel55"]I have a hard time by understanding this PPI stuff like[/quote]

The PPI uses the registers of the HW peripherals to connect their tasks and events.
It monitors a given event register, and in the event that it changes state from 0x00 to 0x01(indicating that the event has happened) it will write a 0x01 to a given task register, thereby triggering the given task.

f.ex, the nRF52832'a SAADC EVENTS_END register has an address offset of 0x104, with an address base of 0x40007000 for the SAADC peripheral the EVENTS_END register has the address of 0x40007104, who's is what nrf_saadc_event_address_get(NRF_SAADC_EVENT_END) will return.

Likewise nrf_saadc_task_address_get(NRF_SAADC_TASK_START) will return 0x40007000, as the address offset of the TASKS_START register is 0x000.

This coupling between an event register and a task register is then assigned to a PPI channel.
An event or task register can be connected to any number of PPI channels.

[quote user="Manuel55"]Well, MAXCNT is to set the maximum sample count for the buffer before firing the NRF_DRV_SAADC_EVT_DONE event, right?[/quote]

The MAXCNT sets the number of samples that the SAADC will sample before it will fire the EVENTS_END, at which point all the samples have been transferred from the SAADC into RAM.

MAXCNT along with PTR must be configured before triggering the next START task, otherwise, they will not be used. This is the core of your issue, that the MAXCNT and PTR register are not updated before the START task is triggered, or the start task is triggered after the SAADC has begun its next sampling cycle.
In both cases, you'll overwrite your previous buffers, and in the second case, you will suddenly change the buffer mid-sample-cycle, thereby creating out of order samples.

[quote user="Manuel55"]What I want to implement is 1 measurement per second. 10 measurements per channel are made at 1kHz. After the DONE event, I switch off the PPI channel so no more samples will be made. After 1 second, I switch on the PPI channel again for 10 measurements. Summarized I want to have one measurement per seccond but the measurements are a average out of 10 samples which were sampled in a high frequency.[/quote]

I interpret this as one set of measurements per second, 10 samples per channel per set, at 1kHz sample rate, with averaging of the sets of 10 samples.

You don't need to disable the PPI channel, but that might work as intended. I would rather stop and clear the TIMER on the SAADC's end event, and then trigger the start event in order to start your sampling sequence.

Other thoughts:
If you only enable one SAADC channel at a time you can use oversampling to average over the samples automatically at 1kHz. That way you will not have to do any averaging in SW.

You can do oversampling on multiple channels, but then you must enable BURST mode on all channels. From Oversampling:
"H[n].CONFIG.BURST can be enabled to avoid setting SAMPLE task 2^OVERSAMPLE times. With BURST = 1 the ADC will sample the input 2^OVERSAMPLE times as fast as it can (actual timing: <(t_ACQ+t_CONV)×2^OVERSAMPLE). Thus, for the user it will just appear like the conversion took a bit longer time, but other than that, it is similar to one-shot mode. Scan mode can be combined with BURST=1, if burst is enabled on all channels."

RE: SAADC scan mode of 3 channels --> buffer order swap

Manuel55 — Fri, 21 Jun 2019 11:20:44 GMT

Thank you for your answer. But I do not fully understand it. How can I catch this STARTED event for calling nrf_drv_saadc_buffer_convert() then. Is there some samplecode for that?

I have a hard time by understanding this PPI stuff like

err_code = nrf_drv_ppi_channel_assign(m_ppi_channel_2, nrf_saadc_event_address_get(NRF_SAADC_EVENT_END), nrf_saadc_task_address_get(NRF_SAADC_TASK_START));

Well, MAXCNT is to set the maximum sample count for the buffer before firing the NRF_DRV_SAADC_EVT_DONE event, right?

What I want to implement is 1 measurement per second. 10 measurements per channel are made at 1kHz. After the DONE event, I switch off the PPI channel so no more samples will be made. After 1 second, I switch on the PPI channel again for 10 measurements. Summarized I want to have one measurement per seccond but the measurements are a average out of 10 samples which were sampled in a high frequency.

Is it clearer now?

Thank you and best regards,
Manuel

#edit:

When I activate the STARTED interrupt with nrf_saadc_int_enable(NRF_SAADC_INT_STARTED), I end up in a NRF_ERROR_INVALID_STATE error while calling APP_ERROR_CHECK(err_code) after enabling my PPI channel 1 which is responsible for triggering the sample task.

RE: SAADC scan mode of 3 channels --> buffer order swap

haakonsh — Fri, 21 Jun 2019 09:13:45 GMT

You need to update the buffer pointer and maxcount registers immediately after a STARTED event. Right now it's done after the END event.
By updating the buffer registers after the START task has been triggered you will overwrite the previous buffer as new buffers will not be used until the next START task.

See the SAADC's EasyDMA chapter.

"I'm using a compare event of the RTC to trigger the sample task in scan mode. Another compare event is used to enable the ppi channel again after disabling it after 10 samples per channel. The reason for that is that I want to sample at a high frequency but only 10 samples per second."
Can you try to rephrase your description a bit, I did not quite catch why you're disabling the PPI to control the sampling, usually this is done with the MAXCNT register.