AVR mit einer SD-Karte erweitern – Teil 2

Im ersten Teil des AVR SD-Karten Tutorials habe ich gezeigt, wie die SD-Karte mit einem Mikrocontroller verbunden wird und wie die Kommunikation mit einer SD-Karte aufgebaut ist. Anschließend habe ich gezeigt, wie die Karte initialisiert wird, sodass der Mikrocontroller mit ihr kommunizieren kann. Dieser Teil des Tutorials soll sich nun etwas tiefer mit der Kommunikation der SD-Karte beschäftigen. Es wird gezeigt, wie die Hardwareinformationen der SD-Karte gelesen, bzw. wie einzelne Blöcke oder Sektoren der Karte gelesen und beschrieben werden können, wodurch es dem Mikrocontroller ermöglichen werden soll, auf das Dateisystem und die Dateien, die auf der SD-Karte gespeichert sind, zuzugreifen und diese zu bearbeiten.

Die Realisierung des Zugriffs auf das Dateisystem wird im nächsten Teil vorgestellt. Ausgangsbasis dafür ist die FatFs-Bibliothek von ElmChan. Diese Bibliothek stellt eine allgemeine Schnittstelle für ein FAT-Dateisystem mit Support für verschiedene Plattformen bereit. Alles was der Anwender entwickeln muss, ist die Schnittstelle zum Speichermedium (hier die SD-Karte).

Bevor Daten von der SD-Karte ausgelesen werden können, muss zuerst ein entsprechendes Kommando (wie z. B. CMD9) an die Karte gesendet werden. Die SD-Karte bestätigt dieses Kommando mit einer R1-Antwort. Anschließend beginnt die Karte mit der Übertragung der angeforderten Daten.

Das gesendete Datenpaket besteht aus einem Token, einen bis zu 2048 Byte langen Datenblock und einer 2 Byte langen CRC.

Token	Beschreibung
0xFC	Token für CMD17/18/24
0xFD	Token für CMD25
0xFE	Stop Token für CMD25

Aus dem gezeigten Ablauf ergibt sich die folgende Empfangsroutine:

static const SD_Error_t SD_ReadBlock(const uint32_t Length, uint8_t* Buffer)
{
	uint8_t Response = 0xFF;

	Wait = 0x00;
	while((++Wait < 0x2710) && (Response == 0xFF))
	{
		Response = SPIM_TRANSMIT(&USARTD0, 0xFF);
		if(Wait >= 0x2710)
		{
			SD_Deselect();

			return SD_NO_RESPONSE;
		}
	}

	for(uint32_t i = 0x00; i < Length; i++)
	{
		*Buffer++ = SPIM_TRANSMIT(&USARTD0, 0xFF);
	}

	SPIM_TRANSMIT(&USARTD0, 0xFF);
	SPIM_TRANSMIT(&USARTD0, 0xFF);
	
	return SD_SUCCESSFULL;
}

Über diese Funktion kann nun z. B. das STATUS-Register der SD-Karte ausgelesen werden. Dazu wird das Kommando ACMD13 an die Karte gesendet. Die SD-Karte antwortet auf diesen Befehl mit einem 64 Byte großen Datenpaket, welches die Statusinformationen der SD-Karte beinhaltet.

const SD_Error_t SD_GetStatus(SD_Status_t* Status)
{
	uint8_t* Ptr = (uint8_t*)Status;
		
	if((SD_SendCommand(SD_ID_TO_CMD(SD_CMD_ACMD13), 0x00) == SD_SUCCESSFULL) && (SD_ReadBlock(sizeof(SD_Status_t), Ptr) == SD_SUCCESSFULL))
	{
		SD_Deselect();

		return SD_SUCCESSFULL;
	}
		
	SD_Deselect();
	
	return SD_NO_RESPONSE;
}

