Hi, Dear Nordic & All:
I use usbd_msc example to generate .xls file, and write content in it, sometimes I write successfully, and can open it right on PC with WPS，
but sometimes I generate the same .xls file (my application in nrf52840 DK(sdk 17.0.2) is exactly the same for creating the .xls files ), but after write content and close it, I can not open it on PC with WPS, and PC prompt the file may be damaged so I can not open, just like this:
All APIs I used in this demo is： f_open(my_file, my_filename, FA_OPEN_ALWAYS | FA_WRITE | FA_OPEN_APPEND);
f_write(&file, m_rx.rx_buff, (UINT)strlen(m_rx.rx_buff), &written);
f_close(my_file);
I'v thought the damaged file may caused by the frequency I open/close(because this demo need operate .xls file frequently ), but I decrease the frequency of open/close, the problem still exist, this really confuse me.
The following is my whole code, It's function is: writing serial data (va libuarte) into .xls file, I will open file once the data come, and will close it when received "END"，
/**
* 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"
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*5)
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,
NRF_BLOCK_DEV_QSPI_FLAG_CACHE_WRITEBACK,
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.");
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 0
err_code = app_timer_start(file_close_timer_id, CLOSE_INTERVAL, NULL);
APP_ERROR_CHECK(err_code);
#endif
g_test_open = true;
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();
}
NRF_LOG_RAW_INFO("done\r\n");
g_test_open = false;
NRF_LOG_RAW_INFO("file closed!\r\n");
NRF_LOG_FLUSH();
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;
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);
memset(&m_rx, 0, sizeof(m_rx));
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_gpio_pin_clear(BSP_LED_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 (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();
}
}
memset(&m_rx, 0, sizeof(m_rx));
}
#endif
}
nrf_gpio_pin_set(BSP_LED_0);
#if 0
if (g_idle_s > 0)
{
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
//memset(&m_rx, 0, sizeof(m_rx));
NRF_LOG_FLUSH();
}
}
/** @} */
and, the following is my .xls file which is damaged and can not open, can you see anything wrong about this file?
Can anybody know what happened on this?
Thanks for your kind help!
