hpi32.c

能用51读写U盘...创建文件格式...能自由创建文件.删除.读写

		   
		 //////////////////////////////////////////////////////
		 if(ThisFile.OffsetofSector>0)
		 	{
		 	if(RBC_Read(ThisFile.SectorPointer,1,DBUF))
		   		{
		   		
		   		len=len-ThisFile.OffsetofSector;
		   		for(i=0;i<len;i++)		   			
		   			DBUF[ThisFile.OffsetofSector+i]=*(pBuffer+i);
		   		if(!RBC_Write(ThisFile.SectorPointer,1,DBUF))
		   			return FALSE;			   			
		   		ThisFile.OffsetofSector=ThisFile.OffsetofSector+len;
		   		}
		   	else
		   		return FALSE;		   		
		 	}
		 else
		 	{
		 	if(!RBC_Write(ThisFile.SectorPointer,1,pBuffer+tlen))
		   		return FALSE;		   		
		   	ThisFile.OffsetofSector=len;
		 	}
		 /////////////////////////////////////////////////////
		   writeLength-=len;
		   tlen+=len;
		 /////////////更新文件指针 //////////////////////////////
		  if(ThisFile.OffsetofSector>DeviceInfo.BPB_BytesPerSec-1)
		   {	
		   	ThisFile.OffsetofSector-=DeviceInfo.BPB_BytesPerSec;
		   	ThisFile.SectorofCluster+=1;
		   	if(ThisFile.SectorofCluster>DeviceInfo.BPB_SecPerClus-1)
		   	{
		   		ThisFile.SectorofCluster=0;
		 		 ThisFile.ClusterPointer=CreateClusterLink32(ThisFile.ClusterPointer);
		 		 if(ThisFile.ClusterPointer==0x00)
		 		 	return FALSE;		 		
		 		 ThisFile.SectorPointer=FirstSectorofCluster32(ThisFile.ClusterPointer); 	
		   	}
		   	else
		   		ThisFile.SectorPointer=ThisFile.SectorPointer+1;
		    }
		
	
	}//end while
	ThisFile.pointer+=tlen;
	///////////更新文件目录信息/////////////////////////////
	if(bSuccess==1)
	{
		NowCluster32=DirStartCluster32;		
			do
			{
				NowSector=FirstSectorofCluster32(NowCluster32);
				for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
	   		 	{   
					if(!RBC_Read(NowSector+sector,1,DBUF))
						return FALSE;				
					for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
					{
						cnum=LSwapINT32(DBUF[i+26],DBUF[i+27],DBUF[i+20],DBUF[i+21]);
						if((cnum==ThisFile.StartCluster)&&(DBUF[i]!=0xe5))
							{
							if(ThisFile.pointer>ThisFile.LengthInByte)
								ThisFile.LengthInByte=ThisFile.pointer;				
							DBUF[i+28]=(unsigned char)(ThisFile.LengthInByte&0xff);
							DBUF[i+29]=(unsigned char)((ThisFile.LengthInByte>>8)&0xff);
							DBUF[i+30]=(unsigned char)((ThisFile.LengthInByte>>16)&0xff);
							DBUF[i+31]=(unsigned char)((ThisFile.LengthInByte>>24)&0xff);
							if(!RBC_Write(NowSector+sector,1,DBUF))
		   						return FALSE;		   	
							 bStop=1;
							 break;
							}							
	    			}
					if(bStop==1)break;
				}
				if(bStop==1)break;
				NowCluster32=GetNextClusterNum32(NowCluster32);			
			}while(NowCluster32<=DeviceInfo.TotCluster);
		
		if(NowCluster32>DeviceInfo.TotCluster)
	    	return FALSE;		
	}
	
	ThisFile.bFileOpen=1;
	//////////////////////////////////////////////
	return TRUE;
}


