Reduce time between SPI transfers

RE: Reduce time between SPI transfers

Jørgen Holmefjord — Mon, 28 Aug 2023 07:01:07 GMT

Hi MinhDuc,

Please post your question in a new ticket instead of resurrecting this old thread. If your question is related to the content of this ticket, you can post a link to this in your new ticket.

Best regards,
Jørgen

RE: Reduce time between SPI transfers

MinhDuc — Mon, 28 Aug 2023 00:23:32 GMT

Hello Jørgen Holmefjord,

I am following your code to send SPI with PPI to reduce as much as possible delay between each SPI transfer.

I tried to use it in multiple different SPI but failed.

Please suggest how can I link multiple different SPI with PPI?

For ex:

While(true)

{

if (timer_handle_tick == true)

{

SPI_1_send();

SPI_2_send();

SPI_3_send();

SPI_4_send();

timer_handle_tick = false;

}

Best,

MinhDuc

RE: Reduce time between SPI transfers

Fran89 — Mon, 20 Jan 2020 08:36:06 GMT

For the time being I decided to use the standard spi transfer api.

I tried linking PPI channels to the timer and the spi, but I could not successfully manage to do so. However, I believe that is the way to go when I become more time-constrained.

I will open a new topic when I have doubts about that, and I think my question has been answered here.

Best regards

RE: Reduce time between SPI transfers

Fran89 — Sat, 11 Jan 2020 12:30:41 GMT

Hi again.

This looks exactly like what I am looking for. Also it is awesome to have the absolute minimum latency value, thanks.

I do need to change the content of the buffer in every transfer of course. I will try to implement this solution throught the week and get back with a question or mark the problem as solved.

Thank you very much in advance.

RE: Reduce time between SPI transfers

Jørgen Holmefjord — Thu, 09 Jan 2020 16:35:46 GMT

Hi,

I did a quick test with the SPI driver in advanced mode. I setup a repeated transfer and connected the SPI END event to the START task, which means that the next transfer will start as soon as the previous is completed. As you can see from the image, I get a delay of 1.372 us between each 4 byte transfer. This is the lowest delay you can get, as everything happens in HW.

I have also attached the main.c for your reference:

devzone.nordicsemi.com/.../main.c

Best regards,
Jørgen

RE: Reduce time between SPI transfers

Fran89 — Wed, 08 Jan 2020 10:54:15 GMT

Thank you very much for the prompt answer. I will test it out as soon as possible and let you know the results.

For now I add a picture for future reference and clarification of what my problem is:

The code is the one for the SPI example, with the delays removed. This doesn't use SoftDevice or any other interrupts, and yet there is a delay of around 30 us. The idea would be to minimize this delay.

#define SPI_INSTANCE  0 /**< SPI instance index. */
static const nrf_drv_spi_t spi = NRF_DRV_SPI_INSTANCE(SPI_INSTANCE);  /**< SPI instance. */
static volatile bool spi_xfer_done;  /**< Flag used to indicate that SPI instance completed the transfer. */

#define TEST_STRING "Nordic"
static uint8_t       m_tx_buf[] = TEST_STRING;           /**< TX buffer. */
static uint8_t       m_rx_buf[sizeof(TEST_STRING) + 1];    /**< RX buffer. */
static const uint8_t m_length = sizeof(m_tx_buf);        /**< Transfer length. */

/**
 * @brief SPI user event handler.
 * @param event
 */
void spi_event_handler(nrf_drv_spi_evt_t const * p_event,
                       void *                    p_context)
{
    spi_xfer_done = true;
    NRF_LOG_INFO("Transfer completed.");
    if (m_rx_buf[0] != 0)
    {
        NRF_LOG_INFO(" Received:");
        NRF_LOG_HEXDUMP_INFO(m_rx_buf, strlen((const char *)m_rx_buf));
    }
}

int main(void)
{
    //bsp_board_init(BSP_INIT_LEDS);

    //APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
    //NRF_LOG_DEFAULT_BACKENDS_INIT();

    nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;
    spi_config.ss_pin   = SPI_SS_PIN;
    spi_config.miso_pin = SPI_MISO_PIN;
    spi_config.mosi_pin = SPI_MOSI_PIN;
    spi_config.sck_pin  = SPI_SCK_PIN;
    APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL));

    NRF_LOG_INFO("SPI example started.");

    while (1)
    {
        // Reset rx buffer and transfer done flag
        memset(m_rx_buf, 0, m_length);
        spi_xfer_done = false;

        APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, m_tx_buf, m_length, m_rx_buf, m_length));

        while (!spi_xfer_done)
        {
            __WFE();
        }

        //NRF_LOG_FLUSH();

        //bsp_board_led_invert(BSP_BOARD_LED_0);
        //nrf_delay_ms(200);
    }
}

Thanks again, and I will report back asap.

Fran89

RE: Reduce time between SPI transfers

Jørgen Holmefjord — Mon, 06 Jan 2020 16:13:52 GMT

Hi,

I think we will need some more details in order to answer your questions. How have you configured the SPI driver? (non-blocking/blocking mode, SS signal being used, etc).

Do you need to update the data that is being transferred every time you call the nrf_drv_spi_transfer? If this is static, you can use the "advanced usage" features of the driver to setup a transfer and start it through PPI directly from a TIMER. This will minimize the time between transfers.

If you need to change the content of the buffer, and are running BLE activity simultaneously, there is no way to guarantee the completion of the transfer in this short time, since the softdevice will always have the highest priority and will preempt the SPI transfer.

Best regards,
Jørgen