demo工程暂存 优化菜单界面UI和功能

MCU/components/modules/fatfs/documents/css_e.css

@@ -0,0 +1,70 @@
+* {margin: 0; padding: 0; border-width: 0;}
+body {margin: 8px; background-color: #e0ffff; font-color: black; font-family: serif; line-height: 133%; max-width: 1024px;}
+a:link {color: blue;}
+a:visited {color: darkmagenta;}
+a:hover {background-color: #a0ffff;}
+a:active {color: darkmagenta; overflow: hidden; outline:none; position: relative; top: 1px; left: 1px;}
+abbr {border-width: 1px;}
+
+p {margin: 0 0 0.3em 1em;}
+i {margin: 0 0.3em 0 0;}
+b {margin: 0 0.1em;}
+em {font-style: normal; font-weight: bold; margin: 0 0.1em;}
+strong {}
+pre {border: 1px dashed gray; margin: 0.5em 1em; padding: 0.5em; line-height: 1.2em; font-size: 85%; font-family: "Consolas", "Courier New", monospace; background-color: white;}
+pre span.c {color: green;}
+pre span.k {color: blue;}
+pre span.e {color: red;}
+pre span.b {font-weight: bold;}
+pre span.arg {font-style: italic;}
+tt {margin: 0 0.2em; font-size: 0.85em; font-family: "Consolas", "Courier New", monospace; }
+tt.arg {font-style: italic;}
+ol {margin: 0.5em 2.5em;}
+ul {margin: 0.5em 2em;}
+ul ul {margin: 0 2em 0.5em 1em;}
+dl {margin: 0.5em 1em;}
+dd {margin: 0 2em;}
+dt {font-size: 0.85em; font-family: "Consolas", "Courier New", monospace;}
+dl.par dt {margin: 0.5em 0 0 0 ; font-style: italic; }
+dl.ret dt {margin: 0.5em 0 0 0 ; font-size: 0.85em; font-family: "Consolas", "Courier New", monospace; font-weight: bold; }
+hr {border-width: 1px; margin: 1em;}
+div.abst {font-family: sans-serif;}
+div.para {clear: both; font-family: serif;}
+div.ret a {font-size: 0.85em; font-family: "Consolas", "Courier New", monospace; }
+.equ {text-indent: 0; margin: 1em 2em 1em;}
+.indent {margin-left: 2em;}
+.rset {float: right; margin: 0.3em 0 0.5em 0.5em;}
+.lset {float: left; margin: 0.3em 0.5em 0.5em 0.5em;}
+ul.flat li {list-style-type: none; margin: 0;}
+a.imglnk img {border: 1px solid;}
+.iequ {white-space: nowrap; font-weight: bold;}
+.clr {clear: both;}
+.it {font-style: italic;}
+.mfd {font-size: 0.7em; padding: 0 1px; border: 1px solid; white-space : nowrap}
+.ral {text-align: right; }
+.lal {text-align: left; }
+.cal {text-align: center; }
+
+h1 {line-height: 1em; font-size: 2em; font-family: sans-serif; padding: 0.3em 0 0.3em;}
+h2 {font-size: 2em; font-family: sans-serif; background-color: #d8d8FF; padding: 0.5em 0.5em; margin: 0 0 0.5em;}
+h3 {font-size: 1.5em; font-family: sans-serif; margin: 1.5em 0 0.5em;}
+div.doc h3 {border-color: #b0d8d8; border-style: solid; border-width: 0px 0px 4px 12px; padding: 4px; margin-top: 3em;}
+h4 {font-size: 1.2em; font-family: sans-serif; margin: 2em 0 0.2em;}
+h5 {font-size: 1em; font-family: sans-serif; margin: 1em 0 0em;}
+p.hdd {float: right; text-align: right; margin-top: 0.5em;}
+hr.hds {clear: both; margin-bottom: 1em;}
+kbd {letter-spacing: 0;}
+small {font-size: 80%;}
+.indent {margin-left: 2em;}
+
+/* Tables */
+table {margin: 0.5em 1em; border-collapse: collapse; border: 2px solid gray; }
+th {background-color: white; border-style: solid; border-width: 1px 1px 2px; border-color: gray; padding: 0 3px; vertical-align: top; white-space: nowrap;}
+td {background-color: white; border: 1px solid gray; padding: 0 3px; vertical-align: top; line-height: 1.3em;}
+table.lst td:first-child {font-size: 0.85em; font-family: "Consolas", "Courier New", monospace; white-space: nowrap;}
+table.lst2 td {font-size: 0.85em; font-family: "Consolas", "Courier New", monospace; white-space: nowrap;}
+table.lst3 td {font-family: "Consolas", "Courier New", monospace; white-space: nowrap;}
+table caption {font-family: sans-serif; font-weight: bold;}
+tr.lst3 td { border-width: 2px 1px 1px; }
+
+p.foot {clear: both; text-indent: 0; margin: 1em 0.5em 1em;}

MCU/components/modules/fatfs/documents/res/app1.c

@@ -0,0 +1,44 @@
+/*------------------------------------------------------------/
+/ Open or create a file in append mode
+/ (This function was sperseded by FA_OPEN_APPEND flag at FatFs R0.12a)
+/------------------------------------------------------------*/
+
+FRESULT open_append (
+    FIL* fp,            /* [OUT] File object to create */
+    const char* path    /* [IN]  File name to be opened */
+)
+{
+    FRESULT fr;
+
+    /* Opens an existing file. If not exist, creates a new file. */
+    fr = f_open(fp, path, FA_WRITE | FA_OPEN_ALWAYS);
+    if (fr == FR_OK) {
+        /* Seek to end of the file to append data */
+        fr = f_lseek(fp, f_size(fp));
+        if (fr != FR_OK)
+            f_close(fp);
+    }
+    return fr;
+}
+
+
+int main (void)
+{
+    FRESULT fr;
+    FATFS fs;
+    FIL fil;
+
+    /* Open or create a log file and ready to append */
+    f_mount(&fs, "", 0);
+    fr = open_append(&fil, "logfile.txt");
+    if (fr != FR_OK) return 1;
+
+    /* Append a line */
+    f_printf(&fil, "%02u/%02u/%u, %2u:%02u\n", Mday, Mon, Year, Hour, Min);
+
+    /* Close the file */
+    f_close(&fil);
+
+    return 0;
+}
+

MCU/components/modules/fatfs/documents/res/app2.c

@@ -0,0 +1,81 @@
+/*------------------------------------------------------------/
+/ Delete a sub-directory even if it contains any file
+/-------------------------------------------------------------/
+/ The delete_node() function is for R0.12+.
+/ It works regardless of FF_FS_RPATH.
+*/
+
+
+FRESULT delete_node (
+    TCHAR* path,    /* Path name buffer with the sub-directory to delete */
+    UINT sz_buff,   /* Size of path name buffer (items) */
+    FILINFO* fno    /* Name read buffer */
+)
+{
+    UINT i, j;
+    FRESULT fr;
+    DIR dir;
+
+
+    fr = f_opendir(&dir, path); /* Open the sub-directory to make it empty */
+    if (fr != FR_OK) return fr;
+
+    for (i = 0; path[i]; i++) ; /* Get current path length */
+    path[i++] = _T('/');
+
+    for (;;) {
+        fr = f_readdir(&dir, fno);  /* Get a directory item */
+        if (fr != FR_OK || !fno->fname[0]) break;   /* End of directory? */
+        j = 0;
+        do {    /* Make a path name */
+            if (i + j >= sz_buff) { /* Buffer over flow? */
+                fr = 100; break;    /* Fails with 100 when buffer overflow */
+            }
+            path[i + j] = fno->fname[j];
+        } while (fno->fname[j++]);
+        if (fno->fattrib & AM_DIR) {    /* Item is a sub-directory */
+            fr = delete_node(path, sz_buff, fno);
+        } else {                        /* Item is a file */
+            fr = f_unlink(path);
+        }
+        if (fr != FR_OK) break;
+    }
+
+    path[--i] = 0;  /* Restore the path name */
+    f_closedir(&dir);
+
+    if (fr == FR_OK) fr = f_unlink(path);  /* Delete the empty sub-directory */
+    return fr;
+}
+
+
+
+
+int main (void) /* How to use */
+{
+    FRESULT fr;
+    FATFS fs;
+    TCHAR buff[256];
+    FILINFO fno;
+
+
+    f_mount(&fs, _T("5:"), 0);
+
+    /* Directory to be deleted */
+    _tcscpy(buff, _T("5:dir"));
+
+    /* Delete the directory */
+    fr = delete_node(buff, sizeof buff / sizeof buff[0], &fno);
+
+    /* Check the result */
+    if (fr) {
+        _tprintf(_T("Failed to delete the directory. (%u)\n"), fr);
+        return fr;
+    } else {
+        _tprintf(_T("The directory and the contents have successfully been deleted.\n"), buff);
+        return 0;
+    }
+}
+
+
+

MCU/components/modules/fatfs/documents/res/app3.c

@@ -0,0 +1,109 @@
+/*----------------------------------------------------------------------/
+/ Allocate a contiguous area to the file
+/-----------------------------------------------------------------------/
+/ This function checks if the file is contiguous with desired size.
+/ If not, a block of contiguous sectors is allocated to the file.
+/ If the file has been opened without FA_WRITE flag, it only checks if
+/ the file is contiguous and returns the resulut.
+/-----------------------------------------------------------------------/
+/ This function can work with FatFs R0.09 - R0.11a.
+/ It is incompatible with R0.12+. Use f_expand function instead.
+/----------------------------------------------------------------------*/
+
+/* Declarations of FatFs internal functions accessible from applications.
+/  This is intended to be used for disk checking/fixing or dirty hacks :-) */
+DWORD clust2sect (FATFS* fs, DWORD clst);
+DWORD get_fat (FATFS* fs, DWORD clst);
+FRESULT put_fat (FATFS* fs, DWORD clst, DWORD val);
+
+
+DWORD allocate_contiguous_clusters (    /* Returns the first sector in LBA (0:error or not contiguous) */
+    FIL* fp,    /* Pointer to the open file object */
+    DWORD len   /* Number of bytes to allocate */
+)
+{
+    DWORD csz, tcl, ncl, ccl, cl;
+
+
+    if (f_lseek(fp, 0) || !len)     /* Check if the given parameters are valid */
+        return 0;
+    csz = 512UL * fp->fs->csize;    /* Cluster size in unit of byte (assuming 512 bytes/sector) */
+    tcl = (len + csz - 1) / csz;    /* Total number of clusters required */
+    len = tcl * csz;                /* Round-up file size to the cluster boundary */
+
+    /* Check if the existing cluster chain is contiguous */
+    if (len == fp->fsize) {
+        ncl = 0; ccl = fp->sclust;
+        do {
+            cl = get_fat(fp->fs, ccl);  /* Get the cluster status */
+            if (cl + 1 < 3) return 0;   /* Hard error? */
+            if (cl != ccl + 1 && cl < fp->fs->n_fatent) break;  /* Not contiguous? */
+            ccl = cl;
+        } while (++ncl < tcl);
+        if (ncl == tcl)             /* Is the file contiguous? */
+            return clust2sect(fp->fs, fp->sclust);  /* File is contiguous. Return the start sector */
+    }
+
+    /* File is not contiguous */
+#if _FS_READONLY
+    return 0;								/* Exit if in read-only cfg. */
+#else
+    if (!(fp->flag & FA_WRITE)) return 0;   /* Exit if the file object is for read-only */
+
+    if (f_truncate(fp)) return 0;           /* Remove the non-contiguous chain */
+
+    /* Find a free contiguous area */
+    ccl = cl = 2; ncl = 0;
+    do {
+        if (cl >= fp->fs->n_fatent) return 0;   /* No contiguous area is found. */
+        if (get_fat(fp->fs, cl)) {  /* Encounterd a cluster in use */
+            do {    /* Skip the block of used clusters */
+                cl++;
+                if (cl >= fp->fs->n_fatent) return 0;   /* No contiguous area is found. */
+            } while (get_fat(fp->fs, cl));
+            ccl = cl; ncl = 0;
+        }
+        cl++; ncl++;
+    } while (ncl < tcl);
+
+    /* Create a contiguous cluster chain */
+    fp->fs->last_clust = ccl - 1;
+    if (f_lseek(fp, len)) return 0;
+
+    return clust2sect(fp->fs, fp->sclust);  /* Return file start sector */
+#endif
+}
+
+
+int main (void)
+{
+    FRESULT fr;
+    DRESULT dr;
+    FATFS fs;
+    FIL fil;
+    DWORD org;
+
+
+    /* Open or create a file to write */
+    f_mount(&fs, "", 0);
+    fr = f_open(&fil, "fastrec.log", FA_READ | FA_WRITE | FA_OPEN_ALWAYS);
+    if (fr) return 1;
+
+    /* Check if the file is 256MB in size and occupies a contiguous area.
+    /  If not, a contiguous area will be re-allocated to the file. */
+    org = allocate_contiguous_clusters(&fil, 0x10000000);
+    if (!org) {
+        printf("Function failed due to any error or insufficient contiguous area.\n");
+        f_close(&fil);
+        return 1;
+    }
+
+    /* Now you can read/write the file without filesystem layer. */
+    ...
+    dr = disk_write(fil.fs->drv, Buff, org, 1024);   /* Write 512KiB from top of the file */
+    ...
+
+    f_close(&fil);
+    return 0;
+}
+

MCU/components/modules/fatfs/documents/res/app4.c

@@ -0,0 +1,315 @@
+/*----------------------------------------------------------------------/
+/ Low level disk I/O module function checker                            /
+/-----------------------------------------------------------------------/
+/ WARNING: The data on the target drive will be lost!
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include "ff.h"         /* Declarations of sector size */
+#include "diskio.h"     /* Declarations of disk functions */
+
+
+
+static DWORD pn (       /* Pseudo random number generator */
+    DWORD pns   /* 0:Initialize, !0:Read */
+)
+{
+    static DWORD lfsr;
+    UINT n;
+
+
+    if (pns) {
+        lfsr = pns;
+        for (n = 0; n < 32; n++) pn(0);
+    }
+    if (lfsr & 1) {
+        lfsr >>= 1;
+        lfsr ^= 0x80200003;
+    } else {
+        lfsr >>= 1;
+    }
+    return lfsr;
+}
+
+
+int test_diskio (
+    BYTE pdrv,      /* Physical drive number to be checked (all data on the drive will be lost) */
+    UINT ncyc,      /* Number of test cycles */
+    DWORD* buff,    /* Pointer to the working buffer */
+    UINT sz_buff    /* Size of the working buffer in unit of byte */
+)
+{
+    UINT n, cc, ns;
+    DWORD sz_drv, lba, lba2, sz_eblk, pns = 1;
+    WORD sz_sect;
+    BYTE *pbuff = (BYTE*)buff;
+    DSTATUS ds;
+    DRESULT dr;
+
+
+    printf("test_diskio(%u, %u, 0x%08X, 0x%08X)\n", pdrv, ncyc, (UINT)buff, sz_buff);
+
+    if (sz_buff < FF_MAX_SS + 8) {
+        printf("Insufficient work area to run the program.\n");
+        return 1;
+    }
+
+    for (cc = 1; cc <= ncyc; cc++) {
+        printf("**** Test cycle %u of %u start ****\n", cc, ncyc);
+
+        printf(" disk_initalize(%u)", pdrv);
+        ds = disk_initialize(pdrv);
+        if (ds & STA_NOINIT) {
+            printf(" - failed.\n");
+            return 2;
+        } else {
+            printf(" - ok.\n");
+        }
+
+        printf("**** Get drive size ****\n");
+        printf(" disk_ioctl(%u, GET_SECTOR_COUNT, 0x%08X)", pdrv, (UINT)&sz_drv);
+        sz_drv = 0;
+        dr = disk_ioctl(pdrv, GET_SECTOR_COUNT, &sz_drv);
+        if (dr == RES_OK) {
+            printf(" - ok.\n");
+        } else {
+            printf(" - failed.\n");
+            return 3;
+        }
+        if (sz_drv < 128) {
+            printf("Failed: Insufficient drive size to test.\n");
+            return 4;
+        }
+        printf(" Number of sectors on the drive %u is %lu.\n", pdrv, sz_drv);
+
+#if FF_MAX_SS != FF_MIN_SS
+        printf("**** Get sector size ****\n");
+        printf(" disk_ioctl(%u, GET_SECTOR_SIZE, 0x%X)", pdrv, (UINT)&sz_sect);
+        sz_sect = 0;
+        dr = disk_ioctl(pdrv, GET_SECTOR_SIZE, &sz_sect);
+        if (dr == RES_OK) {
+            printf(" - ok.\n");
+        } else {
+            printf(" - failed.\n");
+            return 5;
+        }
+        printf(" Size of sector is %u bytes.\n", sz_sect);
+#else
+        sz_sect = FF_MAX_SS;
+#endif
+
+        printf("**** Get block size ****\n");
+        printf(" disk_ioctl(%u, GET_BLOCK_SIZE, 0x%X)", pdrv, (UINT)&sz_eblk);
+        sz_eblk = 0;
+        dr = disk_ioctl(pdrv, GET_BLOCK_SIZE, &sz_eblk);
+        if (dr == RES_OK) {
+            printf(" - ok.\n");
+        } else {
+            printf(" - failed.\n");
+        }
+        if (dr == RES_OK || sz_eblk >= 2) {
+            printf(" Size of the erase block is %lu sectors.\n", sz_eblk);
+        } else {
+            printf(" Size of the erase block is unknown.\n");
+        }
+
+        /* Single sector write test */
+        printf("**** Single sector write test ****\n");
+        lba = 0;
+        for (n = 0, pn(pns); n < sz_sect; n++) pbuff[n] = (BYTE)pn(0);
+        printf(" disk_write(%u, 0x%X, %lu, 1)", pdrv, (UINT)pbuff, lba);
+        dr = disk_write(pdrv, pbuff, lba, 1);
+        if (dr == RES_OK) {
+            printf(" - ok.\n");
+        } else {
+            printf(" - failed.\n");
+            return 6;
+        }
+        printf(" disk_ioctl(%u, CTRL_SYNC, NULL)", pdrv);
+        dr = disk_ioctl(pdrv, CTRL_SYNC, 0);
+        if (dr == RES_OK) {
+            printf(" - ok.\n");
+        } else {
+            printf(" - failed.\n");
+            return 7;
+        }
+        memset(pbuff, 0, sz_sect);
+        printf(" disk_read(%u, 0x%X, %lu, 1)", pdrv, (UINT)pbuff, lba);
+        dr = disk_read(pdrv, pbuff, lba, 1);
+        if (dr == RES_OK) {
+            printf(" - ok.\n");
+        } else {
+            printf(" - failed.\n");
+            return 8;
+        }
+        for (n = 0, pn(pns); n < sz_sect && pbuff[n] == (BYTE)pn(0); n++) ;
+        if (n == sz_sect) {
+            printf(" Read data matched.\n");
+        } else {
+            printf(" Read data differs from the data written.\n");
+            return 10;
+        }
+        pns++;
+
+        printf("**** Multiple sector write test ****\n");
+        lba = 5; ns = sz_buff / sz_sect;
+        if (ns > 4) ns = 4;
+        if (ns > 1) {
+            for (n = 0, pn(pns); n < (UINT)(sz_sect * ns); n++) pbuff[n] = (BYTE)pn(0);
+            printf(" disk_write(%u, 0x%X, %lu, %u)", pdrv, (UINT)pbuff, lba, ns);
+            dr = disk_write(pdrv, pbuff, lba, ns);
+            if (dr == RES_OK) {
+                printf(" - ok.\n");
+            } else {
+                printf(" - failed.\n");
+                return 11;
+            }
+            printf(" disk_ioctl(%u, CTRL_SYNC, NULL)", pdrv);
+            dr = disk_ioctl(pdrv, CTRL_SYNC, 0);
+            if (dr == RES_OK) {
+                printf(" - ok.\n");
+            } else {
+                printf(" - failed.\n");
+                return 12;
+            }
+            memset(pbuff, 0, sz_sect * ns);
+            printf(" disk_read(%u, 0x%X, %lu, %u)", pdrv, (UINT)pbuff, lba, ns);
+            dr = disk_read(pdrv, pbuff, lba, ns);
+            if (dr == RES_OK) {
+                printf(" - ok.\n");
+            } else {
+                printf(" - failed.\n");
+                return 13;
+            }
+            for (n = 0, pn(pns); n < (UINT)(sz_sect * ns) && pbuff[n] == (BYTE)pn(0); n++) ;
+            if (n == (UINT)(sz_sect * ns)) {
+                printf(" Read data matched.\n");
+            } else {
+                printf(" Read data differs from the data written.\n");
+                return 14;
+            }
+        } else {
+            printf(" Test skipped.\n");
+        }
+        pns++;
+
+        printf("**** Single sector write test (unaligned buffer address) ****\n");
+        lba = 5;
+        for (n = 0, pn(pns); n < sz_sect; n++) pbuff[n+3] = (BYTE)pn(0);
+        printf(" disk_write(%u, 0x%X, %lu, 1)", pdrv, (UINT)(pbuff+3), lba);
+        dr = disk_write(pdrv, pbuff+3, lba, 1);
+        if (dr == RES_OK) {
+            printf(" - ok.\n");
+        } else {
+            printf(" - failed.\n");
+            return 15;
+        }
+        printf(" disk_ioctl(%u, CTRL_SYNC, NULL)", pdrv);
+        dr = disk_ioctl(pdrv, CTRL_SYNC, 0);
+        if (dr == RES_OK) {
+            printf(" - ok.\n");
+        } else {
+            printf(" - failed.\n");
+            return 16;
+        }
+        memset(pbuff+5, 0, sz_sect);
+        printf(" disk_read(%u, 0x%X, %lu, 1)", pdrv, (UINT)(pbuff+5), lba);
+        dr = disk_read(pdrv, pbuff+5, lba, 1);
+        if (dr == RES_OK) {
+            printf(" - ok.\n");
+        } else {
+            printf(" - failed.\n");
+            return 17;
+        }
+        for (n = 0, pn(pns); n < sz_sect && pbuff[n+5] == (BYTE)pn(0); n++) ;
+        if (n == sz_sect) {
+            printf(" Read data matched.\n");
+        } else {
+            printf(" Read data differs from the data written.\n");
+            return 18;
+        }
+        pns++;
+
+        printf("**** 4GB barrier test ****\n");
+        if (sz_drv >= 128 + 0x80000000 / (sz_sect / 2)) {
+            lba = 6; lba2 = lba + 0x80000000 / (sz_sect / 2);
+            for (n = 0, pn(pns); n < (UINT)(sz_sect * 2); n++) pbuff[n] = (BYTE)pn(0);
+            printf(" disk_write(%u, 0x%X, %lu, 1)", pdrv, (UINT)pbuff, lba);
+            dr = disk_write(pdrv, pbuff, lba, 1);
+            if (dr == RES_OK) {
+                printf(" - ok.\n");
+            } else {
+                printf(" - failed.\n");
+                return 19;
+            }
+            printf(" disk_write(%u, 0x%X, %lu, 1)", pdrv, (UINT)(pbuff+sz_sect), lba2);
+            dr = disk_write(pdrv, pbuff+sz_sect, lba2, 1);
+            if (dr == RES_OK) {
+                printf(" - ok.\n");
+            } else {
+                printf(" - failed.\n");
+                return 20;
+            }
+            printf(" disk_ioctl(%u, CTRL_SYNC, NULL)", pdrv);
+            dr = disk_ioctl(pdrv, CTRL_SYNC, 0);
+            if (dr == RES_OK) {
+            printf(" - ok.\n");
+            } else {
+                printf(" - failed.\n");
+                return 21;
+            }
+            memset(pbuff, 0, sz_sect * 2);
+            printf(" disk_read(%u, 0x%X, %lu, 1)", pdrv, (UINT)pbuff, lba);
+            dr = disk_read(pdrv, pbuff, lba, 1);
+            if (dr == RES_OK) {
+                printf(" - ok.\n");
+            } else {
+                printf(" - failed.\n");
+                return 22;
+            }
+            printf(" disk_read(%u, 0x%X, %lu, 1)", pdrv, (UINT)(pbuff+sz_sect), lba2);
+            dr = disk_read(pdrv, pbuff+sz_sect, lba2, 1);
+            if (dr == RES_OK) {
+                printf(" - ok.\n");
+            } else {
+                printf(" - failed.\n");
+                return 23;
+            }
+            for (n = 0, pn(pns); pbuff[n] == (BYTE)pn(0) && n < (UINT)(sz_sect * 2); n++) ;
+            if (n == (UINT)(sz_sect * 2)) {
+                printf(" Read data matched.\n");
+            } else {
+                printf(" Read data differs from the data written.\n");
+                return 24;
+            }
+        } else {
+            printf(" Test skipped.\n");
+        }
+        pns++;
+
+        printf("**** Test cycle %u of %u completed ****\n\n", cc, ncyc);
+    }
+
+    return 0;
+}
+
+
+
+int main (int argc, char* argv[])
+{
+    int rc;
+    DWORD buff[FF_MAX_SS];  /* Working buffer (4 sector in size) */
+
+    /* Check function/compatibility of the physical drive #0 */
+    rc = test_diskio(0, 3, buff, sizeof buff);
+
+    if (rc) {
+        printf("Sorry the function/compatibility test failed. (rc=%d)\nFatFs will not work with this disk driver.\n", rc);
+    } else {
+        printf("Congratulations! The disk driver works well.\n");
+    }
+
+    return rc;
+}
+

MCU/components/modules/fatfs/documents/res/app5.c

@@ -0,0 +1,38 @@
+/*----------------------------------------------------------------------/
+/ Test if the file is contiguous                                        /
+/----------------------------------------------------------------------*/
+
+FRESULT test_contiguous_file (
+    FIL* fp,    /* [IN]  Open file object to be checked */
+    int* cont   /* [OUT] 1:Contiguous, 0:Fragmented or zero-length */
+)
+{
+    DWORD clst, clsz, step;
+    FSIZE_t fsz;
+    FRESULT fr;
+
+
+    *cont = 0;
+    fr = f_lseek(fp, 0);            /* Validates and prepares the file */
+    if (fr != FR_OK) return fr;
+
+#if FF_MAX_SS == FF_MIN_SS
+    clsz = (DWORD)fp->obj.fs->csize * FF_MAX_SS;    /* Cluster size */
+#else
+    clsz = (DWORD)fp->obj.fs->csize * fp->obj.fs->ssize;
+#endif
+    fsz = f_size(fp);
+    if (fsz > 0) {
+        clst = fp->obj.sclust - 1;  /* A cluster leading the first cluster for first test */
+        while (fsz) {
+            step = (fsz >= clsz) ? clsz : (DWORD)fsz;
+            fr = f_lseek(fp, f_tell(fp) + step);    /* Advances file pointer a cluster */
+            if (fr != FR_OK) return fr;
+            if (clst + 1 != fp->clust) break;       /* Is not the cluster next to previous one? */
+            clst = fp->clust; fsz -= step;          /* Get current cluster for next test */
+        }
+        if (fsz == 0) *cont = 1;    /* All done without fail? */
+    }
+
+    return FR_OK;
+}

MCU/components/modules/fatfs/documents/res/app6.c

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------*/
+/* Raw Read/Write Throughput Checker                                   */
+/*---------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <systimer.h>
+#include "diskio.h"
+#include "ff.h"
+
+
+int test_raw_speed (
+    BYTE pdrv,      /* Physical drive number */
+    DWORD lba,      /* Start LBA for read/write test */
+    DWORD len,      /* Number of bytes to read/write (must be multiple of sz_buff) */
+    void* buff,     /* Read/write buffer */
+    UINT sz_buff    /* Size of read/write buffer (must be multiple of FF_MAX_SS) */
+)
+{
+    WORD ss;
+    DWORD ofs, tmr;
+
+
+#if FF_MIN_SS != FF_MAX_SS
+    if (disk_ioctl(pdrv, GET_SECTOR_SIZE, &ss) != RES_OK) {
+        printf("\ndisk_ioctl() failed.\n");
+        return 0;
+    }
+#else
+    ss = FF_MAX_SS;
+#endif
+
+    printf("Starting raw write test at sector %lu in %u bytes of data chunks...", lba, sz_buff);
+    tmr = systimer();
+    for (ofs = 0; ofs < len / ss; ofs += sz_buff / ss) {
+        if (disk_write(pdrv, buff, lba + ofs, sz_buff / ss) != RES_OK) {
+            printf("\ndisk_write() failed.\n");
+            return 0;
+        }
+    }
+    if (disk_ioctl(pdrv, CTRL_SYNC, 0) != RES_OK) {
+        printf("\ndisk_ioctl() failed.\n");
+        return 0;
+    }
+    tmr = systimer() - tmr;
+    printf("\n%lu bytes written and it took %lu timer ticks.\n", len, tmr);
+
+    printf("Starting raw read test at sector %lu in %u bytes of data chunks...", lba, sz_buff);
+    tmr = systimer();
+    for (ofs = 0; ofs < len / ss; ofs += sz_buff / ss) {
+        if (disk_read(pdrv, buff, lba + ofs, sz_buff / ss) != RES_OK) {
+            printf("\ndisk_read() failed.\n");
+            return 0;
+        }
+    }
+    tmr = systimer() - tmr;
+    printf("\n%lu bytes read and it took %lu timer ticks.\n", len, tmr);
+
+    printf("Test completed.\n");
+    return 1;
+}
+

MCU/components/modules/fatfs/documents/updates.txt

@@ -0,0 +1,286 @@
+R0.14b (April 17, 2021)
+  Made FatFs uses standard library <string.h> for copy, compare and search instead of built-in string functions.
+  Added support for long long integer and floating point to f_printf(). (FF_STRF_LLI and FF_STRF_FP)
+  Made path name parser ignore the terminating separator to allow "dir/".
+  Improved the compatibility in Unix style path name feature.
+  Fixed the file gets dead-locked when f_open() failed with some conditions. (appeared at R0.12a)
+  Fixed f_mkfs() can create wrong exFAT volume due to a timing dependent error. (appeared at R0.12)
+  Fixed code page 855 cannot be set by f_setcp().
+  Fixed some compiler warnings.
+
+
+R0.14a (December 05, 2020)
+  Limited number of recursive calls in f_findnext().
+  Fixed old floppy disks formatted with MS-DOS 2.x and 3.x cannot be mounted.
+  Fixed some compiler warnings.
+
+
+R0.14 (October 14, 2019)
+  Added support for 64-bit LBA and GUID partition table (FF_LBA64)
+  Changed some API functions, f_mkfs() and f_fdisk().
+  Fixed f_open() function cannot find the file with file name in length of FF_MAX_LFN characters.
+  Fixed f_readdir() function cannot retrieve long file names in length of FF_MAX_LFN - 1 characters.
+  Fixed f_readdir() function returns file names with wrong case conversion. (appeared at R0.12)
+  Fixed f_mkfs() function can fail to create exFAT volume in the second partition. (appeared at R0.12)
+
+R0.13c (October 14, 2018)
+  Supported stdint.h for C99 and later. (integer.h was included in ff.h)
+  Fixed reading a directory gets infinite loop when the last directory entry is not empty. (appeared at R0.12)
+  Fixed creating a sub-directory in the fragmented sub-directory on the exFAT volume collapses FAT chain of the parent directory. (appeared at R0.12)
+  Fixed f_getcwd() cause output buffer overrun when the buffer has a valid drive number. (appeared at R0.13b)
+
+
+R0.13b (April 07, 2018)
+  Added support for UTF-32 encoding on the API. (FF_LFN_UNICODE = 3)
+  Added support for Unix style volume prefix. (FF_STR_VOLUME_ID = 2)
+  Fixed accesing any object on the exFAT root directory beyond the cluster boundary can fail. (appeared at R0.12c)
+  Fixed f_setlabel() does not reject some invalid characters. (appeared at R0.09b)
+
+
+R0.13a (October 14, 2017)
+  Added support for UTF-8 encoding on the API. (FF_LFN_UNICODE = 2)
+  Added options for file name output buffer. (FF_LFN_BUF, FF_SFN_BUF).
+  Added dynamic memory allocation option for working buffer of f_mkfs() and f_fdisk().
+  Fixed f_fdisk() and f_mkfs() create the partition table with wrong CHS parameters. (appeared at R0.09)
+  Fixed f_unlink() can cause lost clusters at fragmented file on the exFAT volume. (appeared at R0.12c)
+  Fixed f_setlabel() rejects some valid characters for exFAT volume. (appeared at R0.12)
+
+
+R0.13 (May 21, 2017)
+  Changed heading character of configuration keywords "_" to "FF_".
+  Removed ASCII-only configuration, FF_CODE_PAGE = 1. Use FF_CODE_PAGE = 437 instead.
+  Added f_setcp(), run-time code page configuration. (FF_CODE_PAGE = 0)
+  Improved cluster allocation time on stretch a deep buried cluster chain.
+  Improved processing time of f_mkdir() with large cluster size by using FF_USE_LFN = 3.
+  Improved NoFatChain flag of the fragmented file to be set after it is truncated and got contiguous.
+  Fixed archive attribute is left not set when a file on the exFAT volume is renamed. (appeared at R0.12)
+  Fixed exFAT FAT entry can be collapsed when write or lseek operation to the existing file is done. (appeared at R0.12c)
+  Fixed creating a file can fail when a new cluster allocation to the exFAT directory occures. (appeared at R0.12c)
+
+
+R0.12c (March 04, 2017)
+  Improved write throughput at the fragmented file on the exFAT volume.
+  Made memory usage for exFAT be able to be reduced as decreasing _MAX_LFN.
+  Fixed successive f_getfree() can return wrong count on the FAT12/16 volume. (appeared at R0.12)
+  Fixed configuration option _VOLUMES cannot be set 10. (appeared at R0.10c)
+
+
+R0.12b (September 4, 2016)
+  Made f_rename() be able to rename objects with the same name but case.
+  Fixed an error in the case conversion teble of code page 866. (ff.c)
+  Fixed writing data is truncated at the file offset 4GiB on the exFAT volume. (appeared at R0.12)
+  Fixed creating a file in the root directory of exFAT volume can fail. (appeared at R0.12)
+  Fixed f_mkfs() creating exFAT volume with too small cluster size can collapse unallocated memory. (appeared at R0.12a)
+  Fixed wrong object name can be returned when read directory at Unicode cfg. (appeared at R0.12)
+  Fixed large file allocation/removing on the exFAT volume collapses allocation bitmap. (appeared at R0.12)
+  Fixed some internal errors in f_expand() and f_lseek(). (appeared at R0.12)
+
+
+R0.12a (July 10, 2016)
+  Added support for creating exFAT volume with some changes of f_mkfs().
+  Added a file open method FA_OPEN_APPEND. An f_lseek() following f_open() is no longer needed.
+  f_forward() is available regardless of _FS_TINY.
+  Fixed f_mkfs() creates wrong volume. (appeared at R0.12)
+  Fixed wrong memory read in create_name(). (appeared at R0.12)
+  Fixed compilation fails at some configurations, _USE_FASTSEEK and _USE_FORWARD.
+
+
+R0.12 (April 12, 2016)
+  Added support for exFAT file system. (_FS_EXFAT)
+  Added f_expand(). (_USE_EXPAND)
+  Changed some members in FINFO structure and behavior of f_readdir().
+  Added an option _USE_CHMOD and removed an option _WORD_ACCESS.
+  Fixed errors in the case conversion teble of Unicode (cc*.c).
+
+
+R0.11a (September 5, 2015)
+  Fixed wrong media change can lead a deadlock at thread-safe configuration.
+  Added code page 771, 860, 861, 863, 864, 865 and 869. (_CODE_PAGE)
+  Removed some code pages actually not exist on the standard systems. (_CODE_PAGE)
+  Fixed errors in the case conversion teble of code page 437 and 850 (ff.c).
+  Fixed errors in the case conversion teble of Unicode (cc*.c).
+
+
+R0.11 (February 9, 2015)
+  Added f_findfirst() and f_findnext(). (_USE_FIND)
+  Fixed f_unlink() does not remove cluster chain of the file. (appeared at R0.10c)
+  Fixed _FS_NORTC option does not work properly. (appeared at R0.10c)
+
+
+R0.10c (November 9, 2014)
+  Added a configuration option for the platforms without RTC. (_FS_NORTC)
+  Fixed volume label created by Mac OS X cannot be retrieved with f_getlabel(). (appeared at R0.09b)
+  Fixed a potential problem of FAT access that can appear on disk error.
+  Fixed null pointer dereference on attempting to delete the root direcotry. (appeared at R0.08)
+
+
+R0.10b (May 19, 2014)
+  Fixed a hard error in the disk I/O layer can collapse the directory entry.
+  Fixed LFN entry is not deleted on delete/rename an object with its lossy converted SFN. (appeared at R0.07)
+
+
+R0.10a (January 15, 2014)
+  Added arbitrary strings as drive number in the path name. (_STR_VOLUME_ID)
+  Added an option for minimum sector size. (_MIN_SS)
+  2nd argument of f_rename() can have a drive number and it will be ignored.
+  Fixed f_mount() with forced mount fails when drive number is larger than 0. (appeared at R0.10)
+  Fixed f_close() invalidates the file object without volume lock.
+  Fixed volume lock is left acquired after return from f_closedir(). (appeared at R0.10)
+  Fixed creation of a directory entry with LFN fails on too many SFN collisions. (appeared at R0.07)
+
+
+R0.10 (October 2, 2013)
+  Added an option for character encoding on the file. (_STRF_ENCODE)
+  Added f_closedir().
+  Added forced full FAT scan option for f_getfree(). (_FS_NOFSINFO)
+  Added forced mount option with changes of f_mount().
+  Improved behavior of volume auto detection.
+  Improved write throughput of f_puts() and f_printf().
+  Changed argument of f_chdrive(), f_mkfs(), disk_read() and disk_write().
+  Fixed f_write() can be truncated when the file size is close to 4GB.
+  Fixed f_open(), f_mkdir() and f_setlabel() can return incorrect result code on error.
+
+
+R0.09b (January 24, 2013)
+  Added f_getlabel() and f_setlabel(). (_USE_LABEL = 1)
+
+
+R0.09a (August 27, 2012)
+  Fixed assertion failure due to OS/2 EA on FAT12/16 volume.
+  Changed file functions reject null object pointer to avoid crash.
+  Changed option name _FS_SHARE to _FS_LOCK.
+
+
+R0.09 (September 6, 2011)
+  f_mkfs() supports multiple partition on a physical drive.
+  Added f_fdisk(). (_MULTI_PARTITION = 2)
+
+
+R0.08b (January 15, 2011)
+  Fast seek function is also applied to f_read() and f_write().
+  f_lseek() reports required table size on creating CLMP.
+  Extended format syntax of f_printf().
+  Ignores duplicated directory separators in given path names.
+
+
+R0.08a (August 16, 2010)
+  Added f_getcwd(). (_FS_RPATH = 2)
+  Added sector erase function. (_USE_ERASE)
+  Moved file lock semaphore table from fs object to the bss.
+  Fixed a wrong directory entry is created on non-LFN cfg when the given name contains ';'.
+  Fixed f_mkfs() creates wrong FAT32 volume.
+
+
+R0.08 (May 15, 2010)
+  Added a memory configuration option. (_USE_LFN)
+  Added support of file lock. (_FS_SHARE)
+  Added fast seek function. (_USE_FASTSEEK)
+  Changed some types on the API, XCHAR->TCHAR.
+  Changed fname member in the FILINFO structure on Unicode cfg.
+  String functions support UTF-8 encoding files on Unicode cfg.
+
+
+R0.07e (November 3, 2009)
+  Separated out configuration options from ff.h to ffconf.h.
+  Added a configuration option, _LFN_UNICODE.
+  Fixed f_unlink() fails to remove a sub-dir on _FS_RPATH.
+  Fixed name matching error on the 13 char boundary.
+  Changed f_readdir() to return the SFN with always upper case on non-LFN cfg.
+
+
+R0.07c (Junuary 21, 2009)
+  Fixed f_unlink() may return FR_OK on error.
+  Fixed wrong cache control in f_lseek().
+  Added support of relative path.
+  Added f_chdir().
+  Added f_chdrive().
+  Added proper case conversion to extended characters.
+
+
+R0.07a (April 14, 2009)
+  Separated out OS dependent code on re-entrant configuration.
+  Added multiple sector size support.
+
+
+R0.07 (April 1, 2009)
+  Merged Tiny-FatFs into FatFs as a buffer configuration option.
+  Added long file name support.
+  Added multiple code page support.
+  Added re-entrancy for multitask operation.
+  Added auto cluster size selection to f_mkfs().
+  Added rewind option to f_readdir().
+  Changed result code of critical errors.
+  Renamed string functions to avoid name collision.
+
+
+R0.06 (April 1, 2008)
+  Added f_forward. (Tiny-FatFs)
+  Added string functions: fgets, fputc, fputs and fprintf.
+  Improved performance of f_lseek on moving to the same or following cluster.
+
+
+R0.05a (February 3, 2008)
+  Added f_truncate.
+  Added f_utime.
+  Fixed off by one error at FAT sub-type determination.
+  Fixed btr in f_read can be mistruncated.
+  Fixed cached sector is left not flushed when create and close without write.
+
+
+R0.05 (August 26, 2007)
+  Changed arguments of f_read, f_write.
+  Changed arguments of f_mkfs. (FatFs)
+  Fixed f_mkfs on FAT32 creates incorrect FSInfo. (FatFs)
+  Fixed f_mkdir on FAT32 creates incorrect directory. (FatFs)
+
+
+R0.04b (May 5, 2007)
+  Added _USE_NTFLAG option.
+  Added FSInfo support.
+  Fixed some problems corresponds to FAT32. (Tiny-FatFs)
+  Fixed DBCS name can result FR_INVALID_NAME.
+  Fixed short seek (<= csize) collapses the file object.
+
+
+R0.04a (April 1, 2007)
+  Supported multiple partitions on a plysical drive. (FatFs)
+  Added minimization level 3.
+  Added a capability of extending file size to f_lseek.
+  Fixed an endian sensitive code in f_mkfs. (FatFs)
+  Fixed a problem corresponds to FAT32 support. (Tiny-FatFs)
+
+
+R0.04 (February 4, 2007)
+  Supported multiple drive system. (FatFs)
+  Changed some APIs for multiple drive system.
+  Added f_mkfs. (FatFs)
+  Added _USE_FAT32 option. (Tiny-FatFs)
+
+
+R0.03a (December 11, 2006)
+  Improved cluster scan algolithm to write files fast.
+  Fixed f_mkdir creates incorrect directory on FAT32.
+
+
+R0.03 (September 22, 2006)
+  Added f_rename.
+  Changed option _FS_MINIMUM to _FS_MINIMIZE.
+
+
+R0.02a (June 10, 2006)
+  Added a configuration option _FS_MINIMUM.
+
+
+R0.02 (Jun 01, 2006)
+  Added FAT12.
+  Removed unbuffered mode.
+  Fixed a problem on small (<32M) patition.
+
+
+R0.01 (April 29, 2006)
+  First release
+
+
+R0.00 (February 26, 2006)
+  Prototype (not released)
+