ASM51

Problema cabeludo para quem tem poucos cabelos:

Tenho dois Pendrives , um de 1Giga e o outro de 256Mega, ambos formatados em FAT32.

Na minha placa com o LPC1768, criei os recursos e telas para listar o conteúdo do pendrive no display, ler arquivos no pendrive e gravar arquivos no pendrive.

Acontece que, com o pendrive de 1Giga, eu não consigo abrir nenhum arquivo presente no pendrive, apesar desse arquivo ter sido listado.

Só consigo gravar arquivos.

Porém, com o pendrive de 256Mega, consigo ler e gravar os arquivos no pendrive.

Que maldição será essa?

.

Acho que a FAT do pen driver de 1G está corrompida, consegue operar ele no PC? Já aconteceu com PC com HDs defeituosos comigo.

mastk escreveu:Acho que a FAT do pen driver de 1G está corrompida, consegue operar ele no PC? Já aconteceu com PC com HDs defeituosos comigo.

Pensei nisso também, o Windows fez uma analise e não encontrou nenhum problema de partição ou arquivo corrompido.

Não seria os clusters que são maiores do que o seu software suporta? tem RAM o suficiente para lidar com FAT32? Já testou outros Pen drivers do mesmo tamanho ou maiores?

Qual código/driver do File System que está sendo usado?

tronico escreveu:Qual código/driver do File System que está sendo usado?

FatFs - FAT file system module R0.07e ChaN, 2009.

Esse file system do Chan é famoso. Putz agora que eu vi. Estou usando uma versao de 2009.

Vou atualizar.

Junior naquela epoca, eu testava com pendrive de 4GB e funcionava perfeitamente, tanto escrita quanto leitura.
Tu num mecheu em nada que não devia ai não eim !?!?!?
Que istrange !!!

Fabim

fabim escreveu:Junior naquela epoca, eu testava com pendrive de 4GB e funcionava perfeitamente, tanto escrita quanto leitura.
Tu num mecheu em nada que não devia ai não eim !?!?!?
Que istrange !!!

Fabim

Naquela época eu testava com pendrive de 256M pois era o unico que eu tinha.

O estranho é que, com o de 256M eu consido ler e escrever mas com o de 1G eu só consigo escrever.

Ei sei que o que eu vou falar vai gerar vários xingamentos:
Cria uma programinha besta que só escreve em um dos arquivos que a tua aplicação não está conseguindo escrever. Roda ele com o depurador e vai executando passo-a-passo, aí vê se alguma das funções de acesso a mídia não está tendo erro ao acessar a memória de massa.
Veja bem, escrevi várias palavras acima que não dizem nada, logo, sou f&d*.

Aquino escreveu:Ei sei que o que eu vou falar vai gerar vários xingamentos:
Cria uma programinha besta que só escreve em um dos arquivos que a tua aplicação não está conseguindo escrever. Roda ele com o depurador e vai executando passo-a-passo, aí vê se alguma das funções de acesso a mídia não está tendo erro ao acessar a memória de massa.
Veja bem, escrevi várias palavras acima que não dizem nada, logo, sou f&d*.

Grande Aquino, para escrever num arquivo eu teria que abri-lo antes. Quando tento isso, a função retorna o código de erro denominado File Disk Error.

Eu uso essa lib que tu falou e hoje mesmo liberei uma placa com cartão de 2GB.
Então, se não chega a abrir, o erro acontece aqui:

Código: Selecionar todos

