Chinaunix首页 | 论坛 | 博客

嵌入式之囧途qiushui007.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

qiushui_007

  • 博客访问： 1514568
  • 博文数量： 129
  • 博客积分： 1449
  • 博客等级： 上尉
  • 技术积分： 3048
  • 用 户 组： 普通用户
  • 注册时间： 2012-07-24 18:36
文章分类

全部博文（129）

文章存档

2015年（3）

2014年（20）

2013年（65）

2012年（41）

我的朋友
最近访客
推荐博文
相关博文
FatFS的应用和对FatFS的封装, 自测成功

分类： C/C++

2013-05-13 09:10:51

1. 参考了 Q-sys的V2.35版本, 2个文件为 fswrap.h, fswarp.c
fswrap.h

点击(此处)折叠或打开

  1. #ifndef __FS_WRAP_H__
  2. #define __FS_WRAP_H__

  4. #define FS_size_t unsigned long /* 32 bit unsigned */
  5. #define FS_u32 unsigned long /* 32 bit unsigned */
  6. #define FS_i32 signed long /* 32 bit signed */
  7. #define FS_u16 unsigned short /* 16 bit unsigned */
  8. #define FS_i16 signed short /* 16 bit signed */
  9. #define FS_i8 signed char /* 8 bit signed */
  10. #define FS_u8 unsigned char /* 8 bit unsigned */
  11. //#define NULL             0

  13. typedef void FS_FILE;
  14. typedef void FS_DIR;

  16. typedef struct {
  17.   FS_u32 total_size;
  18.   FS_u32 free_size;
  19. } _DISK_INFO;

  21. /* Global constants*/
  22. #define FS_SEEK_CUR 1
  23. #define FS_SEEK_END 2
  24. #define FS_SEEK_SET 0 /*文件开头*/

  26. #ifndef _OPENDIR_TYPE_
  27. #define _OPENDIR_TYPE_

  29. typedef unsigned int size_t;
  30. typedef short dev_t;
  31. typedef unsigned int ino_t;
  32. typedef unsigned int mode_t;
  33. typedef unsigned short nlink_t;
  34. typedef unsigned long off_t;
  35. typedef unsigned short gid_t;
  36. typedef unsigned short uid_t;
  37. typedef int pid_t;
  38. typedef int time_t;

  40. struct stat {
  41.     mode_t st_mode; /* File mode */
  42.     ino_t st_ino; /* File serial number */
  43.     dev_t st_dev; /* ID of device containing file */
  44.     nlink_t st_nlink; /* Number of hard links */
  45.     uid_t st_uid; /* User ID of the file owner */
  46.     gid_t st_gid; /* Group ID of the file's group */
  47.     off_t st_size; /* File size (regular files only) */
  48.     time_t st_atime; /* Last access time */
  49.     time_t st_mtime; /* Last data modification time */
  50.     time_t st_ctime; /* Last file status change time */
  51. };

  53. #define NAME_MAX 63 /* domain */
  54. struct dirent
  55. {
  56.     char d_name[NAME_MAX+1];
  57.     unsigned int id;    /* use for id file, and only valid when the */
  58.     mode_t st_mode; /* file mode */
  59.     int st_ctime; /* file create time */


  62.                         /* size of d_name is zero */
  63.     /* now we needn't u_name, we save file name as utf8 */
  64.     //char u_name[NAME_MAX+1];

  66. };

  68. #define    _IFMT        0170000    /* type of file */
  69. #define        _IFDIR    0040000    /* directory */
  70. #define        _IFCHR    0020000    /* character special */
  71. #define        _IFBLK    0060000    /* block special */
  72. #define        _IFREG    0100000    /* regular */
  73. #define        _IFLNK    0120000    /* symbolic link */
  74. #define        _IFSOCK    0140000    /* socket */
  75. #define        _IFIFO    0010000    /* fifo */
  76. #define     S_BLKSIZE 1024 /* size of a block */
  77. #define    S_ISUID        0004000    /* set user id on execution */
  78. #define    S_ISGID        0002000    /* set group id on execution */

  80. #define    S_ISBLK(m)    (((m)&_IFMT) == _IFBLK)
  81. #define    S_ISCHR(m)    (((m)&_IFMT) == _IFCHR)
  82. #define    S_ISDIR(m)    (((m)&_IFMT) == _IFDIR)
  83. #define    S_ISFIFO(m)    (((m)&_IFMT) == _IFIFO)
  84. #define    S_ISREG(m)    (((m)&_IFMT) == _IFREG)
  85. #define    S_ISLNK(m)    (((m)&_IFMT) == _IFLNK)
  86. #define    S_ISSOCK(m)    (((m)&_IFMT) == _IFSOCK)

  88. #endif

  90. #ifndef _INC_TCHAR
  91. #define _INC_TCHAR
  92. typedef char TCHAR;
  93. #define _T(x) x
  94. #define _TEXT(x) x
  95. #endif

  97. #if 0
  98. #ifndef FA_READ
  99. #define    FA_READ                0x01
  100. #endif

  102. #ifndef FA_OPEN_EXISTING
  103. #define    FA_OPEN_EXISTING    0x00
  104. #endif

  106. #ifndef FA_WRITE
  107. #define    FA_WRITE            0x02
  108. #endif

  110. #ifndef FA_CREATE_NEW
  111. #define    FA_CREATE_NEW        0x04
  112. #endif

  114. #ifndef FA_CREATE_ALWAYS
  115. #define    FA_CREATE_ALWAYS    0x08
  116. #endif

  118. #ifndef FA_OPEN_ALWAYS
  119. #define    FA_OPEN_ALWAYS        0x10
  120. #endif
  121. #endif

  123. FS_FILE* FS_FOpen(const TCHAR *pFileName, const FS_i32 Mode);
  124. FS_i32 FS_FClose(FS_FILE*pFile);
  125. FS_size_t FS_FWrite(const void *pData, FS_size_t Size, FS_size_t N, FS_FILE *pFile);
  126. FS_size_t FS_FRead(void *pData, FS_size_t Size, FS_size_t N, FS_FILE *pFile);
  127. FS_i32 FS_FSeek(FS_FILE *pFile, FS_i32 Offset, FS_i32 Whence);
  128. FS_i32 FS_FTell(FS_FILE *pFile);

  130. FS_DIR *FS_OpenDir( const TCHAR *dirname );
  131. struct dirent * FS_ReadDir( FS_DIR *dirp);
  132. struct dirent * FS_ReadDir_IDX( FS_DIR *dirp,unsigned short idx);
  133. void FS_RewindDir(FS_DIR *pDir);
  134. FS_i32 FS_CloseDir( FS_DIR *dirp );
  135. FS_i32 FS_Unlink(const TCHAR *Path);
  136. FS_i32 FS_Stat(const TCHAR *path,struct stat *buf);
  137. FS_i32 FS_Rename(const TCHAR *OldName,const TCHAR *NewName);
  138. FS_i32 FS_Init(void);
  139. FS_i32 FS_Exit(void);

  141. FS_i32 GetDiskInfo(const TCHAR* Path,_DISK_INFO* info);
  142. FS_i32 FS_FileCpy(const TCHAR*path1, const TCHAR*path2);        //path1: souce file path2: destination file
  143. FS_i32 FS_GetFileSize(FS_FILE *pFile);


  146. //--- qiushui007, 自己习惯的写法
  147. #define fs_init     FS_Init
  148. #define fs_exit     FS_Exit

  150. #define fs_fopen     FS_FOpen
  151. #define fs_fclose FS_FClose
  152. #define fs_fwrite FS_FWrite
  153. #define fs_fread     FS_FRead
  154. #define fs_fseek     FS_FSeek
  155. #define fs_ftell     FS_FTell

  157. #endif
