esphome 2025.7.5__py3-none-any.whl → 2025.8.0b2__py3-none-any.whl

esphome/components/adc/adc_sensor_zephyr.cpp

@@ -0,0 +1,207 @@
+
+#include "adc_sensor.h"
+#ifdef USE_ZEPHYR
+#include "esphome/core/log.h"
+
+#include "hal/nrf_saadc.h"
+
+namespace esphome {
+namespace adc {
+
+static const char *const TAG = "adc.zephyr";
+
+void ADCSensor::setup() {
+  if (!adc_is_ready_dt(this->channel_)) {
+    ESP_LOGE(TAG, "ADC controller device %s not ready", this->channel_->dev->name);
+    return;
+  }
+
+  auto err = adc_channel_setup_dt(this->channel_);
+  if (err < 0) {
+    ESP_LOGE(TAG, "Could not setup channel %s (%d)", this->channel_->dev->name, err);
+    return;
+  }
+}
+
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+static const LogString *gain_to_str(enum adc_gain gain) {
+  switch (gain) {
+    case ADC_GAIN_1_6:
+      return LOG_STR("1/6");
+    case ADC_GAIN_1_5:
+      return LOG_STR("1/5");
+    case ADC_GAIN_1_4:
+      return LOG_STR("1/4");
+    case ADC_GAIN_1_3:
+      return LOG_STR("1/3");
+    case ADC_GAIN_2_5:
+      return LOG_STR("2/5");
+    case ADC_GAIN_1_2:
+      return LOG_STR("1/2");
+    case ADC_GAIN_2_3:
+      return LOG_STR("2/3");
+    case ADC_GAIN_4_5:
+      return LOG_STR("4/5");
+    case ADC_GAIN_1:
+      return LOG_STR("1");
+    case ADC_GAIN_2:
+      return LOG_STR("2");
+    case ADC_GAIN_3:
+      return LOG_STR("3");
+    case ADC_GAIN_4:
+      return LOG_STR("4");
+    case ADC_GAIN_6:
+      return LOG_STR("6");
+    case ADC_GAIN_8:
+      return LOG_STR("8");
+    case ADC_GAIN_12:
+      return LOG_STR("12");
+    case ADC_GAIN_16:
+      return LOG_STR("16");
+    case ADC_GAIN_24:
+      return LOG_STR("24");
+    case ADC_GAIN_32:
+      return LOG_STR("32");
+    case ADC_GAIN_64:
+      return LOG_STR("64");
+    case ADC_GAIN_128:
+      return LOG_STR("128");
+  }
+  return LOG_STR("undefined gain");
+}
+
+static const LogString *reference_to_str(enum adc_reference reference) {
+  switch (reference) {
+    case ADC_REF_VDD_1:
+      return LOG_STR("VDD");
+    case ADC_REF_VDD_1_2:
+      return LOG_STR("VDD/2");
+    case ADC_REF_VDD_1_3:
+      return LOG_STR("VDD/3");
+    case ADC_REF_VDD_1_4:
+      return LOG_STR("VDD/4");
+    case ADC_REF_INTERNAL:
+      return LOG_STR("INTERNAL");
+    case ADC_REF_EXTERNAL0:
+      return LOG_STR("External, input 0");
+    case ADC_REF_EXTERNAL1:
+      return LOG_STR("External, input 1");
+  }
+  return LOG_STR("undefined reference");
+}
+
+static const LogString *input_to_str(uint8_t input) {
+  switch (input) {
+    case NRF_SAADC_INPUT_AIN0:
+      return LOG_STR("AIN0");
+    case NRF_SAADC_INPUT_AIN1:
+      return LOG_STR("AIN1");
+    case NRF_SAADC_INPUT_AIN2:
+      return LOG_STR("AIN2");
+    case NRF_SAADC_INPUT_AIN3:
+      return LOG_STR("AIN3");
+    case NRF_SAADC_INPUT_AIN4:
+      return LOG_STR("AIN4");
+    case NRF_SAADC_INPUT_AIN5:
+      return LOG_STR("AIN5");
+    case NRF_SAADC_INPUT_AIN6:
+      return LOG_STR("AIN6");
+    case NRF_SAADC_INPUT_AIN7:
+      return LOG_STR("AIN7");
+    case NRF_SAADC_INPUT_VDD:
+      return LOG_STR("VDD");
+    case NRF_SAADC_INPUT_VDDHDIV5:
+      return LOG_STR("VDDHDIV5");
+  }
+  return LOG_STR("undefined input");
+}
+#endif  // ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+
+void ADCSensor::dump_config() {
+  LOG_SENSOR("", "ADC Sensor", this);
+  LOG_PIN("  Pin: ", this->pin_);
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+  ESP_LOGV(TAG,
+           "  Name: %s\n"
+           "  Channel: %d\n"
+           "  vref_mv: %d\n"
+           "  Resolution %d\n"
+           "  Oversampling %d",
+           this->channel_->dev->name, this->channel_->channel_id, this->channel_->vref_mv, this->channel_->resolution,
+           this->channel_->oversampling);
+
+  ESP_LOGV(TAG,
+           "  Gain: %s\n"
+           "  reference: %s\n"
+           "  acquisition_time: %d\n"
+           "  differential %s",
+           LOG_STR_ARG(gain_to_str(this->channel_->channel_cfg.gain)),
+           LOG_STR_ARG(reference_to_str(this->channel_->channel_cfg.reference)),
+           this->channel_->channel_cfg.acquisition_time, YESNO(this->channel_->channel_cfg.differential));
+  if (this->channel_->channel_cfg.differential) {
+    ESP_LOGV(TAG,
+             "  Positive: %s\n"
+             "  Negative: %s",
+             LOG_STR_ARG(input_to_str(this->channel_->channel_cfg.input_positive)),
+             LOG_STR_ARG(input_to_str(this->channel_->channel_cfg.input_negative)));
+  } else {
+    ESP_LOGV(TAG, "  Positive: %s", LOG_STR_ARG(input_to_str(this->channel_->channel_cfg.input_positive)));
+  }
+#endif
+
+  LOG_UPDATE_INTERVAL(this);
+}
+
+float ADCSensor::sample() {
+  auto aggr = Aggregator<int32_t>(this->sampling_mode_);
+  int err;
+  for (uint8_t sample = 0; sample < this->sample_count_; sample++) {
+    int16_t buf = 0;
+    struct adc_sequence sequence = {
+        .buffer = &buf,
+        /* buffer size in bytes, not number of samples */
+        .buffer_size = sizeof(buf),
+    };
+    int32_t val_raw;
+
+    err = adc_sequence_init_dt(this->channel_, &sequence);
+    if (err < 0) {
+      ESP_LOGE(TAG, "Could sequence init %s (%d)", this->channel_->dev->name, err);
+      return 0.0;
+    }
+
+    err = adc_read(this->channel_->dev, &sequence);
+    if (err < 0) {
+      ESP_LOGE(TAG, "Could not read %s (%d)", this->channel_->dev->name, err);
+      return 0.0;
+    }
+
+    val_raw = (int32_t) buf;
+    if (!this->channel_->channel_cfg.differential) {
+      // https://github.com/adafruit/Adafruit_nRF52_Arduino/blob/0ed4d9ffc674ae407be7cacf5696a02f5e789861/cores/nRF5/wiring_analog_nRF52.c#L222
+      if (val_raw < 0) {
+        val_raw = 0;
+      }
+    }
+    aggr.add_sample(val_raw);
+  }
+
+  int32_t val_mv = aggr.aggregate();
+
+  if (this->output_raw_) {
+    return val_mv;
+  }
+
+  err = adc_raw_to_millivolts_dt(this->channel_, &val_mv);
+  /* conversion to mV may not be supported, skip if not */
+  if (err < 0) {
+    ESP_LOGE(TAG, "Value in mV not available %s (%d)", this->channel_->dev->name, err);
+    return 0.0;
+  }
+
+  return val_mv / 1000.0f;
+}
+
+}  // namespace adc
+}  // namespace esphome
+#endif

