Merge pull request #4997 from esphome/bump-2023.6.2

2023.6.2

.github/actions/restore-python/action.yml

@@ -1,38 +0,0 @@
-name: Restore Python
-inputs:
-  python-version:
-    description: Python version to restore
-    required: true
-    type: string
-  cache-key:
-    description: Cache key to use
-    required: true
-    type: string
-outputs:
-  python-version:
-    description: Python version restored
-    value: ${{ steps.python.outputs.python-version }}
-runs:
-  using: "composite"
-  steps:
-    - name: Set up Python ${{ inputs.python-version }}
-      id: python
-      uses: actions/setup-python@v4.6.0
-      with:
-        python-version: ${{ inputs.python-version }}
-    - name: Restore Python virtual environment
-      id: cache-venv
-      uses: actions/cache/restore@v3.3.1
-      with:
-        path: venv
-        # yamllint disable-line rule:line-length
-        key: ${{ runner.os }}-${{ steps.python.outputs.python-version }}-venv-${{ inputs.cache-key }}
-    - name: Create Python virtual environment
-      if: steps.cache-venv.outputs.cache-hit != 'true'
-      shell: bash
-      run: |
-        python -m venv venv
-        . venv/bin/activate
-        python --version
-        pip install -r requirements.txt -r requirements_optional.txt -r requirements_test.txt
-        pip install -e .

.github/workflows/ci.yml

@@ -26,16 +26,10 @@ jobs:
   common:
     name: Create common environment
     runs-on: ubuntu-latest
-    outputs:
-      cache-key: ${{ steps.cache-key.outputs.key }}
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Generate cache-key
-        id: cache-key
-        run: echo key="${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}" >> $GITHUB_OUTPUT
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        id: python
         uses: actions/setup-python@v4.6.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
@@ -45,7 +39,7 @@ jobs:
         with:
           path: venv
           # yamllint disable-line rule:line-length
-          key: ${{ runner.os }}-${{ steps.python.outputs.python-version }}-venv-${{ steps.cache-key.outputs.key }}
+          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Create Python virtual environment
         if: steps.cache-venv.outputs.cache-hit != 'true'
         run: |
@@ -72,11 +66,12 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
+      - name: Restore Python virtual environment
+        uses: actions/cache/restore@v3.3.1
         with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
+          path: venv
+          # yamllint disable-line rule:line-length
+          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Run black
         run: |
           . venv/bin/activate
@@ -93,11 +88,12 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
+      - name: Restore Python virtual environment
+        uses: actions/cache/restore@v3.3.1
         with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
+          path: venv
+          # yamllint disable-line rule:line-length
+          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Run flake8
         run: |
           . venv/bin/activate
@@ -114,11 +110,12 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
+      - name: Restore Python virtual environment
+        uses: actions/cache/restore@v3.3.1
         with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
+          path: venv
+          # yamllint disable-line rule:line-length
+          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Run pylint
         run: |
           . venv/bin/activate
@@ -135,11 +132,12 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
+      - name: Restore Python virtual environment
+        uses: actions/cache/restore@v3.3.1
         with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
+          path: venv
+          # yamllint disable-line rule:line-length
+          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Run pyupgrade
         run: |
           . venv/bin/activate
@@ -156,11 +154,12 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
+      - name: Restore Python virtual environment
+        uses: actions/cache/restore@v3.3.1
         with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
+          path: venv
+          # yamllint disable-line rule:line-length
+          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Register matcher
         run: echo "::add-matcher::.github/workflows/matchers/ci-custom.json"
       - name: Run script/ci-custom
@@ -177,11 +176,12 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
+      - name: Restore Python virtual environment
+        uses: actions/cache/restore@v3.3.1
         with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
+          path: venv
+          # yamllint disable-line rule:line-length
+          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Register matcher
         run: echo "::add-matcher::.github/workflows/matchers/pytest.json"
       - name: Run pytest
@@ -197,11 +197,12 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
+      - name: Restore Python virtual environment
+        uses: actions/cache/restore@v3.3.1
         with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
+          path: venv
+          # yamllint disable-line rule:line-length
+          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Install clang-format
         run: |
           . venv/bin/activate
@@ -236,11 +237,12 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
+      - name: Restore Python virtual environment
+        uses: actions/cache/restore@v3.3.1
         with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
+          path: venv
+          # yamllint disable-line rule:line-length
+          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Cache platformio
         uses: actions/cache@v3.3.1
         with:
@@ -298,11 +300,13 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
+      - name: Restore Python virtual environment
+        uses: actions/cache/restore@v3.3.1
         with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
+          path: venv
+          # yamllint disable-line rule:line-length
+          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
+        # Use per check platformio cache because checks use different parts
       - name: Cache platformio
         uses: actions/cache@v3.3.1
         with:

.github/workflows/sync-device-classes.yml

@@ -6,12 +6,14 @@ on:
   schedule:
     - cron: '45 6 * * *'
 
+permissions:
+  contents: write
+  pull-requests: write
 
 jobs:
   sync:
     name: Sync Device Classes
     runs-on: ubuntu-latest
-    if: github.repository == 'esphome/esphome'
     steps:
       - name: Checkout
         uses: actions/checkout@v3
@@ -36,6 +38,15 @@ jobs:
         run: |
           python ./script/sync-device_class.py
 
+      - name: Get PR template
+        id: pr-template-body
+        run: |
+          body=$(cat .github/PULL_REQUEST_TEMPLATE.md)
+          delimiter="$(openssl rand -hex 8)"
+          echo "body<<$delimiter" >> $GITHUB_OUTPUT
+          echo "$body" >> $GITHUB_OUTPUT
+          echo "$delimiter" >> $GITHUB_OUTPUT
+
       - name: Commit changes
         uses: peter-evans/create-pull-request@v5
         with:
@@ -45,5 +56,5 @@ jobs:
           branch: sync/device-classes
           delete-branch: true
           title: "Synchronise Device Classes from Home Assistant"
-          body-path: .github/PULL_REQUEST_TEMPLATE.md
+          body: ${{ steps.pr-template-body.outputs.body }}
           token: ${{ secrets.DEVICE_CLASS_SYNC_TOKEN }}

.pre-commit-config.yaml

@@ -27,7 +27,7 @@ repos:
           - --branch=release
           - --branch=beta
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.7.0
+    rev: v3.4.0
     hooks:
       - id: pyupgrade
         args: [--py39-plus]

CODEOWNERS

@@ -103,7 +103,7 @@ esphome/components/gpio/* @esphome/core
 esphome/components/gps/* @coogle
 esphome/components/graph/* @synco
 esphome/components/growatt_solar/* @leeuwte
-esphome/components/haier/* @paveldn
+esphome/components/haier/* @Yarikx
 esphome/components/havells_solar/* @sourabhjaiswal
 esphome/components/hbridge/fan/* @WeekendWarrior
 esphome/components/hbridge/light/* @DotNetDann
@@ -319,5 +319,4 @@ esphome/components/xiaomi_lywsd03mmc/* @ahpohl
 esphome/components/xiaomi_mhoc303/* @drug123
 esphome/components/xiaomi_mhoc401/* @vevsvevs
 esphome/components/xiaomi_rtcgq02lm/* @jesserockz
-esphome/components/xl9535/* @mreditor97
 esphome/components/xpt2046/* @nielsnl68 @numo68

esphome/components/animation/__init__.py

@@ -1,7 +1,7 @@
 import logging
 
-from esphome import automation, core
-from esphome.components import font
+from esphome import core
+from esphome.components import display, font
 import esphome.components.image as espImage
 from esphome.components.image import CONF_USE_TRANSPARENCY
 import esphome.config_validation as cv
@@ -18,30 +18,14 @@ from esphome.core import CORE, HexInt
 
 _LOGGER = logging.getLogger(__name__)
 
-AUTO_LOAD = ["image"]
-CODEOWNERS = ["@syndlex"]
 DEPENDENCIES = ["display"]
 MULTI_CONF = True
 
 CONF_LOOP = "loop"
 CONF_START_FRAME = "start_frame"
 CONF_END_FRAME = "end_frame"
-CONF_FRAME = "frame"
 
-animation_ns = cg.esphome_ns.namespace("animation")
-
-Animation_ = animation_ns.class_("Animation", espImage.Image_)
-
-# Actions
-NextFrameAction = animation_ns.class_(
-    "AnimationNextFrameAction", automation.Action, cg.Parented.template(Animation_)
-)
-PrevFrameAction = animation_ns.class_(
-    "AnimationPrevFrameAction", automation.Action, cg.Parented.template(Animation_)
-)
-SetFrameAction = animation_ns.class_(
-    "AnimationSetFrameAction", automation.Action, cg.Parented.template(Animation_)
-)
+Animation_ = display.display_ns.class_("Animation", espImage.Image_)
 
 
 def validate_cross_dependencies(config):
@@ -90,35 +74,7 @@ ANIMATION_SCHEMA = cv.Schema(
 
 CONFIG_SCHEMA = cv.All(font.validate_pillow_installed, ANIMATION_SCHEMA)
 
-NEXT_FRAME_SCHEMA = automation.maybe_simple_id(
-    {
-        cv.GenerateID(): cv.use_id(Animation_),
-    }
-)
-PREV_FRAME_SCHEMA = automation.maybe_simple_id(
-    {
-        cv.GenerateID(): cv.use_id(Animation_),
-    }
-)
-SET_FRAME_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.use_id(Animation_),
-        cv.Required(CONF_FRAME): cv.uint16_t,
-    }
-)
-
-
-@automation.register_action("animation.next_frame", NextFrameAction, NEXT_FRAME_SCHEMA)
-@automation.register_action("animation.prev_frame", PrevFrameAction, PREV_FRAME_SCHEMA)
-@automation.register_action("animation.set_frame", SetFrameAction, SET_FRAME_SCHEMA)
-async def animation_action_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-
-    if CONF_FRAME in config:
-        template_ = await cg.templatable(config[CONF_FRAME], args, cg.uint16)
-        cg.add(var.set_frame(template_))
-    return var
+CODEOWNERS = ["@syndlex"]
 
 
 async def to_code(config):

esphome/components/animation/animation.h

@@ -1,67 +0,0 @@
-#pragma once
-#include "esphome/components/image/image.h"
-
-#include "esphome/core/automation.h"
-
-namespace esphome {
-namespace animation {
-
-class Animation : public image::Image {
- public:
-  Animation(const uint8_t *data_start, int width, int height, uint32_t animation_frame_count, image::ImageType type);
-
-  uint32_t get_animation_frame_count() const;
-  int get_current_frame() const;
-  void next_frame();
-  void prev_frame();
-
-  /** Selects a specific frame within the animation.
-   *
-   * @param frame If possitive, advance to the frame. If negative, recede to that frame from the end frame.
-   */
-  void set_frame(int frame);
-
-  void set_loop(uint32_t start_frame, uint32_t end_frame, int count);
-
- protected:
-  void update_data_start_();
-
-  const uint8_t *animation_data_start_;
-  int current_frame_;
-  uint32_t animation_frame_count_;
-  uint32_t loop_start_frame_;
-  uint32_t loop_end_frame_;
-  int loop_count_;
-  int loop_current_iteration_;
-};
-
-template<typename... Ts> class AnimationNextFrameAction : public Action<Ts...> {
- public:
-  AnimationNextFrameAction(Animation *parent) : parent_(parent) {}
-  void play(Ts... x) override { this->parent_->next_frame(); }
-
- protected:
-  Animation *parent_;
-};
-
-template<typename... Ts> class AnimationPrevFrameAction : public Action<Ts...> {
- public:
-  AnimationPrevFrameAction(Animation *parent) : parent_(parent) {}
-  void play(Ts... x) override { this->parent_->prev_frame(); }
-
- protected:
-  Animation *parent_;
-};
-
-template<typename... Ts> class AnimationSetFrameAction : public Action<Ts...> {
- public:
-  AnimationSetFrameAction(Animation *parent) : parent_(parent) {}
-  TEMPLATABLE_VALUE(uint16_t, frame)
-  void play(Ts... x) override { this->parent_->set_frame(this->frame_.value(x...)); }
-
- protected:
-  Animation *parent_;
-};
-
-}  // namespace animation
-}  // namespace esphome

esphome/components/display/animation.cpp

@@ -3,10 +3,9 @@
 #include "esphome/core/hal.h"
 
 namespace esphome {
-namespace animation {
+namespace display {
 
-Animation::Animation(const uint8_t *data_start, int width, int height, uint32_t animation_frame_count,
-                     image::ImageType type)
+Animation::Animation(const uint8_t *data_start, int width, int height, uint32_t animation_frame_count, ImageType type)
     : Image(data_start, width, height, type),
       animation_data_start_(data_start),
       current_frame_(0),
@@ -66,5 +65,5 @@ void Animation::update_data_start_() {
   this->data_start_ = this->animation_data_start_ + image_size * this->current_frame_;
 }
 
-}  // namespace animation
+}  // namespace display
 }  // namespace esphome

esphome/components/display/animation.h

@@ -0,0 +1,37 @@
+#pragma once
+#include "image.h"
+
+namespace esphome {
+namespace display {
+
+class Animation : public Image {
+ public:
+  Animation(const uint8_t *data_start, int width, int height, uint32_t animation_frame_count, ImageType type);
+
+  uint32_t get_animation_frame_count() const;
+  int get_current_frame() const;
+  void next_frame();
+  void prev_frame();
+
+  /** Selects a specific frame within the animation.
+   *
+   * @param frame If possitive, advance to the frame. If negative, recede to that frame from the end frame.
+   */
+  void set_frame(int frame);
+
+  void set_loop(uint32_t start_frame, uint32_t end_frame, int count);
+
+ protected:
+  void update_data_start_();
+
+  const uint8_t *animation_data_start_;
+  int current_frame_;
+  uint32_t animation_frame_count_;
+  uint32_t loop_start_frame_;
+  uint32_t loop_end_frame_;
+  int loop_count_;
+  int loop_current_iteration_;
+};
+
+}  // namespace display
+}  // namespace esphome

esphome/components/display/display_buffer.cpp

