Hoe bereken ik het adres van de eerste copy van FAT en de Root Directory?
Ik wil een functie schrijven dat maakt een file in de Root Directory, en dan schrijft daar een block of data van 512 bytes ...
Ik ben bezig met een data loger, dat schrijft alle data naar de MMC cart, het werkt bijna, de enigste wat ik nog moet aan het praat krijgen is dat hij de data naar een file op MMC schrijft ...
Elektronika: Sensors -> PIC18 - > MMC -> File
Jonathan
"Theorie is alleen te rechtvaardigen als 'n vorm van praktijk. De praktijk staat niet terecht voor 't hooggerechtshof van de theorie" (Stephan Toulmin)
Doot derectory?? ff topictitel aanpassen
logic
Maar dat is logisch ...
Boot directory ?
Volgens mij is dat de Root directory.
Er bestaat wel zoiets als een Bootsector, maar da's een ander verhaal.
Topictitel nog maar een keertje aanpassen?
Jonathan
"Theorie is alleen te rechtvaardigen als 'n vorm van praktijk. De praktijk staat niet terecht voor 't hooggerechtshof van de theorie" (Stephan Toulmin)
Op 16 december 2005 20:02:48 schreef logic:
Boot directory ?Volgens mij is dat de Root directory.
Er bestaat wel zoiets als een Bootsector, maar da's een ander verhaal.
Topictitel nog maar een keertje aanpassen?
bloos bloos
ehhmm de root bevind zich in de root 
tja anders is het niet de root (s) de wortels dat is waar het allemaal begint met meest bovenste level of vanaf de gebruikerskant gezien de onderste 
weet je nog wel in dos gewoon een backslash en je bent er in linux is het cd root geloof ik maar hoe je er met een pic moet koomen weet ik echt niet misschien dat je hier meer kunt vinden -->
http://www.xs4all.nl/~smit/asm01001.htm
het is cursus asmvoor pc`s ...
cd / eigenlijk
je hebt op je / wel een directory genaamd root, maar das ROOT(superuser) zijn homedir, wat verwarrend!
Op 16 december 2005 17:35:58 schreef NIN:
Hoe bereken ik het adres van de eerste copy van FAT en de Root Directory?Ik wil een functie schrijven dat maakt een file in de Root Directory, en dan schrijft daar een block of data van 512 bytes ...
Welk file system? FAT12? FAT16? FAT32?
2 tellen op Google: http://www.win.tue.nl/~aeb/linux/fs/fat/fat-1.html
Op 16 december 2005 22:24:15 schreef MNM(tm):
[...]
Welk file system? FAT12? FAT16? FAT32?2 tellen op Google: http://www.win.tue.nl/~aeb/linux/fs/fat/fat-1.html
;-------------------------------------------------------------
FAT16 is de makkelijkste en efficiënte oplossing ...
Ik weet ongeveer hoe dat kan, maar zelf heb ik het nog nooit gedaan ...
Hieronder beschrijf ik de initialisatie procedure, hoe ik een file wil aanmaken, hoe ik deze file wil vullen met data en hoe ik deze aan het eind wil afsluiten.
Note: De naam van deze topic is dus punt 2 van de initialisatie procedure (zie hieronder).
Initialisatie:
1. Het bepalen van de type van de file system. (de eerste byte van sector 0, moet 0xEB zijn) als het geen FAT16 is, dan print "format MMC met FAT16"; goto ERROR;
2. Bereken vanaf welke adres de eerste kopie van FAT begint en ook waar Root Directory begint.
3. Kopie BPB naar RAM
4. Bereken het aantal sectors op MMC.
Create file:
1.In de Root Directory zoeken naar een lege directory entry, dat kan een element zijn die verwijderd was (de eerste byte van de file name veld 0xE5), of vrije element (de eerste byte van de file name veld 0x00)
2. Zoek naar de vrije cluster in de FAT, vrije cluster heeft 0x0000 als inhoud.
3. Nu moeten we aangeven dat de cluster bezet is door onze file, hier voor schrijven we in de FAT entry de nummer van de volgende cluster.
4. Nu wijzigen we de gevonden directory entry (let op punt 1) aan. Daar schrijven we de naam van de file, de data, de grootte en de nummer van de cluster waarmee de file begint. (let op punt 3)
Write one block (sector) to the file:
1. als de cluster op is, zoek naar de nieuwe cluster (hetzelfde als punt 2 van de creatie van de file) en markeer die als een bezette cluster. Dan bereken de eerste sector van de gevonden cluster. Dat is de plaats waar we de inhoud van de file gaan schrijven.
2. Bereken de nummer van de sector die we gaan vullen met de inhoud van de file. = Deze is de nummer van de sector waarmee de cluster begint + nummer van de sector in de cluster.
3. kopieer de blok van 512 byte naar deze sector.
Close file:
1. schrijf FFF8 - FFFF(End of chain) naar de entry in de FAT.
2. Wijzig "FileSize" in de DirectoryEntry. (deze operatie lijkt op de operatie van punt 4, Create file)
Ik had het idee daar ook ooit nog eens aan te beginnen. Maar de problematiek van het netjes onderhouden van een filesysteem is aardig complex. Nu zal MMC nog meevallen, maar er zijn al velen ons voorgegaan die het met een SD-Card hebben geprobeerd en daar lelijk van teruggekomen zijn. Kaarten die behandelt zijn door de micro die daarna dan weer wel/niet in een camera werken of wel /niet in een PC. De echte spec moet je blijkbaar voor betalen en heeft wat trukerij rondom het bootsector/fat/schaduwfat gebeuren wat blijkbaar anders is dan bij floppies en harde schijven. Mogelijk is er vanwege de beperkte levensduur van een flash-sector een soort 'reserve systeem' in ontworpen.
Zelf zou ik denk ik gaan doen zoals iemand anders dat eens succesvol uitgevoerd:
* Maak op je PC (in windows of zo) een paar grote files aan op je Card die je vult met 0xFF, 0x00, spaties of ^Z.
* Zoek uit bij welk blok deze beginnen.
* Hardcode het schrijven in je micro vanaf deze startblokken.
Dan hoef je geen FAT meer bij te houden (die is al gevuld). Alleen moet je PC programmatuur kunnen zien wanneer de fileinhoud ten einde is.
Dat bespaart je een hoop hoofdbrekens.
gradtje
Ja... en toen ?
Goeie workaround
Ik heb er nog een, schrijf "raw" op je kaart, dwz rag de data er zo op als jouw het uitkomt.
Ik weet niet of het voor MS bestaat, voor linux zijn er tools om raw te lezen/schrijven op disks.
Als je toch door wilt met een filesystem, kijk eens op internet naar de mp3 spelers.
En nog een paar linkjes die ik zo ken:
http://home.nikocity.de/andymon/hfg/Alya/alya.html
http://www.cc5x.de/MMC/MMC_FAT.htm
Nog een bemoedigende opmerking, lezen is één, schrijven nog iets heel anders
Op 18 december 2005 02:44:01 schreef gradtje:
Goeie workaround
Ik heb er nog een, schrijf "raw" op je kaart, dwz rag de data er zo op als jouw het uitkomt.
Ik weet niet of het voor MS bestaat, voor linux zijn er tools om raw te lezen/schrijven op disks.Als je toch door wilt met een filesystem, kijk eens op internet naar de mp3 spelers.
En nog een paar linkjes die ik zo ken:
http://home.nikocity.de/andymon/hfg/Alya/alya.html
http://www.cc5x.de/MMC/MMC_FAT.htmNog een bemoedigende opmerking, lezen is één, schrijven nog iets heel anders
Deze heb ik al gezien: http://www.cc5x.de/MMC/MMC_FAT.htm
Het probleem is dat ik snap niet wat hij doet 
Kan iemand mij uitleggen de essentie van de beneden geplaatste code ?
// Ermitteln von Anfang jedes Bereiches
AL=0; // 3
AH=0;
BytN=0x1C6;
Byte_lesen();
AL=ByteLes; // 4
BytN=0xE; // 5
Byte_lesen();
FAT=ByteLes+AL; // 6
BytN=0x16; // 7
Byte_lesen();
ByteLes=ByteLes*2;
Verz=FAT+ByteLes; // 8
Dat=Verz+32; // 9, 10
Suche("TEST TXT"); // 11
while(ByteLes != 0xFFFF)// 12, 25
{
Claster=ByteLes; // 13
Claster=Claster-2; // 14
AL=Claster; // 15
Carry=0; // 16 Hier werden Grenzen der wariable berücksichtigt
AL = rl(AL); // Multiplizieren mit 2 mit Eubertrag
AH = rl(AH);
#asm // 17
MOVF Dat+1,W
ADDWF AL+1,1
MOVF Dat,W
ADDWF AL,1
BTFSS 0x03,Carry
GOTO keinCarry
BCF 0x03,Carry
INCF AL+1,1
BTFSC 0x03,Carry
INCF AH,1
keinCarry:
#endasm
Lesen(AH,AL); // 18 Erste Block des Clasters
Carry=0; // 19
AL++;
if(Carry)AH++; // Hier werden Grenzen der wariable berücksichtigt
Lesen(AH,AL); // 20 Zweite Block des Clasters
AL=FAT; // 21 nexte Claster
temp=ByteLes/0x100;
AL=AL+temp; // 22
temp=temp*0x100; // 23
BytN=ByteLes-temp;
BytN=BytN*2;
Byte_lesen(); // 24
}
while(1);
// Ermitteln von Anfang jedes Bereiches
AL=0; // 3
AH=0;
BytN=0x1C6;
Byte_lesen();
AL=ByteLes; // 4
BytN=0xE; // 5
Byte_lesen();
FAT=ByteLes+AL; // 6
BytN=0x16; // 7
Byte_lesen();
ByteLes=ByteLes*2;
Verz=FAT+ByteLes; // 8
Dat=Verz+32; // 9, 10
Bij //3 worden 2 bytes (eigenlijk een word, want ByteLes = 16-bits) vanaf locatie 0x1C6 uit de bootsector gelezen (AH,AL = 0x0000). De eerste gelezen byte (die op 0x1C6) wordt in de laagste 8 bits van ByteLes gezet, de volgende byte gaat in de hoogste 8 bits. Ik heb geen flauw idee wat daar te vinden is.
De laagste 8 bits worden vervolgens in register AL gezet.
(Rare constructie trouwens: bij //4 wordt de inhoud van een 16-bits variabele in een 8-bit register gegooid. Als ik de compiler was, zou ik daar toch gigantisch over gaan mekkeren!)
Bij //5 hebben we nu een nieuw sectornummer in AH,AL staan. In deze sector vragen we de inhoud van locatie 0xE op. Blijkbaar is hier de locatie van de FAT opgeslagen. Echter wordt er nog een keer de inhoud van AL bij opgeteld. Waarom??? Ik vermoed dat dat de waarde van AL die we bij //4 verkregen hebben een soort algemene offset is.
Bij //7 gaan we kijken hoeveel sectors per FAT er zijn.
Bij //8 rekenen we uit waar de eerste sector van de root-directory is.
Bij //9 rekenen we uit waar de eerste sector van het data-gebied is.
3 2 Byte-Wert lesen von Sektor 0, Position 1C6h, das ist Master Boot Record 1. Partitionseintrag (1BEh)
1C6h-1BEh=8 an dieser Stelle in dem Partitionseintrag ist ein Wert abgespeichert, der der Abstand zwischen MBR-Sektor und dem ersten Sektor der Partition in Sektoren angibt.
3 2 Byte waarde lezen uit sector 0, positie 1C6h, dat is Master Boot Record 1. Partitietabel (1BEh) 1C6h - 1BEh = 8. Op deze locatie in de partitietabel is een waarde opgeslagen die de afstand tussen de MBR-sector en de eerste sector van de partitie in sectoren aangeeft.4 Diese 2 Byte-Wert in AL übertragen, AL enthält jetzt Anfangadresse des Volume Boot Records.
4 Deze 2 byte waarde in AL zetten. AL bevat nu het beginadres van het Volume Boot Record.5 2 Byte-Wert lesen von Sektor =Anfangadresse des Volume Boot Records, Position Eh. Das ist Anzahl der reservierten Sektoren.
5 2 byte waarde lezen uit positie Eh van het Volume Boot Record. Dit is het aantal gereserveerde sectoren.6 Anfangadresse des Volume Boot Records addieren mit Anzahl der reservierten Sektoren und Ergebnis in Variable "FAT" speichern. Das ist nämlich Anfangsadresse der FAT- Tabelle.
6 Beginadres van het Volume Boot Record optellen bij het aantal gereserveerde sectoren en in de variabele "FAT" opslaan. Dit is namelijk het beginadres van de FAT-tabel.7 2 Byte-Wert lesen von Sektor =Anfangadresse des Volume Boot Records, Position 16h. Das ist Anzahl Sectors Per FAT. Da wir 2 FAT- Tabellen haben (FAT und seine Kopie), erhaltene Wert mit 2 multiplizieren, damit wir auf gesamte Anzahl der Sectors die für FAT belegt sind kommen.
7 2 byte waarde lezen uit positie 16h van het Volume Boot Record. Dit is het aantal sectoren per FAT. Omdat we 2 FAT-tabellen hebben (FAT en z'n kopie), de gevonden waarde met 2 vermenigvuldigen, zodat we het totaal aantal sectoren van beide FAT's krijgen.8 Berechnen des Anfangadresse der Verzeichniseinträgen: Anfangsadresse der FAT- Tabelle addieren mit Anzahl Sectors, die für FAT belegt sind. Das Ergebnis wird in Variable "Verz" abgelegt.
8 Beginadres van de root-directory berekenen: beginadres van de FAT-tabel optellen bij het aantal sectoren die de FAT in beslag neemt. Het resultaat wordt opgeslagen in "Verz".9 Als Nächstes wird Anzahl der Sektoren berechnet, die für Verzeichniseinträgen (Hauptverzeichnis) reserviert sind.
Dafür gibt es Formel: (Anzahl Verzeichniseinträgen)*32/512. Aus mehreren Quellen habe ich erfahren, dass Anzahl Verzeichniseinträgen immer für 512 Einträge reserviert ist. Also Anzahl der Sektoren, die für Verzeichniseinträgen (Hauptverzeichnis) reserviert sind: 512*32/512= 32.
9 Vervolgens wordt het aantal sectoren berekend, dat voor de indextabel (root-directory) gereserveerd is.
Daarvoor geldt de formule: (aantal directory-ingangen)*32/512. Uit meerdere bronnen heb ik vernomen dat dit aantal altijd op 512 staat. Daardoor geldt dat er voor de root-directory 512*32/512 = 32 sectoren gereserveerd is.10 Adresse des ersten Sektors des Datenbereichs (Cluster0) berechnen. Addieren des Anfangadresse der Verzeichniseinträgen mit Anzahl der Verzeichniseinträgen-Sektoren (32). Das Ergebnis wird in Variable "Dat" abgespeichert. Damit sind alle Anfangsektoren der FAT-Strukturen gefunden und in Variablen "FAT", "Verz", "Dat" abgespeichert.
10 Adres van de eerste eerste sector van het datagebied (cluster 0) berekenen. Eerste adres van de root-directory optellen bij het aantal sectoren van de root-directory (32). Het resultaat wordt opgeslagen in "Dat". Hiermee zijn alle beginsectoren van de FAT-structuur gevonden en in de variabelen "FAT, 'Verz" en "Dat" opgeslagen.
[Bericht gewijzigd door MNM(tm) op ]