u_func_a.c

c8051f020+CH375读写U盘文件的程序

	  Fat[Currt_File].Ofst=St_Ofst_a;             //文件目录项所在的偏移量
	  if(*(pt+St_Ofst_a+6)==0x7e||*(pt+St_Ofst_a+5)==0x7e)
	   for(i=0;i<8;i++)
	     {		  
		     if(*(pt+St_Ofst_a+i)>0x7e)
		          {
				   rd_short=1;
				   break;
				   }
			 else rd_short=0;		  
		 }
	  else rd_short=1; 
	   if(rd_short)	   //是否为短文件名或是中文名
	      {
		   na=Fat[Currt_File].name;
		   for(j=0;j<8;j++)
		      *(na+j)=*(pt+St_Ofst_a+j);
		   *(na+8)=0;
		  }
	   else			   //若是长文件名
	    Get_Lfat_a();
	   Currt_File++;
//	   if(Currt_File==4) return  Currt_File;		
	  }
	St_Ofst_a+=32;
	
	if(St_Ofst_a==512)
	  {
	   	St_Ofst_a=0;
	    Rd_Rec.Currt_Sect++;
		Rd_Rec.Last_Sect=Rd_Rec.Currt_Sect-1;
		Rd_Rec.Next_Sect=Rd_Rec.Currt_Sect+1;
		Sect_Ofst_a++;
//	   return Currt_File; //
	   }	
	if(*(pt+St_Ofst_a)==0) 
	  {
	   St_Ofst_a=0;
	   return 0xff;	//文件名已读完，返回0xff
	  }
   }
 return Currt_File;
}			

/*******************************************************************************
------键盘处理---------------------------------------------------
********************************************************************************
说明: 入口参数：无
	  出口参数：0
*******************************************************************************/
unsigned char Key_Opare_a()
{ 
 signed char Key,i=0,j;
// LCD_Printf(1,1,">>");
CurrtChainNum=0;	
 while(1)
  {
   Key=Wait_Infrared();
   switch(Key)
     {
	   case UP:     i--;break;
	   case DOWN:   i++;break; 
	   case OK:     Opr_Menu_a(i);i=0;break;
	   case CANCEL: if(CurrtChainNum==0) break;	                
					CurrtChainNum-=2;
	                i=0;
					Dis_Fat_In_Clust_a(ClustChain[CurrtChainNum]);
					CurrtChainNum++;
					break;
	   case 0x0b:   return 0;       //系统重新开始
	 }
	 if(i>=Currt_File) i=Currt_File-1;
	 if((i/4)==(Currt_File/4))
	 {
	  j=1;
	  LCD_Clear ();
	  while((j+(i/4)*4)<=Currt_File)
	    {
		 PrintfFat(j,2,(j-1)+(i/4)*4);
		 j++;
		}
	 }
	 else
	 {
//	  LCD_Clear ();
		for(j=1;j<=4;j++)
		  PrintfFat(j,2,(j-1)+(i/4)*4);
	  }
   switch(i%4)
     {
      case -1:    i=0;break;
//	  case 4:	  return 0x00;
	  case 0:     LCD_Printf(1,1,">>");
	              LCD_Printf(2,1,"  ");
				  LCD_Printf(3,1,"  ");
				  LCD_Printf(4,1,"  ");
				  break; 
	  case 1:     LCD_Printf(2,1,">>");
	              LCD_Printf(1,1,"  ");
				  LCD_Printf(3,1,"  ");
				  LCD_Printf(4,1,"  ");
				  break; 
	  case 2:     LCD_Printf(3,1,">>");
	              LCD_Printf(2,1,"  ");
				  LCD_Printf(1,1,"  ");
				  LCD_Printf(4,1,"  ");
				  break; 
	  case 3:     LCD_Printf(4,1,">>");
	              LCD_Printf(2,1,"  ");
				  LCD_Printf(3,1,"  ");
				  LCD_Printf(1,1,"  ");
				  break; 
     }
   }
}


