|
| HOME PROJETOS PROGRAMAÇÃO |
Este driver não fornece funções para tratamento de sistemas de arquivos como FAT ou outro qualquer.
Este driver fornece funções básicas de acesso a SD Card ou MicroSD, cuja capacidade não exceda 2GB, usando o módulo SSP/SPI do microcontrolador. Funções básicas, como leitura de um setor, gravação de um setor e apagamento de intervalo de setores e algumas outras funções, como leitura dos registradores OCR, CID e CSD, também são fornecidas. Ver tabela abaixo.
O drive fornece funções que podem ser chamadas através de macros ou com a instrução CALL. A seguir listaremos as funções chamadas com macros.
AS FUNÇÕES ABAIXO SÃO CHAMADAS ATRAVÉS DE MACROS ASSEMBLER
Funções cujos nomes estão em vermelho são de uso interno do driver e não devem ser usadas pelo programador.
Funções cujos nomes estão em azul são de uso geral.
Esta macro de uso geral e, usada para ligar e inicializar o cartão. O endereço do campo de resposta (response) e do campo de argumento de comandos (argument) são fixados na estrutura de dados do drive para serem usados nas chamadas subsequentes de outras funções.
Esta macro, de uso restrito do drive, desabilita o cartão levantando o sinal de seu pino CS.
Note que o pino CS do cartão tem lógica invertida, isto é, o cartão será selecionado quando o pino CS estiver
em nível baixo.
Esta macro não possui parâmetros.
Esta macro, de uso restrito do drive, habilita o cartão abaixando o sinal de seu pino CS.
Note que o pino CS do cartão tem lógica invertida, isto é, o cartão será selecionado quando o pino CS estiver
em nível baixo.
Esta macro não possui parâmetros.
Esta macro, de uso restrito do drive, envia n pulsos de clock ao cartão onde n deve ser múltiplo de 8.
Esta macro, de uso restrito do drive, é usada para carregar a estrutura da dados e chamar a funcão interna "_sd_send_command"
que executará o comando solicitado no parâmetro "cmd". Antes de usar esta função, a macro "SD_CONFIG"
deve ser usada para estabelecer a estrutura de dados a ser usada pelo driver.
Se os parâmetros "response" e "argument" desta macro especificarem endereços diferentes dos endereços
especificados pela macro "SD_CONFIG", então todas as funções subsequentes passarão a usar os novos endereços.
O parâmetro "type" especifica o tipo de resposta esperado pelo comando "cmd" e deve ser um dos
símbolos definidos na estrutura da dados do driver: "r1_type", "r2_type" ou "r3_type".
O parâmetro "crc" informa o CRC para o comando a ser executado.
Esta macro, de uso restrito do drive, empacota o valor especificado em "argval" no campo de argumento do comando, de 4 bytes, que foi
especificado anteriormante pela função "SD_CONFIG".
O parâmetro "type" deve ser "INLINE" se o valor "argval" está escrito
na macro.
O parâmetro "type" deve ser "RG" se o valor "argval" residir num registrador
na RAM.
AS FUNÇÕES ABAIXO SÃO CHAMADAS ATRAVÉS DA INSTRUÇÃO CALL DO ASSEMBLER
Funções cujos nomes estão em vermelho são de uso interno do driver e não devem ser usadas pelo programador.
Funções cujos nomes estão em azul são de uso geral.
Função interna para zerar o campo de argumento.
| Entrada: | Não há |
|---|---|
| Saída: | O campo de argumento (4 bytes) apontado pelo registrador "_sd_argaddr" será zerado. |
Função interna para enviar o argumento do comando ao cartão.
| Entrada: | O campo de argumento (4 bytes) apontado pelo registrador '_sd_argaddr' deve estar preenchido com o valor do argumento a ser enviado. |
|---|---|
| Saída: | Argumento enviado ao cartão. |
Função interna para enviar pulsos de clock ao cartão onde o número de pulsos enviados será sempre múltiplo de 8. Assim, se tentar enviar, por exemplo, 37 pulsos, apenas 32 serão enviados, pois o menor número múltiplo de 8 abaixo de 37 é 32. A macro "sd_delay" pode ser usada para chamar esta funcão.
| Entrada: | W deve conter o número de pulsos. |
|---|---|
| Saída: | Pulsos enviado ao cartão. |
Função interna para aumentar ao máximo a taxa de transmissão da porta SSP/SPI.
| Entrada: | Não há. |
|---|---|
| Saída: | Não há. |
Função interna para diminuir ao máximo a taxa de transmissão da porta SSP/SPI.
| Entrada: | Não há. |
|---|---|
| Saída: | Não há. |
Função interna para inicializar do cartão. Antes de chamar esta função, a macro "SD_CONFIG" deve ser usada para estabelecer a estrutura de dados que será usada durante a vida deste serviço.
| Entrada: | Estrutura de dados preenchida manualmente ou pela macro "SD_CONFIG". |
|---|---|
| Saída: | W=0x00 - Não conseguiu inicializar o cartão. W=0x01 - Cartão inicializado. O endereço apontado por _sd_respadd contem o RespCode no formato R1. |
Função interna para executar o comando CMD55.
| Entrada: | Não há |
|---|---|
| Saída: |
W=b"11111111" - não recebeu resposta do comando W=b"0XXXXXXX" - resposta é uma esperada deste comando |
Função interna para executar o comando ACMD41.
| Entrada: | Não há |
|---|---|
| Saída: |
W=0x00 - resposta é uma esperada deste comando W=0xFF - timeout: não recebeu resposta do comando |
Função interna para aguardar a resposta de um comando.
Esta função espera até que o SD Card envie um byte que represente um
Response Code válido, isto é, um byte com o bit 7 zerado.
| Entrada: | Não há |
|---|---|
| Saída: |
W=b'11111111' - Timeout: nao recebeu resposta do comando. W=b'0XXXXXXX' - OK: A resposta é uma das esperadas pelo comando. |
Função interna para executar um comando.
A macro "sd_send_command" pode ser usada para preencher os parâmetros da estrutura de dados.
|
Estrutura de dados da lista de parametros:
_sd_cmdcode res 1 ; SD Card command code
_sd_resptype res 1 ; SD Card response type (r1_type, r2_type ou r3_type)
_sd_crc res 1 ; comand CRC
_sd_respadd res 2 ; (FSRxH:FSRxL) - response buffer address
_sd_argadd res 2 ; (FSRxH:FSRxL) - argument buffer address
_sd_ioaddr res 2 ; (FSRxH:FSRxL) - I/O buffer address (512 bytes);
|
| Entrada: | A estrutura de dados com os parâmetros deve estar preenchida corretamente. |
|---|---|
| Saída: |
W==0x00 - Erro, o comando nao foi executado. W==0x01 - O comando foi executado e o endereço apontado por "_sd_respadd" contem o Response Code no formato R1, R2 ou R3, dependendo do comando executado. |
Função de uso geral para especificar o tamanho do setor, embora isso não seja necessário porque o setor tem sempre 512 bytes.
| Entrada: | O argumento, apontado pelo registrador _sd_argadd deve estar preenchido com o tamanho do setor. |
|---|---|
| Saída: | W=0x00 - Erro W=0x01 - OK |
Função de uso geral para ler o registrador OCR.
| Entrada: | Não há |
|---|---|
| Saída: |
W=0x01 - OCR lido corretamente. Os bytes de 2 a 5 do response code conterão os 32 bits do OCR. W!=0x01 - Erro, não foi possível ler o OCR. |
Função de uso geral para ler o registrador CSD.
| Entrada: | O registrador FSR0 deve apontar para um buffer receptor de 16 bytes na RAM. |
|---|---|
| Saída: |
W=0x00 - Erro no comando CMD9. W=0x01 - CSD lido corretamente. Neste caso, o buffer de 16 byes, apontado por FSR0 na entrada da função, conterá os 16 bytes do CSD. |
Função de uso geral para ler o registrador CID.
| Entrada: | O registrador FSR0 deve apontar para um buffer receptor de 16 bytes na RAM. |
|---|---|
| Saída: |
W=0x00 - Erro no comando CMD10. W=0x01 - CID lido corretamente. Neste caso, o buffer de 16 byes, apontado por FSR0 na entrada da função, conterá os 16 bytes do CID. |
Função de uso geral para ler um setor completo de 512 bytes.
| Entrada: |
FSR0 deve apontar para um buffer receptor de 512 bytes na RAM. "_sd_sector" deve conter o número do setor a ser lido. "_sd_realadd" deve conter o endereco real do setor a ser lido. |
|---|---|
| Saída: |
W=0x91 - Erro de leitura. W=0x92 - Não recebeu token 0xFE. W=0x01 - Bloco lido corretamente. Neste caso, o buffer apontado por FSR0 na entrada, conterá 512 bytes do setor lido. "_sd_sector"' será incrementado de 1 (apontará para o próximo setor). "_sd_realadd" conterá o endereço real do próximo setor. |
Função de uso geral para incrementar de uma unidade o número do setor e calcular o endereço real do mesmo.
| Entrada: | _sd_setor (4 bytes) deve conter um número entre zero e o máximo permitido. |
|---|---|
| Saída: |
_sd_sector será incrementado de 1 (apontará para o próximo setor). _sd_realadd conterá o endereço real do próximo setor. |
Função de uso geral para gravar um setor completo de 512 bytes.
| Entrada: | FSR0 aponta para um buffer de dados de 512 bytes na RAM. _sd_sector deve conter o número do setor a ser gravado. _sd_realadd deve conter o endereço real do setor a ser gravado. |
|---|---|
| Saída: |
W=0x01 - _sd_sector será incrementado de 1 (apontara para o próximo setor). _sd_realadd conterá o endereço real do próximo setor. W=0x93 - Erro de gravação. |
Função de uso geral para apagar os setores pertencentes a um intervalo, incluindo o setor inicial e final.
| Entrada: | FSR0 aponta um registrador de 8 bytes na RAM onde: os 4 primeiros bytes (MSB) contêm o endereço real do setor inicial e os 4 últimos bytes (LSB) contêm o endereço real do setor final. |
|---|---|
| Saída: | W=0x01 - Intervalo apagado W=0x71 - Timeout no comando CMD32 W=0x72 - Erro no comando CMD32 W=0x73 - Timeout no comando CMD33 W=0x74 - Erro no comando CMD33 |
Função de uso geral para converter o número do setor, presente em _sd_sector, em endereço real, colocando o resultado em _sd_realadd. Esta função pode ser usada a qualquer momento pelo programador para fazer a conversão de setor a endereço real.
| Entrada: | _sd_setor (4 bytes) deve conter um número entre zero e o máximo permitido para o cartão. |
|---|---|
| Saída: | _sd_realadd conterá o endereço real do próximo setor. _sd_sector permanece inalterado. |
O driver é muito simples de usar, bastando para isso, copiar a estrututa de dados e incluir a biblioteca do driver no programa.
Primeiramente, definimos na RAM alguns registradores:
cmdresp res .6 cmdarg res .4 iblk res .4 fblk res .4 sd_buffer equ 0x300 ; <=== Buffer de leitura e gravação do cartão
Definimos na RAM, a estrutura de dados necessária para funcionamento do driver.
; --------------------------------------------------------------------------- ; Registradores e simbolos para o servico 'spimodfuncs_services.inc' ; --------------------------------------------------------------------------- spi_temp RES 1 ; Stores temporary data, same bank as SSPBUF SSP_PORT EQU PORTC ; Selects the port containing the SSP port (automatically set) SSP_TRIS EQU TRISC ; Selects the tristate register for the SSP port (automatically set) SSP_SDI EQU 4 ; The bit to use for SDI data input (automatically set) SSP_SDO EQU 5 ; The bit to use for SDO data output (automatically set) SSP_SS EQU 2 ; The bit to use for SS chip select (automatically set) SSP_CS EQU 2 ; The bit to use for SS chip select (automatically set) SSP_SCK EQU 3 ; The bit to use for SC data clock (automatically set) SPI_CKE equ 0 ; borda de clock para transmissao de dados SPI_CKP equ 1 ; borda de clock idle state SPI_SMP equ 0 ; ponto do sinal para aquisicao do dado SPI_RATE_DIV equ .64 ; divisor de clock para taxa de transmissao do SPI ;SPI_SDI_INV EQU 7 ; IF DEFINED, specifies if the SDI port is inverted ; --------------------------------------------------------------------------- ; Registradores e simbolos para o servico 'string_services.inc' ; --------------------------------------------------------------------------- str_dlm RES 1 str_reg1 RES 1 str_reg2 RES 1 str_reg3 RES 1 str_reg4 RES 1 str_reg5 RES 1 str_reg6 RES 1 str_ptr RES 1 ; --------------------------------------------------------------------------- ; Registradores e simbolos usados no servico 'dump_services.inc' ; --------------------------------------------------------------------------- #define __OFFSET_FROM_ZERO 1 ; deslocamentos relativos buffH res 1 ; MSB do endereco do buffer de dados buffL res 1 ; LSB do endereco do buffer de dados lineH res 1 ; MSB do endereco da area de traducao lineL res 1 ; LSB do endereco da area de traducao dumplenH res 1 ; MSB da quantidade de bytes do buffer de entrada dumplenL res 1 ; LSB da quantidade de bytes do buffer de entrada dumpoffH res 1 ; MSB do offset dumpoffL res 1 ; LSB do offset dumpwrby res 1 ; bytes por palavra dumpwlrin res 1 ; palavras por linha dumprg1 res 1 ; auxiliar ; --------------------------------------------------------------------------- ; Registradores e simbolos usados no servico 'sd_driver.inc' ; --------------------------------------------------------------------------- #define _SPI_HIGH_SPEED 1 ; Para SPI em alta velocidade #define _SD_PORT_SUPPLY_VOLTAGE_ 1 ; Para limentar o chip pela porta do PIC #define SDCMD_LED_INDICATOR 1 ; Para gerar LED indicador de comando ; #define SDPOWERTRIS TRISA ; I/O do pino de alimentacao do SD Card #define SDPOWERPORT LATA ; Porta do pino de alimentacao do SD Card #define SDPOWERPIN 0 ; Pino de alimentacao do SD Card #define SDCMDLEDTRIS TRISB ; I/O para LED indicador de comando #define SDCMDLEDPORT LATB ; Porta para LED indicador de comando #define SDCMDLEDPIN 1 ; Pino para LED indicador de comando _sd_rc res 1 ; return code _sd_retry res 1 ; retry _sd_temp1 res 1 ; auxiliar _sd_temp2 res 1 ; auxiliar _sd_temp3 res 1 ; auxiliar _sd_sector res 4 ; numero de setores _sd_realadd res 4 ; endereco real em bytes do setor _sd_cmdcode res 1 ; SD Card command code _sd_resptype res 1 ; SD Card response type _sd_crc res 1 ; comand CRC _sd_respadd res 2 ; (FSRxH:FSRxL) - response buffer address _sd_argadd res 2 ; (FSRxH:FSRxL) - argument buffer address _sd_ioaddr res 2 ; (FSRxH:FSRxL) - I/O buffer address (512 bytes)
Agora configuramos o cartão:
SD_CONFIG cmdresp, cmdarg ; liga e configura o cartão xorlw 0x01 ; RC==0x01??? btfss STATUS, Z ; SIM -- goto erro ; rotina de erro
Vamos ler o registrador OCR do cartão. O resultado da leitura será colocado nos bytes 2 a 5 de cmdresp.
call sd_ocrget ; le OCR xorlw 0x01 ; RC==0x01??? btfss STATUS, Z ; SIM -- goto erro ; rotina de erro
Leremos agora o registrador CID. O resultado da leitura será colocado na localização da RAM apontada pelo registrador FSR0.
lfsr FSR0, sd_buffer ; aponta para o buffer de leitura call sd_cidget ; le CID xorlw 0x01 ; RC==0x01??? btfss STATUS, Z ; SIM -- goto erro ; rotina de erro
Fazemos o mesmo para ler o registrador CSD. O resultado da leitura será colocado na localização da RAM apontada pelo registrador FSR0.
lfsr FSR0, sd_buffer ; aponta para o buffer de leitura call sd_csdget ; le CSD xorlw 0x01 ; RC==0x01??? btfss STATUS, Z ; SIM -- goto erro ; rotina de erro
Lendo o setor número 100 do cartão. O resultado da leitura será colocado na localização da RAM apontada pelo registrador FSR0. Antes lermos um setor devemos posicionar o driver no setor desejado e, a seguir, carregar o endereço real do setor chamando a função call sd_setrealadd. Após uma leitura, o número do setor será automaticamente incrementado de uma unidade assim, para ler o próximo setor, basta chamar a função sd_read novamente, não esquecendo de apontar para o início do buffer de leitura.
; Posicionamos no setor desejado clrf _sd_sector+.0 ; _sd_sector+.0 faz parte da estrutura de dados do driver clrf _sd_sector+.1 ; _sd_sector+.1 faz parte da estrutura de dados do driver clrf _sd_sector+.2 ; _sd_sector+.2 faz parte da estrutura de dados do driver movlw .100 ; setor 100 movwf _sd_sector+.3 ; _sd_sector+.3 faz parte da estrutura de dados do driver ; Carregamos o endereço real do setor na estrutura de dados call sd_setrealadd ; calculamos o endereco real do setor a ser lido ; Lemos o setor posicionado lfsr FSR0, sd_buffer ; buffer contera os dados lidos (512 bytes) call sd_read ; leitura do setor ; Verificamos o retorno xorlw 0x01 ; RC==0x01??? btfss STATUS, Z ; SIM -- goto erro ; rotina de erro
Voltar ao inícioPara testar o comportamento do driver, foi desenvolvido um projeto que pode ser obtido no link sdcard_driver.zip.
Baixe o arquivo "sdcard_driver.zip" e o descompacte no seu HD. Esse arquivo contem o projeto completo, desenvolvido no
.
Ao descompactar o arquivo, será gerada pasta "sdcard_driver" no seu HD. Entre nessa pasta e clique duas vezes no arquivo
"sd_driver.mcp" para abrir o projeto no .
Abra o arquivo "sddrvdev.asm", cujo trecho mais importante esta reproduzido na listagem abaixo.
|
MAIN CODE
#include "includes\math_services.inc" ; operacoes aritmeticas
#include "includes\terminal_services.inc" ; comunicacao com hyperterminal
#include "includes\string_services.inc" ; tratamento de strings
#include "includes\hextostr_services.inc" ; conversao hexadecimal para exibicao em caracter
#include "includes\dump_services.inc" ; funcao de dump na tela do terminal
#include "includes\sd_driver.inc" ; driver do SD Card
inicio movlw 0x0F ; mascara para selecao de I/O ports
movwf ADCON1 ; todas as portas sao I/O digital
DLMSET 0x0D ; especifica delimitador de strings (ENTER)
TERM_CONFIG .9600, .20000000, "A", "N", "C" ; configuracao da USART para usar hyperterminal
TERM_CLEAR ; limpa a tela do terminal
TERM_STR "DRIVER PARA SD CARD USANDO MODO DE ACESSO SPI", nl ; display inicial
kbdget TERM_PUTCHAR ">" ; prompt no terminal
TERM_READ ser_buff, SL ; le o teclado do terminal
TERM_NL ; nova linha no terminal
#include "includes\cmd_cidget.inc" ; Leitura do registrador CID
#include "includes\cmd_csdget.inc" ; Leitura do registrador CSD
#include "includes\cmd_erase.inc" ; Apaga um intervalo de setores
#include "includes\cmd_help.inc" ; Mostra help na tela do terminal
#include "includes\cmd_k.inc" ; Apaga a tela do terminal
#include "includes\cmd_ocrget.inc" ; Leitura do registrador OCR
#include "includes\cmd_offline.inc" ; Desabilita o desliga o SD Card
#include "includes\cmd_online.inc" ; Inicializa o SD Card
#include "includes\cmd_readblock.inc" ; Le um setor e mostra um dump na tela do terminal
#include "includes\cmd_setsector.inc" ; Posicioa num setor - ssnnn...n onde n e' o numero do setor
#include "includes\cmd_write.inc" ; Grava um setor com valor pre determinado na compilacao
#include "includes\cmd_writemany.inc" ; Grava N setores com valor pre determinado na compilacao
TERM_STR "CMD Invalido", nl ; o comando digitado nao existe
goto kbdget ; continua lendo o teclado...
|
O programa foi desenvolvido para podermos observar o comportamento do driver no Hyperterminal do Windows ou no Picocom do Linux. Para essa comunicação funcionar, será necessário um circuito de interface entre o PIC e o PC que pode ser construido com informações da página /circuitos/pc2pic/" target="_blank" style="font-size:14px">COMUNICAÇÃO PIC-PC deste site.
Para facilitar o desenvolvimento, seguindo algumas normas de construção de códigos robustos, o programa foi particionado em vários arquivos para não tumultuar a visualização e a compreensão do mesmo.
O programa usa serviços de várias bibliotecas desenvolvidas ao longo do tempo, que tem provado facilitar a comunicação com dispositivos externos, tratamentos de dados, operações aritméticas e outras funções. A seguir daremos uma breve passada por elas, explicando algumas funções.
Notar que, após a linha MAIN CODE, vários arquivos são incluidos no programa. Esses arquivos fazem parte de uma
biblioteca de funções e serviços necessários para o funcionamento do programa. por exemplo, para usar o terminal do PC e operar
o seu teclado, é necessária a inclusão do arquivo "terminal_services.inc" que contem as funções vistas logo abaixo como,
por exemplo,
TERM_CONFIG .9600, .20000000, "A", "N", "C",
que configura USART do microcontrolador para poder operar a sessão de terminal do PC.
A função "TERM_CLEAR" apaga a tela do terminal e a função "TERM_STR "xxxxxx", nl"
envia a string de mensagem "xxxxxx" ao terminal e, em seguida, vai para a linha seguinte.
Todas as outras funções iniciadas por "TERM_" também fazem parte desse arquivo.
Outro serviço importante é o do arquivo "string_services.inc" que oferece funções para tratamento de strings em programas assembler. Uma das funções desse serviço, observadas na listagem, é "DLMSET 0x0D", que especifica um carater usado para indicar fim de uma string. Exemplos de outras funções de tratamento de strings, como "SUBSTRI", "CLI" e "COPYSTR" podem ser vistos nos arquivos "cmd_cidget.inc", ",cmd_csdget.inc", "cmd_erase.inc" e outros com prefixo "cmd_" que se encontram na pasta "includes/". Mais informações sobre outras funções de strings podem ser obtidas nos comentários do arquivo "includes/string_services.inc".
O serviço "dump_services.inc" fornece função de dump na tela do terminal para mostrar setores de dados em formato hexadecimal.
O serviço "math_services.inc" fornece funções aritméticas de 32 bits como soma, subtração, multiplicação, divisão e conversões de binário a decimal e decimal a binário. Para saber mais sobre funções aritméticas de 32 bits, abra o arquivo "math_services.inc" e leia a documentação sob forma de comentários feitos no próprio fonte.
Todos os arquivos prefixados com "cmd_" tratam de comandos a serem enviados para o driver do SD Card. A função "TERM_READ sd_buffer, SL" le o teclado do terminal esperando que um comando válido seja digidato. Ao receber um Enter, essa função passa o controle para o código do primeiro arquivo com"cmd_" da lista de inclusões e, a partir daí, se o código de um desses arquivos perceber que o comando é endereçado a si, o comando será tratado e enviado ao SD Card através de funções definidas no arquivo "sd_driver.in". Abaixo temos uma tabela com os comandos aceitos no terminal.
| COMANDO | F u n ç ã o |
|---|---|
| e X,Y | Comando erase apaga todos os setores dentro do intervalo especificado por X e Y, inclusive. |
| h | Comando help mostra lista de comandos na tela do terminal. |
| k | Apaga a tela do terminal. |
| off | Desliga o cartão. |
| on | Liga e inicializa o cartão. |
| ocr | Mostra o registrador OCR. |
| cid | Mostra o registrador CID. |
| csd | Mostra o registrador CSD. |
| ssN | Posiciona o driver no setor N, onde N é o número do setor em decimal. |
| r | Le o setor posicionado pelo comando ssN e mostra um dump na tela do terminal. |
| w | Grava o setor posicionado pelo comando ssN. |
| wm | Grava 100 setores a partir daquele posicionado pelo comando ssN. |
Os comandos "w" e "wm" gravam strings definidas pela função "COPYSTR" dentro dos arquivos "cmd_write.inc" e "cmd_writemany.inc" respectivamente. Se desejar mudar as string, basta editar esses arquivos e recompilar o projeto.
O programa usa uma estrutura de dados que pode ser verificada no arquivo fonte "sd_driver.inc".
O programa de teste permite visualizar o comportamento do driver no Hyperterminal do Windows. Siga os seguintes passos para rodar o programa de teste:
 |
