esphome 2025.2.1__py3-none-any.whl → 2025.3.0__py3-none-any.whl

esphome/components/mlx90393/sensor.py

@@ -1,20 +1,21 @@
+from esphome import pins
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import i2c, sensor
+import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ID,
-    UNIT_MICROTESLA,
-    UNIT_CELSIUS,
-    STATE_CLASS_MEASUREMENT,
-    ICON_MAGNET,
-    ICON_THERMOMETER,
+    CONF_FILTER,
     CONF_GAIN,
-    CONF_RESOLUTION,
+    CONF_ID,
     CONF_OVERSAMPLING,
-    CONF_FILTER,
+    CONF_RESOLUTION,
     CONF_TEMPERATURE,
+    CONF_TEMPERATURE_COMPENSATION,
+    ICON_MAGNET,
+    ICON_THERMOMETER,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_MICROTESLA,
 )
-from esphome import pins
 
 CODEOWNERS = ["@functionpointer"]
 DEPENDENCIES = ["i2c"]
@@ -26,30 +27,46 @@ MLX90393Component = mlx90393_ns.class_(
 )
 
 GAIN = {
-    "1X": 7,
-    "1_33X": 6,
-    "1_67X": 5,
-    "2X": 4,
-    "2_5X": 3,
-    "3X": 2,
-    "4X": 1,
-    "5X": 0,
+    "1X": 0,
+    "1_25X": 1,
+    "1_67X": 2,
+    "2X": 3,
+    "2_5X": 4,
+    "3X": 5,
+    "3_75X": 6,
+    "5X": 7,
 }
 
 RESOLUTION = {
-    "16BIT": 0,
-    "17BIT": 1,
-    "18BIT": 2,
-    "19BIT": 3,
+    "DIV_8": 3,
+    "DIV_4": 2,
+    "DIV_2": 1,
+    "DIV_1": 0,
 }
 
 CONF_X_AXIS = "x_axis"
 CONF_Y_AXIS = "y_axis"
 CONF_Z_AXIS = "z_axis"
 CONF_DRDY_PIN = "drdy_pin"
+CONF_HALLCONF = "hallconf"
+
+
+def _validate(config):
+    if config[CONF_TEMPERATURE_COMPENSATION]:
+        for axis in [CONF_X_AXIS, CONF_Y_AXIS, CONF_Z_AXIS]:
+            if axis not in config:
+                continue
+            if (res := config[axis][CONF_RESOLUTION]) in [
+                "DIV_8",
+                "DIV_4",
+            ]:
+                raise cv.Invalid(
+                    f"{axis}: {CONF_RESOLUTION} cannot be {res} with {CONF_TEMPERATURE_COMPENSATION} enabled"
+                )
+    return config
 
 
-def mlx90393_axis_schema(default_resolution: str):
+def mlx90393_axis_schema():
     return sensor.sensor_schema(
         unit_of_measurement=UNIT_MICROTESLA,
         accuracy_decimals=0,
@@ -58,7 +75,7 @@ def mlx90393_axis_schema(default_resolution: str):
     ).extend(
         cv.Schema(
             {
-                cv.Optional(CONF_RESOLUTION, default=default_resolution): cv.enum(
+                cv.Optional(CONF_RESOLUTION, default="DIV_4"): cv.enum(
                     RESOLUTION, upper=True, space="_"
                 )
             }
@@ -66,19 +83,19 @@ def mlx90393_axis_schema(default_resolution: str):
     )
 
 
-CONFIG_SCHEMA = (
+CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(MLX90393Component),
-            cv.Optional(CONF_GAIN, default="2_5X"): cv.enum(
-                GAIN, upper=True, space="_"
-            ),
+            cv.Optional(CONF_GAIN, default="1X"): cv.enum(GAIN, upper=True, space="_"),
             cv.Optional(CONF_DRDY_PIN): pins.gpio_input_pin_schema,
-            cv.Optional(CONF_OVERSAMPLING, default=2): cv.int_range(min=0, max=3),
+            cv.Optional(CONF_OVERSAMPLING, default=0): cv.int_range(min=0, max=3),
             cv.Optional(CONF_FILTER, default=6): cv.int_range(min=0, max=7),
-            cv.Optional(CONF_X_AXIS): mlx90393_axis_schema("19BIT"),
-            cv.Optional(CONF_Y_AXIS): mlx90393_axis_schema("19BIT"),
-            cv.Optional(CONF_Z_AXIS): mlx90393_axis_schema("16BIT"),
+            cv.Optional(CONF_X_AXIS): mlx90393_axis_schema(),
+            cv.Optional(CONF_Y_AXIS): mlx90393_axis_schema(),
+            cv.Optional(CONF_Z_AXIS): mlx90393_axis_schema(),
+            cv.Optional(CONF_TEMPERATURE_COMPENSATION, default=False): bool,
+            cv.Optional(CONF_HALLCONF, default=0xC): cv.one_of(0xC, 0x0),
             cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
                 unit_of_measurement=UNIT_CELSIUS,
                 accuracy_decimals=1,
@@ -96,7 +113,8 @@ CONFIG_SCHEMA = (
         },
     )
     .extend(cv.polling_component_schema("60s"))
-    .extend(i2c.i2c_device_schema(0x0C))
+    .extend(i2c.i2c_device_schema(0x0C)),
+    _validate,
 )
 
 
@@ -111,6 +129,8 @@ async def to_code(config):
     cg.add(var.set_gain(GAIN[config[CONF_GAIN]]))
     cg.add(var.set_oversampling(config[CONF_OVERSAMPLING]))
     cg.add(var.set_filter(config[CONF_FILTER]))
+    cg.add(var.set_temperature_compensation(config[CONF_TEMPERATURE_COMPENSATION]))
+    cg.add(var.set_hallconf(config[CONF_HALLCONF]))
 
     if CONF_X_AXIS in config:
         sens = await sensor.new_sensor(config[CONF_X_AXIS])

esphome/components/mlx90393/sensor_mlx90393.cpp

@@ -43,6 +43,10 @@ void MLX90393Cls::setup() {
   this->mlx_.setDigitalFiltering(this->filter_);
 
   this->mlx_.setTemperatureOverSampling(this->temperature_oversampling_);
+
+  this->mlx_.setTemperatureCompensation(this->temperature_compensation_);
+
+  this->mlx_.setHallConf(this->hallconf_);
 }
 
 void MLX90393Cls::dump_config() {

esphome/components/mlx90393/sensor_mlx90393.h

@@ -29,7 +29,10 @@ class MLX90393Cls : public PollingComponent, public i2c::I2CDevice, public MLX90
   void set_resolution(uint8_t xyz, uint8_t res) { resolutions_[xyz] = res; }
   void set_filter(uint8_t filter) { filter_ = filter; }
   void set_gain(uint8_t gain_sel) { gain_ = gain_sel; }
-
+  void set_temperature_compensation(bool temperature_compensation) {
+    temperature_compensation_ = temperature_compensation;
+  }
+  void set_hallconf(uint8_t hallconf) { hallconf_ = hallconf; }
   // overrides for MLX library
 
   // disable lint because it keeps suggesting const uint8_t *response.
@@ -49,9 +52,11 @@ class MLX90393Cls : public PollingComponent, public i2c::I2CDevice, public MLX90
   sensor::Sensor *t_sensor_{nullptr};
   uint8_t gain_;
   uint8_t oversampling_;
-  uint8_t temperature_oversampling_ = 0;
+  uint8_t temperature_oversampling_{0};
   uint8_t filter_;
-  uint8_t resolutions_[3] = {0};
+  uint8_t resolutions_[3]{0};
+  bool temperature_compensation_{false};
+  uint8_t hallconf_{0xC};
   GPIOPin *drdy_pin_{nullptr};
 };
 

esphome/components/mqtt/__init__.py

@@ -36,6 +36,7 @@ from esphome.const import (
     CONF_PAYLOAD_AVAILABLE,
     CONF_PAYLOAD_NOT_AVAILABLE,
     CONF_PORT,
+    CONF_PUBLISH_NAN_AS_NONE,
     CONF_QOS,
     CONF_REBOOT_TIMEOUT,
     CONF_RETAIN,
@@ -49,7 +50,6 @@ from esphome.const import (
     CONF_USE_ABBREVIATIONS,
     CONF_USERNAME,
     CONF_WILL_MESSAGE,
-    CONF_PUBLISH_NAN_AS_NONE,
     PLATFORM_BK72XX,
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
@@ -406,7 +406,7 @@ async def to_code(config):
     if CONF_SSL_FINGERPRINTS in config:
         for fingerprint in config[CONF_SSL_FINGERPRINTS]:
             arr = [
-                cg.RawExpression(f"0x{fingerprint[i:i + 2]}") for i in range(0, 40, 2)
+                cg.RawExpression(f"0x{fingerprint[i : i + 2]}") for i in range(0, 40, 2)
             ]
             cg.add(var.add_ssl_fingerprint(arr))
         cg.add_build_flag("-DASYNC_TCP_SSL_ENABLED=1")

esphome/components/msa3xx/__init__.py

@@ -0,0 +1,189 @@
+from esphome import automation
+import esphome.codegen as cg
+from esphome.components import i2c
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_CALIBRATION,
+    CONF_ID,
+    CONF_MIRROR_X,
+    CONF_MIRROR_Y,
+    CONF_OFFSET_X,
+    CONF_OFFSET_Y,
+    CONF_OFFSET_Z,
+    CONF_RANGE,
+    CONF_RESOLUTION,
+    CONF_SWAP_XY,
+    CONF_TRANSFORM,
+    CONF_TYPE,
+)
+
+CODEOWNERS = ["@latonita"]
+DEPENDENCIES = ["i2c"]
+
+MULTI_CONF = True
+
+CONF_MSA3XX_ID = "msa3xx_id"
+
+CONF_MIRROR_Z = "mirror_z"
+CONF_ON_ACTIVE = "on_active"
+CONF_ON_DOUBLE_TAP = "on_double_tap"
+CONF_ON_FREEFALL = "on_freefall"
+CONF_ON_ORIENTATION = "on_orientation"
+CONF_ON_TAP = "on_tap"
+
+MODEL_MSA301 = "MSA301"
+MODEL_MSA311 = "MSA311"
+
+msa3xx_ns = cg.esphome_ns.namespace("msa3xx")
+MSA3xxComponent = msa3xx_ns.class_(
+    "MSA3xxComponent", cg.PollingComponent, i2c.I2CDevice
+)
+
+MSAModels = msa3xx_ns.enum("Model", True)
+MSA_MODELS = {
+    MODEL_MSA301: MSAModels.MSA301,
+    MODEL_MSA311: MSAModels.MSA311,
+}
+
+MSARange = msa3xx_ns.enum("Range", True)
+MSA_RANGES = {
+    "2G": MSARange.RANGE_2G,
+    "4G": MSARange.RANGE_4G,
+    "8G": MSARange.RANGE_8G,
+    "16G": MSARange.RANGE_16G,
+}
+
+MSAResolution = msa3xx_ns.enum("Resolution", True)
+RESOLUTIONS_MSA301 = {
+    14: MSAResolution.RES_14BIT,
+    12: MSAResolution.RES_12BIT,
+    10: MSAResolution.RES_10BIT,
+    8: MSAResolution.RES_8BIT,
+}
+
+RESOLUTIONS_MSA311 = {
+    12: MSAResolution.RES_12BIT,
+}
+
+_COMMON_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(MSA3xxComponent),
+        cv.Optional(CONF_RANGE, default="2G"): cv.enum(MSA_RANGES, upper=True),
+        cv.Optional(CONF_CALIBRATION): cv.Schema(
+            {
+                cv.Optional(CONF_OFFSET_X, default=0): cv.float_range(
+                    min=-4.5, max=4.5
+                ),
+                cv.Optional(CONF_OFFSET_Y, default=0): cv.float_range(
+                    min=-4.5, max=4.5
+                ),
+                cv.Optional(CONF_OFFSET_Z, default=0): cv.float_range(
+                    min=-4.5, max=4.5
+                ),
+            }
+        ),
+        cv.Optional(CONF_TRANSFORM): cv.Schema(
+            {
+                cv.Optional(CONF_MIRROR_X, default=False): cv.boolean,
+                cv.Optional(CONF_MIRROR_Y, default=False): cv.boolean,
+                cv.Optional(CONF_MIRROR_Z, default=False): cv.boolean,
+                cv.Optional(CONF_SWAP_XY, default=False): cv.boolean,
+            }
+        ),
+        cv.Optional(CONF_ON_ACTIVE): automation.validate_automation(single=True),
+        cv.Optional(CONF_ON_TAP): automation.validate_automation(single=True),
+        cv.Optional(CONF_ON_DOUBLE_TAP): automation.validate_automation(single=True),
+        cv.Optional(CONF_ON_FREEFALL): automation.validate_automation(single=True),
+        cv.Optional(CONF_ON_ORIENTATION): automation.validate_automation(single=True),
+    }
+).extend(cv.polling_component_schema("10s"))
+
+
+CONFIG_SCHEMA = cv.typed_schema(
+    {
+        MODEL_MSA301: _COMMON_SCHEMA.extend(
+            {
+                cv.Optional(CONF_RESOLUTION, default=14): cv.enum(RESOLUTIONS_MSA301),
+            }
+        ).extend(i2c.i2c_device_schema(0x26)),
+        MODEL_MSA311: _COMMON_SCHEMA.extend(
+            {
+                cv.Optional(CONF_RESOLUTION, default=12): cv.enum(RESOLUTIONS_MSA311),
+            }
+        ).extend(i2c.i2c_device_schema(0x62)),
+    },
+    upper=True,
+    enum=MSA_MODELS,
+)
+
+MSA_SENSOR_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_MSA3XX_ID): cv.use_id(MSA3xxComponent),
+    }
+)
+
+
+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)
+
+    cg.add(var.set_model(config[CONF_TYPE]))
+    cg.add(var.set_range(MSA_RANGES[config[CONF_RANGE]]))
+    cg.add(var.set_resolution(RESOLUTIONS_MSA301[config[CONF_RESOLUTION]]))
+
+    if transform := config.get(CONF_TRANSFORM):
+        cg.add(
+            var.set_transform(
+                transform[CONF_MIRROR_X],
+                transform[CONF_MIRROR_Y],
+                transform[CONF_MIRROR_Z],
+                transform[CONF_SWAP_XY],
+            )
+        )
+
+    if calibration_config := config.get(CONF_CALIBRATION):
+        cg.add(
+            var.set_offset(
+                calibration_config[CONF_OFFSET_X],
+                calibration_config[CONF_OFFSET_Y],
+                calibration_config[CONF_OFFSET_Z],
+            )
+        )
+
+    # Triggers secton
+
+    if CONF_ON_ORIENTATION in config:
+        await automation.build_automation(
+            var.get_orientation_trigger(),
+            [],
+            config[CONF_ON_ORIENTATION],
+        )
+
+    if CONF_ON_TAP in config:
+        await automation.build_automation(
+            var.get_tap_trigger(),
+            [],
+            config[CONF_ON_TAP],
+        )
+
+    if CONF_ON_DOUBLE_TAP in config:
+        await automation.build_automation(
+            var.get_double_tap_trigger(),
+            [],
+            config[CONF_ON_DOUBLE_TAP],
+        )
+
+    if CONF_ON_ACTIVE in config:
+        await automation.build_automation(
+            var.get_active_trigger(),
+            [],
+            config[CONF_ON_ACTIVE],
+        )
+
+    if CONF_ON_FREEFALL in config:
+        await automation.build_automation(
+            var.get_freefall_trigger(),
+            [],
+            config[CONF_ON_FREEFALL],
+        )

esphome/components/msa3xx/binary_sensor.py

@@ -0,0 +1,40 @@
+import esphome.codegen as cg
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ACTIVE, CONF_NAME, DEVICE_CLASS_VIBRATION, ICON_VIBRATE
+
+from . import CONF_MSA3XX_ID, MSA_SENSOR_SCHEMA
+
+CODEOWNERS = ["@latonita"]
+DEPENDENCIES = ["msa3xx"]
+
+CONF_TAP = "tap"
+CONF_DOUBLE_TAP = "double_tap"
+
+ICON_TAP = "mdi:gesture-tap"
+ICON_DOUBLE_TAP = "mdi:gesture-double-tap"
+
+EVENT_SENSORS = (CONF_TAP, CONF_DOUBLE_TAP, CONF_ACTIVE)
+ICONS = (ICON_TAP, ICON_DOUBLE_TAP, ICON_VIBRATE)
+
+CONFIG_SCHEMA = MSA_SENSOR_SCHEMA.extend(
+    {
+        cv.Optional(event): cv.maybe_simple_value(
+            binary_sensor.binary_sensor_schema(
+                device_class=DEVICE_CLASS_VIBRATION,
+                icon=icon,
+            ),
+            key=CONF_NAME,
+        )
+        for event, icon in zip(EVENT_SENSORS, ICONS)
+    }
+)
+
+
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_MSA3XX_ID])
+
+    for sensor in EVENT_SENSORS:
+        if sensor in config:
+            sens = await binary_sensor.new_binary_sensor(config[sensor])
+            cg.add(getattr(hub, f"set_{sensor}_binary_sensor")(sens))