diff --git a/src/detect/ScanI2CConsumer.cpp b/src/detect/ScanI2CConsumer.cpp
new file mode 100644
index 0000000000..a70fa53984
--- /dev/null
+++ b/src/detect/ScanI2CConsumer.cpp
@@ -0,0 +1,16 @@
+#include "ScanI2CConsumer.h"
+#include <forward_list>
+
+static std::forward_list<ScanI2CConsumer *> ScanI2CConsumers;
+
+ScanI2CConsumer::ScanI2CConsumer()
+{
+    ScanI2CConsumers.push_front(this);
+}
+
+void ScanI2CCompleted(ScanI2C *i2cScanner)
+{
+    for (ScanI2CConsumer *consumer : ScanI2CConsumers) {
+        consumer->i2cScanFinished(i2cScanner);
+    }
+}
\ No newline at end of file
diff --git a/src/detect/ScanI2CConsumer.h b/src/detect/ScanI2CConsumer.h
new file mode 100644
index 0000000000..fd97f7edc8
--- /dev/null
+++ b/src/detect/ScanI2CConsumer.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "ScanI2C.h"
+#include <stddef.h>
+
+class ScanI2CConsumer
+{
+  public:
+    ScanI2CConsumer();
+    virtual void i2cScanFinished(ScanI2C *i2cScanner) = 0;
+};
+
+void ScanI2CCompleted(ScanI2C *i2cScanner);
\ No newline at end of file
diff --git a/src/detect/ScanI2CTwoWire.cpp b/src/detect/ScanI2CTwoWire.cpp
index d6daf7b7aa..da2a57feeb 100644
--- a/src/detect/ScanI2CTwoWire.cpp
+++ b/src/detect/ScanI2CTwoWire.cpp
@@ -581,7 +581,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port)
     scanPort(port, nullptr, 0);
 }
 
-TwoWire *ScanI2CTwoWire::fetchI2CBus(ScanI2C::DeviceAddress address) const
+TwoWire *ScanI2CTwoWire::fetchI2CBus(ScanI2C::DeviceAddress address)
 {
     if (address.port == ScanI2C::I2CPort::WIRE) {
         return &Wire;
diff --git a/src/detect/ScanI2CTwoWire.h b/src/detect/ScanI2CTwoWire.h
index 6988091ad3..c5b7919202 100644
--- a/src/detect/ScanI2CTwoWire.h
+++ b/src/detect/ScanI2CTwoWire.h
@@ -23,12 +23,12 @@ class ScanI2CTwoWire : public ScanI2C
 
     ScanI2C::FoundDevice find(ScanI2C::DeviceType) const override;
 
-    TwoWire *fetchI2CBus(ScanI2C::DeviceAddress) const;
-
     bool exists(ScanI2C::DeviceType) const override;
 
     size_t countDevices() const override;
 
+    static TwoWire *fetchI2CBus(ScanI2C::DeviceAddress);
+
   protected:
     FoundDevice firstOfOrNONE(size_t, DeviceType[]) const override;
 
diff --git a/src/main.cpp b/src/main.cpp
index 029b8d7087..bb97a1aa65 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -23,6 +23,7 @@
 #include "power.h"
 
 #if !MESHTASTIC_EXCLUDE_I2C
+#include "detect/ScanI2CConsumer.h"
 #include "detect/ScanI2CTwoWire.h"
 #include <Wire.h>
 #endif
@@ -718,46 +719,21 @@ void setup()
     LOG_DEBUG("acc_info = %i", acc_info.type);
 #endif
 
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::BME_680, meshtastic_TelemetrySensorType_BME680);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::BME_280, meshtastic_TelemetrySensorType_BME280);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::BMP_280, meshtastic_TelemetrySensorType_BMP280);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::BMP_3XX, meshtastic_TelemetrySensorType_BMP3XX);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::BMP_085, meshtastic_TelemetrySensorType_BMP085);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::INA260, meshtastic_TelemetrySensorType_INA260);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::INA226, meshtastic_TelemetrySensorType_INA226);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::INA219, meshtastic_TelemetrySensorType_INA219);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::INA3221, meshtastic_TelemetrySensorType_INA3221);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::MAX17048, meshtastic_TelemetrySensorType_MAX17048);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::MCP9808, meshtastic_TelemetrySensorType_MCP9808);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::SHT31, meshtastic_TelemetrySensorType_SHT31);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::SHTC3, meshtastic_TelemetrySensorType_SHTC3);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::LPS22HB, meshtastic_TelemetrySensorType_LPS22);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::QMC6310, meshtastic_TelemetrySensorType_QMC6310);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::QMI8658, meshtastic_TelemetrySensorType_QMI8658);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::QMC5883L, meshtastic_TelemetrySensorType_QMC5883L);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::HMC5883L, meshtastic_TelemetrySensorType_QMC5883L);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::PMSA0031, meshtastic_TelemetrySensorType_PMSA003I);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::RCWL9620, meshtastic_TelemetrySensorType_RCWL9620);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::VEML7700, meshtastic_TelemetrySensorType_VEML7700);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::TSL2591, meshtastic_TelemetrySensorType_TSL25911FN);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::OPT3001, meshtastic_TelemetrySensorType_OPT3001);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::MLX90632, meshtastic_TelemetrySensorType_MLX90632);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::MLX90614, meshtastic_TelemetrySensorType_MLX90614);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::SHT4X, meshtastic_TelemetrySensorType_SHT4X);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::AHT10, meshtastic_TelemetrySensorType_AHT10);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::DFROBOT_LARK, meshtastic_TelemetrySensorType_DFROBOT_LARK);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::ICM20948, meshtastic_TelemetrySensorType_ICM20948);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::MAX30102, meshtastic_TelemetrySensorType_MAX30102);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::CGRADSENS, meshtastic_TelemetrySensorType_RADSENS);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::DFROBOT_RAIN, meshtastic_TelemetrySensorType_DFROBOT_RAIN);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::LTR390UV, meshtastic_TelemetrySensorType_LTR390UV);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::DPS310, meshtastic_TelemetrySensorType_DPS310);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::RAK12035, meshtastic_TelemetrySensorType_RAK12035);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::PCT2075, meshtastic_TelemetrySensorType_PCT2075);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::SCD4X, meshtastic_TelemetrySensorType_SCD4X);
-    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::TSL2561, meshtastic_TelemetrySensorType_TSL2561);
 
-    i2cScanner.reset();
 #endif
 
 #ifdef HAS_SDCARD
@@ -964,6 +940,12 @@ void setup()
     // Now that the mesh service is created, create any modules
     setupModules();
 