unsigned char RemoveFile32(unsigned char *pBuffer)
{
	unsigned int sector,i;
	unsigned char bStop,j;
	int k;
		
	if(!bFlags.bits.SLAVE_IS_ATTACHED)
		return FALSE;
////////////// 清除目录/////////////////////////////////////		
	NowCluster32=DirStartCluster32;		
		do
		{
			NowSector=FirstSectorofCluster32(NowCluster32);
			for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
	    	{   
				if(!RBC_Read(NowSector+sector,1,DBUF))
					return FALSE;				
				for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
				{
					if(DBUF[i]==0x00)
						return FALSE;
					j=0;
					while(DBUF[i+j]==*(pBuffer+j))
					{
						 j=j+1;
						 if(j>10)
						 	break;
					}
					if(j>10)
				    	{ 
						DBUF[i]=0xE5;
						ThisFile.StartCluster=LSwapINT32(DBUF[i+26],DBUF[i+27],DBUF[i+20],DBUF[i+21]);
					 	for(k=(i-32);k>=0;k=k-32)
						{
						if(DBUF[k+11]==0x0F)
							DBUF[k]=0xE5;
						else
							break;
						}
					 	DelayMs(15);
					 	if(!RBC_Write(NowSector+sector,1,DBUF))
							return FALSE;					
				//////////////////// 清除FAT中的纪录////////////////////////
						DelayMs(10);
						if(!DeleteClusterLink32(ThisFile.StartCluster))
							return FALSE;					
					 	bStop=1;
					 	break;
						}
				}
				if(bStop==1)break;		
	    	}
			if(bStop==1)break;	
			NowCluster32=GetNextClusterNum32(NowCluster32);			
		}while(NowCluster32<=DeviceInfo.TotCluster);	
	
	if(NowCluster32>DeviceInfo.TotCluster)
	    return FALSE;
	
	return TRUE;
}


unsigned char GetCapacity32(void)
{
	unsigned int sectorNum,i;	
	unsigned long FreeSize,Freesectorcnt;

	if(!bFlags.bits.SLAVE_IS_ATTACHED)
		return FALSE;
		
	////////////////////////////////////////////////////////////////////////
	sectorNum=DeviceInfo.FatStartSector;
	Freesectorcnt=0;
	while(sectorNum<DeviceInfo.BPB_FATSz32+DeviceInfo.FatStartSector)
	{
		
		if(RBC_Read(sectorNum,1,DBUF))
		{
		  for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+4)
		  	{		  	 
		  	 if((DBUF[i]||DBUF[i+1]||DBUF[i+2]||DBUF[i+3])==0x00)
		  	 	{	
		  	 	Freesectorcnt++;
		  	 	}	  
		  	}	
		}
		else			
			return FALSE;			
		sectorNum++;
	}
	
	////////////////////////////////////////////////////////////////////////
	FreeSize=DeviceInfo.BPB_BytesPerSec*DeviceInfo.BPB_SecPerClus;
	FreeSize=Freesectorcnt*FreeSize;
	
	UARTBUF[0]=(unsigned char)((FreeSize>>24)&0xff);
	UARTBUF[1]=(unsigned char)((FreeSize>>16)&0xff);
	UARTBUF[2]=(unsigned char)((FreeSize>>8)&0xff);
	UARTBUF[3]=(unsigned char)(FreeSize&0xff);
	Response.len=4;
	return TRUE;
}


