Reduce time between SPI transfers

[Fran89]

Dear all,

I am using a DK with the NRF52832 to drive a 32-bit DAC through SPI @ 8 MHz. I use a solution based on the peripheral/spi example using the SDK15.

My goal is to change the DAC value every (say) 5 us. This is theoretically possible since 32-bit/ 8 MHz = 4 us. The application also uses the SoftDevice, as well as Timer2 (for pulse diuration purposes)

Using the "nrf_drv_spi_transfer()" function in an infinite loop, it yields a delay between transfers of around 60 us. That is, I measure the 32 clock pulses of an SPI transfer in a row, but until the next call of "nrf_drv_spi_transfer()" there is a delay of 60 us.

1) I would firstly like to ask for reference of the origin of this delay. I know it has to do with the SoftDevice mainly, and of course the rest of the executing code, but I could not find a reference guide about it.

2) I would need to minimize the inter-transfer delay to ideally 0. Any strategies on how to do this, and which would be roughly the theoretical minimum of this delay? Is any continuous-transfer (zero inter-delay) implementation possible?

Thank you for your kindness,

Fran89

[Jørgen Holmefjord]

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

[Jørgen Holmefjord]

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:

Fullscreen main.c Download

/**
 * Copyright (c) 2015 - 2019, Nordic Semiconductor ASA
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 *
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
#include "nrf_drv_spi.h"
#include "app_util_platform.h"
#include "nrf_gpio.h"
#include "nrf_delay.h"
#include "boards.h"
#include "app_error.h"
#include <string.h>
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

#include "nrf_drv_ppi.h"

#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 "Nord"
static uint8_t       m_tx_buf[4] = TEST_STRING;           /**< TX buffer. */
static uint8_t       m_rx_buf[4];    /**< RX buffer. */
static const uint8_t m_length = 4;        /**< Transfer length. */

static nrf_ppi_channel_t     m_ppi_channel;

/**
 * @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.");

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

    nrf_drv_spi_xfer_desc_t xfer = NRF_DRV_SPI_XFER_TRX(m_tx_buf, m_length, m_rx_buf, m_length);
    ret_code_t ret = nrf_drv_spi_xfer(&spi, &xfer, NRF_DRV_SPI_FLAG_HOLD_XFER | NRF_DRV_SPI_FLAG_REPEATED_XFER | NRF_DRV_SPI_FLAG_NO_XFER_EVT_HANDLER);
    // SPIM is now configured and ready to be started.
    if (ret == NRF_SUCCESS)
    {
        uint32_t start_tsk_addr = nrf_drv_spi_start_task_get(&spi);
        // Set up PPI to trigger the transfer.
        uint32_t end_evt_addr = nrf_drv_spi_end_event_get(&spi);
        // Set up PPI to count the number of transfers.

        /* setup ppi channel so that timer compare event is triggering sample task in SAADC */
        ret_code_t 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,
                                              end_evt_addr,
                                              start_tsk_addr);
        APP_ERROR_CHECK(err_code);

        err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);

        APP_ERROR_CHECK(err_code);
    } 

    NRF_SPIM0->TASKS_START = 1;

    while (1)
    {

        NRF_LOG_FLUSH();

    }
}

Best regards,
Jørgen

[MinhDuc]

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

[Jørgen Holmefjord]

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