#include #include #include "main.h" #include "hardware.h" #include "fat.h" #include "file.h" //******************************************************************************************************************************* // 2 möglichkeiten beim öffnen, datei existiert(return 1) oder muss angelegt werden(return 2) // zuerst wird geprüft ob es die datei im verzeichniss gibt. danach wird entschieden, ob die datei geöffnet wird oder angelegt. // -beim offnen werden die bekannten cluster gesucht maximal MAX_CLUSTERS_IN_ROW in reihe. dann wird der 1. sektor der datei auf // den puffer fat.sector geladen. jetzt kann man ffread lesen... // -beim anlegen werden freie cluster gesucht, maximal MAX_CLUSTERS_IN_ROW in reihe. dann wird das struct file gefüllt. // danach wird der dateieintrag gemacht(auf karte). dort wird auch geprüft ob genügend platz im aktuellen verzeichniss existiert. // möglicherweise wird der 1. cluster der datei nochmal geändert. jetzt ist der erste frei sektor bekannt und es kann geschrieben werden. //******************************************************************************************************************************* unsigned char ffopen(char name[]){ unsigned char file_flag=fat_loadFileDataFromDir(name); //prüfung ob datei vorhanden und evetuelles laden des file struct if( file_flag==0 ){ /** Datei existiert, anlegen nicht nötig! **/ fat_getFatChainClustersInRow( file.firstCluster ); // verkettete cluster aus der fat-chain suchen. fat_loadSector( fat_clustToSec(file.firstCluster) ); // lät die ersten 512 bytes der datei auf puffer:sector. file.lastCluster=fat_secToClust(fat.endSectors); // letzter bekannter cluster der datei return 1; } #if (WRITE==1) // anlegen ist schreiben ! else{ /** Datei existiert nicht, also anlegen ! (nur wenn schreiben option an ist)**/ fat_getFreeClustersInRow(2); // leere cluster suchen, ab cluster 2. strcpy((char*)file.name,(char*)name); // --- füllen des file struct, zum abschließenden schreiben. file.firstCluster=fat_secToClust(fat.startSectors); // 1. cluster der datei file.lastCluster=file.firstCluster;//fat_secToClust(fat.endSectors); // letzter bekannter cluster der datei file.attrib=32; // --- file.row wird in der funktion fat_getFreeRowOfDir geschrieben !! file.length=0; // damit da nix drin steht ^^ fat_makeFileEntry((char *)file.name,file.attrib,0); // DATEI ANLEGEN auf karte fat.currentSectorNr=fat_clustToSec(file.firstCluster); // setzen des ersten sektors return 2; } #endif } //******************************************************************************************************************************* // schließt die datei operation ab. eigentlich nur nötig wenn geschrieben wurde. es gibt 2 möglichkeiten : // 1. die datei wird geschlossen und es wurde über die alte datei länge hinaus geschrieben. // 2. die datei wird geschlossen und man war innerhalb der datei größe, dann muss nur der aktuelle sektor geschrieben werden. // der erste fall ist komplizierter, weil ermittelt werden muss wie viele sektoren neu beschrieben wurden um diese zu verketten // und die neue datei länge muss ermitt weden. abschließend wird entweder (fall 2) nur der aktuelle sektor geschrieben, oder // der aktuallisierte datei eintrag und die cluster (diese werden verkettet, siehe fileUpdate() ). //******************************************************************************************************************************* unsigned char ffclose(void){ #if (WRITE==1) /** 2 möglichkeiten beim schließen !! (lesend spielt keine rolle, nichts muss geupdatet werden) **/ if( file.length < (file.seek+file.cntOfBytes) ) fileUpdate(); /** 1.) es wurde über die alte datei größe hinaus geschrieben **/ else if( fat.bufferDirty==1) fat_writeSector( fat.currentSectorNr ); /** 2.) nicht über alte datei länge hinaus **/ #endif file.cntOfBytes=0; // init werte der nötigen zähler file.seek=0; return(0); } // ******************************************************************************************************************************* // updatet datei eintrag auf der karte und verkettet die dazugehörigen fat cluster. // füllt den aktuell beschriebenen sektor mit 0x00, da sonst die datei nicht richtig angezeigt wird. // darf nur während schreibe operationen aufgerufen werden ! // ******************************************************************************************************************************* void fileUpdate(void){ unsigned int comp_cntOfBytes=file.cntOfBytes; // sicher nötig wegen schleife... while( comp_cntOfBytes < 512 ){ // sektor ist beschrieben worden, daher nötigenfalls mit 00 füllen fat.sector[comp_cntOfBytes]=0x00; // beschreibt ungenutzte bytes mit 0x00 comp_cntOfBytes++; } char name[13]; // zum sichern des dateinamens unsigned long int save_length = file.cntOfBytes + file.seek; // muss gesichert werden, wird sonst von der karte geladen und verändert ! strcpy(name,(char *)file.name); // muss gesichert werden, wird sonst von der karte geladen und verändert ! fat_setClusterChain(fat_secToClust(fat.startSectors),fat_secToClust(fat.currentSectorNr)); // verketten der geschriebenen cluster fat_loadFileDataFromDir(name); // läd sektor, des datei eintrags, und läd daten von karte auf struct file! fat_makeRowDataEntry(file.row,name,32,file.firstCluster,save_length); // macht eintrag im puffer fat_writeSector(fat.currentSectorNr); } // ******************************************************************************************************************************* // offset byte wird übergeben. es wird durch die sektoren der datei gespult (gerechnet), bis der sektor mit dem offset byte erreicht // ist, dann wird der sektor geladen und der zähler für die bytes eines sektors gesetzt. wenn das byte nicht in den sektoren ist, // die "vorgesucht" wurden, müssen noch weitere sektoren der datei gesucht werden (sec > fat.endSectors). // ******************************************************************************************************************************* void ffseek(unsigned long int offset){ #if (OVER_WRITE==1) // man muss den dateieintrag updaten, um die daten zu retten !! if( file.seek > file.length ) fileUpdate(); // fat verketten und datei update auf der karte ! #endif fat_getFatChainClustersInRow(file.firstCluster); // suchen von anfang der cluster chain aus ! unsigned long int sec=fat.startSectors; // sektor variable zum durchgehen durch die sektoren file.seek=0; // weil auch von anfang an der chain gesucht wird mit 0 initialisiert while(offset>=512){ /** suchen des sektors in dem offset ist **/ sec++; // da byte nicht in diesem sektor ist, muss hochgezählt werden offset-=512; // ein sektor weniger in dem das byte sein kann file.seek+=512; // file.seek update, damit bei ffclose() die richtige file.length herauskommt if ( sec > fat.endSectors ){ // es müssen mehr sektoren der datei gesucht werden fat_getFatChainClustersInRow(fat_getNextCluster( file.lastCluster ) ); // nachladen von clustern in der chain sec=fat.startSectors; // setzen des 1. sektors der neu geladenen, zum weitersuchen ! } } file.lastCluster=fat_secToClust(fat.endSectors); // letzter bekannter cluster der datei fat_loadSector(sec); // sektor mit offset byte laden file.cntOfBytes = offset; // setzen des lese zählers } #if (SMALL_FILE_SYSTEM==0) // ******************************************************************************************************************************* // wechselt verzeichniss. start immer im root Dir. // MUSS in das direktory gewechselt werden, in dem die datei zum lesen/schreiben ist ! // ******************************************************************************************************************************* unsigned char ffcd(char name[]){ return(fat_cd(name)); } // ******************************************************************************************************************************* // zeigt reihen eines clusters an, wird für ffls benötigt ! // es wird ab dem start sektor start_sec, der dazugehörige cluster angezeigt. geprüft wird ob es ein richtiger // eintrag in der reihe ist (nicht gelöscht, nicht frei usw). die sektoren des clusters werden nachgeladen. // die dateien werden mit namen und datei größe angezeigt. // ******************************************************************************************************************************* void lsRowsOfClust (unsigned long int start_sec){ unsigned char row; // reihen unsigned char sec=0; // sektoren unsigned char tmp[12]; // tmp string zur umwandlung do{ fat_loadSector(start_sec + sec); // sektoren des clusters laden for(row=0;row<16;row++){ // geht durch reihen des sektors fat_loadRowOfSector(row); // reihe eines sektors (auf dem puffer) laden if( (file.attrib==0x20||file.attrib==0x10) && (file.name[0]!=0xE5 && file.name[0]!=0x00) ){ uputs(file.name); uputc(' '); ultoa(file.length,(char*)tmp,10); uputs(tmp); uputc('\n'); } } }while(++sec=0){ // gibt es einen eintrag davor ? if(fat.sector[(file.row<<5)-21]==0x0f)fat.sector[(file.row<<5)-32]=0xE5; // langer datei eintag auch gelöscht. } fat.bufferDirty=1; // eintrag in puffer gemacht. if(0==fat_getNextCluster(file.firstCluster)) return(0); // 1.cluster ist leer ?!? fat_delClusterChain(file.firstCluster); // löscht die zu der datei gehörige cluster-chain aus der fat. return(0); } //TODO noch nicht optimal. zu viele schreib vorgänge beim löschen von datei einträgen. max bis zu 16/sektor ! else{ // ist ordner, dann rekursiv löschen !! #ifndef __AVR_ATmega8__ // mega8 zu klein für die funktionalität.... unsigned long int parent; unsigned long int own; unsigned long int clustsOfDir; // um durch die cluster chain eines dirs zu gehen. unsigned char cntSecOfClust=0; unsigned char i=0; fat.sector[file.row<<5]=0xE5; // löscht dir eintrag if((file.row-1)>=0){ // gibt es einen eintrag davor (langer datei eintrag)? if(fat.sector[(file.row<<5)-21]==0x0f)fat.sector[(file.row<<5)-32]=0xE5; // langer datei eintag auch gelöscht } fat.bufferDirty=1; // puffer eintrag gemacht parent=fat.dir; // der ordner in dem der zu löschende ordner ist. own=file.firstCluster; // der 1. cluster des ordners der zu löschen ist. clustsOfDir=file.firstCluster; // die "cluster" des zu löschenden ordners do{ // geht durch cluster des dirs fat_loadSector(fat_clustToSec(clustsOfDir)); // sektor des dirs laden do{ // geht durch sektoren des clusters do{ // geht durch reihen des sektors fat_loadRowOfSector(i); if(file.attrib!=0x10 && file.attrib!=0x00 && file.name[0]!=0xE5){ // ist kein ordner,noch nicht gelöscht, kein freier eintrag fat.sector[i<<5]=0xE5; // erster eintrag der reihe als gelöscht markiert fat.bufferDirty=1; // puffer eintrag gemacht if(file.attrib==0x20){ // ist datei! fat_delClusterChain(file.firstCluster); // ist datei, dann cluster-chain der datei löschen fat_loadSector(fat_clustToSec(clustsOfDir)+cntSecOfClust); // sektor neu laden, weil löschen der chain, den puffer nutzt. } } if(file.attrib==0x10 && file.name[0]=='.'){ // "." oder ".." eintrag erkannt, löschen ! fat.sector[i<<5]=0xE5; // eintrag als gelöscht markiert fat.bufferDirty=1; // puffer eintrag gemacht } if(file.attrib==0x10 && file.name[0]!='.' && file.name[0]!=0xE5 && file.name[0]!=0){ // ordner erkannt ! fat.sector[i<<5]=0xE5; // dir eintrag als gelöscht markiert fat.bufferDirty=1; // puffer eintrag gemacht fat_loadSector(fat_clustToSec(file.firstCluster)); // sektor des dirs laden clustsOfDir=file.firstCluster; // eigenes dir ist file.firstCluster own=file.firstCluster; // eigener start cluster/dir fat_loadRowOfSector(1); // ".." laden um parent zu bestimmen parent=file.firstCluster; // parent sichern. cntSecOfClust=0; // init von gelesenen sektoren und reihen ! i=0; continue; } if(file.name[0]==0x00){ // ende des dirs erreicht, wenn nicht voll !! if(parent==fat.dir){ // erfolgreich alles gelöscht fat_delClusterChain(own); // cluster chain des ordners löschen return(0); } fat_delClusterChain(own); // cluster chain des ordners löschen clustsOfDir=parent; // parent ist jetzt wieder arbeisverzeichniss. own=parent; // arbeitsverzeichniss setzten fat_loadSector(fat_clustToSec(own)); // sektor des dirs laden fat_loadRowOfSector(1); // ".." laden um parent zu bestimmen parent=file.firstCluster; // parent sichern. cntSecOfClust=0; // init von gelesenen sektoren und reihen ! i=0; continue; } i++; }while(i<16); // geht durch reihen des sektors. i=0; // neuer sektor -> reihen von vorne. cntSecOfClust++; fat_loadSector(fat_clustToSec(clustsOfDir)+cntSecOfClust); // läd sektoren des clusters nach }while(cntSecOfClust sektoren von vorne. clustsOfDir=fat_getNextCluster(clustsOfDir); // sucht neuen cluster der cluster-chain. }while( !((clustsOfDir==0xfffffff && fat.fatType==32) || (clustsOfDir==0xffff && fat.fatType==16)) ); // geht durch cluster des dirs. fat_delClusterChain(own); // hier landet man, wenn der ordner voll war (auf cluster "ebene")!! #endif } } return(1); // fehler, nicht gefunden? } #endif //******************************************************************************************************************************* // liest 512 bytes aus dem puffer fat.sector. dann werden neue 512 bytes der datei geladen, sind nicht genügend verkettete // sektoren in einer reihe bekannt, wird in der fat nachgeschaut. dann werden weiter bekannte nachgeladen... //******************************************************************************************************************************* inline unsigned char ffread(void){ if(file.cntOfBytes==512){ /** EINEN SEKTOR GLESEN (ab hier 2 möglichkeiten !) **/ file.cntOfBytes=0; // byte zähler zurück setzen if( fat.currentSectorNr == fat.endSectors ){ /** 1.) nötig mehr sektoren der chain zu laden (mit ein bisschen glück nur alle 512*MAX_CLUSTERS_IN_ROW bytes)**/ fat_getFatChainClustersInRow(fat_getNextCluster(fat_secToClust( fat.endSectors) )); // nachladen von clustern in der chain fat.currentSectorNr=fat.startSectors-1; // setzen des nächsten sektors um weiter lesen zu können.. } fat_loadSector(fat.currentSectorNr+1); /** 2.) die bekannten in einer reihe reichen noch.(nur alle 512 bytes)**/ } return fat.sector[file.cntOfBytes++]; // rückgabe, byte des sektors (NACH rückgabe erhöhen von zähler ! ) } #if (WRITE==1) #if (OVER_WRITE==0) // nicht überschreibende write funktion //******************************************************************************************************************************* // 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(datenmenge zu groß), muss nicht in der fat nachgeschaut werden. sollten nicht genügend // zusammenhängende sektoren bekannt sein, 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)! //******************************************************************************************************************************* 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) **/ fat_setClusterChain( fat_secToClust(fat.startSectors) , fat_secToClust(fat.endSectors) ); // verketten der beschriebenen fat_getFreeClustersInRow(file.lastCluster); // suchen von leeren sektoren. fat.currentSectorNr=fat.startSectors-1; // setzen des 1. sektors der neuen reihe zum schreiben. } fat.currentSectorNr++; // nächsten sektor zum beschreiben. } } #endif #if (OVER_WRITE==1) // überschreibende write funktion, nicht performant, weil immer auch noch ein sektor geladen werden muss //******************************************************************************************************************************* // 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... } } #endif // ******************************************************************************************************************************* // schreibt string auf karte, siehe ffwrite() // ******************************************************************************************************************************* inline void ffwrites(const char *s ){ while (*s) ffwrite(*s++); } #endif