fswrap.c 

点击(此处)折叠或打开

  1. /************************************************************************
  2.     Project :
  3.     Module : file system api
  4.     File Name : fs_api.c
  5.     Author : dragon_zhang
  6.     Start Date : 2011.4.25
  7.     Language : C
  8.     Target :
  9.     Summary :
  10.     Change Notes : 2011.4.25 V1.0 creat file
  11. **************************************************************************/
  12. #include <string.h>
  13. #include "ff.h"
  14. #include "FsWrap.h"
  15. #include "OS_Wrap.h"

  17. #define DEBUGP //printf

  19. static FATFS FileSystemArea[_VOLUMES];         /* Work area (file system object) for logical drives */
  20. #if _USE_LFN
  21. static WCHAR LenFileName[_MAX_LFN+1];
  22. #endif

  24. typedef struct {
  25.     FRESULT error;
  26.     union {
  27.         FIL file;
  28.         DIR dir;
  29.     }fs;
  30. } _FS_PTR;

  32. //--------------------------------------------------------------------
  33. FS_i32 FS_Init(void)
  34. {
  35. #if 2
  36.     FS_i32 i = _VOLUMES;

  38.     for(i=0;i<_VOLUMES;i++) f_mount(i, &FileSystemArea[i]);

  40. #else
  41.     f_mount(0, &FileSystemArea[0]);
  42. #endif

  44.     return 0;
  45. }

  47. FS_i32 FS_Exit(void) {

  49.   FS_i32 i = _VOLUMES;

  51.   while(i--) f_mount(0, NULL);

  53.   return 0;
  54. }

  56. //---- 其余函数
  57. FS_FILE* FS_FOpen(const TCHAR *pFileName, const FS_i32 Mode)
  58. {
  59.     _FS_PTR * fp;

  61.     fp = (_FS_PTR*)Q_Mallco(sizeof(_FS_PTR));
  62.     memset((void*)fp,0,sizeof(_FS_PTR));

  64.     fp->error = f_open(&fp->fs.file,pFileName,Mode);

  66.     if(fp->error!=FR_OK)
  67.     {
  68.         Q_Free((void *)fp );
  69.         fp = 0;
  70.     }

  72.     return (FS_FILE*)fp;
  73. }

  75. FS_i32 FS_FClose(FS_FILE* pFile)
  76. {
  77.     _FS_PTR * fp = (_FS_PTR *)pFile;

  79.     if (!pFile)    return -1; /* No pointer to a FS_FILE structure */

  81.     fp->error = f_close(&fp->fs.file);

  83.     if(fp->error!=FR_OK) return -1;

  85.     Q_Free((void *)pFile);

  87.     return 0;
  88. }

  90. FS_size_t FS_FWrite(const void *pData, FS_size_t Size, FS_size_t N, FS_FILE *pFile)
  91. {
  92.     UINT i;
  93.     _FS_PTR * fp = (_FS_PTR *)pFile;

  95.      if (!pFile) return 0; /* No pointer to a FS_FILE structure */

  97.     fp->error = f_write(&fp->fs.file,pData,Size*N,&i);

  99.     if(fp->error!=FR_OK) return 0;

  101.     return i;
  102. }

  104. FS_size_t FS_FRead(void *pData, FS_size_t Size, FS_size_t N, FS_FILE *pFile)
  105. {
  106.     UINT i=0;
  107.     _FS_PTR * fp = (_FS_PTR *)pFile;

  109.     if (!pFile) return 0; /* No pointer to a FS_FILE structure */

  111.     fp->error = f_read(&fp->fs.file,pData,Size*N,&i);

  113.     if(fp->error!=FR_OK) return 0;

  115.     return i;
  116. }

  118. FS_i32 FS_FSeek(FS_FILE *pFile, FS_i32 Offset, FS_i32 Whence)
  119. {
  120.     FS_i32 value;
  121.     _FS_PTR * fp = (_FS_PTR *)pFile;

  123.     if (!pFile) return -1;

  125.     if(FS_SEEK_SET==Whence) value = 0;
  126.     else if(FS_SEEK_CUR==Whence)    value = fp->fs.file.fptr;
  127.     else if(FS_SEEK_END==Whence)    value = fp->fs.file.fsize;
  128.     else    return -1;

  130.     fp->error = f_lseek(&fp->fs.file,value+Offset);

  132.     if(fp->error!=FR_OK) return -1;

  134.     return 0;
  135. }


  138. FS_i32 FS_FTell(FS_FILE *pFile)
  139. {
  140.     _FS_PTR * fp = (_FS_PTR *)pFile;

  142.     if (!pFile) return -1;

  144.     return fp->fs.file.fptr;
  145. }

  147. FS_DIR *FS_OpenDir( const TCHAR *dirname )
  148. {
  149.     _FS_PTR * dir;

  151.     dir = (_FS_PTR *)Q_Mallco(sizeof(_FS_PTR));
  152.     memset((void*)dir,0,sizeof(_FS_PTR));

  154.     dir->error= f_opendir(&dir->fs.dir,dirname);

  156.     if(dir->error!=FR_OK)
  157.     {
  158.         Q_Free((void *)dir );
  159.         dir= 0;
  160.     }

  162.     return (FS_DIR *)dir;
  163. }


  166. #if _MAX_LFN > (NAME_MAX/2)
  167. #error " _MAX_LFN must less than NAME_MAX/2"
  168. #endif

  170. struct dirent * FS_ReadDir( FS_DIR *dirp)
  171. {
  172.     _FS_PTR * dir = (_FS_PTR *) dirp;

  174.     FILINFO FileInfo;
  175.     static struct dirent ent;
  176.     char *fn;
  177. #if _USE_LFN
  178.     FileInfo.lfname = (TCHAR*)LenFileName;
  179.     FileInfo.lfsize = sizeof(LenFileName);
  180. #endif

  182.     ent.d_name[0]=0;

  184.     if (dirp == 0) {
  185.           return 0; /* Device not found */
  186.     }

  188.      dir->error = f_readdir (
  189.      &dir->fs.dir,     /* Pointer to the open directory object */
  190.      &FileInfo /* Pointer to the file information structure */
  191.     );

  193.    if(dir->error!=FR_OK)
  194.    {
  195.      ent.d_name[0]=0;
  196.      ent.st_mode=0;
  197.      ent.id = 0;
  198.      ent.st_ctime = 0;

  200.      return 0;
  201.    }

  203. #if _USE_LFN
  204.    fn = (char *)FileInfo.lfname;
  205. #else
  206.    fn = (char *)FileInfo.fname;
  207. #endif

  209.    if(FileInfo.fname[0] == 0) //end
  210.      ent.d_name[0]=0;
  211.    else
  212.         strcpy(ent.d_name,fn);

  214.    ent.st_mode = (FileInfo.fattrib & AM_DIR)?_IFDIR:0;
  215.    ent.id = FileInfo.fsize;
  216.    ent.st_ctime = FileInfo.ftime|(FileInfo.fdate<<16);

  218.    return &ent;
  219. }

  221. struct dirent * FS_ReadDir_IDX( FS_DIR *dirp,unsigned short idx)
  222. {
  223.     _FS_PTR * dir = (_FS_PTR *) dirp;

  225.     FILINFO FileInfo;
  226.     static struct dirent ent;
  227.     char *fn;
  228. #if _USE_LFN
  229.     FileInfo.lfname = (TCHAR*)LenFileName;
  230.     FileInfo.lfsize = sizeof(LenFileName);
  231. #endif

  233.     ent.d_name[0]=0;

  235.     if (dirp == 0) {
  236.           return 0; /* Device not found */
  237.     }

  239.     dir->error = f_readdir (
  240.      &dir->fs.dir, /* Pointer to the open directory object */
  241.      0 /* Pointer to the file information structure */
  242.      );

  244.     for(;idx;idx--)
  245.         f_readdir_noinfo(&dir->fs.dir,&FileInfo);

  247.      dir->error = f_readdir (
  248.          &dir->fs.dir,     /* Pointer to the open directory object */
  249.          &FileInfo /* Pointer to the file information structure */
  250.         );

  252.    if(dir->error!=FR_OK)
  253.    {
  254.      ent.d_name[0]=0;
  255.      ent.st_mode=0;
  256.      ent.id = 0;
  257.      ent.st_ctime = 0;

  259.      return 0;
  260.    }

  262. #if _USE_LFN
  263.    fn = (char *)FileInfo.lfname;
  264. #else
  265.    fn = (char *)FileInfo.fname;
  266. #endif

  268.    if(FileInfo.fname[0] == 0) //end
  269.      ent.d_name[0]=0;
  270.    else
  271.        strcpy(ent.d_name,fn);

  273.    ent.st_mode = (FileInfo.fattrib & AM_DIR)?_IFDIR:0;
  274.    ent.id = FileInfo.fsize;
  275.    ent.st_ctime = FileInfo.ftime|(FileInfo.fdate<<16);

  277.    return &ent;
  278. }

  280. void FS_RewindDir(FS_DIR *dirp)
  281. {
  282.     _FS_PTR * dir = (_FS_PTR *) dirp;

  284.     if (!dirp) return;

  286.     dir->fs.dir.index = 0;
  287. }

  289. FS_i32 FS_CloseDir( FS_DIR *dirp )
  290. {
  291.   if(dirp == 0) return -1;

  293.   Q_Free((void *)dirp);

  295.     return 0;
  296. }

  298. FS_i32 FS_Unlink(const TCHAR *Path)
  299. {
  300.      if(f_unlink(Path)!=FR_OK) return -1;

  302.      return 0;
  303. }

  305. FS_i32 FS_GetFileSize(FS_FILE *pFile)
  306. {
  307.     _FS_PTR * fp = (_FS_PTR *)pFile;

  309.     return fp->fs.file.fsize;
  310. }

  312. FS_i32 FS_Stat(const TCHAR *path,struct stat *buf)
  313. {
  314.     FRESULT res;
  315.     FILINFO stat;
  316. #if _USE_LFN
  317.     stat.lfname = (TCHAR*)LenFileName;
  318.     stat.lfsize = sizeof(LenFileName);
  319. #endif

  321.     res=f_stat(path,&stat);

  323.      if(res!=FR_OK)
  324.     {
  325.         buf->st_size = 0;
  326.         buf->st_mode = 0;
  327.         buf->st_mtime = 0;
  328.       return -1;
  329.     }

  331.      buf->st_size = stat.fsize;
  332.     buf->st_mode = (stat.fattrib & AM_DIR)?_IFDIR:0;
  333.     buf->st_mtime = stat.ftime|(stat.fdate<<16);

  335.     return 0;
  336. }

  338. FS_i32 FS_Rename(const TCHAR *OldName,const TCHAR *NewName)
  339. {
  340.     FRESULT res ;

  342.     res =f_rename (OldName,NewName);

  344.     if(res!=FR_OK) return -1;

  346.     return 0;
  347. }

  349. #define COPY_FILE_BUFFER    512
  350. FS_i32 FS_FileCpy(const TCHAR*path1, const TCHAR*path2)        //path1: souce file path2: destination file
  351. {
  352.     FS_FILE *src;
  353.     FS_FILE * dst;
  354.     FS_i32 read_size,write_size;
  355.     FS_i32 src_size, dst_size;
  356.     struct stat buf;
  357.     _DISK_INFO info;
  358.     FS_i8 *buffer;

  360.     if( !strcmp((const char *)path1, (const char *)path2) )
  361.     {
  362.         DEBUGP("ERROR:can not copy a file to itselfrn");
  363.         return 0;
  364.     }

  366.     if( -1 == FS_Stat( path1, &buf ) ) return 0;

  368.     src_size = buf.st_size;

  370.     if(GetDiskInfo(path2,&info)==-1)
  371.     {
  372.         DEBUGP("ERROR:getdiskinfo errrn");
  373.         return 0;
  374.     }

  376.     if(src_size > info.free_size)
  377.     {
  378.         DEBUGP("there is no enough space on the flash!nr");
  379.         return 0;
  380.     }

  382.     src = FS_FOpen(path1, FA_READ|FA_OPEN_EXISTING);
  383.     if(0 == src)
  384.     {
  385.         DEBUGP("ERROR:cannot open the source filern");
  386.         return 0;
  387.     }

  389.     dst = FS_FOpen(path2, FA_CREATE_ALWAYS|FA_WRITE);
  390.     if(0 == dst)
  391.     {
  392.         DEBUGP("ERROR:cannot create the distance filern");
  393.         FS_FClose(src);
  394.         return 0;
  395.     }

  397.     buffer=Q_Mallco(COPY_FILE_BUFFER);

  399.     do{
  400.         read_size = FS_FRead(buffer, COPY_FILE_BUFFER,1,src);
  401.         write_size = FS_FWrite(buffer, read_size,1,dst);

  403.         if(write_size < read_size)
  404.         {
  405.             DEBUGP("ERROR:file write errorrn");
  406.             Q_Free(buffer);
  407.             goto CP_FILE_ERROR;
  408.         }
  409.     }while(read_size == COPY_FILE_BUFFER);

  411.     Q_Free(buffer);
  412.     FS_FClose(src);
  413.     FS_FClose(dst);

  415.     if( -1 == FS_Stat( path2, &buf ) ) return 0;

  417.     dst_size = buf.st_size;

  419.     if(dst_size < src_size)
  420.     {
  421.         DEBUGP("there is an unkown flash operation during the copyfile!nr");
  422.         FS_Unlink(path2);
  423.         return 0;
  424.     }

  426.     return 1;

  428. CP_FILE_ERROR:
  429.     FS_FClose(src);
  430.     FS_FClose(dst);
  431.     return 0;
  432. }

  434. FS_i32 GetDiskInfo(const TCHAR* Path,_DISK_INFO* info)
  435. {
  436.   FATFS *fs;
  437.   DWORD fre_clust, tot_sect,fre_sect;
  438.     FRESULT res;

  440.   /* Get volume information and free clusters of drive 1 */
  441.   res = f_getfree(Path, &fre_clust, &fs);
  442.   if (res)
  443.   {
  444.       info->total_size = 0;
  445.     info->free_size = 0;
  446.     return -1;
  447.   }
  448.   /* Get total sectors and free sectors */
  449.   tot_sect = (fs->n_fatent - 2) * fs->csize;
  450.   fre_sect = fre_clust * fs->csize;

  452.     info->total_size = tot_sect *512;
  453.     info->free_size = fre_sect *512;

  455.     return 0;
  456. }