/*******************************************************************************
------文件处理程序---------------------------------------------------
********************************************************************************
说明: 若为文件夹，则打开，若为文件，则询问是否传输
      入口参数：文件号
	  出口参数：无
*******************************************************************************/
void Opr_Menu_a(unsigned char file_num)
{
 unsigned char *pt,Remain;
 unsigned long FirstClustB;
 pt=Fat[file_num].ext;
 if(CurrtChainNum==0)
   {
	ClustChain[CurrtChainNum]=2;
    CurrtChainNum=1;
   }
 if(*(pt)==0x20)
   {
    ClustChain[CurrtChainNum]=Fat[file_num].St_Clust.value;
    CurrtChainNum++;
	Dis_Fat_In_Clust_a(Fat[file_num].St_Clust.value);
   }
 else
   {
    LCD_Clear ();
    LCD_Printf(2,2,"发送到另一盘？");
	if(Wait_Infrared()==OK)
	   {
	    LCD_Clear ();
        LCD_Printf(2,2,"正在发送...");
	    FirstClustB=WrFAT_b(file_num);
		do{
		   Remain=ReadAA(file_num);
 		   Remain=WriteAB(FirstClustB,file_num);
	      }while(Remain==0xff);

	   	RdFDT_a(file_num);
		WrFDT_b(FirstClustB);
		Rd_Sector_b(root_b);
	   }
	else return;
   }
}

/*******************************************************************************
------读A盘FDT---------------------------------------------------
********************************************************************************
说明: 存入FDTBuf
      入口参数：文件号
	  出口参数：无
*******************************************************************************/
void RdFDT_a(unsigned char file_num)
{
 unsigned char xdata *pt;
 unsigned char i,j=0,LFile=0;
 unsigned int temp_ofst;
 pt=Data_Buf;
 Rd_Sector_a(Fat[file_num].Sector);
 temp_ofst=Fat[file_num].Ofst;
 for(i=0;i<32;i++)
   {
    FDTBuf.Buf[i]=*(pt+temp_ofst+i);
	FDTBuf.FDTNum=32;
	
	if(*(pt+temp_ofst+i)>=0x7e&&i<8)	//判断是否是长文件名
	   LFile=1;
	
   }
   j=1;
 if(LFile==0) return;
   
 do
   {
    if(temp_ofst==0)
	   {
	    Rd_Sector_a(Fat[file_num].Sector-1);
		temp_ofst=512;
		}
	 temp_ofst-=32;
	 for(i=0;i<32;i++)
	   {
	    FDTBuf.Buf[32*j+i]=*(pt+temp_ofst+i);
	   }
	 FDTBuf.FDTNum+=32;
	 j++;
   }while(*(pt+temp_ofst)<0x40);

}

/*******************************************************************************
------写B盘FDT---------------------------------------------------
********************************************************************************
说明: 入口参数：文件号
	  出口参数：无
*******************************************************************************/
void WrFDT_b(unsigned long FirstClust)
{
 unsigned char i,j,CtnsNum=0,SectOfst;
 unsigned char xdata *pt;
 unsigned int temp_ofst;
 pt=Data_Buf;
 FDTBuf.Buf[0x1a]=(unsigned char)FirstClust;		 //修改首簇号
 FDTBuf.Buf[0x1b]=(unsigned char)(FirstClust>>8);
 FDTBuf.Buf[0x14]=(unsigned char)(FirstClust>>16);
 FDTBuf.Buf[0x15]=(unsigned char)(FirstClust>>24);
 for(i=0;i<sect_clust_b;i++)
  {
   Rd_Sector_b(root_b+i);
   temp_ofst=0;
   for(j=0;j<16;j++)
      {
	   if(*(pt+j*32)==0||*(pt+j*32)==0xe5)
	      CtnsNum++;
	   else CtnsNum=0;
	   if(CtnsNum*32==FDTBuf.FDTNum)   //如果找到足够的FDT
	      {
		   temp_ofst=j*32;
		   break;
		  }
	  }
   if(j<16) 		   //如果是因为找到足够的FDT而跳出上一个循环
   	 {
	  SectOfst=i;
      break;
	 }
  }
  if(i==sect_clust_b) return;   //如果没找到空FDT
 for(i=0;i<CtnsNum;i++)
    {
	 for(j=0;j<32;j++)
	     {
		  *(pt+temp_ofst+j)=FDTBuf.Buf[32*i+j];
		 }
     if(temp_ofst==0)
	     {
		  Wr_Sector_b(root_b+SectOfst);
		  SectOfst--;
		  Rd_Sector_b(root_b+SectOfst);
		  temp_ofst=480;
		 }
	 else temp_ofst-=32;
	}
  Wr_Sector_b(root_b+SectOfst);
}

