Store strings only used for logging in flash (#2274)

Co-authored-by: Otto winter <otto@otto-winter.com>

esphome/components/binary_sensor/binary_sensor.h

@@ -10,7 +10,7 @@ namespace binary_sensor {
 
 #define LOG_BINARY_SENSOR(prefix, type, obj) \
   if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
     if (!(obj)->get_device_class().empty()) { \
       ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class().c_str()); \
     } \

esphome/components/climate/climate.cpp

@@ -9,8 +9,8 @@ void ClimateCall::perform() {
   ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
   this->validate_();
   if (this->mode_.has_value()) {
-    const char *mode_s = climate_mode_to_string(*this->mode_);
-    ESP_LOGD(TAG, "  Mode: %s", mode_s);
+    const LogString *mode_s = climate_mode_to_string(*this->mode_);
+    ESP_LOGD(TAG, "  Mode: %s", LOG_STR_ARG(mode_s));
   }
   if (this->custom_fan_mode_.has_value()) {
     this->fan_mode_.reset();
@@ -18,8 +18,8 @@ void ClimateCall::perform() {
   }
   if (this->fan_mode_.has_value()) {
     this->custom_fan_mode_.reset();
-    const char *fan_mode_s = climate_fan_mode_to_string(*this->fan_mode_);
-    ESP_LOGD(TAG, "  Fan: %s", fan_mode_s);
+    const LogString *fan_mode_s = climate_fan_mode_to_string(*this->fan_mode_);
+    ESP_LOGD(TAG, "  Fan: %s", LOG_STR_ARG(fan_mode_s));
   }
   if (this->custom_preset_.has_value()) {
     this->preset_.reset();
@@ -27,12 +27,12 @@ void ClimateCall::perform() {
   }
   if (this->preset_.has_value()) {
     this->custom_preset_.reset();
-    const char *preset_s = climate_preset_to_string(*this->preset_);
-    ESP_LOGD(TAG, "  Preset: %s", preset_s);
+    const LogString *preset_s = climate_preset_to_string(*this->preset_);
+    ESP_LOGD(TAG, "  Preset: %s", LOG_STR_ARG(preset_s));
   }
   if (this->swing_mode_.has_value()) {
-    const char *swing_mode_s = climate_swing_mode_to_string(*this->swing_mode_);
-    ESP_LOGD(TAG, "  Swing: %s", swing_mode_s);
+    const LogString *swing_mode_s = climate_swing_mode_to_string(*this->swing_mode_);
+    ESP_LOGD(TAG, "  Swing: %s", LOG_STR_ARG(swing_mode_s));
   }
   if (this->target_temperature_.has_value()) {
     ESP_LOGD(TAG, "  Target Temperature: %.2f", *this->target_temperature_);
@@ -50,7 +50,7 @@ void ClimateCall::validate_() {
   if (this->mode_.has_value()) {
     auto mode = *this->mode_;
     if (!traits.supports_mode(mode)) {
-      ESP_LOGW(TAG, "  Mode %s is not supported by this device!", climate_mode_to_string(mode));
+      ESP_LOGW(TAG, "  Mode %s is not supported by this device!", LOG_STR_ARG(climate_mode_to_string(mode)));
       this->mode_.reset();
     }
   }
@@ -63,7 +63,8 @@ void ClimateCall::validate_() {
   } else if (this->fan_mode_.has_value()) {
     auto fan_mode = *this->fan_mode_;
     if (!traits.supports_fan_mode(fan_mode)) {
-      ESP_LOGW(TAG, "  Fan Mode %s is not supported by this device!", climate_fan_mode_to_string(fan_mode));
+      ESP_LOGW(TAG, "  Fan Mode %s is not supported by this device!",
+               LOG_STR_ARG(climate_fan_mode_to_string(fan_mode)));
       this->fan_mode_.reset();
     }
   }
@@ -76,14 +77,15 @@ void ClimateCall::validate_() {
   } else if (this->preset_.has_value()) {
     auto preset = *this->preset_;
     if (!traits.supports_preset(preset)) {
-      ESP_LOGW(TAG, "  Preset %s is not supported by this device!", climate_preset_to_string(preset));
+      ESP_LOGW(TAG, "  Preset %s is not supported by this device!", LOG_STR_ARG(climate_preset_to_string(preset)));
       this->preset_.reset();
     }
   }
   if (this->swing_mode_.has_value()) {
     auto swing_mode = *this->swing_mode_;
     if (!traits.supports_swing_mode(swing_mode)) {
-      ESP_LOGW(TAG, "  Swing Mode %s is not supported by this device!", climate_swing_mode_to_string(swing_mode));
+      ESP_LOGW(TAG, "  Swing Mode %s is not supported by this device!",
+               LOG_STR_ARG(climate_swing_mode_to_string(swing_mode)));
       this->swing_mode_.reset();
     }
   }
@@ -373,24 +375,24 @@ void Climate::publish_state() {
   ESP_LOGD(TAG, "'%s' - Sending state:", this->name_.c_str());
   auto traits = this->get_traits();
 
-  ESP_LOGD(TAG, "  Mode: %s", climate_mode_to_string(this->mode));
+  ESP_LOGD(TAG, "  Mode: %s", LOG_STR_ARG(climate_mode_to_string(this->mode)));
   if (traits.get_supports_action()) {
-    ESP_LOGD(TAG, "  Action: %s", climate_action_to_string(this->action));
+    ESP_LOGD(TAG, "  Action: %s", LOG_STR_ARG(climate_action_to_string(this->action)));
   }
   if (traits.get_supports_fan_modes() && this->fan_mode.has_value()) {
-    ESP_LOGD(TAG, "  Fan Mode: %s", climate_fan_mode_to_string(this->fan_mode.value()));
+    ESP_LOGD(TAG, "  Fan Mode: %s", LOG_STR_ARG(climate_fan_mode_to_string(this->fan_mode.value())));
   }
   if (!traits.get_supported_custom_fan_modes().empty() && this->custom_fan_mode.has_value()) {
     ESP_LOGD(TAG, "  Custom Fan Mode: %s", this->custom_fan_mode.value().c_str());
   }
   if (traits.get_supports_presets() && this->preset.has_value()) {
-    ESP_LOGD(TAG, "  Preset: %s", climate_preset_to_string(this->preset.value()));
+    ESP_LOGD(TAG, "  Preset: %s", LOG_STR_ARG(climate_preset_to_string(this->preset.value())));
   }
   if (!traits.get_supported_custom_presets().empty() && this->custom_preset.has_value()) {
     ESP_LOGD(TAG, "  Custom Preset: %s", this->custom_preset.value().c_str());
   }
   if (traits.get_supports_swing_modes()) {
-    ESP_LOGD(TAG, "  Swing Mode: %s", climate_swing_mode_to_string(this->swing_mode));
+    ESP_LOGD(TAG, "  Swing Mode: %s", LOG_STR_ARG(climate_swing_mode_to_string(this->swing_mode)));
   }
   if (traits.get_supports_current_temperature()) {
     ESP_LOGD(TAG, "  Current Temperature: %.2f°C", this->current_temperature);
@@ -534,12 +536,12 @@ void Climate::dump_traits_(const char *tag) {
   if (!traits.get_supported_modes().empty()) {
     ESP_LOGCONFIG(tag, "  [x] Supported modes:");
     for (ClimateMode m : traits.get_supported_modes())
-      ESP_LOGCONFIG(tag, "      - %s", climate_mode_to_string(m));
+      ESP_LOGCONFIG(tag, "      - %s", LOG_STR_ARG(climate_mode_to_string(m)));
   }
   if (!traits.get_supported_fan_modes().empty()) {
     ESP_LOGCONFIG(tag, "  [x] Supported fan modes:");
     for (ClimateFanMode m : traits.get_supported_fan_modes())
-      ESP_LOGCONFIG(tag, "      - %s", climate_fan_mode_to_string(m));
+      ESP_LOGCONFIG(tag, "      - %s", LOG_STR_ARG(climate_fan_mode_to_string(m)));
   }
   if (!traits.get_supported_custom_fan_modes().empty()) {
     ESP_LOGCONFIG(tag, "  [x] Supported custom fan modes:");
@@ -549,7 +551,7 @@ void Climate::dump_traits_(const char *tag) {
   if (!traits.get_supported_presets().empty()) {
     ESP_LOGCONFIG(tag, "  [x] Supported presets:");
     for (ClimatePreset p : traits.get_supported_presets())
-      ESP_LOGCONFIG(tag, "      - %s", climate_preset_to_string(p));
+      ESP_LOGCONFIG(tag, "      - %s", LOG_STR_ARG(climate_preset_to_string(p)));
   }
   if (!traits.get_supported_custom_presets().empty()) {
     ESP_LOGCONFIG(tag, "  [x] Supported custom presets:");
@@ -559,7 +561,7 @@ void Climate::dump_traits_(const char *tag) {
   if (!traits.get_supported_swing_modes().empty()) {
     ESP_LOGCONFIG(tag, "  [x] Supported swing modes:");
     for (ClimateSwingMode m : traits.get_supported_swing_modes())
-      ESP_LOGCONFIG(tag, "      - %s", climate_swing_mode_to_string(m));
+      ESP_LOGCONFIG(tag, "      - %s", LOG_STR_ARG(climate_swing_mode_to_string(m)));
   }
 }
 

esphome/components/climate/climate.h

@@ -12,7 +12,7 @@ namespace climate {
 
 #define LOG_CLIMATE(prefix, type, obj) \
   if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
   }
 
 class Climate;

esphome/components/climate/climate_mode.cpp

@@ -3,105 +3,105 @@
 namespace esphome {
 namespace climate {
 
-const char *climate_mode_to_string(ClimateMode mode) {
+const LogString *climate_mode_to_string(ClimateMode mode) {
   switch (mode) {
     case CLIMATE_MODE_OFF:
-      return "OFF";
-    case CLIMATE_MODE_AUTO:
-      return "AUTO";
-    case CLIMATE_MODE_COOL:
-      return "COOL";
-    case CLIMATE_MODE_HEAT:
-      return "HEAT";
-    case CLIMATE_MODE_FAN_ONLY:
-      return "FAN_ONLY";
-    case CLIMATE_MODE_DRY:
-      return "DRY";
+      return LOG_STR("OFF");
     case CLIMATE_MODE_HEAT_COOL:
-      return "HEAT_COOL";
+      return LOG_STR("HEAT_COOL");
+    case CLIMATE_MODE_AUTO:
+      return LOG_STR("AUTO");
+    case CLIMATE_MODE_COOL:
+      return LOG_STR("COOL");
+    case CLIMATE_MODE_HEAT:
+      return LOG_STR("HEAT");
+    case CLIMATE_MODE_FAN_ONLY:
+      return LOG_STR("FAN_ONLY");
+    case CLIMATE_MODE_DRY:
+      return LOG_STR("DRY");
     default:
-      return "UNKNOWN";
+      return LOG_STR("UNKNOWN");
   }
 }
-const char *climate_action_to_string(ClimateAction action) {
+const LogString *climate_action_to_string(ClimateAction action) {
   switch (action) {
     case CLIMATE_ACTION_OFF:
-      return "OFF";
+      return LOG_STR("OFF");
     case CLIMATE_ACTION_COOLING:
-      return "COOLING";
+      return LOG_STR("COOLING");
     case CLIMATE_ACTION_HEATING:
-      return "HEATING";
+      return LOG_STR("HEATING");
     case CLIMATE_ACTION_IDLE:
-      return "IDLE";
+      return LOG_STR("IDLE");
     case CLIMATE_ACTION_DRYING:
-      return "DRYING";
+      return LOG_STR("DRYING");
     case CLIMATE_ACTION_FAN:
-      return "FAN";
+      return LOG_STR("FAN");
     default:
-      return "UNKNOWN";
+      return LOG_STR("UNKNOWN");
   }
 }
 
-const char *climate_fan_mode_to_string(ClimateFanMode fan_mode) {
+const LogString *climate_fan_mode_to_string(ClimateFanMode fan_mode) {
   switch (fan_mode) {
     case climate::CLIMATE_FAN_ON:
-      return "ON";
+      return LOG_STR("ON");
     case climate::CLIMATE_FAN_OFF:
-      return "OFF";
+      return LOG_STR("OFF");
     case climate::CLIMATE_FAN_AUTO:
-      return "AUTO";
+      return LOG_STR("AUTO");
     case climate::CLIMATE_FAN_LOW:
-      return "LOW";
+      return LOG_STR("LOW");
     case climate::CLIMATE_FAN_MEDIUM:
-      return "MEDIUM";
+      return LOG_STR("MEDIUM");
     case climate::CLIMATE_FAN_HIGH:
-      return "HIGH";
+      return LOG_STR("HIGH");
     case climate::CLIMATE_FAN_MIDDLE:
-      return "MIDDLE";
+      return LOG_STR("MIDDLE");
     case climate::CLIMATE_FAN_FOCUS:
-      return "FOCUS";
+      return LOG_STR("FOCUS");
     case climate::CLIMATE_FAN_DIFFUSE:
-      return "DIFFUSE";
+      return LOG_STR("DIFFUSE");
     default:
-      return "UNKNOWN";
+      return LOG_STR("UNKNOWN");
   }
 }
 
-const char *climate_swing_mode_to_string(ClimateSwingMode swing_mode) {
+const LogString *climate_swing_mode_to_string(ClimateSwingMode swing_mode) {
   switch (swing_mode) {
     case climate::CLIMATE_SWING_OFF:
-      return "OFF";
+      return LOG_STR("OFF");
     case climate::CLIMATE_SWING_BOTH:
-      return "BOTH";
+      return LOG_STR("BOTH");
     case climate::CLIMATE_SWING_VERTICAL:
-      return "VERTICAL";
+      return LOG_STR("VERTICAL");
     case climate::CLIMATE_SWING_HORIZONTAL:
-      return "HORIZONTAL";
+      return LOG_STR("HORIZONTAL");
     default:
-      return "UNKNOWN";
+      return LOG_STR("UNKNOWN");
   }
 }
 
-const char *climate_preset_to_string(ClimatePreset preset) {
+const LogString *climate_preset_to_string(ClimatePreset preset) {
   switch (preset) {
     case climate::CLIMATE_PRESET_NONE:
-      return "NONE";
+      return LOG_STR("NONE");
     case climate::CLIMATE_PRESET_HOME:
-      return "HOME";
+      return LOG_STR("HOME");
     case climate::CLIMATE_PRESET_ECO:
-      return "ECO";
+      return LOG_STR("ECO");
     case climate::CLIMATE_PRESET_AWAY:
-      return "AWAY";
+      return LOG_STR("AWAY");
     case climate::CLIMATE_PRESET_BOOST:
-      return "BOOST";
+      return LOG_STR("BOOST");
     case climate::CLIMATE_PRESET_COMFORT:
-      return "COMFORT";
+      return LOG_STR("COMFORT");
     case climate::CLIMATE_PRESET_SLEEP:
-      return "SLEEP";
+      return LOG_STR("SLEEP");
     case climate::CLIMATE_PRESET_ACTIVITY:
-      return "ACTIVITY";
+      return LOG_STR("ACTIVITY");
     default:
-      return "UNKNOWN";
+      return LOG_STR("UNKNOWN");
   }
 }
 

esphome/components/climate/climate_mode.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace climate {
@@ -96,19 +97,19 @@ enum ClimatePreset : uint8_t {
 };
 
 /// Convert the given ClimateMode to a human-readable string.
-const char *climate_mode_to_string(ClimateMode mode);
+const LogString *climate_mode_to_string(ClimateMode mode);
 
 /// Convert the given ClimateAction to a human-readable string.
-const char *climate_action_to_string(ClimateAction action);
+const LogString *climate_action_to_string(ClimateAction action);
 
 /// Convert the given ClimateFanMode to a human-readable string.
-const char *climate_fan_mode_to_string(ClimateFanMode mode);
+const LogString *climate_fan_mode_to_string(ClimateFanMode mode);
 
 /// Convert the given ClimateSwingMode to a human-readable string.
-const char *climate_swing_mode_to_string(ClimateSwingMode mode);
+const LogString *climate_swing_mode_to_string(ClimateSwingMode mode);
 
 /// Convert the given ClimateSwingMode to a human-readable string.
-const char *climate_preset_to_string(ClimatePreset preset);
+const LogString *climate_preset_to_string(ClimatePreset preset);
 
 }  // namespace climate
 }  // namespace esphome

esphome/components/cover/cover.h

@@ -13,7 +13,7 @@ const extern float COVER_CLOSED;
 
 #define LOG_COVER(prefix, type, obj) \
   if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
     auto traits_ = (obj)->get_traits(); \
     if (traits_.get_is_assumed_state()) { \
       ESP_LOGCONFIG(TAG, "%s  Assumed State: YES", prefix); \

esphome/components/gpio/switch/gpio_switch.cpp

@@ -47,28 +47,28 @@ void GPIOSwitch::setup() {
 void GPIOSwitch::dump_config() {
   LOG_SWITCH("", "GPIO Switch", this);
   LOG_PIN("  Pin: ", this->pin_);
-  const char *restore_mode = "";
+  const LogString *restore_mode = LOG_STR("");
   switch (this->restore_mode_) {
     case GPIO_SWITCH_RESTORE_DEFAULT_OFF:
-      restore_mode = "Restore (Defaults to OFF)";
+      restore_mode = LOG_STR("Restore (Defaults to OFF)");
       break;
     case GPIO_SWITCH_RESTORE_DEFAULT_ON:
-      restore_mode = "Restore (Defaults to ON)";
+      restore_mode = LOG_STR("Restore (Defaults to ON)");
       break;
     case GPIO_SWITCH_RESTORE_INVERTED_DEFAULT_ON:
-      restore_mode = "Restore inverted (Defaults to ON)";
+      restore_mode = LOG_STR("Restore inverted (Defaults to ON)");
       break;
     case GPIO_SWITCH_RESTORE_INVERTED_DEFAULT_OFF:
-      restore_mode = "Restore inverted (Defaults to OFF)";
+      restore_mode = LOG_STR("Restore inverted (Defaults to OFF)");
       break;
     case GPIO_SWITCH_ALWAYS_OFF:
-      restore_mode = "Always OFF";
+      restore_mode = LOG_STR("Always OFF");
       break;
     case GPIO_SWITCH_ALWAYS_ON:
-      restore_mode = "Always ON";
+      restore_mode = LOG_STR("Always ON");
       break;
   }
-  ESP_LOGCONFIG(TAG, "  Restore Mode: %s", restore_mode);
+  ESP_LOGCONFIG(TAG, "  Restore Mode: %s", LOG_STR_ARG(restore_mode));
   if (!this->interlock_.empty()) {
     ESP_LOGCONFIG(TAG, "  Interlocks:");
     for (auto *lock : this->interlock_) {

esphome/components/hitachi_ac344/hitachi_ac344.cpp

@@ -165,7 +165,7 @@ void HitachiClimate::transmit_state() {
       set_power_(false);
       break;
     default:
-      ESP_LOGW(TAG, "Unsupported mode: %s", climate_mode_to_string(this->mode));
+      ESP_LOGW(TAG, "Unsupported mode: %s", LOG_STR_ARG(climate_mode_to_string(this->mode)));
   }
 
   set_temp_(static_cast<uint8_t>(this->target_temperature));

esphome/components/hitachi_ac424/hitachi_ac424.cpp

@@ -166,7 +166,7 @@ void HitachiClimate::transmit_state() {
       set_power_(false);
       break;
     default:
-      ESP_LOGW(TAG, "Unsupported mode: %s", climate_mode_to_string(this->mode));
+      ESP_LOGW(TAG, "Unsupported mode: %s", LOG_STR_ARG(climate_mode_to_string(this->mode)));
   }
 
   set_temp_(static_cast<uint8_t>(this->target_temperature));

esphome/components/light/light_call.cpp

@@ -7,24 +7,24 @@ namespace light {
 
 static const char *const TAG = "light";
 
-static const char *color_mode_to_human(ColorMode color_mode) {
+static const LogString *color_mode_to_human(ColorMode color_mode) {
   if (color_mode == ColorMode::UNKNOWN)
-    return "Unknown";
+    return LOG_STR("Unknown");
   if (color_mode == ColorMode::WHITE)
-    return "White";
+    return LOG_STR("White");
   if (color_mode == ColorMode::COLOR_TEMPERATURE)
-    return "Color temperature";
+    return LOG_STR("Color temperature");
   if (color_mode == ColorMode::COLD_WARM_WHITE)
-    return "Cold/warm white";
+    return LOG_STR("Cold/warm white");
   if (color_mode == ColorMode::RGB)
-    return "RGB";
+    return LOG_STR("RGB");
   if (color_mode == ColorMode::RGB_WHITE)
-    return "RGBW";
+    return LOG_STR("RGBW");
   if (color_mode == ColorMode::RGB_COLD_WARM_WHITE)
-    return "RGB + cold/warm white";
+    return LOG_STR("RGB + cold/warm white");
   if (color_mode == ColorMode::RGB_COLOR_TEMPERATURE)
-    return "RGB + color temperature";
-  return "";
+    return LOG_STR("RGB + color temperature");
+  return LOG_STR("");
 }
 
 void LightCall::perform() {
@@ -37,7 +37,7 @@ void LightCall::perform() {
     // Only print color mode when it's being changed
     ColorMode current_color_mode = this->parent_->remote_values.get_color_mode();
     if (this->color_mode_.value_or(current_color_mode) != current_color_mode) {
-      ESP_LOGD(TAG, "  Color mode: %s", color_mode_to_human(v.get_color_mode()));
+      ESP_LOGD(TAG, "  Color mode: %s", LOG_STR_ARG(color_mode_to_human(v.get_color_mode())));
     }
 
     // Only print state when it's being changed
@@ -135,7 +135,7 @@ LightColorValues LightCall::validate_() {
   // Color mode check
   if (this->color_mode_.has_value() && !traits.supports_color_mode(this->color_mode_.value())) {
     ESP_LOGW(TAG, "'%s' - This light does not support color mode %s!", name,
-             color_mode_to_human(this->color_mode_.value()));
+             LOG_STR_ARG(color_mode_to_human(this->color_mode_.value())));
     this->color_mode_.reset();
   }
 
@@ -206,7 +206,8 @@ LightColorValues LightCall::validate_() {
   if (name_##_.has_value()) { \
     auto val = *name_##_; \
     if (val < (min) || val > (max)) { \
-      ESP_LOGW(TAG, "'%s' - %s value %.2f is out of range [%.1f - %.1f]!", name, upper_name, val, (min), (max)); \
+      ESP_LOGW(TAG, "'%s' - %s value %.2f is out of range [%.1f - %.1f]!", name, LOG_STR_LITERAL(upper_name), val, \
+               (min), (max)); \
       name_##_ = clamp(val, (min), (max)); \
     } \
   }
@@ -387,7 +388,7 @@ ColorMode LightCall::compute_color_mode_() {
   // Don't change if the current mode is suitable.
   if (suitable_modes.count(current_mode) > 0) {
     ESP_LOGI(TAG, "'%s' - Keeping current color mode %s for call without color mode.",
-             this->parent_->get_name().c_str(), color_mode_to_human(current_mode));
+             this->parent_->get_name().c_str(), LOG_STR_ARG(color_mode_to_human(current_mode)));
     return current_mode;
   }
 
@@ -397,7 +398,7 @@ ColorMode LightCall::compute_color_mode_() {
       continue;
 
     ESP_LOGI(TAG, "'%s' - Using color mode %s for call without color mode.", this->parent_->get_name().c_str(),
-             color_mode_to_human(mode));
+             LOG_STR_ARG(color_mode_to_human(mode)));
     return mode;
   }
 
@@ -405,7 +406,7 @@ ColorMode LightCall::compute_color_mode_() {
   // out whatever we don't support.
   auto color_mode = current_mode != ColorMode::UNKNOWN ? current_mode : *supported_modes.begin();
   ESP_LOGW(TAG, "'%s' - No color mode suitable for this call supported, defaulting to %s!",
-           this->parent_->get_name().c_str(), color_mode_to_human(color_mode));
+           this->parent_->get_name().c_str(), LOG_STR_ARG(color_mode_to_human(color_mode)));
   return color_mode;
 }
 std::set<ColorMode> LightCall::get_suitable_color_modes_() {

esphome/components/mqtt/mqtt_client.cpp

@@ -221,40 +221,40 @@ void MQTTClientComponent::check_connected() {
 
 void MQTTClientComponent::loop() {
   if (this->disconnect_reason_.has_value()) {
-    const char *reason_s = nullptr;
+    const LogString *reason_s;
     switch (*this->disconnect_reason_) {
       case AsyncMqttClientDisconnectReason::TCP_DISCONNECTED:
-        reason_s = "TCP disconnected";
+        reason_s = LOG_STR("TCP disconnected");
         break;
       case AsyncMqttClientDisconnectReason::MQTT_UNACCEPTABLE_PROTOCOL_VERSION:
-        reason_s = "Unacceptable Protocol Version";
+        reason_s = LOG_STR("Unacceptable Protocol Version");
         break;
       case AsyncMqttClientDisconnectReason::MQTT_IDENTIFIER_REJECTED:
-        reason_s = "Identifier Rejected";
+        reason_s = LOG_STR("Identifier Rejected");
         break;
       case AsyncMqttClientDisconnectReason::MQTT_SERVER_UNAVAILABLE:
-        reason_s = "Server Unavailable";
+        reason_s = LOG_STR("Server Unavailable");
         break;
       case AsyncMqttClientDisconnectReason::MQTT_MALFORMED_CREDENTIALS:
-        reason_s = "Malformed Credentials";
+        reason_s = LOG_STR("Malformed Credentials");
         break;
       case AsyncMqttClientDisconnectReason::MQTT_NOT_AUTHORIZED:
-        reason_s = "Not Authorized";
+        reason_s = LOG_STR("Not Authorized");
         break;
       case AsyncMqttClientDisconnectReason::ESP8266_NOT_ENOUGH_SPACE:
-        reason_s = "Not Enough Space";
+        reason_s = LOG_STR("Not Enough Space");
         break;
       case AsyncMqttClientDisconnectReason::TLS_BAD_FINGERPRINT:
-        reason_s = "TLS Bad Fingerprint";
+        reason_s = LOG_STR("TLS Bad Fingerprint");
         break;
       default:
-        reason_s = "Unknown";
+        reason_s = LOG_STR("Unknown");
         break;
     }
     if (!network_is_connected()) {
-      reason_s = "WiFi disconnected";
+      reason_s = LOG_STR("WiFi disconnected");
     }
-    ESP_LOGW(TAG, "MQTT Disconnected: %s.", reason_s);
+    ESP_LOGW(TAG, "MQTT Disconnected: %s.", LOG_STR_ARG(reason_s));
     this->disconnect_reason_.reset();
   }
 

esphome/components/number/number.h

@@ -8,7 +8,7 @@ namespace number {
 
 #define LOG_NUMBER(prefix, type, obj) \
   if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
     if (!(obj)->traits.get_icon().empty()) { \
       ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->traits.get_icon().c_str()); \
     } \

esphome/components/select/select.h

@@ -10,7 +10,7 @@ namespace select {
 
 #define LOG_SELECT(prefix, type, obj) \
   if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
     if (!(obj)->traits.get_icon().empty()) { \
       ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->traits.get_icon().c_str()); \
     } \

esphome/components/sensor/sensor.cpp

@@ -6,15 +6,15 @@ namespace sensor {
 
 static const char *const TAG = "sensor";
 
-const char *state_class_to_string(StateClass state_class) {
+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_NONE:
     default:
-      return "";
+      return LOG_STR("");
   }
 }
 

esphome/components/sensor/sensor.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "esphome/core/log.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/components/sensor/filter.h"
@@ -9,11 +10,11 @@ namespace sensor {
 
 #define LOG_SENSOR(prefix, type, obj) \
   if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
     if (!(obj)->get_device_class().empty()) { \
       ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class().c_str()); \
     } \
-    ESP_LOGCONFIG(TAG, "%s  State Class: '%s'", prefix, state_class_to_string((obj)->state_class)); \
+    ESP_LOGCONFIG(TAG, "%s  State Class: '%s'", prefix, LOG_STR_ARG(state_class_to_string((obj)->state_class))); \
     ESP_LOGCONFIG(TAG, "%s  Unit of Measurement: '%s'", prefix, (obj)->get_unit_of_measurement().c_str()); \
     ESP_LOGCONFIG(TAG, "%s  Accuracy Decimals: %d", prefix, (obj)->get_accuracy_decimals()); \
     if (!(obj)->get_icon().empty()) { \
@@ -36,7 +37,7 @@ enum StateClass : uint8_t {
   STATE_CLASS_TOTAL_INCREASING = 2,
 };
 
-const char *state_class_to_string(StateClass state_class);
+const LogString *state_class_to_string(StateClass state_class);
 
 /** Base-class for all sensors.
  *

esphome/components/switch/switch.h

@@ -9,7 +9,7 @@ namespace switch_ {
 
 #define LOG_SWITCH(prefix, type, obj) \
   if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
     if (!(obj)->get_icon().empty()) { \
       ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
     } \

esphome/components/text_sensor/text_sensor.h

@@ -8,7 +8,7 @@ namespace text_sensor {
 
 #define LOG_TEXT_SENSOR(prefix, type, obj) \
   if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
     if (!(obj)->get_icon().empty()) { \
       ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
     } \

esphome/components/uart/uart.cpp

@@ -58,21 +58,21 @@ void UARTDevice::check_uart_settings(uint32_t baud_rate, uint8_t stop_bits, UART
              this->parent_->data_bits_);
   }
   if (this->parent_->parity_ != parity) {
-    ESP_LOGE(TAG, "  Invalid parity: Integration requested parity %s but you have %s!", parity_to_str(parity),
-             parity_to_str(this->parent_->parity_));
+    ESP_LOGE(TAG, "  Invalid parity: Integration requested parity %s but you have %s!",
+             LOG_STR_ARG(parity_to_str(parity)), LOG_STR_ARG(parity_to_str(this->parent_->parity_)));
   }
 }
 
-const char *parity_to_str(UARTParityOptions parity) {
+const LogString *parity_to_str(UARTParityOptions parity) {
   switch (parity) {
     case UART_CONFIG_PARITY_NONE:
-      return "NONE";
+      return LOG_STR("NONE");
     case UART_CONFIG_PARITY_EVEN:
-      return "EVEN";
+      return LOG_STR("EVEN");
     case UART_CONFIG_PARITY_ODD:
-      return "ODD";
+      return LOG_STR("ODD");
     default:
-      return "UNKNOWN";
+      return LOG_STR("UNKNOWN");
   }
 }
 

esphome/components/uart/uart.h

@@ -4,6 +4,7 @@
 #include <HardwareSerial.h>
 #include "esphome/core/esphal.h"
 #include "esphome/core/component.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace uart {
@@ -14,7 +15,7 @@ enum UARTParityOptions {
   UART_CONFIG_PARITY_ODD,
 };
 
-const char *parity_to_str(UARTParityOptions parity);
+const LogString *parity_to_str(UARTParityOptions parity);
 
 #ifdef ARDUINO_ARCH_ESP8266
 class ESP8266SoftwareSerial {

esphome/components/uart/uart_esp8266.cpp

@@ -104,7 +104,7 @@ void UARTComponent::dump_config() {
   }
   ESP_LOGCONFIG(TAG, "  Baud Rate: %u baud", this->baud_rate_);
   ESP_LOGCONFIG(TAG, "  Data Bits: %u", this->data_bits_);
-  ESP_LOGCONFIG(TAG, "  Parity: %s", parity_to_str(this->parity_));
+  ESP_LOGCONFIG(TAG, "  Parity: %s", LOG_STR_ARG(parity_to_str(this->parity_)));
   ESP_LOGCONFIG(TAG, "  Stop bits: %u", this->stop_bits_);
   if (this->hw_serial_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  Using hardware serial interface.");