Aus Gründen der Übersicht habe ich die Statusinformationen in einer Struktur hinterlegt, sodass die empfangenen Daten direkt identifiziert werden können.

 typedef struct  
 {
	 uint8_t DAT_BUS_WIDTH:2;
	 uint8_t SECURED_MODE:1;
	 uint16_t Reserved:13;
	 uint16_t SD_CARD_TYPE;	
	 uint32_t SIZE_OF_PROT_AREA;
	 uint8_t SPEED_CLASS;
	 uint8_t PERFORMANCE_MOVE;
	 uint8_t AU_SIZE:4;
	 uint8_t Reserved1:4;	
	 uint16_t ERASE_SIZE;
	 uint8_t ERASE_TIMEOUT:6;
	 uint8_t ERASE_OFFSET:2;
	 uint8_t Zero[11];
	 uint8_t Reserved3[39];
 } __attribute__((packed)) SD_Status_t;

Es ergibt sich damit der folgende Aufruf:

SD_Status_t Status;
SD_Error_t Error;

Error = SD_GetStatus(&Status);

Aus den Statusinformationen lässt sich z. B. der Kartentyp oder die Klasse der SD-Karte kodiert.

Klasse	Beschreibung
0x00	Klasse 0
0x01	Klasse 1
0x02	Klasse 2
0x03	Klasse 3

Auf ähnliche Weise kann nun das CID oder das CSD-Register der SD-Karte ausgelesen werden.

const SD_Error_t SD_GetCSD(SD_CSD_t* CSD)
{
	uint8_t* Ptr = (uint8_t*)CSD;

	if((SD_SendCommand(SD_ID_TO_CMD(SD_CMD_SEND_CSD), 0x00) == SD_SUCCESSFULL) && (SD_ReadBlock(sizeof(SD_CSD_t), Ptr) == SD_SUCCESSFULL))
	{
		SD_Deselect();

		return SD_SUCCESSFULL;
	}

	SD_Deselect();

	return SD_NO_RESPONSE;
}

const SD_Error_t SD_GetCID(SD_CID_t* CID)
{
	uint8_t* Ptr = (uint8_t*)CID;

	if((SD_SendCommand(SD_ID_TO_CMD(SD_CMD_SEND_CID), 0x00) == SD_SUCCESSFULL) && (SD_ReadBlock(sizeof(SD_CID_t), Ptr) == SD_SUCCESSFULL))
	{
		SD_Deselect();

		return SD_SUCCESSFULL;
	}

	SD_Deselect();
	
	return SD_NO_RESPONSE;
}

SD_CID_t CID;
Error = SD_GetCID(&CID);
	
SD_CSD_t CSD;
Error = SD_GetCSD(&CSD);

Über das CID-Register kann die Karte identifiziert werden. Das Register beinhaltet u. a. eine Hersteller- und eine OEM-ID, sowie die Seriennummer der SD-Karte.

Damit das Dateisystem Daten auf die SD-Karte schreiben, bzw. Daten von der SD-Karte lesen kann, werden Funktionen benötigt, die einzelne Datenblöcke lesen, bzw. schreiben. Die SD-Karte bietet dafür die folgenden Befehle an:

Befehl	Funktion
CMD17	Lese einzelnen Block
CMD18	Lese n Blöcke
CMD24	Schreibe einzelnen Block
CMD25	Schreibe n Blöcke

Ein Lese- bzw. Schreibzugriff auf einen einzelnen Datenblock sieht dabei folgendermaßen aus.

Für einen lesenden Datenzugriff kann die bereits vorgestellte ReadBlock-Funktion verwendet werden. Die Schreibfunktion sieht dann folgendermaßen aus:

static const SD_Error_t SD_WriteBlock(const uint8_t* Buffer, const uint32_t Length, const uint8_t Token)
{
	uint8_t* Buffer_Temp = (uint8_t*)Buffer;

	SPIM_TRANSMIT(&USARTD0, Token);
	if(Token != SD_TOKEN_STOP)
	{
		for(uint32_t i = 0x00; i < Length; i++)
		{
			SPIM_TRANSMIT(&USARTD0, *Buffer_Temp++);
		}

		SPIM_TRANSMIT(&USARTD0, 0xFF);
		SPIM_TRANSMIT(&USARTD0, 0xFF);

		if((SPIM_TRANSMIT(&USARTD0, 0xFF) & 0x1F) != 0x05)
		{
			return SD_NO_RESPONSE;
		}
	}

	while(SPIM_TRANSMIT(&USARTD0, 0xFF) != 0xFF);

	return SD_SUCCESSFULL;
}

Zusammen mit der SendCommand-Funktion werden aus der ReadBlock– und WriteBlock-Funktion die vollständigen Funktionen zum Lesen, bzw. Schreiben eines Datenblocks.

const SD_Error_t SD_ReadDataBlock(const uint32_t Address, uint8_t* Buffer)
{
	if((SD_SendCommand(SD_ID_TO_CMD(SD_CMD_READ_SINGLE_BLOCK), Address) == SD_SUCCESSFULL) && (SD_ReadBlock(SD_BLOCK_SIZE, Buffer) == SD_SUCCESSFULL))
	{
		SD_Deselect();

		return SD_SUCCESSFULL;
	}

	SD_Deselect();

	return SD_NO_RESPONSE;
}

const SD_Error_t SD_WriteDataBlock(const uint32_t Address, const uint8_t* Buffer)
{
	if((SD_SendCommand(SD_ID_TO_CMD(SD_CMD_WRITE_SINGLE_BLOCK), Address) == SD_SUCCESSFULL) && (SD_WriteBlock(Buffer, SD_BLOCK_SIZE, SD_TOKEN_DATA) == SD_SUCCESSFULL))
	{
		SD_Deselect();

		return SD_SUCCESSFULL;
	}

	SD_Deselect();

	return SD_NO_RESPONSE;
}

Mit der SD_ReadDataBlock-Funktion können einzelne Sektoren, wie z. B. der erste Sektor der SD-Karte, ausgelesen werden.

uint8_t FirstSector[512];
Error = SD_ReadDataBlock(0x00, FirstSector);

Die gelesenen Daten können überprüft werden, indem die letzten beiden Stellen des Arrays betrachtet werden. Bei einem gültigen FAT-Dateisystem sind dort die Werte 0x55 und 0xAA gespeichert.

Info:

Bei einem FAT-Dateisystem handelt es sich bei dem ersten Sektor immer um den Bootsektor für das Betriebssystem.

Dieser Sektor ist immer 512 Byte groß, egal was für ein Speichermedium genutzt wird. Das BIOS ließt diesen ein und führt den darin enthaltenen Code aus um das Betriebssystem zu laden.

Für große Datenmengen ist es sinnvoll, sämtliche Daten in einem einzigen Durchlauf zu übertragen. Speziell für die Übertragung von mehreren Datenblöcken besitzen SD-Karten die Befehle CMD18 und CMD25, mit denen mehrere Blöcke gelesen oder geschrieben werden können.

Einmal eingeleitet sendet, bzw. empfängt die SD-Karte so lange Daten bis der Host über ein Stop-Signal die Übertragung beendet. Dies geschieht bei einem Lesevorgang über das Kommando CMD12 und bei einem Schreibvorgang durch ein Stop-Token (siehe Tabelle) in einem leeren Datenpaket.

Zum Senden, bzw. Empfangen der einzelnen Datenblöcke können die bereits erstellten Funktionen genutzt werden, sodass die Funktionen zum Senden, bzw. Empfangen von mehreren Datenblöcken leicht programmiert werden können.

