esphome 2025.9.3__py3-none-any.whl → 2025.10.0b2__py3-none-any.whl

esphome/components/mdns/mdns_esp32.cpp

@@ -2,7 +2,6 @@
 #if defined(USE_ESP32) && defined(USE_MDNS)
 
 #include <mdns.h>
-#include <cstring>
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 #include "mdns_component.h"
@@ -29,23 +28,18 @@ void MDNSComponent::setup() {
     std::vector<mdns_txt_item_t> txt_records;
     for (const auto &record : service.txt_records) {
       mdns_txt_item_t it{};
-      // dup strings to ensure the pointer is valid even after the record loop
-      it.key = strdup(record.key.c_str());
-      it.value = strdup(const_cast<TemplatableValue<std::string> &>(record.value).value().c_str());
+      // key and value are either compile-time string literals in flash or pointers to dynamic_txt_values_
+      // Both remain valid for the lifetime of this function, and ESP-IDF makes internal copies
+      it.key = MDNS_STR_ARG(record.key);
+      it.value = MDNS_STR_ARG(record.value);
       txt_records.push_back(it);
     }
     uint16_t port = const_cast<TemplatableValue<uint16_t> &>(service.port).value();
-    err = mdns_service_add(nullptr, service.service_type.c_str(), service.proto.c_str(), port, txt_records.data(),
-                           txt_records.size());
-
-    // free records
-    for (const auto &it : txt_records) {
-      delete it.key;    // NOLINT(cppcoreguidelines-owning-memory)
-      delete it.value;  // NOLINT(cppcoreguidelines-owning-memory)
-    }
+    err = mdns_service_add(nullptr, MDNS_STR_ARG(service.service_type), MDNS_STR_ARG(service.proto), port,
+                           txt_records.data(), txt_records.size());
 
     if (err != ESP_OK) {
-      ESP_LOGW(TAG, "Failed to register service %s: %s", service.service_type.c_str(), esp_err_to_name(err));
+      ESP_LOGW(TAG, "Failed to register service %s: %s", MDNS_STR_ARG(service.service_type), esp_err_to_name(err));
     }
   }
 }

esphome/components/mdns/mdns_esp8266.cpp

@@ -21,19 +21,19 @@ void MDNSComponent::setup() {
     // part of the wire protocol to have an underscore, and for example ESP-IDF
     // expects the underscore to be there, the ESP8266 implementation always adds
     // the underscore itself.
-    auto *proto = service.proto.c_str();
-    while (*proto == '_') {
+    auto *proto = MDNS_STR_ARG(service.proto);
+    while (progmem_read_byte((const uint8_t *) proto) == '_') {
       proto++;
     }
-    auto *service_type = service.service_type.c_str();
-    while (*service_type == '_') {
+    auto *service_type = MDNS_STR_ARG(service.service_type);
+    while (progmem_read_byte((const uint8_t *) service_type) == '_') {
       service_type++;
     }
     uint16_t port = const_cast<TemplatableValue<uint16_t> &>(service.port).value();
-    MDNS.addService(service_type, proto, port);
+    MDNS.addService(FPSTR(service_type), FPSTR(proto), port);
     for (const auto &record : service.txt_records) {
-      MDNS.addServiceTxt(service_type, proto, record.key.c_str(),
-                         const_cast<TemplatableValue<std::string> &>(record.value).value().c_str());
+      MDNS.addServiceTxt(FPSTR(service_type), FPSTR(proto), FPSTR(MDNS_STR_ARG(record.key)),
+                         FPSTR(MDNS_STR_ARG(record.value)));
     }
   }
 }

esphome/components/mdns/mdns_libretiny.cpp

@@ -21,19 +21,18 @@ void MDNSComponent::setup() {
     // part of the wire protocol to have an underscore, and for example ESP-IDF
     // expects the underscore to be there, the ESP8266 implementation always adds
     // the underscore itself.
-    auto *proto = service.proto.c_str();
+    auto *proto = MDNS_STR_ARG(service.proto);
     while (*proto == '_') {
       proto++;
     }
-    auto *service_type = service.service_type.c_str();
+    auto *service_type = MDNS_STR_ARG(service.service_type);
     while (*service_type == '_') {
       service_type++;
     }
     uint16_t port_ = const_cast<TemplatableValue<uint16_t> &>(service.port).value();
     MDNS.addService(service_type, proto, port_);
     for (const auto &record : service.txt_records) {
-      MDNS.addServiceTxt(service_type, proto, record.key.c_str(),
-                         const_cast<TemplatableValue<std::string> &>(record.value).value().c_str());
+      MDNS.addServiceTxt(service_type, proto, MDNS_STR_ARG(record.key), MDNS_STR_ARG(record.value));
     }
   }
 }

