KalimanMer
diff --git a/‎cpp_utils/Doxyfile
Lines changed: 2 additions & 1 deletion b/‎cpp_utils/Doxyfile
Lines changed: 2 additions & 1 deletion
diff --git a/‎cpp_utils/FATFS_VFS.cpp
Lines changed: 9 additions & 0 deletions b/‎cpp_utils/FATFS_VFS.cpp
Lines changed: 9 additions & 0 deletions
diff --git a/‎cpp_utils/FATFS_VFS.h
Lines changed: 13 additions & 0 deletions b/‎cpp_utils/FATFS_VFS.h
Lines changed: 13 additions & 0 deletions
diff --git a/‎cpp_utils/File.cpp
Lines changed: 138 additions & 0 deletions b/‎cpp_utils/File.cpp
Lines changed: 138 additions & 0 deletions
diff --git a/‎cpp_utils/File.h
Lines changed: 33 additions & 0 deletions b/‎cpp_utils/File.h
Lines changed: 33 additions & 0 deletions
diff --git a/‎cpp_utils/FileSystem.cpp
Lines changed: 87 additions & 5 deletions b/‎cpp_utils/FileSystem.cpp
Lines changed: 87 additions & 5 deletions
diff --git a/‎cpp_utils/FileSystem.h
Lines changed: 5 additions & 0 deletions b/‎cpp_utils/FileSystem.h
Lines changed: 5 additions & 0 deletions
@@ -890,7 +890,8 @@ EXCLUDE_PATTERNS       =
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories use the pattern */test/*
 
-EXCLUDE_SYMBOLS        = 
+EXCLUDE_SYMBOLS        = profile_inst \
+                         data_packet
 
 # The EXAMPLE_PATH tag can be used to specify one or more files or directories
 # that contain example code fragments that are included (see the \include
 
@@ -13,6 +13,15 @@ extern "C" {
 
 /**
  * @brief Constructor.
+ *
+ * In ESP32, every file system has a mount point.  If a file access is attempted south of that
+ * mount point, then the corresponding file system will be used.  The `mountPath` parameter defines
+ * the mount point for this instance of the FATFS file system.
+ * In order to save the files for subsequent retrieval, the file data has to be written to flash memory.
+ * A partition table provides a map or layout of the flash memory by defining named partitions.  The
+ * `partitionName` parameter defines the name of the partition used to provide the underlying storage
+ * for this instance of the FATFS file system.
+ *
  * @param [in] mountPath The path in the VFS where the FAT file system should be mounted.
  * @param [in] partitionName The name of the partition used to store the FAT file system.
  */
 
@@ -13,6 +13,19 @@ extern "C" {
 }
 /**
  * @brief Provide access to the FAT file system on %SPI flash.
+ * The FATFS_VFS file system needs a partition definition.  This is a map of flash memory that
+ * specified an array into which the files should be saved and loaded.  A partition is a named
+ * entity and the name we choose in the partition definition should be named in the constructor.
+ *
+ * A partition configuration file can be described in the `make menuconfig` settings.  For example:
+ * ~~~~
+ * nvs,      data, nvs,     0x9000,  0x6000,
+ * phy_init, data, phy,     0xf000,  0x1000,
+ * factory,  app,  factory, 0x10000, 1M,
+ * storage,  data, fat,     ,        1M,
+ * ~~~~
+ *
+ * The recommended file name for the partition description is `partitions.csv`
  *
  * A typical example would be:
  *
 
@@ -0,0 +1,138 @@
+/*
+ * File.cpp
+ *
+ *  Created on: Jun 1, 2017
+ *      Author: kolban
+ */
+
+#include "File.h"
+#include <sys/stat.h>
+#include <esp_log.h>
+#include <string>
+#include <stdlib.h>
+#include <stdio.h>
+#include <GeneralUtils.h>
+
+static const char tag[] = "File";
+/**
+ * @brief Construct a file.
+ * @param [in] name The name of the file.
+ * @param [in] type The type of the file (DT_REGULAR, DT_DIRECTORY or DT_UNKNOWN).
+ */
+File::File(std::string name, uint8_t type) {
+	m_name = name;
+	m_type = type;
+}
+
+File::~File() {
+}
+
+
+/**
+ * @brief Retrieve the content of the file.
+ * @param [in] base64Encode Should we base64 encode the content?
+ * @return The content of the file.
+ */
+std::string File::getContent(bool base64Encode) {
+
F438
	uint32_t size = length();
+	ESP_LOGD(tag, "File:: getContent(), name=%s, length=%d", m_name.c_str(), size);
+	if (size == 0) {
+		return "";
+	}
+	uint8_t *pData = (uint8_t *)malloc(size);
+	if (pData == nullptr) {
+		ESP_LOGE(tag, "getContent: Failed to allocate memory");
+		return "";
+	}
+	FILE *file = fopen(m_name.c_str(), "r");
+	fread(pData, size, 1, file);
+	fclose(file);
+	std::string ret((char *)pData, size);
+	free(pData);
+	if (base64Encode) {
+		std::string encoded;
+		GeneralUtils::base64Decode(ret, &encoded);
+		return encoded;
+	}
+	return ret;
+} // getContent
+
+
+/**
+ * @brief Retrieve the content of the file.
+ * @param [in] offset The file offset to read from.
+ * @param [in] readSize The number of bytes to read.
+ * @return The content of the file.
+ */
+std::string File::getContent(uint32_t offset, uint32_t readSize) {
+	uint32_t fileSize = length();
+	ESP_LOGD(tag, "File:: getContent(), name=%s, fileSize=%d, offset=%d, readSize=%d",
+		m_name.c_str(), fileSize, offset, readSize);
+	if (fileSize == 0 || offset > fileSize) {
+		return "";
+	}
+	uint8_t *pData = (uint8_t *)malloc(readSize);
+	if (pData == nullptr) {
+		ESP_LOGE(tag, "getContent: Failed to allocate memory");
+		return "";
+	}
+	FILE *file = fopen(m_name.c_str(), "r");
+	fseek(file, offset, SEEK_SET);
+	size_t bytesRead = fread(pData, 1, readSize, file);
+	fclose(file);
+	std::string ret((char *)pData, bytesRead);
+	free(pData);
+	return ret;
+}
+
+
+/**
+ * @brief Get the name of the file.
+ * @return The name of the file.
+ */
+std::string File::getName() {
+	return m_name;
+} // getName
+
+
+/**
+ * @brief Get the type of the file.
+ * The type of a file can be DT_REGULAR, DT_DIRECTORY or DT_UNKNOWN.
+ * @return The type of the file.
+ */
+uint8_t File::getType() {
+	return m_type;
+} // getName
+
+
+/**
+ * @brief Get the length of the file in bytes.
+ * @return The length of the file in bytes.
+ */
+uint32_t File::length() {
+	struct stat buf;
+	int rc = stat(m_name.c_str(), &buf);
+	if (rc != 0) {
+		return 0;
+	}
+	return buf.st_size;
+} // length
+
+
+/**
+ * @brief Determine if the type of the file is a directory.
+ * @return True if the file is a directory.
+ */
+bool File::isDirectory() {
+	struct stat buf;
+	int rc = stat(m_name.c_str(), &buf);
+	if (rc != 0) {
+		return false;
+	}
+	if (S_ISDIR(buf.st_mode)) {
+		return true;
+	}
+	return false;
+} // isDirectory
+
+
@@ -0,0 +1,33 @@
+/*
+ * File.h
+ *
+ *  Created on: Jun 1, 2017
+ *      Author: kolban
+ */
+
+#ifndef COMPONENTS_CPP_UTILS_FILE_H_
+#define COMPONENTS_CPP_UTILS_FILE_H_
+#include <string>
+#include <dirent.h>
+
+/**
+ * @brief A logical representation of a file.
+ */
+class File {
+public:
+	File(std::string name, uint8_t type = DT_UNKNOWN);
+	virtual ~File();
+
+	std::string getContent(bool base64Encode=false);
+	std::string getContent(uint32_t offset, uint32_t size);
+	std::string getName();
+	uint8_t getType();
+	bool isDirectory();
+	uint32_t length();
+
+private:
+	std::string m_name;
+	uint8_t m_type;
+};
+
+#endif /* COMPONENTS_CPP_UTILS_FILE_H_ */
@@ -4,22 +4,25 @@
  *  Created on: May 20, 2017
  *      Author: kolban
  */
