SPI write and read Multiple bytes.

RE: SPI write and read Multiple bytes.

sne_333 — Fri, 14 Jul 2023 11:32:48 GMT

Jørgen Holmefjord Thank you so much. This solved my issue.

RE: SPI write and read Multiple bytes.

Jørgen Holmefjord — Fri, 14 Jul 2023 09:25:04 GMT

Something like this would be equivalent for Nordic TWI driver API:

char* MAXbytes_wr( uint8_t reg, uint8_t nbytes, char* data )
{
	static uint8_t spi_tx_buf[nbytes + 1];	// Declare buffer that can hold reg address + data
	spi_tx_buf[0] = reg;					// Set first byte of TX buffer to register address
	memcpy(&spi_tx_buf[1], data, nbytes);	// Copy data to TX buffer
	
	nrf_gpio_pin_clear(SPI_SS_PIN);			// assert SS

	nrf_drv_spi_transfer(&m_spi, spi_tx_buf, nbytes+1 , NULL, 0);  // No need for a while loop handling each byte separately. SPI driver will transfer all bytes in one go.

	while(!spi_xfer_done)					// Wait for transfer to complete
	{
		spi_xfer_done = false;
	}

	nrf_gpio_pin_set(SPI_SS_PIN);			// deassert SS
	return( data );
}

RE: SPI write and read Multiple bytes.

sne_333 — Fri, 14 Jul 2023 07:48:56 GMT

Hi Jorgen, can you help me with converting this function??

I did conversion like mentioned above but its not working. Please help.

char* MAXbytes_wr( BYTE reg, BYTE nbytes, char* data )
{
Select_MAX3421E; //assert SS
SPI_wr ( reg + 2 ); //set W/R bit and select register
while( nbytes ) {
SPI_wr( *data ); // send the next data byte
data++; // advance the pointer
nbytes--;
}
Deselect_MAX3421E; //deassert SS
return( data );
}

Regards,
Snehal

RE: SPI write and read Multiple bytes.

Jørgen Holmefjord — Tue, 09 May 2023 12:31:12 GMT

Hi,

The warning is likely because you are passing the reference to 'data' to nrf_drv_spi_transfer(), while data is already a pointer in the input to the function.

I think your approach of translating each line of the original function to a similar line in nRF code is not optimal, you should rather understand how the SPI driver works and rewrite the entire function to give the same functionality.

I would do something like this:

char* MAXbytes_rd ( uint8_t reg, uint8_t nbytes, char* data )
{

spi_tx_buf[0] = reg;    //Only need to send the actual register address, the driver will automatically clock out OCR byte to clock in data in RX buffer

nrf_gpio_pin_clear(SPI_SS_PIN);

nrf_drv_spi_transfer(&m_spi, spi_tx_buf, 1, data, nbytes);  // No need for a while loop handling each byte separately. SPI driver will fill buffer with requested number of bytes (nbytes)

while(!spi_xfer_done)   // Wait for transfer to complete
spi_xfer_done = false;

nrf_gpio_pin_set(SPI_SS_PIN);


return( data );

}

Best regards,
Jørgen

RE: SPI write and read Multiple bytes.

sne_333 — Mon, 08 May 2023 16:21:32 GMT

Hi Jorgen,

Yes I misunderstood. you are right, the error code was returned instead of data. I modified the code in following way but still it doesnt seem to work. Gives me a warning on nrf_drv_spi_transfer line.

char* MAXbytes_rd ( uint8_t reg, uint8_t nbytes, char* data )
{

spi_tx_buf[0] = reg;
spi_tx_buf[1] = 0x00;

nrf_gpio_pin_clear(SPI_SS_PIN);

while( nbytes ) {
nrf_drv_spi_transfer(&m_spi, spi_tx_buf, 2, &data, nbytes);
data++;
nbytes--;
}
nrf_gpio_pin_set(SPI_SS_PIN);

return( data );

}

Is still something wrong here?

Regards,

Snehal

RE: SPI write and read Multiple bytes.

Jørgen Holmefjord — Mon, 08 May 2023 15:32:46 GMT

Hi,

You should make sure to check the error codes returned from functions like nrf_drv_spi_transfer(), in your functions you do not do this. It also looks like you have misunderstood the return value from this function in MAXbytes_rd(), it only returns an error code, not the data received by the SPI. Normally, the SPI driver is non-blocking, which means that you have to wait for a transfer to complete before starting a new one, for instance by waiting for the spi_xfer_done flag like you have in one of the functions.

It should be sufficient to call nrf_drv_spi_transfer() once with the requested number of TX and RX bytes. Note that RX and TX buffer will be filled at the same time, meaning that if you want to receive a number of bytes after all data in the TX buffer have been clocked out, you need to set the RX length to TX length + number of expected RX bytes, the bytes clocked into the RX buffer while clocking out TX buffer can be ignored.

Best regards,
Jørgen