SPI blocking or nonblocking?

RE: SPI blocking or nonblocking?

Emil — Wed, 02 Mar 2016 13:26:00 GMT

There's nothing that indicates that it wouldn't. The fact is that it's event based, and i interpret this as a certain "return" of the function signaling the COMPLETED event.

RE: SPI blocking or nonblocking?

wim — Wed, 02 Mar 2016 13:23:44 GMT

i am still using SDK7.2.0, there I only have SPI_MASTER_EVT_TRANSFER_STARTED and SPI_MASTER_EVT_TRANSFER_COMPLETED in the spi_master_evt_type_t enumeration, so I guess I am ok. It should always return, right?

RE: SPI blocking or nonblocking?

Emil — Wed, 02 Mar 2016 13:21:48 GMT

The SDK has changed, but it should always return. Also you might want to handle SPI_MASTER_EVT_TRANSFER_ABORTED.

I changed from this SPI library to an SPI library that is simpler and doesn't use events. This is much tighter and faster and you don't need to have this logic: devzone.nordicsemi.com/.../

RE: SPI blocking or nonblocking?

wim — Wed, 02 Mar 2016 13:08:46 GMT

question: I also use a blocking mechanism with a flag. Is it guaranteed to get a SPI_MASTER_EVT_TRANSFER_COMPLETED? or do I need to cover other cases? Or do I need to put a safety timeout to exit my while loop if the SPI access takes to much time?

RE: SPI blocking or nonblocking?

Emil — Tue, 21 Jul 2015 13:13:18 GMT

Thank you! That cleared everything up!

RE: SPI blocking or nonblocking?

Susheel Nuguru — Tue, 21 Jul 2015 12:47:49 GMT

it calls _WFE, so it falls through only after. Read the discussion regarding this. devzone.nordicsemi.com/.../

RE: SPI blocking or nonblocking?

Emil — Tue, 21 Jul 2015 12:31:58 GMT

Yeah, I need it in top and bottom. But another important thing is to know for certain that sd_app_evt_wait falls through AFTER the handler is called, if it falls through before, it will wait forever for next transfer (?)

RE: SPI blocking or nonblocking?

Susheel Nuguru — Tue, 21 Jul 2015 12:30:23 GMT

Damn, i missed that. you need that flag else you cannot tell which event occured. Sorry for that

while (_isTransferring)
{
  uint32_t err_code = sd_app_evt_wait();
  APP_ERROR_CHECK(err_code);
}

RE: SPI blocking or nonblocking?

Emil — Tue, 21 Jul 2015 12:27:51 GMT

Thanks! But that will wait on any event, what if there are more events in my application? Is there a way to check which event occured? Will the code in the handler get executed before sd_app_evt_wait falls through or after?

RE: SPI blocking or nonblocking?

Susheel Nuguru — Tue, 21 Jul 2015 12:22:18 GMT

It is not sleep, instead the CPU is busy waiting, you can use sd_app_evt_wait() instead, renive _isTransfering completely.

while (_isTransferring) nrf_delay_us(1);

change to

uint32_t err_code = sd_app_evt_wait();
APP_ERROR_CHECK(err_code);

RE: SPI blocking or nonblocking?

Emil — Tue, 21 Jul 2015 12:12:16 GMT

I just wondered what the best way to block a function while waiting for something. Is it still sleeping every µs and poll the volatile bool?

I do this:

static inline void SpiTransfer(uint8_t * const txBuffer, const uint16_t txBufferLength,
	uint8_t * const rxBuffer, const uint16_t rxBufferLength)
{	
	while (_isTransferring)
		nrf_delay_us(1);

	_count = rxBufferLength;

	_isTransferring = true;
	uint32_t result = spi_master_send_recv(SPI_MASTER_HW, txBuffer, txBufferLength, rxBuffer,     rxBufferLength);
	APP_ERROR_CHECK(result);

	while (_isTransferring)
		nrf_delay_us(1);
}

static void spi_master_event_handler(spi_master_evt_t spi_master_evt)
{
	switch (spi_master_evt.evt_type)
	{
	case SPI_MASTER_EVT_TRANSFER_COMPLETED:

		_receivedCount = spi_master_evt.data_count;

		if (_receivedCount >= _count)
		{
			_count = 0;
			_isTransferring = false;
		}

		break;

	default:
		// No implementation needed.
		break;
	}
}

RE: SPI blocking or nonblocking?

Susheel Nuguru — Tue, 21 Jul 2015 12:10:22 GMT

Emil, could you please update this thread with latest info, if this answer helped you then please click the ✓ to the left of the answer so that others can come and look here.

RE: SPI blocking or nonblocking?

Susheel Nuguru — Fri, 03 Jul 2015 14:59:17 GMT

I think checking for a flag and sleeping if not flag not enabled is not dirty. It takes just few ARM instructions to do it. it makes the logic simple too and this method does not effect power consumption. There is scheduler but that also does indirect signalling only if main is polling .

RE: SPI blocking or nonblocking?

Emil — Wed, 01 Jul 2015 08:37:14 GMT

Thanks!

The callback function is in place, and it is waiting. I was thinking more of nrf_delay_us as "sleep". I feel that it's "dirty" to sleep and check a volatile bool if it's done. Is there some Event framework I can use for signaling it from the SPI callback ? Like:

wait_for_event(_eventObject, timeout);

.....

Handler:

signal_event(_eventObject);

RE: SPI blocking or nonblocking?

Susheel Nuguru — Tue, 30 Jun 2015 11:45:29 GMT

In the event callback function that you register using spi_master_evt_handler_reg you can enable a flag (bool) when you get SPI_MASTER_EVT_TRANSFER_COMPLETED. You can wait for this flag to be set in your main context. You can even sleep as the event handler callback is called in interrupt context so the chip will wake up after completion. Make sure you use WFE instead of WFI

RE: SPI blocking or nonblocking?

Emil — Tue, 30 Jun 2015 10:14:30 GMT

Thanks!!! I need to make this a blocking function. What is the best way to block it? In windows you have events that you wait for and signal. Should I use IRQs in this context? Or a sleep + a volatile bool (not preferred) ?

RE: SPI blocking or nonblocking?

Susheel Nuguru — Tue, 30 Jun 2015 10:12:17 GMT

The spi_master_send_recv function will only transmit first bytes to start the transaction and then return. This is non blocking.

After the bytes are received for the transmitted first bytes then the rest of the transaction happens in the interrupt context. When the interrupt context has started for the first time you get a SPI_MASTER_EVT_TRANSFER_STARTED event and when the whole transaction is finished then you get SPI_MASTER_EVT_TRANSFER_COMPLETED event.