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

esphome/components/i2s_audio/microphone/i2s_audio_microphone.cpp

@@ -30,17 +30,17 @@ static const int32_t DC_OFFSET_MOVING_AVERAGE_COEFFICIENT_DENOMINATOR = 1000;
 static const char *const TAG = "i2s_audio.microphone";
 
 enum MicrophoneEventGroupBits : uint32_t {
-  COMMAND_STOP = (1 << 0),  // stops the microphone task
-  TASK_STARTING = (1 << 10),
-  TASK_RUNNING = (1 << 11),
-  TASK_STOPPING = (1 << 12),
-  TASK_STOPPED = (1 << 13),
+  COMMAND_STOP = (1 << 0),  // stops the microphone task, set and cleared by ``loop``
+
+  TASK_STARTING = (1 << 10),  // set by mic task, cleared by ``loop``
+  TASK_RUNNING = (1 << 11),   // set by mic task, cleared by ``loop``
+  TASK_STOPPED = (1 << 13),   // set by mic task, cleared by ``loop``
 
   ALL_BITS = 0x00FFFFFF,  // All valid FreeRTOS event group bits
 };
 
 void I2SAudioMicrophone::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up I2S Audio Microphone...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 #ifdef USE_I2S_LEGACY
 #if SOC_I2S_SUPPORTS_ADC
   if (this->adc_) {
@@ -151,24 +151,21 @@ bool I2SAudioMicrophone::start_driver_() {
     config.mode = (i2s_mode_t) (config.mode | I2S_MODE_ADC_BUILT_IN);
     err = i2s_driver_install(this->parent_->get_port(), &config, 0, nullptr);
     if (err != ESP_OK) {
-      ESP_LOGW(TAG, "Error installing I2S driver: %s", esp_err_to_name(err));
-      this->status_set_error();
+      ESP_LOGE(TAG, "Error installing I2S driver: %s", esp_err_to_name(err));
       return false;
     }
 
     err = i2s_set_adc_mode(ADC_UNIT_1, this->adc_channel_);
     if (err != ESP_OK) {
-      ESP_LOGW(TAG, "Error setting ADC mode: %s", esp_err_to_name(err));
-      this->status_set_error();
+      ESP_LOGE(TAG, "Error setting ADC mode: %s", esp_err_to_name(err));
       return false;
     }
+
     err = i2s_adc_enable(this->parent_->get_port());
     if (err != ESP_OK) {
-      ESP_LOGW(TAG, "Error enabling ADC: %s", esp_err_to_name(err));
-      this->status_set_error();
+      ESP_LOGE(TAG, "Error enabling ADC: %s", esp_err_to_name(err));
       return false;
     }
-
   } else
 #endif
   {
@@ -177,8 +174,7 @@ bool I2SAudioMicrophone::start_driver_() {
 
     err = i2s_driver_install(this->parent_->get_port(), &config, 0, nullptr);
     if (err != ESP_OK) {
-      ESP_LOGW(TAG, "Error installing I2S driver: %s", esp_err_to_name(err));
-      this->status_set_error();
+      ESP_LOGE(TAG, "Error installing I2S driver: %s", esp_err_to_name(err));
       return false;
     }
 
@@ -187,8 +183,7 @@ bool I2SAudioMicrophone::start_driver_() {
 
     err = i2s_set_pin(this->parent_->get_port(), &pin_config);
     if (err != ESP_OK) {
-      ESP_LOGW(TAG, "Error setting I2S pin: %s", esp_err_to_name(err));
-      this->status_set_error();
+      ESP_LOGE(TAG, "Error setting I2S pin: %s", esp_err_to_name(err));
       return false;
     }
   }
@@ -203,8 +198,7 @@ bool I2SAudioMicrophone::start_driver_() {
   /* Allocate a new RX channel and get the handle of this channel */
   err = i2s_new_channel(&chan_cfg, NULL, &this->rx_handle_);
   if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Error creating new I2S channel: %s", esp_err_to_name(err));
-    this->status_set_error();
+    ESP_LOGE(TAG, "Error creating new I2S channel: %s", esp_err_to_name(err));
     return false;
   }
 
@@ -276,22 +270,20 @@ bool I2SAudioMicrophone::start_driver_() {
     err = i2s_channel_init_std_mode(this->rx_handle_, &std_cfg);
   }
   if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Error initializing I2S channel: %s", esp_err_to_name(err));
-    this->status_set_error();
+    ESP_LOGE(TAG, "Error initializing I2S channel: %s", esp_err_to_name(err));
     return false;
   }
 
   /* Before reading data, start the RX channel first */
   i2s_channel_enable(this->rx_handle_);
   if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Error enabling I2S Microphone: %s", esp_err_to_name(err));
-    this->status_set_error();
+    ESP_LOGE(TAG, "Error enabling I2S Microphone: %s", esp_err_to_name(err));
     return false;
   }
 #endif
 
-  this->status_clear_error();
   this->configure_stream_settings_();  // redetermine the settings in case some settings were changed after compilation
+
   return true;
 }
 
