Create sensor classes that can be shared across variants

src/helpers/sensors/AHTX0Sensor.h

@@ -0,0 +1,39 @@
+#pragma once
+#include <Mesh.h>
+#include <Adafruit_AHTX0.h>
+
+#define TELEM_AHTX_ADDRESS    0x38      // AHT10, AHT20 temperature and humidity sensor I2C address
+
+static Adafruit_AHTX0 AHTX0;
+
+class AHTX0Sensor {
+    bool initialized = false;
+public:    
+    void begin() {
+        if (AHTX0.begin(&Wire, 0, TELEM_AHTX_ADDRESS)) {
+            MESH_DEBUG_PRINTLN("Found AHT10/AHT20 at address: %02X", TELEM_AHTX_ADDRESS);
+            initialized = true;
+        } else {
+            initialized = false;
+            MESH_DEBUG_PRINTLN("AHT10/AHT20 was not found at I2C address %02X", TELEM_AHTX_ADDRESS);
+        }
+    }
+
+    bool isInitialized() const { return initialized; };
+
+    float getRelativeHumidity() const {
+        if (initialized) {
+            sensors_event_t humidity, temp;
+            AHTX0.getEvent(&humidity, &temp);
+            return humidity.relative_humidity;
+        }
+    }
+
+    float getTemperature() const {
+        if (initialized) {
+            sensors_event_t humidity, temp;
+            AHTX0.getEvent(&humidity, &temp);
+            return temp.temperature;
+        }
+    }
+};

src/helpers/sensors/EnvironmentSensorManager.cpp

@@ -0,0 +1,67 @@
+#include "EnvironmentSensorManager.h"
+
+bool EnvironmentSensorManager::begin() {
+  INA3221_sensor.begin();
+  INA219_sensor.begin();
+  AHTX0_sensor.begin();
+
+  return true;
+}
+
+bool EnvironmentSensorManager::querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) {
+  next_available_channel = TELEM_CHANNEL_SELF + 1;
+  if (requester_permissions & TELEM_PERM_ENVIRONMENT) {
+    if (INA3221_sensor.isInitialized()) {
+      for(int i = 0; i < 3; i++) {
+        // add only enabled INA3221 channels to telemetry
+        if (INA3221_sensor.getChannelEnabled(i)) {
+          telemetry.addVoltage(next_available_channel, INA3221_sensor.getVoltage(i));
+          telemetry.addCurrent(next_available_channel, INA3221_sensor.getCurrent(i));
+          telemetry.addPower(next_available_channel, INA3221_sensor.getPower(i));
+          next_available_channel++;
+        }
+      }
+    }
+    if (INA219_sensor.isInitialized()) {
+        telemetry.addVoltage(next_available_channel, INA219_sensor.getVoltage());
+        telemetry.addCurrent(next_available_channel, INA219_sensor.getCurrent());
+        telemetry.addPower(next_available_channel, INA219_sensor.getPower());
+        next_available_channel++;
+    }
+    if (AHTX0_sensor.isInitialized()) {
+        telemetry.addTemperature(TELEM_CHANNEL_SELF, AHTX0_sensor.getTemperature());
+        telemetry.addRelativeHumidity(TELEM_CHANNEL_SELF, AHTX0_sensor.getRelativeHumidity());
+    }
+  }
+
+  return true;
+}
+
+int EnvironmentSensorManager::getNumSettings() const {
+  return NUM_SENSOR_SETTINGS;
+}
+
+const char* EnvironmentSensorManager::getSettingName(int i) const {
+  if (i >= 0 && i < NUM_SENSOR_SETTINGS) {
+    return INA3221_CHANNEL_NAMES[i];
+  }
+  return NULL;
+}
+
+const char* EnvironmentSensorManager::getSettingValue(int i) const {
+  if (i >= 0 && i < NUM_SENSOR_SETTINGS) {
+    return INA3221_sensor.getChannelEnabled(i) == true ? "1" : "0";
+  }
+  return NULL;
+}
+
+bool EnvironmentSensorManager::setSettingValue(const char* name, const char* value) {
+  for (int i = 0; i < NUM_SENSOR_SETTINGS; i++) {
+    if (strcmp(name, INA3221_CHANNEL_NAMES[i]) == 0) {
+        bool channel_enabled = strcmp(value, "1") == 0 ? true : false;
+        INA3221_sensor.setChannelEnabled(i, channel_enabled);
+        return true;
+    }
+  }
+  return false;
+}