+#if !MESHTASTIC_EXCLUDE_I2C
+    // Inform modules about I2C devices
+    ScanI2CCompleted(i2cScanner.get());
+    i2cScanner.reset();
+#endif
+
     // warn the user about a low entropy key
     if (nodeDB->keyIsLowEntropy && !nodeDB->hasWarned) {
         LOG_WARN(LOW_ENTROPY_WARNING);
diff --git a/src/modules/Telemetry/EnvironmentTelemetry.cpp b/src/modules/Telemetry/EnvironmentTelemetry.cpp
index 8ac160f8ba..95947560d1 100644
--- a/src/modules/Telemetry/EnvironmentTelemetry.cpp
+++ b/src/modules/Telemetry/EnvironmentTelemetry.cpp
@@ -35,175 +35,103 @@ extern void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const c
 }
 #if __has_include(<Adafruit_AHTX0.h>)
 #include "Sensor/AHT10.h"
-AHT10Sensor aht10Sensor;
-#else
-NullSensor aht10Sensor;
 #endif
+
 #if __has_include(<Adafruit_BME280.h>)
 #include "Sensor/BME280Sensor.h"
-BME280Sensor bme280Sensor;
-#else
-NullSensor bmp280Sensor;
 #endif
 
 #if __has_include(<Adafruit_BMP085.h>)
 #include "Sensor/BMP085Sensor.h"
-BMP085Sensor bmp085Sensor;
-#else
-NullSensor bmp085Sensor;
 #endif
 
 #if __has_include(<Adafruit_BMP280.h>)
 #include "Sensor/BMP280Sensor.h"
-BMP280Sensor bmp280Sensor;
-#else
-NullSensor bme280Sensor;
 #endif
 
 #if __has_include(<Adafruit_LTR390.h>)
 #include "Sensor/LTR390UVSensor.h"
-LTR390UVSensor ltr390uvSensor;
-#else
-NullSensor ltr390uvSensor;
 #endif
 
 #if __has_include(<bsec2.h>)
 #include "Sensor/BME680Sensor.h"
-BME680Sensor bme680Sensor;
-#else
-NullSensor bme680Sensor;
 #endif
 
 #if __has_include(<Adafruit_DPS310.h>)
 #include "Sensor/DPS310Sensor.h"
-DPS310Sensor dps310Sensor;
-#else
-NullSensor dps310Sensor;
 #endif
 
 #if __has_include(<Adafruit_MCP9808.h>)
 #include "Sensor/MCP9808Sensor.h"
-MCP9808Sensor mcp9808Sensor;
-#else
-NullSensor mcp9808Sensor;
 #endif
 
 #if __has_include(<Adafruit_SHT31.h>)
 #include "Sensor/SHT31Sensor.h"
-SHT31Sensor sht31Sensor;
-#else
-NullSensor sht31Sensor;
 #endif
 
 #if __has_include(<Adafruit_LPS2X.h>)
 #include "Sensor/LPS22HBSensor.h"
-LPS22HBSensor lps22hbSensor;
-#else
-NullSensor lps22hbSensor;
 #endif
 
 #if __has_include(<Adafruit_SHTC3.h>)
 #include "Sensor/SHTC3Sensor.h"
-SHTC3Sensor shtc3Sensor;
-#else
-NullSensor shtc3Sensor;
 #endif
 
 #if __has_include("RAK12035_SoilMoisture.h") && defined(RAK_4631) && RAK_4631 == 1
 #include "Sensor/RAK12035Sensor.h"
-RAK12035Sensor rak12035Sensor;
-#else
-NullSensor rak12035Sensor;
 #endif
 
 #if __has_include(<Adafruit_VEML7700.h>)
 #include "Sensor/VEML7700Sensor.h"
-VEML7700Sensor veml7700Sensor;
-#else
-NullSensor veml7700Sensor;
 #endif
 
 #if __has_include(<Adafruit_TSL2591.h>)
 #include "Sensor/TSL2591Sensor.h"
-TSL2591Sensor tsl2591Sensor;
-#else
-NullSensor tsl2591Sensor;
 #endif
 
 #if __has_include(<ClosedCube_OPT3001.h>)
 #include "Sensor/OPT3001Sensor.h"
-OPT3001Sensor opt3001Sensor;
-#else
-NullSensor opt3001Sensor;
 #endif
 
 #if __has_include(<Adafruit_SHT4x.h>)
 #include "Sensor/SHT4XSensor.h"
-SHT4XSensor sht4xSensor;
-#else
-NullSensor sht4xSensor;
 #endif
 
 #if __has_include(<SparkFun_MLX90632_Arduino_Library.h>)
 #include "Sensor/MLX90632Sensor.h"
-MLX90632Sensor mlx90632Sensor;
-#else
-NullSensor mlx90632Sensor;
 #endif
 
 #if __has_include(<DFRobot_LarkWeatherStation.h>)
 #include "Sensor/DFRobotLarkSensor.h"
-DFRobotLarkSensor dfRobotLarkSensor;
-#else
-NullSensor dfRobotLarkSensor;
 #endif
 
 #if __has_include(<DFRobot_RainfallSensor.h>)
 #include "Sensor/DFRobotGravitySensor.h"
-DFRobotGravitySensor dfRobotGravitySensor;
-#else
-NullSensor dfRobotGravitySensor;
 #endif
 
 #if __has_include(<SparkFun_Qwiic_Scale_NAU7802_Arduino_Library.h>)
 #include "Sensor/NAU7802Sensor.h"
-NAU7802Sensor nau7802Sensor;
-#else
-NullSensor nau7802Sensor;
 #endif
 
 #if __has_include(<Adafruit_BMP3XX.h>)
 #include "Sensor/BMP3XXSensor.h"
-BMP3XXSensor bmp3xxSensor;
-#else
-NullSensor bmp3xxSensor;
 #endif
 
 #if __has_include(<Adafruit_PCT2075.h>)
 #include "Sensor/PCT2075Sensor.h"
-PCT2075Sensor pct2075Sensor;
-#else
-NullSensor pct2075Sensor;
 #endif
 
-RCWL9620Sensor rcwl9620Sensor;
-CGRadSensSensor cgRadSens;
-
 #endif
 #ifdef T1000X_SENSOR_EN
 #include "Sensor/T1000xSensor.h"
-T1000xSensor t1000xSensor;
 #endif
+
 #ifdef SENSECAP_INDICATOR
 #include "Sensor/IndicatorSensor.h"
-IndicatorSensor indicatorSensor;
 #endif
 
 #if __has_include(<Adafruit_TSL2561_U.h>)
 #include "Sensor/TSL2561Sensor.h"
