Fonctionne avec la carte SD via l'interface SPI. Implémentation VHDL

Contenu

1. Spécifications de lecture

1.1 Général

• le transfert de données vers la carte SD s'effectue sur une seule ligne;
• la lecture des données d'une carte SD s'effectue sur une seule ligne;
• en mode SPI, la puissance ne peut être que de + 3,3 V;
• fréquence d'horloge en mode d'initialisation dans la plage de 100 à 400 kHz;
• fréquence d'horloge après l'initialisation - 25 MHz.

• SDSC Capacité de la carte jusqu'à 2 Go inclus. L'adresse à l'intérieur de la carte est un octet.
• SDHC. La capacité de la carte est supérieure à 2 Go et jusqu'à 32 Go inclus. L'adresse à l'intérieur de la carte indique un bloc de 512 octets.
• SDXC. La capacité de la carte est supérieure à 32 Go et jusqu'à 128 To inclus. L'adresse à l'intérieur de la carte indique un bloc de 512 octets.

• Le bit 47 (le plus à gauche) contient toujours la valeur 0.
• Le bit 46 contient toujours la valeur 1.
• Les bits 45 à 40 contiennent l'index de commande.
• Les bits 39..8 contiennent les arguments de la commande.
• Les bits 7..1 contiennent le CRC des bits précédents.
• Le bit 0 contient toujours la valeur 1.

1.2 Initialisation

1. Après la mise sous tension, attendez au moins 1 ms.
2. Générez un minimum de 74 commutations d'horloge pour la carte. Les lignes CS et MOSI doivent être à l'état d'unité logique.
3. Générez la commande CMD0. La commande CMD0 réinitialise la carte SD.
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. En attente d'une réponse à la commande CMD58. La réponse est une réponse de type R3. Si un bit est défini dans la réponse que la carte fonctionne avec des adresses de bloc de 512 octets, passez à l'étape 16, sinon à l'étape 14.

Algorithme graphique

1.3 Effacement des informations

1. CMD32. .
2. CMD32. R1. 0x00 ( - ), 3, 4.
3. . , .
4. CMD33. . , CMD32.
5. CMD33. R1. 0x00 ( - ), 3, 6
6. Envoi de la commande CMD38. La commande pour effacer les informations des blocs sélectionnés. 4 octets doivent être envoyés comme argument, à l'exception des valeurs 0x00000001, 0x00000002.
7. En attente d'une réponse à la commande CMD38. La réponse est une réponse de type R1b. Il s'agit d'une version étendue de la réponse lorsque la carte génère une réponse R1, puis dessine la ligne MISO à zéro, indiquant que la puce est occupée. Il faut attendre que la valeur unitaire apparaisse sur la ligne MISO. Si la réponse n'est pas 0x00 (il y a eu une erreur lors de l'exécution de la commande), passez à l'étape 3, sinon à l'étape 8
8. Achèvement de l'algorithme d'effacement.

Algorithme graphique

1.4 Lecture des informations

1.4.1 Lecture d'un seul bloc de données

1.4.2 Lecture de plusieurs blocs de données

• Jeton de données La commande de lecture utilise la valeur 0xFE.
• Bloc de données. Contient des données lues sur la carte.
• CRC Contient la somme de contrôle des champs précédents.

1. Envoi de la commande CMD18. La commande indique à la carte que plusieurs blocs seront lus.
2. En attente d'une réponse à la commande CMD18. La réponse est une réponse de type R1. Si la réponse n'est pas 0x00 (il y a eu une erreur lors de l'exécution de la commande), passez à l'étape 3, sinon à l'étape 4.
3. Statut d'erreur. La lecture a échoué, en quittant l'algorithme de lecture.
4. En attente d'un jeton de la carte. Si un jeton d'erreur est reçu de la carte, passez à l'étape 3, sinon passez à l'étape 5.
5. Recevez d'une carte de bloc de données une taille de 512 octets.
6. Recevez de la carte un champ CRC de 2 octets.
7. . , 8, 4.
8. CMD12. . , Data Packet, .
9. CMD12. R1b. R1, MISO , . MISO , . 0x00 ( - ), 3, 10.
10. .

Algorithme graphique

1.5 Enregistrement des informations

1.5.1 Écriture d'un seul bloc de données

1.5.2 Écriture de plusieurs blocs de données

• Jeton de données Pour la commande d'écriture, la valeur 0xFC est utilisée.
• Bloc de données. Contient des données écrites sur la carte.
• CRC Contient la somme de contrôle des champs précédents.

• Envoi de la commande CMD25. La commande indique à la carte que plusieurs blocs seront écrits.
• CMD25. R1. 0x00 ( - ), 3, 4.
• . , .
• .
• 512 .
• CRC 2 .
• Data Response . , 3, 8.
• . , 9, 4.
• Stop Tran Token. , .
• En attente d'une réponse de la carte. La carte sur le jeton Stop Tran trace la ligne MISO à zéro, indiquant que la carte est occupée. Il faut attendre sur la ligne MISO la valeur unitaire qui indiquera la fin de la commande
• L'achèvement de l'algorithme d'enregistrement.

Algorithme graphique

2. Implémentation de l'algorithme dans le matériel

• Formation de fréquence initiale. Les lignes CS et MOSI doivent être à l'état d'unité logique.
• Transférez les données sur une carte SD.
• Recevez des données d'une carte SD.
• En attente de l'achèvement de l'équipe. Il est utilisé lorsque, après avoir généré une réponse, la carte SD ramène la ligne MISO à zéro afin d'attendre l'apparition d'une unité.
• Lisez la réponse lors de l'écriture des données.
• Attendre un jeton lors de la lecture des données.

• Signal d'horloge à initialiser.
• Signal d'horloge pour le travail.

• Le composant de la couche physique, qui est connecté directement à la carte SD, génère des signaux SCLK, CS, DI, lit avec DO.
• Un composant de niveau commande qui prépare toutes les données pour un composant de la couche physique.
• Un composant de communication avec le monde extérieur qui cache tout le dispositif interne et fournit une interface pour les commandes (lecture, écriture, effacement) et les données.

2.1 Composante de la couche physique

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 , .
• premier signal de réinitialisation, niveau un actif.

• L'état SDummy fournit une mise en forme de fréquence initiale, 128 commutations.
• Le statut STxBits permet le transfert de données vers la carte SD.

• L'état sRxBits assure la réception des données de la carte SD.
• L'état sBusy garantit que la carte SD est prête (la carte libère la ligne MISO au niveau de l'unité).
• L'état sResp implémente la lecture de la réponse lors de l'écriture de données.
• L'état sToken implémente une attente de jeton lors de la lecture des données.

2.2 Composant de niveau commande

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 signe la fin de l'initialisation de la carte SD.
• Signe oSdInitFail de l'échec de l'initialisation.
• Adresse iSdAddress sur la carte SD pour exécuter la commande.
• iSdStartErase démarre l'exécution de la commande d'effacement.
• iSdStartRead démarre la lecture de l'exécution de la commande.
• iSdStartWrite démarre l'exécution de la commande d'écriture.
• Statut d'achèvement de l'équipe oSdCmdFinish. Le bit zéro est égal à un, la commande s'est terminée avec succès. Le premier bit est un, la commande s'est terminée avec une erreur.
• Indicateur de détection de carte SDHC / SDXC oSdhcPresent.
• oSdReadData Lire les données à écrire sur la carte SD.
• Données iSdDataR pour l'écriture sur la carte SD.
• Drapeau oSdWriteData pour écrire les données lues sur la carte SD.
• Données oSdDataW lues sur une carte SD.

• smSdInit ( github ) - initialisation de la carte SD.
• smSdErase ( github ) - efface les données d'une carte SD.
• smSdRead ( github ) - lire les données d'une carte SD.
• smSdWrite ( github ) - écrire des données sur une carte SD.
• smSdCommand ( github ) - sur la base des fonctionnalités générées prépare les données pour la couche physique de toutes les machines précédentes.

2.3 Composante de communication avec le monde extérieur

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 );

