Merge branch 'dev' into socket-client-mode

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

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

@@ -0,0 +1,38 @@
+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,10 +26,16 @@ 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 }}
@@ -39,7 +45,7 @@ jobs:
         with:
           path: venv
           # yamllint disable-line rule:line-length
-          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
+          key: ${{ runner.os }}-${{ steps.python.outputs.python-version }}-venv-${{ steps.cache-key.outputs.key }}
       - name: Create Python virtual environment
         if: steps.cache-venv.outputs.cache-hit != 'true'
         run: |
@@ -66,12 +72,11 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python virtual environment
+      - name: Restore Python
-        uses: actions/cache/restore@v3.3.1
+        uses: ./.github/actions/restore-python
         with:
-          path: venv
+          python-version: ${{ env.DEFAULT_PYTHON }}
-          # yamllint disable-line rule:line-length
+          cache-key: ${{ needs.common.outputs.cache-key }}
-          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Run black
         run: |
           . venv/bin/activate
@@ -88,12 +93,11 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python virtual environment
+      - name: Restore Python
-        uses: actions/cache/restore@v3.3.1
+        uses: ./.github/actions/restore-python
         with:
-          path: venv
+          python-version: ${{ env.DEFAULT_PYTHON }}
-          # yamllint disable-line rule:line-length
+          cache-key: ${{ needs.common.outputs.cache-key }}
-          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Run flake8
         run: |
           . venv/bin/activate
@@ -110,12 +114,11 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python virtual environment
+      - name: Restore Python
-        uses: actions/cache/restore@v3.3.1
+        uses: ./.github/actions/restore-python
         with:
-          path: venv
+          python-version: ${{ env.DEFAULT_PYTHON }}
-          # yamllint disable-line rule:line-length
+          cache-key: ${{ needs.common.outputs.cache-key }}
-          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Run pylint
         run: |
           . venv/bin/activate
@@ -132,12 +135,11 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python virtual environment
+      - name: Restore Python
-        uses: actions/cache/restore@v3.3.1
+        uses: ./.github/actions/restore-python
         with:
-          path: venv
+          python-version: ${{ env.DEFAULT_PYTHON }}
-          # yamllint disable-line rule:line-length
+          cache-key: ${{ needs.common.outputs.cache-key }}
-          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Run pyupgrade
         run: |
           . venv/bin/activate
@@ -154,12 +156,11 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python virtual environment
+      - name: Restore Python
-        uses: actions/cache/restore@v3.3.1
+        uses: ./.github/actions/restore-python
         with:
-          path: venv
+          python-version: ${{ env.DEFAULT_PYTHON }}
-          # yamllint disable-line rule:line-length
+          cache-key: ${{ needs.common.outputs.cache-key }}
-          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
@@ -176,12 +177,11 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python virtual environment
+      - name: Restore Python
-        uses: actions/cache/restore@v3.3.1
+        uses: ./.github/actions/restore-python
         with:
-          path: venv
+          python-version: ${{ env.DEFAULT_PYTHON }}
-          # yamllint disable-line rule:line-length
+          cache-key: ${{ needs.common.outputs.cache-key }}
-          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,12 +197,11 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python virtual environment
+      - name: Restore Python
-        uses: actions/cache/restore@v3.3.1
+        uses: ./.github/actions/restore-python
         with:
-          path: venv
+          python-version: ${{ env.DEFAULT_PYTHON }}
-          # yamllint disable-line rule:line-length
+          cache-key: ${{ needs.common.outputs.cache-key }}
-          key: ${{ runner.os }}-${{ env.DEFAULT_PYTHON }}-venv-${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}
       - name: Install clang-format
         run: |
           . venv/bin/activate
@@ -237,12 +236,11 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python virtual environment
+      - name: Restore Python
-        uses: actions/cache/restore@v3.3.1
+        uses: ./.github/actions/restore-python
         with:
-          path: venv
+          python-version: ${{ env.DEFAULT_PYTHON }}
-          # yamllint disable-line rule:line-length
+          cache-key: ${{ needs.common.outputs.cache-key }}
-          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:
@@ -300,13 +298,11 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v3.5.2
-      - name: Restore Python virtual environment
+      - name: Restore Python
-        uses: actions/cache/restore@v3.3.1
+        uses: ./.github/actions/restore-python
         with:
-          path: venv
+          python-version: ${{ env.DEFAULT_PYTHON }}
-          # yamllint disable-line rule:line-length
+          cache-key: ${{ needs.common.outputs.cache-key }}
-          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,14 +6,12 @@ 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
@@ -38,15 +36,6 @@ 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:
@@ -56,5 +45,5 @@ jobs:
           branch: sync/device-classes
           delete-branch: true
           title: "Synchronise Device Classes from Home Assistant"
-          body: ${{ steps.pr-template-body.outputs.body }}
+          body-path: .github/PULL_REQUEST_TEMPLATE.md
           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.4.0
