rework sensor instantiation to saves memory by removing the static allocation (#8054)

* rework I2C sensor init

the goal is to only instantiate sensors that are pressend to save memory.
side effacts:
 - easyer sensor integration (less C&P code)
 - nodeTelemetrySensorsMap can be removed when all devices are migrated

* add missing ifdef

* refactor a bunch of more sensors

RAM -816
Flash -916

* fix build for t1000

* refactor more sensors

RAM -192
Flash -60

* improve error handling

Flash -112

* fix build

* fix build

* fix IndicatorSensor

* fix tracker-t1000-e build

not sure what magic is used but it works

* Apply suggestion from @Copilot

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Apply suggestion from @Copilot

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Apply suggestion from @Copilot

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update src/modules/Telemetry/Sensor/DFRobotGravitySensor.h

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Fix

---------

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

src/modules/Telemetry/Sensor/AHT10.cpp

@@ -15,20 +15,16 @@
 
 AHT10Sensor::AHT10Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_AHT10, "AHT10") {}
 
-int32_t AHT10Sensor::runOnce()
+bool AHT10Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
     aht10 = Adafruit_AHTX0();
-    status = aht10.begin(nodeTelemetrySensorsMap[sensorType].second, 0, nodeTelemetrySensorsMap[sensorType].first);
+    status = aht10.begin(bus, 0, dev->address.address);
 
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
-void AHT10Sensor::setup() {}
-
 bool AHT10Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
     LOG_DEBUG("AHT10 getMetrics");
@@ -36,11 +32,16 @@ bool AHT10Sensor::getMetrics(meshtastic_Telemetry *measurement)
     sensors_event_t humidity, temp;
     aht10.getEvent(&humidity, &temp);
 
-    measurement->variant.environment_metrics.has_temperature = true;
-    measurement->variant.environment_metrics.has_relative_humidity = true;
+    // prefer other sensors like bmp280, bmp3xx
+    if (!measurement->variant.environment_metrics.has_temperature) {
+        measurement->variant.environment_metrics.has_temperature = true;
+        measurement->variant.environment_metrics.temperature = temp.temperature;
+    }
 
-    measurement->variant.environment_metrics.temperature = temp.temperature;
-    measurement->variant.environment_metrics.relative_humidity = humidity.relative_humidity;
+    if (!measurement->variant.environment_metrics.has_relative_humidity) {
+        measurement->variant.environment_metrics.has_relative_humidity = true;
+        measurement->variant.environment_metrics.relative_humidity = humidity.relative_humidity;
+    }
 
     return true;
 }

src/modules/Telemetry/Sensor/AHT10.h

@@ -15,13 +15,10 @@ class AHT10Sensor : public TelemetrySensor
   private:
     Adafruit_AHTX0 aht10;
 
-  protected:
-    virtual void setup() override;
-
   public:
     AHT10Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/BME280Sensor.cpp

@@ -10,13 +10,13 @@
 
 BME280Sensor::BME280Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_BME280, "BME280") {}
 
-int32_t BME280Sensor::runOnce()
+bool BME280Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    status = bme280.begin(dev->address.address, bus);
+    if (!status) {
+        return status;
     }
-    status = bme280.begin(nodeTelemetrySensorsMap[sensorType].first, nodeTelemetrySensorsMap[sensorType].second);
 
     bme280.setSampling(Adafruit_BME280::MODE_FORCED,
                        Adafruit_BME280::SAMPLING_X1, // Temp. oversampling
@@ -24,11 +24,10 @@ int32_t BME280Sensor::runOnce()
                        Adafruit_BME280::SAMPLING_X1, // Humidity oversampling
                        Adafruit_BME280::FILTER_OFF, Adafruit_BME280::STANDBY_MS_1000);
 
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
-void BME280Sensor::setup() {}
-
 bool BME280Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
     measurement->variant.environment_metrics.has_temperature = true;

src/modules/Telemetry/Sensor/BME280Sensor.h

@@ -11,13 +11,10 @@ class BME280Sensor : public TelemetrySensor
   private:
     Adafruit_BME280 bme280;
 
-  protected:
-    virtual void setup() override;
-
   public:
     BME280Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/BME680Sensor.cpp

@@ -10,7 +10,7 @@
 
 BME680Sensor::BME680Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_BME680, "BME680") {}
 
-int32_t BME680Sensor::runTrigger()
+int32_t BME680Sensor::runOnce()
 {
     if (!bme680.run()) {
         checkStatus("runTrigger");
@@ -18,13 +18,10 @@ int32_t BME680Sensor::runTrigger()
     return 35;
 }
 
-int32_t BME680Sensor::runOnce()
+bool BME680Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
-
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
-    if (!bme680.begin(nodeTelemetrySensorsMap[sensorType].first, *nodeTelemetrySensorsMap[sensorType].second))
+    status = 0;
+    if (!bme680.begin(dev->address.address, *bus))
         checkStatus("begin");
 
     if (bme680.status == BSEC_OK) {
@@ -40,17 +37,15 @@ int32_t BME680Sensor::runOnce()
         }
         LOG_INFO("Init sensor: %s with the BSEC Library version %d.%d.%d.%d ", sensorName, bme680.version.major,
                  bme680.version.minor, bme680.version.major_bugfix, bme680.version.minor_bugfix);
-    } else {
-        status = 0;
     }
