sd_fat.c

本代码主要是完成了一套基于FAT16

            break;

        case SDSEEK_CUR:
            fp->FileSeek += offset;
            break;

        case SDSEEK_END:
            fp->FileSeek = Dirs[fp->FDT_Index].DIR_FileSize;
            break;
    }

    if (fp->FileSeek < 0) fp->FileSeek = 0;
    if (fp->FileSeek > Dirs[fp->FDT_Index].DIR_FileSize) fp->FileSeek = Dirs[fp->FDT_Index].DIR_FileSize;
}


/* 文件读取函数       */
UINT32 SD_fread(UINT8 *buf, UINT16 size, UINT16 count, SD_FILE *fp)
{
    /* 获取要读取的文件长度 */
    UINT32  Leng = size*count, start, end, count2 = 0;
    UINT16  i, j, *CVlue16, CuIndex;
    UINT8   *CVule8;
    DIR     Dirs[16];


    SD_DiskRead(Dirs, fp->FDT_Num, 1);
    if ((Dirs[fp->FDT_Index].DIR_FileSize == 0) || (Leng == 0) || (fp == NULL)
        || (fp->FileSeek == Dirs[fp->FDT_Index].DIR_FileSize)) return 0;    /*说明文件没有内容*/



    start = fp->FileSeek/512;/*Start应是文件的开始扇区*/
    end = fp->FileSeek+Leng;
    if (end > Dirs[fp->FDT_Index].DIR_FileSize)
    {
        Leng = Dirs[fp->FDT_Index].DIR_FileSize - fp->FileSeek;
        end = Dirs[fp->FDT_Index].DIR_FileSize;
    }
    if ((end%512) != 0)
        end = end/512+1;
    else
        end = end/512;



    CuIndex = fp->FileStart;
    for (i = start; i < end; i++)
    {
        for (j = 0; j < i/FatSecPerClus; j++)
        {
            SD_DiskRead(Dirs, FatRsvdSecCnt+CuIndex/256, 1);
            CVlue16 = (UINT16 *)Dirs;
            CuIndex = CVlue16[CuIndex%256];
        }

        SD_DiskRead(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i%FatSecPerClus, 1);
        CVule8 = (UINT8 *)Dirs;
        switch (end-start)
        {
            case 1:             /* 内容只在一个扇区 */
                memcpy(buf, &CVule8[fp->FileSeek%512], Leng);
                fp->FileSeek += Leng;
                return Leng;

            /*case 2:             * 内容只在两个扇区 *
                if (i == start)
                {
                    count2 = 512-fp->FileSeek%512;
                    memcpy(buf, &CVule8[fp->FileSeek%512], count2);
                    fp->FileSeek += count2;
                }

                if (i == (end-1))
                {
                    memcpy(&buf[count2], CVule8, Leng-count2);
                    fp->FileSeek += Leng-count2;
                    return Leng;
                }
                break;*/

            default:            /* 内容在多个扇区   */
                if (i == start)
                {
                    count2 = 512-fp->FileSeek%512;
                    memcpy(buf, &CVule8[fp->FileSeek%512], count2);
                    fp->FileSeek += count2;
                }
                else
                {
                    if (i != (end-1))
                    {
                        memcpy(&buf[count2], CVule8, 512);
                        fp->FileSeek += 512;
                        count2 += 512;
                    }
                }

                if (i == (end-1))
                {
                    memcpy(&buf[count2], CVule8, Leng-count2);
                    fp->FileSeek += Leng-count2;
                    return Leng;
                }
                break;
        }
    }
}