+    rev: v3.7.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/* @Yarikx
+esphome/components/haier/* @paveldn
 esphome/components/havells_solar/* @sourabhjaiswal
 esphome/components/hbridge/fan/* @WeekendWarrior
 esphome/components/hbridge/light/* @DotNetDann
@@ -319,4 +319,5 @@ 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 core
+from esphome import automation, core
-from esphome.components import display, font
+from esphome.components import font
 import esphome.components.image as espImage
 from esphome.components.image import CONF_USE_TRANSPARENCY
 import esphome.config_validation as cv
@@ -18,14 +18,30 @@ 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_ = display.display_ns.class_("Animation", espImage.Image_)
+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_)
+)
 
 
 def validate_cross_dependencies(config):
@@ -74,7 +90,35 @@ ANIMATION_SCHEMA = cv.Schema(
 
 CONFIG_SCHEMA = cv.All(font.validate_pillow_installed, ANIMATION_SCHEMA)
 
-CODEOWNERS = ["@syndlex"]
+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
 
 
 async def to_code(config):

esphome/components/animation/animation.cpp

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

esphome/components/animation/animation.h

@@ -0,0 +1,67 @@
+#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.h

@@ -1,37 +0,0 @@
-#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,105 +7,14 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-#include "animation.h"
-#include "image.h"
-#include "font.h"
-
 namespace esphome {
 namespace display {
 
 static const char *const TAG = "display";
 
-const Color COLOR_OFF(0, 0, 0, 255);
+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);
@@ -256,54 +165,14 @@ void DisplayBuffer::filled_circle(int center_x, int center_y, int radius, Color
   } while (dx <= 0);
 }
 
-void DisplayBuffer::print(int x, int y, Font *font, Color color, TextAlign align, const char *text) {
+void DisplayBuffer::print(int x, int y, BaseFont *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, Font *font, Color color, TextAlign align, const char *format, va_list arg) {
+void DisplayBuffer::vprintf_(int x, int y, BaseFont *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)
@@ -358,7 +227,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, Font *font, TextAlign align, int *x1, int *y1,
+void DisplayBuffer::get_text_bounds(int x, int y, const char *text, BaseFont *font, TextAlign align, int *x1, int *y1,
                                     int *width, int *height) {
   int x_offset, baseline;
   font->measure(text, width, &x_offset, &baseline, height);
@@ -396,34 +265,34 @@ void DisplayBuffer::get_text_bounds(int x, int y, const char *text, Font *font,
       break;
   }
 }
-void DisplayBuffer::print(int x, int y, Font *font, Color color, const char *text) {
+void DisplayBuffer::print(int x, int y, BaseFont *font, Color color, const char *text) {
   this->print(x, y, font, color, TextAlign::TOP_LEFT, text);
 }
-void DisplayBuffer::print(int x, int y, Font *font, TextAlign align, const char *text) {
+void DisplayBuffer::print(int x, int y, BaseFont *font, TextAlign align, const char *text) {
   this->print(x, y, font, COLOR_ON, align, text);
 }
-void DisplayBuffer::print(int x, int y, Font *font, const char *text) {
+void DisplayBuffer::print(int x, int y, BaseFont *font, const char *text) {
   this->print(x, y, font, COLOR_ON, TextAlign::TOP_LEFT, text);
 }
-void DisplayBuffer::printf(int x, int y, Font *font, Color color, TextAlign align, const char *format, ...) {
+void DisplayBuffer::printf(int x, int y, BaseFont *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, Font *font, Color color, const char *format, ...) {
+void DisplayBuffer::printf(int x, int y, BaseFont *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, Font *font, TextAlign align, const char *format, ...) {
+void DisplayBuffer::printf(int x, int y, BaseFont *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, Font *font, const char *format, ...) {
+void DisplayBuffer::printf(int x, int y, BaseFont *font, const char *format, ...) {
   va_list arg;
   va_start(arg, format);
   this->vprintf_(x, y, font, COLOR_ON, TextAlign::TOP_LEFT, format, arg);
@@ -470,19 +339,20 @@ 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, Font *font, Color color, TextAlign align, const char *format, ESPTime time) {
+void DisplayBuffer::strftime(int x, int y, BaseFont *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, Font *font, Color color, const char *format, ESPTime time) {
+void DisplayBuffer::strftime(int x, int y, BaseFont *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, Font *font, TextAlign align, const char *format, ESPTime time) {
+void DisplayBuffer::strftime(int x, int y, BaseFont *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, Font *font, const char *format, ESPTime time) {
+void DisplayBuffer::strftime(int x, int y, BaseFont *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,6 +2,7 @@
 
 #include <cstdarg>
 #include <vector>
+#include "rect.h"
 #include "display_color_utils.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
@@ -16,10 +17,6 @@
 #include "esphome/components/qr_code/qr_code.h"
 #endif
 
-#include "animation.h"
-#include "font.h"
-#include "image.h"
-
 namespace esphome {
 namespace display {
 
@@ -135,33 +132,6 @@ 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;
@@ -175,6 +145,24 @@ 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.
@@ -221,7 +209,7 @@ class DisplayBuffer {
    * @param align The alignment of the text.
    * @param text The text to draw.
    */
-  void print(int x, int y, Font *font, Color color, TextAlign align, const char *text);
+  void print(int x, int y, BaseFont *font, Color color, TextAlign align, const char *text);
 
   /** Print `text` with the top left at [x,y] with `font`.
    *
@@ -231,7 +219,7 @@ class DisplayBuffer {
    * @param color The color to draw the text with.
    * @param text The text to draw.
    */
-  void print(int x, int y, Font *font, Color color, const char *text);
+  void print(int x, int y, BaseFont *font, Color color, const char *text);
 
   /** Print `text` with the anchor point at [x,y] with `font`.
    *
@@ -241,7 +229,7 @@ class DisplayBuffer {
    * @param align The alignment of the text.
    * @param text The text to draw.
    */
-  void print(int x, int y, Font *font, TextAlign align, const char *text);
+  void print(int x, int y, BaseFont *font, TextAlign align, const char *text);
 
   /** Print `text` with the top left at [x,y] with `font`.
    *
@@ -250,7 +238,7 @@ class DisplayBuffer {
    * @param font The font to draw the text with.
    * @param text The text to draw.
    */
-  void print(int x, int y, Font *font, const char *text);
+  void print(int x, int y, BaseFont *font, const char *text);
 
   /** Evaluate the printf-format `format` and print the result with the anchor point at [x,y] with `font`.
    *
@@ -262,7 +250,7 @@ class DisplayBuffer {
    * @param format The format to use.
    * @param ... The arguments to use for the text formatting.
    */
