Trabalhe com cartão SD via interface SPI. Implementação de VHDL

Conteúdo

1. Especificações de leitura

1.1 Geral

• a transferência de dados para o cartão SD é realizada em uma linha;
• a leitura de dados de um cartão SD é realizada em uma linha;
• no modo SPI, a energia pode ser apenas + 3,3V;
• freqüência do relógio no modo de inicialização na faixa de 100 a 400 kHz;
• freqüência do relógio após a inicialização - 25 MHz.

• SDSC Capacidade do cartão de até 2 GB, inclusive. O endereço dentro do cartão é byte.
• SDHC. A capacidade do cartão é superior a 2 GB e até 32 GB, inclusive. O endereço dentro do cartão indica um bloco de 512 bytes.
• SDXC. A capacidade do cartão é superior a 32 GB e até 128 TB, inclusive. O endereço dentro do cartão indica um bloco de 512 bytes.

• O bit 47 (mais à esquerda) sempre contém o valor 0.
• O bit 46 sempre contém o valor 1.
• Os bits 45..40 contêm o índice de comando.
• Os bits 39..8 contêm os argumentos do comando.
• Os bits 7..1 contêm CRC dos bits anteriores.
• O bit 0 sempre contém o valor 1.

1.2 Inicialização

1. Depois de ligar a alimentação, aguarde pelo menos 1 ms.
2. Gere no mínimo 74 comutações de clock para o cartão. As linhas CS e MOSI devem estar no estado da unidade lógica.
3. Gere o comando CMD0. O comando CMD0 redefine o cartão 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. Aguardando uma resposta ao comando CMD58. A resposta é uma resposta do tipo R3. Se um bit for definido na resposta de que o cartão funciona com endereços de bloco de 512 bytes, vá para a etapa 16, caso contrário, para a etapa 14.

Algoritmo Gráfico

1.3 Apagando informações

1. CMD32. .
2. CMD32. R1. 0x00 ( - ), 3, 4.
3. . , .
4. CMD33. . , CMD32.
5. CMD33. R1. 0x00 ( - ), 3, 6
6. Enviando o comando CMD38. O comando para apagar informações dos blocos selecionados. Quaisquer 4 bytes devem ser enviados como argumento, exceto para os valores 0x00000001, 0x00000002.
7. Aguardando uma resposta ao comando CMD38. A resposta é uma resposta do tipo R1b. Esta é uma versão estendida da resposta quando o cartão gera uma resposta R1 e, em seguida, desenha a linha MISO para zero, indicando que o chip está ocupado. É necessário aguardar até que o valor da unidade apareça na linha MISO. Se a resposta não for 0x00 (houve algum erro ao executar o comando), vá para a etapa 3, caso contrário, para a etapa 8
8. Conclusão do algoritmo de apagamento.

Algoritmo Gráfico

1.4 Lendo informações

1.4.1 Lendo um único bloco de dados

1.4.2 Lendo vários blocos de dados

• Token de dados O comando read usa o valor 0xFE.
• Bloco de dados. Contém dados lidos no cartão.
• CRC Contenha a soma de verificação dos campos anteriores.

1. Enviando o comando CMD18. O comando informa ao cartão que vários blocos serão lidos.
2. Aguardando uma resposta ao comando CMD18. A resposta é uma resposta do tipo R1. Se a resposta não for 0x00 (houve algum erro ao executar o comando), vá para a etapa 3, caso contrário, para a etapa 4.
3. Status de erro. A leitura falhou, saindo do algoritmo de leitura.
4. À espera de um token do cartão. Se um Cartão de Erro for recebido do cartão, vá para a etapa 3, caso contrário, vá para a etapa 5.
5. Receba de um cartão de bloco de dados com 512 bytes de tamanho.
6. Receba do tamanho do campo CRC do cartão de 2 bytes.
7. . , 8, 4.
8. CMD12. . , Data Packet, .
9. CMD12. R1b. R1, MISO , . MISO , . 0x00 ( - ), 3, 10.
10. .

Algoritmo Gráfico

1.5 Gravando informações

1.5.1 Escrevendo um único bloco de dados

1.5.2 Escrevendo vários blocos de dados

• Token de dados Para o comando write, o valor 0xFC é usado.
• Bloco de dados. Contém dados gravados no cartão.
• CRC Contenha a soma de verificação dos campos anteriores.

• Enviando o comando CMD25. O comando informa ao cartão que vários blocos serão gravados.
• CMD25. R1. 0x00 ( - ), 3, 4.
• . , .
• .
• 512 .
• CRC 2 .
• Data Response . , 3, 8.
• . , 9, 4.
• Stop Tran Token. , .
• Aguardando uma resposta do cartão. O cartão no Stop Tran Token desenha a linha MISO para zero, indicando que o cartão está ocupado. É necessário aguardar na linha MISO o valor da unidade, que indicará o final do comando
• A conclusão do algoritmo de gravação.

Algoritmo Gráfico

2. Implementação do algoritmo em hardware

