esphome 2024.7.2__py3-none-any.whl → 2024.8.0__py3-none-any.whl

esphome/components/m5stack_8angle/binary_sensor/m5stack_8angle_binary_sensor.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#include "esphome/core/component.h"
+
+#include "../m5stack_8angle.h"
+
+namespace esphome {
+namespace m5stack_8angle {
+
+class M5Stack8AngleSwitchBinarySensor : public binary_sensor::BinarySensor,
+                                        public PollingComponent,
+                                        public Parented<M5Stack8AngleComponent> {
+ public:
+  void update() override;
+};
+
+}  // namespace m5stack_8angle
+}  // namespace esphome

esphome/components/m5stack_8angle/light/__init__.py

@@ -0,0 +1,31 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import light
+
+from esphome.const import CONF_OUTPUT_ID
+
+from .. import M5Stack8AngleComponent, m5stack_8angle_ns, CONF_M5STACK_8ANGLE_ID
+
+
+M5Stack8AngleLightsComponent = m5stack_8angle_ns.class_(
+    "M5Stack8AngleLightOutput",
+    light.AddressableLight,
+)
+
+
+CONFIG_SCHEMA = cv.All(
+    light.ADDRESSABLE_LIGHT_SCHEMA.extend(
+        {
+            cv.GenerateID(CONF_M5STACK_8ANGLE_ID): cv.use_id(M5Stack8AngleComponent),
+            cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(M5Stack8AngleLightsComponent),
+        }
+    )
+)
+
+
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_M5STACK_8ANGLE_ID])
+    lights = cg.new_Pvariable(config[CONF_OUTPUT_ID])
+    await light.register_light(lights, config)
+    await cg.register_component(lights, config)
+    cg.add(lights.set_parent(hub))

esphome/components/m5stack_8angle/light/m5stack_8angle_light.cpp

@@ -0,0 +1,45 @@
+#include "m5stack_8angle_light.h"
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace m5stack_8angle {
+
+static const char *const TAG = "m5stack_8angle.light";
+
+void M5Stack8AngleLightOutput::setup() {
+  ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
+  this->buf_ = allocator.allocate(M5STACK_8ANGLE_NUM_LEDS * M5STACK_8ANGLE_BYTES_PER_LED);
+  if (this->buf_ == nullptr) {
+    ESP_LOGE(TAG, "Failed to allocate buffer of size %u", M5STACK_8ANGLE_NUM_LEDS * M5STACK_8ANGLE_BYTES_PER_LED);
+    this->mark_failed();
+    return;
+  };
+  memset(this->buf_, 0xFF, M5STACK_8ANGLE_NUM_LEDS * M5STACK_8ANGLE_BYTES_PER_LED);
+
+  this->effect_data_ = allocator.allocate(M5STACK_8ANGLE_NUM_LEDS);
+  if (this->effect_data_ == nullptr) {
+    ESP_LOGE(TAG, "Failed to allocate effect data of size %u", M5STACK_8ANGLE_NUM_LEDS);
+    this->mark_failed();
+    return;
+  };
+  memset(this->effect_data_, 0x00, M5STACK_8ANGLE_NUM_LEDS);
+}
+
+void M5Stack8AngleLightOutput::write_state(light::LightState *state) {
+  for (int i = 0; i < M5STACK_8ANGLE_NUM_LEDS;
+       i++) {  // write one LED at a time, otherwise the message will be truncated
+    this->parent_->write_register(M5STACK_8ANGLE_REGISTER_RGB_24B + i * M5STACK_8ANGLE_BYTES_PER_LED,
+                                  this->buf_ + i * M5STACK_8ANGLE_BYTES_PER_LED, M5STACK_8ANGLE_BYTES_PER_LED);
+  }
+}
+
+light::ESPColorView M5Stack8AngleLightOutput::get_view_internal(int32_t index) const {
+  size_t pos = index * M5STACK_8ANGLE_BYTES_PER_LED;
+  // red, green, blue, white, effect_data, color_correction
+  return {this->buf_ + pos, this->buf_ + pos + 1,       this->buf_ + pos + 2,
+          nullptr,          this->effect_data_ + index, &this->correction_};
+}
+
+}  // namespace m5stack_8angle
+}  // namespace esphome

