PPI delay due to interrupt disable.

RE: PPI delay due to interrupt disable.

Karl Ylvisaker — Tue, 29 Nov 2022 08:36:25 GMT

Hello SunBae Yim,

[quote user="ParanBada0"]ADC sampling using the PPI function. Where is the source code for that part?[/quote]

If you just would like to see how to trigger SAADC sampling through PPI then you could take a look at the SAADC example in the SDK.
You could also see some examples of common SAADC usage in this repository.

[quote user="ParanBada0"]Is it done inside the soft device?[/quote]

No - the SoftDevice does use some PPI channels, but your application can use the channels that are not being used by the SoftDevice for whatever you would like.

[quote user="ParanBada0"]Or does it not work on the hardware inside the MCU?[/quote]

I am not sure that I understand this question, could you elaborate?

[quote user="ParanBada0"]For example, if the SAADC buffer size is 100, ADC sampling is executed 100 times and the value is stored in this RAM buffer.
Whenever ADC sampling is performed 100 times, I want to control the GPIO port in that part of the source code as follows.[/quote]

To achieve this you could set the GPIO as part of the DONE handling - just keep in mind that the processing of the DONE event could be postponed if there is a higher priority interrupt being processed at the time where it is generated, so the GPIO will then not show exactly when the 100 samples have completed.
If you want the GPIO to accurately reflect when the 100 samples have been collected you would have to set up a PPI channel between the GPIO and the SAADC DONE event - in this case, it would toggle immediately when the DONE event is generated.

Best regards,
Karl

RE: PPI delay due to interrupt disable.

ParanBada — Thu, 24 Nov 2022 11:12:53 GMT

Hello,

ADC sampling using the PPI function. Where is the source code for that part?
Is it done inside the soft device? Or does it not work on the hardware inside the MCU?

I want to check the code that works when performing ADC sampling through PPI.
For example, if the SAADC buffer size is 100, ADC sampling is executed 100 times and the value is stored in this RAM buffer.
Whenever ADC sampling is performed 100 times, I want to control the GPIO port in that part of the source code as follows.

#if FEATURE_FOR_SCOPE
nrf_gpio_pin_set(ADC_CLK_18);
nrf_gpio_pin_clear(ADC_CLK_18);
#endif

Then I want to check 100 ADC samplings through a logic analyzer.

Best Regards,

SunBae Yim.

RE: PPI delay due to interrupt disable.

Karl Ylvisaker — Mon, 21 Nov 2022 08:46:57 GMT

Hello again, SunBae Yim

[quote user="ParanBada0"]Your advice to increase the SAADC buffer size is good.[/quote]

I am glad to hear you say so! :)

[quote user="ParanBada0"]

Is there any documentation to refer to the SAADC buffer max size?

I want to set the SAADC Buffer size to 4127. Is it possible?

[/quote]

The SAADC uses EasyDMA and so the provided buffer must be in RAM.
Additionally, the maximum value of the MAXCNT register is 2^14 -1, and so that is the maximal buffer size for a single buffer.
You can read more about this in the SAADC EasyDMA documentation.

Best regards,
Karl

RE: PPI delay due to interrupt disable.

ParanBada — Sun, 20 Nov 2022 14:46:45 GMT

Hello,

Your advice to increase the SAADC buffer size is good.
How many SAADC buffers can I increase?
Is there any documentation to refer to the SAADC buffer max size?

I want to set the SAADC Buffer size to 4127. Is it possible?

Best Regards,

SunBae Yim.

RE: PPI delay due to interrupt disable.

Karl Ylvisaker — Wed, 16 Nov 2022 15:27:28 GMT

Hello again, SunBae Yim

[quote user="ParanBada0"]Why is there a delay when the ADC only samples through the PPI?[/quote]

Thank you for sharing the source code used for the measuring.
The GPIO is being set by the CPU when it goes to process the SAADC DONE event, which is not necessarily immediately after the SAADC has performed a sampling. The CPU could be busy handling a higher level interrupt, such as any SoftDevice activity, and thus the processing of the DONE event could be delayed. This is likely what is happening in your measurements.

If you want the GPIO to accurately portray when the DONE event occurs you should instead have a PPI channel connect the DONE event and a GPIO toggle task. This way, you will see that the DONE event is actually generated as soon as the sampling finishes, which should be [t_CONV + t_ACQ] after the 62.5 kHz pulse.

