Sharing SPI interface between SD card and other peripheral

RE: Sharing SPI interface between SD card and other peripheral

Naeem Maroof — Fri, 25 Aug 2023 14:44:02 GMT

I don't know for sure whether I have exact answer for your query or not,

but we can see in the fatfs example that first static initializations are done and then there are two steps namely disk-initialization and disk-mounting. After these steps you can read and write from the disk. Similarly, afterwards we need to unmount and then uninitialize the disk if we want to use the other peripheral. I can see that just going through fatfs_example function takes approximately 10ms.

RE: Sharing SPI interface between SD card and other peripheral

Gianlucamilani — Tue, 22 Aug 2023 14:34:38 GMT

I guess that is internal to how disk drivers do the initialization. It might also depend on the size of the SD card.

Can you try different card size and again check if it makes any difference.

Also, number of files stored on the SDCard contribute to that time.

Perfect, thanks Naeem

I don't know what you mean here.

I mean: do you know the minimal set of commands/functions to reinitialize the SPI instance related to the SD?

RE: Sharing SPI interface between SD card and other peripheral

Naeem Maroof — Tue, 22 Aug 2023 14:04:26 GMT

Hello again,

[quote user="Gianlucamilani"]it is stated that the pin sharing between instances is possible.[/quote]

It would be possibly but you will have to do more, like uninitialize and reinitialize.

That is what that ticket has in its conclusion:

"Yeah, you're right. The SPIM0-2 uses SW Chip Select and you'll have to uninit and then re-init the driver with the new configuration (CS/SS pin and whatever else you want to change) whenever you want to address another slave"

[quote user="Gianlucamilani"]which is the minimal initalization procedure for the fatfs SPI[/quote]

I don't know what you mean here.

[quote user="Gianlucamilani"]I currently tried to calculate the time to run the fatfs example including the whole disk_initialize function, and it lasts 10ms[/quote]

I guess that is internal to how disk drivers do the initialization. It might also depend on the size of the SD card.

Can you try different card size and again check if it makes any difference.

Also, number of files stored on the SDCard contribute to that time.

RE: Sharing SPI interface between SD card and other peripheral

Gianlucamilani — Fri, 18 Aug 2023 18:59:24 GMT

Thanks a lot Naeem.

I asked this also because in this old DevZone post Multiple SPI instances - share pins? , it is stated that the pin sharing between instances is possible. So do you confirm it is not, right?

In the latter case, I would do what you suggested above, i.e. uninitialize and reinitialize the SPI instance every time I need to switch. I would ask you for a doubt:

which is the minimal initalization procedure for the fatfs SPI ? I currently tried to calculate the time to run the fatfs example including the whole disk_initialize function, and it lasts 10ms. it is too much time for my application if I need to do it every time I switch. Do you think it would be possible to remove part of this function when I reinitialize the fatfs SPI instance?

Here the fatfs_example function including the disk_initialize call:

static void fatfs_example()
{
    static FATFS fs;
    static DIR dir;
    static FILINFO fno;
    static FIL file;

 

    uint32_t bytes_written;
    FRESULT ff_result;
    DSTATUS disk_state = STA_NOINIT;

 

    // Initialize FATFS disk I/O interface by providing the block device.
    static diskio_blkdev_t drives[] =
    {
            DISKIO_BLOCKDEV_CONFIG(NRF_BLOCKDEV_BASE_ADDR(m_block_dev_sdc, block_dev), NULL)
    };

 

    diskio_blockdev_register(drives, ARRAY_SIZE(drives));

 

    NRF_LOG_INFO("Initializing disk 0 (SDC)...");
    SEGGER_RTT_printf(0,"Initializing disk 0 (SDC)...");
    for (uint32_t retries = 3; retries && disk_state; --retries)
    {
        disk_state = disk_initialize(0);
    }
    if (disk_state)
    {
        //NRF_LOG_INFO("Disk initialization failed.");
        SEGGER_RTT_printf(0,"Disk initialization failed.");
        return;
    }

 

    uint32_t blocks_per_mb = (1024uL * 1024uL) / m_block_dev_sdc.block_dev.p_ops->geometry(&m_block_dev_sdc.block_dev)->blk_size;
    uint32_t capacity = m_block_dev_sdc.block_dev.p_ops->geometry(&m_block_dev_sdc.block_dev)->blk_count / blocks_per_mb;
    //NRF_LOG_INFO("Capacity: %d MB", capacity);
    SEGGER_RTT_printf(0, "Capacity:  %d ", capacity);

 

    //NRF_LOG_INFO("Mounting volume...");
    SEGGER_RTT_printf(0,"Mounting volume...");
    ff_result = f_mount(&fs, "", 1);
    if (ff_result)
    {
        //NRF_LOG_INFO("Mount failed.");
        SEGGER_RTT_printf(0,"Mount failed.");
        return;
    }

 

    //NRF_LOG_INFO("\r\n Listing directory: /");
    SEGGER_RTT_printf(0,"\r\n Listing directory: /");
    ff_result = f_opendir(&dir, "/");
    if (ff_result)
    {
       // NRF_LOG_INFO("Directory listing failed!");
        SEGGER_RTT_printf(0,"Directory listing failed!");
        return;
    }

 

    do
    {
        ff_result = f_readdir(&dir, &fno);
        if (ff_result != FR_OK)
        {
            //NRF_LOG_INFO("Directory read failed.");
            SEGGER_RTT_printf(0,"Directory read failed.");
            return;
        }

 

        if (fno.fname[0])
        {
            if (fno.fattrib & AM_DIR)
            {
                //NRF_LOG_RAW_INFO("   <DIR>   %s",(uint32_t)fno.fname);
            }
            else
            {
                //NRF_LOG_RAW_INFO("%9lu  %s", fno.fsize, (uint32_t)fno.fname);
            }
        }
    }
    while (fno.fname[0]);
    //NRF_LOG_RAW_INFO("");
    //NRF_LOG_INFO("Writing to file " FILE_NAME "...");
    SEGGER_RTT_printf(0,"Writing to file " FILE_NAME "...");

 

    ff_result = f_open(&file, FILE_NAME, FA_READ | FA_WRITE | FA_OPEN_APPEND);
    if (ff_result != FR_OK)
    {
        //NRF_LOG_INFO("Unable to open or create file: " FILE_NAME ".");
        SEGGER_RTT_printf(0,"Unable to open or create file: " FILE_NAME ".");
        return;
    }

 

    ff_result = f_write(&file, TEST_STRING, sizeof(TEST_STRING) - 1, (UINT *) &bytes_written);
    if (ff_result != FR_OK)
    {
        //NRF_LOG_INFO("Write failed\r\n.");
        SEGGER_RTT_printf(0,"Write failed\r\n.");
    }
    else
    {
        //NRF_LOG_INFO("%d bytes written.", bytes_written);
        SEGGER_RTT_printf(0,"%d bytes written.", bytes_written);
    }

 

    (void) f_close(&file);
    return;
}

Here the body of the disk_initalize function:

DSTATUS disk_initialize(BYTE drv)
{
    ASSERT(m_drives);

    if (drv >= m_drives_count)
    {
        return (STA_NODISK | STA_NOINIT);
    }

    if (!m_drives[drv].config.p_block_device)
    {
        return (STA_NODISK | STA_NOINIT);
    }

    if (!(m_drives[drv].state & STA_NOINIT))
    {
        // Disk already initialized.
        return m_drives[drv].state;
    }

    if (m_drives[drv].config.wait_func == NULL)
    {
        m_drives[drv].config.wait_func = default_wait_func;
    }

    m_drives[drv].busy = true;
    ret_code_t err_code = nrf_blk_dev_init(m_drives[drv].config.p_block_device,
                                           block_dev_handler,
                                           (void *) (uint32_t) drv);
    if (err_code == NRF_SUCCESS)
    {
        while (m_drives[drv].busy)
        {
            m_drives[drv].config.wait_func();
        }

        if (m_drives[drv].last_result == NRF_BLOCK_DEV_RESULT_SUCCESS)
        {
            m_drives[drv].state &= ~STA_NOINIT;
        }
    }

    return m_drives[drv].state;
}

Thanks again,

Best regards

Gianluca

RE: Sharing SPI interface between SD card and other peripheral

Naeem Maroof — Fri, 18 Aug 2023 07:21:05 GMT

Hi Gianluca,

No. Different spi instances (e.g. spi0 and spi1) need to be initialized with their own set of pins.

As in this case, each will have a single device on their bus, they will not need CS pin to enable that.

BR,
Naeem

RE: Sharing SPI interface between SD card and other peripheral

Gianlucamilani — Wed, 16 Aug 2023 15:24:14 GMT

Dear Naeem,

thank you very much for your answer.

I tried unitialize and reinitialize the fatfs between each usage of the peripherals, but it seems that the fatfs SPI initialization lasts too much time (around 10ms), which I cannot spend.

Is it possible then in your opinion to initialize two SPI instances sharing the same CLK, MOSI, MISO pins? as you wrote here:

or you can put one device on spi0 and other on spi1 (multiple spi instances) in which case we don't need to control through the CS pins.

