MMC en CCS

[jhonastad]

Hola slalen, estoy tratando de escribir y leer una sd, pero no he encontrado informacion sobre los comandos que hay que mandarle al mmc, si tu pudieras enviarme estos comandos, o facilitarme el driver te lo agradeceria

[jhonastad]

OK!! SORRY INSTALE UNA VERSION MAS NUEVA DE CCS Y  BENIA CON EL DRIVER, DISCULPEN EL LAPSUS

[bily]

hola a todos estoy trabajando con la memoria mmc y el pic 18f452. tengo el programa de prueba de CCS compiler pero el problema mmc no arranca nada  y en el programa de fat de CCs compiler en los ejemplos tampoco y tengo problema de llevar del pic del demo a mi pic 18f452 espero que me ayuden... saludos a todos

[PalitroqueZ]

uff Slalen leyendote, sueño cuando será el dia en que pueda hacer mis primeros ensayos con la tarjeta 

....

bueno, finalmente ese dia llegó, y lo lógico es primero hacer las simulaciones.

les comento que la MMC del ISIS funciona, no quise usar los programas que trae el ccs (siempre he desconfiado de las funciones spi built-in)

así que me puse a leer un rato documentaciones de varias fuentes y armé los codigos correspondientes a escribir/leer un byte, iniciar la tarjeta, leer la CID y la CSD (que si se puede leer según la MMCA)

esto es un primer intento, el código todavía le falta, pero la idea es que vean que es mejor entender y escribir el programa uno mismo, a fin de evitar sorpresitas 

Código: C

