esphome 2024.12.4__py3-none-any.whl → 2025.2.0__py3-none-any.whl

esphome/components/es7243e/es7243e.cpp

@@ -0,0 +1,125 @@
+#include "es7243e.h"
+#include "es7243e_const.h"
+
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+#include <cinttypes>
+
+namespace esphome {
+namespace es7243e {
+
+static const char *const TAG = "es7243e";
+
+// Mark the component as failed; use only in setup
+#define ES7243E_ERROR_FAILED(func) \
+  if (!(func)) { \
+    this->mark_failed(); \
+    return; \
+  }
+
+// Return false; use outside of setup
+#define ES7243E_ERROR_CHECK(func) \
+  if (!(func)) { \
+    return false; \
+  }
+
+void ES7243E::dump_config() {
+  ESP_LOGCONFIG(TAG, "ES7243E audio ADC:");
+
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "  Failed to initialize");
+    return;
+  }
+}
+
+void ES7243E::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up ES7243E...");
+
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG01, 0x3A));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_RESET_REG00, 0x80));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_TEST_MODE_REGF9, 0x00));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG04, 0x02));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG04, 0x01));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_TEST_MODE_REGF9, 0x01));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_RESET_REG00, 0x1E));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG01, 0x00));
+
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG02, 0x00));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG03, 0x20));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG04, 0x01));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ADC_CTRL_REG0D, 0x00));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG05, 0x00));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG06, 0x03));  // SCLK=MCLK/4
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG07, 0x00));  // LRCK=MCLK/256
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG08, 0xFF));  // LRCK=MCLK/256
+
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG09, 0xCA));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_SDP_REG0A, 0x85));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_SDP_REG0B, 0x00));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ADC_CTRL_REG0E, 0xBF));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ADC_CTRL_REG0F, 0x80));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ADC_CTRL_REG14, 0x0C));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ADC_CTRL_REG15, 0x0C));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG17, 0x02));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG18, 0x26));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG19, 0x77));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG1A, 0xF4));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG1B, 0x66));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG1C, 0x44));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG1E, 0x00));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG1F, 0x0C));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG20, 0x1A));  // PGA gain +30dB
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG21, 0x1A));
+
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_RESET_REG00, 0x80));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG01, 0x3A));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG16, 0x3F));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG16, 0x00));
+
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_TEST_MODE_REGF9, 0x00));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG04, 0x01));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG17, 0x01));
+  ES7243E_ERROR_FAILED(this->configure_mic_gain_());
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_RESET_REG00, 0x80));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG01, 0x3A));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG16, 0x3F));
+  ES7243E_ERROR_FAILED(this->write_byte(ES7243E_ANALOG_REG16, 0x00));
+
+  this->setup_complete_ = true;
+}
+
+bool ES7243E::set_mic_gain(float mic_gain) {
+  this->mic_gain_ = clamp<float>(mic_gain, 0, 37.5);
+  if (this->setup_complete_) {
+    return this->configure_mic_gain_();
+  }
+  return true;
+}
+
+bool ES7243E::configure_mic_gain_() {
+  auto regv = this->es7243e_gain_reg_value_(this->mic_gain_);
+
+  ES7243E_ERROR_CHECK(this->write_byte(ES7243E_ANALOG_REG20, 0x10 | regv));
+  ES7243E_ERROR_CHECK(this->write_byte(ES7243E_ANALOG_REG21, 0x10 | regv));
+
+  return true;
+}
+
+uint8_t ES7243E::es7243e_gain_reg_value_(float mic_gain) {
+  // reg: 12 - 34.5dB, 13 - 36dB, 14 - 37.5dB
+  mic_gain += 0.5;
+  if (mic_gain <= 33.0) {
+    return (uint8_t) mic_gain / 3;
+  }
+  if (mic_gain < 36.0) {
+    return 12;
+  }
+  if (mic_gain < 37.0) {
+    return 13;
+  }
+  return 14;
+}
+
+}  // namespace es7243e
+}  // namespace esphome

