Add combination sensor and remove absorbed kalman_combinator component (#5438)

CODEOWNERS

@@ -71,6 +71,7 @@ esphome/components/cd74hc4067/* @asoehlke
 esphome/components/climate/* @esphome/core
 esphome/components/climate_ir/* @glmnet
 esphome/components/color_temperature/* @jesserockz
+esphome/components/combination/* @Cat-Ion @kahrendt
 esphome/components/coolix/* @glmnet
 esphome/components/copy/* @OttoWinter
 esphome/components/cover/* @esphome/core
@@ -161,7 +162,6 @@ esphome/components/integration/* @OttoWinter
 esphome/components/internal_temperature/* @Mat931
 esphome/components/interval/* @esphome/core
 esphome/components/json/* @OttoWinter
-esphome/components/kalman_combinator/* @Cat-Ion
 esphome/components/key_collector/* @ssieb
 esphome/components/key_provider/* @ssieb
 esphome/components/kuntze/* @ssieb

esphome/components/combination/combination.cpp

@@ -0,0 +1,262 @@
+#include "combination.h"
+
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+
+#include <cmath>
+#include <functional>
+#include <vector>
+
+namespace esphome {
+namespace combination {
+
+static const char *const TAG = "combination";
+
+void CombinationComponent::log_config_(const LogString *combo_type) {
+  LOG_SENSOR("", "Combination Sensor:", this);
+  ESP_LOGCONFIG(TAG, "  Combination Type: %s", LOG_STR_ARG(combo_type));
+  this->log_source_sensors();
+}
+
+void CombinationNoParameterComponent::add_source(Sensor *sensor) { this->sensors_.emplace_back(sensor); }
+
+void CombinationOneParameterComponent::add_source(Sensor *sensor, std::function<float(float)> const &stddev) {
+  this->sensor_pairs_.emplace_back(sensor, stddev);
+}
+
+void CombinationOneParameterComponent::add_source(Sensor *sensor, float stddev) {
+  this->add_source(sensor, std::function<float(float)>{[stddev](float x) -> float { return stddev; }});
+}
+
+void CombinationNoParameterComponent::log_source_sensors() {
+  ESP_LOGCONFIG(TAG, "  Source Sensors:");
+  for (const auto &sensor : this->sensors_) {
+    ESP_LOGCONFIG(TAG, "    - %s", sensor->get_name().c_str());
+  }
+}
+
+void CombinationOneParameterComponent::log_source_sensors() {
+  ESP_LOGCONFIG(TAG, "  Source Sensors:");
+  for (const auto &sensor : this->sensor_pairs_) {
+    auto &entity = *sensor.first;
+    ESP_LOGCONFIG(TAG, "    - %s", entity.get_name().c_str());
+  }
+}
+
+void CombinationNoParameterComponent::setup() {
+  for (const auto &sensor : this->sensors_) {
+    // All sensor updates are deferred until the next loop. This avoids publishing the combined sensor's result
+    // repeatedly in the same loop if multiple source senors update.
+    sensor->add_on_state_callback(
+        [this](float value) -> void { this->defer("update", [this, value]() { this->handle_new_value(value); }); });
+  }
+}
+
+void KalmanCombinationComponent::dump_config() {
+  this->log_config_(LOG_STR("kalman"));
+  ESP_LOGCONFIG(TAG, "  Update variance: %f per ms", this->update_variance_value_);
+
+  if (this->std_dev_sensor_ != nullptr) {
+    LOG_SENSOR("  ", "Standard Deviation Sensor:", this->std_dev_sensor_);
+  }
+}
+
+void KalmanCombinationComponent::setup() {
+  for (const auto &sensor : this->sensor_pairs_) {
+    const auto stddev = sensor.second;
+    sensor.first->add_on_state_callback([this, stddev](float x) -> void { this->correct_(x, stddev(x)); });
+  }
+}
+
+void KalmanCombinationComponent::update_variance_() {
+  uint32_t now = millis();
+
+  // Variance increases by update_variance_ each millisecond
+  auto dt = now - this->last_update_;
+  auto dv = this->update_variance_value_ * dt;
+  this->variance_ += dv;
+  this->last_update_ = now;
+}
+
+void KalmanCombinationComponent::correct_(float value, float stddev) {
+  if (std::isnan(value) || std::isinf(stddev)) {
+    return;
+  }
+
+  if (std::isnan(this->state_) || std::isinf(this->variance_)) {
+    this->state_ = value;
+    this->variance_ = stddev * stddev;
+    if (this->std_dev_sensor_ != nullptr) {
+      this->std_dev_sensor_->publish_state(stddev);
+    }
+    return;
+  }
+
+  this->update_variance_();
+
+  // Combine two gaussian distributions mu1+-var1, mu2+-var2 to a new one around mu
+  // Use the value with the smaller variance as mu1 to prevent precision errors
+  const bool this_first = this->variance_ < (stddev * stddev);
+  const float mu1 = this_first ? this->state_ : value;
+  const float mu2 = this_first ? value : this->state_;
+
+  const float var1 = this_first ? this->variance_ : stddev * stddev;
+  const float var2 = this_first ? stddev * stddev : this->variance_;
+
+  const float mu = mu1 + var1 * (mu2 - mu1) / (var1 + var2);
+  const float var = var1 - (var1 * var1) / (var1 + var2);
+
+  // Update and publish state
+  this->state_ = mu;
+  this->variance_ = var;
+
+  this->publish_state(mu);
+  if (this->std_dev_sensor_ != nullptr) {
+    this->std_dev_sensor_->publish_state(std::sqrt(var));
+  }
+}
+
+void LinearCombinationComponent::setup() {
+  for (const auto &sensor : this->sensor_pairs_) {
+    // All sensor updates are deferred until the next loop. This avoids publishing the combined sensor's result
+    // repeatedly in the same loop if multiple source senors update.
+    sensor.first->add_on_state_callback(
+        [this](float value) -> void { this->defer("update", [this, value]() { this->handle_new_value(value); }); });
+  }
+}
+
+void LinearCombinationComponent::handle_new_value(float value) {
+  // Multiplies each sensor state by a configured coeffecient and then sums
+
+  if (!std::isfinite(value))
+    return;
+
+  float sum = 0.0;
+
+  for (const auto &sensor : this->sensor_pairs_) {
+    const float sensor_state = sensor.first->state;
+    if (std::isfinite(sensor_state)) {
+      sum += sensor_state * sensor.second(sensor_state);
+    }
+  }
+
+  this->publish_state(sum);
+};
+
+void MaximumCombinationComponent::handle_new_value(float value) {
+  if (!std::isfinite(value))
+    return;
+
+  float max_value = (-1) * std::numeric_limits<float>::infinity();  // note x = max(x, -infinity)
+
+  for (const auto &sensor : this->sensors_) {
+    if (std::isfinite(sensor->state)) {
+      max_value = std::max(max_value, sensor->state);
+    }
+  }
+
+  this->publish_state(max_value);
+}
+
+void MeanCombinationComponent::handle_new_value(float value) {
+  if (!std::isfinite(value))
+    return;
+
+  float sum = 0.0;
+  size_t count = 0.0;
+
+  for (const auto &sensor : this->sensors_) {
+    if (std::isfinite(sensor->state)) {
+      ++count;
+      sum += sensor->state;
+    }
+  }
+
+  float mean = sum / count;
+
+  this->publish_state(mean);
+}
+
+void MedianCombinationComponent::handle_new_value(float value) {
+  // Sorts sensor states in ascending order and determines the middle value
+
+  if (!std::isfinite(value))
+    return;
+
+  std::vector<float> sensor_states;
+  for (const auto &sensor : this->sensors_) {
+    if (std::isfinite(sensor->state)) {
+      sensor_states.push_back(sensor->state);
+    }
+  }
+
+  sort(sensor_states.begin(), sensor_states.end());
+  size_t sensor_states_size = sensor_states.size();
+
+  float median = NAN;
+
+  if (sensor_states_size) {
+    if (sensor_states_size % 2) {
+      // Odd number of measurements, use middle measurement
+      median = sensor_states[sensor_states_size / 2];
+    } else {
+      // Even number of measurements, use the average of the two middle measurements
+      median = (sensor_states[sensor_states_size / 2] + sensor_states[sensor_states_size / 2 - 1]) / 2.0;
+    }
+  }
+
+  this->publish_state(median);
+}
+
+void MinimumCombinationComponent::handle_new_value(float value) {
+  if (!std::isfinite(value))
+    return;
+
+  float min_value = std::numeric_limits<float>::infinity();  // note x = min(x, infinity)
+
+  for (const auto &sensor : this->sensors_) {
+    if (std::isfinite(sensor->state)) {
+      min_value = std::min(min_value, sensor->state);
+    }
+  }
+
+  this->publish_state(min_value);
+}
+
+void MostRecentCombinationComponent::handle_new_value(float value) { this->publish_state(value); }
+
+void RangeCombinationComponent::handle_new_value(float value) {
+  // Sorts sensor states then takes difference between largest and smallest states
+
+  if (!std::isfinite(value))
+    return;
+
+  std::vector<float> sensor_states;
+  for (const auto &sensor : this->sensors_) {
+    if (std::isfinite(sensor->state)) {
+      sensor_states.push_back(sensor->state);
+    }
+  }
+
+  sort(sensor_states.begin(), sensor_states.end());
+
+  float range = sensor_states.back() - sensor_states.front();
+  this->publish_state(range);
+}
+
+void SumCombinationComponent::handle_new_value(float value) {
+  if (!std::isfinite(value))
+    return;
+
+  float sum = 0.0;
+  for (const auto &sensor : this->sensors_) {
+    if (std::isfinite(sensor->state)) {
+      sum += sensor->state;
+    }
+  }
+
+  this->publish_state(sum);
+}
+
+}  // namespace combination
+}  // namespace esphome

esphome/components/combination/combination.h

@@ -0,0 +1,141 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+
+#include <vector>
+
+namespace esphome {
+namespace combination {
+
+class CombinationComponent : public Component, public sensor::Sensor {
+ public:
+  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
+
+  /// @brief Logs all source sensor's names
+  virtual void log_source_sensors() = 0;
+
+ protected:
+  /// @brief Logs the sensor for use in dump_config
+  /// @param combo_type Name of the combination operation
+  void log_config_(const LogString *combo_type);
+};
+
+/// @brief Base class for operations that do not require an extra parameter to compute the combination
+class CombinationNoParameterComponent : public CombinationComponent {
+ public:
+  /// @brief Adds a callback to each source sensor
+  void setup() override;
+
+  void add_source(Sensor *sensor);
+
+  /// @brief Computes the combination
+  /// @param value Newest sensor measurement
+  virtual void handle_new_value(float value) = 0;
+
+  /// @brief Logs all source sensor's names in sensors_
+  void log_source_sensors() override;
+
+ protected:
+  std::vector<Sensor *> sensors_;
+};
+
+// Base class for opertions that require one parameter to compute the combination
+class CombinationOneParameterComponent : public CombinationComponent {
+ public:
+  void add_source(Sensor *sensor, std::function<float(float)> const &stddev);
+  void add_source(Sensor *sensor, float stddev);
+
+  /// @brief Logs all source sensor's names in sensor_pairs_
+  void log_source_sensors() override;
+
+ protected:
+  std::vector<std::pair<Sensor *, std::function<float(float)>>> sensor_pairs_;
+};
+
+class KalmanCombinationComponent : public CombinationOneParameterComponent {
+ public:
+  void dump_config() override;
+  void setup() override;
+
+  void set_process_std_dev(float process_std_dev) {
+    this->update_variance_value_ = process_std_dev * process_std_dev * 0.001f;
+  }
+  void set_std_dev_sensor(Sensor *sensor) { this->std_dev_sensor_ = sensor; }
+
+ protected:
+  void update_variance_();
+  void correct_(float value, float stddev);
+
+  // Optional sensor for publishing the current error
+  sensor::Sensor *std_dev_sensor_{nullptr};
+
+  // Tick of the last update
+  uint32_t last_update_{0};
+  // Change of the variance, per ms
+  float update_variance_value_{0.f};
+
+  // Best guess for the state and its variance
+  float state_{NAN};
+  float variance_{INFINITY};
+};
+
+class LinearCombinationComponent : public CombinationOneParameterComponent {
+ public:
+  void dump_config() override { this->log_config_(LOG_STR("linear")); }
+  void setup() override;
+
+  void handle_new_value(float value);
+};
+
+class MaximumCombinationComponent : public CombinationNoParameterComponent {
+ public:
+  void dump_config() override { this->log_config_(LOG_STR("max")); }
+
+  void handle_new_value(float value) override;
+};
+
+class MeanCombinationComponent : public CombinationNoParameterComponent {
+ public:
+  void dump_config() override { this->log_config_(LOG_STR("mean")); }
+
+  void handle_new_value(float value) override;
+};
+
+class MedianCombinationComponent : public CombinationNoParameterComponent {
+ public:
+  void dump_config() override { this->log_config_(LOG_STR("median")); }
+
+  void handle_new_value(float value) override;
+};
+
+class MinimumCombinationComponent : public CombinationNoParameterComponent {
+ public:
+  void dump_config() override { this->log_config_(LOG_STR("min")); }
+
+  void handle_new_value(float value) override;
+};
+
+class MostRecentCombinationComponent : public CombinationNoParameterComponent {
+ public:
+  void dump_config() override { this->log_config_(LOG_STR("most_recently_updated")); }
+
+  void handle_new_value(float value) override;
+};
+
+class RangeCombinationComponent : public CombinationNoParameterComponent {
+ public:
+  void dump_config() override { this->log_config_(LOG_STR("range")); }
+
+  void handle_new_value(float value) override;
+};
+
+class SumCombinationComponent : public CombinationNoParameterComponent {
+ public:
+  void dump_config() override { this->log_config_(LOG_STR("sum")); }
+
+  void handle_new_value(float value) override;
+};
+
+}  // namespace combination
+}  // namespace esphome

esphome/components/combination/sensor.py

@@ -0,0 +1,176 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor
+from esphome.const import (
+    CONF_ACCURACY_DECIMALS,
+    CONF_DEVICE_CLASS,
+    CONF_ENTITY_CATEGORY,
+    CONF_ICON,
+    CONF_ID,
+    CONF_RANGE,
+    CONF_SOURCE,
+    CONF_SUM,
+    CONF_TYPE,
+    CONF_UNIT_OF_MEASUREMENT,
+)
+from esphome.core.entity_helpers import inherit_property_from
+
+CODEOWNERS = ["@Cat-Ion", "@kahrendt"]
+
+combination_ns = cg.esphome_ns.namespace("combination")
+
+KalmanCombinationComponent = combination_ns.class_(
+    "KalmanCombinationComponent", cg.Component, sensor.Sensor
+)
+LinearCombinationComponent = combination_ns.class_(
+    "LinearCombinationComponent", cg.Component, sensor.Sensor
+)
+MaximumCombinationComponent = combination_ns.class_(
+    "MaximumCombinationComponent", cg.Component, sensor.Sensor
+)
+MeanCombinationComponent = combination_ns.class_(
+    "MeanCombinationComponent", cg.Component, sensor.Sensor
+)
+MedianCombinationComponent = combination_ns.class_(
+    "MedianCombinationComponent", cg.Component, sensor.Sensor
+)
+MinimumCombinationComponent = combination_ns.class_(
+    "MinimumCombinationComponent", cg.Component, sensor.Sensor
+)
+MostRecentCombinationComponent = combination_ns.class_(
+    "MostRecentCombinationComponent", cg.Component, sensor.Sensor
+)
+RangeCombinationComponent = combination_ns.class_(
+    "RangeCombinationComponent", cg.Component, sensor.Sensor
+)
+SumCombinationComponent = combination_ns.class_(
+    "SumCombinationComponent", cg.Component, sensor.Sensor
+)
+
+CONF_COEFFECIENT = "coeffecient"
+CONF_ERROR = "error"
+CONF_KALMAN = "kalman"
+CONF_LINEAR = "linear"
+CONF_MAX = "max"
+CONF_MEAN = "mean"
+CONF_MEDIAN = "median"
+CONF_MIN = "min"
+CONF_MOST_RECENTLY_UPDATED = "most_recently_updated"
+CONF_PROCESS_STD_DEV = "process_std_dev"
+CONF_SOURCES = "sources"
+CONF_STD_DEV = "std_dev"
+
+
+KALMAN_SOURCE_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_SOURCE): cv.use_id(sensor.Sensor),
+        cv.Required(CONF_ERROR): cv.templatable(cv.positive_float),
+    }
+)
+
+LINEAR_SOURCE_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_SOURCE): cv.use_id(sensor.Sensor),
+        cv.Required(CONF_COEFFECIENT): cv.templatable(cv.float_),
+    }
+)
+
+SENSOR_ONLY_SOURCE_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_SOURCE): cv.use_id(sensor.Sensor),
+    }
+)
+
+CONFIG_SCHEMA = cv.typed_schema(
+    {
+        CONF_KALMAN: sensor.sensor_schema(KalmanCombinationComponent)
+        .extend(cv.COMPONENT_SCHEMA)
+        .extend(
+            {
+                cv.Required(CONF_PROCESS_STD_DEV): cv.positive_float,
+                cv.Required(CONF_SOURCES): cv.ensure_list(KALMAN_SOURCE_SCHEMA),
+                cv.Optional(CONF_STD_DEV): sensor.sensor_schema(),
+            }
+        ),
+        CONF_LINEAR: sensor.sensor_schema(LinearCombinationComponent)
+        .extend(cv.COMPONENT_SCHEMA)
+        .extend({cv.Required(CONF_SOURCES): cv.ensure_list(LINEAR_SOURCE_SCHEMA)}),
+        CONF_MAX: sensor.sensor_schema(MaximumCombinationComponent)
+        .extend(cv.COMPONENT_SCHEMA)
+        .extend({cv.Required(CONF_SOURCES): cv.ensure_list(SENSOR_ONLY_SOURCE_SCHEMA)}),
+        CONF_MEAN: sensor.sensor_schema(MeanCombinationComponent)
+        .extend(cv.COMPONENT_SCHEMA)
+        .extend({cv.Required(CONF_SOURCES): cv.ensure_list(SENSOR_ONLY_SOURCE_SCHEMA)}),
+        CONF_MEDIAN: sensor.sensor_schema(MedianCombinationComponent)
+        .extend(cv.COMPONENT_SCHEMA)
+        .extend({cv.Required(CONF_SOURCES): cv.ensure_list(SENSOR_ONLY_SOURCE_SCHEMA)}),
+        CONF_MIN: sensor.sensor_schema(MinimumCombinationComponent)
+        .extend(cv.COMPONENT_SCHEMA)
+        .extend({cv.Required(CONF_SOURCES): cv.ensure_list(SENSOR_ONLY_SOURCE_SCHEMA)}),
+        CONF_MOST_RECENTLY_UPDATED: sensor.sensor_schema(MostRecentCombinationComponent)
+        .extend(cv.COMPONENT_SCHEMA)
+        .extend({cv.Required(CONF_SOURCES): cv.ensure_list(SENSOR_ONLY_SOURCE_SCHEMA)}),
+        CONF_RANGE: sensor.sensor_schema(RangeCombinationComponent)
+        .extend(cv.COMPONENT_SCHEMA)
+        .extend({cv.Required(CONF_SOURCES): cv.ensure_list(SENSOR_ONLY_SOURCE_SCHEMA)}),
+        CONF_SUM: sensor.sensor_schema(SumCombinationComponent)
+        .extend(cv.COMPONENT_SCHEMA)
+        .extend({cv.Required(CONF_SOURCES): cv.ensure_list(SENSOR_ONLY_SOURCE_SCHEMA)}),
+    }
+)
+
+
+# Inherit some sensor values from the first source, for both the state and the error value
+# CONF_STATE_CLASS could also be inherited, but might lead to unexpected behaviour with "total_increasing"
+properties_to_inherit = [
+    CONF_ACCURACY_DECIMALS,
+    CONF_DEVICE_CLASS,
+    CONF_ENTITY_CATEGORY,
+    CONF_ICON,
+    CONF_UNIT_OF_MEASUREMENT,
+]
+inherit_schema_for_state = [
+    inherit_property_from(property, [CONF_SOURCES, 0, CONF_SOURCE])
+    for property in properties_to_inherit
+]
+inherit_schema_for_std_dev = [
+    inherit_property_from([CONF_STD_DEV, property], [CONF_SOURCES, 0, CONF_SOURCE])
+    for property in properties_to_inherit
+]
+
+FINAL_VALIDATE_SCHEMA = cv.All(
+    *inherit_schema_for_state,
+    *inherit_schema_for_std_dev,
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await sensor.register_sensor(var, config)
+
+    if proces_std_dev := config.get(CONF_PROCESS_STD_DEV):
+        cg.add(var.set_process_std_dev(proces_std_dev))
+
+    for source_conf in config[CONF_SOURCES]:
+        source = await cg.get_variable(source_conf[CONF_SOURCE])
+        if config[CONF_TYPE] == CONF_KALMAN:
+            error = await cg.templatable(
+                source_conf[CONF_ERROR],
+                [(float, "x")],
+                cg.float_,
+            )
+            cg.add(var.add_source(source, error))
+        elif config[CONF_TYPE] == CONF_LINEAR:
+            coeffecient = await cg.templatable(
+                source_conf[CONF_COEFFECIENT],
+                [(float, "x")],
+                cg.float_,
+            )
+            cg.add(var.add_source(source, coeffecient))
+        else:
+            cg.add(var.add_source(source))
+
+    if CONF_STD_DEV in config:
+        sens = await sensor.new_sensor(config[CONF_STD_DEV])
+        cg.add(var.set_std_dev_sensor(sens))

esphome/components/kalman_combinator/__init__.py

@@ -1 +0,0 @@
-CODEOWNERS = ["@Cat-Ion"]

esphome/components/kalman_combinator/kalman_combinator.cpp

@@ -1,82 +0,0 @@
-#include "kalman_combinator.h"
-#include "esphome/core/hal.h"
-#include <cmath>
-#include <functional>
-
-namespace esphome {
-namespace kalman_combinator {
-
-void KalmanCombinatorComponent::dump_config() {
-  ESP_LOGCONFIG("kalman_combinator", "Kalman Combinator:");
-  ESP_LOGCONFIG("kalman_combinator", "  Update variance: %f per ms", this->update_variance_value_);
-  ESP_LOGCONFIG("kalman_combinator", "  Sensors:");
-  for (const auto &sensor : this->sensors_) {
-    auto &entity = *sensor.first;
-    ESP_LOGCONFIG("kalman_combinator", "    - %s", entity.get_name().c_str());
-  }
-}
-
-void KalmanCombinatorComponent::setup() {
-  for (const auto &sensor : this->sensors_) {
-    const auto stddev = sensor.second;
-    sensor.first->add_on_state_callback([this, stddev](float x) -> void { this->correct_(x, stddev(x)); });
-  }
-}
-
-void KalmanCombinatorComponent::add_source(Sensor *sensor, std::function<float(float)> const &stddev) {
-  this->sensors_.emplace_back(sensor, stddev);
-}
-
-void KalmanCombinatorComponent::add_source(Sensor *sensor, float stddev) {
-  this->add_source(sensor, std::function<float(float)>{[stddev](float x) -> float { return stddev; }});
-}
-
-void KalmanCombinatorComponent::update_variance_() {
-  uint32_t now = millis();
-
-  // Variance increases by update_variance_ each millisecond
-  auto dt = now - this->last_update_;
-  auto dv = this->update_variance_value_ * dt;
-  this->variance_ += dv;
-  this->last_update_ = now;
-}
-
-void KalmanCombinatorComponent::correct_(float value, float stddev) {
-  if (std::isnan(value) || std::isinf(stddev)) {
-    return;
-  }
-
-  if (std::isnan(this->state_) || std::isinf(this->variance_)) {
-    this->state_ = value;
-    this->variance_ = stddev * stddev;
-    if (this->std_dev_sensor_ != nullptr) {
-      this->std_dev_sensor_->publish_state(stddev);
-    }
-    return;
-  }
-
-  this->update_variance_();
-
-  // Combine two gaussian distributions mu1+-var1, mu2+-var2 to a new one around mu
-  // Use the value with the smaller variance as mu1 to prevent precision errors
-  const bool this_first = this->variance_ < (stddev * stddev);
-  const float mu1 = this_first ? this->state_ : value;
-  const float mu2 = this_first ? value : this->state_;
-
-  const float var1 = this_first ? this->variance_ : stddev * stddev;
-  const float var2 = this_first ? stddev * stddev : this->variance_;
-
-  const float mu = mu1 + var1 * (mu2 - mu1) / (var1 + var2);
-  const float var = var1 - (var1 * var1) / (var1 + var2);
-
-  // Update and publish state
-  this->state_ = mu;
-  this->variance_ = var;
-
-  this->publish_state(mu);
-  if (this->std_dev_sensor_ != nullptr) {
-    this->std_dev_sensor_->publish_state(std::sqrt(var));
-  }
-}
-}  // namespace kalman_combinator
-}  // namespace esphome

esphome/components/kalman_combinator/kalman_combinator.h

@@ -1,46 +0,0 @@
-#pragma once
-#include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
-#include <cmath>
-#include <vector>
-
-namespace esphome {
-namespace kalman_combinator {
-
-class KalmanCombinatorComponent : public Component, public sensor::Sensor {
- public:
-  KalmanCombinatorComponent() = default;
-
-  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
-
-  void dump_config() override;
-  void setup() override;
-
-  void add_source(Sensor *sensor, std::function<float(float)> const &stddev);
-  void add_source(Sensor *sensor, float stddev);
-  void set_process_std_dev(float process_std_dev) {
-    this->update_variance_value_ = process_std_dev * process_std_dev * 0.001f;
-  }
-  void set_std_dev_sensor(Sensor *sensor) { this->std_dev_sensor_ = sensor; }
-
- private:
-  void update_variance_();
-  void correct_(float value, float stddev);
-
-  // Source sensors and their error functions
-  std::vector<std::pair<Sensor *, std::function<float(float)>>> sensors_;
-
-  // Optional sensor for publishing the current error
-  sensor::Sensor *std_dev_sensor_{nullptr};
-
-  // Tick of the last update
-  uint32_t last_update_{0};
-  // Change of the variance, per ms
-  float update_variance_value_{0.f};
-
-  // Best guess for the state and its variance
-  float state_{NAN};
-  float variance_{INFINITY};
-};
-}  // namespace kalman_combinator
-}  // namespace esphome

esphome/components/kalman_combinator/sensor.py

@@ -1,90 +1,6 @@
-import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.components import sensor
+
-from esphome.const import (
+CONFIG_SCHEMA = CONFIG_SCHEMA = cv.invalid(
-    CONF_ID,
+    "The kalman_combinator sensor has moved.\nPlease use the combination platform instead with type: kalman.\n"
-    CONF_SOURCE,
+    "See https://esphome.io/components/sensor/combination.html"
-    CONF_ACCURACY_DECIMALS,
-    CONF_DEVICE_CLASS,
-    CONF_ENTITY_CATEGORY,
-    CONF_ICON,
-    CONF_UNIT_OF_MEASUREMENT,
 )
-from esphome.core.entity_helpers import inherit_property_from
-
-kalman_combinator_ns = cg.esphome_ns.namespace("kalman_combinator")
-KalmanCombinatorComponent = kalman_combinator_ns.class_(
-    "KalmanCombinatorComponent", cg.Component, sensor.Sensor
-)
-
-CONF_ERROR = "error"
-CONF_SOURCES = "sources"
-CONF_PROCESS_STD_DEV = "process_std_dev"
-CONF_STD_DEV = "std_dev"
-
-
-CONFIG_SCHEMA = (
-    sensor.sensor_schema(KalmanCombinatorComponent)
-    .extend(cv.COMPONENT_SCHEMA)
-    .extend(
-        {
-            cv.Required(CONF_PROCESS_STD_DEV): cv.positive_float,
-            cv.Required(CONF_SOURCES): cv.ensure_list(
-                cv.Schema(
-                    {
-                        cv.Required(CONF_SOURCE): cv.use_id(sensor.Sensor),
-                        cv.Required(CONF_ERROR): cv.templatable(cv.positive_float),
-                    }
-                ),
-            ),
-            cv.Optional(CONF_STD_DEV): sensor.sensor_schema(),
-        }
-    )
-)
-
-# Inherit some sensor values from the first source, for both the state and the error value
-properties_to_inherit = [
-    CONF_ACCURACY_DECIMALS,
-    CONF_DEVICE_CLASS,
-    CONF_ENTITY_CATEGORY,
-    CONF_ICON,
-    CONF_UNIT_OF_MEASUREMENT,
-    # CONF_STATE_CLASS could also be inherited, but might lead to unexpected behaviour with "total_increasing"
-]
-inherit_schema_for_state = [
-    inherit_property_from(property, [CONF_SOURCES, 0, CONF_SOURCE])
-    for property in properties_to_inherit
-]
-inherit_schema_for_std_dev = [
-    inherit_property_from([CONF_STD_DEV, property], [CONF_SOURCES, 0, CONF_SOURCE])
-    for property in properties_to_inherit
-]
-
-FINAL_VALIDATE_SCHEMA = cv.All(
-    CONFIG_SCHEMA.extend(
-        {cv.Required(CONF_ID): cv.use_id(KalmanCombinatorComponent)},
-        extra=cv.ALLOW_EXTRA,
-    ),
-    *inherit_schema_for_state,
-    *inherit_schema_for_std_dev,
-)
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await sensor.register_sensor(var, config)
-
-    cg.add(var.set_process_std_dev(config[CONF_PROCESS_STD_DEV]))
-    for source_conf in config[CONF_SOURCES]:
-        source = await cg.get_variable(source_conf[CONF_SOURCE])
-        error = await cg.templatable(
-            source_conf[CONF_ERROR],
-            [(float, "x")],
-            cg.float_,
-        )
-        cg.add(var.add_source(source, error))
-
-    if CONF_STD_DEV in config:
-        sens = await sensor.new_sensor(config[CONF_STD_DEV])
-        cg.add(var.set_std_dev_sensor(sens))

tests/test1.yaml

@@ -971,7 +971,8 @@ sensor:
       name: Internal Ttemperature
     update_interval: 15s
     i2c_id: i2c_bus
-  - platform: kalman_combinator
+  - platform: combination
+    type: kalman
     name: Kalman-filtered temperature
     process_std_dev: 0.00139
     sources:
@@ -980,6 +981,57 @@ sensor:
           return 0.4 + std::abs(x - 25) * 0.023;
       - source: scd4x_temperature
         error: 1.5
+  - platform: combination
+    type: linear
+    name: Linearly combined temperatures
+    sources:
+      - source: scd30_temperature
+        coeffecient: !lambda |-
+          return 0.4 + std::abs(x - 25) * 0.023;
+      - source: scd4x_temperature
+        coeffecient: 1.5
+  - platform: combination
+    type: max
+    name: Max of combined temperatures
+    sources:
+      - source: scd30_temperature
+      - source: scd4x_temperature
+  - platform: combination
+    type: mean
+    name: Mean of combined temperatures
+    sources:
+      - source: scd30_temperature
+      - source: scd4x_temperature
+  - platform: combination
+    type: median
+    name: Median of combined temperatures
+    sources:
+      - source: scd30_temperature
+      - source: scd4x_temperature
+  - platform: combination
+    type: min
+    name: Min of combined temperatures
+    sources:
+      - source: scd30_temperature
+      - source: scd4x_temperature
+  - platform: combination
+    type: most_recently_updated
+    name: Most recently updated of combined temperatures
+    sources:
+      - source: scd30_temperature
+      - source: scd4x_temperature
+  - platform: combination
+    type: range
+    name: Range of combined temperatures
+    sources:
+      - source: scd30_temperature
+      - source: scd4x_temperature
+  - platform: combination
+    type: sum
+    name: Sum of combined temperatures
+    sources:
+      - source: scd30_temperature
+      - source: scd4x_temperature
   - platform: htu21d
     temperature:
       name: Living Room Temperature 6