esphome/components/m5stack_8angle/light/m5stack_8angle_light.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "esphome/components/light/addressable_light.h"
+#include "esphome/components/light/light_output.h"
+
+#include "../m5stack_8angle.h"
+
+namespace esphome {
+namespace m5stack_8angle {
+
+static const uint8_t M5STACK_8ANGLE_NUM_LEDS = 9;
+static const uint8_t M5STACK_8ANGLE_BYTES_PER_LED = 4;
+
+class M5Stack8AngleLightOutput : public light::AddressableLight, public Parented<M5Stack8AngleComponent> {
+ public:
+  void setup() override;
+
+  void write_state(light::LightState *state) override;
+
+  int32_t size() const override { return M5STACK_8ANGLE_NUM_LEDS; }
+  light::LightTraits get_traits() override {
+    auto traits = light::LightTraits();
+    traits.set_supported_color_modes({light::ColorMode::RGB});
+    return traits;
+  };
+
+  void clear_effect_data() override { memset(this->effect_data_, 0x00, M5STACK_8ANGLE_NUM_LEDS); };
+
+ protected:
+  light::ESPColorView get_view_internal(int32_t index) const override;
+
+  uint8_t *buf_{nullptr};
+  uint8_t *effect_data_{nullptr};
+};
+
+}  // namespace m5stack_8angle
+}  // namespace esphome

esphome/components/m5stack_8angle/m5stack_8angle.cpp

@@ -0,0 +1,74 @@
+#include "m5stack_8angle.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace m5stack_8angle {
+
+static const char *const TAG = "m5stack_8angle";
+
+void M5Stack8AngleComponent::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up M5STACK_8ANGLE...");
+  i2c::ErrorCode err;
+
+  err = this->read(nullptr, 0);
+  if (err != i2c::NO_ERROR) {
+    ESP_LOGE(TAG, "I2C error %02X...", err);
+    this->mark_failed();
+    return;
+  };
+
+  err = this->read_register(M5STACK_8ANGLE_REGISTER_FW_VERSION, &this->fw_version_, 1);
+  if (err != i2c::NO_ERROR) {
+    ESP_LOGE(TAG, "I2C error %02X...", err);
+    this->mark_failed();
+    return;
+  };
+}
+
+void M5Stack8AngleComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "M5STACK_8ANGLE:");
+  LOG_I2C_DEVICE(this);
+  ESP_LOGCONFIG(TAG, "  Firmware version: %d ", this->fw_version_);
+}
+
+float M5Stack8AngleComponent::read_knob_pos(uint8_t channel, AnalogBits bits) {
+  int32_t raw_pos = this->read_knob_pos_raw(channel, bits);
+  if (raw_pos == -1) {
+    return NAN;
+  }
+  return (float) raw_pos / ((1 << bits) - 1);
+}
+
+int32_t M5Stack8AngleComponent::read_knob_pos_raw(uint8_t channel, AnalogBits bits) {
+  uint16_t knob_pos = 0;
+  i2c::ErrorCode err;
+  if (bits == BITS_8) {
+    err = this->read_register(M5STACK_8ANGLE_REGISTER_ANALOG_INPUT_8B + channel, (uint8_t *) &knob_pos, 1);
+  } else if (bits == BITS_12) {
+    err = this->read_register(M5STACK_8ANGLE_REGISTER_ANALOG_INPUT_12B + (channel * 2), (uint8_t *) &knob_pos, 2);
+  } else {
+    ESP_LOGE(TAG, "Invalid number of bits: %d", bits);
+    return -1;
+  }
+  if (err == i2c::NO_ERROR) {
+    return knob_pos;
+  } else {
+    return -1;
+  }
+}
+
+int8_t M5Stack8AngleComponent::read_switch() {
+  uint8_t out;
+  i2c::ErrorCode err = this->read_register(M5STACK_8ANGLE_REGISTER_DIGITAL_INPUT, (uint8_t *) &out, 1);
+  if (err == i2c::NO_ERROR) {
+    return out ? 1 : 0;
+  } else {
+    return -1;
+  }
+}
+
+float M5Stack8AngleComponent::get_setup_priority() const { return setup_priority::DATA; }
+
+}  // namespace m5stack_8angle
+}  // namespace esphome