esphome/components/es7243e/es7243e.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "esphome/components/audio_adc/audio_adc.h"
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace es7243e {
+
+class ES7243E : public audio_adc::AudioAdc, public Component, public i2c::I2CDevice {
+  /* Class for configuring an ES7243E ADC for microphone input.
+   * Based on code from:
+   * - https://github.com/espressif/esp-adf/ (accessed 20250116)
+   */
+ public:
+  void setup() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void dump_config() override;
+
+  bool set_mic_gain(float mic_gain) override;
+
+  float mic_gain() override { return this->mic_gain_; };
+
+ protected:
+  /// @brief Convert floating point mic gain value to register value
+  /// @param mic_gain Gain value to convert
+  /// @return Corresponding register value for specified gain
+  uint8_t es7243e_gain_reg_value_(float mic_gain);
+
+  bool configure_mic_gain_();
+
+  bool setup_complete_{false};
+  float mic_gain_{0};
+};
+
+}  // namespace es7243e
+}  // namespace esphome

esphome/components/es7243e/es7243e_const.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <cinttypes>
+
+namespace esphome {
+namespace es7243e {
+
+// ES7243E register addresses
+static const uint8_t ES7243E_RESET_REG00 = 0x00;      // Reset control
+static const uint8_t ES7243E_CLOCK_MGR_REG01 = 0x01;  // MCLK/BCLK/ADCCLK/Analog clocks on/off
+static const uint8_t ES7243E_CLOCK_MGR_REG02 = 0x02;  // MCLK & BCLK configuration, source selection
+
+static const uint8_t ES7243E_CLOCK_MGR_REG03 = 0x03;  // ADC Over-sample rate control
+static const uint8_t ES7243E_CLOCK_MGR_REG04 = 0x04;  // Pre-divide/Pre-multiplication
+static const uint8_t ES7243E_CLOCK_MGR_REG05 = 0x05;  // CF/DSP clock divider
+static const uint8_t ES7243E_CLOCK_MGR_REG06 = 0x06;  // BCLK divider at master mode
+static const uint8_t ES7243E_CLOCK_MGR_REG07 = 0x07;  // BCLK/LRCK/SDOUT tri-state control/LRCK divider bit 11->8
+static const uint8_t ES7243E_CLOCK_MGR_REG08 = 0x08;  // Master LRCK divider bit 7 to bit 0
+static const uint8_t ES7243E_CLOCK_MGR_REG09 = 0x09;  // SEL S1/Timer for S1
+static const uint8_t ES7243E_SDP_REG0A = 0x0A;        // SEL S3/Timer for S3
+static const uint8_t ES7243E_SDP_REG0B = 0x0B;        // SDP out mute control/I2S/left-justify case/word length/format
+static const uint8_t ES7243E_SDP_REG0C = 0x0C;        // NFS flag at slot0/LSB/TDM mode selection
+static const uint8_t ES7243E_ADC_CTRL_REG0D = 0x0D;   // data mux/pol. inv./ram clear on lrck/mclk active/gain scale up
+static const uint8_t ES7243E_ADC_CTRL_REG0E = 0x0E;   // volume control
+static const uint8_t ES7243E_ADC_CTRL_REG0F = 0x0F;   // offset freeze/auto level control/automute control/VC ramp rate
+static const uint8_t ES7243E_ADC_CTRL_REG10 = 0x10;   // automute noise gate/detection
+static const uint8_t ES7243E_ADC_CTRL_REG11 = 0x11;   // automute SDP control/out gain select
+static const uint8_t ES7243E_ADC_CTRL_REG12 = 0x12;   // controls for automute PDN_PGA/MOD/reset/digital circuit
+static const uint8_t ES7243E_ADC_CTRL_REG13 = 0x13;   // ALC rate selection/ALC target level
+static const uint8_t ES7243E_ADC_CTRL_REG14 = 0x14;   // ADCHPF stage1 coeff
+static const uint8_t ES7243E_ADC_CTRL_REG15 = 0x15;   // ADCHPF stage2 coeff
+static const uint8_t ES7243E_ANALOG_REG16 = 0x16;     // power-down/reset
+static const uint8_t ES7243E_ANALOG_REG17 = 0x17;     // VMIDSEL
+static const uint8_t ES7243E_ANALOG_REG18 = 0x18;     // ADC/ADCFL bias
+static const uint8_t ES7243E_ANALOG_REG19 = 0x19;     // PGA1/PGA2 bias
+static const uint8_t ES7243E_ANALOG_REG1A = 0x1A;     // ADCI1/ADCI23 bias
+static const uint8_t ES7243E_ANALOG_REG1B = 0x1B;     // ADCSM/ADCCM bias
+static const uint8_t ES7243E_ANALOG_REG1C = 0x1C;     // ADCVRP/ADCCPP bias
+static const uint8_t ES7243E_ANALOG_REG1D = 0x1D;     // low power bits
+static const uint8_t ES7243E_ANALOG_REG1E = 0x1E;     // low power bits
+static const uint8_t ES7243E_ANALOG_REG1F = 0x1F;     // ADC_DMIC_ON/REFSEL/VX2OFF/VX1SEL/VMIDLVL
+static const uint8_t ES7243E_ANALOG_REG20 = 0x20;     // select MIC1 as PGA1 input/PGA1 gain
+static const uint8_t ES7243E_ANALOG_REG21 = 0x21;     // select MIC2 as PGA1 input/PGA2 gain
+static const uint8_t ES7243E_TEST_MODE_REGF7 = 0xF7;
+static const uint8_t ES7243E_TEST_MODE_REGF8 = 0xF8;
+static const uint8_t ES7243E_TEST_MODE_REGF9 = 0xF9;
+static const uint8_t ES7243E_I2C_CONF_REGFA = 0xFA;      // I2C signals retime/reset registers to default
+static const uint8_t ES7243E_FLAG_REGFC = 0xFC;          // CSM flag/ADC automute flag (RO)
+static const uint8_t ES7243E_CHIP_ID1_REGFD = 0xFD;      // chip ID 1, reads 0x7A (RO)
+static const uint8_t ES7243E_CHIP_ID2_REGFE = 0xFE;      // chip ID 2, reads 0x43 (RO)
+static const uint8_t ES7243E_CHIP_VERSION_REGFF = 0xFF;  // chip version, reads 0x00 (RO)
+
+}  // namespace es7243e
+}  // namespace esphome

