esphome 2025.4.2__py3-none-any.whl → 2025.5.0__py3-none-any.whl

esphome/components/remote_base/beo4_protocol.cpp

@@ -0,0 +1,153 @@
+#include "beo4_protocol.h"
+#include "esphome/core/log.h"
+
+#include <cinttypes>
+
+namespace esphome {
+namespace remote_base {
+
+static const char *const TAG = "remote.beo4";
+
+// beo4 pulse width, high=carrier_pulse low=data_pulse
+constexpr uint16_t PW_CARR_US = 200;     // carrier pulse length
+constexpr uint16_t PW_ZERO_US = 2925;    // + 200 =  3125 µs
+constexpr uint16_t PW_SAME_US = 6050;    // + 200 =  6250 µs
+constexpr uint16_t PW_ONE_US = 9175;     // + 200 =  9375 µs
+constexpr uint16_t PW_STOP_US = 12300;   // + 200 = 12500 µs
+constexpr uint16_t PW_START_US = 15425;  // + 200 = 15625 µs
+
+// beo4 pulse codes
+constexpr uint8_t PC_ZERO = (PW_CARR_US + PW_ZERO_US) / 3125;    // =1
+constexpr uint8_t PC_SAME = (PW_CARR_US + PW_SAME_US) / 3125;    // =2
+constexpr uint8_t PC_ONE = (PW_CARR_US + PW_ONE_US) / 3125;      // =3
+constexpr uint8_t PC_STOP = (PW_CARR_US + PW_STOP_US) / 3125;    // =4
+constexpr uint8_t PC_START = (PW_CARR_US + PW_START_US) / 3125;  // =5
+
+// beo4 number of data bits = beoLink+beoSrc+beoCmd = 1+8+8 = 17
+constexpr uint32_t N_BITS = 1 + 8 + 8;
+
+// required symbols = 2*(start_sequence + n_bits + stop) = 2*(3+17+1) = 42
+constexpr uint32_t N_SYM = 2 + ((3 + 17 + 1) * 2u);  // + 2 = 44
+
+// states finite-state-machine decoder
+enum class RxSt { RX_IDLE, RX_DATA, RX_STOP };
+
+void Beo4Protocol::encode(RemoteTransmitData *dst, const Beo4Data &data) {
+  uint32_t beo_code = ((uint32_t) data.source << 8) + (uint32_t) data.command;
+  uint32_t jc = 0, ic = 0;
+  uint32_t cur_bit = 0;
+  uint32_t pre_bit = 0;
+  dst->set_carrier_frequency(455000);
+  dst->reserve(N_SYM);
+
+  // start sequence=zero,zero,start
+  dst->item(PW_CARR_US, PW_ZERO_US);
+  dst->item(PW_CARR_US, PW_ZERO_US);
+  dst->item(PW_CARR_US, PW_START_US);
+
+  // the data-bit BeoLink is always 0
+  dst->item(PW_CARR_US, PW_ZERO_US);
+
+  // The B&O trick to avoid extra long and extra short
+  // code-frames by extracting the data-bits from left
+  // to right, then comparing current with previous bit
+  // and set pulse to "same" "one" or "zero"
+  for (jc = 15, ic = 0; ic < 16; ic++, jc--) {
+    cur_bit = ((beo_code) >> jc) & 1;
+    if (cur_bit == pre_bit) {
+      dst->item(PW_CARR_US, PW_SAME_US);
+    } else if (1 == cur_bit) {
+      dst->item(PW_CARR_US, PW_ONE_US);
+    } else {
+      dst->item(PW_CARR_US, PW_ZERO_US);
+    }
+    pre_bit = cur_bit;
+  }
+  // complete the frame with stop-symbol and final carrier pulse
+  dst->item(PW_CARR_US, PW_STOP_US);
+  dst->mark(PW_CARR_US);
+}
+
+optional<Beo4Data> Beo4Protocol::decode(RemoteReceiveData src) {
+  int32_t n_sym = src.size();
+  Beo4Data data{
+      .source = 0,
+      .command = 0,
+      .repeats = 0,
+  };
+  // suppress dummy codes (TSO7000 hiccups)
+  if (n_sym > 42) {
+    static uint32_t beo_code = 0;
+    RxSt fsm = RxSt::RX_IDLE;
+    int32_t ic = 0;
+    int32_t jc = 0;
+    uint32_t pre_bit = 0;
+    uint32_t cnt_bit = 0;
+    ESP_LOGD(TAG, "Beo4: n_sym=%" PRId32, n_sym);
+    for (jc = 0, ic = 0; ic < (n_sym - 1); ic += 2, jc++) {
+      int32_t pulse_width = src[ic] - src[ic + 1];
+      // suppress TSOP7000 (dummy pulses)
+      if (pulse_width > 1500) {
+        int32_t pulse_code = (pulse_width + 1560) / 3125;
+        switch (fsm) {
+          case RxSt::RX_IDLE: {
+            beo_code = 0;
+            cnt_bit = 0;
+            pre_bit = 0;
+            if (PC_START == pulse_code) {
+              fsm = RxSt::RX_DATA;
+            }
+            break;
+          }
+          case RxSt::RX_DATA: {
+            uint32_t cur_bit = 0;
+            switch (pulse_code) {
+              case PC_ZERO: {
+                cur_bit = pre_bit = 0;
+                break;
+              }
+              case PC_SAME: {
+                cur_bit = pre_bit;
+                break;
+              }
+              case PC_ONE: {
+                cur_bit = pre_bit = 1;
+                break;
+              }
+              default: {
+                fsm = RxSt::RX_IDLE;
+                break;
+              }
+            }
+            beo_code = (beo_code << 1) + cur_bit;
+            if (++cnt_bit == N_BITS) {
+              fsm = RxSt::RX_STOP;
+            }
+            break;
+          }
+          case RxSt::RX_STOP: {
+            if (PC_STOP == pulse_code) {
+              data.source = (uint8_t) ((beo_code >> 8) & 0xff);
+              data.command = (uint8_t) ((beo_code) &0xff);
+              data.repeats++;
+            }
+            if ((n_sym - ic) < 42) {
+              return data;
+            } else {
+              fsm = RxSt::RX_IDLE;
+            }
+            break;
+          }
+        }
+      }
+    }
+  }
+  return {};  // decoding failed
+}
+
+void Beo4Protocol::dump(const Beo4Data &data) {
+  ESP_LOGI(TAG, "Beo4: source=0x%02x command=0x%02x repeats=%d ", data.source, data.command, data.repeats);
+}
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/remote_base/beo4_protocol.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "remote_base.h"
+
+#include <cinttypes>
+
+namespace esphome {
+namespace remote_base {
+
+struct Beo4Data {
+  uint8_t source;   // beoSource, e.g. video, audio, light...
+  uint8_t command;  // beoCommend, e.g. volume+, mute,...
+  uint8_t repeats;  // beoRepeat for repeat commands, e.g. up, down...
+
+  bool operator==(const Beo4Data &rhs) const { return source == rhs.source && command == rhs.command; }
+};
+
+class Beo4Protocol : public RemoteProtocol<Beo4Data> {
+ public:
+  void encode(RemoteTransmitData *dst, const Beo4Data &data) override;
+  optional<Beo4Data> decode(RemoteReceiveData src) override;
+  void dump(const Beo4Data &data) override;
+};
+
+DECLARE_REMOTE_PROTOCOL(Beo4)
+
+template<typename... Ts> class Beo4Action : public RemoteTransmitterActionBase<Ts...> {
+ public:
+  TEMPLATABLE_VALUE(uint8_t, source)
+  TEMPLATABLE_VALUE(uint8_t, command)
+  TEMPLATABLE_VALUE(uint8_t, repeats)
+
+  void encode(RemoteTransmitData *dst, Ts... x) override {
+    Beo4Data data{};
+    data.source = this->source_.value(x...);
+    data.command = this->command_.value(x...);
+    data.repeats = this->repeats_.value(x...);
+    Beo4Protocol().encode(dst, data);
+  }
+};
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/remote_base/gobox_protocol.cpp

@@ -0,0 +1,131 @@
+#include "gobox_protocol.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace remote_base {
+
+static const char *const TAG = "remote.gobox";
+
+constexpr uint32_t BIT_MARK_US = 580;  // 70us seems like a safe time delta for the receiver...
+constexpr uint32_t BIT_ONE_SPACE_US = 1640;
+constexpr uint32_t BIT_ZERO_SPACE_US = 545;
+constexpr uint64_t HEADER = 0b011001001100010uL;  // 15 bits
+constexpr uint64_t HEADER_SIZE = 15;
+constexpr uint64_t CODE_SIZE = 17;
+
+void GoboxProtocol::dump_timings_(const RawTimings &timings) const {
+  ESP_LOGD(TAG, "Gobox: size=%u", timings.size());
+  for (int32_t timing : timings) {
+    ESP_LOGD(TAG, "Gobox: timing=%ld", (long) timing);
+  }
+}
+
+void GoboxProtocol::encode(RemoteTransmitData *dst, const GoboxData &data) {
+  ESP_LOGI(TAG, "Send Gobox: code=0x%x", data.code);
+  dst->set_carrier_frequency(38000);
+  dst->reserve((HEADER_SIZE + CODE_SIZE + 1) * 2);
+  uint64_t code = (HEADER << CODE_SIZE) | (data.code & ((1UL << CODE_SIZE) - 1));
+  ESP_LOGI(TAG, "Send Gobox: code=0x%Lx", code);
+  for (int16_t i = (HEADER_SIZE + CODE_SIZE - 1); i >= 0; i--) {
+    if (code & ((uint64_t) 1 << i)) {
+      dst->item(BIT_MARK_US, BIT_ONE_SPACE_US);
+    } else {
+      dst->item(BIT_MARK_US, BIT_ZERO_SPACE_US);
+    }
+  }
+  dst->item(BIT_MARK_US, 2000);
+
+  dump_timings_(dst->get_data());
+}
+
+optional<GoboxData> GoboxProtocol::decode(RemoteReceiveData src) {
+  if (src.size() < ((HEADER_SIZE + CODE_SIZE) * 2 + 1)) {
+    return {};
+  }
+
+  // First check for the header
+  uint64_t code = HEADER;
+  for (int16_t i = HEADER_SIZE - 1; i >= 0; i--) {
+    if (code & ((uint64_t) 1 << i)) {
+      if (!src.expect_item(BIT_MARK_US, BIT_ONE_SPACE_US)) {
+        return {};
+      }
+    } else {
+      if (!src.expect_item(BIT_MARK_US, BIT_ZERO_SPACE_US)) {
+        return {};
+      }
+    }
+  }
+
+  // Next, build up the code
+  code = 0UL;
+  for (int16_t i = CODE_SIZE - 1; i >= 0; i--) {
+    if (!src.expect_mark(BIT_MARK_US)) {
+      return {};
+    }
+    if (src.expect_space(BIT_ONE_SPACE_US)) {
+      code |= (1UL << i);
+    } else if (!src.expect_space(BIT_ZERO_SPACE_US)) {
+      return {};
+    }
+  }
+
+  if (!src.expect_mark(BIT_MARK_US)) {
+    return {};
+  }
+
+  dump_timings_(src.get_raw_data());
+
+  GoboxData out;
+  out.code = code;
+
+  return out;
+}
+
+void GoboxProtocol::dump(const GoboxData &data) {
+  ESP_LOGI(TAG, "Received Gobox: code=0x%x", data.code);
+  switch (data.code) {
+    case GOBOX_MENU:
+      ESP_LOGI(TAG, "Received Gobox: key=MENU");
+      break;
+    case GOBOX_RETURN:
+      ESP_LOGI(TAG, "Received Gobox: key=RETURN");
+      break;
+    case GOBOX_UP:
+      ESP_LOGI(TAG, "Received Gobox: key=UP");
+      break;
+    case GOBOX_LEFT:
+      ESP_LOGI(TAG, "Received Gobox: key=LEFT");
+      break;
+    case GOBOX_RIGHT:
+      ESP_LOGI(TAG, "Received Gobox: key=RIGHT");
+      break;
+    case GOBOX_DOWN:
+      ESP_LOGI(TAG, "Received Gobox: key=DOWN");
+      break;
+    case GOBOX_OK:
+      ESP_LOGI(TAG, "Received Gobox: key=OK");
+      break;
+    case GOBOX_TOGGLE:
+      ESP_LOGI(TAG, "Received Gobox: key=TOGGLE");
+      break;
+    case GOBOX_PROFILE:
+      ESP_LOGI(TAG, "Received Gobox: key=PROFILE");
+      break;
+    case GOBOX_FASTER:
+      ESP_LOGI(TAG, "Received Gobox: key=FASTER");
+      break;
+    case GOBOX_SLOWER:
+      ESP_LOGI(TAG, "Received Gobox: key=SLOWER");
+      break;
+    case GOBOX_LOUDER:
+      ESP_LOGI(TAG, "Received Gobox: key=LOUDER");
+      break;
+    case GOBOX_SOFTER:
+      ESP_LOGI(TAG, "Received Gobox: key=SOFTER");
+      break;
+  }
+}
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/remote_base/gobox_protocol.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "remote_base.h"
+
+namespace esphome {
+namespace remote_base {
+
+struct GoboxData {
+  int code;
+  bool operator==(const GoboxData &rhs) const { return code == rhs.code; }
+};
+
+enum {
+  GOBOX_MENU = 0xaa55,
+  GOBOX_RETURN = 0x22dd,
+  GOBOX_UP = 0x0af5,
+  GOBOX_LEFT = 0x8a75,
+  GOBOX_RIGHT = 0x48b7,
+  GOBOX_DOWN = 0xa25d,
+  GOBOX_OK = 0xc837,
+  GOBOX_TOGGLE = 0xb847,
+  GOBOX_PROFILE = 0xfa05,
+  GOBOX_FASTER = 0xf00f,
+  GOBOX_SLOWER = 0xd02f,
+  GOBOX_LOUDER = 0xb04f,
+  GOBOX_SOFTER = 0xf807,
+};
+
+class GoboxProtocol : public RemoteProtocol<GoboxData> {
+ private:
+  void dump_timings_(const RawTimings &timings) const;
+
+ public:
+  void encode(RemoteTransmitData *dst, const GoboxData &data) override;
+  optional<GoboxData> decode(RemoteReceiveData src) override;
+  void dump(const GoboxData &data) override;
+};
+
+DECLARE_REMOTE_PROTOCOL(Gobox)
+
+template<typename... Ts> class GoboxAction : public RemoteTransmitterActionBase<Ts...> {
+ public:
+  TEMPLATABLE_VALUE(uint64_t, code);
+
+  void encode(RemoteTransmitData *dst, Ts... x) override {
+    GoboxData data{};
+    data.code = this->code_.value(x...);
+    GoboxProtocol().encode(dst, data);
+  }
+};
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/remote_receiver/remote_receiver_esp32.cpp

@@ -208,7 +208,6 @@ void RemoteReceiverComponent::loop() {
     this->store_.buffer_read = next_read;
 
     if (!this->temp_.empty()) {
-      this->temp_.push_back(-this->idle_us_);
       this->call_listeners_dumpers_();
     }
   }
@@ -219,11 +218,9 @@ void RemoteReceiverComponent::loop() {
     this->decode_rmt_(item, len / sizeof(rmt_item32_t));
     vRingbufferReturnItem(this->ringbuf_, item);
 
-    if (this->temp_.empty())
-      return;
-
-    this->temp_.push_back(-this->idle_us_);
-    this->call_listeners_dumpers_();
+    if (!this->temp_.empty()) {
+      this->call_listeners_dumpers_();
+    }
   }
 #endif
 }
@@ -234,6 +231,7 @@ void RemoteReceiverComponent::decode_rmt_(rmt_symbol_word_t *item, size_t item_c
 void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t item_count) {
 #endif
   bool prev_level = false;
+  bool idle_level = false;
   uint32_t prev_length = 0;
   this->temp_.clear();
   int32_t multiplier = this->pin_->is_inverted() ? -1 : 1;
@@ -266,7 +264,7 @@ void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t item_count)
     } else if ((bool(item[i].level0) == prev_level) || (item[i].duration0 < filter_ticks)) {
       prev_length += item[i].duration0;
     } else {
-      if (prev_length > 0) {
+      if (prev_length >= filter_ticks) {
         if (prev_level) {
           this->temp_.push_back(this->to_microseconds_(prev_length) * multiplier);
         } else {
@@ -276,6 +274,7 @@ void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t item_count)
       prev_level = bool(item[i].level0);
       prev_length = item[i].duration0;
     }
+    idle_level = !bool(item[i].level0);
 
     if (item[i].duration1 == 0u) {
       // EOF, sometimes garbage follows, break early
@@ -283,7 +282,7 @@ void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t item_count)
     } else if ((bool(item[i].level1) == prev_level) || (item[i].duration1 < filter_ticks)) {
       prev_length += item[i].duration1;
     } else {
-      if (prev_length > 0) {
+      if (prev_length >= filter_ticks) {
         if (prev_level) {
           this->temp_.push_back(this->to_microseconds_(prev_length) * multiplier);
         } else {
@@ -293,14 +292,22 @@ void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t item_count)
       prev_level = bool(item[i].level1);
       prev_length = item[i].duration1;
     }
+    idle_level = !bool(item[i].level1);
   }
-  if (prev_length > 0) {
+  if (prev_length >= filter_ticks && prev_level != idle_level) {
     if (prev_level) {
       this->temp_.push_back(this->to_microseconds_(prev_length) * multiplier);
     } else {
       this->temp_.push_back(-int32_t(this->to_microseconds_(prev_length)) * multiplier);
     }
   }
+  if (!this->temp_.empty()) {
+    if (idle_level) {
+      this->temp_.push_back(this->idle_us_ * multiplier);
+    } else {
+      this->temp_.push_back(-int32_t(this->idle_us_) * multiplier);
+    }
+  }
 }
 
 }  // namespace remote_receiver

esphome/components/resampler/speaker/resampler_speaker.cpp

@@ -43,13 +43,18 @@ void ResamplerSpeaker::setup() {
     return;
   }
 
-  this->output_speaker_->add_audio_output_callback(
-      [this](uint32_t new_playback_ms, uint32_t remainder_us, uint32_t pending_ms, uint32_t write_timestamp) {
-        int32_t adjustment = this->playback_differential_ms_;
-        this->playback_differential_ms_ -= adjustment;
-        int32_t adjusted_playback_ms = static_cast<int32_t>(new_playback_ms) + adjustment;
-        this->audio_output_callback_(adjusted_playback_ms, remainder_us, pending_ms, write_timestamp);
-      });
+  this->output_speaker_->add_audio_output_callback([this](uint32_t new_frames, int64_t write_timestamp) {
+    if (this->audio_stream_info_.get_sample_rate() != this->target_stream_info_.get_sample_rate()) {
+      // Convert the number of frames from the target sample rate to the source sample rate. Track the remainder to
+      // avoid losing frames from integer division truncation.
+      const uint64_t numerator = new_frames * this->audio_stream_info_.get_sample_rate() + this->callback_remainder_;
+      const uint64_t denominator = this->target_stream_info_.get_sample_rate();
+      this->callback_remainder_ = numerator % denominator;
+      this->audio_output_callback_(numerator / denominator, write_timestamp);
+    } else {
+      this->audio_output_callback_(new_frames, write_timestamp);
+    }
+  });
 }
 
 void ResamplerSpeaker::loop() {
@@ -283,7 +288,6 @@ void ResamplerSpeaker::resample_task(void *params) {
     xEventGroupSetBits(this_resampler->event_group_, ResamplingEventGroupBits::ERR_ESP_NOT_SUPPORTED);
   }
 
-  this_resampler->playback_differential_ms_ = 0;
   while (err == ESP_OK) {
     uint32_t event_bits = xEventGroupGetBits(this_resampler->event_group_);
 
@@ -295,8 +299,6 @@ void ResamplerSpeaker::resample_task(void *params) {
     int32_t ms_differential = 0;
     audio::AudioResamplerState resampler_state = resampler->resample(false, &ms_differential);
 
-    this_resampler->playback_differential_ms_ += ms_differential;
-
     if (resampler_state == audio::AudioResamplerState::FINISHED) {
       break;
     } else if (resampler_state == audio::AudioResamplerState::FAILED) {

esphome/components/resampler/speaker/resampler_speaker.h

@@ -100,7 +100,7 @@ class ResamplerSpeaker : public Component, public speaker::Speaker {
 
   uint32_t buffer_duration_ms_;
 
-  int32_t playback_differential_ms_{0};
+  uint64_t callback_remainder_{0};
 };
 
 }  // namespace resampler

esphome/components/rf_bridge/rf_bridge.cpp

@@ -1,5 +1,6 @@
 #include "rf_bridge.h"
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 #include <cinttypes>
 #include <cstring>
 
@@ -128,7 +129,7 @@ void RFBridgeComponent::write_byte_str_(const std::string &codes) {
 }
 
 void RFBridgeComponent::loop() {
-  const uint32_t now = millis();
+  const uint32_t now = App.get_loop_component_start_time();
   if (now - this->last_bridge_byte_ > 50) {
     this->rx_buffer_.clear();
     this->last_bridge_byte_ = now;

esphome/components/scd30/sensor.py

@@ -18,6 +18,8 @@ from esphome.const import (
     UNIT_CELSIUS,
     UNIT_PARTS_PER_MILLION,
     UNIT_PERCENT,
+    CONF_AUTOMATIC_SELF_CALIBRATION,
+    CONF_AMBIENT_PRESSURE_COMPENSATION,
 )
 
 DEPENDENCIES = ["i2c"]
@@ -33,10 +35,7 @@ ForceRecalibrationWithReference = scd30_ns.class_(
     "ForceRecalibrationWithReference", automation.Action
 )
 
-CONF_AUTOMATIC_SELF_CALIBRATION = "automatic_self_calibration"
 CONF_ALTITUDE_COMPENSATION = "altitude_compensation"
-CONF_AMBIENT_PRESSURE_COMPENSATION = "ambient_pressure_compensation"
-
 
 CONFIG_SCHEMA = (
     cv.Schema(

esphome/components/scd4x/sensor.py

@@ -20,6 +20,10 @@ from esphome.const import (
     UNIT_CELSIUS,
     UNIT_PARTS_PER_MILLION,
     UNIT_PERCENT,
+    CONF_AUTOMATIC_SELF_CALIBRATION,
+    CONF_AMBIENT_PRESSURE_COMPENSATION,
+    CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE,
+    CONF_MEASUREMENT_MODE,
 )
 
 CODEOWNERS = ["@sjtrny", "@martgras"]
@@ -47,11 +51,6 @@ FactoryResetAction = scd4x_ns.class_("FactoryResetAction", automation.Action)
 
 
 CONF_ALTITUDE_COMPENSATION = "altitude_compensation"
-CONF_AMBIENT_PRESSURE_COMPENSATION = "ambient_pressure_compensation"
-CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE = "ambient_pressure_compensation_source"
-CONF_AUTOMATIC_SELF_CALIBRATION = "automatic_self_calibration"
-CONF_MEASUREMENT_MODE = "measurement_mode"
-
 
 CONFIG_SCHEMA = (
     cv.Schema(

esphome/components/sdp3x/sensor.py

@@ -5,6 +5,7 @@ from esphome.const import (
     DEVICE_CLASS_PRESSURE,
     STATE_CLASS_MEASUREMENT,
     UNIT_HECTOPASCAL,
+    CONF_MEASUREMENT_MODE,
 )
 
 DEPENDENCIES = ["i2c"]
@@ -22,7 +23,7 @@ MEASUREMENT_MODE = {
     "mass_flow": MeasurementMode.MASS_FLOW_AVG,
     "differential_pressure": MeasurementMode.DP_AVG,
 }
-CONF_MEASUREMENT_MODE = "measurement_mode"
+
 
 CONFIG_SCHEMA = (
     sensor.sensor_schema(

esphome/components/sds011/sds011.cpp

@@ -1,5 +1,6 @@
 #include "sds011.h"
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 
 namespace esphome {
 namespace sds011 {
@@ -75,7 +76,7 @@ void SDS011Component::dump_config() {
 }
 
 void SDS011Component::loop() {
-  const uint32_t now = millis();
+  const uint32_t now = App.get_loop_component_start_time();
   if ((now - this->last_transmission_ >= 500) && this->data_index_) {
     // last transmission too long ago. Reset RX index.
     ESP_LOGV(TAG, "Last transmission too long ago. Reset RX index.");

esphome/components/select/__init__.py

@@ -48,7 +48,7 @@ SELECT_OPERATION_OPTIONS = {
 }
 
 
-SELECT_SCHEMA = (
+_SELECT_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
     .extend(
@@ -64,29 +64,28 @@ SELECT_SCHEMA = (
     )
 )
 
-_UNDEF = object()
-
 
 def select_schema(
-    class_: MockObjClass = _UNDEF,
+    class_: MockObjClass,
     *,
-    entity_category: str = _UNDEF,
-    icon: str = _UNDEF,
+    entity_category: str = cv.UNDEFINED,
+    icon: str = cv.UNDEFINED,
 ):
-    schema = cv.Schema({})
-    if class_ is not _UNDEF:
-        schema = schema.extend({cv.GenerateID(): cv.declare_id(class_)})
-    if entity_category is not _UNDEF:
-        schema = schema.extend(
-            {
-                cv.Optional(
-                    CONF_ENTITY_CATEGORY, default=entity_category
-                ): cv.entity_category
-            }
-        )
-    if icon is not _UNDEF:
-        schema = schema.extend({cv.Optional(CONF_ICON, default=icon): cv.icon})
-    return SELECT_SCHEMA.extend(schema)
+    schema = {cv.GenerateID(): cv.declare_id(class_)}
+
+    for key, default, validator in [
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+        (CONF_ICON, icon, cv.icon),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
+    return _SELECT_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+SELECT_SCHEMA = select_schema(Select)
+SELECT_SCHEMA.add_extra(cv.deprecated_schema_constant("select"))
 
 
 async def setup_select_core_(var, config, *, options: list[str]):