Subversion Repositories NaviCtrl

/*#######################################################################################*/

/* !!! THIS IS NOT FREE SOFTWARE !!!                                                     */

/*#######################################################################################*/

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + www.MikroKopter.com

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Software Nutzungsbedingungen (english version: see below)

// + der Fa. HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland - nachfolgend Lizenzgeber genannt -

// + Der Lizenzgeber räumt dem Kunden ein nicht-ausschließliches, zeitlich und räumlich* unbeschränktes Recht ein, die im den

// + Mikrocontroller verwendete Firmware für die Hardware Flight-Ctrl, Navi-Ctrl, BL-Ctrl, MK3Mag & PC-Programm MikroKopter-Tool 

// + - nachfolgend Software genannt - nur für private Zwecke zu nutzen.

// + Der Einsatz dieser Software ist nur auf oder mit Produkten des Lizenzgebers zulässig.

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Die vom Lizenzgeber gelieferte Software ist urheberrechtlich geschützt. Alle Rechte an der Software sowie an sonstigen im

// + Rahmen der Vertragsanbahnung und Vertragsdurchführung überlassenen Unterlagen stehen im Verhältnis der Vertragspartner ausschließlich dem Lizenzgeber zu.

// + Die in der Software enthaltenen Copyright-Vermerke, Markenzeichen, andere Rechtsvorbehalte, Seriennummern sowie

// + sonstige der Programmidentifikation dienenden Merkmale dürfen vom Kunden nicht verändert oder unkenntlich gemacht werden.

// + Der Kunde trifft angemessene Vorkehrungen für den sicheren Einsatz der Software. Er wird die Software gründlich auf deren

// + Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.

// + Die Haftung des Lizenzgebers wird - soweit gesetzlich zulässig - begrenzt in Höhe des typischen und vorhersehbaren

// + Schadens. Die gesetzliche Haftung bei Personenschäden und nach dem Produkthaftungsgesetz bleibt unberührt. Dem Lizenzgeber steht jedoch der Einwand 

// + des Mitverschuldens offen.

// + Der Kunde trifft angemessene Vorkehrungen für den Fall, dass die Software ganz oder teilweise nicht ordnungsgemäß arbeitet.

// + Er wird die Software gründlich auf deren Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.

// + Der Kunde wird er seine Daten vor Einsatz der Software nach dem Stand der Technik sichern.

// + Der Kunde ist darüber unterrichtet, dass der Lizenzgeber seine Daten im zur Vertragsdurchführung erforderlichen Umfang

// + und auf Grundlage der Datenschutzvorschriften erhebt, speichert, verarbeitet und, sofern notwendig, an Dritte übermittelt.

// + *) Die räumliche Nutzung bezieht sich nur auf den Einsatzort, nicht auf die Reichweite der programmierten Software.

// + #### ENDE DER NUTZUNGSBEDINGUNGEN ####'

// +  Hinweis: Informationen über erweiterte Nutzungsrechte (wie z.B. Nutzung für nicht-private Zwecke) sind auf Anfrage per Email an info(@)hisystems.de verfügbar.

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Software LICENSING TERMS

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + of HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland, Germany - the Licensor -

// + The Licensor grants the customer a non-exclusive license to use the microcontroller firmware of the Flight-Ctrl, Navi-Ctrl, BL-Ctrl, and MK3Mag hardware 

// + (the Software) exclusively for private purposes. The License is unrestricted with respect to time and territory*.

// + The Software may only be used with the Licensor's products.

// + The Software provided by the Licensor is protected by copyright. With respect to the relationship between the parties to this

// + agreement, all rights pertaining to the Software and other documents provided during the preparation and execution of this

// + agreement shall be the property of the Licensor.

// + The information contained in the Software copyright notices, trademarks, other legal reservations, serial numbers and other

// + features that can be used to identify the program may not be altered or defaced by the customer.

// + The customer shall be responsible for taking reasonable precautions

// + for the safe use of the Software. The customer shall test the Software thoroughly regarding its suitability for the

// + intended purpose before implementing it for actual operation. The Licensor's liability shall be limited to the extent of typical and

// + foreseeable damage to the extent permitted by law, notwithstanding statutory liability for bodily injury and product

// + liability. However, the Licensor shall be entitled to the defense of contributory negligence.

// + The customer will take adequate precautions in the case, that the software is not working properly. The customer will test

// + the software for his purpose before any operational usage. The customer will backup his data before using the software.

// + The customer understands that the Licensor collects, stores and processes, and, where required, forwards, customer data

// + to third parties to the extent necessary for executing the agreement, subject to applicable data protection and privacy regulations.

// + *) The territory aspect only refers to the place where the Software is used, not its programmed range.

// + #### END OF LICENSING TERMS ####

// + Note: For information on license extensions (e.g. commercial use), please contact us at info(@)hisystems.de.

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#include <stdio.h>

#include <string.h>

#include "91x_lib.h"

#include "timer1.h"

#include "fat16.h"

#include "sdc.h"

#include "uart1.h"

#include "main.h"

#include "logging.h"

