Autor Tema: SDIO /FATFS para STM32F4  (Leído 384 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 2681
SDIO /FATFS para STM32F4
« en: 25 de Junio de 2017, 18:24:08 »
.

hola.
¿ Alguno habeis conseguido implementar con éxito un tarjetero SD con un STM32F4, usando SDIO y FATFS ?

Llevo unos días haciendo todo tipo de pruebas y no hay manera, de pesadilla. Uso Cubemx para configurarlo todo, y el fuente para leer/escribir lo he ido encontrado por varios sitios en internet.

Al final solo me funciona con algunas tarjetas micro SD de Kingston formateadas en FAT, son tarjetas de 2Gb y 4Gb. En mi placa en principio no iba nunca, active las resistencias de pullup internas para todas las lineas, y ya parecía que funcionaba, pero no siempre. Usando una Discovery con un tarjetero externo que lleva resistencias de pullup en todas sus lineas, funciona, pero solo con tarjetas Kingston.

En Cubemx selecciono SDIO y FATFS, eso genera todas las librerías incluidas las de acceso a bajo nivel (DISKIO).  El ruteo de la placa es correcto, según el pinout de las tarjetas micro SD para acceso por SDIO 4 bits paralelo. Además también he hecho pruebas con la Discovery y un tarjetero externo, con idénticos resultados.

1 ------ D2 ------- PC10
2 ------ D3 ------- PC11
3 ------ CMD ----- PD2
4 ------ +3.3v --- +3.3v
5 ------ CLK ------ PC12
6 ------ GND ----- GND
7 ------ D0 ------- PC8
8 ------ D1 ------- PC9




Y estos son los fuentes que he estado probando, para crear y leer un fichero de pruebas.

Variables públicas comunes en algunos ejemplos

Código: [Seleccionar]
FATFS SDFatFs; /* File system object for SD card logical drive */
FIL MyFile; /* File object */

FRESULT res; /* FatFs function common result code */
uint32_t byteswritten, bytesread; /* File write/read counts */




Código prueba1, crea un fichero con una linea de texto.

Código: [Seleccionar]
  FATFS fileSystem;
  FIL testFile;
  uint8_t testBuffer[16] = "SD write success";
  UINT testBytes;

  res = f_mount(&fileSystem, SD_Path, 1);

  if(f_mount(&fileSystem, SD_Path, 1) == FR_OK)
  {
    uint8_t path[13] = "testfile.txt";
    path[12] = '\0';

    res = f_open(&testFile, (char*)path, FA_WRITE | FA_CREATE_ALWAYS);
    res = f_write(&testFile, testBuffer, 16, &testBytes);
    res = f_close(&testFile);
   }



Código prueba2, crea dos ficheros con textos de pruebas.

Código: [Seleccionar]
  const char wtext[] = "Probando fichero1";
  const char wtext2[] = "Probando fichero2";
  // if(FATFS_LinkDriver(&SD_Driver, SDPath) == 0)
    //{
      if(f_mount(&SDFatFs, (TCHAR const*)SD_Path, 0) == FR_OK)
      {
        if(f_open(&MyFile, "Fichero1.txt", FA_CREATE_ALWAYS | FA_WRITE) == FR_OK)
        {
          if(f_write(&MyFile, wtext, sizeof(wtext), (void *)&byteswritten) == FR_OK);
          {
            f_close(&MyFile);
          }
        }
      }


      if(f_mount(&SDFatFs, (TCHAR const*)SD_Path, 0) == FR_OK)
      {
        if(f_open(&MyFile, "fichero2.txt", FA_CREATE_ALWAYS | FA_WRITE) == FR_OK)
        {
          if(f_write(&MyFile, wtext2, sizeof(wtext2), (void *)&byteswritten) == FR_OK);
          {
            f_close(&MyFile);
          }
        }
      }



Código prueba 3, rutinas de configuración, lectura y escritura por separado.

Código: [Seleccionar]
//*** FatFs, enlace logico SD disk I/O driver.
//** Esto es comun tanto para lectura como para escritura
   int errorescritura=0; // 0= fichero creado y escrito con exito,   1=Error al crear o escribir el fichero.
   int sinficheroconfig=0; // 0= existe fichero config.txt,   1= no existe fichero config.txt
   int sintarjeta=0; // 0= hay tarjeta,  1= no hay tarjeta SD
   //if(retSD == 0)
   if(FATFS_LinkDriver(&SD_Driver, SDPath) == 0)
     {
  //2- Register the file system object to the FatFs module
  if(f_mount(&SDFatFs, (TCHAR const*)SD_Path, 0) != FR_OK)
     {
  //FatFs Initialization Error
  sintarjeta=1; // Error, no hay tarjeta insertada
     }
     } else {
           sintarjeta=2; // Error, no hay tarjeta insertada
            }


 //**** Rutina de lectura del fichero *****
  if (sintarjeta==0) // hay tarjeta insertada, la lee
  {
   //7- Open the text file object with read access
       if(f_open(&MyFile, "config.txt", FA_READ) != FR_OK)
        {
      sinficheroconfig = 1; // no existe fichero config.txt o esta dañado
      //'Hello.txt' file Open for read Error
        } else {
             //8- Read data from the text file
             res = f_read(&MyFile, rtext, sizeof(wtext), &bytesread);
          if((res != FR_OK)) // comprueba si ha leido con exito
            {
           sinficheroconfig = 1; // no existe fichero config.txt o esta dañado (o vacio)
           //'Hello.txt' file Read or EOF Error
            } else {
            //Successful read
            //9- Close the open text file
            f_close(&MyFile);
                   }
          }
  }



//*** Rutina escritura, crea fichero config.txt si no existe, con configuración por omisión, chequea que haya una tarjeta
  if (sinficheroconfig==1 && sintarjeta==0)
    {
       const char wtext[] = "Hola Mundo"; // texto de pruebas para Debug
       //1- FatFS: Link the SD disk I/O driver
        if(sintarjeta == 0)
        {
            //4- Create & Open a new text file object with write access
               if(f_open(&MyFile, "config.txt", FA_CREATE_ALWAYS | FA_WRITE) !=FR_OK) // Crea fichero y lo abre
                 {
              sintarjeta=1; // Error, no puede crear el fichero, falta tarjeta, esta dañada o no la puede escribir
                  } else {
                         //5- Write data to the text file
                           res = f_write(&MyFile, wtext, sizeof(wtext), (void*)&byteswritten); // escribe texto de pruebas
                           if((byteswritten == 0) || (res != FR_OK))
                        {
                              errorescritura=1; // Error al intentar grabar en el fichero config.txt
                           //'Hello.txt' file Write or EOF Error
                             } else {
                               //6- Successful open/write
                               //HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_RESET);
                               f_close(&MyFile); // Fichero grabado con exito
                                }
                         }
            }
   }


//10- Unlink the micro SD disk I/O driver ****
// Desconecta tarjeta micro SD ***************
    FATFS_UnLinkDriver(SD_Path);

 





« Última modificación: 25 de Junio de 2017, 18:30:55 por planeta9999 »

Desconectado elgarbe

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2172
Re:SDIO /FATFS para STM32F4
« Respuesta #1 en: 25 de Junio de 2017, 20:47:51 »
Nunca he usado SDIO. Yo tengo varias aplicaciones con FatFS pero con SPI.

sds.
-
Leonardo Garberoglio

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 2681
Re:SDIO /FATFS para STM32F4
« Respuesta #2 en: 25 de Junio de 2017, 20:49:47 »
.

He estado probando con un montón de tarjetas micro SD de varios fabricantes, y definitivamente solo me funciona con Kingston y Acpi. Con el resto, la mayoría Trascend, Sandisk e Innodisk, no me funciona.

La capacidad de la tarjeta tampoco influye, de 2GB y 4GB Kingston y Acpi funciona perfectamente. Todas las tarjetas, las que me van y las que no las puedo leer y grabar sin problemas en el lector de tarjetas del PC, y tambien las uso sin problemas con una placa mía que las lee por SPI, las que fallan solo lo hacen cuando las intento leer/escribir por SDIO 4 bits.

Por si era problemas de las librerías de Cube, que tienen fama de estar plagadas de bugs, he probado otro aplicativo desarrollado en Coocox, y lo mismo, solo funciona con tarjetas SD de Kingston o Acpi.
« Última modificación: 25 de Junio de 2017, 20:54:22 por planeta9999 »

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 2681
Re:SDIO /FATFS para STM32F4
« Respuesta #3 en: 25 de Junio de 2017, 20:51:32 »
Nunca he usado SDIO. Yo tengo varias aplicaciones con FatFS pero con SPI.

sds.

A mi por SPI me van también, solo me fallan por SDIO a 4 bits segun marca de la tarjeta. Quería probar SDIO con acceso a 4 bits porque la lectura/escritura debe de ser mucho más rápida, y para algunos proyectos que tengo a la vista, necesito un acceso muy rápido.

Para el proyecto actual, o lo rediseño para acceso por SPI o lo dejo por SDIO 4bit y que el cliente use solo tarjetas Kingston.
« Última modificación: 25 de Junio de 2017, 20:53:39 por planeta9999 »

Desconectado vixctor

  • PIC16
  • ***
  • Mensajes: 103
Re:SDIO /FATFS para STM32F4
« Respuesta #4 en: 25 de Junio de 2017, 21:10:09 »
Hola planeta9999, permiteme darte 2 sugerencias:

Cuando hice FAT32 para tarjetas uSD, tienes que tener en cuanta si son SD, SDH o SDHC, ya que entre ellas los comandos cambian.

- Esta sugerencia es porqué estás usando tarjetas de 2 a 4 GB de capacidad, para tamaños mayores practicamente todas son SDHC

Por otro lado, tambien use tarjetas de muchas marcas, y resulta que las Kingston son las mas LENTAS, tal que rara vez exceden los 4Mb/seg

Puede ser qué las tarjetas kinsgton te funcionen precisamente por ser las más lentas....

Pero bueno, es solo un par de observaciones...

Saludos

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 2681
Re:SDIO /FATFS para STM32F4
« Respuesta #5 en: 25 de Junio de 2017, 21:21:31 »
Hola planeta9999, permiteme darte 2 sugerencias:
Cuando hice FAT32 para tarjetas uSD, tienes que tener en cuanta si son SD, SDH o SDHC, ya que entre ellas los comandos cambian.

- Esta sugerencia es porqué estás usando tarjetas de 2 a 4 GB de capacidad, para tamaños mayores practicamente todas son SDHC

Por otro lado, tambien use tarjetas de muchas marcas, y resulta que las Kingston son las mas LENTAS, tal que rara vez exceden los 4Mb/seg
Puede ser qué las tarjetas kinsgton te funcionen precisamente por ser las más lentas....

Pero bueno, es solo un par de observaciones...
Saludos


Gracias por los consejos.

En eso me fijé tambien, y no parece ser el problema, tengo SD y SDHC, tanto de Kingston como de otras marcas, y solo las Kingston y las Acpi funcionan, independientemente de que sean SD o SDHC.

En cuanto a la velocidad de acceso, ya probé a modificar la frecuencia del oscilador de la señal de reloj para las tarjetas, entre 400Khz y 24Mhz, y no cambia nada.

A que mala hora decidí probar SDIO, por SPI ya tendría el proyecto encarrilado y dedicándome a otras cosas, llevo días con la KK esta del SDIO. Lo único bueno es que para proyectos futuros, si lo resuelvo, me vendrá muy bien, pero para el diseño actual me está retrasando una barbaridad. Y si tengo que cambiar el PCB, a esperar una semana a recibir la nueva placa y el cliente está que echa chispas.

Además en mi placa, no puse resistencias de pullup, y no funciona, lo hace pero no de manera estable si activo las resistencias de pullup internas del chip. Probando en la Discovery con un tarjetero externo que si tiene resistencias de pullup en todas las lineas, si que funciona, pero solo con Kingston y Acpi.

« Última modificación: 25 de Junio de 2017, 21:30:04 por planeta9999 »

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 2681
Re:SDIO /FATFS para STM32F4
« Respuesta #6 en: 26 de Junio de 2017, 02:14:52 »
.

Bueno, con el último fuente que he probado, ya me va bien, siempre que use tarjetas micro SD o SDHC Kingston o Acpi, de 2/4GB. Lo voy a dejar así, le diré al cliente lo que hay, y ya está, tampoco es un drama poder usar únicamente tarjetas de estos dos fabricantes.

Mi placa la tengo sin resistencias de pullup físicas para las lineas del tarjetero, las activo internamente por software, y ya me va bien. Hace algún tiempo en otro post comentabamos sobre la necesidad de las resistencias de pullup en los tarjeteros SD, al menos por SDIO son imprescindibles o no funciona. Y sospecho que lo mismo por SPI, aunque se pueden activar internamente por software y nos evitamos tener que ponerlas físicamente en placa.

En resumen he generado el proyecto con CubeMx, eligiendo SDIO 4bit y FATFS. Luego he metido mi código en una función, usando las instrucciones de FATFS para montar el volumen SD, crear fichero, abrir fichero, cerrar fichero, leer fichero y escribir en el fichero.

Para el diseño en el que estoy trabajando ahora mismo, la velocidad de acceso al tarjetero SD no es importante, pero prefiero tener bien contralado el uso de SDIO y usarlo ya siempre en todos los diseños, total cuesta lo mismo, y para otros diseños si que puede ser importante tener una tasa de lectura/escritura muy superior a la que ofrece un tarjetero SD por SPI.

También voy a utilizar SDIO con los Kinetis MK66 y los SAM S70 para tarjeteros micro SD, ambos tienen implementado este puerto por hardware.
« Última modificación: 26 de Junio de 2017, 02:26:59 por planeta9999 »

Desconectado george.manson.69

  • PIC10
  • *
  • Mensajes: 23
    • Microcontroladores en General
Re:SDIO /FATFS para STM32F4
« Respuesta #7 en: 07 de Julio de 2017, 14:45:30 »
Hace una semana estuve programando algún ejemplo con FATfs con un microcontrolador PIC18, del cual me funciono dejando el código para exportarlo a otros microcontroladores.

http://www.mediafire.com/file/9kc4n78h5n1od7k/SDCard.X.rar

Utilizo MPLAB X,XC8, MCC y la libreria FATfs junto con una libreria que encontre en el internet para usar el diskio.

Solo creo un archivo delimitado por comas para que pueda usarse en Excel como tablas.

Código: [Seleccionar]
/**
  Generated Main Source File

  Company:
    Microchip Technology Inc.

  File Name:
    main.c

  Summary:
    This is the main file generated using PIC10 / PIC12 / PIC16 / PIC18 MCUs

  Description:
    This header file provides implementations for driver APIs for all modules selected in the GUI.
    Generation Information :
        Product Revision  :  PIC10 / PIC12 / PIC16 / PIC18 MCUs  - 1.45
        Device            :  PIC18F26K80
        Driver Version    :  2.00
    The generated drivers are tested against the following:
        Compiler          :  XC8 1.35
        MPLAB             :  MPLAB X 3.40
*/

/*
    (c) 2016 Microchip Technology Inc. and its subsidiaries. You may use this
    software and any derivatives exclusively with Microchip products.

    THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
    EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY IMPLIED
    WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A
    PARTICULAR PURPOSE, OR ITS INTERACTION WITH MICROCHIP PRODUCTS, COMBINATION
    WITH ANY OTHER PRODUCTS, OR USE IN ANY APPLICATION.

    IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
    INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
    WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS
    BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE
    FULLEST EXTENT ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN
    ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
    THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.

    MICROCHIP PROVIDES THIS SOFTWARE CONDITIONALLY UPON YOUR ACCEPTANCE OF THESE
    TERMS.
*/

#include "mcc_generated_files/mcc.h"


/* Private variables ---------------------------------------------------------*/
FATFS fs;         /* Work area (file system object) for logical drive */
FIL fsrc;         /* file objects */   
FRESULT res;
UINT br;

char path[512]="0:";
const uint8_t textFileBuffer[] = "TITULO,NOMBRE,APELLIDOS\t";   

/*******************************************************************************
* Function Name  : SD_TotalSize
* Description    : Îļþ¿Õ¼äÕ¼ÓÃÇé¿ö
* Input          : None
* Output         : None
* Return         : ·µ»Ø1³É¹¦ ·µ»Ø0ʧ°Ü
* Attention : None
*******************************************************************************/
int SD_TotalSize(void)
{
    FATFS *fs;
    DWORD fre_clust;       

    res = f_getfree("0:", &fre_clust, &fs);  /* ±ØÐëÊǸùĿ¼£¬Ñ¡Ôñ´ÅÅÌ0 */
    if ( res==FR_OK )
    {
  /* Print free space in unit of MB (assuming 512 bytes/sector) */
      printf("\r\n%d MB total drive space.\r\n"
           "%d MB available.\r\n",
           ( (fs->n_fatent - 2) * fs->csize ) / 2 /1024 , (fre_clust * fs->csize) / 2 /1024 );

  return 1;
}
else
  return 0;   
}
/*
                         Main application
 */
void main(void)
{

    // Initialize the device
    SYSTEM_Initialize();

    // If using interrupts in PIC18 High/Low Priority Mode you need to enable the Global High and Low Interrupts
    // If using interrupts in PIC Mid-Range Compatibility Mode you need to enable the Global and Peripheral Interrupts
    // Use the following macros to:

    // Enable high priority global interrupts
    //INTERRUPT_GlobalInterruptHighEnable();

    // Enable low priority global interrupts.
    //INTERRUPT_GlobalInterruptLowEnable();

    // Disable high priority global interrupts
    //INTERRUPT_GlobalInterruptHighDisable();

    // Disable low priority global interrupts.
    //INTERRUPT_GlobalInterruptLowDisable();

    // Enable the Global Interrupts
    //INTERRUPT_GlobalInterruptEnable();

    // Disable the Global Interrupts
    //INTERRUPT_GlobalInterruptDisable();

    // Enable the Peripheral Interrupts
    //INTERRUPT_PeripheralInterruptEnable();

    // Disable the Peripheral Interrupts
    //INTERRUPT_PeripheralInterruptDisable();
    if( _card_insert() == 0 )
    {
  printf("-- SD card detected OK \r\n");
    }
    else
    {
      printf("-- Please connect a SD card \r\n"     );
      while( _card_insert() != 0 );
      printf("-- SD card connection detected \r\n");
  __delay_ms(10);
    }
   
f_mount(&fs,"",0);

   
res = f_open( &fsrc , "Simple2.csv" , FA_CREATE_NEW | FA_WRITE | FA_OPEN_APPEND);

    if ( res == FR_OK )
    {
      /* Write buffer to file */
      res = f_write(&fsrc, textFileBuffer, sizeof(textFileBuffer), &br);     
 
      if(res == FR_OK){
     
        printf("Simple2.csv successfully created        %u\r\n",br);
       
      }else{
     
          printf("Simple2.csv successfully created with some Error        %u\r\n",res);
     
     
      }
   
      /*close file */
      f_close(&fsrc);     
    }
    else if ( res == FR_EXIST )
    {
  printf("Demo.TXT created in the disk      \r\n");
    }
    f_close(&fsrc);
    SD_TotalSize();
   
    f_mount(0,"",0);

    while(1)
    {
        // Add your application code
    }
}
/**
 End of File
*/



Lo bueno de este ejemplo es que pude usar una memoria SANDISK de 8GB, cuando compre una de 16 GB lo probare haber si funciona también.

Nota: Estoy usando la ultima versiond e FATfs ya que tenia otra con una version muy anterior y no me funcionaba la escritura del archivo en la memoria.

¡Saludos!

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 2681
Re:SDIO /FATFS para STM32F4
« Respuesta #8 en: 07 de Julio de 2017, 18:09:43 »

Lo bueno de este ejemplo es que pude usar una memoria SANDISK de 8GB, cuando compre una de 16 GB lo probare haber si funciona también.


El problema no es el código fuente, a mi por SPI también me va con todo tipo de tarjetas en FAT/FAT32 (2, 4, 8 y 16GB).

Cuando hay problemas, según marca de tarjeta, es al intentar hacer un acceso SDIO paralelo a 4 bits, en ese caso solo he conseguido que me funcione con tarjetas Kingston y Acpi.

Tengo el fuente bien depurado y me funcionan todas las funciones, montar volumen, apertura de fichero, lectura, escritura y formateo usando FATFS por SDIO, siempre que use esas dos marcas de tarjeta.
« Última modificación: 07 de Julio de 2017, 18:15:07 por planeta9999 »

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 2681
Re:SDIO /FATFS para STM32F4
« Respuesta #9 en: 20 de Julio de 2017, 13:49:37 »
.

Siguiendo con mis pruebas de la librería FATFS, resulta que con Kinetis me lee y escribe en todas las tarjetas, no entiendo porque con los STM32 solo me va con Kingston. Ahora ya no es un problema de la marca de la tarjeta, hay algo en la librería FATFS para los STM32 que me impide trabajar con ciertas marcas.

He cargado un sketch de Arduino para Teensy 3.6 (Kinetis MK66) que chequea la velocidad de lectura/escritura, y me ha parecido bastante buena. En la ventana, del Monitor Serie de Arduino, me saca estos datos en el test de lectura/escritura usando SDIO a 4 bit paralelo.

size,write,read
bytes,KB/sec,KB/sec
512,16733.97,18772.84
1024,17299.63,18907.91
2048,16544.37,19059.21
4096,17457.50,19161.74
8192,17373.19,19207.90
16384,17273.20,19231.19
32768,17166.38,19241.91

totalMicros 6508199
yieldMicros 209248
yieldCalls 180
yieldMaxUsec 1433
kHzSdClk 45000
Done


Creo que es mucho más de lo que se consigue por SPI (400 Kb/s ??), en esta prueba interpreto que me da una velocidad de lectura/escritura entre 16 y 19 Mb/s, con una señal de reloj al tarjetero, de 45Mhz. Me está gustando usar el tarjetero SD por SDIO 4 bit, las velocidades de lectura/escritura son muy altas, y para ciertas aplicaciones que tengo que hacer me va a venir muy bien, había pensado en usar una flash externa, pero creo que con el tarjetero SDIO a 4 bit me sobra.

Por otra parte, en el sketch de prueba, da dos opciones una usando DMA (SdFatSdio) y la otra sin DMA (SdFatSdioEX), no se todavía porqué solo funciona la versión sin DMA. Una pena, porque creo que con DMA es más rápido.


« Última modificación: 20 de Julio de 2017, 14:06:15 por planeta9999 »

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 5948
Re:SDIO /FATFS para STM32F4
« Respuesta #10 en: 20 de Julio de 2017, 14:10:02 »
Y por que no bajas directamente FatFs y lo pones? Me refiero a no exigir que sea el Cube o de donde sea que traiga esa libreria, vas a tener un modulo actualizado.

Creo que lo unico que lleva ademas del FATfs es el port, pero como son ARM los 2, a lo sumo puede llegar a cambiar los registros.
Tambien podrias verificar si existen diferencias entre los ports entre uno y otro. ( Diferencias de alguna opcion no implementada)

Desconectado planeta9999

  • Moderadores
  • DsPIC30
  • *****
  • Mensajes: 2681
Re:SDIO /FATFS para STM32F4
« Respuesta #11 en: 20 de Julio de 2017, 14:38:10 »
Y por que no bajas directamente FatFs y lo pones? Me refiero a no exigir que sea el Cube o de donde sea que traiga esa libreria, vas a tener un modulo actualizado.

Creo que lo unico que lleva ademas del FATfs es el port, pero como son ARM los 2, a lo sumo puede llegar a cambiar los registros.
Tambien podrias verificar si existen diferencias entre los ports entre uno y otro. ( Diferencias de alguna opcion no implementada)

Si, puedo tratar de bajar directamente la librería FATFS, en vez de usar la que carga Cube, lo que no se es si hará uso de DMA o es configurable (puede que ahí esté el problema). Hay algo que hace que me vaya en Kinetis con todas las marcas de tarjetas, y en STM32 solo funcione con Kingston, es algo muy raro, y no es la frecuencia de reloj, eso ya lo bajé y seguía fallando.

Probablemente hay algo de la parametrización de la FATFS, que no está bien en la implementación para los STM32, y está bien por omisión en los Kinetis.

Me leeré la información de la web de FATFS, a ver si descubro algo.