@@ -7,6 +7,10 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
+#include "animation.h"
+#include "image.h"
+#include "font.h"
+
 namespace esphome {
 namespace display {
 
@@ -15,6 +19,93 @@ static const char *const TAG = "display";
 const Color COLOR_OFF(0, 0, 0, 0);
 const Color COLOR_ON(255, 255, 255, 255);
 
+void Rect::expand(int16_t horizontal, int16_t vertical) {
+  if (this->is_set() && (this->w >= (-2 * horizontal)) && (this->h >= (-2 * vertical))) {
+    this->x = this->x - horizontal;
+    this->y = this->y - vertical;
+    this->w = this->w + (2 * horizontal);
+    this->h = this->h + (2 * vertical);
+  }
+}
+
+void Rect::extend(Rect rect) {
+  if (!this->is_set()) {
+    this->x = rect.x;
+    this->y = rect.y;
+    this->w = rect.w;
+    this->h = rect.h;
+  } else {
+    if (this->x > rect.x) {
+      this->w = this->w + (this->x - rect.x);
+      this->x = rect.x;
+    }
+    if (this->y > rect.y) {
+      this->h = this->h + (this->y - rect.y);
+      this->y = rect.y;
+    }
+    if (this->x2() < rect.x2()) {
+      this->w = rect.x2() - this->x;
+    }
+    if (this->y2() < rect.y2()) {
+      this->h = rect.y2() - this->y;
+    }
+  }
+}
+void Rect::shrink(Rect rect) {
+  if (!this->inside(rect)) {
+    (*this) = Rect();
+  } else {
+    if (this->x2() > rect.x2()) {
+      this->w = rect.x2() - this->x;
+    }
+    if (this->x < rect.x) {
+      this->w = this->w + (this->x - rect.x);
+      this->x = rect.x;
+    }
+    if (this->y2() > rect.y2()) {
+      this->h = rect.y2() - this->y;
+    }
+    if (this->y < rect.y) {
+      this->h = this->h + (this->y - rect.y);
+      this->y = rect.y;
+    }
+  }
+}
+
+bool Rect::equal(Rect rect) {
+  return (rect.x == this->x) && (rect.w == this->w) && (rect.y == this->y) && (rect.h == this->h);
+}
+
+bool Rect::inside(int16_t test_x, int16_t test_y, bool absolute) {  // NOLINT
+  if (!this->is_set()) {
+    return true;
+  }
+  if (absolute) {
+    return ((test_x >= this->x) && (test_x <= this->x2()) && (test_y >= this->y) && (test_y <= this->y2()));
+  } else {
+    return ((test_x >= 0) && (test_x <= this->w) && (test_y >= 0) && (test_y <= this->h));
+  }
+}
+
+bool Rect::inside(Rect rect, bool absolute) {
+  if (!this->is_set() || !rect.is_set()) {
+    return true;
+  }
+  if (absolute) {
+    return ((rect.x <= this->x2()) && (rect.x2() >= this->x) && (rect.y <= this->y2()) && (rect.y2() >= this->y));
+  } else {
+    return ((rect.x <= this->w) && (rect.w >= 0) && (rect.y <= this->h) && (rect.h >= 0));
+  }
+}
+
+void Rect::info(const std::string &prefix) {
+  if (this->is_set()) {
+    ESP_LOGI(TAG, "%s [%3d,%3d,%3d,%3d] (%3d,%3d)", prefix.c_str(), this->x, this->y, this->w, this->h, this->x2(),
+             this->y2());
+  } else
+    ESP_LOGI(TAG, "%s ** IS NOT SET **", prefix.c_str());
+}
+
 void DisplayBuffer::init_internal_(uint32_t buffer_length) {
   ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
   this->buffer_ = allocator.allocate(buffer_length);
@@ -165,14 +256,54 @@ void DisplayBuffer::filled_circle(int center_x, int center_y, int radius, Color
   } while (dx <= 0);
 }
 
-void DisplayBuffer::print(int x, int y, BaseFont *font, Color color, TextAlign align, const char *text) {
+void DisplayBuffer::print(int x, int y, Font *font, Color color, TextAlign align, const char *text) {
   int x_start, y_start;
   int width, height;
   this->get_text_bounds(x, y, text, font, align, &x_start, &y_start, &width, &height);
-  font->print(x_start, y_start, this, color, text);
+
+  int i = 0;
+  int x_at = x_start;
+  while (text[i] != '\0') {
+    int match_length;
+    int glyph_n = font->match_next_glyph(text + i, &match_length);
+    if (glyph_n < 0) {
+      // Unknown char, skip
+      ESP_LOGW(TAG, "Encountered character without representation in font: '%c'", text[i]);
+      if (!font->get_glyphs().empty()) {
+        uint8_t glyph_width = font->get_glyphs()[0].glyph_data_->width;
+        for (int glyph_x = 0; glyph_x < glyph_width; glyph_x++) {
+          for (int glyph_y = 0; glyph_y < height; glyph_y++)
+            this->draw_pixel_at(glyph_x + x_at, glyph_y + y_start, color);
+        }
+        x_at += glyph_width;
+      }
+
+      i++;
+      continue;
+    }
+
+    const Glyph &glyph = font->get_glyphs()[glyph_n];
+    int scan_x1, scan_y1, scan_width, scan_height;
+    glyph.scan_area(&scan_x1, &scan_y1, &scan_width, &scan_height);
+
+    {
+      const int glyph_x_max = scan_x1 + scan_width;
+      const int glyph_y_max = scan_y1 + scan_height;
+      for (int glyph_x = scan_x1; glyph_x < glyph_x_max; glyph_x++) {
+        for (int glyph_y = scan_y1; glyph_y < glyph_y_max; glyph_y++) {
+          if (glyph.get_pixel(glyph_x, glyph_y)) {
+            this->draw_pixel_at(glyph_x + x_at, glyph_y + y_start, color);
+          }
+        }
+      }
+    }
+
+    x_at += glyph.glyph_data_->width + glyph.glyph_data_->offset_x;
+
+    i += match_length;
+  }
 }
-void DisplayBuffer::vprintf_(int x, int y, BaseFont *font, Color color, TextAlign align, const char *format,
-                             va_list arg) {
+void DisplayBuffer::vprintf_(int x, int y, Font *font, Color color, TextAlign align, const char *format, va_list arg) {
   char buffer[256];
   int ret = vsnprintf(buffer, sizeof(buffer), format, arg);
   if (ret > 0)
@@ -227,7 +358,7 @@ void DisplayBuffer::qr_code(int x, int y, qr_code::QrCode *qr_code, Color color_
 }
 #endif  // USE_QR_CODE
 
-void DisplayBuffer::get_text_bounds(int x, int y, const char *text, BaseFont *font, TextAlign align, int *x1, int *y1,
+void DisplayBuffer::get_text_bounds(int x, int y, const char *text, Font *font, TextAlign align, int *x1, int *y1,
                                     int *width, int *height) {
   int x_offset, baseline;
   font->measure(text, width, &x_offset, &baseline, height);
@@ -265,34 +396,34 @@ void DisplayBuffer::get_text_bounds(int x, int y, const char *text, BaseFont *fo
       break;
   }
 }
-void DisplayBuffer::print(int x, int y, BaseFont *font, Color color, const char *text) {
+void DisplayBuffer::print(int x, int y, Font *font, Color color, const char *text) {
   this->print(x, y, font, color, TextAlign::TOP_LEFT, text);
 }
-void DisplayBuffer::print(int x, int y, BaseFont *font, TextAlign align, const char *text) {
+void DisplayBuffer::print(int x, int y, Font *font, TextAlign align, const char *text) {
   this->print(x, y, font, COLOR_ON, align, text);
 }
-void DisplayBuffer::print(int x, int y, BaseFont *font, const char *text) {
+void DisplayBuffer::print(int x, int y, Font *font, const char *text) {
   this->print(x, y, font, COLOR_ON, TextAlign::TOP_LEFT, text);
 }
-void DisplayBuffer::printf(int x, int y, BaseFont *font, Color color, TextAlign align, const char *format, ...) {
+void DisplayBuffer::printf(int x, int y, Font *font, Color color, TextAlign align, const char *format, ...) {
   va_list arg;
   va_start(arg, format);
   this->vprintf_(x, y, font, color, align, format, arg);
   va_end(arg);
 }
-void DisplayBuffer::printf(int x, int y, BaseFont *font, Color color, const char *format, ...) {
+void DisplayBuffer::printf(int x, int y, Font *font, Color color, const char *format, ...) {
   va_list arg;
   va_start(arg, format);
   this->vprintf_(x, y, font, color, TextAlign::TOP_LEFT, format, arg);
   va_end(arg);
 }
-void DisplayBuffer::printf(int x, int y, BaseFont *font, TextAlign align, const char *format, ...) {
+void DisplayBuffer::printf(int x, int y, Font *font, TextAlign align, const char *format, ...) {
   va_list arg;
   va_start(arg, format);
   this->vprintf_(x, y, font, COLOR_ON, align, format, arg);
   va_end(arg);
 }
-void DisplayBuffer::printf(int x, int y, BaseFont *font, const char *format, ...) {
+void DisplayBuffer::printf(int x, int y, Font *font, const char *format, ...) {
   va_list arg;
   va_start(arg, format);
   this->vprintf_(x, y, font, COLOR_ON, TextAlign::TOP_LEFT, format, arg);
@@ -339,20 +470,19 @@ void DisplayOnPageChangeTrigger::process(DisplayPage *from, DisplayPage *to) {
   if ((this->from_ == nullptr || this->from_ == from) && (this->to_ == nullptr || this->to_ == to))
     this->trigger(from, to);
 }
-void DisplayBuffer::strftime(int x, int y, BaseFont *font, Color color, TextAlign align, const char *format,
-                             ESPTime time) {
+void DisplayBuffer::strftime(int x, int y, Font *font, Color color, TextAlign align, const char *format, ESPTime time) {
   char buffer[64];
   size_t ret = time.strftime(buffer, sizeof(buffer), format);
   if (ret > 0)
     this->print(x, y, font, color, align, buffer);
 }
-void DisplayBuffer::strftime(int x, int y, BaseFont *font, Color color, const char *format, ESPTime time) {
+void DisplayBuffer::strftime(int x, int y, Font *font, Color color, const char *format, ESPTime time) {
   this->strftime(x, y, font, color, TextAlign::TOP_LEFT, format, time);
 }
-void DisplayBuffer::strftime(int x, int y, BaseFont *font, TextAlign align, const char *format, ESPTime time) {
+void DisplayBuffer::strftime(int x, int y, Font *font, TextAlign align, const char *format, ESPTime time) {
   this->strftime(x, y, font, COLOR_ON, align, format, time);
 }
-void DisplayBuffer::strftime(int x, int y, BaseFont *font, const char *format, ESPTime time) {
+void DisplayBuffer::strftime(int x, int y, Font *font, const char *format, ESPTime time) {
   this->strftime(x, y, font, COLOR_ON, TextAlign::TOP_LEFT, format, time);
 }
 

esphome/components/display/display_buffer.h

@@ -2,7 +2,6 @@
 
 #include <cstdarg>
 #include <vector>
-#include "rect.h"
 #include "display_color_utils.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
@@ -17,6 +16,10 @@
 #include "esphome/components/qr_code/qr_code.h"
 #endif
 
+#include "animation.h"
+#include "font.h"
+#include "image.h"
+
 namespace esphome {
 namespace display {
 
@@ -132,6 +135,33 @@ enum DisplayRotation {
   DISPLAY_ROTATION_270_DEGREES = 270,
 };
 
+static const int16_t VALUE_NO_SET = 32766;
+
+class Rect {
+ public:
+  int16_t x;  ///< X coordinate of corner
+  int16_t y;  ///< Y coordinate of corner
+  int16_t w;  ///< Width of region
+  int16_t h;  ///< Height of region
+
+  Rect() : x(VALUE_NO_SET), y(VALUE_NO_SET), w(VALUE_NO_SET), h(VALUE_NO_SET) {}  // NOLINT
+  inline Rect(int16_t x, int16_t y, int16_t w, int16_t h) ALWAYS_INLINE : x(x), y(y), w(w), h(h) {}
+  inline int16_t x2() { return this->x + this->w; };  ///< X coordinate of corner
+  inline int16_t y2() { return this->y + this->h; };  ///< Y coordinate of corner
+
+  inline bool is_set() ALWAYS_INLINE { return (this->h != VALUE_NO_SET) && (this->w != VALUE_NO_SET); }
+
+  void expand(int16_t horizontal, int16_t vertical);
+
+  void extend(Rect rect);
+  void shrink(Rect rect);
+
+  bool inside(Rect rect, bool absolute = true);
+  bool inside(int16_t test_x, int16_t test_y, bool absolute = true);
+  bool equal(Rect rect);
+  void info(const std::string &prefix = "rect info:");
+};
+
 class DisplayBuffer;
 class DisplayPage;
 class DisplayOnPageChangeTrigger;
@@ -145,24 +175,6 @@ using display_writer_t = std::function<void(DisplayBuffer &)>;
     ESP_LOGCONFIG(TAG, "%s  Dimensions: %dpx x %dpx", prefix, (obj)->get_width(), (obj)->get_height()); \
   }
 
-/// Turn the pixel OFF.
-extern const Color COLOR_OFF;
-/// Turn the pixel ON.
-extern const Color COLOR_ON;
-
-class BaseImage {
- public:
-  virtual void draw(int x, int y, DisplayBuffer *display, Color color_on, Color color_off) = 0;
-  virtual int get_width() const = 0;
-  virtual int get_height() const = 0;
-};
-
-class BaseFont {
- public:
-  virtual void print(int x, int y, DisplayBuffer *display, Color color, const char *text) = 0;
-  virtual void measure(const char *str, int *width, int *x_offset, int *baseline, int *height) = 0;
-};
-
 class DisplayBuffer {
  public:
   /// Fill the entire screen with the given color.
@@ -209,7 +221,7 @@ class DisplayBuffer {
    * @param align The alignment of the text.
    * @param text The text to draw.
    */
-  void print(int x, int y, BaseFont *font, Color color, TextAlign align, const char *text);
+  void print(int x, int y, Font *font, Color color, TextAlign align, const char *text);
 
   /** Print `text` with the top left at [x,y] with `font`.
    *
@@ -219,7 +231,7 @@ class DisplayBuffer {
    * @param color The color to draw the text with.
    * @param text The text to draw.
    */
-  void print(int x, int y, BaseFont *font, Color color, const char *text);
+  void print(int x, int y, Font *font, Color color, const char *text);
 
   /** Print `text` with the anchor point at [x,y] with `font`.
    *
@@ -229,7 +241,7 @@ class DisplayBuffer {
    * @param align The alignment of the text.
    * @param text The text to draw.
    */
-  void print(int x, int y, BaseFont *font, TextAlign align, const char *text);
+  void print(int x, int y, Font *font, TextAlign align, const char *text);
 
   /** Print `text` with the top left at [x,y] with `font`.
    *
@@ -238,7 +250,7 @@ class DisplayBuffer {
    * @param font The font to draw the text with.
    * @param text The text to draw.
    */
-  void print(int x, int y, BaseFont *font, const char *text);
+  void print(int x, int y, Font *font, const char *text);
 
   /** Evaluate the printf-format `format` and print the result with the anchor point at [x,y] with `font`.
    *
@@ -250,7 +262,7 @@ class DisplayBuffer {
    * @param format The format to use.
    * @param ... The arguments to use for the text formatting.
    */
-  void printf(int x, int y, BaseFont *font, Color color, TextAlign align, const char *format, ...)
+  void printf(int x, int y, Font *font, Color color, TextAlign align, const char *format, ...)
       __attribute__((format(printf, 7, 8)));
 
   /** Evaluate the printf-format `format` and print the result with the top left at [x,y] with `font`.
@@ -262,7 +274,7 @@ class DisplayBuffer {
    * @param format The format to use.
    * @param ... The arguments to use for the text formatting.
    */
-  void printf(int x, int y, BaseFont *font, Color color, const char *format, ...) __attribute__((format(printf, 6, 7)));
+  void printf(int x, int y, Font *font, Color color, const char *format, ...) __attribute__((format(printf, 6, 7)));
 
   /** Evaluate the printf-format `format` and print the result with the anchor point at [x,y] with `font`.
    *
@@ -273,8 +285,7 @@ class DisplayBuffer {
    * @param format The format to use.
    * @param ... The arguments to use for the text formatting.
    */
-  void printf(int x, int y, BaseFont *font, TextAlign align, const char *format, ...)
-      __attribute__((format(printf, 6, 7)));
+  void printf(int x, int y, Font *font, TextAlign align, const char *format, ...) __attribute__((format(printf, 6, 7)));
 
   /** Evaluate the printf-format `format` and print the result with the top left at [x,y] with `font`.
    *
@@ -284,7 +295,7 @@ class DisplayBuffer {
    * @param format The format to use.
    * @param ... The arguments to use for the text formatting.
    */
-  void printf(int x, int y, BaseFont *font, const char *format, ...) __attribute__((format(printf, 5, 6)));
+  void printf(int x, int y, Font *font, const char *format, ...) __attribute__((format(printf, 5, 6)));
 
   /** Evaluate the strftime-format `format` and print the result with the anchor point at [x,y] with `font`.
    *
@@ -296,7 +307,7 @@ class DisplayBuffer {
    * @param format The strftime format to use.
    * @param time The time to format.
    */
-  void strftime(int x, int y, BaseFont *font, Color color, TextAlign align, const char *format, ESPTime time)
+  void strftime(int x, int y, Font *font, Color color, TextAlign align, const char *format, ESPTime time)
       __attribute__((format(strftime, 7, 0)));
 
   /** Evaluate the strftime-format `format` and print the result with the top left at [x,y] with `font`.
@@ -308,7 +319,7 @@ class DisplayBuffer {
    * @param format The strftime format to use.
    * @param time The time to format.
    */
-  void strftime(int x, int y, BaseFont *font, Color color, const char *format, ESPTime time)
+  void strftime(int x, int y, Font *font, Color color, const char *format, ESPTime time)
       __attribute__((format(strftime, 6, 0)));
 
   /** Evaluate the strftime-format `format` and print the result with the anchor point at [x,y] with `font`.
@@ -320,7 +331,7 @@ class DisplayBuffer {
    * @param format The strftime format to use.
    * @param time The time to format.
    */
-  void strftime(int x, int y, BaseFont *font, TextAlign align, const char *format, ESPTime time)
+  void strftime(int x, int y, Font *font, TextAlign align, const char *format, ESPTime time)
       __attribute__((format(strftime, 6, 0)));
 
   /** Evaluate the strftime-format `format` and print the result with the top left at [x,y] with `font`.
@@ -331,7 +342,7 @@ class DisplayBuffer {
    * @param format The strftime format to use.
    * @param time The time to format.
    */
-  void strftime(int x, int y, BaseFont *font, const char *format, ESPTime time) __attribute__((format(strftime, 5, 0)));
+  void strftime(int x, int y, Font *font, const char *format, ESPTime time) __attribute__((format(strftime, 5, 0)));
 
   /** Draw the `image` with the top-left corner at [x,y] to the screen.
    *
@@ -401,7 +412,7 @@ class DisplayBuffer {
    * @param width A pointer to store the returned text width in.
    * @param height A pointer to store the returned text height in.
    */
-  void get_text_bounds(int x, int y, const char *text, BaseFont *font, TextAlign align, int *x1, int *y1, int *width,
+  void get_text_bounds(int x, int y, const char *text, Font *font, TextAlign align, int *x1, int *y1, int *width,
                        int *height);
 
   /// Internal method to set the display writer lambda.
@@ -476,7 +487,7 @@ class DisplayBuffer {
   bool is_clipping() const { return !this->clipping_rectangle_.empty(); }
 
  protected:
-  void vprintf_(int x, int y, BaseFont *font, Color color, TextAlign align, const char *format, va_list arg);
+  void vprintf_(int x, int y, Font *font, Color color, TextAlign align, const char *format, va_list arg);
 
   virtual void draw_absolute_pixel_internal(int x, int y, Color color) = 0;
 

esphome/components/display/font.cpp

@@ -1,35 +1,18 @@
 #include "font.h"
 
 #include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-#include "esphome/core/color.h"
-#include "esphome/components/display/display_buffer.h"
 
 namespace esphome {
-namespace font {
+namespace display {
 
-static const char *const TAG = "font";
-
-void Glyph::draw(int x_at, int y_start, display::DisplayBuffer *display, Color color) const {
-  int scan_x1, scan_y1, scan_width, scan_height;
-  this->scan_area(&scan_x1, &scan_y1, &scan_width, &scan_height);
-
-  const unsigned char *data = this->glyph_data_->data;
-  const int max_x = x_at + scan_x1 + scan_width;
-  const int max_y = y_start + scan_y1 + scan_height;
-
-  for (int glyph_y = y_start + scan_y1; glyph_y < max_y; glyph_y++) {
-    for (int glyph_x = x_at + scan_x1; glyph_x < max_x; data++, glyph_x += 8) {
-      uint8_t pixel_data = progmem_read_byte(data);
-      const int pixel_max_x = std::min(max_x, glyph_x + 8);
-
-      for (int pixel_x = glyph_x; pixel_x < pixel_max_x && pixel_data; pixel_x++, pixel_data <<= 1) {
-        if (pixel_data & 0x80) {
-          display->draw_pixel_at(pixel_x, glyph_y, color);
-        }
-      }
-    }
-  }
+bool Glyph::get_pixel(int x, int y) const {
+  const int x_data = x - this->glyph_data_->offset_x;
+  const int y_data = y - this->glyph_data_->offset_y;
+  if (x_data < 0 || x_data >= this->glyph_data_->width || y_data < 0 || y_data >= this->glyph_data_->height)
+    return false;
+  const uint32_t width_8 = ((this->glyph_data_->width + 7u) / 8u) * 8u;
+  const uint32_t pos = x_data + y_data * width_8;
+  return progmem_read_byte(this->glyph_data_->data + (pos / 8u)) & (0x80 >> (pos % 8u));
 }
 const char *Glyph::get_char() const { return this->glyph_data_->a_char; }
 bool Glyph::compare_to(const char *str) const {
@@ -64,12 +47,6 @@ void Glyph::scan_area(int *x1, int *y1, int *width, int *height) const {
   *width = this->glyph_data_->width;
   *height = this->glyph_data_->height;
 }
-
-Font::Font(const GlyphData *data, int data_nr, int baseline, int height) : baseline_(baseline), height_(height) {
-  glyphs_.reserve(data_nr);
-  for (int i = 0; i < data_nr; ++i)
-    glyphs_.emplace_back(&data[i]);
-}
 int Font::match_next_glyph(const char *str, int *match_length) {
   int lo = 0;
   int hi = this->glyphs_.size() - 1;
@@ -118,32 +95,11 @@ void Font::measure(const char *str, int *width, int *x_offset, int *baseline, in
   *x_offset = min_x;
   *width = x - min_x;
 }
-void Font::print(int x_start, int y_start, display::DisplayBuffer *display, Color color, const char *text) {
-  int i = 0;
-  int x_at = x_start;
-  while (text[i] != '\0') {
-    int match_length;
-    int glyph_n = this->match_next_glyph(text + i, &match_length);
-    if (glyph_n < 0) {
-      // Unknown char, skip
-      ESP_LOGW(TAG, "Encountered character without representation in font: '%c'", text[i]);
-      if (!this->get_glyphs().empty()) {
-        uint8_t glyph_width = this->get_glyphs()[0].glyph_data_->width;
-        display->filled_rectangle(x_at, y_start, glyph_width, this->height_, color);
-        x_at += glyph_width;
-      }
-
-      i++;
-      continue;
-    }
-
-    const Glyph &glyph = this->get_glyphs()[glyph_n];
-    glyph.draw(x_at, y_start, display, color);
-    x_at += glyph.glyph_data_->width + glyph.glyph_data_->offset_x;
-
-    i += match_length;
-  }
+Font::Font(const GlyphData *data, int data_nr, int baseline, int height) : baseline_(baseline), height_(height) {
+  glyphs_.reserve(data_nr);
+  for (int i = 0; i < data_nr; ++i)
+    glyphs_.emplace_back(&data[i]);
 }
 
-}  // namespace font
+}  // namespace display
 }  // namespace esphome

esphome/components/display/font.h

@@ -1,12 +1,11 @@
 #pragma once
 
 #include "esphome/core/datatypes.h"
-#include "esphome/core/color.h"
-#include "esphome/components/display/display_buffer.h"
 
 namespace esphome {
-namespace font {
+namespace display {
 
+class DisplayBuffer;
 class Font;
 
 struct GlyphData {
@@ -22,7 +21,7 @@ class Glyph {
  public:
   Glyph(const GlyphData *data) : glyph_data_(data) {}
 
-  void draw(int x, int y, display::DisplayBuffer *display, Color color) const;
+  bool get_pixel(int x, int y) const;
 
   const char *get_char() const;
 
@@ -34,11 +33,12 @@ class Glyph {
 
  protected:
   friend Font;
+  friend DisplayBuffer;
 
   const GlyphData *glyph_data_;
 };
 
-class Font : public display::BaseFont {
+class Font {
  public:
   /** Construct the font with the given glyphs.
    *
@@ -50,8 +50,7 @@ class Font : public display::BaseFont {
 
   int match_next_glyph(const char *str, int *match_length);
 
-  void print(int x_start, int y_start, display::DisplayBuffer *display, Color color, const char *text) override;
-  void measure(const char *str, int *width, int *x_offset, int *baseline, int *height) override;
+  void measure(const char *str, int *width, int *x_offset, int *baseline, int *height);
   inline int get_baseline() { return this->baseline_; }
   inline int get_height() { return this->height_; }
 
@@ -63,5 +62,5 @@ class Font : public display::BaseFont {
   int height_;
 };
 
-}  // namespace font
+}  // namespace display
 }  // namespace esphome

esphome/components/display/image.cpp

@@ -1,11 +1,12 @@
 #include "image.h"
 
 #include "esphome/core/hal.h"
+#include "display_buffer.h"
 
 namespace esphome {
-namespace image {
+namespace display {
 
-void Image::draw(int x, int y, display::DisplayBuffer *display, Color color_on, Color color_off) {
+void Image::draw(int x, int y, DisplayBuffer *display, Color color_on, Color color_off) {
   switch (type_) {
     case IMAGE_TYPE_BINARY: {
       for (int img_x = 0; img_x < width_; img_x++) {
@@ -130,5 +131,5 @@ ImageType Image::get_type() const { return this->type_; }
 Image::Image(const uint8_t *data_start, int width, int height, ImageType type)
     : width_(width), height_(height), type_(type), data_start_(data_start) {}
 
-}  // namespace image
+}  // namespace display
 }  // namespace esphome

esphome/components/display/image.h

@@ -1,9 +1,8 @@
 #pragma once
 #include "esphome/core/color.h"
-#include "esphome/components/display/display_buffer.h"
 
 namespace esphome {
-namespace image {
+namespace display {
 
 enum ImageType {
   IMAGE_TYPE_BINARY = 0,
@@ -31,15 +30,29 @@ inline int image_type_to_bpp(ImageType type) {
 
 inline int image_type_to_width_stride(int width, ImageType type) { return (width * image_type_to_bpp(type) + 7u) / 8u; }
 
-class Image : public display::BaseImage {
+/// Turn the pixel OFF.
+extern const Color COLOR_OFF;
+/// Turn the pixel ON.
+extern const Color COLOR_ON;
+
+class DisplayBuffer;
+
+class BaseImage {
+ public:
+  virtual void draw(int x, int y, DisplayBuffer *display, Color color_on, Color color_off) = 0;
+  virtual int get_width() const = 0;
+  virtual int get_height() const = 0;
+};
+
+class Image : public BaseImage {
  public:
   Image(const uint8_t *data_start, int width, int height, ImageType type);
-  Color get_pixel(int x, int y, Color color_on = display::COLOR_ON, Color color_off = display::COLOR_OFF) const;
+  Color get_pixel(int x, int y, Color color_on = COLOR_ON, Color color_off = COLOR_OFF) const;
   int get_width() const override;
   int get_height() const override;
   ImageType get_type() const;
 
-  void draw(int x, int y, display::DisplayBuffer *display, Color color_on, Color color_off) override;
+  void draw(int x, int y, DisplayBuffer *display, Color color_on, Color color_off) override;
 
   void set_transparency(bool transparent) { transparent_ = transparent; }
   bool has_transparency() const { return transparent_; }
@@ -58,5 +71,5 @@ class Image : public display::BaseImage {
   bool transparent_;
 };
 
-}  // namespace image
+}  // namespace display
 }  // namespace esphome

esphome/components/display/rect.cpp

@@ -1,98 +0,0 @@
-#include "rect.h"
-
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace display {
-
-static const char *const TAG = "display";
-
-void Rect::expand(int16_t horizontal, int16_t vertical) {
-  if (this->is_set() && (this->w >= (-2 * horizontal)) && (this->h >= (-2 * vertical))) {
-    this->x = this->x - horizontal;
-    this->y = this->y - vertical;
-    this->w = this->w + (2 * horizontal);
-    this->h = this->h + (2 * vertical);
-  }
-}
-
-void Rect::extend(Rect rect) {
-  if (!this->is_set()) {
-    this->x = rect.x;
-    this->y = rect.y;
-    this->w = rect.w;
-    this->h = rect.h;
-  } else {
-    if (this->x > rect.x) {
-      this->w = this->w + (this->x - rect.x);
-      this->x = rect.x;
-    }
-    if (this->y > rect.y) {
-      this->h = this->h + (this->y - rect.y);
-      this->y = rect.y;
-    }
-    if (this->x2() < rect.x2()) {
-      this->w = rect.x2() - this->x;
-    }
-    if (this->y2() < rect.y2()) {
-      this->h = rect.y2() - this->y;
-    }
-  }
-}
-void Rect::shrink(Rect rect) {
-  if (!this->inside(rect)) {
-    (*this) = Rect();
-  } else {
-    if (this->x2() > rect.x2()) {
-      this->w = rect.x2() - this->x;
-    }
-    if (this->x < rect.x) {
-      this->w = this->w + (this->x - rect.x);
-      this->x = rect.x;
-    }
-    if (this->y2() > rect.y2()) {
-      this->h = rect.y2() - this->y;
-    }
-    if (this->y < rect.y) {
-      this->h = this->h + (this->y - rect.y);
-      this->y = rect.y;
-    }
-  }
-}
-
-bool Rect::equal(Rect rect) {
-  return (rect.x == this->x) && (rect.w == this->w) && (rect.y == this->y) && (rect.h == this->h);
-}
-
-bool Rect::inside(int16_t test_x, int16_t test_y, bool absolute) {  // NOLINT
-  if (!this->is_set()) {
-    return true;
-  }
-  if (absolute) {
-    return ((test_x >= this->x) && (test_x <= this->x2()) && (test_y >= this->y) && (test_y <= this->y2()));
-  } else {
-    return ((test_x >= 0) && (test_x <= this->w) && (test_y >= 0) && (test_y <= this->h));
-  }
-}
-
-bool Rect::inside(Rect rect, bool absolute) {
-  if (!this->is_set() || !rect.is_set()) {
-    return true;
-  }
-  if (absolute) {
-    return ((rect.x <= this->x2()) && (rect.x2() >= this->x) && (rect.y <= this->y2()) && (rect.y2() >= this->y));
-  } else {
-    return ((rect.x <= this->w) && (rect.w >= 0) && (rect.y <= this->h) && (rect.h >= 0));
-  }
-}
-
-void Rect::info(const std::string &prefix) {
-  if (this->is_set()) {
-    ESP_LOGI(TAG, "%s [%3d,%3d,%3d,%3d] (%3d,%3d)", prefix.c_str(), this->x, this->y, this->w, this->h, this->x2(),
-             this->y2());
-  } else
-    ESP_LOGI(TAG, "%s ** IS NOT SET **", prefix.c_str());
-}
-
-}  // namespace display
-}  // namespace esphome

esphome/components/display/rect.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include "esphome/core/helpers.h"
-
-namespace esphome {
-namespace display {
-
-static const int16_t VALUE_NO_SET = 32766;
-
-class Rect {
- public:
-  int16_t x;  ///< X coordinate of corner
-  int16_t y;  ///< Y coordinate of corner
-  int16_t w;  ///< Width of region
-  int16_t h;  ///< Height of region
-
-  Rect() : x(VALUE_NO_SET), y(VALUE_NO_SET), w(VALUE_NO_SET), h(VALUE_NO_SET) {}  // NOLINT
-  inline Rect(int16_t x, int16_t y, int16_t w, int16_t h) ALWAYS_INLINE : x(x), y(y), w(w), h(h) {}
-  inline int16_t x2() { return this->x + this->w; };  ///< X coordinate of corner
-  inline int16_t y2() { return this->y + this->h; };  ///< Y coordinate of corner
-
-  inline bool is_set() ALWAYS_INLINE { return (this->h != VALUE_NO_SET) && (this->w != VALUE_NO_SET); }
-
-  void expand(int16_t horizontal, int16_t vertical);
-
-  void extend(Rect rect);
-  void shrink(Rect rect);
-
-  bool inside(Rect rect, bool absolute = true);
-  bool inside(int16_t test_x, int16_t test_y, bool absolute = true);
-  bool equal(Rect rect);
-  void info(const std::string &prefix = "rect info:");
-};
-
-}  // namespace display
-}  // namespace esphome

esphome/components/dsmr/__init__.py

@@ -19,7 +19,6 @@ CONF_CRC_CHECK = "crc_check"
 CONF_DECRYPTION_KEY = "decryption_key"
 CONF_DSMR_ID = "dsmr_id"
 CONF_GAS_MBUS_ID = "gas_mbus_id"
-CONF_WATER_MBUS_ID = "water_mbus_id"
 CONF_MAX_TELEGRAM_LENGTH = "max_telegram_length"
 CONF_REQUEST_INTERVAL = "request_interval"
 CONF_REQUEST_PIN = "request_pin"
@@ -54,7 +53,6 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_DECRYPTION_KEY): _validate_key,
             cv.Optional(CONF_CRC_CHECK, default=True): cv.boolean,
             cv.Optional(CONF_GAS_MBUS_ID, default=1): cv.int_,
-            cv.Optional(CONF_WATER_MBUS_ID, default=2): cv.int_,
             cv.Optional(CONF_MAX_TELEGRAM_LENGTH, default=1500): cv.int_,
             cv.Optional(CONF_REQUEST_PIN): pins.gpio_output_pin_schema,
             cv.Optional(
@@ -84,10 +82,9 @@ async def to_code(config):
     cg.add(var.set_receive_timeout(config[CONF_RECEIVE_TIMEOUT].total_milliseconds))
 
     cg.add_build_flag("-DDSMR_GAS_MBUS_ID=" + str(config[CONF_GAS_MBUS_ID]))
-    cg.add_build_flag("-DDSMR_WATER_MBUS_ID=" + str(config[CONF_WATER_MBUS_ID]))
 
     # DSMR Parser
-    cg.add_library("glmnet/Dsmr", "0.7")
+    cg.add_library("glmnet/Dsmr", "0.5")
 
     # Crypto
     cg.add_library("rweather/Crypto", "0.4.0")

esphome/components/dsmr/sensor.py

@@ -8,7 +8,6 @@ from esphome.const import (
     DEVICE_CLASS_GAS,
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_VOLTAGE,
-    DEVICE_CLASS_WATER,
     STATE_CLASS_MEASUREMENT,
     STATE_CLASS_TOTAL_INCREASING,
     UNIT_AMPERE,
@@ -237,12 +236,6 @@ CONFIG_SCHEMA = cv.Schema(
             device_class=DEVICE_CLASS_GAS,
             state_class=STATE_CLASS_TOTAL_INCREASING,
         ),
-        cv.Optional("water_delivered"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_CUBIC_METER,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_WATER,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 

esphome/components/font/__init__.py

@@ -7,6 +7,7 @@ import re
 import requests
 
 from esphome import core
+from esphome.components import display
 import esphome.config_validation as cv
 import esphome.codegen as cg
 from esphome.helpers import copy_file_if_changed
@@ -28,11 +29,9 @@ DOMAIN = "font"
 DEPENDENCIES = ["display"]
 MULTI_CONF = True
 
-font_ns = cg.esphome_ns.namespace("font")
-
-Font = font_ns.class_("Font")
-Glyph = font_ns.class_("Glyph")
-GlyphData = font_ns.struct("GlyphData")
+Font = display.display_ns.class_("Font")
+Glyph = display.display_ns.class_("Glyph")
+GlyphData = display.display_ns.struct("GlyphData")
 
 
 def validate_glyphs(value):

esphome/components/graph/graph.h

@@ -11,7 +11,7 @@ namespace esphome {
 // forward declare DisplayBuffer
 namespace display {
 class DisplayBuffer;
-class BaseFont;
+class Font;
 }  // namespace display
 
 namespace graph {
@@ -45,8 +45,8 @@ enum ValuePositionType {
 class GraphLegend {
  public:
   void init(Graph *g);
-  void set_name_font(display::BaseFont *font) { this->font_label_ = font; }
-  void set_value_font(display::BaseFont *font) { this->font_value_ = font; }
+  void set_name_font(display::Font *font) { this->font_label_ = font; }
+  void set_value_font(display::Font *font) { this->font_value_ = font; }
   void set_width(uint32_t width) { this->width_ = width; }
   void set_height(uint32_t height) { this->height_ = height; }
   void set_border(bool val) { this->border_ = val; }
@@ -63,8 +63,8 @@ class GraphLegend {
   ValuePositionType values_{VALUE_POSITION_TYPE_AUTO};
   bool units_{true};
   DirectionType direction_{DIRECTION_TYPE_AUTO};
-  display::BaseFont *font_label_{nullptr};
-  display::BaseFont *font_value_{nullptr};
+  display::Font *font_label_{nullptr};
+  display::Font *font_value_{nullptr};
   // Calculated values
   Graph *parent_{nullptr};
   //                      (x0)          (xs,ys)         (xs,ys)

esphome/components/haier/__init__.py

@@ -0,0 +1 @@
+CODEOWNERS = ["@Yarikx"]

esphome/components/haier/automation.h

@@ -1,130 +0,0 @@
-#pragma once
-
-#include "esphome/core/automation.h"
-#include "haier_base.h"
-#include "hon_climate.h"
-
-namespace esphome {
-namespace haier {
-
-template<typename... Ts> class DisplayOnAction : public Action<Ts...> {
- public:
-  DisplayOnAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(Ts... x) { this->parent_->set_display_state(true); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-template<typename... Ts> class DisplayOffAction : public Action<Ts...> {
- public:
-  DisplayOffAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(Ts... x) { this->parent_->set_display_state(false); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-template<typename... Ts> class BeeperOnAction : public Action<Ts...> {
- public:
-  BeeperOnAction(HonClimate *parent) : parent_(parent) {}
-  void play(Ts... x) { this->parent_->set_beeper_state(true); }
-
- protected:
-  HonClimate *parent_;
-};
-
-template<typename... Ts> class BeeperOffAction : public Action<Ts...> {
- public:
-  BeeperOffAction(HonClimate *parent) : parent_(parent) {}
-  void play(Ts... x) { this->parent_->set_beeper_state(false); }
-
- protected:
-  HonClimate *parent_;
-};
-
-template<typename... Ts> class VerticalAirflowAction : public Action<Ts...> {
- public:
-  VerticalAirflowAction(HonClimate *parent) : parent_(parent) {}
-  TEMPLATABLE_VALUE(AirflowVerticalDirection, direction)
-  void play(Ts... x) { this->parent_->set_vertical_airflow(this->direction_.value(x...)); }
-
- protected:
-  HonClimate *parent_;
-};
-
-template<typename... Ts> class HorizontalAirflowAction : public Action<Ts...> {
- public:
-  HorizontalAirflowAction(HonClimate *parent) : parent_(parent) {}
-  TEMPLATABLE_VALUE(AirflowHorizontalDirection, direction)
-  void play(Ts... x) { this->parent_->set_horizontal_airflow(this->direction_.value(x...)); }
-
- protected:
-  HonClimate *parent_;
-};
-
-template<typename... Ts> class HealthOnAction : public Action<Ts...> {
- public:
-  HealthOnAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(Ts... x) { this->parent_->set_health_mode(true); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-template<typename... Ts> class HealthOffAction : public Action<Ts...> {
- public:
-  HealthOffAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(Ts... x) { this->parent_->set_health_mode(false); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-template<typename... Ts> class StartSelfCleaningAction : public Action<Ts...> {
- public:
-  StartSelfCleaningAction(HonClimate *parent) : parent_(parent) {}
-  void play(Ts... x) { this->parent_->start_self_cleaning(); }
-
- protected:
-  HonClimate *parent_;
-};
-
-template<typename... Ts> class StartSteriCleaningAction : public Action<Ts...> {
- public:
-  StartSteriCleaningAction(HonClimate *parent) : parent_(parent) {}
-  void play(Ts... x) { this->parent_->start_steri_cleaning(); }
-
- protected:
-  HonClimate *parent_;
-};
-
-template<typename... Ts> class PowerOnAction : public Action<Ts...> {
- public:
-  PowerOnAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(Ts... x) { this->parent_->send_power_on_command(); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-template<typename... Ts> class PowerOffAction : public Action<Ts...> {
- public:
-  PowerOffAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(Ts... x) { this->parent_->send_power_off_command(); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-template<typename... Ts> class PowerToggleAction : public Action<Ts...> {
- public:
-  PowerToggleAction(HaierClimateBase *parent) : parent_(parent) {}
-  void play(Ts... x) { this->parent_->toggle_power(); }
-
- protected:
-  HaierClimateBase *parent_;
-};
-
-}  // namespace haier
-}  // namespace esphome

esphome/components/haier/climate.py

@@ -1,364 +1,43 @@
-import logging
+from esphome.components import climate
 import esphome.codegen as cg
 import esphome.config_validation as cv
-import esphome.final_validate as fv
-from esphome.components import uart, sensor, climate, logger
-from esphome import automation
-from esphome.const import (
-    CONF_BEEPER,
-    CONF_ID,
-    CONF_LEVEL,
-    CONF_LOGGER,
-    CONF_LOGS,
-    CONF_MAX_TEMPERATURE,
-    CONF_MIN_TEMPERATURE,
-    CONF_PROTOCOL,
-    CONF_SUPPORTED_MODES,
-    CONF_SUPPORTED_SWING_MODES,
-    CONF_VISUAL,
-    CONF_WIFI,
-    DEVICE_CLASS_TEMPERATURE,
-    ICON_THERMOMETER,
-    STATE_CLASS_MEASUREMENT,
-    UNIT_CELSIUS,
-)
-from esphome.components.climate import (
-    ClimateSwingMode,
-    ClimateMode,
-)
+from esphome.components import uart
+from esphome.components.climate import ClimateSwingMode
+from esphome.const import CONF_ID, CONF_SUPPORTED_SWING_MODES
 
-_LOGGER = logging.getLogger(__name__)
-
-PROTOCOL_MIN_TEMPERATURE = 16.0
-PROTOCOL_MAX_TEMPERATURE = 30.0
-PROTOCOL_TEMPERATURE_STEP = 1.0
-
-CODEOWNERS = ["@paveldn"]
-AUTO_LOAD = ["sensor"]
-DEPENDENCIES = ["climate", "uart"]
-CONF_WIFI_SIGNAL = "wifi_signal"
-CONF_OUTDOOR_TEMPERATURE = "outdoor_temperature"
-CONF_VERTICAL_AIRFLOW = "vertical_airflow"
-CONF_HORIZONTAL_AIRFLOW = "horizontal_airflow"
-
-
-PROTOCOL_HON = "HON"
-PROTOCOL_SMARTAIR2 = "SMARTAIR2"
-PROTOCOLS_SUPPORTED = [PROTOCOL_HON, PROTOCOL_SMARTAIR2]
+DEPENDENCIES = ["uart"]
 
 haier_ns = cg.esphome_ns.namespace("haier")
-HaierClimateBase = haier_ns.class_(
-    "HaierClimateBase", uart.UARTDevice, climate.Climate, cg.Component
+HaierClimate = haier_ns.class_(
+    "HaierClimate", climate.Climate, cg.PollingComponent, uart.UARTDevice
 )
-HonClimate = haier_ns.class_("HonClimate", HaierClimateBase)
-Smartair2Climate = haier_ns.class_("Smartair2Climate", HaierClimateBase)
 
-
-AirflowVerticalDirection = haier_ns.enum("AirflowVerticalDirection")
-AIRFLOW_VERTICAL_DIRECTION_OPTIONS = {
-    "UP": AirflowVerticalDirection.UP,
-    "CENTER": AirflowVerticalDirection.CENTER,
-    "DOWN": AirflowVerticalDirection.DOWN,
-}
-
-AirflowHorizontalDirection = haier_ns.enum("AirflowHorizontalDirection")
-AIRFLOW_HORIZONTAL_DIRECTION_OPTIONS = {
-    "LEFT": AirflowHorizontalDirection.LEFT,
-    "CENTER": AirflowHorizontalDirection.CENTER,
-    "RIGHT": AirflowHorizontalDirection.RIGHT,
-}
-
-SUPPORTED_SWING_MODES_OPTIONS = {
-    "OFF": ClimateSwingMode.CLIMATE_SWING_OFF,  # always available
-    "VERTICAL": ClimateSwingMode.CLIMATE_SWING_VERTICAL,  # always available
-    "HORIZONTAL": ClimateSwingMode.CLIMATE_SWING_HORIZONTAL,
+ALLOWED_CLIMATE_SWING_MODES = {
     "BOTH": ClimateSwingMode.CLIMATE_SWING_BOTH,
+    "VERTICAL": ClimateSwingMode.CLIMATE_SWING_VERTICAL,
+    "HORIZONTAL": ClimateSwingMode.CLIMATE_SWING_HORIZONTAL,
 }
 
-SUPPORTED_CLIMATE_MODES_OPTIONS = {
-    "OFF": ClimateMode.CLIMATE_MODE_OFF,  # always available
-    "AUTO": ClimateMode.CLIMATE_MODE_AUTO,  # always available
-    "COOL": ClimateMode.CLIMATE_MODE_COOL,
-    "HEAT": ClimateMode.CLIMATE_MODE_HEAT,
-    "DRY": ClimateMode.CLIMATE_MODE_DRY,
-    "FAN_ONLY": ClimateMode.CLIMATE_MODE_FAN_ONLY,
-}
-
-
-def validate_visual(config):
-    if CONF_VISUAL in config:
-        visual_config = config[CONF_VISUAL]
-        if CONF_MIN_TEMPERATURE in visual_config:
-            min_temp = visual_config[CONF_MIN_TEMPERATURE]
-            if min_temp < PROTOCOL_MIN_TEMPERATURE:
-                raise cv.Invalid(
-                    f"Configured visual minimum temperature {min_temp} is lower than supported by Haier protocol is {PROTOCOL_MIN_TEMPERATURE}"
-                )
-        else:
-            config[CONF_VISUAL][CONF_MIN_TEMPERATURE] = PROTOCOL_MIN_TEMPERATURE
-        if CONF_MAX_TEMPERATURE in visual_config:
-            max_temp = visual_config[CONF_MAX_TEMPERATURE]
-            if max_temp > PROTOCOL_MAX_TEMPERATURE:
-                raise cv.Invalid(
-                    f"Configured visual maximum temperature {max_temp} is higher than supported by Haier protocol is {PROTOCOL_MAX_TEMPERATURE}"
-                )
-        else:
-            config[CONF_VISUAL][CONF_MAX_TEMPERATURE] = PROTOCOL_MAX_TEMPERATURE
-    else:
-        config[CONF_VISUAL] = {
-            CONF_MIN_TEMPERATURE: PROTOCOL_MIN_TEMPERATURE,
-            CONF_MAX_TEMPERATURE: PROTOCOL_MAX_TEMPERATURE,
-        }
-    return config
-
-
-BASE_CONFIG_SCHEMA = (
-    climate.CLIMATE_SCHEMA.extend(
-        {
-            cv.Optional(CONF_SUPPORTED_MODES): cv.ensure_list(
-                cv.enum(SUPPORTED_CLIMATE_MODES_OPTIONS, upper=True)
-            ),
-            cv.Optional(
-                CONF_SUPPORTED_SWING_MODES,
-                default=[
-                    "OFF",
-                    "VERTICAL",
-                    "HORIZONTAL",
-                    "BOTH",
-                ],
-            ): cv.ensure_list(cv.enum(SUPPORTED_SWING_MODES_OPTIONS, upper=True)),
-        }
-    )
-    .extend(uart.UART_DEVICE_SCHEMA)
-    .extend(cv.COMPONENT_SCHEMA)
-)
+validate_swing_modes = cv.enum(ALLOWED_CLIMATE_SWING_MODES, upper=True)
 
 CONFIG_SCHEMA = cv.All(
-    cv.typed_schema(
+    climate.CLIMATE_SCHEMA.extend(
         {
-            PROTOCOL_SMARTAIR2: BASE_CONFIG_SCHEMA.extend(
-                {
-                    cv.GenerateID(): cv.declare_id(Smartair2Climate),
-                }
-            ),
-            PROTOCOL_HON: BASE_CONFIG_SCHEMA.extend(
-                {
-                    cv.GenerateID(): cv.declare_id(HonClimate),
-                    cv.Optional(CONF_WIFI_SIGNAL, default=True): cv.boolean,
-                    cv.Optional(CONF_BEEPER, default=True): cv.boolean,
-                    cv.Optional(CONF_OUTDOOR_TEMPERATURE): sensor.sensor_schema(
-                        unit_of_measurement=UNIT_CELSIUS,
-                        icon=ICON_THERMOMETER,
-                        accuracy_decimals=0,
-                        device_class=DEVICE_CLASS_TEMPERATURE,
-                        state_class=STATE_CLASS_MEASUREMENT,
-                    ),
-                }
-            ),
-        },
-        key=CONF_PROTOCOL,
-        default_type=PROTOCOL_SMARTAIR2,
-        upper=True,
-    ),
-    validate_visual,
-)
-
-
-# Actions
-DisplayOnAction = haier_ns.class_("DisplayOnAction", automation.Action)
-DisplayOffAction = haier_ns.class_("DisplayOffAction", automation.Action)
-BeeperOnAction = haier_ns.class_("BeeperOnAction", automation.Action)
-BeeperOffAction = haier_ns.class_("BeeperOffAction", automation.Action)
-StartSelfCleaningAction = haier_ns.class_("StartSelfCleaningAction", automation.Action)
-StartSteriCleaningAction = haier_ns.class_(
-    "StartSteriCleaningAction", automation.Action
-)
-VerticalAirflowAction = haier_ns.class_("VerticalAirflowAction", automation.Action)
-HorizontalAirflowAction = haier_ns.class_("HorizontalAirflowAction", automation.Action)
-HealthOnAction = haier_ns.class_("HealthOnAction", automation.Action)
-HealthOffAction = haier_ns.class_("HealthOffAction", automation.Action)
-PowerOnAction = haier_ns.class_("PowerOnAction", automation.Action)
-PowerOffAction = haier_ns.class_("PowerOffAction", automation.Action)
-PowerToggleAction = haier_ns.class_("PowerToggleAction", automation.Action)
-
-HAIER_BASE_ACTION_SCHEMA = automation.maybe_simple_id(
-    {
-        cv.GenerateID(): cv.use_id(HaierClimateBase),
-    }
-)
-
-HAIER_HON_BASE_ACTION_SCHEMA = automation.maybe_simple_id(
-    {
-        cv.GenerateID(): cv.use_id(HonClimate),
-    }
-)
-
-
-@automation.register_action(
-    "climate.haier.display_on", DisplayOnAction, HAIER_BASE_ACTION_SCHEMA
-)
-@automation.register_action(
-    "climate.haier.display_off", DisplayOffAction, HAIER_BASE_ACTION_SCHEMA
-)
-async def display_action_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    return var
-
-
-@automation.register_action(
-    "climate.haier.beeper_on", BeeperOnAction, HAIER_HON_BASE_ACTION_SCHEMA
-)
-@automation.register_action(
-    "climate.haier.beeper_off", BeeperOffAction, HAIER_HON_BASE_ACTION_SCHEMA
-)
-async def beeper_action_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    return var
-
-
-# Start self cleaning or steri-cleaning action action
-@automation.register_action(
-    "climate.haier.start_self_cleaning",
-    StartSelfCleaningAction,
-    HAIER_HON_BASE_ACTION_SCHEMA,
-)
-@automation.register_action(
-    "climate.haier.start_steri_cleaning",
-    StartSteriCleaningAction,
-    HAIER_HON_BASE_ACTION_SCHEMA,
-)
-async def start_cleaning_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    return var
-
-
-# Set vertical airflow direction action
-@automation.register_action(
-    "climate.haier.set_vertical_airflow",
-    VerticalAirflowAction,
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.use_id(HonClimate),
-            cv.Required(CONF_VERTICAL_AIRFLOW): cv.templatable(
-                cv.enum(AIRFLOW_VERTICAL_DIRECTION_OPTIONS, upper=True)
+            cv.GenerateID(): cv.declare_id(HaierClimate),
+            cv.Optional(CONF_SUPPORTED_SWING_MODES): cv.ensure_list(
+                validate_swing_modes
             ),
         }
-    ),
-)
-async def haier_set_vertical_airflow_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(
-        config[CONF_VERTICAL_AIRFLOW], args, AirflowVerticalDirection
     )
-    cg.add(var.set_direction(template_))
-    return var
-
-
-# Set horizontal airflow direction action
-@automation.register_action(
-    "climate.haier.set_horizontal_airflow",
-    HorizontalAirflowAction,
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.use_id(HonClimate),
-            cv.Required(CONF_HORIZONTAL_AIRFLOW): cv.templatable(
-                cv.enum(AIRFLOW_HORIZONTAL_DIRECTION_OPTIONS, upper=True)
-            ),
-        }
-    ),
+    .extend(cv.polling_component_schema("5s"))
+    .extend(uart.UART_DEVICE_SCHEMA),
 )
-async def haier_set_horizontal_airflow_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(
-        config[CONF_HORIZONTAL_AIRFLOW], args, AirflowHorizontalDirection
-    )
-    cg.add(var.set_direction(template_))
-    return var
-
-
-@automation.register_action(
-    "climate.haier.health_on", HealthOnAction, HAIER_BASE_ACTION_SCHEMA
-)
-@automation.register_action(
-    "climate.haier.health_off", HealthOffAction, HAIER_BASE_ACTION_SCHEMA
-)
-async def health_action_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    return var
-
-
-@automation.register_action(
-    "climate.haier.power_on", PowerOnAction, HAIER_BASE_ACTION_SCHEMA
-)
-@automation.register_action(
-    "climate.haier.power_off", PowerOffAction, HAIER_BASE_ACTION_SCHEMA
-)
-@automation.register_action(
-    "climate.haier.power_toggle", PowerToggleAction, HAIER_BASE_ACTION_SCHEMA
-)
-async def power_action_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    return var
-
-
-def _final_validate(config):
-    full_config = fv.full_config.get()
-    if CONF_LOGGER in full_config:
-        _level = "NONE"
-        logger_config = full_config[CONF_LOGGER]
-        if CONF_LOGS in logger_config:
-            if "haier.protocol" in logger_config[CONF_LOGS]:
-                _level = logger_config[CONF_LOGS]["haier.protocol"]
-            else:
-                _level = logger_config[CONF_LEVEL]
-        _LOGGER.info("Detected log level for Haier protocol: %s", _level)
-        if _level not in logger.LOG_LEVEL_SEVERITY:
-            raise cv.Invalid("Unknown log level for Haier protocol")
-        _severity = logger.LOG_LEVEL_SEVERITY.index(_level)
-        cg.add_build_flag(f"-DHAIER_LOG_LEVEL={_severity}")
-    else:
-        _LOGGER.info(
-            "No logger component found, logging for Haier protocol is disabled"
-        )
-        cg.add_build_flag("-DHAIER_LOG_LEVEL=0")
-    if (
-        (CONF_WIFI_SIGNAL in config)
-        and (config[CONF_WIFI_SIGNAL])
-        and CONF_WIFI not in full_config
-    ):
-        raise cv.Invalid(
-            f"No WiFi configured, if you want to use haier climate without WiFi add {CONF_WIFI_SIGNAL}: false to climate configuration"
-        )
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
 
 
 async def to_code(config):
-    cg.add(haier_ns.init_haier_protocol_logging())
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
-    await uart.register_uart_device(var, config)
     await climate.register_climate(var, config)
-
-    if (CONF_WIFI_SIGNAL in config) and (config[CONF_WIFI_SIGNAL]):
-        cg.add(var.set_send_wifi(config[CONF_WIFI_SIGNAL]))
-    if CONF_BEEPER in config:
-        cg.add(var.set_beeper_state(config[CONF_BEEPER]))
-    if CONF_OUTDOOR_TEMPERATURE in config:
-        sens = await sensor.new_sensor(config[CONF_OUTDOOR_TEMPERATURE])
-        cg.add(var.set_outdoor_temperature_sensor(sens))
-    if CONF_SUPPORTED_MODES in config:
-        cg.add(var.set_supported_modes(config[CONF_SUPPORTED_MODES]))
+    await uart.register_uart_device(var, config)
     if CONF_SUPPORTED_SWING_MODES in config:
         cg.add(var.set_supported_swing_modes(config[CONF_SUPPORTED_SWING_MODES]))
-    # https://github.com/paveldn/HaierProtocol
-    cg.add_library("pavlodn/HaierProtocol", "0.9.18")

esphome/components/haier/haier.cpp

@@ -0,0 +1,302 @@
+#include <cmath>
+#include "haier.h"
+#include "esphome/core/macros.h"
+
+namespace esphome {
+namespace haier {
+
+static const char *const TAG = "haier";
+
+static const uint8_t TEMPERATURE = 13;
+static const uint8_t HUMIDITY = 15;
+
+static const uint8_t MODE = 23;
+
+static const uint8_t FAN_SPEED = 25;
+
+static const uint8_t SWING = 27;
+
+static const uint8_t POWER = 29;
+static const uint8_t POWER_MASK = 1;
+
+static const uint8_t SET_TEMPERATURE = 35;
+static const uint8_t DECIMAL_MASK = (1 << 5);
+
+static const uint8_t CRC = 36;
+
+static const uint8_t COMFORT_PRESET_MASK = (1 << 3);
+
+static const uint8_t MIN_VALID_TEMPERATURE = 16;
+static const uint8_t MAX_VALID_TEMPERATURE = 50;
+static const float TEMPERATURE_STEP = 0.5f;
+
+static const uint8_t POLL_REQ[13] = {255, 255, 10, 0, 0, 0, 0, 0, 1, 1, 77, 1, 90};
+static const uint8_t OFF_REQ[13] = {255, 255, 10, 0, 0, 0, 0, 0, 1, 1, 77, 3, 92};
+
+void HaierClimate::dump_config() {
+  ESP_LOGCONFIG(TAG, "Haier:");
+  ESP_LOGCONFIG(TAG, "  Update interval: %u", this->get_update_interval());
+  this->dump_traits_(TAG);
+  this->check_uart_settings(9600);
+}
+
+void HaierClimate::loop() {
+  if (this->available() >= sizeof(this->data_)) {
+    this->read_array(this->data_, sizeof(this->data_));
+    if (this->data_[0] != 255 || this->data_[1] != 255)
+      return;
+
+    read_state_(this->data_, sizeof(this->data_));
+  }
+}
+
+void HaierClimate::update() {
+  this->write_array(POLL_REQ, sizeof(POLL_REQ));
+  dump_message_("Poll sent", POLL_REQ, sizeof(POLL_REQ));
+}
+
+climate::ClimateTraits HaierClimate::traits() {
+  auto traits = climate::ClimateTraits();
+
+  traits.set_visual_min_temperature(MIN_VALID_TEMPERATURE);
+  traits.set_visual_max_temperature(MAX_VALID_TEMPERATURE);
+  traits.set_visual_temperature_step(TEMPERATURE_STEP);
+
+  traits.set_supported_modes({climate::CLIMATE_MODE_OFF, climate::CLIMATE_MODE_HEAT_COOL, climate::CLIMATE_MODE_COOL,
+                              climate::CLIMATE_MODE_HEAT, climate::CLIMATE_MODE_FAN_ONLY, climate::CLIMATE_MODE_DRY});
+
+  traits.set_supported_fan_modes({
+      climate::CLIMATE_FAN_AUTO,
+      climate::CLIMATE_FAN_LOW,
+      climate::CLIMATE_FAN_MEDIUM,
+      climate::CLIMATE_FAN_HIGH,
+  });
+
+  traits.set_supported_swing_modes(this->supported_swing_modes_);
+  traits.set_supports_current_temperature(true);
+  traits.set_supports_two_point_target_temperature(false);
+
+  traits.add_supported_preset(climate::CLIMATE_PRESET_NONE);
+  traits.add_supported_preset(climate::CLIMATE_PRESET_COMFORT);
+
+  return traits;
+}
+
+void HaierClimate::read_state_(const uint8_t *data, uint8_t size) {
+  dump_message_("Received state", data, size);
+
+  uint8_t check = data[CRC];
+
+  uint8_t crc = get_checksum_(data, size);
+
+  if (check != crc) {
+    ESP_LOGW(TAG, "Invalid checksum");
+    return;
+  }
+
+  this->current_temperature = data[TEMPERATURE];
+
+  this->target_temperature = data[SET_TEMPERATURE] + MIN_VALID_TEMPERATURE;
+
+  if (data[POWER] & DECIMAL_MASK) {
+    this->target_temperature += 0.5f;
+  }
+
+  switch (data[MODE]) {
+    case MODE_SMART:
+      this->mode = climate::CLIMATE_MODE_HEAT_COOL;
+      break;
+    case MODE_COOL:
+      this->mode = climate::CLIMATE_MODE_COOL;
+      break;
+    case MODE_HEAT:
+      this->mode = climate::CLIMATE_MODE_HEAT;
+      break;
+    case MODE_ONLY_FAN:
+      this->mode = climate::CLIMATE_MODE_FAN_ONLY;
+      break;
+    case MODE_DRY:
+      this->mode = climate::CLIMATE_MODE_DRY;
+      break;
+    default:  // other modes are unsupported
+      this->mode = climate::CLIMATE_MODE_HEAT_COOL;
+  }
+
+  switch (data[FAN_SPEED]) {
+    case FAN_AUTO:
+      this->fan_mode = climate::CLIMATE_FAN_AUTO;
+      break;
+
+    case FAN_MIN:
+      this->fan_mode = climate::CLIMATE_FAN_LOW;
+      break;
+
+    case FAN_MIDDLE:
+      this->fan_mode = climate::CLIMATE_FAN_MEDIUM;
+      break;
+
+    case FAN_MAX:
+      this->fan_mode = climate::CLIMATE_FAN_HIGH;
+      break;
+  }
+
+  switch (data[SWING]) {
+    case SWING_OFF:
+      this->swing_mode = climate::CLIMATE_SWING_OFF;
+      break;
+
+    case SWING_VERTICAL:
+      this->swing_mode = climate::CLIMATE_SWING_VERTICAL;
+      break;
+
+    case SWING_HORIZONTAL:
+      this->swing_mode = climate::CLIMATE_SWING_HORIZONTAL;
+      break;
+
+    case SWING_BOTH:
+      this->swing_mode = climate::CLIMATE_SWING_BOTH;
+      break;
+  }
+
+  if (data[POWER] & COMFORT_PRESET_MASK) {
+    this->preset = climate::CLIMATE_PRESET_COMFORT;
+  } else {
+    this->preset = climate::CLIMATE_PRESET_NONE;
+  }
+
+  if ((data[POWER] & POWER_MASK) == 0) {
+    this->mode = climate::CLIMATE_MODE_OFF;
+  }
+
+  this->publish_state();
+}
+
+void HaierClimate::control(const climate::ClimateCall &call) {
+  if (call.get_mode().has_value()) {
+    switch (call.get_mode().value()) {
+      case climate::CLIMATE_MODE_OFF:
+        send_data_(OFF_REQ, sizeof(OFF_REQ));
+        break;
+
+      case climate::CLIMATE_MODE_HEAT_COOL:
+      case climate::CLIMATE_MODE_AUTO:
+        data_[POWER] |= POWER_MASK;
+        data_[MODE] = MODE_SMART;
+        break;
+      case climate::CLIMATE_MODE_HEAT:
+        data_[POWER] |= POWER_MASK;
+        data_[MODE] = MODE_HEAT;
+        break;
+      case climate::CLIMATE_MODE_COOL:
+        data_[POWER] |= POWER_MASK;
+        data_[MODE] = MODE_COOL;
+        break;
+
+      case climate::CLIMATE_MODE_FAN_ONLY:
+        data_[POWER] |= POWER_MASK;
+        data_[MODE] = MODE_ONLY_FAN;
+        break;
+
+      case climate::CLIMATE_MODE_DRY:
+        data_[POWER] |= POWER_MASK;
+        data_[MODE] = MODE_DRY;
+        break;
+    }
+  }
+
+  if (call.get_preset().has_value()) {
+    if (call.get_preset().value() == climate::CLIMATE_PRESET_COMFORT) {
+      data_[POWER] |= COMFORT_PRESET_MASK;
+    } else {
+      data_[POWER] &= ~COMFORT_PRESET_MASK;
+    }
+  }
+
+  if (call.get_target_temperature().has_value()) {
+    float target = call.get_target_temperature().value() - MIN_VALID_TEMPERATURE;
+
+    data_[SET_TEMPERATURE] = (uint8_t) target;
+
+    if ((int) target == std::lroundf(target)) {
+      data_[POWER] &= ~DECIMAL_MASK;
+    } else {
+      data_[POWER] |= DECIMAL_MASK;
+    }
+  }
+
+  if (call.get_fan_mode().has_value()) {
+    switch (call.get_fan_mode().value()) {
+      case climate::CLIMATE_FAN_AUTO:
+        data_[FAN_SPEED] = FAN_AUTO;
+        break;
+      case climate::CLIMATE_FAN_LOW:
+        data_[FAN_SPEED] = FAN_MIN;
+        break;
+      case climate::CLIMATE_FAN_MEDIUM:
+        data_[FAN_SPEED] = FAN_MIDDLE;
+        break;
+      case climate::CLIMATE_FAN_HIGH:
+        data_[FAN_SPEED] = FAN_MAX;
+        break;
+
+      default:  // other modes are unsupported
+        break;
+    }
+  }
+
+  if (call.get_swing_mode().has_value()) {
+    switch (call.get_swing_mode().value()) {
+      case climate::CLIMATE_SWING_OFF:
+        data_[SWING] = SWING_OFF;
+        break;
+      case climate::CLIMATE_SWING_VERTICAL:
+        data_[SWING] = SWING_VERTICAL;
+        break;
+      case climate::CLIMATE_SWING_HORIZONTAL:
+        data_[SWING] = SWING_HORIZONTAL;
+        break;
+      case climate::CLIMATE_SWING_BOTH:
+        data_[SWING] = SWING_BOTH;
+        break;
+    }
+  }
+
+  // Parts of the message that must have specific values for "send" command.
+  // The meaning of those values is unknown at the moment.
+  data_[9] = 1;
+  data_[10] = 77;
+  data_[11] = 95;
+  data_[17] = 0;
+
+  // Compute checksum
+  uint8_t crc = get_checksum_(data_, sizeof(data_));
+  data_[CRC] = crc;
+
+  send_data_(data_, sizeof(data_));
+}
+
+void HaierClimate::send_data_(const uint8_t *message, uint8_t size) {
+  this->write_array(message, size);
+
+  dump_message_("Sent message", message, size);
+}
+
+void HaierClimate::dump_message_(const char *title, const uint8_t *message, uint8_t size) {
+  ESP_LOGV(TAG, "%s:", title);
+  for (int i = 0; i < size; i++) {
+    ESP_LOGV(TAG, "  byte %02d - %d", i, message[i]);
+  }
+}
+
+uint8_t HaierClimate::get_checksum_(const uint8_t *message, size_t size) {
+  uint8_t position = size - 1;
+  uint8_t crc = 0;
+
+  for (int i = 2; i < position; i++)
+    crc += message[i];
+
+  return crc;
+}
+
+}  // namespace haier
+}  // namespace esphome

esphome/components/haier/haier.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/climate/climate.h"
+#include "esphome/components/uart/uart.h"
+
+namespace esphome {
+namespace haier {
+
+enum Mode : uint8_t { MODE_SMART = 0, MODE_COOL = 1, MODE_HEAT = 2, MODE_ONLY_FAN = 3, MODE_DRY = 4 };
+enum FanSpeed : uint8_t { FAN_MAX = 0, FAN_MIDDLE = 1, FAN_MIN = 2, FAN_AUTO = 3 };
+enum SwingMode : uint8_t { SWING_OFF = 0, SWING_VERTICAL = 1, SWING_HORIZONTAL = 2, SWING_BOTH = 3 };
+
+class HaierClimate : public climate::Climate, public uart::UARTDevice, public PollingComponent {
+ public:
+  void loop() override;
+  void update() override;
+  void dump_config() override;
+  void control(const climate::ClimateCall &call) override;
+  void set_supported_swing_modes(const std::set<climate::ClimateSwingMode> &modes) {
+    this->supported_swing_modes_ = modes;
+  }
+
+ protected:
+  climate::ClimateTraits traits() override;
+  void read_state_(const uint8_t *data, uint8_t size);
+  void send_data_(const uint8_t *message, uint8_t size);
+  void dump_message_(const char *title, const uint8_t *message, uint8_t size);
+  uint8_t get_checksum_(const uint8_t *message, size_t size);
+
+ private:
+  uint8_t data_[37];
+  std::set<climate::ClimateSwingMode> supported_swing_modes_{};
+};
+
+}  // namespace haier
+}  // namespace esphome

esphome/components/haier/haier_base.cpp

@@ -1,311 +0,0 @@
-#include <chrono>
-#include <string>
-#include "esphome/components/climate/climate.h"
-#include "esphome/components/uart/uart.h"
-#include "haier_base.h"
-
-using namespace esphome::climate;
-using namespace esphome::uart;
-
-namespace esphome {
-namespace haier {
-
-static const char *const TAG = "haier.climate";
-constexpr size_t COMMUNICATION_TIMEOUT_MS = 60000;
-constexpr size_t STATUS_REQUEST_INTERVAL_MS = 5000;
-constexpr size_t PROTOCOL_INITIALIZATION_INTERVAL = 10000;
-constexpr size_t DEFAULT_MESSAGES_INTERVAL_MS = 2000;
-constexpr size_t CONTROL_MESSAGES_INTERVAL_MS = 400;
-constexpr size_t CONTROL_TIMEOUT_MS = 7000;
-constexpr size_t NO_COMMAND = 0xFF;  // Indicate that there is no command supplied
-
-#if (HAIER_LOG_LEVEL > 4)
-// To reduce size of binary this function only available when log level is Verbose
-const char *HaierClimateBase::phase_to_string_(ProtocolPhases phase) {
-  static const char *phase_names[] = {
-      "SENDING_INIT_1",
-      "WAITING_ANSWER_INIT_1",
-      "SENDING_INIT_2",
-      "WAITING_ANSWER_INIT_2",
-      "SENDING_FIRST_STATUS_REQUEST",
-      "WAITING_FIRST_STATUS_ANSWER",
-      "SENDING_ALARM_STATUS_REQUEST",
-      "WAITING_ALARM_STATUS_ANSWER",
-      "IDLE",
-      "SENDING_STATUS_REQUEST",
-      "WAITING_STATUS_ANSWER",
-      "SENDING_UPDATE_SIGNAL_REQUEST",
-      "WAITING_UPDATE_SIGNAL_ANSWER",
-      "SENDING_SIGNAL_LEVEL",
-      "WAITING_SIGNAL_LEVEL_ANSWER",
-      "SENDING_CONTROL",
-      "WAITING_CONTROL_ANSWER",
-      "SENDING_POWER_ON_COMMAND",
-      "WAITING_POWER_ON_ANSWER",
-      "SENDING_POWER_OFF_COMMAND",
-      "WAITING_POWER_OFF_ANSWER",
-      "UNKNOWN"  // Should be the last!
-  };
-  int phase_index = (int) phase;
-  if ((phase_index > (int) ProtocolPhases::NUM_PROTOCOL_PHASES) || (phase_index < 0))
-    phase_index = (int) ProtocolPhases::NUM_PROTOCOL_PHASES;
-  return phase_names[phase_index];
-}
-#endif
-
-HaierClimateBase::HaierClimateBase()
-    : haier_protocol_(*this),
-      protocol_phase_(ProtocolPhases::SENDING_INIT_1),
-      action_request_(ActionRequest::NO_ACTION),
-      display_status_(true),
-      health_mode_(false),
-      force_send_control_(false),
-      forced_publish_(false),
-      forced_request_status_(false),
-      first_control_attempt_(false),
-      reset_protocol_request_(false) {
-  this->traits_ = climate::ClimateTraits();
-  this->traits_.set_supported_modes({climate::CLIMATE_MODE_OFF, climate::CLIMATE_MODE_COOL, climate::CLIMATE_MODE_HEAT,
-                                     climate::CLIMATE_MODE_FAN_ONLY, climate::CLIMATE_MODE_DRY,
-                                     climate::CLIMATE_MODE_AUTO});
-  this->traits_.set_supported_fan_modes(
-      {climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH});
-  this->traits_.set_supported_swing_modes({climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_BOTH,
-                                           climate::CLIMATE_SWING_VERTICAL, climate::CLIMATE_SWING_HORIZONTAL});
-  this->traits_.set_supports_current_temperature(true);
-}
-
-HaierClimateBase::~HaierClimateBase() {}
-
-void HaierClimateBase::set_phase_(ProtocolPhases phase) {
-  if (this->protocol_phase_ != phase) {
-#if (HAIER_LOG_LEVEL > 4)
-    ESP_LOGV(TAG, "Phase transition: %s => %s", phase_to_string_(this->protocol_phase_), phase_to_string_(phase));
-#else
-    ESP_LOGV(TAG, "Phase transition: %d => %d", (int) this->protocol_phase_, (int) phase);
-#endif
-    this->protocol_phase_ = phase;
-  }
-}
-
-bool HaierClimateBase::check_timeout_(std::chrono::steady_clock::time_point now,
-                                      std::chrono::steady_clock::time_point tpoint, size_t timeout) {
-  return std::chrono::duration_cast<std::chrono::milliseconds>(now - tpoint).count() > timeout;
-}
-
-bool HaierClimateBase::is_message_interval_exceeded_(std::chrono::steady_clock::time_point now) {
-  return this->check_timeout_(now, this->last_request_timestamp_, DEFAULT_MESSAGES_INTERVAL_MS);
-}
-
-bool HaierClimateBase::is_status_request_interval_exceeded_(std::chrono::steady_clock::time_point now) {
-  return this->check_timeout_(now, this->last_status_request_, STATUS_REQUEST_INTERVAL_MS);
-}
-
-bool HaierClimateBase::is_control_message_timeout_exceeded_(std::chrono::steady_clock::time_point now) {
-  return this->check_timeout_(now, this->control_request_timestamp_, CONTROL_TIMEOUT_MS);
-}
-
-bool HaierClimateBase::is_control_message_interval_exceeded_(std::chrono::steady_clock::time_point now) {
-  return this->check_timeout_(now, this->last_request_timestamp_, CONTROL_MESSAGES_INTERVAL_MS);
-}
-
-bool HaierClimateBase::is_protocol_initialisation_interval_exceded_(std::chrono::steady_clock::time_point now) {
-  return this->check_timeout_(now, this->last_request_timestamp_, PROTOCOL_INITIALIZATION_INTERVAL);
-}
-
-bool HaierClimateBase::get_display_state() const { return this->display_status_; }
-
-void HaierClimateBase::set_display_state(bool state) {
-  if (this->display_status_ != state) {
-    this->display_status_ = state;
-    this->set_force_send_control_(true);
-  }
-}
-
-bool HaierClimateBase::get_health_mode() const { return this->health_mode_; }
-
-void HaierClimateBase::set_health_mode(bool state) {
-  if (this->health_mode_ != state) {
-    this->health_mode_ = state;
-    this->set_force_send_control_(true);
-  }
-}
-
-void HaierClimateBase::send_power_on_command() { this->action_request_ = ActionRequest::TURN_POWER_ON; }
-
-void HaierClimateBase::send_power_off_command() { this->action_request_ = ActionRequest::TURN_POWER_OFF; }
-
-void HaierClimateBase::toggle_power() { this->action_request_ = ActionRequest::TOGGLE_POWER; }
-void HaierClimateBase::set_supported_swing_modes(const std::set<climate::ClimateSwingMode> &modes) {
-  this->traits_.set_supported_swing_modes(modes);
-  this->traits_.add_supported_swing_mode(climate::CLIMATE_SWING_OFF);       // Always available
-  this->traits_.add_supported_swing_mode(climate::CLIMATE_SWING_VERTICAL);  // Always available
-}
-
-void HaierClimateBase::set_supported_modes(const std::set<climate::ClimateMode> &modes) {
-  this->traits_.set_supported_modes(modes);
-  this->traits_.add_supported_mode(climate::CLIMATE_MODE_OFF);   // Always available
-  this->traits_.add_supported_mode(climate::CLIMATE_MODE_AUTO);  // Always available
-}
-
-haier_protocol::HandlerError HaierClimateBase::answer_preprocess_(uint8_t request_message_type,
-                                                                  uint8_t expected_request_message_type,
-                                                                  uint8_t answer_message_type,
-                                                                  uint8_t expected_answer_message_type,
-                                                                  ProtocolPhases expected_phase) {
-  haier_protocol::HandlerError result = haier_protocol::HandlerError::HANDLER_OK;
-  if ((expected_request_message_type != NO_COMMAND) && (request_message_type != expected_request_message_type))
-    result = haier_protocol::HandlerError::UNSUPORTED_MESSAGE;
-  if ((expected_answer_message_type != NO_COMMAND) && (answer_message_type != expected_answer_message_type))
-    result = haier_protocol::HandlerError::UNSUPORTED_MESSAGE;
-  if ((expected_phase != ProtocolPhases::UNKNOWN) && (expected_phase != this->protocol_phase_))
-    result = haier_protocol::HandlerError::UNEXPECTED_MESSAGE;
-  if (is_message_invalid(answer_message_type))
-    result = haier_protocol::HandlerError::INVALID_ANSWER;
-  return result;
-}
-
-haier_protocol::HandlerError HaierClimateBase::timeout_default_handler_(uint8_t request_type) {
-#if (HAIER_LOG_LEVEL > 4)
-  ESP_LOGW(TAG, "Answer timeout for command %02X, phase %s", request_type, phase_to_string_(this->protocol_phase_));
-#else
-  ESP_LOGW(TAG, "Answer timeout for command %02X, phase %d", request_type, (int) this->protocol_phase_);
-#endif
-  if (this->protocol_phase_ > ProtocolPhases::IDLE) {
-    this->set_phase_(ProtocolPhases::IDLE);
-  } else {
-    this->set_phase_(ProtocolPhases::SENDING_INIT_1);
-  }
-  return haier_protocol::HandlerError::HANDLER_OK;
-}
-
-void HaierClimateBase::setup() {
-  ESP_LOGI(TAG, "Haier initialization...");
-  // Set timestamp here to give AC time to boot
-  this->last_request_timestamp_ = std::chrono::steady_clock::now();
-  this->set_phase_(ProtocolPhases::SENDING_INIT_1);
-  this->set_answers_handlers();
-  this->haier_protocol_.set_default_timeout_handler(
-      std::bind(&esphome::haier::HaierClimateBase::timeout_default_handler_, this, std::placeholders::_1));
-}
-
-void HaierClimateBase::dump_config() {
-  LOG_CLIMATE("", "Haier Climate", this);
-  ESP_LOGCONFIG(TAG, "  Device communication status: %s",
-                (this->protocol_phase_ >= ProtocolPhases::IDLE) ? "established" : "none");
-}
-
-void HaierClimateBase::loop() {
-  std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
-  if ((std::chrono::duration_cast<std::chrono::milliseconds>(now - this->last_valid_status_timestamp_).count() >
-       COMMUNICATION_TIMEOUT_MS) ||
-      (this->reset_protocol_request_)) {
-    if (this->protocol_phase_ >= ProtocolPhases::IDLE) {
-      // No status too long, reseting protocol
-      if (this->reset_protocol_request_) {
-        this->reset_protocol_request_ = false;
-        ESP_LOGW(TAG, "Protocol reset requested");
-      } else {
-        ESP_LOGW(TAG, "Communication timeout, reseting protocol");
-      }
-      this->last_valid_status_timestamp_ = now;
-      this->set_force_send_control_(false);
-      if (this->hvac_settings_.valid)
-        this->hvac_settings_.reset();
-      this->set_phase_(ProtocolPhases::SENDING_INIT_1);
-      return;
-    } else {
-      // No need to reset protocol if we didn't pass initialization phase
-      this->last_valid_status_timestamp_ = now;
-    }
-  };
-  if ((this->protocol_phase_ == ProtocolPhases::IDLE) ||
-      (this->protocol_phase_ == ProtocolPhases::SENDING_STATUS_REQUEST) ||
-      (this->protocol_phase_ == ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST) ||
-      (this->protocol_phase_ == ProtocolPhases::SENDING_SIGNAL_LEVEL)) {
-    // If control message or action is pending we should send it ASAP unless we are in initialisation
-    // procedure or waiting for an answer
-    if (this->action_request_ != ActionRequest::NO_ACTION) {
-      this->process_pending_action();
-    } else if (this->hvac_settings_.valid || this->force_send_control_) {
-      ESP_LOGV(TAG, "Control packet is pending...");
-      this->set_phase_(ProtocolPhases::SENDING_CONTROL);
-    }
-  }
-  this->process_phase(now);
-  this->haier_protocol_.loop();
-}
-
-void HaierClimateBase::process_pending_action() {
-  ActionRequest request = this->action_request_;
-  if (this->action_request_ == ActionRequest::TOGGLE_POWER) {
-    request = this->mode == CLIMATE_MODE_OFF ? ActionRequest::TURN_POWER_ON : ActionRequest::TURN_POWER_OFF;
-  }
-  switch (request) {
-    case ActionRequest::TURN_POWER_ON:
-      this->set_phase_(ProtocolPhases::SENDING_POWER_ON_COMMAND);
-      break;
-    case ActionRequest::TURN_POWER_OFF:
-      this->set_phase_(ProtocolPhases::SENDING_POWER_OFF_COMMAND);
-      break;
-    case ActionRequest::TOGGLE_POWER:
-    case ActionRequest::NO_ACTION:
-      // shouldn't get here, do nothing
-      break;
-    default:
-      ESP_LOGW(TAG, "Unsupported action: %d", (uint8_t) this->action_request_);
-      break;
-  }
-  this->action_request_ = ActionRequest::NO_ACTION;
-}
-
-ClimateTraits HaierClimateBase::traits() { return traits_; }
-
-void HaierClimateBase::control(const ClimateCall &call) {
-  ESP_LOGD("Control", "Control call");
-  if (this->protocol_phase_ < ProtocolPhases::IDLE) {
-    ESP_LOGW(TAG, "Can't send control packet, first poll answer not received");
-    return;  // cancel the control, we cant do it without a poll answer.
-  }
-  if (this->hvac_settings_.valid) {
-    ESP_LOGW(TAG, "Overriding old valid settings before they were applied!");
-  }
-  {
-    if (call.get_mode().has_value())
-      this->hvac_settings_.mode = call.get_mode();
-    if (call.get_fan_mode().has_value())
-      this->hvac_settings_.fan_mode = call.get_fan_mode();
-    if (call.get_swing_mode().has_value())
-      this->hvac_settings_.swing_mode = call.get_swing_mode();
-    if (call.get_target_temperature().has_value())
-      this->hvac_settings_.target_temperature = call.get_target_temperature();
-    if (call.get_preset().has_value())
-      this->hvac_settings_.preset = call.get_preset();
-    this->hvac_settings_.valid = true;
-  }
-  this->first_control_attempt_ = true;
-}
-
-void HaierClimateBase::HvacSettings::reset() {
-  this->valid = false;
-  this->mode.reset();
-  this->fan_mode.reset();
-  this->swing_mode.reset();
-  this->target_temperature.reset();
-  this->preset.reset();
-}
-
-void HaierClimateBase::set_force_send_control_(bool status) {
-  this->force_send_control_ = status;
-  if (status) {
-    this->first_control_attempt_ = true;
-  }
-}
-
-void HaierClimateBase::send_message_(const haier_protocol::HaierMessage &command, bool use_crc) {
-  this->haier_protocol_.send_message(command, use_crc);
-  this->last_request_timestamp_ = std::chrono::steady_clock::now();
-}
-
-}  // namespace haier
-}  // namespace esphome

esphome/components/haier/haier_base.h

@@ -1,142 +0,0 @@
-#pragma once
-
-#include <chrono>
-#include <set>
-#include "esphome/components/climate/climate.h"
-#include "esphome/components/uart/uart.h"
-// HaierProtocol
-#include <protocol/haier_protocol.h>
-
-namespace esphome {
-namespace haier {
-
-enum class ActionRequest : uint8_t {
-  NO_ACTION = 0,
-  TURN_POWER_ON = 1,
-  TURN_POWER_OFF = 2,
-  TOGGLE_POWER = 3,
-  START_SELF_CLEAN = 4,   // only hOn
-  START_STERI_CLEAN = 5,  // only hOn
-};
-
-class HaierClimateBase : public esphome::Component,
-                         public esphome::climate::Climate,
-                         public esphome::uart::UARTDevice,
-                         public haier_protocol::ProtocolStream {
- public:
-  HaierClimateBase();
-  HaierClimateBase(const HaierClimateBase &) = delete;
-  HaierClimateBase &operator=(const HaierClimateBase &) = delete;
-  ~HaierClimateBase();
-  void setup() override;
-  void loop() override;
-  void control(const esphome::climate::ClimateCall &call) override;
-  void dump_config() override;
-  float get_setup_priority() const override { return esphome::setup_priority::HARDWARE; }
-  void set_fahrenheit(bool fahrenheit);
-  void set_display_state(bool state);
-  bool get_display_state() const;
-  void set_health_mode(bool state);
-  bool get_health_mode() const;
-  void send_power_on_command();
-  void send_power_off_command();
-  void toggle_power();
-  void reset_protocol() { this->reset_protocol_request_ = true; };
-  void set_supported_modes(const std::set<esphome::climate::ClimateMode> &modes);
-  void set_supported_swing_modes(const std::set<esphome::climate::ClimateSwingMode> &modes);
-  size_t available() noexcept override { return esphome::uart::UARTDevice::available(); };
-  size_t read_array(uint8_t *data, size_t len) noexcept override {
-    return esphome::uart::UARTDevice::read_array(data, len) ? len : 0;
-  };
-  void write_array(const uint8_t *data, size_t len) noexcept override {
-    esphome::uart::UARTDevice::write_array(data, len);
-  };
-  bool can_send_message() const { return haier_protocol_.get_outgoing_queue_size() == 0; };
-
- protected:
-  enum class ProtocolPhases {
-    UNKNOWN = -1,
-    // INITIALIZATION
-    SENDING_INIT_1 = 0,
-    WAITING_ANSWER_INIT_1 = 1,
-    SENDING_INIT_2 = 2,
-    WAITING_ANSWER_INIT_2 = 3,
-    SENDING_FIRST_STATUS_REQUEST = 4,
-    WAITING_FIRST_STATUS_ANSWER = 5,
-    SENDING_ALARM_STATUS_REQUEST = 6,
-    WAITING_ALARM_STATUS_ANSWER = 7,
-    // FUNCTIONAL STATE
-    IDLE = 8,
-    SENDING_STATUS_REQUEST = 9,
-    WAITING_STATUS_ANSWER = 10,
-    SENDING_UPDATE_SIGNAL_REQUEST = 11,
-    WAITING_UPDATE_SIGNAL_ANSWER = 12,
-    SENDING_SIGNAL_LEVEL = 13,
-    WAITING_SIGNAL_LEVEL_ANSWER = 14,
-    SENDING_CONTROL = 15,
-    WAITING_CONTROL_ANSWER = 16,
-    SENDING_POWER_ON_COMMAND = 17,
-    WAITING_POWER_ON_ANSWER = 18,
-    SENDING_POWER_OFF_COMMAND = 19,
-    WAITING_POWER_OFF_ANSWER = 20,
-    NUM_PROTOCOL_PHASES
-  };
-#if (HAIER_LOG_LEVEL > 4)
-  const char *phase_to_string_(ProtocolPhases phase);
-#endif
-  virtual void set_answers_handlers() = 0;
-  virtual void process_phase(std::chrono::steady_clock::time_point now) = 0;
-  virtual haier_protocol::HaierMessage get_control_message() = 0;
-  virtual bool is_message_invalid(uint8_t message_type) = 0;
-  virtual void process_pending_action();
-  esphome::climate::ClimateTraits traits() override;
-  // Answers handlers
-  haier_protocol::HandlerError answer_preprocess_(uint8_t request_message_type, uint8_t expected_request_message_type,
-                                                  uint8_t answer_message_type, uint8_t expected_answer_message_type,
-                                                  ProtocolPhases expected_phase);
-  // Timeout handler
-  haier_protocol::HandlerError timeout_default_handler_(uint8_t request_type);
-  // Helper functions
-  void set_force_send_control_(bool status);
-  void send_message_(const haier_protocol::HaierMessage &command, bool use_crc);
-  void set_phase_(ProtocolPhases phase);
-  bool check_timeout_(std::chrono::steady_clock::time_point now, std::chrono::steady_clock::time_point tpoint,
-                      size_t timeout);
-  bool is_message_interval_exceeded_(std::chrono::steady_clock::time_point now);
-  bool is_status_request_interval_exceeded_(std::chrono::steady_clock::time_point now);
-  bool is_control_message_timeout_exceeded_(std::chrono::steady_clock::time_point now);
-  bool is_control_message_interval_exceeded_(std::chrono::steady_clock::time_point now);
-  bool is_protocol_initialisation_interval_exceded_(std::chrono::steady_clock::time_point now);
-
-  struct HvacSettings {
-    esphome::optional<esphome::climate::ClimateMode> mode;
-    esphome::optional<esphome::climate::ClimateFanMode> fan_mode;
-    esphome::optional<esphome::climate::ClimateSwingMode> swing_mode;
-    esphome::optional<float> target_temperature;
-    esphome::optional<esphome::climate::ClimatePreset> preset;
-    bool valid;
-    HvacSettings() : valid(false){};
-    void reset();
-  };
-  haier_protocol::ProtocolHandler haier_protocol_;
-  ProtocolPhases protocol_phase_;
-  ActionRequest action_request_;
-  uint8_t fan_mode_speed_;
-  uint8_t other_modes_fan_speed_;
-  bool display_status_;
-  bool health_mode_;
-  bool force_send_control_;
-  bool forced_publish_;
-  bool forced_request_status_;
-  bool first_control_attempt_;
-  bool reset_protocol_request_;
-  esphome::climate::ClimateTraits traits_;
-  HvacSettings hvac_settings_;
-  std::chrono::steady_clock::time_point last_request_timestamp_;       // For interval between messages
-  std::chrono::steady_clock::time_point last_valid_status_timestamp_;  // For protocol timeout
-  std::chrono::steady_clock::time_point last_status_request_;          // To request AC status
-  std::chrono::steady_clock::time_point control_request_timestamp_;    // To send control message
-};
-
-}  // namespace haier
-}  // namespace esphome

esphome/components/haier/hon_climate.cpp

@@ -1,857 +0,0 @@
-#include <chrono>
-#include <string>
-#include "esphome/components/climate/climate.h"
-#include "esphome/components/uart/uart.h"
-#ifdef USE_WIFI
-#include "esphome/components/wifi/wifi_component.h"
-#endif
-#include "hon_climate.h"
-#include "hon_packet.h"
-
-using namespace esphome::climate;
-using namespace esphome::uart;
-
-namespace esphome {
-namespace haier {
-
-static const char *const TAG = "haier.climate";
-constexpr size_t SIGNAL_LEVEL_UPDATE_INTERVAL_MS = 10000;
-constexpr int PROTOCOL_OUTDOOR_TEMPERATURE_OFFSET = -64;
-
-hon_protocol::VerticalSwingMode get_vertical_swing_mode(AirflowVerticalDirection direction) {
-  switch (direction) {
-    case AirflowVerticalDirection::HEALTH_UP:
-      return hon_protocol::VerticalSwingMode::HEALTH_UP;
-    case AirflowVerticalDirection::MAX_UP:
-      return hon_protocol::VerticalSwingMode::MAX_UP;
-    case AirflowVerticalDirection::UP:
-      return hon_protocol::VerticalSwingMode::UP;
-    case AirflowVerticalDirection::DOWN:
-      return hon_protocol::VerticalSwingMode::DOWN;
-    case AirflowVerticalDirection::HEALTH_DOWN:
-      return hon_protocol::VerticalSwingMode::HEALTH_DOWN;
-    default:
-      return hon_protocol::VerticalSwingMode::CENTER;
-  }
-}
-
-hon_protocol::HorizontalSwingMode get_horizontal_swing_mode(AirflowHorizontalDirection direction) {
-  switch (direction) {
-    case AirflowHorizontalDirection::MAX_LEFT:
-      return hon_protocol::HorizontalSwingMode::MAX_LEFT;
-    case AirflowHorizontalDirection::LEFT:
-      return hon_protocol::HorizontalSwingMode::LEFT;
-    case AirflowHorizontalDirection::RIGHT:
-      return hon_protocol::HorizontalSwingMode::RIGHT;
-    case AirflowHorizontalDirection::MAX_RIGHT:
-      return hon_protocol::HorizontalSwingMode::MAX_RIGHT;
-    default:
-      return hon_protocol::HorizontalSwingMode::CENTER;
-  }
-}
-
-HonClimate::HonClimate()
-    : last_status_message_(new uint8_t[sizeof(hon_protocol::HaierPacketControl)]),
-      cleaning_status_(CleaningState::NO_CLEANING),
-      got_valid_outdoor_temp_(false),
-      hvac_hardware_info_available_(false),
-      hvac_functions_{false, false, false, false, false},
-      use_crc_(hvac_functions_[2]),
-      active_alarms_{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-      outdoor_sensor_(nullptr),
-      send_wifi_signal_(true) {
-  this->traits_.set_supported_presets({
-      climate::CLIMATE_PRESET_NONE,
-      climate::CLIMATE_PRESET_ECO,
-      climate::CLIMATE_PRESET_BOOST,
-      climate::CLIMATE_PRESET_SLEEP,
-  });
-  this->fan_mode_speed_ = (uint8_t) hon_protocol::FanMode::FAN_MID;
-  this->other_modes_fan_speed_ = (uint8_t) hon_protocol::FanMode::FAN_AUTO;
-}
-
-HonClimate::~HonClimate() {}
-
-void HonClimate::set_beeper_state(bool state) { this->beeper_status_ = state; }
-
-bool HonClimate::get_beeper_state() const { return this->beeper_status_; }
-
-void HonClimate::set_outdoor_temperature_sensor(esphome::sensor::Sensor *sensor) { this->outdoor_sensor_ = sensor; }
-
-AirflowVerticalDirection HonClimate::get_vertical_airflow() const { return this->vertical_direction_; };
-
-void HonClimate::set_vertical_airflow(AirflowVerticalDirection direction) {
-  if (direction > AirflowVerticalDirection::DOWN) {
-    this->vertical_direction_ = AirflowVerticalDirection::CENTER;
-  } else {
-    this->vertical_direction_ = direction;
-  }
-  this->set_force_send_control_(true);
-}
-
-AirflowHorizontalDirection HonClimate::get_horizontal_airflow() const { return this->horizontal_direction_; }
-
-void HonClimate::set_horizontal_airflow(AirflowHorizontalDirection direction) {
-  if (direction > AirflowHorizontalDirection::RIGHT) {
-    this->horizontal_direction_ = AirflowHorizontalDirection::CENTER;
-  } else {
-    this->horizontal_direction_ = direction;
-  }
-  this->set_force_send_control_(true);
-}
-
-std::string HonClimate::get_cleaning_status_text() const {
-  switch (this->cleaning_status_) {
-    case CleaningState::SELF_CLEAN:
-      return "Self clean";
-    case CleaningState::STERI_CLEAN:
-      return "56°C Steri-Clean";
-    default:
-      return "No cleaning";
-  }
-}
-
-CleaningState HonClimate::get_cleaning_status() const { return this->cleaning_status_; }
-
-void HonClimate::start_self_cleaning() {
-  if (this->cleaning_status_ == CleaningState::NO_CLEANING) {
-    ESP_LOGI(TAG, "Sending self cleaning start request");
-    this->action_request_ = ActionRequest::START_SELF_CLEAN;
-    this->set_force_send_control_(true);
-  }
-}
-
-void HonClimate::start_steri_cleaning() {
-  if (this->cleaning_status_ == CleaningState::NO_CLEANING) {
-    ESP_LOGI(TAG, "Sending steri cleaning start request");
-    this->action_request_ = ActionRequest::START_STERI_CLEAN;
-    this->set_force_send_control_(true);
-  }
-}
-
-void HonClimate::set_send_wifi(bool send_wifi) { this->send_wifi_signal_ = send_wifi; }
-
-haier_protocol::HandlerError HonClimate::get_device_version_answer_handler_(uint8_t request_type, uint8_t message_type,
-                                                                            const uint8_t *data, size_t data_size) {
-  haier_protocol::HandlerError result = this->answer_preprocess_(
-      request_type, (uint8_t) hon_protocol::FrameType::GET_DEVICE_VERSION, message_type,
-      (uint8_t) hon_protocol::FrameType::GET_DEVICE_VERSION_RESPONSE, ProtocolPhases::WAITING_ANSWER_INIT_1);
-  if (result == haier_protocol::HandlerError::HANDLER_OK) {
-    if (data_size < sizeof(hon_protocol::DeviceVersionAnswer)) {
-      // Wrong structure
-      this->set_phase_(ProtocolPhases::SENDING_INIT_1);
-      return haier_protocol::HandlerError::WRONG_MESSAGE_STRUCTURE;
-    }
-    // All OK
-    hon_protocol::DeviceVersionAnswer *answr = (hon_protocol::DeviceVersionAnswer *) data;
-    char tmp[9];
-    tmp[8] = 0;
-    strncpy(tmp, answr->protocol_version, 8);
-    this->hvac_protocol_version_ = std::string(tmp);
-    strncpy(tmp, answr->software_version, 8);
-    this->hvac_software_version_ = std::string(tmp);
-    strncpy(tmp, answr->hardware_version, 8);
-    this->hvac_hardware_version_ = std::string(tmp);
-    strncpy(tmp, answr->device_name, 8);
-    this->hvac_device_name_ = std::string(tmp);
-    this->hvac_functions_[0] = (answr->functions[1] & 0x01) != 0;  // interactive mode support
-    this->hvac_functions_[1] = (answr->functions[1] & 0x02) != 0;  // controller-device mode support
-    this->hvac_functions_[2] = (answr->functions[1] & 0x04) != 0;  // crc support
-    this->hvac_functions_[3] = (answr->functions[1] & 0x08) != 0;  // multiple AC support
-    this->hvac_functions_[4] = (answr->functions[1] & 0x20) != 0;  // roles support
-    this->hvac_hardware_info_available_ = true;
-    this->set_phase_(ProtocolPhases::SENDING_INIT_2);
-    return result;
-  } else {
-    this->set_phase_((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
-                                                                     : ProtocolPhases::SENDING_INIT_1);
-    return result;
-  }
-}
-
-haier_protocol::HandlerError HonClimate::get_device_id_answer_handler_(uint8_t request_type, uint8_t message_type,
-                                                                       const uint8_t *data, size_t data_size) {
-  haier_protocol::HandlerError result = this->answer_preprocess_(
-      request_type, (uint8_t) hon_protocol::FrameType::GET_DEVICE_ID, message_type,
-      (uint8_t) hon_protocol::FrameType::GET_DEVICE_ID_RESPONSE, ProtocolPhases::WAITING_ANSWER_INIT_2);
-  if (result == haier_protocol::HandlerError::HANDLER_OK) {
-    this->set_phase_(ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
-    return result;
-  } else {
-    this->set_phase_((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
-                                                                     : ProtocolPhases::SENDING_INIT_1);
-    return result;
-  }
-}
-
-haier_protocol::HandlerError HonClimate::status_handler_(uint8_t request_type, uint8_t message_type,
-                                                         const uint8_t *data, size_t data_size) {
-  haier_protocol::HandlerError result =
-      this->answer_preprocess_(request_type, (uint8_t) hon_protocol::FrameType::CONTROL, message_type,
-                               (uint8_t) hon_protocol::FrameType::STATUS, ProtocolPhases::UNKNOWN);
-  if (result == haier_protocol::HandlerError::HANDLER_OK) {
-    result = this->process_status_message_(data, data_size);
-    if (result != haier_protocol::HandlerError::HANDLER_OK) {
-      ESP_LOGW(TAG, "Error %d while parsing Status packet", (int) result);
-      this->set_phase_((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
-                                                                       : ProtocolPhases::SENDING_INIT_1);
-    } else {
-      if (data_size >= sizeof(hon_protocol::HaierPacketControl) + 2) {
-        memcpy(this->last_status_message_.get(), data + 2, sizeof(hon_protocol::HaierPacketControl));
-      } else {
-        ESP_LOGW(TAG, "Status packet too small: %d (should be >= %d)", data_size,
-                 sizeof(hon_protocol::HaierPacketControl));
-      }
-      if (this->protocol_phase_ == ProtocolPhases::WAITING_FIRST_STATUS_ANSWER) {
-        ESP_LOGI(TAG, "First HVAC status received");
-        this->set_phase_(ProtocolPhases::SENDING_ALARM_STATUS_REQUEST);
-      } else if ((this->protocol_phase_ == ProtocolPhases::WAITING_STATUS_ANSWER) ||
-                 (this->protocol_phase_ == ProtocolPhases::WAITING_POWER_ON_ANSWER) ||
-                 (this->protocol_phase_ == ProtocolPhases::WAITING_POWER_OFF_ANSWER)) {
-        this->set_phase_(ProtocolPhases::IDLE);
-      } else if (this->protocol_phase_ == ProtocolPhases::WAITING_CONTROL_ANSWER) {
-        this->set_phase_(ProtocolPhases::IDLE);
-        this->set_force_send_control_(false);
-        if (this->hvac_settings_.valid)
-          this->hvac_settings_.reset();
-      }
-    }
-    return result;
-  } else {
-    this->set_phase_((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
-                                                                     : ProtocolPhases::SENDING_INIT_1);
-    return result;
-  }
-}
-
-haier_protocol::HandlerError HonClimate::get_management_information_answer_handler_(uint8_t request_type,
-                                                                                    uint8_t message_type,
-                                                                                    const uint8_t *data,
-                                                                                    size_t data_size) {
-  haier_protocol::HandlerError result =
-      this->answer_preprocess_(request_type, (uint8_t) hon_protocol::FrameType::GET_MANAGEMENT_INFORMATION,
-                               message_type, (uint8_t) hon_protocol::FrameType::GET_MANAGEMENT_INFORMATION_RESPONSE,
-                               ProtocolPhases::WAITING_UPDATE_SIGNAL_ANSWER);
-  if (result == haier_protocol::HandlerError::HANDLER_OK) {
-    this->set_phase_(ProtocolPhases::SENDING_SIGNAL_LEVEL);
-    return result;
-  } else {
-    this->set_phase_(ProtocolPhases::IDLE);
-    return result;
-  }
-}
-
-haier_protocol::HandlerError HonClimate::report_network_status_answer_handler_(uint8_t request_type,
-                                                                               uint8_t message_type,
-                                                                               const uint8_t *data, size_t data_size) {
-  haier_protocol::HandlerError result =
-      this->answer_preprocess_(request_type, (uint8_t) hon_protocol::FrameType::REPORT_NETWORK_STATUS, message_type,
-                               (uint8_t) hon_protocol::FrameType::CONFIRM, ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER);
-  this->set_phase_(ProtocolPhases::IDLE);
-  return result;
-}
-
-haier_protocol::HandlerError HonClimate::get_alarm_status_answer_handler_(uint8_t request_type, uint8_t message_type,
-                                                                          const uint8_t *data, size_t data_size) {
-  if (request_type == (uint8_t) hon_protocol::FrameType::GET_ALARM_STATUS) {
-    if (message_type != (uint8_t) hon_protocol::FrameType::GET_ALARM_STATUS_RESPONSE) {
-      // Unexpected answer to request
-      this->set_phase_(ProtocolPhases::IDLE);
-      return haier_protocol::HandlerError::UNSUPORTED_MESSAGE;
-    }
-    if (this->protocol_phase_ != ProtocolPhases::WAITING_ALARM_STATUS_ANSWER) {
-      // Don't expect this answer now
-      this->set_phase_(ProtocolPhases::IDLE);
-      return haier_protocol::HandlerError::UNEXPECTED_MESSAGE;
-    }
-    memcpy(this->active_alarms_, data + 2, 8);
-    this->set_phase_(ProtocolPhases::IDLE);
-    return haier_protocol::HandlerError::HANDLER_OK;
-  } else {
-    this->set_phase_(ProtocolPhases::IDLE);
-    return haier_protocol::HandlerError::UNSUPORTED_MESSAGE;
-  }
-}
-
-void HonClimate::set_answers_handlers() {
-  // Set handlers
-  this->haier_protocol_.set_answer_handler(
-      (uint8_t) (hon_protocol::FrameType::GET_DEVICE_VERSION),
-      std::bind(&HonClimate::get_device_version_answer_handler_, this, std::placeholders::_1, std::placeholders::_2,
-                std::placeholders::_3, std::placeholders::_4));
-  this->haier_protocol_.set_answer_handler(
-      (uint8_t) (hon_protocol::FrameType::GET_DEVICE_ID),
-      std::bind(&HonClimate::get_device_id_answer_handler_, this, std::placeholders::_1, std::placeholders::_2,
-                std::placeholders::_3, std::placeholders::_4));
-  this->haier_protocol_.set_answer_handler(
-      (uint8_t) (hon_protocol::FrameType::CONTROL),
-      std::bind(&HonClimate::status_handler_, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
-                std::placeholders::_4));
-  this->haier_protocol_.set_answer_handler(
-      (uint8_t) (hon_protocol::FrameType::GET_MANAGEMENT_INFORMATION),
-      std::bind(&HonClimate::get_management_information_answer_handler_, this, std::placeholders::_1,
-                std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
-  this->haier_protocol_.set_answer_handler(
-      (uint8_t) (hon_protocol::FrameType::GET_ALARM_STATUS),
-      std::bind(&HonClimate::get_alarm_status_answer_handler_, this, std::placeholders::_1, std::placeholders::_2,
-                std::placeholders::_3, std::placeholders::_4));
-  this->haier_protocol_.set_answer_handler(
-      (uint8_t) (hon_protocol::FrameType::REPORT_NETWORK_STATUS),
-      std::bind(&HonClimate::report_network_status_answer_handler_, this, std::placeholders::_1, std::placeholders::_2,
-                std::placeholders::_3, std::placeholders::_4));
-}
-
-void HonClimate::dump_config() {
-  HaierClimateBase::dump_config();
-  ESP_LOGCONFIG(TAG, "  Protocol version: hOn");
-  if (this->hvac_hardware_info_available_) {
-    ESP_LOGCONFIG(TAG, "  Device protocol version: %s", this->hvac_protocol_version_.c_str());
-    ESP_LOGCONFIG(TAG, "  Device software version: %s", this->hvac_software_version_.c_str());
-    ESP_LOGCONFIG(TAG, "  Device hardware version: %s", this->hvac_hardware_version_.c_str());
-    ESP_LOGCONFIG(TAG, "  Device name: %s", this->hvac_device_name_.c_str());
-    ESP_LOGCONFIG(TAG, "  Device features:%s%s%s%s%s", (this->hvac_functions_[0] ? " interactive" : ""),
-                  (this->hvac_functions_[1] ? " controller-device" : ""), (this->hvac_functions_[2] ? " crc" : ""),
-                  (this->hvac_functions_[3] ? " multinode" : ""), (this->hvac_functions_[4] ? " role" : ""));
-    ESP_LOGCONFIG(TAG, "  Active alarms: %s", buf_to_hex(this->active_alarms_, sizeof(this->active_alarms_)).c_str());
-  }
-}
-
-void HonClimate::process_phase(std::chrono::steady_clock::time_point now) {
-  switch (this->protocol_phase_) {
-    case ProtocolPhases::SENDING_INIT_1:
-      if (this->can_send_message() && this->is_protocol_initialisation_interval_exceded_(now)) {
-        this->hvac_hardware_info_available_ = false;
-        // Indicate device capabilities:
-        // bit 0 - if 1 module support interactive mode
-        // bit 1 - if 1 module support controller-device mode
-        // bit 2 - if 1 module support crc
-        // bit 3 - if 1 module support multiple devices
-        // bit 4..bit 15 - not used
-        uint8_t module_capabilities[2] = {0b00000000, 0b00000111};
-        static const haier_protocol::HaierMessage DEVICE_VERSION_REQUEST(
-            (uint8_t) hon_protocol::FrameType::GET_DEVICE_VERSION, module_capabilities, sizeof(module_capabilities));
-        this->send_message_(DEVICE_VERSION_REQUEST, this->use_crc_);
-        this->set_phase_(ProtocolPhases::WAITING_ANSWER_INIT_1);
-      }
-      break;
-    case ProtocolPhases::SENDING_INIT_2:
-      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
-        static const haier_protocol::HaierMessage DEVICEID_REQUEST((uint8_t) hon_protocol::FrameType::GET_DEVICE_ID);
-        this->send_message_(DEVICEID_REQUEST, this->use_crc_);
-        this->set_phase_(ProtocolPhases::WAITING_ANSWER_INIT_2);
-      }
-      break;
-    case ProtocolPhases::SENDING_FIRST_STATUS_REQUEST:
-    case ProtocolPhases::SENDING_STATUS_REQUEST:
-      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
-        static const haier_protocol::HaierMessage STATUS_REQUEST(
-            (uint8_t) hon_protocol::FrameType::CONTROL, (uint16_t) hon_protocol::SubcomandsControl::GET_USER_DATA);
-        this->send_message_(STATUS_REQUEST, this->use_crc_);
-        this->last_status_request_ = now;
-        this->set_phase_((ProtocolPhases) ((uint8_t) this->protocol_phase_ + 1));
-      }
-      break;
-#ifdef USE_WIFI
-    case ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST:
-      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
-        static const haier_protocol::HaierMessage UPDATE_SIGNAL_REQUEST(
-            (uint8_t) hon_protocol::FrameType::GET_MANAGEMENT_INFORMATION);
-        this->send_message_(UPDATE_SIGNAL_REQUEST, this->use_crc_);
-        this->last_signal_request_ = now;
-        this->set_phase_(ProtocolPhases::WAITING_UPDATE_SIGNAL_ANSWER);
-      }
-      break;
-    case ProtocolPhases::SENDING_SIGNAL_LEVEL:
-      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
-        static uint8_t wifi_status_data[4] = {0x00, 0x00, 0x00, 0x00};
-        if (wifi::global_wifi_component->is_connected()) {
-          wifi_status_data[1] = 0;
-          int8_t rssi = wifi::global_wifi_component->wifi_rssi();
-          wifi_status_data[3] = uint8_t((128 + rssi) / 1.28f);
-          ESP_LOGD(TAG, "WiFi signal is: %ddBm => %d%%", rssi, wifi_status_data[3]);
-        } else {
-          ESP_LOGD(TAG, "WiFi is not connected");
-          wifi_status_data[1] = 1;
-          wifi_status_data[3] = 0;
-        }
-        haier_protocol::HaierMessage wifi_status_request((uint8_t) hon_protocol::FrameType::REPORT_NETWORK_STATUS,
-                                                         wifi_status_data, sizeof(wifi_status_data));
-        this->send_message_(wifi_status_request, this->use_crc_);
-        this->set_phase_(ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER);
-      }
-      break;
-    case ProtocolPhases::WAITING_UPDATE_SIGNAL_ANSWER:
-    case ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER:
-      break;
-#else
-    case ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST:
-    case ProtocolPhases::SENDING_SIGNAL_LEVEL:
-    case ProtocolPhases::WAITING_UPDATE_SIGNAL_ANSWER:
-    case ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER:
-      this->set_phase_(ProtocolPhases::IDLE);
-      break;
-#endif
-    case ProtocolPhases::SENDING_ALARM_STATUS_REQUEST:
-      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
-        static const haier_protocol::HaierMessage ALARM_STATUS_REQUEST(
-            (uint8_t) hon_protocol::FrameType::GET_ALARM_STATUS);
-        this->send_message_(ALARM_STATUS_REQUEST, this->use_crc_);
-        this->set_phase_(ProtocolPhases::WAITING_ALARM_STATUS_ANSWER);
-      }
-      break;
-    case ProtocolPhases::SENDING_CONTROL:
-      if (this->first_control_attempt_) {
-        this->control_request_timestamp_ = now;
-        this->first_control_attempt_ = false;
-      }
-      if (this->is_control_message_timeout_exceeded_(now)) {
-        ESP_LOGW(TAG, "Sending control packet timeout!");
-        this->set_force_send_control_(false);
-        if (this->hvac_settings_.valid)
-          this->hvac_settings_.reset();
-        this->forced_request_status_ = true;
-        this->forced_publish_ = true;
-        this->set_phase_(ProtocolPhases::IDLE);
-      } else if (this->can_send_message() && this->is_control_message_interval_exceeded_(now)) {
-        haier_protocol::HaierMessage control_message = get_control_message();
-        this->send_message_(control_message, this->use_crc_);
-        ESP_LOGI(TAG, "Control packet sent");
-        this->set_phase_(ProtocolPhases::WAITING_CONTROL_ANSWER);
-      }
-      break;
-    case ProtocolPhases::SENDING_POWER_ON_COMMAND:
-    case ProtocolPhases::SENDING_POWER_OFF_COMMAND:
-      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
-        uint8_t pwr_cmd_buf[2] = {0x00, 0x00};
-        if (this->protocol_phase_ == ProtocolPhases::SENDING_POWER_ON_COMMAND)
-          pwr_cmd_buf[1] = 0x01;
-        haier_protocol::HaierMessage power_cmd((uint8_t) hon_protocol::FrameType::CONTROL,
-                                               ((uint16_t) hon_protocol::SubcomandsControl::SET_SINGLE_PARAMETER) + 1,
-                                               pwr_cmd_buf, sizeof(pwr_cmd_buf));
-        this->send_message_(power_cmd, this->use_crc_);
-        this->set_phase_(this->protocol_phase_ == ProtocolPhases::SENDING_POWER_ON_COMMAND
-                             ? ProtocolPhases::WAITING_POWER_ON_ANSWER
-                             : ProtocolPhases::WAITING_POWER_OFF_ANSWER);
-      }
-      break;
-
-    case ProtocolPhases::WAITING_ANSWER_INIT_1:
-    case ProtocolPhases::WAITING_ANSWER_INIT_2:
-    case ProtocolPhases::WAITING_FIRST_STATUS_ANSWER:
-    case ProtocolPhases::WAITING_ALARM_STATUS_ANSWER:
-    case ProtocolPhases::WAITING_STATUS_ANSWER:
-    case ProtocolPhases::WAITING_CONTROL_ANSWER:
-    case ProtocolPhases::WAITING_POWER_ON_ANSWER:
-    case ProtocolPhases::WAITING_POWER_OFF_ANSWER:
-      break;
-    case ProtocolPhases::IDLE: {
-      if (this->forced_request_status_ || this->is_status_request_interval_exceeded_(now)) {
-        this->set_phase_(ProtocolPhases::SENDING_STATUS_REQUEST);
-        this->forced_request_status_ = false;
-      }
-#ifdef USE_WIFI
-      else if (this->send_wifi_signal_ &&
-               (std::chrono::duration_cast<std::chrono::milliseconds>(now - this->last_signal_request_).count() >
-                SIGNAL_LEVEL_UPDATE_INTERVAL_MS))
-        this->set_phase_(ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST);
-#endif
-    } break;
-    default:
-      // Shouldn't get here
-#if (HAIER_LOG_LEVEL > 4)
-      ESP_LOGE(TAG, "Wrong protocol handler state: %s (%d), resetting communication",
-               phase_to_string_(this->protocol_phase_), (int) this->protocol_phase_);
-#else
-      ESP_LOGE(TAG, "Wrong protocol handler state: %d, resetting communication", (int) this->protocol_phase_);
-#endif
-      this->set_phase_(ProtocolPhases::SENDING_INIT_1);
-      break;
-  }
-}
-
-haier_protocol::HaierMessage HonClimate::get_control_message() {
-  uint8_t control_out_buffer[sizeof(hon_protocol::HaierPacketControl)];
-  memcpy(control_out_buffer, this->last_status_message_.get(), sizeof(hon_protocol::HaierPacketControl));
-  hon_protocol::HaierPacketControl *out_data = (hon_protocol::HaierPacketControl *) control_out_buffer;
-  bool has_hvac_settings = false;
-  if (this->hvac_settings_.valid) {
-    has_hvac_settings = true;
-    HvacSettings climate_control;
-    climate_control = this->hvac_settings_;
-    if (climate_control.mode.has_value()) {
-      switch (climate_control.mode.value()) {
-        case CLIMATE_MODE_OFF:
-          out_data->ac_power = 0;
-          break;
-        case CLIMATE_MODE_AUTO:
-          out_data->ac_power = 1;
-          out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::AUTO;
-          out_data->fan_mode = this->other_modes_fan_speed_;
-          break;
-        case CLIMATE_MODE_HEAT:
-          out_data->ac_power = 1;
-          out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::HEAT;
-          out_data->fan_mode = this->other_modes_fan_speed_;
-          break;
-        case CLIMATE_MODE_DRY:
-          out_data->ac_power = 1;
-          out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::DRY;
-          out_data->fan_mode = this->other_modes_fan_speed_;
-          break;
-        case CLIMATE_MODE_FAN_ONLY:
-          out_data->ac_power = 1;
-          out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::FAN;
-          out_data->fan_mode = this->fan_mode_speed_;  // Auto doesn't work in fan only mode
-          // Disabling boost and eco mode for Fan only
-          out_data->quiet_mode = 0;
-          out_data->fast_mode = 0;
-          break;
-        case CLIMATE_MODE_COOL:
-          out_data->ac_power = 1;
-          out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::COOL;
-          out_data->fan_mode = this->other_modes_fan_speed_;
-          break;
-        default:
-          ESP_LOGE("Control", "Unsupported climate mode");
-          break;
-      }
-    }
-    // Set fan speed, if we are in fan mode, reject auto in fan mode
-    if (climate_control.fan_mode.has_value()) {
-      switch (climate_control.fan_mode.value()) {
-        case CLIMATE_FAN_LOW:
-          out_data->fan_mode = (uint8_t) hon_protocol::FanMode::FAN_LOW;
-          break;
-        case CLIMATE_FAN_MEDIUM:
-          out_data->fan_mode = (uint8_t) hon_protocol::FanMode::FAN_MID;
-          break;
-        case CLIMATE_FAN_HIGH:
-          out_data->fan_mode = (uint8_t) hon_protocol::FanMode::FAN_HIGH;
-          break;
-        case CLIMATE_FAN_AUTO:
-          if (mode != CLIMATE_MODE_FAN_ONLY)  // if we are not in fan only mode
-            out_data->fan_mode = (uint8_t) hon_protocol::FanMode::FAN_AUTO;
-          break;
-        default:
-          ESP_LOGE("Control", "Unsupported fan mode");
-          break;
-      }
-    }
-    // Set swing mode
-    if (climate_control.swing_mode.has_value()) {
-      switch (climate_control.swing_mode.value()) {
-        case CLIMATE_SWING_OFF:
-          out_data->horizontal_swing_mode = (uint8_t) get_horizontal_swing_mode(this->horizontal_direction_);
-          out_data->vertical_swing_mode = (uint8_t) get_vertical_swing_mode(this->vertical_direction_);
-          break;
-        case CLIMATE_SWING_VERTICAL:
-          out_data->horizontal_swing_mode = (uint8_t) get_horizontal_swing_mode(this->horizontal_direction_);
-          out_data->vertical_swing_mode = (uint8_t) hon_protocol::VerticalSwingMode::AUTO;
-          break;
-        case CLIMATE_SWING_HORIZONTAL:
-          out_data->horizontal_swing_mode = (uint8_t) hon_protocol::HorizontalSwingMode::AUTO;
-          out_data->vertical_swing_mode = (uint8_t) get_vertical_swing_mode(this->vertical_direction_);
-          break;
-        case CLIMATE_SWING_BOTH:
-          out_data->horizontal_swing_mode = (uint8_t) hon_protocol::HorizontalSwingMode::AUTO;
-          out_data->vertical_swing_mode = (uint8_t) hon_protocol::VerticalSwingMode::AUTO;
-          break;
-      }
-    }
-    if (climate_control.target_temperature.has_value()) {
-      out_data->set_point =
-          climate_control.target_temperature.value() - 16;  // set the temperature at our offset, subtract 16.
-    }
-    if (out_data->ac_power == 0) {
-      // If AC is off - no presets alowed
-      out_data->quiet_mode = 0;
-      out_data->fast_mode = 0;
-      out_data->sleep_mode = 0;
-    } else if (climate_control.preset.has_value()) {
-      switch (climate_control.preset.value()) {
-        case CLIMATE_PRESET_NONE:
-          out_data->quiet_mode = 0;
-          out_data->fast_mode = 0;
-          out_data->sleep_mode = 0;
-          break;
-        case CLIMATE_PRESET_ECO:
-          // Eco is not supported in Fan only mode
-          out_data->quiet_mode = (this->mode != CLIMATE_MODE_FAN_ONLY) ? 1 : 0;
-          out_data->fast_mode = 0;
-          out_data->sleep_mode = 0;
-          break;
-        case CLIMATE_PRESET_BOOST:
-          out_data->quiet_mode = 0;
-          // Boost is not supported in Fan only mode
-          out_data->fast_mode = (this->mode != CLIMATE_MODE_FAN_ONLY) ? 1 : 0;
-          out_data->sleep_mode = 0;
-          break;
-        case CLIMATE_PRESET_AWAY:
-          out_data->quiet_mode = 0;
-          out_data->fast_mode = 0;
-          out_data->sleep_mode = 0;
-          break;
-        case CLIMATE_PRESET_SLEEP:
-          out_data->quiet_mode = 0;
-          out_data->fast_mode = 0;
-          out_data->sleep_mode = 1;
-          break;
-        default:
-          ESP_LOGE("Control", "Unsupported preset");
-          break;
-      }
-    }
-  } else {
-    if (out_data->vertical_swing_mode != (uint8_t) hon_protocol::VerticalSwingMode::AUTO)
-      out_data->vertical_swing_mode = (uint8_t) get_vertical_swing_mode(this->vertical_direction_);
-    if (out_data->horizontal_swing_mode != (uint8_t) hon_protocol::HorizontalSwingMode::AUTO)
-      out_data->horizontal_swing_mode = (uint8_t) get_horizontal_swing_mode(this->horizontal_direction_);
-  }
-  out_data->beeper_status = ((!this->beeper_status_) || (!has_hvac_settings)) ? 1 : 0;
-  control_out_buffer[4] = 0;  // This byte should be cleared before setting values
-  out_data->display_status = this->display_status_ ? 1 : 0;
-  out_data->health_mode = this->health_mode_ ? 1 : 0;
-  switch (this->action_request_) {
-    case ActionRequest::START_SELF_CLEAN:
-      this->action_request_ = ActionRequest::NO_ACTION;
-      out_data->self_cleaning_status = 1;
-      out_data->steri_clean = 0;
-      out_data->set_point = 0x06;
-      out_data->vertical_swing_mode = (uint8_t) hon_protocol::VerticalSwingMode::CENTER;
-      out_data->horizontal_swing_mode = (uint8_t) hon_protocol::HorizontalSwingMode::CENTER;
-      out_data->ac_power = 1;
-      out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::DRY;
-      out_data->light_status = 0;
-      break;
-    case ActionRequest::START_STERI_CLEAN:
-      this->action_request_ = ActionRequest::NO_ACTION;
-      out_data->self_cleaning_status = 0;
-      out_data->steri_clean = 1;
-      out_data->set_point = 0x06;
-      out_data->vertical_swing_mode = (uint8_t) hon_protocol::VerticalSwingMode::CENTER;
-      out_data->horizontal_swing_mode = (uint8_t) hon_protocol::HorizontalSwingMode::CENTER;
-      out_data->ac_power = 1;
-      out_data->ac_mode = (uint8_t) hon_protocol::ConditioningMode::DRY;
-      out_data->light_status = 0;
-      break;
-    default:
-      // No change
-      break;
-  }
-  return haier_protocol::HaierMessage((uint8_t) hon_protocol::FrameType::CONTROL,
-                                      (uint16_t) hon_protocol::SubcomandsControl::SET_GROUP_PARAMETERS,
-                                      control_out_buffer, sizeof(hon_protocol::HaierPacketControl));
-}
-
-haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *packet_buffer, uint8_t size) {
-  if (size < sizeof(hon_protocol::HaierStatus))
-    return haier_protocol::HandlerError::WRONG_MESSAGE_STRUCTURE;
-  hon_protocol::HaierStatus packet;
-  if (size < sizeof(hon_protocol::HaierStatus))
-    size = sizeof(hon_protocol::HaierStatus);
-  memcpy(&packet, packet_buffer, size);
-  if (packet.sensors.error_status != 0) {
-    ESP_LOGW(TAG, "HVAC error, code=0x%02X", packet.sensors.error_status);
-  }
-  if ((this->outdoor_sensor_ != nullptr) && (got_valid_outdoor_temp_ || (packet.sensors.outdoor_temperature > 0))) {
-    got_valid_outdoor_temp_ = true;
-    float otemp = (float) (packet.sensors.outdoor_temperature + PROTOCOL_OUTDOOR_TEMPERATURE_OFFSET);
-    if ((!this->outdoor_sensor_->has_state()) || (this->outdoor_sensor_->get_raw_state() != otemp))
-      this->outdoor_sensor_->publish_state(otemp);
-  }
-  bool should_publish = false;
-  {
-    // Extra modes/presets
-    optional<ClimatePreset> old_preset = this->preset;
-    if (packet.control.quiet_mode != 0) {
-      this->preset = CLIMATE_PRESET_ECO;
-    } else if (packet.control.fast_mode != 0) {
-      this->preset = CLIMATE_PRESET_BOOST;
-    } else if (packet.control.sleep_mode != 0) {
-      this->preset = CLIMATE_PRESET_SLEEP;
-    } else {
-      this->preset = CLIMATE_PRESET_NONE;
-    }
-    should_publish = should_publish || (!old_preset.has_value()) || (old_preset.value() != this->preset.value());
-  }
-  {
-    // Target temperature
-    float old_target_temperature = this->target_temperature;
-    this->target_temperature = packet.control.set_point + 16.0f;
-    should_publish = should_publish || (old_target_temperature != this->target_temperature);
-  }
-  {
-    // Current temperature
-    float old_current_temperature = this->current_temperature;
-    this->current_temperature = packet.sensors.room_temperature / 2.0f;
-    should_publish = should_publish || (old_current_temperature != this->current_temperature);
-  }
-  {
-    // Fan mode
-    optional<ClimateFanMode> old_fan_mode = this->fan_mode;
-    // remember the fan speed we last had for climate vs fan
-    if (packet.control.ac_mode == (uint8_t) hon_protocol::ConditioningMode::FAN) {
-      if (packet.control.fan_mode != (uint8_t) hon_protocol::FanMode::FAN_AUTO)
-        this->fan_mode_speed_ = packet.control.fan_mode;
-    } else {
-      this->other_modes_fan_speed_ = packet.control.fan_mode;
-    }
-    switch (packet.control.fan_mode) {
-      case (uint8_t) hon_protocol::FanMode::FAN_AUTO:
-        if (packet.control.ac_mode != (uint8_t) hon_protocol::ConditioningMode::FAN) {
-          this->fan_mode = CLIMATE_FAN_AUTO;
-        } else {
-          // Shouldn't accept fan speed auto in fan-only mode even if AC reports it
-          ESP_LOGI(TAG, "Fan speed Auto is not supported in Fan only AC mode, ignoring");
-        }
-        break;
-      case (uint8_t) hon_protocol::FanMode::FAN_MID:
-        this->fan_mode = CLIMATE_FAN_MEDIUM;
-        break;
-      case (uint8_t) hon_protocol::FanMode::FAN_LOW:
-        this->fan_mode = CLIMATE_FAN_LOW;
-        break;
-      case (uint8_t) hon_protocol::FanMode::FAN_HIGH:
-        this->fan_mode = CLIMATE_FAN_HIGH;
-        break;
-    }
-    should_publish = should_publish || (!old_fan_mode.has_value()) || (old_fan_mode.value() != fan_mode.value());
-  }
-  {
-    // Display status
-    // should be before "Climate mode" because it is changing this->mode
-    if (packet.control.ac_power != 0) {
-      // if AC is off display status always ON so process it only when AC is on
-      bool disp_status = packet.control.display_status != 0;
-      if (disp_status != this->display_status_) {
-        // Do something only if display status changed
-        if (this->mode == CLIMATE_MODE_OFF) {
-          // AC just turned on from remote need to turn off display
-          this->set_force_send_control_(true);
-        } else {
-          this->display_status_ = disp_status;
-        }
-      }
-    }
-  }
-  {
-    // Health mode
-    bool old_health_mode = this->health_mode_;
-    this->health_mode_ = packet.control.health_mode == 1;
-    should_publish = should_publish || (old_health_mode != this->health_mode_);
-  }
-  {
-    CleaningState new_cleaning;
-    if (packet.control.steri_clean == 1) {
-      // Steri-cleaning
-      new_cleaning = CleaningState::STERI_CLEAN;
-    } else if (packet.control.self_cleaning_status == 1) {
-      // Self-cleaning
-      new_cleaning = CleaningState::SELF_CLEAN;
-    } else {
-      // No cleaning
-      new_cleaning = CleaningState::NO_CLEANING;
-    }
-    if (new_cleaning != this->cleaning_status_) {
-      ESP_LOGD(TAG, "Cleaning status change: %d => %d", (uint8_t) this->cleaning_status_, (uint8_t) new_cleaning);
-      if (new_cleaning == CleaningState::NO_CLEANING) {
-        // Turnuin AC off after cleaning
-        this->action_request_ = ActionRequest::TURN_POWER_OFF;
-      }
-      this->cleaning_status_ = new_cleaning;
-    }
-  }
-  {
-    // Climate mode
-    ClimateMode old_mode = this->mode;
-    if (packet.control.ac_power == 0) {
-      this->mode = CLIMATE_MODE_OFF;
-    } else {
-      // Check current hvac mode
-      switch (packet.control.ac_mode) {
-        case (uint8_t) hon_protocol::ConditioningMode::COOL:
-          this->mode = CLIMATE_MODE_COOL;
-          break;
-        case (uint8_t) hon_protocol::ConditioningMode::HEAT:
-          this->mode = CLIMATE_MODE_HEAT;
-          break;
-        case (uint8_t) hon_protocol::ConditioningMode::DRY:
-          this->mode = CLIMATE_MODE_DRY;
-          break;
-        case (uint8_t) hon_protocol::ConditioningMode::FAN:
-          this->mode = CLIMATE_MODE_FAN_ONLY;
-          break;
-        case (uint8_t) hon_protocol::ConditioningMode::AUTO:
-          this->mode = CLIMATE_MODE_AUTO;
-          break;
-      }
-    }
-    should_publish = should_publish || (old_mode != this->mode);
-  }
-  {
-    // Swing mode
-    ClimateSwingMode old_swing_mode = this->swing_mode;
-    if (packet.control.horizontal_swing_mode == (uint8_t) hon_protocol::HorizontalSwingMode::AUTO) {
-      if (packet.control.vertical_swing_mode == (uint8_t) hon_protocol::VerticalSwingMode::AUTO) {
-        this->swing_mode = CLIMATE_SWING_BOTH;
-      } else {
-        this->swing_mode = CLIMATE_SWING_HORIZONTAL;
-      }
-    } else {
-      if (packet.control.vertical_swing_mode == (uint8_t) hon_protocol::VerticalSwingMode::AUTO) {
-        this->swing_mode = CLIMATE_SWING_VERTICAL;
-      } else {
-        this->swing_mode = CLIMATE_SWING_OFF;
-      }
-    }
-    should_publish = should_publish || (old_swing_mode != this->swing_mode);
-  }
-  this->last_valid_status_timestamp_ = std::chrono::steady_clock::now();
-  if (this->forced_publish_ || should_publish) {
-#if (HAIER_LOG_LEVEL > 4)
-    std::chrono::high_resolution_clock::time_point _publish_start = std::chrono::high_resolution_clock::now();
-#endif
-    this->publish_state();
-#if (HAIER_LOG_LEVEL > 4)
-    ESP_LOGV(TAG, "Publish delay: %lld ms",
-             std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() -
-                                                                   _publish_start)
-                 .count());
-#endif
-    this->forced_publish_ = false;
-  }
-  if (should_publish) {
-    ESP_LOGI(TAG, "HVAC values changed");
-  }
-  esp_log_printf_((should_publish ? ESPHOME_LOG_LEVEL_INFO : ESPHOME_LOG_LEVEL_DEBUG), TAG, __LINE__,
-                  "HVAC Mode = 0x%X", packet.control.ac_mode);
-  esp_log_printf_((should_publish ? ESPHOME_LOG_LEVEL_INFO : ESPHOME_LOG_LEVEL_DEBUG), TAG, __LINE__,
-                  "Fan speed Status = 0x%X", packet.control.fan_mode);
-  esp_log_printf_((should_publish ? ESPHOME_LOG_LEVEL_INFO : ESPHOME_LOG_LEVEL_DEBUG), TAG, __LINE__,
-                  "Horizontal Swing Status = 0x%X", packet.control.horizontal_swing_mode);
-  esp_log_printf_((should_publish ? ESPHOME_LOG_LEVEL_INFO : ESPHOME_LOG_LEVEL_DEBUG), TAG, __LINE__,
-                  "Vertical Swing Status = 0x%X", packet.control.vertical_swing_mode);
-  esp_log_printf_((should_publish ? ESPHOME_LOG_LEVEL_INFO : ESPHOME_LOG_LEVEL_DEBUG), TAG, __LINE__,
-                  "Set Point Status = 0x%X", packet.control.set_point);
-  return haier_protocol::HandlerError::HANDLER_OK;
-}
-
-bool HonClimate::is_message_invalid(uint8_t message_type) {
-  return message_type == (uint8_t) hon_protocol::FrameType::INVALID;
-}
-
-void HonClimate::process_pending_action() {
-  switch (this->action_request_) {
-    case ActionRequest::START_SELF_CLEAN:
-    case ActionRequest::START_STERI_CLEAN:
-      // Will reset action with control message sending
-      this->set_phase_(ProtocolPhases::SENDING_CONTROL);
-      break;
-    default:
-      HaierClimateBase::process_pending_action();
-      break;
-  }
-}
-
-}  // namespace haier
-}  // namespace esphome

esphome/components/haier/hon_climate.h

@@ -1,95 +0,0 @@
-#pragma once
-
-#include <chrono>
-#include "esphome/components/sensor/sensor.h"
-#include "haier_base.h"
-
-namespace esphome {
-namespace haier {
-
-enum class AirflowVerticalDirection : uint8_t {
-  HEALTH_UP = 0,
-  MAX_UP = 1,
-  UP = 2,
-  CENTER = 3,
-  DOWN = 4,
-  HEALTH_DOWN = 5,
-};
-
-enum class AirflowHorizontalDirection : uint8_t {
-  MAX_LEFT = 0,
-  LEFT = 1,
-  CENTER = 2,
-  RIGHT = 3,
-  MAX_RIGHT = 4,
-};
-
-enum class CleaningState : uint8_t {
-  NO_CLEANING = 0,
-  SELF_CLEAN = 1,
-  STERI_CLEAN = 2,
-};
-
-class HonClimate : public HaierClimateBase {
- public:
-  HonClimate();
-  HonClimate(const HonClimate &) = delete;
-  HonClimate &operator=(const HonClimate &) = delete;
-  ~HonClimate();
-  void dump_config() override;
-  void set_beeper_state(bool state);
-  bool get_beeper_state() const;
-  void set_outdoor_temperature_sensor(esphome::sensor::Sensor *sensor);
-  AirflowVerticalDirection get_vertical_airflow() const;
-  void set_vertical_airflow(AirflowVerticalDirection direction);
-  AirflowHorizontalDirection get_horizontal_airflow() const;
-  void set_horizontal_airflow(AirflowHorizontalDirection direction);
-  std::string get_cleaning_status_text() const;
-  CleaningState get_cleaning_status() const;
-  void start_self_cleaning();
-  void start_steri_cleaning();
-  void set_send_wifi(bool send_wifi);
-
- protected:
-  void set_answers_handlers() override;
-  void process_phase(std::chrono::steady_clock::time_point now) override;
-  haier_protocol::HaierMessage get_control_message() override;
-  bool is_message_invalid(uint8_t message_type) override;
-  void process_pending_action() override;
-
-  // Answers handlers
-  haier_protocol::HandlerError get_device_version_answer_handler_(uint8_t request_type, uint8_t message_type,
-                                                                  const uint8_t *data, size_t data_size);
-  haier_protocol::HandlerError get_device_id_answer_handler_(uint8_t request_type, uint8_t message_type,
-                                                             const uint8_t *data, size_t data_size);
-  haier_protocol::HandlerError status_handler_(uint8_t request_type, uint8_t message_type, const uint8_t *data,
-                                               size_t data_size);
-  haier_protocol::HandlerError get_management_information_answer_handler_(uint8_t request_type, uint8_t message_type,
-                                                                          const uint8_t *data, size_t data_size);
-  haier_protocol::HandlerError report_network_status_answer_handler_(uint8_t request_type, uint8_t message_type,
-                                                                     const uint8_t *data, size_t data_size);
-  haier_protocol::HandlerError get_alarm_status_answer_handler_(uint8_t request_type, uint8_t message_type,
-                                                                const uint8_t *data, size_t data_size);
-  // Helper functions
-  haier_protocol::HandlerError process_status_message_(const uint8_t *packet, uint8_t size);
-  std::unique_ptr<uint8_t[]> last_status_message_;
-  bool beeper_status_;
-  CleaningState cleaning_status_;
-  bool got_valid_outdoor_temp_;
-  AirflowVerticalDirection vertical_direction_;
-  AirflowHorizontalDirection horizontal_direction_;
-  bool hvac_hardware_info_available_;
-  std::string hvac_protocol_version_;
-  std::string hvac_software_version_;
-  std::string hvac_hardware_version_;
-  std::string hvac_device_name_;
-  bool hvac_functions_[5];
-  bool &use_crc_;
-  uint8_t active_alarms_[8];
-  esphome::sensor::Sensor *outdoor_sensor_;
-  bool send_wifi_signal_;
-  std::chrono::steady_clock::time_point last_signal_request_;  // To send WiFI signal level
-};
-
-}  // namespace haier
-}  // namespace esphome

esphome/components/haier/hon_packet.h

@@ -1,228 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace esphome {
-namespace haier {
-namespace hon_protocol {
-
-enum class VerticalSwingMode : uint8_t {
-  HEALTH_UP = 0x01,
-  MAX_UP = 0x02,
-  HEALTH_DOWN = 0x03,
-  UP = 0x04,
-  CENTER = 0x06,
-  DOWN = 0x08,
-  AUTO = 0x0C
-};
-
-enum class HorizontalSwingMode : uint8_t {
-  CENTER = 0x00,
-  MAX_LEFT = 0x03,
-  LEFT = 0x04,
-  RIGHT = 0x05,
-  MAX_RIGHT = 0x06,
-  AUTO = 0x07
-};
-
-enum class ConditioningMode : uint8_t {
-  AUTO = 0x00,
-  COOL = 0x01,
-  DRY = 0x02,
-  HEALTHY_DRY = 0x03,
-  HEAT = 0x04,
-  ENERGY_SAVING = 0x05,
-  FAN = 0x06
-};
-
-enum class SpecialMode : uint8_t { NONE = 0x00, ELDERLY = 0x01, CHILDREN = 0x02, PREGNANT = 0x03 };
-
-enum class FanMode : uint8_t { FAN_HIGH = 0x01, FAN_MID = 0x02, FAN_LOW = 0x03, FAN_AUTO = 0x05 };
-
-struct HaierPacketControl {
-  // Control bytes starts here
-  // 10
-  uint8_t set_point;  // Target temperature with 16°C offset (0x00 = 16°C)
-  // 11
-  uint8_t vertical_swing_mode : 4;  // See enum VerticalSwingMode
-  uint8_t : 0;
-  // 12
-  uint8_t fan_mode : 3;      // See enum FanMode
-  uint8_t special_mode : 2;  // See enum SpecialMode
-  uint8_t ac_mode : 3;       // See enum ConditioningMode
-  // 13
-  uint8_t : 8;
-  // 14
-  uint8_t ten_degree : 1;          // 10 degree status
-  uint8_t display_status : 1;      // If 0 disables AC's display
-  uint8_t half_degree : 1;         // Use half degree
-  uint8_t intelegence_status : 1;  // Intelligence status
-  uint8_t pmv_status : 1;          // Comfort/PMV status
-  uint8_t use_fahrenheit : 1;      // Use Fahrenheit instead of Celsius
-  uint8_t : 1;
-  uint8_t steri_clean : 1;
-  // 15
-  uint8_t ac_power : 1;                 // Is ac on or off
-  uint8_t health_mode : 1;              // Health mode (negative ions) on or off
-  uint8_t electric_heating_status : 1;  // Electric heating status
-  uint8_t fast_mode : 1;                // Fast mode
-  uint8_t quiet_mode : 1;               // Quiet mode
-  uint8_t sleep_mode : 1;               // Sleep mode
-  uint8_t lock_remote : 1;              // Disable remote
-  uint8_t beeper_status : 1;  // If 1 disables AC's command feedback beeper (need to be set on every control command)
-  // 16
-  uint8_t target_humidity;  // Target humidity (0=30% .. 3C=90%, step = 1%)
-  // 17
-  uint8_t horizontal_swing_mode : 3;  // See enum HorizontalSwingMode
-  uint8_t : 3;
-  uint8_t human_sensing_status : 2;  // Human sensing status
-  // 18
-  uint8_t change_filter : 1;  // Filter need replacement
-  uint8_t : 0;
-  // 19
-  uint8_t fresh_air_status : 1;       // Fresh air status
-  uint8_t humidification_status : 1;  // Humidification status
-  uint8_t pm2p5_cleaning_status : 1;  // PM2.5 cleaning status
-  uint8_t ch2o_cleaning_status : 1;   // CH2O cleaning status
-  uint8_t self_cleaning_status : 1;   // Self cleaning status
-  uint8_t light_status : 1;           // Light status
-  uint8_t energy_saving_status : 1;   // Energy saving status
-  uint8_t cleaning_time_status : 1;   // Cleaning time (0 - accumulation, 1 - clear)
-};
-
-struct HaierPacketSensors {
-  // 20
-  uint8_t room_temperature;  // 0.5°C step
-  // 21
-  uint8_t room_humidity;  // 0%-100% with 1% step
-  // 22
-  uint8_t outdoor_temperature;  // 1°C step, -64°C offset (0=-64°C)
-  // 23
-  uint8_t pm2p5_level : 2;    // Indoor PM2.5 grade (00: Excellent, 01: good, 02: Medium, 03: Bad)
-  uint8_t air_quality : 2;    // Air quality grade (00: Excellent, 01: good, 02: Medium, 03: Bad)
-  uint8_t human_sensing : 2;  // Human presence result (00: N/A, 01: not detected, 02: One, 03: Multiple)
-  uint8_t : 1;
-  uint8_t ac_type : 1;  // 00 - Heat and cool, 01 - Cool only)
-  // 24
-  uint8_t error_status;  // See enum ErrorStatus
-  // 25
-  uint8_t operation_source : 2;   // who is controlling AC (00: Other, 01: Remote control, 02: Button, 03: ESP)
-  uint8_t operation_mode_hk : 2;  // Homekit only, operation mode (00: Cool, 01: Dry, 02: Heat, 03: Fan)
-  uint8_t : 3;
-  uint8_t err_confirmation : 1;  // If 1 clear error status
-  // 26
-  uint16_t total_cleaning_time;  // Cleaning cumulative time (1h step)
-  // 28
-  uint16_t indoor_pm2p5_value;  // Indoor PM2.5 value (0 ug/m3 -  4095 ug/m3, 1 ug/m3 step)
-  // 30
-  uint16_t outdoor_pm2p5_value;  // Outdoor PM2.5 value (0 ug/m3 -  4095 ug/m3, 1 ug/m3 step)
-  // 32
-  uint16_t ch2o_value;  // Formaldehyde value (0 ug/m3 -  10000 ug/m3, 1 ug/m3 step)
-  // 34
-  uint16_t voc_value;  // VOC value (Volatile Organic Compounds) (0 ug/m3 -  1023 ug/m3, 1 ug/m3 step)
-  // 36
-  uint16_t co2_value;  // CO2 value (0 PPM -  10000 PPM, 1 PPM step)
-};
-
-struct HaierStatus {
-  uint16_t subcommand;
-  HaierPacketControl control;
-  HaierPacketSensors sensors;
-};
-
-struct DeviceVersionAnswer {
-  char protocol_version[8];
-  char software_version[8];
-  uint8_t encryption[3];
-  char hardware_version[8];
-  uint8_t : 8;
-  char device_name[8];
-  uint8_t functions[2];
-};
-
-// In this section comments:
-//  - module is the ESP32 control module (communication module in Haier protocol document)
-//  - device is the conditioner control board (network appliances in Haier protocol document)
-enum class FrameType : uint8_t {
-  CONTROL = 0x01,  // Requests or sets one or multiple parameters (module <-> device, required)
-  STATUS = 0x02,   // Contains one or multiple parameters values, usually answer to control frame (module <-> device,
-                   // required)
-  INVALID = 0x03,  // Communication error indication (module <-> device, required)
-  ALARM_STATUS = 0x04,  // Alarm status report (module <-> device, interactive, required)
-  CONFIRM = 0x05,  // Acknowledgment, usually used to confirm reception of frame if there is no special answer (module
-                   // <-> device, required)
-  REPORT = 0x06,   // Report frame (module <-> device, interactive, required)
-  STOP_FAULT_ALARM = 0x09,             // Stop fault alarm frame (module -> device, interactive, required)
-  SYSTEM_DOWNLIK = 0x11,               // System downlink frame (module -> device, optional)
-  DEVICE_UPLINK = 0x12,                // Device uplink frame (module <- device , interactive, optional)
-  SYSTEM_QUERY = 0x13,                 // System query frame (module -> device, optional)
-  SYSTEM_QUERY_RESPONSE = 0x14,        // System query response frame (module <- device , optional)
-  DEVICE_QUERY = 0x15,                 // Device query frame (module <- device, optional)
-  DEVICE_QUERY_RESPONSE = 0x16,        // Device query response frame (module -> device, optional)
-  GROUP_COMMAND = 0x60,                // Group command frame (module -> device, interactive, optional)
-  GET_DEVICE_VERSION = 0x61,           // Requests device version (module -> device, required)
-  GET_DEVICE_VERSION_RESPONSE = 0x62,  // Device version answer (module <- device, required_
-  GET_ALL_ADDRESSES = 0x67,            // Requests all devices addresses (module -> device, interactive, optional)
-  GET_ALL_ADDRESSES_RESPONSE =
-      0x68,  // Answer to request of all devices addresses (module <- device , interactive, optional)
-  HANDSET_CHANGE_NOTIFICATION = 0x69,  // Handset change notification frame (module <- device , interactive, optional)
-  GET_DEVICE_ID = 0x70,                // Requests Device ID (module -> device, required)
-  GET_DEVICE_ID_RESPONSE = 0x71,       // Response to device ID request (module <- device , required)
-  GET_ALARM_STATUS = 0x73,             // Alarm status request (module -> device, required)
-  GET_ALARM_STATUS_RESPONSE = 0x74,    // Response to alarm status request (module <- device, required)
-  GET_DEVICE_CONFIGURATION = 0x7C,     // Requests device configuration (module -> device, interactive, required)
-  GET_DEVICE_CONFIGURATION_RESPONSE =
-      0x7D,  // Response to device configuration request (module <- device, interactive, required)
-  DOWNLINK_TRANSPARENT_TRANSMISSION = 0x8C,  // Downlink transparent transmission (proxy data Haier cloud -> device)
-                                             // (module -> device, interactive, optional)
-  UPLINK_TRANSPARENT_TRANSMISSION = 0x8D,  // Uplink transparent transmission (proxy data device -> Haier cloud) (module
-                                           // <- device, interactive, optional)
-  START_DEVICE_UPGRADE = 0xE1,             // Initiate device OTA upgrade (module -> device, OTA required)
-  START_DEVICE_UPGRADE_RESPONSE = 0xE2,  // Response to initiate device upgrade command (module <- device, OTA required)
-  GET_FIRMWARE_CONTENT = 0xE5,           // Requests to send firmware (module <- device, OTA required)
-  GET_FIRMWARE_CONTENT_RESPONSE =
-      0xE6,                 // Response to send firmware request (module -> device, OTA required) (multipacket?)
-  CHANGE_BAUD_RATE = 0xE7,  // Requests to change port baud rate (module <- device, OTA required)
-  CHANGE_BAUD_RATE_RESPONSE = 0xE8,    // Response to change port baud rate request (module -> device, OTA required)
-  GET_SUBBOARD_INFO = 0xE9,            // Requests subboard information (module -> device, required)
-  GET_SUBBOARD_INFO_RESPONSE = 0xEA,   // Response to subboard information request (module <- device, required)
-  GET_HARDWARE_INFO = 0xEB,            // Requests information about device and subboard (module -> device, required)
-  GET_HARDWARE_INFO_RESPONSE = 0xEC,   // Response to hardware information request (module <- device, required)
-  GET_UPGRADE_RESULT = 0xED,           // Requests result of the firmware update (module <- device, OTA required)
-  GET_UPGRADE_RESULT_RESPONSE = 0xEF,  // Response to firmware update results request (module -> device, OTA required)
-  GET_NETWORK_STATUS = 0xF0,           // Requests network status (module <- device, interactive, optional)
-  GET_NETWORK_STATUS_RESPONSE = 0xF1,  // Response to network status request (module -> device, interactive, optional)
-  START_WIFI_CONFIGURATION = 0xF2,     // Starts WiFi configuration procedure (module <- device, interactive, required)
-  START_WIFI_CONFIGURATION_RESPONSE =
-      0xF3,  // Response to start WiFi configuration request (module -> device, interactive, required)
-  STOP_WIFI_CONFIGURATION = 0xF4,  // Stop WiFi configuration procedure (module <- device, interactive, required)
-  STOP_WIFI_CONFIGURATION_RESPONSE =
-      0xF5,  // Response to stop WiFi configuration request (module -> device, interactive, required)
-  REPORT_NETWORK_STATUS = 0xF7,  // Reports network status (module -> device, required)
-  CLEAR_CONFIGURATION = 0xF8,    // Request to clear module configuration (module <- device, interactive, optional)
-  BIG_DATA_REPORT_CONFIGURATION =
-      0xFA,  // Configuration for autoreport device full status (module -> device, interactive, optional)
-  BIG_DATA_REPORT_CONFIGURATION_RESPONSE =
-      0xFB,  // Response to set big data configuration (module <- device, interactive, optional)
-  GET_MANAGEMENT_INFORMATION = 0xFC,  // Request management information from device (module -> device, required)
-  GET_MANAGEMENT_INFORMATION_RESPONSE =
-      0xFD,        // Response to management information request (module <- device, required)
-  WAKE_UP = 0xFE,  // Request to wake up (module <-> device, optional)
-};
-
-enum class SubcomandsControl : uint16_t {
-  GET_PARAMETERS = 0x4C01,  // Request specific parameters (packet content: parameter ID1 + parameter ID2 + ...)
-  GET_USER_DATA = 0x4D01,   // Request all user data from device (packet content: None)
-  GET_BIG_DATA = 0x4DFE,    // Request big data information from device (packet content: None)
-  SET_PARAMETERS = 0x5C01,  // Set parameters of the device and device return parameters (packet content: parameter ID1
-                            // + parameter data1 + parameter ID2 + parameter data 2 + ...)
-  SET_SINGLE_PARAMETER = 0x5D00,  // Set single parameter (0x5DXX second byte define parameter ID) and return all user
-                                  // data (packet content: ???)
-  SET_GROUP_PARAMETERS = 0x6001,  // Set group parameters to device (0x60XX second byte define parameter is group ID,
-                                  // the only group mentioned in document is 1) and return all user data (packet
-                                  // content: all values like in status packet)
-};
-
-}  // namespace hon_protocol
-}  // namespace haier
-}  // namespace esphome

esphome/components/haier/logger_handler.cpp

@@ -1,33 +0,0 @@
-#include "logger_handler.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace haier {
-
-void esphome_logger(haier_protocol::HaierLogLevel level, const char *tag, const char *message) {
-  switch (level) {
-    case haier_protocol::HaierLogLevel::LEVEL_ERROR:
-      esp_log_printf_(ESPHOME_LOG_LEVEL_ERROR, tag, __LINE__, "%s", message);
-      break;
-    case haier_protocol::HaierLogLevel::LEVEL_WARNING:
-      esp_log_printf_(ESPHOME_LOG_LEVEL_WARN, tag, __LINE__, "%s", message);
-      break;
-    case haier_protocol::HaierLogLevel::LEVEL_INFO:
-      esp_log_printf_(ESPHOME_LOG_LEVEL_INFO, tag, __LINE__, "%s", message);
-      break;
-    case haier_protocol::HaierLogLevel::LEVEL_DEBUG:
-      esp_log_printf_(ESPHOME_LOG_LEVEL_DEBUG, tag, __LINE__, "%s", message);
-      break;
-    case haier_protocol::HaierLogLevel::LEVEL_VERBOSE:
-      esp_log_printf_(ESPHOME_LOG_LEVEL_VERBOSE, tag, __LINE__, "%s", message);
-      break;
-    default:
-      // Just ignore everything else
-      break;
-  }
-}
-
-void init_haier_protocol_logging() { haier_protocol::set_log_handler(esphome::haier::esphome_logger); };
-
-}  // namespace haier
-}  // namespace esphome

esphome/components/haier/logger_handler.h

@@ -1,14 +0,0 @@
-#pragma once
-
-// HaierProtocol
-#include <utils/haier_log.h>
-
-namespace esphome {
-namespace haier {
-
-// This file is called in the code generated by python script
-// Do not use it directly!
-void init_haier_protocol_logging();
-
-}  // namespace haier
-}  // namespace esphome

esphome/components/haier/smartair2_climate.cpp

@@ -1,457 +0,0 @@
-#include <chrono>
-#include "esphome/components/climate/climate.h"
-#include "esphome/components/uart/uart.h"
-#include "smartair2_climate.h"
-#include "smartair2_packet.h"
-
-using namespace esphome::climate;
-using namespace esphome::uart;
-
-namespace esphome {
-namespace haier {
-
-static const char *const TAG = "haier.climate";
-
-Smartair2Climate::Smartair2Climate()
-    : last_status_message_(new uint8_t[sizeof(smartair2_protocol::HaierPacketControl)]) {
-  this->traits_.set_supported_presets({
-      climate::CLIMATE_PRESET_NONE,
-      climate::CLIMATE_PRESET_BOOST,
-      climate::CLIMATE_PRESET_COMFORT,
-  });
-}
-
-haier_protocol::HandlerError Smartair2Climate::status_handler_(uint8_t request_type, uint8_t message_type,
-                                                               const uint8_t *data, size_t data_size) {
-  haier_protocol::HandlerError result =
-      this->answer_preprocess_(request_type, (uint8_t) smartair2_protocol::FrameType::CONTROL, message_type,
-                               (uint8_t) smartair2_protocol::FrameType::STATUS, ProtocolPhases::UNKNOWN);
-  if (result == haier_protocol::HandlerError::HANDLER_OK) {
-    result = this->process_status_message_(data, data_size);
-    if (result != haier_protocol::HandlerError::HANDLER_OK) {
-      ESP_LOGW(TAG, "Error %d while parsing Status packet", (int) result);
-      this->set_phase_((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
-                                                                       : ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
-    } else {
-      if (data_size >= sizeof(smartair2_protocol::HaierPacketControl) + 2) {
-        memcpy(this->last_status_message_.get(), data + 2, sizeof(smartair2_protocol::HaierPacketControl));
-      } else {
-        ESP_LOGW(TAG, "Status packet too small: %d (should be >= %d)", data_size,
-                 sizeof(smartair2_protocol::HaierPacketControl));
-      }
-      if (this->protocol_phase_ == ProtocolPhases::WAITING_FIRST_STATUS_ANSWER) {
-        ESP_LOGI(TAG, "First HVAC status received");
-        this->set_phase_(ProtocolPhases::IDLE);
-      } else if (this->protocol_phase_ == ProtocolPhases::WAITING_STATUS_ANSWER) {
-        this->set_phase_(ProtocolPhases::IDLE);
-      } else if (this->protocol_phase_ == ProtocolPhases::WAITING_CONTROL_ANSWER) {
-        this->set_phase_(ProtocolPhases::IDLE);
-        this->set_force_send_control_(false);
-        if (this->hvac_settings_.valid)
-          this->hvac_settings_.reset();
-      }
-    }
-    return result;
-  } else {
-    this->set_phase_((this->protocol_phase_ >= ProtocolPhases::IDLE) ? ProtocolPhases::IDLE
-                                                                     : ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
-    return result;
-  }
-}
-
-void Smartair2Climate::set_answers_handlers() {
-  this->haier_protocol_.set_answer_handler(
-      (uint8_t) (smartair2_protocol::FrameType::CONTROL),
-      std::bind(&Smartair2Climate::status_handler_, this, std::placeholders::_1, std::placeholders::_2,
-                std::placeholders::_3, std::placeholders::_4));
-}
-
-void Smartair2Climate::dump_config() {
-  HaierClimateBase::dump_config();
-  ESP_LOGCONFIG(TAG, "  Protocol version: smartAir2");
-}
-
-void Smartair2Climate::process_phase(std::chrono::steady_clock::time_point now) {
-  switch (this->protocol_phase_) {
-    case ProtocolPhases::SENDING_INIT_1:
-      this->set_phase_(ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
-      break;
-    case ProtocolPhases::WAITING_ANSWER_INIT_1:
-    case ProtocolPhases::SENDING_INIT_2:
-    case ProtocolPhases::WAITING_ANSWER_INIT_2:
-    case ProtocolPhases::SENDING_ALARM_STATUS_REQUEST:
-    case ProtocolPhases::WAITING_ALARM_STATUS_ANSWER:
-      this->set_phase_(ProtocolPhases::SENDING_INIT_1);
-      break;
-    case ProtocolPhases::SENDING_UPDATE_SIGNAL_REQUEST:
-    case ProtocolPhases::WAITING_UPDATE_SIGNAL_ANSWER:
-    case ProtocolPhases::SENDING_SIGNAL_LEVEL:
-    case ProtocolPhases::WAITING_SIGNAL_LEVEL_ANSWER:
-      this->set_phase_(ProtocolPhases::IDLE);
-      break;
-    case ProtocolPhases::SENDING_FIRST_STATUS_REQUEST:
-      if (this->can_send_message() && this->is_protocol_initialisation_interval_exceded_(now)) {
-        static const haier_protocol::HaierMessage STATUS_REQUEST((uint8_t) smartair2_protocol::FrameType::CONTROL,
-                                                                 0x4D01);
-        this->send_message_(STATUS_REQUEST, false);
-        this->last_status_request_ = now;
-        this->set_phase_(ProtocolPhases::WAITING_FIRST_STATUS_ANSWER);
-      }
-      break;
-    case ProtocolPhases::SENDING_STATUS_REQUEST:
-      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
-        static const haier_protocol::HaierMessage STATUS_REQUEST((uint8_t) smartair2_protocol::FrameType::CONTROL,
-                                                                 0x4D01);
-        this->send_message_(STATUS_REQUEST, false);
-        this->last_status_request_ = now;
-        this->set_phase_(ProtocolPhases::WAITING_STATUS_ANSWER);
-      }
-      break;
-    case ProtocolPhases::SENDING_CONTROL:
-      if (this->first_control_attempt_) {
-        this->control_request_timestamp_ = now;
-        this->first_control_attempt_ = false;
-      }
-      if (this->is_control_message_timeout_exceeded_(now)) {
-        ESP_LOGW(TAG, "Sending control packet timeout!");
-        this->set_force_send_control_(false);
-        if (this->hvac_settings_.valid)
-          this->hvac_settings_.reset();
-        this->forced_request_status_ = true;
-        this->forced_publish_ = true;
-        this->set_phase_(ProtocolPhases::IDLE);
-      } else if (this->can_send_message() && this->is_control_message_interval_exceeded_(
-                                                 now))  // Using CONTROL_MESSAGES_INTERVAL_MS to speedup requests
-      {
-        haier_protocol::HaierMessage control_message = get_control_message();
-        this->send_message_(control_message, false);
-        ESP_LOGI(TAG, "Control packet sent");
-        this->set_phase_(ProtocolPhases::WAITING_CONTROL_ANSWER);
-      }
-      break;
-    case ProtocolPhases::SENDING_POWER_ON_COMMAND:
-    case ProtocolPhases::SENDING_POWER_OFF_COMMAND:
-      if (this->can_send_message() && this->is_message_interval_exceeded_(now)) {
-        haier_protocol::HaierMessage power_cmd(
-            (uint8_t) smartair2_protocol::FrameType::CONTROL,
-            this->protocol_phase_ == ProtocolPhases::SENDING_POWER_ON_COMMAND ? 0x4D02 : 0x4D03);
-        this->send_message_(power_cmd, false);
-        this->set_phase_(this->protocol_phase_ == ProtocolPhases::SENDING_POWER_ON_COMMAND
-                             ? ProtocolPhases::WAITING_POWER_ON_ANSWER
-                             : ProtocolPhases::WAITING_POWER_OFF_ANSWER);
-      }
-      break;
-    case ProtocolPhases::WAITING_FIRST_STATUS_ANSWER:
-    case ProtocolPhases::WAITING_STATUS_ANSWER:
-    case ProtocolPhases::WAITING_CONTROL_ANSWER:
-    case ProtocolPhases::WAITING_POWER_ON_ANSWER:
-    case ProtocolPhases::WAITING_POWER_OFF_ANSWER:
-      break;
-    case ProtocolPhases::IDLE: {
-      if (this->forced_request_status_ || this->is_status_request_interval_exceeded_(now)) {
-        this->set_phase_(ProtocolPhases::SENDING_STATUS_REQUEST);
-        this->forced_request_status_ = false;
-      }
-    } break;
-    default:
-      // Shouldn't get here
-      ESP_LOGE(TAG, "Wrong protocol handler state: %d, resetting communication", (int) this->protocol_phase_);
-      this->set_phase_(ProtocolPhases::SENDING_FIRST_STATUS_REQUEST);
-      break;
-  }
-}
-
-haier_protocol::HaierMessage Smartair2Climate::get_control_message() {
-  uint8_t control_out_buffer[sizeof(smartair2_protocol::HaierPacketControl)];
-  memcpy(control_out_buffer, this->last_status_message_.get(), sizeof(smartair2_protocol::HaierPacketControl));
-  smartair2_protocol::HaierPacketControl *out_data = (smartair2_protocol::HaierPacketControl *) control_out_buffer;
-  out_data->cntrl = 0;
-  if (this->hvac_settings_.valid) {
-    HvacSettings climate_control;
-    climate_control = this->hvac_settings_;
-    if (climate_control.mode.has_value()) {
-      switch (climate_control.mode.value()) {
-        case CLIMATE_MODE_OFF:
-          out_data->ac_power = 0;
-          break;
-
-        case CLIMATE_MODE_AUTO:
-          out_data->ac_power = 1;
-          out_data->ac_mode = (uint8_t) smartair2_protocol::ConditioningMode::AUTO;
-          out_data->fan_mode = this->other_modes_fan_speed_;
-          break;
-
-        case CLIMATE_MODE_HEAT:
-          out_data->ac_power = 1;
-          out_data->ac_mode = (uint8_t) smartair2_protocol::ConditioningMode::HEAT;
-          out_data->fan_mode = this->other_modes_fan_speed_;
-          break;
-
-        case CLIMATE_MODE_DRY:
-          out_data->ac_power = 1;
-          out_data->ac_mode = (uint8_t) smartair2_protocol::ConditioningMode::DRY;
-          out_data->fan_mode = this->other_modes_fan_speed_;
-          break;
-
-        case CLIMATE_MODE_FAN_ONLY:
-          out_data->ac_power = 1;
-          out_data->ac_mode = (uint8_t) smartair2_protocol::ConditioningMode::FAN;
-          out_data->fan_mode = this->fan_mode_speed_;  // Auto doesn't work in fan only mode
-          break;
-
-        case CLIMATE_MODE_COOL:
-          out_data->ac_power = 1;
-          out_data->ac_mode = (uint8_t) smartair2_protocol::ConditioningMode::COOL;
-          out_data->fan_mode = this->other_modes_fan_speed_;
-          break;
-        default:
-          ESP_LOGE("Control", "Unsupported climate mode");
-          break;
-      }
-    }
-    // Set fan speed, if we are in fan mode, reject auto in fan mode
-    if (climate_control.fan_mode.has_value()) {
-      switch (climate_control.fan_mode.value()) {
-        case CLIMATE_FAN_LOW:
-          out_data->fan_mode = (uint8_t) smartair2_protocol::FanMode::FAN_LOW;
-          break;
-        case CLIMATE_FAN_MEDIUM:
-          out_data->fan_mode = (uint8_t) smartair2_protocol::FanMode::FAN_MID;
-          break;
-        case CLIMATE_FAN_HIGH:
-          out_data->fan_mode = (uint8_t) smartair2_protocol::FanMode::FAN_HIGH;
-          break;
-        case CLIMATE_FAN_AUTO:
-          if (this->mode != CLIMATE_MODE_FAN_ONLY)  // if we are not in fan only mode
-            out_data->fan_mode = (uint8_t) smartair2_protocol::FanMode::FAN_AUTO;
-          break;
-        default:
-          ESP_LOGE("Control", "Unsupported fan mode");
-          break;
-      }
-    }
-    // Set swing mode
-    if (climate_control.swing_mode.has_value()) {
-      switch (climate_control.swing_mode.value()) {
-        case CLIMATE_SWING_OFF:
-          out_data->use_swing_bits = 0;
-          out_data->swing_both = 0;
-          break;
-        case CLIMATE_SWING_VERTICAL:
-          out_data->swing_both = 0;
-          out_data->vertical_swing = 1;
-          out_data->horizontal_swing = 0;
-          break;
-        case CLIMATE_SWING_HORIZONTAL:
-          out_data->swing_both = 0;
-          out_data->vertical_swing = 0;
-          out_data->horizontal_swing = 1;
-          break;
-        case CLIMATE_SWING_BOTH:
-          out_data->swing_both = 1;
-          out_data->use_swing_bits = 0;
-          out_data->vertical_swing = 0;
-          out_data->horizontal_swing = 0;
-          break;
-      }
-    }
-    if (climate_control.target_temperature.has_value()) {
-      out_data->set_point =
-          climate_control.target_temperature.value() - 16;  // set the temperature at our offset, subtract 16.
-    }
-    if (out_data->ac_power == 0) {
-      // If AC is off - no presets alowed
-      out_data->turbo_mode = 0;
-      out_data->quiet_mode = 0;
-    } else if (climate_control.preset.has_value()) {
-      switch (climate_control.preset.value()) {
-        case CLIMATE_PRESET_NONE:
-          out_data->turbo_mode = 0;
-          out_data->quiet_mode = 0;
-          break;
-        case CLIMATE_PRESET_BOOST:
-          out_data->turbo_mode = 1;
-          out_data->quiet_mode = 0;
-          break;
-        case CLIMATE_PRESET_COMFORT:
-          out_data->turbo_mode = 0;
-          out_data->quiet_mode = 1;
-          break;
-        default:
-          ESP_LOGE("Control", "Unsupported preset");
-          out_data->turbo_mode = 0;
-          out_data->quiet_mode = 0;
-          break;
-      }
-    }
-  }
-  out_data->display_status = this->display_status_ ? 0 : 1;
-  out_data->health_mode = this->health_mode_ ? 1 : 0;
-  return haier_protocol::HaierMessage((uint8_t) smartair2_protocol::FrameType::CONTROL, 0x4D5F, control_out_buffer,
-                                      sizeof(smartair2_protocol::HaierPacketControl));
-}
-
-haier_protocol::HandlerError Smartair2Climate::process_status_message_(const uint8_t *packet_buffer, uint8_t size) {
-  if (size < sizeof(smartair2_protocol::HaierStatus))
-    return haier_protocol::HandlerError::WRONG_MESSAGE_STRUCTURE;
-  smartair2_protocol::HaierStatus packet;
-  memcpy(&packet, packet_buffer, size);
-  bool should_publish = false;
-  {
-    // Extra modes/presets
-    optional<ClimatePreset> old_preset = this->preset;
-    if (packet.control.turbo_mode != 0) {
-      this->preset = CLIMATE_PRESET_BOOST;
-    } else if (packet.control.quiet_mode != 0) {
-      this->preset = CLIMATE_PRESET_COMFORT;
-    } else {
-      this->preset = CLIMATE_PRESET_NONE;
-    }
-    should_publish = should_publish || (!old_preset.has_value()) || (old_preset.value() != this->preset.value());
-  }
-  {
-    // Target temperature
-    float old_target_temperature = this->target_temperature;
-    this->target_temperature = packet.control.set_point + 16.0f;
-    should_publish = should_publish || (old_target_temperature != this->target_temperature);
-  }
-  {
-    // Current temperature
-    float old_current_temperature = this->current_temperature;
-    this->current_temperature = packet.control.room_temperature;
-    should_publish = should_publish || (old_current_temperature != this->current_temperature);
-  }
-  {
-    // Fan mode
-    optional<ClimateFanMode> old_fan_mode = this->fan_mode;
-    // remember the fan speed we last had for climate vs fan
-    if (packet.control.ac_mode == (uint8_t) smartair2_protocol::ConditioningMode::FAN) {
-      if (packet.control.fan_mode != (uint8_t) smartair2_protocol::FanMode::FAN_AUTO)
-        this->fan_mode_speed_ = packet.control.fan_mode;
-    } else {
-      this->other_modes_fan_speed_ = packet.control.fan_mode;
-    }
-    switch (packet.control.fan_mode) {
-      case (uint8_t) smartair2_protocol::FanMode::FAN_AUTO:
-        // Somtimes AC reports in fan only mode that fan speed is auto
-        // but never accept this value back
-        if (packet.control.ac_mode != (uint8_t) smartair2_protocol::ConditioningMode::FAN) {
-          this->fan_mode = CLIMATE_FAN_AUTO;
-        } else {
-          should_publish = true;
-        }
-        break;
-      case (uint8_t) smartair2_protocol::FanMode::FAN_MID:
-        this->fan_mode = CLIMATE_FAN_MEDIUM;
-        break;
-      case (uint8_t) smartair2_protocol::FanMode::FAN_LOW:
-        this->fan_mode = CLIMATE_FAN_LOW;
-        break;
-      case (uint8_t) smartair2_protocol::FanMode::FAN_HIGH:
-        this->fan_mode = CLIMATE_FAN_HIGH;
-        break;
-    }
-    should_publish = should_publish || (!old_fan_mode.has_value()) || (old_fan_mode.value() != fan_mode.value());
-  }
-  {
-    // Display status
-    // should be before "Climate mode" because it is changing this->mode
-    if (packet.control.ac_power != 0) {
-      // if AC is off display status always ON so process it only when AC is on
-      bool disp_status = packet.control.display_status == 0;
-      if (disp_status != this->display_status_) {
-        // Do something only if display status changed
-        if (this->mode == CLIMATE_MODE_OFF) {
-          // AC just turned on from remote need to turn off display
-          this->set_force_send_control_(true);
-        } else {
-          this->display_status_ = disp_status;
-        }
-      }
-    }
-  }
-  {
-    // Climate mode
-    ClimateMode old_mode = this->mode;
-    if (packet.control.ac_power == 0) {
-      this->mode = CLIMATE_MODE_OFF;
-    } else {
-      // Check current hvac mode
-      switch (packet.control.ac_mode) {
-        case (uint8_t) smartair2_protocol::ConditioningMode::COOL:
-          this->mode = CLIMATE_MODE_COOL;
-          break;
-        case (uint8_t) smartair2_protocol::ConditioningMode::HEAT:
-          this->mode = CLIMATE_MODE_HEAT;
-          break;
-        case (uint8_t) smartair2_protocol::ConditioningMode::DRY:
-          this->mode = CLIMATE_MODE_DRY;
-          break;
-        case (uint8_t) smartair2_protocol::ConditioningMode::FAN:
-          this->mode = CLIMATE_MODE_FAN_ONLY;
-          break;
-        case (uint8_t) smartair2_protocol::ConditioningMode::AUTO:
-          this->mode = CLIMATE_MODE_AUTO;
-          break;
-      }
-    }
-    should_publish = should_publish || (old_mode != this->mode);
-  }
-  {
-    // Health mode
-    bool old_health_mode = this->health_mode_;
-    this->health_mode_ = packet.control.health_mode == 1;
-    should_publish = should_publish || (old_health_mode != this->health_mode_);
-  }
-  {
-    // Swing mode
-    ClimateSwingMode old_swing_mode = this->swing_mode;
-    if (packet.control.swing_both == 0) {
-      if (packet.control.vertical_swing != 0) {
-        this->swing_mode = CLIMATE_SWING_VERTICAL;
-      } else if (packet.control.horizontal_swing != 0) {
-        this->swing_mode = CLIMATE_SWING_HORIZONTAL;
-      } else {
-        this->swing_mode = CLIMATE_SWING_OFF;
-      }
-    } else {
-      swing_mode = CLIMATE_SWING_BOTH;
-    }
-    should_publish = should_publish || (old_swing_mode != this->swing_mode);
-  }
-  this->last_valid_status_timestamp_ = std::chrono::steady_clock::now();
-  if (this->forced_publish_ || should_publish) {
-#if (HAIER_LOG_LEVEL > 4)
-    std::chrono::high_resolution_clock::time_point _publish_start = std::chrono::high_resolution_clock::now();
-#endif
-    this->publish_state();
-#if (HAIER_LOG_LEVEL > 4)
-    ESP_LOGV(TAG, "Publish delay: %lld ms",
-             std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() -
-                                                                   _publish_start)
-                 .count());
-#endif
-    this->forced_publish_ = false;
-  }
-  if (should_publish) {
-    ESP_LOGI(TAG, "HVAC values changed");
-  }
-  esp_log_printf_((should_publish ? ESPHOME_LOG_LEVEL_INFO : ESPHOME_LOG_LEVEL_DEBUG), TAG, __LINE__,
-                  "HVAC Mode = 0x%X", packet.control.ac_mode);
-  esp_log_printf_((should_publish ? ESPHOME_LOG_LEVEL_INFO : ESPHOME_LOG_LEVEL_DEBUG), TAG, __LINE__,
-                  "Fan speed Status = 0x%X", packet.control.fan_mode);
-  esp_log_printf_((should_publish ? ESPHOME_LOG_LEVEL_INFO : ESPHOME_LOG_LEVEL_DEBUG), TAG, __LINE__,
-                  "Horizontal Swing Status = 0x%X", packet.control.horizontal_swing);
-  esp_log_printf_((should_publish ? ESPHOME_LOG_LEVEL_INFO : ESPHOME_LOG_LEVEL_DEBUG), TAG, __LINE__,
-                  "Vertical Swing Status = 0x%X", packet.control.vertical_swing);
-  esp_log_printf_((should_publish ? ESPHOME_LOG_LEVEL_INFO : ESPHOME_LOG_LEVEL_DEBUG), TAG, __LINE__,
-                  "Set Point Status = 0x%X", packet.control.set_point);
-  return haier_protocol::HandlerError::HANDLER_OK;
-}
-
-bool Smartair2Climate::is_message_invalid(uint8_t message_type) {
-  return message_type == (uint8_t) smartair2_protocol::FrameType::INVALID;
-}
-
-}  // namespace haier
-}  // namespace esphome

esphome/components/haier/smartair2_climate.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <chrono>
-#include "haier_base.h"
-
-namespace esphome {
-namespace haier {
-
-class Smartair2Climate : public HaierClimateBase {
- public:
-  Smartair2Climate();
-  Smartair2Climate(const Smartair2Climate &) = delete;
-  Smartair2Climate &operator=(const Smartair2Climate &) = delete;
-  ~Smartair2Climate();
-  void dump_config() override;
-
- protected:
-  void set_answers_handlers() override;
-  void process_phase(std::chrono::steady_clock::time_point now) override;
-  haier_protocol::HaierMessage get_control_message() override;
-  bool is_message_invalid(uint8_t message_type) override;
-  // Answers handlers
-  haier_protocol::HandlerError status_handler_(uint8_t request_type, uint8_t message_type, const uint8_t *data,
-                                               size_t data_size);
-  // Helper functions
-  haier_protocol::HandlerError process_status_message_(const uint8_t *packet, uint8_t size);
-  std::unique_ptr<uint8_t[]> last_status_message_;
-};
-
-}  // namespace haier
-}  // namespace esphome

esphome/components/haier/smartair2_packet.h

@@ -1,97 +0,0 @@
-#pragma once
-
-namespace esphome {
-namespace haier {
-namespace smartair2_protocol {
-
-enum class ConditioningMode : uint8_t { AUTO = 0x00, COOL = 0x01, HEAT = 0x02, FAN = 0x03, DRY = 0x04 };
-
-enum class FanMode : uint8_t { FAN_HIGH = 0x00, FAN_MID = 0x01, FAN_LOW = 0x02, FAN_AUTO = 0x03 };
-
-struct HaierPacketControl {
-  // Control bytes starts here
-  // 10
-  uint8_t : 8;  // Temperature high byte
-  // 11
-  uint8_t room_temperature;  // current room temperature 1°C step
-  // 12
-  uint8_t : 8;  // Humidity high byte
-  // 13
-  uint8_t room_humidity;  // Humidity 0%-100% with 1% step
-  // 14
-  uint8_t : 8;
-  // 15
-  uint8_t cntrl;  // In AC => ESP packets - 0x7F, in ESP => AC packets - 0x00
-  // 16
-  uint8_t : 8;
-  // 17
-  uint8_t : 8;
-  // 18
-  uint8_t : 8;
-  // 19
-  uint8_t : 8;
-  // 20
-  uint8_t : 8;
-  // 21
-  uint8_t ac_mode;  // See enum ConditioningMode
-  // 22
-  uint8_t : 8;
-  // 23
-  uint8_t fan_mode;  // See enum FanMode
-  // 24
-  uint8_t : 8;
-  // 25
-  uint8_t swing_both;  // If 1 - swing both direction, if 0 - horizontal_swing and vertical_swing define
-                       // vertical/horizontal/off
-  // 26
-  uint8_t : 3;
-  uint8_t use_fahrenheit : 1;
-  uint8_t : 3;
-  uint8_t lock_remote : 1;  // Disable remote
-  // 27
-  uint8_t ac_power : 1;  // Is ac on or off
-  uint8_t : 2;
-  uint8_t health_mode : 1;  // Health mode on or off
-  uint8_t compressor : 1;   // Compressor on or off ???
-  uint8_t : 1;
-  uint8_t ten_degree : 1;  // 10 degree status (only work in heat mode)
-  uint8_t : 0;
-  // 28
-  uint8_t : 8;
-  // 29
-  uint8_t use_swing_bits : 1;    // Indicate if horizontal_swing and vertical_swing should be used
-  uint8_t turbo_mode : 1;        // Turbo mode
-  uint8_t quiet_mode : 1;        // Sleep mode
-  uint8_t horizontal_swing : 1;  // Horizontal swing (if swing_both == 0)
-  uint8_t vertical_swing : 1;    // Vertical swing (if swing_both == 0) if vertical_swing and horizontal_swing both 0 =>
-                                 // swing off
-  uint8_t display_status : 1;    // Led on or off
-  uint8_t : 0;
-  // 30
-  uint8_t : 8;
-  // 31
-  uint8_t : 8;
-  // 32
-  uint8_t : 8;  // Target temperature high byte
-  // 33
-  uint8_t set_point;  // Target temperature with 16°C offset, 1°C step
-};
-
-struct HaierStatus {
-  uint16_t subcommand;
-  HaierPacketControl control;
-};
-
-enum class FrameType : uint8_t {
-  CONTROL = 0x01,
-  STATUS = 0x02,
-  INVALID = 0x03,
-  CONFIRM = 0x05,
-  GET_DEVICE_VERSION = 0x61,
-  REPORT_NETWORK_STATUS = 0xF7,
-  NO_COMMAND = 0xFF,
-};
-
-}  // namespace smartair2_protocol
-}  // namespace haier
-}  // namespace esphome

esphome/components/i2c/i2c.cpp

@@ -14,14 +14,6 @@ ErrorCode I2CDevice::read_register(uint8_t a_register, uint8_t *data, size_t len
   return bus_->read(address_, data, len);
 }
 
-ErrorCode I2CDevice::read_register16(uint16_t a_register, uint8_t *data, size_t len, bool stop) {
-  a_register = convert_big_endian(a_register);
-  ErrorCode const err = this->write(reinterpret_cast<const uint8_t *>(&a_register), 2, stop);
-  if (err != ERROR_OK)
-    return err;
-  return bus_->read(address_, data, len);
-}
-
 ErrorCode I2CDevice::write_register(uint8_t a_register, const uint8_t *data, size_t len, bool stop) {
   WriteBuffer buffers[2];
   buffers[0].data = &a_register;
@@ -31,16 +23,6 @@ ErrorCode I2CDevice::write_register(uint8_t a_register, const uint8_t *data, siz
   return bus_->writev(address_, buffers, 2, stop);
 }
 
-ErrorCode I2CDevice::write_register16(uint16_t a_register, const uint8_t *data, size_t len, bool stop) {
-  a_register = convert_big_endian(a_register);
-  WriteBuffer buffers[2];
-  buffers[0].data = reinterpret_cast<const uint8_t *>(&a_register);
-  buffers[0].len = 2;
-  buffers[1].data = data;
-  buffers[1].len = len;
-  return bus_->writev(address_, buffers, 2, stop);
-}
-
 bool I2CDevice::read_bytes_16(uint8_t a_register, uint16_t *data, uint8_t len) {
   if (read_register(a_register, reinterpret_cast<uint8_t *>(data), len * 2) != ERROR_OK)
     return false;
@@ -78,26 +60,5 @@ uint8_t I2CRegister::get() const {
   return value;
 }
 
-I2CRegister16 &I2CRegister16::operator=(uint8_t value) {
-  this->parent_->write_register16(this->register_, &value, 1);
-  return *this;
-}
-I2CRegister16 &I2CRegister16::operator&=(uint8_t value) {
-  value &= get();
-  this->parent_->write_register16(this->register_, &value, 1);
-  return *this;
-}
-I2CRegister16 &I2CRegister16::operator|=(uint8_t value) {
-  value |= get();
-  this->parent_->write_register16(this->register_, &value, 1);
-  return *this;
-}
-
-uint8_t I2CRegister16::get() const {
-  uint8_t value = 0x00;
-  this->parent_->read_register16(this->register_, &value, 1);
-  return value;
-}
-
 }  // namespace i2c
 }  // namespace esphome

esphome/components/i2c/i2c.h

@@ -31,25 +31,6 @@ class I2CRegister {
   uint8_t register_;
 };
 
-class I2CRegister16 {
- public:
-  I2CRegister16 &operator=(uint8_t value);
-  I2CRegister16 &operator&=(uint8_t value);
-  I2CRegister16 &operator|=(uint8_t value);
-
-  explicit operator uint8_t() const { return get(); }
-
-  uint8_t get() const;
-
- protected:
-  friend class I2CDevice;
-
-  I2CRegister16(I2CDevice *parent, uint16_t a_register) : parent_(parent), register_(a_register) {}
-
-  I2CDevice *parent_;
-  uint16_t register_;
-};
-
 // like ntohs/htons but without including networking headers.
 // ("i2c" byte order is big-endian)
 inline uint16_t i2ctohs(uint16_t i2cshort) { return convert_big_endian(i2cshort); }
@@ -63,15 +44,12 @@ class I2CDevice {
   void set_i2c_bus(I2CBus *bus) { bus_ = bus; }
 
   I2CRegister reg(uint8_t a_register) { return {this, a_register}; }
-  I2CRegister16 reg16(uint16_t a_register) { return {this, a_register}; }
 
   ErrorCode read(uint8_t *data, size_t len) { return bus_->read(address_, data, len); }
   ErrorCode read_register(uint8_t a_register, uint8_t *data, size_t len, bool stop = true);
-  ErrorCode read_register16(uint16_t a_register, uint8_t *data, size_t len, bool stop = true);
 
   ErrorCode write(const uint8_t *data, uint8_t len, bool stop = true) { return bus_->write(address_, data, len, stop); }
   ErrorCode write_register(uint8_t a_register, const uint8_t *data, size_t len, bool stop = true);
-  ErrorCode write_register16(uint16_t a_register, const uint8_t *data, size_t len, bool stop = true);
 
   // Compat APIs
 

esphome/components/image/__init__.py

@@ -6,7 +6,7 @@ import re
 import requests
 
 from esphome import core
-from esphome.components import font
+from esphome.components import display, font
 import esphome.config_validation as cv
 import esphome.codegen as cg
 from esphome.const import (
@@ -28,9 +28,7 @@ DOMAIN = "image"
 DEPENDENCIES = ["display"]
 MULTI_CONF = True
 
-image_ns = cg.esphome_ns.namespace("image")
-
-ImageType = image_ns.enum("ImageType")
+ImageType = display.display_ns.enum("ImageType")
 IMAGE_TYPE = {
     "BINARY": ImageType.IMAGE_TYPE_BINARY,
     "TRANSPARENT_BINARY": ImageType.IMAGE_TYPE_BINARY,
@@ -48,7 +46,7 @@ MDI_DOWNLOAD_TIMEOUT = 30  # seconds
 SOURCE_LOCAL = "local"
 SOURCE_MDI = "mdi"
 
-Image_ = image_ns.class_("Image")
+Image_ = display.display_ns.class_("Image")
 
 
 def _compute_local_icon_path(value) -> Path:

esphome/components/mqtt/mqtt_backend_idf.cpp

@@ -11,7 +11,6 @@ namespace mqtt {
 static const char *const TAG = "mqtt.idf";
 
 bool MQTTBackendIDF::initialize_() {
-#if ESP_IDF_VERSION_MAJOR < 5
   mqtt_cfg_.user_context = (void *) this;
   mqtt_cfg_.buffer_size = MQTT_BUFFER_SIZE;
 
@@ -48,41 +47,6 @@ bool MQTTBackendIDF::initialize_() {
   } else {
     mqtt_cfg_.transport = MQTT_TRANSPORT_OVER_TCP;
   }
-#else
-  mqtt_cfg_.broker.address.hostname = this->host_.c_str();
-  mqtt_cfg_.broker.address.port = this->port_;
-  mqtt_cfg_.session.keepalive = this->keep_alive_;
-  mqtt_cfg_.session.disable_clean_session = !this->clean_session_;
-
-  if (!this->username_.empty()) {
-    mqtt_cfg_.credentials.username = this->username_.c_str();
-    if (!this->password_.empty()) {
-      mqtt_cfg_.credentials.authentication.password = this->password_.c_str();
-    }
-  }
-
-  if (!this->lwt_topic_.empty()) {
-    mqtt_cfg_.session.last_will.topic = this->lwt_topic_.c_str();
-    this->mqtt_cfg_.session.last_will.qos = this->lwt_qos_;
-    this->mqtt_cfg_.session.last_will.retain = this->lwt_retain_;
-
-    if (!this->lwt_message_.empty()) {
-      mqtt_cfg_.session.last_will.msg = this->lwt_message_.c_str();
-      mqtt_cfg_.session.last_will.msg_len = this->lwt_message_.size();
-    }
-  }
-
-  if (!this->client_id_.empty()) {
-    mqtt_cfg_.credentials.client_id = this->client_id_.c_str();
-  }
-  if (ca_certificate_.has_value()) {
-    mqtt_cfg_.broker.verification.certificate = ca_certificate_.value().c_str();
-    mqtt_cfg_.broker.verification.skip_cert_common_name_check = skip_cert_cn_check_;
-    mqtt_cfg_.broker.address.transport = MQTT_TRANSPORT_OVER_SSL;
-  } else {
-    mqtt_cfg_.broker.address.transport = MQTT_TRANSPORT_OVER_TCP;
-  }
-#endif
   auto *mqtt_client = esp_mqtt_client_init(&mqtt_cfg_);
   if (mqtt_client) {
     handler_.reset(mqtt_client);
@@ -114,8 +78,9 @@ void MQTTBackendIDF::mqtt_event_handler_(const Event &event) {
 
     case MQTT_EVENT_CONNECTED:
       ESP_LOGV(TAG, "MQTT_EVENT_CONNECTED");
+      // TODO session present check
       this->is_connected_ = true;
-      this->on_connect_.call(event.session_present);
+      this->on_connect_.call(!mqtt_cfg_.disable_clean_session);
       break;
     case MQTT_EVENT_DISCONNECTED:
       ESP_LOGV(TAG, "MQTT_EVENT_DISCONNECTED");

esphome/components/mqtt/mqtt_backend_idf.h

@@ -22,7 +22,6 @@ struct Event {
   bool retain;
   int qos;
   bool dup;
-  bool session_present;
   esp_mqtt_error_codes_t error_handle;
 
   // Construct from esp_mqtt_event_t
@@ -37,7 +36,6 @@ struct Event {
         retain(event.retain),
         qos(event.qos),
         dup(event.dup),
-        session_present(event.session_present),
         error_handle(*event.error_handle) {}
 };
 

esphome/components/mqtt/mqtt_component.cpp

@@ -118,7 +118,7 @@ bool MQTTComponent::send_discovery_() {
         } else {
           if (discovery_info.unique_id_generator == MQTT_MAC_ADDRESS_UNIQUE_ID_GENERATOR) {
             char friendly_name_hash[9];
-            sprintf(friendly_name_hash, "%08" PRIx32, fnv1_hash(this->friendly_name()));
+            sprintf(friendly_name_hash, "%08x", fnv1_hash(this->friendly_name()));
             friendly_name_hash[8] = 0;  // ensure the hash-string ends with null
             root[MQTT_UNIQUE_ID] = get_mac_address() + "-" + this->component_type() + "-" + friendly_name_hash;
           } else {

esphome/components/mqtt/mqtt_sensor.cpp

@@ -1,4 +1,3 @@
-#include <cinttypes>
 #include "mqtt_sensor.h"
 #include "esphome/core/log.h"
 
@@ -27,7 +26,7 @@ void MQTTSensorComponent::setup() {
 void MQTTSensorComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Sensor '%s':", this->sensor_->get_name().c_str());
   if (this->get_expire_after() > 0) {
-    ESP_LOGCONFIG(TAG, "  Expire After: %" PRIu32 "s", this->get_expire_after() / 1000);
+    ESP_LOGCONFIG(TAG, "  Expire After: %us", this->get_expire_after() / 1000);
   }
   LOG_MQTT_COMPONENT(true, false)
 }

esphome/components/socket/__init__.py

@@ -1,6 +1,5 @@
 import esphome.config_validation as cv
 import esphome.codegen as cg
-from esphome.core import CORE
 
 CODEOWNERS = ["@esphome/core"]
 
@@ -29,6 +28,3 @@ async def to_code(config):
         cg.add_define("USE_SOCKET_IMPL_LWIP_TCP")
     elif impl == IMPLEMENTATION_BSD_SOCKETS:
         cg.add_define("USE_SOCKET_IMPL_BSD_SOCKETS")
-
-    if CORE.target_platform in ["esp8266", "esp32"]:
-        cg.add_define("USE_SOCKET_HAS_LWIP")

esphome/components/socket/bsd_sockets_impl.cpp

@@ -53,43 +53,6 @@ class BSDSocketImpl : public Socket {
     return make_unique<BSDSocketImpl>(fd);
   }
   int bind(const struct sockaddr *addr, socklen_t addrlen) override { return ::bind(fd_, addr, addrlen); }
-  int connect(const struct sockaddr *addr, socklen_t addrlen) override { return ::connect(fd_, addr, addrlen); }
-  int connect_finished() override {
-    fd_set wfds;
-    struct timeval tv;
-    FD_ZERO(&wfds);
-    FD_SET(fd_, &wfds);
-    tv.tv_sec = 0;
-    tv.tv_usec = 0;
-    int retval = ::select(fd_ + 1, nullptr, &wfds, nullptr, &tv);
-    if (retval == -1) {
-      // reuse errno
-      return -1;
-    }
-    if (retval == 0) {
-      // timeout, not writable yet
-      errno = EINPROGRESS;
-      return -1;
-    }
-    if (!FD_ISSET(fd_, &wfds)) {
-      errno = ECONNREFUSED;
-      return -1;
-    }
-
-    int so_error;
-    socklen_t len = sizeof(so_error);
-    int ret = this->getsockopt(SOL_SOCKET, SO_ERROR, &so_error, &len);
-    if (ret == -1) {
-      // reuse errno
-      return -1;
-    }
-    if (so_error == 0) {
-      return 0;
-    }
-    errno = ECONNREFUSED;
-    return -1;
-  }
-
   int close() override {
     int ret = ::close(fd_);
     closed_ = true;

esphome/components/socket/getaddrinfo.h

@@ -1,34 +0,0 @@
-#pragma once
-#include <memory>
-#include "headers.h"
-
-namespace esphome {
-namespace socket {
-
-struct GetaddrinfoFuture {
- public:
-  virtual ~GetaddrinfoFuture() = default;
-  // returns true when the request has completed (successfully or with an error)
-  virtual bool completed() = 0;
-  /**
-   * @brief Fetch the completed result into res.
-   *
-   * Should only be called after completed() returned true.
-   * Make sure to call freeaddrinfo() to free the addrinfo storage
-   * when it's no longer needed.
-   *
-   * @return See posix getaddrinfo() return values.
-   */
-  virtual int fetch_result(struct addrinfo **res) = 0;
-};
-
-std::unique_ptr<GetaddrinfoFuture> getaddrinfo_async(const char *node, const char *service,
-                                                     const struct addrinfo *hints);
-
-}  // namespace socket
-}  // namespace esphome
-
-#ifdef USE_ESP8266
-void freeaddrinfo(struct addrinfo *ai);
-const char *gai_strerror(int errcode);
-#endif

esphome/components/socket/headers.h

@@ -8,7 +8,6 @@
 
 #define LWIP_INTERNAL
 #include "lwip/inet.h"
-#include "lwip/netdb.h"
 #include <cerrno>
 #include <cstdint>
 #include <sys/types.h>
@@ -119,34 +118,6 @@ struct iovec {
 #define ESPHOME_INADDR_NONE INADDR_NONE
 #endif
 
-#ifndef EAI_FAIL
-#define EAI_BADFLAGS (-1)
-#define EAI_NONAME (-2)
-#define EAI_AGAIN (-3)
-#define EAI_FAIL (-4)
-#define EAI_FAMILY (-6)
-#define EAI_SOCKTYPE (-7)
-#define EAI_SERVICE (-8)
-#define EAI_MEMORY (-10)
-#define EAI_SYSTEM (-11)
-#define EAI_OVERFLOW (-12)
-#endif  // !EAI_FAIL
-
-#ifndef IPPROTO_UDP
-#define IPPROTO_UDP 17
-#endif
-
-struct addrinfo {  // NOLINT(readability-identifier-naming)
-  int ai_flags;
-  int ai_family;
-  int ai_socktype;
-  int ai_protocol;
-  socklen_t ai_addrlen;
-  struct sockaddr *ai_addr;
-  char *ai_canonname;
-  struct addrinfo *ai_next;
-};
-
 #endif  // USE_SOCKET_IMPL_LWIP_TCP
 
 #ifdef USE_SOCKET_IMPL_BSD_SOCKETS
@@ -158,7 +129,6 @@ struct addrinfo {  // NOLINT(readability-identifier-naming)
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <unistd.h>
-#include <netdb.h>
 
 #ifdef USE_HOST
 #include <arpa/inet.h>

esphome/components/socket/lwip_getaddrinfo_impl.cpp

@@ -1,197 +0,0 @@
-#include "getaddrinfo.h"
-#include "esphome/core/defines.h"
-
-#ifdef USE_SOCKET_HAS_LWIP
-
-#include <utility>
-#include "lwip/dns.h"
-#include "lwip/ip_addr.h"
-#include "lwip/netdb.h"
-
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace socket {
-
-static const char *const TAG = "socket.lwipgetaddrinfo";
-
-struct LwipDNSResult {
-  bool completed;
-  bool error;
-  ip_addr_t ipaddr;
-};
-
-struct LwipDNSCallbackArg {
-  std::weak_ptr<LwipDNSResult> res;
-};
-
-void lwip_dns_callback(const char *name, const ip_addr_t *ipaddr, void *callback_arg) {
-  LwipDNSCallbackArg *arg = reinterpret_cast<LwipDNSCallbackArg *>(callback_arg);
-  {
-    std::shared_ptr<LwipDNSResult> result = arg->res.lock();
-    if (result) {
-      if (ipaddr == nullptr) {
-        result->error = true;
-      } else {
-        result->error = false;
-        ip_addr_copy(result->ipaddr, *ipaddr);
-      }
-      result->completed = true;
-    }
-  }
-  delete arg;  // NOLINT(cppcoreguidelines-owning-memory)
-}
-
-class LwipGetaddrinfoFuture : public GetaddrinfoFuture {
- public:
-  LwipGetaddrinfoFuture(std::shared_ptr<LwipDNSResult> result, int hint_ai_socktype, int hint_ai_protocol,
-                        uint16_t portno)
-      : result_(std::move(result)),
-        hint_ai_socktype_(hint_ai_socktype),
-        hint_ai_protocol_(hint_ai_protocol),
-        portno_(portno) {}
-  ~LwipGetaddrinfoFuture() override = default;
-
-  bool completed() override { return result_->completed; }
-  int fetch_result(struct addrinfo **res) override {
-    if (res == nullptr)
-      return EAI_FAIL;
-    *res = nullptr;
-    if (!result_->completed)
-      return EAI_FAIL;
-    if (result_->error)
-      return EAI_FAIL;
-
-    size_t alloc_size = sizeof(struct addrinfo) + sizeof(struct sockaddr_storage);
-    // NOLINTNEXTLINE(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
-    void *storage = malloc(alloc_size);
-    memset(storage, 0, alloc_size);
-    struct addrinfo *ai = reinterpret_cast<struct addrinfo *>(storage);
-    struct sockaddr_storage *sa = reinterpret_cast<struct sockaddr_storage *>(ai + 1);
-
-    bool isipv6 = IP_IS_V6(result_->ipaddr);
-
-    bool istcp = true;
-    if ((hint_ai_socktype_ != 0 && hint_ai_socktype_ == SOCK_DGRAM) ||
-        (hint_ai_protocol_ != 0 && hint_ai_protocol_ == IPPROTO_UDP)) {
-      istcp = false;
-    }
-
-    ai->ai_family = isipv6 ? AF_INET6 : AF_INET;
-    ai->ai_socktype = istcp ? SOCK_STREAM : SOCK_DGRAM;
-    ai->ai_protocol = istcp ? IPPROTO_TCP : IPPROTO_UDP;
-
-    if (isipv6) {
-#if LWIP_IPV6
-      struct sockaddr_in6 *sa6 = reinterpret_cast<struct sockaddr_in6 *>(sa);
-      inet6_addr_from_ip6addr(&sa6->sin6_addr, ip_2_ip6(&result_->ipaddr)) sa6->sin6_family = AF_INET6;
-      sa6->sin6_len = sizeof(struct sockaddr_in6);
-      sa6->sin6_port = htons(portno_);
-#endif  // LWIP_IPV6
-    } else {
-      struct sockaddr_in *sa4 = reinterpret_cast<struct sockaddr_in *>(sa);
-      inet_addr_from_ip4addr(&sa4->sin_addr, ip_2_ip4(&result_->ipaddr));
-      sa4->sin_family = AF_INET;
-      sa4->sin_len = sizeof(struct sockaddr_in);
-      sa4->sin_port = htons(portno_);
-    }
-
-    ai->ai_addrlen = sizeof(struct sockaddr_storage);
-    ai->ai_addr = reinterpret_cast<struct sockaddr *>(sa);
-    *res = ai;
-    return 0;
-  }
-
- protected:
-  std::shared_ptr<LwipDNSResult> result_;
-  int hint_ai_socktype_;
-  int hint_ai_protocol_;
-  uint16_t portno_;
-};
-
-std::unique_ptr<GetaddrinfoFuture> getaddrinfo_async(const char *node, const char *service,
-                                                     const struct addrinfo *hints) {
-  std::shared_ptr<LwipDNSResult> result = std::make_shared<LwipDNSResult>();
-  result->completed = false;
-
-  uint16_t portno = 0;
-  if (service != nullptr) {
-    optional<uint16_t> i = parse_number<uint16_t>(service);
-    if (!i.has_value()) {
-      result->completed = true;
-      result->error = true;
-      return std::unique_ptr<GetaddrinfoFuture>{new LwipGetaddrinfoFuture(result, 0, 0, 0)};
-    }
-    portno = *i;
-  }
-
-  int hint_ai_socktype = 0, hint_ai_protocol = 0;
-  uint8_t dns_addrtype = LWIP_DNS_ADDRTYPE_DEFAULT;
-  if (hints != nullptr) {
-    hint_ai_socktype = hints->ai_socktype;
-    hint_ai_protocol = hints->ai_protocol;
-    if (hints->ai_family == AF_INET) {
-      dns_addrtype = LWIP_DNS_ADDRTYPE_IPV4;
-    } else if (hints->ai_family == AF_INET6) {
-      dns_addrtype = LWIP_DNS_ADDRTYPE_IPV6;
-    }
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
-  LwipDNSCallbackArg *callback_arg = new LwipDNSCallbackArg;
-  callback_arg->res = result;
-
-  ip_addr_t immediate_result;
-  err_t err = dns_gethostbyname_addrtype(node, &immediate_result, lwip_dns_callback, callback_arg, dns_addrtype);
-  if (err == ERR_OK) {
-    // immediate result
-    result->completed = true;
-    result->error = false;
-    ip_addr_copy(result->ipaddr, immediate_result);
-
-    // callback won't be called
-    delete callback_arg;  // NOLINT(cppcoreguidelines-owning-memory)
-  } else if (err == ERR_INPROGRESS) {
-    // result notified via callback
-  } else {
-    // error
-    result->completed = true;
-    result->error = true;
-
-    // callback won't be called
-    delete callback_arg;  // NOLINT(cppcoreguidelines-owning-memory)
-  }
-
-  return std::unique_ptr<GetaddrinfoFuture>{
-      new LwipGetaddrinfoFuture(result, hint_ai_socktype, hint_ai_protocol, portno)};
-}
-
-}  // namespace socket
-}  // namespace esphome
-
-#ifdef USE_ESP8266
-void freeaddrinfo(struct addrinfo *ai) {
-  while (ai != nullptr) {
-    struct addrinfo *next = ai->ai_next;
-    delete ai;  // NOLINT(cppcoreguidelines-owning-memory)
-    ai = next;
-  }
-}
-const char *gai_strerror(int errcode) {
-  switch (errcode) {
-    case EAI_BADFLAGS: return "badflags";
-    case EAI_NONAME: return "noname";
-    case EAI_AGAIN: return "again";
-    case EAI_FAMILY: return "family";
-    case EAI_SOCKTYPE: return "socktype";
-    case EAI_SERVICE: return "service";
-    case EAI_MEMORY: return "memory";
-    case EAI_SYSTEM: return "system";
-    case EAI_OVERFLOW: return "overflow";
-    default: return "unknown";
-  }
-}
-#endif
-
-#endif  // USE_SOCKET_HAS_LWIP

esphome/components/socket/lwip_raw_tcp_impl.cpp

@@ -69,7 +69,7 @@ class LWIPRawImpl : public Socket {
     }
     if (name == nullptr) {
       errno = EINVAL;
-      return -1;
+      return 0;
     }
     ip_addr_t ip;
     in_port_t port;
@@ -126,76 +126,6 @@ class LWIPRawImpl : public Socket {
     }
     return 0;
   }
-  int connect(const struct sockaddr *addr, socklen_t addrlen) override {
-    if (pcb_ == nullptr) {
-      errno = EBADF;
-      return -1;
-    }
-    if (addr == nullptr) {
-      errno = EINVAL;
-      return -1;
-    }
-    if (connecting_) {
-      errno = EALREADY;
-      return -1;
-    }
-
-    ip_addr_t ipaddr;
-    uint16_t port;
-
-    if (addr->sa_family == AF_INET) {
-      const struct sockaddr_in *sa4 = reinterpret_cast<const struct sockaddr_in *>(addr);
-      inet_addr_to_ip4addr(ip_2_ip4(&ipaddr), &sa4->sin_addr);
-#if LWIP_IPV4 && LWIP_IPV6
-      ipaddr.type = IPADDR_TYPE_V4;
-#endif
-      port = ntohs(sa4->sin_port);
-#if LWIP_IPV6
-    } else if (addr->sa_family == AF_INET6) {
-      const struct sockaddr_in6 *sa6 = reinterpret_cast<const struct sockaddr_in6 *>(addr);
-      inet6_addr_to_ip6addr(ip_2_ip6(&ipaddr), &sa6->sin_addr);
-      ipaddr.type = IPADDR_TYPE_V6;
-      port = ntohs(sa6->sin_port);
-#endif  // LWIP_IPV6
-    } else {
-      errno = EAFNOSUPPORT;
-      return -1;
-    }
-
-    connecting_ = true;
-    connected_ = false;
-    connect_error_ = false;
-    LWIP_LOG("tcp_connect(%u)", port);
-    err_t err = tcp_connect(pcb_, &ipaddr, port, LWIPRawImpl::s_connected_fn);
-    if (err == ERR_VAL) {
-      errno = EINVAL;
-      return -1;
-    }
-    if (err != ERR_OK) {
-      errno = EIO;
-      return -1;
-    }
-
-    errno = EINPROGRESS;
-    return -1;
-  }
-  int connect_finished() override {
-    if (connected_) {
-      return 0;
-    }
-    if (connect_error_) {
-      errno = ECONNREFUSED;
-      return -1;
-    }
-    if (connecting_) {
-      errno = EINPROGRESS;
-      return -1;
-    }
-    // no connect started
-    errno = EALREADY;
-    return -1;
-  }
-
   int close() override {
     if (pcb_ == nullptr) {
       errno = ECONNRESET;
@@ -439,10 +369,9 @@ class LWIPRawImpl : public Socket {
     for (int i = 0; i < iovcnt; i++) {
       ssize_t err = read(reinterpret_cast<uint8_t *>(iov[i].iov_base), iov[i].iov_len);
       if (err == -1) {
-        if (ret != 0) {
+        if (ret != 0)
           // if we already read some don't return an error
           break;
-        }
         return err;
       }
       ret += err;
@@ -504,10 +433,9 @@ class LWIPRawImpl : public Socket {
     ssize_t written = internal_write(buf, len);
     if (written == -1)
       return -1;
-    if (written == 0) {
+    if (written == 0)
       // no need to output if nothing written
       return 0;
-    }
     if (nodelay_) {
       int err = internal_output();
       if (err == -1)
@@ -520,20 +448,18 @@ class LWIPRawImpl : public Socket {
     for (int i = 0; i < iovcnt; i++) {
       ssize_t err = internal_write(reinterpret_cast<uint8_t *>(iov[i].iov_base), iov[i].iov_len);
       if (err == -1) {
-        if (written != 0) {
+        if (written != 0)
           // if we already read some don't return an error
           break;
-        }
         return err;
       }
       written += err;
       if ((size_t) err != iov[i].iov_len)
         break;
     }
-    if (written == 0) {
+    if (written == 0)
       // no need to output if nothing written
       return 0;
-    }
     if (nodelay_) {
       int err = internal_output();
       if (err == -1)
@@ -602,18 +528,6 @@ class LWIPRawImpl : public Socket {
     }
     return ERR_OK;
   }
-  err_t connected_fn(err_t err) {
-    LWIP_LOG("connected(err=%d)", err);
-    if (err != ERR_OK) {
-      connected_ = false;
-      connect_error_ = false;
-    } else {
-      connected_ = true;
-      connect_error_ = true;
-    }
-    connecting_ = false;
-    return ERR_OK;
-  }
 
   static err_t s_accept_fn(void *arg, struct tcp_pcb *newpcb, err_t err) {
     LWIPRawImpl *arg_this = reinterpret_cast<LWIPRawImpl *>(arg);
@@ -630,11 +544,6 @@ class LWIPRawImpl : public Socket {
     return arg_this->recv_fn(pb, err);
   }
 
-  static err_t s_connected_fn(void *arg, struct tcp_pcb *pcb, err_t err) {
-    LWIPRawImpl *arg_this = reinterpret_cast<LWIPRawImpl *>(arg);
-    return arg_this->connected_fn(err);
-  }
-
  protected:
   int ip2sockaddr_(ip_addr_t *ip, uint16_t port, struct sockaddr *name, socklen_t *addrlen) {
     if (family_ == AF_INET) {
@@ -685,9 +594,6 @@ class LWIPRawImpl : public Socket {
   // instead use it for determining whether to call lwip_output
   bool nodelay_ = false;
   sa_family_t family_ = 0;
-  bool connecting_ = false;
-  bool connected_ = false;
-  bool connect_error_ = false;
 };
 
 std::unique_ptr<Socket> socket(int domain, int type, int protocol) {

esphome/components/socket/socket.cpp

@@ -10,7 +10,7 @@ namespace socket {
 Socket::~Socket() {}
 
 std::unique_ptr<Socket> socket_ip(int type, int protocol) {
-#ifdef USE_SOCKET_IPV6
+#if LWIP_IPV6
   return socket(AF_INET6, type, protocol);
 #else
   return socket(AF_INET, type, protocol);
@@ -51,7 +51,7 @@ socklen_t set_sockaddr(struct sockaddr *addr, socklen_t addrlen, const std::stri
 }
 
 socklen_t set_sockaddr_any(struct sockaddr *addr, socklen_t addrlen, uint16_t port) {
-#if USE_SOCKET_IPV6
+#if LWIP_IPV6
   if (addrlen < sizeof(sockaddr_in6)) {
     errno = EINVAL;
     return 0;

esphome/components/socket/socket.h

@@ -5,12 +5,6 @@
 #include "esphome/core/optional.h"
 #include "headers.h"
 
-#ifdef USE_SOCKET_IMPL_LWIP_TCP
-#if LWIP_IPV6
-#define USE_SOCKET_IPV6
-#endif
-#endif
-
 namespace esphome {
 namespace socket {
 
@@ -23,17 +17,10 @@ class Socket {
 
   virtual std::unique_ptr<Socket> accept(struct sockaddr *addr, socklen_t *addrlen) = 0;
   virtual int bind(const struct sockaddr *addr, socklen_t addrlen) = 0;
-  virtual int connect(const struct sockaddr *addr, socklen_t addrlen) = 0;
-  /**
-   * @brief Helper to check if a socket connect() that was EINPROGRESS is now finished.
-   *
-   * If the connect finnished successfully, returns 0.
-   * If it's still in progress, returns -1 and sets errno to EINPROGRESS.
-   * Other errors result in return code -1 and errno like in blocking connect().
-   */
-  virtual int connect_finished() = 0;
-
   virtual int close() = 0;
+  // not supported yet:
+  // virtual int connect(const std::string &address) = 0;
+  // virtual int connect(const struct sockaddr *addr, socklen_t addrlen) = 0;
   virtual int shutdown(int how) = 0;
 
   virtual int getpeername(struct sockaddr *addr, socklen_t *addrlen) = 0;

esphome/components/socket/thread_getaddrinfo_impl.cpp

@@ -1,99 +0,0 @@
-#include "getaddrinfo.h"
-#include "esphome/core/defines.h"
-
-#ifndef USE_SOCKET_HAS_LWIP
-
-#include <thread>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
-
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace socket {
-
-static const char *const TAG = "socket.threadgetaddrinfo";
-
-struct ThreadGetaddrinfoResult {
-  bool completed;
-  int return_code;
-  struct addrinfo *res;
-};
-
-class ThreadGetaddrinfoFuture : public GetaddrinfoFuture {
- public:
-  ThreadGetaddrinfoFuture(std::shared_ptr<ThreadGetaddrinfoResult> result) : result_(result) {}
-  ~ThreadGetaddrinfoFuture() override = default;
-
-  bool completed() override { return result_->completed; }
-  int fetch_result(struct addrinfo **res) {
-    if (res == nullptr)
-      return EAI_FAIL;
-    *res = nullptr;
-    if (!result_->completed)
-      return EAI_FAIL;
-    if (result_->return_code != 0)
-      return result_->return_code;
-
-    *res = result_->res;
-    return 0;
-  }
-
- protected:
-  std::shared_ptr<ThreadGetaddrinfoResult> result_;
-};
-
-void worker(std::shared_ptr<ThreadGetaddrinfoResult> result, const char *node, const char *service,
-            const struct addrinfo *hints) {
-  result->return_code = getaddrinfo(node, service, hints, &result->res);
-  result->completed = true;
-  if (hints != nullptr) {
-    delete hints->ai_addr;
-    delete hints->ai_canonname;
-    delete hints;
-  }
-  delete node;
-  delete service;
-}
-
-std::unique_ptr<GetaddrinfoFuture> getaddrinfo_async(const char *node, const char *service,
-                                                     const struct addrinfo *hints) {
-  std::shared_ptr<ThreadGetaddrinfoResult> result = std::make_shared<ThreadGetaddrinfoResult>();
-  result->completed = false;
-
-  struct addrinfo *hints_copy = nullptr;
-  if (hints != nullptr) {
-    hints_copy = new struct addrinfo;
-    hints_copy->ai_flags = hints->ai_flags;
-    hints_copy->ai_family = hints->ai_family;
-    hints_copy->ai_socktype = hints->ai_socktype;
-    hints_copy->ai_protocol = hints->ai_protocol;
-    hints_copy->ai_addrlen = hints->ai_addrlen;
-    if (ai->ai_addr != nullptr) {
-      hints_copy->ai_addr = malloc(hints->ai_addrlen);
-      memcpy(hints_copy->ai_addr, hints->ai_addr, hints->ai_addrlen);
-    }
-    if (ai->ai_canonname != nullptr) {
-      hints_copy->ai_canonname = strdup(hints->ai_canonname);
-    }
-    hints_copy->ai_next = nullptr;
-  }
-
-  const char *node_copy = nullptr, *service_copy = nullptr;
-  if (node != nullptr)
-    node_copy = strdup(node);
-  if (service != nullptr)
-    service_copy = strdup(service);
-
-  std::thread thread(worker, result, node_copy, service_copy, hints_copy);
-  thread.detach();
-
-  return std::unique_ptr<GetaddrinfoFuture>{new ThreadGetaddrinfoFuture(result)};
-}
-
-}  // namespace socket
-}  // namespace esphome
-
-#endif  // !USE_SOCKET_HAS_LWIP

esphome/components/wifi/wifi_component_esp_idf.cpp

@@ -58,9 +58,7 @@ struct IDFWiFiEvent {
     wifi_event_ap_probe_req_rx_t ap_probe_req_rx;
     wifi_event_bss_rssi_low_t bss_rssi_low;
     ip_event_got_ip_t ip_got_ip;
-#if LWIP_IPV6
     ip_event_got_ip6_t ip_got_ip6;
-#endif
     ip_event_ap_staipassigned_t ip_ap_staipassigned;
   } data;
 };
@@ -84,10 +82,8 @@ void event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, voi
     memcpy(&event.data.sta_disconnected, event_data, sizeof(wifi_event_sta_disconnected_t));
   } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
     memcpy(&event.data.ip_got_ip, event_data, sizeof(ip_event_got_ip_t));
-#if LWIP_IPV6
   } else if (event_base == IP_EVENT && event_id == IP_EVENT_GOT_IP6) {
     memcpy(&event.data.ip_got_ip6, event_data, sizeof(ip_event_got_ip6_t));
-#endif
   } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_LOST_IP) {  // NOLINT(bugprone-branch-clone)
     // no data
   } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_SCAN_DONE) {
@@ -508,9 +504,7 @@ const char *get_auth_mode_str(uint8_t mode) {
 }
 
 std::string format_ip4_addr(const esp_ip4_addr_t &ip) { return str_snprintf(IPSTR, 15, IP2STR(&ip)); }
-#if LWIP_IPV6
 std::string format_ip6_addr(const esp_ip6_addr_t &ip) { return str_snprintf(IPV6STR, 39, IPV62STR(ip)); }
-#endif
 const char *get_disconnect_reason_str(uint8_t reason) {
   switch (reason) {
     case WIFI_REASON_AUTH_EXPIRE:
@@ -650,11 +644,9 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
              format_ip4_addr(it.ip_info.gw).c_str());
     s_sta_got_ip = true;
 
-#if LWIP_IPV6
   } else if (data->event_base == IP_EVENT && data->event_id == IP_EVENT_GOT_IP6) {
     const auto &it = data->data.ip_got_ip6;
     ESP_LOGV(TAG, "Event: Got IPv6 address=%s", format_ip6_addr(it.ip6_info.ip).c_str());
-#endif
 
   } else if (data->event_base == IP_EVENT && data->event_id == IP_EVENT_STA_LOST_IP) {
     ESP_LOGV(TAG, "Event: Lost IP");

esphome/components/xl9535/__init__.py

@@ -1,73 +0,0 @@
-import esphome.codegen as cg
-import esphome.config_validation as cv
-from esphome.components import i2c
-from esphome.const import (
-    CONF_ID,
-    CONF_INPUT,
-    CONF_INVERTED,
-    CONF_MODE,
-    CONF_NUMBER,
-    CONF_OUTPUT,
-)
-from esphome import pins
-
-CONF_XL9535 = "xl9535"
-
-DEPENDENCIES = ["i2c"]
-CODEOWNERS = ["@mreditor97"]
-
-xl9535_ns = cg.esphome_ns.namespace(CONF_XL9535)
-
-XL9535Component = xl9535_ns.class_("XL9535Component", cg.Component, i2c.I2CDevice)
-XL9535GPIOPin = xl9535_ns.class_("XL9535GPIOPin", cg.GPIOPin)
-
-MULTI_CONF = True
-CONFIG_SCHEMA = (
-    cv.Schema({cv.Required(CONF_ID): cv.declare_id(XL9535Component)})
-    .extend(cv.COMPONENT_SCHEMA)
-    .extend(i2c.i2c_device_schema(0x20))
-)
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await i2c.register_i2c_device(var, config)
-
-
-def validate_mode(mode):
-    if not (mode[CONF_INPUT] or mode[CONF_OUTPUT]) or (
-        mode[CONF_INPUT] and mode[CONF_OUTPUT]
-    ):
-        raise cv.Invalid("Mode must be either a input or a output")
-    return mode
-
-
-XL9535_PIN_SCHEMA = cv.All(
-    {
-        cv.GenerateID(): cv.declare_id(XL9535GPIOPin),
-        cv.Required(CONF_XL9535): cv.use_id(XL9535Component),
-        cv.Required(CONF_NUMBER): cv.int_range(min=0, max=15),
-        cv.Optional(CONF_MODE, default={}): cv.All(
-            {
-                cv.Optional(CONF_INPUT, default=False): cv.boolean,
-                cv.Optional(CONF_OUTPUT, default=False): cv.boolean,
-            },
-            validate_mode,
-        ),
-        cv.Optional(CONF_INVERTED, default=False): cv.boolean,
-    }
-)
-
-
-@pins.PIN_SCHEMA_REGISTRY.register(CONF_XL9535, XL9535_PIN_SCHEMA)
-async def xl9535_pin_to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    parent = await cg.get_variable(config[CONF_XL9535])
-
-    cg.add(var.set_parent(parent))
-    cg.add(var.set_pin(config[CONF_NUMBER]))
-    cg.add(var.set_inverted(config[CONF_INVERTED]))
-    cg.add(var.set_flags(pins.gpio_flags_expr(config[CONF_MODE])))
-
-    return var

esphome/components/xl9535/xl9535.cpp

@@ -1,122 +0,0 @@
-#include "xl9535.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace xl9535 {
-
-static const char *const TAG = "xl9535";
-
-void XL9535Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up XL9535...");
-
-  // Check to see if the device can read from the register
-  uint8_t port = 0;
-  if (this->read_register(XL9535_INPUT_PORT_0_REGISTER, &port, 1) != i2c::ERROR_OK) {
-    this->mark_failed();
-    return;
-  }
-}
-
-void XL9535Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "XL9535:");
-  LOG_I2C_DEVICE(this);
-
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with XL9535 failed!");
-  }
-}
-
-bool XL9535Component::digital_read(uint8_t pin) {
-  bool state = false;
-  uint8_t port = 0;
-
-  if (pin > 7) {
-    if (this->read_register(XL9535_INPUT_PORT_1_REGISTER, &port, 1) != i2c::ERROR_OK) {
-      this->status_set_warning();
-      return state;
-    }
-
-    state = (port & (pin - 10)) != 0;
-  } else {
-    if (this->read_register(XL9535_INPUT_PORT_0_REGISTER, &port, 1) != i2c::ERROR_OK) {
-      this->status_set_warning();
-      return state;
-    }
-
-    state = (port & pin) != 0;
-  }
-
-  this->status_clear_warning();
-  return state;
-}
-
-void XL9535Component::digital_write(uint8_t pin, bool value) {
-  uint8_t port = 0;
-  uint8_t register_data = 0;
-
-  if (pin > 7) {
-    if (this->read_register(XL9535_OUTPUT_PORT_1_REGISTER, &register_data, 1) != i2c::ERROR_OK) {
-      this->status_set_warning();
-      return;
-    }
-
-    register_data = register_data & (~(1 << (pin - 10)));
-    port = register_data | value << (pin - 10);
-
-    if (this->write_register(XL9535_OUTPUT_PORT_1_REGISTER, &port, 1) != i2c::ERROR_OK) {
-      this->status_set_warning();
-      return;
-    }
-  } else {
-    if (this->read_register(XL9535_OUTPUT_PORT_0_REGISTER, &register_data, 1) != i2c::ERROR_OK) {
-      this->status_set_warning();
-      return;
-    }
-    register_data = register_data & (~(1 << pin));
-    port = register_data | value << pin;
-
-    if (this->write_register(XL9535_OUTPUT_PORT_0_REGISTER, &port, 1) != i2c::ERROR_OK) {
-      this->status_set_warning();
-      return;
-    }
-  }
-
-  this->status_clear_warning();
-}
-
-void XL9535Component::pin_mode(uint8_t pin, gpio::Flags mode) {
-  uint8_t port = 0;
-
-  if (pin > 7) {
-    this->read_register(XL9535_CONFIG_PORT_1_REGISTER, &port, 1);
-
-    if (mode == gpio::FLAG_INPUT) {
-      port = port | (1 << (pin - 10));
-    } else if (mode == gpio::FLAG_OUTPUT) {
-      port = port & (~(1 << (pin - 10)));
-    }
-
-    this->write_register(XL9535_CONFIG_PORT_1_REGISTER, &port, 1);
-  } else {
-    this->read_register(XL9535_CONFIG_PORT_0_REGISTER, &port, 1);
-
-    if (mode == gpio::FLAG_INPUT) {
-      port = port | (1 << pin);
-    } else if (mode == gpio::FLAG_OUTPUT) {
-      port = port & (~(1 << pin));
-    }
-
-    this->write_register(XL9535_CONFIG_PORT_0_REGISTER, &port, 1);
-  }
-}
-
-void XL9535GPIOPin::setup() { this->pin_mode(this->flags_); }
-
-std::string XL9535GPIOPin::dump_summary() const { return str_snprintf("%u via XL9535", 15, this->pin_); }
-
-void XL9535GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
-bool XL9535GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
-void XL9535GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
-
-}  // namespace xl9535
-}  // namespace esphome

esphome/components/xl9535/xl9535.h

@@ -1,54 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/components/i2c/i2c.h"
-#include "esphome/core/hal.h"
-
-namespace esphome {
-namespace xl9535 {
-
-enum {
-  XL9535_INPUT_PORT_0_REGISTER = 0x00,
-  XL9535_INPUT_PORT_1_REGISTER = 0x01,
-  XL9535_OUTPUT_PORT_0_REGISTER = 0x02,
-  XL9535_OUTPUT_PORT_1_REGISTER = 0x03,
-  XL9535_INVERSION_PORT_0_REGISTER = 0x04,
-  XL9535_INVERSION_PORT_1_REGISTER = 0x05,
-  XL9535_CONFIG_PORT_0_REGISTER = 0x06,
-  XL9535_CONFIG_PORT_1_REGISTER = 0x07,
-};
-
-class XL9535Component : public Component, public i2c::I2CDevice {
- public:
-  bool digital_read(uint8_t pin);
-  void digital_write(uint8_t pin, bool value);
-  void pin_mode(uint8_t pin, gpio::Flags mode);
-
-  void setup() override;
-  void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
-};
-
-class XL9535GPIOPin : public GPIOPin {
- public:
-  void set_parent(XL9535Component *parent) { this->parent_ = parent; }
-  void set_pin(uint8_t pin) { this->pin_ = pin; }
-  void set_inverted(bool inverted) { this->inverted_ = inverted; }
-  void set_flags(gpio::Flags flags) { this->flags_ = flags; }
-
-  void setup() override;
-  std::string dump_summary() const override;
-  void pin_mode(gpio::Flags flags) override;
-  bool digital_read() override;
-  void digital_write(bool value) override;
-
- protected:
-  XL9535Component *parent_;
-
-  uint8_t pin_;
-  bool inverted_;
-  gpio::Flags flags_;
-};
-
-}  // namespace xl9535
-}  // namespace esphome

esphome/const.py

@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2023.7.0-dev"
+__version__ = "2023.6.2"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (

esphome/core/defines.h

@@ -85,7 +85,6 @@
 #ifdef USE_ESP_IDF
 #define USE_ESP_IDF_VERSION_CODE VERSION_CODE(4, 4, 2)
 #endif
-#define USE_SOCKET_HAS_LWIP
 #endif
 
 // ESP8266-specific feature flags
@@ -95,7 +94,6 @@
 #define USE_ESP8266_PREFERENCES_FLASH
 #define USE_HTTP_REQUEST_ESP8266_HTTPS
 #define USE_SOCKET_IMPL_LWIP_TCP
-#define USE_SOCKET_HAS_LWIP
 
 // Dummy firmware payload for shelly_dimmer
 #define USE_SHD_FIRMWARE_MAJOR_VERSION 56

platformio.ini

@@ -39,7 +39,6 @@ lib_deps =
     bblanchon/ArduinoJson@6.18.5           ; json
     wjtje/qr-code-generator-library@1.7.0  ; qr_code
     functionpointer/arduino-MLX90393@1.0.0 ; mlx90393
-    pavlodn/HaierProtocol@0.9.18           ; haier
     ; This is using the repository until a new release is published to PlatformIO
     https://github.com/Sensirion/arduino-gas-index-algorithm.git#3.2.1 ; Sensirion Gas Index Algorithm Arduino Library
 build_flags =
@@ -62,7 +61,7 @@ lib_deps =
     fastled/FastLED@3.3.2                                 ; fastled_base
     mikalhart/TinyGPSPlus@1.0.2                           ; gps
     freekode/TM1651@1.0.1                                 ; tm1651
-    glmnet/Dsmr@0.7                                       ; dsmr
+    glmnet/Dsmr@0.5                                       ; dsmr
     rweather/Crypto@0.4.0                                 ; dsmr
     dudanov/MideaUART@1.1.8                               ; midea
     tonia/HeatpumpIR@1.0.20                               ; heatpumpir

requirements.txt

@@ -10,8 +10,8 @@ platformio==6.1.7  # When updating platformio, also update Dockerfile
 esptool==4.6
 click==8.1.3
 esphome-dashboard==20230621.0
-aioesphomeapi==15.0.0
-zeroconf==0.69.0
+aioesphomeapi==14.0.0
+zeroconf==0.63.0
 
 # esp-idf requires this, but doesn't bundle it by default
 # https://github.com/espressif/esp-idf/blob/220590d599e134d7a5e7f1e683cc4550349ffbf8/requirements.txt#L24

requirements_test.txt

@@ -1,11 +1,11 @@
 pylint==2.17.4
 flake8==6.0.0  # also change in .pre-commit-config.yaml when updating
 black==23.3.0  # also change in .pre-commit-config.yaml when updating
-pyupgrade==3.7.0  # also change in .pre-commit-config.yaml when updating
+pyupgrade==3.4.0  # also change in .pre-commit-config.yaml when updating
 pre-commit
 
 # Unit tests
-pytest==7.4.0
+pytest==7.3.1
 pytest-cov==4.1.0
 pytest-mock==3.10.0
 pytest-asyncio==0.21.0

script/build_language_schema.py

@@ -461,10 +461,8 @@ def merge(source, destination):
 
 def is_platform_schema(schema_name):
     # added mostly because of schema_name == "microphone.MICROPHONE_SCHEMA"
-    # and "alarm_control_panel"
     # which is shrunk because there is only one component of the schema (i2s_audio)
-    component = schema_name.split(".")[0]
-    return component in components and components[component].is_platform_component
+    return schema_name == "microphone.MICROPHONE_SCHEMA"
 
 
 def shrink():
@@ -532,10 +530,6 @@ def shrink():
         elif not key_s:
             for target in paths:
                 target_s = get_arr_path_schema(target)
-                if S_SCHEMA not in target_s:
-                    # an empty schema like speaker.SPEAKER_SCHEMA
-                    target_s[S_EXTENDS].remove(x)
-                    continue
                 assert target_s[S_SCHEMA][S_EXTENDS] == [x]
                 target_s.pop(S_SCHEMA)
                 target_s.pop(S_TYPE)  # undefined

tests/test3.yaml

@@ -944,29 +944,13 @@ climate:
       kd_multiplier: 0.0
       deadband_output_averaging_samples: 1
   - platform: haier
-    protocol: hOn
     name: Haier AC
-    uart_id: uart_12
-    wifi_signal: true
-    beeper: true
-    outdoor_temperature:
-      name:  Haier AC outdoor temperature
-    visual:
-      min_temperature: 16 °C
-      max_temperature: 30 °C
-      temperature_step: 1 °C
-    supported_modes:
-    - 'OFF'
-    - AUTO
-    - COOL
-    - HEAT
-    - DRY
-    - FAN_ONLY
     supported_swing_modes:
-    - 'OFF'
-    - VERTICAL
-    - HORIZONTAL
-    - BOTH
+      - vertical
+      - horizontal
+      - both
+    update_interval: 10s
+    uart_id: uart_12
 
 sprinkler:
   - id: yard_sprinkler_ctrlr

tests/test4.yaml

@@ -384,15 +384,6 @@ binary_sensor:
         pullup: true
       inverted: false
 
-  - platform: gpio
-    name: XL9535 Pin 0
-    pin:
-      xl9535: xl9535_hub
-      number: 0
-      mode:
-        input: true
-      inverted: false
-
 climate:
   - platform: tuya
     id: tuya_climate
@@ -754,7 +745,3 @@ voice_assistant:
 max6956:
   - id: max6956_1
     address: 0x40
-
-xl9535:
-  - id: xl9535_hub
-    address: 0x20