+#include <iostream>
+#include <sstream>
 #include <string>
-#include <esp_log.h>
+
 #include <dirent.h>
 #include <errno.h>
 #include <sys/stat.h>
+#include <unistd.h>
+
+#include <esp_log.h>
+
 #include "FileSystem.h"
 
 static char tag[] = "FileSystem";
 
 FileSystem::FileSystem() {
-	// TODO Auto-generated constructor stub
-
 }
 
 FileSystem::~FileSystem() {
-	// TODO Auto-generated destructor stub
 }
 
 
@@ -54,10 +57,89 @@ void FileSystem::dumpDirectory(std::string path) {
 	::closedir(pDir);
 } // dumpDirectory
 
+
+/**
+ * @brief Get the contents of a directory.
+ * @param [in] path The path to the directory.
+ * @return A vector of Files in the directory.
+ */
+std::vector<File> FileSystem::getDirectoryContents(std::string path) {
+	std::vector<File> ret;
+	DIR *pDir = ::opendir(path.c_str());
+	if (pDir == nullptr) {
+		ESP_LOGE(tag, "getDirectoryContents:: Unable to open directory: %s [errno=%d]", path.c_str(), errno);
+		return ret;
+	}
+	struct dirent *pDirent;
+	ESP_LOGD(tag, "Directory dump of %s", path.c_str());
+	while((pDirent = readdir(pDir)) != nullptr) {
+		File file(std::string(pDirent->d_name), pDirent->d_type);
+		ret.push_back(file);
+	}
+	::closedir(pDir);
+	return ret;
+} // getDirectoryContents
+
+
+/**
+ * @brief Create a directory
+ * @param [in] path The directory to create.
+ * @return N/A.
+ */
 int FileSystem::mkdir(std::string path) {
 	int rc = ::mkdir(path.c_str(), 0);
 	if (rc != 0) {
 		ESP_LOGE(tag, "mkdir: errno=%d", errno);
+		rc = errno;
 	}
 	return rc;
-}
+} // mkdir
+
+
+/**
+ * @brief Return the constituent parts of the path.
+ * If we imagine a path as composed of parts separated by slashes, then this function
+ * returns a vector composed of the parts.  For example:
+ *
+ * ```
+ * /x/y/z
+ * ```
+ * will break out to:
+ *
+ * ```
+ * path[0] = ""
+ * path[1] = "x"
+ * path[2] = "y"
+ * path[3] = "z"
+ * ```
+ *
+ * @return A vector of the constituent parts of the path.
+ */
+std::vector<std::string> FileSystem::pathSplit(std::string path) {
+	std::istringstream stream(path);
+	std::vector<std::string> ret;
+	std::string pathPart;
+	while(std::getline(stream, pathPart, '/')) {
+		ret.push_back(pathPart);
+	}
+	// Debug
+	for (int i=0; i<ret.size(); i++) {
+		ESP_LOGD(tag, "part[%d]: %s", i, ret[i].c_str());
+	}
+	return ret;
+} // pathSplit
+
+
+/**
+ * @brief Remove a file from the file system.
+ * @param [in] path The path to the file to be removed.
+ * @return The return code of the underlying call.
+ */
+int FileSystem::remove(std::string path) {
+	int rc = ::unlink(path.c_str());
+	if (rc != 0) {
+		ESP_LOGE(tag, "unlink: errno=%d", errno);
+		rc = errno;
+	}
+	return rc;
+} // remove
@@ -8,15 +8,20 @@
 #ifndef COMPONENTS_CPP_UTILS_FILESYSTEM_H_
 #define COMPONENTS_CPP_UTILS_FILESYSTEM_H_
 #include <string>
+#include <vector>
+#include <File.h>
 /**
  * @brief File system utilities.
  */
 class FileSystem {
 public:
 	FileSystem();
 	virtual ~FileSystem();
+	static std::vector<File> getDirectoryContents(std:: string path);
 	static void dumpDirectory(std::string path);
 	static int mkdir(std::string path);
+	static std::vector<std::string> pathSplit(std::string path);
+	static int remove(std::string path);
 };
 
 #endif /* COMPONENTS_CPP_UTILS_FILESYSTEM_H_ */