GPIOTE interrupts with around 30us latency?

RE: GPIOTE interrupts with around 30us latency?

Einar Thorsrud — Wed, 22 Jan 2025 13:10:46 GMT

Hi Fernando,

Yes, that is right. If you trigger NRF_TIMER_TASK_CAPTURE0, the result will be in the CC register for channel 0, and the next time you capture on the same channel, it will be overwritten. There are several channels though, so you could map different events to different capture tasks via PPI (in this case you could map each of the three GPIOTE events to separate capture tasks).

RE: GPIOTE interrupts with around 30us latency?

Fernando Fontes — Tue, 21 Jan 2025 18:11:35 GMT

Hi Einar,

Yes, I could do that, but I'm cleaning the timer before starting the reading and the time of flight should not exceed 1ms. So, there turn around is not an issue with the 32 bit counter.

I only have one question left. If I understood correctly ppi will capture the timer value and store it in the timer.p_reg register. Since I'm doing NRF_TIMER_TASK_CAPTURE0, the result will be on CHANNEL0 right? Is it possible that gpiote_event_handler is not fast enough and I could have the ppi capturing the value between two pulses and overwriting the register?

Best regards,

Fernando Fontes

RE: GPIOTE interrupts with around 30us latency?

Einar Thorsrud — Tue, 21 Jan 2025 15:06:47 GMT

Hi Fernando,

Yes, this is what I had in mind, and it looks good. With this, the interrupt latency does not affect the measurements. Note that depending on what fits best, you can also clear the timer like this so you will get an absolute cycle count between each event and not have to handle the timer wraping around.

RE: GPIOTE interrupts with around 30us latency?

Fernando Fontes — Fri, 17 Jan 2025 18:32:28 GMT

Ok, I've done the following:

#if defined(__ZEPHYR__)
    IRQ_DIRECT_CONNECT(NRFX_IRQ_NUMBER_GET(NRF_TIMER_INST_GET(TIMER_INST_IDX)), IRQ_PRIO_LOWEST,
                       NRFX_TIMER_INST_HANDLER_GET(TIMER_INST_IDX), 0);
    IRQ_DIRECT_CONNECT(NRFX_IRQ_NUMBER_GET(NRF_GPIOTE), IRQ_PRIO_LOWEST, NRFX_GPIOTE_INST_HANDLER_GET(GPIOTE_INST_IDX),
                       0);
#endif

    nrfx_gpiote_t const gpiote_inst = NRFX_GPIOTE_INSTANCE(GPIOTE_INST_IDX);
    status = nrfx_gpiote_init(&gpiote_inst, IRQ_PRIO_LOWEST);
    if (status != NRFX_SUCCESS && status != NRFX_ERROR_ALREADY_INITIALIZED)
    {
        LOG_ERR("Error while configuring gpiote for ToF reading: %d", status);
        return EXIT_FAILURE;
    }

    uint8_t start_pin_ch, stop_pin_ch, errb_pin_ch;
    status = nrfx_gpiote_channel_alloc(&gpiote_inst, &start_pin_ch);
    if (status != NRFX_SUCCESS)
    {
        LOG_ERR("Error while alloc channel for ToF reading!");
        return EXIT_FAILURE;
    }

    status = nrfx_gpiote_channel_alloc(&gpiote_inst, &stop_pin_ch);
    if (status != NRFX_SUCCESS)
    {
        LOG_ERR("Error while alloc channel for ToF reading!");
        return EXIT_FAILURE;
    }

    status = nrfx_gpiote_channel_alloc(&gpiote_inst, &errb_pin_ch);
    if (status != NRFX_SUCCESS)
    {
        LOG_ERR("Error while alloc channel for ToF reading!");
        return EXIT_FAILURE;
    }

    static const nrf_gpio_pin_pull_t rising_input_config = NRF_GPIO_PIN_PULLDOWN;
    static const nrf_gpio_pin_pull_t falling_input_config = NRF_GPIO_PIN_PULLUP;

    const nrfx_gpiote_trigger_config_t start_rising_trigger_config = {
        .trigger = NRFX_GPIOTE_TRIGGER_LOTOHI,
        .p_in_channel = &start_pin_ch,
    };
    const nrfx_gpiote_trigger_config_t stop_rising_trigger_config = {
        .trigger = NRFX_GPIOTE_TRIGGER_LOTOHI,
        .p_in_channel = &stop_pin_ch,
    };
    const nrfx_gpiote_trigger_config_t errb_falling_trigger_config = {
        .trigger = NRFX_GPIOTE_TRIGGER_HITOLO,
        .p_in_channel = &errb_pin_ch,
    };
    static const nrfx_gpiote_handler_config_t handler_config = {
        .handler = gpiote_event_handler,
    };

    static nrfx_gpiote_input_pin_config_t start_cfg;
    start_cfg.p_handler_config = &handler_config;
    start_cfg.p_pull_config = &rising_input_config;
    start_cfg.p_trigger_config = &start_rising_trigger_config;

    static nrfx_gpiote_input_pin_config_t stop_cfg;
    stop_cfg.p_handler_config = &handler_config;
    stop_cfg.p_pull_config = &rising_input_config;
    stop_cfg.p_trigger_config = &stop_rising_trigger_config;

    static nrfx_gpiote_input_pin_config_t errb_cfg;
    errb_cfg.p_handler_config = &handler_config;
    errb_cfg.p_pull_config = &falling_input_config;
    errb_cfg.p_trigger_config = &errb_falling_trigger_config;

    status = nrfx_gpiote_input_configure(&gpiote_inst,
                                         tdc1000_start.pin,
                                         &start_cfg);

    status = nrfx_gpiote_input_configure(&gpiote_inst,
                                         tdc1000_stop.pin,
                                         &stop_cfg);

    status = nrfx_gpiote_input_configure(&gpiote_inst,
                                         tdc1000_errb.pin,
                                         &errb_cfg);

    nrfx_gpiote_trigger_enable(&gpiote_inst, tdc1000_start.pin, 1);
    nrfx_gpiote_trigger_enable(&gpiote_inst, tdc1000_stop.pin, 1);
    nrfx_gpiote_trigger_enable(&gpiote_inst, tdc1000_errb.pin, 1);

    uint8_t gppi_channel1, gppi_channel2, gppi_channel3;
    status = nrfx_gppi_channel_alloc(&gppi_channel1);

    status = nrfx_gppi_channel_alloc(&gppi_channel2);

    status = nrfx_gppi_channel_alloc(&gppi_channel3);

    nrfx_gppi_channel_endpoints_setup(gppi_channel1,
        nrfx_gpiote_in_event_address_get(&gpiote_inst, tdc1000_start.pin),
        nrfx_timer_task_address_get(&tof_timer_inst, NRF_TIMER_TASK_CAPTURE0));

    nrfx_gppi_channel_endpoints_setup(gppi_channel2,
        nrfx_gpiote_in_event_address_get(&gpiote_inst, tdc1000_stop.pin),
        nrfx_timer_task_address_get(&tof_timer_inst, NRF_TIMER_TASK_CAPTURE0));

    nrfx_gppi_channel_endpoints_setup(gppi_channel3,
        nrfx_gpiote_in_event_address_get(&gpiote_inst, tdc1000_errb.pin),
        nrfx_timer_task_address_get(&tof_timer_inst, NRF_TIMER_TASK_CAPTURE0));

    nrfx_gppi_channels_enable(BIT(gppi_channel1));
    nrfx_gppi_channels_enable(BIT(gppi_channel2));
    nrfx_gppi_channels_enable(BIT(gppi_channel3));
    

