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

[Modulay]

A ver si así se puede ver de forma directa

[Modulay]

vaya, al principio se veía la imagen incrustada y ahora no.
Que cosa más rara.
Adjunto la imagen

[Suky]

A mi también, copie el enlace a otra solapa y funciono. Es un diagrama de flujo de como deberia ser la inicialización para detectar todos los tipos de tarjetas.

Saludos !

A! Si ya se de que se trata, creo que la librería de Microchip lo implementa. O en la del mbed, en algún lado la vi 


Saludos!

[Modulay]

La de Microchip efectivamente soporta también las tarjetas HC

[Suky]

Buenas! Actualice la librería para que pueda inicializar memorias HC   Información: SD Specifications  2.00

Código: C

1. /** \file SDCardSPI.h
2.    \version: 1.0
3.    
4.    \brief Este fichero contiene definiciones de libreria para manejo de memoria SD a nivel hardware.
5.    
6.    \author Suky.
7.    \web www.micros-designs.com.ar
8.    \date 19/06/10
9.    
10. ///////////////////////////////////////////////////////////////////////////
11. ////                                                                   ////
12. ////                                                                   ////
13. ////        (C) Copyright 2011 www.micros-designs.com.ar               ////
14. //// Este código puede ser usado, modificado y distribuido libremente  ////
15. //// sin eliminar esta cabecera y  sin garantía de ningún tipo.        ////
16. ////                                                                   ////
17. ////                                                                   ////
18. ///////////////////////////////////////////////////////////////////////////
19.  
20. *- Version Log --------------------------------------------------------------_*
21.  *   Fecha       Autor                Comentarios                             *
22.  *----------------------------------------------------------------------------*
23.  * 25/10/09      Suky     Original (Rev 1.0) CCS                              *
24.  * 01/05/10      Suky     Se agrega mas espera en respuesta a un comando      *    
25.  * 19/06/10      Suky     Se agrega archivo GenericTypeDefs.h, HardwareSPI y..*
26.  *                        ..se modifican funciones para hacer compatible la.. *
27.  *                        ..libreria con otros compiladores. Probado en C18.- *  
28.  * 24/09/11              Suky     Se agrega soporte memorias HC v1.x y v2.x           *
29.  *----------------------------------------------------------------------------*
30. */
31. #ifndef __SDCardSPI_H
32. #define __SDCardSPI_H
33. #if defined(__PCH__)
34.         #include "HardwareSPI.c"
35. #else
36.         #include "HardwareSPI.h"
37. #endif
38.  
39. #include "GenericTypeDefs.h"
40.  
41. // Realiza debugger mediante RS232.-
42. #define SDCARD_DEBUG
43.  
44. #if defined(SDCARD_DEBUG)
45.         #if defined(__18CXX) || defined (__C30__) || defined (__PIC32MX__)
46.                 #include <usart.h>
47.                 #include <stdio.h>
48.         #endif
49. #endif
50.  
51. // Definción de comandos
52. #define CMD0 0       // Resetea la SD Card.-
53. #define CMD1 1       // Activa proceso de inicialización de SD Card.
54. #define CMD8 8
55. #define CMD9 9       // Lectura registro CSD.-
56. #define CMD10 10     // Lectura registro CID.-
57. #define CMD16 16     // Selecciona largo del bloque para lectura/escritura (1 a 512)
58. #define CMD17 17     // Lectura de un único bloque.
59. #define CMD24 24     // Escritura de un único bloque.
60. #define CMD41 41
61. #define CMD55 55
62. #define CMD58 58
63. #define CMD59 59     // Enciende/Apaga CRC.
64. #define CMD32 32     // Setea dirección  del primer bloque a borrar.-
65. #define CDM33 33     // Setea dirección del último bloque en un continuo rango a borrar.-
66. #define CMD38 38     // Borra todos los sectores entre las direcciónes establecidas.-
67.  
68. #define BLOCK_SIZE 512 // Tamaño del bloque de lectura/escritura.
69.  
70. /** \brief Inicialización de SD Card
71.  
72.    \param Ninguno
73.    \return 1 si se ha iniciado correctamente, 0 caso contrario.
74. */
75. BOOL SDCard_init(void);
76. /** \brief Realiza lectura de un bloque.-
77.    
78.    \param Address: Direccion del sector.-
79.    \return Buffer: Buffer donde se almacena lectura de memoria.-
80.    \return  0 a  ocurrido algún error, 1 todo ok.-
81. */
82. BOOL SDCard_read_block(UINT32 Address,UINT8 *Buffer);
83. /** \brief Realiza escritura de un bloque.-
84.    
85.    \param Address: Direccion del sector.-
86.    \param Buffer: Buffer a escribir en memoria.-
87.    \return  0 a ocurrido algún error, 1 todo ok.-
88. */
89. BOOL SDCard_write_block(UINT32 Address,UINT8 *Buffer);
90.  
91. /** \brief Realiza lectura del registro CSD.-
92.    
93.    \param Ninguno
94.    \return  0 a ocurrido algún error, 1 todo ok.-
95. */
96. BOOL SDCard_read_CSD(void);
97. /** \brief Realiza lectura del registro CID.-
98.    
99.    \param Ninguno
100.    \return  0 a ocurrido algún error, 1 todo ok.-
101. */
102. BOOL SDCard_read_CID(void);
103. #endif