//________________________________________________________________________________________________________________________________________

// Module name:                 fat16.c

// Compiler used:               avr-gcc 3.4.5

// Last Modifikation:   20.03.2010

// Version:                             2.10

// Authors:                             Stephan Busker & Gregor Stobrawa

// Description:                 Source files for FAT16 implementation with read and write-access

//                                              Copyright (C) 2008 Stephan Busker & Gregor Stobrawa

//........................................................................................................................................

// Functions:                   extern s16              Fat16_Init(void);

//                                              extern s16              Fat16_Deinit(void);

//                                              extern s8*              FAT16_GetVolumeLabel(void);

//                                              extern File_t * fopen_(const u8 *filename, const s8 mode);

//                                              extern s16              fclose_(File_t *File);

//                                              extern u8               fexist_(s8 * const filename);

//                                              extern s16              fflush_(File_t *File);

//                                              extern s16      fseek_(File_t *File, s32 offset, s16 origin);

//                                              extern s16              fgetc_(File_t *File);

//                                              extern s16              fputc_(u8 c, File_t *File);

//                                              extern u32              fread_(void *buffer, u32 size, u32 count, File_t *File);

//                                              extern u32              fwrite_(void *buffer, u32 size, u32 count, File_t *File);

//                                              extern s16              fputs_(const u8 *string, File_t *File);

//                                              extern u8 *     fgets_(u8 *string, s16 length, File_t *File);

//                                              extern u8               feof_(File_t * const file);

//........................................................................................................................................

// ext. functions:              extern SD_Result_t SDC_Init(void;)

//                                              extern SD_Result_t SDC_Deinit(void);

//                      extern SD_Result_t SDC_GetSector (u32,u8 *);

//                                              extern SD_Result_t SDC_PutSector (u32,u8 *);

//........................................................................................................................................

//

// URL:                                 www.Mikro-Control.de

// mailto:                              stephan.busker@mikro-control.de

//________________________________________________________________________________________________________________________________________

/*

FAT16 Drive Layout:

Description                                             Offset

Volume Boot Sector                                      Start of Partition

Fat Tables                                                      Start + # of Reserved Sectors

Root Directory Entry                            Start + # of Reserved + (# of Sectors Per FAT * 2)

Data Area (Starts with Cluster #2)      Start + # of Reserved + (# of Sectors Per FAT * 2) + ((Maximum Root Directory Entries * 32) / Bytes per Sector)

*/

/*

________________________________________________________________________________________________________________________________________

        Structure of an partition entry

________________________________________________________________________________________________________________________________________

        Partition Entry is 16 bytes long

*/

typedef struct

{

        u8      PartitionState;                         // Current State of Partition (00h=Inactive, 80h=Active)

        u8      BeginningHead;                          // Beginning of Partition - Head

        u16     BeginningCylSec;                        // Beginning of Partition - Cylinder/Sector (See Below)

        u8      Type;                                           // Type of Partition (See List Below)

        u8      EndHead;                                        // End of Partition - Head

        u16     EndCylSec;                                      // End of Partition - Cylinder/Sector

        u32     NoSectorsBeforePartition;       // Number of Sectors between the MBR and the First Sector in the Partition

        u32     NoSectorsPartition      ;               // Number of Sectors in the Partition

} __attribute__((packed)) PartitionEntry_t;

/*

Coding of Cylinder/Sector words

Cylinder is 10 bits:  [7:0] at [15:8] and [9:8] at [7:6]

Sector is 5 bits:  [5:0] at [5:0]

*/

// Partition Types:

#define PART_TYPE_UNKNOWN                       0x00

#define PART_TYPE_FAT12                         0x01

#define PART_TYPE_XENIX                         0x02

#define PART_TYPE_FAT16_ST_32_MB        0x04

#define PART_TYPE_EXTDOS                        0x05

#define PART_TYPE_FAT16_LT_32_MB        0x06

#define PART_TYPE_NTFS                          0x07

#define PART_TYPE_FAT32                         0x0B

#define PART_TYPE_FAT32LBA                      0x0C

#define PART_TYPE_FAT16LBA                      0x0E

#define PART_TYPE_EXTDOSLBA                     0x0F

#define PART_TYPE_EISA                          0x12

#define PART_TYPE_ONTRACK                       0x33

#define PART_TYPE_NOVELL                        0x40

#define PART_TYPE_DYNAMIC                       0x42

#define PART_TYPE_PCIX                          0x4B

#define PART_TYPE_LINUX_SWAP            0x82

#define PART_TYPE_LINUX_NATIVE          0x83

#define PART_TYPE_LINUX_LVM                     0x8E

#define PART_TYPE_PHOENIXSAVE           0xA0

#define PART_TYPE_FREEBSD                       0xA5

#define PART_TYPE_OPENBSD                       0xA6

#define PART_TYPE_NETNBSD                       0xA9

#define PART_TYPE_CPM                           0xDB

#define PART_TYPE_DBFS                          0xE0

#define PART_TYPE_BBT                           0xFF

/*

________________________________________________________________________________________________________________________________________

        Structure of the MasterBootRecord

________________________________________________________________________________________________________________________________________

        Master Boot Record is 512 bytes long

        The Master Boot Record is the same for pretty much all Operating Systems.

        It is located on the first Sector of the Hard Drive, at Cylinder 0, Head 0, Sector 1

*/

typedef struct

{

        u8                              ExecutableCode[446];    // 446 bytes for machine start code

        PartitionEntry_t        PartitionEntry1;                // 16 bytes for partition entry 1

        PartitionEntry_t        PartitionEntry2;                // 16 bytes for partition entry 2

        PartitionEntry_t        PartitionEntry3;                // 16 bytes for partition entry 3

        PartitionEntry_t        PartitionEntry4;                // 16 bytes for partition entry 4

        u16                                     ExecutableMarker;               // BIOS-Signature (0x55 0xAA)

} __attribute__((packed)) MBR_Entry_t;

/*

________________________________________________________________________________________________________________________________________

        Structure of the VolumeBootRecord

________________________________________________________________________________________________________________________________________

        The Volume Boot Record is 512 bytes long

        This information is located in the first sector of every partition.

*/

typedef struct

{

        u8  JumpCode[3];                        // Jump Code + NOP

        s8  OEMName[8];                         // OEM Name

        u16 BytesPerSector;                     // Bytes Per Sector

        u8  SectorsPerCluster;          // Sectors Per Cluster

        u16 ReservedSectors;            // Reserved Sectors

        u8  NoFATCopies;                        // Number of Copies of FAT

        u16 MaxRootEntries;                     // Maximum Root Directory Entries

        u16 NoSectorsInPartSml32MB;     // Number of Sectors in Partition Smaller than 32 MB

        u8  MediaDescriptor;            // Media Descriptor (0xF8 for Hard Disks)

        u16 SectorsPerFAT;                      // Sectors Per FAT

        u16 SectorsPerTrack;            // Sectors Per Track

        u16 NoHeads;                            // Number of Heads

        u32 NoHiddenSectors;            // Number of Hidden Sectors     in Partition

        u32 NoSectors;                          // Number of Sectors in Partition

        u16     DriveNo;                                // Logical Drive Number of Partition

        u8  ExtendedSig;                        // Extended Signature (0x29)

        u32 SerialNo;                           // Serial Number of the Partition

        s8  VolumeName[11];                     // Volume Name of the Partititon

        s8  FATName[8];                         // FAT Name (FAT16)

        u8  ExecutableCode[446];        // 446 bytes for machine start code

        u16 ExecutableMarker;           // Executable Marker (0x55 0xAA)

} __attribute__((packed)) VBR_Entry_t;

/*

________________________________________________________________________________________________________________________________________

        Structure of an directory entry

________________________________________________________________________________________________________________________________________

        Directory entry is 32 bytes.

*/

typedef struct

{

        s8      Name[8];                                        // 8 bytes name, padded with spaces.

        u8      Extension[3];                           // 3 bytes extension, padded with spaces.

        u8      Attribute;                                      // attribute of the directory entry (unused,archive,read-only,system,directory,volume)

        u8  Res1;                                               // should be zero

        u8  CreationTime10ms;                   // subsecond resolution of creation time

        u16 CreationTime;                               // Time of creation h:m:s

        u16 CreationDate;                               // Date of creation Y.M.D

        u16 LastAccessDate;             // The date where the file was last accessed

        u8      Res2[2];                                    // should be zero

        u16 ModTime;                                    // date of last write access

        u16 ModDate;                                    // date of last write access to the file or directory.

        u16 StartCluster;                               // first cluster of the file or directory.

        u32 Size;                                               // size of the file or directory in bytes.

}  __attribute__((packed)) DirEntry_t;

#define SLOT_EMPTY              0x00    // slot has never been used

#define SLOT_E5                 0x05    // the real value is 0xe5

#define SLOT_DELETED            0xE5    // file in this slot deleted

#define ATTR_NONE               0x00    // normal file

#define ATTR_READONLY           0x01    // file is readonly

#define ATTR_HIDDEN                     0x02    // file is hidden

#define ATTR_SYSTEM                     0x04    // file is a system file

#define ATTR_VOLUMELABEL        0x08    // entry is a volume label

#define ATTR_LONG_FILENAME      0x0F    // this is a long filename entry

#define ATTR_SUBDIRECTORY       0x10    // entry is a directory name

#define ATTR_ARCHIVE            0x20    // file is new or modified

/*

________________________________________________________________________________________________________________________________________

        Structure of an entry within the fileallocationtable.

________________________________________________________________________________________________________________________________________

*/

typedef struct

{

        u16  NextCluster;                               // the next cluster of the file.

} __attribute__((packed)) Fat16Entry_t;

// secial fat entries

#define FAT16_CLUSTER_FREE                      0x0000

#define FAT16_CLUSTER_RESERVED          0x0001

#define FAT16_CLUSTER_USED_MIN          0x0002

#define FAT16_CLUSTER_USED_MAX          0xFFEF