esphome/components/adc/sensor.py

@@ -3,6 +3,12 @@ import logging
 import esphome.codegen as cg
 from esphome.components import sensor, voltage_sampler
 from esphome.components.esp32 import get_esp32_variant
+from esphome.components.nrf52.const import AIN_TO_GPIO, EXTRA_ADC
+from esphome.components.zephyr import (
+    zephyr_add_overlay,
+    zephyr_add_prj_conf,
+    zephyr_add_user,
+)
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ATTENUATION,
@@ -10,13 +16,12 @@ from esphome.const import (
     CONF_NUMBER,
     CONF_PIN,
     CONF_RAW,
-    CONF_WIFI,
     DEVICE_CLASS_VOLTAGE,
+    PLATFORM_NRF52,
     STATE_CLASS_MEASUREMENT,
     UNIT_VOLT,
 )
 from esphome.core import CORE
-import esphome.final_validate as fv
 
 from . import (
     ATTENUATION_MODES,
@@ -24,6 +29,7 @@ from . import (
     ESP32_VARIANT_ADC2_PIN_TO_CHANNEL,
     SAMPLING_MODES,
     adc_ns,
+    adc_unit_t,
     validate_adc_pin,
 )
 
@@ -57,25 +63,14 @@ def validate_config(config):
     return config
 
 
-def final_validate_config(config):
-    if CORE.is_esp32:
-        variant = get_esp32_variant()
-        if (
-            CONF_WIFI in fv.full_config.get()
-            and config[CONF_PIN][CONF_NUMBER]
-            in ESP32_VARIANT_ADC2_PIN_TO_CHANNEL[variant]
-        ):
-            raise cv.Invalid(
-                f"{variant} doesn't support ADC on this pin when Wi-Fi is configured"
-            )
-
-    return config
-
-
 ADCSensor = adc_ns.class_(
     "ADCSensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
 )
 
+CONF_NRF_SAADC = "nrf_saadc"
+
+adc_dt_spec = cg.global_ns.class_("adc_dt_spec")
+
 CONFIG_SCHEMA = cv.All(
     sensor.sensor_schema(
         ADCSensor,
@@ -91,6 +86,7 @@ CONFIG_SCHEMA = cv.All(
             cv.SplitDefault(CONF_ATTENUATION, esp32="0db"): cv.All(
                 cv.only_on_esp32, _attenuation
             ),
+            cv.OnlyWith(CONF_NRF_SAADC, PLATFORM_NRF52): cv.declare_id(adc_dt_spec),
             cv.Optional(CONF_SAMPLES, default=1): cv.int_range(min=1, max=255),
             cv.Optional(CONF_SAMPLING_MODE, default="avg"): _sampling_mode,
         }
@@ -99,7 +95,7 @@ CONFIG_SCHEMA = cv.All(
     validate_config,
 )
 
-FINAL_VALIDATE_SCHEMA = final_validate_config
+CONF_ADC_CHANNEL_ID = "adc_channel_id"
 
 
 async def to_code(config):
@@ -111,7 +107,7 @@ async def to_code(config):
         cg.add_define("USE_ADC_SENSOR_VCC")
     elif config[CONF_PIN] == "TEMPERATURE":
         cg.add(var.set_is_temperature())
-    else:
+    elif not CORE.is_nrf52 or config[CONF_PIN][CONF_NUMBER] not in EXTRA_ADC:
         pin = await cg.gpio_pin_expression(config[CONF_PIN])
         cg.add(var.set_pin(pin))
 
@@ -119,13 +115,13 @@ async def to_code(config):
     cg.add(var.set_sample_count(config[CONF_SAMPLES]))
     cg.add(var.set_sampling_mode(config[CONF_SAMPLING_MODE]))
 
-    if attenuation := config.get(CONF_ATTENUATION):
-        if attenuation == "auto":
-            cg.add(var.set_autorange(cg.global_ns.true))
-        else:
-            cg.add(var.set_attenuation(attenuation))
-
     if CORE.is_esp32:
+        if attenuation := config.get(CONF_ATTENUATION):
+            if attenuation == "auto":
+                cg.add(var.set_autorange(cg.global_ns.true))
+            else:
+                cg.add(var.set_attenuation(attenuation))
+
         variant = get_esp32_variant()
         pin_num = config[CONF_PIN][CONF_NUMBER]
         if (
@@ -133,10 +129,48 @@ async def to_code(config):
             and pin_num in ESP32_VARIANT_ADC1_PIN_TO_CHANNEL[variant]
         ):
             chan = ESP32_VARIANT_ADC1_PIN_TO_CHANNEL[variant][pin_num]
-            cg.add(var.set_channel1(chan))
+            cg.add(var.set_channel(adc_unit_t.ADC_UNIT_1, chan))
         elif (
             variant in ESP32_VARIANT_ADC2_PIN_TO_CHANNEL
             and pin_num in ESP32_VARIANT_ADC2_PIN_TO_CHANNEL[variant]
         ):
             chan = ESP32_VARIANT_ADC2_PIN_TO_CHANNEL[variant][pin_num]
-            cg.add(var.set_channel2(chan))
+            cg.add(var.set_channel(adc_unit_t.ADC_UNIT_2, chan))
+
+    elif CORE.is_nrf52:
+        CORE.data.setdefault(CONF_ADC_CHANNEL_ID, 0)
+        channel_id = CORE.data[CONF_ADC_CHANNEL_ID]
+        CORE.data[CONF_ADC_CHANNEL_ID] = channel_id + 1
+        zephyr_add_prj_conf("ADC", True)
+        nrf_saadc = config[CONF_NRF_SAADC]
+        rhs = cg.RawExpression(
+            f"ADC_DT_SPEC_GET_BY_IDX(DT_PATH(zephyr_user), {channel_id})"
+        )
+        adc = cg.new_Pvariable(nrf_saadc, rhs)
+        cg.add(var.set_adc_channel(adc))
+        gain = "ADC_GAIN_1_6"
+        pin_number = config[CONF_PIN][CONF_NUMBER]
+        if pin_number == "VDDHDIV5":
+            gain = "ADC_GAIN_1_2"
+        if isinstance(pin_number, int):
+            GPIO_TO_AIN = {v: k for k, v in AIN_TO_GPIO.items()}
+            pin_number = GPIO_TO_AIN[pin_number]
+        zephyr_add_user("io-channels", f"<&adc {channel_id}>")
+        zephyr_add_overlay(
+            f"""
+&adc {{
+    #address-cells = <1>;
+    #size-cells = <0>;
+
+    channel@{channel_id} {{
+        reg = <{channel_id}>;
+        zephyr,gain = "{gain}";
+        zephyr,reference = "ADC_REF_INTERNAL";
+        zephyr,acquisition-time = <ADC_ACQ_TIME_DEFAULT>;
+        zephyr,input-positive = <NRF_SAADC_{pin_number}>;
+        zephyr,resolution = <14>;
+        zephyr,oversampling = <8>;
+    }};
+}};
+"""
+        )

esphome/components/adc128s102/adc128s102.cpp

@@ -8,10 +8,7 @@ static const char *const TAG = "adc128s102";
 
 float ADC128S102::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-void ADC128S102::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-  this->spi_setup();
-}
+void ADC128S102::setup() { this->spi_setup(); }
 
 void ADC128S102::dump_config() {
   ESP_LOGCONFIG(TAG, "ADC128S102:");

esphome/components/ade7880/sensor.py

@@ -36,6 +36,7 @@ from esphome.const import (
     UNIT_WATT,
     UNIT_WATT_HOURS,
 )
+from esphome.types import ConfigType
 
 DEPENDENCIES = ["i2c"]
 
@@ -51,6 +52,20 @@ CONF_POWER_GAIN = "power_gain"
 
 CONF_NEUTRAL = "neutral"
 
+# Tuple of power channel phases
+POWER_PHASES = (CONF_PHASE_A, CONF_PHASE_B, CONF_PHASE_C)
+
+# Tuple of sensor types that can be configured for power channels
+POWER_SENSOR_TYPES = (
+    CONF_CURRENT,
+    CONF_VOLTAGE,
+    CONF_ACTIVE_POWER,
+    CONF_APPARENT_POWER,
+    CONF_POWER_FACTOR,
+    CONF_FORWARD_ACTIVE_ENERGY,
+    CONF_REVERSE_ACTIVE_ENERGY,
+)
+
 NEUTRAL_CHANNEL_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.declare_id(NeutralChannel),
@@ -150,7 +165,64 @@ POWER_CHANNEL_SCHEMA = cv.Schema(
     }
 )
 
-CONFIG_SCHEMA = (
+
+def prefix_sensor_name(
+    sensor_conf: ConfigType,
+    channel_name: str,
+    channel_config: ConfigType,
+    sensor_type: str,
+) -> None:
+    """Helper to prefix sensor name with channel name.
+
+    Args:
+        sensor_conf: The sensor configuration (dict or string)
+        channel_name: The channel name to prefix with
+        channel_config: The channel configuration to update
+        sensor_type: The sensor type key in the channel config
+    """
+    if isinstance(sensor_conf, dict) and CONF_NAME in sensor_conf:
+        sensor_name = sensor_conf[CONF_NAME]
+        if sensor_name and not sensor_name.startswith(channel_name):
+            sensor_conf[CONF_NAME] = f"{channel_name} {sensor_name}"
+    elif isinstance(sensor_conf, str):
+        # Simple value case - convert to dict with prefixed name
+        channel_config[sensor_type] = {CONF_NAME: f"{channel_name} {sensor_conf}"}
+
+
+def process_channel_sensors(
+    config: ConfigType, channel_key: str, sensor_types: tuple
+) -> None:
+    """Process sensors for a channel and prefix their names.
+
+    Args:
+        config: The main configuration
+        channel_key: The channel key (e.g., CONF_PHASE_A, CONF_NEUTRAL)
+        sensor_types: Tuple of sensor types to process for this channel
+    """
+    if not (channel_config := config.get(channel_key)) or not (
+        channel_name := channel_config.get(CONF_NAME)
+    ):
+        return
+
+    for sensor_type in sensor_types:
+        if sensor_conf := channel_config.get(sensor_type):
+            prefix_sensor_name(sensor_conf, channel_name, channel_config, sensor_type)
+
+
+def preprocess_channels(config: ConfigType) -> ConfigType:
+    """Preprocess channel configurations to add channel name prefix to sensor names."""
+    # Process power channels
+    for channel in POWER_PHASES:
+        process_channel_sensors(config, channel, POWER_SENSOR_TYPES)
+
+    # Process neutral channel
+    process_channel_sensors(config, CONF_NEUTRAL, (CONF_CURRENT,))
+
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    preprocess_channels,
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(ADE7880),
@@ -167,7 +239,7 @@ CONFIG_SCHEMA = (
         }
     )
     .extend(cv.polling_component_schema("60s"))
-    .extend(i2c.i2c_device_schema(0x38))
+    .extend(i2c.i2c_device_schema(0x38)),
 )
 
 
@@ -188,15 +260,7 @@ async def neutral_channel(config):
 async def power_channel(config):
     var = cg.new_Pvariable(config[CONF_ID])
 
-    for sensor_type in [
-        CONF_CURRENT,
-        CONF_VOLTAGE,
-        CONF_ACTIVE_POWER,
-        CONF_APPARENT_POWER,
-        CONF_POWER_FACTOR,
-        CONF_FORWARD_ACTIVE_ENERGY,
-        CONF_REVERSE_ACTIVE_ENERGY,
-    ]:
+    for sensor_type in POWER_SENSOR_TYPES:
         if conf := config.get(sensor_type):
             sens = await sensor.new_sensor(conf)
             cg.add(getattr(var, f"set_{sensor_type}")(sens))
@@ -216,44 +280,6 @@ async def power_channel(config):
     return var
 
 
-def final_validate(config):
-    for channel in [CONF_PHASE_A, CONF_PHASE_B, CONF_PHASE_C]:
-        if channel := config.get(channel):
-            channel_name = channel.get(CONF_NAME)
-
-            for sensor_type in [
-                CONF_CURRENT,
-                CONF_VOLTAGE,
-                CONF_ACTIVE_POWER,
-                CONF_APPARENT_POWER,
-                CONF_POWER_FACTOR,
-                CONF_FORWARD_ACTIVE_ENERGY,
-                CONF_REVERSE_ACTIVE_ENERGY,
-            ]:
-                if conf := channel.get(sensor_type):
-                    sensor_name = conf.get(CONF_NAME)
-                    if (
-                        sensor_name
-                        and channel_name
-                        and not sensor_name.startswith(channel_name)
-                    ):
-                        conf[CONF_NAME] = f"{channel_name} {sensor_name}"
-
-    if channel := config.get(CONF_NEUTRAL):
-        channel_name = channel.get(CONF_NAME)
-        if conf := channel.get(CONF_CURRENT):
-            sensor_name = conf.get(CONF_NAME)
-            if (
-                sensor_name
-                and channel_name
-                and not sensor_name.startswith(channel_name)
-            ):
-                conf[CONF_NAME] = f"{channel_name} {sensor_name}"
-
-
-FINAL_VALIDATE_SCHEMA = final_validate
-
-
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/ads1115/ads1115.cpp

@@ -10,7 +10,6 @@ static const uint8_t ADS1115_REGISTER_CONVERSION = 0x00;
 static const uint8_t ADS1115_REGISTER_CONFIG = 0x01;
 
 void ADS1115Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   uint16_t value;
   if (!this->read_byte_16(ADS1115_REGISTER_CONVERSION, &value)) {
     this->mark_failed();

esphome/components/ads1118/ads1118.cpp

@@ -9,7 +9,6 @@ static const char *const TAG = "ads1118";
 static const uint8_t ADS1118_DATA_RATE_860_SPS = 0b111;
 
 void ADS1118::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->spi_setup();
 
   this->config_ = 0;

esphome/components/ags10/ags10.cpp

@@ -24,8 +24,6 @@ static const uint16_t ZP_CURRENT = 0x0000;
 static const uint16_t ZP_DEFAULT = 0xFFFF;
 
 void AGS10Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   auto version = this->read_version_();
   if (version) {
     ESP_LOGD(TAG, "AGS10 Sensor Version: 0x%02X", *version);
@@ -45,8 +43,6 @@ void AGS10Component::setup() {
   } else {
     ESP_LOGE(TAG, "AGS10 Sensor Resistance: unknown");
   }
-
-  ESP_LOGD(TAG, "Sensor initialized");
 }
 
 void AGS10Component::update() {

esphome/components/aht10/aht10.cpp

@@ -38,8 +38,6 @@ static const uint8_t AHT10_STATUS_BUSY = 0x80;
 static const float AHT10_DIVISOR = 1048576.0f;  // 2^20, used for temperature and humidity calculations
 
 void AHT10Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   if (this->write(AHT10_SOFTRESET_CMD, sizeof(AHT10_SOFTRESET_CMD)) != i2c::ERROR_OK) {
     ESP_LOGE(TAG, "Reset failed");
   }
@@ -80,8 +78,6 @@ void AHT10Component::setup() {
     this->mark_failed();
     return;
   }
-
-  ESP_LOGV(TAG, "Initialization complete");
 }
 
 void AHT10Component::restart_read_() {

esphome/components/aic3204/aic3204.cpp

@@ -17,8 +17,6 @@ static const char *const TAG = "aic3204";
   }
 
 void AIC3204::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   // Set register page to 0
   ERROR_CHECK(this->write_byte(AIC3204_PAGE_CTRL, 0x00), "Set page 0 failed");
   // Initiate SW reset (PLL is powered off as part of reset)

esphome/components/airthings_wave_plus/__init__.py

@@ -1 +1 @@
-CODEOWNERS = ["@jeromelaban"]
+CODEOWNERS = ["@jeromelaban", "@precurse"]

esphome/components/airthings_wave_plus/airthings_wave_plus.cpp

@@ -73,11 +73,29 @@ void AirthingsWavePlus::dump_config() {
   LOG_SENSOR("  ", "Illuminance", this->illuminance_sensor_);
 }
 
-AirthingsWavePlus::AirthingsWavePlus() {
-  this->service_uuid_ = espbt::ESPBTUUID::from_raw(SERVICE_UUID);
-  this->sensors_data_characteristic_uuid_ = espbt::ESPBTUUID::from_raw(CHARACTERISTIC_UUID);
+void AirthingsWavePlus::setup() {
+  const char *service_uuid;
+  const char *characteristic_uuid;
+  const char *access_control_point_characteristic_uuid;
+
+  // Change UUIDs for Wave Radon Gen2
+  switch (this->wave_device_type_) {
+    case WaveDeviceType::WAVE_GEN2:
+      service_uuid = SERVICE_UUID_WAVE_RADON_GEN2;
+      characteristic_uuid = CHARACTERISTIC_UUID_WAVE_RADON_GEN2;
+      access_control_point_characteristic_uuid = ACCESS_CONTROL_POINT_CHARACTERISTIC_UUID_WAVE_RADON_GEN2;
+      break;
+    default:
+      // Wave Plus
+      service_uuid = SERVICE_UUID;
+      characteristic_uuid = CHARACTERISTIC_UUID;
+      access_control_point_characteristic_uuid = ACCESS_CONTROL_POINT_CHARACTERISTIC_UUID;
+  }
+
+  this->service_uuid_ = espbt::ESPBTUUID::from_raw(service_uuid);
+  this->sensors_data_characteristic_uuid_ = espbt::ESPBTUUID::from_raw(characteristic_uuid);
   this->access_control_point_characteristic_uuid_ =
-      espbt::ESPBTUUID::from_raw(ACCESS_CONTROL_POINT_CHARACTERISTIC_UUID);
+      espbt::ESPBTUUID::from_raw(access_control_point_characteristic_uuid);
 }
 
 }  // namespace airthings_wave_plus

esphome/components/airthings_wave_plus/airthings_wave_plus.h

@@ -9,13 +9,20 @@ namespace airthings_wave_plus {
 
 namespace espbt = esphome::esp32_ble_tracker;
 
+enum WaveDeviceType : uint8_t { WAVE_PLUS = 0, WAVE_GEN2 = 1 };
+
 static const char *const SERVICE_UUID = "b42e1c08-ade7-11e4-89d3-123b93f75cba";
 static const char *const CHARACTERISTIC_UUID = "b42e2a68-ade7-11e4-89d3-123b93f75cba";
 static const char *const ACCESS_CONTROL_POINT_CHARACTERISTIC_UUID = "b42e2d06-ade7-11e4-89d3-123b93f75cba";
 
+static const char *const SERVICE_UUID_WAVE_RADON_GEN2 = "b42e4a8e-ade7-11e4-89d3-123b93f75cba";
+static const char *const CHARACTERISTIC_UUID_WAVE_RADON_GEN2 = "b42e4dcc-ade7-11e4-89d3-123b93f75cba";
+static const char *const ACCESS_CONTROL_POINT_CHARACTERISTIC_UUID_WAVE_RADON_GEN2 =
+    "b42e50d8-ade7-11e4-89d3-123b93f75cba";
+
 class AirthingsWavePlus : public airthings_wave_base::AirthingsWaveBase {
  public:
-  AirthingsWavePlus();
+  void setup() override;
 
   void dump_config() override;
 
@@ -23,12 +30,14 @@ class AirthingsWavePlus : public airthings_wave_base::AirthingsWaveBase {
   void set_radon_long_term(sensor::Sensor *radon_long_term) { radon_long_term_sensor_ = radon_long_term; }
   void set_co2(sensor::Sensor *co2) { co2_sensor_ = co2; }
   void set_illuminance(sensor::Sensor *illuminance) { illuminance_sensor_ = illuminance; }
+  void set_device_type(WaveDeviceType wave_device_type) { wave_device_type_ = wave_device_type; }
 
  protected:
   bool is_valid_radon_value_(uint16_t radon);
   bool is_valid_co2_value_(uint16_t co2);
 
   void read_sensors(uint8_t *raw_value, uint16_t value_len) override;
+  WaveDeviceType wave_device_type_{WaveDeviceType::WAVE_PLUS};
 
   sensor::Sensor *radon_sensor_{nullptr};
   sensor::Sensor *radon_long_term_sensor_{nullptr};