2. 应用例程如下

点击(此处)折叠或打开

  1. u8 readfile(char *filename)
  2. {
  3. #if HAVE_FSWRAP
  4.     FS_FILE *fp;

  6. #else
  7.     FATFS fs;         // Work area (file system object) for logical drive
  8.     FIL fsrc, fdst; // file objects
  9.     FRESULT res;     // FatFs function common result code
  10.     UINT br, bw;     // File R/W count
  11. #endif

  13.     u8 bytelen = 38, readlen, ty;
  14.     u8 buffer[50];
  15.     static u16 ustimes = 1;

  17.     memset(buffer, 0x00, sizeof(buffer));

  19. #if HAVE_FSWRAP
  20.     fs_init();

  22.     fp = fs_fopen(filename, FA_OPEN_EXISTING | FA_READ);
  23.     if (fp == 0) {
  24.         display_status((char *)buffer);
  25.         fs_exit();
  26.         return(-1);
  27.     }
  28.     else {
  29.         DEBUGP("fopen OKrn!");
  30.         readlen = fs_fread(buffer, sizeof(char), bytelen, fp);
  31.         if (readlen != bytelen) {
  32.             display_status((char *)buffer);
  33.             fs_exit();
  34.             return(-2);
  35.         }
  36.         fs_fclose(fp);
  37.     }
  38.     fs_exit();

  40. #else
  41.     f_mount(0, &fs);

  43.   res = f_open(&fsrc, filename, FA_OPEN_EXISTING | FA_READ);
  44.   if (res != FR_OK) {
  45.       sprintf((char *)buffer, "f_open Error: %d", res);
  46.       display_status((char *)buffer);

  48.       f_mount(0, NULL);
  49.       return(res);
  50.   }

  52.     f_lseek(&fsrc, 0);
  53.     res = f_read(&fsrc, buffer, bytelen, &br);
  54.     //if (res != FR_OK) {
  55.     if (br != bytelen) {
  56.         sprintf((char *)buffer, "f_read Error: %d", res);
  57.       display_status((char *)buffer);

  59.       f_mount(0, NULL);
  60.         return(res);
  61.     }
  62.     //ty = fsrc.fsize;
  63.     //f_lseek(&fsrc, ty);
  64.     //res = f_write(&fsrc, buffer, ByteLen, &bw);

  66.     f_close(&fsrc);
  67.     f_mount(0, NULL);
  68. #endif    

  70.     return SD_OK;
  71. }
