esphome 2024.9.1__py3-none-any.whl → 2024.10.0__py3-none-any.whl

esphome/components/nau7802/nau7802.h

@@ -0,0 +1,121 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/automation.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+#include <cinttypes>
+
+namespace esphome {
+namespace nau7802 {
+
+enum NAU7802Gain {
+  NAU7802_GAIN_128 = 0b111,
+  NAU7802_GAIN_64 = 0b110,
+  NAU7802_GAIN_32 = 0b101,
+  NAU7802_GAIN_16 = 0b100,
+  NAU7802_GAIN_8 = 0b011,
+  NAU7802_GAIN_4 = 0b010,
+  NAU7802_GAIN_2 = 0b001,
+  NAU7802_GAIN_1 = 0b000,
+};
+
+enum NAU7802SPS {
+  NAU7802_SPS_320 = 0b111,
+  NAU7802_SPS_80 = 0b011,
+  NAU7802_SPS_40 = 0b010,
+  NAU7802_SPS_20 = 0b001,
+  NAU7802_SPS_10 = 0b000,
+};
+
+enum NAU7802LDO {
+  NAU7802_LDO_2V4 = 0b111,
+  NAU7802_LDO_2V7 = 0b110,
+  NAU7802_LDO_3V0 = 0b101,
+  NAU7802_LDO_3V3 = 0b100,
+  NAU7802_LDO_3V6 = 0b011,
+  NAU7802_LDO_3V9 = 0b010,
+  NAU7802_LDO_4V2 = 0b001,
+  NAU7802_LDO_4V5 = 0b000,
+  // Never write this to a register
+  NAU7802_LDO_EXTERNAL = 0b1000,
+};
+
+enum NAU7802CalibrationModes {
+  NAU7802_CALIBRATE_EXTERNAL_OFFSET = 0b10,
+  NAU7802_CALIBRATE_INTERNAL_OFFSET = 0b00,
+  NAU7802_CALIBRATE_GAIN = 0b11,
+};
+
+class NAU7802Sensor : public sensor::Sensor, public PollingComponent, public i2c::I2CDevice {
+ public:
+  void set_samples_per_second(NAU7802SPS sps) { this->sps_ = sps; }
+  void set_ldo_voltage(NAU7802LDO ldo) { this->ldo_ = ldo; }
+  void set_gain(NAU7802Gain gain) { this->gain_ = gain; }
+  void set_gain_calibration(float gain_calibration) { this->gain_calibration_ = gain_calibration; }
+  void set_offset_calibration(int32_t offset_calibration) { this->offset_calibration_ = offset_calibration; }
+  bool calibrate_external_offset() { return this->calibrate_(NAU7802_CALIBRATE_EXTERNAL_OFFSET); }
+  bool calibrate_internal_offset() { return this->calibrate_(NAU7802_CALIBRATE_INTERNAL_OFFSET); }
+  bool calibrate_gain() { return this->calibrate_(NAU7802_CALIBRATE_GAIN); }
+
+  void setup() override;
+  void loop() override;
+  bool can_proceed() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+  void update() override;
+
+ protected:
+  //
+  // Internal state
+  //
+  enum class CalibrationState : uint8_t {
+    INACTIVE,
+    OFFSET,
+    GAIN,
+  } state_{CalibrationState::INACTIVE};
+
+  float gain_calibration_;
+  int32_t offset_calibration_;
+  bool offset_calibration_failed_ = false;
+  bool gain_calibration_failed_ = false;
+  bool setup_complete_ = false;
+
+  //
+  // Config values
+  //
+  NAU7802LDO ldo_;
+  NAU7802SPS sps_;
+  NAU7802Gain gain_;
+
+  //
+  // Internal Methods
+  //
+  bool calibrate_(enum NAU7802CalibrationModes mode);
+  void complete_setup_();
+  void write_value_(uint8_t start_reg, size_t size, int32_t value);
+  int32_t read_value_(uint8_t start_reg, size_t size);
+  bool is_data_ready_();
+  void set_calibration_failure_(bool failed);
+};
+
+template<typename... Ts>
+class NAU7802CalbrateExternalOffsetAction : public Action<Ts...>, public Parented<NAU7802Sensor> {
+ public:
+  void play(Ts... x) override { this->parent_->calibrate_external_offset(); }
+};
+
+template<typename... Ts>
+class NAU7802CalbrateInternalOffsetAction : public Action<Ts...>, public Parented<NAU7802Sensor> {
+ public:
+  void play(Ts... x) override { this->parent_->calibrate_internal_offset(); }
+};
+
+template<typename... Ts> class NAU7802CalbrateGainAction : public Action<Ts...>, public Parented<NAU7802Sensor> {
+ public:
+  void play(Ts... x) override { this->parent_->calibrate_gain(); }
+};
+
+}  // namespace nau7802
+}  // namespace esphome

