Refactor sensors to use I2c base class

Convert multiple sensor/device classes to derive from a common I2c interface and consolidate I2C usage. Moved device register/constants into reg namespaces and standardized constant names (k-prefix), added inline implementations for read/write/initialization in headers, and removed several now-redundant source files. Updates include BH1750, HTU21D/Si7021, INA219, MCP3424, MCP9808, SC16IS740 and SI5351A (headers updated; some .cpp files deleted or adapted), added timing/read delays and initialization checks, and minor copyright year bumps. This refactor centralizes I2C interactions, simplifies constructors (auto-initialize/configure), and modernizes naming and register handling.

Author: vanvught

lib-device/include/bh1750.h

@@ -28,23 +28,46 @@
 
 #include <cstdint>
 
+#include "i2c.h"
+
 namespace sensor {
 namespace bh1750 {
+static constexpr uint8_t kI2CAddress = 0x23;
 inline constexpr char kDescription[] = "Ambient Light";
 inline constexpr auto kRangeMin = 0;
 inline constexpr auto kRangeMax = 65535;
+namespace reg {
+// static constexpr uint8_t POWER_DOWN = 0x00;
+static constexpr uint8_t kPowerOn = 0x01;
+// static constexpr uint8_t RESET = 0x07;
+static constexpr uint8_t kContinuousHighResMode = 0x10;
+// static constexpr uint8_t CONTINUOUS_HIGH_RES_MODE_2 = 0x11;
+// static constexpr uint8_t CONTINUOUS_LOW_RES_MODE = 0x13;
+// static constexpr uint8_t ONE_TIME_HIGH_RES_MODE = 0x20;
+// static constexpr uint8_t ONE_TIME_HIGH_RES_MODE_2 = 0x21;
+// static constexpr uint8_t ONE_TIME_LOW_RES_MODE = 0x23;
+} // namespace reg
 } // namespace bh1750
 
-class BH1750 {
+class BH1750 : I2c {
    public:
-    explicit BH1750(uint8_t address = 0);
+    explicit BH1750(uint8_t address = 0) : I2c(address == 0 ? sensor::bh1750::kI2CAddress : address) {
+        initialized_ = IsConnected();
+
+        if (initialized_) {
+            Write(sensor::bh1750::reg::kPowerOn, true);
+            Write(sensor::bh1750::reg::kContinuousHighResMode, false);
+        }
+    }
 
     bool Initialize() { return initialized_; }
 
-    uint16_t Get();
+    uint16_t Get() {
+        const auto kLevel = static_cast<uint16_t>(static_cast<float>(Read16(true)) / 1.2f);
+        return kLevel;
+    }
 
    private:
-    uint8_t address_{0};
     bool initialized_{false};
 };
 } // namespace sensor

lib-device/include/htu21d.h

@@ -28,8 +28,11 @@
 
 #include <cstdint>
 
+#include "i2c.h"
+
 namespace sensor {
 namespace htu21d {
+inline constexpr uint8_t kI2CAddress = 0x40;
 namespace temperature {
 inline constexpr char kDescription[] = "Ambient Temperature";
 inline constexpr int16_t kRangeMin = -40;
@@ -40,25 +43,58 @@ inline constexpr char kDescription[] = "Relative Humidity";
 inline constexpr int16_t kRangeMin = 0;
 inline constexpr int16_t kRangeMax = 100;
 } // namespace humidity
+namespace reg {
+// static constexpr uint8_t TRIGGER_TEMP_MEASURE_HOLD = 0xE3;
+// static constexpr uint8_t TRIGGER_HUMD_MEASURE_HOLD = 0xE5;
+inline constexpr uint8_t kTriggerTempMeasureNohold = 0xF3;
+inline constexpr uint8_t kTriggerHumdMeasureNohold = 0xF5;
+// static constexpr uint8_t WRITE_USER_REG = 0xE6;
+// static constexpr uint8_t READ_USER_REG = 0xE7;
+// static constexpr uint8_t SOFT_RESET = 0xFE;
+} // namespace reg
 } // namespace htu21d
 
-class HTU21D  {
+class HTU21D: I2c {
    public:
-    explicit HTU21D(uint8_t address = 0);
+    explicit HTU21D(uint8_t address = 0) : I2c(address == 0 ? sensor::htu21d::kI2CAddress : address) {
+        initialized_ = IsConnected();
+    }
 
-    bool Initialize() { return initialized_; }
+    float GetTemperature() {
+        const auto kTemp = static_cast<float>(ReadRaw(sensor::htu21d::reg::kTriggerTempMeasureNohold)) / 65536.0f;
+        return -46.85f + (175.72f * kTemp);
+    }
 
-    float GetTemperature();
-    float GetHumidity();
+    float GetHumidity() {
+        const auto kHumd = static_cast<float>(ReadRaw(sensor::htu21d::reg::kTriggerHumdMeasureNohold)) / 65536.0f;
+        return -6.0f + (125.0f * kHumd);
+    }
+	
+	bool Initialize() { return initialized_; }
 
    private:
-    uint16_t ReadRaw(uint8_t cmd);
+    uint16_t ReadRaw(uint8_t cmd) {
+        Write(cmd, true);
+
+        char buf[3] = {0};
+
+        for (uint32_t i = 0; i < 8; ++i) {
+            timing::DelayUs(10000);
+            Read(buf, 3, false);
+
+            if ((buf[0] & 0x3) == 2) {
+                break;
+            }
+        }
+
+        const auto kRawValue = static_cast<uint16_t>((buf[0] << 8) | buf[1]);
+
+        return kRawValue & 0xFFFC;
+    }
 
    private:
-   uint8_t address_{0};
-   bool initialized_{false};
+    bool initialized_{false};
 };
-
 } // namespace sensor
 
 #endif // HTU21D_H_

lib-device/include/ina219.h

@@ -28,20 +28,35 @@
 
 #include <cstdint>
 
+#include "i2c.h"
+#include "firmware/debug/debug_debug.h"
+
 namespace sensor {
 namespace ina219 {
-inline constexpr uint16_t RANGE_16V = 0x0000; ///< 0-16V Range
-inline constexpr uint16_t RANGE_32V = 0x2000; ///< 0-32V Range
+inline constexpr uint8_t kI2CAddress = 0x40;
+namespace reg {
+inline constexpr uint8_t kConfig = 0x00;
+// static constexpr uint8_t SHUNTVOLTAGE = 0x01;
+inline constexpr uint8_t kBusvoltage = 0x02;
+inline constexpr uint8_t kPower = 0x03;
+inline constexpr uint8_t kCurrent = 0x04;
+inline constexpr uint8_t kCalibration = 0x05;
+namespace value {
+inline constexpr auto kReadDelayUs = 800;
+} // namespace value
+} // namespace reg
+inline constexpr uint16_t kRange16V = 0x0000; ///< 0-16V Range
+inline constexpr uint16_t kRange32V = 0x2000; ///< 0-32V Range
 
 inline constexpr uint16_t GAIN_40MV = 0x0000;  ///< Gain 1, 40mV Range
 inline constexpr uint16_t GAIN_80MV = 0x0800;  ///< Gain 2, 80mV Range
 inline constexpr uint16_t GAIN_160MV = 0x1000; ///< Gain 4, 160mV Range
 inline constexpr uint16_t GAIN_320MV = 0x1800; ///< Gain 8, 320mV Range
 
-inline constexpr uint16_t BUS_RES_9BIT = 0x0080;  ///< 9-bit bus res = 0..511
-inline constexpr uint16_t BUS_RES_10BIT = 0x0100; ///< 10-bit bus res = 0..1023
-inline constexpr uint16_t BUS_RES_11BIT = 0x0200; ///< 11-bit bus res = 0..2047
-inline constexpr uint16_t BUS_RES_12BIT = 0x0400; ///< 12-bit bus res = 0..4097
+inline constexpr uint16_t kBusRes9Bit = 0x0080;  ///< 9-bit bus res = 0..511
+inline constexpr uint16_t kBusRes10Bit = 0x0100; ///< 10-bit bus res = 0..1023
+inline constexpr uint16_t kBusRes11Bit = 0x0200; ///< 11-bit bus res = 0..2047
+inline constexpr uint16_t kBusRes12Bit = 0x0400; ///< 12-bit bus res = 0..4097
 
 inline constexpr uint16_t SHUNT_RES_9BIT_1S = 0x0000;    ///< 1 x 9-bit shunt sample
 inline constexpr uint16_t SHUNT_RES_10BIT_1S = 0x0008;   ///< 1 x 10-bit shunt sample
@@ -53,23 +68,23 @@ inline constexpr uint16_t SHUNT_RES_12BIT_8S = 0x0058;   ///< 8 x 12-bit shunt s
 inline constexpr uint16_t SHUNT_RES_12BIT_16S = 0x0060;  ///< 16 x 12-bit shunt samples averaged together
 inline constexpr uint16_t SHUNT_RES_12BIT_32S = 0x0068;  ///< 32 x 12-bit shunt samples averaged together
 inline constexpr uint16_t SHUNT_RES_12BIT_64S = 0x0070;  ///< 64 x 12-bit shunt samples averaged together
-inline constexpr uint16_t SHUNT_RES_12BIT_128S = 0x0078; ///< 128 x 12-bit shunt samples averaged together
+inline constexpr uint16_t kShuntRes12Bit128S = 0x0078; ///< 128 x 12-bit shunt samples averaged together
 
-inline constexpr uint16_t MODE_POWER_DOWN = 0x0000;
-inline constexpr uint16_t MODE_SHUNT_TRIG = 0x0001;
-inline constexpr uint16_t MODE_BUS_TRIG = 0x0002;
-inline constexpr uint16_t MODE_SHUNT_BUS_TRIG = 0x0003;
-inline constexpr uint16_t MODE_ADC_OFF = 0x0004;
-inline constexpr uint16_t MODE_SHUNT_CONT = 0x0005;
-inline constexpr uint16_t MODE_BUS_CONT = 0x0006;
-inline constexpr uint16_t MODE_SHUNT_BUS_CONT = 0x0007;
+inline constexpr uint16_t kModePowerDown = 0x0000;
+inline constexpr uint16_t kModeShuntTrig = 0x0001;
+inline constexpr uint16_t kModeBusTrig = 0x0002;
+inline constexpr uint16_t kModeShuntBusTrig = 0x0003;
+inline constexpr uint16_t kModeAdcOff = 0x0004;
+inline constexpr uint16_t kModeShuntCont = 0x0005;
+inline constexpr uint16_t kModeBusCont = 0x0006;
+inline constexpr uint16_t kModeShuntBusCont = 0x0007;
 
 struct Config {
-    uint16_t range = RANGE_32V;
+    uint16_t range = kRange32V;
     uint16_t gain = GAIN_320MV;
-    uint16_t bus_res = BUS_RES_12BIT;
+    uint16_t bus_res = kBusRes12Bit;
     uint16_t shunt_res = SHUNT_RES_12BIT_1S;
-    uint16_t mode = MODE_SHUNT_BUS_CONT;
+    uint16_t mode = kModeShuntBusCont;
 };
 
 namespace current {
@@ -89,25 +104,102 @@ inline constexpr int16_t kRangeMax = 64;  // W
 } // namespace power
 } // namespace ina219
 
-class INA219 {
+class INA219 : I2c {
    public:
-    explicit INA219(uint8_t address = 0);
-
-    void Configure(ina219::Config& config);
-    void Calibrate(float r_shunt_value = 0.1f, float i_max_expected = 2.0f);
+    explicit INA219(uint8_t address) : I2c(address == 0 ? sensor::ina219::kI2CAddress : address) {
+        initialized_ = IsConnected();
+
+        if (initialized_) {
+            sensor::ina219::Config config;
+            Configure(config);
+            Calibrate(0.1f, 2.0f);
+        }
+    }
+
+    void Configure(sensor::ina219::Config& config) {
+        switch (config.range) {
+            case sensor::ina219::kRange32V:
+                info_.v_bus_max = 32.0f;
+                break;
+            case sensor::ina219::kRange16V:
+                info_.v_bus_max = 16.0f;
+                break;
+        }
+
+        switch (config.gain) {
+            case sensor::ina219::GAIN_320MV:
+                info_.v_shunt_max = 0.32f;
+                break;
+            case sensor::ina219::GAIN_160MV:
+                info_.v_shunt_max = 0.16f;
+                break;
+            case sensor::ina219::GAIN_80MV:
+                info_.v_shunt_max = 0.08f;
+                break;
+            case sensor::ina219::GAIN_40MV:
+                info_.v_shunt_max = 0.04f;
+                break;
+        }
+
+        const uint16_t kConfig = config.range | config.gain | config.bus_res | config.shunt_res | config.mode;
+
+        DEBUG_PRINTF("kConfig=%x", kConfig);
+
+        i2c::WriteReg(sensor::ina219::reg::kConfig, kConfig);
+    }
+
+    void Calibrate(float r_shunt_value, float i_max_expected) {
+        const float kMinimumLsb = i_max_expected / 32767;
+
+        info_.r_shunt = r_shunt_value;
+
+        info_.current_lsb = (static_cast<uint16_t>(kMinimumLsb * 100000000));
+        info_.current_lsb /= 100000000;
+        info_.current_lsb /= 0.0001f;
+        info_.current_lsb = CeilingPos(info_.current_lsb);
+        info_.current_lsb *= 0.0001f;
+
+        info_.power_lsb = info_.current_lsb * 20;
+
+        const auto kCalibrationValue = static_cast<uint16_t>((0.04096f / (info_.current_lsb * info_.r_shunt)));
+
+        DEBUG_PRINTF("kCalibrationValue=%x", kCalibrationValue);
+
+        i2c::WriteReg(sensor::ina219::reg::kCalibration, kCalibrationValue);
+    }
+
+    float GetShuntCurrent() {
+        const float kValue = ReadRegister16DelayUs(sensor::ina219::reg::kCurrent, sensor::ina219::reg::value::kReadDelayUs) * info_.current_lsb;
+        return kValue;
+    }
+
+    float GetBusVoltage() { return GetBusVoltageRaw() * 0.001f; }
+
+    float GetBusPower() {
+        const float kValue = ReadRegister16DelayUs(sensor::ina219::reg::kPower, sensor::ina219::reg::value::kReadDelayUs) * info_.power_lsb;
+        return kValue;
+    }
+	
+	bool Initialize() { return initialized_; }
 
-    bool Initialize() { return initialized_; }
+   private:
+    int16_t GetBusVoltageRaw() {
+        auto voltage = ReadRegister16DelayUs(sensor::ina219::reg::kBusvoltage, sensor::ina219::reg::value::kReadDelayUs);
+        voltage = static_cast<uint16_t>(voltage >> 3);
 
-    float GetShuntCurrent();
-    float GetBusVoltage();
-    float GetBusPower();
+        return static_cast<int16_t>(voltage * 4);
+    }
 
-   private:
-    int16_t GetBusVoltageRaw();
+    float CeilingPos(float f) {
+        const auto kI = static_cast<int>(f);
+        if (f == static_cast<float>(kI)) {
+            return static_cast<float>(kI);
+        }
+        return static_cast<float>(kI + 1);
+    }
 
    private:
-    uint8_t address_{0};
-    bool initialized_{false};
+     bool initialized_{false};
 
     struct Info {
         float current_lsb;

lib-device/include/mcp3424.h

@@ -28,6 +28,8 @@
 
 #include <cstdint>
 
+#include "i2c.h"
+
 namespace adc::mcp3424 {
 enum class Gain {
     kPgaX1, ///< Default
@@ -49,7 +51,7 @@ enum class Conversion {
 };
 } // namespace adc::mcp3424
 
-class MCP3424 {
+class MCP3424 : I2c {
    public:
     explicit MCP3424(uint8_t address = 0);
 
@@ -68,7 +70,6 @@ class MCP3424 {
     double GetVoltage(uint32_t channel);
 
    private:
-    uint8_t address_{0};
     bool is_connected_{false};
     uint8_t config_;
     double lsb_;