esphome 2025.4.1__py3-none-any.whl → 2025.5.0b2__py3-none-any.whl

esphome/components/pca9685/pca9685_output.cpp

@@ -101,8 +101,9 @@ void PCA9685Output::loop() {
     return;
 
   const uint16_t num_channels = this->max_channel_ - this->min_channel_ + 1;
+  const uint16_t phase_delta_begin = 4096 / num_channels;
   for (uint8_t channel = this->min_channel_; channel <= this->max_channel_; channel++) {
-    uint16_t phase_begin = uint16_t(channel - this->min_channel_) / num_channels * 4096;
+    uint16_t phase_begin = (channel - this->min_channel_) * phase_delta_begin;
     uint16_t phase_end;
     uint16_t amount = this->pwm_amounts_[channel];
     if (amount == 0) {

esphome/components/pid/climate.py

@@ -41,9 +41,8 @@ CONF_KI_MULTIPLIER = "ki_multiplier"
 CONF_KD_MULTIPLIER = "kd_multiplier"
 
 CONFIG_SCHEMA = cv.All(
-    climate.CLIMATE_SCHEMA.extend(
+    climate.climate_schema(PIDClimate).extend(
         {
-            cv.GenerateID(): cv.declare_id(PIDClimate),
             cv.Required(CONF_SENSOR): cv.use_id(sensor.Sensor),
             cv.Optional(CONF_HUMIDITY_SENSOR): cv.use_id(sensor.Sensor),
             cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE): cv.temperature,
@@ -80,9 +79,8 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await climate.new_climate(config)
     await cg.register_component(var, config)
-    await climate.register_climate(var, config)
 
     sens = await cg.get_variable(config[CONF_SENSOR])
     cg.add(var.set_sensor(sens))

esphome/components/pm2005/__init__.py

@@ -0,0 +1 @@
+"""PM2005/2105 component for ESPHome."""

esphome/components/pm2005/pm2005.cpp

@@ -0,0 +1,123 @@
+#include "esphome/core/log.h"
+#include "pm2005.h"
+
+namespace esphome {
+namespace pm2005 {
+
+static const char *const TAG = "pm2005";
+
+// Converts a sensor situation to a human readable string
+static const LogString *pm2005_get_situation_string(int status) {
+  switch (status) {
+    case 1:
+      return LOG_STR("Close");
+    case 2:
+      return LOG_STR("Malfunction");
+    case 3:
+      return LOG_STR("Under detecting");
+    case 0x80:
+      return LOG_STR("Detecting completed");
+    default:
+      return LOG_STR("Invalid");
+  }
+}
+
+// Converts a sensor measuring mode to a human readable string
+static const LogString *pm2005_get_measuring_mode_string(int status) {
+  switch (status) {
+    case 2:
+      return LOG_STR("Single");
+    case 3:
+      return LOG_STR("Continuous");
+    case 5:
+      return LOG_STR("Dynamic");
+    default:
+      return LOG_STR("Timing");
+  }
+}
+
+static inline uint16_t get_sensor_value(const uint8_t *data, uint8_t i) { return data[i] * 0x100 + data[i + 1]; }
+
+void PM2005Component::setup() {
+  if (this->sensor_type_ == PM2005) {
+    ESP_LOGCONFIG(TAG, "Setting up PM2005...");
+
+    this->situation_value_index_ = 3;
+    this->pm_1_0_value_index_ = 4;
+    this->pm_2_5_value_index_ = 6;
+    this->pm_10_0_value_index_ = 8;
+    this->measuring_value_index_ = 10;
+  } else {
+    ESP_LOGCONFIG(TAG, "Setting up PM2105...");
+
+    this->situation_value_index_ = 2;
+    this->pm_1_0_value_index_ = 3;
+    this->pm_2_5_value_index_ = 5;
+    this->pm_10_0_value_index_ = 7;
+    this->measuring_value_index_ = 9;
+  }
+
+  if (this->read(this->data_buffer_, 12) != i2c::ERROR_OK) {
+    ESP_LOGE(TAG, "Communication failed!");
+    this->mark_failed();
+    return;
+  }
+}
+
+void PM2005Component::update() {
+  if (this->read(this->data_buffer_, 12) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Read result failed.");
+    this->status_set_warning();
+    return;
+  }
+
+  if (this->sensor_situation_ == this->data_buffer_[this->situation_value_index_]) {
+    return;
+  }
+
+  this->sensor_situation_ = this->data_buffer_[this->situation_value_index_];
+  ESP_LOGD(TAG, "Sensor situation: %s.", LOG_STR_ARG(pm2005_get_situation_string(this->sensor_situation_)));
+  if (this->sensor_situation_ == 2) {
+    this->status_set_warning();
+    return;
+  }
+  if (this->sensor_situation_ != 0x80) {
+    return;
+  }
+
+  uint16_t pm1 = get_sensor_value(this->data_buffer_, this->pm_1_0_value_index_);
+  uint16_t pm25 = get_sensor_value(this->data_buffer_, this->pm_2_5_value_index_);
+  uint16_t pm10 = get_sensor_value(this->data_buffer_, this->pm_10_0_value_index_);
+  uint16_t sensor_measuring_mode = get_sensor_value(this->data_buffer_, this->measuring_value_index_);
+  ESP_LOGD(TAG, "PM1.0: %d, PM2.5: %d, PM10: %d, Measuring mode: %s.", pm1, pm25, pm10,
+           LOG_STR_ARG(pm2005_get_measuring_mode_string(sensor_measuring_mode)));
+
+  if (this->pm_1_0_sensor_ != nullptr) {
+    this->pm_1_0_sensor_->publish_state(pm1);
+  }
+  if (this->pm_2_5_sensor_ != nullptr) {
+    this->pm_2_5_sensor_->publish_state(pm25);
+  }
+  if (this->pm_10_0_sensor_ != nullptr) {
+    this->pm_10_0_sensor_->publish_state(pm10);
+  }
+
+  this->status_clear_warning();
+}
+
+void PM2005Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "PM2005:");
+  ESP_LOGCONFIG(TAG, "  Type: PM2%u05", this->sensor_type_ == PM2105);
+
+  LOG_I2C_DEVICE(this);
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Communication with PM2%u05 failed!", this->sensor_type_ == PM2105);
+  }
+
+  LOG_SENSOR("  ", "PM1.0", this->pm_1_0_sensor_);
+  LOG_SENSOR("  ", "PM2.5", this->pm_2_5_sensor_);
+  LOG_SENSOR("  ", "PM10 ", this->pm_10_0_sensor_);
+}
+
+}  // namespace pm2005
+}  // namespace esphome

esphome/components/pm2005/pm2005.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace pm2005 {
+
+enum SensorType {
+  PM2005,
+  PM2105,
+};
+
+class PM2005Component : public PollingComponent, public i2c::I2CDevice {
+ public:
+  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
+
+  void set_sensor_type(SensorType sensor_type) { this->sensor_type_ = sensor_type; }
+
+  void set_pm_1_0_sensor(sensor::Sensor *pm_1_0_sensor) { this->pm_1_0_sensor_ = pm_1_0_sensor; }
+  void set_pm_2_5_sensor(sensor::Sensor *pm_2_5_sensor) { this->pm_2_5_sensor_ = pm_2_5_sensor; }
+  void set_pm_10_0_sensor(sensor::Sensor *pm_10_0_sensor) { this->pm_10_0_sensor_ = pm_10_0_sensor; }
+
+  void setup() override;
+  void dump_config() override;
+  void update() override;
+
+ protected:
+  uint8_t sensor_situation_{0};
+  uint8_t data_buffer_[12];
+  SensorType sensor_type_{PM2005};
+
+  sensor::Sensor *pm_1_0_sensor_{nullptr};
+  sensor::Sensor *pm_2_5_sensor_{nullptr};
+  sensor::Sensor *pm_10_0_sensor_{nullptr};
+
+  uint8_t situation_value_index_{3};
+  uint8_t pm_1_0_value_index_{4};
+  uint8_t pm_2_5_value_index_{6};
+  uint8_t pm_10_0_value_index_{8};
+  uint8_t measuring_value_index_{10};
+};
+
+}  // namespace pm2005
+}  // namespace esphome

esphome/components/pm2005/sensor.py

@@ -0,0 +1,86 @@
+"""PM2005/2105 Sensor component for ESPHome."""
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c, sensor
+from esphome.const import (
+    CONF_ID,
+    CONF_PM_1_0,
+    CONF_PM_2_5,
+    CONF_PM_10_0,
+    CONF_TYPE,
+    DEVICE_CLASS_PM1,
+    DEVICE_CLASS_PM10,
+    DEVICE_CLASS_PM25,
+    ICON_CHEMICAL_WEAPON,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_MICROGRAMS_PER_CUBIC_METER,
+)
+
+DEPENDENCIES = ["i2c"]
+CODEOWNERS = ["@andrewjswan"]
+
+pm2005_ns = cg.esphome_ns.namespace("pm2005")
+PM2005Component = pm2005_ns.class_(
+    "PM2005Component", cg.PollingComponent, i2c.I2CDevice
+)
+
+SensorType = pm2005_ns.enum("SensorType")
+SENSOR_TYPE = {
+    "PM2005": SensorType.PM2005,
+    "PM2105": SensorType.PM2105,
+}
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(PM2005Component),
+            cv.Optional(CONF_TYPE, default="PM2005"): cv.enum(SENSOR_TYPE, upper=True),
+            cv.Optional(CONF_PM_1_0): sensor.sensor_schema(
+                unit_of_measurement=UNIT_MICROGRAMS_PER_CUBIC_METER,
+                icon=ICON_CHEMICAL_WEAPON,
+                accuracy_decimals=0,
+                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=0,
+                device_class=DEVICE_CLASS_PM25,
+                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=0,
+                device_class=DEVICE_CLASS_PM10,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        },
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x28)),
+)
+
+
+async def to_code(config) -> None:
+    """Code generation entry point."""
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    cg.add(var.set_sensor_type(config[CONF_TYPE]))
+
+    if pm_1_0_config := config.get(CONF_PM_1_0):
+        sens = await sensor.new_sensor(pm_1_0_config)
+        cg.add(var.set_pm_1_0_sensor(sens))
+
+    if pm_2_5_config := config.get(CONF_PM_2_5):
+        sens = await sensor.new_sensor(pm_2_5_config)
+        cg.add(var.set_pm_2_5_sensor(sens))
+
+    if pm_10_0_config := config.get(CONF_PM_10_0):
+        sens = await sensor.new_sensor(pm_10_0_config)
+        cg.add(var.set_pm_10_0_sensor(sens))