esphome/components/nau7802/sensor.py

@@ -0,0 +1,134 @@
+from esphome import automation
+from esphome.automation import maybe_simple_id
+import esphome.codegen as cg
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_GAIN, CONF_ID, ICON_SCALE, STATE_CLASS_MEASUREMENT
+
+CODEOWNERS = ["@cujomalainey"]
+DEPENDENCIES = ["i2c"]
+
+CONF_GAIN_CALIBRATION = "gain_calibration"
+CONF_OFFSET_CALIBRATION = "offset_calibration"
+CONF_LDO_VOLTAGE = "ldo_voltage"
+CONF_SAMPLES_PER_SECOND = "samples_per_second"
+
+nau7802_ns = cg.esphome_ns.namespace("nau7802")
+NAU7802Sensor = nau7802_ns.class_(
+    "NAU7802Sensor", sensor.Sensor, cg.PollingComponent, i2c.I2CDevice
+)
+NAU7802CalbrateExternalOffsetAction = nau7802_ns.class_(
+    "NAU7802CalbrateExternalOffsetAction",
+    automation.Action,
+    cg.Parented.template(NAU7802Sensor),
+)
+NAU7802CalbrateInternalOffsetAction = nau7802_ns.class_(
+    "NAU7802CalbrateInternalOffsetAction",
+    automation.Action,
+    cg.Parented.template(NAU7802Sensor),
+)
+NAU7802CalbrateGainAction = nau7802_ns.class_(
+    "NAU7802CalbrateGainAction", automation.Action, cg.Parented.template(NAU7802Sensor)
+)
+
+NAU7802Gain = nau7802_ns.enum("NAU7802Gain")
+GAINS = {
+    128: NAU7802Gain.NAU7802_GAIN_128,
+    64: NAU7802Gain.NAU7802_GAIN_64,
+    32: NAU7802Gain.NAU7802_GAIN_32,
+    16: NAU7802Gain.NAU7802_GAIN_16,
+    8: NAU7802Gain.NAU7802_GAIN_8,
+    4: NAU7802Gain.NAU7802_GAIN_4,
+    2: NAU7802Gain.NAU7802_GAIN_2,
+    1: NAU7802Gain.NAU7802_GAIN_1,
+}
+
+NAU7802SPS = nau7802_ns.enum("NAU7802SPS")
+SAMPLES_PER_SECOND = {
+    320: NAU7802SPS.NAU7802_SPS_320,
+    80: NAU7802SPS.NAU7802_SPS_80,
+    40: NAU7802SPS.NAU7802_SPS_40,
+    20: NAU7802SPS.NAU7802_SPS_20,
+    10: NAU7802SPS.NAU7802_SPS_10,
+}
+
+NAU7802LDO = nau7802_ns.enum("NAU7802LDO")
+LDO = {
+    "2.4V": NAU7802LDO.NAU7802_LDO_2V4,
+    "2.7V": NAU7802LDO.NAU7802_LDO_2V7,
+    "3.0V": NAU7802LDO.NAU7802_LDO_3V0,
+    "3.3V": NAU7802LDO.NAU7802_LDO_3V3,
+    "3.6V": NAU7802LDO.NAU7802_LDO_3V6,
+    "3.9V": NAU7802LDO.NAU7802_LDO_3V9,
+    "4.2V": NAU7802LDO.NAU7802_LDO_4V2,
+    "4.5V": NAU7802LDO.NAU7802_LDO_4V5,
+    "EXTERNAL": NAU7802LDO.NAU7802_LDO_EXTERNAL,
+    "EXT": NAU7802LDO.NAU7802_LDO_EXTERNAL,
+}
+
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(
+        NAU7802Sensor,
+        icon=ICON_SCALE,
+        accuracy_decimals=0,
+        state_class=STATE_CLASS_MEASUREMENT,
+    )
+    .extend(
+        {
+            cv.Optional(CONF_LDO_VOLTAGE, default="3.0V"): cv.enum(LDO, upper=True),
+            cv.Optional(CONF_SAMPLES_PER_SECOND, default=10): cv.enum(
+                SAMPLES_PER_SECOND, int=True
+            ),
+            cv.Optional(CONF_GAIN, default=128): cv.enum(GAINS, int=True),
+            cv.Optional(CONF_OFFSET_CALIBRATION, default=0): cv.int_range(
+                min=-8388608, max=8388607
+            ),
+            cv.Optional(CONF_GAIN_CALIBRATION, default=1.0): cv.float_range(
+                min=0, max=511.9999998807907
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x2A))
+)
+
+
+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)
+    await sensor.register_sensor(var, config)
+
+    cg.add(var.set_samples_per_second(config[CONF_SAMPLES_PER_SECOND]))
+    cg.add(var.set_ldo_voltage(config[CONF_LDO_VOLTAGE]))
+    cg.add(var.set_gain(config[CONF_GAIN]))
+    cg.add(var.set_gain_calibration(config[CONF_GAIN_CALIBRATION]))
+    cg.add(var.set_offset_calibration(config[CONF_OFFSET_CALIBRATION]))
+
+
+NAU7802_CALIBRATE_SCHEMA = maybe_simple_id(
+    {
+        cv.GenerateID(CONF_ID): cv.use_id(NAU7802Sensor),
+    }
+)
+
+
+@automation.register_action(
+    "nau7802.calibrate_internal_offset",
+    NAU7802CalbrateInternalOffsetAction,
+    NAU7802_CALIBRATE_SCHEMA,
+)
+@automation.register_action(
+    "nau7802.calibrate_external_offset",
+    NAU7802CalbrateExternalOffsetAction,
+    NAU7802_CALIBRATE_SCHEMA,
+)
+@automation.register_action(
+    "nau7802.calibrate_gain",
+    NAU7802CalbrateGainAction,
+    NAU7802_CALIBRATE_SCHEMA,
+)
+async def nau7802_calibrate_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var

esphome/components/nextion/base_component.py

@@ -27,6 +27,7 @@ CONF_BACKGROUND_PRESSED_COLOR = "background_pressed_color"
 CONF_FOREGROUND_PRESSED_COLOR = "foreground_pressed_color"
 CONF_FONT_ID = "font_id"
 CONF_EXIT_REPARSE_ON_START = "exit_reparse_on_start"
+CONF_SKIP_CONNECTION_HANDSHAKE = "skip_connection_handshake"
 
 
 def NextionName(value):

esphome/components/nextion/display.py

@@ -23,6 +23,7 @@ from .base_component import (
     CONF_START_UP_PAGE,
     CONF_AUTO_WAKE_ON_TOUCH,
     CONF_EXIT_REPARSE_ON_START,
+    CONF_SKIP_CONNECTION_HANDSHAKE,
 )
 
 CODEOWNERS = ["@senexcrenshaw", "@edwardtfn"]
@@ -72,6 +73,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_START_UP_PAGE): cv.uint8_t,
             cv.Optional(CONF_AUTO_WAKE_ON_TOUCH, default=True): cv.boolean,
             cv.Optional(CONF_EXIT_REPARSE_ON_START, default=False): cv.boolean,
+            cv.Optional(CONF_SKIP_CONNECTION_HANDSHAKE, default=False): cv.boolean,
         }
     )
     .extend(cv.polling_component_schema("5s"))
@@ -118,6 +120,8 @@ async def to_code(config):
 
     cg.add(var.set_exit_reparse_on_start_internal(config[CONF_EXIT_REPARSE_ON_START]))
 
+    cg.add(var.set_skip_connection_handshake(config[CONF_SKIP_CONNECTION_HANDSHAKE]))
+
     await display.register_display(var, config)
 
     for conf in config.get(CONF_ON_SETUP, []):

esphome/components/nextion/nextion.cpp

@@ -43,6 +43,16 @@ bool Nextion::check_connect_() {
   if (this->get_is_connected_())
     return true;
 
+  // Check if the handshake should be skipped for the Nextion connection
+  if (this->skip_connection_handshake_) {
+    // Log the connection status without handshake
+    ESP_LOGW(TAG, "Nextion display set as connected without performing handshake");
+    // Set the connection status to true
+    this->is_connected_ = true;
+    // Return true indicating the connection is set
+    return true;
+  }
+
   if (this->comok_sent_ == 0) {
     this->reset_(false);
 
@@ -126,10 +136,14 @@ void Nextion::reset_(bool reset_nextion) {
 
 void Nextion::dump_config() {
   ESP_LOGCONFIG(TAG, "Nextion:");
-  ESP_LOGCONFIG(TAG, "  Device Model:     %s", this->device_model_.c_str());
-  ESP_LOGCONFIG(TAG, "  Firmware Version: %s", this->firmware_version_.c_str());
-  ESP_LOGCONFIG(TAG, "  Serial Number:    %s", this->serial_number_.c_str());
-  ESP_LOGCONFIG(TAG, "  Flash Size:       %s", this->flash_size_.c_str());
+  if (this->skip_connection_handshake_) {
+    ESP_LOGCONFIG(TAG, "  Skip handshake:   %s", YESNO(this->skip_connection_handshake_));
+  } else {
+    ESP_LOGCONFIG(TAG, "  Device Model:     %s", this->device_model_.c_str());
+    ESP_LOGCONFIG(TAG, "  Firmware Version: %s", this->firmware_version_.c_str());
+    ESP_LOGCONFIG(TAG, "  Serial Number:    %s", this->serial_number_.c_str());
+    ESP_LOGCONFIG(TAG, "  Flash Size:       %s", this->flash_size_.c_str());
+  }
   ESP_LOGCONFIG(TAG, "  Wake On Touch:    %s", YESNO(this->auto_wake_on_touch_));
   ESP_LOGCONFIG(TAG, "  Exit reparse:     %s", YESNO(this->exit_reparse_on_start_));
 
@@ -262,6 +276,7 @@ void Nextion::loop() {
       this->goto_page(this->start_up_page_);
     }
 
+    // This could probably be removed from the loop area, as those are redundant.
     this->set_auto_wake_on_touch(this->auto_wake_on_touch_);
     this->set_exit_reparse_on_start(this->exit_reparse_on_start_);
 

esphome/components/nextion/nextion.h

@@ -926,6 +926,21 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    */
   void set_exit_reparse_on_start(bool exit_reparse);
 
+  /**
+   * Sets whether the Nextion display should skip the connection handshake process.
+   * @param skip_handshake True or false. When skip_connection_handshake is true,
+   * the connection will be established without performing the handshake.
+   * This can be useful when using Nextion Simulator.
+   *
+   * Example:
+   * ```cpp
+   * it.set_skip_connection_handshake(true);
+   * ```
+   *
+   * When set to true, the display will be marked as connected without performing a handshake.
+   */
+  void set_skip_connection_handshake(bool skip_handshake) { this->skip_connection_handshake_ = skip_handshake; }
+
   /**
    * Sets Nextion mode between sleep and awake
    * @param True or false. Sleep=true to enter sleep mode or sleep=false to exit sleep mode.
@@ -1221,6 +1236,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   int16_t start_up_page_ = -1;
   bool auto_wake_on_touch_ = true;
   bool exit_reparse_on_start_ = false;
+  bool skip_connection_handshake_ = false;
 
   /**
    * Manually send a raw command to the display and don't wait for an acknowledgement packet.

esphome/components/npi19/npi19.cpp

@@ -0,0 +1,111 @@
+#include "npi19.h"
+#include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/hal.h"
+
+namespace esphome {
+namespace npi19 {
+
+static const char *const TAG = "npi19";
+
+static const uint8_t READ_COMMAND = 0xAC;
+
+void NPI19Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up NPI19...");
+
+  uint16_t raw_temperature(0);
+  uint16_t raw_pressure(0);
+  i2c::ErrorCode err = this->read_(raw_temperature, raw_pressure);
+  if (err != i2c::ERROR_OK) {
+    ESP_LOGCONFIG(TAG, "    I2C Communication Failed...");
+    this->mark_failed();
+    return;
+  }
+
+  ESP_LOGCONFIG(TAG, "    Success...");
+}
+
+void NPI19Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "NPI19:");
+  LOG_I2C_DEVICE(this);
+  LOG_UPDATE_INTERVAL(this);
+  LOG_SENSOR("  ", "Raw Pressure", this->raw_pressure_sensor_);
+  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+}
+
+float NPI19Component::get_setup_priority() const { return setup_priority::DATA; }
+
+i2c::ErrorCode NPI19Component::read_(uint16_t &raw_temperature, uint16_t &raw_pressure) {
+  // initiate data read from device
+  i2c::ErrorCode w_err = write(&READ_COMMAND, sizeof(READ_COMMAND), true);
+  if (w_err != i2c::ERROR_OK) {
+    return w_err;
+  }
+
+  // read 4 bytes from senesor
+  uint8_t response[4] = {0x00, 0x00, 0x00, 0x00};
+  i2c::ErrorCode r_err = this->read(response, 4);
+
+  if (r_err != i2c::ERROR_OK) {
+    return r_err;
+  }
+
+  // extract top 6 bits of first byte and all bits of second byte for pressure
+  raw_pressure = ((response[0] & 0x3F) << 8) | response[1];
+
+  // extract all bytes of 3rd byte and top 3 bits of fourth byte for temperature
+  raw_temperature = (response[2] << 3) | ((response[3] & 0xE0) >> 5);
+
+  return i2c::ERROR_OK;
+}
+
+inline float convert_temperature(uint16_t raw_temperature) {
+  /*
+   * Correspondance with Amphenol confirmed the appropriate equation for computing temperature is:
+   * T (°C) =(((((Th*8)+Tl)/2048)*200)-50), where Th is the high (third) byte and Tl is the low (fourth) byte.
+   *
+   * Tl is actually the upper 3 bits of the fourth data byte; the first 5 (LSBs) must be masked out.
+   *
+   *
+   * The NPI-19 I2C has a temperature output, however the manufacturer does
+   * not specify its accuracy on the published datasheet. They indicate
+   * that the sensor should not be used as a calibrated temperature
+   * reading; it’s only intended for curve fitting data during
+   * compensation.
+   */
+  const float temperature_bits_span = 2048;
+  const float temperature_max = 150;
+  const float temperature_min = -50;
+  const float temperature_span = temperature_max - temperature_min;
+
+  float temperature = (raw_temperature * temperature_span / temperature_bits_span) + temperature_min;
+
+  return temperature;
+}
+
+void NPI19Component::update() {
+  uint16_t raw_temperature(0);
+  uint16_t raw_pressure(0);
+
+  i2c::ErrorCode err = this->read_(raw_temperature, raw_pressure);
+
+  if (err != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "I2C Communication Failed");
+    this->status_set_warning();
+    return;
+  }
+
+  float temperature = convert_temperature(raw_temperature);
+
+  ESP_LOGD(TAG, "Got raw pressure=%d, temperature=%.1f°C", raw_pressure, temperature);
+
+  if (this->temperature_sensor_ != nullptr)
+    this->temperature_sensor_->publish_state(temperature);
+  if (this->raw_pressure_sensor_ != nullptr)
+    this->raw_pressure_sensor_->publish_state(raw_pressure);
+
+  this->status_clear_warning();
+}
+
+}  // namespace npi19
+}  // namespace esphome

esphome/components/npi19/npi19.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace npi19 {
+
+/// This class implements support for the npi19 pressure and temperature i2c sensors.
+class NPI19Component : public PollingComponent, public i2c::I2CDevice {
+ public:
+  void set_temperature_sensor(sensor::Sensor *temperature_sensor) { this->temperature_sensor_ = temperature_sensor; }
+  void set_raw_pressure_sensor(sensor::Sensor *raw_pressure_sensor) {
+    this->raw_pressure_sensor_ = raw_pressure_sensor;
+  }
+
+  float get_setup_priority() const override;
+  void setup() override;
+  void dump_config() override;
+  void update() override;
+
+ protected:
+  i2c::ErrorCode read_(uint16_t &raw_temperature, uint16_t &raw_pressure);
+  sensor::Sensor *temperature_sensor_{nullptr};
+  sensor::Sensor *raw_pressure_sensor_{nullptr};
+};
+
+}  // namespace npi19
+}  // namespace esphome

esphome/components/npi19/sensor.py

@@ -0,0 +1,52 @@
+import esphome.codegen as cg
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_TEMPERATURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+)
+
+CODEOWNERS = ["@bakerkj"]
+DEPENDENCIES = ["i2c"]
+
+npi19_ns = cg.esphome_ns.namespace("npi19")
+
+NPI19Component = npi19_ns.class_("NPI19Component", cg.PollingComponent, i2c.I2CDevice)
+
+CONF_RAW_PRESSURE = "raw_pressure"
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(NPI19Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_RAW_PRESSURE): sensor.sensor_schema(
+                accuracy_decimals=0, state_class=STATE_CLASS_MEASUREMENT
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x28))
+)
+
+
+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)
+
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if raw_pressure_config := config.get(CONF_RAW_PRESSURE):
+        sens = await sensor.new_sensor(raw_pressure_config)
+        cg.add(var.set_raw_pressure_sensor(sens))

esphome/components/number/__init__.py

@@ -18,7 +18,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_UNIT_OF_MEASUREMENT,
     CONF_VALUE,
