SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

Kenneth — Mon, 31 Oct 2022 08:58:00 GMT

Hi,

I believe it looks right, the generic formula is found here:
https://infocenter.nordicsemi.com/topic/com.nordic.infocenter.nrf52832.ps.v1.1/saadc.html#saadc_digital_output

Best regards,
Kenneth

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

ParanBada — Fri, 28 Oct 2022 10:02:28 GMT

Hi,
I inquired about the voltage calculation formula for differential sampling above.
I look forward to your reply.

Best Regards,

SunBae Yim.

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

ParanBada — Thu, 27 Oct 2022 12:35:17 GMT

Hi,

Differential ADC sampling:
Find the difference by reading the P and N channels. Is that right? (VALUE = P - N)

The same formula is used as follows.

#define SIMPLE_REF_VOLTAGE_IN_MILLIVOLTS   		600.0f                                     /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
#define SIMPLE_PRE_SCALING_COMPENSATION    		6.0f                                       /**< The ADC is configured to use VDD with 1/3 prescaling as input. And hence the result of conversion is to be multiplied by 3 to get the actual value of the battery voltage.*/
#define SIMPLE_ADC_RES_10BITS             		1024.0f                                    /**< Maximum digital value for 10-bit ADC conversion. */

/**@brief Macro to convert the result of ADC conversion in millivolts.
 *
 * @param[in]  ADC_VALUE   ADC result.
 *
 * @retval     Result converted to millivolts.
 */
#define SIMPLE_VOUT_IN_MILLI_VOLTS(ADC_VALUE)\
				((((ADC_VALUE) * SIMPLE_REF_VOLTAGE_IN_MILLIVOLTS) / SIMPLE_ADC_RES_10BITS) * SIMPLE_PRE_SCALING_COMPENSATION)

Please check if this formula can also be used for DIFFRENTIAL.

Best Regards,

SunBae Yim.

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

Kenneth — Thu, 27 Oct 2022 10:02:23 GMT

Hi,

[quote user="ParanBada0"]Does the differential read half the voltage?[/quote]

No, it should not. I suggest for test that you try with a different source (for instance with less impedance), and possible try to increase the acquisition time, ref:
https://infocenter.nordicsemi.com/topic/ps_nrf52840/saadc.html

Best regards,
Kenneth

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

ParanBada — Thu, 27 Oct 2022 09:37:18 GMT

Hello,

I implemented ADC sampling with a differential like the source code above, and converted it into a voltage value using the formula.
However, the voltage value is only half of the actual measured value.

Does the differential read half the voltage? Or do I have to change the formula?

In differential sampling, half the voltage is output, how can I solve it?

Best Regards,

SunBae Yim.

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

Kenneth — Wed, 26 Oct 2022 13:17:03 GMT

Hi again,

Looking at the example you shared on your google drive, these are the two things you can change.

In simple_irq_init() use:
err_code = nrfx_gpiote_in_init(ADA2200_SYNCO_PIN, &in_config, NULL);

In addition change to:
#define SIM_SAMPLES_IN_BUFFER 10 // or maybe even higher like 100

At least then it seems to trigger simple_voltage_handler() every 10 or 100 samples here.

Best regards,
Kenneth

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

ParanBada — Wed, 26 Oct 2022 10:32:36 GMT

Hello,
I have a tight schedule these days, so it's very difficult. I need your help.
I inquired about the PPI source code above.
Please review my source code and give me an answer.
I took your advice and blocked the interrupt.
simple_voltage_handler() function is not executed.

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

ParanBada — Tue, 25 Oct 2022 14:30:40 GMT

I add the missing figure in the above post as follows:

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

ParanBada — Tue, 25 Oct 2022 14:26:03 GMT

Hello,

You said:
" Even though you are sampling this at 62.5kHz, you should not need to execute an MCU interrupt at this interval. Much of the point of having PPI and EasyDMA is to offload the MCU for the real-time requirements,......"

So I followed your advice and deleted the [interrupt function] as in the following code.
By the way, simple_voltage_handler() is not called. Why?

/*******************************************************************************
 * @file	meas_pd_voltage.c
 * @author	CandyPops Co.
 * @version	V1.0.0
 * @date	2022-09-05
 * @brief   
 ******************************************************************************/

