esphome 2025.8.4__py3-none-any.whl → 2025.9.0b1__py3-none-any.whl

esphome/components/sen5x/sensor.py

@@ -65,26 +65,47 @@ ACCELERATION_MODES = {
     "high": RhtAccelerationMode.HIGH_ACCELERATION,
 }
 
-GAS_SENSOR = cv.Schema(
-    {
-        cv.Optional(CONF_ALGORITHM_TUNING): cv.Schema(
-            {
-                cv.Optional(CONF_INDEX_OFFSET, default=100): cv.int_range(1, 250),
-                cv.Optional(CONF_LEARNING_TIME_OFFSET_HOURS, default=12): cv.int_range(
-                    1, 1000
-                ),
-                cv.Optional(CONF_LEARNING_TIME_GAIN_HOURS, default=12): cv.int_range(
-                    1, 1000
-                ),
-                cv.Optional(
-                    CONF_GATING_MAX_DURATION_MINUTES, default=720
-                ): cv.int_range(0, 3000),
-                cv.Optional(CONF_STD_INITIAL, default=50): cv.int_,
-                cv.Optional(CONF_GAIN_FACTOR, default=230): cv.int_range(1, 1000),
-            }
-        )
-    }
-)
+
+def _gas_sensor(
+    *,
+    index_offset: int,
+    learning_time_offset: int,
+    learning_time_gain: int,
+    gating_max_duration: int,
+    std_initial: int,
+    gain_factor: int,
+) -> cv.Schema:
+    return sensor.sensor_schema(
+        icon=ICON_RADIATOR,
+        accuracy_decimals=0,
+        device_class=DEVICE_CLASS_AQI,
+        state_class=STATE_CLASS_MEASUREMENT,
+    ).extend(
+        {
+            cv.Optional(CONF_ALGORITHM_TUNING): cv.Schema(
+                {
+                    cv.Optional(CONF_INDEX_OFFSET, default=index_offset): cv.int_range(
+                        1, 250
+                    ),
+                    cv.Optional(
+                        CONF_LEARNING_TIME_OFFSET_HOURS, default=learning_time_offset
+                    ): cv.int_range(1, 1000),
+                    cv.Optional(
+                        CONF_LEARNING_TIME_GAIN_HOURS, default=learning_time_gain
+                    ): cv.int_range(1, 1000),
+                    cv.Optional(
+                        CONF_GATING_MAX_DURATION_MINUTES, default=gating_max_duration
+                    ): cv.int_range(0, 3000),
+                    cv.Optional(CONF_STD_INITIAL, default=std_initial): cv.int_range(
+                        10, 5000
+                    ),
+                    cv.Optional(CONF_GAIN_FACTOR, default=gain_factor): cv.int_range(
+                        1, 1000
+                    ),
+                }
+            )
+        }
+    )
 
 
 def float_previously_pct(value):
@@ -127,18 +148,22 @@ CONFIG_SCHEMA = (
                 state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_AUTO_CLEANING_INTERVAL): cv.update_interval,
-            cv.Optional(CONF_VOC): sensor.sensor_schema(
-                icon=ICON_RADIATOR,
-                accuracy_decimals=0,
-                device_class=DEVICE_CLASS_AQI,
-                state_class=STATE_CLASS_MEASUREMENT,
-            ).extend(GAS_SENSOR),
-            cv.Optional(CONF_NOX): sensor.sensor_schema(
-                icon=ICON_RADIATOR,
-                accuracy_decimals=0,
-                device_class=DEVICE_CLASS_AQI,
-                state_class=STATE_CLASS_MEASUREMENT,
-            ).extend(GAS_SENSOR),
+            cv.Optional(CONF_VOC): _gas_sensor(
+                index_offset=100,
+                learning_time_offset=12,
+                learning_time_gain=12,
+                gating_max_duration=180,
+                std_initial=50,
+                gain_factor=230,
+            ),
+            cv.Optional(CONF_NOX): _gas_sensor(
+                index_offset=1,
+                learning_time_offset=12,
+                learning_time_gain=12,
+                gating_max_duration=720,
+                std_initial=50,
+                gain_factor=230,
+            ),
             cv.Optional(CONF_STORE_BASELINE, default=True): cv.boolean,
             cv.Optional(CONF_VOC_BASELINE): cv.hex_uint16_t,
             cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
