[dlms_meter] Add dlms smart meter component (#8009)

Co-authored-by: Thomas Rupprecht <rupprecht.thomas@gmail.com>
Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>
Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

.clang-tidy.hash

@@ -1 +1 @@
-cf3d341206b4184ec8b7fe85141aef4fe4696aa720c3f8a06d4e57930574bdab
+069fa9526c52f7c580a9ec17c7678d12f142221387e9b561c18f95394d4629a3

CODEOWNERS

@@ -134,6 +134,7 @@ esphome/components/dfplayer/* @glmnet
 esphome/components/dfrobot_sen0395/* @niklasweber
 esphome/components/dht/* @OttoWinter
 esphome/components/display_menu_base/* @numo68
+esphome/components/dlms_meter/* @SimonFischer04
 esphome/components/dps310/* @kbx81
 esphome/components/ds1307/* @badbadc0ffee
 esphome/components/ds2484/* @mrk-its

esphome/components/dlms_meter/__init__.py

@@ -0,0 +1,57 @@
+import esphome.codegen as cg
+from esphome.components import uart
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, PLATFORM_ESP32, PLATFORM_ESP8266
+
+CODEOWNERS = ["@SimonFischer04"]
+DEPENDENCIES = ["uart"]
+
+CONF_DLMS_METER_ID = "dlms_meter_id"
+CONF_DECRYPTION_KEY = "decryption_key"
+CONF_PROVIDER = "provider"
+
+PROVIDERS = {"generic": 0, "netznoe": 1}
+
+dlms_meter_component_ns = cg.esphome_ns.namespace("dlms_meter")
+DlmsMeterComponent = dlms_meter_component_ns.class_(
+    "DlmsMeterComponent", cg.Component, uart.UARTDevice
+)
+
+
+def validate_key(value):
+    value = cv.string_strict(value)
+    if len(value) != 32:
+        raise cv.Invalid("Decryption key must be 32 hex characters (16 bytes)")
+    try:
+        return [int(value[i : i + 2], 16) for i in range(0, 32, 2)]
+    except ValueError as exc:
+        raise cv.Invalid("Decryption key must be hex values from 00 to FF") from exc
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(DlmsMeterComponent),
+            cv.Required(CONF_DECRYPTION_KEY): validate_key,
+            cv.Optional(CONF_PROVIDER, default="generic"): cv.enum(
+                PROVIDERS, lower=True
+            ),
+        }
+    )
+    .extend(uart.UART_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA),
+    cv.only_on([PLATFORM_ESP8266, PLATFORM_ESP32]),
+)
+
+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "dlms_meter", baud_rate=2400, require_rx=True
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await uart.register_uart_device(var, config)
+    key = ", ".join(str(b) for b in config[CONF_DECRYPTION_KEY])
+    cg.add(var.set_decryption_key(cg.RawExpression(f"{{{key}}}")))
+    cg.add(var.set_provider(PROVIDERS[config[CONF_PROVIDER]]))

esphome/components/dlms_meter/dlms.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <cstdint>
+
+namespace esphome::dlms_meter {
+
+/*
++-------------------------------+
+|       Ciphering Service       |
++-------------------------------+
+|      System Title Length      |
++-------------------------------+
+|                               |
+|                               |
+|                               |
+|            System             |
+|            Title              |
+|                               |
+|                               |
+|                               |
++-------------------------------+
+|            Length             | (1 or 3 Bytes)
++-------------------------------+
+|     Security Control Byte     |
++-------------------------------+
+|                               |
+|             Frame             |
+|            Counter            |
+|                               |
++-------------------------------+
+|                               |
+~                               ~
+        Encrypted Payload
+~                               ~
+|                               |
++-------------------------------+
+
+Ciphering Service: 0xDB (General-Glo-Ciphering)
+System Title Length: 0x08
+System Title: Unique ID of meter
+Length: 1 Byte=Length <= 127, 3 Bytes=Length > 127 (0x82 & 2 Bytes length)
+Security Control Byte:
+- Bit 3…0: Security_Suite_Id
+- Bit 4: "A" subfield: indicates that authentication is applied
+- Bit 5: "E" subfield: indicates that encryption is applied
+- Bit 6: Key_Set subfield: 0 = Unicast, 1 = Broadcast
+- Bit 7: Indicates the use of compression.
+ */
+
+static constexpr uint8_t DLMS_HEADER_LENGTH = 16;
+static constexpr uint8_t DLMS_HEADER_EXT_OFFSET = 2;  // Extra offset for extended length header
+static constexpr uint8_t DLMS_CIPHER_OFFSET = 0;
+static constexpr uint8_t DLMS_SYST_OFFSET = 1;
+static constexpr uint8_t DLMS_LENGTH_OFFSET = 10;
+static constexpr uint8_t TWO_BYTE_LENGTH = 0x82;
+static constexpr uint8_t DLMS_LENGTH_CORRECTION = 5;  // Header bytes included in length field
+static constexpr uint8_t DLMS_SECBYTE_OFFSET = 11;
+static constexpr uint8_t DLMS_FRAMECOUNTER_OFFSET = 12;
+static constexpr uint8_t DLMS_FRAMECOUNTER_LENGTH = 4;
+static constexpr uint8_t DLMS_PAYLOAD_OFFSET = 16;
+static constexpr uint8_t GLO_CIPHERING = 0xDB;
+static constexpr uint8_t DATA_NOTIFICATION = 0x0F;
+static constexpr uint8_t TIMESTAMP_DATETIME = 0x0C;
+static constexpr uint16_t MAX_MESSAGE_LENGTH = 512;  // Maximum size of message (when having 2 bytes length in header).
+
+// Provider specific quirks
+static constexpr uint8_t NETZ_NOE_MAGIC_BYTE = 0x81;  // Magic length byte used by Netz NOE
+static constexpr uint8_t NETZ_NOE_EXPECTED_MESSAGE_LENGTH = 0xF8;
+static constexpr uint8_t NETZ_NOE_EXPECTED_SECURITY_CONTROL_BYTE = 0x20;
+
+}  // namespace esphome::dlms_meter

esphome/components/dlms_meter/dlms_meter.cpp