#include "sdk_common.h"
			
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nrf.h"
#include "boards.h"
#include "app_error.h"
#include "nrf_drv_saadc.h"
#include "nrfx_gpiote.h"
#include "nrf_drv_gpiote.h"
#include "nrf_drv_ppi.h"
#include "nrf_drv_timer.h"
#include "nrf_delay.h"

#include "meas_pd_voltage_simple.h"


#define PD_REF_VOLTAGE_IN_MILLIVOLTS   		600.0f                                     /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
#define PD_PRE_SCALING_COMPENSATION    		6.0f                                       /**< The ADC is configured to use VDD with 1/3 prescaling as input. And hence the result of conversion is to be multiplied by 3 to get the actual value of the battery voltage.*/
#define PD_ADC_RES_10BITS             		1024.0f                                    /**< Maximum digital value for 10-bit ADC conversion. */

/**@brief Macro to convert the result of ADC conversion in millivolts.
 *
 * @param[in]  ADC_VALUE   ADC result.
 *
 * @retval     Result converted to millivolts.
 */
#define PD_VOUT_IN_MILLI_VOLTS(ADC_VALUE)\
				((((ADC_VALUE) * PD_REF_VOLTAGE_IN_MILLIVOLTS) / PD_ADC_RES_10BITS) * PD_PRE_SCALING_COMPENSATION)

#define SIM_SAMPLES_IN_BUFFER 		10

static nrf_saadc_value_t pd_adc_buf[2][SIM_SAMPLES_IN_BUFFER];
float pd_voltage_in_milli_volts = 0;
bool  pd_adc_simple_start	= false;





/** @brief Macro for setting @ref nrfx_saadc_config_t to default settings. */
#define PD_NRFX_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                             \
}
/* Resolution is 10bits */
/* Over Sampling Disabled */
/* Interrupt Priority is 0(Highest) */
/* Low Power Mode is Disabled */




/**
 * @brief Macro for setting @ref nrf_saadc_channel_config_t to default settings
 *        in differential mode.
 *
 * @param PIN_P Positive analog input.
 * @param PIN_N Negative analog input.
 */
#define PD_NRFX_SAADC_DEFAULT_CHANNEL_CONFIG_DIFFERENTIAL(PIN_P, PIN_N) \
{                                                                       \
    .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_DIFFERENTIAL,                          \
    .burst      = NRF_SAADC_BURST_DISABLED,                             \
    .pin_p      = (nrf_saadc_input_t)(PIN_P),                           \
    .pin_n      = (nrf_saadc_input_t)(PIN_N)                            \
}


#define PD_ADC_CNT	8
uint8_t SIM_IRQ_NO = 8;

uint32_t sim_call_cnt 		= 0;
uint32_t sim_ans_cnt 		= 0;

float pd_voltage_buff[110] = {0.0f,}; /* For Cycle-8, Cycle-16, Cycle-24, Cycle-32 */ 
uint8_t	pd_voltage_buff_idx = 0;

static nrf_ppi_channel_t	m_ppi_channel;


void simple_ppi_init(void)
{
    ret_code_t err_code;

	printf("simple_ppi_init\r\n");

    err_code = nrf_drv_ppi_init();
    APP_ERROR_CHECK(err_code);

    uint32_t gpiote_event_addr = nrf_drv_gpiote_in_event_addr_get(ADA2200_SYNCO_PIN);	
    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);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
                                          gpiote_event_addr,
                                          saadc_sample_task_addr);
    APP_ERROR_CHECK(err_code);
}


void simple_ppi_uninit(void)
{
    ret_code_t err_code;
	printf("simple_ppi_uninit\r\n");

    err_code = nrf_drv_ppi_uninit();
    APP_ERROR_CHECK(err_code);
}


void simple_sampling_event_enable(void)
{
	printf("simple_sampling_event_enable\r\n");

    ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
    APP_ERROR_CHECK(err_code);

	/////////////////////////////////////////////
	nrf_delay_us(500);
	nrf_drv_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
	nrf_delay_us(500);
	/////////////////////////////////////////////
}


