Triggering SAADC sampling in synchronous with GPIO HITOLOW transition.

RE: Triggering SAADC sampling in synchronous with GPIO HITOLOW transition.

Jørgen Holmefjord — Mon, 22 Feb 2021 10:21:40 GMT

Thanks, it is clear now.

The CONNECTED event is a software event, so this cannot be used to trigger any tasks through PPI. You will have to trigger the tasks from software. You can also use an additional compare event to trigger the tasks through PPI very close after the event is received. If you do not require the GPIO to toggle exactly when the CONNECTED event is received, you can start the timer in software to toggle the GPIO after the first 10ms have passed.

As far as I can see, you should be able to use the timer compare event that toggles the GPIO to trigger the START task of the timer that triggers SAADC sampling. This should trigger the first sampling 100us after the GPIO toggles. If you want to trigger a sample at the same time that the GPIO is toggled, you can also trigger the SAMPLE task from the timer event that toggles the GPIO(s). If you set a SAADC buffer size equal to the number of samples between GPIO toggling, you should be able to use the compare events from the GPIO timer to START the SAADC sampling at the regular interval that you have shown in your timing diagram.

[quote user="Kalrz "]I am confused about where to allocate the PPI event and tasks. Is it inside the callback handler of the SAADC?[/quote]

The address of the tasks and events are static and documented in the Registers section of each peripheral chapter in the product specifications. You should be able to configure this at any location in your code.

RE: Triggering SAADC sampling in synchronous with GPIO HITOLOW transition.

Kalrz — Fri, 19 Feb 2021 16:31:28 GMT

Hai Jorgen,

Sorry, I should have been more clear.

[quote userid="14926" url="~/f/nordic-q-a/71603/triggering-saadc-sampling-in-synchronous-with-gpio-hitolow-transition/295048#295048"]Can you create a timing diagram that shows the toggling of the LEDs and when you want the SAADC sampling to happen?[/quote]

/resized-image/__size/320x240/__key/communityserver-discussions-components-files/4/7532.img.jpg

(Please inform me if the image is not clear enough. I am not sure about it)

At the moment both the GPIOs are triggered via PPI using a single timer. SAADC sampling is triggered every 0.1ms using another timer through PPI. These two methods are clearly mentioned in my previous reply. Now as you can see from the timing diagram, I need my GPIO and SAADC sampling to be triggered at the CONNECTED event from the BLE application (As you suggested). How can I connect the CONNECTED event, GPIOs, and SAADC to be all triggered at the same time through PPI? Is it possible for you to provide a brief line of code just to show how it should be carried out? I am confused about where to allocate the PPI event and tasks. Is it inside the callback handler of the SAADC?

Thanks.

Best regards.

RE: Triggering SAADC sampling in synchronous with GPIO HITOLOW transition.

Jørgen Holmefjord — Thu, 18 Feb 2021 10:27:51 GMT

[quote user="Kalrz "]So should I use the same timer for both SAADC and GPIOs? ( which i believe is not the solution). Or should I use a separate PPI channel to assign the two timers (timer instance 1 and 2) to each other and then use another PPI channel to assign the timer instance 2 with SAADC for triggering sample? I don't quite understand this. So can you please elaborate?[/quote]

I may have misunderstood how and when you want to sample the SAADC. Can you create a timing diagram that shows the toggling of the LEDs and when you want the SAADC sampling to happen?

[quote user="Kalrz "]

Jørgen Holmefjord said:
separate GPIOTE channel as input (configured as watcher), and physically connect the output and input pins together externally.

At the moment, I would prefer any other method without an additional external physical connection.

[/quote]

If things are triggered by events over PPI, it should be possible to synchronize it with PPI forks, or multiple PPI channels, but it depends on how things are triggered, and the required timing accuracy.

RE: Triggering SAADC sampling in synchronous with GPIO HITOLOW transition.

Kalrz — Mon, 15 Feb 2021 20:59:40 GMT

Hello Jorgen,

Thank for the reply.

So let me see if I understood you correctly. Yes the GPIOs are configured in the output of GPIOTE.

    nrf_drv_gpiote_out_config_t config1 = GPIOTE_CONFIG_OUT_TASK_TOGGLE(true);
    nrf_drv_gpiote_out_config_t config2 = GPIOTE_CONFIG_OUT_TASK_TOGGLE(true);
   
    uint32_t err_code;

    err_code = nrfx_gpiote_out_init(GPIO_OUTPUT_PIN_NUMBER1, &config1);
    APP_ERROR_CHECK(err_code);
    err_code = nrfx_gpiote_out_init(GPIO_OUTPUT_PIN_NUMBER2, &config2);
    APP_ERROR_CHECK(err_code);

I have two PPI channels allocated for task and event mapping.

    nrf_ppi_channel_t ppi_channel1;
    nrf_ppi_channel_t ppi_channel2;
    
    err_code = nrf_drv_ppi_channel_alloc(&ppi_channel1);
    APP_ERROR_CHECK(err_code);
    err_code = nrf_drv_ppi_channel_alloc(&ppi_channel2);
    APP_ERROR_CHECK(err_code);

Then I use a timer to trigger at each 20ms. With the use of the code below, I manage to toggle the GPIOs alternatively.

uint32_t ticks_RED = nrfx_timer_ms_to_ticks(&timer, 20);

    nrf_drv_timer_compare(&timer, NRF_TIMER_CC_CHANNEL0, (ticks_RED/2), true);
    nrf_drv_timer_extended_compare(&timer, NRF_TIMER_CC_CHANNEL1, ticks_RED, NRF_TIMER_SHORT_COMPARE1_CLEAR_MASK, true);

