esphome 2024.12.4__py3-none-any.whl → 2025.2.0b2__py3-none-any.whl

esphome/components/resampler/speaker/resampler_speaker.h

@@ -0,0 +1,107 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include "esphome/components/audio/audio.h"
+#include "esphome/components/audio/audio_transfer_buffer.h"
+#include "esphome/components/speaker/speaker.h"
+
+#include "esphome/core/component.h"
+
+#include <freertos/event_groups.h>
+#include <freertos/FreeRTOS.h>
+
+namespace esphome {
+namespace resampler {
+
+class ResamplerSpeaker : public Component, public speaker::Speaker {
+ public:
+  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
+  void setup() override;
+  void loop() override;
+
+  size_t play(const uint8_t *data, size_t length, TickType_t ticks_to_wait) override;
+  size_t play(const uint8_t *data, size_t length) override { return this->play(data, length, 0); }
+
+  void start() override;
+  void stop() override;
+  void finish() override;
+
+  void set_pause_state(bool pause_state) override { this->output_speaker_->set_pause_state(pause_state); }
+  bool get_pause_state() const override { return this->output_speaker_->get_pause_state(); }
+
+  bool has_buffered_data() const override;
+
+  /// @brief Mute state changes are passed to the parent's output speaker
+  void set_mute_state(bool mute_state) override;
+
+  /// @brief Volume state changes are passed to the parent's output speaker
+  void set_volume(float volume) override;
+
+  void set_output_speaker(speaker::Speaker *speaker) { this->output_speaker_ = speaker; }
+  void set_task_stack_in_psram(bool task_stack_in_psram) { this->task_stack_in_psram_ = task_stack_in_psram; }
+
+  void set_target_bits_per_sample(uint8_t target_bits_per_sample) {
+    this->target_bits_per_sample_ = target_bits_per_sample;
+  }
+  void set_target_sample_rate(uint32_t target_sample_rate) { this->target_sample_rate_ = target_sample_rate; }
+
+  void set_filters(uint16_t filters) { this->filters_ = filters; }
+  void set_taps(uint16_t taps) { this->taps_ = taps; }
+
+  void set_buffer_duration(uint32_t buffer_duration_ms) { this->buffer_duration_ms_ = buffer_duration_ms; }
+
+ protected:
+  /// @brief Starts the output speaker after setting the resampled stream info. If resampling is required, it starts the
+  /// task.
+  /// @return ESP_OK if resampling is required
+  ///         return value of start_task_() if resampling is required
+  esp_err_t start_();
+
+  /// @brief Starts the resampler task after allocating the task stack
+  /// @return ESP_OK if successful,
+  ///         ESP_ERR_NO_MEM if the task stack couldn't be allocated
+  ///         ESP_ERR_INVALID_STATE if the task wasn't created
+  esp_err_t start_task_();
+
+  /// @brief Stops the output speaker. If the resampling task is running, it sends the stop command.
+  void stop_();
+
+  /// @brief Deallocates the task stack and resets the pointers.
+  /// @return ESP_OK if successful
+  ///         ESP_ERR_INVALID_STATE if the task hasn't stopped itself
+  esp_err_t delete_task_();
+
+  inline bool requires_resampling_() const;
+  static void resample_task(void *params);
+
+  EventGroupHandle_t event_group_{nullptr};
+
+  std::weak_ptr<RingBuffer> ring_buffer_;
+
+  speaker::Speaker *output_speaker_{nullptr};
+
+  bool task_stack_in_psram_{false};
+  bool task_created_{false};
+
+  TaskHandle_t task_handle_{nullptr};
+  StaticTask_t task_stack_;
+  StackType_t *task_stack_buffer_{nullptr};
+
+  audio::AudioStreamInfo target_stream_info_;
+
+  uint16_t taps_;
+  uint16_t filters_;
+
+  uint8_t target_bits_per_sample_;
+  uint32_t target_sample_rate_;
+
+  uint32_t buffer_duration_ms_;
+
+  int32_t playback_differential_ms_{0};
+};
+
+}  // namespace resampler
+}  // namespace esphome
+
+#endif

esphome/components/resistance/resistance_sensor.h

@@ -1,8 +1,7 @@
 #pragma once
 