void simple_sampling_event_disable(void)
{
	printf("simple_sampling_event_disable\r\n");

	nrf_drv_gpiote_in_event_disable(ADA2200_SYNCO_PIN);

	ret_code_t err_code = nrf_drv_ppi_channel_disable(m_ppi_channel);
	APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling the ADC interrupt.
 *
 * @details  This function will fetch the conversion result from the ADC, convert the value into
 *           percentage and send it to peer.
 */
static void simple_voltage_handler(nrf_drv_saadc_evt_t const * p_event)	/* PD Voltage reading */
{
	printf("p\r\n");

    if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {	
		nrf_gpio_pin_set(ANS_INT_26);
		nrf_gpio_pin_clear(ANS_INT_26);

	   	sim_ans_cnt++;
	
        nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SIM_SAMPLES_IN_BUFFER);

		pd_voltage_in_milli_volts = PD_VOUT_IN_MILLI_VOLTS(p_event->data.done.p_buffer[0]);

		pd_voltage_buff[pd_voltage_buff_idx] = pd_voltage_in_milli_volts;
		pd_voltage_buff_idx++;

		if(sim_call_cnt == 100) {
			pd_adc_simple_start = false;

			simple_mesurement_stop();


			printf("iDx = %d \r\n", pd_voltage_buff_idx);
			printf("sim_call_cnt=%d, sim_ans_cnt=%d\r\n", sim_call_cnt, sim_ans_cnt);
			
			for(uint8_t i = 0; i < 110; i++) {
				printf(" %f ", pd_voltage_buff[i]);
			}
			printf("\r\n === TEST END === \r\n\r\n");

			

			memset(pd_voltage_buff, 0, 110);
			pd_voltage_buff_idx = 0;

			sim_call_cnt		= 0;
			sim_ans_cnt			= 0;
			pd_voltage_buff_idx	= 0;
		}
    }
}


void simple_adc_init(void)
{
	printf("simple_adc_init\r\n");


	nrfx_saadc_config_t default_config = PD_NRFX_SAADC_DEFAULT_CONFIG;

	nrf_saadc_channel_config_t config =
	PD_NRFX_SAADC_DEFAULT_CHANNEL_CONFIG_DIFFERENTIAL(NRF_SAADC_INPUT_AIN0, NRF_SAADC_INPUT_AIN1);

	
	ret_code_t err_code = nrf_drv_saadc_init(&default_config, simple_voltage_handler);
	APP_ERROR_CHECK(err_code);

	err_code = nrf_drv_saadc_channel_init(0, &config);
	APP_ERROR_CHECK(err_code);

	err_code = nrf_drv_saadc_buffer_convert(pd_adc_buf[0], SIM_SAMPLES_IN_BUFFER);
	APP_ERROR_CHECK(err_code);

	err_code = nrf_drv_saadc_buffer_convert(pd_adc_buf[1], SIM_SAMPLES_IN_BUFFER);
	APP_ERROR_CHECK(err_code);	
}


void simple_adc_uninit(void)
{
	printf("simple_adc_uninit\r\n");

	nrf_drv_saadc_uninit();
	nrf_drv_saadc_channel_uninit(0);
}


//static void simple_interrupt_handler(nrfx_gpiote_pin_t pin, nrf_gpiote_polarity_t action)
//{
//	if(pd_adc_simple_start == true) {
//		sim_call_cnt++;
//
//		//nrf_gpio_pin_set(CALL_INT_18);
//		//nrf_gpio_pin_clear(CALL_INT_18);
//
////		if(sim_call_cnt == 100) {
////			pd_adc_simple_start = false;
////
////			simple_mesurement_stop();
////
////
////			printf("iDx = %d \r\n", pd_voltage_buff_idx);
////			printf("sim_call_cnt=%d, sim_ans_cnt=%d\r\n", sim_call_cnt, sim_ans_cnt);
////			
////			for(uint8_t i = 0; i < 110; i++) {
////				printf(" %f ", pd_voltage_buff[i]);
////			}
////			printf("\r\n === TEST END === \r\n\r\n");
////
////			
////
////			memset(pd_voltage_buff, 0, 110);
////			pd_voltage_buff_idx = 0;
////
////			sim_call_cnt		= 0;
////			sim_ans_cnt			= 0;
////			pd_voltage_buff_idx	= 0;
////		}
//	}
//}	