unsigned char CreateDir32(unsigned long len,unsigned char *pBuffer,unsigned char *pName)
{
	unsigned int sector,i,j,DirCount;
	unsigned long cnum;
	unsigned char xdata bstop,InByte,bwrite;
	unsigned long ClusterPointer;
	
	if(!bFlags.bits.SLAVE_IS_ATTACHED)
		return FALSE;
	if((len%32)!=0)
		return FALSE;
	if((len+32)>DeviceInfo.BPB_BytesPerSec)
		return FALSE;

	ThisFile.bFileOpen=0;
	ThisFile.FatSectorPointer=0;

	cnum=GetFreeCusterNum32();
	if(cnum<0x02)
		return FALSE;	
	
	pBuffer[11]=0x10;
	pBuffer[21]=(unsigned char)(cnum>>24);
	pBuffer[20]=(unsigned char)(cnum>>16);
	pBuffer[27]=(unsigned char)(cnum>>8);
	pBuffer[26]=(unsigned char)(cnum);
	pBuffer[28]=0;pBuffer[29]=0;pBuffer[30]=0;pBuffer[31]=0;
	bstop=0;

	NowCluster32=DirStartCluster32;		
		do
		{
			NowSector=FirstSectorofCluster32(NowCluster32);
			ClusterPointer=NowCluster32;
			for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
	    	{   
				if(!RBC_Read(NowSector+sector,1,DBUF))
					return FALSE;
				DirCount=0;bwrite=0;
				for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
				{
				if(len==0)
					{
					if((DBUF[i]==0x00)||(DBUF[i]==0xE5))
					{
					for(j=0;j<32;j++)
						DBUF[i+j]=*(pBuffer+j);
					if(!RBC_Write(NowSector+sector,1,DBUF))
		  	 			return FALSE;		  	 		
					bstop=1;
					break;
					}		
					}
				else
				{
				if(DirCount==0)
					InByte=i;
				if(DBUF[i]==0xE5)				
					DirCount++;				
				else if(DBUF[i]==0x00)
					{	
					DirCount++;	
					DBUF[i]=0xE5;
					bwrite=1;					
					}
				else
					DirCount=0;

				if((DirCount*32)>=(len+32))
					{
					for(j=0;j<len;j++)
						DBUF[InByte+j]=*(pName+j);
					for(j=0;j<32;j++)
						DBUF[InByte+len+j]=*(pBuffer+j);
					if(!RBC_Write(NowSector+sector,1,DBUF))
		  		 		return FALSE;		  	 		
					bstop=1;
					break;
					}
				 }			
				}
				if(bstop==1)break;
				if((len!=0)&&(bwrite==1))
				{
				if(!RBC_Write(NowSector+sector,1,DBUF))
		  			return FALSE;
	    		}
	    	}
			if(bstop==1)break;
	
			NowCluster32=GetNextClusterNum32(NowCluster32);
			if(NowCluster32>DeviceInfo.TotCluster)
	    	{
			NowCluster32=CreateClusterLink32(ClusterPointer);
		 	if(NowCluster32==0x00)
		 		 return FALSE;
			NowSector=FirstSectorofCluster32(NowCluster32);
			for(i=0;i<DeviceInfo.BPB_BytesPerSec;i++) DBUF[i]=0x00;
			for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
				{
				if(!RBC_Write(NowSector+sector,1,DBUF))
		  	 		return FALSE;
				}
			}
		}while(NowCluster32<=DeviceInfo.TotCluster);
	
	if(NowCluster32>DeviceInfo.TotCluster)
	    return FALSE;
////////////////////////////////////////////////////////////////
	for(i=64;i<DeviceInfo.BPB_BytesPerSec;i++)	DBUF[i]=0x00;
	
	for(i=0;i<43;i++) DBUF[i]=0x20;
	
	DBUF[0]=0x2e;
	for(i=11;i<32;i++) DBUF[i]=pBuffer[i];

	DBUF[32]=0x2e;DBUF[33]=0x2e;
	for(i=43;i<64;i++) DBUF[i]=pBuffer[i-32];

	if(DirStartCluster32==DeviceInfo.RootStartCluster)	//Root Dir
		{
		DBUF[53]=0;DBUF[52]=0;DBUF[59]=0;DBUF[58]=0;
		}
	else
		{
		DBUF[53]=(unsigned char)(DirStartCluster32>>24);
		DBUF[52]=(unsigned char)(DirStartCluster32>>16);
		DBUF[59]=(unsigned char)(DirStartCluster32>>8);
		DBUF[58]=(unsigned char)(DirStartCluster32);
		}

	NowSector=FirstSectorofCluster32(cnum);
	if(!RBC_Write(NowSector,1,DBUF))
		return FALSE;	

	DirStartCluster32=cnum;
//	ThisFile.ClusterPointer=DirStartCluster32;
	ThisFile.ClusterPointer=0;		
	return TRUE;	
}

unsigned char DownDir32(unsigned char *pBuffer)
{
	unsigned int i;
	unsigned char j,bstop,sector;	
		
	if(!bFlags.bits.SLAVE_IS_ATTACHED)
		return FALSE;	
	
	ThisFile.bFileOpen=0;
	bstop=0;

	NowCluster32=DirStartCluster32;		
		do
		{
			NowSector=FirstSectorofCluster32(NowCluster32);
			for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
	    	{   
				if(!RBC_Read(NowSector+sector,1,DBUF))
					return FALSE;				
				for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
				{
					if(DBUF[i]==0x00)
						return FALSE;
					j=0;
					while(DBUF[i+j]==*(pBuffer+j))
					{
						 j=j+1;
						 if(j>10)
						 	break;
					}
					if(j>10&&(DBUF[i+11]&0x10))
				    	{bstop=1;break;}
				}
				if(bstop==1)break;		
	    	}
			if(bstop==1)break;	
			NowCluster32=GetNextClusterNum32(NowCluster32);			
		}while(NowCluster32<=DeviceInfo.TotCluster);
		
	if(NowCluster32>DeviceInfo.TotCluster)
	   	return FALSE;

	DirStartCluster32=LSwapINT32(DBUF[i+26],DBUF[i+27],DBUF[i+20],DBUF[i+21]);	
//	ThisFile.ClusterPointer=DirStartCluster32;
	ThisFile.ClusterPointer=0;		
	return TRUE;
}

