Compact Flash Library

The Compact Flash Library provides routines for accessing data on Compact Flash card (abbr. CF further in text). CF cards are widely used memory elements, commonly used with digital cameras. Great capacity and excellent access time of only a few microseconds make them very attractive for microcontroller applications.

In CF card, data is divided into sectors. One sector usually comprises 512 bytes. Routines for file handling, the Cf_Fat routines, are not performed directly but successively through 512B buffer.

Important :

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 writing operation, make sure not to 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 great assistance.

Library Dependency Tree

External dependencies of Compact Flash Library

The following variables must be defined in all projects using Compact Flash Library:	Description :	Example :
`dim CF_Data_Port as byte sfr external`	Compact Flash Data Port.	`dim CF_Data_Port as byte at PORTD`
`dim CF_RDY as sbit sfr external`	Ready signal line.	`dim CF_RDY as sbit at RB7_bit`
`dim CF_WE as sbit sfr external`	Write Enable signal line.	`dim CF_WE as sbit at LATB6_bit`
`dim CF_OE as sbit sfr external`	Output Enable signal line.	`dim CF_OE as sbit at LATB5_bit`
`dim CF_CD1 as sbit sfr external`	Chip Detect signal line.	`dim CF_CD1 as sbit at RB4_bit`
`dim CF_CE1 as sbit sfr external`	Chip Enable signal line.	`dim CF_CE1 as sbit at LATB3_bit`
`dim CF_A2 as sbit sfr external`	Address pin 2.	`dim CF_A2 as sbit at LATB2_bit`
`dim CF_A1 as sbit sfr external`	Address pin 1.	`dim CF_A1 as sbit at LATB1_bit`
`dim CF_A0 as sbit sfr external`	Address pin 0.	`dim CF_A0 as sbit at LATB0_bit`
`dim CF_RDY_direction as sbit sfr external`	Direction of the Ready pin.	`dim CF_RDY_direction as sbit at TRISB7_bit`
`dim CF_WE_direction as sbit sfr external`	Direction of the Write Enable pin.	`dim CF_WE_direction as sbit at TRISB6_bit`
`dim CF_OE_direction as sbit sfr external`	Direction of the Output Enable pin.	`dim CF_OE_direction as sbit at TRISB5_bit`
`dim CF_CD1_direction as sbit sfr external`	Direction of the Chip Detect pin.	`dim CF_CD1_direction as sbit at TRISB4_bit`
`dim CF_CE1_direction as sbit sfr external`	Direction of the Chip Enable pin.	`dim CF_CE1_direction as sbit at TRISB3_bit`
`dim CF_A2_direction as sbit sfr external`	Direction of the Address 2 pin.	`dim CF_A2_direction as sbit at TRISB2_bit`
`dim CF_A1_direction as sbit sfr external`	Direction of the Address 1 pin.	`dim CF_A1_direction as sbit at TRISB1_bit`
`dim CF_A0_direction as sbit sfr external`	Direction of the Address 0 pin.	`dim CF_A0_direction as sbit at TRISB0_bit`

Routines for file handling:

Cf_Fat_Init
Cf_Fat_QuickFormat
Cf_Fat_Assign
Cf_Fat_Reset
Cf_Fat_Read
Cf_Fat_Rewrite
Cf_Fat_Append
Cf_Fat_Delete
Cf_Fat_Write
Cf_Fat_Set_File_Date
Cf_Fat_Get_File_Date
Cf_Fat_Get_File_Date_Modified
Cf_Fat_Get_File_Size
Cf_Fat_Get_Swap_File

The following routine is for the internal use by compiler only:

Cf_Issue_ID_Command

Cf_Init

