Problem about fatfs and QSPI on nRF52840

[junpu]

static bool fatfs_init(void)
{
	FRESULT ff_result;
	bool    init_result = true;
	DSTATUS disk_state = STA_NOINIT;
	bool flag = false;

	memset(&m_filesystem, 0, sizeof(FATFS));

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

	diskio_blockdev_register(drives, ARRAY_SIZE(drives));

	NRF_LOG_INFO("Initializing disk 0 (QSPI)...");

	disk_state = disk_initialize(0);
	if (disk_state)
	{
		NRF_LOG_ERROR("Disk initialization failed.");
		return false;
	}

	NRF_LOG_INFO("Mounting volume...");
	ff_result = f_mount(&m_filesystem, "", 1);
	if (ff_result != FR_OK)
	{
		if (ff_result == FR_NO_FILESYSTEM)
		{
			NRF_LOG_ERROR("Mount failed. Filesystem not found. Please format device.");

		}
		else
		{
			NRF_LOG_ERROR("Mount failed: %u", ff_result);
        
		}

		ff_result = fatfs_mkfs();
		if (ff_result != FR_OK)
		{

			init_result = false;
		}
		else
		{
#ifdef RECORD_ERR
			m_log_buf_len =   sprintf((char *)m_log_buf, "f_mount failed,then fatfs_mkfs sucessfully, fatfs_mkfs result %d\r\n", ff_result);
			record_stat_data(0);
#endif			
			flag = true;

		}
	}
	else
	{
		flag = true;
#ifdef RECORD_ERR
		m_log_buf_len =   sprintf((char *)m_log_buf, "Initializing disk 0 (QSPI) completed,ff_result %d\r\n",ff_result);
		record_stat_data(1);
#endif
	}

	return init_result;
}

Hi, I was using nRF52840 ， flash is mx25L25645GM2, I used fatfs with QSPI ,but I found fatfs was unstable,After some time, the stored file would dispear.Sometime there were scrambling symbols in my files

[Jared]

Hi, 

Which SDK and Softdevice version and revision of the nRF52840 are you using?

Regards

Jared

[junpu]

sdk :nRF5_SDK_15.2.0_9412b96  

revision of the nRF52840 ： cortex-m4 nrf52840_xxAA 1024KB+4KB 256KB  PCA10056

[junpu]

main.h

#ifndef MAIN_H
#define MAIN_
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <inttypes.h>
#include <stdlib.h>

#include "nrf.h"
#include "nrf_block_dev.h"
#include "nrf_block_dev_ram.h"
#include "nrf_block_dev_empty.h"
#include "nrf_block_dev_qspi.h"
#include "nrf_block_dev_sdc.h"
#include "nrf_drv_usbd.h"
#include "nrf_drv_clock.h"
#include "nrf_gpio.h"
#include "nrf_atomic.h"
#include "nrf_drv_power.h"

#include "ff.h"
#include "diskio_blkdev.h"

#include "app_usbd.h"
#include "app_usbd_core.h"
#include "app_usbd_string_desc.h"
#include "app_usbd_msc.h"
#include "app_error.h"
#include "app_timer.h"

#include "bsp.h"


#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

#include "recorder.h"
#include "gnss.h"

#define NEED_NMEAPARSE
#ifdef NEED_NMEAPARSE
#include "minmea.h"
#endif

#include "boards.h"
#include "nrf_delay.h"

#define RESULT_SUCESS "sucessfully!"
#define RESULT_FAILED "failed!"
#define  ACTION_NAME "init"

#define  LOG_ACTION_NAME "Log"
#define  CLOCK_ACTION_NAME "Clock"
#define  TIMER_ACTION_NAME "Timer"
#define  BSP_ACTION_NAME "BSP"



#define BUFFER_SIZE                     180
#define  IS_ASCII(x) ((((unsigned char)(x)) & 0x80 ) == 0x80 ?  false : true)
/**@file
 * @defgroup usbd_msc_example main.c
 * @{
 * @ingroup usbd_msc_example
 * @brief USBD MSC example
 *
 */

#define LED_USB_RESUME   (BSP_BOARD_LED_0)
#define LED_USB_START    (BSP_BOARD_LED_1)

#define BTN_RANDOM_FILE  0
#define BTN_LIST_DIR     1
#define BTN_MKFS         2

