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

Merge branch 'mmc' of git@github.com:optixx/quickdev16 into mmc

Browse Source 
Conflicts:
	avr/usbload/fat.h
	avr/usbload/file.c
	avr/usbload/testing.c
This commit is contained in:
David Voswinkel 2009-08-10 19:44:15 +02:00
commit 8d961dc446
4 changed files with 122 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
avr/usbload/fat.c
View File

@ -6,7 +6,8 @@
#include "fat.h" #include "fat.h"
#include "file.h" #include "file.h"
#include "hardware.h" #include "mmc.h"
#include "config.h"
struct Fat fat; // wichtige daten/variablen der fat struct Fat fat; // wichtige daten/variablen der fat
struct File file; // wichtige dateibezogene daten/variablen struct File file; // wichtige dateibezogene daten/variablen

13
avr/usbload/fat.h
View File

@ -5,14 +5,15 @@
// ************************************************************************************************************************** // **************************************************************************************************************************
// WICHTIGE SCHLATER: -> hier kann die code größe angepasst werden, zu lasten der funktionalität ! // WICHTIGE SCHLATER: -> hier kann die code größe angepasst werden, zu lasten der funktionalität !
#define SMALL_FILE_SYSTEM 0 // wenn 1 dann ist kleines file system, wenn 0 dann komplette file unterstützung !
#define WRITE 1 // wenn 1 dann ist write an, wenn 0 dann read only !
#define OVER_WRITE 1 // wenn 1 dann kann ffwrite dateien überschreiben (nicht performant), wenn 0 dann nur normales schreiben !
#define MAX_CLUSTERS_IN_ROW 256 // gibt an wie viele cluster am stück ohne fat lookup geschrieben bzw gelesen werden können, wenn
// die fat nicht fragmentiert ist ! // die fat nicht fragmentiert ist !
// 1. fat_getFreeRowOfCluster -> fat_getFreeRowOfDir -> fat_makeRowDataEntry -> fat_makeFileEntry -> fat_writeSector "eintrag gemacht !!" #define SMALL_FILE_SYSTEM 0 // wenn 1 dann ist kleines file system, wenn 0 dann komplette file unterstützung !
// 2. fat_loadSector -> fat_loadRowOfSector -> fat_loadFileDataFromCluster -> fat_loadFileDataFromDir (-> fat_cd) "daten chain" #define WRITE 0 // wenn 1 dann ist write an, wenn 0 dann read only !
#define OVER_WRITE 0 // wenn 1 dann kann ffwrite dateien überschreiben (nicht performant), wenn 0 dann nur normales schreiben !
#define MAX_CLUSTERS_IN_ROW 256 // gibt an wie viele cluster am stück ohne fat lookup geschrieben bzw gelesen werden können, wenn die fat nicht fragmentiert ist !
// 1. fat_getFreeRowOfCluster -> fat_getFreeRowOfDir -> fat_makeRowDataEntry -> fat_makeFileEntry -> fat_writeSector "eintrag gemacht !!"
// 2. fat_loadSector -> fat_loadRowOfSector -> fat_loadFileDataFromCluster -> fat_loadFileDataFromDir (-> fat_cd) "daten chain"
// ************************************************************************************************************************** // **************************************************************************************************************************
// funktionen // funktionen

178
avr/usbload/file.c
View File