@@ -194,16 +219,15 @@ async def to_code(config):
     await i2c.register_i2c_device(var, config)
 
     for key, funcName in SETTING_MAP.items():
-        if key in config:
-            cg.add(getattr(var, funcName)(config[key]))
+        if cfg := config.get(key):
+            cg.add(getattr(var, funcName)(cfg))
 
     for key, funcName in SENSOR_MAP.items():
-        if key in config:
-            sens = await sensor.new_sensor(config[key])
+        if cfg := config.get(key):
+            sens = await sensor.new_sensor(cfg)
             cg.add(getattr(var, funcName)(sens))
 
-    if CONF_VOC in config and CONF_ALGORITHM_TUNING in config[CONF_VOC]:
-        cfg = config[CONF_VOC][CONF_ALGORITHM_TUNING]
+    if cfg := config.get(CONF_VOC, {}).get(CONF_ALGORITHM_TUNING):
         cg.add(
             var.set_voc_algorithm_tuning(
                 cfg[CONF_INDEX_OFFSET],
@@ -214,8 +238,7 @@ async def to_code(config):
                 cfg[CONF_GAIN_FACTOR],
             )
         )
-    if CONF_NOX in config and CONF_ALGORITHM_TUNING in config[CONF_NOX]:
-        cfg = config[CONF_NOX][CONF_ALGORITHM_TUNING]
+    if cfg := config.get(CONF_NOX, {}).get(CONF_ALGORITHM_TUNING):
         cg.add(
             var.set_nox_algorithm_tuning(
                 cfg[CONF_INDEX_OFFSET],
@@ -225,12 +248,12 @@ async def to_code(config):
                 cfg[CONF_GAIN_FACTOR],
             )
         )
-    if CONF_TEMPERATURE_COMPENSATION in config:
+    if cfg := config.get(CONF_TEMPERATURE_COMPENSATION):
         cg.add(
             var.set_temperature_compensation(
-                config[CONF_TEMPERATURE_COMPENSATION][CONF_OFFSET],
-                config[CONF_TEMPERATURE_COMPENSATION][CONF_NORMALIZED_OFFSET_SLOPE],
-                config[CONF_TEMPERATURE_COMPENSATION][CONF_TIME_CONSTANT],
+                cfg[CONF_OFFSET],
+                cfg[CONF_NORMALIZED_OFFSET_SLOPE],
+                cfg[CONF_TIME_CONSTANT],
             )
         )
 

esphome/components/sensirion_common/i2c_sensirion.cpp

@@ -11,21 +11,22 @@ static const char *const TAG = "sensirion_i2c";
 // To avoid memory allocations for small writes a stack buffer is used
 static const size_t BUFFER_STACK_SIZE = 16;
 
-bool SensirionI2CDevice::read_data(uint16_t *data, uint8_t len) {
+bool SensirionI2CDevice::read_data(uint16_t *data, const uint8_t len) {
   const uint8_t num_bytes = len * 3;
-  std::vector<uint8_t> buf(num_bytes);
+  uint8_t buf[num_bytes];
 
-  last_error_ = this->read(buf.data(), num_bytes);
-  if (last_error_ != i2c::ERROR_OK) {
+  this->last_error_ = this->read(buf, num_bytes);
+  if (this->last_error_ != i2c::ERROR_OK) {
     return false;
   }
 
   for (uint8_t i = 0; i < len; i++) {
     const uint8_t j = 3 * i;
-    uint8_t crc = sht_crc_(buf[j], buf[j + 1]);
+    // Use MSB first since Sensirion devices use CRC-8 with MSB first
+    uint8_t crc = crc8(&buf[j], 2, 0xFF, CRC_POLYNOMIAL, true);
     if (crc != buf[j + 2]) {
-      ESP_LOGE(TAG, "CRC8 Checksum invalid at pos %d! 0x%02X != 0x%02X", i, buf[j + 2], crc);
-      last_error_ = i2c::ERROR_CRC;
+      ESP_LOGE(TAG, "CRC invalid @ %d! 0x%02X != 0x%02X", i, buf[j + 2], crc);
+      this->last_error_ = i2c::ERROR_CRC;
       return false;
     }
     data[i] = encode_uint16(buf[j], buf[j + 1]);
@@ -34,10 +35,10 @@ bool SensirionI2CDevice::read_data(uint16_t *data, uint8_t len) {
 }
 /***
  * write command with parameters and insert crc
- * use stack array for less than 4 parameters. Most sensirion i2c commands have less parameters
+ * use stack array for less than 4 parameters. Most Sensirion I2C commands have less parameters
  */
 bool SensirionI2CDevice::write_command_(uint16_t command, CommandLen command_len, const uint16_t *data,
-                                        uint8_t data_len) {
+                                        const uint8_t data_len) {
   uint8_t temp_stack[BUFFER_STACK_SIZE];
   std::unique_ptr<uint8_t[]> temp_heap;
   uint8_t *temp;
@@ -74,56 +75,26 @@ bool SensirionI2CDevice::write_command_(uint16_t command, CommandLen command_len
     temp[raw_idx++] = data[i] & 0xFF;
     temp[raw_idx++] = data[i] >> 8;
 #endif
-    temp[raw_idx++] = sht_crc_(data[i]);
+    // Use MSB first since Sensirion devices use CRC-8 with MSB first
+    temp[raw_idx++] = crc8(&temp[raw_idx - 2], 2, 0xFF, CRC_POLYNOMIAL, true);
   }
-  last_error_ = this->write(temp, raw_idx);
-  return last_error_ == i2c::ERROR_OK;
+  this->last_error_ = this->write(temp, raw_idx);
+  return this->last_error_ == i2c::ERROR_OK;
 }
 
-bool SensirionI2CDevice::get_register_(uint16_t reg, CommandLen command_len, uint16_t *data, uint8_t len,
-                                       uint8_t delay_ms) {
+bool SensirionI2CDevice::get_register_(uint16_t reg, CommandLen command_len, uint16_t *data, const uint8_t len,
+                                       const uint8_t delay_ms) {
   if (!this->write_command_(reg, command_len, nullptr, 0)) {
-    ESP_LOGE(TAG, "Failed to write i2c register=0x%X (%d) err=%d,", reg, command_len, this->last_error_);
+    ESP_LOGE(TAG, "Write failed: reg=0x%X (%d) err=%d,", reg, command_len, this->last_error_);
     return false;
   }
   delay(delay_ms);
   bool result = this->read_data(data, len);
   if (!result) {
-    ESP_LOGE(TAG, "Failed to read data from register=0x%X err=%d,", reg, this->last_error_);
+    ESP_LOGE(TAG, "Read failed: reg=0x%X err=%d,", reg, this->last_error_);
   }
   return result;
 }
 
-// The 8-bit CRC checksum is transmitted after each data word
-uint8_t SensirionI2CDevice::sht_crc_(uint16_t data) {
-  uint8_t bit;
-  uint8_t crc = 0xFF;
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-  crc ^= data >> 8;
-#else
-  crc ^= data & 0xFF;
-#endif
-  for (bit = 8; bit > 0; --bit) {
-    if (crc & 0x80) {
-      crc = (crc << 1) ^ crc_polynomial_;
-    } else {
-      crc = (crc << 1);
-    }
-  }
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-  crc ^= data & 0xFF;
-#else
-  crc ^= data >> 8;
-#endif
-  for (bit = 8; bit > 0; --bit) {
-    if (crc & 0x80) {
-      crc = (crc << 1) ^ crc_polynomial_;
-    } else {
-      crc = (crc << 1);
-    }
-  }
-  return crc;
-}
-
 }  // namespace sensirion_common
 }  // namespace esphome

esphome/components/sensirion_common/i2c_sensirion.h

@@ -8,90 +8,92 @@ namespace esphome {
 namespace sensirion_common {
 
 /**
- * Implementation of a i2c functions for Sensirion sensors
- * Sensirion data requires crc checking.
+ * Implementation of I2C functions for Sensirion sensors
+ * Sensirion data requires CRC checking.
  * Each 16 bit word is/must be followed 8 bit CRC code
- * (Applies to read and write - note the i2c command code doesn't need a CRC)
+ * (Applies to read and write - note the I2C command code doesn't need a CRC)
  * Format:
  *   | 16 Bit Command Code | 16 bit Data word 1 | CRC of DW 1 | 16 bit Data word 1 | CRC of DW 2 | ..
  */
+static const uint8_t CRC_POLYNOMIAL = 0x31;  // default for Sensirion
+
 class SensirionI2CDevice : public i2c::I2CDevice {
  public:
   enum CommandLen : uint8_t { ADDR_8_BIT = 1, ADDR_16_BIT = 2 };
 
-  /** Read data words from i2c device.
-   * handles crc check used by Sensirion sensors
+  /** Read data words from I2C device.
+   * handles CRC check used by Sensirion sensors
    * @param data pointer to raw result
    * @param len number of words to read
    * @return true if reading succeeded
    */
   bool read_data(uint16_t *data, uint8_t len);
 
-  /** Read 1 data word from i2c device.
+  /** Read 1 data word from I2C device.
    * @param data reference to raw result
    * @return true if reading succeeded
    */
   bool read_data(uint16_t &data) { return this->read_data(&data, 1); }
 
-  /** get data words from i2c register.
-   * handles crc check used by Sensirion sensors
-   * @param  i2c register
+  /** get data words from I2C register.
+   * handles CRC check used by Sensirion sensors
+   * @param  I2C register
    * @param data pointer to raw result
    * @param len number of words to read
-   * @param delay milliseconds to to wait between sending the i2c command and reading the result
+   * @param delay milliseconds to to wait between sending the I2C command and reading the result
    * @return true if reading succeeded
    */
   bool get_register(uint16_t command, uint16_t *data, uint8_t len, uint8_t delay = 0) {
     return get_register_(command, ADDR_16_BIT, data, len, delay);
   }
-  /** Read 1 data word from 16 bit i2c register.
-   * @param  i2c register
+  /** Read 1 data word from 16 bit I2C register.
+   * @param  I2C register
    * @param data reference to raw result
-   * @param delay milliseconds to to wait between sending the i2c command and reading the result
+   * @param delay milliseconds to to wait between sending the I2C command and reading the result
    * @return true if reading succeeded
    */
   bool get_register(uint16_t i2c_register, uint16_t &data, uint8_t delay = 0) {
     return this->get_register_(i2c_register, ADDR_16_BIT, &data, 1, delay);
   }
 
-  /** get data words from i2c register.
-   * handles crc check used by Sensirion sensors
-   * @param  i2c register
+  /** get data words from I2C register.
+   * handles CRC check used by Sensirion sensors
+   * @param  I2C register
    * @param data pointer to raw result
    * @param len number of words to read
-   * @param delay milliseconds to to wait between sending the i2c command and reading the result
+   * @param delay milliseconds to to wait between sending the I2C command and reading the result
    * @return true if reading succeeded
    */
   bool get_8bit_register(uint8_t i2c_register, uint16_t *data, uint8_t len, uint8_t delay = 0) {
     return get_register_(i2c_register, ADDR_8_BIT, data, len, delay);
   }
 
-  /** Read 1 data word from 8 bit i2c register.
-   * @param  i2c register
+  /** Read 1 data word from 8 bit I2C register.
+   * @param  I2C register
    * @param data reference to raw result
-   * @param delay milliseconds to to wait between sending the i2c command and reading the result
+   * @param delay milliseconds to to wait between sending the I2C command and reading the result
    * @return true if reading succeeded
    */
   bool get_8bit_register(uint8_t i2c_register, uint16_t &data, uint8_t delay = 0) {
     return this->get_register_(i2c_register, ADDR_8_BIT, &data, 1, delay);
   }
 
-  /** Write a command to the i2c device.
-   * @param command i2c command to send
+  /** Write a command to the I2C device.
+   * @param command I2C command to send
    * @return true if reading succeeded
    */
   template<class T> bool write_command(T i2c_register) { return write_command(i2c_register, nullptr, 0); }
 
-  /** Write a command and one data word to the i2c device .
-   * @param command i2c command to send
-   * @param data argument for the i2c command
+  /** Write a command and one data word to the I2C device .
+   * @param command I2C command to send
+   * @param data argument for the I2C command
    * @return true if reading succeeded
    */
   template<class T> bool write_command(T i2c_register, uint16_t data) { return write_command(i2c_register, &data, 1); }
 
   /** Write a command with arguments as words
-   * @param i2c_register i2c command to send - an be uint8_t or uint16_t
-   * @param data vector<uint16> arguments for the i2c command
+   * @param i2c_register I2C command to send - an be uint8_t or uint16_t
+   * @param data vector<uint16> arguments for the I2C command
    * @return true if reading succeeded
    */
   template<class T> bool write_command(T i2c_register, const std::vector<uint16_t> &data) {
@@ -99,57 +101,39 @@ class SensirionI2CDevice : public i2c::I2CDevice {
   }
 
   /** Write a command with arguments as words
-   * @param i2c_register i2c command to send - an be uint8_t or uint16_t
-   * @param data arguments for the i2c command
+   * @param i2c_register I2C command to send - an be uint8_t or uint16_t
+   * @param data arguments for the I2C command
    * @param len number of arguments (words)
    * @return true if reading succeeded
    */
   template<class T> bool write_command(T i2c_register, const uint16_t *data, uint8_t len) {
     // limit to 8 or 16 bit only
-    static_assert(sizeof(i2c_register) == 1 || sizeof(i2c_register) == 2,
-                  "only 8 or 16 bit command types are supported.");
+    static_assert(sizeof(i2c_register) == 1 || sizeof(i2c_register) == 2, "Only 8 or 16 bit command types supported");
     return write_command_(i2c_register, CommandLen(sizeof(T)), data, len);
   }
 
  protected:
-  uint8_t crc_polynomial_{0x31u};  // default for sensirion
   /** Write a command with arguments as words
-   * @param command i2c command to send can be uint8_t or uint16_t
+   * @param command I2C command to send can be uint8_t or uint16_t
    * @param command_len either 1 for short 8 bit command or 2 for 16 bit command codes
-   * @param data arguments for the i2c command
+   * @param data arguments for the I2C command
    * @param data_len number of arguments (words)
    * @return true if reading succeeded
    */
   bool write_command_(uint16_t command, CommandLen command_len, const uint16_t *data, uint8_t data_len);
 
-  /** get data words from i2c register.
-   * handles crc check used by Sensirion sensors
-   * @param  i2c register
+  /** get data words from I2C register.
+   * handles CRC check used by Sensirion sensors
+   * @param  I2C register
    * @param command_len either 1 for short 8 bit command or 2 for 16 bit command codes
    * @param data pointer to raw result
    * @param len number of words to read
-   * @param delay milliseconds to to wait between sending the i2c command and reading the result
+   * @param delay milliseconds to to wait between sending the I2C command and reading the result
    * @return true if reading succeeded
    */
   bool get_register_(uint16_t reg, CommandLen command_len, uint16_t *data, uint8_t len, uint8_t delay);
 
-  /** 8-bit CRC checksum that is transmitted after each data word for read and write operation
-   * @param command i2c command to send
-   * @param data data word for which the crc8 checksum is calculated
-   * @param len number of arguments (words)
-   * @return 8 Bit CRC
-   */
-  uint8_t sht_crc_(uint16_t data);
-
-  /** 8-bit CRC checksum that is transmitted after each data word for read and write operation
-   * @param command i2c command to send
-   * @param data1 high byte of data word
-   * @param data2 low byte of data word
-   * @return 8 Bit CRC
-   */
-  uint8_t sht_crc_(uint8_t data1, uint8_t data2) { return sht_crc_(encode_uint16(data1, data2)); }
-
-  /** last error code from i2c operation
+  /** last error code from I2C operation
    */
   i2c::ErrorCode last_error_;
 };

esphome/components/sensor/__init__.py

@@ -101,7 +101,7 @@ from esphome.const import (
     DEVICE_CLASS_WIND_SPEED,
     ENTITY_CATEGORY_CONFIG,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 from esphome.util import Registry
@@ -1142,6 +1142,6 @@ def _lstsq(a, b):
     return _mat_dot(_mat_dot(x, a_t), b)
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(sensor_ns.using)

esphome/components/sensor/automation.h

@@ -40,7 +40,7 @@ class ValueRangeTrigger : public Trigger<float>, public Component {
   template<typename V> void set_max(V max) { this->max_ = max; }
 
   void setup() override {
-    this->rtc_ = global_preferences->make_preference<bool>(this->parent_->get_object_id_hash());
+    this->rtc_ = global_preferences->make_preference<bool>(this->parent_->get_preference_hash());
     bool initial_state;
     if (this->rtc_.load(&initial_state)) {
       this->previous_in_range_ = initial_state;

esphome/components/sensor/sensor.cpp

@@ -6,17 +6,45 @@ namespace sensor {
 
 static const char *const TAG = "sensor";
 
-std::string state_class_to_string(StateClass state_class) {
+// Function implementation of LOG_SENSOR macro to reduce code size
+void log_sensor(const char *tag, const char *prefix, const char *type, Sensor *obj) {
+  if (obj == nullptr) {
+    return;
+  }
+
+  ESP_LOGCONFIG(tag,
+                "%s%s '%s'\n"
+                "%s  State Class: '%s'\n"
+                "%s  Unit of Measurement: '%s'\n"
+                "%s  Accuracy Decimals: %d",
+                prefix, type, obj->get_name().c_str(), prefix,
+                LOG_STR_ARG(state_class_to_string(obj->get_state_class())), prefix,
+                obj->get_unit_of_measurement_ref().c_str(), prefix, obj->get_accuracy_decimals());
+
+  if (!obj->get_device_class_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class_ref().c_str());
+  }
+
+  if (!obj->get_icon_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
+  }
+
+  if (obj->get_force_update()) {
+    ESP_LOGV(tag, "%s  Force Update: YES", prefix);
+  }
+}
+
+const LogString *state_class_to_string(StateClass state_class) {
   switch (state_class) {
     case STATE_CLASS_MEASUREMENT:
-      return "measurement";
+      return LOG_STR("measurement");
     case STATE_CLASS_TOTAL_INCREASING:
-      return "total_increasing";
+      return LOG_STR("total_increasing");
     case STATE_CLASS_TOTAL:
-      return "total";
+      return LOG_STR("total");
     case STATE_CLASS_NONE:
     default:
-      return "";
+      return LOG_STR("");
   }
 }
 
@@ -101,7 +129,7 @@ void Sensor::internal_send_state_to_frontend(float state) {
   this->set_has_state(true);
   this->state = state;
   ESP_LOGD(TAG, "'%s': Sending state %.5f %s with %d decimals of accuracy", this->get_name().c_str(), state,
-           this->get_unit_of_measurement().c_str(), this->get_accuracy_decimals());
+           this->get_unit_of_measurement_ref().c_str(), this->get_accuracy_decimals());
   this->callback_.call(state);
 }
 

esphome/components/sensor/sensor.h

@@ -12,26 +12,9 @@
 namespace esphome {
 namespace sensor {
 
-#define LOG_SENSOR(prefix, type, obj) \
-  if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, \
-                  "%s%s '%s'\n" \
-                  "%s  State Class: '%s'\n" \
-                  "%s  Unit of Measurement: '%s'\n" \
-                  "%s  Accuracy Decimals: %d", \
-                  prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str(), prefix, \
-                  state_class_to_string((obj)->get_state_class()).c_str(), prefix, \
-                  (obj)->get_unit_of_measurement().c_str(), prefix, (obj)->get_accuracy_decimals()); \
-    if (!(obj)->get_device_class().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class().c_str()); \
-    } \
-    if (!(obj)->get_icon().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
-    } \
-    if ((obj)->get_force_update()) { \
-      ESP_LOGV(TAG, "%s  Force Update: YES", prefix); \
-    } \
-  }
+void log_sensor(const char *tag, const char *prefix, const char *type, Sensor *obj);
+
+#define LOG_SENSOR(prefix, type, obj) log_sensor(TAG, prefix, LOG_STR_LITERAL(type), obj)
 
 #define SUB_SENSOR(name) \
  protected: \
@@ -50,7 +33,7 @@ enum StateClass : uint8_t {
   STATE_CLASS_TOTAL = 3,
 };
 
-std::string state_class_to_string(StateClass state_class);
+const LogString *state_class_to_string(StateClass state_class);
 
 /** Base-class for all sensors.
  *