#define KEY_EV_RANDOM_FILE_MSK (1U << BTN_RANDOM_FILE)
#define KEY_EV_LIST_DIR_MSK    (1U << BTN_LIST_DIR   )
#define KEY_EV_MKFS_MSK        (1U << BTN_MKFS       )

/**
 * @brief Enable power USB detection
 *
 * Configure if example supports USB port connection
 */
#ifndef USBD_POWER_DETECTION
#define USBD_POWER_DETECTION true
#endif

/**
 * @brief SD card enable/disable
 */
#define USE_SD_CARD       0

/**
 * @brief FatFS for QPSI enable/disable
 */
#define USE_FATFS_QSPI    1

/**
 * @brief Mass storage class user event handler
 */
static void msc_user_ev_handler(app_usbd_class_inst_t const * p_inst,
                                app_usbd_msc_user_event_t     event);


/**
 * @brief Ram block device size
 *
 * @note Windows fails to format volumes smaller than 190KB
 */
#define RAM_BLOCK_DEVICE_SIZE (380 * 512)

/**
 * @brief  RAM block device work buffer
 */
static uint8_t m_block_dev_ram_buff[RAM_BLOCK_DEVICE_SIZE];

/**
 * @brief  RAM block device definition
 */
NRF_BLOCK_DEV_RAM_DEFINE(
    m_block_dev_ram,
    NRF_BLOCK_DEV_RAM_CONFIG(512, m_block_dev_ram_buff, sizeof(m_block_dev_ram_buff)),
    NFR_BLOCK_DEV_INFO_CONFIG("Nordic", "RAM", "1.00")
);


/**
 * @brief Empty block device definition
 */
NRF_BLOCK_DEV_EMPTY_DEFINE(
    m_block_dev_empty,
    NRF_BLOCK_DEV_EMPTY_CONFIG(512, 1024 * 1024),
    NFR_BLOCK_DEV_INFO_CONFIG("Nordic", "EMPTY", "1.00")
);


/**
 * @brief  QSPI block device definition
 */
NRF_BLOCK_DEV_QSPI_DEFINE(
    m_block_dev_qspi,
    NRF_BLOCK_DEV_QSPI_CONFIG(
        512,
        NRF_BLOCK_DEV_QSPI_FLAG_CACHE_WRITEBACK,
        NRF_DRV_QSPI_DEFAULT_CONFIG
     ),
     NFR_BLOCK_DEV_INFO_CONFIG("Nordic", "QSPI", "1.00")
);

#if USE_SD_CARD
#if 0
#define SDC_MISO_PIN    (19)        ///< SDC serial data out (DO) pin.
#define SDC_SCK_PIN     (20)        ///< SDC serial clock (SCK) pin.
#define SDC_MOSI_PIN    (21)        ///< SDC serial data in (DI) pin.
#define SDC_CS_PIN      (22)        ///< SDC chip select (CS) pin.
#else
//NOT OK
// #define SDC_MISO_PIN    (31)        ///< SDC serial data out (DO) pin.
// #define SDC_SCK_PIN     (30)        ///< SDC serial clock (SCK) pin.
// #define SDC_MOSI_PIN    (29)        ///< SDC serial data in (DI) pin.
// #define SDC_CS_PIN      (28)        ///< SDC chip select (CS) pin.


//OK
#define SDC_MISO_PIN    (28)         ///< SDC serial data out (DO) pin.
#define SDC_SCK_PIN     (31)        ///< SDC serial clock (SCK) pin.
#define SDC_MOSI_PIN    (30)        ///< SDC serial data in (DI) pin.
#define SDC_CS_PIN      (29)   ///< SDC chip select (CS) pin.


// #define SDC_MISO_PIN    (31)         ///< SDC serial data out (DO) pin.
// #define SDC_SCK_PIN     (26)        ///< SDC serial clock (SCK) pin.
// #define SDC_MOSI_PIN    (27)        ///< SDC serial data in (DI) pin.
// #define SDC_CS_PIN      (04)   ///< SDC chip select (CS) pin.




#endif
/**
 * @brief  SDC block device definition
 */
NRF_BLOCK_DEV_SDC_DEFINE(
    m_block_dev_sdc,
    NRF_BLOCK_DEV_SDC_CONFIG(
        SDC_SECTOR_SIZE,
        APP_SDCARD_CONFIG(SDC_MOSI_PIN, SDC_MISO_PIN, SDC_SCK_PIN, SDC_CS_PIN)
     ),
     NFR_BLOCK_DEV_INFO_CONFIG("Nordic", "SDC", "1.00")
);


