[SD] All tests green again

Author: brentru

platformio.ini

@@ -131,7 +131,7 @@ lib_compat_mode = soft  ; can be strict once pio detects SleepyDog on RP2040
 extends = common:esp32
 board = esp32dev
 board_build.partitions = default_8MB.csv
-build_flags = -DARDUINO_ESP32_DEV -DOFFLINE_MODE_DEBUG
+build_flags = -DARDUINO_ESP32_DEV -DOFFLINE_MODE_DEBUG -DOFFLINE_MODE_WOKWI
 board_build.filesystem = littlefs
 upload_speed = 921600
 

src/Wippersnapper_V2.cpp

@@ -1095,9 +1095,11 @@ void Wippersnapper_V2::pingBrokerV2() {
 */
 /*******************************************************/
 void Wippersnapper_V2::feedWDTV2() {
+    #ifndef OFFLINE_MODE_WOKWI
     // TODO: This is a temporary fix for watchdog.reset() not firing
     // Watchdog.reset();
     esp_task_wdt_reset();
+    #endif
 }
 
 /********************************************************/

src/components/analogIO/controller.cpp

@@ -224,8 +224,8 @@ bool AnalogIOController::EncodePublishPinEvent(
 */
 /***************************************************************************/
 bool AnalogIOController::EncodePublishPinValue(uint8_t pin, uint16_t value) {
-
   if (WsV2._sdCardV2->isModeOffline()) {
+    WS_DEBUG_PRINTLN("Logging offline analogio event...");
     return WsV2._sdCardV2->LogGPIOSensorEventToSD(
         pin, value, wippersnapper_sensor_SensorType_SENSOR_TYPE_RAW);
   } else {
@@ -262,8 +262,9 @@ bool AnalogIOController::EncodePublishPinVoltage(uint8_t pin, float value) {
 /***************************************************************************/
 void AnalogIOController::update() {
   // Bail-out if the vector is empty
-  if (_analogio_pins.empty())
+  if (_analogio_pins.empty()) {
     return;
+  }
 
   // Process analog input pins
   for (int i = 0; i < _analogio_pins.size(); i++) {

src/provisioning/sdcard/ws_sdcard.cpp

@@ -21,7 +21,11 @@
 /**************************************************************************/
 ws_sdcard::ws_sdcard() {
   is_mode_offline = false;
+#ifdef OFFLINE_MODE_WOKWI
+  _is_using_wokwi = true;
+#else
   _is_using_wokwi = false;
+#endif
   _use_test_data = false;
   _sz_log_file = 0;
 }
@@ -167,6 +171,41 @@ void ws_sdcard::CheckIn(uint8_t max_digital_pins, uint8_t max_analog_pins,
   WsV2.analogio_controller->SetRefVoltage(ref_voltage);
 }
 
+/**************************************************************************/
+/*!
+    @brief  Parses a sensor type from the JSON configuration file.
+    @param  sensor_type
+            The sensor type to parse.
+    @returns The parsed sensor type.
+*/
+/**************************************************************************/
+wippersnapper_sensor_SensorType
+ws_sdcard::ParseSensorType(const char *sensor_type) {
+  if (strcmp(sensor_type, "PIN_VALUE") == 0) {
+    return wippersnapper_sensor_SensorType_SENSOR_TYPE_RAW;
+  } else if (strcmp(sensor_type, "VOLTAGE") == 0) {
+    return wippersnapper_sensor_SensorType_SENSOR_TYPE_VOLTAGE;
+  } else if (strcmp(sensor_type, "object-temp-fahrenheit") == 0) {
+    WS_DEBUG_PRINTLN("Found object-temp-fahrenheit");
+    return wippersnapper_sensor_SensorType_SENSOR_TYPE_OBJECT_TEMPERATURE_FAHRENHEIT;
+  } else if (strcmp(sensor_type, "object-temp") == 0) {
+    WS_DEBUG_PRINTLN("Found object-temp");
+    return wippersnapper_sensor_SensorType_SENSOR_TYPE_OBJECT_TEMPERATURE;
+  } else {
+    WS_DEBUG_PRINT("Found unspecified sensortype - ");
+    WS_DEBUG_PRINTLN(sensor_type);
+    return wippersnapper_sensor_SensorType_SENSOR_TYPE_UNSPECIFIED;
+  }
+}
+
+bool ws_sdcard::ValidateJSONKey(const char *key, const char *error_msg) {
+  if (strcmp(key, UNKNOWN_VALUE) == 0) {
+    WS_DEBUG_PRINTLN(error_msg);
+    return false;
+  }
+  return true;
+}
+
 /**************************************************************************/
 /*!
     @brief  Parses a DigitalIOAdd message from the JSON configuration file.
@@ -193,10 +232,8 @@ bool ws_sdcard::ParseDigitalIOAdd(
     float period, bool value, const char *sample_mode, const char *direction,
     const char *pull) {
   bool rc = true;
-  if (!strcmp(pin, UNKNOWN_VALUE) == 0) {
-    WS_DEBUG_PRINTLN("[SD] Parsing Error: Digital pin name not found!");
+  if (!ValidateJSONKey(pin, "[SD] Parsing Error: Digital pin name not found!"))
     return false;
-  }
   strcpy(msg_DigitalIOAdd.pin_name, pin);
 
   if (period == 0.0) {
@@ -207,9 +244,9 @@ bool ws_sdcard::ParseDigitalIOAdd(
   msg_DigitalIOAdd.value = value;
 
   // Determine the sample mode
-  if (strcmp(sample_mode, UNKNOWN_VALUE) == 0) {
-    WS_DEBUG_PRINTLN(
-        "[SD] Parsing Error: Digital pin's sample mode not found!");
+  if (!ValidateJSONKey(
+          sample_mode,
+          "[SD] Parsing Error: Digital pin's sample mode not found!")) {
     return false;
   } else if (strcmp(sample_mode, "TIMER") == 0) {
     msg_DigitalIOAdd.sample_mode =
@@ -223,8 +260,9 @@ bool ws_sdcard::ParseDigitalIOAdd(
   }
 
   // Determine the pin direction and pull
-  if (strcmp(direction, UNKNOWN_VALUE) == 0) {
-    WS_DEBUG_PRINTLN("[SD] Parsing Error: Digital pin's direction not found!");
+  if (!ValidateJSONKey(
+          direction,
+          "[SD] Parsing Error: Digital pin's direction not found!")) {
     return false;
   } else if (strcmp(direction, "INPUT") == 0) {
     if (pull != nullptr) {
@@ -246,33 +284,6 @@ bool ws_sdcard::ParseDigitalIOAdd(
   return rc;
 }
 
-/**************************************************************************/
-/*!
-    @brief  Parses a sensor type from the JSON configuration file.
-    @param  sensor_type
-            The sensor type to parse.
-    @returns The parsed sensor type.
-*/
-/**************************************************************************/
-wippersnapper_sensor_SensorType
-ws_sdcard::ParseSensorType(const char *sensor_type) {
-  if (strcmp(sensor_type, "PIN_VALUE") == 0) {
-    return wippersnapper_sensor_SensorType_SENSOR_TYPE_RAW;
-  } else if (strcmp(sensor_type, "VOLTAGE") == 0) {
-    return wippersnapper_sensor_SensorType_SENSOR_TYPE_VOLTAGE;
-  } else if (strcmp(sensor_type, "object-temp-fahrenheit") == 0) {
-    WS_DEBUG_PRINTLN("Found object-temp-fahrenheit");
-    return wippersnapper_sensor_SensorType_SENSOR_TYPE_OBJECT_TEMPERATURE_FAHRENHEIT;
-  } else if (strcmp(sensor_type, "object-temp") == 0) {
-    WS_DEBUG_PRINTLN("Found object-temp");
-    return wippersnapper_sensor_SensorType_SENSOR_TYPE_OBJECT_TEMPERATURE;
-  } else {
-    WS_DEBUG_PRINT("Found unspecified sensortype - ");
-    WS_DEBUG_PRINTLN(sensor_type);
-    return wippersnapper_sensor_SensorType_SENSOR_TYPE_UNSPECIFIED;
-  }
-}
-
 /**************************************************************************/
 /*!
     @brief  Parses an AnalogIOAdd message from the JSON configuration file.
@@ -291,8 +302,21 @@ ws_sdcard::ParseSensorType(const char *sensor_type) {
 bool ws_sdcard::ParseAnalogIOAdd(
     wippersnapper_analogio_AnalogIOAdd &msg_AnalogIOAdd, const char *pin,
     float period, const char *mode) {
+
+  if (!ValidateJSONKey(pin, "[SD] Parsing Error: Analog pin name not found!"))
+    return false;
   strcpy(msg_AnalogIOAdd.pin_name, pin);
+
+  if (period == 0.0) {
+    WS_DEBUG_PRINTLN("[SD] Parsing Error: Analog pin period less than 1.0 "
+                     "seconds or not found!");
+    return false;
+  }
   msg_AnalogIOAdd.period = period;
+
+  if (!ValidateJSONKey(mode,
+                       "[SD] Parsing Error: Analog pin read mode not found!"))
+    return false;
   msg_AnalogIOAdd.read_mode = ParseSensorType(mode);
   if (msg_AnalogIOAdd.read_mode ==
       wippersnapper_sensor_SensorType_SENSOR_TYPE_UNSPECIFIED) {
@@ -307,18 +331,47 @@ bool ws_sdcard::ParseDS18X20Add(
     wippersnapper_ds18x20_Ds18x20Add &msg_DS18X20Add, const char *pin,
     int resolution, float period, int num_sensors, const char *sensor_type_1,
     const char *sensor_type_2) {
+
+  if (strcmp(pin, UNKNOWN_VALUE) == 0) {
+    WS_DEBUG_PRINTLN("[SD] Parsing Error: DS18X20 pin name not found!");
+    return false;
+  }
   strcpy(msg_DS18X20Add.onewire_pin, pin);
+
+  if (resolution == 0) {
+    WS_DEBUG_PRINTLN(
+        "[SD] Parsing Error: DS18X20 sensor resolution not found!");
+    return false;
+  }
   msg_DS18X20Add.sensor_resolution = resolution;
+
+  if (period == 0.0) {
+    WS_DEBUG_PRINTLN("[SD] Parsing Error: DS18X20 sensor period not found!");
+    return false;
+  }
   msg_DS18X20Add.period = period;
+
+  if (num_sensors == 0) {
+    WS_DEBUG_PRINTLN("[SD] Parsing Error: DS18X20 sensor count not found!");
+    return false;
+  }
   msg_DS18X20Add.sensor_types_count = num_sensors;
 
   WS_DEBUG_PRINT("[SD] msg_DS18X20Add.sensor_types_count: ");
   WS_DEBUG_PRINTLN(msg_DS18X20Add.sensor_types_count);
 
   // Parse the first sensor type
+  if (strcmp(sensor_type_1, UNKNOWN_VALUE) == 0) {
+    WS_DEBUG_PRINTLN("[SD] Parsing Error: DS18X20 sensor type 1 not found!");
+    return false;
+  }
   msg_DS18X20Add.sensor_types[0] = ParseSensorType(sensor_type_1);
   // Parse the second sensor type, if it exists
   if (num_sensors == 2) {
+    if (strcmp(sensor_type_2, UNKNOWN_VALUE) == 0) {
+      WS_DEBUG_PRINTLN("[SD] Parsing Error: DS18X20 sensor type 2 not found!");
+      return false;
+    }
     msg_DS18X20Add.sensor_types[1] = ParseSensorType(sensor_type_2);
   }
   return true;
@@ -414,8 +467,9 @@ bool ws_sdcard::parseConfigFile() {
   error = deserializeJson(doc, file_config);
 #else
   // Test Mode - do not use the SD card, use test data instead!
-  if (_use_test_data == true) {
+  if (!_use_test_data) {
     WS_DEBUG_PRINTLN("[SD] Parsing Serial Input...");
+    WS_DEBUG_PRINT(_serialInput);
     error = deserializeJson(doc, _serialInput.c_str(), max_json_len);
   } else {
     WS_DEBUG_PRINTLN("[SD] Parsing Test Data...");
@@ -432,6 +486,8 @@ bool ws_sdcard::parseConfigFile() {
     return false;
   }
 
+  WS_DEBUG_PRINTLN("[SD] Successfully deserialized JSON config file!");
+
   // NOTE: This is only used by the CI runner, production builds do not run
   // this!
   const char *exportedBy = doc["exportedBy"];
@@ -448,25 +504,28 @@ bool ws_sdcard::parseConfigFile() {
   }
 
   // Mock the check-in process using the JSON's values
+  WS_DEBUG_PRINTLN("[SD] Mocking check-in process...");
   CheckIn(exportedFromDevice["totalGPIOPins"] | 0,
           exportedFromDevice["totalAnalogPins"] | 0,
           exportedFromDevice["referenceVoltage"] | 0.0);
 
+  WS_DEBUG_PRINTLN("[SD] Configuring status LED...");
   setStatusLEDBrightness(exportedFromDevice["statusLEDBrightness"] | 0.3);
 
-  // Initialize and configure RTC
+// Initialize and configure RTC
+#ifndef OFFLINE_MODE_WOKWI
+  WS_DEBUG_PRINTLN("[SD] Configuring RTC...");
   const char *json_rtc = exportedFromDevice["rtc"] | "SOFT_RTC";
-  if (json_rtc == nullptr) {
-    WS_DEBUG_PRINTLN("[SD] FATAL Parsing error - rtc field not found in "
-                     "configuration JSON, unable to configure RTC!");
-    return false;
-  }
   if (!ConfigureRTC(json_rtc)) {
     WS_DEBUG_PRINTLN("[SD] Failed to to configure RTC!");
     return false;
   }
+#else
+  WS_DEBUG_PRINTLN("[SD] Skipping RTC configuration for Wokwi Simulator...");
+#endif
 
   // Parse the "components" array into a JsonObject
+  WS_DEBUG_PRINTLN("[SD] Parsing out components array...");
   JsonArray components_ar = doc["components"].as<JsonArray>();
   if (components_ar.isNull()) {
     WS_DEBUG_PRINTLN("[SD] FATAL Parsing error - No components array found in "
@@ -512,8 +571,10 @@ bool ws_sdcard::parseConfigFile() {
       wippersnapper_analogio_AnalogIOAdd msg_AnalogIOAdd =
           wippersnapper_analogio_AnalogIOAdd_init_default;
       // Parse: JSON->AnalogIOAdd
-      if (!ParseAnalogIOAdd(msg_AnalogIOAdd, component["pinName"],
-                            component["period"], component["analogReadMode"])) {
+      if (!ParseAnalogIOAdd(msg_AnalogIOAdd,
+                            component["pinName"] | UNKNOWN_VALUE,
+                            component["period"] | 0.0,
+                            component["analogReadMode"] | UNKNOWN_VALUE)) {
         WS_DEBUG_PRINTLN(
             "[SD] FATAL Parsing error - Unable to parse AnalogIO component!");
         return false;
@@ -526,11 +587,12 @@ bool ws_sdcard::parseConfigFile() {
       wippersnapper_ds18x20_Ds18x20Add msg_DS18X20Add =
           wippersnapper_ds18x20_Ds18x20Add_init_default;
       // Parse: JSON->DS18X20Add
-      if (!ParseDS18X20Add(msg_DS18X20Add, component["pinName"],
-                           component["sensorResolution"], component["period"],
-                           component["sensorTypeCount"],
-                           component["sensorType1"],
-                           component["sensorType2"])) {
+      if (!ParseDS18X20Add(msg_DS18X20Add, component["pinName"] | UNKNOWN_VALUE,
+                           component["sensorResolution"] | 0,
+                           component["period"] | 0.0,
+                           component["sensorTypeCount"] | 0,
+                           component["sensorType1"] | UNKNOWN_VALUE,
+                           component["sensorType2"] | UNKNOWN_VALUE)) {
         WS_DEBUG_PRINTLN(
             "[SD] FATAL Parsing error - Unable to parse DS18X20 component!");
         return false;
@@ -569,12 +631,11 @@ uint32_t ws_sdcard::GetTimestamp() {
     now = _rtc_ds1307->now();
   else if (_rtc_pcf8523 != nullptr)
     now = _rtc_pcf8523->now();
-  else {
+  else if (_rtc_soft != nullptr) {
     now = _rtc_soft->now();
-  }
-
-  if (_is_using_wokwi)
+  } else { // we're either using a simulator or have undefined behavior
     return 0;
+  }
 
   return now.unixtime();
 }
@@ -683,6 +744,7 @@ void ws_sdcard::BuildJSONDoc(JsonDocument &doc, uint8_t pin, uint16_t value,
   char pin_name[12];
   sprintf(pin_name, "A%d", pin);
   doc["timestamp"] = GetTimestamp();
+  ;
   doc["pin"] = pin_name;
   doc["value"] = value;
   doc["si_unit"] = SensorTypeToString(read_type);
@@ -847,7 +909,13 @@ bool ws_sdcard::waitForSerialConfig() {
   // 2. Provide a JSON string via the hardware's serial input
   // 3. Use a test JSON string - for debugging purposes ONLY
 
-  _use_test_data = true;
+  // TODO: Redundant conditional - should this just be enabled within the class
+  // ctor?
+  if (_is_using_wokwi)
+    _use_test_data = false;
+  else
+    _use_test_data = true;
+
   json_test_data = "{"
                    "\"exportVersion\": \"1.0.0\","
                    "\"exportedBy\": \"tester\","
@@ -900,8 +968,8 @@ bool ws_sdcard::waitForSerialConfig() {
                    "\"componentAPI\": \"ds18x20\","
                    "\"name\": \"DS18B20: Temperature Sensor (°F)\","
                    "\"sensorTypeCount\": 2,"
-                   "\"sensorType1\": \"ambient-temp-fahrenheit\","
-                   "\"sensorType2\": \"ambient-temp\","
+                   "\"sensorType1\": \"object-temp-fahrenheit\","
+                   "\"sensorType2\": \"object-temp\","
                    "\"pinName\": \"D12\","
                    "\"sensorResolution\": 12,"
                    "\"period\": 5"
@@ -910,8 +978,8 @@ bool ws_sdcard::waitForSerialConfig() {
                    "\"componentAPI\": \"ds18x20\","
                    "\"name\": \"DS18B20: Temperature Sensor (°F)\","
                    "\"sensorTypeCount\": 2,"
-                   "\"sensorType1\": \"ambient-temp-fahrenheit\","
-                   "\"sensorType2\": \"ambient-temp\","
+                   "\"sensorType1\": \"object-temp-fahrenheit\","
+                   "\"sensorType2\": \"object-temp\","
                    "\"pinName\": \"D25\","
                    "\"sensorResolution\": 12,"
                    "\"period\": 5"

src/provisioning/sdcard/ws_sdcard.h

@@ -53,6 +53,7 @@ class ws_sdcard {
 
 private:
   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);