[原创]开源AVR32从SD卡中用FAT32文件系统读取文本显示于LCD的Proteus仿真源码

ID:405708 · 发表于 2018-10-10 19:08

这个程序是我8年前无聊时做的，SD卡镜像文件可用uiso打开，编辑后保存镜像文件后可在Proteus中看到效果。
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）

AVR32单片机源程序如下:

/*************************************************************************
*文件: fs/fat32.c
*作用: SD/MMC卡的相关操作
*作者: 宋
*************************************************************************/
#include "../config.h" //配置文件
#include "../drivers/mmc.h" //MMC卡驱动
#include "fat32.h"
#include "../gui/font.h"
DBRInfo dbrInfo;
buf_t dataBuffer;
File *fileItem;
LongDir *longItem;
uint8 getFileInfo(void);
uint8 delSpace(buf_t string,buf_t stringd,uint8 len);
uint32 currentPath;
uint16 currentLong; //当前路径所在簇
/*************************************************************************
*函数: chedkNameSum
*作用: 计算短文件名的效验和
*入口参数: FileName(短文件名)
*返回值: Sum(短文件名的效验和)
*备注: 这个函数参考了Microsoft Extensible Firmware Initiative FAT32 File System Specification.pdf
*************************************************************************/
uint8 checkNameSum(buf_t FileName)
{
uint8 FileNameLen;
uint8 Sum;
Sum = 0;
for(FileNameLen = 11;FileNameLen != 0;FileNameLen --) //共11个字符
{
Sum = ((Sum & 1) ? 0x80 : 0) + (Sum >> 1) + *FileName ++; //计算效验和
}
return Sum;
}
/*************************************************************************
*函数: bigToSmallending
*作用: 大小端转换
*入口参数: big(大端数据)
*返回值: len(big的长度)
*备注: 这个函数参考了一个帖子忘记是哪个帖子了
*************************************************************************/
/*
uint32 bigToSmallEnding(uint32 big,uint8 len)
{
uint32 result = 0;
uint32 fact = 1;
int8 i;
for(i = 0;i < len;i ++)
{
result += ((uint8 *)&(big))[i] *fact;
fact *= 0x100;
}
return big;
}
*/
/*************************************************************************
*函数: stringCmp
*作用: 比较字符串
*入口参数: str1(字符串1),str2(字符串2),len(长度)
*返回值: 0不同 1相同
*************************************************************************/
uint8 stringCmp(buf_t str1,buf_t str2,uint8 len)
{
uint8 i;
for(i = 0;i < len; i ++)
{
if(str1[i] != str2[i]) return 0;
}
return 1;
}
/*************************************************************************
*函数: readSector
*作用: 读一扇区数据
*入口参数: add(扇区地址),buf(数据缓冲区)
*返回值: TRUE(成功),FALSE(失败)
*************************************************************************/
uint8 readSector(uint32 add,buf_t buf)
{
return MMC_ReadSector(add,buf);
}
/*************************************************************************
*函数: getDBRInfo
*作用: 获取FAT的基本信息
*入口参数: dbrsector(DBR所在的扇区)
*返回值: TRUE(成功),FALSE(失败)
*************************************************************************/
uint8 FAT_Initialize(uint32 dbrSector)
{
buf_t tmpString = malloc(11);
dataBuffer = malloc(512);
FAT32_DBR *dbr = (FAT32_DBR *)dataBuffer;
if(readSector(dbrSector,dataBuffer) == FALSE)
{
free(tmpString);
free(dataBuffer);
return FALSE;
}
dbrInfo.bytePerSector = dbr->BPB_BytsPerSec; //每扇区字节数
dbrInfo.rootDirClust = dbr->BPB_RootClus; //根目录所在簇
dbrInfo.sectorsPerClust = dbr->BPB_SecPerClus; //每簇扇区数
dbrInfo.FATSector = dbr->BPB_FATSz32; //FAT表所占扇区数
dbrInfo.firstFATSector = dbr->BPB_RsvdSecCnt; //第一个FAT表的位置
dbrInfo.rootDirSector = dbrInfo.firstFATSector \
+(dbrInfo.FATSector * dbr->BPB_NumFATs); //根目录所在扇区
currentPath = dbrInfo.rootDirClust;
free(tmpString);
free(dataBuffer);
return TRUE;
}
/*************************************************************************
*函数: getNextClust
*作用: 根据当前簇获取下一簇
*入口参数: currentClust(当前簇)
*返回值: nextClust(下一簇)
*************************************************************************/
uint32 getNextClust(uint32 currentClust)
{
uint32 nextClust; //定义下一个簇
readSector(
dbrInfo.firstFATSector //FAT表项的首扇区
+ (uint32)((currentClust << 2) >> 9) //一个FAT表占4个字节
//比如currentClust = 200 那么它所在位置就是800 而一个dataBuffer是512
//字节这样的话800就溢出了所以用800/512=1(整型)这样就读出了它在哪个扇区中
,dataBuffer);
currentClust = (currentClust << 2) >= 512 ?(currentClust * 4) % 512:currentClust << 2;
//如上所说下一簇就等于第800/512扇区中的第的第800%512偏移量处
nextClust = (uint32)(dataBuffer[currentClust] //合并4个字节为1个32位数
|(dataBuffer[currentClust + 1] << 8)
|(dataBuffer[currentClust + 2] << 16)
|(dataBuffer[currentClust + 3] << 24));
return nextClust; //返回下一簇的数值
}
/*************************************************************************
*函数: delSpace
*作用: 删除字符串两端的空格
*入口参数: source(源字符串),string(目地字符串),len(字符个串长度)
*返回值: 去掉空格后的字符串长度
*************************************************************************/
uint8 delSpace(buf_t source,buf_t string,uint8 len)
{
uint8 i;
uint8 handspace = 0;
uint8 lastspace = 0;
for(i = 0;i < len;i ++) //从头部查询
{
if(source[i] == ' ') //发现空格
handspace ++; //字符串头部空格计数器加1
else break; //如发现非空格则退出循环
}
for(i = len - 1;i > 0;i --) //从尾部查询
{
if(source[i] == ' ') //发现空格
lastspace ++; //字符串尾部空格计数器加1
else break; //如发现非空格则退出循环
}
memcpy(string,&source[handspace],len - handspace); //把有字符串的位置向头部移动
if(lastspace != 0)string[len - handspace - lastspace] = 0; //向字符串尾部写0意为字符串到此结束
return len-handspace-lastspace; //返回去掉空格后的字符串长度
}
/*************************************************************************
*函数: getFileDate
*作用: 获取文件日期
*入口参数: date(从File里读到的文件日期信息),filedate(读出的日期)
*返回值: 无
*************************************************************************/
/*
void getFileDate(uint16 date,Date *filedate)
{
filedate->year = (date >> 9) + 1980; //计算年
filedate->month = (date & 0x1e0) >> 5; //计算月
filedate->day = date & 0x1f; //计算日
}
/*************************************************************************
*函数: getFileTime
*作用: 获取文件日期
*入口参数: time(从File里读到的文件时间信息),filetime(读出的时间)
*返回值: 无
*************************************************************************/
/*
void getFileTime(uint16 time,Time *filetime)
{
filetime->hour = (time &0xf800) >> 11; //计算小时
filetime->minute = (time & 0x7e0) >> 5; //计算分钟
filetime->second = time & 0x1f; //计算秒
}
/*************************************************************************
*函数: bigToSmall
*作用: 字符串大小写转换
*入口参数: string(源字符串),stringd(目地字符串),flag(大写到小是为1 小写到大写为0),len(字符个串长度)
*返回值: 无
*************************************************************************/
void bigToSmall(buf_t string,buf_t stringd,flag_t flag,uint8 len)
{
uint8 i;
if(flag) //判断大(小) -> 小(大)
{
for(i = 0;i < len;i ++)
{
if((string[i] >= 'A') && (string[i] <= 'Z')) //大写到小写的字符范围是'A'-'Z'
stringd[i] = string[i] + 0x20; //大写到小写的转换
else
stringd[i] = string[i]; //不在大写字符范围内的不进行转换
}
}else{
for(i = 0;i < len;i ++)
{
if((string[i] >= 'a') && (string[i] <= 'z')) //小写到大写的字符范围是'a'-'z'
stringd[i] = string[i] - 0x20; //小写到大写的转换
else
stringd[i] = string[i]; //不在小写字符范围内的不进行转换
}
}
}
/*************************************************************************
*函数: sectorToClust
*作用: 扇区和簇之间的换算
*入口参数: 扇区
*返回值: 簇
*************************************************************************/
uint32 sectorToClust(uint32 sector)
{
return sector / dbrInfo.sectorsPerClust; //单位换算
}
/*************************************************************************
*函数: clustToSector
*作用: 簇和扇区之间的换算
*入口参数: 簇
*返回值: 扇区
*************************************************************************/
uint32 clustToSector(uint32 clust)
{
return clust * dbrInfo.sectorsPerClust; //单位换算
}
/*************************************************************************
*函数: dispFileSize
*作用: 显示文件的大小信息
*入口参数: size(文件的大小)
*返回值: 无
*************************************************************************/
/*
void dispFileSize(uint32 size)
{
#if DEBUG_TYPE == EN //英文终端
if(size < 1024) //不到1K 的
printf("size:%dB\r\n",size); //直接显示XXB
if((size > 1024) && (size <0x100000)) //大于1K小于1M的
printf("size:%dKB\r\n",size/1024); //显示XXKB
if((size > 0x100000) && (size < 0x40000000)) //大于1M小于1G的
printf("size:%dMB\r\n",size/0x100000); //显示XXMB
if(size > 0x40000000) //大于1G小于1T的
printf("size:%dGB\r\n",size/0x40000000); //显示XXGB
#elif DEBUG_TYPE ==CN
if(size < 1024)
printf("文件大小:%dB\r\n",size);
if((size > 1024) && (size <0x100000))
printf("文件大小:%dKB\r\n",size/1024);
if((size > 0x100000) && (size < 0x40000000))
printf("文件大小:%dMB\r\n",size/0x100000);
if(size > 0x40000000)
printf("文件大小:%dGB\r\n",size/0x40000000);
#endif
}
/*************************************************************************
*函数: getFileItem
*作用: 从当前缓冲区中获取文件信息
*入口参数: offset(当前缓冲区中的位置最大值:512)
*返回值: 无
*************************************************************************/
void getFileItem(uint16 offset)
{
fileItem = (File *)&dataBuffer[offset]; //获取文件结构
}
/*************************************************************************
*函数: getFileItem
*作用: 从当前缓冲区中获取文件信息
*入口参数: offset(当前缓冲区中的位置最大值:512)
*返回值: 无
*************************************************************************/
void getFileLongDirItem(uint16 offset)
{
longItem = (LongDir *)&dataBuffer[offset]; //获取长目录项结构
}
/*************************************************************************
*函数: fileNameProcess
*作用: 普通文件名转换成短文件名例如:"mp3.txt" >> "MP3 TXT"
*入口参数: dir(普通文件名),dird(转换好的文件名)
*返回值: 无
*************************************************************************/
void fileNameProcess(buf_t dir,buf_t dird)
{
uint8 i;
uint8 point = 12; //"."在文件名中的位置
for(i = 0;i < 8;i ++) //主文件名
{
if(dir[i] == 0)goto space;
if(dir[i] != '.') //没有发现"."
dird[i] = dir[i]; //获取短文件名
else
{ //发现"."
point = i + 1; //记录"."的位置
space:
for(;i < 8;i++)
dird[i] = ' '; //从"."的位位置填充空格
}
}
if(dir[8] == '.')point = 9; //如第9个字符是"."
if(point != 12) //如果有"."(为12就是没有".")
{
for(i = 0;i < 3;i ++) //获取3个扩展名
{
if(dir[point + i] != 0) //如果没有结束
dird[8 + i] = dir[point + i]; //从"."后面获取扩展名
else //如果结束了
for(;i < 3;i ++) //剩下的字符填充空格
dird[8 + i] = ' ';
}
}
else //如果没有"."
for(i = 8;i < 11;i ++)
dird[i] = ' '; //全部填充空格
bigToSmall(dird,dird,SMALL_TO_BIG,11); //转换成大写
}
/*************************************************************************
*函数: openDir
*作用: 在当前目录下查找文件如果是文件夹则打开是文件则返回文件首簇
*入口参数: dir(文件或文件夹名)
*返回值: 文件首簇
*************************************************************************/
uint32 openDir(buf_t dir)
{
uint16 i;
uint8 sector;
uint32 currentClust;
buf_t tmpString = malloc(11);
currentClust = currentPath; //设置当前簇
fileNameProcess(dir,tmpString);
while(1)
{
for(sector = 0;sector < dbrInfo.sectorsPerClust;sector ++) //扫描1整簇
{
readSector( //读一扇区到缓冲区
clustToSector(currentClust - dbrInfo.rootDirClust) //扇区和簇之间的单位转换
//当前簇 - 根目录首簇 + 根目录首扇区 = 当前簇首扇区
+ sector //第"sector"个扇区
+ dbrInfo.rootDirSector, //以根目录首扇区为参考
dataBuffer); //读到这里
for(i = 0;i < 16;i ++) //每个目录项占32个字节512/32 = 16所以要扫描16次
{
getFileItem(i *32); //从i*32偏移量获取目录项信息
if(stringCmp(tmpString,fileItem->DIR_Name,11)) //如果找到文件
{
currentLong = i * 32; //获取长目录项用
if(fileItem->DIR_Attr == ATTR_DIRECTORY) //如果是文件夹
{
currentPath = (uint32)(fileItem->DIR_FstClusHI << 16)|(fileItem->DIR_FstClusLO); //设置当前目录首簇(相当于进入一个目录)
free(tmpString);
return TRUE; //返回成功可以用if(openDir("xxx")) == TRUE
//来判读这个文件是文件还是文件夹
}
else
{
free(tmpString);
return (uint32)(fileItem -> DIR_FstClusHI << 16)|(fileItem -> DIR_FstClusLO); //如果是文件则返回文件首簇
}
}
}
}
currentClust = getNextClust(currentClust); //根据当前簇获取下一簇
if((currentClust == ENDCLUST)||(currentClust == BADCLUST)||(currentClust == FIRSTCLUS)) //如果扫描完所有簇还是没有发现要找的文件则返回失败
{
free(tmpString);
return FALSE;
}
}
free(tmpString);
return FALSE;
}
/*************************************************************************
*函数: open
*作用: 返回一个文件所在的簇
*入口参数: path(文件路径)
*返回值: 文件所在的簇
*************************************************************************/
uint32 fileOpen(buf_t path)
{
uint32 result;
uint16 i;
uint8 j = 0;
buf_t dir;
dataBuffer = malloc(512);
dir = malloc(13); //开辟一个13个字节的数组
if(path[0] != '/') //判断文件路径
{
i = 0; //非根目录表示是当前目录
}else
{
i = 1; //
currentPath = dbrInfo.rootDirClust; //是根目录切换当前目录至根目录
}
while(1)
{
if(path[i] == '/') //一个文件或目录名的开始例如:"/usr/src/linux/include/asm-generic/page.c"
{
dir[j + 1] = '\0';
openDir(dir); //打开目录
j = 0; //开始一个文件或目录名的获取
}else
{
dir[j] = path[i]; //获取一个文件或目录名
if(path[i] == 0) //路径结束
{
result = openDir(dir);
free(dir);
free(dataBuffer);
return result; //返回文件或目录的起始簇
}
j ++; //文件或目录字符串中的位置
}
i++; //路径字符串中的位置
}
}
/*************************************************************************
*函数: read
*作用: 读文件
*入口参数: fp(文件首簇),buf(读到的数据),llseek(相对文件首簇的偏移量),len(数据长度最大不能超过512),flag
*返回值: 文件读取结束信息
*************************************************************************/
uint8 fileRead(fp_t fp,buf_t buf,uint32 llseek,uint16 len,flag_t flag)
{
uint32 currentClust; //当前簇
uint32 var,var_llseek;
uint16 i = 0;
var_llseek = llseek;
dataBuffer = malloc(512);
currentClust = fp ;
var = var_llseek >> 9;
if(var >= dbrInfo.sectorsPerClust) //计算偏移量在哪个扇区
if(flag & FONTFILE_MASK == FONTFILE) //判断是否是字库文件因为不加这个读取字库会很慢加了这个如果有碎片会出意外
currentClust = var / dbrInfo.sectorsPerClust + currentClust ; //从偏移量中计算出当前簇;
else
{
i = (var / dbrInfo.sectorsPerClust) ; //计算从文件头部到偏移量有多少簇
while(i-- ) //挨个簇查询
{
currentClust = getNextClust(currentClust); //获取下一簇
if((currentClust == ENDCLUST)\
|| (currentClust == BADCLUST)\
|| (currentClust == FIRSTCLUS)) //有坏簇或到终点返回
{
free(dataBuffer);
return FALSE;
}
}
}
readSector(clustToSector(currentClust - dbrInfo.rootDirClust)\
+ (var % dbrInfo.sectorsPerClust) + dbrInfo.rootDirSector,dataBuffer); //先从偏移位置读取一扇区数据
for(i = 0;i < len;i ++) //把有用数据放进缓冲区
{
if((i + var_llseek % 512) >= 512) //如果读取过程中超出当前扇区
{
var_llseek = 0; //下一个扇区从头读取
if(((var + 1) % dbrInfo.sectorsPerClust) == 0) //如果读取过程中超出当前簇
{
currentClust = getNextClust(currentClust); //获取下一簇
if((currentClust == ENDCLUST)\
|| (currentClust == BADCLUST)\
|| (currentClust == FIRSTCLUS)) //有坏簇或到终点返回
{
free(dataBuffer);
return FALSE;
}
readSector(clustToSector(currentClust - dbrInfo.rootDirClust)\
+ ((var + 1) % dbrInfo.sectorsPerClust)\
+ dbrInfo.rootDirSector ,dataBuffer); //读取下个簇的第一个扇区
}else
readSector(clustToSector(currentClust - dbrInfo.rootDirClust)\
+ (var % dbrInfo.sectorsPerClust)\
+ dbrInfo.rootDirSector + 1,dataBuffer); //读取下个扇区
}
buf[i] = dataBuffer[i + var_llseek % 512]; //收集有用数据
}
free(dataBuffer);
return TRUE;
}
/*************************************************************************
*函数: getFileLongName
*作用: 从当前文件中获取文件长目录项信息
*入口参数: string(获取到的长文件名)
*返回值: 无
*************************************************************************/
void getFileLongName(buf_t string)
{
uint8 val,val1,i,item;
item = 0;
uint32 offset;
offset = currentLong;
if(offset > 31)getFileLongDirItem(offset-32); //获取当前文件的长目录结构
if((longItem->LDIR_Attr == ATTR_LONG_NAME) && (offset > 31)) //如里是长目录项并
{
val = checkNameSum(fileItem->DIR_Name); //获取文件效验和
if(val == longItem->LDIR_Chksum) //对比文件效验和
{
do{
getFileLongDirItem(offset-((item + 1) << 5)); //获取当前文件的长目录结构的子项
for(i = 0;i < 13;i ++) //第个子项是13个字符
{
if(i < 5) //第1-5个字符
{
if(longItem->LDIR_Name1[i] == 0xffff) //是否结束
{
string[i + (item * 13) + 1] = 0; //设置结束
return; //退出
}
if(longItem->LDIR_Name1[i] < 0x100) //是否Unicode
string[i + (item * 13)] = longItem->LDIR_Name1[i]; //从长目录项中获取字符
else
{
UnitoAsc(longItem -> LDIR_Name1[i]); //把Unicode转换成ASCII
string[i + (item * 13)] = longItem -> LDIR_Name1[i];
} //是Unicode
}
if((i > 4)&&(i < 11)) //第6-11个字符
{
if(longItem->LDIR_Name2[i - 5] == 0xffff) //是否结束
{
string[i + (item * 13) + 1] = 0; //设置结束
return; //退出
}
if(longItem->LDIR_Name2[i - 5] < 0x100) //是否Unicode
string[i + (item * 13)] = longItem->LDIR_Name2[i - 5]; //从长目录项中获取字符
else
{
UnitoAsc(longItem -> LDIR_Name2[i]);
string[i + (item * 13)] = longItem -> LDIR_Name2[i]; //把Unicode转换成ASCII
}
}
if (i > 10) //第12-13个字符
{
if(longItem->LDIR_Name3[i - 11] == 0xffff) //是否结束
{
string[i + (item * 13) + 1] = 0; //设置结束
return; //退出
}
if(longItem->LDIR_Name3[i - 11] < 0x100) //是否Unicode
string[i + (item * 13)] = longItem->LDIR_Name3[i - 11];//从长目录项中获取字符
else
{
UnitoAsc(longItem -> LDIR_Name3[i]);
string[i + (item * 13)] = longItem -> LDIR_Name3[i]; //把Unicode转换成ASCII
}
}
}
item ++; //子项计数
}
while(!(longItem->LDIR_Ord & 0x40)); //是否最后一个子项
}
}
else
{
if(fileItem->DIR_LowCase & FILE_NAME_SMALL)
bigToSmall(fileItem->DIR_Name,string,BIG_TO_SMALL,8); //如果文件名是小写就把短文件名转换成小写
else
bigToSmall(fileItem->DIR_Name,string,SMALL_TO_BIG,8); //否则转换成大写
if(fileItem->DIR_LowCase & FILE_EXT_SMALL)
bigToSmall(&fileItem->DIR_Name[8],&string[8],BIG_TO_SMALL,3); //如果扩展名是小写就把短文件名中的扩展名小写
else
bigToSmall(&fileItem->DIR_Name[8],&string[8],SMALL_TO_BIG,3); //否则转换成大写
val = delSpace(string,string,8); //删除空格
string[val] = '.'; //设置'.'
if(strncmp(&fileItem->DIR_Name[8]," ",3) != 0) //扩展名是否为空
{
val1 = delSpace(&string[8],&string[val + 1],3); //如不为空删除空格并连接文件名和扩展名
string[val1 + val + 1] = 0; //设置结束
}else
string[val] = 0; //为空就不设置'.'
}
}