esphome/components/mdns/mdns_rp2040.cpp

@@ -21,19 +21,18 @@ void MDNSComponent::setup() {
     // part of the wire protocol to have an underscore, and for example ESP-IDF
     // expects the underscore to be there, the ESP8266 implementation always adds
     // the underscore itself.
-    auto *proto = service.proto.c_str();
+    auto *proto = MDNS_STR_ARG(service.proto);
     while (*proto == '_') {
       proto++;
     }
-    auto *service_type = service.service_type.c_str();
+    auto *service_type = MDNS_STR_ARG(service.service_type);
     while (*service_type == '_') {
       service_type++;
     }
     uint16_t port = const_cast<TemplatableValue<uint16_t> &>(service.port).value();
     MDNS.addService(service_type, proto, port);
     for (const auto &record : service.txt_records) {
-      MDNS.addServiceTxt(service_type, proto, record.key.c_str(),
-                         const_cast<TemplatableValue<std::string> &>(record.value).value().c_str());
+      MDNS.addServiceTxt(service_type, proto, MDNS_STR_ARG(record.key), MDNS_STR_ARG(record.value));
     }
   }
 }

esphome/components/mipi/__init__.py

@@ -343,11 +343,7 @@ class DriverChip:
             )
             offset_height = native_height - height - offset_height
         # Swap default dimensions if swap_xy is set, or if rotation is 90/270 and we are not using a buffer
-        rotated = not requires_buffer(config) and config.get(CONF_ROTATION, 0) in (
-            90,
-            270,
-        )
-        if transform.get(CONF_SWAP_XY) is True or rotated:
+        if transform.get(CONF_SWAP_XY) is True:
             width, height = height, width
             offset_height, offset_width = offset_width, offset_height
         return width, height, offset_width, offset_height

esphome/components/mipi_spi/display.py

@@ -380,25 +380,41 @@ def get_instance(config):
         bus_type = BusTypes[bus_type]
     buffer_type = cg.uint8 if color_depth == 8 else cg.uint16
     frac = denominator(config)
-    rotation = DISPLAY_ROTATIONS[
+    rotation = (
         0 if model.rotation_as_transform(config) else config.get(CONF_ROTATION, 0)
-    ]
+    )
     templateargs = [
         buffer_type,
         bufferpixels,
         config[CONF_BYTE_ORDER] == "big_endian",
         display_pixel_mode,
         bus_type,
-        width,
-        height,
-        offset_width,
-        offset_height,
     ]
     # If a buffer is required, use MipiSpiBuffer, otherwise use MipiSpi
     if requires_buffer(config):
-        templateargs.append(rotation)
-        templateargs.append(frac)
+        templateargs.extend(
+            [
+                width,
+                height,
+                offset_width,
+                offset_height,
+                DISPLAY_ROTATIONS[rotation],
+                frac,
+            ]
+        )
         return MipiSpiBuffer, templateargs
