SPI burst write fails on NRF52832

RE: SPI burst write fails on NRF52832

Edvin — Tue, 25 Jan 2022 14:54:03 GMT

Hello,

Can you try to analyze the SPI using a logic analyzer that is capable of decoding the output signal?

Just to see if the output data equals what you think you are sending?

Best regards,

Edvin

RE: SPI burst write fails on NRF52832

rayan4444 — Fri, 21 Jan 2022 08:50:56 GMT

I just looked into this and I'm pretty sure the data is copied in RAM before getting sent:
Unless I missed something?

I can also see the signal on the oscilloscope directly so I know data is going out. I am just confused as to why it seems to get corrupted during the transfer.

int8_t spi_write(uint8_t cs_pin, uint8_t reg_addr, uint8_t *reg_data, uint8_t length)
{
    ret_code_t ret;
    
    // I copy the data in RAM here //
    uint8_t temp_buff[length +1];
    temp_buff[0]=reg_addr;
    memcpy(&temp_buff[1], reg_data, length);

    spi_xfer_done = false;
    ret = nrf_drv_spi_transfer(&spi_instance, temp_buff, length+1, NULL, 0);
    while(!spi_xfer_done)
    {
        __WFE();
    }
    return ret;
}

RE: SPI burst write fails on NRF52832

rayan4444 — Fri, 21 Jan 2022 08:45:28 GMT

In SPI modes 1 and 2 there is no response at all from the sensor, which is normal because it is only compatible with modes 3 and 0. In modes 3 and zero I get the same behaviour:
- I can read and write all commands I need, the only operation that fails is writing the sensor configuration file.

The initialization sequence is the following:

/*!
 * @brief Initialize and configure the BMA accelerometer 
 * @param[in]  bma      : pointer to the BMA struct
 * @param[in]  imu      : the specific IMU we want to initialize
 * @param[in] interrupt : wether we want to tie the interupt pin or not
 */
int8_t bma456_imu_init(struct bma4_dev *bma, bool interrupt){
    printf("initializing started\n");
    int8_t ret = BMA4_OK;

    bma->intf = BMA4_SPI_INTF;                 /*Select SPI Interface */
    bma->read_write_len = BMA456_READ_WRITE_LEN;   /*! Read/write length */
    bma->delay_us = user_delay;                     /*! Delay(in microsecond) function pointer */

    /* Function to select interface between SPI and I2C, according to that the device structure gets updated */
    /* THIS WORKS */
    ret = bma4_interface_selection(bma);
    printf("SS pin: %d\n", (int)SPI_SS0_PIN);
    printf("interface: %d\n", bma->intf);
    bma4_error_codes_print_result("bma4_interface_selection status", ret);

    /* Sensor initialization */
    /* THIS WORKS */
    ret = bma456_init(bma);
    printf("resolution: %d\n", bma->resolution);
    bma4_error_codes_print_result("bma456_init status", ret);

    if (ret == 0) { 
        
        printf("soft reset\n");
        /*Soft reset*/
        ret = bma4_soft_reset(bma);
        bma4_error_codes_print_result("bma456 soft reset status", ret);
    }
    
    /* Upload the configuration file to enable the features of the sensor. */
    /* THIS DOESN'T WORK */
    ret = bma456_write_config_file(bma);
    bma4_error_codes_print_result("bma456_write_config status", ret);

    /* Enable the accelerometer */
    /* THIS WORKS */
    ret = bma4_set_accel_enable(BMA4_ENABLE, bma);
    bma4_error_codes_print_result("bma4_set_accel_enable status", ret);

    /* Accelerometer configuration settings */
    struct bma4_accel_config accel_conf = { 0 };

    accel_conf.odr = BMA4_OUTPUT_DATA_RATE_100HZ; /* Output data Rate */

    /* Gravity range of the sensor (+/- 2G, 4G, 8G, 16G) */
    accel_conf.range = BMA4_ACCEL_RANGE_16G;

    /* The bandwidth parameter is used to configure the number of sensor samples that are averaged
     * if it is set to 2, then 2^(bandwidth parameter) samples
     * are averaged, resulting in 4 averaged samples
     * Note1 : For more information, refer the datasheet.
     * Note2 : A higher number of averaged samples will result in a less noisier signal, but
     * this has an adverse effect on the power consumed.
     */
    accel_conf.bandwidth = BMA4_ACCEL_NORMAL_AVG4;

    /* Enable the filter performance mode where averaging of samples
     * will be done based on above set bandwidth and ODR.
     * There are two modes
     *  0 -> Averaging samples (Default)
     *  1 -> No averaging
     * For more info on No Averaging mode refer datasheet.
     */
    // accel_conf.perf_mode = BMA4_CONTINUOUS_MODE;
    accel_conf.perf_mode = BMA4_CIC_AVG_MODE;

    /* Set the accel configurations */
    /* THIS WORKS */
    ret = bma4_set_accel_config(&accel_conf, bma);
    bma4_error_codes_print_result("bma4_set_accel_config status", ret);

    if (interrupt)
    {
        /* Mapping data ready interrupt with interrupt pin 1 to get interrupt status once getting new accel data */
        ret = bma456_map_interrupt(BMA4_INTR1_MAP, BMA4_DATA_RDY_INT, BMA4_ENABLE, bma);
        bma4_error_codes_print_result("bma456_map_interrupt status", ret);
    }
    printf("init done\n");

    return ret;    
}