Then I get the address of both event and task and assign them to each PPI channel and finally enable the channels and gpiote. PPI, timer and GPIOTE are initialized inside the main()

    compare_evt_addr1 = nrf_drv_timer_event_address_get(&timer, NRF_TIMER_EVENT_COMPARE0);
    gpiote_task_addr1 = nrf_drv_gpiote_out_task_addr_get(GPIO_OUTPUT_PIN_NUMBER1);

    compare_evt_addr2 = nrf_drv_timer_event_address_get(&timer, NRF_TIMER_EVENT_COMPARE1);
    gpiote_task_addr2 = nrf_drv_gpiote_out_task_addr_get(GPIO_OUTPUT_PIN_NUMBER2);
    
    err_code = nrf_drv_ppi_channel_assign(ppi_channel1, compare_evt_addr1, gpiote_task_addr1);
    APP_ERROR_CHECK(err_code);
    err_code = nrf_drv_ppi_channel_assign(ppi_channel2, compare_evt_addr2, gpiote_task_addr2);
    APP_ERROR_CHECK(err_code);
    
    err_code = nrf_drv_ppi_channel_enable(ppi_channel1);
    APP_ERROR_CHECK(err_code);
    err_code = nrf_drv_ppi_channel_enable(ppi_channel2);
    APP_ERROR_CHECK(err_code);

    nrf_drv_gpiote_out_task_enable(GPIO_OUTPUT_PIN_NUMBER1);
    nrf_drv_gpiote_out_task_enable(GPIO_OUTPUT_PIN_NUMBER2);

/***************************SAADC*****************************/

For the SAADC right now I am using a single channel with 12-bit resolution.

Here in SAADC I need to sample every 1ms or even lesser than that. Let's say 1ms. So I have a separate timer instance initialized for triggering sampling. Here I use PPI where the timer compare event of timer instance (2) is triggering sample task in SAADC.

void saadc_sampling_event_init(void)
{
    ret_code_t err_code;

    err_code = nrf_drv_ppi_init();
    APP_ERROR_CHECK(err_code);

    nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
    timer_cfg.bit_width = NRF_TIMER_BIT_WIDTH_32;
    err_code = nrf_drv_timer_init(&m_timer, &timer_cfg, timer_handler);
    APP_ERROR_CHECK(err_code);

    /* setup m_timer for compare event every 1ms */
    uint32_t ticks = nrf_drv_timer_ms_to_ticks(&m_timer, 1);
    nrf_drv_timer_extended_compare(&m_timer,
                                   NRF_TIMER_CC_CHANNEL0,
                                   ticks,
                                   NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK,
                                   false);
    nrf_drv_timer_enable(&m_timer);

    uint32_t timer_compare_event_addr = 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);
    APP_ERROR_CHECK(err_code);

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

void saadc_callback(nrf_drv_saadc_evt_t const * p_event)
{

    //NRF_LOG_INFO("SAADC event is %d", p_event->type);
    if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {
        ret_code_t err_code;

        err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SAMPLES_IN_BUFFER);
        APP_ERROR_CHECK(err_code);
        
        uint16_t value;
        value = p_event->data.done.p_buffer[];
        for(i=0; i<SAMPLES_IN_BUFFER; i++)
        {
        NRF_LOG_INFO("%d", p_event->data.done.p_buffer[i]);
        }
    }
}

[quote userid="14926" url="~/f/nordic-q-a/71603/triggering-saadc-sampling-in-synchronous-with-gpio-hitolow-transition/294434#294434"]You either need to use the event that toggles the GPIO to start the TIMER/SAADC sampling through PPI,[/quote]

If I am not wrong, the event that toggles the GPIO is

compare_evt_addr1 = nrf_drv_timer_event_address_get(&timer, NRF_TIMER_EVENT_COMPARE0);

So should I use the same timer for both SAADC and GPIOs? ( which i believe is not the solution). Or should I use a separate PPI channel to assign the two timers (timer instance 1 and 2) to each other and then use another PPI channel to assign the timer instance 2 with SAADC for triggering sample? I don't quite understand this. So can you please elaborate?

[quote userid="14926" url="~/f/nordic-q-a/71603/triggering-saadc-sampling-in-synchronous-with-gpio-hitolow-transition/294434#294434"] separate GPIOTE channel as input (configured as watcher), and physically connect the output and input pins together externally.[/quote]

At the moment, I would prefer any other method without an additional external physical connection.

Thanks in advance.

RE: Triggering SAADC sampling in synchronous with GPIO HITOLOW transition.

Jørgen Holmefjord — Mon, 15 Feb 2021 15:36:40 GMT

Hi,

[quote user=""]

1. How can I use the interrupt at the rising edge of the GPIO1 to trigger the SAADC sampling? This is crucial because the first 100 readings from the SAADC will be the analog value from the photosensor caused due to LED1 and the next 100 readings will be generated due to LED2.

2. Is this approach the correct method or is there any other better method?

[/quote]

If GPIO1 is configured as an output in GPIOTE, you will not get any interrupt on the rising edge of this GPIO. You either need to use the event that toggles the GPIO to start the TIMER/SAADC sampling through PPI, or setup a separate GPIOTE channel as input (configured as watcher), and physically connect the output and input pins together externally.

[quote user=""]3. This question covers a different issue but still, I would like to ask. My application is using a BLE features to send the analog value to a central device. Values are sent to the central device inside the saadc_callback handler. If I had to start the sampling and the GPIO output state transition only after a successful connection is established with the central device, what would be the right way to program the firmware? Are there existing example codes explaining similar usage? (I believe the answer is YES. But I was not able to find any. Please help me out with this.)[/quote]

The simplest solution would be to enable the PPI channel(s) when you receive the CONNECTED event in the application, and similarly, disable the PPI channel(s) when you receive the DISCONNECTED event.

Best regards,
Jørgen