SPI Overhead

RE: SPI Overhead

Jørgen Holmefjord — Fri, 26 Mar 2021 11:50:53 GMT

You can use the HAL function: nrf_spi_event_clear(), where you pass the SPI instance and the event, or you can clear the register manually:

NRF_SPI(M)x->EVENTS_READY = 0, where x is the SPI instance, and M is included if you are using the SPIM peripheral with EasyDMA support.

RE: SPI Overhead

pd@learner — Fri, 26 Mar 2021 10:40:22 GMT

Hi,

Thanks

I have one more question.

How to clear NRF_SPI_EVENT_READY manually?

RE: SPI Overhead

Jørgen Holmefjord — Tue, 23 Mar 2021 10:28:31 GMT

What exactly do you mean by "every time I get the first value in all 6 registers." Do you mean that the receive buffer is filled with the same byte?

Have you checked the SPI lines with a logic analyzer, to see if the sensor outputs the expected data?

The code you have posted will write two bytes and read 6 bytes, but note that the receive buffer will be filled while the two first bytes are written. This means that you will only receive 4 bytes after the write is done to the sensor. Normally, the sensor will not output valid data for bytes where the register address is written, so you need to increase the read buffer to 8 bytes if you want to receive 6 bytes after the write command is completed.

RE: SPI Overhead

pd@learner — Mon, 22 Mar 2021 04:38:31 GMT

Hi,

Thanks for clarification

I want to read multiple bytes at a time i.e 6 bytes

I m trying to read as follows but every time I get the first value in all 6 registers.

void spi_burst_read_reg()
{
nrf_drv_spi_xfer_desc_t spd;
t_tx_data[0]= LIS2DH_OUT_X_L|0x80; //read bit

memset(t_rx_data, 0, 6);

spi_xfer_done = false;
memset(t_rx_data, 0, 6);

spd.p_tx_buffer = t_tx_data;
spd.tx_length = 2;
spd.p_rx_buffer = t_rx_data;
spd.rx_length = 6;
APP_ERROR_CHECK(nrf_drv_spi_xfer(&spi, &spd, NRF_DRV_SPI_FLAG_TX_POSTINC));

while (!spi_xfer_done)
{
__WFE();
}

}

Can you tell me how to read it using the nrf spi driver.?

RE: SPI Overhead

Jørgen Holmefjord — Mon, 15 Mar 2021 14:52:09 GMT

Hi,

There is some small overhead in starting and completing the transfer, but the transfer itself does not have any overhead.

I did a quick test with a logic analyzer to show you the timings in the default SPI master example in the SDK, with frequency increased to 4 MHz:

As you can see, the transfer of 12 bytes takes ~24 us, which correspond with the calculations (8 bits/byte * 12 bytes * (1/4MHz) = 24 us).

The toggling of SS signal is handled in SW by transfer start function and interrupt handler triggered by the END event. This is about 40 us, giving a total overhead of ~16 us.

The timing overhead will depend on the optimization of the code and what state the chip is in when the interrupt is generated. If I remove the sleep function from the example (__WFE()), the overhead is reduced to about 5.5 us:

Best regards,
Jørgen