Comenzando con memorias SD/MMC. Librería a nivel hardware.

[tannke]

Para el divisor resistivo utiliza mejor resistencias de 1.5k y 3.3k, para altas frecuencias funciona mejor.

UUUUfff!!! Suky muchas gracias!!!

Llevo 1 semana peleando con un proyecto, un gravador de llamadas telefonicas a la sd, el tema sd lo hago con las librerias de mikroc y me gravaba el sonido casi perfecto, solo que cada X segundos perdía algunos sectores( se escuchaba un pequeñisimo corte), utilizo 2 buffers de 512 Bytes, y mientras lleno uno con los samples vuelco el otro a la sd. El tema estaba que la escritura en sd era mas lenta que la lectura de samples.
Prové de todo! Incluso con el pic andando a 48MHz seguia perdiendo sectores (Errores de escritura/lectura en sd ni uno)

Oye... fué poner esos valores de resistencias y ala....

Lo dicho, jejej muchas gracias y saludos 

[Suky]

De nada! A mi también me toco probar un par de valores, y con esos ha funcionado hasta con 12 MHz 


Saludos!

[rroque]

Osea todas esas extensiones del FAT16 las agrego al programa inicial probandoSDCard?¿?¿?¿?¿?¿ o como lo tengo q probar?¿?¿ Consegui un cristal de 48MHz, voy a probar con esto a ver que pasa ......


Saludoss

[rroque]

Suky, utilice la resistencias recomendadas (3.3k y 1.5k)y los valores del voltaje de este divisor son de 5voltios :O, no se supone q las memoria trabaja a 3.3v?¿?¿

Otra consulta, hehe acabo de adquirir el 74125N que utilizas en el hardware ideal, veo la resistencias conectadas a 3.3V, que valores son?¿?¿?¿

Saludos

[Suky]

Osea todas esas extensiones del FAT16 las agrego al programa inicial probandoSDCard?¿?¿?¿?¿?¿ o como lo tengo q probar?¿?¿ Consegui un cristal de 48MHz, voy a probar con esto a ver que pasa ......


Saludoss

En el enlace que te indique hay ejemplo, trata de estudiarlos   Primero se inicializa la memoria, luego se pasa a iniciar es sistema de archivos FAT, para determinar la estructura FAT que tiene la memoria, luego pasas a leer o escribir archivos.

Un cristal de 48MHz no sirve, un 18F acepta solo hasta 20 MHz, pero podes usar el PLL interno para llevar la frecuencia de trabajo a 48MHz.

Suky, utilice la resistencias recomendadas (3.3k y 1.5k)y los valores del voltaje de este divisor son de 5voltios :O, no se supone q las memoria trabaja a 3.3v?¿?¿

Otra consulta, hehe acabo de adquirir el 74125N que utilizas en el hardware ideal, veo la resistencias conectadas a 3.3V, que valores son?¿?¿?¿

Saludos

La primera afirmación es incoherente, si conectas el divisor resistivo a la salida del pin del microcontrolador con ~5 V, como puedes obtener 5 V ?  

Respecto a las resistencias pull-up, pueden ser de 10k.


Saludos!

[rroque]

Lo que hice fue darle energia al micro y medir justo esos puntos y salia esos voltajes :S, felizmente saque la memoria, esta bien que exista voltaje en esos puntos cuando el programa ya corra?¿?¿

[rroque]

Implemente el hardware con el 74125n y al parecer esta bien xq coloque unos led en las patillas DI, DO,CS, CLK para comprobar si es que esta mandando data, pero aun asi en la salida serial sigue saliendo lo mismo:

******* Iniciando Memoria SD Card... *******

--> Se inicia sincronizacion

--> Se envia CMD0 (Se desactiva SD Card)

******* Leemos registro CID: *******

--> Se envia CMD10 (Lectura de CID)

******* Leemos registro CSD: *******

--> Se envia CMD9 (Lectura de CSD)

******* Escribimos sector 0x200 *******

--> Se envia CMD24 (Escritura de bloque)

******* Leemos sector 0x200 *******

--> Se envia CMD17 (Lectura de bloque)
   >> Datos leidos:

00,01,02,03,04,05,06,07,08,09,0A,0B,0C,0D,0E,0F,10,11,12,13,14,15,16,17,18,19,1A,1B,1C,1D,1E,1F,
20,21,22,23,24,25,26,27,28,29,2A,2B,2C,2D,2E,2F,30,31,32,33,34,35,36,37,38,39,3A,3B,3C,3D,3E,3F,
40,41,42,43,44,45,46,47,48,49,4A,4B,4C,4D,4E,4F,50,51,52,53,54,55,56,57,58,59,5A,5B,5C,5D,5E,5F,
60,61,62,63,64,65,66,67,68,69,6A,6B,6C,6D,6E,6F,70,71,72,73,74,75,76,77,78,79,7A,7B,7C,7D,7E,7F,
80,81,82,83,84,85,86,87,88,89,8A,8B,8C,8D,8E,8F,90,91,92,93,94,95,96,97,98,99,9A,9B,9C,9D,9E,9F,
A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,B0,B1,B2,B3,B4,B5,B6,B7,B8,B9,BA,BB,BC,BD,BE,BF,
C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,CA,CB,CC,CD,CE,CF,D0,D1,D2,D3,D4,D5,D6,D7,D8,D9,DA,DB,DC,DD,DE,DF,
E0,E1,E2,E3,E4,E5,E6,E7,E8,E9,EA,EB,EC,ED,EE,EF,F0,F1,F2,F3,F4,F5,F6,F7,F8,F9,FA,FB,FC,FD,FE,FF,
00,01,02,03,04,05,06,07,08,09,0A,0B,0C,0D,0E,0F,10,11,12,13,14,15,16,17,18,19,1A,1B,1C,1D,1E,1F,
20,21,22,23,24,25,26,27,28,29,2A,2B,2C,2D,2E,2F,30,31,32,33,34,35,36,37,38,39,3A,3B,3C,3D,3E,3F,
40,41,42,43,44,45,46,47,48,49,4A,4B,4C,4D,4E,4F,50,51,52,53,54,55,56,57,58,59,5A,5B,5C,5D,5E,5F,
60,61,62,63,64,65,66,67,68,69,6A,6B,6C,6D,6E,6F,70,71,72,73,74,75,76,77,78,79,7A,7B,7C,7D,7E,7F,
80,81,82,83,84,85,86,87,88,89,8A,8B,8C,8D,8E,8F,90,91,92,93,94,95,96,97,98,99,9A,9B,9C,9D,9E,9F,
A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,B0,B1,B2,B3,B4,B5,B6,B7,B8,B9,BA,BB,BC,BD,BE,BF,
C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,CA,CB,CC,CD,CE,CF,D0,D1,D2,D3,D4,D5,D6,D7,D8,D9,DA,DB,DC,DD,DE,DF,
E0,E1,E2,E3,E4,E5,E6,E7,E8,E9,EA,EB,EC,ED,EE,EF,F0,F1,F2,F3,F4,F5,F6,F7,F8,F9,FA,FB,FC,FD,FE,FF,

AL parecer no esta corriendo el programa incluido SDCard_hard.c o no se porque tambien modifque en la parte de incializacion del SPI el clock:

SETUP_SPI(SPI_MASTER|SPI_CLK_DIV_4|SPI_H_TO_L|SPI_XMIT_L_TO_H )

Pero no se que mas pueda ser :S

Saludos

[Chenao]

Saludos

Me he hecho a la tarea de montar físicamente el circuito que esta en el primer mensaje del presente hilo, con algunas modificaciones la primera es que lo terminales que quedan libres de la microsd los conecto a 3.3 v por medio de unas resistencias pulls -up de 10k, y conecto entre los terminales VDD y VSS de microcontrolador un condensador de 0,1 uf para eliminar los poblemas de acople que se me estaban presentando con la fuente de tensión que poseo. El microcontrolador utilizado en el circuito es un PIC16F887, además, se utilizó un MAX232 para conectar el microcntrolador con una computadora digital (RS232) para realizar el debug y la respectiva depuración del circuito y del software. Las rutinas que implemente son las que poco a poco he venido haciendo, mejorando como se muestran a continuación.

Rutina de inicialización

Código: [Seleccionar]