• Code de commande iSdCommand à exécuter.
• iSdAddress est l'adresse pour exécuter la commande.
• Exécution de la commande de démarrage iSdStart.
• Statut d'achèvement de l'équipe oSdStatus. Le bit zéro est égal à un - la commande est terminée. Le premier bit est un - la commande s'est terminée avec une erreur.
• Signe oSdInitFail de l'échec de l'initialisation.
• iSdTxData. Interface Axi-Stream pour écrire des données sur une carte SD. Port avec données.
• iSdTxValid. Interface Axi-Stream pour écrire des données sur une carte SD. Port avec un signal d'écriture.
• iSdTxLast. Interface Axi-Stream pour écrire des données sur une carte SD. Port avec un signe du dernier dw dans les données.
• oSdTxReady. Interface Axi-Stream pour écrire des données sur une carte SD. Port avec un signe de disponibilité pour recevoir des données.
• oSdRxData. Interface Axi-Stream pour lire les données d'une carte SD. Port avec données.
• oSdRxValid. Interface Axi-Stream pour lire les données d'une carte SD. Port avec un signal d'écriture.
• oSdRxLast. Interface Axi-Stream pour lire les données d'une carte SD. Port avec un signe du dernier dw dans les données.
• iSdRxReady. Interface Axi-Stream pour lire les données d'une carte SD. Port avec un signe de disponibilité pour recevoir des données.

• État ralenti. En attente d'initialisation et de fin de commande.
• L'état de sWaitCmd. Vérification du type de commande.
• sReadCmd. FIFO, , SD- .
• sWriteCmd. , FIFO SD-, .
• sEraseCmd. .
• sWaitEnd. .
• sFinish. , .

3.

• Définissez l'adresse sur la carte SD.
• Définissez le code de commande 2.
• Écrivez les données dans un tampon situé en logique programmable.
• Exécutez la commande.
• Attendez la fin de la commande.
• Réinitialiser l'état d'achèvement de l'équipe.

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;
}

• Définissez l'adresse sur la carte SD.
• Définissez le code de commande 1.
• Exécutez la commande.
• Attendez la fin de la commande.
• Réinitialiser l'état d'achèvement de l'équipe.
• Lire les données du tampon en logique programmable.

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;
}

• Définissez l'adresse sur la carte SD.
• Définissez le code de commande 4.
• Exécutez la commande.
• Attendez la fin de la commande.
• Réinitialiser l'état d'achèvement de l'équipe.

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. Résultats