fat16.c

sd 卡的读写程序范例

/*#######################################################################################
Project:MSP430F1XX MCU Development Board
fat16.C
Copyright (C) 2007 edadiy
#######################################################################################*/

#include "fat16.h"
#include "mmc.h"
uint8 BUFFER[512];
uint16 BPB_BytesPerSec;
uint8 BPB_SecPerClus;
uint16 BPB_RsvdSecCnt;
uint8 BPB_NumFATs;
uint16 BPB_RootEntCnt;
uint16 BPB_TotSec16;
uint16 BPB_FATSz16;
uint32 BPB_HiddSec;
uint32 BPB_TotSec32;
//********************************************************************************************
void ReadBlock(uint32 LBA)
//********************************************************************************************
{
    mmc_read_sector(LBA,BUFFER);
    return;
}

//********************************************************************************************
void WriteBlock(uint32 LBA)
//********************************************************************************************
{
//  LBA = LBA+19;
    mmc_write_sector(LBA,BUFFER);
    return;
}

//********************************************************************************************
void CopyBytes(void* S, void* D, uint16 size)
//********************************************************************************************
{
    uint8 *s = S, *d = D;
    uint16 i;
    for(i = 0; i < size; i++)
        *d++ = *s++;
}

//********************************************************************************************
uint8 IsEqual(void* A, void* B, uint8 Size)
//********************************************************************************************
{
    uint8 i, *a = A, *b = B;
    for(i = 0; i < Size; i++)
        if(a[i] != b[i])
            return 0;
    return 1;
}

//********************************************************************************************
void EmptyBytes(void *D, uint16 size)
//********************************************************************************************
{
    uint16 i;
    uint8* data = (uint8*)D;
    for(i = 0; i < size; i++)
    {
        *data++ = 0;
    }
}

//********************************************************************************************
void ReadBPB(void)
//********************************************************************************************
{
    //FAT_BPB* BPB = (FAT_BPB*)BUFFER;
    ReadBlock(0);

    BPB_BytesPerSec = BUFFER[11]|BUFFER[12]<<8;
    BPB_SecPerClus = BUFFER[13];
       // BPB_SecPerClus=BPB->BPB_SecPerClus;
    BPB_RsvdSecCnt = BUFFER[14]|BUFFER[15]<<8;
       //BPB_RsvdSecCnt=BPB->BPB_RsvdSecCnt;
    BPB_NumFATs = BUFFER[16];
        //BPB_NumFATs=BPB->BPB_NumFATs;
    BPB_RootEntCnt =BUFFER[17]|BUFFER[18]<<8;
    BPB_TotSec16 = BUFFER[19]|BUFFER[20]<<8;
    BPB_FATSz16 = BUFFER[22]|BUFFER[23]<<8;
        //BPB_HiddSec=BPB->BPB_HiddSec;

        BPB_HiddSec=BUFFER[30]|BUFFER[31]<<8;
        BPB_HiddSec<<=16;
        BPB_HiddSec |= BUFFER[28]|BUFFER[29]<<8;

        BPB_TotSec32= BUFFER[34]|BUFFER[35]<<8;
        BPB_TotSec32<<=16;
        BPB_TotSec32|= BUFFER[32]|BUFFER[33]<<8;

}

//********************************************************************************************
uint32 DirStartSec(void)//根目录起始记扇区
//********************************************************************************************
{
    return BPB_RsvdSecCnt + BPB_NumFATs * BPB_FATSz16;
}

//********************************************************************************************
uint32 DataStartSec(void)//数据起始扇区
//********************************************************************************************
{
    return (uint32)(DirStartSec() + BPB_RootEntCnt * 32 / BPB_BytesPerSec);

}

//********************************************************************************************
uint16 GetDirSecCount(void)
//********************************************************************************************
{
    return BPB_RootEntCnt * 32 / 512;
}

//********************************************************************************************
uint32 ClusConvLBA(uint16 ClusID)//簇转换为LBA(逻辑块地址)
//********************************************************************************************
{
    return DataStartSec() + BPB_SecPerClus * (ClusID - 2);
    
}

//********************************************************************************************
uint16 ReadFAT(uint16 Index)//ReadFAT
//********************************************************************************************
{
    uint16 *RAM = (uint16*)BUFFER;
    ReadBlock(BPB_RsvdSecCnt + Index / 256);
    return RAM[Index % 256];
}

//********************************************************************************************
void WriteFAT(uint16 Index, uint16 Value)//WriteFAT
//********************************************************************************************
{
    uint16 *RAM = (uint16*)BUFFER;
    uint32 SecID;
    SecID = BPB_RsvdSecCnt + Index / 256;
    ReadBlock(SecID);
    RAM[Index % 256] = Value;
    WriteBlock(SecID);
}

//********************************************************************************************
uint16 GetEmptyDIR()
//********************************************************************************************
{
    uint16 DirSecCut, DirStart, i, m, ID = 0;
    DirSecCut = GetDirSecCount();
    DirStart = DirStartSec();
    for(i = 0; i < DirSecCut; i++)
    {
        ReadBlock(DirStart + i);
        for(m = 0; m < 16; m++)
    	{
            if((BUFFER[m * 32] == 0) || (BUFFER[m * 32] == 0xe5))
                return ID;
        	else
            	ID++;
    	}
    }
    return ID;
}