Prototype	sub procedure Cf_Init()
Description	Initializes ports appropriately for communication with CF card.
Parameters	None.
Returns	Nothing.
Requires	Global variables : `CF_Data_Port` : Compact Flash data port `CF_RDY` : Ready signal line `CF_WE` : Write enable signal line `CF_OE` : Output enable signal line `CF_CD1` : Chip detect signal line `CF_CE1` : Enable signal line `CF_A2` : Address pin 2 `CF_A1` : Address pin 1 `CF_A0` : Address pin 0 `CF_RDY_direction` : Direction of the Ready pin `CF_WE_direction` : Direction of the Write enable pin `CF_OE_direction` : Direction of the Output enable pin `CF_CD1_direction` : Direction of the Chip detect pin `CF_CE1_direction` : Direction of the Chip enable pin `CF_A2_direction` : Direction of the Address 2 pin `CF_A1_direction` : Direction of the Address 1 pin `CF_A0_direction` : Direction of the Address 0 pin must be defined before using this function.
Example	' set compact flash pinout dim Cf_Data_Port as byte at PORTD dim CF_RDY as sbit at RB7_bit dim CF_WE as sbit at LATB6_bit ' for writing to output pin always use latch dim CF_OE as sbit at LATB5_bit ' for writing to output pin always use latch dim CF_CD1 as sbit at RB4_bit dim CF_CE1 as sbit at LATB3_bit ' for writing to output pin always use latch dim CF_A2 as sbit at LATB2_bit ' for writing to output pin always use latch dim CF_A1 as sbit at LATB1_bit ' for writing to output pin always use latch dim CF_A0 as sbit at LATB0_bit ' for writing to output pin always use latch dim CF_RDY_direction as sbit at TRISB7_bit dim CF_WE_direction as sbit at TRISB6_bit dim CF_OE_direction as sbit at TRISB5_bit dim CF_CD1_direction as sbit at TRISB4_bit dim CF_CE1_direction as sbit at TRISB3_bit dim CF_A2_direction as sbit at TRISB2_bit dim CF_A1_direction as sbit at TRISB1_bit dim CF_A0_direction as sbit at TRISB0_bit ' end of cf pinout 'Init CF Cf_Init()
Notes	None.

Cf_Detect

Prototype	sub function CF_Detect() as word
Description	Checks for presence of CF card by reading the `chip detect` pin.
Parameters	None.
Returns	`1` - if CF card was detected `0` - otherwise
Requires	The corresponding MCU ports must be appropriately initialized for CF card. See Cf_Init.
Example	' Wait until CF card is inserted: while (Cf_Detect() = 0) nop wend
Notes	dsPIC30 family MCU and CF card voltage levels are different. The user must ensure that MCU's pin connected to CD line can read CF card Logical One correctly.

Cf_Enable

Prototype	sub procedure Cf_Enable()
Description	Enables the device. Routine needs to be called only if you have disabled the device by means of the Cf_Disable routine. These two routines in conjunction allow you to free/occupy data line when working with multiple devices.
Parameters	None.
Returns	Nothing.
Requires	The corresponding MCU ports must be appropriately initialized for CF card. See Cf_Init.
Example	' enable compact flash Cf_Enable()
Notes	None.

Cf_Disable

Prototype	sub procedure Cf_Disable()
Description	Routine disables the device and frees the data lines for other devices. To enable the device again, call Cf_Enable. These two routines in conjunction allow you to free/occupy data line when working with multiple devices.
Parameters	None.
Returns	Nothing.
Requires	The corresponding MCU ports must be appropriately initialized for CF card. See Cf_Init.
Example	' disable compact flash Cf_Disable()
Notes	None.

Cf_Read_Init

Prototype	sub procedure Cf_Read_Init(dim address as longword, dim sectcnt as byte)
Description	Initializes CF card for reading.
Parameters	`address:` the first sector to be prepared for reading operation. `sector_count:` number of sectors to be prepared for reading operation.
Returns	Nothing.
Requires	The corresponding MCU ports must be appropriately initialized for CF card. See Cf_Init.
Example	' initialize compact flash for reading from sector 590 Cf_Read_Init(590, 1)
Notes	None.

Cf_Read_Byte

Prototype	sub function CF_Read_Byte() as byte
Description	Reads one byte from Compact Flash sector buffer location currently pointed to by internal read pointers. These pointers will be autoicremented upon reading.
Parameters	None.
Returns	Returns a byte read from Compact Flash sector buffer.
Requires	The corresponding MCU ports must be appropriately initialized for CF card. See Cf_Init. CF card must be initialized for reading operation. See Cf_Read_Init.
Example	' Read a byte from compact flash: dim data_ as byte ... data_ = Cf_Read_Byte()
Notes	Higher byte of the `unsigned` return value is cleared.

Cf_Write_Init

Prototype	sub procedure Cf_Write_Init(dim address as longword, dim sectcnt as word)
Description	Initializes CF card for writing.
Parameters	`address:` the first sector to be prepared for writing operation. `sectcnt:` number of sectors to be prepared for writing operation.
Returns	Nothing.
Requires	The corresponding MCU ports must be appropriately initialized for CF card. See Cf_Init.
Example	' initialize compact flash for writing to sector 590 Cf_Write_Init(590, 1)
Notes	None.

Cf_Write_Byte

Prototype	sub procedure Cf_Write_Byte(dim data_ as byte)
Description	Writes a byte to Compact Flash sector buffer location currently pointed to by writing pointers. These pointers will be autoicremented upon reading. When sector buffer is full, its contents will be transfered to appropriate flash memory sector.
Parameters	`data_:` byte to be written.
Returns	Nothing.
Requires	The corresponding MCU ports must be appropriately initialized for CF card. See Cf_Init. CF card must be initialized for writing operation. See Cf_Write_Init.
Example	dim data_ as byte ... data_ = 0xAA Cf_Write_Byte(data_)
Notes	None.

Cf_Read_Sector

Prototype	sub procedure Cf_Read_Sector(dim sector_number as longword, dim byref buffer as byte[512])
Description	Reads one sector (512 bytes). Read data is stored into buffer provided by the `buffer` parameter.
Parameters	`sector_number:` sector to be read. `buffer:` data buffer of at least 512 bytes in length.
Returns	Nothing.
Requires	The corresponding MCU ports must be appropriately initialized for CF card. See Cf_Init.
Example	' read sector 22 dim data_ as byte[512] ... Cf_Read_Sector(22, data_)
Notes	None.

Cf_Write_Sector

Prototype	sub procedure Cf_Write_Sector(dim sector_number as longword, dim byref buffer as byte[512])
Description	Writes 512 bytes of data provided by the `buffer` parameter to one CF sector.
Parameters	`sector_number:` sector to be written to. `buffer:` data buffer of 512 bytes in length.
Returns	Nothing.
Requires	The corresponding MCU ports must be appropriately initialized for CF card. See Cf_Init.
Example	' write to sector 22 dim data_ as byte[512] ... Cf_Write_Sector(22, data_)
Notes	None.

Cf_Fat_Init

Prototype	sub function Cf_Fat_Init() as word
Description	Initializes CF card, reads CF FAT16 boot sector and extracts necessary data needed by the library.
Parameters	None.
Returns	`0` - if CF card was detected and successfully initialized `1` - if FAT16 boot sector was not found `255` - if card was not detected
Requires	Nothing.
Example	' init the FAT library if (Cf_Fat_Init() = 0) then ... end if
Notes	None.

Cf_Fat_QuickFormat

Prototype	sub function Cf_Fat_QuickFormat(dim byref cf_fat_label as string[11]) as word
Description	Formats to FAT16 and initializes CF card.
Parameters	`cf_fat_label:` volume label (11 characters in length). If less than 11 characters are provided, the label will be padded with spaces. If null string is passed, the volume will not be labeled.
Returns	`0` - if CF card was detected, successfully formated and initialized `1` - if FAT16 format was unsuccessful `255` - if card was not detected
Requires	Nothing.
Example	' format and initialize the FAT library if ( Cf_Fat_QuickFormat("mikroE") = 0) then ... end if
Notes	This routine can be used instead or in conjunction with Cf_Fat_Init routine. If CF 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.

Cf_Fat_Assign

Prototype

sub function Cf_Fat_Assign(dim byref filename as char[12], dim file_cre_attr as byte) as word

Description

Assigns file for file operations (read, write, delete...). All subsequent file operations will be applied over the assigned file.

Parameters

filename: name of the file that should be assigned for file operations. The file name should be in DOS 8.3 (file_name.extension) format. The file name and extension will be automatically padded with spaces by the library if they have less than length required (i.e. "mikro.tx" -> "mikro .tx "), so the user does not have to take care of that. The file name and extension are case insensitive. The library will convert them to proper case automatically, so the user does not have to take care of that.
Also, in order to keep backward compatibility with the first version of this library, file names can be entered as UPPERCASE string of 11 bytes in length with no dot character between the file name and extension (i.e. "MIKROELETXT" -> MIKROELE.TXT). In this case the last 3 characters of the string are considered to be file extension.
file_cre_attr: file creation and attributes flags. Each bit corresponds to the appropriate file attribute:

Bit	Mask	Description
0	0x01	Read Only
1	0x02	Hidden
2	0x04	System
3	0x08	Volume Label
4	0x10	Subdirectory
5	0x20	Archive
6	0x40	Device (internal use only, never found on disk)
7	0x80	File creation flag. If the file does not exist and this flag is set, a new file with specified name will be created.

Returns

0 if file does not exist and no new file is created.
1 if file already exists or file does not exist but a new file is created.

Requires

CF card and CF library must be initialized for file operations. See Cf_Fat_Init.

Example

' create file with archive attribut if it does not already exist
Cf_Fat_Assign("MIKRO007.TXT",0xA0)

Notes Long File Names (LFN) are not supported.

Cf_Fat_Reset

Prototype	sub procedure Cf_Fat_Reset(dim byref size as longword)
Description	Opens currently assigned file for reading.
Parameters	`size:` buffer to store file size to. After file has been open for reading its size is returned through this parameter.
Returns	Nothing.
Requires	CF card and CF library must be initialized for file operations. See Cf_Fat_Init. File must be previously assigned. See Cf_Fat_Assign.
Example	dim size as longword ... Cf_Fat_Reset(size)
Notes	None.

Cf_Fat_Read

Prototype	sub procedure Cf_Fat_Read(dim byref bdata as byte)
Description	Reads a byte from currently assigned file opened for reading. Upon function execution file pointers will be set to the next character in the file.
Parameters	`bdata:` buffer to store read byte to. Upon this function execution read byte is returned through this parameter.
Returns	Nothing.
Requires	CF card and CF library must be initialized for file operations. See Cf_Fat_Init. File must be previously assigned. See Cf_Fat_Assign. File must be open for reading. See Cf_Fat_Reset.
Example	dim bdata as byte ... Cf_Fat_Read(bdata)
Notes	None.

Cf_Fat_Rewrite

Prototype	sub procedure Cf_Fat_Rewrite()
Description	Opens currently assigned file for writing. If the file is not empty its content will be erased.
Parameters	None.
Returns	Nothing.
Requires	CF card and CF library must be initialized for file operations. See Cf_Fat_Init. The file must be previously assigned. See Cf_Fat_Assign.
Example	' open file for writing Cf_Fat_Rewrite()
Notes	None.

Cf_Fat_Append

Prototype	sub procedure Cf_Fat_Append()
Description	Opens 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 writing operation will start from there.
Parameters	None.
Returns	Nothing.
Requires	CF card and CF library must be initialized for file operations. See Cf_Fat_Init. File must be previously assigned. See Cf_Fat_Assign.
Example	' open file for appending Cf_Fat_Append()
Notes	None.

Cf_Fat_Delete

Prototype	sub procedure Cf_Fat_Delete()
Description	Deletes currently assigned file from CF card.
Parameters	None.
Returns	Nothing.
Requires	CF card and CF library must be initialized for file operations. See Cf_Fat_Init. File must be previously assigned. See Cf_Fat_Assign.
Example	' delete current file Cf_Fat_Delete()
Notes	None.

Cf_Fat_Write

Prototype	sub procedure Cf_Fat_Write(dim byref fdata as byte[512], dim data_len as word)
Description	Writes requested number of bytes to currently assigned file opened for writing.
Parameters	`fdata:` data to be written. `data_len:` number of bytes to be written.
Returns	Nothing.
Requires	CF card and CF library must be initialized for file operations. See Cf_Fat_Init. File must be previously assigned. See Cf_Fat_Assign. File must be open for writing. See Cf_Fat_Rewrite or Cf_Fat_Append.
Example	dim file_contents as array[42] ... Cf_Fat_Write(file_contents, 42) ' write data to the assigned file
Notes	None.

Cf_Fat_Set_File_Date

Prototype	sub procedure Cf_Fat_Set_File_Date(dim year as word, dim month as byte, dim day as byte, dim hours as byte, dim mins as byte, dim seconds as byte)
Description	Sets the date/time stamp. Any subsequent file writing operation will write this stamp to currently assigned file's time/date attributes.
Parameters	`year:` year attribute. Valid values: 1980-2107 `month:` month attribute. Valid values: 1-12 `day:` day attribute. Valid values: 1-31 `hours:` hours attribute. Valid values: 0-23 `mins:` minutes attribute. Valid values: 0-59 `seconds:` seconds attribute. Valid values: 0-59
Returns	Nothing.
Requires	CF card and CF library must be initialized for file operations. See Cf_Fat_Init. File must be previously assigned. See Cf_Fat_Assign. File must be open for writing. See Cf_Fat_Rewrite or Cf_Fat_Append.
Example	Cf_Fat_Set_File_Date(2005,9,30,17,41,0)
Notes	None.

Cf_Fat_Get_File_Date

Prototype	sub procedure Cf_Fat_Get_File_Date(dim byref year as word, dim byref month as byte, dim byref day as byte, dim byref hours as byte, dim byref mins as byte)
Description	Reads time/date attributes of currently assigned file.
Parameters	`year:` buffer to store year attribute to. Upon function execution year attribute is returned through this parameter. `month:` buffer to store month attribute to. Upon function execution month attribute is returned through this parameter. `day:` buffer to store day attribute to. Upon function execution day attribute is returned through this parameter. `hours:` buffer to store hours attribute to. Upon function execution hours attribute is returned through this parameter. `mins:` buffer to store minutes attribute to. Upon function execution minutes attribute is returned through this parameter.
Returns	Nothing.
Requires	CF card and CF library must be initialized for file operations. See Cf_Fat_Init. File must be previously assigned. See Cf_Fat_Assign.
Example	dim year as word dim month, day, hours, mins as byte ... Cf_Fat_Get_File_Date_Modified(year, month, day, hours, mins)
Notes	None.

Cf_Fat_Get_File_Date_Modified

Prototype	sub procedure Cf_Fat_Get_File_Date_Modified(dim byref year as word, dim byref month, day, hours, mins as byte)
Description	Retrieves the last modification date/time of the currently assigned file.
Parameters	`year:` buffer to store year of modification attribute to. Upon function execution year of modification attribute is returned through this parameter. `month:` buffer to store month of modification attribute to. Upon function execution month of modification attribute is returned through this parameter. `day:` buffer to store day of modification attribute to. Upon function execution day of modification attribute is returned through this parameter. `hours:` buffer to store hours of modification attribute to. Upon function execution hours of modification attribute is returned through this parameter. `mins:` buffer to store minutes of modification attribute to. Upon function execution minutes of modification attribute is returned through this parameter.
Returns	Nothing.
Requires	CF card and CF library must be initialized for file operations. See Cf_Fat_Init. File must be previously assigned. See Cf_Fat_Assign.
Example	dim year as word dim month, day, hours, mins as byte ... Cf_Fat_Get_File_Date_Modified(year, month, day, hours, mins)
Notes	None.

Cf_Fat_Get_File_Size

Prototype	sub function Cf_Fat_Get_File_Size() as longword
Description	This function reads size of currently assigned file in bytes.
Parameters	None.
Returns	Size of the currently assigned file in bytes.
Requires	CF card and CF library must be initialized for file operations. See Cf_Fat_Init. File must be previously assigned. See Cf_Fat_Assign.
Example	dim my_file_size as longword ... my_file_size = Cf_Fat_Get_File_Size()
Notes	None.

Cf_Fat_Get_Swap_File

Prototype

sub function Cf_Fat_Get_Swap_File(dim sectors_cnt as longword, dim byref filename as string[11], dim file_attr as byte) as longword

Description

This function is used to create a swap file of predefined name and size on the CF 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 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 CF media as fast as possible, by using the Cf_Read_Sector() and Cf_Write_Sector() functions directly, without potentially damaging the FAT system. Swap file can be considered as a "window" on the media where the user can freely write/read data. It's main purpose in the 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

sectors_cnt: number of consecutive sectors that user wants the swap file to have.
filename: name of the file that should be assigned for file operations. The file name should be in DOS 8.3 (file_name.extension) format. The file name and extension will be automatically padded with spaces by the library if they have less than length required (i.e. "mikro.tx" -> "mikro .tx "), so the user does not have to take care of that. The file name and extension are case insensitive. The library will convert them to proper case automatically, so the user does not have to take care of that.
Also, in order to keep backward compatibility with the first version of this library, file names can be entered as UPPERCASE string of 11 bytes in length with no dot character between the file name and extension (i.e. "MIKROELETXT" -> MIKROELE.TXT). In this case the last 3 characters of the string are considered to be file extension.
file_attr: file creation and attributes flags. Each bit corresponds to the appropriate file attribute:

Bit Mask Description

0 0x01 Read Only

1 0x02 Hidden

2 0x04 System

3 0x08 Volume Label

