Merge pull request #1548 from esphome/bump-1.16.2

1.16.2

CODEOWNERS

@@ -100,3 +100,4 @@ esphome/components/version/* @esphome/core
 esphome/components/web_server_base/* @OttoWinter
 esphome/components/whirlpool/* @glmnet
 esphome/components/xiaomi_lywsd03mmc/* @ahpohl
+esphome/components/xiaomi_mhoc401/* @vevsvevs

docker/Dockerfile

@@ -15,6 +15,10 @@ ENV USERNAME="" PASSWORD=""
 # Expose the dashboard to Docker
 EXPOSE 6052
 
+# Run healthcheck (heartbeat)
+HEALTHCHECK --interval=30s --timeout=30s \
+  CMD curl --fail http://localhost:6052 || exit 1
+
 # The directory the user should mount their configuration files to
 WORKDIR /config
 # Set entrypoint to esphome so that the user doesn't have to type 'esphome'

esphome/components/dht/dht.cpp

@@ -32,19 +32,19 @@ void DHT::dump_config() {
 
 void DHT::update() {
   float temperature, humidity;
-  bool error;
+  bool success;
   if (this->model_ == DHT_MODEL_AUTO_DETECT) {
     this->model_ = DHT_MODEL_DHT22;
-    error = this->read_sensor_(&temperature, &humidity, false);
-    if (error) {
+    success = this->read_sensor_(&temperature, &humidity, false);
+    if (!success) {
       this->model_ = DHT_MODEL_DHT11;
       return;
     }
   } else {
-    error = this->read_sensor_(&temperature, &humidity, true);
+    success = this->read_sensor_(&temperature, &humidity, true);
   }
 
-  if (error) {
+  if (success) {
     ESP_LOGD(TAG, "Got Temperature=%.1f°C Humidity=%.1f%%", temperature, humidity);
 
     if (this->temperature_sensor_ != nullptr)

esphome/components/hlw8012/hlw8012.cpp

@@ -79,6 +79,12 @@ void HLW8012Component::update() {
     this->power_sensor_->publish_state(power);
   }
 
+  if (this->energy_sensor_ != nullptr) {
+    cf_total_pulses_ += raw_cf;
+    float energy = cf_total_pulses_ * power_multiplier_micros / 3600 / 1000000.0f;
+    this->energy_sensor_->publish_state(energy);
+  }
+
   if (this->change_mode_at_++ == this->change_mode_every_) {
     this->current_mode_ = !this->current_mode_;
     ESP_LOGV(TAG, "Changing mode to %s mode", this->current_mode_ ? "CURRENT" : "VOLTAGE");

esphome/components/hlw8012/hlw8012.h

@@ -29,6 +29,7 @@ class HLW8012Component : public PollingComponent {
   void set_voltage_sensor(sensor::Sensor *voltage_sensor) { voltage_sensor_ = voltage_sensor; }
   void set_current_sensor(sensor::Sensor *current_sensor) { current_sensor_ = current_sensor; }
   void set_power_sensor(sensor::Sensor *power_sensor) { power_sensor_ = power_sensor; }
+  void set_energy_sensor(sensor::Sensor *energy_sensor) { energy_sensor_ = energy_sensor; }
 
  protected:
   uint32_t nth_value_{0};
@@ -37,6 +38,7 @@ class HLW8012Component : public PollingComponent {
   uint32_t change_mode_every_{8};
   float current_resistor_{0.001};
   float voltage_divider_{2351};
+  uint64_t cf_total_pulses_{0};
   GPIOPin *sel_pin_;
   GPIOPin *cf_pin_;
   pulse_counter::PulseCounterStorage cf_store_;
@@ -45,6 +47,7 @@ class HLW8012Component : public PollingComponent {
   sensor::Sensor *voltage_sensor_{nullptr};
   sensor::Sensor *current_sensor_{nullptr};
   sensor::Sensor *power_sensor_{nullptr};
+  sensor::Sensor *energy_sensor_{nullptr};
 };
 
 }  // namespace hlw8012

esphome/components/hlw8012/sensor.py

@@ -3,8 +3,8 @@ import esphome.config_validation as cv
 from esphome import pins
 from esphome.components import sensor
 from esphome.const import CONF_CHANGE_MODE_EVERY, CONF_INITIAL_MODE, CONF_CURRENT, \
-    CONF_CURRENT_RESISTOR, CONF_ID, CONF_POWER, CONF_SEL_PIN, CONF_VOLTAGE, CONF_VOLTAGE_DIVIDER, \
-    ICON_FLASH, UNIT_VOLT, UNIT_AMPERE, UNIT_WATT
+    CONF_CURRENT_RESISTOR, CONF_ID, CONF_POWER, CONF_ENERGY, CONF_SEL_PIN, CONF_VOLTAGE, \
+    CONF_VOLTAGE_DIVIDER, ICON_FLASH, UNIT_VOLT, UNIT_AMPERE, UNIT_WATT, UNIT_WATT_HOURS
 
 AUTO_LOAD = ['pulse_counter']
 
@@ -29,6 +29,7 @@ CONFIG_SCHEMA = cv.Schema({
     cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1),
     cv.Optional(CONF_CURRENT): sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2),
     cv.Optional(CONF_POWER): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 1),
+    cv.Optional(CONF_ENERGY): sensor.sensor_schema(UNIT_WATT_HOURS, ICON_FLASH, 1),
 
     cv.Optional(CONF_CURRENT_RESISTOR, default=0.001): cv.resistance,
     cv.Optional(CONF_VOLTAGE_DIVIDER, default=2351): cv.positive_float,
@@ -57,6 +58,9 @@ def to_code(config):
     if CONF_POWER in config:
         sens = yield sensor.new_sensor(config[CONF_POWER])
         cg.add(var.set_power_sensor(sens))
+    if CONF_ENERGY in config:
+        sens = yield sensor.new_sensor(config[CONF_ENERGY])
+        cg.add(var.set_energy_sensor(sens))
     cg.add(var.set_current_resistor(config[CONF_CURRENT_RESISTOR]))
     cg.add(var.set_voltage_divider(config[CONF_VOLTAGE_DIVIDER]))
     cg.add(var.set_change_mode_every(config[CONF_CHANGE_MODE_EVERY]))

esphome/components/max7219/display.py

@@ -9,11 +9,14 @@ max7219_ns = cg.esphome_ns.namespace('max7219')
 MAX7219Component = max7219_ns.class_('MAX7219Component', cg.PollingComponent, spi.SPIDevice)
 MAX7219ComponentRef = MAX7219Component.operator('ref')
 
+CONF_REVERSE_ENABLE = 'reverse_enable'
+
 CONFIG_SCHEMA = display.BASIC_DISPLAY_SCHEMA.extend({
     cv.GenerateID(): cv.declare_id(MAX7219Component),
 
     cv.Optional(CONF_NUM_CHIPS, default=1): cv.int_range(min=1, max=255),
     cv.Optional(CONF_INTENSITY, default=15): cv.int_range(min=0, max=15),
+    cv.Optional(CONF_REVERSE_ENABLE, default=False): cv.boolean,
 }).extend(cv.polling_component_schema('1s')).extend(spi.spi_device_schema())
 
 
@@ -25,6 +28,7 @@ def to_code(config):
 
     cg.add(var.set_num_chips(config[CONF_NUM_CHIPS]))
     cg.add(var.set_intensity(config[CONF_INTENSITY]))
+    cg.add(var.set_reverse(config[CONF_REVERSE_ENABLE]))
 
     if CONF_LAMBDA in config:
         lambda_ = yield cg.process_lambda(config[CONF_LAMBDA], [(MAX7219ComponentRef, 'it')],

esphome/components/max7219/max7219.cpp

@@ -142,9 +142,11 @@ void MAX7219Component::dump_config() {
 void MAX7219Component::display() {
   for (uint8_t i = 0; i < 8; i++) {
     this->enable();
-    for (uint8_t j = 0; j < this->num_chips_; j++) {
-      this->send_byte_(8 - i, this->buffer_[j * 8 + i]);
-    }
+    for (uint8_t j = 0; j < this->num_chips_; j++)
+      if (reverse_)
+        this->send_byte_(8 - i, buffer_[(num_chips_ - j - 1) * 8 + i]);
+      else
+        this->send_byte_(8 - i, buffer_[j * 8 + i]);
     this->disable();
   }
 }

esphome/components/max7219/max7219.h

@@ -34,6 +34,7 @@ class MAX7219Component : public PollingComponent,
 
   void set_intensity(uint8_t intensity);
   void set_num_chips(uint8_t num_chips);
+  void set_reverse(bool reverse) { this->reverse_ = reverse; };
 
   /// Evaluate the printf-format and print the result at the given position.
   uint8_t printf(uint8_t pos, const char *format, ...) __attribute__((format(printf, 3, 4)));
@@ -60,6 +61,7 @@ class MAX7219Component : public PollingComponent,
   uint8_t intensity_{15};  /// Intensity of the display from 0 to 15 (most)
   uint8_t num_chips_{1};
   uint8_t *buffer_;
+  bool reverse_{false};
   optional<max7219_writer_t> writer_{};
 };
 

esphome/components/mcp23008/__init__.py

@@ -2,7 +2,7 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import pins
 from esphome.components import i2c
-from esphome.const import CONF_ID, CONF_NUMBER, CONF_MODE, CONF_INVERTED
+from esphome.const import CONF_ID, CONF_NUMBER, CONF_MODE, CONF_INVERTED, CONF_OPEN_DRAIN_INTERRUPT
 
 DEPENDENCIES = ['i2c']
 MULTI_CONF = True
@@ -20,6 +20,7 @@ MCP23008GPIOPin = mcp23008_ns.class_('MCP23008GPIOPin', cg.GPIOPin)
 
 CONFIG_SCHEMA = cv.Schema({
     cv.Required(CONF_ID): cv.declare_id(MCP23008),
+    cv.Optional(CONF_OPEN_DRAIN_INTERRUPT, default=False): cv.boolean,
 }).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x20))
 
 
@@ -27,6 +28,7 @@ def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     yield cg.register_component(var, config)
     yield i2c.register_i2c_device(var, config)
+    cg.add(var.set_open_drain_ints(config[CONF_OPEN_DRAIN_INTERRUPT]))
 
 
 CONF_MCP23008 = 'mcp23008'

esphome/components/mcp23008/mcp23008.cpp

@@ -14,8 +14,10 @@ void MCP23008::setup() {
     return;
   }
 
-  // all pins input
-  this->write_reg_(MCP23008_IODIR, 0xFF);
+  if (this->open_drain_ints_) {
+    // enable open-drain interrupt pins, 3.3V-safe
+    this->write_reg_(MCP23008_IOCON, 0x04);
+  }
 }
 bool MCP23008::digital_read(uint8_t pin) {
   uint8_t bit = pin % 8;

esphome/components/mcp23008/mcp23008.h

@@ -39,6 +39,8 @@ class MCP23008 : public Component, public i2c::I2CDevice {
   void digital_write(uint8_t pin, bool value);
   void pin_mode(uint8_t pin, uint8_t mode);
 
+  void set_open_drain_ints(const bool value) { open_drain_ints_ = value; }
+
   float get_setup_priority() const override;
 
  protected:
@@ -50,6 +52,7 @@ class MCP23008 : public Component, public i2c::I2CDevice {
   void update_reg_(uint8_t pin, bool pin_value, uint8_t reg_a);
 
   uint8_t olat_{0x00};
+  bool open_drain_ints_;
 };
 
 class MCP23008GPIOPin : public GPIOPin {

esphome/components/mcp23017/__init__.py

@@ -2,7 +2,7 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import pins
 from esphome.components import i2c
-from esphome.const import CONF_ID, CONF_NUMBER, CONF_MODE, CONF_INVERTED
+from esphome.const import CONF_ID, CONF_NUMBER, CONF_MODE, CONF_INVERTED, CONF_OPEN_DRAIN_INTERRUPT
 
 DEPENDENCIES = ['i2c']
 MULTI_CONF = True
@@ -20,6 +20,7 @@ MCP23017GPIOPin = mcp23017_ns.class_('MCP23017GPIOPin', cg.GPIOPin)
 
 CONFIG_SCHEMA = cv.Schema({
     cv.Required(CONF_ID): cv.declare_id(MCP23017),
+    cv.Optional(CONF_OPEN_DRAIN_INTERRUPT, default=False): cv.boolean,
 }).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x20))
 
 
@@ -27,6 +28,7 @@ def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     yield cg.register_component(var, config)
     yield i2c.register_i2c_device(var, config)
+    cg.add(var.set_open_drain_ints(config[CONF_OPEN_DRAIN_INTERRUPT]))
 
 
 CONF_MCP23017 = 'mcp23017'

esphome/components/mcp23017/mcp23017.cpp

@@ -14,9 +14,11 @@ void MCP23017::setup() {
     return;
   }
 
-  // all pins input
-  this->write_reg_(MCP23017_IODIRA, 0xFF);
-  this->write_reg_(MCP23017_IODIRB, 0xFF);
+  if (this->open_drain_ints_) {
+    // enable open-drain interrupt pins, 3.3V-safe
+    this->write_reg_(MCP23017_IOCONA, 0x04);
+    this->write_reg_(MCP23017_IOCONB, 0x04);
+  }
 }
 bool MCP23017::digital_read(uint8_t pin) {
   uint8_t bit = pin % 8;

esphome/components/mcp23017/mcp23017.h

@@ -51,6 +51,8 @@ class MCP23017 : public Component, public i2c::I2CDevice {
   void digital_write(uint8_t pin, bool value);
   void pin_mode(uint8_t pin, uint8_t mode);
 
+  void set_open_drain_ints(const bool value) { open_drain_ints_ = value; }
+
   float get_setup_priority() const override;
 
  protected:
@@ -63,6 +65,7 @@ class MCP23017 : public Component, public i2c::I2CDevice {
 
   uint8_t olat_a_{0x00};
   uint8_t olat_b_{0x00};
+  bool open_drain_ints_;
 };
 
 class MCP23017GPIOPin : public GPIOPin {

esphome/components/ota/__init__.py

@@ -1,3 +1,4 @@
+from esphome.cpp_generator import RawExpression
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
@@ -31,7 +32,9 @@ def to_code(config):
     yield cg.register_component(var, config)
 
     if config[CONF_SAFE_MODE]:
-        cg.add(var.start_safe_mode(config[CONF_NUM_ATTEMPTS], config[CONF_REBOOT_TIMEOUT]))
+        condition = var.should_enter_safe_mode(config[CONF_NUM_ATTEMPTS],
+                                               config[CONF_REBOOT_TIMEOUT])
+        cg.add(RawExpression(f"if ({condition}) return"))
 
     if CORE.is_esp8266:
         cg.add_library('Update', None)

esphome/components/ota/ota_component.cpp

@@ -355,7 +355,7 @@ void OTAComponent::set_auth_password(const std::string &password) { this->passwo
 float OTAComponent::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
 uint16_t OTAComponent::get_port() const { return this->port_; }
 void OTAComponent::set_port(uint16_t port) { this->port_ = port; }
-void OTAComponent::start_safe_mode(uint8_t num_attempts, uint32_t enable_time) {
+bool OTAComponent::should_enter_safe_mode(uint8_t num_attempts, uint32_t enable_time) {
   this->has_safe_mode_ = true;
   this->safe_mode_start_time_ = millis();
   this->safe_mode_enable_time_ = enable_time;
@@ -380,12 +380,11 @@ void OTAComponent::start_safe_mode(uint8_t num_attempts, uint32_t enable_time) {
 
     ESP_LOGI(TAG, "Waiting for OTA attempt.");
 
-    while (true) {
-      App.loop();
-    }
+    return true;
   } else {
     // increment counter
     this->write_rtc_(this->safe_mode_rtc_value_ + 1);
+    return false;
   }
 }
 void OTAComponent::write_rtc_(uint32_t val) { this->rtc_.save(&val); }

esphome/components/ota/ota_component.h

@@ -47,7 +47,7 @@ class OTAComponent : public Component {
   /// Manually set the port OTA should listen on.
   void set_port(uint16_t port);
 
-  void start_safe_mode(uint8_t num_attempts, uint32_t enable_time);
+  bool should_enter_safe_mode(uint8_t num_attempts, uint32_t enable_time);
 
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)

esphome/components/pn532/pn532.cpp

@@ -22,7 +22,7 @@ void PN532::setup() {
   }
 
   std::vector<uint8_t> version_data;
-  if (!this->read_response_(PN532_COMMAND_VERSION_DATA, version_data)) {
+  if (!this->read_response(PN532_COMMAND_VERSION_DATA, version_data)) {
     ESP_LOGE(TAG, "Error getting version");
     this->mark_failed();
     return;
@@ -42,7 +42,7 @@ void PN532::setup() {
   }
 
   std::vector<uint8_t> wakeup_result;
-  if (!this->read_response_(PN532_COMMAND_SAMCONFIGURATION, wakeup_result)) {
+  if (!this->read_response(PN532_COMMAND_SAMCONFIGURATION, wakeup_result)) {
     this->error_code_ = WAKEUP_FAILED;
     this->mark_failed();
     return;
@@ -62,7 +62,7 @@ void PN532::setup() {
   }
 
   std::vector<uint8_t> sam_result;
-  if (!this->read_response_(PN532_COMMAND_SAMCONFIGURATION, sam_result)) {
+  if (!this->read_response(PN532_COMMAND_SAMCONFIGURATION, sam_result)) {
     ESP_LOGV(TAG, "Invalid SAM result: (%u)", sam_result.size());  // NOLINT
     for (uint8_t dat : sam_result) {
       ESP_LOGV(TAG, " 0x%02X", dat);
@@ -97,7 +97,7 @@ void PN532::loop() {
     return;
 
   std::vector<uint8_t> read;
-  bool success = this->read_response_(PN532_COMMAND_INLISTPASSIVETARGET, read);
+  bool success = this->read_response(PN532_COMMAND_INLISTPASSIVETARGET, read);
 
   this->requested_read_ = false;
 
@@ -230,7 +230,7 @@ bool PN532::write_command_(const std::vector<uint8_t> &data) {
 }
 
 bool PN532::read_ack_() {
-  ESP_LOGVV(TAG, "Reading ACK...");
+  ESP_LOGV(TAG, "Reading ACK...");
 
   std::vector<uint8_t> data;
   if (!this->read_data(data, 6)) {
@@ -241,96 +241,18 @@ bool PN532::read_ack_() {
                   data[2] == 0x00 &&                     // start of packet
                   data[3] == 0xFF && data[4] == 0x00 &&  // ACK packet code
                   data[5] == 0xFF && data[6] == 0x00);   // postamble
-  ESP_LOGVV(TAG, "ACK valid: %s", YESNO(matches));
+  ESP_LOGV(TAG, "ACK valid: %s", YESNO(matches));
   return matches;
 }
 
-bool PN532::read_response_(uint8_t command, std::vector<uint8_t> &data) {
-  ESP_LOGV(TAG, "Reading response");
-  uint8_t len = this->read_response_length_();
-  if (len == 0) {
-    return false;
-  }
-
-  ESP_LOGV(TAG, "Reading response of length %d", len);
-  if (!this->read_data(data, 6 + len + 2)) {
-    ESP_LOGD(TAG, "No response data");
-    return false;
-  }
-
-  if (data[1] != 0x00 && data[2] != 0x00 && data[3] != 0xFF) {
-    // invalid packet
-    ESP_LOGV(TAG, "read data invalid preamble!");
-    return false;
-  }
-
-  bool valid_header = (static_cast<uint8_t>(data[4] + data[5]) == 0 &&  // LCS, len + lcs = 0
-                       data[6] == 0xD5 &&                               // TFI - frame from PN532 to system controller
-                       data[7] == command + 1);                         // Correct command response
-
-  if (!valid_header) {
-    ESP_LOGV(TAG, "read data invalid header!");
-    return false;
-  }
-
-  data.erase(data.begin(), data.begin() + 6);  // Remove headers
-
-  uint8_t checksum = 0;
-  for (int i = 0; i < len + 1; i++) {
-    uint8_t dat = data[i];
-    checksum += dat;
-  }
-  checksum = ~checksum + 1;
-
-  if (data[len + 1] != checksum) {
-    ESP_LOGV(TAG, "read data invalid checksum! %02X != %02X", data[len], checksum);
-    return false;
-  }
-
-  if (data[len + 2] != 0x00) {
-    ESP_LOGV(TAG, "read data invalid postamble!");
-    return false;
-  }
-
-  data.erase(data.begin(), data.begin() + 2);  // Remove TFI and command code
-  data.erase(data.end() - 2, data.end());      // Remove checksum and postamble
-
-  return true;
-}
-
-uint8_t PN532::read_response_length_() {
-  std::vector<uint8_t> data;
-  if (!this->read_data(data, 6)) {
-    return 0;
-  }
-
-  if (data[1] != 0x00 && data[2] != 0x00 && data[3] != 0xFF) {
-    // invalid packet
-    ESP_LOGV(TAG, "read data invalid preamble!");
-    return 0;
-  }
-
-  bool valid_header = (static_cast<uint8_t>(data[4] + data[5]) == 0 &&  // LCS, len + lcs = 0
-                       data[6] == 0xD5);                                // TFI - frame from PN532 to system controller
-
-  if (!valid_header) {
-    ESP_LOGV(TAG, "read data invalid header!");
-    return 0;
-  }
-
-  this->write_data({0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00});  // NACK - Retransmit last message
-
-  // full length of message, including TFI
-  uint8_t full_len = data[4];
-  // length of data, excluding TFI
-  uint8_t len = full_len - 1;
-  if (full_len == 0)
-    len = 0;
-  return len;
+void PN532::send_nack_() {
+  ESP_LOGV(TAG, "Sending NACK for retransmit");
+  this->write_data({0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00});
+  delay(10);
 }
 
 void PN532::turn_off_rf_() {
-  ESP_LOGVV(TAG, "Turning RF field OFF");
+  ESP_LOGV(TAG, "Turning RF field OFF");
   this->write_command_({
       PN532_COMMAND_RFCONFIGURATION,
       0x01,  // RF Field

esphome/components/pn532/pn532.h

@@ -46,12 +46,12 @@ class PN532 : public PollingComponent {
  protected:
   void turn_off_rf_();
   bool write_command_(const std::vector<uint8_t> &data);
-  bool read_response_(uint8_t command, std::vector<uint8_t> &data);
   bool read_ack_();
-  uint8_t read_response_length_();
+  void send_nack_();
 
   virtual bool write_data(const std::vector<uint8_t> &data) = 0;
   virtual bool read_data(std::vector<uint8_t> &data, uint8_t len) = 0;
+  virtual bool read_response(uint8_t command, std::vector<uint8_t> &data) = 0;
 
   nfc::NfcTag *read_tag_(std::vector<uint8_t> &uid);
 

esphome/components/pn532/pn532_mifare_classic.cpp

@@ -64,7 +64,7 @@ bool PN532::read_mifare_classic_block_(uint8_t block_num, std::vector<uint8_t> &
     return false;
   }
 
-  if (!this->read_response_(PN532_COMMAND_INDATAEXCHANGE, data) || data[0] != 0x00) {
+  if (!this->read_response(PN532_COMMAND_INDATAEXCHANGE, data) || data[0] != 0x00) {
     return false;
   }
   data.erase(data.begin());
@@ -89,7 +89,7 @@ bool PN532::auth_mifare_classic_block_(std::vector<uint8_t> &uid, uint8_t block_
   }
 
   std::vector<uint8_t> response;
-  if (!this->read_response_(PN532_COMMAND_INDATAEXCHANGE, response) || response[0] != 0x00) {
+  if (!this->read_response(PN532_COMMAND_INDATAEXCHANGE, response) || response[0] != 0x00) {
     ESP_LOGE(TAG, "Authentication failed - Block 0x%02x", block_num);
     return false;
   }
@@ -194,7 +194,7 @@ bool PN532::write_mifare_classic_block_(uint8_t block_num, std::vector<uint8_t>
   }
 
   std::vector<uint8_t> response;
-  if (!this->read_response_(PN532_COMMAND_INDATAEXCHANGE, response)) {
+  if (!this->read_response(PN532_COMMAND_INDATAEXCHANGE, response)) {
     ESP_LOGE(TAG, "Error writing block %d", block_num);
     return false;
   }

esphome/components/pn532/pn532_mifare_ultralight.cpp

@@ -52,7 +52,7 @@ bool PN532::read_mifare_ultralight_page_(uint8_t page_num, std::vector<uint8_t>
     return false;
   }
 
-  if (!this->read_response_(PN532_COMMAND_INDATAEXCHANGE, data) || data[0] != 0x00) {
+  if (!this->read_response(PN532_COMMAND_INDATAEXCHANGE, data) || data[0] != 0x00) {
     return false;
   }
   data.erase(data.begin());
@@ -168,7 +168,7 @@ bool PN532::write_mifare_ultralight_page_(uint8_t page_num, std::vector<uint8_t>
   }
 
   std::vector<uint8_t> response;
-  if (!this->read_response_(PN532_COMMAND_INDATAEXCHANGE, response)) {
+  if (!this->read_response(PN532_COMMAND_INDATAEXCHANGE, response)) {
     ESP_LOGE(TAG, "Error writing page %d", page_num);
     return false;
   }

esphome/components/pn532_i2c/pn532_i2c.cpp

@@ -36,6 +36,90 @@ bool PN532I2C::read_data(std::vector<uint8_t> &data, uint8_t len) {
   return true;
 }
 
+bool PN532I2C::read_response(uint8_t command, std::vector<uint8_t> &data) {
+  ESP_LOGV(TAG, "Reading response");
+  uint8_t len = this->read_response_length_();
+  if (len == 0) {
+    return false;
+  }
+
+  ESP_LOGV(TAG, "Reading response of length %d", len);
+  if (!this->read_data(data, 6 + len + 2)) {
+    ESP_LOGD(TAG, "No response data");
+    return false;
+  }
+
+  if (data[1] != 0x00 && data[2] != 0x00 && data[3] != 0xFF) {
+    // invalid packet
+    ESP_LOGV(TAG, "read data invalid preamble!");
+    return false;
+  }
+
+  bool valid_header = (static_cast<uint8_t>(data[4] + data[5]) == 0 &&  // LCS, len + lcs = 0
+                       data[6] == 0xD5 &&                               // TFI - frame from PN532 to system controller
+                       data[7] == command + 1);                         // Correct command response
+
+  if (!valid_header) {
+    ESP_LOGV(TAG, "read data invalid header!");
+    return false;
+  }
+
+  data.erase(data.begin(), data.begin() + 6);  // Remove headers
+
+  uint8_t checksum = 0;
+  for (int i = 0; i < len + 1; i++) {
+    uint8_t dat = data[i];
+    checksum += dat;
+  }
+  checksum = ~checksum + 1;
+
+  if (data[len + 1] != checksum) {
+    ESP_LOGV(TAG, "read data invalid checksum! %02X != %02X", data[len], checksum);
+    return false;
+  }
+
+  if (data[len + 2] != 0x00) {
+    ESP_LOGV(TAG, "read data invalid postamble!");
+    return false;
+  }
+
+  data.erase(data.begin(), data.begin() + 2);  // Remove TFI and command code
+  data.erase(data.end() - 2, data.end());      // Remove checksum and postamble
+
+  return true;
+}
+
+uint8_t PN532I2C::read_response_length_() {
+  std::vector<uint8_t> data;
+  if (!this->read_data(data, 6)) {
+    return 0;
+  }
+
+  if (data[1] != 0x00 && data[2] != 0x00 && data[3] != 0xFF) {
+    // invalid packet
+    ESP_LOGV(TAG, "read data invalid preamble!");
+    return 0;
+  }
+
+  bool valid_header = (static_cast<uint8_t>(data[4] + data[5]) == 0 &&  // LCS, len + lcs = 0
+                       data[6] == 0xD5);                                // TFI - frame from PN532 to system controller
+
+  if (!valid_header) {
+    ESP_LOGV(TAG, "read data invalid header!");
+    return 0;
+  }
+
+  this->send_nack_();
+
+  // full length of message, including TFI
+  uint8_t full_len = data[4];
+  // length of data, excluding TFI
+  uint8_t len = full_len - 1;
+  if (full_len == 0)
+    len = 0;
+  return len;
+}
+
 void PN532I2C::dump_config() {
   PN532::dump_config();
   LOG_I2C_DEVICE(this);

esphome/components/pn532_i2c/pn532_i2c.h

@@ -14,6 +14,8 @@ class PN532I2C : public pn532::PN532, public i2c::I2CDevice {
  protected:
   bool write_data(const std::vector<uint8_t> &data) override;
   bool read_data(std::vector<uint8_t> &data, uint8_t len) override;
+  bool read_response(uint8_t command, std::vector<uint8_t> &data) override;
+  uint8_t read_response_length_();
 };
 
 }  // namespace pn532_i2c

esphome/components/pn532_spi/pn532_spi.cpp

@@ -26,7 +26,7 @@ bool PN532Spi::write_data(const std::vector<uint8_t> &data) {
   delay(2);
   // First byte, communication mode: Write data
   this->write_byte(0x01);
-
+  ESP_LOGV(TAG, "Writing data: %s", hexencode(data).c_str());
   this->write_array(data.data(), data.size());
   this->disable();
 
@@ -34,31 +34,122 @@ bool PN532Spi::write_data(const std::vector<uint8_t> &data) {
 }
 
 bool PN532Spi::read_data(std::vector<uint8_t> &data, uint8_t len) {
-  this->enable();
-  // First byte, communication mode: Read state
-  this->write_byte(0x02);
+  ESP_LOGV(TAG, "Waiting for ready byte...");
 
   uint32_t start_time = millis();
   while (true) {
-    if (this->read_byte() & 0x01)
+    this->enable();
+    // First byte, communication mode: Read state
+    this->write_byte(0x02);
+    bool ready = this->read_byte() == 0x01;
+    this->disable();
+    if (ready)
       break;
+    ESP_LOGV(TAG, "Not ready yet...");
 
     if (millis() - start_time > 100) {
-      this->disable();
       ESP_LOGV(TAG, "Timed out waiting for readiness from PN532!");
       return false;
     }
+    yield();
   }
 
   // Read data (transmission from the PN532 to the host)
+  this->enable();
+  delay(2);
   this->write_byte(0x03);
 
+  ESP_LOGV(TAG, "Reading data...");
+
   data.resize(len);
   this->read_array(data.data(), len);
   this->disable();
   data.insert(data.begin(), 0x01);
+  ESP_LOGV(TAG, "Read data: %s", hexencode(data).c_str());
   return true;
-};
+}
+
+bool PN532Spi::read_response(uint8_t command, std::vector<uint8_t> &data) {
+  ESP_LOGV(TAG, "Reading response");
+
+  uint32_t start_time = millis();
+  while (true) {
+    this->enable();
+    // First byte, communication mode: Read state
+    this->write_byte(0x02);
+    bool ready = this->read_byte() == 0x01;
+    this->disable();
+    if (ready)
+      break;
+    ESP_LOGV(TAG, "Not ready yet...");
+
+    if (millis() - start_time > 100) {
+      ESP_LOGV(TAG, "Timed out waiting for readiness from PN532!");
+      return false;
+    }
+    yield();
+  }
+
+  this->enable();
+  delay(2);
+  this->write_byte(0x03);
+
+  std::vector<uint8_t> header(7);
+  this->read_array(header.data(), 7);
+
+  ESP_LOGV(TAG, "Header data: %s", hexencode(header).c_str());
+
+  if (header[0] != 0x00 && header[1] != 0x00 && header[2] != 0xFF) {
+    // invalid packet
+    ESP_LOGV(TAG, "read data invalid preamble!");
+    return false;
+  }
+
+  bool valid_header = (static_cast<uint8_t>(header[3] + header[4]) == 0 &&  // LCS, len + lcs = 0
+                       header[5] == 0xD5 &&        // TFI - frame from PN532 to system controller
+                       header[6] == command + 1);  // Correct command response
+
+  if (!valid_header) {
+    ESP_LOGV(TAG, "read data invalid header!");
+    return false;
+  }
+
+  // full length of message, including command response
+  uint8_t full_len = header[3];
+  // length of data, excluding command response
+  uint8_t len = full_len - 1;
+  if (full_len == 0)
+    len = 0;
+
+  ESP_LOGV(TAG, "Reading response of length %d", len);
+
+  data.resize(len + 1);
+  this->read_array(data.data(), len + 1);
+  this->disable();
+
+  ESP_LOGV(TAG, "Response data: %s", hexencode(data).c_str());
+
+  uint8_t checksum = header[5] + header[6];  // TFI + Command response code
+  for (int i = 0; i < len - 1; i++) {
+    uint8_t dat = data[i];
+    checksum += dat;
+  }
+  checksum = ~checksum + 1;
+
+  if (data[len - 1] != checksum) {
+    ESP_LOGV(TAG, "read data invalid checksum! %02X != %02X", data[len - 1], checksum);
+    return false;
+  }
+
+  if (data[len] != 0x00) {
+    ESP_LOGV(TAG, "read data invalid postamble!");
+    return false;
+  }
+
+  data.erase(data.end() - 2, data.end());  // Remove checksum and postamble
+
+  return true;
+}
 
 void PN532Spi::dump_config() {
   PN532::dump_config();

esphome/components/pn532_spi/pn532_spi.h

@@ -18,6 +18,7 @@ class PN532Spi : public pn532::PN532,
  protected:
   bool write_data(const std::vector<uint8_t> &data) override;
   bool read_data(std::vector<uint8_t> &data, uint8_t len) override;
+  bool read_response(uint8_t command, std::vector<uint8_t> &data) override;
 };
 
 }  // namespace pn532_spi

esphome/components/rc522/rc522.cpp

@@ -349,7 +349,7 @@ RC522::StatusCode RC522::pcd_communicate_with_picc_(
   // transmitting. Each iteration of the do-while-loop takes 17.86μs.
   // TODO check/modify for other architectures than Arduino Uno 16bit
   uint16_t i;
-  for (i = 4; i > 0; i--) {
+  for (i = 2000; i > 0; i--) {
     uint8_t n = pcd_read_register(
         COM_IRQ_REG);     // ComIrqReg[7..0] bits are: Set1 TxIRq RxIRq IdleIRq HiAlertIRq LoAlertIRq ErrIRq TimerIRq
     if (n & wait_i_rq) {  // One of the interrupts that signal success has been set.

esphome/components/scd30/sensor.py

@@ -23,10 +23,10 @@ def remove_altitude_suffix(value):
 
 CONFIG_SCHEMA = cv.Schema({
     cv.GenerateID(): cv.declare_id(SCD30Component),
-    cv.Required(CONF_CO2): sensor.sensor_schema(UNIT_PARTS_PER_MILLION,
+    cv.Optional(CONF_CO2): sensor.sensor_schema(UNIT_PARTS_PER_MILLION,
                                                 ICON_MOLECULE_CO2, 0),
-    cv.Required(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
-    cv.Required(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1),
+    cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
+    cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1),
     cv.Optional(CONF_AUTOMATIC_SELF_CALIBRATION, default=True): cv.boolean,
     cv.Optional(CONF_ALTITUDE_COMPENSATION): cv.All(remove_altitude_suffix,
                                                     cv.int_range(min=0, max=0xFFFF,

esphome/components/st7735/st7735.cpp

@@ -407,7 +407,7 @@ void HOT ST7735::senddata_(const uint8_t *data_bytes, uint8_t num_data_bytes) {
   this->cs_->digital_write(false);
   this->enable();
   for (uint8_t i = 0; i < num_data_bytes; i++) {
-    this->transfer_byte(pgm_read_byte(data_bytes++));  // write byte - SPI library
+    this->write_byte(pgm_read_byte(data_bytes++));  // write byte - SPI library
   }
   this->cs_->digital_write(true);
   this->disable();

esphome/components/tuya/tuya.cpp

@@ -42,6 +42,8 @@ void Tuya::dump_config() {
       ESP_LOGCONFIG(TAG, "  Datapoint %d: switch (value: %s)", info.id, ONOFF(info.value_bool));
     else if (info.type == TuyaDatapointType::INTEGER)
       ESP_LOGCONFIG(TAG, "  Datapoint %d: int value (value: %d)", info.id, info.value_int);
+    else if (info.type == TuyaDatapointType::STRING)
+      ESP_LOGCONFIG(TAG, "  Datapoint %d: string value (value: %s)", info.id, info.value_string.c_str());
     else if (info.type == TuyaDatapointType::ENUM)
       ESP_LOGCONFIG(TAG, "  Datapoint %d: enum (value: %d)", info.id, info.value_enum);
     else if (info.type == TuyaDatapointType::BITMASK)
@@ -283,6 +285,9 @@ void Tuya::handle_datapoint_(const uint8_t *buffer, size_t len) {
         return;
       datapoint.value_uint = encode_uint32(data[0], data[1], data[2], data[3]);
       break;
+    case TuyaDatapointType::STRING:
+      datapoint.value_string = std::string(reinterpret_cast<const char *>(data), data_len);
+      break;
     case TuyaDatapointType::ENUM:
       if (data_len != 1)
         return;
@@ -339,7 +344,13 @@ void Tuya::set_datapoint_value(TuyaDatapoint datapoint) {
   ESP_LOGV(TAG, "Datapoint %u set to %u", datapoint.id, datapoint.value_uint);
   for (auto &other : this->datapoints_) {
     if (other.id == datapoint.id) {
-      if (other.value_uint == datapoint.value_uint) {
+      // String value is stored outside the union; must be checked separately.
+      if (datapoint.type == TuyaDatapointType::STRING) {
+        if (other.value_string == datapoint.value_string) {
+          ESP_LOGV(TAG, "Not sending unchanged value");
+          return;
+        }
+      } else if (other.value_uint == datapoint.value_uint) {
         ESP_LOGV(TAG, "Not sending unchanged value");
         return;
       }
@@ -359,6 +370,11 @@ void Tuya::set_datapoint_value(TuyaDatapoint datapoint) {
       data.push_back(datapoint.value_uint >> 8);
       data.push_back(datapoint.value_uint >> 0);
       break;
+    case TuyaDatapointType::STRING:
+      for (char const &c : datapoint.value_string) {
+        data.push_back(c);
+      }
+      break;
     case TuyaDatapointType::ENUM:
       data.push_back(datapoint.value_enum);
       break;

esphome/components/tuya/tuya.h

@@ -30,6 +30,7 @@ struct TuyaDatapoint {
     uint8_t value_enum;
     uint16_t value_bitmask;
   };
+  std::string value_string;
 };
 
 struct TuyaDatapointListener {

esphome/components/waveshare_epaper/display.py

@@ -27,6 +27,7 @@ MODELS = {
     '2.13in-ttgo': ('a', WaveshareEPaperTypeAModel.TTGO_EPAPER_2_13_IN),
     '2.13in-ttgo-b73': ('a', WaveshareEPaperTypeAModel.TTGO_EPAPER_2_13_IN_B73),
     '2.90in': ('a', WaveshareEPaperTypeAModel.WAVESHARE_EPAPER_2_9_IN),
+    '2.90inv2': ('a', WaveshareEPaperTypeAModel.WAVESHARE_EPAPER_2_9_IN_V2),
     '2.70in': ('b', WaveshareEPaper2P7In),
     '2.90in-b': ('b', WaveshareEPaper2P9InB),
     '4.20in': ('b', WaveshareEPaper4P2In),
@@ -41,7 +42,7 @@ def validate_full_update_every_only_type_a(value):
         return value
     if MODELS[value[CONF_MODEL]][0] != 'a':
         raise cv.Invalid("The 'full_update_every' option is only available for models "
-                         "'1.54in', '2.13in' and '2.90in'.")
+                         "'1.54in', '2.13in', '2.90in', and '2.90inV2'.")
     return value
 
 

esphome/components/waveshare_epaper/waveshare_epaper.cpp

@@ -178,6 +178,13 @@ void WaveshareEPaperTypeA::initialize() {
   // COMMAND DATA ENTRY MODE SETTING
   this->command(0x11);
   this->data(0x03);  // from top left to bottom right
+
+  if (this->model_ == WAVESHARE_EPAPER_2_9_IN_V2) {
+    // RAM content option for Display Update
+    this->command(0x21);
+    this->data(0x00);
+    this->data(0x80);
+  }
 }
 void WaveshareEPaperTypeA::dump_config() {
   LOG_DISPLAY("", "Waveshare E-Paper", this);
@@ -197,6 +204,9 @@ void WaveshareEPaperTypeA::dump_config() {
     case WAVESHARE_EPAPER_2_9_IN:
       ESP_LOGCONFIG(TAG, "  Model: 2.9in");
       break;
+    case WAVESHARE_EPAPER_2_9_IN_V2:
+      ESP_LOGCONFIG(TAG, "  Model: 2.9inV2");
+      break;
   }
   ESP_LOGCONFIG(TAG, "  Full Update Every: %u", this->full_update_every_);
   LOG_PIN("  Reset Pin: ", this->reset_pin_);
@@ -205,14 +215,15 @@ void WaveshareEPaperTypeA::dump_config() {
   LOG_UPDATE_INTERVAL(this);
 }
 void HOT WaveshareEPaperTypeA::display() {
+  bool full_update = this->at_update_ == 0;
+  bool prev_full_update = this->at_update_ == 1;
+
   if (!this->wait_until_idle_()) {
     this->status_set_warning();
     return;
   }
 
   if (this->full_update_every_ >= 2) {
-    bool prev_full_update = this->at_update_ == 1;
-    bool full_update = this->at_update_ == 0;
     if (full_update != prev_full_update) {
       if (this->model_ == TTGO_EPAPER_2_13_IN) {
         this->write_lut_(full_update ? FULL_UPDATE_LUT_TTGO : PARTIAL_UPDATE_LUT_TTGO, LUT_SIZE_TTGO);
@@ -258,7 +269,12 @@ void HOT WaveshareEPaperTypeA::display() {
 
   // COMMAND DISPLAY UPDATE CONTROL 2
   this->command(0x22);
-  this->data(0xC4);
+  if (this->model_ == WAVESHARE_EPAPER_2_9_IN_V2) {
+    this->data(full_update ? 0xF7 : 0xFF);
+  } else {
+    this->data(0xC4);
+  }
+
   // COMMAND MASTER ACTIVATION
   this->command(0x20);
   // COMMAND TERMINATE FRAME READ WRITE
@@ -278,6 +294,8 @@ int WaveshareEPaperTypeA::get_width_internal() {
       return 128;
     case WAVESHARE_EPAPER_2_9_IN:
       return 128;
+    case WAVESHARE_EPAPER_2_9_IN_V2:
+      return 128;
   }
   return 0;
 }
@@ -293,6 +311,8 @@ int WaveshareEPaperTypeA::get_height_internal() {
       return 250;
     case WAVESHARE_EPAPER_2_9_IN:
       return 296;
+    case WAVESHARE_EPAPER_2_9_IN_V2:
+      return 296;
   }
   return 0;
 }

esphome/components/waveshare_epaper/waveshare_epaper.h

@@ -67,6 +67,7 @@ enum WaveshareEPaperTypeAModel {
   WAVESHARE_EPAPER_1_54_IN = 0,
   WAVESHARE_EPAPER_2_13_IN,
   WAVESHARE_EPAPER_2_9_IN,
+  WAVESHARE_EPAPER_2_9_IN_V2,
   TTGO_EPAPER_2_13_IN,
   TTGO_EPAPER_2_13_IN_B73,
 };
@@ -82,8 +83,14 @@ class WaveshareEPaperTypeA : public WaveshareEPaper {
   void display() override;
 
   void deep_sleep() override {
-    // COMMAND DEEP SLEEP MODE
-    this->command(0x10);
+    if (this->model_ == WAVESHARE_EPAPER_2_9_IN_V2) {
+      // COMMAND DEEP SLEEP MODE
+      this->command(0x10);
+      this->data(0x01);
+    } else {
+      // COMMAND DEEP SLEEP MODE
+      this->command(0x10);
+    }
     this->wait_until_idle_();
   }
 

esphome/components/xiaomi_ble/xiaomi_ble.cpp

@@ -194,6 +194,9 @@ optional<XiaomiParseResult> parse_xiaomi_header(const esp32_ble_tracker::Service
     result.name = "MJYD02YLA";
     if (raw.size() == 19)
       result.raw_offset -= 6;
+  } else if ((raw[2] == 0x87) && (raw[3] == 0x03)) {  // square body, e-ink display
+    result.type = XiaomiParseResult::TYPE_MHOC401;
+    result.name = "MHOC401";
   } else {
     ESP_LOGVV(TAG, "parse_xiaomi_header(): unknown device, no magic bytes.");
     return {};

esphome/components/xiaomi_ble/xiaomi_ble.h

@@ -21,7 +21,8 @@ struct XiaomiParseResult {
     TYPE_JQJCY01YM,
     TYPE_MUE4094RT,
     TYPE_WX08ZM,
-    TYPE_MJYD02YLA
+    TYPE_MJYD02YLA,
+    TYPE_MHOC401
   } type;
   std::string name;
   optional<float> temperature;

esphome/components/xiaomi_mhoc401/sensor.py

@@ -0,0 +1,43 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, esp32_ble_tracker
+from esphome.const import CONF_BATTERY_LEVEL, CONF_HUMIDITY, CONF_MAC_ADDRESS, CONF_TEMPERATURE, \
+    UNIT_CELSIUS, ICON_THERMOMETER, UNIT_PERCENT, ICON_WATER_PERCENT, ICON_BATTERY, CONF_ID, \
+    CONF_BINDKEY
+
+CODEOWNERS = ['@vevsvevs']
+DEPENDENCIES = ['esp32_ble_tracker']
+AUTO_LOAD = ['xiaomi_ble']
+
+xiaomi_mhoc401_ns = cg.esphome_ns.namespace('xiaomi_mhoc401')
+XiaomiMHOC401 = xiaomi_mhoc401_ns.class_('XiaomiMHOC401',
+                                         esp32_ble_tracker.ESPBTDeviceListener,
+                                         cg.Component)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_id(XiaomiMHOC401),
+    cv.Required(CONF_BINDKEY): cv.bind_key,
+    cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
+    cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
+    cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 0),
+    cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(UNIT_PERCENT, ICON_BATTERY, 0),
+}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA)
+
+
+def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    yield cg.register_component(var, config)
+    yield esp32_ble_tracker.register_ble_device(var, config)
+
+    cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
+    cg.add(var.set_bindkey(config[CONF_BINDKEY]))
+
+    if CONF_TEMPERATURE in config:
+        sens = yield sensor.new_sensor(config[CONF_TEMPERATURE])
+        cg.add(var.set_temperature(sens))
+    if CONF_HUMIDITY in config:
+        sens = yield sensor.new_sensor(config[CONF_HUMIDITY])
+        cg.add(var.set_humidity(sens))
+    if CONF_BATTERY_LEVEL in config:
+        sens = yield sensor.new_sensor(config[CONF_BATTERY_LEVEL])
+        cg.add(var.set_battery_level(sens))

esphome/components/xiaomi_mhoc401/xiaomi_mhoc401.cpp

@@ -0,0 +1,81 @@
+#include "xiaomi_mhoc401.h"
+#include "esphome/core/log.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace xiaomi_mhoc401 {
+
+static const char *TAG = "xiaomi_mhoc401";
+
+void XiaomiMHOC401::dump_config() {
+  ESP_LOGCONFIG(TAG, "Xiaomi MHOC401");
+  ESP_LOGCONFIG(TAG, "  Bindkey: %s", hexencode(this->bindkey_, 16).c_str());
+  LOG_SENSOR("  ", "Temperature", this->temperature_);
+  LOG_SENSOR("  ", "Humidity", this->humidity_);
+  LOG_SENSOR("  ", "Battery Level", this->battery_level_);
+}
+
+bool XiaomiMHOC401::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
+  if (device.address_uint64() != this->address_) {
+    ESP_LOGVV(TAG, "parse_device(): unknown MAC address.");
+    return false;
+  }
+  ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", device.address_str().c_str());
+
+  bool success = false;
+  for (auto &service_data : device.get_service_datas()) {
+    auto res = xiaomi_ble::parse_xiaomi_header(service_data);
+    if (!res.has_value()) {
+      continue;
+    }
+    if (res->is_duplicate) {
+      continue;
+    }
+    if (res->has_encryption &&
+        (!(xiaomi_ble::decrypt_xiaomi_payload(const_cast<std::vector<uint8_t> &>(service_data.data), this->bindkey_,
+                                              this->address_)))) {
+      continue;
+    }
+    if (!(xiaomi_ble::parse_xiaomi_message(service_data.data, *res))) {
+      continue;
+    }
+    if (res->humidity.has_value() && this->humidity_ != nullptr) {
+      // see https://github.com/custom-components/sensor.mitemp_bt/issues/7#issuecomment-595948254
+      *res->humidity = trunc(*res->humidity);
+    }
+    if (!(xiaomi_ble::report_xiaomi_results(res, device.address_str()))) {
+      continue;
+    }
+    if (res->temperature.has_value() && this->temperature_ != nullptr)
+      this->temperature_->publish_state(*res->temperature);
+    if (res->humidity.has_value() && this->humidity_ != nullptr)
+      this->humidity_->publish_state(*res->humidity);
+    if (res->battery_level.has_value() && this->battery_level_ != nullptr)
+      this->battery_level_->publish_state(*res->battery_level);
+    success = true;
+  }
+
+  if (!success) {
+    return false;
+  }
+
+  return true;
+}
+
+void XiaomiMHOC401::set_bindkey(const std::string &bindkey) {
+  memset(bindkey_, 0, 16);
+  if (bindkey.size() != 32) {
+    return;
+  }
+  char temp[3] = {0};
+  for (int i = 0; i < 16; i++) {
+    strncpy(temp, &(bindkey.c_str()[i * 2]), 2);
+    bindkey_[i] = std::strtoul(temp, NULL, 16);
+  }
+}
+
+}  // namespace xiaomi_mhoc401
+}  // namespace esphome
+
+#endif

esphome/components/xiaomi_mhoc401/xiaomi_mhoc401.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+#include "esphome/components/xiaomi_ble/xiaomi_ble.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace xiaomi_mhoc401 {
+
+class XiaomiMHOC401 : public Component, public esp32_ble_tracker::ESPBTDeviceListener {
+ public:
+  void set_address(uint64_t address) { address_ = address; };
+  void set_bindkey(const std::string &bindkey);
+
+  bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void set_temperature(sensor::Sensor *temperature) { temperature_ = temperature; }
+  void set_humidity(sensor::Sensor *humidity) { humidity_ = humidity; }
+  void set_battery_level(sensor::Sensor *battery_level) { battery_level_ = battery_level; }
+
+ protected:
+  uint64_t address_;
+  uint8_t bindkey_[16];
+  sensor::Sensor *temperature_{nullptr};
+  sensor::Sensor *humidity_{nullptr};
+  sensor::Sensor *battery_level_{nullptr};
+};
+
+}  // namespace xiaomi_mhoc401
+}  // namespace esphome
+
+#endif

esphome/const.py

@@ -2,7 +2,7 @@
 
 MAJOR_VERSION = 1
 MINOR_VERSION = 16
-PATCH_VERSION = '0b5'
+PATCH_VERSION = '2'
 __short_version__ = f'{MAJOR_VERSION}.{MINOR_VERSION}'
 __version__ = f'{__short_version__}.{PATCH_VERSION}'
 
@@ -357,6 +357,7 @@ CONF_ON_VALUE = 'on_value'
 CONF_ON_VALUE_RANGE = 'on_value_range'
 CONF_ONE = 'one'
 CONF_OPEN_ACTION = 'open_action'
+CONF_OPEN_DRAIN_INTERRUPT = 'open_drain_interrupt'
 CONF_OPEN_DURATION = 'open_duration'
 CONF_OPEN_ENDSTOP = 'open_endstop'
 CONF_OPTIMISTIC = 'optimistic'

esphome/core/helpers.cpp

@@ -171,15 +171,17 @@ uint8_t crc8(uint8_t *data, uint8_t len) {
   }
   return crc;
 }
+
 void delay_microseconds_accurate(uint32_t usec) {
   if (usec == 0)
     return;
-
-  if (usec <= 16383UL) {
+  if (usec < 5000UL) {
     delayMicroseconds(usec);
-  } else {
-    delay(usec / 1000UL);
-    delayMicroseconds(usec % 1000UL);
+    return;
+  }
+  uint32_t start = micros();
+  while (micros() - start < usec) {
+    delay(0);
   }
 }
 

tests/test1.yaml

@@ -434,6 +434,9 @@ sensor:
     power:
       name: 'HLW8012 Power'
       id: hlw8012_power
+    energy:
+      name: "HLW8012 Energy"
+      id: hlw8012_energy
     update_interval: 15s
     current_resistor: 0.001 ohm
     voltage_divider: 2351
@@ -1782,6 +1785,15 @@ display:
     full_update_every: 30
     lambda: |-
       it.rectangle(0, 0, it.get_width(), it.get_height());
+  - platform: waveshare_epaper
+    cs_pin: GPIO23
+    dc_pin: GPIO23
+    busy_pin: GPIO23
+    reset_pin: GPIO23
+    model: 2.90inv2
+    full_update_every: 30
+    lambda: |-
+      it.rectangle(0, 0, it.get_width(), it.get_height());
   - platform: st7789v
     cs_pin: GPIO5
     dc_pin: GPIO16
@@ -1892,10 +1904,12 @@ pcf8574:
 
 mcp23017:
   - id: 'mcp23017_hub'
+    open_drain_interrupt: 'true'
 
 mcp23008:
   - id: 'mcp23008_hub'
     address: 0x22
+    open_drain_interrupt: 'true'
 
 mcp23016:
   - id: 'mcp23016_hub'