+
     if (status == 0)
         LOG_DEBUG("BME680Sensor::runOnce: bme680.status %d", bme680.status);
 
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
-void BME680Sensor::setup() {}
-
 bool BME680Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
     if (bme680.getData(BSEC_OUTPUT_RAW_PRESSURE).signal == 0)

src/modules/Telemetry/Sensor/BME680Sensor.h

@@ -18,7 +18,6 @@ class BME680Sensor : public TelemetrySensor
     Bsec2 bme680;
 
   protected:
-    virtual void setup() override;
     const char *bsecConfigFileName = "/prefs/bsec.dat";
     uint8_t bsecState[BSEC_MAX_STATE_BLOB_SIZE] = {0};
     uint8_t accuracy = 0;
@@ -38,9 +37,9 @@ class BME680Sensor : public TelemetrySensor
 
   public:
     BME680Sensor();
-    int32_t runTrigger();
     virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/BMP085Sensor.cpp

@@ -10,20 +10,17 @@
 
 BMP085Sensor::BMP085Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_BMP085, "BMP085") {}
 
-int32_t BMP085Sensor::runOnce()
+bool BMP085Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
+
     bmp085 = Adafruit_BMP085();
-    status = bmp085.begin(nodeTelemetrySensorsMap[sensorType].first, nodeTelemetrySensorsMap[sensorType].second);
+    status = bmp085.begin(dev->address.address, bus);
 
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
-void BMP085Sensor::setup() {}
-
 bool BMP085Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
     measurement->variant.environment_metrics.has_temperature = true;

src/modules/Telemetry/Sensor/BMP085Sensor.h

@@ -11,13 +11,10 @@ class BMP085Sensor : public TelemetrySensor
   private:
     Adafruit_BMP085 bmp085;
 
-  protected:
-    virtual void setup() override;
-
   public:
     BMP085Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/BMP280Sensor.cpp

@@ -10,25 +10,25 @@
 
 BMP280Sensor::BMP280Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_BMP280, "BMP280") {}
 
-int32_t BMP280Sensor::runOnce()
+bool BMP280Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+
+    bmp280 = Adafruit_BMP280(bus);
+    status = bmp280.begin(dev->address.address);
+    if (!status) {
+        return status;
     }
-    bmp280 = Adafruit_BMP280(nodeTelemetrySensorsMap[sensorType].second);
-    status = bmp280.begin(nodeTelemetrySensorsMap[sensorType].first);
 
     bmp280.setSampling(Adafruit_BMP280::MODE_FORCED,
                        Adafruit_BMP280::SAMPLING_X1, // Temp. oversampling
                        Adafruit_BMP280::SAMPLING_X1, // Pressure oversampling
                        Adafruit_BMP280::FILTER_OFF, Adafruit_BMP280::STANDBY_MS_1000);
 
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
-void BMP280Sensor::setup() {}
-
 bool BMP280Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
     measurement->variant.environment_metrics.has_temperature = true;

src/modules/Telemetry/Sensor/BMP280Sensor.h

@@ -11,13 +11,10 @@ class BMP280Sensor : public TelemetrySensor
   private:
     Adafruit_BMP280 bmp280;
 
-  protected:
-    virtual void setup() override;
-
   public:
     BMP280Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/BMP3XXSensor.cpp

@@ -6,20 +6,18 @@
 
 BMP3XXSensor::BMP3XXSensor() : TelemetrySensor(meshtastic_TelemetrySensorType_BMP3XX, "BMP3XX") {}
 
-void BMP3XXSensor::setup() {}
-
-int32_t BMP3XXSensor::runOnce()
+bool BMP3XXSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
 
     // Get a singleton instance and initialise the bmp3xx
     if (bmp3xx == nullptr) {
         bmp3xx = BMP3XXSingleton::GetInstance();
     }
-    status = bmp3xx->begin_I2C(nodeTelemetrySensorsMap[sensorType].first, nodeTelemetrySensorsMap[sensorType].second);
+    status = bmp3xx->begin_I2C(dev->address.address, bus);
+    if (!status) {
+        return status;
+    }
 
     // set up oversampling and filter initialization
     bmp3xx->setTemperatureOversampling(BMP3_OVERSAMPLING_4X);
@@ -31,7 +29,8 @@ int32_t BMP3XXSensor::runOnce()
     for (int i = 0; i < 3; i++) {
         bmp3xx->performReading();
     }
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
 bool BMP3XXSensor::getMetrics(meshtastic_Telemetry *measurement)

src/modules/Telemetry/Sensor/BMP3XXSensor.h

@@ -43,12 +43,11 @@ class BMP3XXSensor : public TelemetrySensor
 {
   protected:
     BMP3XXSingleton *bmp3xx = nullptr;
-    virtual void setup() override;
 
   public:
     BMP3XXSensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/CGRadSensSensor.cpp

@@ -14,22 +14,16 @@
 
 CGRadSensSensor::CGRadSensSensor() : TelemetrySensor(meshtastic_TelemetrySensorType_RADSENS, "RadSens") {}
 
-int32_t CGRadSensSensor::runOnce()
+bool CGRadSensSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     // Initialize the sensor following the same pattern as RCWL9620Sensor
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
-
     status = true;
-    begin(nodeTelemetrySensorsMap[sensorType].second, nodeTelemetrySensorsMap[sensorType].first);
-
-    return initI2CSensor();
+    begin(bus, dev->address.address);
+    initI2CSensor();
+    return status;
 }
 
-void CGRadSensSensor::setup() {}
-
 void CGRadSensSensor::begin(TwoWire *wire, uint8_t addr)
 {
     // Store the Wire and address to the sensor following the same pattern as RCWL9620Sensor

src/modules/Telemetry/Sensor/CGRadSensSensor.h

@@ -17,14 +17,13 @@ class CGRadSensSensor : public TelemetrySensor
     TwoWire *_wire = &Wire;
 
   protected:
-    virtual void setup() override;
     void begin(TwoWire *wire = &Wire, uint8_t addr = 0x66);
     float getStaticRadiation();
 
   public:
     CGRadSensSensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/DFRobotGravitySensor.cpp

@@ -10,31 +10,39 @@
 
 DFRobotGravitySensor::DFRobotGravitySensor() : TelemetrySensor(meshtastic_TelemetrySensorType_DFROBOT_RAIN, "DFROBOT_RAIN") {}
 
-int32_t DFRobotGravitySensor::runOnce()
+DFRobotGravitySensor::~DFRobotGravitySensor()
 {
-    LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    if (gravity) {
+        delete gravity;
+        gravity = nullptr;
     }
-
-    gravity = DFRobot_RainfallSensor_I2C(nodeTelemetrySensorsMap[sensorType].second);
-    status = gravity.begin();
-
-    return initI2CSensor();
 }
 
-void DFRobotGravitySensor::setup()
+bool DFRobotGravitySensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
-    LOG_DEBUG("%s VID: %x, PID: %x, Version: %s", sensorName, gravity.vid, gravity.pid, gravity.getFirmwareVersion().c_str());
+    LOG_INFO("Init sensor: %s", sensorName);
+
+    gravity = new DFRobot_RainfallSensor_I2C(bus);
+    status = gravity->begin();
+
+    LOG_DEBUG("%s VID: %x, PID: %x, Version: %s", sensorName, gravity->vid, gravity->pid, gravity->getFirmwareVersion().c_str());
+
+    initI2CSensor();
+    return status;
 }
 
 bool DFRobotGravitySensor::getMetrics(meshtastic_Telemetry *measurement)
 {
+    if (!gravity) {
+        LOG_ERROR("DFRobotGravitySensor not initialized");
+        return false;
+    }
+
     measurement->variant.environment_metrics.has_rainfall_1h = true;
     measurement->variant.environment_metrics.has_rainfall_24h = true;
 
-    measurement->variant.environment_metrics.rainfall_1h = gravity.getRainfall(1);
-    measurement->variant.environment_metrics.rainfall_24h = gravity.getRainfall(24);
+    measurement->variant.environment_metrics.rainfall_1h = gravity->getRainfall(1);
+    measurement->variant.environment_metrics.rainfall_24h = gravity->getRainfall(24);
 
     LOG_INFO("Rain 1h: %f mm", measurement->variant.environment_metrics.rainfall_1h);
     LOG_INFO("Rain 24h: %f mm", measurement->variant.environment_metrics.rainfall_24h);

src/modules/Telemetry/Sensor/DFRobotGravitySensor.h

@@ -14,15 +14,13 @@
 class DFRobotGravitySensor : public TelemetrySensor
 {
   private:
-    DFRobot_RainfallSensor_I2C gravity = DFRobot_RainfallSensor_I2C(nodeTelemetrySensorsMap[sensorType].second);
-
-  protected:
-    virtual void setup() override;
+    DFRobot_RainfallSensor_I2C *gravity = nullptr;
 
   public:
     DFRobotGravitySensor();
-    virtual int32_t runOnce() override;
+    ~DFRobotGravitySensor();
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/DFRobotLarkSensor.cpp

@@ -11,14 +11,10 @@
 
 DFRobotLarkSensor::DFRobotLarkSensor() : TelemetrySensor(meshtastic_TelemetrySensorType_DFROBOT_LARK, "DFROBOT_LARK") {}
 
-int32_t DFRobotLarkSensor::runOnce()
+bool DFRobotLarkSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
-
-    lark = DFRobot_LarkWeatherStation_I2C(nodeTelemetrySensorsMap[sensorType].first, nodeTelemetrySensorsMap[sensorType].second);
+    lark = DFRobot_LarkWeatherStation_I2C(dev->address.address, bus);
 
     if (lark.begin() == 0) // DFRobotLarkSensor init
     {
@@ -28,11 +24,10 @@ int32_t DFRobotLarkSensor::runOnce()
         LOG_ERROR("DFRobotLarkSensor Init Failed");
         status = false;
     }
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
-void DFRobotLarkSensor::setup() {}
-
 bool DFRobotLarkSensor::getMetrics(meshtastic_Telemetry *measurement)
 {
     measurement->variant.environment_metrics.has_temperature = true;

src/modules/Telemetry/Sensor/DFRobotLarkSensor.h

@@ -16,13 +16,10 @@ class DFRobotLarkSensor : public TelemetrySensor
   private:
     DFRobot_LarkWeatherStation_I2C lark = DFRobot_LarkWeatherStation_I2C();
 
-  protected:
-    virtual void setup() override;
-
   public:
     DFRobotLarkSensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/DPS310Sensor.cpp

@@ -9,23 +9,22 @@
 
 DPS310Sensor::DPS310Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_DPS310, "DPS310") {}
 
-int32_t DPS310Sensor::runOnce()
+bool DPS310Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    status = dps310.begin_I2C(dev->address.address, bus);
+    if (!status) {
+        return status;
     }
-    status = dps310.begin_I2C(nodeTelemetrySensorsMap[sensorType].first, nodeTelemetrySensorsMap[sensorType].second);
 
     dps310.configurePressure(DPS310_1HZ, DPS310_4SAMPLES);
     dps310.configureTemperature(DPS310_1HZ, DPS310_4SAMPLES);
     dps310.setMode(DPS310_CONT_PRESTEMP);
 
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
-void DPS310Sensor::setup() {}
-
 bool DPS310Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
     sensors_event_t temp, press;

src/modules/Telemetry/Sensor/DPS310Sensor.h

@@ -11,13 +11,10 @@ class DPS310Sensor : public TelemetrySensor
   private:
     Adafruit_DPS310 dps310;
 
-  protected:
-    virtual void setup() override;
-
   public:
     DPS310Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/IndicatorSensor.cpp

@@ -61,11 +61,11 @@ static int cmd_send(uint8_t cmd, const char *p_data, uint8_t len)
     return -1;
 }
 
-int32_t IndicatorSensor::runOnce()
+bool IndicatorSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("%s: init", sensorName);
     setup();
-    return 2 * DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS; // give it some time to start up
+    return true;
 }
 
 void IndicatorSensor::setup()

