doc: renamed project
This commit is contained in:
SylvanArnold
committed by
Sylvan Arnold
Sylvan Arnold
parent
244e516bd8
commit
32618389d1
953
pico-sensor/McuLib/littleFS/McuLittleFS.c
Normal file
953
pico-sensor/McuLib/littleFS/McuLittleFS.c
Normal file
@@ -0,0 +1,953 @@
|
||||
/*
|
||||
* Copyright (c) 2022, Erich Styger
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
#include "McuLittleFS.h"
|
||||
#include "McuLittleFSconfig.h"
|
||||
#include "McuLittleFSBlockDevice.h"
|
||||
#include "McuShell.h"
|
||||
#include "McuTimeDate.h"
|
||||
#include "littleFS/lfs.h"
|
||||
#if McuLittleFSBlockDevice_CONFIG_MEMORY_TYPE==McuLittleFSBlockDevice_CONFIG_MEMORY_TYPE_WINBOND_W25Q128
|
||||
#include "McuW25Q128.h"
|
||||
#elif McuLittleFSBlockDevice_CONFIG_MEMORY_TYPE==McuLittleFSBlockDevice_CONFIG_MEMORY_TYPE_MCU_FLASH
|
||||
#include "McuFlash.h"
|
||||
#endif
|
||||
|
||||
/* variables used by the file system */
|
||||
static bool McuLFS_isMounted = FALSE;
|
||||
static lfs_t McuLFS_lfs;
|
||||
|
||||
#if LITTLEFS_CONFIG_THREAD_SAFE
|
||||
static SemaphoreHandle_t fileSystemAccessMutex;
|
||||
#endif
|
||||
|
||||
bool McuLFS_IsMounted(void) {
|
||||
return McuLFS_isMounted;
|
||||
}
|
||||
|
||||
#if LITTLEFS_CONFIG_THREAD_SAFE
|
||||
static int McuLittleFS_lock(const struct lfs_config *c) {
|
||||
if (xSemaphoreTakeRecursive(fileSystemAccessMutex, portMAX_DELAY)== pdTRUE) {
|
||||
return 0; /* ok */
|
||||
}
|
||||
return -1; /* failed */
|
||||
}
|
||||
|
||||
static int McuLittleFS_unlock(const struct lfs_config *c) {
|
||||
if (xSemaphoreGiveRecursive(fileSystemAccessMutex) == pdTRUE) {
|
||||
return 0; /* ok */
|
||||
}
|
||||
return -1; /* failed */
|
||||
}
|
||||
#endif /* LITTLEFS_CONFIG_THREAD_SAFE */
|
||||
|
||||
/* configuration of the file system is provided by this struct */
|
||||
static const struct lfs_config McuLFS_cfg = {
|
||||
.context = NULL,
|
||||
/* block device operations */
|
||||
.read = McuLittleFS_block_device_read,
|
||||
.prog = McuLittleFS_block_device_prog,
|
||||
.erase = McuLittleFS_block_device_erase,
|
||||
.sync = McuLittleFS_block_device_sync,
|
||||
/* block device configuration */
|
||||
.read_size = McuLittleFS_CONFIG_FILESYSTEM_READ_BUFFER_SIZE,
|
||||
.prog_size = McuLittleFS_CONFIG_FILESYSTEM_PROG_BUFFER_SIZE,
|
||||
.block_size = McuLittleFS_CONFIG_BLOCK_SIZE,
|
||||
.block_count = McuLittleFS_CONFIG_BLOCK_COUNT,
|
||||
.cache_size = McuLittleFS_CONFIG_FILESYSTEM_CACHE_SIZE,
|
||||
.lookahead_size = McuLittleFS_CONFIG_FILESYSTEM_LOOKAHEAD_SIZE,
|
||||
.block_cycles = 500,
|
||||
#if LITTLEFS_CONFIG_THREAD_SAFE
|
||||
.lock = McuLittleFS_lock,
|
||||
.unlock = McuLittleFS_unlock,
|
||||
#endif
|
||||
};
|
||||
|
||||
const struct lfs_config *McuLFS_get_config(void) {
|
||||
return &McuLFS_cfg;
|
||||
}
|
||||
|
||||
lfs_t *McuLFS_get_lfs(void) {
|
||||
return &McuLFS_lfs;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* Get a string from the file
|
||||
* (ported from FatFS function: f_gets())
|
||||
*-----------------------------------------------------------------------*/
|
||||
|
||||
char* McuLFS_gets (
|
||||
char* buff, /* Pointer to the string buffer to read */
|
||||
int len, /* Size of string buffer (characters) */
|
||||
lfs_file_t* fp /* Pointer to the file object */
|
||||
)
|
||||
{
|
||||
int n = 0;
|
||||
char c, *p = buff;
|
||||
unsigned char s[2];
|
||||
uint32_t rc;
|
||||
|
||||
while (n < len - 1) { /* Read characters until buffer gets filled */
|
||||
rc = lfs_file_read(&McuLFS_lfs,fp,s,1);
|
||||
if (rc != 1) break;
|
||||
c = s[0];
|
||||
|
||||
if (c == '\r') continue; /* Strip '\r' */
|
||||
*p++ = c;
|
||||
n++;
|
||||
if (c == '\n') break; /* Break on EOL */
|
||||
}
|
||||
*p = 0;
|
||||
return n ? buff : 0; /* When no data read (eof or error), return with error. */
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------*
|
||||
* Put a character to the file
|
||||
* (ported from FatFS)
|
||||
*-----------------------------------------------------------------------*/
|
||||
|
||||
typedef struct putbuff {
|
||||
lfs_file_t* fp ;
|
||||
int idx, nchr;
|
||||
unsigned char buf[64];
|
||||
} putbuff;
|
||||
|
||||
|
||||
static void putc_bfd (putbuff* pb, char c) {
|
||||
uint32_t bw;
|
||||
int32_t i;
|
||||
|
||||
if (c == '\n') { /* LF -> CRLF conversion */
|
||||
putc_bfd(pb, '\r');
|
||||
}
|
||||
|
||||
i = pb->idx; /* Buffer write index (-1:error) */
|
||||
if (i < 0) {
|
||||
return;
|
||||
}
|
||||
pb->buf[i++] = (unsigned char)c;
|
||||
|
||||
if (i >= (int)(sizeof pb->buf) - 3) { /* Write buffered characters to the file */
|
||||
bw = lfs_file_write(&McuLFS_lfs,pb->fp, pb->buf,(uint32_t)i);
|
||||
i = (bw == (uint32_t)i) ? 0 : -1;
|
||||
}
|
||||
pb->idx = i;
|
||||
pb->nchr++;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------*/
|
||||
/* Put a string to the file
|
||||
* (ported from FatFS function: f_puts()) */
|
||||
/*-----------------------------------------------------------------------*/
|
||||
|
||||
int McuLFS_puts (
|
||||
const char* str, /* Pointer to the string to be output */
|
||||
lfs_file_t* fp /* Pointer to the file object */
|
||||
)
|
||||
{
|
||||
putbuff pb;
|
||||
uint32_t nw;
|
||||
|
||||
pb.fp = fp; /* Initialize output buffer */
|
||||
pb.nchr = pb.idx = 0;
|
||||
|
||||
while (*str) { /* Put the string */
|
||||
putc_bfd(&pb, *str++);
|
||||
}
|
||||
nw = lfs_file_write(&McuLFS_lfs,pb.fp, pb.buf, (uint32_t)pb.idx);
|
||||
|
||||
if ( pb.idx >= 0 /* Flush buffered characters to the file */
|
||||
&& nw>=0
|
||||
&& (uint32_t)pb.idx == nw)
|
||||
{
|
||||
return pb.nchr;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
uint8_t McuLFS_Format(McuShell_ConstStdIOType *io) {
|
||||
int res;
|
||||
|
||||
if (McuLFS_isMounted) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"File system is mounted, unmount it first.\r\n",io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"Formatting ...", io->stdOut);
|
||||
}
|
||||
res = lfs_format(&McuLFS_lfs, &McuLFS_cfg);
|
||||
if (res == LFS_ERR_OK) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)" done.\r\n", io->stdOut);
|
||||
}
|
||||
return ERR_OK;
|
||||
} else {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)" FAILED!\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t McuLFS_Mount(McuShell_ConstStdIOType *io) {
|
||||
int res;
|
||||
|
||||
if (McuLFS_isMounted) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"File system is already mounted.\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"Mounting ...", io->stdOut);
|
||||
}
|
||||
res = lfs_mount(&McuLFS_lfs, &McuLFS_cfg);
|
||||
if (res == LFS_ERR_OK) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)" done.\r\n", io->stdOut);
|
||||
}
|
||||
McuLFS_isMounted = TRUE;
|
||||
return ERR_OK;
|
||||
} else {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)" FAILED! Did you format the device?\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t McuLFS_Unmount(McuShell_ConstStdIOType *io) {
|
||||
int res;
|
||||
|
||||
if (!McuLFS_isMounted) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"File system is already unmounted.\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"Unmounting ...", io->stdOut);
|
||||
}
|
||||
res = lfs_unmount(&McuLFS_lfs);
|
||||
if (res == LFS_ERR_OK) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)" done.\r\n", io->stdOut);
|
||||
}
|
||||
McuLFS_isMounted = FALSE;
|
||||
return ERR_OK;
|
||||
} else {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)" FAILED!\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t McuLFS_Dir(const char *path, McuShell_ConstStdIOType *io) {
|
||||
int res;
|
||||
lfs_dir_t dir;
|
||||
struct lfs_info info;
|
||||
|
||||
if (io == NULL) {
|
||||
return ERR_FAILED; /* listing a directory without an I/O channel does not make any sense */
|
||||
}
|
||||
|
||||
if (!McuLFS_isMounted) {
|
||||
McuShell_SendStr((const uint8_t *)"File system is not mounted, mount it first.\r\n", io->stdErr);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
if (path == NULL) {
|
||||
path = "/"; /* default path */
|
||||
}
|
||||
res = lfs_dir_open(&McuLFS_lfs, &dir, path);
|
||||
if (res != LFS_ERR_OK) {
|
||||
McuShell_SendStr((const uint8_t *)"FAILED lfs_dir_open()!\r\n", io->stdErr);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
for(;;) {
|
||||
res = lfs_dir_read(&McuLFS_lfs, &dir, &info);
|
||||
if (res < 0) {
|
||||
McuShell_SendStr((const uint8_t *)"FAILED lfs_dir_read()!\r\n", io->stdErr);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
if (res == 0) { /* no more files */
|
||||
break;
|
||||
}
|
||||
switch (info.type) {
|
||||
case LFS_TYPE_REG:
|
||||
McuShell_SendStr((const uint8_t *)"reg ", io->stdOut);
|
||||
break;
|
||||
case LFS_TYPE_DIR:
|
||||
McuShell_SendStr((const uint8_t *)"dir ", io->stdOut);
|
||||
break;
|
||||
default:
|
||||
McuShell_SendStr((const uint8_t *)"? ", io->stdOut);
|
||||
break;
|
||||
}
|
||||
static const char *prefixes[] = { "", "K", "M", "G" }; /* prefixes for kilo, mega and giga */
|
||||
unsigned char buf[12];
|
||||
|
||||
for (int i = sizeof(prefixes) / sizeof(prefixes[0]) - 1; i >= 0; i--) {
|
||||
if (info.size >= (1 << 10 * i) - 1) {
|
||||
McuUtility_Num32sToStrFormatted(buf, sizeof(buf), (unsigned int)(info.size >> 10 * i), ' ', 4 - (i != 0));
|
||||
McuUtility_strcat(buf, sizeof(buf), (const unsigned char*)prefixes[i]);
|
||||
McuUtility_chcat(buf, sizeof(buf), ' ');
|
||||
McuShell_SendStr(buf, io->stdOut);
|
||||
break;
|
||||
}
|
||||
} /* for */
|
||||
McuShell_SendStr((const uint8_t *)info.name, io->stdOut);
|
||||
McuShell_SendStr((const uint8_t *)"\r\n", io->stdOut);
|
||||
} /* for */
|
||||
res = lfs_dir_close(&McuLFS_lfs, &dir);
|
||||
if (res != LFS_ERR_OK) {
|
||||
McuShell_SendStr((const uint8_t *)"FAILED lfs_dir_close()!\r\n", io->stdErr);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
* Prints a list of Files and Directories of a given path
|
||||
* If path == NULL, the Files and Direcotries of the root-directory are printed
|
||||
* The First two characters of every line determin if its a File (F:) or a Directory (D:)
|
||||
*/
|
||||
uint8_t McuLFS_FileList(const char *path, McuShell_ConstStdIOType *io) {
|
||||
int res;
|
||||
lfs_dir_t dir;
|
||||
struct lfs_info info;
|
||||
|
||||
if (io == NULL) {
|
||||
return ERR_FAILED; /* listing a directory without an I/O channel does not make any sense */
|
||||
}
|
||||
if (!McuLFS_isMounted) {
|
||||
McuShell_SendStr((const uint8_t *)"File system is not mounted, mount it first.\r\n", io->stdErr);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
if (path == NULL) {
|
||||
path = "/"; /* default path */
|
||||
}
|
||||
res = lfs_dir_open(&McuLFS_lfs, &dir, path);
|
||||
if (res != LFS_ERR_OK) {
|
||||
McuShell_SendStr((const uint8_t *)"FAILED lfs_dir_open()!\r\n", io->stdErr);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
for(;;) {
|
||||
res = lfs_dir_read(&McuLFS_lfs, &dir, &info);
|
||||
if (res < 0) {
|
||||
McuShell_SendStr((const uint8_t *)"FAILED lfs_dir_read()!\r\n", io->stdErr);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
if (res == 0) { /* no more files */
|
||||
break;
|
||||
}
|
||||
|
||||
if(!(McuUtility_strcmp(info.name,".") == 0 || McuUtility_strcmp(info.name,"..") == 0 )) {
|
||||
switch (info.type) {
|
||||
case LFS_TYPE_REG:
|
||||
McuShell_SendStr((const uint8_t *)"F:", io->stdOut);
|
||||
break;
|
||||
case LFS_TYPE_DIR:
|
||||
McuShell_SendStr((const uint8_t *)"D:", io->stdOut);
|
||||
break;
|
||||
default:
|
||||
McuShell_SendStr((const uint8_t *)"?:", io->stdOut);
|
||||
break;
|
||||
}
|
||||
McuShell_SendStr((const uint8_t *)info.name, io->stdOut);
|
||||
McuShell_SendStr((const uint8_t *)"\r\n", io->stdOut);
|
||||
}
|
||||
|
||||
} /* for */
|
||||
res = lfs_dir_close(&McuLFS_lfs, &dir);
|
||||
if (res != LFS_ERR_OK) {
|
||||
McuShell_SendStr((const uint8_t *)"FAILED lfs_dir_close()!\r\n", io->stdErr);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
uint8_t McuLFS_CopyFile(const char *srcPath, const char *dstPath,McuShell_ConstStdIOType *io) {
|
||||
lfs_file_t fsrc, fdst;
|
||||
int result, nofBytesRead;
|
||||
uint8_t buffer[32]; /* copy buffer */
|
||||
uint8_t res = ERR_OK;
|
||||
|
||||
if (!McuLFS_isMounted) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"ERROR: File system is not mounted.\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
|
||||
/* open source file */
|
||||
result = lfs_file_open(&McuLFS_lfs, &fsrc, srcPath, LFS_O_RDONLY);
|
||||
if (result < 0) {
|
||||
McuShell_SendStr((const unsigned char*) "*** Failed opening source file!\r\n",io->stdErr);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
/* create destination file */
|
||||
result = lfs_file_open(&McuLFS_lfs, &fdst, dstPath, LFS_O_WRONLY | LFS_O_CREAT);
|
||||
if (result < 0) {
|
||||
(void) lfs_file_close(&McuLFS_lfs, &fsrc);
|
||||
McuShell_SendStr((const unsigned char*) "*** Failed opening destination file!\r\n", io->stdErr);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
/* now copy source to destination */
|
||||
for (;;) {
|
||||
nofBytesRead = lfs_file_read(&McuLFS_lfs, &fsrc, buffer, sizeof(buffer));
|
||||
if (nofBytesRead < 0) {
|
||||
McuShell_SendStr((const unsigned char*) "*** Failed reading source file!\r\n",io->stdErr);
|
||||
res = ERR_FAILED;
|
||||
break;
|
||||
}
|
||||
if (nofBytesRead == 0) { /* end of file */
|
||||
break;
|
||||
}
|
||||
result = lfs_file_write(&McuLFS_lfs, &fdst, buffer, nofBytesRead);
|
||||
if (result < 0) {
|
||||
McuShell_SendStr((const unsigned char*) "*** Failed writing destination file!\r\n", io->stdErr);
|
||||
res = ERR_FAILED;
|
||||
break;
|
||||
}
|
||||
} /* for */
|
||||
/* close all files */
|
||||
result = lfs_file_close(&McuLFS_lfs, &fsrc);
|
||||
if (result < 0) {
|
||||
McuShell_SendStr((const unsigned char*) "*** Failed closing source file!\r\n", io->stdErr);
|
||||
res = ERR_FAILED;
|
||||
}
|
||||
result = lfs_file_close(&McuLFS_lfs, &fdst);
|
||||
if (result < 0) {
|
||||
McuShell_SendStr((const unsigned char*) "*** Failed closing destination file!\r\n", io->stdErr);
|
||||
res = ERR_FAILED;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
uint8_t McuLFS_MoveFile(const char *srcPath, const char *dstPath,McuShell_ConstStdIOType *io) {
|
||||
if (!McuLFS_isMounted) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"ERROR: File system is not mounted.\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
if (lfs_rename(&McuLFS_lfs, srcPath, dstPath) < 0) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"ERROR: failed renaming file or directory.\r\n",io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
* Used to read out data from Files for SDEP communication
|
||||
*/
|
||||
uint8_t McuLFS_ReadFile(lfs_file_t* file, bool readFromBeginning, size_t nofBytes, McuShell_ConstStdIOType *io) {
|
||||
static int32_t filePos;
|
||||
size_t fileSize;
|
||||
uint8_t buf[1024];
|
||||
|
||||
if( nofBytes > 1024) {
|
||||
nofBytes = 1024;
|
||||
}
|
||||
if(readFromBeginning) {
|
||||
lfs_file_rewind(&McuLFS_lfs,file);
|
||||
filePos = 0;
|
||||
} else {
|
||||
lfs_file_seek(&McuLFS_lfs,file, filePos,LFS_SEEK_SET);
|
||||
}
|
||||
|
||||
fileSize = lfs_file_size(&McuLFS_lfs, file);
|
||||
filePos = lfs_file_tell(&McuLFS_lfs, file);
|
||||
fileSize = fileSize - filePos;
|
||||
|
||||
if (fileSize < 0) {
|
||||
return ERR_FAILED;
|
||||
}
|
||||
|
||||
if(fileSize > nofBytes) {
|
||||
if (lfs_file_read(&McuLFS_lfs, file, buf, nofBytes) < 0) {
|
||||
return ERR_FAILED;
|
||||
}
|
||||
McuShell_SendData(buf,nofBytes,io->stdErr);
|
||||
filePos = filePos + nofBytes;
|
||||
return ERR_OK;
|
||||
} else {
|
||||
if (lfs_file_read(&McuLFS_lfs, file, buf, fileSize) < 0) {
|
||||
return ERR_FAILED;
|
||||
}
|
||||
McuShell_SendData(buf,fileSize,io->stdErr);
|
||||
filePos = filePos + fileSize;
|
||||
return ERR_PARAM_SIZE; //EOF
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
uint8_t McuLFS_openFile(lfs_file_t* file, uint8_t* filename) {
|
||||
if (lfs_file_open(&McuLFS_lfs, file, (const char*)filename, LFS_O_RDWR | LFS_O_CREAT| LFS_O_APPEND) < 0) {
|
||||
return ERR_FAILED;
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
uint8_t McuLFS_closeFile(lfs_file_t* file) {
|
||||
if(lfs_file_close(&McuLFS_lfs, file) == 0) {
|
||||
return ERR_OK;
|
||||
} else {
|
||||
return ERR_FAILED;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t McuLFS_writeLine(lfs_file_t* file, uint8_t* line) {
|
||||
uint8_t lineBuf[200];
|
||||
McuUtility_strcpy(lineBuf, sizeof(lineBuf), line);
|
||||
McuUtility_strcat(lineBuf, sizeof(lineBuf), (unsigned char*)"\r\n");
|
||||
|
||||
if (lfs_file_write(&McuLFS_lfs, file, lineBuf, McuUtility_strlen((char*)lineBuf)) < 0) {
|
||||
lfs_file_close(&McuLFS_lfs, file);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
uint8_t McuLFS_readLine(lfs_file_t* file, uint8_t* lineBuf, size_t bufSize, uint8_t* nofReadChars) {
|
||||
lineBuf[0] = '\0';
|
||||
uint8_t ch;
|
||||
*nofReadChars = 0;
|
||||
|
||||
while(lfs_file_read(&McuLFS_lfs, file, &ch, 1) != 0 && ch != '\n') {
|
||||
(*nofReadChars)++;
|
||||
McuUtility_chcat(lineBuf,200,ch);
|
||||
}
|
||||
McuUtility_chcat(lineBuf,200,ch);
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
/* Function for the Shell PrintHex command */
|
||||
static uint8_t readFromFile(void *hndl, uint32_t addr, uint8_t *buf, size_t bufSize) {
|
||||
lfs_file_t *fp;
|
||||
|
||||
fp = (lfs_file_t*)hndl;
|
||||
if (lfs_file_read(&McuLFS_lfs, fp, buf, bufSize) < 0) {
|
||||
return ERR_FAILED;
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
uint8_t McuLFS_PrintFile(const char *filePath, McuShell_ConstStdIOType *io, bool inHex) {
|
||||
lfs_file_t file;
|
||||
uint8_t res = ERR_OK;
|
||||
int32_t fileSize;
|
||||
int result;
|
||||
|
||||
if (io == NULL) {
|
||||
return ERR_FAILED; /* printing a file without an I/O channel does not make any sense */
|
||||
}
|
||||
if (!McuLFS_isMounted) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"ERROR: File system is not mounted.\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
result = lfs_file_open(&McuLFS_lfs, &file, filePath, LFS_O_RDONLY);
|
||||
if (result < 0) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"ERROR: Failed opening file.\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
fileSize = lfs_file_size(&McuLFS_lfs, &file);
|
||||
if (fileSize < 0) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"ERROR: getting file size\r\n", io->stdErr);
|
||||
(void) lfs_file_close(&McuLFS_lfs, &file);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
if (inHex) {
|
||||
res = McuShell_PrintMemory(&file, 0, fileSize-1, 4, 16, readFromFile, io);
|
||||
if (res != ERR_OK)
|
||||
{
|
||||
McuShell_SendStr((const uint8_t *)"ERROR while calling PrintMemory()\r\n", io->stdErr);
|
||||
}
|
||||
} else {
|
||||
uint8_t ch;
|
||||
|
||||
while(fileSize>0) {
|
||||
if (lfs_file_read(&McuLFS_lfs, &file, &ch, sizeof(ch)) < 0) {
|
||||
break; /* error case */
|
||||
}
|
||||
McuShell_SendCh(ch, io->stdOut); /* print character */
|
||||
fileSize--;
|
||||
}
|
||||
}
|
||||
(void) lfs_file_close(&McuLFS_lfs, &file);
|
||||
return res;
|
||||
}
|
||||
|
||||
static uint8_t McuLFS_CatBinaryTextDataToFile(const char *filePath, McuShell_ConstStdIOType *io, const unsigned char *p) {
|
||||
lfs_file_t file;
|
||||
int result;
|
||||
|
||||
if (io == NULL) {
|
||||
return ERR_FAILED; /* printing a file without an I/O channel does not make any sense */
|
||||
}
|
||||
if (!McuLFS_isMounted) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"ERROR: File system is not mounted.\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
result = lfs_file_open(&McuLFS_lfs, &file, filePath, LFS_O_RDWR | LFS_O_CREAT| LFS_O_APPEND);
|
||||
if (result < 0) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"ERROR: Failed opening file.\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
result = lfs_file_seek(&McuLFS_lfs, &file, 0, LFS_SEEK_END);
|
||||
if (result < 0) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"ERROR: Failed opening file.\r\n", io->stdErr);
|
||||
}
|
||||
(void)lfs_file_close(&McuLFS_lfs, &file);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
for(;;) { /* breaks */
|
||||
int32_t v;
|
||||
uint8_t ch, res;
|
||||
|
||||
res = McuUtility_xatoi(&p, &v);
|
||||
if (res!=ERR_OK) {
|
||||
break;
|
||||
}
|
||||
ch = v; /* just one byte */
|
||||
if (lfs_file_write(&McuLFS_lfs, &file, &ch, sizeof(ch)) < 0) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"ERROR: Failed writing to file.\r\n", io->stdErr);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
(void)lfs_file_close(&McuLFS_lfs, &file);
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
uint8_t McuLFS_RemoveFile(const char *filePath, McuShell_ConstStdIOType *io) {
|
||||
int result;
|
||||
|
||||
if (!McuLFS_isMounted) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"ERROR: File system is not mounted.\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
result = lfs_remove(&McuLFS_lfs, filePath);
|
||||
if (result < 0) {
|
||||
if (io != NULL) {
|
||||
McuShell_SendStr((const uint8_t *)"ERROR: Failed removing file.\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
lfs_t* McuLFS_GetFileSystem(void) {
|
||||
return &McuLFS_lfs;
|
||||
}
|
||||
|
||||
uint8_t McuLFS_RunBenchmark(const McuShell_ConstStdIOType *io) {
|
||||
lfs_file_t file;
|
||||
uint32_t i;
|
||||
uint8_t read_buf[10];
|
||||
TIMEREC time, startTime;
|
||||
int32_t start_mseconds, mseconds;
|
||||
|
||||
if (!McuLFS_isMounted) {
|
||||
if (io!=NULL) {
|
||||
McuShell_SendStr((const unsigned char*)"ERROR: File system is not mounted.\r\n", io->stdErr);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
/* write benchmark */
|
||||
McuShell_SendStr((const unsigned char*)"Benchmark: write/copy/read a 100kB file:\r\n", io->stdOut);
|
||||
McuShell_SendStr((const unsigned char*)"Delete existing benchmark files...\r\n", io->stdOut);
|
||||
(void)McuLFS_RemoveFile((const char*)"./bench.txt", io);
|
||||
(void)McuLFS_RemoveFile((const char*)"./copy.txt", io);
|
||||
|
||||
McuShell_SendStr((const unsigned char*)"Create benchmark file...\r\n", io->stdOut);
|
||||
(void)McuTimeDate_GetTime(&startTime);
|
||||
if (lfs_file_open(&McuLFS_lfs, &file, "./bench.txt", LFS_O_WRONLY | LFS_O_CREAT)<0) {
|
||||
McuShell_SendStr((const unsigned char*)"*** Failed creating benchmark file!\r\n", io->stdErr);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
for(i=0;i<10240;i++) {
|
||||
if (lfs_file_write(&McuLFS_lfs, &file, "benchmark ", sizeof("benchmark ")-1)<0) {
|
||||
McuShell_SendStr((const unsigned char*)"*** Failed writing file!\r\n", io->stdErr);
|
||||
(void)lfs_file_close(&McuLFS_lfs, &file);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
}
|
||||
(void)lfs_file_close(&McuLFS_lfs, &file);
|
||||
(void)McuTimeDate_GetTime(&time);
|
||||
start_mseconds = startTime.Hour*60*60*1000 + startTime.Min*60*1000 + startTime.Sec*1000
|
||||
#if TmDt1_HAS_SEC100_IN_TIMEREC
|
||||
+ startTime.Sec100*10
|
||||
#endif
|
||||
;
|
||||
mseconds = time.Hour*60*60*1000 + time.Min*60*1000 + time.Sec*1000
|
||||
#if TmDt1_HAS_SEC100_IN_TIMEREC
|
||||
+ time.Sec100*10
|
||||
#endif
|
||||
- start_mseconds;
|
||||
McuShell_SendNum32s(mseconds, io->stdOut);
|
||||
McuShell_SendStr((const unsigned char*)" ms for writing (", io->stdOut);
|
||||
McuShell_SendNum32s((100*1000)/mseconds, io->stdOut);
|
||||
McuShell_SendStr((const unsigned char*)" kB/s)\r\n", io->stdOut);
|
||||
|
||||
/* read benchmark */
|
||||
McuShell_SendStr((const unsigned char*)"Read 100kB benchmark file...\r\n", io->stdOut);
|
||||
(void)McuTimeDate_GetTime(&startTime);
|
||||
if (lfs_file_open(&McuLFS_lfs, &file, "./bench.txt", LFS_O_RDONLY)<0) {
|
||||
McuShell_SendStr((const unsigned char*)"*** Failed opening benchmark file!\r\n", io->stdErr);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
for(i=0;i<10240;i++) {
|
||||
if (lfs_file_read(&McuLFS_lfs, &file, &read_buf[0], sizeof(read_buf))<0) {
|
||||
McuShell_SendStr((const unsigned char*)"*** Failed reading file!\r\n", io->stdErr);
|
||||
(void)lfs_file_close(&McuLFS_lfs, &file);
|
||||
return ERR_FAILED;
|
||||
}
|
||||
}
|
||||
(void)lfs_file_close(&McuLFS_lfs, &file);
|
||||
(void)McuTimeDate_GetTime(&time);
|
||||
start_mseconds = startTime.Hour*60*60*1000 + startTime.Min*60*1000 + startTime.Sec*1000
|
||||
#if TmDt1_HAS_SEC100_IN_TIMEREC
|
||||
+ startTime.Sec100*10
|
||||
#endif
|
||||
;
|
||||
mseconds = time.Hour*60*60*1000 + time.Min*60*1000 + time.Sec*1000
|
||||
#if TmDt1_HAS_SEC100_IN_TIMEREC
|
||||
+ time.Sec100*10
|
||||
#endif
|
||||
- start_mseconds;
|
||||
McuShell_SendNum32s(mseconds, io->stdOut);
|
||||
McuShell_SendStr((const unsigned char*)" ms for reading (", io->stdOut);
|
||||
McuShell_SendNum32s((100*1000)/mseconds, io->stdOut);
|
||||
McuShell_SendStr((const unsigned char*)" kB/s)\r\n", io->stdOut);
|
||||
|
||||
/* copy benchmark */
|
||||
McuShell_SendStr((const unsigned char*)"Copy 100kB file...\r\n", io->stdOut);
|
||||
(void)McuTimeDate_GetTime(&startTime);
|
||||
(void)McuLFS_CopyFile((const char*)"./bench.txt", (const char*)"./copy.txt", io);
|
||||
(void)McuTimeDate_GetTime(&time);
|
||||
start_mseconds = startTime.Hour*60*60*1000 + startTime.Min*60*1000 + startTime.Sec*1000
|
||||
#if TmDt1_HAS_SEC100_IN_TIMEREC
|
||||
+ startTime.Sec100*10
|
||||
#endif
|
||||
;
|
||||
mseconds = time.Hour*60*60*1000 + time.Min*60*1000 + time.Sec*1000
|
||||
#if TmDt1_HAS_SEC100_IN_TIMEREC
|
||||
+ time.Sec100*10
|
||||
#endif
|
||||
- start_mseconds;
|
||||
McuShell_SendNum32s(mseconds, io->stdOut);
|
||||
McuShell_SendStr((const unsigned char*)" ms for copy (", io->stdOut);
|
||||
McuShell_SendNum32s((100*1000)/mseconds, io->stdOut);
|
||||
McuShell_SendStr((const unsigned char*)" kB/s)\r\n", io->stdOut);
|
||||
McuShell_SendStr((const unsigned char*)"done!\r\n", io->stdOut);
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
static uint8_t McuLFS_PrintStatus(McuShell_ConstStdIOType *io) {
|
||||
uint8_t buf[32];
|
||||
|
||||
McuShell_SendStatusStr((const unsigned char*) "McuLittleFS", (const unsigned char*) "McuLittleFS status\r\n", io->stdOut);
|
||||
|
||||
McuUtility_strcpy(buf, sizeof(buf), (const uint8_t *)"0x");
|
||||
McuUtility_strcatNum32Hex(buf, sizeof(buf), LFS_VERSION);
|
||||
McuUtility_strcat(buf, sizeof(buf), (const uint8_t *)", disk ");
|
||||
McuUtility_strcatNum32Hex(buf, sizeof(buf), LFS_DISK_VERSION);
|
||||
McuUtility_strcat(buf, sizeof(buf), (const uint8_t *)"\r\n");
|
||||
McuShell_SendStatusStr((const unsigned char*)" version", buf, io->stdOut);
|
||||
|
||||
#if McuLittleFSBlockDevice_CONFIG_MEMORY_TYPE==McuLittleFSBlockDevice_CONFIG_MEMORY_TYPE_GENERIC
|
||||
McuShell_SendStatusStr((const unsigned char*)" memory", (const unsigned char*)"Generic\r\n", io->stdOut);
|
||||
#elif McuLittleFSBlockDevice_CONFIG_MEMORY_TYPE==McuLittleFSBlockDevice_CONFIG_MEMORY_TYPE_WINBOND_W25Q128
|
||||
McuShell_SendStatusStr((const unsigned char*)" memory", (const unsigned char*)"Winbond W25Q128\r\n", io->stdOut);
|
||||
#elif McuLittleFSBlockDevice_CONFIG_MEMORY_TYPE==McuLittleFSBlockDevice_CONFIG_MEMORY_TYPE_MCU_FLASH
|
||||
McuShell_SendStatusStr((const unsigned char*)" memory", (const unsigned char*)"MCU Flash\r\n", io->stdOut);
|
||||
#else
|
||||
#error "unknown type"
|
||||
#endif
|
||||
|
||||
McuShell_SendStatusStr((const unsigned char*) " mounted", McuLFS_isMounted ? (const uint8_t *)"yes\r\n" : (const uint8_t *)"no\r\n", io->stdOut);
|
||||
|
||||
McuUtility_Num32uToStr(buf, sizeof(buf), McuLFS_cfg.block_size);
|
||||
McuUtility_strcat(buf, sizeof(buf), (const uint8_t *)"\r\n");
|
||||
McuShell_SendStatusStr((const unsigned char*)" block_size", buf, io->stdOut);
|
||||
|
||||
McuUtility_Num32uToStr(buf, sizeof(buf), McuLFS_cfg.block_count);
|
||||
McuUtility_strcat(buf, sizeof(buf), (const uint8_t *)"\r\n");
|
||||
McuShell_SendStatusStr((const unsigned char*)" block_count", buf, io->stdOut);
|
||||
|
||||
McuUtility_Num32uToStr(buf, sizeof(buf), McuLittleFS_CONFIG_BLOCK_OFFSET);
|
||||
McuUtility_strcat(buf, sizeof(buf), (const uint8_t *)"\r\n");
|
||||
McuShell_SendStatusStr((const unsigned char*)" blockoffset", buf, io->stdOut);
|
||||
|
||||
McuUtility_Num32uToStr(buf, sizeof(buf), McuLFS_cfg.block_count * McuLFS_cfg.block_size);
|
||||
McuUtility_strcat(buf, sizeof(buf), (const uint8_t *)" bytes\r\n");
|
||||
McuShell_SendStatusStr((const unsigned char*)" space", buf, io->stdOut);
|
||||
|
||||
McuUtility_Num32uToStr(buf, sizeof(buf), McuLFS_cfg.read_size);
|
||||
McuUtility_strcat(buf, sizeof(buf), (const uint8_t *)"\r\n");
|
||||
McuShell_SendStatusStr((const unsigned char*)" read_size", buf, io->stdOut);
|
||||
|
||||
McuUtility_Num32uToStr(buf, sizeof(buf), McuLFS_cfg.prog_size);
|
||||
McuUtility_strcat(buf, sizeof(buf), (const uint8_t *)"\r\n");
|
||||
McuShell_SendStatusStr((const unsigned char*)" prog_size", buf, io->stdOut);
|
||||
|
||||
McuUtility_Num32uToStr(buf, sizeof(buf), McuLFS_cfg.lookahead_size);
|
||||
McuUtility_strcat(buf, sizeof(buf), (const uint8_t *)"\r\n");
|
||||
McuShell_SendStatusStr((const unsigned char*)" lookahead", buf, io->stdOut);
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
uint8_t McuLFS_ParseCommand(const unsigned char* cmd, bool *handled,const McuShell_StdIOType *io) {
|
||||
unsigned char fileNameSrc[McuLittleFS_CONFIG_FILE_NAME_SIZE], fileNameDst[McuLittleFS_CONFIG_FILE_NAME_SIZE];
|
||||
size_t lenRead;
|
||||
const unsigned char *p;
|
||||
|
||||
if (McuUtility_strcmp((char*)cmd, McuShell_CMD_HELP) == 0|| McuUtility_strcmp((char*)cmd, "McuLittleFS help") == 0) {
|
||||
McuShell_SendHelpStr((unsigned char*) "McuLittleFS", (const unsigned char*) "Group of FileSystem (LittleFS) commands\r\n", io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " help|status", (const unsigned char*) "Print help or status information\r\n", io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " format",(const unsigned char*) "Format the file system\r\n",io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " mount",(const unsigned char*) "Mount the file system\r\n", io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " unmount",(const unsigned char*) "Unmount the file system\r\n", io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " ls",(const unsigned char*) "List directory and files of root\r\n", io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " ls <dir>",(const unsigned char*) "List directory and files of dir (ex. /Samples)\r\n", io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " rm <file>",(const unsigned char*) "Remove a file\r\n", io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " mv <src> <dst>",(const unsigned char*) "Rename a file\r\n", io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " cp <src> <dst>",(const unsigned char*) "Copy a file\r\n", io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " mkdir <dir>",(const unsigned char*) "Create a directory\r\n", io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " bincat <file> <data>",(const unsigned char*) "Add hex numbers as binary data to a file. If file does not exist, it gets created\r\n",io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " printhex <file>",(const unsigned char*) "Print the file data in hexadecimal format\r\n",io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " printtxt <file>",(const unsigned char*) "Print the file data in text format\r\n",io->stdOut);
|
||||
McuShell_SendHelpStr((unsigned char*) " benchmark",(const unsigned char*) "Run a benchmark to measure performance\r\n",io->stdOut);
|
||||
*handled = TRUE;
|
||||
return ERR_OK;
|
||||
} else if (McuUtility_strcmp((char*)cmd, McuShell_CMD_STATUS) == 0|| McuUtility_strcmp((char*)cmd, "McuLittleFS status") == 0) {
|
||||
*handled = TRUE;
|
||||
return McuLFS_PrintStatus(io);
|
||||
} else if (McuUtility_strcmp((char*)cmd, "McuLittleFS format") == 0) {
|
||||
*handled = TRUE;
|
||||
return McuLFS_Format(io);
|
||||
} else if (McuUtility_strcmp((char*)cmd, "McuLittleFS mount") == 0) {
|
||||
*handled = TRUE;
|
||||
return McuLFS_Mount(io);
|
||||
} else if (McuUtility_strcmp((char*)cmd, "McuLittleFS unmount") == 0) {
|
||||
*handled = TRUE;
|
||||
return McuLFS_Unmount(io);
|
||||
} else if (McuUtility_strcmp((char*)cmd, "McuLittleFS ls") == 0) {
|
||||
*handled = TRUE;
|
||||
return McuLFS_Dir(NULL, io);
|
||||
} else if (McuUtility_strncmp((char* )cmd, "McuLittleFS ls ", sizeof("McuLittleFS ls ") - 1) == 0) {
|
||||
*handled = TRUE;
|
||||
if ((McuUtility_ReadEscapedName(cmd + sizeof("McuLittleFS ls ") - 1,fileNameSrc, sizeof(fileNameSrc), &lenRead, NULL, NULL) == ERR_OK)) {
|
||||
return McuLFS_Dir((const char*)fileNameSrc, io);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
} else if (McuUtility_strcmp((char*)cmd, "McuLittleFS benchmark") == 0) {
|
||||
*handled = TRUE;
|
||||
return McuLFS_RunBenchmark(io);
|
||||
} else if (McuUtility_strncmp((char* )cmd, "McuLittleFS printhex ", sizeof("McuLittleFS printhex ") - 1) == 0) {
|
||||
*handled = TRUE;
|
||||
if ((McuUtility_ReadEscapedName(cmd + sizeof("McuLittleFS printhex ") - 1,fileNameSrc, sizeof(fileNameSrc), &lenRead, NULL, NULL) == ERR_OK)) {
|
||||
return McuLFS_PrintFile((const char*)fileNameSrc, io, TRUE);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
} else if (McuUtility_strncmp((char* )cmd, "McuLittleFS printtxt ", sizeof("McuLittleFS printtxt ") - 1) == 0) {
|
||||
*handled = TRUE;
|
||||
if ((McuUtility_ReadEscapedName(cmd + sizeof("McuLittleFS printtxt ") - 1,fileNameSrc, sizeof(fileNameSrc), &lenRead, NULL, NULL) == ERR_OK)) {
|
||||
return McuLFS_PrintFile((const char*)fileNameSrc, io, FALSE);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
} else if (McuUtility_strncmp((char*)cmd, "McuLittleFS rm ", sizeof("McuLittleFS rm ")-1) == 0) {
|
||||
*handled = TRUE;
|
||||
if ((McuUtility_ReadEscapedName(cmd + sizeof("McuLittleFS rm ") - 1, fileNameSrc, sizeof(fileNameSrc), &lenRead, NULL, NULL) == ERR_OK)) {
|
||||
return McuLFS_RemoveFile((const char*)fileNameSrc, io);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
} else if (McuUtility_strncmp((char*)cmd, "McuLittleFS mv ", sizeof("McuLittleFS mv ")-1) == 0) {
|
||||
*handled = TRUE;
|
||||
if ((McuUtility_ReadEscapedName(cmd + sizeof("McuLittleFS mv ") - 1, fileNameSrc, sizeof(fileNameSrc), &lenRead, NULL, NULL) == ERR_OK)
|
||||
&& *(cmd + sizeof("McuLittleFS mv ") - 1 + lenRead) == ' '
|
||||
&& (McuUtility_ReadEscapedName(cmd + sizeof("McuLittleFS mv ") - 1 + lenRead + 1, fileNameDst,sizeof(fileNameDst), NULL, NULL, NULL) == ERR_OK))
|
||||
{
|
||||
return McuLFS_MoveFile((const char*)fileNameSrc, (const char*)fileNameDst, io);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
} else if (McuUtility_strncmp((char*)cmd, "McuLittleFS cp ", sizeof("McuLittleFS cp ")-1) == 0) {
|
||||
*handled = TRUE;
|
||||
if ((McuUtility_ReadEscapedName(cmd + sizeof("McuLittleFS cp ") - 1, fileNameSrc, sizeof(fileNameSrc), &lenRead, NULL, NULL) == ERR_OK)
|
||||
&& *(cmd + sizeof("McuLittleFS cp ") - 1 + lenRead) == ' '
|
||||
&& (McuUtility_ReadEscapedName(cmd + sizeof("McuLittleFS cp ") - 1 + lenRead + 1, fileNameDst,sizeof(fileNameDst), NULL, NULL, NULL) == ERR_OK))
|
||||
{
|
||||
return McuLFS_CopyFile((const char*)fileNameSrc, (const char*)fileNameDst, io);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
} else if (McuUtility_strncmp((char*)cmd, "McuLittleFS bincat ", sizeof("McuLittleFS bincat ")-1) == 0) {
|
||||
*handled = TRUE;
|
||||
p = cmd + sizeof("McuLittleFS bincat ") - 1;
|
||||
if ((McuUtility_ReadEscapedName(p, fileNameSrc, sizeof(fileNameSrc), &lenRead, NULL, NULL) == ERR_OK)) {
|
||||
p += lenRead;
|
||||
return McuLFS_CatBinaryTextDataToFile((const char*)fileNameSrc, io, p);
|
||||
}
|
||||
return ERR_FAILED;
|
||||
} else if (McuUtility_strncmp((char*)cmd, "McuLittleFS mkdir ", sizeof("McuLittleFS mkdir ")-1) == 0) {
|
||||
*handled = TRUE;
|
||||
p = cmd + sizeof("McuLittleFS mkdir ") - 1;
|
||||
if ((McuUtility_ReadEscapedName(p, fileNameSrc, sizeof(fileNameSrc), &lenRead, NULL, NULL) == ERR_OK)) {
|
||||
if (lfs_mkdir(&McuLFS_lfs, (const char*)fileNameSrc)!=0) {
|
||||
return ERR_FAILED;
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
return ERR_FAILED;
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
#if LITTLEFS_CONFIG_THREAD_SAFE
|
||||
void McuLFS_GetFileAccessSemaphore(SemaphoreHandle_t *mutex) {
|
||||
*mutex = fileSystemAccessMutex;
|
||||
}
|
||||
#endif
|
||||
|
||||
void McuLFS_Deinit(void) {
|
||||
#if LITTLEFS_CONFIG_THREAD_SAFE
|
||||
vSemaphoreDelete(fileSystemAccessMutex);
|
||||
fileSystemAccessMutex = NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
void McuLFS_Init(void) {
|
||||
#if LITTLEFS_CONFIG_THREAD_SAFE
|
||||
fileSystemAccessMutex = xSemaphoreCreateRecursiveMutex();
|
||||
if (fileSystemAccessMutex == NULL) {
|
||||
for(;;) {} /* Error */
|
||||
}
|
||||
vQueueAddToRegistry(fileSystemAccessMutex, "littleFSmutex");
|
||||
xSemaphoreGiveRecursive(fileSystemAccessMutex);
|
||||
if (McuLittleFS_block_device_init() != ERR_OK) {
|
||||
for(;;) {} /* Error */
|
||||
}
|
||||
#endif
|
||||
}
|
||||
Reference in New Issue
Block a user