esphome/components/es8156/audio_dac.py

@@ -0,0 +1,27 @@
+import esphome.codegen as cg
+from esphome.components import i2c
+from esphome.components.audio_dac import AudioDac
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+
+CODEOWNERS = ["@kbx81"]
+DEPENDENCIES = ["i2c"]
+
+es8156_ns = cg.esphome_ns.namespace("es8156")
+ES8156 = es8156_ns.class_("ES8156", AudioDac, cg.Component, i2c.I2CDevice)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ES8156),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(i2c.i2c_device_schema(0x08))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)

esphome/components/es8156/es8156.cpp

@@ -0,0 +1,87 @@
+#include "es8156.h"
+#include "es8156_const.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+#include <cinttypes>
+
+namespace esphome {
+namespace es8156 {
+
+static const char *const TAG = "es8156";
+
+// Mark the component as failed; use only in setup
+#define ES8156_ERROR_FAILED(func) \
+  if (!(func)) { \
+    this->mark_failed(); \
+    return; \
+  }
+
+void ES8156::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up ES8156...");
+
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG02_SCLK_MODE, 0x04));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG20_ANALOG_SYS1, 0x2A));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG21_ANALOG_SYS2, 0x3C));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG22_ANALOG_SYS3, 0x00));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG24_ANALOG_LP, 0x07));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG23_ANALOG_SYS4, 0x00));
+
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG0A_TIME_CONTROL1, 0x01));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG0B_TIME_CONTROL2, 0x01));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG11_DAC_SDP, 0x00));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG19_EQ_CONTROL1, 0x20));
+
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG0D_P2S_CONTROL, 0x14));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG09_MISC_CONTROL2, 0x00));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG18_MISC_CONTROL3, 0x00));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG08_CLOCK_ON_OFF, 0x3F));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG00_RESET, 0x02));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG00_RESET, 0x03));
+  ES8156_ERROR_FAILED(this->write_byte(ES8156_REG25_ANALOG_SYS5, 0x20));
+}
+
+void ES8156::dump_config() {
+  ESP_LOGCONFIG(TAG, "ES8156 Audio Codec:");
+
+  if (this->is_failed()) {
+    ESP_LOGCONFIG(TAG, "  Failed to initialize");
+    return;
+  }
+}
+
+bool ES8156::set_volume(float volume) {
+  volume = clamp(volume, 0.0f, 1.0f);
+  uint8_t reg = remap<uint8_t, float>(volume, 0.0f, 1.0f, 0, 255);
+  ESP_LOGV(TAG, "Setting ES8156_REG14_VOLUME_CONTROL to %u (volume: %f)", reg, volume);
+  return this->write_byte(ES8156_REG14_VOLUME_CONTROL, reg);
+}
+
+float ES8156::volume() {
+  uint8_t reg;
+  this->read_byte(ES8156_REG14_VOLUME_CONTROL, &reg);
+  return remap<float, uint8_t>(reg, 0, 255, 0.0f, 1.0f);
+}
+
+bool ES8156::set_mute_state_(bool mute_state) {
+  uint8_t reg13;
+
+  this->is_muted_ = mute_state;
+
+  if (!this->read_byte(ES8156_REG13_DAC_MUTE, &reg13)) {
+    return false;
+  }
+
+  ESP_LOGV(TAG, "Read ES8156_REG13_DAC_MUTE: %u", reg13);
+
+  if (mute_state) {
+    reg13 |= BIT(1) | BIT(2);
+  } else {
+    reg13 &= ~(BIT(1) | BIT(2));
+  }
+
+  ESP_LOGV(TAG, "Setting ES8156_REG13_DAC_MUTE to %u (muted: %s)", reg13, YESNO(mute_state));
+  return this->write_byte(ES8156_REG13_DAC_MUTE, reg13);
+}
+
+}  // namespace es8156
+}  // namespace esphome

esphome/components/es8156/es8156.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "esphome/components/audio_dac/audio_dac.h"
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace es8156 {
+
+class ES8156 : public audio_dac::AudioDac, public Component, public i2c::I2CDevice {
+ public:
+  /////////////////////////
+  // Component overrides //
+  /////////////////////////
+
+  void setup() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void dump_config() override;
+
+  ////////////////////////
+  // AudioDac overrides //
+  ////////////////////////
+
+  /// @brief Writes the volume out to the DAC
+  /// @param volume floating point between 0.0 and 1.0
+  /// @return True if successful and false otherwise
+  bool set_volume(float volume) override;
+
+  /// @brief Gets the current volume out from the DAC
+  /// @return floating point between 0.0 and 1.0
+  float volume() override;
+
+  /// @brief Disables mute for audio out
+  /// @return True if successful and false otherwise
+  bool set_mute_off() override { return this->set_mute_state_(false); }
+
+  /// @brief Enables mute for audio out
+  /// @return True if successful and false otherwise
+  bool set_mute_on() override { return this->set_mute_state_(true); }
+
+  bool is_muted() override { return this->is_muted_; }
+
+ protected:
+  /// @brief Mutes or unmutes the DAC audio out
+  /// @param mute_state True to mute, false to unmute
+  /// @return True if successful and false otherwise
+  bool set_mute_state_(bool mute_state);
+};
+
+}  // namespace es8156
+}  // namespace esphome

