[SD] Handle sd cards of varying capacities!

Author: brentru

.vscode/settings.json

@@ -1,7 +1,8 @@
 {
     "files.associations": {
         "limits": "c",
-        "type_traits": "c"
+        "type_traits": "c",
+        "vector": "cpp"
     },
     "C_Cpp.dimInactiveRegions": false,
     "dotnet.defaultSolution": "disable",

src/components/analogIO/controller.cpp

@@ -271,7 +271,10 @@ void AnalogIOController::update() {
       // Read the pin's raw value
       uint16_t value = _analogio_hardware->GetPinValue(pin.name);
       // Encode and publish it to the broker
-      EncodePublishPinValue(pin.name, value);
+      if (!EncodePublishPinValue(pin.name, value)) {
+        WS_DEBUG_PRINTLN("[analogio] ERROR: Unable to record pin value!");
+        continue;
+      }
       pin.prv_period = cur_time; // Reset the pin's period
     } else if (pin.read_mode ==
                wippersnapper_sensor_SensorType_SENSOR_TYPE_VOLTAGE) {

src/components/digitalIO/controller.cpp

@@ -364,8 +364,10 @@ void DigitalIOController::Update() {
         continue; // No change in pin value detected, move onto the next pin
 
       // Encode and publish the event
-      if (!EncodePublishPinEvent(pin.pin_name, pin.pin_value))
-        continue; // Unable to encode and publish event, move onto the next pin
+      if (!EncodePublishPinEvent(pin.pin_name, pin.pin_value)) {
+        WS_DEBUG_PRINTLN("[digitalio] ERROR: Unable to record pin value!");
+        continue;
+      }
     } else if (
         pin.sample_mode ==
         wippersnapper_digitalio_DigitalIOSampleMode_DIGITAL_IO_SAMPLE_MODE_TIMER) {
@@ -374,8 +376,10 @@ void DigitalIOController::Update() {
         continue; // Timer has not expired yet, move onto the next pin
 
       // Encode and publish the event
-      if (!EncodePublishPinEvent(pin.pin_name, pin.pin_value))
-        continue; // Failed to encode and publish event, move onto the next pin
+      if (!EncodePublishPinEvent(pin.pin_name, pin.pin_value)) {
+        WS_DEBUG_PRINTLN("[digitalio] ERROR: Unable to record pin value!");
+        continue;
+      }
     } else {
       // Invalid sample mode
       WS_DEBUG_PRINT("[digitalio] ERROR: DigitalIO Pin ");

src/provisioning/sdcard/ws_sdcard.cpp

@@ -22,7 +22,7 @@
 ws_sdcard::ws_sdcard() {
   is_mode_offline = false;
   _use_test_data = false;
-  _sz_log_file = 0;
+  _sz_cur_log_file = 0;
 }
 
 /**************************************************************************/
@@ -45,16 +45,36 @@ ws_sdcard::~ws_sdcard() {
 */
 /**************************************************************************/
 bool ws_sdcard::InitSDCard() {
-  if (WsV2.pin_sd_cs == PIN_SD_CS_ERROR) {
-    is_mode_offline = false;
+  is_mode_offline = false;
+  csd_t csd;
+  if (WsV2.pin_sd_cs == PIN_SD_CS_ERROR)
+    return is_mode_offline;
+
+  if (!_sd.begin(WsV2.pin_sd_cs)) {
+    WS_DEBUG_PRINTLN(
+        "SD initialization failed.\nDo not reformat the card!\nIs the card "
+        "correctly inserted?\nIs there a wiring/soldering problem\n");
     return is_mode_offline;
   }
 
-  if (_sd.begin(WsV2.pin_sd_cs)) {
-    is_mode_offline = true;
-  } else {
-    is_mode_offline = false;
+  // Calculate the maximum number of log files that can be stored on the SD card
+  if (!_sd.card()->readCSD(&csd)) {
+    WS_DEBUG_PRINTLN("ERROR: Could not read sdcard information");
+    return is_mode_offline;
+  }
+  // get the complete sdcard capacity in bytes
+  _sd_capacity = (uint64_t)512 * csd.capacity();
+  // account for 3-5% fatfs overhead utilization
+  size_t sd_capacity_usable = _sd_capacity * (1 - 0.05);
+  // proportionally set sz of each log file to 10% of the SD card's usable capacity
+  _max_sz_log_file = sd_capacity_usable / 10;
+  // Regardless of sd card size, cap log files to 512MB
+  if (_max_sz_log_file > MAX_SZ_LOG_FILE) {
+    _max_sz_log_file = MAX_SZ_LOG_FILE;
   }
+  _sd_max_num_log_files = sd_capacity_usable / _max_sz_log_file;
+
+  is_mode_offline = true;
   return is_mode_offline;
 }
 
@@ -430,6 +450,12 @@ bool ws_sdcard::AddSignalMessageToSharedBuffer(
 */
 /**************************************************************************/
 bool ws_sdcard::CreateNewLogFile() {
+  if (_sd_cur_log_files >= _sd_max_num_log_files) {
+    WS_DEBUG_PRINTLN(
+        "[SD] Maximum number of log files for SD card capacity reached!");
+    return false;
+  }
+
   File32 file;
   // Generate a name for the new log file using the RTC's timestamp
   String logFilename = "log_" + String(GetTimestamp()) + ".json";
@@ -444,6 +470,7 @@ bool ws_sdcard::CreateNewLogFile() {
     return false;
   WS_DEBUG_PRINT("[SD] Created new log file on SD card: ");
   WS_DEBUG_PRINTLN(_log_filename);
+  _sd_cur_log_files++;
   return true;
 }
 
@@ -473,6 +500,14 @@ bool ws_sdcard::ValidateChecksum(JsonDocument &doc) {
 */
 /**************************************************************************/
 bool ws_sdcard::parseConfigFile() {
+  // TODO: THIS IS JUST DEBUG!
+  WS_DEBUG_PRINT("SD card capacity: ");
+  WS_DEBUG_PRINTLN(_sd_capacity);
+  WS_DEBUG_PRINT("Maximum number of log files: ");
+  WS_DEBUG_PRINTLN(_sd_max_num_log_files);
+  WS_DEBUG_PRINT("Maximum size of log file: ");
+  WS_DEBUG_PRINTLN(_max_sz_log_file);
+
   int max_json_len = 4096;
   DeserializationError error;
   JsonDocument doc;
@@ -785,12 +820,13 @@ bool ws_sdcard::LogJSONDoc(JsonDocument &doc) {
   szJson = serializeJson(doc, Serial); // TODO: Add buffering here, too?
   Serial.print("\n");                  // JSONL format specifier
 #endif
-  _sz_log_file = szJson + 2; // +2 bytes for "\n"
+  _sz_cur_log_file = szJson + 2; // +2 bytes for "\n"
 
-  if (_sz_log_file > MAX_LOG_FILE_SZ) {
-    WS_DEBUG_PRINTLN("[SD] Log file size has exceeded maximum size, creating "
-                     "a new file...");
-    CreateNewLogFile();
+  if (_sz_cur_log_file >= _max_sz_log_file) {
+    WS_DEBUG_PRINTLN("[SD] Log file has exceeded maximum size! Attempting to "
+                     "create a new file...");
+    if (!CreateNewLogFile())
+      return false;
     return false;
   }
 

src/provisioning/sdcard/ws_sdcard.h

@@ -18,11 +18,12 @@
 #include "SdFat.h"
 #include "StreamUtils.h"
 #include "Wippersnapper_V2.h"
+#include "sdios.h"
 
 #define SD_FAT_TYPE 3           ///< SdFat type (3 = SdFs)
-#define MAX_LOG_FILE_SZ 500     ///< Maximum log file size of 500 bytes
 #define PIN_SD_CS_ERROR 255     ///< Error code for invalid SD card CS pin
 #define UNKNOWN_VALUE "unknown" ///< Unknown JSON field value
+#define MAX_SZ_LOG_FILE (512 * 1024 * 1024) ///< Maximum log file size, in Bytes
 
 // forward decl.
 class Wippersnapper_V2;
@@ -78,16 +79,23 @@ class ws_sdcard {
   void BuildJSONDoc(JsonDocument &doc, uint8_t pin, bool value,
                     wippersnapper_sensor_SensorType read_type);
   bool LogJSONDoc(JsonDocument &doc);
-  bool
-  AddSignalMessageToSharedBuffer(wippersnapper_signal_BrokerToDevice &msg_signal);
-  SdFat _sd;            ///< SD object from Adafruit SDFat library
-  bool is_mode_offline; ///< True if offline mode is enabled, False otherwise
-  String _serialInput;  ///< Serial input buffer
-  const char *json_test_data;        ///< Json test data
-  const char *_log_filename;         ///< Path to the log file
-  size_t _sz_log_file;               ///< Size of the current log file, in Bytes
-  RTC_DS3231 *_rtc_ds3231 = nullptr; ///< DS3231 RTC object
-  RTC_DS1307 *_rtc_ds1307 = nullptr; ///< DS1307 RTC object
+  bool AddSignalMessageToSharedBuffer(
+      wippersnapper_signal_BrokerToDevice &msg_signal);
+
+  SdFat _sd;               ///< SD object from Adafruit SDFat library
+  size_t _sd_capacity;     ///< Capacity of the SD card, in Bytes
+  size_t _sz_cur_log_file; ///< Size of the current log file, in Bytes
+  size_t _max_sz_log_file; ///< Calculated maximum size of a log file, in Bytes
+  int _sd_max_num_log_files; ///< Maximum number of log files that can fit on
+                             ///< the SD card
+  int _sd_cur_log_files; ///< Current number of log files that can fit on the SD
+                         ///< card
+  bool is_mode_offline;  ///< True if offline mode is enabled, False otherwise
+  String _serialInput;   ///< Serial input buffer
+  const char *json_test_data;          ///< Json test data
+  const char *_log_filename;           ///< Path to the log file
+  RTC_DS3231 *_rtc_ds3231 = nullptr;   ///< DS3231 RTC object
+  RTC_DS1307 *_rtc_ds1307 = nullptr;   ///< DS1307 RTC object
   RTC_PCF8523 *_rtc_pcf8523 = nullptr; ///< PCF8523 RTC object
   RTC_Millis *_rtc_soft = nullptr;     ///< Software RTC object
   bool _use_test_data; ///< True if sample data is being used for testing