-  void printf(int x, int y, Font *font, Color color, TextAlign align, const char *format, ...)
+  void printf(int x, int y, BaseFont *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`.
@@ -274,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, Font *font, Color color, const char *format, ...) __attribute__((format(printf, 6, 7)));
+  void printf(int x, int y, BaseFont *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`.
    *
@@ -285,7 +273,8 @@ class DisplayBuffer {
    * @param format The format to use.
    * @param ... The arguments to use for the text formatting.
    */
-  void printf(int x, int y, Font *font, TextAlign align, const char *format, ...) __attribute__((format(printf, 6, 7)));
+  void printf(int x, int y, BaseFont *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`.
    *
@@ -295,7 +284,7 @@ class DisplayBuffer {
    * @param format The format to use.
    * @param ... The arguments to use for the text formatting.
    */
-  void printf(int x, int y, Font *font, const char *format, ...) __attribute__((format(printf, 5, 6)));
+  void printf(int x, int y, BaseFont *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`.
    *
@@ -307,7 +296,7 @@ class DisplayBuffer {
    * @param format The strftime format to use.
    * @param time The time to format.
    */
-  void strftime(int x, int y, Font *font, Color color, TextAlign align, const char *format, ESPTime time)
+  void strftime(int x, int y, BaseFont *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`.
@@ -319,7 +308,7 @@ class DisplayBuffer {
    * @param format The strftime format to use.
    * @param time The time to format.
    */
-  void strftime(int x, int y, Font *font, Color color, const char *format, ESPTime time)
+  void strftime(int x, int y, BaseFont *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`.
@@ -331,7 +320,7 @@ class DisplayBuffer {
    * @param format The strftime format to use.
    * @param time The time to format.
    */
-  void strftime(int x, int y, Font *font, TextAlign align, const char *format, ESPTime time)
+  void strftime(int x, int y, BaseFont *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`.
@@ -342,7 +331,7 @@ class DisplayBuffer {
    * @param format The strftime format to use.
    * @param time The time to format.
    */
-  void strftime(int x, int y, Font *font, const char *format, ESPTime time) __attribute__((format(strftime, 5, 0)));
+  void strftime(int x, int y, BaseFont *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.
    *
@@ -412,7 +401,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, Font *font, TextAlign align, int *x1, int *y1, int *width,
+  void get_text_bounds(int x, int y, const char *text, BaseFont *font, TextAlign align, int *x1, int *y1, int *width,
                        int *height);
 
   /// Internal method to set the display writer lambda.
@@ -487,7 +476,7 @@ class DisplayBuffer {
   bool is_clipping() const { return !this->clipping_rectangle_.empty(); }
 
  protected:
-  void vprintf_(int x, int y, Font *font, Color color, TextAlign align, const char *format, va_list arg);
+  void vprintf_(int x, int y, BaseFont *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/rect.cpp

@@ -0,0 +1,98 @@
+#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

@@ -0,0 +1,36 @@
+#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,6 +19,7 @@ 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"
@@ -53,6 +54,7 @@ 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(
@@ -82,9 +84,10 @@ 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.5")
+    cg.add_library("glmnet/Dsmr", "0.7")
 
     # Crypto
     cg.add_library("rweather/Crypto", "0.4.0")

esphome/components/dsmr/sensor.py

@@ -8,6 +8,7 @@ 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,
@@ -236,6 +237,12 @@ 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/ethernet_info/ethernet_info_text_sensor.cpp

@@ -1,7 +1,7 @@
 #include "ethernet_info_text_sensor.h"
 #include "esphome/core/log.h"
 
-#ifdef USE_ESP32_FRAMEWORK_ARDUINO
+#ifdef USE_ESP32
 
 namespace esphome {
 namespace ethernet_info {
@@ -13,4 +13,4 @@ void IPAddressEthernetInfo::dump_config() { LOG_TEXT_SENSOR("", "EthernetInfo IP
 }  // namespace ethernet_info
 }  // namespace esphome
 
-#endif  // USE_ESP32_FRAMEWORK_ARDUINO
+#endif  // USE_ESP32

esphome/components/ethernet_info/ethernet_info_text_sensor.h

@@ -4,7 +4,7 @@
 #include "esphome/components/text_sensor/text_sensor.h"
 #include "esphome/components/ethernet/ethernet_component.h"
 
-#ifdef USE_ESP32_FRAMEWORK_ARDUINO
+#ifdef USE_ESP32
 
 namespace esphome {
 namespace ethernet_info {
@@ -30,4 +30,4 @@ class IPAddressEthernetInfo : public PollingComponent, public text_sensor::TextS
 }  // namespace ethernet_info
 }  // namespace esphome
 
-#endif  // USE_ESP32_FRAMEWORK_ARDUINO
+#endif  // USE_ESP32

esphome/components/font/__init__.py

@@ -7,7 +7,6 @@ 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
@@ -29,9 +28,11 @@ DOMAIN = "font"
 DEPENDENCIES = ["display"]
 MULTI_CONF = True
 
-Font = display.display_ns.class_("Font")
+font_ns = cg.esphome_ns.namespace("font")
-Glyph = display.display_ns.class_("Glyph")
+
-GlyphData = display.display_ns.struct("GlyphData")
+Font = font_ns.class_("Font")
+Glyph = font_ns.class_("Glyph")
+GlyphData = font_ns.struct("GlyphData")
 
 
 def validate_glyphs(value):

esphome/components/font/font.cpp

@@ -1,18 +1,35 @@
 #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 display {
+namespace font {
 
-bool Glyph::get_pixel(int x, int y) const {
+static const char *const TAG = "font";
-  const int x_data = x - this->glyph_data_->offset_x;
+
-  const int y_data = y - this->glyph_data_->offset_y;
+void Glyph::draw(int x_at, int y_start, display::DisplayBuffer *display, Color color) const {
-  if (x_data < 0 || x_data >= this->glyph_data_->width || y_data < 0 || y_data >= this->glyph_data_->height)
+  int scan_x1, scan_y1, scan_width, scan_height;
-    return false;
+  this->scan_area(&scan_x1, &scan_y1, &scan_width, &scan_height);
-  const uint32_t width_8 = ((this->glyph_data_->width + 7u) / 8u) * 8u;
+
-  const uint32_t pos = x_data + y_data * width_8;
+  const unsigned char *data = this->glyph_data_->data;
-  return progmem_read_byte(this->glyph_data_->data + (pos / 8u)) & (0x80 >> (pos % 8u));
+  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);
+        }
+      }
+    }
+  }
 }
 const char *Glyph::get_char() const { return this->glyph_data_->a_char; }
 bool Glyph::compare_to(const char *str) const {
@@ -47,6 +64,12 @@ 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;
@@ -95,11 +118,32 @@ void Font::measure(const char *str, int *width, int *x_offset, int *baseline, in
   *x_offset = min_x;
   *width = x - min_x;
 }
-Font::Font(const GlyphData *data, int data_nr, int baseline, int height) : baseline_(baseline), height_(height) {
+void Font::print(int x_start, int y_start, display::DisplayBuffer *display, Color color, const char *text) {
-  glyphs_.reserve(data_nr);
+  int i = 0;
-  for (int i = 0; i < data_nr; ++i)
+  int x_at = x_start;
-    glyphs_.emplace_back(&data[i]);
+  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;
+  }
 }
 
-}  // namespace display
+}  // namespace font
 }  // namespace esphome

esphome/components/font/font.h

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

esphome/components/graph/graph.h

@@ -11,7 +11,7 @@ namespace esphome {
 // forward declare DisplayBuffer
 namespace display {
 class DisplayBuffer;
-class Font;
+class BaseFont;
 }  // namespace display
 
 namespace graph {
@@ -45,8 +45,8 @@ enum ValuePositionType {
 class GraphLegend {
  public:
   void init(Graph *g);
-  void set_name_font(display::Font *font) { this->font_label_ = font; }
+  void set_name_font(display::BaseFont *font) { this->font_label_ = font; }
-  void set_value_font(display::Font *font) { this->font_value_ = font; }
+  void set_value_font(display::BaseFont *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::Font *font_label_{nullptr};
+  display::BaseFont *font_label_{nullptr};
-  display::Font *font_value_{nullptr};
+  display::BaseFont *font_value_{nullptr};
   // Calculated values
   Graph *parent_{nullptr};
   //                      (x0)          (xs,ys)         (xs,ys)

esphome/components/haier/__init__.py

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

esphome/components/haier/automation.h

@@ -0,0 +1,130 @@
+#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,43 +1,364 @@
-from esphome.components import climate
+import logging
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.components import uart
+import esphome.final_validate as fv
-from esphome.components.climate import ClimateSwingMode
+from esphome.components import uart, sensor, climate, logger
-from esphome.const import CONF_ID, CONF_SUPPORTED_SWING_MODES
+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,
+)
 
-DEPENDENCIES = ["uart"]
+_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]
 
 haier_ns = cg.esphome_ns.namespace("haier")
-HaierClimate = haier_ns.class_(
+HaierClimateBase = haier_ns.class_(
-    "HaierClimate", climate.Climate, cg.PollingComponent, uart.UARTDevice
+    "HaierClimateBase", uart.UARTDevice, climate.Climate, cg.Component
 )
+HonClimate = haier_ns.class_("HonClimate", HaierClimateBase)
+Smartair2Climate = haier_ns.class_("Smartair2Climate", HaierClimateBase)
 
-ALLOWED_CLIMATE_SWING_MODES = {
+
-    "BOTH": ClimateSwingMode.CLIMATE_SWING_BOTH,
+AirflowVerticalDirection = haier_ns.enum("AirflowVerticalDirection")
-    "VERTICAL": ClimateSwingMode.CLIMATE_SWING_VERTICAL,
+AIRFLOW_VERTICAL_DIRECTION_OPTIONS = {
-    "HORIZONTAL": ClimateSwingMode.CLIMATE_SWING_HORIZONTAL,
+    "UP": AirflowVerticalDirection.UP,
+    "CENTER": AirflowVerticalDirection.CENTER,
+    "DOWN": AirflowVerticalDirection.DOWN,
 }
 
-validate_swing_modes = cv.enum(ALLOWED_CLIMATE_SWING_MODES, upper=True)
+AirflowHorizontalDirection = haier_ns.enum("AirflowHorizontalDirection")
+AIRFLOW_HORIZONTAL_DIRECTION_OPTIONS = {
+    "LEFT": AirflowHorizontalDirection.LEFT,
+    "CENTER": AirflowHorizontalDirection.CENTER,
+    "RIGHT": AirflowHorizontalDirection.RIGHT,
+}
 
-CONFIG_SCHEMA = cv.All(
+SUPPORTED_SWING_MODES_OPTIONS = {
+    "OFF": ClimateSwingMode.CLIMATE_SWING_OFF,  # always available
+    "VERTICAL": ClimateSwingMode.CLIMATE_SWING_VERTICAL,  # always available
+    "HORIZONTAL": ClimateSwingMode.CLIMATE_SWING_HORIZONTAL,
+    "BOTH": ClimateSwingMode.CLIMATE_SWING_BOTH,
+}
+
+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.GenerateID(): cv.declare_id(HaierClimate),
+            cv.Optional(CONF_SUPPORTED_MODES): cv.ensure_list(
-            cv.Optional(CONF_SUPPORTED_SWING_MODES): cv.ensure_list(
+                cv.enum(SUPPORTED_CLIMATE_MODES_OPTIONS, upper=True)
-                validate_swing_modes
             ),
+            cv.Optional(
+                CONF_SUPPORTED_SWING_MODES,
+                default=[
+                    "OFF",
+                    "VERTICAL",
+                    "HORIZONTAL",
+                    "BOTH",
+                ],
+            ): cv.ensure_list(cv.enum(SUPPORTED_SWING_MODES_OPTIONS, upper=True)),
         }
     )
-    .extend(cv.polling_component_schema("5s"))
+    .extend(uart.UART_DEVICE_SCHEMA)
-    .extend(uart.UART_DEVICE_SCHEMA),
+    .extend(cv.COMPONENT_SCHEMA)
 )
 
+CONFIG_SCHEMA = cv.All(
+    cv.typed_schema(
+        {
+            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)
+            ),
+        }
+    ),
+)
+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)
+            ),
+        }
+    ),
+)
+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 climate.register_climate(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]))
     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

@@ -1,302 +0,0 @@
-#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

@@ -1,37 +0,0 @@
-#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

@@ -0,0 +1,311 @@
+#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

@@ -0,0 +1,142 @@
+#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

@@ -0,0 +1,857 @@
+#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

@@ -0,0 +1,95 @@
+#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

@@ -0,0 +1,228 @@
+#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

@@ -0,0 +1,33 @@
+#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

@@ -0,0 +1,14 @@
+#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

@@ -0,0 +1,457 @@
+#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

@@ -0,0 +1,31 @@
+#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

@@ -0,0 +1,97 @@
+#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,6 +14,14 @@ 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;
@@ -23,6 +31,16 @@ 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;
@@ -60,5 +78,26 @@ 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,6 +31,25 @@ 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); }
@@ -44,12 +63,15 @@ 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 display, font
+from esphome.components import font
 import esphome.config_validation as cv
 import esphome.codegen as cg
 from esphome.const import (
@@ -28,7 +28,9 @@ DOMAIN = "image"
 DEPENDENCIES = ["display"]
 MULTI_CONF = True
 
-ImageType = display.display_ns.enum("ImageType")
+image_ns = cg.esphome_ns.namespace("image")
+
+ImageType = image_ns.enum("ImageType")
 IMAGE_TYPE = {
     "BINARY": ImageType.IMAGE_TYPE_BINARY,
     "TRANSPARENT_BINARY": ImageType.IMAGE_TYPE_BINARY,
@@ -46,7 +48,7 @@ MDI_DOWNLOAD_TIMEOUT = 30  # seconds
 SOURCE_LOCAL = "local"
 SOURCE_MDI = "mdi"
 
-Image_ = display.display_ns.class_("Image")
+Image_ = image_ns.class_("Image")
 
 
 def _compute_local_icon_path(value) -> Path:

esphome/components/image/image.cpp

@@ -1,12 +1,11 @@
 #include "image.h"
 
 #include "esphome/core/hal.h"
-#include "display_buffer.h"
 
 namespace esphome {
-namespace display {
+namespace image {
 
-void Image::draw(int x, int y, DisplayBuffer *display, Color color_on, Color color_off) {
+void Image::draw(int x, int y, display::DisplayBuffer *display, Color color_on, Color color_off) {
   switch (type_) {
     case IMAGE_TYPE_BINARY: {
       for (int img_x = 0; img_x < width_; img_x++) {
@@ -131,5 +130,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 display
+}  // namespace image
 }  // namespace esphome

esphome/components/image/image.h

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

esphome/components/mqtt/mqtt_backend_idf.cpp

@@ -11,6 +11,7 @@ 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;
 
@@ -47,6 +48,41 @@ 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);
@@ -78,9 +114,8 @@ 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(!mqtt_cfg_.disable_clean_session);
+      this->on_connect_.call(event.session_present);
       break;
     case MQTT_EVENT_DISCONNECTED:
       ESP_LOGV(TAG, "MQTT_EVENT_DISCONNECTED");

esphome/components/mqtt/mqtt_backend_idf.h

@@ -22,6 +22,7 @@ struct Event {
   bool retain;
   int qos;
   bool dup;
+  bool session_present;
   esp_mqtt_error_codes_t error_handle;
 
   // Construct from esp_mqtt_event_t
@@ -36,6 +37,7 @@ 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, "%08x", fnv1_hash(this->friendly_name()));
+            sprintf(friendly_name_hash, "%08" PRIx32, 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,3 +1,4 @@
+#include <cinttypes>
 #include "mqtt_sensor.h"
 #include "esphome/core/log.h"
 
@@ -26,7 +27,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: %us", this->get_expire_after() / 1000);
+    ESP_LOGCONFIG(TAG, "  Expire After: %" PRIu32 "s", this->get_expire_after() / 1000);
   }
   LOG_MQTT_COMPONENT(true, false)
 }

esphome/components/rp2040/__init__.py

@@ -16,8 +16,7 @@ from esphome.const import (
     KEY_TARGET_PLATFORM,
 )
 from esphome.core import CORE, coroutine_with_priority, EsphomeError
-from esphome.helpers import mkdir_p, write_file
+from esphome.helpers import mkdir_p, write_file, copy_file_if_changed
-import esphome.platformio_api as api
 
 from .const import KEY_BOARD, KEY_PIO_FILES, KEY_RP2040, rp2040_ns
 
@@ -193,25 +192,20 @@ def generate_pio_files() -> bool:
         pio_path = CORE.relative_build_path(f"src/pio/{key}.pio")
         mkdir_p(os.path.dirname(pio_path))
         write_file(pio_path, data)
-        _LOGGER.info("Assembling PIO assembly code")
-        retval = api.run_platformio_cli(
-            "pkg",
-            "exec",
-            "--package",
-            "earlephilhower/tool-pioasm-rp2040-earlephilhower",
-            "--",
-            "pioasm",
-            pio_path,
-            pio_path + ".h",
-        )
         includes.append(f"pio/{key}.pio.h")
-        if retval != 0:
-            raise EsphomeError("PIO assembly failed")
 
     write_file(
         CORE.relative_build_path("src/pio_includes.h"),
         "#pragma once\n" + "\n".join([f'#include "{include}"' for include in includes]),
     )
+
+    dir = os.path.dirname(__file__)
+    build_pio_file = os.path.join(dir, "build_pio.py.script")
+    copy_file_if_changed(
+        build_pio_file,
+        CORE.relative_build_path("build_pio.py"),
+    )
+
     return True
 
 

esphome/components/rp2040/build_pio.py.script

@@ -0,0 +1,47 @@
+"""
+Custom pioasm compiler script for platformio.
+(c) 2022 by P.Z.
+
+Sourced 2023/06/23 from https://gist.github.com/hexeguitar/f4533bc697c956ac1245b6843e2ef438
+
+Modified by jesserockz 2023/06/23
+"""
+
+from os.path import join
+import glob
+import sys
+
+import subprocess
+
+# pylint: disable=E0602
+Import("env")  # noqa
+
+from SCons.Script import ARGUMENTS
+
+
+platform = env.PioPlatform()
+PROJ_SRC = env["PROJECT_SRC_DIR"]
+PIO_FILES = glob.glob(join(PROJ_SRC, "**", "*.pio"), recursive=True)
+
+verbose = bool(int(ARGUMENTS.get("PIOVERBOSE", "0")))
+
+
+if PIO_FILES:
+    if verbose:
+        print("==============================================")
+        print("PIO ASSEMBLY COMPILER")
+    try:
+        PIOASM_DIR = platform.get_package_dir("tool-pioasm-rp2040-earlephilhower")
+    except:
+        print("tool-pioasm-rp2040-earlephilhower not supported on your system!")
+        sys.exit()
+
+    PIOASM_EXE = join(PIOASM_DIR, "pioasm")
+    if verbose:
+        print("PIO files found:")
+    for filename in PIO_FILES:
+        if verbose:
+            print(f"  {filename}")
+        subprocess.run([PIOASM_EXE, "-o", "c-sdk", filename, f"{filename}.h"])
+    if verbose:
+        print("==============================================")

esphome/components/rp2040_pio/__init__.py

@@ -0,0 +1,40 @@
+import platform
+
+import esphome.codegen as cg
+
+
+DEPENDENCIES = ["rp2040"]
+
+
+PIOASM_REPO_VERSION = "1.5.0-b"
+PIOASM_REPO_BASE = f"https://github.com/earlephilhower/pico-quick-toolchain/releases/download/{PIOASM_REPO_VERSION}"
+PIOASM_VERSION = "pioasm-2e6142b.230216"
+PIOASM_DOWNLOADS = {
+    "linux": {
+        "aarch64": f"aarch64-linux-gnu.{PIOASM_VERSION}.tar.gz",
+        "armv7l": f"arm-linux-gnueabihf.{PIOASM_VERSION}.tar.gz",
+        "x86_64": f"x86_64-linux-gnu.{PIOASM_VERSION}.tar.gz",
+    },
+    "windows": {
+        "amd64": f"x86_64-w64-mingw32.{PIOASM_VERSION}.zip",
+    },
+    "darwin": {
+        "x86_64": f"x86_64-apple-darwin14.{PIOASM_VERSION}.tar.gz",
+        "arm64": f"x86_64-apple-darwin14.{PIOASM_VERSION}.tar.gz",
+    },
+}
+
+
+async def to_code(config):
+    # cg.add_platformio_option(
+    #     "platform_packages",
+    #     [
+    #         "earlephilhower/tool-pioasm-rp2040-earlephilhower",
+    #     ],
+    # )
+    file = PIOASM_DOWNLOADS[platform.system().lower()][platform.machine().lower()]
+    cg.add_platformio_option(
+        "platform_packages",
+        [f"earlephilhower/tool-pioasm-rp2040-earlephilhower@{PIOASM_REPO_BASE}/{file}"],
+    )
+    cg.add_platformio_option("extra_scripts", ["pre:build_pio.py"])

esphome/components/rp2040_pio_led_strip/light.py

@@ -127,6 +127,7 @@ def time_to_cycles(time_us):
 
 CONF_PIO = "pio"
 
+AUTO_LOAD = ["rp2040_pio"]
 CODEOWNERS = ["@Papa-DMan"]
 DEPENDENCIES = ["rp2040"]
 
@@ -265,9 +266,3 @@ async def to_code(config):
                 time_to_cycles(config[CONF_BIT1_LOW]),
             ),
         )
-    cg.add_platformio_option(
-        "platform_packages",
-        [
-            "earlephilhower/tool-pioasm-rp2040-earlephilhower",
-        ],
-    )

esphome/components/socket/__init__.py

@@ -1,5 +1,6 @@
 import esphome.config_validation as cv
 import esphome.codegen as cg
+from esphome.core import CORE
 
 CODEOWNERS = ["@esphome/core"]
 
@@ -28,3 +29,6 @@ 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,6 +53,43 @@ 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

@@ -0,0 +1,34 @@
+#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,6 +8,7 @@
 
 #define LWIP_INTERNAL
 #include "lwip/inet.h"
+#include "lwip/netdb.h"
 #include <cerrno>
 #include <cstdint>
 #include <sys/types.h>
@@ -118,6 +119,34 @@ 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
@@ -129,6 +158,7 @@ struct iovec {
 #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

@@ -0,0 +1,197 @@
+#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 0;
+      return -1;
     }
     ip_addr_t ip;
     in_port_t port;
@@ -126,6 +126,76 @@ 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;
@@ -369,9 +439,10 @@ 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;
@@ -433,9 +504,10 @@ 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)
@@ -448,18 +520,20 @@ 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)
@@ -528,6 +602,18 @@ 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);
@@ -544,6 +630,11 @@ 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) {
@@ -594,6 +685,9 @@ 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) {
-#if LWIP_IPV6
+#ifdef USE_SOCKET_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 LWIP_IPV6
+#if USE_SOCKET_IPV6
   if (addrlen < sizeof(sockaddr_in6)) {
     errno = EINVAL;
     return 0;

esphome/components/socket/socket.h

@@ -5,6 +5,12 @@
 #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 {
 
@@ -17,10 +23,17 @@ 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

@@ -0,0 +1,99 @@
+#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,7 +58,9 @@ 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;
 };
@@ -82,8 +84,10 @@ 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) {
@@ -504,7 +508,9 @@ 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:
@@ -644,9 +650,11 @@ 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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,122 @@
+#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

@@ -0,0 +1,54 @@
+#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.6.0b7"
+__version__ = "2023.7.0-dev"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (

esphome/core/defines.h

@@ -85,6 +85,7 @@
 #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
@@ -94,6 +95,7 @@
 #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

esphome/core/time.cpp

@@ -2,6 +2,16 @@
 
 namespace esphome {
 
+static bool is_leap_year(uint32_t year) { return (year % 4) == 0 && ((year % 100) != 0 || (year % 400) == 0); }
+
+static uint8_t days_in_month(uint8_t month, uint16_t year) {
+  static const uint8_t DAYS_IN_MONTH[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+  uint8_t days = DAYS_IN_MONTH[month];
+  if (month == 2 && is_leap_year(year))
+    return 29;
+  return days;
+}
+
 size_t ESPTime::strftime(char *buffer, size_t buffer_len, const char *format) {
   struct tm c_tm = this->to_c_tm();
   return ::strftime(buffer, buffer_len, format, &c_tm);
@@ -158,14 +168,4 @@ template<typename T> bool increment_time_value(T &current, uint16_t begin, uint1
   return false;
 }
 
-static bool is_leap_year(uint32_t year) { return (year % 4) == 0 && ((year % 100) != 0 || (year % 400) == 0); }
-
-static uint8_t days_in_month(uint8_t month, uint16_t year) {
-  static const uint8_t DAYS_IN_MONTH[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
-  uint8_t days = DAYS_IN_MONTH[month];
-  if (month == 2 && is_leap_year(year))
-    return 29;
-  return days;
-}
-
 }  // namespace esphome

esphome/core/time.h

@@ -8,10 +8,6 @@ namespace esphome {
 
 template<typename T> bool increment_time_value(T &current, uint16_t begin, uint16_t end);
 
-static bool is_leap_year(uint32_t year);
-
-static uint8_t days_in_month(uint8_t month, uint16_t year);
-
 /// A more user-friendly version of struct tm from time.h
 struct ESPTime {
   /** seconds after the minute [0-60]

platformio.ini

@@ -39,6 +39,7 @@ 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 =
@@ -61,7 +62,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.5                                       ; dsmr
+    glmnet/Dsmr@0.7                                       ; 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==14.0.0
+aioesphomeapi==15.0.0
-zeroconf==0.63.0
+zeroconf==0.69.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.4.0  # also change in .pre-commit-config.yaml when updating
+pyupgrade==3.7.0  # also change in .pre-commit-config.yaml when updating
 pre-commit
 
 # Unit tests
-pytest==7.3.1
+pytest==7.4.0
 pytest-cov==4.1.0
 pytest-mock==3.10.0
 pytest-asyncio==0.21.0

script/build_language_schema.py

@@ -461,8 +461,10 @@ 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)
-    return schema_name == "microphone.MICROPHONE_SCHEMA"
+    component = schema_name.split(".")[0]
+    return component in components and components[component].is_platform_component
 
 
 def shrink():
@@ -530,6 +532,10 @@ 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,13 +944,29 @@ climate:
       kd_multiplier: 0.0
       deadband_output_averaging_samples: 1
   - platform: haier
+    protocol: hOn
     name: Haier AC
-    supported_swing_modes:
-      - vertical
-      - horizontal
-      - both
-    update_interval: 10s
     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
 
 sprinkler:
   - id: yard_sprinkler_ctrlr

tests/test4.yaml

@@ -384,6 +384,15 @@ 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
@@ -745,3 +754,7 @@ voice_assistant:
 max6956:
   - id: max6956_1
     address: 0x40
+
+xl9535:
+  - id: xl9535_hub
+    address: 0x20