Using the DPPI on the nRF5340 to enable the ADC and GPIO toggling based on a hardware timer

RE: Using the DPPI on the nRF5340 to enable the ADC and GPIO toggling based on a hardware timer

Kenneth — Wed, 27 Jul 2022 08:43:21 GMT

I must admit I was not paying attention to whether you were using START or SAMPLE, my main focus was how to setup publish to several subscribers. But you are right, you should use SAMPLE to actually SAMPLE the analog input, while START simply prepare the ADC for the SAMPLE task. In general you may find the hardware description useful:
https://infocenter.nordicsemi.com/topic/ps_nrf5340/saadc.html

In terms of which api to use when setting up the publish and subscribe, I was looking at how you can write to the registers directly, but you can also setup this with a more convenient api like you have found also (they do the same, one is just a wrapper around the other).

Glad to hear you have made it work!

Kenneth

RE: Using the DPPI on the nRF5340 to enable the ADC and GPIO toggling based on a hardware timer

Ted H — Tue, 26 Jul 2022 15:48:16 GMT

Kenneth, the SAADC still doesn't work with your code but I managed to make it work!

The SAADC driver worked with the following code, but this helper layer didn't work to assign a single event to trigger multiple tasks:

	nrfx_gppi_channel_endpoints_setup(dppi_channel,
		nrfx_timer_event_address_get(&timer1, NRF_TIMER_EVENT_COMPARE0),
		nrf_saadc_task_address_get(NRF_SAADC, NRF_SAADC_TASK_SAMPLE));
	
	err = nrfx_dppi_channel_enable(dppi_channel);
	if (err != NRFX_SUCCESS) {
		LOG_ERR("Failed to enable (D)PPI channel, error: %08x", err);
		return;
	}
	
	nrfx_dppi_channel_enable(dppi_channel);

So, instead of setting:
NRF_SAADC->SUBSCRIBE_START = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | dppi_channel_0;

I modified it to:
NRF_SAADC->SUBSCRIBE_SAMPLE = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | dppi_channel_0;

Then the GPIO pin toggling worked simultaneously with the SAADC read!

Here is the portion of the code that allowed me to do that:

	uint8_t dppi_channel;
	err = nrfx_dppi_channel_alloc(&dppi_channel);
	if (err != NRFX_SUCCESS) {
		LOG_ERR("(D)PPI channel allocation error: %08x", err);
		return;
	}

	NRF_TIMER1->PUBLISH_COMPARE[0] = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | dppi_channel;
	NRF_SAADC->SUBSCRIBE_SAMPLE = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | dppi_channel;
	NRF_GPIOTE->SUBSCRIBE_OUT[1] = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | dppi_channel;

	nrfx_dppi_channel_enable(dppi_channel);	
	LOG_INF("DPPI configured");

	nrfx_gpiote_out_task_enable(PIN);
	LOG_INF("nrfx_gpiote initialized");

	nrfx_timer_enable(&timer1);
	printk("TIMER1 started\n");

Can you clarify why the original helper layer didn't work but this publish/subscribe method worked? I was able to find another approach here, and it ties the publish and subscribe sets like this:

	/* Tie it all together */
	nrf_gpiote_publish_set(NRF_GPIOTE_EVENTS_IN_0, dppi_ch_1);
	nrf_gpiote_publish_set(NRF_GPIOTE_EVENTS_IN_1, dppi_ch_2);
	nrf_timer_subscribe_set(timer.p_reg, NRF_TIMER_TASK_START, dppi_ch_1);
	nrf_timer_subscribe_set(timer.p_reg, NRF_TIMER_TASK_STOP, dppi_ch_2);
	nrf_timer_subscribe_set(timer.p_reg, NRF_TIMER_TASK_CAPTURE0, dppi_ch_2);