4 0x10 Subdirectory

5 0x20 Archive

6 0x40 Device (internal use only, never found on disk)

7 0x80 Not used

Returns

Number of the start sector for the newly created swap file, if there was enough free space on CF card to create file of required size.
0 - otherwise.

Requires

CF card and CF library must be initialized for file operations. See Cf_Fat_Init.

Example

'  Try to create a swap file with archive atribute, whose size will be at least 1000 sectors.
'               If it succeeds, it sends the No. of start sector over UART
dim size as longword
...
size = Cf_Fat_Get_Swap_File(1000, "mikroE.txt", 0x20)
if (size <> 0) then
  UART1_Write(0xAA)
  UART1_Write(Lo(size))
  UART1_Write(Hi(size))
  UART1_Write(Higher(size))
  UART1_Write(Highest(size))
  UART1_Write(0xAA)
end if

Notes Long File Names (LFN) are not supported.

Library Example

This project consists of several blocks that demonstrate various aspects of usage of the Cf_Fat16 library. These are :

Creation of new file and writing down to it;
Opening existing file and re-writing it (writing from start-of-file);
Opening existing file and appending data to it (writing from end-of-file);
Opening a file and reading data from it (sending it to USART terminal);
Creating and modifying several files at once;
Reading file contents;
Deleting file(s);
Creating the swap file (see Help for details);

Copy Code To Clipboard

program CF_Fat16_Test

dim
  ' set compact flash pinout
  Cf_Data_Port as byte at PORTD
  
  CF_RDY as sbit at RB7_bit
  CF_WE  as sbit at LATB6_bit   ' for writing to output pin always use latch
  CF_OE  as sbit at LATB5_bit   ' for writing to output pin always use latch
  CF_CD1 as sbit at RB4_bit
  CF_CE1 as sbit at LATB3_bit   ' for writing to output pin always use latch
  CF_A2  as sbit at LATB2_bit   ' for writing to output pin always use latch
  CF_A1  as sbit at LATB1_bit   ' for writing to output pin always use latch
  CF_A0  as sbit at LATB0_bit   ' for writing to output pin always use latch

  CF_RDY_direction as sbit at TRISB7_bit
  CF_WE_direction  as sbit at TRISB6_bit
  CF_OE_direction  as sbit at TRISB5_bit
  CF_CD1_direction as sbit at TRISB4_bit
  CF_CE1_direction as sbit at TRISB3_bit
  CF_A2_direction  as sbit at TRISB2_bit
  CF_A1_direction  as sbit at TRISB1_bit
  CF_A0_direction  as sbit at TRISB0_bit
 ' end of cf pinout

const LINE_LEN = 37
dim
  err_txt as string[20]
  file_contents as string[LINE_LEN]

  filename as string[14]    ' File names

  character as byte
  loop1, loop2 as byte
  i, size as longint

  Buffer as byte[512]

' UART write text and new line (carriage return + line feed)
sub procedure UART1_Write_Line( dim byref uart_text as string )
  UART1_Write_Text(uart_text)
  UART1_Write(13)
  UART1_Write(10)
end sub

'-------------- Creates new file and writes some data to it
sub procedure M_Create_New_File()
  filename[7] = "A"
  Cf_Fat_Set_File_Date(2005,6,21,10,35,0)        ' Set file date & time info
  Cf_Fat_Assign(filename, 0xA0)                  ' Will not find file and then create file
  Cf_Fat_Rewrite()                               ' To clear file and start with new data
  for loop1=1 to 90                              '  We want 5 files on the MMC card
    UART1_Write(".")
    file_contents[0] = loop1 div 10 + 48
    file_contents[1] = loop1 mod 10 + 48
    Cf_Fat_Write(file_contents, LINE_LEN-1)      ' write data to the assigned file
  next loop1
end sub

'-------------- Creates many new files and writes data to them
sub procedure M_Create_Multiple_Files()
  for loop2 = "B" to "Z"
    UART1_Write(loop2)                           ' this line can slow down the performance
    filename[7] = loop2                          ' set filename
    Cf_Fat_Set_File_Date(2005,6,21,10,35,0)      ' Set file date & time info
    Cf_Fat_Assign(filename, 0xA0)                ' find existing file or create a new one
    Cf_Fat_Rewrite()                             ' To clear file and start with new data
    for loop1 = 1 to 44
      file_contents[0] = loop1 div 10 + 48
      file_contents[1] = loop1 mod 10 + 48
      Cf_Fat_Write(file_contents, LINE_LEN-1)    ' write data to the assigned file
    next loop1
  next loop2