/*******************************************************************************
------写B盘FAT---------------------------------------------------
********************************************************************************
说明: 入口参数：文件号
	  出口参数：首簇号
*******************************************************************************/
unsigned long WrFAT_b(unsigned char file_num)
{
 unsigned char xdata *pt;
 unsigned char SectFirst,SectChange;
 UINT32 data ClustNum;
 UINT32 temp_clust;
 struct{
 	    unsigned long SectOfst;
		unsigned int ByteOfst;
       }c1,c2;
 unsigned long data i;
 unsigned char data j;
 unsigned long fat_b,ChangeClust=0,SumClust,FirstClust=0;
 pt=Data_Buf;

 SumClust=Fat[file_num].Big.value/(512*sect_clust_b)+1;
 fat_b=hidd_sect_b+resv_sect_b;
 for(i=0;i<sect_fat_b;i++)
    {
     Rd_Sector_b(fat_b+i);
	 SectFirst=1;
	 SectChange=0;
	 for(j=0;j<128;j++)
	    {
		 ClustNum.num[3]=*(pt+j*4);
		 ClustNum.num[2]=*(pt+j*4+1);
		 ClustNum.num[1]=*(pt+j*4+2);
		 ClustNum.num[0]=*(pt+j*4+3);
		 if(ClustNum.value==0)		 //是否为空
		    {
			 SectChange=1;
			 if(FirstClust==0)
			   {
				FirstClust=j+128*i;		 //首簇号
				c1.SectOfst=i;
				c1.ByteOfst=j*4;
				c2.SectOfst=i;
				c2.ByteOfst=j*4;
				SectFirst=0;
			 	}
			 else
			    {
				 c2.SectOfst=i;
				 c2.ByteOfst=j*4;
				 temp_clust.value=j+128*i;	  //c2指向的簇号
				 if(SectFirst==1)		//若为此扇区的第一空簇
				    {
					 Rd_Sector_b(fat_b+c1.SectOfst);
					 *(pt+c1.ByteOfst)=temp_clust.num[3];
					 *(pt+c1.ByteOfst+1)=temp_clust.num[2];
					 *(pt+c1.ByteOfst+2)=temp_clust.num[1];
					 *(pt+c1.ByteOfst+3)=temp_clust.num[0];
					 Wr_Sector_b(fat_b+c1.SectOfst);
					 Wr_Sector_b(fat_b+sect_fat_b+c1.SectOfst);	//写FAT2
					 Rd_Sector_b(fat_b+c2.SectOfst);
					 c1=c2;
					 SectFirst=0;	
					}
				  else
				    {
					 *(pt+c1.ByteOfst)=temp_clust.num[3];
					 *(pt+c1.ByteOfst+1)=temp_clust.num[2];
					 *(pt+c1.ByteOfst+2)=temp_clust.num[1];
					 *(pt+c1.ByteOfst+3)=temp_clust.num[0];
					 c1=c2;
					}					
				 }
			ChangeClust++;
			if(ChangeClust>=SumClust) 
			   {
			    *(pt+c2.ByteOfst)=0xff;
			    *(pt+c2.ByteOfst+1)=0xff;
				*(pt+c2.ByteOfst+2)=0xff;
				*(pt+c2.ByteOfst+3)=0x0f;
			    break;			    
			   }			
			}
		}
	  if(SectChange==1)
	      {
	       Wr_Sector_b(fat_b+i);//此扇区修改完毕，写入，注：最后一空簇可能未写
	       Wr_Sector_b(fat_b+sect_fat_b+c1.SectOfst);    //写FAT2
	       if(ChangeClust>=SumClust) return FirstClust;
		  }
	}
}

/*******************************************************************************
------读A盘文件的某一扇区---------------------------------------------------
********************************************************************************
说明: 写入单片机中数据缓冲区
      入口参数：文件号
	  出口参数：0x00:文件结束，0xff：文件还未读完
*******************************************************************************/
unsigned char ReadAA(unsigned char file_num)	
{
 static unsigned char data TempSectOfstAA;
 unsigned char xdata *Fpt;
 unsigned int data temp_ofst;
 static unsigned long data BaseSectAA,SumSectorAA,SectorAA=0;
 Fpt=FATBufA; 
 if(SectorAA==0)
    {
     ClusterA.NextClust.value=Fat[file_num].St_Clust.value;		   
     SumSectorAA=Fat[file_num].Big.value/512+1;
	}
 if(SectorAA<=SumSectorAA)
    {
	 
	 if(SectorAA%sect_clust_a==0)
	    {
		 
		 if(ClusterA.NextClust.value/128!=ClusterA.CurrtClust/128||SectorAA==0)
		    {
			 ClusterA.CurrtClust=ClusterA.NextClust.value;
			 Rd_FAT_a(ClusterA.NextClust.value/128+resv_sect_a+hidd_sect_a);
			}
		 else
		    {
			  ClusterA.CurrtClust=ClusterA.NextClust.value;
			}
			  temp_ofst=(ClusterA.CurrtClust%128)*4;			
			  ClusterA.NextClust.num[3]=*(Fpt+temp_ofst);
			  ClusterA.NextClust.num[2]=*(Fpt+temp_ofst+1);
			  ClusterA.NextClust.num[1]=*(Fpt+temp_ofst+2);
			  ClusterA.NextClust.num[0]=*(Fpt+temp_ofst+3);
			  BaseSectAA=(ClusterA.CurrtClust-2)*sect_clust_a+root_a;
			  TempSectOfstAA=0;			
		}
	 Rd_Sector_a(BaseSectAA+TempSectOfstAA);		   //读一扇区
	 TempSectOfstAA++;
	 SectorAA++;
	}
  if(SectorAA>=SumSectorAA)
    {
	 SectorAA=0;
     return 0x00;
	}
  else return 0xff;
}