Código: C

1. /** \file SDCardSPI.c
2.    \version: 1.0
3.    
4.    \brief Este fichero contiene definiciones de libreria para manejo de memoria SD a nivel hardware.
5.    
6.    \author Suky.
7.    \web www.micros-designs.com.ar
8.    \date 19/06/10
9.    
10. ///////////////////////////////////////////////////////////////////////////
11. ////                                                                   ////
12. ////                                                                   ////
13. ////        (C) Copyright 2011 www.micros-designs.com.ar               ////
14. //// Este código puede ser usado, modificado y distribuido libremente  ////
15. //// sin eliminar esta cabecera y  sin garantía de ningún tipo.        ////
16. ////                                                                   ////
17. ////                                                                   ////
18. ///////////////////////////////////////////////////////////////////////////
19.  
20. *- Version Log --------------------------------------------------------------_*
21.  *   Fecha       Autor                Comentarios                             *
22.  *----------------------------------------------------------------------------*
23.  * 25/10/09      Suky     Original (Rev 1.0) CCS                              *
24.  * 01/05/10      Suky     Se agrega mas espera en respuesta a un comando      *    
25.  * 19/06/10      Suky     Se agrega archivo GenericTypeDefs.h, HardwareSPI y..*
26.  *                        ..se modifican funciones para hacer compatible la.. *
27.  *                        ..libreria con otros compiladores. Probado en C18.- *  
28.  * 24/09/11              Suky     Se agrega soporte memorias HC v1.x y v2.x           *
29.  *----------------------------------------------------------------------------*
30. */
31. #include "SDCardSPI.h"
32.  
33. #define SDCARD_TIMEOUT                  5000
34. #define SDCARD_MODO_NORMAL              0x10
35. #define SDCARD_MODO_HC                  0x20
36. typedef struct{
37.         union{
38.                 UINT8   Val;
39.                 struct{
40.             unsigned IdleState:1;      
41.             unsigned EraseReset:1;        
42.             unsigned IllegalCmd:1;        
43.             unsigned CrcErr:1;            
44.             unsigned EraseSeqErr:1;      
45.             unsigned AddressErr:1;        
46.             unsigned ParamErr:1;          
47.             unsigned B7:1;                  
48.         }bits;
49.         }R1;
50.         UINT32  Retorno;
51. }SDCARD_RESPUESTA;
52. UINT8 SDCARD_Modo;
53. //*******************************************************************************
54. void SDSelect(void){
55.    SD_CS=0;
56.    WriteMedia(0xFF);
57. }
58. //*******************************************************************************
59. void SDDeselect(void){
60.    WriteMedia(0xFF);
61.    SD_CS=1;
62. }
63. //*******************************************************************************
64. BOOL SDCard_send_command(UINT8 cmd,UINT32 arg,SDCARD_RESPUESTA *res){
65.  
66.    UINT8_VAL ResTmp;
67.    UINT16 i;
68.    UINT32_VAL Argumento;
69.    
70.    Argumento.Val=arg;
71.    SD_CS=0;
72.    for( i=0;i<16;i++) WriteMedia(0xFF);
73.    WriteMedia(cmd|0x40);
74.    WriteMedia(Argumento.MB);
75.    WriteMedia(Argumento.UB);
76.    WriteMedia(Argumento.HB);
77.    WriteMedia(Argumento.LB);
78.    if(cmd==0){
79.       WriteMedia(0x95);
80.    }else{  
81.       WriteMedia(0xFF);
82.    }
83.    
84.      
85.    // Se espera respuesta R1
86.    i=0;
87.    do{
88.       ResTmp.Val=ReadMedia();
89.       i++;
90.    }while((ResTmp.b7)!=0 && i<SDCARD_TIMEOUT);// mientras no corresponda con 0xxxxxxx.-
91.    if(i>=SDCARD_TIMEOUT){SDDeselect();return(0);}
92.    res->R1.Val=ResTmp.Val;
93.    #if defined(SDCARD_DEBUG)
94.       printf("Repeticiones para respuesta de CmdXX: %u; Respuesta recibida:%u\r\n",i,ResTmp.Val);
95.    #endif
96.    return(1);
97. }
98. //*******************************************************************************
99. BOOL SDCard_send_command_R7(UINT8 cmd,UINT32 arg,UINT8 CRC,SDCARD_RESPUESTA *res){
100.  
101.    UINT8_VAL ResTmp;
102.    UINT16 i;
103.    UINT32_VAL Temp;
104.    
105.    Temp.Val=arg;
106.    SD_CS=0;
107.    for( i=0;i<16;i++) WriteMedia(0xFF);
108.    WriteMedia(cmd|0x40);
109.    WriteMedia(Temp.MB);
110.    WriteMedia(Temp.UB);
111.    WriteMedia(Temp.HB);
112.    WriteMedia(Temp.LB);
113.    WriteMedia(CRC);
114.  
115.      
116.    // Se espera respuesta R1
117.    i=0;
118.    do{
119.       ResTmp.Val=ReadMedia();
120.       i++;
121.    }while((ResTmp.b7)!=0 && i<SDCARD_TIMEOUT);// mientras no corresponda con 0xxxxxxx.-
122.    if(i>=SDCARD_TIMEOUT){SDDeselect();return(0);}
123.    Temp.MB=ReadMedia();
124.    Temp.UB=ReadMedia();
125.    Temp.HB=ReadMedia();
126.    Temp.LB=ReadMedia();
127.    
128.    res->R1.Val=ResTmp.Val;
129.    res->Retorno=Temp.Val;
130.    #if defined(SDCARD_DEBUG)
131.       printf("Repeticiones para respuesta de CmdXX: %u; Respuesta recibida:%u,0x%lX\r\n",i,ResTmp.Val,Temp.Val);
132.    #endif
133.    return(1);
134. }
135. //*******************************************************************************
136. BOOL SDCard_init(void){
137.  
138.    SDCARD_RESPUESTA Respuesta;
139.    UINT16 i;
140.    
141.    TRIS_SD_CS=0;
142.    SD_CS=1;  
143.    // Configuración del Módulo SPI.-
144.    InitSPI(VELOCITY_SPI_LOW);
145.    
146.    #if defined(SDCARD_DEBUG)  
147.       printf("\r\n--> Se inicia sincronizacion\r\n");
148.    #endif  
149.    Delay_ms20();
150.    for(i=0;i<20;i++) WriteMedia(0xFF);   // Para sincronización.
151.    SD_CS=0;
152.    #if defined(SDCARD_DEBUG)
153.            printf("\r\n--> Se envia CMD0 (Se desactiva SD Card)\r\n\r\n");
154.    #endif
155.  
156.    i=0;
157.    do{
158.       if(SDCard_send_command(CMD0,0x00,&Respuesta)==0){
159.          return(0);        // Si se recibe 0 error por timeout.-
160.       }else{i++;}  
161.    }while((Respuesta.R1.bits.IdleState==0) && i<SDCARD_TIMEOUT);
162.    if(i>=SDCARD_TIMEOUT){SDDeselect();return(0);} // Timeout esperando desactivación de SD Card.
163.       // *---------------------------------------------------------------------*
164.         #if defined(SDCARD_DEBUG)
165.                 printf("--> Se envia CMD8\r\n");
166.         #endif
167.         if(SDCard_send_command_R7(CMD8,0x000001AA,0x87,&Respuesta)==0){
168.                 #if defined(SDCARD_DEBUG)
169.                         printf("        > Error por timeout al enviar comando\r\n");
170.                 #endif
171.                 return(0);        // Si se recibe 0 error por timeout.-
172.         }
173.        
174.         if(((Respuesta.Retorno&0xFFF)==0x1AA)&&(Respuesta.R1.bits.IllegalCmd==0)){
175.                 // Pasamos a esperar condición de SD Card activa.
176.                 // Si R1=0x01, SD Card en estado desactivado.
177.                 #if defined(SDCARD_DEBUG)
178.                         printf("--> Se envia CMD55/ACMD41 (Se activa SD Card)\r\n");
179.                 #endif         
180.                 i=0;
181.                 do{                    
182.                         if(SDCard_send_command(CMD55,0x00,&Respuesta)==0){
183.                                 #if defined(SDCARD_DEBUG)
184.                                         printf("        > Error por timeout al enviar comando\r\n");
185.                                 #endif
186.                                 return(0);
187.                         }
188.                         if(SDCard_send_command(CMD41,0x40000000,&Respuesta)==0){ // Argumento soporta HC...
189.                                 #if defined(SDCARD_DEBUG)
190.                                         printf("        > Error por timeout al enviar comando\r\n");
191.                                 #endif
192.                                 return(0);     // Si se recibe 0 error por timeout.-
193.                         }else{
194.                                 i++;
195.                         }
196.                 }while((Respuesta.R1.bits.IdleState==1) && (i<SDCARD_TIMEOUT)); // Mientras se reciba R1=0x01
197.                 if(i>=SDCARD_TIMEOUT){
198.                         SDDeselect();
199.                         return(0);
200.                 }
201.                 #if defined(SDCARD_DEBUG)
202.                         printf("--> Se envia CMD58\r\n");
203.                 #endif
204.                 if(SDCard_send_command_R7(CMD58,0x00,0xFF,&Respuesta)==0){
205.                         #if defined(SDCARD_DEBUG)
206.                                 printf("        > Error por timeout al enviar comando\r\n");
207.                         #endif
208.                         return(0);        // Si se recibe 0 error por timeout.-
209.                 }
210.                 if(((Respuesta.Retorno&0xC0000000)==0xC0000000)&&(Respuesta.R1.Val==0)){
211.                         #if defined(SDCARD_DEBUG)
212.                                 printf("        > SD Card modo HC\r\n");
213.                         #endif
214.                         SDCARD_Modo=SDCARD_MODO_HC;
215.                 }else{ // ((Respuesta.Retorno&0xC0000000)==0x80000000)
216.                         #if defined(SDCARD_DEBUG)
217.                                 printf("        > SD Card modo normal\r\n");
218.                         #endif
219.                         SDCARD_Modo=SDCARD_MODO_NORMAL;
220.                 }
221.                
222.         }else{ 
223.            // Pasamos a esperar condición de SD Card activa.
224.            // Si R1=0x01, SD Card en estado desactivado.
225.            #if defined(SDCARD_DEBUG)
226.               printf("\r\n--> Se envia CMD1 (Se activa SD Card)\r\n\r\n");
227.            #endif
228.            i=0;
229.            do{
230.               if(SDCard_send_command(CMD1,0x00,&Respuesta)==0){
231.                  return(0);     // Si se recibe 0 error por timeout.-
232.               }else{i++;}
233.            }while((Respuesta.R1.bits.IdleState==1) && (i<SDCARD_TIMEOUT)); // Mientras se reciba R1=0x01
234.            if(i>=SDCARD_TIMEOUT){
235.                         SDDeselect();
236.                         return(0);
237.                 } // Timeout esperando activación de SD Card.
238.                 #if defined(SDCARD_DEBUG)
239.                         printf("        > SD Card modo normal\r\n");
240.                 #endif
241.                 SDCARD_Modo=SDCARD_MODO_NORMAL;
242.         }
243.  
244.    #if defined(SDCARD_DEBUG)
245.       printf("\r\n--> Se envia CMD16 (Se fija largo del Bloque para escritura/lectura : %u)\r\n",BLOCK_SIZE);
246.    #endif
247.    // Se fija largo del bloque lectura/escitura.
248.    if(SDCard_send_command(CMD16,BLOCK_SIZE,&Respuesta)==0){
249.       return(0);
250.    }
251.    if(Respuesta.R1.Val!=0){
252.       return(0);
253.    }
254.  
255.    #if defined(SDCARD_DEBUG)
256.       printf("\r\n--> Se envia CMD59 (Desactivación de CRC)\r\n");
257.    #endif
258.    // Se desactiva CRC.
259.    if(SDCard_send_command(CMD59,0,&Respuesta)==0){
260.       return(0);
261.    }
262.    if(Respuesta.R1.Val!=0){
263.       return(0);
264.    }  
265.    SDDeselect();
266.    
267.    InitSPI(VELOCITY_SPI_HIGH);
268.    
269.    return(1);
270. }
271. //*******************************************************************************
272. BOOL SDCard_read_block(UINT32 Address,UINT8 *Buffer){
273.        
274.         SDCARD_RESPUESTA Respuesta;
275.         UINT8 TokenTmp;
276.         UINT16 i;
277.        
278.    // Se envia comando para leer bloque de bytes.-
279.    #if defined(SDCARD_DEBUG)
280.       printf("\r\n--> Se envia CMD17 (Lectura de bloque)\r\n");
281.    #endif
282.    SDSelect();
283.    if(SDCard_send_command(CMD17,Address,&Respuesta)==0){
284.       return(0);
285.    }
286.    if(Respuesta.R1.Val!=0){
287.       return(0);
288.    }  
289.    // Pasamos a esperar Token.
290.    i=0;
291.    do{
292.       TokenTmp=ReadMedia();
293.       i++;
294.    }while(TokenTmp==0xFF && i<SDCARD_TIMEOUT);// Mientras sea 0xFF.-
295.    if(i>=SDCARD_TIMEOUT){SDDeselect();return(0);}
296.    if((TokenTmp&0xE0)==0){ // Si se recibe 000xxxxx y no 0xFE.-
297.       SDDeselect();
298.       return(0);
299.    }
300.    #if defined(SDCARD_DEBUG)
301.       printf("Toquen recibido: 0x%X\r\n",TokenTmp);
302.    #endif
303.    // Todo ok, recibimos data.-
304.    for(i=0;i<BLOCK_SIZE;i++){
305.       *Buffer++=ReadMedia();
306.    }
307.    // Ignoramos CRC.-
308.    ReadMedia();
309.    ReadMedia();
310.    
311.    SDDeselect();
312.    #if defined(SDCARD_DEBUG)
313.       printf("Terminada la lectura\r\n");
314.    #endif
315.    return(1);  
316. }
317.  
318. //*******************************************************************************
319. BOOL SDCard_write_block(UINT32 Address,UINT8 *Buffer){ 
320.         SDCARD_RESPUESTA Respuesta;
321.         UINT8 ResTmp;
322.         UINT16 i;
323.        
324.    #if defined(SDCARD_DEBUG)
325.       printf("\r\n--> Se envia CMD24 (Escritura de bloque)\r\n");
326.    #endif
327.    SDSelect();
328.    // Se envia comando para escribir bloque de bytes.-
329.    if(SDCard_send_command(CMD24,Address,&Respuesta)==0){
330.       return(0);
331.    }
332.    if(Respuesta.R1.Val!=0){
333.       return(0);
334.    }
335.    #if defined(SDCARD_DEBUG)
336.       printf("Se envia Token (0xFE)\r\n");
337.    #endif
338.    // Enviamos Token.
339.    WriteMedia(0xFE);
340.    #if defined(SDCARD_DEBUG)
341.       printf("Se envia Bloque de datos\r\n");
342.    #endif
343.    // Enviamos data.-
344.    for(i=0;i<BLOCK_SIZE;i++){
345.       WriteMedia(*Buffer++);
346.    }
347.    // Ignoramos CRC.-
348.    WriteMedia(0xFF);
349.    WriteMedia(0xFF);
350.    // Esperamos respuesta.-
351.    i=0;
352.    do{
353.       ResTmp=ReadMedia();
354.       i++;
355.    }while(ResTmp==0xFF && i<SDCARD_TIMEOUT);// Mientras sea 0xFF.-
356.    if(i>=SDCARD_TIMEOUT){SDDeselect();return(0);}
357.    #if defined(SDCARD_DEBUG)
358.       printf("Respuesta de recepción del bloque: 0x%X  (***00101)\r\n",ResTmp);
359.    #endif
360.    if((ResTmp&0x1F)!=0x05){ // Si no se recibe ***00101.-
361.       SDDeselect();
362.       return(0);
363.    }
364.    // Esperamos a que baje la linea, indicando escritura completa.-
365.    while(ReadMedia()==0);
366.    #if defined(SDCARD_DEBUG)
367.       printf("Escritura Terminada\r\n");
368.    #endif
369.    SDDeselect();
370.    return(1);  
371. }
372. //*******************************************************************************
373. BOOL SDCard_read_CSD(void){
374.        
375.    SDCARD_RESPUESTA Respuesta;
376.    UINT8 TokenTmp, buf[16];  
377.    UINT16 i;
378.    
379.    #if defined(SDCARD_DEBUG)
380.       printf("\r\n--> Se envia CMD9 (Lectura de CSD)\r\n");
381.    #endif
382.    SDSelect();
383.    if(SDCard_send_command(CMD9,0,&Respuesta)==0){
384.       return(0);
385.    }else if(Respuesta.R1.Val!=0){
386.       return(0);
387.    }
388.    // Pasamos a esperar Token.
389.    i=0;
390.    do{
391.       TokenTmp=ReadMedia();
392.       i++;
393.    }while(TokenTmp==0xFF && i<SDCARD_TIMEOUT);// Mientras sea 0xFF.-
394.    if(i>=SDCARD_TIMEOUT){SDDeselect();return(0);}
395.    if((TokenTmp&0xE0)==0){ // Si se recibe 000xxxxx y no 0xFE.-
396.       SDDeselect();
397.       return(0);
398.    }
399.    #if defined(SDCARD_DEBUG)
400.       printf("Toquen recibido: 0x%X\r\n",TokenTmp);
401.    #endif
402.    // Todo ok, recibimos data.-
403.    for(i=0;i<16;i++){
404.       buf[i]=ReadMedia();
405.    }
406.    SDDeselect();
407.    
408.    #if defined(SDCARD_DEBUG)
409.    printf("\r\nCSD_STRUCTURE: %X", (buf[0] & 0x0C) >> 2);
410.    printf("\r\nTAAC: %X", buf[1]);
411.    printf("\r\nNSAC: %X", buf[2]);
412.    printf("\r\nTRAN_SPEED: %X", buf[3]);
413.    printf("\r\nCCC: %lX", ((((unsigned char)(buf[4])<<8)+ buf[5]) & 0xFFF0) >> 4);
414.    printf("\r\nREAD_BL_LEN: %X", buf[5] & 0x0F);  
415.    printf("\r\nREAD_BL_PARTIAL: %X", (buf[6] & 0x80) >> 7);
416.    printf("\r\nWRITE_BLK_MISALIGN: %X", (buf[6] & 0x40) >> 6);
417.    printf("\r\nREAD_BLK_MISALIGN: %X", (buf[6] & 0x20) >> 5);
418.    printf("\r\nDSR_IMP: %X", (buf[6] & 0x10) >> 4);
419.    printf("\r\nC_SIZE: %lX", (((buf[6] & 0x03) << 10) | (buf[7] << 2) | ((buf[8] & 0xC0) >> 6)));
420.    printf("\r\nVDD_R_CURR_MIN: %X", (buf[8] & 0x38) >> 3);
421.    printf("\r\nVDD_R_CURR_MAX: %X", buf[8] & 0x07);
422.    printf("\r\nVDD_W_CURR_MIN: %X", (buf[9] & 0xE0) >> 5);
423.    printf("\r\nVDD_W_CURR_MAX: %X", (buf[9] & 0x1C) >> 2);
424.    printf("\r\nC_SIZE_MULT: %X", ((buf[9] & 0x03) << 1) | ((buf[10] & 0x80) >> 7));
425.    printf("\r\nERASE_BLK_EN: %X", (buf[10] & 0x40) >> 6);
426.    printf("\r\nSECTOR_SIZE: %X", ((buf[10] & 0x3F) << 1) | ((buf[11] & 0x80) >> 7));
427.    printf("\r\nWP_GRP_SIZE: %X", buf[11] & 0x7F);
428.    printf("\r\nWP_GRP_ENABLE: %X", (buf[12] & 0x80) >> 7);
429.    printf("\r\nR2W_FACTOR: %X", (buf[12] & 0x1C) >> 2);
430.    printf("\r\nWRITE_BL_LEN: %X", ((buf[12] & 0x03) << 2) | ((buf[13] & 0xC0) >> 6));
431.    printf("\r\nWRITE_BL_PARTIAL: %X", (buf[13] & 0x20) >> 5);
432.    printf("\r\nFILE_FORMAT_GRP: %X", (buf[14] & 0x80) >> 7);
433.    printf("\r\nCOPY: %X", (buf[14] & 0x40) >> 6);
434.    printf("\r\nPERM_WRITE_PROTECT: %X", (buf[14] & 0x20) >> 5);
435.    printf("\r\nTMP_WRITE_PROTECT: %X", (buf[14] & 0x10) >> 4);
436.    printf("\r\nFILE_FORMAT: %X", (buf[14] & 0x0C) >> 2);
437.    printf("\r\nCRC: %X\r\n", buf[15]);
438.    #endif
439.    return(1);
440. }
441. //*******************************************************************************
442. BOOL SDCard_read_CID(void){
443.        
444.    SDCARD_RESPUESTA Respuesta;
445.    UINT8 TokenTmp, buf[16];  
446.    UINT16 i;
447.    
448.    #if defined(SDCARD_DEBUG)
449.       printf("\r\n--> Se envia CMD10 (Lectura de CID)\r\n");
450.    #endif
451.    SDSelect();
452.    if(SDCard_send_command(CMD10,0,&Respuesta)==0){
453.       return(0);
454.    }else if(Respuesta.R1.Val!=0){
455.       return(0);
456.    }
457.    // Pasamos a esperar Token.
458.    i=0;
459.    do{
460.       TokenTmp=ReadMedia();
461.       i++;
462.    }while(TokenTmp==0xFF && i<SDCARD_TIMEOUT);// Mientras sea 0xFF.-
463.    if(i>=SDCARD_TIMEOUT){SDDeselect();return(0);}
464.    if((TokenTmp&0xE0)==0){ // Si se recibe 000xxxxx y no 0xFE.-
465.       SDDeselect();
466.       return(0);
467.    }
468.    #if defined(SDCARD_DEBUG)
469.       printf("Toquen recibido: 0x%X\r\n",TokenTmp);
470.    #endif
471.    // Todo ok, recibimos data.-
472.    for(i=0;i<16;i++){
473.       buf[i]=ReadMedia();
474.    }
475.    SDDeselect();
476.    
477.    #if defined(SDCARD_DEBUG)
478.    printf("\r\nManufacturer ID: %X", buf[0]);
479.    printf("\r\nOEM/Application ID: %c%c", buf[1], buf[2]);
480.    printf("\r\nProduct Name: %c%c%c%c%c", buf[3], buf[4], buf[5], buf[6], buf[7]);
481.    printf("\r\nProduct Revision: %X", buf[8]);
482.    printf("\r\nSerial Number: %X%X%X%X", buf[9], buf[10], buf[11], buf[12]);
483.    printf("\r\nManufacturer Date Code: %X%X", buf[13] & 0x0F, buf[14]);
484.    printf("\r\nCRC-7 Checksum: %X\r\n", buf[15]);
485.    #endif
486.    return(1);
487. }

