Unable to interface nrf51822 with LIS3DH (accelerometer) using SPI being nrf as master

Question

Hi,

I tried interfacing LIS3Dh using SPI, I used the SPI example to start with, when I didn't get the desired result, I look numerous question on the forum and tried to modify the code but it does not seem to be working.

I am simply trying to read WHO_AM_I register/or any other register, I am getting FF always,

the sensor is embedded on PCB with following configurations:

Configurations:

LIS3DH	nrf 51822 pin	sdk_config.h
SCK	9	SPI_SCK_PIN 9
SDI	10	SPI_MOSI_PIN 10
CS	12	SPI_SS_PIN 12
SDO	7	SPI_MISO_PIN 11

Below code is trying to read who_am_i ( 0x0F)

#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. */

#define TEST_STRING "Nordic"
static uint8_t       m_tx_buf[]={0x0F};           /**< TX buffer. */
static uint8_t       m_rx_buf[]={0x00, 0x00,0x00, 0x00,0x00};    /**< RX buffer. */
//static const uint8_t m_length = sizeof(m_rx_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;
    SEGGER_RTT_printf(0,"Transfer completed.\r\n");
    if (1 != 0)
    {
        SEGGER_RTT_printf(0," Received: \r\n");
        NRF_LOG_HEXDUMP_INFO(m_rx_buf, strlen((const char *)m_rx_buf));
        SEGGER_RTT_printf(0, "value: %u \r\n", *m_rx_buf);
        bsp_board_led_invert(BSP_BOARD_LED_1);
    }
}

int main(void)
{
    bsp_board_leds_init();

    APP_ERROR_CHECK(NRF_LOG_INIT(NULL));

    SEGGER_RTT_printf(0,"SPI example\r\n");

   nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;
	spi_config.ss_pin   = SPI_SS_PIN;
	spi_config.miso_pin = SPI_MISO_PIN;
	spi_config.mosi_pin = SPI_MOSI_PIN;
	spi_config.sck_pin  = SPI_SCK_PIN;
	spi_config.frequency= NRF_DRV_SPI_FREQ_8M;
	spi_config.mode= NRF_DRV_SPI_MODE_2;
        
	APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, spi_event_handler));
        
       
        uint8_t sizerx = 2;
        spi_xfer_done = false;
        
        APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, m_tx_buf, 1, m_rx_buf, sizerx));
        while (!spi_xfer_done){
	  __WFE();
        }

        if(sizerx!=0)
        {
            SEGGER_RTT_printf(0,"Received[0]: %x %x %x %x %x \n\r",m_rx_buf[0],m_rx_buf[1],m_rx_buf[2],m_rx_buf[3],m_rx_buf[4]);
        }else{
            SEGGER_RTT_printf(0,"no value return from \r\n");
        }
      
      SEGGER_RTT_printf(0,"miso-> %u \r\n", nrf_gpio_pin_out_read(11));
      SEGGER_RTT_printf(0,"mosi-> %u \r\n", nrf_gpio_pin_out_read(10));
      SEGGER_RTT_printf(0,"ss-> %u \r\n", nrf_gpio_pin_out_read(12));
                     
}

log output ( in every case I am getting FF value in rx_buff )

SDK Used: 12.2

using JLink to transfer the via SWO

I have tried with different modes and frequencies also but no luck.

Please help.

hmolesworth · Answer

You have at least two problems: you might try SPI_MODE_0 instead of MODE_2, as that works correctly with the similar part LIS2DH12. Also if this is the first time you have used SPI, it's not obvious that to receive (say) 5 bytes that you actually have to transmit 5 bytes as the transmit provides the clock required for the receive. In the case above only 1 byte is transmitted, so increase that to 5 
 spi_config.ss_pin = ACC_CS_PIN;
 spi_config.miso_pin = ACC_MISO_PIN;
 spi_config.mosi_pin = ACC_MOSI_PIN;
 spi_config.sck_pin = ACC_SCK_PIN;
 spi_config.frequency = NRF_SPI_FREQ_8M;
 spi_config.bit_order = NRF_DRV_SPI_BIT_ORDER_MSB_FIRST;
 spi_config.mode = NRF_DRV_SPI_MODE_0;
 APP_ERROR_CHECK(nrf_drv_spi_init(&mAccSpiInstance, &spi_config, acc_spi_event_handler, NULL));

static uint8_t m_tx_buf[]={0x0F, 0x00, 0x00, 0x00, 0x00}; /**< TX buffer. */
static uint8_t m_rx_buf[]={0x00, 0x00, 0x00, 0x00, 0x00}; /**< RX buffer. */
static const uint8_t m_length = sizeof(m_rx_buf); /**< Transfer length. */

// Ensure transmit and receive buffers are identical lengths
#include "nrf_drv_common.h";
STATIC_ASSERT(sizeof(m_rx_buf) == sizeof(m_tx_buf));
 
 And now specify correct lengths: 
 // Ensure transmit and receive buffers are identical lengths
#include "nrf_drv_common.h";

// 2 bytes each or whatever ..
uint8_t sizerx = 2, sizerx = 2;

STATIC_ASSERT(sizetx == sizerx);

APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, m_tx_buf, sizetx, m_rx_buf, sizerx));

hmolesworth · Answer

The SPI can't return the id you require using your code since the LIS doesn't know what the command is until after the 8-bit tx transfer is complete. If sending an 8-bit command that didn't require a response then a length of 1 byte transfer is fine, but you want the ID response so therefore you require a 2-byte transfer: 1st tx byte is request, 2nd a dummy 0. 1st Rx byte a dummy, 2nd a response to the Tx command request. In general the Rx stream is always 1-byte behind the tx stream since the first tx byte instructs the LIS what to put in the response. 
 I would stick with Mode 0 as that works .. also I would recommend finding the LIS in the examples, eg: look in Thingy SDK v2.1.0\include\frivers which can be downloaded from Nordic 
 /**@brief Read and verify accelerometer ID.
 */
static ret_code_t lis3dh_verify_id(void)
{
 ret_code_t err_code;
 uint8_t reg_val;

 err_code = lis3dh_read_regs(WHO_AM_I, &reg_val);
 RETURN_IF_ERROR(err_code);

 return (reg_val == I_AM_LIS3DH);
}

hmolesworth · Answer

Ah-Ha! Try reading .. use 0x8F not 0x0F .. similar to this - or did you try that I now notice above 
 uint8_t tx_buf[] = {0x80|LIS2DH12_WHO_AM_I, 0xFF};

RenatoMorelli · Answer

Hey, Agam , try these changes on your code: 
 static uint8_t m_tx_buf[] = {0x8F,0x00}; 
 void spi_event_handler(nrf_drv_spi_evt_t const * p_event,
 void * p_context)
{
 spi_xfer_done = true;
 NRF_LOG_INFO("Transfer completed.");
 if (m_rx_buf[1] != 0) // change the byte to compare here
 {
 NRF_LOG_INFO(" Received:");
 NRF_LOG_INFO(" %X",m_rx_buf[1]); // here to print it
// NRF_LOG_HEXDUMP_INFO(m_rx_buf, strlen((const char *)m_rx_buf));
 }
}