@@ -0,0 +1,468 @@
+#include "dlms_meter.h"
+
+#include <cmath>
+
+#if defined(USE_ESP8266_FRAMEWORK_ARDUINO)
+#include <bearssl/bearssl.h>
+#elif defined(USE_ESP32)
+#include "mbedtls/esp_config.h"
+#include "mbedtls/gcm.h"
+#endif
+
+namespace esphome::dlms_meter {
+
+static constexpr const char *TAG = "dlms_meter";
+
+void DlmsMeterComponent::dump_config() {
+  const char *provider_name = this->provider_ == PROVIDER_NETZNOE ? "Netz NOE" : "Generic";
+  ESP_LOGCONFIG(TAG,
+                "DLMS Meter:\n"
+                "  Provider: %s\n"
+                "  Read Timeout: %u ms",
+                provider_name, this->read_timeout_);
+#define DLMS_METER_LOG_SENSOR(s) LOG_SENSOR("  ", #s, this->s##_sensor_);
+  DLMS_METER_SENSOR_LIST(DLMS_METER_LOG_SENSOR, )
+#define DLMS_METER_LOG_TEXT_SENSOR(s) LOG_TEXT_SENSOR("  ", #s, this->s##_text_sensor_);
+  DLMS_METER_TEXT_SENSOR_LIST(DLMS_METER_LOG_TEXT_SENSOR, )
+}
+
+void DlmsMeterComponent::loop() {
+  // Read while data is available, netznoe uses two frames so allow 2x max frame length
+  while (this->available()) {
+    if (this->receive_buffer_.size() >= MBUS_MAX_FRAME_LENGTH * 2) {
+      ESP_LOGW(TAG, "Receive buffer full, dropping remaining bytes");
+      break;
+    }
+    uint8_t c;
+    this->read_byte(&c);
+    this->receive_buffer_.push_back(c);
+    this->last_read_ = millis();
+  }
+
+  if (!this->receive_buffer_.empty() && millis() - this->last_read_ > this->read_timeout_) {
+    this->mbus_payload_.clear();
+    if (!this->parse_mbus_(this->mbus_payload_))
+      return;
+
+    uint16_t message_length;
+    uint8_t systitle_length;
+    uint16_t header_offset;
+    if (!this->parse_dlms_(this->mbus_payload_, message_length, systitle_length, header_offset))
+      return;
+
+    if (message_length < DECODER_START_OFFSET || message_length > MAX_MESSAGE_LENGTH) {
+      ESP_LOGE(TAG, "DLMS: Message length invalid: %u", message_length);
+      this->receive_buffer_.clear();
+      return;
+    }
+
+    // Decrypt in place and then decode the OBIS codes
+    if (!this->decrypt_(this->mbus_payload_, message_length, systitle_length, header_offset))
+      return;
+    this->decode_obis_(&this->mbus_payload_[header_offset + DLMS_PAYLOAD_OFFSET], message_length);
+  }
+}
+
+bool DlmsMeterComponent::parse_mbus_(std::vector<uint8_t> &mbus_payload) {
+  ESP_LOGV(TAG, "Parsing M-Bus frames");
+  uint16_t frame_offset = 0;  // Offset is used if the M-Bus message is split into multiple frames
+
+  while (frame_offset < this->receive_buffer_.size()) {
+    // Ensure enough bytes remain for the minimal intro header before accessing indices
+    if (this->receive_buffer_.size() - frame_offset < MBUS_HEADER_INTRO_LENGTH) {
+      ESP_LOGE(TAG, "MBUS: Not enough data for frame header (need %d, have %d)", MBUS_HEADER_INTRO_LENGTH,
+               (this->receive_buffer_.size() - frame_offset));
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    // Check start bytes
+    if (this->receive_buffer_[frame_offset + MBUS_START1_OFFSET] != START_BYTE_LONG_FRAME ||
+        this->receive_buffer_[frame_offset + MBUS_START2_OFFSET] != START_BYTE_LONG_FRAME) {
+      ESP_LOGE(TAG, "MBUS: Start bytes do not match");
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    // Both length bytes must be identical
+    if (this->receive_buffer_[frame_offset + MBUS_LENGTH1_OFFSET] !=
+        this->receive_buffer_[frame_offset + MBUS_LENGTH2_OFFSET]) {
+      ESP_LOGE(TAG, "MBUS: Length bytes do not match");
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    uint8_t frame_length = this->receive_buffer_[frame_offset + MBUS_LENGTH1_OFFSET];  // Get length of this frame
+
+    // Check if received data is enough for the given frame length
+    if (this->receive_buffer_.size() - frame_offset <
+        frame_length + 3) {  // length field inside packet does not account for second start- + checksum- + stop- byte
+      ESP_LOGE(TAG, "MBUS: Frame too big for received data");
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    // Ensure we have full frame (header + payload + checksum + stop byte) before accessing stop byte
+    size_t required_total =
+        frame_length + MBUS_HEADER_INTRO_LENGTH + MBUS_FOOTER_LENGTH;  // payload + header + 2 footer bytes
+    if (this->receive_buffer_.size() - frame_offset < required_total) {
+      ESP_LOGE(TAG, "MBUS: Incomplete frame (need %d, have %d)", (unsigned int) required_total,
+               this->receive_buffer_.size() - frame_offset);
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    if (this->receive_buffer_[frame_offset + frame_length + MBUS_HEADER_INTRO_LENGTH + MBUS_FOOTER_LENGTH - 1] !=
+        STOP_BYTE) {
+      ESP_LOGE(TAG, "MBUS: Invalid stop byte");
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    // Verify checksum: sum of all bytes starting at MBUS_HEADER_INTRO_LENGTH, take last byte
+    uint8_t checksum = 0;  // use uint8_t so only the 8 least significant bits are stored
+    for (uint16_t i = 0; i < frame_length; i++) {
+      checksum += this->receive_buffer_[frame_offset + MBUS_HEADER_INTRO_LENGTH + i];
+    }
+    if (checksum != this->receive_buffer_[frame_offset + frame_length + MBUS_HEADER_INTRO_LENGTH]) {
+      ESP_LOGE(TAG, "MBUS: Invalid checksum: %x != %x", checksum,
+               this->receive_buffer_[frame_offset + frame_length + MBUS_HEADER_INTRO_LENGTH]);
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    mbus_payload.insert(mbus_payload.end(), &this->receive_buffer_[frame_offset + MBUS_FULL_HEADER_LENGTH],
+                        &this->receive_buffer_[frame_offset + MBUS_HEADER_INTRO_LENGTH + frame_length]);
+
+    frame_offset += MBUS_HEADER_INTRO_LENGTH + frame_length + MBUS_FOOTER_LENGTH;
+  }
+  return true;
+}
+
+bool DlmsMeterComponent::parse_dlms_(const std::vector<uint8_t> &mbus_payload, uint16_t &message_length,
+                                     uint8_t &systitle_length, uint16_t &header_offset) {
+  ESP_LOGV(TAG, "Parsing DLMS header");
+  if (mbus_payload.size() < DLMS_HEADER_LENGTH + DLMS_HEADER_EXT_OFFSET) {
+    ESP_LOGE(TAG, "DLMS: Payload too short");
+    this->receive_buffer_.clear();
+    return false;
+  }
+
+  if (mbus_payload[DLMS_CIPHER_OFFSET] != GLO_CIPHERING) {  // Only general-glo-ciphering is supported (0xDB)
+    ESP_LOGE(TAG, "DLMS: Unsupported cipher");
+    this->receive_buffer_.clear();
+    return false;
+  }
+
+  systitle_length = mbus_payload[DLMS_SYST_OFFSET];
+
+  if (systitle_length != 0x08) {  // Only system titles with length of 8 are supported
+    ESP_LOGE(TAG, "DLMS: Unsupported system title length");
+    this->receive_buffer_.clear();
+    return false;
+  }
+
+  message_length = mbus_payload[DLMS_LENGTH_OFFSET];
+  header_offset = 0;
+
+  if (this->provider_ == PROVIDER_NETZNOE) {
+    // for some reason EVN seems to set the standard "length" field to 0x81 and then the actual length is in the next
+    // byte. Check some bytes to see if received data still matches expectation
+    if (message_length == NETZ_NOE_MAGIC_BYTE &&
+        mbus_payload[DLMS_LENGTH_OFFSET + 1] == NETZ_NOE_EXPECTED_MESSAGE_LENGTH &&
+        mbus_payload[DLMS_LENGTH_OFFSET + 2] == NETZ_NOE_EXPECTED_SECURITY_CONTROL_BYTE) {
+      message_length = mbus_payload[DLMS_LENGTH_OFFSET + 1];
+      header_offset = 1;
+    } else {
+      ESP_LOGE(TAG, "Wrong Length - Security Control Byte sequence detected for provider EVN");
+    }
+  } else {
+    if (message_length == TWO_BYTE_LENGTH) {
+      message_length = encode_uint16(mbus_payload[DLMS_LENGTH_OFFSET + 1], mbus_payload[DLMS_LENGTH_OFFSET + 2]);
+      header_offset = DLMS_HEADER_EXT_OFFSET;
+    }
+  }
+  if (message_length < DLMS_LENGTH_CORRECTION) {
+    ESP_LOGE(TAG, "DLMS: Message length too short: %u", message_length);
+    this->receive_buffer_.clear();
+    return false;
+  }
+  message_length -= DLMS_LENGTH_CORRECTION;  // Correct message length due to part of header being included in length
+
+  if (mbus_payload.size() - DLMS_HEADER_LENGTH - header_offset != message_length) {
+    ESP_LOGV(TAG, "DLMS: Length mismatch - payload=%d, header=%d, offset=%d, message=%d", mbus_payload.size(),
+             DLMS_HEADER_LENGTH, header_offset, message_length);
+    ESP_LOGE(TAG, "DLMS: Message has invalid length");
+    this->receive_buffer_.clear();
+    return false;
+  }
+
+  if (mbus_payload[header_offset + DLMS_SECBYTE_OFFSET] != 0x21 &&
+      mbus_payload[header_offset + DLMS_SECBYTE_OFFSET] !=
+          0x20) {  // Only certain security suite is supported (0x21 || 0x20)
+    ESP_LOGE(TAG, "DLMS: Unsupported security control byte");
+    this->receive_buffer_.clear();
+    return false;
+  }
+
+  return true;
+}
+
+bool DlmsMeterComponent::decrypt_(std::vector<uint8_t> &mbus_payload, uint16_t message_length, uint8_t systitle_length,
+                                  uint16_t header_offset) {
+  ESP_LOGV(TAG, "Decrypting payload");
+  uint8_t iv[12];  // Reserve space for the IV, always 12 bytes
+  // Copy system title to IV (System title is before length; no header offset needed!)
+  // Add 1 to the offset in order to skip the system title length byte
+  memcpy(&iv[0], &mbus_payload[DLMS_SYST_OFFSET + 1], systitle_length);
+  memcpy(&iv[8], &mbus_payload[header_offset + DLMS_FRAMECOUNTER_OFFSET],
+         DLMS_FRAMECOUNTER_LENGTH);  // Copy frame counter to IV
+
+  uint8_t *payload_ptr = &mbus_payload[header_offset + DLMS_PAYLOAD_OFFSET];
+
+#if defined(USE_ESP8266_FRAMEWORK_ARDUINO)
+  br_gcm_context gcm_ctx;
+  br_aes_ct_ctr_keys bc;
+  br_aes_ct_ctr_init(&bc, this->decryption_key_.data(), this->decryption_key_.size());
+  br_gcm_init(&gcm_ctx, &bc.vtable, br_ghash_ctmul32);
+  br_gcm_reset(&gcm_ctx, iv, sizeof(iv));
+  br_gcm_flip(&gcm_ctx);
+  br_gcm_run(&gcm_ctx, 0, payload_ptr, message_length);
+#elif defined(USE_ESP32)
+  size_t outlen = 0;
+  mbedtls_gcm_context gcm_ctx;
+  mbedtls_gcm_init(&gcm_ctx);
+  mbedtls_gcm_setkey(&gcm_ctx, MBEDTLS_CIPHER_ID_AES, this->decryption_key_.data(), this->decryption_key_.size() * 8);
+  mbedtls_gcm_starts(&gcm_ctx, MBEDTLS_GCM_DECRYPT, iv, sizeof(iv));
+  auto ret = mbedtls_gcm_update(&gcm_ctx, payload_ptr, message_length, payload_ptr, message_length, &outlen);
+  mbedtls_gcm_free(&gcm_ctx);
+  if (ret != 0) {
+    ESP_LOGE(TAG, "Decryption failed with error: %d", ret);
+    this->receive_buffer_.clear();
+    return false;
+  }
+#else
+#error "Invalid Platform"
+#endif
+
+  if (payload_ptr[0] != DATA_NOTIFICATION || payload_ptr[5] != TIMESTAMP_DATETIME) {
+    ESP_LOGE(TAG, "OBIS: Packet was decrypted but data is invalid");
+    this->receive_buffer_.clear();
+    return false;
+  }
+  ESP_LOGV(TAG, "Decrypted payload: %d bytes", message_length);
+  return true;
+}
+
+void DlmsMeterComponent::decode_obis_(uint8_t *plaintext, uint16_t message_length) {
+  ESP_LOGV(TAG, "Decoding payload");
+  MeterData data{};
+  uint16_t current_position = DECODER_START_OFFSET;
+  bool power_factor_found = false;
+
+  while (current_position + OBIS_CODE_OFFSET <= message_length) {
+    if (plaintext[current_position + OBIS_TYPE_OFFSET] != DataType::OCTET_STRING) {
+      ESP_LOGE(TAG, "OBIS: Unsupported OBIS header type: %x", plaintext[current_position + OBIS_TYPE_OFFSET]);
+      this->receive_buffer_.clear();
+      return;
+    }
+
+    uint8_t obis_code_length = plaintext[current_position + OBIS_LENGTH_OFFSET];
+    if (obis_code_length != OBIS_CODE_LENGTH_STANDARD && obis_code_length != OBIS_CODE_LENGTH_EXTENDED) {
+      ESP_LOGE(TAG, "OBIS: Unsupported OBIS header length: %x", obis_code_length);
+      this->receive_buffer_.clear();
+      return;
+    }
+    if (current_position + OBIS_CODE_OFFSET + obis_code_length > message_length) {
+      ESP_LOGE(TAG, "OBIS: Buffer too short for OBIS code");
+      this->receive_buffer_.clear();
+      return;
+    }
+
+    uint8_t *obis_code = &plaintext[current_position + OBIS_CODE_OFFSET];
+    uint8_t obis_medium = obis_code[OBIS_A];
+    uint16_t obis_cd = encode_uint16(obis_code[OBIS_C], obis_code[OBIS_D]);
+
+    bool timestamp_found = false;
+    bool meter_number_found = false;
+    if (this->provider_ == PROVIDER_NETZNOE) {
+      // Do not advance Position when reading the Timestamp at DECODER_START_OFFSET
+      if ((obis_code_length == OBIS_CODE_LENGTH_EXTENDED) && (current_position == DECODER_START_OFFSET)) {
+        timestamp_found = true;
+      } else if (power_factor_found) {
+        meter_number_found = true;
+        power_factor_found = false;
+      } else {
+        current_position += obis_code_length + OBIS_CODE_OFFSET;  // Advance past code and position
+      }
+    } else {
+      current_position += obis_code_length + OBIS_CODE_OFFSET;  // Advance past code, position and type
+    }
+    if (!timestamp_found && !meter_number_found && obis_medium != Medium::ELECTRICITY &&
+        obis_medium != Medium::ABSTRACT) {
+      ESP_LOGE(TAG, "OBIS: Unsupported OBIS medium: %x", obis_medium);
+      this->receive_buffer_.clear();
+      return;
+    }
+
+    if (current_position >= message_length) {
+      ESP_LOGE(TAG, "OBIS: Buffer too short for data type");
+      this->receive_buffer_.clear();
+      return;
+    }
+
+    float value = 0.0f;
+    uint8_t value_size = 0;
+    uint8_t data_type = plaintext[current_position];
+    current_position++;
+
+    switch (data_type) {
+      case DataType::DOUBLE_LONG_UNSIGNED: {
+        value_size = 4;
+        if (current_position + value_size > message_length) {
+          ESP_LOGE(TAG, "OBIS: Buffer too short for DOUBLE_LONG_UNSIGNED");
+          this->receive_buffer_.clear();
+          return;
+        }
+        value = encode_uint32(plaintext[current_position + 0], plaintext[current_position + 1],
+                              plaintext[current_position + 2], plaintext[current_position + 3]);
+        current_position += value_size;
+        break;
+      }
+      case DataType::LONG_UNSIGNED: {
+        value_size = 2;
+        if (current_position + value_size > message_length) {
+          ESP_LOGE(TAG, "OBIS: Buffer too short for LONG_UNSIGNED");
+          this->receive_buffer_.clear();
+          return;
+        }
+        value = encode_uint16(plaintext[current_position + 0], plaintext[current_position + 1]);
+        current_position += value_size;
+        break;
+      }
+      case DataType::OCTET_STRING: {
+        uint8_t data_length = plaintext[current_position];
+        current_position++;  // Advance past string length
+        if (current_position + data_length > message_length) {
+          ESP_LOGE(TAG, "OBIS: Buffer too short for OCTET_STRING");
+          this->receive_buffer_.clear();
+          return;
+        }
+        // Handle timestamp (normal OBIS code or NETZNOE special case)
+        if (obis_cd == OBIS_TIMESTAMP || timestamp_found) {
+          if (data_length < 8) {
+            ESP_LOGE(TAG, "OBIS: Timestamp data too short: %u", data_length);
+            this->receive_buffer_.clear();
+            return;
+          }
+          uint16_t year = encode_uint16(plaintext[current_position + 0], plaintext[current_position + 1]);
+          uint8_t month = plaintext[current_position + 2];
+          uint8_t day = plaintext[current_position + 3];
+          uint8_t hour = plaintext[current_position + 5];
+          uint8_t minute = plaintext[current_position + 6];
+          uint8_t second = plaintext[current_position + 7];
+          if (year > 9999 || month > 12 || day > 31 || hour > 23 || minute > 59 || second > 59) {
+            ESP_LOGE(TAG, "Invalid timestamp values: %04u-%02u-%02uT%02u:%02u:%02uZ", year, month, day, hour, minute,
+                     second);
+            this->receive_buffer_.clear();
+            return;
+          }
+          snprintf(data.timestamp, sizeof(data.timestamp), "%04u-%02u-%02uT%02u:%02u:%02uZ", year, month, day, hour,
+                   minute, second);
+        } else if (meter_number_found) {
+          snprintf(data.meternumber, sizeof(data.meternumber), "%.*s", data_length, &plaintext[current_position]);
+        }
+        current_position += data_length;
+        break;
+      }
+      default:
+        ESP_LOGE(TAG, "OBIS: Unsupported OBIS data type: %x", data_type);
+        this->receive_buffer_.clear();
+        return;
+    }
+
+    // Skip break after data
+    if (this->provider_ == PROVIDER_NETZNOE) {
+      // Don't skip the break on the first timestamp, as there's none
+      if (!timestamp_found) {
+        current_position += 2;
+      }
+    } else {
+      current_position += 2;
+    }
+
+    // Check for additional data (scaler-unit structure)
+    if (current_position < message_length && plaintext[current_position] == DataType::INTEGER) {
+      // Apply scaler: real_value = raw_value × 10^scaler
+      if (current_position + 1 < message_length) {
+        int8_t scaler = static_cast<int8_t>(plaintext[current_position + 1]);
+        if (scaler != 0) {
+          value *= powf(10.0f, scaler);
+        }
+      }
+
+      // on EVN Meters there is no additional break
+      if (this->provider_ == PROVIDER_NETZNOE) {
+        current_position += 4;
+      } else {
+        current_position += 6;
+      }
+    }
+
+    // Handle numeric values (LONG_UNSIGNED and DOUBLE_LONG_UNSIGNED)
+    if (value_size > 0) {
+      switch (obis_cd) {
+        case OBIS_VOLTAGE_L1:
+          data.voltage_l1 = value;
+          break;
+        case OBIS_VOLTAGE_L2:
+          data.voltage_l2 = value;
+          break;
+        case OBIS_VOLTAGE_L3:
+          data.voltage_l3 = value;
+          break;
+        case OBIS_CURRENT_L1:
+          data.current_l1 = value;
+          break;
+        case OBIS_CURRENT_L2:
+          data.current_l2 = value;
+          break;
+        case OBIS_CURRENT_L3:
+          data.current_l3 = value;
+          break;
+        case OBIS_ACTIVE_POWER_PLUS:
+          data.active_power_plus = value;
+          break;
+        case OBIS_ACTIVE_POWER_MINUS:
+          data.active_power_minus = value;
+          break;
+        case OBIS_ACTIVE_ENERGY_PLUS:
+          data.active_energy_plus = value;
+          break;
+        case OBIS_ACTIVE_ENERGY_MINUS:
+          data.active_energy_minus = value;
+          break;
+        case OBIS_REACTIVE_ENERGY_PLUS:
+          data.reactive_energy_plus = value;
+          break;
+        case OBIS_REACTIVE_ENERGY_MINUS:
+          data.reactive_energy_minus = value;
+          break;
+        case OBIS_POWER_FACTOR:
+          data.power_factor = value;
+          power_factor_found = true;
+          break;
+        default:
+          ESP_LOGW(TAG, "Unsupported OBIS code 0x%04X", obis_cd);
+      }
+    }
+  }
+
+  this->receive_buffer_.clear();
+
+  ESP_LOGI(TAG, "Received valid data");
+  this->publish_sensors(data);
+  this->status_clear_warning();
+}
+
+}  // namespace esphome::dlms_meter

esphome/components/dlms_meter/dlms_meter.h

@@ -0,0 +1,96 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/log.h"
+#ifdef USE_SENSOR
+#include "esphome/components/sensor/sensor.h"
+#endif
+#ifdef USE_TEXT_SENSOR
+#include "esphome/components/text_sensor/text_sensor.h"
+#endif
+#include "esphome/components/uart/uart.h"
+
+#include "mbus.h"
+#include "dlms.h"
+#include "obis.h"
+
+#include <array>
+#include <vector>
+
+namespace esphome::dlms_meter {
+
+#ifndef DLMS_METER_SENSOR_LIST
+#define DLMS_METER_SENSOR_LIST(F, SEP)
+#endif
+
+#ifndef DLMS_METER_TEXT_SENSOR_LIST
+#define DLMS_METER_TEXT_SENSOR_LIST(F, SEP)
+#endif
+
+struct MeterData {
+  float voltage_l1 = 0.0f;             // Voltage L1
+  float voltage_l2 = 0.0f;             // Voltage L2
+  float voltage_l3 = 0.0f;             // Voltage L3
+  float current_l1 = 0.0f;             // Current L1
+  float current_l2 = 0.0f;             // Current L2
+  float current_l3 = 0.0f;             // Current L3
+  float active_power_plus = 0.0f;      // Active power taken from grid
+  float active_power_minus = 0.0f;     // Active power put into grid
+  float active_energy_plus = 0.0f;     // Active energy taken from grid
+  float active_energy_minus = 0.0f;    // Active energy put into grid
+  float reactive_energy_plus = 0.0f;   // Reactive energy taken from grid
+  float reactive_energy_minus = 0.0f;  // Reactive energy put into grid
+  char timestamp[27]{};                // Text sensor for the timestamp value
+
+  // Netz NOE
+  float power_factor = 0.0f;  // Power Factor
+  char meternumber[13]{};     // Text sensor for the meterNumber value
+};
+
+// Provider constants
+enum Providers : uint32_t { PROVIDER_GENERIC = 0x00, PROVIDER_NETZNOE = 0x01 };
+
+class DlmsMeterComponent : public Component, public uart::UARTDevice {
+ public:
+  DlmsMeterComponent() = default;
+
+  void dump_config() override;
+  void loop() override;
+
+  void set_decryption_key(const std::array<uint8_t, 16> &key) { this->decryption_key_ = key; }
+  void set_provider(uint32_t provider) { this->provider_ = provider; }
+
+  void publish_sensors(MeterData &data) {
+#define DLMS_METER_PUBLISH_SENSOR(s) \
+  if (this->s##_sensor_ != nullptr) \
+    s##_sensor_->publish_state(data.s);
+    DLMS_METER_SENSOR_LIST(DLMS_METER_PUBLISH_SENSOR, )
+
+#define DLMS_METER_PUBLISH_TEXT_SENSOR(s) \
+  if (this->s##_text_sensor_ != nullptr) \
+    s##_text_sensor_->publish_state(data.s);
+    DLMS_METER_TEXT_SENSOR_LIST(DLMS_METER_PUBLISH_TEXT_SENSOR, )
+  }
+
+  DLMS_METER_SENSOR_LIST(SUB_SENSOR, )
+  DLMS_METER_TEXT_SENSOR_LIST(SUB_TEXT_SENSOR, )
+
+ protected:
+  bool parse_mbus_(std::vector<uint8_t> &mbus_payload);
+  bool parse_dlms_(const std::vector<uint8_t> &mbus_payload, uint16_t &message_length, uint8_t &systitle_length,
+                   uint16_t &header_offset);
+  bool decrypt_(std::vector<uint8_t> &mbus_payload, uint16_t message_length, uint8_t systitle_length,
+                uint16_t header_offset);
+  void decode_obis_(uint8_t *plaintext, uint16_t message_length);
+
+  std::vector<uint8_t> receive_buffer_;  // Stores the packet currently being received
+  std::vector<uint8_t> mbus_payload_;    // Parsed M-Bus payload, reused to avoid heap churn
+  uint32_t last_read_ = 0;               // Timestamp when data was last read
+  uint32_t read_timeout_ = 1000;         // Time to wait after last byte before considering data complete
+
+  uint32_t provider_ = PROVIDER_GENERIC;  // Provider of the meter / your grid operator
+  std::array<uint8_t, 16> decryption_key_;
+};
+
+}  // namespace esphome::dlms_meter

esphome/components/dlms_meter/mbus.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <cstdint>
+
+namespace esphome::dlms_meter {
+
+/*
++----------------------------------------------------+ -
+|               Start Character [0x68]               |  \
++----------------------------------------------------+   |
+|                   Data Length (L)                  |   |
++----------------------------------------------------+   |
+|               Data Length Repeat (L)               |   |
++----------------------------------------------------+    > M-Bus Data link layer
+|            Start Character Repeat [0x68]           |   |
++----------------------------------------------------+   |
+|             Control/Function Field (C)             |   |
++----------------------------------------------------+   |
+|                  Address Field (A)                 |  /
++----------------------------------------------------+ -
+|           Control Information Field (CI)           |  \
++----------------------------------------------------+   |
+|    Source Transport Service Access Point (STSAP)   |    > DLMS/COSEM M-Bus transport layer
++----------------------------------------------------+   |
+| Destination Transport Service Access Point (DTSAP) |  /
++----------------------------------------------------+ -
+|                                                    |  \
+~                                                    ~   |
+                         Data                             > DLMS/COSEM Application Layer
+~                                                    ~   |
+|                                                    |  /
++----------------------------------------------------+ -
+|                      Checksum                      |  \
++----------------------------------------------------+    > M-Bus Data link layer
+|                Stop Character [0x16]               |  /
++----------------------------------------------------+ -
+
+Data_Length = L - C - A - CI
+Each line (except Data) is one Byte
+
+Possible Values found in publicly available docs:
+- C: 0x53/0x73 (SND_UD)
+- A: FF (Broadcast)
+- CI: 0x00-0x1F/0x60/0x61/0x7C/0x7D
+- STSAP: 0x01 (Management Logical Device ID 1 of the meter)
+- DTSAP: 0x67 (Consumer Information Push Client ID 103)
+ */
+
+// MBUS start bytes for different telegram formats:
+// - Single Character: 0xE5 (length=1)
+// - Short Frame: 0x10 (length=5)
+// - Control Frame: 0x68 (length=9)
+// - Long Frame: 0x68 (length=9+data_length)
+// This component currently only uses Long Frame.
+static constexpr uint8_t START_BYTE_SINGLE_CHARACTER = 0xE5;
+static constexpr uint8_t START_BYTE_SHORT_FRAME = 0x10;
+static constexpr uint8_t START_BYTE_CONTROL_FRAME = 0x68;
+static constexpr uint8_t START_BYTE_LONG_FRAME = 0x68;
+static constexpr uint8_t MBUS_HEADER_INTRO_LENGTH = 4;  // Header length for the intro (0x68, length, length, 0x68)
+static constexpr uint8_t MBUS_FULL_HEADER_LENGTH = 9;   // Total header length
+static constexpr uint8_t MBUS_FOOTER_LENGTH = 2;        // Footer after frame
+static constexpr uint8_t MBUS_MAX_FRAME_LENGTH = 250;   // Maximum size of frame
+static constexpr uint8_t MBUS_START1_OFFSET = 0;        // Offset of first start byte
+static constexpr uint8_t MBUS_LENGTH1_OFFSET = 1;       // Offset of first length byte
+static constexpr uint8_t MBUS_LENGTH2_OFFSET = 2;       // Offset of (duplicated) second length byte
+static constexpr uint8_t MBUS_START2_OFFSET = 3;        // Offset of (duplicated) second start byte
+static constexpr uint8_t STOP_BYTE = 0x16;
+
+}  // namespace esphome::dlms_meter

esphome/components/dlms_meter/obis.h

@@ -0,0 +1,94 @@
+#pragma once
+
+#include <cstdint>
+
+namespace esphome::dlms_meter {
+
+// Data types as per specification
+enum DataType {
+  NULL_DATA = 0x00,
+  BOOLEAN = 0x03,
+  BIT_STRING = 0x04,
+  DOUBLE_LONG = 0x05,
+  DOUBLE_LONG_UNSIGNED = 0x06,
+  OCTET_STRING = 0x09,
+  VISIBLE_STRING = 0x0A,
+  UTF8_STRING = 0x0C,
+  BINARY_CODED_DECIMAL = 0x0D,
+  INTEGER = 0x0F,
+  LONG = 0x10,
+  UNSIGNED = 0x11,
+  LONG_UNSIGNED = 0x12,
+  LONG64 = 0x14,
+  LONG64_UNSIGNED = 0x15,
+  ENUM = 0x16,
+  FLOAT32 = 0x17,
+  FLOAT64 = 0x18,
+  DATE_TIME = 0x19,
+  DATE = 0x1A,
+  TIME = 0x1B,
+
+  ARRAY = 0x01,
+  STRUCTURE = 0x02,
+  COMPACT_ARRAY = 0x13
+};
+
+enum Medium {
+  ABSTRACT = 0x00,
+  ELECTRICITY = 0x01,
+  HEAT_COST_ALLOCATOR = 0x04,
+  COOLING = 0x05,
+  HEAT = 0x06,
+  GAS = 0x07,
+  COLD_WATER = 0x08,
+  HOT_WATER = 0x09,
+  OIL = 0x10,
+  COMPRESSED_AIR = 0x11,
+  NITROGEN = 0x12
+};
+
+// Data structure
+static constexpr uint8_t DECODER_START_OFFSET = 20;  // Skip header, timestamp and break block
+static constexpr uint8_t OBIS_TYPE_OFFSET = 0;
+static constexpr uint8_t OBIS_LENGTH_OFFSET = 1;
+static constexpr uint8_t OBIS_CODE_OFFSET = 2;
+static constexpr uint8_t OBIS_CODE_LENGTH_STANDARD = 0x06;  // 6-byte OBIS code (A.B.C.D.E.F)
+static constexpr uint8_t OBIS_CODE_LENGTH_EXTENDED = 0x0C;  // 12-byte extended OBIS code
+static constexpr uint8_t OBIS_A = 0;
+static constexpr uint8_t OBIS_B = 1;
+static constexpr uint8_t OBIS_C = 2;
+static constexpr uint8_t OBIS_D = 3;
+static constexpr uint8_t OBIS_E = 4;
+static constexpr uint8_t OBIS_F = 5;
+
+// Metadata
+static constexpr uint16_t OBIS_TIMESTAMP = 0x0100;
+static constexpr uint16_t OBIS_SERIAL_NUMBER = 0x6001;
+static constexpr uint16_t OBIS_DEVICE_NAME = 0x2A00;
+
+// Voltage
+static constexpr uint16_t OBIS_VOLTAGE_L1 = 0x2007;
+static constexpr uint16_t OBIS_VOLTAGE_L2 = 0x3407;
+static constexpr uint16_t OBIS_VOLTAGE_L3 = 0x4807;
+
+// Current
+static constexpr uint16_t OBIS_CURRENT_L1 = 0x1F07;
+static constexpr uint16_t OBIS_CURRENT_L2 = 0x3307;
+static constexpr uint16_t OBIS_CURRENT_L3 = 0x4707;
+
+// Power
+static constexpr uint16_t OBIS_ACTIVE_POWER_PLUS = 0x0107;
+static constexpr uint16_t OBIS_ACTIVE_POWER_MINUS = 0x0207;
+
+// Active energy
+static constexpr uint16_t OBIS_ACTIVE_ENERGY_PLUS = 0x0108;
+static constexpr uint16_t OBIS_ACTIVE_ENERGY_MINUS = 0x0208;
+
+// Reactive energy
+static constexpr uint16_t OBIS_REACTIVE_ENERGY_PLUS = 0x0308;
+static constexpr uint16_t OBIS_REACTIVE_ENERGY_MINUS = 0x0408;
+
+// Netz NOE specific
+static constexpr uint16_t OBIS_POWER_FACTOR = 0x0D07;
+
+}  // namespace esphome::dlms_meter

esphome/components/dlms_meter/sensor/__init__.py

@@ -0,0 +1,124 @@
+import esphome.codegen as cg
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_POWER_FACTOR,
+    DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
+    STATE_CLASS_TOTAL_INCREASING,
+    UNIT_AMPERE,
+    UNIT_VOLT,
+    UNIT_WATT,
+    UNIT_WATT_HOURS,
+)
+
+from .. import CONF_DLMS_METER_ID, DlmsMeterComponent
+
+AUTO_LOAD = ["dlms_meter"]
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_DLMS_METER_ID): cv.use_id(DlmsMeterComponent),
+        cv.Optional("voltage_l1"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=1,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("voltage_l2"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=1,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("voltage_l3"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=1,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("current_l1"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_AMPERE,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_CURRENT,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("current_l2"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_AMPERE,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_CURRENT,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("current_l3"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_AMPERE,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_CURRENT,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("active_power_plus"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_POWER,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("active_power_minus"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_POWER,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("active_energy_plus"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT_HOURS,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_ENERGY,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
+        ),
+        cv.Optional("active_energy_minus"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT_HOURS,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_ENERGY,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
+        ),
+        cv.Optional("reactive_energy_plus"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT_HOURS,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_ENERGY,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
+        ),
+        cv.Optional("reactive_energy_minus"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT_HOURS,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_ENERGY,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
+        ),
+        # Netz NOE
+        cv.Optional("power_factor"): sensor.sensor_schema(
+            accuracy_decimals=3,
+            device_class=DEVICE_CLASS_POWER_FACTOR,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_DLMS_METER_ID])
+
+    sensors = []
+    for key, conf in config.items():
+        if not isinstance(conf, dict):
+            continue
+        id = conf[CONF_ID]
+        if id and id.type == sensor.Sensor:
+            sens = await sensor.new_sensor(conf)
+            cg.add(getattr(hub, f"set_{key}_sensor")(sens))
+            sensors.append(f"F({key})")
+
+    if sensors:
+        cg.add_define(
+            "DLMS_METER_SENSOR_LIST(F, sep)", cg.RawExpression(" sep ".join(sensors))
+        )

esphome/components/dlms_meter/text_sensor/__init__.py

@@ -0,0 +1,37 @@
+import esphome.codegen as cg
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+
+from .. import CONF_DLMS_METER_ID, DlmsMeterComponent
+
+AUTO_LOAD = ["dlms_meter"]
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_DLMS_METER_ID): cv.use_id(DlmsMeterComponent),
+        cv.Optional("timestamp"): text_sensor.text_sensor_schema(),
+        # Netz NOE
+        cv.Optional("meternumber"): text_sensor.text_sensor_schema(),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_DLMS_METER_ID])
+
+    text_sensors = []
+    for key, conf in config.items():
+        if not isinstance(conf, dict):
+            continue
+        id = conf[CONF_ID]
+        if id and id.type == text_sensor.TextSensor:
+            sens = await text_sensor.new_text_sensor(conf)
+            cg.add(getattr(hub, f"set_{key}_text_sensor")(sens))
+            text_sensors.append(f"F({key})")
+
+    if text_sensors:
+        cg.add_define(
+            "DLMS_METER_TEXT_SENSOR_LIST(F, sep)",
+            cg.RawExpression(" sep ".join(text_sensors)),
+        )

esphome/components/esp32/__init__.py

@@ -1329,6 +1329,10 @@ async def to_code(config):
     # Disable dynamic log level control to save memory
     add_idf_sdkconfig_option("CONFIG_LOG_DYNAMIC_LEVEL_CONTROL", False)
 
+    # Disable per-tag log level filtering since dynamic level control is disabled above
+    # This saves ~250 bytes of RAM (tag cache) and associated code
+    add_idf_sdkconfig_option("CONFIG_LOG_TAG_LEVEL_IMPL_NONE", True)
+
     # Reduce PHY TX power in the event of a brownout
     add_idf_sdkconfig_option("CONFIG_ESP_PHY_REDUCE_TX_POWER", True)
 

esphome/components/i2c/i2c.cpp

@@ -11,12 +11,6 @@ namespace i2c {
 static const char *const TAG = "i2c";
 
 void I2CBus::i2c_scan_() {
-  // suppress logs from the IDF I2C library during the scan
-#if defined(USE_ESP32) && defined(USE_LOGGER)
-  auto previous = esp_log_level_get("*");
-  esp_log_level_set("*", ESP_LOG_NONE);
-#endif
-
   for (uint8_t address = 8; address != 120; address++) {
     auto err = write_readv(address, nullptr, 0, nullptr, 0);
     if (err == ERROR_OK) {
@@ -27,9 +21,6 @@ void I2CBus::i2c_scan_() {
     // it takes 16sec to scan on nrf52. It prevents board reset.
     arch_feed_wdt();
   }
-#if defined(USE_ESP32) && defined(USE_LOGGER)
-  esp_log_level_set("*", previous);
-#endif
 }
 
 ErrorCode I2CDevice::read_register(uint8_t a_register, uint8_t *data, size_t len) {

esphome/components/logger/logger_esp32.cpp

@@ -114,9 +114,6 @@ void Logger::pre_setup() {
 
   global_logger = this;
   esp_log_set_vprintf(esp_idf_log_vprintf_);
-  if (ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE) {
-    esp_log_level_set("*", ESP_LOG_VERBOSE);
-  }
 
   ESP_LOGI(TAG, "Log initialized");
 }

esphome/components/max7219/display.py

@@ -28,11 +28,10 @@ CONFIG_SCHEMA = (
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = cg.new_Pvariable(config[CONF_ID], config[CONF_NUM_CHIPS])
     await spi.register_spi_device(var, config, write_only=True)
     await display.register_display(var, config)
 
-    cg.add(var.set_num_chips(config[CONF_NUM_CHIPS]))
     cg.add(var.set_intensity(config[CONF_INTENSITY]))
     cg.add(var.set_reverse(config[CONF_REVERSE_ENABLE]))
 

esphome/components/max7219/max7219.cpp

@@ -3,8 +3,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace max7219 {
+namespace esphome::max7219 {
 
 static const char *const TAG = "max7219";
 
@@ -115,12 +114,14 @@ const uint8_t MAX7219_ASCII_TO_RAW[95] PROGMEM = {
 };
 
 float MAX7219Component::get_setup_priority() const { return setup_priority::PROCESSOR; }
+
+MAX7219Component::MAX7219Component(uint8_t num_chips) : num_chips_(num_chips) {
+  this->buffer_ = new uint8_t[this->num_chips_ * 8];  // NOLINT
+  memset(this->buffer_, 0, this->num_chips_ * 8);
+}
+
 void MAX7219Component::setup() {
   this->spi_setup();
-  this->buffer_ = new uint8_t[this->num_chips_ * 8];  // NOLINT
-  for (uint8_t i = 0; i < this->num_chips_ * 8; i++)
-    this->buffer_[i] = 0;
-
   // let's assume the user has all 8 digits connected, only important in daisy chained setups anyway
   this->send_to_all_(MAX7219_REGISTER_SCAN_LIMIT, 7);
   // let's use our own ASCII -> led pattern encoding
@@ -229,7 +230,6 @@ void MAX7219Component::set_intensity(uint8_t intensity) {
     this->intensity_ = intensity;
   }
 }
-void MAX7219Component::set_num_chips(uint8_t num_chips) { this->num_chips_ = num_chips; }
 
 uint8_t MAX7219Component::strftime(uint8_t pos, const char *format, ESPTime time) {
   char buffer[64];
@@ -240,5 +240,4 @@ uint8_t MAX7219Component::strftime(uint8_t pos, const char *format, ESPTime time
 }
 uint8_t MAX7219Component::strftime(const char *format, ESPTime time) { return this->strftime(0, format, time); }
 
-}  // namespace max7219
-}  // namespace esphome
+}  // namespace esphome::max7219

esphome/components/max7219/max7219.h

@@ -6,8 +6,7 @@
 #include "esphome/components/spi/spi.h"
 #include "esphome/components/display/display.h"
 
-namespace esphome {
-namespace max7219 {
+namespace esphome::max7219 {
 
 class MAX7219Component;
 
@@ -17,6 +16,8 @@ class MAX7219Component : public PollingComponent,
                          public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW,
                                                spi::CLOCK_PHASE_LEADING, spi::DATA_RATE_1MHZ> {
  public:
+  explicit MAX7219Component(uint8_t num_chips);
+
   void set_writer(max7219_writer_t &&writer);
 
   void setup() override;
@@ -30,7 +31,6 @@ class MAX7219Component : public PollingComponent,
   void display();
 
   void set_intensity(uint8_t intensity);
-  void set_num_chips(uint8_t num_chips);
   void set_reverse(bool reverse) { this->reverse_ = reverse; };
 
   /// Evaluate the printf-format and print the result at the given position.
@@ -56,10 +56,9 @@ class MAX7219Component : public PollingComponent,
   uint8_t intensity_{15};     // Intensity of the display from 0 to 15 (most)
   bool intensity_changed_{};  // True if we need to re-send the intensity
   uint8_t num_chips_{1};
-  uint8_t *buffer_;
+  uint8_t *buffer_{nullptr};
   bool reverse_{false};
   max7219_writer_t writer_{};
 };
 
-}  // namespace max7219
-}  // namespace esphome
+}  // namespace esphome::max7219

esphome/components/mipi_spi/mipi_spi.cpp

@@ -1,6 +1,39 @@
 #include "mipi_spi.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace mipi_spi {}  // namespace mipi_spi
-}  // namespace esphome
+namespace esphome::mipi_spi {
+
+void internal_dump_config(const char *model, int width, int height, int offset_width, int offset_height, uint8_t madctl,
+                          bool invert_colors, int display_bits, bool is_big_endian, const optional<uint8_t> &brightness,
+                          GPIOPin *cs, GPIOPin *reset, GPIOPin *dc, int spi_mode, uint32_t data_rate, int bus_width) {
+  ESP_LOGCONFIG(TAG,
+                "MIPI_SPI Display\n"
+                "  Model: %s\n"
+                "  Width: %d\n"
+                "  Height: %d\n"
+                "  Swap X/Y: %s\n"
+                "  Mirror X: %s\n"
+                "  Mirror Y: %s\n"
+                "  Invert colors: %s\n"
+                "  Color order: %s\n"
+                "  Display pixels: %d bits\n"
+                "  Endianness: %s\n"
+                "  SPI Mode: %d\n"
+                "  SPI Data rate: %uMHz\n"
+                "  SPI Bus width: %d",
+                model, width, height, YESNO(madctl & MADCTL_MV), YESNO(madctl & (MADCTL_MX | MADCTL_XFLIP)),
+                YESNO(madctl & (MADCTL_MY | MADCTL_YFLIP)), YESNO(invert_colors), (madctl & MADCTL_BGR) ? "BGR" : "RGB",
+                display_bits, is_big_endian ? "Big" : "Little", spi_mode, static_cast<unsigned>(data_rate / 1000000),
+                bus_width);
+  LOG_PIN("  CS Pin: ", cs);
+  LOG_PIN("  Reset Pin: ", reset);
+  LOG_PIN("  DC Pin: ", dc);
+  if (offset_width != 0)
+    ESP_LOGCONFIG(TAG, "  Offset width: %d", offset_width);
+  if (offset_height != 0)
+    ESP_LOGCONFIG(TAG, "  Offset height: %d", offset_height);
+  if (brightness.has_value())
+    ESP_LOGCONFIG(TAG, "  Brightness: %u", brightness.value());
+}
+
+}  // namespace esphome::mipi_spi

esphome/components/mipi_spi/mipi_spi.h

@@ -63,6 +63,11 @@ enum BusType {
   BUS_TYPE_SINGLE_16 = 16,  // Single bit bus, but 16 bits per transfer
 };
 
+// Helper function for dump_config - defined in mipi_spi.cpp to allow use of LOG_PIN macro
+void internal_dump_config(const char *model, int width, int height, int offset_width, int offset_height, uint8_t madctl,
+                          bool invert_colors, int display_bits, bool is_big_endian, const optional<uint8_t> &brightness,
+                          GPIOPin *cs, GPIOPin *reset, GPIOPin *dc, int spi_mode, uint32_t data_rate, int bus_width);
+
 /**
  * Base class for MIPI SPI displays.
  * All the methods are defined here in the header file, as it is not possible to define templated methods in a cpp file.
@@ -201,37 +206,9 @@ class MipiSpi : public display::Display,
   }
 
   void dump_config() override {
-    esph_log_config(TAG,
-                    "MIPI_SPI Display\n"
-                    "  Model: %s\n"
-                    "  Width: %u\n"
-                    "  Height: %u",
-                    this->model_, WIDTH, HEIGHT);
-    if constexpr (OFFSET_WIDTH != 0)
-      esph_log_config(TAG, "  Offset width: %u", OFFSET_WIDTH);
-    if constexpr (OFFSET_HEIGHT != 0)
-      esph_log_config(TAG, "  Offset height: %u", OFFSET_HEIGHT);
-    esph_log_config(TAG,
-                    "  Swap X/Y: %s\n"
-                    "  Mirror X: %s\n"
-                    "  Mirror Y: %s\n"
-                    "  Invert colors: %s\n"
-                    "  Color order: %s\n"
-                    "  Display pixels: %d bits\n"
-                    "  Endianness: %s\n",
-                    YESNO(this->madctl_ & MADCTL_MV), YESNO(this->madctl_ & (MADCTL_MX | MADCTL_XFLIP)),
-                    YESNO(this->madctl_ & (MADCTL_MY | MADCTL_YFLIP)), YESNO(this->invert_colors_),
-                    this->madctl_ & MADCTL_BGR ? "BGR" : "RGB", DISPLAYPIXEL * 8, IS_BIG_ENDIAN ? "Big" : "Little");
-    if (this->brightness_.has_value())
-      esph_log_config(TAG, "  Brightness: %u", this->brightness_.value());
-    log_pin(TAG, "  CS Pin: ", this->cs_);
-    log_pin(TAG, "  Reset Pin: ", this->reset_pin_);
-    log_pin(TAG, "  DC Pin: ", this->dc_pin_);
-    esph_log_config(TAG,
-                    "  SPI Mode: %d\n"
-                    "  SPI Data rate: %dMHz\n"
-                    "  SPI Bus width: %d",
-                    this->mode_, static_cast<unsigned>(this->data_rate_ / 1000000), BUS_TYPE);
+    internal_dump_config(this->model_, WIDTH, HEIGHT, OFFSET_WIDTH, OFFSET_HEIGHT, this->madctl_, this->invert_colors_,
+                         DISPLAYPIXEL * 8, IS_BIG_ENDIAN, this->brightness_, this->cs_, this->reset_pin_, this->dc_pin_,
+                         this->mode_, this->data_rate_, BUS_TYPE);
   }
 
  protected:

esphome/components/mqtt/mqtt_client.cpp

@@ -643,10 +643,34 @@ static bool topic_match(const char *message, const char *subscription) {
 }
 
 void MQTTClientComponent::on_message(const std::string &topic, const std::string &payload) {
-  for (auto &subscription : this->subscriptions_) {
-    if (topic_match(topic.c_str(), subscription.topic.c_str()))
-      subscription.callback(topic, payload);
-  }
+#ifdef USE_ESP8266
+  // IMPORTANT: This defer is REQUIRED to prevent stack overflow crashes on ESP8266.
+  //
+  // On ESP8266, this callback is invoked directly from the lwIP/AsyncTCP network stack
+  // which runs in the "sys" context with a very limited stack (~4KB). By the time we
+  // reach this function, the stack is already partially consumed by the network
+  // processing chain: tcp_input -> AsyncClient::_recv -> AsyncMqttClient::_onMessage -> here.
+  //
+  // MQTT subscription callbacks can trigger arbitrary user actions (automations, HTTP
+  // requests, sensor updates, etc.) which may have deep call stacks of their own.
+  // For example, an HTTP request action requires: DNS lookup -> TCP connect -> TLS
+  // handshake (if HTTPS) -> request formatting. This easily overflows the remaining
+  // system stack space, causing a LoadStoreAlignmentCause exception or silent corruption.
+  //
+  // By deferring to the main loop, we ensure callbacks execute with a fresh, full-size
+  // stack in the normal application context rather than the constrained network task.
+  //
+  // DO NOT REMOVE THIS DEFER without understanding the above. It may appear to work
+  // in simple tests but will cause crashes with complex automations.
+  this->defer([this, topic, payload]() {
+#endif
+    for (auto &subscription : this->subscriptions_) {
+      if (topic_match(topic.c_str(), subscription.topic.c_str()))
+        subscription.callback(topic, payload);
+    }
+#ifdef USE_ESP8266
+  });
+#endif
 }
 
 // Setters

esphome/components/pmsx003/pmsx003.cpp

@@ -181,17 +181,20 @@ optional<bool> PMSX003Component::check_byte_() {
 bool PMSX003Component::check_payload_length_(uint16_t payload_length) {
   // https://avaldebe.github.io/PyPMS/sensors/Plantower/
   switch (this->type_) {
-    case Type::PMSX003:
-      // The expected payload length is typically 28 bytes.
-      // However, a 20-byte payload check was already present in the code.
-      // No official documentation was found confirming this.
-      // Retaining this check to avoid breaking existing behavior.
+    case Type::PMS1003:
+      return payload_length == 28;  // 2*13+2
+    case Type::PMS3003:             // Data 7/8/9 not set/reserved
+      return payload_length == 20;  // 2*9+2
+    case Type::PMSX003:             // Data 13 not set/reserved
+      // Deprecated: Length 20 is for PMS3003 backwards compatibility
       return payload_length == 28 || payload_length == 20;  // 2*13+2
     case Type::PMS5003S:
-    case Type::PMS5003T:
-      return payload_length == 28;  // 2*13+2 (Data 13 not set/reserved)
-    case Type::PMS5003ST:
-      return payload_length == 36;  // 2*17+2 (Data 16 not set/reserved)
+    case Type::PMS5003T:            // Data 13 not set/reserved
+      return payload_length == 28;  // 2*13+2
+    case Type::PMS5003ST:           // Data 16 not set/reserved
+      return payload_length == 36;  // 2*17+2
+    case Type::PMS9003M:
+      return payload_length == 28;  // 2*13+2
   }
   return false;
 }
@@ -314,9 +317,10 @@ void PMSX003Component::parse_data_() {
   }
 
   // Firmware Version and Error Code
-  if (this->type_ == Type::PMS5003ST) {
-    const uint8_t firmware_version = this->data_[36];
-    const uint8_t error_code = this->data_[37];
+  if (this->type_ == Type::PMS1003 || this->type_ == Type::PMS5003ST || this->type_ == Type::PMS9003M) {
+    const uint8_t firmware_error_code_offset = (this->type_ == Type::PMS5003ST) ? 36 : 28;
+    const uint8_t firmware_version = this->data_[firmware_error_code_offset];
+    const uint8_t error_code = this->data_[firmware_error_code_offset + 1];
 
     ESP_LOGD(TAG, "Got Firmware Version: 0x%02X, Error Code: 0x%02X", firmware_version, error_code);
   }

esphome/components/pmsx003/pmsx003.h

@@ -8,10 +8,13 @@
 namespace esphome::pmsx003 {
 
 enum class Type : uint8_t {
-  PMSX003 = 0,
+  PMS1003 = 0,
+  PMS3003,
+  PMSX003,  // PMS5003, PMS6003, PMS7003, PMSA003 (NOT PMSA003I - see `pmsa003i` component)
   PMS5003S,
   PMS5003T,
   PMS5003ST,
+  PMS9003M,
 };
 
 enum class Command : uint8_t {

esphome/components/pmsx003/sensor.py

@@ -40,33 +40,127 @@ pmsx003_ns = cg.esphome_ns.namespace("pmsx003")
 PMSX003Component = pmsx003_ns.class_("PMSX003Component", uart.UARTDevice, cg.Component)
 PMSX003Sensor = pmsx003_ns.class_("PMSX003Sensor", sensor.Sensor)
 
-TYPE_PMSX003 = "PMSX003"
+TYPE_PMS1003 = "PMS1003"
+TYPE_PMS3003 = "PMS3003"
+TYPE_PMSX003 = "PMSX003"  # PMS5003, PMS6003, PMS7003, PMSA003 (NOT PMSA003I - see `pmsa003i` component)
 TYPE_PMS5003S = "PMS5003S"
 TYPE_PMS5003T = "PMS5003T"
 TYPE_PMS5003ST = "PMS5003ST"
+TYPE_PMS9003M = "PMS9003M"
 
 Type = pmsx003_ns.enum("Type", is_class=True)
 
 PMSX003_TYPES = {
+    TYPE_PMS1003: Type.PMS1003,
+    TYPE_PMS3003: Type.PMS3003,
     TYPE_PMSX003: Type.PMSX003,
     TYPE_PMS5003S: Type.PMS5003S,
     TYPE_PMS5003T: Type.PMS5003T,
     TYPE_PMS5003ST: Type.PMS5003ST,
+    TYPE_PMS9003M: Type.PMS9003M,
 }
 
 SENSORS_TO_TYPE = {
-    CONF_PM_1_0_STD: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
-    CONF_PM_2_5_STD: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
-    CONF_PM_10_0_STD: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
-    CONF_PM_1_0: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
-    CONF_PM_2_5: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
-    CONF_PM_10_0: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
-    CONF_PM_0_3UM: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
-    CONF_PM_0_5UM: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
-    CONF_PM_1_0UM: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
-    CONF_PM_2_5UM: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003T, TYPE_PMS5003ST],
-    CONF_PM_5_0UM: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003ST],
-    CONF_PM_10_0UM: [TYPE_PMSX003, TYPE_PMS5003S, TYPE_PMS5003ST],
+    CONF_PM_1_0_STD: [
+        TYPE_PMS1003,
+        TYPE_PMS3003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_2_5_STD: [
+        TYPE_PMS1003,
+        TYPE_PMS3003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_10_0_STD: [
+        TYPE_PMS1003,
+        TYPE_PMS3003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_1_0: [
+        TYPE_PMS1003,
+        TYPE_PMS3003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_2_5: [
+        TYPE_PMS1003,
+        TYPE_PMS3003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_10_0: [
+        TYPE_PMS1003,
+        TYPE_PMS3003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_0_3UM: [
+        TYPE_PMS1003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_0_5UM: [
+        TYPE_PMS1003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_1_0UM: [
+        TYPE_PMS1003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_2_5UM: [
+        TYPE_PMS1003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003T,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_5_0UM: [
+        TYPE_PMS1003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
+    CONF_PM_10_0UM: [
+        TYPE_PMS1003,
+        TYPE_PMSX003,
+        TYPE_PMS5003S,
+        TYPE_PMS5003ST,
+        TYPE_PMS9003M,
+    ],
     CONF_FORMALDEHYDE: [TYPE_PMS5003S, TYPE_PMS5003ST],
     CONF_TEMPERATURE: [TYPE_PMS5003T, TYPE_PMS5003ST],
     CONF_HUMIDITY: [TYPE_PMS5003T, TYPE_PMS5003ST],

esphome/components/time/posix_tz.cpp

@@ -1,481 +0,0 @@
-#include "esphome/core/defines.h"
-
-#ifdef USE_TIME_TIMEZONE
-
-#include "posix_tz.h"
-#include <cctype>
-
-namespace esphome::time {
-
-// Global timezone - set once at startup, rarely changes
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) - intentional mutable state
-static ParsedTimezone global_tz_{};
-
-void set_global_tz(const ParsedTimezone &tz) { global_tz_ = tz; }
-
-const ParsedTimezone &get_global_tz() { return global_tz_; }
-
-namespace internal {
-
-// Helper to parse an unsigned integer from string, updating pointer
-static uint32_t parse_uint(const char *&p) {
-  uint32_t value = 0;
-  while (std::isdigit(static_cast<unsigned char>(*p))) {
-    value = value * 10 + (*p - '0');
-    p++;
-  }
-  return value;
-}
-
-bool is_leap_year(int year) { return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); }
-
-// Get days in year (avoids duplicate is_leap_year calls)
-static inline int days_in_year(int year) { return is_leap_year(year) ? 366 : 365; }
-
-// Convert days since epoch to year, updating days to remainder
-static int __attribute__((noinline)) days_to_year(int64_t &days) {
-  int year = 1970;
-  int diy;
-  while (days >= (diy = days_in_year(year))) {
-    days -= diy;
-    year++;
-  }
-  while (days < 0) {
-    year--;
-    days += days_in_year(year);
-  }
-  return year;
-}
-
-// Extract just the year from a UTC epoch
-static int epoch_to_year(time_t epoch) {
-  int64_t days = epoch / 86400;
-  if (epoch < 0 && epoch % 86400 != 0)
-    days--;
-  return days_to_year(days);
-}
-
-int days_in_month(int year, int month) {
-  switch (month) {
-    case 2:
-      return is_leap_year(year) ? 29 : 28;
-    case 4:
-    case 6:
-    case 9:
-    case 11:
-      return 30;
-    default:
-      return 31;
-  }
-}
-
-// Zeller-like algorithm for day of week (0 = Sunday)
-int __attribute__((noinline)) day_of_week(int year, int month, int day) {
-  // Adjust for January/February
-  if (month < 3) {
-    month += 12;
-    year--;
-  }
-  int k = year % 100;
-  int j = year / 100;
-  int h = (day + (13 * (month + 1)) / 5 + k + k / 4 + j / 4 - 2 * j) % 7;
-  // Convert from Zeller (0=Sat) to standard (0=Sun)
-  return ((h + 6) % 7);
-}
-
-void __attribute__((noinline)) epoch_to_tm_utc(time_t epoch, struct tm *out_tm) {
-  // Days since epoch
-  int64_t days = epoch / 86400;
-  int32_t remaining_secs = epoch % 86400;
-  if (remaining_secs < 0) {
-    days--;
-    remaining_secs += 86400;
-  }
-
-  out_tm->tm_sec = remaining_secs % 60;
-  remaining_secs /= 60;
-  out_tm->tm_min = remaining_secs % 60;
-  out_tm->tm_hour = remaining_secs / 60;
-
-  // Day of week (Jan 1, 1970 was Thursday = 4)
-  out_tm->tm_wday = static_cast<int>((days + 4) % 7);
-  if (out_tm->tm_wday < 0)
-    out_tm->tm_wday += 7;
-
-  // Calculate year (updates days to day-of-year)
-  int year = days_to_year(days);
-  out_tm->tm_year = year - 1900;
-  out_tm->tm_yday = static_cast<int>(days);
-
-  // Calculate month and day
-  int month = 1;
-  int dim;
-  while (days >= (dim = days_in_month(year, month))) {
-    days -= dim;
-    month++;
-  }
-
-  out_tm->tm_mon = month - 1;
-  out_tm->tm_mday = static_cast<int>(days) + 1;
-  out_tm->tm_isdst = 0;
-}
-
-bool skip_tz_name(const char *&p) {
-  if (*p == '<') {
-    // Angle-bracket quoted name: <+07>, <-03>, <AEST>
-    p++;  // skip '<'
-    while (*p && *p != '>') {
-      p++;
-    }
-    if (*p == '>') {
-      p++;  // skip '>'
-      return true;
-    }
-    return false;  // Unterminated
-  }
-
-  // Standard name: 3+ letters
-  const char *start = p;
-  while (*p && std::isalpha(static_cast<unsigned char>(*p))) {
-    p++;
-  }
-  return (p - start) >= 3;
-}
-
-int32_t __attribute__((noinline)) parse_offset(const char *&p) {
-  int sign = 1;
-  if (*p == '-') {
-    sign = -1;
-    p++;
-  } else if (*p == '+') {
-    p++;
-  }
-
-  int hours = parse_uint(p);
-  int minutes = 0;
-  int seconds = 0;
-
-  if (*p == ':') {
-    p++;
-    minutes = parse_uint(p);
-    if (*p == ':') {
-      p++;
-      seconds = parse_uint(p);
-    }
-  }
-
-  return sign * (hours * 3600 + minutes * 60 + seconds);
-}
-
-// Helper to parse the optional /time suffix (reuses parse_offset logic)
-static void parse_transition_time(const char *&p, DSTRule &rule) {
-  rule.time_seconds = 2 * 3600;  // Default 02:00
-  if (*p == '/') {
-    p++;
-    rule.time_seconds = parse_offset(p);
-  }
-}
-
-void __attribute__((noinline)) julian_to_month_day(int julian_day, int &out_month, int &out_day) {
-  // J format: day 1-365, Feb 29 is NOT counted even in leap years
-  // So day 60 is always March 1
-  // Iterate forward through months (no array needed)
-  int remaining = julian_day;
-  out_month = 1;
-  while (out_month <= 12) {
-    // Days in month for non-leap year (J format ignores leap years)
-    int dim = days_in_month(2001, out_month);  // 2001 is non-leap year
-    if (remaining <= dim) {
-      out_day = remaining;
-      return;
-    }
-    remaining -= dim;
-    out_month++;
-  }
-  out_day = remaining;
-}
-
-void __attribute__((noinline)) day_of_year_to_month_day(int day_of_year, int year, int &out_month, int &out_day) {
-  // Plain format: day 0-365, Feb 29 IS counted in leap years
-  // Day 0 = Jan 1
-  int remaining = day_of_year;
-  out_month = 1;
-
-  while (out_month <= 12) {
-    int days_this_month = days_in_month(year, out_month);
-    if (remaining < days_this_month) {
-      out_day = remaining + 1;
-      return;
-    }
-    remaining -= days_this_month;
-    out_month++;
-  }
-
-  // Shouldn't reach here with valid input
-  out_month = 12;
-  out_day = 31;
-}
-
-bool parse_dst_rule(const char *&p, DSTRule &rule) {
-  rule = {};  // Zero initialize
-
-  if (*p == 'M' || *p == 'm') {
-    // M format: Mm.w.d (month.week.day)
-    rule.type = DSTRuleType::MONTH_WEEK_DAY;
-    p++;
-
-    rule.month = parse_uint(p);
-    if (rule.month < 1 || rule.month > 12)
-      return false;
-
-    if (*p++ != '.')
-      return false;
-
-    rule.week = parse_uint(p);
-    if (rule.week < 1 || rule.week > 5)
-      return false;
-
-    if (*p++ != '.')
-      return false;
-
-    rule.day_of_week = parse_uint(p);
-    if (rule.day_of_week > 6)
-      return false;
-
-  } else if (*p == 'J' || *p == 'j') {
-    // J format: Jn (Julian day 1-365, not counting Feb 29)
-    rule.type = DSTRuleType::JULIAN_NO_LEAP;
-    p++;
-
-    rule.day = parse_uint(p);
-    if (rule.day < 1 || rule.day > 365)
-      return false;
-
-  } else if (std::isdigit(static_cast<unsigned char>(*p))) {
-    // Plain number format: n (day 0-365, counting Feb 29)
-    rule.type = DSTRuleType::DAY_OF_YEAR;
-
-    rule.day = parse_uint(p);
-    if (rule.day > 365)
-      return false;
-
-  } else {
-    return false;
-  }
-
-  // Parse optional /time suffix
-  parse_transition_time(p, rule);
-
-  return true;
-}
-
-// Calculate days from Jan 1 of given year to given month/day
-static int __attribute__((noinline)) days_from_year_start(int year, int month, int day) {
-  int days = day - 1;
-  for (int m = 1; m < month; m++) {
-    days += days_in_month(year, m);
-  }
-  return days;
-}
-
-// Calculate days from epoch to Jan 1 of given year (for DST transition calculations)
-// Only supports years >= 1970. Timezone is either compiled in from YAML or set by
-// Home Assistant, so pre-1970 dates are not a concern.
-static int64_t __attribute__((noinline)) days_to_year_start(int year) {
-  int64_t days = 0;
-  for (int y = 1970; y < year; y++) {
-    days += days_in_year(y);
-  }
-  return days;
-}
-
-time_t __attribute__((noinline)) calculate_dst_transition(int year, const DSTRule &rule, int32_t base_offset_seconds) {
-  int month, day;
-
-  switch (rule.type) {
-    case DSTRuleType::MONTH_WEEK_DAY: {
-      // Find the nth occurrence of day_of_week in the given month
-      int first_dow = day_of_week(year, rule.month, 1);
-
-      // Days until first occurrence of target day
-      int days_until_first = (rule.day_of_week - first_dow + 7) % 7;
-      int first_occurrence = 1 + days_until_first;
-
-      if (rule.week == 5) {
-        // "Last" occurrence - find the last one in the month
-        int dim = days_in_month(year, rule.month);
-        day = first_occurrence;
-        while (day + 7 <= dim) {
-          day += 7;
-        }
-      } else {
-        // nth occurrence
-        day = first_occurrence + (rule.week - 1) * 7;
-      }
-      month = rule.month;
-      break;
-    }
-
-    case DSTRuleType::JULIAN_NO_LEAP:
-      // J format: day 1-365, Feb 29 not counted
-      julian_to_month_day(rule.day, month, day);
-      break;
-
-    case DSTRuleType::DAY_OF_YEAR:
-      // Plain format: day 0-365, Feb 29 counted
-      day_of_year_to_month_day(rule.day, year, month, day);
-      break;
-
-    case DSTRuleType::NONE:
-      // Should never be called with NONE, but handle it gracefully
-      month = 1;
-      day = 1;
-      break;
-  }
-
-  // Calculate days from epoch to this date
-  int64_t days = days_to_year_start(year) + days_from_year_start(year, month, day);
-
-  // Convert to epoch and add transition time and base offset
-  return days * 86400 + rule.time_seconds + base_offset_seconds;
-}
-
-}  // namespace internal
-
-bool __attribute__((noinline)) is_in_dst(time_t utc_epoch, const ParsedTimezone &tz) {
-  if (!tz.has_dst()) {
-    return false;
-  }
-
-  int year = internal::epoch_to_year(utc_epoch);
-
-  // Calculate DST start and end for this year
-  // DST start transition happens in standard time
-  time_t dst_start = internal::calculate_dst_transition(year, tz.dst_start, tz.std_offset_seconds);
-  // DST end transition happens in daylight time
-  time_t dst_end = internal::calculate_dst_transition(year, tz.dst_end, tz.dst_offset_seconds);
-
-  if (dst_start < dst_end) {
-    // Northern hemisphere: DST is between start and end
-    return (utc_epoch >= dst_start && utc_epoch < dst_end);
-  } else {
-    // Southern hemisphere: DST is outside the range (wraps around year)
-    return (utc_epoch >= dst_start || utc_epoch < dst_end);
-  }
-}
-
-bool parse_posix_tz(const char *tz_string, ParsedTimezone &result) {
-  if (!tz_string || !*tz_string) {
-    return false;
-  }
-
-  const char *p = tz_string;
-
-  // Initialize result (dst_start/dst_end default to type=NONE, so has_dst() returns false)
-  result.std_offset_seconds = 0;
-  result.dst_offset_seconds = 0;
-  result.dst_start = {};
-  result.dst_end = {};
-
-  // Skip standard timezone name
-  if (!internal::skip_tz_name(p)) {
-    return false;
-  }
-
-  // Parse standard offset (required)
-  if (!*p || (!std::isdigit(static_cast<unsigned char>(*p)) && *p != '+' && *p != '-')) {
-    return false;
-  }
-  result.std_offset_seconds = internal::parse_offset(p);
-
-  // Check for DST name
-  if (!*p) {
-    return true;  // No DST
-  }
-
-  // If next char is comma, there's no DST name but there are rules (invalid)
-  if (*p == ',') {
-    return false;
-  }
-
-  // Check if there's something that looks like a DST name start
-  // (letter or angle bracket). If not, treat as trailing garbage and return success.
-  if (!std::isalpha(static_cast<unsigned char>(*p)) && *p != '<') {
-    return true;  // No DST, trailing characters ignored
-  }
-
-  if (!internal::skip_tz_name(p)) {
-    return false;  // Invalid DST name (started but malformed)
-  }
-
-  // Optional DST offset (default is std - 1 hour)
-  if (*p && *p != ',' && (std::isdigit(static_cast<unsigned char>(*p)) || *p == '+' || *p == '-')) {
-    result.dst_offset_seconds = internal::parse_offset(p);
-  } else {
-    result.dst_offset_seconds = result.std_offset_seconds - 3600;
-  }
-
-  // Parse DST rules (required when DST name is present)
-  if (*p != ',') {
-    // DST name without rules - treat as no DST since we can't determine transitions
-    return true;
-  }
-
-  p++;
-  if (!internal::parse_dst_rule(p, result.dst_start)) {
-    return false;
-  }
-
-  // Second rule is required per POSIX
-  if (*p != ',') {
-    return false;
-  }
-  p++;
-  // has_dst() now returns true since dst_start.type was set by parse_dst_rule
-  return internal::parse_dst_rule(p, result.dst_end);
-}
-
-bool epoch_to_local_tm(time_t utc_epoch, const ParsedTimezone &tz, struct tm *out_tm) {
-  if (!out_tm) {
-    return false;
-  }
-
-  // Determine DST status once (avoids duplicate is_in_dst calculation)
-  bool in_dst = is_in_dst(utc_epoch, tz);
-  int32_t offset = in_dst ? tz.dst_offset_seconds : tz.std_offset_seconds;
-
-  // Apply offset (POSIX offset is positive west, so subtract to get local)
-  time_t local_epoch = utc_epoch - offset;
-
-  internal::epoch_to_tm_utc(local_epoch, out_tm);
-  out_tm->tm_isdst = in_dst ? 1 : 0;
-
-  return true;
-}
-
-}  // namespace esphome::time
-
-#ifndef USE_HOST
-// Override libc's localtime functions to use our timezone on embedded platforms.
-// This allows user lambdas calling ::localtime() to get correct local time
-// without needing the TZ environment variable (which pulls in scanf bloat).
-// On host, we use the normal TZ mechanism since there's no memory constraint.
-
-// Thread-safe version
-extern "C" struct tm *localtime_r(const time_t *timer, struct tm *result) {
-  if (timer == nullptr || result == nullptr) {
-    return nullptr;
-  }
-  esphome::time::epoch_to_local_tm(*timer, esphome::time::get_global_tz(), result);
-  return result;
-}
-
-// Non-thread-safe version (uses static buffer, standard libc behavior)
-extern "C" struct tm *localtime(const time_t *timer) {
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  static struct tm localtime_buf;
-  return localtime_r(timer, &localtime_buf);
-}
-#endif  // !USE_HOST
-
-#endif  // USE_TIME_TIMEZONE

esphome/components/time/posix_tz.h

@@ -1,132 +0,0 @@
-#pragma once
-
-#ifdef USE_TIME_TIMEZONE
-
-#include <cstdint>
-#include <ctime>
-
-namespace esphome::time {
-
-/// Type of DST transition rule
-enum class DSTRuleType : uint8_t {
-  NONE = 0,        ///< No DST rule (used to indicate no DST)
-  MONTH_WEEK_DAY,  ///< M format: Mm.w.d (e.g., M3.2.0 = 2nd Sunday of March)
-  JULIAN_NO_LEAP,  ///< J format: Jn (day 1-365, Feb 29 not counted)
-  DAY_OF_YEAR,     ///< Plain number: n (day 0-365, Feb 29 counted in leap years)
-};
-
-/// Rule for DST transition (packed for 32-bit: 12 bytes)
-struct DSTRule {
-  int32_t time_seconds;  ///< Seconds after midnight (default 7200 = 2:00 AM)
-  uint16_t day;          ///< Day of year (for JULIAN_NO_LEAP and DAY_OF_YEAR)
-  DSTRuleType type;      ///< Type of rule
-  uint8_t month;         ///< Month 1-12 (for MONTH_WEEK_DAY)
-  uint8_t week;          ///< Week 1-5, 5 = last (for MONTH_WEEK_DAY)
-  uint8_t day_of_week;   ///< Day 0-6, 0 = Sunday (for MONTH_WEEK_DAY)
-};
-
-/// Parsed POSIX timezone information (packed for 32-bit: 32 bytes)
-struct ParsedTimezone {
-  int32_t std_offset_seconds;  ///< Standard time offset from UTC in seconds (positive = west)
-  int32_t dst_offset_seconds;  ///< DST offset from UTC in seconds
-  DSTRule dst_start;           ///< When DST starts
-  DSTRule dst_end;             ///< When DST ends
-
-  /// Check if this timezone has DST rules
-  bool has_dst() const { return this->dst_start.type != DSTRuleType::NONE; }
-};
-
-/// Parse a POSIX TZ string into a ParsedTimezone struct.
-/// Supports formats like:
-///   - "EST5" (simple offset, no DST)
-///   - "EST5EDT,M3.2.0,M11.1.0" (with DST, M-format rules)
-///   - "CST6CDT,M3.2.0/2,M11.1.0/2" (with transition times)
-///   - "<+07>-7" (angle-bracket notation for special names)
-///   - "IST-5:30" (half-hour offsets)
-///   - "EST5EDT,J60,J300" (J-format: Julian day without leap day)
-///   - "EST5EDT,60,300" (plain day number: day of year with leap day)
-/// @param tz_string The POSIX TZ string to parse
-/// @param result Output: the parsed timezone data
-/// @return true if parsing succeeded, false on error
-bool parse_posix_tz(const char *tz_string, ParsedTimezone &result);
-
-/// Convert a UTC epoch to local time using the parsed timezone.
-/// This replaces libc's localtime() to avoid scanf dependency.
-/// @param utc_epoch Unix timestamp in UTC
-/// @param tz The parsed timezone
-/// @param[out] out_tm Output tm struct with local time
-/// @return true on success
-bool epoch_to_local_tm(time_t utc_epoch, const ParsedTimezone &tz, struct tm *out_tm);
-
-/// Set the global timezone used by epoch_to_local_tm() when called without a timezone.
-/// This is called by RealTimeClock::apply_timezone_() to enable ESPTime::from_epoch_local()
-/// to work without libc's localtime().
-void set_global_tz(const ParsedTimezone &tz);
-
-/// Get the global timezone.
-const ParsedTimezone &get_global_tz();
-
-/// Check if a given UTC epoch falls within DST for the parsed timezone.
-/// @param utc_epoch Unix timestamp in UTC
-/// @param tz The parsed timezone
-/// @return true if DST is in effect at the given time
-bool is_in_dst(time_t utc_epoch, const ParsedTimezone &tz);
-
-// Internal helper functions exposed for testing
-
-namespace internal {
-
-/// Skip a timezone name (letters or <...> quoted format)
-/// @param p Pointer to current position, updated on return
-/// @return true if a valid name was found
-bool skip_tz_name(const char *&p);
-
-/// Parse an offset in format [-]hh[:mm[:ss]]
-/// @param p Pointer to current position, updated on return
-/// @return Offset in seconds
-int32_t parse_offset(const char *&p);
-
-/// Parse a DST rule in format Mm.w.d[/time], Jn[/time], or n[/time]
-/// @param p Pointer to current position, updated on return
-/// @param rule Output: the parsed rule
-/// @return true if parsing succeeded
-bool parse_dst_rule(const char *&p, DSTRule &rule);
-
-/// Convert Julian day (J format, 1-365 not counting Feb 29) to month/day
-/// @param julian_day Day number 1-365
-/// @param[out] month Output: month 1-12
-/// @param[out] day Output: day of month
-void julian_to_month_day(int julian_day, int &month, int &day);
-
-/// Convert day of year (plain format, 0-365 counting Feb 29) to month/day
-/// @param day_of_year Day number 0-365
-/// @param year The year (for leap year calculation)
-/// @param[out] month Output: month 1-12
-/// @param[out] day Output: day of month
-void day_of_year_to_month_day(int day_of_year, int year, int &month, int &day);
-
-/// Calculate day of week for any date (0 = Sunday)
-/// Uses a simplified algorithm that works for years 1970-2099
-int day_of_week(int year, int month, int day);
-
-/// Get the number of days in a month
-int days_in_month(int year, int month);
-
-/// Check if a year is a leap year
-bool is_leap_year(int year);
-
-/// Convert epoch to year/month/day/hour/min/sec (UTC)
-void epoch_to_tm_utc(time_t epoch, struct tm *out_tm);
-
-/// Calculate the epoch timestamp for a DST transition in a given year.
-/// @param year The year (e.g., 2026)
-/// @param rule The DST rule (month, week, day_of_week, time)
-/// @param base_offset_seconds The timezone offset to apply (std or dst depending on context)
-/// @return Unix epoch timestamp of the transition
-time_t calculate_dst_transition(int year, const DSTRule &rule, int32_t base_offset_seconds);
-
-}  // namespace internal
-
-}  // namespace esphome::time
-
-#endif  // USE_TIME_TIMEZONE

esphome/components/time/real_time_clock.cpp

@@ -14,8 +14,8 @@
 #include <sys/time.h>
 #endif
 #include <cerrno>
+
 #include <cinttypes>
-#include <cstdlib>
 
 namespace esphome::time {
 
@@ -23,33 +23,9 @@ static const char *const TAG = "time";
 
 RealTimeClock::RealTimeClock() = default;
 
-ESPTime __attribute__((noinline)) RealTimeClock::now() {
-#ifdef USE_TIME_TIMEZONE
-  time_t epoch = this->timestamp_now();
-  struct tm local_tm;
-  if (epoch_to_local_tm(epoch, get_global_tz(), &local_tm)) {
-    return ESPTime::from_c_tm(&local_tm, epoch);
-  }
-  // Fallback to UTC if parsing failed
-  return ESPTime::from_epoch_utc(epoch);
-#else
-  return ESPTime::from_epoch_local(this->timestamp_now());
-#endif
-}
-
 void RealTimeClock::dump_config() {
 #ifdef USE_TIME_TIMEZONE
-  const auto &tz = get_global_tz();
-  // POSIX offset is positive west, negate for conventional UTC+X display
-  int std_h = -tz.std_offset_seconds / 3600;
-  int std_m = (std::abs(tz.std_offset_seconds) % 3600) / 60;
-  if (tz.has_dst()) {
-    int dst_h = -tz.dst_offset_seconds / 3600;
-    int dst_m = (std::abs(tz.dst_offset_seconds) % 3600) / 60;
-    ESP_LOGCONFIG(TAG, "Timezone: UTC%+d:%02d (DST UTC%+d:%02d)", std_h, std_m, dst_h, dst_m);
-  } else {
-    ESP_LOGCONFIG(TAG, "Timezone: UTC%+d:%02d", std_h, std_m);
-  }
+  ESP_LOGCONFIG(TAG, "Timezone: '%s'", this->timezone_.c_str());
 #endif
   auto time = this->now();
   ESP_LOGCONFIG(TAG, "Current time: %04d-%02d-%02d %02d:%02d:%02d", time.year, time.month, time.day_of_month, time.hour,
@@ -96,6 +72,11 @@ void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
     ret = settimeofday(&timev, nullptr);
   }
 
+#ifdef USE_TIME_TIMEZONE
+  // Move timezone back to local timezone.
+  this->apply_timezone_();
+#endif
+
   if (ret != 0) {
     ESP_LOGW(TAG, "setimeofday() failed with code %d", ret);
   }
@@ -108,29 +89,9 @@ void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
 }
 
 #ifdef USE_TIME_TIMEZONE
-void RealTimeClock::apply_timezone_(const char *tz) {
-  ParsedTimezone parsed{};
-
-  // Handle null or empty input - use UTC
-  if (tz == nullptr || *tz == '\0') {
-    set_global_tz(parsed);
-    return;
-  }
-
-#ifdef USE_HOST
-  // On host platform, also set TZ environment variable for libc compatibility
-  setenv("TZ", tz, 1);
+void RealTimeClock::apply_timezone_() {
+  setenv("TZ", this->timezone_.c_str(), 1);
   tzset();
-#endif
-
-  // Parse the POSIX TZ string using our custom parser
-  if (!parse_posix_tz(tz, parsed)) {
-    ESP_LOGW(TAG, "Failed to parse timezone: %s", tz);
-    // parsed stays as default (UTC) on failure
-  }
-
-  // Set global timezone for all time conversions
-  set_global_tz(parsed);
 }
 #endif
 

esphome/components/time/real_time_clock.h

@@ -6,9 +6,6 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/time.h"
-#ifdef USE_TIME_TIMEZONE
-#include "posix_tz.h"
-#endif
 
 namespace esphome::time {
 
@@ -23,31 +20,26 @@ class RealTimeClock : public PollingComponent {
   explicit RealTimeClock();
 
 #ifdef USE_TIME_TIMEZONE
-  /// Set the time zone from a POSIX TZ string.
-  void set_timezone(const char *tz) { this->apply_timezone_(tz); }
-
-  /// Set the time zone from a character buffer with known length.
-  /// The buffer does not need to be null-terminated.
-  void set_timezone(const char *tz, size_t len) {
-    if (tz == nullptr) {
-      this->apply_timezone_(nullptr);
-      return;
-    }
-    // Stack buffer - TZ strings from tzdata are typically short (< 50 chars)
-    char buf[128];
-    if (len >= sizeof(buf))
-      len = sizeof(buf) - 1;
-    memcpy(buf, tz, len);
-    buf[len] = '\0';
-    this->apply_timezone_(buf);
+  /// Set the time zone.
+  void set_timezone(const std::string &tz) {
+    this->timezone_ = tz;
+    this->apply_timezone_();
   }
 
-  /// Set the time zone from a std::string.
-  void set_timezone(const std::string &tz) { this->apply_timezone_(tz.c_str()); }
+  /// Set the time zone from raw buffer, only if it differs from the current one.
+  void set_timezone(const char *tz, size_t len) {
+    if (this->timezone_.length() != len || memcmp(this->timezone_.c_str(), tz, len) != 0) {
+      this->timezone_.assign(tz, len);
+      this->apply_timezone_();
+    }
+  }
+
+  /// Get the time zone currently in use.
+  std::string get_timezone() { return this->timezone_; }
 #endif
 
   /// Get the time in the currently defined timezone.
-  ESPTime now();
+  ESPTime now() { return ESPTime::from_epoch_local(this->timestamp_now()); }
 
   /// Get the time without any time zone or DST corrections.
   ESPTime utcnow() { return ESPTime::from_epoch_utc(this->timestamp_now()); }
@@ -66,7 +58,8 @@ class RealTimeClock : public PollingComponent {
   void synchronize_epoch_(uint32_t epoch);
 
 #ifdef USE_TIME_TIMEZONE
-  void apply_timezone_(const char *tz);
+  std::string timezone_{};
+  void apply_timezone_();
 #endif
 
   CallbackManager<void()> time_sync_callback_;

esphome/components/udp/__init__.py

@@ -12,8 +12,8 @@ from esphome.components.packet_transport import (
 )
 import esphome.config_validation as cv
 from esphome.const import CONF_DATA, CONF_ID, CONF_PORT, CONF_TRIGGER_ID
-from esphome.core import ID, Lambda
-from esphome.cpp_generator import ExpressionStatement, MockObj
+from esphome.core import ID
+from esphome.cpp_generator import literal
 
 CODEOWNERS = ["@clydebarrow"]
 DEPENDENCIES = ["network"]
@@ -24,6 +24,8 @@ udp_ns = cg.esphome_ns.namespace("udp")
 UDPComponent = udp_ns.class_("UDPComponent", cg.Component)
 UDPWriteAction = udp_ns.class_("UDPWriteAction", automation.Action)
 trigger_args = cg.std_vector.template(cg.uint8)
+trigger_argname = "data"
+trigger_argtype = [(trigger_args, trigger_argname)]
 
 CONF_ADDRESSES = "addresses"
 CONF_LISTEN_ADDRESS = "listen_address"
@@ -111,13 +113,14 @@ async def to_code(config):
     cg.add(var.set_addresses([str(addr) for addr in config[CONF_ADDRESSES]]))
     if on_receive := config.get(CONF_ON_RECEIVE):
         on_receive = on_receive[0]
-        trigger = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
+        trigger_id = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
         trigger = await automation.build_automation(
-            trigger, [(trigger_args, "data")], on_receive
+            trigger_id, trigger_argtype, on_receive
         )
-        trigger = Lambda(str(ExpressionStatement(trigger.trigger(MockObj("data")))))
-        trigger = await cg.process_lambda(trigger, [(trigger_args, "data")])
-        cg.add(var.add_listener(trigger))
+        trigger_lambda = await cg.process_lambda(
+            trigger.trigger(literal(trigger_argname)), trigger_argtype
+        )
+        cg.add(var.add_listener(trigger_lambda))
         cg.add(var.set_should_listen())
 
 

esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp

@@ -155,8 +155,9 @@ void USBCDCACMInstance::setup() {
     return;
   }
 
-  // Use a larger stack size for (very) verbose logging
-  const size_t stack_size = esp_log_level_get(TAG) > ESP_LOG_DEBUG ? USB_TX_TASK_STACK_SIZE_VV : USB_TX_TASK_STACK_SIZE;
+  // Use a larger stack size for very verbose logging
+  constexpr size_t stack_size =
+      ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE ? USB_TX_TASK_STACK_SIZE_VV : USB_TX_TASK_STACK_SIZE;
 
   // Create a simple, unique task name per interface
   char task_name[] = "usb_tx_0";

esphome/components/web_server_base/__init__.py

@@ -53,4 +53,4 @@ async def to_code(config):
                 "lib_ignore", ["ESPAsyncTCP", "AsyncTCP", "AsyncTCP_RP2040W"]
             )
         # https://github.com/ESP32Async/ESPAsyncWebServer/blob/main/library.json
-        cg.add_library("ESP32Async/ESPAsyncWebServer", "3.9.5")
+        cg.add_library("ESP32Async/ESPAsyncWebServer", "3.9.6")

esphome/core/__init__.py

@@ -278,9 +278,13 @@ LAMBDA_PROG = re.compile(r"\bid\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\)(\.?)")
 
 class Lambda:
     def __init__(self, value):
+        from esphome.cpp_generator import Expression, statement
+
         # pylint: disable=protected-access
         if isinstance(value, Lambda):
             self._value = value._value
+        elif isinstance(value, Expression):
+            self._value = str(statement(value))
         else:
             self._value = value
         self._parts = None

esphome/core/application.cpp

@@ -210,7 +210,7 @@ void Application::loop() {
 #ifdef USE_ESP32
       esp_chip_info_t chip_info;
       esp_chip_info(&chip_info);
-      ESP_LOGI(TAG, "ESP32 Chip: %s r%d.%d, %d core(s)", ESPHOME_VARIANT, chip_info.revision / 100,
+      ESP_LOGI(TAG, "ESP32 Chip: %s rev%d.%d, %d core(s)", ESPHOME_VARIANT, chip_info.revision / 100,
                chip_info.revision % 100, chip_info.cores);
 #if defined(USE_ESP32_VARIANT_ESP32) && !defined(USE_ESP32_MIN_CHIP_REVISION_SET)
       // Suggest optimization for chips that don't need the PSRAM cache workaround

esphome/core/time.cpp

@@ -2,6 +2,7 @@
 #include "helpers.h"
 
 #include <algorithm>
+#include <cinttypes>
 
 namespace esphome {
 
@@ -66,121 +67,56 @@ std::string ESPTime::strftime(const char *format) {
 
 std::string ESPTime::strftime(const std::string &format) { return this->strftime(format.c_str()); }
 
-// Helper to parse exactly N digits, returns false if not enough digits
-static bool parse_digits(const char *&p, const char *end, int count, uint16_t &value) {
-  value = 0;
-  for (int i = 0; i < count; i++) {
-    if (p >= end || *p < '0' || *p > '9')
-      return false;
-    value = value * 10 + (*p - '0');
-    p++;
-  }
-  return true;
-}
-
-// Helper to check for expected character
-static bool expect_char(const char *&p, const char *end, char expected) {
-  if (p >= end || *p != expected)
-    return false;
-  p++;
-  return true;
-}
-
 bool ESPTime::strptime(const char *time_to_parse, size_t len, ESPTime &esp_time) {
-  // Supported formats:
-  //   YYYY-MM-DD HH:MM:SS (19 chars)
-  //   YYYY-MM-DD HH:MM    (16 chars)
-  //   YYYY-MM-DD          (10 chars)
-  //   HH:MM:SS            (8 chars)
-  //   HH:MM               (5 chars)
+  uint16_t year;
+  uint8_t month;
+  uint8_t day;
+  uint8_t hour;
+  uint8_t minute;
+  uint8_t second;
+  int num;
+  const int ilen = static_cast<int>(len);
 
-  if (time_to_parse == nullptr || len == 0)
+  if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
+             &hour,                                                                              // NOLINT
+             &minute,                                                                            // NOLINT
+             &second, &num) == 6 &&                                                              // NOLINT
+      num == ilen) {
+    esp_time.year = year;
+    esp_time.month = month;
+    esp_time.day_of_month = day;
+    esp_time.hour = hour;
+    esp_time.minute = minute;
+    esp_time.second = second;
+  } else if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
+                    &hour,                                                                       // NOLINT
+                    &minute, &num) == 5 &&                                                       // NOLINT
+             num == ilen) {
+    esp_time.year = year;
+    esp_time.month = month;
+    esp_time.day_of_month = day;
+    esp_time.hour = hour;
+    esp_time.minute = minute;
+    esp_time.second = 0;
+  } else if (sscanf(time_to_parse, "%02hhu:%02hhu:%02hhu %n", &hour, &minute, &second, &num) == 3 &&  // NOLINT
+             num == ilen) {
+    esp_time.hour = hour;
+    esp_time.minute = minute;
+    esp_time.second = second;
+  } else if (sscanf(time_to_parse, "%02hhu:%02hhu %n", &hour, &minute, &num) == 2 &&  // NOLINT
+             num == ilen) {
+    esp_time.hour = hour;
+    esp_time.minute = minute;
+    esp_time.second = 0;
+  } else if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %n", &year, &month, &day, &num) == 3 &&  // NOLINT
+             num == ilen) {
+    esp_time.year = year;
+    esp_time.month = month;
+    esp_time.day_of_month = day;
+  } else {
     return false;
-
-  const char *p = time_to_parse;
-  const char *end = time_to_parse + len;
-  uint16_t v1, v2, v3, v4, v5, v6;
-
-  // Try date formats first (start with 4-digit year)
-  if (len >= 10 && time_to_parse[4] == '-') {
-    // YYYY-MM-DD...
-    if (!parse_digits(p, end, 4, v1))
-      return false;
-    if (!expect_char(p, end, '-'))
-      return false;
-    if (!parse_digits(p, end, 2, v2))
-      return false;
-    if (!expect_char(p, end, '-'))
-      return false;
-    if (!parse_digits(p, end, 2, v3))
-      return false;
-
-    esp_time.year = v1;
-    esp_time.month = v2;
-    esp_time.day_of_month = v3;
-
-    if (p == end) {
-      // YYYY-MM-DD (date only)
-      return true;
-    }
-
-    if (!expect_char(p, end, ' '))
-      return false;
-
-    // Continue with time part: HH:MM[:SS]
-    if (!parse_digits(p, end, 2, v4))
-      return false;
-    if (!expect_char(p, end, ':'))
-      return false;
-    if (!parse_digits(p, end, 2, v5))
-      return false;
-
-    esp_time.hour = v4;
-    esp_time.minute = v5;
-
-    if (p == end) {
-      // YYYY-MM-DD HH:MM
-      esp_time.second = 0;
-      return true;
-    }
-
-    if (!expect_char(p, end, ':'))
-      return false;
-    if (!parse_digits(p, end, 2, v6))
-      return false;
-
-    esp_time.second = v6;
-    return p == end;  // YYYY-MM-DD HH:MM:SS
   }
-
-  // Try time-only formats (HH:MM[:SS])
-  if (len >= 5 && time_to_parse[2] == ':') {
-    if (!parse_digits(p, end, 2, v1))
-      return false;
-    if (!expect_char(p, end, ':'))
-      return false;
-    if (!parse_digits(p, end, 2, v2))
-      return false;
-
-    esp_time.hour = v1;
-    esp_time.minute = v2;
-
-    if (p == end) {
-      // HH:MM
-      esp_time.second = 0;
-      return true;
-    }
-
-    if (!expect_char(p, end, ':'))
-      return false;
-    if (!parse_digits(p, end, 2, v3))
-      return false;
-
-    esp_time.second = v3;
-    return p == end;  // HH:MM:SS
-  }
-
-  return false;
+  return true;
 }
 
 void ESPTime::increment_second() {
@@ -257,67 +193,27 @@ void ESPTime::recalc_timestamp_utc(bool use_day_of_year) {
 }
 
 void ESPTime::recalc_timestamp_local() {
-#ifdef USE_TIME_TIMEZONE
-  // Calculate timestamp as if fields were UTC
-  this->recalc_timestamp_utc(false);
-  if (this->timestamp == -1) {
-    return;  // Invalid time
-  }
+  struct tm tm;
 
-  // Now convert from local to UTC by adding the offset
-  // POSIX: local = utc - offset, so utc = local + offset
-  const auto &tz = time::get_global_tz();
+  tm.tm_year = this->year - 1900;
+  tm.tm_mon = this->month - 1;
+  tm.tm_mday = this->day_of_month;
+  tm.tm_hour = this->hour;
+  tm.tm_min = this->minute;
+  tm.tm_sec = this->second;
+  tm.tm_isdst = -1;
 
-  if (!tz.has_dst()) {
-    // No DST - just apply standard offset
-    this->timestamp += tz.std_offset_seconds;
-    return;
-  }
-
-  // Try both interpretations to match libc mktime() with tm_isdst=-1
-  // For ambiguous times (fall-back repeated hour), prefer standard time
-  // For invalid times (spring-forward skipped hour), libc normalizes forward
-  time_t utc_if_dst = this->timestamp + tz.dst_offset_seconds;
-  time_t utc_if_std = this->timestamp + tz.std_offset_seconds;
-
-  bool dst_valid = time::is_in_dst(utc_if_dst, tz);
-  bool std_valid = !time::is_in_dst(utc_if_std, tz);
-
-  if (dst_valid && std_valid) {
-    // Ambiguous time (repeated hour during fall-back) - prefer standard time
-    this->timestamp = utc_if_std;
-  } else if (dst_valid) {
-    // Only DST interpretation is valid
-    this->timestamp = utc_if_dst;
-  } else if (std_valid) {
-    // Only standard interpretation is valid
-    this->timestamp = utc_if_std;
-  } else {
-    // Invalid time (skipped hour during spring-forward)
-    // libc normalizes forward: 02:30 CST -> 08:30 UTC -> 03:30 CDT
-    // Using std offset achieves this since the UTC result falls during DST
-    this->timestamp = utc_if_std;
-  }
-#else
-  // No timezone support - treat as UTC
-  this->recalc_timestamp_utc(false);
-#endif
+  this->timestamp = mktime(&tm);
 }
 
 int32_t ESPTime::timezone_offset() {
-#ifdef USE_TIME_TIMEZONE
   time_t now = ::time(nullptr);
-  const auto &tz = time::get_global_tz();
-  // POSIX offset is positive west, but we return offset to add to UTC to get local
-  // So we negate the POSIX offset
-  if (time::is_in_dst(now, tz)) {
-    return -tz.dst_offset_seconds;
-  }
-  return -tz.std_offset_seconds;
-#else
-  // No timezone support - no offset
-  return 0;
-#endif
+  struct tm local_tm = *::localtime(&now);
+  local_tm.tm_isdst = 0;  // Cause mktime to ignore daylight saving time because we want to include it in the offset.
+  time_t local_time = mktime(&local_tm);
+  struct tm utc_tm = *::gmtime(&now);
+  time_t utc_time = mktime(&utc_tm);
+  return static_cast<int32_t>(local_time - utc_time);
 }
 
 bool ESPTime::operator<(const ESPTime &other) const { return this->timestamp < other.timestamp; }

esphome/core/time.h

@@ -7,10 +7,6 @@
 #include <span>
 #include <string>
 
-#ifdef USE_TIME_TIMEZONE
-#include "esphome/components/time/posix_tz.h"
-#endif
-
 namespace esphome {
 
 template<typename T> bool increment_time_value(T &current, uint16_t begin, uint16_t end);
@@ -109,17 +105,11 @@ struct ESPTime {
    * @return The generated ESPTime
    */
   static ESPTime from_epoch_local(time_t epoch) {
-#ifdef USE_TIME_TIMEZONE
-    struct tm local_tm;
-    if (time::epoch_to_local_tm(epoch, time::get_global_tz(), &local_tm)) {
-      return ESPTime::from_c_tm(&local_tm, epoch);
+    struct tm *c_tm = ::localtime(&epoch);
+    if (c_tm == nullptr) {
+      return ESPTime{};  // Return an invalid ESPTime
     }
-    // Fallback to UTC if conversion failed
-    return ESPTime::from_epoch_utc(epoch);
-#else
-    // No timezone support - return UTC (no TZ configured, localtime would return UTC anyway)
-    return ESPTime::from_epoch_utc(epoch);
-#endif
+    return ESPTime::from_c_tm(c_tm, epoch);
   }
   /** Convert an UTC epoch timestamp to a UTC time ESPTime instance.
    *

esphome/cpp_generator.py

@@ -462,6 +462,16 @@ def statement(expression: Expression | Statement) -> Statement:
     return ExpressionStatement(expression)
 
 
+def literal(name: str) -> "MockObj":
+    """Create a literal name that will appear in the generated code
+    not surrounded by quotes.
+
+    :param name: The name of the literal.
+    :return: The literal as a MockObj.
+    """
+    return MockObj(name, "")
+
+
 def variable(
     id_: ID, rhs: SafeExpType, type_: "MockObj" = None, register=True
 ) -> "MockObj":
@@ -665,7 +675,7 @@ async def get_variable_with_full_id(id_: ID) -> tuple[ID, "MockObj"]:
 
 
 async def process_lambda(
-    value: Lambda,
+    value: Lambda | Expression,
     parameters: TemplateArgsType,
     capture: str = "",
     return_type: SafeExpType = None,
@@ -689,6 +699,14 @@ async def process_lambda(
 
     if value is None:
         return None
+    # Inadvertently passing a malformed parameters value will lead to the build process mysteriously hanging at the
+    # "Generating C++ source..." stage, so check here to save the developer's hair.
+    assert isinstance(parameters, list) and all(
+        isinstance(p, tuple) and len(p) == 2 for p in parameters
+    )
+    if isinstance(value, Expression):
+        value = Lambda(value)
+
     parts = value.parts[:]
     for i, id in enumerate(value.requires_ids):
         full_id, var = await get_variable_with_full_id(id)

platformio.ini

@@ -114,7 +114,7 @@ lib_deps =
     ESP8266WiFi                           ; wifi (Arduino built-in)
     Update                                ; ota (Arduino built-in)
     ESP32Async/ESPAsyncTCP@2.0.0          ; async_tcp
-    ESP32Async/ESPAsyncWebServer@3.9.5    ; web_server_base
+    ESP32Async/ESPAsyncWebServer@3.9.6    ; web_server_base
     makuna/NeoPixelBus@2.7.3              ; neopixelbus
     ESP8266HTTPClient                     ; http_request (Arduino built-in)
     ESP8266mDNS                           ; mdns (Arduino built-in)
@@ -202,7 +202,7 @@ lib_deps =
     ${common:arduino.lib_deps}
     ayushsharma82/RPAsyncTCP@1.3.2        ; async_tcp
     bblanchon/ArduinoJson@7.4.2           ; json
-    ESP32Async/ESPAsyncWebServer@3.9.5    ; web_server_base
+    ESP32Async/ESPAsyncWebServer@3.9.6    ; web_server_base
 build_flags =
     ${common:arduino.build_flags}
     -DUSE_RP2040
@@ -218,7 +218,7 @@ framework = arduino
 lib_compat_mode = soft
 lib_deps =
     bblanchon/ArduinoJson@7.4.2           ; json
-    ESP32Async/ESPAsyncWebServer@3.9.5    ; web_server_base
+    ESP32Async/ESPAsyncWebServer@3.9.6    ; web_server_base
     droscy/esp_wireguard@0.4.2            ; wireguard
 build_flags =
     ${common:arduino.build_flags}

script/cpp_unit_test.py

@@ -66,7 +66,6 @@ def create_test_config(config_name: str, includes: list[str]) -> dict:
                 ],
                 "build_flags": [
                     "-Og",  # optimize for debug
-                    "-DUSE_TIME_TIMEZONE",  # enable timezone code paths for testing
                 ],
                 "debug_build_flags": [  # only for debug builds
                     "-g3",  # max debug info

tests/components/dlms_meter/common-generic.yaml

@@ -0,0 +1,11 @@
+dlms_meter:
+  decryption_key: "36C66639E48A8CA4D6BC8B282A793BBB"   # change this to your decryption key!
+
+sensor:
+  - platform: dlms_meter
+    reactive_energy_plus:
+      name: "Reactive energy taken from grid"
+    reactive_energy_minus:
+      name: "Reactive energy put into grid"
+
+<<: !include common.yaml

tests/components/dlms_meter/common-netznoe.yaml

@@ -0,0 +1,17 @@
+dlms_meter:
+  decryption_key: "36C66639E48A8CA4D6BC8B282A793BBB"  # change this to your decryption key!
+  provider: netznoe                                   # (optional) key - only set if using evn
+
+sensor:
+  - platform: dlms_meter
+    # EVN
+    power_factor:
+      name: "Power Factor"
+
+text_sensor:
+  - platform: dlms_meter
+    # EVN
+    meternumber:
+      name: "meterNumber"
+
+<<: !include common.yaml

tests/components/dlms_meter/common.yaml

@@ -0,0 +1,27 @@
+sensor:
+  - platform: dlms_meter
+    voltage_l1:
+      name: "Voltage L1"
+    voltage_l2:
+      name: "Voltage L2"
+    voltage_l3:
+      name: "Voltage L3"
+    current_l1:
+      name: "Current L1"
+    current_l2:
+      name: "Current L2"
+    current_l3:
+      name: "Current L3"
+    active_power_plus:
+      name: "Active power taken from grid"
+    active_power_minus:
+      name: "Active power put into grid"
+    active_energy_plus:
+      name: "Active energy taken from grid"
+    active_energy_minus:
+      name: "Active energy put into grid"
+
+text_sensor:
+  - platform: dlms_meter
+    timestamp:
+      name: "timestamp"

tests/components/dlms_meter/test.esp32-ard.yaml

@@ -0,0 +1,4 @@
+packages:
+  uart: !include ../../test_build_components/common/uart_2400/esp32-ard.yaml
+
+<<: !include common-generic.yaml

tests/components/dlms_meter/test.esp32-idf.yaml

@@ -0,0 +1,4 @@
+packages:
+  uart: !include ../../test_build_components/common/uart_2400/esp32-idf.yaml
+
+<<: !include common-netznoe.yaml

tests/components/dlms_meter/test.esp8266-ard.yaml

@@ -0,0 +1,4 @@
+packages:
+  uart: !include ../../test_build_components/common/uart_2400/esp8266-ard.yaml
+
+<<: !include common-generic.yaml

tests/components/mipi_spi/test.esp8266-ard.yaml

@@ -0,0 +1,10 @@
+substitutions:
+  dc_pin: GPIO15
+  cs_pin: GPIO5
+  enable_pin: GPIO4
+  reset_pin: GPIO16
+
+packages:
+  spi: !include ../../test_build_components/common/spi/esp8266-ard.yaml
+
+<<: !include common.yaml

tests/test_build_components/common/uart_2400/esp32-ard.yaml

@@ -0,0 +1,11 @@
+# Common UART configuration for ESP32 Arduino tests - 2400 baud
+
+substitutions:
+  tx_pin: GPIO17
+  rx_pin: GPIO16
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 2400

tests/test_build_components/common/uart_2400/esp32-idf.yaml

@@ -0,0 +1,11 @@
+# Common UART configuration for ESP32 IDF tests - 2400 baud
+
+substitutions:
+  tx_pin: GPIO17
+  rx_pin: GPIO16
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 2400

tests/test_build_components/common/uart_2400/esp8266-ard.yaml

@@ -0,0 +1,11 @@
+# Common UART configuration for ESP8266 Arduino tests - 2400 baud
+
+substitutions:
+  tx_pin: GPIO4
+  rx_pin: GPIO5
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 2400

tests/unit_tests/test_cpp_generator.py

@@ -347,3 +347,280 @@ class TestMockObj:
         assert isinstance(actual, cg.MockObj)
         assert actual.base == "foo.eek"
         assert actual.op == "."
+
+
+class TestStatementFunction:
+    """Tests for the statement() function."""
+
+    def test_statement__expression_converted_to_statement(self):
+        """Test that expressions are converted to ExpressionStatement."""
+        expr = cg.RawExpression("foo()")
+        result = cg.statement(expr)
+
+        assert isinstance(result, cg.ExpressionStatement)
+        assert str(result) == "foo();"
+
+    def test_statement__statement_unchanged(self):
+        """Test that statements are returned unchanged."""
+        stmt = cg.RawStatement("foo()")
+        result = cg.statement(stmt)
+
+        assert result is stmt
+        assert str(result) == "foo()"
+
+    def test_statement__expression_statement_unchanged(self):
+        """Test that ExpressionStatement is returned unchanged."""
+        stmt = cg.ExpressionStatement(42)
+        result = cg.statement(stmt)
+
+        assert result is stmt
+        assert str(result) == "42;"
+
+    def test_statement__line_comment_unchanged(self):
+        """Test that LineComment is returned unchanged."""
+        stmt = cg.LineComment("This is a comment")
+        result = cg.statement(stmt)
+
+        assert result is stmt
+        assert str(result) == "// This is a comment"
+
+
+class TestLiteralFunction:
+    """Tests for the literal() function."""
+
+    def test_literal__creates_mockobj(self):
+        """Test that literal() creates a MockObj."""
+        result = cg.literal("MY_CONSTANT")
+
+        assert isinstance(result, cg.MockObj)
+        assert result.base == "MY_CONSTANT"
+        assert result.op == ""
+
+    def test_literal__string_representation(self):
+        """Test that literal names appear unquoted in generated code."""
+        result = cg.literal("nullptr")
+
+        assert str(result) == "nullptr"
+
+    def test_literal__can_be_used_in_expressions(self):
+        """Test that literals can be used as part of larger expressions."""
+        null_lit = cg.literal("nullptr")
+        expr = cg.CallExpression(cg.RawExpression("my_func"), null_lit)
+
+        assert str(expr) == "my_func(nullptr)"
+
+    def test_literal__common_cpp_literals(self):
+        """Test common C++ literal values."""
+        test_cases = [
+            ("nullptr", "nullptr"),
+            ("true", "true"),
+            ("false", "false"),
+            ("NULL", "NULL"),
+            ("NAN", "NAN"),
+        ]
+
+        for name, expected in test_cases:
+            result = cg.literal(name)
+            assert str(result) == expected
+
+
+class TestLambdaConstructor:
+    """Tests for the Lambda class constructor in core/__init__.py."""
+
+    def test_lambda__from_string(self):
+        """Test Lambda constructor with string argument."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + 1;")
+
+        assert lambda_obj.value == "return x + 1;"
+        assert str(lambda_obj) == "return x + 1;"
+
+    def test_lambda__from_expression(self):
+        """Test Lambda constructor with Expression argument."""
+        from esphome.core import Lambda
+
+        expr = cg.RawExpression("x + 1")
+        lambda_obj = Lambda(expr)
+
+        # Expression should be converted to statement (with semicolon)
+        assert lambda_obj.value == "x + 1;"
+
+    def test_lambda__from_lambda(self):
+        """Test Lambda constructor with another Lambda argument."""
+        from esphome.core import Lambda
+
+        original = Lambda("return x + 1;")
+        copy = Lambda(original)
+
+        assert copy.value == original.value
+        assert copy.value == "return x + 1;"
+
+    def test_lambda__parts_parsing(self):
+        """Test that Lambda correctly parses parts with id() references."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return id(my_sensor).state;")
+        parts = lambda_obj.parts
+
+        # Parts should be split by LAMBDA_PROG regex: text, id, op, text
+        assert len(parts) == 4
+        assert parts[0] == "return "
+        assert parts[1] == "my_sensor"
+        assert parts[2] == "."
+        assert parts[3] == "state;"
+
+    def test_lambda__requires_ids(self):
+        """Test that Lambda correctly extracts required IDs."""
+        from esphome.core import ID, Lambda
+
+        lambda_obj = Lambda("return id(sensor1).state + id(sensor2).value;")
+        ids = lambda_obj.requires_ids
+
+        assert len(ids) == 2
+        assert all(isinstance(id_obj, ID) for id_obj in ids)
+        assert ids[0].id == "sensor1"
+        assert ids[1].id == "sensor2"
+
+    def test_lambda__no_ids(self):
+        """Test Lambda with no id() references."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return 42;")
+        ids = lambda_obj.requires_ids
+
+        assert len(ids) == 0
+
+    def test_lambda__comment_removal(self):
+        """Test that comments are removed when parsing parts."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return id(sensor).state; // Get sensor state")
+        parts = lambda_obj.parts
+
+        # Comment should be replaced with space, not affect parsing
+        assert "my_sensor" not in str(parts)
+
+    def test_lambda__multiline_string(self):
+        """Test Lambda with multiline string."""
+        from esphome.core import Lambda
+
+        code = """if (id(sensor).state > 0) {
+  return true;
+}
+return false;"""
+        lambda_obj = Lambda(code)
+
+        assert lambda_obj.value == code
+        assert "sensor" in [id_obj.id for id_obj in lambda_obj.requires_ids]
+
+
+@pytest.mark.asyncio
+class TestProcessLambda:
+    """Tests for the process_lambda() async function."""
+
+    async def test_process_lambda__none_value(self):
+        """Test that None returns None."""
+        result = await cg.process_lambda(None, [])
+
+        assert result is None
+
+    async def test_process_lambda__with_expression(self):
+        """Test process_lambda with Expression argument."""
+
+        expr = cg.RawExpression("return x + 1")
+        result = await cg.process_lambda(expr, [(int, "x")])
+
+        assert isinstance(result, cg.LambdaExpression)
+        assert "x + 1" in str(result)
+
+    async def test_process_lambda__simple_lambda_no_ids(self):
+        """Test process_lambda with simple Lambda without id() references."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + 1;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")])
+
+        assert isinstance(result, cg.LambdaExpression)
+        # Should have parameter
+        lambda_str = str(result)
+        assert "int32_t x" in lambda_str
+        assert "return x + 1;" in lambda_str
+
+    async def test_process_lambda__with_return_type(self):
+        """Test process_lambda with return type specified."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x > 0;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")], return_type=bool)
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "-> bool" in lambda_str
+
+    async def test_process_lambda__with_capture(self):
+        """Test process_lambda with capture specified."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return captured + x;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")], capture="captured")
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "[captured]" in lambda_str
+
+    async def test_process_lambda__empty_capture(self):
+        """Test process_lambda with empty capture (stateless lambda)."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + 1;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")], capture="")
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "[]" in lambda_str
+
+    async def test_process_lambda__no_parameters(self):
+        """Test process_lambda with no parameters."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return 42;")
+        result = await cg.process_lambda(lambda_obj, [])
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        # Should have empty parameter list
+        assert "()" in lambda_str
+
+    async def test_process_lambda__multiple_parameters(self):
+        """Test process_lambda with multiple parameters."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + y + z;")
+        result = await cg.process_lambda(
+            lambda_obj, [(int, "x"), (float, "y"), (bool, "z")]
+        )
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "int32_t x" in lambda_str
+        assert "float y" in lambda_str
+        assert "bool z" in lambda_str
+
+    async def test_process_lambda__parameter_validation(self):
+        """Test that malformed parameters raise assertion error."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x;")
+
+        # Test invalid parameter format (not list of tuples)
+        with pytest.raises(AssertionError):
+            await cg.process_lambda(lambda_obj, "invalid")
+
+        # Test invalid tuple format (not 2-element tuples)
+        with pytest.raises(AssertionError):
+            await cg.process_lambda(lambda_obj, [(int, "x", "extra")])
+
+        # Test invalid tuple format (single element)
+        with pytest.raises(AssertionError):
+            await cg.process_lambda(lambda_obj, [(int,)])