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

esphome/components/modbus/modbus.cpp

@@ -15,23 +15,33 @@ void Modbus::setup() {
 void Modbus::loop() {
   const uint32_t now = millis();
 
-  if (now - this->last_modbus_byte_ > 50) {
-    this->rx_buffer_.clear();
-    this->last_modbus_byte_ = now;
-  }
-  // stop blocking new send commands after send_wait_time_ ms regardless if a response has been received since then
-  if (now - this->last_send_ > send_wait_time_) {
-    waiting_for_response = 0;
-  }
-
   while (this->available()) {
     uint8_t byte;
     this->read_byte(&byte);
     if (this->parse_modbus_byte_(byte)) {
       this->last_modbus_byte_ = now;
     } else {
+      size_t at = this->rx_buffer_.size();
+      if (at > 0) {
+        ESP_LOGV(TAG, "Clearing buffer of %d bytes - parse failed", at);
+        this->rx_buffer_.clear();
+      }
+    }
+  }
+
+  if (now - this->last_modbus_byte_ > 50) {
+    size_t at = this->rx_buffer_.size();
+    if (at > 0) {
+      ESP_LOGV(TAG, "Clearing buffer of %d bytes - timeout", at);
       this->rx_buffer_.clear();
     }
+
+    // stop blocking new send commands after sent_wait_time_ ms after response received
+    if (now - this->last_send_ > send_wait_time_) {
+      if (waiting_for_response > 0)
+        ESP_LOGV(TAG, "Stop waiting for response from %d", waiting_for_response);
+      waiting_for_response = 0;
+    }
   }
 }
 
@@ -39,7 +49,7 @@ bool Modbus::parse_modbus_byte_(uint8_t byte) {
   size_t at = this->rx_buffer_.size();
   this->rx_buffer_.push_back(byte);
   const uint8_t *raw = &this->rx_buffer_[0];
-  ESP_LOGV(TAG, "Modbus received Byte  %d (0X%x)", byte, byte);
+  ESP_LOGVV(TAG, "Modbus received Byte  %d (0X%x)", byte, byte);
   // Byte 0: modbus address (match all)
   if (at == 0)
     return true;
@@ -144,8 +154,10 @@ bool Modbus::parse_modbus_byte_(uint8_t byte) {
     ESP_LOGW(TAG, "Got Modbus frame from unknown address 0x%02X! ", address);
   }
 
-  // return false to reset buffer
-  return false;
+  // reset buffer
+  ESP_LOGV(TAG, "Clearing buffer of %d bytes - parse succeeded", at);
+  this->rx_buffer_.clear();
+  return true;
 }
 
 void Modbus::dump_config() {

esphome/components/modbus_controller/__init__.py

@@ -25,6 +25,8 @@ from .const import (
     CONF_MODBUS_CONTROLLER_ID,
     CONF_OFFLINE_SKIP_UPDATES,
     CONF_ON_COMMAND_SENT,
+    CONF_ON_ONLINE,
+    CONF_ON_OFFLINE,
     CONF_REGISTER_COUNT,
     CONF_REGISTER_TYPE,
     CONF_RESPONSE_SIZE,
@@ -114,6 +116,14 @@ ModbusCommandSentTrigger = modbus_controller_ns.class_(
     "ModbusCommandSentTrigger", automation.Trigger.template(cg.int_, cg.int_)
 )
 
+ModbusOnlineTrigger = modbus_controller_ns.class_(
+    "ModbusOnlineTrigger", automation.Trigger.template(cg.int_, cg.int_)
+)
+
+ModbusOfflineTrigger = modbus_controller_ns.class_(
+    "ModbusOfflineTrigger", automation.Trigger.template(cg.int_, cg.int_)
+)
+
 _LOGGER = logging.getLogger(__name__)
 
 ModbusServerRegisterSchema = cv.Schema(
@@ -146,6 +156,16 @@ CONFIG_SCHEMA = cv.All(
                     ),
                 }
             ),
+            cv.Optional(CONF_ON_ONLINE): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ModbusOnlineTrigger),
+                }
+            ),
+            cv.Optional(CONF_ON_OFFLINE): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ModbusOnlineTrigger),
+                }
+            ),
         }
     )
     .extend(cv.polling_component_schema("60s"))