#define FAT16_CLUSTER_ROOTDIR_MIN       0xFFF0

#define FAT16_CLUSTER_ROOTDIR_MAX       0xFFF6

#define FAT16_CLUSTER_BAD                       0xFFF7

#define FAT16_CLUSTER_LAST_MIN          0xFFF8

#define FAT16_CLUSTER_LAST_MAX          0xFFFF

/*****************************************************************************************************************************************/

/*                                                                                                                                                                                                                                                                               */

/*      Global variables needed for read- or write-acces to the FAT16- filesystem.                                                                                                                       */

/*                                                                                                                                                                                                                                                                               */

/*****************************************************************************************************************************************/

#define MBR_SECTOR                                      0x00    // the masterboot record is located in sector 0.

#define DIRENTRY_SIZE                           32              //bytes

#define DIRENTRIES_PER_SECTOR           BYTES_PER_SECTOR/DIRENTRY_SIZE

#define FAT16_BYTES                                     2

#define FAT16_ENTRIES_PER_SECTOR        BYTES_PER_SECTOR/FAT16_BYTES

#define SECTOR_UNDEFINED        0x00000000L

#define CLUSTER_UNDEFINED       0x0000

#define FSTATE_UNUSED   0

#define FSTATE_USED             1

typedef struct

{

        u8      IsValid;                                // 0 means invalid, else valid

        u8      SectorsPerCluster;              // how many sectors does a cluster contain?

        u8      FatCopies;                              // Numbers of copies of the FAT

        u16     MaxRootEntries;                 // Possible number of entries in the root directory.

        u16     SectorsPerFat;                  // how many sectors does a fat16 contain?

        u32 FirstFatSector;                     // sector of the start of the fat

        u32 FirstRootDirSector;         // sector of the rootdirectory

        u32 FirstDataSector;            // sector of the first cluster containing data (cluster2).

        u32 LastDataSector;                     // the last data sector of the partition

        u8  VolumeLabel[12];        // the volume label

        u32     CurrentWorkingDirectory;// A pointer to the directory we are actual using 

        s8      PathToCwd[256];                 // a string containing the complete path to the current working directory                               

}   __attribute__((packed)) Partition_t;

Partition_t     Partition;              // Structure holds partition information

File_t FilePointer[FILE_MAX_OPEN];      // Allocate Memmoryspace for each filepointer used.

/****************************************************************************************************************************************/

/*      Function:               FileDate(DateTime_t *);                                                                                                                                                                                         */

/*                                                                                                                                                                                                                                                                              */

/*      Description:    This function calculates the DOS date from a pointer to a time structure.                                                                                       */

/*                                                                                                                                                                                                                                                                              */

/*      Returnvalue:    Returns the DOS date.                                                                                                                                                                                           */

/****************************************************************************************************************************************/

u16 FileDate(DateTime_t * pTimeStruct)

{

        u16 date = 0;

        if(pTimeStruct == NULL)   return date;

        if(!(pTimeStruct->Valid)) return date;

        date |= (0x007F & (u16)(pTimeStruct->Year - 1980))<<9; // set year

        date |= (0x000F & (u16)(pTimeStruct->Month))<<5; // set month

        date |= (0x001F & (u16)(pTimeStruct->Day));

        return date;

}

/****************************************************************************************************************************************/

/*      Function:               FileTime(DateTime_t *);                                                                                                                                                                                         */

/*                                                                                                                                                                                                                                                                              */

/*      Description:    This function calculates the DOS time from a pointer to a time structure.                                                                                       */

/*                                                                                                                                                                                                                                                                              */

/*      Returnvalue:    Returns the DOS time.                                                                                                                                                                                           */

/****************************************************************************************************************************************/

u16 FileTime(DateTime_t * pTimeStruct)

{

        u16 time = 0;

        if(pTimeStruct == NULL)   return time;

        if(!(pTimeStruct->Valid)) return time;

        time |= (0x001F & (u16)(pTimeStruct->Hour))<<11;

        time |= (0x003F & (u16)(pTimeStruct->Min))<<5;

        time |= (0x001F & (u16)(pTimeStruct->Sec/2));

        return time;

}

/****************************************************************************************************************************************/

/*      Function:               LockFilePointer();                                                                                                                                                                                                      */

/*                                                                                                                                                                                                                                                                              */

/*      Description:    This function trys to lock a free file pointer.                                                                                                                                         */

/*                                                                                                                                                                                                                                                                              */

/*      Returnvalue:    Returns the Filepointer on success or 0.                                                                                                                                                        */

/****************************************************************************************************************************************/

File_t * LockFilePointer(void)

{

        u8 i;

        File_t * File = 0;

        for(i = 0; i < FILE_MAX_OPEN; i++)

        {

                if(FilePointer[i].State == FSTATE_UNUSED)               // found an unused one

                {

                        File = &FilePointer[i];                                         // set pointer to that entry

                        FilePointer[i].State = FSTATE_USED;                     // mark it as used

                        break;

                }

        }

        return(File);

}

/****************************************************************************************************************************************/

