⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 sd_fat.c

📁 本代码主要是完成了一套基于FAT16
💻 C
📖 第 1 页 / 共 3 页
字号:
                                    {
                                        SD_DiskRead(Dirs, FatRsvdSecCnt+FatFATSz*2+i, 1);
                                        for (j = 0; j < 16; j++)
                                        {   
                                            /* 说明找到个删除的一个条目位置 */
                                            switch (Dirs[j].DIR_Name[0])
                                            {
                                                case 0x00:      /* 说明找到个空条目位置         */
                                                case 0xE5:      /* 说明找到个删除条目位置       */
                                                    memcpy(Dirs[j].DIR_Name, CmpStr, 11);
                                                    Dirs[j].DIR_Attr = 0x20;
                                                    Dirs[j].DIR_CrtData.Day = 26;
                                                    Dirs[j].DIR_CrtData.Mon = 3;
                                                    Dirs[j].DIR_CrtData.Year = 2004;
                                                    Dirs[j].DIR_WrtData = Dirs[j].DIR_RedData = Dirs[j].DIR_CrtData;

                                                    Dirs[j].DIR_LFstClus = 0;
                                                    Dirs[j].DIR_FileSize = 0;

                                                    fp->FDT_Num = FatRsvdSecCnt+FatFATSz*2+i;
                                                    fp->FDT_Index = j;
                                                    SD_DiskWrite(Dirs, FatRsvdSecCnt+FatFATSz*2+i, 1);
                                                    return fp;
                                            }
                                        }
                                    }

                                    free(fp);
                                    return NULL;                /* 说明根目录不足,退出     */
                                }
                            }
                        }

                        free(fp);
                        return NULL;                            /* 说明空间不足,退出       */
                }
            }
            else        /* 说明不在根目录下 */
            {
                if (Mode == CRWBinary)  /* 创建文件时(并且此文件不存在)用于记录此目录启始簇 */
                    CuIndex2 = CuIndex;


OUT4:/**********/
                for (i = 0; i < FatSecPerClus; i++)
                {
                    SD_DiskRead(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i, 1);
                    for (j = 0; j < 16; j++)
                    {
                        /* 记录空闲条目位置,以便在新建文件时减少搜索 */
                        if ((Dirs[j].DIR_Name[0] == 0x00 || Dirs[j].DIR_Name[0] == 0xE5)
                            && CuIndexCreat == 0 && Mode == CRWBinary)
                        {
                            /* 所在扇区位置             */
                            CuIndexCreat = FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i;
                            /* 记录此条目在扇区的位置   */
                            CreatIndex = j;
                        }



                        for (l = 0; l < 11; l++)
                            if (Dirs[j].DIR_Name[l] != CmpStr[l]) break;


                        /* 若为创建文件 */
                        if (Mode == CRWBinary)
                        {
                            /* 说明找到匹配的文件名-目录 */
                            if (l == 11 && (Dirs[j].DIR_Attr & 0x10) == 0x10)
                            {
                                free(fp);
                                return NULL;
                            }
                        }


                        if ((Dirs[j].DIR_Attr & 0x20) != 0x20) continue;    /* 若不为目录(文件?)直接到下一个 */
                        if (l == 11)    /* 说明找到匹配的文件名 */
                        {
                            switch (Mode)
                            {
                                case ORWBinary:
                                    fp->FDT_Num = FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i;
                                    fp->FDT_Index = j;
                                    fp->FileSize = Dirs[j].DIR_FileSize;
                                    fp->FileStart = Dirs[j].DIR_LFstClus;
                                    return fp;


                                case DelFile:       /* 删除指定文件               */
                                case CRWBinary:
                                    fp->FDT_Num = FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i;
                                    fp->FDT_Index = j;
                                    fp->FileSize = 0;
                                    fp->FileStart = Dirs[j].DIR_LFstClus;

                                    /* 改写文件条目信息 */
                                    Dirs[j].DIR_FileSize = Dirs[j].DIR_LFstClus = 0;
                                    SD_DiskWrite(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i, 1);

                                    /* 删除指定文件 */
                                    if (Mode == DelFile)
                                    {
                                        Dirs[j].DIR_Name[0] = 0xE5;
                                        SD_DiskWrite(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i, 1);
                                    }


                                    CuIndex = fp->FileStart;
                                    if (CuIndex > 0)        /* 说明有此文件有内容 */
                                    {
OUT5:/******************************/
                                        OldFatIndex = CuIndex/256;
                                        SD_DiskRead(Dirs, FatRsvdSecCnt+OldFatIndex, 1);
                                        CuValue = (UINT16 *)Dirs;

OUT8:/**********************************/
                                        if ((CuIndex2=CuValue[CuIndex%256]) != 0xFFFF)
                                        {
                                            CuValue[CuIndex%256] = 0;
                                            CuIndex = CuIndex2;

                                            if (OldFatIndex != CuIndex/256)
                                            {
                                                SD_DiskWrite(Dirs, FatRsvdSecCnt+OldFatIndex, 1);
                                                goto OUT5;
                                            }
                                            else
                                            {
                                                goto OUT8;
                                            }
                                        }
                                        else
                                        {
                                            CuValue[CuIndex%256] = 0;
                                            SD_DiskWrite(Dirs, FatRsvdSecCnt+OldFatIndex, 1);  
                                        }
                                        return fp;
                                    }
                                    else                    /* 说明无此内容,选找空闲簇 */
                                    {
                                        /* 删除指定文件 */
                                        if (Mode == DelFile) return fp;


                                        for (i = 0; i < FatFATSz; i++)
                                        {
                                            SD_DiskRead(Dirs, FatRsvdSecCnt+i, 1);
                                            CuValue = (UINT16 *)Dirs; 
                                            for (j = 0; j < 256; j++)
                                            {
                                                if (CuValue[j] == 0x0000)       /* 说明找到空闲位置 */
                                                {
                                                    fp->FileStart = i*256+j;     /* 记录此文件开始簇 */
                                                    return fp;
                                                }
                                            }
                                        }

                                        free(fp);
                                        return NULL;    /* 说明空间不足,退出 */  
                                    }
                            }
                        }
                    }
                }

                SD_DiskRead(Dirs, FatRsvdSecCnt+CuIndex/256, 1);
                CuValue = (UINT16 *)Dirs;
                if (CuValue[CuIndex%256] == 0xFFFF)                         /* 说明没有此目录,返回空 */
                {
                    switch (Mode)
                    {
                        case DelFile:       /* 删除指定文件,且无此文件         */
                        case ORWBinary:
                            free(fp);
                            return NULL;                /* 说明没有此文件返回空 */

                        case CRWBinary:
                            if (CuIndexCreat > 0)       /* 说明已经找到空闲条目 */
                            {
                                for (i = 0; i < FatFATSz; i++)
                                {
                                    SD_DiskRead(Dirs, FatRsvdSecCnt+i, 1);
                                    CuValue = (UINT16 *)Dirs;
                                    for (j = 0; j < 256; j++)
                                    {
                                        if (CuValue[j] == 0x0000)       /* 说明找到空闲位置 */
                                        {
                                            fp->FDT_Num = CuIndexCreat;
                                            fp->FDT_Index = CreatIndex;
                                            fp->FileSize = 0;
                                            fp->FileStart = i*256+j;     /* 记录此文件开始簇 */

                                            SD_DiskRead(Dirs, CuIndexCreat, 1);
                                            memcpy(Dirs[CreatIndex].DIR_Name, CmpStr, 11);
                                            Dirs[CreatIndex].DIR_Attr = 0x20;
                                            Dirs[CreatIndex].DIR_CrtData.Day = 26;
                                            Dirs[CreatIndex].DIR_CrtData.Mon = 3;
                                            Dirs[CreatIndex].DIR_CrtData.Year = 2004;
                                            Dirs[CreatIndex].DIR_WrtData = Dirs[CreatIndex].DIR_RedData = Dirs[CreatIndex].DIR_CrtData;

                                            Dirs[CreatIndex].DIR_LFstClus = 0;
                                            Dirs[CreatIndex].DIR_FileSize = 0;
                                            SD_DiskWrite(Dirs, CuIndexCreat, 1);
                                            
                                            return fp;
                                        }
                                    }
                                }
                                free(fp);
                                return NULL;            /* 说明控间不足 */
                            }
                            else                        /* 说明此目录当前已满,扩充簇 */
                            {
                                CuIndexCreat = 0;
                                for (i = 0; i < FatFATSz; i++)
                                {
                                    SD_DiskRead(Dirs, FatRsvdSecCnt+i, 1);
                                    CuValue = (UINT16 *)Dirs;
                                    for (j = 0; j < 256; j++)
                                    {
                                        if (CuValue[j] == 0x0000)       /* 说明找到空闲位置 */
                                        {
                                            if (CuIndexCreat == 0)
                                            {
                                                fp->FileSize = 0;
                                                CuIndexCreat = i*256+j;     /* 记录此文件开始簇 */
                                            }
                                            else                        /* 记录当前目录扩充到多少簇 */
                                            {
                                                fp->FileStart = i*256+j;

                                                SD_DiskRead(Dirs, FatRsvdSecCnt+CuIndex/256, 1);
                                                CuValue = (UINT16 *)Dirs;
                                                CuValue[CuIndex%256] = CuIndexCreat;
                                                SD_DiskWrite(Dirs, FatRsvdSecCnt+CuIndex/256, 1);

                                                CuIndex = CuIndexCreat;
                                                SD_DiskRead(Dirs, FatRsvdSecCnt+CuIndex/256, 1);
                                                CuValue = (UINT16 *)Dirs;
                                                CuValue[CuIndex%256] = 0xFFFF;
                                                SD_DiskWrite(Dirs, FatRsvdSecCnt+CuIndex/256, 1);

                                                fp->FDT_Num = FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus;
                                                fp->FDT_Index = 0;


                                                memset(Dirs, 0, 512);
                                                for (i = 0; i < FatSecPerClus; i++)
                                                    SD_DiskWrite(Dirs, fp->FDT_Num+i, 1);


                                                memcpy(Dirs[0].DIR_Name, CmpStr, 11);
                                                Dirs[0].DIR_Attr = 0x20;
                                                Dirs[0].DIR_CrtData.Day = 26;
                                                Dirs[0].DIR_CrtData.Mon = 3;
                                                Dirs[0].DIR_CrtData.Year = 2004;
                                                Dirs[0].DIR_WrtData = Dirs[0].DIR_RedData = Dirs[0].DIR_CrtData;

                                                Dirs[0].DIR_LFstClus = 0;
                                                Dirs[0].DIR_FileSize = 0;
                                                SD_DiskWrite(Dirs, fp->FDT_Num, 1);


                                                return fp;
                                            }
                                        }
                                    }
                                }

                                free(fp);
                                return NULL;            /* 说明控间不足 */
                            }
                    }
                }
                else                                                        /* 继续搜索下一簇         */
                {
                    CuIndex = CuValue[CuIndex%256];
                    goto OUT4;
                }
            }
        }
    }

}


/* 调整文件位置指针   */
void SD_fseek(SD_FILE *fp, INT32 offset, UINT8 Mode)
{
    DIR     Dirs[16];  

    if (fp == NULL) return ;

    SD_DiskRead(Dirs, fp->FDT_Num, 1);
    switch (Mode)
    {
        case SDSEEK_SET:
            fp->FileSeek = 0;
            fp->FileSeek += offset;

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -