Merge pull request #5077 from esphome/bump-2023.6.5

2023.6.5

esphome/components/binary_sensor/__init__.py

@@ -323,6 +323,18 @@ def validate_multi_click_timing(value):
 validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 
 
+def validate_click_timing(value):
+    for v in value:
+        min_length = v.get(CONF_MIN_LENGTH)
+        max_length = v.get(CONF_MAX_LENGTH)
+        if max_length < min_length:
+            raise cv.Invalid(
+                f"Max length ({max_length}) must be larger than min length ({min_length})."
+            )
+
+    return value
+
+
 BINARY_SENSOR_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMPONENT_SCHEMA).extend(
     {
         cv.GenerateID(): cv.declare_id(BinarySensor),
@@ -342,7 +354,8 @@ BINARY_SENSOR_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMPONENT_SCHEMA).ex
                 cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ReleaseTrigger),
             }
         ),
-        cv.Optional(CONF_ON_CLICK): automation.validate_automation(
+        cv.Optional(CONF_ON_CLICK): cv.All(
+            automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ClickTrigger),
                     cv.Optional(
@@ -353,7 +366,10 @@ BINARY_SENSOR_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMPONENT_SCHEMA).ex
                     ): cv.positive_time_period_milliseconds,
                 }
             ),
-        cv.Optional(CONF_ON_DOUBLE_CLICK): automation.validate_automation(
+            validate_click_timing,
+        ),
+        cv.Optional(CONF_ON_DOUBLE_CLICK): cv.All(
+            automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(DoubleClickTrigger),
                     cv.Optional(
@@ -364,6 +380,8 @@ BINARY_SENSOR_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMPONENT_SCHEMA).ex
                     ): cv.positive_time_period_milliseconds,
                 }
             ),
+            validate_click_timing,
+        ),
         cv.Optional(CONF_ON_MULTI_CLICK): automation.validate_automation(
             {
                 cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MultiClickTrigger),

esphome/components/bluetooth_proxy/bluetooth_connection.cpp

@@ -275,6 +275,10 @@ esp_err_t BluetoothConnection::notify_characteristic(uint16_t handle, bool enabl
   return ESP_OK;
 }
 
+esp32_ble_tracker::AdvertisementParserType BluetoothConnection::get_advertisement_parser_type() {
+  return this->proxy_->get_advertisement_parser_type();
+}
+
 }  // namespace bluetooth_proxy
 }  // namespace esphome
 

esphome/components/bluetooth_proxy/bluetooth_connection.h

@@ -14,6 +14,7 @@ class BluetoothConnection : public esp32_ble_client::BLEClientBase {
   bool gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                            esp_ble_gattc_cb_param_t *param) override;
   void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) override;
+  esp32_ble_tracker::AdvertisementParserType get_advertisement_parser_type() override;
 
   esp_err_t read_characteristic(uint16_t handle);
   esp_err_t write_characteristic(uint16_t handle, const std::string &data, bool response);

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -198,6 +198,12 @@ void BluetoothProxy::loop() {
   }
 }
 
