Arbeiten Sie mit der SD-Karte über die SPI-Schnittstelle. VHDL-Implementierung

Inhalt

1. Lesen der Spezifikationen

1.1 Allgemeines

• Die Datenübertragung auf die SD-Karte erfolgt in einer Zeile.
• Das Lesen von Daten von einer SD-Karte erfolgt in einer Zeile.
• im SPI-Modus kann die Leistung nur +3,3 V betragen;
• Taktfrequenz im Initialisierungsmodus im Bereich von 100-400 kHz;
• Taktfrequenz nach der Initialisierung - 25 MHz.

• SDSC Kartenkapazität bis zu 2 GB inklusive. Die Adresse auf der Karte ist Byte.
• SDHC. Die Kartenkapazität beträgt mehr als 2 GB und bis zu 32 GB inklusive. Die Adresse auf der Karte gibt einen 512-Byte-Block an.
• SDXC. Die Kartenkapazität beträgt mehr als 32 GB und bis zu 128 TB inklusive. Die Adresse auf der Karte gibt einen 512-Byte-Block an.

• Bit 47 (ganz links) enthält immer den Wert 0.
• Bit 46 enthält immer den Wert 1.
• Die Bits 45..40 enthalten den Befehlsindex.
• Die Bits 39..8 enthalten die Argumente des Befehls.
• Die Bits 7..1 enthalten CRC aus vorherigen Bits.
• Bit 0 enthält immer den Wert 1.

1.2 Initialisierung

1. Warten Sie nach dem Einschalten mindestens 1 ms.
2. Generieren Sie mindestens 74 Taktschaltungen für die Karte. CS- und MOSI-Leitungen müssen sich im Status der logischen Einheit befinden.
3. Generieren Sie den Befehl CMD0. Der Befehl CMD0 setzt die SD-Karte zurück.
4. CMD0. R1. , R1 16 , 3. R1 , 0x01 ( ), 3, 5.
5. CMD8. .
6. CMD8. R7. , , , 7, , , 17, 13.
7. CMD55. CMD55 , .
8. CMD55. R1. 0x01 ( ), 7, 9.
9. ACMD41. ACMD41 , SDSC ( 0x00000000) .
10. ACMD41. R1. , , 11. , 0x00 ( ) 14, 7.
11. CMD1. CMD1 ACMD41.
12. CMD1. R1. , , 13, , 0x00 ( ), 14, 11.
13. . , . .
14. CMD16. , 512 .
15. CMD16. R1. , 0x00 ( ) 16, 13.
16. . . .
17. CMD55. CMD55 , .
18. CMD55. R1. 0x01 ( ), 17, 19.
19. ACMD41. ACMD41. ACMD41 , SDHC ( 0x40000000) .
20. ACMD41. R1. , , 13. , 0x00 ( ) 21, 17.
21. CMD58. .
22. Warten auf eine Antwort auf den Befehl CMD58. Die Antwort ist eine Antwort vom Typ R3. Wenn in der Antwort, dass die Karte mit Blockadressen von 512 Bytes arbeitet, ein Bit gesetzt ist, fahren Sie mit Schritt 16 fort, andernfalls mit Schritt 14.

Grafischer Algorithmus

1.3 Informationen löschen

1. CMD32. .
2. CMD32. R1. 0x00 ( - ), 3, 4.
3. . , .
4. CMD33. . , CMD32.
5. CMD33. R1. 0x00 ( - ), 3, 6
6. CMD38-Befehl senden. Der Befehl zum Löschen von Informationen aus den ausgewählten Blöcken. Alle 4 Bytes sollten als Argument gesendet werden, mit Ausnahme der Werte 0x00000001, 0x00000002.
7. Warten auf eine Antwort auf den CMD38-Befehl. Die Antwort ist eine Antwort vom Typ R1b. Dies ist eine erweiterte Version der Antwort, wenn die Karte eine R1-Antwort generiert und dann die MISO-Linie auf Null zieht, was anzeigt, dass der Chip beschäftigt ist. Es muss gewartet werden, bis der Einheitswert in der MISO-Zeile angezeigt wird. Wenn die Antwort nicht 0x00 lautet (beim Ausführen des Befehls ist ein Fehler aufgetreten), fahren Sie mit Schritt 3 fort, andernfalls mit Schritt 8
8. Vervollständigung des Löschalgorithmus.

