mcc_ccs.c

CCS FAT file systemp access

      ReadSector (actsector, gFiles[f].IOpuffer);
   
   
      pDir = (DIR*)(&(gFiles[f].IOpuffer[32 * gFAT32Vars.gFirstEmptyDirEntry]));
      gFiles[f].dirSector = actsector;
      gFiles[f].dirIdx = gFAT32Vars.gFirstEmptyDirEntry;
      
      GetDOSName (pDir, fname);
      
      pDir->bAttr = 0;
      actcl = FindFirstFreeCluster ();
      pDir->hCluster = actcl & 0xFFFF;
      pDir->hClusterH = actcl >> 16;
      
      SetClusterEntry (actcl, 0x0FFFFFFF);
      pDir->wSize = 0;
      gFiles[f].position = 0;
      pDir->hDate = GetCurrentDOSDate ();
      pDir->hTime = GetCurrentDOSTime ();
      
      WriteSector (actsector, gFiles[f].IOpuffer);
      memcpy (&(gFiles[f].DirEntry), pDir,32);
      
   return TRUE;
}

int32 ComposeCluster (char f)
{
   int32 retval;

   retval = gFiles[f].DirEntry.hClusterH;
   retval <<= 16;
   retval |= gFiles[f].DirEntry.hCluster;

   return retval;
}

char fopen (char *fname, char mode)
{
   char found;
      char f;
      int32 actsector;
      int32 actcluster;
      int32 nextcluster;
      char *filename;

      //if (input(CardInserted)) return 0xFF;
   
            
      filename = TryFile (fname, &f);

      if (filename == 0) return 0xFF;

      found = FALSE;
      found = FindDirEntry (filename,f);

      
      if (!found)
   {
         if (mode == 'r')
         {
            gFiles[f].Free = TRUE;
            return 0xFF;
         }
       else
      {
           if (! fcreate(f, filename)) return 0xFF;
            found = TRUE;
         }
      }
   
   if (found)
   {
         gFiles[f].Free = FALSE;
         gFiles[f].mode = mode;
         
         if  (mode == 'a') // com problemas
       {
           gFiles[f].position = gFiles[f].DirEntry.wSize;
           
            actcluster = ComposeCluster(f);
            
            while ((actcluster != 0x0FFFFFFF) && (nextcluster != 0))
           {
               nextcluster = GetNextCluster(actcluster);
                  
                  if ((nextcluster == 0x0FFFFFFF) || (nextcluster == 0)) break;
                  
                  actcluster = nextcluster;
            }
           
            actsector = actcluster + gFAT32Vars.gFirstDataSector;
            ReadSector (actsector, gFiles[f].IOpuffer);
            
            gFiles[f].CurrentCluster = actcluster;
            gFiles[f].posinsector = gFiles[f].position & 0x01FF;
            
            if ((gFiles[f].posinsector == 0) && (gFiles[f].position != 0))
            {
               gFiles[f].posinsector = 512;
         }   
         }
      
      else
      {
           gFiles[f].position = 0;
           
            actsector = ComposeCluster (f);
            actsector += gFAT32Vars.gFirstDataSector;
         ReadSector(actsector,gFiles[f].IOpuffer);
         
            gFiles[f].CurrentCluster = ComposeCluster (f);
            gFiles[f].posinsector = 0;
         }
      }
   
      return f;
}

void fclose (char f)
{
      if (f > (MAXFILES-1)) return;
      if ((gFiles[f].mode == 'a') || (gFiles[f].mode == 'w')) fflush(f);
      
      gFiles[f].Free = TRUE;
}

void fflush (char f)
{
   int32 actsector;
   DIR *pDir;

      if (f > (MAXFILES-1)) return;
   
      actsector = gFiles[f].CurrentCluster + gFAT32Vars.gFirstDataSector;
      WriteSector (actsector, gFiles[f].IOpuffer);
      ReadSector(gFiles[f].dirSector, gFiles[f].IOpuffer);
   
      pDir = (DIR*)(&(gFiles[f].IOpuffer[32 * gFiles[f].dirIdx]));
   
      if (gFiles[f].DirEntry.bAttr & 0x10) pDir->wSize = 0; // if it is a directory
      else pDir->wSize = gFiles[f].position;
   
      pDir->hDate = GetCurrentDOSDate ();
      pDir->hTime = GetCurrentDOSTime ();
      WriteSector(gFiles[f].dirSector,gFiles[f].IOpuffer);
      ReadSector(actsector, gFiles[f].IOpuffer);
}

