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

esphome/components/ld2450/sensor.py

@@ -0,0 +1,156 @@
+import esphome.codegen as cg
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ANGLE,
+    CONF_DISTANCE,
+    CONF_RESOLUTION,
+    CONF_SPEED,
+    DEVICE_CLASS_DISTANCE,
+    DEVICE_CLASS_SPEED,
+    UNIT_DEGREES,
+    UNIT_MILLIMETER,
+)
+
+from . import CONF_LD2450_ID, LD2450Component
+
+DEPENDENCIES = ["ld2450"]
+
+CONF_MOVING_TARGET_COUNT = "moving_target_count"
+CONF_STILL_TARGET_COUNT = "still_target_count"
+CONF_TARGET_COUNT = "target_count"
+CONF_X = "x"
+CONF_Y = "y"
+
+ICON_ACCOUNT_GROUP = "mdi:account-group"
+ICON_ACCOUNT_SWITCH = "mdi:account-switch"
+ICON_ALPHA_X_BOX_OUTLINE = "mdi:alpha-x-box-outline"
+ICON_ALPHA_Y_BOX_OUTLINE = "mdi:alpha-y-box-outline"
+ICON_FORMAT_TEXT_ROTATION_ANGLE_UP = "mdi:format-text-rotation-angle-up"
+ICON_HUMAN_GREETING_PROXIMITY = "mdi:human-greeting-proximity"
+ICON_MAP_MARKER_ACCOUNT = "mdi:map-marker-account"
+ICON_MAP_MARKER_DISTANCE = "mdi:map-marker-distance"
+ICON_RELATION_ZERO_OR_ONE_TO_ZERO_OR_ONE = "mdi:relation-zero-or-one-to-zero-or-one"
+ICON_SPEEDOMETER_SLOW = "mdi:speedometer-slow"
+
+MAX_TARGETS = 3
+MAX_ZONES = 3
+
+UNIT_MILLIMETER_PER_SECOND = "mm/s"
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
+        cv.Optional(CONF_TARGET_COUNT): sensor.sensor_schema(
+            icon=ICON_ACCOUNT_GROUP,
+        ),
+        cv.Optional(CONF_STILL_TARGET_COUNT): sensor.sensor_schema(
+            icon=ICON_HUMAN_GREETING_PROXIMITY,
+        ),
+        cv.Optional(CONF_MOVING_TARGET_COUNT): sensor.sensor_schema(
+            icon=ICON_ACCOUNT_SWITCH,
+        ),
+    }
+)
+
+CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
+    {
+        cv.Optional(f"target_{n + 1}"): cv.Schema(
+            {
+                cv.Optional(CONF_X): sensor.sensor_schema(
+                    device_class=DEVICE_CLASS_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
+                    icon=ICON_ALPHA_X_BOX_OUTLINE,
+                ),
+                cv.Optional(CONF_Y): sensor.sensor_schema(
+                    device_class=DEVICE_CLASS_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
+                    icon=ICON_ALPHA_Y_BOX_OUTLINE,
+                ),
+                cv.Optional(CONF_SPEED): sensor.sensor_schema(
+                    device_class=DEVICE_CLASS_SPEED,
+                    unit_of_measurement=UNIT_MILLIMETER_PER_SECOND,
+                    icon=ICON_SPEEDOMETER_SLOW,
+                ),
+                cv.Optional(CONF_ANGLE): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_DEGREES,
+                    icon=ICON_FORMAT_TEXT_ROTATION_ANGLE_UP,
+                ),
+                cv.Optional(CONF_DISTANCE): sensor.sensor_schema(
+                    device_class=DEVICE_CLASS_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
+                    icon=ICON_MAP_MARKER_DISTANCE,
+                ),
+                cv.Optional(CONF_RESOLUTION): sensor.sensor_schema(
+                    device_class=DEVICE_CLASS_DISTANCE,
+                    unit_of_measurement=UNIT_MILLIMETER,
+                    icon=ICON_RELATION_ZERO_OR_ONE_TO_ZERO_OR_ONE,
+                ),
+            }
+        )
+        for n in range(MAX_TARGETS)
+    },
+    {
+        cv.Optional(f"zone_{n + 1}"): cv.Schema(
+            {
+                cv.Optional(CONF_TARGET_COUNT): sensor.sensor_schema(
+                    icon=ICON_MAP_MARKER_ACCOUNT,
+                ),
+                cv.Optional(CONF_STILL_TARGET_COUNT): sensor.sensor_schema(
+                    icon=ICON_MAP_MARKER_ACCOUNT,
+                ),
+                cv.Optional(CONF_MOVING_TARGET_COUNT): sensor.sensor_schema(
+                    icon=ICON_MAP_MARKER_ACCOUNT,
+                ),
+            }
+        )
+        for n in range(MAX_ZONES)
+    },
+)
+
+
+async def to_code(config):
+    ld2450_component = await cg.get_variable(config[CONF_LD2450_ID])
+
+    if target_count_config := config.get(CONF_TARGET_COUNT):
+        sens = await sensor.new_sensor(target_count_config)
+        cg.add(ld2450_component.set_target_count_sensor(sens))
+
+    if still_target_count_config := config.get(CONF_STILL_TARGET_COUNT):
+        sens = await sensor.new_sensor(still_target_count_config)
+        cg.add(ld2450_component.set_still_target_count_sensor(sens))
+
+    if moving_target_count_config := config.get(CONF_MOVING_TARGET_COUNT):
+        sens = await sensor.new_sensor(moving_target_count_config)
+        cg.add(ld2450_component.set_moving_target_count_sensor(sens))
+    for n in range(MAX_TARGETS):
+        if target_conf := config.get(f"target_{n + 1}"):
+            if x_config := target_conf.get(CONF_X):
+                sens = await sensor.new_sensor(x_config)
+                cg.add(ld2450_component.set_move_x_sensor(n, sens))
+            if y_config := target_conf.get(CONF_Y):
+                sens = await sensor.new_sensor(y_config)
+                cg.add(ld2450_component.set_move_y_sensor(n, sens))
+            if speed_config := target_conf.get(CONF_SPEED):
+                sens = await sensor.new_sensor(speed_config)
+                cg.add(ld2450_component.set_move_speed_sensor(n, sens))
+            if angle_config := target_conf.get(CONF_ANGLE):
+                sens = await sensor.new_sensor(angle_config)
+                cg.add(ld2450_component.set_move_angle_sensor(n, sens))
+            if distance_config := target_conf.get(CONF_DISTANCE):
+                sens = await sensor.new_sensor(distance_config)
+                cg.add(ld2450_component.set_move_distance_sensor(n, sens))
+            if resolution_config := target_conf.get(CONF_RESOLUTION):
+                sens = await sensor.new_sensor(resolution_config)
+                cg.add(ld2450_component.set_move_resolution_sensor(n, sens))
+    for n in range(MAX_ZONES):
+        if zone_config := config.get(f"zone_{n + 1}"):
+            if target_count_config := zone_config.get(CONF_TARGET_COUNT):
+                sens = await sensor.new_sensor(target_count_config)
+                cg.add(ld2450_component.set_zone_target_count_sensor(n, sens))
+            if still_target_count_config := zone_config.get(CONF_STILL_TARGET_COUNT):
+                sens = await sensor.new_sensor(still_target_count_config)
+                cg.add(ld2450_component.set_zone_still_target_count_sensor(n, sens))
+            if moving_target_count_config := zone_config.get(CONF_MOVING_TARGET_COUNT):
+                sens = await sensor.new_sensor(moving_target_count_config)
+                cg.add(ld2450_component.set_zone_moving_target_count_sensor(n, sens))

