esphome 2025.4.1__py3-none-any.whl → 2025.5.0b2__py3-none-any.whl

esphome/components/sensor/__init__.py

@@ -1,3 +1,4 @@
+import logging
 import math
 
 from esphome import automation
@@ -9,6 +10,7 @@ from esphome.const import (
     CONF_ACCURACY_DECIMALS,
     CONF_ALPHA,
     CONF_BELOW,
+    CONF_CALIBRATION,
     CONF_DEVICE_CLASS,
     CONF_ENTITY_CATEGORY,
     CONF_EXPIRE_AFTER,
@@ -30,6 +32,7 @@ from esphome.const import (
     CONF_SEND_EVERY,
     CONF_SEND_FIRST_AT,
     CONF_STATE_CLASS,
+    CONF_TEMPERATURE,
     CONF_TIMEOUT,
     CONF_TO,
     CONF_TRIGGER_ID,
@@ -153,6 +156,8 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_WIND_SPEED,
 ]
 
+_LOGGER = logging.getLogger(__name__)
+
 sensor_ns = cg.esphome_ns.namespace("sensor")
 StateClasses = sensor_ns.enum("StateClass")
 STATE_CLASSES = {
@@ -246,6 +251,8 @@ HeartbeatFilter = sensor_ns.class_("HeartbeatFilter", Filter, cg.Component)
 DeltaFilter = sensor_ns.class_("DeltaFilter", Filter)
 OrFilter = sensor_ns.class_("OrFilter", Filter)
 CalibrateLinearFilter = sensor_ns.class_("CalibrateLinearFilter", Filter)
+ToNTCResistanceFilter = sensor_ns.class_("ToNTCResistanceFilter", Filter)
+ToNTCTemperatureFilter = sensor_ns.class_("ToNTCTemperatureFilter", Filter)
 CalibratePolynomialFilter = sensor_ns.class_("CalibratePolynomialFilter", Filter)
 SensorInRangeCondition = sensor_ns.class_("SensorInRangeCondition", Filter)
 ClampFilter = sensor_ns.class_("ClampFilter", Filter)
@@ -257,7 +264,7 @@ validate_accuracy_decimals = cv.int_
 validate_icon = cv.icon
 validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 
-SENSOR_SCHEMA = (
+_SENSOR_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMPONENT_SCHEMA)
     .extend(
@@ -302,22 +309,20 @@ SENSOR_SCHEMA = (
     )
 )
 
-_UNDEF = object()
-
 
 def sensor_schema(
-    class_: MockObjClass = _UNDEF,
+    class_: MockObjClass = cv.UNDEFINED,
     *,
-    unit_of_measurement: str = _UNDEF,
-    icon: str = _UNDEF,
-    accuracy_decimals: int = _UNDEF,
-    device_class: str = _UNDEF,
-    state_class: str = _UNDEF,
-    entity_category: str = _UNDEF,
+    unit_of_measurement: str = cv.UNDEFINED,
+    icon: str = cv.UNDEFINED,
+    accuracy_decimals: int = cv.UNDEFINED,
+    device_class: str = cv.UNDEFINED,
+    state_class: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
 ) -> cv.Schema:
     schema = {}
 
-    if class_ is not _UNDEF:
+    if class_ is not cv.UNDEFINED:
         # Not optional.
         schema[cv.GenerateID()] = cv.declare_id(class_)
 
@@ -329,10 +334,15 @@ def sensor_schema(
         (CONF_STATE_CLASS, state_class, validate_state_class),
         (CONF_ENTITY_CATEGORY, entity_category, sensor_entity_category),
     ]:
-        if default is not _UNDEF:
+        if default is not cv.UNDEFINED:
             schema[cv.Optional(key, default=default)] = validator
 
-    return SENSOR_SCHEMA.extend(schema)
+    return _SENSOR_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+SENSOR_SCHEMA = sensor_schema()
+SENSOR_SCHEMA.add_extra(cv.deprecated_schema_constant("sensor"))
 
 
 @FILTER_REGISTRY.register("offset", OffsetFilter, cv.templatable(cv.float_))
@@ -804,7 +814,9 @@ async def setup_sensor_core_(var, config):
         mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
-        if (expire_after := config.get(CONF_EXPIRE_AFTER, _UNDEF)) is not _UNDEF:
+        if (
+            expire_after := config.get(CONF_EXPIRE_AFTER, cv.UNDEFINED)
+        ) is not cv.UNDEFINED:
             if expire_after is None:
                 cg.add(mqtt_.disable_expire_after())
             else:
@@ -852,6 +864,138 @@ async def sensor_in_range_to_code(config, condition_id, template_arg, args):
     return var
 
 
+def validate_ntc_calibration_parameter(value):
+    if isinstance(value, dict):
+        return cv.Schema(
+            {
+                cv.Required(CONF_TEMPERATURE): cv.temperature,
+                cv.Required(CONF_VALUE): cv.resistance,
+            }
+        )(value)
+
+    value = cv.string(value)
+    parts = value.split("->")
+    if len(parts) != 2:
+        raise cv.Invalid("Calibration parameter must be of form 3000 -> 23°C")
+    resistance = cv.resistance(parts[0].strip())
+    temperature = cv.temperature(parts[1].strip())
+    return validate_ntc_calibration_parameter(
+        {
+            CONF_TEMPERATURE: temperature,
+            CONF_VALUE: resistance,
+        }
+    )
+
+
+CONF_A = "a"
+CONF_B = "b"
+CONF_C = "c"
+ZERO_POINT = 273.15
+
+
+def ntc_calc_steinhart_hart(value):
+    r1 = value[0][CONF_VALUE]
+    r2 = value[1][CONF_VALUE]
+    r3 = value[2][CONF_VALUE]
+    t1 = value[0][CONF_TEMPERATURE] + ZERO_POINT
+    t2 = value[1][CONF_TEMPERATURE] + ZERO_POINT
+    t3 = value[2][CONF_TEMPERATURE] + ZERO_POINT
+
+    l1 = math.log(r1)
+    l2 = math.log(r2)
+    l3 = math.log(r3)
+
+    y1 = 1 / t1
+    y2 = 1 / t2
+    y3 = 1 / t3
+
+    g2 = (y2 - y1) / (l2 - l1)
+    g3 = (y3 - y1) / (l3 - l1)
+
+    c = (g3 - g2) / (l3 - l2) * 1 / (l1 + l2 + l3)
+    b = g2 - c * (l1 * l1 + l1 * l2 + l2 * l2)
+    a = y1 - (b + l1 * l1 * c) * l1
+    return a, b, c
+
+
+def ntc_get_abc(value):
+    a = value[CONF_A]
+    b = value[CONF_B]
+    c = value[CONF_C]
+    return a, b, c
+
+
+def ntc_process_calibration(value):
+    if isinstance(value, dict):
+        value = cv.Schema(
+            {
+                cv.Required(CONF_A): cv.float_,
+                cv.Required(CONF_B): cv.float_,
+                cv.Required(CONF_C): cv.float_,
+            }
+        )(value)
+        a, b, c = ntc_get_abc(value)
+    elif isinstance(value, list):
+        if len(value) != 3:
+            raise cv.Invalid(
+                "Steinhart–Hart Calibration must consist of exactly three values"
+            )
+        value = cv.Schema([validate_ntc_calibration_parameter])(value)
+        a, b, c = ntc_calc_steinhart_hart(value)
+    else:
+        raise cv.Invalid(
+            f"Calibration parameter accepts either a list for steinhart-hart calibration, or mapping for b-constant calibration, not {type(value)}"
+        )
+    _LOGGER.info("Coefficient: a:%s, b:%s, c:%s", a, b, c)
+    return {
+        CONF_A: a,
+        CONF_B: b,
+        CONF_C: c,
+    }
+
+
+@FILTER_REGISTRY.register(
+    "to_ntc_resistance",
+    ToNTCResistanceFilter,
+    cv.All(
+        cv.Schema(
+            {
+                cv.Required(CONF_CALIBRATION): ntc_process_calibration,
+            }
+        ),
+    ),
+)
+async def calibrate_ntc_resistance_filter_to_code(config, filter_id):
+    calib = config[CONF_CALIBRATION]
+    return cg.new_Pvariable(
+        filter_id,
+        calib[CONF_A],
+        calib[CONF_B],
+        calib[CONF_C],
+    )
+
+
+@FILTER_REGISTRY.register(
+    "to_ntc_temperature",
+    ToNTCTemperatureFilter,
+    cv.All(
+        cv.Schema(
+            {
+                cv.Required(CONF_CALIBRATION): ntc_process_calibration,
+            }
+        ),
+    ),
+)
+async def calibrate_ntc_temperature_filter_to_code(config, filter_id):
+    calib = config[CONF_CALIBRATION]
+    return cg.new_Pvariable(
+        filter_id,
+        calib[CONF_A],
+        calib[CONF_B],
+        calib[CONF_C],
+    )
+
+
 def _mean(xs):
     return sum(xs) / len(xs)
 

esphome/components/sensor/filter.cpp

@@ -481,5 +481,28 @@ optional<float> RoundMultipleFilter::new_value(float value) {
   return value;
 }
 
+optional<float> ToNTCResistanceFilter::new_value(float value) {
+  if (!std::isfinite(value)) {
+    return NAN;
+  }
+  double k = 273.15;
+  // https://de.wikipedia.org/wiki/Steinhart-Hart-Gleichung#cite_note-stein2_s4-3
+  double t = value + k;
+  double y = (this->a_ - 1 / (t)) / (2 * this->c_);
+  double x = sqrt(pow(this->b_ / (3 * this->c_), 3) + y * y);
+  double resistance = exp(pow(x - y, 1 / 3.0) - pow(x + y, 1 / 3.0));
+  return resistance;
+}
+
+optional<float> ToNTCTemperatureFilter::new_value(float value) {
+  if (!std::isfinite(value)) {
+    return NAN;
+  }
+  double lr = log(double(value));
+  double v = this->a_ + this->b_ * lr + this->c_ * lr * lr * lr;
+  double temp = float(1.0 / v - 273.15);
+  return temp;
+}
+
 }  // namespace sensor
 }  // namespace esphome