FRESULT f_open (
   FIL *fp,         /* Pointer to the blank file object */
   const TCHAR *path,   /* Pointer to the file name */
   BYTE mode         /* Access mode and file open mode flags */
)
{
   FRESULT res;
   DIR dj;
   BYTE *dir;
   DEF_NAMEBUF;


   fp->fs = 0;         /* Clear file object */

#if !_FS_READONLY
   mode &= FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW;
   res = chk_mounted(&path, &dj.fs, (BYTE)(mode & ~FA_READ));
#else
   mode &= FA_READ;
   res = chk_mounted(&path, &dj.fs, 0);
#endif
   INIT_BUF(dj);
   if (res == FR_OK)
      res = follow_path(&dj, path);   /* Follow the file path */
   dir = dj.dir;

#if !_FS_READONLY   /* R/W configuration */
   if (res == FR_OK) {
      if (!dir)   /* Current dir itself */
         res = FR_INVALID_NAME;
#if _FS_SHARE
      else
         res = chk_lock(&dj, (mode & ~FA_READ) ? 1 : 0);
#endif
   }
   /* Create or Open a file */
   if (mode & (FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)) {
      DWORD dw, cl;

      if (res != FR_OK) {               /* No file, create new */
         if (res == FR_NO_FILE)         /* There is no file to open, create a new entry */
#if _FS_SHARE
            res = enq_lock(dj.fs) ? dir_register(&dj) : FR_TOO_MANY_OPEN_FILES;
#else
            res = dir_register(&dj);
#endif
         mode |= FA_CREATE_ALWAYS;      /* File is created */
         dir = dj.dir;               /* New entry */
      }
      else {                        /* Any object is already existing */
         if (dir[DIR_Attr] & (AM_RDO | AM_DIR)) {   /* Cannot overwrite it (R/O or DIR) */
            res = FR_DENIED;
         } else {
            if (mode & FA_CREATE_NEW)   /* Cannot create as new file */
               res = FR_EXIST;
         }
      }
      if (res == FR_OK && (mode & FA_CREATE_ALWAYS)) {   /* Truncate it if overwrite mode */
         dw = get_fattime();               /* Created time */
         ST_DWORD(dir+DIR_CrtTime, dw);
         dir[DIR_Attr] = 0;               /* Reset attribute */
         ST_DWORD(dir+DIR_FileSize, 0);      /* size = 0 */
         cl = LD_CLUST(dir);               /* Get start cluster */
         ST_CLUST(dir, 0);               /* cluster = 0 */
         dj.fs->wflag = 1;
         if (cl) {                     /* Remove the cluster chain if exist */
            dw = dj.fs->winsect;
            res = remove_chain(dj.fs, cl);
            if (res == FR_OK) {
               dj.fs->last_clust = cl - 1;   /* Reuse the cluster hole */
               res = move_window(dj.fs, dw);
            }
         }
      }
   }
   else {   /* Open an existing file */
      if (res == FR_OK) {                  /* Follow succeeded */
         if (dir[DIR_Attr] & AM_DIR) {      /* It is a directory */
            res = FR_NO_FILE;
         } else {
            if ((mode & FA_WRITE) && (dir[DIR_Attr] & AM_RDO)) /* R/O violation */
               res = FR_DENIED;
         }
      }
   }
   if (res == FR_OK) {
      if (mode & FA_CREATE_ALWAYS)         /* Set file change flag if created or overwritten */
         mode |= FA__WRITTEN;
      fp->dir_sect = dj.fs->winsect;         /* Pointer to the directory entry */
      fp->dir_ptr = dir;
#if _FS_SHARE
      fp->lockid = inc_lock(&dj, (mode & ~FA_READ) ? 1 : 0);
      if (!fp->lockid) res = FR_INT_ERR;
#endif
   }

#else            /* R/O configuration */
   if (res == FR_OK) {               /* Follow succeeded */
      if (!dir) {                  /* Current dir itself */
         res = FR_INVALID_NAME;
      } else {
         if (dir[DIR_Attr] & AM_DIR)   /* It is a directory */
            res = FR_NO_FILE;
      }
   }
#endif
   FREE_BUF();

   if (res == FR_OK) {
      fp->flag = mode;               /* File access mode */
      fp->sclust = LD_CLUST(dir);         /* File start cluster */
      fp->fsize = LD_DWORD(dir+DIR_FileSize);   /* File size */
      fp->fptr = 0;                  /* File pointer */
      fp->dsect = 0;
#if _USE_FASTSEEK
      fp->cltbl = 0;                  /* Normal seek mode */
#endif
      fp->fs = dj.fs; fp->id = dj.fs->id;   /* Validate file object */
   }

   LEAVE_FF(dj.fs, res);
}


Olhando a parte do código que gerar esse erro que tu falou, o problema está no tamanho dos variavel que aloca os ponteiros.
Mas olhei bem rápido e tal, não me culpe.
Eu uso assim, vê se é algo do tipo que tu usa:

Código: Selecionar todos

  FATFS fs;
  FIL arquivo;
  char buffer[50];
  unsigned int escritos;
  unsigned char hora,minuto,segundo,dia,mes;
  unsigned int ano;
   
  RTC_getValue(&hora,&minuto,&segundo,&dia,&mes,&ano);
 
  if(!f_mount(0,&fs)){
   
    f_open(&arquivo,PATH_ARQUIVO_LOG,FA_OPEN_ALWAYS | FA_READ | FA_WRITE);
                   
    f_lseek(&arquivo,f_size(&arquivo));           
   
    sprintf(buffer,"%d;%d;%d;%d:%d:%d;%d/%d/%d;",laco+1,ponto,grupo,hora,minuto,segundo,dia,mes,ano);       
    f_write(&arquivo,buffer,strlen(buffer),&escritos);
   
    unsigned char habilitado,setor;
   
    if(ponto)
      PARAMETROS_loadConfigPonto(laco,ponto,&habilitado,&setor,buffer);           
    else
      sprintf(buffer,"Alarme no analogico                     ");   
    buffer[40] = 0;
   
    f_write(&arquivo,buffer,40,&escritos);   
    f_write(&arquivo,"\n",strlen("\n"),&escritos);
    f_close(&arquivo);
   
    if(escritos)
      return 0;
  }               
  return 1; 


Por que você não debuga e descobre onde que ocorre o erro exatamente? Quando eu usei essa biblioteca achei os problemas debugando mesmo. De qualquer forma eu ja usei ela com pendrive de 8GB sem problemas, de varias marcas. Também usei com pendrives menores com FAT16...

Abs

Debugando o processo:

O programa passa pela função "f_open" sem problemas.
Depois é chamada a função "f_read".

Dentro dela existem um monte de chamada para outras funções, até chegar numa tal de "Host_ProcessTD" no arquivo <Usbhost_lpc17xx.c> Veja abaixo:

Código: Selecionar todos

**************************************************************************************************************
*                                     PROCESS TRANSFER DESCRIPTOR
*
* Description: This function processes the transfer descriptor
*
* Arguments  : ed            Endpoint descriptor that contains this transfer descriptor
*              token         SETUP, IN, OUT
*              buffer        Current Buffer Pointer of the transfer descriptor
*              buffer_len    Length of the buffer
*
* Returns    : OK       if TD submission is successful
*              ERROR    if TD submission fails
*
**************************************************************************************************************
*/

int32_t  Host_ProcessTD (volatile  HCED       *ed,
                         volatile  uint32_t  token,
                         volatile  uint8_t *buffer,
                              uint32_t  buffer_len)
{
    volatile  uint32_t   td_toggle;


    if (ed == EDCtrl) {
        if (token == TD_SETUP) {
            td_toggle = TD_TOGGLE_0;
        } else {
            td_toggle = TD_TOGGLE_1;
        }
    } else {
        td_toggle = 0;
    }
    TDHead->Control = (TD_ROUNDING    |
                      token           |
                      TD_DELAY_INT(0) |                           
                      td_toggle       |
                      TD_CC);
    TDTail->Control = 0;
    TDHead->CurrBufPtr   = (uint32_t) buffer;
    TDTail->CurrBufPtr   = 0;
    TDHead->Next         = (uint32_t) TDTail;
    TDTail->Next         = 0;
    TDHead->BufEnd       = (uint32_t)(buffer + (buffer_len - 1));
    TDTail->BufEnd       = 0;

    ed->HeadTd  = (uint32_t)TDHead | ((ed->HeadTd) & 0x00000002);
    ed->TailTd  = (uint32_t)TDTail;
    ed->Next    = 0;

    if (ed == EDCtrl) {
        LPC_USB->HcControlHeadED  = (uint32_t)ed;
        LPC_USB->HcCommandStatus |= OR_CMD_STATUS_CLF;
        LPC_USB->HcControl       |= OR_CONTROL_CLE;
    } else {
        LPC_USB->HcBulkHeadED     = (uint32_t)ed;
        LPC_USB->HcCommandStatus |= OR_CMD_STATUS_BLF;
        LPC_USB->HcControl       |= OR_CONTROL_BLE;
    }   

    Host_WDHWait();





O ERRO É GERADO NO TESTE ABAIXO
 


   if (!HOST_TDControlStatus) {
        return (OK);
    } else {     
        return (ERR_TD_FAIL);  <<<<<<----------
    }
}


Junior.
Aquela vez que estavamos mexendo nisso com o stuch, eu tinha visto um erro critico não me lembro aonde.
Tipo.
Existe um ponteiro em algum lugar ai que era uma INT, e não uma UNSIGNED INT.
E ele contava até +2GB e -2GB, e isso dava pau no cartão, ai o stuch trocou por um de 1GB e não dava o problema.
Era problema de estouro de ponteiro !!

Da uma verificada nas variaveis de apontamento, com certeza tem caquinha ai !!