How to use spi_write_dt

RE: How to use spi_write_dt

jbeh444 — Mon, 08 Jan 2024 15:36:33 GMT

Thank you for all the help!! I think I understand this function well enough to use it for our needs!

RE: How to use spi_write_dt

Einar Thorsrud — Fri, 05 Jan 2024 09:42:31 GMT

Hi,

This looks sensible to me. If it does not wok, I would consider modifying your custom board to get the signals out so that you can look at them (or use a DK and connect the sensor to it and test your code there if that is easier).

Regarding reviewing hardware, you can make a private ticket here (select "PRICATE Tech Support") and upload your schematic and layout files (in gerber format) for review.

RE: How to use spi_write_dt

jbeh444 — Wed, 03 Jan 2024 16:19:11 GMT

Hello,

This was very helpful! I have been trying to wrap my head around buffers and you have help me understand them better! The SPI MOSI on this custom board is impossible to access as there were no connections made to access the pins (sorry, I know you asked about it twice and I forgot to mention it).

Here is the updated code:

static uint8_t buffer[5025]; //declared globaly

BMA4_INTF_RET_TYPE bma4_spi_write(uint8_t reg_addr, const uint8_t *reg_data, uint32_t len, void *intf_ptr)
{    
    
    buffer[0] = reg_addr;
    memcpy(&buffer[1], &reg_data, len);    
   
    /*This SPI attempts to put the register address in front of the data buffer */
    struct spi_buf tx = {
    .buf = buffer,.len = len+1        
    };

    const struct spi_buf_set tx_bufs = {
    .buffers = &tx,.count = 1
    };

    rslt= spi_write_dt(&dev_spi, &tx_bufs);          
    return rslt;
}

On a side note, I was hoping to review a custom board design with Nordic. We are using the NPM1100 and the nRF52832-CIAA. Do I just ask about it on a private chat over the DevZone?

RE: How to use spi_write_dt

Einar Thorsrud — Wed, 03 Jan 2024 15:03:21 GMT

Hi,

Yes, this is more or less what I was thinking. With one important exception that your declare a buffer of variable length, and it is also on the stack. So the first line here should probably be something like this instead:

static uint8_t buffer[BMA4_MAX_LEN]; // BMA4_MAX_LEN should have a value that is larger than you will ever need

Does this not work? If not, why? How does the Tx (MOSI) signal look and how is it compared to what you would expect?

RE: How to use spi_write_dt

jbeh444 — Tue, 02 Jan 2024 23:04:01 GMT

Hello,

Thank you for getting back to me. Your insight and help is much appreciated. My biggest issue is trying to understand how to use the buffers in the way you described. Here is another attempt and any help would be very appreciated!

  uint8_t buffer[len +1];
    buffer[0] = reg_addr;
    memcpy(&buffer[1], &reg_data, len);    
   
    /*This SPI attempts to put the register address in front of the data buffer */
    struct spi_buf tx[] = {
        {.buf = buffer,.len = len+1}, 
        //{.buf = (uint8_t *)reg_data,.len = len}, 
    };

    const struct spi_buf_set tx_bufs = {
    .buffers = tx,.count = 1
    };

    rslt= spi_write_dt(&dev_spi, &tx_bufs);          
    return rslt;

RE: How to use spi_write_dt

Einar Thorsrud — Tue, 02 Jan 2024 14:09:20 GMT

Hi,

I see burst write is supported by the BMA456 for the initialization data, then you write the 1 byte address and the multi byte data. I am not sure why yo split this up in two Tx buffers, though. This is one transaction, so I would make a single buffer and copy the data in to the first possition (index 0), and the data to the next position (index 1 and so on in case you have more data for a burst write). Other than that I don't see any problems.

In what way does it not work? If you look at the data on the SPI line with a logic analyzer, how does it differ from what you would have expected?

RE: How to use spi_write_dt

jbeh444 — Sun, 31 Dec 2023 22:35:41 GMT

BMA4_INTF_RET_TYPE bma4_spi_write(uint8_t reg_addr, const uint8_t *reg_data, uint32_t len, void *intf_ptr)
{    
    struct spi_buf tx[2];
    tx[0].buf = &reg_addr;
    tx[0].len = 1;  
    tx[1].buf = (uint8_t *)reg_data;
    tx[1].len = len;        
   
    const struct spi_buf_set tx_bufs = {
        .buffers = tx,
        .count = ARRAY_SIZE(tx)
    };     
    rslt= spi_write_dt(&dev_spi, &tx_bufs);       
    return rslt;
}

This seems to almost do what I want it to. I think I may not be addressing the write properly. I would love to just have register address in front of the data buffer, but I can't seem to wrap my head around the steps to do that.

RE: How to use spi_write_dt

Øyvind — Wed, 27 Dec 2023 09:59:16 GMT

Hello,

We are severely understaffed this week because of the Christmas holidays, and Einar will have to get back to you on this next week. Sorry for the inconvenience.

Kind regards,
Øyvind

RE: How to use spi_write_dt

jbeh444 — Sat, 23 Dec 2023 23:00:10 GMT

Hello Einar,

Thank you for the update. I look forward to hearing back from you after the holidays.

Here is some additional info for the time being.

I need the SPI function to write a configuration file approximately 5016 bytes which can be broken up into smaller pieces. This is passed to the write function as a pointer to the file.I can't wrap my head around how to do that with the spi_buf and spi_buf_set structs.