/**
 * @brief Block devices list passed to @ref APP_USBD_MSC_GLOBAL_DEF
 */
#if 0
#define BLOCKDEV_LIST() (                                   \

    NRF_BLOCKDEV_BASE_ADDR(m_block_dev_ram, block_dev),     \
    NRF_BLOCKDEV_BASE_ADDR(m_block_dev_empty, block_dev),   \
    NRF_BLOCKDEV_BASE_ADDR(m_block_dev_sdc, block_dev)      \
)
#else
#define BLOCKDEV_LIST() (                                   \
    NRF_BLOCKDEV_BASE_ADDR(m_block_dev_sdc, block_dev)      \
)
#endif

#else
#if 0
#define BLOCKDEV_LIST() (                                   \
    NRF_BLOCKDEV_BASE_ADDR(m_block_dev_ram, block_dev),     \
    NRF_BLOCKDEV_BASE_ADDR(m_block_dev_empty, block_dev),   \
    NRF_BLOCKDEV_BASE_ADDR(m_block_dev_qspi, block_dev)     \
)
#else
#define BLOCKDEV_LIST() (                                   \
    NRF_BLOCKDEV_BASE_ADDR(m_block_dev_qspi, block_dev)     \
)
#endif
#endif

/**
 * @brief Endpoint list passed to @ref APP_USBD_MSC_GLOBAL_DEF
 */
#define ENDPOINT_LIST() APP_USBD_MSC_ENDPOINT_LIST(1, 1)

/**
 * @brief Mass storage class work buffer size
 */
#define MSC_WORKBUFFER_SIZE (1024)

/*lint -save -e26 -e64 -e123 -e505 -e651*/
/**
 * @brief Mass storage class instance
 */
APP_USBD_MSC_GLOBAL_DEF(m_app_msc,
                        0,
                        msc_user_ev_handler,
                        ENDPOINT_LIST(),
                        BLOCKDEV_LIST(),
                        MSC_WORKBUFFER_SIZE);

/*lint -restore*/

/**
 * @brief Events from keys
 */
static nrf_atomic_u32_t m_key_events;

/**
 * @brief  USB connection status
 */
static bool m_usb_connected = false;
static FRESULT  fatfs_mkfs(void);
// #define SDC_SCK_PIN     (30)        ///< SDC serial clock (SCK) pin.
// #define SDC_MOSI_PIN    (29)        ///< SDC serial data in (DI) pin.
// #define SDC_CS_PIN      (28)        ///< SDC chip select (CS) pin.


//OK
#define SDC_MISO_PIN    (28)         ///< SDC serial data out (DO) pin.
#define SDC_SCK_PIN     (31)        ///< SDC serial clock (SCK) pin.
#define SDC_MOSI_PIN    (30)        ///< SDC serial data in (DI) pin.
#define SDC_CS_PIN      (29)   ///< SDC chip select (CS) pin.


// #define SDC_MISO_PIN    (31)         ///< SDC serial data out (DO) pin.
// #define SDC_SCK_PIN     (26)        ///< SDC serial clock (SCK) pin.
// #define SDC_MOSI_PIN    (27)        ///< SDC serial data in (DI) pin.
// #define SDC_CS_PIN      (04)   ///< SDC chip select (CS) pin.

void record_stat_data(int close_flag);
void delay_ms(unsigned short time);
void delay_us(unsigned short time);
uint32_t app_uart_get(uint8_t * p_byte);

#endif

main.c

