esphome 2024.10.3__py3-none-any.whl → 2024.11.0__py3-none-any.whl

esphome/components/lvgl/widgets/dropdown.py

@@ -1,4 +1,3 @@
-import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_OPTIONS
 
@@ -9,21 +8,24 @@ from ..defines import (
     CONF_SCROLLBAR,
     CONF_SELECTED,
     CONF_SELECTED_INDEX,
+    CONF_SELECTED_TEXT,
     CONF_SYMBOL,
     DIRECTIONS,
     literal,
 )
+from ..helpers import lvgl_components_required
 from ..lv_validation import lv_int, lv_text, option_string
-from ..lvcode import LocalVariable, lv, lv_expr
+from ..lvcode import LocalVariable, lv, lv_add, lv_expr
 from ..schemas import part_schema
-from ..types import LvSelect, LvType, lv_obj_t
+from ..types import LvCompound, LvSelect, LvType, lv_obj_t
 from . import Widget, WidgetType, set_obj_properties
 from .label import CONF_LABEL
 
 CONF_DROPDOWN = "dropdown"
 CONF_DROPDOWN_LIST = "dropdown_list"
 
-lv_dropdown_t = LvSelect("lv_dropdown_t")
+lv_dropdown_t = LvSelect("LvDropdownType", parents=(LvCompound,))
+
 lv_dropdown_list_t = LvType("lv_dropdown_list_t")
 dropdown_list_spec = WidgetType(
     CONF_DROPDOWN_LIST, lv_dropdown_list_t, (CONF_MAIN, CONF_SELECTED, CONF_SCROLLBAR)
@@ -32,7 +34,8 @@ dropdown_list_spec = WidgetType(
 DROPDOWN_BASE_SCHEMA = cv.Schema(
     {
         cv.Optional(CONF_SYMBOL): lv_text,
-        cv.Optional(CONF_SELECTED_INDEX): cv.templatable(cv.int_),
+        cv.Exclusive(CONF_SELECTED_INDEX, CONF_SELECTED_TEXT): lv_int,
+        cv.Exclusive(CONF_SELECTED_TEXT, CONF_SELECTED_TEXT): lv_text,
         cv.Optional(CONF_DIR, default="BOTTOM"): DIRECTIONS.one_of,
         cv.Optional(CONF_DROPDOWN_LIST): part_schema(dropdown_list_spec),
     }
@@ -44,6 +47,12 @@ DROPDOWN_SCHEMA = DROPDOWN_BASE_SCHEMA.extend(
     }
 )
 
+DROPDOWN_UPDATE_SCHEMA = DROPDOWN_BASE_SCHEMA.extend(
+    {
+        cv.Optional(CONF_OPTIONS): cv.ensure_list(option_string),
+    }
+)
+
 
 class DropdownType(WidgetType):
     def __init__(self):
@@ -52,18 +61,21 @@ class DropdownType(WidgetType):
             lv_dropdown_t,
             (CONF_MAIN, CONF_INDICATOR),
             DROPDOWN_SCHEMA,
-            DROPDOWN_BASE_SCHEMA,
+            modify_schema=DROPDOWN_UPDATE_SCHEMA,
         )
 
     async def to_code(self, w: Widget, config):
+        lvgl_components_required.add(CONF_DROPDOWN)
         if options := config.get(CONF_OPTIONS):
-            text = cg.safe_exp("\n".join(options))
-            lv.dropdown_set_options(w.obj, text)
+            lv_add(w.var.set_options(options))
         if symbol := config.get(CONF_SYMBOL):
-            lv.dropdown_set_symbol(w.obj, await lv_text.process(symbol))
+            lv.dropdown_set_symbol(w.var.obj, await lv_text.process(symbol))
         if (selected := config.get(CONF_SELECTED_INDEX)) is not None:
             value = await lv_int.process(selected)
-            lv.dropdown_set_selected(w.obj, value)
+            lv_add(w.var.set_selected_index(value, literal("LV_ANIM_OFF")))
+        if (selected := config.get(CONF_SELECTED_TEXT)) is not None:
+            value = await lv_text.process(selected)
+            lv_add(w.var.set_selected_text(value, literal("LV_ANIM_OFF")))
         if dirn := config.get(CONF_DIR):
             lv.dropdown_set_dir(w.obj, literal(dirn))
         if dlist := config.get(CONF_DROPDOWN_LIST):

esphome/components/lvgl/widgets/msgbox.py

@@ -20,6 +20,7 @@ from ..lvcode import (
     EVENT_ARG,
     LambdaContext,
     LocalVariable,
+    lv,
     lv_add,
     lv_assign,
     lv_expr,
@@ -27,7 +28,6 @@ from ..lvcode import (
     lv_Pvariable,
 )
 from ..schemas import STYLE_SCHEMA, STYLED_TEXT_SCHEMA, container_schema, part_schema
-from ..styles import TOP_LAYER
 from ..types import LV_EVENT, char_ptr, lv_obj_t
 from . import Widget, set_obj_properties
 from .button import button_spec
@@ -59,7 +59,7 @@ MSGBOX_SCHEMA = container_schema(
 )
 
 
-async def msgbox_to_code(conf):
+async def msgbox_to_code(top_layer, conf):
     """
     Construct a message box. This consists of a full-screen translucent background enclosing a centered container
     with an optional title, body, close button and a button matrix. And any other widgets the user cares to add
@@ -101,7 +101,7 @@ async def msgbox_to_code(conf):
     text = await lv_text.process(conf[CONF_BODY].get(CONF_TEXT, ""))
     title = await lv_text.process(conf[CONF_TITLE].get(CONF_TEXT, ""))
     close_button = conf[CONF_CLOSE_BUTTON]
-    lv_assign(outer, lv_expr.obj_create(TOP_LAYER))
+    lv_assign(outer, lv_expr.obj_create(top_layer))
     lv_obj.set_width(outer, lv_pct(100))
     lv_obj.set_height(outer, lv_pct(100))
     lv_obj.set_style_bg_opa(outer, 128, 0)
@@ -141,6 +141,7 @@ async def msgbox_to_code(conf):
         set_btn_data(buttonmatrix.obj, ctrl_list, width_list)
 
 
-async def msgboxes_to_code(config):
+async def msgboxes_to_code(lv_component, config):
+    top_layer = lv.disp_get_layer_top(lv_component.get_disp())
     for conf in config.get(CONF_MSGBOXES, ()):
-        await msgbox_to_code(conf)
+        await msgbox_to_code(top_layer, conf)

esphome/components/lvgl/widgets/obj.py

@@ -1,7 +1,7 @@
 from esphome import automation
 
 from ..automation import update_to_code
-from ..defines import CONF_MAIN, CONF_OBJ
+from ..defines import CONF_MAIN, CONF_OBJ, CONF_SCROLLBAR
 from ..schemas import create_modify_schema
 from ..types import ObjUpdateAction, WidgetType, lv_obj_t
 
@@ -12,7 +12,9 @@ class ObjType(WidgetType):
     """
 
     def __init__(self):
-        super().__init__(CONF_OBJ, lv_obj_t, (CONF_MAIN,), schema={}, modify_schema={})
+        super().__init__(
+            CONF_OBJ, lv_obj_t, (CONF_MAIN, CONF_SCROLLBAR), schema={}, modify_schema={}
+        )
 
     async def to_code(self, w, config):
         return []

esphome/components/lvgl/widgets/page.py

@@ -20,6 +20,7 @@ from ..lvcode import (
     add_line_marks,
     lv_add,
     lvgl_comp,
+    lvgl_static,
 )
 from ..schemas import LVGL_SCHEMA
 from ..types import LvglAction, lv_page_t
@@ -139,7 +140,7 @@ async def add_pages(lv_component, config):
         await add_widgets(page, pconf)
 
 
-async def generate_page_triggers(lv_component, config):
+async def generate_page_triggers(config):
     for pconf in config.get(CONF_PAGES, ()):
         page = (await get_widgets(pconf))[0]
         for ev in (CONF_ON_LOAD, CONF_ON_UNLOAD):
@@ -149,7 +150,7 @@ async def generate_page_triggers(lv_component, config):
                 async with LambdaContext(EVENT_ARG, where=id) as context:
                     lv_add(trigger.trigger())
                 lv_add(
-                    lv_component.add_event_cb(
+                    lvgl_static.add_event_cb(
                         page.obj,
                         await context.get_lambda(),
                         literal(f"LV_EVENT_SCREEN_{ev[3:].upper()}_START"),

esphome/components/lvgl/widgets/qrcode.py

@@ -0,0 +1,54 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.const import CONF_SIZE, CONF_TEXT
+from esphome.cpp_generator import MockObjClass
+
+from ..defines import CONF_MAIN, literal
+from ..lv_validation import color, color_retmapper, lv_text
+from ..lvcode import LocalVariable, lv, lv_expr
+from ..schemas import TEXT_SCHEMA
+from ..types import WidgetType, lv_obj_t
+from . import Widget
+
+CONF_QRCODE = "qrcode"
+CONF_DARK_COLOR = "dark_color"
+CONF_LIGHT_COLOR = "light_color"
+
+QRCODE_SCHEMA = TEXT_SCHEMA.extend(
+    {
+        cv.Optional(CONF_DARK_COLOR, default="black"): color,
+        cv.Optional(CONF_LIGHT_COLOR, default="white"): color,
+        cv.Required(CONF_SIZE): cv.int_,
+    }
+)
+
+
+class QrCodeType(WidgetType):
+    def __init__(self):
+        super().__init__(
+            CONF_QRCODE,
+            lv_obj_t,
+            (CONF_MAIN,),
+            QRCODE_SCHEMA,
+            modify_schema=TEXT_SCHEMA,
+        )
+
+    def get_uses(self):
+        return ("canvas", "img")
+
+    def obj_creator(self, parent: MockObjClass, config: dict):
+        dark_color = color_retmapper(config[CONF_DARK_COLOR])
+        light_color = color_retmapper(config[CONF_LIGHT_COLOR])
+        size = config[CONF_SIZE]
+        return lv_expr.call("qrcode_create", parent, size, dark_color, light_color)
+
+    async def to_code(self, w: Widget, config):
+        if (value := config.get(CONF_TEXT)) is not None:
+            value = await lv_text.process(value)
+            with LocalVariable(
+                "qr_text", cg.const_char_ptr, value, modifier=""
+            ) as str_obj:
+                lv.qrcode_update(w.obj, str_obj, literal(f"strlen({str_obj})"))
+
+
+qr_code_spec = QrCodeType()

esphome/components/lvgl/widgets/roller.py

@@ -1,4 +1,3 @@
-import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_MODE, CONF_OPTIONS
 
@@ -7,36 +6,40 @@ from ..defines import (
     CONF_MAIN,
     CONF_SELECTED,
     CONF_SELECTED_INDEX,
+    CONF_SELECTED_TEXT,
     CONF_VISIBLE_ROW_COUNT,
     ROLLER_MODES,
     literal,
 )
-from ..lv_validation import animated, lv_int, option_string
-from ..lvcode import lv
+from ..helpers import lvgl_components_required
+from ..lv_validation import animated, lv_int, lv_text, option_string
+from ..lvcode import lv_add
 from ..types import LvSelect
 from . import WidgetType
 from .label import CONF_LABEL
 
 CONF_ROLLER = "roller"
-lv_roller_t = LvSelect("lv_roller_t")
+lv_roller_t = LvSelect("LvRollerType")
 
 ROLLER_BASE_SCHEMA = cv.Schema(
     {
-        cv.Optional(CONF_SELECTED_INDEX): cv.templatable(cv.int_),
+        cv.Exclusive(CONF_SELECTED_INDEX, CONF_SELECTED_TEXT): lv_int,
+        cv.Exclusive(CONF_SELECTED_TEXT, CONF_SELECTED_TEXT): lv_text,
         cv.Optional(CONF_VISIBLE_ROW_COUNT): lv_int,
+        cv.Optional(CONF_MODE): ROLLER_MODES.one_of,
     }
 )
 
 ROLLER_SCHEMA = ROLLER_BASE_SCHEMA.extend(
     {
         cv.Required(CONF_OPTIONS): cv.ensure_list(option_string),
-        cv.Optional(CONF_MODE, default="NORMAL"): ROLLER_MODES.one_of,
     }
 )
 
 ROLLER_MODIFY_SCHEMA = ROLLER_BASE_SCHEMA.extend(
     {
         cv.Optional(CONF_ANIMATED, default=True): animated,
+        cv.Optional(CONF_OPTIONS): cv.ensure_list(option_string),
     }
 )
 
@@ -52,15 +55,19 @@ class RollerType(WidgetType):
         )
 
     async def to_code(self, w, config):
+        lvgl_components_required.add(CONF_ROLLER)
+        if mode := config.get(CONF_MODE):
+            mode = await ROLLER_MODES.process(mode)
+            lv_add(w.var.set_mode(mode))
         if options := config.get(CONF_OPTIONS):
-            mode = await ROLLER_MODES.process(config[CONF_MODE])
-            text = cg.safe_exp("\n".join(options))
-            lv.roller_set_options(w.obj, text, mode)
-        animopt = literal(config.get(CONF_ANIMATED) or "LV_ANIM_OFF")
-        if CONF_SELECTED_INDEX in config:
-            if selected := config[CONF_SELECTED_INDEX]:
-                value = await lv_int.process(selected)
-                lv.roller_set_selected(w.obj, value, animopt)
+            lv_add(w.var.set_options(options))
+        animopt = literal(config.get(CONF_ANIMATED, "LV_ANIM_OFF"))
+        if (selected := config.get(CONF_SELECTED_INDEX)) is not None:
+            value = await lv_int.process(selected)
+            lv_add(w.var.set_selected_index(value, animopt))
+        if (selected := config.get(CONF_SELECTED_TEXT)) is not None:
+            value = await lv_text.process(selected)
+            lv_add(w.var.set_selected_text(value, animopt))
         await w.set_property(
             CONF_VISIBLE_ROW_COUNT,
             await lv_int.process(config.get(CONF_VISIBLE_ROW_COUNT)),

esphome/components/lvgl/widgets/tileview.py

@@ -9,6 +9,7 @@ from ..defines import (
     CONF_COLUMN,
     CONF_DIR,
     CONF_MAIN,
+    CONF_SCROLLBAR,
     CONF_TILE_ID,
     CONF_TILES,
     TILE_DIRECTIONS,
@@ -56,7 +57,7 @@ class TileviewType(WidgetType):
         super().__init__(
             CONF_TILEVIEW,
             lv_tileview_t,
-            (CONF_MAIN,),
+            (CONF_MAIN, CONF_SCROLLBAR),
             schema=TILEVIEW_SCHEMA,
             modify_schema={},
         )

esphome/components/max17043/__init__.py

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

esphome/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/components/max17043/max17043.cpp

@@ -0,0 +1,98 @@
+#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...");
+
+  uint16_t config_reg;
+  if (this->write(&MAX17043_CONFIG, 1) != i2c::ERROR_OK) {
+    this->status_set_warning();
+    return;
+  }
+
+  if (this->read(reinterpret_cast<uint8_t *>(&config_reg), 2) != i2c::ERROR_OK) {
+    this->status_set_warning();
+    return;
+  }
+
+  config_reg = i2c::i2ctohs(config_reg) & MAX17043_CONFIG_SAFE_MASK;
+  ESP_LOGV(TAG, "MAX17043 CONFIG register reads 0x%X", config_reg);
+
+  if (config_reg != MAX17043_CONFIG_POWER_UP_DEFAULT) {
+    ESP_LOGE(TAG, "Device does not appear to be a MAX17043");
+    this->status_set_error("unrecognised");
+    this->mark_failed();
+    return;
+  }
+
+  // need to write back to config register to reset the sleep bit
+  if (!this->write_byte_16(MAX17043_CONFIG, MAX17043_CONFIG_POWER_UP_DEFAULT)) {
+    this->status_set_error("sleep reset failed");
+    this->mark_failed();
+    return;
+  }
+}
+
+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/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/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/components/media_player/__init__.py

@@ -21,6 +21,7 @@ media_player_ns = cg.esphome_ns.namespace("media_player")
 
 MediaPlayer = media_player_ns.class_("MediaPlayer")
 
+
 PlayAction = media_player_ns.class_(
     "PlayAction", automation.Action, cg.Parented.template(MediaPlayer)
 )
@@ -60,7 +61,11 @@ AnnoucementTrigger = media_player_ns.class_(
     "AnnouncementTrigger", automation.Trigger.template()
 )
 IsIdleCondition = media_player_ns.class_("IsIdleCondition", automation.Condition)
+IsPausedCondition = media_player_ns.class_("IsPausedCondition", automation.Condition)
 IsPlayingCondition = media_player_ns.class_("IsPlayingCondition", automation.Condition)
+IsAnnouncingCondition = media_player_ns.class_(
+    "IsAnnouncingCondition", automation.Condition
+)
 
 
 async def setup_media_player_core_(var, config):
@@ -159,9 +164,15 @@ async def media_player_play_media_action(config, action_id, template_arg, args):
 @automation.register_condition(
     "media_player.is_idle", IsIdleCondition, MEDIA_PLAYER_ACTION_SCHEMA
 )
+@automation.register_condition(
+    "media_player.is_paused", IsPausedCondition, MEDIA_PLAYER_ACTION_SCHEMA
+)
 @automation.register_condition(
     "media_player.is_playing", IsPlayingCondition, MEDIA_PLAYER_ACTION_SCHEMA
 )
+@automation.register_condition(
+    "media_player.is_announcing", IsAnnouncingCondition, MEDIA_PLAYER_ACTION_SCHEMA
+)
 async def media_player_action(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])

esphome/components/media_player/automation.h

@@ -68,5 +68,15 @@ template<typename... Ts> class IsPlayingCondition : public Condition<Ts...>, pub
   bool check(Ts... x) override { return this->parent_->state == MediaPlayerState::MEDIA_PLAYER_STATE_PLAYING; }
 };
 
+template<typename... Ts> class IsPausedCondition : public Condition<Ts...>, public Parented<MediaPlayer> {
+ public:
+  bool check(Ts... x) override { return this->parent_->state == MediaPlayerState::MEDIA_PLAYER_STATE_PAUSED; }
+};
+
+template<typename... Ts> class IsAnnouncingCondition : public Condition<Ts...>, public Parented<MediaPlayer> {
+ public:
+  bool check(Ts... x) override { return this->parent_->state == MediaPlayerState::MEDIA_PLAYER_STATE_ANNOUNCING; }
+};
+
 }  // namespace media_player
 }  // namespace esphome

esphome/components/media_player/media_player.cpp

@@ -37,6 +37,10 @@ const char *media_player_command_to_string(MediaPlayerCommand command) {
       return "UNMUTE";
     case MEDIA_PLAYER_COMMAND_TOGGLE:
       return "TOGGLE";
+    case MEDIA_PLAYER_COMMAND_VOLUME_UP:
+      return "VOLUME_UP";
+    case MEDIA_PLAYER_COMMAND_VOLUME_DOWN:
+      return "VOLUME_DOWN";
     default:
       return "UNKNOWN";
   }

esphome/components/midea/air_conditioner.cpp

@@ -3,6 +3,8 @@
 #include "esphome/core/log.h"
 #include "air_conditioner.h"
 #include "ac_adapter.h"
+#include <cmath>
+#include <cstdint>
 
 namespace esphome {
 namespace midea {
@@ -121,7 +123,21 @@ void AirConditioner::dump_config() {
 
 void AirConditioner::do_follow_me(float temperature, bool beeper) {
 #ifdef USE_REMOTE_TRANSMITTER
-  IrFollowMeData data(static_cast<uint8_t>(lroundf(temperature)), beeper);
+  // Check if temperature is finite (not NaN or infinite)
+  if (!std::isfinite(temperature)) {
+    ESP_LOGW(Constants::TAG, "Follow me action requires a finite temperature, got: %f", temperature);
+    return;
+  }
+
+  // Round and convert temperature to long, then clamp and convert it to uint8_t
+  uint8_t temp_uint8 =
+      static_cast<uint8_t>(std::max(0L, std::min(static_cast<long>(UINT8_MAX), std::lroundf(temperature))));
+
+  ESP_LOGD(Constants::TAG, "Follow me action called with temperature: %f °C, rounded to: %u °C", temperature,
+           temp_uint8);
+
+  // Create and transmit the data
+  IrFollowMeData data(temp_uint8, beeper);
   this->transmitter_.transmit(data);
 #else
   ESP_LOGW(Constants::TAG, "Action needs remote_transmitter component");

esphome/components/mlx90393/sensor.py

@@ -132,4 +132,4 @@ async def to_code(config):
         pin = await cg.gpio_pin_expression(config[CONF_DRDY_PIN])
         cg.add(var.set_drdy_gpio(pin))
 
-    cg.add_library("functionpointer/arduino-MLX90393", "1.0.0")
+    cg.add_library("functionpointer/arduino-MLX90393", "1.0.2")