Refactoring some of the i2c boilerplate (#1498)

* Refactoring some of the i2c boilerplate

* Default value

* Debug statement

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -90,11 +90,11 @@ int32_t EnvironmentTelemetryModule::runOnce()
                     DEBUG_MSG("Environment Telemetry: No sensor type specified; Checking for detected i2c sensors\n");
                 break;
             }
-            if (hasSensor(TelemetrySensorType_BME680)) 
+            if (bme680Sensor.hasSensor()) 
                 result = bme680Sensor.runOnce();
-            if (hasSensor(TelemetrySensorType_BME280)) 
+            if (bme280Sensor.hasSensor()) 
                 result = bme280Sensor.runOnce();
-            if (hasSensor(TelemetrySensorType_MCP9808)) 
+            if (mcp9808Sensor.hasSensor()) 
                 result = mcp9808Sensor.runOnce();
         }
         return result;
@@ -233,25 +233,25 @@ bool EnvironmentTelemetryModule::sendOurTelemetry(NodeNum dest, bool wantReplies
 
     switch (moduleConfig.telemetry.environment_sensor_type) {
         case TelemetrySensorType_DS18B20:
-            if (!dallasSensor.getMeasurement(&m))
+            if (!dallasSensor.getMetrics(&m))
                 sensor_read_error_count++;
             break;
         case TelemetrySensorType_DHT11:
         case TelemetrySensorType_DHT12:
         case TelemetrySensorType_DHT21:
         case TelemetrySensorType_DHT22:
-            if (!dhtSensor.getMeasurement(&m))
+            if (!dhtSensor.getMetrics(&m))
                 sensor_read_error_count++;
             break;
         default:
             DEBUG_MSG("Environment Telemetry: No specified sensor type; Trying any detected i2c sensors\n");
     }
-    if (hasSensor(TelemetrySensorType_BME280)) 
+    if (bme280Sensor.hasSensor())
-        bme280Sensor.getMeasurement(&m);
+        bme280Sensor.getMetrics(&m);
-    if (hasSensor(TelemetrySensorType_BME680)) 
+    if (bme680Sensor.hasSensor())
-        bme680Sensor.getMeasurement(&m);
+        bme680Sensor.getMetrics(&m);
-    if (hasSensor(TelemetrySensorType_MCP9808)) 
+    if (mcp9808Sensor.hasSensor())
-        mcp9808Sensor.getMeasurement(&m);
+        mcp9808Sensor.getMetrics(&m);
 
     DEBUG_MSG("Telemetry->time: %i\n", m.time);
     DEBUG_MSG("Telemetry->barometric_pressure: %f\n", m.variant.environment_metrics.barometric_pressure);

src/modules/Telemetry/Sensor/BME280Sensor.cpp

@@ -3,29 +3,26 @@
 #include "TelemetrySensor.h"
 #include "BME280Sensor.h"
 #include <Adafruit_BME280.h>
+#include <typeinfo>
 
-BME280Sensor::BME280Sensor() : TelemetrySensor {} 
+BME280Sensor::BME280Sensor() : 
+    TelemetrySensor(TelemetrySensorType_BME280, "BME280")
 {
 }
 
 int32_t BME280Sensor::runOnce() {
-    unsigned bme280Status;
     DEBUG_MSG("Init sensor: TelemetrySensorType_BME280\n");
-    if (!hasSensor(TelemetrySensorType_BME280)) {
+    if (!hasSensor()) {
         return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
     }
-    bme280Status = bme280.begin(nodeTelemetrySensorsMap[TelemetrySensorType_BME280]); 
+    status = bme280.begin(nodeTelemetrySensorsMap[TelemetrySensorType_BME280]); 
-    if (!bme280Status) {
+    return initI2CSensor();
-        DEBUG_MSG("Could not connect to any detected BME-280 sensor.\nRemoving from nodeTelemetrySensorsMap.\n");
-        nodeTelemetrySensorsMap[TelemetrySensorType_BME280] = 0;
-    } else {
-        DEBUG_MSG("Opened BME280 on default i2c bus\n");
-    }
-    return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
 }
 
-bool BME280Sensor::getMeasurement(Telemetry *measurement) {
+void BME280Sensor::setup() { }
-    DEBUG_MSG("BME280Sensor::getMeasurement\n");
+
+bool BME280Sensor::getMetrics(Telemetry *measurement) {
+    DEBUG_MSG("BME280Sensor::getMetrics\n");
     measurement->variant.environment_metrics.temperature = bme280.readTemperature();
     measurement->variant.environment_metrics.relative_humidity = bme280.readHumidity();
     measurement->variant.environment_metrics.barometric_pressure = bme280.readPressure() / 100.0F;

src/modules/Telemetry/Sensor/BME280Sensor.h

@@ -6,8 +6,11 @@ class BME280Sensor : virtual public TelemetrySensor {
 private:
     Adafruit_BME280 bme280;
 
+protected:
+    virtual void setup() override;
+
 public:
     BME280Sensor();
     virtual int32_t runOnce() override;
-    virtual bool getMeasurement(Telemetry *measurement) override;
+    virtual bool getMetrics(Telemetry *measurement) override;
 };    

src/modules/Telemetry/Sensor/BME680Sensor.cpp

@@ -4,22 +4,22 @@
 #include "BME680Sensor.h"
 #include <Adafruit_BME680.h>
 
-BME680Sensor::BME680Sensor() : TelemetrySensor {} 
+BME680Sensor::BME680Sensor() : 
+    TelemetrySensor(TelemetrySensorType_BME680, "BME680") 
 {
 }
 
 int32_t BME680Sensor::runOnce() {
-    unsigned bme680Status;
+    DEBUG_MSG("runOnce: TelemetrySensorType_BME680\n");
-    DEBUG_MSG("Init sensor: TelemetrySensorType_BME680\n");
+    if (!hasSensor()) {
-    if (!hasSensor(TelemetrySensorType_BME680)) {
         return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
     }
-    bme680Status = bme680.begin(nodeTelemetrySensorsMap[TelemetrySensorType_BME680]); 
+    status = bme680.begin(nodeTelemetrySensorsMap[TelemetrySensorType_BME680]); 
-    if (!bme680Status) {
+    return initI2CSensor();
-        DEBUG_MSG("Could not connect to any detected BME-680 sensor.\nRemoving from nodeTelemetrySensorsMap.\n");
+}
-        nodeTelemetrySensorsMap[TelemetrySensorType_BME680] = 0;
+
-    } else {
+void BME680Sensor::setup() 
-        DEBUG_MSG("Opened BME680 on default i2c bus\n");
+{
     // Set up oversampling and filter initialization
     bme680.setTemperatureOversampling(BME680_OS_8X);
     bme680.setHumidityOversampling(BME680_OS_2X);
@@ -27,11 +27,9 @@ int32_t BME680Sensor::runOnce() {
     bme680.setIIRFilterSize(BME680_FILTER_SIZE_3);
     bme680.setGasHeater(320, 150); // 320*C for 150 ms
 }
-    return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-}
 
-bool BME680Sensor::getMeasurement(Telemetry *measurement) {
+bool BME680Sensor::getMetrics(Telemetry *measurement) {
-    DEBUG_MSG("BME680Sensor::getMeasurement\n");
+    
     measurement->variant.environment_metrics.temperature = bme680.readTemperature();
     measurement->variant.environment_metrics.relative_humidity = bme680.readHumidity();
     measurement->variant.environment_metrics.barometric_pressure = bme680.readPressure() / 100.0F;

src/modules/Telemetry/Sensor/BME680Sensor.h

@@ -6,8 +6,11 @@ class BME680Sensor : virtual public TelemetrySensor {
 private:
     Adafruit_BME680 bme680;
 
+protected:
+    virtual void setup() override;
+    
 public:
     BME680Sensor();
     virtual int32_t runOnce() override;
-    virtual bool getMeasurement(Telemetry *measurement) override;
+    virtual bool getMetrics(Telemetry *measurement) override;
 };    

src/modules/Telemetry/Sensor/DHTSensor.cpp

@@ -5,10 +5,12 @@
 #include "configuration.h"
 #include <DHT.h>
 
-DHTSensor::DHTSensor() : TelemetrySensor{} {}
+DHTSensor::DHTSensor() : 
-
+    TelemetrySensor(TelemetrySensorType_NotSet, "DHT") 
-int32_t DHTSensor::runOnce()
 {
+}
+
+int32_t DHTSensor::runOnce() {
     if (moduleConfig.telemetry.environment_sensor_type == TelemetrySensorType_DHT11 || 
         moduleConfig.telemetry.environment_sensor_type == TelemetrySensorType_DHT12) {
         dht = new DHT(moduleConfig.telemetry.environment_sensor_pin, DHT11);
@@ -23,9 +25,10 @@ int32_t DHTSensor::runOnce()
     return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
 }
 
-bool DHTSensor::getMeasurement(Telemetry *measurement)
+void DHTSensor::setup() { }
-{
+
-    DEBUG_MSG("DHTSensor::getMeasurement\n");
+bool DHTSensor::getMetrics(Telemetry *measurement) {
+    DEBUG_MSG("DHTSensor::getMetrics\n");
     if (!dht->read(true)) {
         DEBUG_MSG("Telemetry: FAILED TO READ DATA\n");
         return false;

src/modules/Telemetry/Sensor/DHTSensor.h

@@ -6,8 +6,11 @@ class DHTSensor : virtual public TelemetrySensor {
 private:
     DHT *dht = NULL;
 
+protected:
+    virtual void setup() override;
+
 public:
     DHTSensor();
     virtual int32_t runOnce() override;
-    virtual bool getMeasurement(Telemetry *measurement) override;
+    virtual bool getMetrics(Telemetry *measurement) override;
 };    

src/modules/Telemetry/Sensor/DallasSensor.cpp

@@ -6,10 +6,12 @@
 #include <DS18B20.h>
 #include <OneWire.h>
 
-DallasSensor::DallasSensor() : TelemetrySensor{} {}
+DallasSensor::DallasSensor() : 
-
+    TelemetrySensor(TelemetrySensorType_DS18B20, "DS18B20") 
-int32_t DallasSensor::runOnce()
 {
+}
+
+int32_t DallasSensor::runOnce() {
     oneWire = new OneWire(moduleConfig.telemetry.environment_sensor_pin);
     ds18b20 = new DS18B20(oneWire);
     ds18b20->begin();
@@ -19,9 +21,10 @@ int32_t DallasSensor::runOnce()
     return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
 }
 
-bool DallasSensor::getMeasurement(Telemetry *measurement)
+void DallasSensor::setup() {}
-{
+
-    DEBUG_MSG("DallasSensor::getMeasurement\n");
+bool DallasSensor::getMetrics(Telemetry *measurement){
+    DEBUG_MSG("DallasSensor::getMetrics\n");
     if (ds18b20->isConversionComplete()) {
         measurement->variant.environment_metrics.temperature = ds18b20->getTempC();
         measurement->variant.environment_metrics.relative_humidity = 0;

src/modules/Telemetry/Sensor/DallasSensor.h

@@ -8,8 +8,11 @@ private:
     OneWire *oneWire = NULL;
     DS18B20 *ds18b20 = NULL;
 
+protected:
+    virtual void setup() override;
+
 public:
     DallasSensor();
     virtual int32_t runOnce() override;
-    virtual bool getMeasurement(Telemetry *measurement) override;
+    virtual bool getMetrics(Telemetry *measurement) override;
 };    

src/modules/Telemetry/Sensor/MCP9808Sensor.cpp

@@ -4,31 +4,26 @@
 #include "MCP9808Sensor.h"
 #include <Adafruit_MCP9808.h>
 
-MCP9808Sensor::MCP9808Sensor() : TelemetrySensor {} 
+MCP9808Sensor::MCP9808Sensor() : 
+    TelemetrySensor(TelemetrySensorType_MCP9808, "MCP9808") 
 {
 }
 
 int32_t MCP9808Sensor::runOnce() {
-    unsigned mcp9808Status;
     DEBUG_MSG("Init sensor: TelemetrySensorType_MCP9808\n");
-    if (!hasSensor(TelemetrySensorType_MCP9808)) {
+    if (!hasSensor()) {
         return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
     }
+    status = mcp9808.begin(nodeTelemetrySensorsMap[TelemetrySensorType_MCP9808]);
+    return initI2CSensor();
+}
 
-    mcp9808Status = mcp9808.begin(nodeTelemetrySensorsMap[TelemetrySensorType_MCP9808]); 
+void MCP9808Sensor::setup() {
-    if (!mcp9808Status) {
-        DEBUG_MSG("Could not connect to detected MCP9808 sensor.\n Removing from nodeTelemetrySensorsMap.\n");
-        nodeTelemetrySensorsMap[TelemetrySensorType_MCP9808] = 0;
-    } else {
-        DEBUG_MSG("TelemetrySensor: Opened MCP9808 on default i2c bus\n");
-        // Reduce resolution from 0.0625 degrees (precision) to 0.125 degrees (high). 
     mcp9808.setResolution(2);
 }
-    return (DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
-}
 
-bool MCP9808Sensor::getMeasurement(Telemetry *measurement) {
+bool MCP9808Sensor::getMetrics(Telemetry *measurement) {
-    DEBUG_MSG("MCP9808Sensor::getMeasurement\n");
+    DEBUG_MSG("MCP9808Sensor::getMetrics\n");
     measurement->variant.environment_metrics.temperature = mcp9808.readTempC();
     return true;
 }    

src/modules/Telemetry/Sensor/MCP9808Sensor.h

@@ -6,8 +6,11 @@ class MCP9808Sensor : virtual public TelemetrySensor {
 private:
     Adafruit_MCP9808 mcp9808;
 
+protected:
+    virtual void setup() override;
+    
 public:
     MCP9808Sensor();
     virtual int32_t runOnce() override;
-    virtual bool getMeasurement(Telemetry *measurement) override;
+    virtual bool getMetrics(Telemetry *measurement) override;
 };    

src/modules/Telemetry/Sensor/TelemetrySensor.cpp

@@ -0,0 +1,4 @@
+#include "TelemetrySensor.h"
+#include "../mesh/generated/telemetry.pb.h"
+#include "NodeDB.h"
+#include "main.h"

src/modules/Telemetry/Sensor/TelemetrySensor.h

@@ -5,16 +5,37 @@
 
 #define DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
 
-inline bool hasSensor(TelemetrySensorType sensorType) { 
-  return sensorType < sizeof(nodeTelemetrySensorsMap) && nodeTelemetrySensorsMap[sensorType] > 0;
-}
-
 class TelemetrySensor
 {
   protected:
-    TelemetrySensor() {}
+    TelemetrySensor(TelemetrySensorType sensorType, const char *sensorName)
+    {
+        this->sensorName = sensorName;
+        this->sensorType = sensorType;
+        this->status = 0;
+    }
+
+    const char *sensorName;
+    TelemetrySensorType sensorType;
+    unsigned status;
+
+    int32_t initI2CSensor() {
+        if (!status) {
+            DEBUG_MSG("Could not connect to detected %s sensor.\n Removing from nodeTelemetrySensorsMap.\n", sensorName);
+            nodeTelemetrySensorsMap[sensorType] = 0;
+        } else {
+            DEBUG_MSG("Opened %s sensor on default i2c bus\n", sensorName);
+            setup();
+        }
+        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    }
+    virtual void setup();
 
   public:
+    bool hasSensor() { 
+        return sensorType < sizeof(nodeTelemetrySensorsMap) && nodeTelemetrySensorsMap[sensorType] > 0; 
+    }
+
     virtual int32_t runOnce() = 0;
-    virtual bool getMeasurement(Telemetry *measurement) = 0;
+    virtual bool getMetrics(Telemetry *measurement) = 0;
 };