esphome/components/pmsa003i/pmsa003i.cpp

@@ -1,5 +1,6 @@
 #include "pmsa003i.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 #include <cstring>
 
 namespace esphome {
@@ -7,6 +8,16 @@ namespace pmsa003i {
 
 static const char *const TAG = "pmsa003i";
 
+static const uint8_t COUNT_PAYLOAD_BYTES = 28;
+static const uint8_t COUNT_PAYLOAD_LENGTH_BYTES = 2;
+static const uint8_t COUNT_START_CHARACTER_BYTES = 2;
+static const uint8_t COUNT_DATA_BYTES = COUNT_START_CHARACTER_BYTES + COUNT_PAYLOAD_LENGTH_BYTES + COUNT_PAYLOAD_BYTES;
+static const uint8_t CHECKSUM_START_INDEX = COUNT_DATA_BYTES - 2;
+static const uint8_t COUNT_16_BIT_VALUES = (COUNT_PAYLOAD_LENGTH_BYTES + COUNT_PAYLOAD_BYTES) / 2;
+static const uint8_t START_CHARACTER_1 = 0x42;
+static const uint8_t START_CHARACTER_2 = 0x4D;
+static const uint8_t READ_DATA_RETRY_COUNT = 3;
+
 void PMSA003IComponent::setup() {
   ESP_LOGCONFIG(TAG, "Setting up pmsa003i...");
 
@@ -14,7 +25,7 @@ void PMSA003IComponent::setup() {
   bool successful_read = this->read_data_(&data);
 
   if (!successful_read) {
-    for (int i = 0; i < 3; i++) {
+    for (uint8_t i = 0; i < READ_DATA_RETRY_COUNT; i++) {
       successful_read = this->read_data_(&data);
       if (successful_read) {
         break;
@@ -28,7 +39,10 @@ void PMSA003IComponent::setup() {
   }
 }
 
-void PMSA003IComponent::dump_config() { LOG_I2C_DEVICE(this); }
+void PMSA003IComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "PMSA003I:");
+  LOG_I2C_DEVICE(this);
+}
 
 void PMSA003IComponent::update() {
   PM25AQIData data;
@@ -75,35 +89,48 @@ void PMSA003IComponent::update() {
 }
 
 bool PMSA003IComponent::read_data_(PM25AQIData *data) {
-  const uint8_t num_bytes = 32;
-  uint8_t buffer[num_bytes];
+  uint8_t buffer[COUNT_DATA_BYTES];
 
-  this->read_bytes_raw(buffer, num_bytes);
+  this->read_bytes_raw(buffer, COUNT_DATA_BYTES);
 
   // https://github.com/adafruit/Adafruit_PM25AQI
 
   // Check that start byte is correct!
-  if (buffer[0] != 0x42) {
+  if (buffer[0] != START_CHARACTER_1 || buffer[1] != START_CHARACTER_2) {
+    ESP_LOGW(TAG, "Start character mismatch: %02X %02X != %02X %02X", buffer[0], buffer[1], START_CHARACTER_1,
+             START_CHARACTER_2);
+    return false;
+  }
+
+  const uint16_t payload_length = encode_uint16(buffer[2], buffer[3]);
+  if (payload_length != COUNT_PAYLOAD_BYTES) {
+    ESP_LOGW(TAG, "Payload length mismatch: %u != %u", payload_length, COUNT_PAYLOAD_BYTES);
     return false;
   }
 
-  // get checksum ready
-  int16_t sum = 0;
-  for (uint8_t i = 0; i < 30; i++) {
-    sum += buffer[i];
+  // Calculate checksum
+  uint16_t checksum = 0;
+  for (uint8_t i = 0; i < CHECKSUM_START_INDEX; i++) {
+    checksum += buffer[i];
+  }
+
+  const uint16_t check = encode_uint16(buffer[CHECKSUM_START_INDEX], buffer[CHECKSUM_START_INDEX + 1]);
+  if (checksum != check) {
+    ESP_LOGW(TAG, "Checksum mismatch: %u != %u", checksum, check);
+    return false;
   }
 
   // The data comes in endian'd, this solves it so it works on all platforms
-  uint16_t buffer_u16[15];
-  for (uint8_t i = 0; i < 15; i++) {
-    buffer_u16[i] = buffer[2 + i * 2 + 1];
-    buffer_u16[i] += (buffer[2 + i * 2] << 8);
+  uint16_t buffer_u16[COUNT_16_BIT_VALUES];
+  for (uint8_t i = 0; i < COUNT_16_BIT_VALUES; i++) {
+    const uint8_t buffer_index = COUNT_START_CHARACTER_BYTES + i * 2;
+    buffer_u16[i] = encode_uint16(buffer[buffer_index], buffer[buffer_index + 1]);
   }
 
   // put it into a nice struct :)
-  memcpy((void *) data, (void *) buffer_u16, 30);
+  memcpy((void *) data, (void *) buffer_u16, COUNT_16_BIT_VALUES * 2);
 
-  return (sum == data->checksum);
+  return true;
 }
 
 }  // namespace pmsa003i

esphome/components/pmsa003i/pmsa003i.h

@@ -10,21 +10,21 @@ namespace pmsa003i {
 /**! Structure holding Plantower's standard packet **/
 // From https://github.com/adafruit/Adafruit_PM25AQI
 struct PM25AQIData {
-  uint16_t framelen;        ///< How long this data chunk is
-  uint16_t pm10_standard,   ///< Standard PM1.0
-      pm25_standard,        ///< Standard PM2.5
-      pm100_standard;       ///< Standard PM10.0
-  uint16_t pm10_env,        ///< Environmental PM1.0
-      pm25_env,             ///< Environmental PM2.5
-      pm100_env;            ///< Environmental PM10.0
-  uint16_t particles_03um,  ///> 0.3um Particle Count
-      particles_05um,       ///> 0.5um Particle Count
-      particles_10um,       ///> 1.0um Particle Count
-      particles_25um,       ///> 2.5um Particle Count
-      particles_50um,       ///> 5.0um Particle Count
-      particles_100um;      ///> 10.0um Particle Count
-  uint16_t unused;          ///< Unused
-  uint16_t checksum;        ///< Packet checksum
+  uint16_t framelen;         ///< How long this data chunk is
+  uint16_t pm10_standard;    ///< Standard PM1.0
+  uint16_t pm25_standard;    ///< Standard PM2.5
+  uint16_t pm100_standard;   ///< Standard PM10.0
+  uint16_t pm10_env;         ///< Environmental PM1.0
+  uint16_t pm25_env;         ///< Environmental PM2.5
+  uint16_t pm100_env;        ///< Environmental PM10.0
+  uint16_t particles_03um;   ///< 0.3um Particle Count
+  uint16_t particles_05um;   ///< 0.5um Particle Count
+  uint16_t particles_10um;   ///< 1.0um Particle Count
+  uint16_t particles_25um;   ///< 2.5um Particle Count
+  uint16_t particles_50um;   ///< 5.0um Particle Count
+  uint16_t particles_100um;  ///< 10.0um Particle Count
+  uint16_t unused;           ///< Unused
+  uint16_t checksum;         ///< Packet checksum
 };
 
 class PMSA003IComponent : public PollingComponent, public i2c::I2CDevice {
@@ -34,18 +34,18 @@ class PMSA003IComponent : public PollingComponent, public i2c::I2CDevice {
   void update() override;
   float get_setup_priority() const override { return setup_priority::DATA; }
 
-  void set_standard_units(bool standard_units) { standard_units_ = standard_units; }
+  void set_standard_units(bool standard_units) { this->standard_units_ = standard_units; }
 
-  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_10_0_sensor(sensor::Sensor *pm_10_0) { pm_10_0_sensor_ = pm_10_0; }
+  void set_pm_1_0_sensor(sensor::Sensor *pm_1_0) { this->pm_1_0_sensor_ = pm_1_0; }
+  void set_pm_2_5_sensor(sensor::Sensor *pm_2_5) { this->pm_2_5_sensor_ = pm_2_5; }
+  void set_pm_10_0_sensor(sensor::Sensor *pm_10_0) { this->pm_10_0_sensor_ = pm_10_0; }
 
-  void set_pmc_0_3_sensor(sensor::Sensor *pmc_0_3) { pmc_0_3_sensor_ = pmc_0_3; }
-  void set_pmc_0_5_sensor(sensor::Sensor *pmc_0_5) { pmc_0_5_sensor_ = pmc_0_5; }
-  void set_pmc_1_0_sensor(sensor::Sensor *pmc_1_0) { pmc_1_0_sensor_ = pmc_1_0; }
-  void set_pmc_2_5_sensor(sensor::Sensor *pmc_2_5) { pmc_2_5_sensor_ = pmc_2_5; }
-  void set_pmc_5_0_sensor(sensor::Sensor *pmc_5_0) { pmc_5_0_sensor_ = pmc_5_0; }
-  void set_pmc_10_0_sensor(sensor::Sensor *pmc_10_0) { pmc_10_0_sensor_ = pmc_10_0; }
+  void set_pmc_0_3_sensor(sensor::Sensor *pmc_0_3) { this->pmc_0_3_sensor_ = pmc_0_3; }
+  void set_pmc_0_5_sensor(sensor::Sensor *pmc_0_5) { this->pmc_0_5_sensor_ = pmc_0_5; }
+  void set_pmc_1_0_sensor(sensor::Sensor *pmc_1_0) { this->pmc_1_0_sensor_ = pmc_1_0; }
+  void set_pmc_2_5_sensor(sensor::Sensor *pmc_2_5) { this->pmc_2_5_sensor_ = pmc_2_5; }
+  void set_pmc_5_0_sensor(sensor::Sensor *pmc_5_0) { this->pmc_5_0_sensor_ = pmc_5_0; }
+  void set_pmc_10_0_sensor(sensor::Sensor *pmc_10_0) { this->pmc_10_0_sensor_ = pmc_10_0; }
 
  protected:
   bool read_data_(PM25AQIData *data);