-#include "esphome/components/resistance_sampler/resistance_sampler.h"
-#include "esphome/components/sensor/sensor.h"
 #include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
 
 namespace esphome {
 namespace resistance {
@@ -12,7 +11,7 @@ enum ResistanceConfiguration {
   DOWNSTREAM,
 };
 
-class ResistanceSensor : public Component, public sensor::Sensor, resistance_sampler::ResistanceSampler {
+class ResistanceSensor : public Component, public sensor::Sensor {
  public:
   void set_sensor(Sensor *sensor) { sensor_ = sensor; }
   void set_configuration(ResistanceConfiguration configuration) { configuration_ = configuration; }

esphome/components/resistance/sensor.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.components import sensor, resistance_sampler
+from esphome.components import sensor
 from esphome.const import (
     CONF_REFERENCE_VOLTAGE,
     CONF_SENSOR,
@@ -9,15 +9,8 @@ from esphome.const import (
     ICON_FLASH,
 )
 
-AUTO_LOAD = ["resistance_sampler"]
-
 resistance_ns = cg.esphome_ns.namespace("resistance")
-ResistanceSensor = resistance_ns.class_(
-    "ResistanceSensor",
-    cg.Component,
-    sensor.Sensor,
-    resistance_sampler.ResistanceSampler,
-)
+ResistanceSensor = resistance_ns.class_("ResistanceSensor", cg.Component, sensor.Sensor)
 
 CONF_CONFIGURATION = "configuration"
 CONF_RESISTOR = "resistor"

esphome/components/rotary_encoder/rotary_encoder.cpp

@@ -93,13 +93,17 @@ void IRAM_ATTR HOT RotaryEncoderSensorStore::gpio_intr(RotaryEncoderSensorStore
   int8_t rotation_dir = 0;
   uint16_t new_state = STATE_LOOKUP_TABLE[input_state];
   if ((new_state & arg->resolution & STATE_HAS_INCREMENTED) != 0) {
-    if (arg->counter < arg->max_value)
-      arg->counter++;
+    if (arg->counter < arg->max_value) {
+      auto x = arg->counter + 1;
+      arg->counter = x;
+    }
     rotation_dir = 1;
   }
   if ((new_state & arg->resolution & STATE_HAS_DECREMENTED) != 0) {
-    if (arg->counter > arg->min_value)
-      arg->counter--;
+    if (arg->counter > arg->min_value) {
+      auto x = arg->counter - 1;
+      arg->counter = x;
+    }
     rotation_dir = -1;
   }
 

esphome/components/rp2040/__init__.py

@@ -27,6 +27,7 @@ from .gpio import rp2040_pin_to_code  # noqa
 _LOGGER = logging.getLogger(__name__)
 CODEOWNERS = ["@jesserockz"]
 AUTO_LOAD = ["preferences"]
+IS_TARGET_PLATFORM = True
 
 
 def set_core_data(config):

esphome/components/rp2040/gpio.h

@@ -22,6 +22,7 @@ class RP2040GPIOPin : public InternalGPIOPin {
   void detach_interrupt() const override;
   ISRInternalGPIOPin to_isr() const override;
   uint8_t get_pin() const override { return pin_; }
+  gpio::Flags get_flags() const override { return flags_; }
   bool is_inverted() const override { return inverted_; }
 
  protected:

esphome/components/rtl87xx/__init__.py

@@ -19,6 +19,8 @@ from .boards import RTL87XX_BOARD_PINS, RTL87XX_BOARDS
 
 CODEOWNERS = ["@kuba2k2"]
 AUTO_LOAD = ["libretiny"]
+IS_TARGET_PLATFORM = True
+
 
 COMPONENT_DATA = LibreTinyComponent(
     name=COMPONENT_RTL87XX,

esphome/components/sdl/binary_sensor.py

@@ -0,0 +1,270 @@
+import esphome.codegen as cg
+from esphome.components import binary_sensor
+from esphome.components.binary_sensor import BinarySensor
+import esphome.config_validation as cv
+from esphome.const import CONF_KEY
+from esphome.core import Lambda
+from esphome.cpp_generator import ExpressionStatement, RawExpression
+
+from .display import CONF_SDL_ID, Sdl
+
+CODEOWNERS = ["@bdm310"]
+
+STATE_ARG = "state"
+
+SDL_KEYMAP = {
+    "SDLK_UNKNOWN": 0,
+    "SDLK_FIRST": 0,
+    "SDLK_BACKSPACE": 8,
+    "SDLK_TAB": 9,
+    "SDLK_CLEAR": 12,
+    "SDLK_RETURN": 13,
+    "SDLK_PAUSE": 19,
+    "SDLK_ESCAPE": 27,
+    "SDLK_SPACE": 32,
+    "SDLK_EXCLAIM": 33,
+    "SDLK_QUOTEDBL": 34,
+    "SDLK_HASH": 35,
+    "SDLK_DOLLAR": 36,
+    "SDLK_AMPERSAND": 38,
+    "SDLK_QUOTE": 39,
+    "SDLK_LEFTPAREN": 40,
+    "SDLK_RIGHTPAREN": 41,
+    "SDLK_ASTERISK": 42,
+    "SDLK_PLUS": 43,
+    "SDLK_COMMA": 44,
+    "SDLK_MINUS": 45,
+    "SDLK_PERIOD": 46,
+    "SDLK_SLASH": 47,
+    "SDLK_0": 48,
+    "SDLK_1": 49,
+    "SDLK_2": 50,
+    "SDLK_3": 51,
+    "SDLK_4": 52,
+    "SDLK_5": 53,
+    "SDLK_6": 54,
+    "SDLK_7": 55,
+    "SDLK_8": 56,
+    "SDLK_9": 57,
+    "SDLK_COLON": 58,
+    "SDLK_SEMICOLON": 59,
+    "SDLK_LESS": 60,
+    "SDLK_EQUALS": 61,
+    "SDLK_GREATER": 62,
+    "SDLK_QUESTION": 63,
+    "SDLK_AT": 64,
+    "SDLK_LEFTBRACKET": 91,
+    "SDLK_BACKSLASH": 92,
+    "SDLK_RIGHTBRACKET": 93,
+    "SDLK_CARET": 94,
+    "SDLK_UNDERSCORE": 95,
+    "SDLK_BACKQUOTE": 96,
+    "SDLK_a": 97,
+    "SDLK_b": 98,
+    "SDLK_c": 99,
+    "SDLK_d": 100,
+    "SDLK_e": 101,
+    "SDLK_f": 102,
+    "SDLK_g": 103,
+    "SDLK_h": 104,
+    "SDLK_i": 105,
+    "SDLK_j": 106,
+    "SDLK_k": 107,
+    "SDLK_l": 108,
+    "SDLK_m": 109,
+    "SDLK_n": 110,
+    "SDLK_o": 111,
+    "SDLK_p": 112,
+    "SDLK_q": 113,
+    "SDLK_r": 114,
+    "SDLK_s": 115,
+    "SDLK_t": 116,
+    "SDLK_u": 117,
+    "SDLK_v": 118,
+    "SDLK_w": 119,
+    "SDLK_x": 120,
+    "SDLK_y": 121,
+    "SDLK_z": 122,
+    "SDLK_DELETE": 127,
+    "SDLK_WORLD_0": 160,
+    "SDLK_WORLD_1": 161,
+    "SDLK_WORLD_2": 162,
+    "SDLK_WORLD_3": 163,
+    "SDLK_WORLD_4": 164,
+    "SDLK_WORLD_5": 165,
+    "SDLK_WORLD_6": 166,
+    "SDLK_WORLD_7": 167,
+    "SDLK_WORLD_8": 168,
+    "SDLK_WORLD_9": 169,
+    "SDLK_WORLD_10": 170,
+    "SDLK_WORLD_11": 171,
+    "SDLK_WORLD_12": 172,
+    "SDLK_WORLD_13": 173,
+    "SDLK_WORLD_14": 174,
+    "SDLK_WORLD_15": 175,
+    "SDLK_WORLD_16": 176,
+    "SDLK_WORLD_17": 177,
+    "SDLK_WORLD_18": 178,
+    "SDLK_WORLD_19": 179,
+    "SDLK_WORLD_20": 180,
+    "SDLK_WORLD_21": 181,
+    "SDLK_WORLD_22": 182,
+    "SDLK_WORLD_23": 183,
+    "SDLK_WORLD_24": 184,
+    "SDLK_WORLD_25": 185,
+    "SDLK_WORLD_26": 186,
+    "SDLK_WORLD_27": 187,
+    "SDLK_WORLD_28": 188,
+    "SDLK_WORLD_29": 189,
+    "SDLK_WORLD_30": 190,
+    "SDLK_WORLD_31": 191,
+    "SDLK_WORLD_32": 192,
+    "SDLK_WORLD_33": 193,
+    "SDLK_WORLD_34": 194,
+    "SDLK_WORLD_35": 195,
+    "SDLK_WORLD_36": 196,
+    "SDLK_WORLD_37": 197,
+    "SDLK_WORLD_38": 198,
+    "SDLK_WORLD_39": 199,
+    "SDLK_WORLD_40": 200,
+    "SDLK_WORLD_41": 201,
+    "SDLK_WORLD_42": 202,
+    "SDLK_WORLD_43": 203,
+    "SDLK_WORLD_44": 204,
+    "SDLK_WORLD_45": 205,
+    "SDLK_WORLD_46": 206,
+    "SDLK_WORLD_47": 207,
+    "SDLK_WORLD_48": 208,
+    "SDLK_WORLD_49": 209,
+    "SDLK_WORLD_50": 210,
+    "SDLK_WORLD_51": 211,
+    "SDLK_WORLD_52": 212,
+    "SDLK_WORLD_53": 213,
+    "SDLK_WORLD_54": 214,
+    "SDLK_WORLD_55": 215,
+    "SDLK_WORLD_56": 216,
+    "SDLK_WORLD_57": 217,
+    "SDLK_WORLD_58": 218,
+    "SDLK_WORLD_59": 219,
+    "SDLK_WORLD_60": 220,
+    "SDLK_WORLD_61": 221,
+    "SDLK_WORLD_62": 222,
+    "SDLK_WORLD_63": 223,
+    "SDLK_WORLD_64": 224,
+    "SDLK_WORLD_65": 225,
+    "SDLK_WORLD_66": 226,
+    "SDLK_WORLD_67": 227,
+    "SDLK_WORLD_68": 228,
+    "SDLK_WORLD_69": 229,
+    "SDLK_WORLD_70": 230,
+    "SDLK_WORLD_71": 231,
+    "SDLK_WORLD_72": 232,
+    "SDLK_WORLD_73": 233,
+    "SDLK_WORLD_74": 234,
+    "SDLK_WORLD_75": 235,
+    "SDLK_WORLD_76": 236,
+    "SDLK_WORLD_77": 237,
+    "SDLK_WORLD_78": 238,
+    "SDLK_WORLD_79": 239,
+    "SDLK_WORLD_80": 240,
+    "SDLK_WORLD_81": 241,
+    "SDLK_WORLD_82": 242,
+    "SDLK_WORLD_83": 243,
+    "SDLK_WORLD_84": 244,
+    "SDLK_WORLD_85": 245,
+    "SDLK_WORLD_86": 246,
+    "SDLK_WORLD_87": 247,
+    "SDLK_WORLD_88": 248,
+    "SDLK_WORLD_89": 249,
+    "SDLK_WORLD_90": 250,
+    "SDLK_WORLD_91": 251,
+    "SDLK_WORLD_92": 252,
+    "SDLK_WORLD_93": 253,
+    "SDLK_WORLD_94": 254,
+    "SDLK_WORLD_95": 255,
+    "SDLK_KP0": 256,
+    "SDLK_KP1": 257,
+    "SDLK_KP2": 258,
+    "SDLK_KP3": 259,
+    "SDLK_KP4": 260,
+    "SDLK_KP5": 261,
+    "SDLK_KP6": 262,
+    "SDLK_KP7": 263,
+    "SDLK_KP8": 264,
+    "SDLK_KP9": 265,
+    "SDLK_KP_PERIOD": 266,
+    "SDLK_KP_DIVIDE": 267,
+    "SDLK_KP_MULTIPLY": 268,
+    "SDLK_KP_MINUS": 269,
+    "SDLK_KP_PLUS": 270,
+    "SDLK_KP_ENTER": 271,
+    "SDLK_KP_EQUALS": 272,
+    "SDLK_UP": 273,
+    "SDLK_DOWN": 274,
+    "SDLK_RIGHT": 275,
+    "SDLK_LEFT": 276,
+    "SDLK_INSERT": 277,
+    "SDLK_HOME": 278,
+    "SDLK_END": 279,
+    "SDLK_PAGEUP": 280,
+    "SDLK_PAGEDOWN": 281,
+    "SDLK_F1": 282,
+    "SDLK_F2": 283,
+    "SDLK_F3": 284,
+    "SDLK_F4": 285,
+    "SDLK_F5": 286,
+    "SDLK_F6": 287,
+    "SDLK_F7": 288,
+    "SDLK_F8": 289,
+    "SDLK_F9": 290,
+    "SDLK_F10": 291,
+    "SDLK_F11": 292,
+    "SDLK_F12": 293,
+    "SDLK_F13": 294,
+    "SDLK_F14": 295,
+    "SDLK_F15": 296,
+    "SDLK_NUMLOCK": 300,
+    "SDLK_CAPSLOCK": 301,
+    "SDLK_SCROLLOCK": 302,
+    "SDLK_RSHIFT": 303,
+    "SDLK_LSHIFT": 304,
+    "SDLK_RCTRL": 305,
+    "SDLK_LCTRL": 306,
+    "SDLK_RALT": 307,
+    "SDLK_LALT": 308,
+    "SDLK_RMETA": 309,
+    "SDLK_LMETA": 310,
+    "SDLK_LSUPER": 311,
+    "SDLK_RSUPER": 312,
+    "SDLK_MODE": 313,
+    "SDLK_COMPOSE": 314,
+    "SDLK_HELP": 315,
+    "SDLK_PRINT": 316,
+    "SDLK_SYSREQ": 317,
+    "SDLK_BREAK": 318,
+    "SDLK_MENU": 319,
+    "SDLK_POWER": 320,
+    "SDLK_EURO": 321,
+    "SDLK_UNDO": 322,
+}
+
+CONFIG_SCHEMA = (
+    binary_sensor.binary_sensor_schema(BinarySensor)
+    .extend(
+        {
+            cv.Required(CONF_KEY): cv.enum(SDL_KEYMAP),
+            cv.GenerateID(CONF_SDL_ID): cv.use_id(Sdl),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+async def to_code(config):
+    var = await binary_sensor.new_binary_sensor(config)
+    parent = await cg.get_variable(config[CONF_SDL_ID])
+    listener = Lambda(
+        str(ExpressionStatement(var.publish_state(RawExpression(STATE_ARG))))
+    )
+    listener = await cg.process_lambda(listener, [(cg.bool_, STATE_ARG)])
+    cg.add(parent.add_key_listener(config[CONF_KEY], listener))

esphome/components/sdl/sdl_esphome.cpp

@@ -61,6 +61,12 @@ void Sdl::draw_pixel_at(int x, int y, Color color) {
     this->y_high_ = y;
 }
 
+void Sdl::process_key(uint32_t keycode, bool down) {
+  auto callback = this->key_callbacks_.find(keycode);
+  if (callback != this->key_callbacks_.end())
+    callback->second(down);
+}
+
 void Sdl::loop() {
   SDL_Event e;
   if (SDL_PollEvent(&e)) {
@@ -87,6 +93,16 @@ void Sdl::loop() {
         }
         break;
 
+      case SDL_KEYDOWN:
+        ESP_LOGD(TAG, "keydown %d", e.key.keysym.sym);
+        this->process_key(e.key.keysym.sym, true);
+        break;
+
+      case SDL_KEYUP:
+        ESP_LOGD(TAG, "keyup %d", e.key.keysym.sym);
+        this->process_key(e.key.keysym.sym, false);
+        break;
+
       case SDL_WINDOWEVENT:
         switch (e.window.event) {
           case SDL_WINDOWEVENT_SIZE_CHANGED:

esphome/components/sdl/sdl_esphome.h

@@ -7,6 +7,7 @@
 #include "esphome/components/display/display.h"
 #define SDL_MAIN_HANDLED
 #include "SDL.h"
+#include <map>
 
 namespace esphome {
 namespace sdl {
@@ -22,6 +23,7 @@ class Sdl : public display::Display {
   void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
                       display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
   void draw_pixel_at(int x, int y, Color color) override;
+  void process_key(uint32_t keycode, bool down);
   void set_dimensions(uint16_t width, uint16_t height) {
     this->width_ = width;
     this->height_ = height;
@@ -30,6 +32,12 @@ class Sdl : public display::Display {
   int get_height() override { return this->height_; }
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
   void dump_config() override { LOG_DISPLAY("", "SDL", this); }
+  void add_key_listener(int32_t keycode, std::function<void(bool)> &&callback) {
+    if (!this->key_callbacks_.count(keycode)) {
+      this->key_callbacks_[keycode] = CallbackManager<void(bool)>();
+    }
+    this->key_callbacks_[keycode].add(std::move(callback));
+  }
 
   int mouse_x{};
   int mouse_y{};
@@ -48,6 +56,7 @@ class Sdl : public display::Display {
   uint16_t y_low_{0};
   uint16_t x_high_{0};
   uint16_t y_high_{0};
+  std::map<int32_t, CallbackManager<void(bool)>> key_callbacks_{};
 };
 }  // namespace sdl
 }  // namespace esphome

esphome/components/seeed_mr60bha2/binary_sensor.py

@@ -0,0 +1,25 @@
+import esphome.codegen as cg
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    DEVICE_CLASS_OCCUPANCY,
+    CONF_HAS_TARGET,
+)
+from . import CONF_MR60BHA2_ID, MR60BHA2Component
+
+DEPENDENCIES = ["seeed_mr60bha2"]
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_MR60BHA2_ID): cv.use_id(MR60BHA2Component),
+    cv.Optional(CONF_HAS_TARGET): binary_sensor.binary_sensor_schema(
+        device_class=DEVICE_CLASS_OCCUPANCY, icon="mdi:motion-sensor"
+    ),
+}
+
+
+async def to_code(config):
+    mr60bha2_component = await cg.get_variable(config[CONF_MR60BHA2_ID])
+
+    if has_target_config := config.get(CONF_HAS_TARGET):
+        sens = await binary_sensor.new_binary_sensor(has_target_config)
+        cg.add(mr60bha2_component.set_has_target_binary_sensor(sens))

esphome/components/seeed_mr60bha2/seeed_mr60bha2.cpp

@@ -1,6 +1,7 @@
 #include "seeed_mr60bha2.h"
 #include "esphome/core/log.h"
 
+#include <cinttypes>
 #include <utility>
 
 namespace esphome {
@@ -12,10 +13,14 @@ static const char *const TAG = "seeed_mr60bha2";
 // items in an easy-to-read format, including the configuration key-value pairs.
 void MR60BHA2Component::dump_config() {
   ESP_LOGCONFIG(TAG, "MR60BHA2:");
+#ifdef USE_BINARY_SENSOR
+  LOG_BINARY_SENSOR(" ", "People Exist Binary Sensor", this->has_target_binary_sensor_);
+#endif
 #ifdef USE_SENSOR
   LOG_SENSOR(" ", "Breath Rate Sensor", this->breath_rate_sensor_);
   LOG_SENSOR(" ", "Heart Rate Sensor", this->heart_rate_sensor_);
   LOG_SENSOR(" ", "Distance Sensor", this->distance_sensor_);
+  LOG_SENSOR(" ", "Target Number Sensor", this->num_targets_sensor_);
 #endif
 }
 
@@ -94,7 +99,8 @@ bool MR60BHA2Component::validate_message_() {
   uint16_t frame_type = encode_uint16(data[5], data[6]);
 
   if (frame_type != BREATH_RATE_TYPE_BUFFER && frame_type != HEART_RATE_TYPE_BUFFER &&
-      frame_type != DISTANCE_TYPE_BUFFER) {
+      frame_type != DISTANCE_TYPE_BUFFER && frame_type != PEOPLE_EXIST_TYPE_BUFFER &&
+      frame_type != PRINT_CLOUD_BUFFER) {
     return false;
   }
 
@@ -144,6 +150,18 @@ void MR60BHA2Component::process_frame_(uint16_t frame_id, uint16_t frame_type, c
         }
       }
       break;
+    case PEOPLE_EXIST_TYPE_BUFFER:
+      if (this->has_target_binary_sensor_ != nullptr && length >= 2) {
+        uint16_t has_target_int = encode_uint16(data[1], data[0]);
+        this->has_target_binary_sensor_->publish_state(has_target_int);
+        if (has_target_int == 0) {
+          this->breath_rate_sensor_->publish_state(0.0);
+          this->heart_rate_sensor_->publish_state(0.0);
+          this->distance_sensor_->publish_state(0.0);
+          this->num_targets_sensor_->publish_state(0);
+        }
+      }
+      break;
     case HEART_RATE_TYPE_BUFFER:
       if (this->heart_rate_sensor_ != nullptr && length >= 4) {
         uint32_t current_heart_rate_int = encode_uint32(data[3], data[2], data[1], data[0]);
@@ -155,7 +173,7 @@ void MR60BHA2Component::process_frame_(uint16_t frame_id, uint16_t frame_type, c
       }
       break;
     case DISTANCE_TYPE_BUFFER:
-      if (!data[0]) {
+      if (data[0] != 0) {
         if (this->distance_sensor_ != nullptr && length >= 8) {
           uint32_t current_distance_int = encode_uint32(data[7], data[6], data[5], data[4]);
           float distance_float;
@@ -164,6 +182,12 @@ void MR60BHA2Component::process_frame_(uint16_t frame_id, uint16_t frame_type, c
         }
       }
       break;
+    case PRINT_CLOUD_BUFFER:
+      if (this->num_targets_sensor_ != nullptr && length >= 4) {
+        uint32_t current_num_targets_int = encode_uint32(data[3], data[2], data[1], data[0]);
+        this->num_targets_sensor_->publish_state(current_num_targets_int);
+      }
+      break;
     default:
       break;
   }

esphome/components/seeed_mr60bha2/seeed_mr60bha2.h

@@ -1,6 +1,9 @@
 #pragma once
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
+#ifdef USE_BINARY_SENSOR
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#endif
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"
 #endif
@@ -12,37 +15,23 @@
 
 namespace esphome {
 namespace seeed_mr60bha2 {
-
-static const uint8_t DATA_BUF_MAX_SIZE = 12;
-static const uint8_t FRAME_BUF_MAX_SIZE = 21;
-static const uint8_t LEN_TO_HEAD_CKSUM = 8;
-static const uint8_t LEN_TO_DATA_FRAME = 9;
-
 static const uint8_t FRAME_HEADER_BUFFER = 0x01;
 static const uint16_t BREATH_RATE_TYPE_BUFFER = 0x0A14;
+static const uint16_t PEOPLE_EXIST_TYPE_BUFFER = 0x0F09;
 static const uint16_t HEART_RATE_TYPE_BUFFER = 0x0A15;
 static const uint16_t DISTANCE_TYPE_BUFFER = 0x0A16;
-
-enum FrameLocation {
-  LOCATE_FRAME_HEADER,
-  LOCATE_ID_FRAME1,
-  LOCATE_ID_FRAME2,
-  LOCATE_LENGTH_FRAME_H,
-  LOCATE_LENGTH_FRAME_L,
-  LOCATE_TYPE_FRAME1,
-  LOCATE_TYPE_FRAME2,
-  LOCATE_HEAD_CKSUM_FRAME,  // Header checksum: [from the first byte to the previous byte of the HEAD_CKSUM bit]
-  LOCATE_DATA_FRAME,
-  LOCATE_DATA_CKSUM_FRAME,  // Data checksum: [from the first to the previous byte of the DATA_CKSUM bit]
-  LOCATE_PROCESS_FRAME,
-};
+static const uint16_t PRINT_CLOUD_BUFFER = 0x0A04;
 
 class MR60BHA2Component : public Component,
                           public uart::UARTDevice {  // The class name must be the name defined by text_sensor.py
+#ifdef USE_BINARY_SENSOR
+  SUB_BINARY_SENSOR(has_target);
+#endif
 #ifdef USE_SENSOR
   SUB_SENSOR(breath_rate);
   SUB_SENSOR(heart_rate);
   SUB_SENSOR(distance);
+  SUB_SENSOR(num_targets);
 #endif
 
  public: