nrF52832 get wrong WHO_AM_I value with spi

[Christoph_I]

Hey guys (and merry Christmas),

I'm working with a Laird BL652-DVK (nrF 52832 - chip), Nordic SDK v.14.2.0 and SES (Segger Embedded Studio v.4.30). I try to receive data from an accelerometer using spi. At first I configured the uart example because I want to send the data to my pc with uart and Termite v3.4. That's working.

Now I have implented the spi example into the uart example.  I have configured spi and the accelerometer. After that I read the WHO_AM_I register (uint8_t read_data_1), but I get a wrong value. I get the value "11" instead of "33".... My code is below. If I read the "uint8_t read_data[1]" (commented out), I get the value "0x0". I really don't know, what to do. I hope someone can help me.

My code:

/**
 * Copyright (c) 2014 - 2017, Nordic Semiconductor ASA
 * 
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 * 
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 * 
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 * 
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 * 
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 */
/** @file
 * @defgroup uart_example_main main.c
 * @{
 * @ingroup uart_example
 * @brief UART Example Application main file.
 *
 * This file contains the source code for a sample application using UART.
 *
 */

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <math.h>
#include "app_uart.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "nrf.h"
#include "bsp.h"
#if defined (UART_PRESENT)
#include "nrf_uart.h"
#endif
#if defined (UARTE_PRESENT)
#include "nrf_uarte.h"
#endif

//spi header
#include <nrf_drv_spi.h>
#include "app_util_platform.h"
#include "nrf_gpio.h"
#include "boards.h"
#include <string.h>
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"


#define MAX_TEST_DATA_BYTES     (15U)                /**< max number of test bytes to be used for tx and rx. */
#define UART_TX_BUF_SIZE 256                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE 256                         /**< UART RX buffer size. */
#define UART_HWFC APP_UART_FLOW_CONTROL_DISABLED     /* When UART is used for communication with the host do not use flow control.*/


//spi variables
#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. */
//uint8_t read_data[1];
uint8_t read_data[1];

//accel input register
uint8_t LIS3DH_CTRL_REG1[] = {0x20, 0x47}; //all axes, normal, 50Hz
uint8_t LIS3DH_CTRL_REG2[] = {0x21, 0x00}; //no highpass filter
uint8_t LIS3DH_CTRL_REG3[] = {0x22, 0x00}; //no interrupts
uint8_t LIS3DH_CTRL_REG4[] = {0x23, 0x88}; //all defaults
uint8_t LIS3DH_CTRL_REG5[] = {0x24, 0x00}; //all defaults
uint8_t LIS3DH_CTRL_REG6[] = {0x25, 0x00}; //all defaults


//accel output register
uint8_t LIS3DH_WHO_AM_I_REG[] = {0x0F};
uint8_t LIS3DH_OUT_X_H[] = {0x29};
uint8_t LIS3DH_OUT_X_L[] = {0x28};
uint8_t LIS3DH_OUT_Y_H[] = {0x2B};
uint8_t LIS3DH_OUT_Y_L[] = {0x2A};
uint8_t LIS3DH_OUT_Z_H[] = {0x2D};
uint8_t LIS3DH_OUT_Z_L[] = {0x2C};


//uart error handle
void uart_error_handle(app_uart_evt_t * p_event)
{
    if (p_event->evt_type == APP_UART_COMMUNICATION_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_communication);
    }
    else if (p_event->evt_type == APP_UART_FIFO_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_code);
    }
}


//init lis3dh
void init_lis() 
{
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG1, sizeof(LIS3DH_CTRL_REG1), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG2, sizeof(LIS3DH_CTRL_REG2), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG3, sizeof(LIS3DH_CTRL_REG3), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG4, sizeof(LIS3DH_CTRL_REG4), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG5, sizeof(LIS3DH_CTRL_REG5), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG6, sizeof(LIS3DH_CTRL_REG6), NULL, 0);
}



//spi user event handler
void spi_event_handler(nrf_drv_spi_evt_t const * p_event,
                       void *                    p_context)
{
    spi_xfer_done = true;
    printf("Transfer completed.");
}



/**
 * @brief Function for main application entry.
 */