char cwd (char *fname, char f)
{
   int32 actsector;

     if (f > (MAXFILES-1))
      {
      return FALSE; // just in case of overaddressing
      }
   
   if (IsSelfDir(fname))
      {
         return TRUE; // already in Root dir
      }   
      
      if (!FindDirEntry(fname,f))
      {
         return FALSE; // not found
      }

 
      actsector = ComposeCluster (f);
      actsector += gFAT32Vars.gFirstDataSector; // read current dir
      ReadSector (actsector, gFiles[f].IOpuffer);
      
      gFAT32Vars.gDirEntrySector = actsector;
      gFiles[f].dirSector = actsector;
      gFiles[f].CurrentCluster = ComposeCluster (f);
            
      return TRUE;
}

void fputch (char be, char f)
{
      int32 nextcluster;
      int32 actsector;

      if (f > (MAXFILES-1)) return;
      
      if (gFiles[f].posinsector == 512)
   {
       actsector = gFiles[f].CurrentCluster + gFAT32Vars.gFirstDataSector;
         WriteSector (actsector,gFiles[f].IOpuffer);
         
         nextcluster = FindFirstFreeCluster ();
     
       if ((nextcluster != 0x0FFFFFFF) && (nextcluster != 0))
      {
           SetClusterEntry (gFiles[f].CurrentCluster, nextcluster);
            SetClusterEntry (nextcluster, 0x0FFFFFFF);
            actsector = nextcluster + gFAT32Vars.gFirstDataSector;
            //ReadSector (actsector,gFiles[f].IOpuffer);  //-- nao tem a necessidade de ler o setor toda vez que for gravar um bloco
            gFiles[f].CurrentCluster = nextcluster;
            gFiles[f].posinsector = 0;
         }
      }
      
      gFiles[f].IOpuffer[gFiles[f].posinsector] = be;
      gFiles[f].posinsector++;
      gFiles[f].position++;

   return;      
}

void fputstring (char *be, char f)
{
   int16 leng;
   int16 i;

      if (f > (MAXFILES-1)) return;
   
      leng = strlen (be);
   
      for (i = 0; i < leng; i++)
       fputch (be[i], f);
   
}

int16 fread (char *buffer, int16 leng, char f)
{
   int16 i;
   int16 retv;
   char c;
   char v;

      if (f > (MAXFILES-1)) return 0;
      
      retv = 0;
      
      for (i = 0; i < leng; i++)
   {
       v = fgetch (&c, f);
       
         if (v)
        {
           buffer[i] = c;
            retv++;
         }
         
         else break;
      }
   
      return retv;
}

void fwrite (char *buffer, int16 leng, char f)
{
   int16 i;

      if (f > (MAXFILES-1)) return;
      
      for (i = 0; i < leng; i++)
       fputch (buffer[i],f);

}


char fgetch (char *ki, char f)
{
      int32 nextcluster;
      int32 actsector;

      if (f > (MAXFILES-1)) return FALSE;
      
      if (gFiles[f].position >= gFiles[f].DirEntry.wSize) return FALSE;
      
      *ki = gFiles[f].IOpuffer[gFiles[f].posinsector];
      
      gFiles[f].posinsector++;
      gFiles[f].position++;
   
   if (gFiles[f].posinsector == 512)
   {
       nextcluster = GetNextCluster (gFiles[f].CurrentCluster);
       
         if ((nextcluster != 0x0FFFFFFF) && (nextcluster != 0))
         {
            actsector = nextcluster + gFAT32Vars.gFirstDataSector;
            ReadSector (actsector,gFiles[f].IOpuffer);
            
            gFiles[f].CurrentCluster = nextcluster;
            gFiles[f].posinsector = 0;
         }
      }
   
      return TRUE;
}

