Permalink
Browse files

initial commit (fork of Libraries_for_Music_Shield_20120619)

  • Loading branch information...
0 parents commit 5e8f04fde40a36b257f52978927013850c3a7278 @nkrkv nkrkv committed Jul 12, 2012
Showing with 6,280 additions and 0 deletions.
  1. +990 −0 Fat16/Fat16.cpp
  2. +378 −0 Fat16/Fat16.h
  3. +38 −0 Fat16/Fat16Config.h
  4. +208 −0 Fat16/Fat16mainpage.h
  5. +74 −0 Fat16/Fat16util.h
  6. +418 −0 Fat16/FatStructs.h
  7. +279 −0 Fat16/SdCard.cpp
  8. +192 −0 Fat16/SdCard.h
  9. +117 −0 Fat16/SdInfo.h
  10. +122 −0 Fat16/examples/fat16AnalogLogger/fat16AnalogLogger.pde
  11. +328 −0 Fat16/examples/fat16GPSLogger_v3/fat16GPSLogger_v3.pde
  12. +374 −0 Fat16/examples/fat16GPS_CSVSensorLogger/fat16GPS_CSVSensorLogger.pde
  13. +67 −0 Fat16/examples/fat16append/fat16append.pde
  14. +90 −0 Fat16/examples/fat16bench/fat16bench.pde
  15. +74 −0 Fat16/examples/fat16copy/fat16copy.pde
  16. +239 −0 Fat16/examples/fat16info/fat16info.pde
  17. +41 −0 Fat16/examples/fat16ls/fat16ls.pde
  18. +65 −0 Fat16/examples/fat16print/fat16print.pde
  19. +61 −0 Fat16/examples/fat16read/fat16read.pde
  20. +50 −0 Fat16/examples/fat16remove/fat16remove.pde
  21. +64 −0 Fat16/examples/fat16rewrite/fat16rewrite.pde
  22. +85 −0 Fat16/examples/fat16tail/fat16tail.pde
  23. +174 −0 Fat16/examples/fat16timestamp/fat16timestamp.pde
  24. +58 −0 Fat16/examples/fat16truncate/fat16truncate.pde
  25. +80 −0 Fat16/examples/fat16write/fat16write.pde
  26. +386 −0 MusicPlayer_v1_7/MusicPlayer.cpp
  27. +133 −0 MusicPlayer_v1_7/MusicPlayer.h
  28. +17 −0 MusicPlayer_v1_7/README.txt
  29. +46 −0 MusicPlayer_v1_7/examples/addToList/addToList.ino
  30. +53 −0 MusicPlayer_v1_7/examples/analogInputControl/analogInputControl.ino
  31. +45 −0 MusicPlayer_v1_7/examples/creatList/creatList.ino
  32. +64 −0 MusicPlayer_v1_7/examples/digitalInputControl/digitalInputControl.ino
  33. +50 −0 MusicPlayer_v1_7/examples/extIntControl/extIntControl.ino
  34. +45 −0 MusicPlayer_v1_7/examples/keyDisable/keyDisable.ino
  35. +42 −0 MusicPlayer_v1_7/examples/playWithName/playWithName.ino
  36. +189 −0 MusicPlayer_v1_7/newSDlib.cpp
  37. +51 −0 MusicPlayer_v1_7/newSDlib.h
  38. +79 −0 MusicPlayer_v1_7/pins_config.h
  39. +143 −0 MusicPlayer_v1_7/vs10xx.cpp
  40. +90 −0 MusicPlayer_v1_7/vs10xx.h
  41. +61 −0 NewSPI/NewSPI.cpp
  42. +75 −0 NewSPI/NewSPI.h
  43. +36 −0 NewSPI/keywords.txt
  44. +9 −0 software installation.txt

Large diffs are not rendered by default.

