M3pi logo character recognition principle

Dependencies:   mbed m3pi

Files at this revision

API Documentation at this revision

Comitter:
Nicholas
Date:
Fri Jul 08 12:12:56 2011 +0000
Commit message:

Changed in this revision

FATFileSystem/FATDirHandle.h Show annotated file Show diff for this revision Revisions of this file
FATFileSystem/FATFileHandle.h Show annotated file Show diff for this revision Revisions of this file
FATFileSystem/FATFileSystem.ar Show annotated file Show diff for this revision Revisions of this file
FATFileSystem/FATFileSystem.h Show annotated file Show diff for this revision Revisions of this file
FATFileSystem/diskio.h Show annotated file Show diff for this revision Revisions of this file
FATFileSystem/ff.h Show annotated file Show diff for this revision Revisions of this file
FATFileSystem/integer.h Show annotated file Show diff for this revision Revisions of this file
MSCFileSystem.lib Show annotated file Show diff for this revision Revisions of this file
m3pi.lib Show annotated file Show diff for this revision Revisions of this file
main.cpp Show annotated file Show diff for this revision Revisions of this file
mbed.bld Show annotated file Show diff for this revision Revisions of this file
diff -r 000000000000 -r 33bfb6a726ba FATFileSystem/FATDirHandle.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FATFileSystem/FATDirHandle.h	Fri Jul 08 12:12:56 2011 +0000
@@ -0,0 +1,29 @@
+/* Copyright 2008 ARM Limited. All rights reserved. */
+
+#ifndef MBED_FATDIRHANDLE_H
+#define MBED_FATDIRHANDLE_H
+
+#include "DirHandle.h"
+#include "ff.h"
+
+namespace mbed {
+
+class FATDirHandle : public DirHandle {
+
+ public:
+    FATDirHandle(const FATFS_DIR &the_dir);
+    virtual int closedir();
+    virtual struct dirent *readdir();
+    virtual void rewinddir();
+    virtual off_t telldir();
+    virtual void seekdir(off_t location);
+
+ private:
+    FATFS_DIR dir;
+    struct dirent cur_entry;
+
+};
+
+}
+
+#endif
diff -r 000000000000 -r 33bfb6a726ba FATFileSystem/FATFileHandle.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FATFileSystem/FATFileHandle.h	Fri Jul 08 12:12:56 2011 +0000
@@ -0,0 +1,33 @@
+/* mbed Microcontroller Library - FATFileHandle
+ * Copyright (c) 2008, sford
+ */
+
+#ifndef MBED_FATFILEHANDLE_H
+#define MBED_FATFILEHANDLE_H
+
+#include "FileHandle.h"
+#include "ff.h"
+
+namespace mbed {
+
+class FATFileHandle : public FileHandle {
+public:
+
+    FATFileHandle(FIL fh);
+    virtual int close();
+    virtual ssize_t write(const void* buffer, size_t length);
+    virtual ssize_t read(void* buffer, size_t length);
+    virtual int isatty();
+    virtual off_t lseek(off_t position, int whence);
+    virtual int fsync();
+    virtual off_t flen();
+
+protected:
+
+    FIL _fh;
+
+};
+
+}
+
+#endif
diff -r 000000000000 -r 33bfb6a726ba FATFileSystem/FATFileSystem.ar
Binary file FATFileSystem/FATFileSystem.ar has changed
diff -r 000000000000 -r 33bfb6a726ba FATFileSystem/FATFileSystem.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FATFileSystem/FATFileSystem.h	Fri Jul 08 12:12:56 2011 +0000
@@ -0,0 +1,61 @@
+/* mbed Microcontroller Library - FATFileSystem
+ * Copyright (c) 2008, sford
+ */
+
+/* Library: FATFileSystem.h
+ * A library of stuff to make a fat filesystem on top of a block device
+ */
+
+#ifndef MBED_FATFILESYSTEM_H
+#define MBED_FATFILESYSTEM_H
+
+#ifndef FFSDEBUG_ENABLED
+#define FFSDEBUG_ENABLED 0
+#endif
+
+#if FFSDEBUG_ENABLED
+#define FFSDEBUG(FMT, ...) printf(FMT, ##__VA_ARGS__)
+#else
+#define FFSDEBUG(FMT, ...)
+#endif
+
+#include "FileSystemLike.h"
+#include "FileHandle.h"
+#include "ff.h"
+#include "diskio.h"
+
+namespace mbed {
+/* Class: FATFileSystem
+ * The class itself
+ */
+class FATFileSystem : public FileSystemLike {
+public:
+
+    FATFileSystem(const char* n);
+    virtual ~FATFileSystem();
+    
+    /* Function: open
+       * open a file on the filesystem. never called directly
+       */
+    virtual FileHandle *open(const char* name, int flags);
+    virtual int remove(const char *filename);
+    virtual int format();
+        virtual DirHandle *opendir(const char *name);
+        virtual int mkdir(const char *name, mode_t mode);
+    
+    FATFS _fs;                                // Work area (file system object) for logical drive    
+    static FATFileSystem *_ffs[_DRIVES];    // FATFileSystem objects, as parallel to FatFs drives array
+    int _fsid;
+    
+    virtual int disk_initialize() { return 0; }
+    virtual int disk_status() { return 0; }
+    virtual int disk_read(char *buffer, int sector) = 0;
+    virtual int disk_write(const char *buffer, int sector) = 0;
+    virtual int disk_sync() { return 0; }
+    virtual int disk_sectors() = 0;
+     
+};
+    
+}
+
+#endif
diff -r 000000000000 -r 33bfb6a726ba FATFileSystem/diskio.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FATFileSystem/diskio.h	Fri Jul 08 12:12:56 2011 +0000
@@ -0,0 +1,76 @@
+/*-----------------------------------------------------------------------
+/  Low level disk interface modlue include file  R0.06   (C)ChaN, 2007
+/-----------------------------------------------------------------------*/
+
+#ifndef _DISKIO
+
+#define _READONLY    0    /* 1: Read-only mode */
+#define _USE_IOCTL    1
+
+#include "integer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Status of Disk Functions */
+typedef BYTE    DSTATUS;
+
+/* Results of Disk Functions */
+typedef enum {
+    RES_OK = 0,        /* 0: Successful */
+    RES_ERROR,        /* 1: R/W Error */
+    RES_WRPRT,        /* 2: Write Protected */
+    RES_NOTRDY,        /* 3: Not Ready */
+    RES_PARERR        /* 4: Invalid Parameter */
+} DRESULT;
+
+
+/*---------------------------------------*/
+/* Prototypes for disk control functions */
+
+DSTATUS disk_initialize (BYTE);
+DSTATUS disk_status (BYTE);
+DRESULT disk_read (BYTE, BYTE*, DWORD, BYTE);
+#if    _READONLY == 0
+DRESULT disk_write (BYTE, const BYTE*, DWORD, BYTE);
+#endif
+DRESULT disk_ioctl (BYTE, BYTE, void*);
+void    disk_timerproc (void);
+
+#ifdef __cplusplus
+};
+#endif
+
+
+/* Disk Status Bits (DSTATUS) */
+
+#define STA_NOINIT        0x01    /* Drive not initialized */
+#define STA_NODISK        0x02    /* No medium in the drive */
+#define STA_PROTECT        0x04    /* Write protected */
+
+
+/* Command code for disk_ioctrl() */
+
+/* Generic command */
+#define CTRL_SYNC            0    /* Mandatory for read/write configuration */
+#define GET_SECTOR_COUNT    1    /* Mandatory for only f_mkfs() */
+#define GET_SECTOR_SIZE        2
+#define GET_BLOCK_SIZE        3    /* Mandatory for only f_mkfs() */
+#define CTRL_POWER            4
+#define CTRL_LOCK            5
+#define CTRL_EJECT            6
+/* MMC/SDC command */
+#define MMC_GET_TYPE        10
+#define MMC_GET_CSD            11
+#define MMC_GET_CID            12
+#define MMC_GET_OCR            13
+#define MMC_GET_SDSTAT        14
+/* ATA/CF command */
+#define ATA_GET_REV            20
+#define ATA_GET_MODEL        21
+#define ATA_GET_SN            22
+
+
+#define _DISKIO
+#endif
diff -r 000000000000 -r 33bfb6a726ba FATFileSystem/ff.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FATFileSystem/ff.h	Fri Jul 08 12:12:56 2011 +0000
@@ -0,0 +1,344 @@
+/*--------------------------------------------------------------------------/
+/  FatFs - FAT file system module include file  R0.06        (C)ChaN, 2008
+/---------------------------------------------------------------------------/
+/ FatFs module is an experimenal project to implement FAT file system to
+/ cheap microcontrollers. This is a free software and is opened for education,
+/ research and development under license policy of following trems.
+/
+/  Copyright (C) 2008, ChaN, all right reserved.
+/
+/ * The FatFs module is a free software and there is no warranty.
+/ * You can use, modify and/or redistribute it for personal, non-profit or
+/   commercial use without any restriction under your responsibility.
+/ * Redistributions of source code must retain the above copyright notice.
+/
+/---------------------------------------------------------------------------*/
+
+#ifndef _FATFS
+
+#define _MCU_ENDIAN        2
+/* The _MCU_ENDIAN defines which access method is used to the FAT structure.
+/  1: Enable word access.
+/  2: Disable word access and use byte-by-byte access instead.
+/  When the architectural byte order of the MCU is big-endian and/or address
+/  miss-aligned access results incorrect behavior, the _MCU_ENDIAN must be set to 2.
+/  If it is not the case, it can also be set to 1 for good code efficiency. */
+
+#define _FS_READONLY    0
+/* Setting _FS_READONLY to 1 defines read only configuration. This removes
+/  writing functions, f_write, f_sync, f_unlink, f_mkdir, f_chmod, f_rename,
+/  f_truncate and useless f_getfree. */
+
+#define _FS_MINIMIZE    0
+/* The _FS_MINIMIZE option defines minimization level to remove some functions.
+/  0: Full function.
+/  1: f_stat, f_getfree, f_unlink, f_mkdir, f_chmod, f_truncate and f_rename are removed.
+/  2: f_opendir and f_readdir are removed in addition to level 1.
+/  3: f_lseek is removed in addition to level 2. */
+
+#define    _USE_STRFUNC    0
+/* To enable string functions, set _USE_STRFUNC to 1 or 2. */
+
+#define    _USE_MKFS    1
+/* When _USE_MKFS is set to 1 and _FS_READONLY is set to 0, f_mkfs function is
+/  enabled. */
+
+#define _DRIVES        4
+/* Number of logical drives to be used. This affects the size of internal table. */
+
+#define    _MULTI_PARTITION    0
+/* When _MULTI_PARTITION is set to 0, each logical drive is bound to same
+/  physical drive number and can mount only 1st primaly partition. When it is
+/  set to 1, each logical drive can mount a partition listed in Drives[]. */
+
+#define _USE_FSINFO    0
+/* To enable FSInfo support on FAT32 volume, set _USE_FSINFO to 1. */
+
+#define    _USE_SJIS    1
+/* When _USE_SJIS is set to 1, Shift-JIS code transparency is enabled, otherwise
+/  only US-ASCII(7bit) code can be accepted as file/directory name. */
+
+#define    _USE_NTFLAG    1
+/* When _USE_NTFLAG is set to 1, upper/lower case of the file name is preserved.
+/  Note that the files are always accessed in case insensitive. */
+
+
+#include "integer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Definitions corresponds to multiple sector size (not tested) */
+#define    S_MAX_SIZ    512U            /* Do not change */
+#if S_MAX_SIZ > 512U
+#define    SS(fs)    ((fs)->s_size)
+#else
+#define    SS(fs)    512U
+#endif
+
+
+/* File system object structure */
+typedef struct _FATFS {
+    WORD    id;                /* File system mount ID */
+    WORD    n_rootdir;        /* Number of root directory entries */
+    DWORD    winsect;        /* Current sector appearing in the win[] */
+    DWORD    sects_fat;        /* Sectors per fat */
+    DWORD    max_clust;        /* Maximum cluster# + 1 */
+    DWORD    fatbase;        /* FAT start sector */
+    DWORD    dirbase;        /* Root directory start sector (cluster# for FAT32) */
+    DWORD    database;        /* Data start sector */
+#if !_FS_READONLY
+    DWORD    last_clust;        /* Last allocated cluster */
+    DWORD    free_clust;        /* Number of free clusters */
+#if _USE_FSINFO
+    DWORD    fsi_sector;        /* fsinfo sector */
+    BYTE    fsi_flag;        /* fsinfo dirty flag (1:must be written back) */
+    BYTE    pad2;
+#endif
+#endif
+    BYTE    fs_type;        /* FAT sub type */
+    BYTE    csize;            /* Number of sectors per cluster */
+#if S_MAX_SIZ > 512U
+    WORD    s_size;            /* Sector size */
+#endif
+    BYTE    n_fats;            /* Number of FAT copies */
+    BYTE    drive;            /* Physical drive number */
+    BYTE    winflag;        /* win[] dirty flag (1:must be written back) */
+    BYTE    pad1;
+    BYTE    win[S_MAX_SIZ];    /* Disk access window for Directory/FAT */
+} FATFS;
+
+
+/* Directory object structure */
+typedef struct _DIR {
+    WORD    id;            /* Owner file system mount ID */
+    WORD    index;        /* Current index */
+    FATFS*    fs;            /* Pointer to the owner file system object */
+    DWORD    sclust;        /* Start cluster */
+    DWORD    clust;        /* Current cluster */
+    DWORD    sect;        /* Current sector */
+} FATFS_DIR;
+
+
+/* File object structure */
+typedef struct _FIL {
+    WORD    id;                /* Owner file system mount ID */
+    BYTE    flag;            /* File status flags */
+    BYTE    csect;            /* Sector address in the cluster */
+    FATFS*    fs;                /* Pointer to the owner file system object */
+    DWORD    fptr;            /* File R/W pointer */
+    DWORD    fsize;            /* File size */
+    DWORD    org_clust;        /* File start cluster */
+    DWORD    curr_clust;        /* Current cluster */
+    DWORD    curr_sect;        /* Current sector */
+#if _FS_READONLY == 0
+    DWORD    dir_sect;        /* Sector containing the directory entry */
+    BYTE*    dir_ptr;        /* Ponter to the directory entry in the window */
+#endif
+    BYTE    buffer[S_MAX_SIZ];    /* File R/W buffer */
+} FIL;
+
+
+/* File status structure */
+typedef struct _FILINFO {
+    DWORD fsize;            /* Size */
+    WORD fdate;                /* Date */
+    WORD ftime;                /* Time */
+    BYTE fattrib;            /* Attribute */
+    char fname[8+1+3+1];    /* Name (8.3 format) */
+} FILINFO;
+
+
+
+/* Definitions corresponds to multi partition */
+
+#if _MULTI_PARTITION != 0    /* Multiple partition cfg */
+
+typedef struct _PARTITION {
+    BYTE pd;    /* Physical drive # (0-255) */
+    BYTE pt;    /* Partition # (0-3) */
+} PARTITION;
+extern
+const PARTITION Drives[];            /* Logical drive# to physical location conversion table */
+#define LD2PD(drv) (Drives[drv].pd)    /* Get physical drive# */
+#define LD2PT(drv) (Drives[drv].pt)    /* Get partition# */
+
+#else                        /* Single partition cfg */
+
+#define LD2PD(drv) (drv)        /* Physical drive# is equal to logical drive# */
+#define LD2PT(drv) 0            /* Always mounts the 1st partition */
+
+#endif
+
+
+/* File function return code (FRESULT) */
+
+typedef enum {
+    FR_OK = 0,            /* 0 */
+    FR_NOT_READY,        /* 1 */
+    FR_NO_FILE,            /* 2 */
+    FR_NO_PATH,            /* 3 */
+    FR_INVALID_NAME,    /* 4 */
+    FR_INVALID_DRIVE,    /* 5 */
+    FR_DENIED,            /* 6 */
+    FR_EXIST,            /* 7 */
+    FR_RW_ERROR,        /* 8 */
+    FR_WRITE_PROTECTED,    /* 9 */
+    FR_NOT_ENABLED,        /* 10 */
+    FR_NO_FILESYSTEM,    /* 11 */
+    FR_INVALID_OBJECT,    /* 12 */
+    FR_MKFS_ABORTED        /* 13 */
+} FRESULT;
+
+
+
+/*-----------------------------------------------------*/
+/* FatFs module application interface                  */
+
+FRESULT f_mount (BYTE, FATFS*);                        /* Mount/Unmount a logical drive */
+FRESULT f_open (FIL*, const char*, BYTE);            /* Open or create a file */
+FRESULT f_read (FIL*, void*, UINT, UINT*);            /* Read data from a file */
+FRESULT f_write (FIL*, const void*, UINT, UINT*);    /* Write data to a file */
+FRESULT f_lseek (FIL*, DWORD);                        /* Move file pointer of a file object */
+FRESULT f_close (FIL*);                                /* Close an open file object */
+FRESULT f_opendir (FATFS_DIR*, const char*);                /* Open an existing directory */
+FRESULT f_readdir (FATFS_DIR*, FILINFO*);                    /* Read a directory item */
+FRESULT f_stat (const char*, FILINFO*);                /* Get file status */
+FRESULT f_getfree (const char*, DWORD*, FATFS**);    /* Get number of free clusters on the drive */
+FRESULT f_truncate (FIL*);                            /* Truncate file */
+FRESULT f_sync (FIL*);                                /* Flush cached data of a writing file */
+FRESULT f_unlink (const char*);                        /* Delete an existing file or directory */
+FRESULT    f_mkdir (const char*);                        /* Create a new directory */
+FRESULT f_chmod (const char*, BYTE, BYTE);            /* Change file/dir attriburte */
+FRESULT f_utime (const char*, const FILINFO*);        /* Change file/dir timestamp */
+FRESULT f_rename (const char*, const char*);        /* Rename/Move a file or directory */
+FRESULT f_mkfs (BYTE, BYTE, WORD);                    /* Create a file system on the drive */
+#if _USE_STRFUNC
+#define feof(fp) ((fp)->fptr == (fp)->fsize)
+#define EOF -1
+int fputc (int, FIL*);                                /* Put a character to the file */
+int fputs (const char*, FIL*);                        /* Put a string to the file */
+int fprintf (FIL*, const char*, ...);                /* Put a formatted string to the file */
+char* fgets (char*, int, FIL*);                        /* Get a string from the file */
+#endif
+
+/* User defined function to give a current time to fatfs module */
+
+DWORD get_fattime (void);    /* 31-25: Year(0-127 org.1980), 24-21: Month(1-12), 20-16: Day(1-31) */
+                            /* 15-11: Hour(0-23), 10-5: Minute(0-59), 4-0: Second(0-29 *2) */
+
+
+
+/* File access control and file status flags (FIL.flag) */
+
+#define    FA_READ                0x01
+#define    FA_OPEN_EXISTING    0x00
+#if _FS_READONLY == 0
+#define    FA_WRITE            0x02
+#define    FA_CREATE_NEW        0x04
+#define    FA_CREATE_ALWAYS    0x08
+#define    FA_OPEN_ALWAYS        0x10
+#define FA__WRITTEN            0x20
+#define FA__DIRTY            0x40
+#endif
+#define FA__ERROR            0x80
+
+
+/* FAT sub type (FATFS.fs_type) */
+
+#define FS_FAT12    1
+#define FS_FAT16    2
+#define FS_FAT32    3
+
+
+/* File attribute bits for directory entry */
+
+#define    AM_RDO    0x01    /* Read only */
+#define    AM_HID    0x02    /* Hidden */
+#define    AM_SYS    0x04    /* System */
+#define    AM_VOL    0x08    /* Volume label */
+#define AM_LFN    0x0F    /* LFN entry */
+#define AM_DIR    0x10    /* Directory */
+#define AM_ARC    0x20    /* Archive */
+
+
+
+/* Offset of FAT structure members */
+
+#define BS_jmpBoot            0
+#define BS_OEMName            3
+#define BPB_BytsPerSec        11
+#define BPB_SecPerClus        13
+#define BPB_RsvdSecCnt        14
+#define BPB_NumFATs            16
+#define BPB_RootEntCnt        17
+#define BPB_TotSec16        19
+#define BPB_Media            21
+#define BPB_FATSz16            22
+#define BPB_SecPerTrk        24
+#define BPB_NumHeads        26
+#define BPB_HiddSec            28
+#define BPB_TotSec32        32
+#define BS_55AA                510
+
+#define BS_DrvNum            36
+#define BS_BootSig            38
+#define BS_VolID            39
+#define BS_VolLab            43
+#define BS_FilSysType        54
+
+#define BPB_FATSz32            36
+#define BPB_ExtFlags        40
+#define BPB_FSVer            42
+#define BPB_RootClus        44
+#define BPB_FSInfo            48
+#define BPB_BkBootSec        50
+#define BS_DrvNum32            64
+#define BS_BootSig32        66
+#define BS_VolID32            67
+#define BS_VolLab32            71
+#define BS_FilSysType32        82
+
+#define    FSI_LeadSig            0
+#define    FSI_StrucSig        484
+#define    FSI_Free_Count        488
+#define    FSI_Nxt_Free        492
+
+#define MBR_Table            446
+
+#define    DIR_Name            0
+#define    DIR_Attr            11
+#define    DIR_NTres            12
+#define    DIR_CrtTime            14
+#define    DIR_CrtDate            16
+#define    DIR_FstClusHI        20
+#define    DIR_WrtTime            22
+#define    DIR_WrtDate            24
+#define    DIR_FstClusLO        26
+#define    DIR_FileSize        28
+
+
+
+/* Multi-byte word access macros  */
+
+#if _MCU_ENDIAN == 1    /* Use word access */
+#define    LD_WORD(ptr)        (WORD)(*(WORD*)(BYTE*)(ptr))
+#define    LD_DWORD(ptr)        (DWORD)(*(DWORD*)(BYTE*)(ptr))
+#define    ST_WORD(ptr,val)    *(WORD*)(BYTE*)(ptr)=(WORD)(val)
+#define    ST_DWORD(ptr,val)    *(DWORD*)(BYTE*)(ptr)=(DWORD)(val)
+#elif _MCU_ENDIAN == 2    /* Use byte-by-byte access */
+#define    LD_WORD(ptr)        (WORD)(((WORD)*(volatile BYTE*)((ptr)+1)<<8)|(WORD)*(volatile BYTE*)(ptr))
+#define    LD_DWORD(ptr)        (DWORD)(((DWORD)*(volatile BYTE*)((ptr)+3)<<24)|((DWORD)*(volatile BYTE*)((ptr)+2)<<16)|((WORD)*(volatile BYTE*)((ptr)+1)<<8)|*(volatile BYTE*)(ptr))
+#define    ST_WORD(ptr,val)    *(volatile BYTE*)(ptr)=(BYTE)(val); *(volatile BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8)
+#define    ST_DWORD(ptr,val)    *(volatile BYTE*)(ptr)=(BYTE)(val); *(volatile BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8); *(volatile BYTE*)((ptr)+2)=(BYTE)((DWORD)(val)>>16); *(volatile BYTE*)((ptr)+3)=(BYTE)((DWORD)(val)>>24)
+#else
+#error Do not forget to set _MCU_ENDIAN properly!
+#endif
+
+#ifdef __cplusplus
+};
+#endif
+
+#define _FATFS
+#endif /* _FATFS */
diff -r 000000000000 -r 33bfb6a726ba FATFileSystem/integer.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FATFileSystem/integer.h	Fri Jul 08 12:12:56 2011 +0000
@@ -0,0 +1,30 @@
+/*-------------------------------------------*/
+/* Integer type definitions for FatFs module */
+/*-------------------------------------------*/
+
+#ifndef _INTEGER
+
+/* These types must be 16-bit, 32-bit or larger integer */
+typedef int                INT;
+typedef unsigned int    UINT;
+
+/* These types must be 8-bit integer */
+typedef signed char        CHAR;
+typedef unsigned char    UCHAR;
+typedef unsigned char    BYTE;
+
+/* These types must be 16-bit integer */
+typedef short            SHORT;
+typedef unsigned short    USHORT;
+typedef unsigned short    WORD;
+
+/* These types must be 32-bit integer */
+typedef long            LONG;
+typedef unsigned long    ULONG;
+typedef unsigned long    DWORD;
+
+/* Boolean type */
+typedef enum { FALSE = 0, TRUE } BOOL;
+
+#define _INTEGER
+#endif
diff -r 000000000000 -r 33bfb6a726ba MSCFileSystem.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MSCFileSystem.lib	Fri Jul 08 12:12:56 2011 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/chris/code/MSCFileSystem/#a82ee02f2e91
diff -r 000000000000 -r 33bfb6a726ba m3pi.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/m3pi.lib	Fri Jul 08 12:12:56 2011 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/chris/code/m3pi/#4b7d6ea9b35b
diff -r 000000000000 -r 33bfb6a726ba main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Fri Jul 08 12:12:56 2011 +0000
@@ -0,0 +1,189 @@
+#include "mbed.h"
+#include "m3pi.h"
+#include "MSCFileSystem.h"
+
+DigitalOut ledone(LED1);
+DigitalOut ledtwo(LED2);
+DigitalOut ledthree(LED3);
+DigitalOut ledfour(LED4);
+MSCFileSystem msc("msc");   // allows read/write to a removable USB device through the m3pi's USB interface
+Serial pc(USBTX, USBRX);
+m3pi m3pi;
+
+float speed_max;            //the maximum speed allowed. used in fwd/bck under recognition
+float speed_mod;            //the modifiable speed varible used for cornering. may be used to adjust cornering values in future versions
+float speed_user;
+
+char Buffer[512];   //will house all of the data in the Commands.txt file. has space for 510 commands + one speed variable at begining (M5)
+
+FILE *CMD = fopen("/msc/Commands.txt", "r");    //where all the commands should be stored
+
+//this will be run in the event that something goes wrong like a character cant be recognised or a file is missing
+void ERR() {
+    while (1) {
+        ledtwo = 0;
+        ledthree = 0;
+        ledone = 1;
+        ledfour = 1;
+        wait(0.2);
+        ledfour = 0;
+        ledone = 0;
+        ledtwo = 1;
+        ledthree = 1;
+        wait(0.2);
+    }
+}
+
+//run on completion of the scrip
+void FIN() {
+    while (1) {
+        ledone = 1;
+        ledtwo = 1;
+        ledthree = 1;
+        ledfour = 1;
+        wait(0.5);
+        ledone = 0;
+        ledtwo = 0;
+        ledthree = 0;
+        ledfour = 0;
+        wait(0.5);
+    }
+}
+//this will check that all the files are present and accounted for.
+void opening() {
+    m3pi.cls();
+    m3pi.locate(0,0);
+    m3pi.printf("  LOGO");
+    m3pi.locate(0,1);
+    m3pi.printf("  RACE");
+    FILE *CMD = fopen("/msc/Commands.txt", "r");
+    //if it isnt is there, we have an ERROR, Run ERR();
+    if (CMD == NULL) {
+        m3pi.cls();
+        m3pi.printf("CMD ERR");
+        fclose(CMD);
+        while (1) {
+            ERR();
+        }
+        fclose(CMD);
+    }
+}
+
+//getting everything from the text document
+void grabbing() {
+    fopen("/msc/Commands.txt", "r");
+    while (!feof(CMD)) {
+        ledone = 1;
+        //put everything in Buffer as a string it would be easier to have it in seperate containers but for simplicity to understand for nivices like my, i have done it like this.
+        fscanf (CMD, "%s", Buffer);
+    }
+    fclose(CMD);
+    ledone = 0;
+    //add on to the end of Buffer a *  so that the end can be recognised
+    sprintf(Buffer + strlen(Buffer), "*");
+}
+
+//sets the speed
+void variables () {
+    if (Buffer[0] == 'M') {
+        //as everything is in a string, numbers /begin at 48 (0, 1 etc) so anything after 48 should be a number
+        if (Buffer[1] >= 49) {
+            speed_max = ((Buffer[1] - 48) / 10);
+        } else {
+            // if it isnt a number, it can be used, say ERR
+            m3pi.cls();
+            m3pi.printf("BAD");
+            m3pi.locate(0,1);
+            m3pi.printf("SPEED");
+            ERR();
+        }
+        speed_user = speed_max;
+    } else {
+        //if nothing is there, there has been no speed defined!
+        m3pi.cls();
+        m3pi.printf("NO SPEED");
+        m3pi.locate(0,1);
+        m3pi.printf("DEFINED");
+    }
+}
+
+
+void recognition() {
+    //this shall be used to incriment what character we are looking at
+    int N=2;
+    //repeat until the end of the document
+    while (!feof(CMD)) {
+        if (Buffer[N] == 'F' || Buffer[N] == 'f') {
+            N++;
+            //Because it's a  string, the conversion will turn the number 1 into 49, as it is the 49th character that can be recognised.
+            while (Buffer[N] >= 48) {
+                m3pi.cls();
+                m3pi.printf("FWD %c", Buffer[N]);   // F represents forward and
+                m3pi.forward(speed_max);            // a number after it represents how long
+                wait(Buffer[N] - 48);               //to go forwards for. this senario
+                m3pi.stop();                        //only includes the posibilty of
+                N++;                                // a one digit number.
+            }
+        } else if (Buffer[N] == 'B' || Buffer[N] == 'b') {
+            N++;
+            while (Buffer[N] >= 48) {
+                m3pi.cls();
+                m3pi.printf("BACK %c", Buffer[N]);
+                m3pi.backward(speed_max);
+                wait(Buffer[N] - 48);
+                N++;
+            }
+        } else if (Buffer[N] == 'R' || Buffer[N] == 'r') {
+            N++;
+            while (Buffer[N] >= 48) {
+                int A=Buffer[N] - 48;
+                m3pi.cls();
+                m3pi.printf("RGHT %d", A);
+                m3pi.left( - speed_max);
+                m3pi.right(speed_max);
+                wait(((speed_mod * 0.28)/9)*A); //a number after R or L represents
+                m3pi.stop();                    //how much to turn. the algorithm
+                N++;                            //above converts that to wait times for motors
+            }
+        } else if (Buffer[N] == 'L' || Buffer[N] == 'l') {
+            N++;
+            while (Buffer[N] >= 48) {
+                int A=Buffer[N] - 48;
+                m3pi.cls();
+                m3pi.printf("LFT %d", A);
+                m3pi.right( - speed_max);
+                m3pi.left(speed_max);
+                wait(((speed_mod * 0.28)/9)*A);
+                m3pi.stop();
+                N++;
+            }
+        } else if (Buffer[N] == 'S' || Buffer[N] == 's') {
+            m3pi.cls();
+            m3pi.printf("STOP");
+            m3pi.stop();
+            FIN();
+            N++;
+            //if there is a * then we have reached the end of what is in Buffer
+        } else if (Buffer[N] == '*') {
+            m3pi.stop();
+            m3pi.cls();
+            m3pi.printf("FIN!");
+            FIN();
+            //if there is a character that is not listed above, it is probebly an error
+        } else {
+            m3pi.stop();
+            m3pi.cls();
+            m3pi.printf("  ERR  ");
+            ERR();
+        }
+    }
+}
+
+int main() {
+    opening();
+    grabbing();
+    variables();
+    speed_mod = speed_max;
+    wait(2.0);
+    recognition();
+}
\ No newline at end of file
diff -r 000000000000 -r 33bfb6a726ba mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Fri Jul 08 12:12:56 2011 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/63bcd7ba4912