/* 文件写入函数       */
UINT32 SD_fwrite(UINT8 *buf, UINT16 size, UINT16 count, SD_FILE *fp)
{
    /* 获取要读取的文件长度 */
    UINT32  Leng = size*count, start, end, count2 = 0;
    UINT16  m, n, i, j, *CVlue16, CuIndex;
    UINT8   *CVule8;
    DIR     Dirs[16];


    if (Leng == 0 || fp == NULL) return 0;                /* 说明没有要写如的内容     */

    start = fp->FileSeek/512;
    end = fp->FileSeek+Leng;



    if ((end%512) != 0)
        end = end/512+1;
    else
        end = end/512;


    /* 若为新建的文件 */
    CuIndex = fp->FileStart;
    if (fp->FileSize == 0)
    {
		
        SD_DiskRead(Dirs, fp->FDT_Num, 1); 
        Dirs[fp->FDT_Index].DIR_LFstClus = fp->FileStart;
        SD_DiskWrite(Dirs, fp->FDT_Num, 1);

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


        /* 清空新找的簇 */
        memset(Dirs, 0, 512);
        for (n = 0; n < FatSecPerClus; n++)
            SD_DiskWrite(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+n, 1);
    }
    

    for (i = start; i < end; i++)
    {
        for (j = 0; j < i/FatSecPerClus; j++)
        {
            SD_DiskRead(Dirs, FatRsvdSecCnt+CuIndex/256, 1);
            CVlue16 = (UINT16 *)Dirs;
            if (CVlue16[CuIndex%256] == 0xFFFF)
            {
                /* 说明要增长文件长度，搜索新空闲簇，建立新的文件FAT表链接 */
                for (m = 0; m < FatFATSz; m++)
                {
                    SD_DiskRead(Dirs, FatRsvdSecCnt+m, 1);
                    CVlue16 = (UINT16 *)Dirs;
                    for (n = 0; n < 256; n++)
                    {
                        if (CVlue16[n] == 0x0000)       /* 说明找到空闲位置 */
                        {
                            size = CVlue16[CuIndex%256] = m*256+n;
                            SD_DiskWrite(Dirs, FatRsvdSecCnt+CuIndex/256, 1);

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


                            /* 清空新连接上的簇 */
                            memset(Dirs, 0, 512);
                            for (n = 0; n < FatSecPerClus; n++)
                                SD_DiskWrite(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+n, 1);


                            goto OUT1;
                        }
                    }
                }

                return count2;   /* 说明没有空间 */

OUT1: ;
            }
            else
            {
                CuIndex = CVlue16[CuIndex%256];
            }
        }


        SD_DiskRead(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i%FatSecPerClus, 1);
        CVule8 = (UINT8 *)Dirs;
        switch (end-start)
        {
            case 1:             /* 内容只在一个扇区 */
                memcpy(&CVule8[fp->FileSeek%512], buf, Leng);
                SD_DiskWrite(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i%FatSecPerClus, 1);
                fp->FileSeek += Leng;

                if (fp->FileSeek > fp->FileSize)
                {
                    SD_DiskRead(Dirs, fp->FDT_Num, 1); 
                    fp->FileSize = Dirs[fp->FDT_Index].DIR_FileSize = fp->FileSeek;
                    SD_DiskWrite(Dirs, fp->FDT_Num, 1);


                }
                return Leng;

            /*case 2:             * 内容只在两个扇区 *
                if (i == start)
                {
                    count2 = 512-fp->FileSeek%512;
                    memcpy(&CVule8[fp->FileSeek%512], buf, count2);
                    SD_DiskWrite(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i%FatSecPerClus, 1);
                    fp->FileSeek += count2;
                }

                if (i == (end-1))
                {
                    memcpy(CVule8, &buf[count2], Leng-count2);
                    SD_DiskWrite(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i%FatSecPerClus, 1);
                    fp->FileSeek += Leng-count2;

                    if (fp->FileSeek > fp->FileSize)
                    {
                        SD_DiskRead(Dirs, fp->FDT_Num, 1); 
                        fp->FileSize = Dirs[fp->FDT_Index].DIR_FileSize = fp->FileSeek;
                        SD_DiskWrite(Dirs, fp->FDT_Num, 1);
                    }
                    return Leng;
                }
                break;*/

            default:            /* 内容在多个扇区   */
                if (i == start)
                {
                    count2 = 512-fp->FileSeek%512;
                    memcpy(&CVule8[fp->FileSeek%512], buf, count2);
                    SD_DiskWrite(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i%FatSecPerClus, 1);
                    fp->FileSeek += count2;
                }
                else
                {
                    if (i != (end-1))
                    {
                        memcpy(CVule8, &buf[count2], 512);
                        SD_DiskWrite(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i%FatSecPerClus, 1);
                        fp->FileSeek += 512;
                        count2 += 512;
                    }
                }

                if (i == (end-1))
                {
                    memcpy(CVule8, &buf[count2], Leng-count2);
                    SD_DiskWrite(Dirs, FatRsvdSecCnt+FatFATSz*2+FatRootEntCnt/16+(CuIndex-2)*FatSecPerClus+i%FatSecPerClus, 1);
                    fp->FileSeek += Leng-count2;

                    if (fp->FileSeek > fp->FileSize)
                    {
                        SD_DiskRead(Dirs, fp->FDT_Num, 1); 
                        fp->FileSize = Dirs[fp->FDT_Index].DIR_FileSize = fp->FileSeek;
                        SD_DiskWrite(Dirs, fp->FDT_Num, 1);
                    }
                    return Leng;
                }
                break;
        }
    }   
}




/* 文件关闭函数       */
UINT8 SD_fclose(SD_FILE *fp)
{
    free(fp);
    fp = NULL;
    if (fp == NULL)
        return 0;
    else
        return 1;
}