src/modules/Telemetry/Sensor/IndicatorSensor.h

@@ -7,13 +7,13 @@
 
 class IndicatorSensor : public TelemetrySensor
 {
-  protected:
-    virtual void setup() override;
-
   public:
     IndicatorSensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
+
+  private:
+    void setup();
 };
 
 #endif

src/modules/Telemetry/Sensor/LPS22HBSensor.cpp

@@ -10,19 +10,17 @@
 
 LPS22HBSensor::LPS22HBSensor() : TelemetrySensor(meshtastic_TelemetrySensorType_LPS22, "LPS22HB") {}
 
-int32_t LPS22HBSensor::runOnce()
+bool LPS22HBSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    status = lps22hb.begin_I2C(dev->address.address, bus);
+    if (!status) {
+        return status;
     }
-    status = lps22hb.begin_I2C(nodeTelemetrySensorsMap[sensorType].first, nodeTelemetrySensorsMap[sensorType].second);
-    return initI2CSensor();
-}
-
-void LPS22HBSensor::setup()
-{
     lps22hb.setDataRate(LPS22_RATE_10_HZ);
+
+    initI2CSensor();
+    return status;
 }
 
 bool LPS22HBSensor::getMetrics(meshtastic_Telemetry *measurement)

src/modules/Telemetry/Sensor/LPS22HBSensor.h

@@ -12,13 +12,10 @@ class LPS22HBSensor : public TelemetrySensor
   private:
     Adafruit_LPS22 lps22hb;
 
-  protected:
-    virtual void setup() override;
-
   public:
     LPS22HBSensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/LTR390UVSensor.cpp

@@ -9,23 +9,23 @@
 
 LTR390UVSensor::LTR390UVSensor() : TelemetrySensor(meshtastic_TelemetrySensorType_LTR390UV, "LTR390UV") {}
 
-int32_t LTR390UVSensor::runOnce()
+bool LTR390UVSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+
+    status = ltr390uv.begin(bus);
+    if (!status) {
+        return status;
     }
 
