//*************************************************************************************************************** // geht reihen weise durch sektoren des clusters mit dem startsektor:sec, und sucht nach der datei mit dem // namen:name. es werden die einzelnen sektoren nachgeladen auf puffer:sector vor dem bearbeiten. // wird die datei in dem cluster gefunden ist return 0 , sonst return1. //*************************************************************************************************************** unsigned char fat_loadFileDataFromCluster(unsigned long int sec , char name[]){ unsigned char r; unsigned char s=0; do{ // sektoren des clusters prüfen r=0; // neuer sektor, dann reihen von 0 an. mmc_read_sector(sec+s,fat.sector); // läd den sektor sec auf den puffer fat.sector fat.currentSectorNr=sec+s; // setzen des aktuellen sektors do{ // reihen des sektors prüfen fat_loadRowOfSector(r); // zeile 0-15 auf struct file laden if(file.name[0]==0){ // wenn man auf erste 0 stößt müsste der rest auch leer sein! file.row=r; // zeile sichern. return(1); } if(0==strncmp((char*)file.name,name,10)){ // zeile r ist gesuchte file.row=r; // zeile sichern. return(0); } r++; }while(r<16); // zählt zeilennummer (16(zeilen) * 32(spalten) == 512 bytes des sektors) s++; }while(s<fat.secPerClust); // geht durch sektoren des clusters return (1); // fehler (datei nicht gefunden, oder fehler beim lesen) }
//*************************************************************************************************************** // läd sektor:sec auf puffer:sector zum bearbeiten im ram ! // setzt currentSectorNr auf richtigen wert (also den sektor der gepuffert ist). es wird geprüft // ob der gepufferte sektor geändert wurde, wenn ja muss erst geschrieben werden, um diese daten nicht zu verlieren ! //*************************************************************************************************************** unsigned char fat_loadSector(unsigned long int sec){ if(sec!=fat.currentSectorNr){ // nachladen nötig #if (WRITE==1) if(fat.bufferDirty==1) fat_writeSector(fat.currentSectorNr); // puffer diry, also vorher schreiben #endif mmc_read_sector(sec,fat.sector); // neuen sektor laden fat.currentSectorNr=sec; // aktualisiert sektor nummer (nummer des gepufferten sektors) return(0); } else return(0); // alles ok, daten sind schon da (sec==fat.currentSectorNr) return(1); // fehler }
DRESULT disk_read (BYTE pdrv, BYTE *buff, DWORD sector, BYTE count) { if (mmc_state != MMC_READY) { return RES_NOTRDY; } if (mmc_start_read(sector)) { return RES_ERROR; } while (count > 0) { if (mmc_read_sector(buff)) { return RES_ERROR; } buff += 512; count--; } if (mmc_stop_read()) { return RES_ERROR; } return RES_OK; }
//******************************************************************************************************************************* // schreibt 512 byte blöcke auf den puffer fat.sector. dann wird dieser auf die karte geschrieben. wenn genügend feie // sektoren zum beschreiben bekannt sind, muss nicht in der fat nachgeschaut werden. sollten nicht genügend zusammenhängende // sektoren bekannt sein(datenmenge zu groß), werden die alten verkettet und neue gesucht. es ist nötig sich den letzten bekannten einer // kette zu merken -> file.lastCluster, um auch nicht zusammenhängende cluster verketten zu können (fat_setClusterChain macht das)! // es ist beim überschreiben nötig, die schon beschriebenen sektoren der datei zu laden, damit man die richtigen daten // hat. das ist blöd, weil so ein daten overhead von 50% entsteht. da lesen aber schneller als schreiben geht, verliert man nicht 50% an geschwindigkeit. //******************************************************************************************************************************* inline void ffwrite(unsigned char c){ fat.sector[file.cntOfBytes++]=c; // schreiben des chars auf den puffer sector und zähler erhöhen (pre-increment) fat.bufferDirty=1; // puffer dirty weil geschrieben und noch nicht auf karte. if( file.cntOfBytes==512 ){ /** SEKTOR VOLL ( 2 möglichkeiten ab hier !) **/ file.cntOfBytes=0; // rücksetzen des sektor byte zählers. mmc_write_sector(fat.currentSectorNr,fat.sector); /** 1.) vollen sektor auf karte schreiben**/ fat.bufferDirty=0; // puffer jetzt clear, weil grade alles geschrieben. file.seek+=512; // position in der datei erhöhen, weil grade 512 bytes geschrieben. if( fat.currentSectorNr==fat.endSectors ){ /** 2.) es ist nötig, neue freie zu suchen und die alten zu verketten (mit ein bischen glück nur alle 512*MAX_CLUSTERS_IN_ROW bytes) **/ if( file.seek > file.length ){ // außerhalb der datei !! fat_setClusterChain( fat_secToClust(fat.startSectors) , fat_secToClust(fat.endSectors) ); // verketten der beschriebenen. fat_getFreeClustersInRow( file.lastCluster ); // neue leere sektoren benötigt, also suchen. } else { fat_getFatChainClustersInRow( fat_getNextCluster(file.lastCluster) ); // noch innerhalb der datei, deshlab verkettete suchen. } fat.currentSectorNr=fat.startSectors-1; // setzen des 1. sektors der neuen reihe zum schreiben. } fat.currentSectorNr++; // nächsten sektor zum beschreiben. mmc_read_sector(fat.currentSectorNr,fat.sector); // wegen überschreiben, muss der zu beschreibende sektor geladen werden... } }