mv plugins/ to modules/

src/modules/Telemetry/Sensor/BME280Sensor.cpp

@@ -0,0 +1,29 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "configuration.h"
+#include "TelemetrySensor.h"
+#include "BME280Sensor.h"
+#include <Adafruit_BME280.h>
+
+BME280Sensor::BME280Sensor() : TelemetrySensor {} {
+}
+
+int32_t BME280Sensor::runOnce() {
+    unsigned bme280Status;
+    // Default i2c address for BME280
+    bme280Status = bme280.begin(0x76); 
+    if (!bme280Status) {
+        DEBUG_MSG("Could not find a valid BME280 sensor, check wiring, address, sensor ID!");
+        // TODO more verbose diagnostics
+    } else {
+        DEBUG_MSG("Telemetry: Opened BME280 on default i2c bus");
+    }
+    return BME_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+}
+
+bool BME280Sensor::getMeasurement(Telemetry *measurement) {
+    measurement->temperature = bme280.readTemperature();
+    measurement->relative_humidity = bme280.readHumidity();
+    measurement->barometric_pressure = bme280.readPressure() / 100.0F;
+
+    return true;
+}    

src/modules/Telemetry/Sensor/BME280Sensor.h

@@ -0,0 +1,15 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_BME280.h>
+
+#define BME_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
+
+class BME280Sensor : virtual public TelemetrySensor {
+private:
+    Adafruit_BME280 bme280;
+
+public:
+    BME280Sensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMeasurement(Telemetry *measurement) override;
+};    

src/modules/Telemetry/Sensor/BME680Sensor.cpp