I wonder which approach works best with setting up the DPPI module because I intend to use the DPPI more widely now and then. Can you explain why this approach failed to read the ADC channel but only the GPIO pin toggling worked:

	/* Allocate a (D)PPI channel. */
	uint8_t dppi_channel_0, dppi_channel_01;
	err = nrfx_dppi_channel_alloc(&dppi_channel_0);
	if (err != NRFX_SUCCESS) {
		LOG_ERR("(D)PPI channel 0 allocation error: %08x", err);
		return;
	}

	/* Configure endpoints of the channel so that the TIMER1 CAPTURE0
	 * event is connected with the SAADC SAMPLE task. This means that each time
	 * TIMER1 reaches it's set compare value, the SAADC will sample all 
	 * enabled channel once.
	 */
	nrfx_gppi_channel_endpoints_setup(dppi_channel_0,
		nrfx_timer_event_address_get(&timer1, NRF_TIMER_EVENT_COMPARE0),
		nrf_saadc_task_address_get(NRF_SAADC, NRF_SAADC_TASK_SAMPLE));

	/* Enable (D)PPI channel. */
	err = nrfx_dppi_channel_enable(dppi_channel_0);
	if (err != NRFX_SUCCESS) {
		LOG_ERR("Failed to enable (D)PPI channel 0, error: %08x", err);
		return;
	}

	nrfx_gppi_channel_endpoints_setup(dppi_channel_1,
		nrfx_timer_event_address_get(&timer1, NRF_TIMER_EVENT_COMPARE0),
		nrfx_gpiote_out_task_addr_get(PIN));

	/* Enable (D)PPI channel. */
	err = nrfx_dppi_channel_enable(dppi_channel_1);
	if (err != NRFX_SUCCESS) {
		LOG_ERR("Failed to enable (D)PPI channel 1, error: %08x", err);
		return;
	}

	nrfx_gppi_channels_enable((1 << dppi_channel_0) | (1 << dppi_channel_1));
	LOG_INF("DPPI configured");

	nrfx_gpiote_out_task_enable(PIN);
	LOG_INF("nrfx_gpiote initialized");

	nrfx_timer_enable(&timer1);
	printk("TIMER1 started\n");

Thank you for leading to the answer I was looking for!

Ted

RE: Using the DPPI on the nRF5340 to enable the ADC and GPIO toggling based on a hardware timer

Kenneth — Tue, 26 Jul 2022 11:04:27 GMT

Try something like this:

	/* Allocate a (D)PPI channel. */
	uint8_t dppi_channel_0;
	err = nrfx_dppi_channel_alloc(&dppi_channel_0);
	if (err != NRFX_SUCCESS) {
		LOG_ERR("(D)PPI channel 0 allocation error: %08x", err);
		return;
	}

	NRF_TIMER1->PUBLISH_COMPARE[0] = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | dppi_channel_0;
	NRF_SAADC->SUBSCRIBE_START = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | dppi_channel_0;
	NRF_GPIOTE->SUBSCRIBE_OUT[1] = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | dppi_channel_0;

	static uint32_t dppi_all_channels_mask;

	dppi_all_channels_mask = (1 << dppi_channel_0);

	nrfx_gppi_channels_enable(dppi_all_channels_mask);	

	LOG_INF("DPPI configured");

	nrfx_gpiote_out_task_enable(PIN);

	LOG_INF("nrfx_gpiote initialized");

	nrfx_timer_enable(&timer1);
	printk("TIMER1 started\n");

RE: Using the DPPI on the nRF5340 to enable the ADC and GPIO toggling based on a hardware timer

Ted H — Mon, 25 Jul 2022 21:25:26 GMT

So here is what I did but I still cannot get the ADC read working... The GPIO pin toggling only works. Am I missing something here?

	/* Allocate a (D)PPI channel. */
	uint8_t dppi_channel_0, dppi_channel_1;
	err = nrfx_dppi_channel_alloc(&dppi_channel_0);
	if (err != NRFX_SUCCESS) {
		LOG_ERR("(D)PPI channel 0 allocation error: %08x", err);
		return;
	}
	err = nrfx_dppi_channel_alloc(&dppi_channel_1);
	if (err != NRFX_SUCCESS) {
		LOG_ERR("(D)PPI channel 1 allocation error: %08x", err);
		return;
	}
	
	NRF_TIMER1->PUBLISH_COMPARE[0] = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | dppi_channel_0;
	NRF_SAADC->SUBSCRIBE_START = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | dppi_channel_0;

	NRF_TIMER1->PUBLISH_COMPARE[0] = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | dppi_channel_1;
	NRF_GPIOTE->SUBSCRIBE_OUT[1] = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | dppi_channel_1;

	static uint32_t dppi_all_channels_mask;

	dppi_all_channels_mask = (1 << dppi_channel_0) | (1 << dppi_channel_1);

	nrfx_gppi_channels_enable(dppi_all_channels_mask);	

	LOG_INF("DPPI configured");

	nrfx_gpiote_out_task_enable(PIN);

	LOG_INF("nrfx_gpiote initialized");

	nrfx_timer_enable(&timer1);
	printk("TIMER1 started\n");

