esphome 2025.3.2__py3-none-any.whl → 2025.4.0b1__py3-none-any.whl

esphome/components/xiaomi_rtcgq02lm/binary_sensor.py

@@ -1,14 +1,14 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import binary_sensor
+import esphome.config_validation as cv
 from esphome.const import (
+    CONF_BUTTON,
+    CONF_ID,
     CONF_LIGHT,
     CONF_MOTION,
     CONF_TIMEOUT,
     DEVICE_CLASS_LIGHT,
     DEVICE_CLASS_MOTION,
-    CONF_ID,
-    CONF_BUTTON,
 )
 from esphome.core import TimePeriod
 

esphome/components/xiaomi_rtcgq02lm/sensor.py

@@ -1,13 +1,13 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import sensor
+import esphome.config_validation as cv
 from esphome.const import (
     CONF_BATTERY_LEVEL,
+    CONF_ID,
+    DEVICE_CLASS_BATTERY,
     ENTITY_CATEGORY_DIAGNOSTIC,
     STATE_CLASS_MEASUREMENT,
     UNIT_PERCENT,
-    CONF_ID,
-    DEVICE_CLASS_BATTERY,
 )
 
 from . import XiaomiRTCGQ02LM

esphome/components/xiaomi_wx08zm/binary_sensor.py

@@ -1,18 +1,17 @@
 import esphome.codegen as cg
+from esphome.components import binary_sensor, esp32_ble_tracker, sensor
 import esphome.config_validation as cv
-from esphome.components import sensor, binary_sensor, esp32_ble_tracker
 from esphome.const import (
     CONF_BATTERY_LEVEL,
     CONF_MAC_ADDRESS,
     CONF_TABLET,
     DEVICE_CLASS_BATTERY,
     ENTITY_CATEGORY_DIAGNOSTIC,
+    ICON_BUG,
     STATE_CLASS_MEASUREMENT,
     UNIT_PERCENT,
-    ICON_BUG,
 )
 
-
 DEPENDENCIES = ["esp32_ble_tracker"]
 AUTO_LOAD = ["xiaomi_ble", "sensor"]
 

esphome/components/xl9535/__init__.py

@@ -1,6 +1,7 @@
+from esphome import pins
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import i2c
+import esphome.config_validation as cv
 from esphome.const import (
     CONF_ID,
     CONF_INPUT,
@@ -9,7 +10,6 @@ from esphome.const import (
     CONF_NUMBER,
     CONF_OUTPUT,
 )
-from esphome import pins
 
 CONF_XL9535 = "xl9535"
 

esphome/components/yashima/climate.py

@@ -1,7 +1,7 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import climate, remote_transmitter, sensor
 from esphome.components.remote_base import CONF_TRANSMITTER_ID
+import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_SENSOR, CONF_SUPPORTS_COOL, CONF_SUPPORTS_HEAT
 
 AUTO_LOAD = ["sensor"]

esphome/components/zhlt01/climate.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import climate_ir
+import esphome.config_validation as cv
 from esphome.const import CONF_ID
 
 AUTO_LOAD = ["climate_ir"]

esphome/components/zio_ultrasonic/sensor.py

@@ -1,10 +1,7 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import i2c, sensor
-from esphome.const import (
-    DEVICE_CLASS_DISTANCE,
-    STATE_CLASS_MEASUREMENT,
-)
+import esphome.config_validation as cv
+from esphome.const import DEVICE_CLASS_DISTANCE, STATE_CLASS_MEASUREMENT
 
 DEPENDENCIES = ["i2c"]
 CODEOWNERS = ["@kahrendt"]

esphome/components/zyaura/sensor.py

@@ -1,22 +1,22 @@
-import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome import pins
+import esphome.codegen as cg
 from esphome.components import sensor
+import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ID,
     CONF_CLOCK_PIN,
-    CONF_DATA_PIN,
     CONF_CO2,
-    CONF_TEMPERATURE,
+    CONF_DATA_PIN,
     CONF_HUMIDITY,
+    CONF_ID,
+    CONF_TEMPERATURE,
     DEVICE_CLASS_CARBON_DIOXIDE,
     DEVICE_CLASS_HUMIDITY,
     DEVICE_CLASS_TEMPERATURE,
+    ICON_MOLECULE_CO2,
     STATE_CLASS_MEASUREMENT,
-    UNIT_PARTS_PER_MILLION,
     UNIT_CELSIUS,
+    UNIT_PARTS_PER_MILLION,
     UNIT_PERCENT,
-    ICON_MOLECULE_CO2,
 )
 from esphome.cpp_helpers import gpio_pin_expression
 