esphome/components/sensor/filter.h

@@ -439,5 +439,27 @@ class RoundMultipleFilter : public Filter {
   float multiple_;
 };
 
+class ToNTCResistanceFilter : public Filter {
+ public:
+  ToNTCResistanceFilter(double a, double b, double c) : a_(a), b_(b), c_(c) {}
+  optional<float> new_value(float value) override;
+
+ protected:
+  double a_;
+  double b_;
+  double c_;
+};
+
+class ToNTCTemperatureFilter : public Filter {
+ public:
+  ToNTCTemperatureFilter(double a, double b, double c) : a_(a), b_(b), c_(c) {}
+  optional<float> new_value(float value) override;
+
+ protected:
+  double a_;
+  double b_;
+  double c_;
+};
+
 }  // namespace sensor
 }  // namespace esphome

esphome/components/sgp4x/sensor.py

@@ -3,6 +3,7 @@ from esphome.components import i2c, sensirion_common, sensor
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_COMPENSATION,
+    CONF_GAIN_FACTOR,
     CONF_ID,
     CONF_STORE_BASELINE,
     CONF_TEMPERATURE_SOURCE,
@@ -24,7 +25,6 @@ SGP4xComponent = sgp4x_ns.class_(
 )
 
 CONF_ALGORITHM_TUNING = "algorithm_tuning"