int main(void)
{
    uint32_t err_code;

    const app_uart_comm_params_t comm_params =
      {
          RX_PIN_NUMBER,
          TX_PIN_NUMBER,
          RTS_PIN_NUMBER,
          CTS_PIN_NUMBER,
          UART_HWFC,
          false,
          NRF_UART_BAUDRATE_115200
      };

    APP_UART_FIFO_INIT(&comm_params,
                         UART_RX_BUF_SIZE,
                         UART_TX_BUF_SIZE,
                         uart_error_handle,
                         APP_IRQ_PRIORITY_LOWEST,
                         err_code);

    bsp_board_leds_init();

    printf("\r\nStart: \r\n");

    nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;  //SPI master driver instance configuration
    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_2M; // data rate: 2 Mbps
    spi_config.mode     = NRF_DRV_SPI_MODE_3;	// SPI mode: SCK active low, sample on trailing edge of clock.
    nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL); //Function for initializing the SPI master driver instance
    
    printf("\r\nSPI config done! \r\n");

    APP_ERROR_CHECK(err_code);

    init_lis();
    
    uint8_t read_data_1 = nrf_drv_spi_transfer(&spi, LIS3DH_WHO_AM_I_REG, sizeof(LIS3DH_WHO_AM_I_REG), read_data, sizeof(read_data));
    printf("\r\nWHO_AM_I: %x\n", read_data_1);  //value: 0x11 ??
    /*
    nrf_drv_spi_transfer(&spi, LIS3DH_WHO_AM_I_REG, sizeof(LIS3DH_WHO_AM_I_REG), read_data, sizeof(read_data));
    printf("\r\nWHO_AM_I: %x\n", read_data[1]);  //value: 0x0 ?? 
    */

}


/** @} */

Here I get the value "0x11" instead of "0x33":

 uint8_t read_data_1 = nrf_drv_spi_transfer(&spi, LIS3DH_WHO_AM_I_REG, sizeof(LIS3DH_WHO_AM_I_REG), read_data, sizeof(read_data));
    printf("\r\nWHO_AM_I: %x\n", read_data_1);  //value: 0x11 ??

And here I get the value "0x0" instead of "0x33":

nrf_drv_spi_transfer(&spi, LIS3DH_WHO_AM_I_REG, sizeof(LIS3DH_WHO_AM_I_REG), read_data, sizeof(read_data));
printf("\r\nWHO_AM_I: %x\n", read_data[1]);  //value: 0x0 ??

Thanks in advance,

Christoph

[hmolesworth]

Several issues in the code above, try the following changes:

uint8_t read_data[1];
change to:
// 2-byte receive array, 2nd byte will contain Id
uint8_t read_data[2];

A read operation is required for the Id, so try this:

uint8_t LIS3DH_WHO_AM_I_REG[] = {0x0F};
Change to:
// Set ms bit to perform a read
uint8_t LIS3DH_WHO_AM_I_REG[] = {0x80 | 0x0F};

The data sheet implies Mode 3, but I find Mode 0 works best:

    spi_config.mode     = NRF_DRV_SPI_MODE_0;

This should now work, but I would suggest making this the first operation before init_lis():

    nrf_drv_spi_transfer(&spi, LIS3DH_WHO_AM_I_REG, sizeof(LIS3DH_WHO_AM_I_REG), read_data, sizeof(read_data));
    printf("\r\nWHO_AM_I: %x\n", read_data[1]);  //print 2nd returned byte, which will be Id 

Once it works, the clock speed can be increased to 8MHz, although if connected by long traces SCK and MOSI and CS might require H0H1 drive levels at the faster clock speed. Good luck!

[Christoph_I]

Hey hmolesworth,

the changes doesn't work. Now I get: 0x0.

Here is my current code:

/**
 * Copyright (c) 2014 - 2017, Nordic Semiconductor ASA
 * 
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 * 
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 * 
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 * 
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 * 
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 */
/** @file
 * @defgroup uart_example_main main.c
 * @{
 * @ingroup uart_example
 * @brief UART Example Application main file.
 *
 * This file contains the source code for a sample application using UART.
 *
 */

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <math.h>
#include "app_uart.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "nrf.h"
#include "bsp.h"
#if defined (UART_PRESENT)
#include "nrf_uart.h"
#endif
#if defined (UARTE_PRESENT)
#include "nrf_uarte.h"
#endif