+esp32_ble_tracker::AdvertisementParserType BluetoothProxy::get_advertisement_parser_type() {
+  if (this->raw_advertisements_)
+    return esp32_ble_tracker::AdvertisementParserType::RAW_ADVERTISEMENTS;
+  return esp32_ble_tracker::AdvertisementParserType::PARSED_ADVERTISEMENTS;
+}
+
 BluetoothConnection *BluetoothProxy::get_connection_(uint64_t address, bool reserve) {
   for (auto *connection : this->connections_) {
     if (connection->get_address() == address)
@@ -435,6 +441,7 @@ void BluetoothProxy::subscribe_api_connection(api::APIConnection *api_connection
   }
   this->api_connection_ = api_connection;
   this->raw_advertisements_ = flags & BluetoothProxySubscriptionFlag::SUBSCRIPTION_RAW_ADVERTISEMENTS;
+  this->parent_->recalculate_advertisement_parser_types();
 }
 
 void BluetoothProxy::unsubscribe_api_connection(api::APIConnection *api_connection) {
@@ -444,6 +451,7 @@ void BluetoothProxy::unsubscribe_api_connection(api::APIConnection *api_connecti
   }
   this->api_connection_ = nullptr;
   this->raw_advertisements_ = false;
+  this->parent_->recalculate_advertisement_parser_types();
 }
 
 void BluetoothProxy::send_device_connection(uint64_t address, bool connected, uint16_t mtu, esp_err_t error) {

esphome/components/bluetooth_proxy/bluetooth_proxy.h

@@ -51,6 +51,7 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
   bool parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, size_t count) override;
   void dump_config() override;
   void loop() override;
+  esp32_ble_tracker::AdvertisementParserType get_advertisement_parser_type() override;
 
   void register_connection(BluetoothConnection *connection) {
     this->connections_.push_back(connection);

esphome/components/button/__init__.py

@@ -12,6 +12,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_MQTT_ID,
     DEVICE_CLASS_EMPTY,
+    DEVICE_CLASS_IDENTIFY,
     DEVICE_CLASS_RESTART,
     DEVICE_CLASS_UPDATE,
 )
@@ -24,6 +25,7 @@ IS_PLATFORM_COMPONENT = True
 
 DEVICE_CLASSES = [
     DEVICE_CLASS_EMPTY,
+    DEVICE_CLASS_IDENTIFY,
     DEVICE_CLASS_RESTART,
     DEVICE_CLASS_UPDATE,
 ]

esphome/components/esp32_ble/__init__.py

@@ -55,3 +55,4 @@ async def to_code(config):
 
     if CORE.using_esp_idf:
         add_idf_sdkconfig_option("CONFIG_BT_ENABLED", True)
+        add_idf_sdkconfig_option("CONFIG_BT_BLE_42_FEATURES_SUPPORTED", True)

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -107,16 +107,16 @@ void ESP32BLETracker::loop() {
         ESP_LOGW(TAG, "Too many BLE events to process. Some devices may not show up.");
       }
 
-      bool bulk_parsed = false;
+      if (this->raw_advertisements_) {
-
         for (auto *listener : this->listeners_) {
-        bulk_parsed |= listener->parse_devices(this->scan_result_buffer_, this->scan_result_index_);
+          listener->parse_devices(this->scan_result_buffer_, this->scan_result_index_);
         }
         for (auto *client : this->clients_) {
-        bulk_parsed |= client->parse_devices(this->scan_result_buffer_, this->scan_result_index_);
+          client->parse_devices(this->scan_result_buffer_, this->scan_result_index_);
+        }
       }
 
-      if (!bulk_parsed) {
+      if (this->parse_advertisements_) {
         for (size_t i = 0; i < index; i++) {
           ESPBTDevice device;
           device.parse_scan_rst(this->scan_result_buffer_[i]);
@@ -284,6 +284,32 @@ void ESP32BLETracker::end_of_scan_() {
 void ESP32BLETracker::register_client(ESPBTClient *client) {
   client->app_id = ++this->app_id_;
   this->clients_.push_back(client);
+  this->recalculate_advertisement_parser_types();
+}
+
+void ESP32BLETracker::register_listener(ESPBTDeviceListener *listener) {
+  listener->set_parent(this);
+  this->listeners_.push_back(listener);
+  this->recalculate_advertisement_parser_types();
+}
+
+void ESP32BLETracker::recalculate_advertisement_parser_types() {
+  this->raw_advertisements_ = false;
+  this->parse_advertisements_ = false;
+  for (auto *listener : this->listeners_) {
+    if (listener->get_advertisement_parser_type() == AdvertisementParserType::PARSED_ADVERTISEMENTS) {
+      this->parse_advertisements_ = true;
+    } else {
+      this->raw_advertisements_ = true;
+    }
+  }
+  for (auto *client : this->clients_) {
+    if (client->get_advertisement_parser_type() == AdvertisementParserType::PARSED_ADVERTISEMENTS) {
+      this->parse_advertisements_ = true;
+    } else {
+      this->raw_advertisements_ = true;
+    }
+  }
 }
 
 void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -27,6 +27,11 @@ using namespace esp32_ble;
 
 using adv_data_t = std::vector<uint8_t>;
 
+enum AdvertisementParserType {
+  PARSED_ADVERTISEMENTS,
+  RAW_ADVERTISEMENTS,
+};
+
 struct ServiceData {
   ESPBTUUID uuid;
   adv_data_t data;
@@ -116,6 +121,9 @@ class ESPBTDeviceListener {
   virtual bool parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, size_t count) {
     return false;
   };
+  virtual AdvertisementParserType get_advertisement_parser_type() {
+    return AdvertisementParserType::PARSED_ADVERTISEMENTS;
+  };
   void set_parent(ESP32BLETracker *parent) { parent_ = parent; }
 
  protected:
@@ -184,12 +192,9 @@ class ESP32BLETracker : public Component, public GAPEventHandler, public GATTcEv
 
   void loop() override;
 
-  void register_listener(ESPBTDeviceListener *listener) {
+  void register_listener(ESPBTDeviceListener *listener);
-    listener->set_parent(this);
-    this->listeners_.push_back(listener);
-  }
-
   void register_client(ESPBTClient *client);
+  void recalculate_advertisement_parser_types();
 
   void print_bt_device_info(const ESPBTDevice &device);
 
@@ -231,6 +236,8 @@ class ESP32BLETracker : public Component, public GAPEventHandler, public GATTcEv
   bool scan_continuous_;
   bool scan_active_;
   bool scanner_idle_;
+  bool raw_advertisements_{false};
+  bool parse_advertisements_{false};
   SemaphoreHandle_t scan_result_lock_;
   SemaphoreHandle_t scan_end_lock_;
   size_t scan_result_index_{0};

esphome/components/mdns/mdns_component.cpp

@@ -57,6 +57,10 @@ void MDNSComponent::compile_records_() {
     service.txt_records.push_back({"network", "ethernet"});
 #endif
 
+#ifdef USE_API_NOISE
+    service.txt_records.push_back({"api_encryption", "Noise_NNpsk0_25519_ChaChaPoly_SHA256"});
+#endif
+
 #ifdef ESPHOME_PROJECT_NAME
     service.txt_records.push_back({"project_name", ESPHOME_PROJECT_NAME});
     service.txt_records.push_back({"project_version", ESPHOME_PROJECT_VERSION});

esphome/components/scd30/scd30.cpp

@@ -42,14 +42,19 @@ void SCD30Component::setup() {
   ESP_LOGD(TAG, "SCD30 Firmware v%0d.%02d", (uint16_t(raw_firmware_version[0]) >> 8),
            uint16_t(raw_firmware_version[0] & 0xFF));
 
-  if (this->temperature_offset_ != 0) {
+  uint16_t temp_offset;
-    if (!this->write_command(SCD30_CMD_TEMPERATURE_OFFSET, (uint16_t) (temperature_offset_ * 100.0))) {
+  if (this->temperature_offset_ > 0) {
+    temp_offset = (this->temperature_offset_ * 100);
+  } else {
+    temp_offset = 0;
+  }
+
+  if (!this->write_command(SCD30_CMD_TEMPERATURE_OFFSET, temp_offset)) {
     ESP_LOGE(TAG, "Sensor SCD30 error setting temperature offset.");
     this->error_code_ = MEASUREMENT_INIT_FAILED;
     this->mark_failed();
     return;
   }
-  }
 #ifdef USE_ESP32
   // According ESP32 clock stretching is typically 30ms and up to 150ms "due to
   // internal calibration processes". The I2C peripheral only supports 13ms (at

esphome/components/scd30/sensor.py

@@ -68,7 +68,10 @@ CONFIG_SCHEMA = (
                 cv.int_range(min=0, max=0xFFFF, max_included=False),
             ),
             cv.Optional(CONF_AMBIENT_PRESSURE_COMPENSATION, default=0): cv.pressure,
-            cv.Optional(CONF_TEMPERATURE_OFFSET): cv.temperature,
+            cv.Optional(CONF_TEMPERATURE_OFFSET): cv.All(
+                cv.temperature,
+                cv.float_range(min=0, max=655.35),
+            ),
             cv.Optional(CONF_UPDATE_INTERVAL, default="60s"): cv.All(
                 cv.positive_time_period_seconds,
                 cv.Range(

esphome/components/template/binary_sensor/template_binary_sensor.cpp

@@ -6,11 +6,21 @@ namespace template_ {
 
 static const char *const TAG = "template.binary_sensor";
 
-void TemplateBinarySensor::loop() {
+void TemplateBinarySensor::setup() {
-  if (!this->f_.has_value())
+  if (!this->publish_initial_state_)
     return;
 
-  auto s = (*this->f_)();
+  if (this->f_ != nullptr) {
+    this->publish_initial_state(*this->f_());
+  } else {
+    this->publish_initial_state(false);
+  }
+}
+void TemplateBinarySensor::loop() {
+  if (this->f_ == nullptr)
+    return;
+
+  auto s = this->f_();
   if (s.has_value()) {
     this->publish_state(*s);
   }

esphome/components/template/binary_sensor/template_binary_sensor.h

@@ -10,13 +10,14 @@ class TemplateBinarySensor : public Component, public binary_sensor::BinarySenso
  public:
   void set_template(std::function<optional<bool>()> &&f) { this->f_ = f; }
 
+  void setup() override;
   void loop() override;
   void dump_config() override;
 
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
  protected:
-  optional<std::function<optional<bool>()>> f_{};
+  std::function<optional<bool>()> f_{nullptr};
 };
 
 }  // namespace template_

esphome/config_validation.py

@@ -108,6 +108,7 @@ ROOT_CONFIG_PATH = object()
 
 RESERVED_IDS = [
     # C++ keywords http://en.cppreference.com/w/cpp/keyword
+    "alarm",
     "alignas",
     "alignof",
     "and",

esphome/const.py

@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2023.6.2"
+__version__ = "2023.6.5"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (
@@ -968,6 +968,7 @@ DEVICE_CLASS_GAS = "gas"
 DEVICE_CLASS_GATE = "gate"
 DEVICE_CLASS_HEAT = "heat"
 DEVICE_CLASS_HUMIDITY = "humidity"
+DEVICE_CLASS_IDENTIFY = "identify"
 DEVICE_CLASS_ILLUMINANCE = "illuminance"
 DEVICE_CLASS_IRRADIANCE = "irradiance"
 DEVICE_CLASS_LIGHT = "light"

esphome/dashboard/dashboard.py

@@ -546,22 +546,11 @@ class DownloadBinaryRequestHandler(BaseHandler):
             return
 
         with open(path, "rb") as f:
-            while True:
+            data = f.read()
-                # For a 528KB image used as benchmark:
-                #   - using 256KB blocks resulted in the smallest file size.
-                #   - blocks larger than 256KB didn't improve the size of compressed file.
-                #   - blocks smaller than 256KB hindered compression, making the output file larger.
-
-                # Read file in blocks of 256KB.
-                data = f.read(256 * 1024)
-
-                if not data:
-                    break
-
             if compressed:
                 data = gzip.compress(data, 9)
-
             self.write(data)
+
         self.finish()