Add MAX17043 battery sensor support and related components

.gitignore

@@ -22,6 +22,8 @@
 !blueprints/
 !esphome/
 !esphome/ha-remote/
+!esphome/ha-remote/components/
+!esphome/ha-remote/components/**
 !custom_components/
 # !packages/
 # !themes/

esphome/ha-remote-1.yaml

@@ -5,6 +5,8 @@ substitutions:
 esphome:
   name: ${device_name}
   friendly_name: ${friendly_name}
+  include:
+    - MAX17048_component.h
   on_boot:
     priority: -10
     then:
@@ -43,6 +45,12 @@ wifi:
 
 captive_portal:
 
+external_components:
+  - source:
+      type: local
+      path: ha-remote/components
+    components: [max17043]
+
 packages:
   base: !include ha-remote/ha-remote-1.base.yaml
   bindings: !include ha-remote/ha-remote-1.bindings.yaml

esphome/ha-remote/components/max17043/__init__.py

@@ -0,0 +1 @@
+CODEOWNERS = ["@blacknell"]

esphome/ha-remote/components/max17043/automation.h

@@ -0,0 +1,20 @@
+
+#pragma once
+#include "esphome/core/automation.h"
+#include "max17043.h"
+
+namespace esphome {
+namespace max17043 {
+
+template<typename... Ts> class SleepAction : public Action<Ts...> {
+ public:
+  explicit SleepAction(MAX17043Component *max17043) : max17043_(max17043) {}
+
+  void play(Ts... x) override { this->max17043_->sleep_mode(); }
+
+ protected:
+  MAX17043Component *max17043_;
+};
+
+}  // namespace max17043
+}  // namespace esphome

esphome/ha-remote/components/max17043/max17043.cpp

@@ -0,0 +1,72 @@
+#include "max17043.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace max17043 {
+
+// MAX174043 is a 1-Cell Fuel Gauge with ModelGauge and Low-Battery Alert
+// Consult the datasheet at https://www.analog.com/en/products/max17043.html
+
+static const char *const TAG = "max17043";
+
+static const uint8_t MAX17043_VCELL = 0x02;
+static const uint8_t MAX17043_SOC = 0x04;
+static const uint8_t MAX17043_CONFIG = 0x0c;
+
+static const uint16_t MAX17043_CONFIG_POWER_UP_DEFAULT = 0x971C;
+static const uint16_t MAX17043_CONFIG_SAFE_MASK = 0xFF1F;  // mask out sleep bit (7), unused bit (6) and alert bit (4)
+static const uint16_t MAX17043_CONFIG_SLEEP_MASK = 0x0080;
+
+void MAX17043Component::update() {
+  uint16_t raw_voltage, raw_percent;
+
+  if (this->voltage_sensor_ != nullptr) {
+    if (!this->read_byte_16(MAX17043_VCELL, &raw_voltage)) {
+      this->status_set_warning("Unable to read MAX17043_VCELL");
+    } else {
+      float voltage = (1.25 * (float) (raw_voltage >> 4)) / 1000.0;
+      this->voltage_sensor_->publish_state(voltage);
+      this->status_clear_warning();
+    }
+  }
+  if (this->battery_remaining_sensor_ != nullptr) {
+    if (!this->read_byte_16(MAX17043_SOC, &raw_percent)) {
+      this->status_set_warning("Unable to read MAX17043_SOC");
+    } else {
+      float percent = (float) ((raw_percent >> 8) + 0.003906f * (raw_percent & 0x00ff));
+      this->battery_remaining_sensor_->publish_state(percent);
+      this->status_clear_warning();
+    }
+  }
+}
+
+void MAX17043Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up MAX17043...");
+  // Compatible mode for MAX17048/variant boards:
+  // avoid setup-time register writes on the shared touch I2C bus.
+}
+
+void MAX17043Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "MAX17043:");
+  LOG_I2C_DEVICE(this);
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Communication with MAX17043 failed");
+  }
+  LOG_UPDATE_INTERVAL(this);
+  LOG_SENSOR("  ", "Battery Voltage", this->voltage_sensor_);
+  LOG_SENSOR("  ", "Battery Level", this->battery_remaining_sensor_);
+}
+
+float MAX17043Component::get_setup_priority() const { return setup_priority::DATA; }
+
+void MAX17043Component::sleep_mode() {
+  if (!this->is_failed()) {
+    if (!this->write_byte_16(MAX17043_CONFIG, MAX17043_CONFIG_POWER_UP_DEFAULT | MAX17043_CONFIG_SLEEP_MASK)) {
+      ESP_LOGW(TAG, "Unable to write the sleep bit to config register");
+      this->status_set_warning();
+    }
+  }
+}
+
+}  // namespace max17043
+}  // namespace esphome

esphome/ha-remote/components/max17043/max17043.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace max17043 {
+
+class MAX17043Component : public PollingComponent, public i2c::I2CDevice {
+ public:
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+  void update() override;
+  void sleep_mode();
+
+  void set_voltage_sensor(sensor::Sensor *voltage_sensor) { voltage_sensor_ = voltage_sensor; }
+  void set_battery_remaining_sensor(sensor::Sensor *battery_remaining_sensor) {
+    battery_remaining_sensor_ = battery_remaining_sensor;
+  }
+
+ protected:
+  sensor::Sensor *voltage_sensor_{nullptr};
+  sensor::Sensor *battery_remaining_sensor_{nullptr};
+};
+
+}  // namespace max17043
+}  // namespace esphome

esphome/ha-remote/components/max17043/sensor.py

@@ -0,0 +1,77 @@
+from esphome import automation
+from esphome.automation import maybe_simple_id
+import esphome.codegen as cg
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_BATTERY_LEVEL,
+    CONF_BATTERY_VOLTAGE,
+    CONF_ID,
+    DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_VOLTAGE,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_PERCENT,
+    UNIT_VOLT,
+)
+
+DEPENDENCIES = ["i2c"]
+
+max17043_ns = cg.esphome_ns.namespace("max17043")
+MAX17043Component = max17043_ns.class_(
+    "MAX17043Component", cg.PollingComponent, i2c.I2CDevice
+)
+
+# Actions
+SleepAction = max17043_ns.class_("SleepAction", automation.Action)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(MAX17043Component),
+            cv.Optional(CONF_BATTERY_VOLTAGE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_VOLT,
+                accuracy_decimals=3,
+                device_class=DEVICE_CLASS_VOLTAGE,
+                state_class=STATE_CLASS_MEASUREMENT,
+                entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            ),
+            cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                accuracy_decimals=3,
+                device_class=DEVICE_CLASS_BATTERY,
+                state_class=STATE_CLASS_MEASUREMENT,
+                entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x36))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    if voltage_config := config.get(CONF_BATTERY_VOLTAGE):
+        sens = await sensor.new_sensor(voltage_config)
+        cg.add(var.set_voltage_sensor(sens))
+
+    if CONF_BATTERY_LEVEL in config:
+        sens = await sensor.new_sensor(config[CONF_BATTERY_LEVEL])
+        cg.add(var.set_battery_remaining_sensor(sens))
+
+
+MAX17043_ACTION_SCHEMA = maybe_simple_id(
+    {
+        cv.Required(CONF_ID): cv.use_id(MAX17043Component),
+    }
+)
+
+
+@automation.register_action("max17043.sleep_mode", SleepAction, MAX17043_ACTION_SCHEMA)
+async def max17043_sleep_mode_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)

esphome/ha-remote/ha-remote-1.base.yaml

@@ -131,32 +131,43 @@ font:
 # Note: On ESP32-S3-Touch-LCD-7, GPIO14 is used by the RGB display bus,
 # so it cannot be reused as ADC for battery telemetry in this display mode.
 
-# --- Battery fuel gauge (Adafruit MAX17048) ---
+# --- Battery fuel gauge (Adafruit MAX17048 via compatible driver) ---
 sensor:
-  - platform: max17048
-    id: max17048_battery
-    i2c_id: i2c_main
-    update_interval: 120s
-    battery_voltage:
-      name: "Remote Battery Voltage"
-      id: remote_battery_voltage
-      entity_category: diagnostic
-      device_class: voltage
-      state_class: measurement
-      accuracy_decimals: 3
-      on_value:
-        then:
-          - lambda: |-
-              ESP_LOGI("battery", "Voltage: %.3f V", x);
-    battery_level:
-      name: "Remote Battery Level"
-      id: remote_battery_level
-      entity_category: diagnostic
-      device_class: battery
-      state_class: measurement
-      accuracy_decimals: 0
-      on_value:
-        then:
-          - lambda: |-
-              const float pct = x;
-              ESP_LOGI("battery", "Level: %.0f%%", pct);
+  # - platform: max17043
+  #   id: max17048_battery
+  #   i2c_id: i2c_main
+  #   update_interval: 120s
+  #   battery_voltage:
+  #     name: "Remote Battery Voltage"
+  #     id: remote_battery_voltage
+  #     entity_category: diagnostic
+  #     device_class: voltage
+  #     state_class: measurement
+  #     accuracy_decimals: 3
+  #     on_value:
+  #       then:
+  #         - lambda: |-
+  #             ESP_LOGI("battery", "Voltage: %.3f V", x);
+  #   battery_level:
+  #     name: "Remote Battery Level"
+  #     id: remote_battery_level
+  #     entity_category: diagnostic
+  #     device_class: battery
+  #     state_class: measurement
+  #     accuracy_decimals: 0
+  #     on_value:
+  #       then:
+  #         - lambda: |-
+  #             const float pct = x;
+  #             ESP_LOGI("battery", "Level: %.0f%%", pct);
+  - platform: custom
+    lambda: |-
+      auto max17048_sensor = new MAX17048Sensor();
+      App.register_component(max17048_sensor);
+      return {max17048_sensor->voltage_sensor, max17048_sensor->percentage_sensor};
+    sensors:
+      - name: "Voltage"
+        unit_of_measurement: V
+        accuracy_decimals: 2
+      - name: "Percentage"
+        unit_of_measurement: '%'