SPI long data transfer

RE: SPI long data transfer

Einar Thorsrud — Mon, 14 Jan 2019 13:27:27 GMT

Hi,

There have been a few weeks before this last update so I am unsure about what to look for. Can you explain the current issue, and how the code snipped and data you have printed relates to it?

RE: SPI long data transfer

Dhiraj — Mon, 14 Jan 2019 10:48:20 GMT

I am reading this Data:

0> 790A000000D0A8FA000000000000
0> 79AD000000000000000000000000
0> 7900000000D0A8FA000000000000
0> 79AD000000000000000000000000
0> 7900000000305705000000000000
0> 790A000000D0A8FA000000000000
0> 79AD000000000000000000000000
0> 7900000000D0A8FA000000000000
0> 79AD000000000000000000000000
0> 7900000000305705000000000000
0> 790A000000D0A8FA000000000000
0> 79AD000000000000000000000000
0> 7900000000D0A8FA000000000000
0> 79AD000000000000000000000000
0> 7900000000305705000000000000
0> 790A000000D0A8FA000000000000
0> 79AD000000000000000000000000
0> 7900000000D0A8FA000000000000
0> 79AD000000000000000000000000
0> 7900000000305705000000000000
0> 790A000000D0A8FA000000000000
0> 79AD000000000000000000000000
0> 7900000000D0A8FA000000000000
0> 79AD000000000000000000000000
0> 7900000000305705000000000000

while(1)
    {

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

				sendSPI(0xAD0055730);
				nrf_delay_ms(2000);
				sendSPI(0xADFFFAA8D0);     //XTARGET=512000 | 10 revolutions with micro step = 256

				sendSPI(0x2100000000);
				sendSPI(0xADFFFAA8D0);
				nrf_delay_ms(2000);	
				sendSPI(0x2100000000);
			
				while (!spi_xfer_done)
        {
            __WFE();
        }

RE: SPI long data transfer

Dhiraj — Fri, 21 Dec 2018 07:10:12 GMT

Hello Einar,

Data is received only once I see on the datasheet.

RE: SPI long data transfer

Einar Thorsrud — Thu, 20 Dec 2018 15:40:52 GMT

Your m_rx_buf buffer should hold the buffer the nRF receives from the SPI slave (on MISO). Which data is that? have you checked verified the actual data on the SPI lines (using for instance a logic analyzer)?

RE: SPI long data transfer

Dhiraj — Thu, 20 Dec 2018 14:29:02 GMT

Thanks for the reply.

However, its always printing “FFFFFFFF000000000000000000000000”

i assume m_rx_buf should have printed the data which is written over SPI right?

In code, i am trying to write:

0x80000008

0xEC0100C5

and so on...

RE: SPI long data transfer

Einar Thorsrud — Thu, 20 Dec 2018 13:48:08 GMT

Perfect. Then that is the content of the m_rx_buf at the point where you print it. (Note that you could always beautify it if you want by for instance splitting in bytes and prefixing each byte with 0x by changing the print statement to this: "NRF_LOG_PRINTF("0x%02x, ", m_rx_buf[i]);").

RE: SPI long data transfer

Dhiraj — Thu, 20 Dec 2018 13:37:38 GMT

For this:

for (int i = 0; i < sizeof(m_rx_buf); i++)
{
NRF_LOG_PRINTF("%02x", m_rx_buf[i]);
}

Output is : FFFFFFFF00000000000000000000"

complete code:

/* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
 *
 * The information contained herein is property of Nordic Semiconductor ASA.
 * Terms and conditions of usage are described in detail in NORDIC
 * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
 *
 * Licensees are granted free, non-transferable use of the information. NO
 * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
 * the file.
 *
 */

#include "nrf_drv_spi.h"
#include "app_util_platform.h"
#include "nrf_gpio.h"
#include "nrf_delay.h"
#include "nrf_log.h"
#include "boards.h"
#include "app_error.h"
#include <string.h>

#if defined(BOARD_PCA10036) || defined(BOARD_PCA10040)
#define SPI_CS_PIN   29 /**< SPI CS Pin.*/
#elif defined(BOARD_PCA10028)
#define SPI_CS_PIN   2  /**< SPI CS Pin.*/
#define SPI_SCK_PIN 4
#define SPI_MOSI_PIN 1
#define SPI_MISO_PIN 3


#else
#error "Example is not supported on that board."
#endif

#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. */
long long MISO = 0x8000000008;
#define TEST_STRING "0x8000000008"

unsigned char val0, val1, val2, val3, val4;

static uint8_t       m_tx_buf[] = {0x80};           /**< TX buffer. */
static uint8_t       m_rx_buf[sizeof(TEST_STRING)+1];    /**< RX buffer. */
static uint8_t m_length = sizeof(m_tx_buf);        /**< Transfer length. */


/**
 * @brief SPI user event handler.
 * @param event
 */
void spi_event_handler(nrf_drv_spi_evt_t const * p_event)
{
    spi_xfer_done = true;
    //NRF_LOG_PRINTF(" Transfer completed.\r\n");
	  //NRF_LOG_PRINTF(" address: %x %x %x %x\n", val3, val2, val1, val0);

    if (m_rx_buf[0] != 0)
    {
			for (int i = 0; i < sizeof(m_rx_buf); i++)
				{
						NRF_LOG_PRINTF("%02x", m_rx_buf[i]);
				}
    }
}

void sendDataToSPI(uint8_t address, unsigned long datagram)
{					
				
				APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, &address, m_length, m_rx_buf, m_length));
	      NRF_LOG_PRINTF(" address: %x\r\n",address);

				val0 = (datagram & 0xFF);

				datagram >>= 8;
				val1 =  (datagram & 0xFF);

				datagram >>= 8;
				val2 = (datagram & 0xFF);

				datagram >>= 8;
				val3 =  (datagram & 0xFF);
	
				APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, &val3, m_length, m_rx_buf, m_length));
        NRF_LOG_PRINTF(" val3: %x\r\n",val3);
	
				APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, &val2, m_length, m_rx_buf, m_length));
        NRF_LOG_PRINTF(" val2: %x\r\n",val2);
		
				APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, &val1, m_length, m_rx_buf, m_length));
        NRF_LOG_PRINTF(" val1: %x\r\n",val1);
	
				APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, &val0, m_length, m_rx_buf, m_length));
        NRF_LOG_PRINTF(" val0: %x\r\n",val0);


}