/*      Function:               UnlockFilePointer(file_t *);                                                                                                                                                                            */

/*                                                                                                                                                                                                                                                                              */

/*      Description:    This function trys to unlock a file pointer.                                                                                                                                            */

/*                                                                                                                                                                                                                                                                              */

/*      Returnvalue:    Returns 1 if file pointer was freed else 0.                                                                                                                                                     */

/****************************************************************************************************************************************/

u8 UnlockFilePointer(File_t * file)

{

        u8 cnt;

        if(file == NULL) return(0);

        for(cnt = 0; cnt < FILE_MAX_OPEN; cnt++)

        {

                if(&FilePointer[cnt] == file)                                           // filepointer to be freed found?

                {

                        file->State = FSTATE_UNUSED;

                        file->FirstSectorOfFirstCluster = SECTOR_UNDEFINED;                     // Sectorpointer to the first sector of the first datacluster of the file.

                        file->FirstSectorOfCurrCluster  = SECTOR_UNDEFINED;                     // Pointer to the cluster which is edited at the moment.

                        file->SectorOfCurrCluster               = 0;                    // The sector which is edited at the moment (cluster_pointer + sector_index).

                        file->ByteOfCurrSector                  = 0;                    // The bytelocation within the current sector (cluster_pointer + sector_index + byte_index).

                        file->Mode                                              = 0;                    // mode of fileoperation (read,write)

                        file->Size                                              = 0;                    // the size of the opend file in bytes.

                        file->Position                                  = 0;                    // pointer to a character within the file 0 < fileposition < filesize

                        file->SectorInCache                     = SECTOR_UNDEFINED;                     // the last sector read, wich is still in the sectorbuffer.

                        file->DirectorySector                   = SECTOR_UNDEFINED;                     // the sectorposition where the directoryentry has been made.

                        file->DirectoryIndex                    = 0;                    // the index to the directoryentry within the specified sector.

                        file->Attribute                                 = 0;                    // the attribute of the file opened.

                        file = NULL;

                        return(1);

                }

        }

        return(0);

}

/****************************************************************************************************************************************/

/*      Function:               SeperateDirName(s8*, s8*);                                                                                                                                                                              */

/*                                                                                                                                                                                                                                                                              */

/*      Description:    This function seperates the first dirname from filepath and brings them                                                                                         */

/*                                      into the needed format ('test.txt' -> 'TEST    TXT')                                                                                                                            */

/*                                      The subpath is the pointer to the remaining substring of the filepath                                                                                           */

/*                                                                                                                                                                                                                                                                              */

/*      Returnvalue:    Return NULL on error or pointer to subpath                                                                                                                                                                                                      */

/****************************************************************************************************************************************/

s8* SeperateDirName(const s8 *filepath, s8 *dirname)

{

        s8* subpath = NULL;

        u8 readpointer  = 0;

        u8 writepointer = 0;

        // search subpath from beginning of filepath

        subpath = NULL;

        readpointer     = 0;

        if(filepath[0] == '/') readpointer = 1; // ignore first '/'

        while(subpath == NULL)  // search the filepath until a subpath was found.

        {

                if(((filepath[readpointer] == 0) || (filepath[readpointer] == '/')))    // if '/' found or end of filepath reached

                {

                        subpath = (s8*)&filepath[readpointer];                          // store the position of the first "/" found after the beginning of the filenpath

                }

                readpointer++;

        }

        // clear dirname with spaces

        dirname[11] = 0; // terminate dirname

        for(writepointer = 0; writepointer < 11; writepointer++) dirname[writepointer] = ' ';

        // handle the special dirnames "." and ".." seperately

        readpointer = 0;

        if(filepath[0] == '/') readpointer++;

        // if we are trying to enter directories "." or ".." 

        if(filepath[readpointer] == '.')

        {

                // directory '.'

                if(filepath[readpointer+1] == 0)

                {

                        dirname[0] = '.';

                        return((s8*)&filepath[readpointer]);

                }

                // directory '..'               

                if((filepath[readpointer+1] == '.') &&  (filepath[readpointer+2] == 0))

                {

                        dirname[0] = '.';

                        dirname[1] = '.';

                        return((s8*)&filepath[readpointer]);

                }

        }

        writepointer = 0;

        // start seperating the dirname from the filepath.

        readpointer = 0;

        if(filepath[0] == '/') readpointer = 1; // ignore first '/'

        while( &filepath[readpointer] < subpath)

        {

                if(writepointer >= 11) return(NULL);            // dirname to long

                if(filepath[readpointer] == '.')                        // seperating dirname and extension.

                {

                        if(writepointer <= 8)

                        {

                                readpointer++;                                          // next character in filename

                                writepointer = 8;                                       // jump to start of extension

                        }

                        else return(NULL);                                              // dirbasename to long

                }

                else

                {

                        if((0x60 < filepath[readpointer]) && (filepath[readpointer] < 0x7B))

                        {

                                dirname[writepointer] = (filepath[readpointer] - 0x20);                                 // all characters must be upper case.

                        }

                        else

                        {

                                dirname[writepointer] = filepath[readpointer];

                        }

                        readpointer++;

                        writepointer++;

                }

        }

        return(subpath);

}

