SPI master timings

[Sébastien Schiesser]

Hi

I modified the SPI master example to read an 16-bit ADC at 44.1 kHz.

While the HAL_TIMER achieves its ~22 microseconds quite good, the SPI driver is quite slow: the CS pin stays low for 7.5 us for a 8 MHz transfer of ca 2 us (see picture). Do I have a possibility to optimize that?

And I don't know if it's related: when I reduce the timer to 20 us, just after starting up it works fine (the toggles on the 'TIMER' channel have ca 19.9 us):

But after 28 ms it changes and I get the following shapes, as if the time did get some delay and has to catch up (total time of an ON-OFF toggle is 38.8 us):

Is the 20 us value a limit for this application?

Thanks,

Sébastien

[MartinBL]

So there are two questions here?

1. Why is the CSN chip low for so long? This is probably, at least partly, due to the SPI driver in the SDK. The CSN pin is not automatically controlled by HW, but is controlled by SW in the driver. It seems a bit weird that it would stay low that long though. 
2. You have configured the timer to generate a waveform with a period of 20us, but then it suddenly changes to 38us? Is that correct?

Is this nRF52832?
Are you using a Softdevice?
What timer are you using?
Can you upload your code so I can test it?

[Sébastien Schiesser]

That's right! Two question, but perhaps related :-) So I start with #2

Yes it's nRF52832

No Softdevice for the moment, but my next step will be adding S132 for remote purposes

I use the HAL timer (controlled by nrf_drv_timer)

Code:

#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_timer.h"

/* SPI instance for ADC device */
#define ADC_SPI_INSTANCE  		0 /**< SPI instance index. */
#define ADC_BUFFER_NUMBER		4
#define ADC_CHUNK_SIZE			512
static const 					nrf_drv_spi_t spi = NRF_DRV_SPI_INSTANCE(ADC_SPI_INSTANCE);  /**< SPI instance. */
static volatile bool 			adc_spi_xfer_done = false;  /**< Flag used to indicate that SPI instance completed the transfer. */
static uint8_t					m_tx_buf[2] = {0xFF, 0xFF};	/**< Dummy TX value to push the 2 ADC bytes. */
static uint8_t					m_rx_buf[2];
static uint8_t					m_adc_buffer[ADC_BUFFER_NUMBER][ADC_CHUNK_SIZE];
static const uint8_t			m_adc_len = 2;
static uint16_t					m_adc_sample_cnt = 0;
static uint8_t					m_adc_buffer_cnt = 0;
static uint32_t					m_adc_total_samples = 0;



/* TIMER instance for audio synchronization */
#define AUDIO_TIMER_INSTANCE	0
#define AUDIO_TIMER_CNT_US		25
const nrf_drv_timer_t 			TIMER_AUDIO = NRF_DRV_TIMER_INSTANCE(AUDIO_TIMER_INSTANCE);


/**
 * @brief SPI user event handler.
 * @param event
 */
void adc_spi_event_handler(nrf_drv_spi_evt_t const * p_event,
                       void *                    p_context)
{
    adc_spi_xfer_done = true;
}

static void audio_sync_handler(nrf_timer_event_t event_type, void *p_context)
{
//	bsp_board_led_invert(0);
	nrf_drv_spi_transfer(&spi, m_tx_buf, m_adc_len, m_rx_buf, m_adc_len);
}

static void audio_sync_init(void)
{
	uint32_t time_us = AUDIO_TIMER_CNT_US;
	uint32_t time_ticks;
    ret_code_t err_code;
	
	nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
	err_code = nrf_drv_timer_init(&TIMER_AUDIO, &timer_cfg, audio_sync_handler);
	APP_ERROR_CHECK(err_code);
	
	time_ticks = nrf_drv_timer_us_to_ticks(&TIMER_AUDIO, time_us);
	nrf_drv_timer_extended_compare(&TIMER_AUDIO, NRF_TIMER_CC_CHANNEL0, time_ticks, NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK, true);
	nrf_drv_timer_enable(&TIMER_AUDIO);
}

static void adc_spi_init(void)
{
    nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;
    spi_config.ss_pin   = SPI0_SS_PIN;
    spi_config.miso_pin = SPI0_MISO_PIN;
    spi_config.mosi_pin = SPI0_MOSI_PIN;
    spi_config.sck_pin  = SPI0_SCK_PIN;
	spi_config.frequency = NRF_DRV_SPI_FREQ_8M;
	spi_config.irq_priority = SPI0_IRQ_PRIORITY;
    APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, adc_spi_event_handler, NULL));
}

int main(void)
{
    APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
    NRF_LOG_DEFAULT_BACKENDS_INIT();
    
    NRF_LOG_INFO("Sounding Soil, version 0.1");

    bsp_board_leds_init();
	adc_spi_init();
	audio_sync_init();
	
    while (1)
    {
		if(adc_spi_xfer_done) {
//			bsp_board_led_invert(1);
			m_adc_buffer[m_adc_buffer_cnt][m_adc_sample_cnt++] = m_rx_buf[0];
			m_adc_buffer[m_adc_buffer_cnt][m_adc_sample_cnt++] = m_rx_buf[1];
			if(m_adc_sample_cnt >= ADC_CHUNK_SIZE) {
				m_adc_total_samples += m_adc_sample_cnt;
				m_adc_sample_cnt = 0;
				m_adc_buffer_cnt = (m_adc_buffer_cnt >= (ADC_BUFFER_NUMBER - 1)) ? 0 : m_adc_buffer_cnt + 1;
			}
			adc_spi_xfer_done = false;
//			bsp_board_led_invert(1);
		}
		else {
		__WFE();
		}
    }
}

Hope it works... Thanks in advance.

Sébastien

[MartinBL]

Hi,

It worked like a charm and I managed to reproduce it:

You can see how after ~40-60ms things start going haywire. The problem seems to go away if you slow down the timings, and  disappears entirely if you remove __WFE() from your main loop, but obviously that is not a viable fix. This made me think of erratum 108: RAM content cannot be trusted upon waking up from System ON Idle or System OFF mode, but it doesn't quite fit these symptoms. I'm going to need a couple more days to debug this.

 

[Sébastien Schiesser]

I'm thrilled to learn more about this issue!

[MartinBL]

Hi, I just thought I'd let you know I'm still working on this. It's a very weird issue, and I need to involve some experts.