esphome/components/es8156/es8156_const.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "es8156.h"
+
+namespace esphome {
+namespace es8156 {
+
+/* ES8156 register addresses */
+/*
+ * RESET Control
+ */
+static const uint8_t ES8156_REG00_RESET = 0x00;
+/*
+ * Clock Managerment
+ */
+static const uint8_t ES8156_REG01_MAINCLOCK_CTL = 0x01;
+static const uint8_t ES8156_REG02_SCLK_MODE = 0x02;
+static const uint8_t ES8156_REG03_LRCLK_DIV_H = 0x03;
+static const uint8_t ES8156_REG04_LRCLK_DIV_L = 0x04;
+static const uint8_t ES8156_REG05_SCLK_DIV = 0x05;
+static const uint8_t ES8156_REG06_NFS_CONFIG = 0x06;
+static const uint8_t ES8156_REG07_MISC_CONTROL1 = 0x07;
+static const uint8_t ES8156_REG08_CLOCK_ON_OFF = 0x08;
+static const uint8_t ES8156_REG09_MISC_CONTROL2 = 0x09;
+static const uint8_t ES8156_REG0A_TIME_CONTROL1 = 0x0a;
+static const uint8_t ES8156_REG0B_TIME_CONTROL2 = 0x0b;
+/*
+ * System Control
+ */
+static const uint8_t ES8156_REG0C_CHIP_STATUS = 0x0c;
+static const uint8_t ES8156_REG0D_P2S_CONTROL = 0x0d;
+static const uint8_t ES8156_REG10_DAC_OSR_COUNTER = 0x10;
+/*
+ * SDP Control
+ */
+static const uint8_t ES8156_REG11_DAC_SDP = 0x11;
+static const uint8_t ES8156_REG12_AUTOMUTE_SET = 0x12;
+static const uint8_t ES8156_REG13_DAC_MUTE = 0x13;
+static const uint8_t ES8156_REG14_VOLUME_CONTROL = 0x14;
+
+/*
+ * ALC Control
+ */
+static const uint8_t ES8156_REG15_ALC_CONFIG1 = 0x15;
+static const uint8_t ES8156_REG16_ALC_CONFIG2 = 0x16;
+static const uint8_t ES8156_REG17_ALC_CONFIG3 = 0x17;
+static const uint8_t ES8156_REG18_MISC_CONTROL3 = 0x18;
+static const uint8_t ES8156_REG19_EQ_CONTROL1 = 0x19;
+static const uint8_t ES8156_REG1A_EQ_CONTROL2 = 0x1a;
+/*
+ * Analog System Control
+ */
+static const uint8_t ES8156_REG20_ANALOG_SYS1 = 0x20;
+static const uint8_t ES8156_REG21_ANALOG_SYS2 = 0x21;
+static const uint8_t ES8156_REG22_ANALOG_SYS3 = 0x22;
+static const uint8_t ES8156_REG23_ANALOG_SYS4 = 0x23;
+static const uint8_t ES8156_REG24_ANALOG_LP = 0x24;
+static const uint8_t ES8156_REG25_ANALOG_SYS5 = 0x25;
+/*
+ * Chip Information
+ */
+static const uint8_t ES8156_REGFC_I2C_PAGESEL = 0xFC;
+static const uint8_t ES8156_REGFD_CHIPID1 = 0xFD;
+static const uint8_t ES8156_REGFE_CHIPID0 = 0xFE;
+static const uint8_t ES8156_REGFF_CHIP_VERSION = 0xFF;
+
+}  // namespace es8156
+}  // namespace esphome

esphome/components/es8311/audio_dac.py

@@ -2,7 +2,7 @@ import esphome.codegen as cg
 from esphome.components import i2c
 from esphome.components.audio_dac import AudioDac
 import esphome.config_validation as cv
-from esphome.const import CONF_BITS_PER_SAMPLE, CONF_ID, CONF_SAMPLE_RATE
+from esphome.const import CONF_BITS_PER_SAMPLE, CONF_ID, CONF_MIC_GAIN, CONF_SAMPLE_RATE
 
 CODEOWNERS = ["@kroimon", "@kahrendt"]
 DEPENDENCIES = ["i2c"]
