WebSVN - Projects - Blame - Rev 436 - /FollowMe/trunk/fat16.c

Rev	Author	Line No.	Line
426	killagreg	1	#include <string.h>
		2	#include "printf_P.h"
		3	#include "timer0.h"
		4	#include "fat16.h"
		5	#include "sdc.h"
		6	#include "uart1.h"
		7
		8
		9	/*
		10	FAT16 Drive Layout:
		11	Description Offset
		12	Volume Boot Sector Start of Partition
		13	Fat Tables Start + # of Reserved Sectors
		14	Root Directory Entry Start + # of Reserved + (# of Sectors Per FAT * 2)
		15	Data Area (Starts with Cluster #2) Start + # of Reserved + (# of Sectors Per FAT * 2) + ((Maximum Root Directory Entries * 32) / Bytes per Sector)
		16	*/
		17
		18
		19	/*
		20	________________________________________________________________________________________________________________________________________
		21
		22	Structure of an partition entry
		23	________________________________________________________________________________________________________________________________________
		24
		25	Partition Entry is 16 bytes long
		26	*/
		27	typedef struct
		28	{
		29	uint8_t PartitionState; // Current State of Partition (00h=Inactive, 80h=Active)
		30	uint8_t BeginningHead; // Beginning of Partition - Head
		31	uint16_t BeginningCylSec; // Beginning of Partition - Cylinder/Sector (See Below)
		32	uint8_t Type; // Type of Partition (See List Below)
		33	uint8_t EndHead; // End of Partition - Head
		34	uint16_t EndCylSec; // End of Partition - Cylinder/Sector
		35	uint32_t NoSectorsBeforePartition; // Number of Sectors between the MBR and the First Sector in the Partition
		36	uint32_t NoSectorsPartition ; // Number of Sectors in the Partition
		37	} __attribute__((packed)) PartitionEntry_t;
		38
		39	/*
		40	Coding of Cylinder/Sector words
		41
		42	Cylinder is 10 bits: [7:0] at [15:8] and [9:8] at [7:6]
		43	Sector is 5 bits: [5:0] at [5:0]
		44	*/
		45
		46	// Partition Types:
		47	#define PART_TYPE_UNKNOWN 0x00
		48	#define PART_TYPE_FAT12 0x01
		49	#define PART_TYPE_XENIX 0x02
		50	#define PART_TYPE_FAT16_ST_32_MB 0x04
		51	#define PART_TYPE_EXTDOS 0x05
		52	#define PART_TYPE_FAT16_LT_32_MB 0x06
		53	#define PART_TYPE_NTFS 0x07
		54	#define PART_TYPE_FAT32 0x0B
		55	#define PART_TYPE_FAT32LBA 0x0C
		56	#define PART_TYPE_FAT16LBA 0x0E
		57	#define PART_TYPE_EXTDOSLBA 0x0F
		58	#define PART_TYPE_EISA 0x12
		59	#define PART_TYPE_ONTRACK 0x33
		60	#define PART_TYPE_NOVELL 0x40
		61	#define PART_TYPE_DYNAMIC 0x42
		62	#define PART_TYPE_PCIX 0x4B
		63	#define PART_TYPE_LINUX_SWAP 0x82
		64	#define PART_TYPE_LINUX_NATIVE 0x83
		65	#define PART_TYPE_LINUX_LVM 0x8E
		66	#define PART_TYPE_PHOENIXSAVE 0xA0
		67	#define PART_TYPE_FREEBSD 0xA5
		68	#define PART_TYPE_OPENBSD 0xA6
		69	#define PART_TYPE_NETNBSD 0xA9
		70	#define PART_TYPE_CPM 0xDB
		71	#define PART_TYPE_DBFS 0xE0
		72	#define PART_TYPE_BBT 0xFF
		73
		74
		75	/*
		76	________________________________________________________________________________________________________________________________________
		77
		78	Structure of the MasterBootRecord
		79	________________________________________________________________________________________________________________________________________
		80
		81	Master Boot Record is 512 bytes long
		82	The Master Boot Record is the same for pretty much all Operating Systems.
		83	It is located on the first Sector of the Hard Drive, at Cylinder 0, Head 0, Sector 1
		84	*/
		85	typedef struct
		86	{
		87	uint8_t ExecutableCode[446]; // 446 bytes for machine start code
		88	PartitionEntry_t PartitionEntry1; // 16 bytes for partition entry 1
		89	PartitionEntry_t PartitionEntry2; // 16 bytes for partition entry 2
		90	PartitionEntry_t PartitionEntry3; // 16 bytes for partition entry 3
		91	PartitionEntry_t PartitionEntry4; // 16 bytes for partition entry 4
		92	uint16_t ExecutableMarker; // BIOS-Signature (0x55 0xAA)
		93	} __attribute__((packed)) MBR_Entry_t;
		94
		95
		96	/*
		97	________________________________________________________________________________________________________________________________________
		98
		99	Structure of the VolumeBootRecord
		100	________________________________________________________________________________________________________________________________________
		101
		102	The Volume Boot Record is 512 bytes long
		103	This information is located in the first sector of every partition.
		104	*/
		105	typedef struct
		106	{
		107	uint8_t JumpCode[3]; // Jump Code + NOP
		108	int8_t OEMName[8]; // OEM Name
		109	uint16_t BytesPerSector; // Bytes Per Sector
		110	uint8_t SectorsPerCluster; // Sectors Per Cluster
		111	uint16_t ReservedSectors; // Reserved Sectors
		112	uint8_t NoFATCopies; // Number of Copies of FAT
		113	uint16_t MaxRootEntries; // Maximum Root Directory Entries
		114	uint16_t NoSectorsInPartSml32MB; // Number of Sectors in Partition Smaller than 32 MB
		115	uint8_t MediaDescriptor; // Media Descriptor (0xF8 for Hard Disks)
		116	uint16_t SectorsPerFAT; // Sectors Per FAT
		117	uint16_t SectorsPerTrack; // Sectors Per Track
		118	uint16_t NoHeads; // Number of Heads
		119	uint32_t NoHiddenSectors; // Number of Hidden Sectors in Partition
		120	uint32_t NoSectors; // Number of Sectors in Partition
		121	uint16_t DriveNo; // Logical Drive Number of Partition
		122	uint8_t ExtendedSig; // Extended Signature (0x29)
		123	uint32_t SerialNo; // Serial Number of the Partition
		124	int8_t VolumeName[11]; // Volume Name of the Partititon
		125	int8_t FATName[8]; // FAT Name (FAT16)
		126	uint8_t ExecutableCode[446]; // 446 bytes for machine start code
		127	uint16_t ExecutableMarker; // Executable Marker (0x55 0xAA)
		128	} __attribute__((packed)) VBR_Entry_t;
		129
		130
		131
		132	/*
		133	________________________________________________________________________________________________________________________________________
		134
		135	Structure of an directory entry
		136	________________________________________________________________________________________________________________________________________
		137
		138	Directory entry is 32 bytes.
		139	*/
		140	typedef struct
		141	{
		142	int8_t Name[8]; // 8 bytes name, padded with spaces.
		143	uint8_t Extension[3]; // 3 bytes extension, padded with spaces.
		144	uint8_t Attribute; // attribute of the directory entry (unused,archive,read-only,system,directory,volume)
		145	uint8_t Reserved[10]; // reserved bytes within the directory entry.
		146	uint32_t DateTime; // date and time of last write access to the file or directory.
		147	uint16_t StartCluster; // first cluster of the file or directory.
		148	uint32_t Size; // size of the file or directory in bytes.
		149	} __attribute__((packed)) DirEntry_t;
		150
		151	#define SLOT_EMPTY 0x00 // slot has never been used
		152	#define SLOT_E5 0x05 // the real value is 0xe5
		153	#define SLOT_DELETED 0xE5 // file in this slot deleted
		154
		155	#define ATTR_NONE 0x00 // normal file
		156	#define ATTR_READONLY 0x01 // file is readonly
		157	#define ATTR_HIDDEN 0x02 // file is hidden
		158	#define ATTR_SYSTEM 0x04 // file is a system file
		159	#define ATTR_VOLUMELABEL 0x08 // entry is a volume label
		160	#define ATTR_LONG_FILENAME 0x0F // this is a long filename entry
		161	#define ATTR_SUBDIRECTORY 0x10 // entry is a directory name
		162	#define ATTR_ARCHIVE 0x20 // file is new or modified
		163
		164
		165	/*
		166	________________________________________________________________________________________________________________________________________
		167
		168	Structure of an entry within the fileallocationtable.
		169	________________________________________________________________________________________________________________________________________
		170	*/
		171	typedef struct
		172	{
		173	uint16_t NextCluster; // the next cluster of the file.
		174	} __attribute__((packed)) Fat16Entry_t;
		175
		176	// secial fat entries
		177	#define FAT16_CLUSTER_FREE 0x0000
		178	#define FAT16_CLUSTER_RESERVED 0x0001
		179	#define FAT16_CLUSTER_USED_MIN 0x0002
		180	#define FAT16_CLUSTER_USED_MAX 0xFFEF
		181	#define FAT16_CLUSTER_ROOTDIR_MIN 0xFFF0
		182	#define FAT16_CLUSTER_ROOTDIR_MAX 0xFFF6
		183	#define FAT16_CLUSTER_BAD 0xFFF7
		184	#define FAT16_CLUSTER_LAST_MIN 0xFFF8
		185	#define FAT16_CLUSTER_LAST_MAX 0xFFFF
		186
		187	/*****************************************************************************************************************************************/
		188	/* */
		189	/* Global variables needed for read- or write-acces to the FAT16- filesystem. */
		190	/* */
		191	/*****************************************************************************************************************************************/
		192
		193	#define MBR_SECTOR 0x00 // the masterboot record is located in sector 0.
		194	#define DIRENTRY_SIZE 32 //bytes
		195	#define DIRENTRIES_PER_SECTOR BYTES_PER_SECTOR/DIRENTRY_SIZE
		196	#define FAT16_BYTES 2
		197	#define FAT16_ENTRIES_PER_SECTOR BYTES_PER_SECTOR/FAT16_BYTES
		198
		199	#define FSTATE_UNUSED 0
		200	#define FSTATE_USED 1
		201
		202	typedef struct
		203	{
		204	uint8_t IsValid; // 0 means invalid, else valid
		205	uint8_t SectorsPerCluster; // how many sectors does a cluster contain?
		206	uint8_t FatCopies; // Numbers of copies of the FAT
		207	uint16_t MaxRootEntries; // Possible number of entries in the root directory.
		208	uint16_t SectorsPerFat; // how many sectors does a fat16 contain?
		209	uint32_t FirstFatSector; // sector of the start of the fat
		210	uint32_t FirstRootDirSector; // sector of the rootdirectory
		211	uint32_t FirstDataSector; // sector of the first cluster containing data (cluster2).
		212	uint32_t LastDataSector; // the last data sector of the partition
		213	} Partition_t;
		214
		215	Partition_t Partition; // Structure holds partition information
		216
		217	File_t FilePointer[FILE_MAX_OPEN]; // Allocate Memmoryspace for each filepointer used.
		218
		219
		220	/****************************************************************************************************************************************/
		221	/* Function: FileDateTime(DateTime_t ); /
		222	/* */
		223	/* Description: This function calculates the DOS date time from a pointer to a time structure. */
		224	/* */
		225	/* Returnvalue: Returns the DOS date time. */
		226	/****************************************************************************************************************************************/
		227
		228	uint32_t FileDateTime(DateTime_t * pTimeStruct)
		229	{
		230	uint32_t datetime = 0;
		231	if((pTimeStruct == 0) \|\| !(pTimeStruct->Valid)) return datetime;
		232
		233	datetime \|= (0x0000007FL & (uint32_t)(pTimeStruct->Year - 1980))<<25; // set year
		234	datetime \|= (0x0000000FL & (uint32_t)(pTimeStruct->Month))<<21; // set month
		235	datetime \|= (0x0000001FL & (uint32_t)(pTimeStruct->Day))<<16;
		236	datetime \|= (0x0000001FL & (uint32_t)(pTimeStruct->Hour))<<11;
		237	datetime \|= (0x0000003FL & (uint32_t)(pTimeStruct->Min))<<5;
		238	datetime \|= (0x0000001FL & (uint32_t)(pTimeStruct->Sec/2));
		239	return datetime;
		240	}
		241
		242
		243	/****************************************************************************************************************************************/
		244	/* Function: LockFilePointer(); */
		245	/* */
		246	/* Description: This function trys to lock a free file pointer. */
		247	/* */
		248	/* Returnvalue: Returns the Filepointer on success or 0. */
		249	/****************************************************************************************************************************************/
		250	File_t * LockFilePointer(void)
		251	{
		252	uint8_t i;
		253	File_t * File = 0;
		254	for(i = 0; i < FILE_MAX_OPEN; i++)
		255	{
		256	if(FilePointer[i].State == FSTATE_UNUSED) // found an unused one
		257	{
		258	File = &FilePointer[i]; // set pointer to that entry
		259	FilePointer[i].State = FSTATE_USED; // mark it as used
		260	break;
		261	}
		262	}
		263	return(File);
		264	}
		265
		266	/****************************************************************************************************************************************/
		267	/* Function: UnlockFilePointer(file_t ); /
		268	/* */
		269	/* Description: This function trys to unlock a file pointer. */
		270	/* */
		271	/* Returnvalue: Returns 1 if file pointer was freed else 0. */
		272	/****************************************************************************************************************************************/
		273	uint8_t UnlockFilePointer(File_t * file)
		274	{
		275	uint8_t cnt;
		276	if(file == NULL) return(0);
		277	for(cnt = 0; cnt < FILE_MAX_OPEN; cnt++)
		278	{
		279	if(&FilePointer[cnt] == file) // filepointer to be freed found?
		280	{
		281	file->State = FSTATE_UNUSED;
		282	file->FirstSectorOfFirstCluster = 0; // Sectorpointer to the first sector of the first datacluster of the file.
		283	file->FirstSectorOfCurrCluster = 0;
		284	file->SectorOfCurrCluster = 0; // Pointer to the cluster which is edited at the moment.
		285	file->SectorOfCurrCluster = 0; // The sector which is edited at the moment (cluster_pointer + sector_index).
		286	file->ByteOfCurrSector = 0; // The bytelocation within the current sector (cluster_pointer + sector_index + byte_index).
		287	file->Mode = 0; // mode of fileoperation (read,write)
		288	file->Size = 0; // the size of the opend file in bytes.
		289	file->Position = 0; // pointer to a character within the file 0 < fileposition < filesize
		290	file->SectorInCache = 0; // the last sector read, wich is still in the sectorbuffer.
		291	file->DirectorySector = 0; // the sectorposition where the directoryentry has been made.
		292	file->DirectoryIndex = 0; // the index to the directoryentry within the specified sector.
		293	file->Attribute = 0; // the attribute of the file opened.
		294	file = NULL;
		295	return(1);
		296	}
		297	}
		298	return(0);
		299	}
		300
		301	/****************************************************************************************************************************************/
		302	/* Function: SeperateDirName(int8_t, int8_t); */
		303	/* */
		304	/* Description: This function seperates the first dirname from filepath and brings them */
		305	/* into the needed format ('test.txt' -> 'TEST TXT') */
		306	/* The subpath is the pointer to the remaining substring if the filepath */
		307	/* */
		308	/* Returnvalue: Return NULL on error or pointer to subpath */
		309	/****************************************************************************************************************************************/
		310	int8_t* SeperateDirName(const int8_t filepath, int8_t dirname)
		311	{
		312	int8_t* subpath = NULL;
		313	uint8_t readpointer = 0;
		314	uint8_t writepointer = 0;
		315
		316	// search subpath from beginning of filepath
		317	subpath = NULL;
		318	readpointer = 0;
		319	if(filepath[0] == '/') readpointer = 1; // ignore first '/'
		320	while(subpath == NULL) // search the filepath until a subpath was found.
		321	{
		322	if(((filepath[readpointer] == 0) \|\| (filepath[readpointer] == '/'))) // if '/' found or end of filepath reached
		323	{
		324	subpath = (int8_t*)&filepath[readpointer]; // store the position of the first "/" found after the beginning of the filenpath
		325	}
		326	readpointer++;
		327	}
		328
		329	// clear dirname with spaces
		330	dirname[11] = 0; // terminate dirname
		331	for(writepointer = 0; writepointer < 11; writepointer++) dirname[writepointer] = ' ';
		332	writepointer = 0;
		333	// start seperating the dirname from the filepath.
		334	readpointer = 0;
		335	if(filepath[0] == '/') readpointer = 1; // ignore first '/'
		336	while( &filepath[readpointer] < subpath)
		337	{
		338	if(writepointer >= 11) return(NULL); // dirname to long
		339	if(filepath[readpointer] == '.') // seperating dirname and extension.
		340	{
		341	if(writepointer <= 8)
		342	{
		343	readpointer++; // next character in filename
		344	writepointer = 8; // jump to start of extension
		345	}
		346	else return(NULL); // dirbasename to long
		347	}
		348	else
		349	{
		350	if((0x60 < filepath[readpointer]) && (filepath[readpointer] < 0x7B))
		351	{
		352	dirname[writepointer] = (filepath[readpointer] - 0x20); // all characters must be upper case.
		353	}
		354	else
		355	{
		356	dirname[writepointer] = filepath[readpointer];
		357	}
		358	readpointer++;
		359	writepointer++;
		360	}
		361	}
		362	return(subpath);
		363	}
		364
		365
		366	/*************************************************************************************************************************************+/
		367	/* Function: Fat16ClusterToSector( uint16_t cluster); */
		368	/* */
		369	/* Description: This function converts a cluster number given by the fat to the corresponding */
		370	/* sector that points to the start of the data area that is represented by the cluster number. */
		371	/* */
		372	/* Returnvalue: The sector number with the data area of the given cluster */
		373	/****************************************************************************************************************************************/
		374	uint32_t Fat16ClusterToSector(uint16_t cluster)
		375	{
		376	if(!Partition.IsValid) return 0;
		377	if (cluster < 2) cluster = 2; // the 0. and 1. cluster in the fat are used for the media descriptor
		378	return ( (cluster - 2) * Partition.SectorsPerCluster) + Partition.FirstDataSector; // the first data sector is represented by the 2nd cluster
		379	}
		380
		381	/****************************************************************************************************************************************/
		382	/* Function: SectorToFat16Cluster( uint32_t sector); */
		383	/* */
		384	/* Description: This function converts a given sector number given to the corresponding */
		385	/* cluster number in the fat that represents this data area. */
		386	/* */
		387	/* Returnvalue: The cluster number representing the data area of the sector. */
		388	/****************************************************************************************************************************************/
		389	uint16_t SectorToFat16Cluster(uint32_t sector)
		390	{
		391	if(!Partition.IsValid) return 0;
		392	return ((uint16_t)((sector - Partition.FirstDataSector) / Partition.SectorsPerCluster) + 2);
		393	}
		394
		395
		396	/****************************************************************************************************************************************/
		397	/* Function: Fat16_Deinit(void); */
		398	/* */
		399	/* Description: This function uninitializes the fat 16 api */
		400	/* */
		401	/* Returnvalue: The function returns "0" on success */
		402	/****************************************************************************************************************************************/
		403	uint8_t Fat16_Deinit(void)
		404	{
		405	int16_t returnvalue = 0;
		406	uint8_t cnt;
		407	// declare the filepointers as unused.
		408	for(cnt = 0; cnt < FILE_MAX_OPEN; cnt++)
		409	{
		410	if(FilePointer[cnt].State == FSTATE_USED)
		411	{
		412	returnvalue += fclose_(&FilePointer[cnt]); // try to close open file pointers
		413	}
		414
		415	}
		416	SDC_Deinit(); // uninitialize interface to sd-card
		417	Partition.IsValid = 0; // mark data in partition structure as invalid
		418	return(returnvalue);
		419	}
		420
		421	/****************************************************************************************************************************************/
		422	/* Function: Fat16_Init(void); */
		423	/* */
		424	/* Description: This function reads the Masterbootrecord and finds the position of the Volumebootrecord, the FAT and the Rootdir */
		425	/* and stores the information in global variables. */
		426	/* */
		427	/* Returnvalue: The function returns "0" if the filesystem is initialized. */
		428	/****************************************************************************************************************************************/
		429	uint8_t Fat16_Init(void)
		430	{
		431	uint8_t cnt = 0;
		432	uint32_t partitionfirstsector;
		433	VBR_Entry_t *VBR;
		434	MBR_Entry_t *MBR;
		435	File_t *file;
		436	uint8_t result = 0;
		437
		438	printf("\r\n FAT16 init...");
		439	Partition.IsValid = 0;
		440
		441	// declare the filepointers as unused.
		442	for(cnt = 0; cnt < FILE_MAX_OPEN; cnt++)
		443	{
		444	FilePointer[cnt].State = FSTATE_UNUSED;
		445	}
		446	// set current file pinter to first position in list
		447	file = &FilePointer[0];
		448
		449	// try to initialise the sd-card.
		450	if(SD_SUCCESS != SDC_Init())
		451	{
		452	printf("SD-Card could not be initialized.");
		453	result = 1;
		454	goto end;
		455	}
		456
		457	// SD-Card is initialized successfully
		458	if(SD_SUCCESS != SDC_GetSector((uint32_t)MBR_SECTOR,file->Cache)) // Read the MasterBootRecord
		459	{
		460	printf("Error reading the MBR.");
		461	result = 2;
		462	goto end;
		463	}
		464	MBR = (MBR_Entry_t *)file->Cache; // Enter the MBR using the structure MBR_Entry_t.
		465	if((MBR->PartitionEntry1.Type == PART_TYPE_FAT16_ST_32_MB) \|\|
		466	(MBR->PartitionEntry1.Type == PART_TYPE_FAT16_LT_32_MB) \|\|
		467	(MBR->PartitionEntry1.Type == PART_TYPE_FAT16LBA))
		468	{
		469	// get sector offset 1st partition
		470	partitionfirstsector = MBR->PartitionEntry1.NoSectorsBeforePartition;
		471	// Start of Partition is the Volume Boot Sector
		472	if(SD_SUCCESS != SDC_GetSector(partitionfirstsector,file->Cache)) // Read the volume boot record
		473	{
		474	printf("Error reading the VBR.");
		475	result = 3;
		476	goto end;
		477	}
		478	}
		479	else // maybe the medium has no partition assuming sector 0 is the vbr
		480	{
		481	partitionfirstsector = 0;
		482	}
		483
		484	VBR = (VBR_Entry_t *) file->Cache; // Enter the VBR using the structure VBR_Entry_t.
		485	if(VBR->BytesPerSector != BYTES_PER_SECTOR)
		486	{
		487	printf("VBR: Sector size not supported.");
		488	result = 4;
		489	goto end;
		490	}
		491	Partition.SectorsPerCluster = VBR->SectorsPerCluster; // Number of sectors per cluster. Depends on the memorysize of the sd-card.
		492	Partition.FatCopies = VBR->NoFATCopies; // Number of fatcopies.
		493	Partition.MaxRootEntries = VBR->MaxRootEntries; // How many Entries are possible in the rootdirectory (FAT16 allows max. 512 entries).
		494	Partition.SectorsPerFat = VBR->SectorsPerFAT; // The number of sectors per FAT.
		495
		496	/* Calculate the sectorpositon of the FAT, the Rootdirectory and the first Datacluster. */
		497	// Calculate the position of the FileAllocationTable:
		498	// Start + # of Reserved Sectors
		499	Partition.FirstFatSector = (uint32_t)(partitionfirstsector + (uint32_t)(VBR->ReservedSectors));
		500	// Calculate the position of the Rootdirectory:
		501	// Start + # of Reserved Sectors + (# of Sectors Per FAT * # of FAT Copies)
		502	Partition.FirstRootDirSector = Partition.FirstFatSector + (uint32_t)((uint32_t)Partition.SectorsPerFat*(uint32_t)Partition.FatCopies);
		503	// Calculate the position of the first datacluster:
		504	// Start + # of Reserved + (# of Sectors Per FAT * # of FAT Copies) + ((Maximum Root Directory Entries * 32) / Bytes per Sector)
		505	Partition.FirstDataSector = Partition.FirstRootDirSector + (uint32_t)(Partition.MaxRootEntries>>4); // assuming 512 Byte Per Sector
		506	// Calculate the last data sector
		507	if(VBR->NoSectors == 0)
		508	{
		509	printf("VBR: Bad number of sectors.");
		510	result = 5;
		511	goto end;
		512	}
		513	Partition.LastDataSector = Partition.FirstDataSector + VBR->NoSectors - 1;
		514	// check for FAT16 in VBR of first partition
		515	if(!((VBR->FATName[0]=='F') && (VBR->FATName[1]=='A') && (VBR->FATName[2]=='T') && (VBR->FATName[3]=='1')&&(VBR->FATName[4]=='6')))
		516	{
		517	printf("VBR: Partition ist not FAT16 type.");
		518	result = 6;
		519	goto end;
		520	}
		521	Partition.IsValid = 1; // mark data in partition structure as valid
		522	result = 0;
		523	end:
		524	if(result != 0) Fat16_Deinit();
		525	else printf(" ...ok");
		526	return(result);
		527	}
		528
		529	/****************************************************************************************************************************************/
		530	/* Function: Fat16_IsValid(void); */
		531	/* */
		532	/* Description: This function return the Fat 15 filesystem state */
		533	/* */
		534	/* Returnvalue: The function returns "1" on success */
		535	/****************************************************************************************************************************************/
		536	uint8_t Fat16_IsValid(void)
		537	{
		538	return(Partition.IsValid);
		539	}
		540
		541	/****************************************************************************************************************************************/
		542	/* Function: ClearCurrCluster(File_t); /
		543	/* */
		544	/* Description: This function fills the current cluster with 0. */
		545	/* */
		546	/* Returnvalue: The function returns 1 on success else 0. */
		547	/****************************************************************************************************************************************/
		548	uint8_t ClearCurrCluster(File_t * file)
		549	{
		550	uint8_t retvalue = 1;
		551	uint32_t i;
		552
		553	if((!Partition.IsValid) \|\| (file == NULL)) return(0);
		554
		555	for(i = 0; i < BYTES_PER_SECTOR; i++) file->Cache[i] = 0; // clear file cache
		556	for(i = 0; i < Partition.SectorsPerCluster; i++)
		557	{
		558	file->SectorInCache = file->FirstSectorOfCurrCluster + i;
		559	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))
		560	{
		561	Fat16_Deinit();
		562	retvalue = 0;
		563	}
		564	}
		565	return(retvalue);
		566	}
		567
		568	/*****************************************************************************************************************************************/
		569	/* Function: GetNextCluster(File_t* ); */
		570	/* */
		571	/* Description: This function finds the next datacluster of the file specified with File File. /
		572	/* */
		573	/* Returnvalue: The function returns the next cluster or 0 if the last cluster has already reached. */
		574	/*****************************************************************************************************************************************/
		575	uint16_t GetNextCluster(File_t * file)
		576	{
		577	uint16_t cluster = 0;
		578	uint32_t fat_byte_offset, sector, byte;
		579	Fat16Entry_t * fat;
		580
		581	if((!Partition.IsValid) \|\| (file == NULL)) return(cluster);
		582	// if sector is within the data area
		583	if((Partition.FirstDataSector <= file->FirstSectorOfCurrCluster)&& (file->FirstSectorOfCurrCluster <= Partition.LastDataSector))
		584	{
		585	// determine current file cluster
		586	cluster = SectorToFat16Cluster(file->FirstSectorOfCurrCluster);
		587	// calculate byte offset in the fat for corresponding entry
		588	fat_byte_offset = ((uint32_t)cluster)<<1; // two FAT bytes (16 bits) for every cluster
		589	// calculate the sector that contains the current cluster within the fat
		590	sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);
		591	// calculate byte offset of the current cluster within that fat sector
		592	byte = fat_byte_offset % BYTES_PER_SECTOR;
		593	// read this sector to the file cache
		594	if(file->SectorInCache != sector)
		595	{
		596	file->SectorInCache = sector; // update sector stored in buffer
		597	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read sector from sd-card
		598	{
		599	Fat16_Deinit();
		600	return (cluster);
		601	}
		602	}
		603	// read the next cluster from cache
		604	fat = (Fat16Entry_t *)(&(file->Cache[byte]));
		605	cluster = fat->NextCluster;
		606	// if last cluster fat entry
		607	if(FAT16_CLUSTER_LAST_MIN <= cluster)
		608	{
		609	cluster = 0;
		610	}
		611	else
		612	{
		613	file->FirstSectorOfCurrCluster = Fat16ClusterToSector(cluster);
		614	file->SectorOfCurrCluster = 0;
		615	file->ByteOfCurrSector = 0;
		616	}
		617	}
		618	return(cluster);
		619	}
		620
		621
		622	/****************************************************************************************************************************************/
		623	/* Function: FindNextFreeCluster(File_t ); /
		624	/* */
		625	/* Description: This function looks in the fat to find the next free cluster */
		626	/* */
		627	/* Returnvalue: The function returns the cluster number of the next free cluster found within the fat. */
		628	/****************************************************************************************************************************************/
		629	uint16_t FindNextFreeCluster(File_t *file)
		630	{
		631	uint32_t fat_sector; // current sector within the fat relative to the first sector of the fat.
		632	uint32_t curr_sector; // current sector
		633	uint16_t fat_entry; // index to an fatentry within the actual sector (256 fatentries are possible within one sector).
		634	uint16_t free_cluster = 0; // next free cluster number.
		635	Fat16Entry_t * fat;
		636
		637	if((!Partition.IsValid) \|\| (file == NULL)) return(0);
		638
		639	// start searching for an empty cluster at the beginning of the fat.
		640	fat_sector = 0;
		641	do
		642	{
		643	curr_sector = Partition.FirstFatSector + fat_sector; // calculate sector to read
		644	file->SectorInCache = curr_sector; // upate the sector number of file cache.
		645	if( SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read sector of fat from sd-card.
		646	{
		647	Fat16_Deinit();
		648	return(free_cluster);
		649	}
		650
		651	fat = (Fat16Entry_t *)file->Cache; // set fat pointer to file cache
		652
		653	for(fat_entry = 0; fat_entry < FAT16_ENTRIES_PER_SECTOR; fat_entry++) // look for an free cluster at all entries in this sector of the fat.
		654	{
		655	if(fat[fat_entry].NextCluster == FAT16_CLUSTER_FREE) // empty cluster found!!
		656	{
		657	fat[fat_entry].NextCluster = FAT16_CLUSTER_LAST_MAX; // mark this fat-entry as used
		658	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache)) // and save the sector at the sd-card.
		659	{
		660	Fat16_Deinit();
		661	return(free_cluster);
		662	}
		663	free_cluster = (uint16_t)(fat_sector * FAT16_ENTRIES_PER_SECTOR + (uint32_t)fat_entry);
		664	fat_entry = FAT16_ENTRIES_PER_SECTOR; // terminate the search for a free cluster in this sector.
		665	}
		666	}
		667	fat_sector++; // continue the search in next fat sector
		668	// repeat until the end of the fat is reached and no free cluster has been found so far
		669	}while((fat_sector < Partition.SectorsPerFat) && (!free_cluster));
		670	return(free_cluster);
		671	}
		672
		673
		674	/****************************************************************************************************************************************************/
		675	/* Function: int16_t fseek_(File_t , int32_t , uint8_t) */
		676	/* */
		677	/* Description: This function sets the pointer of the stream relative to the position */
		678	/* specified by origin (SEEK_SET, SEEK_CUR, SEEK_END) */
		679	/* Returnvalue: Is 1 if seek was successful */
		680	/****************************************************************************************************************************************************/
		681	int16_t fseek_(File_t * const file, int32_t offset, int16_t origin)
		682	{
		683	int32_t fposition = 0;
		684	int16_t retvalue = 1;
		685
		686	if((!Partition.IsValid) \|\| (file == NULL)) return(0);
		687	switch(origin)
		688	{
		689	case SEEK_SET: // Fileposition relative to the beginning of the file.
		690	fposition = 0;
		691	break;
		692	case SEEK_END: // Fileposition relative to the end of the file.
		693	fposition = (int32_t)file->Size;
		694	break;
		695	case SEEK_CUR: // Fileposition relative to the current position of the file.
		696	default:
		697	fposition = file->Position;
		698	break;
		699	}
		700
		701	fposition += offset;
		702
		703	if((fposition >= 0) && (fposition <= (int32_t)file->Size)) // is the pointer still within the file?
		704	{
		705	// reset file position to start of the file
		706	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		707	file->SectorOfCurrCluster = 0;
		708	file->ByteOfCurrSector = 0;
		709	file->Position = 0;
		710
		711	while(file->Position < fposition) // repeat until the current position is less than target
		712	{
		713	file->Position++; // increment file position
		714	file->ByteOfCurrSector++; // next byte in current sector
		715	if(file->ByteOfCurrSector >= BYTES_PER_SECTOR)
		716	{
		717	file->ByteOfCurrSector = 0; // reading at the beginning of new sector.
		718	file->SectorOfCurrCluster++; // continue reading in next sector
		719	if(file->SectorOfCurrCluster >= Partition.SectorsPerCluster) // if end of cluster is reached, the next datacluster has to be searched in the FAT.
		720	{
		721	if(GetNextCluster(file)) // Sets the clusterpointer of the file to the next datacluster.
		722	{
		723	file->SectorOfCurrCluster = 0;
		724	}
		725	else // the last cluster was allready reached
		726	{
		727	file->SectorOfCurrCluster--; // jump back to the ast sector in the last cluster
		728	file->ByteOfCurrSector = BYTES_PER_SECTOR; // set ByteOfCurrSector one byte over sector end
		729	}
		730	}
		731	}
		732	}
		733	}
		734	if(file->Position == fposition) retvalue = 0;
		735	return(retvalue);
		736	}
		737
		738
		739	/****************************************************************************************************************************************/
		740	/* Function: uint16_t DeleteClusterChain(File file); /
		741	/* */
		742	/* Description: This function trances along a cluster chain in the fat and frees all clusters visited. */
		743	/* */
		744	/****************************************************************************************************************************************/
		745	uint8_t DeleteClusterChain(uint16_t StartCluster)
		746	{
		747	uint16_t cluster;
		748	uint32_t fat_byte_offset, sector, byte;
		749	Fat16Entry_t * fat;
		750	uint8_t buffer[BYTES_PER_SECTOR];
		751	uint32_t sector_in_buffer = 0;
		752	uint8_t repeat = 0;
		753
		754	if(!Partition.IsValid) return 0;
		755
		756	cluster = StartCluster; // init chain trace
		757	// calculate byte offset in the fat for corresponding entry
		758	fat_byte_offset = ((uint32_t)cluster)<<1; // two FAT bytes (16 bits) for every cluster
		759	// calculate the sector that contains the current cluster within the fat
		760	sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);
		761	// calculate byte offset of the current cluster within that fat sector
		762	byte = fat_byte_offset % BYTES_PER_SECTOR;
		763	do
		764	{
		765	if(sector != sector_in_buffer)
		766	{
		767	// read this sector to buffer
		768	sector_in_buffer = sector;
		769	if(SD_SUCCESS != SDC_GetSector(sector_in_buffer, buffer)) return 0; // read sector from sd-card
		770	}
		771	// read the next cluster from cache
		772	fat = (Fat16Entry_t *)(&(buffer[byte]));
		773	cluster = fat->NextCluster;
		774	if((FAT16_CLUSTER_USED_MIN <= cluster) && (cluster <= FAT16_CLUSTER_USED_MAX) ) repeat = 1;
		775	else repeat = 0;
		776
		777	fat->NextCluster = FAT16_CLUSTER_FREE; // mark current cluster as free
		778	// calculate byte offset in the fat for corresponding entry
		779	fat_byte_offset = ((uint32_t)cluster)<<1; // two FAT bytes (16 bits) for every cluster
		780	// calculate the sector that contains the current cluster within the fat
		781	sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);
		782	// calculate byte offset of the current cluster within that fat sector
		783	byte = fat_byte_offset % BYTES_PER_SECTOR;
		784	// if new sector is not the sector in buffer or the last cluster in the chain was traced
		785	if((sector != sector_in_buffer) \|\| !repeat)
		786	{ // write sector in buffer
		787	if(SD_SUCCESS != SDC_PutSector(sector_in_buffer,buffer)) return 0;
		788	}
		789	}
		790	while(repeat);
		791
		792	return 1;
		793	}
		794
		795
		796	/****************************************************************************************************************************************/
		797	/* Function: uint16_t AppendCluster(File file); /
		798	/* */
		799	/* Description: This function looks in the fat to find the next free cluster and appends it to the file. */
		800	/* */
		801	/* Returnvalue: The function returns the appened cluster number or 0 of no cluster was appended. */
		802	/****************************************************************************************************************************************/
		803	uint16_t AppendCluster(File_t *file)
		804	{
		805	uint16_t last_cluster, new_cluster = 0;
		806	uint32_t fat_byte_offset, sector, byte;
		807	Fat16Entry_t * fat;
		808
		809	if((!Partition.IsValid) \|\| (file == NULL)) return(new_cluster);
		810
		811	new_cluster = FindNextFreeCluster(file); // the next free cluster found on the disk.
		812	if(new_cluster)
		813	{ // A free cluster was found and can be added to the end of the file.
		814	fseek_(file, 0, SEEK_END); // jump to the end of the file
		815	last_cluster = SectorToFat16Cluster(file->FirstSectorOfCurrCluster); // determine current file cluster
		816	fat_byte_offset = ((uint32_t)last_cluster)<<1;
		817	sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);
		818	byte = fat_byte_offset % BYTES_PER_SECTOR;
		819
		820	if(file->SectorInCache != sector)
		821	{
		822	file->SectorInCache = sector; // update sector stored in buffer
		823	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read sector from sd-card
		824	{
		825	Fat16_Deinit();
		826	return(0);
		827	}
		828	}
		829	fat = (Fat16Entry_t *)(&(file->Cache[byte]));
		830	fat->NextCluster = new_cluster; // append the free cluster to the end of the file in the FAT.
		831	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache)) // save the modified sector to the FAT.
		832	{
		833	Fat16_Deinit();
		834	return(0);
		835	}
		836	file->FirstSectorOfCurrCluster = Fat16ClusterToSector(new_cluster);
		837	file->SectorOfCurrCluster = 0;
		838	file->ByteOfCurrSector = 0;
		839	}
		840	return(new_cluster);
		841	}
		842
		843	/****************************************************************************************************************************************************/
		844	/* Function: DirectoryEntryExist(int8_t , uint8_t, uint8_t, File_t ) */
		845	/* */
		846	/* Description: This function searches all possible dir entries until the file or directory is found or the end of the directory is reached */
		847	/* */
		848	/* Returnvalue: This function returns 1 if the directory entry specified was found. */
		849	/****************************************************************************************************************************************************/
		850	uint8_t DirectoryEntryExist(int8_t dirname, uint8_t attribfilter, uint8_t attribmask, File_t file)
		851	{
		852	uint32_t dir_sector, max_dir_sector, curr_sector;
		853	uint16_t dir_entry = 0;
		854
		855	uint16_t end_of_directory_not_reached = 0;
		856	uint8_t i = 0;
		857	uint8_t direntry_exist = 0;
		858	DirEntry_t * dir;
		859
		860	// if incomming pointers are useless return immediatly
		861	if((!Partition.IsValid) \|\| (file == NULL) \|\| (dirname == NULL)) return(direntry_exist);
		862
		863	// dir entries can be searched only in filesclusters that have
		864	// a corresponding dir entry with adir-flag set in its attribute
		865	// or direct within the root directory area
		866
		867	file->FirstSectorOfFirstCluster = 0;
		868	// no current directory exist therefore assume searching in the root
		869	if(file->DirectorySector == 0)
		870	{
		871	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		872	file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
		873	}
		874	// within the root directory area we can read sectors sequentially until the end of this area
		875	else if((Partition.FirstRootDirSector <= file->DirectorySector) && (file->DirectorySector < Partition.FirstDataSector))
		876	{
		877	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		878	}
		879	// within the data clusters we can read sectors sequentially only within the cluster
		880	else if((Partition.FirstDataSector <= file->DirectorySector) && (file->DirectorySector <= Partition.LastDataSector))
		881	{
		882	max_dir_sector = Partition.SectorsPerCluster; // limit max secters before next cluster
		883	}
		884	else return (direntry_exist); // bad sector range for directory sector of the file
		885	// if search area is not defined yet
		886	if(file->FirstSectorOfFirstCluster == 0)
		887	{
		888	// check if the directory entry of current file is existent and has the dir-flag set
		889	file->SectorInCache = file->DirectorySector; // update the sector number of file cache.
		890	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
		891	{
		892	Fat16_Deinit();
		893	return(direntry_exist);
		894	}
		895	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		896	switch((uint8_t)dir[file->DirectoryIndex].Name[0]) // check if current directory exist
		897	{
		898	case SLOT_EMPTY:
		899	case SLOT_DELETED:
		900	// the directrory pointer of this file points to a deleted or not existen directory
		901	// therefore no file or subdirectory can be created
		902	return (direntry_exist);
		903	break;
		904	default: // and is a real directory
		905	if((dir[file->DirectoryIndex].Attribute & ATTR_SUBDIRECTORY) != ATTR_SUBDIRECTORY)
		906	{ // current file is not a directory therefore no file or subdirectory can be created here
		907	return (direntry_exist);
		908	}
		909	break;
		910	}
		911	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dir[file->DirectoryIndex].StartCluster);
		912	}
		913
		914	// update current file data area position to start of first cluster
		915	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		916	file->SectorOfCurrCluster = 0;
		917	file->ByteOfCurrSector = 0;
		918
		919	do // loop over all data clusters of the current directory entry
		920	{
		921	dir_sector = 0; // reset sector counter within a new cluster
		922	do // loop over all sectors of a cluster or all sectors of the root directory
		923	{
		924	curr_sector = file->FirstSectorOfCurrCluster + dir_sector; // calculate sector number
		925	file->SectorInCache = curr_sector; // upate the sector number of file cache.
		926	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read the sector
		927	{
		928	Fat16_Deinit();
		929	return(direntry_exist);
		930	}
		931	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		932	// search all directory entries within that sector
		933	for(dir_entry = 0; dir_entry < DIRENTRIES_PER_SECTOR; dir_entry++)
		934	{ // check for existing dir entry
		935	switch((uint8_t)dir[dir_entry].Name[0])
		936	{
		937	case SLOT_EMPTY:
		938	case SLOT_DELETED:
		939	// ignore empty or deleted dir entries
		940	break;
		941	default:
		942	// if existing check attributes before names are compared will safe performance
		943	if ((dir[dir_entry].Attribute & attribmask) != attribfilter) break; // attribute must match
		944	// then compare the name to the giveb dirname (first 11 characters include 8 chars of basename and 3 chars extension.)
		945	i = 0;
		946	while((i < 11) && (dir[dir_entry].Name[i] == dirname[i])) i++;
		947	if (i < 10) break; // names does not match
		948	// if dirname and attribute have matched
		949	file->Attribute = dir[dir_entry].Attribute; // store attribute of found dir entry
		950	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dir[dir_entry].StartCluster); // set sector of first data cluster
		951	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		952	file->SectorOfCurrCluster = 0;
		953	file->ByteOfCurrSector = 0;
		954	file->DirectorySector = curr_sector; // current sector
		955	file->DirectoryIndex = dir_entry; // current direntry in current sector
		956	file->Size = dir[dir_entry].Size;
		957	direntry_exist = 1; // mark as found
		958	dir_entry = DIRENTRIES_PER_SECTOR; // stop for-loop
		959	} // end of first byte of name check
		960	}
		961	dir_sector++; // search next sector
		962	// stop if we reached the end of the cluster or the end of the root dir
		963	}while((dir_sector < max_dir_sector) && (!direntry_exist));
		964
		965	// if we are seaching in the data area and the file not found in this cluster so take next cluster.
		966	if(!direntry_exist && ( Partition.FirstDataSector <= file->FirstSectorOfCurrCluster))
		967	{
		968	end_of_directory_not_reached = GetNextCluster(file); // updates File->FirstSectorOfCurrCluster
		969	}
		970	}while((end_of_directory_not_reached) && (!direntry_exist)); // repeat until a next cluster exist an no
		971	return(direntry_exist);
		972	}
		973
		974
		975	/****************************************************************************************************************************************/
		976	/* Function: CreateDirectoryEntry(int8_t , uint16_t, File_t ) */
		977	/* */
		978	/* Description: This function looks for the next free position in the directory and creates an entry. */
		979	/* The type of an directory entry is specified by the file attribute. */
		980	/* */
		981	/* Returnvalue: Return 0 on error */
		982	/****************************************************************************************************************************************/
		983	uint8_t CreateDirectoryEntry(int8_t dirname, uint8_t attrib, File_t file)
		984	{
		985	uint32_t dir_sector, max_dir_sector, curr_sector;
		986	uint16_t dir_entry = 0;
		987	uint16_t subdircluster, dircluster = 0;
		988	uint16_t end_of_directory_not_reached = 0;
		989	uint8_t i = 0;
		990	uint8_t retvalue = 0;
		991	DirEntry_t* dir;
		992
		993	if((!Partition.IsValid) \|\| (file == NULL) \|\| (dirname == NULL)) return (retvalue);
		994	// It is not checked here that the dir entry that should be created is already existent!
		995
		996	// Dir entries can be created only in file-clusters that have
		997	// the dir-flag set in its attribute or within the root directory
		998
		999	file->FirstSectorOfFirstCluster = 0;
		1000	// no current directory exist therefore assume creating in the root
		1001	if(file->DirectorySector == 0)
		1002	{
		1003	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		1004	dircluster = 0;
		1005	file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
		1006	}
		1007	// within the root directory area we can read sectors sequentially until the end of this area
		1008	else if((Partition.FirstRootDirSector <= file->DirectorySector) && (file->DirectorySector < Partition.FirstDataSector))
		1009	{
		1010	max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
		1011	}
		1012	// within the data clusters we can read sectors sequentially only within the cluster
		1013	else if((Partition.FirstDataSector <= file->DirectorySector) && (file->DirectorySector <= Partition.LastDataSector))
		1014	{
		1015	max_dir_sector = Partition.SectorsPerCluster;
		1016	}
		1017	else return (retvalue); // bad sector range for directory sector of the file
		1018	// if search area is not defined yet
		1019	if(file->FirstSectorOfFirstCluster == 0)
		1020	{
		1021	// check if the directory entry of current file is existent and has the dir-flag set
		1022	file->SectorInCache = file->DirectorySector; // update the sector number of file cache.
		1023	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
		1024	{
		1025	Fat16_Deinit();
		1026	return(retvalue);
		1027	}
		1028	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		1029	switch((uint8_t)dir[file->DirectoryIndex].Name[0]) // check if current directory exist
		1030	{
		1031	case SLOT_EMPTY:
		1032	case SLOT_DELETED:
		1033	return (retvalue);
		1034	break;
		1035	default: // and is a real directory
		1036	if((dir[file->DirectoryIndex].Attribute & ATTR_SUBDIRECTORY) != ATTR_SUBDIRECTORY)
		1037	{ // current file is not a directory therefore no file or subdirectory can be created here
		1038	return (retvalue);
		1039	}
		1040	break;
		1041	}
		1042	dircluster = dir[file->DirectoryIndex].StartCluster;
		1043	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dircluster);
		1044	}
		1045
		1046	subdircluster = FindNextFreeCluster(file); // get the next free cluster on the disk and mark it as used.
		1047	if(subdircluster)
		1048	{
		1049	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		1050	file->SectorOfCurrCluster = 0;
		1051	do // loop over all clusters of current directory
		1052	{
		1053	dir_sector = 0; // reset sector counter within a new cluster
		1054	do // loop over all sectors of a cluster or all sectors of the root directory
		1055	{
		1056	curr_sector = file->FirstSectorOfCurrCluster + dir_sector; // calculate sector number
		1057	file->SectorInCache = curr_sector; // upate the sector number of file cache.
		1058	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
		1059	{
		1060	Fat16_Deinit();
		1061	return(retvalue);
		1062	}
		1063	dir = (DirEntry_t *)file->Cache; // set pointer to directory
		1064	// search all directory entries of a sector
		1065	for(dir_entry = 0; dir_entry < DIRENTRIES_PER_SECTOR; dir_entry++)
		1066	{ // check if current direntry is available
		1067	if(((uint8_t)dir[dir_entry].Name[0] == SLOT_EMPTY) \|\| ((uint8_t)dir[dir_entry].Name[0] == SLOT_DELETED))
		1068	{ // a free direntry was found
		1069	for(i = 0; i < 11; i++) dir[dir_entry].Name[i] = dirname[i]; // Set dir name
		1070	dir[dir_entry].Attribute = attrib; // Set the attribute of the new directoryentry.
		1071	dir[dir_entry].StartCluster = subdircluster; // copy the location of the first datacluster to the directoryentry.
		1072	dir[dir_entry].DateTime = FileDateTime(&SystemTime); // set date/time
		1073	dir[dir_entry].Size = 0; // the new createted file has no content yet.
		1074	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache)) // write back to card
		1075	{
		1076	Fat16_Deinit();
		1077	return(retvalue);
		1078	}
		1079	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(subdircluster); // Calculate absolute sectorposition of first datacluster.
		1080	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster; // Start reading the file with the first sector of the first datacluster.
		1081	file->SectorOfCurrCluster = 0; // reset sector of cureen cluster
		1082	file->ByteOfCurrSector = 0; // reset the byte location within the current sector
		1083	file->Attribute = attrib; // set file attribute to dir attribute
		1084	file->Size = 0; // new file has no size
		1085	file->DirectorySector = curr_sector;
		1086	file->DirectoryIndex = dir_entry;
		1087	if((attrib & ATTR_SUBDIRECTORY) == ATTR_SUBDIRECTORY) // if a new directory was created then initilize the data area
		1088	{
		1089	ClearCurrCluster(file); // fill cluster with zeros
		1090	file->SectorInCache = file->FirstSectorOfFirstCluster;
		1091	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
		1092	{
		1093	Fat16_Deinit();
		1094	return(retvalue);
		1095	}
		1096	dir = (DirEntry_t *)file->Cache;
		1097	// create direntry "." to current dir
		1098	dir[0].Name[0] = 0x2E;
		1099	for(i = 1; i < 11; i++) dir[0].Name[i] = ' ';
		1100	dir[0].Attribute = ATTR_SUBDIRECTORY;
		1101	dir[0].StartCluster = subdircluster;
		1102	dir[0].DateTime = 0;
		1103	dir[0].Size = 0;
		1104	// create direntry ".." to the upper dir
		1105	dir[1].Name[0] = 0x2E;
		1106	dir[1].Name[1] = 0x2E;
		1107	for(i = 2; i < 11; i++) dir[1].Name[i] = ' ';
		1108	dir[1].Attribute = ATTR_SUBDIRECTORY;
		1109	dir[1].StartCluster = dircluster;
		1110	dir[1].DateTime = 0;
		1111	dir[1].Size = 0;
		1112	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))// read in the sector.
		1113	{
		1114	Fat16_Deinit();
		1115	return(retvalue);
		1116	}
		1117	}
		1118	retvalue = 1;
		1119	dir_entry = DIRENTRIES_PER_SECTOR; // stop for-loop
		1120	}
		1121	}
		1122	dir_sector++; // search next sector
		1123	// stop if we reached the end of the cluster or the end of the root dir
		1124	}while((dir_sector < max_dir_sector) && (!retvalue));
		1125
		1126	// if we are seaching in the data area and the file not found in this cluster so take next cluster.
		1127	if(!retvalue && ( Partition.FirstDataSector <= file->FirstSectorOfCurrCluster))
		1128	{
		1129	end_of_directory_not_reached = GetNextCluster(file); // updates File->FirstSectorOfCurrCluster
		1130	}
		1131	}while((end_of_directory_not_reached) && (!retvalue));
		1132	// Perhaps we are at the end of the last cluster of a directory file an have no free direntry found.
		1133	// Then we would need to add a cluster to that file and create the new direntry there.
		1134	// This code is not implemented yet, because its occurs only if more that 32*32=1024 direntries are
		1135	// within a subdirectory of root.
		1136	}
		1137	return(retvalue); // return 1 if file has been created otherwise return 0.
		1138	}
		1139
		1140	/********************************************************************************************************************************************/
		1141	/* Function: FileExist(const int8_t* filename, uint8_t attribfilter, uint8_t attribmask, File_t file); /
		1142	/* */
		1143	/* Description: This function looks for the specified file including its subdirectories beginning */
		1144	/* in the rootdirectory of the drive. If the file is found the Filepointer properties are */
		1145	/* updated. */
		1146	/* */
		1147	/* Returnvalue: 1 if file is found else 0. */
		1148	/********************************************************************************************************************************************/
		1149	uint8_t FileExist(const int8_t* filename, const uint8_t attribfilter, const uint8_t attribmask, File_t *file)
		1150	{
		1151	int8_t* path = 0;
		1152	int8_t* subpath = 0;
		1153	uint8_t af, am, file_exist = 0;
		1154	int8_t dirname[12]; // 8+3 + temination character
		1155
		1156	// if incomming pointers are useless return immediatly
		1157	if ((filename == NULL) \|\| (file == NULL) \|\| (!Partition.IsValid)) return 0;
		1158
		1159	// trace along the filepath
		1160	path = (int8_t*)filename; // start a the beginning of the filename string
		1161	file->DirectorySector = 0; // start at RootDirectory with file search
		1162	file->DirectoryIndex = 0;
		1163	// as long as the file was not found and the remaining path is not empty
		1164	while((*path != 0) && !file_exist)
		1165	{ // separate dirname and subpath from filepath string
		1166	subpath = SeperateDirName(path, dirname);
		1167	if(subpath != NULL)
		1168	{
		1169	if(*subpath == 0)
		1170	{ // empty subpath indicates last element of dir chain
		1171	af = attribfilter;
		1172	am = attribmask;
		1173	}
		1174	else // it must be a subdirectory and no volume label
		1175	{
		1176	af = ATTR_SUBDIRECTORY;
		1177	am = ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL;
		1178	}
		1179	if(!DirectoryEntryExist(dirname, af, am, file))
		1180	{
		1181	return (file_exist); // subdirectory does not exist
		1182	}
		1183	else
		1184	{
		1185	if (*subpath == 0)
		1186	{
		1187	file_exist = 1; // last element of path chain was found with the given attribute filter
		1188	}
		1189	}
		1190	}
		1191	else // error seperating the subpath
		1192	{
		1193	return file_exist; // bad subdir format
		1194	}
		1195	path = subpath;
		1196	subpath = 0;
		1197	}
		1198	return (file_exist);
		1199	}
		1200
		1201
		1202	/********************************************************************************************************************************************/
		1203	/* Function: FileCreate(const s8* filename, u8 attrib, File_t file); /
		1204	/* */
		1205	/* Description: This function looks for the specified file including its subdirectories beginning */
		1206	/* in the rootdirectory of the partition. If the file is found the Filepointer properties are */
		1207	/* updated. If file or its subdirectories are not found they will be created */
		1208	/* */
		1209	/* Returnvalue: 1 if file was created else 0. */
		1210	/********************************************************************************************************************************************/
		1211	uint8_t FileCreate(const int8_t* filename, const uint8_t attrib, File_t *file)
		1212	{
		1213	int8_t *path = 0;
		1214	int8_t *subpath = 0;
		1215	uint8_t af, am, file_created = 0;
		1216	int8_t dirname[12];
		1217
		1218	// if incomming pointers are useless return immediatly
		1219	if ((filename == NULL) \|\| (file == NULL) \|\| (!Partition.IsValid)) return 0;
		1220
		1221	// trace along the filepath
		1222	path = (int8_t*)filename; // start a the beginning of the filename string
		1223	file->DirectorySector = 0; // start at RootDirectory with file search
		1224	file->DirectoryIndex = 0;
		1225	// as long as the file was not created and the remaining file path is not empty
		1226	while((*path != 0) && !file_created)
		1227	{ // separate dirname and subpath from filepath string
		1228	subpath = SeperateDirName(path, dirname);
		1229	if(subpath != NULL)
		1230	{
		1231	if(*subpath == 0)
		1232	{ // empty subpath indicates last element of dir chain
		1233	af = ATTR_NONE;
		1234	am = ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL; // any file that is no subdir or volume label
		1235	}
		1236	else // it must be a subdirectory and no volume label
		1237	{
		1238	af = ATTR_SUBDIRECTORY;
		1239	am = ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL;
		1240	}
		1241	if(!DirectoryEntryExist(dirname, af, am, file)) // if subdir or file is not existent
		1242	{ // try to create subdir or file
		1243	if(*subpath == 0) af = attrib; // if last element in dir chain take the given attribute
		1244	if(!CreateDirectoryEntry(dirname, af, file))
		1245	{ // could not be created
		1246	return(file_created);
		1247	}
		1248	else if (*subpath == 0) file_created = 1; // last element of path chain was created
		1249	}
		1250	}
		1251	else // error seperating the subpath
		1252	{
		1253	return file_created; // bad subdir format
		1254	}
		1255	path = subpath;
		1256	subpath = 0;
		1257	}
		1258	return (file_created);
		1259	}
		1260
		1261
		1262	/********************************************************************************************************************************************/
		1263	/* Function: File_t * fopen_(int8_t* filename, int8_t mode); */
		1264	/* */
		1265	/* Description: This function looks for the specified file in the rootdirectory of the drive. If the file is found the number of the */
		1266	/* corrosponding filepointer is returned. Only modes 'r' (reading) and 'a' append are implemented yet. */
		1267	/* */
		1268	/* Returnvalue: The filepointer to the file or 0 if faild. */
		1269	/********************************************************************************************************************************************/
		1270	File_t * fopen_(int8_t * const filename, const int8_t mode)
		1271	{
		1272	File_t *file = 0;
		1273
		1274	if((!Partition.IsValid) \|\| (filename == 0)) return(file);
		1275
		1276	// Look for an unused filepointer in the file pointer list?
		1277	file = LockFilePointer();
		1278	// if no unused file pointer was found return 0
		1279	if(file == NULL) return(file);
		1280
		1281	// now we have found a free filepointer and claimed it
		1282	// so let initiate its property values
		1283	file->FirstSectorOfFirstCluster = 0; // Sectorpointer to the first sector of the first datacluster of the file.
		1284	file->FirstSectorOfCurrCluster = 0; // Pointer to the cluster which is edited at the moment.
		1285	file->SectorOfCurrCluster = 0; // The sector which is edited at the moment (cluster_pointer + sector_index).
		1286	file->ByteOfCurrSector = 0; // The bytelocation within the current sector (cluster_pointer + sector_index + byte_index).
		1287	file->Mode = mode; // mode of fileoperation (read,write)
		1288	file->Size = 0; // the size of the opened file in bytes.
		1289	file->Position = 0; // pointer to a byte within the file 0 < fileposition < filesize
		1290	file->SectorInCache = 0; // the last sector read, wich is still in the sectorbuffer.
		1291	file->DirectorySector = 0; // the sectorposition where the directoryentry has been made.
		1292	file->DirectoryIndex = 0; // the index to the directoryentry within the specified sector.
		1293	file->Attribute = 0; // the attribute of the file opened.
		1294
		1295	// check if a real file (no directory) to the given filename exist
		1296	if(FileExist(filename, ATTR_NONE, ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL, file))
		1297	{ // file exist
		1298	switch(mode) // check mode
		1299	{
		1300	case 'a': // if mode is: append to file
		1301	if((file->Attribute & ATTR_READONLY) == ATTR_READONLY)
		1302	{ // file is marked as readonly --> do not open this file
		1303	fclose_(file);
		1304	file = NULL;
		1305	}
		1306	else
		1307	{ // file is not marked as read only --> goto end of file
		1308	fseek_(file, 0, SEEK_END); // point to the end of the file
		1309	}
		1310	break;
		1311	case 'w': // if mode is: write to file
		1312	if((file->Attribute & ATTR_READONLY) == ATTR_READONLY)
		1313	{ // file is marked as readonly --> do not open this file
		1314	fclose_(file);
		1315	file = NULL;
		1316	}
		1317	else
		1318	{ // file is not marked as read only --> goto start of file
		1319	// free all clusters of that file
		1320	DeleteClusterChain(SectorToFat16Cluster(file->FirstSectorOfFirstCluster));
		1321	// mar an empy cluster as the last one and store the corresponding sector
		1322	file->FirstSectorOfFirstCluster = Fat16ClusterToSector(FindNextFreeCluster(file));
		1323	file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
		1324	file->SectorOfCurrCluster = 0;
		1325	file->ByteOfCurrSector = 0;
		1326	file->Size = 0;
		1327	file->Position = 0;
		1328	fseek_(file, 0, SEEK_SET);
		1329	}
		1330	break;
		1331	case 'r': // if mode is: read from file
		1332	// goto end of file
		1333	fseek_(file, 0, SEEK_SET);
		1334	break;
		1335	default: // other modes are not supported
		1336	fclose_(file);
		1337	file = NULL;
		1338	break;
		1339	}
		1340	return(file);
		1341	}
		1342	else // file does not exist
		1343	{
		1344	switch(mode) // check mode
		1345	{
		1346	case 'a':
		1347	case 'w': // if mode is write or append
		1348	// try to create the file
		1349	if(!FileCreate(filename, ATTR_ARCHIVE, file))
		1350	{ // if it could not be created
		1351	fclose_(file);
		1352	file = NULL;
		1353	}
		1354	break;
		1355	case 'r': // else opened for 'r'
		1356	default: // of unsupported mode
		1357	fclose_(file);
		1358	file = NULL;
		1359	break;
		1360	}
		1361	return(file);
		1362	}
		1363	// we should never come to this point
		1364	fclose_(file);
		1365	file = NULL;
		1366	return(file);
		1367	}
		1368
		1369	/****************************************************************************************************************************************************/
		1370	/* Function: fflush_(File ); /
		1371	/* */
		1372	/* Description: This function writes the data already in the buffer but not yet written to the file. */
		1373	/* */
		1374	/* Returnvalue: 0 on success EOF on error */
		1375	/****************************************************************************************************************************************************/
		1376	int16_t fflush_(File_t * const file)
		1377	{
		1378	DirEntry_t *dir;
		1379
		1380	if((file == NULL) \|\| (!Partition.IsValid)) return (EOF);
		1381
		1382	switch(file->Mode)
		1383	{
		1384	case 'a':
		1385	case 'w':
		1386	if(file->ByteOfCurrSector > 0) // has data been added to the file?
		1387	{
		1388	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))// save the data still in the buffer
		1389	{
		1390	Fat16_Deinit();
		1391	return(EOF);
		1392	}
		1393	}
		1394	file->SectorInCache = file->DirectorySector;
		1395	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read the directory entry for this file.
		1396	{
		1397	Fat16_Deinit();
		1398	return(EOF);
		1399	}
		1400
		1401	dir = (DirEntry_t *)file->Cache;
		1402	dir[file->DirectoryIndex].Size = file->Size; // update file size
		1403	dir[file->DirectoryIndex].DateTime = FileDateTime(&SystemTime); // update date time
		1404	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache)) // write back to sd-card
		1405	{
		1406	Fat16_Deinit();
		1407	return(EOF);
		1408	}
		1409	break;
		1410	case 'r':
		1411	default:
		1412	return(EOF);
		1413	break;
		1414
		1415	}
		1416	return(0);
		1417	}
		1418
		1419	/****************************************************************************************************************************************/
		1420	/* Function: fclose_(File file); /
		1421	/* */
		1422	/* Description: This function closes the open file by writing the remaining data */
		1423	/* from the buffer to the device and entering the filesize in the directory entry. */
		1424	/* */
		1425	/* Returnvalue: 0 on success EOF on error */
		1426	/****************************************************************************************************************************************/
		1427	int16_t fclose_(File_t *file)
		1428	{
		1429	int16_t returnvalue = EOF;
		1430
		1431	if(file == NULL) return(returnvalue);
		1432	returnvalue = fflush_(file);
		1433	UnlockFilePointer(file);
		1434	return(returnvalue);
		1435	}
		1436
		1437	/********************************************************************************************************************************************/
		1438	/* Function: fgetc_(File file); /
		1439	/* */
		1440	/* Description: This function reads and returns one character from the specified file. Is the end of the actual sector reached the */
		1441	/* next sector of the cluster is read. If the last sector of the cluster read the next cluster will be searched in FAT. */
		1442	/* */
		1443	/* Returnvalue: The function returns the character read from the specified memorylocation as u8 casted to s16 or EOF. */
		1444	/********************************************************************************************************************************************/
		1445	int16_t fgetc_(File_t * const file)
		1446	{
		1447	int16_t c = EOF;
		1448	uint32_t curr_sector;
		1449
		1450	if( (!Partition.IsValid) \|\| (file == NULL)) return(c);
		1451	// if the end of the file is not reached, get the next character.
		1452	if((0 < file->Size) && ((file->Position+1) < file->Size) )
		1453	{
		1454	curr_sector = file->FirstSectorOfCurrCluster; // calculate the sector of the next character to be read.
		1455	curr_sector += file->SectorOfCurrCluster;
		1456
		1457	if(file->SectorInCache != curr_sector)
		1458	{
		1459	file->SectorInCache = curr_sector;
		1460	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache,file->Cache))
		1461	{
		1462	Fat16_Deinit();
		1463	return(c);
		1464	}
		1465	}
		1466	c = (int16_t) file->Cache[file->ByteOfCurrSector];
		1467	file->Position++; // increment file position
		1468	file->ByteOfCurrSector++; // goto next byte in sector
		1469	if(file->ByteOfCurrSector >= BYTES_PER_SECTOR) // if end of sector
		1470	{
		1471	file->ByteOfCurrSector = 0; // reset byte location
		1472	file->SectorOfCurrCluster++; // next sector
		1473	if(file->SectorOfCurrCluster >= Partition.SectorsPerCluster) // if end of cluster is reached, the next datacluster has to be searched in the FAT.
		1474	{
		1475
		1476	if(GetNextCluster(file)) // Sets the clusterpointer of the file to the next datacluster.
		1477	{
		1478	file->SectorOfCurrCluster = 0; // start reading new cluster at first sector of the cluster.
		1479	}
		1480	else // the last cluster was allready reached
		1481	{
		1482	file->SectorOfCurrCluster--; // jump back to the last sector in the last cluster
		1483	file->ByteOfCurrSector = BYTES_PER_SECTOR; // set ByteOfCurrSector one byte over sector end
		1484	}
		1485	}
		1486	}
		1487	}
		1488	return(c);
		1489	}
		1490
		1491	/********************************************************************************************************************************************/
		1492	/* Function: fputc_( const s8 c, File file); /
		1493	/* */
		1494	/* Description: This function writes a byte to the specified file and takes care of writing the necessary FAT- Entries. */
		1495	/* next sector of the cluster is read. If the last sector of the cluster read the next cluster will be searched in FAT. */
		1496	/* */
		1497	/* Returnvalue: The function returns the character written to the stream or EOF on error. */
		1498	/********************************************************************************************************************************************/
		1499	int16_t fputc_(const int8_t c, File_t * const file)
		1500	{
		1501	uint32_t curr_sector = 0;
		1502
		1503	if((!Partition.IsValid) \|\| (file == NULL)) return(EOF);
		1504
		1505	// If file position equals to file size, then the end of file has reached.
		1506	// In this chase it has to be checked that the ByteOfCurrSector is BYTES_PER_SECTOR
		1507	// and a new cluster should be appended.
		1508	if((file->Position >= file->Size) && (file->ByteOfCurrSector >= BYTES_PER_SECTOR))
		1509	{
		1510	if(!AppendCluster(file)) return(EOF);
		1511	}
		1512
		1513	curr_sector = file->FirstSectorOfCurrCluster;
		1514	curr_sector += file->SectorOfCurrCluster;
		1515	if(file->SectorInCache != curr_sector)
		1516	{
		1517	file->SectorInCache = curr_sector;
		1518	if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))
		1519	{
		1520	Fat16_Deinit();
		1521	return(EOF);
		1522	}
		1523	}
		1524
		1525	file->Cache[file->ByteOfCurrSector] = (uint8_t)c; // write databyte into the buffer. The byte will be written to the device at once
		1526	if(file->Size == file->Position) file->Size++; // a character has been written to the file so the size is incremented only when the character has been added at the end of the file.
		1527	file->Position++; // the actual positon within the file.
		1528	file->ByteOfCurrSector++; // goto next byte in sector
		1529	if(file->ByteOfCurrSector >= BYTES_PER_SECTOR) // if the end of this sector is reached yet
		1530	{ // save the sector to the sd-card
		1531	if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))
		1532	{
		1533	Fat16_Deinit();
		1534	return(EOF);
		1535	}
		1536	file->ByteOfCurrSector = 0; // reset byte location
		1537	file->SectorOfCurrCluster++; // next sector
		1538	if(file->SectorOfCurrCluster >= Partition.SectorsPerCluster)// if end of cluster is reached, the next datacluster has to be searched in the FAT.
		1539	{
		1540	if(!GetNextCluster(file)) // Sets the clusterpointer of the file to the next datacluster.
		1541	{ // if current cluster was the last cluster of the file
		1542	if(!AppendCluster(file)) // append a new and free cluster at the end of the file.
		1543	{
		1544	file->SectorOfCurrCluster--; // jump back to last sector of last cluster
		1545	file->ByteOfCurrSector = BYTES_PER_SECTOR; // set byte location to 1 byte over sector len
		1546	return(EOF);
		1547	}
		1548	}
		1549	else // next cluster
		1550	{
		1551	file->SectorOfCurrCluster = 0; // start reading new cluster at first sector of the cluster.
		1552	}
		1553	}
		1554	}
		1555	return(0);
		1556	}
		1557
		1558
		1559	/****************************************************************************************************************************************/
		1560	/* Function: fread_(void buffer, uint32_t size, uint32_t count, File File); */
		1561	/* */
		1562	/* Description: This function reads count objects of the specified size */
		1563	/* from the actual position of the file to the specified buffer. */
		1564	/* */
		1565	/* Returnvalue: The function returns the number of objects (not bytes) read from the file. */
		1566	/****************************************************************************************************************************************/
		1567	uint32_t fread_(void * const buffer, uint32_t size, uint32_t count, File_t * const file)
		1568	{
		1569	uint32_t object_cnt = 0; // count the number of objects read from the file.
		1570	uint32_t object_size = 0; // count the number of bytes read from the actual object.
		1571	uint8_t *pbuff = 0; // a pointer to the actual bufferposition.
		1572	uint8_t success = 1; // no error occured during read operation to the file.
		1573	int16_t c;
		1574
		1575	if((!Partition.IsValid) \|\| (file == NULL) \|\| (buffer == NULL)) return(0);
		1576
		1577	pbuff = (uint8_t ) buffer; // cast the void pointer to an u8
		1578
		1579	while((object_cnt < count) && success)
		1580	{
		1581	object_size = size;
		1582	while((size > 0) && success)
		1583	{
		1584	c = fgetc_(file);
		1585	if(c != EOF)
		1586	{
		1587	*pbuff = (uint8_t)c; // read a byte from the buffer to the opened file.
		1588	pbuff++;
		1589	size--;
		1590	}
		1591	else // error or end of file reached
		1592	{
		1593	success = 0;
		1594	}
		1595	}
		1596	if(success) object_cnt++;
		1597	}
		1598	return(object_cnt); // return the number of objects succesfully read from the file
		1599	}
		1600
		1601
		1602	/****************************************************************************************************************************************/
		1603	/* Function: fwrite_(void buffer, uint32_t size, uint32_t count, File file); */
		1604	/* */
		1605	/* Description: This function writes count objects of the specified size */
		1606	/* from the buffer pointer to the actual position in the file. */
		1607	/* */
		1608	/* Returnvalue: The function returns the number of objects (not bytes) read from the file. */
		1609	/****************************************************************************************************************************************/
		1610	uint32_t fwrite_(void * const buffer, uint32_t size, uint32_t count, File_t * const file)
		1611	{
		1612	uint32_t object_cnt = 0; // count the number of objects written to the file.
		1613	uint32_t object_size = 0; // count the number of bytes written from the actual object.
		1614	uint8_t *pbuff = 0; // a pointer to the actual bufferposition.
		1615	uint8_t success = 1; // no error occured during write operation to the file.
		1616	int16_t c;
		1617
		1618	if((!Partition.IsValid) \|\| (file == NULL) \|\| (buffer == NULL)) return(0);
		1619
		1620	pbuff = (uint8_t ) buffer; // cast the void pointer to an u8
		1621
		1622	while((object_cnt < count) && success)
		1623	{
		1624	object_size = size;
		1625	while((size > 0) && success)
		1626	{
		1627	c = fputc_(*pbuff, file); // write a byte from the buffer to the opened file.
		1628	if(c != EOF)
		1629	{
		1630	pbuff++;
		1631	size--;
		1632	}
		1633	else
		1634	{
		1635	success = 0;
		1636	}
		1637	}
		1638	if(success) object_cnt++;
		1639	}
		1640
		1641	return(object_cnt); // return the number of objects succesfully written to the file
		1642	}
		1643
		1644
		1645	/****************************************************************************************************************************************/
		1646	/* Function: fputs_(const int8_t string, File_t File); */
		1647	/* */
		1648	/* Description: This function writes a string to the specified file. */
		1649	/* */
		1650	/* Returnvalue: The function returns a no negative value or EOF on error. */
		1651	/****************************************************************************************************************************************/
		1652	int16_t fputs_(int8_t * const string, File_t * const file)
		1653	{
		1654	uint8_t i=0;
		1655	int16_t c = 0;
		1656
		1657	if((!Partition.IsValid) \|\| (file == NULL) \|\| (string == NULL)) return(0);
		1658
		1659	while((string[i] != 0)&& (c != EOF))
		1660	{
		1661	c = fputc_(string[i], file);
		1662	i++;
		1663	}
		1664	return(c);
		1665	}
		1666
		1667	/****************************************************************************************************************************************/
		1668	/* Function: fgets_(int8 , int16_t , File_t ); */
		1669	/* */
		1670	/* Description: This function reads a string from the file to the specifies string. */
		1671	/* */
		1672	/* Returnvalue: A pointer to the string read from the file or 0 on error. */
		1673	/****************************************************************************************************************************************/
		1674	int8_t * fgets_(int8_t * const string, int16_t length, File_t * const file)
		1675	{
		1676	int8_t *pbuff;
		1677	int16_t c = 0, bytecount;
		1678
436	killagreg	1679	if( (!Partition.IsValid) \|\| (file == NULL) \|\| (string == NULL) \|\| (length < 1) ) return (0);
		1680
426	killagreg	1681	pbuff = string;
		1682	bytecount = length;
		1683	while(bytecount > 1) // read the count-1 characters from the file to the string.
		1684	{
		1685	c = fgetc_(file); // read a character from the opened file.
436	killagreg	1686
426	killagreg	1687	switch(c)
		1688	{
		1689	case 0x0A:
		1690	*pbuff = 0; // set string terminator
		1691	return(string); // stop loop
		1692	break;
		1693
		1694	case EOF:
		1695	*pbuff = 0; // set string terminator
		1696	return(0);
		1697	default:
		1698	*pbuff++ = (int8_t)c; // copy byte to string
		1699	bytecount--;
		1700	break;
		1701	}
		1702	}
		1703	*pbuff = 0;
		1704	return(string);
		1705	}
		1706
		1707	/****************************************************************************************************************************************/
		1708	/* Function: fexist_(const int8_t); /
		1709	/* */
		1710	/* Description: This function checks if a file already exist. */
		1711	/* */
		1712	/* Returnvalue: 1 if the file exist else 0. */
		1713	/****************************************************************************************************************************************/
		1714	uint8_t fexist_(int8_t* const filename)
		1715	{
		1716	uint8_t exist = 0;
		1717	File_t *file = 0;
		1718	file = LockFilePointer();
		1719	exist = FileExist(filename, ATTR_NONE, ATTR_SUBDIRECTORY\|ATTR_VOLUMELABEL, file);
		1720	UnlockFilePointer(file);
		1721	return(exist);
		1722	}
		1723
		1724	/****************************************************************************************************************************************/
		1725	/* Function: feof_(File_t File); /
		1726	/* */
		1727	/* Description: This function checks wether the end of the file has been reached. */
		1728	/* */
		1729	/* Returnvalue: 0 if the end of the file was not reached otherwise 1. */
		1730	/****************************************************************************************************************************************/
		1731	uint8_t feof_(File_t *file)
		1732	{
		1733	if(((file->Position)+1) < (file->Size))
		1734	{
		1735	return(0);
		1736	}
		1737	else
		1738	{
		1739	return(1);
		1740	}
		1741	}
		1742
		1743

Subversion Repositories Projects

(root)/FollowMe/trunk/fat16.c - Rev 436