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

📄 libdir.lst

📁 威望公司MP3 + USB MCU 的参考软件
💻 LST
📖 第 1 页 / 共 2 页
字号:
 261   2                      size = 0;//根目录的size,以sector为单位。
 262   2                      start = drv->RootStart;
 263   2      
 264   2                      //循环整个cluster chain,得到根目录的size
 265   2                      while(start != 0xffffffff){
 266   3                              size += drv->ClusterSize;
 267   3      //                      start = drv->FatRead(drv, start);
 268   3                              start = ReadFatxx(start);
 269   3                              if(!start)
 270   3                              {
 271   4                              //start为0表示该cluster可用,则根目录不存在
 272   4      //                              drv->StatusCode = DRIVE_FORMAT_ERROR;
 273   4                                      return ABNORMAL_STATUS;
 274   4                              }
 275   3                      }
 276   2                      
 277   2                      start = drv->RootStart;
 278   2                      //每个sector为512bytes,将size从sector单位转为byte单位。
 279   2                      size = size << drv->bBytesPerSectorExp;//size = size << 9;                      // byte size
 280   2      
 281   2      //              UartOutText("-I-: drv->Flag.Fat32 \r\n");       
 282   2              }else{
 283   2                      //size = ( drv->DataStart - drv->RootStart ) << 9;      // byte size
 284   2                      size = ( drv->DataStart - drv->RootStart ) << drv->bBytesPerSectorExp;
 285   2                      //no no no if start = 0 mean in the root area of FAT12/FAT16
 286   2                      start = 0;//??????why is not the drv->RootStart 
 287   2      
 288   2      //              UartOutText("-I-: drv->Flag.Fat16 \r\n");       
 289   2              }
 290   1              //size为根目录区的大小,以byte为单位。          
 291   1              ChainInit(drv, drv->DirStackBuffer, start, size);
 292   1              
 293   1      #if 0   
                      dir = (CHAIN *) drv->DirStackBuffer;
                      UartOutText("-I-:dir->Current: ");UartOutValue(dir->Current, 8);        
                      UartOutText("-I-:dir->Start: ");UartOutValue(dir->Start, 8);    
                      UartOutText("-I-:dir->Point: ");UartOutValue(dir->Point, 8);    
                      UartOutText("-I-:dir->Size: ");UartOutValue(dir->Size, 8);      
              #endif  
 300   1              if(DirCaching(drv) != FS_SUCCEED) return DRIVE_ACCESS_FAIL;
 301   1      