int main(void)
{
    ret_code_t ret;
    FRESULT ff_result; 
    int mode = 0;
    //char m_log_buf[256] = {0}; 
    int loop_cnt = 0;

    uint32_t time_ms = 500; //Time(in miliseconds) between consecutive compare events.
    uint32_t time_ticks;
    uint32_t err_code = NRF_SUCCESS;

    bool    init_result = true;

    static const app_usbd_config_t usbd_config =
    {
        .ev_state_proc = usbd_user_ev_handler
    };

    /*******************************************************************
     * Step 1: System init
     *******************************************************************/

    ret = NRF_LOG_INIT(app_usbd_sof_timestamp_get);
    APP_ERROR_CHECK(ret);
    NRF_LOG_DEFAULT_BACKENDS_INIT();

    ret = nrf_drv_clock_init();
    APP_ERROR_CHECK(ret);

    if(ret)
    {
   
        return -1;
    }
    /* Fill whole RAM block device buffer */
    for (size_t i = 0; i < sizeof(m_block_dev_ram_buff); ++i)
    {
        m_block_dev_ram_buff[i] = i;
    }

    /* Configure LEDs and buttons */
    nrf_drv_clock_lfclk_request(NULL);
    ret = app_timer_init();
    APP_ERROR_CHECK(ret);

    ret = bsp_init(BSP_INIT_BUTTONS, bsp_event_callback);
    APP_ERROR_CHECK(ret);
   


    bsp_board_init(BSP_INIT_LEDS);



    //Configure all leds on board.

#if 1
    ret = fatfs_init();

    APP_ERROR_CHECK(!ret);
    if(ret!=true)
    {

        ff_result = fatfs_mkfs();
        if (ff_result != FR_OK)
        {
       
            init_result = false;
            return -1;
        }
		
        bsp_board_led_off(BSP_BOARD_LED_1);
nrf_delay_ms(30*1000);
//        sleep(30);//while(1);
    
    }
	nrf_delay_ms(10);

    fatfs_ls();

#endif

    bsp_board_led_on(BSP_BOARD_LED_0);
    nrf_delay_ms(3000);
    bsp_board_led_off(BSP_BOARD_LED_0);

    ret = gnss_init();
#if 0
    m_log_buf_len =   sprintf( (char *) m_log_buf, "%s %s %s : %d.\r\n",BSP_ACTION_NAME,ACTION_NAME,(NRF_SUCCESS==ret)?RESULT_SUCESS:RESULT_FAILED, ret );
    record_stat_data(0);
#endif
    if(ret)
    {
       // m_log_buf_len =   sprintf( (char *) m_log_buf, "Step 1:System  init failed,because of gnss.\r\n" );
        return -1;
    }
    /*******************************************************************
     * Step 2: System configure GPS
     *******************************************************************/

    ret = init_param();
    if(NRF_SUCCESS != ret)
    {
    ff_result = fatfs_mkfs();
    if(!ff_result)
    {
      ret = init_param();
      if(NRF_SUCCESS != ret)
      {
        return ret;
      }
    }else
    {


        return ret;
        }
    }
    mode = get_mode_from_param();

    if(mode <0 || mode >4)
    {
 
		NRF_LOG_ERROR("GNSS mode from config err: %d", mode);
        return mode;
    }

    NRF_LOG_INFO("GNSS mode from config: %d", mode);
    ret = gnss_set_mode(mode);
    if(NRF_SUCCESS != ret)
    {

        return ret;
    }
    //        set_gnss_mode(mode);
    // fatfs_file_create();

    /*******************************************************************
     * Step 3: System configure USB 
     *******************************************************************/
    ret = app_usbd_init(&usbd_config);
    APP_ERROR_CHECK(ret);
    if(NRF_SUCCESS != ret)
    {

    }
    app_usbd_class_inst_t const * class_inst_msc = app_usbd_msc_class_inst_get(&m_app_msc);
    ret = app_usbd_class_append(class_inst_msc);
    APP_ERROR_CHECK(ret);
    if(NRF_SUCCESS != ret)
    {

    }
    NRF_LOG_INFO("USBD configure  finished.");

    //    gnss_set_callback(on_uart_receive);

    if (USBD_POWER_DETECTION)
    {
        ret = app_usbd_power_events_enable();
        APP_ERROR_CHECK(ret);
    }
    else
    {
        NRF_LOG_INFO("No USB power detection enabled\r\nStarting USB now");

        app_usbd_enable();
        app_usbd_start();
        m_usb_connected = true;
    }


    /*******************************************************************
     * Step 4: 
     *******************************************************************/
    while (true)
    {
        while (app_usbd_event_queue_process() && loop_cnt<100)
        {
        #if 0
            /* Nothing to do */
            m_log_buf_len =   sprintf( (char *) m_log_buf, "Step 4: Enter app_usbd_event_queue_process loop .\r\n");
		  
            record_stat_data(0);
		#endif
            loop_cnt++;
			
        }

        /* Process BSP key events flags.*/
        uint32_t events = nrf_atomic_u32_fetch_store(&m_key_events, 0);
        if (events & KEY_EV_RANDOM_FILE_MSK)
        {
            //            fatfs_file_create();
            //            recorder_stest();
            mode = 0;
            init_param();
            mode = get_mode_from_param();
            NRF_LOG_INFO("GNSS mode from config: %d", mode);

        }

        if (events & KEY_EV_LIST_DIR_MSK)
        {
            //            fatfs_ls();
            recorder_fatfs_ls();
        }

        if (events & KEY_EV_MKFS_MSK)
        {
            fatfs_mkfs();
        }

        uart_data_process();

        UNUSED_RETURN_VALUE(NRF_LOG_PROCESS());
        /* Sleep CPU only if there was no interrupt since last loop processing */
        __WFE();
    }
}