/**************************************************************************************************************************************+*/

/*      Function:       Fat16ClusterToSector( u16 cluster);                                                                                                                                                                             */

/*                                                                                                                                                                                                                                                                              */

/*      Description:    This function converts a cluster number given by the fat to the corresponding                                                                           */

/*                                      sector that points to the start of the data area that is represented by the cluster number.                                                     */

/*                                                                                                                                                                                                                                                                              */

/*      Returnvalue: The sector number with the data area of the given cluster                                                                                                                          */

/****************************************************************************************************************************************/

u32     Fat16ClusterToSector(u16 cluster)

{

        if(!Partition.IsValid) return SECTOR_UNDEFINED;

        if ((cluster < 2) || (cluster == CLUSTER_UNDEFINED))

        {

                return SECTOR_UNDEFINED;

        }

        else

        {

                return ( (cluster - 2) * Partition.SectorsPerCluster) + Partition.FirstDataSector; // the first data sector     is represented by the 2nd cluster

        }

}

/****************************************************************************************************************************************/

/*      Function:       SectorToFat16Cluster( u32 sector);                                                                                                                                                                              */

/*                                                                                                                                                                                                                                                                              */

/*      Description:    This function converts a given sector number given to the corresponding                                                                                         */

/*                                      cluster number in the fat that represents this data area.                                                                                                                       */

/*                                                                                                                                                                                                                                                                              */

/*      Returnvalue: The cluster number representing the data area of the sector.                                                                                                                       */

/****************************************************************************************************************************************/

u16     SectorToFat16Cluster(u32 sector)

{

        if(!Partition.IsValid) return CLUSTER_UNDEFINED;

        if((sector == SECTOR_UNDEFINED) || (sector < Partition.FirstDataSector)) return CLUSTER_UNDEFINED;

        else return ((u16)((sector - Partition.FirstDataSector) / Partition.SectorsPerCluster) + 2);

}

/****************************************************************************************************************************************/

/*      Function:       Fat16_IsValid(void);                                                                                                                                                                                                    */

/*                                                                                                                                                                                                                                                                              */

/*      Description:    This function return the Fat 16 filesystem state                                                                                                                                        */

/*                                                                                                                                                                                                                                                                              */

/*      Returnvalue: The function returns "1" on success                                                                                                                                                                        */

/****************************************************************************************************************************************/

u8 Fat16_IsValid(void)

{

        return(Partition.IsValid);

}

/****************************************************************************************************************************************/

/*      Function:       Fat16_Deinit(void);                                                                                                                                                                                                             */

/*                                                                                                                                                                                                                                                                              */

/*      Description:    This function uninitializes the fat 16 api                                                                                                                                                      */

/*                                                                                                                                                                                                                                                                              */

/*      Returnvalue: The function returns "0" on success                                                                                                                                                                        */

/****************************************************************************************************************************************/

u8 Fat16_Deinit(void)

{

        s16 returnvalue = 0;

        u8 cnt;

        UART1_PutString("\r\n FAT16 deinit...");

        // declare the filepointers as unused.

        for(cnt = 0; cnt < FILE_MAX_OPEN; cnt++)

        {      

                UnlockFilePointer(&FilePointer[cnt]);

        }

        returnvalue = SDC_Deinit();                     // uninitialize interface to sd-card

        Partition.IsValid = 0;  // mark data in partition structure as invalid

        Partition.VolumeLabel[0]='\0';

        UART1_PutString("ok");

        if(SD_WatchDog > 2000) SD_WatchDog = 2000;

        SD_LoggingError = 100;

        return(returnvalue);

}

/****************************************************************************************************************************************/

/*      Function:               Fat16_Init(void);                                                                                                                                                                                                       */

/*                                                                                                                                                                                                                                                                          */

/*      Description:    This function reads the Masterbootrecord and finds the position of the Volumebootrecord, the FAT and the Rootdir    */

/*                                      and stores the information in global variables.                                                                                                                                     */

/*                                                                                                                                                                                                                                                                          */

/*      Returnvalue:    The function returns "0" if the filesystem is initialized.                                                                                                                      */

/****************************************************************************************************************************************/

u8 Fat16_Init(void)

