cleanup code
This commit is contained in:
David Voswinkel
parent
a823badfe0
commit
b018ae6f78
@ -1,29 +1,14 @@
|
||||
/*
|
||||
* Ulrich Radig Bei Fragen und Verbesserungen wendet euch per EMail an mail@ulrichradig.de oder im Forum meiner Web Page :
|
||||
* www.ulrichradig.de Dieses Programm ist freie Software. Sie können es unter den Bedingungen der GNU General Public License, wie
|
||||
* von der Free Software Foundation veröffentlicht, weitergeben und/oder modifizieren, entweder gemäß Version 2 der Lizenz oder (nach
|
||||
* Ihrer Option) jeder späteren Version. Die Veröffentlichung dieses Programms erfolgt in der Hoffnung, daß es Ihnen von Nutzen sein
|
||||
* wird, aber OHNE IRGENDEINE GARANTIE, sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT FÜR EINEN BESTIMMTEN
|
||||
* ZWECK. Details finden Sie in der GNU General Public License. Sie sollten eine Kopie der GNU General Public License zusammen mit
|
||||
* diesem Programm erhalten haben. Falls nicht, schreiben Sie an die Free Software Foundation, Inc., 59 Temple Place, Suite 330,
|
||||
*/
|
||||
|
||||
#include "fat.h"
|
||||
|
||||
uint8_t cluster_size;
|
||||
uint16_t fat_offset;
|
||||
uint16_t cluster_offset;
|
||||
uint16_t volume_boot_record_addr;
|
||||
|
||||
// Auslesen Cluster Size der MMC/SD Karte und Speichern der größe ins EEprom
|
||||
// Auslesen Cluster Offset der MMC/SD Karte und Speichern der größe ins EEprom
|
||||
void fat_init(uint8_t * Buffer)
|
||||
{
|
||||
struct BootSec *bootp; // Zeiger auf Bootsektor Struktur
|
||||
|
||||
// uint8_t Buffer[BlockSize];
|
||||
|
||||
// volume_boot_record_addr = fat_addr (Buffer);
|
||||
mmc_read_sector(MASTER_BOOT_RECORD, Buffer); // Read Master Boot Record
|
||||
struct BootSec *bootp;
|
||||
mmc_read_sector(MASTER_BOOT_RECORD, Buffer);
|
||||
if (Buffer[510] == 0x55 && Buffer[511] == 0xAA) {
|
||||
FAT_DEBUG("MBR Signatur found!\r\n");
|
||||
}
|
||||
@ -40,8 +25,8 @@ void fat_init(uint8_t * Buffer)
|
||||
|
||||
else {
|
||||
FAT_DEBUG("VBR Signatur not found!\r\n");
|
||||
volume_boot_record_addr = MASTER_BOOT_RECORD; // <- added by Hennie
|
||||
mmc_read_sector(MASTER_BOOT_RECORD, Buffer); // Read Master Boot Record
|
||||
volume_boot_record_addr = MASTER_BOOT_RECORD;
|
||||
mmc_read_sector(MASTER_BOOT_RECORD, Buffer);
|
||||
}
|
||||
bootp = (struct BootSec *) Buffer;
|
||||
cluster_size = bootp->BPB_SecPerClus;
|
||||
@ -49,37 +34,33 @@ void fat_init(uint8_t * Buffer)
|
||||
cluster_offset = ((bootp->BPB_BytesPerSec * 32) / BlockSize);
|
||||
cluster_offset += fat_root_dir_addr(Buffer);
|
||||
}
|
||||
// Auslesen der Adresse des First Root Directory von Volume Boot Record
|
||||
uint16_t fat_root_dir_addr(uint8_t *Buffer)
|
||||
|
||||
uint16_t fat_root_dir_addr(uint8_t * Buffer)
|
||||
{
|
||||
struct BootSec *bootp; // Zeiger auf Bootsektor Struktur
|
||||
struct BootSec *bootp;
|
||||
uint16_t FirstRootDirSecNum;
|
||||
|
||||
// auslesen des Volume Boot Record von der MMC/SD Karte
|
||||
|
||||
mmc_read_sector(volume_boot_record_addr, Buffer);
|
||||
bootp = (struct BootSec *) Buffer;
|
||||
|
||||
// berechnet den ersten Sector des Root Directory
|
||||
|
||||
FirstRootDirSecNum = (bootp->BPB_RsvdSecCnt +
|
||||
(bootp->BPB_NumFATs * bootp->BPB_FATSz16));
|
||||
FirstRootDirSecNum += volume_boot_record_addr;
|
||||
return (FirstRootDirSecNum);
|
||||
}
|
||||
|
||||
// Ausgabe des angegebenen Directory Eintrag in Entry_Count
|
||||
// ist kein Eintrag vorhanden, ist der Eintrag im
|
||||
// Rückgabe Cluster 0xFFFF. Es wird immer nur ein Eintrag ausgegeben
|
||||
// um Speicherplatz zu sparen um es auch für kleine Atmels zu benutzen
|
||||
uint16_t fat_read_dir_ent(uint16_t dir_cluster, // Angabe Dir Cluster
|
||||
uint8_t Entry_Count, // Angabe welcher Direintrag
|
||||
uint32_t *Size, // Rückgabe der File Größe
|
||||
uint8_t *Dir_Attrib, // Rückgabe des Dir Attributs
|
||||
uint8_t *Buffer) // Working Buffer
|
||||
|
||||
uint16_t fat_read_dir_ent(uint16_t dir_cluster,
|
||||
uint8_t Entry_Count,
|
||||
uint32_t * Size,
|
||||
uint8_t * Dir_Attrib, uint8_t * Buffer)
|
||||
{
|
||||
uint8_t *pointer;
|
||||
uint16_t TMP_Entry_Count = 0;
|
||||
uint32_t Block = 0;
|
||||
struct DirEntry *dir; // Zeiger auf einen Verzeichniseintrag
|
||||
struct DirEntry *dir;
|
||||
uint16_t blk;
|
||||
uint16_t a;
|
||||
uint8_t b;
|
||||
@ -89,34 +70,27 @@ uint16_t fat_read_dir_ent(uint16_t dir_cluster, // Angabe Dir Cluster
|
||||
}
|
||||
|
||||
else {
|
||||
|
||||
// Berechnung des Blocks aus BlockCount und Cluster aus FATTabelle
|
||||
// Berechnung welcher Cluster zu laden ist
|
||||
// Auslesen der FAT - Tabelle
|
||||
fat_load(dir_cluster, &Block, Buffer);
|
||||
Block = ((Block - 2) * cluster_size) + cluster_offset;
|
||||
}
|
||||
|
||||
// auslesen des gesamten Root Directory
|
||||
|
||||
for (blk = Block;; blk++) {
|
||||
mmc_read_sector(blk, Buffer); // Lesen eines Blocks des Root Directory
|
||||
mmc_read_sector(blk, Buffer);
|
||||
for (a = 0; a < BlockSize; a = a + 32) {
|
||||
dir = (struct DirEntry *) &Buffer[a]; // Zeiger auf aktuellen Verzeichniseintrag holen
|
||||
if (dir->DIR_Name[0] == 0) // Kein weiterer Eintrag wenn erstes Zeichen des Namens 0 ist
|
||||
{
|
||||
dir = (struct DirEntry *) &Buffer[a];
|
||||
if (dir->DIR_Name[0] == 0) {
|
||||
return (0xFFFF);
|
||||
}
|
||||
// Prüfen ob es ein 8.3 Eintrag ist
|
||||
// Das ist der Fall wenn es sich nicht um einen Eintrag für lange Dateinamen
|
||||
// oder um einen als gelöscht markierten Eintrag handelt.
|
||||
|
||||
if ((dir->DIR_Attr != ATTR_LONG_NAME) &&
|
||||
(dir->DIR_Name[0] != DIR_ENTRY_IS_FREE)) {
|
||||
|
||||
// Ist es der gewünschte Verzeichniseintrag
|
||||
|
||||
if (TMP_Entry_Count == Entry_Count) {
|
||||
|
||||
// Speichern des Verzeichnis Eintrages in den Rückgabe Buffer
|
||||
for ( b = 0; b < 11; b++) {
|
||||
|
||||
for (b = 0; b < 11; b++) {
|
||||
if (dir->DIR_Name[b] != SPACE) {
|
||||
if (b == 8) {
|
||||
*pointer++ = '.';
|
||||
@ -127,68 +101,48 @@ uint16_t fat_read_dir_ent(uint16_t dir_cluster, // Angabe Dir Cluster
|
||||
*pointer++ = '\0';
|
||||
*Dir_Attrib = dir->DIR_Attr;
|
||||
|
||||
// Speichern der Filegröße
|
||||
|
||||
*Size = dir->DIR_FileSize;
|
||||
|
||||
// Speichern des Clusters des Verzeichniseintrages
|
||||
|
||||
dir_cluster = dir->DIR_FstClusLO;
|
||||
|
||||
// Eintrag gefunden Rücksprung mit Cluster File Start
|
||||
|
||||
return (dir_cluster);
|
||||
}
|
||||
TMP_Entry_Count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
return (0xFFFF); // Kein Eintrag mehr gefunden Rücksprung mit 0xFFFF
|
||||
return (0xFFFF);
|
||||
}
|
||||
|
||||
// Auslesen der Cluster für ein File aus der FAT
|
||||
// in den Buffer(512Byte). Bei einer 128MB MMC/SD
|
||||
// Karte ist die Cluster größe normalerweise 16KB groß
|
||||
// das bedeutet das File kann max. 4MByte groß sein.
|
||||
// Bei größeren Files muß der Buffer größer definiert
|
||||
// werden! (Ready)
|
||||
// Cluster = Start Clusterangabe aus dem Directory
|
||||
void fat_load(uint16_t Cluster, // Angabe Startcluster
|
||||
uint32_t *Block, uint8_t *TMP_Buffer) // Workingbuffer
|
||||
void fat_load(uint16_t Cluster, uint32_t * Block, uint8_t * TMP_Buffer)
|
||||
{
|
||||
|
||||
// Zum Überprüfen ob der FAT Block schon geladen wurde
|
||||
uint16_t FAT_Block_Store = 0;
|
||||
|
||||
// Byte Adresse innerhalb des Fat Blocks
|
||||
uint16_t FAT_Byte_Addresse;
|
||||
|
||||
// FAT Block Adresse
|
||||
uint16_t FAT_Block_Addresse;
|
||||
uint16_t a;
|
||||
|
||||
// Berechnung für den ersten FAT Block (FAT Start Addresse)
|
||||
for (a = 0;; a++) {
|
||||
if (a == *Block) {
|
||||
*Block = (0x0000FFFF & Cluster);
|
||||
return;
|
||||
}
|
||||
if (Cluster == 0xFFFF) {
|
||||
break; // Ist das Ende des Files erreicht Schleife beenden
|
||||
break;
|
||||
}
|
||||
// Berechnung des Bytes innerhalb des FAT Block´s
|
||||
|
||||
FAT_Byte_Addresse = (Cluster * 2) % BlockSize;
|
||||
|
||||
// Berechnung des Blocks der gelesen werden muß
|
||||
|
||||
FAT_Block_Addresse =
|
||||
((Cluster * 2) / BlockSize) + volume_boot_record_addr + fat_offset;
|
||||
|
||||
// Lesen des FAT Blocks
|
||||
// Überprüfung ob dieser Block schon gelesen wurde
|
||||
if (FAT_Block_Addresse != FAT_Block_Store) {
|
||||
FAT_Block_Store = FAT_Block_Addresse;
|
||||
|
||||
// Lesen des FAT Blocks
|
||||
mmc_read_sector(FAT_Block_Addresse, TMP_Buffer);
|
||||
}
|
||||
// Lesen der nächsten Clusternummer
|
||||
Cluster =
|
||||
(TMP_Buffer[FAT_Byte_Addresse + 1] << 8) +
|
||||
TMP_Buffer[FAT_Byte_Addresse];
|
||||
@ -196,75 +150,43 @@ void fat_load(uint16_t Cluster, // Angabe Startcluster
|
||||
return;
|
||||
}
|
||||
|
||||
// Lesen eines 512Bytes Blocks von einem File
|
||||
void fat_read_file(uint16_t Cluster, // Angabe des Startclusters vom File
|
||||
uint8_t *Buffer, // Workingbuffer
|
||||
uint32_t BlockCount) // Angabe welcher Bock vom File geladen
|
||||
// werden soll a 512 Bytes
|
||||
void fat_read_file(uint16_t Cluster, uint8_t * Buffer, uint32_t BlockCount)
|
||||
{
|
||||
|
||||
// Berechnung des Blocks aus BlockCount und Cluster aus FATTabelle
|
||||
// Berechnung welcher Cluster zu laden ist
|
||||
uint32_t Block = (BlockCount / cluster_size);
|
||||
|
||||
// Auslesen der FAT - Tabelle
|
||||
fat_load(Cluster, &Block, Buffer);
|
||||
Block = ((Block - 2) * cluster_size) + cluster_offset;
|
||||
|
||||
// Berechnung des Blocks innerhalb des Cluster
|
||||
Block += (BlockCount % cluster_size);
|
||||
|
||||
// Read Data Block from Device
|
||||
mmc_read_sector(Block, Buffer);
|
||||
return;
|
||||
}
|
||||
|
||||
// Lesen eines 512Bytes Blocks von einem File
|
||||
void fat_write_file(uint16_t cluster, // Angabe des Startclusters vom File
|
||||
uint8_t *buffer, // Workingbuffer
|
||||
uint32_t blockCount) // Angabe welcher Bock vom File gespeichert
|
||||
// werden soll a 512 Bytes
|
||||
void fat_write_file(uint16_t cluster, uint8_t * buffer, uint32_t blockCount)
|
||||
{
|
||||
|
||||
// Berechnung des Blocks aus BlockCount und Cluster aus FATTabelle
|
||||
// Berechnung welcher Cluster zu speichern ist
|
||||
uint8_t tmp_buffer[513];
|
||||
uint32_t block = (blockCount / cluster_size);
|
||||
|
||||
// Auslesen der FAT - Tabelle
|
||||
fat_load(cluster, &block, tmp_buffer);
|
||||
block = ((block - 2) * cluster_size) + cluster_offset;
|
||||
|
||||
// Berechnung des Blocks innerhalb des Cluster
|
||||
block += (blockCount % cluster_size);
|
||||
|
||||
// Write Data Block to Device
|
||||
mmc_write_sector(block, buffer);
|
||||
return;
|
||||
}
|
||||
|
||||
// Sucht ein File im Directory
|
||||
uint8_t fat_search_file(uint8_t *File_Name, // Name des zu suchenden Files
|
||||
uint16_t *Cluster, // Angabe Dir Cluster welches
|
||||
// durchsucht werden soll
|
||||
// und Rückgabe des clusters
|
||||
// vom File welches gefunden
|
||||
// wurde
|
||||
uint32_t *Size, // Rückgabe der File Größe
|
||||
uint8_t *Dir_Attrib, // Rückgabe des Dir Attributs
|
||||
uint8_t *Buffer) // Working Buffer
|
||||
uint8_t fat_search_file(uint8_t * File_Name,
|
||||
uint16_t * Cluster,
|
||||
uint32_t * Size, uint8_t * Dir_Attrib, uint8_t * Buffer)
|
||||
{
|
||||
uint16_t Dir_Cluster_Store = *Cluster;
|
||||
uint8_t a ;
|
||||
uint8_t a;
|
||||
for (a = 0; a < 100; a++) {
|
||||
*Cluster =
|
||||
fat_read_dir_ent(Dir_Cluster_Store, a, Size, Dir_Attrib, Buffer);
|
||||
if (*Cluster == 0xffff) {
|
||||
return (0); // File not Found
|
||||
return (0);
|
||||
}
|
||||
if (strcasecmp((char *) File_Name, (char *) Buffer) == 0) {
|
||||
return (1); // File Found
|
||||
return (1);
|
||||
}
|
||||
}
|
||||
return (2); // Error
|
||||
return (2);
|
||||
}
|
||||
|
||||
@ -8,37 +8,35 @@
|
||||
#include "uart.h"
|
||||
|
||||
#define FAT_DEBUG uart_puts
|
||||
// #define FAT_DEBUG(...)
|
||||
|
||||
// Prototypes
|
||||
|
||||
|
||||
extern uint16_t fat_root_dir_addr(uint8_t *);
|
||||
extern uint16_t fat_read_dir_ent(uint16_t, uint8_t,
|
||||
uint32_t *, uint8_t *,
|
||||
uint8_t *);
|
||||
uint32_t *, uint8_t *, uint8_t *);
|
||||
extern void fat_load(uint16_t, uint32_t *, uint8_t *);
|
||||
extern void fat_read_file(uint16_t, uint8_t *, uint32_t);
|
||||
extern void fat_write_file(uint16_t, uint8_t *, uint32_t);
|
||||
extern void fat_init(uint8_t * Buffer);
|
||||
extern uint8_t fat_search_file(uint8_t *, uint16_t *,
|
||||
uint32_t *, uint8_t *,
|
||||
uint8_t *);
|
||||
uint32_t *, uint8_t *, uint8_t *);
|
||||
|
||||
|
||||
// Block Size in Bytes
|
||||
#define BlockSize 512
|
||||
|
||||
// Master Boot Record
|
||||
|
||||
#define MASTER_BOOT_RECORD 0
|
||||
|
||||
// Volume Boot Record location in Master Boot Record
|
||||
|
||||
#define VBR_ADDR 0x1C6
|
||||
|
||||
// define ASCII
|
||||
|
||||
#define SPACE 0x20
|
||||
#define DIR_ENTRY_IS_FREE 0xE5
|
||||
#define FIRST_LONG_ENTRY 0x01
|
||||
#define SECOND_LONG_ENTRY 0x42
|
||||
|
||||
// define DIR_Attr
|
||||
|
||||
#define ATTR_LONG_NAME 0x0F
|
||||
#define ATTR_READ_ONLY 0x01
|
||||
#define ATTR_HIDDEN 0x02
|
||||
@ -49,21 +47,21 @@ extern uint8_t fat_search_file(uint8_t *, uint16_t *,
|
||||
struct BootSec {
|
||||
uint8_t BS_jmpBoot[3];
|
||||
uint8_t BS_OEMName[8];
|
||||
uint16_t BPB_BytesPerSec; // 2 bytes
|
||||
uint16_t BPB_BytesPerSec;
|
||||
uint8_t BPB_SecPerClus;
|
||||
uint16_t BPB_RsvdSecCnt; // 2 bytes
|
||||
uint16_t BPB_RsvdSecCnt;
|
||||
uint8_t BPB_NumFATs;
|
||||
uint16_t BPB_RootEntCnt; // 2 bytes
|
||||
uint16_t BPB_TotSec16; // 2 bytes
|
||||
uint16_t BPB_RootEntCnt;
|
||||
uint16_t BPB_TotSec16;
|
||||
uint8_t BPB_Media;
|
||||
uint16_t BPB_FATSz16; // 2 bytes
|
||||
uint16_t BPB_SecPerTrk; // 2 bytes
|
||||
uint16_t BPB_NumHeads; // 2 bytes
|
||||
uint32_t BPB_HiddSec; // 4 bytes
|
||||
uint32_t BPB_TotSec32; // 4 bytes
|
||||
uint16_t BPB_FATSz16;
|
||||
uint16_t BPB_SecPerTrk;
|
||||
uint16_t BPB_NumHeads;
|
||||
uint32_t BPB_HiddSec;
|
||||
uint32_t BPB_TotSec32;
|
||||
};
|
||||
|
||||
// FAT12 and FAT16 Structure Starting at Offset 36
|
||||
|
||||
#define BS_DRVNUM 36
|
||||
#define BS_RESERVED1 37
|
||||
#define BS_BOOTSIG 38
|
||||
@ -71,7 +69,7 @@ struct BootSec {
|
||||
#define BS_VOLLAB 43
|
||||
#define BS_FILSYSTYPE 54
|
||||
|
||||
// FAT32 Structure Starting at Offset 36
|
||||
|
||||
#define BPB_FATSZ32 36
|
||||
#define BPB_EXTFLAGS 40
|
||||
#define BPB_FSVER 42
|
||||
@ -86,20 +84,20 @@ struct BootSec {
|
||||
#define FAT32_BS_VOLID 67
|
||||
#define FAT32_BS_VOLLAB 71
|
||||
#define FAT32_BS_FILSYSTYPE 82
|
||||
// End of Boot Sctor and BPB Structure
|
||||
|
||||
struct DirEntry {
|
||||
uint8_t DIR_Name[11]; // 8 chars filename
|
||||
uint8_t DIR_Attr; // file attributes RSHA, Longname, Drive Label, Directory
|
||||
uint8_t DIR_NTRes; // set to zero
|
||||
uint8_t DIR_CrtTimeTenth; // creation time part in milliseconds
|
||||
uint16_t DIR_CrtTime; // creation time
|
||||
uint16_t DIR_CrtDate; // creation date
|
||||
uint16_t DIR_LastAccDate; // last access date
|
||||
uint16_t DIR_FstClusHI; // first cluster high word
|
||||
uint16_t DIR_WrtTime; // last write time
|
||||
uint16_t DIR_WrtDate; // last write date
|
||||
uint16_t DIR_FstClusLO; // first cluster low word
|
||||
uint8_t DIR_Name[11];
|
||||
uint8_t DIR_Attr;
|
||||
uint8_t DIR_NTRes;
|
||||
uint8_t DIR_CrtTimeTenth;
|
||||
uint16_t DIR_CrtTime;
|
||||
uint16_t DIR_CrtDate;
|
||||
uint16_t DIR_LastAccDate;
|
||||
uint16_t DIR_FstClusHI;
|
||||
uint16_t DIR_WrtTime;
|
||||
uint16_t DIR_WrtDate;
|
||||
uint16_t DIR_FstClusLO;
|
||||
uint32_t DIR_FileSize;
|
||||
};
|
||||
|
||||
#endif // _FAT_H_
|
||||
#endif
|
||||
|
||||
@ -1,18 +1,13 @@
|
||||
#include "mmc.h"
|
||||
#include <util/delay.h>
|
||||
|
||||
uint8_t mmc_init()
|
||||
{
|
||||
uint16_t Timeout = 0, i;
|
||||
|
||||
// Konfiguration des Ports an der die MMC/SD-Karte angeschlossen wurde
|
||||
MMC_REG |= ((1 << MMC_DO) | (1 << MMC_CS) | (1 << MMC_CLK));
|
||||
MMC_REG &= ~(1 << MMC_DI);
|
||||
MMC_WRITE |= ((1 << MMC_DO) | (1 << MMC_DI) | (1 << MMC_CS));
|
||||
|
||||
// Wartet eine kurze Zeit
|
||||
_delay_ms(20);
|
||||
|
||||
// Initialisiere MMC/SD-Karte in den SPI-Mode
|
||||
for (i = 0; i < 250; i++) {
|
||||
MMC_WRITE ^= (1 << MMC_CLK);
|
||||
_delay_us(4);
|
||||
@ -22,52 +17,46 @@ uint8_t mmc_init()
|
||||
MMC_WRITE &= ~(1 << MMC_CS);
|
||||
_delay_us(3);
|
||||
|
||||
// Sendet Commando CMD0 an MMC/SD-Karte
|
||||
uint8_t CMD[] = { 0x40, 0x00, 0x00, 0x00, 0x00, 0x95 };
|
||||
while (mmc_write_command(CMD) != 1) {
|
||||
if (Timeout++ > 20) {
|
||||
mmc_disable();
|
||||
return (1); // Abbruch bei Commando1 (Return Code1)
|
||||
return (1);
|
||||
}
|
||||
}
|
||||
|
||||
// Sendet Commando CMD1 an MMC/SD-Karte
|
||||
Timeout = 0;
|
||||
CMD[0] = 0x41; // Commando 1
|
||||
CMD[0] = 0x41;
|
||||
CMD[5] = 0xFF;
|
||||
while (mmc_write_command(CMD) != 0) {
|
||||
if (Timeout++ > 800) {
|
||||
mmc_disable();
|
||||
return (9); // Abbruch bei Commando2 (Return Code2)
|
||||
return (9);
|
||||
}
|
||||
}
|
||||
return (0);
|
||||
}
|
||||
|
||||
// Sendet ein Commando an die MMC/SD-Karte
|
||||
uint8_t mmc_write_command(uint8_t *cmd)
|
||||
uint8_t mmc_write_command(uint8_t * cmd)
|
||||
{
|
||||
uint8_t tmp = 0xff;
|
||||
uint16_t Timeout = 0;
|
||||
uint8_t a;
|
||||
|
||||
// sendet 6 Byte Commando
|
||||
for (a = 0; a < 0x06; a++) // sendet 6 Byte Commando zur MMC/SD-Karte
|
||||
{
|
||||
for (a = 0; a < 0x06; a++) {
|
||||
mmc_write_byte(*cmd++);
|
||||
}
|
||||
|
||||
// Wartet auf ein gültige Antwort von der MMC/SD-Karte
|
||||
while (tmp == 0xff) {
|
||||
tmp = mmc_read_byte();
|
||||
if (Timeout++ > 50) {
|
||||
break; // Abbruch da die MMC/SD-Karte nicht Antwortet
|
||||
break;
|
||||
}
|
||||
}
|
||||
return (tmp);
|
||||
}
|
||||
|
||||
// Routine zum Empfangen eines Bytes von der MMC-Karte
|
||||
|
||||
uint8_t mmc_read_byte(void)
|
||||
{
|
||||
uint8_t Byte = 0, j;
|
||||
@ -88,7 +77,7 @@ uint8_t mmc_read_byte(void)
|
||||
return (Byte);
|
||||
}
|
||||
|
||||
// Routine zum Senden eines Bytes zur MMC-Karte
|
||||
|
||||
void mmc_write_byte(uint8_t Byte)
|
||||
{
|
||||
uint8_t i;
|
||||
@ -109,94 +98,76 @@ void mmc_write_byte(uint8_t Byte)
|
||||
MMC_WRITE |= (1 << MMC_DO);
|
||||
}
|
||||
|
||||
// Routine zum schreiben eines Blocks(512Byte) auf die MMC/SD-Karte
|
||||
uint8_t mmc_write_sector(uint32_t addr, uint8_t *Buffer)
|
||||
uint8_t mmc_write_sector(uint32_t addr, uint8_t * Buffer)
|
||||
{
|
||||
uint8_t tmp;
|
||||
|
||||
// Commando 24 zum schreiben eines Blocks auf die MMC/SD - Karte
|
||||
|
||||
uint8_t cmd[] = { 0x58, 0x00, 0x00, 0x00, 0x00, 0xFF };
|
||||
uint8_t a;
|
||||
uint16_t i;
|
||||
|
||||
/*
|
||||
* Die Adressierung der MMC/SD-Karte wird in Bytes angegeben, addr wird von Blocks zu Bytes umgerechnet danach werden diese in
|
||||
* das Commando eingefügt
|
||||
*/
|
||||
addr = addr << 9; // addr = addr * 512
|
||||
addr = addr << 9;
|
||||
cmd[1] = ((addr & 0xFF000000) >> 24);
|
||||
cmd[2] = ((addr & 0x00FF0000) >> 16);
|
||||
cmd[3] = ((addr & 0x0000FF00) >> 8);
|
||||
|
||||
// Sendet Commando cmd24 an MMC/SD-Karte (Write 1 Block/512 Bytes)
|
||||
|
||||
tmp = mmc_write_command(cmd);
|
||||
if (tmp != 0) {
|
||||
return (tmp);
|
||||
}
|
||||
// Wartet einen Moment und sendet einen Clock an die MMC/SD-Karte
|
||||
|
||||
for (a = 0; a < 100; a++) {
|
||||
mmc_read_byte();
|
||||
}
|
||||
|
||||
// Sendet Start Byte an MMC/SD-Karte
|
||||
mmc_write_byte(0xFE);
|
||||
|
||||
// Schreiben des Bolcks (512Bytes) auf MMC/SD-Karte
|
||||
for (a = 0; i < 512; i++) {
|
||||
mmc_write_byte(*Buffer++);
|
||||
}
|
||||
|
||||
// CRC-Byte schreiben
|
||||
mmc_write_byte(0xFF); // Schreibt Dummy CRC
|
||||
mmc_write_byte(0xFF); // CRC Code wird nicht benutzt
|
||||
mmc_write_byte(0xFF);
|
||||
mmc_write_byte(0xFF);
|
||||
|
||||
// Fehler beim schreiben? (Data Response XXX00101 = OK)
|
||||
if ((mmc_read_byte() & 0x1F) != 0x05)
|
||||
return (1);
|
||||
|
||||
// Wartet auf MMC/SD-Karte Bussy
|
||||
while (mmc_read_byte() != 0xff) {
|
||||
};
|
||||
return (0);
|
||||
}
|
||||
|
||||
// Routine zum lesen des CID Registers von der MMC/SD-Karte (16Bytes)
|
||||
void mmc_read_block(uint8_t *cmd, uint8_t *Buffer,
|
||||
uint16_t Bytes)
|
||||
|
||||
void mmc_read_block(uint8_t * cmd, uint8_t * Buffer, uint16_t Bytes)
|
||||
{
|
||||
uint16_t a;
|
||||
|
||||
// Sendet Commando cmd an MMC/SD-Karte
|
||||
if (mmc_write_command(cmd) != 0) {
|
||||
return;
|
||||
}
|
||||
// Wartet auf Start Byte von der MMC/SD-Karte (FEh/Start Byte)
|
||||
|
||||
while (mmc_read_byte() != 0xfe) {
|
||||
};
|
||||
|
||||
// Lesen des Bolcks (normal 512Bytes) von MMC/SD-Karte
|
||||
|
||||
for (a = 0; a < Bytes; a++) {
|
||||
*Buffer++ = mmc_read_byte();
|
||||
}
|
||||
|
||||
// CRC-Byte auslesen
|
||||
mmc_read_byte(); // CRC - Byte wird nicht ausgewertet
|
||||
mmc_read_byte(); // CRC - Byte wird nicht ausgewertet
|
||||
mmc_read_byte();
|
||||
mmc_read_byte();
|
||||
return;
|
||||
}
|
||||
|
||||
// Routine zum lesen eines Blocks(512Byte) von der MMC/SD-Karte
|
||||
uint8_t mmc_read_sector(uint32_t addr, uint8_t *Buffer)
|
||||
uint8_t mmc_read_sector(uint32_t addr, uint8_t * Buffer)
|
||||
{
|
||||
|
||||
// Commando 16 zum lesen eines Blocks von der MMC/SD - Karte
|
||||
|
||||
uint8_t cmd[] = { 0x51, 0x00, 0x00, 0x00, 0x00, 0xFF };
|
||||
|
||||
/*
|
||||
* Die Adressierung der MMC/SD-Karte wird in Bytes angegeben, addr wird von Blocks zu Bytes umgerechnet danach werden diese in
|
||||
* das Commando eingefügt
|
||||
*/
|
||||
addr = addr << 9; // addr = addr * 512
|
||||
addr = addr << 9;
|
||||
cmd[1] = ((addr & 0xFF000000) >> 24);
|
||||
cmd[2] = ((addr & 0x00FF0000) >> 16);
|
||||
cmd[3] = ((addr & 0x0000FF00) >> 8);
|
||||
@ -204,21 +175,19 @@ uint8_t mmc_read_sector(uint32_t addr, uint8_t *Buffer)
|
||||
return (0);
|
||||
}
|
||||
|
||||
// Routine zum lesen des CID Registers von der MMC/SD-Karte (16Bytes)
|
||||
uint8_t mmc_read_cid(uint8_t *Buffer)
|
||||
|
||||
uint8_t mmc_read_cid(uint8_t * Buffer)
|
||||
{
|
||||
|
||||
// Commando zum lesen des CID Registers
|
||||
uint8_t cmd[] = { 0x4A, 0x00, 0x00, 0x00, 0x00, 0xFF };
|
||||
mmc_read_block(cmd, Buffer, 16);
|
||||
return (0);
|
||||
}
|
||||
|
||||
// Routine zum lesen des CSD Registers von der MMC/SD-Karte (16Bytes)
|
||||
uint8_t mmc_read_csd(uint8_t *Buffer)
|
||||
|
||||
uint8_t mmc_read_csd(uint8_t * Buffer)
|
||||
{
|
||||
|
||||
// Commando zum lesen des CSD Registers
|
||||
uint8_t cmd[] = { 0x49, 0x00, 0x00, 0x00, 0x00, 0xFF };
|
||||
mmc_read_block(cmd, Buffer, 16);
|
||||
return (0);
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
#include <avr/io.h>
|
||||
|
||||
|
||||
#define MMC_WRITE PORTB // Port an der die MMC/SD-Karte angeschlossen ist also des SPI
|
||||
#define MMC_WRITE PORTB
|
||||
#define MMC_READ PINB
|
||||
#define MMC_REG DDRB
|
||||
|
||||
@ -26,6 +26,4 @@ extern uint8_t mmc_read_cid(uint8_t *);
|
||||
|
||||
#define mmc_enable() MMC_WRITE&=~(1<<MMC_CS);
|
||||
|
||||
#define nop() __asm__ __volatile__ ("nop" ::)
|
||||
|
||||
#endif
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user