In that case I do not need reinitialization every time right? Is it feasible in your opinion even with the same pins? Do I need to make any particular action?

Thanks again,

best regards

Gianluca

RE: Sharing SPI interface between SD card and other peripheral

Naeem Maroof — Wed, 16 Aug 2023 09:58:54 GMT

Dear Gianluca,

Thank you for your patience.

As you want to have two spi devices (SDCard and another peripheral): you can put both on the same spi controller by having different CS pins, or you can put one device on spi0 and other on spi1 (multiple spi instances) in which case we don't need to control through the CS pins.

If you (and your hardware) have the flexibility, then it is preferred to use separate instance for SDCard as sharing another spi peripheral with the SDCard might not be very good idea.

Nonetheless, as in your case, you have a SDCard and another peripheral that you are putting on the same spi-bus and using spi0 controller.

Also, as you are using FATFS sample, you have seen that this sample initializes spi internally and you don't have to do any initialization like you are doing for your other peripheral.

What I mean is that: for the other peripheral, you have written spi_master_init() function but we have not written any such initialization function for the SDCard as we know that the FATFS must be handling internally.

Saying that, the problem you are facing seems to be due to the fact that the instance is already initialized, and you are trying to reinitialize it. As per your code:

err_code = spi_master_init();
CDCInit();                    
nrf_delay_ms(1000);

APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
NRF_LOG_DEFAULT_BACKENDS_INIT();
fatfs_example();

If you are calling fatfs example first, then do something like this:

fatfs_example();

nrf_drv_spi_uninit(&spi);

spi_transceiver_init();    

while (1) 
    {   
        // ...
        APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, m_tx_buf, m_length, m_rx_buf, m_length));
        while (!spi_xfer_done)
        {
          __WFE();
        }
        // ...
        nrf_delay_ms(1000);
    }

where, after fatfs example, we uninitialize the spi instance driver, and then re-initializ (in this spi_transceiver_init() function like spi_master_init() ) before using it.

Best regards,

Naeem

RE: Sharing SPI interface between SD card and other peripheral

Gianlucamilani — Wed, 09 Aug 2023 09:24:00 GMT

Dear Naeem,

thank you very much for your answer.

However, the standard SPI initialization (the one I use for the other device), handles two devices, not one. This is the reason why in that initialization I set the CS pin as not set (NRF_DRV_SPI_PIN_NOT_USED). Then, every time I need to communicate with those two devices, I manually set the CS pin.

For the fatfs instead, I am not modifying the example code, which sets a specific CS pin.

Given that, I am wondering if this double initialization can create some kind of issues, but for the time being I tried to avoid modifying the fatfs example which seems to be very customized with respect to the SPI stuff.

Given that, do you think there can be other possible modifications/solutions I can try?

For what concerns this:

Another test can be using a different spi-instance for both devices

the devices share the same lines, so I think I cannot create two different instances, right?

Thank you again,

Best regards

Gianluca

RE: Sharing SPI interface between SD card and other peripheral

Naeem Maroof — Fri, 28 Jul 2023 09:20:07 GMT

Hello Gianluca,

Thank you for contacting DevZone at NordicSemi. Appreciate your patience.

When you are want to use a spi controller for two or more spi devices, then each device need to have its own chip-select (CS) pin, that will enable only one peripheral for communication. Rest of the lines (MOSI, MISO, CLK) are same pins.

Yes, we can see that SDCard spi configuration has a definite CS pin (check #define at top of main), so I think your other device should also have a CS pin defined.

Another test can be using a different spi-instance for both devices to make sure that nothing is wrong with code / procedure and both devices are working with their spi-istances.

BR, Naeem

RE: Sharing SPI interface between SD card and other peripheral

Gianlucamilani — Wed, 26 Jul 2023 14:43:07 GMT

I found out that in the fatfs SPI initialization function there is this configuration:

#define APP_SDCARD_CONFIG(MOSI_PIN, MISO_PIN, SCK_PIN, CS_PIN) {    \
            .mosi_pin = MOSI_PIN,                                   \
            .miso_pin = MISO_PIN,                                   \
            .sck_pin  = SCK_PIN,                                    \
            .cs_pin   = CS_PIN                                      \
        }

Can this be the problem? In the sense that I set the CS to be a specific pin (while in the other case the CS pin was not set). Anyways, I would expect that the fatfs example work after this initialization

RE: Sharing SPI interface between SD card and other peripheral

Gianlucamilani — Wed, 26 Jul 2023 14:05:35 GMT

I attach here the sdk_config file for completeness:
devzone.nordicsemi.com/.../sdk_5F00_configh.txt