You are right, most examples are for i2C, and SPI does require a dummy byte, but that is handled by the bosch API here:
(in fact, I can read data just fine, it's that specific write operation that fails)

/*!
 *  @brief This API reads the 8-bit data from the given register
 *  in the sensor.
 */
static int8_t read_regs(uint8_t addr, uint8_t *data, uint32_t len, struct bma4_dev *dev)
{
    int8_t rslt;

    /* Check the dev structure as NULL */
    rslt = null_pointer_check(dev);

    if ((rslt == BMA4_OK) && (data != NULL))
    {
        /* variable used to return the status of communication result*/
        uint32_t temp_len = len + dev->dummy_byte;
        uint16_t indx;
        uint8_t temp_buff[temp_len];

        if (dev->intf == BMA4_SPI_INTF)
        {
            /* SPI mask added */
            addr = addr | BMA4_SPI_RD_MASK;
        }

        /* Read the data from the register */
        dev->intf_rslt = dev->bus_read(dev->cs_pin, addr, temp_buff, temp_len);

        if (dev->intf_rslt == BMA4_INTF_RET_SUCCESS)
        {
            for (indx = 0; indx < len; indx++)
            {
                /* Parsing and storing the valid data */
                data[indx] = temp_buff[indx + dev->dummy_byte];
            }
        }
        else
        {
            rslt = BMA4_E_COM_FAIL;
        }
    }
    else
    {
        rslt = BMA4_E_NULL_PTR;
    }

    return rslt;
}

RE: SPI burst write fails on NRF52832

hmolesworth — Wed, 19 Jan 2022 16:16:38 GMT

At first sight it's worth checking the memory location of the data you are trying to stream; if it's the config data note this:

const uint8_t bma456_config_file[] = {

The const means this data is in flash memory which will not work with DMA unless first copied to RAM. Put a breakpoint in your spi_write() function and look at the memory address the buffer is pointing to; if the source address is actually bma456_config_file[] (or any other const data) then this is the problem.

RE: SPI burst write fails on NRF52832

Edvin — Wed, 19 Jan 2022 11:07:21 GMT

Hello,

What is the difference between "don't work" and "same behavior as the original post". How does it behave exactly?

I have never used this sensor before, nor used the driver that you linked to. What does your bma456_imu_init() look like?

I also noticed that most of the README.md is written for I2C. When I searched for SPI I found this. Do you use the dummy_read to switch the sensor to SPI?

Best regards,

Edvin

RE: SPI burst write fails on NRF52832

rayan4444 — Tue, 18 Jan 2022 14:51:34 GMT

Hello! Thank you for getting back to me :)

I've tried all the SPI modes:
- Modes 1 and 2 don't work with the sensor (and that is expected, given the datasheet)
- Modes 0 and 3 have the same behavior as the original post

Is there anything else you'd suggest looking into?

RE: SPI burst write fails on NRF52832

Edvin — Tue, 18 Jan 2022 13:39:27 GMT

Hello,

The first thing that comes to mind is that you are using the wrong SPI mode. I don't think the state of the MOSI pin matters when the clock has stopped.

Try changing NRF_DRV_SPI_MODE_0 to NRF_DRV_SPI_MODE_1, NRF_DRV_SPI_MODE_2, or NRF_DRV_SPI_MODE_3. If none of them works, please let me know.

Best regards,

Edvin