const SD_Error_t SD_ReadDataBlocks(const uint32_t Address, const uint32_t Blocks, uint8_t* Buffer)
{
	SD_Error_t ErrorCode;

	if(SD_SendCommand(SD_ID_TO_CMD(SD_CMD_READ_MULTIPLE_BLOCK), Address) != SD_SUCCESSFULL)
	{
		SD_Deselect();

		return SD_NO_RESPONSE;
	}

	for(uint32_t i = 0x00; i < Blocks; i++)
	{
		ErrorCode = SD_ReadBlock(SD_BLOCK_SIZE, Buffer);
		if(ErrorCode != SD_SUCCESSFULL)
		{
			SD_Deselect();

			return ErrorCode;
		}

		Buffer += SD_BLOCK_SIZE;
	}

	SD_SendCommand(SD_ID_TO_CMD(SD_CMD_STOP_TRANSMISSION), 0x00);
		
	SD_Deselect();

	return SD_SUCCESSFULL;
}

const SD_Error_t SD_WriteDataBlocks(const uint32_t Address, const uint32_t Blocks, const uint8_t* Buffer)
{
	SD_Error_t ErrorCode;

	if(SD_SendCommand(SD_ID_TO_CMD(SD_CMD_WRITE_MULTIPLE_BLOCK), Address) != SD_SUCCESSFULL)
	{
		SD_Deselect();

		return SD_NO_RESPONSE;
	}

	for(uint32_t i = 0x00; i < Blocks; i++)
	{
		ErrorCode = SD_WriteBlock(Buffer, SD_BLOCK_SIZE, SD_TOKEN_DATA_CMD25);
		if(ErrorCode != SD_SUCCESSFULL)
		{
			SD_Deselect();

			return ErrorCode;
		}

		Buffer += SD_BLOCK_SIZE;
	}

	SD_WriteBlock(NULL, 0, SD_TOKEN_STOP);

	SD_Deselect();

	return SD_SUCCESSFULL;
}

Die grundlegenden Schreib- und Lesefunktionen sind nun fertig programmiert. Wir sind damit in der Lage Daten zwischen der SD-Karte und dem Mikrocontroller auszutauschen und die Daten permanent auf der SD-Karte zu speichern.

Im nächsten Teil soll es dann darum gehen, wie die Unterstützung eines FAT-Dateisystems umgesetzt wird. Das komplette Beispielprojekt kann in meinem GitHub-Repository heruntergeladen werden.

Viel Spaß beim Ausprobieren und vielen Grüße
Daniel

2 Kommentare

Pascal sagt:

31. August 2023 um 09:46 Uhr

Es scheint so, als würde man einen Benutzeraccount für Gitlab benötigten, zumindest wenn man auf den Link hier klickt. Ist das gewollt oder gibt es den Beispielcode auch woanders zu sehen ohne Accountzwang?