[Suky]

El debug para una memoria HC de 8Gb:

--> Se inicia sincronizacion                                                                                                                                                                                                                       
                                                                                                                                                                                                                                                   
--> Se envia CMD0 (Se desactiva SD Card)                                                                                                                                                                                                           
                                                                                                                                                                                                                                                   
Repeticiones para respuesta de CmdXX: 1; Respuesta recibida:127                                                                                                                                                                                     
--> Se envia CMD8                                                                                                                                                                                                                                   
Repeticiones para respuesta de CmdXX: 2; Respuesta recibida:1,0x1AA                                                                                                                                                                                 
--> Se envia CMD55/ACMD41 (Se activa SD Card)                                                                                                                                                                                                       
Repeticiones para respuesta de CmdXX: 2; Respuesta recibida:1                                                                                                                                                                                       
Repeticiones para respuesta de CmdXX: 2; Respuesta recibida:1                                                                                                                                                                                       
Repeticiones para respuesta de CmdXX: 2; Respuesta recibida:1                                                                                                                                                                                       
Repeticiones para respuesta de CmdXX: 2; Respuesta recibida:0                                                                                                                                                                                       
--> Se envia CMD58                                                                                                                                                                                                                                 
Repeticiones para respuesta de CmdXX: 2; Respuesta recibida:0,0xC0FF8000                                                                                                                                                                           
        > SD Card modo HC                                                                                                                                                                                                                           
                                                                                                                                                                                                                                                   