-    status = ltr390uv.begin(nodeTelemetrySensorsMap[sensorType].second);
     ltr390uv.setMode(LTR390_MODE_UVS);
     ltr390uv.setGain(LTR390_GAIN_18);                // Datasheet default
     ltr390uv.setResolution(LTR390_RESOLUTION_20BIT); // Datasheet default
 
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
-void LTR390UVSensor::setup() {}
-
 bool LTR390UVSensor::getMetrics(meshtastic_Telemetry *measurement)
 {
     LOG_DEBUG("LTR390UV getMetrics");

src/modules/Telemetry/Sensor/LTR390UVSensor.h

@@ -13,13 +13,10 @@ class LTR390UVSensor : public TelemetrySensor
     float lastLuxReading = 0;
     float lastUVReading = 0;
 
-  protected:
-    virtual void setup() override;
-
   public:
     LTR390UVSensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/MCP9808Sensor.cpp

@@ -9,19 +9,17 @@
 
 MCP9808Sensor::MCP9808Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_MCP9808, "MCP9808") {}
 
-int32_t MCP9808Sensor::runOnce()
+bool MCP9808Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    status = mcp9808.begin(dev->address.address, bus);
+    if (!status) {
+        return status;
     }
-    status = mcp9808.begin(nodeTelemetrySensorsMap[sensorType].first, nodeTelemetrySensorsMap[sensorType].second);
-    return initI2CSensor();
-}
-
-void MCP9808Sensor::setup()
-{
     mcp9808.setResolution(2);
+
+    initI2CSensor();
+    return status;
 }
 
 bool MCP9808Sensor::getMetrics(meshtastic_Telemetry *measurement)

src/modules/Telemetry/Sensor/MCP9808Sensor.h

@@ -11,13 +11,10 @@ class MCP9808Sensor : public TelemetrySensor
   private:
     Adafruit_MCP9808 mcp9808;
 
-  protected:
-    virtual void setup() override;
-
   public:
     MCP9808Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/MLX90632Sensor.cpp

@@ -8,16 +8,12 @@
 
 MLX90632Sensor::MLX90632Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_MLX90632, "MLX90632") {}
 
-int32_t MLX90632Sensor::runOnce()
+bool MLX90632Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
 
     MLX90632::status returnError;
-    if (mlx.begin(nodeTelemetrySensorsMap[sensorType].first, *nodeTelemetrySensorsMap[sensorType].second, returnError) ==
-        true) // MLX90632 init
+    if (mlx.begin(dev->address.address, *bus, returnError) == true) // MLX90632 init
     {
         LOG_DEBUG("MLX90632 Init Succeed");
         status = true;
@@ -25,11 +21,10 @@ int32_t MLX90632Sensor::runOnce()
         LOG_ERROR("MLX90632 Init Failed");
         status = false;
     }
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
-void MLX90632Sensor::setup() {}
-
 bool MLX90632Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
     measurement->variant.environment_metrics.has_temperature = true;

src/modules/Telemetry/Sensor/MLX90632Sensor.h

@@ -11,13 +11,10 @@ class MLX90632Sensor : public TelemetrySensor
   private:
     MLX90632 mlx = MLX90632();
 
-  protected:
-    virtual void setup() override;
-
   public:
     MLX90632Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/NAU7802Sensor.cpp

@@ -16,24 +16,23 @@ meshtastic_Nau7802Config nau7802config = meshtastic_Nau7802Config_init_zero;
 
 NAU7802Sensor::NAU7802Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_NAU7802, "NAU7802") {}
 
-int32_t NAU7802Sensor::runOnce()
+bool NAU7802Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    status = nau7802.begin(*bus);
+    if (!status) {
+        return status;
     }
-    status = nau7802.begin(*nodeTelemetrySensorsMap[sensorType].second);
     nau7802.setSampleRate(NAU7802_SPS_320);
     if (!loadCalibrationData()) {
         LOG_ERROR("Failed to load calibration data");
     }
     nau7802.calibrateAFE();
     LOG_INFO("Offset: %d, Calibration factor: %.2f", nau7802.getZeroOffset(), nau7802.getCalibrationFactor());
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
-void NAU7802Sensor::setup() {}
-
 bool NAU7802Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
     LOG_DEBUG("NAU7802 getMetrics");

src/modules/Telemetry/Sensor/NAU7802Sensor.h

@@ -13,15 +13,14 @@ class NAU7802Sensor : public TelemetrySensor
     NAU7802 nau7802;
 
   protected:
-    virtual void setup() override;
     const char *nau7802ConfigFileName = "/prefs/nau7802.dat";
     bool saveCalibrationData();
     bool loadCalibrationData();
 
   public:
     NAU7802Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
     void tare();
     void calibrate(float weight);
     AdminMessageHandleResult handleAdminMessage(const meshtastic_MeshPacket &mp, meshtastic_AdminMessage *request,

src/modules/Telemetry/Sensor/OPT3001Sensor.cpp

@@ -9,20 +9,15 @@
 
 OPT3001Sensor::OPT3001Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_OPT3001, "OPT3001") {}
 
-int32_t OPT3001Sensor::runOnce()
+bool OPT3001Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
-    auto errorCode = opt3001.begin(nodeTelemetrySensorsMap[sensorType].first);
+    auto errorCode = opt3001.begin(dev->address.address);
     status = errorCode == NO_ERROR;
