Merge pull request #4350 from esphome/bump-2022.12.7

2022.12.7

.github/workflows/release.yml

@@ -30,6 +30,10 @@ jobs:
             TAG=$(cat esphome/const.py | sed -n -E "s/^__version__\s+=\s+\"(.+)\"$/\1/p")
             today="$(date --utc '+%Y%m%d')"
             TAG="${TAG}${today}"
+            BRANCH=${GITHUB_REF#refs/heads/}
+            if [[ "$BRANCH" != "dev" ]]; then
+              TAG="${TAG}-${BRANCH}"
+            fi
           fi
           echo "tag=${TAG}" >> $GITHUB_OUTPUT
         # yamllint enable rule:line-length
@@ -57,7 +61,7 @@ jobs:
         run: twine upload dist/*
 
   deploy-docker:
-    name: Build and publish docker containers
+    name: Build and publish ESPHome ${{ matrix.image.title}}
     if: github.repository == 'esphome/esphome'
     permissions:
       contents: read
@@ -66,8 +70,19 @@ jobs:
     needs: [init]
     strategy:
       matrix:
-        arch: [amd64, armv7, aarch64]
-        build_type: ["ha-addon", "docker", "lint"]
+        image:
+          - title: "ha-addon"
+            suffix: "hassio"
+            target: "hassio"
+            baseimg: "hassio"
+          - title: "docker"
+            suffix: ""
+            target: "docker"
+            baseimg: "docker"
+          - title: "lint"
+            suffix: "lint"
+            target: "lint"
+            baseimg: "docker"
     steps:
       - uses: actions/checkout@v3
       - name: Set up Python
@@ -92,54 +107,29 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Generate short tags
+        id: tags
+        run: |
+          docker/generate_tags.py \
+            --tag "${{ needs.init.outputs.tag }}" \
+            --suffix "${{ matrix.image.suffix }}"
+
       - name: Build and push
-        run: |
-          docker/build.py \
-            --tag "${{ needs.init.outputs.tag }}" \
-            --arch "${{ matrix.arch }}" \
-            --build-type "${{ matrix.build_type }}" \
-            build \
-            --push
-
-  deploy-docker-manifest:
-    if: github.repository == 'esphome/esphome'
-    permissions:
-      contents: read
-      packages: write
-    runs-on: ubuntu-latest
-    needs: [init, deploy-docker]
-    strategy:
-      matrix:
-        build_type: ["ha-addon", "docker", "lint"]
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: docker/build-push-action@v3
         with:
-          python-version: "3.9"
-      - name: Enable experimental manifest support
-        run: |
-          mkdir -p ~/.docker
-          echo "{\"experimental\": \"enabled\"}" > ~/.docker/config.json
-
-      - name: Log in to docker hub
-        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@v2
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Run manifest
-        run: |
-          docker/build.py \
-            --tag "${{ needs.init.outputs.tag }}" \
-            --build-type "${{ matrix.build_type }}" \
-            manifest
+          context: .
+          file: ./docker/Dockerfile
+          platforms: linux/amd64,linux/arm/v7,linux/arm64
+          target: ${{ matrix.image.target }}
+          push: true
+          # yamllint disable rule:line-length
+          cache-from: type=registry,ref=ghcr.io/${{ steps.tags.outputs.image }}:cache-${{ steps.tags.outputs.channel }}
+          cache-to: type=registry,ref=ghcr.io/${{ steps.tags.outputs.image }}:cache-${{ steps.tags.outputs.channel }},mode=max
+          # yamllint enable rule:line-length
+          tags: ${{ steps.tags.outputs.tags }}
+          build-args: |
+            BASEIMGTYPE=${{ matrix.image.baseimg }}
+            BUILD_VERSION=${{ needs.init.outputs.tag }}
 
   deploy-ha-addon-repo:
     if: github.repository == 'esphome/esphome' && github.event_name == 'release'
@@ -150,11 +140,10 @@ jobs:
           TOKEN: ${{ secrets.DEPLOY_HA_ADDON_REPO_TOKEN }}
         # yamllint disable rule:line-length
         run: |
-          TAG="${GITHUB_REF#refs/tags/}"
           curl \
             -u ":$TOKEN" \
             -X POST \
             -H "Accept: application/vnd.github.v3+json" \
             https://api.github.com/repos/esphome/home-assistant-addon/actions/workflows/bump-version.yml/dispatches \
-            -d "{\"ref\":\"main\",\"inputs\":{\"version\":\"$TAG\"}}"
+            -d '{"ref":"main","inputs":{"version":"${{ github.event.release.tag_name }}","content":${{ toJSON(github.event.release.body) }}}}'
         # yamllint enable rule:line-length

docker/Dockerfile

@@ -139,7 +139,7 @@ RUN \
         clang-tidy-11=1:11.0.1-2 \
         patch=2.7.6-7 \
         software-properties-common=0.96.20.2-2.1 \
-        nano=5.4-2+deb11u1 \
+        nano=5.4-2+deb11u2 \
         build-essential=12.9 \
         python3-dev=3.9.2-3 \
     && rm -rf \

docker/generate_tags.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+import re
+import os
+import argparse
+import json
+
+CHANNEL_DEV = "dev"
+CHANNEL_BETA = "beta"
+CHANNEL_RELEASE = "release"
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--tag",
+    type=str,
+    required=True,
+    help="The main docker tag to push to. If a version number also adds latest and/or beta tag",
+)
+parser.add_argument(
+    "--suffix",
+    type=str,
+    required=True,
+    help="The suffix of the tag.",
+)
+
+
+def main():
+    args = parser.parse_args()
+
+    # detect channel from tag
+    match = re.match(r"^(\d+\.\d+)(?:\.\d+)?(b\d+)?$", args.tag)
+    major_minor_version = None
+    if match is None:
+        channel = CHANNEL_DEV
+    elif match.group(2) is None:
+        major_minor_version = match.group(1)
+        channel = CHANNEL_RELEASE
+    else:
+        channel = CHANNEL_BETA
+
+    tags_to_push = [args.tag]
+    if channel == CHANNEL_DEV:
+        tags_to_push.append("dev")
+    elif channel == CHANNEL_BETA:
+        tags_to_push.append("beta")
+    elif channel == CHANNEL_RELEASE:
+        # Additionally push to beta
+        tags_to_push.append("beta")
+        tags_to_push.append("latest")
+
+        if major_minor_version:
+            tags_to_push.append("stable")
+            tags_to_push.append(major_minor_version)
+
+    suffix = f"-{args.suffix}" if args.suffix else ""
+
+    with open(os.environ["GITHUB_OUTPUT"], "w") as f:
+        print(f"channel={channel}", file=f)
+        print(f"image=esphome/esphome{suffix}", file=f)
+        full_tags = []
+
+        for tag in tags_to_push:
+            full_tags += [f"ghcr.io/esphome/esphome{suffix}:{tag}"]
+            full_tags += [f"esphome/esphome{suffix}:{tag}"]
+        print(f"tags={','.join(full_tags)}", file=f)
+
+
+if __name__ == "__main__":
+    main()

esphome/components/a4988/a4988.cpp

@@ -46,6 +46,7 @@ void A4988::loop() {
     return;
 
   this->dir_pin_->digital_write(dir == 1);
+  delayMicroseconds(50);
   this->step_pin_->digital_write(true);
   delayMicroseconds(5);
   this->step_pin_->digital_write(false);

esphome/components/bme280/bme280.cpp

@@ -88,7 +88,10 @@ void BME280Component::setup() {
 
   // 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->component_state_ & COMPONENT_STATE_MASK) == COMPONENT_STATE_FAILED) {
+    this->component_state_ &= ~COMPONENT_STATE_MASK;
+    this->component_state_ |= COMPONENT_STATE_CONSTRUCTION;
+  }
 
   if (!this->read_byte(BME280_REGISTER_CHIPID, &chip_id)) {
     this->error_code_ = COMMUNICATION_FAILED;

esphome/components/bmp280/bmp280.cpp

@@ -1,4 +1,5 @@
 #include "bmp280.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -11,8 +12,11 @@ static const uint8_t BMP280_REGISTER_CONTROL = 0xF4;
 static const uint8_t BMP280_REGISTER_CONFIG = 0xF5;
 static const uint8_t BMP280_REGISTER_PRESSUREDATA = 0xF7;
 static const uint8_t BMP280_REGISTER_TEMPDATA = 0xFA;
+static const uint8_t BMP280_REGISTER_RESET = 0xE0;
 
 static const uint8_t BMP280_MODE_FORCED = 0b01;
+static const uint8_t BMP280_SOFT_RESET = 0xB6;
+static const uint8_t BMP280_STATUS_IM_UPDATE = 0b01;
 
 inline uint16_t combine_bytes(uint8_t msb, uint8_t lsb) { return ((msb & 0xFF) << 8) | (lsb & 0xFF); }
 
@@ -66,6 +70,28 @@ void BMP280Component::setup() {
     return;
   }
 
+  // Send a soft reset.
+  if (!this->write_byte(BMP280_REGISTER_RESET, BMP280_SOFT_RESET)) {
+    this->mark_failed();
+    return;
+  }
+  // Wait until the NVM data has finished loading.
+  uint8_t status;
+  uint8_t retry = 5;
+  do {
+    delay(2);
+    if (!this->read_byte(BMP280_REGISTER_STATUS, &status)) {
+      ESP_LOGW(TAG, "Error reading status register.");
+      this->mark_failed();
+      return;
+    }
+  } while ((status & BMP280_STATUS_IM_UPDATE) && (--retry));
+  if (status & BMP280_STATUS_IM_UPDATE) {
+    ESP_LOGW(TAG, "Timeout loading NVM.");
+    this->mark_failed();
+    return;
+  }
+
   // Read calibration
   this->calibration_.t1 = this->read_u16_le_(0x88);
   this->calibration_.t2 = this->read_s16_le_(0x8A);

esphome/components/dashboard_import/__init__.py

@@ -4,7 +4,7 @@ import requests
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components.packages import validate_source_shorthand
-from esphome.const import CONF_WIFI
+from esphome.const import CONF_WIFI, CONF_REF
 from esphome.wizard import wizard_file
 from esphome.yaml_util import dump
 from esphome import git
@@ -21,19 +21,32 @@ CODEOWNERS = ["@esphome/core"]
 def validate_import_url(value):
     value = cv.string_strict(value)
     value = cv.Length(max=255)(value)
-    # ignore result, only check if it's a valid shorthand
     validate_source_shorthand(value)
     return value
 
 
+def validate_full_url(config):
+    if not config[CONF_IMPORT_FULL_CONFIG]:
+        return config
+    source = validate_source_shorthand(config[CONF_PACKAGE_IMPORT_URL])
+    if CONF_REF not in source:
+        raise cv.Invalid(
+            "Must specify a ref (branch or tag) to import from when importing full config"
+        )
+    return config
+
+
 CONF_PACKAGE_IMPORT_URL = "package_import_url"
 CONF_IMPORT_FULL_CONFIG = "import_full_config"
 
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.Required(CONF_PACKAGE_IMPORT_URL): validate_import_url,
-        cv.Optional(CONF_IMPORT_FULL_CONFIG, default=False): cv.boolean,
-    }
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.Required(CONF_PACKAGE_IMPORT_URL): validate_import_url,
+            cv.Optional(CONF_IMPORT_FULL_CONFIG, default=False): cv.boolean,
+        }
+    ),
+    validate_full_url,
 )
 
 WIFI_CONFIG = """
@@ -49,7 +62,7 @@ async def to_code(config):
     url = config[CONF_PACKAGE_IMPORT_URL]
     if config[CONF_IMPORT_FULL_CONFIG]:
         url += "?full_config"
-    cg.add(dashboard_import_ns.set_package_import_url(config[CONF_PACKAGE_IMPORT_URL]))
+    cg.add(dashboard_import_ns.set_package_import_url(url))
 
 
 def import_config(

esphome/components/esp32/gpio.cpp

@@ -95,7 +95,7 @@ void ESP32InternalGPIOPin::pin_mode(gpio::Flags flags) {
   // can't call gpio_config here because that logs in esp-idf which may cause issues
   gpio_set_direction(pin_, flags_to_mode(flags));
   gpio_pull_mode_t pull_mode = GPIO_FLOATING;
-  if (flags & (gpio::FLAG_PULLUP | gpio::FLAG_PULLDOWN)) {
+  if ((flags & gpio::FLAG_PULLUP) && (flags & gpio::FLAG_PULLDOWN)) {
     pull_mode = GPIO_PULLUP_PULLDOWN;
   } else if (flags & gpio::FLAG_PULLUP) {
     pull_mode = GPIO_PULLUP_ONLY;
@@ -128,7 +128,7 @@ void IRAM_ATTR ISRInternalGPIOPin::pin_mode(gpio::Flags flags) {
   auto *arg = reinterpret_cast<ISRPinArg *>(arg_);
   gpio_set_direction(arg->pin, flags_to_mode(flags));
   gpio_pull_mode_t pull_mode = GPIO_FLOATING;
-  if (flags & (gpio::FLAG_PULLUP | gpio::FLAG_PULLDOWN)) {
+  if ((flags & gpio::FLAG_PULLUP) && (flags & gpio::FLAG_PULLDOWN)) {
     pull_mode = GPIO_PULLUP_PULLDOWN;
   } else if (flags & gpio::FLAG_PULLUP) {
     pull_mode = GPIO_PULLUP_ONLY;

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -132,16 +132,16 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         this->set_state(espbt::ClientState::IDLE);
         break;
       }
-      if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
-        this->set_state(espbt::ClientState::CONNECTED);
-        this->state_ = espbt::ClientState::ESTABLISHED;
-        break;
-      }
       auto ret = esp_ble_gattc_send_mtu_req(this->gattc_if_, param->open.conn_id);
       if (ret) {
         ESP_LOGW(TAG, "[%d] [%s] esp_ble_gattc_send_mtu_req failed, status=%x", this->connection_index_,
                  this->address_str_.c_str(), ret);
       }
+      if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
+        this->set_state(espbt::ClientState::CONNECTED);
+        this->state_ = espbt::ClientState::ESTABLISHED;
+        break;
+      }
       esp_ble_gattc_search_service(esp_gattc_if, param->cfg_mtu.conn_id, nullptr);
       break;
     }

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -706,11 +706,7 @@ void ESPBTDevice::parse_adv_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_p
   while (offset + 2 < len) {
     const uint8_t field_length = payload[offset++];  // First byte is length of adv record
     if (field_length == 0) {
-      if (offset < param.adv_data_len && param.scan_rsp_len > 0) {  // Zero padded advertisement data
-        offset = param.adv_data_len;
-        continue;
-      }
-      break;
+      continue;  // Possible zero padded advertisement data
     }
 
     // first byte of adv record is adv record type

esphome/components/esp32_can/esp32_can.cpp

@@ -2,7 +2,7 @@
 #include "esp32_can.h"
 #include "esphome/core/log.h"
 
-#include <driver/can.h>
+#include <driver/twai.h>
 
 // WORKAROUND, because CAN_IO_UNUSED is just defined as (-1) in this version
 // of the framework which does not work with -fpermissive
@@ -14,25 +14,25 @@ namespace esp32_can {
 
 static const char *const TAG = "esp32_can";
 
-static bool get_bitrate(canbus::CanSpeed bitrate, can_timing_config_t *t_config) {
+static bool get_bitrate(canbus::CanSpeed bitrate, twai_timing_config_t *t_config) {
   switch (bitrate) {
     case canbus::CAN_50KBPS:
-      *t_config = (can_timing_config_t) CAN_TIMING_CONFIG_50KBITS();
+      *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_50KBITS();
       return true;
     case canbus::CAN_100KBPS:
-      *t_config = (can_timing_config_t) CAN_TIMING_CONFIG_100KBITS();
+      *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_100KBITS();
       return true;
     case canbus::CAN_125KBPS:
-      *t_config = (can_timing_config_t) CAN_TIMING_CONFIG_125KBITS();
+      *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_125KBITS();
       return true;
     case canbus::CAN_250KBPS:
-      *t_config = (can_timing_config_t) CAN_TIMING_CONFIG_250KBITS();
+      *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_250KBITS();
       return true;
     case canbus::CAN_500KBPS:
-      *t_config = (can_timing_config_t) CAN_TIMING_CONFIG_500KBITS();
+      *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_500KBITS();
       return true;
     case canbus::CAN_1000KBPS:
-      *t_config = (can_timing_config_t) CAN_TIMING_CONFIG_1MBITS();
+      *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_1MBITS();
       return true;
     default:
       return false;
@@ -40,10 +40,10 @@ static bool get_bitrate(canbus::CanSpeed bitrate, can_timing_config_t *t_config)
 }
 
 bool ESP32Can::setup_internal() {
-  can_general_config_t g_config =
-      CAN_GENERAL_CONFIG_DEFAULT((gpio_num_t) this->tx_, (gpio_num_t) this->rx_, CAN_MODE_NORMAL);
-  can_filter_config_t f_config = CAN_FILTER_CONFIG_ACCEPT_ALL();
-  can_timing_config_t t_config;
+  twai_general_config_t g_config =
+      TWAI_GENERAL_CONFIG_DEFAULT((gpio_num_t) this->tx_, (gpio_num_t) this->rx_, TWAI_MODE_NORMAL);
+  twai_filter_config_t f_config = TWAI_FILTER_CONFIG_ACCEPT_ALL();
+  twai_timing_config_t t_config;
 
   if (!get_bitrate(this->bit_rate_, &t_config)) {
     // invalid bit rate
@@ -51,15 +51,15 @@ bool ESP32Can::setup_internal() {
     return false;
   }
 
-  // Install CAN driver
-  if (can_driver_install(&g_config, &t_config, &f_config) != ESP_OK) {
+  // Install TWAI driver
+  if (twai_driver_install(&g_config, &t_config, &f_config) != ESP_OK) {
     // Failed to install driver
     this->mark_failed();
     return false;
   }
 
-  // Start CAN driver
-  if (can_start() != ESP_OK) {
+  // Start TWAI driver
+  if (twai_start() != ESP_OK) {
     // Failed to start driver
     this->mark_failed();
     return false;
@@ -72,15 +72,15 @@ canbus::Error ESP32Can::send_message(struct canbus::CanFrame *frame) {
     return canbus::ERROR_FAILTX;
   }
 
-  uint32_t flags = CAN_MSG_FLAG_NONE;
+  uint32_t flags = TWAI_MSG_FLAG_NONE;
   if (frame->use_extended_id) {
-    flags |= CAN_MSG_FLAG_EXTD;
+    flags |= TWAI_MSG_FLAG_EXTD;
   }
   if (frame->remote_transmission_request) {
-    flags |= CAN_MSG_FLAG_RTR;
+    flags |= TWAI_MSG_FLAG_RTR;
   }
 
-  can_message_t message = {
+  twai_message_t message = {
       .flags = flags,
       .identifier = frame->can_id,
       .data_length_code = frame->can_data_length_code,
@@ -89,7 +89,7 @@ canbus::Error ESP32Can::send_message(struct canbus::CanFrame *frame) {
     memcpy(message.data, frame->data, frame->can_data_length_code);
   }
 
-  if (can_transmit(&message, pdMS_TO_TICKS(1000)) == ESP_OK) {
+  if (twai_transmit(&message, pdMS_TO_TICKS(1000)) == ESP_OK) {
     return canbus::ERROR_OK;
   } else {
     return canbus::ERROR_ALLTXBUSY;
@@ -97,15 +97,15 @@ canbus::Error ESP32Can::send_message(struct canbus::CanFrame *frame) {
 }
 
 canbus::Error ESP32Can::read_message(struct canbus::CanFrame *frame) {
-  can_message_t message;
+  twai_message_t message;
 
-  if (can_receive(&message, 0) != ESP_OK) {
+  if (twai_receive(&message, 0) != ESP_OK) {
     return canbus::ERROR_NOMSG;
   }
 
   frame->can_id = message.identifier;
-  frame->use_extended_id = message.flags & CAN_MSG_FLAG_EXTD;
-  frame->remote_transmission_request = message.flags & CAN_MSG_FLAG_RTR;
+  frame->use_extended_id = message.flags & TWAI_MSG_FLAG_EXTD;
+  frame->remote_transmission_request = message.flags & TWAI_MSG_FLAG_RTR;
   frame->can_data_length_code = message.data_length_code;
 
   if (!frame->remote_transmission_request) {

esphome/components/modbus/modbus.cpp

@@ -47,7 +47,7 @@ bool Modbus::parse_modbus_byte_(uint8_t byte) {
   uint8_t function_code = raw[1];
   // Byte 2: Size (with modbus rtu function code 4/3)
   // See also https://en.wikipedia.org/wiki/Modbus
-  if (at <= 2)
+  if (at == 2)
     return true;
 
   uint8_t data_len = raw[2];

esphome/components/slow_pwm/slow_pwm_output.cpp

@@ -70,7 +70,7 @@ void SlowPWMOutput::dump_config() {
 void SlowPWMOutput::write_state(float state) {
   this->state_ = state;
   if (this->restart_cycle_on_state_change_)
-    this->restart_cycle();
+    this->period_start_time_ = millis();
 }
 
 }  // namespace slow_pwm

esphome/components/slow_pwm/slow_pwm_output.h

@@ -14,7 +14,6 @@ class SlowPWMOutput : public output::FloatOutput, public Component {
   void set_restart_cycle_on_state_change(bool restart_cycle_on_state_change) {
     restart_cycle_on_state_change_ = restart_cycle_on_state_change;
   }
-  void restart_cycle() { this->period_start_time_ = millis(); }
 
   /// Initialize pin
   void setup() override;

esphome/components/toshiba/toshiba.cpp

@@ -124,6 +124,9 @@ void ToshibaClimate::setup() {
   // Set supported modes & temperatures based on model
   this->minimum_temperature_ = this->temperature_min_();
   this->maximum_temperature_ = this->temperature_max_();
+  this->supports_dry_ = this->toshiba_supports_dry_();
+  this->supports_fan_only_ = this->toshiba_supports_fan_only_();
+  this->fan_modes_ = this->toshiba_fan_modes_();
   this->swing_modes_ = this->toshiba_swing_modes_();
   // Never send nan to HA
   if (std::isnan(this->target_temperature))
@@ -175,39 +178,12 @@ void ToshibaClimate::transmit_generic_() {
       mode = TOSHIBA_MODE_COOL;
       break;
 
-    case climate::CLIMATE_MODE_DRY:
-      mode = TOSHIBA_MODE_DRY;
-      break;
-
-    case climate::CLIMATE_MODE_FAN_ONLY:
-      mode = TOSHIBA_MODE_FAN_ONLY;
-      break;
-
     case climate::CLIMATE_MODE_HEAT_COOL:
     default:
       mode = TOSHIBA_MODE_AUTO;
   }
 
-  uint8_t fan;
-  switch (this->fan_mode.value()) {
-    case climate::CLIMATE_FAN_LOW:
-      fan = TOSHIBA_FAN_SPEED_1;
-      break;
-
-    case climate::CLIMATE_FAN_MEDIUM:
-      fan = TOSHIBA_FAN_SPEED_3;
-      break;
-
-    case climate::CLIMATE_FAN_HIGH:
-      fan = TOSHIBA_FAN_SPEED_5;
-      break;
-
-    case climate::CLIMATE_FAN_AUTO:
-    default:
-      fan = TOSHIBA_FAN_SPEED_AUTO;
-      break;
-  }
-  message[6] = fan | mode;
+  message[6] |= mode | TOSHIBA_FAN_SPEED_AUTO;
 
   // Zero
   message[7] = 0x00;

esphome/components/toshiba/toshiba.h

@@ -22,10 +22,7 @@ const float TOSHIBA_RAC_PT1411HWRU_TEMP_F_MAX = 86.0;
 
 class ToshibaClimate : public climate_ir::ClimateIR {
  public:
-  ToshibaClimate()
-      : climate_ir::ClimateIR(TOSHIBA_GENERIC_TEMP_C_MIN, TOSHIBA_GENERIC_TEMP_C_MAX, 1.0f, true, true,
-                              {climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM,
-                               climate::CLIMATE_FAN_HIGH}) {}
+  ToshibaClimate() : climate_ir::ClimateIR(TOSHIBA_GENERIC_TEMP_C_MIN, TOSHIBA_GENERIC_TEMP_C_MAX, 1.0f) {}
 
   void setup() override;
   void set_model(Model model) { this->model_ = model; }
@@ -49,6 +46,18 @@ class ToshibaClimate : public climate_ir::ClimateIR {
   float temperature_max_() {
     return (this->model_ == MODEL_GENERIC) ? TOSHIBA_GENERIC_TEMP_C_MAX : TOSHIBA_RAC_PT1411HWRU_TEMP_C_MAX;
   }
+  bool toshiba_supports_dry_() {
+    return ((this->model_ == MODEL_RAC_PT1411HWRU_C) || (this->model_ == MODEL_RAC_PT1411HWRU_F));
+  }
+  bool toshiba_supports_fan_only_() {
+    return ((this->model_ == MODEL_RAC_PT1411HWRU_C) || (this->model_ == MODEL_RAC_PT1411HWRU_F));
+  }
+  std::set<climate::ClimateFanMode> toshiba_fan_modes_() {
+    return (this->model_ == MODEL_GENERIC)
+               ? std::set<climate::ClimateFanMode>{}
+               : std::set<climate::ClimateFanMode>{climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW,
+                                                   climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH};
+  }
   std::set<climate::ClimateSwingMode> toshiba_swing_modes_() {
     return (this->model_ == MODEL_GENERIC)
                ? std::set<climate::ClimateSwingMode>{}

esphome/const.py

@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2023.1.0-dev"
+__version__ = "2022.12.7"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 

esphome/git.py

@@ -129,9 +129,9 @@ class GitFile:
     def raw_url(self) -> str:
         if self.ref is None:
             raise ValueError("URL has no ref")
-        if self.domain == "github":
+        if self.domain == "github.com":
             return f"https://raw.githubusercontent.com/{self.owner}/{self.repo}/{self.ref}/{self.filename}"
-        if self.domain == "gitlab":
+        if self.domain == "gitlab.com":
             return f"https://gitlab.com/{self.owner}/{self.repo}/-/raw/{self.ref}/{self.filename}"
         raise NotImplementedError(f"Git domain {self.domain} not supported")