esphome/components/m5stack_8angle/m5stack_8angle.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace m5stack_8angle {
+
+static const uint8_t M5STACK_8ANGLE_REGISTER_ANALOG_INPUT_12B = 0x00;
+static const uint8_t M5STACK_8ANGLE_REGISTER_ANALOG_INPUT_8B = 0x10;
+static const uint8_t M5STACK_8ANGLE_REGISTER_DIGITAL_INPUT = 0x20;
+static const uint8_t M5STACK_8ANGLE_REGISTER_RGB_24B = 0x30;
+static const uint8_t M5STACK_8ANGLE_REGISTER_FW_VERSION = 0xFE;
+
+enum AnalogBits : uint8_t {
+  BITS_8 = 8,
+  BITS_12 = 12,
+};
+
+class M5Stack8AngleComponent : public i2c::I2CDevice, public Component {
+ public:
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+  float read_knob_pos(uint8_t channel, AnalogBits bits = AnalogBits::BITS_8);
+  int32_t read_knob_pos_raw(uint8_t channel, AnalogBits bits = AnalogBits::BITS_8);
+  int8_t read_switch();
+
+ protected:
+  uint8_t fw_version_;
+};
+
+}  // namespace m5stack_8angle
+}  // namespace esphome

esphome/components/m5stack_8angle/sensor/__init__.py

@@ -0,0 +1,66 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor
+
+from esphome.const import (
+    CONF_BIT_DEPTH,
+    CONF_CHANNEL,
+    CONF_RAW,
+    ICON_ROTATE_RIGHT,
+    STATE_CLASS_MEASUREMENT,
+)
+
+from .. import (
+    AnalogBits,
+    M5Stack8AngleComponent,
+    m5stack_8angle_ns,
+    CONF_M5STACK_8ANGLE_ID,
+)
+
+
+M5Stack8AngleKnobSensor = m5stack_8angle_ns.class_(
+    "M5Stack8AngleKnobSensor",
+    sensor.Sensor,
+    cg.PollingComponent,
+)
+
+
+BIT_DEPTHS = {
+    8: AnalogBits.BITS_8,
+    12: AnalogBits.BITS_12,
+}
+
+_validate_bits = cv.float_with_unit("bits", "bit")
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(M5Stack8AngleKnobSensor),
+            cv.GenerateID(CONF_M5STACK_8ANGLE_ID): cv.use_id(M5Stack8AngleComponent),
+            cv.Required(CONF_CHANNEL): cv.int_range(min=1, max=8),
+            cv.Optional(CONF_BIT_DEPTH, default="8bit"): cv.All(
+                _validate_bits, cv.enum(BIT_DEPTHS)
+            ),
+            cv.Optional(CONF_RAW, default=False): cv.boolean,
+        }
+    )
+    .extend(
+        sensor.sensor_schema(
+            M5Stack8AngleKnobSensor,
+            accuracy_decimals=2,
+            icon=ICON_ROTATE_RIGHT,
+            state_class=STATE_CLASS_MEASUREMENT,
+        )
+    )
+    .extend(cv.polling_component_schema("10s"))
+)
+
+
+async def to_code(config):
+    var = await sensor.new_sensor(config)
+    await cg.register_component(var, config)
+    await cg.register_parented(var, config[CONF_M5STACK_8ANGLE_ID])
+    cg.add(var.set_channel(config[CONF_CHANNEL] - 1))
+    cg.add(var.set_bit_depth(BIT_DEPTHS[config[CONF_BIT_DEPTH]]))
+    cg.add(var.set_raw(config[CONF_RAW]))

esphome/components/m5stack_8angle/sensor/m5stack_8angle_sensor.cpp

@@ -0,0 +1,24 @@
+#include "m5stack_8angle_sensor.h"
+
+namespace esphome {
+namespace m5stack_8angle {
+
+void M5Stack8AngleKnobSensor::update() {
+  if (this->parent_ != nullptr) {
+    int32_t raw_pos = this->parent_->read_knob_pos_raw(this->channel_, this->bits_);
+    if (raw_pos == -1) {
+      this->status_set_warning("Could not read knob position from M5Stack 8Angle.");
+      return;
+    }
+    if (this->raw_) {
+      this->publish_state(raw_pos);
+    } else {
+      float knob_pos = (float) raw_pos / ((1 << this->bits_) - 1);
+      this->publish_state(knob_pos);
+    }
+    this->status_clear_warning();
+  };
+}
+
+}  // namespace m5stack_8angle
+}  // namespace esphome

esphome/components/m5stack_8angle/sensor/m5stack_8angle_sensor.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/core/component.h"
+
+#include "../m5stack_8angle.h"
+
+namespace esphome {
+namespace m5stack_8angle {
+
+class M5Stack8AngleKnobSensor : public sensor::Sensor,
+                                public PollingComponent,
+                                public Parented<M5Stack8AngleComponent> {
+ public:
+  void update() override;
+  void set_channel(uint8_t channel) { this->channel_ = channel; };
+  void set_bit_depth(AnalogBits bits) { this->bits_ = bits; };
+  void set_raw(bool raw) { this->raw_ = raw; };
+
+ protected:
+  uint8_t channel_;
+  AnalogBits bits_;
+  bool raw_;
+};
+
+}  // namespace m5stack_8angle
+}  // namespace esphome

esphome/components/matrix_keypad/matrix_keypad.cpp

