Merge pull request #2051 from esphome/bump-1.20.0

1.20.0

esphome/components/adc/adc_sensor.cpp

@@ -11,7 +11,30 @@ namespace adc {
 static const char *const TAG = "adc";
 
 #ifdef ARDUINO_ARCH_ESP32
-void ADCSensor::set_attenuation(adc_attenuation_t attenuation) { this->attenuation_ = attenuation; }
+void ADCSensor::set_attenuation(adc_atten_t attenuation) { this->attenuation_ = attenuation; }
+
+inline adc1_channel_t gpio_to_adc1(uint8_t pin) {
+  switch (pin) {
+    case 36:
+      return ADC1_CHANNEL_0;
+    case 37:
+      return ADC1_CHANNEL_1;
+    case 38:
+      return ADC1_CHANNEL_2;
+    case 39:
+      return ADC1_CHANNEL_3;
+    case 32:
+      return ADC1_CHANNEL_4;
+    case 33:
+      return ADC1_CHANNEL_5;
+    case 34:
+      return ADC1_CHANNEL_6;
+    case 35:
+      return ADC1_CHANNEL_7;
+    default:
+      return ADC1_CHANNEL_MAX;
+  }
+}
 #endif
 
 void ADCSensor::setup() {
@@ -21,7 +44,9 @@ void ADCSensor::setup() {
 #endif
 
 #ifdef ARDUINO_ARCH_ESP32
-  analogSetPinAttenuation(this->pin_, this->attenuation_);
+  adc1_config_channel_atten(gpio_to_adc1(pin_), attenuation_);
+  adc1_config_width(ADC_WIDTH_BIT_12);
+  adc_gpio_init(ADC_UNIT_1, (adc_channel_t) gpio_to_adc1(pin_));
 #endif
 }
 void ADCSensor::dump_config() {
@@ -36,18 +61,20 @@ void ADCSensor::dump_config() {
 #ifdef ARDUINO_ARCH_ESP32
   ESP_LOGCONFIG(TAG, "  Pin: %u", this->pin_);
   switch (this->attenuation_) {
-    case ADC_0db:
+    case ADC_ATTEN_DB_0:
       ESP_LOGCONFIG(TAG, " Attenuation: 0db (max 1.1V)");
       break;
-    case ADC_2_5db:
+    case ADC_ATTEN_DB_2_5:
       ESP_LOGCONFIG(TAG, " Attenuation: 2.5db (max 1.5V)");
       break;
-    case ADC_6db:
+    case ADC_ATTEN_DB_6:
       ESP_LOGCONFIG(TAG, " Attenuation: 6db (max 2.2V)");
       break;
-    case ADC_11db:
+    case ADC_ATTEN_DB_11:
       ESP_LOGCONFIG(TAG, " Attenuation: 11db (max 3.9V)");
       break;
+    default:  // This is to satisfy the unused ADC_ATTEN_MAX
+      break;
   }
 #endif
   LOG_UPDATE_INTERVAL(this);
@@ -60,20 +87,23 @@ void ADCSensor::update() {
 }
 float ADCSensor::sample() {
 #ifdef ARDUINO_ARCH_ESP32
-  float value_v = analogRead(this->pin_) / 4095.0f;  // NOLINT
+  int raw = adc1_get_raw(gpio_to_adc1(pin_));
+  float value_v = raw / 4095.0f;
   switch (this->attenuation_) {
-    case ADC_0db:
+    case ADC_ATTEN_DB_0:
       value_v *= 1.1;
       break;
-    case ADC_2_5db:
+    case ADC_ATTEN_DB_2_5:
       value_v *= 1.5;
       break;
-    case ADC_6db:
+    case ADC_ATTEN_DB_6:
       value_v *= 2.2;
       break;
-    case ADC_11db:
+    case ADC_ATTEN_DB_11:
       value_v *= 3.9;
       break;
+    default:  // This is to satisfy the unused ADC_ATTEN_MAX
+      break;
   }
   return value_v;
 #endif

esphome/components/adc/adc_sensor.h

@@ -6,6 +6,10 @@
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/voltage_sampler/voltage_sampler.h"
 
+#ifdef ARDUINO_ARCH_ESP32
+#include "driver/adc.h"
+#endif
+
 namespace esphome {
 namespace adc {
 
@@ -13,7 +17,7 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
  public:
 #ifdef ARDUINO_ARCH_ESP32
   /// Set the attenuation for this pin. Only available on the ESP32.
-  void set_attenuation(adc_attenuation_t attenuation);
+  void set_attenuation(adc_atten_t attenuation);
 #endif
 
   /// Update adc values.
@@ -34,7 +38,7 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
   uint8_t pin_;
 
 #ifdef ARDUINO_ARCH_ESP32
-  adc_attenuation_t attenuation_{ADC_0db};
+  adc_atten_t attenuation_{ADC_ATTEN_DB_0};
 #endif
 };
 

esphome/components/adc/sensor.py

@@ -16,10 +16,10 @@ from esphome.const import (
 AUTO_LOAD = ["voltage_sampler"]
 
 ATTENUATION_MODES = {
-    "0db": cg.global_ns.ADC_0db,
+    "0db": cg.global_ns.ADC_ATTEN_DB_0,
-    "2.5db": cg.global_ns.ADC_2_5db,
+    "2.5db": cg.global_ns.ADC_ATTEN_DB_2_5,
-    "6db": cg.global_ns.ADC_6db,
+    "6db": cg.global_ns.ADC_ATTEN_DB_6,
-    "11db": cg.global_ns.ADC_11db,
+    "11db": cg.global_ns.ADC_ATTEN_DB_11,
 }
 
 

esphome/components/ads1115/ads1115.cpp

@@ -64,11 +64,6 @@ void ADS1115Component::setup() {
     return;
   }
   this->prev_config_ = config;
-
-  for (auto *sensor : this->sensors_) {
-    this->set_interval(sensor->get_name(), sensor->update_interval(),
-                       [this, sensor] { this->request_measurement(sensor); });
-  }
 }
 void ADS1115Component::dump_config() {
   ESP_LOGCONFIG(TAG, "Setting up ADS1115...");
@@ -107,17 +102,22 @@ float ADS1115Component::request_measurement(ADS1115Sensor *sensor) {
     }
     this->prev_config_ = config;
 
-    // about 1.6 ms with 860 samples per second
+    // about 1.2 ms with 860 samples per second
     delay(2);
 
-    uint32_t start = millis();
+    // in continuous mode, conversion will always be running, rely on the delay
-    while (this->read_byte_16(ADS1115_REGISTER_CONFIG, &config) && (config >> 15) == 0) {
+    // to ensure conversion is taking place with the correct settings
-      if (millis() - start > 100) {
+    // can we use the rdy pin to trigger when a conversion is done?
-        ESP_LOGW(TAG, "Reading ADS1115 timed out");
+    if (!this->continuous_mode_) {
-        this->status_set_warning();
+      uint32_t start = millis();
-        return NAN;
+      while (this->read_byte_16(ADS1115_REGISTER_CONFIG, &config) && (config >> 15) == 0) {
+        if (millis() - start > 100) {
+          ESP_LOGW(TAG, "Reading ADS1115 timed out");
+          this->status_set_warning();
+          return NAN;
+        }
+        yield();
       }
-      yield();
     }
   }
 

esphome/components/api/api.proto

@@ -422,6 +422,12 @@ enum SensorStateClass {
   STATE_CLASS_MEASUREMENT = 1;
 }
 
+enum SensorLastResetType {
+  LAST_RESET_NONE = 0;
+  LAST_RESET_NEVER = 1;
+  LAST_RESET_AUTO = 2;
+}
+
 message ListEntitiesSensorResponse {
   option (id) = 16;
   option (source) = SOURCE_SERVER;
@@ -438,6 +444,7 @@ message ListEntitiesSensorResponse {
   bool force_update = 8;
   string device_class = 9;
   SensorStateClass state_class = 10;
+  SensorLastResetType last_reset_type = 11;
 }
 message SensorStateResponse {
   option (id) = 25;

esphome/components/api/api_connection.cpp

@@ -399,6 +399,7 @@ bool APIConnection::send_sensor_info(sensor::Sensor *sensor) {
   msg.force_update = sensor->get_force_update();
   msg.device_class = sensor->get_device_class();
   msg.state_class = static_cast<enums::SensorStateClass>(sensor->state_class);
+  msg.last_reset_type = static_cast<enums::SensorLastResetType>(sensor->last_reset_type);
 
   return this->send_list_entities_sensor_response(msg);
 }

esphome/components/api/api_pb2.cpp

@@ -72,6 +72,18 @@ template<> const char *proto_enum_to_string<enums::SensorStateClass>(enums::Sens
       return "UNKNOWN";
   }
 }
+template<> const char *proto_enum_to_string<enums::SensorLastResetType>(enums::SensorLastResetType value) {
+  switch (value) {
+    case enums::LAST_RESET_NONE:
+      return "LAST_RESET_NONE";
+    case enums::LAST_RESET_NEVER:
+      return "LAST_RESET_NEVER";
+    case enums::LAST_RESET_AUTO:
+      return "LAST_RESET_AUTO";
+    default:
+      return "UNKNOWN";
+  }
+}
 template<> const char *proto_enum_to_string<enums::LogLevel>(enums::LogLevel value) {
   switch (value) {
     case enums::LOG_LEVEL_NONE:
@@ -1592,6 +1604,10 @@ bool ListEntitiesSensorResponse::decode_varint(uint32_t field_id, ProtoVarInt va
       this->state_class = value.as_enum<enums::SensorStateClass>();
       return true;
     }
+    case 11: {
+      this->last_reset_type = value.as_enum<enums::SensorLastResetType>();
+      return true;
+    }
     default:
       return false;
   }
@@ -1647,6 +1663,7 @@ void ListEntitiesSensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(8, this->force_update);
   buffer.encode_string(9, this->device_class);
   buffer.encode_enum<enums::SensorStateClass>(10, this->state_class);
+  buffer.encode_enum<enums::SensorLastResetType>(11, this->last_reset_type);
 }
 void ListEntitiesSensorResponse::dump_to(std::string &out) const {
   char buffer[64];
@@ -1692,6 +1709,10 @@ void ListEntitiesSensorResponse::dump_to(std::string &out) const {
   out.append("  state_class: ");
   out.append(proto_enum_to_string<enums::SensorStateClass>(this->state_class));
   out.append("\n");
+
+  out.append("  last_reset_type: ");
+  out.append(proto_enum_to_string<enums::SensorLastResetType>(this->last_reset_type));
+  out.append("\n");
   out.append("}");
 }
 bool SensorStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {

esphome/components/api/api_pb2.h

@@ -36,6 +36,11 @@ enum SensorStateClass : uint32_t {
   STATE_CLASS_NONE = 0,
   STATE_CLASS_MEASUREMENT = 1,
 };
+enum SensorLastResetType : uint32_t {
+  LAST_RESET_NONE = 0,
+  LAST_RESET_NEVER = 1,
+  LAST_RESET_AUTO = 2,
+};
 enum LogLevel : uint32_t {
   LOG_LEVEL_NONE = 0,
   LOG_LEVEL_ERROR = 1,
@@ -429,6 +434,7 @@ class ListEntitiesSensorResponse : public ProtoMessage {
   bool force_update{false};
   std::string device_class{};
   enums::SensorStateClass state_class{};
+  enums::SensorLastResetType last_reset_type{};
   void encode(ProtoWriteBuffer buffer) const override;
   void dump_to(std::string &out) const override;
 

esphome/components/atm90e32/sensor.py

@@ -21,6 +21,7 @@ from esphome.const import (
     ICON_EMPTY,
     ICON_LIGHTBULB,
     ICON_CURRENT_AC,
+    LAST_RESET_TYPE_AUTO,
     STATE_CLASS_MEASUREMENT,
     UNIT_HERTZ,
     UNIT_VOLT,
@@ -91,10 +92,20 @@ ATM90E32_PHASE_SCHEMA = cv.Schema(
             STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional(CONF_FORWARD_ACTIVE_ENERGY): sensor.sensor_schema(
-            UNIT_WATT_HOURS, ICON_EMPTY, 2, DEVICE_CLASS_ENERGY, STATE_CLASS_MEASUREMENT
+            UNIT_WATT_HOURS,
+            ICON_EMPTY,
+            2,
+            DEVICE_CLASS_ENERGY,
+            STATE_CLASS_MEASUREMENT,
+            LAST_RESET_TYPE_AUTO,
         ),
         cv.Optional(CONF_REVERSE_ACTIVE_ENERGY): sensor.sensor_schema(
-            UNIT_WATT_HOURS, ICON_EMPTY, 2, DEVICE_CLASS_ENERGY, STATE_CLASS_MEASUREMENT
+            UNIT_WATT_HOURS,
+            ICON_EMPTY,
+            2,
+            DEVICE_CLASS_ENERGY,
+            STATE_CLASS_MEASUREMENT,
+            LAST_RESET_TYPE_AUTO,
         ),
         cv.Optional(CONF_GAIN_VOLTAGE, default=7305): cv.uint16_t,
         cv.Optional(CONF_GAIN_CT, default=27961): cv.uint16_t,

esphome/components/havells_solar/sensor.py

@@ -15,6 +15,7 @@ from esphome.const import (
     DEVICE_CLASS_VOLTAGE,
     ICON_CURRENT_AC,
     ICON_EMPTY,
+    LAST_RESET_TYPE_AUTO,
     STATE_CLASS_MEASUREMENT,
     STATE_CLASS_NONE,
     UNIT_AMPERE,
@@ -121,14 +122,16 @@ CONFIG_SCHEMA = (
                 ICON_EMPTY,
                 2,
                 DEVICE_CLASS_ENERGY,
-                STATE_CLASS_NONE,
+                STATE_CLASS_MEASUREMENT,
+                LAST_RESET_TYPE_AUTO,
             ),
             cv.Optional(CONF_TOTAL_ENERGY_PRODUCTION): sensor.sensor_schema(
                 UNIT_KILOWATT_HOURS,
                 ICON_EMPTY,
                 0,
                 DEVICE_CLASS_ENERGY,
-                STATE_CLASS_NONE,
+                STATE_CLASS_MEASUREMENT,
+                LAST_RESET_TYPE_AUTO,
             ),
             cv.Optional(CONF_TOTAL_GENERATION_TIME): sensor.sensor_schema(
                 UNIT_HOURS,

esphome/components/hlw8012/sensor.py

@@ -19,8 +19,8 @@ from esphome.const import (
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_VOLTAGE,
     ICON_EMPTY,
+    LAST_RESET_TYPE_AUTO,
     STATE_CLASS_MEASUREMENT,
-    STATE_CLASS_NONE,
     UNIT_VOLT,
     UNIT_AMPERE,
     UNIT_WATT,
@@ -67,7 +67,12 @@ CONFIG_SCHEMA = cv.Schema(
             UNIT_WATT, ICON_EMPTY, 1, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT
         ),
         cv.Optional(CONF_ENERGY): sensor.sensor_schema(
-            UNIT_WATT_HOURS, ICON_EMPTY, 1, DEVICE_CLASS_ENERGY, STATE_CLASS_NONE
+            UNIT_WATT_HOURS,
+            ICON_EMPTY,
+            1,
+            DEVICE_CLASS_ENERGY,
+            STATE_CLASS_MEASUREMENT,
+            LAST_RESET_TYPE_AUTO,
         ),
         cv.Optional(CONF_CURRENT_RESISTOR, default=0.001): cv.resistance,
         cv.Optional(CONF_VOLTAGE_DIVIDER, default=2351): cv.positive_float,

esphome/components/light/addressable_light.cpp

@@ -68,10 +68,7 @@ void AddressableLight::write_state(LightState *state) {
 
     // our transition will handle brightness, disable brightness in correction.
     this->correction_.set_local_brightness(255);
-    uint8_t orig_w = target_color.w;
     target_color *= static_cast<uint8_t>(roundf(end_values.get_brightness() * end_values.get_state() * 255.0f));
-    // w is not scaled by brightness
-    target_color.w = orig_w;
 
     float denom = (1.0f - new_smoothed);
     float alpha = denom == 0.0f ? 0.0f : (new_smoothed - prev_smoothed) / denom;

esphome/components/midea_ac/midea_climate.h

@@ -6,6 +6,9 @@
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/midea_dongle/midea_dongle.h"
 #include "esphome/components/climate/climate.h"
+#include "esphome/components/midea_dongle/midea_dongle.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/core/component.h"
 #include "midea_frame.h"
 
 namespace esphome {

esphome/components/midea_ac/midea_frame.h

@@ -102,8 +102,11 @@ class PropertiesFrame : public midea_dongle::BaseFrame {
   void set_sleep_mode(bool state) { this->set_bytemask_(20, 0x01, state); }
 
   /* TURBO MODE */
-  bool get_turbo_mode() const { return this->pbuf_[18] & 0x20; }
+  bool get_turbo_mode() const { return this->pbuf_[18] & 0x20 || this->pbuf_[20] & 0x02; }
-  void set_turbo_mode(bool state) { this->set_bytemask_(18, 0x20, state); }
+  void set_turbo_mode(bool state) {
+    this->set_bytemask_(18, 0x20, state);
+    this->set_bytemask_(20, 0x02, state);
+  }
 
   /* FREEZE PROTECTION */
   bool get_freeze_protection_mode() const { return this->pbuf_[31] & 0x80; }

esphome/components/pzem004t/sensor.py

@@ -12,8 +12,8 @@ from esphome.const import (
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_VOLTAGE,
     ICON_EMPTY,
+    LAST_RESET_TYPE_AUTO,
     STATE_CLASS_MEASUREMENT,
-    STATE_CLASS_NONE,
     UNIT_VOLT,
     UNIT_AMPERE,
     UNIT_WATT,
@@ -47,7 +47,8 @@ CONFIG_SCHEMA = (
                 ICON_EMPTY,
                 0,
                 DEVICE_CLASS_ENERGY,
-                STATE_CLASS_NONE,
+                STATE_CLASS_MEASUREMENT,
+                LAST_RESET_TYPE_AUTO,
             ),
         }
     )

esphome/components/pzemac/sensor.py

@@ -17,8 +17,8 @@ from esphome.const import (
     DEVICE_CLASS_ENERGY,
     ICON_EMPTY,
     ICON_CURRENT_AC,
+    LAST_RESET_TYPE_AUTO,
     STATE_CLASS_MEASUREMENT,
-    STATE_CLASS_NONE,
     UNIT_HERTZ,
     UNIT_VOLT,
     UNIT_AMPERE,
@@ -54,7 +54,8 @@ CONFIG_SCHEMA = (
                 ICON_EMPTY,
                 0,
                 DEVICE_CLASS_ENERGY,
-                STATE_CLASS_NONE,
+                STATE_CLASS_MEASUREMENT,
+                LAST_RESET_TYPE_AUTO,
             ),
             cv.Optional(CONF_FREQUENCY): sensor.sensor_schema(
                 UNIT_HERTZ,

esphome/components/sdm_meter/sensor.py

@@ -25,8 +25,8 @@ from esphome.const import (
     ICON_CURRENT_AC,
     ICON_EMPTY,
     ICON_FLASH,
+    LAST_RESET_TYPE_AUTO,
     STATE_CLASS_MEASUREMENT,
-    STATE_CLASS_NONE,
     UNIT_AMPERE,
     UNIT_DEGREES,
     UNIT_EMPTY,
@@ -88,24 +88,36 @@ CONFIG_SCHEMA = (
                 STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_IMPORT_ACTIVE_ENERGY): sensor.sensor_schema(
-                UNIT_WATT_HOURS, ICON_EMPTY, 2, DEVICE_CLASS_ENERGY, STATE_CLASS_NONE
+                UNIT_WATT_HOURS,
+                ICON_EMPTY,
+                2,
+                DEVICE_CLASS_ENERGY,
+                STATE_CLASS_MEASUREMENT,
+                LAST_RESET_TYPE_AUTO,
             ),
             cv.Optional(CONF_EXPORT_ACTIVE_ENERGY): sensor.sensor_schema(
-                UNIT_WATT_HOURS, ICON_EMPTY, 2, DEVICE_CLASS_ENERGY, STATE_CLASS_NONE
+                UNIT_WATT_HOURS,
+                ICON_EMPTY,
+                2,
+                DEVICE_CLASS_ENERGY,
+                STATE_CLASS_MEASUREMENT,
+                LAST_RESET_TYPE_AUTO,
             ),
             cv.Optional(CONF_IMPORT_REACTIVE_ENERGY): sensor.sensor_schema(
                 UNIT_VOLT_AMPS_REACTIVE_HOURS,
                 ICON_EMPTY,
                 2,
                 DEVICE_CLASS_ENERGY,
-                STATE_CLASS_NONE,
+                STATE_CLASS_MEASUREMENT,
+                LAST_RESET_TYPE_AUTO,
             ),
             cv.Optional(CONF_EXPORT_REACTIVE_ENERGY): sensor.sensor_schema(
                 UNIT_VOLT_AMPS_REACTIVE_HOURS,
                 ICON_EMPTY,
                 2,
                 DEVICE_CLASS_ENERGY,
-                STATE_CLASS_NONE,
+                STATE_CLASS_MEASUREMENT,
+                LAST_RESET_TYPE_AUTO,
             ),
         }
     )

esphome/components/sensor/__init__.py

@@ -17,6 +17,7 @@ from esphome.const import (
     CONF_ICON,
     CONF_ID,
     CONF_INTERNAL,
+    CONF_LAST_RESET_TYPE,
     CONF_ON_RAW_VALUE,
     CONF_ON_VALUE,
     CONF_ON_VALUE_RANGE,
@@ -30,6 +31,9 @@ from esphome.const import (
     CONF_NAME,
     CONF_MQTT_ID,
     CONF_FORCE_UPDATE,
+    LAST_RESET_TYPE_AUTO,
+    LAST_RESET_TYPE_NEVER,
+    LAST_RESET_TYPE_NONE,
     UNIT_EMPTY,
     ICON_EMPTY,
     DEVICE_CLASS_EMPTY,
@@ -79,6 +83,15 @@ STATE_CLASSES = {
 }
 validate_state_class = cv.enum(STATE_CLASSES, lower=True, space="_")
 
+LastResetTypes = sensor_ns.enum("LastResetType")
+LAST_RESET_TYPES = {
+    LAST_RESET_TYPE_NONE: LastResetTypes.LAST_RESET_TYPE_NONE,
+    LAST_RESET_TYPE_NEVER: LastResetTypes.LAST_RESET_TYPE_NEVER,
+    LAST_RESET_TYPE_AUTO: LastResetTypes.LAST_RESET_TYPE_AUTO,
+}
+validate_last_reset_type = cv.enum(LAST_RESET_TYPES, lower=True, space="_")
+
+
 IS_PLATFORM_COMPONENT = True
 
 
@@ -168,6 +181,7 @@ SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend(
         cv.Optional(CONF_ACCURACY_DECIMALS): accuracy_decimals,
         cv.Optional(CONF_DEVICE_CLASS): device_class,
         cv.Optional(CONF_STATE_CLASS): validate_state_class,
+        cv.Optional(CONF_LAST_RESET_TYPE): validate_last_reset_type,
         cv.Optional(CONF_FORCE_UPDATE, default=False): cv.boolean,
         cv.Optional(CONF_EXPIRE_AFTER): cv.All(
             cv.requires_component("mqtt"),
@@ -202,6 +216,7 @@ def sensor_schema(
     accuracy_decimals_: int,
     device_class_: Optional[str] = DEVICE_CLASS_EMPTY,
     state_class_: Optional[str] = STATE_CLASS_NONE,
+    last_reset_type_: Optional[str] = LAST_RESET_TYPE_NONE,
 ) -> cv.Schema:
     schema = SENSOR_SCHEMA
     if unit_of_measurement_ != UNIT_EMPTY:
@@ -230,6 +245,14 @@ def sensor_schema(
         schema = schema.extend(
             {cv.Optional(CONF_STATE_CLASS, default=state_class_): validate_state_class}
         )
+    if last_reset_type_ != LAST_RESET_TYPE_NONE:
+        schema = schema.extend(
+            {
+                cv.Optional(
+                    CONF_LAST_RESET_TYPE, default=last_reset_type_
+                ): validate_last_reset_type
+            }
+        )
     return schema
 
 
@@ -479,6 +502,8 @@ async def setup_sensor_core_(var, config):
         cg.add(var.set_icon(config[CONF_ICON]))
     if CONF_ACCURACY_DECIMALS in config:
         cg.add(var.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
+    if CONF_LAST_RESET_TYPE in config:
+        cg.add(var.set_last_reset_type(config[CONF_LAST_RESET_TYPE]))
     cg.add(var.set_force_update(config[CONF_FORCE_UPDATE]))
     if config.get(CONF_FILTERS):  # must exist and not be empty
         filters = await build_filters(config[CONF_FILTERS])

esphome/components/sensor/sensor.cpp

@@ -16,6 +16,18 @@ const char *state_class_to_string(StateClass state_class) {
   }
 }
 
+const char *last_reset_type_to_string(LastResetType last_reset_type) {
+  switch (last_reset_type) {
+    case LAST_RESET_TYPE_NEVER:
+      return "never";
+    case LAST_RESET_TYPE_AUTO:
+      return "auto";
+    case LAST_RESET_TYPE_NONE:
+    default:
+      return "";
+  }
+}
+
 void Sensor::publish_state(float state) {
   this->raw_state = state;
   this->raw_callback_.call(state);
@@ -64,6 +76,7 @@ void Sensor::set_state_class(const std::string &state_class) {
     ESP_LOGW(TAG, "'%s' - Unrecognized state class %s", this->get_name().c_str(), state_class.c_str());
   }
 }
+void Sensor::set_last_reset_type(LastResetType last_reset_type) { this->last_reset_type = last_reset_type; }
 std::string Sensor::get_unit_of_measurement() {
   if (this->unit_of_measurement_.has_value())
     return *this->unit_of_measurement_;

esphome/components/sensor/sensor.h

@@ -14,6 +14,10 @@ namespace sensor {
       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)); \
+    if ((obj)->state_class == sensor::STATE_CLASS_MEASUREMENT && \
+        (obj)->last_reset_type != sensor::LAST_RESET_TYPE_NONE) { \
+      ESP_LOGCONFIG(TAG, "%s  Last Reset Type: '%s'", prefix, last_reset_type_to_string((obj)->last_reset_type)); \
+    } \
     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()) { \
@@ -37,6 +41,20 @@ enum StateClass : uint8_t {
 
 const char *state_class_to_string(StateClass state_class);
 
+/**
+ * Sensor last reset types
+ */
+enum LastResetType : uint8_t {
+  /// This sensor does not support resetting. ie, it is not accumulative
+  LAST_RESET_TYPE_NONE = 0,
+  /// This sensor is expected to never reset its value
+  LAST_RESET_TYPE_NEVER = 1,
+  /// This sensor may reset and Home Assistant will watch for this
+  LAST_RESET_TYPE_AUTO = 2,
+};
+
+const char *last_reset_type_to_string(LastResetType last_reset_type);
+
 /** Base-class for all sensors.
  *
  * A sensor has unit of measurement and can use publish_state to send out a new value with the specified accuracy.
@@ -155,6 +173,12 @@ class Sensor : public Nameable {
    */
   virtual std::string device_class();
 
+  // The Last reset type of this sensor
+  LastResetType last_reset_type{LAST_RESET_TYPE_NONE};
+
+  /// Manually set the Home Assistant last reset type for this sensor.
+  void set_last_reset_type(LastResetType last_reset_type);
+
   /** A unique ID for this sensor, empty for no unique id. See unique ID requirements:
    * https://developers.home-assistant.io/docs/en/entity_registry_index.html#unique-id-requirements
    *

esphome/components/template/number/__init__.py

@@ -9,6 +9,7 @@ from esphome.const import (
     CONF_MAX_VALUE,
     CONF_MIN_VALUE,
     CONF_OPTIMISTIC,
+    CONF_RESTORE_VALUE,
     CONF_STEP,
 )
 from .. import template_ns
@@ -26,6 +27,17 @@ def validate_min_max(config):
     return config
 
 
+def validate(config):
+    if CONF_LAMBDA in config:
+        if CONF_OPTIMISTIC in config:
+            raise cv.Invalid("optimistic cannot be used with lambda")
+        if CONF_INITIAL_VALUE in config:
+            raise cv.Invalid("initial_value cannot be used with lambda")
+        if CONF_RESTORE_VALUE in config:
+            raise cv.Invalid("restore_value cannot be used with lambda")
+    return config
+
+
 CONFIG_SCHEMA = cv.All(
     number.NUMBER_SCHEMA.extend(
         {
@@ -33,13 +45,15 @@ CONFIG_SCHEMA = cv.All(
             cv.Required(CONF_MAX_VALUE): cv.float_,
             cv.Required(CONF_MIN_VALUE): cv.float_,
             cv.Required(CONF_STEP): cv.positive_float,
-            cv.Exclusive(CONF_LAMBDA, "lambda-optimistic"): cv.returning_lambda,
+            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
-            cv.Exclusive(CONF_OPTIMISTIC, "lambda-optimistic"): cv.boolean,
+            cv.Optional(CONF_OPTIMISTIC): cv.boolean,
             cv.Optional(CONF_SET_ACTION): automation.validate_automation(single=True),
             cv.Optional(CONF_INITIAL_VALUE): cv.float_,
+            cv.Optional(CONF_RESTORE_VALUE): cv.boolean,
         }
     ).extend(cv.polling_component_schema("60s")),
     validate_min_max,
+    validate,
 )
 
 
@@ -60,13 +74,15 @@ async def to_code(config):
         )
         cg.add(var.set_template(template_))
 
-    elif CONF_OPTIMISTIC in config:
+    else:
-        cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
+        if CONF_OPTIMISTIC in config:
+            cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
+        if CONF_INITIAL_VALUE in config:
+            cg.add(var.set_initial_value(config[CONF_INITIAL_VALUE]))
+        if CONF_RESTORE_VALUE in config:
+            cg.add(var.set_restore_value(config[CONF_RESTORE_VALUE]))
 
     if CONF_SET_ACTION in config:
         await automation.build_automation(
             var.get_set_trigger(), [(float, "x")], config[CONF_SET_ACTION]
         )
-
-    if CONF_INITIAL_VALUE in config:
-        cg.add(var.set_initial_value(config[CONF_INITIAL_VALUE]))

esphome/components/template/number/template_number.cpp

@@ -7,16 +7,20 @@ namespace template_ {
 static const char *const TAG = "template.number";
 
 void TemplateNumber::setup() {
-  if (this->f_.has_value() || !this->optimistic_)
+  if (this->f_.has_value())
     return;
 
-  this->pref_ = global_preferences.make_preference<float>(this->get_object_id_hash());
   float value;
-  if (!this->pref_.load(&value)) {
+  if (!this->restore_value_) {
-    if (!isnan(this->initial_value_))
+    value = this->initial_value_;
-      value = this->initial_value_;
+  } else {
-    else
+    this->pref_ = global_preferences.make_preference<float>(this->get_object_id_hash());
-      value = this->traits.get_min_value();
+    if (!this->pref_.load(&value)) {
+      if (!isnan(this->initial_value_))
+        value = this->initial_value_;
+      else
+        value = this->traits.get_min_value();
+    }
   }
   this->publish_state(value);
 }
@@ -35,10 +39,11 @@ void TemplateNumber::update() {
 void TemplateNumber::control(float value) {
   this->set_trigger_->trigger(value);
 
-  if (this->optimistic_) {
+  if (this->optimistic_)
     this->publish_state(value);
+
+  if (this->restore_value_)
     this->pref_.save(&value);
-  }
 }
 void TemplateNumber::dump_config() {
   LOG_NUMBER("", "Template Number", this);

esphome/components/template/number/template_number.h

@@ -20,11 +20,13 @@ class TemplateNumber : public number::Number, public PollingComponent {
   Trigger<float> *get_set_trigger() const { return set_trigger_; }
   void set_optimistic(bool optimistic) { optimistic_ = optimistic; }
   void set_initial_value(float initial_value) { initial_value_ = initial_value; }
+  void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
 
  protected:
   void control(float value) override;
   bool optimistic_{false};
   float initial_value_{NAN};
+  bool restore_value_{false};
   Trigger<float> *set_trigger_ = new Trigger<float>();
   optional<std::function<optional<float>()>> f_;
 

esphome/const.py

@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "1.20.0b4"
+__version__ = "1.20.0"
 
 ESP_PLATFORM_ESP32 = "ESP32"
 ESP_PLATFORM_ESP8266 = "ESP8266"
@@ -297,6 +297,7 @@ CONF_KEY = "key"
 CONF_LAMBDA = "lambda"
 CONF_LAST_CONFIDENCE = "last_confidence"
 CONF_LAST_FINGER_ID = "last_finger_id"
+CONF_LAST_RESET_TYPE = "last_reset_type"
 CONF_LATITUDE = "latitude"
 CONF_LENGTH = "length"
 CONF_LEVEL = "level"
@@ -785,3 +786,10 @@ STATE_CLASS_NONE = ""
 
 # The state represents a measurement in present time
 STATE_CLASS_MEASUREMENT = "measurement"
+
+# This sensor does not support resetting. ie, it is not accumulative
+LAST_RESET_TYPE_NONE = ""
+# This sensor is expected to never reset its value
+LAST_RESET_TYPE_NEVER = "never"
+# This sensor may reset and Home Assistant will watch for this
+LAST_RESET_TYPE_AUTO = "auto"

requirements.txt

@@ -11,4 +11,4 @@ ifaddr==0.1.7
 platformio==5.1.1
 esptool==2.8
 click==7.1.2
-esphome-dashboard==20210623.0
+esphome-dashboard==20210719.0