void sendSPI(unsigned long datagram)
{
	static int length= sizeof(datagram);
	APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, (uint8_t *) &datagram, length, m_rx_buf, length));
}
	
int main(void)
{
    LEDS_CONFIGURE(BSP_LED_0_MASK);
    LEDS_OFF(BSP_LED_0_MASK);

    APP_ERROR_CHECK(NRF_LOG_INIT());
    NRF_LOG_PRINTF("SPI example\r\n");

    nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG(SPI_INSTANCE);
    spi_config.ss_pin = SPI_CS_PIN;
		spi_config.miso_pin=SPI_MISO_PIN;
		spi_config.mosi_pin=SPI_MOSI_PIN;
		spi_config.sck_pin=SPI_SCK_PIN;
		spi_config.mode=NRF_DRV_SPI_MODE_3;
	
		spi_config.bit_order = NRF_DRV_SPI_BIT_ORDER_MSB_FIRST;
    APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, spi_event_handler));
				
				/*
				sendDataToSPI(0x80, 0x00000008);
				sendDataToSPI(0xEC, 0x000100C5);
				sendDataToSPI(0xB0, 0x00011F05);
				sendDataToSPI(0xAC, 0x00002710);
				sendDataToSPI(0x90, 0x000401C8);
				sendDataToSPI(0xB2, 0x00061A80);
				sendDataToSPI(0xB1, 0x00007530);
				sendDataToSPI(0xA6, 0x00001388);
				sendDataToSPI(0xA7, 0x00004E20);
				sendDataToSPI(0xA0, 0x00000001);
				sendDataToSPI(0x21, 0x00000000);
				*/
				
				sendSPI(0x80000008);
				sendSPI(0xEC0100C5);
				sendSPI(0xB0011F05);
				sendSPI(0xAC002710);
				sendSPI(0x900401C8);
				sendSPI(0xB2061A80);
				sendSPI(0xB1007530);
				sendSPI(0xA6001388);
				sendSPI(0xA7004E20);
				sendSPI(0xA0000001);
				sendSPI(0x21000000);
				
    while(1)
    {
				unsigned long i_datagram;

        // Reset rx buffer and transfer done flag
        memset(m_rx_buf, 0, m_length);
        spi_xfer_done = false;
				/*
				sendDataToSPI(0xA4, 0x000003E8);
				sendDataToSPI(0xA5, 0x0000C350);
				sendDataToSPI(0xA6, 0x000001F4);
				sendDataToSPI(0xA7, 0x000304D0);
				sendDataToSPI(0xA8, 0x000002BC);
				sendDataToSPI(0xAA, 0x00000578);
				sendDataToSPI(0xAB, 0x0000000A);
				sendDataToSPI(0xA0, 0x00000000);
				sendDataToSPI(0xAD, 0xFFFF3800);
				*/
				sendSPI(0xA40003E8);
				sendSPI(0xA500C350);
				sendSPI(0xA60001F4);
				sendSPI(0xA70304D0);
				sendSPI(0xA80002BC);
				sendSPI(0xAA000578);
				sendSPI(0xAB00000A);
				sendSPI(0xA0000000);
				sendSPI(0xADFF3800);
        while (!spi_xfer_done)
        {
            __WFE();
        }

        LEDS_INVERT(BSP_LED_0_MASK);
        nrf_delay_ms(200);
    }
}

