esphome 2025.5.1__py3-none-any.whl → 2025.6.0__py3-none-any.whl

esphome/components/bmp581/bmp581.cpp

@@ -72,22 +72,22 @@ void BMP581Component::dump_config() {
     case NONE:
       break;
     case ERROR_COMMUNICATION_FAILED:
-      ESP_LOGE(TAG, "  Communication with BMP581 failed!");
+      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
       break;
     case ERROR_WRONG_CHIP_ID:
-      ESP_LOGE(TAG, "  BMP581 has wrong chip ID - please verify you are using a BMP 581");
+      ESP_LOGE(TAG, "Unknown chip ID");
       break;
     case ERROR_SENSOR_RESET:
-      ESP_LOGE(TAG, "  BMP581 failed to reset");
+      ESP_LOGE(TAG, "Reset failed");
       break;
     case ERROR_SENSOR_STATUS:
-      ESP_LOGE(TAG, "  BMP581 sensor status failed, there were NVM problems");
+      ESP_LOGE(TAG, "Get status failed");
       break;
     case ERROR_PRIME_IIR_FAILED:
-      ESP_LOGE(TAG, "  BMP581's IIR Filter failed to prime with an initial measurement");
+      ESP_LOGE(TAG, "IIR Filter failed to prime with initial measurement");
       break;
     default:
-      ESP_LOGE(TAG, "  BMP581 error code %d", (int) this->error_code_);
+      ESP_LOGE(TAG, "Error %d", (int) this->error_code_);
       break;
   }
 
@@ -98,14 +98,20 @@ void BMP581Component::dump_config() {
 
   if (this->temperature_sensor_) {
     LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
-    ESP_LOGCONFIG(TAG, "    IIR Filter: %s", LOG_STR_ARG(iir_filter_to_str(this->iir_temperature_level_)));
-    ESP_LOGCONFIG(TAG, "    Oversampling: %s", LOG_STR_ARG(oversampling_to_str(this->temperature_oversampling_)));
+    ESP_LOGCONFIG(TAG,
+                  "    IIR Filter: %s\n"
+                  "    Oversampling: %s",
+                  LOG_STR_ARG(iir_filter_to_str(this->iir_temperature_level_)),
+                  LOG_STR_ARG(oversampling_to_str(this->temperature_oversampling_)));
   }
 
   if (this->pressure_sensor_) {
     LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
-    ESP_LOGCONFIG(TAG, "    IIR Filter: %s", LOG_STR_ARG(iir_filter_to_str(this->iir_pressure_level_)));
-    ESP_LOGCONFIG(TAG, "    Oversampling: %s", LOG_STR_ARG(oversampling_to_str(this->pressure_oversampling_)));
+    ESP_LOGCONFIG(TAG,
+                  "    IIR Filter: %s\n"
+                  "    Oversampling: %s",
+                  LOG_STR_ARG(iir_filter_to_str(this->iir_pressure_level_)),
+                  LOG_STR_ARG(oversampling_to_str(this->pressure_oversampling_)));
   }
 }
 