record.c

#include "recorder.h"
#include "ff.h"
#include "diskio_blkdev.h"
#include "nrf_log_ctrl.h"
#include "nrf_delay.h"
#include "ini.h"

#define NRF_LOG_MODULE_NAME recorder
#include <nrf_log.h>
NRF_LOG_MODULE_REGISTER();

#define LEN_FILENAME 128
/*每次记录完是不是关闭文件*/
#define CLOSE_FILE_AFTER_RECORDED 0

#define CONFIG_FILE "CONFIG.INI"
#define CONFIG_CONTENT \
";---------------------------------------------------\r\n"\
";-----do not delete these lines with no meaning-----\r\n"\
";---------------------------------------------------\r\n"\
";--------these lines may fix some bugs--------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";---------------------------------------------------\r\n"\
";config starts--------------------------------------\r\n"\
";---mode\r\n"\
";------1\tGPS only\r\n"\
";------2\tGLONASS only\r\n"\
";------3\tGPS+GLONASS\r\n"\
";------4\tGPS+BDS(default)\r\n"\
";------5\tBDS only\r\n"\
";------6\tGPS+GLONASS+Galileo\r\n"\
"mode=4\r\n"

#define CONFIG_KEYWORD "config starts"
#define CONFIG_CONTENT_LENGTH_MAX 4096


#define PARAM_MODE_KEY "mode"

typedef struct {
    int mode;
}param_t;

static bool m_record_disabled;
static FIL* m_opened_file = NULL;
static char m_filename[LEN_FILENAME] = "default.csv";
static char m_endline[] = "\n";
static param_t m_param = {0};


uint32_t init_config_file();
static uint32_t file_close();

void set_record_disabled(bool disabled)
{
    m_record_disabled = disabled;
    if(m_opened_file){
        file_close();
    }
}

bool get_record_disabled()
{
    return m_record_disabled;
}



uint32_t recorder_fatfs_ls(void)
{
   DIR dir;
   FRESULT ff_result;
   FILINFO fno;

   if (m_record_disabled)
   {
       NRF_LOG_ERROR("Unable to operate on filesystem while USB is connected");
       return NRF_ERROR_BUSY;
   }

   NRF_LOG_INFO("\r\nListing directory: /");
   if(get_record_disabled()){
       return NRF_ERROR_BUSY;
   }
   ff_result = f_opendir(&dir, "/");
   if (ff_result != FR_OK)
   {
       NRF_LOG_ERROR("Directory listing failed: %u", ff_result);
       return NRF_ERROR_FORBIDDEN;
   }

   uint32_t entries_count = 0;
   do
   {
       ff_result = f_readdir(&dir, &fno);
       if (ff_result != FR_OK)
       {
           NRF_LOG_ERROR("Directory read failed: %u", ff_result);
           return NRF_ERROR_NULL;
       }

       if (fno.fname[0])
       {
           if (fno.fattrib & AM_DIR)
           {
               NRF_LOG_RAW_INFO("   <DIR>   %s\r\n",(uint32_t)fno.fname);
           }
           else
           {
               NRF_LOG_RAW_INFO("%9lu  %s\r\n", fno.fsize, (uint32_t)fno.fname);
           }
       }

       ++entries_count;
       NRF_LOG_FLUSH();
   } while (fno.fname[0]);

   NRF_LOG_RAW_INFO("Entries count: %u\r\n", entries_count);
   return NRF_SUCCESS;
}


static uint32_t file_close()
{
    FRESULT ff_result = f_close(m_opened_file);
    if (ff_result != FR_OK)
    {
        NRF_LOG_ERROR("\r\nUnable to close file: %u", ff_result);
        NRF_LOG_FLUSH();
        return NRF_ERROR_NULL;
    }
    
    NRF_LOG_INFO("closed %x.", (uint32_t)m_opened_file);
    m_opened_file = NULL;
    return NRF_SUCCESS;

}