-    CONF_WEB_SERVER_ID,
+    CONF_WEB_SERVER,
     DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_AQI,
     DEVICE_CLASS_ATMOSPHERIC_PRESSURE,
@@ -254,10 +254,8 @@ async def setup_number_core_(
     if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
         mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
-
-    if (webserver_id := config.get(CONF_WEB_SERVER_ID)) is not None:
-        web_server_ = await cg.get_variable(webserver_id)
-        web_server.add_entity_to_sorting_list(web_server_, var, config)
+    if web_server_config := config.get(CONF_WEB_SERVER):
+        await web_server.add_entity_config(var, web_server_config)
 
 
 async def register_number(

esphome/components/online_image/__init__.py

@@ -125,7 +125,7 @@ async def online_image_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg, paren)
 
     if CONF_URL in config:
-        template_ = await cg.templatable(config[CONF_URL], args, cg.const_char_ptr)
+        template_ = await cg.templatable(config[CONF_URL], args, cg.std_string)
         cg.add(var.set_url(template_))
     return var
 

esphome/components/online_image/online_image.h

@@ -157,7 +157,7 @@ class OnlineImage : public PollingComponent,
 template<typename... Ts> class OnlineImageSetUrlAction : public Action<Ts...> {
  public:
   OnlineImageSetUrlAction(OnlineImage *parent) : parent_(parent) {}
-  TEMPLATABLE_VALUE(const char *, url)
+  TEMPLATABLE_VALUE(std::string, url)
   void play(Ts... x) override {
     this->parent_->set_url(this->url_.value(x...));
     this->parent_->update();
@@ -170,7 +170,6 @@ template<typename... Ts> class OnlineImageSetUrlAction : public Action<Ts...> {
 template<typename... Ts> class OnlineImageReleaseAction : public Action<Ts...> {
  public:
   OnlineImageReleaseAction(OnlineImage *parent) : parent_(parent) {}
-  TEMPLATABLE_VALUE(const char *, url)
   void play(Ts... x) override { this->parent_->release(); }
 
  protected:

esphome/components/opentherm/__init__.py

@@ -0,0 +1,57 @@
+from typing import Any
+
+from esphome import pins
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, PLATFORM_ESP32, PLATFORM_ESP8266
+
+CODEOWNERS = ["@olegtarasov"]
+MULTI_CONF = True
+
+CONF_IN_PIN = "in_pin"
+CONF_OUT_PIN = "out_pin"
+CONF_CH_ENABLE = "ch_enable"
+CONF_DHW_ENABLE = "dhw_enable"
+CONF_COOLING_ENABLE = "cooling_enable"
+CONF_OTC_ACTIVE = "otc_active"
+CONF_CH2_ACTIVE = "ch2_active"
+CONF_SYNC_MODE = "sync_mode"
+
+opentherm_ns = cg.esphome_ns.namespace("opentherm")
+OpenthermHub = opentherm_ns.class_("OpenthermHub", cg.Component)
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(OpenthermHub),
+            cv.Required(CONF_IN_PIN): pins.internal_gpio_input_pin_schema,
+            cv.Required(CONF_OUT_PIN): pins.internal_gpio_output_pin_schema,
+            cv.Optional(CONF_CH_ENABLE, True): cv.boolean,
+            cv.Optional(CONF_DHW_ENABLE, True): cv.boolean,
+            cv.Optional(CONF_COOLING_ENABLE, False): cv.boolean,
+            cv.Optional(CONF_OTC_ACTIVE, False): cv.boolean,
+            cv.Optional(CONF_CH2_ACTIVE, False): cv.boolean,
+            cv.Optional(CONF_SYNC_MODE, False): cv.boolean,
+        }
+    ).extend(cv.COMPONENT_SCHEMA),
+    cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266]),
+)
+
+
+async def to_code(config: dict[str, Any]) -> None:
+    # Create the hub, passing the two callbacks defined below
+    # Since the hub is used in the callbacks, we need to define it first
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+
+    # Set pins
+    in_pin = await cg.gpio_pin_expression(config[CONF_IN_PIN])
+    cg.add(var.set_in_pin(in_pin))
+
+    out_pin = await cg.gpio_pin_expression(config[CONF_OUT_PIN])
+    cg.add(var.set_out_pin(out_pin))
+
+    non_sensors = {CONF_ID, CONF_IN_PIN, CONF_OUT_PIN}
+    for key, value in config.items():
+        if key not in non_sensors:
+            cg.add(getattr(var, f"set_{key}")(value))