//void simple_irq_init(void){
//    ret_code_t err_code;
//
//	printf("simple_irq_init\r\n");
//
//	/* Initialize int pin */
//	if (!nrfx_gpiote_is_init())
//	{
//	  err_code = nrfx_gpiote_init();
//	  APP_ERROR_CHECK(err_code);
//	}
//
//    nrfx_gpiote_in_config_t in_config = NRFX_GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
//    in_config.pull = NRF_GPIO_PIN_PULLDOWN;
//
//    err_code = nrfx_gpiote_in_init(ADA2200_SYNCO_PIN, &in_config, simple_interrupt_handler);
//    APP_ERROR_CHECK(err_code);
//
//    nrfx_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
//}


//void simple_irq_uninit(void){
//	printf("pd_irq_uninit\r\n");
//	
//	nrfx_gpiote_in_event_disable(ADA2200_SYNCO_PIN);
//	nrfx_gpiote_in_uninit(ADA2200_SYNCO_PIN);
//}


void simple_mesurement_start(void){
	printf("simple_mesurement_start\r\n");

//	simple_irq_init();

	simple_adc_init();
	simple_ppi_init();
	
	simple_sampling_event_enable();
}


void simple_mesurement_stop(void){
	printf("simple_mesurement_stop\r\n");

	simple_sampling_event_disable();
	simple_adc_uninit();
	simple_ppi_uninit();

//	simple_irq_uninit();
}

Looking at the source code, is the processing of the 62.5KHz external clock pin (ADA2200_SYNCO_PIN) in the red box normal?

Regardless of MCU, it should receive an external clock of 62.5KHz and PPI should perform ADC sampling on its own, but it doesn't work that way.
How do I fix my code to do that?

Best Regards,

SunBae Yim.

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

Kenneth — Tue, 25 Oct 2022 12:49:34 GMT

Hello,

Even though you are sampling this at 62.5kHz, you should not need to execute an MCU interrupt at this interval. Much of the point of having PPI and EasyDMA is to offload the MCU for the real-time requirements, and instead the MCU only need to actively handle "lump" of data, not on a byte level, but on an array of data. So my suggestion here is that you change SIM_SAMPLES_IN_BUFFER from 1 to 10. Then the MCU will be interrupted every 6.25kHz to process 10samples, instead of 1 sample every 62.5kHz.

Best regards,
Kenneth

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

ParanBada — Mon, 24 Oct 2022 15:39:11 GMT

Hi,

I implemented SAADC on a custom board using a BSP only example without using SoftDevice and BLE.
Chipset: nRF52840CIAA

This product uses an external ADA2200 (Lock-In-Amp) to generate a 62.5KHz clock (Logic Channel 7).
This clock is input to the nRF52840 as an interrupt (Logic Channel 5).
This interrupt does SAADC sampling through ppi (Logic Channel 3).

According to the nRF52840 datasheet, the maximum sampling rate is 200KHz.
I'm trying to do ADC sampling synchronized to a 62.5KHz clock. (Channel 7)
However, as shown in the figure, 19 clocks per 100 INTs were dropped (Channel 5)
But even worse, ADC Sampling only got 19 (Channel 3)

This is a very serious problem. The most important function of my product is to perform ADC sampling in synchronization with the 62.5KHz clock.
However, there are too many DROPs as shown in the picture below.

Looking at the second picture,
When ADC sampling is acquired, the next interrupt is dropped. 19 interrupts dropped, 19 ADC samplings acquired.

The interval time of 62.5KHz is 16uSec. ADC sampling takes more than 16uSec.

I have to solve this.

I share the source code I made. https://drive.google.com/file/d/1tBp8IeFoq03mxUm5P3QUvkJj_13QjYGn/view?usp=sharing
Please check this source code. How can I solve this problem?
And are there no mistakes in my source code? SAADC, PPI, INT.

Please help and thank you.

SunBae Yim.

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

Kenneth — Wed, 19 Oct 2022 14:52:19 GMT

What you are asking about here I believe is explained in the SAADC chapter:
https://infocenter.nordicsemi.com/topic/ps_nrf52840/saadc.html#concept_continuous

There is a calculation showing fSAMPLE < (1/(fACQ + tCONB)), best case (<10kohm source) < (1/(3us + 2us)) < 200kHz.

Note that in your case you are sampling two channel at 62.5Hz, which in this case translate to 125kHz since there is only one ADC that sample 2 channels. So if you connect a TIMER with a timeout of (1/125kHz=) 8us, then every other analog input is sampled at 62.5kHz (with an offset of 8us).

So yes, this can work, not though that sampling for 1 seconds will require 2byte * 2samples * 62.5k = 250kByte, so you need to offload this to some external memory in between here.

There should be ppi examples in the SDK.

Best regards,
Kenneth

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

ParanBada — Tue, 18 Oct 2022 10:44:55 GMT

This product must be sampled for about 5 seconds with Two ADCs (set to Diffrencial) in synchronization with an external 62.5KHz clock. The sampling period is only about 5 seconds. Instead, the sampling rate is 62.5KHz, which is very fast and the most important part.

The measured data is collected in RAM, and when the measurement is finished, it is transmitted sequentially through BLE or UART.

62.5KHz ADC Sampling and BLE transmission do not occur at the same time.
This means that only the ADC should operate at 62.5KHz for about 5 seconds.

Is 62.5KHz sampling possible if I use the PPI?
Any examples to reference?

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

Kenneth — Tue, 18 Oct 2022 09:25:57 GMT

Hello,

The other threads were long, I did not read all no. But I get the impression that the same discussion was performed two years ago and there have been no fundemental changes to hardware or software that will make this possible today. I can also see in the other thread that you want to measure 2 analog inputs, ref: "This technology receives 62.5kHz through the interrupt pin (P.7), and needs to sample 2 ADC channels in synchronization with this interrupt clock." This is the double of my throughput calculations.

You may consider using the nRF5340 instead, then you can do all the ADC sampling on the application core and the network core will do the BLE link. However the BLE will be the same, so I don't see how you are able to transfer the amount of data you want here. Have you done any calculations on the throughput you need on the link?

Kenneth

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

ParanBada — Tue, 18 Oct 2022 07:51:45 GMT

Hello,

I asked 2 questions 2 years ago. The open question link is here.
https://devzone.nordicsemi.com/support/250254
And the private question is at the following link. Can I see this link here?
https://devzone.nordicsemi.com/f/nordic-q-a/61750/what-is-the-saadc-maximum-sampling-rate-for-nrf52810

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

ParanBada — Tue, 18 Oct 2022 07:44:24 GMT

The place I inquired about two years ago was private question.
Can I post a private question link here?

RE: SAADC(two channel) Differencial Sampling by External 62.5KHz Clock Interrupt.

Kenneth — Tue, 18 Oct 2022 07:34:25 GMT

Hello,

Maybe you can share a link to the case you had two years ago so I can see what was done at the time?

Looking at the saadc chapter in the datasheet:
https://infocenter.nordicsemi.com/topic/ps_nrf52840/saadc.html

In specific Figure 4:
https://infocenter.nordicsemi.com/topic/ps_nrf52840/ip/saadc/doc/image/saadc.svg

It looks like this should be possible for instance by a gpiote event->ppi->sample task, then once the buffer is full you get an END event which you can handle in the SAADC interrupt. Then you don't need to handle the data at 65kHz (~15us), but for instance every 1.5ms (assuming a 100byte buffer, likely you need to double buffer, so one buffer can fill up while you are handling the other). Also I expect you need to have a ppi between END event and START task, so the next buffer is used automatically when the END event occur.

I expect the main problem here will be the throughput the BLE link must handle, e.g. if you assume every sample here is 10bit, and you are able to shift 3 10-bit samples into a 32bit word. Then you need a steady throughput of roughly 700kbps, and you can't expect to get this high throughput steadily over time, and I assume you are also interested in relative low latency here (e.g. of sub <100ms).

So I expect the problem here is not that the hardware can't handle the data throughput, the main limitiation will be the BLE link throughput.

Best regards,
Kenneth