Oops, something went wrong.
@@ -0,0 +1,378 @@
+/* Arduino FAT16 Library
+ * Copyright (C) 2008 by William Greiman
+ *
+ * This file is part of the Arduino FAT16 Library
+ *
+ * This Library is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This Library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with the Arduino Fat16 Library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+#ifndef Fat16_h
+#define Fat16_h
+/**
+ * \file
+ * Fat16 class
+ */
+#include <string.h>
+#include <avr/pgmspace.h>
+#include <Print.h>
+#include <SdCard.h>
+#include <FatStructs.h>
+#include <Fat16Config.h>
+//------------------------------------------------------------------------------
+/** Fat16 version YYYYMMDD */
+#define FAT16_VERSION 20111205
+//------------------------------------------------------------------------------
+// flags for ls()
+/** ls() flag to print modify date */
+uint8_t const LS_DATE = 1;
+/** ls() flag to print file size */
+uint8_t const LS_SIZE = 2;
+
+// use the gnu style oflags
+/** open for reading */
+uint8_t const O_READ = 0X01;
+/** same as O_READ */
+uint8_t const O_RDONLY = O_READ;
+/** open for write */
+uint8_t const O_WRITE = 0X02;
+/** same as O_WRITE */
+uint8_t const O_WRONLY = O_WRITE;
+/** open for reading and writing */
+uint8_t const O_RDWR = O_READ | O_WRITE;
+/** mask for access modes */
+uint8_t const O_ACCMODE = O_READ | O_WRITE;
+/** The file offset shall be set to the end of the file prior to each write. */
+uint8_t const O_APPEND = 0X04;
+/** synchronous writes - call sync() after each write */
+uint8_t const O_SYNC = 0X08;
+/** create the file if nonexistent */
+uint8_t const O_CREAT = 0X10;
+/** If O_CREAT and O_EXCL are set, open() shall fail if the file exists */
+uint8_t const O_EXCL = 0X20;
+/** truncate the file to zero length */
+uint8_t const O_TRUNC = 0X40;
+
+// flags for timestamp
+/** set the file's last access date */
+uint8_t const T_ACCESS = 1;
+/** set the file's creation date and time */
+uint8_t const T_CREATE = 2;
+/** Set the file's write date and time */
+uint8_t const T_WRITE = 4;
+
+/** date field for FAT directory entry */
+static inline uint16_t FAT_DATE(uint16_t year, uint8_t month, uint8_t day) {
+ return (year - 1980) << 9 | month << 5 | day;
+}
+/** year part of FAT directory date field */
+static inline uint16_t FAT_YEAR(uint16_t fatDate) {
+ return 1980 + (fatDate >> 9);
+}
+/** month part of FAT directory date field */
+static inline uint8_t FAT_MONTH(uint16_t fatDate) {
+ return (fatDate >> 5) & 0XF;
+}
+/** day part of FAT directory date field */
+static inline uint8_t FAT_DAY(uint16_t fatDate) {
+ return fatDate & 0X1F;
+}
+/** time field for FAT directory entry */
+static inline uint16_t FAT_TIME(uint8_t hour, uint8_t minute, uint8_t second) {
+ return hour << 11 | minute << 5 | second >> 1;
+}
+/** hour part of FAT directory time field */
+static inline uint8_t FAT_HOUR(uint16_t fatTime) {
+ return fatTime >> 11;
+}
+/** minute part of FAT directory time field */
+static inline uint8_t FAT_MINUTE(uint16_t fatTime) {
+ return(fatTime >> 5) & 0X3F;
+}
+/** second part of FAT directory time field */
+static inline uint8_t FAT_SECOND(uint16_t fatTime) {
+ return 2*(fatTime & 0X1F);
+}
+/** Default date for file timestamps is 1 Jan 2000 */
+uint16_t const FAT_DEFAULT_DATE = ((2000 - 1980) << 9) | (1 << 5) | 1;
+/** Default time for file timestamp is 1 am */
+uint16_t const FAT_DEFAULT_TIME = (1 << 11);
+//------------------------------------------------------------------------------
+/**
+ * \typedef fat_t
+ *
+ * \brief Type for FAT16 entry
+ */
+typedef uint16_t fat_t;
+/**
+ * \union cache16_t
+ *
+ * \brief Cache buffer data type
+ *
+ */
+union cache16_t {
+ /** Used to access cached file data blocks. */
+ uint8_t data[512];
+ /** Used to access cached FAT entries. */
+ fat_t fat[256];
+ /** Used to access cached directory entries. */
+ dir_t dir[16];
+ /** Used to access a cached Master Boot Record. */
+ mbr_t mbr;
+ /** Used to access to a cached FAT16 boot sector. */
+ fbs_t fbs;
+};
+//------------------------------------------------------------------------------
+/** \class Fat16
+ * \brief Fat16 implements a minimal Arduino FAT16 Library
+ *
+ * Fat16 does not support subdirectories or long file names.
+ */
+class Fat16 : public Print {
+ public:
+ /*
+ * Public functions
+ */
+ /** create with file closed */
+ Fat16(void) : flags_(0) {}
+ /** \return The current cluster number. */
+ fat_t curCluster(void) const {return curCluster_;}
+ uint8_t close(void);
+ /** \return The count of clusters in the FAT16 volume. */
+ static fat_t clusterCount(void) {return clusterCount_;}
+ /** \return The number of 512 byte blocks in a cluster */
+ static uint8_t clusterSize(void) {return blocksPerCluster_;}
+ /** \return The current file position. */
+ uint32_t curPosition(void) const {return curPosition_;}
+ /**
+ * Set the date/time callback function
+ *
+ * \param[in] dateTime The user's callback function. The callback
+ * function is of the form:
+ *
+ * \code
+ * void dateTime(uint16_t* date, uint16_t* time) {
+ * uint16_t year;
+ * uint8_t month, day, hour, minute, second;
+ *
+ * // User gets date and time from GPS or real-time clock here
+ *
+ * // return date using FAT_DATE macro to format fields
+ * *date = FAT_DATE(year, month, day);
+ *
+ * // return time using FAT_TIME macro to format fields
+ * *time = FAT_TIME(hour, minute, second);
+ * }
+ * \endcode
+ *
+ * Sets the function that is called when a file is created or when
+ * a file's directory entry is modified by sync(). All timestamps,
+ * access, creation, and modify, are set when a file is created.
+ * sync() maintains the last access date and last modify date/time.
+ *
+ * See the timestamp() function.
+ */
+ static void dateTimeCallback(
+ void (*dateTime)(uint16_t* date, uint16_t* time)) {
+ dateTime_ = dateTime;
+ }
+ /**
+ * Cancel the date/time callback function.
+ */
+ static void dateTimeCallbackCancel(void) {dateTime_ = NULL;}
+ uint8_t dirEntry(dir_t* dir);
+
+ /** \return The file's size in bytes. */
+ uint32_t fileSize(void) const {return fileSize_;}
+ static uint8_t init(SdCard* dev, uint8_t part);
+ /**
+ * Initialize a FAT16 volume.
+ *
+ * First try partition 1 then try super floppy format.
+ *
+ * \param[in] dev The SdCard where the volume is located.
+ *
+ * \return The value one, true, is returned for success and
+ * the value zero, false, is returned for failure. reasons for
+ * failure include not finding a valid FAT16 file system, a call
+ * to init() after a volume has been successful initialized or
+ * an I/O error.
+ *
+ */
+ static uint8_t init(SdCard* dev) {
+ return init(dev, 1) ? true : init(dev, 0);
+ }
+ /**
+ * Checks the file's open/closed status for this instance of Fat16.
+ * \return The value true if a file is open otherwise false;
+ */
+ uint8_t isOpen(void) const {return (flags_ & O_ACCMODE) != 0;}
+ static void ls(uint8_t flags = 0);
+ uint8_t open(const char* fileName, uint8_t oflag);
+ uint8_t open(uint16_t entry, uint8_t oflag);
+ static void printDirName(const dir_t& dir, uint8_t width);
+ static void printFatDate(uint16_t fatDate);
+ static void printFatTime(uint16_t fatTime);
+ static void printTwoDigits(uint8_t v);
+ int16_t read(void);
+ int16_t read(void* buf, uint16_t nbyte);
+ static uint8_t readDir(dir_t* dir, uint16_t* index,
+ uint8_t skip = (DIR_ATT_VOLUME_ID | DIR_ATT_DIRECTORY));
+
+ uint8_t remove(void);
+ static uint8_t remove(const char* fileName);
+ /** Sets the file's current position to zero. */
+ void rewind(void) {curPosition_ = curCluster_ = 0;}
+ /** \return The number of entries in the root directory. */
+ static uint16_t rootDirEntryCount(void) {return rootDirEntryCount_;}
+ /** Seek to current position plus \a pos bytes. See Fat16::seekSet(). */
+ uint8_t seekCur(uint32_t pos) {return seekSet(curPosition_ + pos);}
+ /** Seek to end of file. See Fat16::seekSet(). */
+ uint8_t seekEnd(void) {return seekSet(fileSize_);}
+ uint8_t seekSet(uint32_t pos);
+ uint8_t sync(void);
+ uint8_t timestamp(uint8_t flag, uint16_t year, uint8_t month, uint8_t day,
+ uint8_t hour, uint8_t minute, uint8_t second);
+ uint8_t truncate(uint32_t size);
+ /** Fat16::writeError is set to true if an error occurs during a write().
+ * Set Fat16::writeError to false before calling print() and/or write() and check
+ * for true after calls to write() and/or print().
+ */
+ bool writeError;
+ int16_t write(const void *buf, uint16_t nbyte);
+#if ARDUINO < 100
+ void write(uint8_t b);
+ void write(const char* str);
+#else // ARDUINO < 100
+ size_t write(uint8_t b);
+ int16_t write(const char* str);
+#endif // ARDUINO < 100
+ void write_P(PGM_P str);
+ void writeln_P(PGM_P str);
+//------------------------------------------------------------------------------
+#if FAT16_DEBUG_SUPPORT
+ /** For debug only. Do not use in applications. */
+ static cache16_t* dbgBufAdd(void) {return &cacheBuffer_;}
+ /** For debug only. Do not use in applications. */
+ static void dbgSetDev(SdCard* dev) {rawDev_ = dev;}
+ /** For debug only. Do not use in applications. */
+ static uint8_t* dbgCacheBlock(uint32_t blockNumber) {
+ return cacheRawBlock(blockNumber) ? cacheBuffer_.data : 0; }
+ /** For debug only. Do not use in applications. */
+ static dir_t* dbgCacheDir(uint16_t index) {
+ return cacheDirEntry(index);}
+#endif // FAT16_DEBUG_SUPPORT
+//------------------------------------------------------------------------------
+#if ALLOW_DEPRECATED_FUNCTIONS
+// Deprecated functions - suppress cpplint messages with NOLINT comment
+ public:
+ /**
+ * Deprecated - Use:
+ * static void Fat16::dateTimeCallback(
+ * void (*dateTime)(uint16_t* date, uint16_t* time));
+ */
+ static void dateTimeCallback(
+ void (*dateTime)(uint16_t& date, uint16_t& time)) { // NOLINT
+ oldDateTime_ = dateTime;
+ dateTime_ = dateTime ? oldToNew : 0;
+ }
+ /** Deprecated - Use: uint8_t Fat16::dirEntry(dir_t* dir); */
+ uint8_t dirEntry(dir_t& dir) { // NOLINT
+ return dirEntry(&dir);
+ }
+ /** Deprecated - Use: static uint8_t Fat16::init(SdCard *dev); */
+ static uint8_t init(SdCard& dev) {return init(&dev);} // NOLINT
+
+ /** Deprecated - Use: static uint8_t Fat16::init(SdCard *dev, uint8_t part) */
+ static uint8_t init(SdCard& dev, uint8_t part) { // NOLINT
+ return init(&dev, part);
+ }
+ /**
+ * Deprecated - Use:
+ * uint8_t Fat16::readDir(dir_t* dir, uint16_t* index, uint8_t skip);
+ */
+ static uint8_t readDir(dir_t& dir, uint16_t& index, // NOLINT
+ uint8_t skip = (DIR_ATT_VOLUME_ID | DIR_ATT_DIRECTORY)) {
+ return readDir(&dir, &index, skip);
+ }
+//------------------------------------------------------------------------------
+ private:
+ static void (*oldDateTime_)(uint16_t& date, uint16_t& time); // NOLINT
+ static void oldToNew(uint16_t *date, uint16_t *time) {
+ uint16_t d;
+ uint16_t t;
+ oldDateTime_(d, t);
+ *date = d;
+ *time = t;
+ }
+#endif // ALLOW_DEPRECATED_FUNCTIONS
+//------------------------------------------------------------------------------
+ private:
+ // Volume info
+ static uint8_t volumeInitialized_; // true if volume has been initialized
+ static uint8_t fatCount_; // number of FATs
+ static uint8_t blocksPerCluster_; // must be power of 2
+ static uint16_t rootDirEntryCount_; // should be 512 for FAT16
+ static fat_t blocksPerFat_; // number of blocks in one FAT
+ static fat_t clusterCount_; // total clusters in volume
+ static uint32_t fatStartBlock_; // start of first FAT
+ static uint32_t rootDirStartBlock_; // start of root dir
+ static uint32_t dataStartBlock_; // start of data clusters
+
+ // block cache
+ static uint8_t const CACHE_FOR_READ = 0; // cache a block for read
+ static uint8_t const CACHE_FOR_WRITE = 1; // cache a block and set dirty
+ static SdCard *rawDev_; // Device
+ static cache16_t cacheBuffer_; // 512 byte cache for raw blocks
+ static uint32_t cacheBlockNumber_; // Logical number of block in the cache
+ static uint8_t cacheDirty_; // cacheFlush() will write block if true
+ static uint32_t cacheMirrorBlock_; // mirror block for second FAT
+
+ // callback function for date/time
+ static void (*dateTime_)(uint16_t* date, uint16_t* time);
+
+ // define fields in flags_
+ static uint8_t const F_OFLAG = O_ACCMODE | O_APPEND | O_SYNC;
+ static uint8_t const F_FILE_DIR_DIRTY = 0X80; // require sync directory entry
+
+ uint8_t flags_; // see above for bit definitions
+ int16_t dirEntryIndex_; // index of directory entry for open file
+ fat_t firstCluster_; // first cluster of file
+ uint32_t fileSize_; // fileSize
+ fat_t curCluster_; // current cluster
+ uint32_t curPosition_; // current byte offset
+
+ // private functions for cache
+ static uint8_t blockOfCluster(uint32_t position) {
+ // depends on blocks per cluster being power of two
+ return (position >> 9) & (blocksPerCluster_ - 1);
+ }
+ static uint16_t cacheDataOffset(uint32_t position) {return position & 0X1FF;}
+ static dir_t* cacheDirEntry(uint16_t index, uint8_t action = 0);
+ static uint8_t cacheRawBlock(uint32_t blockNumber, uint8_t action = 0);
+ static uint8_t cacheFlush(void);
+ static void cacheSetDirty(void) {cacheDirty_ |= CACHE_FOR_WRITE;}
+ static uint32_t dataBlockLba(fat_t cluster, uint8_t blockOfCluster) {
+ return dataStartBlock_ + (uint32_t)(cluster - 2) * blocksPerCluster_
+ + blockOfCluster;
+ }
+ static uint8_t fatGet(fat_t cluster, fat_t* value);
+ static uint8_t fatPut(fat_t cluster, fat_t value);
+ // end of chain test
+ static uint8_t isEOC(fat_t cluster) {return cluster >= 0XFFF8;}
+ // allocate a cluster to a file
+ uint8_t addCluster(void);
+ // free a cluster chain
+ uint8_t freeChain(fat_t cluster);
+};
+#endif // Fat16_h
Oops, something went wrong.

0 comments on commit 5e8f04f

Please sign in to comment.