ASM51

Boa tarde amigos do ASM51.
Tenho uma aplicação em campo, rodando perfeitamente com SD Card de até 2Gb. Agora que só encontramos para compra cartões acima de 2Gb, e agora o mais baixo é de 4Gb, não estamos conseguindo fazer funcionar.
Aparentemente, a rotina de inicialização mudou nesse novo formato SDHC. Alguém já passou por essa dificuldade?

O problema e que alguns destes cartoes nem tem mais a spi. Se voce usava spi acredito que nao tenha solucao.

Procura no Mercado livre que ainda tem 1G e 2G.

Se encontrar uma solucao, nao deixe de postar.

É isso mesmo. Atualmente trabalho com cartões de até 2Gb em modo SPI. Hoje estou tentando iniciar o cartão SDHC de 4Gb em SPI e não funciona. Ao enviar o comando CMD0 com CS e "0", ele não responde, envia apenas 0x09h.

Recentemente achei esse link :

http://www.dharmanitech.com/2009/01/sd-card-interfacing-with-atmega8-fat32.html

Não testei ainda mas pelo que li ainda é possível fazer acesso SDHC pela SPI ...

Que eu recorde das 39439483904 normas (ok, tá mais pra 2 ou 3) que tive que ler pra resolver o mesmo problema, a norma que criou os SDHC torna opcional o suporte SPI *apenas* para os µSD, sendo ainda mandatário o suporte para cartões de tamanho convencional. Como na prática o que os fabricantes fizeram foi passar a produzir só circuitos µSD, prevendo que venderiam mais destes do que os SDHC de tamanho convencional (que costumam ser apenas uma caixa grande para a mesma plaquinha que eles vendem na versão µSD), eu ainda não deparei com *nenhum* (dos cerca de 20 modelos diferentes que testei) µSDHC que não suportasse SPI.

São 3 "segredos industriais" que tive que aprender a duras penas (leia-se testando) para portar uma biblioteca que só lia SDCARD para SDHC, mantendo a correta compatibilidade com cartões mais antigos:

1) A rotina de inicialização precisa ser alterada. É preciso interrogar se o cartão segue a norma sd 2.0 (cmd 0x8 parametro 0x1aa), e caso sim, verificar se é um sdhc. alguns cartões são bastante suscetíveis a sequencia correta de inicialização: Mesmo que não seja sdhc, os cartoes com norma 2.0 (sairam varios de 2gb) precisam de uma inicializacao diferenciada. Os SDHC ainda um pouco mais específica.
2) Os cartões SDHC usam endereços em blocos de 512 bytes (hmm, blocos de tamanho variável conforme a norma, vc inicializa lendo os descritores, se lembro bem, mas na prática 512 bytes funciona bem em todo o range suportado pelo SDHC), enquanto os antigos usam endereços em bytes - ainda que vc especifique que usará blocos de transferência de 512 bytes. No código que faz a leitura/gravação de setores, verifique se vc tem um multiplicador por 512; substitua por uma variável que por default será 512, mas será setada para 1, caso seja um sdhc).

3) A inicialização do cartao, feita com o "ACMD 41", que é mandatório para SDHC (e acho que para SD 2.0), costuma levar beeeeeeem mais tempo (ou ciclos de clock) nos cartões maiores. Então é necessário geralmente aumentar o timeout específico de resposta à este comando, durante a sequencia de init, para evitar que o procedimento aborte.

Se lembro bem era isso.

Só faltou bostar o código ai pra gente


.

Baseado na http://elm-chan.org/fsw/ff/00index_e.html

Segue a rotina de inicialização... o resto deixo como exercício aos leitores

Código: Selecionar todos

DSTATUS disk_initialize(BYTE Drive ATTRIBUTE_UNUSED) {
  int i, response;


  printf("Disk Init\r\n");
  sdhal_init();
  sdhal_cardunsel();


  for (i = 0; i < 16; i++) {
    sdhal_write(0xff);
  }

  // send CMD0, should return with all zeros except IDLE STATE set (bit 0)
  if (_cmd(0, 0) != R1_IDLE_STATE) {
    printf("Not in idle state\n");
    return STA_NOINIT;
  }

  block_mode = 512;
  response = _cmd(0x08, 0x1AA);
  //printf("cmd 8 resp: %02x\n", response);
  if (response == 0x01) {
    char ocr[4];
    for (i = 0; i < 4; i++) ocr[i] = sdhal_write(0xff);
    // This is an SD 2.0 card, probably SDHC.
    if (ocr[2] == 0x01 && ocr[3] == 0xAA) {
      for (i = 0; i < 1000; i++) {
        _cmd(55, 0);
        if (_cmd(41, (1UL << 30)) == 0) break;
      }
      if (i == 100) {
        printf("Timeout awaiting for ACMD41 after CMD8\n");
        return STA_NOINIT;
      }
      if (_cmd(58, 0) == 0) {
        for (i = 0; i < 4; i++) ocr[i] = sdhal_write(0xff);
        printf("CMD 58: %02x %02x %02x %02x\r\n", ocr[0], ocr[1], ocr[2], ocr[3]);
        if (ocr[0] & 0x40) {
          block_mode = 1;
          printf("SDHC detected.\r\n");
        }
      }
    }
  } else

  // ACMD41 to give host capacity support (repeat until not busy)
  // ACMD41 is application specific command, so we send APP_CMD (CMD55) beforehand
  for (i = 0;; i++) {
    _cmd(55, 0);
    response = _cmd(41, 0);
    if (response == 0) {
      break;
    } else if (i > SD_COMMAND_TIMEOUT) {
      printf("Timeout waiting for card (last response was %02x)\n", response);
      return STA_NOINIT;
    }
  }

  _sectors = _sd_sectors();

  int b;
  // Set block length to 512 (CMD16)
  if ((b = _cmd(16, 512)) != 0) {
    printf("Set block error %02x\n", b);
    return STA_NOINIT;
  }

  sdhal_sethispeed();
  printf("SDCard Initialized.\n");
  return 0;
}