--> Se envia CMD16 (Se fija largo del Bloque para escritura/lectura : 512)                                                                                                                                                                         
Repeticiones para respuesta de CmdXX: 2; Respuesta recibida:0                                                                                                                                                                                       
                                                                                                                                                                                                                                                   
--> Se envia CMD59 (Desactivaci n de CRC)                                                                                                                                                                                                           
Repeticiones para respuesta de CmdXX: 2; Respuesta recibida:0                                                                                                                                                                                       
                                                                                                                                                                                                                                                   
--> Se envia CMD9 (Lectura de CSD)                                                                                                                                                                                                                 
Repeticiones para respuesta de CmdXX: 2; Respuesta recibida:0                                                                                                                                                                                       
Toquen recibido: 0xFE                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                   
CSD_STRUCTURE: 0                                                                                                                                                                                                                                   
TAAC: E                                                                                                                                                                                                                                             
NSAC: 0                                                                                                                                                                                                                                             
TRAN_SPEED: 32                                                                                                                                                                                                                                     
CCC: 60010                                                                                                                                                                                                                                         
READ_BL_LEN: 9                                                                                                                                                                                                                                     
READ_BL_PARTIAL: 0                                                                                                                                                                                                                                 
WRITE_BLK_MISALIGN: 0                                                                                                                                                                                                                               
READ_BLK_MISALIGN: 0                                                                                                                                                                                                                               
DSR_IMP: 0                                                                                                                                                                                                                                         
C_SIZE: 10                                                                                                                                                                                                                                         
VDD_R_CURR_MIN: 7                                                                                                                                                                                                                                   
VDD_R_CURR_MAX: 3                                                                                                                                                                                                                                   
VDD_W_CURR_MIN: 2                                                                                                                                                                                                                                   
VDD_W_CURR_MAX: 3                                                                                                                                                                                                                                   
C_SIZE_MULT: 6                                                                                                                                                                                                                                     
ERASE_BLK_EN: 1                                                                                                                                                                                                                                     
SECTOR_SIZE: 7F                                                                                                                                                                                                                                     
WP_GRP_SIZE: 0                                                                                                                                                                                                                                     
WP_GRP_ENABLE: 0                                                                                                                                                                                                                                   
R2W_FACTOR: 2                                                                                                                                                                                                                                       
WRITE_BL_LEN: 9                                                                                                                                                                                                                                     
WRITE_BL_PARTIAL: 0                                                                                                                                                                                                                                 
FILE_FORMAT_GRP: 0                                                                                                                                                                                                                                 
COPY: 0                                                                                                                                                                                                                                             
PERM_WRITE_PROTECT: 0                                                                                                                                                                                                                               
TMP_WRITE_PROTECT: 0                                                                                                                                                                                                                               
FILE_FORMAT: 0                                                                                                                                                                                                                                     
CRC: 4B                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                                   
--> Se envia CMD10 (Lectura de CID)                                                                                                                                                                                                                 
Repeticiones para respuesta de CmdXX: 2; Respuesta recibida:0                                                                                                                                                                                       
Toquen recibido: 0xFE                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                   
Manufacturer ID: 2                                                                                                                                                                                                                                 
OEM/Application ID: TM                                                                                                                                                                                                                             
Product Name: SA08G                                                                                                                                                                                                                                 
Product Revision: 6                                                                                                                                                                                                                                 
Serial Number: 226E644C                                                                                                                                                                                                                             
Manufacturer Date Code: 0AC                                                                                                                                                                                                                         
CRC-7 Checksum: C3