static uint32_t file_open(const char*filename)
{
    static FIL file;
    FRESULT ff_result;

    NRF_LOG_INFO("Opening file: %s.", NRF_LOG_PUSH(filename));
    if(get_record_disabled()){
        return NRF_ERROR_BUSY;
    }
    ff_result = f_open(&file, filename, FA_READ | FA_WRITE | FA_OPEN_APPEND);
    if (ff_result != FR_OK)
    {
       NRF_LOG_INFO("Unable to open or create file: %d", ff_result);
       return NRF_ERROR_BUSY;
    }
    m_opened_file = &file;
    return NRF_SUCCESS;
}
static uint32_t file_write(const uint8_t *buf, uint32_t len)
{
    uint32_t written = 0;
    FRESULT ff_result;
    if(m_opened_file == NULL){
        NRF_LOG_ERROR("Sorry, open file first");
        return NRF_ERROR_BUSY;
    }
    NRF_LOG_HEXDUMP_DEBUG(buf, len);
    if(get_record_disabled()){
        return NRF_ERROR_BUSY;
    }
	f_lseek(m_opened_file,f_size(m_opened_file));
    ff_result = f_write(m_opened_file, buf, len, (UINT *) &written);
    if (ff_result != FR_OK || written != len)
    {
        NRF_LOG_ERROR("Failed to write, ff_result: %d, written: %d", ff_result, written);
        return NRF_ERROR_NULL;
    }
    else
    {
        NRF_LOG_DEBUG("%d bytes written.", written);
    }
    f_sync(m_opened_file);
    return NRF_SUCCESS;
}

uint32_t set_record_filename(const char* name)
{
    if(name[0] == '\0'){
        return NRF_ERROR_NULL;
    }
    memset(m_filename, 0x00, LEN_FILENAME);
    int n = snprintf(m_filename, LEN_FILENAME, "%s.csv", name);
    NRF_LOG_INFO("Set record file name:")
    NRF_LOG_HEXDUMP_INFO(m_filename, n + 1);
    if(m_opened_file){
        file_close();
    }
    return file_open(m_filename);
}

uint32_t record_one_line(uint8_t *buf, uint32_t len)
{
    uint32_t ret;
    bool result = false;
    if(m_opened_file == NULL)
    {
        #if CLOSE_FILE_AFTER_RECORDED
        if(get_record_disabled()){
            return NRF_ERROR_BUSY;
        }
        ret = file_open(m_filename);
        if(ret != NRF_SUCCESS){
            return NRF_ERROR_BUSY;
        }
        #endif
         return NRF_ERROR_NULL;
    }
    result = get_record_disabled();
    if(result == true)
    {
        return NRF_ERROR_BUSY;
    }
	
    ret = file_write(buf, len);
    if(ret != NRF_SUCCESS)
    {
        NRF_LOG_ERROR("Failed1 to record one line");
        return NRF_ERROR_NULL;
    }
    
    ret = file_write(&m_endline, sizeof(m_endline) - 1);
    if(ret != NRF_SUCCESS)
    {
        NRF_LOG_ERROR("Failed to record one line");
        return NRF_ERROR_NULL;
    }
#if CLOSE_FILE_AFTER_RECORDED
   file_close();
#endif
    NRF_LOG_WARNING("Recorded one line: %d", len);
    return NRF_SUCCESS;
}


static void show_file_info()
{
//    NRF_LOG_INFO("m_opened_file: %X.", m_opened_file);
}


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;
#define FILE_NAME "heheda"
#define TEST_STRING "123"

    D_RETURN_VALUE(NRF_LOG_PROCESS());
    file_open(m_filename);
    while(1){   
        file_write(TEST_STRING, sizeof(TEST_STRING) - 1);
        nrf_delay_ms(500);
    }

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

void recorder_test()
{
#if 0
    char random_file_name[32];
    memset(random_file_name, 0x00, 32);

    snprintf(random_file_name, sizeof(random_file_name), "%08x.txt", rand());
    new_file_create(random_file_name, false);
#endif
    char random_data[32] __attribute__ ((aligned (4)));
    int n = snprintf(random_data, sizeof(random_data), "%08x", rand() * rand());
    record_one_line(random_data, n);
    show_file_info();
}

bool is_file_opened()
{ 
    return NULL != m_opened_file;
}