int init_mmc()
  {
    SETUP_SPI(SPI_MASTER | SPI_H_TO_L | SPI_CLK_DIV_16 | SPI_XMIT_L_TO_H);
    OUTPUT_HIGH(PIN_C2);
    delay_ms(20);
    for(i=0; i<20; i++)
      {
        SPI_WRITE(0xFF);             // espero a que se inicialice la memoria que van desde 8 a 10 pulso del reloj
      }
    OUTPUT_LOW(PIN_C2);             // Activo la targeta
    delay_ms(20);
    for(i=0; i<20; i++)
      {
        SPI_WRITE(0xFF);             // espero a que se inicialice la memoria que van desde 8 a 10 pulso del reloj
      }
    i = 0;
    do
     {
      SPI_WRITE(0x40);
      SPI_WRITE(0x00);
      SPI_WRITE(0x00);
      SPI_WRITE(0x00);
      SPI_WRITE(0x00);
      SPI_WRITE(0x95);                // Comando CMDO datos a enviar
     }
    while((mmc_respuesta(0x01)==0x01) && (i<200));
    if(i>=200)
      {
        printf("Error en comando CMD0");
        return 1;                    // Error en memoria por que se supero el tiempo
      }
    i = 0;
    do
      {
        SPI_WRITE(0x41);         // Envia comando hasta que de la respuesta y hasta que se cumpla el tiempo
        SPI_WRITE(0x00);
        SPI_WRITE(0x00);
        SPI_WRITE(0x00);
        SPI_WRITE(0x00);
        SPI_WRITE(0xFF);            // Secuencia del comando CMD1
        i= i + 1;
      }
    while((i<250) && (mmc_respuesta(0x00)==0x01));
    if(i>=250)
      {
        printf("Error en comando CMD1");
        return 1;                // si se supera el tiempo de respuesta no se ha inicializado bien la targeta
      }
   i = 0;
   do
    {
     SPI_WRITE(0x50);
     SPI_WRITE(0x00);
     SPI_WRITE(0x00);
     SPI_WRITE(0x02);
     SPI_WRITE(0x00);
     SPI_WRITE(0xFF);              // Comando CMD16 para configurarlo de 512 bytes
     i = i + 1;
    }
   while((mmc_respuesta(0x00)==0x01) && (i<2));
    if(i>=2)
      {
        printf("Error en comando CMD16");
        return 1;                // se ha inicializado incorrectamente
      }
    SPI_WRITE(59|0x40);
    SPI_WRITE(0x00);   
    SPI_WRITE(0x00);
    SPI_WRITE(0x00);   
    SPI_WRITE(0x00);
    SPI_WRITE(0xFF);              // Comando CMD59 para desactivar el CRC
    if(mmc_respuesta(0x00)== 0x01)
     {
      printf("Error en comando CMD59");
      return 1;
     }
    OUTPUT_HIGH(PIN_C2);
    return 0;                // se ha inicializado correctamente

  }
La rutina de control de respuesta del comando es:

Código: [Seleccionar]

int mmc_respuesta(unsigned char respuesta)
  {
    unsigned long espera = 0xFFFF;
    while(SPI_READ(0xFF)!= respuesta && espera> 0)
     {
       espera= espera - 1;
     }
    if(espera==0)
     {
      return 1;                  // se ha superado el tiempo
     }
    else
     {
      return 0;
     }
  }

La rutina de escritura de un sector de la memoria es la siguiente

Código: [Seleccionar]

int mmc_escribir_bloque()
  {
    resp = 0;   OUTPUT_LOW(PIN_C2);
    for(i=0; i<16; i++)
      {
        SPI_WRITE(0xFF);         // Espero a que se estabilice la memoria
      }
    SPI_WRITE(0x58);
    SPI_WRITE(0x00);
    SPI_WRITE(0x00);
    SPI_WRITE(0x02);
    SPI_WRITE(0x00);
    SPI_WRITE(0xFF);          // Comando CMD24 pero escribé en el segundo bloque 0x200
    if(mmc_respuesta(0x00)==0x01)         // Espero la respuesta RB1
      {
        printf("Error en CMD24");
        return 1;              // no respondio correctamente la memoria
      } 
    SPI_WRITE(0xFE);          // Envio el token de inicio
    for(i=0; i<512; i++)
      {   spi_write(17);
        delay_ms(1);
      }
    SPI_WRITE(0xFF);
    SPI_WRITE(0xFF);             // espero ha que se estabilice o envio 2 CRC
    printf("%Lu",i);
    i=0;
    do
     {
      resp = SPI_READ(0xFF);
      i++;
     }
    while ((i<2000) && resp == 0xFF);
    if(i>=2000)
     {
       printf("Se ha superado el tiempo");
       return 1;
     }
    printf("Respuesta de recepción \n %X",resp);
    if((resp&0x0F)!=0x05)
      {
        printf("error al escribir los datos");
        SPI_WRITE(0xFF);
        OUTPUT_HIGH(PIN_C2);
        return 1;                            // No se escribio correctamente el bloque de 512 bytes dirente de 00101
      }
    OUTPUT_HIGH(PIN_C2);
    return 0;
  }

Continua...

[Chenao]

Continua.

La rutina para lectura de un sector de la memoria es la siguiente

Código: [Seleccionar]

int mmc_leer_bloque()
  {
    OUTPUT_LOW(PIN_C2);
    SPI_WRITE(0x51);
    SPI_WRITE(0x00);
    SPI_WRITE(0x00);
    SPI_WRITE(0x02);
    SPI_WRITE(0x00);
    SPI_WRITE(0xFF);          // Comando CMD17 para leer el bloque 2 de la memoria
    if(mmc_respuesta(0x00)==0x01)         // Espero el comando RB1 la respuesta
      {
        return 1;             // Hubo error en la lectura del bloque 2 de la memoria
      }
    if(mmc_respuesta(0xFE)==0x01)
      {
        return 1;            // espera por el token de respuesta
      }
    if((SPI_READ(0XFF)&0xE0)==0x00)  // espero el token correcto
      {
        return 1;
      }
    OUTPUT_HIGH(PIN_C2);
    return 0;
  }