//spi header
#include <nrf_drv_spi.h>
#include "app_util_platform.h"
#include "nrf_gpio.h"
#include "boards.h"
#include <string.h>
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"


#define MAX_TEST_DATA_BYTES     (15U)                /**< max number of test bytes to be used for tx and rx. */
#define UART_TX_BUF_SIZE 256                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE 256                         /**< UART RX buffer size. */
#define UART_HWFC APP_UART_FLOW_CONTROL_DISABLED     /* When UART is used for communication with the host do not use flow control.*/


//spi variables
#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. */
uint8_t read_data[2]; //2-byte receive array, 2nd byte will contain id

//accel input register
uint8_t LIS3DH_CTRL_REG1[] = {0x20, 0x47}; //all axes, normal, 50Hz
uint8_t LIS3DH_CTRL_REG2[] = {0x21, 0x00}; //no highpass filter
uint8_t LIS3DH_CTRL_REG3[] = {0x22, 0x00}; //no interrupts
uint8_t LIS3DH_CTRL_REG4[] = {0x23, 0x88}; //all defaults
uint8_t LIS3DH_CTRL_REG5[] = {0x24, 0x00}; //all defaults
uint8_t LIS3DH_CTRL_REG6[] = {0x25, 0x00}; //all defaults


//accel output register
uint8_t LIS3DH_WHO_AM_I_REG[] = {0x80 | 0x0F};  // Set ms bit to perform a read
uint8_t LIS3DH_OUT_X_H[] = {0x29};
uint8_t LIS3DH_OUT_X_L[] = {0x28};
uint8_t LIS3DH_OUT_Y_H[] = {0x2B};
uint8_t LIS3DH_OUT_Y_L[] = {0x2A};
uint8_t LIS3DH_OUT_Z_H[] = {0x2D};
uint8_t LIS3DH_OUT_Z_L[] = {0x2C};


//uart error handle
void uart_error_handle(app_uart_evt_t * p_event)
{
    if (p_event->evt_type == APP_UART_COMMUNICATION_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_communication);
    }
    else if (p_event->evt_type == APP_UART_FIFO_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_code);
    }
}


//init lis3dh
void init_lis() 
{
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG1, sizeof(LIS3DH_CTRL_REG1), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG2, sizeof(LIS3DH_CTRL_REG2), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG3, sizeof(LIS3DH_CTRL_REG3), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG4, sizeof(LIS3DH_CTRL_REG4), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG5, sizeof(LIS3DH_CTRL_REG5), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG6, sizeof(LIS3DH_CTRL_REG6), NULL, 0);
}



//spi user event handler
void spi_event_handler(nrf_drv_spi_evt_t const * p_event,
                       void *                    p_context)
{
    spi_xfer_done = true;
    printf("Transfer completed.");
}



/**
 * @brief Function for main application entry.
 */
int main(void)
{
    uint32_t err_code;

    const app_uart_comm_params_t comm_params =
      {
          RX_PIN_NUMBER,
          TX_PIN_NUMBER,
          RTS_PIN_NUMBER,
          CTS_PIN_NUMBER,
          UART_HWFC,
          false,
          NRF_UART_BAUDRATE_115200
      };

    APP_UART_FIFO_INIT(&comm_params,
                         UART_RX_BUF_SIZE,
                         UART_TX_BUF_SIZE,
                         uart_error_handle,
                         APP_IRQ_PRIORITY_LOWEST,
                         err_code);

    bsp_board_leds_init();

    printf("\r\nStart: \r\n");

    nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;  //SPI master driver instance configuration
    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_2M; // data rate: 2 Mbps
    spi_config.mode     = NRF_DRV_SPI_MODE_0;	// SPI mode: SCK active low, sample on trailing edge of clock.
    nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL); //Function for initializing the SPI master driver instance
    
    printf("\r\nSPI config done! \r\n");

    APP_ERROR_CHECK(err_code);
    
    nrf_drv_spi_transfer(&spi, LIS3DH_WHO_AM_I_REG, sizeof(LIS3DH_WHO_AM_I_REG), read_data, sizeof(read_data));
    printf("\r\nWHO_AM_I: %x\n", read_data[1]);  //print 2nd returned byte, which will be Id 

    init_lis();

}


