Add to tests

Co-authored-by: Peter <psv@tsat.net>
Co-authored-by: Carlos Garcia Saura <CarlosGS@users.noreply.github.com>

.clang-tidy

@@ -5,11 +5,8 @@ Checks: >-
   -altera-*,
   -android-*,
   -boost-*,
-  -bugprone-branch-clone,
-  -bugprone-easily-swappable-parameters,
   -bugprone-narrowing-conversions,
   -bugprone-signed-char-misuse,
-  -bugprone-too-small-loop-variable,
   -cert-dcl50-cpp,
   -cert-err58-cpp,
   -cert-oop57-cpp,
@@ -19,12 +16,10 @@ Checks: >-
   -clang-diagnostic-delete-abstract-non-virtual-dtor,
   -clang-diagnostic-delete-non-abstract-non-virtual-dtor,
   -clang-diagnostic-shadow-field,
-  -clang-diagnostic-sign-compare,
-  -clang-diagnostic-unused-variable,
   -clang-diagnostic-unused-const-variable,
+  -clang-diagnostic-unused-parameter,
   -concurrency-*,
   -cppcoreguidelines-avoid-c-arrays,
-  -cppcoreguidelines-avoid-goto,
   -cppcoreguidelines-avoid-magic-numbers,
   -cppcoreguidelines-init-variables,
   -cppcoreguidelines-macro-usage,
@@ -41,7 +36,6 @@ Checks: >-
   -cppcoreguidelines-pro-type-union-access,
   -cppcoreguidelines-pro-type-vararg,
   -cppcoreguidelines-special-member-functions,
-  -fuchsia-default-arguments,
   -fuchsia-multiple-inheritance,
   -fuchsia-overloaded-operator,
   -fuchsia-statically-constructed-objects,
@@ -51,6 +45,7 @@ Checks: >-
   -google-explicit-constructor,
   -google-readability-braces-around-statements,
   -google-readability-casting,
+  -google-readability-namespace-comments,
   -google-readability-todo,
   -google-runtime-references,
   -hicpp-*,
@@ -97,9 +92,11 @@ CheckOptions:
     value:           '1'
   - key:             google-readability-function-size.StatementThreshold
     value:           '800'
-  - key:             google-readability-namespace-comments.ShortNamespaceLines
+  - key:             google-runtime-int.TypeSuffix
+    value:           '_t'
+  - key:             llvm-namespace-comment.ShortNamespaceLines
     value:           '10'
-  - key:             google-readability-namespace-comments.SpacesBeforeComments
+  - key:             llvm-namespace-comment.SpacesBeforeComments
     value:           '2'
   - key:             modernize-loop-convert.MaxCopySize
     value:           '16'

.github/workflows/ci.yml

@@ -1,5 +1,3 @@
-# THESE JOBS ARE COPIED IN release.yml and release-dev.yml
-# PLEASE ALSO UPDATE THOSE FILES WHEN CHANGING LINES HERE
 name: CI
 
 on:
@@ -11,6 +9,10 @@ on:
 permissions:
   contents: read
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   ci:
     name: ${{ matrix.name }}
@@ -34,7 +36,7 @@ jobs:
           - id: test
             file: tests/test3.yaml
             name: Test tests/test3.yaml
-            pio_cache_key: test1
+            pio_cache_key: test3
           - id: test
             file: tests/test4.yaml
             name: Test tests/test4.yaml
@@ -80,18 +82,23 @@ jobs:
         with:
           python-version: '3.7'
 
-      - name: Cache pip modules
+      - name: Cache virtualenv
         uses: actions/cache@v2
         with:
-          path: ~/.cache/pip
-          key: pip-${{ steps.python.outputs.python-version }}-${{ hashFiles('requirements*.txt') }}
+          path: .venv
+          key: venv-${{ steps.python.outputs.python-version }}-${{ hashFiles('requirements*.txt') }}
           restore-keys: |
-            pip-${{ steps.python.outputs.python-version }}-
+            venv-${{ steps.python.outputs.python-version }}-
 
-      - name: Set up python environment
+      - name: Set up virtualenv
         run: |
-          pip3 install -r requirements.txt -r requirements_optional.txt -r requirements_test.txt
-          pip3 install -e .
+          python -m venv .venv
+          source .venv/bin/activate
+          pip install -U pip
+          pip install -r requirements.txt -r requirements_optional.txt -r requirements_test.txt
+          pip install -e .
+          echo "$GITHUB_WORKSPACE/.venv/bin" >> $GITHUB_PATH
+          echo "VIRTUAL_ENV=$GITHUB_WORKSPACE/.venv" >> $GITHUB_ENV
 
       # Use per check platformio cache because checks use different parts
       - name: Cache platformio

.github/workflows/matchers/ci-custom.json

