esphome 2025.7.4__py3-none-any.whl → 2025.8.0__py3-none-any.whl

esphome/components/tm1651/__init__.py

@@ -10,26 +10,28 @@ from esphome.const import (
     CONF_LEVEL,
 )
 
-CODEOWNERS = ["@freekode"]
+CODEOWNERS = ["@mrtoy-me"]
+
+CONF_LEVEL_PERCENT = "level_percent"
 
 tm1651_ns = cg.esphome_ns.namespace("tm1651")
 TM1651Brightness = tm1651_ns.enum("TM1651Brightness")
 TM1651Display = tm1651_ns.class_("TM1651Display", cg.Component)
 
-SetLevelPercentAction = tm1651_ns.class_("SetLevelPercentAction", automation.Action)
-SetLevelAction = tm1651_ns.class_("SetLevelAction", automation.Action)
 SetBrightnessAction = tm1651_ns.class_("SetBrightnessAction", automation.Action)
-TurnOnAction = tm1651_ns.class_("SetLevelPercentAction", automation.Action)
-TurnOffAction = tm1651_ns.class_("SetLevelPercentAction", automation.Action)
-
-CONF_LEVEL_PERCENT = "level_percent"
+SetLevelAction = tm1651_ns.class_("SetLevelAction", automation.Action)
+SetLevelPercentAction = tm1651_ns.class_("SetLevelPercentAction", automation.Action)
+TurnOnAction = tm1651_ns.class_("TurnOnAction", automation.Action)
+TurnOffAction = tm1651_ns.class_("TurnOffAction", automation.Action)
 
 TM1651_BRIGHTNESS_OPTIONS = {
-    1: TM1651Brightness.TM1651_BRIGHTNESS_LOW,
-    2: TM1651Brightness.TM1651_BRIGHTNESS_MEDIUM,
-    3: TM1651Brightness.TM1651_BRIGHTNESS_HIGH,
+    1: TM1651Brightness.TM1651_DARKEST,
+    2: TM1651Brightness.TM1651_TYPICAL,
+    3: TM1651Brightness.TM1651_BRIGHTEST,
 }
 
+MULTI_CONF = True
+
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -38,26 +40,21 @@ CONFIG_SCHEMA = cv.All(
             cv.Required(CONF_DIO_PIN): pins.internal_gpio_output_pin_schema,
         }
     ),
-    cv.only_with_arduino,
 )
 
-validate_level_percent = cv.All(cv.int_range(min=0, max=100))
-validate_level = cv.All(cv.int_range(min=0, max=7))
-validate_brightness = cv.enum(TM1651_BRIGHTNESS_OPTIONS, int=True)
-
 
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
-
     clk_pin = await cg.gpio_pin_expression(config[CONF_CLK_PIN])
     cg.add(var.set_clk_pin(clk_pin))
     dio_pin = await cg.gpio_pin_expression(config[CONF_DIO_PIN])
     cg.add(var.set_dio_pin(dio_pin))
 
-    # https://platformio.org/lib/show/6865/TM1651
-    cg.add_library("freekode/TM1651", "1.0.1")
 
+validate_brightness = cv.enum(TM1651_BRIGHTNESS_OPTIONS, int=True)
+validate_level = cv.All(cv.int_range(min=0, max=7))
+validate_level_percent = cv.All(cv.int_range(min=0, max=100))
 
 BINARY_OUTPUT_ACTION_SCHEMA = maybe_simple_id(
     {
@@ -66,38 +63,22 @@ BINARY_OUTPUT_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-@automation.register_action("tm1651.turn_on", TurnOnAction, BINARY_OUTPUT_ACTION_SCHEMA)
-async def output_turn_on_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
 @automation.register_action(
-    "tm1651.turn_off", TurnOffAction, BINARY_OUTPUT_ACTION_SCHEMA
-)
-async def output_turn_off_to_code(config, action_id, template_arg, args):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-@automation.register_action(
-    "tm1651.set_level_percent",
-    SetLevelPercentAction,
+    "tm1651.set_brightness",
+    SetBrightnessAction,
     cv.maybe_simple_value(
         {
             cv.GenerateID(): cv.use_id(TM1651Display),
-            cv.Required(CONF_LEVEL_PERCENT): cv.templatable(validate_level_percent),
+            cv.Required(CONF_BRIGHTNESS): cv.templatable(validate_brightness),
         },
-        key=CONF_LEVEL_PERCENT,
+        key=CONF_BRIGHTNESS,
     ),
 )
-async def tm1651_set_level_percent_to_code(config, action_id, template_arg, args):
+async def tm1651_set_brightness_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_LEVEL_PERCENT], args, cg.uint8)
-    cg.add(var.set_level_percent(template_))
+    template_ = await cg.templatable(config[CONF_BRIGHTNESS], args, cg.uint8)
+    cg.add(var.set_brightness(template_))
     return var
 
 