Additionally, I also note that you are using a SAADC buffer size of 1, which means that the CPU needs to intervene for every sample to provide the next buffer to use by the ADC. Instead, I would recommend increasing the SAADC buffer to a higher number, so that you only need to do processing every so often, instead of after each sampling.

Best regards,
Karl

RE: PPI delay due to interrupt disable.

ParanBada — Wed, 16 Nov 2022 13:56:31 GMT

I set SIM_IRQ_NO to 16 in the code.
The register value is saved in the RAM Buffer pd_voltage_buff while performing ADC sampling 16 times.
I am only doing the same ADC sampling. But why would the delay happen?

After 16 samplings are completed, the value is changed to voltage, LOG is displayed, and the value is transmitted through BLE.

Why is there a delay when the ADC only samples through the PPI?
please help me.

Best Regards.

SunBae Yim.

RE: PPI delay due to interrupt disable.

ParanBada — Wed, 16 Nov 2022 13:44:34 GMT

Here is my source code:

/*******************************************************************************
 * @file	meas_pd_voltage_simple.c
 * @author	
 * @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 "ada2200_spi.h"
#include "battery_saadc.h"
#include "ble_nus.h"
#include "meas_pd_voltage_simple.h"
#include "main.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)*2)

#define SIM_SAMPLES_IN_BUFFER 		1

static nrf_saadc_value_t pd_adc_buf[2][SIM_SAMPLES_IN_BUFFER];
bool  pd_adc_simple_start	= false;
bool  pd_adc_simple_end		= false;

#define PD_ADC_CNT			8
uint8_t SIM_IRQ_NO 			= 8;

float pd_voltage_buff[35]; /* For Cycle-8, Cycle-16, Cycle-24, Cycle-32 */ 
uint8_t	pd_voltage_buff_idx = 0;

static nrf_ppi_channel_t	m_ppi_channel;

extern char		ble_tx_buffer[BLE_NUS_MAX_DATA_LEN];