char remove (char *fname)
{
      char i;
      char found;
      char f;
      DIR *pDir;
      int32 nextcluster;
      int32 currentcluster;
      char *filename;

      filename = TryFile (fname, &f);
      
      if (filename == 0) return FALSE;
      
      found = FindDirEntry (filename,f);
      
   if (!found)
   {
       gFiles[f].Free = TRUE;
       
       printf ("Arquivo n?o encontrado...\r\n");
         return FALSE;
      }
      
   
   
      pDir = (DIR*)(&(gFiles[f].IOpuffer[32 * gFAT32Vars.gDirEntryIdx]));
      pDir->sName[0] = 0xE5;
      
      for (i = 1; i < 8; i++)
      pDir->sName[i] = ' ';
      
      for (i = 0; i < 3; i++)
         pDir->spam[i] = ' ';
         
      WriteSector (gFAT32Vars.gDirEntrySector, gFiles[f].IOpuffer);
      currentcluster = ComposeCluster (f);
      
      while ((currentcluster != 0x0FFFFFFF) && (nextcluster != 0))
   {
       nextcluster = GetNextCluster (currentcluster);
         ClearClusterEntry (currentcluster);
          currentcluster = nextcluster;
      }
      
      ClearClusterEntry (currentcluster);
      SetClusterEntry (currentcluster, 0);
      currentcluster = gFAT32Vars.gStartSector + DiskInfo.Reserved1 + gFAT32Vars.FATstartidx;
      WriteSector (currentcluster, FATTable);
      currentcluster += DiskInfo.hSectorsPerFat;
      WriteSector (currentcluster, FATTable);
      gFiles[f].Free = TRUE;
   
      return TRUE;
}

char getfsize (char *fname, int32 *fsiz)
{
      char found;
      char f;
      DIR *pDir;
      char *filename;

      filename = TryFile (fname, &f);
      
      if (filename == 0) return FALSE;
      
      found = FindDirEntry (filename, f);
   
   if (!found)
   {
       gFiles[f].Free = TRUE;
       
         return FALSE;
      }
   
      pDir = (DIR*)(&(gFiles[f].IOpuffer[32 * gFAT32Vars.gDirEntryIdx]));
   
      gFiles[f].Free = TRUE;
      *fsiz = pDir->wSize;
   
      return TRUE;
}


MMCFAT32.h

Code:

/*******************************************************
 * ANDRE L. V. SILVA
 * [e-mail]
 *******************************************************/

#ifndef __MMCFat32_h__
#define __MMCFat32_h__



// user config. - change it for your desired pic
#byte PORTA_A          =    0xf80          // (PIC16F - 0x05) (PIC18F - 0xf80)
#byte PORTA_B          =   0xf81          // (PIC16F - 0x06) (PIC18F - 0xf81)
#byte PORTA_C          =   0xf82          // (PIC16F - 0x07) (PIC18F - 0xf82)

#byte TRIS_PORTA_A       =    0xf92    // (PIC16F - 0x85) (PIC18F - 0xf92)
#byte TRIS_PORTA_B       =   0xf93    // (PIC16F - 0x86) (PIC18F - 0xf93)
#byte TRIS_PORTA_C       =   0xf94    // (PIC16F - 0x87) (PIC18F - 0xf94)

#bit TRIS_SPI_SCK      =   TRIS_PORTA_C.3
#bit TRIS_SPI_SDI      =   TRIS_PORTA_C.4
#bit TRIS_SPI_SDO      =   TRIS_PORTA_C.5
#bit TRIS_SPI_MMC_CS   =   TRIS_PORTA_B.0
#bit TRIS_DETECTA_MMC   =   TRIS_PORTA_B.4

#bit MMC_CS          =    PORTA_B.0
#bit SPI_SCK          =    PORTA_C.3
#bit SPI_DI            =    PORTA_C.4
#bit SPI_DO            =    PORTA_C.5
#bit MMC_DETECT         =    PORTA_B.4


#byte SSPBUF     = 0xfc9  // (PIC16F - 0x13) (PIC18F - 0xfc9)
#byte SSPSTAT    = 0xfc7  // (PIC16F - 0x94) (PIC18F - 0xfc7)
#byte SSPCON1    = 0xfc6  // (PIC16F - 0x14) (PIC18F - 0xfc6)
#byte SSPCON2    = 0xfc5  // (PIC16F - 0x91) (PIC18F - 0xfc5)

/////////////////////////////////////////////////////////////