A figura ao lado mostra a mensagem que deverá aparecer na tela logo após o circuito ser ligado. |
 |
A primeira coisa a ser feita é dar o comando on para ligar e inicializar o cartão. A figura ao lado mostra o comando on e a resposta enviada pelo cartão. Se tudo correr bem, o driver retorna 0x01 no registrador W porém, o verdadeiro response code do cartão estará no primeiro byte do campo de resposta (6 bytes) especificado pelo segundo parâmetro da função SD_CONFIG. |
 |
Já com o cartão inicializado, a figura ao lado mostra a leitura do registrador OCR. Notar que, de cartão para cartão, nem sempre a mensagem "Power On Completed" aparece mas o cartão funciona perfeitamente. |
 |
Ao lado, leitura do registrador CID com algumas informações traduzidas. |
 |
A figura ao lado mostra o posicionamento do driver no setor 100 feito com o comando "ss100" e, logo após, um comando "r" faz a leitura do setor posicionado. Devemos observar que o número do setor 100 (0x00000064), foi convertido no endereço real 0x0000C800 que será usado pelo driver para acessar esse setor. Notar, ainda, que os dados do setor lido foram colocados no endereço 0x300 da RAM (RAM ADDRESS: 0x300) e esse setor está completamente zerado. A listagem foi produzida pelo serviço de dump. A coluna do lado esquerdo da listagem mostra os deslocamentos (+0000 a +01F0) dentro do buffer de leitura que reside no endereço 0x300 da RAM. Do lado direito da listagem, os pontinhos indicam que não há tradução para essa linha. . |
 |