Y el main es el siguiente

Código: [Seleccionar]

void main()
  {
   long conversion;
    int lectura;
    i = 0;
    setup_adc_ports(sAN0|sAN1|VREF_VREF);
    setup_adc(adc_clock_div_32);                  // configuro el conversor análogo digital
    set_tris_b(0x00);
    set_tris_a(0xff);
    set_tris_c(0x93);
    disable_interrupts(global);
    retorno = init_mmc();
    if(retorno==0x01)
      {
        printf("Error en memoria");
      }
    else
      {
    do
     {
        if (input(pin_d2)==1)
         {
           retorno = mmc_escribir_bloque();
           if(retorno==0x01)
            {
             printf("No se pudo escribir el bloque");
            }
           else
            {
             printf("Escritura realizada");
            }
          }
         if(input(pin_d2)==0)
           {
            retorno== mmc_leer_bloque();
            if(retorno==0x01)
             {
              printf("Error en lectura\r");
             }
            else
             {
              for(i=0; i<512; i++)
               {
                 lectura = spi_read(0XFF);
                 printf("%x",lectura);
                }
              SPI_READ(0xFF);
              SPI_READ(0xFF);
              OUTPUT_HIGH(PIN_C2);                   // Chip Select = 1 (off)
              SPI_WRITE(0xFF);
             }
           }
       }
      while(true);
     }
  }

Se dio inicio a la pruebas verificando que la memoria respondiera al algoritmo de inicio (init_mmc()), y funciona efectivamente, después se hicieron la implementación de la rutina de lectura de un sector y sin problemas, la única rutina que no he podido hacer funcionar es la rutina de escritura de un sector de la misma, para detectar el posible error empezé hacer el debug, encontre que la memoria responde acertadamente al comando CMD24, despues se envian acertadamente el token de inicio, después se envia el bloque a escribir y por último la memoria responde (si todo salio bien) la memoria debe responde con 0x05 pero según el siguiente código para revisar con que valor responde la memoria.

Código: [Seleccionar]

do
     {
      resp = SPI_READ(0xFF);
      i++;
     }
    while ((i<2000) && resp == 0xFF);
    if(i>=2000)
     {
       printf("Se ha superado el tiempo");
       return 1;
     }
    printf("Respuesta de recepción \n %X",resp);
    if((resp&0x0F)!=0x05)
      {
        printf("error al escribir los datos");
        SPI_WRITE(0xFF);
        OUTPUT_HIGH(PIN_C2);
        return 1;                            // No se escribio correctamente el bloque de 512 bytes diferente de 00101
      }
La memoria responde la mayoria de la veces con 0x00, en muy pocas ocasiones responde con 0xFC, 0x80, 0xF0 pero nunca aparece 0x05 la verdad no se cual se ha el problema no se si algún compañero del foro se le haya presentado el mismo problema, estoy por pensar que el conector con que viene la microsd tiene la protección contra escritura truncada, y por tal razón, no me deja realizar la operación de escritura. Si alguién tiene alguna idea o sugerencia bienvenida.

Saludos

[EMIF]

Hola amigos del Foro, les comento que estoy usando las librerias de Suky "FAT16_SDCard" y "SDCard_hard", y he obtenido muy buenos resultados, inicializo la memoria, la FAT, creo un archivo y puedo almacenar datos.
El paso que sigue es descargar los datos a la PC a traves del PIC, no sacando la memoria y leyendola diectamente de la PC. En las librerias esta la funcion FAT_OpenFile y dentro de esta llama a FAT_GETFile que por lo que entiendo mando por RS232 todo el archivo, pero esto no esta funcionando.
Lo que hace es enviar muchos caracteres NULL.
La verdad que hay algo que no estoy interpretando bien. Si hay alguien que haya trabajado con esto se agradeceria alguna sugerencia

[Suky]

Estas usando la versión 1.8?

[EMIF]

De la Fat uso la version 1.5 no la 1.8, porque esta andando muy bien. No quise usar las librerias genericas porque eran un poco mas complejas.
Has usado la funcion OpenFile o GetFile, para mandar el archivo por RS232?
Que deberia recibir en la PC? Los datos uno abajo del otro?

[Suky]

Te recomiendo la 1.8. La otra seguramente tiene algunos bugs 

[EMIF]

Disculpa que te pregunte tanto, pero no se que debo recibir al utilizar FAT_OpenFile, voy a recibir simplemente todos los datos uno tras otro??

[Suky]

Claro, los bytes que vaya leyendo del archivo.