-CONF_GAIN_FACTOR = "gain_factor"
 CONF_GATING_MAX_DURATION_MINUTES = "gating_max_duration_minutes"
 CONF_HUMIDITY_SOURCE = "humidity_source"
 CONF_INDEX_OFFSET = "index_offset"

esphome/components/sht4x/sht4x.cpp

@@ -12,14 +12,22 @@ void SHT4XComponent::start_heater_() {
   uint8_t cmd[] = {MEASURECOMMANDS[this->heater_command_]};
 
   ESP_LOGD(TAG, "Heater turning on");
-  this->write(cmd, 1);
+  if (this->write(cmd, 1) != i2c::ERROR_OK) {
+    this->status_set_error("Failed to turn on heater");
+  }
 }
 
 void SHT4XComponent::setup() {
   ESP_LOGCONFIG(TAG, "Setting up sht4x...");
 
-  if (this->duty_cycle_ > 0.0) {
-    uint32_t heater_interval = (uint32_t) (this->heater_time_ / this->duty_cycle_);
+  auto err = this->write(nullptr, 0);
+  if (err != i2c::ERROR_OK) {
+    this->mark_failed();
+    return;
+  }
+
+  if (std::isfinite(this->duty_cycle_) && this->duty_cycle_ > 0.0f) {
+    uint32_t heater_interval = static_cast<uint32_t>(static_cast<uint16_t>(this->heater_time_) / this->duty_cycle_);
     ESP_LOGD(TAG, "Heater interval: %" PRIu32, heater_interval);
 
     if (this->heater_power_ == SHT4X_HEATERPOWER_HIGH) {
@@ -47,37 +55,50 @@ void SHT4XComponent::setup() {
   }
 }
 
-void SHT4XComponent::dump_config() { LOG_I2C_DEVICE(this); }
+void SHT4XComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "SHT4x:");
+  LOG_I2C_DEVICE(this);
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Communication with SHT4x failed!");
+  }
+}
 
 void SHT4XComponent::update() {
   // Send command
-  this->write_command(MEASURECOMMANDS[this->precision_]);
+  if (!this->write_command(MEASURECOMMANDS[this->precision_])) {
+    // Warning will be printed only if warning status is not set yet
+    this->status_set_warning("Failed to send measurement command");
+    return;
+  }
 
   this->set_timeout(10, [this]() {
     uint16_t buffer[2];
 
     // Read measurement
-    bool read_status = this->read_data(buffer, 2);
+    if (!this->read_data(buffer, 2)) {
+      // Using ESP_LOGW to force the warning to be printed
+      ESP_LOGW(TAG, "Sensor read failed");
+      this->status_set_warning();
+      return;
+    }
 
-    if (read_status) {
-      // Evaluate and publish measurements
-      if (this->temp_sensor_ != nullptr) {
-        // Temp is contained in the first result word
-        float sensor_value_temp = buffer[0];
-        float temp = -45 + 175 * sensor_value_temp / 65535;
+    this->status_clear_warning();
 
-        this->temp_sensor_->publish_state(temp);
-      }
+    // Evaluate and publish measurements
+    if (this->temp_sensor_ != nullptr) {
+      // Temp is contained in the first result word
+      float sensor_value_temp = buffer[0];
+      float temp = -45 + 175 * sensor_value_temp / 65535;
+
+      this->temp_sensor_->publish_state(temp);
+    }
 
-      if (this->humidity_sensor_ != nullptr) {
-        // Relative humidity is in the second result word
-        float sensor_value_rh = buffer[1];
-        float rh = -6 + 125 * sensor_value_rh / 65535;
+    if (this->humidity_sensor_ != nullptr) {
+      // Relative humidity is in the second result word
+      float sensor_value_rh = buffer[1];
+      float rh = -6 + 125 * sensor_value_rh / 65535;
 
-        this->humidity_sensor_->publish_state(rh);
-      }
-    } else {
-      ESP_LOGD(TAG, "Sensor read failed");
+      this->humidity_sensor_->publish_state(rh);
     }
   });
 }

esphome/components/sht4x/sht4x.h

@@ -13,7 +13,7 @@ enum SHT4XPRECISION { SHT4X_PRECISION_HIGH = 0, SHT4X_PRECISION_MED, SHT4X_PRECI
 
 enum SHT4XHEATERPOWER { SHT4X_HEATERPOWER_HIGH, SHT4X_HEATERPOWER_MED, SHT4X_HEATERPOWER_LOW };
 
-enum SHT4XHEATERTIME { SHT4X_HEATERTIME_LONG = 1100, SHT4X_HEATERTIME_SHORT = 110 };
+enum SHT4XHEATERTIME : uint16_t { SHT4X_HEATERTIME_LONG = 1100, SHT4X_HEATERTIME_SHORT = 110 };
 
 class SHT4XComponent : public PollingComponent, public sensirion_common::SensirionI2CDevice {
  public:

esphome/components/sml/text_sensor/__init__.py

@@ -1,7 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import text_sensor
 import esphome.config_validation as cv
-from esphome.const import CONF_FORMAT, CONF_ID
+from esphome.const import CONF_FORMAT
 
 from .. import CONF_OBIS_CODE, CONF_SERVER_ID, CONF_SML_ID, Sml, obis_code, sml_ns
 
@@ -19,9 +19,8 @@ SML_TYPES = {
 
 SmlTextSensor = sml_ns.class_("SmlTextSensor", text_sensor.TextSensor, cg.Component)
 
-CONFIG_SCHEMA = text_sensor.TEXT_SENSOR_SCHEMA.extend(
+CONFIG_SCHEMA = text_sensor.text_sensor_schema(SmlTextSensor).extend(
     {
-        cv.GenerateID(): cv.declare_id(SmlTextSensor),
         cv.GenerateID(CONF_SML_ID): cv.use_id(Sml),
         cv.Required(CONF_OBIS_CODE): obis_code,
         cv.Optional(CONF_SERVER_ID, default=""): cv.string,
@@ -31,13 +30,12 @@ CONFIG_SCHEMA = text_sensor.TEXT_SENSOR_SCHEMA.extend(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(
-        config[CONF_ID],
+    var = await text_sensor.new_text_sensor(
+        config,
         config[CONF_SERVER_ID],
         config[CONF_OBIS_CODE],
         config[CONF_FORMAT],
     )
     await cg.register_component(var, config)
-    await text_sensor.register_text_sensor(var, config)
     sml = await cg.get_variable(config[CONF_SML_ID])
     cg.add(sml.register_sml_listener(var))

esphome/components/sound_level/sensor.py

@@ -0,0 +1,97 @@
+from esphome import automation
+import esphome.codegen as cg
+from esphome.components import microphone, sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    CONF_MEASUREMENT_DURATION,
+    CONF_MICROPHONE,
+    DEVICE_CLASS_SOUND_PRESSURE,
+    PLATFORM_ESP32,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_DECIBEL,
+)
+
+AUTOLOAD = ["audio"]
+CODEOWNERS = ["@kahrendt"]
+DEPENDENCIES = ["microphone"]
+
+
+CONF_PASSIVE = "passive"
+CONF_PEAK = "peak"
+CONF_RMS = "rms"
+
+sound_level_ns = cg.esphome_ns.namespace("sound_level")
+SoundLevelComponent = sound_level_ns.class_("SoundLevelComponent", cg.Component)
+
+StartAction = sound_level_ns.class_("StartAction", automation.Action)
+StopAction = sound_level_ns.class_("StopAction", automation.Action)
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(SoundLevelComponent),
+            cv.Optional(CONF_MEASUREMENT_DURATION, default="1000ms"): cv.All(
+                cv.positive_time_period_milliseconds,
+                cv.Range(
+                    min=cv.TimePeriod(milliseconds=50),
+                    max=cv.TimePeriod(seconds=60),
+                ),
+            ),
+            cv.Optional(
+                CONF_MICROPHONE, default={}
+            ): microphone.microphone_source_schema(
+                min_bits_per_sample=16,
+                max_bits_per_sample=16,
+            ),
+            cv.Required(CONF_PASSIVE): cv.boolean,
+            cv.Optional(CONF_PEAK): sensor.sensor_schema(
+                unit_of_measurement=UNIT_DECIBEL,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_SOUND_PRESSURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_RMS): sensor.sensor_schema(
+                unit_of_measurement=UNIT_DECIBEL,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_SOUND_PRESSURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    ).extend(cv.COMPONENT_SCHEMA),
+    cv.only_on([PLATFORM_ESP32]),
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+
+    mic_source = await microphone.microphone_source_to_code(
+        config[CONF_MICROPHONE], passive=config[CONF_PASSIVE]
+    )
+    cg.add(var.set_microphone_source(mic_source))
+
+    cg.add(var.set_measurement_duration(config[CONF_MEASUREMENT_DURATION]))
+
+    if peak_config := config.get(CONF_PEAK):
+        sens = await sensor.new_sensor(peak_config)
+        cg.add(var.set_peak_sensor(sens))
+    if rms_config := config.get(CONF_RMS):
+        sens = await sensor.new_sensor(rms_config)
+        cg.add(var.set_rms_sensor(sens))
+
+
+SOUND_LEVEL_ACTION_SCHEMA = automation.maybe_simple_id(
+    {
+        cv.GenerateID(): cv.use_id(SoundLevelComponent),
+    }
+)
+
+
+@automation.register_action("sound_level.start", StartAction, SOUND_LEVEL_ACTION_SCHEMA)
+@automation.register_action("sound_level.stop", StopAction, SOUND_LEVEL_ACTION_SCHEMA)
+async def sound_level_action_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var