uint32_t paser_mode_from_config(const char* data, int len, int* mode)
{
#define MODE_CONFIG_PREFIX "mode="
    if(!data || !mode)
        return NRF_ERROR_INVALID_PARAM;
    char *input = data;
    int index = 0;
    int line_start = index;
    int line_len = 0;
    bool is_valid = true;
    static char c;// static for debug

    while(index < len){
        c = input[index];
        if(c == ';'){ // this is comment
            is_valid = false;
        }
        else if(c == '\r' || c == '\n'){ // this is the end of line
            input[index] = '\0';
            if(is_valid){ // check "mode="
                line_len = index - line_start;
                if(0 == strncasecmp(input + line_start, MODE_CONFIG_PREFIX, sizeof(MODE_CONFIG_PREFIX) - 1)){
                    int m = atoi(input + line_start + sizeof(MODE_CONFIG_PREFIX) - 1);
                    NRF_LOG_INFO("Success to read mode from config: %d", m);
                    *mode = m;
                    break;
                }
            }
            is_valid = true;
            line_start = index + 1;
        }
        index++;
    }

    return NRF_SUCCESS;
}

int User;
char Prev_section[50];

int dumper(void* user, const char* section, const char* name,
           const char* value)
{
    User = *((int*)user);
    if (strcmp(section, Prev_section))
    {
        strncpy(Prev_section, section, sizeof(Prev_section));
        Prev_section[sizeof(Prev_section) - 1] = '\0';
    }
    NRF_LOG_INFO("... %s=%s;\n", NRF_LOG_PUSH(name), NRF_LOG_PUSH(value));

    if(0 == strncasecmp(name, PARAM_MODE_KEY, sizeof(PARAM_MODE_KEY) - 1))
    {
        int m = atoi(value);
        NRF_LOG_INFO("Success to read mode from config: %d", m);
        m_param.mode = m;
    }
    return 1;
}

int get_mode_from_param()
{

    if(m_param.mode == 0)
	{
        init_config_file();
    }
    return m_param.mode;
}
static uint32_t read_from_config_file()
{
    FIL file;
    FRESULT ff_result;
    UINT read = 0;
    char buffer[CONFIG_CONTENT_LENGTH_MAX] = {0};
    int e;
    static int u = 100;
    *Prev_section = '\0';

    NRF_LOG_INFO("Opening config file");
    if(get_record_disabled()){
        return NRF_ERROR_BUSY;
    }
    ff_result = f_open(&file, CONFIG_FILE, FA_READ | FA_OPEN_EXISTING);
    if (ff_result != FR_OK)
    {
       NRF_LOG_INFO("Unable to open file: %d", ff_result);
       return NRF_ERROR_BUSY;
    }

    ff_result = f_read(&file, buffer, CONFIG_CONTENT_LENGTH_MAX, &read);
    if (ff_result != FR_OK)
    {
        NRF_LOG_ERROR("Failed to read, ff_result: %d, read: %d", ff_result, read);
        return NRF_ERROR_NULL;
    }
    NRF_LOG_INFO("read from config file: %d", read);
//    NRF_LOG_HEXDUMP_INFO(buffer, read);

    if(NULL == strnstr(buffer, CONFIG_KEYWORD, CONFIG_CONTENT_LENGTH_MAX))
    {
        NRF_LOG_INFO("config key word not found");
        goto exit;
    }

    e = ini_parse_string(buffer, dumper, &u);
    NRF_LOG_INFO("e=%d user=%d\n", e, User);

    // if(NRF_SUCCESS != paser_mode_from_config(buffer, read, mode)){
    //     *mode = 0;
    // }
    
exit:
    ff_result = f_close(&file);
    if (ff_result != FR_OK)
    {
        NRF_LOG_ERROR("\r\nUnable to close config file: %u", ff_result);
        NRF_LOG_FLUSH();
        return NRF_ERROR_NULL;
    }
    
    NRF_LOG_INFO("closed config file");

    return NRF_SUCCESS;
}