+    if (!status) {
+        return status;
+    }
 
-    return initI2CSensor();
-}
-
-void OPT3001Sensor::setup()
-{
     OPT3001_Config newConfig;
 
     newConfig.RangeNumber = 0b1100;
@@ -34,6 +29,10 @@ void OPT3001Sensor::setup()
     if (errorConfig != NO_ERROR) {
         LOG_ERROR("OPT3001 configuration error #%d", errorConfig);
     }
+    status = errorConfig == NO_ERROR;
+
+    initI2CSensor();
+    return status;
 }
 
 bool OPT3001Sensor::getMetrics(meshtastic_Telemetry *measurement)

src/modules/Telemetry/Sensor/OPT3001Sensor.h

@@ -12,13 +12,13 @@ class OPT3001Sensor : public TelemetrySensor
   private:
     ClosedCube_OPT3001 opt3001;
 
-  protected:
-    virtual void setup() override;
-
   public:
     OPT3001Sensor();
-    virtual int32_t runOnce() override;
+#if WIRE_INTERFACES_COUNT > 1
+    virtual bool onlyWire1() { return true; }
+#endif
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/PCT2075Sensor.cpp

@@ -9,24 +9,18 @@
 
 PCT2075Sensor::PCT2075Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_PCT2075, "PCT2075") {}
 
-int32_t PCT2075Sensor::runOnce()
+bool PCT2075Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
+    status = pct2075.begin(dev->address.address, bus);
 
-    status = pct2075.begin(nodeTelemetrySensorsMap[sensorType].first, nodeTelemetrySensorsMap[sensorType].second);
-
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
-void PCT2075Sensor::setup() {}
-
 bool PCT2075Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
     measurement->variant.environment_metrics.has_temperature = true;
-
     measurement->variant.environment_metrics.temperature = pct2075.getTemperature();
 
     return true;

src/modules/Telemetry/Sensor/PCT2075Sensor.h

@@ -12,13 +12,10 @@ class PCT2075Sensor : public TelemetrySensor
   private:
     Adafruit_PCT2075 pct2075;
 
-  protected:
-    virtual void setup() override;
-
   public:
     PCT2075Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/RAK12035Sensor.cpp

@@ -6,16 +6,12 @@
 
 RAK12035Sensor::RAK12035Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_RAK12035, "RAK12035") {}
 
-int32_t RAK12035Sensor::runOnce()
+bool RAK12035Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
-
     // TODO:: check for up to 2 additional sensors and start them if present.
     sensor.set_sensor_addr(RAK120351_ADDR);
     delay(100);
-    sensor.begin(nodeTelemetrySensorsMap[sensorType].first);
+    sensor.begin(dev->address.address);
 
     // Get sensor firmware version
     uint8_t data = 0;
@@ -31,8 +27,13 @@ int32_t RAK12035Sensor::runOnce()
         LOG_ERROR("RAK12035Sensor Init Failed");
         status = false;
     }
+    if (!status) {
+        return status;
+    }
+    setup();
 
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
 void RAK12035Sensor::setup()

src/modules/Telemetry/Sensor/RAK12035Sensor.h

@@ -16,13 +16,14 @@ class RAK12035Sensor : public TelemetrySensor
 {
   private:
     RAK12035 sensor;
-
-  protected:
-    virtual void setup() override;
+    void setup();
 
   public:
     RAK12035Sensor();
-    virtual int32_t runOnce() override;
+#if WIRE_INTERFACES_COUNT > 1
+    virtual bool onlyWire1() { return true; }
+#endif
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 #endif

src/modules/Telemetry/Sensor/RCWL9620Sensor.cpp

@@ -8,19 +8,15 @@
 
 RCWL9620Sensor::RCWL9620Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_RCWL9620, "RCWL9620") {}
 
-int32_t RCWL9620Sensor::runOnce()
+bool RCWL9620Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
     status = 1;
-    begin(nodeTelemetrySensorsMap[sensorType].second, nodeTelemetrySensorsMap[sensorType].first);
-    return initI2CSensor();
+    begin(bus, dev->address.address);
+    initI2CSensor();
+    return status;
 }
 
-void RCWL9620Sensor::setup() {}
-
 bool RCWL9620Sensor::getMetrics(meshtastic_Telemetry *measurement)
 {
     measurement->variant.environment_metrics.has_distance = true;

src/modules/Telemetry/Sensor/RCWL9620Sensor.h

@@ -16,14 +16,13 @@ class RCWL9620Sensor : public TelemetrySensor
     uint32_t _speed = 200000UL;
 
   protected:
-    virtual void setup() override;
     void begin(TwoWire *wire = &Wire, uint8_t addr = 0x57, uint8_t sda = -1, uint8_t scl = -1, uint32_t speed = 200000UL);
     float getDistance();
 
   public:
     RCWL9620Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/SHT31Sensor.cpp

@@ -9,20 +9,13 @@
 
 SHT31Sensor::SHT31Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_SHT31, "SHT31") {}
 