I am having trouble understanding the zephyr version spi_write_dt and having changeable sizes of transactions they seem to want the same size buffers for every SPI transaction.

I have tried to get a different version of SPI to work using the spim examples in the ncs folder, but it ultimately wouldn't initialize the SPI and seemed like it needed a ton of different files (header and .c) to get working.

Thanks again,

Jared

RE: How to use spi_write_dt

Einar Thorsrud — Fri, 22 Dec 2023 14:16:56 GMT

Hi Jared,

I have not had a chance to look at this unfortuantely, and I will be OoO next week. DevZone will also have reduced staffing. That said, I se Bosch has a driver that you may look at.

RE: How to use spi_write_dt

jbeh444 — Thu, 21 Dec 2023 16:53:41 GMT

Thank you for the great insight! The I2c version worked on this sensor on the dev kit. We moved to a custom board which the pins were switch to an SPI. I am now attempting to correct this by getting the SPI working. The BMA456 uses a burst write to write a config file. To change settings, it does a burst read on the same register. I am trying to understand how to write a file of 5016 bytes and what the limits are on the SPI TX.

#1 I need the read function to be a modifiable buffer size because the number of bytes it reads can vary. The read must be saved to reg_data in the function call as this is what the other functions read to see if the chip_id and register data is correct.

#2 The write function needs to be a modifiable buffer of various sizes as well.

I apologize for my lack of understanding about the SPI buffers and pointers to data.

Here is my latest attempt to modify the code to attempt to initialize the sensor.

BMA4_INTF_RET_TYPE bma4_spi_read(uint8_t reg_addr, uint8_t *reg_data, uint32_t len, void *intf_ptr)
{  
    static struct spi_buf rx;
    static struct spi_buf_set rx_bufs = {
    .buffers = &rx,
    .count = 1,
    };

    static struct spi_buf tx;
    static struct spi_buf_set tx_bufs = {
    .buffers = &tx,
    .count = 1,
    }; 
    
    tx.buf = &reg_addr;       
    tx.len = 1;
    rx.buf = reg_data;       
    rx.len = len;   
    rslt= spi_transceive_dt(&dev_spi, &tx_bufs, &rx_bufs);

    return rslt;
}

BMA4_INTF_RET_TYPE bma4_spi_write(uint8_t reg_addr, const uint8_t *reg_data, uint32_t len, void *intf_ptr)
{    
    struct spi_buf tx[len+1];
            
    tx[0].buf = &reg_addr;
    tx[0].len = 1; 
    for(int i = 0; i < len; i++)
    {
        tx[i+1].buf = (uint8_t*)reg_data+i; 
        tx[i+1].len = 1;       
    }      
    struct spi_buf_set tx_bufs = {
        .buffers = tx,
        .count = 1,
    };     
    rslt= spi_write_dt(&dev_spi, &tx_bufs);       
    return rslt;
}

RE: How to use spi_write_dt

Einar Thorsrud — Thu, 21 Dec 2023 08:09:48 GMT

Hi Jared,

[quote user="jbeh444"]I was hoping you could take a look at SPI code in the post and give me some pointers on best practices of how to make sure my data is in the proper format and length. When I create the buffer, it seems to cut off the rest of the data and only shows eight bits.[/quote]

I can take a look. I guess the relevant part is this function;

BMA4_INTF_RET_TYPE bma4_spi_write(uint8_t reg_addr, const uint8_t *reg_data, uint32_t len, void *intf_ptr)
{    
    uint8_t txbuffer[2] = {reg_addr, *reg_data};
    struct spi_buf tx = {
        .buf = txbuffer,  .len = sizeof(txbuffer),};
    struct spi_buf_set tx_bufs = {
        .buffers = &tx, .count = 1,};
    rslt= spi_write_dt(&dev_spi, &tx_bufs);       
    return rslt;
}

Here I see you ignore the len parameter of your function, and always set len in the spi_buf instante to the size of the array, which is 2. And that matches what I saw in the datasheet when I briefely looked yesterday. I did not read it carefully so I might be wrong, but it seemd to me like you always write a 1 byte address and 1 byte data. Then you could add on with another 1 byte address and 1 byte data, and so on. The latter is not supported by your function here.

If you wanted to do that you would have to buidl a larger array of every second byte addres an data. There should not be anything preventing you from doing that though. Essentially make your txbuffer larger, populate it properly, and that should be it. (I have no knowledge of the sensor though and did not carefully read the datasheet, so there may be details I am missing).

RE: How to use spi_write_dt

jbeh444 — Wed, 20 Dec 2023 16:38:48 GMT

Hello Einar,

Thank you for the quick response!

I was hoping you could take a look at SPI code in the post and give me some pointers on best practices of how to make sure my data is in the proper format and length. When I create the buffer, it seems to cut off the rest of the data and only shows eight bits.

Best regards,

Jared

RE: How to use spi_write_dt

Einar Thorsrud — Wed, 20 Dec 2023 13:31:56 GMT

Hi Jared,

SPI just transfers data, and if you are writing to a specific register on the slave device it just still just data seen from the nRF. From what I can see from the BMA400 datasheet under "SPI Interface and protocol", the address should just be the first byte when you write (then you can add another register and data byte if you like, and so on).

Einar