GeoFatFsStorage.hpp

/*
 * GmTivaSDStorage.hpp
 *
 *  Created on: May 10, 2016
 *      Author: rcram
 */
 
#ifndef GM_FATFS_STORAGE_HPP_
#define GM_FATFS_STORAGE_HPP_
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <GmFatFs/ff.h>
#include "GmStorage.hpp"
 
 
 
/********************************************************************/
/* 1024 and 512 work fine with SD cards, but not with
   USB storage, so 256 it is.  It could be possible to switch conditionally
   during execution, but it's not clear for now why that would be necessary;
   th4 256-bite issue is not currently a limit.
   Some discussion about this on the TI forums; the USB standard may
   limit block transfers to 256 bytes for low speed.
   (5/2018) RHC */
/********************************************************************/
#define GEO_MAX_FATFS_BLOCK_SIZE 1024
#define GEO_MIN_FATFS_BLOCK_SIZE 256
#define GEO_SD_FATFS_BLOCK_SIZE 1024
#define GEO_USB_FATFS_BLOCK_SIZE 512
 
namespace Geometrics
{
 
   class GeoFatFsStorage : public GmStorage
   {
      public:
         GeoFatFsStorage  ();
         ~GeoFatFsStorage ();
         virtual int   Open               (const char*      szName,
                                           const char*      szReadWrite);
         int           Seek               (UInt32          uiLocation);
         bool          EndOfFile           () { return FALSE; };
         int           Verify              (int             iMarker);
         int           RunTestSuite        ();
         virtual int   Shutdown            () = 0;
         int           Flush               ();
         int           FileSize            (const char     *strFileName,
                                            UInt32*         uiSize);
         int           ReadStr             (char           *strBuffer,
                                            int             iLength);
         int           ReadRaw             (int             dummy,
                                            char*           pcBuffer,
                                            UInt32          uiLength,
                                            UInt32          *uiActualLengthRead);
         virtual int           Close               (int             iFileIndex);
         virtual int           WriteData           (const char*     pcData,
                                            unsigned int    iDataSize,
                                            UInt32          ui32Topic);
 
 
 
         virtual const char *GetDrive      () = 0;
         virtual int   IsFileStorage    () { return TRUE; };
         virtual int   IsDataStorage    () { return TRUE; };
 
 
 
 
      protected: // TODO RHC should not be.
         bool               m_hasOsFile;
         FIL                m_fOsFile;
      protected:
         char               m_caCurrentOpenFileName   [50];
         int                m_iCurrentOpenFile,
                            m_iBufferCount;
 
         bool               m_bReadOnly;
         int                m_iFatFsBlockSize;
         char               m_caBlockBuffer[GEO_MAX_FATFS_BLOCK_SIZE];
         virtual int        GetFatFsBlockSize () = 0;
 
      public:
         static int s_iLastError;
 
         class IFatFsStorageFactory
         {
         public:
            virtual GeoFatFsStorage *MakeNewStorage () = 0;
         };
 
         static GeoFatFsStorage::IFatFsStorageFactory  *s_pStorageFactoryPrimary,
                                                       *s_pStorageFactoryZero,
                                                       *s_pStorageFactoryOne;
 
         static GeoFatFsStorage::IFatFsStorageFactory *GetFactory (const char whichStorage = 0);
         static void SetFactory (const char whichStorage, GeoFatFsStorage::IFatFsStorageFactory *pFactory);
   };
}
 
 
 
#endif /* GMTIVASDSTORAGE_HPP_ */