Improvement pipsolar crc (#3316)

Co-authored-by: Andreas <andreas.hergert@otrs.com>

.github/dependabot.yml

@@ -7,3 +7,8 @@ updates:
     ignore:
       # Hypotehsis is only used for testing and is updated quite often
       - dependency-name: hypothesis
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: daily
+    open-pull-requests-limit: 10

.github/workflows/ci-docker.yml

@@ -30,15 +30,15 @@ jobs:
         arch: [amd64, armv7, aarch64]
         build_type: ["ha-addon", "docker", "lint"]
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
         python-version: '3.9'
     - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v1
+      uses: docker/setup-buildx-action@v2
     - name: Set up QEMU
-      uses: docker/setup-qemu-action@v1
+      uses: docker/setup-qemu-action@v2
 
     - name: Set TAG
       run: |

.github/workflows/ci.yml

@@ -75,15 +75,15 @@ jobs:
             pio_cache_key: tidyesp32-idf
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Set up Python
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v4
         id: python
         with:
           python-version: '3.8'
 
       - name: Cache virtualenv
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: .venv
           key: venv-${{ steps.python.outputs.python-version }}-${{ hashFiles('requirements*.txt') }}
@@ -102,7 +102,7 @@ jobs:
 
       # Use per check platformio cache because checks use different parts
       - name: Cache platformio
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: ~/.platformio
           key: platformio-${{ matrix.pio_cache_key }}-${{ hashFiles('platformio.ini') }}

.github/workflows/release.yml

@@ -17,7 +17,7 @@ jobs:
     outputs:
       tag: ${{ steps.tag.outputs.tag }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Get tag
         id: tag
         run: |
@@ -35,9 +35,9 @@ jobs:
     if: github.repository == 'esphome/esphome' && github.event_name == 'release'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Set up Python
-        uses: actions/setup-python@v1
+        uses: actions/setup-python@v4
         with:
           python-version: '3.x'
       - name: Set up python environment
@@ -65,24 +65,24 @@ jobs:
         arch: [amd64, armv7, aarch64]
         build_type: ["ha-addon", "docker", "lint"]
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
         python-version: '3.9'
 
     - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v1
+      uses: docker/setup-buildx-action@v2
     - name: Set up QEMU
-      uses: docker/setup-qemu-action@v1
+      uses: docker/setup-qemu-action@v2
 
     - name: Log in to docker hub
-      uses: docker/login-action@v1
+      uses: docker/login-action@v2
       with:
         username: ${{ secrets.DOCKER_USER }}
         password: ${{ secrets.DOCKER_PASSWORD }}
     - name: Log in to the GitHub container registry
-      uses: docker/login-action@v1
+      uses: docker/login-action@v2
       with:
           registry: ghcr.io
           username: ${{ github.actor }}
@@ -108,9 +108,9 @@ jobs:
       matrix:
         build_type: ["ha-addon", "docker", "lint"]
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
         python-version: '3.9'
     - name: Enable experimental manifest support
@@ -119,12 +119,12 @@ jobs:
         echo "{\"experimental\": \"enabled\"}" > ~/.docker/config.json
 
     - name: Log in to docker hub
-      uses: docker/login-action@v1
+      uses: docker/login-action@v2
       with:
         username: ${{ secrets.DOCKER_USER }}
         password: ${{ secrets.DOCKER_PASSWORD }}
     - name: Log in to the GitHub container registry
-      uses: docker/login-action@v1
+      uses: docker/login-action@v2
       with:
           registry: ghcr.io
           username: ${{ github.actor }}

.github/workflows/stale.yml

@@ -16,7 +16,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v4
+      - uses: actions/stale@v5
         with:
           days-before-pr-stale: 90
           days-before-pr-close: 7
@@ -35,7 +35,7 @@ jobs:
   close-issues:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v4
+      - uses: actions/stale@v5
         with:
           days-before-pr-stale: -1
           days-before-pr-close: -1

.pre-commit-config.yaml

@@ -2,7 +2,7 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/ambv/black
-    rev: 22.3.0
+    rev: 22.6.0
     hooks:
     - id: black
       args:
@@ -26,7 +26,7 @@ repos:
           - --branch=release
           - --branch=beta
   - repo: https://github.com/asottile/pyupgrade
-    rev: v2.31.1
+    rev: v2.34.0
     hooks:
       - id: pyupgrade
         args: [--py38-plus]

CODEOWNERS

@@ -52,14 +52,17 @@ esphome/components/cs5460a/* @balrog-kun
 esphome/components/cse7761/* @berfenger
 esphome/components/ct_clamp/* @jesserockz
 esphome/components/current_based/* @djwmarcx
+esphome/components/dac7678/* @NickB1
 esphome/components/daly_bms/* @s1lvi0
 esphome/components/dashboard_import/* @esphome/core
 esphome/components/debug/* @OttoWinter
+esphome/components/delonghi/* @grob6000
 esphome/components/dfplayer/* @glmnet
 esphome/components/dht/* @OttoWinter
 esphome/components/ds1307/* @badbadc0ffee
 esphome/components/dsmr/* @glmnet @zuidwijk
 esphome/components/ektf2232/* @jesserockz
+esphome/components/ens210/* @itn3rd77
 esphome/components/esp32/* @esphome/core
 esphome/components/esp32_ble/* @jesserockz
 esphome/components/esp32_ble_server/* @jesserockz
@@ -86,6 +89,7 @@ esphome/components/honeywellabp/* @RubyBailey
 esphome/components/hrxl_maxsonar_wr/* @netmikey
 esphome/components/hydreon_rgxx/* @functionpointer
 esphome/components/i2c/* @esphome/core
+esphome/components/i2s_audio/* @jesserockz
 esphome/components/improv_serial/* @esphome/core
 esphome/components/ina260/* @MrEditor97
 esphome/components/inkbird_ibsth1_mini/* @fkirill
@@ -100,6 +104,7 @@ esphome/components/lilygo_t5_47/touchscreen/* @jesserockz
 esphome/components/lock/* @esphome/core
 esphome/components/logger/* @esphome/core
 esphome/components/ltr390/* @sjtrny
+esphome/components/max31865/* @DAVe3283
 esphome/components/max44009/* @berfenger
 esphome/components/max7219digit/* @rspaargaren
 esphome/components/max9611/* @mckaymatthew
@@ -117,6 +122,7 @@ esphome/components/mcp47a1/* @jesserockz
 esphome/components/mcp9808/* @k7hpn
 esphome/components/md5/* @esphome/core
 esphome/components/mdns/* @esphome/core
+esphome/components/media_player/* @jesserockz
 esphome/components/midea/* @dudanov
 esphome/components/midea_ir/* @dudanov
 esphome/components/mitsubishi/* @RubyBailey
@@ -166,23 +172,27 @@ esphome/components/rf_bridge/* @jesserockz
 esphome/components/rgbct/* @jesserockz
 esphome/components/rtttl/* @glmnet
 esphome/components/safe_mode/* @jsuanet @paulmonigatti
-esphome/components/scd4x/* @sjtrny
+esphome/components/scd4x/* @martgras @sjtrny
 esphome/components/script/* @esphome/core
 esphome/components/sdm_meter/* @jesserockz @polyfaces
 esphome/components/sdp3x/* @Azimath
 esphome/components/selec_meter/* @sourabhjaiswal
 esphome/components/select/* @esphome/core
+esphome/components/sen5x/* @martgras
 esphome/components/sensirion_common/* @martgras
 esphome/components/sensor/* @esphome/core
 esphome/components/sgp40/* @SenexCrenshaw
+esphome/components/sgp4x/* @SenexCrenshaw @martgras
 esphome/components/shelly_dimmer/* @edge90 @rnauber
 esphome/components/sht4x/* @sjtrny
 esphome/components/shutdown/* @esphome/core @jsuanet
 esphome/components/sim800l/* @glmnet
 esphome/components/sm2135/* @BoukeHaarsma23
+esphome/components/sml/* @alengwenus
 esphome/components/socket/* @esphome/core
 esphome/components/sonoff_d1/* @anatoly-savchenkov
 esphome/components/spi/* @esphome/core
+esphome/components/sps30/* @martgras
 esphome/components/ssd1322_base/* @kbx81
 esphome/components/ssd1322_spi/* @kbx81
 esphome/components/ssd1325_base/* @kbx81
@@ -217,6 +227,7 @@ esphome/components/tsl2591/* @wjcarpenter
 esphome/components/tuya/binary_sensor/* @jesserockz
 esphome/components/tuya/climate/* @jesserockz
 esphome/components/tuya/number/* @frankiboy1
+esphome/components/tuya/select/* @bearpawmaxim
 esphome/components/tuya/sensor/* @jesserockz
 esphome/components/tuya/switch/* @jesserockz
 esphome/components/tuya/text_sensor/* @dentra

docker/Dockerfile

@@ -30,6 +30,7 @@ RUN \
         iputils-ping=3:20210202-1 \
         git=1:2.30.2-1 \
         curl=7.74.0-1.3+deb11u1 \
+        openssh-client=1:8.4p1-5 \
     && rm -rf \
         /tmp/* \
         /var/{cache,log}/* \
@@ -45,12 +46,10 @@ RUN \
     # Ubuntu python3-pip is missing wheel
     pip3 install --no-cache-dir \
         wheel==0.37.1 \
-        platformio==5.2.5 \
+        platformio==6.0.2 \
     # Change some platformio settings
     && platformio settings set enable_telemetry No \
-    && platformio settings set check_libraries_interval 1000000 \
     && platformio settings set check_platformio_interval 1000000 \
-    && platformio settings set check_platforms_interval 1000000 \
     && mkdir -p /piolibs
 
 

esphome/__main__.py

@@ -2,6 +2,7 @@ import argparse
 import functools
 import logging
 import os
+import re
 import sys
 from datetime import datetime
 
@@ -9,15 +10,18 @@ from esphome import const, writer, yaml_util
 import esphome.codegen as cg
 from esphome.config import iter_components, read_config, strip_default_ids
 from esphome.const import (
+    ALLOWED_NAME_CHARS,
     CONF_BAUD_RATE,
     CONF_BROKER,
     CONF_DEASSERT_RTS_DTR,
     CONF_LOGGER,
+    CONF_NAME,
     CONF_OTA,
     CONF_PASSWORD,
     CONF_PORT,
     CONF_ESPHOME,
     CONF_PLATFORMIO_OPTIONS,
+    CONF_SUBSTITUTIONS,
     SECRETS_FILES,
 )
 from esphome.core import CORE, EsphomeError, coroutine
@@ -481,6 +485,98 @@ def command_idedata(args, config):
     return 0
 
 
+def command_rename(args, config):
+    for c in args.name:
+        if c not in ALLOWED_NAME_CHARS:
+            print(
+                color(
+                    Fore.BOLD_RED,
+                    f"'{c}' is an invalid character for names. Valid characters are: "
+                    f"{ALLOWED_NAME_CHARS} (lowercase, no spaces)",
+                )
+            )
+            return 1
+    # Load existing yaml file
+    with open(CORE.config_path, mode="r+", encoding="utf-8") as raw_file:
+        raw_contents = raw_file.read()
+
+    yaml = yaml_util.load_yaml(CORE.config_path)
+    if CONF_ESPHOME not in yaml or CONF_NAME not in yaml[CONF_ESPHOME]:
+        print(
+            color(Fore.BOLD_RED, "Complex YAML files cannot be automatically renamed.")
+        )
+        return 1
+    old_name = yaml[CONF_ESPHOME][CONF_NAME]
+    match = re.match(r"^\$\{?([a-zA-Z0-9_]+)\}?$", old_name)
+    if match is None:
+        new_raw = re.sub(
+            rf"name:\s+[\"']?{old_name}[\"']?",
+            f'name: "{args.name}"',
+            raw_contents,
+        )
+    else:
+        old_name = yaml[CONF_SUBSTITUTIONS][match.group(1)]
+        if (
+            len(
+                re.findall(
+                    rf"^\s+{match.group(1)}:\s+[\"']?{old_name}[\"']?",
+                    raw_contents,
+                    flags=re.MULTILINE,
+                )
+            )
+            > 1
+        ):
+            print(color(Fore.BOLD_RED, "Too many matches in YAML to safely rename"))
+            return 1
+
+        new_raw = re.sub(
+            rf"^(\s+{match.group(1)}):\s+[\"']?{old_name}[\"']?",
+            f'\\1: "{args.name}"',
+            raw_contents,
+            flags=re.MULTILINE,
+        )
+
+    new_path = os.path.join(CORE.config_dir, args.name + ".yaml")
+    print(
+        f"Updating {color(Fore.CYAN, CORE.config_path)} to {color(Fore.CYAN, new_path)}"
+    )
+    print()
+
+    with open(new_path, mode="w", encoding="utf-8") as new_file:
+        new_file.write(new_raw)
+
+    rc = run_external_process("esphome", "config", new_path)
+    if rc != 0:
+        print(color(Fore.BOLD_RED, "Rename failed. Reverting changes."))
+        os.remove(new_path)
+        return 1
+
+    cli_args = [
+        "run",
+        new_path,
+        "--no-logs",
+        "--device",
+        CORE.address,
+    ]
+
+    if args.dashboard:
+        cli_args.insert(0, "--dashboard")
+
+    try:
+        rc = run_external_process("esphome", *cli_args)
+    except KeyboardInterrupt:
+        rc = 1
+    if rc != 0:
+        os.remove(new_path)
+        return 1
+
+    os.remove(CORE.config_path)
+
+    print(color(Fore.BOLD_GREEN, "SUCCESS"))
+    print()
+    return 0
+
+
 PRE_CONFIG_ACTIONS = {
     "wizard": command_wizard,
     "version": command_version,
@@ -499,6 +595,7 @@ POST_CONFIG_ACTIONS = {
     "mqtt-fingerprint": command_mqtt_fingerprint,
     "clean": command_clean,
     "idedata": command_idedata,
+    "rename": command_rename,
 }
 
 
@@ -681,6 +778,15 @@ def parse_args(argv):
         "configuration", help="Your YAML configuration file(s).", nargs=1
     )
 
+    parser_rename = subparsers.add_parser(
+        "rename",
+        help="Rename a device in YAML, compile the binary and upload it.",
+    )
+    parser_rename.add_argument(
+        "configuration", help="Your YAML configuration file.", nargs=1
+    )
+    parser_rename.add_argument("name", help="The new name for the device.", type=str)
+
     # Keep backward compatibility with the old command line format of
     # esphome <config> <command>.
     #

esphome/automation.py

@@ -12,7 +12,7 @@ from esphome.const import (
     CONF_TYPE_ID,
     CONF_TIME,
 )
-from esphome.jsonschema import jschema_extractor
+from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
 from esphome.util import Registry
 
 
@@ -23,11 +23,10 @@ def maybe_simple_id(*validators):
 def maybe_conf(conf, *validators):
     validator = cv.All(*validators)
 
-    @jschema_extractor("maybe")
+    @schema_extractor("maybe")
     def validate(value):
-        # pylint: disable=comparison-with-callable
-        if value == jschema_extractor:
-            return validator
+        if value == SCHEMA_EXTRACT:
+            return (validator, conf)
 
         if isinstance(value, dict):
             return validator(value)
@@ -111,11 +110,9 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
         # This should only happen with invalid configs, but let's have a nice error message.
         return [schema(value)]
 
-    @jschema_extractor("automation")
+    @schema_extractor("automation")
     def validator(value):
-        # hack to get the schema
-        # pylint: disable=comparison-with-callable
-        if value == jschema_extractor:
+        if value == SCHEMA_EXTRACT:
             return schema
 
         value = validator_(value)

esphome/codegen.py

@@ -64,6 +64,7 @@ from esphome.cpp_types import (  # noqa
     uint64,
     int32,
     int64,
+    size_t,
     const_char_ptr,
     NAN,
     esphome_ns,

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -121,7 +121,11 @@ void IRAM_ATTR HOT AcDimmerDataStore::gpio_intr() {
       // calculate time until enable in µs: (1.0-value)*cycle_time, but with integer arithmetic
       // also take into account min_power
       auto min_us = this->cycle_time_us * this->min_power / 1000;
-      this->enable_time_us = std::max((uint32_t) 1, ((65535 - this->value) * (this->cycle_time_us - min_us)) / 65535);
+      // calculate required value to provide a true RMS voltage output
+      this->enable_time_us =
+          std::max((uint32_t) 1, (uint32_t)((65535 - (acos(1 - (2 * this->value / 65535.0)) / 3.14159 * 65535)) *
+                                            (this->cycle_time_us - min_us)) /
+                                     65535);
       if (this->method == DIM_METHOD_LEADING_PULSE) {
         // Minimum pulse time should be enough for the triac to trigger when it is close to the ZC zone
         // this is for brightness near 99%

esphome/components/adc/adc_sensor.cpp

@@ -15,10 +15,21 @@ namespace esphome {
 namespace adc {
 
 static const char *const TAG = "adc";
-// 13 bits for S3 / 12 bit for all other esp32 variants
-// create a const to avoid the repated cast to enum
+
+// 13bit for S2, and 12bit for all other esp32 variants
 #ifdef USE_ESP32
 static const adc_bits_width_t ADC_WIDTH_MAX_SOC_BITS = static_cast<adc_bits_width_t>(ADC_WIDTH_MAX - 1);
+
+#ifndef SOC_ADC_RTC_MAX_BITWIDTH
+#if USE_ESP32_VARIANT_ESP32S2
+static const int SOC_ADC_RTC_MAX_BITWIDTH = 13;
+#else
+static const int SOC_ADC_RTC_MAX_BITWIDTH = 12;
+#endif
+#endif
+
+static const int ADC_MAX = (1 << SOC_ADC_RTC_MAX_BITWIDTH) - 1;    // 4095 (12 bit) or 8191 (13 bit)
+static const int ADC_HALF = (1 << SOC_ADC_RTC_MAX_BITWIDTH) >> 1;  // 2048 (12 bit) or 4096 (13 bit)
 #endif
 
 void ADCSensor::setup() {
@@ -51,8 +62,8 @@ void ADCSensor::setup() {
     }
   }
 
-  // adc_gpio_init doesn't exist on ESP32-C3 or ESP32-H2
-#if !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32H2)
+  // adc_gpio_init doesn't exist on ESP32-S2, ESP32-C3 or ESP32-H2
+#if !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32H2) && !defined(USE_ESP32_VARIANT_ESP32S2)
   adc_gpio_init(ADC_UNIT_1, (adc_channel_t) channel_);
 #endif
 #endif  // USE_ESP32
@@ -75,16 +86,16 @@ void ADCSensor::dump_config() {
   } else {
     switch (this->attenuation_) {
       case ADC_ATTEN_DB_0:
-        ESP_LOGCONFIG(TAG, " Attenuation: 0db (max 1.1V)");
+        ESP_LOGCONFIG(TAG, " Attenuation: 0db");
         break;
       case ADC_ATTEN_DB_2_5:
-        ESP_LOGCONFIG(TAG, " Attenuation: 2.5db (max 1.5V)");
+        ESP_LOGCONFIG(TAG, " Attenuation: 2.5db");
         break;
       case ADC_ATTEN_DB_6:
-        ESP_LOGCONFIG(TAG, " Attenuation: 6db (max 2.2V)");
+        ESP_LOGCONFIG(TAG, " Attenuation: 6db");
         break;
       case ADC_ATTEN_DB_11:
-        ESP_LOGCONFIG(TAG, " Attenuation: 11db (max 3.9V)");
+        ESP_LOGCONFIG(TAG, " Attenuation: 11db");
         break;
       default:  // This is to satisfy the unused ADC_ATTEN_MAX
         break;
@@ -129,16 +140,16 @@ float ADCSensor::sample() {
     return mv / 1000.0f;
   }
 
-  int raw11, raw6 = 4095, raw2 = 4095, raw0 = 4095;
+  int raw11, raw6 = ADC_MAX, raw2 = ADC_MAX, raw0 = ADC_MAX;
   adc1_config_channel_atten(channel_, ADC_ATTEN_DB_11);
   raw11 = adc1_get_raw(channel_);
-  if (raw11 < 4095) {
+  if (raw11 < ADC_MAX) {
     adc1_config_channel_atten(channel_, ADC_ATTEN_DB_6);
     raw6 = adc1_get_raw(channel_);
-    if (raw6 < 4095) {
+    if (raw6 < ADC_MAX) {
       adc1_config_channel_atten(channel_, ADC_ATTEN_DB_2_5);
       raw2 = adc1_get_raw(channel_);
-      if (raw2 < 4095) {
+      if (raw2 < ADC_MAX) {
         adc1_config_channel_atten(channel_, ADC_ATTEN_DB_0);
         raw0 = adc1_get_raw(channel_);
       }
@@ -154,15 +165,15 @@ float ADCSensor::sample() {
   uint32_t mv2 = esp_adc_cal_raw_to_voltage(raw2, &cal_characteristics_[(int) ADC_ATTEN_DB_2_5]);
   uint32_t mv0 = esp_adc_cal_raw_to_voltage(raw0, &cal_characteristics_[(int) ADC_ATTEN_DB_0]);
 
-  // Contribution of each value, in range 0-2048
-  uint32_t c11 = std::min(raw11, 2048);
-  uint32_t c6 = 2048 - std::abs(raw6 - 2048);
-  uint32_t c2 = 2048 - std::abs(raw2 - 2048);
-  uint32_t c0 = std::min(4095 - raw0, 2048);
-  // max theoretical csum value is 2048*4 = 8192
+  // Contribution of each value, in range 0-2048 (12 bit ADC) or 0-4096 (13 bit ADC)
+  uint32_t c11 = std::min(raw11, ADC_HALF);
+  uint32_t c6 = ADC_HALF - std::abs(raw6 - ADC_HALF);
+  uint32_t c2 = ADC_HALF - std::abs(raw2 - ADC_HALF);
+  uint32_t c0 = std::min(ADC_MAX - raw0, ADC_HALF);
+  // max theoretical csum value is 4096*4 = 16384
   uint32_t csum = c11 + c6 + c2 + c0;
 
-  // each mv is max 3900; so max value is 3900*2048*4, fits in unsigned
+  // each mv is max 3900; so max value is 3900*4096*4, fits in unsigned32
   uint32_t mv_scaled = (mv11 * c11) + (mv6 * c6) + (mv2 * c2) + (mv0 * c0);
   return mv_scaled / (float) (csum * 1000U);
 }

esphome/components/addressable_light/addressable_light_display.h

@@ -40,6 +40,8 @@ class AddressableLightDisplay : public display::DisplayBuffer, public PollingCom
   void setup() override;
   void display();
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
+
  protected:
   int get_width_internal() override;
   int get_height_internal() override;

esphome/components/animation/__init__.py

@@ -76,6 +76,8 @@ async def to_code(config):
         pos = 0
         for frameIndex in range(frames):
             image.seek(frameIndex)
+            if CONF_RESIZE in config:
+                image.thumbnail(config[CONF_RESIZE])
             frame = image.convert("RGB")
             if CONF_RESIZE in config:
                 frame = frame.resize([width, height])
@@ -92,6 +94,29 @@ async def to_code(config):
                 data[pos] = pix[2]
                 pos += 1
 
+    elif config[CONF_TYPE] == "RGB565":
+        data = [0 for _ in range(height * width * 2 * frames)]
+        pos = 0
+        for frameIndex in range(frames):
+            image.seek(frameIndex)
+            frame = image.convert("RGB")
+            if CONF_RESIZE in config:
+                frame = frame.resize([width, height])
+            pixels = list(frame.getdata())
+            if len(pixels) != height * width:
+                raise core.EsphomeError(
+                    f"Unexpected number of pixels in {path} frame {frameIndex}: ({len(pixels)} != {height*width})"
+                )
+            for pix in pixels:
+                R = pix[0] >> 3
+                G = pix[1] >> 2
+                B = pix[2] >> 3
+                rgb = (R << 11) | (G << 5) | B
+                data[pos] = rgb >> 8
+                pos += 1
+                data[pos] = rgb & 255
+                pos += 1
+
     elif config[CONF_TYPE] == "BINARY":
         width8 = ((width + 7) // 8) * 8
         data = [0 for _ in range((height * width8 // 8) * frames)]

esphome/components/anova/anova.cpp

@@ -92,7 +92,7 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
       }
       if (this->codec_->has_unit()) {
         this->fahrenheit_ = (this->codec_->unit_ == 'f');
-        ESP_LOGD(TAG, "Anova units is %s", this->fahrenheit_ ? "fahrenheit" : "celcius");
+        ESP_LOGD(TAG, "Anova units is %s", this->fahrenheit_ ? "fahrenheit" : "celsius");
         this->current_request_++;
       }
       this->publish_state();

esphome/components/api/api.proto

@@ -42,6 +42,7 @@ service APIConnection {
   rpc select_command (SelectCommandRequest) returns (void) {}
   rpc button_command (ButtonCommandRequest) returns (void) {}
   rpc lock_command (LockCommandRequest) returns (void) {}
+  rpc media_player_command (MediaPlayerCommandRequest) returns (void) {}
 }
 
 
@@ -991,7 +992,7 @@ message ListEntitiesLockResponse {
   bool supports_open = 9;
   bool requires_code = 10;
 
-  # Not yet implemented:
+  // Not yet implemented:
   string code_format = 11;
 }
 message LockStateResponse {
@@ -1010,7 +1011,7 @@ message LockCommandRequest {
   fixed32 key = 1;
   LockCommand command = 2;
 
-  # Not yet implemented:
+  // Not yet implemented:
   bool has_code = 3;
   string code = 4;
 }
@@ -1040,3 +1041,60 @@ message ButtonCommandRequest {
   fixed32 key = 1;
 }
 
+// ==================== MEDIA PLAYER ====================
+enum MediaPlayerState {
+  MEDIA_PLAYER_STATE_NONE = 0;
+  MEDIA_PLAYER_STATE_IDLE = 1;
+  MEDIA_PLAYER_STATE_PLAYING = 2;
+  MEDIA_PLAYER_STATE_PAUSED = 3;
+}
+enum MediaPlayerCommand {
+  MEDIA_PLAYER_COMMAND_PLAY = 0;
+  MEDIA_PLAYER_COMMAND_PAUSE = 1;
+  MEDIA_PLAYER_COMMAND_STOP = 2;
+  MEDIA_PLAYER_COMMAND_MUTE = 3;
+  MEDIA_PLAYER_COMMAND_UNMUTE = 4;
+}
+message ListEntitiesMediaPlayerResponse {
+  option (id) = 63;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_MEDIA_PLAYER";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  bool disabled_by_default = 6;
+  EntityCategory entity_category = 7;
+
+  bool supports_pause = 8;
+}
+message MediaPlayerStateResponse {
+  option (id) = 64;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_MEDIA_PLAYER";
+  option (no_delay) = true;
+  fixed32 key = 1;
+  MediaPlayerState state = 2;
+  float volume = 3;
+  bool muted = 4;
+}
+message MediaPlayerCommandRequest {
+  option (id) = 65;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_MEDIA_PLAYER";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+
+  bool has_command = 2;
+  MediaPlayerCommand command = 3;
+
+  bool has_volume = 4;
+  float volume = 5;
+
+  bool has_media_url = 6;
+  string media_url = 7;
+}

esphome/components/api/api_connection.cpp

@@ -12,9 +12,6 @@
 #ifdef USE_HOMEASSISTANT_TIME
 #include "esphome/components/homeassistant/time/homeassistant_time.h"
 #endif
-#ifdef USE_FAN
-#include "esphome/components/fan/fan_helpers.h"
-#endif
 
 namespace esphome {
 namespace api {
@@ -253,9 +250,6 @@ void APIConnection::cover_command(const CoverCommandRequest &msg) {
 #endif
 
 #ifdef USE_FAN
-// Shut-up about usage of deprecated speed_level_to_enum/speed_enum_to_level functions for a bit.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 bool APIConnection::send_fan_state(fan::Fan *fan) {
   if (!this->state_subscription_)
     return false;
@@ -268,7 +262,6 @@ bool APIConnection::send_fan_state(fan::Fan *fan) {
     resp.oscillating = fan->oscillating;
   if (traits.supports_speed()) {
     resp.speed_level = fan->speed;
-    resp.speed = static_cast<enums::FanSpeed>(fan::speed_level_to_enum(fan->speed, traits.supported_speed_count()));
   }
   if (traits.supports_direction())
     resp.direction = static_cast<enums::FanDirection>(fan->direction);
@@ -295,8 +288,6 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
   if (fan == nullptr)
     return;
 
-  auto traits = fan->get_traits();
-
   auto call = fan->make_call();
   if (msg.has_state)
     call.set_state(msg.state);
@@ -305,14 +296,11 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
   if (msg.has_speed_level) {
     // Prefer level
     call.set_speed(msg.speed_level);
-  } else if (msg.has_speed) {
-    call.set_speed(fan::speed_enum_to_level(static_cast<fan::FanSpeed>(msg.speed), traits.supported_speed_count()));
   }
   if (msg.has_direction)
     call.set_direction(static_cast<fan::FanDirection>(msg.direction));
   call.perform();
 }
-#pragma GCC diagnostic pop
 #endif
 
 #ifdef USE_LIGHT
@@ -745,6 +733,52 @@ void APIConnection::lock_command(const LockCommandRequest &msg) {
 }
 #endif
 
+#ifdef USE_MEDIA_PLAYER
+bool APIConnection::send_media_player_state(media_player::MediaPlayer *media_player) {
+  if (!this->state_subscription_)
+    return false;
+
+  MediaPlayerStateResponse resp{};
+  resp.key = media_player->get_object_id_hash();
+  resp.state = static_cast<enums::MediaPlayerState>(media_player->state);
+  resp.volume = media_player->volume;
+  resp.muted = media_player->is_muted();
+  return this->send_media_player_state_response(resp);
+}
+bool APIConnection::send_media_player_info(media_player::MediaPlayer *media_player) {
+  ListEntitiesMediaPlayerResponse msg;
+  msg.key = media_player->get_object_id_hash();
+  msg.object_id = media_player->get_object_id();
+  msg.name = media_player->get_name();
+  msg.unique_id = get_default_unique_id("media_player", media_player);
+  msg.icon = media_player->get_icon();
+  msg.disabled_by_default = media_player->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(media_player->get_entity_category());
+
+  auto traits = media_player->get_traits();
+  msg.supports_pause = traits.get_supports_pause();
+
+  return this->send_list_entities_media_player_response(msg);
+}
+void APIConnection::media_player_command(const MediaPlayerCommandRequest &msg) {
+  media_player::MediaPlayer *media_player = App.get_media_player_by_key(msg.key);
+  if (media_player == nullptr)
+    return;
+
+  auto call = media_player->make_call();
+  if (msg.has_command) {
+    call.set_command(static_cast<media_player::MediaPlayerCommand>(msg.command));
+  }
+  if (msg.has_volume) {
+    call.set_volume(msg.volume);
+  }
+  if (msg.has_media_url) {
+    call.set_media_url(msg.media_url);
+  }
+  call.perform();
+}
+#endif
+
 #ifdef USE_ESP32_CAMERA
 void APIConnection::send_camera_state(std::shared_ptr<esp32_camera::CameraImage> image) {
   if (!this->state_subscription_)

esphome/components/api/api_connection.h

@@ -82,6 +82,11 @@ class APIConnection : public APIServerConnection {
   bool send_lock_state(lock::Lock *a_lock, lock::LockState state);
   bool send_lock_info(lock::Lock *a_lock);
   void lock_command(const LockCommandRequest &msg) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool send_media_player_state(media_player::MediaPlayer *media_player);
+  bool send_media_player_info(media_player::MediaPlayer *media_player);
+  void media_player_command(const MediaPlayerCommandRequest &msg) override;
 #endif
   bool send_log_message(int level, const char *tag, const char *line);
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call) {

esphome/components/api/api_frame_helper.cpp

@@ -270,7 +270,7 @@ APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
  *
  * If the handshake is still active when this method returns and a read/write can't take place at
  * the moment, returns WOULD_BLOCK.
- * If an error occured, returns that error. Only returns OK if the transport is ready for data
+ * If an error occurred, returns that error. Only returns OK if the transport is ready for data
  * traffic.
  */
 APIError APINoiseFrameHelper::state_action_() {
@@ -586,7 +586,7 @@ APIError APINoiseFrameHelper::write_raw_(const struct iovec *iov, int iovcnt) {
     }
     return APIError::OK;
   } else if (sent == -1) {
-    // an error occured
+    // an error occurred
     state_ = State::FAILED;
     HELPER_LOG("Socket write failed with errno %d", errno);
     return APIError::SOCKET_WRITE_FAILED;
@@ -980,7 +980,7 @@ APIError APIPlaintextFrameHelper::write_raw_(const struct iovec *iov, int iovcnt
     }
     return APIError::OK;
   } else if (sent == -1) {
-    // an error occured
+    // an error occurred
     state_ = State::FAILED;
     HELPER_LOG("Socket write failed with errno %d", errno);
     return APIError::SOCKET_WRITE_FAILED;

esphome/components/api/api_pb2.cpp

@@ -308,6 +308,36 @@ template<> const char *proto_enum_to_string<enums::LockCommand>(enums::LockComma
       return "UNKNOWN";
   }
 }
+template<> const char *proto_enum_to_string<enums::MediaPlayerState>(enums::MediaPlayerState value) {
+  switch (value) {
+    case enums::MEDIA_PLAYER_STATE_NONE:
+      return "MEDIA_PLAYER_STATE_NONE";
+    case enums::MEDIA_PLAYER_STATE_IDLE:
+      return "MEDIA_PLAYER_STATE_IDLE";
+    case enums::MEDIA_PLAYER_STATE_PLAYING:
+      return "MEDIA_PLAYER_STATE_PLAYING";
+    case enums::MEDIA_PLAYER_STATE_PAUSED:
+      return "MEDIA_PLAYER_STATE_PAUSED";
+    default:
+      return "UNKNOWN";
+  }
+}
+template<> const char *proto_enum_to_string<enums::MediaPlayerCommand>(enums::MediaPlayerCommand value) {
+  switch (value) {
+    case enums::MEDIA_PLAYER_COMMAND_PLAY:
+      return "MEDIA_PLAYER_COMMAND_PLAY";
+    case enums::MEDIA_PLAYER_COMMAND_PAUSE:
+      return "MEDIA_PLAYER_COMMAND_PAUSE";
+    case enums::MEDIA_PLAYER_COMMAND_STOP:
+      return "MEDIA_PLAYER_COMMAND_STOP";
+    case enums::MEDIA_PLAYER_COMMAND_MUTE:
+      return "MEDIA_PLAYER_COMMAND_MUTE";
+    case enums::MEDIA_PLAYER_COMMAND_UNMUTE:
+      return "MEDIA_PLAYER_COMMAND_UNMUTE";
+    default:
+      return "UNKNOWN";
+  }
+}
 bool HelloRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
@@ -4574,6 +4604,254 @@ void ButtonCommandRequest::dump_to(std::string &out) const {
   out.append("}");
 }
 #endif
+bool ListEntitiesMediaPlayerResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 6: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
+    case 7: {
+      this->entity_category = value.as_enum<enums::EntityCategory>();
+      return true;
+    }
+    case 8: {
+      this->supports_pause = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesMediaPlayerResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->object_id = value.as_string();
+      return true;
+    }
+    case 3: {
+      this->name = value.as_string();
+      return true;
+    }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
+    case 5: {
+      this->icon = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesMediaPlayerResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 2: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ListEntitiesMediaPlayerResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_string(1, this->object_id);
+  buffer.encode_fixed32(2, this->key);
+  buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
+  buffer.encode_string(5, this->icon);
+  buffer.encode_bool(6, this->disabled_by_default);
+  buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
+  buffer.encode_bool(8, this->supports_pause);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ListEntitiesMediaPlayerResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("ListEntitiesMediaPlayerResponse {\n");
+  out.append("  object_id: ");
+  out.append("'").append(this->object_id).append("'");
+  out.append("\n");
+
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  name: ");
+  out.append("'").append(this->name).append("'");
+  out.append("\n");
+
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
+  out.append("  icon: ");
+  out.append("'").append(this->icon).append("'");
+  out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
+
+  out.append("  entity_category: ");
+  out.append(proto_enum_to_string<enums::EntityCategory>(this->entity_category));
+  out.append("\n");
+
+  out.append("  supports_pause: ");
+  out.append(YESNO(this->supports_pause));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool MediaPlayerStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2: {
+      this->state = value.as_enum<enums::MediaPlayerState>();
+      return true;
+    }
+    case 4: {
+      this->muted = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool MediaPlayerStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 3: {
+      this->volume = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void MediaPlayerStateResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_enum<enums::MediaPlayerState>(2, this->state);
+  buffer.encode_float(3, this->volume);
+  buffer.encode_bool(4, this->muted);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void MediaPlayerStateResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("MediaPlayerStateResponse {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  state: ");
+  out.append(proto_enum_to_string<enums::MediaPlayerState>(this->state));
+  out.append("\n");
+
+  out.append("  volume: ");
+  sprintf(buffer, "%g", this->volume);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  muted: ");
+  out.append(YESNO(this->muted));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool MediaPlayerCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2: {
+      this->has_command = value.as_bool();
+      return true;
+    }
+    case 3: {
+      this->command = value.as_enum<enums::MediaPlayerCommand>();
+      return true;
+    }
+    case 4: {
+      this->has_volume = value.as_bool();
+      return true;
+    }
+    case 6: {
+      this->has_media_url = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool MediaPlayerCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 7: {
+      this->media_url = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool MediaPlayerCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 5: {
+      this->volume = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void MediaPlayerCommandRequest::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_bool(2, this->has_command);
+  buffer.encode_enum<enums::MediaPlayerCommand>(3, this->command);
+  buffer.encode_bool(4, this->has_volume);
+  buffer.encode_float(5, this->volume);
+  buffer.encode_bool(6, this->has_media_url);
+  buffer.encode_string(7, this->media_url);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void MediaPlayerCommandRequest::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("MediaPlayerCommandRequest {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  has_command: ");
+  out.append(YESNO(this->has_command));
+  out.append("\n");
+
+  out.append("  command: ");
+  out.append(proto_enum_to_string<enums::MediaPlayerCommand>(this->command));
+  out.append("\n");
+
+  out.append("  has_volume: ");
+  out.append(YESNO(this->has_volume));
+  out.append("\n");
+
+  out.append("  volume: ");
+  sprintf(buffer, "%g", this->volume);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  has_media_url: ");
+  out.append(YESNO(this->has_media_url));
+  out.append("\n");
+
+  out.append("  media_url: ");
+  out.append("'").append(this->media_url).append("'");
+  out.append("\n");
+  out.append("}");
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2.h

@@ -141,6 +141,19 @@ enum LockCommand : uint32_t {
   LOCK_LOCK = 1,
   LOCK_OPEN = 2,
 };
+enum MediaPlayerState : uint32_t {
+  MEDIA_PLAYER_STATE_NONE = 0,
+  MEDIA_PLAYER_STATE_IDLE = 1,
+  MEDIA_PLAYER_STATE_PLAYING = 2,
+  MEDIA_PLAYER_STATE_PAUSED = 3,
+};
+enum MediaPlayerCommand : uint32_t {
+  MEDIA_PLAYER_COMMAND_PLAY = 0,
+  MEDIA_PLAYER_COMMAND_PAUSE = 1,
+  MEDIA_PLAYER_COMMAND_STOP = 2,
+  MEDIA_PLAYER_COMMAND_MUTE = 3,
+  MEDIA_PLAYER_COMMAND_UNMUTE = 4,
+};
 
 }  // namespace enums
 
@@ -1146,6 +1159,60 @@ class ButtonCommandRequest : public ProtoMessage {
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
 };
+class ListEntitiesMediaPlayerResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  bool disabled_by_default{false};
+  enums::EntityCategory entity_category{};
+  bool supports_pause{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class MediaPlayerStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  enums::MediaPlayerState state{};
+  float volume{0.0f};
+  bool muted{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class MediaPlayerCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  bool has_command{false};
+  enums::MediaPlayerCommand command{};
+  bool has_volume{false};
+  float volume{0.0f};
+  bool has_media_url{false};
+  std::string media_url{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.cpp

@@ -310,6 +310,24 @@ bool APIServerConnectionBase::send_list_entities_button_response(const ListEntit
 #endif
 #ifdef USE_BUTTON
 #endif
+#ifdef USE_MEDIA_PLAYER
+bool APIServerConnectionBase::send_list_entities_media_player_response(const ListEntitiesMediaPlayerResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_list_entities_media_player_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ListEntitiesMediaPlayerResponse>(msg, 63);
+}
+#endif
+#ifdef USE_MEDIA_PLAYER
+bool APIServerConnectionBase::send_media_player_state_response(const MediaPlayerStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_media_player_state_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<MediaPlayerStateResponse>(msg, 64);
+}
+#endif
+#ifdef USE_MEDIA_PLAYER
+#endif
 bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {
   switch (msg_type) {
     case 1: {
@@ -563,6 +581,17 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ESP_LOGVV(TAG, "on_button_command_request: %s", msg.dump().c_str());
 #endif
       this->on_button_command_request(msg);
+#endif
+      break;
+    }
+    case 65: {
+#ifdef USE_MEDIA_PLAYER
+      MediaPlayerCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_media_player_command_request: %s", msg.dump().c_str());
+#endif
+      this->on_media_player_command_request(msg);
 #endif
       break;
     }
@@ -813,6 +842,19 @@ void APIServerConnection::on_lock_command_request(const LockCommandRequest &msg)
   this->lock_command(msg);
 }
 #endif
+#ifdef USE_MEDIA_PLAYER
+void APIServerConnection::on_media_player_command_request(const MediaPlayerCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->media_player_command(msg);
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.h

@@ -144,6 +144,15 @@ class APIServerConnectionBase : public ProtoService {
 #endif
 #ifdef USE_BUTTON
   virtual void on_button_command_request(const ButtonCommandRequest &value){};
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool send_list_entities_media_player_response(const ListEntitiesMediaPlayerResponse &msg);
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool send_media_player_state_response(const MediaPlayerStateResponse &msg);
+#endif
+#ifdef USE_MEDIA_PLAYER
+  virtual void on_media_player_command_request(const MediaPlayerCommandRequest &value){};
 #endif
  protected:
   bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
@@ -192,6 +201,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #endif
 #ifdef USE_LOCK
   virtual void lock_command(const LockCommandRequest &msg) = 0;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  virtual void media_player_command(const MediaPlayerCommandRequest &msg) = 0;
 #endif
  protected:
   void on_hello_request(const HelloRequest &msg) override;
@@ -236,6 +248,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_LOCK
   void on_lock_command_request(const LockCommandRequest &msg) override;
 #endif
+#ifdef USE_MEDIA_PLAYER
+  void on_media_player_command_request(const MediaPlayerCommandRequest &msg) override;
+#endif
 };
 
 }  // namespace api

esphome/components/api/api_server.cpp

@@ -255,7 +255,7 @@ void APIServer::on_number_update(number::Number *obj, float state) {
 #endif
 
 #ifdef USE_SELECT
-void APIServer::on_select_update(select::Select *obj, const std::string &state) {
+void APIServer::on_select_update(select::Select *obj, const std::string &state, size_t index) {
   if (obj->is_internal())
     return;
   for (auto &c : this->clients_)
@@ -272,6 +272,15 @@ void APIServer::on_lock_update(lock::Lock *obj) {
 }
 #endif
 
+#ifdef USE_MEDIA_PLAYER
+void APIServer::on_media_player_update(media_player::MediaPlayer *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_media_player_state(obj);
+}
+#endif
+
 float APIServer::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
 void APIServer::set_port(uint16_t port) { this->port_ = port; }
 APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

esphome/components/api/api_server.h

@@ -64,10 +64,13 @@ class APIServer : public Component, public Controller {
   void on_number_update(number::Number *obj, float state) override;
 #endif
 #ifdef USE_SELECT
-  void on_select_update(select::Select *obj, const std::string &state) override;
+  void on_select_update(select::Select *obj, const std::string &state, size_t index) override;
 #endif
 #ifdef USE_LOCK
   void on_lock_update(lock::Lock *obj) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  void on_media_player_update(media_player::MediaPlayer *obj) override;
 #endif
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call);
   void register_user_service(UserServiceDescriptor *descriptor) { this->user_services_.push_back(descriptor); }

esphome/components/api/list_entities.cpp

@@ -64,5 +64,11 @@ bool ListEntitiesIterator::on_number(number::Number *number) { return this->clie
 bool ListEntitiesIterator::on_select(select::Select *select) { return this->client_->send_select_info(select); }
 #endif
 
+#ifdef USE_MEDIA_PLAYER
+bool ListEntitiesIterator::on_media_player(media_player::MediaPlayer *media_player) {
+  return this->client_->send_media_player_info(media_player);
+}
+#endif
+
 }  // namespace api
 }  // namespace esphome

esphome/components/api/list_entities.h

@@ -51,6 +51,9 @@ class ListEntitiesIterator : public ComponentIterator {
 #endif
 #ifdef USE_LOCK
   bool on_lock(lock::Lock *a_lock) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool on_media_player(media_player::MediaPlayer *media_player) override;
 #endif
   bool on_end() override;
 

esphome/components/api/subscribe_state.cpp

@@ -50,6 +50,11 @@ bool InitialStateIterator::on_select(select::Select *select) {
 #ifdef USE_LOCK
 bool InitialStateIterator::on_lock(lock::Lock *a_lock) { return this->client_->send_lock_state(a_lock, a_lock->state); }
 #endif
+#ifdef USE_MEDIA_PLAYER
+bool InitialStateIterator::on_media_player(media_player::MediaPlayer *media_player) {
+  return this->client_->send_media_player_state(media_player);
+}
+#endif
 InitialStateIterator::InitialStateIterator(APIConnection *client) : client_(client) {}
 
 }  // namespace api

esphome/components/api/subscribe_state.h

@@ -48,6 +48,9 @@ class InitialStateIterator : public ComponentIterator {
 #endif
 #ifdef USE_LOCK
   bool on_lock(lock::Lock *a_lock) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool on_media_player(media_player::MediaPlayer *media_player) override;
 #endif
  protected:
   APIConnection *client_;

esphome/components/bedjet/bedjet.cpp

@@ -36,6 +36,14 @@ static uint8_t bedjet_fan_speed_to_step(const std::string &fan_step_percent) {
   return -1;
 }
 
+static BedjetButton heat_button(BedjetHeatMode mode) {
+  BedjetButton btn = BTN_HEAT;
+  if (mode == HEAT_MODE_EXTENDED) {
+    btn = BTN_EXTHT;
+  }
+  return btn;
+}
+
 void Bedjet::upgrade_firmware() {
   auto *pkt = this->codec_->get_button_request(MAGIC_UPDATE);
   auto status = this->write_bedjet_packet_(pkt);
@@ -117,7 +125,7 @@ void Bedjet::control(const ClimateCall &call) {
         pkt = this->codec_->get_button_request(BTN_OFF);
         break;
       case climate::CLIMATE_MODE_HEAT:
-        pkt = this->codec_->get_button_request(BTN_EXTHT);
+        pkt = this->codec_->get_button_request(heat_button(this->heating_mode_));
         break;
       case climate::CLIMATE_MODE_FAN_ONLY:
         pkt = this->codec_->get_button_request(BTN_COOL);
@@ -137,7 +145,7 @@ void Bedjet::control(const ClimateCall &call) {
     } else {
       this->force_refresh_ = true;
       this->mode = mode;
-      // We're using (custom) preset for Turbo & M1-3 presets, so changing climate mode will clear those
+      // We're using (custom) preset for Turbo, EXT HT, & M1-3 presets, so changing climate mode will clear those
       this->custom_preset.reset();
       this->preset.reset();
     }
@@ -186,6 +194,10 @@ void Bedjet::control(const ClimateCall &call) {
       pkt = this->codec_->get_button_request(BTN_M2);
     } else if (preset == "M3") {
       pkt = this->codec_->get_button_request(BTN_M3);
+    } else if (preset == "LTD HT") {
+      pkt = this->codec_->get_button_request(BTN_HEAT);
+    } else if (preset == "EXT HT") {
+      pkt = this->codec_->get_button_request(BTN_EXTHT);
     } else {
       ESP_LOGW(TAG, "Unsupported preset: %s", preset.c_str());
       return;
@@ -296,7 +308,7 @@ void Bedjet::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc
 
 #ifdef USE_TIME
       if (this->time_id_.has_value()) {
-        this->send_local_time_();
+        this->send_local_time();
       }
 #endif
       break;
@@ -451,40 +463,47 @@ uint8_t Bedjet::write_notify_config_descriptor_(bool enable) {
 
 #ifdef USE_TIME
 /** Attempts to sync the local time (via `time_id`) to the BedJet device. */
-void Bedjet::send_local_time_() {
-  if (this->node_state != espbt::ClientState::ESTABLISHED) {
-    ESP_LOGV(TAG, "[%s] Not connected, cannot send time.", this->get_name().c_str());
-    return;
-  }
-  auto *time_id = *this->time_id_;
-  time::ESPTime now = time_id->now();
-  if (now.is_valid()) {
-    uint8_t hour = now.hour;
-    uint8_t minute = now.minute;
-    BedjetPacket *pkt = this->codec_->get_set_time_request(hour, minute);
-    auto status = this->write_bedjet_packet_(pkt);
-    if (status) {
-      ESP_LOGW(TAG, "Failed setting BedJet clock: %d", status);
-    } else {
-      ESP_LOGD(TAG, "[%s] BedJet clock set to: %d:%02d", this->get_name().c_str(), hour, minute);
+void Bedjet::send_local_time() {
+  if (this->time_id_.has_value()) {
+    auto *time_id = *this->time_id_;
+    time::ESPTime now = time_id->now();
+    if (now.is_valid()) {
+      this->set_clock(now.hour, now.minute);
+      ESP_LOGD(TAG, "Using time component to set BedJet clock: %d:%02d", now.hour, now.minute);
     }
+  } else {
+    ESP_LOGI(TAG, "`time_id` is not configured: will not sync BedJet clock.");
   }
 }
 
 /** Initializes time sync callbacks to support syncing current time to the BedJet. */
 void Bedjet::setup_time_() {
   if (this->time_id_.has_value()) {
-    this->send_local_time_();
+    this->send_local_time();
     auto *time_id = *this->time_id_;
-    time_id->add_on_time_sync_callback([this] { this->send_local_time_(); });
-    time::ESPTime now = time_id->now();
-    ESP_LOGD(TAG, "Using time component to set BedJet clock: %d:%02d", now.hour, now.minute);
+    time_id->add_on_time_sync_callback([this] { this->send_local_time(); });
   } else {
     ESP_LOGI(TAG, "`time_id` is not configured: will not sync BedJet clock.");
   }
 }
 #endif
 
+/** Attempt to set the BedJet device's clock to the specified time. */
+void Bedjet::set_clock(uint8_t hour, uint8_t minute) {
+  if (this->node_state != espbt::ClientState::ESTABLISHED) {
+    ESP_LOGV(TAG, "[%s] Not connected, cannot send time.", this->get_name().c_str());
+    return;
+  }
+
+  BedjetPacket *pkt = this->codec_->get_set_time_request(hour, minute);
+  auto status = this->write_bedjet_packet_(pkt);
+  if (status) {
+    ESP_LOGW(TAG, "Failed setting BedJet clock: %d", status);
+  } else {
+    ESP_LOGD(TAG, "[%s] BedJet clock set to: %d:%02d", this->get_name().c_str(), hour, minute);
+  }
+}
+
 /** Writes one BedjetPacket to the BLE client on the BEDJET_COMMAND_UUID. */
 uint8_t Bedjet::write_bedjet_packet_(BedjetPacket *pkt) {
   if (this->node_state != espbt::ClientState::ESTABLISHED) {
@@ -555,11 +574,25 @@ bool Bedjet::update_status_() {
       break;
 
     case MODE_HEAT:
+      this->mode = climate::CLIMATE_MODE_HEAT;
+      this->action = climate::CLIMATE_ACTION_HEATING;
+      this->preset.reset();
+      if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
+        this->set_custom_preset_("LTD HT");
+      } else {
+        this->custom_preset.reset();
+      }
+      break;
+
     case MODE_EXTHT:
       this->mode = climate::CLIMATE_MODE_HEAT;
       this->action = climate::CLIMATE_ACTION_HEATING;
-      this->custom_preset.reset();
       this->preset.reset();
+      if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
+        this->custom_preset.reset();
+      } else {
+        this->set_custom_preset_("EXT HT");
+      }
       break;
 
     case MODE_COOL:

esphome/components/bedjet/bedjet.h

@@ -4,6 +4,7 @@
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/components/climate/climate.h"
 #include "esphome/core/component.h"
+#include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
 #include "bedjet_base.h"
 
@@ -37,8 +38,12 @@ class Bedjet : public climate::Climate, public esphome::ble_client::BLEClientNod
 
 #ifdef USE_TIME
   void set_time_id(time::RealTimeClock *time_id) { this->time_id_ = time_id; }
+  void send_local_time();
 #endif
+  void set_clock(uint8_t hour, uint8_t minute);
   void set_status_timeout(uint32_t timeout) { this->timeout_ = timeout; }
+  /** Sets the default strategy to use for climate::CLIMATE_MODE_HEAT. */
+  void set_heating_mode(BedjetHeatMode mode) { this->heating_mode_ = mode; }
 
   /** Attempts to check for and apply firmware updates. */
   void upgrade_firmware();
@@ -67,10 +72,17 @@ class Bedjet : public climate::Climate, public esphome::ble_client::BLEClientNod
         // We could fetch biodata from bedjet and set these names that way.
         // But then we have to invert the lookup in order to send the right preset.
         // For now, we can leave them as M1-3 to match the remote buttons.
+        // EXT HT added to match remote button.
+        "EXT HT",
         "M1",
         "M2",
         "M3",
     });
+    if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
+      traits.add_supported_custom_preset("LTD HT");
+    } else {
+      traits.add_supported_custom_preset("EXT HT");
+    }
     traits.set_visual_min_temperature(19.0);
     traits.set_visual_max_temperature(43.0);
     traits.set_visual_temperature_step(1.0);
@@ -82,11 +94,11 @@ class Bedjet : public climate::Climate, public esphome::ble_client::BLEClientNod
 
 #ifdef USE_TIME
   void setup_time_();
-  void send_local_time_();
   optional<time::RealTimeClock *> time_id_{};
 #endif
 
   uint32_t timeout_{DEFAULT_STATUS_TIMEOUT};
+  BedjetHeatMode heating_mode_ = HEAT_MODE_HEAT;
 
   static const uint32_t MIN_NOTIFY_THROTTLE = 5000;
   static const uint32_t NOTIFY_WARN_THRESHOLD = 300000;

esphome/components/bedjet/bedjet_const.h

@@ -24,6 +24,14 @@ enum BedjetMode : uint8_t {
   MODE_WAIT = 6,
 };
 
+/** Optional heating strategies to use for climate::CLIMATE_MODE_HEAT. */
+enum BedjetHeatMode {
+  /// HVACMode.HEAT is handled using BTN_HEAT (default)
+  HEAT_MODE_HEAT,
+  /// HVACMode.HEAT is handled using BTN_EXTHT
+  HEAT_MODE_EXTENDED,
+};
+
 enum BedjetButton : uint8_t {
   /// Turn BedJet off
   BTN_OFF = 0x1,
@@ -66,8 +74,8 @@ enum BedjetCommand : uint8_t {
 
 #define BEDJET_FAN_STEP_NAMES_ \
   { \
-    "  5%", " 10%", " 15%", " 20%", " 25%", " 30%", " 35%", " 40%", " 45%", " 50%", " 55%", " 60%", " 65%", " 70%", \
-        " 75%", " 80%", " 85%", " 90%", " 95%", "100%" \
+    "5%", "10%", "15%", "20%", "25%", "30%", "35%", "40%", "45%", "50%", "55%", "60%", "65%", "70%", "75%", "80%", \
+        "85%", "90%", "95%", "100%" \
   }
 
 static const char *const BEDJET_FAN_STEP_NAMES[20] = BEDJET_FAN_STEP_NAMES_;

esphome/components/bedjet/climate.py

@@ -2,6 +2,7 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import climate, ble_client, time
 from esphome.const import (
+    CONF_HEAT_MODE,
     CONF_ID,
     CONF_RECEIVE_TIMEOUT,
     CONF_TIME_ID,
@@ -14,11 +15,19 @@ bedjet_ns = cg.esphome_ns.namespace("bedjet")
 Bedjet = bedjet_ns.class_(
     "Bedjet", climate.Climate, ble_client.BLEClientNode, cg.PollingComponent
 )
+BedjetHeatMode = bedjet_ns.enum("BedjetHeatMode")
+BEDJET_HEAT_MODES = {
+    "heat": BedjetHeatMode.HEAT_MODE_HEAT,
+    "extended": BedjetHeatMode.HEAT_MODE_EXTENDED,
+}
 
 CONFIG_SCHEMA = (
     climate.CLIMATE_SCHEMA.extend(
         {
             cv.GenerateID(): cv.declare_id(Bedjet),
+            cv.Optional(CONF_HEAT_MODE, default="heat"): cv.enum(
+                BEDJET_HEAT_MODES, lower=True
+            ),
             cv.Optional(CONF_TIME_ID): cv.use_id(time.RealTimeClock),
             cv.Optional(
                 CONF_RECEIVE_TIMEOUT, default="0s"
@@ -35,6 +44,7 @@ async def to_code(config):
     await cg.register_component(var, config)
     await climate.register_climate(var, config)
     await ble_client.register_ble_node(var, config)
+    cg.add(var.set_heating_mode(config[CONF_HEAT_MODE]))
     if CONF_TIME_ID in config:
         time_ = await cg.get_variable(config[CONF_TIME_ID])
         cg.add(var.set_time_id(time_))

esphome/components/binary_sensor/binary_sensor.cpp

@@ -69,7 +69,6 @@ void BinarySensor::add_filters(const std::vector<Filter *> &filters) {
   }
 }
 bool BinarySensor::has_state() const { return this->has_state_; }
-uint32_t BinarySensor::hash_base() { return 1210250844UL; }
 bool BinarySensor::is_status_binary_sensor() const { return false; }
 
 }  // namespace binary_sensor

esphome/components/binary_sensor/binary_sensor.h

@@ -76,8 +76,6 @@ class BinarySensor : public EntityBase {
   virtual std::string device_class();
 
  protected:
-  uint32_t hash_base() override;
-
   CallbackManager<void(bool)> state_callback_{};
   optional<std::string> device_class_{};  ///< Stores the override of the device class
   Filter *filter_list_{nullptr};

esphome/components/bl0939/bl0939.cpp

@@ -7,7 +7,7 @@ namespace bl0939 {
 static const char *const TAG = "bl0939";
 
 // https://www.belling.com.cn/media/file_object/bel_product/BL0939/datasheet/BL0939_V1.2_cn.pdf
-// (unfortunatelly chinese, but the protocol can be understood with some translation tool)
+// (unfortunately chinese, but the protocol can be understood with some translation tool)
 static const uint8_t BL0939_READ_COMMAND = 0x55;  // 0x5{A4,A3,A2,A1}
 static const uint8_t BL0939_FULL_PACKET = 0xAA;
 static const uint8_t BL0939_PACKET_HEADER = 0x55;

esphome/components/bl0939/bl0939.h

@@ -8,7 +8,7 @@ namespace esphome {
 namespace bl0939 {
 
 // https://datasheet.lcsc.com/lcsc/2108071830_BL-Shanghai-Belling-BL0939_C2841044.pdf
-// (unfortunatelly chinese, but the formulas can be easily understood)
+// (unfortunately chinese, but the formulas can be easily understood)
 // Sonoff Dual R3 V2 has the exact same resistor values for the current shunts (RL=1miliOhm)
 // and for the voltage divider (R1=0.51kOhm, R2=5*390kOhm)
 // as in the manufacturer's reference circuit, so the same formulas were used here (Vref=1.218V)

esphome/components/ble_client/ble_client.cpp

@@ -113,6 +113,7 @@ void BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t es
     }
     case ESP_GATTC_OPEN_EVT: {
       ESP_LOGV(TAG, "[%s] ESP_GATTC_OPEN_EVT", this->address_str().c_str());
+      this->conn_id = param->open.conn_id;
       if (param->open.status != ESP_GATT_OK) {
         ESP_LOGW(TAG, "connect to %s failed, status=%d", this->address_str().c_str(), param->open.status);
         this->set_states_(espbt::ClientState::IDLE);
@@ -122,7 +123,10 @@ void BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t es
     }
     case ESP_GATTC_CONNECT_EVT: {
       ESP_LOGV(TAG, "[%s] ESP_GATTC_CONNECT_EVT", this->address_str().c_str());
-      this->conn_id = param->connect.conn_id;
+      if (this->conn_id != param->connect.conn_id) {
+        ESP_LOGD(TAG, "[%s] Unexpected conn_id in CONNECT_EVT: param conn=%d, open conn=%d",
+                 this->address_str().c_str(), param->connect.conn_id, this->conn_id);
+      }
       auto ret = esp_ble_gattc_send_mtu_req(this->gattc_if, param->connect.conn_id);
       if (ret) {
         ESP_LOGW(TAG, "esp_ble_gattc_send_mtu_req failed, status=%x", ret);
@@ -183,9 +187,10 @@ void BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t es
                  descr->uuid.to_string().c_str());
         break;
       }
-      uint8_t notify_en = 1;
-      auto status = esp_ble_gattc_write_char_descr(this->gattc_if, this->conn_id, descr->handle, sizeof(notify_en),
-                                                   &notify_en, ESP_GATT_WRITE_TYPE_RSP, ESP_GATT_AUTH_REQ_NONE);
+      uint16_t notify_en = 1;
+      auto status =
+          esp_ble_gattc_write_char_descr(this->gattc_if, this->conn_id, descr->handle, sizeof(notify_en),
+                                         (uint8_t *) &notify_en, ESP_GATT_WRITE_TYPE_RSP, ESP_GATT_AUTH_REQ_NONE);
       if (status) {
         ESP_LOGW(TAG, "esp_ble_gattc_write_char_descr error, status=%d", status);
       }

esphome/components/ble_client/sensor/ble_sensor.cpp

@@ -11,8 +11,6 @@ namespace ble_client {
 
 static const char *const TAG = "ble_sensor";
 
-uint32_t BLESensor::hash_base() { return 343459825UL; }
-
 void BLESensor::loop() {}
 
 void BLESensor::dump_config() {

esphome/components/ble_client/sensor/ble_sensor.h

@@ -37,7 +37,6 @@ class BLESensor : public sensor::Sensor, public PollingComponent, public BLEClie
   uint16_t handle;
 
  protected:
-  uint32_t hash_base() override;
   float parse_data_(uint8_t *value, uint16_t value_len);
   optional<data_to_value_t> data_to_value_func_{};
   bool notify_;

esphome/components/ble_client/text_sensor/ble_text_sensor.cpp

@@ -14,8 +14,6 @@ static const char *const TAG = "ble_text_sensor";
 
 static const std::string EMPTY = "";
 
-uint32_t BLETextSensor::hash_base() { return 193967603UL; }
-
 void BLETextSensor::loop() {}
 
 void BLETextSensor::dump_config() {

esphome/components/ble_client/text_sensor/ble_text_sensor.h

@@ -35,7 +35,6 @@ class BLETextSensor : public text_sensor::TextSensor, public PollingComponent, p
   uint16_t handle;
 
  protected:
-  uint32_t hash_base() override;
   bool notify_;
   espbt::ESPBTUUID service_uuid_;
   espbt::ESPBTUUID char_uuid_;

esphome/components/bme280/bme280.cpp

@@ -81,6 +81,11 @@ static const char *iir_filter_to_str(BME280IIRFilter filter) {
 void BME280Component::setup() {
   ESP_LOGCONFIG(TAG, "Setting up BME280...");
   uint8_t chip_id = 0;
+
+  // Mark as not failed before initializing. Some devices will turn off sensors to save on batteries
+  // and when they come back on, the COMPONENT_STATE_FAILED bit must be unset on the component.
+  this->component_state_ &= ~COMPONENT_STATE_FAILED;
+
   if (!this->read_byte(BME280_REGISTER_CHIPID, &chip_id)) {
     this->error_code_ = COMMUNICATION_FAILED;
     this->mark_failed();

esphome/components/bme680_bsec/bme680_bsec.cpp

@@ -169,6 +169,14 @@ void BME680BSECComponent::loop() {
   } else {
     this->status_clear_warning();
   }
+
+  // Process a single action from the queue. These are primarily sensor state publishes
+  // that in totality take too long to send in a single call.
+  if (this->queue_.size()) {
+    auto action = std::move(this->queue_.front());
+    this->queue_.pop();
+    action();
+  }
 }
 
 void BME680BSECComponent::run_() {
@@ -306,37 +314,39 @@ void BME680BSECComponent::read_(int64_t trigger_time_ns, bsec_bme_settings_t bme
 }
 
 void BME680BSECComponent::publish_(const bsec_output_t *outputs, uint8_t num_outputs) {
-  ESP_LOGV(TAG, "Publishing sensor states");
+  ESP_LOGV(TAG, "Queuing sensor state publish actions");
   for (uint8_t i = 0; i < num_outputs; i++) {
+    float signal = outputs[i].signal;
     switch (outputs[i].sensor_id) {
       case BSEC_OUTPUT_IAQ:
-      case BSEC_OUTPUT_STATIC_IAQ:
-        uint8_t accuracy;
-        accuracy = outputs[i].accuracy;
-        this->publish_sensor_state_(this->iaq_sensor_, outputs[i].signal);
-        this->publish_sensor_state_(this->iaq_accuracy_text_sensor_, IAQ_ACCURACY_STATES[accuracy]);
-        this->publish_sensor_state_(this->iaq_accuracy_sensor_, accuracy, true);
+      case BSEC_OUTPUT_STATIC_IAQ: {
+        uint8_t accuracy = outputs[i].accuracy;
+        this->queue_push_([this, signal]() { this->publish_sensor_(this->iaq_sensor_, signal); });
+        this->queue_push_([this, accuracy]() {
+          this->publish_sensor_(this->iaq_accuracy_text_sensor_, IAQ_ACCURACY_STATES[accuracy]);
+        });
+        this->queue_push_([this, accuracy]() { this->publish_sensor_(this->iaq_accuracy_sensor_, accuracy, true); });
 
         // Queue up an opportunity to save state
-        this->defer("save_state", [this, accuracy]() { this->save_state_(accuracy); });
-        break;
+        this->queue_push_([this, accuracy]() { this->save_state_(accuracy); });
+      } break;
       case BSEC_OUTPUT_CO2_EQUIVALENT:
-        this->publish_sensor_state_(this->co2_equivalent_sensor_, outputs[i].signal);
+        this->queue_push_([this, signal]() { this->publish_sensor_(this->co2_equivalent_sensor_, signal); });
         break;
       case BSEC_OUTPUT_BREATH_VOC_EQUIVALENT:
-        this->publish_sensor_state_(this->breath_voc_equivalent_sensor_, outputs[i].signal);
+        this->queue_push_([this, signal]() { this->publish_sensor_(this->breath_voc_equivalent_sensor_, signal); });
         break;
       case BSEC_OUTPUT_RAW_PRESSURE:
-        this->publish_sensor_state_(this->pressure_sensor_, outputs[i].signal / 100.0f);
+        this->queue_push_([this, signal]() { this->publish_sensor_(this->pressure_sensor_, signal / 100.0f); });
         break;
       case BSEC_OUTPUT_RAW_GAS:
-        this->publish_sensor_state_(this->gas_resistance_sensor_, outputs[i].signal);
+        this->queue_push_([this, signal]() { this->publish_sensor_(this->gas_resistance_sensor_, signal); });
         break;
       case BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE:
-        this->publish_sensor_state_(this->temperature_sensor_, outputs[i].signal);
+        this->queue_push_([this, signal]() { this->publish_sensor_(this->temperature_sensor_, signal); });
         break;
       case BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY:
-        this->publish_sensor_state_(this->humidity_sensor_, outputs[i].signal);
+        this->queue_push_([this, signal]() { this->publish_sensor_(this->humidity_sensor_, signal); });
         break;
     }
   }
@@ -352,14 +362,14 @@ int64_t BME680BSECComponent::get_time_ns_() {
   return (time_ms + ((int64_t) this->millis_overflow_counter_ << 32)) * INT64_C(1000000);
 }
 
-void BME680BSECComponent::publish_sensor_state_(sensor::Sensor *sensor, float value, bool change_only) {
+void BME680BSECComponent::publish_sensor_(sensor::Sensor *sensor, float value, bool change_only) {
   if (!sensor || (change_only && sensor->has_state() && sensor->state == value)) {
     return;
   }
   sensor->publish_state(value);
 }
 
-void BME680BSECComponent::publish_sensor_state_(text_sensor::TextSensor *sensor, const std::string &value) {
+void BME680BSECComponent::publish_sensor_(text_sensor::TextSensor *sensor, const std::string &value) {
   if (!sensor || (sensor->has_state() && sensor->state == value)) {
     return;
   }

esphome/components/bme680_bsec/bme680_bsec.h

@@ -70,12 +70,14 @@ class BME680BSECComponent : public Component, public i2c::I2CDevice {
   void publish_(const bsec_output_t *outputs, uint8_t num_outputs);
   int64_t get_time_ns_();
 
-  void publish_sensor_state_(sensor::Sensor *sensor, float value, bool change_only = false);
-  void publish_sensor_state_(text_sensor::TextSensor *sensor, const std::string &value);
+  void publish_sensor_(sensor::Sensor *sensor, float value, bool change_only = false);
+  void publish_sensor_(text_sensor::TextSensor *sensor, const std::string &value);
 
   void load_state_();
   void save_state_(uint8_t accuracy);
 
+  void queue_push_(std::function<void()> &&f) { this->queue_.push(std::move(f)); }
+
   struct bme680_dev bme680_;
   bsec_library_return_t bsec_status_{BSEC_OK};
   int8_t bme680_status_{BME680_OK};
@@ -84,6 +86,8 @@ class BME680BSECComponent : public Component, public i2c::I2CDevice {
   uint32_t millis_overflow_counter_{0};
   int64_t next_call_ns_{0};
 
+  std::queue<std::function<void()>> queue_;
+
   ESPPreferenceObject bsec_state_;
   uint32_t state_save_interval_ms_{21600000};  // 6 hours - 4 times a day
   uint32_t last_state_save_ms_ = 0;

esphome/components/bmp3xx/sensor.py

@@ -25,7 +25,7 @@ OVERSAMPLING_OPTIONS = {
     "4X": Oversampling.OVERSAMPLING_X4,
     "8X": Oversampling.OVERSAMPLING_X8,
     "16X": Oversampling.OVERSAMPLING_X16,
-    "32x": Oversampling.OVERSAMPLING_X32,
+    "32X": Oversampling.OVERSAMPLING_X32,
 }
 
 IIRFilter = bmp3xx_ns.enum("IIRFilter")

esphome/components/button/button.cpp

@@ -15,7 +15,6 @@ void Button::press() {
   this->press_callback_.call();
 }
 void Button::add_on_press_callback(std::function<void()> &&callback) { this->press_callback_.add(std::move(callback)); }
-uint32_t Button::hash_base() { return 1495763804UL; }
 
 void Button::set_device_class(const std::string &device_class) { this->device_class_ = device_class; }
 std::string Button::get_device_class() { return this->device_class_; }

esphome/components/button/button.h

@@ -47,8 +47,6 @@ class Button : public EntityBase {
    */
   virtual void press_action() = 0;
 
-  uint32_t hash_base() override;
-
   CallbackManager<void()> press_callback_{};
   std::string device_class_{};
 };

esphome/components/canbus/__init__.py

@@ -78,6 +78,7 @@ CANBUS_SCHEMA = cv.Schema(
                     min=0, max=0x1FFFFFFF
                 ),
                 cv.Optional(CONF_USE_EXTENDED_ID, default=False): cv.boolean,
+                cv.Optional(CONF_REMOTE_TRANSMISSION_REQUEST): cv.boolean,
             },
             validate_id,
         ),
@@ -100,10 +101,20 @@ async def setup_canbus_core_(var, config):
         trigger = cg.new_Pvariable(
             conf[CONF_TRIGGER_ID], var, can_id, can_id_mask, ext_id
         )
+        if CONF_REMOTE_TRANSMISSION_REQUEST in conf:
+            cg.add(
+                trigger.set_remote_transmission_request(
+                    conf[CONF_REMOTE_TRANSMISSION_REQUEST]
+                )
+            )
         await cg.register_component(trigger, conf)
         await automation.build_automation(
             trigger,
-            [(cg.std_vector.template(cg.uint8), "x"), (cg.uint32, "can_id")],
+            [
+                (cg.std_vector.template(cg.uint8), "x"),
+                (cg.uint32, "can_id"),
+                (cg.bool_, "remote_transmission_request"),
+            ],
             conf,
         )
 

esphome/components/canbus/canbus.cpp

@@ -81,8 +81,10 @@ void Canbus::loop() {
     // fire all triggers
     for (auto *trigger : this->triggers_) {
       if ((trigger->can_id_ == (can_message.can_id & trigger->can_id_mask_)) &&
-          (trigger->use_extended_id_ == can_message.use_extended_id)) {
-        trigger->trigger(data, can_message.can_id);
+          (trigger->use_extended_id_ == can_message.use_extended_id) &&
+          (!trigger->remote_transmission_request_.has_value() ||
+           trigger->remote_transmission_request_.value() == can_message.remote_transmission_request)) {
+        trigger->trigger(data, can_message.can_id, can_message.remote_transmission_request);
       }
     }
   }

esphome/components/canbus/canbus.h

@@ -126,13 +126,18 @@ template<typename... Ts> class CanbusSendAction : public Action<Ts...>, public P
   std::vector<uint8_t> data_static_{};
 };
 
-class CanbusTrigger : public Trigger<std::vector<uint8_t>, uint32_t>, public Component {
+class CanbusTrigger : public Trigger<std::vector<uint8_t>, uint32_t, bool>, public Component {
   friend class Canbus;
 
  public:
   explicit CanbusTrigger(Canbus *parent, const std::uint32_t can_id, const std::uint32_t can_id_mask,
                          const bool use_extended_id)
       : parent_(parent), can_id_(can_id), can_id_mask_(can_id_mask), use_extended_id_(use_extended_id){};
+
+  void set_remote_transmission_request(bool remote_transmission_request) {
+    this->remote_transmission_request_ = remote_transmission_request;
+  }
+
   void setup() override { this->parent_->add_trigger(this); }
 
  protected:
@@ -140,6 +145,7 @@ class CanbusTrigger : public Trigger<std::vector<uint8_t>, uint32_t>, public Com
   uint32_t can_id_;
   uint32_t can_id_mask_;
   bool use_extended_id_;
+  optional<bool> remote_transmission_request_{};
 };
 
 }  // namespace canbus

esphome/components/captive_portal/captive_portal.h

@@ -39,17 +39,7 @@ class CaptivePortal : public AsyncWebHandler, public Component {
     if (request->method() == HTTP_GET) {
       if (request->url() == "/")
         return true;
-      if (request->url() == "/stylesheet.css")
-        return true;
-      if (request->url() == "/wifi-strength-1.svg")
-        return true;
-      if (request->url() == "/wifi-strength-2.svg")
-        return true;
-      if (request->url() == "/wifi-strength-3.svg")
-        return true;
-      if (request->url() == "/wifi-strength-4.svg")
-        return true;
-      if (request->url() == "/lock.svg")
+      if (request->url() == "/config.json")
         return true;
       if (request->url() == "/wifisave")
         return true;

esphome/components/climate/__init__.py

@@ -287,9 +287,11 @@ CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema(
         cv.Exclusive(CONF_FAN_MODE, "fan_mode"): cv.templatable(
             validate_climate_fan_mode
         ),
-        cv.Exclusive(CONF_CUSTOM_FAN_MODE, "fan_mode"): cv.string_strict,
+        cv.Exclusive(CONF_CUSTOM_FAN_MODE, "fan_mode"): cv.templatable(
+            cv.string_strict
+        ),
         cv.Exclusive(CONF_PRESET, "preset"): cv.templatable(validate_climate_preset),
-        cv.Exclusive(CONF_CUSTOM_PRESET, "preset"): cv.string_strict,
+        cv.Exclusive(CONF_CUSTOM_PRESET, "preset"): cv.templatable(cv.string_strict),
         cv.Optional(CONF_SWING_MODE): cv.templatable(validate_climate_swing_mode),
     }
 )
@@ -324,13 +326,17 @@ async def climate_control_to_code(config, action_id, template_arg, args):
         template_ = await cg.templatable(config[CONF_FAN_MODE], args, ClimateFanMode)
         cg.add(var.set_fan_mode(template_))
     if CONF_CUSTOM_FAN_MODE in config:
-        template_ = await cg.templatable(config[CONF_CUSTOM_FAN_MODE], args, str)
+        template_ = await cg.templatable(
+            config[CONF_CUSTOM_FAN_MODE], args, cg.std_string
+        )
         cg.add(var.set_custom_fan_mode(template_))
     if CONF_PRESET in config:
         template_ = await cg.templatable(config[CONF_PRESET], args, ClimatePreset)
         cg.add(var.set_preset(template_))
     if CONF_CUSTOM_PRESET in config:
-        template_ = await cg.templatable(config[CONF_CUSTOM_PRESET], args, str)
+        template_ = await cg.templatable(
+            config[CONF_CUSTOM_PRESET], args, cg.std_string
+        )
         cg.add(var.set_custom_preset(template_))
     if CONF_SWING_MODE in config:
         template_ = await cg.templatable(

esphome/components/climate/climate.cpp

@@ -419,7 +419,6 @@ void Climate::publish_state() {
   // Save state
   this->save_state_();
 }
-uint32_t Climate::hash_base() { return 3104134496UL; }
 
 ClimateTraits Climate::get_traits() {
   auto traits = this->traits();

esphome/components/climate/climate.h

@@ -282,7 +282,6 @@ class Climate : public EntityBase {
    */
   void save_state_();
 
-  uint32_t hash_base() override;
   void dump_traits_(const char *tag);
 
   CallbackManager<void()> state_callback_{};

esphome/components/copy/select/copy_select.cpp

@@ -7,7 +7,7 @@ namespace copy {
 static const char *const TAG = "copy.select";
 
 void CopySelect::setup() {
-  source_->add_on_state_callback([this](const std::string &value) { this->publish_state(value); });
+  source_->add_on_state_callback([this](const std::string &value, size_t index) { this->publish_state(value); });
 
   traits.set_options(source_->traits.get_options());
 

esphome/components/cover/cover.cpp

@@ -33,8 +33,6 @@ const char *cover_operation_to_str(CoverOperation op) {
 
 Cover::Cover(const std::string &name) : EntityBase(name), position{COVER_OPEN} {}
 
-uint32_t Cover::hash_base() { return 1727367479UL; }
-
 CoverCall::CoverCall(Cover *parent) : parent_(parent) {}
 CoverCall &CoverCall::set_command(const char *command) {
   if (strcasecmp(command, "OPEN") == 0) {

esphome/components/cover/cover.h

@@ -177,7 +177,6 @@ class Cover : public EntityBase {
   virtual std::string device_class();
 
   optional<CoverRestoreState> restore_state_();
-  uint32_t hash_base() override;
 
   CallbackManager<void()> state_callback_{};
   optional<std::string> device_class_override_{};

esphome/components/current_based/current_based_cover.cpp

@@ -131,7 +131,7 @@ void CurrentBasedCover::dump_config() {
   ESP_LOGCONFIG(TAG, "  Close Duration: %.1fs", this->close_duration_ / 1e3f);
   ESP_LOGCONFIG(TAG, "Obstacle Rollback: %.1f%%", this->obstacle_rollback_ * 100);
   if (this->max_duration_ != UINT32_MAX) {
-    ESP_LOGCONFIG(TAG, "Maximun duration: %.1fs", this->max_duration_ / 1e3f);
+    ESP_LOGCONFIG(TAG, "Maximum duration: %.1fs", this->max_duration_ / 1e3f);
   }
   ESP_LOGCONFIG(TAG, "Start sensing delay: %.1fs", this->start_sensing_delay_ / 1e3f);
   ESP_LOGCONFIG(TAG, "Malfunction detection: %s", YESNO(this->malfunction_detection_));

esphome/components/dac7678/__init__.py

@@ -0,0 +1,32 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c
+from esphome.const import CONF_ID
+
+AUTO_LOAD = ["output"]
+CODEOWNERS = ["@NickB1"]
+DEPENDENCIES = ["i2c"]
+MULTI_CONF = True
+
+dac7678_ns = cg.esphome_ns.namespace("dac7678")
+DAC7678Output = dac7678_ns.class_("DAC7678Output", cg.Component, i2c.I2CDevice)
+CONF_INTERNAL_REFERENCE = "internal_reference"
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(DAC7678Output),
+            cv.Optional(CONF_INTERNAL_REFERENCE, default=False): cv.boolean,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(i2c.i2c_device_schema(0x48))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    cg.add(var.set_internal_reference(config[CONF_INTERNAL_REFERENCE]))
+    await i2c.register_i2c_device(var, config)
+    return var

esphome/components/dac7678/dac7678_output.cpp

@@ -0,0 +1,83 @@
+#include "dac7678_output.h"
+#include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/hal.h"
+
+namespace esphome {
+namespace dac7678 {
+
+static const char *const TAG = "dac7678";
+
+static const uint8_t DAC7678_REG_INPUT_N = 0x00;
+static const uint8_t DAC7678_REG_SELECT_UPDATE_N = 0x10;
+static const uint8_t DAC7678_REG_WRITE_N_UPDATE_ALL = 0x20;
+static const uint8_t DAC7678_REG_WRITE_N_UPDATE_N = 0x30;
+static const uint8_t DAC7678_REG_POWER = 0x40;
+static const uint8_t DAC7678_REG_CLEAR_CODE = 0x50;
+static const uint8_t DAC7678_REG_LDAC = 0x60;
+static const uint8_t DAC7678_REG_SOFTWARE_RESET = 0x70;
+static const uint8_t DAC7678_REG_INTERNAL_REF_0 = 0x80;
+static const uint8_t DAC7678_REG_INTERNAL_REF_1 = 0x90;
+
+void DAC7678Output::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up DAC7678OutputComponent...");
+
+  ESP_LOGV(TAG, "Resetting device...");
+
+  // Reset device
+  if (!this->write_byte_16(DAC7678_REG_SOFTWARE_RESET, 0x0000)) {
+    ESP_LOGE(TAG, "Reset failed");
+    this->mark_failed();
+    return;
+  } else
+    ESP_LOGV(TAG, "Reset succeeded");
+
+  delayMicroseconds(1000);
+
+  // Set internal reference
+  if (this->internal_reference_) {
+    if (!this->write_byte_16(DAC7678_REG_INTERNAL_REF_0, 1 << 4)) {
+      ESP_LOGE(TAG, "Set internal reference failed");
+      this->mark_failed();
+      return;
+    } else
+      ESP_LOGV(TAG, "Internal reference enabled");
+  }
+}
+
+void DAC7678Output::dump_config() {
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Setting up DAC7678 failed!");
+  } else
+    ESP_LOGCONFIG(TAG, "DAC7678 initialised");
+}
+
+void DAC7678Output::register_channel(DAC7678Channel *channel) {
+  auto c = channel->channel_;
+  this->min_channel_ = std::min(this->min_channel_, c);
+  this->max_channel_ = std::max(this->max_channel_, c);
+  channel->set_parent(this);
+  ESP_LOGV(TAG, "Registered channel: %01u", channel->channel_);
+}
+
+void DAC7678Output::set_channel_value_(uint8_t channel, uint16_t value) {
+  if (this->dac_input_reg_[channel] != value) {
+    ESP_LOGV(TAG, "Channel %01u: input_reg=%04u ", channel, value);
+
+    if (!this->write_byte_16(DAC7678_REG_WRITE_N_UPDATE_N | channel, value << 4)) {
+      this->status_set_warning();
+      return;
+    }
+  }
+  this->dac_input_reg_[channel] = value;
+  this->status_clear_warning();
+}
+
+void DAC7678Channel::write_state(float state) {
+  const float input_rounded = roundf(state * this->full_scale_);
+  auto input = static_cast<uint16_t>(input_rounded);
+  this->parent_->set_channel_value_(this->channel_, input);
+}
+
+}  // namespace dac7678
+}  // namespace esphome

esphome/components/dac7678/dac7678_output.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "esphome/components/output/float_output.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace dac7678 {
+
+class DAC7678Output;
+
+class DAC7678Channel : public output::FloatOutput, public Parented<DAC7678Output> {
+ public:
+  void set_channel(uint8_t channel) { channel_ = channel; }
+
+ protected:
+  friend class DAC7678Output;
+
+  const uint16_t full_scale_ = 0xFFF;
+
+  void write_state(float state) override;
+
+  uint8_t channel_;
+};
+
+/// DAC7678 float output component.
+class DAC7678Output : public Component, public i2c::I2CDevice {
+ public:
+  DAC7678Output() {}
+
+  void register_channel(DAC7678Channel *channel);
+
+  void set_internal_reference(const bool value) { this->internal_reference_ = value; }
+
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::HARDWARE; }
+
+ protected:
+  friend DAC7678Channel;
+
+  bool internal_reference_;
+
+  void set_channel_value_(uint8_t channel, uint16_t value);
+
+  uint8_t min_channel_{0xFF};
+  uint8_t max_channel_{0x00};
+  uint16_t dac_input_reg_[8] = {
+      0,
+  };
+};
+
+}  // namespace dac7678
+}  // namespace esphome

esphome/components/dac7678/output.py

@@ -0,0 +1,27 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import output
+from esphome.const import CONF_CHANNEL, CONF_ID
+from . import DAC7678Output, dac7678_ns
+
+DEPENDENCIES = ["dac7678"]
+
+DAC7678Channel = dac7678_ns.class_("DAC7678Channel", output.FloatOutput)
+CONF_DAC7678_ID = "dac7678_id"
+
+CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
+    {
+        cv.Required(CONF_ID): cv.declare_id(DAC7678Channel),
+        cv.GenerateID(CONF_DAC7678_ID): cv.use_id(DAC7678Output),
+        cv.Required(CONF_CHANNEL): cv.int_range(min=0, max=7),
+    }
+)
+
+
+async def to_code(config):
+    paren = await cg.get_variable(config[CONF_DAC7678_ID])
+    var = cg.new_Pvariable(config[CONF_ID])
+    cg.add(var.set_channel(config[CONF_CHANNEL]))
+    cg.add(paren.register_channel(var))
+    await output.register_output(var, config)
+    return var

esphome/components/dallas/dallas_component.cpp

@@ -134,7 +134,6 @@ void DallasComponent::update() {
         return;
       }
       if (!sensor->check_scratch_pad()) {
-        ESP_LOGW(TAG, "'%s' - Scratch pad checksum invalid!", sensor->get_name().c_str());
         sensor->publish_state(NAN);
         this->status_set_warning();
         return;
@@ -241,13 +240,29 @@ bool DallasTemperatureSensor::setup_sensor() {
   return true;
 }
 bool DallasTemperatureSensor::check_scratch_pad() {
+  bool chksum_validity = (crc8(this->scratch_pad_, 8) == this->scratch_pad_[8]);
+  bool config_validity = false;
+
+  switch (this->get_address8()[0]) {
+    case DALLAS_MODEL_DS18B20:
+      config_validity = ((this->scratch_pad_[4] & 0x9F) == 0x1F);
+      break;
+    default:
+      config_validity = ((this->scratch_pad_[4] & 0x10) == 0x10);
+  }
+
 #ifdef ESPHOME_LOG_LEVEL_VERY_VERBOSE
   ESP_LOGVV(TAG, "Scratch pad: %02X.%02X.%02X.%02X.%02X.%02X.%02X.%02X.%02X (%02X)", this->scratch_pad_[0],
             this->scratch_pad_[1], this->scratch_pad_[2], this->scratch_pad_[3], this->scratch_pad_[4],
             this->scratch_pad_[5], this->scratch_pad_[6], this->scratch_pad_[7], this->scratch_pad_[8],
             crc8(this->scratch_pad_, 8));
 #endif
-  return crc8(this->scratch_pad_, 8) == this->scratch_pad_[8];
+  if (!chksum_validity) {
+    ESP_LOGW(TAG, "'%s' - Scratch pad checksum invalid!", this->get_name().c_str());
+  } else if (!config_validity) {
+    ESP_LOGW(TAG, "'%s' - Scratch pad config register invalid!", this->get_name().c_str());
+  }
+  return chksum_validity && config_validity;
 }
 float DallasTemperatureSensor::get_temp_c() {
   int16_t temp = (int16_t(this->scratch_pad_[1]) << 11) | (int16_t(this->scratch_pad_[0]) << 3);

esphome/components/dashboard_import/__init__.py

@@ -64,7 +64,10 @@ def import_config(path: str, name: str, project_name: str, import_url: str) -> N
         config = {
             "substitutions": {"name": name},
             "packages": {project_name: import_url},
-            "esphome": {"name_add_mac_suffix": False},
+            "esphome": {
+                "name": "${name}",
+                "name_add_mac_suffix": False,
+            },
         }
         p.write_text(
             dump(config) + WIFI_CONFIG,

esphome/components/deep_sleep/__init__.py

@@ -93,7 +93,14 @@ deep_sleep_ns = cg.esphome_ns.namespace("deep_sleep")
 DeepSleepComponent = deep_sleep_ns.class_("DeepSleepComponent", cg.Component)
 EnterDeepSleepAction = deep_sleep_ns.class_("EnterDeepSleepAction", automation.Action)
 PreventDeepSleepAction = deep_sleep_ns.class_(
-    "PreventDeepSleepAction", automation.Action
+    "PreventDeepSleepAction",
+    automation.Action,
+    cg.Parented.template(DeepSleepComponent),
+)
+AllowDeepSleepAction = deep_sleep_ns.class_(
+    "AllowDeepSleepAction",
+    automation.Action,
+    cg.Parented.template(DeepSleepComponent),
 )
 
 WakeupPinMode = deep_sleep_ns.enum("WakeupPinMode")
@@ -208,28 +215,32 @@ async def to_code(config):
     cg.add_define("USE_DEEP_SLEEP")
 
 
-DEEP_SLEEP_ENTER_SCHEMA = cv.All(
-    automation.maybe_simple_id(
-        {
-            cv.GenerateID(): cv.use_id(DeepSleepComponent),
-            cv.Exclusive(CONF_SLEEP_DURATION, "time"): cv.templatable(
-                cv.positive_time_period_milliseconds
-            ),
-            # Only on ESP32 due to how long the RTC on ESP8266 can stay asleep
-            cv.Exclusive(CONF_UNTIL, "time"): cv.All(cv.only_on_esp32, cv.time_of_day),
-            cv.Optional(CONF_TIME_ID): cv.use_id(time.RealTimeClock),
-        }
-    ),
-    cv.has_none_or_all_keys(CONF_UNTIL, CONF_TIME_ID),
-)
-
-
-DEEP_SLEEP_PREVENT_SCHEMA = automation.maybe_simple_id(
+DEEP_SLEEP_ACTION_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.use_id(DeepSleepComponent),
     }
 )
 
+DEEP_SLEEP_ENTER_SCHEMA = cv.All(
+    automation.maybe_simple_id(
+        DEEP_SLEEP_ACTION_SCHEMA.extend(
+            cv.Schema(
+                {
+                    cv.Exclusive(CONF_SLEEP_DURATION, "time"): cv.templatable(
+                        cv.positive_time_period_milliseconds
+                    ),
+                    # Only on ESP32 due to how long the RTC on ESP8266 can stay asleep
+                    cv.Exclusive(CONF_UNTIL, "time"): cv.All(
+                        cv.only_on_esp32, cv.time_of_day
+                    ),
+                    cv.Optional(CONF_TIME_ID): cv.use_id(time.RealTimeClock),
+                }
+            )
+        )
+    ),
+    cv.has_none_or_all_keys(CONF_UNTIL, CONF_TIME_ID),
+)
+
 
 @automation.register_action(
     "deep_sleep.enter", EnterDeepSleepAction, DEEP_SLEEP_ENTER_SCHEMA
@@ -252,8 +263,16 @@ async def deep_sleep_enter_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "deep_sleep.prevent", PreventDeepSleepAction, DEEP_SLEEP_PREVENT_SCHEMA
+    "deep_sleep.prevent",
+    PreventDeepSleepAction,
+    automation.maybe_simple_id(DEEP_SLEEP_ACTION_SCHEMA),
 )
-async def deep_sleep_prevent_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+@automation.register_action(
+    "deep_sleep.allow",
+    AllowDeepSleepAction,
+    automation.maybe_simple_id(DEEP_SLEEP_ACTION_SCHEMA),
+)
+async def deep_sleep_action_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var

esphome/components/deep_sleep/deep_sleep_component.cpp

@@ -21,6 +21,7 @@ optional<uint32_t> DeepSleepComponent::get_run_duration_() const {
     switch (wakeup_cause) {
       case ESP_SLEEP_WAKEUP_EXT0:
       case ESP_SLEEP_WAKEUP_EXT1:
+      case ESP_SLEEP_WAKEUP_GPIO:
         return this->wakeup_cause_to_run_duration_->gpio_cause;
       case ESP_SLEEP_WAKEUP_TOUCHPAD:
         return this->wakeup_cause_to_run_duration_->touch_cause;
@@ -72,16 +73,27 @@ float DeepSleepComponent::get_loop_priority() const {
   return -100.0f;  // run after everything else is ready
 }
 void DeepSleepComponent::set_sleep_duration(uint32_t time_ms) { this->sleep_duration_ = uint64_t(time_ms) * 1000; }
-#ifdef USE_ESP32
+#if defined(USE_ESP32)
 void DeepSleepComponent::set_wakeup_pin_mode(WakeupPinMode wakeup_pin_mode) {
   this->wakeup_pin_mode_ = wakeup_pin_mode;
 }
+#endif
+
+#if defined(USE_ESP32)
+#if !defined(USE_ESP32_VARIANT_ESP32C3)
+
 void DeepSleepComponent::set_ext1_wakeup(Ext1Wakeup ext1_wakeup) { this->ext1_wakeup_ = ext1_wakeup; }
+
 void DeepSleepComponent::set_touch_wakeup(bool touch_wakeup) { this->touch_wakeup_ = touch_wakeup; }
+
+#endif
+
 void DeepSleepComponent::set_run_duration(WakeupCauseToRunDuration wakeup_cause_to_run_duration) {
   wakeup_cause_to_run_duration_ = wakeup_cause_to_run_duration;
 }
+
 #endif
+
 void DeepSleepComponent::set_run_duration(uint32_t time_ms) { this->run_duration_ = time_ms; }
 void DeepSleepComponent::begin_sleep(bool manual) {
   if (this->prevent_ && !manual) {
@@ -107,7 +119,8 @@ void DeepSleepComponent::begin_sleep(bool manual) {
 
   App.run_safe_shutdown_hooks();
 
-#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3)
+#if defined(USE_ESP32)
+#if !defined(USE_ESP32_VARIANT_ESP32C3)
   if (this->sleep_duration_.has_value())
     esp_sleep_enable_timer_wakeup(*this->sleep_duration_);
   if (this->wakeup_pin_ != nullptr) {
@@ -125,10 +138,7 @@ void DeepSleepComponent::begin_sleep(bool manual) {
     esp_sleep_enable_touchpad_wakeup();
     esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
   }
-
-  esp_deep_sleep_start();
 #endif
-
 #ifdef USE_ESP32_VARIANT_ESP32C3
   if (this->sleep_duration_.has_value())
     esp_sleep_enable_timer_wakeup(*this->sleep_duration_);
@@ -137,9 +147,12 @@ void DeepSleepComponent::begin_sleep(bool manual) {
     if (this->wakeup_pin_mode_ == WAKEUP_PIN_MODE_INVERT_WAKEUP && this->wakeup_pin_->digital_read()) {
       level = !level;
     }
-    esp_deep_sleep_enable_gpio_wakeup(gpio_num_t(this->wakeup_pin_->get_pin()), level);
+    esp_deep_sleep_enable_gpio_wakeup(gpio_num_t(this->wakeup_pin_->get_pin()),
+                                      static_cast<esp_deepsleep_gpio_wake_up_mode_t>(level));
   }
 #endif
+  esp_deep_sleep_start();
+#endif
 
 #ifdef USE_ESP8266
   ESP.deepSleep(*this->sleep_duration_);  // NOLINT(readability-static-accessed-through-instance)
@@ -147,6 +160,7 @@ void DeepSleepComponent::begin_sleep(bool manual) {
 }
 float DeepSleepComponent::get_setup_priority() const { return setup_priority::LATE; }
 void DeepSleepComponent::prevent_deep_sleep() { this->prevent_ = true; }
+void DeepSleepComponent::allow_deep_sleep() { this->prevent_ = false; }
 
 }  // namespace deep_sleep
 }  // namespace esphome

esphome/components/deep_sleep/deep_sleep_component.h

@@ -70,17 +70,19 @@ class DeepSleepComponent : public Component {
   void set_wakeup_pin_mode(WakeupPinMode wakeup_pin_mode);
 #endif
 
-#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3)
+#if defined(USE_ESP32)
+#if !defined(USE_ESP32_VARIANT_ESP32C3)
 
   void set_ext1_wakeup(Ext1Wakeup ext1_wakeup);
 
   void set_touch_wakeup(bool touch_wakeup);
 
+#endif
   // Set the duration in ms for how long the code should run before entering
   // deep sleep mode, according to the cause the ESP32 has woken.
   void set_run_duration(WakeupCauseToRunDuration wakeup_cause_to_run_duration);
-
 #endif
+
   /// Set a duration in ms for how long the code should run before entering deep sleep mode.
   void set_run_duration(uint32_t time_ms);
 
@@ -94,6 +96,7 @@ class DeepSleepComponent : public Component {
   void begin_sleep(bool manual = false);
 
   void prevent_deep_sleep();
+  void allow_deep_sleep();
 
  protected:
   // Returns nullopt if no run duration is set. Otherwise, returns the run
@@ -187,14 +190,14 @@ template<typename... Ts> class EnterDeepSleepAction : public Action<Ts...> {
 #endif
 };
 
-template<typename... Ts> class PreventDeepSleepAction : public Action<Ts...> {
+template<typename... Ts> class PreventDeepSleepAction : public Action<Ts...>, public Parented<DeepSleepComponent> {
  public:
-  PreventDeepSleepAction(DeepSleepComponent *deep_sleep) : deep_sleep_(deep_sleep) {}
+  void play(Ts... x) override { this->parent_->prevent_deep_sleep(); }
+};
 
-  void play(Ts... x) override { this->deep_sleep_->prevent_deep_sleep(); }
-
- protected:
-  DeepSleepComponent *deep_sleep_;
+template<typename... Ts> class AllowDeepSleepAction : public Action<Ts...>, public Parented<DeepSleepComponent> {
+ public:
+  void play(Ts... x) override { this->parent_->allow_deep_sleep(); }
 };
 
 }  // namespace deep_sleep

esphome/components/delonghi/__init__.py

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

esphome/components/delonghi/climate.py

@@ -0,0 +1,20 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import climate_ir
+from esphome.const import CONF_ID
+
+AUTO_LOAD = ["climate_ir"]
+
+delonghi_ns = cg.esphome_ns.namespace("delonghi")
+DelonghiClimate = delonghi_ns.class_("DelonghiClimate", climate_ir.ClimateIR)
+
+CONFIG_SCHEMA = climate_ir.CLIMATE_IR_WITH_RECEIVER_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(DelonghiClimate),
+    }
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await climate_ir.register_climate_ir(var, config)

esphome/components/delonghi/delonghi.cpp

@@ -0,0 +1,186 @@
+#include "delonghi.h"
+#include "esphome/components/remote_base/remote_base.h"
+
+namespace esphome {
+namespace delonghi {
+
+static const char *const TAG = "delonghi.climate";
+
+void DelonghiClimate::transmit_state() {
+  uint8_t remote_state[DELONGHI_STATE_FRAME_SIZE] = {0};
+  remote_state[0] = DELONGHI_ADDRESS;
+  remote_state[1] = this->temperature_();
+  remote_state[1] |= (this->fan_speed_()) << 5;
+  remote_state[2] = this->operation_mode_();
+  // Calculate checksum
+  for (int i = 0; i < DELONGHI_STATE_FRAME_SIZE - 1; i++) {
+    remote_state[DELONGHI_STATE_FRAME_SIZE - 1] += remote_state[i];
+  }
+
+  auto transmit = this->transmitter_->transmit();
+  auto *data = transmit.get_data();
+  data->set_carrier_frequency(DELONGHI_IR_FREQUENCY);
+
+  data->mark(DELONGHI_HEADER_MARK);
+  data->space(DELONGHI_HEADER_SPACE);
+  for (unsigned char b : remote_state) {
+    for (uint8_t mask = 1; mask > 0; mask <<= 1) {  // iterate through bit mask
+      data->mark(DELONGHI_BIT_MARK);
+      bool bit = b & mask;
+      data->space(bit ? DELONGHI_ONE_SPACE : DELONGHI_ZERO_SPACE);
+    }
+  }
+  data->mark(DELONGHI_BIT_MARK);
+  data->space(0);
+
+  transmit.perform();
+}
+
+uint8_t DelonghiClimate::operation_mode_() {
+  uint8_t operating_mode = DELONGHI_MODE_ON;
+  switch (this->mode) {
+    case climate::CLIMATE_MODE_COOL:
+      operating_mode |= DELONGHI_MODE_COOL;
+      break;
+    case climate::CLIMATE_MODE_DRY:
+      operating_mode |= DELONGHI_MODE_DRY;
+      break;
+    case climate::CLIMATE_MODE_HEAT:
+      operating_mode |= DELONGHI_MODE_HEAT;
+      break;
+    case climate::CLIMATE_MODE_HEAT_COOL:
+      operating_mode |= DELONGHI_MODE_AUTO;
+      break;
+    case climate::CLIMATE_MODE_FAN_ONLY:
+      operating_mode |= DELONGHI_MODE_FAN;
+      break;
+    case climate::CLIMATE_MODE_OFF:
+    default:
+      operating_mode = DELONGHI_MODE_OFF;
+      break;
+  }
+  return operating_mode;
+}
+
+uint16_t DelonghiClimate::fan_speed_() {
+  uint16_t fan_speed;
+  switch (this->fan_mode.value()) {
+    case climate::CLIMATE_FAN_LOW:
+      fan_speed = DELONGHI_FAN_LOW;
+      break;
+    case climate::CLIMATE_FAN_MEDIUM:
+      fan_speed = DELONGHI_FAN_MEDIUM;
+      break;
+    case climate::CLIMATE_FAN_HIGH:
+      fan_speed = DELONGHI_FAN_HIGH;
+      break;
+    case climate::CLIMATE_FAN_AUTO:
+    default:
+      fan_speed = DELONGHI_FAN_AUTO;
+  }
+  return fan_speed;
+}
+
+uint8_t DelonghiClimate::temperature_() {
+  // Force special temperatures depending on the mode
+  uint8_t temperature = 0b0001;
+  switch (this->mode) {
+    case climate::CLIMATE_MODE_HEAT:
+      temperature = (uint8_t) roundf(this->target_temperature) - DELONGHI_TEMP_OFFSET_HEAT;
+      break;
+    case climate::CLIMATE_MODE_COOL:
+    case climate::CLIMATE_MODE_DRY:
+    case climate::CLIMATE_MODE_HEAT_COOL:
+    case climate::CLIMATE_MODE_FAN_ONLY:
+    case climate::CLIMATE_MODE_OFF:
+    default:
+      temperature = (uint8_t) roundf(this->target_temperature) - DELONGHI_TEMP_OFFSET_COOL;
+  }
+  if (temperature > 0x0F) {
+    temperature = 0x0F;  // clamp maximum
+  }
+  return temperature;
+}
+
+bool DelonghiClimate::parse_state_frame_(const uint8_t frame[]) {
+  uint8_t checksum = 0;
+  for (int i = 0; i < (DELONGHI_STATE_FRAME_SIZE - 1); i++) {
+    checksum += frame[i];
+  }
+  if (frame[DELONGHI_STATE_FRAME_SIZE - 1] != checksum) {
+    return false;
+  }
+  uint8_t mode = frame[2] & 0x0F;
+  if (mode & DELONGHI_MODE_ON) {
+    switch (mode & 0x0E) {
+      case DELONGHI_MODE_COOL:
+        this->mode = climate::CLIMATE_MODE_COOL;
+        break;
+      case DELONGHI_MODE_DRY:
+        this->mode = climate::CLIMATE_MODE_DRY;
+        break;
+      case DELONGHI_MODE_HEAT:
+        this->mode = climate::CLIMATE_MODE_HEAT;
+        break;
+      case DELONGHI_MODE_AUTO:
+        this->mode = climate::CLIMATE_MODE_HEAT_COOL;
+        break;
+      case DELONGHI_MODE_FAN:
+        this->mode = climate::CLIMATE_MODE_FAN_ONLY;
+        break;
+    }
+  } else {
+    this->mode = climate::CLIMATE_MODE_OFF;
+  }
+  uint8_t temperature = frame[1] & 0x0F;
+  if (this->mode == climate::CLIMATE_MODE_HEAT) {
+    this->target_temperature = temperature + DELONGHI_TEMP_OFFSET_HEAT;
+  } else {
+    this->target_temperature = temperature + DELONGHI_TEMP_OFFSET_COOL;
+  }
+  uint8_t fan_mode = frame[1] >> 5;
+  switch (fan_mode) {
+    case DELONGHI_FAN_LOW:
+      this->fan_mode = climate::CLIMATE_FAN_LOW;
+      break;
+    case DELONGHI_FAN_MEDIUM:
+      this->fan_mode = climate::CLIMATE_FAN_MEDIUM;
+      break;
+    case DELONGHI_FAN_HIGH:
+      this->fan_mode = climate::CLIMATE_FAN_HIGH;
+      break;
+    case DELONGHI_FAN_AUTO:
+      this->fan_mode = climate::CLIMATE_FAN_AUTO;
+      break;
+  }
+  this->publish_state();
+  return true;
+}
+
+bool DelonghiClimate::on_receive(remote_base::RemoteReceiveData data) {
+  uint8_t state_frame[DELONGHI_STATE_FRAME_SIZE] = {};
+  if (!data.expect_item(DELONGHI_HEADER_MARK, DELONGHI_HEADER_SPACE)) {
+    return false;
+  }
+  for (uint8_t pos = 0; pos < DELONGHI_STATE_FRAME_SIZE; pos++) {
+    uint8_t byte = 0;
+    for (int8_t bit = 0; bit < 8; bit++) {
+      if (data.expect_item(DELONGHI_BIT_MARK, DELONGHI_ONE_SPACE)) {
+        byte |= 1 << bit;
+      } else if (!data.expect_item(DELONGHI_BIT_MARK, DELONGHI_ZERO_SPACE)) {
+        return false;
+      }
+    }
+    state_frame[pos] = byte;
+    if (pos == 0) {
+      // frame header
+      if (byte != DELONGHI_ADDRESS) {
+        return false;
+      }
+    }
+  }
+  return this->parse_state_frame_(state_frame);
+}
+
+}  // namespace delonghi
+}  // namespace esphome

esphome/components/delonghi/delonghi.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "esphome/components/climate_ir/climate_ir.h"
+
+namespace esphome {
+namespace delonghi {
+
+// Values for DELONGHI ARC43XXX IR Controllers
+const uint8_t DELONGHI_ADDRESS = 83;
+
+// Temperature
+const uint8_t DELONGHI_TEMP_MIN = 13;          // Celsius
+const uint8_t DELONGHI_TEMP_MAX = 32;          // Celsius
+const uint8_t DELONGHI_TEMP_OFFSET_COOL = 17;  // Celsius
+const uint8_t DELONGHI_TEMP_OFFSET_HEAT = 12;  // Celsius
+
+// Modes
+const uint8_t DELONGHI_MODE_AUTO = 0b1000;
+const uint8_t DELONGHI_MODE_COOL = 0b0000;
+const uint8_t DELONGHI_MODE_HEAT = 0b0110;
+const uint8_t DELONGHI_MODE_DRY = 0b0010;
+const uint8_t DELONGHI_MODE_FAN = 0b0100;
+const uint8_t DELONGHI_MODE_OFF = 0b0000;
+const uint8_t DELONGHI_MODE_ON = 0b0001;
+
+// Fan Speed
+const uint8_t DELONGHI_FAN_AUTO = 0b00;
+const uint8_t DELONGHI_FAN_HIGH = 0b01;
+const uint8_t DELONGHI_FAN_MEDIUM = 0b10;
+const uint8_t DELONGHI_FAN_LOW = 0b11;
+
+// IR Transmission - similar to NEC1
+const uint32_t DELONGHI_IR_FREQUENCY = 38000;
+const uint32_t DELONGHI_HEADER_MARK = 9000;
+const uint32_t DELONGHI_HEADER_SPACE = 4500;
+const uint32_t DELONGHI_BIT_MARK = 465;
+const uint32_t DELONGHI_ONE_SPACE = 1750;
+const uint32_t DELONGHI_ZERO_SPACE = 670;
+
+// State Frame size
+const uint8_t DELONGHI_STATE_FRAME_SIZE = 8;
+
+class DelonghiClimate : public climate_ir::ClimateIR {
+ public:
+  DelonghiClimate()
+      : climate_ir::ClimateIR(DELONGHI_TEMP_MIN, DELONGHI_TEMP_MAX, 1.0f, true, true,
+                              {climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM,
+                               climate::CLIMATE_FAN_HIGH},
+                              {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL,
+                               climate::CLIMATE_SWING_HORIZONTAL, climate::CLIMATE_SWING_BOTH}) {}
+
+ protected:
+  // Transmit via IR the state of this climate controller.
+  void transmit_state() override;
+  uint8_t operation_mode_();
+  uint16_t fan_speed_();
+  uint8_t temperature_();
+  // Handle received IR Buffer
+  bool on_receive(remote_base::RemoteReceiveData data) override;
+  bool parse_state_frame_(const uint8_t frame[]);
+};
+
+}  // namespace delonghi
+}  // namespace esphome

esphome/components/dfplayer/__init__.py

@@ -348,7 +348,7 @@ async def dfplayer_random_to_code(config, action_id, template_arg, args):
         }
     ),
 )
-async def dfplyaer_is_playing_to_code(config, condition_id, template_arg, args):
+async def dfplayer_is_playing_to_code(config, condition_id, template_arg, args):
     var = cg.new_Pvariable(condition_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
     return var

esphome/components/display/display_buffer.cpp

@@ -242,6 +242,13 @@ void DisplayBuffer::image(int x, int y, Image *image, Color color_on, Color colo
         }
       }
       break;
+    case IMAGE_TYPE_RGB565:
+      for (int img_x = 0; img_x < image->get_width(); img_x++) {
+        for (int img_y = 0; img_y < image->get_height(); img_y++) {
+          this->draw_pixel_at(x + img_x, y + img_y, image->get_rgb565_pixel(img_x, img_y));
+        }
+      }
+      break;
   }
 }
 
@@ -497,6 +504,17 @@ Color Image::get_color_pixel(int x, int y) const {
                            (progmem_read_byte(this->data_start_ + pos + 0) << 16);
   return Color(color32);
 }
+Color Image::get_rgb565_pixel(int x, int y) const {
+  if (x < 0 || x >= this->width_ || y < 0 || y >= this->height_)
+    return Color::BLACK;
+  const uint32_t pos = (x + y * this->width_) * 2;
+  uint16_t rgb565 =
+      progmem_read_byte(this->data_start_ + pos + 0) << 8 | progmem_read_byte(this->data_start_ + pos + 1);
+  auto r = (rgb565 & 0xF800) >> 11;
+  auto g = (rgb565 & 0x07E0) >> 5;
+  auto b = rgb565 & 0x001F;
+  return Color((r << 3) | (r >> 2), (g << 2) | (g >> 4), (b << 3) | (b >> 2));
+}
 Color Image::get_grayscale_pixel(int x, int y) const {
   if (x < 0 || x >= this->width_ || y < 0 || y >= this->height_)
     return Color::BLACK;
@@ -532,6 +550,20 @@ Color Animation::get_color_pixel(int x, int y) const {
                            (progmem_read_byte(this->data_start_ + pos + 0) << 16);
   return Color(color32);
 }
+Color Animation::get_rgb565_pixel(int x, int y) const {
+  if (x < 0 || x >= this->width_ || y < 0 || y >= this->height_)
+    return Color::BLACK;
+  const uint32_t frame_index = this->width_ * this->height_ * this->current_frame_;
+  if (frame_index >= (uint32_t)(this->width_ * this->height_ * this->animation_frame_count_))
+    return Color::BLACK;
+  const uint32_t pos = (x + y * this->width_ + frame_index) * 2;
+  uint16_t rgb565 =
+      progmem_read_byte(this->data_start_ + pos + 0) << 8 | progmem_read_byte(this->data_start_ + pos + 1);
+  auto r = (rgb565 & 0xF800) >> 11;
+  auto g = (rgb565 & 0x07E0) >> 5;
+  auto b = rgb565 & 0x001F;
+  return Color((r << 3) | (r >> 2), (g << 2) | (g >> 4), (b << 3) | (b >> 2));
+}
 Color Animation::get_grayscale_pixel(int x, int y) const {
   if (x < 0 || x >= this->width_ || y < 0 || y >= this->height_)
     return Color::BLACK;
@@ -552,6 +584,12 @@ void Animation::next_frame() {
     this->current_frame_ = 0;
   }
 }
+void Animation::prev_frame() {
+  this->current_frame_--;
+  if (this->current_frame_ < 0) {
+    this->current_frame_ = this->animation_frame_count_ - 1;
+  }
+}
 
 DisplayPage::DisplayPage(display_writer_t writer) : writer_(std::move(writer)) {}
 void DisplayPage::show() { this->parent_->show_page(this); }

esphome/components/display/display_buffer.h

@@ -82,6 +82,13 @@ enum ImageType {
   IMAGE_TYPE_GRAYSCALE = 1,
   IMAGE_TYPE_RGB24 = 2,
   IMAGE_TYPE_TRANSPARENT_BINARY = 3,
+  IMAGE_TYPE_RGB565 = 4,
+};
+
+enum DisplayType {
+  DISPLAY_TYPE_BINARY = 1,
+  DISPLAY_TYPE_GRAYSCALE = 2,
+  DISPLAY_TYPE_COLOR = 3,
 };
 
 enum DisplayRotation {
@@ -360,6 +367,11 @@ class DisplayBuffer {
   virtual int get_width_internal() = 0;
   DisplayRotation get_rotation() const { return this->rotation_; }
 
+  /** Get the type of display that the buffer corresponds to. In case of dynamically configurable displays,
+   * returns the type the display is currently configured to.
+   */
+  virtual DisplayType get_display_type() = 0;
+
  protected:
   void vprintf_(int x, int y, Font *font, Color color, TextAlign align, const char *format, va_list arg);
 
@@ -453,6 +465,7 @@ class Image {
   Image(const uint8_t *data_start, int width, int height, ImageType type);
   virtual bool get_pixel(int x, int y) const;
   virtual Color get_color_pixel(int x, int y) const;
+  virtual Color get_rgb565_pixel(int x, int y) const;
   virtual Color get_grayscale_pixel(int x, int y) const;
   int get_width() const;
   int get_height() const;
@@ -470,11 +483,13 @@ class Animation : public Image {
   Animation(const uint8_t *data_start, int width, int height, uint32_t animation_frame_count, ImageType type);
   bool get_pixel(int x, int y) const override;
   Color get_color_pixel(int x, int y) const override;
+  Color get_rgb565_pixel(int x, int y) const override;
   Color get_grayscale_pixel(int x, int y) const override;
 
   int get_animation_frame_count() const;
   int get_current_frame() const;
   void next_frame();
+  void prev_frame();
 
  protected:
   int current_frame_;

esphome/components/display/display_color_utils.h

@@ -66,6 +66,9 @@ class ColorUtil {
     }
     return color_return;
   }
+  static inline Color rgb332_to_color(uint8_t rgb332_color) {
+    return to_color((uint32_t) rgb332_color, COLOR_ORDER_RGB, COLOR_BITNESS_332);
+  }
   static uint8_t color_to_332(Color color, ColorOrder color_order = ColorOrder::COLOR_ORDER_RGB) {
     uint16_t red_color, green_color, blue_color;
 
@@ -100,11 +103,57 @@ class ColorUtil {
     }
     return 0;
   }
-
   static uint32_t color_to_grayscale4(Color color) {
     uint32_t gs4 = esp_scale8(color.white, 15);
     return gs4;
   }
+  /***
+   * Converts a Color value to an 8bit index using a 24bit 888 palette.
+   * Uses euclidiean distance to calculate the linear distance between
+   * two points in an RGB cube, then iterates through the full palette
+   * returning the closest match.
+   * @param[in] color The target color.
+   * @param[in] palette The 256*3 byte RGB palette.
+   * @return The 8 bit index of the closest color (e.g. for display buffer).
+   */
+  // static uint8_t color_to_index8_palette888(Color color, uint8_t *palette) {
+  static uint8_t color_to_index8_palette888(Color color, const uint8_t *palette) {
+    uint8_t closest_index = 0;
+    uint32_t minimum_dist2 = UINT32_MAX;  // Smallest distance^2 to the target
+                                          // so far
+    // int8_t(*plt)[][3] = palette;
+    int16_t tgt_r = color.r;
+    int16_t tgt_g = color.g;
+    int16_t tgt_b = color.b;
+    uint16_t x, y, z;
+    // Loop through each row of the palette
+    for (uint16_t i = 0; i < 256; i++) {
+      // Get the pallet rgb color
+      int16_t plt_r = (int16_t) palette[i * 3 + 0];
+      int16_t plt_g = (int16_t) palette[i * 3 + 1];
+      int16_t plt_b = (int16_t) palette[i * 3 + 2];
+      // Calculate euclidean distance (linear distance in rgb cube).
+      x = (uint32_t) std::abs(tgt_r - plt_r);
+      y = (uint32_t) std::abs(tgt_g - plt_g);
+      z = (uint32_t) std::abs(tgt_b - plt_b);
+      uint32_t dist2 = x * x + y * y + z * z;
+      if (dist2 < minimum_dist2) {
+        minimum_dist2 = dist2;
+        closest_index = (uint8_t) i;
+      }
+    }
+    return closest_index;
+  }
+  /***
+   * Converts an 8bit palette index (e.g. from a display buffer) to a color.
+   * @param[in] index The index to look up.
+   * @param[in] palette The 256*3 byte RGB palette.
+   * @return The RGBW Color object looked up by the palette.
+   */
+  static Color index8_to_color_palette888(uint8_t index, const uint8_t *palette) {
+    Color color = Color(palette[index * 3 + 0], palette[index * 3 + 1], palette[index * 3 + 2], 0);
+    return color;
+  }
 };
 }  // namespace display
 }  // namespace esphome

esphome/components/dsmr/__init__.py

@@ -79,7 +79,7 @@ async def to_code(config):
     cg.add(var.set_request_interval(config[CONF_REQUEST_INTERVAL].total_milliseconds))
     cg.add(var.set_receive_timeout(config[CONF_RECEIVE_TIMEOUT].total_milliseconds))
 
-    cg.add_define("DSMR_GAS_MBUS_ID", config[CONF_GAS_MBUS_ID])
+    cg.add_build_flag("-DDSMR_GAS_MBUS_ID=" + str(config[CONF_GAS_MBUS_ID]))
 
     # DSMR Parser
     cg.add_library("glmnet/Dsmr", "0.5")

esphome/components/dsmr/dsmr.cpp

@@ -171,7 +171,7 @@ void Dsmr::receive_telegram_() {
     this->telegram_[this->bytes_read_] = c;
     this->bytes_read_++;
 
-    // Check for a footer, i.e. exlamation mark, followed by a hex checksum.
+    // Check for a footer, i.e. exclamation mark, followed by a hex checksum.
     if (c == '!') {
       ESP_LOGV(TAG, "Footer of telegram found");
       this->footer_found_ = true;

esphome/components/ens210/ens210.cpp

@@ -0,0 +1,230 @@
+// ENS210 relative humidity and temperature sensor with I2C interface from ScioSense
+//
+// Datasheet: https://www.sciosense.com/wp-content/uploads/2021/01/ENS210.pdf
+//
+// Implementation based on:
+//   https://github.com/maarten-pennings/ENS210
+//   https://github.com/sciosense/ENS210_driver
+
+#include "ens210.h"
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+
+namespace esphome {
+namespace ens210 {
+
+static const char *const TAG = "ens210";
+
+// ENS210 chip constants
+static const uint8_t ENS210_BOOTING_MS = 2;  // Booting time in ms (also after reset, or going to high power)
+static const uint8_t ENS210_SINGLE_MEASURMENT_CONVERSION_TIME_MS =
+    130;                                        // Conversion time in ms for single shot T/H measurement
+static const uint16_t ENS210_PART_ID = 0x0210;  // The expected part id of the ENS210
+
+// Addresses of the ENS210 registers
+static const uint8_t ENS210_REGISTER_PART_ID = 0x00;
+static const uint8_t ENS210_REGISTER_UID = 0x04;
+static const uint8_t ENS210_REGISTER_SYS_CTRL = 0x10;
+static const uint8_t ENS210_REGISTER_SYS_STAT = 0x11;
+static const uint8_t ENS210_REGISTER_SENS_RUN = 0x21;
+static const uint8_t ENS210_REGISTER_SENS_START = 0x22;
+static const uint8_t ENS210_REGISTER_SENS_STOP = 0x23;
+static const uint8_t ENS210_REGISTER_SENS_STAT = 0x24;
+static const uint8_t ENS210_REGISTER_T_VAL = 0x30;
+static const uint8_t ENS210_REGISTER_H_VAL = 0x33;
+
+// CRC-7 constants
+static const uint8_t CRC7_WIDTH = 7;    // A 7 bits CRC has polynomial of 7th order, which has 8 terms
+static const uint8_t CRC7_POLY = 0x89;  // The 8 coefficients of the polynomial
+static const uint8_t CRC7_IVEC = 0x7F;  // Initial vector has all 7 bits high
+
+// Payload data constants
+static const uint8_t DATA7_WIDTH = 17;
+static const uint32_t DATA7_MASK = ((1UL << DATA7_WIDTH) - 1);  // 0b 0 1111 1111 1111 1111
+static const uint32_t DATA7_MSB = (1UL << (DATA7_WIDTH - 1));   // 0b 1 0000 0000 0000 0000
+
+// Converts a status to a human readable string
+static const LogString *ens210_status_to_human(int status) {
+  switch (status) {
+    case ENS210Component::ENS210_STATUS_I2C_ERROR:
+      return LOG_STR("I2C error - communication with ENS210 failed!");
+    case ENS210Component::ENS210_STATUS_CRC_ERROR:
+      return LOG_STR("CRC error");
+    case ENS210Component::ENS210_STATUS_INVALID:
+      return LOG_STR("Invalid data");
+    case ENS210Component::ENS210_STATUS_OK:
+      return LOG_STR("Status OK");
+    case ENS210Component::ENS210_WRONG_CHIP_ID:
+      return LOG_STR("ENS210 has wrong chip ID! Is it a ENS210?");
+    default:
+      return LOG_STR("Unknown");
+  }
+}
+
+// Compute the CRC-7 of 'value' (should only have 17 bits)
+// https://en.wikipedia.org/wiki/Cyclic_redundancy_check#Computation
+static uint32_t crc7(uint32_t value) {
+  // Setup polynomial
+  uint32_t polynomial = CRC7_POLY;
+  // Align polynomial with data
+  polynomial = polynomial << (DATA7_WIDTH - CRC7_WIDTH - 1);
+  // Loop variable (indicates which bit to test, start with highest)
+  uint32_t bit = DATA7_MSB;
+  // Make room for CRC value
+  value = value << CRC7_WIDTH;
+  bit = bit << CRC7_WIDTH;
+  polynomial = polynomial << CRC7_WIDTH;
+  // Insert initial vector
+  value |= CRC7_IVEC;
+  // Apply division until all bits done
+  while (bit & (DATA7_MASK << CRC7_WIDTH)) {
+    if (bit & value)
+      value ^= polynomial;
+    bit >>= 1;
+    polynomial >>= 1;
+  }
+  return value;
+}
+
+void ENS210Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up ENS210...");
+  uint8_t data[2];
+  uint16_t part_id = 0;
+  // Reset
+  if (!this->write_byte(ENS210_REGISTER_SYS_CTRL, 0x80)) {
+    this->write_byte(ENS210_REGISTER_SYS_CTRL, 0x80);
+    this->error_code_ = ENS210_STATUS_I2C_ERROR;
+    this->mark_failed();
+    return;
+  }
+  // Wait to boot after reset
+  delay(ENS210_BOOTING_MS);
+  // Must disable low power to read PART_ID
+  if (!set_low_power_(false)) {
+    // Try to go back to default mode (low power enabled)
+    set_low_power_(true);
+    this->error_code_ = ENS210_STATUS_I2C_ERROR;
+    this->mark_failed();
+    return;
+  }
+  // Read the PART_ID
+  if (!this->read_bytes(ENS210_REGISTER_PART_ID, data, 2)) {
+    // Try to go back to default mode (low power enabled)
+    set_low_power_(true);
+    this->error_code_ = ENS210_STATUS_I2C_ERROR;
+    this->mark_failed();
+    return;
+  }
+  // Pack bytes into partid
+  part_id = data[1] * 256U + data[0] * 1U;
+  // Check expected part id of the ENS210
+  if (part_id != ENS210_PART_ID) {
+    this->error_code_ = ENS210_WRONG_CHIP_ID;
+    this->mark_failed();
+  }
+  // Set default power mode (low power enabled)
+  set_low_power_(true);
+}
+
+void ENS210Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "ENS210:");
+  LOG_I2C_DEVICE(this);
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "%s", LOG_STR_ARG(ens210_status_to_human(this->error_code_)));
+  }
+  LOG_UPDATE_INTERVAL(this);
+  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+  LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
+}
+
+float ENS210Component::get_setup_priority() const { return setup_priority::DATA; }
+
+void ENS210Component::update() {
+  // Execute a single measurement
+  if (!this->write_byte(ENS210_REGISTER_SENS_RUN, 0x00)) {
+    ESP_LOGE(TAG, "Starting single measurement failed!");
+    this->status_set_warning();
+    return;
+  }
+  // Trigger measurement
+  if (!this->write_byte(ENS210_REGISTER_SENS_START, 0x03)) {
+    ESP_LOGE(TAG, "Trigger of measurement failed!");
+    this->status_set_warning();
+    return;
+  }
+  // Wait for measurement to complete
+  this->set_timeout("data", uint32_t(ENS210_SINGLE_MEASURMENT_CONVERSION_TIME_MS), [this]() {
+    int temperature_data, temperature_status, humidity_data, humidity_status;
+    uint8_t data[6];
+    uint32_t h_val_data, t_val_data;
+    // Set default status for early bail out
+    temperature_status = ENS210_STATUS_I2C_ERROR;
+    humidity_status = ENS210_STATUS_I2C_ERROR;
+
+    // Read T_VAL and H_VAL
+    if (!this->read_bytes(ENS210_REGISTER_T_VAL, data, 6)) {
+      ESP_LOGE(TAG, "Communication with ENS210 failed!");
+      this->status_set_warning();
+      return;
+    }
+    // Pack bytes for humidity
+    h_val_data = (uint32_t)((uint32_t) data[5] << 16 | (uint32_t) data[4] << 8 | (uint32_t) data[3]);
+    // Extract humidity data and update the status
+    extract_measurement_(h_val_data, &humidity_data, &humidity_status);
+
+    if (humidity_status == ENS210_STATUS_OK) {
+      if (this->humidity_sensor_ != nullptr) {
+        float humidity = (humidity_data & 0xFFFF) / 512.0;
+        this->humidity_sensor_->publish_state(humidity);
+      }
+    } else {
+      ESP_LOGW(TAG, "Humidity status failure: %s", LOG_STR_ARG(ens210_status_to_human(humidity_status)));
+      this->status_set_warning();
+      return;
+    }
+    // Pack bytes for temperature
+    t_val_data = (uint32_t)((uint32_t) data[2] << 16 | (uint32_t) data[1] << 8 | (uint32_t) data[0]);
+    // Extract temperature data and update the status
+    extract_measurement_(t_val_data, &temperature_data, &temperature_status);
+
+    if (temperature_status == ENS210_STATUS_OK) {
+      if (this->temperature_sensor_ != nullptr) {
+        // Temperature in Celsius
+        float temperature = (temperature_data & 0xFFFF) / 64.0 - 27315L / 100.0;
+        this->temperature_sensor_->publish_state(temperature);
+      }
+    } else {
+      ESP_LOGW(TAG, "Temperature status failure: %s", LOG_STR_ARG(ens210_status_to_human(temperature_status)));
+    }
+  });
+}
+
+// Extracts measurement 'data' and 'status' from a 'val' obtained from measurement.
+void ENS210Component::extract_measurement_(uint32_t val, int *data, int *status) {
+  *data = (val >> 0) & 0xffff;
+  int valid = (val >> 16) & 0x1;
+  uint32_t crc = (val >> 17) & 0x7f;
+  uint32_t payload = (val >> 0) & 0x1ffff;
+  // Check CRC
+  uint8_t crc_ok = crc7(payload) == crc;
+
+  if (!crc_ok) {
+    *status = ENS210_STATUS_CRC_ERROR;
+  } else if (!valid) {
+    *status = ENS210_STATUS_INVALID;
+  } else {
+    *status = ENS210_STATUS_OK;
+  }
+}
+
+// Sets ENS210 to low (true) or high (false) power. Returns false on I2C problems.
+bool ENS210Component::set_low_power_(bool enable) {
+  uint8_t low_power_cmd = enable ? 0x01 : 0x00;
+  ESP_LOGD(TAG, "Enable low power: %s", enable ? "true" : "false");
+  bool result = this->write_byte(ENS210_REGISTER_SYS_CTRL, low_power_cmd);
+  delay(ENS210_BOOTING_MS);
+  return result;
+}
+
+}  // namespace ens210
+}  // namespace esphome

esphome/components/ens210/ens210.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace ens210 {
+
+/// This class implements support for the ENS210 relative humidity and temperature i2c sensor.
+class ENS210Component : public PollingComponent, public i2c::I2CDevice {
+ public:
+  float get_setup_priority() const override;
+  void dump_config() override;
+  void setup() override;
+  void update() override;
+
+  void set_humidity_sensor(sensor::Sensor *humidity_sensor) { humidity_sensor_ = humidity_sensor; }
+  void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
+
+  enum ErrorCode {
+    ENS210_STATUS_OK = 0,     // The value was read, the CRC matches, and data is valid
+    ENS210_STATUS_INVALID,    // The value was read, the CRC matches, but the data is invalid (e.g. the measurement was
+                              // not yet finished)
+    ENS210_STATUS_CRC_ERROR,  // The value was read, but the CRC over the payload (valid and data) does not match
+    ENS210_STATUS_I2C_ERROR,  // There was an I2C communication error
+    ENS210_WRONG_CHIP_ID      // The read PART_ID is not the expected part id of the ENS210
+  } error_code_{ENS210_STATUS_OK};
+
+ protected:
+  bool set_low_power_(bool enable);
+  void extract_measurement_(uint32_t val, int *data, int *status);
+
+  sensor::Sensor *temperature_sensor_;
+  sensor::Sensor *humidity_sensor_;
+};
+
+}  // namespace ens210
+}  // namespace esphome

esphome/components/ens210/sensor.py

@@ -0,0 +1,58 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c, sensor
+from esphome.const import (
+    CONF_HUMIDITY,
+    CONF_ID,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_TEMPERATURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_PERCENT,
+)
+
+CODEOWNERS = ["@itn3rd77"]
+DEPENDENCIES = ["i2c"]
+
+ens210_ns = cg.esphome_ns.namespace("ens210")
+
+ENS210Component = ens210_ns.class_(
+    "ENS210Component", cg.PollingComponent, i2c.I2CDevice
+)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ENS210Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_HUMIDITY,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x43))
+)
+
+
+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)
+
+    if CONF_TEMPERATURE in config:
+        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
+        cg.add(var.set_temperature_sensor(sens))
+
+    if CONF_HUMIDITY in config:
+        sens = await sensor.new_sensor(config[CONF_HUMIDITY])
+        cg.add(var.set_humidity_sensor(sens))

esphome/components/esp32/__init__.py

@@ -129,7 +129,7 @@ def _format_framework_espidf_version(ver: cv.Version) -> str:
 # The default/recommended arduino framework version
 #  - https://github.com/espressif/arduino-esp32/releases
 #  - https://api.registry.platformio.org/v3/packages/platformio/tool/framework-arduinoespressif32
-RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(2, 0, 0)
+RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(1, 0, 6)
 # The platformio/espressif32 version to use for arduino frameworks
 #  - https://github.com/platformio/platform-espressif32/releases
 #  - https://api.registry.platformio.org/v3/packages/platformio/platform/espressif32

esphome/components/esp32/boards.py

@@ -521,6 +521,33 @@ ESP32_BOARD_PINS = {
     },
     "lolin32": {"LED": 5},
     "lolin32_lite": {"LED": 22},
+    "lolin_c3_mini": {
+        "TX": 21,
+        "RX": 20,
+        "SDA": 8,
+        "SCL": 10,
+        "SS": 5,
+        "MOSI": 4,
+        "MISO": 3,
+        "SCK": 2,
+        "A0": 0,
+        "A1": 1,
+        "A2": 2,
+        "A3": 3,
+        "A4": 4,
+        "A5": 5,
+        "D0": 1,
+        "D1": 10,
+        "D2": 8,
+        "D3": 7,
+        "D4": 6,
+        "D5": 2,
+        "D6": 3,
+        "D7": 4,
+        "D8": 5,
+        "LED": 7,
+        "BUTTON": 9,
+    },
     "lolin_d32": {"LED": 5, "_VBAT": 35},
     "lolin_d32_pro": {"LED": 5, "_VBAT": 35},
     "lopy": {
@@ -1026,6 +1053,7 @@ BOARD_TO_VARIANT = {
     "labplus_mpython": VARIANT_ESP32,
     "lolin32_lite": VARIANT_ESP32,
     "lolin32": VARIANT_ESP32,
+    "lolin_c3_mini": VARIANT_ESP32C3,
     "lolin_d32_pro": VARIANT_ESP32,
     "lolin_d32": VARIANT_ESP32,
     "lopy4": VARIANT_ESP32,

esphome/components/esp32/gpio.py

@@ -107,7 +107,7 @@ def validate_gpio_pin(value):
     value = _translate_pin(value)
     variant = CORE.data[KEY_ESP32][KEY_VARIANT]
     if variant not in _esp32_validations:
-        raise cv.Invalid("Unsupported ESP32 variant {variant}")
+        raise cv.Invalid(f"Unsupported ESP32 variant {variant}")
 
     return _esp32_validations[variant].pin_validation(value)
 
@@ -121,7 +121,7 @@ def validate_supports(value):
     is_pulldown = mode[CONF_PULLDOWN]
     variant = CORE.data[KEY_ESP32][KEY_VARIANT]
     if variant not in _esp32_validations:
-        raise cv.Invalid("Unsupported ESP32 variant {variant}")
+        raise cv.Invalid(f"Unsupported ESP32 variant {variant}")
 
     if is_open_drain and not is_output:
         raise cv.Invalid(

esphome/components/esp32/preferences.cpp

@@ -36,6 +36,7 @@ class ESP32PreferenceBackend : public ESPPreferenceBackend {
     save.key = key;
     save.data.assign(data, data + len);
     s_pending_save.emplace_back(save);
+    ESP_LOGVV(TAG, "s_pending_save: key: %s, len: %d", key.c_str(), len);
     return true;
   }
   bool load(uint8_t *data, size_t len) override {
@@ -65,6 +66,8 @@ class ESP32PreferenceBackend : public ESPPreferenceBackend {
     if (err != 0) {
       ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", key.c_str(), esp_err_to_name(err));
       return false;
+    } else {
+      ESP_LOGVV(TAG, "nvs_get_blob: key: %s, len: %d", key.c_str(), len);
     }
     return true;
   }
@@ -73,7 +76,6 @@ class ESP32PreferenceBackend : public ESPPreferenceBackend {
 class ESP32Preferences : public ESPPreferences {
  public:
   uint32_t nvs_handle;
-  uint32_t current_offset = 0;
 
   void open() {
     nvs_flash_init();
@@ -97,12 +99,9 @@ class ESP32Preferences : public ESPPreferences {
   ESPPreferenceObject make_preference(size_t length, uint32_t type) override {
     auto *pref = new ESP32PreferenceBackend();  // NOLINT(cppcoreguidelines-owning-memory)
     pref->nvs_handle = nvs_handle;
-    current_offset += length;
 
-    uint32_t keyval = current_offset ^ type;
-    char keybuf[16];
-    snprintf(keybuf, sizeof(keybuf), "%d", keyval);
-    pref->key = keybuf;  // copied to std::string
+    uint32_t keyval = type;
+    pref->key = str_sprintf("%u", keyval);
 
     return ESPPreferenceObject(pref);
   }
@@ -118,12 +117,18 @@ class ESP32Preferences : public ESPPreferences {
     // go through vector from back to front (makes erase easier/more efficient)
     for (ssize_t i = s_pending_save.size() - 1; i >= 0; i--) {
       const auto &save = s_pending_save[i];
-      esp_err_t err = nvs_set_blob(nvs_handle, save.key.c_str(), save.data.data(), save.data.size());
-      if (err != 0) {
-        ESP_LOGV(TAG, "nvs_set_blob('%s', len=%u) failed: %s", save.key.c_str(), save.data.size(),
-                 esp_err_to_name(err));
-        any_failed = true;
-        continue;
+      ESP_LOGVV(TAG, "Checking if NVS data %s has changed", save.key.c_str());
+      if (is_changed(nvs_handle, save)) {
+        esp_err_t err = nvs_set_blob(nvs_handle, save.key.c_str(), save.data.data(), save.data.size());
+        ESP_LOGV(TAG, "sync: key: %s, len: %d", save.key.c_str(), save.data.size());
+        if (err != 0) {
+          ESP_LOGV(TAG, "nvs_set_blob('%s', len=%u) failed: %s", save.key.c_str(), save.data.size(),
+                   esp_err_to_name(err));
+          any_failed = true;
+          continue;
+        }
+      } else {
+        ESP_LOGD(TAG, "NVS data not changed skipping %s  len=%u", save.key.c_str(), save.data.size());
       }
       s_pending_save.erase(s_pending_save.begin() + i);
     }
@@ -137,6 +142,22 @@ class ESP32Preferences : public ESPPreferences {
 
     return !any_failed;
   }
+  bool is_changed(const uint32_t nvs_handle, const NVSData &to_save) {
+    NVSData stored_data{};
+    size_t actual_len;
+    esp_err_t err = nvs_get_blob(nvs_handle, to_save.key.c_str(), nullptr, &actual_len);
+    if (err != 0) {
+      ESP_LOGV(TAG, "nvs_get_blob('%s'): %s - the key might not be set yet", to_save.key.c_str(), esp_err_to_name(err));
+      return true;
+    }
+    stored_data.data.reserve(actual_len);
+    err = nvs_get_blob(nvs_handle, to_save.key.c_str(), stored_data.data.data(), &actual_len);
+    if (err != 0) {
+      ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", to_save.key.c_str(), esp_err_to_name(err));
+      return true;
+    }
+    return to_save.data != stored_data.data;
+  }
 };
 
 void setup_preferences() {

esphome/components/esp32_camera/__init__.py

@@ -1,5 +1,6 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
+from esphome import automation
 from esphome import pins
 from esphome.const import (
     CONF_FREQUENCY,
@@ -12,6 +13,7 @@ from esphome.const import (
     CONF_RESOLUTION,
     CONF_BRIGHTNESS,
     CONF_CONTRAST,
+    CONF_TRIGGER_ID,
 )
 from esphome.core import CORE
 from esphome.components.esp32 import add_idf_sdkconfig_option
@@ -23,7 +25,14 @@ AUTO_LOAD = ["psram"]
 
 esp32_camera_ns = cg.esphome_ns.namespace("esp32_camera")
 ESP32Camera = esp32_camera_ns.class_("ESP32Camera", cg.PollingComponent, cg.EntityBase)
-
+ESP32CameraStreamStartTrigger = esp32_camera_ns.class_(
+    "ESP32CameraStreamStartTrigger",
+    automation.Trigger.template(),
+)
+ESP32CameraStreamStopTrigger = esp32_camera_ns.class_(
+    "ESP32CameraStreamStopTrigger",
+    automation.Trigger.template(),
+)
 ESP32CameraFrameSize = esp32_camera_ns.enum("ESP32CameraFrameSize")
 FRAME_SIZES = {
     "160X120": ESP32CameraFrameSize.ESP32_CAMERA_SIZE_160X120,
@@ -111,6 +120,10 @@ CONF_TEST_PATTERN = "test_pattern"
 CONF_MAX_FRAMERATE = "max_framerate"
 CONF_IDLE_FRAMERATE = "idle_framerate"
 
+# stream trigger
+CONF_ON_STREAM_START = "on_stream_start"
+CONF_ON_STREAM_STOP = "on_stream_stop"
+
 camera_range_param = cv.int_range(min=-2, max=2)
 
 CONFIG_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
@@ -178,6 +191,20 @@ CONFIG_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
         cv.Optional(CONF_IDLE_FRAMERATE, default="0.1 fps"): cv.All(
             cv.framerate, cv.Range(min=0, max=1)
         ),
+        cv.Optional(CONF_ON_STREAM_START): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                    ESP32CameraStreamStartTrigger
+                ),
+            }
+        ),
+        cv.Optional(CONF_ON_STREAM_STOP): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                    ESP32CameraStreamStopTrigger
+                ),
+            }
+        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
@@ -238,3 +265,11 @@ async def to_code(config):
     if CORE.using_esp_idf:
         cg.add_library("espressif/esp32-camera", "1.0.0")
         add_idf_sdkconfig_option("CONFIG_RTCIO_SUPPORT_RTC_GPIO_DESC", True)
+
+    for conf in config.get(CONF_ON_STREAM_START, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+
+    for conf in config.get(CONF_ON_STREAM_STOP, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)

esphome/components/esp32_camera/esp32_camera.cpp

@@ -282,8 +282,20 @@ void ESP32Camera::set_idle_update_interval(uint32_t idle_update_interval) {
 void ESP32Camera::add_image_callback(std::function<void(std::shared_ptr<CameraImage>)> &&f) {
   this->new_image_callback_.add(std::move(f));
 }
-void ESP32Camera::start_stream(CameraRequester requester) { this->stream_requesters_ |= (1U << requester); }
-void ESP32Camera::stop_stream(CameraRequester requester) { this->stream_requesters_ &= ~(1U << requester); }
+void ESP32Camera::add_stream_start_callback(std::function<void()> &&callback) {
+  this->stream_start_callback_.add(std::move(callback));
+}
+void ESP32Camera::add_stream_stop_callback(std::function<void()> &&callback) {
+  this->stream_stop_callback_.add(std::move(callback));
+}
+void ESP32Camera::start_stream(CameraRequester requester) {
+  this->stream_start_callback_.call();
+  this->stream_requesters_ |= (1U << requester);
+}
+void ESP32Camera::stop_stream(CameraRequester requester) {
+  this->stream_stop_callback_.call();
+  this->stream_requesters_ &= ~(1U << requester);
+}
 void ESP32Camera::request_image(CameraRequester requester) { this->single_requesters_ |= (1U << requester); }
 void ESP32Camera::update_camera_parameters() {
   sensor_t *s = esp_camera_sensor_get();
@@ -305,12 +317,11 @@ void ESP32Camera::update_camera_parameters() {
   s->set_gainceiling(s, (gainceiling_t) this->agc_gain_ceiling_);
   /* update white balance mode */
   s->set_wb_mode(s, (int) this->wb_mode_);  // 0 to 4
-  /* update test patern */
+  /* update test pattern */
   s->set_colorbar(s, this->test_pattern_);
 }
 
 /* ---------------- Internal methods ---------------- */
-uint32_t ESP32Camera::hash_base() { return 3010542557UL; }
 bool ESP32Camera::has_requested_image_() const { return this->single_requesters_ || this->stream_requesters_; }
 bool ESP32Camera::can_return_image_() const { return this->current_image_.use_count() == 1; }
 void ESP32Camera::framebuffer_task(void *pv) {

esphome/components/esp32_camera/esp32_camera.h

@@ -2,6 +2,7 @@
 
 #ifdef USE_ESP32
 
+#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
@@ -145,9 +146,11 @@ class ESP32Camera : public Component, public EntityBase {
   void request_image(CameraRequester requester);
   void update_camera_parameters();
 
+  void add_stream_start_callback(std::function<void()> &&callback);
+  void add_stream_stop_callback(std::function<void()> &&callback);
+
  protected:
   /* internal methods */
-  uint32_t hash_base() override;
   bool has_requested_image_() const;
   bool can_return_image_() const;
 
@@ -187,6 +190,8 @@ class ESP32Camera : public Component, public EntityBase {
   QueueHandle_t framebuffer_get_queue_;
   QueueHandle_t framebuffer_return_queue_;
   CallbackManager<void(std::shared_ptr<CameraImage>)> new_image_callback_;
+  CallbackManager<void()> stream_start_callback_{};
+  CallbackManager<void()> stream_stop_callback_{};
 
   uint32_t last_idle_request_{0};
   uint32_t last_update_{0};
@@ -195,6 +200,23 @@ class ESP32Camera : public Component, public EntityBase {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 extern ESP32Camera *global_esp32_camera;
 
+class ESP32CameraStreamStartTrigger : public Trigger<> {
+ public:
+  explicit ESP32CameraStreamStartTrigger(ESP32Camera *parent) {
+    parent->add_stream_start_callback([this]() { this->trigger(); });
+  }
+
+ protected:
+};
+class ESP32CameraStreamStopTrigger : public Trigger<> {
+ public:
+  explicit ESP32CameraStreamStopTrigger(ESP32Camera *parent) {
+    parent->add_stream_stop_callback([this]() { this->trigger(); });
+  }
+
+ protected:
+};
+
 }  // namespace esp32_camera
 }  // namespace esphome
 

esphome/components/esp8266/__init__.py

@@ -19,6 +19,7 @@ from esphome.helpers import copy_file_if_changed
 
 from .const import (
     CONF_RESTORE_FROM_FLASH,
+    CONF_EARLY_PIN_INIT,
     KEY_BOARD,
     KEY_ESP8266,
     KEY_PIN_INITIAL_STATES,
@@ -148,6 +149,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Required(CONF_BOARD): cv.string_strict,
             cv.Optional(CONF_FRAMEWORK, default={}): ARDUINO_FRAMEWORK_SCHEMA,
             cv.Optional(CONF_RESTORE_FROM_FLASH, default=False): cv.boolean,
+            cv.Optional(CONF_EARLY_PIN_INIT, default=True): cv.boolean,
             cv.Optional(CONF_BOARD_FLASH_MODE, default="dout"): cv.one_of(
                 *BUILD_FLASH_MODES, lower=True
             ),
@@ -197,6 +199,9 @@ async def to_code(config):
     if config[CONF_RESTORE_FROM_FLASH]:
         cg.add_define("USE_ESP8266_PREFERENCES_FLASH")
 
+    if config[CONF_EARLY_PIN_INIT]:
+        cg.add_define("USE_ESP8266_EARLY_PIN_INIT")
+
     # Arduino 2 has a non-standards conformant new that returns a nullptr instead of failing when
     # out of memory and exceptions are disabled. Since Arduino 2.6.0, this flag can be used to make
     # new abort instead. Use it so that OOM fails early (on allocation) instead of on dereference of

esphome/components/esp8266/const.py

@@ -4,6 +4,7 @@ KEY_ESP8266 = "esp8266"
 KEY_BOARD = "board"
 KEY_PIN_INITIAL_STATES = "pin_initial_states"
 CONF_RESTORE_FROM_FLASH = "restore_from_flash"
+CONF_EARLY_PIN_INIT = "early_pin_init"
 
 # esp8266 namespace is already defined by arduino, manually prefix esphome
 esp8266_ns = cg.global_ns.namespace("esphome").namespace("esp8266")

esphome/components/esp8266/core.cpp

@@ -1,6 +1,7 @@
 #ifdef USE_ESP8266
 
 #include "core.h"
+#include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "preferences.h"
@@ -55,6 +56,7 @@ extern "C" void resetPins() {  // NOLINT
   // ourselves and this causes pins to toggle during reboot.
   force_link_symbols();
 
+#ifdef USE_ESP8266_EARLY_PIN_INIT
   for (int i = 0; i < 16; i++) {
     uint8_t mode = ESPHOME_ESP8266_GPIO_INITIAL_MODE[i];
     uint8_t level = ESPHOME_ESP8266_GPIO_INITIAL_LEVEL[i];
@@ -63,6 +65,7 @@ extern "C" void resetPins() {  // NOLINT
     if (level != 255)
       digitalWrite(i, level);  // NOLINT
   }
+#endif
 }
 
 }  // namespace esphome

esphome/components/fan/fan.cpp

@@ -1,5 +1,4 @@
 #include "fan.h"
-#include "fan_helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -61,22 +60,6 @@ void FanCall::validate_() {
   }
 }
 
-// This whole method is deprecated, don't warn about usage of deprecated methods inside of it.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-FanCall &FanCall::set_speed(const char *legacy_speed) {
-  const auto supported_speed_count = this->parent_.get_traits().supported_speed_count();
-  if (strcasecmp(legacy_speed, "low") == 0) {
-    this->set_speed(fan::speed_enum_to_level(FAN_SPEED_LOW, supported_speed_count));
-  } else if (strcasecmp(legacy_speed, "medium") == 0) {
-    this->set_speed(fan::speed_enum_to_level(FAN_SPEED_MEDIUM, supported_speed_count));
-  } else if (strcasecmp(legacy_speed, "high") == 0) {
-    this->set_speed(fan::speed_enum_to_level(FAN_SPEED_HIGH, supported_speed_count));
-  }
-  return *this;
-}
-#pragma GCC diagnostic pop
-
 FanCall FanRestoreState::to_call(Fan &fan) {
   auto call = fan.make_call();
   call.set_state(this->state);
@@ -169,7 +152,6 @@ void Fan::dump_traits_(const char *tag, const char *prefix) {
   if (this->get_traits().supports_direction())
     ESP_LOGCONFIG(tag, "%s  Direction: YES", prefix);
 }
-uint32_t Fan::hash_base() { return 418001110UL; }
 
 }  // namespace fan
 }  // namespace esphome

esphome/components/fan/fan.h

@@ -16,13 +16,6 @@ namespace fan {
     (obj)->dump_traits_(TAG, prefix); \
   }
 
-/// Simple enum to represent the speed of a fan. - DEPRECATED - Will be deleted soon
-enum ESPDEPRECATED("FanSpeed is deprecated.", "2021.9") FanSpeed {
-  FAN_SPEED_LOW = 0,     ///< The fan is running on low speed.
-  FAN_SPEED_MEDIUM = 1,  ///< The fan is running on medium speed.
-  FAN_SPEED_HIGH = 2     ///< The fan is running on high/full speed.
-};
-
 /// Simple enum to represent the direction of a fan.
 enum class FanDirection { FORWARD = 0, REVERSE = 1 };
 
@@ -143,7 +136,6 @@ class Fan : public EntityBase {
   void save_state_();
 
   void dump_traits_(const char *tag, const char *prefix);
-  uint32_t hash_base() override;
 
   CallbackManager<void()> state_callback_{};
   ESPPreferenceObject rtc_;

esphome/components/fan/fan_helpers.cpp

@@ -1,23 +0,0 @@
-#include <cassert>
-#include "fan_helpers.h"
-
-namespace esphome {
-namespace fan {
-
-// This whole file is deprecated, don't warn about usage of deprecated types in here.
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-FanSpeed speed_level_to_enum(int speed_level, int supported_speed_levels) {
-  const auto speed_ratio = static_cast<float>(speed_level) / (supported_speed_levels + 1);
-  const auto legacy_level = clamp<int>(static_cast<int>(ceilf(speed_ratio * 3)), 1, 3);
-  return static_cast<FanSpeed>(legacy_level - 1);
-}
-
-int speed_enum_to_level(FanSpeed speed, int supported_speed_levels) {
-  const auto enum_level = static_cast<int>(speed) + 1;
-  const auto speed_level = roundf(enum_level / 3.0f * supported_speed_levels);
-  return static_cast<int>(speed_level);
-}
-
-}  // namespace fan
-}  // namespace esphome

esphome/components/fan/fan_helpers.h

@@ -1,20 +0,0 @@
-#pragma once
-
-#include "fan.h"
-
-namespace esphome {
-namespace fan {
-
-// Shut-up about usage of deprecated FanSpeed for a bit.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-ESPDEPRECATED("FanSpeed and speed_level_to_enum() are deprecated.", "2021.9")
-FanSpeed speed_level_to_enum(int speed_level, int supported_speed_levels);
-ESPDEPRECATED("FanSpeed and speed_enum_to_level() are deprecated.", "2021.9")
-int speed_enum_to_level(FanSpeed speed, int supported_speed_levels);
-
-#pragma GCC diagnostic pop
-
-}  // namespace fan
-}  // namespace esphome

esphome/components/globals/globals_component.h

@@ -44,7 +44,14 @@ template<typename T> class RestoringGlobalsComponent : public Component {
 
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  void loop() override {
+  void loop() override { store_value_(); }
+
+  void on_shutdown() override { store_value_(); }
+
+  void set_name_hash(uint32_t name_hash) { this->name_hash_ = name_hash; }
+
+ protected:
+  void store_value_() {
     int diff = memcmp(&this->value_, &this->prev_value_, sizeof(T));
     if (diff != 0) {
       this->rtc_.save(&this->value_);
@@ -52,9 +59,6 @@ template<typename T> class RestoringGlobalsComponent : public Component {
     }
   }
 
-  void set_name_hash(uint32_t name_hash) { this->name_hash_ = name_hash; }
-
- protected:
   T value_{};
   T prev_value_{};
   uint32_t name_hash_{};

esphome/components/graph/__init__.py

@@ -118,7 +118,7 @@ def _relocate_fields_to_subfolder(config, subfolder, subschema):
     fields = [k.schema for k in subschema.schema.keys()]
     fields.remove(CONF_ID)
     if subfolder in config:
-        # Ensure no ambigious fields in base of config
+        # Ensure no ambiguous fields in base of config
         for f in fields:
             if f in config:
                 raise cv.Invalid(

esphome/components/hbridge/fan/hbridge_fan.cpp

@@ -1,5 +1,4 @@
 #include "hbridge_fan.h"
-#include "esphome/components/fan/fan_helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {

esphome/components/hydreon_rgxx/hydreon_rgxx.cpp

@@ -195,7 +195,7 @@ void HydreonRGxxComponent::process_line_() {
       if (n == std::string::npos) {
         continue;
       }
-      int data = strtol(this->buffer_.substr(n + strlen(PROTOCOL_NAMES[i])).c_str(), nullptr, 10);
+      float data = strtof(this->buffer_.substr(n + strlen(PROTOCOL_NAMES[i])).c_str(), nullptr);
       this->sensors_[i]->publish_state(data);
       ESP_LOGD(TAG, "Received %s: %f", PROTOCOL_NAMES[i], this->sensors_[i]->get_raw_state());
       this->sensors_received_ |= (1 << i);

esphome/components/hydreon_rgxx/sensor.py

@@ -37,7 +37,7 @@ SUPPORTED_SENSORS = {
 PROTOCOL_NAMES = {
     CONF_MOISTURE: "R",
     CONF_ACC: "Acc",
-    CONF_R_INT: "Rint",
+    CONF_R_INT: "RInt",
     CONF_EVENT_ACC: "EventAcc",
     CONF_TOTAL_ACC: "TotalAcc",
 }

esphome/components/i2c/i2c_bus_arduino.cpp

@@ -224,7 +224,7 @@ void ArduinoI2CBus::recover_() {
   digitalWrite(sda_pin_, LOW);      // NOLINT
 
   // By now, any stuck device ought to have sent all remaining bits of its
-  // transation, meaning that it should have freed up the SDA line, resulting
+  // transaction, meaning that it should have freed up the SDA line, resulting
   // in SDA being pulled up.
   if (digitalRead(sda_pin_) == LOW) {  // NOLINT
     ESP_LOGE(TAG, "Recovery failed: SDA is held LOW after clock pulse cycle");

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -285,7 +285,7 @@ void IDFI2CBus::recover_() {
   }
 
   // By now, any stuck device ought to have sent all remaining bits of its
-  // transation, meaning that it should have freed up the SDA line, resulting
+  // transaction, meaning that it should have freed up the SDA line, resulting
   // in SDA being pulled up.
   if (gpio_get_level(sda_pin) == 0) {
     ESP_LOGE(TAG, "Recovery failed: SDA is held LOW after clock pulse cycle");

esphome/components/i2s_audio/i2s_audio_media_player.cpp

@@ -0,0 +1,160 @@
+#include "i2s_audio_media_player.h"
+
+#ifdef USE_ESP32_FRAMEWORK_ARDUINO
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace i2s_audio {
+
+static const char *const TAG = "audio";
+
+void I2SAudioMediaPlayer::control(const media_player::MediaPlayerCall &call) {
+  if (call.get_media_url().has_value()) {
+    if (this->audio_->isRunning())
+      this->audio_->stopSong();
+    this->high_freq_.start();
+    this->audio_->connecttohost(call.get_media_url().value().c_str());
+    this->state = media_player::MEDIA_PLAYER_STATE_PLAYING;
+  }
+  if (call.get_volume().has_value()) {
+    this->volume = call.get_volume().value();
+    this->set_volume_(volume);
+    this->unmute_();
+  }
+  if (call.get_command().has_value()) {
+    switch (call.get_command().value()) {
+      case media_player::MEDIA_PLAYER_COMMAND_PLAY:
+        if (!this->audio_->isRunning())
+          this->audio_->pauseResume();
+        this->state = media_player::MEDIA_PLAYER_STATE_PLAYING;
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_PAUSE:
+        if (this->audio_->isRunning())
+          this->audio_->pauseResume();
+        this->state = media_player::MEDIA_PLAYER_STATE_PAUSED;
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_STOP:
+        this->stop_();
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_MUTE:
+        this->mute_();
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_UNMUTE:
+        this->unmute_();
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_TOGGLE:
+        this->audio_->pauseResume();
+        if (this->audio_->isRunning()) {
+          this->state = media_player::MEDIA_PLAYER_STATE_PLAYING;
+        } else {
+          this->state = media_player::MEDIA_PLAYER_STATE_PAUSED;
+        }
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_VOLUME_UP: {
+        float new_volume = this->volume + 0.1f;
+        if (new_volume > 1.0f)
+          new_volume = 1.0f;
+        this->set_volume_(new_volume);
+        this->unmute_();
+        break;
+      }
+      case media_player::MEDIA_PLAYER_COMMAND_VOLUME_DOWN: {
+        float new_volume = this->volume - 0.1f;
+        if (new_volume < 0.0f)
+          new_volume = 0.0f;
+        this->set_volume_(new_volume);
+        this->unmute_();
+        break;
+      }
+    }
+  }
+  this->publish_state();
+}
+
+void I2SAudioMediaPlayer::mute_() {
+  if (this->mute_pin_ != nullptr) {
+    this->mute_pin_->digital_write(true);
+  } else {
+    this->set_volume_(0.0f, false);
+  }
+  this->muted_ = true;
+}
+void I2SAudioMediaPlayer::unmute_() {
+  if (this->mute_pin_ != nullptr) {
+    this->mute_pin_->digital_write(false);
+  } else {
+    this->set_volume_(this->volume, false);
+  }
+  this->muted_ = false;
+}
+void I2SAudioMediaPlayer::set_volume_(float volume, bool publish) {
+  this->audio_->setVolume(remap<uint8_t, float>(volume, 0.0f, 1.0f, 0, 21));
+  if (publish)
+    this->volume = volume;
+}
+
+void I2SAudioMediaPlayer::stop_() {
+  if (this->audio_->isRunning())
+    this->audio_->stopSong();
+  this->high_freq_.stop();
+  this->state = media_player::MEDIA_PLAYER_STATE_IDLE;
+}
+
+void I2SAudioMediaPlayer::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up Audio...");
+  if (this->internal_dac_mode_ != I2S_DAC_CHANNEL_DISABLE) {
+    this->audio_ = make_unique<Audio>(true, this->internal_dac_mode_);
+  } else {
+    this->audio_ = make_unique<Audio>(false);
+    this->audio_->setPinout(this->bclk_pin_, this->lrclk_pin_, this->dout_pin_);
+    this->audio_->forceMono(this->external_dac_channels_ == 1);
+    if (this->mute_pin_ != nullptr) {
+      this->mute_pin_->setup();
+      this->mute_pin_->digital_write(false);
+    }
+  }
+  this->state = media_player::MEDIA_PLAYER_STATE_IDLE;
+}
+
+void I2SAudioMediaPlayer::loop() {
+  this->audio_->loop();
+  if (this->state == media_player::MEDIA_PLAYER_STATE_PLAYING && !this->audio_->isRunning()) {
+    this->stop_();
+    this->publish_state();
+  }
+}
+
+media_player::MediaPlayerTraits I2SAudioMediaPlayer::get_traits() {
+  auto traits = media_player::MediaPlayerTraits();
+  traits.set_supports_pause(true);
+  return traits;
+};
+
+void I2SAudioMediaPlayer::dump_config() {
+  ESP_LOGCONFIG(TAG, "Audio:");
+  if (this->is_failed()) {
+    ESP_LOGCONFIG(TAG, "Audio failed to initialize!");
+    return;
+  }
+  if (this->internal_dac_mode_ != I2S_DAC_CHANNEL_DISABLE) {
+    switch (this->internal_dac_mode_) {
+      case I2S_DAC_CHANNEL_LEFT_EN:
+        ESP_LOGCONFIG(TAG, "  Internal DAC mode: Left");
+        break;
+      case I2S_DAC_CHANNEL_RIGHT_EN:
+        ESP_LOGCONFIG(TAG, "  Internal DAC mode: Right");
+        break;
+      case I2S_DAC_CHANNEL_BOTH_EN:
+        ESP_LOGCONFIG(TAG, "  Internal DAC mode: Left & Right");
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+}  // namespace i2s_audio
+}  // namespace esphome
+
+#endif  // USE_ESP32_FRAMEWORK_ARDUINO

esphome/components/i2s_audio/i2s_audio_media_player.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#ifdef USE_ESP32_FRAMEWORK_ARDUINO
+
+#include "esphome/components/media_player/media_player.h"
+#include "esphome/core/component.h"
+#include "esphome/core/gpio.h"
+#include "esphome/core/helpers.h"
+
+#include <Audio.h>
+
+namespace esphome {
+namespace i2s_audio {
+
+class I2SAudioMediaPlayer : public Component, public media_player::MediaPlayer {
+ public:
+  void setup() override;
+  float get_setup_priority() const override { return esphome::setup_priority::LATE; }
+
+  void loop() override;
+
+  void dump_config() override;
+
+  void set_dout_pin(uint8_t pin) { this->dout_pin_ = pin; }
+  void set_bclk_pin(uint8_t pin) { this->bclk_pin_ = pin; }
+  void set_lrclk_pin(uint8_t pin) { this->lrclk_pin_ = pin; }
+  void set_mute_pin(GPIOPin *mute_pin) { this->mute_pin_ = mute_pin; }
+  void set_internal_dac_mode(i2s_dac_mode_t mode) { this->internal_dac_mode_ = mode; }
+  void set_external_dac_channels(uint8_t channels) { this->external_dac_channels_ = channels; }
+
+  media_player::MediaPlayerTraits get_traits() override;
+
+  bool is_muted() const override { return this->muted_; }
+
+ protected:
+  void control(const media_player::MediaPlayerCall &call) override;
+
+  void mute_();
+  void unmute_();
+  void set_volume_(float volume, bool publish = true);
+  void stop_();
+
+  std::unique_ptr<Audio> audio_;
+
+  uint8_t dout_pin_{0};
+  uint8_t din_pin_{0};
+  uint8_t bclk_pin_;
+  uint8_t lrclk_pin_;
+
+  GPIOPin *mute_pin_{nullptr};
+  bool muted_{false};
+  float unmuted_volume_{0};
+
+  i2s_dac_mode_t internal_dac_mode_{I2S_DAC_CHANNEL_DISABLE};
+  uint8_t external_dac_channels_;
+
+  HighFrequencyLoopRequester high_freq_;
+};
+
+}  // namespace i2s_audio
+}  // namespace esphome
+
+#endif  // USE_ESP32_FRAMEWORK_ARDUINO

esphome/components/i2s_audio/media_player.py

@@ -0,0 +1,94 @@
+import esphome.codegen as cg
+from esphome.components import media_player
+import esphome.config_validation as cv
+
+from esphome import pins
+
+from esphome.const import CONF_ID, CONF_MODE
+from esphome.core import CORE
+
+CODEOWNERS = ["@jesserockz"]
+DEPENDENCIES = ["esp32"]
+
+i2s_audio_ns = cg.esphome_ns.namespace("i2s_audio")
+
+I2SAudioMediaPlayer = i2s_audio_ns.class_(
+    "I2SAudioMediaPlayer", cg.Component, media_player.MediaPlayer
+)
+
+i2s_dac_mode_t = cg.global_ns.enum("i2s_dac_mode_t")
+
+CONF_I2S_DOUT_PIN = "i2s_dout_pin"
+CONF_I2S_BCLK_PIN = "i2s_bclk_pin"
+CONF_I2S_LRCLK_PIN = "i2s_lrclk_pin"
+CONF_MUTE_PIN = "mute_pin"
+CONF_AUDIO_ID = "audio_id"
+CONF_DAC_TYPE = "dac_type"
+
+INTERNAL_DAC_OPTIONS = {
+    "left": i2s_dac_mode_t.I2S_DAC_CHANNEL_LEFT_EN,
+    "right": i2s_dac_mode_t.I2S_DAC_CHANNEL_RIGHT_EN,
+    "stereo": i2s_dac_mode_t.I2S_DAC_CHANNEL_BOTH_EN,
+}
+
+EXTERNAL_DAC_OPTIONS = ["mono", "stereo"]
+
+CONFIG_SCHEMA = cv.All(
+    cv.typed_schema(
+        {
+            "internal": cv.Schema(
+                {
+                    cv.GenerateID(): cv.declare_id(I2SAudioMediaPlayer),
+                    cv.Required(CONF_MODE): cv.enum(INTERNAL_DAC_OPTIONS, lower=True),
+                }
+            )
+            .extend(media_player.MEDIA_PLAYER_SCHEMA)
+            .extend(cv.COMPONENT_SCHEMA),
+            "external": cv.Schema(
+                {
+                    cv.GenerateID(): cv.declare_id(I2SAudioMediaPlayer),
+                    cv.Required(
+                        CONF_I2S_DOUT_PIN
+                    ): pins.internal_gpio_output_pin_number,
+                    cv.Required(
+                        CONF_I2S_BCLK_PIN
+                    ): pins.internal_gpio_output_pin_number,
+                    cv.Required(
+                        CONF_I2S_LRCLK_PIN
+                    ): pins.internal_gpio_output_pin_number,
+                    cv.Optional(CONF_MUTE_PIN): pins.gpio_output_pin_schema,
+                    cv.Optional(CONF_MODE, default="mono"): cv.one_of(
+                        *EXTERNAL_DAC_OPTIONS, lower=True
+                    ),
+                }
+            )
+            .extend(media_player.MEDIA_PLAYER_SCHEMA)
+            .extend(cv.COMPONENT_SCHEMA),
+        },
+        key=CONF_DAC_TYPE,
+    ),
+    cv.only_with_arduino,
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await media_player.register_media_player(var, config)
+
+    if config[CONF_DAC_TYPE] == "internal":
+        cg.add(var.set_internal_dac_mode(config[CONF_MODE]))
+    else:
+        cg.add(var.set_dout_pin(config[CONF_I2S_DOUT_PIN]))
+        cg.add(var.set_bclk_pin(config[CONF_I2S_BCLK_PIN]))
+        cg.add(var.set_lrclk_pin(config[CONF_I2S_LRCLK_PIN]))
+        if CONF_MUTE_PIN in config:
+            pin = await cg.gpio_pin_expression(config[CONF_MUTE_PIN])
+            cg.add(var.set_mute_pin(pin))
+        cg.add(var.set_external_dac_channels(2 if config[CONF_MODE] == "stereo" else 1))
+
+    if CORE.is_esp32:
+        cg.add_library("WiFiClientSecure", None)
+        cg.add_library("HTTPClient", None)
+        cg.add_library("esphome/ESP32-audioI2S", "2.1.0")
+        cg.add_build_flag("-DAUDIO_NO_SD_FS")

esphome/components/ili9341/display.py

@@ -3,13 +3,16 @@ import esphome.config_validation as cv
 from esphome import pins
 from esphome.components import display, spi
 from esphome.const import (
+    CONF_COLOR_PALETTE,
     CONF_DC_PIN,
     CONF_ID,
     CONF_LAMBDA,
     CONF_MODEL,
     CONF_PAGES,
+    CONF_RAW_DATA_ID,
     CONF_RESET_PIN,
 )
+from esphome.core import HexInt
 
 DEPENDENCIES = ["spi"]
 
@@ -21,16 +24,21 @@ ili9341 = ili9341_ns.class_(
 )
 ILI9341M5Stack = ili9341_ns.class_("ILI9341M5Stack", ili9341)
 ILI9341TFT24 = ili9341_ns.class_("ILI9341TFT24", ili9341)
+ILI9341TFT24R = ili9341_ns.class_("ILI9341TFT24R", ili9341)
 
 ILI9341Model = ili9341_ns.enum("ILI9341Model")
+ILI9341ColorMode = ili9341_ns.enum("ILI9341ColorMode")
 
 MODELS = {
     "M5STACK": ILI9341Model.M5STACK,
     "TFT_2.4": ILI9341Model.TFT_24,
+    "TFT_2.4R": ILI9341Model.TFT_24R,
 }
 
 ILI9341_MODEL = cv.enum(MODELS, upper=True, space="_")
 
+COLOR_PALETTE = cv.one_of("NONE", "GRAYSCALE")
+
 CONFIG_SCHEMA = cv.All(
     display.FULL_DISPLAY_SCHEMA.extend(
         {
@@ -39,6 +47,8 @@ CONFIG_SCHEMA = cv.All(
             cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
             cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
             cv.Optional(CONF_LED_PIN): pins.gpio_output_pin_schema,
+            cv.Optional(CONF_COLOR_PALETTE, default="NONE"): COLOR_PALETTE,
+            cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
         }
     )
     .extend(cv.polling_component_schema("1s"))
@@ -52,6 +62,8 @@ async def to_code(config):
         lcd_type = ILI9341M5Stack
     if config[CONF_MODEL] == "TFT_2.4":
         lcd_type = ILI9341TFT24
+    if config[CONF_MODEL] == "TFT_2.4R":
+        lcd_type = ILI9341TFT24R
     rhs = lcd_type.new()
     var = cg.Pvariable(config[CONF_ID], rhs)
 
@@ -73,3 +85,13 @@ async def to_code(config):
     if CONF_LED_PIN in config:
         led_pin = await cg.gpio_pin_expression(config[CONF_LED_PIN])
         cg.add(var.set_led_pin(led_pin))
+
+    if config[CONF_COLOR_PALETTE] == "GRAYSCALE":
+        cg.add(var.set_buffer_color_mode(ILI9341ColorMode.BITS_8_INDEXED))
+        rhs = []
+        for x in range(256):
+            rhs.extend([HexInt(x), HexInt(x), HexInt(x)])
+        prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
+        cg.add(var.set_palette(prog_arr))
+    else:
+        pass

esphome/components/ili9341/ili9341_display.cpp

@@ -112,29 +112,9 @@ void ILI9341Display::display_() {
   this->y_high_ = 0;
 }
 
-uint16_t ILI9341Display::convert_to_16bit_color_(uint8_t color_8bit) {
-  int r = color_8bit >> 5;
-  int g = (color_8bit >> 2) & 0x07;
-  int b = color_8bit & 0x03;
-  uint16_t color = (r * 0x04) << 11;
-  color |= (g * 0x09) << 5;
-  color |= (b * 0x0A);
-
-  return color;
-}
-
-uint8_t ILI9341Display::convert_to_8bit_color_(uint16_t color_16bit) {
-  // convert 16bit color to 8 bit buffer
-  uint8_t r = color_16bit >> 11;
-  uint8_t g = (color_16bit >> 5) & 0x3F;
-  uint8_t b = color_16bit & 0x1F;
-
-  return ((b / 0x0A) | ((g / 0x09) << 2) | ((r / 0x04) << 5));
-}
-
 void ILI9341Display::fill(Color color) {
-  auto color565 = display::ColorUtil::color_to_565(color);
-  memset(this->buffer_, convert_to_8bit_color_(color565), this->get_buffer_length_());
+  uint8_t color332 = display::ColorUtil::color_to_332(color, display::ColorOrder::COLOR_ORDER_RGB);
+  memset(this->buffer_, color332, this->get_buffer_length_());
   this->x_low_ = 0;
   this->y_low_ = 0;
   this->x_high_ = this->get_width_internal() - 1;
@@ -181,8 +161,13 @@ void HOT ILI9341Display::draw_absolute_pixel_internal(int x, int y, Color color)
   this->y_high_ = (y > this->y_high_) ? y : this->y_high_;
 
   uint32_t pos = (y * width_) + x;
-  auto color565 = display::ColorUtil::color_to_565(color);
-  buffer_[pos] = convert_to_8bit_color_(color565);
+  if (this->buffer_color_mode_ == BITS_8) {
+    uint8_t color332 = display::ColorUtil::color_to_332(color, display::ColorOrder::COLOR_ORDER_RGB);
+    buffer_[pos] = color332;
+  } else {  // if (this->buffer_color_mode_ == BITS_8_INDEXED) {
+    uint8_t index = display::ColorUtil::color_to_index8_palette888(color, this->palette_);
+    buffer_[pos] = index;
+  }
 }
 
 // should return the total size: return this->get_width_internal() * this->get_height_internal() * 2 // 16bit color
@@ -247,7 +232,13 @@ uint32_t ILI9341Display::buffer_to_transfer_(uint32_t pos, uint32_t sz) {
   }
 
   for (uint32_t i = 0; i < sz; ++i) {
-    uint16_t color = convert_to_16bit_color_(*src++);
+    uint16_t color;
+    if (this->buffer_color_mode_ == BITS_8) {
+      color = display::ColorUtil::color_to_565(display::ColorUtil::rgb332_to_color(*src++));
+    } else {  //  if (this->buffer_color_mode == BITS_8_INDEXED) {
+      Color col = display::ColorUtil::index8_to_color_palette888(*src++, this->palette_);
+      color = display::ColorUtil::color_to_565(col);
+    }
     *dst++ = (uint8_t)(color >> 8);
     *dst++ = (uint8_t) color;
   }
@@ -272,5 +263,13 @@ void ILI9341TFT24::initialize() {
   this->fill_internal_(Color::BLACK);
 }
 
+//   24_TFT rotated display
+void ILI9341TFT24R::initialize() {
+  this->init_lcd_(INITCMD_TFT);
+  this->width_ = 320;
+  this->height_ = 240;
+  this->fill_internal_(Color::BLACK);
+}
+
 }  // namespace ili9341
 }  // namespace esphome

esphome/components/ili9341/ili9341_display.h

@@ -12,6 +12,12 @@ namespace ili9341 {
 enum ILI9341Model {
   M5STACK = 0,
   TFT_24,
+  TFT_24R,
+};
+
+enum ILI9341ColorMode {
+  BITS_8,
+  BITS_8_INDEXED,
 };
 
 class ILI9341Display : public PollingComponent,
@@ -24,6 +30,8 @@ class ILI9341Display : public PollingComponent,
   void set_reset_pin(GPIOPin *reset) { this->reset_pin_ = reset; }
   void set_led_pin(GPIOPin *led) { this->led_pin_ = led; }
   void set_model(ILI9341Model model) { this->model_ = model; }
+  void set_palette(const uint8_t *palette) { this->palette_ = palette; }
+  void set_buffer_color_mode(ILI9341ColorMode color_mode) { this->buffer_color_mode_ = color_mode; }
 
   void command(uint8_t value);
   void data(uint8_t value);
@@ -41,6 +49,8 @@ class ILI9341Display : public PollingComponent,
     this->initialize();
   }
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
+
  protected:
   void draw_absolute_pixel_internal(int x, int y, Color color) override;
   void setup_pins_();
@@ -51,8 +61,6 @@ class ILI9341Display : public PollingComponent,
   void reset_();
   void fill_internal_(Color color);
   void display_();
-  uint16_t convert_to_16bit_color_(uint8_t color_8bit);
-  uint8_t convert_to_8bit_color_(uint16_t color_16bit);
 
   ILI9341Model model_;
   int16_t width_{320};   ///< Display width as modified by current rotation
@@ -61,6 +69,9 @@ class ILI9341Display : public PollingComponent,
   uint16_t y_low_{0};
   uint16_t x_high_{0};
   uint16_t y_high_{0};
+  const uint8_t *palette_;
+
+  ILI9341ColorMode buffer_color_mode_{BITS_8};
 
   uint32_t get_buffer_length_();
   int get_width_internal() override;
@@ -92,5 +103,12 @@ class ILI9341TFT24 : public ILI9341Display {
  public:
   void initialize() override;
 };
+
+//-----------   ILI9341_24_TFT rotated display --------------
+class ILI9341TFT24R : public ILI9341Display {
+ public:
+  void initialize() override;
+};
+
 }  // namespace ili9341
 }  // namespace esphome

esphome/components/image/__init__.py

@@ -25,6 +25,7 @@ IMAGE_TYPE = {
     "GRAYSCALE": ImageType.IMAGE_TYPE_GRAYSCALE,
     "RGB24": ImageType.IMAGE_TYPE_RGB24,
     "TRANSPARENT_BINARY": ImageType.IMAGE_TYPE_TRANSPARENT_BINARY,
+    "RGB565": ImageType.IMAGE_TYPE_RGB565,
 }
 
 Image_ = display.display_ns.class_("Image")
@@ -89,6 +90,21 @@ async def to_code(config):
             data[pos] = pix[2]
             pos += 1
 
+    elif config[CONF_TYPE] == "RGB565":
+        image = image.convert("RGB")
+        pixels = list(image.getdata())
+        data = [0 for _ in range(height * width * 3)]
+        pos = 0
+        for pix in pixels:
+            R = pix[0] >> 3
+            G = pix[1] >> 2
+            B = pix[2] >> 3
+            rgb = (R << 11) | (G << 5) | B
+            data[pos] = rgb >> 8
+            pos += 1
+            data[pos] = rgb & 255
+            pos += 1
+
     elif config[CONF_TYPE] == "BINARY":
         image = image.convert("1", dither=dither)
         width8 = ((width + 7) // 8) * 8

esphome/components/improv_serial/__init__.py

@@ -1,6 +1,8 @@
-from esphome.const import CONF_BAUD_RATE, CONF_ID, CONF_LOGGER
+from esphome.components.logger import USB_CDC, USB_SERIAL_JTAG
+from esphome.const import CONF_BAUD_RATE, CONF_HARDWARE_UART, CONF_ID, CONF_LOGGER
 import esphome.codegen as cg
 import esphome.config_validation as cv
+from esphome.core import CORE
 import esphome.final_validate as fv
 
 CODEOWNERS = ["@esphome/core"]
@@ -17,14 +19,19 @@ CONFIG_SCHEMA = cv.Schema(
 ).extend(cv.COMPONENT_SCHEMA)
 
 
-def validate_logger_baud_rate(config):
+def validate_logger(config):
     logger_conf = fv.full_config.get()[CONF_LOGGER]
     if logger_conf[CONF_BAUD_RATE] == 0:
         raise cv.Invalid("improv_serial requires the logger baud_rate to be not 0")
+    if CORE.using_esp_idf:
+        if logger_conf[CONF_HARDWARE_UART] in [USB_SERIAL_JTAG, USB_CDC]:
+            raise cv.Invalid(
+                "improv_serial does not support the selected logger hardware_uart"
+            )
     return config
 
 
-FINAL_VALIDATE_SCHEMA = validate_logger_baud_rate
+FINAL_VALIDATE_SCHEMA = validate_logger
 
 
 async def to_code(config):

esphome/components/improv_serial/improv_serial_component.h

@@ -51,7 +51,7 @@ class ImprovSerialComponent : public Component {
   void write_data_(std::vector<uint8_t> &data);
 
 #ifdef USE_ARDUINO
-  HardwareSerial *hw_serial_{nullptr};
+  Stream *hw_serial_{nullptr};
 #endif
 #ifdef USE_ESP_IDF
   uart_port_t uart_num_;

esphome/components/inkplate6/inkplate.h

@@ -86,6 +86,10 @@ class Inkplate6 : public PollingComponent, public display::DisplayBuffer, public
 
   void block_partial() { this->block_partial_ = true; }
 
+  display::DisplayType get_display_type() override {
+    return get_greyscale() ? display::DisplayType::DISPLAY_TYPE_GRAYSCALE : display::DisplayType::DISPLAY_TYPE_BINARY;
+  }
+
  protected:
   void draw_absolute_pixel_internal(int x, int y, Color color) override;
   void display1b_();

esphome/components/integration/integration_sensor.cpp

@@ -10,14 +10,13 @@ static const char *const TAG = "integration";
 
 void IntegrationSensor::setup() {
   if (this->restore_) {
-    this->rtc_ = global_preferences->make_preference<float>(this->get_object_id_hash());
+    this->pref_ = global_preferences->make_preference<float>(this->get_object_id_hash());
     float preference_value = 0;
-    this->rtc_.load(&preference_value);
+    this->pref_.load(&preference_value);
     this->result_ = preference_value;
   }
 
   this->last_update_ = millis();
-  this->last_save_ = this->last_update_;
 
   this->publish_and_save_(this->result_);
   this->sensor_->add_on_state_callback([this](float state) { this->process_sensor_value_(state); });

esphome/components/integration/integration_sensor.h

@@ -28,7 +28,6 @@ class IntegrationSensor : public sensor::Sensor, public Component {
   void setup() override;
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::DATA; }
-  void set_min_save_interval(uint32_t min_interval) { this->min_save_interval_ = min_interval; }
   void set_sensor(Sensor *sensor) { sensor_ = sensor; }
   void set_time(IntegrationSensorTime time) { time_ = time; }
   void set_method(IntegrationMethod method) { method_ = method; }
@@ -56,22 +55,18 @@ class IntegrationSensor : public sensor::Sensor, public Component {
   void publish_and_save_(double result) {
     this->result_ = result;
     this->publish_state(result);
-    float result_f = result;
-    const uint32_t now = millis();
-    if (now - this->last_save_ < this->min_save_interval_)
-      return;
-    this->last_save_ = now;
-    this->rtc_.save(&result_f);
+    if (this->restore_) {
+      float result_f = result;
+      this->pref_.save(&result_f);
+    }
   }
 
   sensor::Sensor *sensor_;
   IntegrationSensorTime time_;
   IntegrationMethod method_;
   bool restore_;
-  ESPPreferenceObject rtc_;
+  ESPPreferenceObject pref_;
 
-  uint32_t last_save_{0};
-  uint32_t min_save_interval_{0};
   uint32_t last_update_;
   double result_{0.0f};
   float last_value_{0.0f};

esphome/components/integration/sensor.py

@@ -35,7 +35,6 @@ INTEGRATION_METHODS = {
 
 CONF_TIME_UNIT = "time_unit"
 CONF_INTEGRATION_METHOD = "integration_method"
-CONF_MIN_SAVE_INTERVAL = "min_save_interval"
 
 
 def inherit_unit_of_measurement(uom, config):
@@ -58,9 +57,9 @@ CONFIG_SCHEMA = sensor.SENSOR_SCHEMA.extend(
             INTEGRATION_METHODS, lower=True
         ),
         cv.Optional(CONF_RESTORE, default=False): cv.boolean,
-        cv.Optional(
-            CONF_MIN_SAVE_INTERVAL, default="0s"
-        ): cv.positive_time_period_milliseconds,
+        cv.Optional("min_save_interval"): cv.invalid(
+            "min_save_interval was removed in 2022.8.0. Please use the `preferences` -> `flash_write_interval` to adjust."
+        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
@@ -97,7 +96,6 @@ async def to_code(config):
     cg.add(var.set_time(config[CONF_TIME_UNIT]))
     cg.add(var.set_method(config[CONF_INTEGRATION_METHOD]))
     cg.add(var.set_restore(config[CONF_RESTORE]))
-    cg.add(var.set_min_save_interval(config[CONF_MIN_SAVE_INTERVAL]))
 
 
 @automation.register_action(

esphome/components/json/json_util.cpp

@@ -26,21 +26,33 @@ std::string build_json(const json_build_t &f) {
   const size_t free_heap = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT);
 #endif
 
-  const size_t request_size = std::min(free_heap, (size_t) 512);
-
-  DynamicJsonDocument json_document(request_size);
-  if (json_document.capacity() == 0) {
-    ESP_LOGE(TAG, "Could not allocate memory for JSON document! Requested %u bytes, largest free heap block: %u bytes",
-             request_size, free_heap);
-    return "{}";
+  size_t request_size = std::min(free_heap, (size_t) 512);
+  while (true) {
+    ESP_LOGV(TAG, "Attempting to allocate %u bytes for JSON serialization", request_size);
+    DynamicJsonDocument json_document(request_size);
+    if (json_document.capacity() == 0) {
+      ESP_LOGE(TAG,
+               "Could not allocate memory for JSON document! Requested %u bytes, largest free heap block: %u bytes",
+               request_size, free_heap);
+      return "{}";
+    }
+    JsonObject root = json_document.to<JsonObject>();
+    f(root);
+    if (json_document.overflowed()) {
+      if (request_size == free_heap) {
+        ESP_LOGE(TAG, "Could not allocate memory for JSON document! Overflowed largest free heap block: %u bytes",
+                 free_heap);
+        return "{}";
+      }
+      request_size = std::min(request_size * 2, free_heap);
+      continue;
+    }
+    json_document.shrinkToFit();
+    ESP_LOGV(TAG, "Size after shrink %u bytes", json_document.capacity());
+    std::string output;
+    serializeJson(json_document, output);
+    return output;
   }
-  JsonObject root = json_document.to<JsonObject>();
-  f(root);
-  json_document.shrinkToFit();
-  ESP_LOGV(TAG, "Size after shrink %u bytes", json_document.capacity());
-  std::string output;
-  serializeJson(json_document, output);
-  return output;
 }
 
 void parse_json(const std::string &data, const json_parse_t &f) {

esphome/components/light/effects.py

@@ -1,4 +1,4 @@
-from esphome.jsonschema import jschema_extractor
+from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import automation
@@ -479,11 +479,11 @@ async def addressable_flicker_effect_to_code(config, effect_id):
 
 
 def validate_effects(allowed_effects):
-    @jschema_extractor("effects")
+    @schema_extractor("effects")
     def validator(value):
-        # pylint: disable=comparison-with-callable
-        if value == jschema_extractor:
+        if value == SCHEMA_EXTRACT:
             return (allowed_effects, EFFECTS_REGISTRY)
+
         value = cv.validate_registry("effect", EFFECTS_REGISTRY)(value)
         errors = []
         names = set()

esphome/components/light/light_color_values.h

@@ -203,7 +203,7 @@ class LightColorValues {
       *color_temperature =
           (this->color_temperature_ - color_temperature_cw) / (color_temperature_ww - color_temperature_cw);
       *white_brightness = gamma_correct(this->state_ * this->brightness_ * white_level, gamma);
-    } else {  // Probably wont get here but put this here anyway.
+    } else {  // Probably won't get here but put this here anyway.
       *white_brightness = 0;
     }
   }

esphome/components/light/light_json_schema.cpp

@@ -121,7 +121,7 @@ void LightJSONSchema::parse_color_json(LightState &state, LightCall &call, JsonO
       call.set_cold_white(float(color["c"]) / 255.0f);
     }
     if (color.containsKey("w")) {
-      // the HA scheme is ambigious here, the same key is used for white channel in RGBW and warm
+      // the HA scheme is ambiguous here, the same key is used for white channel in RGBW and warm
       // white channel in RGBWW.
       if (color.containsKey("c")) {
         call.set_warm_white(float(color["w"]) / 255.0f);

esphome/components/light/light_state.cpp

@@ -145,7 +145,6 @@ void LightState::loop() {
 }
 
 float LightState::get_setup_priority() const { return setup_priority::HARDWARE - 1.0f; }
-uint32_t LightState::hash_base() { return 1114400283; }
 
 void LightState::publish_state() { this->remote_values_callback_.call(); }
 

esphome/components/light/light_state.h

@@ -150,8 +150,6 @@ class LightState : public EntityBase, public Component {
   friend LightCall;
   friend class AddressableLight;
 
-  uint32_t hash_base() override;
-
   /// Internal method to start an effect with the given index
   void start_effect_(uint32_t effect_index);
   /// Internal method to get the currently active effect

esphome/components/lock/lock.cpp

@@ -57,7 +57,6 @@ void Lock::publish_state(LockState state) {
 }
 
 void Lock::add_on_state_callback(std::function<void()> &&callback) { this->state_callback_.add(std::move(callback)); }
-uint32_t Lock::hash_base() { return 856245656UL; }
 
 void LockCall::perform() {
   ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());

esphome/components/lock/lock.h

@@ -167,8 +167,6 @@ class Lock : public EntityBase {
    */
   virtual void control(const LockCall &call) = 0;
 
-  uint32_t hash_base() override;
-
   CallbackManager<void()> state_callback_{};
   Deduplicator<LockState> publish_dedup_;
   ESPPreferenceObject rtc_;

esphome/components/logger/__init__.py

@@ -19,8 +19,13 @@ from esphome.const import (
     CONF_TX_BUFFER_SIZE,
 )
 from esphome.core import CORE, EsphomeError, Lambda, coroutine_with_priority
-from esphome.components.esp32 import get_esp32_variant
-from esphome.components.esp32.const import VARIANT_ESP32S2, VARIANT_ESP32C3
+from esphome.components.esp32 import add_idf_sdkconfig_option, get_esp32_variant
+from esphome.components.esp32.const import (
+    VARIANT_ESP32,
+    VARIANT_ESP32S2,
+    VARIANT_ESP32C3,
+    VARIANT_ESP32S3,
+)
 
 CODEOWNERS = ["@esphome/core"]
 logger_ns = cg.esphome_ns.namespace("logger")
@@ -54,36 +59,51 @@ LOG_LEVEL_SEVERITY = [
     "VERY_VERBOSE",
 ]
 
-ESP32_REDUCED_VARIANTS = [VARIANT_ESP32C3, VARIANT_ESP32S2]
+UART0 = "UART0"
+UART1 = "UART1"
+UART2 = "UART2"
+UART0_SWAP = "UART0_SWAP"
+USB_SERIAL_JTAG = "USB_SERIAL_JTAG"
+USB_CDC = "USB_CDC"
 
-UART_SELECTION_ESP32_REDUCED = ["UART0", "UART1"]
+UART_SELECTION_ESP32 = {
+    VARIANT_ESP32: [UART0, UART1, UART2],
+    VARIANT_ESP32S2: [UART0, UART1, USB_CDC],
+    VARIANT_ESP32S3: [UART0, UART1, USB_CDC, USB_SERIAL_JTAG],
+    VARIANT_ESP32C3: [UART0, UART1, USB_SERIAL_JTAG],
+}
 
-UART_SELECTION_ESP32 = ["UART0", "UART1", "UART2"]
+UART_SELECTION_ESP8266 = [UART0, UART0_SWAP, UART1]
 
-UART_SELECTION_ESP8266 = ["UART0", "UART0_SWAP", "UART1"]
+ESP_IDF_UARTS = [USB_CDC, USB_SERIAL_JTAG]
 
 HARDWARE_UART_TO_UART_SELECTION = {
-    "UART0": logger_ns.UART_SELECTION_UART0,
-    "UART0_SWAP": logger_ns.UART_SELECTION_UART0_SWAP,
-    "UART1": logger_ns.UART_SELECTION_UART1,
-    "UART2": logger_ns.UART_SELECTION_UART2,
+    UART0: logger_ns.UART_SELECTION_UART0,
+    UART0_SWAP: logger_ns.UART_SELECTION_UART0_SWAP,
+    UART1: logger_ns.UART_SELECTION_UART1,
+    UART2: logger_ns.UART_SELECTION_UART2,
+    USB_CDC: logger_ns.UART_SELECTION_USB_CDC,
+    USB_SERIAL_JTAG: logger_ns.UART_SELECTION_USB_SERIAL_JTAG,
 }
 
 HARDWARE_UART_TO_SERIAL = {
-    "UART0": cg.global_ns.Serial,
-    "UART0_SWAP": cg.global_ns.Serial,
-    "UART1": cg.global_ns.Serial1,
-    "UART2": cg.global_ns.Serial2,
+    UART0: cg.global_ns.Serial,
+    UART0_SWAP: cg.global_ns.Serial,
+    UART1: cg.global_ns.Serial1,
+    UART2: cg.global_ns.Serial2,
 }
 
 is_log_level = cv.one_of(*LOG_LEVELS, upper=True)
 
 
 def uart_selection(value):
+    if value.upper() in ESP_IDF_UARTS:
+        if not CORE.using_esp_idf:
+            raise cv.Invalid(f"Only esp-idf framework supports {value}.")
     if CORE.is_esp32:
-        if get_esp32_variant() in ESP32_REDUCED_VARIANTS:
-            return cv.one_of(*UART_SELECTION_ESP32_REDUCED, upper=True)(value)
-        return cv.one_of(*UART_SELECTION_ESP32, upper=True)(value)
+        variant = get_esp32_variant()
+        if variant in UART_SELECTION_ESP32:
+            return cv.one_of(*UART_SELECTION_ESP32[variant], upper=True)(value)
     if CORE.is_esp8266:
         return cv.one_of(*UART_SELECTION_ESP8266, upper=True)(value)
     raise NotImplementedError
@@ -113,7 +133,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_BAUD_RATE, default=115200): cv.positive_int,
             cv.Optional(CONF_TX_BUFFER_SIZE, default=512): cv.validate_bytes,
             cv.Optional(CONF_DEASSERT_RTS_DTR, default=False): cv.boolean,
-            cv.Optional(CONF_HARDWARE_UART, default="UART0"): uart_selection,
+            cv.Optional(CONF_HARDWARE_UART, default=UART0): uart_selection,
             cv.Optional(CONF_LEVEL, default="DEBUG"): is_log_level,
             cv.Optional(CONF_LOGS, default={}): cv.Schema(
                 {
@@ -185,6 +205,12 @@ async def to_code(config):
     if config.get(CONF_ESP8266_STORE_LOG_STRINGS_IN_FLASH):
         cg.add_build_flag("-DUSE_STORE_LOG_STR_IN_FLASH")
 
+    if CORE.using_esp_idf:
+        if config[CONF_HARDWARE_UART] == USB_CDC:
+            add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_USB_CDC", True)
+        elif config[CONF_HARDWARE_UART] == USB_SERIAL_JTAG:
+            add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG", True)
+
     # Register at end for safe mode
     await cg.register_component(log, config)
 

esphome/components/logger/logger.cpp

@@ -116,8 +116,22 @@ void HOT Logger::log_message_(int level, const char *tag, int offset) {
     this->hw_serial_->println(msg);
 #endif  // USE_ARDUINO
 #ifdef USE_ESP_IDF
-    uart_write_bytes(uart_num_, msg, strlen(msg));
-    uart_write_bytes(uart_num_, "\n", 1);
+    if (
+#if defined(USE_ESP32_VARIANT_ESP32S2)
+        uart_ == UART_SELECTION_USB_CDC
+#elif defined(USE_ESP32_VARIANT_ESP32C3)
+        uart_ == UART_SELECTION_USB_SERIAL_JTAG
+#elif defined(USE_ESP32_VARIANT_ESP32S3)
+        uart_ == UART_SELECTION_USB_CDC || uart_ == UART_SELECTION_USB_SERIAL_JTAG
+#else
+        /* DISABLES CODE */ (false)
+#endif
+    ) {
+      puts(msg);
+    } else {
+      uart_write_bytes(uart_num_, msg, strlen(msg));
+      uart_write_bytes(uart_num_, "\n", 1);
+    }
 #endif
   }
 
@@ -149,13 +163,26 @@ void Logger::pre_setup() {
       case UART_SELECTION_UART0_SWAP:
 #endif
         this->hw_serial_ = &Serial;
+        Serial.begin(this->baud_rate_);
+#ifdef USE_ESP8266
+        if (this->uart_ == UART_SELECTION_UART0_SWAP) {
+          Serial.swap();
+        }
+        Serial.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
+#endif
         break;
       case UART_SELECTION_UART1:
         this->hw_serial_ = &Serial1;
+        Serial1.begin(this->baud_rate_);
+#ifdef USE_ESP8266
+        Serial1.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
+#endif
         break;
-#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32S2)
+#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32S2) && \
+    !defined(USE_ESP32_VARIANT_ESP32S3)
       case UART_SELECTION_UART2:
         this->hw_serial_ = &Serial2;
+        Serial2.begin(this->baud_rate_);
         break;
 #endif
     }
@@ -169,39 +196,41 @@ void Logger::pre_setup() {
       case UART_SELECTION_UART1:
         uart_num_ = UART_NUM_1;
         break;
-#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32S2)
+#if !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32S3)
       case UART_SELECTION_UART2:
         uart_num_ = UART_NUM_2;
         break;
-#endif
+#endif  // !USE_ESP32_VARIANT_ESP32C3 && !USE_ESP32_VARIANT_ESP32S2 && !USE_ESP32_VARIANT_ESP32S3
+#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+      case UART_SELECTION_USB_CDC:
+        uart_num_ = -1;
+        break;
+#endif  // USE_ESP32_VARIANT_ESP32S2 || USE_ESP32_VARIANT_ESP32S3
+#if defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32S3)
+      case UART_SELECTION_USB_SERIAL_JTAG:
+        uart_num_ = -1;
+        break;
+#endif  // USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32S3
     }
-    uart_config_t uart_config{};
-    uart_config.baud_rate = (int) baud_rate_;
-    uart_config.data_bits = UART_DATA_8_BITS;
-    uart_config.parity = UART_PARITY_DISABLE;
-    uart_config.stop_bits = UART_STOP_BITS_1;
-    uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
-    uart_param_config(uart_num_, &uart_config);
-    const int uart_buffer_size = tx_buffer_size_;
-    // Install UART driver using an event queue here
-    uart_driver_install(uart_num_, uart_buffer_size, uart_buffer_size, 10, nullptr, 0);
-#endif
-
-#ifdef USE_ARDUINO
-    this->hw_serial_->begin(this->baud_rate_);
-#ifdef USE_ESP8266
-    if (this->uart_ == UART_SELECTION_UART0_SWAP) {
-      this->hw_serial_->swap();
+    if (uart_num_ >= 0) {
+      uart_config_t uart_config{};
+      uart_config.baud_rate = (int) baud_rate_;
+      uart_config.data_bits = UART_DATA_8_BITS;
+      uart_config.parity = UART_PARITY_DISABLE;
+      uart_config.stop_bits = UART_STOP_BITS_1;
+      uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
+      uart_param_config(uart_num_, &uart_config);
+      const int uart_buffer_size = tx_buffer_size_;
+      // Install UART driver using an event queue here
+      uart_driver_install(uart_num_, uart_buffer_size, uart_buffer_size, 10, nullptr, 0);
     }
-    this->hw_serial_->setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
-#endif
-#endif  // USE_ARDUINO
+#endif  // USE_ESP_IDF
   }
 #ifdef USE_ESP8266
   else {
     uart_set_debug(UART_NO);
   }
-#endif
+#endif  // USE_ESP8266
 
   global_logger = this;
 #if defined(USE_ESP_IDF) || defined(USE_ESP32_FRAMEWORK_ARDUINO)
@@ -209,7 +238,7 @@ void Logger::pre_setup() {
   if (ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE) {
     esp_log_level_set("*", ESP_LOG_VERBOSE);
   }
-#endif
+#endif  // USE_ESP_IDF || USE_ESP32_FRAMEWORK_ARDUINO
 
   ESP_LOGI(TAG, "Log initialized");
 }
@@ -224,11 +253,24 @@ void Logger::add_on_log_callback(std::function<void(int, const char *, const cha
 float Logger::get_setup_priority() const { return setup_priority::BUS + 500.0f; }
 const char *const LOG_LEVELS[] = {"NONE", "ERROR", "WARN", "INFO", "CONFIG", "DEBUG", "VERBOSE", "VERY_VERBOSE"};
 #ifdef USE_ESP32
-const char *const UART_SELECTIONS[] = {"UART0", "UART1", "UART2"};
-#endif
+const char *const UART_SELECTIONS[] = {
+    "UART0",           "UART1",
+#if !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32S3)
+    "UART2",
+#endif  // !USE_ESP32_VARIANT_ESP32C3 && !USE_ESP32_VARIANT_ESP32S2 && !USE_ESP32_VARIANT_ESP32S3
+#if defined(USE_ESP_IDF)
+#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+    "USB_CDC",
+#endif  // USE_ESP32_VARIANT_ESP32S2 || USE_ESP32_VARIANT_ESP32S3
+#if defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32S3)
+    "USB_SERIAL_JTAG",
+#endif  // USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32S3
+#endif  // USE_ESP_IDF
+};
+#endif  // USE_ESP32
 #ifdef USE_ESP8266
 const char *const UART_SELECTIONS[] = {"UART0", "UART1", "UART0_SWAP"};
-#endif
+#endif  // USE_ESP8266
 void Logger::dump_config() {
   ESP_LOGCONFIG(TAG, "Logger:");
   ESP_LOGCONFIG(TAG, "  Level: %s", LOG_LEVELS[ESPHOME_LOG_LEVEL]);

esphome/components/logger/logger.h

@@ -24,9 +24,19 @@ namespace logger {
 enum UARTSelection {
   UART_SELECTION_UART0 = 0,
   UART_SELECTION_UART1,
-#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32S2)
+#if defined(USE_ESP32)
+#if !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32S3)
   UART_SELECTION_UART2,
 #endif
+#ifdef USE_ESP_IDF
+#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+  UART_SELECTION_USB_CDC,
+#endif
+#if defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32S3)
+  UART_SELECTION_USB_SERIAL_JTAG,
+#endif
+#endif
+#endif
 #ifdef USE_ESP8266
   UART_SELECTION_UART0_SWAP,
 #endif
@@ -40,7 +50,7 @@ class Logger : public Component {
   void set_baud_rate(uint32_t baud_rate);
   uint32_t get_baud_rate() const { return baud_rate_; }
 #ifdef USE_ARDUINO
-  HardwareSerial *get_hw_serial() const { return hw_serial_; }
+  Stream *get_hw_serial() const { return hw_serial_; }
 #endif
 #ifdef USE_ESP_IDF
   uart_port_t get_uart_num() const { return uart_num_; }
@@ -119,7 +129,7 @@ class Logger : public Component {
   int tx_buffer_size_{0};
   UARTSelection uart_{UART_SELECTION_UART0};
 #ifdef USE_ARDUINO
-  HardwareSerial *hw_serial_{nullptr};
+  Stream *hw_serial_{nullptr};
 #endif
 #ifdef USE_ESP_IDF
   uart_port_t uart_num_;

esphome/components/max31865/max31865.cpp

@@ -94,6 +94,14 @@ void MAX31865Sensor::read_data_() {
   const uint16_t rtd_resistance_register = this->read_register_16_(RTD_RESISTANCE_MSB_REG);
   this->write_config_(0b11000000, 0b00000000);
 
+  // Check for bad connection
+  if (rtd_resistance_register == 0b0000000000000000 || rtd_resistance_register == 0b1111111111111111) {
+    ESP_LOGE(TAG, "SPI bus read all 0 or all 1 (0x%04X), check MAX31865 wiring & power.", rtd_resistance_register);
+    this->publish_state(NAN);
+    this->status_set_error();
+    return;
+  }
+
   // Check faults
   const uint8_t faults = this->read_register_(FAULT_STATUS_REG);
   if ((has_fault_ = faults & 0b00111100)) {

esphome/components/max31865/sensor.py

@@ -11,6 +11,9 @@ from esphome.const import (
     UNIT_CELSIUS,
 )
 
+CODEOWNERS = ["@DAVe3283"]
+DEPENDENCIES = ["spi"]
+
 max31865_ns = cg.esphome_ns.namespace("max31865")
 MAX31865Sensor = max31865_ns.class_(
     "MAX31865Sensor", sensor.Sensor, cg.PollingComponent, spi.SPIDevice

esphome/components/max7219digit/max7219digit.h

@@ -93,6 +93,8 @@ class MAX7219Component : public PollingComponent,
   uint8_t strftimedigit(const char *format, time::ESPTime time) __attribute__((format(strftime, 2, 0)));
 #endif
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_BINARY; }
+
  protected:
   void send_byte_(uint8_t a_register, uint8_t data);
   void send_to_all_(uint8_t a_register, uint8_t data);

esphome/components/media_player/__init__.py

@@ -0,0 +1,179 @@
+from esphome import automation
+import esphome.config_validation as cv
+import esphome.codegen as cg
+
+from esphome.automation import maybe_simple_id
+from esphome.const import CONF_ID, CONF_ON_STATE, CONF_TRIGGER_ID
+from esphome.core import CORE
+from esphome.coroutine import coroutine_with_priority
+from esphome.cpp_helpers import setup_entity
+
+
+CODEOWNERS = ["@jesserockz"]
+
+IS_PLATFORM_COMPONENT = True
+
+media_player_ns = cg.esphome_ns.namespace("media_player")
+
+MediaPlayer = media_player_ns.class_("MediaPlayer")
+
+PlayAction = media_player_ns.class_(
+    "PlayAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+PlayMediaAction = media_player_ns.class_(
+    "PlayMediaAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+ToggleAction = media_player_ns.class_(
+    "ToggleAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+PauseAction = media_player_ns.class_(
+    "PauseAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+StopAction = media_player_ns.class_(
+    "StopAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+VolumeUpAction = media_player_ns.class_(
+    "VolumeUpAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+VolumeDownAction = media_player_ns.class_(
+    "VolumeDownAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+VolumeSetAction = media_player_ns.class_(
+    "VolumeSetAction", automation.Action, cg.Parented.template(MediaPlayer)
+)
+
+
+CONF_VOLUME = "volume"
+CONF_ON_IDLE = "on_idle"
+CONF_ON_PLAY = "on_play"
+CONF_ON_PAUSE = "on_pause"
+CONF_MEDIA_URL = "media_url"
+
+StateTrigger = media_player_ns.class_("StateTrigger", automation.Trigger.template())
+IdleTrigger = media_player_ns.class_("IdleTrigger", automation.Trigger.template())
+PlayTrigger = media_player_ns.class_("PlayTrigger", automation.Trigger.template())
+PauseTrigger = media_player_ns.class_("PauseTrigger", automation.Trigger.template())
+IsIdleCondition = media_player_ns.class_("IsIdleCondition", automation.Condition)
+IsPlayingCondition = media_player_ns.class_("IsPlayingCondition", automation.Condition)
+
+
+async def setup_media_player_core_(var, config):
+    await setup_entity(var, config)
+    for conf in config.get(CONF_ON_STATE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+    for conf in config.get(CONF_ON_IDLE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+    for conf in config.get(CONF_ON_PLAY, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+    for conf in config.get(CONF_ON_PAUSE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+
+
+async def register_media_player(var, config):
+    if not CORE.has_id(config[CONF_ID]):
+        var = cg.Pvariable(config[CONF_ID], var)
+    cg.add(cg.App.register_media_player(var))
+    await setup_media_player_core_(var, config)
+
+
+MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
+    {
+        cv.Optional(CONF_ON_STATE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StateTrigger),
+            }
+        ),
+        cv.Optional(CONF_ON_IDLE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(IdleTrigger),
+            }
+        ),
+        cv.Optional(CONF_ON_PLAY): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PlayTrigger),
+            }
+        ),
+        cv.Optional(CONF_ON_PAUSE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PauseTrigger),
+            }
+        ),
+    }
+)
+
+
+MEDIA_PLAYER_ACTION_SCHEMA = maybe_simple_id({cv.GenerateID(): cv.use_id(MediaPlayer)})
+
+
+@automation.register_action(
+    "media_player.play_media",
+    PlayMediaAction,
+    cv.maybe_simple_value(
+        {
+            cv.GenerateID(): cv.use_id(MediaPlayer),
+            cv.Required(CONF_MEDIA_URL): cv.templatable(cv.url),
+        },
+        key=CONF_MEDIA_URL,
+    ),
+)
+async def media_player_play_media_action(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    media_url = await cg.templatable(config[CONF_MEDIA_URL], args, cg.std_string)
+    cg.add(var.set_media_url(media_url))
+    return var
+
+
+@automation.register_action("media_player.play", PlayAction, MEDIA_PLAYER_ACTION_SCHEMA)
+@automation.register_action(
+    "media_player.toggle", ToggleAction, MEDIA_PLAYER_ACTION_SCHEMA
+)
+@automation.register_action(
+    "media_player.pause", PauseAction, MEDIA_PLAYER_ACTION_SCHEMA
+)
+@automation.register_action("media_player.stop", StopAction, MEDIA_PLAYER_ACTION_SCHEMA)
+@automation.register_action(
+    "media_player.volume_up", VolumeUpAction, MEDIA_PLAYER_ACTION_SCHEMA
+)
+@automation.register_action(
+    "media_player.volume_down", VolumeDownAction, MEDIA_PLAYER_ACTION_SCHEMA
+)
+@automation.register_condition(
+    "media_player.is_idle", IsIdleCondition, MEDIA_PLAYER_ACTION_SCHEMA
+)
+@automation.register_condition(
+    "media_player.is_playing", IsPlayingCondition, MEDIA_PLAYER_ACTION_SCHEMA
+)
+async def media_player_action(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@automation.register_action(
+    "media_player.volume_set",
+    VolumeSetAction,
+    cv.maybe_simple_value(
+        {
+            cv.GenerateID(): cv.use_id(MediaPlayer),
+            cv.Required(CONF_VOLUME): cv.templatable(cv.percentage),
+        },
+        key=CONF_VOLUME,
+    ),
+)
+async def media_player_volume_set_action(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    volume = await cg.templatable(config[CONF_VOLUME], args, float)
+    cg.add(var.set_volume(volume))
+    return var
+
+
+@coroutine_with_priority(100.0)
+async def to_code(config):
+    cg.add_global(media_player_ns.using)
+    cg.add_define("USE_MEDIA_PLAYER")

esphome/components/media_player/automation.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "media_player.h"
+
+namespace esphome {
+
+namespace media_player {
+
+#define MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(ACTION_CLASS, ACTION_COMMAND) \
+  template<typename... Ts> class ACTION_CLASS : public Action<Ts...>, public Parented<MediaPlayer> { \
+    void play(Ts... x) override { \
+      this->parent_->make_call().set_command(MediaPlayerCommand::MEDIA_PLAYER_COMMAND_##ACTION_COMMAND).perform(); \
+    } \
+  };
+
+#define MEDIA_PLAYER_SIMPLE_STATE_TRIGGER(TRIGGER_CLASS, TRIGGER_STATE) \
+  class TRIGGER_CLASS : public Trigger<> { \
+   public: \
+    explicit TRIGGER_CLASS(MediaPlayer *player) { \
+      player->add_on_state_callback([this, player]() { \
+        if (player->state == MediaPlayerState::MEDIA_PLAYER_STATE_##TRIGGER_STATE) \
+          this->trigger(); \
+      }); \
+    } \
+  };
+
+MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(PlayAction, PLAY)
+MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(PauseAction, PAUSE)
+MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(StopAction, STOP)
+MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(ToggleAction, TOGGLE)
+MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(VolumeUpAction, VOLUME_UP)
+MEDIA_PLAYER_SIMPLE_COMMAND_ACTION(VolumeDownAction, VOLUME_DOWN)
+
+template<typename... Ts> class PlayMediaAction : public Action<Ts...>, public Parented<MediaPlayer> {
+  TEMPLATABLE_VALUE(std::string, media_url)
+  void play(Ts... x) override { this->parent_->make_call().set_media_url(this->media_url_.value(x...)).perform(); }
+};
+
+template<typename... Ts> class VolumeSetAction : public Action<Ts...>, public Parented<MediaPlayer> {
+  TEMPLATABLE_VALUE(float, volume)
+  void play(Ts... x) override { this->parent_->make_call().set_volume(this->volume_.value(x...)).perform(); }
+};
+
+class StateTrigger : public Trigger<> {
+ public:
+  explicit StateTrigger(MediaPlayer *player) {
+    player->add_on_state_callback([this]() { this->trigger(); });
+  }
+};
+
+MEDIA_PLAYER_SIMPLE_STATE_TRIGGER(IdleTrigger, IDLE)
+MEDIA_PLAYER_SIMPLE_STATE_TRIGGER(PlayTrigger, PLAYING)
+MEDIA_PLAYER_SIMPLE_STATE_TRIGGER(PauseTrigger, PAUSED)
+
+template<typename... Ts> class IsIdleCondition : public Condition<Ts...>, public Parented<MediaPlayer> {
+ public:
+  bool check(Ts... x) override { return this->parent_->state == MediaPlayerState::MEDIA_PLAYER_STATE_IDLE; }
+};
+
+template<typename... Ts> class IsPlayingCondition : public Condition<Ts...>, public Parented<MediaPlayer> {
+ public:
+  bool check(Ts... x) override { return this->parent_->state == MediaPlayerState::MEDIA_PLAYER_STATE_PLAYING; }
+};
+
+}  // namespace media_player
+}  // namespace esphome

esphome/components/media_player/media_player.cpp

@@ -0,0 +1,118 @@
+#include "media_player.h"
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace media_player {
+
+static const char *const TAG = "media_player";
+
+const char *media_player_state_to_string(MediaPlayerState state) {
+  switch (state) {
+    case MEDIA_PLAYER_STATE_IDLE:
+      return "IDLE";
+    case MEDIA_PLAYER_STATE_PLAYING:
+      return "PLAYING";
+    case MEDIA_PLAYER_STATE_PAUSED:
+      return "PAUSED";
+    case MEDIA_PLAYER_STATE_NONE:
+    default:
+      return "UNKNOWN";
+  }
+}
+
+const char *media_player_command_to_string(MediaPlayerCommand command) {
+  switch (command) {
+    case MEDIA_PLAYER_COMMAND_PLAY:
+      return "PLAY";
+    case MEDIA_PLAYER_COMMAND_PAUSE:
+      return "PAUSE";
+    case MEDIA_PLAYER_COMMAND_STOP:
+      return "STOP";
+    case MEDIA_PLAYER_COMMAND_MUTE:
+      return "MUTE";
+    case MEDIA_PLAYER_COMMAND_UNMUTE:
+      return "UNMUTE";
+    case MEDIA_PLAYER_COMMAND_TOGGLE:
+      return "TOGGLE";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+void MediaPlayerCall::validate_() {
+  if (this->media_url_.has_value()) {
+    if (this->command_.has_value()) {
+      ESP_LOGW(TAG, "MediaPlayerCall: Setting both command and media_url is not needed.");
+      this->command_.reset();
+    }
+  }
+  if (this->volume_.has_value()) {
+    if (this->volume_.value() < 0.0f || this->volume_.value() > 1.0f) {
+      ESP_LOGW(TAG, "MediaPlayerCall: Volume must be between 0.0 and 1.0.");
+      this->volume_.reset();
+    }
+  }
+}
+
+void MediaPlayerCall::perform() {
+  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  this->validate_();
+  if (this->command_.has_value()) {
+    const char *command_s = media_player_command_to_string(this->command_.value());
+    ESP_LOGD(TAG, "  Command: %s", command_s);
+  }
+  if (this->media_url_.has_value()) {
+    ESP_LOGD(TAG, "  Media URL: %s", this->media_url_.value().c_str());
+  }
+  if (this->volume_.has_value()) {
+    ESP_LOGD(TAG, "  Volume: %.2f", this->volume_.value());
+  }
+  this->parent_->control(*this);
+}
+
+MediaPlayerCall &MediaPlayerCall::set_command(MediaPlayerCommand command) {
+  this->command_ = command;
+  return *this;
+}
+MediaPlayerCall &MediaPlayerCall::set_command(optional<MediaPlayerCommand> command) {
+  this->command_ = command;
+  return *this;
+}
+MediaPlayerCall &MediaPlayerCall::set_command(const std::string &command) {
+  if (str_equals_case_insensitive(command, "PLAY")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_PLAY);
+  } else if (str_equals_case_insensitive(command, "PAUSE")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_PAUSE);
+  } else if (str_equals_case_insensitive(command, "STOP")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_STOP);
+  } else if (str_equals_case_insensitive(command, "MUTE")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_MUTE);
+  } else if (str_equals_case_insensitive(command, "UNMUTE")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_UNMUTE);
+  } else if (str_equals_case_insensitive(command, "TOGGLE")) {
+    this->set_command(MEDIA_PLAYER_COMMAND_TOGGLE);
+  } else {
+    ESP_LOGW(TAG, "'%s' - Unrecognized command %s", this->parent_->get_name().c_str(), command.c_str());
+  }
+  return *this;
+}
+
+MediaPlayerCall &MediaPlayerCall::set_media_url(const std::string &media_url) {
+  this->media_url_ = media_url;
+  return *this;
+}
+
+MediaPlayerCall &MediaPlayerCall::set_volume(float volume) {
+  this->volume_ = volume;
+  return *this;
+}
+
+void MediaPlayer::add_on_state_callback(std::function<void()> &&callback) {
+  this->state_callback_.add(std::move(callback));
+}
+
+void MediaPlayer::publish_state() { this->state_callback_.call(); }
+
+}  // namespace media_player
+}  // namespace esphome

esphome/components/media_player/media_player.h

@@ -0,0 +1,93 @@
+#pragma once
+
+#include "esphome/core/entity_base.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace media_player {
+
+enum MediaPlayerState : uint8_t {
+  MEDIA_PLAYER_STATE_NONE = 0,
+  MEDIA_PLAYER_STATE_IDLE = 1,
+  MEDIA_PLAYER_STATE_PLAYING = 2,
+  MEDIA_PLAYER_STATE_PAUSED = 3
+};
+const char *media_player_state_to_string(MediaPlayerState state);
+
+enum MediaPlayerCommand : uint8_t {
+  MEDIA_PLAYER_COMMAND_PLAY = 0,
+  MEDIA_PLAYER_COMMAND_PAUSE = 1,
+  MEDIA_PLAYER_COMMAND_STOP = 2,
+  MEDIA_PLAYER_COMMAND_MUTE = 3,
+  MEDIA_PLAYER_COMMAND_UNMUTE = 4,
+  MEDIA_PLAYER_COMMAND_TOGGLE = 5,
+  MEDIA_PLAYER_COMMAND_VOLUME_UP = 6,
+  MEDIA_PLAYER_COMMAND_VOLUME_DOWN = 7,
+};
+const char *media_player_command_to_string(MediaPlayerCommand command);
+
+class MediaPlayer;
+
+class MediaPlayerTraits {
+ public:
+  MediaPlayerTraits() = default;
+
+  void set_supports_pause(bool supports_pause) { this->supports_pause_ = supports_pause; }
+
+  bool get_supports_pause() const { return this->supports_pause_; }
+
+ protected:
+  bool supports_pause_{false};
+};
+
+class MediaPlayerCall {
+ public:
+  MediaPlayerCall(MediaPlayer *parent) : parent_(parent) {}
+
+  MediaPlayerCall &set_command(MediaPlayerCommand command);
+  MediaPlayerCall &set_command(optional<MediaPlayerCommand> command);
+  MediaPlayerCall &set_command(const std::string &command);
+
+  MediaPlayerCall &set_media_url(const std::string &url);
+
+  MediaPlayerCall &set_volume(float volume);
+
+  void perform();
+
+  const optional<MediaPlayerCommand> &get_command() const { return command_; }
+  const optional<std::string> &get_media_url() const { return media_url_; }
+  const optional<float> &get_volume() const { return volume_; }
+
+ protected:
+  void validate_();
+  MediaPlayer *const parent_;
+  optional<MediaPlayerCommand> command_;
+  optional<std::string> media_url_;
+  optional<float> volume_;
+};
+
+class MediaPlayer : public EntityBase {
+ public:
+  MediaPlayerState state{MEDIA_PLAYER_STATE_NONE};
+  float volume{1.0f};
+
+  MediaPlayerCall make_call() { return MediaPlayerCall(this); }
+
+  void publish_state();
+
+  void add_on_state_callback(std::function<void()> &&callback);
+
+  virtual bool is_muted() const { return false; }
+
+  virtual MediaPlayerTraits get_traits() = 0;
+
+ protected:
+  friend MediaPlayerCall;
+
+  virtual void control(const MediaPlayerCall &call) = 0;
+
+  CallbackManager<void()> state_callback_{};
+};
+
+}  // namespace media_player
+}  // namespace esphome

esphome/components/midea/ac_automations.h

@@ -56,6 +56,11 @@ template<typename... Ts> class PowerOffAction : public MideaActionBase<Ts...> {
   void play(Ts... x) override { this->parent_->do_power_off(); }
 };
 
+template<typename... Ts> class PowerToggleAction : public MideaActionBase<Ts...> {
+ public:
+  void play(Ts... x) override { this->parent_->do_power_toggle(); }
+};
+
 }  // namespace ac
 }  // namespace midea
 }  // namespace esphome

esphome/components/midea/air_conditioner.h

@@ -39,6 +39,7 @@ class AirConditioner : public ApplianceBase<dudanov::midea::ac::AirConditioner>,
   void do_beeper_off() { this->set_beeper_feedback(false); }
   void do_power_on() { this->base_.setPowerState(true); }
   void do_power_off() { this->base_.setPowerState(false); }
+  void do_power_toggle() { this->base_.setPowerState(this->mode == ClimateMode::CLIMATE_MODE_OFF); }
   void set_supported_modes(const std::set<ClimateMode> &modes) { this->supported_modes_ = modes; }
   void set_supported_swing_modes(const std::set<ClimateSwingMode> &modes) { this->supported_swing_modes_ = modes; }
   void set_supported_presets(const std::set<ClimatePreset> &presets) { this->supported_presets_ = presets; }

esphome/components/midea/climate.py

@@ -113,7 +113,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_PERIOD, default="1s"): cv.time_period,
             cv.Optional(CONF_TIMEOUT, default="2s"): cv.time_period,
             cv.Optional(CONF_NUM_ATTEMPTS, default=3): cv.int_range(min=1, max=5),
-            cv.Optional(CONF_TRANSMITTER_ID): cv.use_id(
+            cv.OnlyWith(CONF_TRANSMITTER_ID, "remote_transmitter"): cv.use_id(
                 remote_transmitter.RemoteTransmitterComponent
             ),
             cv.Optional(CONF_BEEPER, default=False): cv.boolean,
@@ -163,6 +163,7 @@ BeeperOnAction = midea_ac_ns.class_("BeeperOnAction", automation.Action)
 BeeperOffAction = midea_ac_ns.class_("BeeperOffAction", automation.Action)
 PowerOnAction = midea_ac_ns.class_("PowerOnAction", automation.Action)
 PowerOffAction = midea_ac_ns.class_("PowerOffAction", automation.Action)
+PowerToggleAction = midea_ac_ns.class_("PowerToggleAction", automation.Action)
 
 MIDEA_ACTION_BASE_SCHEMA = cv.Schema(
     {
@@ -249,6 +250,16 @@ async def power_off_to_code(var, config, args):
     pass
 
 
+# Power Toggle action
+@register_action(
+    "power_toggle",
+    PowerToggleAction,
+    cv.Schema({}),
+)
+async def power_inv_to_code(var, config, args):
+    pass
+
+
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/modbus/modbus.cpp

@@ -68,33 +68,59 @@ bool Modbus::parse_modbus_byte_(uint8_t byte) {
 
   uint8_t data_len = raw[2];
   uint8_t data_offset = 3;
-  // the response for write command mirrors the requests and data startes at offset 2 instead of 3 for read commands
-  if (function_code == 0x5 || function_code == 0x06 || function_code == 0xF || function_code == 0x10) {
-    data_offset = 2;
-    data_len = 4;
-  }
 
-  // Error ( msb indicates error )
-  // response format:  Byte[0] = device address, Byte[1] function code | 0x80 , Byte[2] excpetion code, Byte[3-4] crc
-  if ((function_code & 0x80) == 0x80) {
-    data_offset = 2;
-    data_len = 1;
-  }
+  // Per https://modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf Ch 5 User-Defined function codes
+  if (((function_code >= 65) && (function_code <= 72)) || ((function_code >= 100) && (function_code <= 110))) {
+    // Handle user-defined function, since we don't know how big this ought to be,
+    // ideally we should delegate the entire length detection to whatever handler is
+    // installed, but wait, there is the CRC, and if we get a hit there is a good
+    // chance that this is a complete message ... admittedly there is a small chance is
+    // isn't but that is quite small given the purpose of the CRC in the first place
 
-  // Byte data_offset..data_offset+data_len-1: Data
-  if (at < data_offset + data_len)
-    return true;
+    // Fewer than 2 bytes can't calc CRC
+    if (at < 2)
+      return true;
 
-  // Byte 3+data_len: CRC_LO (over all bytes)
-  if (at == data_offset + data_len)
-    return true;
+    data_len = at - 2;
+    data_offset = 1;
 
-  // Byte data_offset+len+1: CRC_HI (over all bytes)
-  uint16_t computed_crc = crc16(raw, data_offset + data_len);
-  uint16_t remote_crc = uint16_t(raw[data_offset + data_len]) | (uint16_t(raw[data_offset + data_len + 1]) << 8);
-  if (computed_crc != remote_crc) {
-    ESP_LOGW(TAG, "Modbus CRC Check failed! %02X!=%02X", computed_crc, remote_crc);
-    return false;
+    uint16_t computed_crc = crc16(raw, data_offset + data_len);
+    uint16_t remote_crc = uint16_t(raw[data_offset + data_len]) | (uint16_t(raw[data_offset + data_len + 1]) << 8);
+
+    if (computed_crc != remote_crc)
+      return true;
+
+    ESP_LOGD(TAG, "Modbus user-defined function %02X found", function_code);
+
+  } else {
+    // the response for write command mirrors the requests and data startes at offset 2 instead of 3 for read commands
+    if (function_code == 0x5 || function_code == 0x06 || function_code == 0xF || function_code == 0x10) {
+      data_offset = 2;
+      data_len = 4;
+    }
+
+    // Error ( msb indicates error )
+    // response format:  Byte[0] = device address, Byte[1] function code | 0x80 , Byte[2] exception code, Byte[3-4] crc
+    if ((function_code & 0x80) == 0x80) {
+      data_offset = 2;
+      data_len = 1;
+    }
+
+    // Byte data_offset..data_offset+data_len-1: Data
+    if (at < data_offset + data_len)
+      return true;
+
+    // Byte 3+data_len: CRC_LO (over all bytes)
+    if (at == data_offset + data_len)
+      return true;
+
+    // Byte data_offset+len+1: CRC_HI (over all bytes)
+    uint16_t computed_crc = crc16(raw, data_offset + data_len);
+    uint16_t remote_crc = uint16_t(raw[data_offset + data_len]) | (uint16_t(raw[data_offset + data_len + 1]) << 8);
+    if (computed_crc != remote_crc) {
+      ESP_LOGW(TAG, "Modbus CRC Check failed! %02X!=%02X", computed_crc, remote_crc);
+      return false;
+    }
   }
   std::vector<uint8_t> data(this->rx_buffer_.begin() + data_offset, this->rx_buffer_.begin() + data_offset + data_len);
   bool found = false;

esphome/components/modbus_controller/modbus_controller.cpp

@@ -70,7 +70,7 @@ void ModbusController::on_modbus_error(uint8_t function_code, uint8_t exception_
   auto &current_command = this->command_queue_.front();
   if (current_command != nullptr) {
     ESP_LOGE(TAG,
-             "Modbus error - last command: function code=0x%X  register adddress = 0x%X  "
+             "Modbus error - last command: function code=0x%X  register address = 0x%X  "
              "registers count=%d "
              "payload size=%zu",
              function_code, current_command->register_address, current_command->register_count,
@@ -105,7 +105,7 @@ void ModbusController::on_register_data(ModbusRegisterType register_type, uint16
 }
 
 void ModbusController::queue_command(const ModbusCommandItem &command) {
-  // check if this commmand is already qeued.
+  // check if this command is already qeued.
   // not very effective but the queue is never really large
   for (auto &item : command_queue_) {
     if (item->register_address == command.register_address && item->register_count == command.register_count &&
@@ -299,7 +299,7 @@ void ModbusController::loop() {
     incoming_queue_.pop();
 
   } else {
-    // all messages processed send pending commmands
+    // all messages processed send pending commands
     send_next_command_();
   }
 }

esphome/components/modbus_controller/modbus_controller.h

@@ -185,8 +185,8 @@ inline bool coil_from_vector(int coil, const std::vector<uint8_t> &data) {
 
 /** Extract bits from value and shift right according to the bitmask
  * if the bitmask is 0x00F0  we want the values frrom bit 5 - 8.
- * the result is then shifted right by the postion if the first right set bit in the mask
- * Usefull for modbus data where more than one value is packed in a 16 bit register
+ * the result is then shifted right by the position if the first right set bit in the mask
+ * Useful for modbus data where more than one value is packed in a 16 bit register
  * Example: on Epever the "Length of night" register 0x9065 encodes values of the whole night length of time as
  * D15 - D8 =  hour, D7 - D0 = minute
  * To get the hours use mask 0xFF00 and  0x00FF for the minute
@@ -447,7 +447,7 @@ class ModbusController : public PollingComponent, public modbus::ModbusDevice {
   void dump_sensors_();
   /// Collection of all sensors for this component
   SensorSet sensorset_;
-  /// Continous range of modbus registers
+  /// Continuous range of modbus registers
   std::vector<RegisterRange> register_ranges_;
   /// Hold the pending requests to be sent
   std::list<std::unique_ptr<ModbusCommandItem>> command_queue_;

esphome/components/modbus_controller/number/__init__.py

@@ -68,7 +68,7 @@ CONFIG_SCHEMA = cv.All(
             ),
             cv.Optional(CONF_VALUE_TYPE, default="U_WORD"): cv.enum(SENSOR_VALUE_TYPE),
             cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
-            # 24 bits are the maximum value for fp32 before precison is lost
+            # 24 bits are the maximum value for fp32 before precision is lost
             # 0x00FFFFFF = 16777215
             cv.Optional(CONF_MAX_VALUE, default=16777215.0): cv.float_,
             cv.Optional(CONF_MIN_VALUE, default=-16777215.0): cv.float_,

esphome/components/mqtt/__init__.py

@@ -24,6 +24,8 @@ from esphome.const import (
     CONF_LOG_TOPIC,
     CONF_ON_JSON_MESSAGE,
     CONF_ON_MESSAGE,
+    CONF_ON_CONNECT,
+    CONF_ON_DISCONNECT,
     CONF_PASSWORD,
     CONF_PAYLOAD,
     CONF_PAYLOAD_AVAILABLE,
@@ -90,6 +92,10 @@ MQTTMessageTrigger = mqtt_ns.class_(
 MQTTJsonMessageTrigger = mqtt_ns.class_(
     "MQTTJsonMessageTrigger", automation.Trigger.template(cg.JsonObjectConst)
 )
+MQTTConnectTrigger = mqtt_ns.class_("MQTTConnectTrigger", automation.Trigger.template())
+MQTTDisconnectTrigger = mqtt_ns.class_(
+    "MQTTDisconnectTrigger", automation.Trigger.template()
+)
 MQTTComponent = mqtt_ns.class_("MQTTComponent", cg.Component)
 MQTTConnectedCondition = mqtt_ns.class_("MQTTConnectedCondition", Condition)
 
@@ -212,6 +218,18 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(
                 CONF_REBOOT_TIMEOUT, default="15min"
             ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_ON_CONNECT): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MQTTConnectTrigger),
+                }
+            ),
+            cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        MQTTDisconnectTrigger
+                    ),
+                }
+            ),
             cv.Optional(CONF_ON_MESSAGE): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MQTTMessageTrigger),
@@ -362,6 +380,14 @@ async def to_code(config):
         trig = cg.new_Pvariable(conf[CONF_TRIGGER_ID], conf[CONF_TOPIC], conf[CONF_QOS])
         await automation.build_automation(trig, [(cg.JsonObjectConst, "x")], conf)
 
+    for conf in config.get(CONF_ON_CONNECT, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+
+    for conf in config.get(CONF_ON_DISCONNECT, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+
 
 MQTT_PUBLISH_ACTION_SCHEMA = cv.Schema(
     {

esphome/components/mqtt/mqtt_client.cpp

@@ -187,7 +187,7 @@ void MQTTClientComponent::start_connect_() {
 
   this->mqtt_backend_.set_credentials(username, password);
 
-  this->mqtt_backend_.set_server((uint32_t) this->ip_, this->credentials_.port);
+  this->mqtt_backend_.set_server(this->credentials_.address.c_str(), this->credentials_.port);
   if (!this->last_will_.topic.empty()) {
     this->mqtt_backend_.set_will(this->last_will_.topic.c_str(), this->last_will_.qos, this->last_will_.retain,
                                  this->last_will_.payload.c_str());
@@ -572,6 +572,14 @@ void MQTTClientComponent::on_shutdown() {
   this->mqtt_backend_.disconnect();
 }
 
+void MQTTClientComponent::set_on_connect(mqtt_on_connect_callback_t &&callback) {
+  this->mqtt_backend_.set_on_connect(std::forward<mqtt_on_connect_callback_t>(callback));
+}
+
+void MQTTClientComponent::set_on_disconnect(mqtt_on_disconnect_callback_t &&callback) {
+  this->mqtt_backend_.set_on_disconnect(std::forward<mqtt_on_disconnect_callback_t>(callback));
+}
+
 #if ASYNC_TCP_SSL_ENABLED
 void MQTTClientComponent::add_ssl_fingerprint(const std::array<uint8_t, SHA1_SIZE> &fingerprint) {
   this->mqtt_backend_.setSecure(true);

esphome/components/mqtt/mqtt_client.h

@@ -19,6 +19,11 @@
 namespace esphome {
 namespace mqtt {
 
+/** Callback for MQTT events.
+ */
+using mqtt_on_connect_callback_t = std::function<MQTTBackend::on_connect_callback_t>;
+using mqtt_on_disconnect_callback_t = std::function<MQTTBackend::on_disconnect_callback_t>;
+
 /** Callback for MQTT subscriptions.
  *
  * First parameter is the topic, the second one is the payload.
@@ -240,6 +245,8 @@ class MQTTClientComponent : public Component {
   void set_username(const std::string &username) { this->credentials_.username = username; }
   void set_password(const std::string &password) { this->credentials_.password = password; }
   void set_client_id(const std::string &client_id) { this->credentials_.client_id = client_id; }
+  void set_on_connect(mqtt_on_connect_callback_t &&callback);
+  void set_on_disconnect(mqtt_on_disconnect_callback_t &&callback);
 
  protected:
   /// Reconnect to the MQTT broker if not already connected.
@@ -328,6 +335,20 @@ class MQTTJsonMessageTrigger : public Trigger<JsonObjectConst> {
   }
 };
 
+class MQTTConnectTrigger : public Trigger<> {
+ public:
+  explicit MQTTConnectTrigger(MQTTClientComponent *&client) {
+    client->set_on_connect([this](bool session_present) { this->trigger(); });
+  }
+};
+
+class MQTTDisconnectTrigger : public Trigger<> {
+ public:
+  explicit MQTTDisconnectTrigger(MQTTClientComponent *&client) {
+    client->set_on_disconnect([this](MQTTClientDisconnectReason reason) { this->trigger(); });
+  }
+};
+
 template<typename... Ts> class MQTTPublishAction : public Action<Ts...> {
  public:
   MQTTPublishAction(MQTTClientComponent *parent) : parent_(parent) {}

esphome/components/mqtt/mqtt_cover.cpp

@@ -51,10 +51,9 @@ void MQTTCoverComponent::setup() {
 void MQTTCoverComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT cover '%s':", this->cover_->get_name().c_str());
   auto traits = this->cover_->get_traits();
-  // no state topic for position
-  bool state_topic = !traits.get_supports_position();
-  LOG_MQTT_COMPONENT(state_topic, true)
-  if (!state_topic) {
+  bool has_command_topic = traits.get_supports_position() || !traits.get_supports_tilt();
+  LOG_MQTT_COMPONENT(true, has_command_topic)
+  if (traits.get_supports_position()) {
     ESP_LOGCONFIG(TAG, "  Position State Topic: '%s'", this->get_position_state_topic().c_str());
     ESP_LOGCONFIG(TAG, "  Position Command Topic: '%s'", this->get_position_command_topic().c_str());
   }
@@ -72,7 +71,6 @@ void MQTTCoverComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConf
     root[MQTT_OPTIMISTIC] = true;
   }
   if (traits.get_supports_position()) {
-    config.state_topic = false;
     root[MQTT_POSITION_TOPIC] = this->get_position_state_topic();
     root[MQTT_SET_POSITION_TOPIC] = this->get_position_command_topic();
   }
@@ -92,17 +90,7 @@ bool MQTTCoverComponent::send_initial_state() { return this->publish_state(); }
 bool MQTTCoverComponent::publish_state() {
   auto traits = this->cover_->get_traits();
   bool success = true;
-  if (!traits.get_supports_position()) {
-    const char *state_s = "unknown";
-    if (this->cover_->position == COVER_OPEN) {
-      state_s = "open";
-    } else if (this->cover_->position == COVER_CLOSED) {
-      state_s = "closed";
-    }
-
-    if (!this->publish(this->get_state_topic_(), state_s))
-      success = false;
-  } else {
+  if (traits.get_supports_position()) {
     std::string pos = value_accuracy_to_string(roundf(this->cover_->position * 100), 0);
     if (!this->publish(this->get_position_state_topic(), pos))
       success = false;
@@ -112,6 +100,14 @@ bool MQTTCoverComponent::publish_state() {
     if (!this->publish(this->get_tilt_state_topic(), pos))
       success = false;
   }
+  const char *state_s = this->cover_->current_operation == COVER_OPERATION_OPENING   ? "opening"
+                        : this->cover_->current_operation == COVER_OPERATION_CLOSING ? "closing"
+                        : this->cover_->position == COVER_CLOSED                     ? "closed"
+                        : this->cover_->position == COVER_OPEN                       ? "open"
+                        : traits.get_supports_position()                             ? "open"
+                                                                                     : "unknown";
+  if (!this->publish(this->get_state_topic_(), state_s))
+    success = false;
   return success;
 }
 

esphome/components/mqtt/mqtt_fan.cpp

@@ -5,7 +5,6 @@
 
 #ifdef USE_MQTT
 #ifdef USE_FAN
-#include "esphome/components/fan/fan_helpers.h"
 
 namespace esphome {
 namespace mqtt {
@@ -88,17 +87,6 @@ void MQTTFanComponent::setup() {
                     });
   }
 
-  if (this->state_->get_traits().supports_speed()) {
-    this->subscribe(this->get_speed_command_topic(), [this](const std::string &topic, const std::string &payload) {
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-      this->state_->make_call()
-          .set_speed(payload.c_str())  // NOLINT(clang-diagnostic-deprecated-declarations)
-          .perform();
-#pragma GCC diagnostic pop
-    });
-  }
-
   auto f = std::bind(&MQTTFanComponent::publish_state, this);
   this->state_->add_on_state_callback([this, f]() { this->defer("send", f); });
 }
@@ -113,8 +101,6 @@ void MQTTFanComponent::dump_config() {
   if (this->state_->get_traits().supports_speed()) {
     ESP_LOGCONFIG(TAG, "  Speed Level State Topic: '%s'", this->get_speed_level_state_topic().c_str());
     ESP_LOGCONFIG(TAG, "  Speed Level Command Topic: '%s'", this->get_speed_level_command_topic().c_str());
-    ESP_LOGCONFIG(TAG, "  Speed State Topic: '%s'", this->get_speed_state_topic().c_str());
-    ESP_LOGCONFIG(TAG, "  Speed Command Topic: '%s'", this->get_speed_command_topic().c_str());
   }
 }
 
@@ -126,10 +112,9 @@ void MQTTFanComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig
     root[MQTT_OSCILLATION_STATE_TOPIC] = this->get_oscillation_state_topic();
   }
   if (this->state_->get_traits().supports_speed()) {
-    root["speed_level_command_topic"] = this->get_speed_level_command_topic();
-    root["speed_level_state_topic"] = this->get_speed_level_state_topic();
-    root[MQTT_SPEED_COMMAND_TOPIC] = this->get_speed_command_topic();
-    root[MQTT_SPEED_STATE_TOPIC] = this->get_speed_state_topic();
+    root[MQTT_PERCENTAGE_COMMAND_TOPIC] = this->get_speed_level_command_topic();
+    root[MQTT_PERCENTAGE_STATE_TOPIC] = this->get_speed_level_state_topic();
+    root[MQTT_SPEED_RANGE_MAX] = this->state_->get_traits().supported_speed_count();
   }
 }
 bool MQTTFanComponent::publish_state() {
@@ -148,31 +133,6 @@ bool MQTTFanComponent::publish_state() {
     bool success = this->publish(this->get_speed_level_state_topic(), payload);
     failed = failed || !success;
   }
-  if (traits.supports_speed()) {
-    const char *payload;
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    // NOLINTNEXTLINE(clang-diagnostic-deprecated-declarations)
-    switch (fan::speed_level_to_enum(this->state_->speed, traits.supported_speed_count())) {
-      case FAN_SPEED_LOW: {  // NOLINT(clang-diagnostic-deprecated-declarations)
-        payload = "low";
-        break;
-      }
-      case FAN_SPEED_MEDIUM: {  // NOLINT(clang-diagnostic-deprecated-declarations)
-        payload = "medium";
-        break;
-      }
-      default:
-      case FAN_SPEED_HIGH: {  // NOLINT(clang-diagnostic-deprecated-declarations)
-        payload = "high";
-        break;
-      }
-    }
-#pragma GCC diagnostic pop
-    bool success = this->publish(this->get_speed_state_topic(), payload);
-    failed = failed || !success;
-  }
-
   return !failed;
 }
 

esphome/components/mqtt/mqtt_select.cpp

@@ -21,7 +21,7 @@ void MQTTSelectComponent::setup() {
     call.set_option(state);
     call.perform();
   });
-  this->select_->add_on_state_callback([this](const std::string &state) { this->publish_state(state); });
+  this->select_->add_on_state_callback([this](const std::string &state, size_t index) { this->publish_state(state); });
 }
 
 void MQTTSelectComponent::dump_config() {

esphome/components/nextion/nextion_commands.cpp

@@ -115,7 +115,7 @@ void Nextion::set_backlight_brightness(float brightness) {
     ESP_LOGD(TAG, "Brightness out of bounds, percentage range 0-1.0");
     return;
   }
-  this->add_no_result_to_queue_with_set("backlight_brightness", "dim", static_cast<int>(brightness * 100));
+  this->add_no_result_to_queue_with_printf_("backlight_brightness", "dim=%d", static_cast<int>(brightness * 100));
 }
 
 void Nextion::set_auto_wake_on_touch(bool auto_wake) {

esphome/components/nfc/ndef_record.cpp

@@ -12,7 +12,7 @@ NdefRecord::NdefRecord(std::vector<uint8_t> payload_data) {
 std::vector<uint8_t> NdefRecord::encode(bool first, bool last) {
   std::vector<uint8_t> data;
 
-  // Get encoded payload, this is overriden by more specific record classes
+  // Get encoded payload, this is overridden by more specific record classes
   std::vector<uint8_t> payload_data = get_encoded_payload();
 
   size_t payload_length = payload_data.size();

esphome/components/number/__init__.py

@@ -14,6 +14,8 @@ from esphome.const import (
     CONF_UNIT_OF_MEASUREMENT,
     CONF_MQTT_ID,
     CONF_VALUE,
+    CONF_OPERATION,
+    CONF_CYCLE,
 )
 from esphome.core import CORE, coroutine_with_priority
 from esphome.cpp_helpers import setup_entity
@@ -35,6 +37,7 @@ ValueRangeTrigger = number_ns.class_(
 
 # Actions
 NumberSetAction = number_ns.class_("NumberSetAction", automation.Action)
+NumberOperationAction = number_ns.class_("NumberOperationAction", automation.Action)
 
 # Conditions
 NumberInRangeCondition = number_ns.class_(
@@ -49,6 +52,15 @@ NUMBER_MODES = {
     "SLIDER": NumberMode.NUMBER_MODE_SLIDER,
 }
 
+NumberOperation = number_ns.enum("NumberOperation")
+
+NUMBER_OPERATION_OPTIONS = {
+    "INCREMENT": NumberOperation.NUMBER_OP_INCREMENT,
+    "DECREMENT": NumberOperation.NUMBER_OP_DECREMENT,
+    "TO_MIN": NumberOperation.NUMBER_OP_TO_MIN,
+    "TO_MAX": NumberOperation.NUMBER_OP_TO_MAX,
+}
+
 icon = cv.icon
 
 NUMBER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).extend(
@@ -159,12 +171,18 @@ async def to_code(config):
     cg.add_global(number_ns.using)
 
 
+OPERATION_BASE_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.use_id(Number),
+    }
+)
+
+
 @automation.register_action(
     "number.set",
     NumberSetAction,
-    cv.Schema(
+    OPERATION_BASE_SCHEMA.extend(
         {
-            cv.Required(CONF_ID): cv.use_id(Number),
             cv.Required(CONF_VALUE): cv.templatable(cv.float_),
         }
     ),
@@ -175,3 +193,85 @@ async def number_set_to_code(config, action_id, template_arg, args):
     template_ = await cg.templatable(config[CONF_VALUE], args, float)
     cg.add(var.set_value(template_))
     return var
+
+
+@automation.register_action(
+    "number.increment",
+    NumberOperationAction,
+    automation.maybe_simple_id(
+        OPERATION_BASE_SCHEMA.extend(
+            {
+                cv.Optional(CONF_MODE, default="INCREMENT"): cv.one_of(
+                    "INCREMENT", upper=True
+                ),
+                cv.Optional(CONF_CYCLE, default=True): cv.boolean,
+            }
+        )
+    ),
+)
+@automation.register_action(
+    "number.decrement",
+    NumberOperationAction,
+    automation.maybe_simple_id(
+        OPERATION_BASE_SCHEMA.extend(
+            {
+                cv.Optional(CONF_MODE, default="DECREMENT"): cv.one_of(
+                    "DECREMENT", upper=True
+                ),
+                cv.Optional(CONF_CYCLE, default=True): cv.boolean,
+            }
+        )
+    ),
+)
+@automation.register_action(
+    "number.to_min",
+    NumberOperationAction,
+    automation.maybe_simple_id(
+        OPERATION_BASE_SCHEMA.extend(
+            {
+                cv.Optional(CONF_MODE, default="TO_MIN"): cv.one_of(
+                    "TO_MIN", upper=True
+                ),
+            }
+        )
+    ),
+)
+@automation.register_action(
+    "number.to_max",
+    NumberOperationAction,
+    automation.maybe_simple_id(
+        OPERATION_BASE_SCHEMA.extend(
+            {
+                cv.Optional(CONF_MODE, default="TO_MAX"): cv.one_of(
+                    "TO_MAX", upper=True
+                ),
+            }
+        )
+    ),
+)
+@automation.register_action(
+    "number.operation",
+    NumberOperationAction,
+    OPERATION_BASE_SCHEMA.extend(
+        {
+            cv.Required(CONF_OPERATION): cv.templatable(
+                cv.enum(NUMBER_OPERATION_OPTIONS, upper=True)
+            ),
+            cv.Optional(CONF_CYCLE, default=True): cv.templatable(cv.boolean),
+        }
+    ),
+)
+async def number_to_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_OPERATION in config:
+        to_ = await cg.templatable(config[CONF_OPERATION], args, NumberOperation)
+        cg.add(var.set_operation(to_))
+        if CONF_CYCLE in config:
+            cycle_ = await cg.templatable(config[CONF_CYCLE], args, bool)
+            cg.add(var.set_cycle(cycle_))
+    if CONF_MODE in config:
+        cg.add(var.set_operation(NUMBER_OPERATION_OPTIONS[config[CONF_MODE]]))
+        if CONF_CYCLE in config:
+            cg.add(var.set_cycle(config[CONF_CYCLE]))
+    return var

esphome/components/number/automation.cpp

@@ -6,8 +6,17 @@ namespace number {
 
 static const char *const TAG = "number.automation";
 
+union convert {
+  float from;
+  uint32_t to;
+};
+
 void ValueRangeTrigger::setup() {
-  this->rtc_ = global_preferences->make_preference<bool>(this->parent_->get_object_id_hash());
+  float local_min = this->min_.value(0.0);
+  float local_max = this->max_.value(0.0);
+  convert hash = {.from = (local_max - local_min)};
+  uint32_t myhash = hash.to ^ this->parent_->get_object_id_hash();
+  this->rtc_ = global_preferences->make_preference<bool>(myhash);
   bool initial_state;
   if (this->rtc_.load(&initial_state)) {
     this->previous_in_range_ = initial_state;

esphome/components/number/automation.h

@@ -29,6 +29,25 @@ template<typename... Ts> class NumberSetAction : public Action<Ts...> {
   Number *number_;
 };
 
+template<typename... Ts> class NumberOperationAction : public Action<Ts...> {
+ public:
+  explicit NumberOperationAction(Number *number) : number_(number) {}
+  TEMPLATABLE_VALUE(NumberOperation, operation)
+  TEMPLATABLE_VALUE(bool, cycle)
+
+  void play(Ts... x) override {
+    auto call = this->number_->make_call();
+    call.with_operation(this->operation_.value(x...));
+    if (this->cycle_.has_value()) {
+      call.with_cycle(this->cycle_.value(x...));
+    }
+    call.perform();
+  }
+
+ protected:
+  Number *number_;
+};
+
 class ValueRangeTrigger : public Trigger<float>, public Component {
  public:
   explicit ValueRangeTrigger(Number *parent) : parent_(parent) {}

esphome/components/number/number.cpp

@@ -6,30 +6,6 @@ namespace number {
 
 static const char *const TAG = "number";
 
-void NumberCall::perform() {
-  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
-  if (!this->value_.has_value() || std::isnan(*this->value_)) {
-    ESP_LOGW(TAG, "No value set for NumberCall");
-    return;
-  }
-
-  const auto &traits = this->parent_->traits;
-  auto value = *this->value_;
-
-  float min_value = traits.get_min_value();
-  if (value < min_value) {
-    ESP_LOGW(TAG, "  Value %f must not be less than minimum %f", value, min_value);
-    return;
-  }
-  float max_value = traits.get_max_value();
-  if (value > max_value) {
-    ESP_LOGW(TAG, "  Value %f must not be greater than maximum %f", value, max_value);
-    return;
-  }
-  ESP_LOGD(TAG, "  Value: %f", *this->value_);
-  this->parent_->control(*this->value_);
-}
-
 void Number::publish_state(float state) {
   this->has_state_ = true;
   this->state = state;
@@ -41,16 +17,5 @@ void Number::add_on_state_callback(std::function<void(float)> &&callback) {
   this->state_callback_.add(std::move(callback));
 }
 
-std::string NumberTraits::get_unit_of_measurement() {
-  if (this->unit_of_measurement_.has_value())
-    return *this->unit_of_measurement_;
-  return "";
-}
-void NumberTraits::set_unit_of_measurement(const std::string &unit_of_measurement) {
-  this->unit_of_measurement_ = unit_of_measurement;
-}
-
-uint32_t Number::hash_base() { return 2282307003UL; }
-
 }  // namespace number
 }  // namespace esphome

esphome/components/number/number.h

@@ -3,6 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
+#include "number_call.h"
+#include "number_traits.h"
 
 namespace esphome {
 namespace number {
@@ -20,54 +22,6 @@ namespace number {
 
 class Number;
 
-class NumberCall {
- public:
-  explicit NumberCall(Number *parent) : parent_(parent) {}
-  void perform();
-
-  NumberCall &set_value(float value) {
-    value_ = value;
-    return *this;
-  }
-  const optional<float> &get_value() const { return value_; }
-
- protected:
-  Number *const parent_;
-  optional<float> value_;
-};
-
-enum NumberMode : uint8_t {
-  NUMBER_MODE_AUTO = 0,
-  NUMBER_MODE_BOX = 1,
-  NUMBER_MODE_SLIDER = 2,
-};
-
-class NumberTraits {
- public:
-  void set_min_value(float min_value) { min_value_ = min_value; }
-  float get_min_value() const { return min_value_; }
-  void set_max_value(float max_value) { max_value_ = max_value; }
-  float get_max_value() const { return max_value_; }
-  void set_step(float step) { step_ = step; }
-  float get_step() const { return step_; }
-
-  /// Get the unit of measurement, using the manual override if set.
-  std::string get_unit_of_measurement();
-  /// Manually set the unit of measurement.
-  void set_unit_of_measurement(const std::string &unit_of_measurement);
-
-  // Get/set the frontend mode.
-  NumberMode get_mode() const { return this->mode_; }
-  void set_mode(NumberMode mode) { this->mode_ = mode; }
-
- protected:
-  float min_value_ = NAN;
-  float max_value_ = NAN;
-  float step_ = NAN;
-  optional<std::string> unit_of_measurement_;  ///< Unit of measurement override
-  NumberMode mode_{NUMBER_MODE_AUTO};
-};
-
 /** Base-class for all numbers.
  *
  * A number can use publish_state to send out a new value.
@@ -79,7 +33,6 @@ class Number : public EntityBase {
   void publish_state(float state);
 
   NumberCall make_call() { return NumberCall(this); }
-  void set(float value) { make_call().set_value(value).perform(); }
 
   void add_on_state_callback(std::function<void(float)> &&callback);
 
@@ -99,8 +52,6 @@ class Number : public EntityBase {
    */
   virtual void control(float value) = 0;
 
-  uint32_t hash_base() override;
-
   CallbackManager<void(float)> state_callback_;
   bool has_state_{false};
 };

esphome/components/number/number_call.cpp

@@ -0,0 +1,118 @@
+#include "number_call.h"
+#include "number.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace number {
+
+static const char *const TAG = "number";
+
+NumberCall &NumberCall::set_value(float value) { return this->with_operation(NUMBER_OP_SET).with_value(value); }
+
+NumberCall &NumberCall::number_increment(bool cycle) {
+  return this->with_operation(NUMBER_OP_INCREMENT).with_cycle(cycle);
+}
+
+NumberCall &NumberCall::number_decrement(bool cycle) {
+  return this->with_operation(NUMBER_OP_DECREMENT).with_cycle(cycle);
+}
+
+NumberCall &NumberCall::number_to_min() { return this->with_operation(NUMBER_OP_TO_MIN); }
+
+NumberCall &NumberCall::number_to_max() { return this->with_operation(NUMBER_OP_TO_MAX); }
+
+NumberCall &NumberCall::with_operation(NumberOperation operation) {
+  this->operation_ = operation;
+  return *this;
+}
+
+NumberCall &NumberCall::with_value(float value) {
+  this->value_ = value;
+  return *this;
+}
+
+NumberCall &NumberCall::with_cycle(bool cycle) {
+  this->cycle_ = cycle;
+  return *this;
+}
+
+void NumberCall::perform() {
+  auto *parent = this->parent_;
+  const auto *name = parent->get_name().c_str();
+  const auto &traits = parent->traits;
+
+  if (this->operation_ == NUMBER_OP_NONE) {
+    ESP_LOGW(TAG, "'%s' - NumberCall performed without selecting an operation", name);
+    return;
+  }
+
+  float target_value = NAN;
+  float min_value = traits.get_min_value();
+  float max_value = traits.get_max_value();
+
+  if (this->operation_ == NUMBER_OP_SET) {
+    ESP_LOGD(TAG, "'%s' - Setting number value", name);
+    if (!this->value_.has_value() || std::isnan(*this->value_)) {
+      ESP_LOGW(TAG, "'%s' - No value set for NumberCall", name);
+      return;
+    }
+    target_value = this->value_.value();
+  } else if (this->operation_ == NUMBER_OP_TO_MIN) {
+    if (std::isnan(min_value)) {
+      ESP_LOGW(TAG, "'%s' - Can't set to min value through NumberCall: no min_value defined", name);
+    } else {
+      target_value = min_value;
+    }
+  } else if (this->operation_ == NUMBER_OP_TO_MAX) {
+    if (std::isnan(max_value)) {
+      ESP_LOGW(TAG, "'%s' - Can't set to max value through NumberCall: no max_value defined", name);
+    } else {
+      target_value = max_value;
+    }
+  } else if (this->operation_ == NUMBER_OP_INCREMENT) {
+    ESP_LOGD(TAG, "'%s' - Increment number, with%s cycling", name, this->cycle_ ? "" : "out");
+    if (!parent->has_state()) {
+      ESP_LOGW(TAG, "'%s' - Can't increment number through NumberCall: no active state to modify", name);
+      return;
+    }
+    auto step = traits.get_step();
+    target_value = parent->state + (std::isnan(step) ? 1 : step);
+    if (target_value > max_value) {
+      if (this->cycle_ && !std::isnan(min_value)) {
+        target_value = min_value;
+      } else {
+        target_value = max_value;
+      }
+    }
+  } else if (this->operation_ == NUMBER_OP_DECREMENT) {
+    ESP_LOGD(TAG, "'%s' - Decrement number, with%s cycling", name, this->cycle_ ? "" : "out");
+    if (!parent->has_state()) {
+      ESP_LOGW(TAG, "'%s' - Can't decrement number through NumberCall: no active state to modify", name);
+      return;
+    }
+    auto step = traits.get_step();
+    target_value = parent->state - (std::isnan(step) ? 1 : step);
+    if (target_value < min_value) {
+      if (this->cycle_ && !std::isnan(max_value)) {
+        target_value = max_value;
+      } else {
+        target_value = min_value;
+      }
+    }
+  }
+
+  if (target_value < min_value) {
+    ESP_LOGW(TAG, "'%s' - Value %f must not be less than minimum %f", name, target_value, min_value);
+    return;
+  }
+  if (target_value > max_value) {
+    ESP_LOGW(TAG, "'%s' - Value %f must not be greater than maximum %f", name, target_value, max_value);
+    return;
+  }
+
+  ESP_LOGD(TAG, "  New number value: %f", target_value);
+  this->parent_->control(target_value);
+}
+
+}  // namespace number
+}  // namespace esphome

esphome/components/number/number_call.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "esphome/core/helpers.h"
+#include "number_traits.h"
+
+namespace esphome {
+namespace number {
+
+class Number;
+
+enum NumberOperation {
+  NUMBER_OP_NONE,
+  NUMBER_OP_SET,
+  NUMBER_OP_INCREMENT,
+  NUMBER_OP_DECREMENT,
+  NUMBER_OP_TO_MIN,
+  NUMBER_OP_TO_MAX,
+};
+
+class NumberCall {
+ public:
+  explicit NumberCall(Number *parent) : parent_(parent) {}
+  void perform();
+
+  NumberCall &set_value(float value);
+  NumberCall &number_increment(bool cycle);
+  NumberCall &number_decrement(bool cycle);
+  NumberCall &number_to_min();
+  NumberCall &number_to_max();
+
+  NumberCall &with_operation(NumberOperation operation);
+  NumberCall &with_value(float value);
+  NumberCall &with_cycle(bool cycle);
+
+ protected:
+  Number *const parent_;
+  NumberOperation operation_{NUMBER_OP_NONE};
+  optional<float> value_;
+  bool cycle_;
+};
+
+}  // namespace number
+}  // namespace esphome

esphome/components/number/number_traits.cpp

@@ -0,0 +1,20 @@
+#include "esphome/core/log.h"
+#include "number_traits.h"
+
+namespace esphome {
+namespace number {
+
+static const char *const TAG = "number";
+
+void NumberTraits::set_unit_of_measurement(const std::string &unit_of_measurement) {
+  this->unit_of_measurement_ = unit_of_measurement;
+}
+
+std::string NumberTraits::get_unit_of_measurement() {
+  if (this->unit_of_measurement_.has_value())
+    return *this->unit_of_measurement_;
+  return "";
+}
+
+}  // namespace number
+}  // namespace esphome

esphome/components/number/number_traits.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace number {
+
+enum NumberMode : uint8_t {
+  NUMBER_MODE_AUTO = 0,
+  NUMBER_MODE_BOX = 1,
+  NUMBER_MODE_SLIDER = 2,
+};
+
+class NumberTraits {
+ public:
+  // Set/get the number value boundaries.
+  void set_min_value(float min_value) { min_value_ = min_value; }
+  float get_min_value() const { return min_value_; }
+  void set_max_value(float max_value) { max_value_ = max_value; }
+  float get_max_value() const { return max_value_; }
+
+  // Set/get the step size for incrementing or decrementing the number value.
+  void set_step(float step) { step_ = step; }
+  float get_step() const { return step_; }
+
+  /// Manually set the unit of measurement.
+  void set_unit_of_measurement(const std::string &unit_of_measurement);
+  /// Get the unit of measurement, using the manual override if set.
+  std::string get_unit_of_measurement();
+
+  // Set/get the frontend mode.
+  void set_mode(NumberMode mode) { this->mode_ = mode; }
+  NumberMode get_mode() const { return this->mode_; }
+
+ protected:
+  float min_value_ = NAN;
+  float max_value_ = NAN;
+  float step_ = NAN;
+  optional<std::string> unit_of_measurement_;  ///< Unit of measurement override
+  NumberMode mode_{NUMBER_MODE_AUTO};
+};
+
+}  // namespace number
+}  // namespace esphome

esphome/components/pcd8544/pcd_8544.h

@@ -52,6 +52,8 @@ class PCD8544 : public PollingComponent,
     this->initialize();
   }
 
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_BINARY; }
+
  protected:
   void draw_absolute_pixel_internal(int x, int y, Color color) override;
 

esphome/components/pipsolar/pipsolar.cpp

@@ -768,7 +768,7 @@ uint8_t Pipsolar::check_incoming_length_(uint8_t length) {
 
 uint8_t Pipsolar::check_incoming_crc_() {
   uint16_t crc16;
-  crc16 = calc_crc_(read_buffer_, read_pos_ - 3);
+  crc16 = cal_crc_half_(read_buffer_, read_pos_ - 3);
   ESP_LOGD(TAG, "checking crc on incoming message");
   if (((uint8_t)((crc16) >> 8)) == read_buffer_[read_pos_ - 3] &&
       ((uint8_t)((crc16) &0xff)) == read_buffer_[read_pos_ - 2]) {
@@ -797,7 +797,7 @@ uint8_t Pipsolar::send_next_command_() {
     this->command_start_millis_ = millis();
     this->empty_uart_buffer_();
     this->read_pos_ = 0;
-    crc16 = calc_crc_(byte_command, length);
+    crc16 = cal_crc_half_(byte_command, length);
     this->write_str(command);
     // checksum
     this->write(((uint8_t)((crc16) >> 8)));   // highbyte
@@ -824,8 +824,8 @@ void Pipsolar::send_next_poll_() {
   this->command_start_millis_ = millis();
   this->empty_uart_buffer_();
   this->read_pos_ = 0;
-  crc16 = calc_crc_(this->used_polling_commands_[this->last_polling_command_].command,
-                    this->used_polling_commands_[this->last_polling_command_].length);
+  crc16 = cal_crc_half_(this->used_polling_commands_[this->last_polling_command_].command,
+                        this->used_polling_commands_[this->last_polling_command_].length);
   this->write_array(this->used_polling_commands_[this->last_polling_command_].command,
                     this->used_polling_commands_[this->last_polling_command_].length);
   // checksum
@@ -892,29 +892,41 @@ void Pipsolar::add_polling_command_(const char *command, ENUMPollingCommand poll
   }
 }
 
-uint16_t Pipsolar::calc_crc_(uint8_t *msg, int n) {
-  // Initial value. xmodem uses 0xFFFF but this example
-  // requires an initial value of zero.
-  uint16_t x = 0;
-  while (n--) {
-    x = crc_xmodem_update_(x, (uint16_t) *msg++);
-  }
-  return (x);
-}
+uint16_t Pipsolar::cal_crc_half_(uint8_t *msg, uint8_t len) {
+  uint16_t crc;
 
-// See bottom of this page: http://www.nongnu.org/avr-libc/user-manual/group__util__crc.html
-// Polynomial: x^16 + x^12 + x^5 + 1 (0x1021)
-uint16_t Pipsolar::crc_xmodem_update_(uint16_t crc, uint8_t data) {
-  int i;
-  crc = crc ^ ((uint16_t) data << 8);
-  for (i = 0; i < 8; i++) {
-    if (crc & 0x8000) {
-      crc = (crc << 1) ^ 0x1021;  //(polynomial = 0x1021)
-    } else {
-      crc <<= 1;
-    }
+  uint8_t da;
+  uint8_t *ptr;
+  uint8_t b_crc_hign;
+  uint8_t b_crc_low;
+
+  uint16_t crc_ta[16] = {0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
+                         0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef};
+
+  ptr = msg;
+  crc = 0;
+
+  while (len-- != 0) {
+    da = ((uint8_t)(crc >> 8)) >> 4;
+    crc <<= 4;
+    crc ^= crc_ta[da ^ (*ptr >> 4)];
+    da = ((uint8_t)(crc >> 8)) >> 4;
+    crc <<= 4;
+    crc ^= crc_ta[da ^ (*ptr & 0x0f)];
+    ptr++;
   }
-  return crc;
+
+  b_crc_low = crc;
+  b_crc_hign = (uint8_t)(crc >> 8);
+
+  if (b_crc_low == 0x28 || b_crc_low == 0x0d || b_crc_low == 0x0a)
+    b_crc_low++;
+  if (b_crc_hign == 0x28 || b_crc_hign == 0x0d || b_crc_hign == 0x0a)
+    b_crc_hign++;
+
+  crc = ((uint16_t) b_crc_hign) << 8;
+  crc += b_crc_low;
+  return (crc);
 }
 
 }  // namespace pipsolar

esphome/components/pipsolar/pipsolar.h

@@ -193,8 +193,7 @@ class Pipsolar : public uart::UARTDevice, public PollingComponent {
   void empty_uart_buffer_();
   uint8_t check_incoming_crc_();
   uint8_t check_incoming_length_(uint8_t length);
-  uint16_t calc_crc_(uint8_t *msg, int n);
-  uint16_t crc_xmodem_update_(uint16_t crc, uint8_t data);
+  uint16_t cal_crc_half_(uint8_t *msg, uint8_t len);
   uint8_t send_next_command_();
   void send_next_poll_();
   void queue_command_(const char *command, uint8_t length);

esphome/components/pmsx003/pmsx003.cpp

@@ -49,6 +49,47 @@ void PMSX003Component::set_formaldehyde_sensor(sensor::Sensor *formaldehyde_sens
 
 void PMSX003Component::loop() {
   const uint32_t now = millis();
+
+  // If we update less often than it takes the device to stabilise, spin the fan down
+  // rather than running it constantly. It does take some time to stabilise, so we
+  // need to keep track of what state we're in.
+  if (this->update_interval_ > PMS_STABILISING_MS) {
+    if (this->initialised_ == 0) {
+      this->send_command_(PMS_CMD_AUTO_MANUAL, 0);
+      this->send_command_(PMS_CMD_ON_STANDBY, 1);
+      this->initialised_ = 1;
+    }
+    switch (this->state_) {
+      case PMSX003_STATE_IDLE:
+        // Power on the sensor now so it'll be ready when we hit the update time
+        if (now - this->last_update_ < (this->update_interval_ - PMS_STABILISING_MS))
+          return;
+
+        this->state_ = PMSX003_STATE_STABILISING;
+        this->send_command_(PMS_CMD_ON_STANDBY, 1);
+        this->fan_on_time_ = now;
+        return;
+      case PMSX003_STATE_STABILISING:
+        // wait for the sensor to be stable
+        if (now - this->fan_on_time_ < PMS_STABILISING_MS)
+          return;
+        // consume any command responses that are in the serial buffer
+        while (this->available())
+          this->read_byte(&this->data_[0]);
+        // Trigger a new read
+        this->send_command_(PMS_CMD_TRIG_MANUAL, 0);
+        this->state_ = PMSX003_STATE_WAITING;
+        break;
+      case PMSX003_STATE_WAITING:
+        // Just go ahead and read stuff
+        break;
+    }
+  } else if (now - this->last_update_ < this->update_interval_) {
+    // Otherwise just leave the sensor powered up and come back when we hit the update
+    // time
+    return;
+  }
+
   if (now - this->last_transmission_ >= 500) {
     // last transmission too long ago. Reset RX index.
     this->data_index_ = 0;
@@ -65,6 +106,7 @@ void PMSX003Component::loop() {
       // finished
       this->parse_data_();
       this->data_index_ = 0;
+      this->last_update_ = now;
     } else if (!*check) {
       // wrong data
       this->data_index_ = 0;
@@ -131,6 +173,25 @@ optional<bool> PMSX003Component::check_byte_() {
   return {};
 }
 
+void PMSX003Component::send_command_(uint8_t cmd, uint16_t data) {
+  this->data_index_ = 0;
+  this->data_[data_index_++] = 0x42;
+  this->data_[data_index_++] = 0x4D;
+  this->data_[data_index_++] = cmd;
+  this->data_[data_index_++] = (data >> 8) & 0xFF;
+  this->data_[data_index_++] = (data >> 0) & 0xFF;
+  int sum = 0;
+  for (int i = 0; i < data_index_; i++) {
+    sum += this->data_[i];
+  }
+  this->data_[data_index_++] = (sum >> 8) & 0xFF;
+  this->data_[data_index_++] = (sum >> 0) & 0xFF;
+  for (int i = 0; i < data_index_; i++) {
+    this->write_byte(this->data_[i]);
+  }
+  this->data_index_ = 0;
+}
+
 void PMSX003Component::parse_data_() {
   switch (this->type_) {
     case PMSX003_TYPE_5003ST: {
@@ -218,6 +279,13 @@ void PMSX003Component::parse_data_() {
     }
   }
 
+  // Spin down the sensor again if we aren't going to need it until more time has
+  // passed than it takes to stabilise
+  if (this->update_interval_ > PMS_STABILISING_MS) {
+    this->send_command_(PMS_CMD_ON_STANDBY, 0);
+    this->state_ = PMSX003_STATE_IDLE;
+  }
+
   this->status_clear_warning();
 }
 uint16_t PMSX003Component::get_16_bit_uint_(uint8_t start_index) {

esphome/components/pmsx003/pmsx003.h

@@ -7,6 +7,13 @@
 namespace esphome {
 namespace pmsx003 {
 
+// known command bytes
+#define PMS_CMD_AUTO_MANUAL 0xE1  // data=0: perform measurement manually, data=1: perform measurement automatically
+#define PMS_CMD_TRIG_MANUAL 0xE2  // trigger a manual measurement
+#define PMS_CMD_ON_STANDBY 0xE4   // data=0: go to standby mode, data=1: go to normal mode
+
+static const uint16_t PMS_STABILISING_MS = 30000;  // time taken for the sensor to become stable after power on
+
 enum PMSX003Type {
   PMSX003_TYPE_X003 = 0,
   PMSX003_TYPE_5003T,
@@ -14,6 +21,12 @@ enum PMSX003Type {
   PMSX003_TYPE_5003S,
 };
 
+enum PMSX003State {
+  PMSX003_STATE_IDLE = 0,
+  PMSX003_STATE_STABILISING,
+  PMSX003_STATE_WAITING,
+};
+
 class PMSX003Component : public uart::UARTDevice, public Component {
  public:
   PMSX003Component() = default;
@@ -23,6 +36,8 @@ class PMSX003Component : public uart::UARTDevice, public Component {
 
   void set_type(PMSX003Type type) { type_ = type; }
 
+  void set_update_interval(uint32_t val) { update_interval_ = val; };
+
   void set_pm_1_0_std_sensor(sensor::Sensor *pm_1_0_std_sensor);
   void set_pm_2_5_std_sensor(sensor::Sensor *pm_2_5_std_sensor);
   void set_pm_10_0_std_sensor(sensor::Sensor *pm_10_0_std_sensor);
@@ -45,11 +60,17 @@ class PMSX003Component : public uart::UARTDevice, public Component {
  protected:
   optional<bool> check_byte_();
   void parse_data_();
+  void send_command_(uint8_t cmd, uint16_t data);
   uint16_t get_16_bit_uint_(uint8_t start_index);
 
   uint8_t data_[64];
   uint8_t data_index_{0};
+  uint8_t initialised_{0};
+  uint32_t fan_on_time_{0};
+  uint32_t last_update_{0};
   uint32_t last_transmission_{0};
+  uint32_t update_interval_{0};
+  PMSX003State state_{PMSX003_STATE_IDLE};
   PMSX003Type type_;
 
   // "Standard Particle"

esphome/components/pmsx003/sensor.py

@@ -1,6 +1,7 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import sensor, uart
+
 from esphome.const import (
     CONF_FORMALDEHYDE,
     CONF_HUMIDITY,
@@ -17,6 +18,7 @@ from esphome.const import (
     CONF_PM_2_5UM,
     CONF_PM_5_0UM,
     CONF_PM_10_0UM,
+    CONF_UPDATE_INTERVAL,
     CONF_TEMPERATURE,
     CONF_TYPE,
     DEVICE_CLASS_PM1,
@@ -44,6 +46,7 @@ TYPE_PMS5003ST = "PMS5003ST"
 TYPE_PMS5003S = "PMS5003S"
 
 PMSX003Type = pmsx003_ns.enum("PMSX003Type")
+
 PMSX003_TYPES = {
     TYPE_PMSX003: PMSX003Type.PMSX003_TYPE_X003,
     TYPE_PMS5003T: PMSX003Type.PMSX003_TYPE_5003T,
@@ -68,6 +71,17 @@ def validate_pmsx003_sensors(value):
     return value
 
 
+def validate_update_interval(value):
+    value = cv.positive_time_period_milliseconds(value)
+    if value == cv.time_period("0s"):
+        return value
+    if value < cv.time_period("30s"):
+        raise cv.Invalid(
+            "Update interval must be greater than or equal to 30 seconds if set."
+        )
+    return value
+
+
 CONFIG_SCHEMA = (
     cv.Schema(
         {
@@ -157,6 +171,7 @@ CONFIG_SCHEMA = (
                 accuracy_decimals=0,
                 state_class=STATE_CLASS_MEASUREMENT,
             ),
+            cv.Optional(CONF_UPDATE_INTERVAL, default="0s"): validate_update_interval,
         }
     )
     .extend(cv.COMPONENT_SCHEMA)
@@ -164,6 +179,17 @@ CONFIG_SCHEMA = (
 )
 
 
+def final_validate(config):
+    require_tx = config[CONF_UPDATE_INTERVAL] > cv.time_period("0s")
+    schema = uart.final_validate_device_schema(
+        "pmsx003", baud_rate=9600, require_rx=True, require_tx=require_tx
+    )
+    schema(config)
+
+
+FINAL_VALIDATE_SCHEMA = final_validate
+
+
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
@@ -230,3 +256,5 @@ async def to_code(config):
     if CONF_FORMALDEHYDE in config:
         sens = await sensor.new_sensor(config[CONF_FORMALDEHYDE])
         cg.add(var.set_formaldehyde_sensor(sens))
+
+    cg.add(var.set_update_interval(config[CONF_UPDATE_INTERVAL]))

esphome/components/prometheus/__init__.py

@@ -1,6 +1,9 @@
 import esphome.config_validation as cv
 import esphome.codegen as cg
-from esphome.const import CONF_ID
+from esphome.const import (
+    CONF_ID,
+    CONF_INCLUDE_INTERNAL,
+)
 from esphome.components.web_server_base import CONF_WEB_SERVER_BASE_ID
 from esphome.components import web_server_base
 
@@ -15,6 +18,7 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(CONF_WEB_SERVER_BASE_ID): cv.use_id(
             web_server_base.WebServerBase
         ),
+        cv.Optional(CONF_INCLUDE_INTERNAL, default=False): cv.boolean,
     },
     cv.only_with_arduino,
 ).extend(cv.COMPONENT_SCHEMA)
@@ -27,3 +31,5 @@ async def to_code(config):
 
     var = cg.new_Pvariable(config[CONF_ID], paren)
     await cg.register_component(var, config)
+
+    cg.add(var.set_include_internal(config[CONF_INCLUDE_INTERNAL]))

esphome/components/prometheus/prometheus_handler.cpp

@@ -61,7 +61,7 @@ void PrometheusHandler::sensor_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_sensor_failed GAUGE\n"));
 }
 void PrometheusHandler::sensor_row_(AsyncResponseStream *stream, sensor::Sensor *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   if (!std::isnan(obj->state)) {
     // We have a valid value, output this value
@@ -98,7 +98,7 @@ void PrometheusHandler::binary_sensor_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_binary_sensor_failed GAUGE\n"));
 }
 void PrometheusHandler::binary_sensor_row_(AsyncResponseStream *stream, binary_sensor::BinarySensor *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   if (obj->has_state()) {
     // We have a valid value, output this value
@@ -134,7 +134,7 @@ void PrometheusHandler::fan_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_fan_oscillation GAUGE\n"));
 }
 void PrometheusHandler::fan_row_(AsyncResponseStream *stream, fan::Fan *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   stream->print(F("esphome_fan_failed{id=\""));
   stream->print(obj->get_object_id().c_str());
@@ -179,7 +179,7 @@ void PrometheusHandler::light_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_light_effect_active GAUGE\n"));
 }
 void PrometheusHandler::light_row_(AsyncResponseStream *stream, light::LightState *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   // State
   stream->print(F("esphome_light_state{id=\""));
@@ -255,7 +255,7 @@ void PrometheusHandler::cover_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_cover_failed GAUGE\n"));
 }
 void PrometheusHandler::cover_row_(AsyncResponseStream *stream, cover::Cover *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   if (!std::isnan(obj->position)) {
     // We have a valid value, output this value
@@ -298,7 +298,7 @@ void PrometheusHandler::switch_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_switch_failed GAUGE\n"));
 }
 void PrometheusHandler::switch_row_(AsyncResponseStream *stream, switch_::Switch *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   stream->print(F("esphome_switch_failed{id=\""));
   stream->print(obj->get_object_id().c_str());
@@ -322,7 +322,7 @@ void PrometheusHandler::lock_type_(AsyncResponseStream *stream) {
   stream->print(F("#TYPE esphome_lock_failed GAUGE\n"));
 }
 void PrometheusHandler::lock_row_(AsyncResponseStream *stream, lock::Lock *obj) {
-  if (obj->is_internal())
+  if (obj->is_internal() && !this->include_internal_)
     return;
   stream->print(F("esphome_lock_failed{id=\""));
   stream->print(obj->get_object_id().c_str());

esphome/components/prometheus/prometheus_handler.h

@@ -13,6 +13,13 @@ class PrometheusHandler : public AsyncWebHandler, public Component {
  public:
   PrometheusHandler(web_server_base::WebServerBase *base) : base_(base) {}
 
+  /** Determine whether internal components should be exported as metrics.
+   * Defaults to false.
+   *
+   * @param include_internal Whether internal components should be exported.
+   */
+  void set_include_internal(bool include_internal) { include_internal_ = include_internal; }
+
   bool canHandle(AsyncWebServerRequest *request) override {
     if (request->method() == HTTP_GET) {
       if (request->url() == "/metrics")
@@ -84,6 +91,7 @@ class PrometheusHandler : public AsyncWebHandler, public Component {
 #endif
 
   web_server_base::WebServerBase *base_;
+  bool include_internal_{false};
 };
 
 }  // namespace prometheus

esphome/components/remote_base/__init__.py

@@ -32,7 +32,7 @@ from esphome.const import (
     CONF_LEVEL,
 )
 from esphome.core import coroutine
-from esphome.jsonschema import jschema_extractor
+from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
 from esphome.util import Registry, SimpleRegistry
 
 AUTO_LOAD = ["binary_sensor"]
@@ -195,14 +195,14 @@ def validate_dumpers(value):
 def validate_triggers(base_schema):
     assert isinstance(base_schema, cv.Schema)
 
-    @jschema_extractor("triggers")
+    @schema_extractor("triggers")
     def validator(config):
         added_keys = {}
         for key, (_, valid) in TRIGGER_REGISTRY.items():
             added_keys[cv.Optional(key)] = valid
         new_schema = base_schema.extend(added_keys)
-        # pylint: disable=comparison-with-callable
-        if config == jschema_extractor:
+
+        if config == SCHEMA_EXTRACT:
             return new_schema
         return new_schema(config)
 
@@ -728,6 +728,48 @@ async def rc5_action(var, config, args):
     cg.add(var.set_command(template_))
 
 
+# RC6
+RC6Data, RC6BinarySensor, RC6Trigger, RC6Action, RC6Dumper = declare_protocol("RC6")
+RC6_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ADDRESS): cv.hex_uint8_t,
+        cv.Required(CONF_COMMAND): cv.hex_uint8_t,
+    }
+)
+
+
+@register_binary_sensor("rc6", RC6BinarySensor, RC6_SCHEMA)
+def rc6_binary_sensor(var, config):
+    cg.add(
+        var.set_data(
+            cg.StructInitializer(
+                RC6Data,
+                ("device", config[CONF_DEVICE]),
+                ("address", config[CONF_ADDRESS]),
+                ("command", config[CONF_COMMAND]),
+            )
+        )
+    )
+
+
+@register_trigger("rc6", RC6Trigger, RC6Data)
+def rc6_trigger(var, config):
+    pass
+
+
+@register_dumper("rc6", RC6Dumper)
+def rc6_dumper(var, config):
+    pass
+
+
+@register_action("rc6", RC6Action, RC6_SCHEMA)
+async def rc6_action(var, config, args):
+    template_ = await cg.templatable(config[CONF_ADDRESS], args, cg.uint8)
+    cg.add(var.set_address(template_))
+    template_ = await cg.templatable(config[CONF_COMMAND], args, cg.uint8)
+    cg.add(var.set_command(template_))
+
+
 # RC Switch Raw
 RC_SWITCH_TIMING_SCHEMA = cv.All([cv.uint8_t], cv.Length(min=2, max=2))
 

esphome/components/remote_base/nexa_protocol.cpp

@@ -106,7 +106,7 @@ optional<NexaData> NexaProtocol::decode(RemoteReceiveData src) {
   SHHHH HHHH HHHH HHHH HHHH HHHH HHGO EE BB DDDD 0 P
 
   S = Sync bit.
-  H = The first 26 bits are transmitter unique codes, and it is this code that the reciever "learns" to recognize.
+  H = The first 26 bits are transmitter unique codes, and it is this code that the receiver "learns" to recognize.
   G = Group code, set to one for the whole group.
   O = On/Off bit. Set to 1 for on, 0 for off.
   E = Unit to be turned on or off. The code is inverted, i.e. '11' equals 1, '00' equals 4.

esphome/components/remote_base/rc6_protocol.cpp

@@ -0,0 +1,181 @@
+#include "rc6_protocol.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace remote_base {
+
+static const char *const RC6_TAG = "remote.rc6";
+
+static const uint16_t RC6_FREQ = 36000;
+static const uint16_t RC6_UNIT = 444;
+static const uint16_t RC6_HEADER_MARK = (6 * RC6_UNIT);
+static const uint16_t RC6_HEADER_SPACE = (2 * RC6_UNIT);
+static const uint16_t RC6_MODE_MASK = 0x07;
+
+void RC6Protocol::encode(RemoteTransmitData *dst, const RC6Data &data) {
+  dst->reserve(44);
+  dst->set_carrier_frequency(RC6_FREQ);
+
+  // Encode header
+  dst->item(RC6_HEADER_MARK, RC6_HEADER_SPACE);
+
+  int32_t next{0};
+
+  // Encode startbit+mode
+  uint8_t header{static_cast<uint8_t>((1 << 3) | data.mode)};
+
+  for (uint8_t mask = 0x8; mask; mask >>= 1) {
+    if (header & mask) {
+      if (next < 0) {
+        dst->space(-next);
+        next = 0;
+      }
+      if (next >= 0) {
+        next = next + RC6_UNIT;
+        dst->mark(next);
+        next = -RC6_UNIT;
+      }
+    } else {
+      if (next > 0) {
+        dst->mark(next);
+        next = 0;
+      }
+      if (next <= 0) {
+        next = next - RC6_UNIT;
+        dst->space(-next);
+        next = RC6_UNIT;
+      }
+    }
+  }
+
+  // Toggle
+  if (data.toggle) {
+    if (next < 0) {
+      dst->space(-next);
+      next = 0;
+    }
+    if (next >= 0) {
+      next = next + RC6_UNIT * 2;
+      dst->mark(next);
+      next = -RC6_UNIT * 2;
+    }
+  } else {
+    if (next > 0) {
+      dst->mark(next);
+      next = 0;
+    }
+    if (next <= 0) {
+      next = next - RC6_UNIT * 2;
+      dst->space(-next);
+      next = RC6_UNIT * 2;
+    }
+  }
+
+  // Encode data
+  uint16_t raw{static_cast<uint16_t>((data.address << 8) | data.command)};
+
+  for (uint16_t mask = 0x8000; mask; mask >>= 1) {
+    if (raw & mask) {
+      if (next < 0) {
+        dst->space(-next);
+        next = 0;
+      }
+      if (next >= 0) {
+        next = next + RC6_UNIT;
+        dst->mark(next);
+        next = -RC6_UNIT;
+      }
+    } else {
+      if (next > 0) {
+        dst->mark(next);
+        next = 0;
+      }
+      if (next <= 0) {
+        next = next - RC6_UNIT;
+        dst->space(-next);
+        next = RC6_UNIT;
+      }
+    }
+  }
+
+  if (next > 0) {
+    dst->mark(next);
+  } else {
+    dst->space(-next);
+  }
+}
+
+optional<RC6Data> RC6Protocol::decode(RemoteReceiveData src) {
+  RC6Data data{
+      .mode = 0,
+      .toggle = 0,
+      .address = 0,
+      .command = 0,
+  };
+
+  // Check if header matches
+  if (!src.expect_item(RC6_HEADER_MARK, RC6_HEADER_SPACE)) {
+    return {};
+  }
+
+  uint8_t bit{1};
+  uint8_t offset{0};
+  uint8_t header{0};
+  uint32_t buffer{0};
+
+  // Startbit + mode
+  while (offset < 4) {
+    bit = src.peek() > 0;
+    header = header + (bit << (3 - offset++));
+    src.advance();
+
+    if (src.peek_mark(RC6_UNIT) || src.peek_space(RC6_UNIT)) {
+      src.advance();
+    } else if (offset == 4) {
+      break;
+    } else if (!src.peek_mark(RC6_UNIT * 2) && !src.peek_space(RC6_UNIT * 2)) {
+      return {};
+    }
+  }
+
+  data.mode = header & RC6_MODE_MASK;
+
+  if (data.mode != 0) {
+    return {};  // I dont have a device to test other modes
+  }
+
+  // Toggle
+  data.toggle = src.peek() > 0;
+  src.advance();
+  if (src.peek_mark(RC6_UNIT * 2) || src.peek_space(RC6_UNIT * 2)) {
+    src.advance();
+  }
+
+  // Data
+  offset = 0;
+  while (offset < 16) {
+    bit = src.peek() > 0;
+    buffer = buffer + (bit << (15 - offset++));
+    src.advance();
+
+    if (offset == 16) {
+      break;
+    } else if (src.peek_mark(RC6_UNIT) || src.peek_space(RC6_UNIT)) {
+      src.advance();
+    } else if (!src.peek_mark(RC6_UNIT * 2) && !src.peek_space(RC6_UNIT * 2)) {
+      return {};
+    }
+  }
+
+  data.address = (0xFF00 & buffer) >> 8;
+  data.command = (0x00FF & buffer);
+  return data;
+}
+
+void RC6Protocol::dump(const RC6Data &data) {
+  ESP_LOGD(RC6_TAG, "Received RC6: mode=0x%X, address=0x%02X, command=0x%02X, toggle=0x%X", data.mode, data.address,
+           data.command, data.toggle);
+}
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/remote_base/rc6_protocol.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "remote_base.h"
+
+namespace esphome {
+namespace remote_base {
+
+struct RC6Data {
+  uint8_t mode : 3;
+  uint8_t toggle : 1;
+  uint8_t address;
+  uint8_t command;
+
+  bool operator==(const RC6Data &rhs) const { return address == rhs.address && command == rhs.command; }
+};
+
+class RC6Protocol : public RemoteProtocol<RC6Data> {
+ public:
+  void encode(RemoteTransmitData *dst, const RC6Data &data) override;
+  optional<RC6Data> decode(RemoteReceiveData src) override;
+  void dump(const RC6Data &data) override;
+};
+
+DECLARE_REMOTE_PROTOCOL(RC6)
+
+template<typename... Ts> class RC6Action : public RemoteTransmitterActionBase<Ts...> {
+ public:
+  TEMPLATABLE_VALUE(uint8_t, address)
+  TEMPLATABLE_VALUE(uint8_t, command)
+
+  void encode(RemoteTransmitData *dst, Ts... x) {
+    RC6Data data{};
+    data.mode = 0;
+    data.toggle = this->toggle_;
+    data.address = this->address_.value(x...);
+    data.command = this->command_.value(x...);
+    RC6Protocol().encode(dst, data);
+    this->toggle_ = !this->toggle_;
+  }
+
+ protected:
+  uint8_t toggle_{0};
+};
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/remote_base/rc_switch_protocol.cpp

@@ -102,7 +102,7 @@ bool RCSwitchBase::expect_sync(RemoteReceiveData &src) const {
     if (!src.peek_space(this->sync_low_, 1))
       return false;
   } else {
-    // We cant peek a space at the beginning because signals starts with a low to high transition.
+    // We can't peek a space at the beginning because signals starts with a low to high transition.
     // this long space at the beginning is the separation between the transmissions itself, so it is actually
     // added at the end kind of artificially (by the value given to "idle:" option by the user in the yaml)
     if (!src.peek_mark(this->sync_low_))

esphome/components/rotary_encoder/rotary_encoder.cpp

@@ -103,7 +103,7 @@ void IRAM_ATTR HOT RotaryEncoderSensorStore::gpio_intr(RotaryEncoderSensorStore
     rotation_dir = -1;
   }
 
-  if (rotation_dir != 0) {
+  if (rotation_dir != 0 && !arg->first_read) {
     auto *first_zero = std::find(arg->rotation_events.begin(), arg->rotation_events.end(), 0);  // find first zero
     if (first_zero == arg->rotation_events.begin()  // are we at the start (first event this loop iteration)
         || std::signbit(*std::prev(first_zero)) !=
@@ -119,6 +119,7 @@ void IRAM_ATTR HOT RotaryEncoderSensorStore::gpio_intr(RotaryEncoderSensorStore
       *std::prev(first_zero) += rotation_dir;  // store the rotation into the previous slot
     }
   }
+  arg->first_read = false;
 
   arg->state = new_state;
 }

esphome/components/rotary_encoder/rotary_encoder.h

@@ -34,6 +34,7 @@ struct RotaryEncoderSensorStore {
   int32_t max_value{INT32_MAX};
   int32_t last_read{0};
   uint8_t state{0};
+  bool first_read{true};
 
   std::array<int8_t, 8> rotation_events{};
   bool rotation_events_overflow{false};

esphome/components/scd4x/automation.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/automation.h"
+#include "scd4x.h"
+
+namespace esphome {
+namespace scd4x {
+
+template<typename... Ts> class PerformForcedCalibrationAction : public Action<Ts...>, public Parented<SCD4XComponent> {
+ public:
+  void play(Ts... x) override {
+    if (this->value_.has_value()) {
+      this->parent_->perform_forced_calibration(this->value_.value(x...));
+    }
+  }
+
+ protected:
+  TEMPLATABLE_VALUE(uint16_t, value)
+};
+
+template<typename... Ts> class FactoryResetAction : public Action<Ts...>, public Parented<SCD4XComponent> {
+ public:
+  void play(Ts... x) override { this->parent_->factory_reset(); }
+};
+
+}  // namespace scd4x
+}  // namespace esphome

esphome/components/scd4x/scd4x.cpp

@@ -13,39 +13,32 @@ static const uint16_t SCD4X_CMD_ALTITUDE_COMPENSATION = 0x2427;
 static const uint16_t SCD4X_CMD_AMBIENT_PRESSURE_COMPENSATION = 0xe000;
 static const uint16_t SCD4X_CMD_AUTOMATIC_SELF_CALIBRATION = 0x2416;
 static const uint16_t SCD4X_CMD_START_CONTINUOUS_MEASUREMENTS = 0x21b1;
+static const uint16_t SCD4X_CMD_START_LOW_POWER_CONTINUOUS_MEASUREMENTS = 0x21ac;
+static const uint16_t SCD4X_CMD_START_LOW_POWER_SINGLE_SHOT = 0x219d;  // SCD41 only
+static const uint16_t SCD4X_CMD_START_LOW_POWER_SINGLE_SHOT_RHT_ONLY = 0x2196;
 static const uint16_t SCD4X_CMD_GET_DATA_READY_STATUS = 0xe4b8;
 static const uint16_t SCD4X_CMD_READ_MEASUREMENT = 0xec05;
 static const uint16_t SCD4X_CMD_PERFORM_FORCED_CALIBRATION = 0x362f;
 static const uint16_t SCD4X_CMD_STOP_MEASUREMENTS = 0x3f86;
-
+static const uint16_t SCD4X_CMD_FACTORY_RESET = 0x3632;
+static const uint16_t SCD4X_CMD_GET_FEATURESET = 0x202f;
 static const float SCD4X_TEMPERATURE_OFFSET_MULTIPLIER = (1 << 16) / 175.0f;
+static const uint16_t SCD41_ID = 0x1408;
+static const uint16_t SCD40_ID = 0x440;
 
 void SCD4XComponent::setup() {
   ESP_LOGCONFIG(TAG, "Setting up scd4x...");
-
   // the sensor needs 1000 ms to enter the idle state
   this->set_timeout(1000, [this]() {
-    uint16_t raw_read_status;
-    if (!this->get_register(SCD4X_CMD_GET_DATA_READY_STATUS, raw_read_status)) {
-      ESP_LOGE(TAG, "Failed to read data ready status");
+    this->status_clear_error();
+    if (!this->write_command(SCD4X_CMD_STOP_MEASUREMENTS)) {
+      ESP_LOGE(TAG, "Failed to stop measurements");
       this->mark_failed();
       return;
     }
-
-    uint32_t stop_measurement_delay = 0;
-    // In order to query the device periodic measurement must be ceased
-    if (raw_read_status) {
-      ESP_LOGD(TAG, "Sensor has data available, stopping periodic measurement");
-      if (!this->write_command(SCD4X_CMD_STOP_MEASUREMENTS)) {
-        ESP_LOGE(TAG, "Failed to stop measurements");
-        this->mark_failed();
-        return;
-      }
-      // According to the SCD4x datasheet the sensor will only respond to other commands after waiting 500 ms after
-      // issuing the stop_periodic_measurement command
-      stop_measurement_delay = 500;
-    }
-    this->set_timeout(stop_measurement_delay, [this]() {
+    // According to the SCD4x datasheet the sensor will only respond to other commands after waiting 500 ms after
+    // issuing the stop_periodic_measurement command
+    this->set_timeout(500, [this]() {
       uint16_t raw_serial_number[3];
       if (!this->get_register(SCD4X_CMD_GET_SERIAL_NUMBER, raw_serial_number, 3, 1)) {
         ESP_LOGE(TAG, "Failed to read serial number");
@@ -89,15 +82,9 @@ void SCD4XComponent::setup() {
         return;
       }
 
-      // Finally start sensor measurements
-      if (!this->write_command(SCD4X_CMD_START_CONTINUOUS_MEASUREMENTS)) {
-        ESP_LOGE(TAG, "Error starting continuous measurements.");
-        this->error_code_ = MEASUREMENT_INIT_FAILED;
-        this->mark_failed();
-        return;
-      }
-
       initialized_ = true;
+      // Finally start sensor measurements
+      this->start_measurement_();
       ESP_LOGD(TAG, "Sensor initialized");
     });
   });
@@ -123,12 +110,31 @@ void SCD4XComponent::dump_config() {
     }
   }
   ESP_LOGCONFIG(TAG, "  Automatic self calibration: %s", ONOFF(this->enable_asc_));
-  if (this->ambient_pressure_compensation_) {
-    ESP_LOGCONFIG(TAG, "  Altitude compensation disabled");
-    ESP_LOGCONFIG(TAG, "  Ambient pressure compensation: %dmBar", this->ambient_pressure_);
+  if (this->ambient_pressure_source_ != nullptr) {
+    ESP_LOGCONFIG(TAG, "  Dynamic ambient pressure compensation using sensor '%s'",
+                  this->ambient_pressure_source_->get_name().c_str());
   } else {
-    ESP_LOGCONFIG(TAG, "  Ambient pressure compensation disabled");
-    ESP_LOGCONFIG(TAG, "  Altitude compensation: %dm", this->altitude_compensation_);
+    if (this->ambient_pressure_compensation_) {
+      ESP_LOGCONFIG(TAG, "  Altitude compensation disabled");
+      ESP_LOGCONFIG(TAG, "  Ambient pressure compensation: %dmBar", this->ambient_pressure_);
+    } else {
+      ESP_LOGCONFIG(TAG, "  Ambient pressure compensation disabled");
+      ESP_LOGCONFIG(TAG, "  Altitude compensation: %dm", this->altitude_compensation_);
+    }
+  }
+  switch (this->measurement_mode_) {
+    case PERIODIC:
+      ESP_LOGCONFIG(TAG, "  Measurement mode: periodic (5s)");
+      break;
+    case LOW_POWER_PERIODIC:
+      ESP_LOGCONFIG(TAG, "  Measurement mode: low power periodic (30s)");
+      break;
+    case SINGLE_SHOT:
+      ESP_LOGCONFIG(TAG, "  Measurement mode: single shot");
+      break;
+    case SINGLE_SHOT_RHT_ONLY:
+      ESP_LOGCONFIG(TAG, "  Measurement mode: single shot rht only");
+      break;
   }
   ESP_LOGCONFIG(TAG, "  Temperature offset: %.2f °C", this->temperature_offset_);
   LOG_UPDATE_INTERVAL(this);
@@ -149,47 +155,105 @@ void SCD4XComponent::update() {
     }
   }
 
-  // Check if data is ready
-  if (!this->write_command(SCD4X_CMD_GET_DATA_READY_STATUS)) {
-    this->status_set_warning();
-    return;
+  uint32_t wait_time = 0;
+  if (this->measurement_mode_ == SINGLE_SHOT || this->measurement_mode_ == SINGLE_SHOT_RHT_ONLY) {
+    start_measurement_();
+    wait_time =
+        this->measurement_mode_ == SINGLE_SHOT ? 5000 : 50;  // Single shot measurement takes 5 secs rht mode 50 ms
   }
+  this->set_timeout(wait_time, [this]() {
+    // Check if data is ready
+    if (!this->write_command(SCD4X_CMD_GET_DATA_READY_STATUS)) {
+      this->status_set_warning();
+      return;
+    }
 
-  uint16_t raw_read_status;
-  if (!this->read_data(raw_read_status) || raw_read_status == 0x00) {
-    this->status_set_warning();
-    ESP_LOGW(TAG, "Data not ready yet!");
-    return;
-  }
+    uint16_t raw_read_status;
 
-  if (!this->write_command(SCD4X_CMD_READ_MEASUREMENT)) {
-    ESP_LOGW(TAG, "Error reading measurement!");
-    this->status_set_warning();
-    return;
-  }
+    if (!this->read_data(raw_read_status) || raw_read_status == 0x00) {
+      this->status_set_warning();
+      ESP_LOGW(TAG, "Data not ready yet!");
+      return;
+    }
 
-  // Read off sensor data
-  uint16_t raw_data[3];
-  if (!this->read_data(raw_data, 3)) {
-    this->status_set_warning();
-    return;
-  }
+    if (!this->write_command(SCD4X_CMD_READ_MEASUREMENT)) {
+      ESP_LOGW(TAG, "Error reading measurement!");
+      this->status_set_warning();
+      return;  // NO RETRY
+    }
+    // Read off sensor data
+    uint16_t raw_data[3];
+    if (!this->read_data(raw_data, 3)) {
+      this->status_set_warning();
+      return;
+    }
+    if (this->co2_sensor_ != nullptr)
+      this->co2_sensor_->publish_state(raw_data[0]);
 
-  if (this->co2_sensor_ != nullptr)
-    this->co2_sensor_->publish_state(raw_data[0]);
-
-  if (this->temperature_sensor_ != nullptr) {
-    const float temperature = -45.0f + (175.0f * (raw_data[1])) / (1 << 16);
-    this->temperature_sensor_->publish_state(temperature);
-  }
-
-  if (this->humidity_sensor_ != nullptr) {
-    const float humidity = (100.0f * raw_data[2]) / (1 << 16);
-    this->humidity_sensor_->publish_state(humidity);
-  }
-
-  this->status_clear_warning();
+    if (this->temperature_sensor_ != nullptr) {
+      const float temperature = -45.0f + (175.0f * (raw_data[1])) / (1 << 16);
+      this->temperature_sensor_->publish_state(temperature);
+    }
+    if (this->humidity_sensor_ != nullptr) {
+      const float humidity = (100.0f * raw_data[2]) / (1 << 16);
+      this->humidity_sensor_->publish_state(humidity);
+    }
+    this->status_clear_warning();
+  });  // set_timeout
 }
+
+bool SCD4XComponent::perform_forced_calibration(uint16_t current_co2_concentration) {
+  /*
+    Operate the SCD4x in the operation mode later used in normal sensor operation (periodic measurement, low power
+    periodic measurement or single shot) for > 3 minutes in an environment with homogeneous and constant CO2
+    concentration before performing a forced recalibration.
+  */
+  if (!this->write_command(SCD4X_CMD_STOP_MEASUREMENTS)) {
+    ESP_LOGE(TAG, "Failed to stop measurements");
+    this->status_set_warning();
+  }
+  this->set_timeout(500, [this, current_co2_concentration]() {
+    if (this->write_command(SCD4X_CMD_PERFORM_FORCED_CALIBRATION, current_co2_concentration)) {
+      ESP_LOGD(TAG, "setting forced calibration Co2 level %d ppm", current_co2_concentration);
+      // frc takes 400 ms
+      // because this method will be used very rarly
+      // the simple approach with delay is ok
+      delay(400);  // NOLINT'
+      if (!this->start_measurement_()) {
+        return false;
+      } else {
+        ESP_LOGD(TAG, "forced calibration complete");
+      }
+      return true;
+    } else {
+      ESP_LOGE(TAG, "force calibration failed");
+      this->error_code_ = FRC_FAILED;
+      this->status_set_warning();
+      return false;
+    }
+  });
+  return true;
+}
+
+bool SCD4XComponent::factory_reset() {
+  if (!this->write_command(SCD4X_CMD_STOP_MEASUREMENTS)) {
+    ESP_LOGE(TAG, "Failed to stop measurements");
+    this->status_set_warning();
+    return false;
+  }
+
+  this->set_timeout(500, [this]() {
+    if (!this->write_command(SCD4X_CMD_FACTORY_RESET)) {
+      ESP_LOGE(TAG, "Failed to send factory reset command");
+      this->status_set_warning();
+      return false;
+    }
+    ESP_LOGD(TAG, "Factory reset complete");
+    return true;
+  });
+  return true;
+}
+
 // Note pressure in bar here. Convert to hPa
 void SCD4XComponent::set_ambient_pressure_compensation(float pressure_in_bar) {
   ambient_pressure_compensation_ = true;
@@ -213,5 +277,38 @@ bool SCD4XComponent::update_ambient_pressure_compensation_(uint16_t pressure_in_
   }
 }
 
+bool SCD4XComponent::start_measurement_() {
+  uint16_t measurement_command = SCD4X_CMD_START_CONTINUOUS_MEASUREMENTS;
+  switch (this->measurement_mode_) {
+    case PERIODIC:
+      measurement_command = SCD4X_CMD_START_CONTINUOUS_MEASUREMENTS;
+      break;
+    case LOW_POWER_PERIODIC:
+      measurement_command = SCD4X_CMD_START_LOW_POWER_CONTINUOUS_MEASUREMENTS;
+      break;
+    case SINGLE_SHOT:
+      measurement_command = SCD4X_CMD_START_LOW_POWER_SINGLE_SHOT;
+      break;
+    case SINGLE_SHOT_RHT_ONLY:
+      measurement_command = SCD4X_CMD_START_LOW_POWER_SINGLE_SHOT_RHT_ONLY;
+      break;
+  }
+
+  static uint8_t remaining_retries = 3;
+  while (remaining_retries) {
+    if (!this->write_command(measurement_command)) {
+      ESP_LOGE(TAG, "Error starting measurements.");
+      this->error_code_ = MEASUREMENT_INIT_FAILED;
+      this->status_set_warning();
+      if (--remaining_retries == 0)
+        return false;
+      delay(50);  // NOLINT wait 50 ms and try again
+    }
+    this->status_clear_warning();
+    return true;
+  }
+  return false;
+}
+
 }  // namespace scd4x
 }  // namespace esphome

esphome/components/scd4x/scd4x.h

@@ -1,5 +1,6 @@
 #pragma once
-
+#include <vector>
+#include "esphome/core/application.h"
 #include "esphome/core/component.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/sensirion_common/i2c_sensirion.h"
@@ -7,7 +8,14 @@
 namespace esphome {
 namespace scd4x {
 
-enum ERRORCODE { COMMUNICATION_FAILED, SERIAL_NUMBER_IDENTIFICATION_FAILED, MEASUREMENT_INIT_FAILED, UNKNOWN };
+enum ERRORCODE {
+  COMMUNICATION_FAILED,
+  SERIAL_NUMBER_IDENTIFICATION_FAILED,
+  MEASUREMENT_INIT_FAILED,
+  FRC_FAILED,
+  UNKNOWN
+};
+enum MeasurementMode { PERIODIC, LOW_POWER_PERIODIC, SINGLE_SHOT, SINGLE_SHOT_RHT_ONLY };
 
 class SCD4XComponent : public PollingComponent, public sensirion_common::SensirionI2CDevice {
  public:
@@ -25,10 +33,13 @@ class SCD4XComponent : public PollingComponent, public sensirion_common::Sensiri
   void set_co2_sensor(sensor::Sensor *co2) { co2_sensor_ = co2; }
   void set_temperature_sensor(sensor::Sensor *temperature) { temperature_sensor_ = temperature; };
   void set_humidity_sensor(sensor::Sensor *humidity) { humidity_sensor_ = humidity; }
+  void set_measurement_mode(MeasurementMode mode) { measurement_mode_ = mode; }
+  bool perform_forced_calibration(uint16_t current_co2_concentration);
+  bool factory_reset();
 
  protected:
   bool update_ambient_pressure_compensation_(uint16_t pressure_in_hpa);
-
+  bool start_measurement_();
   ERRORCODE error_code_;
 
   bool initialized_{false};
@@ -38,7 +49,7 @@ class SCD4XComponent : public PollingComponent, public sensirion_common::Sensiri
   bool ambient_pressure_compensation_;
   uint16_t ambient_pressure_;
   bool enable_asc_;
-
+  MeasurementMode measurement_mode_{PERIODIC};
   sensor::Sensor *co2_sensor_{nullptr};
   sensor::Sensor *temperature_sensor_{nullptr};
   sensor::Sensor *humidity_sensor_{nullptr};

esphome/components/scd4x/sensor.py

@@ -2,11 +2,15 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import i2c, sensor
 from esphome.components import sensirion_common
+from esphome import automation
+from esphome.automation import maybe_simple_id
+
 from esphome.const import (
     CONF_ID,
     CONF_CO2,
     CONF_HUMIDITY,
     CONF_TEMPERATURE,
+    CONF_VALUE,
     DEVICE_CLASS_CARBON_DIOXIDE,
     DEVICE_CLASS_HUMIDITY,
     DEVICE_CLASS_TEMPERATURE,
@@ -19,7 +23,7 @@ from esphome.const import (
     UNIT_PERCENT,
 )
 
-CODEOWNERS = ["@sjtrny"]
+CODEOWNERS = ["@sjtrny", "@martgras"]
 DEPENDENCIES = ["i2c"]
 AUTO_LOAD = ["sensirion_common"]
 
@@ -27,12 +31,29 @@ scd4x_ns = cg.esphome_ns.namespace("scd4x")
 SCD4XComponent = scd4x_ns.class_(
     "SCD4XComponent", cg.PollingComponent, sensirion_common.SensirionI2CDevice
 )
+MeasurementMode = scd4x_ns.enum("MEASUREMENT_MODE")
+MEASUREMENT_MODE_OPTIONS = {
+    "periodic": MeasurementMode.PERIODIC,
+    "low_power_periodic": MeasurementMode.LOW_POWER_PERIODIC,
+    "single_shot": MeasurementMode.SINGLE_SHOT,
+    "single_shot_rht_only": MeasurementMode.SINGLE_SHOT_RHT_ONLY,
+}
+
+
+# Actions
+PerformForcedCalibrationAction = scd4x_ns.class_(
+    "PerformForcedCalibrationAction", automation.Action
+)
+FactoryResetAction = scd4x_ns.class_("FactoryResetAction", automation.Action)
+
 
-CONF_AUTOMATIC_SELF_CALIBRATION = "automatic_self_calibration"
 CONF_ALTITUDE_COMPENSATION = "altitude_compensation"
 CONF_AMBIENT_PRESSURE_COMPENSATION = "ambient_pressure_compensation"
-CONF_TEMPERATURE_OFFSET = "temperature_offset"
 CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE = "ambient_pressure_compensation_source"
+CONF_AUTOMATIC_SELF_CALIBRATION = "automatic_self_calibration"
+CONF_MEASUREMENT_MODE = "measurement_mode"
+CONF_TEMPERATURE_OFFSET = "temperature_offset"
+
 
 CONFIG_SCHEMA = (
     cv.Schema(
@@ -69,6 +90,9 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE): cv.use_id(
                 sensor.Sensor
             ),
+            cv.Optional(CONF_MEASUREMENT_MODE, default="periodic"): cv.enum(
+                MEASUREMENT_MODE_OPTIONS, lower=True
+            ),
         }
     )
     .extend(cv.polling_component_schema("60s"))
@@ -106,3 +130,42 @@ async def to_code(config):
     if CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE in config:
         sens = await cg.get_variable(config[CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE])
         cg.add(var.set_ambient_pressure_source(sens))
+
+    cg.add(var.set_measurement_mode(config[CONF_MEASUREMENT_MODE]))
+
+
+SCD4X_ACTION_SCHEMA = maybe_simple_id(
+    {
+        cv.GenerateID(): cv.use_id(SCD4XComponent),
+        cv.Required(CONF_VALUE): cv.templatable(cv.positive_int),
+    }
+)
+
+
+@automation.register_action(
+    "scd4x.perform_forced_calibration",
+    PerformForcedCalibrationAction,
+    SCD4X_ACTION_SCHEMA,
+)
+async def scd4x_frc_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_VALUE], args, cg.uint16)
+    cg.add(var.set_value(template_))
+    return var
+
+
+SCD4X_RESET_ACTION_SCHEMA = maybe_simple_id(
+    {
+        cv.Required(CONF_ID): cv.use_id(SCD4XComponent),
+    }
+)
+
+
+@automation.register_action(
+    "scd4x.factory_reset", FactoryResetAction, SCD4X_RESET_ACTION_SCHEMA
+)
+async def scd4x_reset_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var

esphome/components/sdp3x/sdp3x.cpp

@@ -40,7 +40,7 @@ void SDP3XComponent::setup() {
     }
 
     uint16_t data[6];
-    if (this->read_data(data, 6) != i2c::ERROR_OK) {
+    if (!this->read_data(data, 6)) {
       ESP_LOGE(TAG, "Read ID SDP3X failed!");
       this->mark_failed();
       return;
@@ -78,8 +78,7 @@ void SDP3XComponent::setup() {
       }
     }
 
-    if (this->write_command(measurement_mode_ == DP_AVG ? SDP3X_START_DP_AVG : SDP3X_START_MASS_FLOW_AVG) !=
-        i2c::ERROR_OK) {
+    if (!this->write_command(measurement_mode_ == DP_AVG ? SDP3X_START_DP_AVG : SDP3X_START_MASS_FLOW_AVG)) {
       ESP_LOGE(TAG, "Start Measurements SDP3X failed!");
       this->mark_failed();
       return;
@@ -98,7 +97,7 @@ void SDP3XComponent::dump_config() {
 
 void SDP3XComponent::read_pressure_() {
   uint16_t data[3];
-  if (this->read_data(data, 3) != i2c::ERROR_OK) {
+  if (!this->read_data(data, 3)) {
     ESP_LOGW(TAG, "Couldn't read SDP3X data!");
     this->status_set_warning();
     return;

esphome/components/select/__init__.py

@@ -9,6 +9,10 @@ from esphome.const import (
     CONF_OPTION,
     CONF_TRIGGER_ID,
     CONF_MQTT_ID,
+    CONF_CYCLE,
+    CONF_MODE,
+    CONF_OPERATION,
+    CONF_INDEX,
 )
 from esphome.core import CORE, coroutine_with_priority
 from esphome.cpp_helpers import setup_entity
@@ -22,14 +26,27 @@ SelectPtr = Select.operator("ptr")
 
 # Triggers
 SelectStateTrigger = select_ns.class_(
-    "SelectStateTrigger", automation.Trigger.template(cg.float_)
+    "SelectStateTrigger",
+    automation.Trigger.template(cg.std_string, cg.size_t),
 )
 
 # Actions
 SelectSetAction = select_ns.class_("SelectSetAction", automation.Action)
+SelectSetIndexAction = select_ns.class_("SelectSetIndexAction", automation.Action)
+SelectOperationAction = select_ns.class_("SelectOperationAction", automation.Action)
+
+# Enums
+SelectOperation = select_ns.enum("SelectOperation")
+SELECT_OPERATION_OPTIONS = {
+    "NEXT": SelectOperation.SELECT_OP_NEXT,
+    "PREVIOUS": SelectOperation.SELECT_OP_PREVIOUS,
+    "FIRST": SelectOperation.SELECT_OP_FIRST,
+    "LAST": SelectOperation.SELECT_OP_LAST,
+}
 
 icon = cv.icon
 
+
 SELECT_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).extend(
     {
         cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTSelectComponent),
@@ -50,7 +67,9 @@ async def setup_select_core_(var, config, *, options: List[str]):
 
     for conf in config.get(CONF_ON_VALUE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [(cg.std_string, "x")], conf)
+        await automation.build_automation(
+            trigger, [(cg.std_string, "x"), (cg.size_t, "i")], conf
+        )
 
     if CONF_MQTT_ID in config:
         mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
@@ -76,12 +95,18 @@ async def to_code(config):
     cg.add_global(select_ns.using)
 
 
+OPERATION_BASE_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.use_id(Select),
+    }
+)
+
+
 @automation.register_action(
     "select.set",
     SelectSetAction,
-    cv.Schema(
+    OPERATION_BASE_SCHEMA.extend(
         {
-            cv.Required(CONF_ID): cv.use_id(Select),
             cv.Required(CONF_OPTION): cv.templatable(cv.string_strict),
         }
     ),
@@ -92,3 +117,96 @@ async def select_set_to_code(config, action_id, template_arg, args):
     template_ = await cg.templatable(config[CONF_OPTION], args, cg.std_string)
     cg.add(var.set_option(template_))
     return var
+
+
+@automation.register_action(
+    "select.set_index",
+    SelectSetIndexAction,
+    OPERATION_BASE_SCHEMA.extend(
+        {
+            cv.Required(CONF_INDEX): cv.templatable(cv.positive_int),
+        }
+    ),
+)
+async def select_set_index_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_INDEX], args, cg.size_t)
+    cg.add(var.set_index(template_))
+    return var
+
+
+@automation.register_action(
+    "select.operation",
+    SelectOperationAction,
+    OPERATION_BASE_SCHEMA.extend(
+        {
+            cv.Required(CONF_OPERATION): cv.templatable(
+                cv.enum(SELECT_OPERATION_OPTIONS, upper=True)
+            ),
+            cv.Optional(CONF_CYCLE, default=True): cv.templatable(cv.boolean),
+        }
+    ),
+)
+@automation.register_action(
+    "select.next",
+    SelectOperationAction,
+    automation.maybe_simple_id(
+        OPERATION_BASE_SCHEMA.extend(
+            {
+                cv.Optional(CONF_MODE, default="NEXT"): cv.one_of("NEXT", upper=True),
+                cv.Optional(CONF_CYCLE, default=True): cv.boolean,
+            }
+        )
+    ),
+)
+@automation.register_action(
+    "select.previous",
+    SelectOperationAction,
+    automation.maybe_simple_id(
+        OPERATION_BASE_SCHEMA.extend(
+            {
+                cv.Optional(CONF_MODE, default="PREVIOUS"): cv.one_of(
+                    "PREVIOUS", upper=True
+                ),
+                cv.Optional(CONF_CYCLE, default=True): cv.boolean,
+            }
+        )
+    ),
+)
+@automation.register_action(
+    "select.first",
+    SelectOperationAction,
+    automation.maybe_simple_id(
+        OPERATION_BASE_SCHEMA.extend(
+            {
+                cv.Optional(CONF_MODE, default="FIRST"): cv.one_of("FIRST", upper=True),
+            }
+        )
+    ),
+)
+@automation.register_action(
+    "select.last",
+    SelectOperationAction,
+    automation.maybe_simple_id(
+        OPERATION_BASE_SCHEMA.extend(
+            {
+                cv.Optional(CONF_MODE, default="LAST"): cv.one_of("LAST", upper=True),
+            }
+        )
+    ),
+)
+async def select_operation_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_OPERATION in config:
+        op_ = await cg.templatable(config[CONF_OPERATION], args, SelectOperation)
+        cg.add(var.set_operation(op_))
+        if CONF_CYCLE in config:
+            cycle_ = await cg.templatable(config[CONF_CYCLE], args, bool)
+            cg.add(var.set_cycle(cycle_))
+    if CONF_MODE in config:
+        cg.add(var.set_operation(SELECT_OPERATION_OPTIONS[config[CONF_MODE]]))
+        if CONF_CYCLE in config:
+            cg.add(var.set_cycle(config[CONF_CYCLE]))
+    return var

esphome/components/select/automation.h

@@ -7,16 +7,16 @@
 namespace esphome {
 namespace select {
 
-class SelectStateTrigger : public Trigger<std::string> {
+class SelectStateTrigger : public Trigger<std::string, size_t> {
  public:
   explicit SelectStateTrigger(Select *parent) {
-    parent->add_on_state_callback([this](const std::string &value) { this->trigger(value); });
+    parent->add_on_state_callback([this](const std::string &value, size_t index) { this->trigger(value, index); });
   }
 };
 
 template<typename... Ts> class SelectSetAction : public Action<Ts...> {
  public:
-  SelectSetAction(Select *select) : select_(select) {}
+  explicit SelectSetAction(Select *select) : select_(select) {}
   TEMPLATABLE_VALUE(std::string, option)
 
   void play(Ts... x) override {
@@ -29,5 +29,39 @@ template<typename... Ts> class SelectSetAction : public Action<Ts...> {
   Select *select_;
 };
 
+template<typename... Ts> class SelectSetIndexAction : public Action<Ts...> {
+ public:
+  explicit SelectSetIndexAction(Select *select) : select_(select) {}
+  TEMPLATABLE_VALUE(size_t, index)
+
+  void play(Ts... x) override {
+    auto call = this->select_->make_call();
+    call.set_index(this->index_.value(x...));
+    call.perform();
+  }
+
+ protected:
+  Select *select_;
+};
+
+template<typename... Ts> class SelectOperationAction : public Action<Ts...> {
+ public:
+  explicit SelectOperationAction(Select *select) : select_(select) {}
+  TEMPLATABLE_VALUE(bool, cycle)
+  TEMPLATABLE_VALUE(SelectOperation, operation)
+
+  void play(Ts... x) override {
+    auto call = this->select_->make_call();
+    call.with_operation(this->operation_.value(x...));
+    if (this->cycle_.has_value()) {
+      call.with_cycle(this->cycle_.value(x...));
+    }
+    call.perform();
+  }
+
+ protected:
+  Select *select_;
+};
+
 }  // namespace select
 }  // namespace esphome

esphome/components/select/select.cpp

@@ -6,38 +6,57 @@ namespace select {
 
 static const char *const TAG = "select";
 
-void SelectCall::perform() {
-  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
-  if (!this->option_.has_value()) {
-    ESP_LOGW(TAG, "No value set for SelectCall");
-    return;
-  }
-
-  const auto &traits = this->parent_->traits;
-  auto value = *this->option_;
-  auto options = traits.get_options();
-
-  if (std::find(options.begin(), options.end(), value) == options.end()) {
-    ESP_LOGW(TAG, "  Option %s is not a valid option.", value.c_str());
-    return;
-  }
-
-  ESP_LOGD(TAG, "  Option: %s", (*this->option_).c_str());
-  this->parent_->control(*this->option_);
-}
-
 void Select::publish_state(const std::string &state) {
-  this->has_state_ = true;
-  this->state = state;
-  ESP_LOGD(TAG, "'%s': Sending state %s", this->get_name().c_str(), state.c_str());
-  this->state_callback_.call(state);
+  auto index = this->index_of(state);
+  const auto *name = this->get_name().c_str();
+  if (index.has_value()) {
+    this->has_state_ = true;
+    this->state = state;
+    ESP_LOGD(TAG, "'%s': Sending state %s (index %d)", name, state.c_str(), index.value());
+    this->state_callback_.call(state, index.value());
+  } else {
+    ESP_LOGE(TAG, "'%s': invalid state for publish_state(): %s", name, state.c_str());
+  }
 }
 
-void Select::add_on_state_callback(std::function<void(std::string)> &&callback) {
+void Select::add_on_state_callback(std::function<void(std::string, size_t)> &&callback) {
   this->state_callback_.add(std::move(callback));
 }
 
-uint32_t Select::hash_base() { return 2812997003UL; }
+bool Select::has_option(const std::string &option) const { return this->index_of(option).has_value(); }
+
+bool Select::has_index(size_t index) const { return index < this->size(); }
+
+size_t Select::size() const {
+  auto options = traits.get_options();
+  return options.size();
+}
+
+optional<size_t> Select::index_of(const std::string &option) const {
+  auto options = traits.get_options();
+  auto it = std::find(options.begin(), options.end(), option);
+  if (it == options.end()) {
+    return {};
+  }
+  return std::distance(options.begin(), it);
+}
+
+optional<size_t> Select::active_index() const {
+  if (this->has_state()) {
+    return this->index_of(this->state);
+  } else {
+    return {};
+  }
+}
+
+optional<std::string> Select::at(size_t index) const {
+  if (this->has_index(index)) {
+    auto options = traits.get_options();
+    return options.at(index);
+  } else {
+    return {};
+  }
+}
 
 }  // namespace select
 }  // namespace esphome

esphome/components/select/select.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <set>
-#include <utility>
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
+#include "select_call.h"
+#include "select_traits.h"
 
 namespace esphome {
 namespace select {
@@ -17,33 +17,6 @@ namespace select {
     } \
   }
 
-class Select;
-
-class SelectCall {
- public:
-  explicit SelectCall(Select *parent) : parent_(parent) {}
-  void perform();
-
-  SelectCall &set_option(const std::string &option) {
-    option_ = option;
-    return *this;
-  }
-  const optional<std::string> &get_option() const { return option_; }
-
- protected:
-  Select *const parent_;
-  optional<std::string> option_;
-};
-
-class SelectTraits {
- public:
-  void set_options(std::vector<std::string> options) { this->options_ = std::move(options); }
-  std::vector<std::string> get_options() const { return this->options_; }
-
- protected:
-  std::vector<std::string> options_;
-};
-
 /** Base-class for all selects.
  *
  * A select can use publish_state to send out a new value.
@@ -51,19 +24,36 @@ class SelectTraits {
 class Select : public EntityBase {
  public:
   std::string state;
+  SelectTraits traits;
 
   void publish_state(const std::string &state);
 
-  SelectCall make_call() { return SelectCall(this); }
-  void set(const std::string &value) { make_call().set_option(value).perform(); }
-
-  void add_on_state_callback(std::function<void(std::string)> &&callback);
-
-  SelectTraits traits;
-
-  /// Return whether this select has gotten a full state yet.
+  /// Return whether this select component has gotten a full state yet.
   bool has_state() const { return has_state_; }
 
+  /// Instantiate a SelectCall object to modify this select component's state.
+  SelectCall make_call() { return SelectCall(this); }
+
+  /// Return whether this select component contains the provided option.
+  bool has_option(const std::string &option) const;
+
+  /// Return whether this select component contains the provided index offset.
+  bool has_index(size_t index) const;
+
+  /// Return the number of options in this select component.
+  size_t size() const;
+
+  /// Find the (optional) index offset of the provided option value.
+  optional<size_t> index_of(const std::string &option) const;
+
+  /// Return the (optional) index offset of the currently active option.
+  optional<size_t> active_index() const;
+
+  /// Return the (optional) option value at the provided index offset.
+  optional<std::string> at(size_t index) const;
+
+  void add_on_state_callback(std::function<void(std::string, size_t)> &&callback);
+
  protected:
   friend class SelectCall;
 
@@ -75,9 +65,7 @@ class Select : public EntityBase {
    */
   virtual void control(const std::string &value) = 0;
 
-  uint32_t hash_base() override;
-
-  CallbackManager<void(std::string)> state_callback_;
+  CallbackManager<void(std::string, size_t)> state_callback_;
   bool has_state_{false};
 };
 

esphome/components/select/select_call.cpp

@@ -0,0 +1,120 @@
+#include "select_call.h"
+#include "select.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace select {
+
+static const char *const TAG = "select";
+
+SelectCall &SelectCall::set_option(const std::string &option) {
+  return with_operation(SELECT_OP_SET).with_option(option);
+}
+
+SelectCall &SelectCall::set_index(size_t index) { return with_operation(SELECT_OP_SET_INDEX).with_index(index); }
+
+SelectCall &SelectCall::select_next(bool cycle) { return with_operation(SELECT_OP_NEXT).with_cycle(cycle); }
+
+SelectCall &SelectCall::select_previous(bool cycle) { return with_operation(SELECT_OP_PREVIOUS).with_cycle(cycle); }
+
+SelectCall &SelectCall::select_first() { return with_operation(SELECT_OP_FIRST); }
+
+SelectCall &SelectCall::select_last() { return with_operation(SELECT_OP_LAST); }
+
+SelectCall &SelectCall::with_operation(SelectOperation operation) {
+  this->operation_ = operation;
+  return *this;
+}
+
+SelectCall &SelectCall::with_cycle(bool cycle) {
+  this->cycle_ = cycle;
+  return *this;
+}
+
+SelectCall &SelectCall::with_option(const std::string &option) {
+  this->option_ = option;
+  return *this;
+}
+
+SelectCall &SelectCall::with_index(size_t index) {
+  this->index_ = index;
+  return *this;
+}
+
+void SelectCall::perform() {
+  auto *parent = this->parent_;
+  const auto *name = parent->get_name().c_str();
+  const auto &traits = parent->traits;
+  auto options = traits.get_options();
+
+  if (this->operation_ == SELECT_OP_NONE) {
+    ESP_LOGW(TAG, "'%s' - SelectCall performed without selecting an operation", name);
+    return;
+  }
+  if (options.empty()) {
+    ESP_LOGW(TAG, "'%s' - Cannot perform SelectCall, select has no options", name);
+    return;
+  }
+
+  std::string target_value;
+
+  if (this->operation_ == SELECT_OP_SET) {
+    ESP_LOGD(TAG, "'%s' - Setting", name);
+    if (!this->option_.has_value()) {
+      ESP_LOGW(TAG, "'%s' - No option value set for SelectCall", name);
+      return;
+    }
+    target_value = this->option_.value();
+  } else if (this->operation_ == SELECT_OP_SET_INDEX) {
+    if (!this->index_.has_value()) {
+      ESP_LOGW(TAG, "'%s' - No index value set for SelectCall", name);
+      return;
+    }
+    if (this->index_.value() >= options.size()) {
+      ESP_LOGW(TAG, "'%s' - Index value %d out of bounds", name, this->index_.value());
+      return;
+    }
+    target_value = options[this->index_.value()];
+  } else if (this->operation_ == SELECT_OP_FIRST) {
+    target_value = options.front();
+  } else if (this->operation_ == SELECT_OP_LAST) {
+    target_value = options.back();
+  } else if (this->operation_ == SELECT_OP_NEXT || this->operation_ == SELECT_OP_PREVIOUS) {
+    auto cycle = this->cycle_;
+    ESP_LOGD(TAG, "'%s' - Selecting %s, with%s cycling", name, this->operation_ == SELECT_OP_NEXT ? "next" : "previous",
+             cycle ? "" : "out");
+    if (!parent->has_state()) {
+      target_value = this->operation_ == SELECT_OP_NEXT ? options.front() : options.back();
+    } else {
+      auto index = parent->index_of(parent->state);
+      if (index.has_value()) {
+        auto size = options.size();
+        if (cycle) {
+          auto use_index = (size + index.value() + (this->operation_ == SELECT_OP_NEXT ? +1 : -1)) % size;
+          target_value = options[use_index];
+        } else {
+          if (this->operation_ == SELECT_OP_PREVIOUS && index.value() > 0) {
+            target_value = options[index.value() - 1];
+          } else if (this->operation_ == SELECT_OP_NEXT && index.value() < options.size() - 1) {
+            target_value = options[index.value() + 1];
+          } else {
+            return;
+          }
+        }
+      } else {
+        target_value = this->operation_ == SELECT_OP_NEXT ? options.front() : options.back();
+      }
+    }
+  }
+
+  if (std::find(options.begin(), options.end(), target_value) == options.end()) {
+    ESP_LOGW(TAG, "'%s' - Option %s is not a valid option", name, target_value.c_str());
+    return;
+  }
+
+  ESP_LOGD(TAG, "'%s' - Set selected option to: %s", name, target_value.c_str());
+  parent->control(target_value);
+}
+
+}  // namespace select
+}  // namespace esphome

esphome/components/select/select_call.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace select {
+
+class Select;
+
+enum SelectOperation {
+  SELECT_OP_NONE,
+  SELECT_OP_SET,
+  SELECT_OP_SET_INDEX,
+  SELECT_OP_NEXT,
+  SELECT_OP_PREVIOUS,
+  SELECT_OP_FIRST,
+  SELECT_OP_LAST
+};
+
+class SelectCall {
+ public:
+  explicit SelectCall(Select *parent) : parent_(parent) {}
+  void perform();
+
+  SelectCall &set_option(const std::string &option);
+  SelectCall &set_index(size_t index);
+
+  SelectCall &select_next(bool cycle);
+  SelectCall &select_previous(bool cycle);
+  SelectCall &select_first();
+  SelectCall &select_last();
+
+  SelectCall &with_operation(SelectOperation operation);
+  SelectCall &with_cycle(bool cycle);
+  SelectCall &with_option(const std::string &option);
+  SelectCall &with_index(size_t index);
+
+ protected:
+  Select *const parent_;
+  optional<std::string> option_;
+  optional<size_t> index_;
+  SelectOperation operation_{SELECT_OP_NONE};
+  bool cycle_;
+};
+
+}  // namespace select
+}  // namespace esphome

esphome/components/select/select_traits.cpp

@@ -0,0 +1,11 @@
+#include "select_traits.h"
+
+namespace esphome {
+namespace select {
+
+void SelectTraits::set_options(std::vector<std::string> options) { this->options_ = std::move(options); }
+
+std::vector<std::string> SelectTraits::get_options() const { return this->options_; }
+
+}  // namespace select
+}  // namespace esphome

esphome/components/select/select_traits.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <vector>
+#include <string>
+
+namespace esphome {
+namespace select {
+
+class SelectTraits {
+ public:
+  void set_options(std::vector<std::string> options);
+  std::vector<std::string> get_options() const;
+
+ protected:
+  std::vector<std::string> options_;
+};
+
+}  // namespace select
+}  // namespace esphome

esphome/components/sen5x/automation.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/automation.h"
+#include "sen5x.h"
+
+namespace esphome {
+namespace sen5x {
+
+template<typename... Ts> class StartFanAction : public Action<Ts...> {
+ public:
+  explicit StartFanAction(SEN5XComponent *sen5x) : sen5x_(sen5x) {}
+
+  void play(Ts... x) override { this->sen5x_->start_fan_cleaning(); }
+
+ protected:
+  SEN5XComponent *sen5x_;
+};
+
+}  // namespace sen5x
+}  // namespace esphome

esphome/components/sen5x/sen5x.cpp

@@ -0,0 +1,413 @@
+#include "sen5x.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace sen5x {
+
+static const char *const TAG = "sen5x";
+
+static const uint16_t SEN5X_CMD_AUTO_CLEANING_INTERVAL = 0x8004;
+static const uint16_t SEN5X_CMD_GET_DATA_READY_STATUS = 0x0202;
+static const uint16_t SEN5X_CMD_GET_FIRMWARE_VERSION = 0xD100;
+static const uint16_t SEN5X_CMD_GET_PRODUCT_NAME = 0xD014;
+static const uint16_t SEN5X_CMD_GET_SERIAL_NUMBER = 0xD033;
+static const uint16_t SEN5X_CMD_NOX_ALGORITHM_TUNING = 0x60E1;
+static const uint16_t SEN5X_CMD_READ_MEASUREMENT = 0x03C4;
+static const uint16_t SEN5X_CMD_RHT_ACCELERATION_MODE = 0x60F7;
+static const uint16_t SEN5X_CMD_START_CLEANING_FAN = 0x5607;
+static const uint16_t SEN5X_CMD_START_MEASUREMENTS = 0x0021;
+static const uint16_t SEN5X_CMD_START_MEASUREMENTS_RHT_ONLY = 0x0037;
+static const uint16_t SEN5X_CMD_STOP_MEASUREMENTS = 0x3f86;
+static const uint16_t SEN5X_CMD_TEMPERATURE_COMPENSATION = 0x60B2;
+static const uint16_t SEN5X_CMD_VOC_ALGORITHM_STATE = 0x6181;
+static const uint16_t SEN5X_CMD_VOC_ALGORITHM_TUNING = 0x60D0;
+
+void SEN5XComponent::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up sen5x...");
+
+  // the sensor needs 1000 ms to enter the idle state
+  this->set_timeout(1000, [this]() {
+    // Check if measurement is ready before reading the value
+    if (!this->write_command(SEN5X_CMD_GET_DATA_READY_STATUS)) {
+      ESP_LOGE(TAG, "Failed to write data ready status command");
+      this->mark_failed();
+      return;
+    }
+
+    uint16_t raw_read_status;
+    if (!this->read_data(raw_read_status)) {
+      ESP_LOGE(TAG, "Failed to read data ready status");
+      this->mark_failed();
+      return;
+    }
+
+    uint32_t stop_measurement_delay = 0;
+    // In order to query the device periodic measurement must be ceased
+    if (raw_read_status) {
+      ESP_LOGD(TAG, "Sensor has data available, stopping periodic measurement");
+      if (!this->write_command(SEN5X_CMD_STOP_MEASUREMENTS)) {
+        ESP_LOGE(TAG, "Failed to stop measurements");
+        this->mark_failed();
+        return;
+      }
+      // According to the SEN5x datasheet the sensor will only respond to other commands after waiting 200 ms after
+      // issuing the stop_periodic_measurement command
+      stop_measurement_delay = 200;
+    }
+    this->set_timeout(stop_measurement_delay, [this]() {
+      uint16_t raw_serial_number[3];
+      if (!this->get_register(SEN5X_CMD_GET_SERIAL_NUMBER, raw_serial_number, 3, 20)) {
+        ESP_LOGE(TAG, "Failed to read serial number");
+        this->error_code_ = SERIAL_NUMBER_IDENTIFICATION_FAILED;
+        this->mark_failed();
+        return;
+      }
+      this->serial_number_[0] = static_cast<bool>(uint16_t(raw_serial_number[0]) & 0xFF);
+      this->serial_number_[1] = static_cast<uint16_t>(raw_serial_number[0] & 0xFF);
+      this->serial_number_[2] = static_cast<uint16_t>(raw_serial_number[1] >> 8);
+      ESP_LOGD(TAG, "Serial number %02d.%02d.%02d", serial_number_[0], serial_number_[1], serial_number_[2]);
+
+      uint16_t raw_product_name[16];
+      if (!this->get_register(SEN5X_CMD_GET_PRODUCT_NAME, raw_product_name, 16, 20)) {
+        ESP_LOGE(TAG, "Failed to read product name");
+        this->error_code_ = PRODUCT_NAME_FAILED;
+        this->mark_failed();
+        return;
+      }
+      // 2 ASCII bytes are encoded in an int
+      const uint16_t *current_int = raw_product_name;
+      char current_char;
+      uint8_t max = 16;
+      do {
+        // first char
+        current_char = *current_int >> 8;
+        if (current_char) {
+          product_name_.push_back(current_char);
+          // second char
+          current_char = *current_int & 0xFF;
+          if (current_char)
+            product_name_.push_back(current_char);
+        }
+        current_int++;
+      } while (current_char && --max);
+
+      Sen5xType sen5x_type = UNKNOWN;
+      if (product_name_ == "SEN50") {
+        sen5x_type = SEN50;
+      } else {
+        if (product_name_ == "SEN54") {
+          sen5x_type = SEN54;
+        } else {
+          if (product_name_ == "SEN55") {
+            sen5x_type = SEN55;
+          }
+        }
+        ESP_LOGD(TAG, "Productname %s", product_name_.c_str());
+      }
+      if (this->humidity_sensor_ && sen5x_type == SEN50) {
+        ESP_LOGE(TAG, "For Relative humidity a SEN54 OR SEN55 is required. You are using a <%s> sensor",
+                 this->product_name_.c_str());
+        this->humidity_sensor_ = nullptr;  // mark as not used
+      }
+      if (this->temperature_sensor_ && sen5x_type == SEN50) {
+        ESP_LOGE(TAG, "For Temperature a SEN54 OR SEN55 is required. You are using a <%s> sensor",
+                 this->product_name_.c_str());
+        this->temperature_sensor_ = nullptr;  // mark as not used
+      }
+      if (this->voc_sensor_ && sen5x_type == SEN50) {
+        ESP_LOGE(TAG, "For VOC a SEN54 OR SEN55 is required. You are using a <%s> sensor", this->product_name_.c_str());
+        this->voc_sensor_ = nullptr;  // mark as not used
+      }
+      if (this->nox_sensor_ && sen5x_type != SEN55) {
+        ESP_LOGE(TAG, "For NOx a SEN55 is required. You are using a <%s> sensor", this->product_name_.c_str());
+        this->nox_sensor_ = nullptr;  // mark as not used
+      }
+
+      if (!this->get_register(SEN5X_CMD_GET_FIRMWARE_VERSION, this->firmware_version_, 20)) {
+        ESP_LOGE(TAG, "Failed to read firmware version");
+        this->error_code_ = FIRMWARE_FAILED;
+        this->mark_failed();
+        return;
+      }
+      this->firmware_version_ >>= 8;
+      ESP_LOGD(TAG, "Firmware version %d", this->firmware_version_);
+
+      if (this->voc_sensor_ && this->store_baseline_) {
+        // Hash with compilation time
+        // This ensures the baseline storage is cleared after OTA
+        uint32_t hash = fnv1_hash(App.get_compilation_time());
+        this->pref_ = global_preferences->make_preference<Sen5xBaselines>(hash, true);
+
+        if (this->pref_.load(&this->voc_baselines_storage_)) {
+          ESP_LOGI(TAG, "Loaded VOC baseline state0: 0x%04X, state1: 0x%04X", this->voc_baselines_storage_.state0,
+                   voc_baselines_storage_.state1);
+        }
+
+        // Initialize storage timestamp
+        this->seconds_since_last_store_ = 0;
+
+        if (this->voc_baselines_storage_.state0 > 0 && this->voc_baselines_storage_.state1 > 0) {
+          ESP_LOGI(TAG, "Setting VOC baseline from save state0: 0x%04X, state1: 0x%04X",
+                   this->voc_baselines_storage_.state0, voc_baselines_storage_.state1);
+          uint16_t states[4];
+
+          states[0] = voc_baselines_storage_.state0 >> 16;
+          states[1] = voc_baselines_storage_.state0 & 0xFFFF;
+          states[2] = voc_baselines_storage_.state1 >> 16;
+          states[3] = voc_baselines_storage_.state1 & 0xFFFF;
+
+          if (!this->write_command(SEN5X_CMD_VOC_ALGORITHM_STATE, states, 4)) {
+            ESP_LOGE(TAG, "Failed to set VOC baseline from saved state");
+          }
+        }
+      }
+      bool result;
+      if (this->auto_cleaning_interval_.has_value()) {
+        // override default value
+        result = write_command(SEN5X_CMD_AUTO_CLEANING_INTERVAL, this->auto_cleaning_interval_.value());
+      } else {
+        result = write_command(SEN5X_CMD_AUTO_CLEANING_INTERVAL);
+      }
+      if (result) {
+        delay(20);
+        uint16_t secs[2];
+        if (this->read_data(secs, 2)) {
+          auto_cleaning_interval_ = secs[0] << 16 | secs[1];
+        }
+      }
+      if (acceleration_mode_.has_value()) {
+        result = this->write_command(SEN5X_CMD_RHT_ACCELERATION_MODE, acceleration_mode_.value());
+      } else {
+        result = this->write_command(SEN5X_CMD_RHT_ACCELERATION_MODE);
+      }
+      if (!result) {
+        ESP_LOGE(TAG, "Failed to set rh/t acceleration mode");
+        this->error_code_ = COMMUNICATION_FAILED;
+        this->mark_failed();
+        return;
+      }
+      delay(20);
+      if (!acceleration_mode_.has_value()) {
+        uint16_t mode;
+        if (this->read_data(mode)) {
+          this->acceleration_mode_ = RhtAccelerationMode(mode);
+        } else {
+          ESP_LOGE(TAG, "Failed to read RHT Acceleration mode");
+        }
+      }
+      if (this->voc_tuning_params_.has_value())
+        this->write_tuning_parameters_(SEN5X_CMD_VOC_ALGORITHM_TUNING, this->voc_tuning_params_.value());
+      if (this->nox_tuning_params_.has_value())
+        this->write_tuning_parameters_(SEN5X_CMD_NOX_ALGORITHM_TUNING, this->nox_tuning_params_.value());
+
+      if (this->temperature_compensation_.has_value())
+        this->write_temperature_compensation_(this->temperature_compensation_.value());
+
+      // Finally start sensor measurements
+      auto cmd = SEN5X_CMD_START_MEASUREMENTS_RHT_ONLY;
+      if (this->pm_1_0_sensor_ || this->pm_2_5_sensor_ || this->pm_4_0_sensor_ || this->pm_10_0_sensor_) {
+        // if any of the gas sensors are active we need a full measurement
+        cmd = SEN5X_CMD_START_MEASUREMENTS;
+      }
+
+      if (!this->write_command(cmd)) {
+        ESP_LOGE(TAG, "Error starting continuous measurements.");
+        this->error_code_ = MEASUREMENT_INIT_FAILED;
+        this->mark_failed();
+        return;
+      }
+      initialized_ = true;
+      ESP_LOGD(TAG, "Sensor initialized");
+    });
+  });
+}
+
+void SEN5XComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "sen5x:");
+  LOG_I2C_DEVICE(this);
+  if (this->is_failed()) {
+    switch (this->error_code_) {
+      case COMMUNICATION_FAILED:
+        ESP_LOGW(TAG, "Communication failed! Is the sensor connected?");
+        break;
+      case MEASUREMENT_INIT_FAILED:
+        ESP_LOGW(TAG, "Measurement Initialization failed!");
+        break;
+      case SERIAL_NUMBER_IDENTIFICATION_FAILED:
+        ESP_LOGW(TAG, "Unable to read sensor serial id");
+        break;
+      case PRODUCT_NAME_FAILED:
+        ESP_LOGW(TAG, "Unable to read product name");
+        break;
+      case FIRMWARE_FAILED:
+        ESP_LOGW(TAG, "Unable to read sensor firmware version");
+        break;
+      default:
+        ESP_LOGW(TAG, "Unknown setup error!");
+        break;
+    }
+  }
+  ESP_LOGCONFIG(TAG, "  Productname: %s", this->product_name_.c_str());
+  ESP_LOGCONFIG(TAG, "  Firmware version: %d", this->firmware_version_);
+  ESP_LOGCONFIG(TAG, "  Serial number %02d.%02d.%02d", serial_number_[0], serial_number_[1], serial_number_[2]);
+  if (this->auto_cleaning_interval_.has_value()) {
+    ESP_LOGCONFIG(TAG, "  Auto auto cleaning interval %d seconds", auto_cleaning_interval_.value());
+  }
+  if (this->acceleration_mode_.has_value()) {
+    switch (this->acceleration_mode_.value()) {
+      case LOW_ACCELERATION:
+        ESP_LOGCONFIG(TAG, "  Low RH/T acceleration mode");
+        break;
+      case MEDIUM_ACCELERATION:
+        ESP_LOGCONFIG(TAG, "  Medium RH/T accelertion mode");
+        break;
+      case HIGH_ACCELERATION:
+        ESP_LOGCONFIG(TAG, "  High RH/T accelertion mode");
+        break;
+    }
+  }
+  LOG_UPDATE_INTERVAL(this);
+  LOG_SENSOR("  ", "PM  1.0", this->pm_1_0_sensor_);
+  LOG_SENSOR("  ", "PM  2.5", this->pm_2_5_sensor_);
+  LOG_SENSOR("  ", "PM  4.0", this->pm_4_0_sensor_);
+  LOG_SENSOR("  ", "PM 10.0", this->pm_10_0_sensor_);
+  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+  LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
+  LOG_SENSOR("  ", "VOC", this->voc_sensor_);  // SEN54 and SEN55 only
+  LOG_SENSOR("  ", "NOx", this->nox_sensor_);  // SEN55 only
+}
+
+void SEN5XComponent::update() {
+  if (!initialized_) {
+    return;
+  }
+
+  // Store baselines after defined interval or if the difference between current and stored baseline becomes too
+  // much
+  if (this->store_baseline_ && this->seconds_since_last_store_ > SHORTEST_BASELINE_STORE_INTERVAL) {
+    if (this->write_command(SEN5X_CMD_VOC_ALGORITHM_STATE)) {
+      // run it a bit later to avoid adding a delay here
+      this->set_timeout(550, [this]() {
+        uint16_t states[4];
+        if (this->read_data(states, 4)) {
+          uint32_t state0 = states[0] << 16 | states[1];
+          uint32_t state1 = states[2] << 16 | states[3];
+          if ((uint32_t) std::abs(static_cast<int32_t>(this->voc_baselines_storage_.state0 - state0)) >
+                  MAXIMUM_STORAGE_DIFF ||
+              (uint32_t) std::abs(static_cast<int32_t>(this->voc_baselines_storage_.state1 - state1)) >
+                  MAXIMUM_STORAGE_DIFF) {
+            this->seconds_since_last_store_ = 0;
+            this->voc_baselines_storage_.state0 = state0;
+            this->voc_baselines_storage_.state1 = state1;
+
+            if (this->pref_.save(&this->voc_baselines_storage_)) {
+              ESP_LOGI(TAG, "Stored VOC baseline state0: 0x%04X ,state1: 0x%04X", this->voc_baselines_storage_.state0,
+                       voc_baselines_storage_.state1);
+            } else {
+              ESP_LOGW(TAG, "Could not store VOC baselines");
+            }
+          }
+        }
+      });
+    }
+  }
+
+  if (!this->write_command(SEN5X_CMD_READ_MEASUREMENT)) {
+    this->status_set_warning();
+    ESP_LOGD(TAG, "write error read measurement (%d)", this->last_error_);
+    return;
+  }
+  this->set_timeout(20, [this]() {
+    uint16_t measurements[8];
+
+    if (!this->read_data(measurements, 8)) {
+      this->status_set_warning();
+      ESP_LOGD(TAG, "read data error (%d)", this->last_error_);
+      return;
+    }
+    float pm_1_0 = measurements[0] / 10.0;
+    if (measurements[0] == 0xFFFF)
+      pm_1_0 = NAN;
+    float pm_2_5 = measurements[1] / 10.0;
+    if (measurements[1] == 0xFFFF)
+      pm_2_5 = NAN;
+    float pm_4_0 = measurements[2] / 10.0;
+    if (measurements[2] == 0xFFFF)
+      pm_4_0 = NAN;
+    float pm_10_0 = measurements[3] / 10.0;
+    if (measurements[3] == 0xFFFF)
+      pm_10_0 = NAN;
+    float humidity = measurements[4] / 100.0;
+    if (measurements[4] == 0xFFFF)
+      humidity = NAN;
+    float temperature = measurements[5] / 200.0;
+    if (measurements[5] == 0xFFFF)
+      temperature = NAN;
+    float voc = measurements[6] / 10.0;
+    if (measurements[6] == 0xFFFF)
+      voc = NAN;
+    float nox = measurements[7] / 10.0;
+    if (measurements[7] == 0xFFFF)
+      nox = NAN;
+
+    if (this->pm_1_0_sensor_ != nullptr)
+      this->pm_1_0_sensor_->publish_state(pm_1_0);
+    if (this->pm_2_5_sensor_ != nullptr)
+      this->pm_2_5_sensor_->publish_state(pm_2_5);
+    if (this->pm_4_0_sensor_ != nullptr)
+      this->pm_4_0_sensor_->publish_state(pm_4_0);
+    if (this->pm_10_0_sensor_ != nullptr)
+      this->pm_10_0_sensor_->publish_state(pm_10_0);
+    if (this->temperature_sensor_ != nullptr)
+      this->temperature_sensor_->publish_state(temperature);
+    if (this->humidity_sensor_ != nullptr)
+      this->humidity_sensor_->publish_state(humidity);
+    if (this->voc_sensor_ != nullptr)
+      this->voc_sensor_->publish_state(voc);
+    if (this->nox_sensor_ != nullptr)
+      this->nox_sensor_->publish_state(nox);
+    this->status_clear_warning();
+  });
+}
+
+bool SEN5XComponent::write_tuning_parameters_(uint16_t i2c_command, const GasTuning &tuning) {
+  uint16_t params[6];
+  params[0] = tuning.index_offset;
+  params[1] = tuning.learning_time_offset_hours;
+  params[2] = tuning.learning_time_gain_hours;
+  params[3] = tuning.gating_max_duration_minutes;
+  params[4] = tuning.std_initial;
+  params[5] = tuning.gain_factor;
+  auto result = write_command(i2c_command, params, 6);
+  if (!result) {
+    ESP_LOGE(TAG, "set tuning parameters failed. i2c command=%0xX, err=%d", i2c_command, this->last_error_);
+  }
+  return result;
+}
+
+bool SEN5XComponent::write_temperature_compensation_(const TemperatureCompensation &compensation) {
+  uint16_t params[3];
+  params[0] = compensation.offset;
+  params[1] = compensation.normalized_offset_slope;
+  params[2] = compensation.time_constant;
+  if (!write_command(SEN5X_CMD_TEMPERATURE_COMPENSATION, params, 3)) {
+    ESP_LOGE(TAG, "set temperature_compensation failed. Err=%d", this->last_error_);
+    return false;
+  }
+  return true;
+}
+
+bool SEN5XComponent::start_fan_cleaning() {
+  if (!write_command(SEN5X_CMD_START_CLEANING_FAN)) {
+    this->status_set_warning();
+    ESP_LOGE(TAG, "write error start fan (%d)", this->last_error_);
+    return false;
+  } else {
+    ESP_LOGD(TAG, "Fan auto clean started");
+  }
+  return true;
+}
+
+}  // namespace sen5x
+}  // namespace esphome

esphome/components/sen5x/sen5x.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/sensirion_common/i2c_sensirion.h"
+#include "esphome/core/application.h"
+#include "esphome/core/preferences.h"
+
+namespace esphome {
+namespace sen5x {
+
+enum ERRORCODE {
+  COMMUNICATION_FAILED,
+  SERIAL_NUMBER_IDENTIFICATION_FAILED,
+  MEASUREMENT_INIT_FAILED,
+  PRODUCT_NAME_FAILED,
+  FIRMWARE_FAILED,
+  UNKNOWN
+};
+
+// Shortest time interval of 3H for storing baseline values.
+// Prevents wear of the flash because of too many write operations
+const uint32_t SHORTEST_BASELINE_STORE_INTERVAL = 10800;
+// Store anyway if the baseline difference exceeds the max storage diff value
+const uint32_t MAXIMUM_STORAGE_DIFF = 50;
+
+struct Sen5xBaselines {
+  int32_t state0;
+  int32_t state1;
+} PACKED;  // NOLINT
+
+enum RhtAccelerationMode : uint16_t { LOW_ACCELERATION = 0, MEDIUM_ACCELERATION = 1, HIGH_ACCELERATION = 2 };
+
+struct GasTuning {
+  uint16_t index_offset;
+  uint16_t learning_time_offset_hours;
+  uint16_t learning_time_gain_hours;
+  uint16_t gating_max_duration_minutes;
+  uint16_t std_initial;
+  uint16_t gain_factor;
+};
+
+struct TemperatureCompensation {
+  uint16_t offset;
+  uint16_t normalized_offset_slope;
+  uint16_t time_constant;
+};
+
+class SEN5XComponent : public PollingComponent, public sensirion_common::SensirionI2CDevice {
+ public:
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void setup() override;
+  void dump_config() override;
+  void update() override;
+
+  enum Sen5xType { SEN50, SEN54, SEN55, UNKNOWN };
+
+  void set_pm_1_0_sensor(sensor::Sensor *pm_1_0) { pm_1_0_sensor_ = pm_1_0; }
+  void set_pm_2_5_sensor(sensor::Sensor *pm_2_5) { pm_2_5_sensor_ = pm_2_5; }
+  void set_pm_4_0_sensor(sensor::Sensor *pm_4_0) { pm_4_0_sensor_ = pm_4_0; }
+  void set_pm_10_0_sensor(sensor::Sensor *pm_10_0) { pm_10_0_sensor_ = pm_10_0; }
+
+  void set_voc_sensor(sensor::Sensor *voc_sensor) { voc_sensor_ = voc_sensor; }
+  void set_nox_sensor(sensor::Sensor *nox_sensor) { nox_sensor_ = nox_sensor; }
+  void set_humidity_sensor(sensor::Sensor *humidity_sensor) { humidity_sensor_ = humidity_sensor; }
+  void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
+  void set_store_baseline(bool store_baseline) { store_baseline_ = store_baseline; }
+  void set_acceleration_mode(RhtAccelerationMode mode) { acceleration_mode_ = mode; }
+  void set_auto_cleaning_interval(uint32_t auto_cleaning_interval) { auto_cleaning_interval_ = auto_cleaning_interval; }
+  void set_voc_algorithm_tuning(uint16_t index_offset, uint16_t learning_time_offset_hours,
+                                uint16_t learning_time_gain_hours, uint16_t gating_max_duration_minutes,
+                                uint16_t std_initial, uint16_t gain_factor) {
+    voc_tuning_params_.value().index_offset = index_offset;
+    voc_tuning_params_.value().learning_time_offset_hours = learning_time_offset_hours;
+    voc_tuning_params_.value().learning_time_gain_hours = learning_time_gain_hours;
+    voc_tuning_params_.value().gating_max_duration_minutes = gating_max_duration_minutes;
+    voc_tuning_params_.value().std_initial = std_initial;
+    voc_tuning_params_.value().gain_factor = gain_factor;
+  }
+  void set_nox_algorithm_tuning(uint16_t index_offset, uint16_t learning_time_offset_hours,
+                                uint16_t learning_time_gain_hours, uint16_t gating_max_duration_minutes,
+                                uint16_t gain_factor) {
+    nox_tuning_params_.value().index_offset = index_offset;
+    nox_tuning_params_.value().learning_time_offset_hours = learning_time_offset_hours;
+    nox_tuning_params_.value().learning_time_gain_hours = learning_time_gain_hours;
+    nox_tuning_params_.value().gating_max_duration_minutes = gating_max_duration_minutes;
+    nox_tuning_params_.value().std_initial = 50;
+    nox_tuning_params_.value().gain_factor = gain_factor;
+  }
+  void set_temperature_compensation(float offset, float normalized_offset_slope, uint16_t time_constant) {
+    temperature_compensation_.value().offset = offset * 200;
+    temperature_compensation_.value().normalized_offset_slope = normalized_offset_slope * 100;
+    temperature_compensation_.value().time_constant = time_constant;
+  }
+  bool start_fan_cleaning();
+
+ protected:
+  bool write_tuning_parameters_(uint16_t i2c_command, const GasTuning &tuning);
+  bool write_temperature_compensation_(const TemperatureCompensation &compensation);
+  ERRORCODE error_code_;
+  bool initialized_{false};
+  sensor::Sensor *pm_1_0_sensor_{nullptr};
+  sensor::Sensor *pm_2_5_sensor_{nullptr};
+  sensor::Sensor *pm_4_0_sensor_{nullptr};
+  sensor::Sensor *pm_10_0_sensor_{nullptr};
+  // SEN54 and SEN55 only
+  sensor::Sensor *temperature_sensor_{nullptr};
+  sensor::Sensor *humidity_sensor_{nullptr};
+  sensor::Sensor *voc_sensor_{nullptr};
+  // SEN55 only
+  sensor::Sensor *nox_sensor_{nullptr};
+
+  std::string product_name_;
+  uint8_t serial_number_[4];
+  uint16_t firmware_version_;
+  Sen5xBaselines voc_baselines_storage_;
+  bool store_baseline_;
+  uint32_t seconds_since_last_store_;
+  ESPPreferenceObject pref_;
+  optional<RhtAccelerationMode> acceleration_mode_;
+  optional<uint32_t> auto_cleaning_interval_;
+  optional<GasTuning> voc_tuning_params_;
+  optional<GasTuning> nox_tuning_params_;
+  optional<TemperatureCompensation> temperature_compensation_;
+};
+
+}  // namespace sen5x
+}  // namespace esphome

esphome/components/sen5x/sensor.py

@@ -0,0 +1,241 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c, sensor, sensirion_common
+from esphome import automation
+from esphome.automation import maybe_simple_id
+
+from esphome.const import (
+    CONF_HUMIDITY,
+    CONF_ID,
+    CONF_OFFSET,
+    CONF_PM_1_0,
+    CONF_PM_10_0,
+    CONF_PM_2_5,
+    CONF_PM_4_0,
+    CONF_STORE_BASELINE,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_NITROUS_OXIDE,
+    DEVICE_CLASS_PM1,
+    DEVICE_CLASS_PM10,
+    DEVICE_CLASS_PM25,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS,
+    ICON_CHEMICAL_WEAPON,
+    ICON_RADIATOR,
+    ICON_THERMOMETER,
+    ICON_WATER_PERCENT,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_MICROGRAMS_PER_CUBIC_METER,
+    UNIT_PERCENT,
+)
+
+CODEOWNERS = ["@martgras"]
+DEPENDENCIES = ["i2c"]
+AUTO_LOAD = ["sensirion_common"]
+
+sen5x_ns = cg.esphome_ns.namespace("sen5x")
+SEN5XComponent = sen5x_ns.class_(
+    "SEN5XComponent", cg.PollingComponent, sensirion_common.SensirionI2CDevice
+)
+RhtAccelerationMode = sen5x_ns.enum("RhtAccelerationMode")
+
+CONF_ACCELERATION_MODE = "acceleration_mode"
+CONF_ALGORITHM_TUNING = "algorithm_tuning"
+CONF_AUTO_CLEANING_INTERVAL = "auto_cleaning_interval"
+CONF_GAIN_FACTOR = "gain_factor"
+CONF_GATING_MAX_DURATION_MINUTES = "gating_max_duration_minutes"
+CONF_INDEX_OFFSET = "index_offset"
+CONF_LEARNING_TIME_GAIN_HOURS = "learning_time_gain_hours"
+CONF_LEARNING_TIME_OFFSET_HOURS = "learning_time_offset_hours"
+CONF_NORMALIZED_OFFSET_SLOPE = "normalized_offset_slope"
+CONF_NOX = "nox"
+CONF_STD_INITIAL = "std_initial"
+CONF_TEMPERATURE_COMPENSATION = "temperature_compensation"
+CONF_TIME_CONSTANT = "time_constant"
+CONF_VOC = "voc"
+CONF_VOC_BASELINE = "voc_baseline"
+
+
+# Actions
+StartFanAction = sen5x_ns.class_("StartFanAction", automation.Action)
+
+ACCELERATION_MODES = {
+    "low": RhtAccelerationMode.LOW_ACCELERATION,
+    "medium": RhtAccelerationMode.MEDIUM_ACCELERATION,
+    "high": RhtAccelerationMode.HIGH_ACCELERATION,
+}
+
+GAS_SENSOR = cv.Schema(
+    {
+        cv.Optional(CONF_ALGORITHM_TUNING): cv.Schema(
+            {
+                cv.Optional(CONF_INDEX_OFFSET, default=100): cv.int_range(1, 250),
+                cv.Optional(CONF_LEARNING_TIME_OFFSET_HOURS, default=12): cv.int_range(
+                    1, 1000
+                ),
+                cv.Optional(CONF_LEARNING_TIME_GAIN_HOURS, default=12): cv.int_range(
+                    1, 1000
+                ),
+                cv.Optional(
+                    CONF_GATING_MAX_DURATION_MINUTES, default=720
+                ): cv.int_range(0, 3000),
+                cv.Optional(CONF_STD_INITIAL, default=50): cv.int_,
+                cv.Optional(CONF_GAIN_FACTOR, default=230): cv.int_range(1, 1000),
+            }
+        )
+    }
+)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(SEN5XComponent),
+            cv.Optional(CONF_PM_1_0): sensor.sensor_schema(
+                unit_of_measurement=UNIT_MICROGRAMS_PER_CUBIC_METER,
+                icon=ICON_CHEMICAL_WEAPON,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_PM1,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_PM_2_5): sensor.sensor_schema(
+                unit_of_measurement=UNIT_MICROGRAMS_PER_CUBIC_METER,
+                icon=ICON_CHEMICAL_WEAPON,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_PM25,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_PM_4_0): sensor.sensor_schema(
+                unit_of_measurement=UNIT_MICROGRAMS_PER_CUBIC_METER,
+                icon=ICON_CHEMICAL_WEAPON,
+                accuracy_decimals=2,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_PM_10_0): sensor.sensor_schema(
+                unit_of_measurement=UNIT_MICROGRAMS_PER_CUBIC_METER,
+                icon=ICON_CHEMICAL_WEAPON,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_PM10,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_AUTO_CLEANING_INTERVAL): cv.time_period_in_seconds_,
+            cv.Optional(CONF_VOC): sensor.sensor_schema(
+                icon=ICON_RADIATOR,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ).extend(GAS_SENSOR),
+            cv.Optional(CONF_NOX): sensor.sensor_schema(
+                icon=ICON_RADIATOR,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_NITROUS_OXIDE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ).extend(GAS_SENSOR),
+            cv.Optional(CONF_STORE_BASELINE, default=True): cv.boolean,
+            cv.Optional(CONF_VOC_BASELINE): cv.hex_uint16_t,
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                icon=ICON_THERMOMETER,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                icon=ICON_WATER_PERCENT,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_HUMIDITY,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_TEMPERATURE_COMPENSATION): cv.Schema(
+                {
+                    cv.Optional(CONF_OFFSET, default=0): cv.float_,
+                    cv.Optional(CONF_NORMALIZED_OFFSET_SLOPE, default=0): cv.percentage,
+                    cv.Optional(CONF_TIME_CONSTANT, default=0): cv.int_,
+                }
+            ),
+            cv.Optional(CONF_ACCELERATION_MODE): cv.enum(ACCELERATION_MODES),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x69))
+)
+
+SENSOR_MAP = {
+    CONF_PM_1_0: "set_pm_1_0_sensor",
+    CONF_PM_2_5: "set_pm_2_5_sensor",
+    CONF_PM_4_0: "set_pm_4_0_sensor",
+    CONF_PM_10_0: "set_pm_10_0_sensor",
+    CONF_VOC: "set_voc_sensor",
+    CONF_NOX: "set_nox_sensor",
+    CONF_TEMPERATURE: "set_temperature_sensor",
+    CONF_HUMIDITY: "set_humidity_sensor",
+}
+
+SETTING_MAP = {
+    CONF_AUTO_CLEANING_INTERVAL: "set_auto_cleaning_interval",
+    CONF_ACCELERATION_MODE: "set_acceleration_mode",
+}
+
+
+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)
+
+    for key, funcName in SETTING_MAP.items():
+        if key in config:
+            cg.add(getattr(var, funcName)(config[key]))
+
+    for key, funcName in SENSOR_MAP.items():
+        if key in config:
+            sens = await sensor.new_sensor(config[key])
+            cg.add(getattr(var, funcName)(sens))
+
+    if CONF_VOC in config and CONF_ALGORITHM_TUNING in config[CONF_VOC]:
+        cfg = config[CONF_VOC][CONF_ALGORITHM_TUNING]
+        cg.add(
+            var.set_voc_algorithm_tuning(
+                cfg[CONF_INDEX_OFFSET],
+                cfg[CONF_LEARNING_TIME_OFFSET_HOURS],
+                cfg[CONF_LEARNING_TIME_GAIN_HOURS],
+                cfg[CONF_GATING_MAX_DURATION_MINUTES],
+                cfg[CONF_STD_INITIAL],
+                cfg[CONF_GAIN_FACTOR],
+            )
+        )
+    if CONF_NOX in config and CONF_ALGORITHM_TUNING in config[CONF_NOX]:
+        cfg = config[CONF_NOX][CONF_ALGORITHM_TUNING]
+        cg.add(
+            var.set_nox_algorithm_tuning(
+                cfg[CONF_INDEX_OFFSET],
+                cfg[CONF_LEARNING_TIME_OFFSET_HOURS],
+                cfg[CONF_LEARNING_TIME_GAIN_HOURS],
+                cfg[CONF_GATING_MAX_DURATION_MINUTES],
+                cfg[CONF_GAIN_FACTOR],
+            )
+        )
+    if CONF_TEMPERATURE_COMPENSATION in config:
+        cg.add(
+            var.set_temperature_compensation(
+                config[CONF_TEMPERATURE_COMPENSATION][CONF_OFFSET],
+                config[CONF_TEMPERATURE_COMPENSATION][CONF_NORMALIZED_OFFSET_SLOPE],
+                config[CONF_TEMPERATURE_COMPENSATION][CONF_TIME_CONSTANT],
+            )
+        )
+
+
+SEN5X_ACTION_SCHEMA = maybe_simple_id(
+    {
+        cv.Required(CONF_ID): cv.use_id(SEN5XComponent),
+    }
+)
+
+
+@automation.register_action(
+    "sen5x.start_fan_autoclean", StartFanAction, SEN5X_ACTION_SCHEMA
+)
+async def sen54_fan_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)

esphome/components/sensirion_common/i2c_sensirion.cpp

@@ -33,7 +33,7 @@ bool SensirionI2CDevice::read_data(uint16_t *data, uint8_t len) {
 }
 /***
  * write command with parameters and insert crc
- * use stack array for less than 4 paramaters. Most sensirion i2c commands have less parameters
+ * use stack array for less than 4 parameters. Most sensirion i2c commands have less parameters
  */
 bool SensirionI2CDevice::write_command_(uint16_t command, CommandLen command_len, const uint16_t *data,
                                         uint8_t data_len) {
@@ -63,7 +63,7 @@ bool SensirionI2CDevice::write_command_(uint16_t command, CommandLen command_len
     temp[raw_idx++] = command >> 8;
 #endif
   }
-  // add parameters folllowed by crc
+  // add parameters followed by crc
   // skipped if len == 0
   for (size_t i = 0; i < data_len; i++) {
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

esphome/components/sensirion_common/i2c_sensirion.h

@@ -20,13 +20,13 @@ class SensirionI2CDevice : public i2c::I2CDevice {
    * handles crc check used by Sensirion sensors
    * @param data pointer to raw result
    * @param len number of words to read
-   * @return true if reading succeded
+   * @return true if reading succeeded
    */
   bool read_data(uint16_t *data, uint8_t len);
 
   /** Read 1 data word from i2c device.
    * @param data reference to raw result
-   * @return true if reading succeded
+   * @return true if reading succeeded
    */
   bool read_data(uint16_t &data) { return this->read_data(&data, 1); }
 
@@ -35,8 +35,8 @@ class SensirionI2CDevice : public i2c::I2CDevice {
    * @param  i2c register
    * @param data pointer to raw result
    * @param len number of words to read
-   * @param delay milliseconds to to wait between sending the i2c commmand and reading the result
-   * @return true if reading succeded
+   * @param delay milliseconds to to wait between sending the i2c command and reading the result
+   * @return true if reading succeeded
    */
   bool get_register(uint16_t command, uint16_t *data, uint8_t len, uint8_t delay = 0) {
     return get_register_(command, ADDR_16_BIT, data, len, delay);
@@ -44,8 +44,8 @@ class SensirionI2CDevice : public i2c::I2CDevice {
   /** Read 1 data word from 16 bit i2c register.
    * @param  i2c register
    * @param data reference to raw result
-   * @param delay milliseconds to to wait between sending the i2c commmand and reading the result
-   * @return true if reading succeded
+   * @param delay milliseconds to to wait between sending the i2c command and reading the result
+   * @return true if reading succeeded
    */
   bool get_register(uint16_t i2c_register, uint16_t &data, uint8_t delay = 0) {
     return this->get_register_(i2c_register, ADDR_16_BIT, &data, 1, delay);
@@ -56,8 +56,8 @@ class SensirionI2CDevice : public i2c::I2CDevice {
    * @param  i2c register
    * @param data pointer to raw result
    * @param len number of words to read
-   * @param delay milliseconds to to wait between sending the i2c commmand and reading the result
-   * @return true if reading succeded
+   * @param delay milliseconds to to wait between sending the i2c command and reading the result
+   * @return true if reading succeeded
    */
   bool get_8bit_register(uint8_t i2c_register, uint16_t *data, uint8_t len, uint8_t delay = 0) {
     return get_register_(i2c_register, ADDR_8_BIT, data, len, delay);
@@ -66,8 +66,8 @@ class SensirionI2CDevice : public i2c::I2CDevice {
   /** Read 1 data word from 8 bit i2c register.
    * @param  i2c register
    * @param data reference to raw result
-   * @param delay milliseconds to to wait between sending the i2c commmand and reading the result
-   * @return true if reading succeded
+   * @param delay milliseconds to to wait between sending the i2c command and reading the result
+   * @return true if reading succeeded
    */
   bool get_8bit_register(uint8_t i2c_register, uint16_t &data, uint8_t delay = 0) {
     return this->get_register_(i2c_register, ADDR_8_BIT, &data, 1, delay);
@@ -75,21 +75,21 @@ class SensirionI2CDevice : public i2c::I2CDevice {
 
   /** Write a command to the i2c device.
    * @param command i2c command to send
-   * @return true if reading succeded
+   * @return true if reading succeeded
    */
   template<class T> bool write_command(T i2c_register) { return write_command(i2c_register, nullptr, 0); }
 
   /** Write a command and one data word to the i2c device .
    * @param command i2c command to send
    * @param data argument for the i2c command
-   * @return true if reading succeded
+   * @return true if reading succeeded
    */
   template<class T> bool write_command(T i2c_register, uint16_t data) { return write_command(i2c_register, &data, 1); }
 
   /** Write a command with arguments as words
    * @param i2c_register i2c command to send - an be uint8_t or uint16_t
    * @param data vector<uint16> arguments for the i2c command
-   * @return true if reading succeded
+   * @return true if reading succeeded
    */
   template<class T> bool write_command(T i2c_register, const std::vector<uint16_t> &data) {
     return write_command_(i2c_register, sizeof(T), data.data(), data.size());
@@ -99,7 +99,7 @@ class SensirionI2CDevice : public i2c::I2CDevice {
    * @param i2c_register i2c command to send - an be uint8_t or uint16_t
    * @param data arguments for the i2c command
    * @param len number of arguments (words)
-   * @return true if reading succeded
+   * @return true if reading succeeded
    */
   template<class T> bool write_command(T i2c_register, const uint16_t *data, uint8_t len) {
     // limit to 8 or 16 bit only
@@ -115,7 +115,7 @@ class SensirionI2CDevice : public i2c::I2CDevice {
    * @param command_len either 1 for short 8 bit command or 2 for 16 bit command codes
    * @param data arguments for the i2c command
    * @param data_len number of arguments (words)
-   * @return true if reading succeded
+   * @return true if reading succeeded
    */
   bool write_command_(uint16_t command, CommandLen command_len, const uint16_t *data, uint8_t data_len);
 
@@ -125,8 +125,8 @@ class SensirionI2CDevice : public i2c::I2CDevice {
    * @param command_len either 1 for short 8 bit command or 2 for 16 bit command codes
    * @param data pointer to raw result
    * @param len number of words to read
-   * @param delay milliseconds to to wait between sending the i2c commmand and reading the result
-   * @return true if reading succeded
+   * @param delay milliseconds to to wait between sending the i2c command and reading the result
+   * @return true if reading succeeded
    */
   bool get_register_(uint16_t reg, CommandLen command_len, uint16_t *data, uint8_t len, uint8_t delay);
 

esphome/components/sensor/__init__.py

@@ -29,13 +29,17 @@ from esphome.const import (
     CONF_WINDOW_SIZE,
     CONF_MQTT_ID,
     CONF_FORCE_UPDATE,
+    DEVICE_CLASS_DURATION,
     DEVICE_CLASS_EMPTY,
+    DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_AQI,
     DEVICE_CLASS_BATTERY,
     DEVICE_CLASS_CARBON_DIOXIDE,
     DEVICE_CLASS_CARBON_MONOXIDE,
     DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_DATE,
     DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_FREQUENCY,
     DEVICE_CLASS_GAS,
     DEVICE_CLASS_HUMIDITY,
     DEVICE_CLASS_ILLUMINANCE,
@@ -50,6 +54,7 @@ from esphome.const import (
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_POWER_FACTOR,
     DEVICE_CLASS_PRESSURE,
+    DEVICE_CLASS_REACTIVE_POWER,
     DEVICE_CLASS_SIGNAL_STRENGTH,
     DEVICE_CLASS_SULPHUR_DIOXIDE,
     DEVICE_CLASS_TEMPERATURE,
@@ -65,12 +70,16 @@ from esphome.util import Registry
 CODEOWNERS = ["@esphome/core"]
 DEVICE_CLASSES = [
     DEVICE_CLASS_EMPTY,
+    DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_AQI,
     DEVICE_CLASS_BATTERY,
     DEVICE_CLASS_CARBON_DIOXIDE,
     DEVICE_CLASS_CARBON_MONOXIDE,
     DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_DATE,
+    DEVICE_CLASS_DURATION,
     DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_FREQUENCY,
     DEVICE_CLASS_GAS,
     DEVICE_CLASS_HUMIDITY,
     DEVICE_CLASS_ILLUMINANCE,
@@ -85,6 +94,7 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_POWER_FACTOR,
     DEVICE_CLASS_PRESSURE,
+    DEVICE_CLASS_REACTIVE_POWER,
     DEVICE_CLASS_SIGNAL_STRENGTH,
     DEVICE_CLASS_SULPHUR_DIOXIDE,
     DEVICE_CLASS_TEMPERATURE,

esphome/components/sensor/sensor.cpp

@@ -126,7 +126,6 @@ void Sensor::internal_send_state_to_frontend(float state) {
   this->callback_.call(state);
 }
 bool Sensor::has_state() const { return this->has_state_; }
-uint32_t Sensor::hash_base() { return 2455723294UL; }
 
 }  // namespace sensor
 }  // namespace esphome

esphome/components/sensor/sensor.h

@@ -174,8 +174,6 @@ class Sensor : public EntityBase {
    */
   virtual StateClass state_class();  // NOLINT
 
-  uint32_t hash_base() override;
-
   CallbackManager<void(float)> raw_callback_;  ///< Storage for raw state callbacks.
   CallbackManager<void(float)> callback_;      ///< Storage for filtered state callbacks.
 

esphome/components/sgp40/sensirion_voc_algorithm.cpp

@@ -1,628 +0,0 @@
-
-#include "sensirion_voc_algorithm.h"
-
-namespace esphome {
-namespace sgp40 {
-
-/* The VOC code were originally created by
- *  https://github.com/Sensirion/embedded-sgp
- * The fixed point arithmetic parts of this code were originally created by
- * https://github.com/PetteriAimonen/libfixmath
- */
-
-/*!< the maximum value of fix16_t */
-#define FIX16_MAXIMUM 0x7FFFFFFF
-/*!< the minimum value of fix16_t */
-static const uint32_t FIX16_MINIMUM = 0x80000000;
-/*!< the value used to indicate overflows when FIXMATH_NO_OVERFLOW is not
- * specified */
-static const uint32_t FIX16_OVERFLOW = 0x80000000;
-/*!< fix16_t value of 1 */
-const uint32_t FIX16_ONE = 0x00010000;
-
-inline fix16_t fix16_from_int(int32_t a) { return a * FIX16_ONE; }
-
-inline int32_t fix16_cast_to_int(fix16_t a) { return (a >> 16); }
-
-/*! Multiplies the two given fix16_t's and returns the result. */
-static fix16_t fix16_mul(fix16_t in_arg0, fix16_t in_arg1);
-
-/*! Divides the first given fix16_t by the second and returns the result. */
-static fix16_t fix16_div(fix16_t a, fix16_t b);
-
-/*! Returns the square root of the given fix16_t. */
-static fix16_t fix16_sqrt(fix16_t in_value);
-
-/*! Returns the exponent (e^) of the given fix16_t. */
-static fix16_t fix16_exp(fix16_t in_value);
-
-static fix16_t fix16_mul(fix16_t in_arg0, fix16_t in_arg1) {
-  // Each argument is divided to 16-bit parts.
-  //                    AB
-  //            *     CD
-  // -----------
-  //                    BD    16 * 16 -> 32 bit products
-  //                 CB
-  //                 AD
-  //                AC
-  //             |----| 64 bit product
-  int32_t a = (in_arg0 >> 16), c = (in_arg1 >> 16);
-  uint32_t b = (in_arg0 & 0xFFFF), d = (in_arg1 & 0xFFFF);
-
-  int32_t ac = a * c;
-  int32_t ad_cb = a * d + c * b;
-  uint32_t bd = b * d;
-
-  int32_t product_hi = ac + (ad_cb >> 16);  // NOLINT
-
-  // Handle carry from lower 32 bits to upper part of result.
-  uint32_t ad_cb_temp = ad_cb << 16;  // NOLINT
-  uint32_t product_lo = bd + ad_cb_temp;
-  if (product_lo < bd)
-    product_hi++;
-
-#ifndef FIXMATH_NO_OVERFLOW
-  // The upper 17 bits should all be the same (the sign).
-  if (product_hi >> 31 != product_hi >> 15)
-    return FIX16_OVERFLOW;
-#endif
-
-#ifdef FIXMATH_NO_ROUNDING
-  return (product_hi << 16) | (product_lo >> 16);
-#else
-  // Subtracting 0x8000 (= 0.5) and then using signed right shift
-  // achieves proper rounding to result-1, except in the corner
-  // case of negative numbers and lowest word = 0x8000.
-  // To handle that, we also have to subtract 1 for negative numbers.
-  uint32_t product_lo_tmp = product_lo;
-  product_lo -= 0x8000;
-  product_lo -= (uint32_t) product_hi >> 31;
-  if (product_lo > product_lo_tmp)
-    product_hi--;
-
-  // Discard the lowest 16 bits. Note that this is not exactly the same
-  // as dividing by 0x10000. For example if product = -1, result will
-  // also be -1 and not 0. This is compensated by adding +1 to the result
-  // and compensating this in turn in the rounding above.
-  fix16_t result = (product_hi << 16) | (product_lo >> 16);  // NOLINT
-  result += 1;
-  return result;
-#endif
-}
-
-static fix16_t fix16_div(fix16_t a, fix16_t b) {
-  // This uses the basic binary restoring division algorithm.
-  // It appears to be faster to do the whole division manually than
-  // trying to compose a 64-bit divide out of 32-bit divisions on
-  // platforms without hardware divide.
-
-  if (b == 0)
-    return FIX16_MINIMUM;
-
-  uint32_t remainder = (a >= 0) ? a : (-a);
-  uint32_t divider = (b >= 0) ? b : (-b);
-
-  uint32_t quotient = 0;
-  uint32_t bit = 0x10000;
-
-  /* The algorithm requires D >= R */
-  while (divider < remainder) {
-    divider <<= 1;
-    bit <<= 1;
-  }
-
-#ifndef FIXMATH_NO_OVERFLOW
-  if (!bit)
-    return FIX16_OVERFLOW;
-#endif
-
-  if (divider & 0x80000000) {
-    // Perform one step manually to avoid overflows later.
-    // We know that divider's bottom bit is 0 here.
-    if (remainder >= divider) {
-      quotient |= bit;
-      remainder -= divider;
-    }
-    divider >>= 1;
-    bit >>= 1;
-  }
-
-  /* Main division loop */
-  while (bit && remainder) {
-    if (remainder >= divider) {
-      quotient |= bit;
-      remainder -= divider;
-    }
-
-    remainder <<= 1;
-    bit >>= 1;
-  }
-
-#ifndef FIXMATH_NO_ROUNDING
-  if (remainder >= divider) {
-    quotient++;
-  }
-#endif
-
-  fix16_t result = quotient;
-
-  /* Figure out the sign of result */
-  if ((a ^ b) & 0x80000000) {
-#ifndef FIXMATH_NO_OVERFLOW
-    if (result == FIX16_MINIMUM)  // NOLINT(clang-diagnostic-sign-compare)
-      return FIX16_OVERFLOW;
-#endif
-
-    result = -result;
-  }
-
-  return result;
-}
-
-static fix16_t fix16_sqrt(fix16_t in_value) {
-  // It is assumed that x is not negative
-
-  uint32_t num = in_value;
-  uint32_t result = 0;
-  uint32_t bit;
-  uint8_t n;
-
-  bit = (uint32_t) 1 << 30;
-  while (bit > num)
-    bit >>= 2;
-
-  // The main part is executed twice, in order to avoid
-  // using 64 bit values in computations.
-  for (n = 0; n < 2; n++) {
-    // First we get the top 24 bits of the answer.
-    while (bit) {
-      if (num >= result + bit) {
-        num -= result + bit;
-        result = (result >> 1) + bit;
-      } else {
-        result = (result >> 1);
-      }
-      bit >>= 2;
-    }
-
-    if (n == 0) {
-      // Then process it again to get the lowest 8 bits.
-      if (num > 65535) {
-        // The remainder 'num' is too large to be shifted left
-        // by 16, so we have to add 1 to result manually and
-        // adjust 'num' accordingly.
-        // num = a - (result + 0.5)^2
-        //     = num + result^2 - (result + 0.5)^2
-        //     = num - result - 0.5
-        num -= result;
-        num = (num << 16) - 0x8000;
-        result = (result << 16) + 0x8000;
-      } else {
-        num <<= 16;
-        result <<= 16;
-      }
-
-      bit = 1 << 14;
-    }
-  }
-
-#ifndef FIXMATH_NO_ROUNDING
-  // Finally, if next bit would have been 1, round the result upwards.
-  if (num > result) {
-    result++;
-  }
-#endif
-
-  return (fix16_t) result;
-}
-
-static fix16_t fix16_exp(fix16_t in_value) {
-  // Function to approximate exp(); optimized more for code size than speed
-
-  // exp(x) for x = +/- {1, 1/8, 1/64, 1/512}
-  fix16_t x = in_value;
-  static const uint8_t NUM_EXP_VALUES = 4;
-  static const fix16_t EXP_POS_VALUES[4] = {F16(2.7182818), F16(1.1331485), F16(1.0157477), F16(1.0019550)};
-  static const fix16_t EXP_NEG_VALUES[4] = {F16(0.3678794), F16(0.8824969), F16(0.9844964), F16(0.9980488)};
-  const fix16_t *exp_values;
-
-  fix16_t res, arg;
-  uint16_t i;
-
-  if (x >= F16(10.3972))
-    return FIX16_MAXIMUM;
-  if (x <= F16(-11.7835))
-    return 0;
-
-  if (x < 0) {
-    x = -x;
-    exp_values = EXP_NEG_VALUES;
-  } else {
-    exp_values = EXP_POS_VALUES;
-  }
-
-  res = FIX16_ONE;
-  arg = FIX16_ONE;
-  for (i = 0; i < NUM_EXP_VALUES; i++) {
-    while (x >= arg) {
-      res = fix16_mul(res, exp_values[i]);
-      x -= arg;
-    }
-    arg >>= 3;
-  }
-  return res;
-}
-
-static void voc_algorithm_init_instances(VocAlgorithmParams *params);
-static void voc_algorithm_mean_variance_estimator_init(VocAlgorithmParams *params);
-static void voc_algorithm_mean_variance_estimator_init_instances(VocAlgorithmParams *params);
-static void voc_algorithm_mean_variance_estimator_set_parameters(VocAlgorithmParams *params, fix16_t std_initial,
-                                                                 fix16_t tau_mean_variance_hours,
-                                                                 fix16_t gating_max_duration_minutes);
-static void voc_algorithm_mean_variance_estimator_set_states(VocAlgorithmParams *params, fix16_t mean, fix16_t std,
-                                                             fix16_t uptime_gamma);
-static fix16_t voc_algorithm_mean_variance_estimator_get_std(VocAlgorithmParams *params);
-static fix16_t voc_algorithm_mean_variance_estimator_get_mean(VocAlgorithmParams *params);
-static void voc_algorithm_mean_variance_estimator_calculate_gamma(VocAlgorithmParams *params,
-                                                                  fix16_t voc_index_from_prior);
-static void voc_algorithm_mean_variance_estimator_process(VocAlgorithmParams *params, fix16_t sraw,
-                                                          fix16_t voc_index_from_prior);
-static void voc_algorithm_mean_variance_estimator_sigmoid_init(VocAlgorithmParams *params);
-static void voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(VocAlgorithmParams *params, fix16_t l,
-                                                                         fix16_t x0, fix16_t k);
-static fix16_t voc_algorithm_mean_variance_estimator_sigmoid_process(VocAlgorithmParams *params, fix16_t sample);
-static void voc_algorithm_mox_model_init(VocAlgorithmParams *params);
-static void voc_algorithm_mox_model_set_parameters(VocAlgorithmParams *params, fix16_t sraw_std, fix16_t sraw_mean);
-static fix16_t voc_algorithm_mox_model_process(VocAlgorithmParams *params, fix16_t sraw);
-static void voc_algorithm_sigmoid_scaled_init(VocAlgorithmParams *params);
-static void voc_algorithm_sigmoid_scaled_set_parameters(VocAlgorithmParams *params, fix16_t offset);
-static fix16_t voc_algorithm_sigmoid_scaled_process(VocAlgorithmParams *params, fix16_t sample);
-static void voc_algorithm_adaptive_lowpass_init(VocAlgorithmParams *params);
-static void voc_algorithm_adaptive_lowpass_set_parameters(VocAlgorithmParams *params);
-static fix16_t voc_algorithm_adaptive_lowpass_process(VocAlgorithmParams *params, fix16_t sample);
-
-void voc_algorithm_init(VocAlgorithmParams *params) {
-  params->mVoc_Index_Offset = F16(VOC_ALGORITHM_VOC_INDEX_OFFSET_DEFAULT);
-  params->mTau_Mean_Variance_Hours = F16(VOC_ALGORITHM_TAU_MEAN_VARIANCE_HOURS);
-  params->mGating_Max_Duration_Minutes = F16(VOC_ALGORITHM_GATING_MAX_DURATION_MINUTES);
-  params->mSraw_Std_Initial = F16(VOC_ALGORITHM_SRAW_STD_INITIAL);
-  params->mUptime = F16(0.);
-  params->mSraw = F16(0.);
-  params->mVoc_Index = 0;
-  voc_algorithm_init_instances(params);
-}
-
-static void voc_algorithm_init_instances(VocAlgorithmParams *params) {
-  voc_algorithm_mean_variance_estimator_init(params);
-  voc_algorithm_mean_variance_estimator_set_parameters(
-      params, params->mSraw_Std_Initial, params->mTau_Mean_Variance_Hours, params->mGating_Max_Duration_Minutes);
-  voc_algorithm_mox_model_init(params);
-  voc_algorithm_mox_model_set_parameters(params, voc_algorithm_mean_variance_estimator_get_std(params),
-                                         voc_algorithm_mean_variance_estimator_get_mean(params));
-  voc_algorithm_sigmoid_scaled_init(params);
-  voc_algorithm_sigmoid_scaled_set_parameters(params, params->mVoc_Index_Offset);
-  voc_algorithm_adaptive_lowpass_init(params);
-  voc_algorithm_adaptive_lowpass_set_parameters(params);
-}
-
-void voc_algorithm_get_states(VocAlgorithmParams *params, int32_t *state0, int32_t *state1) {
-  *state0 = voc_algorithm_mean_variance_estimator_get_mean(params);
-  *state1 = voc_algorithm_mean_variance_estimator_get_std(params);
-}
-
-void voc_algorithm_set_states(VocAlgorithmParams *params, int32_t state0, int32_t state1) {
-  voc_algorithm_mean_variance_estimator_set_states(params, state0, state1, F16(VOC_ALGORITHM_PERSISTENCE_UPTIME_GAMMA));
-  params->mSraw = state0;
-}
-
-void voc_algorithm_set_tuning_parameters(VocAlgorithmParams *params, int32_t voc_index_offset,
-                                         int32_t learning_time_hours, int32_t gating_max_duration_minutes,
-                                         int32_t std_initial) {
-  params->mVoc_Index_Offset = (fix16_from_int(voc_index_offset));
-  params->mTau_Mean_Variance_Hours = (fix16_from_int(learning_time_hours));
-  params->mGating_Max_Duration_Minutes = (fix16_from_int(gating_max_duration_minutes));
-  params->mSraw_Std_Initial = (fix16_from_int(std_initial));
-  voc_algorithm_init_instances(params);
-}
-
-void voc_algorithm_process(VocAlgorithmParams *params, int32_t sraw, int32_t *voc_index) {
-  if ((params->mUptime <= F16(VOC_ALGORITHM_INITIAL_BLACKOUT))) {
-    params->mUptime = (params->mUptime + F16(VOC_ALGORITHM_SAMPLING_INTERVAL));
-  } else {
-    if (((sraw > 0) && (sraw < 65000))) {
-      if ((sraw < 20001)) {
-        sraw = 20001;
-      } else if ((sraw > 52767)) {
-        sraw = 52767;
-      }
-      params->mSraw = (fix16_from_int((sraw - 20000)));
-    }
-    params->mVoc_Index = voc_algorithm_mox_model_process(params, params->mSraw);
-    params->mVoc_Index = voc_algorithm_sigmoid_scaled_process(params, params->mVoc_Index);
-    params->mVoc_Index = voc_algorithm_adaptive_lowpass_process(params, params->mVoc_Index);
-    if ((params->mVoc_Index < F16(0.5))) {
-      params->mVoc_Index = F16(0.5);
-    }
-    if ((params->mSraw > F16(0.))) {
-      voc_algorithm_mean_variance_estimator_process(params, params->mSraw, params->mVoc_Index);
-      voc_algorithm_mox_model_set_parameters(params, voc_algorithm_mean_variance_estimator_get_std(params),
-                                             voc_algorithm_mean_variance_estimator_get_mean(params));
-    }
-  }
-  *voc_index = (fix16_cast_to_int((params->mVoc_Index + F16(0.5))));
-}
-
-static void voc_algorithm_mean_variance_estimator_init(VocAlgorithmParams *params) {
-  voc_algorithm_mean_variance_estimator_set_parameters(params, F16(0.), F16(0.), F16(0.));
-  voc_algorithm_mean_variance_estimator_init_instances(params);
-}
-
-static void voc_algorithm_mean_variance_estimator_init_instances(VocAlgorithmParams *params) {
-  voc_algorithm_mean_variance_estimator_sigmoid_init(params);
-}
-
-static void voc_algorithm_mean_variance_estimator_set_parameters(VocAlgorithmParams *params, fix16_t std_initial,
-                                                                 fix16_t tau_mean_variance_hours,
-                                                                 fix16_t gating_max_duration_minutes) {
-  params->m_Mean_Variance_Estimator_Gating_Max_Duration_Minutes = gating_max_duration_minutes;
-  params->m_Mean_Variance_Estimator_Initialized = false;
-  params->m_Mean_Variance_Estimator_Mean = F16(0.);
-  params->m_Mean_Variance_Estimator_Sraw_Offset = F16(0.);
-  params->m_Mean_Variance_Estimator_Std = std_initial;
-  params->m_Mean_Variance_Estimator_Gamma =
-      (fix16_div(F16((VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING * (VOC_ALGORITHM_SAMPLING_INTERVAL / 3600.))),
-                 (tau_mean_variance_hours + F16((VOC_ALGORITHM_SAMPLING_INTERVAL / 3600.)))));
-  params->m_Mean_Variance_Estimator_Gamma_Initial_Mean =
-      F16(((VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING * VOC_ALGORITHM_SAMPLING_INTERVAL) /
-           (VOC_ALGORITHM_TAU_INITIAL_MEAN + VOC_ALGORITHM_SAMPLING_INTERVAL)));
-  params->m_Mean_Variance_Estimator_Gamma_Initial_Variance =
-      F16(((VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING * VOC_ALGORITHM_SAMPLING_INTERVAL) /
-           (VOC_ALGORITHM_TAU_INITIAL_VARIANCE + VOC_ALGORITHM_SAMPLING_INTERVAL)));
-  params->m_Mean_Variance_Estimator_Gamma_Mean = F16(0.);
-  params->m_Mean_Variance_Estimator_Gamma_Variance = F16(0.);
-  params->m_Mean_Variance_Estimator_Uptime_Gamma = F16(0.);
-  params->m_Mean_Variance_Estimator_Uptime_Gating = F16(0.);
-  params->m_Mean_Variance_Estimator_Gating_Duration_Minutes = F16(0.);
-}
-
-static void voc_algorithm_mean_variance_estimator_set_states(VocAlgorithmParams *params, fix16_t mean, fix16_t std,
-                                                             fix16_t uptime_gamma) {
-  params->m_Mean_Variance_Estimator_Mean = mean;
-  params->m_Mean_Variance_Estimator_Std = std;
-  params->m_Mean_Variance_Estimator_Uptime_Gamma = uptime_gamma;
-  params->m_Mean_Variance_Estimator_Initialized = true;
-}
-
-static fix16_t voc_algorithm_mean_variance_estimator_get_std(VocAlgorithmParams *params) {
-  return params->m_Mean_Variance_Estimator_Std;
-}
-
-static fix16_t voc_algorithm_mean_variance_estimator_get_mean(VocAlgorithmParams *params) {
-  return (params->m_Mean_Variance_Estimator_Mean + params->m_Mean_Variance_Estimator_Sraw_Offset);
-}
-
-static void voc_algorithm_mean_variance_estimator_calculate_gamma(VocAlgorithmParams *params,
-                                                                  fix16_t voc_index_from_prior) {
-  fix16_t uptime_limit;
-  fix16_t sigmoid_gamma_mean;
-  fix16_t gamma_mean;
-  fix16_t gating_threshold_mean;
-  fix16_t sigmoid_gating_mean;
-  fix16_t sigmoid_gamma_variance;
-  fix16_t gamma_variance;
-  fix16_t gating_threshold_variance;
-  fix16_t sigmoid_gating_variance;
-
-  uptime_limit = F16((VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_FI_X16_MAX - VOC_ALGORITHM_SAMPLING_INTERVAL));
-  if ((params->m_Mean_Variance_Estimator_Uptime_Gamma < uptime_limit)) {
-    params->m_Mean_Variance_Estimator_Uptime_Gamma =
-        (params->m_Mean_Variance_Estimator_Uptime_Gamma + F16(VOC_ALGORITHM_SAMPLING_INTERVAL));
-  }
-  if ((params->m_Mean_Variance_Estimator_Uptime_Gating < uptime_limit)) {
-    params->m_Mean_Variance_Estimator_Uptime_Gating =
-        (params->m_Mean_Variance_Estimator_Uptime_Gating + F16(VOC_ALGORITHM_SAMPLING_INTERVAL));
-  }
-  voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(params, F16(1.), F16(VOC_ALGORITHM_INIT_DURATION_MEAN),
-                                                               F16(VOC_ALGORITHM_INIT_TRANSITION_MEAN));
-  sigmoid_gamma_mean =
-      voc_algorithm_mean_variance_estimator_sigmoid_process(params, params->m_Mean_Variance_Estimator_Uptime_Gamma);
-  gamma_mean =
-      (params->m_Mean_Variance_Estimator_Gamma +
-       (fix16_mul((params->m_Mean_Variance_Estimator_Gamma_Initial_Mean - params->m_Mean_Variance_Estimator_Gamma),
-                  sigmoid_gamma_mean)));
-  gating_threshold_mean = (F16(VOC_ALGORITHM_GATING_THRESHOLD) +
-                           (fix16_mul(F16((VOC_ALGORITHM_GATING_THRESHOLD_INITIAL - VOC_ALGORITHM_GATING_THRESHOLD)),
-                                      voc_algorithm_mean_variance_estimator_sigmoid_process(
-                                          params, params->m_Mean_Variance_Estimator_Uptime_Gating))));
-  voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(params, F16(1.), gating_threshold_mean,
-                                                               F16(VOC_ALGORITHM_GATING_THRESHOLD_TRANSITION));
-  sigmoid_gating_mean = voc_algorithm_mean_variance_estimator_sigmoid_process(params, voc_index_from_prior);
-  params->m_Mean_Variance_Estimator_Gamma_Mean = (fix16_mul(sigmoid_gating_mean, gamma_mean));
-  voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(
-      params, F16(1.), F16(VOC_ALGORITHM_INIT_DURATION_VARIANCE), F16(VOC_ALGORITHM_INIT_TRANSITION_VARIANCE));
-  sigmoid_gamma_variance =
-      voc_algorithm_mean_variance_estimator_sigmoid_process(params, params->m_Mean_Variance_Estimator_Uptime_Gamma);
-  gamma_variance =
-      (params->m_Mean_Variance_Estimator_Gamma +
-       (fix16_mul((params->m_Mean_Variance_Estimator_Gamma_Initial_Variance - params->m_Mean_Variance_Estimator_Gamma),
-                  (sigmoid_gamma_variance - sigmoid_gamma_mean))));
-  gating_threshold_variance =
-      (F16(VOC_ALGORITHM_GATING_THRESHOLD) +
-       (fix16_mul(F16((VOC_ALGORITHM_GATING_THRESHOLD_INITIAL - VOC_ALGORITHM_GATING_THRESHOLD)),
-                  voc_algorithm_mean_variance_estimator_sigmoid_process(
-                      params, params->m_Mean_Variance_Estimator_Uptime_Gating))));
-  voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(params, F16(1.), gating_threshold_variance,
-                                                               F16(VOC_ALGORITHM_GATING_THRESHOLD_TRANSITION));
-  sigmoid_gating_variance = voc_algorithm_mean_variance_estimator_sigmoid_process(params, voc_index_from_prior);
-  params->m_Mean_Variance_Estimator_Gamma_Variance = (fix16_mul(sigmoid_gating_variance, gamma_variance));
-  params->m_Mean_Variance_Estimator_Gating_Duration_Minutes =
-      (params->m_Mean_Variance_Estimator_Gating_Duration_Minutes +
-       (fix16_mul(F16((VOC_ALGORITHM_SAMPLING_INTERVAL / 60.)),
-                  ((fix16_mul((F16(1.) - sigmoid_gating_mean), F16((1. + VOC_ALGORITHM_GATING_MAX_RATIO)))) -
-                   F16(VOC_ALGORITHM_GATING_MAX_RATIO)))));
-  if ((params->m_Mean_Variance_Estimator_Gating_Duration_Minutes < F16(0.))) {
-    params->m_Mean_Variance_Estimator_Gating_Duration_Minutes = F16(0.);
-  }
-  if ((params->m_Mean_Variance_Estimator_Gating_Duration_Minutes >
-       params->m_Mean_Variance_Estimator_Gating_Max_Duration_Minutes)) {
-    params->m_Mean_Variance_Estimator_Uptime_Gating = F16(0.);
-  }
-}
-
-static void voc_algorithm_mean_variance_estimator_process(VocAlgorithmParams *params, fix16_t sraw,
-                                                          fix16_t voc_index_from_prior) {
-  fix16_t delta_sgp;
-  fix16_t c;
-  fix16_t additional_scaling;
-
-  if ((!params->m_Mean_Variance_Estimator_Initialized)) {
-    params->m_Mean_Variance_Estimator_Initialized = true;
-    params->m_Mean_Variance_Estimator_Sraw_Offset = sraw;
-    params->m_Mean_Variance_Estimator_Mean = F16(0.);
-  } else {
-    if (((params->m_Mean_Variance_Estimator_Mean >= F16(100.)) ||
-         (params->m_Mean_Variance_Estimator_Mean <= F16(-100.)))) {
-      params->m_Mean_Variance_Estimator_Sraw_Offset =
-          (params->m_Mean_Variance_Estimator_Sraw_Offset + params->m_Mean_Variance_Estimator_Mean);
-      params->m_Mean_Variance_Estimator_Mean = F16(0.);
-    }
-    sraw = (sraw - params->m_Mean_Variance_Estimator_Sraw_Offset);
-    voc_algorithm_mean_variance_estimator_calculate_gamma(params, voc_index_from_prior);
-    delta_sgp = (fix16_div((sraw - params->m_Mean_Variance_Estimator_Mean),
-                           F16(VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING)));
-    if ((delta_sgp < F16(0.))) {
-      c = (params->m_Mean_Variance_Estimator_Std - delta_sgp);
-    } else {
-      c = (params->m_Mean_Variance_Estimator_Std + delta_sgp);
-    }
-    additional_scaling = F16(1.);
-    if ((c > F16(1440.))) {
-      additional_scaling = F16(4.);
-    }
-    params->m_Mean_Variance_Estimator_Std = (fix16_mul(
-        fix16_sqrt((fix16_mul(additional_scaling, (F16(VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING) -
-                                                   params->m_Mean_Variance_Estimator_Gamma_Variance)))),
-        fix16_sqrt(((fix16_mul(params->m_Mean_Variance_Estimator_Std,
-                               (fix16_div(params->m_Mean_Variance_Estimator_Std,
-                                          (fix16_mul(F16(VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING),
-                                                     additional_scaling)))))) +
-                    (fix16_mul((fix16_div((fix16_mul(params->m_Mean_Variance_Estimator_Gamma_Variance, delta_sgp)),
-                                          additional_scaling)),
-                               delta_sgp))))));
-    params->m_Mean_Variance_Estimator_Mean =
-        (params->m_Mean_Variance_Estimator_Mean + (fix16_mul(params->m_Mean_Variance_Estimator_Gamma_Mean, delta_sgp)));
-  }
-}
-
-static void voc_algorithm_mean_variance_estimator_sigmoid_init(VocAlgorithmParams *params) {
-  voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(params, F16(0.), F16(0.), F16(0.));
-}
-
-static void voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(VocAlgorithmParams *params, fix16_t l,
-                                                                         fix16_t x0, fix16_t k) {
-  params->m_Mean_Variance_Estimator_Sigmoid_L = l;
-  params->m_Mean_Variance_Estimator_Sigmoid_K = k;
-  params->m_Mean_Variance_Estimator_Sigmoid_X0 = x0;
-}
-
-static fix16_t voc_algorithm_mean_variance_estimator_sigmoid_process(VocAlgorithmParams *params, fix16_t sample) {
-  fix16_t x;
-
-  x = (fix16_mul(params->m_Mean_Variance_Estimator_Sigmoid_K, (sample - params->m_Mean_Variance_Estimator_Sigmoid_X0)));
-  if ((x < F16(-50.))) {
-    return params->m_Mean_Variance_Estimator_Sigmoid_L;
-  } else if ((x > F16(50.))) {
-    return F16(0.);
-  } else {
-    return (fix16_div(params->m_Mean_Variance_Estimator_Sigmoid_L, (F16(1.) + fix16_exp(x))));
-  }
-}
-
-static void voc_algorithm_mox_model_init(VocAlgorithmParams *params) {
-  voc_algorithm_mox_model_set_parameters(params, F16(1.), F16(0.));
-}
-
-static void voc_algorithm_mox_model_set_parameters(VocAlgorithmParams *params, fix16_t sraw_std, fix16_t sraw_mean) {
-  params->m_Mox_Model_Sraw_Std = sraw_std;
-  params->m_Mox_Model_Sraw_Mean = sraw_mean;
-}
-
-static fix16_t voc_algorithm_mox_model_process(VocAlgorithmParams *params, fix16_t sraw) {
-  return (fix16_mul((fix16_div((sraw - params->m_Mox_Model_Sraw_Mean),
-                               (-(params->m_Mox_Model_Sraw_Std + F16(VOC_ALGORITHM_SRAW_STD_BONUS))))),
-                    F16(VOC_ALGORITHM_VOC_INDEX_GAIN)));
-}
-
-static void voc_algorithm_sigmoid_scaled_init(VocAlgorithmParams *params) {
-  voc_algorithm_sigmoid_scaled_set_parameters(params, F16(0.));
-}
-
-static void voc_algorithm_sigmoid_scaled_set_parameters(VocAlgorithmParams *params, fix16_t offset) {
-  params->m_Sigmoid_Scaled_Offset = offset;
-}
-
-static fix16_t voc_algorithm_sigmoid_scaled_process(VocAlgorithmParams *params, fix16_t sample) {
-  fix16_t x;
-  fix16_t shift;
-
-  x = (fix16_mul(F16(VOC_ALGORITHM_SIGMOID_K), (sample - F16(VOC_ALGORITHM_SIGMOID_X0))));
-  if ((x < F16(-50.))) {
-    return F16(VOC_ALGORITHM_SIGMOID_L);
-  } else if ((x > F16(50.))) {
-    return F16(0.);
-  } else {
-    if ((sample >= F16(0.))) {
-      shift =
-          (fix16_div((F16(VOC_ALGORITHM_SIGMOID_L) - (fix16_mul(F16(5.), params->m_Sigmoid_Scaled_Offset))), F16(4.)));
-      return ((fix16_div((F16(VOC_ALGORITHM_SIGMOID_L) + shift), (F16(1.) + fix16_exp(x)))) - shift);
-    } else {
-      return (fix16_mul((fix16_div(params->m_Sigmoid_Scaled_Offset, F16(VOC_ALGORITHM_VOC_INDEX_OFFSET_DEFAULT))),
-                        (fix16_div(F16(VOC_ALGORITHM_SIGMOID_L), (F16(1.) + fix16_exp(x))))));
-    }
-  }
-}
-
-static void voc_algorithm_adaptive_lowpass_init(VocAlgorithmParams *params) {
-  voc_algorithm_adaptive_lowpass_set_parameters(params);
-}
-
-static void voc_algorithm_adaptive_lowpass_set_parameters(VocAlgorithmParams *params) {
-  params->m_Adaptive_Lowpass_A1 =
-      F16((VOC_ALGORITHM_SAMPLING_INTERVAL / (VOC_ALGORITHM_LP_TAU_FAST + VOC_ALGORITHM_SAMPLING_INTERVAL)));
-  params->m_Adaptive_Lowpass_A2 =
-      F16((VOC_ALGORITHM_SAMPLING_INTERVAL / (VOC_ALGORITHM_LP_TAU_SLOW + VOC_ALGORITHM_SAMPLING_INTERVAL)));
-  params->m_Adaptive_Lowpass_Initialized = false;
-}
-
-static fix16_t voc_algorithm_adaptive_lowpass_process(VocAlgorithmParams *params, fix16_t sample) {
-  fix16_t abs_delta;
-  fix16_t f1;
-  fix16_t tau_a;
-  fix16_t a3;
-
-  if ((!params->m_Adaptive_Lowpass_Initialized)) {
-    params->m_Adaptive_Lowpass_X1 = sample;
-    params->m_Adaptive_Lowpass_X2 = sample;
-    params->m_Adaptive_Lowpass_X3 = sample;
-    params->m_Adaptive_Lowpass_Initialized = true;
-  }
-  params->m_Adaptive_Lowpass_X1 =
-      ((fix16_mul((F16(1.) - params->m_Adaptive_Lowpass_A1), params->m_Adaptive_Lowpass_X1)) +
-       (fix16_mul(params->m_Adaptive_Lowpass_A1, sample)));
-  params->m_Adaptive_Lowpass_X2 =
-      ((fix16_mul((F16(1.) - params->m_Adaptive_Lowpass_A2), params->m_Adaptive_Lowpass_X2)) +
-       (fix16_mul(params->m_Adaptive_Lowpass_A2, sample)));
-  abs_delta = (params->m_Adaptive_Lowpass_X1 - params->m_Adaptive_Lowpass_X2);
-  if ((abs_delta < F16(0.))) {
-    abs_delta = (-abs_delta);
-  }
-  f1 = fix16_exp((fix16_mul(F16(VOC_ALGORITHM_LP_ALPHA), abs_delta)));
-  tau_a =
-      ((fix16_mul(F16((VOC_ALGORITHM_LP_TAU_SLOW - VOC_ALGORITHM_LP_TAU_FAST)), f1)) + F16(VOC_ALGORITHM_LP_TAU_FAST));
-  a3 = (fix16_div(F16(VOC_ALGORITHM_SAMPLING_INTERVAL), (F16(VOC_ALGORITHM_SAMPLING_INTERVAL) + tau_a)));
-  params->m_Adaptive_Lowpass_X3 =
-      ((fix16_mul((F16(1.) - a3), params->m_Adaptive_Lowpass_X3)) + (fix16_mul(a3, sample)));
-  return params->m_Adaptive_Lowpass_X3;
-}
-}  // namespace sgp40
-}  // namespace esphome