{

    u8  cnt     = 0;

        u32     partitionfirstsector;

        VBR_Entry_t *VBR;

        MBR_Entry_t *MBR;

        File_t *file;

        u8 result = 0;

        UART1_PutString("\r\n FAT16 init...");

        Partition.IsValid = 0;

        // declare the filepointers as unused.

        for(cnt = 0; cnt < FILE_MAX_OPEN; cnt++)

        {

                UnlockFilePointer(&FilePointer[cnt]);

        }

        // set current file pinter to first position in list

        file = &FilePointer[0];

        // try to initialize the sd-card.

        if(SD_SUCCESS != SDC_Init())

        {

                UART1_PutString("SD-Card could not be initialized.");

                result = 1;

                goto end;

        }

        // SD-Card is initialized successfully

        if(SD_SUCCESS != SDC_GetSector((u32)MBR_SECTOR,file->Cache))    // Read the MasterBootRecord

        {

                UART1_PutString("Error reading the MBR.");

                result = 2;

                goto end;

        }

        MBR = (MBR_Entry_t *)file->Cache;                                               // Enter the MBR using the structure MBR_Entry_t.

        if((MBR->PartitionEntry1.Type == PART_TYPE_FAT16_ST_32_MB) ||

           (MBR->PartitionEntry1.Type == PART_TYPE_FAT16_LT_32_MB) ||

           (MBR->PartitionEntry1.Type == PART_TYPE_FAT16LBA))

        {

                // get sector offset 1st partition

                partitionfirstsector = MBR->PartitionEntry1.NoSectorsBeforePartition;

                // Start of Partition is the Volume Boot Sector

                if(SD_SUCCESS != SDC_GetSector(partitionfirstsector,file->Cache)) // Read the volume boot record

                {

                        UART1_PutString("Error reading the VBR.");

                        result = 3;

                        goto end;

                }

        }

        else  // maybe the medium has no partition assuming sector 0 is the vbr

        {

                partitionfirstsector = 0;

        }

        VBR = (VBR_Entry_t *) file->Cache;                                              // Enter the VBR using the structure VBR_Entry_t.

        if(VBR->BytesPerSector != BYTES_PER_SECTOR)

        {

                UART1_PutString("VBR: Sector size not supported.");

                result = 4;

                goto end;

        }

        Partition.SectorsPerCluster             = VBR->SectorsPerCluster;                       // Number of sectors per cluster. Depends on the memorysize of the sd-card.

        Partition.FatCopies                     = VBR->NoFATCopies;                                     // Number of fatcopies.

        Partition.MaxRootEntries                = VBR->MaxRootEntries;                          // How many Entries are possible in the rootdirectory (FAT16 allows max. 512 entries).

        Partition.SectorsPerFat                 = VBR->SectorsPerFAT;                           // The number of sectors per FAT                                // copy volume label

        Partition.VolumeLabel[0] = '\0';                                                                        // set string terminator

        /* Calculate the sectorpositon of the FAT, the Rootdirectory and the first Datacluster. */

        // Calculate the position of the FileAllocationTable:

        // Start + # of Reserved Sectors

        Partition.FirstFatSector        =   (u32)(partitionfirstsector + (u32)(VBR->ReservedSectors));

        // Calculate the position of the Rootdirectory:

        // Start + # of Reserved Sectors + (# of Sectors Per FAT * # of FAT Copies)

        Partition.FirstRootDirSector    =   Partition.FirstFatSector + (u32)((u32)Partition.SectorsPerFat*(u32)Partition.FatCopies);

        // Calculate the position of the first datacluster:

        // Start + # of Reserved + (# of Sectors Per FAT * # of FAT Copies) + ((Maximum Root Directory Entries * 32) / Bytes per Sector)

        Partition.FirstDataSector       =   Partition.FirstRootDirSector + (u32)(Partition.MaxRootEntries>>4);  // assuming 512 Byte Per Sector

        // Calculate the last data sector

        if(VBR->NoSectors == 0)

        {

                UART1_PutString("VBR: Bad number of sectors.");

                result = 5;

                goto end;

        }

        Partition.LastDataSector = Partition.FirstDataSector + VBR->NoSectors - 1;

        // check for FAT16 in VBR of first partition

        if(!((VBR->FATName[0]=='F') && (VBR->FATName[1]=='A') && (VBR->FATName[2]=='T') && (VBR->FATName[3]=='1')&&(VBR->FATName[4]=='6')))

        {

                UART1_PutString("VBR: Partition ist not FAT16 type.");

                result = 6;

                goto end;

        }

        Partition.IsValid = 1; // mark data in partition structure as valid

        Partition.CurrentWorkingDirectory = Partition.FirstRootDirSector;

        strcpy(Partition.PathToCwd,"/");       

        result = 0;

        end:

        if(result != 0) Fat16_Deinit();

        else UART1_PutString("ok");

        return(result);

}

/****************************************************************************************************************************************/

/* Function:    ClearCurrCluster(File_t*);                                                                                                                                                                                      */

/*                                                                                                                                                                                                                                                                              */

/* Description: This function fills the current cluster with 0.                                                                                                                                                 */

/*                                                                                                                                                                                                                                                                              */

/* Returnvalue: The function returns 1 on success else 0.                                                                                                                                                               */

/****************************************************************************************************************************************/

u8 ClearCurrCluster(File_t * file)

{

        u8 retvalue = 1;

        u32 i;

        if((!Partition.IsValid) || (file == NULL)) return(0);

        for(i = 0; i < BYTES_PER_SECTOR; i++) file->Cache[i] = 0; // clear file cache

        if(file->FirstSectorOfCurrCluster == SECTOR_UNDEFINED) return (0); // nothing to do 

        for(i = 0; i < Partition.SectorsPerCluster; i++)

        {

                file->SectorInCache = file->FirstSectorOfCurrCluster + i;

                if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))

                {

                        Fat16_Deinit();

                        return(0);

                }

        }

        return(retvalue);

}