esphome/components/ld2450/switch/__init__.py

@@ -0,0 +1,45 @@
+import esphome.codegen as cg
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import (
+    DEVICE_CLASS_SWITCH,
+    ENTITY_CATEGORY_CONFIG,
+    ICON_BLUETOOTH,
+    ICON_PULSE,
+)
+
+from .. import CONF_LD2450_ID, LD2450Component, ld2450_ns
+
+BluetoothSwitch = ld2450_ns.class_("BluetoothSwitch", switch.Switch)
+MultiTargetSwitch = ld2450_ns.class_("MultiTargetSwitch", switch.Switch)
+
+CONF_BLUETOOTH = "bluetooth"
+CONF_MULTI_TARGET = "multi_target"
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
+    cv.Optional(CONF_BLUETOOTH): switch.switch_schema(
+        BluetoothSwitch,
+        device_class=DEVICE_CLASS_SWITCH,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_BLUETOOTH,
+    ),
+    cv.Optional(CONF_MULTI_TARGET): switch.switch_schema(
+        MultiTargetSwitch,
+        device_class=DEVICE_CLASS_SWITCH,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_PULSE,
+    ),
+}
+
+
+async def to_code(config):
+    ld2450_component = await cg.get_variable(config[CONF_LD2450_ID])
+    if bluetooth_config := config.get(CONF_BLUETOOTH):
+        s = await switch.new_switch(bluetooth_config)
+        await cg.register_parented(s, config[CONF_LD2450_ID])
+        cg.add(ld2450_component.set_bluetooth_switch(s))
+    if multi_target_config := config.get(CONF_MULTI_TARGET):
+        s = await switch.new_switch(multi_target_config)
+        await cg.register_parented(s, config[CONF_LD2450_ID])
+        cg.add(ld2450_component.set_multi_target_switch(s))

esphome/components/ld2450/switch/bluetooth_switch.cpp

@@ -0,0 +1,12 @@
+#include "bluetooth_switch.h"
+
+namespace esphome {
+namespace ld2450 {
+
+void BluetoothSwitch::write_state(bool state) {
+  this->publish_state(state);
+  this->parent_->set_bluetooth(state);
+}
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/switch/bluetooth_switch.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../ld2450.h"
+
+namespace esphome {
+namespace ld2450 {
+
+class BluetoothSwitch : public switch_::Switch, public Parented<LD2450Component> {
+ public:
+  BluetoothSwitch() = default;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/switch/multi_target_switch.cpp

@@ -0,0 +1,12 @@
+#include "multi_target_switch.h"
+
+namespace esphome {
+namespace ld2450 {
+
+void MultiTargetSwitch::write_state(bool state) {
+  this->publish_state(state);
+  this->parent_->set_multi_target(state);
+}
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/switch/multi_target_switch.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../ld2450.h"
+
+namespace esphome {
+namespace ld2450 {
+
+class MultiTargetSwitch : public switch_::Switch, public Parented<LD2450Component> {
+ public:
+  MultiTargetSwitch() = default;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace ld2450
+}  // namespace esphome

esphome/components/ld2450/text_sensor.py

@@ -0,0 +1,62 @@
+import esphome.codegen as cg
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_DIRECTION,
+    CONF_MAC_ADDRESS,
+    CONF_VERSION,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    ENTITY_CATEGORY_NONE,
+    ICON_BLUETOOTH,
+    ICON_CHIP,
+    ICON_SIGN_DIRECTION,
+)
+
+from . import CONF_LD2450_ID, LD2450Component
+
+DEPENDENCIES = ["ld2450"]
+
+MAX_TARGETS = 3
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
+        cv.Optional(CONF_VERSION): text_sensor.text_sensor_schema(
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            icon=ICON_CHIP,
+        ),
+        cv.Optional(CONF_MAC_ADDRESS): text_sensor.text_sensor_schema(
+            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            icon=ICON_BLUETOOTH,
+        ),
+    }
+)
+
+CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
+    {
+        cv.Optional(f"target_{n + 1}"): cv.Schema(
+            {
+                cv.Optional(CONF_DIRECTION): text_sensor.text_sensor_schema(
+                    entity_category=ENTITY_CATEGORY_NONE,
+                    icon=ICON_SIGN_DIRECTION,
+                ),
+            }
+        )
+        for n in range(MAX_TARGETS)
+    }
+)
+
+
+async def to_code(config):
+    ld2450_component = await cg.get_variable(config[CONF_LD2450_ID])
+    if version_config := config.get(CONF_VERSION):
+        sens = await text_sensor.new_text_sensor(version_config)
+        cg.add(ld2450_component.set_version_text_sensor(sens))
+    if mac_address_config := config.get(CONF_MAC_ADDRESS):
+        sens = await text_sensor.new_text_sensor(mac_address_config)
+        cg.add(ld2450_component.set_mac_text_sensor(sens))
+    for n in range(MAX_TARGETS):
+        if direction_conf := config.get(f"target_{n + 1}"):
+            if direction_config := direction_conf.get(CONF_DIRECTION):
+                sens = await text_sensor.new_text_sensor(direction_config)
+                cg.add(ld2450_component.set_direction_text_sensor(n, sens))

esphome/components/lvgl/defines.py

@@ -462,8 +462,6 @@ CONF_LVGL_ID = "lvgl_id"
 CONF_LONG_MODE = "long_mode"
 CONF_MSGBOXES = "msgboxes"
 CONF_OBJ = "obj"
-CONF_OFFSET_X = "offset_x"
-CONF_OFFSET_Y = "offset_y"
 CONF_ONE_CHECKED = "one_checked"
 CONF_ONE_LINE = "one_line"
 CONF_ON_PAUSE = "on_pause"

esphome/components/lvgl/font.cpp

@@ -19,7 +19,7 @@ static bool get_glyph_dsc_cb(const lv_font_t *font, lv_font_glyph_dsc_t *dsc, ui
   const auto *gd = fe->get_glyph_data(unicode_letter);
   if (gd == nullptr)
     return false;
-  dsc->adv_w = gd->offset_x + gd->width;
+  dsc->adv_w = gd->advance;
   dsc->ofs_x = gd->offset_x;
   dsc->ofs_y = fe->height - gd->height - gd->offset_y - fe->baseline;
   dsc->box_w = gd->width;

esphome/components/lvgl/lvgl_esphome.cpp

@@ -416,37 +416,45 @@ LvglComponent::LvglComponent(std::vector<display::Display *> displays, float buf
       buffer_frac_(buffer_frac),
       full_refresh_(full_refresh),
       resume_on_input_(resume_on_input) {
-  auto *display = this->displays_[0];
-  size_t buffer_pixels = display->get_width() * display->get_height() / this->buffer_frac_;
-  auto buf_bytes = buffer_pixels * LV_COLOR_DEPTH / 8;
-  this->rotation = display->get_rotation();
-  if (this->rotation != display::DISPLAY_ROTATION_0_DEGREES) {
-    this->rotate_buf_ = static_cast<lv_color_t *>(lv_custom_mem_alloc(buf_bytes));  // NOLINT
-    if (this->rotate_buf_ == nullptr)
-      return;
-  }
-  auto *buf = lv_custom_mem_alloc(buf_bytes);  // NOLINT
-  if (buf == nullptr)
-    return;
-  lv_disp_draw_buf_init(&this->draw_buf_, buf, nullptr, buffer_pixels);
+  lv_disp_draw_buf_init(&this->draw_buf_, nullptr, nullptr, 0);
   lv_disp_drv_init(&this->disp_drv_);
   this->disp_drv_.draw_buf = &this->draw_buf_;
   this->disp_drv_.user_data = this;
   this->disp_drv_.full_refresh = this->full_refresh_;
   this->disp_drv_.flush_cb = static_flush_cb;
   this->disp_drv_.rounder_cb = rounder_cb;
-  this->disp_drv_.hor_res = (lv_coord_t) display->get_width();
-  this->disp_drv_.ver_res = (lv_coord_t) display->get_height();
+  this->disp_drv_.hor_res = 0;
+  this->disp_drv_.ver_res = 0;
   this->disp_ = lv_disp_drv_register(&this->disp_drv_);
 }
 
 void LvglComponent::setup() {
-  if (this->draw_buf_.buf1 == nullptr) {
+  ESP_LOGCONFIG(TAG, "LVGL Setup starts");
+  auto *display = this->displays_[0];
+  auto width = display->get_width();
+  auto height = display->get_height();
+  size_t buffer_pixels = width * height / this->buffer_frac_;
+  auto buf_bytes = buffer_pixels * LV_COLOR_DEPTH / 8;
+  auto *buffer = lv_custom_mem_alloc(buf_bytes);  // NOLINT
+  if (buffer == nullptr) {
     this->mark_failed();
     this->status_set_error("Memory allocation failure");
     return;
   }
-  ESP_LOGCONFIG(TAG, "LVGL Setup starts");
+  lv_disp_draw_buf_init(&this->draw_buf_, buffer, nullptr, buf_bytes);
+  this->disp_drv_.hor_res = width;
+  this->disp_drv_.ver_res = height;
+  // this->setup_driver_(display->get_width(), display->get_height());
+  lv_disp_drv_update(this->disp_, &this->disp_drv_);
+  this->rotation = display->get_rotation();
+  if (this->rotation != display::DISPLAY_ROTATION_0_DEGREES) {
+    this->rotate_buf_ = static_cast<lv_color_t *>(lv_custom_mem_alloc(this->draw_buf_.size));  // NOLINT
+    if (this->rotate_buf_ == nullptr) {
+      this->mark_failed();
+      this->status_set_error("Memory allocation failure");
+      return;
+    }
+  }
 #if LV_USE_LOG
   lv_log_register_print_cb([](const char *buf) {
     auto next = strchr(buf, ')');
@@ -458,8 +466,8 @@ void LvglComponent::setup() {
   });
 #endif
   // Rotation will be handled by our drawing function, so reset the display rotation.
-  for (auto *display : this->displays_)
-    display->set_rotation(display::DISPLAY_ROTATION_0_DEGREES);
+  for (auto *disp : this->displays_)
+    disp->set_rotation(display::DISPLAY_ROTATION_0_DEGREES);
   this->show_page(0, LV_SCR_LOAD_ANIM_NONE, 0);
   lv_disp_trig_activity(this->disp_);
   ESP_LOGCONFIG(TAG, "LVGL Setup complete");

esphome/components/lvgl/widgets/img.py

@@ -1,11 +1,9 @@
 import esphome.config_validation as cv
-from esphome.const import CONF_ANGLE, CONF_MODE
+from esphome.const import CONF_ANGLE, CONF_MODE, CONF_OFFSET_X, CONF_OFFSET_Y
 
 from ..defines import (
     CONF_ANTIALIAS,
     CONF_MAIN,
-    CONF_OFFSET_X,
-    CONF_OFFSET_Y,
     CONF_PIVOT_X,
     CONF_PIVOT_Y,
     CONF_SRC,

esphome/components/mcp2515/mcp2515.cpp

@@ -550,6 +550,7 @@ canbus::Error MCP2515::set_bitrate_(canbus::CanSpeed can_speed, CanClock can_clo
           cfg3 = MCP_16MHZ_40KBPS_CFG3;
           break;
         case (canbus::CAN_50KBPS):  //  50Kbps
+          cfg1 = MCP_16MHZ_50KBPS_CFG1;
           cfg2 = MCP_16MHZ_50KBPS_CFG2;
           cfg3 = MCP_16MHZ_50KBPS_CFG3;
           break;

esphome/components/mdns/__init__.py

@@ -91,7 +91,7 @@ async def to_code(config):
         add_idf_component(
             name="mdns",
             repo="https://github.com/espressif/esp-protocols.git",
-            ref="mdns-v1.5.1",
+            ref="mdns-v1.8.0",
             path="components/mdns",
         )
 

esphome/components/mixer/speaker/mixer_speaker.cpp

@@ -177,11 +177,15 @@ void SourceSpeaker::set_mute_state(bool mute_state) {
   this->parent_->get_output_speaker()->set_mute_state(mute_state);
 }
 
+bool SourceSpeaker::get_mute_state() { return this->parent_->get_output_speaker()->get_mute_state(); }
+
 void SourceSpeaker::set_volume(float volume) {
   this->volume_ = volume;
   this->parent_->get_output_speaker()->set_volume(volume);
 }
 
+float SourceSpeaker::get_volume() { return this->parent_->get_output_speaker()->get_volume(); }
+
 size_t SourceSpeaker::process_data_from_source(TickType_t ticks_to_wait) {
   if (!this->transfer_buffer_.use_count()) {
     return 0;
@@ -490,7 +494,8 @@ void MixerSpeaker::audio_mixer_task(void *params) {
       break;
     }
 
-    output_transfer_buffer->transfer_data_to_sink(pdMS_TO_TICKS(TASK_DELAY_MS));
+    // Never shift the data in the output transfer buffer to avoid unnecessary, slow data moves
+    output_transfer_buffer->transfer_data_to_sink(pdMS_TO_TICKS(TASK_DELAY_MS), false);
 
     const uint32_t output_frames_free =
         this_mixer->audio_stream_info_.value().bytes_to_frames(output_transfer_buffer->free());

esphome/components/mixer/speaker/mixer_speaker.h

@@ -53,9 +53,11 @@ class SourceSpeaker : public speaker::Speaker, public Component {
 
   /// @brief Mute state changes are passed to the parent's output speaker
   void set_mute_state(bool mute_state) override;
+  bool get_mute_state() override;
 
   /// @brief Volume state changes are passed to the parent's output speaker
   void set_volume(float volume) override;
+  float get_volume() override;
 
   void set_pause_state(bool pause_state) override { this->pause_state_ = pause_state; }
   bool get_pause_state() const override { return this->pause_state_; }

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() {