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

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

嵌入式/单片机编程

开发平台：

C/C++

HPI.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. unsigned char xdata UARTBUF[UARTBUF_LENGTH];
  13. SYS_INFO_BLOCK xdata DeviceInfo;
  14. FILE_INFO xdata ThisFile;
  16. Command_Def xdata Command;
  17. Response_Def xdata Response;
  19. unsigned int xdata DirStartCluster,NowCluster;
  20. unsigned long xdata NowSector;
  21. ShowFileName_Def xdata ShowFileName[MaxLFNum]; //long file struct
  22. /////////////////////////////////////////////
  24. void UartSendRsp(void)
  25. {
  26. unsigned int i;
  27. unsigned char *pBuf=(unsigned char *)&Response;
  28. MCU_LED4=0;
  29. for(i=0;i<5;i++)
  30. ComSendByte(*(pBuf+i));
  32. if(Response.len!=0)
  33. {
  34. for(i=0;i<Response.len;i++)
  35. ComSendByte(UARTBUF[i]);
  36.     }
  37. MCU_LED4=1;
  38. }
  40. unsigned char UartHandler(void)
  41. {
  42.   Response.Result=0;Response.len=0;
  43.   switch(Command.CLass)
  44.   {
  45.     case 0x00: //List
  46.      Response.Result=List();
  47.      break;  
  48.    case 0x01: //Open File
  49.   Response.Result=OpenFile(Command.Parameter);
  50.       break;
  51. case 0x02: //Read File
  52. Response.Result=ReadFile(Command.len,UARTBUF);
  53. break;   
  54.     case 0x03: //Set Pointer
  55. Response.Result=SetFilePointer(Command.len);
  56. break;
  57. case 0x04: //Great File
  58. Response.Result=OpenFile(Command.Parameter);
  59. if(Response.Result)
  60. {
  61. Response.Result=SetFilePointer(ThisFile.LengthInByte);
  62. }
  63. else
  64.      Response.Result=CreateFile(Command.len,Command.Parameter,UARTBUF);    
  65.      break; 
  66. case 0x05: //Write File
  67.      Response.Result=WriteFile(Command.len,UARTBUF);
  68.      break; 
  69.     case 0x06: //Remove File
  70.      ThisFile.bFileOpen=0;
  71.      Response.Result=RemoveFile(Command.Parameter);
  72.      break; 
  73. case 0x07: //Get Space    
  74.      Response.Result=GetCapacity();
  75.      break;     
  76. case 0x08:  //DetectDisk
  77. if(bFlags.bits.SLAVE_IS_ATTACHED)
  78. Response.Result=1;
  79. break;
  80. case 0x09:  //Great Dir
  81. Response.Result=DownDir(Command.Parameter);
  82. if(!Response.Result)
  83. Response.Result=CreateDir(Command.len,Command.Parameter,UARTBUF);    
  84.      break; 
  85. case 0x0a: //Down Dir
  86. Response.Result=DownDir(Command.Parameter);
  87. break;
  88. case 0x0b: //Up Dir
  89. Response.Result=UpDir();
  90. break;
  91. case 0x0c: //Up RootDir
  92. Response.Result=UpRootDir();
  93. break;
  94.   }
  96.   UartSendRsp();
  97.   ///////////////////////////////
  98.   return TRUE;  
  99. }
  101. unsigned char List(void)
  102. {
  103. unsigned int item,i;
  104. unsigned char k,bstop,sector;
  105. unsigned char Lcount,Ncount,base;
  107. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  108. return FALSE;
  109. item=0;
  110. bstop=0;
  111. ////////////////////////////////////
  112. Lcount=0;
  113. for(i=0;i<MaxLFNum;i++)
  114. {
  115. ShowFileName[i].LongName[0]=0x00;
  116. ShowFileName[i].LongName[1]=0x00;
  117. }
  118. /////////////////////////////////////
  120. if(DirStartCluster==0) //Root Dir
  121. {
  122. for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
  123.     {   
  124. if(!SdReadSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  125. return FALSE;
  126. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  127. {
  128. if(DBUF[i]==0x00)
  129. {bstop=1;
  130. break;}
  131. else if(DBUF[i]==0xE5)
  132. continue;
  133. else
  134. {
  135. for(k=0;k<32;k++)
  136. UARTBUF[item*32+k]=DBUF[i+k];
  137. item=item+1;
  138.     if(item>=(UARTBUF_LENGTH/32))  {bstop=1;break;}  //串口缓冲 只能有512项目录，强行结束
  139. /////////////////////////////////
  140. if(Lcount<MaxLFNum)
  141. {
  142. if(DBUF[i+11]==0x0F)
  143. {
  144. base=((DBUF[i]&0x1F)-1)*26;
  145. if(base<=224)
  146. {
  147. Ncount=0;
  148. for(k=1;k<11;k++)
  149. {
  150. ShowFileName[Lcount].LongName[base+Ncount]=DBUF[i+k];
  151. Ncount++;
  152. }
  153. for(k=14;k<26;k++)
  154. {
  155. ShowFileName[Lcount].LongName[base+Ncount]=DBUF[i+k];
  156. Ncount++;
  157. }
  158. for(k=28;k<32;k++)
  159. {
  160. ShowFileName[Lcount].LongName[base+Ncount]=DBUF[i+k];
  161. Ncount++;
  162. }
  163. }
  164. }
  165. else
  166. {
  167. for(k=0;k<32;k++)
  168. ShowFileName[Lcount].item[k]=DBUF[i+k];
  169.     Lcount++;
  170. }
  171. }//if(Lcount<MaxLFNum)
  172. /////////////////////////////////
  173. }
  174. }
  176. if(bstop==1)break;
  177.     }
  178. Response.len=item*32;
  179. return TRUE;
  180. }
  181. //////////////////////////////////////////////////////////////////   
  182. else //Son Dir
  183. {
  184. NowCluster=DirStartCluster;
  185. do
  186. {
  187. NowSector=FirstSectorofCluster(NowCluster);
  188. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  189.      {   
  190. if(!SdReadSector(NowSector+sector,1,DBUF))
  191. return FALSE;
  192. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  193. {
  194. if(DBUF[i]==0x00)
  195. {bstop=1;break;}
  196. else if(DBUF[i]==0xE5)
  197. continue;
  198. else
  199. {
  200. for(k=0;k<32;k++)
  201. UARTBUF[item*32+k]=DBUF[i+k];
  202. item=item+1;
  203. /////////////////////////////////
  204. if(DBUF[i+11]==0x0F)
  205. {
  206. base=((DBUF[i]&0x1F)-1)*26;
  207. if(base<=224)
  208. {
  209. Ncount=0;
  210. for(k=1;k<11;k++)
  211. {
  212. ShowFileName[Lcount].LongName[base+Ncount]=DBUF[i+k];
  213. Ncount++;
  214. }
  215. for(k=14;k<26;k++)
  216. {
  217. ShowFileName[Lcount].LongName[base+Ncount]=DBUF[i+k];
  218. Ncount++;
  219. }
  220. for(k=28;k<32;k++)
  221. {
  222. ShowFileName[Lcount].LongName[base+Ncount]=DBUF[i+k];
  223. Ncount++;
  224. }
  225. }
  226. }
  227. else
  228. {
  229. for(k=0;k<32;k++)
  230. ShowFileName[Lcount].item[k]=DBUF[i+k];
  231.      Lcount++;
  232. }
  233. /////////////////////////////////
  234. }
  235. }
  236. if(bstop==1)break;
  237.      }
  239. if(bstop==1)break;
  241. NowCluster=GetNextClusterNum(NowCluster); 
  243. }while(NowCluster<=0xffef);
  245. Response.len=item*32;
  246. return TRUE;
  247. }
  248. }
  250. unsigned char OpenFile(unsigned char *pBuffer)
  251. {
  252. unsigned int i;
  253. unsigned char j,bstop,sector;
  255. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  256. return FALSE;
  257. ThisFile.bFileOpen=0;
  259. if(DirStartCluster==0) //Root Dir
  260. {
  261. for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
  262.     {   
  263. if(!SdReadSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  264. return FALSE;
  265. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  266. {
  267. if(DBUF[i]==0x00)
  268. return FALSE;
  269. j=0;
  270. while(DBUF[i+j]==*(pBuffer+j))
  271. {
  272.  j=j+1;
  273.  if(j>10)
  274.   break;
  275. }
  277. if(j>10&&(DBUF[i+11]&0x10)!=0x10)
  278.     {
  279.     for(j=0;j<32;j++)
  280.      UARTBUF[j]=DBUF[i+j];     
  281.     bstop=1;
  282.     break;}
  284. }
  285. if(bstop==1)break;
  286. }
  287.     
  288.     if(sector>=DeviceInfo.BPB_RootEntCnt)
  289.      return FALSE;
  290. }
  291. ///////////////////////////////////////////////////////////////////////////////////////
  292. else
  293. {
  294. NowCluster=DirStartCluster;
  295. do
  296. {
  297. NowSector=FirstSectorofCluster(NowCluster);
  298. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  299.      {   
  300. if(!SdReadSector(NowSector+sector,1,DBUF))
  301. return FALSE;
  302. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  303. {
  304. if(DBUF[i]==0x00)
  305. return FALSE;
  306. j=0;
  307. while(DBUF[i+j]==*(pBuffer+j))
  308. {
  309.  j=j+1;
  310.  if(j>10)
  311.   break;
  312. }
  313. if(j>10&&(DBUF[i+11]&0x10)!=0x10)
  314.      { 
  315. for(j=0;j<32;j++)
  316.      UARTBUF[j]=DBUF[i+j];     
  317.      bstop=1;
  318.      break;
  319. }
  320. }
  321. if(bstop==1)break;
  322.      }
  323. if(bstop==1)break;
  324. NowCluster=GetNextClusterNum(NowCluster);
  325. }while(NowCluster<=0xffef);
  327. if(NowCluster>0xffef)
  328.      return FALSE;
  329. }
  331. ThisFile.bFileOpen=1;
  332. ThisFile.StartCluster=LSwapINT16(UARTBUF[26],UARTBUF[27]);
  333. ThisFile.LengthInByte=LSwapINT32(UARTBUF[28],UARTBUF[29],UARTBUF[30],UARTBUF[31]);
  334. ThisFile.ClusterPointer=ThisFile.StartCluster;
  335. ThisFile.SectorPointer=FirstSectorofCluster(ThisFile.StartCluster);
  336. ThisFile.OffsetofSector=0;
  337. ThisFile.SectorofCluster=0;
  338. ThisFile.FatSectorPointer=0;
  339. ThisFile.pointer=0;
  341. Response.len=32;
  342. return TRUE;
  343. }
  345. unsigned char ReadFile(unsigned long readLength,unsigned char *pBuffer)
  346. {
  348. unsigned int len,i;
  349. unsigned int tlen;
  350. unsigned long blen;
  352. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  353. return FALSE;
  354. if(!ThisFile.bFileOpen)
  355. return FALSE;
  357. blen=readLength;
  359. tlen=0;
  360. if(readLength>MAX_READ_LENGTH)
  361. return FALSE;
  363. if(readLength+ThisFile.pointer>ThisFile.LengthInByte)
  364. return FALSE;
  366. ////////////////////////////////////////////
  367. while(readLength>0)
  368. {
  369.    if(readLength+ThisFile.OffsetofSector>DeviceInfo.BPB_BytesPerSec)
  370.     len=DeviceInfo.BPB_BytesPerSec;
  371.    else
  372.     len=readLength+ThisFile.OffsetofSector;
  373.    
  374.    //////////////////////////////////////////////////////
  375.    if(ThisFile.OffsetofSector>0)
  376.     {
  377.     if(SdReadSector(ThisFile.SectorPointer,1,DBUF))
  378.     {
  379.    
  380.     len=len-ThisFile.OffsetofSector;
  381.     for(i=0;i<len;i++)
  382.    
  383.     *(pBuffer+i)=DBUF[ThisFile.OffsetofSector+i];
  384.     ThisFile.OffsetofSector=ThisFile.OffsetofSector+len;
  385.     }
  386.     else
  387.     return FALSE;    
  388.     }
  389.    else
  390.     {
  391.     if(!SdReadSector(ThisFile.SectorPointer,1,pBuffer+tlen))
  392.     return FALSE;
  393.     ThisFile.OffsetofSector=len;
  394.     }
  395.    ////////////////////////////////////////////////////////////
  396.    readLength-=len;
  397.    tlen+=len;
  398.   
  399.    /////////////////////////////////////////////////////////
  400.    if(ThisFile.OffsetofSector>DeviceInfo.BPB_BytesPerSec-1)
  401.    {
  402.     ThisFile.OffsetofSector-=DeviceInfo.BPB_BytesPerSec;
  403.     ThisFile.SectorofCluster+=1;
  404.     if(ThisFile.SectorofCluster>DeviceInfo.BPB_SecPerClus-1)
  405.     {
  406.     ThisFile.SectorofCluster=0;
  407.    ThisFile.ClusterPointer=GetNextClusterNum(ThisFile.ClusterPointer);
  408.    if(ThisFile.ClusterPointer>0xffef)
  409.        return FALSE;    
  410.    ThisFile.SectorPointer=FirstSectorofCluster(ThisFile.ClusterPointer); 
  411.     }
  412.     else
  413.     ThisFile.SectorPointer=ThisFile.SectorPointer+1;
  414.     }
  415.    //////////////////////////////////////////////////////////////////
  416. }//end while
  418. ThisFile.bFileOpen=1;
  419. ThisFile.pointer+=tlen;
  420. //////////////////////////////////////////////
  421. Response.len=blen;
  423. return TRUE;
  424. }
  426. unsigned char SetFilePointer(unsigned long pointer)
  427. {
  428. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  429. return FALSE;
  430. if(!ThisFile.bFileOpen)
  431. return FALSE;
  432. ///////////////////////////////////////////////////////////
  433. ThisFile.pointer=pointer;
  434. if(ThisFile.pointer>ThisFile.LengthInByte)
  435. return FALSE;
  437. if(!GoToPointer(ThisFile.pointer))
  438. {
  439. ThisFile.bFileOpen=0;
  440. return FALSE;
  441. }
  442. //////////////////////////////////////////////
  443. return TRUE;
  444. }
  446. unsigned char CreateFile(unsigned long len,unsigned char *pBuffer,unsigned char *pName)
  447. {
  448. unsigned int sector,i,j,DirCount;
  449. unsigned int cnum,ClusterPointer;
  450. unsigned char xdata bstop,InByte,bwrite;
  452. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  453. return FALSE;
  454. if((len%32)!=0)
  455. return FALSE;
  456. if((len+32)>DeviceInfo.BPB_BytesPerSec)
  457. return FALSE;
  459. ThisFile.bFileOpen=0;
  461. cnum=GetFreeCusterNum();
  462. if(cnum<0x02)
  463. return FALSE;
  465. pBuffer[26]=(unsigned char)(cnum);
  466. pBuffer[27]=(unsigned char)(cnum>>8);
  467. pBuffer[28]=0;pBuffer[29]=0;pBuffer[30]=0;pBuffer[31]=0;
  468. bstop=0;
  470. if(DirStartCluster==0)
  471. {
  472. /////// Search a free space in the root dir space and build the item ///
  473. for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
  474.     {   
  475. if(!SdReadSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  476. return FALSE;
  477. DirCount=0;bwrite=0;
  478. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  479. {
  480. if(len==0)
  481. {
  482. if((DBUF[i]==0x00)||(DBUF[i]==0xE5))
  483. {
  484. for(j=0;j<32;j++)
  485. DBUF[i+j]=*(pBuffer+j);
  486. if(!SdWriteSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  487.      return FALSE;     
  488. bstop=1;
  489. break;
  490. }
  491. }
  492. else
  493. {
  494. if(DirCount==0)
  495. InByte=i;
  496. if(DBUF[i]==0xE5)
  497. DirCount++;
  498. else if(DBUF[i]==0x00)
  499. {
  500. DirCount++;
  501. DBUF[i]=0xE5;
  502. bwrite=1;
  503. }
  504. else
  505. DirCount=0;
  507. if((DirCount*32)>=(len+32))
  508. {
  509. for(j=0;j<len;j++)
  510. DBUF[InByte+j]=*(pName+j);
  512. for(j=0;j<32;j++)
  513. DBUF[InByte+len+j]=*(pBuffer+j);
  515. if(!SdWriteSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  516.      return FALSE;     
  517. bstop=1;
  518. break;
  519. }
  520.  }
  521. }
  522. if(bstop==1)break;
  524. if((len!=0)&&(bwrite==1))
  525. {
  526. if(!SdWriteSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  527.    return FALSE;
  528.      }
  529. }
  531. if(sector>=DeviceInfo.BPB_RootEntCnt)
  532. return FALSE;
  533. }
  534. ////////////////////////////////////////////////////////////
  535. else
  536. {
  537. NowCluster=DirStartCluster;
  538. do
  539. {
  540. NowSector=FirstSectorofCluster(NowCluster);
  541. ClusterPointer=NowCluster;
  542. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  543.      {   
  544. if(!SdReadSector(NowSector+sector,1,DBUF))
  545. return FALSE;
  546. DirCount=0;bwrite=0;
  548. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  549. {
  550. if(len==0)
  551. {
  552. if((DBUF[i]==0x00)||(DBUF[i]==0xE5))
  553. {
  554. for(j=0;j<32;j++)
  555. DBUF[i+j]=*(pBuffer+j);
  556. if(!SdWriteSector(NowSector+sector,1,DBUF))
  557.      return FALSE;     
  558. bstop=1;
  559. break;
  560. }
  561. }
  562. else
  563. {
  564. if(DirCount==0)
  565. InByte=i;
  566. if(DBUF[i]==0xE5)
  567. DirCount++;
  568. else if(DBUF[i]==0x00)
  569. {
  570. DirCount++;
  571. DBUF[i]=0xE5;
  572. bwrite=1;
  573. }
  574. else
  575. DirCount=0;
  577. if((DirCount*32)>=(len+32))
  578. {
  579. for(j=0;j<len;j++)
  580. DBUF[InByte+j]=*(pName+j);
  581. for(j=0;j<32;j++)
  582. DBUF[InByte+len+j]=*(pBuffer+j);
  583. if(!SdWriteSector(NowSector+sector,1,DBUF))
  584.      return FALSE;     
  585. bstop=1;
  586. break;
  587. }
  588.  }
  589. }
  590. if(bstop==1)break;
  592. if((len!=0)&&(bwrite==1))
  593. {
  594. if(!SdWriteSector(NowSector+sector,1,DBUF))
  595.    return FALSE;
  596.      }
  597.      }
  598. if(bstop==1)break;
  600. NowCluster=GetNextClusterNum(NowCluster);
  601. if(NowCluster>0xffef)
  602.      {
  603. NowCluster=CreateClusterLink(ClusterPointer);
  604.   if(NowCluster==0x00)
  605.    return FALSE;
  606. NowSector=FirstSectorofCluster(NowCluster);
  607. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i++) DBUF[i]=0x00;
  608. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  609. {
  610. if(!SdWriteSector(NowSector+sector,1,DBUF))
  611.      return FALSE;
  612. }
  613. }
  614. }while(NowCluster<=0xffef);
  617. if(NowCluster>0xffef)
  618.     return FALSE;
  619. }
  620. ////////////////////////////////////////////////////////////////
  622. ThisFile.StartCluster=cnum;
  623. ThisFile.LengthInByte=0;
  624. ThisFile.ClusterPointer=ThisFile.StartCluster;
  625. ThisFile.SectorPointer=FirstSectorofCluster(ThisFile.StartCluster);
  626. ThisFile.OffsetofSector=0;
  627. ThisFile.SectorofCluster=0;
  628. ThisFile.bFileOpen=1;
  629. ThisFile.pointer=0;
  630. ThisFile.FatSectorPointer=0;
  632. return TRUE;
  633. }
  635. unsigned char WriteFile(unsigned long writeLength,unsigned char *pBuffer)
  636. {
  637. unsigned int  len,sector,i,cnum,tlen;
  638. unsigned char bSuccess,bStop;
  640. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  641. return FALSE;
  642. if(!ThisFile.bFileOpen)
  643. return FALSE;
  644. ThisFile.bFileOpen=0;
  645. bSuccess=1;
  646. bStop=0;
  647. tlen=0;
  649. while(writeLength>0)
  650. {
  651. if(writeLength+ThisFile.OffsetofSector>DeviceInfo.BPB_BytesPerSec)
  652.     len=DeviceInfo.BPB_BytesPerSec;
  653. else
  654.     len=writeLength+ThisFile.OffsetofSector;
  655.    
  656.  //////////////////////////////////////////////////////
  657.  if(ThisFile.OffsetofSector>0)
  658.   {
  659.   if(SdReadSector(ThisFile.SectorPointer,1,DBUF))
  660.     {
  661.    
  662.     len=len-ThisFile.OffsetofSector;
  663.     for(i=0;i<len;i++)
  664.    
  665.     DBUF[ThisFile.OffsetofSector+i]=*(pBuffer+i);
  666.     if(!SdWriteSector(ThisFile.SectorPointer,1,DBUF))
  667.     return FALSE;    
  668.     ThisFile.OffsetofSector=ThisFile.OffsetofSector+len;
  669.     }
  670.     else
  671.     return FALSE;    
  672.   }
  673.  else
  674.   {
  675.   if(!SdWriteSector(ThisFile.SectorPointer,1,pBuffer+tlen))
  676.     return FALSE;    
  677.     ThisFile.OffsetofSector=len;
  678.   }
  679.  /////////////////////////////////////////////////////
  680.    writeLength-=len;
  681.    tlen+=len;
  682.  /////////////更新文件指针 //////////////////////////////
  683.   if(ThisFile.OffsetofSector>DeviceInfo.BPB_BytesPerSec-1)
  684.    {
  685.     ThisFile.OffsetofSector-=DeviceInfo.BPB_BytesPerSec;
  686.     ThisFile.SectorofCluster+=1;
  687.     if(ThisFile.SectorofCluster>DeviceInfo.BPB_SecPerClus-1)
  688.     {
  689.     ThisFile.SectorofCluster=0;
  690.    ThisFile.ClusterPointer=CreateClusterLink(ThisFile.ClusterPointer);
  691.    if(ThisFile.ClusterPointer==0x00)
  692.     return FALSE;  
  693.    ThisFile.SectorPointer=FirstSectorofCluster(ThisFile.ClusterPointer); 
  694.     }
  695.     else
  696.     ThisFile.SectorPointer=ThisFile.SectorPointer+1;
  697.     }
  700. }//end while
  701. ThisFile.pointer+=tlen;
  702.     DelayMs(200);
  703. ///////////更新文件目录信息/////////////////////////////
  704. if(bSuccess==1)
  705. {
  706. if(DirStartCluster==0)
  707. {
  708. for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
  709.      {   
  710. //////////////////////////////////////////////////
  711. if(!SdReadSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  712. return FALSE;
  713. ///////////////////////////////////////////////////
  714. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  715. {
  716. cnum=LSwapINT16(DBUF[i+26],DBUF[i+27]);
  717. if((cnum==ThisFile.StartCluster)&&(DBUF[i]!=0xe5))
  718. {
  719. if(ThisFile.pointer>ThisFile.LengthInByte)
  720. ThisFile.LengthInByte=ThisFile.pointer;
  721. DBUF[i+28]=(unsigned char)(ThisFile.LengthInByte&0xff);
  722. DBUF[i+29]=(unsigned char)((ThisFile.LengthInByte>>8)&0xff);
  723. DBUF[i+30]=(unsigned char)((ThisFile.LengthInByte>>16)&0xff);
  724. DBUF[i+31]=(unsigned char)((ThisFile.LengthInByte>>24)&0xff);
  725. if(!SdWriteSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  726.     return FALSE;    
  727.  bStop=1;
  728.  break;
  729. }
  730. }
  731. if(bStop==1)
  732. break;
  733.        }
  734. }
  735. //////////////////////////////////////////////////////////////////////////////
  736. else
  737. {
  738. NowCluster=DirStartCluster;
  739. do
  740. {
  741. NowSector=FirstSectorofCluster(NowCluster);
  742. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  743.       {   
  744. if(!SdReadSector(NowSector+sector,1,DBUF))
  745. return FALSE;
  746. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  747. {
  748. cnum=LSwapINT16(DBUF[i+26],DBUF[i+27]);
  749. if((cnum==ThisFile.StartCluster)&&(DBUF[i]!=0xe5))
  750. {
  751. if(ThisFile.pointer>ThisFile.LengthInByte)
  752. ThisFile.LengthInByte=ThisFile.pointer;
  753. DBUF[i+28]=(unsigned char)(ThisFile.LengthInByte&0xff);
  754. DBUF[i+29]=(unsigned char)((ThisFile.LengthInByte>>8)&0xff);
  755. DBUF[i+30]=(unsigned char)((ThisFile.LengthInByte>>16)&0xff);
  756. DBUF[i+31]=(unsigned char)((ThisFile.LengthInByte>>24)&0xff);
  757. if(!SdWriteSector(NowSector+sector,1,DBUF))
  758.     return FALSE;    
  759.  bStop=1;
  760.  break;
  761. }
  762.      }
  763. if(bStop==1)break;
  764. }
  765. if(bStop==1)break;
  766. NowCluster=GetNextClusterNum(NowCluster);
  767. }while(NowCluster<=0xffef);
  769. if(NowCluster>0xffef)
  770.      return FALSE;
  771. }
  772. }
  774. ThisFile.bFileOpen=1;
  775. //////////////////////////////////////////////
  776. return TRUE;
  777. }
  779. unsigned char RemoveFile(unsigned char *pBuffer)
  780. {
  781. unsigned int sector,i;
  782. unsigned char bStop,j;
  783. int k;
  785. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  786. return FALSE;
  787. if(DirStartCluster==0)
  788. {
  789. ////////////// 清除目录/////////////////////////////////////
  790. for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
  791.      {   
  792. //////////////////////////////////////////////////
  793. if(!SdReadSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  794. return FALSE;
  795. ///////////////////////////////////////////////////
  796. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  797. {
  798. if(DBUF[i]==0x00)
  799. return FALSE;
  800. ///////////////////////////////////////////
  801. j=0;
  802. while(DBUF[i+j]==*(pBuffer+j))
  803. {
  804.  j=j+1;
  805.  if(j>10) break;
  806.  }
  808. if(j>10)
  809.   {
  810.   DBUF[i]=0xE5;
  811.   ThisFile.StartCluster=LSwapINT16(DBUF[i+26],DBUF[i+27]);
  813. for(k=(i-32);k>=0;k=k-32)
  814. {
  815. if(DBUF[k+11]==0x0F)
  816. DBUF[k]=0xE5;
  817. else
  818. break;
  819. }
  820. DelayMs(15);
  821. if(!SdWriteSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  822. return FALSE;
  823. /*
  824.   k=sector-1;
  825. if(k>=0)
  826. {
  827. if(!SdReadSector(DeviceInfo.RootStartSector+k,1,DBUF))
  828. return FALSE;
  829. for(k=DeviceInfo.BPB_BytesPerSec;k>=0;k=k-32)
  830. {
  831. if(DBUF[k+11]==0x0F)
  832. DBUF[k]=0xE5;
  833. else
  834. break;
  835. }
  836. // DelayMs(15);
  837.   if(!SdWriteSector(DeviceInfo.RootStartSector+sector-1,1,DBUF))
  838. return FALSE;
  839. }
  840. */
  841. //////////////////// 清除FAT中的纪录////////////////////////
  842. DelayMs(10);
  843. if(!DeleteClusterLink(ThisFile.StartCluster))
  844. return FALSE;
  845.   bStop=1;
  846.   break;
  847.   }
  849. }//end for
  850. if(bStop==1)
  851. break;
  853.        }//end search
  854. if(sector>=DeviceInfo.BPB_RootEntCnt)
  855. return FALSE;
  856. }
  857. else
  858. {
  859. NowCluster=DirStartCluster;
  860. do
  861. {
  862. NowSector=FirstSectorofCluster(NowCluster);
  863. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  864.      {   
  865. if(!SdReadSector(NowSector+sector,1,DBUF))
  866. return FALSE;
  867. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  868. {
  869. if(DBUF[i]==0x00)
  870. return FALSE;
  871. j=0;
  872. while(DBUF[i+j]==*(pBuffer+j))
  873. {
  874.  j=j+1;
  875.  if(j>10)
  876.   break;
  877. }
  878. if(j>10)
  879.      { 
  880. DBUF[i]=0xE5;
  881.   ThisFile.StartCluster=LSwapINT16(DBUF[i+26],DBUF[i+27]);
  882. for(k=(i-32);k>=0;k=k-32)
  883. {
  884. if(DBUF[k+11]==0x0F)
  885. DBUF[k]=0xE5;
  886. else
  887. break;
  888. }
  889.   DelayMs(15);
  890.   if(!SdWriteSector(NowSector+sector,1,DBUF))
  891. return FALSE;
  892. //////////////////// 清除FAT中的纪录////////////////////////
  893. DelayMs(10);
  894. if(!DeleteClusterLink(ThisFile.StartCluster))
  895. return FALSE;
  896.   bStop=1;
  897.   break;
  898. }
  899. }
  900. if(bStop==1)break;
  901.      }
  902. if(bStop==1)break;
  903. NowCluster=GetNextClusterNum(NowCluster);
  904. }while(NowCluster<=0xffef);
  906. if(NowCluster>0xffef)
  907.      return FALSE;
  908. }
  909. return TRUE;
  910. }
  912. unsigned char GetCapacity(void)
  913. {
  914. unsigned int sectorNum,i;
  915. unsigned long FreeSize,Freesectorcnt;
  917. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  918. return FALSE;
  920. ////////////////////////////////////////////////////////////////////////
  921. sectorNum=DeviceInfo.FatStartSector;
  922. Freesectorcnt=0;
  923. while(sectorNum<DeviceInfo.BPB_FATSz16+DeviceInfo.FatStartSector)
  924. {
  926. if(SdReadSector(sectorNum,1,DBUF))
  927. {
  928.   for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+2)
  929.    {     
  930.     if((DBUF[i]==0x00)&&(DBUF[i+1]==0x00))
  931.      {
  932.      Freesectorcnt++;
  933.      }   
  934.    }
  935. }
  936. else
  937. return FALSE;
  938. sectorNum++;
  939. }
  941. ////////////////////////////////////////////////////////////////////////
  942. FreeSize=DeviceInfo.BPB_BytesPerSec*DeviceInfo.BPB_SecPerClus;
  943. FreeSize=Freesectorcnt*FreeSize;
  945. UARTBUF[0]=(unsigned char)((FreeSize>>24)&0xff);
  946. UARTBUF[1]=(unsigned char)((FreeSize>>16)&0xff);
  947. UARTBUF[2]=(unsigned char)((FreeSize>>8)&0xff);
  948. UARTBUF[3]=(unsigned char)(FreeSize&0xff);
  949. Response.len=4;
  950. return TRUE;
  951. }
  953. unsigned char CreateDir(unsigned long len,unsigned char *pBuffer,unsigned char *pName)
  954. {
  955. unsigned int sector,i,j,DirCount;
  956. unsigned int cnum,ClusterPointer;
  957. unsigned char xdata bstop,InByte,bwrite;
  959. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  960. return FALSE;
  961. if((len%32)!=0)
  962. return FALSE;
  963. if((len+32)>DeviceInfo.BPB_BytesPerSec)
  964. return FALSE;
  966. ThisFile.bFileOpen=0;
  967. ThisFile.FatSectorPointer=0;
  969. cnum=GetFreeCusterNum();
  970. if(cnum<0x02)
  971. return FALSE;
  973. pBuffer[11]=0x10;
  974. pBuffer[26]=(unsigned char)(cnum);
  975. pBuffer[27]=(unsigned char)(cnum>>8);
  976. pBuffer[28]=0;pBuffer[29]=0;pBuffer[30]=0;pBuffer[31]=0;
  977. bstop=0;
  979. if(DirStartCluster==0)
  980. {
  981. /////// Search a free space in the root dir space and build the item ///
  982. for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
  983.     {   
  984. if(!SdReadSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  985. return FALSE;
  986. DirCount=0;bwrite=0;
  987. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  988. {
  989. if(len==0)
  990. {
  991. if((DBUF[i]==0x00)||(DBUF[i]==0xE5))
  992. {
  993. for(j=0;j<32;j++)
  994. DBUF[i+j]=*(pBuffer+j);
  995. if(!SdWriteSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  996.      return FALSE;     
  997. bstop=1;
  998. break;
  999. }
  1000. }
  1001. else
  1002. {
  1003. if(DirCount==0)
  1004. InByte=i;
  1005. if(DBUF[i]==0xE5)
  1006. DirCount++;
  1007. else if(DBUF[i]==0x00)
  1008. {
  1009. DirCount++;
  1010. DBUF[i]=0xE5;
  1011. bwrite=1;
  1012. }
  1013. else
  1014. DirCount=0;
  1016. if((DirCount*32)>=(len+32))
  1017. {
  1018. for(j=0;j<len;j++)
  1019. DBUF[InByte+j]=*(pName+j);
  1021. for(j=0;j<32;j++)
  1022. DBUF[InByte+len+j]=*(pBuffer+j);
  1024. if(!SdWriteSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  1025.      return FALSE;     
  1026. bstop=1;
  1027. break;
  1028. }
  1029.  }
  1030. }
  1031. if(bstop==1)break;
  1033. if((len!=0)&&(bwrite==1))
  1034. {
  1035. if(!SdWriteSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  1036.    return FALSE;
  1037.      }
  1038.     }
  1040. if(sector>=DeviceInfo.BPB_RootEntCnt)
  1041. return FALSE;
  1042. }
  1043. ////////////////////////////////////////////////////////////
  1044. else
  1045. {
  1046. NowCluster=DirStartCluster;
  1047. do
  1048. {
  1049. NowSector=FirstSectorofCluster(NowCluster);
  1050. ClusterPointer=NowCluster;
  1051. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  1052.      {   
  1053. if(!SdReadSector(NowSector+sector,1,DBUF))
  1054. return FALSE;
  1055. DirCount=0;bwrite=0;
  1056. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  1057. {
  1058. if(len==0)
  1059. {
  1060. if((DBUF[i]==0x00)||(DBUF[i]==0xE5))
  1061. {
  1062. for(j=0;j<32;j++)
  1063. DBUF[i+j]=*(pBuffer+j);
  1064. if(!SdWriteSector(NowSector+sector,1,DBUF))
  1065.      return FALSE;     
  1066. bstop=1;
  1067. break;
  1068. }
  1069. }
  1070. else
  1071. {
  1072. if(DirCount==0)
  1073. InByte=i;
  1074. if(DBUF[i]==0xE5)
  1075. DirCount++;
  1076. else if(DBUF[i]==0x00)
  1077. {
  1078. DirCount++;
  1079. DBUF[i]=0xE5;
  1080. bwrite=1;
  1081. }
  1082. else
  1083. DirCount=0;
  1085. if((DirCount*32)>=(len+32))
  1086. {
  1087. for(j=0;j<len;j++)
  1088. DBUF[InByte+j]=*(pName+j);
  1089. for(j=0;j<32;j++)
  1090. DBUF[InByte+len+j]=*(pBuffer+j);
  1091. if(!SdWriteSector(NowSector+sector,1,DBUF))
  1092.      return FALSE;     
  1093. bstop=1;
  1094. break;
  1095. }
  1096.  }
  1097. }
  1098. if(bstop==1)break;
  1099. if((len!=0)&&(bwrite==1))
  1100. {
  1101. if(!SdWriteSector(NowSector+sector,1,DBUF))
  1102.    return FALSE;
  1103.      }
  1104.      }
  1105. if(bstop==1)break;
  1107. NowCluster=GetNextClusterNum(NowCluster);
  1108. if(NowCluster>0xffef)
  1109.      {
  1110. NowCluster=CreateClusterLink(ClusterPointer);
  1111.   if(NowCluster==0x00)
  1112.    return FALSE;
  1113. NowSector=FirstSectorofCluster(NowCluster);
  1114. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i++) DBUF[i]=0x00;
  1115. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  1116. {
  1117. if(!SdWriteSector(NowSector+sector,1,DBUF))
  1118.      return FALSE;
  1119. }
  1120. }
  1121. }while(NowCluster<=0xffef);
  1123. if(NowCluster>0xffef)
  1124.     return FALSE;
  1125. }
  1126. ////////////////////////////////////////////////////////////////
  1127. for(i=64;i<DeviceInfo.BPB_BytesPerSec;i++) DBUF[i]=0x00;
  1129. for(i=0;i<43;i++) DBUF[i]=0x20;
  1131. DBUF[0]=0x2e;
  1132. for(i=11;i<32;i++) DBUF[i]=pBuffer[i];
  1134. DBUF[32]=0x2e;DBUF[33]=0x2e;
  1135. for(i=43;i<64;i++) DBUF[i]=pBuffer[i-32];
  1136. DBUF[58]=(unsigned char)(DirStartCluster);
  1137. DBUF[59]=(unsigned char)(DirStartCluster>>8);
  1139. NowSector=FirstSectorofCluster(cnum);
  1140. if(!SdWriteSector(NowSector,1,DBUF))
  1141. return FALSE;
  1143. DirStartCluster=cnum;
  1144. // ThisFile.ClusterPointer=DirStartCluster;
  1145. ThisFile.ClusterPointer=0;
  1146. return TRUE;
  1147. }
  1149. unsigned char DownDir(unsigned char *pBuffer)
  1150. {
  1151. unsigned int i;
  1152. unsigned char j,bstop,sector;
  1154. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  1155. return FALSE;
  1157. ThisFile.bFileOpen=0;
  1158. bstop=0;
  1160. if(DirStartCluster==0) //Root Dir
  1161. {
  1162. for(sector=0;sector<DeviceInfo.BPB_RootEntCnt;sector++)
  1163.     {   
  1164. if(!SdReadSector(DeviceInfo.RootStartSector+sector,1,DBUF))
  1165. return FALSE;
  1166. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  1167. {
  1168. if(DBUF[i]==0x00)
  1169. return FALSE;
  1170. j=0;
  1171. while(DBUF[i+j]==*(pBuffer+j))
  1172. {
  1173.  j=j+1;
  1174.  if(j>10)
  1175.   break;
  1176. }
  1178. if(j>10&&(DBUF[i+11]&0x10))
  1179.     {    
  1180.     bstop=1;
  1181.      break;}
  1183. }
  1184. if(bstop==1)break;
  1185.     }
  1186.     
  1187.     if(sector>=DeviceInfo.BPB_RootEntCnt)
  1188.      return FALSE;
  1189.     
  1190. DirStartCluster=LSwapINT16(DBUF[i+26],DBUF[i+27]);
  1191. // ThisFile.ClusterPointer=DirStartCluster;
  1192. ThisFile.ClusterPointer=0;
  1193. return TRUE;
  1194. }
  1195. ////////////////////////////////////////////
  1196. else
  1197. {
  1198. NowCluster=DirStartCluster;
  1199. do
  1200. {
  1201. NowSector=FirstSectorofCluster(NowCluster);
  1202. for(sector=0;sector<DeviceInfo.BPB_SecPerClus;sector++)
  1203.      {   
  1204. if(!SdReadSector(NowSector+sector,1,DBUF))
  1205. return FALSE;
  1206. for(i=0;i<DeviceInfo.BPB_BytesPerSec;i=i+32)
  1207. {
  1208. if(DBUF[i]==0x00)
  1209. return FALSE;
  1210. j=0;
  1211. while(DBUF[i+j]==*(pBuffer+j))
  1212. {
  1213.  j=j+1;
  1214.  if(j>10)
  1215.   break;
  1216. }
  1217. if(j>10&&(DBUF[i+11]&0x10))
  1218.      {bstop=1;break;}
  1219. }
  1220. if(bstop==1)break;
  1221.      }
  1222. if(bstop==1)break;
  1223. NowCluster=GetNextClusterNum(NowCluster);
  1224. }while(NowCluster<=0xffef);
  1226. if(NowCluster>0xffef)
  1227.      return FALSE;
  1229. DirStartCluster=LSwapINT16(DBUF[i+26],DBUF[i+27]);
  1230. // ThisFile.ClusterPointer=DirStartCluster;
  1231. ThisFile.ClusterPointer=0;
  1232. return TRUE;
  1233. }
  1234. }
  1236. unsigned char UpDir()
  1237. {
  1238. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  1239. return FALSE;
  1240. if(DirStartCluster==0) //Root Dir
  1241. return TRUE;
  1243. ThisFile.bFileOpen=0;
  1245. NowSector=FirstSectorofCluster(DirStartCluster);
  1246. if(!SdReadSector(NowSector,1,DBUF))
  1247. return FALSE;
  1248. if(DBUF[32]!=0x2e&&DBUF[33]!=0x2e) //..
  1249. return FALSE;
  1251. DirStartCluster=LSwapINT16(DBUF[58],DBUF[59]);
  1252. // ThisFile.ClusterPointer=DirStartCluster;
  1253. ThisFile.ClusterPointer=0;
  1254. return TRUE;
  1255. }
  1257. unsigned char UpRootDir()
  1258. {
  1259. if(!bFlags.bits.SLAVE_IS_ATTACHED)
  1260. return FALSE;
  1262. ThisFile.bFileOpen=0;
  1263. DirStartCluster=0; //Root Dir
  1265. return TRUE;
  1266. }