@@ -121,19 +102,35 @@ async def tm1651_set_level_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "tm1651.set_brightness",
-    SetBrightnessAction,
+    "tm1651.set_level_percent",
+    SetLevelPercentAction,
     cv.maybe_simple_value(
         {
             cv.GenerateID(): cv.use_id(TM1651Display),
-            cv.Required(CONF_BRIGHTNESS): cv.templatable(validate_brightness),
+            cv.Required(CONF_LEVEL_PERCENT): cv.templatable(validate_level_percent),
         },
-        key=CONF_BRIGHTNESS,
+        key=CONF_LEVEL_PERCENT,
     ),
 )
-async def tm1651_set_brightness_to_code(config, action_id, template_arg, args):
+async def tm1651_set_level_percent_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_LEVEL_PERCENT], args, cg.uint8)
+    cg.add(var.set_level_percent(template_))
+    return var
+
+
+@automation.register_action(
+    "tm1651.turn_off", TurnOffAction, BINARY_OUTPUT_ACTION_SCHEMA
+)
+async def output_turn_off_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@automation.register_action("tm1651.turn_on", TurnOnAction, BINARY_OUTPUT_ACTION_SCHEMA)
+async def output_turn_on_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_BRIGHTNESS], args, cg.uint8)
-    cg.add(var.set_brightness(template_))
     return var

esphome/components/tm1651/tm1651.cpp

@@ -1,7 +1,54 @@
-#ifdef USE_ARDUINO
+// This Esphome TM1651 component for use with Mini Battery Displays (7 LED levels)
+// and removes the Esphome dependency on the TM1651 Arduino library.
+// It was largely based on the work of others as set out below.
+// @mrtoy-me July 2025
+// ==============================================================================================
+// Original Arduino TM1651 library:
+// Author:Fred.Chu
+// Date:14 August, 2014
+// Applicable Module: Battery Display v1.0
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the GNU
+// Lesser General Public License for more details.
+// Modified record:
+// Author:  Detlef Giessmann Germany
+// Mail:    mydiyp@web.de
+// Demo for the new 7 LED Battery-Display 2017
+// IDE:     Arduino-1.6.5
+// Type:    OPEN-SMART CX10*4RY68  4Color
+// Date:    01.05.2017
+// ==============================================================================================
+// Esphome component using arduino TM1651 library:
+// MIT License
+// Copyright (c) 2019 freekode
+// ==============================================================================================
+// Library and command-line (python) program to control mini battery displays on Raspberry Pi:
+// MIT License
+// Copyright (c) 2020 Koen Vervloese
+// ==============================================================================================
+// MIT License
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #include "tm1651.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -9,86 +56,205 @@ namespace tm1651 {
 
 static const char *const TAG = "tm1651.display";
 
-static const uint8_t MAX_INPUT_LEVEL_PERCENT = 100;
-static const uint8_t TM1651_MAX_LEVEL = 7;
+static const bool LINE_HIGH = true;
+static const bool LINE_LOW = false;
 
-static const uint8_t TM1651_BRIGHTNESS_LOW_HW = 0;
-static const uint8_t TM1651_BRIGHTNESS_MEDIUM_HW = 2;
-static const uint8_t TM1651_BRIGHTNESS_HIGH_HW = 7;
+// TM1651 maximum frequency is 500 kHz (duty ratio 50%) = 2 microseconds / cycle
+static const uint8_t CLOCK_CYCLE = 8;
+
+static const uint8_t HALF_CLOCK_CYCLE = CLOCK_CYCLE / 2;
+static const uint8_t QUARTER_CLOCK_CYCLE = CLOCK_CYCLE / 4;
+
+static const uint8_t ADDR_FIXED = 0x44;  // fixed address mode
+static const uint8_t ADDR_START = 0xC0;  // address of the display register
+
+static const uint8_t DISPLAY_OFF = 0x80;
+static const uint8_t DISPLAY_ON = 0x88;
+
+static const uint8_t MAX_DISPLAY_LEVELS = 7;
+
+static const uint8_t PERCENT100 = 100;
+static const uint8_t PERCENT50 = 50;
+
+static const uint8_t TM1651_BRIGHTNESS_DARKEST = 0;
+static const uint8_t TM1651_BRIGHTNESS_TYPICAL = 2;
+static const uint8_t TM1651_BRIGHTNESS_BRIGHTEST = 7;
+
+static const uint8_t TM1651_LEVEL_TAB[] = {0b00000000, 0b00000001, 0b00000011, 0b00000111,
+                                           0b00001111, 0b00011111, 0b00111111, 0b01111111};
+
+// public
 
 void TM1651Display::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  this->clk_pin_->setup();
+  this->clk_pin_->pin_mode(gpio::FLAG_OUTPUT);
+
+  this->dio_pin_->setup();
+  this->dio_pin_->pin_mode(gpio::FLAG_OUTPUT);
 
-  uint8_t clk = clk_pin_->get_pin();
-  uint8_t dio = dio_pin_->get_pin();
+  this->brightness_ = TM1651_BRIGHTNESS_TYPICAL;
 
-  battery_display_ = make_unique<TM1651>(clk, dio);
-  battery_display_->init();
-  battery_display_->clearDisplay();
+  // clear display
+  this->display_level_();
+  this->update_brightness_(DISPLAY_ON);
 }
 
 void TM1651Display::dump_config() {
-  ESP_LOGCONFIG(TAG, "TM1651 Battery Display");
+  ESP_LOGCONFIG(TAG, "Battery Display");
   LOG_PIN("  CLK: ", clk_pin_);
   LOG_PIN("  DIO: ", dio_pin_);
 }
 
