Multi Media Card Library
The Multi Media Card (MMC) is a Flash memory card standard. MMC cards are currently available in sizes up to and including 32 GB and are used in cellular phones, digital audio players, digital cameras and PDA’s.
mikroC PRO for PIC32 provides a library for accessing data on Multi Media Card via SPI communication. This library also supports SD (Secure Digital) and high capacity SDHC (Secure Digital High Capacity) memory cards .
Secure Digital Card
Secure Digital (SD) is a Flash memory card standard, based on the older Multi Media Card (MMC) format.
SD cards are currently available in sizes of up to and including 2 GB, and are used in digital cameras, digital camcorders, handheld computers, media players, mobile phones, GPS receivers, video games and PDAs.
Secure Digital High Capacity Card
SDHC (Secure Digital High Capacity, SD 2.0) is an extension of the SD standard which increases card's storage capacity up to 32 GB by using sector addressing instead of byte addressing in the previous SD standard.
SDHC cards share the same physical and electrical form factor as older (SD 1.x) cards, allowing SDHC-devices to support both newer SDHC cards and older SD-cards. The current standard limits the maximum capacity of an SDHC card to 32 GB.

- Routines for file handling can be used only with FAT16 file system.
- Library functions create and read files from the root directory only.
- Library functions populate both FAT1 and FAT2 tables when writing to files, but the file data is being read from the FAT1 table only; i.e. there is no recovery if the FAT1 table gets corrupted.
- If MMC/SD card has Master Boot Record (MBR), the library will work with the first available primary (logical) partition that has non-zero size. If MMC/SD card has Volume Boot Record (i.e. there is only one logical partition and no MBRs), the library works with entire card as a single partition. For more information on MBR, physical and logical drives, primary/secondary partitions and partition tables, please consult other resources, e.g. Wikipedia and similar.
- Before write operation, make sure you don’t overwrite boot or FAT sector as it could make your card on PC or digital camera unreadable. Drive mapping tools, such as Winhex, can be of a great assistance.
- Library uses SPI module for communication. The user must initialize the appropriate SPI module before using the MMC Library.
- For MCUs with multiple SPI modules it is possible to initialize all of them and then switch by using the
SPI_Set_Active()
function. See the SPI Library functions.
The SPI module has to be initialized through SPIx_Init_Advanced
routine with the following parameters:
- SPI Master
- 8bit mode
- secondary prescaler 1
- primary prescaler 64
- Slave Select disabled
- data sampled in the middle of data output time
- clock idle high
- Serial output data changes on transition from active clock state to idle clock state

Library Dependency Tree