/*******************************************************************************
------写B盘某一扇区---------------------------------------------------
********************************************************************************
说明: 入口参数：首簇号，文件号
	  出口参数：0x00:文件写结束，0xff：文件还未写完
*******************************************************************************/
unsigned char WriteAB(unsigned long FirstClust,unsigned char file_num)		//AB表示A为主盘，对B操作
{
 static unsigned char data TempSectOfstAB;
 unsigned char xdata *Fpt;
 unsigned int data temp_ofst;
 static unsigned long data SectorAB=0,SumSectorAB,BaseSectAB;
 Fpt=FATBufB;
 if(SectorAB==0)
     {
      ClusterB.NextClust.value=FirstClust;
      SumSectorAB=Fat[file_num].Big.value/512+1;
	 }
 if(SectorAB<=SumSectorAB)
    {
	 
	 if(SectorAB%sect_clust_b==0)
	    {
		 
		 if(ClusterB.NextClust.value/128!=ClusterB.CurrtClust/128||SectorAB==0)
		    {
			 ClusterB.CurrtClust=ClusterB.NextClust.value;
			 Rd_FAT_b(ClusterB.NextClust.value/128+resv_sect_b+hidd_sect_b);
			}
		 else
		    {
			  ClusterB.CurrtClust=ClusterB.NextClust.value;
			}
			  temp_ofst=(ClusterB.CurrtClust%128)*4;			
			  ClusterB.NextClust.num[3]=*(Fpt+temp_ofst);
			  ClusterB.NextClust.num[2]=*(Fpt+temp_ofst+1);
			  ClusterB.NextClust.num[1]=*(Fpt+temp_ofst+2);
			  ClusterB.NextClust.num[0]=*(Fpt+temp_ofst+3);
			  BaseSectAB=(ClusterB.CurrtClust-2)*sect_clust_b+root_b;
			  TempSectOfstAB=0;			
		}
	 Wr_Sector_b(BaseSectAB+TempSectOfstAB);		   //读一扇区
	 TempSectOfstAB++;
	 SectorAB++;
	}
  if(SectorAB>=SumSectorAB) 
      {
	   SectorAB=0;
	   return 0x00;
	  }
  else return 0xff;
}

/*******************************************************************************
------读AFAT表---------------------------------------------------
********************************************************************************
说明: 入口参数：扇区号LBA
	  出口参数：0x14:读取成功，0x1f：读取失败
*******************************************************************************/
unsigned char Rd_FAT_a(unsigned long LBA)		
{
  unsigned char sta,i,j,Next_Num=0;
  unsigned char xdata *pt;
  sta=0x1f;
  pt=FATBufA;
  CH375HM_INDEX_WR_a( DISK_READ );                        /* 从USB存储器读数据块 */
  CH375HM_DATA_WR_a( (unsigned char)LBA );                /* LBA的最低8位 */
  CH375HM_DATA_WR_a( (unsigned char)( LBA >> 8 ) );
  CH375HM_DATA_WR_a( (unsigned char)( LBA >> 16 ) );
  CH375HM_DATA_WR_a( (unsigned char)( LBA >> 24 ) );      /* LBA的最高8位 */
  CH375HM_DATA_WR_a( 1 );                           /* 扇区数 */ 
  Delay();
  for(i=0;i<9;i++)
    {
	sta=Wait_Int_a();
     if(sta==0x1f||sta==0x14) return sta;
	 CH375HM_INDEX_WR_a(RD_USB_DATA);
	 Next_Num=CH375HM_DATA_RD_a();
     for(j=0;j<Next_Num;j++)
	    {
		 *pt=CH375HM_DATA_RD_a();
		 pt++;
		}
	  CH375HM_INDEX_WR_a(DISK_RD_GO);
	 }
return 0xff;
}