• Formação inicial de frequências. As linhas CS e MOSI devem estar no estado da unidade lógica.
• Transfira dados para um cartão SD.
• Receba dados de um cartão SD.
• Aguardando a conclusão da equipe. É usado quando, após gerar uma resposta, o cartão SD desenha a linha MISO para zero, a fim de aguardar o aparecimento de uma unidade.
• Leia a resposta ao gravar dados.
• Aguardando um token durante a leitura de dados.

• Sinal de relógio para inicializar.
• Sinal de relógio para o trabalho.

• O componente da camada física, conectado diretamente ao cartão SD, gera sinais SCLK, CS, DI e lê com DO.
• Um componente em nível de comando que prepara todos os dados para um componente na camada física.
• Um componente de comunicação com o mundo externo que oculta todo o dispositivo interno e fornece uma interface para comandos (leitura, gravação, exclusão) e dados.

2.1 Componente da camada física

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 , .
• primeiro sinal de reset, nível um ativo.

• O estado SDummy fornece modelagem de frequência inicial, 128 chaveamento.
• O status do STxBits fornece transferência de dados para o cartão SD.

• O estado sRxBits fornece recepção de dados do cartão SD.
• O estado sBusy garante que o cartão SD esteja pronto (o cartão libera a linha MISO para o nível da unidade).
• O estado sResp implementa a leitura da resposta ao gravar dados.
• O estado sToken implementa uma espera de token durante a leitura de dados.

2.2 Componente em nível de comando

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 assina a conclusão da inicialização do cartão SD.
• oSdInitFail sinal de falha na inicialização.
• Endereço iSdAddress no cartão SD para executar o comando.
• O iSdStartErase inicia a exclusão da execução do comando.
• O iSdStartRead começa a ler a execução do comando.
• iSdStartWrite inicia a execução do comando write.
• oSdCmdFinish o status de conclusão da equipe. O bit zero é igual a um, o comando foi concluído com êxito. O primeiro bit é um, o comando foi concluído com um erro.
• oSdhcPresent Flag de detecção de cartão SDHC / SDXC.
• oSdReadData Leia os dados para gravar no cartão SD.
• Dados iSdDataR para gravar no cartão SD.
• oSdWriteData para gravar dados lidos no cartão SD.
• Dados do SDDataW lidos a partir de um cartão SD.

• smSdInit ( github ) - inicialização do cartão SD.
• smSdErase ( github ) - apaga dados de um cartão SD.
• smSdRead ( github ) - lê dados de um cartão SD.
• smSdWrite ( github ) - grava dados em um cartão SD.
• smSdCommand ( github ) - com base nos recursos gerados, prepara os dados para a camada física de todas as máquinas anteriores.

2.3 Componente da comunicação com o mundo exterior

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

• Código de comando iSdCommand para executar.
• iSdAddress é o endereço para executar o comando.
• O iSdStart inicia a execução do comando.
• Status de conclusão da equipe oSdStatus. O bit zero é igual a um - o comando está concluído. O primeiro bit é um - o comando foi concluído com um erro.
• oSdInitFail sinal de falha na inicialização.
• iSdTxData. Interface Axi-Stream para gravar dados em um cartão SD. Porta com dados.
• iSdTxValid. Interface Axi-Stream para gravar dados em um cartão SD. Porta com um sinal de gravação.
• iSdTxLast. Interface Axi-Stream para gravar dados em um cartão SD. Porta com um sinal da última dw nos dados.
• oSdTxReady. Interface Axi-Stream para gravar dados em um cartão SD. Porta com um sinal de prontidão para receber dados.
• oSdRxData. Interface Axi-Stream para leitura de dados de um cartão SD. Porta com dados.
• oSdRxValid. Interface Axi-Stream para leitura de dados de um cartão SD. Porta com um sinal de gravação.
• oSdRxLast. Interface Axi-Stream para leitura de dados de um cartão SD. Porta com um sinal da última dw nos dados.
• iSdRxReady. Interface Axi-Stream para leitura de dados de um cartão SD. Porta com um sinal de prontidão para receber dados.

• Estado de grupo. Aguardando a inicialização e o comando serem concluídos.
• O estado de sWaitCmd. Verificando o tipo de comando.
• sReadCmd. FIFO, , SD- .
• sWriteCmd. , FIFO SD-, .
• sEraseCmd. .
• sWaitEnd. .
• sFinish. , .

3.

• Defina o endereço no cartão SD.
• Defina o código de comando 2.
• Grave dados em um buffer localizado na lógica programável.
• Execute o comando
• Aguarde até que o comando seja concluído.
• Redefina o status de conclusão da equipe.

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

• Defina o endereço no cartão SD.
• Defina o código de comando 1.
• Execute o comando
• Aguarde até que o comando seja concluído.
• Redefina o status de conclusão da equipe.
• Leia os dados do buffer na lógica programável.

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

• Defina o endereço no cartão SD.
• Defina o código de comando 4.
• Execute o comando
• Aguarde até que o comando seja concluído.
• Redefina o status de conclusão da equipe.

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. Resultados