-void TM1651Display::set_level_percent(uint8_t new_level) {
-  this->level_ = calculate_level_(new_level);
-  this->repaint_();
+void TM1651Display::set_brightness(uint8_t new_brightness) {
+  this->brightness_ = this->remap_brightness_(new_brightness);
+  if (this->display_on_) {
+    this->update_brightness_(DISPLAY_ON);
+  }
 }
 
 void TM1651Display::set_level(uint8_t new_level) {
+  if (new_level > MAX_DISPLAY_LEVELS)
+    new_level = MAX_DISPLAY_LEVELS;
   this->level_ = new_level;
-  this->repaint_();
+  if (this->display_on_) {
+    this->display_level_();
+  }
 }
 
-void TM1651Display::set_brightness(uint8_t new_brightness) {
-  this->brightness_ = calculate_brightness_(new_brightness);
-  this->repaint_();
+void TM1651Display::set_level_percent(uint8_t percentage) {
+  this->level_ = this->calculate_level_(percentage);
+  if (this->display_on_) {
+    this->display_level_();
+  }
+}
+
+void TM1651Display::turn_off() {
+  this->display_on_ = false;
+  this->update_brightness_(DISPLAY_OFF);
 }
 
 void TM1651Display::turn_on() {
-  this->is_on_ = true;
-  this->repaint_();
+  this->display_on_ = true;
+  // display level as it could have been changed when display turned off
+  this->display_level_();
+  this->update_brightness_(DISPLAY_ON);
 }
 
-void TM1651Display::turn_off() {
-  this->is_on_ = false;
-  battery_display_->displayLevel(0);
+// protected
+
+uint8_t TM1651Display::calculate_level_(uint8_t percentage) {
+  if (percentage > PERCENT100)
+    percentage = PERCENT100;
+  // scale 0-100% to 0-7 display levels
+  // use integer arithmetic with rounding
+  uint16_t initial_scaling = (percentage * MAX_DISPLAY_LEVELS) + PERCENT50;
+  return (uint8_t) (initial_scaling / PERCENT100);
 }
 
-void TM1651Display::repaint_() {
-  if (!this->is_on_) {
-    return;
-  }
+void TM1651Display::display_level_() {
+  this->start_();
+  this->write_byte_(ADDR_FIXED);
+  this->stop_();
+
+  this->start_();
+  this->write_byte_(ADDR_START);
+  this->write_byte_(TM1651_LEVEL_TAB[this->level_]);
+  this->stop_();
+}
+
+uint8_t TM1651Display::remap_brightness_(uint8_t new_brightness) {
+  if (new_brightness <= 1)
+    return TM1651_BRIGHTNESS_DARKEST;
+  if (new_brightness == 2)
+    return TM1651_BRIGHTNESS_TYPICAL;
 
-  battery_display_->set(this->brightness_);
-  battery_display_->displayLevel(this->level_);
+  // new_brightness >= 3
+  return TM1651_BRIGHTNESS_BRIGHTEST;
 }
 
-uint8_t TM1651Display::calculate_level_(uint8_t new_level) {
-  if (new_level == 0) {
-    return 0;
+void TM1651Display::update_brightness_(uint8_t on_off_control) {
+  this->start_();
+  this->write_byte_(on_off_control | this->brightness_);
+  this->stop_();
+}
+
+// low level functions
+
+bool TM1651Display::write_byte_(uint8_t data) {
+  // data bit written to DIO when CLK is low
+  for (uint8_t i = 0; i < 8; i++) {
+    this->half_cycle_clock_low_((bool) (data & 0x01));
+    this->half_cycle_clock_high_();
+    data >>= 1;
   }
 
-  float calculated_level = TM1651_MAX_LEVEL / (float) (MAX_INPUT_LEVEL_PERCENT / (float) new_level);
-  return (uint8_t) roundf(calculated_level);
+  // start 9th cycle, setting DIO high and look for ack
+  this->half_cycle_clock_low_(LINE_HIGH);
+  return this->half_cycle_clock_high_ack_();
+}
+
+void TM1651Display::half_cycle_clock_low_(bool data_bit) {
+  // first half cycle, clock low and write data bit
+  this->clk_pin_->digital_write(LINE_LOW);
+  delayMicroseconds(QUARTER_CLOCK_CYCLE);
+
+  this->dio_pin_->digital_write(data_bit);
+  delayMicroseconds(QUARTER_CLOCK_CYCLE);
 }
 
-uint8_t TM1651Display::calculate_brightness_(uint8_t new_brightness) {
-  if (new_brightness <= 1) {
-    return TM1651_BRIGHTNESS_LOW_HW;
-  } else if (new_brightness == 2) {
-    return TM1651_BRIGHTNESS_MEDIUM_HW;
-  } else if (new_brightness >= 3) {
-    return TM1651_BRIGHTNESS_HIGH_HW;
+void TM1651Display::half_cycle_clock_high_() {
+  // second half cycle, clock high
+  this->clk_pin_->digital_write(LINE_HIGH);
+  delayMicroseconds(HALF_CLOCK_CYCLE);
+}
+
+bool TM1651Display::half_cycle_clock_high_ack_() {
+  // second half cycle, clock high and check for ack
+  this->clk_pin_->digital_write(LINE_HIGH);
+  delayMicroseconds(QUARTER_CLOCK_CYCLE);
+
+  this->dio_pin_->pin_mode(gpio::FLAG_INPUT);
+  // valid ack on DIO is low
+  bool ack = (!this->dio_pin_->digital_read());
+
+  this->dio_pin_->pin_mode(gpio::FLAG_OUTPUT);
+
+  // ack should be set DIO low by now
+  // if its not, set DIO low before the next cycle
+  if (!ack) {
+    this->dio_pin_->digital_write(LINE_LOW);
   }
+  delayMicroseconds(QUARTER_CLOCK_CYCLE);
 
-  return TM1651_BRIGHTNESS_LOW_HW;
+  // begin next cycle
+  this->clk_pin_->digital_write(LINE_LOW);
+
+  return ack;
+}
+
+void TM1651Display::start_() {
+  // start data transmission
+  this->delineate_transmission_(LINE_HIGH);
+}
+
+void TM1651Display::stop_() {
+  // stop data transmission
+  this->delineate_transmission_(LINE_LOW);
+}
+
+void TM1651Display::delineate_transmission_(bool dio_state) {
+  // delineate data transmission
+  // DIO changes its value while CLK is high
+
+  this->dio_pin_->digital_write(dio_state);
+  delayMicroseconds(HALF_CLOCK_CYCLE);
+
+  this->clk_pin_->digital_write(LINE_HIGH);
+  delayMicroseconds(QUARTER_CLOCK_CYCLE);
+
+  this->dio_pin_->digital_write(!dio_state);
+  delayMicroseconds(QUARTER_CLOCK_CYCLE);
 }
 
 }  // namespace tm1651
 }  // namespace esphome
-
-#endif  // USE_ARDUINO

esphome/components/tm1651/tm1651.h

@@ -1,22 +1,16 @@
 #pragma once
 
-#ifdef USE_ARDUINO
-
-#include <memory>
-
+#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
-#include "esphome/core/automation.h"
-
-#include <TM1651.h>
 
 namespace esphome {
 namespace tm1651 {
 
 enum TM1651Brightness : uint8_t {
-  TM1651_BRIGHTNESS_LOW = 1,
-  TM1651_BRIGHTNESS_MEDIUM = 2,
-  TM1651_BRIGHTNESS_HIGH = 3,
+  TM1651_DARKEST = 1,
+  TM1651_TYPICAL = 2,
+  TM1651_BRIGHTEST = 3,
 };
 
 class TM1651Display : public Component {
@@ -27,36 +21,49 @@ class TM1651Display : public Component {
   void setup() override;
   void dump_config() override;
 
-  void set_level_percent(uint8_t new_level);
-  void set_level(uint8_t new_level);
   void set_brightness(uint8_t new_brightness);
   void set_brightness(TM1651Brightness new_brightness) { this->set_brightness(static_cast<uint8_t>(new_brightness)); }
 
-  void turn_on();
+  void set_level(uint8_t new_level);
+  void set_level_percent(uint8_t percentage);
+
   void turn_off();
+  void turn_on();
 
  protected:
-  std::unique_ptr<TM1651> battery_display_;
-  InternalGPIOPin *clk_pin_;
-  InternalGPIOPin *dio_pin_;
-  bool is_on_ = true;
+  uint8_t calculate_level_(uint8_t percentage);
+  void display_level_();
+
+  uint8_t remap_brightness_(uint8_t new_brightness);
+  void update_brightness_(uint8_t on_off_control);
+
+  // low level functions
+  bool write_byte_(uint8_t data);
 
-  uint8_t brightness_;
-  uint8_t level_;
+  void half_cycle_clock_low_(bool data_bit);
+  void half_cycle_clock_high_();
+  bool half_cycle_clock_high_ack_();
 
-  void repaint_();
+  void start_();
+  void stop_();
+
+  void delineate_transmission_(bool dio_state);
+
+  InternalGPIOPin *clk_pin_;
+  InternalGPIOPin *dio_pin_;
 
-  uint8_t calculate_level_(uint8_t new_level);
-  uint8_t calculate_brightness_(uint8_t new_brightness);
+  bool display_on_{true};
+  uint8_t brightness_{};
+  uint8_t level_{0};
 };
 
-template<typename... Ts> class SetLevelPercentAction : public Action<Ts...>, public Parented<TM1651Display> {
+template<typename... Ts> class SetBrightnessAction : public Action<Ts...>, public Parented<TM1651Display> {
  public:
-  TEMPLATABLE_VALUE(uint8_t, level_percent)
+  TEMPLATABLE_VALUE(uint8_t, brightness)
 
   void play(Ts... x) override {
-    auto level_percent = this->level_percent_.value(x...);
-    this->parent_->set_level_percent(level_percent);
+    auto brightness = this->brightness_.value(x...);
+    this->parent_->set_brightness(brightness);
   }
 };
 
@@ -70,13 +77,13 @@ template<typename... Ts> class SetLevelAction : public Action<Ts...>, public Par
   }
 };
 
-template<typename... Ts> class SetBrightnessAction : public Action<Ts...>, public Parented<TM1651Display> {
+template<typename... Ts> class SetLevelPercentAction : public Action<Ts...>, public Parented<TM1651Display> {
  public:
-  TEMPLATABLE_VALUE(uint8_t, brightness)
+  TEMPLATABLE_VALUE(uint8_t, level_percent)
 
   void play(Ts... x) override {
-    auto brightness = this->brightness_.value(x...);
-    this->parent_->set_brightness(brightness);
+    auto level_percent = this->level_percent_.value(x...);
+    this->parent_->set_level_percent(level_percent);
   }
 };
 
@@ -92,5 +99,3 @@ template<typename... Ts> class TurnOffAction : public Action<Ts...>, public Pare
 
 }  // namespace tm1651
 }  // namespace esphome
-
-#endif  // USE_ARDUINO

esphome/components/tmp117/tmp117.cpp

@@ -26,8 +26,6 @@ void TMP117Component::update() {
   }
 }
 void TMP117Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   if (!this->write_config_(this->config_)) {
     this->mark_failed();
     return;

esphome/components/tsl2561/tsl2561.cpp

@@ -15,7 +15,6 @@ static const uint8_t TSL2561_REGISTER_DATA_0 = 0x0C;
 static const uint8_t TSL2561_REGISTER_DATA_1 = 0x0E;
 
 void TSL2561Sensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t id;
   if (!this->tsl2561_read_byte(TSL2561_REGISTER_ID, &id)) {
     this->mark_failed();

esphome/components/tsl2591/tsl2591.cpp

@@ -43,7 +43,6 @@ void TSL2591Component::disable_if_power_saving_() {
 }
 
 void TSL2591Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for address 0x%02X", this->address_);
   switch (this->component_gain_) {
     case TSL2591_CGAIN_LOW:
       this->gain_ = TSL2591_GAIN_LOW;

esphome/components/tt21100/touchscreen/tt21100.cpp

@@ -47,8 +47,6 @@ struct TT21100TouchReport {
 float TT21100Touchscreen::get_setup_priority() const { return setup_priority::HARDWARE - 1.0f; }
 
 void TT21100Touchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   // Register interrupt pin
   if (this->interrupt_pin_ != nullptr) {
     this->interrupt_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);

esphome/components/ttp229_bsf/ttp229_bsf.cpp

@@ -7,7 +7,6 @@ namespace ttp229_bsf {
 static const char *const TAG = "ttp229_bsf";
 
 void TTP229BSFComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->sdo_pin_->setup();
   this->scl_pin_->setup();
   this->scl_pin_->digital_write(true);

esphome/components/ttp229_lsf/ttp229_lsf.cpp

@@ -7,7 +7,6 @@ namespace ttp229_lsf {
 static const char *const TAG = "ttp229_lsf";
 
 void TTP229LSFComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t data[2];
   if (this->read(data, 2) != i2c::ERROR_OK) {
     this->error_code_ = COMMUNICATION_FAILED;

esphome/components/tuya/climate/__init__.py

@@ -46,16 +46,15 @@ TuyaClimate = tuya_ns.class_("TuyaClimate", climate.Climate, cg.Component)
 
 
 def validate_temperature_multipliers(value):
-    if CONF_TEMPERATURE_MULTIPLIER in value:
-        if (
-            CONF_CURRENT_TEMPERATURE_MULTIPLIER in value
-            or CONF_TARGET_TEMPERATURE_MULTIPLIER in value
-        ):
-            raise cv.Invalid(
-                f"Cannot have {CONF_TEMPERATURE_MULTIPLIER} at the same time as "
-                f"{CONF_CURRENT_TEMPERATURE_MULTIPLIER} and "
-                f"{CONF_TARGET_TEMPERATURE_MULTIPLIER}"
-            )
+    if CONF_TEMPERATURE_MULTIPLIER in value and (
+        CONF_CURRENT_TEMPERATURE_MULTIPLIER in value
+        or CONF_TARGET_TEMPERATURE_MULTIPLIER in value
+    ):
+        raise cv.Invalid(
+            f"Cannot have {CONF_TEMPERATURE_MULTIPLIER} at the same time as "
+            f"{CONF_CURRENT_TEMPERATURE_MULTIPLIER} and "
+            f"{CONF_TARGET_TEMPERATURE_MULTIPLIER}"
+        )
     if (
         CONF_CURRENT_TEMPERATURE_MULTIPLIER in value
         and CONF_TARGET_TEMPERATURE_MULTIPLIER not in value