static void gpiote_event_handler(nrfx_gpiote_pin_t pin, nrfx_gpiote_trigger_t action, void *unused)
{
    // LOG_INF("INT on pin: %u", pin);

    static gpio_int_context_t int_context = {0};

    int_context.cycle_count = nrf_timer_cc_get(tof_timer_inst.p_reg, NRF_TIMER_CC_CHANNEL0);
    
    if (pin == tdc1000_start.pin) {
        int_context.pin = TDC1000_START_PIN;
    }
    else if (pin == tdc1000_stop.pin) {
        int_context.pin = TDC1000_STOP_PIN;
    }
    else if (pin == tdc1000_errb.pin) {
        int_context.pin = TDC1000_ERRB_PIN;
    }
    else {
        return;
    }

    // add to the queue
    k_msgq_put(&gpio_interrupt_q, &int_context, K_NO_WAIT);
}

This seems indeed to improve a lot the timing. Can you just take a look to make sure that I'm doing everything ok?

My take was, since I want to read the time that it takes between the trigger command (writing to gpio) and the start interrupt followed by the echos (stop pin interrupt) i've configured ppi to NRF_TIMER_TASK_CAPTURE0. Then on the interrupt handler I'm retrieving the captured value.

Best regards,

Fernando Fontes

RE: GPIOTE interrupts with around 30us latency?

Fernando Fontes — Fri, 17 Jan 2025 16:11:58 GMT

But I think I will have issues when trying to attach an interrupt to GPIOTE since when GPIO is enabled on zephyr it already does that.

Is it possible to count the time between two pulses on different pins without having to enable interrupts to start/stop the timers from counting?

RE: GPIOTE interrupts with around 30us latency?

Einar Thorsrud — Fri, 17 Jan 2025 14:07:17 GMT

Hi Fernando,

It is possible to use PPI without disabling the GPIO lib. It is a common thing to do, and this is a situation where PPI is a very good match. You can see another unofficial PPI example here (where GPIO is not disabled). https://github.com/too1/ncs-nrfx-pulse-count-example/blob/master/src/main.c

RE: GPIOTE interrupts with around 30us latency?

Fernando Fontes — Fri, 17 Jan 2025 13:33:15 GMT

Hi Thorsrud,

Thank you for the response. Using PPI would require to set CONFIG_GPIO to 'n' which would then make everything else to stop working.

I have other sensors on the board, a modem and they also require the GPIO lib to work.

Is there any other way?

Best regards,

Fernando

RE: GPIOTE interrupts with around 30us latency?

Einar Thorsrud — Fri, 17 Jan 2025 13:09:12 GMT

Hi,

I suggest you do this measurement with PPI instead of software, by hooking the TIMER to GPIOTE via PPI, similarily to whta is done here (this use GPIO as output so some changes are needed, but it shows how you can hook things up). With this, you can do the measurements in hardware and interrupt latency will not affect th emeasurment results.