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

📄 hpi.c

📁 USB U 盘 开发的源代码
💻 C
📖 第 1 页 / 共 2 页
字号:
{
	unsigned int  len,sector,i,cnum,tlen;
	unsigned char bSuccess,bStop;
	
	if(!bFlags.bits.SLAVE_IS_ATTACHED)
		return FALSE;		
	if(!ThisFile.bFileOpen)
		return FALSE;
	ThisFile.bFileOpen=0;
	bSuccess=1;
	bStop=0;
	tlen=0;

	while(writeLength>0)
	{
		if(writeLength+ThisFile.OffsetofSector>DeviceInfo.BPB_BytesPerSec)
		   	len=DeviceInfo.BPB_BytesPerSec;
		else
		   	len=writeLength+ThisFile.OffsetofSector;
		   
		 //////////////////////////////////////////////////////
		 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=CreateClusterLink(ThisFile.ClusterPointer);
		 		 if(ThisFile.ClusterPointer==0x00)
		 		 	return FALSE;		 		
		 		 ThisFile.SectorPointer=FirstSectorofCluster(ThisFile.ClusterPointer); 	
		   	}
		   	else
		   		ThisFile.SectorPointer=ThisFile.SectorPointer+1;
		    }
		
	
	}//end while
	ThisFile.pointer+=tlen;
	///////////更新文件目录信息/////////////////////////////
	if(bSuccess==1)
	{
		if(DirStartCluster==0)	
		{
		for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
	    	{   
		//////////////////////////////////////////////////
		if(!RBC_Read(DeviceInfo.RootStartSector+sector,1,DBUF))
			return FALSE;				
		///////////////////////////////////////////////////
		for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
			{
			cnum=LSwapINT16(DBUF[i+26],DBUF[i+27]);
			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(DeviceInfo.RootStartSector+sector,1,DBUF))
		   			return FALSE;		   	
				 bStop=1;
				 break;
				}
			}
		if(bStop==1)
			break;		
	       }
		}
//////////////////////////////////////////////////////////////////////////////
		else
		{
			NowCluster=DirStartCluster;		
			do
			{
				NowSector=FirstSectorofCluster(NowCluster);
				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=LSwapINT16(DBUF[i+26],DBUF[i+27]);
						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;
				NowCluster=GetNextClusterNum(NowCluster);			
			}while(NowCluster<=0xffef);
		
		if(NowCluster>0xffef)
	    	return FALSE;
		}
	}
	
	ThisFile.bFileOpen=1;
	//////////////////////////////////////////////
	return TRUE;
}

unsigned char RemoveFile(unsigned char *pBuffer)
{
	unsigned int sector,i;
	unsigned char bStop,j;
	int k;
		
	if(!bFlags.bits.SLAVE_IS_ATTACHED)
		return FALSE;		
	if(DirStartCluster==0)	
	{
	////////////// 清除目录/////////////////////////////////////
	for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
	    	{   
		//////////////////////////////////////////////////
		if(!RBC_Read(DeviceInfo.RootStartSector+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=LSwapINT16(DBUF[i+26],DBUF[i+27]);
			
				for(k=(i-32);k>=0;k=k-32)
					{
					if(DBUF[k+11]==0x0F)
						DBUF[k]=0xE5;
					else
						break;
					}
				DelayMs(15);
				if(!RBC_Write(DeviceInfo.RootStartSector+sector,1,DBUF))
					return FALSE;
/*
			 	k=sector-1;
				if(k>=0)
					{
					if(!RBC_Read(DeviceInfo.RootStartSector+k,1,DBUF))
						return FALSE;	
					for(k=DeviceInfo.BPB_BytesPerSec;k>=0;k=k-32)
						{
						if(DBUF[k+11]==0x0F)
							DBUF[k]=0xE5;
						else
							break;
						}
				//	DelayMs(15);
			 		if(!RBC_Write(DeviceInfo.RootStartSector+sector-1,1,DBUF))
						return FALSE;
					}
*/			
				//////////////////// 清除FAT中的纪录////////////////////////
				DelayMs(10);
				if(!DeleteClusterLink(ThisFile.StartCluster))
					return FALSE;					
			 	bStop=1;
			 	break;
			 	}
			
			}//end for
		if(bStop==1)
			break;
		
	       }//end search
	if(sector>=DeviceInfo.BPB_RootEntCnt)
		return FALSE;	
	}
	else
	{
	NowCluster=DirStartCluster;		
		do
		{
			NowSector=FirstSectorofCluster(NowCluster);
			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=LSwapINT16(DBUF[i+26],DBUF[i+27]);
						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(!DeleteClusterLink(ThisFile.StartCluster))
							return FALSE;					
					 	bStop=1;
					 	break;
						}
				}
				if(bStop==1)break;		
	    	}
			if(bStop==1)break;	
			NowCluster=GetNextClusterNum(NowCluster);			
		}while(NowCluster<=0xffef);
		
		if(NowCluster>0xffef)
	    	return FALSE;
	}
	return TRUE;
}