end sub

'-------------- Opens an existing file and rewrites it
sub procedure M_Open_File_Rewrite()
  filename[7] = "C"                              ' Set filename for single-file tests
  Cf_Fat_Assign(filename, 0)
  Cf_Fat_Rewrite()
  for loop1 = 1 to 55
    file_contents[0] = byte(loop1 div 10 + 48)
    file_contents[1] = byte(loop1 mod 10 + 48)
    Cf_Fat_Write(file_contents, LINE_LEN-1)      ' write data to the assigned file
  next loop1
end sub

'-------------- Opens an existing file and appends data to it
'               (and alters the date/time stamp)
sub procedure M_Open_File_Append()
   filename[7] = "B"
   Cf_Fat_Assign(filename, 0)
   Cf_Fat_Set_File_Date(2009, 1, 23, 17, 22, 0)
   Cf_Fat_Append
   file_contents = " for mikroElektronika 2007"  ' Prepare file for append
   file_contents[26] = 10                        ' LF
   Cf_Fat_Write(file_contents, 27)               ' Write data to assigned file
end sub

'-------------- Opens an existing file, reads data from it and puts it to USART
sub procedure M_Open_File_Read()
  filename[7] = "B"
  Cf_Fat_Assign(filename, 0)
  Cf_Fat_Reset(size)              ' To read file, procedure returns size of file
  while size > 0
    Cf_Fat_Read(character)
    UART1_Write(character)       ' Write data to USART
    Dec(size)
  wend
end sub

'-------------- Deletes a file. If file doesn't exist, it will first be created
'               and then deleted.
sub procedure M_Delete_File()
  filename[7] = "F"
  Cf_Fat_Assign(filename, 0)
  Cf_Fat_Delete()
end sub

'-------------- Tests whether file exists, and if so sends its creation date
'               and file size via USART
sub procedure M_Test_File_Exist()
dim
  fsize as longint
  year as word
  month_, day, hour_, minute_ as byte
  outstr as char[12]
  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 Cf_Fat_Assign(filename, 0) <> 0 then
    '--- file has been found - get its date
    Cf_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
    Cf_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 = Cf_Fat_Get_File_Size
    LongIntToStr(fsize, outstr)
    UART1_Write_Line(outstr)
  else
    '--- file was not found - signal it
    UART1_Write(0x55)
    Delay_ms(1000)
    UART1_Write(0x55)
  end if
end sub


'-------------- Tries to create a swap file, whose size will be at least 100
'               sectors (see Help for details)
sub procedure M_Create_Swap_File()
  dim i as word

  for i=0 to 511
    Buffer[i] = i
  next i

  size = Cf_Fat_Get_Swap_File(5000, "mikroE.txt", 0x20)   ' see help on this function for details

  if (size <> 0) then
    LongIntToStr(size, err_txt)
    UART1_Write_Line(err_txt)

    for i=0 to 4999
      Cf_Write_Sector(size, Buffer)
      Inc(size)
      UART1_Write(".")
    next i
  end if
      
end sub

'-------------- Main. Uncomment the function(s) to test the desired operation(s)
main:
  err_txt = "FAT16 not found"
  file_contents = "XX CF FAT16 library by Anton Rieckert"
  filename = "MIKRO00xTXT"

  #define COMPLETE_EXAMPLE               ' comment this line to make simpler/smaller example
  ADPCFG = 0xFFFF                        ' disable A/D inputs

  ' Initialize UART1 module
  UART1_Init(19200)
  Delay_ms(10)

  UART1_Write_Line("dsPIC-Started")      ' dsPIC present report

  ' --- Init the FAT library
  ' --- use Cf_Fat_QuickFormat instead of init routine if a format is needed
  if Cf_Fat_Init() = 0 then
    Delay_ms(2000)                       ' wait for a while until the card is stabilized
                                         ' period depends on used CF card
    '--- Test start
    UART1_Write_Line("Test Start.")
    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: Cf_Fat_Init tries to initialize a card more than once.
                                '       If card is not present, initialization may last longer (depending on clock speed)
  end if
end.

HW Connection

Pin diagram of CF memory card

Want more examples and libraries?
Find them on