void simple_ppi_init(void)
{
    ret_code_t err_code;

    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;

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


void simple_sampling_event_enable(void)
{
    ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
    APP_ERROR_CHECK(err_code);
}


void simple_sampling_event_disable(void)
{
	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 */
{
	
	float pd_voltage_sum = 0.0f;

    if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {	
#if FEATURE_FOR_SCOPE    
		nrf_gpio_pin_set(ADC_CLK_18);
		nrf_gpio_pin_clear(ADC_CLK_18);
#endif	
	
        ret_code_t err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SIM_SAMPLES_IN_BUFFER);
		APP_ERROR_CHECK(err_code);

		pd_voltage_buff[pd_voltage_buff_idx] = p_event->data.done.p_buffer[0];
		pd_voltage_buff_idx++;

		if(pd_voltage_buff_idx == SIM_IRQ_NO) {
			pd_adc_simple_end = true;
			pd_adc_simple_start = false;

			simple_mesurement_stop();

			pd_voltage_sum = 0;

			for(uint8_t i = 0; i < SIM_IRQ_NO; i++) {
				
				pd_voltage_buff[i] = PD_VOUT_IN_MILLI_VOLTS(pd_voltage_buff[i]);
				pd_voltage_buff[i] = pd_voltage_buff[i] * -1;
				pd_voltage_sum += pd_voltage_buff[i];
			}

			for(uint8_t i = 0; i < SIM_IRQ_NO; i++) {
				printf(" %f ", pd_voltage_buff[i]);
			}

			printf("\r\nTh%f\r\n\r\n", pd_voltage_sum);
			sprintf(ble_tx_buffer, "Th%f\r\n", pd_voltage_sum);
			data_tx_handler(ble_tx_buffer);
		}
    }
}


void simple_adc_init(void)
{
	static nrfx_saadc_config_t default_config;
	default_config.resolution 			= (nrf_saadc_resolution_t)NRFX_SAADC_CONFIG_RESOLUTION;	/* Resolution is 10bits */
	default_config.oversample 			= (nrf_saadc_oversample_t)NRFX_SAADC_CONFIG_OVERSAMPLE;	/* Over Sampling Disabled */
	default_config.interrupt_priority 	= NRFX_SAADC_CONFIG_IRQ_PRIORITY;						/* Interrupt Priority is 0(Highest) */
	default_config.low_power_mode 		= NRFX_SAADC_CONFIG_LP_MODE;							/* Low Power Mode is Disabled */

	static nrf_saadc_channel_config_t config;
	config.resistor_p 	= NRF_SAADC_RESISTOR_DISABLED;
	config.resistor_n 	= NRF_SAADC_RESISTOR_DISABLED;
	config.gain			= NRF_SAADC_GAIN1_6;
	config.reference	= NRF_SAADC_REFERENCE_INTERNAL;
	config.acq_time		= NRF_SAADC_ACQTIME_3US;
	config.mode			= NRF_SAADC_MODE_DIFFERENTIAL;
	config.burst		= NRF_SAADC_BURST_DISABLED;
	config.pin_p		= (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN0);
	config.pin_n		= (nrf_saadc_input_t)(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)
{
	nrf_drv_saadc_uninit();
	nrf_drv_saadc_channel_uninit(0);
}


void simple_irq_init(void){
    ret_code_t err_code;

	/* 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, NULL);
    APP_ERROR_CHECK(err_code);

    nrfx_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
}


void simple_irq_uninit(void){

	nrfx_gpiote_in_event_disable(ADA2200_SYNCO_PIN);
	nrfx_gpiote_in_uninit(ADA2200_SYNCO_PIN);
}


void simple_mesurement_start(void){

	battery_timer_stop();

	simple_irq_init();
	simple_adc_init();
	simple_ppi_init();

	simple_sampling_event_enable();
}


void simple_mesurement_stop(void){

	battery_timer_start();

	simple_sampling_event_disable();
	simple_adc_uninit();
	simple_ppi_uninit();
	simple_irq_uninit();
}

Looking at simple_voltage_handler() in my source code, I make GPIO High->Low as follows.

#if FEATURE_FOR_SCOPE
nrf_gpio_pin_set(ADC_CLK_18);
nrf_gpio_pin_clear(ADC_CLK_18);
#endif

This code represents a green clock. And the lag appears.

RE: PPI delay due to interrupt disable.

Karl Ylvisaker — Wed, 16 Nov 2022 12:55:16 GMT

I am glad to hear that you improved the sampling through PPI! :)

[quote user="ParanBada0"]However, ADC sampling may be delayed as shown by the arrow in the figure.[/quote]

What exactly are the green lines set by? What are you scoping here, and where exactly is the setup for this in your code?
It seems to me that the green lines are not exactly aligned with the 62.5 kHz input, and so I suspect that the delay here is not an actual delay of the sampling, but rather a delay on the processing of the tasks/events on the measuring side.
Since PPI is used to trigger the sampling then the SAMPLE task will be triggered immediately by the triggering event.

Best regards,
Karl

RE: PPI delay due to interrupt disable.

ParanBada — Wed, 16 Nov 2022 10:53:43 GMT

Hello,

I improved the ADC sampling using PPI technique. It performs ADC sampling in synchronization with an external 62.5KHz clock.

However, ADC sampling may be delayed as shown by the arrow in the figure.
Why is there such a delay? What is the solution?
This is a very important and urgent issue.
I would appreciate it if you could help me.

Best Regards,

SunBae Yim.

RE: PPI delay due to interrupt disable.

Karl Ylvisaker — Tue, 15 Nov 2022 14:22:11 GMT

Hello SunBae Yim,

Thank you for your patience with this.

Briefly looking through the provided code it looks alright to me,
is there anything specifically you would like for me to take a look at in the code? Is there anything that is not working as expected?

Two minor comment:

- it seems that you do not check the error the returned error code from nrf_drv_saadc_buffer_convert, which I would recommend that you do.

- you have a lot of clutter in the code; magic numbers and commented out code lines. To increase maintainability I would recommend that you replace the magic numbers with appropriate defines, and that you move the scrap code into a separate file if you feel like you might need it again later.

[quote user="ParanBada0"]Is it correct to use this formula? Or should the formula be changed?[/quote]

Yes, this is correct.
The formula can be derived from the Digital Output section in the SAADC documentation.

Best regards,
Karl

RE: PPI delay due to interrupt disable.

ParanBada — Wed, 09 Nov 2022 12:08:39 GMT

My source code is here;

/*******************************************************************************
 * @file	
 * @author	
 * @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 "app_timer.h"
#include "nrf_drv_timer.h"
#include "nrf_delay.h"
#include "nrf_drv_ppi.h"
#include "ada2200_spi.h"
#include "ble_nus.h"
#include "fstorage.h"
#include "measurements.h"
#include "meas_pd_voltage_full.h"
#include "mcp4725_i2c.h"
#include "ad5272_i2c.h"
#include "main_timer.h"
#include "battery_saadc.h"
#include "main.h"

#define FULL_REF_VOLTAGE_IN_MILLIVOLTS   	600.0f                                     /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
#define FULL_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 FULL_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 FULL_VOUT_IN_MILLI_VOLTS(ADC_VALUE)\
				((((ADC_VALUE) * FULL_REF_VOLTAGE_IN_MILLIVOLTS) / FULL_ADC_RES_10BITS) * FULL_PRE_SCALING_COMPENSATION)

#define FULL_SAMPLES_IN_BUFFER 		1
static nrf_saadc_value_t pd_full_adc_buf[2][FULL_SAMPLES_IN_BUFFER];
bool  pd_adc_full_start	= false;


uint8_t led_full_list[6];
uint8_t pd_full_list[12];

uint8_t led_full_list_a[6]	= {1,2,3,4,5,6};
uint8_t pd_full_list_a[12]	= {5,6,7,8,9,10,15,16,17,18,19,20};

uint8_t led_full_list_b[6]	= {7,8,9,10,11,12};
uint8_t pd_full_list_b[12]	= {6,5,4,3,2,1,16,15,14,13,12,11};

uint8_t led_full_list_c[6]	= {13,14,15,16,17,18};
uint8_t pd_full_list_c[12]	= {15,16,17,18,19,20,5,6,7,8,9,10};

uint8_t led_full_list_d[6]	= {19,20,21,22,23,24};
uint8_t pd_full_list_d[12]	= {16,15,14,13,12,11,6,5,4,3,2,1};


static uint16_t FULL_DELAY_CLK = 0;
static bool full_main_delay = false;
static bool full_main_testing = false;
#define full_main_clock_delay(delay_cnt) 	full_main_delay = true;\
										full_main_testing = false;\
										FULL_DELAY_CLK = delay_cnt;

#define FULL_CYCLE_CNT 			32	/* Dummy=16, Cycle_Max_Cnt=32*/
/* ----------------  +  --------                         */
/*       Dummy 16       Cycle = 8                        */
/*                                                       */
/* ----------------  +  ----------------                 */
/*       Dummy 16       Cycle = 16                       */
/*                                                       */
/* ----------------  +  ------------------------         */
/*       Dummy 16       Cycle = 24                       */
/*                                                       */
/* ----------------  +  -------------------------------- */
/*       Dummy 16       Cycle = 32                       */
/*                                                       */

#define FULL_CYCLE_SEND_CNT 	12

static float	full_cycle_buff[FULL_CYCLE_CNT] = {0,};
static float	full_cycle_send_buff[FULL_CYCLE_SEND_CNT] = {0,};

uint8_t	FULL_IRQ_NO			= 7;
#define FULL_PD_NO			11
#define FULL_LED_NO			5

static int16_t 	buf_seq		= 0;
static int16_t 	irq_no 		= 0;
static int8_t 	pd_no 		= 0;
static int8_t 	led_no 		= 0;

extern bool pd_adc_full_a_start; 
extern bool pd_adc_full_a_end; 

extern bool pd_adc_full_b_start; 
extern bool pd_adc_full_b_end; 

extern bool pd_adc_full_c_start; 
extern bool pd_adc_full_c_end; 

extern bool pd_adc_full_d_start;
extern bool pd_adc_full_d_end; 


static nrf_ppi_channel_t	m_ppi_channel;

extern char		ble_tx_buffer[BLE_NUS_MAX_DATA_LEN];


void full_ppi_init(void)
{
    ret_code_t err_code;

    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 full_ppi_uninit(void)
{
    ret_code_t err_code;

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


void full_sampling_event_enable(void)
{
    ret_code_t err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
    APP_ERROR_CHECK(err_code);
}


void full_sampling_event_disable(void)
{
	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 inline void full_main_meas_process(void)
{
	static float sum = 0.0f;

	if(irq_no < FULL_IRQ_NO) {
		irq_no++;
	} else if(irq_no >= FULL_IRQ_NO) {

		///////////////////////////////////////////				/* Calculation Cycle-8, Cycle-16, Cycle-24, Cycle-32 */
		for(uint8_t i = 0; i <= FULL_IRQ_NO; i++) {
			sum += full_cycle_buff[i];
		}

		full_cycle_send_buff[buf_seq] = sum;
//#if FEATURE_PRINTF
//		printf("\r\n===============\r\n");
//		printf("sum = %f\r\nfull_cycle_send_buff=\r\n", sum);
//
//		for(uint8_t i = 0; i < FULL_CYCLE_SEND_CNT; i++) {
//			printf("<%d>= %f\r\n", i, full_cycle_send_buff[i]);
//		}
//		printf("===============\r\n\r\n");
//#endif

		sum = 0;

		for(uint8_t i = 0; i < FULL_CYCLE_CNT; i++) {
			full_cycle_buff[i] = 0.0f;
		}

		buf_seq++;
		irq_no = 0;
		
		///////////////////////////////////////////				/* PD Changed */
		if(pd_no < FULL_PD_NO) {
			
			pd_no++;
#if FEATURE_PRINTF
			printf("\r\nPD changed(a) to %d ---------------------------\r\n\r\n", pd_no);
#endif

			led_pd_matching_value_set(led_full_list[led_no], pd_full_list[pd_no]); /* MCP4725 DAC setting and PD on */
			full_main_clock_delay(m_config.pd_delay_us/16);

		} else if(pd_no >= FULL_PD_NO) {
			pd_no = 0;
			buf_seq = 0;

			printf("Tj%d,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f\r\n", led_full_list[led_no], full_cycle_send_buff[0], full_cycle_send_buff[1], full_cycle_send_buff[2], full_cycle_send_buff[3], full_cycle_send_buff[4], full_cycle_send_buff[5], full_cycle_send_buff[6], full_cycle_send_buff[7], full_cycle_send_buff[8], full_cycle_send_buff[9], full_cycle_send_buff[10], full_cycle_send_buff[11]);
			sprintf(ble_tx_buffer, "Tj%d,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f\r\n", led_full_list[led_no], full_cycle_send_buff[0], full_cycle_send_buff[1], full_cycle_send_buff[2], full_cycle_send_buff[3], full_cycle_send_buff[4], full_cycle_send_buff[5], full_cycle_send_buff[6], full_cycle_send_buff[7], full_cycle_send_buff[8], full_cycle_send_buff[9], full_cycle_send_buff[10], full_cycle_send_buff[11]);
			data_tx_handler(ble_tx_buffer);
			
#if FEATURE_PRINTF
			printf(">>>>> SEND 12 data <<<<<\r\n");
			printf("PD changed(b) to %d ---------------------------\r\n", pd_no);
#endif
			for(uint8_t i = 0; i < FULL_CYCLE_SEND_CNT; i++) {
				full_cycle_send_buff[i] = 0.0f;
			}

			/////////////////////////////////////////////
			led_pd_matching_value_set(led_full_list[led_no], pd_full_list[pd_no]); /* MCP4725 DAC setting and PD on */
//			full_main_clock_delay(m_config.pd_delay_us/16);				/* PD와 LED 딜레이가 이중으로 적용되므로 하나 막는다. */
			/////////////////////////////////////////////

			////////////////////////////////////////////////////	/* LED Changed */
			if(led_no < FULL_LED_NO) {
				led_no++;
#if FEATURE_PRINTF
				printf("LED changed to %d ---------------------------\r\n", led_no);
#endif
				////////////////////////////////////////////////
				led_on(led_full_list[led_no]);
				full_main_clock_delay(m_config.led_delay_us/16);
				////////////////////////////////////////////////

			} else if(led_no >= FULL_LED_NO) {
				if(pd_adc_full_a_start == true) {
					pd_adc_full_a_start = false;
					pd_adc_full_a_end = true;
								
					main_timer_start();
				}

				if(pd_adc_full_b_start == true) {
					pd_adc_full_b_start = false;
					pd_adc_full_b_end = true;
								
					main_timer_start();
				}

				if(pd_adc_full_c_start == true) {
					pd_adc_full_c_start = false;
					pd_adc_full_c_end = true;
								
					main_timer_start();
				}

				if(pd_adc_full_d_start == true) {
					pd_adc_full_d_start = false;
					pd_adc_full_d_end = true;
								
					main_timer_start();
				}
				
				printf("\r\n");
				full_adc_end();
				return;
			}
		}
	}
} 


static void full_voltage_handler(nrf_drv_saadc_evt_t const * p_event)	/* PD Voltage reading */
{

    if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {	
		static uint16_t main_delay_cnt = 0;
		static float imsi_voltage = 0;

#if FEATURE_FOR_SCOPE    
		nrf_gpio_pin_set(ADC_CLK_18);
		nrf_gpio_pin_clear(ADC_CLK_18);
#endif

        nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, FULL_SAMPLES_IN_BUFFER);
		imsi_voltage = FULL_VOUT_IN_MILLI_VOLTS(p_event->data.done.p_buffer[0]);

		if(full_main_testing == true) {

#if FEATURE_PRINTF
			printf("[buf_seq=%d], led_no=%d(%d), pd_no=%d(%d), irq_no=%d V=%f\r\n", buf_seq, led_no, led_full_list[led_no], pd_no, pd_full_list[pd_no], irq_no, imsi_voltage);
#endif			
			full_cycle_buff[irq_no] = imsi_voltage;

//#if FEATURE_PRINTF
//			printf("full_cycle_buff=\r\n");
//			switch(m_config.pd_adc_cnt){
//				case 8:
//					for(uint8_t i = 16; i < 24; i++) {
//						printf("<%d>= %f\r\n", i, full_cycle_buff[i]);
//					}
//					break;
//			
//				case 16:
//					for(uint8_t i = 16; i < 32; i++) {
//						printf("<%d>= %f\r\n", i, full_cycle_buff[i]);
//					}
//					break;
//			
//				case 24:
//					for(uint8_t i = 16; i < 40; i++) {
//						printf("<%d>= %f\r\n", i, full_cycle_buff[i]);
//					}
//					break;
//			
//				case 32:
//					for(uint8_t i = 16; i < 48; i++) {
//						printf("<%d>= %f\r\n", i, full_cycle_buff[i]);
//					}
//					break;
//			
//				default:
//					break;
//			}
//			printf("===============\r\n");
//		
//			printf("full_cycle_send_buff=\r\n");
//			for(uint8_t i = 0; i < FULL_CYCLE_SEND_CNT; i++) {
//				printf("<%d>= %f\r\n", i, full_cycle_send_buff[i]);
//			}
//			printf("===============\r\n\r\n");
//#endif

			full_main_meas_process();
			
		}else if(full_main_delay) {
#if FEATURE_PRINTF
			printf("m_d = %d  ", main_delay_cnt);
#endif			
			if(main_delay_cnt++ >= FULL_DELAY_CLK-1) {
#if FEATURE_PRINTF
				printf("\r\n");
#endif					
				main_delay_cnt = 0;
				full_main_delay = false;
				full_main_testing = true;
			}
		}
    }
}


void full_adc_init(void)
{
	static nrfx_saadc_config_t default_config;
	default_config.resolution			= (nrf_saadc_resolution_t)NRFX_SAADC_CONFIG_RESOLUTION; /* Resolution is 10bits */
	default_config.oversample			= (nrf_saadc_oversample_t)NRFX_SAADC_CONFIG_OVERSAMPLE; /* Over Sampling Disabled */
	default_config.interrupt_priority	= NRFX_SAADC_CONFIG_IRQ_PRIORITY;						/* Interrupt Priority is 0(Highest) */
	default_config.low_power_mode		= NRFX_SAADC_CONFIG_LP_MODE;							/* Low Power Mode is Disabled */

	static nrf_saadc_channel_config_t config;
	config.resistor_p	= NRF_SAADC_RESISTOR_DISABLED;
	config.resistor_n	= NRF_SAADC_RESISTOR_DISABLED;
	config.gain 		= NRF_SAADC_GAIN1_6;
	config.reference	= NRF_SAADC_REFERENCE_INTERNAL;
	config.acq_time 	= NRF_SAADC_ACQTIME_10US;
	config.mode 		= NRF_SAADC_MODE_DIFFERENTIAL;
	config.burst		= NRF_SAADC_BURST_DISABLED;
	config.pin_p		= (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN0);
	config.pin_n		= (nrf_saadc_input_t)(NRF_SAADC_INPUT_AIN1);
	
	ret_code_t err_code = nrf_drv_saadc_init(&default_config, full_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_full_adc_buf[0], FULL_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 full_adc_uninit(void)
{
#if FEATURE_PRINTF
	printf("pd_full_adc_uninit\r\n");
#endif

	nrf_drv_saadc_uninit();
	nrf_drv_saadc_channel_uninit(0);
}


void full_adc_start(void)
{

	battery_timer_stop();

	full_adc_init();
	full_irq_init();
	full_ppi_init();
	ada2200_start();

	full_sampling_event_enable();	

	if(pd_adc_full_a_start == true) {
#if FEATURE_PRINTF
		printf("\r\n===============================================================\r\n");
		printf("===== Full_A start ============================================\r\n");
		printf("===============================================================\r\n");
#endif
		memcpy(led_full_list, led_full_list_a, 6);
		memcpy(pd_full_list, pd_full_list_a, 12);
	}

	if(pd_adc_full_b_start == true) {
#if FEATURE_PRINTF
		printf("\r\n===============================================================\r\n");
		printf("===== Full_B start ============================================\r\n");
		printf("===============================================================\r\n");
#endif
		memcpy(led_full_list, led_full_list_b, 6);
		memcpy(pd_full_list, pd_full_list_b, 12);
	}

	if(pd_adc_full_c_start == true) {
#if FEATURE_PRINTF
		printf("\r\n===============================================================\r\n");
		printf("===== Full_C start ============================================\r\n");
		printf("===============================================================\r\n");
#endif
		memcpy(led_full_list, led_full_list_c, 6);
		memcpy(pd_full_list, pd_full_list_c, 12);
	}

	if(pd_adc_full_d_start == true) {
#if FEATURE_PRINTF
		printf("\r\n===============================================================\r\n");
		printf("===== Full_D start ============================================\r\n");
		printf("===============================================================\r\n");
#endif
		memcpy(led_full_list, led_full_list_d, 6);
		memcpy(pd_full_list, pd_full_list_d, 12);
	}

#if FEATURE_PRINTF
	printf("LED(0) ON, PD(0) ON\r\n");
#endif

	led_on(led_full_list[0]);

	led_pd_matching_value_set(led_full_list[0], pd_full_list[0]); /* MCP4725 DAC setting And PD on */
	nrf_delay_us(m_config.pd_delay_us);

#if FEATURE_PRINTF
	printf("\r\nfull_cycle_buff Cleared<start>\r\n");
	printf("full_cycle_send_buff Cleared<start>\r\n");
#endif
	
	for(uint8_t i = 0; i < FULL_CYCLE_CNT; i++) {
		full_cycle_buff[i] = 0.0f;
	}
	for(uint8_t i = 0; i < FULL_CYCLE_SEND_CNT; i++) {
		full_cycle_send_buff[i] = 0.0f;
	}

#if FEATURE_PRINTF
	printf("full_cycle_buff=\r\n");
	switch(m_config.pd_adc_cnt){
		case 8:
			for(uint8_t i = 16; i < 24; i++) {
				printf("<%d>= %f\r\n", i, full_cycle_buff[i]);
			}
			break;
	
		case 16:
			for(uint8_t i = 16; i < 32; i++) {
				printf("<%d>= %f\r\n", i, full_cycle_buff[i]);
			}
			break;
	
		case 24:
			for(uint8_t i = 16; i < 40; i++) {
				printf("<%d>= %f\r\n", i, full_cycle_buff[i]);
			}
			break;
	
		case 32:
			for(uint8_t i = 16; i < 48; i++) {
				printf("<%d>= %f\r\n", i, full_cycle_buff[i]);
			}
			break;
	
		default:
			break;
	}
	printf("===============\r\n");

	printf("===============\r\n");

	printf("full_cycle_send_buff=\r\n");
	for(uint8_t i = 0; i < FULL_CYCLE_SEND_CNT; i++) {
		printf("<%d>= %f\r\n", i, full_cycle_send_buff[i]);
	}
	printf("===============\r\n\r\n");
#endif

	buf_seq		= 0;
	irq_no		= 0;
	pd_no 		= 0;
	led_no		= 0;

	full_main_testing = true;
	
}


void full_adc_end(void) 
{
#if FEATURE_PRINTF
	printf("full_adc_end\r\n");
#endif

	battery_timer_start();

	ada2200_stop();
	full_sampling_event_disable();

	full_irq_uninit();
	full_adc_uninit();
	full_ppi_uninit();

#if FEATURE_PRINTF
	printf("\r\nfull_cycle_buff Cleared<end>\r\n");
	printf("full_cycle_send_buff Cleared<end>\r\n");
#endif

	for(uint8_t i = 0; i < FULL_CYCLE_CNT; i++) {
		full_cycle_buff[i] = 0.0f;
	}
	for(uint8_t i = 0; i < FULL_CYCLE_SEND_CNT; i++) {
		full_cycle_send_buff[i] = 0.0f;
	}

#if FEATURE_PRINTF
	printf("full_cycle_buff=\r\n");
	switch(m_config.pd_adc_cnt){
		case 8:
			for(uint8_t i = 16; i < 24; i++) {
				printf("<%d>= %f\r\n", i, full_cycle_buff[i]);
			}
			break;
	
		case 16:
			for(uint8_t i = 16; i < 32; i++) {
				printf("<%d>= %f\r\n", i, full_cycle_buff[i]);
			}
			break;
	
		case 24:
			for(uint8_t i = 16; i < 40; i++) {
				printf("<%d>= %f\r\n", i, full_cycle_buff[i]);
			}
			break;
	
		case 32:
			for(uint8_t i = 16; i < 48; i++) {
				printf("<%d>= %f\r\n", i, full_cycle_buff[i]);
			}
			break;
	
		default:
			break;
	}
	printf("===============\r\n");

	printf("===============\r\n");

	printf("full_cycle_send_buff=\r\n");
	for(uint8_t i = 0; i < FULL_CYCLE_SEND_CNT; i++) {
		printf("<%d>= %f\r\n", i, full_cycle_send_buff[i]);
	}
	printf("===============\r\n\r\n");
#endif

	led_off(99);
	pd_off(99);

	full_main_testing = false;
	full_main_delay = false;
}


void full_irq_init(void){
    ret_code_t err_code;
#if FEATURE_PRINTF
	printf("full_irq_init\r\n");
#endif

	/* 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, NULL);
    APP_ERROR_CHECK(err_code);

    nrfx_gpiote_in_event_enable(ADA2200_SYNCO_PIN, true);
}


void full_irq_uninit(void){
#if FEATURE_PRINTF
	printf("full_irq_uninit\r\n");
#endif	
	nrfx_gpiote_in_event_disable(ADA2200_SYNCO_PIN);
	nrfx_gpiote_in_uninit(ADA2200_SYNCO_PIN);
}

Please review whether PPI, EasyDMA, etc. are implemented well.

And I use 2 channels for ADC sampling with DIFFRENTIAL Mode. It takes a register value and calculates the actual voltage value using the following formula:

#define FULL_REF_VOLTAGE_IN_MILLIVOLTS   	600.0f                                     /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
#define FULL_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 FULL_ADC_RES_10BITS             	1024.0f                                    /**< Maximum digital value for 10-bit ADC conversion. */

#define FULL_VOUT_IN_MILLI_VOLTS(ADC_VALUE)\
				((((ADC_VALUE) * FULL_REF_VOLTAGE_IN_MILLIVOLTS) / FULL_ADC_RES_10BITS) * FULL_PRE_SCALING_COMPENSATION)

Is it correct to use this formula? Or should the formula be changed?

Best Regards,

SunBae Yim.

RE: PPI delay due to interrupt disable.

Karl Ylvisaker — Mon, 31 Oct 2022 13:23:46 GMT

Hello SunBae Yim,

It looks to me like your PPI might not be set up correctly. Could you share the section of your code in which this takes place?
When PPI is set up correctly you will not need the CPU to handle any interrupts, in order for the connected TASK to be triggered by the generated EVENT.
Therefore, there should be no delay on the triggering of the TASK as well, since it will happen as soon as the connected EVENT is generated.

Are you using the nRF5 SDK, and if so, are also using the SoftDevice in your project?

Best regards,
Karl