-TSL2561Sensor tsl2561Sensor;
-#else
-NullSensor tsl2561Sensor;
 #endif
 
 #define FAILED_STATE_SENSOR_READ_MULTIPLIER 10
@@ -212,6 +140,132 @@ NullSensor tsl2561Sensor;
 #include "graphics/ScreenFonts.h"
 #include <Throttle.h>
 
+#include <forward_list>
+
+static std::forward_list<TelemetrySensor *> sensors;
+
+template <typename T> void addSensor(ScanI2C *i2cScanner, ScanI2C::DeviceType type)
+{
+    ScanI2C::FoundDevice dev = i2cScanner->find(type);
+    if (dev.type != ScanI2C::DeviceType::NONE || type == ScanI2C::DeviceType::NONE) {
+        TelemetrySensor *sensor = new T();
+#if WIRE_INTERFACES_COUNT > 1
+        TwoWire *bus = ScanI2CTwoWire::fetchI2CBus(dev.address);
+        if (dev.address.port != ScanI2C::I2CPort::WIRE1 && sensor->onlyWire1()) {
+            // This sensor only works on Wire (Wire1 is not supported)
+            delete sensor;
+            return;
+        }
+#else
+        TwoWire *bus = &Wire;
+#endif
+        if (sensor->initDevice(bus, &dev)) {
+            sensors.push_front(sensor);
+            return;
+        }
+        // destroy sensor
+        delete sensor;
+    }
+}
+
+void EnvironmentTelemetryModule::i2cScanFinished(ScanI2C *i2cScanner)
+{
+    if (!moduleConfig.telemetry.environment_measurement_enabled && !ENVIRONMENTAL_TELEMETRY_MODULE_ENABLE) {
+        return;
+    }
+    LOG_INFO("Environment Telemetry adding I2C devices...");
+
+    // order by priority of metrics/values (low top, high bottom)
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+#ifdef T1000X_SENSOR_EN
+    // Not a real I2C device
+    addSensor<T1000xSensor>(i2cScanner, ScanI2C::DeviceType::NONE);
+#else
+#ifdef SENSECAP_INDICATOR
+    // Not a real I2C device, uses UART
+    addSensor<IndicatorSensor>(i2cScanner, ScanI2C::DeviceType::NONE);
+#endif
+    addSensor<RCWL9620Sensor>(i2cScanner, ScanI2C::DeviceType::RCWL9620);
+    addSensor<CGRadSensSensor>(i2cScanner, ScanI2C::DeviceType::CGRADSENS);
+#endif
+#endif
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR_EXTERNAL
+#if __has_include(<DFRobot_LarkWeatherStation.h>)
+    addSensor<DFRobotLarkSensor>(i2cScanner, ScanI2C::DeviceType::DFROBOT_LARK);
+#endif
+#if __has_include(<DFRobot_RainfallSensor.h>)
+    addSensor<DFRobotGravitySensor>(i2cScanner, ScanI2C::DeviceType::DFROBOT_RAIN);
+#endif
+#if __has_include(<Adafruit_AHTX0.h>)
+    addSensor<AHT10Sensor>(i2cScanner, ScanI2C::DeviceType::AHT10);
+#endif
+#if __has_include(<Adafruit_BMP085.h>)
+    addSensor<BMP085Sensor>(i2cScanner, ScanI2C::DeviceType::BMP_085);
+#endif
+#if __has_include(<Adafruit_BME280.h>)
+    addSensor<BME280Sensor>(i2cScanner, ScanI2C::DeviceType::BME_280);
+#endif
+#if __has_include(<Adafruit_LTR390.h>)
+    addSensor<LTR390UVSensor>(i2cScanner, ScanI2C::DeviceType::LTR390UV);
+#endif
+#if __has_include(<bsec2.h>)
+    addSensor<BME680Sensor>(i2cScanner, ScanI2C::DeviceType::BME_680);
+#endif
+#if __has_include(<Adafruit_BMP280.h>)
+    addSensor<BMP280Sensor>(i2cScanner, ScanI2C::DeviceType::BMP_280);
+#endif
+#if __has_include(<Adafruit_DPS310.h>)
+    addSensor<DPS310Sensor>(i2cScanner, ScanI2C::DeviceType::DPS310);
+#endif
+#if __has_include(<Adafruit_MCP9808.h>)
+    addSensor<MCP9808Sensor>(i2cScanner, ScanI2C::DeviceType::MCP9808);
+#endif
+#if __has_include(<Adafruit_SHT31.h>)
+    addSensor<SHT31Sensor>(i2cScanner, ScanI2C::DeviceType::SHT31);
+#endif
+#if __has_include(<Adafruit_LPS2X.h>)
+    addSensor<LPS22HBSensor>(i2cScanner, ScanI2C::DeviceType::LPS22HB);
+#endif
+#if __has_include(<Adafruit_SHTC3.h>)
+    addSensor<SHTC3Sensor>(i2cScanner, ScanI2C::DeviceType::SHTC3);
+#endif
+#if __has_include("RAK12035_SoilMoisture.h") && defined(RAK_4631) && RAK_4631 == 1
+    addSensor<RAK12035Sensor>(i2cScanner, ScanI2C::DeviceType::RAK12035);
+#endif
+#if __has_include(<Adafruit_VEML7700.h>)
+    addSensor<VEML7700Sensor>(i2cScanner, ScanI2C::DeviceType::VEML7700);
+#endif
+#if __has_include(<Adafruit_TSL2591.h>)
+    addSensor<TSL2591Sensor>(i2cScanner, ScanI2C::DeviceType::TSL2591);
+#endif
+#if __has_include(<ClosedCube_OPT3001.h>)
+    addSensor<OPT3001Sensor>(i2cScanner, ScanI2C::DeviceType::OPT3001);
+#endif
+#if __has_include(<Adafruit_SHT4x.h>)
+    addSensor<SHT4XSensor>(i2cScanner, ScanI2C::DeviceType::SHT4X);
+#endif
+#if __has_include(<SparkFun_MLX90632_Arduino_Library.h>)
+    addSensor<MLX90632Sensor>(i2cScanner, ScanI2C::DeviceType::MLX90632);
+#endif
+
+#if __has_include(<Adafruit_BMP3XX.h>)
+    addSensor<BMP3XXSensor>(i2cScanner, ScanI2C::DeviceType::BMP_3XX);
+#endif
+#if __has_include(<Adafruit_PCT2075.h>)
+    addSensor<PCT2075Sensor>(i2cScanner, ScanI2C::DeviceType::PCT2075);
+#endif
+#if __has_include(<Adafruit_TSL2561_U.h>)
+    addSensor<TSL2561Sensor>(i2cScanner, ScanI2C::DeviceType::TSL2561);
+#endif
+#if __has_include(<SparkFun_Qwiic_Scale_NAU7802_Arduino_Library.h>)
+    addSensor<NAU7802Sensor>(i2cScanner, ScanI2C::DeviceType::NAU7802);
+#endif
+
+#endif
+}
+
 int32_t EnvironmentTelemetryModule::runOnce()
 {
     if (sleepOnNextExecution == true) {
@@ -244,81 +298,27 @@ int32_t EnvironmentTelemetryModule::runOnce()
 
         if (moduleConfig.telemetry.environment_measurement_enabled || ENVIRONMENTAL_TELEMETRY_MODULE_ENABLE) {
             LOG_INFO("Environment Telemetry: init");
-#ifdef SENSECAP_INDICATOR
-            result = indicatorSensor.runOnce();
-#endif
+
+            // check if we have at least one sensor
+            if (!sensors.empty()) {
+                result = DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+            }
+
 #ifdef T1000X_SENSOR_EN
-            result = t1000xSensor.runOnce();
 #elif !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR_EXTERNAL
-            if (dfRobotLarkSensor.hasSensor())
-                result = dfRobotLarkSensor.runOnce();
-            if (dfRobotGravitySensor.hasSensor())
-                result = dfRobotGravitySensor.runOnce();
-            if (bmp085Sensor.hasSensor())
-                result = bmp085Sensor.runOnce();
-#if __has_include(<Adafruit_BME280.h>)
-            if (bmp280Sensor.hasSensor())
-                result = bmp280Sensor.runOnce();
-#endif
-            if (bme280Sensor.hasSensor())
-                result = bme280Sensor.runOnce();
-            if (ltr390uvSensor.hasSensor())
-                result = ltr390uvSensor.runOnce();
-            if (bmp3xxSensor.hasSensor())
-                result = bmp3xxSensor.runOnce();
-            if (bme680Sensor.hasSensor())
-                result = bme680Sensor.runOnce();
-            if (dps310Sensor.hasSensor())
-                result = dps310Sensor.runOnce();
-            if (mcp9808Sensor.hasSensor())
-                result = mcp9808Sensor.runOnce();
-            if (shtc3Sensor.hasSensor())
-                result = shtc3Sensor.runOnce();
-            if (lps22hbSensor.hasSensor())
-                result = lps22hbSensor.runOnce();
-            if (sht31Sensor.hasSensor())
-                result = sht31Sensor.runOnce();
-            if (sht4xSensor.hasSensor())
-                result = sht4xSensor.runOnce();
             if (ina219Sensor.hasSensor())
                 result = ina219Sensor.runOnce();
             if (ina260Sensor.hasSensor())
                 result = ina260Sensor.runOnce();
             if (ina3221Sensor.hasSensor())
                 result = ina3221Sensor.runOnce();
-            if (veml7700Sensor.hasSensor())
-                result = veml7700Sensor.runOnce();
-            if (tsl2591Sensor.hasSensor())
-                result = tsl2591Sensor.runOnce();
-            if (opt3001Sensor.hasSensor())
-                result = opt3001Sensor.runOnce();
-            if (rcwl9620Sensor.hasSensor())
-                result = rcwl9620Sensor.runOnce();
-            if (aht10Sensor.hasSensor())
-                result = aht10Sensor.runOnce();
-            if (mlx90632Sensor.hasSensor())
-                result = mlx90632Sensor.runOnce();
-            if (nau7802Sensor.hasSensor())
-                result = nau7802Sensor.runOnce();
             if (max17048Sensor.hasSensor())
                 result = max17048Sensor.runOnce();
-            if (cgRadSens.hasSensor())
-                result = cgRadSens.runOnce();
-            if (tsl2561Sensor.hasSensor())
-                result = tsl2561Sensor.runOnce();
-            if (pct2075Sensor.hasSensor())
-                result = pct2075Sensor.runOnce();
                 // this only works on the wismesh hub with the solar option. This is not an I2C sensor, so we don't need the
                 // sensormap here.
 #ifdef HAS_RAKPROT
-
             result = rak9154Sensor.runOnce();
 #endif
-#if __has_include("RAK12035_SoilMoisture.h") && defined(RAK_4631) && RAK_4631 == 1
-            if (rak12035Sensor.hasSensor()) {
-                result = rak12035Sensor.runOnce();
-            }
-#endif
 #endif
         }
         // it's possible to have this module enabled, only for displaying values on the screen.
@@ -328,11 +328,13 @@ int32_t EnvironmentTelemetryModule::runOnce()
         // if we somehow got to a second run of this module with measurement disabled, then just wait forever
         if (!moduleConfig.telemetry.environment_measurement_enabled && !ENVIRONMENTAL_TELEMETRY_MODULE_ENABLE) {
             return disable();
-        } else {
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR_EXTERNAL
-            if (bme680Sensor.hasSensor())
-                result = bme680Sensor.runTrigger();
-#endif
+        }
+
+        for (TelemetrySensor *sensor : sensors) {
+            uint32_t delay = sensor->runOnce();
+            if (delay < result) {
+                result = delay;
+            }
         }
 
         if (((lastSentToMesh == 0) ||
@@ -550,72 +552,12 @@ bool EnvironmentTelemetryModule::getEnvironmentTelemetry(meshtastic_Telemetry *m
     m->which_variant = meshtastic_Telemetry_environment_metrics_tag;
     m->variant.environment_metrics = meshtastic_EnvironmentMetrics_init_zero;
 
-#ifdef SENSECAP_INDICATOR
-    valid = valid && indicatorSensor.getMetrics(m);
-    hasSensor = true;
-#endif
-#ifdef T1000X_SENSOR_EN // add by WayenWeng
-    valid = valid && t1000xSensor.getMetrics(m);
-    hasSensor = true;
-#else
-    if (dfRobotLarkSensor.hasSensor()) {
-        valid = valid && dfRobotLarkSensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (dfRobotGravitySensor.hasSensor()) {
-        valid = valid && dfRobotGravitySensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (sht31Sensor.hasSensor()) {
-        valid = valid && sht31Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (sht4xSensor.hasSensor()) {
-        valid = valid && sht4xSensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (lps22hbSensor.hasSensor()) {
-        valid = valid && lps22hbSensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (shtc3Sensor.hasSensor()) {
-        valid = valid && shtc3Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (bmp085Sensor.hasSensor()) {
-        valid = valid && bmp085Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-#if __has_include(<Adafruit_BME280.h>)
-    if (bmp280Sensor.hasSensor()) {
-        valid = valid && bmp280Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-#endif
-    if (bme280Sensor.hasSensor()) {
-        valid = valid && bme280Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (ltr390uvSensor.hasSensor()) {
-        valid = valid && ltr390uvSensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (bmp3xxSensor.hasSensor()) {
-        valid = valid && bmp3xxSensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (bme680Sensor.hasSensor()) {
-        valid = valid && bme680Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (dps310Sensor.hasSensor()) {
-        valid = valid && dps310Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (mcp9808Sensor.hasSensor()) {
-        valid = valid && mcp9808Sensor.getMetrics(m);
+    for (TelemetrySensor *sensor : sensors) {
+        valid = valid && sensor->getMetrics(m);
         hasSensor = true;
     }
+
+#ifndef T1000X_SENSOR_EN
     if (ina219Sensor.hasSensor()) {
         valid = valid && ina219Sensor.getMetrics(m);
         hasSensor = true;
@@ -628,78 +570,14 @@ bool EnvironmentTelemetryModule::getEnvironmentTelemetry(meshtastic_Telemetry *m
         valid = valid && ina3221Sensor.getMetrics(m);
         hasSensor = true;
     }
-    if (veml7700Sensor.hasSensor()) {
-        valid = valid && veml7700Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (tsl2591Sensor.hasSensor()) {
-        valid = valid && tsl2591Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (opt3001Sensor.hasSensor()) {
-        valid = valid && opt3001Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (mlx90632Sensor.hasSensor()) {
-        valid = valid && mlx90632Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (rcwl9620Sensor.hasSensor()) {
-        valid = valid && rcwl9620Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (nau7802Sensor.hasSensor()) {
-        valid = valid && nau7802Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (tsl2561Sensor.hasSensor()) {
-        valid = valid && tsl2561Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-    if (aht10Sensor.hasSensor()) {
-        if (!bmp280Sensor.hasSensor() && !bmp3xxSensor.hasSensor()) {
-            valid = valid && aht10Sensor.getMetrics(m);
-            hasSensor = true;
-        } else if (bmp280Sensor.hasSensor()) {
-            // prefer bmp280 temp if both sensors are present, fetch only humidity
-            meshtastic_Telemetry m_ahtx = meshtastic_Telemetry_init_zero;
-            LOG_INFO("AHTX0+BMP280 module detected: using temp from BMP280 and humy from AHTX0");
-            aht10Sensor.getMetrics(&m_ahtx);
-            m->variant.environment_metrics.relative_humidity = m_ahtx.variant.environment_metrics.relative_humidity;
-            m->variant.environment_metrics.has_relative_humidity = m_ahtx.variant.environment_metrics.has_relative_humidity;
-        } else {
-            // prefer bmp3xx temp if both sensors are present, fetch only humidity
-            meshtastic_Telemetry m_ahtx = meshtastic_Telemetry_init_zero;
-            LOG_INFO("AHTX0+BMP3XX module detected: using temp from BMP3XX and humy from AHTX0");
-            aht10Sensor.getMetrics(&m_ahtx);
-            m->variant.environment_metrics.relative_humidity = m_ahtx.variant.environment_metrics.relative_humidity;
-            m->variant.environment_metrics.has_relative_humidity = m_ahtx.variant.environment_metrics.has_relative_humidity;
-        }
-    }
     if (max17048Sensor.hasSensor()) {
         valid = valid && max17048Sensor.getMetrics(m);
         hasSensor = true;
     }
-    if (cgRadSens.hasSensor()) {
-        valid = valid && cgRadSens.getMetrics(m);
-        hasSensor = true;
-    }
-    if (pct2075Sensor.hasSensor()) {
-        valid = valid && pct2075Sensor.getMetrics(m);
-        hasSensor = true;
-    }
+#endif
 #ifdef HAS_RAKPROT
     valid = valid && rak9154Sensor.getMetrics(m);
     hasSensor = true;
-#endif
-#if __has_include("RAK12035_SoilMoisture.h") && defined(RAK_4631) &&                                                             \
-                  RAK_4631 ==                                                                                                    \
-                      1 // Not really needed, but may as well just skip at a lower level it if no library or not a RAK_4631
-    if (rak12035Sensor.hasSensor()) {
-        valid = valid && rak12035Sensor.getMetrics(m);
-        hasSensor = true;
-    }
-#endif
 #endif
     return valid && hasSensor;
 }
@@ -737,11 +615,8 @@ bool EnvironmentTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
     meshtastic_Telemetry m = meshtastic_Telemetry_init_zero;
     m.which_variant = meshtastic_Telemetry_environment_metrics_tag;
     m.time = getTime();
-#ifdef T1000X_SENSOR_EN
-    if (t1000xSensor.getMetrics(&m)) {
-#else
+
     if (getEnvironmentTelemetry(&m)) {
-#endif
         LOG_INFO("Send: barometric_pressure=%f, current=%f, gas_resistance=%f, relative_humidity=%f, temperature=%f",
                  m.variant.environment_metrics.barometric_pressure, m.variant.environment_metrics.current,
                  m.variant.environment_metrics.gas_resistance, m.variant.environment_metrics.relative_humidity,
@@ -803,71 +678,13 @@ AdminMessageHandleResult EnvironmentTelemetryModule::handleAdminMessageForModule
 {
     AdminMessageHandleResult result = AdminMessageHandleResult::NOT_HANDLED;
 #if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR_EXTERNAL
-    if (dfRobotLarkSensor.hasSensor()) {
-        result = dfRobotLarkSensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (dfRobotGravitySensor.hasSensor()) {
-        result = dfRobotGravitySensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (sht31Sensor.hasSensor()) {
-        result = sht31Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (lps22hbSensor.hasSensor()) {
-        result = lps22hbSensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (shtc3Sensor.hasSensor()) {
-        result = shtc3Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (bmp085Sensor.hasSensor()) {
-        result = bmp085Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (bmp280Sensor.hasSensor()) {
-        result = bmp280Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (bme280Sensor.hasSensor()) {
-        result = bme280Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (ltr390uvSensor.hasSensor()) {
-        result = ltr390uvSensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (bmp3xxSensor.hasSensor()) {
-        result = bmp3xxSensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (bme680Sensor.hasSensor()) {
-        result = bme680Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (dps310Sensor.hasSensor()) {
-        result = dps310Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (mcp9808Sensor.hasSensor()) {
-        result = mcp9808Sensor.handleAdminMessage(mp, request, response);
+
+    for (TelemetrySensor *sensor : sensors) {
+        result = sensor->handleAdminMessage(mp, request, response);
         if (result != AdminMessageHandleResult::NOT_HANDLED)
             return result;
     }
+
     if (ina219Sensor.hasSensor()) {
         result = ina219Sensor.handleAdminMessage(mp, request, response);
         if (result != AdminMessageHandleResult::NOT_HANDLED)
@@ -883,60 +700,11 @@ AdminMessageHandleResult EnvironmentTelemetryModule::handleAdminMessageForModule
         if (result != AdminMessageHandleResult::NOT_HANDLED)
             return result;
     }
-    if (veml7700Sensor.hasSensor()) {
-        result = veml7700Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (tsl2591Sensor.hasSensor()) {
-        result = tsl2591Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (opt3001Sensor.hasSensor()) {
-        result = opt3001Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (mlx90632Sensor.hasSensor()) {
-        result = mlx90632Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (rcwl9620Sensor.hasSensor()) {
-        result = rcwl9620Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (nau7802Sensor.hasSensor()) {
-        result = nau7802Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-    if (aht10Sensor.hasSensor()) {
-        result = aht10Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
     if (max17048Sensor.hasSensor()) {
         result = max17048Sensor.handleAdminMessage(mp, request, response);
         if (result != AdminMessageHandleResult::NOT_HANDLED)
             return result;
     }
-    if (cgRadSens.hasSensor()) {
-        result = cgRadSens.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-#if __has_include("RAK12035_SoilMoisture.h") && defined(RAK_4631) &&                                                             \
-                  RAK_4631 ==                                                                                                    \
-                      1 // Not really needed, but may as well just skip it at a lower level if no library or not a RAK_4631
-    if (rak12035Sensor.hasSensor()) {
-        result = rak12035Sensor.handleAdminMessage(mp, request, response);
-        if (result != AdminMessageHandleResult::NOT_HANDLED)
-            return result;
-    }
-#endif
 #endif
     return result;
 }
diff --git a/src/modules/Telemetry/EnvironmentTelemetry.h b/src/modules/Telemetry/EnvironmentTelemetry.h
index d70c063fc6..6e4ce82e7b 100644
--- a/src/modules/Telemetry/EnvironmentTelemetry.h
+++ b/src/modules/Telemetry/EnvironmentTelemetry.h
@@ -11,10 +11,13 @@
 #include "../mesh/generated/meshtastic/telemetry.pb.h"
 #include "NodeDB.h"
 #include "ProtobufModule.h"
+#include "detect/ScanI2CConsumer.h"
 #include <OLEDDisplay.h>
 #include <OLEDDisplayUi.h>
 
-class EnvironmentTelemetryModule : private concurrency::OSThread, public ProtobufModule<meshtastic_Telemetry>
+class EnvironmentTelemetryModule : private concurrency::OSThread,
+                                   public ScanI2CConsumer,
+                                   public ProtobufModule<meshtastic_Telemetry>
 {
     CallbackObserver<EnvironmentTelemetryModule, const meshtastic::Status *> nodeStatusObserver =
         CallbackObserver<EnvironmentTelemetryModule, const meshtastic::Status *>(this,
@@ -22,7 +25,7 @@ class EnvironmentTelemetryModule : private concurrency::OSThread, public Protobu
 
   public:
     EnvironmentTelemetryModule()
-        : concurrency::OSThread("EnvironmentTelemetry"),
+        : concurrency::OSThread("EnvironmentTelemetry"), ScanI2CConsumer(),
           ProtobufModule("EnvironmentTelemetry", meshtastic_PortNum_TELEMETRY_APP, &meshtastic_Telemetry_msg)
     {
         lastMeasurementPacket = nullptr;
@@ -56,6 +59,8 @@ class EnvironmentTelemetryModule : private concurrency::OSThread, public Protobu
                                                                  meshtastic_AdminMessage *request,
                                                                  meshtastic_AdminMessage *response) override;
 
+    void i2cScanFinished(ScanI2C *i2cScanner);
+
   private:
     bool firstTime = 1;
     meshtastic_MeshPacket *lastMeasurementPacket;
diff --git a/src/modules/Telemetry/Sensor/AHT10.cpp b/src/modules/Telemetry/Sensor/AHT10.cpp
index 35934533b9..52fdc05c00 100644
--- a/src/modules/Telemetry/Sensor/AHT10.cpp
+++ b/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;
 }
diff --git a/src/modules/Telemetry/Sensor/AHT10.h b/src/modules/Telemetry/Sensor/AHT10.h
index a6fa19952a..ab3f5806c5 100644
--- a/src/modules/Telemetry/Sensor/AHT10.h
+++ b/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
diff --git a/src/modules/Telemetry/Sensor/BME280Sensor.cpp b/src/modules/Telemetry/Sensor/BME280Sensor.cpp
index d7b0a8a38b..779b2e603d 100644
--- a/src/modules/Telemetry/Sensor/BME280Sensor.cpp
+++ b/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;
diff --git a/src/modules/Telemetry/Sensor/BME280Sensor.h b/src/modules/Telemetry/Sensor/BME280Sensor.h
index d1e21c8d5c..fadae46cdc 100644
--- a/src/modules/Telemetry/Sensor/BME280Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/BME680Sensor.cpp b/src/modules/Telemetry/Sensor/BME680Sensor.cpp
index fce029deb7..95f3dc5f02 100644
--- a/src/modules/Telemetry/Sensor/BME680Sensor.cpp
+++ b/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)
diff --git a/src/modules/Telemetry/Sensor/BME680Sensor.h b/src/modules/Telemetry/Sensor/BME680Sensor.h
index ce1fa4f3b8..f4ead95f78 100644
--- a/src/modules/Telemetry/Sensor/BME680Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/BMP085Sensor.cpp b/src/modules/Telemetry/Sensor/BMP085Sensor.cpp
index 8087eb4b96..1fb2ecc286 100644
--- a/src/modules/Telemetry/Sensor/BMP085Sensor.cpp
+++ b/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;
diff --git a/src/modules/Telemetry/Sensor/BMP085Sensor.h b/src/modules/Telemetry/Sensor/BMP085Sensor.h
index 8dadceab48..12ccf35a18 100644
--- a/src/modules/Telemetry/Sensor/BMP085Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/BMP280Sensor.cpp b/src/modules/Telemetry/Sensor/BMP280Sensor.cpp
index 47069b8e03..2b7407c433 100644
--- a/src/modules/Telemetry/Sensor/BMP280Sensor.cpp
+++ b/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;
diff --git a/src/modules/Telemetry/Sensor/BMP280Sensor.h b/src/modules/Telemetry/Sensor/BMP280Sensor.h
index d615411b2b..2199fc0cd3 100644
--- a/src/modules/Telemetry/Sensor/BMP280Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/BMP3XXSensor.cpp b/src/modules/Telemetry/Sensor/BMP3XXSensor.cpp
index 28a71b48f8..ac80732bf8 100644
--- a/src/modules/Telemetry/Sensor/BMP3XXSensor.cpp
+++ b/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)
diff --git a/src/modules/Telemetry/Sensor/BMP3XXSensor.h b/src/modules/Telemetry/Sensor/BMP3XXSensor.h
index 6ab0f533d9..7ce14d9dba 100644
--- a/src/modules/Telemetry/Sensor/BMP3XXSensor.h
+++ b/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
diff --git a/src/modules/Telemetry/Sensor/CGRadSensSensor.cpp b/src/modules/Telemetry/Sensor/CGRadSensSensor.cpp
index ac5df1b813..e7b1913986 100644
--- a/src/modules/Telemetry/Sensor/CGRadSensSensor.cpp
+++ b/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
diff --git a/src/modules/Telemetry/Sensor/CGRadSensSensor.h b/src/modules/Telemetry/Sensor/CGRadSensSensor.h
index 3b15a19a21..c677e88996 100644
--- a/src/modules/Telemetry/Sensor/CGRadSensSensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/DFRobotGravitySensor.cpp b/src/modules/Telemetry/Sensor/DFRobotGravitySensor.cpp
index 9581057b0b..59a98e2911 100644
--- a/src/modules/Telemetry/Sensor/DFRobotGravitySensor.cpp
+++ b/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);
diff --git a/src/modules/Telemetry/Sensor/DFRobotGravitySensor.h b/src/modules/Telemetry/Sensor/DFRobotGravitySensor.h
index dfd81a913f..2b4890e30a 100644
--- a/src/modules/Telemetry/Sensor/DFRobotGravitySensor.h
+++ b/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
diff --git a/src/modules/Telemetry/Sensor/DFRobotLarkSensor.cpp b/src/modules/Telemetry/Sensor/DFRobotLarkSensor.cpp
index d962f1634b..2c2aeed6dc 100644
--- a/src/modules/Telemetry/Sensor/DFRobotLarkSensor.cpp
+++ b/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;
diff --git a/src/modules/Telemetry/Sensor/DFRobotLarkSensor.h b/src/modules/Telemetry/Sensor/DFRobotLarkSensor.h
index 7b67bc5b62..f3e4661a13 100644
--- a/src/modules/Telemetry/Sensor/DFRobotLarkSensor.h
+++ b/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
diff --git a/src/modules/Telemetry/Sensor/DPS310Sensor.cpp b/src/modules/Telemetry/Sensor/DPS310Sensor.cpp
index cc9b83af8b..19e54aa4b1 100644
--- a/src/modules/Telemetry/Sensor/DPS310Sensor.cpp
+++ b/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;
diff --git a/src/modules/Telemetry/Sensor/DPS310Sensor.h b/src/modules/Telemetry/Sensor/DPS310Sensor.h
index e9b4ece893..4de8b2d1ad 100644
--- a/src/modules/Telemetry/Sensor/DPS310Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/IndicatorSensor.cpp b/src/modules/Telemetry/Sensor/IndicatorSensor.cpp
index 3173571371..26a4bc5fc5 100644
--- a/src/modules/Telemetry/Sensor/IndicatorSensor.cpp
+++ b/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()
diff --git a/src/modules/Telemetry/Sensor/IndicatorSensor.h b/src/modules/Telemetry/Sensor/IndicatorSensor.h
index 48ecef8dea..22a0d9c833 100644
--- a/src/modules/Telemetry/Sensor/IndicatorSensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/LPS22HBSensor.cpp b/src/modules/Telemetry/Sensor/LPS22HBSensor.cpp
index cf0fbe4a96..4ed78dcb03 100644
--- a/src/modules/Telemetry/Sensor/LPS22HBSensor.cpp
+++ b/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)
diff --git a/src/modules/Telemetry/Sensor/LPS22HBSensor.h b/src/modules/Telemetry/Sensor/LPS22HBSensor.h
index 24d75e903c..90b006fa21 100644
--- a/src/modules/Telemetry/Sensor/LPS22HBSensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/LTR390UVSensor.cpp b/src/modules/Telemetry/Sensor/LTR390UVSensor.cpp
index fb84700c48..cb7290fee4 100644
--- a/src/modules/Telemetry/Sensor/LTR390UVSensor.cpp
+++ b/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");
diff --git a/src/modules/Telemetry/Sensor/LTR390UVSensor.h b/src/modules/Telemetry/Sensor/LTR390UVSensor.h
index 40206bce8d..e12d172742 100644
--- a/src/modules/Telemetry/Sensor/LTR390UVSensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/MCP9808Sensor.cpp b/src/modules/Telemetry/Sensor/MCP9808Sensor.cpp
index 906634c405..c93d6a927f 100644
--- a/src/modules/Telemetry/Sensor/MCP9808Sensor.cpp
+++ b/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)
diff --git a/src/modules/Telemetry/Sensor/MCP9808Sensor.h b/src/modules/Telemetry/Sensor/MCP9808Sensor.h
index 705a717003..cef7a48c2c 100644
--- a/src/modules/Telemetry/Sensor/MCP9808Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/MLX90632Sensor.cpp b/src/modules/Telemetry/Sensor/MLX90632Sensor.cpp
index dfc0490230..eb84edffce 100644
--- a/src/modules/Telemetry/Sensor/MLX90632Sensor.cpp
+++ b/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;
diff --git a/src/modules/Telemetry/Sensor/MLX90632Sensor.h b/src/modules/Telemetry/Sensor/MLX90632Sensor.h
index ef7be180ac..566db83197 100644
--- a/src/modules/Telemetry/Sensor/MLX90632Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/NAU7802Sensor.cpp b/src/modules/Telemetry/Sensor/NAU7802Sensor.cpp
index b6b5d89f78..e67b781451 100644
--- a/src/modules/Telemetry/Sensor/NAU7802Sensor.cpp
+++ b/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");
diff --git a/src/modules/Telemetry/Sensor/NAU7802Sensor.h b/src/modules/Telemetry/Sensor/NAU7802Sensor.h
index cb9e64829c..a45e9a78a6 100644
--- a/src/modules/Telemetry/Sensor/NAU7802Sensor.h
+++ b/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,
diff --git a/src/modules/Telemetry/Sensor/OPT3001Sensor.cpp b/src/modules/Telemetry/Sensor/OPT3001Sensor.cpp
index 1f04073745..3407f2f0f0 100644
--- a/src/modules/Telemetry/Sensor/OPT3001Sensor.cpp
+++ b/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)
diff --git a/src/modules/Telemetry/Sensor/OPT3001Sensor.h b/src/modules/Telemetry/Sensor/OPT3001Sensor.h
index a9da2d7051..c8a140b51d 100644
--- a/src/modules/Telemetry/Sensor/OPT3001Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/PCT2075Sensor.cpp b/src/modules/Telemetry/Sensor/PCT2075Sensor.cpp
index d2b50d983d..189317bf2b 100644
--- a/src/modules/Telemetry/Sensor/PCT2075Sensor.cpp
+++ b/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;
diff --git a/src/modules/Telemetry/Sensor/PCT2075Sensor.h b/src/modules/Telemetry/Sensor/PCT2075Sensor.h
index 842c973d08..55f9423d40 100644
--- a/src/modules/Telemetry/Sensor/PCT2075Sensor.h
+++ b/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
diff --git a/src/modules/Telemetry/Sensor/RAK12035Sensor.cpp b/src/modules/Telemetry/Sensor/RAK12035Sensor.cpp
index 7a1bb01ceb..ff0628cc37 100644
--- a/src/modules/Telemetry/Sensor/RAK12035Sensor.cpp
+++ b/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()
diff --git a/src/modules/Telemetry/Sensor/RAK12035Sensor.h b/src/modules/Telemetry/Sensor/RAK12035Sensor.h
index 2c32a840d4..6a38d2eb31 100644
--- a/src/modules/Telemetry/Sensor/RAK12035Sensor.h
+++ b/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
diff --git a/src/modules/Telemetry/Sensor/RCWL9620Sensor.cpp b/src/modules/Telemetry/Sensor/RCWL9620Sensor.cpp
index 9f7a55cc50..3dbd06e8d6 100644
--- a/src/modules/Telemetry/Sensor/RCWL9620Sensor.cpp
+++ b/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;
diff --git a/src/modules/Telemetry/Sensor/RCWL9620Sensor.h b/src/modules/Telemetry/Sensor/RCWL9620Sensor.h
index 7f9486d25e..408db36330 100644
--- a/src/modules/Telemetry/Sensor/RCWL9620Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/SHT31Sensor.cpp b/src/modules/Telemetry/Sensor/SHT31Sensor.cpp
index 8619a79059..67a36933d8 100644
--- a/src/modules/Telemetry/Sensor/SHT31Sensor.cpp
+++ b/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)
diff --git a/src/modules/Telemetry/Sensor/SHT31Sensor.h b/src/modules/Telemetry/Sensor/SHT31Sensor.h
index c3d81af954..ecb7d63a62 100644
--- a/src/modules/Telemetry/Sensor/SHT31Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/SHT4XSensor.cpp b/src/modules/Telemetry/Sensor/SHT4XSensor.cpp
index 83fdaf6c6d..b11795d972 100644
--- a/src/modules/Telemetry/Sensor/SHT4XSensor.cpp
+++ b/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)
diff --git a/src/modules/Telemetry/Sensor/SHT4XSensor.h b/src/modules/Telemetry/Sensor/SHT4XSensor.h
index da608cb82c..7311d23668 100644
--- a/src/modules/Telemetry/Sensor/SHT4XSensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/SHTC3Sensor.cpp b/src/modules/Telemetry/Sensor/SHTC3Sensor.cpp
index e9c4d2a0b2..fdab0b2668 100644
--- a/src/modules/Telemetry/Sensor/SHTC3Sensor.cpp
+++ b/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)
diff --git a/src/modules/Telemetry/Sensor/SHTC3Sensor.h b/src/modules/Telemetry/Sensor/SHTC3Sensor.h
index 458af6465e..51cee18f77 100644
--- a/src/modules/Telemetry/Sensor/SHTC3Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/T1000xSensor.cpp b/src/modules/Telemetry/Sensor/T1000xSensor.cpp
index 068969e8e5..b123450ec3 100644
--- a/src/modules/Telemetry/Sensor/T1000xSensor.cpp
+++ b/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()
diff --git a/src/modules/Telemetry/Sensor/T1000xSensor.h b/src/modules/Telemetry/Sensor/T1000xSensor.h
index a1c771cfae..b840a2d882 100644
--- a/src/modules/Telemetry/Sensor/T1000xSensor.h
+++ b/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();
 };
diff --git a/src/modules/Telemetry/Sensor/TSL2561Sensor.cpp b/src/modules/Telemetry/Sensor/TSL2561Sensor.cpp
index 9f3b7e4609..4e02af6422 100644
--- a/src/modules/Telemetry/Sensor/TSL2561Sensor.cpp
+++ b/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(nodeTelemetrySensorsMap[sensorType].second);
-
-    return initI2CSensor();
-}
 
-void TSL2561Sensor::setup()
-{
+    status = tsl.begin(bus);
+    if (!status) {
+        return status;
+    }
     tsl.setGain(TSL2561_GAIN_1X);
     tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_101MS);
+
+    initI2CSensor();
+    return status;
 }
 
 bool TSL2561Sensor::getMetrics(meshtastic_Telemetry *measurement)
diff --git a/src/modules/Telemetry/Sensor/TSL2561Sensor.h b/src/modules/Telemetry/Sensor/TSL2561Sensor.h
index 0329becd8a..abf5a8f739 100644
--- a/src/modules/Telemetry/Sensor/TSL2561Sensor.h
+++ b/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
diff --git a/src/modules/Telemetry/Sensor/TSL2591Sensor.cpp b/src/modules/Telemetry/Sensor/TSL2591Sensor.cpp
index 04443ebeca..0899d44700 100644
--- a/src/modules/Telemetry/Sensor/TSL2591Sensor.cpp
+++ b/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)
diff --git a/src/modules/Telemetry/Sensor/TSL2591Sensor.h b/src/modules/Telemetry/Sensor/TSL2591Sensor.h
index edf7698b1f..1ac430a03d 100644
--- a/src/modules/Telemetry/Sensor/TSL2591Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/TelemetrySensor.h b/src/modules/Telemetry/Sensor/TelemetrySensor.h
index 83d7b38b06..3c3e618089 100644
--- a/src/modules/Telemetry/Sensor/TelemetrySensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/VEML7700Sensor.cpp b/src/modules/Telemetry/Sensor/VEML7700Sensor.cpp
index b075bf405a..c89463be5f 100644
--- a/src/modules/Telemetry/Sensor/VEML7700Sensor.cpp
+++ b/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
diff --git a/src/modules/Telemetry/Sensor/VEML7700Sensor.h b/src/modules/Telemetry/Sensor/VEML7700Sensor.h
index f40384ad39..92883df080 100644
--- a/src/modules/Telemetry/Sensor/VEML7700Sensor.h
+++ b/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
\ No newline at end of file
diff --git a/src/modules/Telemetry/Sensor/nullSensor.cpp b/src/modules/Telemetry/Sensor/nullSensor.cpp
index c84b9d27f5..1d545186a2 100644
--- a/src/modules/Telemetry/Sensor/nullSensor.cpp
+++ b/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() {}