-int32_t SHT31Sensor::runOnce()
+bool SHT31Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
-    sht31 = Adafruit_SHT31(nodeTelemetrySensorsMap[sensorType].second);
-    status = sht31.begin(nodeTelemetrySensorsMap[sensorType].first);
-    return initI2CSensor();
-}
-
-void SHT31Sensor::setup()
-{
-    // Set up oversampling and filter initialization
+    sht31 = Adafruit_SHT31(bus);
+    status = sht31.begin(dev->address.address);
+    initI2CSensor();
+    return status;
 }
 
 bool SHT31Sensor::getMetrics(meshtastic_Telemetry *measurement)

src/modules/Telemetry/Sensor/SHT31Sensor.h

@@ -11,13 +11,10 @@ class SHT31Sensor : public TelemetrySensor
   private:
     Adafruit_SHT31 sht31;
 
-  protected:
-    virtual void setup() override;
-
   public:
     SHT31Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/SHT4XSensor.cpp

@@ -9,16 +9,16 @@
 
 SHT4XSensor::SHT4XSensor() : TelemetrySensor(meshtastic_TelemetrySensorType_SHT4X, "SHT4X") {}
 
-int32_t SHT4XSensor::runOnce()
+bool SHT4XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
 
     uint32_t serialNumber = 0;
 
-    sht4x.begin(nodeTelemetrySensorsMap[sensorType].second);
+    status = sht4x.begin(bus);
+    if (!status) {
+        return status;
+    }
 
     serialNumber = sht4x.readSerial();
     if (serialNumber != 0) {
@@ -29,12 +29,8 @@ int32_t SHT4XSensor::runOnce()
         status = 0;
     }
 
-    return initI2CSensor();
-}
-
-void SHT4XSensor::setup()
-{
-    // Set up oversampling and filter initialization
+    initI2CSensor();
+    return status;
 }
 
 bool SHT4XSensor::getMetrics(meshtastic_Telemetry *measurement)

src/modules/Telemetry/Sensor/SHT4XSensor.h

@@ -11,13 +11,10 @@ class SHT4XSensor : public TelemetrySensor
   private:
     Adafruit_SHT4x sht4x = Adafruit_SHT4x();
 
-  protected:
-    virtual void setup() override;
-
   public:
     SHT4XSensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/SHTC3Sensor.cpp

@@ -9,19 +9,13 @@
 
 SHTC3Sensor::SHTC3Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_SHTC3, "SHTC3") {}
 
-int32_t SHTC3Sensor::runOnce()
+bool SHTC3Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
-    status = shtc3.begin(nodeTelemetrySensorsMap[sensorType].second);
-    return initI2CSensor();
-}
+    status = shtc3.begin(bus);
 
-void SHTC3Sensor::setup()
-{
-    // Set up oversampling and filter initialization
+    initI2CSensor();
+    return status;
 }
 
 bool SHTC3Sensor::getMetrics(meshtastic_Telemetry *measurement)

src/modules/Telemetry/Sensor/SHTC3Sensor.h

@@ -11,13 +11,10 @@ class SHTC3Sensor : public TelemetrySensor
   private:
     Adafruit_SHTC3 shtc3 = Adafruit_SHTC3();
 
-  protected:
-    virtual void setup() override;
-
   public:
     SHTC3Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 
 #endif

src/modules/Telemetry/Sensor/T1000xSensor.cpp

@@ -38,18 +38,10 @@ int8_t ntc_temp2[136] = {
 
 T1000xSensor::T1000xSensor() : TelemetrySensor(meshtastic_TelemetrySensorType_SENSOR_UNSET, "T1000x") {}
 
-int32_t T1000xSensor::runOnce()
+bool T1000xSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-    }
-    return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
-}
-
-void T1000xSensor::setup()
-{
-    // Set up oversampling and filter initialization
+    return true;
 }
 
 float T1000xSensor::getLux()

src/modules/Telemetry/Sensor/T1000xSensor.h

@@ -7,13 +7,10 @@
 
 class T1000xSensor : public TelemetrySensor
 {
-  protected:
-    virtual void setup() override;
-
   public:
     T1000xSensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
     virtual float getLux();
     virtual float getTemp();
 };

src/modules/Telemetry/Sensor/TSL2561Sensor.cpp

@@ -9,22 +9,19 @@
 
 TSL2561Sensor::TSL2561Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_TSL2561, "TSL2561") {}
 
-int32_t TSL2561Sensor::runOnce()
+bool TSL2561Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+
+    status = tsl.begin(bus);
+    if (!status) {
+        return status;
     }
-
-    status = tsl.begin(nodeTelemetrySensorsMap[sensorType].second);
-
-    return initI2CSensor();
-}
-
-void TSL2561Sensor::setup()
-{
     tsl.setGain(TSL2561_GAIN_1X);
     tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_101MS);
+
+    initI2CSensor();
+    return status;
 }
 
 bool TSL2561Sensor::getMetrics(meshtastic_Telemetry *measurement)