@@ -10,7 +10,6 @@ DEPENDENCIES = ["i2c"]
 es8311_ns = cg.esphome_ns.namespace("es8311")
 ES8311 = es8311_ns.class_("ES8311", AudioDac, cg.Component, i2c.I2CDevice)
 
-CONF_MIC_GAIN = "mic_gain"
 CONF_USE_MCLK = "use_mclk"
 CONF_USE_MICROPHONE = "use_microphone"
 

esphome/components/esp32/__init__.py

@@ -64,6 +64,7 @@ from .gpio import esp32_pin_to_code  # noqa
 _LOGGER = logging.getLogger(__name__)
 CODEOWNERS = ["@esphome/core"]
 AUTO_LOAD = ["preferences"]
+IS_TARGET_PLATFORM = True
 
 CONF_RELEASE = "release"
 

esphome/components/esp32/core.cpp

@@ -58,7 +58,11 @@ uint32_t arch_get_cpu_cycle_count() { return esp_cpu_get_cycle_count(); }
 #else
 uint32_t arch_get_cpu_cycle_count() { return cpu_hal_get_cycle_count(); }
 #endif
-uint32_t arch_get_cpu_freq_hz() { return rtc_clk_apb_freq_get(); }
+uint32_t arch_get_cpu_freq_hz() {
+  rtc_cpu_freq_config_t config;
+  rtc_clk_cpu_freq_get_config(&config);
+  return config.freq_mhz * 1000000U;
+}
 
 #ifdef USE_ESP_IDF
 TaskHandle_t loop_task_handle = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

esphome/components/esp32/gpio.h