@@ -303,71 +295,55 @@ void I2SAudioMicrophone::stop() {
 }
 
 void I2SAudioMicrophone::stop_driver_() {
+  // There is no harm continuing to unload the driver if an error is ever returned by the various functions. This
+  // ensures that we stop/unload the driver when it only partially starts.
+
   esp_err_t err;
 #ifdef USE_I2S_LEGACY
 #if SOC_I2S_SUPPORTS_ADC
   if (this->adc_) {
     err = i2s_adc_disable(this->parent_->get_port());
     if (err != ESP_OK) {
-      ESP_LOGW(TAG, "Error disabling ADC: %s", esp_err_to_name(err));
-      this->status_set_error();
-      return;
+      ESP_LOGW(TAG, "Error disabling ADC - it may not have started: %s", esp_err_to_name(err));
     }
   }
 #endif
   err = i2s_stop(this->parent_->get_port());
   if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Error stopping I2S microphone: %s", esp_err_to_name(err));
-    this->status_set_error();
-    return;
+    ESP_LOGW(TAG, "Error stopping I2S microphone - it may not have started: %s", esp_err_to_name(err));
   }
   err = i2s_driver_uninstall(this->parent_->get_port());
   if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Error uninstalling I2S driver: %s", esp_err_to_name(err));
-    this->status_set_error();
-    return;
+    ESP_LOGW(TAG, "Error uninstalling I2S driver - it may not have started: %s", esp_err_to_name(err));
   }
 #else
   /* Have to stop the channel before deleting it */
   err = i2s_channel_disable(this->rx_handle_);
   if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Error stopping I2S microphone: %s", esp_err_to_name(err));
-    this->status_set_error();
-    return;
+    ESP_LOGW(TAG, "Error stopping I2S microphone - it may not have started: %s", esp_err_to_name(err));
   }
   /* If the handle is not needed any more, delete it to release the channel resources */
   err = i2s_del_channel(this->rx_handle_);
   if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Error deleting I2S channel: %s", esp_err_to_name(err));
-    this->status_set_error();
-    return;
+    ESP_LOGW(TAG, "Error deleting I2S channel - it may not have started: %s", esp_err_to_name(err));
   }
 #endif
   this->parent_->unlock();