C51 COMPILER V8.01   LIBDIR                                                                04/17/2008 09:45:58 PAGE 6   

 302   1              return FS_SUCCEED;
 303   1      }
 304          
 305          ///
 306          ///@ingroup     DIRECTORY
 307          ///@brief       Move to first available file or sub-dir in the current directory
 308          ///
 309          ///@param       DRIVE *drv              The drive to access
 310          ///
 311          ///@return END_OF_DIR mean no file or sub-dir in the current directory
 312          ///@return ABNORMAL_STATUS move fail
 313          ///@return FS_SUCCEED mean move successful
 314          ///
 315          ///finding the first available file or sub-dir in the current directory of the
 316          ///specified drive, the current node point will move to the found node or at
 317          ///the end of the directory if file not found
 318          BYTE DirFirst(DRIVE *drv)
 319          {
 320   1      //      BYTE result;
 321   1              FDB *node;
 322   1              
 323   1              FirstNode(drv);
 324   1              node = (FDB *)(drv->Node);
 325   1              if(!node->Name[0])      return END_OF_DIR;
 326   1              
 327   1      #if 0   
                      while(ScanFileName(drv) == FILENAME_SCAN_CONTINUE)
                      {
                              result = NextNode(drv);
                              if(result != FS_SUCCEED)        return result;
                      }
              #endif          
 334   1              return FS_SUCCEED;
 335   1      }
 336          
 337          BYTE DirLast(DRIVE *drv)
 338          {
 339   1              if(DirFirst(drv) == END_OF_DIR) return END_OF_DIR;
 340   1      
 341   1              while(NextNode(drv) == FS_SUCCEED);//   WDT = 0x1F;
 342   1      
 343   1      #if 0
                      DirPrevious(drv);
              #else
 346   1              PreviousNode(drv);
 347   1      #endif
 348   1              return FS_SUCCEED;      
 349   1      }
 350          
 351          #if 0
              BYTE DirPrevious(DRIVE *drv)
              {
                      register BYTE first, attr;
                      BYTE    flag;
                      
                      do      
                      {
                              // if no next node can read then return fail
                              if(PreviousNode(drv) != FS_SUCCEED)     
                                      return BEGIN_OF_DIR;
                              
                              first = drv->Node->Name[0];
C51 COMPILER V8.01   LIBDIR                                                                04/17/2008 09:45:58 PAGE 7   

                              attr = drv->Node->Attribute;
              
                              // check if the node is a valid file or sub-dir
                      }while(first == 0xe5 || first == 0x2e || (attr&FDB_LABEL) || attr == 0x0f);
                              
                      if(PreviousNode(drv) == BEGIN_OF_DIR)   
                              DirFirst(drv);
                      else
                      {
                              flag = FS_SUCCEED;
                              while(drv->Node->Attribute == 0x0f && flag == FS_SUCCEED)       
                                      flag = PreviousNode(drv);
                              
                              if(flag == FS_SUCCEED)          
                                      DirNext(drv);
                              else                                            
                                      DirFirst(drv);
                      }
                      
                      return FS_SUCCEED;
              }
              
              
              ///
              ///@ingroup     DIRECTORY
              ///@brief       Move to next available file or sub-dir in the current directory
              ///
              ///@param       DRIVE *drv              The drive to access
              ///
              ///@return END_OF_DIR mean no more file or sub-dir in the current directory
              ///@return ABNORMAL_STATUS move fail
              ///@return FS_SUCCEED mean move successful
              ///
              ///finding next available file or sub-dir in the current directory of the
              ///specified drive, the current node point will move to the found node or at
              ///the end of the directory if file not found
              BYTE DirNext(DRIVE *drv)
              {
                      BYTE    result;
                      
                      do{
                              result = NextNode(drv);
                              if(result != FS_SUCCEED)        return result;
                      }while(ScanFileName(drv) == FILENAME_SCAN_CONTINUE);
              
                      return FS_SUCCEED;
              }
              #endif
 412          
 413          /////////////////////////////////////////////////////////////////////////////
 414          //         Follows function calls are for directory access                                 //
 415          /////////////////////////////////////////////////////////////////////////////
 416          ///
 417          ///@ingroup     DIRECTORY
 418          ///@brief       Enter subdirectory
 419          ///
 420          ///@param       DRIVE *drv              The drive to access
 421          ///
 422          ///@return ABNORMAL_STATUS can open the subdirectory
 423          ///@return FS_SUCCEED enter the subdirectory sucess
 424          ///
 425          BYTE CdSub(DRIVE *drv)