@@ -13,6 +13,7 @@ class ESP32InternalGPIOPin : public InternalGPIOPin {
   void set_inverted(bool inverted) { inverted_ = inverted; }
   void set_drive_strength(gpio_drive_cap_t drive_strength) { drive_strength_ = drive_strength; }
   void set_flags(gpio::Flags flags) { flags_ = flags; }
+
   void setup() override;
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
@@ -21,6 +22,7 @@ class ESP32InternalGPIOPin : public InternalGPIOPin {
   void detach_interrupt() const override;
   ISRInternalGPIOPin to_isr() const override;
   uint8_t get_pin() const override { return (uint8_t) pin_; }
+  gpio::Flags get_flags() const override { return flags_; }
   bool is_inverted() const override { return inverted_; }
 
  protected:

esphome/components/esp32_ble/__init__.py

@@ -1,3 +1,5 @@
+import re
+
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_sdkconfig_option, const, get_esp32_variant
@@ -64,6 +66,43 @@ CONFIG_SCHEMA = cv.Schema(
 ).extend(cv.COMPONENT_SCHEMA)
 
 
+bt_uuid16_format = "XXXX"
+bt_uuid32_format = "XXXXXXXX"
+bt_uuid128_format = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"
+
+
+def bt_uuid(value):
+    in_value = cv.string_strict(value)
+    value = in_value.upper()
+
+    if len(value) == len(bt_uuid16_format):
+        pattern = re.compile("^[A-F|0-9]{4,}$")
+        if not pattern.match(value):
+            raise cv.Invalid(
+                f"Invalid hexadecimal value for 16 bit UUID format: '{in_value}'"
+            )
+        return value
+    if len(value) == len(bt_uuid32_format):
+        pattern = re.compile("^[A-F|0-9]{8,}$")
+        if not pattern.match(value):
+            raise cv.Invalid(
+                f"Invalid hexadecimal value for 32 bit UUID format: '{in_value}'"
+            )
+        return value
+    if len(value) == len(bt_uuid128_format):
+        pattern = re.compile(
+            "^[A-F|0-9]{8,}-[A-F|0-9]{4,}-[A-F|0-9]{4,}-[A-F|0-9]{4,}-[A-F|0-9]{12,}$"
+        )
+        if not pattern.match(value):
+            raise cv.Invalid(
+                f"Invalid hexadecimal value for 128 UUID format: '{in_value}'"
+            )
+        return value
+    raise cv.Invalid(
+        f"Bluetooth UUID must be in 16 bit '{bt_uuid16_format}', 32 bit '{bt_uuid32_format}', or 128 bit '{bt_uuid128_format}' format"
+    )
+
+
 def validate_variant(_):
     variant = get_esp32_variant()
     if variant in NO_BLUETOOTH_VARIANTS:

esphome/components/esp32_ble/queue.h

@@ -26,10 +26,10 @@ template<class T> class Queue {
   void push(T *element) {
     if (element == nullptr)
       return;
-    if (xSemaphoreTake(m_, 5L / portTICK_PERIOD_MS)) {
-      q_.push(element);
-      xSemaphoreGive(m_);
-    }
+    // It is not called from main loop. Thus it won't block main thread.
+    xSemaphoreTake(m_, portMAX_DELAY);
+    q_.push(element);
+    xSemaphoreGive(m_);
   }
 
   T *pop() {

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -44,6 +44,50 @@ void BLEClientBase::loop() {
 
 float BLEClientBase::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }
 
+void BLEClientBase::dump_config() {
+  ESP_LOGCONFIG(TAG, "  Address: %s", this->address_str().c_str());
+  ESP_LOGCONFIG(TAG, "  Auto-Connect: %s", TRUEFALSE(this->auto_connect_));
+  std::string state_name;
+  switch (this->state()) {
+    case espbt::ClientState::INIT:
+      state_name = "INIT";
+      break;
+    case espbt::ClientState::DISCONNECTING:
+      state_name = "DISCONNECTING";
+      break;
+    case espbt::ClientState::IDLE:
+      state_name = "IDLE";
+      break;
+    case espbt::ClientState::SEARCHING:
+      state_name = "SEARCHING";
+      break;
+    case espbt::ClientState::DISCOVERED:
+      state_name = "DISCOVERED";
+      break;
+    case espbt::ClientState::READY_TO_CONNECT:
+      state_name = "READY_TO_CONNECT";
+      break;
+    case espbt::ClientState::CONNECTING:
+      state_name = "CONNECTING";
+      break;
+    case espbt::ClientState::CONNECTED:
+      state_name = "CONNECTED";
+      break;
+    case espbt::ClientState::ESTABLISHED:
+      state_name = "ESTABLISHED";
+      break;
+    default:
+      state_name = "UNKNOWN_STATE";
+      break;
+  }
+  ESP_LOGCONFIG(TAG, "  State: %s", state_name.c_str());
+  if (this->status_ == ESP_GATT_NO_RESOURCES) {
+    ESP_LOGE(TAG, "  Failed due to no resources. Try to reduce number of BLE clients in config.");
+  } else if (this->status_ != ESP_GATT_OK) {
+    ESP_LOGW(TAG, "  Failed due to error code %d", this->status_);
+  }
+}
+
 bool BLEClientBase::parse_device(const espbt::ESPBTDevice &device) {
   if (!this->auto_connect_)
     return false;
@@ -129,6 +173,8 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       } else {
         ESP_LOGE(TAG, "[%d] [%s] gattc app registration failed id=%d code=%d", this->connection_index_,
                  this->address_str_.c_str(), param->reg.app_id, param->reg.status);
+        this->status_ = param->reg.status;
+        this->mark_failed();
       }
       break;
     }

esphome/components/esp32_ble_client/ble_client_base.h

@@ -26,6 +26,7 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   void setup() override;
   void loop() override;
   float get_setup_priority() const override;
+  void dump_config() override;
 
   void run_later(std::function<void()> &&f);  // NOLINT
   bool parse_device(const espbt::ESPBTDevice &device) override;
@@ -103,6 +104,7 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   bool paired_{false};
   espbt::ConnectionType connection_type_{espbt::ConnectionType::V1};
   std::vector<BLEService *> services_;
+  esp_gatt_status_t status_{ESP_GATT_OK};
 
   void log_event_(const char *name);
 };