Ao lado, o comando "ss100" posiciona no setor 100 e, logo a seguir, o comando "w" grava alguns dados nesse setor. Em seguida temos um comando "r" que lista o setor 100 recém gravado. Devemos observar que o número do setor 100 (0x00000064), foi convertido no endereço real 0x0000C800 que será usado pelo driver para acessar esse setor. Notar, ainda, que os dados do setor lido foram colocados no endereço 0x300 da RAM (RAM ADDRESS: 0x300) e esse setor contem os dados gravados pelo comando "w". A listagem foi produzida pelo serviço de dump. A coluna do lado esquerdo da listagem mostra os deslocamentos (+0000 a +01F0) dentro do buffer de leitura que reside no endereço 0x300 da RAM. Do lado direito da listagem aparece atradução dos caracteres ASCII, onde é possivel, e apenas pontos onde não há tradução. |
 |
Na figura ao lado, o comando "e 100,100" é usado para apagar o setor 100. O comando "e" apaga um intervalo de setores, inclusive os setores informados no comando. Como foi informado setor inicial 100 e setor final 100, apenas o setor 100 foi apagado. A seguir, o comando "r" mostra a listagem do setor 100, comprovando seu apagamento. |
Para mais detalhes SD Cards, consulte:
|
H P S P I N Desde 04 de Março de 2010 Atualização: 27 de Jul de 2024 |
|