Hi, Noddic & all：
I meet a problem when use external flash(25Q64FVSIG) as the USBD_MSC example's storage;
that is : "fatfs_init()" return FR_NO_FILESYSTEM;
then I go deep to check the definition(fatfs_init() > f_mount(&m_filesystem, "", 1) > find_volume(&path, &fs, 0) > check_fs(fs, bsect)) and found returned at this line:
if (ld_word(fs->win + BS_55AA) != 0xAA55) return 3; /* Check boot record signature (always placed at offset 510 even if the sector size is >512) */
As this is my first time to use FATFS, don't know what happened about this, did I miss some configure about 25Q64FVSIG?
Thanks for all your kind help.
The following is my main.c code and log:
/**
* Copyright (c) 2018 - 2020, 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 libuarte_example_main main.c
* @{
* @ingroup libuarte_example
* @brief Libuarte Example Application main file.
*
* This file contains the source code for a sample application using libuarte.
*
*/
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "nrf_libuarte_async.h"
#include "nrf_drv_clock.h"
#include <bsp.h>
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "nrf_queue.h"
#include <stddef.h>
#include <inttypes.h>
#include <stdlib.h>
#include "nrf.h"
#include "nrf_block_dev.h"
#include "nrf_block_dev_qspi.h"
#include "nrf_drv_usbd.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 "nrf_log.h"
#include "nrf_drv_qspi.h"
#include "nrf_qspi.h"
bool g_test_open = false;
uint32_t g_idle_s = 0;
typedef struct{
BYTE rx_buff[1024];
uint16_t rx_index;
} libuarte_rx_t;
libuarte_rx_t m_rx = {0};
#define USE_FATFS_QSPI 1
#define CLOSE_INTERVAL APP_TIMER_TICKS(1000*15)
#define CLOSE_FILE_BY_TIMER 0
#define CLOSE_FILE_BY_STRING 1
APP_TIMER_DEF(file_close_timer_id);
static void msc_user_ev_handler(app_usbd_class_inst_t const * p_inst,
app_usbd_msc_user_event_t event);
/**
* @brief QSPI block device definition
*/
NRF_BLOCK_DEV_QSPI_DEFINE(
m_block_dev_qspi,
NRF_BLOCK_DEV_QSPI_CONFIG(
512,
0,
NRF_DRV_QSPI_DEFAULT_CONFIG
),
NFR_BLOCK_DEV_INFO_CONFIG("Nordic", "QSPI", "1.00")
);
#define BLOCKDEV_LIST() ( \
NRF_BLOCKDEV_BASE_ADDR(m_block_dev_qspi, block_dev) \
)
/**
* @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;
#if USE_FATFS_QSPI
static FATFS m_filesystem;
static bool fatfs_init(void)
{
FRESULT ff_result;
DSTATUS disk_state = STA_NOINIT;
memset(&m_filesystem, 0, sizeof(FATFS));
// 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_qspi, block_dev), NULL)
};
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.disk_state<%d>", disk_state);
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);
}
return false;
}
return true;
}
static void fatfs_mkfs(void)
{
FRESULT ff_result;
if (m_usb_connected)
{
NRF_LOG_ERROR("Unable to operate on filesystem while USB is connected");
return;
}
NRF_LOG_INFO("\r\nCreating filesystem...");
static uint8_t buf[512];
ff_result = f_mkfs("", FM_FAT, 1024, buf, sizeof(buf));
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("Mkfs failed.");
return;
}
NRF_LOG_INFO("Mounting volume...");
ff_result = f_mount(&m_filesystem, "", 1);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("Mount failed.");
return;
}
NRF_LOG_INFO("Done");
}
static void fatfs_ls(void)
{
DIR dir;
FRESULT ff_result;
FILINFO fno;
if (m_usb_connected)
{
NRF_LOG_ERROR("Unable to operate on filesystem while USB is connected");
return;
}
NRF_LOG_INFO("\r\nListing directory: /");
ff_result = f_opendir(&dir, "/");
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("Directory listing failed: %u", ff_result);
return;
}
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;
}
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);
}
const char my_filename[] = "test1.xls";
static void fatfs_file_create(void)
{
FRESULT ff_result;
FIL file;
if (m_usb_connected)
{
NRF_LOG_ERROR("Unable to operate on filesystem while USB is connected");
return;
}
NRF_LOG_RAW_INFO("Creating random file: %s ...", (uint32_t)my_filename);
NRF_LOG_FLUSH();
ff_result = f_open(&file, my_filename, FA_CREATE_ALWAYS | FA_WRITE);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to open or create file: %u", ff_result);
NRF_LOG_FLUSH();
return;
}
//write a string
#if 0
static BYTE test_string[] = "christophe\t1995\t0707\r\nsid\t1997\t1234\r\n";
UINT data_len_written = 0;
ff_result = f_write(&file, test_string, (UINT)strlen(test_string), &data_len_written);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to write data: %u", ff_result);
NRF_LOG_FLUSH();
return;
}
//#endif
//
// ff_result = f_close(&file);
// if (ff_result != FR_OK)
// {
// NRF_LOG_ERROR("\r\nUnable to close file: %u", ff_result);
// NRF_LOG_FLUSH();
// return;
// }
// NRF_LOG_RAW_INFO("done\r\n");
//
////second open
//#if 1
// ff_result = f_open(&file, my_filename, FA_CREATE_ALWAYS | FA_WRITE);
// if (ff_result != FR_OK)
// {
// NRF_LOG_ERROR("\r\nUnable to open or create file: %u", ff_result);
// NRF_LOG_FLUSH();
// return;
// }
//
// ff_result = f_lseek(&file, (FSIZE_t)strlen(test_string));
// if (ff_result != FR_OK)
// {
// NRF_LOG_ERROR("\r\nUnable to write data: %u", ff_result);
// NRF_LOG_FLUSH();
// return;
// }
static BYTE test_string2[] = "\r\nerqwerq\t4755\t8575\r\ndsFEF\t4789\t8760\r\n";
UINT data_len_written2 = 0;
ff_result = f_write(&file, test_string2, (UINT)strlen(test_string2), &data_len_written2);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to write data: %u", ff_result);
NRF_LOG_FLUSH();
return;
}
static BYTE test_string3[] = "\r\ncaerg\t1472\t8673\r\nitukk\t4752\t1785\r\n";
UINT data_len_written3 = 0;
ff_result = f_write(&file, test_string3, (UINT)strlen(test_string3), &data_len_written3);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to write data: %u", ff_result);
NRF_LOG_FLUSH();
return;
}
#endif
ff_result = f_close(&file);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to close file: %u", ff_result);
NRF_LOG_FLUSH();
return;
}
NRF_LOG_RAW_INFO("done\r\n");
}
static FRESULT my_file_open(FIL* my_file)
{
FRESULT ff_result;
ret_code_t err_code;
if (g_test_open)
{
return FR_FILE_OPENED;
}
ff_result = f_open(my_file, my_filename, FA_OPEN_ALWAYS | FA_WRITE | FA_OPEN_APPEND);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to open or create file: %u", ff_result);
NRF_LOG_FLUSH();
return ff_result;
}
#if CLOSE_FILE_BY_TIMER
err_code = app_timer_start(file_close_timer_id, CLOSE_INTERVAL, NULL);
APP_ERROR_CHECK(err_code);
#endif
g_test_open = true;
nrf_gpio_pin_set(BSP_LED_0);
nrf_gpio_pin_clear(BSP_LED_1);
return ff_result;
}
#if 0
static void my_file_write(void)
{
FRESULT ff_result;
FIL file;
ff_result = f_write(&file, test, (UINT)strlen(test), &written);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to write data: %u", ff_result);
NRF_LOG_FLUSH();
return;
}
}
#endif
static FRESULT my_file_close(FIL * my_file)
{
FRESULT ff_result;
if (g_test_open == false)
{
return FR_FILE_CLOSED;
}
ff_result = f_close(my_file);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to close file: %u", ff_result);
NRF_LOG_FLUSH();
return ff_result;
}
NRF_LOG_RAW_INFO("done\r\n");
g_test_open = false;
#if CLOSE_FILE_BY_TIMER
//app_timer_stop(file_close_timer_id);
#endif
NRF_LOG_RAW_INFO("file closed!\r\n");
NRF_LOG_FLUSH();
nrf_gpio_pin_set(BSP_LED_1);
nrf_gpio_pin_clear(BSP_LED_0);
return ff_result;
}
static void my_write_data(void)
{
FRESULT ff_result;
FIL file;
ff_result = f_open(&file, my_filename, FA_CREATE_ALWAYS | FA_WRITE);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to open or create file: %u", ff_result);
NRF_LOG_FLUSH();
return;
}
//write a string
#if 1
// ff_result = f_lseek(&file, file.obj->fs.fsize));
// if (ff_result != FR_OK)
// {
// NRF_LOG_ERROR("\r\nUnable to write data: %u", ff_result);
// NRF_LOG_FLUSH();
// return;
// }
static BYTE test[] = "1111\t2222\t3333\r\n4444\t5555\t6666\r\n";
UINT written = 0;
ff_result = f_write(&file, test, (UINT)strlen(test), &written);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to write data: %u", ff_result);
NRF_LOG_FLUSH();
return;
}
ff_result = f_close(&file);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to close file: %u", ff_result);
NRF_LOG_FLUSH();
return;
}
NRF_LOG_RAW_INFO("done\r\n");
}
static void fatfs_uninit(void)
{
NRF_LOG_INFO("Un-initializing disk 0 (QSPI)...");
UNUSED_RETURN_VALUE(disk_uninitialize(0));
}
#else //USE_FATFS_QSPI
#define fatfs_init() false
#define fatfs_mkfs() do { } while (0)
#define fatfs_ls() do { } while (0)
#define fatfs_file_create() do { } while (0)
#define fatfs_uninit() do { } while (0)
#endif
/**
* @brief Class specific event handler.
*
* @param p_inst Class instance.
* @param event Class specific event.
*/
static void msc_user_ev_handler(app_usbd_class_inst_t const * p_inst,
app_usbd_msc_user_event_t event)
{
UNUSED_PARAMETER(p_inst);
UNUSED_PARAMETER(event);
}
/**
* @brief USBD library specific event handler.
*
* @param event USBD library event.
*/
static void usbd_user_ev_handler(app_usbd_event_type_t event)
{
switch (event)
{
case APP_USBD_EVT_DRV_SUSPEND:
//bsp_board_led_off(LED_USB_RESUME);
break;
case APP_USBD_EVT_DRV_RESUME:
//bsp_board_led_on(LED_USB_RESUME);
break;
case APP_USBD_EVT_STARTED:
//bsp_board_led_on(LED_USB_START);
break;
case APP_USBD_EVT_STOPPED:
UNUSED_RETURN_VALUE(fatfs_init());
app_usbd_disable();
//bsp_board_leds_off();
break;
case APP_USBD_EVT_POWER_DETECTED:
NRF_LOG_INFO("USB power detected");
if (!nrf_drv_usbd_is_enabled())
{
fatfs_uninit();
app_usbd_enable();
}
break;
case APP_USBD_EVT_POWER_REMOVED:
NRF_LOG_INFO("USB power removed");
app_usbd_stop();
m_usb_connected = false;
memset(&m_rx, 0, sizeof(m_rx));
break;
case APP_USBD_EVT_POWER_READY:
NRF_LOG_INFO("USB ready");
app_usbd_start();
m_usb_connected = true;
break;
default:
break;
}
}
#endif
NRF_LIBUARTE_ASYNC_DEFINE(libuarte, 0, 0, 0, NRF_LIBUARTE_PERIPHERAL_NOT_USED, 255, 3);
static uint8_t text[] = "UART example started.\r\n Loopback:\r\n";
static uint8_t text_size = sizeof(text);
static volatile bool m_loopback_phase;
typedef struct {
uint8_t * p_data;
uint32_t length;
} buffer_t;
NRF_QUEUE_DEF(buffer_t, m_buf_queue, 10, NRF_QUEUE_MODE_NO_OVERFLOW);
#if 0
void uart_event_handler(void * context, nrf_libuarte_async_evt_t * p_evt)
{
nrf_libuarte_async_t * p_libuarte = (nrf_libuarte_async_t *)context;
ret_code_t ret;
FRESULT ff_result;
FIL file;
switch (p_evt->type)
{
case NRF_LIBUARTE_ASYNC_EVT_ERROR:
bsp_board_led_invert(0);
break;
case NRF_LIBUARTE_ASYNC_EVT_RX_DATA:
ret = nrf_libuarte_async_tx(p_libuarte,p_evt->data.rxtx.p_data, p_evt->data.rxtx.length);
if (ret == NRF_ERROR_BUSY)
{
buffer_t buf = {
.p_data = p_evt->data.rxtx.p_data,
.length = p_evt->data.rxtx.length,
};
ret = nrf_queue_push(&m_buf_queue, &buf);
APP_ERROR_CHECK(ret);
}
else
{
APP_ERROR_CHECK(ret);
}
bsp_board_led_invert(1);
m_loopback_phase = true;
g_write_flag = true;
break;
case NRF_LIBUARTE_ASYNC_EVT_TX_DONE:
if (m_loopback_phase)
{
nrf_libuarte_async_rx_free(p_libuarte, p_evt->data.rxtx.p_data, p_evt->data.rxtx.length);
if (!nrf_queue_is_empty(&m_buf_queue))
{
buffer_t buf;
ret = nrf_queue_pop(&m_buf_queue, &buf);
APP_ERROR_CHECK(ret);
UNUSED_RETURN_VALUE(nrf_libuarte_async_tx(p_libuarte, buf.p_data, buf.length));
}
}
bsp_board_led_invert(2);
break;
default:
break;
}
}
#endif
void uart_event_handler(void * context, nrf_libuarte_async_evt_t * p_evt)
{
nrf_libuarte_async_t * p_libuarte = (nrf_libuarte_async_t *)context;
ret_code_t ret;
switch (p_evt->type)
{
case NRF_LIBUARTE_ASYNC_EVT_ERROR:
bsp_board_led_invert(0);
break;
case NRF_LIBUARTE_ASYNC_EVT_RX_DATA:
memcpy(&m_rx.rx_buff[m_rx.rx_index],p_evt->data.rxtx.p_data,p_evt->data.rxtx.length);
m_rx.rx_index += p_evt->data.rxtx.length;
nrf_libuarte_async_rx_free(p_libuarte, p_evt->data.rxtx.p_data, p_evt->data.rxtx.length);
break;
case NRF_LIBUARTE_ASYNC_EVT_RX_DATA_TIMEOUT:
if(p_evt->data.rxtx.length)
{
memcpy(&m_rx.rx_buff[m_rx.rx_index],p_evt->data.rxtx.p_data,p_evt->data.rxtx.length);
m_rx.rx_index += p_evt->data.rxtx.length;
}
nrf_libuarte_async_rx_free(p_libuarte, p_evt->data.rxtx.p_data, p_evt->data.rxtx.length);
//nrf_libuarte_async_tx(p_libuarte, m_rx.rx_buff, m_rx.rx_index);
NRF_LOG_INFO("rx_buff is: %s\n", m_rx.rx_buff);
break;
case NRF_LIBUARTE_ASYNC_EVT_TX_DONE:
memset(&m_rx, 0, sizeof(m_rx));
break;
default:
break;
}
}
static void close_file_handler(void * p_context)
{
UNUSED_PARAMETER(p_context);
g_idle_s++;
}
static void timers_init(void)
{
ret_code_t err_code = app_timer_init();
APP_ERROR_CHECK(err_code);
err_code = app_timer_create(&file_close_timer_id,
APP_TIMER_MODE_REPEATED,
close_file_handler);
APP_ERROR_CHECK(err_code);
}
/**
* @brief Function for main application entry.
*/
int main(void)
{
FRESULT ff_result;
FIL file;
bsp_board_init(BSP_INIT_LEDS);
ret_code_t ret;
static const app_usbd_config_t usbd_config = {
.ev_state_proc = usbd_user_ev_handler
};
ret = nrf_drv_clock_init();
APP_ERROR_CHECK(ret);
nrf_drv_clock_lfclk_request(NULL);
ret_code_t err_code = NRF_LOG_INIT(app_timer_cnt_get);
APP_ERROR_CHECK(err_code);
NRF_LOG_DEFAULT_BACKENDS_INIT();
nrf_libuarte_async_config_t nrf_libuarte_async_config = {
.tx_pin = TX_PIN_NUMBER,
.rx_pin = RX_PIN_NUMBER,
.baudrate = NRF_UARTE_BAUDRATE_38400,
.parity = NRF_UARTE_PARITY_EXCLUDED,
.hwfc = NRF_UARTE_HWFC_DISABLED,
.timeout_us = 10000,
.int_prio = APP_IRQ_PRIORITY_LOW_MID
};
err_code = nrf_libuarte_async_init(&libuarte, &nrf_libuarte_async_config, uart_event_handler, (void *)&libuarte);
APP_ERROR_CHECK(err_code);
nrf_libuarte_async_enable(&libuarte);
err_code = nrf_libuarte_async_tx(&libuarte, text, text_size);
APP_ERROR_CHECK(err_code);
timers_init();
if (fatfs_init())
{
fatfs_ls();
fatfs_file_create();
//fatfs_mkfs();
}
ret = app_usbd_init(&usbd_config);
APP_ERROR_CHECK(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);
NRF_LOG_INFO("USBD MSC example started.");
if (true)
{
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;
}
uint8_t write_cnt = 0;
nrf_gpio_cfg_output(BSP_LED_0);
nrf_gpio_cfg_output(BSP_LED_1);
nrf_gpio_pin_set(BSP_LED_0);
nrf_gpio_pin_set(BSP_LED_1);
memset(&m_rx, 0, sizeof(m_rx));
NRF_LOG_INFO("New Flash to write.");
#if 1 //read JEDEC ID
nrf_qspi_cinstr_conf_t cinstr_cfg = {
.opcode = 0x9F,
.length = 4,
.io2_level = true,
.io3_level = true,
.wipwait = true,
.wren = true
};
uint8_t rdid_buf[3] = {0, 0, 0};
ret = nrf_drv_qspi_cinstr_xfer(&cinstr_cfg, NULL, rdid_buf);
if (ret != NRF_SUCCESS)
{
NRF_LOG_INFO("read eror.");
//NRF_LOG_INST_ERROR(p_qspi_dev->p_log, "QSPI get 3 byte id error: %"PRIu32"", ret);
//return ret;
}
NRF_LOG_INFO("rdid_buf [%02x %02x %02x]", rdid_buf[0], rdid_buf[1], rdid_buf[2]);
#endif
while (true)
{
while (app_usbd_event_queue_process())
{
/* Nothing to do */
}
#if 1
if (strlen(m_rx.rx_buff) && !m_usb_connected)
{
g_idle_s = 0;
NRF_LOG_INFO("will write something.");
UINT written = 0;
ff_result = my_file_open(&file);
if (ff_result == FR_FILE_OPENED || ff_result == FR_OK)
{
ff_result = f_write(&file, m_rx.rx_buff, (UINT)strlen(m_rx.rx_buff), &written);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to write data: %u", ff_result);
NRF_LOG_FLUSH();
}
#if CLOSE_FILE_BY_STRING
if (strstr(m_rx.rx_buff, "END\n"))
{
ff_result = my_file_close(&file);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to close file: %u", ff_result);
NRF_LOG_FLUSH();
}
}
#endif
memset(&m_rx, 0, sizeof(m_rx));
}
}
#if CLOSE_FILE_BY_TIMER
if (g_idle_s > 1)
{
g_idle_s = 0;
ff_result = my_file_close(&file);
if (ff_result != FR_OK)
{
NRF_LOG_ERROR("\r\nUnable to close file: %u", ff_result);
NRF_LOG_FLUSH();
}
nrf_gpio_pin_set(BSP_LED_1);
nrf_gpio_pin_clear(BSP_LED_0);
}
#endif
#endif
//memset(&m_rx, 0, sizeof(m_rx));
NRF_LOG_FLUSH();
}
}
/** @} */
<info> app_timer: RTC: initialized.
<info> app: Initializing disk 0 (QSPI)...
<info> app: Mounting volume...
<error> app: Mount failed. Filesystem not found. Please format device.
<info> app: USBD MSC example started.
<info> app: New Flash to write.
<info> app: rdid_buf [EF 40 17]
<info> app: USB power detected
<info> app: Un-initializing disk 0 (QSPI)...
<info> app: USB ready