@ -2,11 +2,10 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include "hardware.h" #include "mmc.h"
#include "fat.h" #include "fat.h"
#include "file.h" #include "file.h"
#include "config.h"
// ******************************************************************************************************************************* // *******************************************************************************************************************************
// 2 möglichkeiten beim öffnen, datei existiert(return 1) oder muss angelegt werden(return 2) // 2 möglichkeiten beim öffnen, datei existiert(return 1) oder muss angelegt werden(return 2)
@ -16,35 +15,33 @@
// -beim anlegen werden freie cluster gesucht, maximal MAX_CLUSTERS_IN_ROW in reihe. dann wird das struct file gefüllt. // -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. // 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.
// ******************************************************************************************************************************* //*******************************************************************************************************************************
uint8_t ffopen(char name[]) unsigned char ffopen(char name[]){
{
uint8_t file_flag = fat_loadFileDataFromDir(name); // prüfung ob datei vorhanden und evetuelles laden des file struct 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! **/ 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.
fat_loadSector(fat_clustToSec(file.firstCluster)); // lät die ersten 512 bytes der datei auf puffer:sector. 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 file.lastCluster=fat_secToClust(fat.endSectors); // letzter bekannter cluster der datei
return 1; return 1;
} }
#if (WRITE==1) // anlegen ist schreiben ! #if (WRITE==1) // anlegen ist schreiben !
else { /** Datei existiert nicht, also anlegen ! (nur wenn schreiben option an ist)**/ else{ /** Datei existiert nicht, also anlegen ! (nur wenn schreiben option an ist)**/
fat_getFreeClustersInRow(2); // leere cluster suchen, ab cluster 2. fat_getFreeClustersInRow(2); // leere cluster suchen, ab cluster 2.
strcpy((char *) file.name, (char *) name); // --- füllen des file struct, zum abschließenden schreiben. 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.firstCluster=fat_secToClust(fat.startSectors); // 1. cluster der datei
file.lastCluster = file.firstCluster; // fat_secToClust(fat.endSectors); // letzter bekannter 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.attrib=32; // --- file.row wird in der funktion fat_getFreeRowOfDir geschrieben !!
file.length = 0; // damit da nix drin steht ^^ file.length=0; // damit da nix drin steht ^^
fat_makeFileEntry((char *) file.name, file.attrib, 0); // DATEI ANLEGEN auf karte fat_makeFileEntry((char *)file.name,file.attrib,0); // DATEI ANLEGEN auf karte
fat.currentSectorNr = fat_clustToSec(file.firstCluster); // setzen des ersten sektors fat.currentSectorNr=fat_clustToSec(file.firstCluster); // setzen des ersten sektors
return 2; return 2;
} }
#endif #endif
} }
//*******************************************************************************************************************************
// *******************************************************************************************************************************
// schließt die datei operation ab. eigentlich nur nötig wenn geschrieben wurde. es gibt 2 möglichkeiten : // 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. // 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. // 2. die datei wird geschlossen und man war innerhalb der datei größe, dann muss nur der aktuelle sektor geschrieben werden.
@ -75,56 +72,59 @@ uint8_t ffclose(void)
// füllt den aktuell beschriebenen sektor mit 0x00, da sonst die datei nicht richtig angezeigt wird. // füllt den aktuell beschriebenen sektor mit 0x00, da sonst die datei nicht richtig angezeigt wird.
// darf nur während schreibe operationen aufgerufen werden ! // darf nur während schreibe operationen aufgerufen werden !
// ******************************************************************************************************************************* // *******************************************************************************************************************************
void fileUpdate(void) #if (WRITE==1)
{
uint16_t comp_cntOfBytes = file.cntOfBytes; // sicher nötig wegen schleife... void fileUpdate(void){
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
uint32_t 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 unsigned int comp_cntOfBytes=file.cntOfBytes; // sicher nötig wegen schleife...
fat_loadFileDataFromDir(name); // läd sektor, des datei eintrags, und läd daten von karte auf struct file! while( comp_cntOfBytes < 512 ){ // sektor ist beschrieben worden, daher nötigenfalls mit 00 füllen
fat_makeRowDataEntry(file.row, name, 32, file.firstCluster, save_length); // macht eintrag im puffer 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); fat_writeSector(fat.currentSectorNr);
} }
#endif
// ******************************************************************************************************************************* // *******************************************************************************************************************************
// offset byte wird übergeben. es wird durch die sektoren der datei gespult (gerechnet), bis der sektor mit dem offset byte erreicht // 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, // 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(uint32_t offset) void ffseek(unsigned long int offset){
{
#if (OVER_WRITE==1) // man muss den dateieintrag updaten, um die daten zu retten !! #if (WRITE==1)
if (file.seek > file.length)
fileUpdate(); // fat verketten und datei update auf der karte ! #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
#endif #endif
fat_getFatChainClustersInRow(file.firstCluster); // suchen von anfang der cluster chain aus ! fat_getFatChainClustersInRow(file.firstCluster); // suchen von anfang der cluster chain aus !
uint32_t sec = fat.startSectors; // sektor variable zum durchgehen durch die sektoren 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 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 **/
sec++; // da byte nicht in diesem sektor ist, muss hochgezählt werden sec++; // da byte nicht in diesem sektor ist, muss hochgezählt werden
offset -= 512; // ein sektor weniger in dem das byte sein kann 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 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 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 fat_getFatChainClustersInRow(fat_getNextCluster( file.lastCluster ) ); // nachladen von clustern in der chain
sec = fat.startSectors; // setzen des 1. sektors der neu geladenen, zum weitersuchen ! sec=fat.startSectors; // setzen des 1. sektors der neu geladenen, zum weitersuchen !
} }
} }
file.lastCluster = fat_secToClust(fat.endSectors); // letzter bekannter cluster der datei file.lastCluster=fat_secToClust(fat.endSectors); // letzter bekannter cluster der datei
fat_loadSector(sec); // sektor mit offset byte laden fat_loadSector(sec); // sektor mit offset byte laden
file.cntOfBytes = offset; // setzen des lese zählers file.cntOfBytes = offset; // setzen des lese zählers
} }
@ -229,39 +229,39 @@ uint8_t ffcdLower(void)
// der "." hat den 1. cluster des eigenen dirs. der ".." eintrag ist der 1. cluster des parent dirs. // der "." hat den 1. cluster des eigenen dirs. der ".." eintrag ist der 1. cluster des parent dirs.
// ein dir wird immer mit 0x00 initialisiert ! also alle einträge der sektoren des clusters ( bis auf . und .. einträge)! // ein dir wird immer mit 0x00 initialisiert ! also alle einträge der sektoren des clusters ( bis auf . und .. einträge)!
// ******************************************************************************************************************************* // *******************************************************************************************************************************
void ffmkdir(char name[]) #if (WRITE==1)
{
uint8_t i; void ffmkdir(char name[]){
uint16_t j;
if (0 == fat_loadFileDataFromDir(name)) unsigned char i;
return; // prüft ob dirname im dir schon vorhanden, wenn ja, abbruch ! unsigned int j;
// cluster in fat setzen, und ordner eintrg im aktuellen verzeichniss machen. if(0==fat_loadFileDataFromDir(name))return ; // prüft ob dirname im dir schon vorhanden, wenn ja, abbruch !
fat_getFreeClustersInRow(2); // holt neue freie cluster, ab cluster 2 ...
fat_setCluster(fat_secToClust(fat.startSectors), 0x0fffffff); // fat16/32 cluster chain ende setzen. (neuer ordner in fat)
file.firstCluster = fat_secToClust(fat.startSectors); // dammit fat_makeFileEntry den cluster richtig setzen kann
fat_makeFileEntry(name, 0x10, 0); // macht dir eintrag im aktuellen verzeichniss (legt ordner im partent verzeichniss an)
// aufbereiten des puffers // cluster in fat setzen, und ordner eintrg im aktuellen verzeichniss machen.
j = 511; fat_getFreeClustersInRow(2); // holt neue freie cluster, ab cluster 2 ...
do { fat_setCluster(fat_secToClust(fat.startSectors),0x0fffffff); // fat16/32 cluster chain ende setzen. (neuer ordner in fat)
fat.sector[j] = 0x00; // schreibt puffer fat.sector voll mit 0x00==leer file.firstCluster=fat_secToClust(fat.startSectors); // dammit fat_makeFileEntry den cluster richtig setzen kann
} while (j--); fat_makeFileEntry(name,0x10,0); // macht dir eintrag im aktuellen verzeichniss (legt ordner im partent verzeichniss an)
// aufbereiten des clusters // aufbereiten des puffers
for (i = 1; i < fat.secPerClust; i++) { // ein dir cluster muss mit 0x00 initialisiert werden ! j=511;
fat_writeSector(fat.startSectors + i); // löschen des cluster (überschreibt mit 0x00), wichtig bei ffls! do{
} fat.sector[j]=0x00; //schreibt puffer fat.sector voll mit 0x00==leer
}while(j--);
// aufbereiten des neuen dir sektors mit "." und ".." eintraegen ! // aufbereiten des clusters
fat_makeRowDataEntry(0, ". ", 0x10, file.firstCluster, 0); // macht "." eintrag des dirs for(i=1;i<fat.secPerClust;i++){ // ein dir cluster muss mit 0x00 initialisiert werden !
fat_makeRowDataEntry(1, ".. ", 0x10, fat.dir, 0); // macht ".." eintrag des dirs fat_writeSector(fat.startSectors+i); // löschen des cluster (überschreibt mit 0x00), wichtig bei ffls!
fat_writeSector(fat_clustToSec(file.firstCluster)); // schreibt einträge auf karte ! }
// aufbereiten des neuen dir sektors mit "." und ".." eintraegen !
fat_makeRowDataEntry(0,". ",0x10,file.firstCluster,0); // macht "." eintrag des dirs
fat_makeRowDataEntry(1,".. ",0x10,fat.dir,0); // macht ".." eintrag des dirs
fat_writeSector(fat_clustToSec(file.firstCluster)); // schreibt einträge auf karte !
} }
#endif //WRITE
#endif // ffmkdir wegen atmega8 #endif // ffmkdir wegen atmega8
#endif #endif