Grafischer Algorithmus

1.4 Informationen lesen

1.4.1 Einen einzelnen Datenblock lesen

1.4.2 Mehrere Datenblöcke lesen

• Daten-Token Der Lesebefehl verwendet den Wert 0xFE.
• Datenblock. Enthält von der Karte gelesene Daten.
• CRC Enthält die Prüfsumme aus den vorherigen Feldern.

1. CMD18-Befehl senden. Der Befehl teilt der Karte mit, dass mehrere Blöcke gelesen werden.
2. Warten auf eine Antwort auf den CMD18-Befehl. Die Antwort ist eine Antwort vom Typ R1. Wenn die Antwort nicht 0x00 lautet (beim Ausführen des Befehls ist ein Fehler aufgetreten), fahren Sie mit Schritt 3 fort, andernfalls mit Schritt 4.
3. Fehlerstatus. Lesen fehlgeschlagen, Beenden des Lesealgorithmus.
4. Warten auf einen Token von der Karte. Wenn ein Fehler-Token von der Karte empfangen wird, fahren Sie mit Schritt 3 fort, andernfalls fahren Sie mit Schritt 5 fort.
5. Empfangen von einer Datenblockkarte mit einer Größe von 512 Bytes.
6. Empfangen Sie von der Karte eine CRC-Feldgröße von 2 Bytes.
7. . , 8, 4.
8. CMD12. . , Data Packet, .
9. CMD12. R1b. R1, MISO , . MISO , . 0x00 ( - ), 3, 10.
10. .

Grafischer Algorithmus

1.5 Informationen aufzeichnen

1.5.1 Einen einzelnen Datenblock schreiben

1.5.2 Mehrere Datenblöcke schreiben

• Daten-Token Für den Schreibbefehl wird der Wert 0xFC verwendet.
• Datenblock. Enthält auf die Karte geschriebene Daten.
• CRC Enthält die Prüfsumme aus den vorherigen Feldern.

• CMD25-Befehl senden. Der Befehl teilt der Karte mit, dass mehrere Blöcke geschrieben werden.
• CMD25. R1. 0x00 ( - ), 3, 4.
• . , .
• .
• 512 .
• CRC 2 .
• Data Response . , 3, 8.
• . , 9, 4.
• Stop Tran Token. , .
• Warten auf eine Antwort von der Karte. Die Karte auf Stop Tran Token zieht die MISO-Linie auf Null, was anzeigt, dass die Karte besetzt ist. Es ist notwendig, in der MISO-Zeile auf den Einheitswert zu warten, der das Ende des Befehls anzeigt
• Der Abschluss des Aufzeichnungsalgorithmus.

Grafischer Algorithmus

2. Implementierung des Algorithmus in Hardware

• Anfängliche Frequenzbildung. CS- und MOSI-Leitungen müssen sich im Status der logischen Einheit befinden.
• Daten auf eine SD-Karte übertragen.
• Empfangen Sie Daten von einer SD-Karte.
• Warten auf die Fertigstellung des Teams. Es wird verwendet, wenn die SD-Karte nach dem Generieren einer Antwort die MISO-Linie auf Null zieht, um auf das Erscheinen einer Einheit zu warten.
• Antwort beim Schreiben von Daten lesen.
• Warten auf ein Token beim Lesen von Daten.

• Taktsignal zum Initialisieren.
• Taktsignal für die Arbeit.

• Die Komponente der physikalischen Schicht, die direkt mit der SD-Karte verbunden ist, erzeugt SCLK-, CS-, DI-Signale und liest mit DO.
• Eine Komponente auf Befehlsebene, die alle Daten für eine Komponente in der physischen Schicht vorbereitet.
• Eine Komponente der Kommunikation mit der Außenwelt, die das gesamte interne Gerät verbirgt und eine Schnittstelle für Befehle (Lesen, Schreiben, Löschen) und Daten bietet.

2.1 Komponente der physikalischen Schicht

entity SDPhy is
	generic	(	gTCQ		: time := 2 ns );
	port	(	-- Control bus
			iPhyTxData	: in	std_logic_vector( 9 downto 0);
			iPhyMode	: in	std_logic_vector( 4 downto 0);
			iPhyTxWrite	: in	std_logic;
			oPhyTxReady	: out	std_logic; 
			-- Out Data
			oPhyRxData	: out	std_logic_vector( 7 downto 0); 
			oPhyRxWrite	: out	std_logic;
			oPhyCmdEnd	: out	std_logic;
			-- Spi
			oSdCS		: out	std_logic;
			oSdClk		: out	std_logic;
			oSdMosi		: out	std_logic;
			oSdMosiT	: out	std_logic;
			iSdMiso		: in	std_logic;
			-- system
			sclk		: in	std_logic;
			pclk		: in	std_logic;
			rst		: in	std_logic ); 
end SDPhy;

• iPhyTxData , iPhyMode , .
• iPhyTxWrite , iPhyTxData iPhyMode .
• oPhyTxReady , . FULL FIFO, .
• oPhyRxData , SD-.
• oPhyRxWrite , oPhyRxData .
• oPhyCmdEnd , .
• oSdCS (CS) SD-.
• oSdClk SD-.
• oSdMosi SD-.
• oSdMosiT SD-.
• iSdMiso SD-.
• sclk SD- (50 ).
• pclk , .
• Erstes Rücksetzsignal, aktive Stufe eins.

• Der SDummy-Zustand bietet eine anfängliche Frequenzformung und 128 Umschaltung.
• Der STxBits-Status ermöglicht die Datenübertragung auf die SD-Karte.

• Der Status sRxBits ermöglicht den Datenempfang von der SD-Karte.
• Der Status sBusy stellt sicher, dass die SD-Karte bereit ist (die Karte gibt die MISO-Leitung auf Einheitenebene frei).
• Der sResp-Status implementiert das Lesen der Antwort beim Schreiben von Daten.
• Der sToken-Status implementiert eine Token-Wartezeit beim Lesen von Daten.

2.2 Komponente auf Befehlsebene

entity SdCommand is
	generic	(	gTCQ		: time := 2 ns );
	port	(	-- Command from host
			oSdInitComp	: out	std_logic;
			oSdInitFail	: out	std_logic;
			iSdAddress	: in	std_logic_vector(31 downto 0);
			iSdStartErase	: in	std_logic;
			iSdStartRead	: in	std_logic;
			iSdStartWrite	: in	std_logic;
			oSdCmdFinish	: out	std_logic_vector( 1 downto 0);
			oSdhcPresent	: out	std_logic;
			-- Data
			oSdReadData	: out	std_logic;
			iSdDataR	: in	std_logic_vector(31 downto 0);
			oSdWriteData	: out	std_logic;
			oSdDataW	: out	std_logic_vector(32 downto 0);
			-- Spi
			oSdCS		: out	std_logic;
			oSdClk		: out	std_logic;
			oSdMosi		: out	std_logic;
			oSdMosiT	: out	std_logic;
			iSdMiso		: in	std_logic;
			-- system
			pclk		: in	std_logic;
			sclk		: in	std_logic;
			rst		: in	std_logic );

• oSdInitComp signiert Abschluss der Initialisierung der SD-Karte.
• oSdInitFail Zeichen eines Initialisierungsfehlers.
• iSdAddress-Adresse auf der SD-Karte, um den Befehl auszuführen.
• iSdStartErase Start Löschbefehlsausführung.
• iSdStartRead beginnt mit dem Lesen der Befehlsausführung.
• iSdStartWrite startet die Ausführung des Schreibbefehls.
• Abschlussstatus des oSdCmdFinish-Teams. Das Nullbit ist gleich Eins, der Befehl wurde erfolgreich ausgeführt. Das erste Bit ist eins, der Befehl wurde mit einem Fehler abgeschlossen.
• oSdhcPresent SDHC / SDXC-Kartenerkennungsflag.
• oSdReadData Liest Daten, um auf die SD-Karte zu schreiben.
• iSdDataR-Daten zum Schreiben auf die SD-Karte.
• oSdWriteData-Flag zum Schreiben von Daten, die von der SD-Karte gelesen wurden.
• oSdDataW-Daten, die von einer SD-Karte gelesen wurden.

• smSdInit ( github ) - Initialisierung der SD-Karte.
• smSdErase ( github ) - löscht Daten von einer SD-Karte.
• smSdRead ( github ) - liest Daten von einer SD-Karte.
• smSdWrite ( github ) - Daten auf eine SD-Karte schreiben.
• smSdCommand ( github ) - bereitet auf der Grundlage der generierten Features Daten für die physische Schicht aller vorherigen Maschinen auf.

2.3 Bestandteil der Kommunikation mit der Außenwelt

entity SdHost is
	generic	(	gTCQ		: time := 2 ns );
	port	(	-- Sd Host command
			iSdCommand	: in	std_logic_vector( 2 downto 0);
			iSdAddress	: in	std_logic_vector(31 downto 0);
			iSdStart	: in	std_logic;
			oSdStatus	: out	std_logic_vector( 1 downto 0);
			oSdInitFail	: out	std_logic;
			-- Write data to card
			iSdTxData	: in	std_logic_vector(31 downto 0);
			iSdTxValid	: in	std_logic;
			iSdTxLast	: in	std_logic;
			oSdTxReady	: out	std_logic;
			-- Read data from card
			oSdRxData	: out	std_logic_vector(31 downto 0);
			oSdRxValid	: out	std_logic;
			oSdRxLast	: out	std_logic;
			iSdRxReady	: in	std_logic;
			-- Spi
			oSdCS		: out	std_logic;
			oSdClk		: out	std_logic;
			oSdMosi		: out	std_logic;
			oSdMosiT	: out	std_logic;
			iSdMiso		: in	std_logic;
			-- system
			pclk		: in	std_logic;
			sclk		: in	std_logic;
			rst		: in	std_logic );

• auszuführender iSdCommand-Befehlscode.
• iSdAddress ist die Adresse, an der der Befehl ausgeführt werden soll.
• iSdStart Startbefehlsausführung.
• Abschlussstatus des oSdStatus-Teams. Das Nullbit ist gleich Eins - der Befehl ist abgeschlossen. Das erste Bit ist eins - der Befehl wurde mit einem Fehler abgeschlossen.
• oSdInitFail Zeichen eines Initialisierungsfehlers.
• iSdTxData. Axi-Stream-Schnittstelle zum Schreiben von Daten auf eine SD-Karte. Port mit Daten.
• iSdTxValid. Axi-Stream-Schnittstelle zum Schreiben von Daten auf eine SD-Karte. Port mit einem Schreibsignal.
• iSdTxLast. Axi-Stream-Schnittstelle zum Schreiben von Daten auf eine SD-Karte. Port mit einem Zeichen des letzten Dw in den Daten.
• oSdTxReady. Axi-Stream-Schnittstelle zum Schreiben von Daten auf eine SD-Karte. Port mit einem Zeichen der Bereitschaft zum Empfang von Daten.
• oSdRxData. Axi-Stream-Schnittstelle zum Lesen von Daten von einer SD-Karte. Port mit Daten.
• oSdRxValid. Axi-Stream-Schnittstelle zum Lesen von Daten von einer SD-Karte. Port mit einem Schreibsignal.
• oSdRxLast. Axi-Stream-Schnittstelle zum Lesen von Daten von einer SD-Karte. Port mit einem Zeichen des letzten Dw in den Daten.
• iSdRxReady. Axi-Stream-Schnittstelle zum Lesen von Daten von einer SD-Karte. Port mit einem Zeichen der Bereitschaft zum Empfang von Daten.

• Einzelzustand. Warten auf die Initialisierung und den Abschluss des Befehls.
• Der Status von sWaitCmd. Überprüfen des Befehlstyps.
• sReadCmd. FIFO, , SD- .
• sWriteCmd. , FIFO SD-, .
• sEraseCmd. .
• sWaitEnd. .
• sFinish. , .

3.

• Adresse auf SD-Karte einstellen.
• Befehlscode 2 einstellen.
• Schreiben Sie Daten in einen Puffer in der programmierbaren Logik.
• Führen Sie den Befehl aus.
• Warten Sie, bis der Befehl abgeschlossen ist.
• Teamabschlussstatus zurücksetzen.

