godzil/quickdev16
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cleanup types:

Browse Source
This commit is contained in:
David Voswinkel 2009-08-10 19:34:03 +02:00
parent 8656beb769
commit 9859b1fbc8
5 changed files with 164 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

154
avr/usbload/fat.c
View File

@ -1,6 +1,8 @@
#include <ctype.h>
#include <string.h> #include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include "fat.h" #include "fat.h"
#include "file.h" #include "file.h"
@ -16,7 +18,7 @@ struct File file; // wichtige dateibezogene daten/variablen
// schreibt sektor nummer:sec auf die karte (puffer:sector) !! // schreibt sektor nummer:sec auf die karte (puffer:sector) !!
// setzt bufferFlag=0 da puffer nicht dirty sein kann nach schreiben ! // setzt bufferFlag=0 da puffer nicht dirty sein kann nach schreiben !
// *************************************************************************************************************** // ***************************************************************************************************************
unsigned char fat_writeSector(unsigned long int sec) uint8_t fat_writeSector(uint32_t sec)
{ {
fat.bufferDirty = 0; // buffer kann nicht dirty sein weil wird geschrieben fat.bufferDirty = 0; // buffer kann nicht dirty sein weil wird geschrieben
@ -29,7 +31,7 @@ unsigned char fat_writeSector(unsigned long int sec)
// *************************************************************************************************************** // ***************************************************************************************************************
// umrechnung cluster auf 1.sektor des clusters (möglicherweise mehrere sektoren/cluster) ! // umrechnung cluster auf 1.sektor des clusters (möglicherweise mehrere sektoren/cluster) !
// *************************************************************************************************************** // ***************************************************************************************************************
unsigned long int fat_clustToSec(unsigned long int clust) uint32_t fat_clustToSec(uint32_t clust)
{ {
return (fat.dataDirSec + 2 + ((clust - 2) * fat.secPerClust)); // errechnet den 1. sektor der sektoren des clusters return (fat.dataDirSec + 2 + ((clust - 2) * fat.secPerClust)); // errechnet den 1. sektor der sektoren des clusters
@ -38,7 +40,7 @@ unsigned long int fat_clustToSec(unsigned long int clust)
// *************************************************************************************************************** // ***************************************************************************************************************
// umrechnung sektor auf cluster (nicht die position im cluster selber!!) // umrechnung sektor auf cluster (nicht die position im cluster selber!!)
// *************************************************************************************************************** // ***************************************************************************************************************
unsigned long int fat_secToClust(unsigned long int sec) uint32_t fat_secToClust(uint32_t sec)
{ {
return ((sec - fat.dataDirSec - 2 + 2 * fat.secPerClust) / fat.secPerClust); // umkerhrfunktion von fat_clustToSec return ((sec - fat.dataDirSec - 2 + 2 * fat.secPerClust) / fat.secPerClust); // umkerhrfunktion von fat_clustToSec
@ -50,7 +52,7 @@ unsigned long int fat_secToClust(unsigned long int sec)
// setzt currentSectorNr auf richtigen wert (also den sektor der gepuffert ist). es wird geprüft // 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 ! // 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) uint8_t fat_loadSector(uint32_t sec)
{ {
if (sec != fat.currentSectorNr) { // nachladen nötig if (sec != fat.currentSectorNr) { // nachladen nötig
@ -84,10 +86,10 @@ unsigned char fat_loadSector(unsigned long int sec)
// läd die reihe:row des gepufferten sektors auf das struct:file. dort stehen dann // läd die reihe:row des gepufferten sektors auf das struct:file. dort stehen dann
// alle wichgigen daten wie: 1.cluster,länge bei dateien, name des eintrags, reihen nummer (im sektor), attribut use... // alle wichgigen daten wie: 1.cluster,länge bei dateien, name des eintrags, reihen nummer (im sektor), attribut use...
// *************************************************************************************************************** // ***************************************************************************************************************
unsigned char fat_loadRowOfSector(unsigned int row) uint8_t fat_loadRowOfSector(uint16_t row)
{ {
unsigned char i; uint8_t i;
row = row << 5; // multipliziert mit 32 um immer auf zeilen anfang zu kommen (zeile 0=0,zeile 1=32,zeile 2=62 usw). row = row << 5; // multipliziert mit 32 um immer auf zeilen anfang zu kommen (zeile 0=0,zeile 1=32,zeile 2=62 usw).
void *vsector; // void, damit man schoen umbiegen kann :) void *vsector; // void, damit man schoen umbiegen kann :)
@ -98,13 +100,13 @@ unsigned char fat_loadRowOfSector(unsigned int row)
file.attrib = fat.sector[row + 11]; // datei attribut, byte 11. file.attrib = fat.sector[row + 11]; // datei attribut, byte 11.
vsector = &fat.sector[row + 26]; // low word von fist.cluster vsector = &fat.sector[row + 26]; // low word von fist.cluster
file.firstCluster = *(unsigned short *) vsector; file.firstCluster = *(uint16_t *) vsector;
vsector = &fat.sector[row + 20]; // high word von first.cluster vsector = &fat.sector[row + 20]; // high word von first.cluster
file.firstCluster |= (*(unsigned short *) vsector) << 16; file.firstCluster |= (*(uint16_t *) vsector) << 16;
vsector = &fat.sector[row + 28]; // 4 byte von file.length vsector = &fat.sector[row + 28]; // 4 byte von file.length
file.length = *(unsigned long int *) vsector; file.length = *(uint32_t *) vsector;
return (0); return (0);
} }
@ -115,11 +117,11 @@ unsigned char fat_loadRowOfSector(unsigned int row)
// namen:name. es werden die einzelnen sektoren nachgeladen auf puffer:sector vor dem bearbeiten. // 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. // wird die datei in dem cluster gefunden ist return 0 , sonst return1.
// *************************************************************************************************************** // ***************************************************************************************************************
unsigned char fat_loadFileDataFromCluster(unsigned long int sec, char name[]) uint8_t fat_loadFileDataFromCluster(uint32_t sec, char name[])
{ {
unsigned char r; uint8_t r;
unsigned char s = 0; uint8_t s = 0;
do { // sektoren des clusters prüfen do { // sektoren des clusters prüfen
r = 0; // neuer sektor, dann reihen von 0 an. r = 0; // neuer sektor, dann reihen von 0 an.
@ -149,13 +151,13 @@ unsigned char fat_loadFileDataFromCluster(unsigned long int sec, char name[])
// die datei zu finden. es wird das komplette directory in dem man sich befindet durchsucht. // die datei zu finden. es wird das komplette directory in dem man sich befindet durchsucht.
// bei fat16 wird der rootDir berreich durchsucht, bei fat32 die cluster chain des rootDir. // bei fat16 wird der rootDir berreich durchsucht, bei fat32 die cluster chain des rootDir.
// *************************************************************************************************************** // ***************************************************************************************************************
unsigned char fat_loadFileDataFromDir(char name[]) uint8_t fat_loadFileDataFromDir(char name[])
{ {
unsigned int s; uint16_t s;
if (fat.dir == 0 && fat.fatType == 16) { // IM ROOTDIR. fat16 if (fat.dir == 0 && fat.fatType == 16) { // IM ROOTDIR. fat16
for (s = 0; s < (unsigned int) (fat.dataDirSec + 2 - fat.rootDir); s++) { // zählt durch RootDir sektoren (errechnet anzahl for (s = 0; s < (uint16_t) (fat.dataDirSec + 2 - fat.rootDir); s++) { // zählt durch RootDir sektoren (errechnet anzahl
// rootDir sektoren). // rootDir sektoren).
if (0 == fat_loadFileDataFromCluster(fat.rootDir + s, name)) if (0 == fat_loadFileDataFromCluster(fat.rootDir + s, name))
return (0); // sucht die datei, wenn da, läd daten (1.cluster usw) return (0); // sucht die datei, wenn da, läd daten (1.cluster usw)
@ -163,7 +165,7 @@ unsigned char fat_loadFileDataFromDir(char name[])
} }
else { else {
unsigned long int i; uint32_t i;
if (fat.dir == 0 && fat.fatType == 32) if (fat.dir == 0 && fat.fatType == 32)
i = fat.rootDir; // IM ROOTDIR. fat32 i = fat.rootDir; // IM ROOTDIR. fat32
else else
@ -186,7 +188,7 @@ unsigned char fat_loadFileDataFromDir(char name[])
// start immer im root Dir. start in root dir (dir==0). // start immer im root Dir. start in root dir (dir==0).
// es MUSS in das direktory gewechselt werden, in dem die datei zum lesen/anhängen ist (außer root, da startet mann)! // es MUSS in das direktory gewechselt werden, in dem die datei zum lesen/anhängen ist (außer root, da startet mann)!
// *************************************************************************************************************** // ***************************************************************************************************************
unsigned char fat_cd(char name[]) uint8_t fat_cd(char name[])
{ {
if (name[0] == 0) { // ZUM ROOTDIR FAT16/32 if (name[0] == 0) { // ZUM ROOTDIR FAT16/32
@ -218,11 +220,11 @@ unsigned char fat_cd(char name[])
// wird ein freier eintrag gefunden, ist die position der freien reihe auf file.row abzulesen und return (0). // wird ein freier eintrag gefunden, ist die position der freien reihe auf file.row abzulesen und return (0).
// der sektor mit der freien reihe ist auf dem puffer:sector gepuffert. // der sektor mit der freien reihe ist auf dem puffer:sector gepuffert.
// **************************************************************************************************************** // ****************************************************************************************************************
unsigned char fat_getFreeRowOfCluster(unsigned long secStart) uint8_t fat_getFreeRowOfCluster(unsigned long secStart)
{ {
unsigned int b; // zum durchgenen der sektor bytes uint16_t b; // zum durchgenen der sektor bytes
unsigned char s = 0; // sektoren des clusters. uint8_t s = 0; // sektoren des clusters.
do { do {
file.row = 0; // neuer sektor(oder 1.sektor), reihen von vorne. file.row = 0; // neuer sektor(oder 1.sektor), reihen von vorne.
@ -246,10 +248,10 @@ unsigned char fat_getFreeRowOfCluster(unsigned long secStart)
// 1. sektor des freien clusters geladen. die reihe wird auf den ersten eintrag gesetzt, da frei. // 1. sektor des freien clusters geladen. die reihe wird auf den ersten eintrag gesetzt, da frei.
// anhand der reihe kann man nun den direktory eintrag vornehmen, und auf die karte schreiben. // anhand der reihe kann man nun den direktory eintrag vornehmen, und auf die karte schreiben.
// **************************************************************************************************************** // ****************************************************************************************************************
void fat_getFreeRowOfDir(unsigned long int dir) void fat_getFreeRowOfDir(uint32_t dir)
{ {
unsigned long int start = dir; uint32_t start = dir;
// solange bis ende cluster chain. // solange bis ende cluster chain.
while (! while (!
@ -272,12 +274,12 @@ void fat_getFreeRowOfDir(unsigned long int dir)
fat.currentSectorNr = fat_clustToSec(dir); // setzen des richtigen sektors, also auf den 1. der neu verketteten fat.currentSectorNr = fat_clustToSec(dir); // setzen des richtigen sektors, also auf den 1. der neu verketteten
unsigned int j = 511; uint16_t j = 511;
do { do {
fat.sector[j] = 0x00; // schreibt puffer fat.sector voll mit 0x00==leer fat.sector[j] = 0x00; // schreibt puffer fat.sector voll mit 0x00==leer
} while (j--); } while (j--);
unsigned char i = 1; // ab 1 weil der 1.sektor des clusters eh noch beschrieben wird... uint8_t i = 1; // ab 1 weil der 1.sektor des clusters eh noch beschrieben wird...
do { do {
fat_writeSector(fat.currentSectorNr + i); // löschen des cluster (überschreibt mit 0x00), wichtig bei ffls, fat_writeSector(fat.currentSectorNr + i); // löschen des cluster (überschreibt mit 0x00), wichtig bei ffls,
i++; i++;
@ -292,8 +294,8 @@ void fat_getFreeRowOfDir(unsigned long int dir)
// erstellt eintrag in reihe:row, mit namen:name usw... !! // erstellt eintrag in reihe:row, mit namen:name usw... !!
// muss noch auf die karte geschrieben werden ! nicht optimiert auf geschwindigkeit. // muss noch auf die karte geschrieben werden ! nicht optimiert auf geschwindigkeit.
// *************************************************************************************************************** // ***************************************************************************************************************
void fat_makeRowDataEntry(unsigned int row, char name[], unsigned char attrib, void fat_makeRowDataEntry(uint16_t row, char name[], uint8_t attrib,
unsigned long int cluster, unsigned long int length) uint32_t cluster, uint32_t length)
{ {
fat.bufferDirty = 1; // puffer beschrieben, also neue daten darin(vor lesen muss geschrieben werden) fat.bufferDirty = 1; // puffer beschrieben, also neue daten darin(vor lesen muss geschrieben werden)
@ -301,8 +303,8 @@ void fat_makeRowDataEntry(unsigned int row, char name[], unsigned char attrib,
row = row << 5; // multipliziert mit 32 um immer auf zeilen anfang zu kommen (zeile 0=0,zeile 1=32,zeile 2=62 ... zeile row = row << 5; // multipliziert mit 32 um immer auf zeilen anfang zu kommen (zeile 0=0,zeile 1=32,zeile 2=62 ... zeile
// 15=480) // 15=480)
unsigned char i; // byte zähler in reihe von sektor (32byte eintrag) uint8_t i; // byte zähler in reihe von sektor (32byte eintrag)
unsigned char *bytesOfSec = &fat.sector[row]; // zeiger auf sector bytes uint8_t *bytesOfSec = &fat.sector[row]; // zeiger auf sector bytes
void *vsector; void *vsector;
for (i = 0; i < 11; i++) for (i = 0; i < 11; i++)
@ -311,20 +313,20 @@ void fat_makeRowDataEntry(unsigned int row, char name[], unsigned char attrib,
*bytesOfSec++ = attrib; // attrib schreiben *bytesOfSec++ = attrib; // attrib schreiben
vsector = &fat.sector[row + 12]; vsector = &fat.sector[row + 12];
*(unsigned long int *) vsector++ = 0x01010101; // unnoetige felder beschreiben *(uint32_t *) vsector++ = 0x01010101; // unnoetige felder beschreiben
*(unsigned long int *) vsector = 0x01010101; *(uint32_t *) vsector = 0x01010101;
vsector = &fat.sector[row + 20]; vsector = &fat.sector[row + 20];
*(unsigned short *) vsector = (cluster & 0xffff0000) >> 16; // low word von cluster *(uint16_t *) vsector = (cluster & 0xffff0000) >> 16; // low word von cluster
vsector = &fat.sector[row + 22]; vsector = &fat.sector[row + 22];
*(unsigned long int *) vsector = 0x01010101; // unnoetige felder beschreiben *(uint32_t *) vsector = 0x01010101; // unnoetige felder beschreiben
vsector = &fat.sector[row + 26]; vsector = &fat.sector[row + 26];
*(unsigned short *) vsector = (cluster & 0x0000ffff); // high word von cluster *(uint16_t *) vsector = (cluster & 0x0000ffff); // high word von cluster
vsector = &fat.sector[row + 28]; vsector = &fat.sector[row + 28];
*(unsigned long int *) vsector = length; // laenge *(uint32_t *) vsector = length; // laenge
} }
@ -334,17 +336,17 @@ void fat_makeRowDataEntry(unsigned int row, char name[], unsigned char attrib,
// sektor gepuffert. für fat16 im root dir muss andere funktion genutzt werden, als fat_getFreeRowOfDir (durchsucht nur dirs). // sektor gepuffert. für fat16 im root dir muss andere funktion genutzt werden, als fat_getFreeRowOfDir (durchsucht nur dirs).
// fat.rootDir enthält bei fat32 den start cluster des directory, bei fat16 den 1. sektor des rootDir bereichs! // fat.rootDir enthält bei fat32 den start cluster des directory, bei fat16 den 1. sektor des rootDir bereichs!
// *************************************************************************************************************** // ***************************************************************************************************************
void fat_makeFileEntry(char name[], unsigned char attrib, void fat_makeFileEntry(char name[], uint8_t attrib,
unsigned long int length) uint32_t length)
{ {
unsigned int s; // zähler für root dir sektoren fat16 uint16_t s; // zähler für root dir sektoren fat16
if (fat.dir == 0 && fat.fatType == 32) if (fat.dir == 0 && fat.fatType == 32)
fat_getFreeRowOfDir(fat.rootDir); // IM ROOT DIR (fat32) fat_getFreeRowOfDir(fat.rootDir); // IM ROOT DIR (fat32)
else if (fat.dir == 0 && fat.fatType == 16) { // IM ROOT DIR (fat16) else if (fat.dir == 0 && fat.fatType == 16) { // IM ROOT DIR (fat16)
for (s = 0; s < (unsigned int) (fat.dataDirSec + 2 - fat.rootDir); s++) { // zählt durch RootDir sektoren (errechnet anzahl for (s = 0; s < (uint16_t) (fat.dataDirSec + 2 - fat.rootDir); s++) { // zählt durch RootDir sektoren (errechnet anzahl
// rootDir sektoren). // rootDir sektoren).
if (0 == fat_getFreeRowOfCluster(fat.rootDir + s)) if (0 == fat_getFreeRowOfCluster(fat.rootDir + s))
break; // geht durch sektoren des root dir. break; // geht durch sektoren des root dir.
@ -371,29 +373,29 @@ void fat_makeFileEntry(char name[], unsigned char attrib,
// erster daten cluster = 2, ende einer cluster chain 0xFFFF (fat16) oder 0xFFFFFFF, 0xFFFFFF8 (fat32), // erster daten cluster = 2, ende einer cluster chain 0xFFFF (fat16) oder 0xFFFFFFF, 0xFFFFFF8 (fat32),
// stelle des clusters in der fat, hat als wert, den nächsten cluster. (1:1 gemapt)! // stelle des clusters in der fat, hat als wert, den nächsten cluster. (1:1 gemapt)!
// *************************************************************************************************************** // ***************************************************************************************************************
unsigned long int fat_getNextCluster(unsigned long int oneCluster) uint32_t fat_getNextCluster(uint32_t oneCluster)
{ {
// FAT 16**************FAT 16 // FAT 16**************FAT 16
if (fat.fatType == 16) { if (fat.fatType == 16) {
unsigned long int i = oneCluster >> 8;; // (i=oneCluster/256)errechnet den sektor der fat in dem oneCluster ist (rundet immer ab) uint32_t i = oneCluster >> 8;; // (i=oneCluster/256)errechnet den sektor der fat in dem oneCluster ist (rundet immer ab)
unsigned long int j = (oneCluster << 1) - (i << 9); // (j=(oneCluster-256*i)*2 == 2*oneCluster-512*i)errechnet das low byte von uint32_t j = (oneCluster << 1) - (i << 9); // (j=(oneCluster-256*i)*2 == 2*oneCluster-512*i)errechnet das low byte von
// oneCluster // oneCluster
if (0 == fat_loadSector(i + fat.fatSec)) { // ob neu laden nötig, wird von fat_loadSector geprüft if (0 == fat_loadSector(i + fat.fatSec)) { // ob neu laden nötig, wird von fat_loadSector geprüft
void *bytesOfSec = &fat.sector[j]; // zeiger auf puffer void *bytesOfSec = &fat.sector[j]; // zeiger auf puffer
return *(unsigned short *) bytesOfSec; // da der ram auch little endian ist, kann einfach gecastet werden und gut :) return *(uint16_t *) bytesOfSec; // da der ram auch little endian ist, kann einfach gecastet werden und gut :)
} }
} }
// FAT 32**************FAT 32 // FAT 32**************FAT 32
else { else {
unsigned long int i = oneCluster >> 7; // (i=oneCluster/128)errechnet den sektor der fat in dem oneCluster ist (rundet immer ab) uint32_t i = oneCluster >> 7; // (i=oneCluster/128)errechnet den sektor der fat in dem oneCluster ist (rundet immer ab)
unsigned long int j = (oneCluster << 2) - (i << 9); // (j=(oneCluster-128*i)*4 == oneCluster*4-512*i)errechnet das low byte von uint32_t j = (oneCluster << 2) - (i << 9); // (j=(oneCluster-128*i)*4 == oneCluster*4-512*i)errechnet das low byte von
// oneCluster // oneCluster
if (0 == fat_loadSector(i + fat.fatSec)) { // ob neu laden nötig wird von fat_loadSector geprüft if (0 == fat_loadSector(i + fat.fatSec)) { // ob neu laden nötig wird von fat_loadSector geprüft
void *bytesOfSec = &fat.sector[j]; // zeiger auf puffer void *bytesOfSec = &fat.sector[j]; // zeiger auf puffer
return *(unsigned long int *) bytesOfSec; // da der ram auch little endian ist, kann einfach gecastet werden und gut :) return *(uint32_t *) bytesOfSec; // da der ram auch little endian ist, kann einfach gecastet werden und gut :)
} }
} }
@ -407,10 +409,10 @@ unsigned long int fat_getNextCluster(unsigned long int oneCluster)
// am stück,falls möglich. prüft ob der cluster neben offsetCluster dazu gehört... // am stück,falls möglich. prüft ob der cluster neben offsetCluster dazu gehört...
// setzt dann fat.endSectors und fat.startSectors. das -1 weil z.b. [95,98] = {95,96,97,98} = 4 sektoren // setzt dann fat.endSectors und fat.startSectors. das -1 weil z.b. [95,98] = {95,96,97,98} = 4 sektoren
// *************************************************************************************************************** // ***************************************************************************************************************
void fat_getFatChainClustersInRow(unsigned long int offsetCluster) void fat_getFatChainClustersInRow(uint32_t offsetCluster)
{ {
unsigned int i = 0; uint16_t i = 0;
fat.startSectors = fat_clustToSec(offsetCluster); // setzen des 1. sektors der datei fat.startSectors = fat_clustToSec(offsetCluster); // setzen des 1. sektors der datei
fat.endSectors = fat.startSectors; fat.endSectors = fat.startSectors;
do { do {
@ -432,10 +434,10 @@ void fat_getFatChainClustersInRow(unsigned long int offsetCluster)
// erst wir der erste frei cluster gesucht, ab offsetCluster(iklusive) und dann wird geschaut, ob der // erst wir der erste frei cluster gesucht, ab offsetCluster(iklusive) und dann wird geschaut, ob der
// daneben auch frei ist. setzt dann fat.endSectors und fat.startSectors. das -1 weil z.b. [95,98] = {95,96,97,98} = 4 sektoren // daneben auch frei ist. setzt dann fat.endSectors und fat.startSectors. das -1 weil z.b. [95,98] = {95,96,97,98} = 4 sektoren
// *************************************************************************************************************** // ***************************************************************************************************************
void fat_getFreeClustersInRow(unsigned long int offsetCluster) void fat_getFreeClustersInRow(uint32_t offsetCluster)
{ {
unsigned int i = 1; // variable für anzahl der zu suchenden sektoren uint16_t i = 1; // variable für anzahl der zu suchenden sektoren
while (fat_getNextCluster(offsetCluster)) while (fat_getNextCluster(offsetCluster))
offsetCluster++; // suche des 1. freien clusters offsetCluster++; // suche des 1. freien clusters
@ -458,8 +460,8 @@ void fat_getFreeClustersInRow(unsigned long int offsetCluster)
// es ist wegen der fragmentierung der fat nötig, sich den letzten bekannten cluster zu merken, // es ist wegen der fragmentierung der fat nötig, sich den letzten bekannten cluster zu merken,
// damit man bei weiteren cluster in einer reihe die alten cluster noch dazu verketten kann (so sind lücken im verketten möglich). // damit man bei weiteren cluster in einer reihe die alten cluster noch dazu verketten kann (so sind lücken im verketten möglich).
// *************************************************************************************************************** // ***************************************************************************************************************
void fat_setClusterChain(unsigned long int startCluster, void fat_setClusterChain(uint32_t startCluster,
unsigned int endCluster) uint16_t endCluster)
{ {
fat_setCluster(file.lastCluster, startCluster); // ende der chain setzen, bzw verketten der ketten fat_setCluster(file.lastCluster, startCluster); // ende der chain setzen, bzw verketten der ketten
@ -482,30 +484,30 @@ void fat_setClusterChain(unsigned long int startCluster,
// prüft ob buffer dirty (zu setztender cluster nicht in jetzt gepuffertem). // prüft ob buffer dirty (zu setztender cluster nicht in jetzt gepuffertem).
// prüfung erfolgt in fat_loadSector, dann wird alter vorher geschrieben, sonst gehen dort daten verloren !! // prüfung erfolgt in fat_loadSector, dann wird alter vorher geschrieben, sonst gehen dort daten verloren !!
// *************************************************************************************************************** // ***************************************************************************************************************
void fat_setCluster(unsigned long int cluster, unsigned long int content) void fat_setCluster(uint32_t cluster, uint32_t content)
{ {
// FAT 16**************FAT 16 // FAT 16**************FAT 16
if (fat.fatType == 16) { if (fat.fatType == 16) {
unsigned long int i = cluster >> 8; // (i=cluster/256)errechnet den sektor der fat in dem cluster ist (rundet immer ab) uint32_t i = cluster >> 8; // (i=cluster/256)errechnet den sektor der fat in dem cluster ist (rundet immer ab)
unsigned long int j = (cluster << 1) - (i << 9); // (j=(cluster-256*i)*2 == 2*cluster-512*i)errechnet das low byte von uint32_t j = (cluster << 1) - (i << 9); // (j=(cluster-256*i)*2 == 2*cluster-512*i)errechnet das low byte von
// cluster // cluster
if (0 == fat_loadSector(i + fat.fatSec)) { // neu laden (fat_loadSector prüft ob schon gepuffert) if (0 == fat_loadSector(i + fat.fatSec)) { // neu laden (fat_loadSector prüft ob schon gepuffert)
void *bytesOfSec = &fat.sector[j]; // init des zeigers auf unterste adresse void *bytesOfSec = &fat.sector[j]; // init des zeigers auf unterste adresse
*(unsigned short *) bytesOfSec = content; // weil ram auch little endian geht das so :) *(uint16_t *) bytesOfSec = content; // weil ram auch little endian geht das so :)
fat.bufferDirty = 1; // zeigt an, dass im aktuellen sector geschrieben wurde fat.bufferDirty = 1; // zeigt an, dass im aktuellen sector geschrieben wurde
} }
} }
// FAT 32**************FAT 32 // FAT 32**************FAT 32
else { else {
unsigned long int i = cluster >> 7; // (i=cluster/128)errechnet den sektor der fat in dem cluster ist (rundet immer ab) uint32_t i = cluster >> 7; // (i=cluster/128)errechnet den sektor der fat in dem cluster ist (rundet immer ab)
unsigned long int j = (cluster << 2) - (i << 9); // (j=(cluster-128*i)*4 == cluster*4-512*i)errechnet das low byte von uint32_t j = (cluster << 2) - (i << 9); // (j=(cluster-128*i)*4 == cluster*4-512*i)errechnet das low byte von
// cluster // cluster
if (0 == fat_loadSector(i + fat.fatSec)) { // neu laden (fat_loadSector prüft ob schon gepuffert) if (0 == fat_loadSector(i + fat.fatSec)) { // neu laden (fat_loadSector prüft ob schon gepuffert)
void *bytesOfSec = &fat.sector[j]; // init des zeigers auf unterste adresse void *bytesOfSec = &fat.sector[j]; // init des zeigers auf unterste adresse
*(unsigned long int *) bytesOfSec = content; // weil ram auch little endian geht das so :) *(uint32_t *) bytesOfSec = content; // weil ram auch little endian geht das so :)
fat.bufferDirty = 1; // zeigt an, dass im aktuellen sector geschrieben wurde fat.bufferDirty = 1; // zeigt an, dass im aktuellen sector geschrieben wurde
} }
} }
@ -516,10 +518,10 @@ void fat_setCluster(unsigned long int cluster, unsigned long int content)
// löscht cluster chain, beginnend ab dem startCluster. // löscht cluster chain, beginnend ab dem startCluster.
// sucht cluster, setzt inhalt usw.. abschließend noch den cluster-chain ende markierten cluster löschen. // sucht cluster, setzt inhalt usw.. abschließend noch den cluster-chain ende markierten cluster löschen.
// *************************************************************************************************************** // ***************************************************************************************************************
void fat_delClusterChain(unsigned long int startCluster) void fat_delClusterChain(uint32_t startCluster)
{ {
unsigned long int nextCluster = startCluster; // tmp variable, wegen verketteter cluster.. uint32_t nextCluster = startCluster; // tmp variable, wegen verketteter cluster..
do { do {
startCluster = nextCluster; startCluster = nextCluster;
@ -539,13 +541,13 @@ void fat_delClusterChain(unsigned long int startCluster)
// siehe auch Fatgen103.pdf. ist NICHT auf performance optimiert! // siehe auch Fatgen103.pdf. ist NICHT auf performance optimiert!
// byte/sector, byte/cluster, anzahl der fats, sector/fat ... (halt alle wichtigen daten zum lesen ders datei systems!) // byte/sector, byte/cluster, anzahl der fats, sector/fat ... (halt alle wichtigen daten zum lesen ders datei systems!)
// *****************************************************************<********************************************** // *****************************************************************<**********************************************
unsigned char fat_loadFatData(unsigned long int sec) uint8_t fat_loadFatData(uint32_t sec)
{ {
// offset,size // offset,size
unsigned int rootEntCnt; // 17,2 größe die eine fat belegt uint16_t rootEntCnt; // 17,2 größe die eine fat belegt
unsigned int fatSz16; // 22,2 sectors occupied by one fat16 uint16_t fatSz16; // 22,2 sectors occupied by one fat16
unsigned long int fatSz32; // 36,4 sectors occupied by one fat32 uint32_t fatSz32; // 36,4 sectors occupied by one fat32
void *vsector; void *vsector;
@ -556,23 +558,23 @@ unsigned char fat_loadFatData(unsigned long int sec)
fat.secPerClust = fat.sector[13]; // fat.secPerClust, 13 only (power of 2) fat.secPerClust = fat.sector[13]; // fat.secPerClust, 13 only (power of 2)
vsector = &fat.sector[14]; vsector = &fat.sector[14];
fat.fatSec = *(unsigned short *) vsector; fat.fatSec = *(uint16_t *) vsector;
vsector = &fat.sector[17]; vsector = &fat.sector[17];
rootEntCnt = *(unsigned short *) vsector; rootEntCnt = *(uint16_t *) vsector;
vsector = &fat.sector[22]; vsector = &fat.sector[22];
fatSz16 = *(unsigned short *) vsector; fatSz16 = *(uint16_t *) vsector;
fat.rootDir = (((rootEntCnt << 5) + 512) / 512) - 1; // ist 0 bei fat 32, sonst der root dir sektor fat.rootDir = (((rootEntCnt << 5) + 512) / 512) - 1; // ist 0 bei fat 32, sonst der root dir sektor
if (fat.rootDir == 0) { // FAT32 spezifisch (die prüfung so, ist nicht spezifikation konform !). if (fat.rootDir == 0) { // FAT32 spezifisch (die prüfung so, ist nicht spezifikation konform !).
vsector = &fat.sector[36]; vsector = &fat.sector[36];
fatSz32 = *(unsigned long int *) vsector; fatSz32 = *(uint32_t *) vsector;
vsector = &fat.sector[44]; vsector = &fat.sector[44];
fat.rootDir = *(unsigned long int *) vsector; fat.rootDir = *(uint32_t *) vsector;
fat.dataDirSec = fat.fatSec + (fatSz32 * fat.sector[16]); // data sector (beginnt mit cluster 2) fat.dataDirSec = fat.fatSec + (fatSz32 * fat.sector[16]); // data sector (beginnt mit cluster 2)
fat.fatType = 32; // fat typ fat.fatType = 32; // fat typ
@ -600,15 +602,15 @@ unsigned char fat_loadFatData(unsigned long int sec)
// ************************************************************************************************<<*************** // ************************************************************************************************<<***************
// int fat sucht den 1. cluster des dateisystems (fat16/32) auch VBR genannt, // int fat sucht den 1. cluster des dateisystems (fat16/32) auch VBR genannt,
// ************************************************************************************************<<*************** // ************************************************************************************************<<***************
unsigned char fat_initfat(void) uint8_t fat_initfat(void)
{ {
unsigned long int secOfFirstPartition = 0; // ist 1. sektor der 1. partition aus dem MBR uint32_t secOfFirstPartition = 0; // ist 1. sektor der 1. partition aus dem MBR
if (0 == mmc_read_sector(0, fat.sector)) { if (0 == mmc_read_sector(0, fat.sector)) {
void *vsector = &fat.sector[454]; // startsektor bestimmen void *vsector = &fat.sector[454]; // startsektor bestimmen
secOfFirstPartition = *(unsigned long int *) vsector; secOfFirstPartition = *(uint32_t *) vsector;
// prüfung ob man schon im VBR gelesen hat (0x6964654d = "Medi") // prüfung ob man schon im VBR gelesen hat (0x6964654d = "Medi")
if (secOfFirstPartition == 0x6964654d) if (secOfFirstPartition == 0x6964654d)
@ -633,9 +635,9 @@ unsigned char fat_initfat(void)
char *fat_str(char *str) char *fat_str(char *str)
{ {
unsigned char i; uint8_t i;
unsigned char j = 0; uint8_t j = 0;
unsigned char c; uint8_t c;
char tmp[12]; // tmp string zum einfacheren umwandeln char tmp[12]; // tmp string zum einfacheren umwandeln
strcpy(tmp, str); strcpy(tmp, str);

88
avr/usbload/fat.h
View File

@ -17,31 +17,31 @@
// ************************************************************************************************************************** // **************************************************************************************************************************
// funktionen // funktionen
extern unsigned long int fat_clustToSec(unsigned long int); // rechnet cluster zu 1. sektor des clusters um extern uint32_t fat_clustToSec(uint32_t); // rechnet cluster zu 1. sektor des clusters um
extern unsigned long int fat_secToClust(unsigned long int sec); // rechnet sektor zu cluster um! extern uint32_t fat_secToClust(uint32_t sec); // rechnet sektor zu cluster um!
extern unsigned long int fat_getNextCluster(unsigned long int oneCluster); // fat auf nächsten, verketteten cluster durchsuchen extern uint32_t fat_getNextCluster(uint32_t oneCluster); // fat auf nächsten, verketteten cluster durchsuchen
extern unsigned char fat_initfat(void); // initalisierung (durchsucht MBR oder nicht) extern uint8_t fat_initfat(void); // initalisierung (durchsucht MBR oder nicht)
extern unsigned char fat_writeSector(unsigned long int sec); // schreibt sektor auf karte extern uint8_t fat_writeSector(uint32_t sec); // schreibt sektor auf karte
extern void fat_setCluster(unsigned long int cluster, unsigned long int content); // setzt cluster inhalt in der fat extern void fat_setCluster(uint32_t cluster, uint32_t content); // setzt cluster inhalt in der fat
extern void fat_delClusterChain(unsigned long int startCluster); // löscht cluster-chain in der fat extern void fat_delClusterChain(uint32_t startCluster); // löscht cluster-chain in der fat
extern void fat_getFreeRowOfDir(unsigned long int dir); // durchsucht directory nach feiem eintrag extern void fat_getFreeRowOfDir(uint32_t dir); // durchsucht directory nach feiem eintrag
extern void fat_makeFileEntry(char name[], unsigned char attrib, extern void fat_makeFileEntry(char name[], uint8_t attrib,
unsigned long int length); uint32_t length);
extern unsigned char fat_loadSector(unsigned long int sec); // läd übergebenen absoluten sektor extern uint8_t fat_loadSector(uint32_t sec); // läd übergebenen absoluten sektor
extern unsigned char fat_loadFileDataFromDir(char name[]); // durchsucht das aktuelle directory extern uint8_t fat_loadFileDataFromDir(char name[]); // durchsucht das aktuelle directory
extern unsigned char fat_cd(char *); // wechselt directory (start im rootDir) extern uint8_t fat_cd(char *); // wechselt directory (start im rootDir)
extern unsigned char fat_loadFatData(unsigned long int); // läd fat daten extern uint8_t fat_loadFatData(uint32_t); // läd fat daten
extern unsigned char fat_getFreeRowOfCluster(unsigned long secStart); // durchsucht cluster nach freiem eintrag extern uint8_t fat_getFreeRowOfCluster(unsigned long secStart); // durchsucht cluster nach freiem eintrag
extern void fat_getFreeClustersInRow(unsigned long int offsetCluster); // sucht zusammenhängende freie cluster aus der fat extern void fat_getFreeClustersInRow(uint32_t offsetCluster); // sucht zusammenhängende freie cluster aus der fat
extern void fat_getFatChainClustersInRow(unsigned long int offsetCluster); // sucht fat-chain cluster die zusammenhängen extern void fat_getFatChainClustersInRow(uint32_t offsetCluster); // sucht fat-chain cluster die zusammenhängen
extern void fat_makeRowDataEntry(unsigned int row, char name[], extern void fat_makeRowDataEntry(uint16_t row, char name[],
unsigned char attrib, uint8_t attrib,
unsigned long int cluster, uint32_t cluster,
unsigned long int length); uint32_t length);
extern unsigned char fat_loadRowOfSector(unsigned int); // läd reihe des geladen sektors auf struct:file extern uint8_t fat_loadRowOfSector(uint16_t); // läd reihe des geladen sektors auf struct:file
extern unsigned char fat_loadFileDataFromCluster(unsigned long int sec, char name[]); // durchsucht die reihen des geladenen sektors extern uint8_t fat_loadFileDataFromCluster(uint32_t sec, char name[]); // durchsucht die reihen des geladenen sektors
extern void fat_setClusterChain(unsigned long int newOffsetCluster, extern void fat_setClusterChain(uint32_t newOffsetCluster,
unsigned int length); uint16_t length);
extern char *fat_str(char *str); // wandelt einen string so, dass er der fat konvention entspricht ! extern char *fat_str(char *str); // wandelt einen string so, dass er der fat konvention entspricht !
@ -49,29 +49,29 @@ extern char *fat_str(char *str); // wandelt einen string so, dass er der
// variablen // variablen
extern struct Fat { // fat daten (1.cluster, root-dir, dir usw.) extern struct Fat { // fat daten (1.cluster, root-dir, dir usw.)
unsigned char sector[512]; // der puffer für sektoren ! uint8_t sector[512]; // der puffer für sektoren !
unsigned char bufferDirty; // puffer wurde beschrieben, sector muss geschrieben werden bevor er neu geladen wird uint8_t bufferDirty; // puffer wurde beschrieben, sector muss geschrieben werden bevor er neu geladen wird
unsigned long int currentSectorNr; // aktuell geladener Sektor (in sector) //beschleunigt wenn z.b 2* 512 byte puffer vorhanden, oder uint32_t currentSectorNr; // aktuell geladener Sektor (in sector) //beschleunigt wenn z.b 2* 512 byte puffer vorhanden, oder
// bei fat operationen im gleichen sektor // bei fat operationen im gleichen sektor
unsigned long int dir; // Direktory zeiger rootDir=='0' sonst(1.Cluster des dir; start auf root) uint32_t dir; // Direktory zeiger rootDir=='0' sonst(1.Cluster des dir; start auf root)
unsigned long int rootDir; // Sektor(f16)/Cluster(f32) nr root directory uint32_t rootDir; // Sektor(f16)/Cluster(f32) nr root directory
unsigned long int dataDirSec; // Sektor nr data area uint32_t dataDirSec; // Sektor nr data area
unsigned long int fatSec; // Sektor nr fat area uint32_t fatSec; // Sektor nr fat area
unsigned long int startSectors; // der erste sektor in einer reihe (freie oder verkettete) uint32_t startSectors; // der erste sektor in einer reihe (freie oder verkettete)
unsigned long int endSectors; uint32_t endSectors;
unsigned char secPerClust; // anzahl der sektoren pro cluster uint8_t secPerClust; // anzahl der sektoren pro cluster
unsigned char fatType; // fat16 oder fat32 (16 oder 32) uint8_t fatType; // fat16 oder fat32 (16 oder 32)
} fat; } fat;
extern struct File { // datei infos extern struct File { // datei infos
unsigned int cntOfBytes; // -nicht direkt aus dem dateisystem- zäht geschriebene bytes eines sektors uint16_t cntOfBytes; // -nicht direkt aus dem dateisystem- zäht geschriebene bytes eines sektors
unsigned char name[13]; // 0,10 datei Name.ext (8.3 = max 11)(MUSS unsigned char weil E5) uint8_t name[13]; // 0,10 datei Name.ext (8.3 = max 11)(MUSS uint8_t weil E5)
unsigned char attrib; // 11,1 datei Attribut: 8=value name, 32=datei, 16=Verzeichniss, 15=linux kleingeschrieben eintrag uint8_t attrib; // 11,1 datei Attribut: 8=value name, 32=datei, 16=Verzeichniss, 15=linux kleingeschrieben eintrag
unsigned char row; // reihe im sektor in der die datei infos stehen (reihe 0-15) uint8_t row; // reihe im sektor in der die datei infos stehen (reihe 0-15)
unsigned long int firstCluster; // 20,2 /26,2 datei 1.cluster hi,low(möglicherweise der einzige) (4-byte) uint32_t firstCluster; // 20,2 /26,2 datei 1.cluster hi,low(möglicherweise der einzige) (4-byte)
unsigned long int length; // 28,4 datei Länge (4-byte) uint32_t length; // 28,4 datei Länge (4-byte)
unsigned long int lastCluster; // -nicht direkt aus dem dateisystem- letzter cluster der ersten kette uint32_t lastCluster; // -nicht direkt aus dem dateisystem- letzter cluster der ersten kette
unsigned long int seek; // schreib position in der datei uint32_t seek; // schreib position in der datei
} file; } file;
#endif #endif

52
avr/usbload/file.c
View File

@ -17,10 +17,10 @@
// danach wird der dateieintrag gemacht(auf karte). dort wird auch geprüft ob genügend platz im aktuellen verzeichniss existiert. // 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. // 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[]) uint8_t ffopen(char name[])
{ {
unsigned char file_flag = fat_loadFileDataFromDir(name); // prüfung ob datei vorhanden und evetuelles laden des file struct uint8_t 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! **/ if (file_flag == 0) { /** Datei existiert, anlegen nicht nötig! **/
fat_getFatChainClustersInRow(file.firstCluster); // verkettete cluster aus der fat-chain suchen. fat_getFatChainClustersInRow(file.firstCluster); // verkettete cluster aus der fat-chain suchen.
@ -52,7 +52,7 @@ unsigned char ffopen(char name[])
// und die neue datei länge muss ermitt weden. abschließend wird entweder (fall 2) nur der aktuelle sektor geschrieben, oder // 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() ). // der aktuallisierte datei eintrag und die cluster (diese werden verkettet, siehe fileUpdate() ).
// ******************************************************************************************************************************* // *******************************************************************************************************************************
unsigned char ffclose(void) uint8_t ffclose(void)
{ {
#if (WRITE==1) /** 2 möglichkeiten beim schließen !! (lesend spielt keine rolle, nichts muss geupdatet werden) **/ #if (WRITE==1) /** 2 möglichkeiten beim schließen !! (lesend spielt keine rolle, nichts muss geupdatet werden) **/
@ -78,13 +78,13 @@ unsigned char ffclose(void)
void fileUpdate(void) void fileUpdate(void)
{ {
unsigned int comp_cntOfBytes = file.cntOfBytes; // sicher nötig wegen schleife... uint16_t comp_cntOfBytes = file.cntOfBytes; // sicher nötig wegen schleife...
while (comp_cntOfBytes < 512) { // sektor ist beschrieben worden, daher nötigenfalls mit 00 füllen 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 fat.sector[comp_cntOfBytes] = 0x00; // beschreibt ungenutzte bytes mit 0x00
comp_cntOfBytes++; comp_cntOfBytes++;
} }
char name[13]; // zum sichern des dateinamens 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 uint32_t save_length = file.cntOfBytes + file.seek; // muss gesichert werden, wird sonst von der karte geladen und
// verändert ! // verändert !
strcpy(name, (char *) file.name); // 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 !
@ -101,7 +101,7 @@ void fileUpdate(void)
// 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, // 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). // die "vorgesucht" wurden, müssen noch weitere sektoren der datei gesucht werden (sec > fat.endSectors).
// ******************************************************************************************************************************* // *******************************************************************************************************************************
void ffseek(unsigned long int offset) void ffseek(uint32_t offset)
{ {
#if (OVER_WRITE==1) // man muss den dateieintrag updaten, um die daten zu retten !! #if (OVER_WRITE==1) // man muss den dateieintrag updaten, um die daten zu retten !!
@ -110,7 +110,7 @@ void ffseek(unsigned long int offset)
#endif #endif
fat_getFatChainClustersInRow(file.firstCluster); // suchen von anfang der cluster chain aus ! fat_getFatChainClustersInRow(file.firstCluster); // suchen von anfang der cluster chain aus !
unsigned long int sec = fat.startSectors; // sektor variable zum durchgehen durch die sektoren uint32_t 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 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 **/ while (offset >= 512) { /** suchen des sektors in dem offset ist **/
@ -136,7 +136,7 @@ void ffseek(unsigned long int offset)
// wechselt verzeichniss. start immer im root Dir. // wechselt verzeichniss. start immer im root Dir.
// MUSS in das direktory gewechselt werden, in dem die datei zum lesen/schreiben ist ! // MUSS in das direktory gewechselt werden, in dem die datei zum lesen/schreiben ist !
// ******************************************************************************************************************************* // *******************************************************************************************************************************
unsigned char ffcd(char name[]) uint8_t ffcd(char name[])
{ {
return (fat_cd(name)); return (fat_cd(name));
} }
@ -148,11 +148,11 @@ unsigned char ffcd(char name[])
// eintrag in der reihe ist (nicht gelöscht, nicht frei usw). die sektoren des clusters werden nachgeladen. // 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. // die dateien werden mit namen und datei größe angezeigt.
// ******************************************************************************************************************************* // *******************************************************************************************************************************
void lsRowsOfClust(unsigned long int start_sec) void lsRowsOfClust(uint32_t start_sec)
{ {
unsigned char row; // reihen uint8_t row; // reihen
unsigned char sec = 0; // sektoren uint8_t sec = 0; // sektoren
do { do {
fat_loadSector(start_sec + sec); // sektoren des clusters laden fat_loadSector(start_sec + sec); // sektoren des clusters laden
for (row = 0; row < 16; row++) { // geht durch reihen des sektors for (row = 0; row < 16; row++) { // geht durch reihen des sektors
@ -174,11 +174,11 @@ void lsRowsOfClust(unsigned long int start_sec)
void ffls(void) void ffls(void)
{ {
unsigned long int clust; // cluster uint32_t clust; // cluster
unsigned int s; // fat16 root dir sektoren uint16_t s; // fat16 root dir sektoren
if (fat.dir == 0 && fat.fatType == 16) { // IM ROOTDIR. fat16 if (fat.dir == 0 && fat.fatType == 16) { // IM ROOTDIR. fat16
for (s = 0; s < (unsigned int) (fat.dataDirSec + 2 - fat.rootDir); s++) { // zählt durch RootDir sektoren (errechnet anzahl for (s = 0; s < (uint16_t) (fat.dataDirSec + 2 - fat.rootDir); s++) { // zählt durch RootDir sektoren (errechnet anzahl
// rootDir sektoren). // rootDir sektoren).
lsRowsOfClust(fat.rootDir + s); // zeigt reihen eines root dir clust an lsRowsOfClust(fat.rootDir + s); // zeigt reihen eines root dir clust an
} }
@ -205,7 +205,7 @@ void ffls(void)
// die variable fat.dir enthält den start cluster des direktory in dem man sich grade befindet, anhand diesem, // die variable fat.dir enthält den start cluster des direktory in dem man sich grade befindet, anhand diesem,
// kann der "." bzw ".." eintrag im ersten sektor des direktory ausgelesen und das parent direktory bestimmt werden. // kann der "." bzw ".." eintrag im ersten sektor des direktory ausgelesen und das parent direktory bestimmt werden.
// ******************************************************************************************************************************* // *******************************************************************************************************************************
unsigned char ffcdLower(void) uint8_t ffcdLower(void)
{ {
if (fat.dir == 0) if (fat.dir == 0)
@ -232,8 +232,8 @@ unsigned char ffcdLower(void)
void ffmkdir(char name[]) void ffmkdir(char name[])
{ {
unsigned char i; uint8_t i;
unsigned int j; uint16_t j;
if (0 == fat_loadFileDataFromDir(name)) if (0 == fat_loadFileDataFromDir(name))
return; // prüft ob dirname im dir schon vorhanden, wenn ja, abbruch ! return; // prüft ob dirname im dir schon vorhanden, wenn ja, abbruch !
@ -272,7 +272,7 @@ void ffmkdir(char name[])
// löscht datei/ordner aus aktuellem verzeichniss, wenn es die datei gibt. // löscht datei/ordner aus aktuellem verzeichniss, wenn es die datei gibt.
// löscht dateien und ordner rekursiv ! // löscht dateien und ordner rekursiv !
// ******************************************************************************************************************************* // *******************************************************************************************************************************
unsigned char ffrm(char name[]) uint8_t ffrm(char name[])
{ {
if (0 == fat_loadFileDataFromDir(name)) { // datei oder ordner ist vorhanden, nur dann lösch operation if (0 == fat_loadFileDataFromDir(name)) { // datei oder ordner ist vorhanden, nur dann lösch operation
@ -292,11 +292,11 @@ unsigned char ffrm(char name[])
// TODO noch nicht optimal. zu viele schreib vorgänge beim löschen von datei einträgen. max bis zu 16/sektor ! // 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 !! else { // ist ordner, dann rekursiv löschen !!
#ifndef __AVR_ATmega8__ // mega8 zu klein für die funktionalität.... #ifndef __AVR_ATmega8__ // mega8 zu klein für die funktionalität....
unsigned long int parent; uint32_t parent;
unsigned long int own; uint32_t own;
unsigned long int clustsOfDir; // um durch die cluster chain eines dirs zu gehen. uint32_t clustsOfDir; // um durch die cluster chain eines dirs zu gehen.
unsigned char cntSecOfClust = 0; uint8_t cntSecOfClust = 0;
unsigned char i = 0; uint8_t i = 0;
fat.sector[file.row << 5] = 0xE5; // löscht dir eintrag fat.sector[file.row << 5] = 0xE5; // löscht dir eintrag
if ((file.row - 1) >= 0) { // gibt es einen eintrag davor (langer datei eintrag)? if ((file.row - 1) >= 0) { // gibt es einen eintrag davor (langer datei eintrag)?
@ -392,7 +392,7 @@ unsigned char ffrm(char name[])
// liest 512 bytes aus dem puffer fat.sector. dann werden neue 512 bytes der datei geladen, sind nicht genügend verkettete // 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... // sektoren in einer reihe bekannt, wird in der fat nachgeschaut. dann werden weiter bekannte nachgeladen...
// ******************************************************************************************************************************* // *******************************************************************************************************************************
inline unsigned char ffread(void) inline uint8_t ffread(void)
{ {
if (file.cntOfBytes == 512) { /** EINEN SEKTOR GLESEN (ab hier 2 möglichkeiten !) **/ if (file.cntOfBytes == 512) { /** EINEN SEKTOR GLESEN (ab hier 2 möglichkeiten !) **/
@ -417,7 +417,7 @@ inline unsigned char ffread(void)
// zusammenhängende sektoren bekannt sein, werden die alten verkettet und neue gesucht. es ist nötig sich den letzten bekannten // 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)! // 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) inline void ffwrite(uint8_t c)
{ {
fat.sector[file.cntOfBytes++] = c; // schreiben des chars auf den puffer sector und zähler erhöhen (pre-increment) fat.sector[file.cntOfBytes++] = c; // schreiben des chars auf den puffer sector und zähler erhöhen (pre-increment)
@ -450,7 +450,7 @@ inline void ffwrite(unsigned char c)
// 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 // 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. // geschwindigkeit.
// ******************************************************************************************************************************* // *******************************************************************************************************************************
inline void ffwrite(unsigned char c) inline void ffwrite(uint8_t c)
{ {
fat.sector[file.cntOfBytes++] = c; // schreiben des chars auf den puffer sector und zähler erhöhen (pre-increment) fat.sector[file.cntOfBytes++] = c; // schreiben des chars auf den puffer sector und zähler erhöhen (pre-increment)

18
avr/usbload/file.h
View File

@ -8,20 +8,20 @@
// ************************************************************************************************************************** // **************************************************************************************************************************
// funktionen // funktionen
extern inline unsigned char ffread(void); // liest byte-weise aus der datei (puffert immer 512 bytes zwischen) extern inline uint8_t ffread(void); // liest byte-weise aus der datei (puffert immer 512 bytes zwischen)
extern inline void ffwrite(unsigned char c); // schreibt ein byte in die geöffnete datei extern inline void ffwrite(uint8_t c); // schreibt ein byte in die geöffnete datei
extern inline void ffwrites(const char *s); // schreibt string auf karte extern inline void ffwrites(const char *s); // schreibt string auf karte
extern unsigned char ffopen(char name[]); // kann immer nur 1 datei bearbeiten. extern uint8_t ffopen(char name[]); // kann immer nur 1 datei bearbeiten.
extern unsigned char ffclose(void); // muss aufgerufen werden bevor neue datei bearbeitet wird. extern uint8_t ffclose(void); // muss aufgerufen werden bevor neue datei bearbeitet wird.
extern void ffseek(unsigned long int offset); // setzt zeiger:bytesOfSec auf position in der geöffneten datei. extern void ffseek(uint32_t offset); // setzt zeiger:bytesOfSec auf position in der geöffneten datei.
extern unsigned char ffcd(char name[]); // wechselt direktory extern uint8_t ffcd(char name[]); // wechselt direktory
extern void ffls(void); // zeigt direktory inhalt an extern void ffls(void); // zeigt direktory inhalt an
extern unsigned char ffcdLower(void); // geht ein direktory zurück, also cd.. (parent direktory) extern uint8_t ffcdLower(void); // geht ein direktory zurück, also cd.. (parent direktory)
extern unsigned char ffrm(char name[]); // löscht datei aus aktuellem verzeichniss. extern uint8_t ffrm(char name[]); // löscht datei aus aktuellem verzeichniss.
extern void ffmkdir(char name[]); // legt ordner in aktuellem verzeichniss an. extern void ffmkdir(char name[]); // legt ordner in aktuellem verzeichniss an.
void lsRowsOfClust(unsigned long int start_sec); // zeigt reihen eines clusters an, ab start_sec void lsRowsOfClust(uint32_t start_sec); // zeigt reihen eines clusters an, ab start_sec
void fileUpdate(void); // updatet datei eintrag auf karte void fileUpdate(void); // updatet datei eintrag auf karte
// **************************************************************************************************************************// // **************************************************************************************************************************//

14
avr/usbload/mmc.h
View File

@ -27,13 +27,13 @@
extern unsigned char mmc_read_byte(void); extern uint8_t mmc_read_byte(void);
extern void mmc_write_byte(unsigned char); extern void mmc_write_byte(uint8_t);
extern void mmc_read_block(unsigned char *, unsigned char *, unsigned in); extern void mmc_read_block(uint8_t *, uint8_t *, unsigned in);
extern unsigned char mmc_init(void); extern uint8_t mmc_init(void);
extern unsigned char mmc_read_sector(unsigned long, unsigned char *); extern uint8_t mmc_read_sector(unsigned long, uint8_t *);
extern unsigned char mmc_write_sector(unsigned long, unsigned char *); extern uint8_t mmc_write_sector(unsigned long, uint8_t *);
extern unsigned char mmc_write_command(unsigned char *); extern uint8_t mmc_write_command(uint8_t *);
#define mmc_disable() MMC_WRITE|= (1<<MMC_CS); #define mmc_disable() MMC_WRITE|= (1<<MMC_CS);