27
avr/usbload/testing.c
View File

@ -29,6 +29,7 @@
#include "sram.h" #include "sram.h"
#include "debug.h" #include "debug.h"
#include "crc.h" #include "crc.h"
#include "config.h"
#include "info.h" #include "info.h"
#include "mmc.h" #include "mmc.h"
@ -127,9 +128,29 @@ void test_sdcard(void){
printf("Root dirlist\n"); printf("Root dirlist\n");
ffls(); ffls();
printf("FOLDER2 dirlist\n");
ffcd("FOLDER1"); #if (WRITE==1)
ffls(); char datei[12]="test.txt"; // hier muss platz für 11 zeichen sein (8.3), da fat_str diesen string benutzt !!
fat_str(datei);
ffrm( datei ); // löschen der datei/ordner falls vorhanden
printf("open %s\n",datei);
ffopen( datei );
printf("write %s\n",datei);
ffwrites((char*)"Hallo Datei :)");
ffwrite(0x0D);
ffwrite(0x0A);
printf("close %s\n",datei);
ffclose();
printf("open %s\n",datei);
ffopen( datei );
printf("open %s\n",datei);
unsigned long int seek=file.length; // eine variable setzen und runterzählen bis 0 geht am schnellsten !
do{
printf("%c",ffread()); // liest ein zeichen und gibt es über uart aus !
}while(--seek); // liest solange bytes da sind (von datei länge bis 0)
ffclose(); // schließt datei
#endif
} }