@@ -284,7 +304,17 @@ async def to_code(config):
     for conf in config.get(CONF_ON_COMMAND_SENT, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(
-            trigger, [(int, "function_code"), (int, "address")], conf
+            trigger, [(cg.int_, "function_code"), (cg.int_, "address")], conf
+        )
+    for conf in config.get(CONF_ON_ONLINE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(
+            trigger, [(cg.int_, "function_code"), (cg.int_, "address")], conf
+        )
+    for conf in config.get(CONF_ON_OFFLINE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(
+            trigger, [(cg.int_, "function_code"), (cg.int_, "address")], conf
         )
 
 

esphome/components/modbus_controller/automation.h

@@ -15,5 +15,21 @@ class ModbusCommandSentTrigger : public Trigger<int, int> {
   }
 };
 
+class ModbusOnlineTrigger : public Trigger<int, int> {
+ public:
+  ModbusOnlineTrigger(ModbusController *a_modbuscontroller) {
+    a_modbuscontroller->add_on_online_callback(
+        [this](int function_code, int address) { this->trigger(function_code, address); });
+  }
+};
+
+class ModbusOfflineTrigger : public Trigger<int, int> {
+ public:
+  ModbusOfflineTrigger(ModbusController *a_modbuscontroller) {
+    a_modbuscontroller->add_on_offline_callback(
+        [this](int function_code, int address) { this->trigger(function_code, address); });
+  }
+};
+
 }  // namespace modbus_controller
 }  // namespace esphome

esphome/components/modbus_controller/const.py

@@ -9,6 +9,8 @@ CONF_MAX_CMD_RETRIES = "max_cmd_retries"
 CONF_MODBUS_CONTROLLER_ID = "modbus_controller_id"
 CONF_MODBUS_FUNCTIONCODE = "modbus_functioncode"
 CONF_ON_COMMAND_SENT = "on_command_sent"
+CONF_ON_ONLINE = "on_online"
+CONF_ON_OFFLINE = "on_offline"
 CONF_RAW_ENCODE = "raw_encode"
 CONF_REGISTER_COUNT = "register_count"
 CONF_REGISTER_TYPE = "register_type"

esphome/components/modbus_controller/modbus_controller.cpp

@@ -32,8 +32,10 @@ bool ModbusController::send_next_command_() {
             r.skip_updates_counter = this->offline_skip_updates_;
           }
         }
+
+        this->module_offline_ = true;
+        this->offline_callback_.call((int) command->function_code, command->register_address);
       }
-      this->module_offline_ = true;
       ESP_LOGD(TAG, "Modbus command to device=%d register=0x%02X no response received - removed from send queue",
                this->address_, command->register_address);
       this->command_queue_.pop_front();
@@ -68,8 +70,10 @@ void ModbusController::on_modbus_data(const std::vector<uint8_t> &data) {
           r.skip_updates_counter = 0;
         }
       }
+      // Restore module online state
+      this->module_offline_ = false;
+      this->online_callback_.call((int) current_command->function_code, current_command->register_address);
     }
-    this->module_offline_ = false;
 
     // Move the commandItem to the response queue
     current_command->payload = data;
@@ -670,5 +674,13 @@ void ModbusController::add_on_command_sent_callback(std::function<void(int, int)
   this->command_sent_callback_.add(std::move(callback));
 }
 
+void ModbusController::add_on_online_callback(std::function<void(int, int)> &&callback) {
+  this->online_callback_.add(std::move(callback));
+}
+
+void ModbusController::add_on_offline_callback(std::function<void(int, int)> &&callback) {
+  this->offline_callback_.add(std::move(callback));
+}
+
 }  // namespace modbus_controller
 }  // namespace esphome

esphome/components/modbus_controller/modbus_controller.h

@@ -468,6 +468,10 @@ class ModbusController : public PollingComponent, public modbus::ModbusDevice {
   bool get_module_offline() { return module_offline_; }
   /// Set callback for commands
   void add_on_command_sent_callback(std::function<void(int, int)> &&callback);
+  /// Set callback for online changes
+  void add_on_online_callback(std::function<void(int, int)> &&callback);
+  /// Set callback for offline changes
+  void add_on_offline_callback(std::function<void(int, int)> &&callback);
   /// called by esphome generated code to set the max_cmd_retries.
   void set_max_cmd_retries(uint8_t max_cmd_retries) { this->max_cmd_retries_ = max_cmd_retries; }
   /// get how many times a command will be (re)sent if no response is received
@@ -508,7 +512,12 @@ class ModbusController : public PollingComponent, public modbus::ModbusDevice {
   uint16_t offline_skip_updates_;
   /// How many times we will retry a command if we get no response
   uint8_t max_cmd_retries_{4};
+  /// Command sent callback
   CallbackManager<void(int, int)> command_sent_callback_{};
+  /// Server online callback
+  CallbackManager<void(int, int)> online_callback_{};
+  /// Server offline callback
+  CallbackManager<void(int, int)> offline_callback_{};
 };
 
 /** Convert vector<uint8_t> response payload to float.

esphome/components/mopeka_pro_check/mopeka_pro_check.cpp

@@ -17,6 +17,8 @@ void MopekaProCheck::dump_config() {
   LOG_SENSOR("  ", "Temperature", this->temperature_);
   LOG_SENSOR("  ", "Battery Level", this->battery_level_);
   LOG_SENSOR("  ", "Reading Distance", this->distance_);
+  LOG_SENSOR("  ", "Read Quality", this->read_quality_);
+  LOG_SENSOR("  ", "Ignored Reads", this->ignored_reads_);
 }
 
 /**
@@ -66,34 +68,49 @@ bool MopekaProCheck::parse_device(const esp32_ble_tracker::ESPBTDevice &device)
     this->battery_level_->publish_state(level);
   }
 
+  // Get the quality value
+  SensorReadQuality quality_value = this->parse_read_quality_(manu_data.data);
+  if (this->read_quality_ != nullptr) {
+    this->read_quality_->publish_state(static_cast<int>(quality_value));
+  }
+
+  // Determine if we have a good enough quality of read to report level and distance
+  // sensors.  This sensor is reported regardless of distance or level sensors being enabled
+  if (quality_value < this->min_signal_quality_) {
+    ESP_LOGW(TAG, "Read Quality too low to report distance or level");
+    this->ignored_read_count_++;
+  } else {
+    // reset to zero since read quality was sufficient
+    this->ignored_read_count_ = 0;
+  }
+  // Report number of contiguous ignored reads if sensor defined
+  if (this->ignored_reads_ != nullptr) {
+    this->ignored_reads_->publish_state(this->ignored_read_count_);
+  }
+
   // Get distance and level if either are sensors
   if ((this->distance_ != nullptr) || (this->level_ != nullptr)) {
     uint32_t distance_value = this->parse_distance_(manu_data.data);
-    SensorReadQuality quality_value = this->parse_read_quality_(manu_data.data);
     ESP_LOGD(TAG, "Distance Sensor: Quality (0x%X) Distance (%" PRId32 "mm)", quality_value, distance_value);
-    if (quality_value < QUALITY_HIGH) {
-      ESP_LOGW(TAG, "Poor read quality.");
-    }
-    if (quality_value < QUALITY_MED) {
-      // if really bad reading set to 0
-      ESP_LOGW(TAG, "Setting distance to 0");
-      distance_value = 0;
-    }
 
-    // update distance sensor
-    if (this->distance_ != nullptr) {
-      this->distance_->publish_state(distance_value);
-    }
+    // only update distance and level sensors if read quality was sufficient.  This can be determined by
+    // if the ignored_read_count is zero.
+    if (this->ignored_read_count_ == 0) {
+      // update distance sensor
+      if (this->distance_ != nullptr) {
+        this->distance_->publish_state(distance_value);
+      }
 
-    // update level sensor
-    if (this->level_ != nullptr) {
-      uint8_t tank_level = 0;
-      if (distance_value >= this->full_mm_) {
-        tank_level = 100;  // cap at 100%
-      } else if (distance_value > this->empty_mm_) {
-        tank_level = ((100.0f / (this->full_mm_ - this->empty_mm_)) * (distance_value - this->empty_mm_));
+      // update level sensor
+      if (this->level_ != nullptr) {
+        uint8_t tank_level = 0;
+        if (distance_value >= this->full_mm_) {
+          tank_level = 100;  // cap at 100%
+        } else if (distance_value > this->empty_mm_) {
+          tank_level = ((100.0f / (this->full_mm_ - this->empty_mm_)) * (distance_value - this->empty_mm_));
+        }
+        this->level_->publish_state(tank_level);
       }
-      this->level_->publish_state(tank_level);
     }
   }
 
@@ -131,6 +148,8 @@ uint32_t MopekaProCheck::parse_distance_(const std::vector<uint8_t> &message) {
 uint8_t MopekaProCheck::parse_temperature_(const std::vector<uint8_t> &message) { return (message[2] & 0x7F) - 40; }
 
 SensorReadQuality MopekaProCheck::parse_read_quality_(const std::vector<uint8_t> &message) {
+  // Since a 8 bit value is being shifted and truncated to 2 bits all possible values are defined as enumeration
+  //  value and the static cast is safe.
   return static_cast<SensorReadQuality>(message[4] >> 6);
 }
 

esphome/components/mopeka_pro_check/mopeka_pro_check.h

@@ -24,9 +24,9 @@ enum SensorType {
 };
 
 // Sensor read quality.  If sensor is poorly placed or tank level
-// gets too low the read quality will show and the distanace
+// gets too low the read quality will show and the distance
 // measurement may be inaccurate.
-enum SensorReadQuality { QUALITY_HIGH = 0x3, QUALITY_MED = 0x2, QUALITY_LOW = 0x1, QUALITY_NONE = 0x0 };
+enum SensorReadQuality { QUALITY_HIGH = 0x3, QUALITY_MED = 0x2, QUALITY_LOW = 0x1, QUALITY_ZERO = 0x0 };
 
 class MopekaProCheck : public Component, public esp32_ble_tracker::ESPBTDeviceListener {
  public:
@@ -35,11 +35,14 @@ class MopekaProCheck : public Component, public esp32_ble_tracker::ESPBTDeviceLi
   bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::DATA; }
+  void set_min_signal_quality(SensorReadQuality min) { this->min_signal_quality_ = min; };
 
   void set_level(sensor::Sensor *level) { level_ = level; };
   void set_temperature(sensor::Sensor *temperature) { temperature_ = temperature; };
   void set_battery_level(sensor::Sensor *bat) { battery_level_ = bat; };
   void set_distance(sensor::Sensor *distance) { distance_ = distance; };
+  void set_signal_quality(sensor::Sensor *rq) { read_quality_ = rq; };
+  void set_ignored_reads(sensor::Sensor *ir) { ignored_reads_ = ir; };
   void set_tank_full(float full) { full_mm_ = full; };
   void set_tank_empty(float empty) { empty_mm_ = empty; };
 
@@ -49,9 +52,13 @@ class MopekaProCheck : public Component, public esp32_ble_tracker::ESPBTDeviceLi
   sensor::Sensor *temperature_{nullptr};
   sensor::Sensor *distance_{nullptr};
   sensor::Sensor *battery_level_{nullptr};
+  sensor::Sensor *read_quality_{nullptr};
+  sensor::Sensor *ignored_reads_{nullptr};
 
   uint32_t full_mm_;
   uint32_t empty_mm_;
+  uint32_t ignored_read_count_ = 0;
+  SensorReadQuality min_signal_quality_ = QUALITY_MED;
 
   uint8_t parse_battery_level_(const std::vector<uint8_t> &message);
   uint32_t parse_distance_(const std::vector<uint8_t> &message);

esphome/components/mopeka_pro_check/sensor.py

@@ -5,9 +5,12 @@ from esphome.const import (
     CONF_DISTANCE,
     CONF_MAC_ADDRESS,
     CONF_ID,
+    ICON_COUNTER,
     ICON_THERMOMETER,
     ICON_RULER,
+    ICON_SIGNAL,
     UNIT_PERCENT,
+    UNIT_EMPTY,
     CONF_LEVEL,
     CONF_TEMPERATURE,
     DEVICE_CLASS_TEMPERATURE,
@@ -16,11 +19,15 @@ from esphome.const import (
     STATE_CLASS_MEASUREMENT,
     CONF_BATTERY_LEVEL,
     DEVICE_CLASS_BATTERY,
+    ENTITY_CATEGORY_DIAGNOSTIC,
 )
 
 CONF_TANK_TYPE = "tank_type"
 CONF_CUSTOM_DISTANCE_FULL = "custom_distance_full"
 CONF_CUSTOM_DISTANCE_EMPTY = "custom_distance_empty"
+CONF_SIGNAL_QUALITY = "signal_quality"
+CONF_MINIMUM_SIGNAL_QUALITY = "minimum_signal_quality"
+CONF_IGNORED_READS = "ignored_reads"
 
 ICON_PROPANE_TANK = "mdi:propane-tank"
 
@@ -56,6 +63,14 @@ MopekaProCheck = mopeka_pro_check_ns.class_(
     "MopekaProCheck", esp32_ble_tracker.ESPBTDeviceListener, cg.Component
 )
 
+SensorReadQuality = mopeka_pro_check_ns.enum("SensorReadQuality")
+SIGNAL_QUALITIES = {
+    "ZERO": SensorReadQuality.QUALITY_ZERO,
+    "LOW": SensorReadQuality.QUALITY_LOW,
+    "MEDIUM": SensorReadQuality.QUALITY_MED,
+    "HIGH": SensorReadQuality.QUALITY_HIGH,
+}
+
 CONFIG_SCHEMA = (
     cv.Schema(
         {
@@ -89,6 +104,21 @@ CONFIG_SCHEMA = (
                 device_class=DEVICE_CLASS_BATTERY,
                 state_class=STATE_CLASS_MEASUREMENT,
             ),
+            cv.Optional(CONF_SIGNAL_QUALITY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_EMPTY,
+                icon=ICON_SIGNAL,
+                accuracy_decimals=0,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_IGNORED_READS): sensor.sensor_schema(
+                unit_of_measurement=UNIT_EMPTY,
+                icon=ICON_COUNTER,
+                accuracy_decimals=0,
+                entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            ),
+            cv.Optional(CONF_MINIMUM_SIGNAL_QUALITY, default="MEDIUM"): cv.enum(
+                SIGNAL_QUALITIES, upper=True
+            ),
         }
     )
     .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
@@ -119,6 +149,11 @@ async def to_code(config):
         cg.add(var.set_tank_empty(CONF_SUPPORTED_TANKS_MAP[t][0]))
         cg.add(var.set_tank_full(CONF_SUPPORTED_TANKS_MAP[t][1]))
 
+    if (
+        minimum_signal_quality := config.get(CONF_MINIMUM_SIGNAL_QUALITY, None)
+    ) is not None:
+        cg.add(var.set_min_signal_quality(minimum_signal_quality))
+
     if CONF_TEMPERATURE in config:
         sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
         cg.add(var.set_temperature(sens))
@@ -131,3 +166,9 @@ async def to_code(config):
     if CONF_BATTERY_LEVEL in config:
         sens = await sensor.new_sensor(config[CONF_BATTERY_LEVEL])
         cg.add(var.set_battery_level(sens))
+    if CONF_SIGNAL_QUALITY in config:
+        sens = await sensor.new_sensor(config[CONF_SIGNAL_QUALITY])
+        cg.add(var.set_signal_quality(sens))
+    if CONF_IGNORED_READS in config:
+        sens = await sensor.new_sensor(config[CONF_IGNORED_READS])
+        cg.add(var.set_ignored_reads(sens))

esphome/components/mqtt/__init__.py

@@ -22,6 +22,7 @@ from esphome.const import (
     CONF_DISCOVERY_PREFIX,
     CONF_DISCOVERY_RETAIN,
     CONF_DISCOVERY_UNIQUE_ID_GENERATOR,
+    CONF_ENABLE_ON_BOOT,
     CONF_ID,
     CONF_KEEPALIVE,
     CONF_LEVEL,
@@ -41,6 +42,7 @@ from esphome.const import (
     CONF_SHUTDOWN_MESSAGE,
     CONF_SSL_FINGERPRINTS,
     CONF_STATE_TOPIC,
+    CONF_SUBSCRIBE_QOS,
     CONF_TOPIC,
     CONF_TOPIC_PREFIX,
     CONF_TRIGGER_ID,
@@ -98,6 +100,8 @@ MQTTMessage = mqtt_ns.struct("MQTTMessage")
 MQTTClientComponent = mqtt_ns.class_("MQTTClientComponent", cg.Component)
 MQTTPublishAction = mqtt_ns.class_("MQTTPublishAction", automation.Action)
 MQTTPublishJsonAction = mqtt_ns.class_("MQTTPublishJsonAction", automation.Action)
+MQTTEnableAction = mqtt_ns.class_("MQTTEnableAction", automation.Action)
+MQTTDisableAction = mqtt_ns.class_("MQTTDisableAction", automation.Action)
 MQTTMessageTrigger = mqtt_ns.class_(
     "MQTTMessageTrigger", automation.Trigger.template(cg.std_string), cg.Component
 )
@@ -207,6 +211,7 @@ CONFIG_SCHEMA = cv.All(
         {
             cv.GenerateID(): cv.declare_id(MQTTClientComponent),
             cv.Required(CONF_BROKER): cv.string_strict,
+            cv.Optional(CONF_ENABLE_ON_BOOT, default=True): cv.boolean,
             cv.Optional(CONF_PORT, default=1883): cv.port,
             cv.Optional(CONF_USERNAME, default=""): cv.string,
             cv.Optional(CONF_PASSWORD, default=""): cv.string,
@@ -324,6 +329,7 @@ async def to_code(config):
     cg.add_global(mqtt_ns.using)
 
     cg.add(var.set_broker_address(config[CONF_BROKER]))
+    cg.add(var.set_enable_on_boot(config[CONF_ENABLE_ON_BOOT]))
     cg.add(var.set_broker_port(config[CONF_PORT]))
     cg.add(var.set_username(config[CONF_USERNAME]))
     cg.add(var.set_password(config[CONF_PASSWORD]))
@@ -518,6 +524,8 @@ async def register_mqtt_component(var, config):
         cg.add(var.set_qos(config[CONF_QOS]))
     if CONF_RETAIN in config:
         cg.add(var.set_retain(config[CONF_RETAIN]))
+    if CONF_SUBSCRIBE_QOS in config:
+        cg.add(var.set_subscribe_qos(config[CONF_SUBSCRIBE_QOS]))
     if not config.get(CONF_DISCOVERY, True):
         cg.add(var.disable_discovery())
     if CONF_STATE_TOPIC in config:
@@ -552,3 +560,31 @@ async def register_mqtt_component(var, config):
 async def mqtt_connected_to_code(config, condition_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     return cg.new_Pvariable(condition_id, template_arg, paren)
+
+
+@automation.register_action(
+    "mqtt.enable",
+    MQTTEnableAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(MQTTClientComponent),
+        }
+    ),
+)
+async def mqtt_enable_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)
+
+
+@automation.register_action(
+    "mqtt.disable",
+    MQTTDisableAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(MQTTClientComponent),
+        }
+    ),
+)
+async def mqtt_disable_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/mqtt/mqtt_client.cpp

@@ -50,6 +50,8 @@ void MQTTClientComponent::setup() {
         }
       });
   this->mqtt_backend_.set_on_disconnect([this](MQTTClientDisconnectReason reason) {
+    if (this->state_ == MQTT_CLIENT_DISABLED)
+      return;
     this->state_ = MQTT_CLIENT_DISCONNECTED;
     this->disconnect_reason_ = reason;
   });
@@ -77,8 +79,9 @@ void MQTTClientComponent::setup() {
         topic, [this](const std::string &topic, const std::string &payload) { this->send_device_info_(); }, 2);
   }
 
-  this->last_connected_ = millis();
-  this->start_dnslookup_();
+  if (this->enable_on_boot_) {
+    this->enable();
+  }
 }
 
 void MQTTClientComponent::send_device_info_() {
@@ -163,7 +166,9 @@ void MQTTClientComponent::dump_config() {
     ESP_LOGCONFIG(TAG, "  Availability: '%s'", this->availability_.topic.c_str());
   }
 }
-bool MQTTClientComponent::can_proceed() { return network::is_disabled() || this->is_connected(); }
+bool MQTTClientComponent::can_proceed() {
+  return network::is_disabled() || this->state_ == MQTT_CLIENT_DISABLED || this->is_connected();
+}
 
 void MQTTClientComponent::start_dnslookup_() {
   for (auto &subscription : this->subscriptions_) {
@@ -339,6 +344,8 @@ void MQTTClientComponent::loop() {
   const uint32_t now = millis();
 
   switch (this->state_) {
+    case MQTT_CLIENT_DISABLED:
+      return;  // Return to avoid a reboot when disabled
     case MQTT_CLIENT_DISCONNECTED:
       if (now - this->connect_begin_ > 5000) {
         this->start_dnslookup_();
@@ -501,6 +508,23 @@ bool MQTTClientComponent::publish_json(const std::string &topic, const json::jso
   return this->publish(topic, message, qos, retain);
 }
 
+void MQTTClientComponent::enable() {
+  if (this->state_ != MQTT_CLIENT_DISABLED)
+    return;
+  ESP_LOGD(TAG, "Enabling MQTT...");
+  this->state_ = MQTT_CLIENT_DISCONNECTED;
+  this->last_connected_ = millis();
+  this->start_dnslookup_();
+}
+
+void MQTTClientComponent::disable() {
+  if (this->state_ == MQTT_CLIENT_DISABLED)
+    return;
+  ESP_LOGD(TAG, "Disabling MQTT...");
+  this->state_ = MQTT_CLIENT_DISABLED;
+  this->on_shutdown();
+}
+
 /** Check if the message topic matches the given subscription topic
  *
  * INFO: MQTT spec mandates that topics must not be empty and must be valid NULL-terminated UTF-8 strings.

esphome/components/mqtt/mqtt_client.h

@@ -87,7 +87,8 @@ struct MQTTDiscoveryInfo {
 };
 
 enum MQTTClientState {
-  MQTT_CLIENT_DISCONNECTED = 0,
+  MQTT_CLIENT_DISABLED = 0,
+  MQTT_CLIENT_DISCONNECTED,
   MQTT_CLIENT_RESOLVING_ADDRESS,
   MQTT_CLIENT_CONNECTING,
   MQTT_CLIENT_CONNECTED,
@@ -247,6 +248,9 @@ class MQTTClientComponent : public Component {
   void register_mqtt_component(MQTTComponent *component);
 
   bool is_connected();
+  void set_enable_on_boot(bool enable_on_boot) { this->enable_on_boot_ = enable_on_boot; }
+  void enable();
+  void disable();
 
   void on_shutdown() override;
 
@@ -314,10 +318,11 @@ class MQTTClientComponent : public Component {
   MQTTBackendLibreTiny mqtt_backend_;
 #endif
 
-  MQTTClientState state_{MQTT_CLIENT_DISCONNECTED};
+  MQTTClientState state_{MQTT_CLIENT_DISABLED};
   network::IPAddress ip_;
   bool dns_resolved_{false};
   bool dns_resolve_error_{false};
+  bool enable_on_boot_{true};
   std::vector<MQTTComponent *> children_;
   uint32_t reboot_timeout_{300000};
   uint32_t connect_begin_;
@@ -414,6 +419,26 @@ template<typename... Ts> class MQTTConnectedCondition : public Condition<Ts...>
   MQTTClientComponent *parent_;
 };
 
+template<typename... Ts> class MQTTEnableAction : public Action<Ts...> {
+ public:
+  MQTTEnableAction(MQTTClientComponent *parent) : parent_(parent) {}
+
+  void play(Ts... x) override { this->parent_->enable(); }
+
+ protected:
+  MQTTClientComponent *parent_;
+};
+
+template<typename... Ts> class MQTTDisableAction : public Action<Ts...> {
+ public:
+  MQTTDisableAction(MQTTClientComponent *parent) : parent_(parent) {}
+
+  void play(Ts... x) override { this->parent_->disable(); }
+
+ protected:
+  MQTTClientComponent *parent_;
+};
+
 }  // namespace mqtt
 }  // namespace esphome
 

esphome/components/mqtt/mqtt_climate.cpp

@@ -71,8 +71,10 @@ void MQTTClimateComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryCo
   root[MQTT_MIN_TEMP] = traits.get_visual_min_temperature();
   // max_temp
   root[MQTT_MAX_TEMP] = traits.get_visual_max_temperature();
-  // temp_step
-  root["temp_step"] = traits.get_visual_target_temperature_step();
+  // target_temp_step
+  root[MQTT_TARGET_TEMPERATURE_STEP] = traits.get_visual_target_temperature_step();
+  // current_temp_step
+  root[MQTT_CURRENT_TEMPERATURE_STEP] = traits.get_visual_current_temperature_step();
   // temperature units are always coerced to Celsius internally
   root[MQTT_TEMPERATURE_UNIT] = "C";
 

esphome/components/mqtt/mqtt_component.cpp

@@ -16,6 +16,8 @@ static const char *const TAG = "mqtt.component";
 
 void MQTTComponent::set_qos(uint8_t qos) { this->qos_ = qos; }
 
+void MQTTComponent::set_subscribe_qos(uint8_t qos) { this->subscribe_qos_ = qos; }
+
 void MQTTComponent::set_retain(bool retain) { this->retain_ = retain; }
 
 std::string MQTTComponent::get_discovery_topic_(const MQTTDiscoveryInfo &discovery_info) const {
@@ -76,6 +78,10 @@ bool MQTTComponent::send_discovery_() {
         config.command_topic = true;
 
         this->send_discovery(root, config);
+        // Set subscription QoS (default is 0)
+        if (this->subscribe_qos_ != 0) {
+          root[MQTT_QOS] = this->subscribe_qos_;
+        }
 
         // Fields from EntityBase
         if (this->get_entity()->has_own_name()) {