#bit  BF        = SSPSTAT.0   // flag that indicates traffic on SPI bus
#bit CKE        = SSPSTAT.6   // 1 = data exchange on HIGH to Idle, 0 on Idle to HIGH
#bit SMP        = SSPSTAT.7   // in Master mode let this bit set (sample at end), in slave mode this bit must be cleared 0   
#bit CKP      = SSPCON1.4   // clock polarity (1 = low, 0 = high)
#bit SSPEN       = SSPCON1.5   // 1 = spi mode, 0 = io mode

#define SPI_SLAVE_SS_DESABILITADO    0xf5
#define SPI_SLAVE_SS_HABILITADO    0xf4
#define SPI_MASTER_SCK_TMR2      0xf3
#define SPI_MASTER_SCK_DIV_64      0xf2
#define SPI_MASTER_SCK_DIV_16      0xf1
#define SPI_MASTER_SCK_DIV_4      0xf0

// timer 0 = 1 / 4000000 / 4 / 256 = 64us   (with pll, timer 0 uses 4MHZ clock ???)


#ifndef MAXFILES
#define MAXFILES 1
#endif

#ifndef SAIDA
#define SAIDA 0
#endif

#ifndef ENTRADA
#define ENTRADA 1
#endif

#define MINIMO 0
#define MEDIO  1
#define MAXIMO 2

#define SINAL 0

#define SALVAR 1
#define PARAR  0

#define TAMANHO_BLOCO    512
#define START_BYTE      0xfe


typedef struct 
{
   unsigned long     tm_year;
   char            tm_mon;
   char            tm_day;
   char            tm_mday;
   char            tm_hour;
   char            tm_min;
   char            tm_sec;
   
} TimeRecord;


TimeRecord myrec; // this variable is updated in regular intervals in DoIdle()

typedef struct _diskinforec
{
   char  hJumpCode[3];
   char  OEMName[8];
   int16 hBytesPerSector;
   char  bSectorsPerCluster;
   int16 Reserved1;
   char  FATCopies;
   int16 hMaxRootEntries;
   int16 hSectors;
   char  Descriptor;
   int16 holdSectorsPerFat;
   int16 hSectorsPerTrack;
   int16 hNumberofHeads;
   int32 hNumberofHidden;
   int32 hNumberofSectors;

   int32 hSectorsPerFat;
   int16 hFlags;
   int16 hFAT32Version;
   int32 hRootStartCluster;
   
} diskinforec;

typedef struct _direntry
{
   char  sName[8];
   char  spam[3];
   char  bAttr;
   char  bReserved[8];
   int16 hClusterH;
   int16 hTime;
   int16 hDate;
   int16 hCluster;
   int32 wSize;
   
} DIR;

typedef struct _fileentry
{
   char    IOpuffer[512];
   DIR   DirEntry;
   int32 CurrentCluster;
   int16 posinsector;
   int32 position;
   int32 dirSector;
   int16 dirIdx;
   char  mode;
   char  Free;
   
} FILE;

typedef struct
{
   int32 MMCAddress;
   int32 FATstartidx;
   int32 gStartSector;
   int32 gFirstDataSector;
   int16 gDirEntryIdx;
   int32 gDirEntrySector;
   int16 gFirstEmptyDirEntry;
   int32 gFirstDirEntryCluster;
   
} FAT32Vars;


void InicializaSPI       (char Tipo);
void InicializaMMC       (void);
void SelecionaMMC        (boolean Flag);
void EnviaMMC         (char a);
char RecebeMMC         (void);
void MMC8Clock         (void);
void ReadSector         (int32 sector, char *buffer);
void WriteSector       (int32 sector, char *buffer);


char DetectaMMC (void);

void ExecutaCMD0    (void);
void ExecutaCMD1    (void);
void ExecutaCMD16    (void);
void ExecutaCMD10    (void);
void ExecutaCMD9    (void);
void ExecutaCMD6    (void);

void InicializaFAT32   ();
char FindDirEntry   (char *fname, char f);
char fopen         (char *fname, char mode);
void fclose         (char f);
void fflush         (char f);
char cwd         (char *fname, char f);
void fputch         (char be, char f);
char fgetch         (char *ki, char f);
void fputstring      (char *be, char f); // fputs is reserved in CCS C
int16 fread         (char *buffer, int16 leng, char f);
void fwrite         (char *buffer, int16 leng, char f);
char remove         (char *fname);
char getfsize      (char *fname, int32 *fsiz);

#endif