RE: Using the DPPI on the nRF5340 to enable the ADC and GPIO toggling based on a hardware timer

Kenneth — Mon, 25 Jul 2022 10:07:27 GMT

I can find various code that show this to some degree, for instance ppi_init() from esb.c

nrfx_dppi_channel_alloc(&ppi_ch_radio_ready_timer_start);
nrfx_dppi_channel_alloc(&ppi_ch_radio_address_timer_stop);
nrfx_dppi_channel_alloc(&ppi_ch_timer_compare0_radio_disable);
nrfx_dppi_channel_alloc(&ppi_ch_timer_compare1_radio_txen);

NRF_RADIO->PUBLISH_READY          = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | ppi_ch_radio_ready_timer_start;
ESB_SYS_TIMER->SUBSCRIBE_START    = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | ppi_ch_radio_ready_timer_start;
// here you can add several subscribe if you like.
NRF_RADIO->PUBLISH_ADDRESS        = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | ppi_ch_radio_address_timer_stop;
ESB_SYS_TIMER->SUBSCRIBE_SHUTDOWN = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | ppi_ch_radio_address_timer_stop;
// here you can add several subscribe if you like.
ESB_SYS_TIMER->PUBLISH_COMPARE[0] = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | ppi_ch_timer_compare0_radio_disable;
NRF_RADIO->SUBSCRIBE_DISABLE      = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | ppi_ch_timer_compare0_radio_disable;
// here you can add several subscribe if you like.
ESB_SYS_TIMER->PUBLISH_COMPARE[1] = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | ppi_ch_timer_compare1_radio_txen;
NRF_RADIO->SUBSCRIBE_TXEN         = DPPIC_SUBSCRIBE_CHG_EN_EN_Msk | ppi_ch_timer_compare1_radio_txen;
// here you can add several subscribe if you like.

static uint32_t ppi_all_channels_mask;

ppi_all_channels_mask = (1 << ppi_ch_radio_ready_timer_start) | (1 << ppi_ch_radio_address_timer_stop) |
						(1 << ppi_ch_timer_compare0_radio_disable) | (1 << ppi_ch_timer_compare1_radio_txen);
							
nrfx_gppi_channels_enable(ppi_all_channels_mask);

RE: Using the DPPI on the nRF5340 to enable the ADC and GPIO toggling based on a hardware timer

Ted H — Fri, 22 Jul 2022 16:51:05 GMT

Hello Kenneth,

Thanks for the info. Do you have any SDK examples available for subscribing to those DPPI channels? It seems like the nrfx drivers do not offer many examples in the SDK...

Ted

RE: Using the DPPI on the nRF5340 to enable the ADC and GPIO toggling based on a hardware timer

Kenneth — Fri, 22 Jul 2022 11:09:22 GMT

Hi,

When you alloc a dppi channel, then you can use this channel to connect severval publishers and subcribers, e.g. in this case you want to set the allocated channel to the TIMER->PUBLISH_COMPARE[] register:
https://infocenter.nordicsemi.com/topic/ps_nrf5340/timer.html#register.PUBLISH_COMPARE

And then for each peripheral that you want to do something based on this event, then you need to set the subscribe, e.g. in your case set the came dppi channel to SAADC->SUBSCRIBE_START and GPIOTE->SUBSCRIBE_OUT[]:
https://infocenter.nordicsemi.com/topic/ps_nrf5340/saadc.html#register.SUBSCRIBE_START
https://infocenter.nordicsemi.com/topic/ps_nrf5340/gpiote.html#register.SUBSCRIBE_OUT

Best regards,
Kenneth