Este projeto explica como fazer a interface do cartão SD com um microcontrolador AVR. Neste projeto, utilizamos um microcontrolador ATMEGA16. O microcontrolador funciona com fonte de alimentação de 5 V com frequência de cristal integrada de 8 MHz. Um cartão SDSC de 2 GB da Transcend, mas o código funcionará com a maioria dos cartões SD. O cartão SD está formatado com FAT32. O objetivo final deste projeto é ler um arquivo do sistema de arquivos FAT32 do cartão SD.
O cartão SD foi formatado como FAT32 antes da interface. O código generalizado para o FAT32 é escrito para fazer interface com o cartão SD. Explicações sobre o sistema de arquivos FAT32 e como acessar os arquivos desse sistema de arquivos são explicadas neste projeto.
A seção a seguir explica o funcionamento do cartão SD em detalhes.
CARTÃO SD
O cartão SD consiste em duas seções básicas de semicondutores, uma 'núcleo de memória' e um 'Controlador de cartão SD'.
O 'núcleo de memória' é a região da memória flash onde os dados reais do arquivo são salvos. Quando formatarmos o cartão SD, um sistema de arquivos será gravado nesta região. Portanto, esta é a região onde existe o sistema de arquivos.
O 'controlador de cartão SD' ajuda a comunicar o 'núcleo de memória' com dispositivos externos como microcontroladores. Ele pode responder a determinados conjuntos de comandos SD padrão e ler ou gravar dados do núcleo da memória para o dispositivo externo.
A capacidade do ‘núcleo de memória’ é referida como o tamanho do cartão SD. Além do 'núcleo de memória', existem certos registros associados ao 'controlador de cartão SD'. Esses registros armazenam o status do cartão SD. O conteúdo desses registros é somente leitura.
O cartão SD pode ser conectado ao microcontrolador usando barramento de dados serial. Ele pode se conectar usando 'ônibus SD' ou 'ônibus SPI'. O 'barramento SD' é projetado para alta velocidade, enquanto o barramento SPI pode operar apenas com velocidades muito mais baixas. O microcontrolador pode ler ou gravar dados no núcleo da memória e ler os registradores usando comandos SD padrão enviados por meio desses barramentos seriais.
Neste projeto, a interface do cartão de memória é feita usando o barramento SPI. Certos comandos não estão disponíveis para o modo de interface SPI e também a velocidade será inferior ao modo SD. Mas esse tipo de interface é muito mais simples, especialmente devido ao fato de que a maior parte do microcontrolador possui módulo de hardware SPI integrado.
Esta seção resume que o cartão SD possui um chip controlador interno, uma região central de memória. O controlador interno pode decodificar os comandos, fornecer interface serial enquanto a região do núcleo da memória é onde o sistema de arquivos é implementado.
Com base neste conhecimento, a seção seguinte tenta explicar o conceito da camada funcional do cartão SD.
(cabeçalho = Camadas Funcionais do Cartão SD)
CAMADAS FUNCIONAIS DO CARTÃO SD
A parte interna do cartão SD pode ser explicada com a ajuda do conceito de camada funcional. Basicamente existem três camadas
1) Camada de interface serial
2) Camada de comandos SD
3) Camada do sistema de arquivos
A 'camada de interface serial' e a 'camada de comandos SD' podem ser vistas como residentes dentro do 'controlador SD' e a 'camada do sistema de arquivos' pode ser encontrada dentro do 'núcleo de memória'. Como o objetivo final deste projeto é ler um arquivo do sistema de arquivos FAT32 do cartão SD, é necessário acessar todas as três camadas de forma adequada.
1) CAMADA DE INTERFACE SERIAL
Esta camada fornece interface serial do cartão SD com o microcontrolador. Neste projeto o barramento SPI é utilizado para a interface serial. O diagrama a seguir mostra como fazer a interface de mais de um cartão SD com um microcontrolador.
Neste tipo de interface o microcontrolador é denominado 'Host' e o cartão SD é denominado 'Slave'. O microcontrolador inicia todas as transferências de dados. O relógio também é controlado pelo microcontrolador. O microcontrolador é livre para escolher entre os cartões SD, ativando o respectivo pino CS (Chip Select).
Os dados são transmitidos do microcontrolador para o cartão SD usando o canal MOSI (Master Output Slave Input) e os dados são transferidos do cartão SD para o microcontrolador usando o canal MISO (Master Input Slave Output).
A pinagem de um cartão SD para o modo de interface SPI é mostrada na figura a seguir.
O microcontrolador usado neste projeto funciona com fonte de alimentação de 5V, mas o cartão SD pode suportar apenas até 3,3V. Os níveis lógicos de 5V e 3,3V são diferentes e podem causar problemas. Um dispositivo de nível lógico de 3,3 V pode ler o 0 lógico de um dispositivo de 5 V como lógico 1. Da mesma forma, o dispositivo de nível lógico de 5 V pode ler tanto o 0 lógico quanto o 1 lógico de um dispositivo de nível lógico de 3,3 V apenas como 0 lógico. Este problema pode ser resolvido usando um conversor de nível bidirecional introduzido entre os pinos SPI do microcontrolador e o cartão SD.
O diagrama do circuito para o interface serial de um cartão SD com o microcontrolador incluindo o conversor de nível é mostrado abaixo.
O programador é 'USBasp' que também é um dispositivo SPI. Ele está conectado ao barramento SPI junto com o cartão SD. LM1117 é usado para fornecer energia de 3,3 V ao cartão SD e também ao lado de baixa tensão do conversor de nível. O conversor de nível é um dispositivo de quatro canais com um MOSFET controlando cada canal. Este tipo de conversor de nível é adequado para barramentos SPI, I2C. A imagem do conversor de nível utilizado neste projeto é mostrada abaixo.
A imagem do cartão SD AVR configurado
(cabeçalho = Camada de Comandos SD)
2) CAMADA DE COMANDOS SD
O cartão SD aceita apenas um conjunto de comandos SD padrão. Usando estes comandos, um microcontrolador pode ler os registros do cartão SD e também ler/escrever o 'Memory Core'.
Existem seis registros básicos encontrados nos cartões SD, cujos detalhes são fornecidos na figura a seguir:
Todos os comandos SD suportados no modo SPI têm 6 bytes. O MSB é transmitido primeiro e o comando real ocupa o primeiro byte. O byte de comando é seguido por seus argumentos de 4 bytes. O último byte é o byte CRC correspondente aos bytes de comando e argumento.
A estrutura de um bloco de comando no modo de interface SPI de um cartão SD é mostrada na figura a seguir
O CRC é obrigatório apenas para alguns comandos no modo SPI. O CRC utilizado é o CRC de 7 bits, com polinômio gerador dado por
x7 +x3 + 1
O cálculo da CRC é apresentado abaixo;
G(x) = x7 +x3 + 1
M(x) = (bit inicial) ? x39 + (bit hospedeiro) ? x38 +…+ (último bit antes do CRC) ? x0
CRC (6…0) = Restante ( (M(x) ? x7) / G(x) )
O CRC de 7 bits forma os primeiros sete bits do último byte do comando e o oitavo bit (bit final) deve ser sempre definido como um.
Usando as equações acima e a condição do bit final, o byte CRC para o 0º comando e o 8º comando são calculados como 0x95 e 0x87 respectivamente. Para todos os outros comandos o CRC é ignorado por quase todos os cartões SD.
Os comandos SD padrão, seus argumentos, tipo de resposta e descrição são fornecidos na figura a seguir.
RESPOSTA DE COMANDO
No modo SPI, o cartão SD responde a todos os comandos recebidos usando três tipos básicos de resposta de comando, R1, R2 e R3. Cada bit no bloco de resposta contém alguns detalhes específicos sobre o status do cartão SD.
Resposta – R1
Resposta – R2
Resposta – R3
A resposta R3 está disponível apenas para 58º comando (READ_OCR).
COMANDOS PARA ESCREVER DADOS
Os dados podem ser gravados no 'Memory Core' do cartão SD usando os comandos abaixo seguidos dos dados reais;
WRITE_BLOCK – Grava dados em um único bloco
WRITE_MULTIPLE_BLOCK – Grave dados em vários blocos
WRITE_BLOCK
No cartão SD, um bloco é sempre considerado como locais de memória consecutivos de 512 bytes. Suponha que um bloco a partir de 2000º a localização da memória precisa ser escrita com alguns dados usando o comando WRITE_BLOCK. O pacote de comando deve ser semelhante ao mostrado abaixo;
1st byte (comando) – 0x18
2e para 5º byte (argumento) – 0x000007d0 (Mesmo que não haja argumentos para outros comandos, este campo deve ser definido como zero)
6º byte (CRC) – qualquer valor
Assim que o comando for enviado, o microcontrolador deverá receber a resposta R1. Todos os bits na resposta devem ser zero. Após receber o byte de resposta R1 com valor zero, o microcontrolador pode enviar os dados para serem gravados no cartão SD. O comprimento dos dados deve ser de 512 bytes, mesmo que os dados reais tenham menos bytes.
Os dados de 512 bytes devem ser precedidos por um byte de token de dados e devem terminar com um byte CRC de 16 bits. Estes 1 + 512 + 2 = 515 bytes formam um pacote de dados. O Data Token é um byte com todos os bits, exceto o LSB, definido como 1 (0xFE). O formato do pacote de dados é mostrado abaixo:
Para escrever o próximo bloco de dados o comando WRITE_BLOCK deverá ser enviado novamente.
WRITE_MULTIPLE_BLOCK
O comando WRITE_MULTIPLE_BLOCK difere do WRITE_BLOCK de tal forma que este comando precisa ser enviado apenas uma vez e os seguintes pacotes de dados de 512 bytes serão gravados nos blocos de memória consecutivos.
RESPOSTA DE DADOS
Para cada bloco de dados escrito, o cartão SD envia um byte de resposta ao microcontrolador. O conteúdo do byte de resposta é fornecido da seguinte forma:
(header= Comandos para leitura de dados e inicialização do cartão)
COMANDOS PARA LEITURA DE DADOS
Os dados podem ser lidos do 'Memory Core' do cartão SD usando os comandos abaixo;
READ_SINGLE_BLOCK – Leia dados de um único bloco
READ_MULTIPLE_BLOCK – Leia dados de vários blocos
READ_SINGLE_BLOCK
No cartão SD, um bloco é sempre considerado como locais de memória consecutivos de 512 bytes. Suponha que um bloco a partir de 2000º a localização da memória precisa ser lida usando o comando READ_SINGLE_BLOCK. O pacote de comando deve ser semelhante ao mostrado abaixo;
1st byte (comando) – 0x11
2e para 5º byte (argumento) – 0x000007d0 (Mesmo que não haja argumentos para outros comandos, este campo deve ser definido como zero)
6º byte (CRC) – qualquer valor
Assim que o comando for enviado, o microcontrolador deverá receber a resposta R1. Todos os bits na resposta devem ser zero. Depois de receber o byte de resposta R1 com valor zero, o microcontrolador pode ler os dados do cartão SD. Os dados de 512 bytes serão enviados pelo cartão SD em resposta a cada comando READ_SINGLE_BLOCK.
TOKEN DE DADOS
A leitura de dados de 512 bytes deve ser precedida por um byte de token de dados e deve terminar com um byte CRC de 16 bits. Estes 1 + 512 + 2 = 515 bytes formam um pacote de dados. O Data Token é um byte com todos os bits, exceto o LSB, definido como 1 (0xFE). O formato do pacote de dados é mostrado abaixo:
Caso ocorra algum problema durante o processo de leitura, o microcontrolador receberá apenas um token de erro de dados de byte único. Os bits do token de erro de dados representam o tipo de erro ocorrido. O token de erro de dados é mostrado abaixo:
Para leitura do próximo bloco de dados o comando READ_SINGLE_BLOCK deverá ser enviado novamente.
READ_MULTIPLE_BLOCK
O comando READ_MULTIPLE_BLOCK difere do READ_SINGLE_BLOCK de tal forma que este comando precisa ser enviado apenas uma vez e os locais de memória consecutivos de 512 bytes serão lidos continuamente.
COMANDOS PARA INICIALIZAR O CARTÃO DE MEMÓRIA
Antes que o cartão de memória possa responder a esses comandos, ele deve ser inicializado no modo SPI. Certos comandos devem ser enviados um após o outro para inicializar o cartão SD. O cartão SD estará no modo de interface SD na reinicialização. Portanto, o primeiro comando enviado para o cartão SD deve incluir o byte CRC correto.
As etapas necessárias para inicializar o cartão SD no modo SPI usando comandos são as seguintes:
Assim que o cartão SD for inicializado, podemos começar a usar os comandos de leitura e gravação. Os comandos da camada de comandos SD como READ_SINGLE_BLOCK, READ_MULTIPLE_BLOCK, WRITE_BLOCK etc. são usados principalmente para interagir com a camada do sistema de arquivos.
A seção a seguir explica os recursos do sistema de arquivos FAT32 e mostra como os dados podem ser lidos nessa implementação de sistema de arquivos.
(cabeçalho = camada do sistema de arquivos)
3) CAMADA DO SISTEMA DE ARQUIVOS
Esta seção explica detalhadamente a implementação do sistema de arquivos FAT32 do cartão SD. O sistema de arquivos FAT32 é gravado no 'Memory Core' quando foi formatado. O FAT32 significa File Allocation Table 32, significa que possui uma tabela de alocação de arquivos de 32 bits.
Todos os dados de um arquivo são embaralhados no Memory Core e o FAT (File Allocation Table) mantém a localização do próximo bloco correspondente à localização do bloco atual.
SETORES
O Memory Core possui locais de memória de 8 bits (1 byte). As localizações consecutivas de memória de 8 bits são agrupadas em 'Setores'. Um setor FAT32 geralmente possui 512 bytes por setor. O agrupamento dos bytes de memória para formar Setores é mostrado na figura a seguir.
CONJUNTOS
Os Setores consecutivos são agrupados para formar 'Clusters'. O número de setores por cluster depende do tamanho de todo o sistema de arquivos. O agrupamento dos Setores para formar Clusters é mostrado na figura a seguir.
ARMAZENAMENTO EMBALHADO
Todos os dados de um arquivo são embaralhados no Memory Core como clusters de dados. A figura a seguir mostra como os dados de três arquivos chamados A, B, C são embaralhados no Memory Core. FAT (File Allocation Table) mantém a localização do próximo Cluster correspondente à localização do Cluster atual do arquivo.
FORMATO DE SISTEMA DE ARQUIVOS FAT32
O sistema de arquivos FAT32 é armazenado ou gravado dentro do Memory Core em um formato específico definido. Existem certos setores definidos no início do núcleo de memória que são seguidos por clusters. O formato de um sistema de arquivos FAT32 é mostrado abaixo:
O primeiro setor é o MBR (Master Boot Record), que segue um número significativo de setores não utilizados. Os setores não utilizados são seguidos pelos setores reservados, entre os quais o primeiro setor é o setor BOOT. Os Setores Reservados são seguidos pelos Setores FAT. O número de setores FAT depende do tamanho do sistema de arquivos. Os setores FAT são seguidos por alguns setores ocultos. Os Setores Ocultos são seguidos pelos Clusters.
MBR
O MBR (Master Boot Record) é o primeiro setor do 'Memory Core' e tem como objetivo armazenar as informações sobre as partições dentro do sistema de arquivos. O MBR pode conter detalhes de quatro partições fundamentais. O MBR tem um setor e os bytes importantes do MBR são mostrados abaixo.
Os bytes de informações da partição têm 16 bytes e cada um deles contém informações importantes sobre as partições correspondentes. O último byte do MBR é o byte de assinatura que contém um valor específico (0xAA55 para FAT32) que pode ser usado para verificar se o setor é MBR ou não. O número do primeiro setor de quatro bytes da partição pode ser lido a partir de 8º pouco para 11º bit dos bytes de informações da partição, conforme mostrado abaixo:
SETOR DE INICIALIZAÇÃO
O setor de inicialização é o primeiro setor dentro de uma partição. Este setor contém todos os detalhes valiosos sobre o sistema de arquivos dentro daquela partição específica.
Os primeiros dois bytes são Check Bytes que juntos contêm um valor específico, geralmente 0xE9 ou 0xEB. O 11º e o 12º bytes quando lidos juntos fornecem o número de bytes por setor para o sistema de arquivos. O FAT32 geralmente possui 512 bytes por setor. O 13º byte contém o número de setores por cluster para o sistema de arquivos. O 14º e os 15º os bytes juntos leem o número de setores reservados antes dos FATs, começando no início da partição. O 16º bit contém o valor do número de FATs no sistema de arquivos. Os 4 bytes a partir do 27º byte para 30º byte pode ser lido em conjunto para obter o número de setores ocultos entre os FATs e o primeiro cluster da partição. Os 4 bytes a partir do 43terceiro byte para 46º byte contém o endereço do cluster raiz, que é o primeiro cluster da partição (geralmente 2). O 47º e o 48º bytes podem ser lidos juntos para obter a localização do setor onde as informações do arquivo estão armazenadas (setor de diretório).
SETOR DE INFORMAÇÕES FS
O número do Setor do Setor FS Info é obtido no 47º e 48º byte do setor de inicialização. Ele contém o status atual dos Clusters. Ele pode conter o valor do número total de clusters livres no momento e também o número do cluster do próximo cluster livre dentro do sistema de arquivos, conforme mostrado abaixo:
SETOR DE DIRETÓRIO FS
É o primeiro setor dentro do primeiro cluster do sistema de arquivos. O primeiro Cluster sempre começa com um Cluster número 2. É também o primeiro Setor de Dados da partição. O Diretório FS tem 32 bytes e, portanto, existem 16 Diretórios FS por Setor de Diretório FS. O número do setor do primeiro setor do diretório FS pode ser encontrado usando a seguinte equação:
DIR_SECTOR_NUM = Nº SETORES RESERVADOS + Nº GORDURAS + Nº SETORES OCULTOS
Cada diretório FS contém detalhes significativos sobre um único arquivo, conforme mostrado na figura a seguir:
Os primeiros 11 bytes contêm o nome do arquivo e os 11º byte contém o atributo do arquivo. O atributo byte é usado para verificar um arquivo válido. O conteúdo do byte do atributo é mostrado na figura a seguir:
Os 20º e o 21st byte juntos mantêm os bytes mais altos do número do primeiro cluster do arquivo enquanto os 26º e o 27º byte contém os bytes inferiores do número do primeiro cluster do arquivo. Os últimos quatro bytes contêm o tamanho do arquivo.
A LÓGICA PARA LER UM ARQUIVO DO SISTEMA DE ARQUIVOS FAT32
Um arquivo com um nome específico pode ser lido no sistema de arquivos formatado em FAT32 usando a lógica mostrada abaixo; Dê uma olhada mais de perto e verá que todo processo finalmente termina com uma leitura do Setor. Esta leitura do setor do núcleo de memória do cartão SD pode ser obtida usando o comando READ_SINGLE_BLOCK apenas da camada de comando SD.
(cabeçalho= Usando FAT32)
USANDO O FAT32 (TABELA DE ALOCAÇÃO DE ARQUIVOS 32)
FAT32 são setores nos quais cada 32 bits consecutivos juntos contém o número de clusters. Simplesmente cada 32 bits apontam para um cluster específico. Como um Cluster normalmente possui 512 bytes, haverá 128 ponteiros de Cluster dentro do Setor. Isso forma a Tabela de Alocação de Arquivos 32 FAT32.
O número do próximo ponteiro de Cluster dentro do FAT32 correspondente a um número de Cluster atual pode ser calculado usando a seguinte equação
NÚMERO DO SETOR DE GORDURA PARA O PRÓXIMO PONTEIRO DE CLUSTER = NÚMERO DO PRIMEIRO SETOR DA PARTIÇÃO
+ NÚMERO DE SETORES RESERVADOS
+ ((NÚMERO DO CLUSTER ATUAL * 4)
/BYTES POR SETOR)
A figura a seguir mostra o método de leitura de um arquivo que foi embaralhado no flash 'Memory Core' usando FAT32.
O amarelo indica Clusters que possuem os dados do arquivo específico e os ponteiros de Cluster correspondentes dentro do FAT32. As linhas vermelhas indicam encontrar o próximo ponteiro de Cluster correspondente ao Cluster atual e a linha verde indica encontrar o próximo Cluster usando o número de Cluster armazenado dentro dos ponteiros de Cluster do FAT32.
OS DETALHES DA CODIFICAÇÃO
Como existem três camadas funcionais, nomeadamente camada de interface serial, camada de comandos SD e camada de sistema de arquivos, a codificação também é feita para cada uma das camadas separadamente e depois combinadas. As camadas de código são mostradas na figura a seguir:
O microcontrolador lê e grava dados usando a camada do sistema de arquivos. A camada do sistema de arquivos interage com a camada de comandos SD usando apenas o comando READ_SINGLE_BLOCK. A camada de comandos SD interage com a camada de interface serial usando chamadas de função de transmissão SPI e recepção SPI. Todo o sistema microcontrolador interage com o cartão SD usando a interface de barramento SPI.
Ponteiros de função têm sido usados para a interação eficaz entre diferentes camadas. Estruturas e alocação dinâmica de memória foram usadas para armazenar e acessar 512 bytes de dados de cada vez.