1. #byte SSPCON1 = 0xFC6
2. #byte SSPSTAT = 0xFC7
3. #byte SSPBUF= 0xFC9
4. #byte PIR1=0xF9E
5.  
6. int const cmd[]={0x40,0x41,0xff,0x4A,0x49,0x51,0x58,0x50};
7. int const lTimeout=0x2fff;
8.  
9. #inline
10. int Leer_1Byte_SPI(){
11.    SSPBUF=0xff;  // envia puros unos en dataout
12.    while(!bit_test(PIR1,3)){};
13.    // mientras SSPIF=0 la transmisión contínua
14.    // si SSPIF=1, terminó la transmisión. SSPIF-> PIR1,3
15.    bit_clear(PIR1,3); // borro el flag SSPIF
16.    return(SSPBUF);
17. }
18. //--------------------------------------------------------------
19. #inline
20. int Escribir_1Byte_SPI(int dato){
21.    SSPBUF=dato;
22.    if(SSPCON1 & 0x80){
23.       return(0xff);
24.    }
25.    else{
26.       while(!bit_test(PIR1,3)){};
27.       // mientras SSPIF=0 la transmisión contínua
28.       // si SSPIF=1, terminó la transmisión. SSPIF-> PIR1,3
29.       bit_clear(PIR1,3); // borro el flag SSPIF
30.    }
31.    return(0);
32. }
33. //--------------------------------------------------------------
34. #inline
35. int Comando_MMC(int _cmd){
36.    int iRespuesta=cmd[2];//0xff;
37.    long lTiempo_fuera=0;
38.  
39.    output_low(MMC_CS);
40.    Leer_1Byte_SPI();
41.  
42.    Escribir_1Byte_SPI(cmd[_cmd]);
43.    Escribir_1Byte_SPI(0);
44.    Escribir_1Byte_SPI(0);
45.    Escribir_1Byte_SPI(0);  
46.    Escribir_1Byte_SPI(0);
47.    Escribir_1Byte_SPI(0x95);
48.    
49.    
50.    while(iRespuesta==cmd[2]){//0xff){
51.       iRespuesta=Leer_1Byte_SPI();
52.       if(lTiempo_fuera++>500){ break;}
53.    }
54.    return(iRespuesta);
55. }
56. //------------------------------------------------------------------------
57.  
58. #inline
59. int Iniciar_MMC(){
60.    int t;
61.    long lTiempo_fuera=0;
62.  
63.    SSPCON1=0b00110010;
64.    // activa spi por hardware, maestro en Fosc/64, reloj idle en alto (CKP=1)
65.    SSPSTAT=0;
66.    //transmisión ocurre en flanco bajada (CKE=0)
67.  
68.    output_high(MMC_CS);
69.    delay_us(100); // una especie de power-up timer para la MMC
70.    
71.    for(t=0;t<12;t++){
72.       Leer_1Byte_SPI();
73.    }
74.    
75.    while(Comando_MMC(0)!=1){
76.      delay_us(100);
77.      if(lTiempo_fuera++>lTimeout){ return(1);}
78.    }
79.    
80.    lTiempo_fuera=0;
81.    while(Comando_MMC(1)!=0){
82.      delay_us(100);
83.      if(lTiempo_fuera++>lTimeout){ return(2);}
84.    }
85.    
86.    SSPCON1=0b00110010;
87.    // activa spi por hardware, maestro en Fosc/4, reloj idle en alto (CKP=1)  
88.    SSPSTAT = 0;
89.    //transmisión ocurre en flanco bajada (CKE=0
90.  
91.    output_high(MMC_CS);
92.    return 0;
93. }
94. //------------------------------------------------------------
95. #inline
96. int Leer_CID(char *sCID){
97.    int t;
98.    long lTiempo_fuera=0;
99.    
100.    output_low(MMC_CS);
101.    while(Comando_MMC(3)!=0){
102.       delay_us(100);
103.       if(lTiempo_fuera++>lTimeout){
104.          output_high(MMC_CS);
105.          return(2);
106.       }
107.    }
108.    while(Leer_1Byte_SPI()!=0xFE){};
109.    
110.    for(t=0;t<18;t++){
111.       sCID[t]=Leer_1Byte_SPI();
112.    }
113.    
114.    output_high(MMC_CS);
115.    Leer_1Byte_SPI();
116.    return 0;
117. }
118.  
119. //----------------------------------------------------------------
120. #inline
121. int Leer_CSD(char *sCSD){
122.    int t;
123.    long lTiempo_fuera=0;
124.    
125.    output_low(MMC_CS);
126.    while(Comando_MMC(4)!=0){
127.       delay_us(100);
128.       if(lTiempo_fuera++>lTimeout){
129.          output_high(MMC_CS);
130.          return(2);
131.       }
132.    }
133.    while(Leer_1Byte_SPI()!=0xFE){};
134.    
135.    for(t=0;t<18;t++){
136.       sCSD[t]=Leer_1Byte_SPI();
137.    }
138.    
139.    output_high(MMC_CS);
140.    Leer_1Byte_SPI();
141.    return 0;
142. }

como verán el programa está personalizado, no voy a entrar en detalle si es mejor el asm o el c, pero ahora pienso que con estas limitaciones que tienen los pics, lo mejor es pensar en ambos lenguajes (adios portabilidad, bienvenido la velocidad y las optimizaciones)

hay un hilo bastante instructivo en el forum ccs, donde discuten como optimizar el acceso a una sd, y dan unas ideas muy interesantes.

[Slalen]

Pffffffffffffffff.....

Ya te adelantaste....

Eres una máquina!!!!

Yo lo quería retomar ahora que he acabado un nuevo robot (a ver si lo cuelgo) y que tengo más tiempo.

Voy a buscar mi placa de pruebas y ver que tal va tu librería.

Muchas gracias!!!!!!!

[PalitroqueZ]

En la modificación que estoy trabajando, quiero hacer del código lo mas veloz posible, (estoy revisando que es mas rapido, si punteros ó variables globales)

es que si vieras guillermo, probando en el osciloscopio, solamente la rutina de escribir, me tardo mas de 2 uS entre datos, ¡el overhead es una vaina seria!

yo me pregunto a que velocidad de escritura trabajaran los pendriver, allí debe ser todo por hardware, porque sino imaginate...

[Slalen]

Conociéndote se que lo lograrás en unos días....

Suerte!!!!

[daniel_ac32_venezuela]

buenas tengo una pregunta!! alguien sabe de una libreria para sd card en ccs que me permita leer los archivos de la misma?