External dependencies of MMC Library
The following variable must be defined in all projects using MMC library: | Description : | Example : |
---|---|---|
extern sfr atomic sbit Mmc_Chip_Select; |
Chip select pin. | sbit Mmc_Chip_Select at LATF0_bit; |
extern sfr atomic sbit Mmc_Chip_Select_Direction; |
Direction of the chip select pin. | sbit Mmc_Chip_Select_Direction at TRISF0_bit; |
Library Routines
- Mmc_Init
- Mmc_Read_Sector
- Mmc_Write_Sector
- Mmc_Read_Cid
- Mmc_Read_Csd
- Mmc_Multi_Read_Start
- Mmc_Multi_Read_Sector
- Mmc_Multi_Read_Stop
Routines for file handling:
- Mmc_Fat_Init
- Mmc_Fat_QuickFormat
- Mmc_Fat_Assign
- Mmc_Fat_Reset
- Mmc_Fat_Read
- Mmc_Fat_Rewrite
- Mmc_Fat_Append
- Mmc_Fat_Delete
- Mmc_Fat_Write
- Mmc_Fat_Set_File_Date
- Mmc_Fat_Get_File_Date
- Mmc_Fat_Get_File_Date_Modified
- Mmc_Fat_Get_File_Size
- Mmc_Get_File_Write_Sector
- Mmc_Fat_Get_Swap_File
- Mmc_Fat_Tell
- Mmc_Fat_Seek
- Mmc_Fat_Rename
- Mmc_Fat_MakeDir
- Mmc_Fat_RenameDir
- Mmc_Fat_RemoveDir
- Mmc_Fat_ChangeDir
- Mmc_Fat_Exists
- Mmc_Fat_Dir
- Mmc_Fat_ReadDir
- Mmc_Fat_Activate
- Mmc_Fat_ReadN
- Mmc_Fat_Open
- Mmc_Fat_Close
- Mmc_Fat_EOF
Mmc_Init
Prototype |
unsigned int Mmc_Init(); |
---|---|
Description |
Initializes MMC through hardware SPI interface. Mmc_Init needs to be called before using other functions of this library. |
Parameters |
None. |
Returns |
|
Requires |
The appropriate hardware SPI module must be previously initialized. Global variables :
|
Example |
// MMC module connections sbit Mmc_Chip_Select at LATF0_bit; sbit Mmc_Chip_Select_Direction at TRISF0_bit; // MMC module connections ... // Initialize the SPI module SPI1_Init_Advanced(_SPI_MASTER, _SPI_8_BIT, 64, _SPI_SS_DISABLE, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_HIGH, _SPI_ACTIVE_2_IDLE); // Loop until MMC is initialized while (Mmc_Init()) ; // Reinitialize the SPI module at higher speed (change primary prescaler). SPI1_Init_Advanced(_SPI_MASTER, _SPI_8_BIT, 8, _SPI_SS_DISABLE, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_HIGH, _SPI_ACTIVE_2_IDLE); |
Notes |
None. |
Mmc_Read_Sector
Prototype |
unsigned int Mmc_Read_Sector(unsigned long sector, char *dbuff); |
---|---|
Description |
The function reads one sector (512 bytes) from MMC card. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card must be initialized. See Mmc_Init. |
Example |
// read sector 510 of the MMC/SD card unsigned int error; unsigned long sectorNo = 510; char dataBuffer[512]; ... error = Mmc_Read_Sector(sectorNo, dataBuffer); |
Notes |
None. |
Mmc_Write_Sector
Prototype |
unsigned int Mmc_Write_Sector(unsigned long sector, char *dbuff); |
---|---|
Description |
The function writes 512 bytes of data to one MMC card sector. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card must be initialized. See Mmc_Init. |
Example |
// write to sector 510 of the MMC/SD card unsigned int error; unsigned long sectorNo = 510; char dataBuffer[512]; ... error = Mmc_Write_Sector(sectorNo, dataBuffer); |
Notes |
None. |
Mmc_Read_Cid
Prototype |
unsigned int Mmc_Read_Cid(char *data_cid); |
---|---|
Description |
The function reads 16-byte CID register. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card must be initialized. See Mmc_Init. |
Example |
unsigned int error; char dataBuffer[16]; ... error = Mmc_Read_Cid(dataBuffer); |
Notes |
None. |
Mmc_Read_Csd
Prototype |
unsigned int Mmc_Read_Csd(char *data_csd); |
---|---|
Description |
The function reads 16-byte CSD register. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card must be initialized. See Mmc_Init. |
Example |
unsigned int error; char dataBuffer[16]; ... error = Mmc_Read_Csd(dataBuffer); |
Notes |
None. |
Mmc_Multi_Read_Start
Prototype |
unsigned int Mmc_Multi_Read_Start(unsigned long sector); |
---|---|
Description |
The function starts multi read mode, sectors are sequentially read starting from the sector given in the function argument. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card must be initialized. See Mmc_Init. |
Example |
unsigned int error; char sector; ... error = Mmc_Multi_Read_Start(sector); |
Notes |
None. |
Mmc_Multi_Read_Sector
Prototype |
void Mmc_Multi_Read_Sector(char *dbuff); |
---|---|
Description |
The function reads sectors in multi read mode and places them in the buffer given as the function argument. Next function call reads the subsequent sector. Buffer size should be 512B. |
Parameters |
|
Returns |
Nothing. |
Requires |
MMC/SD card must be initialized. See Mmc_Init. |
Example |
unsigned int error; ... Mmc_Multi_Read_Sector(buffer); |
Notes |
None. |
Mmc_Multi_Read_Stop
Prototype |
unsigned int Mmc_Multi_Read_Stop(); |
---|---|
Description |
The function stops multi read mode sequence. |
Parameters |
None. |
Returns |
|
Requires |
MMC/SD card must be initialized. See Mmc_Init. |
Example |
Mmc_Multi_Read_Stop; |
Notes |
None. |
Mmc_Fat_Init
Prototype |
unsigned int Mmc_Fat_Init(); |
---|---|
Description |
Initializes MMC/SD card, reads MMC/SD FAT16 boot sector and extracts necessary data needed by the library. |
Parameters |
None. |
Returns |
|
Requires |
Global variables :
The appropriate hardware SPI module must be previously initialized. See the SPIx_Init, SPIx_Init_Advanced routines. |
Example |
// MMC module connections sbit Mmc_Chip_Select at LATF0_bit; sbit Mmc_Chip_Select_Direction at TRISF0_bit; // MMC module connections #include <spi_const.h> ... // Initialize the SPI module SPI1_Init_Advanced(_SPI_MASTER, _SPI_8_BIT, 64, _SPI_SS_DISABLE, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_HIGH, _SPI_ACTIVE_2_IDLE); // Loop until MMC is initialized while (Mmc_Init()) ; // Reinitialize the SPI module at higher speed (change primary prescaler). SPI1_Init_Advanced(_SPI_MASTER, _SPI_8_BIT, 8, _SPI_SS_DISABLE, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_HIGH, _SPI_ACTIVE_2_IDLE); |
Notes |
MMC/SD card has to be formatted to FAT16 file system. |
Mmc_Fat_QuickFormat
Prototype |
unsigned int Mmc_Fat_QuickFormat(char *mmc_fat_label); |
---|---|
Description |
Formats to FAT16 and initializes MMC/SD card. |
Parameters |
|
Returns |
|
Requires |
The appropriate hardware SPI module must be previously initialized. |
Example |
// Initialize the SPI module SPI1_Init_Advanced(_SPI_MASTER, _SPI_8_BIT, _SPI_PRESCALE_SEC_1, _SPI_PRESCALE_PRI_64, _SPI_SS_DISABLE, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_HIGH, _SPI_ACTIVE_2_IDLE); // Format and initialize MMC/SD card and MMC_FAT16 library globals Mmc_Fat_QuickFormat("mikroE"); // Reinitialize the SPI module at higher speed (change primary prescaler). SPI1_Init_Advanced(_SPI_MASTER, _SPI_8_BIT, _SPI_PRESCALE_SEC_1, _SPI_PRESCALE_PRI_4,_SPI_SS_DISABLE, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_HIGH, _SPI_ACTIVE_2_IDLE); |
Notes |
This routine can be used instead or in conjunction with Mmc_Fat_Init routine. If MMC/SD card already contains a valid boot sector, it will remain unchanged (except volume label field) and only FAT and ROOT tables will be erased. Also, the new volume label will be set. |
Mmc_Fat_Assign
Prototype |
unsigned int Mmc_Fat_Assign(char *filename, char file_cre_attr); |
|||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Description |
Assigns file for file operations (read, write, delete...). All subsequent file operations will be applied on an assigned file. |
|||||||||||||||||||||||||||
Parameters |
|
|||||||||||||||||||||||||||
Returns |
|
|||||||||||||||||||||||||||
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
|||||||||||||||||||||||||||
Example |
// create file with archive attribute if it does not already exist Mmc_Fat_Assign("MIKRO007.TXT",0xA0); |
|||||||||||||||||||||||||||
Notes |
Long File Names (LFN) are not supported. |
Mmc_Fat_Reset
Prototype |
void Mmc_Fat_Reset(unsigned long *size); |
---|---|
Description |
Procedure resets the file pointer (moves it to the start of the file) of the assigned file, so that the file can be read. |
Parameters |
|
Returns |
Nothing. |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. |
Example |
unsigned long size; ... Mmc_Fat_Reset(&size); |
Notes |
None. |
Mmc_Fat_Read
Prototype |
void Mmc_Fat_Read(unsigned short *bdata); |
---|---|
Description |
Reads a byte from the currently assigned file opened for reading. Upon function execution file pointers will be set to the next character in the file. |
Parameters |
|
Returns |
Nothing. |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. The file must be opened for reading. See Mmc_Fat_Reset. |
Example |
char character; ... Mmc_Fat_Read(&character); |
Notes |
None. |
Mmc_Fat_Rewrite
Prototype |
void Mmc_Fat_Rewrite(); |
---|---|
Description |
Opens the currently assigned file for writing. If the file is not empty its content will be erased. |
Parameters |
None. |
Returns |
Nothing. |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. |
Example |
// open file for writing Mmc_Fat_Rewrite(); |
Notes |
None. |
Mmc_Fat_Append
Prototype |
void Mmc_Fat_Append(); |
---|---|
Description |
Opens the currently assigned file for appending. Upon this function execution file pointers will be positioned after the last byte in the file, so any subsequent file write operation will start from there. |
Parameters |
None. |
Returns |
Nothing. |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. |
Example |
// open file for appending Mmc_Fat_Append(); |
Notes |
None. |
Mmc_Fat_Delete
Prototype |
void Mmc_Fat_Delete(); |
---|---|
Description |
Deletes currently assigned file from MMC/SD card. |
Parameters |
None. |
Returns |
Nothing. |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. |
Example |
// delete current file Mmc_Fat_Delete(); |
Notes |
None. |
Mmc_Fat_Write
Prototype |
void Mmc_Fat_Write(char *fdata, unsigned data_len); |
---|---|
Description |
Writes requested number of bytes to the currently assigned file opened for writing. |
Parameters |
|
Returns |
Nothing. |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. The file must be opened for writing. See Mmc_Fat_Rewrite or Mmc_Fat_Append. |
Example |
char file_contents[42]; ... Mmc_Fat_Write(file_contents, 42); // write data to the assigned file |
Notes |
None. |
Mmc_Fat_Set_File_Date
Prototype |
void Mmc_Fat_Set_File_Date(unsigned int year, unsigned short month, unsigned short day, unsigned short hours, unsigned short mins, unsigned short seconds); |
---|---|
Description |
Sets the date/time stamp. Any subsequent file write operation will write this stamp to the currently assigned file's time/date attributes. |
Parameters |
|
Returns |
Nothing. |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. The file must be opened for writing. See Mmc_Fat_Rewrite or Mmc_Fat_Append. |
Example |
// April 1st 2005, 18:07:00 Mmc_Fat_Set_File_Date(2005, 4, 1, 18, 7, 0); |
Notes |
None. |
Mmc_Fat_Get_File_Date
Prototype |
void Mmc_Fat_Get_File_Date(unsigned int *year, unsigned short *month, unsigned short *day, unsigned short *hours, unsigned short *mins); |
---|---|
Description |
Reads time/date attributes of the currently assigned file. |
Parameters |
|
Returns |
Nothing. |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. |
Example |
// get Date/time of file unsigned yr; char mnth, dat, hrs, mins; ... file_Name = "MYFILEABTXT"; Mmc_Fat_Assign(file_Name); Mmc_Fat_Get_File_Date(&yr, &mnth, &day, &hrs, &mins); |
Notes |
None. |
Mmc_Fat_Get_File_Date_Modified
Prototype |
void Mmc_Fat_Get_File_Date_Modified(unsigned int *year, unsigned short *month, unsigned short *day, unsigned short *hours, unsigned short *mins); |
---|---|
Description |
Retrieves the last modification date/time for the currently selected file. Seconds are not being retrieved since they are written in 2-sec increments. |
Parameters |
|
Returns |
Nothing. |
Requires |
The file must be assigned, see Mmc_Fat_Assign. |
Example |
// get modification Date/time of file unsigned yr; char mnth, dat, hrs, mins; ... file_Name = "MYFILEABTXT"; Mmc_Fat_Assign(file_Name); Mmc_Fat_Get_File_Date_Modified(&yr, &mnth, &day, &hrs, &mins); |
Mmc_Fat_Get_File_Size
Prototype |
unsigned long Mmc_Fat_Get_File_Size(); |
---|---|
Description |
This function reads size of the currently assigned file in bytes. |
Parameters |
None. |
Returns |
This function returns size of active file (in bytes). |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. |
Example |
unsigned long my_file_size; ... my_file_size = Mmc_Fat_Get_File_Size(); |
Notes |
None. |
Mmc_Get_File_Write_Sector
Prototype |
unsigned long Mmc_Get_File_Write_Sector(); |
---|---|
Description |
This function returns the current file write sector. |
Parameters |
None. |
Returns |
This function returns the current file write sector. |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. |
Example |
unsigned long sector; ... sector = Mmc_Get_File_Write_Sector(); |
Notes |
None. |
Mmc_Fat_Get_Swap_File
Prototype |
unsigned long Mmc_Fat_Get_Swap_File(unsigned long sectors_cnt, char* filename, char file_attr); |
|||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Description |
This function is used to create a swap file of predefined name and size on the MMC/SD media. If a file with specified name already exists on the media, search for consecutive sectors will ignore sectors occupied by this file. Therefore, it is recommended to erase such file if it already exists before calling this function. If it is not erased and there is still enough space for a new swap file, this function will delete it after allocating new memory space for a new swap file. The purpose of the swap file is to make reading and writing to MMC/SD media as fast as possible, by using the Mmc_Read_Sector() and Mmc_Write_Sector() functions directly, without potentially damaging the FAT system. The swap file can be considered as a "window" on the media where the user can freely write/read data. It's main purpose in this library is to be used for fast data acquisition; when the time-critical acquisition has finished, the data can be re-written into a "normal" file, and formatted in the most suitable way. |
|||||||||||||||||||||||||||
Parameters |
|
|||||||||||||||||||||||||||
Returns |
|
|||||||||||||||||||||||||||
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
|||||||||||||||||||||||||||
Example |
//-------------- Tries to create a swap file, whose size will be at least 100 sectors. //If it succeeds, it sends the No. of start sector over UART void M_Create_Swap_File(){ size = Mmc_Fat_Get_Swap_File(5000, "mikroE.txt", 0x20); if (size <> 0) { UART1_Write(0xAA); UART1_Write(Lo(size)); UART1_Write(Hi(size)); UART1_Write(Higher(size)); UART1_Write(Highest(size)); UART1_Write(0xAA); } } |
|||||||||||||||||||||||||||
Notes |
Long File Names (LFN) are not supported. |
Mmc_Fat_Tell
Prototype |
unsigned long Mmc_Fat_Tell(); |
---|---|
Description |
This routine is used to retrieve the cursor position within an opened file. |
Parameters |
None. |
Returns |
Returns the cursor position in currently assigned file. |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. |
Example |
unsigned long position; position = Mmc_Fat_Tell(); |
Notes |
None. |
Mmc_Fat_Seek
Prototype |
unsigned long Mmc_Fat_Seek(unsigned long position); |
---|---|
Description |
This routine is used to set the cursor position within an opened file and returns the cursor's new position within an opened file. |
Parameters |
|
Returns |
Returns the cursor's new position in currently assigned file. |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. |
Example |
unsigned long position; position = Mmc_Fat_Seek(1000); |
Notes |
If the desired cursor position exceeds file size, the cursor will be placed at the end of the file. |
Mmc_Fat_Rename
Prototype |
char Mmc_Fat_Rename(char *newname); |
---|---|
Description |
This function renames the currently assigned file. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. The file must be previously assigned. See Mmc_Fat_Assign. |
Example |
if (0 == Mmc_Fat_Rename("NEWNAME.TXT")) { // if rename operation was successful... ... } |
Notes |
None. |
Mmc_Fat_MakeDir
Prototype |
char Mmc_Fat_MakeDir(char *name, char attrib); |
---|---|
Description |
This function creates a new directory. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
Example |
if (0 == Mmc_Fat_MakeDir("DIR_A")) { // create DIR_A directory ... } |
Notes |
None. |
Mmc_Fat_RenameDir
Prototype |
char Mmc_Fat_RenameDir(unsigned char *oldname, unsigned char *newname); |
---|---|
Description |
This function renames a directory. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
Example |
if (0 == Mmc_Fat_RenameDir("DIR_A", "DIR_B")) { // if rename operation was successful... ... } |
Notes |
None. |
Mmc_Fat_RemoveDir
Prototype |
char Mmc_Fat_RemoveDir(unsigned char *name); |
---|---|
Description |
This function removes directory entry from current directory. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
Example |
if (0 == Mmc_Fat_RemoveDir("DIR_A")) { // if removing operation was successful... ... } |
Notes |
Recursive removing is not supported, i.e. the directory must be empty before it can be removed. |
Mmc_Fat_ChangeDir
Prototype |
char Mmc_Fat_ChangeDir(unsigned char *name); |
---|---|
Description |
This function changes the current directory to |
Parameters |
|
Returns |
|
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
Example |
// enter DIR_A directory if (0 == Mmc_Fat_ChangeDir("DIR_A")) { ... } // go to parent directory if (0 == Mmc_Fat_ChangeDir("..")) { ... } // go to root directory if (0 == Mmc_Fat_ChangeDir("\")) { ... } |
Notes |
Special directory names like " |
Mmc_Fat_Exists
Prototype |
char Mmc_Fat_Exists(char *name); |
---|---|
Description |
This function returns information on file/directory existence. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
Example |
status = Mmc_Fat_Exists("X_FILES.TXT"); if (1 == status) { ... } // if the file was found... else if (0 == status) { ... } // or if the file was not found... else { ... } // or if there was an error during function call, // which needs to be handled separately. |
Notes |
None. |
Mmc_Fat_Dir
Prototype |
char Mmc_Fat_Dir(void (*print)(char ch)) |
---|---|
Description |
This routine displays contents of the current directory via user-defined medium (i.e. UART module, a file on FAT16 file system). The function displays character by character. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
Example |
// Displaying routine void PrintChar(char ch) { UART1_Write(ch); } ... Mmc_Fat_Dir(PrintChar); |
Notes |
None. |
Mmc_Fat_ReadDir
Prototype |
static short Mmc_Fat_ReadDir(DIR *d); |
---|---|
Description |
This function gets next directory entry from current directory. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
Example |
if (1 == Mmc_Fat_ReadDir("DIR_A")) { ... } |
Notes |
None. |
Mmc_Fat_Activate
Prototype |
char Mmc_Fat_Activate(short fileHandle); |
---|---|
Description |
This function selects active file of currently opened files. |
Parameters |
|
Returns |
|
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
Example |
short fhandle; fhandle = Mmc_Fat_Open("X_FILES.TXT", FILE_READ, 0x01); if (Mmc_Fat_Activate(fhandle)) == 0) { } |
Notes |
Use Mmc_Fat_Open function to get file handles. |
Mmc_Fat_ReadN
Prototype |
unsigned int Mmc_Fat_ReadN(char *fdata, unsigned int n); |
---|---|
Description |
This function reads multiple bytes. |
Parameters |
|
Returns |
Number of read bytes. |
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
Example |
char data_buffer[512]; unsigned int no_bytes; ... no_bytes = Mmc_Fat_ReadN(&data_buffer, 500); |
Notes |
None. |
Mmc_Fat_Open
Prototype |
short Mmc_Fat_Open(unsigned char *name, unsigned short mode, char attrib); |
|||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Description |
This function opens a file for manipulation. |
|||||||||||||||||||||||||||
Parameters |
|
|||||||||||||||||||||||||||
Returns |
|
|||||||||||||||||||||||||||
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
|||||||||||||||||||||||||||
Example |
short fhandle; fhandle = Mmc_Fat_Open("X_FILES.TXT", FILE_READ, 0x01); |
|||||||||||||||||||||||||||
Notes |
None. |
Mmc_Fat_Close
Prototype |
char Mmc_Fat_Close(); |
---|---|
Description |
This function closes currently opened file. |
Parameters |
None. |
Returns |
|
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
Example |
if (Mmc_Fat_Close() == 0) { } |
Notes |
None. |
Mmc_Fat_EOF
Prototype |
short Mmc_Fat_EOF(); |
---|---|
Description |
This function check if the end of file is reached. |
Parameters |
None. |
Returns |
|
Requires |
MMC/SD card and MMC library must be initialized for file operations. See Mmc_Fat_Init. |
Example |
if (Mmc_Fat_EOF() == 0) { } |
Notes |
None. |
Library Example
The following example demonstrates usage of the MMC and MMC_FAT routines.
// MMC module connections
sbit Mmc_Chip_Select at LATG9_bit; // for writing to output pin always use latch
sbit Mmc_Chip_Select_Direction at TRISG9_bit;
// eof MMC module connections
const LINE_LEN = 43;
char err_txt[20] = "FAT16 not found";
char file_contents[LINE_LEN] = "XX MMC/SD FAT16 library by Anton Rieckert\n";
char filename[14] = "MIKRO00x.TXT"; // File names
unsigned short loop, loop2;
unsigned long i, size;
char Buffer[512];
// UART1 write text and new line (carriage return + line feed)
void UART1_Write_Line(char *uart_text) {
UART1_Write_Text(uart_text);
UART1_Write(13);
UART1_Write(10);
}
// Creates new file and writes some data to it
void M_Create_New_File() {
filename[7] = 'A';
Mmc_Fat_Set_File_Date(2011,1,12,11,9,0); // Set file date & time info
Mmc_Fat_Assign(&filename, 0xA0); // Find existing file or create a new one
Mmc_Fat_Rewrite(); // To clear file and start with new data
for(loop = 1; loop <= 99; loop++) {
UART1_Write('.');
file_contents[0] = loop / 10 + 48;
file_contents[1] = loop % 10 + 48;
Mmc_Fat_Write(file_contents, LINE_LEN-1); // write data to the assigned file
}
}
// Creates many new files and writes data to them
void M_Create_Multiple_Files() {
for(loop2 = 'B'; loop2 <= 'Z'; loop2++) {
UART1_Write(loop2); // signal the progress
filename[7] = loop2; // set filename
Mmc_Fat_Set_File_Date(2011,1,12,11,9,0); // Set file date & time info
Mmc_Fat_Assign(&filename, 0xA0); // find existing file or create a new one
Mmc_Fat_Rewrite(); // To clear file and start with new data
for(loop = 1; loop <= 44; loop++) {
file_contents[0] = loop / 10 + 48;
file_contents[1] = loop % 10 + 48;
Mmc_Fat_Write(file_contents, LINE_LEN-1); // write data to the assigned file
}
}
}
// Opens an existing file and rewrites it
void M_Open_File_Rewrite() {
filename[7] = 'C';
Mmc_Fat_Assign(&filename, 0);
Mmc_Fat_Rewrite();
for(loop = 1; loop <= 55; loop++) {
file_contents[0] = loop / 10 + 48;
file_contents[1] = loop % 10 + 48;
Mmc_Fat_Write(file_contents, LINE_LEN-1); // write data to the assigned file
}
}
// Opens an existing file and appends data to it
// (and alters the date/time stamp)
void M_Open_File_Append() {
filename[7] = 'B';
Mmc_Fat_Assign(&filename, 0);
Mmc_Fat_Set_File_Date(2009, 1, 23, 17, 22, 0);
Mmc_Fat_Append(); // Prepare file for append
Mmc_Fat_Write(" for mikroElektronika 2009\n", 27); // Write data to assigned file
}
// Opens an existing file, reads data from it and puts it to UART
void M_Open_File_Read() {
char character;
filename[7] = 'B';
Mmc_Fat_Assign(&filename, 0);
Mmc_Fat_Reset(&size); // To read file, procedure returns size of file
for (i = 1; i <= size; i++) {
Mmc_Fat_Read(&character);
UART1_Write(character); // Write data to UART
}
}
// Deletes a file. If file doesn't exist, it will first be created
// and then deleted.
void M_Delete_File() {
filename[7] = 'F';
Mmc_Fat_Assign(filename, 0);
Mmc_Fat_Delete();
}
// Tests whether file exists, and if so sends its creation date
// and file size via UART
void M_Test_File_Exist() {
unsigned long fsize;
unsigned int year;
unsigned short month, day, hour, minute;
unsigned char outstr[12];
Mmc_Fat_Get_File_Date(&year, &month, &day, &hour, &minute);
filename[7] = 'B'; //uncomment this line to search for file that DOES exists
// filename[7] = 'F'; //uncomment this line to search for file that DOES NOT exist
if (Mmc_Fat_Assign(filename, 0)) {
//--- file has been found - get its create date
Mmc_Fat_Get_File_Date(&year, &month, &day, &hour, &minute);
UART1_Write_Text(" created: ");
WordToStr(year, outstr);
UART1_Write_Text(outstr);
ByteToStr(month, outstr);
UART1_Write_Text(outstr);
WordToStr(day, outstr);
UART1_Write_Text(outstr);
WordToStr(hour, outstr);
UART1_Write_Text(outstr);
WordToStr(minute, outstr);
UART1_Write_Text(outstr);
//--- file has been found - get its modified date
Mmc_Fat_Get_File_Date_Modified(&year, &month, &day, &hour, &minute);
UART1_Write_Text(" modified: ");
WordToStr(year, outstr);
UART1_Write_Text(outstr);
ByteToStr(month, outstr);
UART1_Write_Text(outstr);
WordToStr(day, outstr);
UART1_Write_Text(outstr);
WordToStr(hour, outstr);
UART1_Write_Text(outstr);
WordToStr(minute, outstr);
UART1_Write_Text(outstr);
//--- get file size
fsize = Mmc_Fat_Get_File_Size();
LongToStr((signed long)fsize, outstr);
UART1_Write_Line(outstr);
}
else {
//--- file was not found - signal it
UART1_Write(0x55);
Delay_ms(1000);
UART1_Write(0x55);
}
}
// Tries to create a swap file, whose size will be at least 100
// sectors (see Help for details)
void M_Create_Swap_File() {
unsigned int i;
for(i=0; i<512; i++)
Buffer[i] = i;
size = Mmc_Fat_Get_Swap_File(5000, "mikroE.txt", 0x20); // see help on this function for details
if (size) {
LongToStr((signed long)size, err_txt);
UART1_Write_Line(err_txt);
for(i=0; i<5000; i++) {
Mmc_Write_Sector(size++, Buffer);
UART1_Write('.');
}
}
}
//-------------- Main. Uncomment the function(s) to test the desired operation(s)
void main() {
#define COMPLETE_EXAMPLE // comment this line to make simpler/smaller example
PORTD = 0;
TRISD = 0;
PORTF = 0;
TRISF = 0;
CHECON = 0x32;
AD1PCFG = 0xFFFF; // initialize AN pins as digital
// Initialize UART1 module
UART1_Init(19200);
Delay_ms(10);
UART1_Write_Line("MCU-Started"); // MCU present report
//--- set up SPI for the file read
SPI2_Init_Advanced(_SPI_MASTER, _SPI_8_BIT, 64, _SPI_SS_DISABLE, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_HIGH, _SPI_ACTIVE_2_IDLE);
Delay_ms(10);
//--- init the FAT library
if (!Mmc_Fat_Init()) {
// reinitialize spi at higher speed
SPI2_Init_Advanced(_SPI_MASTER, _SPI_8_BIT, 8, _SPI_SS_DISABLE, _SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_HIGH, _SPI_ACTIVE_2_IDLE);
//--- Test start
UART1_Write_Line("Test Start.");
//--- Test routines. Uncomment them one-by-one to test certain features
M_Create_New_File();
#ifdef COMPLETE_EXAMPLE
M_Create_Multiple_Files();
M_Open_File_Rewrite();
M_Open_File_Append();
M_Open_File_Read();
M_Delete_File();
M_Test_File_Exist();
M_Create_Swap_File();
#endif
UART1_Write_Line("Test End.");
}
else {
UART1_Write_Line(err_txt); // Note: Mmc_Fat_Init tries to initialize a card more than once.
// If card is not present, initialization may last longer (depending on clock speed)
}
}
HW Connection
Pin diagram of MMC memory card
What do you think about this topic ? Send us feedback!