NOTA: La librería de Microchip, al detectar una memoria que posiblemente es V2.x envía el comando CMD1 o SEND_OP_COND. En mi caso, memoria 8gB Kingston, responde a eso como comando no valido (no se inicializa), así que lo reemplace por el par CMD55 y ACMD41  Revisar ese detalle al usarla 


Saludos!

[RICHI777]

Hola Suky se ve que estamos sintonizados, justamente estoy agregando algunas funciones a Micrologger, pero sigo sin soportar la tarjetas de alta capacidad porque no soporto FAT32

Saludos !

[Suky]

  La idea era, si hay tiempo, mejorar la librería de FAT y agregarle FAT32. También me sirvió para hacer funcionar la de Microchip, pero esta última consume bastantes recursos  


Saludos!

[mikepic]

Gracias como siempre por tus aportes, Suky.

Entiendo entonces que tu nueva librería sirve, tanto para SD como para SDHC?

Gracias

[rroque]

hola a la gentita del foro!!!!! ^^

Una consulta la ultima libreria que posteo suky, fue probada en ccs?¿

Saludos

[Suky]

Yo por lo menos no la probé  Te dio algún inconveniente?


Saludos!

[rroque]

Sorry por la gran demora en responder, pero me salio una chamba y me dedique a lo otro, pero ahora si lo retomo ^^, abri tu programa en PCW CCS y lo compile sin ningun problema y corre normal en el proteus, pero una consulta con respecto al crystal, puedeo utilizar un oscilador TTL Half can de 20MHz eso funcionan a 3,3V pero el pic que utilizo es el 18f2550?¿?¿?¿ te pregunto esto dado que lo quiero probar en proto y no quiero quemar el pic, xq lo probe con 4MHz y el pic murio:(

Saludos

[Suky]

Si, seguro, mientras realices las configuraciones adecuadas, ningún problema 

[rroque]

Bueno probe con ese oscilador de 20MHz y si funciona en cierta forma por que la salida serial veo esto:




******* 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,


Pero me doy cuenta que solo es lo que el programa principal tiene para compiar, xq esto sale teniendo al memoria conectada y desconectada. Y no sale la parte del SDCard.... , ademas estoy utilizando el hardware que recomendaste con las resistencias de 18K y 33K. Sera tema de hardware por lo que no puedo la info tal como sale en el proteus?¿?¿

Todo esto lo probe en protoboard.....

Saludos!!!!

[Suky]

Para el divisor resistivo utiliza mejor resistencias de 1.5k y 3.3k, para altas frecuencias funciona mejor. Lo que sería bueno es que bajes la ultima versión, por aquí

Por aquí tienes unos ejemplos de como usar FAT.


Saludos!