@@ -8,6 +8,7 @@ static const char *const TAG = "matrix_keypad";
 
 void MatrixKeypad::setup() {
   for (auto *pin : this->rows_) {
+    pin->setup();
     if (!has_diodes_) {
       pin->pin_mode(gpio::FLAG_INPUT);
     } else {
@@ -15,6 +16,7 @@ void MatrixKeypad::setup() {
     }
   }
   for (auto *pin : this->columns_) {
+    pin->setup();
     if (has_pulldowns_) {
       pin->pin_mode(gpio::FLAG_INPUT);
     } else {

esphome/components/max31856/sensor.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome.components import sensor, spi
+import esphome.config_validation as cv
 from esphome.const import (
     CONF_MAINS_FILTER,
     DEVICE_CLASS_TEMPERATURE,
@@ -15,8 +15,8 @@ MAX31856Sensor = max31856_ns.class_(
 
 MAX31865ConfigFilter = max31856_ns.enum("MAX31856ConfigFilter")
 FILTER = {
-    "50HZ": MAX31865ConfigFilter.FILTER_50HZ,
-    "60HZ": MAX31865ConfigFilter.FILTER_60HZ,
+    50: MAX31865ConfigFilter.FILTER_50HZ,
+    60: MAX31865ConfigFilter.FILTER_60HZ,
 }
 
 CONFIG_SCHEMA = (
@@ -29,8 +29,8 @@ CONFIG_SCHEMA = (
     )
     .extend(
         {
-            cv.Optional(CONF_MAINS_FILTER, default="60HZ"): cv.enum(
-                FILTER, upper=True, space=""
+            cv.Optional(CONF_MAINS_FILTER, default="60Hz"): cv.All(
+                cv.frequency, cv.enum(FILTER, int=True)
             ),
         }
     )

esphome/components/media_player/__init__.py

@@ -1,20 +1,18 @@
 from esphome import automation
-import esphome.config_validation as cv
-import esphome.codegen as cg
-
 from esphome.automation import maybe_simple_id
+import esphome.codegen as cg
+import esphome.config_validation as cv
 from esphome.const import (
     CONF_ID,
+    CONF_ON_IDLE,
     CONF_ON_STATE,
     CONF_TRIGGER_ID,
     CONF_VOLUME,
-    CONF_ON_IDLE,
 )
 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

esphome/components/media_player/automation.h

@@ -7,30 +7,24 @@ 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(); \
-      }); \
-    } \
-  };
+template<MediaPlayerCommand Command, typename... Ts>
+class MediaPlayerCommandAction : public Action<Ts...>, public Parented<MediaPlayer> {
+ public:
+  void play(Ts... x) override { this->parent_->make_call().set_command(Command).perform(); }
+};
 
-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>
+using PlayAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_PLAY, Ts...>;
+template<typename... Ts>
+using PauseAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_PAUSE, Ts...>;
+template<typename... Ts>
+using StopAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_STOP, Ts...>;
+template<typename... Ts>
+using ToggleAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_TOGGLE, Ts...>;
+template<typename... Ts>
+using VolumeUpAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_VOLUME_UP, Ts...>;
+template<typename... Ts>
+using VolumeDownAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_VOLUME_DOWN, Ts...>;
 
 template<typename... Ts> class PlayMediaAction : public Action<Ts...>, public Parented<MediaPlayer> {
   TEMPLATABLE_VALUE(std::string, media_url)
@@ -49,10 +43,20 @@ class StateTrigger : public Trigger<> {
   }
 };
 
-MEDIA_PLAYER_SIMPLE_STATE_TRIGGER(IdleTrigger, IDLE)
-MEDIA_PLAYER_SIMPLE_STATE_TRIGGER(PlayTrigger, PLAYING)
-MEDIA_PLAYER_SIMPLE_STATE_TRIGGER(PauseTrigger, PAUSED)
-MEDIA_PLAYER_SIMPLE_STATE_TRIGGER(AnnouncementTrigger, ANNOUNCING)
+template<MediaPlayerState State> class MediaPlayerStateTrigger : public Trigger<> {
+ public:
+  explicit MediaPlayerStateTrigger(MediaPlayer *player) {
+    player->add_on_state_callback([this, player]() {
+      if (player->state == State)
+        this->trigger();
+    });
+  }
+};
+
+using IdleTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_IDLE>;
+using PlayTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_PLAYING>;
+using PauseTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_PAUSED>;
+using AnnouncementTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_ANNOUNCING>;
 
 template<typename... Ts> class IsIdleCondition : public Condition<Ts...>, public Parented<MediaPlayer> {
  public:

esphome/components/micro_wake_word/__init__.py

@@ -1,39 +1,34 @@
-import logging
-
-import json
 import hashlib
-from urllib.parse import urljoin
+import json
+import logging
 from pathlib import Path
+from urllib.parse import urljoin
+
 import requests
 
-import esphome.config_validation as cv
+from esphome import automation, external_files, git
+from esphome.automation import register_action, register_condition
 import esphome.codegen as cg
-
-from esphome.core import CORE, HexInt
-
 from esphome.components import esp32, microphone
-from esphome import automation, git, external_files
-from esphome.automation import register_action, register_condition
-
-
+import esphome.config_validation as cv
 from esphome.const import (
-    __version__,
+    CONF_FILE,
     CONF_ID,
     CONF_MICROPHONE,
     CONF_MODEL,
-    CONF_URL,
-    CONF_FILE,
+    CONF_PASSWORD,
     CONF_PATH,
+    CONF_RAW_DATA_ID,
     CONF_REF,
     CONF_REFRESH,
     CONF_TYPE,
+    CONF_URL,
     CONF_USERNAME,
-    CONF_PASSWORD,
-    CONF_RAW_DATA_ID,
     TYPE_GIT,
     TYPE_LOCAL,
+    __version__,
 )
-
+from esphome.core import CORE, HexInt
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -174,12 +169,12 @@ def _convert_manifest_v1_to_v2(v1_manifest):
         CONF_SLIDING_WINDOW_AVERAGE_SIZE
     ]
     del v2_manifest[KEY_MICRO][CONF_SLIDING_WINDOW_AVERAGE_SIZE]
-    v2_manifest[KEY_MICRO][
-        CONF_TENSOR_ARENA_SIZE
-    ] = 45672  # Original Inception-based V1 manifest models require a minimum of 45672 bytes
-    v2_manifest[KEY_MICRO][
-        CONF_FEATURE_STEP_SIZE
-    ] = 20  # Original Inception-based V1 manifest models use a 20 ms feature step size
+
+    # Original Inception-based V1 manifest models require a minimum of 45672 bytes
+    v2_manifest[KEY_MICRO][CONF_TENSOR_ARENA_SIZE] = 45672
+
+    # Original Inception-based V1 manifest models use a 20 ms feature step size
+    v2_manifest[KEY_MICRO][CONF_FEATURE_STEP_SIZE] = 20
 
     return v2_manifest
 
@@ -502,7 +497,7 @@ async def to_code(config):
             )
 
     cg.add(var.set_features_step_size(manifest[KEY_MICRO][CONF_FEATURE_STEP_SIZE]))
-    cg.add_library("kahrendt/ESPMicroSpeechFeatures", "1.0.0")
+    cg.add_library("kahrendt/ESPMicroSpeechFeatures", "1.1.0")
 
 
 MICRO_WAKE_WORD_ACTION_SCHEMA = cv.Schema({cv.GenerateID(): cv.use_id(MicroWakeWord)})

esphome/components/micro_wake_word/streaming_model.cpp

@@ -148,7 +148,7 @@ WakeWordModel::WakeWordModel(const uint8_t *model_start, float probability_cutof
 };
 
 bool WakeWordModel::determine_detected() {
-  int32_t sum = 0;
+  uint32_t sum = 0;
   for (auto &prob : this->recent_streaming_probabilities_) {
     sum += prob;
   }
@@ -175,12 +175,14 @@ VADModel::VADModel(const uint8_t *model_start, float probability_cutoff, size_t
 };
 
 bool VADModel::determine_detected() {
-  uint8_t max = 0;
+  uint32_t sum = 0;
   for (auto &prob : this->recent_streaming_probabilities_) {
-    max = std::max(prob, max);
+    sum += prob;
   }
 
-  return max > this->probability_cutoff_;
+  float sliding_window_average = static_cast<float>(sum) / static_cast<float>(255 * this->sliding_window_size_);
+
+  return sliding_window_average > this->probability_cutoff_;
 }
 
 }  // namespace micro_wake_word

esphome/components/microphone/microphone.h

@@ -1,6 +1,9 @@
 #pragma once
 
-#include "esphome/core/entity_base.h"
+#include <stddef.h>
+#include <cstdint>
+#include <functional>
+#include <vector>
 #include "esphome/core/helpers.h"
 
 namespace esphome {

esphome/components/mitsubishi/mitsubishi.cpp

@@ -110,7 +110,7 @@ void MitsubishiClimate::transmit_state() {
   // Byte 15: HVAC specfic, i.e. POWERFUL, SMART SET, PLASMA, always 0x00
   // Byte 16: Constant 0x00
   // Byte 17: Checksum: SUM[Byte0...Byte16]
-  uint8_t remote_state[18] = {0x23, 0xCB, 0x26, 0x01, 0x00, 0x20, 0x08, 0x00, 0x00,
+  uint8_t remote_state[18] = {0x23, 0xCB, 0x26, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00,
                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
   switch (this->mode) {
@@ -136,6 +136,12 @@ void MitsubishiClimate::transmit_state() {
       break;
     case climate::CLIMATE_MODE_OFF:
     default:
+      remote_state[6] = MITSUBISHI_MODE_COOL;
+      remote_state[8] = MITSUBISHI_MODE_A_COOL;
+      if (this->supports_heat_) {
+        remote_state[6] = MITSUBISHI_MODE_HEAT;
+        remote_state[8] = MITSUBISHI_MODE_A_HEAT;
+      }
       remote_state[5] = MITSUBISHI_OFF;
       break;
   }