uint32_t init_config_file_prefix(const char*filename)
{
    FIL file;
    FRESULT ff_result;
    UINT written;

    NRF_LOG_INFO("Creating config file");
    if(get_record_disabled()){
        return NRF_ERROR_BUSY;
    }
    ff_result = f_open(&file, filename, FA_WRITE | FA_CREATE_ALWAYS);
    if (ff_result != FR_OK)
    {
       NRF_LOG_INFO("Unable to create file: %d", ff_result);
       return NRF_ERROR_BUSY;
    }

    if(get_record_disabled()){
        return NRF_ERROR_BUSY;
    }
    ff_result = f_write(&file, CONFIG_CONTENT, sizeof(CONFIG_CONTENT), (UINT *) &written);
    if (ff_result != FR_OK || written != sizeof(CONFIG_CONTENT))
    {
        NRF_LOG_ERROR("Failed to write, ff_result: %d, written: %d", ff_result, written);
        return NRF_ERROR_NULL;
    }
    else
    {
        NRF_LOG_INFO("["CONFIG_CONTENT"] %d bytes written.", written);
    }

    ff_result = f_close(&file);
    if (ff_result != FR_OK)
    {
        NRF_LOG_ERROR("\r\nUnable to close config file: %u", ff_result);
        NRF_LOG_FLUSH();
        return NRF_ERROR_NULL;
    }
    
    NRF_LOG_INFO("closed config file");
    
    return NRF_SUCCESS;
}

uint32_t init_config_file()
{
    uint32_t ret = -1;
    ret = init_config_file_prefix("fake");
    if(NRF_SUCCESS != ret)
    {
        NRF_LOG_ERROR("Failed to init_config_file_prefix fake, result: %d", ret);
        return ret;
    }
    ret = init_config_file_prefix(CONFIG_FILE);
    if(NRF_SUCCESS != ret)
    {
        NRF_LOG_ERROR("Failed to init_config_file_prefix %s, result: %d",CONFIG_FILE, ret);
        return ret;
    }
}

static uint32_t open_config_file()
{
    return !NRF_SUCCESS;
}

int read_mode_from_record()
{
    int mode= 0;
    int count = 5;
    uint32_t ret = NRF_SUCCESS;
    ret = read_mode_from_config_file(&mode);
    #if 1
    if(NRF_SUCCESS != ret){
    #else
    if(1){
    #endif
        NRF_LOG_INFO("Initing config file");
        init_config_file();
        return 0;
    }
    return mode;
}


uint32_t init_param()
{
    uint32_t ret = -1;

    ret = read_from_config_file();
    if(NRF_SUCCESS != ret)
	{
        ret = init_config_file();
        if(NRF_SUCCESS == ret) /* read config file again */
        {
            ret = read_from_config_file();
            if(NRF_SUCCESS != ret)
            {
                NRF_LOG_ERROR("read config file failed again.");
                return ret;
            }

        }
        else
        {

            NRF_LOG_ERROR("init config file failed. ");
            return  ret;
        }
    }

    NRF_LOG_INFO("Initing param sucessfully");
    return NRF_SUCCESS;
}

[junpu]

// <5=> 5
// <6=> 6
// <7=> 7

#ifndef USBD_CONFIG_IRQ_PRIORITY
#define USBD_CONFIG_IRQ_PRIORITY 6
#endif

// <o> USBD_CONFIG_DMASCHEDULER_MODE - USBD SMA scheduler working scheme

// <0=> Prioritized access
// <1=> Round Robin

#ifndef USBD_CONFIG_DMASCHEDULER_MODE
#define USBD_CONFIG_DMASCHEDULER_MODE 0
#endif

[junpu]

the last is sdk_config.h

[junpu]

Look forward to your favourable reply

[junpu]

Look forward to your favourable reply

[Jared]

Hi,

Sorry for the late reply

I can't really see anything in the code that should create the issue. Are you able to reproduce the issue on the development kit? How long after flashing the application to the nRF do you experience the issue? 

regards

Jared 

[junpu]

Hi, I am sorry for late reply. My question is the same with https://devzone.nordicsemi.com/f/nordic-q-a/39428/usb-msc-corruption  . I found there was no answer in https://devzone.nordicsemi.com/f/nordic-q-a/39428/usb-msc-corruption.  Have  you got the solution?  

I could reproduce  on the development kit.  This problem lacked of regularity, some minitues  or some houses., 

[Jared]

Hi,

Could you share your entire project folder with me? I would like to try to reproduce it myself.

regards

Jared 

[junpu]

How to share my project folder? by mail or ？

[Jared]

Hi,

You could upload it here. Click Insert->insert image/video/file->chose file upload.I can make the case private if you prefer to not share it in a public case. You  only need to share the specific folder that you're application is in, which contains the config file and other source files belonging to the project. You don't need to share the entire SDK.

regards

Jared