@@ -4,7 +4,7 @@
             "owner": "ci-custom",
             "pattern": [
                 {
-                    "regexp": "^ERROR (.*):(\\d+):(\\d+) - (.*)$",
+                    "regexp": "^(.*):(\\d+):(\\d+):\\s+lint:\\s+(.*)$",
                     "file": 1,
                     "line": 2,
                     "column": 3,

.github/workflows/matchers/gcc.json

@@ -5,7 +5,7 @@
       "severity": "error",
       "pattern": [
         {
-          "regexp": "^(.*):(\\d+):(\\d+):\\s+(?:fatal\\s+)?(warning|error):\\s+(.*)$",
+          "regexp": "^src/(.*):(\\d+):(\\d+):\\s+(?:fatal\\s+)?(warning|error):\\s+(.*)$",
           "file": 1,
           "line": 2,
           "column": 3,

.github/workflows/matchers/lint-python.json

@@ -1,11 +1,22 @@
 {
   "problemMatcher": [
+    {
+      "owner": "black",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^(.*): (Please format this file with the black formatter)",
+          "file": 1,
+          "message": 2
+        }
+      ]
+    },
     {
       "owner": "flake8",
       "severity": "error",
       "pattern": [
           {
-          "regexp": "^(.*):(\\d+) - ([EFCDNW]\\d{3}.*)$",
+          "regexp": "^(.*):(\\d+): ([EFCDNW]\\d{3}.*)$",
           "file": 1,
           "line": 2,
           "message": 3
@@ -17,7 +28,7 @@
       "severity": "error",
       "pattern": [
         {
-          "regexp": "^(.*):(\\d+) - (\\[[EFCRW]\\d{4}\\(.*\\),.*\\].*)$",
+          "regexp": "^(.*):(\\d+): (\\[[EFCRW]\\d{4}\\(.*\\),.*\\].*)$",
           "file": 1,
           "line": 2,
           "message": 3

CODEOWNERS

@@ -30,6 +30,7 @@ esphome/components/bang_bang/* @OttoWinter
 esphome/components/binary_sensor/* @esphome/core
 esphome/components/ble_client/* @buxtronix
 esphome/components/bme680_bsec/* @trvrnrth
+esphome/components/button/* @esphome/core
 esphome/components/canbus/* @danielschramm @mvturnho
 esphome/components/cap1188/* @MrEditor97
 esphome/components/captive_portal/* @OttoWinter
@@ -132,6 +133,7 @@ esphome/components/rf_bridge/* @jesserockz
 esphome/components/rgbct/* @jesserockz
 esphome/components/rtttl/* @glmnet
 esphome/components/safe_mode/* @paulmonigatti
+esphome/components/safe_mode/button/* @jesserockz
 esphome/components/scd4x/* @sjtrny
 esphome/components/script/* @esphome/core
 esphome/components/sdm_meter/* @jesserockz @polyfaces
@@ -180,6 +182,7 @@ esphome/components/tuya/binary_sensor/* @jesserockz
 esphome/components/tuya/climate/* @jesserockz
 esphome/components/tuya/sensor/* @jesserockz
 esphome/components/tuya/switch/* @jesserockz
+esphome/components/tuya/text_sensor/* @dentra
 esphome/components/uart/* @esphome/core
 esphome/components/ultrasonic/* @OttoWinter
 esphome/components/version/* @esphome/core

esphome/__main__.py

@@ -145,6 +145,8 @@ def wrap_to_code(name, comp):
         if comp.config_schema is not None:
             conf_str = yaml_util.dump(conf)
             conf_str = conf_str.replace("//", "")
+            # remove tailing \ to avoid multi-line comment warning
+            conf_str = conf_str.replace("\\\n", "\n")
             cg.add(cg.LineComment(indent(conf_str)))
         await coro(conf)
 

esphome/components/adalight/adalight_light_effect.cpp

@@ -25,7 +25,7 @@ void AdalightLightEffect::stop() {
   AddressableLightEffect::stop();
 }
 
-int AdalightLightEffect::get_frame_size_(int led_count) const {
+unsigned int AdalightLightEffect::get_frame_size_(int led_count) const {
   // 3 bytes: Ada
   // 2 bytes: LED count
   // 1 byte: checksum

esphome/components/adalight/adalight_light_effect.h

@@ -25,7 +25,7 @@ class AdalightLightEffect : public light::AddressableLightEffect, public uart::U
     CONSUMED,
   };
 
-  int get_frame_size_(int led_count) const;
+  unsigned int get_frame_size_(int led_count) const;
   void reset_frame_(light::AddressableLight &it);
   void blank_all_leds_(light::AddressableLight &it);
   Frame parse_frame_(light::AddressableLight &it);

esphome/components/adc/adc_sensor.cpp

@@ -91,7 +91,7 @@ void ADCSensor::dump_config() {
 float ADCSensor::get_setup_priority() const { return setup_priority::DATA; }
 void ADCSensor::update() {
   float value_v = this->sample();
-  ESP_LOGD(TAG, "'%s': Got voltage=%.4fV", this->get_name().c_str(), value_v);
+  ESP_LOGV(TAG, "'%s': Got voltage=%.4fV", this->get_name().c_str(), value_v);
   this->publish_state(value_v);
 }
 

esphome/components/aht10/aht10.cpp

@@ -110,12 +110,12 @@ void AHT10Component::update() {
   uint32_t raw_temperature = ((data[3] & 0x0F) << 16) | (data[4] << 8) | data[5];
   uint32_t raw_humidity = ((data[1] << 16) | (data[2] << 8) | data[3]) >> 4;
 
-  float temperature = ((200.0 * (float) raw_temperature) / 1048576.0) - 50.0;
+  float temperature = ((200.0f * (float) raw_temperature) / 1048576.0f) - 50.0f;
   float humidity;
   if (raw_humidity == 0) {  // unrealistic value
     humidity = NAN;
   } else {
-    humidity = (float) raw_humidity * 100.0 / 1048576.0;
+    humidity = (float) raw_humidity * 100.0f / 1048576.0f;
   }
 
   if (this->temperature_sensor_ != nullptr) {

esphome/components/am2320/am2320.cpp

@@ -38,9 +38,9 @@ void AM2320Component::update() {
     return;
   }
 
-  float temperature = (((data[4] & 0x7F) << 8) + data[5]) / 10.0;
+  float temperature = (((data[4] & 0x7F) << 8) + data[5]) / 10.0f;
   temperature = (data[4] & 0x80) ? -temperature : temperature;
-  float humidity = ((data[2] << 8) + data[3]) / 10.0;
+  float humidity = ((data[2] << 8) + data[3]) / 10.0f;
 
   ESP_LOGD(TAG, "Got temperature=%.1f°C humidity=%.1f%%", temperature, humidity);
   if (this->temperature_sensor_ != nullptr)

esphome/components/anova/anova.h

@@ -30,7 +30,7 @@ class Anova : public climate::Climate, public esphome::ble_client::BLEClientNode
   climate::ClimateTraits traits() override {
     auto traits = climate::ClimateTraits();
     traits.set_supports_current_temperature(true);
-    traits.set_supports_heat_mode(true);
+    traits.set_supported_modes({climate::CLIMATE_MODE_OFF, climate::ClimateMode::CLIMATE_MODE_HEAT});
     traits.set_visual_min_temperature(25.0);
     traits.set_visual_max_temperature(100.0);
     traits.set_visual_temperature_step(0.1);

esphome/components/anova/anova_base.cpp

@@ -73,51 +73,46 @@ AnovaPacket *AnovaCodec::get_stop_request() {
 }
 
 void AnovaCodec::decode(const uint8_t *data, uint16_t length) {
-  memset(this->buf_, 0, 32);
-  strncpy(this->buf_, (char *) data, length);
+  char buf[32];
+  memset(buf, 0, sizeof(buf));
+  strncpy(buf, (char *) data, std::min<uint16_t>(length, sizeof(buf) - 1));
   this->has_target_temp_ = this->has_current_temp_ = this->has_unit_ = this->has_running_ = false;
   switch (this->current_query_) {
     case READ_DEVICE_STATUS: {
-      if (!strncmp(this->buf_, "stopped", 7)) {
+      if (!strncmp(buf, "stopped", 7)) {
         this->has_running_ = true;
         this->running_ = false;
       }
-      if (!strncmp(this->buf_, "running", 7)) {
+      if (!strncmp(buf, "running", 7)) {
         this->has_running_ = true;
         this->running_ = true;
       }
       break;
     }
     case START: {
-      if (!strncmp(this->buf_, "start", 5)) {
+      if (!strncmp(buf, "start", 5)) {
         this->has_running_ = true;
         this->running_ = true;
       }
       break;
     }
     case STOP: {
-      if (!strncmp(this->buf_, "stop", 4)) {
+      if (!strncmp(buf, "stop", 4)) {
         this->has_running_ = true;
         this->running_ = false;
       }
       break;
     }
-    case READ_TARGET_TEMPERATURE: {
-      this->target_temp_ = parse_number<float>(this->buf_, sizeof(this->buf_)).value_or(0.0f);
-      if (this->fahrenheit_)
-        this->target_temp_ = ftoc(this->target_temp_);
-      this->has_target_temp_ = true;
-      break;
-    }
+    case READ_TARGET_TEMPERATURE:
     case SET_TARGET_TEMPERATURE: {
-      this->target_temp_ = parse_number<float>(this->buf_, sizeof(this->buf_)).value_or(0.0f);
+      this->target_temp_ = parse_number<float>(str_until(buf, '\r')).value_or(0.0f);
       if (this->fahrenheit_)
         this->target_temp_ = ftoc(this->target_temp_);
       this->has_target_temp_ = true;
       break;
     }
     case READ_CURRENT_TEMPERATURE: {
-      this->current_temp_ = parse_number<float>(this->buf_, sizeof(this->buf_)).value_or(0.0f);
+      this->current_temp_ = parse_number<float>(str_until(buf, '\r')).value_or(0.0f);
       if (this->fahrenheit_)
         this->current_temp_ = ftoc(this->current_temp_);
       this->has_current_temp_ = true;
@@ -125,8 +120,8 @@ void AnovaCodec::decode(const uint8_t *data, uint16_t length) {
     }
     case SET_UNIT:
     case READ_UNIT: {
-      this->unit_ = this->buf_[0];
-      this->fahrenheit_ = this->buf_[0] == 'f';
+      this->unit_ = buf[0];
+      this->fahrenheit_ = buf[0] == 'f';
       this->has_unit_ = true;
       break;
     }

esphome/components/anova/anova_base.h

@@ -70,7 +70,6 @@ class AnovaCodec {
   bool has_current_temp_;
   bool has_unit_;
   bool has_running_;
-  char buf_[32];
   bool fahrenheit_;
 
   CurrentQuery current_query_;

esphome/components/api/api.proto

@@ -40,6 +40,7 @@ service APIConnection {
   rpc climate_command (ClimateCommandRequest) returns (void) {}
   rpc number_command (NumberCommandRequest) returns (void) {}
   rpc select_command (SelectCommandRequest) returns (void) {}
+  rpc button_command (ButtonCommandRequest) returns (void) {}
 }
 
 
@@ -868,6 +869,11 @@ message ClimateCommandRequest {
 }
 
 // ==================== NUMBER ====================
+enum NumberMode {
+  NUMBER_MODE_AUTO = 0;
+  NUMBER_MODE_BOX = 1;
+  NUMBER_MODE_SLIDER = 2;
+}
 message ListEntitiesNumberResponse {
   option (id) = 49;
   option (source) = SOURCE_SERVER;
@@ -884,6 +890,8 @@ message ListEntitiesNumberResponse {
   float step = 8;
   bool disabled_by_default = 9;
   EntityCategory entity_category = 10;
+  string unit_of_measurement = 11;
+  NumberMode mode = 12;
 }
 message NumberStateResponse {
   option (id) = 50;
@@ -944,3 +952,28 @@ message SelectCommandRequest {
   fixed32 key = 1;
   string state = 2;
 }
+
+// ==================== BUTTON ====================
+message ListEntitiesButtonResponse {
+  option (id) = 61;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BUTTON";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  bool disabled_by_default = 6;
+  EntityCategory entity_category = 7;
+  string device_class = 8;
+}
+message ButtonCommandRequest {
+  option (id) = 62;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_BUTTON";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+}

esphome/components/api/api_connection.cpp

@@ -132,7 +132,7 @@ void APIConnection::loop() {
 
   if (state_subs_at_ != -1) {
     const auto &subs = this->parent_->get_state_subs();
-    if (state_subs_at_ >= subs.size()) {
+    if (state_subs_at_ >= (int) subs.size()) {
       state_subs_at_ = -1;
     } else {
       auto &it = subs[state_subs_at_];
@@ -619,6 +619,8 @@ bool APIConnection::send_number_info(number::Number *number) {
   msg.icon = number->get_icon();
   msg.disabled_by_default = number->is_disabled_by_default();
   msg.entity_category = static_cast<enums::EntityCategory>(number->get_entity_category());
+  msg.unit_of_measurement = number->traits.get_unit_of_measurement();
+  msg.mode = static_cast<enums::NumberMode>(number->traits.get_mode());
 
   msg.min_value = number->traits.get_min_value();
   msg.max_value = number->traits.get_max_value();
@@ -674,6 +676,28 @@ void APIConnection::select_command(const SelectCommandRequest &msg) {
 }
 #endif
 
+#ifdef USE_BUTTON
+bool APIConnection::send_button_info(button::Button *button) {
+  ListEntitiesButtonResponse msg;
+  msg.key = button->get_object_id_hash();
+  msg.object_id = button->get_object_id();
+  msg.name = button->get_name();
+  msg.unique_id = get_default_unique_id("button", button);
+  msg.icon = button->get_icon();
+  msg.disabled_by_default = button->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(button->get_entity_category());
+  msg.device_class = button->get_device_class();
+  return this->send_list_entities_button_response(msg);
+}
+void APIConnection::button_command(const ButtonCommandRequest &msg) {
+  button::Button *button = App.get_button_by_key(msg.key);
+  if (button == nullptr)
+    return;
+
+  button->press();
+}
+#endif
+
 #ifdef USE_ESP32_CAMERA
 void APIConnection::send_camera_state(std::shared_ptr<esp32_camera::CameraImage> image) {
   if (!this->state_subscription_)

esphome/components/api/api_connection.h

@@ -73,6 +73,10 @@ class APIConnection : public APIServerConnection {
   bool send_select_state(select::Select *select, std::string state);
   bool send_select_info(select::Select *select);
   void select_command(const SelectCommandRequest &msg) override;
+#endif
+#ifdef USE_BUTTON
+  bool send_button_info(button::Button *button);
+  void button_command(const ButtonCommandRequest &msg) override;
 #endif
   bool send_log_message(int level, const char *tag, const char *line);
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call) {

esphome/components/api/api_frame_helper.cpp

@@ -174,9 +174,6 @@ APIError APINoiseFrameHelper::loop() {
  * errno API_ERROR_HANDSHAKE_PACKET_LEN: Packet too big for this phase.
  */
 APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
-  int err;
-  APIError aerr;
-
   if (frame == nullptr) {
     HELPER_LOG("Bad argument for try_read_frame_");
     return APIError::BAD_ARG;
@@ -200,7 +197,7 @@ APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
       return APIError::CONNECTION_CLOSED;
     }
     rx_header_buf_len_ += received;
-    if (received != to_read) {
+    if ((size_t) received != to_read) {
       // not a full read
       return APIError::WOULD_BLOCK;
     }
@@ -247,7 +244,7 @@ APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
       return APIError::CONNECTION_CLOSED;
     }
     rx_buf_len_ += received;
-    if (received != to_read) {
+    if ((size_t) received != to_read) {
       // not all read
       return APIError::WOULD_BLOCK;
     }
@@ -255,7 +252,7 @@ APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
 
   // uncomment for even more debugging
 #ifdef HELPER_LOG_PACKETS
-  ESP_LOGVV(TAG, "Received frame: %s", hexencode(rx_buf_).c_str());
+  ESP_LOGVV(TAG, "Received frame: %s", format_hex_pretty(rx_buf_).c_str());
 #endif
   frame->msg = std::move(rx_buf_);
   // consume msg
@@ -544,13 +541,13 @@ APIError APINoiseFrameHelper::try_send_tx_buf_() {
 APIError APINoiseFrameHelper::write_raw_(const struct iovec *iov, int iovcnt) {
   if (iovcnt == 0)
     return APIError::OK;
-  int err;
   APIError aerr;
 
   size_t total_write_len = 0;
   for (int i = 0; i < iovcnt; i++) {
 #ifdef HELPER_LOG_PACKETS
-    ESP_LOGVV(TAG, "Sending raw: %s", hexencode(reinterpret_cast<uint8_t *>(iov[i].iov_base), iov[i].iov_len).c_str());
+    ESP_LOGVV(TAG, "Sending raw: %s",
+              format_hex_pretty(reinterpret_cast<uint8_t *>(iov[i].iov_base), iov[i].iov_len).c_str());
 #endif
     total_write_len += iov[i].iov_len;
   }
@@ -584,7 +581,7 @@ APIError APINoiseFrameHelper::write_raw_(const struct iovec *iov, int iovcnt) {
     state_ = State::FAILED;
     HELPER_LOG("Socket write failed with errno %d", errno);
     return APIError::SOCKET_WRITE_FAILED;
-  } else if (sent != total_write_len) {
+  } else if ((size_t) sent != total_write_len) {
     // partially sent, add end to tx_buf
     size_t to_consume = sent;
     for (int i = 0; i < iovcnt; i++) {
@@ -778,9 +775,6 @@ APIError APIPlaintextFrameHelper::loop() {
  * error API_ERROR_BAD_INDICATOR: Bad indicator byte at start of frame.
  */
 APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
-  int err;
-  APIError aerr;
-
   if (frame == nullptr) {
     HELPER_LOG("Bad argument for try_read_frame_");
     return APIError::BAD_ARG;
@@ -854,7 +848,7 @@ APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
       return APIError::CONNECTION_CLOSED;
     }
     rx_buf_len_ += received;
-    if (received != to_read) {
+    if ((size_t) received != to_read) {
       // not all read
       return APIError::WOULD_BLOCK;
     }
@@ -862,7 +856,7 @@ APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
 
   // uncomment for even more debugging
 #ifdef HELPER_LOG_PACKETS
-  ESP_LOGVV(TAG, "Received frame: %s", hexencode(rx_buf_).c_str());
+  ESP_LOGVV(TAG, "Received frame: %s", format_hex_pretty(rx_buf_).c_str());
 #endif
   frame->msg = std::move(rx_buf_);
   // consume msg
@@ -874,7 +868,6 @@ APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
 }
 
 APIError APIPlaintextFrameHelper::read_packet(ReadPacketBuffer *buffer) {
-  int err;
   APIError aerr;
 
   if (state_ != State::DATA) {
@@ -894,9 +887,6 @@ APIError APIPlaintextFrameHelper::read_packet(ReadPacketBuffer *buffer) {
 }
 bool APIPlaintextFrameHelper::can_write_without_blocking() { return state_ == State::DATA && tx_buf_.empty(); }
 APIError APIPlaintextFrameHelper::write_packet(uint16_t type, const uint8_t *payload, size_t payload_len) {
-  int err;
-  APIError aerr;
-
   if (state_ != State::DATA) {
     return APIError::BAD_STATE;
   }
@@ -940,13 +930,13 @@ APIError APIPlaintextFrameHelper::try_send_tx_buf_() {
 APIError APIPlaintextFrameHelper::write_raw_(const struct iovec *iov, int iovcnt) {
   if (iovcnt == 0)
     return APIError::OK;
-  int err;
   APIError aerr;
 
   size_t total_write_len = 0;
   for (int i = 0; i < iovcnt; i++) {
 #ifdef HELPER_LOG_PACKETS
-    ESP_LOGVV(TAG, "Sending raw: %s", hexencode(reinterpret_cast<uint8_t *>(iov[i].iov_base), iov[i].iov_len).c_str());
+    ESP_LOGVV(TAG, "Sending raw: %s",
+              format_hex_pretty(reinterpret_cast<uint8_t *>(iov[i].iov_base), iov[i].iov_len).c_str());
 #endif
     total_write_len += iov[i].iov_len;
   }
@@ -980,7 +970,7 @@ APIError APIPlaintextFrameHelper::write_raw_(const struct iovec *iov, int iovcnt
     state_ = State::FAILED;
     HELPER_LOG("Socket write failed with errno %d", errno);
     return APIError::SOCKET_WRITE_FAILED;
-  } else if (sent != total_write_len) {
+  } else if ((size_t) sent != total_write_len) {
     // partially sent, add end to tx_buf
     size_t to_consume = sent;
     for (int i = 0; i < iovcnt; i++) {

esphome/components/api/api_pb2.cpp

@@ -266,6 +266,18 @@ template<> const char *proto_enum_to_string<enums::ClimatePreset>(enums::Climate
       return "UNKNOWN";
   }
 }
+template<> const char *proto_enum_to_string<enums::NumberMode>(enums::NumberMode value) {
+  switch (value) {
+    case enums::NUMBER_MODE_AUTO:
+      return "NUMBER_MODE_AUTO";
+    case enums::NUMBER_MODE_BOX:
+      return "NUMBER_MODE_BOX";
+    case enums::NUMBER_MODE_SLIDER:
+      return "NUMBER_MODE_SLIDER";
+    default:
+      return "UNKNOWN";
+  }
+}
 bool HelloRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
@@ -279,7 +291,7 @@ bool HelloRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value)
 void HelloRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_string(1, this->client_info); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void HelloRequest::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("HelloRequest {\n");
   out.append("  client_info: ");
   out.append("'").append(this->client_info).append("'");
@@ -318,7 +330,7 @@ void HelloResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void HelloResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("HelloResponse {\n");
   out.append("  api_version_major: ");
   sprintf(buffer, "%u", this->api_version_major);
@@ -349,7 +361,7 @@ bool ConnectRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value
 void ConnectRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_string(1, this->password); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ConnectRequest::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ConnectRequest {\n");
   out.append("  password: ");
   out.append("'").append(this->password).append("'");
@@ -370,7 +382,7 @@ bool ConnectResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
 void ConnectResponse::encode(ProtoWriteBuffer buffer) const { buffer.encode_bool(1, this->invalid_password); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ConnectResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ConnectResponse {\n");
   out.append("  invalid_password: ");
   out.append(YESNO(this->invalid_password));
@@ -464,7 +476,7 @@ void DeviceInfoResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DeviceInfoResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("DeviceInfoResponse {\n");
   out.append("  uses_password: ");
   out.append(YESNO(this->uses_password));
@@ -588,7 +600,7 @@ void ListEntitiesBinarySensorResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesBinarySensorResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesBinarySensorResponse {\n");
   out.append("  object_id: ");
   out.append("'").append(this->object_id).append("'");
@@ -660,7 +672,7 @@ void BinarySensorStateResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BinarySensorStateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("BinarySensorStateResponse {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -754,7 +766,7 @@ void ListEntitiesCoverResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesCoverResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesCoverResponse {\n");
   out.append("  object_id: ");
   out.append("'").append(this->object_id).append("'");
@@ -844,7 +856,7 @@ void CoverStateResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void CoverStateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("CoverStateResponse {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -927,7 +939,7 @@ void CoverCommandRequest::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void CoverCommandRequest::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("CoverCommandRequest {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -1043,7 +1055,7 @@ void ListEntitiesFanResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesFanResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesFanResponse {\n");
   out.append("  object_id: ");
   out.append("'").append(this->object_id).append("'");
@@ -1139,7 +1151,7 @@ void FanStateResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void FanStateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("FanStateResponse {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -1240,7 +1252,7 @@ void FanCommandRequest::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void FanCommandRequest::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("FanCommandRequest {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -1391,7 +1403,7 @@ void ListEntitiesLightResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesLightResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesLightResponse {\n");
   out.append("  object_id: ");
   out.append("'").append(this->object_id).append("'");
@@ -1549,7 +1561,7 @@ void LightStateResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void LightStateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("LightStateResponse {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -1772,7 +1784,7 @@ void LightCommandRequest::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void LightCommandRequest::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("LightCommandRequest {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -1983,7 +1995,7 @@ void ListEntitiesSensorResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesSensorResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesSensorResponse {\n");
   out.append("  object_id: ");
   out.append("'").append(this->object_id).append("'");
@@ -2072,7 +2084,7 @@ void SensorStateResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SensorStateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("SensorStateResponse {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -2152,7 +2164,7 @@ void ListEntitiesSwitchResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesSwitchResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesSwitchResponse {\n");
   out.append("  object_id: ");
   out.append("'").append(this->object_id).append("'");
@@ -2215,7 +2227,7 @@ void SwitchStateResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SwitchStateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("SwitchStateResponse {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -2254,7 +2266,7 @@ void SwitchCommandRequest::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SwitchCommandRequest::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("SwitchCommandRequest {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -2324,7 +2336,7 @@ void ListEntitiesTextSensorResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesTextSensorResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesTextSensorResponse {\n");
   out.append("  object_id: ");
   out.append("'").append(this->object_id).append("'");
@@ -2394,7 +2406,7 @@ void TextSensorStateResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void TextSensorStateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("TextSensorStateResponse {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -2431,7 +2443,7 @@ void SubscribeLogsRequest::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeLogsRequest::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("SubscribeLogsRequest {\n");
   out.append("  level: ");
   out.append(proto_enum_to_string<enums::LogLevel>(this->level));
@@ -2474,7 +2486,7 @@ void SubscribeLogsResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeLogsResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("SubscribeLogsResponse {\n");
   out.append("  level: ");
   out.append(proto_enum_to_string<enums::LogLevel>(this->level));
@@ -2516,7 +2528,7 @@ void HomeassistantServiceMap::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void HomeassistantServiceMap::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("HomeassistantServiceMap {\n");
   out.append("  key: ");
   out.append("'").append(this->key).append("'");
@@ -2575,7 +2587,7 @@ void HomeassistantServiceResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void HomeassistantServiceResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("HomeassistantServiceResponse {\n");
   out.append("  service: ");
   out.append("'").append(this->service).append("'");
@@ -2631,7 +2643,7 @@ void SubscribeHomeAssistantStateResponse::encode(ProtoWriteBuffer buffer) const
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeHomeAssistantStateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("SubscribeHomeAssistantStateResponse {\n");
   out.append("  entity_id: ");
   out.append("'").append(this->entity_id).append("'");
@@ -2668,7 +2680,7 @@ void HomeAssistantStateResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void HomeAssistantStateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("HomeAssistantStateResponse {\n");
   out.append("  entity_id: ");
   out.append("'").append(this->entity_id).append("'");
@@ -2701,7 +2713,7 @@ bool GetTimeResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
 void GetTimeResponse::encode(ProtoWriteBuffer buffer) const { buffer.encode_fixed32(1, this->epoch_seconds); }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void GetTimeResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("GetTimeResponse {\n");
   out.append("  epoch_seconds: ");
   sprintf(buffer, "%u", this->epoch_seconds);
@@ -2736,7 +2748,7 @@ void ListEntitiesServicesArgument::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesServicesArgument::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesServicesArgument {\n");
   out.append("  name: ");
   out.append("'").append(this->name).append("'");
@@ -2781,7 +2793,7 @@ void ListEntitiesServicesResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesServicesResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesServicesResponse {\n");
   out.append("  name: ");
   out.append("'").append(this->name).append("'");
@@ -2875,7 +2887,7 @@ void ExecuteServiceArgument::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ExecuteServiceArgument::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ExecuteServiceArgument {\n");
   out.append("  bool_: ");
   out.append(YESNO(this->bool_));
@@ -2956,7 +2968,7 @@ void ExecuteServiceRequest::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ExecuteServiceRequest::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ExecuteServiceRequest {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -3028,7 +3040,7 @@ void ListEntitiesCameraResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesCameraResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesCameraResponse {\n");
   out.append("  object_id: ");
   out.append("'").append(this->object_id).append("'");
@@ -3098,7 +3110,7 @@ void CameraImageResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void CameraImageResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("CameraImageResponse {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -3135,7 +3147,7 @@ void CameraImageRequest::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void CameraImageRequest::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("CameraImageRequest {\n");
   out.append("  single: ");
   out.append(YESNO(this->single));
@@ -3281,7 +3293,7 @@ void ListEntitiesClimateResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesClimateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesClimateResponse {\n");
   out.append("  object_id: ");
   out.append("'").append(this->object_id).append("'");
@@ -3468,7 +3480,7 @@ void ClimateStateResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ClimateStateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ClimateStateResponse {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -3656,7 +3668,7 @@ void ClimateCommandRequest::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ClimateCommandRequest::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ClimateCommandRequest {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -3758,6 +3770,10 @@ bool ListEntitiesNumberResponse::decode_varint(uint32_t field_id, ProtoVarInt va
       this->entity_category = value.as_enum<enums::EntityCategory>();
       return true;
     }
+    case 12: {
+      this->mode = value.as_enum<enums::NumberMode>();
+      return true;
+    }
     default:
       return false;
   }
@@ -3780,6 +3796,10 @@ bool ListEntitiesNumberResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->icon = value.as_string();
       return true;
     }
+    case 11: {
+      this->unit_of_measurement = value.as_string();
+      return true;
+    }
     default:
       return false;
   }
@@ -3817,10 +3837,12 @@ void ListEntitiesNumberResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(8, this->step);
   buffer.encode_bool(9, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(10, this->entity_category);
+  buffer.encode_string(11, this->unit_of_measurement);
+  buffer.encode_enum<enums::NumberMode>(12, this->mode);
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesNumberResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesNumberResponse {\n");
   out.append("  object_id: ");
   out.append("'").append(this->object_id).append("'");
@@ -3865,6 +3887,14 @@ void ListEntitiesNumberResponse::dump_to(std::string &out) const {
   out.append("  entity_category: ");
   out.append(proto_enum_to_string<enums::EntityCategory>(this->entity_category));
   out.append("\n");
+
+  out.append("  unit_of_measurement: ");
+  out.append("'").append(this->unit_of_measurement).append("'");
+  out.append("\n");
+
+  out.append("  mode: ");
+  out.append(proto_enum_to_string<enums::NumberMode>(this->mode));
+  out.append("\n");
   out.append("}");
 }
 #endif
@@ -3899,7 +3929,7 @@ void NumberStateResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void NumberStateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("NumberStateResponse {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -3937,7 +3967,7 @@ void NumberCommandRequest::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void NumberCommandRequest::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("NumberCommandRequest {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -4015,7 +4045,7 @@ void ListEntitiesSelectResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesSelectResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("ListEntitiesSelectResponse {\n");
   out.append("  object_id: ");
   out.append("'").append(this->object_id).append("'");
@@ -4091,7 +4121,7 @@ void SelectStateResponse::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SelectStateResponse::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("SelectStateResponse {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -4134,7 +4164,7 @@ void SelectCommandRequest::encode(ProtoWriteBuffer buffer) const {
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SelectCommandRequest::dump_to(std::string &out) const {
-  char buffer[64];
+  __attribute__((unused)) char buffer[64];
   out.append("SelectCommandRequest {\n");
   out.append("  key: ");
   sprintf(buffer, "%u", this->key);
@@ -4147,6 +4177,127 @@ void SelectCommandRequest::dump_to(std::string &out) const {
   out.append("}");
 }
 #endif
+bool ListEntitiesButtonResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 6: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
+    case 7: {
+      this->entity_category = value.as_enum<enums::EntityCategory>();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesButtonResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->object_id = value.as_string();
+      return true;
+    }
+    case 3: {
+      this->name = value.as_string();
+      return true;
+    }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
+    case 5: {
+      this->icon = value.as_string();
+      return true;
+    }
+    case 8: {
+      this->device_class = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesButtonResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 2: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ListEntitiesButtonResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_string(1, this->object_id);
+  buffer.encode_fixed32(2, this->key);
+  buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
+  buffer.encode_string(5, this->icon);
+  buffer.encode_bool(6, this->disabled_by_default);
+  buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
+  buffer.encode_string(8, this->device_class);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ListEntitiesButtonResponse::dump_to(std::string &out) const {
+  char buffer[64];
+  out.append("ListEntitiesButtonResponse {\n");
+  out.append("  object_id: ");
+  out.append("'").append(this->object_id).append("'");
+  out.append("\n");
+
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  name: ");
+  out.append("'").append(this->name).append("'");
+  out.append("\n");
+
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
+  out.append("  icon: ");
+  out.append("'").append(this->icon).append("'");
+  out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
+
+  out.append("  entity_category: ");
+  out.append(proto_enum_to_string<enums::EntityCategory>(this->entity_category));
+  out.append("\n");
+
+  out.append("  device_class: ");
+  out.append("'").append(this->device_class).append("'");
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool ButtonCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ButtonCommandRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_fixed32(1, this->key); }
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ButtonCommandRequest::dump_to(std::string &out) const {
+  char buffer[64];
+  out.append("ButtonCommandRequest {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+  out.append("}");
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2.h

@@ -123,6 +123,11 @@ enum ClimatePreset : uint32_t {
   CLIMATE_PRESET_SLEEP = 6,
   CLIMATE_PRESET_ACTIVITY = 7,
 };
+enum NumberMode : uint32_t {
+  NUMBER_MODE_AUTO = 0,
+  NUMBER_MODE_BOX = 1,
+  NUMBER_MODE_SLIDER = 2,
+};
 
 }  // namespace enums
 
@@ -957,6 +962,8 @@ class ListEntitiesNumberResponse : public ProtoMessage {
   float step{0.0f};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
+  std::string unit_of_measurement{};
+  enums::NumberMode mode{};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -1041,6 +1048,37 @@ class SelectCommandRequest : public ProtoMessage {
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
 };
+class ListEntitiesButtonResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  bool disabled_by_default{false};
+  enums::EntityCategory entity_category{};
+  std::string device_class{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ButtonCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+};
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.cpp

@@ -282,6 +282,16 @@ bool APIServerConnectionBase::send_select_state_response(const SelectStateRespon
 #endif
 #ifdef USE_SELECT
 #endif
+#ifdef USE_BUTTON
+bool APIServerConnectionBase::send_list_entities_button_response(const ListEntitiesButtonResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_list_entities_button_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ListEntitiesButtonResponse>(msg, 61);
+}
+#endif
+#ifdef USE_BUTTON
+#endif
 bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {
   switch (msg_type) {
     case 1: {
@@ -513,6 +523,17 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ESP_LOGVV(TAG, "on_select_command_request: %s", msg.dump().c_str());
 #endif
       this->on_select_command_request(msg);
+#endif
+      break;
+    }
+    case 62: {
+#ifdef USE_BUTTON
+      ButtonCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_button_command_request: %s", msg.dump().c_str());
+#endif
+      this->on_button_command_request(msg);
 #endif
       break;
     }
@@ -737,6 +758,19 @@ void APIServerConnection::on_select_command_request(const SelectCommandRequest &
   this->select_command(msg);
 }
 #endif
+#ifdef USE_BUTTON
+void APIServerConnection::on_button_command_request(const ButtonCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->button_command(msg);
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.h

@@ -129,6 +129,12 @@ class APIServerConnectionBase : public ProtoService {
 #endif
 #ifdef USE_SELECT
   virtual void on_select_command_request(const SelectCommandRequest &value){};
+#endif
+#ifdef USE_BUTTON
+  bool send_list_entities_button_response(const ListEntitiesButtonResponse &msg);
+#endif
+#ifdef USE_BUTTON
+  virtual void on_button_command_request(const ButtonCommandRequest &value){};
 #endif
  protected:
   bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
@@ -171,6 +177,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #endif
 #ifdef USE_SELECT
   virtual void select_command(const SelectCommandRequest &msg) = 0;
+#endif
+#ifdef USE_BUTTON
+  virtual void button_command(const ButtonCommandRequest &msg) = 0;
 #endif
  protected:
   void on_hello_request(const HelloRequest &msg) override;
@@ -209,6 +218,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_SELECT
   void on_select_command_request(const SelectCommandRequest &msg) override;
 #endif
+#ifdef USE_BUTTON
+  void on_button_command_request(const ButtonCommandRequest &msg) override;
+#endif
 };
 
 }  // namespace api

esphome/components/api/list_entities.cpp

@@ -27,6 +27,9 @@ bool ListEntitiesIterator::on_sensor(sensor::Sensor *sensor) { return this->clie
 #ifdef USE_SWITCH
 bool ListEntitiesIterator::on_switch(switch_::Switch *a_switch) { return this->client_->send_switch_info(a_switch); }
 #endif
+#ifdef USE_BUTTON
+bool ListEntitiesIterator::on_button(button::Button *button) { return this->client_->send_button_info(button); }
+#endif
 #ifdef USE_TEXT_SENSOR
 bool ListEntitiesIterator::on_text_sensor(text_sensor::TextSensor *text_sensor) {
   return this->client_->send_text_sensor_info(text_sensor);

esphome/components/api/list_entities.h

@@ -30,6 +30,9 @@ class ListEntitiesIterator : public ComponentIterator {
 #ifdef USE_SWITCH
   bool on_switch(switch_::Switch *a_switch) override;
 #endif
+#ifdef USE_BUTTON
+  bool on_button(button::Button *button) override;
+#endif
 #ifdef USE_TEXT_SENSOR
   bool on_text_sensor(text_sensor::TextSensor *text_sensor) override;
 #endif

esphome/components/api/subscribe_state.h

@@ -31,6 +31,9 @@ class InitialStateIterator : public ComponentIterator {
 #ifdef USE_SWITCH
   bool on_switch(switch_::Switch *a_switch) override;
 #endif
+#ifdef USE_BUTTON
+  bool on_button(button::Button *button) override { return true; };
+#endif
 #ifdef USE_TEXT_SENSOR
   bool on_text_sensor(text_sensor::TextSensor *text_sensor) override;
 #endif

esphome/components/api/util.cpp

@@ -116,6 +116,21 @@ void ComponentIterator::advance() {
       }
       break;
 #endif
+#ifdef USE_BUTTON
+    case IteratorState::BUTTON:
+      if (this->at_ >= App.get_buttons().size()) {
+        advance_platform = true;
+      } else {
+        auto *button = App.get_buttons()[this->at_];
+        if (button->is_internal()) {
+          success = true;
+          break;
+        } else {
+          success = this->on_button(button);
+        }
+      }
+      break;
+#endif
 #ifdef USE_TEXT_SENSOR
     case IteratorState::TEXT_SENSOR:
       if (this->at_ >= App.get_text_sensors().size()) {

esphome/components/api/util.h

@@ -38,6 +38,9 @@ class ComponentIterator {
 #ifdef USE_SWITCH
   virtual bool on_switch(switch_::Switch *a_switch) = 0;
 #endif
+#ifdef USE_BUTTON
+  virtual bool on_button(button::Button *button) = 0;
+#endif
 #ifdef USE_TEXT_SENSOR
   virtual bool on_text_sensor(text_sensor::TextSensor *text_sensor) = 0;
 #endif
@@ -78,6 +81,9 @@ class ComponentIterator {
 #ifdef USE_SWITCH
     SWITCH,
 #endif
+#ifdef USE_BUTTON
+    BUTTON,
+#endif
 #ifdef USE_TEXT_SENSOR
     TEXT_SENSOR,
 #endif

esphome/components/bme280/bme280.cpp

@@ -33,6 +33,7 @@ static const uint8_t BME280_REGISTER_CONTROLHUMID = 0xF2;
 static const uint8_t BME280_REGISTER_STATUS = 0xF3;
 static const uint8_t BME280_REGISTER_CONTROL = 0xF4;
 static const uint8_t BME280_REGISTER_CONFIG = 0xF5;
+static const uint8_t BME280_REGISTER_MEASUREMENTS = 0xF7;
 static const uint8_t BME280_REGISTER_PRESSUREDATA = 0xF7;
 static const uint8_t BME280_REGISTER_TEMPDATA = 0xFA;
 static const uint8_t BME280_REGISTER_HUMIDDATA = 0xFD;
@@ -178,23 +179,29 @@ void BME280Component::update() {
     return;
   }
 
-  float meas_time = 1.5;
+  float meas_time = 1.5f;
   meas_time += 2.3f * oversampling_to_time(this->temperature_oversampling_);
   meas_time += 2.3f * oversampling_to_time(this->pressure_oversampling_) + 0.575f;
   meas_time += 2.3f * oversampling_to_time(this->humidity_oversampling_) + 0.575f;
 
   this->set_timeout("data", uint32_t(ceilf(meas_time)), [this]() {
+    uint8_t data[8];
+    if (!this->read_bytes(BME280_REGISTER_MEASUREMENTS, data, 8)) {
+      ESP_LOGW(TAG, "Error reading registers.");
+      this->status_set_warning();
+      return;
+    }
     int32_t t_fine = 0;
-    float temperature = this->read_temperature_(&t_fine);
+    float temperature = this->read_temperature_(data, &t_fine);
     if (std::isnan(temperature)) {
       ESP_LOGW(TAG, "Invalid temperature, cannot read pressure & humidity values.");
       this->status_set_warning();
       return;
     }
-    float pressure = this->read_pressure_(t_fine);
-    float humidity = this->read_humidity_(t_fine);
+    float pressure = this->read_pressure_(data, t_fine);
+    float humidity = this->read_humidity_(data, t_fine);
 
-    ESP_LOGD(TAG, "Got temperature=%.1f°C pressure=%.1fhPa humidity=%.1f%%", temperature, pressure, humidity);
+    ESP_LOGV(TAG, "Got temperature=%.1f°C pressure=%.1fhPa humidity=%.1f%%", temperature, pressure, humidity);
     if (this->temperature_sensor_ != nullptr)
       this->temperature_sensor_->publish_state(temperature);
     if (this->pressure_sensor_ != nullptr)
@@ -204,11 +211,8 @@ void BME280Component::update() {
     this->status_clear_warning();
   });
 }
-float BME280Component::read_temperature_(int32_t *t_fine) {
-  uint8_t data[3];
-  if (!this->read_bytes(BME280_REGISTER_TEMPDATA, data, 3))
-    return NAN;
-  int32_t adc = ((data[0] & 0xFF) << 16) | ((data[1] & 0xFF) << 8) | (data[2] & 0xFF);
+float BME280Component::read_temperature_(const uint8_t *data, int32_t *t_fine) {
+  int32_t adc = ((data[3] & 0xFF) << 16) | ((data[4] & 0xFF) << 8) | (data[5] & 0xFF);
   adc >>= 4;
   if (adc == 0x80000)
     // temperature was disabled
@@ -226,10 +230,7 @@ float BME280Component::read_temperature_(int32_t *t_fine) {
   return temperature / 100.0f;
 }
 
-float BME280Component::read_pressure_(int32_t t_fine) {
-  uint8_t data[3];
-  if (!this->read_bytes(BME280_REGISTER_PRESSUREDATA, data, 3))
-    return NAN;
+float BME280Component::read_pressure_(const uint8_t *data, int32_t t_fine) {
   int32_t adc = ((data[0] & 0xFF) << 16) | ((data[1] & 0xFF) << 8) | (data[2] & 0xFF);
   adc >>= 4;
   if (adc == 0x80000)
@@ -265,9 +266,9 @@ float BME280Component::read_pressure_(int32_t t_fine) {
   return (p / 256.0f) / 100.0f;
 }
 
-float BME280Component::read_humidity_(int32_t t_fine) {
-  uint16_t raw_adc;
-  if (!this->read_byte_16(BME280_REGISTER_HUMIDDATA, &raw_adc) || raw_adc == 0x8000)
+float BME280Component::read_humidity_(const uint8_t *data, int32_t t_fine) {
+  uint16_t raw_adc = ((data[6] & 0xFF) << 8) | (data[7] & 0xFF);
+  if (raw_adc == 0x8000)
     return NAN;
 
   int32_t adc = raw_adc;

esphome/components/bme280/bme280.h

@@ -82,11 +82,11 @@ class BME280Component : public PollingComponent, public i2c::I2CDevice {
 
  protected:
   /// Read the temperature value and store the calculated ambient temperature in t_fine.
-  float read_temperature_(int32_t *t_fine);
+  float read_temperature_(const uint8_t *data, int32_t *t_fine);
   /// Read the pressure value in hPa using the provided t_fine value.
-  float read_pressure_(int32_t t_fine);
+  float read_pressure_(const uint8_t *data, int32_t t_fine);
   /// Read the humidity value in % using the provided t_fine value.
-  float read_humidity_(int32_t t_fine);
+  float read_humidity_(const uint8_t *data, int32_t t_fine);
   uint8_t read_u8_(uint8_t a_register);
   uint16_t read_u16_le_(uint8_t a_register);
   int16_t read_s16_le_(uint8_t a_register);

esphome/components/button/__init__.py

@@ -0,0 +1,127 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome import automation
+from esphome.automation import maybe_simple_id
+from esphome.components import mqtt
+from esphome.const import (
+    CONF_DEVICE_CLASS,
+    CONF_ENTITY_CATEGORY,
+    CONF_ICON,
+    CONF_ID,
+    CONF_ON_PRESS,
+    CONF_TRIGGER_ID,
+    CONF_MQTT_ID,
+    DEVICE_CLASS_RESTART,
+    DEVICE_CLASS_UPDATE,
+)
+from esphome.core import CORE, coroutine_with_priority
+from esphome.cpp_helpers import setup_entity
+
+CODEOWNERS = ["@esphome/core"]
+IS_PLATFORM_COMPONENT = True
+
+DEVICE_CLASSES = [
+    DEVICE_CLASS_RESTART,
+    DEVICE_CLASS_UPDATE,
+]
+
+button_ns = cg.esphome_ns.namespace("button")
+Button = button_ns.class_("Button", cg.EntityBase)
+ButtonPtr = Button.operator("ptr")
+
+PressAction = button_ns.class_("PressAction", automation.Action)
+
+ButtonPressTrigger = button_ns.class_(
+    "ButtonPressTrigger", automation.Trigger.template()
+)
+
+validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
+
+
+BUTTON_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).extend(
+    {
+        cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTButtonComponent),
+        cv.Optional(CONF_DEVICE_CLASS): validate_device_class,
+        cv.Optional(CONF_ON_PRESS): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ButtonPressTrigger),
+            }
+        ),
+    }
+)
+
+_UNDEF = object()
+
+
+def button_schema(
+    icon: str = _UNDEF,
+    entity_category: str = _UNDEF,
+    device_class: str = _UNDEF,
+) -> cv.Schema:
+    schema = BUTTON_SCHEMA
+    if icon is not _UNDEF:
+        schema = schema.extend({cv.Optional(CONF_ICON, default=icon): cv.icon})
+    if entity_category is not _UNDEF:
+        schema = schema.extend(
+            {
+                cv.Optional(
+                    CONF_ENTITY_CATEGORY, default=entity_category
+                ): cv.entity_category
+            }
+        )
+    if device_class is not _UNDEF:
+        schema = schema.extend(
+            {
+                cv.Optional(
+                    CONF_DEVICE_CLASS, default=device_class
+                ): validate_device_class
+            }
+        )
+    return schema
+
+
+async def setup_button_core_(var, config):
+    await setup_entity(var, config)
+
+    for conf in config.get(CONF_ON_PRESS, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+
+    if CONF_DEVICE_CLASS in config:
+        cg.add(var.set_device_class(config[CONF_DEVICE_CLASS]))
+
+    if CONF_MQTT_ID in config:
+        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+        await mqtt.register_mqtt_component(mqtt_, config)
+
+
+async def register_button(var, config):
+    if not CORE.has_id(config[CONF_ID]):
+        var = cg.Pvariable(config[CONF_ID], var)
+    cg.add(cg.App.register_button(var))
+    await setup_button_core_(var, config)
+
+
+async def new_button(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await register_button(var, config)
+    return var
+
+
+BUTTON_PRESS_SCHEMA = maybe_simple_id(
+    {
+        cv.Required(CONF_ID): cv.use_id(Button),
+    }
+)
+
+
+@automation.register_action("button.press", PressAction, BUTTON_PRESS_SCHEMA)
+async def button_press_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)
+
+
+@coroutine_with_priority(100.0)
+async def to_code(config):
+    cg.add_global(button_ns.using)
+    cg.add_define("USE_BUTTON")

esphome/components/button/automation.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "esphome/components/button/button.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace button {
+
+template<typename... Ts> class PressAction : public Action<Ts...> {
+ public:
+  explicit PressAction(Button *button) : button_(button) {}
+
+  void play(Ts... x) override { this->button_->press(); }
+
+ protected:
+  Button *button_;
+};
+
+class ButtonPressTrigger : public Trigger<> {
+ public:
+  ButtonPressTrigger(Button *button) {
+    button->add_on_press_callback([this]() { this->trigger(); });
+  }
+};
+
+}  // namespace button
+}  // namespace esphome

esphome/components/button/button.cpp

@@ -0,0 +1,28 @@
+#include "button.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace button {
+
+static const char *const TAG = "button";
+
+Button::Button(const std::string &name) : EntityBase(name) {}
+Button::Button() : Button("") {}
+
+void Button::press() {
+  ESP_LOGD(TAG, "'%s' Pressed.", this->get_name().c_str());
+  this->press_action();
+  this->press_callback_.call();
+}
+void Button::add_on_press_callback(std::function<void()> &&callback) { this->press_callback_.add(std::move(callback)); }
+uint32_t Button::hash_base() { return 1495763804UL; }
+
+void Button::set_device_class(const std::string &device_class) { this->device_class_ = device_class; }
+std::string Button::get_device_class() {
+  if (this->device_class_.has_value())
+    return *this->device_class_;
+  return "";
+}
+
+}  // namespace button
+}  // namespace esphome

esphome/components/button/button.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/entity_base.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace button {
+
+#define LOG_BUTTON(prefix, type, obj) \
+  if ((obj) != nullptr) { \
+    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()); \
+    } \
+  }
+
+/** Base class for all buttons.
+ *
+ * A button is just a momentary switch that does not have a state, only a trigger.
+ */
+class Button : public EntityBase {
+ public:
+  explicit Button();
+  explicit Button(const std::string &name);
+
+  /** Press this button. This is called by the front-end.
+   *
+   * For implementing buttons, please override press_action.
+   */
+  void press();
+
+  /** Set callback for state changes.
+   *
+   * @param callback The void() callback.
+   */
+  void add_on_press_callback(std::function<void()> &&callback);
+
+  /// Set the Home Assistant device class (see button::device_class).
+  void set_device_class(const std::string &device_class);
+
+  /// Get the device class for this button.
+  std::string get_device_class();
+
+ protected:
+  /** You should implement this virtual method if you want to create your own button.
+   */
+  virtual void press_action(){};
+
+  uint32_t hash_base() override;
+
+  CallbackManager<void()> press_callback_{};
+  optional<std::string> device_class_{};
+};
+
+}  // namespace button
+}  // namespace esphome

esphome/components/captive_portal/captive_portal.cpp

@@ -85,14 +85,7 @@ void CaptivePortal::start() {
   this->dns_server_->start(53, "*", (uint32_t) ip);
 
   this->base_->get_server()->onNotFound([this](AsyncWebServerRequest *req) {
-    bool not_found = false;
-    if (!this->active_) {
-      not_found = true;
-    } else if (req->host().c_str() == wifi::global_wifi_component->wifi_soft_ap_ip().str()) {
-      not_found = true;
-    }
-
-    if (not_found) {
+    if (!this->active_ || req->host().c_str() == wifi::global_wifi_component->wifi_soft_ap_ip().str()) {
       req->send(404, "text/html", "File not found");
       return;
     }

esphome/components/climate/__init__.py

@@ -213,7 +213,7 @@ async def setup_climate_core_(var, config):
         if CONF_MODE_COMMAND_TOPIC in config:
             cg.add(mqtt_.set_custom_mode_command_topic(config[CONF_MODE_COMMAND_TOPIC]))
         if CONF_MODE_STATE_TOPIC in config:
-            cg.add(mqtt_.set_custom_state_topic(config[CONF_MODE_STATE_TOPIC]))
+            cg.add(mqtt_.set_custom_mode_state_topic(config[CONF_MODE_STATE_TOPIC]))
 
         if CONF_SWING_MODE_COMMAND_TOPIC in config:
             cg.add(

esphome/components/cs5460a/cs5460a.cpp

@@ -102,8 +102,6 @@ void CS5460AComponent::hw_init_() {
 
 /* Doesn't reset the register values etc., just restarts the "computation cycle" */
 void CS5460AComponent::restart_() {
-  int cnt;
-
   this->enable();
   /* Stop running conversion, wake up if needed */
   this->write_byte(CMD_POWER_UP);

esphome/components/cse7766/cse7766.cpp

@@ -90,6 +90,7 @@ void CSE7766Component::parse_data_() {
   uint32_t power_cycle = this->get_24_bit_uint_(17);
 
   uint8_t adj = this->raw_data_[20];
+  uint32_t cf_pulses = (this->raw_data_[21] << 8) + this->raw_data_[22];
 
   bool power_ok = true;
   bool voltage_ok = true;
@@ -127,6 +128,18 @@ void CSE7766Component::parse_data_() {
     power = power_calib / float(power_cycle);
     this->power_acc_ += power;
     this->power_counts_ += 1;
+
+    uint32_t difference;
+    if (this->cf_pulses_last_ == 0)
+      this->cf_pulses_last_ = cf_pulses;
+
+    if (cf_pulses < this->cf_pulses_last_) {
+      difference = cf_pulses + (0x10000 - this->cf_pulses_last_);
+    } else {
+      difference = cf_pulses - this->cf_pulses_last_;
+    }
+    this->cf_pulses_last_ = cf_pulses;
+    this->energy_total_ += difference * float(power_calib) / 1000000.0 / 3600.0;
   }
 
   if ((adj & 0x20) == 0x20 && current_ok && voltage_ok && power != 0.0) {
@@ -136,9 +149,9 @@ void CSE7766Component::parse_data_() {
   }
 }
 void CSE7766Component::update() {
-  float voltage = this->voltage_counts_ > 0 ? this->voltage_acc_ / this->voltage_counts_ : 0.0;
-  float current = this->current_counts_ > 0 ? this->current_acc_ / this->current_counts_ : 0.0;
-  float power = this->power_counts_ > 0 ? this->power_acc_ / this->power_counts_ : 0.0;
+  float voltage = this->voltage_counts_ > 0 ? this->voltage_acc_ / this->voltage_counts_ : 0.0f;
+  float current = this->current_counts_ > 0 ? this->current_acc_ / this->current_counts_ : 0.0f;
+  float power = this->power_counts_ > 0 ? this->power_acc_ / this->power_counts_ : 0.0f;
 
   ESP_LOGV(TAG, "Got voltage_acc=%.2f current_acc=%.2f power_acc=%.2f", this->voltage_acc_, this->current_acc_,
            this->power_acc_);
@@ -152,6 +165,8 @@ void CSE7766Component::update() {
     this->current_sensor_->publish_state(current);
   if (this->power_sensor_ != nullptr)
     this->power_sensor_->publish_state(power);
+  if (this->energy_sensor_ != nullptr)
+    this->energy_sensor_->publish_state(this->energy_total_);
 
   this->voltage_acc_ = 0.0f;
   this->current_acc_ = 0.0f;
@@ -172,6 +187,7 @@ void CSE7766Component::dump_config() {
   LOG_SENSOR("  ", "Voltage", this->voltage_sensor_);
   LOG_SENSOR("  ", "Current", this->current_sensor_);
   LOG_SENSOR("  ", "Power", this->power_sensor_);
+  LOG_SENSOR("  ", "Energy", this->energy_sensor_);
   this->check_uart_settings(4800);
 }
 

esphome/components/cse7766/cse7766.h

@@ -12,6 +12,7 @@ class CSE7766Component : public PollingComponent, public uart::UARTDevice {
   void set_voltage_sensor(sensor::Sensor *voltage_sensor) { voltage_sensor_ = voltage_sensor; }
   void set_current_sensor(sensor::Sensor *current_sensor) { current_sensor_ = current_sensor; }
   void set_power_sensor(sensor::Sensor *power_sensor) { power_sensor_ = power_sensor; }
+  void set_energy_sensor(sensor::Sensor *energy_sensor) { energy_sensor_ = energy_sensor; }
 
   void loop() override;
   float get_setup_priority() const override;
@@ -29,9 +30,12 @@ class CSE7766Component : public PollingComponent, public uart::UARTDevice {
   sensor::Sensor *voltage_sensor_{nullptr};
   sensor::Sensor *current_sensor_{nullptr};
   sensor::Sensor *power_sensor_{nullptr};
+  sensor::Sensor *energy_sensor_{nullptr};
   float voltage_acc_{0.0f};
   float current_acc_{0.0f};
   float power_acc_{0.0f};
+  float energy_total_{0.0f};
+  uint32_t cf_pulses_last_{0};
   uint32_t voltage_counts_{0};
   uint32_t current_counts_{0};
   uint32_t power_counts_{0};

esphome/components/cse7766/sensor.py

@@ -3,16 +3,20 @@ import esphome.config_validation as cv
 from esphome.components import sensor, uart
 from esphome.const import (
     CONF_CURRENT,
+    CONF_ENERGY,
     CONF_ID,
     CONF_POWER,
     CONF_VOLTAGE,
     DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_ENERGY,
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_VOLTAGE,
     STATE_CLASS_MEASUREMENT,
+    STATE_CLASS_TOTAL_INCREASING,
     UNIT_VOLT,
     UNIT_AMPERE,
     UNIT_WATT,
+    UNIT_WATT_HOURS,
 )
 
 DEPENDENCIES = ["uart"]
@@ -44,6 +48,12 @@ CONFIG_SCHEMA = (
                 device_class=DEVICE_CLASS_POWER,
                 state_class=STATE_CLASS_MEASUREMENT,
             ),
+            cv.Optional(CONF_ENERGY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_WATT_HOURS,
+                accuracy_decimals=3,
+                device_class=DEVICE_CLASS_ENERGY,
+                state_class=STATE_CLASS_TOTAL_INCREASING,
+            ),
         }
     )
     .extend(cv.polling_component_schema("60s"))
@@ -71,3 +81,7 @@ async def to_code(config):
         conf = config[CONF_POWER]
         sens = await sensor.new_sensor(conf)
         cg.add(var.set_power_sensor(sens))
+    if CONF_ENERGY in config:
+        conf = config[CONF_ENERGY]
+        sens = await sensor.new_sensor(conf)
+        cg.add(var.set_energy_sensor(sens))

esphome/components/daikin/daikin.cpp

@@ -231,7 +231,7 @@ bool DaikinClimate::on_receive(remote_base::RemoteReceiveData data) {
       // frame header
       if (byte != 0x27)
         return false;
-    } else if (pos == 3) {
+    } else if (pos == 3) {  // NOLINT(bugprone-branch-clone)
       // frame header
       if (byte != 0x00)
         return false;

esphome/components/dashboard_import/__init__.py

@@ -29,12 +29,11 @@ CONFIG_SCHEMA = cv.Schema(
     }
 )
 
-WIFI_MESSAGE = """
+WIFI_CONFIG = """
 
-# Do not forget to add your own wifi configuration before installing this configuration
-# wifi:
-#   ssid: !secret wifi_ssid
-#   password: !secret wifi_password
+wifi:
+  ssid: !secret wifi_ssid
+  password: !secret wifi_password
 """
 
 
@@ -55,6 +54,6 @@ def import_config(path: str, name: str, project_name: str, import_url: str) -> N
         "esphome": {"name_add_mac_suffix": False},
     }
     p.write_text(
-        dump(config) + WIFI_MESSAGE,
+        dump(config) + WIFI_CONFIG,
         encoding="utf8",
     )

esphome/components/deep_sleep/__init__.py

@@ -41,15 +41,30 @@ EXT1_WAKEUP_MODES = {
     "ALL_LOW": esp_sleep_ext1_wakeup_mode_t.ESP_EXT1_WAKEUP_ALL_LOW,
     "ANY_HIGH": esp_sleep_ext1_wakeup_mode_t.ESP_EXT1_WAKEUP_ANY_HIGH,
 }
+WakeupCauseToRunDuration = deep_sleep_ns.struct("WakeupCauseToRunDuration")
 
 CONF_WAKEUP_PIN_MODE = "wakeup_pin_mode"
 CONF_ESP32_EXT1_WAKEUP = "esp32_ext1_wakeup"
 CONF_TOUCH_WAKEUP = "touch_wakeup"
+CONF_DEFAULT = "default"
+CONF_GPIO_WAKEUP_REASON = "gpio_wakeup_reason"
+CONF_TOUCH_WAKEUP_REASON = "touch_wakeup_reason"
+
+WAKEUP_CAUSES_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_DEFAULT): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_TOUCH_WAKEUP_REASON): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_GPIO_WAKEUP_REASON): cv.positive_time_period_milliseconds,
+    }
+)
 
 CONFIG_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.declare_id(DeepSleepComponent),
-        cv.Optional(CONF_RUN_DURATION): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_RUN_DURATION): cv.Any(
+            cv.All(cv.only_on_esp32, WAKEUP_CAUSES_SCHEMA),
+            cv.positive_time_period_milliseconds,
+        ),
         cv.Optional(CONF_SLEEP_DURATION): cv.positive_time_period_milliseconds,
         cv.Optional(CONF_WAKEUP_PIN): cv.All(
             cv.only_on_esp32, pins.internal_gpio_input_pin_schema, validate_pin_number
@@ -85,7 +100,28 @@ async def to_code(config):
     if CONF_WAKEUP_PIN_MODE in config:
         cg.add(var.set_wakeup_pin_mode(config[CONF_WAKEUP_PIN_MODE]))
     if CONF_RUN_DURATION in config:
-        cg.add(var.set_run_duration(config[CONF_RUN_DURATION]))
+        run_duration_config = config[CONF_RUN_DURATION]
+        if not isinstance(run_duration_config, dict):
+            cg.add(var.set_run_duration(config[CONF_RUN_DURATION]))
+        else:
+            default_run_duration = run_duration_config[CONF_DEFAULT]
+            wakeup_cause_to_run_duration = cg.StructInitializer(
+                WakeupCauseToRunDuration,
+                ("default_cause", default_run_duration),
+                (
+                    "touch_cause",
+                    run_duration_config.get(
+                        CONF_TOUCH_WAKEUP_REASON, default_run_duration
+                    ),
+                ),
+                (
+                    "gpio_cause",
+                    run_duration_config.get(
+                        CONF_GPIO_WAKEUP_REASON, default_run_duration
+                    ),
+                ),
+            )
+            cg.add(var.set_run_duration(wakeup_cause_to_run_duration))
 
     if CONF_ESP32_EXT1_WAKEUP in config:
         conf = config[CONF_ESP32_EXT1_WAKEUP]

esphome/components/deep_sleep/deep_sleep_component.cpp

@@ -13,12 +13,35 @@ static const char *const TAG = "deep_sleep";
 
 bool global_has_deep_sleep = false;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
+optional<uint32_t> DeepSleepComponent::get_run_duration_() const {
+#ifdef USE_ESP32
+  if (this->wakeup_cause_to_run_duration_.has_value()) {
+    esp_sleep_wakeup_cause_t wakeup_cause = esp_sleep_get_wakeup_cause();
+    switch (wakeup_cause) {
+      case ESP_SLEEP_WAKEUP_EXT0:
+      case ESP_SLEEP_WAKEUP_EXT1:
+        return this->wakeup_cause_to_run_duration_->gpio_cause;
+      case ESP_SLEEP_WAKEUP_TOUCHPAD:
+        return this->wakeup_cause_to_run_duration_->touch_cause;
+      default:
+        return this->wakeup_cause_to_run_duration_->default_cause;
+    }
+  }
+#endif
+  return this->run_duration_;
+}
+
 void DeepSleepComponent::setup() {
   ESP_LOGCONFIG(TAG, "Setting up Deep Sleep...");
   global_has_deep_sleep = true;
 
-  if (this->run_duration_.has_value())
-    this->set_timeout(*this->run_duration_, [this]() { this->begin_sleep(); });
+  const optional<uint32_t> run_duration = get_run_duration_();
+  if (run_duration.has_value()) {
+    ESP_LOGI(TAG, "Scheduling Deep Sleep to start in %u ms", *run_duration);
+    this->set_timeout(*run_duration, [this]() { this->begin_sleep(); });
+  } else {
+    ESP_LOGD(TAG, "Not scheduling Deep Sleep, as no run duration is configured.");
+  }
 }
 void DeepSleepComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "Setting up Deep Sleep...");
@@ -33,6 +56,11 @@ void DeepSleepComponent::dump_config() {
   if (wakeup_pin_ != nullptr) {
     LOG_PIN("  Wakeup Pin: ", this->wakeup_pin_);
   }
+  if (this->wakeup_cause_to_run_duration_.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Default Wakeup Run Duration: %u ms", this->wakeup_cause_to_run_duration_->default_cause);
+    ESP_LOGCONFIG(TAG, "  Touch Wakeup Run Duration: %u ms", this->wakeup_cause_to_run_duration_->touch_cause);
+    ESP_LOGCONFIG(TAG, "  GPIO Wakeup Run Duration: %u ms", this->wakeup_cause_to_run_duration_->gpio_cause);
+  }
 #endif
 }
 void DeepSleepComponent::loop() {
@@ -49,6 +77,9 @@ void DeepSleepComponent::set_wakeup_pin_mode(WakeupPinMode wakeup_pin_mode) {
 }
 void DeepSleepComponent::set_ext1_wakeup(Ext1Wakeup ext1_wakeup) { this->ext1_wakeup_ = ext1_wakeup; }
 void DeepSleepComponent::set_touch_wakeup(bool touch_wakeup) { this->touch_wakeup_ = touch_wakeup; }
+void DeepSleepComponent::set_run_duration(WakeupCauseToRunDuration wakeup_cause_to_run_duration) {
+  wakeup_cause_to_run_duration_ = wakeup_cause_to_run_duration;
+}
 #endif
 void DeepSleepComponent::set_run_duration(uint32_t time_ms) { this->run_duration_ = time_ms; }
 void DeepSleepComponent::begin_sleep(bool manual) {
@@ -77,8 +108,8 @@ void DeepSleepComponent::begin_sleep(bool manual) {
   if (this->sleep_duration_.has_value())
     esp_sleep_enable_timer_wakeup(*this->sleep_duration_);
   if (this->wakeup_pin_ != nullptr) {
-    bool level = this->wakeup_pin_->is_inverted();
-    if (this->wakeup_pin_mode_ == WAKEUP_PIN_MODE_INVERT_WAKEUP && !this->wakeup_pin_->digital_read()) {
+    bool level = !this->wakeup_pin_->is_inverted();
+    if (this->wakeup_pin_mode_ == WAKEUP_PIN_MODE_INVERT_WAKEUP && this->wakeup_pin_->digital_read()) {
       level = !level;
     }
     esp_sleep_enable_ext0_wakeup(gpio_num_t(this->wakeup_pin_->get_pin()), level);

esphome/components/deep_sleep/deep_sleep_component.h

@@ -32,6 +32,15 @@ struct Ext1Wakeup {
   esp_sleep_ext1_wakeup_mode_t wakeup_mode;
 };
 
+struct WakeupCauseToRunDuration {
+  // Run duration if woken up by timer or any other reason besides those below.
+  uint32_t default_cause;
+  // Run duration if woken up by touch pads.
+  uint32_t touch_cause;
+  // Run duration if woken up by GPIO pins.
+  uint32_t gpio_cause;
+};
+
 #endif
 
 template<typename... Ts> class EnterDeepSleepAction;
@@ -59,6 +68,11 @@ class DeepSleepComponent : public Component {
   void set_ext1_wakeup(Ext1Wakeup ext1_wakeup);
 
   void set_touch_wakeup(bool touch_wakeup);
+
+  // Set the duration in ms for how long the code should run before entering
+  // deep sleep mode, according to the cause the ESP32 has woken.
+  void set_run_duration(WakeupCauseToRunDuration wakeup_cause_to_run_duration);
+
 #endif
   /// Set a duration in ms for how long the code should run before entering deep sleep mode.
   void set_run_duration(uint32_t time_ms);
@@ -75,12 +89,17 @@ class DeepSleepComponent : public Component {
   void prevent_deep_sleep();
 
  protected:
+  // Returns nullopt if no run duration is set. Otherwise, returns the run
+  // duration before entering deep sleep.
+  optional<uint32_t> get_run_duration_() const;
+
   optional<uint64_t> sleep_duration_;
 #ifdef USE_ESP32
   InternalGPIOPin *wakeup_pin_;
   WakeupPinMode wakeup_pin_mode_{WAKEUP_PIN_MODE_IGNORE};
   optional<Ext1Wakeup> ext1_wakeup_;
   optional<bool> touch_wakeup_;
+  optional<WakeupCauseToRunDuration> wakeup_cause_to_run_duration_;
 #endif
   optional<uint32_t> run_duration_;
   bool next_enter_deep_sleep_{false};

esphome/components/display/display_buffer.cpp

@@ -496,7 +496,7 @@ bool Animation::get_pixel(int x, int y) const {
     return false;
   const uint32_t width_8 = ((this->width_ + 7u) / 8u) * 8u;
   const uint32_t frame_index = this->height_ * width_8 * this->current_frame_;
-  if (frame_index >= this->width_ * this->height_ * this->animation_frame_count_)
+  if (frame_index >= (uint32_t)(this->width_ * this->height_ * this->animation_frame_count_))
     return false;
   const uint32_t pos = x + y * width_8 + frame_index;
   return progmem_read_byte(this->data_start_ + (pos / 8u)) & (0x80 >> (pos % 8u));
@@ -505,7 +505,7 @@ Color Animation::get_color_pixel(int x, int y) const {
   if (x < 0 || x >= this->width_ || y < 0 || y >= this->height_)
     return Color::BLACK;
   const uint32_t frame_index = this->width_ * this->height_ * this->current_frame_;
-  if (frame_index >= this->width_ * this->height_ * this->animation_frame_count_)
+  if (frame_index >= (uint32_t)(this->width_ * this->height_ * this->animation_frame_count_))
     return Color::BLACK;
   const uint32_t pos = (x + y * this->width_ + frame_index) * 3;
   const uint32_t color32 = (progmem_read_byte(this->data_start_ + pos + 2) << 0) |
@@ -517,7 +517,7 @@ Color Animation::get_grayscale_pixel(int x, int y) const {
   if (x < 0 || x >= this->width_ || y < 0 || y >= this->height_)
     return Color::BLACK;
   const uint32_t frame_index = this->width_ * this->height_ * this->current_frame_;
-  if (frame_index >= this->width_ * this->height_ * this->animation_frame_count_)
+  if (frame_index >= (uint32_t)(this->width_ * this->height_ * this->animation_frame_count_))
     return Color::BLACK;
   const uint32_t pos = (x + y * this->width_ + frame_index);
   const uint8_t gray = progmem_read_byte(this->data_start_ + pos);

esphome/components/display/display_color_utils.h

@@ -42,7 +42,7 @@ class ColorUtil {
                        ? esp_scale(((colorcode >> third_bits) & ((1 << second_bits) - 1)), ((1 << second_bits) - 1))
                        : esp_scale(((colorcode >> 8) & 0xFF), ((1 << second_bits) - 1));
 
-    third_color = (right_bit_aligned ? esp_scale(((colorcode >> 0) & 0xFF), ((1 << third_bits) - 1))
+    third_color = (right_bit_aligned ? esp_scale(((colorcode >> 0) & ((1 << third_bits) - 1)), ((1 << third_bits) - 1))
                                      : esp_scale(((colorcode >> 0) & 0xFF), (1 << third_bits) - 1));
 
     Color color_return;

esphome/components/dsmr/__init__.py

@@ -5,6 +5,7 @@ from esphome.components import uart
 from esphome.const import (
     CONF_ID,
     CONF_UART_ID,
+    CONF_RECEIVE_TIMEOUT,
 )
 
 CODEOWNERS = ["@glmnet", "@zuidwijk"]
@@ -52,7 +53,12 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_GAS_MBUS_ID, default=1): cv.int_,
             cv.Optional(CONF_MAX_TELEGRAM_LENGTH, default=1500): cv.int_,
             cv.Optional(CONF_REQUEST_PIN): pins.gpio_output_pin_schema,
-            cv.Optional(CONF_REQUEST_INTERVAL): cv.positive_time_period_milliseconds,
+            cv.Optional(
+                CONF_REQUEST_INTERVAL, default="0ms"
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(
+                CONF_RECEIVE_TIMEOUT, default="200ms"
+            ): cv.positive_time_period_milliseconds,
         }
     ).extend(uart.UART_DEVICE_SCHEMA),
     cv.only_with_arduino,
@@ -70,10 +76,8 @@ async def to_code(config):
     if CONF_REQUEST_PIN in config:
         request_pin = await cg.gpio_pin_expression(config[CONF_REQUEST_PIN])
         cg.add(var.set_request_pin(request_pin))
-    if CONF_REQUEST_INTERVAL in config:
-        cg.add(
-            var.set_request_interval(config[CONF_REQUEST_INTERVAL].total_milliseconds)
-        )
+    cg.add(var.set_request_interval(config[CONF_REQUEST_INTERVAL].total_milliseconds))
+    cg.add(var.set_receive_timeout(config[CONF_RECEIVE_TIMEOUT].total_milliseconds))
 
     cg.add_define("DSMR_GAS_MBUS_ID", config[CONF_GAS_MBUS_ID])
 

esphome/components/dsmr/dsmr.cpp

@@ -24,7 +24,7 @@ void Dsmr::loop() {
     if (this->decryption_key_.empty()) {
       this->receive_telegram_();
     } else {
-      this->receive_encrypted_();
+      this->receive_encrypted_telegram_();
     }
   }
 }
@@ -57,14 +57,42 @@ bool Dsmr::request_interval_reached_() {
   return millis() - this->last_request_time_ > this->request_interval_;
 }
 
+bool Dsmr::receive_timeout_reached_() { return millis() - this->last_read_time_ > this->receive_timeout_; }
+
 bool Dsmr::available_within_timeout_() {
-  uint8_t tries = READ_TIMEOUT_MS / 5;
-  while (tries--) {
-    delay(5);
-    if (this->available()) {
-      return true;
+  // Data are available for reading on the UART bus?
+  // Then we can start reading right away.
+  if (this->available()) {
+    this->last_read_time_ = millis();
+    return true;
+  }
+  // When we're not in the process of reading a telegram, then there is
+  // no need to actively wait for new data to come in.
+  if (!header_found_) {
+    return false;
+  }
+  // A telegram is being read. The smart meter might not deliver a telegram
+  // in one go, but instead send it in chunks with small pauses in between.
+  // When the UART RX buffer cannot hold a full telegram, then make sure
+  // that the UART read buffer does not overflow while other components
+  // perform their work in their loop. Do this by not returning control to
+  // the main loop, until the read timeout is reached.
+  if (this->parent_->get_rx_buffer_size() < this->max_telegram_len_) {
+    while (!this->receive_timeout_reached_()) {
+      delay(5);
+      if (this->available()) {
+        this->last_read_time_ = millis();
+        return true;
+      }
     }
   }
+  // No new data has come in during the read timeout? Then stop reading the
+  // telegram and start waiting for the next one to arrive.
+  if (this->receive_timeout_reached_()) {
+    ESP_LOGW(TAG, "Timeout while reading data for telegram");
+    this->reset_telegram_();
+  }
+
   return false;
 }
 
@@ -96,30 +124,31 @@ void Dsmr::stop_requesting_data_() {
   }
 }
 
-void Dsmr::receive_telegram_() {
-  while (true) {
-    if (!this->available()) {
-      if (!this->header_found_ || !this->available_within_timeout_()) {
-        return;
-      }
-    }
+void Dsmr::reset_telegram_() {
+  this->header_found_ = false;
+  this->footer_found_ = false;
+  this->bytes_read_ = 0;
+  this->crypt_bytes_read_ = 0;
+  this->crypt_telegram_len_ = 0;
+  this->last_read_time_ = 0;
+}
 
+void Dsmr::receive_telegram_() {
+  while (this->available_within_timeout_()) {
     const char c = this->read();
 
     // Find a new telegram header, i.e. forward slash.
     if (c == '/') {
       ESP_LOGV(TAG, "Header of telegram found");
+      this->reset_telegram_();
       this->header_found_ = true;
-      this->footer_found_ = false;
-      this->telegram_len_ = 0;
     }
     if (!this->header_found_)
       continue;
 
     // Check for buffer overflow.
-    if (this->telegram_len_ >= this->max_telegram_len_) {
-      this->header_found_ = false;
-      this->footer_found_ = false;
+    if (this->bytes_read_ >= this->max_telegram_len_) {
+      this->reset_telegram_();
       ESP_LOGE(TAG, "Error: telegram larger than buffer (%d bytes)", this->max_telegram_len_);
       return;
     }
@@ -129,9 +158,9 @@ void Dsmr::receive_telegram_() {
     // proper parsing, remove these new line characters.
     if (c == '(') {
       while (true) {
-        auto previous_char = this->telegram_[this->telegram_len_ - 1];
+        auto previous_char = this->telegram_[this->bytes_read_ - 1];
         if (previous_char == '\n' || previous_char == '\r') {
-          this->telegram_len_--;
+          this->bytes_read_--;
         } else {
           break;
         }
@@ -139,8 +168,8 @@ void Dsmr::receive_telegram_() {
     }
 
     // Store the byte in the buffer.
-    this->telegram_[this->telegram_len_] = c;
-    this->telegram_len_++;
+    this->telegram_[this->bytes_read_] = c;
+    this->bytes_read_++;
 
     // Check for a footer, i.e. exlamation mark, followed by a hex checksum.
     if (c == '!') {
@@ -152,28 +181,14 @@ void Dsmr::receive_telegram_() {
     if (this->footer_found_ && c == '\n') {
       // Parse the telegram and publish sensor values.
       this->parse_telegram();
-
-      this->header_found_ = false;
+      this->reset_telegram_();
       return;
     }
   }
 }
 
-void Dsmr::receive_encrypted_() {
-  this->encrypted_telegram_len_ = 0;
-  size_t packet_size = 0;
-
-  while (true) {
-    if (!this->available()) {
-      if (!this->header_found_) {
-        return;
-      }
-      if (!this->available_within_timeout_()) {
-        ESP_LOGW(TAG, "Timeout while reading data for encrypted telegram");
-        return;
-      }
-    }
-
+void Dsmr::receive_encrypted_telegram_() {
+  while (this->available_within_timeout_()) {
     const char c = this->read();
 
     // Find a new telegram start byte.
@@ -182,50 +197,58 @@ void Dsmr::receive_encrypted_() {
         continue;
       }
       ESP_LOGV(TAG, "Start byte 0xDB of encrypted telegram found");
+      this->reset_telegram_();
       this->header_found_ = true;
     }
 
     // Check for buffer overflow.
-    if (this->encrypted_telegram_len_ >= this->max_telegram_len_) {
-      this->header_found_ = false;
+    if (this->crypt_bytes_read_ >= this->max_telegram_len_) {
+      this->reset_telegram_();
       ESP_LOGE(TAG, "Error: encrypted telegram larger than buffer (%d bytes)", this->max_telegram_len_);
       return;
     }
 
-    this->encrypted_telegram_[this->encrypted_telegram_len_++] = c;
+    // Store the byte in the buffer.
+    this->crypt_telegram_[this->crypt_bytes_read_] = c;
+    this->crypt_bytes_read_++;
 
-    if (packet_size == 0 && this->encrypted_telegram_len_ > 20) {
+    // Read the length of the incoming encrypted telegram.
+    if (this->crypt_telegram_len_ == 0 && this->crypt_bytes_read_ > 20) {
       // Complete header + data bytes
-      packet_size = 13 + (this->encrypted_telegram_[11] << 8 | this->encrypted_telegram_[12]);
-      ESP_LOGV(TAG, "Encrypted telegram size: %d bytes", packet_size);
+      this->crypt_telegram_len_ = 13 + (this->crypt_telegram_[11] << 8 | this->crypt_telegram_[12]);
+      ESP_LOGV(TAG, "Encrypted telegram length: %d bytes", this->crypt_telegram_len_);
     }
-    if (this->encrypted_telegram_len_ == packet_size && packet_size > 0) {
-      ESP_LOGV(TAG, "End of encrypted telegram found");
-      GCM<AES128> *gcmaes128{new GCM<AES128>()};
-      gcmaes128->setKey(this->decryption_key_.data(), gcmaes128->keySize());
-      // the iv is 8 bytes of the system title + 4 bytes frame counter
-      // system title is at byte 2 and frame counter at byte 15
-      for (int i = 10; i < 14; i++)
-        this->encrypted_telegram_[i] = this->encrypted_telegram_[i + 4];
-      constexpr uint16_t iv_size{12};
-      gcmaes128->setIV(&this->encrypted_telegram_[2], iv_size);
-      gcmaes128->decrypt(reinterpret_cast<uint8_t *>(this->telegram_),
-                         // the ciphertext start at byte 18
-                         &this->encrypted_telegram_[18],
-                         // cipher size
-                         this->encrypted_telegram_len_ - 17);
-      delete gcmaes128;  // NOLINT(cppcoreguidelines-owning-memory)
 
-      this->telegram_len_ = strnlen(this->telegram_, this->max_telegram_len_);
-      ESP_LOGV(TAG, "Decrypted telegram size: %d bytes", this->telegram_len_);
-      ESP_LOGVV(TAG, "Decrypted telegram: %s", this->telegram_);
-
-      this->parse_telegram();
-
-      this->header_found_ = false;
-      this->telegram_len_ = 0;
-      return;
+    // Check for the end of the encrypted telegram.
+    if (this->crypt_telegram_len_ == 0 || this->crypt_bytes_read_ != this->crypt_telegram_len_) {
+      continue;
     }
+    ESP_LOGV(TAG, "End of encrypted telegram found");
+
+    // Decrypt the encrypted telegram.
+    GCM<AES128> *gcmaes128{new GCM<AES128>()};
+    gcmaes128->setKey(this->decryption_key_.data(), gcmaes128->keySize());
+    // the iv is 8 bytes of the system title + 4 bytes frame counter
+    // system title is at byte 2 and frame counter at byte 15
+    for (int i = 10; i < 14; i++)
+      this->crypt_telegram_[i] = this->crypt_telegram_[i + 4];
+    constexpr uint16_t iv_size{12};
+    gcmaes128->setIV(&this->crypt_telegram_[2], iv_size);
+    gcmaes128->decrypt(reinterpret_cast<uint8_t *>(this->telegram_),
+                       // the ciphertext start at byte 18
+                       &this->crypt_telegram_[18],
+                       // cipher size
+                       this->crypt_bytes_read_ - 17);
+    delete gcmaes128;  // NOLINT(cppcoreguidelines-owning-memory)
+
+    this->bytes_read_ = strnlen(this->telegram_, this->max_telegram_len_);
+    ESP_LOGV(TAG, "Decrypted telegram size: %d bytes", this->bytes_read_);
+    ESP_LOGVV(TAG, "Decrypted telegram: %s", this->telegram_);
+
+    // Parse the decrypted telegram and publish sensor values.
+    this->parse_telegram();
+    this->reset_telegram_();
+    return;
   }
 }
 
@@ -234,11 +257,11 @@ bool Dsmr::parse_telegram() {
   ESP_LOGV(TAG, "Trying to parse telegram");
   this->stop_requesting_data_();
   ::dsmr::ParseResult<void> res =
-      ::dsmr::P1Parser::parse(&data, this->telegram_, this->telegram_len_, false,
+      ::dsmr::P1Parser::parse(&data, this->telegram_, this->bytes_read_, false,
                               this->crc_check_);  // Parse telegram according to data definition. Ignore unknown values.
   if (res.err) {
     // Parsing error, show it
-    auto err_str = res.fullError(this->telegram_, this->telegram_ + this->telegram_len_);
+    auto err_str = res.fullError(this->telegram_, this->telegram_ + this->bytes_read_);
     ESP_LOGE(TAG, "%s", err_str.c_str());
     return false;
   } else {
@@ -251,7 +274,7 @@ bool Dsmr::parse_telegram() {
 void Dsmr::dump_config() {
   ESP_LOGCONFIG(TAG, "DSMR:");
   ESP_LOGCONFIG(TAG, "  Max telegram length: %d", this->max_telegram_len_);
-
+  ESP_LOGCONFIG(TAG, "  Receive timeout: %.1fs", this->receive_timeout_ / 1e3f);
   if (this->request_pin_ != nullptr) {
     LOG_PIN("  Request Pin: ", this->request_pin_);
   }
@@ -270,9 +293,9 @@ void Dsmr::set_decryption_key(const std::string &decryption_key) {
   if (decryption_key.length() == 0) {
     ESP_LOGI(TAG, "Disabling decryption");
     this->decryption_key_.clear();
-    if (this->encrypted_telegram_ != nullptr) {
-      delete[] this->encrypted_telegram_;
-      this->encrypted_telegram_ = nullptr;
+    if (this->crypt_telegram_ != nullptr) {
+      delete[] this->crypt_telegram_;
+      this->crypt_telegram_ = nullptr;
     }
     return;
   }
@@ -293,13 +316,11 @@ void Dsmr::set_decryption_key(const std::string &decryption_key) {
     this->decryption_key_.push_back(std::strtoul(temp, nullptr, 16));
   }
 
-  if (this->encrypted_telegram_ == nullptr) {
-    this->encrypted_telegram_ = new uint8_t[this->max_telegram_len_];  // NOLINT
+  if (this->crypt_telegram_ == nullptr) {
+    this->crypt_telegram_ = new uint8_t[this->max_telegram_len_];  // NOLINT
   }
 }
 
-void Dsmr::set_max_telegram_length(size_t length) { max_telegram_len_ = length; }
-
 }  // namespace dsmr
 }  // namespace esphome
 

esphome/components/dsmr/dsmr.h

@@ -16,8 +16,6 @@
 namespace esphome {
 namespace dsmr {
 
-static constexpr uint32_t READ_TIMEOUT_MS = 200;
-
 using namespace ::dsmr::fields;
 
 // DSMR_**_LIST generated by ESPHome and written in esphome/core/defines
@@ -71,11 +69,10 @@ class Dsmr : public Component, public uart::UARTDevice {
   void dump_config() override;
 
   void set_decryption_key(const std::string &decryption_key);
-
-  void set_max_telegram_length(size_t length);
-
+  void set_max_telegram_length(size_t length) { this->max_telegram_len_ = length; }
   void set_request_pin(GPIOPin *request_pin) { this->request_pin_ = request_pin; }
   void set_request_interval(uint32_t interval) { this->request_interval_ = interval; }
+  void set_receive_timeout(uint32_t timeout) { this->receive_timeout_ = timeout; }
 
 // Sensor setters
 #define DSMR_SET_SENSOR(s) \
@@ -88,7 +85,8 @@ class Dsmr : public Component, public uart::UARTDevice {
 
  protected:
   void receive_telegram_();
-  void receive_encrypted_();
+  void receive_encrypted_telegram_();
+  void reset_telegram_();
 
   /// Wait for UART data to become available within the read timeout.
   ///
@@ -101,24 +99,26 @@ class Dsmr : public Component, public uart::UARTDevice {
   /// lost in the process.
   bool available_within_timeout_();
 
-  // Data request
+  // Request telegram
+  uint32_t request_interval_;
+  bool request_interval_reached_();
   GPIOPin *request_pin_{nullptr};
-  uint32_t request_interval_{0};
   uint32_t last_request_time_{0};
   bool requesting_data_{false};
   bool ready_to_request_data_();
-  bool request_interval_reached_();
   void start_requesting_data_();
   void stop_requesting_data_();
 
-  // Telegram buffer
+  // Read telegram
+  uint32_t receive_timeout_;
+  bool receive_timeout_reached_();
   size_t max_telegram_len_;
   char *telegram_{nullptr};
-  int telegram_len_{0};
-  uint8_t *encrypted_telegram_{nullptr};
-  int encrypted_telegram_len_{0};
-
-  // Serial parser
+  size_t bytes_read_{0};
+  uint8_t *crypt_telegram_{nullptr};
+  size_t crypt_telegram_len_{0};
+  size_t crypt_bytes_read_{0};
+  uint32_t last_read_time_{0};
   bool header_found_{false};
   bool footer_found_{false};
 

esphome/components/duty_cycle/duty_cycle_sensor.cpp

@@ -23,22 +23,24 @@ void DutyCycleSensor::dump_config() {
 }
 void DutyCycleSensor::update() {
   const uint32_t now = micros();
+  const uint32_t last_interrupt = this->store_.last_interrupt;  // Read the measurement taken by the interrupt
+  uint32_t on_time = this->store_.on_time;
+
+  this->store_.on_time = 0;  // Start new measurement, exactly aligned with the micros() reading
+  this->store_.last_interrupt = now;
+
   if (this->last_update_ != 0) {
     const bool level = this->store_.last_level;
-    const uint32_t last_interrupt = this->store_.last_interrupt;
-    uint32_t on_time = this->store_.on_time;
 
     if (level)
       on_time += now - last_interrupt;
 
     const float total_time = float(now - this->last_update_);
 
-    const float value = (on_time / total_time) * 100.0f;
+    const float value = (on_time * 100.0f) / total_time;
     ESP_LOGD(TAG, "'%s' Got duty cycle=%.1f%%", this->get_name().c_str(), value);
     this->publish_state(value);
   }
-  this->store_.on_time = 0;
-  this->store_.last_interrupt = now;
   this->last_update_ = now;
 }
 

esphome/components/esp32/__init__.py

@@ -311,9 +311,16 @@ async def to_code(config):
         )
         add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_DEFAULT", False)
         add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_SIZE", True)
+
         # Increase freertos tick speed from 100Hz to 1kHz so that delay() resolution is 1ms
         add_idf_sdkconfig_option("CONFIG_FREERTOS_HZ", 1000)
 
+        # Setup watchdog
+        add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT", True)
+        add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_PANIC", True)
+        add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0", False)
+        add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1", False)
+
         cg.add_platformio_option("board_build.partitions", "partitions.csv")
 
         for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():

esphome/components/esp32/core.cpp

@@ -6,12 +6,17 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 #include <esp_idf_version.h>
+#include <esp_task_wdt.h>
 #include <soc/rtc.h>
 
 #if ESP_IDF_VERSION_MAJOR >= 4
 #include <hal/cpu_hal.h>
 #endif
 
+#ifdef USE_ARDUINO
+#include <esp32-hal.h>
+#endif
+
 void setup();
 void loop();
 
@@ -29,24 +34,24 @@ void arch_restart() {
     yield();
   }
 }
-void IRAM_ATTR HOT arch_feed_wdt() {
-#ifdef USE_ARDUINO
-#if CONFIG_ARDUINO_RUNNING_CORE == 0
-#ifdef CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0
-  // ESP32 uses "Task Watchdog" which is hooked to the FreeRTOS idle task.
-  // To cause the Watchdog to be triggered we need to put the current task
-  // to sleep to get the idle task scheduled.
-  delay(1);
-#endif
-#endif
-#endif  // USE_ARDUINO
 
-#ifdef USE_ESP_IDF
-#ifdef CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0
-  delay(1);
+void arch_init() {
+  // Enable the task watchdog only on the loop task (from which we're currently running)
+#if defined(USE_ESP_IDF)
+  esp_task_wdt_add(nullptr);
+  // Idle task watchdog is disabled on ESP-IDF
+#elif defined(USE_ARDUINO)
+  enableLoopWDT();
+  // Disable idle task watchdog on the core we're using (Arduino pins the task to a core)
+#if defined(CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0) && CONFIG_ARDUINO_RUNNING_CORE == 0
+  disableCore0WDT();
+#endif
+#if defined(CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1) && CONFIG_ARDUINO_RUNNING_CORE == 1
+  disableCore1WDT();
+#endif
 #endif
-#endif  // USE_ESP_IDF
 }
+void IRAM_ATTR HOT arch_feed_wdt() { esp_task_wdt_reset(); }
 
 uint8_t progmem_read_byte(const uint8_t *addr) { return *addr; }
 uint32_t arch_get_cpu_cycle_count() {

esphome/components/esp32/gpio_esp32.py

@@ -18,7 +18,7 @@ _ESP_SDIO_PINS = {
     11: "Flash Command",
 }
 
-_ESP32_STRAPPING_PINS = {0, 2, 4, 15}
+_ESP32_STRAPPING_PINS = {0, 2, 4, 12, 15}
 _LOGGER = logging.getLogger(__name__)
 
 

esphome/components/esp32/preferences.cpp

@@ -76,6 +76,7 @@ class ESP32Preferences : public ESPPreferences {
   uint32_t current_offset = 0;
 
   void open() {
+    nvs_flash_init();
     esp_err_t err = nvs_open("esphome", NVS_READWRITE, &nvs_handle);
     if (err == 0)
       return;

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -483,6 +483,7 @@ optional<ESPBLEiBeacon> ESPBLEiBeacon::from_manufacturer_data(const ServiceData
 }
 
 void ESPBTDevice::parse_scan_rst(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
+  this->scan_result_ = param;
   for (uint8_t i = 0; i < ESP_BD_ADDR_LEN; i++)
     this->address_[i] = param.bda[i];
   this->address_type_ = param.ble_addr_type;
@@ -524,7 +525,7 @@ void ESPBTDevice::parse_scan_rst(const esp_ble_gap_cb_param_t::ble_scan_result_e
     ESP_LOGVV(TAG, "  Service UUID: %s", uuid.to_string().c_str());
   }
   for (auto &data : this->manufacturer_datas_) {
-    ESP_LOGVV(TAG, "  Manufacturer data: %s", hexencode(data.data).c_str());
+    ESP_LOGVV(TAG, "  Manufacturer data: %s", format_hex_pretty(data.data).c_str());
     if (this->get_ibeacon().has_value()) {
       auto ibeacon = this->get_ibeacon().value();
       ESP_LOGVV(TAG, "    iBeacon data:");
@@ -537,10 +538,10 @@ void ESPBTDevice::parse_scan_rst(const esp_ble_gap_cb_param_t::ble_scan_result_e
   for (auto &data : this->service_datas_) {
     ESP_LOGVV(TAG, "  Service data:");
     ESP_LOGVV(TAG, "    UUID: %s", data.uuid.to_string().c_str());
-    ESP_LOGVV(TAG, "    Data: %s", hexencode(data.data).c_str());
+    ESP_LOGVV(TAG, "    Data: %s", format_hex_pretty(data.data).c_str());
   }
 
-  ESP_LOGVV(TAG, "Adv data: %s", hexencode(param.ble_adv, param.adv_data_len + param.scan_rsp_len).c_str());
+  ESP_LOGVV(TAG, "Adv data: %s", format_hex_pretty(param.ble_adv, param.adv_data_len + param.scan_rsp_len).c_str());
 #endif
 }
 void ESPBTDevice::parse_adv_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -97,6 +97,8 @@ class ESPBTDevice {
 
   const std::vector<ServiceData> &get_service_datas() const { return service_datas_; }
 
+  const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &get_scan_result() const { return scan_result_; }
+
   optional<ESPBLEiBeacon> get_ibeacon() const {
     for (auto &it : this->manufacturer_datas_) {
       auto res = ESPBLEiBeacon::from_manufacturer_data(it);
@@ -121,6 +123,7 @@ class ESPBTDevice {
   std::vector<ESPBTUUID> service_uuids_;
   std::vector<ServiceData> manufacturer_datas_{};
   std::vector<ServiceData> service_datas_{};
+  esp_ble_gap_cb_param_t::ble_scan_result_evt_param scan_result_{};
 };
 
 class ESP32BLETracker;

esphome/components/esp32_camera/__init__.py

@@ -57,6 +57,9 @@ CONF_IDLE_FRAMERATE = "idle_framerate"
 CONF_JPEG_QUALITY = "jpeg_quality"
 CONF_VERTICAL_FLIP = "vertical_flip"
 CONF_HORIZONTAL_MIRROR = "horizontal_mirror"
+CONF_AEC2 = "aec2"
+CONF_AE_LEVEL = "ae_level"
+CONF_AEC_VALUE = "aec_value"
 CONF_SATURATION = "saturation"
 CONF_TEST_PATTERN = "test_pattern"
 
@@ -102,6 +105,9 @@ CONFIG_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
         cv.Optional(CONF_SATURATION, default=0): camera_range_param,
         cv.Optional(CONF_VERTICAL_FLIP, default=True): cv.boolean,
         cv.Optional(CONF_HORIZONTAL_MIRROR, default=True): cv.boolean,
+        cv.Optional(CONF_AEC2, default=False): cv.boolean,
+        cv.Optional(CONF_AE_LEVEL, default=0): camera_range_param,
+        cv.Optional(CONF_AEC_VALUE, default=300): cv.int_range(min=0, max=1200),
         cv.Optional(CONF_TEST_PATTERN, default=False): cv.boolean,
     }
 ).extend(cv.COMPONENT_SCHEMA)
@@ -116,6 +122,9 @@ SETTERS = {
     CONF_JPEG_QUALITY: "set_jpeg_quality",
     CONF_VERTICAL_FLIP: "set_vertical_flip",
     CONF_HORIZONTAL_MIRROR: "set_horizontal_mirror",
+    CONF_AEC2: "set_aec2",
+    CONF_AE_LEVEL: "set_ae_level",
+    CONF_AEC_VALUE: "set_aec_value",
     CONF_CONTRAST: "set_contrast",
     CONF_BRIGHTNESS: "set_brightness",
     CONF_SATURATION: "set_saturation",

esphome/components/esp32_camera/esp32_camera.cpp

@@ -26,6 +26,9 @@ void ESP32Camera::setup() {
   sensor_t *s = esp_camera_sensor_get();
   s->set_vflip(s, this->vertical_flip_);
   s->set_hmirror(s, this->horizontal_mirror_);
+  s->set_aec2(s, this->aec2_);            // 0 = disable , 1 = enable
+  s->set_ae_level(s, this->ae_level_);    // -2 to 2
+  s->set_aec_value(s, this->aec_value_);  // 0 to 1200
   s->set_contrast(s, this->contrast_);
   s->set_brightness(s, this->brightness_);
   s->set_saturation(s, this->saturation_);
@@ -111,9 +114,9 @@ void ESP32Camera::dump_config() {
   // ESP_LOGCONFIG(TAG, "  Auto White Balance: %u", st.awb);
   // ESP_LOGCONFIG(TAG, "  Auto White Balance Gain: %u", st.awb_gain);
   // ESP_LOGCONFIG(TAG, "  Auto Exposure Control: %u", st.aec);
-  // ESP_LOGCONFIG(TAG, "  Auto Exposure Control 2: %u", st.aec2);
-  // ESP_LOGCONFIG(TAG, "  Auto Exposure Level: %d", st.ae_level);
-  // ESP_LOGCONFIG(TAG, "  Auto Exposure Value: %u", st.aec_value);
+  ESP_LOGCONFIG(TAG, "  Auto Exposure Control 2: %u", st.aec2);
+  ESP_LOGCONFIG(TAG, "  Auto Exposure Level: %d", st.ae_level);
+  ESP_LOGCONFIG(TAG, "  Auto Exposure Value: %u", st.aec_value);
   // ESP_LOGCONFIG(TAG, "  AGC: %u", st.agc);
   // ESP_LOGCONFIG(TAG, "  AGC Gain: %u", st.agc_gain);
   // ESP_LOGCONFIG(TAG, "  Gain Ceiling: %u", st.gainceiling);
@@ -250,6 +253,9 @@ void ESP32Camera::add_image_callback(std::function<void(std::shared_ptr<CameraIm
 }
 void ESP32Camera::set_vertical_flip(bool vertical_flip) { this->vertical_flip_ = vertical_flip; }
 void ESP32Camera::set_horizontal_mirror(bool horizontal_mirror) { this->horizontal_mirror_ = horizontal_mirror; }
+void ESP32Camera::set_aec2(bool aec2) { this->aec2_ = aec2; }
+void ESP32Camera::set_ae_level(int ae_level) { this->ae_level_ = ae_level; }
+void ESP32Camera::set_aec_value(uint32_t aec_value) { this->aec_value_ = aec_value; }
 void ESP32Camera::set_contrast(int contrast) { this->contrast_ = contrast; }
 void ESP32Camera::set_brightness(int brightness) { this->brightness_ = brightness; }
 void ESP32Camera::set_saturation(int saturation) { this->saturation_ = saturation; }

esphome/components/esp32_camera/esp32_camera.h

@@ -67,6 +67,9 @@ class ESP32Camera : public Component, public EntityBase {
   void set_power_down_pin(uint8_t pin);
   void set_vertical_flip(bool vertical_flip);
   void set_horizontal_mirror(bool horizontal_mirror);
+  void set_aec2(bool aec2);
+  void set_ae_level(int ae_level);
+  void set_aec_value(uint32_t aec_value);
   void set_contrast(int contrast);
   void set_brightness(int brightness);
   void set_saturation(int saturation);
@@ -91,6 +94,9 @@ class ESP32Camera : public Component, public EntityBase {
   camera_config_t config_{};
   bool vertical_flip_{true};
   bool horizontal_mirror_{true};
+  bool aec2_{false};
+  int ae_level_{0};
+  uint32_t aec_value_{300};
   int contrast_{0};
   int brightness_{0};
   int saturation_{0};

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -219,7 +219,7 @@ void ESP32ImprovComponent::dump_config() {
 void ESP32ImprovComponent::process_incoming_data_() {
   uint8_t length = this->incoming_data_[1];
 
-  ESP_LOGD(TAG, "Processing bytes - %s", hexencode(this->incoming_data_).c_str());
+  ESP_LOGD(TAG, "Processing bytes - %s", format_hex_pretty(this->incoming_data_).c_str());
   if (this->incoming_data_.size() - 3 == length) {
     this->set_error_(improv::ERROR_NONE);
     improv::ImprovCommand command = improv::parse_improv_data(this->incoming_data_);

esphome/components/esp8266/core.cpp

@@ -20,6 +20,7 @@ void arch_restart() {
     yield();
   }
 }
+void arch_init() {}
 void IRAM_ATTR HOT arch_feed_wdt() {
   ESP.wdtFeed();  // NOLINT(readability-static-accessed-through-instance)
 }
@@ -27,7 +28,7 @@ void IRAM_ATTR HOT arch_feed_wdt() {
 uint8_t progmem_read_byte(const uint8_t *addr) {
   return pgm_read_byte(addr);  // NOLINT
 }
-uint32_t arch_get_cpu_cycle_count() {
+uint32_t IRAM_ATTR HOT arch_get_cpu_cycle_count() {
   return ESP.getCycleCount();  // NOLINT(readability-static-accessed-through-instance)
 }
 uint32_t arch_get_cpu_freq_hz() { return F_CPU; }

esphome/components/esp8266/gpio.cpp

@@ -9,7 +9,7 @@ namespace esp8266 {
 static const char *const TAG = "esp8266";
 
 static int IRAM_ATTR flags_to_mode(gpio::Flags flags, uint8_t pin) {
-  if (flags == gpio::FLAG_INPUT) {
+  if (flags == gpio::FLAG_INPUT) {  // NOLINT(bugprone-branch-clone)
     return INPUT;
   } else if (flags == gpio::FLAG_OUTPUT) {
     return OUTPUT;

esphome/components/esp8266/preferences.cpp

@@ -55,7 +55,7 @@ static inline bool esp_rtc_user_mem_write(uint32_t index, uint32_t value) {
 
 extern "C" uint32_t _SPIFFS_end;  // NOLINT
 
-static const uint32_t get_esp8266_flash_sector() {
+static uint32_t get_esp8266_flash_sector() {
   union {
     uint32_t *ptr;
     uint32_t uint;
@@ -63,7 +63,7 @@ static const uint32_t get_esp8266_flash_sector() {
   data.ptr = &_SPIFFS_end;
   return (data.uint - 0x40200000) / SPI_FLASH_SEC_SIZE;
 }
-static const uint32_t get_esp8266_flash_address() { return get_esp8266_flash_sector() * SPI_FLASH_SEC_SIZE; }
+static uint32_t get_esp8266_flash_address() { return get_esp8266_flash_sector() * SPI_FLASH_SEC_SIZE; }
 
 template<class It> uint32_t calculate_crc(It first, It last, uint32_t type) {
   uint32_t crc = type;

esphome/components/ethernet/ethernet_component.cpp

@@ -184,7 +184,9 @@ void EthernetComponent::start_connect_() {
   }
 
   err = tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_ETH);
-  ESPHL_ERROR_CHECK(err, "DHCPC stop error");
+  if (err != ESP_ERR_TCPIP_ADAPTER_DHCP_ALREADY_STOPPED) {
+    ESPHL_ERROR_CHECK(err, "DHCPC stop error");
+  }
   err = tcpip_adapter_set_ip_info(TCPIP_ADAPTER_IF_ETH, &info);
   ESPHL_ERROR_CHECK(err, "DHCPC set IP info error");
 

esphome/components/external_components/__init__.py

@@ -12,6 +12,8 @@ from esphome.const import (
     CONF_TYPE,
     CONF_EXTERNAL_COMPONENTS,
     CONF_PATH,
+    CONF_USERNAME,
+    CONF_PASSWORD,
 )
 from esphome.core import CORE
 from esphome import git, loader
@@ -27,6 +29,8 @@ TYPE_LOCAL = "local"
 GIT_SCHEMA = {
     cv.Required(CONF_URL): cv.url,
     cv.Optional(CONF_REF): cv.git_ref,
+    cv.Optional(CONF_USERNAME): cv.string,
+    cv.Optional(CONF_PASSWORD): cv.string,
 }
 LOCAL_SCHEMA = {
     cv.Required(CONF_PATH): cv.directory,
@@ -99,6 +103,8 @@ def _process_git_config(config: dict, refresh) -> str:
         ref=config.get(CONF_REF),
         refresh=refresh,
         domain=DOMAIN,
+        username=config.get(CONF_USERNAME),
+        password=config.get(CONF_PASSWORD),
     )
 
     if (repo_dir / "esphome" / "components").is_dir():

esphome/components/ezo/ezo.cpp

@@ -32,7 +32,7 @@ void EZOSensor::update() {
 }
 
 void EZOSensor::loop() {
-  uint8_t buf[20];
+  uint8_t buf[21];
   if (!(this->state_ & EZO_STATE_WAIT)) {
     if (this->state_ & EZO_STATE_SEND_TEMP) {
       int len = sprintf((char *) buf, "T,%0.3f", this->tempcomp_);
@@ -74,7 +74,12 @@ void EZOSensor::loop() {
   if (buf[0] != 1)
     return;
 
-  float val = parse_number<float>((char *) &buf[1], sizeof(buf) - 1).value_or(0);
+  // some sensors return multiple comma-separated values, terminate string after first one
+  for (size_t i = 1; i < sizeof(buf) - 1; i++)
+    if (buf[i] == ',')
+      buf[i] = '\0';
+
+  float val = parse_number<float>((char *) &buf[1]).value_or(0);
   this->publish_state(val);
 }
 

esphome/components/graph/graph.cpp

@@ -86,7 +86,7 @@ void Graph::draw(DisplayBuffer *buff, uint16_t x_offset, uint16_t y_offset, Colo
     // Look back in trace data to best-fit into local range
     float mx = NAN;
     float mn = NAN;
-    for (int16_t i = 0; i < this->width_; i++) {
+    for (uint32_t i = 0; i < this->width_; i++) {
       for (auto *trace : traces_) {
         float v = trace->get_tracedata()->get_value(i);
         if (!std::isnan(v)) {
@@ -132,7 +132,7 @@ void Graph::draw(DisplayBuffer *buff, uint16_t x_offset, uint16_t y_offset, Colo
   if (!std::isnan(this->gridspacing_y_)) {
     for (int y = yn; y <= ym; y++) {
       int16_t py = (int16_t) roundf((this->height_ - 1) * (1.0 - (float) (y - yn) / (ym - yn)));
-      for (int x = 0; x < this->width_; x += 2) {
+      for (uint32_t x = 0; x < this->width_; x += 2) {
         buff->draw_pixel_at(x_offset + x, y_offset + py, color);
       }
     }
@@ -147,7 +147,7 @@ void Graph::draw(DisplayBuffer *buff, uint16_t x_offset, uint16_t y_offset, Colo
       ESP_LOGW(TAG, "Graphing reducing x-scale to prevent too many gridlines");
     }
     for (int i = 0; i <= n; i++) {
-      for (int y = 0; y < this->height_; y += 2) {
+      for (uint32_t y = 0; y < this->height_; y += 2) {
         buff->draw_pixel_at(x_offset + i * (this->width_ - 1) / n, y_offset + y, color);
       }
     }
@@ -158,14 +158,14 @@ void Graph::draw(DisplayBuffer *buff, uint16_t x_offset, uint16_t y_offset, Colo
   for (auto *trace : traces_) {
     Color c = trace->get_line_color();
     uint16_t thick = trace->get_line_thickness();
-    for (int16_t i = 0; i < this->width_; i++) {
+    for (uint32_t i = 0; i < this->width_; i++) {
       float v = (trace->get_tracedata()->get_value(i) - ymin) / yrange;
       if (!std::isnan(v) && (thick > 0)) {
         int16_t x = this->width_ - 1 - i;
         uint8_t b = (i % (thick * LineType::PATTERN_LENGTH)) / thick;
         if (((uint8_t) trace->get_line_type() & (1 << b)) == (1 << b)) {
           int16_t y = (int16_t) roundf((this->height_ - 1) * (1.0 - v)) - thick / 2;
-          for (int16_t t = 0; t < thick; t++) {
+          for (uint16_t t = 0; t < thick; t++) {
             buff->draw_pixel_at(x_offset + x, y_offset + y + t, c);
           }
         }
@@ -179,8 +179,8 @@ void GraphLegend::init(Graph *g) {
   parent_ = g;
 
   // Determine maximum expected text and value width / height
-  int txtw = 0, txtos = 0, txtbl = 0, txth = 0;
-  int valw = 0, valos = 0, valbl = 0, valh = 0;
+  int txtw = 0, txth = 0;
+  int valw = 0, valh = 0;
   int lt = 0;
   for (auto *trace : g->traces_) {
     std::string txtstr = trace->get_name();
@@ -320,7 +320,7 @@ void Graph::draw_legend(display::DisplayBuffer *buff, uint16_t x_offset, uint16_
 
     if (legend_->lines_) {
       uint16_t thick = trace->get_line_thickness();
-      for (int16_t i = 0; i < legend_->x0_ * 4 / 3; i++) {
+      for (int i = 0; i < legend_->x0_ * 4 / 3; i++) {
         uint8_t b = (i % (thick * LineType::PATTERN_LENGTH)) / thick;
         if (((uint8_t) trace->get_line_type() & (1 << b)) == (1 << b)) {
           buff->vertical_line(x - legend_->x0_ * 2 / 3 + i, y + legend_->yl_ - thick / 2, thick,

esphome/components/hitachi_ac344/hitachi_ac344.cpp

@@ -299,9 +299,7 @@ bool HitachiClimate::parse_swing_(const uint8_t remote_state[]) {
       GETBITS8(remote_state[HITACHI_AC344_SWINGH_BYTE], HITACHI_AC344_SWINGH_OFFSET, HITACHI_AC344_SWINGH_SIZE);
   ESP_LOGV(TAG, "SwingH: %02X %02X", remote_state[HITACHI_AC344_SWINGH_BYTE], swing_modeh);
 
-  if ((swing_modeh & 0x7) == 0x0) {
-    this->swing_mode = climate::CLIMATE_SWING_HORIZONTAL;
-  } else if ((swing_modeh & 0x3) == 0x3) {
+  if ((swing_modeh & 0x3) == 0x3) {
     this->swing_mode = climate::CLIMATE_SWING_OFF;
   } else {
     this->swing_mode = climate::CLIMATE_SWING_HORIZONTAL;

esphome/components/hitachi_ac424/hitachi_ac424.cpp

@@ -300,9 +300,7 @@ bool HitachiClimate::parse_swing_(const uint8_t remote_state[]) {
                                                HITACHI_AC424_SWINGH_SIZE);
   ESP_LOGV(TAG, "SwingH: %02X %02X", remote_state[HITACHI_AC424_SWINGH_BYTE], swing_modeh);
 
-  if ((swing_modeh & 0x7) == 0x0) {
-    this->swing_mode = climate::CLIMATE_SWING_HORIZONTAL;
-  } else if ((swing_modeh & 0x3) == 0x3) {
+  if ((swing_modeh & 0x3) == 0x3) {
     this->swing_mode = climate::CLIMATE_SWING_OFF;
   } else {
     this->swing_mode = climate::CLIMATE_SWING_HORIZONTAL;

esphome/components/i2c/i2c_bus.h

@@ -1,6 +1,8 @@
 #pragma once
 #include <cstdint>
 #include <cstddef>
+#include <utility>
+#include <vector>
 
 namespace esphome {
 namespace i2c {
@@ -40,6 +42,20 @@ class I2CBus {
     return writev(address, &buf, 1);
   }
   virtual ErrorCode writev(uint8_t address, WriteBuffer *buffers, size_t cnt) = 0;
+
+ protected:
+  void i2c_scan_() {
+    for (uint8_t address = 8; address < 120; address++) {
+      auto err = writev(address, nullptr, 0);
+      if (err == ERROR_OK) {
+        scan_results_.emplace_back(address, true);
+      } else if (err == ERROR_UNKNOWN) {
+        scan_results_.emplace_back(address, false);
+      }
+    }
+  }
+  std::vector<std::pair<uint8_t, bool>> scan_results_;
+  bool scan_{false};
 };
 
 }  // namespace i2c

esphome/components/i2c/i2c_bus_arduino.cpp

@@ -2,6 +2,7 @@
 
 #include "i2c_bus_arduino.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 #include <Arduino.h>
 #include <cstring>
 
@@ -27,6 +28,10 @@ void ArduinoI2CBus::setup() {
   wire_->begin(sda_pin_, scl_pin_);
   wire_->setClock(frequency_);
   initialized_ = true;
+  if (this->scan_) {
+    ESP_LOGV(TAG, "Scanning i2c bus for active devices...");
+    this->i2c_scan_();
+  }
 }
 void ArduinoI2CBus::dump_config() {
   ESP_LOGCONFIG(TAG, "I2C Bus:");
@@ -45,22 +50,20 @@ void ArduinoI2CBus::dump_config() {
       break;
   }
   if (this->scan_) {
-    ESP_LOGI(TAG, "Scanning i2c bus for active devices...");
-    uint8_t found = 0;
-    for (uint8_t address = 8; address < 120; address++) {
-      auto err = writev(address, nullptr, 0);
-      if (err == ERROR_OK) {
-        ESP_LOGI(TAG, "Found i2c device at address 0x%02X", address);
-        found++;
-      } else if (err == ERROR_UNKNOWN) {
-        ESP_LOGI(TAG, "Unknown error at address 0x%02X", address);
-      }
-    }
-    if (found == 0) {
+    ESP_LOGI(TAG, "Results from i2c bus scan:");
+    if (scan_results_.empty()) {
       ESP_LOGI(TAG, "Found no i2c devices!");
+    } else {
+      for (const auto &s : scan_results_) {
+        if (s.second)
+          ESP_LOGI(TAG, "Found i2c device at address 0x%02X", s.first);
+        else
+          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
+      }
     }
   }
 }
+
 ErrorCode ArduinoI2CBus::readv(uint8_t address, ReadBuffer *buffers, size_t cnt) {
   // logging is only enabled with vv level, if warnings are shown the caller
   // should log them

esphome/components/i2c/i2c_bus_arduino.h

@@ -34,7 +34,6 @@ class ArduinoI2CBus : public I2CBus, public Component {
 
  protected:
   TwoWire *wire_;
-  bool scan_;
   uint8_t sda_pin_;
   uint8_t scl_pin_;
   uint32_t frequency_;

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -3,6 +3,7 @@
 #include "i2c_bus_esp_idf.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 #include <cstring>
 
 namespace esphome {
@@ -37,6 +38,10 @@ void IDFI2CBus::setup() {
     return;
   }
   initialized_ = true;
+  if (this->scan_) {
+    ESP_LOGV(TAG, "Scanning i2c bus for active devices...");
+    this->i2c_scan_();
+  }
 }
 void IDFI2CBus::dump_config() {
   ESP_LOGCONFIG(TAG, "I2C Bus:");
@@ -55,23 +60,20 @@ void IDFI2CBus::dump_config() {
       break;
   }
   if (this->scan_) {
-    ESP_LOGI(TAG, "Scanning i2c bus for active devices...");
-    uint8_t found = 0;
-    for (uint8_t address = 8; address < 120; address++) {
-      auto err = writev(address, nullptr, 0);
-
-      if (err == ERROR_OK) {
-        ESP_LOGI(TAG, "Found i2c device at address 0x%02X", address);
-        found++;
-      } else if (err == ERROR_UNKNOWN) {
-        ESP_LOGI(TAG, "Unknown error at address 0x%02X", address);
-      }
-    }
-    if (found == 0) {
+    ESP_LOGI(TAG, "Results from i2c bus scan:");
+    if (scan_results_.empty()) {
       ESP_LOGI(TAG, "Found no i2c devices!");
+    } else {
+      for (const auto &s : scan_results_) {
+        if (s.second)
+          ESP_LOGI(TAG, "Found i2c device at address 0x%02X", s.first);
+        else
+          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
+      }
     }
   }
 }
+
 ErrorCode IDFI2CBus::readv(uint8_t address, ReadBuffer *buffers, size_t cnt) {
   // logging is only enabled with vv level, if warnings are shown the caller
   // should log them

esphome/components/i2c/i2c_bus_esp_idf.h

@@ -36,7 +36,6 @@ class IDFI2CBus : public I2CBus, public Component {
 
  protected:
   i2c_port_t port_;
-  bool scan_;
   uint8_t sda_pin_;
   bool sda_pullup_enabled_;
   uint8_t scl_pin_;

esphome/components/ili9341/ili9341_display.cpp

@@ -86,8 +86,8 @@ void ILI9341Display::update() {
 
 void ILI9341Display::display_() {
   // we will only update the changed window to the display
-  int w = this->x_high_ - this->x_low_ + 1;
-  int h = this->y_high_ - this->y_low_ + 1;
+  uint16_t w = this->x_high_ - this->x_low_ + 1;
+  uint16_t h = this->y_high_ - this->y_low_ + 1;
 
   set_addr_window_(this->x_low_, this->y_low_, w, h);
   this->start_data_();

esphome/components/improv_serial/improv_serial_component.cpp

@@ -145,7 +145,7 @@ bool ImprovSerialComponent::parse_improv_serial_byte_(uint8_t byte) {
 
   if (at == 8 + data_len + 1) {
     uint8_t checksum = 0x00;
-    for (uint8_t i = 0; i < at; i++)
+    for (size_t i = 0; i < at; i++)
       checksum += raw[i];
 
     if (checksum != byte) {

esphome/components/lcd_gpio/gpio_lcd_display.cpp

@@ -17,7 +17,7 @@ void GPIOLCDDisplay::setup() {
   this->enable_pin_->setup();  // OUTPUT
   this->enable_pin_->digital_write(false);
 
-  for (uint8_t i = 0; i < (this->is_four_bit_mode() ? 4 : 8); i++) {
+  for (uint8_t i = 0; i < (uint8_t)(this->is_four_bit_mode() ? 4u : 8u); i++) {
     this->data_pins_[i]->setup();  // OUTPUT
     this->data_pins_[i]->digital_write(false);
   }

esphome/components/light/__init__.py

@@ -14,6 +14,7 @@ from esphome.const import (
     CONF_RESTORE_MODE,
     CONF_ON_TURN_OFF,
     CONF_ON_TURN_ON,
+    CONF_ON_STATE,
     CONF_TRIGGER_ID,
     CONF_COLD_WHITE_COLOR_TEMPERATURE,
     CONF_WARM_WHITE_COLOR_TEMPERATURE,
@@ -37,6 +38,7 @@ from .types import (  # noqa
     AddressableLight,
     LightTurnOnTrigger,
     LightTurnOffTrigger,
+    LightStateTrigger,
 )
 
 CODEOWNERS = ["@esphome/core"]
@@ -69,6 +71,11 @@ LIGHT_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).ex
                 cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(LightTurnOffTrigger),
             }
         ),
+        cv.Optional(CONF_ON_STATE): auto.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(LightStateTrigger),
+            }
+        ),
     }
 )
 
@@ -151,6 +158,9 @@ async def setup_light_core_(light_var, output_var, config):
     for conf in config.get(CONF_ON_TURN_OFF, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], light_var)
         await auto.build_automation(trigger, [], conf)
+    for conf in config.get(CONF_ON_STATE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], light_var)
+        await auto.build_automation(trigger, [], conf)
 
     if CONF_COLOR_CORRECT in config:
         cg.add(output_var.set_correction(*config[CONF_COLOR_CORRECT]))

esphome/components/light/addressable_light_effect.h

@@ -167,7 +167,7 @@ class AddressableScanEffect : public AddressableLightEffect {
     this->last_move_ = now;
 
     it.all() = Color::BLACK;
-    for (auto i = 0; i < this->scan_width_; i++) {
+    for (uint32_t i = 0; i < this->scan_width_; i++) {
       it[this->at_led_ + i] = current_color;
     }
 
@@ -178,7 +178,7 @@ class AddressableScanEffect : public AddressableLightEffect {
   uint32_t move_interval_{};
   uint32_t scan_width_{1};
   uint32_t last_move_{0};
-  int at_led_{0};
+  uint32_t at_led_{0};
   bool direction_{true};
 };
 

esphome/components/light/automation.h

@@ -141,6 +141,13 @@ class LightTurnOffTrigger : public Trigger<> {
   }
 };
 
+class LightStateTrigger : public Trigger<> {
+ public:
+  LightStateTrigger(LightState *a_light) {
+    a_light->add_new_remote_values_callback([this]() { this->trigger(); });
+  }
+};
+
 // This is slightly ugly, but we can't log in headers, and can't make this a static method on AddressableSet
 // due to the template. It's just a temporary warning anyway.
 void addressableset_warn_about_scale(const char *field);

esphome/components/light/light_call.cpp

@@ -98,7 +98,7 @@ void LightCall::perform() {
     // EFFECT
     auto effect = this->effect_;
     const char *effect_s;
-    if (effect == 0)
+    if (effect == 0u)
       effect_s = "None";
     else
       effect_s = this->parent_->effects_[*this->effect_ - 1]->get_name().c_str();

esphome/components/light/types.py

@@ -41,6 +41,7 @@ LightTurnOnTrigger = light_ns.class_(
 LightTurnOffTrigger = light_ns.class_(
     "LightTurnOffTrigger", automation.Trigger.template()
 )
+LightStateTrigger = light_ns.class_("LightStateTrigger", automation.Trigger.template())
 
 # Effects
 LightEffect = light_ns.class_("LightEffect")

esphome/components/ltr390/ltr390.cpp

@@ -97,7 +97,7 @@ void LTR390Component::read_mode_(int mode_index) {
 
     // If there are more modes to read then begin the next
     // otherwise stop
-    if (mode_index + 1 < this->mode_funcs_.size()) {
+    if (mode_index + 1 < (int) this->mode_funcs_.size()) {
       this->read_mode_(mode_index + 1);
     } else {
       this->reading_ = false;

esphome/components/max31865/max31865.cpp

@@ -203,16 +203,16 @@ float MAX31865Sensor::calc_temperature_(float rtd_ratio) {
     rtd_resistance *= 100;
   }
   float rpoly = rtd_resistance;
-  float neg_temp = -242.02;
-  neg_temp += 2.2228 * rpoly;
+  float neg_temp = -242.02f;
+  neg_temp += 2.2228f * rpoly;
   rpoly *= rtd_resistance;  // square
-  neg_temp += 2.5859e-3 * rpoly;
+  neg_temp += 2.5859e-3f * rpoly;
   rpoly *= rtd_resistance;  // ^3
-  neg_temp -= 4.8260e-6 * rpoly;
+  neg_temp -= 4.8260e-6f * rpoly;
   rpoly *= rtd_resistance;  // ^4
-  neg_temp -= 2.8183e-8 * rpoly;
+  neg_temp -= 2.8183e-8f * rpoly;
   rpoly *= rtd_resistance;  // ^5
-  neg_temp += 1.5243e-10 * rpoly;
+  neg_temp += 1.5243e-10f * rpoly;
   return neg_temp;
 }
 

esphome/components/max7219digit/max7219digit.cpp

@@ -76,7 +76,7 @@ void MAX7219Component::loop() {
     this->stepsleft_ = 0;
 
   // Return if there is no need to scroll or scroll is off
-  if (!this->scroll_ || (this->max_displaybuffer_[0].size() <= get_width_internal())) {
+  if (!this->scroll_ || (this->max_displaybuffer_[0].size() <= (size_t) get_width_internal())) {
     this->display();
     return;
   }
@@ -88,7 +88,7 @@ void MAX7219Component::loop() {
 
   // Dwell time at end of string in case of stop at end
   if (this->scroll_mode_ == ScrollMode::STOP) {
-    if (this->stepsleft_ >= this->max_displaybuffer_[0].size() - get_width_internal() + 1) {
+    if (this->stepsleft_ >= this->max_displaybuffer_[0].size() - (size_t) get_width_internal() + 1) {
       if (now - this->last_scroll_ >= this->scroll_dwell_) {
         this->stepsleft_ = 0;
         this->last_scroll_ = now;
@@ -155,7 +155,7 @@ int MAX7219Component::get_height_internal() {
 int MAX7219Component::get_width_internal() { return this->num_chips_ / this->num_chip_lines_ * 8; }
 
 void HOT MAX7219Component::draw_absolute_pixel_internal(int x, int y, Color color) {
-  if (x + 1 > this->max_displaybuffer_[0].size()) {  // Extend the display buffer in case required
+  if (x + 1 > (int) this->max_displaybuffer_[0].size()) {  // Extend the display buffer in case required
     for (int chip_line = 0; chip_line < this->num_chip_lines_; chip_line++) {
       this->max_displaybuffer_[chip_line].resize(x + 1, this->bckgrnd_);
     }

esphome/components/mcp23s08/mcp23s08.cpp

@@ -35,7 +35,6 @@ void MCP23S08::dump_config() {
 }
 
 bool MCP23S08::read_reg(uint8_t reg, uint8_t *value) {
-  uint8_t data;
   this->enable();
   this->transfer_byte(this->device_opcode_ | 1);
   this->transfer_byte(reg);

esphome/components/mcp23x17_base/mcp23x17_base.cpp

@@ -24,6 +24,7 @@ void MCP23X17Base::pin_mode(uint8_t pin, gpio::Flags flags) {
   uint8_t gppu = pin < 8 ? mcp23x17_base::MCP23X17_GPPUA : mcp23x17_base::MCP23X17_GPPUB;
   if (flags == gpio::FLAG_INPUT) {
     this->update_reg(pin, true, iodir);
+    this->update_reg(pin, false, gppu);
   } else if (flags == (gpio::FLAG_INPUT | gpio::FLAG_PULLUP)) {
     this->update_reg(pin, true, iodir);
     this->update_reg(pin, true, gppu);

esphome/components/mcp2515/mcp2515.cpp

@@ -127,9 +127,6 @@ canbus::Error MCP2515::set_mode_(const CanctrlReqopMode mode) {
 }
 
 canbus::Error MCP2515::set_clk_out_(const CanClkOut divisor) {
-  canbus::Error res;
-  uint8_t cfg3;
-
   if (divisor == CLKOUT_DISABLE) {
     /* Turn off CLKEN */
     modify_register_(MCP_CANCTRL, CANCTRL_CLKEN, 0x00);

esphome/components/md5/md5.cpp

@@ -23,7 +23,7 @@ void MD5Digest::get_hex(char *output) {
   }
 }
 
-bool MD5Digest::equals_bytes(const char *expected) {
+bool MD5Digest::equals_bytes(const uint8_t *expected) {
   for (size_t i = 0; i < 16; i++) {
     if (expected[i] != this->digest_[i]) {
       return false;
@@ -33,18 +33,10 @@ bool MD5Digest::equals_bytes(const char *expected) {
 }
 
 bool MD5Digest::equals_hex(const char *expected) {
-  for (size_t i = 0; i < 16; i++) {
-    auto high = parse_hex(expected[i * 2]);
-    auto low = parse_hex(expected[i * 2 + 1]);
-    if (!high.has_value() || !low.has_value()) {
-      return false;
-    }
-    auto value = (*high << 4) | *low;
-    if (value != this->digest_[i]) {
-      return false;
-    }
-  }
-  return true;
+  uint8_t parsed[16];
+  if (!parse_hex(expected, parsed, 16))
+    return false;
+  return equals_bytes(parsed);
 }
 
 }  // namespace md5

esphome/components/md5/md5.h

@@ -44,7 +44,7 @@ class MD5Digest {
   void get_hex(char *output);
 
   /// Compare the digest against a provided byte-encoded digest (16 bytes).
-  bool equals_bytes(const char *expected);
+  bool equals_bytes(const uint8_t *expected);
 
   /// Compare the digest against a provided hex-encoded digest (32 bytes).
   bool equals_hex(const char *expected);

esphome/components/modbus/modbus.cpp

@@ -181,7 +181,7 @@ void Modbus::send(uint8_t address, uint8_t function_code, uint16_t start_address
     this->flow_control_pin_->digital_write(false);
   waiting_for_response = address;
   last_send_ = millis();
-  ESP_LOGV(TAG, "Modbus write: %s", hexencode(data).c_str());
+  ESP_LOGV(TAG, "Modbus write: %s", format_hex_pretty(data).c_str());
 }
 
 // Helper function for lambdas
@@ -202,7 +202,7 @@ void Modbus::send_raw(const std::vector<uint8_t> &payload) {
   if (this->flow_control_pin_ != nullptr)
     this->flow_control_pin_->digital_write(false);
   waiting_for_response = payload[0];
-  ESP_LOGV(TAG, "Modbus write raw: %s", hexencode(payload).c_str());
+  ESP_LOGV(TAG, "Modbus write raw: %s", format_hex_pretty(payload).c_str());
   last_send_ = millis();
 }
 

esphome/components/modbus_controller/__init__.py

@@ -1,10 +1,21 @@
+import binascii
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import modbus
-from esphome.const import CONF_ID, CONF_ADDRESS
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_LAMBDA, CONF_OFFSET
 from esphome.cpp_helpers import logging
 from .const import (
+    CONF_BITMASK,
+    CONF_BYTE_OFFSET,
     CONF_COMMAND_THROTTLE,
+    CONF_CUSTOM_COMMAND,
+    CONF_FORCE_NEW_RANGE,
+    CONF_MODBUS_CONTROLLER_ID,
+    CONF_REGISTER_COUNT,
+    CONF_REGISTER_TYPE,
+    CONF_RESPONSE_SIZE,
+    CONF_SKIP_UPDATES,
+    CONF_VALUE_TYPE,
 )
 
 CODEOWNERS = ["@martgras"]
@@ -37,6 +48,7 @@ MODBUS_FUNCTION_CODE = {
 ModbusRegisterType_ns = modbus_controller_ns.namespace("ModbusRegisterType")
 ModbusRegisterType = ModbusRegisterType_ns.enum("ModbusRegisterType")
 MODBUS_REGISTER_TYPE = {
+    "custom": ModbusRegisterType.CUSTOM,
     "coil": ModbusRegisterType.COIL,
     "discrete_input": ModbusRegisterType.DISCRETE_INPUT,
     "holding": ModbusRegisterType.HOLDING,
@@ -95,6 +107,100 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
+ModbusItemBaseSchema = cv.Schema(
+    {
+        cv.GenerateID(CONF_MODBUS_CONTROLLER_ID): cv.use_id(ModbusController),
+        cv.Optional(CONF_ADDRESS): cv.positive_int,
+        cv.Optional(CONF_CUSTOM_COMMAND): cv.ensure_list(cv.hex_uint8_t),
+        cv.Exclusive(
+            CONF_OFFSET,
+            "offset",
+            f"{CONF_OFFSET} and {CONF_BYTE_OFFSET} can't be used together",
+        ): cv.positive_int,
+        cv.Exclusive(
+            CONF_BYTE_OFFSET,
+            "offset",
+            f"{CONF_OFFSET} and {CONF_BYTE_OFFSET} can't be used together",
+        ): cv.positive_int,
+        cv.Optional(CONF_BITMASK, default=0xFFFFFFFF): cv.hex_uint32_t,
+        cv.Optional(CONF_SKIP_UPDATES, default=0): cv.positive_int,
+        cv.Optional(CONF_FORCE_NEW_RANGE, default=False): cv.boolean,
+        cv.Optional(CONF_LAMBDA): cv.returning_lambda,
+        cv.Optional(CONF_RESPONSE_SIZE, default=0): cv.positive_int,
+    },
+)
+
+
+def validate_modbus_register(config):
+    if CONF_CUSTOM_COMMAND not in config and CONF_ADDRESS not in config:
+        raise cv.Invalid(
+            f" {CONF_ADDRESS} is a required property if '{CONF_CUSTOM_COMMAND}:' isn't used"
+        )
+    if CONF_CUSTOM_COMMAND in config and CONF_REGISTER_TYPE in config:
+        raise cv.Invalid(
+            f"can't use '{CONF_REGISTER_TYPE}:' together with '{CONF_CUSTOM_COMMAND}:'",
+        )
+
+    if CONF_CUSTOM_COMMAND not in config and CONF_REGISTER_TYPE not in config:
+        raise cv.Invalid(
+            f" {CONF_REGISTER_TYPE} is a required property if '{CONF_CUSTOM_COMMAND}:' isn't used"
+        )
+    return config
+
+
+def modbus_calc_properties(config):
+    byte_offset = 0
+    reg_count = 0
+    if CONF_OFFSET in config:
+        byte_offset = config[CONF_OFFSET]
+    # A CONF_BYTE_OFFSET setting overrides CONF_OFFSET
+    if CONF_BYTE_OFFSET in config:
+        byte_offset = config[CONF_BYTE_OFFSET]
+    if CONF_REGISTER_COUNT in config:
+        reg_count = config[CONF_REGISTER_COUNT]
+    if CONF_VALUE_TYPE in config:
+        value_type = config[CONF_VALUE_TYPE]
+        if reg_count == 0:
+            reg_count = TYPE_REGISTER_MAP[value_type]
+    if CONF_CUSTOM_COMMAND in config:
+        if CONF_ADDRESS not in config:
+            # generate a unique modbus address using the hash of the name
+            # CONF_NAME set even if only CONF_ID is used.
+            # a modbus register address is required to add the item to sensormap
+            value = config[CONF_NAME]
+            if isinstance(value, str):
+                value = value.encode()
+            config[CONF_ADDRESS] = binascii.crc_hqx(value, 0)
+        config[CONF_REGISTER_TYPE] = ModbusRegisterType.CUSTOM
+        config[CONF_FORCE_NEW_RANGE] = True
+    return byte_offset, reg_count
+
+
+async def add_modbus_base_properties(
+    var, config, sensor_type, lamdba_param_type=cg.float_, lamdba_return_type=float
+):
+    if CONF_CUSTOM_COMMAND in config:
+        cg.add(var.set_custom_data(config[CONF_CUSTOM_COMMAND]))
+
+    if config[CONF_RESPONSE_SIZE] > 0:
+        cg.add(var.set_register_size(config[CONF_RESPONSE_SIZE]))
+
+    if CONF_LAMBDA in config:
+        template_ = await cg.process_lambda(
+            config[CONF_LAMBDA],
+            [
+                (sensor_type.operator("ptr"), "item"),
+                (lamdba_param_type, "x"),
+                (
+                    cg.std_vector.template(cg.uint8).operator("const").operator("ref"),
+                    "data",
+                ),
+            ],
+            return_type=cg.optional.template(lamdba_return_type),
+        )
+        cg.add(var.set_template(template_))
+
+
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID], config[CONF_COMMAND_THROTTLE])
     cg.add(var.set_command_throttle(config[CONF_COMMAND_THROTTLE]))
@@ -119,11 +225,3 @@ def function_code_to_register(function_code):
         "write_multiple_registers": ModbusRegisterType.HOLDING,
     }
     return FUNCTION_CODE_TYPE_MAP[function_code]
-
-
-def find_by_value(dict, find_value):
-    for (key, value) in MODBUS_REGISTER_TYPE.items():
-        print(find_value, value)
-        if find_value == value:
-            return key
-    return "not found"

esphome/components/modbus_controller/binary_sensor/__init__.py

@@ -2,16 +2,18 @@ from esphome.components import binary_sensor
 import esphome.config_validation as cv
 import esphome.codegen as cg
 
-from esphome.const import CONF_ADDRESS, CONF_ID, CONF_LAMBDA, CONF_OFFSET
+from esphome.const import CONF_ADDRESS, CONF_ID
 from .. import (
-    SensorItem,
+    add_modbus_base_properties,
     modbus_controller_ns,
-    ModbusController,
+    modbus_calc_properties,
+    validate_modbus_register,
+    ModbusItemBaseSchema,
+    SensorItem,
     MODBUS_REGISTER_TYPE,
 )
 from ..const import (
     CONF_BITMASK,
-    CONF_BYTE_OFFSET,
     CONF_FORCE_NEW_RANGE,
     CONF_MODBUS_CONTROLLER_ID,
     CONF_REGISTER_TYPE,
@@ -27,30 +29,20 @@ ModbusBinarySensor = modbus_controller_ns.class_(
 )
 
 CONFIG_SCHEMA = cv.All(
-    binary_sensor.BINARY_SENSOR_SCHEMA.extend(
+    binary_sensor.BINARY_SENSOR_SCHEMA.extend(cv.COMPONENT_SCHEMA)
+    .extend(ModbusItemBaseSchema)
+    .extend(
         {
             cv.GenerateID(): cv.declare_id(ModbusBinarySensor),
-            cv.GenerateID(CONF_MODBUS_CONTROLLER_ID): cv.use_id(ModbusController),
-            cv.Required(CONF_ADDRESS): cv.positive_int,
-            cv.Required(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
-            cv.Optional(CONF_OFFSET, default=0): cv.positive_int,
-            cv.Optional(CONF_BYTE_OFFSET): cv.positive_int,
-            cv.Optional(CONF_BITMASK, default=0x1): cv.hex_uint32_t,
-            cv.Optional(CONF_SKIP_UPDATES, default=0): cv.positive_int,
-            cv.Optional(CONF_FORCE_NEW_RANGE, default=False): cv.boolean,
-            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
+            cv.Optional(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
         }
-    ).extend(cv.COMPONENT_SCHEMA),
+    ),
+    validate_modbus_register,
 )
 
 
 async def to_code(config):
-    byte_offset = 0
-    if CONF_OFFSET in config:
-        byte_offset = config[CONF_OFFSET]
-    # A CONF_BYTE_OFFSET setting overrides CONF_OFFSET
-    if CONF_BYTE_OFFSET in config:
-        byte_offset = config[CONF_BYTE_OFFSET]
+    byte_offset, _ = modbus_calc_properties(config)
     var = cg.new_Pvariable(
         config[CONF_ID],
         config[CONF_REGISTER_TYPE],
@@ -65,17 +57,4 @@ async def to_code(config):
 
     paren = await cg.get_variable(config[CONF_MODBUS_CONTROLLER_ID])
     cg.add(paren.add_sensor_item(var))
-    if CONF_LAMBDA in config:
-        template_ = await cg.process_lambda(
-            config[CONF_LAMBDA],
-            [
-                (ModbusBinarySensor.operator("ptr"), "item"),
-                (cg.float_, "x"),
-                (
-                    cg.std_vector.template(cg.uint8).operator("const").operator("ref"),
-                    "data",
-                ),
-            ],
-            return_type=cg.optional.template(bool),
-        )
-        cg.add(var.set_template(template_))
+    await add_modbus_base_properties(var, config, ModbusBinarySensor, cg.float_, bool)

esphome/components/modbus_controller/binary_sensor/modbus_binarysensor.cpp

@@ -13,8 +13,6 @@ void ModbusBinarySensor::parse_and_publish(const std::vector<uint8_t> &data) {
 
   switch (this->register_type) {
     case ModbusRegisterType::DISCRETE_INPUT:
-      value = coil_from_vector(this->offset, data);
-      break;
     case ModbusRegisterType::COIL:
       // offset for coil is the actual number of the coil not the byte offset
       value = coil_from_vector(this->offset, data);

esphome/components/modbus_controller/const.py

@@ -1,6 +1,7 @@
 CONF_BITMASK = "bitmask"
 CONF_BYTE_OFFSET = "byte_offset"
 CONF_COMMAND_THROTTLE = "command_throttle"
+CONF_CUSTOM_COMMAND = "custom_command"
 CONF_FORCE_NEW_RANGE = "force_new_range"
 CONF_MODBUS_CONTROLLER_ID = "modbus_controller_id"
 CONF_MODBUS_FUNCTIONCODE = "modbus_functioncode"
@@ -9,5 +10,6 @@ CONF_REGISTER_COUNT = "register_count"
 CONF_REGISTER_TYPE = "register_type"
 CONF_RESPONSE_SIZE = "response_size"
 CONF_SKIP_UPDATES = "skip_updates"
+CONF_USE_WRITE_MULTIPLE = "use_write_multiple"
 CONF_VALUE_TYPE = "value_type"
 CONF_WRITE_LAMBDA = "write_lambda"

esphome/components/modbus_controller/modbus_controller.cpp

@@ -28,7 +28,10 @@ bool ModbusController::send_next_command_() {
              command->register_address, command->register_count);
     command->send();
     this->last_command_timestamp_ = millis();
-    if (!command->on_data_func) {  // No handler remove from queue directly after sending
+    // remove from queue if no handler is defined or command was sent too often
+    if (!command->on_data_func || command->send_countdown < 1) {
+      ESP_LOGD(TAG, "Modbus command to device=%d register=0x%02X countdown=%d removed from queue after send",
+               this->address_, command->register_address, command->send_countdown);
       command_queue_.pop_front();
     }
   }
@@ -69,24 +72,30 @@ void ModbusController::on_modbus_error(uint8_t function_code, uint8_t exception_
   }
 }
 
-void ModbusController::on_register_data(ModbusRegisterType register_type, uint16_t start_address,
-                                        const std::vector<uint8_t> &data) {
-  ESP_LOGV(TAG, "data for register address : 0x%X : ", start_address);
-
+std::map<uint64_t, SensorItem *>::iterator ModbusController::find_register_(ModbusRegisterType register_type,
+                                                                            uint16_t start_address) {
   auto vec_it = find_if(begin(register_ranges_), end(register_ranges_), [=](RegisterRange const &r) {
     return (r.start_address == start_address && r.register_type == register_type);
   });
 
   if (vec_it == register_ranges_.end()) {
-    ESP_LOGE(TAG, "Handle incoming data : No matching range for sensor found - start_address :  0x%X", start_address);
-    return;
-  }
-  auto map_it = sensormap_.find(vec_it->first_sensorkey);
-  if (map_it == sensormap_.end()) {
-    ESP_LOGE(TAG, "Handle incoming data : No sensor found in at start_address :  0x%X (0x%llX)", start_address,
-             vec_it->first_sensorkey);
-    return;
+    ESP_LOGE(TAG, "No matching range for sensor found - start_address :  0x%X", start_address);
+  } else {
+    auto map_it = sensormap_.find(vec_it->first_sensorkey);
+    if (map_it == sensormap_.end()) {
+      ESP_LOGE(TAG, "No sensor found in at start_address :  0x%X (0x%llX)", start_address, vec_it->first_sensorkey);
+    } else {
+      return sensormap_.find(vec_it->first_sensorkey);
+    }
   }
+  // not found
+  return std::end(sensormap_);
+}
+void ModbusController::on_register_data(ModbusRegisterType register_type, uint16_t start_address,
+                                        const std::vector<uint8_t> &data) {
+  ESP_LOGV(TAG, "data for register address : 0x%X : ", start_address);
+
+  auto map_it = find_register_(register_type, start_address);
   // loop through all sensors with the same start address
   while (map_it != sensormap_.end() && map_it->second->start_address == start_address) {
     if (map_it->second->register_type == register_type) {
@@ -116,9 +125,23 @@ void ModbusController::update_range_(RegisterRange &r) {
   ESP_LOGV(TAG, "Range : %X Size: %x (%d) skip: %d", r.start_address, r.register_count, (int) r.register_type,
            r.skip_updates_counter);
   if (r.skip_updates_counter == 0) {
-    ModbusCommandItem command_item =
-        ModbusCommandItem::create_read_command(this, r.register_type, r.start_address, r.register_count);
-    queue_command(command_item);
+    // if a custom command is used the user supplied custom_data is only available in the SensorItem.
+    if (r.register_type == ModbusRegisterType::CUSTOM) {
+      auto it = this->find_register_(r.register_type, r.start_address);
+      if (it != sensormap_.end()) {
+        auto command_item = ModbusCommandItem::create_custom_command(
+            this, it->second->custom_data,
+            [this](ModbusRegisterType register_type, uint16_t start_address, const std::vector<uint8_t> &data) {
+              this->on_register_data(ModbusRegisterType::CUSTOM, start_address, data);
+            });
+        command_item.register_address = it->second->start_address;
+        command_item.register_count = it->second->register_count;
+        command_item.function_code = ModbusFunctionCode::CUSTOM;
+        queue_command(command_item);
+      }
+    } else {
+      queue_command(ModbusCommandItem::create_read_command(this, r.register_type, r.start_address, r.register_count));
+    }
     r.skip_updates_counter = r.skip_updates;  // reset counter to config value
   } else {
     r.skip_updates_counter--;
@@ -422,6 +445,7 @@ bool ModbusCommandItem::send() {
     modbusdevice->send_raw(this->payload);
   }
   ESP_LOGV(TAG, "Command sent %d 0x%X %d", uint8_t(this->function_code), this->register_address, this->register_count);
+  send_countdown--;
   return true;
 }
 
@@ -549,6 +573,9 @@ float payload_to_float(const std::vector<uint8_t> &data, SensorValueType sensor_
       ESP_LOGD(TAG, "FP32_R = 0x%08X => %f", raw_to_float.raw, raw_to_float.float_value);
       result = raw_to_float.float_value;
     } break;
+    case SensorValueType::RAW:
+      result = NAN;
+      break;
     default:
       break;
   }

esphome/components/modbus_controller/modbus_controller.h

@@ -102,8 +102,6 @@ inline ModbusFunctionCode modbus_register_write_function(ModbusRegisterType reg_
       return ModbusFunctionCode::READ_WRITE_MULTIPLE_REGISTERS;
       break;
     case ModbusRegisterType::READ:
-      return ModbusFunctionCode::CUSTOM;
-      break;
     default:
       return ModbusFunctionCode::CUSTOM;
       break;
@@ -221,7 +219,7 @@ template<typename N> N mask_and_shift_by_rightbit(N data, uint32_t mask) {
   if (result == 0) {
     return result;
   }
-  for (int pos = 0; pos < sizeof(N) << 3; pos++) {
+  for (size_t pos = 0; pos < sizeof(N) << 3; pos++) {
     if ((mask & (1 << pos)) != 0)
       return result >> pos;
   }
@@ -247,29 +245,36 @@ float payload_to_float(const std::vector<uint8_t> &data, SensorValueType sensor_
 
 class ModbusController;
 
-struct SensorItem {
+class SensorItem {
+ public:
+  virtual void parse_and_publish(const std::vector<uint8_t> &data) = 0;
+
+  void set_custom_data(const std::vector<uint8_t> &data) { custom_data = data; }
+  uint64_t getkey() const { return calc_key(register_type, start_address, offset, bitmask); }
+  size_t virtual get_register_size() const {
+    if (register_type == ModbusRegisterType::COIL || register_type == ModbusRegisterType::DISCRETE_INPUT)
+      return 1;
+    else  // if CONF_RESPONSE_BYTES is used override the default
+      return response_bytes > 0 ? response_bytes : register_count * 2;
+  }
+  // Override register size for modbus devices not using 1 register for one dword
+  void set_register_size(uint8_t register_size) { response_bytes = register_size; }
   ModbusRegisterType register_type;
   SensorValueType sensor_value_type;
   uint16_t start_address;
   uint32_t bitmask;
   uint8_t offset;
   uint8_t register_count;
+  uint8_t response_bytes{0};
   uint8_t skip_updates;
+  std::vector<uint8_t> custom_data{};
   bool force_new_range{false};
-
-  virtual void parse_and_publish(const std::vector<uint8_t> &data) = 0;
-
-  uint64_t getkey() const { return calc_key(register_type, start_address, offset, bitmask); }
-  size_t virtual get_register_size() const {
-    if (register_type == ModbusRegisterType::COIL || register_type == ModbusRegisterType::DISCRETE_INPUT)
-      return 1;
-    else
-      return register_count * 2;
-  }
 };
 
-struct ModbusCommandItem {
+class ModbusCommandItem {
+ public:
   static const size_t MAX_PAYLOAD_BYTES = 240;
+  static const uint8_t MAX_SEND_REPEATS = 5;
   ModbusController *modbusdevice;
   uint16_t register_address;
   uint16_t register_count;
@@ -279,7 +284,9 @@ struct ModbusCommandItem {
       on_data_func;
   std::vector<uint8_t> payload = {};
   bool send();
-
+  // wrong commands (esp. custom commands) can block the send queue
+  // limit the number of repeats
+  uint8_t send_countdown{MAX_SEND_REPEATS};
   /// factory methods
   /** Create modbus read command
    *  Function code 02-04
@@ -392,6 +399,8 @@ class ModbusController : public PollingComponent, public modbus::ModbusDevice {
  protected:
   /// parse sensormap_ and create range of sequential addresses
   size_t create_register_ranges_();
+  // find register in sensormap. Returns iterator with all registers having the same start address
+  std::map<uint64_t, SensorItem *>::iterator find_register_(ModbusRegisterType register_type, uint16_t start_address);
   /// submit the read command for the address range to the send queue
   void update_range_(RegisterRange &r);
   /// parse incoming modbus data

esphome/components/modbus_controller/number/__init__.py

@@ -4,30 +4,28 @@ from esphome.components import number
 from esphome.const import (
     CONF_ADDRESS,
     CONF_ID,
-    CONF_LAMBDA,
     CONF_MAX_VALUE,
     CONF_MIN_VALUE,
     CONF_MULTIPLY,
-    CONF_OFFSET,
     CONF_STEP,
 )
 
 from .. import (
+    add_modbus_base_properties,
     modbus_controller_ns,
-    ModbusController,
-    SENSOR_VALUE_TYPE,
+    modbus_calc_properties,
+    ModbusItemBaseSchema,
     SensorItem,
-    TYPE_REGISTER_MAP,
+    SENSOR_VALUE_TYPE,
 )
 
-
 from ..const import (
     CONF_BITMASK,
-    CONF_BYTE_OFFSET,
+    CONF_CUSTOM_COMMAND,
     CONF_FORCE_NEW_RANGE,
     CONF_MODBUS_CONTROLLER_ID,
-    CONF_REGISTER_COUNT,
     CONF_SKIP_UPDATES,
+    CONF_USE_WRITE_MULTIPLE,
     CONF_VALUE_TYPE,
     CONF_WRITE_LAMBDA,
 )
@@ -51,45 +49,38 @@ def validate_min_max(config):
     return config
 
 
+def validate_modbus_number(config):
+    if CONF_CUSTOM_COMMAND not in config and CONF_ADDRESS not in config:
+        raise cv.Invalid(
+            f" {CONF_ADDRESS} is a required property if '{CONF_CUSTOM_COMMAND}:' isn't used"
+        )
+    return config
+
+
 CONFIG_SCHEMA = cv.All(
-    number.NUMBER_SCHEMA.extend(
+    number.NUMBER_SCHEMA.extend(ModbusItemBaseSchema)
+    .extend(
         {
             cv.GenerateID(): cv.declare_id(ModbusNumber),
-            cv.GenerateID(CONF_MODBUS_CONTROLLER_ID): cv.use_id(ModbusController),
-            cv.Required(CONF_ADDRESS): cv.positive_int,
-            cv.Optional(CONF_OFFSET, default=0): cv.positive_int,
-            cv.Optional(CONF_BYTE_OFFSET): cv.positive_int,
-            cv.Optional(CONF_BITMASK, default=0xFFFFFFFF): cv.hex_uint32_t,
             cv.Optional(CONF_VALUE_TYPE, default="U_WORD"): cv.enum(SENSOR_VALUE_TYPE),
-            cv.Optional(CONF_REGISTER_COUNT, default=0): cv.positive_int,
-            cv.Optional(CONF_SKIP_UPDATES, default=0): cv.positive_int,
-            cv.Optional(CONF_FORCE_NEW_RANGE, default=False): cv.boolean,
-            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
             cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
-            cv.GenerateID(): cv.declare_id(ModbusNumber),
             # 24 bits are the maximum value for fp32 before precison is lost
             # 0x00FFFFFF = 16777215
             cv.Optional(CONF_MAX_VALUE, default=16777215.0): cv.float_,
             cv.Optional(CONF_MIN_VALUE, default=-16777215.0): cv.float_,
             cv.Optional(CONF_STEP, default=1): cv.positive_float,
             cv.Optional(CONF_MULTIPLY, default=1.0): cv.float_,
+            cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
         }
-    ).extend(cv.polling_component_schema("60s")),
+    )
+    .extend(cv.polling_component_schema("60s")),
     validate_min_max,
+    validate_modbus_number,
 )
 
 
 async def to_code(config):
-    byte_offset = 0
-    if CONF_OFFSET in config:
-        byte_offset = config[CONF_OFFSET]
-    # A CONF_BYTE_OFFSET setting overrides CONF_OFFSET
-    if CONF_BYTE_OFFSET in config:
-        byte_offset = config[CONF_BYTE_OFFSET]
-    value_type = config[CONF_VALUE_TYPE]
-    reg_count = config[CONF_REGISTER_COUNT]
-    if reg_count == 0:
-        reg_count = TYPE_REGISTER_MAP[value_type]
+    byte_offset, reg_count = modbus_calc_properties(config)
     var = cg.new_Pvariable(
         config[CONF_ID],
         config[CONF_ADDRESS],
@@ -115,20 +106,8 @@ async def to_code(config):
 
     cg.add(var.set_parent(parent))
     cg.add(parent.add_sensor_item(var))
-    if CONF_LAMBDA in config:
-        template_ = await cg.process_lambda(
-            config[CONF_LAMBDA],
-            [
-                (ModbusNumber.operator("ptr"), "item"),
-                (cg.float_, "x"),
-                (
-                    cg.std_vector.template(cg.uint8).operator("const").operator("ref"),
-                    "data",
-                ),
-            ],
-            return_type=cg.optional.template(float),
-        )
-        cg.add(var.set_template(template_))
+    await add_modbus_base_properties(var, config, ModbusNumber)
+    cg.add(var.set_use_write_mutiple(config[CONF_USE_WRITE_MULTIPLE]))
     if CONF_WRITE_LAMBDA in config:
         template_ = await cg.process_lambda(
             config[CONF_WRITE_LAMBDA],

esphome/components/modbus_controller/number/modbus_number.cpp

@@ -8,12 +8,7 @@ namespace modbus_controller {
 static const char *const TAG = "modbus.number";
 
 void ModbusNumber::parse_and_publish(const std::vector<uint8_t> &data) {
-  union {
-    float float_value;
-    uint32_t raw;
-  } raw_to_float;
-
-  float result = payload_to_float(data, *this);
+  float result = payload_to_float(data, *this) / multiply_by_;
 
   // Is there a lambda registered
   // call it with the pre converted value and the raw data array
@@ -31,13 +26,8 @@ void ModbusNumber::parse_and_publish(const std::vector<uint8_t> &data) {
 }
 
 void ModbusNumber::control(float value) {
-  union {
-    float float_value;
-    uint32_t raw;
-  } raw_to_float;
-
   std::vector<uint16_t> data;
-  auto original_value = value;
+  float write_value = value;
   // Is there are lambda configured?
   if (this->write_transform_func_.has_value()) {
     // data is passed by reference
@@ -46,28 +36,32 @@ void ModbusNumber::control(float value) {
     auto val = (*this->write_transform_func_)(this, value, data);
     if (val.has_value()) {
       ESP_LOGV(TAG, "Value overwritten by lambda");
-      value = val.value();
+      write_value = val.value();
     } else {
       ESP_LOGV(TAG, "Communication handled by lambda - exiting control");
       return;
     }
   } else {
-    value = multiply_by_ * value;
+    write_value = multiply_by_ * write_value;
   }
 
   // lambda didn't set payload
   if (data.empty()) {
-    data = float_to_payload(value, this->sensor_value_type);
+    data = float_to_payload(write_value, this->sensor_value_type);
   }
 
   ESP_LOGD(TAG,
            "Updating register: connected Sensor=%s start address=0x%X register count=%d new value=%.02f (val=%.02f)",
-           this->get_name().c_str(), this->start_address, this->register_count, value, value);
+           this->get_name().c_str(), this->start_address, this->register_count, value, write_value);
 
   // Create and send the write command
-  auto write_cmd = ModbusCommandItem::create_write_multiple_command(parent_, this->start_address + this->offset,
-                                                                    this->register_count, data);
-
+  ModbusCommandItem write_cmd;
+  if (this->register_count == 1 && !this->use_write_multiple_) {
+    write_cmd = ModbusCommandItem::create_write_single_command(parent_, this->start_address + this->offset, data[0]);
+  } else {
+    write_cmd = ModbusCommandItem::create_write_multiple_command(parent_, this->start_address + this->offset,
+                                                                 this->register_count, data);
+  }
   // publish new value
   write_cmd.on_data_func = [this, write_cmd, value](ModbusRegisterType register_type, uint16_t start_address,
                                                     const std::vector<uint8_t> &data) {

esphome/components/modbus_controller/number/modbus_number.h

@@ -35,6 +35,7 @@ class ModbusNumber : public number::Number, public Component, public SensorItem
   using write_transform_func_t = std::function<optional<float>(ModbusNumber *, float, std::vector<uint16_t> &)>;
   void set_template(transform_func_t &&f) { this->transform_func_ = f; }
   void set_write_template(write_transform_func_t &&f) { this->write_transform_func_ = f; }
+  void set_use_write_mutiple(bool use_write_multiple) { this->use_write_multiple_ = use_write_multiple; }
 
  protected:
   void control(float value) override;
@@ -42,6 +43,7 @@ class ModbusNumber : public number::Number, public Component, public SensorItem
   optional<write_transform_func_t> write_transform_func_;
   ModbusController *parent_;
   float multiply_by_{1.0};
+  bool use_write_multiple_{false};
 };
 
 }  // namespace modbus_controller

esphome/components/modbus_controller/output/__init__.py

@@ -6,24 +6,22 @@ from esphome.const import (
     CONF_ADDRESS,
     CONF_ID,
     CONF_MULTIPLY,
-    CONF_OFFSET,
 )
 
 from .. import (
-    SensorItem,
     modbus_controller_ns,
-    ModbusController,
-    TYPE_REGISTER_MAP,
+    modbus_calc_properties,
+    validate_modbus_register,
+    ModbusItemBaseSchema,
+    SensorItem,
 )
 
 from ..const import (
-    CONF_BYTE_OFFSET,
     CONF_MODBUS_CONTROLLER_ID,
-    CONF_REGISTER_COUNT,
+    CONF_USE_WRITE_MULTIPLE,
     CONF_VALUE_TYPE,
     CONF_WRITE_LAMBDA,
 )
-from ..sensor import SENSOR_VALUE_TYPE
 
 DEPENDENCIES = ["modbus_controller"]
 CODEOWNERS = ["@martgras"]
@@ -34,43 +32,31 @@ ModbusOutput = modbus_controller_ns.class_(
 )
 
 CONFIG_SCHEMA = cv.All(
-    output.FLOAT_OUTPUT_SCHEMA.extend(
+    output.FLOAT_OUTPUT_SCHEMA.extend(ModbusItemBaseSchema).extend(
         {
-            cv.GenerateID(CONF_MODBUS_CONTROLLER_ID): cv.use_id(ModbusController),
             cv.GenerateID(): cv.declare_id(ModbusOutput),
-            cv.Required(CONF_ADDRESS): cv.positive_int,
-            cv.Optional(CONF_OFFSET, default=0): cv.positive_int,
-            cv.Optional(CONF_BYTE_OFFSET): cv.positive_int,
-            cv.Optional(CONF_VALUE_TYPE, default="U_WORD"): cv.enum(SENSOR_VALUE_TYPE),
-            cv.Optional(CONF_REGISTER_COUNT, default=0): cv.positive_int,
             cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
             cv.Optional(CONF_MULTIPLY, default=1.0): cv.float_,
+            cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
         }
     ),
+    validate_modbus_register,
 )
 
 
 async def to_code(config):
-    byte_offset = 0
-    if CONF_OFFSET in config:
-        byte_offset = config[CONF_OFFSET]
-    # A CONF_BYTE_OFFSET setting overrides CONF_OFFSET
-    if CONF_BYTE_OFFSET in config:
-        byte_offset = config[CONF_BYTE_OFFSET]
-    value_type = config[CONF_VALUE_TYPE]
-    reg_count = config[CONF_REGISTER_COUNT]
-    if reg_count == 0:
-        reg_count = TYPE_REGISTER_MAP[value_type]
+    byte_offset, reg_count = modbus_calc_properties(config)
     var = cg.new_Pvariable(
         config[CONF_ID],
         config[CONF_ADDRESS],
         byte_offset,
-        value_type,
+        config[CONF_VALUE_TYPE],
         reg_count,
     )
     await output.register_output(var, config)
     cg.add(var.set_write_multiply(config[CONF_MULTIPLY]))
     parent = await cg.get_variable(config[CONF_MODBUS_CONTROLLER_ID])
+    cg.add(var.set_use_write_mutiple(config[CONF_USE_WRITE_MULTIPLE]))
     cg.add(var.set_parent(parent))
     if CONF_WRITE_LAMBDA in config:
         template_ = await cg.process_lambda(

esphome/components/modbus_controller/output/modbus_output.cpp

@@ -13,11 +13,6 @@ void ModbusOutput::setup() {}
  *
  */
 void ModbusOutput::write_state(float value) {
-  union {
-    float float_value;
-    uint32_t raw;
-  } raw_to_float;
-
   std::vector<uint16_t> data;
   auto original_value = value;
   // Is there are lambda configured?
@@ -45,8 +40,14 @@ void ModbusOutput::write_state(float value) {
            this->start_address, this->register_count, value, original_value);
 
   // Create and send the write command
-  auto write_cmd =
-      ModbusCommandItem::create_write_multiple_command(parent_, this->start_address, this->register_count, data);
+  // Create and send the write command
+  ModbusCommandItem write_cmd;
+  if (this->register_count == 1 && !this->use_write_multiple_) {
+    write_cmd = ModbusCommandItem::create_write_single_command(parent_, this->start_address + this->offset, data[0]);
+  } else {
+    write_cmd = ModbusCommandItem::create_write_multiple_command(parent_, this->start_address + this->offset,
+                                                                 this->register_count, data);
+  }
   parent_->queue_command(write_cmd);
 }
 

esphome/components/modbus_controller/output/modbus_output.h

@@ -33,6 +33,7 @@ class ModbusOutput : public output::FloatOutput, public Component, public Sensor
 
   using write_transform_func_t = std::function<optional<float>(ModbusOutput *, float, std::vector<uint16_t> &)>;
   void set_write_template(write_transform_func_t &&f) { this->write_transform_func_ = f; }
+  void set_use_write_mutiple(bool use_write_multiple) { this->use_write_multiple_ = use_write_multiple; }
 
  protected:
   void write_state(float value) override;
@@ -40,6 +41,7 @@ class ModbusOutput : public output::FloatOutput, public Component, public Sensor
 
   ModbusController *parent_;
   float multiply_by_{1.0};
+  bool use_write_multiple_;
 };
 
 }  // namespace modbus_controller

esphome/components/modbus_controller/sensor/__init__.py

@@ -2,18 +2,19 @@ from esphome.components import sensor
 import esphome.config_validation as cv
 import esphome.codegen as cg
 
-from esphome.const import CONF_ID, CONF_ADDRESS, CONF_LAMBDA, CONF_OFFSET
+from esphome.const import CONF_ID, CONF_ADDRESS
 from .. import (
-    SensorItem,
+    add_modbus_base_properties,
     modbus_controller_ns,
-    ModbusController,
+    modbus_calc_properties,
+    validate_modbus_register,
+    ModbusItemBaseSchema,
+    SensorItem,
     MODBUS_REGISTER_TYPE,
     SENSOR_VALUE_TYPE,
-    TYPE_REGISTER_MAP,
 )
 from ..const import (
     CONF_BITMASK,
-    CONF_BYTE_OFFSET,
     CONF_FORCE_NEW_RANGE,
     CONF_MODBUS_CONTROLLER_ID,
     CONF_REGISTER_COUNT,
@@ -31,43 +32,30 @@ ModbusSensor = modbus_controller_ns.class_(
 )
 
 CONFIG_SCHEMA = cv.All(
-    sensor.SENSOR_SCHEMA.extend(
+    sensor.SENSOR_SCHEMA.extend(cv.COMPONENT_SCHEMA)
+    .extend(ModbusItemBaseSchema)
+    .extend(
         {
             cv.GenerateID(): cv.declare_id(ModbusSensor),
-            cv.GenerateID(CONF_MODBUS_CONTROLLER_ID): cv.use_id(ModbusController),
-            cv.Required(CONF_ADDRESS): cv.positive_int,
-            cv.Required(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
-            cv.Optional(CONF_OFFSET, default=0): cv.positive_int,
-            cv.Optional(CONF_BYTE_OFFSET): cv.positive_int,
-            cv.Optional(CONF_BITMASK, default=0xFFFFFFFF): cv.hex_uint32_t,
+            cv.Optional(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
             cv.Optional(CONF_VALUE_TYPE, default="U_WORD"): cv.enum(SENSOR_VALUE_TYPE),
             cv.Optional(CONF_REGISTER_COUNT, default=0): cv.positive_int,
-            cv.Optional(CONF_SKIP_UPDATES, default=0): cv.positive_int,
-            cv.Optional(CONF_FORCE_NEW_RANGE, default=False): cv.boolean,
-            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
         }
-    ).extend(cv.COMPONENT_SCHEMA),
+    ),
+    validate_modbus_register,
 )
 
 
 async def to_code(config):
-    byte_offset = 0
-    if CONF_OFFSET in config:
-        byte_offset = config[CONF_OFFSET]
-    # A CONF_BYTE_OFFSET setting overrides CONF_OFFSET
-    if CONF_BYTE_OFFSET in config:
-        byte_offset = config[CONF_BYTE_OFFSET]
+    byte_offset, reg_count = modbus_calc_properties(config)
     value_type = config[CONF_VALUE_TYPE]
-    reg_count = config[CONF_REGISTER_COUNT]
-    if reg_count == 0:
-        reg_count = TYPE_REGISTER_MAP[value_type]
     var = cg.new_Pvariable(
         config[CONF_ID],
         config[CONF_REGISTER_TYPE],
         config[CONF_ADDRESS],
         byte_offset,
         config[CONF_BITMASK],
-        config[CONF_VALUE_TYPE],
+        value_type,
         reg_count,
         config[CONF_SKIP_UPDATES],
         config[CONF_FORCE_NEW_RANGE],
@@ -77,17 +65,4 @@ async def to_code(config):
 
     paren = await cg.get_variable(config[CONF_MODBUS_CONTROLLER_ID])
     cg.add(paren.add_sensor_item(var))
-    if CONF_LAMBDA in config:
-        template_ = await cg.process_lambda(
-            config[CONF_LAMBDA],
-            [
-                (ModbusSensor.operator("ptr"), "item"),
-                (cg.float_, "x"),
-                (
-                    cg.std_vector.template(cg.uint8).operator("const").operator("ref"),
-                    "data",
-                ),
-            ],
-            return_type=cg.optional.template(float),
-        )
-        cg.add(var.set_template(template_))
+    await add_modbus_base_properties(var, config, ModbusSensor)

esphome/components/modbus_controller/sensor/modbus_sensor.cpp

@@ -10,11 +10,6 @@ static const char *const TAG = "modbus_controller.sensor";
 void ModbusSensor::dump_config() { LOG_SENSOR(TAG, "Modbus Controller Sensor", this); }
 
 void ModbusSensor::parse_and_publish(const std::vector<uint8_t> &data) {
-  union {
-    float float_value;
-    uint32_t raw;
-  } raw_to_float;
-
   float result = payload_to_float(data, *this);
 
   // Is there a lambda registered

esphome/components/modbus_controller/sensor/modbus_sensor.h

@@ -25,6 +25,7 @@ class ModbusSensor : public Component, public sensor::Sensor, public SensorItem
   void parse_and_publish(const std::vector<uint8_t> &data) override;
   void dump_config() override;
   using transform_func_t = std::function<optional<float>(ModbusSensor *, float, const std::vector<uint8_t> &)>;
+
   void set_template(transform_func_t &&f) { this->transform_func_ = f; }
 
  protected:

esphome/components/modbus_controller/switch/__init__.py

@@ -3,19 +3,23 @@ import esphome.config_validation as cv
 import esphome.codegen as cg
 
 
-from esphome.const import CONF_ID, CONF_ADDRESS, CONF_LAMBDA, CONF_OFFSET
+from esphome.const import CONF_ID, CONF_ADDRESS
 from .. import (
-    MODBUS_REGISTER_TYPE,
-    SensorItem,
+    add_modbus_base_properties,
     modbus_controller_ns,
-    ModbusController,
+    modbus_calc_properties,
+    validate_modbus_register,
+    ModbusItemBaseSchema,
+    SensorItem,
+    MODBUS_REGISTER_TYPE,
 )
 from ..const import (
     CONF_BITMASK,
-    CONF_BYTE_OFFSET,
     CONF_FORCE_NEW_RANGE,
     CONF_MODBUS_CONTROLLER_ID,
     CONF_REGISTER_TYPE,
+    CONF_USE_WRITE_MULTIPLE,
+    CONF_WRITE_LAMBDA,
 )
 
 DEPENDENCIES = ["modbus_controller"]
@@ -26,31 +30,23 @@ ModbusSwitch = modbus_controller_ns.class_(
     "ModbusSwitch", cg.Component, switch.Switch, SensorItem
 )
 
-
 CONFIG_SCHEMA = cv.All(
-    switch.SWITCH_SCHEMA.extend(
+    switch.SWITCH_SCHEMA.extend(cv.COMPONENT_SCHEMA)
+    .extend(ModbusItemBaseSchema)
+    .extend(
         {
             cv.GenerateID(): cv.declare_id(ModbusSwitch),
-            cv.GenerateID(CONF_MODBUS_CONTROLLER_ID): cv.use_id(ModbusController),
-            cv.Required(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
-            cv.Required(CONF_ADDRESS): cv.positive_int,
-            cv.Optional(CONF_OFFSET, default=0): cv.positive_int,
-            cv.Optional(CONF_BYTE_OFFSET): cv.positive_int,
-            cv.Optional(CONF_BITMASK, default=0x1): cv.hex_uint32_t,
-            cv.Optional(CONF_FORCE_NEW_RANGE, default=False): cv.boolean,
-            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
+            cv.Optional(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
+            cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
+            cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
         }
-    ).extend(cv.COMPONENT_SCHEMA),
+    ),
+    validate_modbus_register,
 )
 
 
 async def to_code(config):
-    byte_offset = 0
-    if CONF_OFFSET in config:
-        byte_offset = config[CONF_OFFSET]
-    # A CONF_BYTE_OFFSET setting overrides CONF_OFFSET
-    if CONF_BYTE_OFFSET in config:
-        byte_offset = config[CONF_BYTE_OFFSET]
+    byte_offset, _ = modbus_calc_properties(config)
     var = cg.new_Pvariable(
         config[CONF_ID],
         config[CONF_REGISTER_TYPE],
@@ -63,19 +59,18 @@ async def to_code(config):
     await switch.register_switch(var, config)
 
     paren = await cg.get_variable(config[CONF_MODBUS_CONTROLLER_ID])
-    cg.add(paren.add_sensor_item(var))
     cg.add(var.set_parent(paren))
-    if CONF_LAMBDA in config:
-        publish_template_ = await cg.process_lambda(
-            config[CONF_LAMBDA],
+    cg.add(var.set_use_write_mutiple(config[CONF_USE_WRITE_MULTIPLE]))
+    cg.add(paren.add_sensor_item(var))
+    if CONF_WRITE_LAMBDA in config:
+        template_ = await cg.process_lambda(
+            config[CONF_WRITE_LAMBDA],
             [
                 (ModbusSwitch.operator("ptr"), "item"),
-                (bool, "x"),
-                (
-                    cg.std_vector.template(cg.uint8).operator("const").operator("ref"),
-                    "data",
-                ),
+                (cg.bool_, "x"),
+                (cg.std_vector.template(cg.uint8).operator("ref"), "payload"),
             ],
             return_type=cg.optional.template(bool),
         )
-        cg.add(var.set_template(publish_template_))
+        cg.add(var.set_write_template(template_))
+    await add_modbus_base_properties(var, config, ModbusSwitch, bool, bool)

esphome/components/modbus_controller/switch/modbus_switch.cpp

@@ -45,22 +45,50 @@ void ModbusSwitch::parse_and_publish(const std::vector<uint8_t> &data) {
 void ModbusSwitch::write_state(bool state) {
   // This will be called every time the user requests a state change.
   ModbusCommandItem cmd;
-  ESP_LOGV(TAG, "write_state '%s': new value = %s type = %d address = %X offset = %x", this->get_name().c_str(),
-           ONOFF(state), (int) this->register_type, this->start_address, this->offset);
-  switch (this->register_type) {
-    case ModbusRegisterType::COIL:
+  std::vector<uint8_t> data;
+  // Is there are lambda configured?
+  if (this->write_transform_func_.has_value()) {
+    // data is passed by reference
+    // the lambda can fill the empty vector directly
+    // in that case the return value is ignored
+    auto val = (*this->write_transform_func_)(this, state, data);
+    if (val.has_value()) {
+      ESP_LOGV(TAG, "Value overwritten by lambda");
+      state = val.value();
+    } else {
+      ESP_LOGV(TAG, "Communication handled by lambda - exiting control");
+      return;
+    }
+  }
+  if (!data.empty()) {
+    ESP_LOGV(TAG, "Modbus Switch write raw: %s", format_hex_pretty(data).c_str());
+    cmd = ModbusCommandItem::create_custom_command(
+        this->parent_, data,
+        [this, cmd](ModbusRegisterType register_type, uint16_t start_address, const std::vector<uint8_t> &data) {
+          this->parent_->on_write_register_response(cmd.register_type, this->start_address, data);
+        });
+  } else {
+    ESP_LOGV(TAG, "write_state '%s': new value = %s type = %d address = %X offset = %x", this->get_name().c_str(),
+             ONOFF(state), (int) this->register_type, this->start_address, this->offset);
+    if (this->register_type == ModbusRegisterType::COIL) {
       // offset for coil and discrete inputs is the coil/register number not bytes
-      cmd = ModbusCommandItem::create_write_single_coil(parent_, this->start_address + this->offset, state);
-      break;
-    case ModbusRegisterType::DISCRETE_INPUT:
-      cmd = ModbusCommandItem::create_write_single_command(parent_, this->start_address + this->offset, state);
-      break;
-
-    default:
+      if (this->use_write_multiple_) {
+        std::vector<bool> states{state};
+        cmd = ModbusCommandItem::create_write_multiple_coils(parent_, this->start_address + this->offset, states);
+      } else {
+        cmd = ModbusCommandItem::create_write_single_coil(parent_, this->start_address + this->offset, state);
+      }
+    } else {
       // since offset is in bytes and a register is 16 bits we get the start by adding offset/2
-      cmd = ModbusCommandItem::create_write_single_command(parent_, this->start_address + this->offset / 2,
-                                                           state ? 0xFFFF & this->bitmask : 0);
-      break;
+      if (this->use_write_multiple_) {
+        std::vector<uint16_t> bool_states(1, state ? (0xFFFF & this->bitmask) : 0);
+        cmd = ModbusCommandItem::create_write_multiple_command(parent_, this->start_address + this->offset / 2, 1,
+                                                               bool_states);
+      } else {
+        cmd = ModbusCommandItem::create_write_single_command(parent_, this->start_address + this->offset / 2,
+                                                             state ? 0xFFFF & this->bitmask : 0u);
+      }
+    }
   }
   this->parent_->queue_command(cmd);
   publish_state(state);

esphome/components/modbus_controller/switch/modbus_switch.h

@@ -33,11 +33,16 @@ class ModbusSwitch : public Component, public switch_::Switch, public SensorItem
   void set_parent(ModbusController *parent) { this->parent_ = parent; }
 
   using transform_func_t = std::function<optional<bool>(ModbusSwitch *, bool, const std::vector<uint8_t> &)>;
+  using write_transform_func_t = std::function<optional<bool>(ModbusSwitch *, bool, std::vector<uint8_t> &)>;
   void set_template(transform_func_t &&f) { this->publish_transform_func_ = f; }
+  void set_write_template(write_transform_func_t &&f) { this->write_transform_func_ = f; }
+  void set_use_write_mutiple(bool use_write_multiple) { this->use_write_multiple_ = use_write_multiple; }
 
  protected:
   ModbusController *parent_;
+  bool use_write_multiple_;
   optional<transform_func_t> publish_transform_func_{nullopt};
+  optional<write_transform_func_t> write_transform_func_{nullopt};
 };
 
 }  // namespace modbus_controller

esphome/components/modbus_controller/text_sensor/__init__.py

@@ -3,15 +3,17 @@ import esphome.config_validation as cv
 import esphome.codegen as cg
 
 
-from esphome.const import CONF_ID, CONF_ADDRESS, CONF_LAMBDA, CONF_OFFSET
+from esphome.const import CONF_ADDRESS, CONF_ID
 from .. import (
-    SensorItem,
+    add_modbus_base_properties,
     modbus_controller_ns,
-    ModbusController,
+    modbus_calc_properties,
+    validate_modbus_register,
+    ModbusItemBaseSchema,
+    SensorItem,
     MODBUS_REGISTER_TYPE,
 )
 from ..const import (
-    CONF_BYTE_OFFSET,
     CONF_FORCE_NEW_RANGE,
     CONF_MODBUS_CONTROLLER_ID,
     CONF_REGISTER_COUNT,
@@ -38,32 +40,23 @@ RAW_ENCODING = {
 }
 
 CONFIG_SCHEMA = cv.All(
-    text_sensor.TEXT_SENSOR_SCHEMA.extend(
+    text_sensor.TEXT_SENSOR_SCHEMA.extend(cv.COMPONENT_SCHEMA)
+    .extend(ModbusItemBaseSchema)
+    .extend(
         {
             cv.GenerateID(): cv.declare_id(ModbusTextSensor),
-            cv.GenerateID(CONF_MODBUS_CONTROLLER_ID): cv.use_id(ModbusController),
-            cv.Required(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
-            cv.Required(CONF_ADDRESS): cv.positive_int,
-            cv.Optional(CONF_OFFSET, default=0): cv.positive_int,
-            cv.Optional(CONF_BYTE_OFFSET): cv.positive_int,
+            cv.Optional(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
             cv.Optional(CONF_REGISTER_COUNT, default=0): cv.positive_int,
             cv.Optional(CONF_RESPONSE_SIZE, default=2): cv.positive_int,
             cv.Optional(CONF_RAW_ENCODE, default="NONE"): cv.enum(RAW_ENCODING),
-            cv.Optional(CONF_SKIP_UPDATES, default=0): cv.positive_int,
-            cv.Optional(CONF_FORCE_NEW_RANGE, default=False): cv.boolean,
-            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
         }
-    ).extend(cv.COMPONENT_SCHEMA),
+    ),
+    validate_modbus_register,
 )
 
 
 async def to_code(config):
-    byte_offset = 0
-    if CONF_OFFSET in config:
-        byte_offset = config[CONF_OFFSET]
-    # A CONF_BYTE_OFFSET setting overrides CONF_OFFSET
-    if CONF_BYTE_OFFSET in config:
-        byte_offset = config[CONF_BYTE_OFFSET]
+    byte_offset, reg_count = modbus_calc_properties(config)
     response_size = config[CONF_RESPONSE_SIZE]
     reg_count = config[CONF_REGISTER_COUNT]
     if reg_count == 0:
@@ -85,17 +78,6 @@ async def to_code(config):
 
     paren = await cg.get_variable(config[CONF_MODBUS_CONTROLLER_ID])
     cg.add(paren.add_sensor_item(var))
-    if CONF_LAMBDA in config:
-        template_ = await cg.process_lambda(
-            config[CONF_LAMBDA],
-            [
-                (ModbusTextSensor.operator("ptr"), "item"),
-                (cg.std_string.operator("const").operator("ref"), "x"),
-                (
-                    cg.std_vector.template(cg.uint8).operator("const").operator("ref"),
-                    "data",
-                ),
-            ],
-            return_type=cg.optional.template(cg.std_string),
-        )
-        cg.add(var.set_template(template_))
+    await add_modbus_base_properties(
+        var, config, ModbusTextSensor, cg.std_string, cg.std_string
+    )

esphome/components/modbus_controller/text_sensor/modbus_textsensor.cpp

@@ -13,7 +13,7 @@ void ModbusTextSensor::dump_config() { LOG_TEXT_SENSOR("", "Modbus Controller Te
 
 void ModbusTextSensor::parse_and_publish(const std::vector<uint8_t> &data) {
   std::ostringstream output;
-  uint8_t max_items = this->response_bytes_;
+  uint8_t max_items = this->response_bytes;
   char buffer[4];
   bool add_comma = false;
   for (auto b : data) {

esphome/components/modbus_controller/text_sensor/modbus_textsensor.h

@@ -17,7 +17,7 @@ class ModbusTextSensor : public Component, public text_sensor::TextSensor, publi
     this->register_type = register_type;
     this->start_address = start_address;
     this->offset = offset;
-    this->response_bytes_ = response_bytes;
+    this->response_bytes = response_bytes;
     this->register_count = register_count;
     this->encode_ = encode;
     this->skip_updates = skip_updates;
@@ -38,7 +38,6 @@ class ModbusTextSensor : public Component, public text_sensor::TextSensor, publi
 
  protected:
   RawEncoding encode_;
-  uint16_t response_bytes_;
 };
 
 }  // namespace modbus_controller

esphome/components/mqtt/__init__.py

@@ -95,6 +95,7 @@ MQTTSwitchComponent = mqtt_ns.class_("MQTTSwitchComponent", MQTTComponent)
 MQTTTextSensor = mqtt_ns.class_("MQTTTextSensor", MQTTComponent)
 MQTTNumberComponent = mqtt_ns.class_("MQTTNumberComponent", MQTTComponent)
 MQTTSelectComponent = mqtt_ns.class_("MQTTSelectComponent", MQTTComponent)
+MQTTButtonComponent = mqtt_ns.class_("MQTTButtonComponent", MQTTComponent)
 
 MQTTDiscoveryUniqueIdGenerator = mqtt_ns.enum("MQTTDiscoveryUniqueIdGenerator")
 MQTT_DISCOVERY_UNIQUE_ID_GENERATOR_OPTIONS = {

esphome/components/mqtt/mqtt_button.cpp

@@ -0,0 +1,45 @@
+#include "mqtt_button.h"
+#include "esphome/core/log.h"
+
+#include "mqtt_const.h"
+
+#ifdef USE_MQTT
+#ifdef USE_BUTTON
+
+namespace esphome {
+namespace mqtt {
+
+static const char *const TAG = "mqtt.button";
+
+using namespace esphome::button;
+
+MQTTButtonComponent::MQTTButtonComponent(button::Button *button) : MQTTComponent(), button_(button) {}
+
+void MQTTButtonComponent::setup() {
+  this->subscribe(this->get_command_topic_(), [this](const std::string &topic, const std::string &payload) {
+    if (payload == "press") {
+      this->button_->press();
+    } else {
+      ESP_LOGW(TAG, "'%s': Received unknown status payload: %s", this->friendly_name().c_str(), payload.c_str());
+      this->status_momentary_warning("state", 5000);
+    }
+  });
+}
+void MQTTButtonComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "MQTT Button '%s': ", this->button_->get_name().c_str());
+  LOG_MQTT_COMPONENT(true, true);
+}
+
+void MQTTButtonComponent::send_discovery(JsonObject &root, mqtt::SendDiscoveryConfig &config) {
+  if (!this->button_->get_device_class().empty())
+    root[MQTT_DEVICE_CLASS] = this->button_->get_device_class();
+}
+
+std::string MQTTButtonComponent::component_type() const { return "button"; }
+const EntityBase *MQTTButtonComponent::get_entity() const { return this->button_; }
+
+}  // namespace mqtt
+}  // namespace esphome
+
+#endif
+#endif  // USE_MQTT

esphome/components/mqtt/mqtt_button.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_MQTT
+#ifdef USE_BUTTON
+
+#include "esphome/components/button/button.h"
+#include "mqtt_component.h"
+
+namespace esphome {
+namespace mqtt {
+
+class MQTTButtonComponent : public mqtt::MQTTComponent {
+ public:
+  explicit MQTTButtonComponent(button::Button *button);
+
+  // ========== INTERNAL METHODS ==========
+  // (In most use cases you won't need these)
+  void setup() override;
+  void dump_config() override;
+
+  /// Buttons do not send a state so just return true.
+  bool send_initial_state() override { return true; }
+
+  void send_discovery(JsonObject &root, mqtt::SendDiscoveryConfig &config) override;
+
+ protected:
+  /// "button" component type.
+  std::string component_type() const override;
+  const EntityBase *get_entity() const override;
+
+  button::Button *button_;
+};
+
+}  // namespace mqtt
+}  // namespace esphome
+
+#endif
+#endif  // USE_MQTT

esphome/components/mqtt/mqtt_const.h

@@ -514,6 +514,7 @@ constexpr const char *const MQTT_DEVICE_SUGGESTED_AREA = "suggested_area";
 
 // Additional MQTT fields where no abbreviation is defined in HA source
 constexpr const char *const MQTT_ENTITY_CATEGORY = "entity_category";
+constexpr const char *const MQTT_MODE = "mode";
 
 }  // namespace mqtt
 }  // namespace esphome

esphome/components/mqtt/mqtt_number.cpp

@@ -43,6 +43,18 @@ void MQTTNumberComponent::send_discovery(JsonObject &root, mqtt::SendDiscoveryCo
   root[MQTT_MIN] = traits.get_min_value();
   root[MQTT_MAX] = traits.get_max_value();
   root[MQTT_STEP] = traits.get_step();
+  if (!this->number_->traits.get_unit_of_measurement().empty())
+    root[MQTT_UNIT_OF_MEASUREMENT] = this->number_->traits.get_unit_of_measurement();
+  switch (this->number_->traits.get_mode()) {
+    case NUMBER_MODE_AUTO:
+      break;
+    case NUMBER_MODE_BOX:
+      root[MQTT_MODE] = "box";
+      break;
+    case NUMBER_MODE_SLIDER:
+      root[MQTT_MODE] = "slider";
+      break;
+  }
 
   config.command_topic = true;
 }

esphome/components/neopixelbus/_methods.py

@@ -88,8 +88,8 @@ def _esp32_i2s_default_bus():
 
 
 def _validate_esp32_i2s_bus(value):
-    if isinstance(value, str) and value.lower() == CHANNEL_DYNAMIC:
-        value = CHANNEL_DYNAMIC
+    if isinstance(value, str) and value.lower() == BUS_DYNAMIC:
+        value = BUS_DYNAMIC
     else:
         value = cv.int_(value)
     variant_buses = {

esphome/components/nextion/nextion.cpp

@@ -64,7 +64,7 @@ bool Nextion::check_connect_() {
   if (response.empty() || response.find("comok") == std::string::npos) {
 #ifdef NEXTION_PROTOCOL_LOG
     ESP_LOGN(TAG, "Bad connect request %s", response.c_str());
-    for (int i = 0; i < response.length(); i++) {
+    for (size_t i = 0; i < response.length(); i++) {
       ESP_LOGN(TAG, "response %s %d %d %c", response.c_str(), i, response[i], response[i]);
     }
 #endif
@@ -563,11 +563,10 @@ void Nextion::process_nextion_commands_() {
       // FF FF FF - End
       case 0x90: {  // Switched component
         std::string variable_name;
-        uint8_t index = 0;
 
         // Get variable name
-        index = to_process.find('\0');
-        if (static_cast<char>(index) == std::string::npos || (to_process_length - index - 1) < 1) {
+        auto index = to_process.find('\0');
+        if (index == std::string::npos || (to_process_length - index - 1) < 1) {
           ESP_LOGE(TAG, "Bad switch component data received for 0x90 event!");
           ESP_LOGN(TAG, "to_process %s %zu %d", to_process.c_str(), to_process_length, index);
           break;
@@ -591,10 +590,9 @@ void Nextion::process_nextion_commands_() {
       // FF FF FF - End
       case 0x91: {  // Sensor component
         std::string variable_name;
-        uint8_t index = 0;
 
-        index = to_process.find('\0');
-        if (static_cast<char>(index) == std::string::npos || (to_process_length - index - 1) != 4) {
+        auto index = to_process.find('\0');
+        if (index == std::string::npos || (to_process_length - index - 1) != 4) {
           ESP_LOGE(TAG, "Bad sensor component data received for 0x91 event!");
           ESP_LOGN(TAG, "to_process %s %zu %d", to_process.c_str(), to_process_length, index);
           break;
@@ -626,11 +624,10 @@ void Nextion::process_nextion_commands_() {
       case 0x92: {  // Text Sensor Component
         std::string variable_name;
         std::string text_value;
-        uint8_t index = 0;
 
         // Get variable name
-        index = to_process.find('\0');
-        if (static_cast<char>(index) == std::string::npos || (to_process_length - index - 1) < 1) {
+        auto index = to_process.find('\0');
+        if (index == std::string::npos || (to_process_length - index - 1) < 1) {
           ESP_LOGE(TAG, "Bad text sensor component data received for 0x92 event!");
           ESP_LOGN(TAG, "to_process %s %zu %d", to_process.c_str(), to_process_length, index);
           break;
@@ -660,11 +657,10 @@ void Nextion::process_nextion_commands_() {
       // FF FF FF - End
       case 0x93: {  // Binary Sensor component
         std::string variable_name;
-        uint8_t index = 0;
 
         // Get variable name
-        index = to_process.find('\0');
-        if (static_cast<char>(index) == std::string::npos || (to_process_length - index - 1) < 1) {
+        auto index = to_process.find('\0');
+        if (index == std::string::npos || (to_process_length - index - 1) < 1) {
           ESP_LOGE(TAG, "Bad binary sensor component data received for 0x92 event!");
           ESP_LOGN(TAG, "to_process %s %zu %d", to_process.c_str(), to_process_length, index);
           break;
@@ -736,7 +732,7 @@ void Nextion::process_nextion_commands_() {
   uint32_t ms = millis();
 
   if (!this->nextion_queue_.empty() && this->nextion_queue_.front()->queue_time + this->max_q_age_ms_ < ms) {
-    for (int i = 0; i < this->nextion_queue_.size(); i++) {
+    for (size_t i = 0; i < this->nextion_queue_.size(); i++) {
       NextionComponentBase *component = this->nextion_queue_[i]->component;
       if (this->nextion_queue_[i]->queue_time + this->max_q_age_ms_ < ms) {
         if (this->nextion_queue_[i]->queue_time == 0)

esphome/components/nextion/nextion_upload.cpp

@@ -95,7 +95,7 @@ int Nextion::upload_by_chunks_(HTTPClient *http, int range_start) {
   }
   http->end();
   ESP_LOGN(TAG, "this->content_length_ %d sent %d", this->content_length_, sent);
-  for (uint32_t i = 0; i < range; i += 4096) {
+  for (int i = 0; i < range; i += 4096) {
     this->write_array(&this->transfer_buffer_[i], 4096);
     this->content_length_ -= 4096;
     ESP_LOGN(TAG, "this->content_length_ %d range %d range_end %d range_start %d", this->content_length_, range,
@@ -238,7 +238,7 @@ void Nextion::upload_tft() {
   // The Nextion display will, if it's ready to accept data, send a 0x05 byte.
   ESP_LOGD(TAG, "Upgrade response is %s %zu", response.c_str(), response.length());
 
-  for (int i = 0; i < response.length(); i++) {
+  for (size_t i = 0; i < response.length(); i++) {
     ESP_LOGD(TAG, "Available %d : 0x%02X", i, response[i]);
   }
 

esphome/components/nextion/sensor/nextion_sensor.cpp

@@ -24,7 +24,7 @@ void NextionSensor::add_to_wave_buffer(float state) {
 
   wave_buffer_.push_back(wave_state);
 
-  if (this->wave_buffer_.size() > this->wave_max_length_) {
+  if (this->wave_buffer_.size() > (size_t) this->wave_max_length_) {
     this->wave_buffer_.erase(this->wave_buffer_.begin());
   }
 }

esphome/components/nfc/ndef_message.cpp

@@ -93,7 +93,7 @@ bool NdefMessage::add_uri_record(const std::string &uri) { return this->add_reco
 std::vector<uint8_t> NdefMessage::encode() {
   std::vector<uint8_t> data;
 
-  for (uint8_t i = 0; i < this->records_.size(); i++) {
+  for (size_t i = 0; i < this->records_.size(); i++) {
     auto encoded_record = this->records_[i]->encode(i == 0, (i + 1) == this->records_.size());
     data.insert(data.end(), encoded_record.begin(), encoded_record.end());
   }

esphome/components/nfc/nfc.cpp

@@ -10,7 +10,7 @@ static const char *const TAG = "nfc";
 std::string format_uid(std::vector<uint8_t> &uid) {
   char buf[(uid.size() * 2) + uid.size() - 1];
   int offset = 0;
-  for (uint8_t i = 0; i < uid.size(); i++) {
+  for (size_t i = 0; i < uid.size(); i++) {
     const char *format = "%02X";
     if (i + 1 < uid.size())
       format = "%02X-";
@@ -22,7 +22,7 @@ std::string format_uid(std::vector<uint8_t> &uid) {
 std::string format_bytes(std::vector<uint8_t> &bytes) {
   char buf[(bytes.size() * 2) + bytes.size() - 1];
   int offset = 0;
-  for (uint8_t i = 0; i < bytes.size(); i++) {
+  for (size_t i = 0; i < bytes.size(); i++) {
     const char *format = "%02X";
     if (i + 1 < bytes.size())
       format = "%02X ";

esphome/components/number/__init__.py

@@ -7,9 +7,11 @@ from esphome.const import (
     CONF_ABOVE,
     CONF_BELOW,
     CONF_ID,
+    CONF_MODE,
     CONF_ON_VALUE,
     CONF_ON_VALUE_RANGE,
     CONF_TRIGGER_ID,
+    CONF_UNIT_OF_MEASUREMENT,
     CONF_MQTT_ID,
     CONF_VALUE,
 )
@@ -39,6 +41,14 @@ NumberInRangeCondition = number_ns.class_(
     "NumberInRangeCondition", automation.Condition
 )
 
+NumberMode = number_ns.enum("NumberMode")
+
+NUMBER_MODES = {
+    "AUTO": NumberMode.NUMBER_MODE_AUTO,
+    "BOX": NumberMode.NUMBER_MODE_BOX,
+    "SLIDER": NumberMode.NUMBER_MODE_SLIDER,
+}
+
 icon = cv.icon
 
 NUMBER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).extend(
@@ -58,6 +68,8 @@ NUMBER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).e
             },
             cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW),
         ),
+        cv.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string_strict,
+        cv.Optional(CONF_MODE, default="AUTO"): cv.enum(NUMBER_MODES, upper=True),
     }
 )
 
@@ -72,6 +84,8 @@ async def setup_number_core_(
     if step is not None:
         cg.add(var.traits.set_step(step))
 
+    cg.add(var.traits.set_mode(config[CONF_MODE]))
+
     for conf in config.get(CONF_ON_VALUE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [(float, "x")], conf)
@@ -86,6 +100,8 @@ async def setup_number_core_(
             cg.add(trigger.set_max(template_))
         await automation.build_automation(trigger, [(float, "x")], conf)
 
+    if CONF_UNIT_OF_MEASUREMENT in config:
+        cg.add(var.traits.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
     if CONF_MQTT_ID in config:
         mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
         await mqtt.register_mqtt_component(mqtt_, config)

esphome/components/number/number.cpp

@@ -41,6 +41,15 @@ void Number::add_on_state_callback(std::function<void(float)> &&callback) {
   this->state_callback_.add(std::move(callback));
 }
 
+std::string NumberTraits::get_unit_of_measurement() {
+  if (this->unit_of_measurement_.has_value())
+    return *this->unit_of_measurement_;
+  return "";
+}
+void NumberTraits::set_unit_of_measurement(const std::string &unit_of_measurement) {
+  this->unit_of_measurement_ = unit_of_measurement;
+}
+
 uint32_t Number::hash_base() { return 2282307003UL; }
 
 }  // namespace number

esphome/components/number/number.h

@@ -13,6 +13,9 @@ namespace number {
     if (!(obj)->get_icon().empty()) { \
       ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
     } \
+    if (!(obj)->traits.get_unit_of_measurement().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Unit of Measurement: '%s'", prefix, (obj)->traits.get_unit_of_measurement().c_str()); \
+    } \
   }
 
 class Number;
@@ -33,6 +36,12 @@ class NumberCall {
   optional<float> value_;
 };
 
+enum NumberMode : uint8_t {
+  NUMBER_MODE_AUTO = 0,
+  NUMBER_MODE_BOX = 1,
+  NUMBER_MODE_SLIDER = 2,
+};
+
 class NumberTraits {
  public:
   void set_min_value(float min_value) { min_value_ = min_value; }
@@ -42,10 +51,21 @@ class NumberTraits {
   void set_step(float step) { step_ = step; }
   float get_step() const { return step_; }
 
+  /// Get the unit of measurement, using the manual override if set.
+  std::string get_unit_of_measurement();
+  /// Manually set the unit of measurement.
+  void set_unit_of_measurement(const std::string &unit_of_measurement);
+
+  // Get/set the frontend mode.
+  NumberMode get_mode() const { return this->mode_; }
+  void set_mode(NumberMode mode) { this->mode_ = mode; }
+
  protected:
   float min_value_ = NAN;
   float max_value_ = NAN;
   float step_ = NAN;
+  optional<std::string> unit_of_measurement_;  ///< Unit of measurement override
+  NumberMode mode_{NUMBER_MODE_AUTO};
 };
 
 /** Base-class for all numbers.

esphome/components/ota/ota_component.cpp

@@ -141,14 +141,14 @@ void OTAComponent::handle_() {
 
   if (!this->readall_(buf, 5)) {
     ESP_LOGW(TAG, "Reading magic bytes failed!");
-    goto error;
+    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
   // 0x6C, 0x26, 0xF7, 0x5C, 0x45
   if (buf[0] != 0x6C || buf[1] != 0x26 || buf[2] != 0xF7 || buf[3] != 0x5C || buf[4] != 0x45) {
     ESP_LOGW(TAG, "Magic bytes do not match! 0x%02X-0x%02X-0x%02X-0x%02X-0x%02X", buf[0], buf[1], buf[2], buf[3],
              buf[4]);
     error_code = OTA_RESPONSE_ERROR_MAGIC;
-    goto error;
+    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
 
   // Send OK and version - 2 bytes
@@ -161,7 +161,7 @@ void OTAComponent::handle_() {
   // Read features - 1 byte
   if (!this->readall_(buf, 1)) {
     ESP_LOGW(TAG, "Reading features failed!");
-    goto error;
+    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
   ota_features = buf[0];  // NOLINT
   ESP_LOGV(TAG, "OTA features is 0x%02X", ota_features);
@@ -189,7 +189,7 @@ void OTAComponent::handle_() {
     // Send nonce, 32 bytes hex MD5
     if (!this->writeall_(reinterpret_cast<uint8_t *>(sbuf), 32)) {
       ESP_LOGW(TAG, "Auth: Writing nonce failed!");
-      goto error;
+      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
 
     // prepare challenge
@@ -201,7 +201,7 @@ void OTAComponent::handle_() {
     // Receive cnonce, 32 bytes hex MD5
     if (!this->readall_(buf, 32)) {
       ESP_LOGW(TAG, "Auth: Reading cnonce failed!");
-      goto error;
+      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
     sbuf[32] = '\0';
     ESP_LOGV(TAG, "Auth: CNonce is %s", sbuf);
@@ -216,7 +216,7 @@ void OTAComponent::handle_() {
     // Receive result, 32 bytes hex MD5
     if (!this->readall_(buf + 64, 32)) {
       ESP_LOGW(TAG, "Auth: Reading response failed!");
-      goto error;
+      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
     sbuf[64 + 32] = '\0';
     ESP_LOGV(TAG, "Auth: Response is %s", sbuf + 64);
@@ -228,7 +228,7 @@ void OTAComponent::handle_() {
     if (!matches) {
       ESP_LOGW(TAG, "Auth failed! Passwords do not match!");
       error_code = OTA_RESPONSE_ERROR_AUTH_INVALID;
-      goto error;
+      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
   }
 #endif  // USE_OTA_PASSWORD
@@ -240,7 +240,7 @@ void OTAComponent::handle_() {
   // Read size, 4 bytes MSB first
   if (!this->readall_(buf, 4)) {
     ESP_LOGW(TAG, "Reading size failed!");
-    goto error;
+    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
   ota_size = 0;
   for (uint8_t i = 0; i < 4; i++) {
@@ -251,7 +251,7 @@ void OTAComponent::handle_() {
 
   error_code = backend->begin(ota_size);
   if (error_code != OTA_RESPONSE_OK)
-    goto error;
+    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   update_started = true;
 
   // Acknowledge prepare OK - 1 byte
@@ -261,7 +261,7 @@ void OTAComponent::handle_() {
   // Read binary MD5, 32 bytes
   if (!this->readall_(buf, 32)) {
     ESP_LOGW(TAG, "Reading binary MD5 checksum failed!");
-    goto error;
+    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
   sbuf[32] = '\0';
   ESP_LOGV(TAG, "Update: Binary MD5 is %s", sbuf);
@@ -277,23 +277,24 @@ void OTAComponent::handle_() {
     ssize_t read = this->client_->read(buf, requested);
     if (read == -1) {
       if (errno == EAGAIN || errno == EWOULDBLOCK) {
+        App.feed_wdt();
         delay(1);
         continue;
       }
       ESP_LOGW(TAG, "Error receiving data for update, errno: %d", errno);
-      goto error;
+      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     } else if (read == 0) {
       // $ man recv
       // "When  a  stream socket peer has performed an orderly shutdown, the return value will
       // be 0 (the traditional "end-of-file" return)."
       ESP_LOGW(TAG, "Remote end closed connection");
-      goto error;
+      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
 
     error_code = backend->write(buf, read);
     if (error_code != OTA_RESPONSE_OK) {
       ESP_LOGW(TAG, "Error writing binary data to flash!");
-      goto error;
+      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
     total += read;
 
@@ -305,8 +306,9 @@ void OTAComponent::handle_() {
 #ifdef USE_OTA_STATE_CALLBACK
       this->state_callback_.call(OTA_IN_PROGRESS, percentage, 0);
 #endif
-      // slow down OTA update to avoid getting killed by task watchdog (task_wdt)
-      delay(10);
+      // feed watchdog and give other tasks a chance to run
+      App.feed_wdt();
+      yield();
     }
   }
 
@@ -317,7 +319,7 @@ void OTAComponent::handle_() {
   error_code = backend->end();
   if (error_code != OTA_RESPONSE_OK) {
     ESP_LOGW(TAG, "Error ending OTA!");
-    goto error;
+    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
 
   // Acknowledge Update end OK - 1 byte
@@ -370,6 +372,7 @@ bool OTAComponent::readall_(uint8_t *buf, size_t len) {
     ssize_t read = this->client_->read(buf + at, len - at);
     if (read == -1) {
       if (errno == EAGAIN || errno == EWOULDBLOCK) {
+        App.feed_wdt();
         delay(1);
         continue;
       }
@@ -381,6 +384,7 @@ bool OTAComponent::readall_(uint8_t *buf, size_t len) {
     } else {
       at += read;
     }
+    App.feed_wdt();
     delay(1);
   }
 
@@ -399,6 +403,7 @@ bool OTAComponent::writeall_(const uint8_t *buf, size_t len) {
     ssize_t written = this->client_->write(buf + at, len - at);
     if (written == -1) {
       if (errno == EAGAIN || errno == EWOULDBLOCK) {
+        App.feed_wdt();
         delay(1);
         continue;
       }
@@ -407,6 +412,7 @@ bool OTAComponent::writeall_(const uint8_t *buf, size_t len) {
     } else {
       at += written;
     }
+    App.feed_wdt();
     delay(1);
   }
   return true;

esphome/components/packages/__init__.py

@@ -10,6 +10,8 @@ from esphome.const import (
     CONF_REF,
     CONF_REFRESH,
     CONF_URL,
+    CONF_USERNAME,
+    CONF_PASSWORD,
 )
 import esphome.config_validation as cv
 
@@ -93,6 +95,8 @@ BASE_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.Required(CONF_URL): cv.url,
+            cv.Optional(CONF_USERNAME): cv.string,
+            cv.Optional(CONF_PASSWORD): cv.string,
             cv.Exclusive(CONF_FILE, "files"): validate_yaml_filename,
             cv.Exclusive(CONF_FILES, "files"): cv.All(
                 cv.ensure_list(validate_yaml_filename),
@@ -124,6 +128,8 @@ def _process_base_package(config: dict) -> dict:
         ref=config.get(CONF_REF),
         refresh=config[CONF_REFRESH],
         domain=DOMAIN,
+        username=config.get(CONF_USERNAME),
+        password=config.get(CONF_PASSWORD),
     )
     files: str = config[CONF_FILES]
 

esphome/components/pid/pid_autotuner.cpp

@@ -330,7 +330,7 @@ bool PIDAutotuner::OscillationAmplitudeDetector::has_enough_data() const {
 float PIDAutotuner::OscillationAmplitudeDetector::get_mean_oscillation_amplitude() const {
   float total_amplitudes = 0;
   size_t total_amplitudes_n = 0;
-  for (int i = 1; i < std::min(phase_mins.size(), phase_maxs.size()) - 1; i++) {
+  for (size_t i = 1; i < std::min(phase_mins.size(), phase_maxs.size()) - 1; i++) {
     total_amplitudes += std::abs(phase_maxs[i] - phase_mins[i + 1]);
     total_amplitudes_n++;
   }

esphome/components/pipsolar/pipsolar.cpp

@@ -413,8 +413,6 @@ void Pipsolar::loop() {
         this->state_ = STATE_IDLE;
         break;
       case POLLING_QT:
-        this->state_ = STATE_IDLE;
-        break;
       case POLLING_QMN:
         this->state_ = STATE_IDLE;
         break;
@@ -481,7 +479,7 @@ void Pipsolar::loop() {
         ESP_LOGD(TAG, "Decode QFLAG");
         // result like:"(EbkuvxzDajy"
         // get through all char: ignore first "(" Enable flag on 'E', Disable on 'D') else set the corresponding value
-        for (int i = 1; i < strlen(tmp); i++) {
+        for (size_t i = 1; i < strlen(tmp); i++) {
           switch (tmp[i]) {
             case 'E':
               enabled = true;
@@ -530,7 +528,7 @@ void Pipsolar::loop() {
         this->value_warnings_present_ = false;
         this->value_faults_present_ = true;
 
-        for (int i = 1; i < strlen(tmp); i++) {
+        for (size_t i = 1; i < strlen(tmp); i++) {
           enabled = tmp[i] == '1';
           switch (i) {
             case 1:

esphome/components/pn532/pn532.cpp

@@ -145,7 +145,7 @@ void PN532::loop() {
 
   if (nfcid.size() == this->current_uid_.size()) {
     bool same_uid = false;
-    for (uint8_t i = 0; i < nfcid.size(); i++)
+    for (size_t i = 0; i < nfcid.size(); i++)
       same_uid |= nfcid[i] == this->current_uid_[i];
     if (same_uid)
       return;
@@ -367,7 +367,7 @@ bool PN532BinarySensor::process(std::vector<uint8_t> &data) {
   if (data.size() != this->uid_.size())
     return false;
 
-  for (uint8_t i = 0; i < data.size(); i++) {
+  for (size_t i = 0; i < data.size(); i++) {
     if (data[i] != this->uid_[i])
       return false;
   }

esphome/components/pn532_spi/pn532_spi.cpp

@@ -26,7 +26,7 @@ bool PN532Spi::write_data(const std::vector<uint8_t> &data) {
   delay(2);
   // First byte, communication mode: Write data
   this->write_byte(0x01);
-  ESP_LOGV(TAG, "Writing data: %s", hexencode(data).c_str());
+  ESP_LOGV(TAG, "Writing data: %s", format_hex_pretty(data).c_str());
   this->write_array(data.data(), data.size());
   this->disable();
 
@@ -65,7 +65,7 @@ bool PN532Spi::read_data(std::vector<uint8_t> &data, uint8_t len) {
   this->read_array(data.data(), len);
   this->disable();
   data.insert(data.begin(), 0x01);
-  ESP_LOGV(TAG, "Read data: %s", hexencode(data).c_str());
+  ESP_LOGV(TAG, "Read data: %s", format_hex_pretty(data).c_str());
   return true;
 }
 
@@ -97,7 +97,7 @@ bool PN532Spi::read_response(uint8_t command, std::vector<uint8_t> &data) {
   std::vector<uint8_t> header(7);
   this->read_array(header.data(), 7);
 
-  ESP_LOGV(TAG, "Header data: %s", hexencode(header).c_str());
+  ESP_LOGV(TAG, "Header data: %s", format_hex_pretty(header).c_str());
 
   if (header[0] != 0x00 && header[1] != 0x00 && header[2] != 0xFF) {
     // invalid packet
@@ -127,7 +127,7 @@ bool PN532Spi::read_response(uint8_t command, std::vector<uint8_t> &data) {
   this->read_array(data.data(), len + 1);
   this->disable();
 
-  ESP_LOGV(TAG, "Response data: %s", hexencode(data).c_str());
+  ESP_LOGV(TAG, "Response data: %s", format_hex_pretty(data).c_str());
 
   uint8_t checksum = header[5] + header[6];  // TFI + Command response code
   for (int i = 0; i < len - 1; i++) {

esphome/components/pulse_meter/pulse_meter_sensor.cpp

@@ -35,7 +35,7 @@ void PulseMeterSensor::loop() {
       this->publish_state(0);
     } else {
       // Calculate pulses/min from the pulse width in ms
-      this->publish_state((60.0 * 1000.0) / pulse_width_ms);
+      this->publish_state((60.0f * 1000.0f) / pulse_width_ms);
     }
   }
 

esphome/components/rc522/rc522.cpp

@@ -28,7 +28,7 @@ std::string format_buffer(uint8_t *b, uint8_t len) {
 std::string format_uid(std::vector<uint8_t> &uid) {
   char buf[32];
   int offset = 0;
-  for (uint8_t i = 0; i < uid.size(); i++) {
+  for (size_t i = 0; i < uid.size(); i++) {
     const char *format = "%02X";
     if (i + 1 < uid.size())
       format = "%02X-";
@@ -479,7 +479,7 @@ bool RC522BinarySensor::process(std::vector<uint8_t> &data) {
   if (data.size() != this->uid_.size())
     result = false;
   else {
-    for (uint8_t i = 0; i < data.size(); i++) {
+    for (size_t i = 0; i < data.size(); i++) {
       if (data[i] != this->uid_[i]) {
         result = false;
         break;

esphome/components/remote_base/midea_protocol.h

@@ -26,7 +26,7 @@ class MideaData {
   bool is_valid() const { return this->data_[OFFSET_CS] == this->calc_cs_(); }
   void finalize() { this->data_[OFFSET_CS] = this->calc_cs_(); }
   bool check_compliment(const MideaData &rhs) const;
-  std::string to_string() const { return hexencode(*this); }
+  std::string to_string() const { return format_hex_pretty(this->data_, sizeof(this->data_)); }
   // compare only 40-bits
   bool operator==(const MideaData &rhs) const { return !memcmp(this->data_, rhs.data_, OFFSET_CS); }
   enum MideaDataType : uint8_t {

esphome/components/remote_base/pronto_protocol.cpp

@@ -113,7 +113,7 @@ void ProntoProtocol::send_pronto_(RemoteTransmitData *dst, const std::string &st
   const char *p = str.c_str();
   char *endptr[1];
 
-  for (uint16_t i = 0; i < len; i++) {
+  for (size_t i = 0; i < len; i++) {
     uint16_t x = strtol(p, endptr, 16);
     if (x == 0 && i >= NUMBERS_IN_PREAMBLE) {
       // Alignment error?, bail immediately (often right result).

esphome/components/remote_base/remote_base.cpp

@@ -33,7 +33,7 @@ void RemoteTransmitterBase::send_(uint32_t send_times, uint32_t send_wait) {
   uint32_t buffer_offset = 0;
   buffer_offset += sprintf(buffer, "Sending times=%u wait=%ums: ", send_times, send_wait);
 
-  for (int32_t i = 0; i < vec.size(); i++) {
+  for (size_t i = 0; i < vec.size(); i++) {
     const int32_t value = vec[i];
     const uint32_t remaining_length = sizeof(buffer) - buffer_offset;
     int written;

esphome/components/remote_transmitter/remote_transmitter_esp32.cpp

@@ -113,7 +113,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     this->rmt_temp_.push_back(rmt_item);
   }
 
-  for (uint16_t i = 0; i < send_times; i++) {
+  for (uint32_t i = 0; i < send_times; i++) {
     esp_err_t error = rmt_write_items(this->channel_, this->rmt_temp_.data(), this->rmt_temp_.size(), true);
     if (error != ESP_OK) {
       ESP_LOGW(TAG, "rmt_write_items failed: %s", esp_err_to_name(error));

esphome/components/restart/button/__init__.py

@@ -0,0 +1,25 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import button
+from esphome.const import (
+    CONF_ID,
+    DEVICE_CLASS_RESTART,
+    ENTITY_CATEGORY_CONFIG,
+)
+
+restart_ns = cg.esphome_ns.namespace("restart")
+RestartButton = restart_ns.class_("RestartButton", button.Button, cg.Component)
+
+CONFIG_SCHEMA = (
+    button.button_schema(
+        device_class=DEVICE_CLASS_RESTART, entity_category=ENTITY_CATEGORY_CONFIG
+    )
+    .extend({cv.GenerateID(): cv.declare_id(RestartButton)})
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await button.register_button(var, config)

esphome/components/restart/button/restart_button.cpp

@@ -0,0 +1,20 @@
+#include "restart_button.h"
+#include "esphome/core/application.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace restart {
+
+static const char *const TAG = "restart.button";
+
+void RestartButton::press_action() {
+  ESP_LOGI(TAG, "Restarting device...");
+  // Let MQTT settle a bit
+  delay(100);  // NOLINT
+  App.safe_reboot();
+}
+void RestartButton::dump_config() { LOG_BUTTON("", "Restart Button", this); }
+
+}  // namespace restart
+}  // namespace esphome

esphome/components/restart/button/restart_button.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/button/button.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace restart {
+
+class RestartButton : public button::Button, public Component {
+ public:
+  void dump_config() override;
+
+ protected:
+  void press_action() override;
+};
+
+}  // namespace restart
+}  // namespace esphome

esphome/components/rtttl/rtttl.cpp

@@ -159,7 +159,7 @@ void Rtttl::loop() {
   // Now play the note
   if (note) {
     auto note_index = (scale - 4) * 12 + note;
-    if (note_index < 0 || note_index >= sizeof(NOTES)) {
+    if (note_index < 0 || note_index >= (int) sizeof(NOTES)) {
       ESP_LOGE(TAG, "Note out of valid range");
       return;
     }

esphome/components/safe_mode/button/__init__.py

@@ -0,0 +1,27 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import button
+from esphome.const import (
+    CONF_ID,
+    ENTITY_CATEGORY_CONFIG,
+    ICON_RESTART_ALERT,
+)
+from .. import safe_mode_ns
+
+CODEOWNERS = ["@jesserockz"]
+
+SafeModeButton = safe_mode_ns.class_("SafeModeButton", button.Button, cg.Component)
+
+CONFIG_SCHEMA = (
+    button.button_schema(
+        entity_category=ENTITY_CATEGORY_CONFIG, icon=ICON_RESTART_ALERT
+    )
+    .extend({cv.GenerateID(): cv.declare_id(SafeModeButton)})
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await button.register_button(var, config)

esphome/components/safe_mode/button/safe_mode_button.cpp

@@ -0,0 +1,24 @@
+#include "safe_mode_button.h"
+#include "esphome/core/application.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace safe_mode {
+
+static const char *const TAG = "safe_mode.button";
+
+void SafeModeButton::set_ota(ota::OTAComponent *ota) { this->ota_ = ota; }
+
+void SafeModeButton::press_action() {
+  ESP_LOGI(TAG, "Restarting device in safe mode...");
+  this->ota_->set_safe_mode_pending(true);
+
+  // Let MQTT settle a bit
+  delay(100);  // NOLINT
+  App.safe_reboot();
+}
+void SafeModeButton::dump_config() { LOG_BUTTON("", "Safe Mode Button", this); }
+
+}  // namespace safe_mode
+}  // namespace esphome

esphome/components/safe_mode/button/safe_mode_button.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "esphome/components/button/button.h"
+#include "esphome/components/ota/ota_component.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace safe_mode {
+
+class SafeModeButton : public button::Button, public Component {
+ public:
+  void dump_config() override;
+  void set_ota(ota::OTAComponent *ota);
+
+ protected:
+  ota::OTAComponent *ota_;
+  void press_action() override;
+};
+
+}  // namespace safe_mode
+}  // namespace esphome

esphome/components/scd30/scd30.cpp

@@ -200,6 +200,7 @@ bool SCD30Component::is_data_ready_() {
   if (!this->write_command_(SCD30_CMD_GET_DATA_READY_STATUS)) {
     return false;
   }
+  delay(4);
   uint16_t is_data_ready;
   if (!this->read_data_(&is_data_ready, 1)) {
     return false;

esphome/components/sensor/__init__.py

@@ -19,6 +19,7 @@ from esphome.const import (
     CONF_ON_RAW_VALUE,
     CONF_ON_VALUE,
     CONF_ON_VALUE_RANGE,
+    CONF_QUANTILE,
     CONF_SEND_EVERY,
     CONF_SEND_FIRST_AT,
     CONF_STATE_CLASS,
@@ -151,6 +152,7 @@ SensorPublishAction = sensor_ns.class_("SensorPublishAction", automation.Action)
 
 # Filters
 Filter = sensor_ns.class_("Filter")
+QuantileFilter = sensor_ns.class_("QuantileFilter", Filter)
 MedianFilter = sensor_ns.class_("MedianFilter", Filter)
 MinFilter = sensor_ns.class_("MinFilter", Filter)
 MaxFilter = sensor_ns.class_("MaxFilter", Filter)
@@ -285,6 +287,30 @@ async def filter_out_filter_to_code(config, filter_id):
     return cg.new_Pvariable(filter_id, config)
 
 
+QUANTILE_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.Optional(CONF_WINDOW_SIZE, default=5): cv.positive_not_null_int,
+            cv.Optional(CONF_SEND_EVERY, default=5): cv.positive_not_null_int,
+            cv.Optional(CONF_SEND_FIRST_AT, default=1): cv.positive_not_null_int,
+            cv.Optional(CONF_QUANTILE, default=0.9): cv.zero_to_one_float,
+        }
+    ),
+    validate_send_first_at,
+)
+
+
+@FILTER_REGISTRY.register("quantile", QuantileFilter, QUANTILE_SCHEMA)
+async def quantile_filter_to_code(config, filter_id):
+    return cg.new_Pvariable(
+        filter_id,
+        config[CONF_WINDOW_SIZE],
+        config[CONF_SEND_EVERY],
+        config[CONF_SEND_FIRST_AT],
+        config[CONF_QUANTILE],
+    )
+
+
 MEDIAN_SCHEMA = cv.All(
     cv.Schema(
         {

esphome/components/sensor/filter.cpp

@@ -1,7 +1,8 @@
 #include "filter.h"
-#include "sensor.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+#include "sensor.h"
+#include <cmath>
 
 namespace esphome {
 namespace sensor {
@@ -66,6 +67,41 @@ optional<float> MedianFilter::new_value(float value) {
   return {};
 }
 
+// QuantileFilter
+QuantileFilter::QuantileFilter(size_t window_size, size_t send_every, size_t send_first_at, float quantile)
+    : send_every_(send_every), send_at_(send_every - send_first_at), window_size_(window_size), quantile_(quantile) {}
+void QuantileFilter::set_send_every(size_t send_every) { this->send_every_ = send_every; }
+void QuantileFilter::set_window_size(size_t window_size) { this->window_size_ = window_size; }
+void QuantileFilter::set_quantile(float quantile) { this->quantile_ = quantile; }
+optional<float> QuantileFilter::new_value(float value) {
+  if (!std::isnan(value)) {
+    while (this->queue_.size() >= this->window_size_) {
+      this->queue_.pop_front();
+    }
+    this->queue_.push_back(value);
+    ESP_LOGVV(TAG, "QuantileFilter(%p)::new_value(%f), quantile:%f", this, value, this->quantile_);
+  }
+
+  if (++this->send_at_ >= this->send_every_) {
+    this->send_at_ = 0;
+
+    float result = 0.0f;
+    if (!this->queue_.empty()) {
+      std::deque<float> quantile_queue = this->queue_;
+      sort(quantile_queue.begin(), quantile_queue.end());
+
+      size_t queue_size = quantile_queue.size();
+      size_t position = ceilf(queue_size * this->quantile_) - 1;
+      ESP_LOGVV(TAG, "QuantileFilter(%p)::position: %d/%d", this, position, queue_size);
+      result = quantile_queue[position];
+    }
+
+    ESP_LOGVV(TAG, "QuantileFilter(%p)::new_value(%f) SENDING", this, result);
+    return result;
+  }
+  return {};
+}
+
 // MinFilter
 MinFilter::MinFilter(size_t window_size, size_t send_every, size_t send_first_at)
     : send_every_(send_every), send_at_(send_every - send_first_at), window_size_(window_size) {}

esphome/components/sensor/filter.h

@@ -42,6 +42,37 @@ class Filter {
   Sensor *parent_{nullptr};
 };
 
+/** Simple quantile filter.
+ *
+ * Takes the quantile of the last <send_every> values and pushes it out every <send_every>.
+ */
+class QuantileFilter : public Filter {
+ public:
+  /** Construct a QuantileFilter.
+   *
+   * @param window_size The number of values that should be used in quantile calculation.
+   * @param send_every After how many sensor values should a new one be pushed out.
+   * @param send_first_at After how many values to forward the very first value. Defaults to the first value
+   *   on startup being published on the first *raw* value, so with no filter applied. Must be less than or equal to
+   *   send_every.
+   * @param quantile float 0..1 to pick the requested quantile. Defaults to 0.9.
+   */
+  explicit QuantileFilter(size_t window_size, size_t send_every, size_t send_first_at, float quantile);
+
+  optional<float> new_value(float value) override;
+
+  void set_send_every(size_t send_every);
+  void set_window_size(size_t window_size);
+  void set_quantile(float quantile);
+
+ protected:
+  std::deque<float> queue_;
+  size_t send_every_;
+  size_t send_at_;
+  size_t window_size_;
+  float quantile_;
+};
+
 /** Simple median filter.
  *
  * Takes the median of the last <send_every> values and pushes it out every <send_every>.

esphome/components/sgp30/sgp30.cpp

@@ -147,8 +147,8 @@ void SGP30Component::read_iaq_baseline_() {
         // much
         if (this->store_baseline_ &&
             (this->seconds_since_last_store_ > SHORTEST_BASELINE_STORE_INTERVAL ||
-             abs(this->baselines_storage_.eco2 - this->eco2_baseline_) > MAXIMUM_STORAGE_DIFF ||
-             abs(this->baselines_storage_.tvoc - this->tvoc_baseline_) > MAXIMUM_STORAGE_DIFF)) {
+             (uint32_t) abs(this->baselines_storage_.eco2 - this->eco2_baseline_) > MAXIMUM_STORAGE_DIFF ||
+             (uint32_t) abs(this->baselines_storage_.tvoc - this->tvoc_baseline_) > MAXIMUM_STORAGE_DIFF)) {
           this->seconds_since_last_store_ = 0;
           this->baselines_storage_.eco2 = this->eco2_baseline_;
           this->baselines_storage_.tvoc = this->tvoc_baseline_;

esphome/components/sgp40/sensirion_voc_algorithm.cpp

@@ -149,7 +149,7 @@ static fix16_t fix16_div(fix16_t a, fix16_t b) {
   /* Figure out the sign of result */
   if ((a ^ b) & 0x80000000) {
 #ifndef FIXMATH_NO_OVERFLOW
-    if (result == FIX16_MINIMUM)
+    if (result == FIX16_MINIMUM)  // NOLINT(clang-diagnostic-sign-compare)
       return FIX16_OVERFLOW;
 #endif
 

esphome/components/sgp40/sgp40.cpp

@@ -144,8 +144,8 @@ int32_t SGP40Component::measure_voc_index_() {
   // much
   if (this->store_baseline_ && this->seconds_since_last_store_ > SHORTEST_BASELINE_STORE_INTERVAL) {
     voc_algorithm_get_states(&voc_algorithm_params_, &this->state0_, &this->state1_);
-    if (abs(this->baselines_storage_.state0 - this->state0_) > MAXIMUM_STORAGE_DIFF ||
-        abs(this->baselines_storage_.state1 - this->state1_) > MAXIMUM_STORAGE_DIFF) {
+    if ((uint32_t) abs(this->baselines_storage_.state0 - this->state0_) > MAXIMUM_STORAGE_DIFF ||
+        (uint32_t) abs(this->baselines_storage_.state1 - this->state1_) > MAXIMUM_STORAGE_DIFF) {
       this->seconds_since_last_store_ = 0;
       this->baselines_storage_.state0 = this->state0_;
       this->baselines_storage_.state1 = this->state1_;

esphome/components/sgp40/sgp40.h

@@ -66,7 +66,7 @@ class SGP40Component : public PollingComponent, public sensor::Sensor, public i2
   uint8_t generate_crc_(const uint8_t *data, uint8_t datalen);
   uint16_t measure_raw_();
   ESPPreferenceObject pref_;
-  int32_t seconds_since_last_store_;
+  uint32_t seconds_since_last_store_;
   SGP40Baselines baselines_storage_;
   VocAlgorithmParams voc_algorithm_params_;
   bool self_test_complete_;

esphome/components/sm300d2/sm300d2.cpp

@@ -50,10 +50,10 @@ void SM300D2Sensor::update() {
   const uint16_t pm_2_5 = (response[8] * 256) + response[9];
   const uint16_t pm_10_0 = (response[10] * 256) + response[11];
   // A negative value is indicated by adding 0x80 (128) to the temperature value
-  const float temperature = ((response[12] + (response[13] * 0.1)) > 128)
-                                ? (((response[12] + (response[13] * 0.1)) - 128) * -1)
-                                : response[12] + (response[13] * 0.1);
-  const float humidity = response[14] + (response[15] * 0.1);
+  const float temperature = ((response[12] + (response[13] * 0.1f)) > 128)
+                                ? (((response[12] + (response[13] * 0.1f)) - 128) * -1)
+                                : response[12] + (response[13] * 0.1f);
+  const float humidity = response[14] + (response[15] * 0.1f);
 
   ESP_LOGD(TAG, "Received CO₂: %u ppm", co2);
   if (this->co2_sensor_ != nullptr)

esphome/components/socket/lwip_raw_tcp_impl.cpp

@@ -383,7 +383,7 @@ class LWIPRawImpl : public Socket {
         return err;
       }
       ret += err;
-      if (err != iov[i].iov_len)
+      if ((size_t) err != iov[i].iov_len)
         break;
     }
     return ret;
@@ -462,7 +462,7 @@ class LWIPRawImpl : public Socket {
         return err;
       }
       written += err;
-      if (err != iov[i].iov_len)
+      if ((size_t) err != iov[i].iov_len)
         break;
     }
     if (written == 0)

esphome/components/spi/spi.cpp

@@ -55,13 +55,9 @@ void SPIComponent::setup() {
     }
   }
 #ifdef USE_ESP8266
-  if (clk_pin == 6 && miso_pin == 7 && mosi_pin == 8) {
-    // pass
-  } else if (clk_pin == 14 && (!has_miso || miso_pin == 12) && (!has_mosi || mosi_pin == 13)) {
-    // pass
-  } else {
+  if (!(clk_pin == 6 && miso_pin == 7 && mosi_pin == 8) &&
+      !(clk_pin == 14 && (!has_miso || miso_pin == 12) && (!has_mosi || mosi_pin == 13)))
     use_hw_spi = false;
-  }
 
   if (use_hw_spi) {
     this->hw_spi_ = &SPI;

esphome/components/spi/spi.h

@@ -195,7 +195,14 @@ class SPIComponent : public Component {
   void enable(GPIOPin *cs) {
 #ifdef USE_SPI_ARDUINO_BACKEND
     if (this->hw_spi_ != nullptr) {
-      uint8_t data_mode = (uint8_t(CLOCK_POLARITY) << 1) | uint8_t(CLOCK_PHASE);
+      uint8_t data_mode = SPI_MODE0;
+      if (!CLOCK_POLARITY && CLOCK_PHASE) {
+        data_mode = SPI_MODE1;
+      } else if (CLOCK_POLARITY && !CLOCK_PHASE) {
+        data_mode = SPI_MODE2;
+      } else if (CLOCK_POLARITY && CLOCK_PHASE) {
+        data_mode = SPI_MODE3;
+      }
       SPISettings settings(DATA_RATE, BIT_ORDER, data_mode);
       this->hw_spi_->beginTransaction(settings);
     } else {

esphome/components/sps30/sps30.cpp

@@ -32,14 +32,11 @@ void SPS30Component::setup() {
       return;
     }
 
-    uint16_t raw_firmware_version[4];
-    if (!this->read_data_(raw_firmware_version, 4)) {
+    if (!this->read_data_(&raw_firmware_version_, 1)) {
       this->error_code_ = FIRMWARE_VERSION_READ_FAILED;
       this->mark_failed();
       return;
     }
-    ESP_LOGD(TAG, "  Firmware version v%0d.%02d", (raw_firmware_version[0] >> 8),
-             uint16_t(raw_firmware_version[0] & 0xFF));
     /// Serial number identification
     if (!this->write_command_(SPS30_CMD_GET_SERIAL_NUMBER)) {
       this->error_code_ = SERIAL_NUMBER_REQUEST_FAILED;
@@ -59,6 +56,8 @@ void SPS30Component::setup() {
       this->serial_number_[i * 2 + 1] = uint16_t(uint16_t(raw_serial_number[i] & 0xFF));
     }
     ESP_LOGD(TAG, "  Serial Number: '%s'", this->serial_number_);
+    this->status_clear_warning();
+    this->skipped_data_read_cycles_ = 0;
     this->start_continuous_measurement_();
   });
 }
@@ -93,10 +92,17 @@ void SPS30Component::dump_config() {
   }
   LOG_UPDATE_INTERVAL(this);
   ESP_LOGCONFIG(TAG, "  Serial Number: '%s'", this->serial_number_);
-  LOG_SENSOR("  ", "PM1.0", this->pm_1_0_sensor_);
-  LOG_SENSOR("  ", "PM2.5", this->pm_2_5_sensor_);
-  LOG_SENSOR("  ", "PM4", this->pm_4_0_sensor_);
-  LOG_SENSOR("  ", "PM10", this->pm_10_0_sensor_);
+  ESP_LOGCONFIG(TAG, "  Firmware version v%0d.%0d", (raw_firmware_version_ >> 8),
+                uint16_t(raw_firmware_version_ & 0xFF));
+  LOG_SENSOR("  ", "PM1.0 Weight Concentration", this->pm_1_0_sensor_);
+  LOG_SENSOR("  ", "PM2.5 Weight Concentration", this->pm_2_5_sensor_);
+  LOG_SENSOR("  ", "PM4 Weight Concentration", this->pm_4_0_sensor_);
+  LOG_SENSOR("  ", "PM10 Weight Concentration", this->pm_10_0_sensor_);
+  LOG_SENSOR("  ", "PM1.0 Number Concentration", this->pmc_1_0_sensor_);
+  LOG_SENSOR("  ", "PM2.5 Number Concentration", this->pmc_2_5_sensor_);
+  LOG_SENSOR("  ", "PM4 Number Concentration", this->pmc_4_0_sensor_);
+  LOG_SENSOR("  ", "PM10 Number Concentration", this->pmc_10_0_sensor_);
+  LOG_SENSOR("  ", "PM typical size", this->pm_size_sensor_);
 }
 
 void SPS30Component::update() {
@@ -123,8 +129,8 @@ void SPS30Component::update() {
     return;
   }
 
-  uint16_t raw_read_status[1];
-  if (!this->read_data_(raw_read_status, 1) || raw_read_status[0] == 0x00) {
+  uint16_t raw_read_status;
+  if (!this->read_data_(&raw_read_status, 1) || raw_read_status == 0x00) {
     ESP_LOGD(TAG, "Sensor measurement not ready yet.");
     this->skipped_data_read_cycles_++;
     /// The following logic is required to address the cases when a sensor is quickly replaced before it's marked

esphome/components/sps30/sps30.h

@@ -33,6 +33,7 @@ class SPS30Component : public PollingComponent, public i2c::I2CDevice {
   bool read_data_(uint16_t *data, uint8_t len);
   uint8_t sht_crc_(uint8_t data1, uint8_t data2);
   char serial_number_[17] = {0};  /// Terminating NULL character
+  uint16_t raw_firmware_version_;
   bool start_continuous_measurement_();
   uint8_t skipped_data_read_cycles_ = 0;
 

esphome/components/ssd1306_base/ssd1306_base.cpp

@@ -292,7 +292,7 @@ const char *SSD1306::model_str_() {
     case SSD1305_MODEL_128_32:
       return "SSD1305 128x32";
     case SSD1305_MODEL_128_64:
-      return "SSD1305 128x32";
+      return "SSD1305 128x64";
     default:
       return "Unknown";
   }

esphome/components/ssd1306_i2c/ssd1306_i2c.cpp

@@ -40,12 +40,12 @@ void I2CSSD1306::command(uint8_t value) { this->write_byte(0x00, value); }
 void HOT I2CSSD1306::write_display_data() {
   if (this->is_sh1106_()) {
     uint32_t i = 0;
-    for (uint8_t page = 0; page < this->get_height_internal() / 8; page++) {
+    for (uint8_t page = 0; page < (uint8_t) this->get_height_internal() / 8; page++) {
       this->command(0xB0 + page);  // row
       this->command(0x02);         // lower column
       this->command(0x10);         // higher column
 
-      for (uint8_t x = 0; x < this->get_width_internal() / 16; x++) {
+      for (uint8_t x = 0; x < (uint8_t) this->get_width_internal() / 16; x++) {
         uint8_t data[16];
         for (uint8_t &j : data)
           j = this->buffer_[i++];

esphome/components/ssd1306_spi/ssd1306_spi.cpp

@@ -37,12 +37,12 @@ void SPISSD1306::command(uint8_t value) {
 }
 void HOT SPISSD1306::write_display_data() {
   if (this->is_sh1106_()) {
-    for (uint8_t y = 0; y < this->get_height_internal() / 8; y++) {
+    for (uint8_t y = 0; y < (uint8_t) this->get_height_internal() / 8; y++) {
       this->command(0xB0 + y);
       this->command(0x02);
       this->command(0x10);
       this->dc_pin_->digital_write(true);
-      for (uint8_t x = 0; x < this->get_width_internal(); x++) {
+      for (uint8_t x = 0; x < (uint8_t) this->get_width_internal(); x++) {
         this->enable();
         this->write_byte(this->buffer_[x + y * this->get_width_internal()]);
         this->disable();

esphome/components/st7735/st7735.cpp

@@ -275,7 +275,7 @@ void ST7735::setup() {
 
   uint8_t data = 0;
   if (this->model_ != INITR_HALLOWING) {
-    uint8_t data = ST77XX_MADCTL_MX | ST77XX_MADCTL_MY;
+    data = ST77XX_MADCTL_MX | ST77XX_MADCTL_MY;
   }
   if (this->usebgr_) {
     data = data | ST7735_MADCTL_BGR;
@@ -446,7 +446,7 @@ void HOT ST7735::write_display_data_() {
   this->dc_pin_->digital_write(true);
 
   if (this->eightbitcolor_) {
-    for (int line = 0; line < this->get_buffer_length(); line = line + this->get_width_internal()) {
+    for (size_t line = 0; line < this->get_buffer_length(); line = line + this->get_width_internal()) {
       for (int index = 0; index < this->get_width_internal(); ++index) {
         auto color332 = display::ColorUtil::to_color(this->buffer_[index + line], display::ColorOrder::COLOR_ORDER_RGB,
                                                      display::ColorBitness::COLOR_BITNESS_332, true);

esphome/components/st7920/st7920.cpp

@@ -74,7 +74,7 @@ void ST7920::goto_xy_(uint16_t x, uint16_t y) {
 
 void HOT ST7920::write_display_data() {
   uint8_t i, j, b;
-  for (j = 0; j < this->get_height_internal() / 2; j++) {
+  for (j = 0; j < (uint8_t)(this->get_height_internal() / 2); j++) {
     this->goto_xy_(0, j);
     this->enable();
     for (i = 0; i < 16; i++) {  // 16 bytes from line #0+

esphome/components/teleinfo/teleinfo.cpp

@@ -118,7 +118,7 @@ void TeleInfo::loop() {
        *
        */
       while ((buf_finger = static_cast<char *>(memchr(buf_finger, (int) 0xa, buf_index_ - 1))) &&
-             ((buf_finger - buf_) < buf_index_)) {
+             ((buf_finger - buf_) < buf_index_)) {  // NOLINT(clang-diagnostic-sign-compare)
         /*
          * Make sure timesamp is nullified between each tag as some tags don't
          * have a timestamp

esphome/components/template/button/__init__.py

@@ -0,0 +1,13 @@
+import esphome.config_validation as cv
+from esphome.components import button
+
+
+CONFIG_SCHEMA = button.BUTTON_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(button.Button),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config):
+    await button.new_button(config)

esphome/components/text_sensor/__init__.py

@@ -49,6 +49,7 @@ ToLowerFilter = text_sensor_ns.class_("ToLowerFilter", Filter)
 AppendFilter = text_sensor_ns.class_("AppendFilter", Filter)
 PrependFilter = text_sensor_ns.class_("PrependFilter", Filter)
 SubstituteFilter = text_sensor_ns.class_("SubstituteFilter", Filter)
+MapFilter = text_sensor_ns.class_("MapFilter", Filter)
 
 
 @FILTER_REGISTRY.register("lambda", LambdaFilter, cv.returning_lambda)
@@ -79,26 +80,21 @@ async def prepend_filter_to_code(config, filter_id):
     return cg.new_Pvariable(filter_id, config)
 
 
-def validate_substitute(value):
-    if isinstance(value, dict):
-        return cv.Schema(
-            {
-                cv.Required(CONF_FROM): cv.string,
-                cv.Required(CONF_TO): cv.string,
-            }
-        )(value)
-    value = cv.string(value)
-    if "->" not in value:
-        raise cv.Invalid("Substitute mapping must contain '->'")
-    a, b = value.split("->", 1)
-    a, b = a.strip(), b.strip()
-    return validate_substitute({CONF_FROM: cv.string(a), CONF_TO: cv.string(b)})
+def validate_mapping(value):
+    if not isinstance(value, dict):
+        value = cv.string(value)
+        if "->" not in value:
+            raise cv.Invalid("Mapping must contain '->'")
+        a, b = value.split("->", 1)
+        value = {CONF_FROM: a.strip(), CONF_TO: b.strip()}
+
+    return cv.Schema(
+        {cv.Required(CONF_FROM): cv.string, cv.Required(CONF_TO): cv.string}
+    )(value)
 
 
 @FILTER_REGISTRY.register(
-    "substitute",
-    SubstituteFilter,
-    cv.All(cv.ensure_list(validate_substitute), cv.Length(min=2)),
+    "substitute", SubstituteFilter, cv.ensure_list(validate_mapping)
 )
 async def substitute_filter_to_code(config, filter_id):
     from_strings = [conf[CONF_FROM] for conf in config]
@@ -106,6 +102,14 @@ async def substitute_filter_to_code(config, filter_id):
     return cg.new_Pvariable(filter_id, from_strings, to_strings)
 
 
+@FILTER_REGISTRY.register("map", MapFilter, cv.ensure_list(validate_mapping))
+async def map_filter_to_code(config, filter_id):
+    map_ = cg.std_ns.class_("map").template(cg.std_string, cg.std_string)
+    return cg.new_Pvariable(
+        filter_id, map_([(item[CONF_FROM], item[CONF_TO]) for item in config])
+    )
+
+
 icon = cv.icon
 
 

esphome/components/text_sensor/filter.cpp

@@ -64,11 +64,17 @@ optional<std::string> PrependFilter::new_value(std::string value) { return this-
 // Substitute
 optional<std::string> SubstituteFilter::new_value(std::string value) {
   std::size_t pos;
-  for (int i = 0; i < this->from_strings_.size(); i++)
+  for (size_t i = 0; i < this->from_strings_.size(); i++)
     while ((pos = value.find(this->from_strings_[i])) != std::string::npos)
       value.replace(pos, this->from_strings_[i].size(), this->to_strings_[i]);
   return value;
 }
 
+// Map
+optional<std::string> MapFilter::new_value(std::string value) {
+  auto item = mappings_.find(value);
+  return item == mappings_.end() ? value : item->second;
+}
+
 }  // namespace text_sensor
 }  // namespace esphome

esphome/components/text_sensor/filter.h

@@ -4,6 +4,7 @@
 #include "esphome/core/helpers.h"
 #include <queue>
 #include <utility>
+#include <map>
 
 namespace esphome {
 namespace text_sensor {
@@ -108,5 +109,15 @@ class SubstituteFilter : public Filter {
   std::vector<std::string> to_strings_;
 };
 
+/// A filter that maps values from one set to another
+class MapFilter : public Filter {
+ public:
+  MapFilter(std::map<std::string, std::string> mappings) : mappings_(std::move(mappings)) {}
+  optional<std::string> new_value(std::string value) override;
+
+ protected:
+  std::map<std::string, std::string> mappings_;
+};
+
 }  // namespace text_sensor
 }  // namespace esphome

esphome/components/text_sensor/text_sensor.cpp

@@ -62,7 +62,7 @@ void TextSensor::add_on_raw_state_callback(std::function<void(std::string)> call
 std::string TextSensor::get_state() const { return this->state; }
 std::string TextSensor::get_raw_state() const { return this->raw_state; }
 void TextSensor::internal_send_state_to_frontend(const std::string &state) {
-  this->state = this->raw_state;
+  this->state = state;
   this->has_state_ = true;
   ESP_LOGD(TAG, "'%s': Sending state '%s'", this->name_.c_str(), state.c_str());
   this->callback_.call(state);

esphome/components/thermostat/climate.py

@@ -431,7 +431,8 @@ async def to_code(config):
 
     heat_cool_mode_available = CONF_HEAT_ACTION in config and CONF_COOL_ACTION in config
     two_points_available = CONF_HEAT_ACTION in config and (
-        CONF_COOL_ACTION in config or CONF_FAN_ONLY_ACTION in config
+        CONF_COOL_ACTION in config
+        or (config[CONF_FAN_ONLY_COOLING] and CONF_FAN_ONLY_ACTION in config)
     )
 
     sens = await cg.get_variable(config[CONF_SENSOR])

esphome/components/tlc59208f/tlc59208f_output.cpp

@@ -1,6 +1,7 @@
 #include "tlc59208f_output.h"
 #include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/hal.h"
 
 namespace esphome {
 namespace tlc59208f {

esphome/components/tof10120/tof10120_sensor.cpp

@@ -50,7 +50,7 @@ void TOF10120Sensor::update() {
     ESP_LOGW(TAG, "Distance measurement out of range");
     this->publish_state(NAN);
   } else {
-    this->publish_state(distance_mm / 1000.0);
+    this->publish_state(distance_mm / 1000.0f);
   }
   this->status_clear_warning();
 }

esphome/components/toshiba/toshiba.cpp

@@ -580,13 +580,13 @@ bool ToshibaClimate::on_receive(remote_base::RemoteReceiveData data) {
         temperature_code =
             (message[4] >> 4) | (message[14] & RAC_PT1411HWRU_FLAG_FRAC) | (message[15] & RAC_PT1411HWRU_FLAG_NEG);
         if (message[15] & RAC_PT1411HWRU_FLAG_FAH) {
-          for (uint8_t i = 0; i < RAC_PT1411HWRU_TEMPERATURE_F.size(); i++) {
+          for (size_t i = 0; i < RAC_PT1411HWRU_TEMPERATURE_F.size(); i++) {
             if (RAC_PT1411HWRU_TEMPERATURE_F[i] == temperature_code) {
               this->target_temperature = static_cast<float>((i + TOSHIBA_RAC_PT1411HWRU_TEMP_F_MIN - 32) * 5) / 9;
             }
           }
         } else {
-          for (uint8_t i = 0; i < RAC_PT1411HWRU_TEMPERATURE_C.size(); i++) {
+          for (size_t i = 0; i < RAC_PT1411HWRU_TEMPERATURE_C.size(); i++) {
             if (RAC_PT1411HWRU_TEMPERATURE_C[i] == temperature_code) {
               this->target_temperature = i + TOSHIBA_RAC_PT1411HWRU_TEMP_C_MIN;
             }

esphome/components/total_daily_energy/sensor.py

@@ -4,6 +4,7 @@ from esphome.components import sensor, time
 from esphome.const import (
     CONF_ICON,
     CONF_ID,
+    CONF_RESTORE,
     CONF_TIME_ID,
     DEVICE_CLASS_ENERGY,
     CONF_METHOD,
@@ -36,6 +37,7 @@ CONFIG_SCHEMA = (
             cv.GenerateID(): cv.declare_id(TotalDailyEnergy),
             cv.GenerateID(CONF_TIME_ID): cv.use_id(time.RealTimeClock),
             cv.Required(CONF_POWER_ID): cv.use_id(sensor.Sensor),
+            cv.Optional(CONF_RESTORE, default=True): cv.boolean,
             cv.Optional(
                 CONF_MIN_SAVE_INTERVAL, default="0s"
             ): cv.positive_time_period_milliseconds,
@@ -70,5 +72,6 @@ async def to_code(config):
     cg.add(var.set_parent(sens))
     time_ = await cg.get_variable(config[CONF_TIME_ID])
     cg.add(var.set_time(time_))
+    cg.add(var.set_restore(config[CONF_RESTORE]))
     cg.add(var.set_min_save_interval(config[CONF_MIN_SAVE_INTERVAL]))
     cg.add(var.set_method(config[CONF_METHOD]))

esphome/components/total_daily_energy/total_daily_energy.cpp

@@ -7,14 +7,14 @@ namespace total_daily_energy {
 static const char *const TAG = "total_daily_energy";
 
 void TotalDailyEnergy::setup() {
-  this->pref_ = global_preferences->make_preference<float>(this->get_object_id_hash());
+  float initial_value = 0;
 
-  float recovered;
-  if (this->pref_.load(&recovered)) {
-    this->publish_state_and_save(recovered);
-  } else {
-    this->publish_state_and_save(0);
+  if (this->restore_) {
+    this->pref_ = global_preferences->make_preference<float>(this->get_object_id_hash());
+    this->pref_.load(&initial_value);
   }
+  this->publish_state_and_save(initial_value);
+
   this->last_update_ = millis();
   this->last_save_ = this->last_update_;
 

esphome/components/total_daily_energy/total_daily_energy.h

@@ -17,6 +17,7 @@ enum TotalDailyEnergyMethod {
 
 class TotalDailyEnergy : public sensor::Sensor, public Component {
  public:
+  void set_restore(bool restore) { restore_ = restore; }
   void set_min_save_interval(uint32_t min_interval) { this->min_save_interval_ = min_interval; }
   void set_time(time::RealTimeClock *time) { time_ = time; }
   void set_parent(Sensor *parent) { parent_ = parent; }
@@ -41,6 +42,7 @@ class TotalDailyEnergy : public sensor::Sensor, public Component {
   uint32_t last_update_{0};
   uint32_t last_save_{0};
   uint32_t min_save_interval_{0};
+  bool restore_;
   float total_energy_{0.0f};
   float last_power_state_{0.0f};
 };

esphome/components/tuya/__init__.py

@@ -1,16 +1,84 @@
 from esphome.components import time
+from esphome import automation
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import uart
-from esphome.const import CONF_ID, CONF_TIME_ID
+from esphome.const import CONF_ID, CONF_TIME_ID, CONF_TRIGGER_ID, CONF_SENSOR_DATAPOINT
 
 DEPENDENCIES = ["uart"]
 
 CONF_IGNORE_MCU_UPDATE_ON_DATAPOINTS = "ignore_mcu_update_on_datapoints"
 
+CONF_ON_DATAPOINT_UPDATE = "on_datapoint_update"
+CONF_DATAPOINT_TYPE = "datapoint_type"
+
 tuya_ns = cg.esphome_ns.namespace("tuya")
 Tuya = tuya_ns.class_("Tuya", cg.Component, uart.UARTDevice)
 
+DPTYPE_ANY = "any"
+DPTYPE_RAW = "raw"
+DPTYPE_BOOL = "bool"
+DPTYPE_INT = "int"
+DPTYPE_UINT = "uint"
+DPTYPE_STRING = "string"
+DPTYPE_ENUM = "enum"
+DPTYPE_BITMASK = "bitmask"
+
+DATAPOINT_TYPES = {
+    DPTYPE_ANY: tuya_ns.struct("TuyaDatapoint"),
+    DPTYPE_RAW: cg.std_vector.template(cg.uint8),
+    DPTYPE_BOOL: cg.bool_,
+    DPTYPE_INT: cg.int_,
+    DPTYPE_UINT: cg.uint32,
+    DPTYPE_STRING: cg.std_string,
+    DPTYPE_ENUM: cg.uint8,
+    DPTYPE_BITMASK: cg.uint32,
+}
+
+DATAPOINT_TRIGGERS = {
+    DPTYPE_ANY: tuya_ns.class_(
+        "TuyaDatapointUpdateTrigger",
+        automation.Trigger.template(DATAPOINT_TYPES[DPTYPE_ANY]),
+    ),
+    DPTYPE_RAW: tuya_ns.class_(
+        "TuyaRawDatapointUpdateTrigger",
+        automation.Trigger.template(DATAPOINT_TYPES[DPTYPE_RAW]),
+    ),
+    DPTYPE_BOOL: tuya_ns.class_(
+        "TuyaBoolDatapointUpdateTrigger",
+        automation.Trigger.template(DATAPOINT_TYPES[DPTYPE_BOOL]),
+    ),
+    DPTYPE_INT: tuya_ns.class_(
+        "TuyaIntDatapointUpdateTrigger",
+        automation.Trigger.template(DATAPOINT_TYPES[DPTYPE_INT]),
+    ),
+    DPTYPE_UINT: tuya_ns.class_(
+        "TuyaUIntDatapointUpdateTrigger",
+        automation.Trigger.template(DATAPOINT_TYPES[DPTYPE_UINT]),
+    ),
+    DPTYPE_STRING: tuya_ns.class_(
+        "TuyaStringDatapointUpdateTrigger",
+        automation.Trigger.template(DATAPOINT_TYPES[DPTYPE_STRING]),
+    ),
+    DPTYPE_ENUM: tuya_ns.class_(
+        "TuyaEnumDatapointUpdateTrigger",
+        automation.Trigger.template(DATAPOINT_TYPES[DPTYPE_ENUM]),
+    ),
+    DPTYPE_BITMASK: tuya_ns.class_(
+        "TuyaBitmaskDatapointUpdateTrigger",
+        automation.Trigger.template(DATAPOINT_TYPES[DPTYPE_BITMASK]),
+    ),
+}
+
+
+def assign_declare_id(value):
+    value = value.copy()
+    value[CONF_TRIGGER_ID] = cv.declare_id(
+        DATAPOINT_TRIGGERS[value[CONF_DATAPOINT_TYPE]]
+    )(value[CONF_TRIGGER_ID].id)
+    return value
+
+
 CONF_TUYA_ID = "tuya_id"
 CONFIG_SCHEMA = (
     cv.Schema(
@@ -20,6 +88,18 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_IGNORE_MCU_UPDATE_ON_DATAPOINTS): cv.ensure_list(
                 cv.uint8_t
             ),
+            cv.Optional(CONF_ON_DATAPOINT_UPDATE): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        DATAPOINT_TRIGGERS[DPTYPE_ANY]
+                    ),
+                    cv.Required(CONF_SENSOR_DATAPOINT): cv.uint8_t,
+                    cv.Optional(CONF_DATAPOINT_TYPE, default=DPTYPE_ANY): cv.one_of(
+                        *DATAPOINT_TRIGGERS, lower=True
+                    ),
+                },
+                extra_validators=assign_declare_id,
+            ),
         }
     )
     .extend(cv.COMPONENT_SCHEMA)
@@ -37,3 +117,10 @@ async def to_code(config):
     if CONF_IGNORE_MCU_UPDATE_ON_DATAPOINTS in config:
         for dp in config[CONF_IGNORE_MCU_UPDATE_ON_DATAPOINTS]:
             cg.add(var.add_ignore_mcu_update_on_datapoints(dp))
+    for conf in config.get(CONF_ON_DATAPOINT_UPDATE, []):
+        trigger = cg.new_Pvariable(
+            conf[CONF_TRIGGER_ID], var, conf[CONF_SENSOR_DATAPOINT]
+        )
+        await automation.build_automation(
+            trigger, [(DATAPOINT_TYPES[conf[CONF_DATAPOINT_TYPE]], "x")], conf
+        )

esphome/components/tuya/automation.cpp

@@ -0,0 +1,67 @@
+#include "esphome/core/log.h"
+
+#include "automation.h"
+
+static const char *const TAG = "tuya.automation";
+
+namespace esphome {
+namespace tuya {
+
+void check_expected_datapoint(const TuyaDatapoint &dp, TuyaDatapointType expected) {
+  if (dp.type != expected) {
+    ESP_LOGW(TAG, "Tuya sensor %u expected datapoint type %#02hhX but got %#02hhX", dp.id,
+             static_cast<uint8_t>(expected), static_cast<uint8_t>(dp.type));
+  }
+}
+
+TuyaRawDatapointUpdateTrigger::TuyaRawDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id) {
+  parent->register_listener(sensor_id, [this](const TuyaDatapoint &dp) {
+    check_expected_datapoint(dp, TuyaDatapointType::RAW);
+    this->trigger(dp.value_raw);
+  });
+}
+
+TuyaBoolDatapointUpdateTrigger::TuyaBoolDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id) {
+  parent->register_listener(sensor_id, [this](const TuyaDatapoint &dp) {
+    check_expected_datapoint(dp, TuyaDatapointType::BOOLEAN);
+    this->trigger(dp.value_bool);
+  });
+}
+
+TuyaIntDatapointUpdateTrigger::TuyaIntDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id) {
+  parent->register_listener(sensor_id, [this](const TuyaDatapoint &dp) {
+    check_expected_datapoint(dp, TuyaDatapointType::INTEGER);
+    this->trigger(dp.value_int);
+  });
+}
+
+TuyaUIntDatapointUpdateTrigger::TuyaUIntDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id) {
+  parent->register_listener(sensor_id, [this](const TuyaDatapoint &dp) {
+    check_expected_datapoint(dp, TuyaDatapointType::INTEGER);
+    this->trigger(dp.value_uint);
+  });
+}
+
+TuyaStringDatapointUpdateTrigger::TuyaStringDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id) {
+  parent->register_listener(sensor_id, [this](const TuyaDatapoint &dp) {
+    check_expected_datapoint(dp, TuyaDatapointType::STRING);
+    this->trigger(dp.value_string);
+  });
+}
+
+TuyaEnumDatapointUpdateTrigger::TuyaEnumDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id) {
+  parent->register_listener(sensor_id, [this](const TuyaDatapoint &dp) {
+    check_expected_datapoint(dp, TuyaDatapointType::ENUM);
+    this->trigger(dp.value_enum);
+  });
+}
+
+TuyaBitmaskDatapointUpdateTrigger::TuyaBitmaskDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id) {
+  parent->register_listener(sensor_id, [this](const TuyaDatapoint &dp) {
+    check_expected_datapoint(dp, TuyaDatapointType::BITMASK);
+    this->trigger(dp.value_bitmask);
+  });
+}
+
+}  // namespace tuya
+}  // namespace esphome

esphome/components/tuya/automation.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/automation.h"
+#include "tuya.h"
+
+namespace esphome {
+namespace tuya {
+
+class TuyaDatapointUpdateTrigger : public Trigger<TuyaDatapoint> {
+ public:
+  explicit TuyaDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id) {
+    parent->register_listener(sensor_id, [this](const TuyaDatapoint &dp) { this->trigger(dp); });
+  }
+};
+
+class TuyaRawDatapointUpdateTrigger : public Trigger<std::vector<uint8_t>> {
+ public:
+  explicit TuyaRawDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id);
+};
+
+class TuyaBoolDatapointUpdateTrigger : public Trigger<bool> {
+ public:
+  explicit TuyaBoolDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id);
+};
+
+class TuyaIntDatapointUpdateTrigger : public Trigger<int> {
+ public:
+  explicit TuyaIntDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id);
+};
+
+class TuyaUIntDatapointUpdateTrigger : public Trigger<uint32_t> {
+ public:
+  explicit TuyaUIntDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id);
+};
+
+class TuyaStringDatapointUpdateTrigger : public Trigger<std::string> {
+ public:
+  explicit TuyaStringDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id);
+};
+
+class TuyaEnumDatapointUpdateTrigger : public Trigger<uint8_t> {
+ public:
+  explicit TuyaEnumDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id);
+};
+
+class TuyaBitmaskDatapointUpdateTrigger : public Trigger<uint32_t> {
+ public:
+  explicit TuyaBitmaskDatapointUpdateTrigger(Tuya *parent, uint8_t sensor_id);
+};
+
+}  // namespace tuya
+}  // namespace esphome

esphome/components/tuya/binary_sensor/__init__.py

@@ -1,14 +1,12 @@
 from esphome.components import binary_sensor
 import esphome.config_validation as cv
 import esphome.codegen as cg
-from esphome.const import CONF_ID
+from esphome.const import CONF_ID, CONF_SENSOR_DATAPOINT
 from .. import tuya_ns, CONF_TUYA_ID, Tuya
 
 DEPENDENCIES = ["tuya"]
 CODEOWNERS = ["@jesserockz"]
 
-CONF_SENSOR_DATAPOINT = "sensor_datapoint"
-
 TuyaBinarySensor = tuya_ns.class_(
     "TuyaBinarySensor", binary_sensor.BinarySensor, cg.Component
 )

esphome/components/tuya/cover/__init__.py

@@ -5,16 +5,27 @@ from esphome.const import (
     CONF_OUTPUT_ID,
     CONF_MIN_VALUE,
     CONF_MAX_VALUE,
+    CONF_RESTORE_MODE,
 )
 from .. import tuya_ns, CONF_TUYA_ID, Tuya
 
 DEPENDENCIES = ["tuya"]
 
+CONF_CONTROL_DATAPOINT = "control_datapoint"
+CONF_DIRECTION_DATAPOINT = "direction_datapoint"
 CONF_POSITION_DATAPOINT = "position_datapoint"
+CONF_POSITION_REPORT_DATAPOINT = "position_report_datapoint"
 CONF_INVERT_POSITION = "invert_position"
 
 TuyaCover = tuya_ns.class_("TuyaCover", cover.Cover, cg.Component)
 
+TuyaCoverRestoreMode = tuya_ns.enum("TuyaCoverRestoreMode")
+RESTORE_MODES = {
+    "NO_RESTORE": TuyaCoverRestoreMode.COVER_NO_RESTORE,
+    "RESTORE": TuyaCoverRestoreMode.COVER_RESTORE,
+    "RESTORE_AND_CALL": TuyaCoverRestoreMode.COVER_RESTORE_AND_CALL,
+}
+
 
 def validate_range(config):
     if config[CONF_MIN_VALUE] > config[CONF_MAX_VALUE]:
@@ -29,10 +40,16 @@ CONFIG_SCHEMA = cv.All(
         {
             cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(TuyaCover),
             cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya),
+            cv.Optional(CONF_CONTROL_DATAPOINT): cv.uint8_t,
+            cv.Optional(CONF_DIRECTION_DATAPOINT): cv.uint8_t,
             cv.Required(CONF_POSITION_DATAPOINT): cv.uint8_t,
+            cv.Optional(CONF_POSITION_REPORT_DATAPOINT): cv.uint8_t,
             cv.Optional(CONF_MIN_VALUE, default=0): cv.int_,
             cv.Optional(CONF_MAX_VALUE, default=100): cv.int_,
             cv.Optional(CONF_INVERT_POSITION, default=False): cv.boolean,
+            cv.Optional(CONF_RESTORE_MODE, default="RESTORE"): cv.enum(
+                RESTORE_MODES, upper=True
+            ),
         },
     ).extend(cv.COMPONENT_SCHEMA),
     validate_range,
@@ -44,9 +61,16 @@ async def to_code(config):
     await cg.register_component(var, config)
     await cover.register_cover(var, config)
 
+    if CONF_CONTROL_DATAPOINT in config:
+        cg.add(var.set_control_id(config[CONF_CONTROL_DATAPOINT]))
+    if CONF_DIRECTION_DATAPOINT in config:
+        cg.add(var.set_direction_id(config[CONF_DIRECTION_DATAPOINT]))
     cg.add(var.set_position_id(config[CONF_POSITION_DATAPOINT]))
+    if CONF_POSITION_REPORT_DATAPOINT in config:
+        cg.add(var.set_position_report_id(config[CONF_POSITION_REPORT_DATAPOINT]))
     cg.add(var.set_min_value(config[CONF_MIN_VALUE]))
     cg.add(var.set_max_value(config[CONF_MAX_VALUE]))
     cg.add(var.set_invert_position(config[CONF_INVERT_POSITION]))
+    cg.add(var.set_restore_mode(config[CONF_RESTORE_MODE]))
     paren = await cg.get_variable(config[CONF_TUYA_ID])
     cg.add(var.set_tuya_parent(paren))

esphome/components/tuya/cover/tuya_cover.cpp

@@ -4,48 +4,122 @@
 namespace esphome {
 namespace tuya {
 
+const uint8_t COMMAND_OPEN = 0x00;
+const uint8_t COMMAND_CLOSE = 0x02;
+const uint8_t COMMAND_STOP = 0x01;
+
+using namespace esphome::cover;
+
 static const char *const TAG = "tuya.cover";
 
 void TuyaCover::setup() {
   this->value_range_ = this->max_value_ - this->min_value_;
-  if (this->position_id_.has_value()) {
-    this->parent_->register_listener(*this->position_id_, [this](const TuyaDatapoint &datapoint) {
-      auto pos = float(datapoint.value_uint - this->min_value_) / this->value_range_;
-      if (this->invert_position_)
-        pos = 1.0f - pos;
-      this->position = pos;
-      this->publish_state();
-    });
+
+  this->parent_->add_on_initialized_callback([this]() {
+    // Set the direction (if configured/supported).
+    this->set_direction_(this->invert_position_);
+
+    // Handle configured restore mode.
+    switch (this->restore_mode_) {
+      case COVER_NO_RESTORE:
+        break;
+      case COVER_RESTORE: {
+        auto restore = this->restore_state_();
+        if (restore.has_value())
+          restore->apply(this);
+        break;
+      }
+      case COVER_RESTORE_AND_CALL: {
+        auto restore = this->restore_state_();
+        if (restore.has_value()) {
+          restore->to_call(this).perform();
+        }
+        break;
+      }
+    }
+  });
+
+  uint8_t report_id = *this->position_id_;
+  if (this->position_report_id_.has_value()) {
+    // A position report datapoint is configured; listen to that instead.
+    report_id = *this->position_report_id_;
   }
+
+  this->parent_->register_listener(report_id, [this](const TuyaDatapoint &datapoint) {
+    if (datapoint.value_int == 123) {
+      ESP_LOGD(TAG, "Ignoring MCU position report - not calibrated");
+      return;
+    }
+    auto pos = float(datapoint.value_uint - this->min_value_) / this->value_range_;
+    this->position = 1.0f - pos;
+    this->publish_state();
+  });
 }
 
 void TuyaCover::control(const cover::CoverCall &call) {
   if (call.get_stop()) {
-    auto pos = this->position;
-    if (this->invert_position_)
+    if (this->control_id_.has_value()) {
+      this->parent_->force_set_enum_datapoint_value(*this->control_id_, COMMAND_STOP);
+    } else {
+      auto pos = this->position;
       pos = 1.0f - pos;
-    auto position_int = static_cast<uint32_t>(pos * this->value_range_);
-    position_int = position_int + this->min_value_;
+      auto position_int = static_cast<uint32_t>(pos * this->value_range_);
+      position_int = position_int + this->min_value_;
 
-    parent_->set_integer_datapoint_value(*this->position_id_, position_int);
+      parent_->set_integer_datapoint_value(*this->position_id_, position_int);
+    }
   }
   if (call.get_position().has_value()) {
     auto pos = *call.get_position();
-    if (this->invert_position_)
+    if (this->control_id_.has_value() && (pos == COVER_OPEN || pos == COVER_CLOSED)) {
+      if (pos == COVER_OPEN) {
+        this->parent_->force_set_enum_datapoint_value(*this->control_id_, COMMAND_OPEN);
+      } else {
+        this->parent_->force_set_enum_datapoint_value(*this->control_id_, COMMAND_CLOSE);
+      }
+    } else {
       pos = 1.0f - pos;
-    auto position_int = static_cast<uint32_t>(pos * this->value_range_);
-    position_int = position_int + this->min_value_;
+      auto position_int = static_cast<uint32_t>(pos * this->value_range_);
+      position_int = position_int + this->min_value_;
 
-    parent_->set_integer_datapoint_value(*this->position_id_, position_int);
+      parent_->set_integer_datapoint_value(*this->position_id_, position_int);
+    }
   }
 
   this->publish_state();
 }
 
+void TuyaCover::set_direction_(bool inverted) {
+  if (!this->direction_id_.has_value()) {
+    return;
+  }
+
+  if (inverted) {
+    ESP_LOGD(TAG, "Setting direction: inverted");
+  } else {
+    ESP_LOGD(TAG, "Setting direction: normal");
+  }
+
+  this->parent_->set_boolean_datapoint_value(*this->direction_id_, inverted);
+}
+
 void TuyaCover::dump_config() {
   ESP_LOGCONFIG(TAG, "Tuya Cover:");
+  if (this->invert_position_) {
+    if (this->direction_id_.has_value()) {
+      ESP_LOGCONFIG(TAG, "   Inverted");
+    } else {
+      ESP_LOGCONFIG(TAG, "   Configured as Inverted, but direction_datapoint isn't configured");
+    }
+  }
+  if (this->control_id_.has_value())
+    ESP_LOGCONFIG(TAG, "   Control has datapoint ID %u", *this->control_id_);
+  if (this->direction_id_.has_value())
+    ESP_LOGCONFIG(TAG, "   Direction has datapoint ID %u", *this->direction_id_);
   if (this->position_id_.has_value())
     ESP_LOGCONFIG(TAG, "   Position has datapoint ID %u", *this->position_id_);
+  if (this->position_report_id_.has_value())
+    ESP_LOGCONFIG(TAG, "   Position Report has datapoint ID %u", *this->position_report_id_);
 }
 
 cover::CoverTraits TuyaCover::get_traits() {

esphome/components/tuya/cover/tuya_cover.h

@@ -7,22 +7,37 @@
 namespace esphome {
 namespace tuya {
 
+enum TuyaCoverRestoreMode {
+  COVER_NO_RESTORE,
+  COVER_RESTORE,
+  COVER_RESTORE_AND_CALL,
+};
+
 class TuyaCover : public cover::Cover, public Component {
  public:
   void setup() override;
   void dump_config() override;
-  void set_position_id(uint8_t dimmer_id) { this->position_id_ = dimmer_id; }
+  void set_control_id(uint8_t control_id) { this->control_id_ = control_id; }
+  void set_direction_id(uint8_t direction_id) { this->direction_id_ = direction_id; }
+  void set_position_id(uint8_t position_id) { this->position_id_ = position_id; }
+  void set_position_report_id(uint8_t position_report_id) { this->position_report_id_ = position_report_id; }
   void set_tuya_parent(Tuya *parent) { this->parent_ = parent; }
   void set_min_value(uint32_t min_value) { min_value_ = min_value; }
   void set_max_value(uint32_t max_value) { max_value_ = max_value; }
   void set_invert_position(bool invert_position) { invert_position_ = invert_position; }
+  void set_restore_mode(TuyaCoverRestoreMode restore_mode) { restore_mode_ = restore_mode; }
 
  protected:
   void control(const cover::CoverCall &call) override;
+  void set_direction_(bool inverted);
   cover::CoverTraits get_traits() override;
 
   Tuya *parent_;
+  TuyaCoverRestoreMode restore_mode_{};
+  optional<uint8_t> control_id_{};
+  optional<uint8_t> direction_id_{};
   optional<uint8_t> position_id_{};
+  optional<uint8_t> position_report_id_{};
   uint32_t min_value_;
   uint32_t max_value_;
   uint32_t value_range_;

esphome/components/tuya/light/tuya_light.cpp

@@ -37,9 +37,9 @@ void TuyaLight::setup() {
   }
   if (rgb_id_.has_value()) {
     this->parent_->register_listener(*this->rgb_id_, [this](const TuyaDatapoint &datapoint) {
-      auto red = parse_hex(datapoint.value_string, 0, 2);
-      auto green = parse_hex(datapoint.value_string, 2, 2);
-      auto blue = parse_hex(datapoint.value_string, 4, 2);
+      auto red = parse_hex<uint8_t>(datapoint.value_string.substr(0, 2));
+      auto green = parse_hex<uint8_t>(datapoint.value_string.substr(2, 2));
+      auto blue = parse_hex<uint8_t>(datapoint.value_string.substr(4, 2));
       if (red.has_value() && green.has_value() && blue.has_value()) {
         auto call = this->state_->make_call();
         call.set_rgb(float(*red) / 255, float(*green) / 255, float(*blue) / 255);
@@ -48,9 +48,9 @@ void TuyaLight::setup() {
     });
   } else if (hsv_id_.has_value()) {
     this->parent_->register_listener(*this->hsv_id_, [this](const TuyaDatapoint &datapoint) {
-      auto hue = parse_hex(datapoint.value_string, 0, 4);
-      auto saturation = parse_hex(datapoint.value_string, 4, 4);
-      auto value = parse_hex(datapoint.value_string, 8, 4);
+      auto hue = parse_hex<uint16_t>(datapoint.value_string.substr(0, 4));
+      auto saturation = parse_hex<uint16_t>(datapoint.value_string.substr(4, 4));
+      auto value = parse_hex<uint16_t>(datapoint.value_string.substr(8, 4));
       if (hue.has_value() && saturation.has_value() && value.has_value()) {
         float red, green, blue;
         hsv_to_rgb(*hue, float(*saturation) / 1000, float(*value) / 1000, red, green, blue);

esphome/components/tuya/sensor/__init__.py

@@ -1,14 +1,12 @@
 from esphome.components import sensor
 import esphome.config_validation as cv
 import esphome.codegen as cg
-from esphome.const import CONF_ID
+from esphome.const import CONF_ID, CONF_SENSOR_DATAPOINT
 from .. import tuya_ns, CONF_TUYA_ID, Tuya
 
 DEPENDENCIES = ["tuya"]
 CODEOWNERS = ["@jesserockz"]
 
-CONF_SENSOR_DATAPOINT = "sensor_datapoint"
-
 TuyaSensor = tuya_ns.class_("TuyaSensor", sensor.Sensor, cg.Component)
 
 CONFIG_SCHEMA = sensor.SENSOR_SCHEMA.extend(

esphome/components/tuya/text_sensor/__init__.py

@@ -0,0 +1,29 @@
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+import esphome.codegen as cg
+from esphome.const import CONF_ID, CONF_SENSOR_DATAPOINT
+from .. import tuya_ns, CONF_TUYA_ID, Tuya
+
+DEPENDENCIES = ["tuya"]
+CODEOWNERS = ["@dentra"]
+
+TuyaTextSensor = tuya_ns.class_("TuyaTextSensor", text_sensor.TextSensor, cg.Component)
+
+CONFIG_SCHEMA = text_sensor.TEXT_SENSOR_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(TuyaTextSensor),
+        cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya),
+        cv.Required(CONF_SENSOR_DATAPOINT): cv.uint8_t,
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await text_sensor.register_text_sensor(var, config)
+
+    paren = await cg.get_variable(config[CONF_TUYA_ID])
+    cg.add(var.set_tuya_parent(paren))
+
+    cg.add(var.set_sensor_id(config[CONF_SENSOR_DATAPOINT]))

esphome/components/tuya/text_sensor/tuya_text_sensor.cpp

@@ -0,0 +1,35 @@
+#include "esphome/core/log.h"
+#include "tuya_text_sensor.h"
+
+namespace esphome {
+namespace tuya {
+
+static const char *const TAG = "tuya.text_sensor";
+
+void TuyaTextSensor::setup() {
+  this->parent_->register_listener(this->sensor_id_, [this](const TuyaDatapoint &datapoint) {
+    switch (datapoint.type) {
+      case TuyaDatapointType::STRING:
+        ESP_LOGD(TAG, "MCU reported text sensor %u is: %s", datapoint.id, datapoint.value_string.c_str());
+        this->publish_state(datapoint.value_string);
+        break;
+      case TuyaDatapointType::RAW: {
+        std::string data = format_hex_pretty(datapoint.value_raw);
+        ESP_LOGD(TAG, "MCU reported text sensor %u is: %s", datapoint.id, data.c_str());
+        this->publish_state(data);
+        break;
+      }
+      default:
+        ESP_LOGW(TAG, "Unsupported data type for tuya text sensor %u: %#02hhX", datapoint.id, datapoint.type);
+        break;
+    }
+  });
+}
+
+void TuyaTextSensor::dump_config() {
+  ESP_LOGCONFIG(TAG, "Tuya Text Sensor:");
+  ESP_LOGCONFIG(TAG, "  Text Sensor has datapoint ID %u", this->sensor_id_);
+}
+
+}  // namespace tuya
+}  // namespace esphome

esphome/components/tuya/text_sensor/tuya_text_sensor.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/tuya/tuya.h"
+#include "esphome/components/text_sensor/text_sensor.h"
+
+namespace esphome {
+namespace tuya {
+
+class TuyaTextSensor : public text_sensor::TextSensor, public Component {
+ public:
+  void setup() override;
+  void dump_config() override;
+  void set_sensor_id(uint8_t sensor_id) { this->sensor_id_ = sensor_id; }
+
+  void set_tuya_parent(Tuya *parent) { this->parent_ = parent; }
+
+ protected:
+  Tuya *parent_;
+  uint8_t sensor_id_{0};
+};
+
+}  // namespace tuya
+}  // namespace esphome

esphome/components/tuya/tuya.cpp

@@ -34,7 +34,7 @@ void Tuya::dump_config() {
   }
   for (auto &info : this->datapoints_) {
     if (info.type == TuyaDatapointType::RAW)
-      ESP_LOGCONFIG(TAG, "  Datapoint %u: raw (value: %s)", info.id, hexencode(info.value_raw).c_str());
+      ESP_LOGCONFIG(TAG, "  Datapoint %u: raw (value: %s)", info.id, format_hex_pretty(info.value_raw).c_str());
     else if (info.type == TuyaDatapointType::BOOLEAN)
       ESP_LOGCONFIG(TAG, "  Datapoint %u: switch (value: %s)", info.id, ONOFF(info.value_bool));
     else if (info.type == TuyaDatapointType::INTEGER)
@@ -104,7 +104,7 @@ bool Tuya::validate_message_() {
   // valid message
   const uint8_t *message_data = data + 6;
   ESP_LOGV(TAG, "Received Tuya: CMD=0x%02X VERSION=%u DATA=[%s] INIT_STATE=%u", command, version,
-           hexencode(message_data, length).c_str(), static_cast<uint8_t>(this->init_state_));
+           format_hex_pretty(message_data, length).c_str(), static_cast<uint8_t>(this->init_state_));
   this->handle_command_(command, version, message_data, length);
 
   // return false to reset rx buffer
@@ -143,7 +143,7 @@ void Tuya::handle_command_(uint8_t command, uint8_t version, const uint8_t *buff
     case TuyaCommandType::PRODUCT_QUERY: {
       // check it is a valid string made up of printable characters
       bool valid = true;
-      for (int i = 0; i < len; i++) {
+      for (size_t i = 0; i < len; i++) {
         if (!std::isprint(buffer[i])) {
           valid = false;
           break;
@@ -195,6 +195,7 @@ void Tuya::handle_command_(uint8_t command, uint8_t version, const uint8_t *buff
       if (this->init_state_ == TuyaInitState::INIT_DATAPOINT) {
         this->init_state_ = TuyaInitState::INIT_DONE;
         this->set_timeout("datapoint_dump", 1000, [this] { this->dump_config(); });
+        this->initialized_callback_.call();
       }
       this->handle_datapoint_(buffer, len);
       break;
@@ -252,7 +253,7 @@ void Tuya::handle_datapoint_(const uint8_t *buffer, size_t len) {
   switch (datapoint.type) {
     case TuyaDatapointType::RAW:
       datapoint.value_raw = std::vector<uint8_t>(data, data + data_len);
-      ESP_LOGD(TAG, "Datapoint %u update to %s", datapoint.id, hexencode(datapoint.value_raw).c_str());
+      ESP_LOGD(TAG, "Datapoint %u update to %s", datapoint.id, format_hex_pretty(datapoint.value_raw).c_str());
       break;
     case TuyaDatapointType::BOOLEAN:
       if (data_len != 1) {
@@ -339,8 +340,6 @@ void Tuya::send_raw_command_(TuyaCommand command) {
       this->expected_response_ = TuyaCommandType::CONF_QUERY;
       break;
     case TuyaCommandType::DATAPOINT_DELIVER:
-      this->expected_response_ = TuyaCommandType::DATAPOINT_REPORT;
-      break;
     case TuyaCommandType::DATAPOINT_QUERY:
       this->expected_response_ = TuyaCommandType::DATAPOINT_REPORT;
       break;
@@ -349,7 +348,7 @@ void Tuya::send_raw_command_(TuyaCommand command) {
   }
 
   ESP_LOGV(TAG, "Sending Tuya: CMD=0x%02X VERSION=%u DATA=[%s] INIT_STATE=%u", static_cast<uint8_t>(command.cmd),
-           version, hexencode(command.payload).c_str(), static_cast<uint8_t>(this->init_state_));
+           version, format_hex_pretty(command.payload).c_str(), static_cast<uint8_t>(this->init_state_));
 
   this->write_array({0x55, 0xAA, version, (uint8_t) command.cmd, len_hi, len_lo});
   if (!command.payload.empty())
@@ -441,53 +440,51 @@ void Tuya::send_local_time_() {
 #endif
 
 void Tuya::set_raw_datapoint_value(uint8_t datapoint_id, const std::vector<uint8_t> &value) {
-  ESP_LOGD(TAG, "Setting datapoint %u to %s", datapoint_id, hexencode(value).c_str());
-  optional<TuyaDatapoint> datapoint = this->get_datapoint_(datapoint_id);
-  if (!datapoint.has_value()) {
-    ESP_LOGW(TAG, "Setting unknown datapoint %u", datapoint_id);
-  } else if (datapoint->type != TuyaDatapointType::RAW) {
-    ESP_LOGE(TAG, "Attempt to set datapoint %u with incorrect type", datapoint_id);
-    return;
-  } else if (datapoint->value_raw == value) {
-    ESP_LOGV(TAG, "Not sending unchanged value");
-    return;
-  }
-  this->send_datapoint_command_(datapoint_id, TuyaDatapointType::RAW, value);
+  this->set_raw_datapoint_value_(datapoint_id, value, false);
 }
 
 void Tuya::set_boolean_datapoint_value(uint8_t datapoint_id, bool value) {
-  this->set_numeric_datapoint_value_(datapoint_id, TuyaDatapointType::BOOLEAN, value, 1);
+  this->set_numeric_datapoint_value_(datapoint_id, TuyaDatapointType::BOOLEAN, value, 1, false);
 }
 
 void Tuya::set_integer_datapoint_value(uint8_t datapoint_id, uint32_t value) {
-  this->set_numeric_datapoint_value_(datapoint_id, TuyaDatapointType::INTEGER, value, 4);
+  this->set_numeric_datapoint_value_(datapoint_id, TuyaDatapointType::INTEGER, value, 4, false);
 }
 
 void Tuya::set_string_datapoint_value(uint8_t datapoint_id, const std::string &value) {
-  ESP_LOGD(TAG, "Setting datapoint %u to %s", datapoint_id, value.c_str());
-  optional<TuyaDatapoint> datapoint = this->get_datapoint_(datapoint_id);
-  if (!datapoint.has_value()) {
-    ESP_LOGW(TAG, "Setting unknown datapoint %u", datapoint_id);
-  } else if (datapoint->type != TuyaDatapointType::STRING) {
-    ESP_LOGE(TAG, "Attempt to set datapoint %u with incorrect type", datapoint_id);
-    return;
-  } else if (datapoint->value_string == value) {
-    ESP_LOGV(TAG, "Not sending unchanged value");
-    return;
-  }
-  std::vector<uint8_t> data;
-  for (char const &c : value) {
-    data.push_back(c);
-  }
-  this->send_datapoint_command_(datapoint_id, TuyaDatapointType::STRING, data);
+  this->set_string_datapoint_value_(datapoint_id, value, false);
 }
 
 void Tuya::set_enum_datapoint_value(uint8_t datapoint_id, uint8_t value) {
-  this->set_numeric_datapoint_value_(datapoint_id, TuyaDatapointType::ENUM, value, 1);
+  this->set_numeric_datapoint_value_(datapoint_id, TuyaDatapointType::ENUM, value, 1, false);
 }
 
 void Tuya::set_bitmask_datapoint_value(uint8_t datapoint_id, uint32_t value, uint8_t length) {
-  this->set_numeric_datapoint_value_(datapoint_id, TuyaDatapointType::BITMASK, value, length);
+  this->set_numeric_datapoint_value_(datapoint_id, TuyaDatapointType::BITMASK, value, length, false);
+}
+
+void Tuya::force_set_raw_datapoint_value(uint8_t datapoint_id, const std::vector<uint8_t> &value) {
+  this->set_raw_datapoint_value_(datapoint_id, value, true);
+}
+
+void Tuya::force_set_boolean_datapoint_value(uint8_t datapoint_id, bool value) {
+  this->set_numeric_datapoint_value_(datapoint_id, TuyaDatapointType::BOOLEAN, value, 1, true);
+}
+
+void Tuya::force_set_integer_datapoint_value(uint8_t datapoint_id, uint32_t value) {
+  this->set_numeric_datapoint_value_(datapoint_id, TuyaDatapointType::INTEGER, value, 4, true);
+}
+
+void Tuya::force_set_string_datapoint_value(uint8_t datapoint_id, const std::string &value) {
+  this->set_string_datapoint_value_(datapoint_id, value, true);
+}
+
+void Tuya::force_set_enum_datapoint_value(uint8_t datapoint_id, uint8_t value) {
+  this->set_numeric_datapoint_value_(datapoint_id, TuyaDatapointType::ENUM, value, 1, true);
+}
+
+void Tuya::force_set_bitmask_datapoint_value(uint8_t datapoint_id, uint32_t value, uint8_t length) {
+  this->set_numeric_datapoint_value_(datapoint_id, TuyaDatapointType::BITMASK, value, length, true);
 }
 
 optional<TuyaDatapoint> Tuya::get_datapoint_(uint8_t datapoint_id) {
@@ -498,7 +495,7 @@ optional<TuyaDatapoint> Tuya::get_datapoint_(uint8_t datapoint_id) {
 }
 
 void Tuya::set_numeric_datapoint_value_(uint8_t datapoint_id, TuyaDatapointType datapoint_type, const uint32_t value,
-                                        uint8_t length) {
+                                        uint8_t length, bool forced) {
   ESP_LOGD(TAG, "Setting datapoint %u to %u", datapoint_id, value);
   optional<TuyaDatapoint> datapoint = this->get_datapoint_(datapoint_id);
   if (!datapoint.has_value()) {
@@ -506,7 +503,7 @@ void Tuya::set_numeric_datapoint_value_(uint8_t datapoint_id, TuyaDatapointType
   } else if (datapoint->type != datapoint_type) {
     ESP_LOGE(TAG, "Attempt to set datapoint %u with incorrect type", datapoint_id);
     return;
-  } else if (datapoint->value_uint == value) {
+  } else if (!forced && datapoint->value_uint == value) {
     ESP_LOGV(TAG, "Not sending unchanged value");
     return;
   }
@@ -528,6 +525,40 @@ void Tuya::set_numeric_datapoint_value_(uint8_t datapoint_id, TuyaDatapointType
   this->send_datapoint_command_(datapoint_id, datapoint_type, data);
 }
 
+void Tuya::set_raw_datapoint_value_(uint8_t datapoint_id, const std::vector<uint8_t> &value, bool forced) {
+  ESP_LOGD(TAG, "Setting datapoint %u to %s", datapoint_id, format_hex_pretty(value).c_str());
+  optional<TuyaDatapoint> datapoint = this->get_datapoint_(datapoint_id);
+  if (!datapoint.has_value()) {
+    ESP_LOGW(TAG, "Setting unknown datapoint %u", datapoint_id);
+  } else if (datapoint->type != TuyaDatapointType::RAW) {
+    ESP_LOGE(TAG, "Attempt to set datapoint %u with incorrect type", datapoint_id);
+    return;
+  } else if (!forced && datapoint->value_raw == value) {
+    ESP_LOGV(TAG, "Not sending unchanged value");
+    return;
+  }
+  this->send_datapoint_command_(datapoint_id, TuyaDatapointType::RAW, value);
+}
+
+void Tuya::set_string_datapoint_value_(uint8_t datapoint_id, const std::string &value, bool forced) {
+  ESP_LOGD(TAG, "Setting datapoint %u to %s", datapoint_id, value.c_str());
+  optional<TuyaDatapoint> datapoint = this->get_datapoint_(datapoint_id);
+  if (!datapoint.has_value()) {
+    ESP_LOGW(TAG, "Setting unknown datapoint %u", datapoint_id);
+  } else if (datapoint->type != TuyaDatapointType::STRING) {
+    ESP_LOGE(TAG, "Attempt to set datapoint %u with incorrect type", datapoint_id);
+    return;
+  } else if (!forced && datapoint->value_string == value) {
+    ESP_LOGV(TAG, "Not sending unchanged value");
+    return;
+  }
+  std::vector<uint8_t> data;
+  for (char const &c : value) {
+    data.push_back(c);
+  }
+  this->send_datapoint_command_(datapoint_id, TuyaDatapointType::STRING, data);
+}
+
 void Tuya::send_datapoint_command_(uint8_t datapoint_id, TuyaDatapointType datapoint_type, std::vector<uint8_t> data) {
   std::vector<uint8_t> buffer;
   buffer.push_back(datapoint_id);
@@ -552,5 +583,7 @@ void Tuya::register_listener(uint8_t datapoint_id, const std::function<void(Tuya
       func(datapoint);
 }
 
+TuyaInitState Tuya::get_init_state() { return this->init_state_; }
+
 }  // namespace tuya
 }  // namespace esphome

esphome/components/tuya/tuya.h

@@ -2,6 +2,7 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
+#include "esphome/core/helpers.h"
 #include "esphome/components/uart/uart.h"
 
 #ifdef USE_TIME
@@ -81,12 +82,22 @@ class Tuya : public Component, public uart::UARTDevice {
   void set_string_datapoint_value(uint8_t datapoint_id, const std::string &value);
   void set_enum_datapoint_value(uint8_t datapoint_id, uint8_t value);
   void set_bitmask_datapoint_value(uint8_t datapoint_id, uint32_t value, uint8_t length);
+  void force_set_raw_datapoint_value(uint8_t datapoint_id, const std::vector<uint8_t> &value);
+  void force_set_boolean_datapoint_value(uint8_t datapoint_id, bool value);
+  void force_set_integer_datapoint_value(uint8_t datapoint_id, uint32_t value);
+  void force_set_string_datapoint_value(uint8_t datapoint_id, const std::string &value);
+  void force_set_enum_datapoint_value(uint8_t datapoint_id, uint8_t value);
+  void force_set_bitmask_datapoint_value(uint8_t datapoint_id, uint32_t value, uint8_t length);
+  TuyaInitState get_init_state();
 #ifdef USE_TIME
   void set_time_id(time::RealTimeClock *time_id) { this->time_id_ = time_id; }
 #endif
   void add_ignore_mcu_update_on_datapoints(uint8_t ignore_mcu_update_on_datapoints) {
     this->ignore_mcu_update_on_datapoints_.push_back(ignore_mcu_update_on_datapoints);
   }
+  void add_on_initialized_callback(std::function<void()> callback) {
+    this->initialized_callback_.add(std::move(callback));
+  }
 
  protected:
   void handle_char_(uint8_t c);
@@ -100,7 +111,9 @@ class Tuya : public Component, public uart::UARTDevice {
   void send_command_(const TuyaCommand &command);
   void send_empty_command_(TuyaCommandType command);
   void set_numeric_datapoint_value_(uint8_t datapoint_id, TuyaDatapointType datapoint_type, uint32_t value,
-                                    uint8_t length);
+                                    uint8_t length, bool forced);
+  void set_string_datapoint_value_(uint8_t datapoint_id, const std::string &value, bool forced);
+  void set_raw_datapoint_value_(uint8_t datapoint_id, const std::vector<uint8_t> &value, bool forced);
   void send_datapoint_command_(uint8_t datapoint_id, TuyaDatapointType datapoint_type, std::vector<uint8_t> data);
   void send_wifi_status_();
 
@@ -122,6 +135,7 @@ class Tuya : public Component, public uart::UARTDevice {
   std::vector<TuyaCommand> command_queue_;
   optional<TuyaCommandType> expected_response_{};
   uint8_t wifi_status_ = -1;
+  CallbackManager<void()> initialized_callback_{};
 };
 
 }  // namespace tuya

esphome/components/tx20/tx20.cpp

@@ -113,7 +113,7 @@ void Tx20Component::decode_and_publish_() {
   if (tx20_sa == 4) {
     if (chk == tx20_sd) {
       if (tx20_sf == tx20_sc) {
-        tx20_wind_speed_kmh = float(tx20_sc) * 0.36;
+        tx20_wind_speed_kmh = float(tx20_sc) * 0.36f;
         ESP_LOGV(TAG, "WindSpeed %f", tx20_wind_speed_kmh);
         if (this->wind_speed_sensor_ != nullptr)
           this->wind_speed_sensor_->publish_state(tx20_wind_speed_kmh);

esphome/components/uart/__init__.py

@@ -14,6 +14,7 @@ from esphome.const import (
     CONF_UART_ID,
     CONF_DATA,
     CONF_RX_BUFFER_SIZE,
+    CONF_INVERTED,
     CONF_INVERT,
     CONF_TRIGGER_ID,
     CONF_SEQUENCE,
@@ -67,6 +68,19 @@ def validate_rx_pin(value):
     return value
 
 
+def validate_invert_esp32(config):
+    if (
+        CORE.is_esp32
+        and CONF_TX_PIN in config
+        and CONF_RX_PIN in config
+        and config[CONF_TX_PIN][CONF_INVERTED] != config[CONF_RX_PIN][CONF_INVERTED]
+    ):
+        raise cv.Invalid(
+            "Different invert values for TX and RX pin are not (yet) supported for ESP32."
+        )
+    return config
+
+
 def _uart_declare_type(value):
     if CORE.is_esp8266:
         return cv.declare_id(ESP8266UartComponent)(value)
@@ -162,6 +176,7 @@ CONFIG_SCHEMA = cv.All(
         }
     ).extend(cv.COMPONENT_SCHEMA),
     cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN),
+    validate_invert_esp32,
 )
 
 

esphome/components/uart/uart_component.h

@@ -52,6 +52,7 @@ class UARTComponent {
   void set_tx_pin(InternalGPIOPin *tx_pin) { this->tx_pin_ = tx_pin; }
   void set_rx_pin(InternalGPIOPin *rx_pin) { this->rx_pin_ = rx_pin; }
   void set_rx_buffer_size(size_t rx_buffer_size) { this->rx_buffer_size_ = rx_buffer_size; }
+  size_t get_rx_buffer_size() { return this->rx_buffer_size_; }
 
   void set_stop_bits(uint8_t stop_bits) { this->stop_bits_ = stop_bits; }
   uint8_t get_stop_bits() const { return this->stop_bits_; }

esphome/components/uart/uart_component_esp8266.cpp

@@ -45,6 +45,11 @@ uint32_t ESP8266UartComponent::get_config() {
   else
     config |= UART_NB_STOP_BIT_2;
 
+  if (this->tx_pin_ != nullptr && this->tx_pin_->is_inverted())
+    config |= BIT(22);
+  if (this->rx_pin_ != nullptr && this->rx_pin_->is_inverted())
+    config |= BIT(19);
+
   return config;
 }
 
@@ -209,9 +214,7 @@ void IRAM_ATTR ESP8266SoftwareSerial::gpio_intr(ESP8266SoftwareSerial *arg) {
 
   /* If parity is enabled, just read it and ignore it. */
   /* TODO: Should we check parity? Or is it too slow for nothing added..*/
-  if (arg->parity_ == UART_CONFIG_PARITY_EVEN)
-    arg->read_bit_(&wait, start);
-  else if (arg->parity_ == UART_CONFIG_PARITY_ODD)
+  if (arg->parity_ == UART_CONFIG_PARITY_EVEN || arg->parity_ == UART_CONFIG_PARITY_ODD)
     arg->read_bit_(&wait, start);
 
   // Stop bit

esphome/components/uart/uart_debugger.cpp

@@ -90,6 +90,11 @@ void UARTDummyReceiver::loop() {
   }
 }
 
+// In the upcoming log functions, a delay was added after all log calls.
+// This is done to allow the system to ship the log lines via the API
+// TCP connection(s). Without these delays, debug log lines could go
+// missing when UART devices block the main loop for too long.
+
 void UARTDebug::log_hex(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator) {
   std::string res;
   if (direction == UART_DIRECTION_RX) {
@@ -107,6 +112,7 @@ void UARTDebug::log_hex(UARTDirection direction, std::vector<uint8_t> bytes, uin
     res += buf;
   }
   ESP_LOGD(TAG, "%s", res.c_str());
+  delay(10);
 }
 
 void UARTDebug::log_string(UARTDirection direction, std::vector<uint8_t> bytes) {
@@ -150,6 +156,7 @@ void UARTDebug::log_string(UARTDirection direction, std::vector<uint8_t> bytes)
   }
   res += '"';
   ESP_LOGD(TAG, "%s", res.c_str());
+  delay(10);
 }
 
 void UARTDebug::log_int(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator) {
@@ -167,6 +174,7 @@ void UARTDebug::log_int(UARTDirection direction, std::vector<uint8_t> bytes, uin
     res += to_string(bytes[i]);
   }
   ESP_LOGD(TAG, "%s", res.c_str());
+  delay(10);
 }
 
 void UARTDebug::log_binary(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator) {
@@ -186,6 +194,7 @@ void UARTDebug::log_binary(UARTDirection direction, std::vector<uint8_t> bytes,
     res += buf;
   }
   ESP_LOGD(TAG, "%s", res.c_str());
+  delay(10);
 }
 
 }  // namespace uart