@@ -122,7 +128,7 @@ void BMP581Component::setup() {
    */
 
   this->error_code_ = NONE;
-  ESP_LOGCONFIG(TAG, "Setting up BMP581...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   ////////////////////
   // 1) Soft reboot //
@@ -130,7 +136,7 @@ void BMP581Component::setup() {
 
   // Power-On-Reboot bit is asserted if sensor successfully reset
   if (!this->reset_()) {
-    ESP_LOGE(TAG, "BMP581 failed to reset");
+    ESP_LOGE(TAG, "Reset failed");
 
     this->error_code_ = ERROR_SENSOR_RESET;
     this->mark_failed();
@@ -146,7 +152,7 @@ void BMP581Component::setup() {
 
   // read chip id from sensor
   if (!this->read_byte(BMP581_CHIP_ID, &chip_id)) {
-    ESP_LOGE(TAG, "Failed to read chip id");
+    ESP_LOGE(TAG, "Read chip ID failed");
 
     this->error_code_ = ERROR_COMMUNICATION_FAILED;
     this->mark_failed();
@@ -156,7 +162,7 @@ void BMP581Component::setup() {
 
   // verify id
   if (chip_id != BMP581_ASIC_ID) {
-    ESP_LOGE(TAG, "Unknown chip ID, is this a BMP581?");
+    ESP_LOGE(TAG, "Unknown chip ID");
 
     this->error_code_ = ERROR_WRONG_CHIP_ID;
     this->mark_failed();
@@ -179,7 +185,7 @@ void BMP581Component::setup() {
 
   // verify status_nvm_rdy bit (it is asserted if boot was successful)
   if (!(this->status_.bit.status_nvm_rdy)) {
-    ESP_LOGE(TAG, "NVM not ready after boot");
+    ESP_LOGE(TAG, "NVM not ready");
 
     this->error_code_ = ERROR_SENSOR_STATUS;
     this->mark_failed();
@@ -189,7 +195,7 @@ void BMP581Component::setup() {
 
   // verify status_nvm_err bit (it is asserted if an error is detected)
   if (this->status_.bit.status_nvm_err) {
-    ESP_LOGE(TAG, "NVM error detected on boot");
+    ESP_LOGE(TAG, "NVM error detected");
 
     this->error_code_ = ERROR_SENSOR_STATUS;
     this->mark_failed();
@@ -254,7 +260,7 @@ void BMP581Component::setup() {
     }
 
     if (!this->prime_iir_filter_()) {
-      ESP_LOGE(TAG, "Failed to prime the IIR filter with an intiial measurement");
+      ESP_LOGE(TAG, "Failed to prime the IIR filter with an initial measurement");
 
       this->error_code_ = ERROR_PRIME_IIR_FAILED;
       this->mark_failed();
@@ -286,10 +292,10 @@ void BMP581Component::update() {
   // 1) Request a measurement //
   //////////////////////////////
 
-  ESP_LOGVV(TAG, "Requesting a measurement from sensor");
+  ESP_LOGVV(TAG, "Requesting measurement");
 
   if (!this->start_measurement_()) {
-    ESP_LOGW(TAG, "Failed to request forced measurement of sensor");
+    ESP_LOGW(TAG, "Requesting forced measurement failed");
     this->status_set_warning();
 
     return;
@@ -299,7 +305,7 @@ void BMP581Component::update() {
   // 2) Wait for measurement to finish (based on oversampling rates) //
   //////////////////////////////////////////////////////////////////////
 
-  ESP_LOGVV(TAG, "Measurement is expected to take %d ms to complete", this->conversion_time_);
+  ESP_LOGVV(TAG, "Measurement should take %d ms", this->conversion_time_);
 
   this->set_timeout("measurement", this->conversion_time_, [this]() {
     float temperature = 0.0;
@@ -311,14 +317,14 @@ void BMP581Component::update() {
 
     if (this->pressure_sensor_) {
       if (!this->read_temperature_and_pressure_(temperature, pressure)) {
-        ESP_LOGW(TAG, "Failed to read temperature and pressure measurements, skipping update");
+        ESP_LOGW(TAG, "Failed to read temperature and pressure; skipping update");
         this->status_set_warning();
 
         return;
       }
     } else {
       if (!this->read_temperature_(temperature)) {
-        ESP_LOGW(TAG, "Failed to read temperature measurement, skipping update");
+        ESP_LOGW(TAG, "Failed to read temperature; skipping update");
         this->status_set_warning();
 
         return;
@@ -349,7 +355,7 @@ bool BMP581Component::check_data_readiness_() {
   //   - returns data readiness state
 
   if (this->odr_config_.bit.pwr_mode == STANDBY_MODE) {
-    ESP_LOGD(TAG, "Data is not ready, sensor is in standby mode");
+    ESP_LOGD(TAG, "Data not ready, sensor is in standby mode");
     return false;
   }
 
@@ -443,7 +449,7 @@ bool BMP581Component::read_temperature_(float &temperature) {
   //    - the measured temperature (in degrees Celsius)
 
   if (!this->check_data_readiness_()) {
-    ESP_LOGW(TAG, "Data from sensor isn't ready, skipping this update");
+    ESP_LOGW(TAG, "Data not ready, skipping this update");
     this->status_set_warning();
 
     return false;
@@ -451,7 +457,7 @@ bool BMP581Component::read_temperature_(float &temperature) {
 
   uint8_t data[3];
   if (!this->read_bytes(BMP581_MEASUREMENT_DATA, &data[0], 3)) {
-    ESP_LOGW(TAG, "Failed to read sensor's measurement data");
+    ESP_LOGW(TAG, "Failed to read measurement");
     this->status_set_warning();
 
     return false;
@@ -472,7 +478,7 @@ bool BMP581Component::read_temperature_and_pressure_(float &temperature, float &
   //    - the measured pressure (in Pa)
 
   if (!this->check_data_readiness_()) {
-    ESP_LOGW(TAG, "Data from sensor isn't ready, skipping this update");
+    ESP_LOGW(TAG, "Data not ready, skipping this update");
     this->status_set_warning();
 
     return false;
@@ -480,7 +486,7 @@ bool BMP581Component::read_temperature_and_pressure_(float &temperature, float &
 
   uint8_t data[6];
   if (!this->read_bytes(BMP581_MEASUREMENT_DATA, &data[0], 6)) {
-    ESP_LOGW(TAG, "Failed to read sensor's measurement data");
+    ESP_LOGW(TAG, "Failed to read measurement");
     this->status_set_warning();
 
     return false;

esphome/components/bp1658cj/bp1658cj.cpp

@@ -15,7 +15,7 @@ static const uint8_t BP1658CJ_ADDR_START_5CH = 0x30;
 static const uint8_t BP1658CJ_DELAY = 2;
 
 void BP1658CJ::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up BP1658CJ Output Component...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(false);
   this->clock_pin_->setup();
@@ -26,8 +26,10 @@ void BP1658CJ::dump_config() {
   ESP_LOGCONFIG(TAG, "BP1658CJ:");
   LOG_PIN("  Data Pin: ", this->data_pin_);
   LOG_PIN("  Clock Pin: ", this->clock_pin_);
-  ESP_LOGCONFIG(TAG, "  Color Channels Max Power: %u", this->max_power_color_channels_);
-  ESP_LOGCONFIG(TAG, "  White Channels Max Power: %u", this->max_power_white_channels_);
+  ESP_LOGCONFIG(TAG,
+                "  Color Channels Max Power: %u\n"
+                "  White Channels Max Power: %u",
+                this->max_power_color_channels_, this->max_power_white_channels_);
 }
 
 void BP1658CJ::loop() {

esphome/components/bp5758d/bp5758d.cpp

@@ -20,7 +20,7 @@ static const uint8_t BP5758D_ALL_DATA_CHANNEL_ENABLEMENT = 0b00011111;
 static const uint8_t BP5758D_DELAY = 2;
 
 void BP5758D::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up BP5758D Output Component...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->data_pin_->setup();
   this->data_pin_->digital_write(false);
   delayMicroseconds(BP5758D_DELAY);

esphome/components/button/__init__.py

@@ -108,6 +108,7 @@ async def register_button(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_button(var))
+    CORE.register_platform_component("button", var)
     await setup_button_core_(var, config)
 
 

esphome/components/canbus/canbus.cpp

@@ -7,7 +7,7 @@ namespace canbus {
 static const char *const TAG = "canbus";
 
 void Canbus::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up Canbus...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (!this->setup_internal()) {
     ESP_LOGE(TAG, "setup error!");
     this->mark_failed();

esphome/components/cap1188/cap1188.cpp

@@ -8,7 +8,7 @@ namespace cap1188 {
 static const char *const TAG = "cap1188";
 
 void CAP1188Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up CAP1188...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // Reset device using the reset pin
   if (this->reset_pin_ != nullptr) {
@@ -52,9 +52,11 @@ void CAP1188Component::dump_config() {
   ESP_LOGCONFIG(TAG, "CAP1188:");
   LOG_I2C_DEVICE(this);
   LOG_PIN("  Reset Pin: ", this->reset_pin_);
-  ESP_LOGCONFIG(TAG, "  Product ID: 0x%x", this->cap1188_product_id_);
-  ESP_LOGCONFIG(TAG, "  Manufacture ID: 0x%x", this->cap1188_manufacture_id_);
-  ESP_LOGCONFIG(TAG, "  Revision ID: 0x%x", this->cap1188_revision_);
+  ESP_LOGCONFIG(TAG,
+                "  Product ID: 0x%x\n"
+                "  Manufacture ID: 0x%x\n"
+                "  Revision ID: 0x%x",
+                this->cap1188_product_id_, this->cap1188_manufacture_id_, this->cap1188_revision_);
 
   switch (this->error_code_) {
     case COMMUNICATION_FAILED:

esphome/components/captive_portal/captive_portal.cpp

@@ -29,7 +29,7 @@ void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
 void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
   std::string ssid = request->arg("ssid").c_str();
   std::string psk = request->arg("psk").c_str();
-  ESP_LOGI(TAG, "Captive Portal Requested WiFi Settings Change:");
+  ESP_LOGI(TAG, "Requested WiFi Settings Change:");
   ESP_LOGI(TAG, "  SSID='%s'", ssid.c_str());
   ESP_LOGI(TAG, "  Password=" LOG_SECRET("'%s'"), psk.c_str());
   wifi::global_wifi_component->save_wifi_sta(ssid, psk);

esphome/components/ccs811/ccs811.cpp

@@ -1,6 +1,7 @@
 #include "ccs811.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace ccs811 {
@@ -163,7 +164,7 @@ void CCS811Component::dump_config() {
   if (this->is_failed()) {
     switch (this->error_code_) {
       case COMMUNICATION_FAILED:
-        ESP_LOGW(TAG, "Communication failed! Is the sensor connected?");
+        ESP_LOGW(TAG, ESP_LOG_MSG_COMM_FAIL);
         break;
       case INVALID_ID:
         ESP_LOGW(TAG, "Sensor reported an invalid ID. Is this a CCS811?");

esphome/components/cd74hc4067/cd74hc4067.cpp

@@ -10,7 +10,7 @@ static const char *const TAG = "cd74hc4067";
 float CD74HC4067Component::get_setup_priority() const { return setup_priority::DATA; }
 
 void CD74HC4067Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up CD74HC4067...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   this->pin_s0_->setup();
   this->pin_s1_->setup();

esphome/components/ch422g/ch422g.cpp

@@ -14,7 +14,7 @@ static const uint8_t CH422G_REG_OUT_UPPER = 0x23;    // write reg for output bit
 static const char *const TAG = "ch422g";
 
 void CH422GComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up CH422G...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // set outputs before mode
   this->write_outputs_();
   // Set mode and check for errors
@@ -37,7 +37,7 @@ void CH422GComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "CH422G:");
   LOG_I2C_DEVICE(this)
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with CH422G failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
 

esphome/components/chsc6x/chsc6x_touchscreen.cpp

@@ -4,7 +4,7 @@ namespace esphome {
 namespace chsc6x {
 
 void CHSC6XTouchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up CHSC6X Touchscreen...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (this->interrupt_pin_ != nullptr) {
     this->interrupt_pin_->setup();
     this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);
@@ -38,9 +38,11 @@ void CHSC6XTouchscreen::dump_config() {
   ESP_LOGCONFIG(TAG, "CHSC6X Touchscreen:");
   LOG_I2C_DEVICE(this);
   LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
-  ESP_LOGCONFIG(TAG, "  Touch timeout: %d", this->touch_timeout_);
-  ESP_LOGCONFIG(TAG, "  x_raw_max_: %d", this->x_raw_max_);
-  ESP_LOGCONFIG(TAG, "  y_raw_max_: %d", this->y_raw_max_);
+  ESP_LOGCONFIG(TAG,
+                "  Touch timeout: %d\n"
+                "  x_raw_max_: %d\n"
+                "  y_raw_max_: %d",
+                this->touch_timeout_, this->x_raw_max_, this->y_raw_max_);
 }
 
 }  // namespace chsc6x

esphome/components/climate/__init__.py

@@ -443,6 +443,7 @@ async def register_climate(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_climate(var))
+    CORE.register_platform_component("climate", var)
     await setup_climate_core_(var, config)
 
 

esphome/components/climate/climate.cpp

@@ -569,17 +569,22 @@ bool Climate::set_custom_preset_(const std::string &preset) {
 void Climate::dump_traits_(const char *tag) {
   auto traits = this->get_traits();
   ESP_LOGCONFIG(tag, "ClimateTraits:");
-  ESP_LOGCONFIG(tag, "  [x] Visual settings:");
-  ESP_LOGCONFIG(tag, "      - Min temperature: %.1f", traits.get_visual_min_temperature());
-  ESP_LOGCONFIG(tag, "      - Max temperature: %.1f", traits.get_visual_max_temperature());
-  ESP_LOGCONFIG(tag, "      - Temperature step:");
-  ESP_LOGCONFIG(tag, "          Target: %.1f", traits.get_visual_target_temperature_step());
+  ESP_LOGCONFIG(tag,
+                "  [x] Visual settings:\n"
+                "      - Min temperature: %.1f\n"
+                "      - Max temperature: %.1f\n"
+                "      - Temperature step:\n"
+                "          Target: %.1f",
+                traits.get_visual_min_temperature(), traits.get_visual_max_temperature(),
+                traits.get_visual_target_temperature_step());
   if (traits.get_supports_current_temperature()) {
     ESP_LOGCONFIG(tag, "          Current: %.1f", traits.get_visual_current_temperature_step());
   }
   if (traits.get_supports_target_humidity() || traits.get_supports_current_humidity()) {
-    ESP_LOGCONFIG(tag, "      - Min humidity: %.0f", traits.get_visual_min_humidity());
-    ESP_LOGCONFIG(tag, "      - Max humidity: %.0f", traits.get_visual_max_humidity());
+    ESP_LOGCONFIG(tag,
+                  "      - Min humidity: %.0f\n"
+                  "      - Max humidity: %.0f",
+                  traits.get_visual_min_humidity(), traits.get_visual_max_humidity());
   }
   if (traits.get_supports_two_point_target_temperature()) {
     ESP_LOGCONFIG(tag, "  [x] Supports two-point target temperature");

esphome/components/climate/climate.h

@@ -3,8 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/preferences.h"
 #include "esphome/core/log.h"
+#include "esphome/core/preferences.h"
 #include "climate_mode.h"
 #include "climate_traits.h"
 

esphome/components/climate_ir/climate_ir.cpp

@@ -75,10 +75,13 @@ void ClimateIR::control(const climate::ClimateCall &call) {
 }
 void ClimateIR::dump_config() {
   LOG_CLIMATE("", "IR Climate", this);
-  ESP_LOGCONFIG(TAG, "  Min. Temperature: %.1f°C", this->minimum_temperature_);
-  ESP_LOGCONFIG(TAG, "  Max. Temperature: %.1f°C", this->maximum_temperature_);
-  ESP_LOGCONFIG(TAG, "  Supports HEAT: %s", YESNO(this->supports_heat_));
-  ESP_LOGCONFIG(TAG, "  Supports COOL: %s", YESNO(this->supports_cool_));
+  ESP_LOGCONFIG(TAG,
+                "  Min. Temperature: %.1f°C\n"
+                "  Max. Temperature: %.1f°C\n"
+                "  Supports HEAT: %s\n"
+                "  Supports COOL: %s",
+                this->minimum_temperature_, this->maximum_temperature_, YESNO(this->supports_heat_),
+                YESNO(this->supports_cool_));
 }
 
 }  // namespace climate_ir

esphome/components/cm1106/__init__.py

@@ -0,0 +1 @@
+"""CM1106 component for ESPHome."""

esphome/components/cm1106/cm1106.cpp

@@ -0,0 +1,112 @@
+#include "cm1106.h"
+#include "esphome/core/log.h"
+
+#include <cinttypes>
+
+namespace esphome {
+namespace cm1106 {
+
+static const char *const TAG = "cm1106";
+static const uint8_t C_M1106_CMD_GET_CO2[4] = {0x11, 0x01, 0x01, 0xED};
+static const uint8_t C_M1106_CMD_SET_CO2_CALIB[6] = {0x11, 0x03, 0x03, 0x00, 0x00, 0x00};
+static const uint8_t C_M1106_CMD_SET_CO2_CALIB_RESPONSE[4] = {0x16, 0x01, 0x03, 0xE6};
+
+uint8_t cm1106_checksum(const uint8_t *response, size_t len) {
+  uint8_t crc = 0;
+  for (int i = 0; i < len - 1; i++) {
+    crc -= response[i];
+  }
+  return crc;
+}
+
+void CM1106Component::setup() {
+  ESP_LOGCONFIG(TAG, "Running setup");
+  uint8_t response[8] = {0};
+  if (!this->cm1106_write_command_(C_M1106_CMD_GET_CO2, sizeof(C_M1106_CMD_GET_CO2), response, sizeof(response))) {
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    this->mark_failed();
+    return;
+  }
+}
+
+void CM1106Component::update() {
+  uint8_t response[8] = {0};
+  if (!this->cm1106_write_command_(C_M1106_CMD_GET_CO2, sizeof(C_M1106_CMD_GET_CO2), response, sizeof(response))) {
+    ESP_LOGW(TAG, "Reading data from CM1106 failed!");
+    this->status_set_warning();
+    return;
+  }
+
+  if (response[0] != 0x16 || response[1] != 0x05 || response[2] != 0x01) {
+    ESP_LOGW(TAG, "Got wrong UART response from CM1106: %02X %02X %02X %02X", response[0], response[1], response[2],
+             response[3]);
+    this->status_set_warning();
+    return;
+  }
+
+  uint8_t checksum = cm1106_checksum(response, sizeof(response));
+  if (response[7] != checksum) {
+    ESP_LOGW(TAG, "CM1106 Checksum doesn't match: 0x%02X!=0x%02X", response[7], checksum);
+    this->status_set_warning();
+    return;
+  }
+
+  this->status_clear_warning();
+
+  uint16_t ppm = response[3] << 8 | response[4];
+  ESP_LOGD(TAG, "CM1106 Received CO₂=%uppm DF3=%02X DF4=%02X", ppm, response[5], response[6]);
+  if (this->co2_sensor_ != nullptr)
+    this->co2_sensor_->publish_state(ppm);
+}
+
+void CM1106Component::calibrate_zero(uint16_t ppm) {
+  uint8_t cmd[6];
+  memcpy(cmd, C_M1106_CMD_SET_CO2_CALIB, sizeof(cmd));
+  cmd[3] = ppm >> 8;
+  cmd[4] = ppm & 0xFF;
+  uint8_t response[4] = {0};
+
+  if (!this->cm1106_write_command_(cmd, sizeof(cmd), response, sizeof(response))) {
+    ESP_LOGW(TAG, "Reading data from CM1106 failed!");
+    this->status_set_warning();
+    return;
+  }
+
+  // check if correct response received
+  if (memcmp(response, C_M1106_CMD_SET_CO2_CALIB_RESPONSE, sizeof(response)) != 0) {
+    ESP_LOGW(TAG, "Got wrong UART response from CM1106: %02X %02X %02X %02X", response[0], response[1], response[2],
+             response[3]);
+    this->status_set_warning();
+    return;
+  }
+
+  this->status_clear_warning();
+  ESP_LOGD(TAG, "CM1106 Successfully calibrated sensor to %uppm", ppm);
+}
+
+bool CM1106Component::cm1106_write_command_(const uint8_t *command, size_t command_len, uint8_t *response,
+                                            size_t response_len) {
+  // Empty RX Buffer
+  while (this->available())
+    this->read();
+  this->write_array(command, command_len - 1);
+  this->write_byte(cm1106_checksum(command, command_len));
+  this->flush();
+
+  if (response == nullptr)
+    return true;
+
+  return this->read_array(response, response_len);
+}
+
+void CM1106Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "CM1106:");
+  LOG_SENSOR("  ", "CO2", this->co2_sensor_);
+  this->check_uart_settings(9600);
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+  }
+}
+
+}  // namespace cm1106
+}  // namespace esphome

esphome/components/cm1106/cm1106.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/automation.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/uart/uart.h"
+
+namespace esphome {
+namespace cm1106 {
+
+class CM1106Component : public PollingComponent, public uart::UARTDevice {
+ public:
+  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
+
+  void setup() override;
+  void update() override;
+  void dump_config() override;
+
+  void calibrate_zero(uint16_t ppm);
+
+  void set_co2_sensor(sensor::Sensor *co2_sensor) { this->co2_sensor_ = co2_sensor; }
+
+ protected:
+  sensor::Sensor *co2_sensor_{nullptr};
+
+  bool cm1106_write_command_(const uint8_t *command, size_t command_len, uint8_t *response, size_t response_len);
+};
+
+template<typename... Ts> class CM1106CalibrateZeroAction : public Action<Ts...> {
+ public:
+  CM1106CalibrateZeroAction(CM1106Component *cm1106) : cm1106_(cm1106) {}
+
+  void play(Ts... x) override { this->cm1106_->calibrate_zero(400); }
+
+ protected:
+  CM1106Component *cm1106_;
+};
+
+}  // namespace cm1106
+}  // namespace esphome

esphome/components/cm1106/sensor.py

@@ -0,0 +1,72 @@
+"""CM1106 Sensor component for ESPHome."""
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome import automation
+from esphome.automation import maybe_simple_id
+from esphome.components import sensor, uart
+from esphome.const import (
+    CONF_CO2,
+    CONF_ID,
+    DEVICE_CLASS_CARBON_DIOXIDE,
+    ICON_MOLECULE_CO2,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_PARTS_PER_MILLION,
+)
+
+DEPENDENCIES = ["uart"]
+CODEOWNERS = ["@andrewjswan"]
+
+cm1106_ns = cg.esphome_ns.namespace("cm1106")
+CM1106Component = cm1106_ns.class_(
+    "CM1106Component", cg.PollingComponent, uart.UARTDevice
+)
+CM1106CalibrateZeroAction = cm1106_ns.class_(
+    "CM1106CalibrateZeroAction",
+    automation.Action,
+)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(CM1106Component),
+            cv.Optional(CONF_CO2): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PARTS_PER_MILLION,
+                icon=ICON_MOLECULE_CO2,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_CARBON_DIOXIDE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        },
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(uart.UART_DEVICE_SCHEMA)
+)
+
+
+async def to_code(config) -> None:
+    """Code generation entry point."""
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await uart.register_uart_device(var, config)
+    if co2_config := config.get(CONF_CO2):
+        sens = await sensor.new_sensor(co2_config)
+        cg.add(var.set_co2_sensor(sens))
+
+
+CALIBRATION_ACTION_SCHEMA = maybe_simple_id(
+    {
+        cv.GenerateID(): cv.use_id(CM1106Component),
+    },
+)
+
+
+@automation.register_action(
+    "cm1106.calibrate_zero",
+    CM1106CalibrateZeroAction,
+    CALIBRATION_ACTION_SCHEMA,
+)
+async def cm1106_calibration_to_code(config, action_id, template_arg, args) -> None:
+    """Service code generation entry point."""
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)

esphome/components/const/__init__.py

@@ -3,3 +3,4 @@
 CODEOWNERS = ["@esphome/core"]
 
 CONF_DRAW_ROUNDING = "draw_rounding"
+CONF_REQUEST_HEADERS = "request_headers"