moved watchdog routine to an example

Author: dizcza

examples/sdpsensor-esp-arduino.ino examples/SDP3x/SDP3x.inoexamples/sdpsensor-esp-arduino.ino renamed to examples/SDP3x/SDP3x.ino

@@ -10,31 +10,46 @@
 #include "sdpsensor.h"
 
 
-/* If you don't know the I2C address of a sensor,
- *  scan all addresses with an I2C scanner first.
+/* An SDP sensor instance.
+ * If you don't know the I2C address of a sensor,
+ *   scan all addresses with an I2C scanner first.
  */
 SDPSensor sdp(0x21);
 
 
-void setup() {
-  Serial.begin(115200);
-  delay(1000); // let serial console settle
-  sdp.initI2C(19, 23);  // same as Wire.begin(19, 23)
+/* Try until succeeds. */
+void initSensorUntilSuccess() {
+  while (sdp.stopContinuous() != ESP_OK);  // sdp.reset() is also possible
+  while (sdp.begin() != ESP_OK);
+  while (sdp.startContinuous() != ESP_OK);
+}
+
+
+/* Try until the first error occurs. */
+void initSensorSingleTrial() {
   sdp.stopContinuous();  // sdp.reset() is also possible
   sdp.begin();
   sdp.startContinuous();
 }
 
 
+void setup() {
+  Serial.begin(115200);
+  delay(1000); // let serial console settle
+  sdp.initI2C(19, 23);  // same as Wire.begin(SDA, SCL)
+
+  // choose how you want to initialize the sensor
+  initSensorSingleTrial();
+  //initSensorUntilSuccess();
+}
+
+
 void loop() {
   delay(1000);
   int16_t pressure;
   esp_err_t err = sdp.readDiffPressure(&pressure);
+  if (err == ESP_OK) {
+    // success; process the 'pressure' here
+  }
   ESP_LOGI("sdp", "raw pressure: %d, err code: %s", pressure, esp_err_to_name(err));
-
-  /*
-   *  Optionally, check the last result code.
-   *  If enough errors occur, a software reset is issued.
-   */
-  sdp.watchdogCheck(err);
 }

examples/SDP3x_Watchdog/SDP3x_Watchdog.ino

@@ -0,0 +1,82 @@
+/**
+ * An example to use an SDP3x sensor with an ESP32 board
+ *   with a watchdog that barks each time three errors are
+ *   encountered in a row.
+ * 
+ * Prior setup:
+ *   1) install the arduino-esp library
+ *   2) select your ESP board in "Tools" -> "Board"
+ *   3) select the right port in "Tools" -> "Port"
+ *   4) turn on the logs by setting "Tools" -> "Core Debug Level" -> "Info"
+ */
+#include "sdpsensor.h"
+
+
+/**
+ * An SDP Sensor instance.
+ * If you don't know the I2C address of a sensor,
+ *   scan all addresses with an I2C scanner first.
+ */
+SDPSensor sdp(0x21);
+
+/* Failed reads count */
+uint32_t failsCount = 0;
+
+/* Max SDP successive failed reads before a SW reset */
+const uint32_t maxSuccessiveFailsCount = 3;
+
+/**
+ * Check the error code status of the last read measurement.
+ * If enough errors occurred, a software reset is issued.
+ *
+ * Usage:
+ *   esp_err_t err = sdp.readContinuousRaw(&diff_pressure);
+ *   sdp.watchdogCheck(err);
+ *
+ * @param status - the error code of the last measurement
+ */
+void watchdogCheck(esp_err_t status) {
+    if (status == ESP_OK) {
+        failsCount = 0;
+    } else {
+        failsCount++;
+    }
+
+    if (failsCount >= maxSuccessiveFailsCount) {
+        ESP_LOGW("watchdog", "SDPWatchdog barked. Resetting...");
+        esp_err_t err = ESP_FAIL;
+        do {
+            err = sdp.reset();  // sdp.stopContinuous() is a safer version
+            if (err == ESP_OK) {
+                err = sdp.startContinuous();
+            }
+        } while (err != ESP_OK);
+    }
+
+}
+
+
+void setup() {
+  Serial.begin(115200);
+  delay(1000); // let serial console settle
+  sdp.initI2C(19, 23);  // same as Wire.begin(SDA, SCL)
+
+  // try until succeeds
+  while (sdp.stopContinuous() != ESP_OK);  // sdp.reset() is also possible
+  while (sdp.begin() != ESP_OK);
+  while (sdp.startContinuous() != ESP_OK);
+}
+
+
+void loop() {
+  delay(1000);
+  int16_t pressure;
+  esp_err_t err = sdp.readDiffPressure(&pressure);
+  ESP_LOGI("sdp", "raw pressure: %d, err code: %s", pressure, esp_err_to_name(err));
+
+  /*
+   *  Optionally, check the last result code.
+   *  If enough errors occur, a software reset is issued.
+   */
+  watchdogCheck(err);
+}

sdpsensor.cpp

@@ -56,8 +56,6 @@ SDPSensor::SDPSensor(uint8_t i2c_addr, i2c_port_t i2c_port) {
     this->i2c_addr = i2c_addr;
     this->i2c_port = i2c_port;
     this->pressureScale = 0;  // will be read & set in the begin()
-    this->maxSuccessiveFailsCount = 2;
-    this->failsCount = 0;
     this->initialized = false;
 }
 
@@ -246,38 +244,6 @@ esp_err_t SDPSensor::reset() {
 }
 
 
-void SDPSensor::watchdogSetParams(uint32_t maxSuccessiveFailsCount) {
-    this->maxSuccessiveFailsCount = maxSuccessiveFailsCount;
-}
-
-
-void SDPSensor::watchdogCheck(esp_err_t status) {
-    if (!initialized) return;
-
-    if (status == ESP_OK || status == ESP_ERR_INVALID_CRC) {
-        // invalid CRC does not mean that the sensor is not functioning
-        failsCount = 0;
-    } else {
-        failsCount++;
-    }
-
-    if (failsCount >= maxSuccessiveFailsCount) {
-        ESP_LOGW(TAG_SDPSENSOR, "SDPWatchdog barked. Resetting...");
-        // flush i2c buffers before resetting
-        i2c_reset_tx_fifo(i2c_port);
-        i2c_reset_rx_fifo(i2c_port);
-
-        esp_err_t err = ESP_FAIL;
-        do {
-            err = SDPSensor::reset();
-            if (err == ESP_OK) {
-                err = SDPSensor::startContinuous();
-            }
-        } while (err != ESP_OK);
-    }
-}
-
-
 esp_err_t SDPSensor::readDiffPressure(int16_t *diffPressureRaw) {
     if (!initialized) return ESP_ERR_INVALID_STATE;
 

sdpsensor.h

@@ -16,8 +16,6 @@ class SDPSensor {
         uint8_t i2c_addr;                    /* I2C address */
         i2c_port_t i2c_port;                 /* I2C master port */
         uint16_t pressureScale;              /* Diff pressure scale */
-        uint32_t failsCount;                 /* [watchdog] SDP successive failed reads count */
-        uint32_t maxSuccessiveFailsCount;    /* [watchdog] SDP max successive failed reads before SW reset */
         bool initialized;
     public:
 
@@ -92,29 +90,6 @@ class SDPSensor {
         esp_err_t reset();
 
 
-        /**
-         * Set watchdog params to be used in the `watchdogCheck()` function.
-         * Has no effect if the user does not call the `watchdogCheck()` function.
-         *
-         * @param maxSuccessiveFailsCount - the maximum successive failed reads
-         *                                  until the reset command is issued.
-         */
-        void watchdogSetParams(uint32_t maxSuccessiveFailsCount);
-
-
-        /**
-         * Check the error code status of the last read measurement.
-         * If enough errors occurred, a software reset is issued.
-         *
-         * Usage:
-         *   esp_err_t err = sdp.readContinuousRaw(&diff_pressure);
-         *   sdp.watchdogCheck(err);
-         *
-         * @param status - the error code of the last measurement
-         */
-        void watchdogCheck(esp_err_t status);
-
-
         /**
          * Read the raw (unnormalized) differential pressure value and
          * save the result in `diffPressureRaw`. To convert it to a