C51 COMPILER V8.01   LIBDIR                                                                04/17/2008 09:45:58 PAGE 8   

 426          {
 427   1              CHAIN *dir;
 428   1              FDB *node;
 429   1              DWORD start, cluster, size;
 430   1      //      WORD *string;
 431   1      
 432   1              node = drv->Node;
 433   1              
 434   1              if(!(node->Attribute&FDB_SUB_DIR))      return ABNORMAL_STATUS;
 435   1              //Here we should check the depth of subdir
 436   1              //if(drv->DirStackPoint == (DIR_STACK_DEEP-1)*sizeof(CHAIN)){ 
 437   1              if(drv->DirStackPoint == (DIR_STACK_DEEP-1)<<CHAIN_SIZEEXP){ 
 438   2                      UartOutText("-W-: DIR_STACK_DEEP \r\n");
 439   2                      //return FS_SUCCEED;//ABNORMAL_STATUS;
 440   2                      return ABNORMAL_STATUS;
 441   2              }
 442   1      /*      
 443   1              string = drv->Path;
 444   1              while(*string)  string ++;      // search to the end of the string
 445   1              string = StringCopy16(string, drv->Name);       // append current node name
 446   1              *string = 0x5c;                         // append '\'
 447   1              string ++;
 448   1              *string = 0;
 449   1      */
 450   1              drv->DirStackPoint += sizeof(CHAIN);
 451   1              dir = (CHAIN *)((BYTE *)drv->DirStackBuffer + drv->DirStackPoint);
 452   1              
 453   1              //start = (LoadAlien16(&node->StartHigh) << 16) + LoadAlien16(&node->StartLow);
 454   1      #if 0
                      start = LoadAlien16(&node->StartHigh);
                      start <<= 16;
                      start +=        LoadAlien16(&node->StartLow);
              #else
 459   1              *((WORD *)(&start)) =  LoadAlien16(&node->StartHigh);
 460   1              *((WORD *)(&start) + 1) =  LoadAlien16(&node->StartLow);
 461   1      #endif
 462   1              size = 0;
 463   1              cluster = start;
 464   1              while(cluster != 0xffffffff){
 465   2                      size += drv->ClusterSize;
 466   2                      //cluster = drv->FatRead(drv, cluster);
 467   2                      cluster = ReadFatxx(cluster);
 468   2              }                       
 469   1              size = size << drv->bBytesPerSectorExp;//size = size << 9;
 470   1              
 471   1              ChainInit(drv, dir, start, size);
 472   1      //      UartOutText("-I-: dir start:"); UartOutValue(start, 8);
 473   1      //      UartOutText("-I-: dir size:"); UartOutValue(size, 8);   
 474   1              if(DirCaching(drv) != FS_SUCCEED) return ABNORMAL_STATUS;
 475   1              
 476   1              return FS_SUCCEED;
 477   1      }
 478          
 479          
 480          ///
 481          ///@ingroup     DIRECTORY
 482          ///@brief       exit the subdirectory
 483          ///
 484          ///@param       DRIVE *drv              The drive to access
 485          ///
 486          ///@return ABNORMAL_STATUS exit fail
 487          ///@return FS_SUCCEED open the subdirectory sucess
C51 COMPILER V8.01   LIBDIR                                                                04/17/2008 09:45:58 PAGE 9   

 488          ///
 489          BYTE CdParent(DRIVE *drv)
 490          {
 491   1      //      WORD *string;
 492   1              
 493   1              if(!drv->DirStackPoint) return FS_SUCCEED; // at root dir
 494   1              
 495   1              drv->DirStackPoint -= sizeof(CHAIN);
 496   1      /*                      
 497   1              // recover the path to upper layer directory
 498   1              string = drv->Path;
 499   1              while(*string)  string ++;      // search to the end of the string
 500   1              string -= 2;
 501   1              while(*string != 0x5c)  string--;               // search the '\'
 502   1              string ++;
 503   1              *string = 0;
 504   1      */      
 505   1              if(DirCaching(drv) != FS_SUCCEED) return ABNORMAL_STATUS;
 506   1              
 507   1              return FS_SUCCEED;
 508   1      }
 509          
 510          #if 0
              BYTE GetLongNameFdbCount()
              {
                      return LongNameFdbCount;
              }
              #endif
 516          


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =   1272    ----
   CONSTANT SIZE    =   ----    ----
   XDATA SIZE       =   ----      67
   PDATA SIZE       =   ----    ----
   DATA SIZE        =   ----    ----
   IDATA SIZE       =   ----    ----
   BIT SIZE         =   ----    ----
END OF MODULE INFORMATION.


C51 COMPILATION COMPLETE.  0 WARNING(S),  0 ERROR(S)

⌨️ 快捷键说明

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