@@ -0,0 +1,36 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "configuration.h"
+#include "TelemetrySensor.h"
+#include "BME680Sensor.h"
+#include <Adafruit_BME680.h>
+
+BME680Sensor::BME680Sensor() : TelemetrySensor {} {
+}
+
+int32_t BME680Sensor::runOnce() {
+    unsigned bme680Status;
+    // Default i2c address for BME680
+    bme680Status = bme680.begin(0x76); 
+    if (!bme680Status) {
+        DEBUG_MSG("Could not find a valid BME680 sensor, check wiring, address, sensor ID!");
+        // TODO more verbose TelemetrySensor
+    } else {
+        DEBUG_MSG("Telemetry: Opened BME680 on default i2c bus");
+        // Set up oversampling and filter initialization
+        bme680.setTemperatureOversampling(BME680_OS_8X);
+        bme680.setHumidityOversampling(BME680_OS_2X);
+        bme680.setPressureOversampling(BME680_OS_4X);
+        bme680.setIIRFilterSize(BME680_FILTER_SIZE_3);
+        bme680.setGasHeater(320, 150); // 320*C for 150 ms
+    }
+    return (BME_680_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+}
+
+bool BME680Sensor::getMeasurement(Telemetry *measurement) {
+    measurement->temperature = bme680.readTemperature();
+    measurement->relative_humidity = bme680.readHumidity();
+    measurement->barometric_pressure = bme680.readPressure() / 100.0F;
+    measurement->gas_resistance = bme680.readGas() / 1000.0;
+
+    return true;
+}    

src/modules/Telemetry/Sensor/BME680Sensor.h

@@ -0,0 +1,15 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_BME680.h>
+
+#define BME_680_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
+
+class BME680Sensor : virtual public TelemetrySensor {
+private:
+    Adafruit_BME680 bme680;
+
+public:
+    BME680Sensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMeasurement(Telemetry *measurement) override;
+};    

src/modules/Telemetry/Sensor/DHTSensor.cpp

@@ -0,0 +1,36 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "configuration.h"
+#include "MeshService.h"
+#include "TelemetrySensor.h"
+#include "DHTSensor.h"
+#include <DHT.h>
+
+DHTSensor::DHTSensor() : TelemetrySensor {} {
+}
+
+int32_t DHTSensor::runOnce() {
+    if (RadioConfig_UserPreferences_TelemetrySensorType_DHT11 || 
+        RadioConfig_UserPreferences_TelemetrySensorType_DHT12) {
+        dht = new DHT(radioConfig.preferences.telemetry_module_sensor_pin, DHT11);
+    }
+    else { 
+        dht = new DHT(radioConfig.preferences.telemetry_module_sensor_pin, DHT22);
+    }
+
+    dht->begin();
+    dht->read();
+    DEBUG_MSG("Telemetry: Opened DHT11/DHT12 on pin: %d\n",
+                radioConfig.preferences.telemetry_module_sensor_pin);
+
+    return (DHT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+}
+
+bool DHTSensor::getMeasurement(Telemetry *measurement) {
+    if (!dht->read(true)) {
+        DEBUG_MSG("Telemetry: FAILED TO READ DATA\n");
+        return false;
+    }
+    measurement->relative_humidity = dht->readHumidity();
+    measurement->temperature = dht->readTemperature();
+    return true;
+}    

src/modules/Telemetry/Sensor/DHTSensor.h

@@ -0,0 +1,15 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <DHT.h>
+
+#define DHT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
+
+class DHTSensor : virtual public TelemetrySensor {
+private:
+    DHT *dht = NULL;
+
+public:
+    DHTSensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMeasurement(Telemetry *measurement) override;
+};    

src/modules/Telemetry/Sensor/DallasSensor.cpp

@@ -0,0 +1,31 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "configuration.h"
+#include "MeshService.h"
+#include "TelemetrySensor.h"
+#include "DallasSensor.h"
+#include <DS18B20.h>
+#include <OneWire.h>
+
+DallasSensor::DallasSensor() : TelemetrySensor {} {
+}
+
+int32_t DallasSensor::runOnce() {
+    oneWire = new OneWire(radioConfig.preferences.telemetry_module_sensor_pin);
+    ds18b20 = new DS18B20(oneWire);
+    ds18b20->begin();
+    ds18b20->setResolution(12);
+    ds18b20->requestTemperatures();
+    DEBUG_MSG("Telemetry: Opened DS18B20 on pin: %d\n",
+                radioConfig.preferences.telemetry_module_sensor_pin);
+    return (DS18B20_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+}
+
+bool DallasSensor::getMeasurement(Telemetry *measurement) {
+    if (ds18b20->isConversionComplete()) {
+        measurement->temperature = ds18b20->getTempC();
+        measurement->relative_humidity = 0;
+        ds18b20->requestTemperatures();
+        return true;
+    } 
+    return false;
+}

src/modules/Telemetry/Sensor/DallasSensor.h

@@ -0,0 +1,17 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <DS18B20.h>
+#include <OneWire.h>
+
+#define DS18B20_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
+
+class DallasSensor : virtual public TelemetrySensor {
+private:
+    OneWire *oneWire = NULL;
+    DS18B20 *ds18b20 = NULL;
+
+public:
+    DallasSensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMeasurement(Telemetry *measurement) override;
+};    

src/modules/Telemetry/Sensor/MCP9808Sensor.cpp

@@ -0,0 +1,28 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "configuration.h"
+#include "TelemetrySensor.h"
+#include "MCP9808Sensor.h"
+#include <Adafruit_MCP9808.h>
+
+MCP9808Sensor::MCP9808Sensor() : TelemetrySensor {} {
+}
+
+int32_t MCP9808Sensor::runOnce() {
+    unsigned mcp9808Status;
+    // Default i2c address for MCP9808
+    mcp9808Status = mcp9808.begin(0x18); 
+    if (!mcp9808Status) {
+        DEBUG_MSG("Could not find a valid MCP9808 sensor, check wiring, address, sensor ID!");
+    } else {
+        DEBUG_MSG("TelemetrySensor: Opened MCP9808 on default i2c bus");
+        // Reduce resolution from 0.0625 degrees (precision) to 0.125 degrees (high). 
+        mcp9808.setResolution(2);
+    }
+    return (MCP_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+}
+
+bool MCP9808Sensor::getMeasurement(Telemetry *measurement) {
+    measurement->temperature = mcp9808.readTempC();
+
+    return true;
+}    

src/modules/Telemetry/Sensor/MCP9808Sensor.h

@@ -0,0 +1,15 @@
+#include "../mesh/generated/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_MCP9808.h>
+
+#define MCP_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
+
+class MCP9808Sensor : virtual public TelemetrySensor {
+private:
+    Adafruit_MCP9808 mcp9808;
+
+public:
+    MCP9808Sensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMeasurement(Telemetry *measurement) override;
+};    

src/modules/Telemetry/Sensor/TelemetrySensor.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "../mesh/generated/telemetry.pb.h"
+#define DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000
+
+class TelemetrySensor {
+protected:
+    TelemetrySensor() { }
+
+public:
+    virtual int32_t runOnce() = 0;
+    virtual bool getMeasurement(Telemetry *measurement)  = 0;
+};