esphome/const.py

@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2025.3.2"
+__version__ = "2025.4.0b1"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (
@@ -196,8 +196,10 @@ CONF_DC_PIN = "dc_pin"
 CONF_DEASSERT_RTS_DTR = "deassert_rts_dtr"
 CONF_DEBOUNCE = "debounce"
 CONF_DEBUG = "debug"
+CONF_DEBUG_SCHEDULER = "debug_scheduler"
 CONF_DECAY_MODE = "decay_mode"
 CONF_DECELERATION = "deceleration"
+CONF_DEFAULT = "default"
 CONF_DEFAULT_MODE = "default_mode"
 CONF_DEFAULT_TARGET_TEMPERATURE_HIGH = "default_target_temperature_high"
 CONF_DEFAULT_TARGET_TEMPERATURE_LOW = "default_target_temperature_low"

esphome/core/component.cpp

@@ -79,7 +79,7 @@ void Component::call_setup() { this->setup(); }
 void Component::call_dump_config() {
   this->dump_config();
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "  Component %s is marked FAILED", this->get_component_source());
+    ESP_LOGE(TAG, "  Component %s is marked FAILED: %s", this->get_component_source(), this->error_message_.c_str());
   }
 }
 
@@ -162,6 +162,8 @@ void Component::status_set_error(const char *message) {
   this->component_state_ |= STATUS_LED_ERROR;
   App.app_state_ |= STATUS_LED_ERROR;
   ESP_LOGE(TAG, "Component %s set Error flag: %s", this->get_component_source(), message);
+  if (strcmp(message, "unspecified") != 0)
+    this->error_message_ = message;
 }
 void Component::status_clear_warning() {
   if ((this->component_state_ & STATUS_LED_WARNING) == 0)

esphome/core/component.h

@@ -118,6 +118,11 @@ class Component {
    */
   virtual void mark_failed();
 
+  void mark_failed(const char *message) {
+    this->status_set_error(message);
+    this->mark_failed();
+  }
+
   bool is_failed() const;
 
   bool is_ready() const;
@@ -165,10 +170,17 @@ class Component {
    * This will call f every interval ms. Can be cancelled via CancelInterval().
    * Similar to javascript's setInterval().
    *
-   * IMPORTANT: Do not rely on this having correct timing. This is only called from
-   * loop() and therefore can be significantly delay. If you need exact timing please
+   * IMPORTANT NOTE:
+   * The only guarantee offered by this call is that the callback will be called no *earlier* than
+   * the specified interval after the previous call. Any given interval may be longer due to
+   * other components blocking the loop() call.
+   *
+   * So do not rely on this having correct timing. If you need exact timing please
    * use hardware timers.
    *
+   * Note also that the first call to f will not happen immediately, but after a random delay. This is
+   * intended to prevent many interval functions from being called at the same time.
+   *
    * @param name The identifier for this interval function.
    * @param interval The interval in ms.
    * @param f The function (or lambda) that should be called
@@ -272,6 +284,7 @@ class Component {
   uint32_t component_state_{0x0000};  ///< State of this component.
   float setup_priority_override_{NAN};
   const char *component_source_{nullptr};
+  std::string error_message_{};
 };
 
 /** This class simplifies creating components that periodically check a state.

esphome/core/config.py

@@ -10,6 +10,7 @@ from esphome.const import (
     CONF_BUILD_PATH,
     CONF_COMMENT,
     CONF_COMPILE_PROCESS_LIMIT,
+    CONF_DEBUG_SCHEDULER,
     CONF_ESPHOME,
     CONF_FRIENDLY_NAME,
     CONF_INCLUDES,
@@ -144,6 +145,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_INCLUDES, default=[]): cv.ensure_list(valid_include),
             cv.Optional(CONF_LIBRARIES, default=[]): cv.ensure_list(cv.string_strict),
             cv.Optional(CONF_NAME_ADD_MAC_SUFFIX, default=False): cv.boolean,
+            cv.Optional(CONF_DEBUG_SCHEDULER, default=False): cv.boolean,
             cv.Optional(CONF_PROJECT): cv.Schema(
                 {
                     cv.Required(CONF_NAME): cv.All(
@@ -369,6 +371,8 @@ async def to_code(config):
     cg.add_build_flag("-Wno-unused-variable")
     cg.add_build_flag("-Wno-unused-but-set-variable")
     cg.add_build_flag("-Wno-sign-compare")
+    if config[CONF_DEBUG_SCHEDULER]:
+        cg.add_define("ESPHOME_DEBUG_SCHEDULER")
 
     if CORE.using_arduino and not CORE.is_bk72xx:
         CORE.add_job(add_arduino_global_workaround)

esphome/core/defines.h

@@ -13,6 +13,7 @@
 #define ESPHOME_PROJECT_VERSION "v2"
 #define ESPHOME_PROJECT_VERSION_30 "v2"
 #define ESPHOME_VARIANT "ESP32"
+#define ESPHOME_DEBUG_SCHEDULER
 
 // logger
 #define ESPHOME_LOG_LEVEL ESPHOME_LOG_LEVEL_VERY_VERBOSE
@@ -47,16 +48,36 @@
 #define USE_LOGGER
 #define USE_LVGL
 #define USE_LVGL_ANIMIMG
+#define USE_LVGL_ARC
 #define USE_LVGL_BINARY_SENSOR
+#define USE_LVGL_BUTTON
 #define USE_LVGL_BUTTONMATRIX
+#define USE_LVGL_CANVAS
+#define USE_LVGL_CHART
+#define USE_LVGL_CHECKBOX
 #define USE_LVGL_DROPDOWN
 #define USE_LVGL_FONT
 #define USE_LVGL_IMAGE
+#define USE_LVGL_IMAGEBUTTON
 #define USE_LVGL_KEY_LISTENER
 #define USE_LVGL_KEYBOARD
+#define USE_LVGL_LABEL
+#define USE_LVGL_LINE
+#define USE_LVGL_LIST
+#define USE_LVGL_MENU
 #define USE_LVGL_METER
+#define USE_LVGL_MSGBOX
 #define USE_LVGL_ROLLER
 #define USE_LVGL_ROTARY_ENCODER
+#define USE_LVGL_SLIDER
+#define USE_LVGL_SPAN
+#define USE_LVGL_SPINBOX
+#define USE_LVGL_SPINNER
+#define USE_LVGL_SWITCH
+#define USE_LVGL_TABLE
+#define USE_LVGL_TABVIEW
+#define USE_LVGL_TEXTAREA
+#define USE_LVGL_TILEVIEW
 #define USE_LVGL_TOUCHSCREEN
 #define USE_MD5
 #define USE_MDNS

esphome/core/helpers.cpp

@@ -44,10 +44,7 @@
 #include <random>
 #endif
 #ifdef USE_ESP32
-#include "esp32/rom/crc.h"
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 2)
-#include "esp_mac.h"
-#endif
+#include "rom/crc.h"
 #include "esp_efuse.h"
 #include "esp_efuse_table.h"
 #endif
@@ -70,7 +67,9 @@ static const uint16_t CRC16_8408_LE_LUT_L[] = {0x0000, 0x1189, 0x2312, 0x329b, 0
                                                0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7};
 static const uint16_t CRC16_8408_LE_LUT_H[] = {0x0000, 0x1081, 0x2102, 0x3183, 0x4204, 0x5285, 0x6306, 0x7387,
                                                0x8408, 0x9489, 0xa50a, 0xb58b, 0xc60c, 0xd68d, 0xe70e, 0xf78f};
+#endif
 
+#if !defined(USE_ESP32) || defined(USE_ESP32_VARIANT_ESP32S2)
 static const uint16_t CRC16_1021_BE_LUT_L[] = {0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
                                                0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef};
 static const uint16_t CRC16_1021_BE_LUT_H[] = {0x0000, 0x1231, 0x2462, 0x3653, 0x48c4, 0x5af5, 0x6ca6, 0x7e97,
@@ -151,7 +150,7 @@ uint16_t crc16(const uint8_t *data, uint16_t len, uint16_t crc, uint16_t reverse
 }
 
 uint16_t crc16be(const uint8_t *data, uint16_t len, uint16_t crc, uint16_t poly, bool refin, bool refout) {
-#ifdef USE_ESP32
+#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32S2)
   if (poly == 0x1021) {
     crc = crc16_be(refin ? crc : (crc ^ 0xffff), data, len);
     return refout ? crc : (crc ^ 0xffff);
@@ -160,7 +159,7 @@ uint16_t crc16be(const uint8_t *data, uint16_t len, uint16_t crc, uint16_t poly,
   if (refin) {
     crc ^= 0xffff;
   }
-#ifndef USE_ESP32
+#if !defined(USE_ESP32) || defined(USE_ESP32_VARIANT_ESP32S2)
   if (poly == 0x1021) {
     while (len--) {
       uint8_t combo = (crc >> 8) ^ *data++;
@@ -178,7 +177,7 @@ uint16_t crc16be(const uint8_t *data, uint16_t len, uint16_t crc, uint16_t poly,
         }
       }
     }
-#ifndef USE_ESP32
+#if !defined(USE_ESP32) || defined(USE_ESP32_VARIANT_ESP32S2)
   }
 #endif
   return refout ? (crc ^ 0xffff) : crc;

esphome/core/scheduler.cpp

@@ -1,4 +1,5 @@
 #include "scheduler.h"
+#include "esphome/core/defines.h"
 #include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/hal.h"
@@ -21,7 +22,7 @@ static const uint32_t MAX_LOGICALLY_DELETED_ITEMS = 10;
 
 void HOT Scheduler::set_timeout(Component *component, const std::string &name, uint32_t timeout,
                                 std::function<void()> func) {
-  const uint32_t now = this->millis_();
+  const auto now = this->millis_();
 
   if (!name.empty())
     this->cancel_timeout(component, name);
@@ -29,17 +30,16 @@ void HOT Scheduler::set_timeout(Component *component, const std::string &name, u
   if (timeout == SCHEDULER_DONT_RUN)
     return;
 
-  ESP_LOGVV(TAG, "set_timeout(name='%s', timeout=%" PRIu32 ")", name.c_str(), timeout);
-
   auto item = make_unique<SchedulerItem>();
   item->component = component;
   item->name = name;
   item->type = SchedulerItem::TIMEOUT;
-  item->timeout = timeout;
-  item->last_execution = now;
-  item->last_execution_major = this->millis_major_;
+  item->next_execution_ = now + timeout;
   item->callback = std::move(func);
   item->remove = false;
+#ifdef ESPHOME_DEBUG_SCHEDULER
+  ESP_LOGD(TAG, "set_timeout(name='%s/%s', timeout=%" PRIu32 ")", item->get_source(), name.c_str(), timeout);
+#endif
   this->push_(std::move(item));
 }
 bool HOT Scheduler::cancel_timeout(Component *component, const std::string &name) {
@@ -47,7 +47,7 @@ bool HOT Scheduler::cancel_timeout(Component *component, const std::string &name
 }
 void HOT Scheduler::set_interval(Component *component, const std::string &name, uint32_t interval,
                                  std::function<void()> func) {
-  const uint32_t now = this->millis_();
+  const auto now = this->millis_();
 
   if (!name.empty())
     this->cancel_interval(component, name);
@@ -60,19 +60,18 @@ void HOT Scheduler::set_interval(Component *component, const std::string &name,
   if (interval != 0)
     offset = (random_uint32() % interval) / 2;
 
-  ESP_LOGVV(TAG, "set_interval(name='%s', interval=%" PRIu32 ", offset=%" PRIu32 ")", name.c_str(), interval, offset);
-
   auto item = make_unique<SchedulerItem>();
   item->component = component;
   item->name = name;
   item->type = SchedulerItem::INTERVAL;
   item->interval = interval;
-  item->last_execution = now - offset - interval;
-  item->last_execution_major = this->millis_major_;
-  if (item->last_execution > now)
-    item->last_execution_major--;
+  item->next_execution_ = now + offset;
   item->callback = std::move(func);
   item->remove = false;
+#ifdef ESPHOME_DEBUG_SCHEDULER
+  ESP_LOGD(TAG, "set_interval(name='%s/%s', interval=%" PRIu32 ", offset=%" PRIu32 ")", item->get_source(),
+           name.c_str(), interval, offset);
+#endif
   this->push_(std::move(item));
 }
 bool HOT Scheduler::cancel_interval(Component *component, const std::string &name) {
@@ -138,36 +137,36 @@ optional<uint32_t> HOT Scheduler::next_schedule_in() {
   if (this->empty_())
     return {};
   auto &item = this->items_[0];
-  const uint32_t now = this->millis_();
-  uint32_t next_time = item->last_execution + item->interval;
-  if (next_time < now)
+  const auto now = this->millis_();
+  if (item->next_execution_ < now)
     return 0;
-  return next_time - now;
+  return item->next_execution_ - now;
 }
 void HOT Scheduler::call() {
-  const uint32_t now = this->millis_();
+  const auto now = this->millis_();
   this->process_to_add();
 
 #ifdef ESPHOME_DEBUG_SCHEDULER
-  static uint32_t last_print = 0;
+  static uint64_t last_print = 0;
 
   if (now - last_print > 2000) {
     last_print = now;
     std::vector<std::unique_ptr<SchedulerItem>> old_items;
-    ESP_LOGVV(TAG, "Items: count=%u, now=%" PRIu32, this->items_.size(), now);
+    ESP_LOGD(TAG, "Items: count=%u, now=%" PRIu64 " (%u, %" PRIu32 ")", this->items_.size(), now, this->millis_major_,
+             this->last_millis_);
     while (!this->empty_()) {
       this->lock_.lock();
       auto item = std::move(this->items_[0]);
       this->pop_raw_();
       this->lock_.unlock();
 
-      ESP_LOGVV(TAG, "  %s '%s' interval=%" PRIu32 " last_execution=%" PRIu32 " (%u) next=%" PRIu32 " (%u)",
-                item->get_type_str(), item->name.c_str(), item->interval, item->last_execution,
-                item->last_execution_major, item->next_execution(), item->next_execution_major());
+      ESP_LOGD(TAG, "  %s '%s/%s' interval=%" PRIu32 " next_execution in %" PRIu64 "ms at %" PRIu64,
+               item->get_type_str(), item->get_source(), item->name.c_str(), item->interval,
+               item->next_execution_ - now, item->next_execution_);
 
       old_items.push_back(std::move(item));
     }
-    ESP_LOGVV(TAG, "\n");
+    ESP_LOGD(TAG, "\n");
 
     {
       LockGuard guard{this->lock_};
@@ -206,14 +205,10 @@ void HOT Scheduler::call() {
     {
       // Don't copy-by value yet
       auto &item = this->items_[0];
-      if ((now - item->last_execution) < item->interval) {
+      if (item->next_execution_ > now) {
         // Not reached timeout yet, done for this call
         break;
       }
-      uint8_t major = item->next_execution_major();
-      if (this->millis_major_ - major > 1)
-        break;
-
       // Don't run on failed components
       if (item->component != nullptr && item->component->is_failed()) {
         LockGuard guard{this->lock_};
@@ -221,9 +216,10 @@ void HOT Scheduler::call() {
         continue;
       }
 
-#ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
-      ESP_LOGVV(TAG, "Running %s '%s' with interval=%" PRIu32 " last_execution=%" PRIu32 " (now=%" PRIu32 ")",
-                item->get_type_str(), item->name.c_str(), item->interval, item->last_execution, now);
+#ifdef ESPHOME_DEBUG_SCHEDULER
+      ESP_LOGV(TAG, "Running %s '%s/%s' with interval=%" PRIu32 " next_execution=%" PRIu64 " (now=%" PRIu64 ")",
+               item->get_type_str(), item->get_source(), item->name.c_str(), item->interval, item->next_execution_,
+               now);
 #endif
 
       // Warning: During callback(), a lot of stuff can happen, including:
@@ -254,13 +250,7 @@ void HOT Scheduler::call() {
       }
 
       if (item->type == SchedulerItem::INTERVAL) {
-        if (item->interval != 0) {
-          const uint32_t before = item->last_execution;
-          const uint32_t amount = (now - item->last_execution) / item->interval;
-          item->last_execution += amount * item->interval;
-          if (item->last_execution < before)
-            item->last_execution_major++;
-        }
+        item->next_execution_ = now + item->interval;
         this->push_(std::move(item));
       }
     }
@@ -322,43 +312,20 @@ bool HOT Scheduler::cancel_item_(Component *component, const std::string &name,
 
   return ret;
 }
-uint32_t Scheduler::millis_() {
+uint64_t Scheduler::millis_() {
   const uint32_t now = millis();
   if (now < this->last_millis_) {
-    ESP_LOGD(TAG, "Incrementing scheduler major");
     this->millis_major_++;
+    ESP_LOGD(TAG, "Incrementing scheduler major at %" PRIu64 "ms",
+             now + (static_cast<uint64_t>(this->millis_major_) << 32));
   }
   this->last_millis_ = now;
-  return now;
+  return now + (static_cast<uint64_t>(this->millis_major_) << 32);
 }
 
 bool HOT Scheduler::SchedulerItem::cmp(const std::unique_ptr<SchedulerItem> &a,
                                        const std::unique_ptr<SchedulerItem> &b) {
-  // min-heap
-  // return true if *a* will happen after *b*
-  uint32_t a_next_exec = a->next_execution();
-  uint8_t a_next_exec_major = a->next_execution_major();
-  uint32_t b_next_exec = b->next_execution();
-  uint8_t b_next_exec_major = b->next_execution_major();
-
-  if (a_next_exec_major != b_next_exec_major) {
-    // The "major" calculation is quite complicated.
-    // Basically, we need to check if the major value lies in the future or
-    //
-
-    // Here are some cases to think about:
-    // Format: a_major,b_major -> expected result (a-b, b-a)
-    // a=255,b=0 -> false (255, 1)
-    // a=0,b=1 -> false   (255, 1)
-    // a=1,b=0 -> true    (1, 255)
-    // a=0,b=255 -> true  (1, 255)
-
-    uint8_t diff1 = a_next_exec_major - b_next_exec_major;
-    uint8_t diff2 = b_next_exec_major - a_next_exec_major;
-    return diff1 < diff2;
-  }
-
-  return a_next_exec > b_next_exec;
+  return a->next_execution_ > b->next_execution_;
 }
 
 }  // namespace esphome

esphome/core/scheduler.h

@@ -32,23 +32,10 @@ class Scheduler {
     Component *component;
     std::string name;
     enum Type { TIMEOUT, INTERVAL } type;
-    union {
-      uint32_t interval;
-      uint32_t timeout;
-    };
-    uint32_t last_execution;
+    uint32_t interval;
+    uint64_t next_execution_;
     std::function<void()> callback;
     bool remove;
-    uint8_t last_execution_major;
-
-    inline uint32_t next_execution() { return this->last_execution + this->timeout; }
-    inline uint8_t next_execution_major() {
-      uint32_t next_exec = this->next_execution();
-      uint8_t next_exec_major = this->last_execution_major;
-      if (next_exec < this->last_execution)
-        next_exec_major++;
-      return next_exec_major;
-    }
 
     static bool cmp(const std::unique_ptr<SchedulerItem> &a, const std::unique_ptr<SchedulerItem> &b);
     const char *get_type_str() {
@@ -61,9 +48,12 @@ class Scheduler {
           return "";
       }
     }
+    const char *get_source() {
+      return this->component != nullptr ? this->component->get_component_source() : "unknown";
+    }
   };
 
-  uint32_t millis_();
+  uint64_t millis_();
   void cleanup_();
   void pop_raw_();
   void push_(std::unique_ptr<SchedulerItem> item);
@@ -77,7 +67,7 @@ class Scheduler {
   std::vector<std::unique_ptr<SchedulerItem>> items_;
   std::vector<std::unique_ptr<SchedulerItem>> to_add_;
   uint32_t last_millis_{0};
-  uint8_t millis_major_{0};
+  uint16_t millis_major_{0};
   uint32_t to_remove_{0};
 };
 

esphome/dashboard/status/mqtt.py

@@ -32,8 +32,6 @@ class MqttStatusThread(threading.Thread):
         topic = "esphome/discover/#"
 
         def on_message(client, userdata, msg):
-            nonlocal current_entries
-
             payload = msg.payload.decode(errors="backslashreplace")
             if len(payload) > 0:
                 data = json.loads(payload)