-  this->status_clear_error();
 }
 
 void I2SAudioMicrophone::mic_task(void *params) {
   I2SAudioMicrophone *this_microphone = (I2SAudioMicrophone *) params;
-
   xEventGroupSetBits(this_microphone->event_group_, MicrophoneEventGroupBits::TASK_STARTING);
 
-  uint8_t start_counter = 0;
-  bool started = this_microphone->start_driver_();
-  while (!started && start_counter < 10) {
-    // Attempt to load the driver again in 100 ms. Doesn't slow down main loop since its in a task.
-    vTaskDelay(pdMS_TO_TICKS(100));
-    ++start_counter;
-    started = this_microphone->start_driver_();
-  }
+  {  // Ensures the samples vector is freed when the task stops
 
-  if (started) {
-    xEventGroupSetBits(this_microphone->event_group_, MicrophoneEventGroupBits::TASK_RUNNING);
     const size_t bytes_to_read = this_microphone->audio_stream_info_.ms_to_bytes(READ_DURATION_MS);
     std::vector<uint8_t> samples;
     samples.reserve(bytes_to_read);
 
-    while (!(xEventGroupGetBits(this_microphone->event_group_) & COMMAND_STOP)) {
+    xEventGroupSetBits(this_microphone->event_group_, MicrophoneEventGroupBits::TASK_RUNNING);
+
+    while (!(xEventGroupGetBits(this_microphone->event_group_) & MicrophoneEventGroupBits::COMMAND_STOP)) {
       if (this_microphone->data_callbacks_.size() > 0) {
         samples.resize(bytes_to_read);
         size_t bytes_read = this_microphone->read_(samples.data(), bytes_to_read, 2 * pdMS_TO_TICKS(READ_DURATION_MS));
@@ -382,9 +358,6 @@ void I2SAudioMicrophone::mic_task(void *params) {
     }
   }
 
-  xEventGroupSetBits(this_microphone->event_group_, MicrophoneEventGroupBits::TASK_STOPPING);
-  this_microphone->stop_driver_();
-
   xEventGroupSetBits(this_microphone->event_group_, MicrophoneEventGroupBits::TASK_STOPPED);
   while (true) {
     // Continuously delay until the loop method deletes the task
@@ -425,7 +398,10 @@ size_t I2SAudioMicrophone::read_(uint8_t *buf, size_t len, TickType_t ticks_to_w
 #endif
   if ((err != ESP_OK) && ((err != ESP_ERR_TIMEOUT) || (ticks_to_wait != 0))) {
     // Ignore ESP_ERR_TIMEOUT if ticks_to_wait = 0, as it will read the data on the next call
-    ESP_LOGW(TAG, "Error reading from I2S microphone: %s", esp_err_to_name(err));
+    if (!this->status_has_warning()) {
+      // Avoid spamming the logs with the error message if its repeated
+      ESP_LOGW(TAG, "Error reading from I2S microphone: %s", esp_err_to_name(err));
+    }
     this->status_set_warning();
     return 0;
   }
@@ -452,7 +428,7 @@ void I2SAudioMicrophone::loop() {
   uint32_t event_group_bits = xEventGroupGetBits(this->event_group_);
 
   if (event_group_bits & MicrophoneEventGroupBits::TASK_STARTING) {
-    ESP_LOGD(TAG, "Task has started, attempting to setup I2S audio driver");
+    ESP_LOGD(TAG, "Task started, attempting to allocate buffer");
     xEventGroupClearBits(this->event_group_, MicrophoneEventGroupBits::TASK_STARTING);
   }
 
@@ -463,23 +439,25 @@ void I2SAudioMicrophone::loop() {
     this->state_ = microphone::STATE_RUNNING;
   }
 
-  if (event_group_bits & MicrophoneEventGroupBits::TASK_STOPPING) {
-    ESP_LOGD(TAG, "Task is stopping, attempting to unload the I2S audio driver");
-    xEventGroupClearBits(this->event_group_, MicrophoneEventGroupBits::TASK_STOPPING);
-  }
-
   if ((event_group_bits & MicrophoneEventGroupBits::TASK_STOPPED)) {
-    ESP_LOGD(TAG, "Task is finished, freeing resources");
+    ESP_LOGD(TAG, "Task finished, freeing resources and uninstalling I2S driver");
+
     vTaskDelete(this->task_handle_);
     this->task_handle_ = nullptr;
+    this->stop_driver_();
     xEventGroupClearBits(this->event_group_, ALL_BITS);
+    this->status_clear_error();
+
     this->state_ = microphone::STATE_STOPPED;
   }
 
+  // Start the microphone if any semaphores are taken
   if ((uxSemaphoreGetCount(this->active_listeners_semaphore_) < MAX_LISTENERS) &&
       (this->state_ == microphone::STATE_STOPPED)) {
     this->state_ = microphone::STATE_STARTING;
   }
+
+  // Stop the microphone if all semaphores are returned
   if ((uxSemaphoreGetCount(this->active_listeners_semaphore_) == MAX_LISTENERS) &&
       (this->state_ == microphone::STATE_RUNNING)) {
     this->state_ = microphone::STATE_STOPPING;
@@ -487,14 +465,26 @@ void I2SAudioMicrophone::loop() {
 
   switch (this->state_) {
     case microphone::STATE_STARTING:
-      if ((this->task_handle_ == nullptr) && !this->status_has_error()) {
+      if (this->status_has_error()) {
+        break;
+      }
+
+      if (!this->start_driver_()) {
+        this->status_momentary_error("I2S driver failed to start, unloading it and attempting again in 1 second", 1000);
+        this->stop_driver_();  // Stop/frees whatever possibly started
+        break;
+      }
+
+      if (this->task_handle_ == nullptr) {
         xTaskCreate(I2SAudioMicrophone::mic_task, "mic_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
                     &this->task_handle_);
 
         if (this->task_handle_ == nullptr) {
           this->status_momentary_error("Task failed to start, attempting again in 1 second", 1000);
+          this->stop_driver_();  // Stops the driver to return the lock; will be reloaded in next attempt
         }
       }
+
       break;
     case microphone::STATE_RUNNING:
       break;

esphome/components/i2s_audio/microphone/i2s_audio_microphone.h

@@ -43,7 +43,11 @@ class I2SAudioMicrophone : public I2SAudioIn, public microphone::Microphone, pub
 #endif
 
  protected:
+  /// @brief Starts the I2S driver. Updates the ``audio_stream_info_`` member variable with the current setttings.
+  /// @return True if succesful, false otherwise
   bool start_driver_();
+
+  /// @brief Stops the I2S driver.
   void stop_driver_();
 
   /// @brief Attempts to correct a microphone DC offset; e.g., a microphones silent level is offset from 0. Applies a

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -99,7 +99,7 @@ static const std::vector<int16_t> Q15_VOLUME_SCALING_FACTORS = {
     19508, 20665, 21891, 23189, 24565, 26022, 27566, 29201, 30933, 32767};
 
 void I2SAudioSpeaker::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up I2S Audio Speaker...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   this->event_group_ = xEventGroupCreate();
 

esphome/components/iaqcore/iaqcore.cpp

@@ -1,7 +1,7 @@
 #include "iaqcore.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace iaqcore {
@@ -26,7 +26,7 @@ struct SensorData {
 
 void IAQCore::setup() {
   if (this->write(nullptr, 0) != i2c::ERROR_OK) {
-    ESP_LOGD(TAG, "Communication failed!");
+    ESP_LOGD(TAG, ESP_LOG_MSG_COMM_FAIL);
     this->mark_failed();
     return;
   }
@@ -89,7 +89,7 @@ void IAQCore::dump_config() {
   LOG_I2C_DEVICE(this);
   LOG_UPDATE_INTERVAL(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with AMS iAQ Core failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_SENSOR("  ", "CO2", this->co2_);
   LOG_SENSOR("  ", "TVOC", this->tvoc_);

esphome/components/ili9xxx/ili9xxx_display.cpp

@@ -89,8 +89,10 @@ void ILI9XXXDisplay::setup_pins_() {
 
 void ILI9XXXDisplay::dump_config() {
   LOG_DISPLAY("", "ili9xxx", this);
-  ESP_LOGCONFIG(TAG, "  Width Offset: %u", this->offset_x_);
-  ESP_LOGCONFIG(TAG, "  Height Offset: %u", this->offset_y_);
+  ESP_LOGCONFIG(TAG,
+                "  Width Offset: %u\n"
+                "  Height Offset: %u",
+                this->offset_x_, this->offset_y_);
   switch (this->buffer_color_mode_) {
     case BITS_8_INDEXED:
       ESP_LOGCONFIG(TAG, "  Color mode: 8bit Indexed");
@@ -111,11 +113,14 @@ void ILI9XXXDisplay::dump_config() {
   LOG_PIN("  CS Pin: ", this->cs_);
   LOG_PIN("  DC Pin: ", this->dc_pin_);
   LOG_PIN("  Busy Pin: ", this->busy_pin_);
-  ESP_LOGCONFIG(TAG, "  Color order: %s", this->color_order_ == display::COLOR_ORDER_BGR ? "BGR" : "RGB");
-  ESP_LOGCONFIG(TAG, "  Swap_xy: %s", YESNO(this->swap_xy_));
-  ESP_LOGCONFIG(TAG, "  Mirror_x: %s", YESNO(this->mirror_x_));
-  ESP_LOGCONFIG(TAG, "  Mirror_y: %s", YESNO(this->mirror_y_));
-  ESP_LOGCONFIG(TAG, "  Invert colors: %s", YESNO(this->pre_invertcolors_));
+  ESP_LOGCONFIG(TAG,
+                "  Color order: %s\n"
+                "  Swap_xy: %s\n"
+                "  Mirror_x: %s\n"
+                "  Mirror_y: %s\n"
+                "  Invert colors: %s",
+                this->color_order_ == display::COLOR_ORDER_BGR ? "BGR" : "RGB", YESNO(this->swap_xy_),
+                YESNO(this->mirror_x_), YESNO(this->mirror_y_), YESNO(this->pre_invertcolors_));
 
   if (this->is_failed()) {
     ESP_LOGCONFIG(TAG, "  => Failed to init Memory: YES!");

esphome/components/ili9xxx/ili9xxx_display.h

@@ -89,7 +89,7 @@ class ILI9XXXDisplay : public display::DisplayBuffer,
 
   void dump_config() override;
   void setup() override;
-  void on_shutdown() override { this->command(ILI9XXX_SLPIN); }
+  void on_powerdown() override { this->command(ILI9XXX_SLPIN); }
 
   display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
   void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,

esphome/components/image/image.cpp

@@ -1,6 +1,7 @@
 #include "image.h"
 
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace image {

esphome/components/ina219/ina219.cpp

@@ -34,7 +34,7 @@ static const uint8_t INA219_REGISTER_CURRENT = 0x04;
 static const uint8_t INA219_REGISTER_CALIBRATION = 0x05;
 
 void INA219Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up INA219...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // Config Register
   // 0bx000000000000000 << 15 RESET Bit (1 -> trigger reset)
   if (!this->write_byte_16(INA219_REGISTER_CONFIG, 0x8000)) {
@@ -134,7 +134,7 @@ void INA219Component::dump_config() {
   LOG_I2C_DEVICE(this);
 
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with INA219 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
     return;
   }
   LOG_UPDATE_INTERVAL(this);

esphome/components/ina226/ina226.cpp

@@ -37,7 +37,7 @@ static const uint16_t INA226_ADC_TIMES[] = {140, 204, 332, 588, 1100, 2116, 4156
 static const uint16_t INA226_ADC_AVG_SAMPLES[] = {1, 4, 16, 64, 128, 256, 512, 1024};
 
 void INA226Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up INA226...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   ConfigurationRegister config;
 
@@ -88,14 +88,17 @@ void INA226Component::dump_config() {
   LOG_I2C_DEVICE(this);
 
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with INA226 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
     return;
   }
   LOG_UPDATE_INTERVAL(this);
 
-  ESP_LOGCONFIG(TAG, "  ADC Conversion Time Bus Voltage: %d", INA226_ADC_TIMES[this->adc_time_voltage_ & 0b111]);
-  ESP_LOGCONFIG(TAG, "  ADC Conversion Time Shunt Voltage: %d", INA226_ADC_TIMES[this->adc_time_current_ & 0b111]);
-  ESP_LOGCONFIG(TAG, "  ADC Averaging Samples: %d", INA226_ADC_AVG_SAMPLES[this->adc_avg_samples_ & 0b111]);
+  ESP_LOGCONFIG(TAG,
+                "  ADC Conversion Time Bus Voltage: %d\n"
+                "  ADC Conversion Time Shunt Voltage: %d\n"
+                "  ADC Averaging Samples: %d",
+                INA226_ADC_TIMES[this->adc_time_voltage_ & 0b111], INA226_ADC_TIMES[this->adc_time_current_ & 0b111],
+                INA226_ADC_AVG_SAMPLES[this->adc_avg_samples_ & 0b111]);
 
   LOG_SENSOR("  ", "Bus Voltage", this->bus_voltage_sensor_);
   LOG_SENSOR("  ", "Shunt Voltage", this->shunt_voltage_sensor_);

esphome/components/ina260/ina260.cpp

@@ -35,7 +35,7 @@ static const uint8_t INA260_REGISTER_MANUFACTURE_ID = 0xFE;
 static const uint8_t INA260_REGISTER_DEVICE_ID = 0xFF;
 
 void INA260Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up INA260...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // Reset device on setup
   if (!this->write_byte_16(INA260_REGISTER_CONFIG, 0x8000)) {

esphome/components/ina2xx_base/ina2xx_base.cpp

@@ -1,7 +1,7 @@
 #include "ina2xx_base.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include <cinttypes>
 #include <cmath>
 
@@ -50,7 +50,7 @@ static bool check_model_and_device_match(INAModel model, uint16_t dev_id) {
 }
 
 void INA2XX::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up INA2xx...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   if (!this->reset_config_()) {
     ESP_LOGE(TAG, "Reset failed, check connection");
@@ -203,15 +203,19 @@ void INA2XX::dump_config() {
              this->dev_id_);
   }
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with INA2xx failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
-  ESP_LOGCONFIG(TAG, "  Shunt resistance = %f Ohm", this->shunt_resistance_ohm_);
-  ESP_LOGCONFIG(TAG, "  Max current = %f A", this->max_current_a_);
-  ESP_LOGCONFIG(TAG, "  Shunt temp coeff = %d ppm/°C", this->shunt_tempco_ppm_c_);
-  ESP_LOGCONFIG(TAG, "  ADCRANGE = %d (%s)", (uint8_t) this->adc_range_, this->adc_range_ ? "±40.96 mV" : "±163.84 mV");
-  ESP_LOGCONFIG(TAG, "  CURRENT_LSB = %f", this->current_lsb_);
-  ESP_LOGCONFIG(TAG, "  SHUNT_CAL = %d", this->shunt_cal_);
+  ESP_LOGCONFIG(TAG,
+                "  Shunt resistance = %f Ohm\n"
+                "  Max current = %f A\n"
+                "  Shunt temp coeff = %d ppm/°C\n"
+                "  ADCRANGE = %d (%s)\n"
+                "  CURRENT_LSB = %f\n"
+                "  SHUNT_CAL = %d",
+                this->shunt_resistance_ohm_, this->max_current_a_, this->shunt_tempco_ppm_c_,
+                (uint8_t) this->adc_range_, this->adc_range_ ? "±40.96 mV" : "±163.84 mV", this->current_lsb_,
+                this->shunt_cal_);
 
   ESP_LOGCONFIG(TAG, "  ADC Samples = %d; ADC times: Bus = %d μs, Shunt = %d μs, Temp = %d μs",
                 ADC_SAMPLES[0b111 & (uint8_t) this->adc_avg_samples_],

esphome/components/ina3221/ina3221.cpp

@@ -22,7 +22,7 @@ static const uint8_t INA3221_REGISTER_CHANNEL3_BUS_VOLTAGE = 0x06;
 // A0 = SCL -> 0x43
 
 void INA3221Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up INA3221...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // Config Register
   // 0bx000000000000000 << 15 RESET Bit (1 -> trigger reset)
   if (!this->write_byte_16(INA3221_REGISTER_CONFIG, 0x8000)) {
@@ -60,7 +60,7 @@ void INA3221Component::dump_config() {
   ESP_LOGCONFIG(TAG, "INA3221:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with INA3221 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
 

esphome/components/inkplate6/display.py

@@ -6,9 +6,12 @@ from esphome.const import (
     CONF_FULL_UPDATE_EVERY,
     CONF_ID,
     CONF_LAMBDA,
+    CONF_MIRROR_X,
+    CONF_MIRROR_Y,
     CONF_MODEL,
     CONF_OE_PIN,
     CONF_PAGES,
+    CONF_TRANSFORM,
     CONF_WAKEUP_PIN,
 )
 
@@ -36,7 +39,6 @@ CONF_SPH_PIN = "sph_pin"
 CONF_SPV_PIN = "spv_pin"
 CONF_VCOM_PIN = "vcom_pin"
 
-
 inkplate6_ns = cg.esphome_ns.namespace("inkplate6")
 Inkplate6 = inkplate6_ns.class_(
     "Inkplate6",
@@ -62,6 +64,12 @@ CONFIG_SCHEMA = cv.All(
         {
             cv.GenerateID(): cv.declare_id(Inkplate6),
             cv.Optional(CONF_GREYSCALE, default=False): cv.boolean,
+            cv.Optional(CONF_TRANSFORM): cv.Schema(
+                {
+                    cv.Optional(CONF_MIRROR_X, default=False): cv.boolean,
+                    cv.Optional(CONF_MIRROR_Y, default=False): cv.boolean,
+                }
+            ),
             cv.Optional(CONF_PARTIAL_UPDATING, default=True): cv.boolean,
             cv.Optional(CONF_FULL_UPDATE_EVERY, default=10): cv.uint32_t,
             cv.Optional(CONF_MODEL, default="inkplate_6"): cv.enum(
@@ -109,7 +117,6 @@ CONFIG_SCHEMA = cv.All(
     .extend(cv.polling_component_schema("5s"))
     .extend(i2c.i2c_device_schema(0x48)),
     cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
-    cv.only_with_arduino,
 )
 
 
@@ -126,6 +133,9 @@ async def to_code(config):
         cg.add(var.set_writer(lambda_))
 
     cg.add(var.set_greyscale(config[CONF_GREYSCALE]))
+    if transform := config.get(CONF_TRANSFORM):
+        cg.add(var.set_mirror_x(transform[CONF_MIRROR_X]))
+        cg.add(var.set_mirror_y(transform[CONF_MIRROR_Y]))
     cg.add(var.set_partial_updating(config[CONF_PARTIAL_UPDATING]))
     cg.add(var.set_full_update_every(config[CONF_FULL_UPDATE_EVERY]))
 

esphome/components/inkplate6/inkplate.cpp

@@ -1,11 +1,9 @@
 #include "inkplate.h"
-#include "esphome/core/log.h"
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
-#ifdef USE_ESP32_FRAMEWORK_ARDUINO
-
-#include <esp32-hal-gpio.h>
+#include <hal/gpio_hal.h>
 
 namespace esphome {
 namespace inkplate6 {
@@ -156,6 +154,12 @@ void HOT Inkplate6::draw_absolute_pixel_internal(int x, int y, Color color) {
   if (x >= this->get_width_internal() || y >= this->get_height_internal() || x < 0 || y < 0)
     return;
 
+  if (this->mirror_y_)
+    y = this->get_height_internal() - y - 1;
+
+  if (this->mirror_x_)
+    x = this->get_width_internal() - x - 1;
+
   if (this->greyscale_) {
     int x1 = x / 2;
     int x_sub = x % 2;
@@ -180,9 +184,11 @@ void HOT Inkplate6::draw_absolute_pixel_internal(int x, int y, Color color) {
 
 void Inkplate6::dump_config() {
   LOG_DISPLAY("", "Inkplate", this);
-  ESP_LOGCONFIG(TAG, "  Greyscale: %s", YESNO(this->greyscale_));
-  ESP_LOGCONFIG(TAG, "  Partial Updating: %s", YESNO(this->partial_updating_));
-  ESP_LOGCONFIG(TAG, "  Full Update Every: %d", this->full_update_every_);
+  ESP_LOGCONFIG(TAG,
+                "  Greyscale: %s\n"
+                "  Partial Updating: %s\n"
+                "  Full Update Every: %d",
+                YESNO(this->greyscale_), YESNO(this->partial_updating_), this->full_update_every_);
   // Log pins
   LOG_PIN("  CKV Pin: ", this->ckv_pin_);
   LOG_PIN("  CL Pin: ", this->cl_pin_);
@@ -715,5 +721,3 @@ void Inkplate6::pins_as_outputs_() {
 
 }  // namespace inkplate6
 }  // namespace esphome
-
-#endif  // USE_ESP32_FRAMEWORK_ARDUINO

esphome/components/inkplate6/inkplate.h

@@ -1,11 +1,9 @@
 #pragma once
 
+#include "esphome/components/display/display_buffer.h"
+#include "esphome/components/i2c/i2c.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
-#include "esphome/components/i2c/i2c.h"
-#include "esphome/components/display/display_buffer.h"
-
-#ifdef USE_ESP32_FRAMEWORK_ARDUINO
 
 namespace esphome {
 namespace inkplate6 {
@@ -92,6 +90,9 @@ class Inkplate6 : public display::DisplayBuffer, public i2c::I2CDevice {
     if (this->is_ready())
       this->initialize_();
   }
+  void set_mirror_y(bool mirror_y) { this->mirror_y_ = mirror_y; }
+  void set_mirror_x(bool mirror_x) { this->mirror_x_ = mirror_x; }
+
   void set_partial_updating(bool partial_updating) { this->partial_updating_ = partial_updating; }
   void set_full_update_every(uint32_t full_update_every) { this->full_update_every_ = full_update_every; }
 
@@ -221,6 +222,8 @@ class Inkplate6 : public display::DisplayBuffer, public i2c::I2CDevice {
 
   bool block_partial_{true};
   bool greyscale_;
+  bool mirror_y_{false};
+  bool mirror_x_{false};
   bool partial_updating_;
 
   InkplateModel model_;
@@ -249,5 +252,3 @@ class Inkplate6 : public display::DisplayBuffer, public i2c::I2CDevice {
 
 }  // namespace inkplate6
 }  // namespace esphome
-
-#endif  // USE_ESP32_FRAMEWORK_ARDUINO

esphome/components/integration/integration_sensor.cpp

@@ -1,7 +1,7 @@
 #include "integration_sensor.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "esphome/core/hal.h"
 
 namespace esphome {
 namespace integration {