/** @} */

And I don't know where is the issue..

[hmolesworth]

Hope you had a good Christmas! Actually your code does work now, I just ran it (on a LIS2DH12, very similar part)! I tried both 2MHz and 8MHz and both return 0x33 as expected. I had printfs commented out and just put in a breakpoint to look at the 2-byte returned values:

int test_main(void)
{
    uint32_t err_code;
    //printf("\r\nStart: \r\n");
    nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;  //SPI master driver instance configuration
    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; // data rate: 2 Mbps
    spi_config.mode     = NRF_DRV_SPI_MODE_0;	// SPI mode: SCK active low, sample on trailing edge of clock.
    nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL); //Function for initializing the SPI master driver instance
    //printf("\r\nSPI config done! \r\n");
    APP_ERROR_CHECK(err_code);
    nrf_drv_spi_transfer(&spi, LIS3DH_WHO_AM_I_REG, sizeof(LIS3DH_WHO_AM_I_REG), read_data, sizeof(read_data));
    //printf("\r\nWHO_AM_I: %x\n", read_data[1]);  //print 2nd returned byte, which will be Id 
    init_lis();
}

Maybe share your circuit (or at least the part of the LIS3DH).in case there is some issue, perhaps i/o pin voltage. Typically (LIS2DH12) pins 5,6,7,8 are all Gnd; pins 9,10 share nRF52832 Vdd; LIS3 is similar but different pins

[Christoph_I]

Hey hmolesworth,

yes thanks, I hope you had a good Christmas too! Ok, I insert photos of my development kit, Uart-to-USB-Bridge and the LIS3DH-circuit. At first I wanted to say, that I changed my code a little bit and got more terminal output.

My changes:

//from this
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_2M;

//to this
spi_config.ss_pin   = 22;
spi_config.miso_pin = 24;
spi_config.mosi_pin = 23;
spi_config.sck_pin  = 25;
spi_config.frequency = NRF_DRV_SPI_FREQ_8M;

And now I got this output:

I think that the manual pin configuration made SPI transfers and the spi_event_handler (code below) was triggered by it.

//spi user event handler
void spi_event_handler(nrf_drv_spi_evt_t const * p_event,
                       void *                    p_context)
{
    spi_xfer_done = true;
    printf("\r\nTransfer completed. \r\n");
}

From here come photos and circuits of the components:

-BL652_SA:

Here is the BL652-SA datasheet: https://connectivity-staging.s3.us-east-2.amazonaws.com/2019-05/CS-DS-BL652%20v2_9.pdf

I can send BL652_SA circuit by mail, if you want. Maybe it's not allowed to public the circuit in a forum.

-LIS3DH:

*photo removed*  ->not public

circuit:

*removed*  ->not public

->pin6: 3.3V, pin5: GND, pin4: SCL 3.3V, pin3: MOSI, pin2:MISO, pin1:CSD/SS

Connector:

MOSI and MISO connectioh to board:

SCL and SS connection to board:

VDD and GND connection to board:

-USB-to-UART-Bridge:

I hope this will help. I can insert more photos if needed.

PS: hmolesworth thank you for your dedication to help me!

[hmolesworth]

Two issues.

The major problem is that this is incorrect

pin6: 3.3V, pin5: GND, pin4: SCL 3.3V, pin3: MOSI, pin2:MISO, pin1:CSD/SS

Swap MOSI and MISO definitions thus:

pin6: 3.3V, pin5: GND, pin4: SCL 3.3V, pin3: MISO, pin2:MOSI, pin1:CSD/SS

Why? pin 7 on the LIS3DH is SPI serial data output (SDO) from LIS3DH, so therefore is MISO on the nRF52832. Swapping the pin definitions in the code will fix that.

The second issue - which you can ignore for now - is that Laird have been naughty in suggesting port pins in the range P22-P31 can be used as SPI. I quote:

4.3.1 GPIO located near the radio
Radio performance parameters, such as sensitivity, may be affected by high frequency digital I/O with large sink/source current close to the Radio power supply and antenna pins. Table 5: GPIO recommended usage for QFN48 package on page 17 and Table 6: GPIO recommended usage for WLCSP package on page 17 identify some GPIO that have recommended usage guidelines to maximize radio performance in an application.

What's the workaround? Don't expect to SPI at the same time as BLEing without data transmission issues

One other point, using long wires off-board to another dev board causes soggy edges due to parasitic capacitance and hence significant CR quite apart from acting as a transmission line which causes ringing (false data) when not properly terminated. You can start by boosting drive levels to the outputs thus (after SPI init):

  nrf_gpio_cfg(SPI_SS,       NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_DISCONNECT, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_H0H1, NRF_GPIO_PIN_NOSENSE);
  nrf_gpio_cfg(SPI_MOSI_PIN, NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_DISCONNECT, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_H0H1, NRF_GPIO_PIN_NOSENSE);
  nrf_gpio_cfg(SPI_SCK_PIN,  NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_DISCONNECT, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_H0H1, NRF_GPIO_PIN_NOSENSE);

[Christoph_I]

Hey hmolesworth,

thank you very much, you are such an expert. I executed your recommended changes (I didn't swap the pin definitions in the code, but swapped the wires from the LIS to the MOSI and MISO connection; added the boosting drive levels to the outputs) and finally I get the value 0x33 from WHO_AM_I-Register. But I only get the value when I make the WHO_AM_I operation after init_lis().

But there are some things I don't understand:

1) In the boosting drive levels to the outputs in the code below:

nrf_gpio_cfg(SPI_SS,       NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_DISCONNECT, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_H0H1, NRF_GPIO_PIN_NOSENSE);

What means NRF_GPIO_PIN_H0H1? I know that this is the drive configuration, but I don't understand High drive '0', high-drive '1':

NRF_GPIO_PIN_H0H1 = GPIO_PIN_CNF_DRIVE_H0H1, ///< !< High drive '0', high-drive '1'.

2) The 0x80 in the brackets.

uint8_t LIS3DH_WHO_AM_I_REG[] = {0x80 | 0x0F};  // Set ms bit to perform a read

This is a bit to perform a read or? And what means ms? And is {0x80 | 0x0F} the same as "0x80 OR 0x0F" and can be written like { 0x8F } ? And do I need the read bit in every read-operation (e.g. to read the X_H_Register)?

3) And why do I need two bytes for reading registers? In my case:

uint8_t read_data[2];

The 2nd byte will contain the ID (output value from register), and the first byte? Contain the first byte the register address?

4) Six months ago I only used the acceleration sensor as a 2-point-controller for a robot-car that drives up a ramp autonomously (with i2c). The car has permanently read out the x-axis of the acceleration sensor and  has steered the car accordingly.

But now my goal is to record vibrations and therefore acceleration with the sensor. As a first step, I considered reading an axis (e.g. X_HIGH_Register / LIS3DH_OUT_X_H[] ). But here I only get the same value "d5". But I don't know why? Do I have to permanently delete the value in array read_data after every printf? I will post my code here:

/**
 * Copyright (c) 2014 - 2017, Nordic Semiconductor ASA
 * 
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 * 
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 * 
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 * 
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 * 
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 */
/** @file
 * @defgroup uart_example_main main.c
 * @{
 * @ingroup uart_example
 * @brief UART Example Application main file.
 *
 * This file contains the source code for a sample application using UART.
 *
 */

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <math.h>
#include "app_uart.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "nrf.h"
#include "bsp.h"
#if defined (UART_PRESENT)
#include "nrf_uart.h"
#endif
#if defined (UARTE_PRESENT)
#include "nrf_uarte.h"
#endif

//spi header
#include <nrf_drv_spi.h>
#include "app_util_platform.h"
#include "nrf_gpio.h"
#include "boards.h"
#include <string.h>
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"


#define MAX_TEST_DATA_BYTES     (15U)                /**< max number of test bytes to be used for tx and rx. */
#define UART_TX_BUF_SIZE 256                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE 256                         /**< UART RX buffer size. */
#define UART_HWFC APP_UART_FLOW_CONTROL_DISABLED     /* When UART is used for communication with the host do not use flow control.*/


//spi variables
#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. */
uint8_t read_data[2]; //2-byte receive array, 2nd byte will contain id

//accel input register
uint8_t LIS3DH_CTRL_REG1[] = {0x20, 0x47}; //all axes, normal, 50Hz
uint8_t LIS3DH_CTRL_REG2[] = {0x21, 0x00}; //no highpass filter
uint8_t LIS3DH_CTRL_REG3[] = {0x22, 0x00}; //no interrupts
uint8_t LIS3DH_CTRL_REG4[] = {0x23, 0x88}; //all defaults
uint8_t LIS3DH_CTRL_REG5[] = {0x24, 0x00}; //all defaults
uint8_t LIS3DH_CTRL_REG6[] = {0x25, 0x00}; //all defaults


//accel output register
uint8_t LIS3DH_WHO_AM_I_REG[] = {0x80 | 0x0F};  // Set ms bit to perform a read
uint8_t LIS3DH_OUT_X_H[] = {0x80 | 0x29};
uint8_t LIS3DH_OUT_X_L[] = {0x28};
uint8_t LIS3DH_OUT_Y_H[] = {0x2B};
uint8_t LIS3DH_OUT_Y_L[] = {0x2A};
uint8_t LIS3DH_OUT_Z_H[] = {0x2D};
uint8_t LIS3DH_OUT_Z_L[] = {0x2C};


//uart error handle
void uart_error_handle(app_uart_evt_t * p_event)
{
    if (p_event->evt_type == APP_UART_COMMUNICATION_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_communication);
    }
    else if (p_event->evt_type == APP_UART_FIFO_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_code);
    }
}


//init lis3dh
void init_lis() 
{
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG1, sizeof(LIS3DH_CTRL_REG1), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG2, sizeof(LIS3DH_CTRL_REG2), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG3, sizeof(LIS3DH_CTRL_REG3), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG4, sizeof(LIS3DH_CTRL_REG4), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG5, sizeof(LIS3DH_CTRL_REG5), NULL, 0);
        nrf_drv_spi_transfer(&spi, LIS3DH_CTRL_REG6, sizeof(LIS3DH_CTRL_REG6), NULL, 0);
}



//spi user event handler
void spi_event_handler(nrf_drv_spi_evt_t const * p_event,
                       void *                    p_context)
{
    spi_xfer_done = true;
    printf("\r\nTransfer completed. \r\n");
}



/**
 * @brief Function for main application entry.
 */
int main(void)
{
    uint32_t err_code;

    const app_uart_comm_params_t comm_params =
      {
          RX_PIN_NUMBER,
          TX_PIN_NUMBER,
          RTS_PIN_NUMBER,
          CTS_PIN_NUMBER,
          UART_HWFC,
          false,
          NRF_UART_BAUDRATE_115200
      };

    APP_UART_FIFO_INIT(&comm_params,
                         UART_RX_BUF_SIZE,
                         UART_TX_BUF_SIZE,
                         uart_error_handle,
                         APP_IRQ_PRIORITY_LOWEST,
                         err_code);

    bsp_board_leds_init();

    printf("\r\nStart: \r\n");

    nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;  //SPI master driver instance configuration
    spi_config.ss_pin   = 22;
    spi_config.miso_pin = 24;   
    spi_config.mosi_pin = 23;   
    spi_config.sck_pin  = 25;
    spi_config.frequency = NRF_DRV_SPI_FREQ_8M; // data rate: 8 Mbps
    spi_config.mode     = NRF_DRV_SPI_MODE_0;	// SPI mode: SCK active low, sample on trailing edge of clock.
    nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL); //Function for initializing the SPI master driver instance
    
    printf("\r\nSPI config done! \r\n");

    APP_ERROR_CHECK(err_code);
    
    nrf_drv_spi_transfer(&spi, LIS3DH_WHO_AM_I_REG, sizeof(LIS3DH_WHO_AM_I_REG), read_data, sizeof(read_data));
    printf("\r\nWHO_AM_I: %x\n", read_data[1]);  //print 2nd returned byte, which will be Id 

    init_lis();

    //boosting drive levels to the outputs
    nrf_gpio_cfg(22,  NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_DISCONNECT, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_H0H1, NRF_GPIO_PIN_NOSENSE);
    nrf_gpio_cfg(23,  NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_DISCONNECT, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_H0H1, NRF_GPIO_PIN_NOSENSE);
    nrf_gpio_cfg(25,  NRF_GPIO_PIN_DIR_OUTPUT, NRF_GPIO_PIN_INPUT_DISCONNECT, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_H0H1, NRF_GPIO_PIN_NOSENSE);

    nrf_drv_spi_transfer(&spi, LIS3DH_WHO_AM_I_REG, sizeof(LIS3DH_WHO_AM_I_REG), read_data, sizeof(read_data));
    printf("\r\nWHO_AM_I: %x\n", read_data[1]);  //print 2nd returned byte, which will be Id 

    while(true)
    {
        nrf_drv_spi_transfer(&spi, LIS3DH_OUT_X_H, sizeof(LIS3DH_OUT_X_H), read_data, sizeof(read_data));
        printf("\r\nLIS3DH_OUT_X_H: %x\n", read_data[1]);  //print 2nd returned byte, which will be Id 
        nrf_delay_ms(200); 
    }

}


/** @} */

My Output:

As a professional, what do you think of my approach to reach my goal (measure vibration and acceleration)?

PS: I wish you a happy new year! Slip in well.

[hmolesworth]

Ah, well  .. since you said nice things I'll give you a few more tips. Most of the time I am too busy on projects, but it's New year's Eve so here's some pointers.

1. H1 applies to the drive level when the port pin is high; H0 is the drive level when low. They are independent; you can use standard drive or high drive for both low-level and high-level. Standard drive uses less power (less mA available), so is preferred except when driving long wires and high capacitance of very high clock rates. Once the pin reaches its level (high or low) power is no longer an issue in most cases, it's only the transition that consumes power assuming no significant resistive pin loading (ie SPI).

2. "ms" is "Most Significant bit", biit 7 in an 8-bit byte.. {0x80 | 0x0F} is not the same as "0x80 OR 0x0F" but yes you can use 0x8F

3. Look at some of my other posts answering questions. SPI is a very good simple synchronous physical-layer protocol which simultaneously receives a byte for every byte transmitted. The slave - LIS3DH in this case - isn't great at premonition, so it doesn't know what you are asking until you ask - that's the first byte, Then it responds to the ask, that's the 2nd byte.

4. I would read x,y,z in 12-bit modes. It helps to decide where do the 12 bits come from; they are available in 2 consecutive 8-bit registers

typedef struct {
   uint8_t OUT_d_L;       // LIS2DH12_OUT_XYX_L
   uint8_t OUT_d_H;       // LIS2DH12_OUT_XYZ_H
}__attribute__((packed)) axis_t;

ypedef union {
   axis_t   Bytes;       // LIS2DH12_OUT_X_L, H           0x28, 0x29
   int16_t  sWord;
}__attribute__((packed)) axisUn_t;

typedef struct {
   axisUn_t rOUT_X;        // LIS2DH12_OUT_X_L,H         0x28,29
   axisUn_t rOUT_Y;        // LIS2DH12_OUT_Y_L,H         0x2A,2B
   axisUn_t rOUT_Z;        // LIS2DH12_OUT_Z_L,H         0x2C,2D
}__attribute__((packed)) reg2_t;

So with a single SPI command read all the consecutive registers (3 x 2 = 6 bytes), something like this:

reg2_t BlahBlah;
int16_t X, Y, Z;
ReadAccRegisters(); // sequential byte read into BlahBlah
// Ensure we have correct sign extension, also assuming even byte alignment
X = BlahBlah.rOUT_X.sWord / 16;
Y = BlahBlah.rOUT_Y.sWord / 16;
Z = BlahBlah.rOUT_Z.sWord / 16;

The goal is to read the 6 bytes into an array and then interpret them as signed 12-bit which will be used as signed 16-bit (since you don't have a 12-bit processor)

Hapy new Year!