/*****************************************************************************************************************************************/

/* Function:    GetNextCluster(File_t* );                                                                                                                                                                                        */

/*                                                                                                                                                                                                                                                                               */

/* Description: This function finds the next datacluster of the file specified with File *File.                                                                                  */

/*                                                                                                                                                                                                                                                                               */

/* Returnvalue: The function returns the next cluster or 0 if the last cluster has already reached.                                                                                                      */

/*****************************************************************************************************************************************/

u16 GetNextCluster(File_t * file)

{

        u16 cluster = CLUSTER_UNDEFINED;

        u32 fat_byte_offset, sector, byte;

        Fat16Entry_t * fat;

        if((!Partition.IsValid) || (file == NULL)) return(cluster);

        if(file->FirstSectorOfCurrCluster == SECTOR_UNDEFINED) return(cluster);

        // if sector is within the data area

        if((Partition.FirstDataSector <= file->FirstSectorOfCurrCluster)&& (file->FirstSectorOfCurrCluster <= Partition.LastDataSector))

        {

                // determine current file cluster

                cluster = SectorToFat16Cluster(file->FirstSectorOfCurrCluster);

                // calculate byte offset in the fat for corresponding entry

                fat_byte_offset = ((u32)cluster)<<1; // two FAT bytes (16 bits) for every cluster

                // calculate the sector that contains the current cluster within the fat

                sector = Partition.FirstFatSector + ( fat_byte_offset / BYTES_PER_SECTOR);

                // calculate byte offset of the current cluster within that fat sector

                byte = fat_byte_offset % BYTES_PER_SECTOR;

                // read this sector to the file cache

                if(file->SectorInCache != sector)

                {

                        file->SectorInCache = sector;                                           // update sector stored in buffer

                        if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))       // read sector from sd-card

                        {

                                Fat16_Deinit();

                                return (CLUSTER_UNDEFINED);

                        }

                }

                // read the next cluster from cache

                fat = (Fat16Entry_t *)(&(file->Cache[byte]));

                cluster = fat->NextCluster;

                // if no next cluster exist

                if(FAT16_CLUSTER_LAST_MIN <= cluster)

                {

                         cluster = CLUSTER_UNDEFINED; // next cluster is undefined

                }

                else

                {

                        file->FirstSectorOfCurrCluster = Fat16ClusterToSector(cluster);

                        file->SectorOfCurrCluster = 0;

                        file->ByteOfCurrSector = 0;

                }

        }

        return(cluster);

}

/****************************************************************************************************************************************/

/* Function:    FindNextFreeCluster(File_t *);                                                                                                                                                                          */

/*                                                                                                                                                                                                                                                                              */

/* Description: This function looks in the fat to find the next free cluster                                                                                                                    */

/*                                                                                                                                                                                                                                                                              */

/* Returnvalue: The function returns the cluster number of the next free cluster found within the fat.                                                                  */

/****************************************************************************************************************************************/

u16 FindNextFreeCluster(File_t *file)

{

        u32 fat_sector;                                 // current sector within the fat relative to the first sector of the fat.

        u32     curr_sector;                            // current sector

        u16     fat_entry;                                      // index to an fatentry within the actual sector (256 fatentries are possible within one sector).

        u16     free_cluster    = CLUSTER_UNDEFINED;    // next free cluster number.

        Fat16Entry_t * fat;

        if((!Partition.IsValid) || (file == NULL)) return(0);

        // start searching for an empty cluster at the beginning of the fat.

        fat_sector = 0;

        do

        {

                curr_sector = Partition.FirstFatSector + fat_sector;    // calculate sector to read

                file->SectorInCache = curr_sector;                                              // upate the sector number of file cache.

                if( SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))              // read sector of fat from sd-card.

                {

                        Fat16_Deinit();

                        return(CLUSTER_UNDEFINED);

                }

                fat = (Fat16Entry_t *)file->Cache;                                              // set fat pointer to file cache

                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.

                {

                        if(fat[fat_entry].NextCluster == FAT16_CLUSTER_FREE)            // empty cluster found!!

                        {

                                fat[fat_entry].NextCluster = FAT16_CLUSTER_LAST_MAX;    // mark this fat-entry as used

                                if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))               // and save the sector at the sd-card.

                                {

                                        Fat16_Deinit();

                                        return(CLUSTER_UNDEFINED);

                                }

                                free_cluster = (u16)(fat_sector * FAT16_ENTRIES_PER_SECTOR + (u32)fat_entry);

                                fat_entry = FAT16_ENTRIES_PER_SECTOR;                                   // terminate the search for a free cluster in this sector.

                        }

                }

                fat_sector++;                                                                                                   // continue the search in next fat sector

        // repeat until the end of the fat is  reached and no free cluster has been found so far

        }while((fat_sector < Partition.SectorsPerFat) && (!free_cluster));

        return(free_cluster);