unsigned char UpDir32()
{
	if(!bFlags.bits.SLAVE_IS_ATTACHED)
		return FALSE;	
	if(DirStartCluster32==DeviceInfo.RootStartCluster)	//Root Dir
		return TRUE;	
	
	ThisFile.bFileOpen=0;

	NowSector=FirstSectorofCluster32(DirStartCluster32);
	if(!RBC_Read(NowSector,1,DBUF))
			return FALSE;
	if(DBUF[32]!=0x2e&&DBUF[33]!=0x2e)	//..
			return FALSE;

	DirStartCluster32=LSwapINT32(DBUF[58],DBUF[59],DBUF[52],DBUF[53]);
	if(DirStartCluster32==0)	//Root Dir
		DirStartCluster32=DeviceInfo.RootStartCluster;	
//	ThisFile.ClusterPointer=DirStartCluster32;
	ThisFile.ClusterPointer=0;		
	return TRUE;
}

unsigned char UpRootDir32()
{
	if(!bFlags.bits.SLAVE_IS_ATTACHED)
		return FALSE;

	ThisFile.bFileOpen=0;
	DirStartCluster32=DeviceInfo.RootStartCluster;	//Root Dir
			
	return TRUE;
}

unsigned char GetDriveNum()
{
	Response.len=1;
	UARTBUF[0]=DeviceInfo.DriveNum;
	return TRUE;
}

unsigned char SelectDrive(unsigned char Drive_Num)//Drive_Num=0,1,2,....
{
	unsigned int ReservedSectorsNum;
	
	if(Drive_Num>=DeviceInfo.DriveNum)
		return FALSE;

	bFlags.bits.SLAVE_IS_ATTACHED=0;
	if(!RBC_Read(DeviceInfo.StartSector[Drive_Num],1,DBUF))
		return FALSE;

	DeviceInfo.BPB_BytesPerSec=LSwapINT16(DBUF[11],DBUF[12]);
	DeviceInfo.BPB_SecPerClus=DBUF[13];
	ReservedSectorsNum=LSwapINT16(DBUF[14],DBUF[15]);
	DeviceInfo.BPB_NumFATs=DBUF[16];

	//if(DBUF[82]=='F'&&DBUF[83]=='A'&&DBUF[84]=='T'&&DBUF[85]=='3'&&DBUF[86]=='2')
	if(DeviceInfo.par_FAT[Drive_Num]==1)	//FAT32
		{
		DeviceInfo.BPB_TotSec32=LSwapINT32(DBUF[32],DBUF[33],DBUF[34],DBUF[35]);
		DeviceInfo.BPB_FATSz32=LSwapINT32(DBUF[36],DBUF[37],DBUF[38],DBUF[39]);
		DeviceInfo.RootStartCluster=LSwapINT32(DBUF[44],DBUF[45],DBUF[46],DBUF[47]);
		DeviceInfo.FatStartSector=DeviceInfo.StartSector[Drive_Num]+ReservedSectorsNum;
		DeviceInfo.FirstDataSector=DeviceInfo.FatStartSector+DeviceInfo.BPB_NumFATs*DeviceInfo.BPB_FATSz32;
		DeviceInfo.TotCluster=(DeviceInfo.BPB_TotSec32-DeviceInfo.FirstDataSector+1)/DeviceInfo.BPB_SecPerClus+1;
		DirStartCluster32=DeviceInfo.RootStartCluster;
		DeviceInfo.FAT=1;	//FAT16=0,FAT32=1;
		}
	else	//FAT16
		{		
		DeviceInfo.BPB_RootEntCnt=LSwapINT16(DBUF[17],DBUF[18]);
		DeviceInfo.BPB_RootEntCnt=(DeviceInfo.BPB_RootEntCnt)*32/DeviceInfo.BPB_BytesPerSec;	
		DeviceInfo.BPB_TotSec16=LSwapINT16(DBUF[19],DBUF[20]);	
		DeviceInfo.BPB_FATSz16=LSwapINT16(DBUF[22],DBUF[23]);			
		DeviceInfo.FatStartSector=DeviceInfo.StartSector[Drive_Num]+ReservedSectorsNum;
		DeviceInfo.RootStartSector=DeviceInfo.StartSector[Drive_Num]+DeviceInfo.BPB_NumFATs*DeviceInfo.BPB_FATSz16+ReservedSectorsNum;	
		DeviceInfo.FirstDataSector=DeviceInfo.FatStartSector+DeviceInfo.BPB_NumFATs*DeviceInfo.BPB_FATSz16+DeviceInfo.BPB_RootEntCnt;
		DeviceInfo.FAT=0;
		}

	///////////////////////////////////////////////////////
	bFlags.bits.SLAVE_IS_ATTACHED=1;
	ThisFile.bFileOpen=0;	
	///////////////////////////////////////////////////////
	return TRUE;
}