for (SectorAddress = 0; SectorAddress < 1048576; SectorAddress ++)
{
	if ((SectorAddress % 1024) == 0)
	{
		xil_printf("Data write to %d sector \n\r", SectorAddress);
	}

	/** Set address */
	Xil_Out32(0x43c00008, SectorAddress);

	/** Set command */
	Xil_Out32(0x43c00004, 2);

	/** Write data to PL */
	for (int32_t i = 0; i < 1024; i++)
	{
		Xil_Out32(0x43c00014, cntrData);
		cntrData++;
	}

	/** Start */
	Xil_Out32(0x43c00000, 1);

	/** Wait end of operation */
	for (;;)
	{
		status = Xil_In32(0x43c0000c);
		if (status == 0x01 || status == 0x03)
		{
			if (status == 0x03)
			{
				xil_printf("Error in write \n\r");
			}
			break;
		}
		else
		{
			cntrDuration++;
			usleep(100);
		}
	}

	/** Duration operation */
	durationWrite += cntrDuration;

	if (cntrDuration > MaxWrite )
	{
		MaxWrite = cntrDuration;
	}

	cntrDuration = 0x00;

	/** Clear start */
	Xil_Out32(0x43c00000, 0);

	SectorAddress += 7;
}

• Adresse auf SD-Karte einstellen.
• Befehlscode 1 einstellen.
• Führen Sie den Befehl aus.
• Warten Sie, bis der Befehl abgeschlossen ist.
• Teamabschlussstatus zurücksetzen.
• Lesen Sie Daten aus dem Puffer in programmierbarer Logik.

for (SectorAddress = 0; SectorAddress < 1048576; SectorAddress++)
{
	if ((SectorAddress % 1024) == 0)
	{
		xil_printf("Data read from %d sector \n\r", SectorAddress);
	}

	/** Set address */
	Xil_Out32(0x43c00008, SectorAddress);

	/** Set command */
	Xil_Out32(0x43c00004, 1);

	/** Start */
	Xil_Out32(0x43c00000, 1);

	/** Wait end of operation */
	for (;;)
	{
		status = Xil_In32(0x43c0000c);
		if (status == 0x01 || status == 0x03)
		{
			 if (status == 0x03)
			{
				xil_printf("Error in read \n\r");
			}
			break;
		}
		else
		{
			cntrDuration++;
			usleep(100);
		}
	}

	 /** Duration operation */
	 durationRead += cntrDuration;

	 if (cntrDuration > MaxRead )
	 {
		 MaxRead = cntrDuration;
	 }

	cntrDuration = 0x00;

	/** Clear start */
	Xil_Out32(0x43c00000, 0);

	/** Read data from PL */
	for (int32_t i = 0; i < 1024; i++)
	{
		DataR = Xil_In32(0x43c0001c);
		if (DataR != cntrData)
		{
			xil_printf("Data corrupt! \n\r");
		}
		DataR = Xil_In32(0x43c00020);
		cntrData++;
	}

	SectorAddress += 7;
}

• Adresse auf SD-Karte einstellen.
• Befehlscode einstellen 4.
• Führen Sie den Befehl aus.
• Warten Sie, bis der Befehl abgeschlossen ist.
• Teamabschlussstatus zurücksetzen.

for (SectorAddress = 0; SectorAddress < 1048576; SectorAddress++)
{
	if ((SectorAddress % 1024) == 0)
	{
		xil_printf("Data erase from %d sector \n\r", SectorAddress);
	}

	/** Set address */
	Xil_Out32(0x43c00008, SectorAddress);

	/** Set command */
	Xil_Out32(0x43c00004, 4);

	/** Start */
	Xil_Out32(0x43c00000, 1);

	/** Wait end of operation */
	for (;;)
	{
		status = Xil_In32(0x43c0000c);
		if (status == 0x01 || status == 0x03)
		{
			if (status == 0x03)
			{
				xil_printf("Error in write! \n\r");
			}
			break;
		}
		else
		{
			cntrDuration++;
			usleep(100);
		}
	}

	/** Duration operation */
	durationErase += cntrDuration;

	if (cntrDuration > MaxErase )
	{
		MaxErase = cntrDuration;
	}

	cntrDuration = 0x00;

	/** Clear start */
	Xil_Out32(0x43c00000, 0);

	SectorAddress += 7;
}

4. Ergebnisse