3. 移植参考
ff.c: 主要为底层协议, 配置文件为 ffconf.h,
diskio.c: 数据读取的驱动代码, 中间层, 为ff.c 服务. 至少完成disk_read和disk_write
sdcard.c: 底层的硬件驱动
每次读写时都调用 f_mount 可以支持热插拔. 带目录如: theme/f/common/btn/backp.bmp

//--- FatFs module application interface,
FRESULT f_mount (BYTE, FATFS*); //加载文件系统，BYTE参数是ID，后一个是文件系统定义。
FRESULT f_open (FIL*, const XCHAR*, BYTE); //打开文件，第一个参数是文件信息结构，第二个参数是文件名，第三是文件打开模式
FRESULT f_read (FIL*, void*, UINT, UINT*); //文件读取函数，参数1为文件对象（文件打开函数中得到），参数2为文件读取缓冲区，参数3为读取的字节数，参数4意义不清晰，等读到源代码就清楚了。
FRESULT f_write (FIL*, const void*, UINT, UINT*);//写文件，参数跟读差不多
FRESULT f_lseek (FIL*, DWORD); //移动文件的读写指针，参数2应该是移动的数目。
FRESULT f_close (FIL*); /* Close an open file object */
FRESULT f_opendir (DIR*, const XCHAR*); //打开目录，返回目录对象
FRESULT f_readdir (DIR*, FILINFO*); //读取目录，获得文件信息
FRESULT f_stat (const XCHAR*, FILINFO*); /* Get file status */
FRESULT f_getfree (const XCHAR*, DWORD*, FATFS**); /* Get number of free clusters on the drive */
FRESULT f_truncate (FIL*); /* Truncate file */
FRESULT f_sync (FIL*); /* Flush cached data of a writing file */将缓冲区数据写回文件
FRESULT f_unlink (const XCHAR*); //删除目录中的一个文件
FRESULT f_mkdir (const XCHAR*); /* Create a new directory */
FRESULT f_chmod (const XCHAR*, BYTE, BYTE); /* Change attriburte of the file/dir */
FRESULT f_utime (const XCHAR*, const FILINFO*); /* Change timestamp of the file/dir */
FRESULT f_rename (const XCHAR*, const XCHAR*); /* Rename/Move a file or directory */
FRESULT f_forward (FIL*, UINT(*)(const BYTE*,UINT), UINT, UINT*); /* Forward data to the stream */ 这个函数还要提供一个回调函数。
FRESULT f_mkfs (BYTE, BYTE, WORD); /* Create a file system on the drive */
FRESULT f_chdir (const XCHAR*); /* Change current directory */改变当前目录
FRESULT f_chdrive (BYTE); /* Change current drive */



 

阅读(3317) | 评论(0) | 转发(0) |
0

上一篇：uCOS和FreeRTOS都适用的M3启动代码, STM32F103VE系列试验OK

下一篇：openwrt用lighttpd替换默认的uhttpd, 支持LUCI

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6