//********************************************************************************************
uint8 GetFileID(uint8* Name, DIR* ID)
//********************************************************************************************
{
    uint16 DirSecCut, DirStart, i, m;
    DirSecCut = GetDirSecCount();
    DirStart = DirStartSec();
    for(i = 0; i < DirSecCut; i++)
    {
                ReadBlock(DirStart + i);

        for(m = 0; m <16; m++)
    	{
            if(IsEqual(Name, &((DIR*)&BUFFER[m * 32])->FileName, 11))
    		{
                *ID = *((DIR*)&BUFFER[m * 32]);

                               return 1;
    		}
    	}
    }
    return 0;
}

//********************************************************************************************
uint16 GetNextFAT(void)
//********************************************************************************************
{
    uint16 FAT_Count, i;
    FAT_Count = BPB_FATSz16 * 256;
    for(i = 0; i < FAT_Count; i++)
    {
        if(ReadFAT(i) == 0)
            return i;
    }
    return 0;
}

//********************************************************************************************
void ReadDIR(uint16 Index, DIR* Value)
//********************************************************************************************
{
    uint32 DirStart = DirStartSec();
    ReadBlock(DirStart + Index / 16);
    CopyBytes(&BUFFER[(Index % 16) * 32], Value, 32);
}

//********************************************************************************************
void WriteDIR(uint16 Index, DIR* Value)
//********************************************************************************************
{
    uint32 LBA = DirStartSec() + Index / 16;
    ReadBlock(LBA);
    CopyBytes(Value, &BUFFER[(Index % 16) * 32], 32);
    WriteBlock(LBA);
}
//********************************************************************************************
uint8 CreateFile(uint8* FileName, uint32 Size)
//********************************************************************************************
{
    uint16 ClusID, ClusNum, ClusNext, i;
    DIR FileDir;
        if(GetFileID(FileName,&FileDir)==1)
        return 0;  // 文件存在，不创建 
    ClusNum = Size / (BPB_SecPerClus * 512) + 1;
    EmptyBytes(&FileDir, sizeof(DIR));
    CopyBytes(FileName, &FileDir.FileName, 11);
    FileDir.FilePosit.Size = Size;
    FileDir.FilePosit.Start = GetNextFAT();
    ClusID = FileDir.FilePosit.Start;
    for(i = 0; i < ClusNum - 1; i++)
    {
        WriteFAT(ClusID, 0xffff);
        ClusNext = GetNextFAT();
        WriteFAT(ClusID, ClusNext);
        ClusID = ClusNext;
    }
    WriteFAT(ClusID, 0xffff);
    WriteDIR(GetEmptyDIR(), &FileDir);
        GetEmptyFile(FileName, Size);
        return 1;
}

//********************************************************************************************
void CopyFAT(void)
//********************************************************************************************
{
    uint16 FATSz16, RsvdSecCnt, i;
    FATSz16 = BPB_FATSz16;
    RsvdSecCnt = BPB_RsvdSecCnt;
    for(i = 0; i < FATSz16; i++)
    {
        ReadBlock(RsvdSecCnt + i);
        WriteBlock(RsvdSecCnt + FATSz16 + i);
    }
}

//********************************************************************************************
uint8 OperateFile(uint8 Write ,uint8* Name, uint32 Start, uint32 Length, void* Data)
//********************************************************************************************
{
    uint8 *data = Data;
    uint16 BytePerClus, SecPerClus, ClusNum, ClusID, m;
    uint32 LBA, i;
    DIR FileDir;
    SecPerClus = BPB_SecPerClus;
    BytePerClus = BPB_SecPerClus * 512;
    if(GetFileID(Name, &FileDir)!=1)
    return 0;

    ClusNum = Start / BytePerClus;
    ClusID = FileDir.FilePosit.Start;
    for(i = 0; i < ClusNum; i++)
    ClusID = ReadFAT(ClusID);


    i = (Start % BytePerClus) / 512;


    m = (Start % BytePerClus) % 512;

    LBA = ClusConvLBA(ClusID) + m;

    if(Write)
        ReadBlock(LBA);
    else
        ReadBlock(LBA++);

    goto Start;

    while(1)
    {
        ClusID = ReadFAT(ClusID);
        LBA = ClusConvLBA(ClusID);
        for(i = 0; i < SecPerClus; i++)
    	{
            if(Write)
                ReadBlock(LBA);
        	else
                ReadBlock(LBA++);

            for(m = 0; m < 512; m++)
    		{
Start:
                if(Write)
                    BUFFER[m] = *data++;
        		else
                    *data++ = BUFFER[m];

    			
                if(--Length == 0)
        		{
                	if(Write)
                        WriteBlock(LBA);
                	return 1;
        		}
    		}
            if(Write)
                WriteBlock(LBA++);
    	}
    }
}

void GetEmptyFile(uint8* Name, uint32 size)
{
    uint32 i;
    uint8 buff[512] = {0};
    for(i=0;i<size/512;i++)
      OperateFile(1, Name, 512*i, 512, buff);
}