+    # Swap height and width if the display is rotated 90 or 270 degrees in software
+    if rotation in (90, 270):
+        width, height = height, width
+        offset_width, offset_height = offset_height, offset_width
+    templateargs.extend(
+        [
+            width,
+            height,
+            offset_width,
+            offset_height,
+        ]
+    )
     return MipiSpi, templateargs
 
 

esphome/components/mipi_spi/mipi_spi.h

@@ -340,7 +340,7 @@ class MipiSpi : public display::Display,
         this->write_cmd_addr_data(0, 0, 0, 0, ptr, w * h, 8);
       }
     } else {
-      for (size_t y = 0; y != h; y++) {
+      for (size_t y = 0; y != static_cast<size_t>(h); y++) {
         if constexpr (BUS_TYPE == BUS_TYPE_SINGLE || BUS_TYPE == BUS_TYPE_SINGLE_16) {
           this->write_array(ptr, w);
         } else if constexpr (BUS_TYPE == BUS_TYPE_QUAD) {
@@ -372,8 +372,8 @@ class MipiSpi : public display::Display,
       uint8_t dbuffer[DISPLAYPIXEL * 48];
       uint8_t *dptr = dbuffer;
       auto stride = x_offset + w + x_pad;  // stride in pixels
-      for (size_t y = 0; y != h; y++) {
-        for (size_t x = 0; x != w; x++) {
+      for (size_t y = 0; y != static_cast<size_t>(h); y++) {
+        for (size_t x = 0; x != static_cast<size_t>(w); x++) {
           auto color_val = ptr[y * stride + x];
           if constexpr (DISPLAYPIXEL == PIXEL_MODE_18 && BUFFERPIXEL == PIXEL_MODE_16) {
             // 16 to 18 bit conversion

esphome/components/mixer/speaker/mixer_speaker.cpp

@@ -572,7 +572,7 @@ void MixerSpeaker::audio_mixer_task(void *params) {
       }
     } else {
       // Determine how many frames to mix
-      for (int i = 0; i < transfer_buffers_with_data.size(); ++i) {
+      for (size_t i = 0; i < transfer_buffers_with_data.size(); ++i) {
         const uint32_t frames_available_in_buffer =
             speakers_with_data[i]->get_audio_stream_info().bytes_to_frames(transfer_buffers_with_data[i]->available());
         frames_to_mix = std::min(frames_to_mix, frames_available_in_buffer);
@@ -581,7 +581,7 @@ void MixerSpeaker::audio_mixer_task(void *params) {
       audio::AudioStreamInfo primary_stream_info = speakers_with_data[0]->get_audio_stream_info();
 
       // Mix two streams together
-      for (int i = 1; i < transfer_buffers_with_data.size(); ++i) {
+      for (size_t i = 1; i < transfer_buffers_with_data.size(); ++i) {
         mix_audio_samples(primary_buffer, primary_stream_info,
                           reinterpret_cast<int16_t *>(transfer_buffers_with_data[i]->get_buffer_start()),
                           speakers_with_data[i]->get_audio_stream_info(),
@@ -596,7 +596,7 @@ void MixerSpeaker::audio_mixer_task(void *params) {
       }
 
       // Update source transfer buffer lengths and add new audio durations to the source speaker pending playbacks
-      for (int i = 0; i < transfer_buffers_with_data.size(); ++i) {
+      for (size_t i = 0; i < transfer_buffers_with_data.size(); ++i) {
         transfer_buffers_with_data[i]->decrease_buffer_length(
             speakers_with_data[i]->get_audio_stream_info().frames_to_bytes(frames_to_mix));
         speakers_with_data[i]->pending_playback_frames_ += frames_to_mix;

esphome/components/mmc5603/mmc5603.cpp

@@ -128,21 +128,21 @@ void MMC5603Component::update() {
   raw_x |= buffer[1] << 4;
   raw_x |= buffer[2] << 0;
 
-  const float x = 0.0625 * (raw_x - 524288);
+  const float x = 0.00625 * (raw_x - 524288);
 
   int32_t raw_y = 0;
   raw_y |= buffer[3] << 12;
   raw_y |= buffer[4] << 4;
   raw_y |= buffer[5] << 0;
 
-  const float y = 0.0625 * (raw_y - 524288);
+  const float y = 0.00625 * (raw_y - 524288);
 
   int32_t raw_z = 0;
   raw_z |= buffer[6] << 12;
   raw_z |= buffer[7] << 4;
   raw_z |= buffer[8] << 0;
 
-  const float z = 0.0625 * (raw_z - 524288);
+  const float z = 0.00625 * (raw_z - 524288);
 
   const float heading = atan2f(0.0f - x, y) * 180.0f / M_PI;
   ESP_LOGD(TAG, "Got x=%0.02fµT y=%0.02fµT z=%0.02fµT heading=%0.01f°", x, y, z, heading);

esphome/components/modbus/modbus.cpp

@@ -66,7 +66,10 @@ bool Modbus::parse_modbus_byte_(uint8_t byte) {
   uint8_t data_offset = 3;
 
   // Per https://modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf Ch 5 User-Defined function codes
-  if (((function_code >= 65) && (function_code <= 72)) || ((function_code >= 100) && (function_code <= 110))) {
+  if (((function_code >= FUNCTION_CODE_USER_DEFINED_SPACE_1_INIT) &&
+       (function_code <= FUNCTION_CODE_USER_DEFINED_SPACE_1_END)) ||
+      ((function_code >= FUNCTION_CODE_USER_DEFINED_SPACE_2_INIT) &&
+       (function_code <= FUNCTION_CODE_USER_DEFINED_SPACE_2_END))) {
     // Handle user-defined function, since we don't know how big this ought to be,
     // ideally we should delegate the entire length detection to whatever handler is
     // installed, but wait, there is the CRC, and if we get a hit there is a good
@@ -91,10 +94,14 @@ bool Modbus::parse_modbus_byte_(uint8_t byte) {
   } else {
     // data starts at 2 and length is 4 for read registers commands
     if (this->role == ModbusRole::SERVER) {
-      if (function_code == 0x1 || function_code == 0x3 || function_code == 0x4 || function_code == 0x6) {
+      if (function_code == ModbusFunctionCode::READ_COILS ||
+          function_code == ModbusFunctionCode::READ_DISCRETE_INPUTS ||
+          function_code == ModbusFunctionCode::READ_HOLDING_REGISTERS ||
+          function_code == ModbusFunctionCode::READ_INPUT_REGISTERS ||
+          function_code == ModbusFunctionCode::WRITE_SINGLE_REGISTER) {
         data_offset = 2;
         data_len = 4;
-      } else if (function_code == 0x10) {
+      } else if (function_code == ModbusFunctionCode::WRITE_MULTIPLE_REGISTERS) {
         if (at < 6) {
           return true;
         }
@@ -104,7 +111,10 @@ bool Modbus::parse_modbus_byte_(uint8_t byte) {
       }
     } else {
       // the response for write command mirrors the requests and data starts at offset 2 instead of 3 for read commands
-      if (function_code == 0x5 || function_code == 0x06 || function_code == 0xF || function_code == 0x10) {
+      if (function_code == ModbusFunctionCode::WRITE_SINGLE_COIL ||
+          function_code == ModbusFunctionCode::WRITE_SINGLE_REGISTER ||
+          function_code == ModbusFunctionCode::WRITE_MULTIPLE_COILS ||
+          function_code == ModbusFunctionCode::WRITE_MULTIPLE_REGISTERS) {
         data_offset = 2;
         data_len = 4;
       }
@@ -112,7 +122,7 @@ bool Modbus::parse_modbus_byte_(uint8_t byte) {
 
     // Error ( msb indicates error )
     // response format:  Byte[0] = device address, Byte[1] function code | 0x80 , Byte[2] exception code, Byte[3-4] crc
-    if ((function_code & 0x80) == 0x80) {
+    if ((function_code & FUNCTION_CODE_EXCEPTION_MASK) == FUNCTION_CODE_EXCEPTION_MASK) {
       data_offset = 2;
       data_len = 1;
     }
@@ -143,10 +153,10 @@ bool Modbus::parse_modbus_byte_(uint8_t byte) {
     if (device->address_ == address) {
       found = true;
       // Is it an error response?
-      if ((function_code & 0x80) == 0x80) {
+      if ((function_code & FUNCTION_CODE_EXCEPTION_MASK) == FUNCTION_CODE_EXCEPTION_MASK) {
         ESP_LOGD(TAG, "Modbus error function code: 0x%X exception: %d", function_code, raw[2]);
         if (waiting_for_response != 0) {
-          device->on_modbus_error(function_code & 0x7F, raw[2]);
+          device->on_modbus_error(function_code & FUNCTION_CODE_MASK, raw[2]);
         } else {
           // Ignore modbus exception not related to a pending command
           ESP_LOGD(TAG, "Ignoring Modbus error - not expecting a response");
@@ -154,12 +164,14 @@ bool Modbus::parse_modbus_byte_(uint8_t byte) {
         continue;
       }
       if (this->role == ModbusRole::SERVER) {
-        if (function_code == 0x3 || function_code == 0x4) {
+        if (function_code == ModbusFunctionCode::READ_HOLDING_REGISTERS ||
+            function_code == ModbusFunctionCode::READ_INPUT_REGISTERS) {
           device->on_modbus_read_registers(function_code, uint16_t(data[1]) | (uint16_t(data[0]) << 8),
                                            uint16_t(data[3]) | (uint16_t(data[2]) << 8));
           continue;
         }
-        if (function_code == 0x6 || function_code == 0x10) {
+        if (function_code == ModbusFunctionCode::WRITE_SINGLE_REGISTER ||
+            function_code == ModbusFunctionCode::WRITE_MULTIPLE_REGISTERS) {
           device->on_modbus_write_registers(function_code, data);
           continue;
         }
@@ -199,7 +211,7 @@ void Modbus::send(uint8_t address, uint8_t function_code, uint16_t start_address
 
   // Only check max number of registers for standard function codes
   // Some devices use non standard codes like 0x43
-  if (number_of_entities > MAX_VALUES && function_code <= 0x10) {
+  if (number_of_entities > MAX_VALUES && function_code <= ModbusFunctionCode::WRITE_MULTIPLE_REGISTERS) {
     ESP_LOGE(TAG, "send too many values %d max=%zu", number_of_entities, MAX_VALUES);
     return;
   }
@@ -210,15 +222,17 @@ void Modbus::send(uint8_t address, uint8_t function_code, uint16_t start_address
   if (this->role == ModbusRole::CLIENT) {
     data.push_back(start_address >> 8);
     data.push_back(start_address >> 0);
-    if (function_code != 0x5 && function_code != 0x6) {
+    if (function_code != ModbusFunctionCode::WRITE_SINGLE_COIL &&
+        function_code != ModbusFunctionCode::WRITE_SINGLE_REGISTER) {
       data.push_back(number_of_entities >> 8);
       data.push_back(number_of_entities >> 0);
     }
   }
 
   if (payload != nullptr) {
-    if (this->role == ModbusRole::SERVER || function_code == 0xF || function_code == 0x10) {  // Write multiple
-      data.push_back(payload_len);  // Byte count is required for write
+    if (this->role == ModbusRole::SERVER || function_code == ModbusFunctionCode::WRITE_MULTIPLE_COILS ||
+        function_code == ModbusFunctionCode::WRITE_MULTIPLE_REGISTERS) {  // Write multiple
+      data.push_back(payload_len);                                        // Byte count is required for write
     } else {
       payload_len = 2;  // Write single register or coil
     }

esphome/components/modbus/modbus.h

@@ -3,6 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/components/uart/uart.h"
 
+#include "esphome/components/modbus/modbus_definitions.h"
+
 #include <vector>
 
 namespace esphome {
@@ -65,12 +67,12 @@ class ModbusDevice {
     this->parent_->send(this->address_, function, start_address, number_of_entities, payload_len, payload);
   }
   void send_raw(const std::vector<uint8_t> &payload) { this->parent_->send_raw(payload); }
-  void send_error(uint8_t function_code, uint8_t exception_code) {
+  void send_error(uint8_t function_code, ModbusExceptionCode exception_code) {
     std::vector<uint8_t> error_response;
     error_response.reserve(3);
     error_response.push_back(this->address_);
-    error_response.push_back(function_code | 0x80);
-    error_response.push_back(exception_code);
+    error_response.push_back(function_code | FUNCTION_CODE_EXCEPTION_MASK);
+    error_response.push_back(static_cast<uint8_t>(exception_code));
     this->send_raw(error_response);
   }
   // If more than one device is connected block sending a new command before a response is received

esphome/components/modbus/modbus_definitions.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace modbus {
+
+/// Modbus definitions from specs:
+/// https://modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf
+// 5 Function Code Categories
+const uint8_t FUNCTION_CODE_USER_DEFINED_SPACE_1_INIT = 65;  // 0x41
+const uint8_t FUNCTION_CODE_USER_DEFINED_SPACE_1_END = 72;   // 0x48
+
+const uint8_t FUNCTION_CODE_USER_DEFINED_SPACE_2_INIT = 100;  // 0x64
+const uint8_t FUNCTION_CODE_USER_DEFINED_SPACE_2_END = 110;   // 0x6E
+
+enum class ModbusFunctionCode : uint8_t {
+  CUSTOM = 0x00,
+  READ_COILS = 0x01,
+  READ_DISCRETE_INPUTS = 0x02,
+  READ_HOLDING_REGISTERS = 0x03,
+  READ_INPUT_REGISTERS = 0x04,
+  WRITE_SINGLE_COIL = 0x05,
+  WRITE_SINGLE_REGISTER = 0x06,
+  READ_EXCEPTION_STATUS = 0x07,   // not implemented
+  DIAGNOSTICS = 0x08,             // not implemented
+  GET_COMM_EVENT_COUNTER = 0x0B,  // not implemented
+  GET_COMM_EVENT_LOG = 0x0C,      // not implemented
+  WRITE_MULTIPLE_COILS = 0x0F,
+  WRITE_MULTIPLE_REGISTERS = 0x10,
+  REPORT_SERVER_ID = 0x11,               // not implemented
+  READ_FILE_RECORD = 0x14,               // not implemented
+  WRITE_FILE_RECORD = 0x15,              // not implemented
+  MASK_WRITE_REGISTER = 0x16,            // not implemented
+  READ_WRITE_MULTIPLE_REGISTERS = 0x17,  // not implemented
+  READ_FIFO_QUEUE = 0x18,                // not implemented
+};
+
+/*Allow  comparison operators between ModbusFunctionCode and uint8_t*/
+inline bool operator==(ModbusFunctionCode lhs, uint8_t rhs) { return static_cast<uint8_t>(lhs) == rhs; }
+inline bool operator==(uint8_t lhs, ModbusFunctionCode rhs) { return lhs == static_cast<uint8_t>(rhs); }
+inline bool operator!=(ModbusFunctionCode lhs, uint8_t rhs) { return !(static_cast<uint8_t>(lhs) == rhs); }
+inline bool operator!=(uint8_t lhs, ModbusFunctionCode rhs) { return !(lhs == static_cast<uint8_t>(rhs)); }
+inline bool operator<(ModbusFunctionCode lhs, uint8_t rhs) { return static_cast<uint8_t>(lhs) < rhs; }
+inline bool operator<(uint8_t lhs, ModbusFunctionCode rhs) { return lhs < static_cast<uint8_t>(rhs); }
+inline bool operator<=(ModbusFunctionCode lhs, uint8_t rhs) { return static_cast<uint8_t>(lhs) <= rhs; }
+inline bool operator<=(uint8_t lhs, ModbusFunctionCode rhs) { return lhs <= static_cast<uint8_t>(rhs); }
+inline bool operator>(ModbusFunctionCode lhs, uint8_t rhs) { return static_cast<uint8_t>(lhs) > rhs; }
+inline bool operator>(uint8_t lhs, ModbusFunctionCode rhs) { return lhs > static_cast<uint8_t>(rhs); }
+inline bool operator>=(ModbusFunctionCode lhs, uint8_t rhs) { return static_cast<uint8_t>(lhs) >= rhs; }
+inline bool operator>=(uint8_t lhs, ModbusFunctionCode rhs) { return lhs >= static_cast<uint8_t>(rhs); }
+
+// 4.3 MODBUS Data model
+enum class ModbusRegisterType : uint8_t {
+  CUSTOM = 0x00,
+  COIL = 0x01,
+  DISCRETE_INPUT = 0x02,
+  HOLDING = 0x03,
+  READ = 0x04,
+};
+
+// 7 MODBUS Exception Responses:
+const uint8_t FUNCTION_CODE_MASK = 0x7F;
+const uint8_t FUNCTION_CODE_EXCEPTION_MASK = 0x80;
+
+enum class ModbusExceptionCode : uint8_t {
+  ILLEGAL_FUNCTION = 0x01,
+  ILLEGAL_DATA_ADDRESS = 0x02,
+  ILLEGAL_DATA_VALUE = 0x03,
+  SERVICE_DEVICE_FAILURE = 0x04,
+  ACKNOWLEDGE = 0x05,
+  SERVER_DEVICE_BUSY = 0x06,
+  MEMORY_PARITY_ERROR = 0x08,
+  GATEWAY_PATH_UNAVAILABLE = 0x0A,
+  GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND = 0x0B,
+};
+
+// 6.12 16 (0x10) Write Multiple registers:
+const uint8_t MAX_NUM_OF_REGISTERS_TO_WRITE = 123;  // 0x7B
+
+// 6.3 03 (0x03) Read Holding Registers
+// 6.4 04 (0x04) Read Input Registers
+const uint8_t MAX_NUM_OF_REGISTERS_TO_READ = 125;  // 0x7D
+/// End of Modbus definitions
+}  // namespace modbus
+}  // namespace esphome

esphome/components/modbus_controller/__init__.py

@@ -20,6 +20,7 @@ from .const import (
     CONF_BYTE_OFFSET,
     CONF_COMMAND_THROTTLE,
     CONF_CUSTOM_COMMAND,
+    CONF_ENABLED,
     CONF_FORCE_NEW_RANGE,
     CONF_MAX_CMD_RETRIES,
     CONF_MODBUS_CONTROLLER_ID,
@@ -28,8 +29,11 @@ from .const import (
     CONF_ON_OFFLINE,
     CONF_ON_ONLINE,
     CONF_REGISTER_COUNT,
+    CONF_REGISTER_LAST_ADDRESS,
     CONF_REGISTER_TYPE,
+    CONF_REGISTER_VALUE,
     CONF_RESPONSE_SIZE,
+    CONF_SERVER_COURTESY_RESPONSE,
     CONF_SKIP_UPDATES,
     CONF_VALUE_TYPE,
 )
@@ -49,6 +53,7 @@ ModbusController = modbus_controller_ns.class_(
 )
 
 SensorItem = modbus_controller_ns.struct("SensorItem")
+ServerCourtesyResponse = modbus_controller_ns.struct("ServerCourtesyResponse")
 ServerRegister = modbus_controller_ns.struct("ServerRegister")
 
 ModbusFunctionCode_ns = modbus_controller_ns.namespace("ModbusFunctionCode")
@@ -143,6 +148,14 @@ ModbusOfflineTrigger = modbus_controller_ns.class_(
 
 _LOGGER = logging.getLogger(__name__)
 
+SERVER_COURTESY_RESPONSE_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_ENABLED, default=False): cv.boolean,
+        cv.Optional(CONF_REGISTER_LAST_ADDRESS, default=0xFFFF): cv.hex_uint16_t,
+        cv.Optional(CONF_REGISTER_VALUE, default=0): cv.hex_uint16_t,
+    }
+)
+
 ModbusServerRegisterSchema = cv.Schema(
     {
         cv.GenerateID(): cv.declare_id(ServerRegister),
@@ -162,6 +175,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(
                 CONF_COMMAND_THROTTLE, default="0ms"
             ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_SERVER_COURTESY_RESPONSE): SERVER_COURTESY_RESPONSE_SCHEMA,
             cv.Optional(CONF_MAX_CMD_RETRIES, default=4): cv.positive_int,
             cv.Optional(CONF_OFFLINE_SKIP_UPDATES, default=0): cv.positive_int,
             cv.Optional(
@@ -232,7 +246,7 @@ def validate_modbus_register(config):
 
 
 def _final_validate(config):
-    if CONF_SERVER_REGISTERS in config:
+    if CONF_SERVER_COURTESY_RESPONSE in config or CONF_SERVER_REGISTERS in config:
         return modbus.final_validate_modbus_device("modbus_controller", role="server")(
             config
         )
@@ -299,6 +313,20 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     cg.add(var.set_allow_duplicate_commands(config[CONF_ALLOW_DUPLICATE_COMMANDS]))
     cg.add(var.set_command_throttle(config[CONF_COMMAND_THROTTLE]))
+    if server_courtesy_response := config.get(CONF_SERVER_COURTESY_RESPONSE):
+        cg.add(
+            var.set_server_courtesy_response(
+                cg.StructInitializer(
+                    ServerCourtesyResponse,
+                    ("enabled", server_courtesy_response[CONF_ENABLED]),
+                    (
+                        "register_last_address",
+                        server_courtesy_response[CONF_REGISTER_LAST_ADDRESS],
+                    ),
+                    ("register_value", server_courtesy_response[CONF_REGISTER_VALUE]),
+                )
+            )
+        )
     cg.add(var.set_max_cmd_retries(config[CONF_MAX_CMD_RETRIES]))
     cg.add(var.set_offline_skip_updates(config[CONF_OFFLINE_SKIP_UPDATES]))
     if CONF_SERVER_REGISTERS in config:

esphome/components/modbus_controller/const.py

@@ -2,6 +2,7 @@ CONF_ALLOW_DUPLICATE_COMMANDS = "allow_duplicate_commands"
 CONF_BITMASK = "bitmask"
 CONF_BYTE_OFFSET = "byte_offset"
 CONF_COMMAND_THROTTLE = "command_throttle"
+CONF_ENABLED = "enabled"
 CONF_OFFLINE_SKIP_UPDATES = "offline_skip_updates"
 CONF_CUSTOM_COMMAND = "custom_command"
 CONF_FORCE_NEW_RANGE = "force_new_range"
@@ -13,8 +14,11 @@ CONF_ON_ONLINE = "on_online"
 CONF_ON_OFFLINE = "on_offline"
 CONF_RAW_ENCODE = "raw_encode"
 CONF_REGISTER_COUNT = "register_count"
+CONF_REGISTER_LAST_ADDRESS = "register_last_address"
 CONF_REGISTER_TYPE = "register_type"
+CONF_REGISTER_VALUE = "register_value"
 CONF_RESPONSE_SIZE = "response_size"
+CONF_SERVER_COURTESY_RESPONSE = "server_courtesy_response"
 CONF_SKIP_UPDATES = "skip_updates"
 CONF_USE_WRITE_MULTIPLE = "use_write_multiple"
 CONF_VALUE_TYPE = "value_type"