src/modules/Telemetry/Sensor/TSL2561Sensor.h

@@ -12,12 +12,9 @@ class TSL2561Sensor : public TelemetrySensor
     // The magic number is a sensor id, the actual value doesn't matter
     Adafruit_TSL2561_Unified tsl = Adafruit_TSL2561_Unified(TSL2561_ADDR_LOW, 12345);
 
-  protected:
-    virtual void setup() override;
-
   public:
     TSL2561Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 #endif

src/modules/Telemetry/Sensor/TSL2591Sensor.cpp

@@ -10,21 +10,18 @@
 
 TSL2591Sensor::TSL2591Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_TSL25911FN, "TSL2591") {}
 
-int32_t TSL2591Sensor::runOnce()
+bool TSL2591Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    status = tsl.begin(bus);
+    if (!status) {
+        return status;
     }
-    status = tsl.begin(nodeTelemetrySensorsMap[sensorType].second);
-
-    return initI2CSensor();
-}
-
-void TSL2591Sensor::setup()
-{
     tsl.setGain(TSL2591_GAIN_LOW); // 1x gain
     tsl.setTiming(TSL2591_INTEGRATIONTIME_100MS);
+
+    initI2CSensor();
+    return status;
 }
 
 bool TSL2591Sensor::getMetrics(meshtastic_Telemetry *measurement)

src/modules/Telemetry/Sensor/TSL2591Sensor.h

@@ -11,12 +11,9 @@ class TSL2591Sensor : public TelemetrySensor
   private:
     Adafruit_TSL2591 tsl;
 
-  protected:
-    virtual void setup() override;
-
   public:
     TSL2591Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 #endif

src/modules/Telemetry/Sensor/TelemetrySensor.h

@@ -6,6 +6,7 @@
 #include "../mesh/generated/meshtastic/telemetry.pb.h"
 #include "MeshModule.h"
 #include "NodeDB.h"
+#include "detect/ScanI2C.h"
 #include <utility>
 
 #if !ARCH_PORTDUINO
@@ -42,22 +43,32 @@ class TelemetrySensor
         initialized = true;
         return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
     }
-    virtual void setup() = 0;
+
+    // TODO: check is setup used at all?
+    virtual void setup() {}
 
   public:
+    virtual ~TelemetrySensor() {}
+
     virtual AdminMessageHandleResult handleAdminMessage(const meshtastic_MeshPacket &mp, meshtastic_AdminMessage *request,
                                                         meshtastic_AdminMessage *response)
     {
         return AdminMessageHandleResult::NOT_HANDLED;
     }
 
+    // TODO: delete after migration
     bool hasSensor() { return nodeTelemetrySensorsMap[sensorType].first > 0; }
 
-    virtual int32_t runOnce() = 0;
+#if WIRE_INTERFACES_COUNT > 1
+    // Set to true if Implementation only works first I2C port (Wire)
+    virtual bool onlyWire1() { return false; }
+#endif
+    virtual int32_t runOnce() { return INT32_MAX; }
     virtual bool isInitialized() { return initialized; }
     virtual bool isRunning() { return status > 0; }
 
     virtual bool getMetrics(meshtastic_Telemetry *measurement) = 0;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) { return false; };
 };
 
 #endif

src/modules/Telemetry/Sensor/VEML7700Sensor.cpp

@@ -11,23 +11,22 @@
 
 VEML7700Sensor::VEML7700Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_VEML7700, "VEML7700") {}
 
-int32_t VEML7700Sensor::runOnce()
+bool VEML7700Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
 {
     LOG_INFO("Init sensor: %s", sensorName);
-    if (!hasSensor()) {
-        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    status = veml7700.begin(bus);
+    if (!status) {
+        return status;
     }
-    status = veml7700.begin(nodeTelemetrySensorsMap[sensorType].second);
 
     veml7700.setLowThreshold(10000);
     veml7700.setHighThreshold(20000);
     veml7700.interruptEnable(true);
 
-    return initI2CSensor();
+    initI2CSensor();
+    return status;
 }
 
-void VEML7700Sensor::setup() {}
-
 /*!
  *    @brief Copmute lux from ALS reading.
  *    @param rawALS raw ALS register value

src/modules/Telemetry/Sensor/VEML7700Sensor.h

@@ -16,12 +16,9 @@ class VEML7700Sensor : public TelemetrySensor
     float computeLux(uint16_t rawALS, bool corrected);
     float getResolution(void);
 
-  protected:
-    virtual void setup() override;
-
   public:
     VEML7700Sensor();
-    virtual int32_t runOnce() override;
     virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
 };
 #endif

src/modules/Telemetry/Sensor/nullSensor.cpp

@@ -11,7 +11,7 @@ NullSensor::NullSensor() : TelemetrySensor(meshtastic_TelemetrySensorType_SENSOR
 
 int32_t NullSensor::runOnce()
 {
-    return 0;
+    return INT32_MAX;
 }
 
 void NullSensor::setup() {}