Antworten
1. Kampi sagt:
  
  2. September 2023 um 16:48 Uhr
  
  Hallo,
  
  ich habe die Repos umgezogen, allerdings noch nicht die URLs geändert. Bitte bei GitHub (https://github.com/Kampi/AVR) vorbeischauen :)
  
  Gruß
  
  Antworten

Item-Tag	Beschreibung
Usage Page	Spezifiziert die Usage Page der verwendeten Elemente.
Logical Minimum	Kleinste logische Einheit die übertragen wird.
Logical Maximum	Größte logische Einheit die übertragen wird.
Physical Minimum	Das Feld Logical Minimum in physikalische Größen umgerechnet.
Physical Maximum	Das Feld Logical Maximum in physikalische Größen umgerechnet.
Unit Exponent	Einheitenexponent zur Basis 10 (z. B. 3 für Kilo)
Unit	Einheiten-ID um die Einheit des Datenfeldes festzulegen (z. B. 2 für Masse).
Report Size	Legt die Größe eines Datenfeldes für ein Element in Bit fest.
Report ID	Report ID für ein Element. Wenn ein Report ID-Element genutzt wird, werden alle Reports um ein 8-bit großes Datenfeld für die ID erweitert.
Report Count	Legt die Anzahl der Datenfelder für ein Element fest.
Push	Platziert eine Kopie der globalen Statustabelle der Elemente auf dem Stack.
Pop	Ersetzt die Statustabelle für die Elemente mit der aktuellen Tabelle vom Stack.

Item-Tag	Beschreibung
Input	Ausgelesene Daten von einem oder mehreren Steuerungselementen.
Output	Daten für die Steuerung von einem oder mehreren Elementen.
Feature	Ein- oder Ausgabedaten, die nicht für eine Interaktion mit dem Nutzer verwendet werden.
Collection	Eine Gruppierung von Input-, Output- oder Feature-Items.
End Collection	Markiert das Ende einer Collection.

bmRequestType	bReqest	wValue	wIndex	wLength	Data
0xA1	GET_REPORT (1)	Art des Reports und die Report-ID	Interface	Länge des Reports	Report
0xA1	GET_IDLE (2)	0	Interface	1	Idle-Zeit
0xA1	GET_PROTOCOL (3)	0	Interface	1	0 – Boot-Protokoll 1 – Report Protokoll
0x21	SET_REPORT (9)	Art des Reports und die Report ID	Interface	Länge des Reports	Report
0x21	SET_IDLE (10)	Idle-Zeit und Report-ID	Interface	0	–
0x21	SET_PROTOCOL (11)	0 – Boot-Protokoll 1 – Report Protokoll	Interface	0	–

Item-Tag	Beschreibung
Usage	Spezifiziert den Usage Index und ergibt zusammen mit der Usage Page die fertige Gruppe.
Usage Minimum	Definiert den Startwert für eine Gruppe von Anwendungszwecken für mehrere Eingabemethoden.
Usage Maximum	Definiert den Endwert für eine Gruppe von Anwendungszwecken für mehrere Eingabemethoden.
Designator Index	Bezeichner eines entsprechenden Physical-Deskriptors um die Art der Eingabe zu definieren.
Designator Minimum	Definiert den Startwert für eine Gruppe von Bezeichnern für mehrere Eingabemethoden.
Designator Maximum	Definiert den Endwert für eine Gruppe von Bezeichnern für mehrere Eingabemethoden.
String Index	Index des String-Deskriptors um die jeweilige Eingabemethode zu beschreiben.
String Minimum	Legt den Startwert für eine Gruppe von Strings fest um mehrere Eingabemethoden zu benennen.
String Maximum	Legt den Endwert für eine Gruppe von Strings fest um mehrere Eingabemethoden zu benennen.
Delimiter	Definiert den Angang (1) oder das Ende (0) eines lokalen Elements.

bmRequestType	bReqest	wValue	wIndex	wLength	Data
0x00 0x01 0x02	CLEAR_FEATURE (1)	Feature	Null Interface Endpunkt	0	–
0x80	GET_CONFIGURATION (8)	0	0	1	Konfiguration
0x80	GET_DESCRIPTOR (6)	Deskriptortyp (H) und Deskriptorindex (L)	Null oder Sprach ID	Länge des Deskriptors	Deskriptor
0x81	GET_INTERFACE (10)	0	Interface	1	Interface
0x80 0x81 0x82	GET_STATUS (0)	0	0 Interface Endpunkt	2	Gerät-, Interface- oder Endpunktstatus
0x00	SET_ADDRESS (5)	Geräteadresse	0	0	–
0x00	SET_CONFIGURATION (9)	Konfiguration	0	0	–
0x00	SET_DESCRIPTOR (7)	Deskriptortyp (H) und Deskriptorindex (L)	Null oder Sprach ID	Länge des Deskriptors	Deskriptor
0x00 0x01 0x02	SET_FEATURE (3)	Feature	0 Interface Endpunkt	0	–
0x01	SET_INTERFACE (11)	Interface	Interface	0	–
0x82	SYNCH_FRAME (12)	0	Endpunkt	2	Framezähler

AVR mit einer SD-Karte erweitern – Teil 2

Info:

2 Kommentare

Schreibe einen Kommentar Antworten abbrechen

Stringdeskriptor 0

Allgemeiner Stringdeskriptor

Offset	Feld	Größe	Beschreibung
0	bLength	1	Größe des Deskriptors in Bytes
1	bDescriptorType	1	ENDPOINT Deskriptor (Feld = 5)
2	bEndpointAddress	1	Adresse des Endpunktes
			Bit 7: Richtung	0 = OUT 1 = IN
			Bit 6 – 4	0
			Bit 3 – 0: Endpunktnummer	0 – 15
3	bmAttributes	1	Bit 7 – 6	0
			Bit 5 – 4: Verwendung	Nur für Isochrone Endpunkte. Andernfalls 0. 0 = Data endpoint 1 = Feedback endpoint 2 = Implicit feedback Data endpoint 3 = Reserved
			Bit 3 – 2: Synchronisation	Nur für Isochrone Endpunkte. Andernfalls 0. 0 = No Synchronisation 1 = Asynchronous 2 = Adaptive 3 = Synchronous
			Bit 1 – 0: Transfer	0 = Control 1 = Isochronous 2 = Bulk 3 = Interrupt
4	wMaxPacketSize	2	Maximale Paketgröße, die dieser Endpunkt senden oder empfangen kann
6	bInterval	1	Polling Intervall für den Endpunkt in ms Schritten für Low und Full Speed Devices oder in 125 us Schritten für High Speed Devices

Offset	Feld	Größe	Beschreibung
0	bLength	1	Größe des Deskriptors in Bytes
1	bDescriptorType	1	GERÄTE-Deskriptor (Feld = 0x01)
2	bcdUSB	2	Verwendete USB Version
4	bDeviceClass	1	Durch das USB-IF vergebener Klassencode
5	bDeviceSubClass	1	Durch das USB-IF vergebener Subklassencode
6	bDeviceProtocol	1	Durch das USB-IF vergebener Protokolcode
7	bMaxPacketSize0	1	Maximale Paketgröße für Endpunkt 0. Muss entweder 8, 16, 32 oder 64 sein
8	idVendor	2	Durch das USB-IF vergebene Vendor-ID
10	idProduct	2	Durch den Hersteller vergebene Produkt-ID
12	bcdDevice	2	Releasenummer des Gerätes
14	iManufacturer	1	Index des Stringdeskriptors, der den Hersteller beschreibt
15	iProduct	1	Index des Stringdeskriptors, der das Produkt beschreibt
16	iSerialNumber	1	Index des Stringdeskriptors, der die Seriennummer beschreibt
17	bNumConfigurations	1	Anzahl der Gerätekonfigurationen

Offset	Feld	Größe	Beschreibung
0	bLength	1	Größe des Deskriptors in Bytes
1	bDescriptorType	1	INTERFACE-Deskriptor (Feld = 0x04)
2	bInterfaceNumber	1	Interface ID
3	bAlternateSetting	1	Alternative Einstellungen für dieses Interface
4	bNumEndpoints	1	Anzahl der Endpunkte, die für dieses Interface genutzt werden (ohne Endpunkt 0)
5	bInterfaceClass	1	Durch das USB-IF vergebener Klassencode
6	bInterfaceSubClass	1	Durch das USB-IF vergebener Subklassencode
7	bInterfaceProtocol	1	Durch das USB-IF vergebener Protokollcode
8	iInterface	1	Index des Stringdeskriptors, der dieses Interface beschreibt

Offset	Feld	Größe	Beschreibung
0	bLength	1	Größe des Deskriptors in Bytes
1	bDescriptorType	1	STRING-Deskriptor (Feld = 0x03)
2	wLANGID[0]	2	LANGID Code 0
…	…	…	…
2 + x * 2	wLANGID[x]	2	LANGID Code x