src/helpers/sensors/EnvironmentSensorManager.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <helpers/SensorManager.h>
+#include "INA3221Sensor.h"
+#include "INA219Sensor.h"
+#include "AHTX0Sensor.h"
+
+#define NUM_SENSOR_SETTINGS 3
+#define TELEM_INA3221_SETTING_CH1 "INA3221-1"
+#define TELEM_INA3221_SETTING_CH2 "INA3221-2"
+#define TELEM_INA3221_SETTING_CH3 "INA3221-3"
+
+class EnvironmentSensorManager : public SensorManager {
+// INA3221 channels in telemetry
+const char * INA3221_CHANNEL_NAMES[NUM_SENSOR_SETTINGS] = { TELEM_INA3221_SETTING_CH1, TELEM_INA3221_SETTING_CH2, TELEM_INA3221_SETTING_CH3};
+
+protected:
+  int next_available_channel = TELEM_CHANNEL_SELF + 1;
+  INA3221Sensor INA3221_sensor;
+  AHTX0Sensor AHTX0_sensor;
+  INA219Sensor INA219_sensor;
+public:
+  EnvironmentSensorManager(){};
+  bool begin() override;
+  bool querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) override;
+  int getNumSettings() const override;
+  const char* getSettingName(int i) const override;
+  const char* getSettingValue(int i) const override;
+  bool setSettingValue(const char* name, const char* value) override;
+};

src/helpers/sensors/INA219Sensor.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <Mesh.h>
+#include <INA219.h>
+
+#define TELEM_INA219_ADDRESS  0x40      // INA219 single channel current sensor I2C address
+#define TELEM_INA219_SHUNT_VALUE 0.100  // shunt value in ohms (may differ between manufacturers)
+#define TELEM_INA219_MAX_CURRENT 5
+
+static INA219 INA_219(TELEM_INA219_ADDRESS, &Wire);
+
+class INA219Sensor {
+    bool initialized = false;
+public:    
+    void begin() {
+        if (INA_219.begin()) {
+            MESH_DEBUG_PRINTLN("Found INA219 at address: %02X", INA_219.getAddress());
+            INA_219.setMaxCurrentShunt(TELEM_INA219_MAX_CURRENT, TELEM_INA219_SHUNT_VALUE);
+            initialized = true;
+        } else {
+            initialized = false;
+            MESH_DEBUG_PRINTLN("INA219 was not found at I2C address %02X", TELEM_INA219_ADDRESS);
+        }
+    }
+
+    bool isInitialized() const { return initialized; }
+
+    float getVoltage() const {
+        if (initialized) {
+            return INA_219.getBusVoltage();    
+        }
+        return 0;
+    }
+
+    float getCurrent() const {
+        if (initialized) {
+            return INA_219.getCurrent();    
+        }
+        return 0;
+    }
+
+    float getPower() const {
+        if (initialized) {
+            return INA_219.getPower();    
+        }
+        return 0;
+    }
+};

src/helpers/sensors/INA3221Sensor.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <Mesh.h>
+#include <INA3221.h>
+
+#define TELEM_INA3221_ADDRESS 0x42      // INA3221 3 channel current sensor I2C address
+#define TELEM_INA3221_SHUNT_VALUE 0.100 // most variants will have a 0.1 ohm shunts
+
+#define NUM_CHANNELS 3
+
+static INA3221 INA_3221(TELEM_INA3221_ADDRESS, &Wire);
+
+class INA3221Sensor {
+    bool initialized = false;
+
+public:
+    void begin() {
+        if (INA_3221.begin()) {
+            MESH_DEBUG_PRINTLN("Found INA3221 at address: %02X", INA_3221.getAddress());
+            MESH_DEBUG_PRINTLN("%04X %04X %04X", INA_3221.getDieID(), INA_3221.getManufacturerID(), INA_3221.getConfiguration());
+
+            for(int i = 0; i < 3; i++) {
+            INA_3221.setShuntR(i, TELEM_INA3221_SHUNT_VALUE);
+            }
+            initialized = true;
+        } else {
+            initialized = false;
+            MESH_DEBUG_PRINTLN("INA3221 was not found at I2C address %02X", TELEM_INA3221_ADDRESS);
+        }
+    }
+
+    bool isInitialized() const { return initialized; }
+
+    int numChannels() const { return NUM_CHANNELS; }
+
+    float getVoltage(int channel) const {
+        if (initialized && channel >=0 && channel < NUM_CHANNELS) {
+            return INA_3221.getBusVoltage(channel);
+        }
+        return 0;
+    }
+
+    float getCurrent(int channel) const {
+        if (initialized && channel >=0 && channel < NUM_CHANNELS) {
+            return INA_3221.getCurrent(channel);
+        }
+        return 0;
+    }
+
+    float getPower (int channel) const {
+        if (initialized && channel >=0 && channel < NUM_CHANNELS) {
+            return INA_3221.getPower(channel);
+        }
+        return 0;
+    }
+
+    bool setChannelEnabled(int channel, bool enabled) {
+        if (initialized && channel >=0 && channel < NUM_CHANNELS) {
+            INA_3221.enableChannel(channel);
+            return true;
+        }
+        return false;
+    }
+
+    bool getChannelEnabled(int channel) const {
+        if (initialized && channel >=0 && channel < NUM_CHANNELS) {
+            return INA_3221.getEnableChannel(channel);
+        }
+        return false;
+    }
+};