unsigned char GetCapacity(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_FATSz16+DeviceInfo.FatStartSector)
	{
		
		if(RBC_Read(sectorNum,1,DBUF))
		{
		  for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+2)
		  	{		  	 
		  	 if((DBUF[i]==0x00)&&(DBUF[i+1]==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 CreateDir(unsigned long len,unsigned char *pBuffer,unsigned char *pName)
{
	unsigned int sector,i,j,DirCount;
	unsigned int cnum,ClusterPointer;
	unsigned char xdata bstop,InByte,bwrite;
	
	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=GetFreeCusterNum();
	if(cnum<0x02)
		return FALSE;	

	pBuffer[11]=0x10;
	pBuffer[26]=(unsigned char)(cnum);
	pBuffer[27]=(unsigned char)(cnum>>8);
	pBuffer[28]=0;pBuffer[29]=0;pBuffer[30]=0;pBuffer[31]=0;
	bstop=0;

	if(DirStartCluster==0)	
	{
	/////// Search a free space in the root dir space and build the item ///
	for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
	    {   
		if(!RBC_Read(DeviceInfo.RootStartSector+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(DeviceInfo.RootStartSector+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(DeviceInfo.RootStartSector+sector,1,DBUF))
		  	 		return FALSE;		  	 		
				bstop=1;
				break;
				}
			 }
			}		
		if(bstop==1)break;	

		if((len!=0)&&(bwrite==1))
			{
			if(!RBC_Write(DeviceInfo.RootStartSector+sector,1,DBUF))
		  		return FALSE;
	    	}
	    }

	if(sector>=DeviceInfo.BPB_RootEntCnt)
		return FALSE;
	}
////////////////////////////////////////////////////////////
	else
	{
		NowCluster=DirStartCluster;		
		do
		{
			NowSector=FirstSectorofCluster(NowCluster);
			ClusterPointer=NowCluster;
			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;
	
			NowCluster=GetNextClusterNum(NowCluster);
			if(NowCluster>0xffef)
	    	{
			NowCluster=CreateClusterLink(ClusterPointer);
		 	if(NowCluster==0x00)
		 		 return FALSE;
			NowSector=FirstSectorofCluster(NowCluster);
			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(NowCluster<=0xffef);
	
	if(NowCluster>0xffef)
	    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];
	DBUF[58]=(unsigned char)(DirStartCluster);
	DBUF[59]=(unsigned char)(DirStartCluster>>8);

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

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

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

	if(DirStartCluster==0)	//Root Dir
	{
	for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
	    {   
		if(!RBC_Read(DeviceInfo.RootStartSector+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(sector>=DeviceInfo.BPB_RootEntCnt)
	    	return FALSE;		
	    	
	DirStartCluster=LSwapINT16(DBUF[i+26],DBUF[i+27]);
//	ThisFile.ClusterPointer=DirStartCluster;
	ThisFile.ClusterPointer=0;
	return TRUE;
	}
	////////////////////////////////////////////
	else
	{
		NowCluster=DirStartCluster;		
		do
		{
			NowSector=FirstSectorofCluster(NowCluster);
			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;	
			NowCluster=GetNextClusterNum(NowCluster);			
		}while(NowCluster<=0xffef);
		
	if(NowCluster>0xffef)
	    	return FALSE;
		
	DirStartCluster=LSwapINT16(DBUF[i+26],DBUF[i+27]);
//	ThisFile.ClusterPointer=DirStartCluster;
	ThisFile.ClusterPointer=0;		
	return TRUE;		
	}
}

unsigned char UpDir()
{
	if(!bFlags.bits.SLAVE_IS_ATTACHED)
		return FALSE;	
	if(DirStartCluster==0)	//Root Dir
		return TRUE;	
	
	ThisFile.bFileOpen=0;

	NowSector=FirstSectorofCluster(DirStartCluster);
	if(!RBC_Read(NowSector,1,DBUF))
			return FALSE;
	if(DBUF[32]!=0x2e&&DBUF[33]!=0x2e)	//..
			return FALSE;
	
	DirStartCluster=LSwapINT16(DBUF[58],DBUF[59]);
//	ThisFile.ClusterPointer=DirStartCluster;
	ThisFile.ClusterPointer=0;		
	return TRUE;
}

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

	ThisFile.bFileOpen=0;
	DirStartCluster=0;	//Root Dir
			
	return TRUE;
}

⌨️ 快捷键说明

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