开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 查看源码
HPI32.C
资源名称：51-SD.rar　[点击查看]
上传用户：jcsy2001
上传日期：2013-11-29
资源大小：201k
文件大小：23k
源码类别：

嵌入式/单片机编程

开发平台：

C/C++

HPI32.C：源码内容
  1. #include "common.h"
  2. #include "DEVICE.H"
  3. #include "HPI.H"
  4. #include "HAL.H"
  5. #include "Fat.h"
  6. #include "Fat32.h"
  7. #include "HPI32.H"
  9. extern FLAGS bdata bFlags;
  10. extern unsigned char xdata DBUF[BUFFER_LENGTH];
  11. //////////////////////////////////////////
  12. extern unsigned char xdata UARTBUF[UARTBUF_LENGTH];
  13. extern SYS_INFO_BLOCK xdata DeviceInfo;
  14. extern FILE_INFO xdata ThisFile;
  16. extern Command_Def xdata Command;
  17. extern Response_Def xdata Response;
  19. unsigned long xdata DirStartCluster32,NowCluster32;
  20. extern unsigned long xdata NowSector;
  21. extern ShowFileName_Def xdata ShowFileName[MaxLFNum]; //long file struct
  22. /////////////////////////////////////////////
  24. unsigned char UartHandler32(void)
  25. {
  26.   Response.Result=0;Response.len=0;
  27.   switch(Command.CLass)
  28.   {
  29.     case 0x00: //List
  30.      Response.Result=List32();
  31.      break;  
  32.    case 0x01: //Open File
  33.   Response.Result=OpenFile32(Command.Parameter);
  34.       break;
  35. case 0x02: //Read File
  36. Response.Result=ReadFile32(Command.len,UARTBUF);
  37. break;   
  38.     case 0x03: //Set Pointer
  39. Response.Result=SetFilePointer32(Command.len);
  40. break;
  41. case 0x04: //Great File
  42. Response.Result=OpenFile32(Command.Parameter);
  43. if(Response.Result)
  44. {
  45. Response.Result=SetFilePointer32(ThisFile.LengthInByte);
  46. }
  47. else
  48.      Response.Result=CreateFile32(Command.len,Command.Parameter,UARTBUF);    
  49.      break; 
  50. case 0x05: //Write File
  51.      Response.Result=WriteFile32(Command.len,UARTBUF);
  52.      break; 
  53.     case 0x06: //Remove File
  54.      ThisFile.bFileOpen=0;
  55.      Response.Result=RemoveFile32(Command.Parameter);
  56.      break; 
  57. case 0x07: //Get Space    
  58.      Response.Result=GetCapacity32();
  59.      break;     
  60. case 0x08:  //DetectDisk
  61. if(bFlags.bits.SLAVE_IS_ATTACHED)
  62. Response.Result=1;
  63. break;
  64. case 0x09:  //Great Dir
  65. Response.Result=DownDir32(Command.Parameter);
  66. if(!Response.Result)
  67. Response.Result=CreateDir32(Command.len,Command.Parameter,UARTBUF);    
  68.      break; 
  69. case 0x0a: //Down Dir
  70. Response.Result=DownDir32(Command.Parameter);
  71. break;
  72. case 0x0b: //Up Dir
  73. Response.Result=UpDir32();
  74. break;
  75. case 0x0c: //Up RootDir
  76. Response.Result=UpRootDir32();
  77. break;
  78.   }
  80.   UartSendRsp();
  81.   ///////////////////////////////
  82.   return TRUE;  
  83. }
  85. unsigned char List32(void)
  86. {
  87. unsigned int item,i;
  88. unsigned char k,bstop,sector;
  89. unsigned char Lcount,Ncount,base;
  91. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  92. return FALSE;
  93. item=0;
  94. bstop=0;
  95. ////////////////////////////////////
  96. Lcount=0;
  97. for(i=0;i<MaxLFNum;i++)
  98. {
  99. ShowFileName[i].LongName[0]=0x00;
  100. ShowFileName[i].LongName[1]=0x00;
  101. }
  102. //////////////////////////////////////////////////////////////////   
  103. NowCluster32=DirStartCluster32;
  104. do
  105. {
  106. NowSector=FirstSectorofCluster32(NowCluster32);
  107. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  108.      {   
  109. if(!SdReadSector(NowSector+sector,1,DBUF))
  110. return FALSE;
  111. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  112. {
  113. if(DBUF[i]==0x00)
  114. {bstop=1;break;}
  115. else if(DBUF[i]==0xE5)
  116. continue;
  117. else
  118. {
  119. for(k=0;k<32;k++)
  120. UARTBUF[item*32+k]=DBUF[i+k];
  121. item=item+1;
  122.  if(item>=(UARTBUF_LENGTH/32))  {bstop=1;break;}  //串口缓冲 只能有512项目录，强行结束
  123. /////////////////////////////////
  124. if(Lcount<MaxLFNum)
  125.  {
  126. if(DBUF[i+11]==0x0F)
  127. {
  128. base=((DBUF[i]&0x1F)-1)*26;
  129. if(base<=224)
  130. {
  131. Ncount=0;
  132. for(k=1;k<11;k++)
  133. {
  134. ShowFileName[Lcount].LongName[base+Ncount]=DBUF[i+k];
  135. Ncount++;
  136. }
  137. for(k=14;k<26;k++)
  138. {
  139. ShowFileName[Lcount].LongName[base+Ncount]=DBUF[i+k];
  140. Ncount++;
  141. }
  142. for(k=28;k<32;k++)
  143. {
  144. ShowFileName[Lcount].LongName[base+Ncount]=DBUF[i+k];
  145. Ncount++;
  146. }
  147. }
  148. }
  149. else
  150. {
  151. for(k=0;k<32;k++)
  152. ShowFileName[Lcount].item[k]=DBUF[i+k];
  153.      Lcount++;
  154. }
  155.       }
  156. /////////////////////////////////
  157. }
  158. }
  159. if(bstop==1)break;
  160.      }
  161. if(bstop==1)break;
  163. NowCluster32=GetNextClusterNum32(NowCluster32); 
  165. }while(NowCluster32<=DeviceInfo.TotCluster);
  167. Response.len=item*32;
  168. return TRUE;
  169. }
  171. unsigned char OpenFile32(unsigned char *pBuffer)
  172. {
  173. unsigned int i;
  174. unsigned char j,bstop,sector;
  176. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  177. return FALSE;
  178. ThisFile.bFileOpen=0;
  179. NowCluster32=DirStartCluster32;
  180. do
  181. {
  182. NowSector=FirstSectorofCluster32(NowCluster32);
  183. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  184.      {   
  185. if(!SdReadSector(NowSector+sector,1,DBUF))
  186. return FALSE;
  187. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  188. {
  189. if(DBUF[i]==0x00)
  190. return FALSE;
  191. j=0;
  192. while(DBUF[i+j]==*(pBuffer+j))
  193. {
  194.  j=j+1;
  195.  if(j>10)
  196.   break;
  197. }
  198. if(j>10&&(DBUF[i+11]&0x10)!=0x10)
  199.      { 
  200. for(j=0;j<32;j++)
  201.      UARTBUF[j]=DBUF[i+j];     
  202.      bstop=1;
  203.      break;
  204. }
  205. }
  206. if(bstop==1)break;
  207.      }
  208. if(bstop==1)break;
  209. NowCluster32=GetNextClusterNum32(NowCluster32);
  210. }while(NowCluster32<=DeviceInfo.TotCluster);
  212. if(NowCluster32>DeviceInfo.TotCluster)
  213.     return FALSE;
  215. ThisFile.bFileOpen=1;
  216. ThisFile.StartCluster=LSwapINT32(UARTBUF[26],UARTBUF[27],UARTBUF[20],UARTBUF[21]);
  217. ThisFile.LengthInByte=LSwapINT32(UARTBUF[28],UARTBUF[29],UARTBUF[30],UARTBUF[31]);
  218. ThisFile.ClusterPointer=ThisFile.StartCluster;
  219. ThisFile.SectorPointer=FirstSectorofCluster32(ThisFile.StartCluster);
  220. ThisFile.OffsetofSector=0;
  221. ThisFile.SectorofCluster=0;
  222. ThisFile.FatSectorPointer=0;
  223. ThisFile.pointer=0;
  225. Response.len=32;
  226. return TRUE;
  227. }
  230. unsigned char ReadFile32(unsigned long readLength,unsigned char *pBuffer)
  231. {
  233. unsigned int len,i;
  234. unsigned int tlen;
  235. unsigned long blen;
  237. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  238. return FALSE;
  239. if(!ThisFile.bFileOpen)
  240. return FALSE;
  242. blen=readLength;
  243. tlen=0;
  244. if(readLength>MAX_READ_LENGTH)
  245. return FALSE;
  247. if(readLength+ThisFile.pointer>ThisFile.LengthInByte)
  248. return FALSE;
  250. ////////////////////////////////////////////
  251. while(readLength>0)
  252. {
  253.    if(readLength+ThisFile.OffsetofSector>DeviceInfo.BPB_BytesPerSec)
  254.     len=DeviceInfo.BPB_BytesPerSec;
  255.    else
  256.     len=readLength+ThisFile.OffsetofSector;
  257.    
  258.    //////////////////////////////////////////////////////
  259.    if(ThisFile.OffsetofSector>0)
  260.     {
  261.     if(SdReadSector(ThisFile.SectorPointer,1,DBUF))
  262.     {
  263.    
  264.     len=len-ThisFile.OffsetofSector;
  265.     for(i=0;i<len;i++)
  266.    
  267.     *(pBuffer+i)=DBUF[ThisFile.OffsetofSector+i];
  268.     ThisFile.OffsetofSector=ThisFile.OffsetofSector+len;
  269.     }
  270.     else
  271.     return FALSE;    
  272.     }
  273.    else
  274.     {
  275.     if(!SdReadSector(ThisFile.SectorPointer,1,pBuffer+tlen))
  276.     return FALSE;
  277.     ThisFile.OffsetofSector=len;
  278.     }
  279.    ////////////////////////////////////////////////////////////
  280.    readLength-=len;
  281.    tlen+=len;
  282.   
  283.    /////////////////////////////////////////////////////////
  284.    if(ThisFile.OffsetofSector>DeviceInfo.BPB_BytesPerSec-1)
  285.    {
  286.     ThisFile.OffsetofSector-=DeviceInfo.BPB_BytesPerSec;
  287.     ThisFile.SectorofCluster+=1;
  288.     if(ThisFile.SectorofCluster>DeviceInfo.BPB_SecPerClus-1)
  289.     {
  290.     ThisFile.SectorofCluster=0;
  291.    ThisFile.ClusterPointer=GetNextClusterNum32(ThisFile.ClusterPointer);
  292.    if(ThisFile.ClusterPointer>DeviceInfo.TotCluster)
  293.        return FALSE;    
  294.    ThisFile.SectorPointer=FirstSectorofCluster32(ThisFile.ClusterPointer); 
  295.     }
  296.     else
  297.     ThisFile.SectorPointer=ThisFile.SectorPointer+1;
  298.     }
  299.    //////////////////////////////////////////////////////////////////
  300. }//end while
  302. ThisFile.bFileOpen=1;
  303. ThisFile.pointer+=tlen;
  304. //////////////////////////////////////////////
  305. Response.len=blen;
  307. return TRUE;
  308. }
  310. unsigned char SetFilePointer32(unsigned long pointer)
  311. {
  312. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  313. return FALSE;
  314. if(!ThisFile.bFileOpen)
  315. return FALSE;
  316. ///////////////////////////////////////////////////////////
  317. ThisFile.pointer=pointer;
  318. if(ThisFile.pointer>ThisFile.LengthInByte)
  319. return FALSE;
  321. if(!GoToPointer32(ThisFile.pointer))
  322. {
  323. ThisFile.bFileOpen=0;
  324. return FALSE;
  325. }
  326. //////////////////////////////////////////////
  327. return TRUE;
  328. }
  330. unsigned char CreateFile32(unsigned long len,unsigned char *pBuffer,unsigned char *pName)
  331. {
  332. unsigned int sector,i,j,DirCount;
  333. unsigned long cnum;
  334. unsigned char xdata bstop,InByte,bwrite;
  335. unsigned long ClusterPointer;
  337. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  338. return FALSE;
  339. if((len%32)!=0)
  340. return FALSE;
  341. if((len+32)>DeviceInfo.BPB_BytesPerSec)
  342. return FALSE;
  344. ThisFile.bFileOpen=0;
  346. cnum=GetFreeCusterNum32();
  347. if(cnum<0x02)
  348. return FALSE;
  350. pBuffer[21]=(unsigned char)(cnum>>24);
  351. pBuffer[20]=(unsigned char)(cnum>>16);
  352. pBuffer[27]=(unsigned char)(cnum>>8);
  353. pBuffer[26]=(unsigned char)(cnum);
  355. pBuffer[28]=0;pBuffer[29]=0;pBuffer[30]=0;pBuffer[31]=0;
  356. bstop=0;
  358. NowCluster32=DirStartCluster32;
  359. do
  360. {
  361. NowSector=FirstSectorofCluster32(NowCluster32);
  362. ClusterPointer=NowCluster32;
  363. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  364.      {   
  365. if(!SdReadSector(NowSector+sector,1,DBUF))
  366. return FALSE;
  367. DirCount=0;bwrite=0;
  369. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  370. {
  371. if(len==0)
  372. {
  373. if((DBUF[i]==0x00)||(DBUF[i]==0xE5))
  374. {
  375. for(j=0;j<32;j++)
  376. DBUF[i+j]=*(pBuffer+j);
  377. if(!SdWriteSector(NowSector+sector,1,DBUF))
  378.      return FALSE;     
  379. bstop=1;
  380. break;
  381. }
  382. }
  383. else
  384. {
  385. if(DirCount==0)
  386. InByte=i;
  387. if(DBUF[i]==0xE5)
  388. DirCount++;
  389. else if(DBUF[i]==0x00)
  390. {
  391. DirCount++;
  392. DBUF[i]=0xE5;
  393. bwrite=1;
  394. }
  395. else
  396. DirCount=0;
  398. if((DirCount*32)>=(len+32))
  399. {
  400. for(j=0;j<len;j++)
  401. DBUF[InByte+j]=*(pName+j);
  402. for(j=0;j<32;j++)
  403. DBUF[InByte+len+j]=*(pBuffer+j);
  404. if(!SdWriteSector(NowSector+sector,1,DBUF))
  405.      return FALSE;     
  406. bstop=1;
  407. break;
  408. }
  409.  }
  410. }
  411. if(bstop==1)break;
  413. if((len!=0)&&(bwrite==1))
  414. {
  415. if(!SdWriteSector(NowSector+sector,1,DBUF))
  416.    return FALSE;
  417.      }
  418.      }
  419. if(bstop==1)break;
  421. NowCluster32=GetNextClusterNum32(NowCluster32);
  422. if(NowCluster32>DeviceInfo.TotCluster)
  423.      {
  424. NowCluster32=CreateClusterLink32(ClusterPointer);
  425.   if(NowCluster32==0x00)
  426.    return FALSE;
  427. NowSector=FirstSectorofCluster32(NowCluster32);
  428. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i++) DBUF[i]=0x00;
  429. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  430. {
  431. if(!SdWriteSector(NowSector+sector,1,DBUF))
  432.      return FALSE;
  433. }
  434. }
  435. }while(NowCluster32<=DeviceInfo.TotCluster);
  436. ////////////////////////////////////////////////////////////////
  438. ThisFile.StartCluster=cnum;
  439. ThisFile.LengthInByte=0;
  440. ThisFile.ClusterPointer=ThisFile.StartCluster;
  441. ThisFile.SectorPointer=FirstSectorofCluster32(ThisFile.StartCluster);
  442. ThisFile.OffsetofSector=0;
  443. ThisFile.SectorofCluster=0;
  444. ThisFile.bFileOpen=1;
  445. ThisFile.pointer=0;
  446. ThisFile.FatSectorPointer=0;
  448. return TRUE;
  449. }
  452. unsigned char WriteFile32(unsigned long writeLength,unsigned char *pBuffer)
  453. {
  454.     unsigned long cnum;
  455. unsigned int  len,sector,i,tlen;
  456. unsigned char bSuccess,bStop;
  458. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  459. return FALSE;
  460. if(!ThisFile.bFileOpen)
  461. return FALSE;
  462. ThisFile.bFileOpen=0;
  463. bSuccess=1;
  464. bStop=0;
  465. tlen=0;
  467. while(writeLength>0)
  468. {
  469. if(writeLength+ThisFile.OffsetofSector>DeviceInfo.BPB_BytesPerSec)
  470.     len=DeviceInfo.BPB_BytesPerSec;
  471. else
  472.     len=writeLength+ThisFile.OffsetofSector;
  473.    
  474.  //////////////////////////////////////////////////////
  475.  if(ThisFile.OffsetofSector>0)
  476.   {
  477.   if(SdReadSector(ThisFile.SectorPointer,1,DBUF))
  478.     {
  479.    
  480.     len=len-ThisFile.OffsetofSector;
  481.     for(i=0;i<len;i++)    
  482.     DBUF[ThisFile.OffsetofSector+i]=*(pBuffer+i);
  483.     if(!SdWriteSector(ThisFile.SectorPointer,1,DBUF))
  484.     return FALSE;    
  485.     ThisFile.OffsetofSector=ThisFile.OffsetofSector+len;
  486.     }
  487.     else
  488.     return FALSE;    
  489.   }
  490.  else
  491.   {
  492.   if(!SdWriteSector(ThisFile.SectorPointer,1,pBuffer+tlen))
  493.     return FALSE;    
  494.     ThisFile.OffsetofSector=len;
  495.   }
  496.  /////////////////////////////////////////////////////
  497.    writeLength-=len;
  498.    tlen+=len;
  499.  /////////////更新文件指针 //////////////////////////////
  500.   if(ThisFile.OffsetofSector>DeviceInfo.BPB_BytesPerSec-1)
  501.    {
  502.     ThisFile.OffsetofSector-=DeviceInfo.BPB_BytesPerSec;
  503.     ThisFile.SectorofCluster+=1;
  504.     if(ThisFile.SectorofCluster>DeviceInfo.BPB_SecPerClus-1)
  505.     {
  506.     ThisFile.SectorofCluster=0;
  507.    ThisFile.ClusterPointer=CreateClusterLink32(ThisFile.ClusterPointer);
  508.    if(ThisFile.ClusterPointer==0x00)
  509.     return FALSE;  
  510.    ThisFile.SectorPointer=FirstSectorofCluster32(ThisFile.ClusterPointer); 
  511.     }
  512.     else
  513.     ThisFile.SectorPointer=ThisFile.SectorPointer+1;
  514.     }
  517. }//end while
  518. ThisFile.pointer+=tlen;
  519. ///////////更新文件目录信息/////////////////////////////
  520. if(bSuccess==1)
  521. {
  522. NowCluster32=DirStartCluster32;
  523. do
  524. {
  525. NowSector=FirstSectorofCluster32(NowCluster32);
  526. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  527.       {   
  528. if(!SdReadSector(NowSector+sector,1,DBUF))
  529. return FALSE;
  530. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  531. {
  532. cnum=LSwapINT32(DBUF[i+26],DBUF[i+27],DBUF[i+20],DBUF[i+21]);
  533. if((cnum==ThisFile.StartCluster)&&(DBUF[i]!=0xe5))
  534. {
  535. if(ThisFile.pointer>ThisFile.LengthInByte)
  536. ThisFile.LengthInByte=ThisFile.pointer;
  537. DBUF[i+28]=(unsigned char)(ThisFile.LengthInByte&0xff);
  538. DBUF[i+29]=(unsigned char)((ThisFile.LengthInByte>>8)&0xff);
  539. DBUF[i+30]=(unsigned char)((ThisFile.LengthInByte>>16)&0xff);
  540. DBUF[i+31]=(unsigned char)((ThisFile.LengthInByte>>24)&0xff);
  541. if(!SdWriteSector(NowSector+sector,1,DBUF))
  542.     return FALSE;    
  543.  bStop=1;
  544.  break;
  545. }
  546.      }
  547. if(bStop==1)break;
  548. }
  549. if(bStop==1)break;
  550. NowCluster32=GetNextClusterNum32(NowCluster32);
  551. }while(NowCluster32<=DeviceInfo.TotCluster);
  553. if(NowCluster32>DeviceInfo.TotCluster)
  554.      return FALSE;
  555. }
  557. ThisFile.bFileOpen=1;
  558. //////////////////////////////////////////////
  559. return TRUE;
  560. }
  563. unsigned char RemoveFile32(unsigned char *pBuffer)
  564. {
  565. unsigned int sector,i;
  566. unsigned char bStop,j;
  567. int k;
  569. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  570. return FALSE;
  571. ////////////// 清除目录/////////////////////////////////////
  572. NowCluster32=DirStartCluster32;
  573. do
  574. {
  575. NowSector=FirstSectorofCluster32(NowCluster32);
  576. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  577.      {   
  578. if(!SdReadSector(NowSector+sector,1,DBUF))
  579. return FALSE;
  580. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  581. {
  582. if(DBUF[i]==0x00)
  583. return FALSE;
  584. j=0;
  585. while(DBUF[i+j]==*(pBuffer+j))
  586. {
  587.  j=j+1;
  588.  if(j>10)
  589.   break;
  590. }
  591. if(j>10)
  592.      { 
  593. DBUF[i]=0xE5;
  594. ThisFile.StartCluster=LSwapINT32(DBUF[i+26],DBUF[i+27],DBUF[i+20],DBUF[i+21]);
  595.   for(k=(i-32);k>=0;k=k-32)
  596. {
  597. if(DBUF[k+11]==0x0F)
  598. DBUF[k]=0xE5;
  599. else
  600. break;
  601. }
  602.   DelayMs(15);
  603.   if(!SdWriteSector(NowSector+sector,1,DBUF))
  604. return FALSE;
  605. //////////////////// 清除FAT中的纪录////////////////////////
  606. DelayMs(10);
  607. if(!DeleteClusterLink32(ThisFile.StartCluster))
  608. return FALSE;
  609.   bStop=1;
  610.   break;
  611. }
  612. }
  613. if(bStop==1)break;
  614.      }
  615. if(bStop==1)break;
  616. NowCluster32=GetNextClusterNum32(NowCluster32);
  617. }while(NowCluster32<=DeviceInfo.TotCluster);
  619. if(NowCluster32>DeviceInfo.TotCluster)
  620.     return FALSE;
  622. return TRUE;
  623. }
  626. unsigned char GetCapacity32(void)
  627. {
  628. unsigned int sectorNum,i;
  629. unsigned long FreeSize,Freesectorcnt;
  631. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  632. return FALSE;
  634. ////////////////////////////////////////////////////////////////////////
  635. sectorNum=DeviceInfo.FatStartSector;
  636. Freesectorcnt=0;
  637. while(sectorNum<DeviceInfo.BPB_FATSz32+DeviceInfo.FatStartSector)
  638. {
  640. if(SdReadSector(sectorNum,1,DBUF))
  641. {
  642.   for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+4)
  643.    {     
  644.     if((DBUF[i]||DBUF[i+1]||DBUF[i+2]||DBUF[i+3])==0x00)
  645.      {
  646.      Freesectorcnt++;
  647.      }   
  648.    }
  649. }
  650. else
  651. return FALSE;
  652. sectorNum++;
  653. }
  655. ////////////////////////////////////////////////////////////////////////
  656. FreeSize=DeviceInfo.BPB_BytesPerSec*DeviceInfo.BPB_SecPerClus;
  657. FreeSize=Freesectorcnt*FreeSize;
  659. UARTBUF[0]=(unsigned char)((FreeSize>>24)&0xff);
  660. UARTBUF[1]=(unsigned char)((FreeSize>>16)&0xff);
  661. UARTBUF[2]=(unsigned char)((FreeSize>>8)&0xff);
  662. UARTBUF[3]=(unsigned char)(FreeSize&0xff);
  663. Response.len=4;
  664. return TRUE;
  665. }
  668. unsigned char CreateDir32(unsigned long len,unsigned char *pBuffer,unsigned char *pName)
  669. {
  670. unsigned int sector,i,j,DirCount;
  671. unsigned long cnum;
  672. unsigned char xdata bstop,InByte,bwrite;
  673. unsigned long ClusterPointer;
  675. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  676. return FALSE;
  677. if((len%32)!=0)
  678. return FALSE;
  679. if((len+32)>DeviceInfo.BPB_BytesPerSec)
  680. return FALSE;
  682. ThisFile.bFileOpen=0;
  683. ThisFile.FatSectorPointer=0;
  685. cnum=GetFreeCusterNum32();
  686. if(cnum<0x02)
  687. return FALSE;
  689. pBuffer[11]=0x10;
  690. pBuffer[21]=(unsigned char)(cnum>>24);
  691. pBuffer[20]=(unsigned char)(cnum>>16);
  692. pBuffer[27]=(unsigned char)(cnum>>8);
  693. pBuffer[26]=(unsigned char)(cnum);
  694. pBuffer[28]=0;pBuffer[29]=0;pBuffer[30]=0;pBuffer[31]=0;
  695. bstop=0;
  697. NowCluster32=DirStartCluster32;
  698. do
  699. {
  700. NowSector=FirstSectorofCluster32(NowCluster32);
  701. ClusterPointer=NowCluster32;
  702. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  703.      {   
  704. if(!SdReadSector(NowSector+sector,1,DBUF))
  705. return FALSE;
  706. DirCount=0;bwrite=0;
  707. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  708. {
  709. if(len==0)
  710. {
  711. if((DBUF[i]==0x00)||(DBUF[i]==0xE5))
  712. {
  713. for(j=0;j<32;j++)
  714. DBUF[i+j]=*(pBuffer+j);
  715. if(!SdWriteSector(NowSector+sector,1,DBUF))
  716.      return FALSE;     
  717. bstop=1;
  718. break;
  719. }
  720. }
  721. else
  722. {
  723. if(DirCount==0)
  724. InByte=i;
  725. if(DBUF[i]==0xE5)
  726. DirCount++;
  727. else if(DBUF[i]==0x00)
  728. {
  729. DirCount++;
  730. DBUF[i]=0xE5;
  731. bwrite=1;
  732. }
  733. else
  734. DirCount=0;
  736. if((DirCount*32)>=(len+32))
  737. {
  738. for(j=0;j<len;j++)
  739. DBUF[InByte+j]=*(pName+j);
  740. for(j=0;j<32;j++)
  741. DBUF[InByte+len+j]=*(pBuffer+j);
  742. if(!SdWriteSector(NowSector+sector,1,DBUF))
  743.      return FALSE;     
  744. bstop=1;
  745. break;
  746. }
  747.  }
  748. }
  749. if(bstop==1)break;
  750. if((len!=0)&&(bwrite==1))
  751. {
  752. if(!SdWriteSector(NowSector+sector,1,DBUF))
  753.    return FALSE;
  754.      }
  755.      }
  756. if(bstop==1)break;
  758. NowCluster32=GetNextClusterNum32(NowCluster32);
  759. if(NowCluster32>DeviceInfo.TotCluster)
  760.      {
  761. NowCluster32=CreateClusterLink32(ClusterPointer);
  762.   if(NowCluster32==0x00)
  763.    return FALSE;
  764. NowSector=FirstSectorofCluster32(NowCluster32);
  765. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i++) DBUF[i]=0x00;
  766. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  767. {
  768. if(!SdWriteSector(NowSector+sector,1,DBUF))
  769.      return FALSE;
  770. }
  771. }
  772. }while(NowCluster32<=DeviceInfo.TotCluster);
  774. if(NowCluster32>DeviceInfo.TotCluster)
  775.     return FALSE;
  776. ////////////////////////////////////////////////////////////////
  777. for(i=64;i<DeviceInfo.BPB_BytesPerSec;i++) DBUF[i]=0x00;
  779. for(i=0;i<43;i++) DBUF[i]=0x20;
  781. DBUF[0]=0x2e;
  782. for(i=11;i<32;i++) DBUF[i]=pBuffer[i];
  784. DBUF[32]=0x2e;DBUF[33]=0x2e;
  785. for(i=43;i<64;i++) DBUF[i]=pBuffer[i-32];
  787. if(DirStartCluster32==DeviceInfo.RootStartCluster) //Root Dir
  788. {
  789. DBUF[53]=0;DBUF[52]=0;DBUF[59]=0;DBUF[58]=0;
  790. }
  791. else
  792. {
  793. DBUF[53]=(unsigned char)(DirStartCluster32>>24);
  794. DBUF[52]=(unsigned char)(DirStartCluster32>>16);
  795. DBUF[59]=(unsigned char)(DirStartCluster32>>8);
  796. DBUF[58]=(unsigned char)(DirStartCluster32);
  797. }
  799. NowSector=FirstSectorofCluster32(cnum);
  800. if(!SdWriteSector(NowSector,1,DBUF))
  801. return FALSE;
  803. DirStartCluster32=cnum;
  804. // ThisFile.ClusterPointer=DirStartCluster32;
  805. ThisFile.ClusterPointer=0;
  806. return TRUE;
  807. }
  809. unsigned char DownDir32(unsigned char *pBuffer)
  810. {
  811. unsigned int i;
  812. unsigned char j,bstop,sector;
  814. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  815. return FALSE;
  817. ThisFile.bFileOpen=0;
  818. bstop=0;
  820. NowCluster32=DirStartCluster32;
  821. do
  822. {
  823. NowSector=FirstSectorofCluster32(NowCluster32);
  824. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  825.      {   
  826. if(!SdReadSector(NowSector+sector,1,DBUF))
  827. return FALSE;
  828. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  829. {
  830. if(DBUF[i]==0x00)
  831. return FALSE;
  832. j=0;
  833. while(DBUF[i+j]==*(pBuffer+j))
  834. {
  835.  j=j+1;
  836.  if(j>10)
  837.   break;
  838. }
  839. if(j>10&&(DBUF[i+11]&0x10))
  840.      {bstop=1;break;}
  841. }
  842. if(bstop==1)break;
  843.      }
  844. if(bstop==1)break;
  845. NowCluster32=GetNextClusterNum32(NowCluster32);
  846. }while(NowCluster32<=DeviceInfo.TotCluster);
  848. if(NowCluster32>DeviceInfo.TotCluster)
  849.     return FALSE;
  851. DirStartCluster32=LSwapINT32(DBUF[i+26],DBUF[i+27],DBUF[i+20],DBUF[i+21]);
  852. // ThisFile.ClusterPointer=DirStartCluster32;
  853. ThisFile.ClusterPointer=0;
  854. return TRUE;
  855. }
  857. unsigned char UpDir32()
  858. {
  859. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  860. return FALSE;
  861. if(DirStartCluster32==DeviceInfo.RootStartCluster) //Root Dir
  862. return TRUE;
  864. ThisFile.bFileOpen=0;
  866. NowSector=FirstSectorofCluster32(DirStartCluster32);
  867. if(!SdReadSector(NowSector,1,DBUF))
  868. return FALSE;
  869. if(DBUF[32]!=0x2e&&DBUF[33]!=0x2e) //..
  870. return FALSE;
  872. DirStartCluster32=LSwapINT32(DBUF[58],DBUF[59],DBUF[52],DBUF[53]);
  873. if(DirStartCluster32==0) //Root Dir
  874. DirStartCluster32=DeviceInfo.RootStartCluster;
  875. // ThisFile.ClusterPointer=DirStartCluster32;
  876. ThisFile.ClusterPointer=0;
  877. return TRUE;
  878. }
  880. unsigned char UpRootDir32()
  881. {
  882. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  883. return FALSE;
  885. ThisFile.bFileOpen=0;
  886. DirStartCluster32=DeviceInfo.RootStartCluster; //Root Dir
  888. return TRUE;
  889. }