[SD] Address error cases/states for sd_cs handling

Author: brentru

src/Wippersnapper_V2.cpp

@@ -105,13 +105,12 @@ void Wippersnapper_V2::provisionV2() {
 #endif
 
   // Determine if app is in SDLogger mode
-  uint8_t pin_cs;
   #ifdef USE_TINYUSB
-  pin_cs = _fileSystemV2->GetSDCSPin(); 
+  _fileSystemV2->GetSDCSPin(); 
   #else
-  pin_cs = _littleFSV2->GetSDCSPin();
+  _littleFSV2->GetSDCSPin();
   #endif
-  if (WsV2._sdCardV2->InitSDCard(pin_cs))
+  if (WsV2._sdCardV2->InitSDCard())
     return;
 
 #ifdef USE_DISPLAY

src/Wippersnapper_V2.h

@@ -255,9 +255,8 @@ class Wippersnapper_V2 {
                              ///< otherwise.
   std::vector<std::vector<uint8_t>>
       _sharedConfigBuffers; ///< Shared JSON config buffers for offline mode
-
-
   JsonDocument _config_doc;
+  uint8_t pin_sd_cs; ///< SD card chip select pin
 private:
   void _initV2();
 

src/provisioning/littlefs/WipperSnapper_LittleFS_V2.cpp

@@ -161,24 +161,23 @@ void WipperSnapper_LittleFS_V2::fsHalt(String msg) {
               config.json file.
 */
 /**************************************************************************/
-uint8_t WipperSnapper_LittleFS_V2::GetSDCSPin() {
+void WipperSnapper_LittleFS_V2::GetSDCSPin() {
   File32 file_cfg;
   DeserializationError error;
   // Attempt to open and deserialize the config.json file
   file_cfg = LittleFS.open("/config.json");
   if (!file_cfg)
-    return 255;
+    WsV2.pin_sd_cs = 255;
   error = deserializeJson(WsV2._config_doc, file_cfg);
   if (error) {
     file_cfg.close();
-    return 255;
+    WsV2.pin_sd_cs = 255;
   }
 
   // Parse config.json and save the SD CS pin
   JsonObject exportedFromDevice = WsV2._config_doc["exportedFromDevice"];
-  uint8_t pin_cs = exportedFromDevice["sd_cs_pin"] | 255;
+  WsV2.pin_sd_cs = exportedFromDevice["sd_cs_pin"] | 255;
   file_cfg.close();
-  return pin_cs;
 }
 
 #endif

src/provisioning/littlefs/WipperSnapper_LittleFS_V2.h

@@ -34,7 +34,7 @@ class WipperSnapper_LittleFS_V2 {
   ~WipperSnapper_LittleFS_V2();
   void parseSecrets();
   void fsHalt(String msg);
-  uint8_t GetSDCSPin();
+  void GetSDCSPin();
 };
 extern Wippersnapper_V2 WsV2;
 #endif // WIPPERSNAPPER_LITTLEFS_H

src/provisioning/sdcard/ws_sdcard.cpp

@@ -44,14 +44,18 @@ ws_sdcard::~ws_sdcard() {
               otherwise.
 */
 /**************************************************************************/
-bool ws_sdcard::InitSDCard(uint8_t pin_cs) {
-  /*   if (pin_cs == 255)
-      return false; */
-  if (_sd.begin(pin_cs)) {
-    is_mode_offline = true;
+bool ws_sdcard::InitSDCard() {
+  if (WsV2.pin_sd_cs == PIN_SD_CS_ERROR) {
+    is_mode_offline = false;
     return is_mode_offline;
   }
-  return false;
+
+  if (_sd.begin(WsV2.pin_sd_cs)) {
+    is_mode_offline = true;
+  } else {
+    is_mode_offline = false;
+  }
+  return is_mode_offline;
 }
 
 /**************************************************************************/
@@ -881,162 +885,4 @@ bool ws_sdcard::LogDS18xSensorEventToSD(
     LogJSONDoc(doc);
   }
   return true;
-}
-
-// TODO: Do we even need to use this function anymore now that we're running
-// wokwi unit tests?
-#ifdef OFFLINE_MODE_DEBUG
-/**************************************************************************/
-/*!
-    @brief  Validates a JSON string.
-    @param  input
-            A JSON string to validate.
-    @returns True if the provided JSON string is valid, False otherwise.
-*/
-/**************************************************************************/
-bool ws_sdcard::ValidateJSON(const char *input) {
-  JsonDocument doc, filter;
-
-  DeserializationError error =
-      deserializeJson(doc, input, DeserializationOption::Filter(filter));
-  return error == DeserializationError::Ok;
-}
-
-/**************************************************************************/
-/*!
-    @brief  Waits for a valid JSON string to be received via the hardware's
-            serial input or from a hardcoded test JSON string.
-    @returns True if a valid JSON string was received, False otherwise.
-*/
-/**************************************************************************/
-bool ws_sdcard::waitForSerialConfig() {
-
-  // We provide three ways to use this function:
-  // 1. Use a SD card with a JSON config file
-  // 2. Provide a JSON string via the hardware's serial input
-  // 3. Use a test JSON string - for debugging purposes ONLY
-
-  json_test_data = "{"
-                   "\"exportVersion\": \"1.0.0\","
-                   "\"exportedBy\": \"tester\","
-                   "\"exportedAt\": \"2024-10-28T18:58:23.976Z\","
-                   "\"exportedFromDevice\": {"
-                   "\"board\": \"metroesp32s3\","
-                   "\"firmwareVersion\": \"1.0.0-beta.93\","
-                   "\"referenceVoltage\": 2.6,"
-                   "\"totalGPIOPins\": 11,"
-                   "\"totalAnalogPins\": 6"
-                   "},"
-                   "\"components\": ["
-                   "{"
-                   "\"componentAPI\": \"analogio\","
-                   "\"name\": \"Analog Pin\","
-                   "\"pinName\": \"D14\","
-                   "\"type\": \"analog_pin\","
-                   "\"mode\": \"ANALOG\","
-                   "\"direction\": \"INPUT\","
-                   "\"sampleMode\": \"TIMER\","
-                   "\"analogReadMode\": \"PIN_VALUE\","
-                   "\"period\": 5,"
-                   "\"isPin\": true"
-                   "},"
-                   "{"
-                   "\"componentAPI\": \"analogio\","
-                   "\"name\": \"Analog Pin\","
-                   "\"pinName\": \"D27\","
-                   "\"type\": \"analog_pin\","
-                   "\"mode\": \"ANALOG\","
-                   "\"direction\": \"INPUT\","
-                   "\"sampleMode\": \"TIMER\","
-                   "\"analogReadMode\": \"PIN_VALUE\","
-                   "\"period\": 5,"
-                   "\"isPin\": true"
-                   "},"
-                   "{"
-                   "\"componentAPI\": \"digitalio\","
-                   "\"name\": \"Button (D4)\","
-                   "\"pinName\": \"D4\","
-                   "\"type\": \"push_button\","
-                   "\"mode\": \"DIGITAL\","
-                   "\"sampleMode\": \"EVENT\","
-                   "\"direction\": \"INPUT\","
-                   "\"period\": 5,"
-                   "\"pull\": \"UP\","
-                   "\"isPin\": true"
-                   "},"
-                   "{"
-                   "\"componentAPI\": \"ds18x20\","
-                   "\"name\": \"DS18B20: Temperature Sensor (°F)\","
-                   "\"sensorTypeCount\": 2,"
-                   "\"sensorType1\": \"object-temp-fahrenheit\","
-                   "\"sensorType2\": \"object-temp\","
-                   "\"pinName\": \"D12\","
-                   "\"sensorResolution\": 12,"
-                   "\"period\": 5"
-                   "},"
-                   "{"
-                   "\"componentAPI\": \"ds18x20\","
-                   "\"name\": \"DS18B20: Temperature Sensor (°F)\","
-                   "\"sensorTypeCount\": 2,"
-                   "\"sensorType1\": \"object-temp-fahrenheit\","
-                   "\"sensorType2\": \"object-temp\","
-                   "\"pinName\": \"D25\","
-                   "\"sensorResolution\": 12,"
-                   "\"period\": 5"
-                   "}"
-                   "]"
-                   "}\\n\r\n";
-
-  _serialInput = ""; // Clear the serial input buffer
-  if (!_use_test_data) {
-    WS_DEBUG_PRINTLN("[SD] Waiting for incoming JSON string...");
-    while (true) {
-      // Check if there is data available to read
-      if (Serial.available() > 0) {
-        // Read and append to _serialInput
-        char c = Serial.read();
-        _serialInput += c;
-
-        // DEBUG - Check JSON output as an Int and total output
-        // WS_DEBUG_PRINT("[SD] Character read: ");
-        // WS_DEBUG_PRINTLN((int)c);
-        // WS_DEBUG_PRINTLN(_serialInput);
-
-        // Check for end of JSON string using \n sequence
-        if (_serialInput.endsWith("\\n")) {
-          WS_DEBUG_PRINTLN("[SD] End of JSON string detected!");
-          break;
-        }
-      }
-    }
-  }
-
-  // Strip the '\n' off the end of _serialInput
-  _serialInput.trim();
-
-  // Print out the received JSON string
-  WS_DEBUG_PRINT("[SD][Debug] JSON string received!");
-  if (_use_test_data) {
-    WS_DEBUG_PRINTLN("[from json test data]");
-    WS_DEBUG_PRINTLN(json_test_data);
-  } else {
-    WS_DEBUG_PRINTLN(_serialInput);
-  }
-
-  // Attempt to validate the string as JSON
-  if (!_use_test_data) {
-    if (!ValidateJSON(_serialInput.c_str())) {
-      WS_DEBUG_PRINTLN("[SD] Invalid JSON string received!");
-      return false;
-    }
-  } else {
-    if (!ValidateJSON(json_test_data)) {
-      WS_DEBUG_PRINTLN("[SD] Invalid JSON string received!");
-      return false;
-    }
-  }
-
-  WS_DEBUG_PRINTLN("[SD] Valid JSON string received!");
-  return true;
-}
-#endif
+}

src/provisioning/sdcard/ws_sdcard.h

@@ -21,6 +21,7 @@
 
 #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
 
 // forward decl.
@@ -36,11 +37,8 @@ class ws_sdcard {
 public:
   ws_sdcard();
   ~ws_sdcard();
-  bool InitSDCard(uint8_t pin_cs);
+  bool InitSDCard();
   bool parseConfigFile();
-#ifdef OFFLINE_MODE_DEBUG
-  bool waitForSerialConfig();
-#endif
   bool CreateNewLogFile();
   bool isModeOffline() { return is_mode_offline; }
   bool LogGPIOSensorEventToSD(uint8_t pin, float value,
@@ -53,7 +51,6 @@ class ws_sdcard {
 
 private:
   bool ValidateChecksum(JsonDocument &doc);
-  bool ValidateJSON(const char *input);
   bool ValidateJSONKey(const char *key, const char *error_msg);
   void CheckIn(uint8_t max_digital_pins, uint8_t max_analog_pins,
                float ref_voltage);

src/provisioning/tinyusb/Wippersnapper_FS_V2.cpp

@@ -168,24 +168,31 @@ Wippersnapper_FS_V2::~Wippersnapper_FS_V2() {
               config.json file.
 */
 /**************************************************************************/
-uint8_t Wippersnapper_FS_V2::GetSDCSPin() { 
+void Wippersnapper_FS_V2::GetSDCSPin() { 
   File32 file_cfg;
   DeserializationError error;
   // Attempt to open and deserialize the config.json file
   file_cfg = wipperFatFs_v2.open("/config.json");
-  if (!file_cfg)
-    return 255;
+  if (!file_cfg) {
+    WsV2.pin_sd_cs = 255;
+    return;
+  }
+
   error = deserializeJson(WsV2._config_doc, file_cfg);
   if (error) {
     file_cfg.close();
-    return 255;
+    WsV2.pin_sd_cs = 255;
+    return;
   }
 
   // Parse config.json and save the SD CS pin
   JsonObject exportedFromDevice = WsV2._config_doc["exportedFromDevice"];
-  uint8_t pin_cs = exportedFromDevice["sd_cs_pin"] | 255;
+  WsV2.pin_sd_cs = exportedFromDevice["sd_cs_pin"] | 255;
+  if (WsV2.pin_sd_cs == 255) {
+    file_cfg.close();
+    fsHalt("ERROR: Could not find required sd_cs_pin in config.json!");
+  }
   file_cfg.close();
-  return pin_cs;
 }
 
 /**************************************************************************/

src/provisioning/tinyusb/Wippersnapper_FS_V2.h

@@ -46,7 +46,7 @@ class Wippersnapper_FS_V2 {
 
   void initUSBMSC();
 
-  uint8_t GetSDCSPin();
+  void GetSDCSPin();
 
   bool writeFSContents();
   void fsHalt(String msg);