add-mcp23008-support

esphome/components/am2320/am2320.cpp

@@ -69,7 +69,7 @@ void AM2320Component::dump_config() {
 }
 float AM2320Component::get_setup_priority() const { return setup_priority::DATA; }
 
-bool AM2320Component::read_bytes_(uint8_t a_register, uint8_t *data, uint8_t len, uint32_t conversion) {
+bool AM2320Component::read_bytes(uint8_t a_register, uint8_t *data, uint8_t len, uint32_t conversion) {
   if (!this->write_bytes(a_register, data, 2)) {
     ESP_LOGW(TAG, "Writing bytes for AM2320 failed!");
     return false;
@@ -80,7 +80,7 @@ bool AM2320Component::read_bytes_(uint8_t a_register, uint8_t *data, uint8_t len
   return this->parent_->raw_receive(this->address_, data, len);
 }
 
-bool AM2320Component::read_data_(uint8_t *data) {
+bool AM2320Component::read_data(uint8_t *data) {
   // Wake up
   this->write_bytes(0, data, 0);
 
@@ -95,12 +95,7 @@ bool AM2320Component::read_data_(uint8_t *data) {
   checksum = data[7] << 8;
   checksum += data[6];
 
-  if (crc_16(data, 6) != checksum) {
-    ESP_LOGW(TAG, "AM2320 Checksum invalid!");
-    return false;
-  }
-
-  return true;
+  return !;
 }
 
 }  // namespace am2320

esphome/components/apds9960/apds9960.cpp

@@ -158,7 +158,7 @@ void APDS9960::update() {
 
 void APDS9960::loop() { this->read_gesture_data_(); }
 
-void APDS9960::read_color_data_(uint8_t status) {
+void APDS9960::read_color_data(uint8_t status) {
   if (!this->is_color_enabled_())
     return;
 
@@ -190,7 +190,7 @@ void APDS9960::read_color_data_(uint8_t status) {
   if (this->blue_channel_ != nullptr)
     this->blue_channel_->publish_state(blue_perc);
 }
-void APDS9960::read_proximity_data_(uint8_t status) {
+void APDS9960::read_proximity_data(uint8_t status) {
   if (this->proximity_ == nullptr)
     return;
 

esphome/components/api/user_services.h

@@ -80,7 +80,7 @@ template<typename... Ts> class UserService : public UserServiceDescriptor, publi
 
 template<typename... Ts>
 template<int... S>
-void UserService<Ts...>::execute_(std::vector<ExecuteServiceArgument> args, seq<S...>) {
+void UserService<Ts...>::execute(std::vector<ExecuteServiceArgument> args, seq<S...>) {
   this->trigger((args[S].get_value<Ts>())...);
 }
 template<typename... Ts> void UserService<Ts...>::encode_list_service_response(APIBuffer &buffer) {

esphome/components/bang_bang/bang_bang_climate.cpp

@@ -90,7 +90,7 @@ void BangBangClimate::compute_state_() {
 
   this->switch_to_mode_(target_mode);
 }
-void BangBangClimate::switch_to_mode_(climate::ClimateMode mode) {
+void BangBangClimate::switch_to_mode(climate::ClimateMode mode) {
   if (mode == this->internal_mode_)
     // already in target mode
     return;

esphome/components/bang_bang/bang_bang_climate.h

@@ -33,11 +33,11 @@ class BangBangClimate : public climate::Climate, public Component {
 
  protected:
   /// Override control to change settings of the climate device.
-  void control(const climate::ClimateCall &call) override;
+  void control_(const climate::ClimateCall &call) override;
   /// Change the away setting, will reset target temperatures to defaults.
   void change_away_(bool away);
   /// Return the traits of this controller.
-  climate::ClimateTraits traits() override;
+  climate::ClimateTraits traits_() override;
 
   /// Re-compute the state of this climate controller.
   void compute_state_();

esphome/components/binary_sensor/automation.cpp

@@ -79,14 +79,14 @@ void binary_sensor::MultiClickTrigger::schedule_cooldown_() {
   this->cancel_timeout("is_valid");
   this->cancel_timeout("is_not_valid");
 }
-void binary_sensor::MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
+void binary_sensor::MultiClickTrigger::schedule_is_valid(uint32_t min_length) {
   this->is_valid_ = false;
   this->set_timeout("is_valid", min_length, [this]() {
     ESP_LOGV(TAG, "Multi Click: You can now %s the button.", this->parent_->state ? "RELEASE" : "PRESS");
     this->is_valid_ = true;
   });
 }
-void binary_sensor::MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
+void binary_sensor::MultiClickTrigger::schedule_is_not_valid(uint32_t max_length) {
   this->set_timeout("is_not_valid", max_length, [this]() {
     ESP_LOGV(TAG, "Multi Click: You waited too long to %s.", this->parent_->state ? "RELEASE" : "PRESS");
     this->is_valid_ = false;

esphome/components/binary_sensor/automation.h

@@ -136,7 +136,7 @@ template<typename... Ts> class BinarySensorCondition : public Condition<Ts...> {
 template<typename... Ts> class BinarySensorPublishAction : public Action<Ts...> {
  public:
   explicit BinarySensorPublishAction(BinarySensor *sensor) : sensor_(sensor) {}
-  TEMPLATABLE_VALUE(bool, state)
+  templatable_value(bool, state)
   void play(Ts... x) override {
     auto val = this->state_.value(x...);
     this->sensor_->publish_state(val);

esphome/components/binary_sensor/binary_sensor.h

@@ -77,7 +77,7 @@ class BinarySensor : public Nameable {
   virtual std::string device_class();
 
  protected:
-  uint32_t hash_base() override;
+  uint32_t hash_base_() override;
 
   CallbackManager<void(bool)> state_callback_{};
   optional<std::string> device_class_{};  ///< Stores the override of the device class

esphome/components/bme280/bme280.cpp

@@ -204,7 +204,7 @@ void BME280Component::update() {
     this->status_clear_warning();
   });
 }
-float BME280Component::read_temperature_(int32_t *t_fine) {
+float BME280Component::read_temperature(int32_t *t_fine) {
   uint8_t data[3];
   if (!this->read_bytes(BME280_REGISTER_TEMPDATA, data, 3))
     return NAN;
@@ -226,7 +226,7 @@ float BME280Component::read_temperature_(int32_t *t_fine) {
   return temperature / 100.0f;
 }
 
-float BME280Component::read_pressure_(int32_t t_fine) {
+float BME280Component::read_pressure(int32_t t_fine) {
   uint8_t data[3];
   if (!this->read_bytes(BME280_REGISTER_PRESSUREDATA, data, 3))
     return NAN;
@@ -265,7 +265,7 @@ float BME280Component::read_pressure_(int32_t t_fine) {
   return (p / 256.0f) / 100.0f;
 }
 
-float BME280Component::read_humidity_(int32_t t_fine) {
+float BME280Component::read_humidity(int32_t t_fine) {
   uint16_t raw_adc;
   if (!this->read_byte_16(BME280_REGISTER_HUMIDDATA, &raw_adc) || raw_adc == 0x8000)
     return NAN;
@@ -302,17 +302,17 @@ void BME280Component::set_humidity_oversampling(BME280Oversampling humidity_over
   this->humidity_oversampling_ = humidity_over_sampling;
 }
 void BME280Component::set_iir_filter(BME280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
-uint8_t BME280Component::read_u8_(uint8_t a_register) {
+uint8_t BME280Component::read_u8(uint8_t a_register) {
   uint8_t data = 0;
   this->read_byte(a_register, &data);
   return data;
 }
-uint16_t BME280Component::read_u16_le_(uint8_t a_register) {
+uint16_t BME280Component::read_u16_le(uint8_t a_register) {
   uint16_t data = 0;
   this->read_byte_16(a_register, &data);
   return (data >> 8) | (data << 8);
 }
-int16_t BME280Component::read_s16_le_(uint8_t a_register) { return this->read_u16_le_(a_register); }
+int16_t BME280Component::read_s16_le(uint8_t a_register) { return this->read_u16_le_(a_register); }
 
 }  // namespace bme280
 }  // namespace esphome

esphome/components/bme680/bme680.cpp

@@ -242,7 +242,7 @@ void BME680Component::update() {
   this->set_timeout("data", this->calc_meas_duration_(), [this]() { this->read_data_(); });
 }
 
-uint8_t BME680Component::calc_heater_resistance_(uint16_t temperature) {
+uint8_t BME680Component::calc_heater_resistance(uint16_t temperature) {
   if (temperature < 200)
     temperature = 200;
   if (temperature > 400)
@@ -273,7 +273,7 @@ uint8_t BME680Component::calc_heater_resistance_(uint16_t temperature) {
 
   return heatr_res;
 }
-uint8_t BME680Component::calc_heater_duration_(uint16_t duration) {
+uint8_t BME680Component::calc_heater_duration(uint16_t duration) {
   uint8_t factor = 0;
   uint8_t duration_value;
 
@@ -323,7 +323,7 @@ void BME680Component::read_data_() {
   this->status_clear_warning();
 }
 
-float BME680Component::calc_temperature_(uint32_t raw_temperature) {
+float BME680Component::calc_temperature(uint32_t raw_temperature) {
   float var1 = 0;
   float var2 = 0;
   float var3 = 0;
@@ -349,7 +349,7 @@ float BME680Component::calc_temperature_(uint32_t raw_temperature) {
 
   return calc_temp;
 }
-float BME680Component::calc_pressure_(uint32_t raw_pressure) {
+float BME680Component::calc_pressure(uint32_t raw_pressure) {
   const float tfine = this->calibration_.tfine;
   const float p1 = this->calibration_.p1;
   const float p2 = this->calibration_.p2;
@@ -391,7 +391,7 @@ float BME680Component::calc_pressure_(uint32_t raw_pressure) {
   return calc_pres / 100.0f;
 }
 
-float BME680Component::calc_humidity_(uint16_t raw_humidity) {
+float BME680Component::calc_humidity(uint16_t raw_humidity) {
   const float tfine = this->calibration_.tfine;
   const float h1 = this->calibration_.h1;
   const float h2 = this->calibration_.h2;
@@ -426,7 +426,7 @@ float BME680Component::calc_humidity_(uint16_t raw_humidity) {
 
   return calc_hum;
 }
-uint32_t BME680Component::calc_gas_resistance_(uint16_t raw_gas, uint8_t range) {
+uint32_t BME680Component::calc_gas_resistance(uint16_t raw_gas, uint8_t range) {
   float calc_gas_res;
   float var1 = 0;
   float var2 = 0;
@@ -441,7 +441,7 @@ uint32_t BME680Component::calc_gas_resistance_(uint16_t raw_gas, uint8_t range)
 
   return static_cast<uint32_t>(calc_gas_res);
 }
-uint32_t BME680Component::calc_meas_duration_() {
+uint32_t BME680Component::calc_meas_duration() {
   uint32_t tph_dur;  // Calculate in us
   uint32_t meas_cycles;
   const uint8_t os_to_meas_cycles[6] = {0, 1, 2, 4, 8, 16};

esphome/components/bmp085/bmp085.cpp

@@ -128,7 +128,7 @@ void BMP085Component::read_pressure_() {
     this->pressure_->publish_state(pressure);
   this->status_clear_warning();
 }
-bool BMP085Component::set_mode_(uint8_t mode) {
+bool BMP085Component::set_mode(uint8_t mode) {
   ESP_LOGV(TAG, "Setting mode to 0x%02X...", mode);
   return this->write_byte(BMP085_REGISTER_CONTROL, mode);
 }

esphome/components/bmp280/bmp280.cpp

@@ -155,7 +155,7 @@ void BMP280Component::update() {
   });
 }
 
-float BMP280Component::read_temperature_(int32_t *t_fine) {
+float BMP280Component::read_temperature(int32_t *t_fine) {
   uint8_t data[3];
   if (!this->read_bytes(BMP280_REGISTER_TEMPDATA, data, 3))
     return NAN;
@@ -177,7 +177,7 @@ float BMP280Component::read_temperature_(int32_t *t_fine) {
   return temperature / 100.0f;
 }
 
-float BMP280Component::read_pressure_(int32_t t_fine) {
+float BMP280Component::read_pressure(int32_t t_fine) {
   uint8_t data[3];
   if (!this->read_bytes(BMP280_REGISTER_PRESSUREDATA, data, 3))
     return NAN;
@@ -222,17 +222,17 @@ void BMP280Component::set_pressure_oversampling(BMP280Oversampling pressure_over
   this->pressure_oversampling_ = pressure_over_sampling;
 }
 void BMP280Component::set_iir_filter(BMP280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
-uint8_t BMP280Component::read_u8_(uint8_t a_register) {
+uint8_t BMP280Component::read_u8(uint8_t a_register) {
   uint8_t data = 0;
   this->read_byte(a_register, &data);
   return data;
 }
-uint16_t BMP280Component::read_u16_le_(uint8_t a_register) {
+uint16_t BMP280Component::read_u16_le(uint8_t a_register) {
   uint16_t data = 0;
   this->read_byte_16(a_register, &data);
   return (data >> 8) | (data << 8);
 }
-int16_t BMP280Component::read_s16_le_(uint8_t a_register) { return this->read_u16_le_(a_register); }
+int16_t BMP280Component::read_s16_le(uint8_t a_register) { return this->read_u16_le_(a_register); }
 
 }  // namespace bmp280
 }  // namespace esphome

esphome/components/climate/climate.h

@@ -182,7 +182,7 @@ class Climate : public Nameable {
    * modes, temperature range etc. Each integration must implement this method and the return value must
    * be constant during all of execution time.
    */
-  virtual ClimateTraits traits() = 0;
+  virtual ClimateTraits traits_() = 0;
 
   /** Control the climate device, this is a virtual method that each climate integration must implement.
    *
@@ -200,7 +200,7 @@ class Climate : public Nameable {
    */
   void save_state_();
 
-  uint32_t hash_base() override;
+  uint32_t hash_base_() override;
 
   CallbackManager<void()> state_callback_{};
   ESPPreferenceObject rtc_;

esphome/components/coolix/coolix.h

@@ -22,9 +22,9 @@ class CoolixClimate : public climate::Climate, public Component {
 
  protected:
   /// Override control to change settings of the climate device.
-  void control(const climate::ClimateCall &call) override;
+  void control_(const climate::ClimateCall &call) override;
   /// Return the traits of this controller.
-  climate::ClimateTraits traits() override;
+  climate::ClimateTraits traits_() override;
 
   /// Transmit via IR the state of this climate controller.
   void transmit_state_();

esphome/components/cover/cover.h

@@ -117,7 +117,7 @@ class Cover : public Nameable {
      * COVER_CLOSED constants).
      */
     float position;
-    ESPDEPRECATED("<cover>.state is deprecated, please use .position instead") float state;
+    espdeprecated("<cover>.state is deprecated, please use .position instead") float state;
   };
   /// The current tilt value of the cover from 0.0 to 1.0.
   float tilt{COVER_OPEN};
@@ -164,10 +164,10 @@ class Cover : public Nameable {
   friend CoverCall;
 
   virtual void control(const CoverCall &call) = 0;
-  virtual std::string device_class();
+  virtual std::string device_class_();
 
   optional<CoverRestoreState> restore_state_();
-  uint32_t hash_base() override;
+  uint32_t hash_base_() override;
 
   CallbackManager<void()> state_callback_{};
   optional<std::string> device_class_override_{};

esphome/components/cse7766/cse7766.cpp

@@ -42,11 +42,7 @@ bool CSE7766Component::check_byte_() {
   }
 
   if (index == 1) {
-    if (byte != 0x5A) {
-      ESP_LOGV(TAG, "Invalid Header 2 Start: 0x%02X!", byte);
-      return false;
-    }
-    return true;
+    return !;
   }
 
   if (index == 23) {
@@ -54,11 +50,7 @@ bool CSE7766Component::check_byte_() {
     for (uint8_t i = 2; i < 23; i++)
       checksum += this->raw_data_[i];
 
-    if (checksum != this->raw_data_[23]) {
-      ESP_LOGW(TAG, "Invalid checksum from CSE7766: 0x%02X != 0x%02X", checksum, this->raw_data_[23]);
-      return false;
-    }
-    return true;
+    return !;
   }
 
   return true;
@@ -161,7 +153,7 @@ void CSE7766Component::update() {
   this->current_counts_ = 0;
 }
 
-uint32_t CSE7766Component::get_24_bit_uint_(uint8_t start_index) {
+uint32_t CSE7766Component::get_24_bit_uint(uint8_t start_index) {
   return (uint32_t(this->raw_data_[start_index]) << 16) | (uint32_t(this->raw_data_[start_index + 1]) << 8) |
          uint32_t(this->raw_data_[start_index + 2]);
 }

esphome/components/dallas/dallas_component.cpp

@@ -110,13 +110,7 @@ void DallasComponent::update() {
 
   disable_interrupts();
   bool result;
-  if (!this->one_wire_->reset()) {
-    result = false;
-  } else {
-    result = true;
-    this->one_wire_->skip();
-    this->one_wire_->write8(DALLAS_COMMAND_START_CONVERSION);
-  }
+  result = !;
   enable_interrupts();
 
   if (!result) {
@@ -168,17 +162,7 @@ const std::string &DallasTemperatureSensor::get_address_name() {
 }
 bool DallasTemperatureSensor::read_scratch_pad() {
   ESPOneWire *wire = this->parent_->one_wire_;
-  if (!wire->reset()) {
-    return false;
-  }
-
-  wire->select(this->address_);
-  wire->write8(DALLAS_COMMAND_READ_SCRATCH_PAD);
-
-  for (unsigned char &i : this->scratch_pad_) {
-    i = wire->read8();
-  }
-  return true;
+  return !;
 }
 bool DallasTemperatureSensor::setup_sensor() {
   disable_interrupts();
@@ -244,11 +228,7 @@ bool DallasTemperatureSensor::check_scratch_pad() {
             this->scratch_pad_[5], this->scratch_pad_[6], this->scratch_pad_[7], this->scratch_pad_[8],
             crc8(this->scratch_pad_, 8));
 #endif
-  if (crc8(this->scratch_pad_, 8) != this->scratch_pad_[8]) {
-    ESP_LOGE(TAG, "Reading scratchpad from Dallas Sensor failed");
-    return false;
-  }
-  return true;
+  return !;
 }
 float DallasTemperatureSensor::get_temp_c() {
   int16_t temp = (int16_t(this->scratch_pad_[1]) << 11) | (int16_t(this->scratch_pad_[0]) << 3);

esphome/components/dht12/dht12.cpp

@@ -51,19 +51,14 @@ void DHT12Component::dump_config() {
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
 float DHT12Component::get_setup_priority() const { return setup_priority::DATA; }
-bool DHT12Component::read_data_(uint8_t *data) {
+bool DHT12Component::read_data(uint8_t *data) {
   if (!this->read_bytes(0, data, 5)) {
     ESP_LOGW(TAG, "Updating DHT12 failed!");
     return false;
   }
 
   uint8_t checksum = data[0] + data[1] + data[2] + data[3];
-  if (data[4] != checksum) {
-    ESP_LOGW(TAG, "DHT12 Checksum invalid!");
-    return false;
-  }
-
-  return true;
+  return !;
 }
 
 }  // namespace dht12

esphome/components/display/display_buffer.cpp

@@ -10,7 +10,7 @@ static const char *TAG = "display";
 const uint8_t COLOR_OFF = 0;
 const uint8_t COLOR_ON = 1;
 
-void DisplayBuffer::init_internal_(uint32_t buffer_length) {
+void DisplayBuffer::init_internal(uint32_t buffer_length) {
   this->buffer_ = new uint8_t[buffer_length];
   if (this->buffer_ == nullptr) {
     ESP_LOGE(TAG, "Could not allocate buffer for display!");

esphome/components/display/display_buffer.h

@@ -390,7 +390,7 @@ class Image {
 
 template<typename... Ts> class DisplayPageShowAction : public Action<Ts...> {
  public:
-  TEMPLATABLE_VALUE(DisplayPage *, page)
+  templatable_value(DisplayPage *, page)
   void play(Ts... x) override {
     auto *page = this->page_.value(x...);
     if (page != nullptr) {

esphome/components/endstop/endstop_cover.cpp

@@ -113,7 +113,7 @@ bool EndstopCover::is_at_target_() const {
       return true;
   }
 }
-void EndstopCover::start_direction_(CoverOperation dir) {
+void EndstopCover::start_direction(CoverOperation dir) {
   if (dir == this->current_operation)
     return;
 

esphome/components/endstop/endstop_cover.h

@@ -27,7 +27,7 @@ class EndstopCover : public cover::Cover, public Component {
   cover::CoverTraits get_traits() override;
 
  protected:
-  void control(const cover::CoverCall &call) override;
+  void control_(const cover::CoverCall &call) override;
   void stop_prev_trigger_();
   bool is_open_() const { return this->open_endstop_->state; }
   bool is_closed_() const { return this->close_endstop_->state; }

esphome/components/esp8266_pwm/esp8266_pwm.h

@@ -25,7 +25,7 @@ class ESP8266PWM : public output::FloatOutput, public Component {
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
  protected:
-  void write_state(float state) override;
+  void write_state_(float state) override;
 
   GPIOPin *pin_;
   float frequency_{1000.0};
@@ -36,7 +36,7 @@ class ESP8266PWM : public output::FloatOutput, public Component {
 template<typename... Ts> class SetFrequencyAction : public Action<Ts...> {
  public:
   SetFrequencyAction(ESP8266PWM *parent) : parent_(parent) {}
-  TEMPLATABLE_VALUE(float, frequency);
+  templatable_value(float, frequency);
 
   void play(Ts... x) {
     float freq = this->frequency_.value(x...);

esphome/components/fan/automation.h

@@ -11,7 +11,7 @@ template<typename... Ts> class TurnOnAction : public Action<Ts...> {
  public:
   explicit TurnOnAction(FanState *state) : state_(state) {}
 
-  TEMPLATABLE_VALUE(bool, oscillating)
+  templatable_value(bool, oscillating)
   TEMPLATABLE_VALUE(FanSpeed, speed)
 
   void play(Ts... x) override {

esphome/components/fan/fan_state.h

@@ -88,7 +88,7 @@ class FanState : public Nameable, public Component {
  protected:
   friend FanStateCall;
 
-  uint32_t hash_base() override;
+  uint32_t hash_base_() override;
 
   FanTraits traits_{};
   CallbackManager<void()> state_callback_{};

esphome/components/fastled_base/fastled_light.h

@@ -223,7 +223,7 @@ class FastLEDLightOutput : public light::AddressableLight {
   }
 
  protected:
-  light::ESPColorView get_view_internal(int32_t index) const override {
+  light::ESPColorView get_view_internal_(int32_t index) const override {
     return {&this->leds_[index].r,      &this->leds_[index].g, &this->leds_[index].b, nullptr,
             &this->effect_data_[index], &this->correction_};
   }

esphome/components/gpio/output/gpio_binary_output.h

@@ -20,7 +20,7 @@ class GPIOBinaryOutput : public output::BinaryOutput, public Component {
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
  protected:
-  void write_state(bool state) override { this->pin_->digital_write(state); }
+  void write_state_(bool state) override { this->pin_->digital_write(state); }
 
   GPIOPin *pin_;
 };

esphome/components/gpio/switch/gpio_switch.cpp

@@ -66,7 +66,7 @@ void GPIOSwitch::dump_config() {
     }
   }
 }
-void GPIOSwitch::write_state(bool state) {
+void GPIOSwitch::write_state_(bool state) {
   if (state != this->inverted_) {
     // Turning ON, check interlocking
     for (auto *lock : this->interlock_) {

esphome/components/gpio/switch/gpio_switch.h

@@ -28,7 +28,7 @@ class GPIOSwitch : public switch_::Switch, public Component {
   void set_interlock(const std::vector<Switch *> &interlock);
 
  protected:
-  void write_state(bool state) override;
+  void write_state_(bool state) override;
 
   GPIOPin *pin_;
   GPIOSwitchRestoreMode restore_mode_{GPIO_SWITCH_RESTORE_DEFAULT_OFF};

esphome/components/hx711/hx711.cpp

@@ -32,7 +32,7 @@ void HX711Sensor::update() {
     this->publish_state(value);
   }
 }
-bool HX711Sensor::read_sensor_(uint32_t *result) {
+bool HX711Sensor::read_sensor(uint32_t *result) {
   if (this->dout_pin_->digital_read()) {
     ESP_LOGW(TAG, "HX711 is not ready for new measurements yet!");
     this->status_set_warning();

esphome/components/i2c/i2c.cpp

@@ -82,11 +82,7 @@ bool I2CComponent::raw_end_transmission(uint8_t address) {
 bool I2CComponent::raw_request_from(uint8_t address, uint8_t len) {
   ESP_LOGVV(TAG, "Requesting %u bytes from 0x%02X:", len, address);
   uint8_t ret = this->wire_->requestFrom(address, len);
-  if (ret != len) {
-    ESP_LOGW(TAG, "Requesting %u bytes from 0x%02X failed!", len, address);
-    return false;
-  }
-  return true;
+  return !;
 }
 void HOT I2CComponent::raw_write(uint8_t address, const uint8_t *data, uint8_t len) {
   for (size_t i = 0; i < len; i++) {

esphome/components/integration/integration_sensor.h

@@ -56,9 +56,9 @@ class IntegrationSensor : public sensor::Sensor, public Component {
     this->publish_state(result);
     this->rtc_.save(&result);
   }
-  std::string unit_of_measurement() override;
-  std::string icon() override { return this->sensor_->get_icon(); }
-  int8_t accuracy_decimals() override { return this->sensor_->get_accuracy_decimals() + 2; }
+  std::string unit_of_measurement_() override;
+  std::string icon_() override { return this->sensor_->get_icon(); }
+  int8_t accuracy_decimals_() override { return this->sensor_->get_accuracy_decimals() + 2; }
 
   sensor::Sensor *sensor_;
   IntegrationSensorTime time_;

esphome/components/lcd_gpio/gpio_lcd_display.h

@@ -33,11 +33,11 @@ class GPIOLCDDisplay : public lcd_base::LCDDisplay {
   void dump_config() override;
 
  protected:
-  bool is_four_bit_mode() override { return this->data_pins_[4] == nullptr; }
-  void write_n_bits(uint8_t value, uint8_t n) override;
-  void send(uint8_t value, bool rs) override;
+  bool is_four_bit_mode_() override { return this->data_pins_[4] == nullptr; }
+  void write_n_bits_(uint8_t value, uint8_t n) override;
+  void send_(uint8_t value, bool rs) override;
 
-  void call_writer() override { this->writer_(*this); }
+  void call_writer_() override { this->writer_(*this); }
 
   GPIOPin *rs_pin_{nullptr};
   GPIOPin *rw_pin_{nullptr};

esphome/components/lcd_pcf8574/pcf8574_display.h

@@ -16,11 +16,11 @@ class PCF8574LCDDisplay : public lcd_base::LCDDisplay, public i2c::I2CDevice {
   void no_backlight();
 
  protected:
-  bool is_four_bit_mode() override { return true; }
-  void write_n_bits(uint8_t value, uint8_t n) override;
-  void send(uint8_t value, bool rs) override;
+  bool is_four_bit_mode_() override { return true; }
+  void write_n_bits_(uint8_t value, uint8_t n) override;
+  void send_(uint8_t value, bool rs) override;
 
-  void call_writer() override { this->writer_(*this); }
+  void call_writer_() override { this->writer_(*this); }
 
   // Stores the current state of the backlight.
   uint8_t backlight_value_;

esphome/components/light/light_state.cpp

@@ -7,12 +7,12 @@ namespace light {
 
 static const char *TAG = "light";
 
-void LightState::start_transition_(const LightColorValues &target, uint32_t length) {
+void LightState::start_transition(const LightColorValues &target, uint32_t length) {
   this->transformer_ = make_unique<LightTransitionTransformer>(millis(), length, this->current_values, target);
   this->remote_values = this->transformer_->get_remote_values();
 }
 
-void LightState::start_flash_(const LightColorValues &target, uint32_t length) {
+void LightState::start_flash(const LightColorValues &target, uint32_t length) {
   LightColorValues end_colors = this->current_values;
   // If starting a flash if one is already happening, set end values to end values of current flash
   // Hacky but works
@@ -24,7 +24,7 @@ void LightState::start_flash_(const LightColorValues &target, uint32_t length) {
 
 LightState::LightState(const std::string &name, LightOutput *output) : Nameable(name), output_(output) {}
 
-void LightState::set_immediately_(const LightColorValues &target) {
+void LightState::set_immediately(const LightColorValues &target) {
   this->transformer_ = nullptr;
   this->current_values = this->remote_values = target;
   this->next_write_ = true;
@@ -46,7 +46,7 @@ std::string LightState::get_effect_name() {
     return "None";
 }
 
-void LightState::start_effect_(uint32_t effect_index) {
+void LightState::start_effect(uint32_t effect_index) {
   this->stop_effect_();
   if (effect_index == 0)
     return;
@@ -57,7 +57,7 @@ void LightState::start_effect_(uint32_t effect_index) {
 }
 
 bool LightState::supports_effects() { return !this->effects_.empty(); }
-void LightState::set_transformer_(std::unique_ptr<LightTransformer> transformer) {
+void LightState::set_transformer(std::unique_ptr<LightTransformer> transformer) {
   this->transformer_ = std::move(transformer);
 }
 void LightState::stop_effect_() {
@@ -351,7 +351,7 @@ void LightCall::perform() {
   }
 }
 
-LightColorValues LightCall::validate_() {
+LightColorValues LightCall::validate() {
   // use remote values for fallback
   auto *name = this->parent_->get_name().c_str();
   auto traits = this->parent_->get_traits();

esphome/components/light/light_state.h

@@ -203,11 +203,11 @@ class LightState : public Nameable, public Component {
   LightColorValues current_values;
 
   /// Deprecated method to access current_values.
-  ESPDEPRECATED("get_current_values() is deprecated, please use .current_values instead.")
+  espdeprecated("get_current_values() is deprecated, please use .current_values instead.")
   LightColorValues get_current_values();
 
   /// Deprecated method to access remote_values.
-  ESPDEPRECATED("get_remote_values() is deprecated, please use .remote_values instead.")
+  espdeprecated("get_remote_values() is deprecated, please use .remote_values instead.")
   LightColorValues get_remote_values();
 
   /** The remote color values reported to the frontend.
@@ -278,7 +278,7 @@ class LightState : public Nameable, public Component {
   friend LightOutput;
   friend LightCall;
 
-  uint32_t hash_base() override;
+  uint32_t hash_base_() override;
 
   /// Internal method to start an effect with the given index
   void start_effect_(uint32_t effect_index);

esphome/components/max7219/max7219.cpp

@@ -145,11 +145,11 @@ void MAX7219Component::display() {
     this->disable();
   }
 }
-void MAX7219Component::send_byte_(uint8_t a_register, uint8_t data) {
+void MAX7219Component::send_byte(uint8_t a_register, uint8_t data) {
   this->write_byte(a_register);
   this->write_byte(data);
 }
-void MAX7219Component::send_to_all_(uint8_t a_register, uint8_t data) {
+void MAX7219Component::send_to_all(uint8_t a_register, uint8_t data) {
   this->enable();
   for (uint8_t i = 0; i < this->num_chips_; i++)
     this->send_byte_(a_register, data);

esphome/components/mcp23008/__init__.py

@@ -47,5 +47,5 @@ MCP23008_INPUT_PIN_SCHEMA = cv.Schema({
 @pins.PIN_SCHEMA_REGISTRY.register(CONF_MCP23008,
                                    (MCP23008_OUTPUT_PIN_SCHEMA, MCP23008_INPUT_PIN_SCHEMA))
 def mcp23008_pin_to_code(config):
-     parent = yield cg.get_variable(config[CONF_MCP23008])
-     yield MCP23008GPIOPin.new(parent, config[CONF_NUMBER], config[CONF_MODE], config[CONF_INVERTED])
+    parent = yield cg.get_variable(config[CONF_MCP23008])
+    yield MCP23008GPIOPin.new(parent, config[CONF_NUMBER], config[CONF_MODE], config[CONF_INVERTED])

esphome/components/mcp23008/mcp23008.cpp

@@ -19,7 +19,7 @@ void MCP23008::setup() {
 }
 bool MCP23008::digital_read(uint8_t pin) {
   uint8_t bit = pin % 8;
-  uint8_t reg_addr =  MCP23008_GPIO;
+  uint8_t reg_addr = MCP23008_GPIO;
   uint8_t value = 0;
   this->read_reg_(reg_addr, &value);
   return value & (1 << bit);
@@ -47,19 +47,19 @@ void MCP23008::pin_mode(uint8_t pin, uint8_t mode) {
   }
 }
 float MCP23008::get_setup_priority() const { return setup_priority::HARDWARE; }
-bool MCP23008::read_reg_(uint8_t reg, uint8_t *value) {
+bool MCP23008::read_reg(uint8_t reg, uint8_t *value) {
   if (this->is_failed())
     return false;
 
   return this->read_byte(reg, value);
 }
-bool MCP23008::write_reg_(uint8_t reg, uint8_t value) {
+bool MCP23008::write_reg(uint8_t reg, uint8_t value) {
   if (this->is_failed())
     return false;
 
   return this->write_byte(reg, value);
 }
-void MCP23008::update_reg_(uint8_t pin, bool pin_value, uint8_t reg_addr) {
+void MCP23008::update_reg(uint8_t pin, bool pin_value, uint8_t reg_addr) {
   uint8_t bit = pin % 8;
   uint8_t reg_value = 0;
   if (reg_addr == MCP23008_OLAT) {
@@ -77,7 +77,7 @@ void MCP23008::update_reg_(uint8_t pin, bool pin_value, uint8_t reg_addr) {
 
   if (reg_addr == MCP23008_OLAT) {
     this->olat_ = reg_value;
-  } 
+  }
 }
 
 MCP23008GPIOPin::MCP23008GPIOPin(MCP23008 *parent, uint8_t pin, uint8_t mode, bool inverted)

esphome/components/mcp23017/mcp23017.cpp

@@ -48,19 +48,19 @@ void MCP23017::pin_mode(uint8_t pin, uint8_t mode) {
   }
 }
 float MCP23017::get_setup_priority() const { return setup_priority::HARDWARE; }
-bool MCP23017::read_reg_(uint8_t reg, uint8_t *value) {
+bool MCP23017::read_reg(uint8_t reg, uint8_t *value) {
   if (this->is_failed())
     return false;
 
   return this->read_byte(reg, value);
 }
-bool MCP23017::write_reg_(uint8_t reg, uint8_t value) {
+bool MCP23017::write_reg(uint8_t reg, uint8_t value) {
   if (this->is_failed())
     return false;
 
   return this->write_byte(reg, value);
 }
-void MCP23017::update_reg_(uint8_t pin, bool pin_value, uint8_t reg_addr) {
+void MCP23017::update_reg(uint8_t pin, bool pin_value, uint8_t reg_addr) {
   uint8_t bit = pin % 8;
   uint8_t reg_value = 0;
   if (reg_addr == MCP23017_OLATA) {

esphome/components/mhz19/mhz19.cpp

@@ -50,7 +50,7 @@ void MHZ19Component::update() {
     this->temperature_sensor_->publish_state(temp);
 }
 
-bool MHZ19Component::mhz19_write_command_(const uint8_t *command, uint8_t *response) {
+bool MHZ19Component::mhz19_write_command(const uint8_t *command, uint8_t *response) {
   this->flush();
   this->write_array(command, MHZ19_REQUEST_LENGTH);
   this->write_byte(mhz19_checksum(command));

esphome/components/mqtt/mqtt_client.cpp

@@ -286,7 +286,7 @@ void MQTTClientComponent::loop() {
 float MQTTClientComponent::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
 
 // Subscribe
-bool MQTTClientComponent::subscribe_(const char *topic, uint8_t qos) {
+bool MQTTClientComponent::subscribe(const char *topic, uint8_t qos) {
   if (!this->is_connected())
     return false;
 

esphome/components/mqtt/mqtt_client.h

@@ -294,7 +294,7 @@ class MQTTJsonMessageTrigger : public Trigger<const JsonObject &> {
 template<typename... Ts> class MQTTPublishAction : public Action<Ts...> {
  public:
   MQTTPublishAction(MQTTClientComponent *parent) : parent_(parent) {}
-  TEMPLATABLE_VALUE(std::string, topic)
+  templatable_value(std::string, topic)
   TEMPLATABLE_VALUE(std::string, payload)
   TEMPLATABLE_VALUE(uint8_t, qos)
   TEMPLATABLE_VALUE(bool, retain)
@@ -311,7 +311,7 @@ template<typename... Ts> class MQTTPublishAction : public Action<Ts...> {
 template<typename... Ts> class MQTTPublishJsonAction : public Action<Ts...> {
  public:
   MQTTPublishJsonAction(MQTTClientComponent *parent) : parent_(parent) {}
-  TEMPLATABLE_VALUE(std::string, topic)
+  templatable_value(std::string, topic)
   TEMPLATABLE_VALUE(uint8_t, qos)
   TEMPLATABLE_VALUE(bool, retain)