RE: SPI long data transfer

Einar Thorsrud — Thu, 20 Dec 2018 11:13:51 GMT

No, NRF_LOG_HEXDUMP_INFO is not available in SDK 11. Then you have to do it in a loop instead. For instance:

for (int i = 0; i < sizeof(m_rx_buf); i++)
{
    NRF_LOG_PRINTF("%02x", m_rx_buf[i]);
}

RE: SPI long data transfer

Dhiraj — Thu, 20 Dec 2018 11:08:45 GMT

I am using SDK11, Is "NRF_LOG_HEXDUMP_INFO" available in SDK11?

RE: SPI long data transfer

Einar Thorsrud — Thu, 20 Dec 2018 06:52:58 GMT

I see. Then it is as I assumed, you just print the address of the buffer. A simple way to print the buffer as a hexadecimal string is to use NRF_LOG_HEXDUMP_INFO.

RE: SPI long data transfer

Dhiraj — Thu, 20 Dec 2018 06:18:51 GMT

Hi,

The m_rx_buf is declared as the following:

#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. */
long long MISO = 0x8000000008;
#define TEST_STRING "0x8000000008"

unsigned char val0, val1, val2, val3, val4;

static uint8_t       m_tx_buf[] = {0x80};           /**< TX buffer. */
static uint8_t       m_rx_buf[sizeof(TEST_STRING)+1];    /**< RX buffer. */
static uint8_t m_length = sizeof(m_tx_buf);        /**< Transfer length. */


void spi_event_handler(nrf_drv_spi_evt_t const * p_event)
{
    spi_xfer_done = true;
    //NRF_LOG_PRINTF(" Transfer completed.\r\n");
	  //NRF_LOG_PRINTF(" address: %x %x %x %x\n", val3, val2, val1, val0);

    if (m_rx_buf[0] != 0)
    {
        NRF_LOG_PRINTF(" Received: %x\r\n",m_rx_buf);
    }
}

RE: SPI long data transfer

Einar Thorsrud — Wed, 19 Dec 2018 14:43:46 GMT

Hi,

That looks OK.

The way you print the RX buffer you print it as if it was a variable, but the number looks like it is an address (in RAM). So most likely you are just printing a pointer address. How have you declared m_rx_buf?

RE: SPI long data transfer

Dhiraj — Wed, 19 Dec 2018 13:53:34 GMT

Hi Einar,

Thanks for the reply again.

Is this correct if I transfer complete date in one go?


void sendSPI(unsigned long datagram) 
{ 
    static int length= sizeof(datagram); 
    APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, (uint8_t *) &datagram, length, m_rx_buf, length)); 
}
.

.
int main()
{
    sendSPI(0x80000008); sendSPI(0xEC0100C5); sendSPI(0xB0011F05); sendSPI(0xAC002710); sendSPI(0x900401C8); sendSPI(0xB2061A80); sendSPI(0xB1007530); sendSPI(0xA6001388); sendSPI(0xA7004E20); sendSPI(0xA0000001); sendSPI(0x21000000);
}

One more question:

if (m_rx_buf[0] != 0) { NRF_LOG_PRINTF(" Received: %x\r\n",m_rx_buf);

this part is printing

0> Received: 20000034

No matter what's the data send by SPI.

RE: SPI long data transfer

Einar Thorsrud — Wed, 19 Dec 2018 13:22:36 GMT

Hi,

Assuming you still want a separate write for the address you can do it like this (assuming blocking mode):

void sendDataToSPI(uint8_t address, unsigned long datagram)
{
    static length = sizeof(address); // 1
    APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, &address, length, m_rx_buf, length));

    length = sizeof(datagram); // 4
    APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, (uint8_t *)&datagram, length, m_rx_buf, length));
}

If you don't want to send the address in a separate transaction (I don't see any reason why), then you can make an array containing both so that you only have one transaction.

RE: SPI long data transfer

Dhiraj — Wed, 19 Dec 2018 12:52:07 GMT

Hi Einar, Can you help me with some example?

RE: SPI long data transfer

Dhiraj — Wed, 19 Dec 2018 12:52:07 GMT

Hi Einar, Can you help me with some example?

RE: SPI long data transfer

Einar Thorsrud — Wed, 19 Dec 2018 12:11:15 GMT

Hi,

Why do you split the transaction up like this? You can send up to 255 bytes in one transfer. Just let the puffer pointer point to the start of the data, and set the length field to a multiple of the bytes you have to send.

RE: SPI long data transfer

Dhiraj — Wed, 19 Dec 2018 11:33:14 GMT

Hello Einar,

Thank you for your reply. I made this function "sendDataToSPI" which accepts the address and data (as mentioned in the above image). Total 40 bits are transferred via SPI in each data transfer. The first byte is send directly and later 32 byte are split in to 4 byte and sent separately.

Is this function Ok?

void sendDataToSPI(uint8_t address, unsigned long datagram)
{					
				APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, &address, m_length, m_rx_buf, m_length));
	      NRF_LOG_PRINTF(" address: %x\r\n",address);

				val0 = (datagram & 0xFF);

				datagram >>= 8;
				val1 =  (datagram & 0xFF);

				datagram >>= 8;
				val2 = (datagram & 0xFF);

				datagram >>= 8;
				val3 =  (datagram & 0xFF);
	
				APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, &val3, m_length, m_rx_buf, m_length));
        NRF_LOG_PRINTF(" val3: %x\r\n",val3);
	
				APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, &val2, m_length, m_rx_buf, m_length));
        NRF_LOG_PRINTF(" val2: %x\r\n",val2);
		
				APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, &val1, m_length, m_rx_buf, m_length));
        NRF_LOG_PRINTF(" val1: %x\r\n",val1);
	
				APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, &val0, m_length, m_rx_buf, m_length));
        NRF_LOG_PRINTF(" val0: %x\r\n",val0);


}

RE: SPI long data transfer

Einar Thorsrud — Mon, 17 Dec 2018 19:13:20 GMT

Hi,

As you write, the SPI driver uses uint8_t, so you must handle it like that. I do not see that as a problem though. You would still provide a pointer to the beginning of the data, so all you should have to do is to cast the pointer and set the length field properly (length in bytes). Lastly you might want to consider the endianess (in case the bytes of your long data type are not transferred in the order you need.)