sascha/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2025-10-30 14:43:51 +00:00
Code Issues Releases Wiki Activity

Merge branch 'entity_name_must_be_unique' into integration

Browse Source
This commit is contained in:
J. Nick Koston
2025-06-30 17:48:49 -05:00
parent 3cbce4df42 b7d0f5e36b
commit ae981ea7f2
29 changed files with 303 additions and 294 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
esphome/components/ethernet/__init__.py
View File

@@ -23,8 +23,10 @@ from esphome.const import (
CONF_INTERRUPT_PIN,
CONF_MANUAL_IP,
CONF_MISO_PIN,
CONF_MODE,
CONF_MOSI_PIN,
CONF_PAGE_ID,
CONF_PIN,
CONF_POLLING_INTERVAL,
CONF_RESET_PIN,
CONF_SPI,
@@ -49,6 +51,7 @@ PHYRegister = ethernet_ns.struct("PHYRegister")
CONF_PHY_ADDR = "phy_addr"
CONF_MDC_PIN = "mdc_pin"
CONF_MDIO_PIN = "mdio_pin"
CONF_CLK = "clk"
CONF_CLK_MODE = "clk_mode"
CONF_POWER_PIN = "power_pin"
CONF_PHY_REGISTERS = "phy_registers"
@@ -73,26 +76,18 @@ SPI_ETHERNET_TYPES = ["W5500", "DM9051"]
SPI_ETHERNET_DEFAULT_POLLING_INTERVAL = TimePeriodMilliseconds(milliseconds=10)
emac_rmii_clock_mode_t = cg.global_ns.enum("emac_rmii_clock_mode_t")
emac_rmii_clock_gpio_t = cg.global_ns.enum("emac_rmii_clock_gpio_t")
CLK_MODES = {
"GPIO0_IN": (
emac_rmii_clock_mode_t.EMAC_CLK_EXT_IN,
emac_rmii_clock_gpio_t.EMAC_CLK_IN_GPIO,
),
"GPIO0_OUT": (
emac_rmii_clock_mode_t.EMAC_CLK_OUT,
emac_rmii_clock_gpio_t.EMAC_APPL_CLK_OUT_GPIO,
),
"GPIO16_OUT": (
emac_rmii_clock_mode_t.EMAC_CLK_OUT,
emac_rmii_clock_gpio_t.EMAC_CLK_OUT_GPIO,
),
"GPIO17_OUT": (
emac_rmii_clock_mode_t.EMAC_CLK_OUT,
emac_rmii_clock_gpio_t.EMAC_CLK_OUT_180_GPIO,
),
"CLK_EXT_IN": emac_rmii_clock_mode_t.EMAC_CLK_EXT_IN,
"CLK_OUT": emac_rmii_clock_mode_t.EMAC_CLK_OUT,
}
CLK_MODES_DEPRECATED = {
"GPIO0_IN": ("CLK_EXT_IN", 0),
"GPIO0_OUT": ("CLK_OUT", 0),
"GPIO16_OUT": ("CLK_OUT", 16),
"GPIO17_OUT": ("CLK_OUT", 17),
}
MANUAL_IP_SCHEMA = cv.Schema(
{
@@ -154,6 +149,18 @@ def _validate(config):
f"({CORE.target_framework} {CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]}), "
f"'{CONF_INTERRUPT_PIN}' is a required option for [ethernet]."
)
elif config[CONF_TYPE] != "OPENETH":
if CONF_CLK_MODE in config:
LOGGER.warning(
"[ethernet] The 'clk_mode' option is deprecated and will be removed in ESPHome 2026.1. "
"Please update your configuration to use 'clk' instead."
)
mode = CLK_MODES_DEPRECATED[config[CONF_CLK_MODE]]
config[CONF_CLK] = CLK_SCHEMA({CONF_MODE: mode[0], CONF_PIN: mode[1]})
del config[CONF_CLK_MODE]
elif CONF_CLK not in config:
raise cv.Invalid("'clk' is a required option for [ethernet].")
return config
@@ -177,14 +184,21 @@ PHY_REGISTER_SCHEMA = cv.Schema(
cv.Optional(CONF_PAGE_ID): cv.hex_int,
}
)
CLK_SCHEMA = cv.Schema(
{
cv.Required(CONF_MODE): cv.enum(CLK_MODES, upper=True, space="_"),
cv.Required(CONF_PIN): pins.internal_gpio_pin_number,
}
)
RMII_SCHEMA = BASE_SCHEMA.extend(
cv.Schema(
{
cv.Required(CONF_MDC_PIN): pins.internal_gpio_output_pin_number,
cv.Required(CONF_MDIO_PIN): pins.internal_gpio_output_pin_number,
cv.Optional(CONF_CLK_MODE, default="GPIO0_IN"): cv.enum(
CLK_MODES, upper=True, space="_"
cv.Optional(CONF_CLK_MODE): cv.enum(
CLK_MODES_DEPRECATED, upper=True, space="_"
),
cv.Optional(CONF_CLK): CLK_SCHEMA,
cv.Optional(CONF_PHY_ADDR, default=0): cv.int_range(min=0, max=31),
cv.Optional(CONF_POWER_PIN): pins.internal_gpio_output_pin_number,
cv.Optional(CONF_PHY_REGISTERS): cv.ensure_list(PHY_REGISTER_SCHEMA),
@@ -308,7 +322,8 @@ async def to_code(config):
cg.add(var.set_phy_addr(config[CONF_PHY_ADDR]))
cg.add(var.set_mdc_pin(config[CONF_MDC_PIN]))
cg.add(var.set_mdio_pin(config[CONF_MDIO_PIN]))
cg.add(var.set_clk_mode(*CLK_MODES[config[CONF_CLK_MODE]]))
cg.add(var.set_clk_mode(config[CONF_CLK][CONF_MODE]))
cg.add(var.set_clk_pin(config[CONF_CLK][CONF_PIN]))
if CONF_POWER_PIN in config:
cg.add(var.set_power_pin(config[CONF_POWER_PIN]))
for register_value in config.get(CONF_PHY_REGISTERS, []):

41
esphome/components/ethernet/ethernet_component.cpp
View File

@@ -17,6 +17,22 @@
namespace esphome {
namespace ethernet {
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 4, 2)
// work around IDF compile issue on P4 https://github.com/espressif/esp-idf/pull/15637
#ifdef USE_ESP32_VARIANT_ESP32P4
#undef ETH_ESP32_EMAC_DEFAULT_CONFIG
#define ETH_ESP32_EMAC_DEFAULT_CONFIG() \
{ \
.smi_gpio = {.mdc_num = 31, .mdio_num = 52}, .interface = EMAC_DATA_INTERFACE_RMII, \
.clock_config = {.rmii = {.clock_mode = EMAC_CLK_EXT_IN, .clock_gpio = (emac_rmii_clock_gpio_t) 50}}, \
.dma_burst_len = ETH_DMA_BURST_LEN_32, .intr_priority = 0, \
.emac_dataif_gpio = \
{.rmii = {.tx_en_num = 49, .txd0_num = 34, .txd1_num = 35, .crs_dv_num = 28, .rxd0_num = 29, .rxd1_num = 30}}, \
.clock_config_out_in = {.rmii = {.clock_mode = EMAC_CLK_EXT_IN, .clock_gpio = (emac_rmii_clock_gpio_t) -1}}, \
}
#endif
#endif
static const char *const TAG = "ethernet";
EthernetComponent *global_eth_component; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -150,22 +166,18 @@ void EthernetComponent::setup() {
phy_config.phy_addr = this->phy_addr_;
phy_config.reset_gpio_num = this->power_pin_;
#if ESP_IDF_VERSION_MAJOR >= 5
eth_esp32_emac_config_t esp32_emac_config = ETH_ESP32_EMAC_DEFAULT_CONFIG();
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
esp32_emac_config.smi_gpio.mdc_num = this->mdc_pin_;
esp32_emac_config.smi_gpio.mdio_num = this->mdio_pin_;
#else
esp32_emac_config.smi_mdc_gpio_num = this->mdc_pin_;
esp32_emac_config.smi_mdio_gpio_num = this->mdio_pin_;
#endif
esp32_emac_config.clock_config.rmii.clock_mode = this->clk_mode_;
esp32_emac_config.clock_config.rmii.clock_gpio = this->clk_gpio_;
esp32_emac_config.clock_config.rmii.clock_gpio = (emac_rmii_clock_gpio_t) this->clk_pin_;
esp_eth_mac_t *mac = esp_eth_mac_new_esp32(&esp32_emac_config, &mac_config);
#else
mac_config.smi_mdc_gpio_num = this->mdc_pin_;
mac_config.smi_mdio_gpio_num = this->mdio_pin_;
mac_config.clock_config.rmii.clock_mode = this->clk_mode_;
mac_config.clock_config.rmii.clock_gpio = this->clk_gpio_;
esp_eth_mac_t *mac = esp_eth_mac_new_esp32(&mac_config);
#endif
#endif
switch (this->type_) {
@@ -387,10 +399,11 @@ void EthernetComponent::dump_config() {
ESP_LOGCONFIG(TAG, " Power Pin: %u", this->power_pin_);
}
ESP_LOGCONFIG(TAG,
" CLK Pin: %u\n"
" MDC Pin: %u\n"
" MDIO Pin: %u\n"
" PHY addr: %u",
this->mdc_pin_, this->mdio_pin_, this->phy_addr_);
this->clk_pin_, this->mdc_pin_, this->mdio_pin_, this->phy_addr_);
#endif
ESP_LOGCONFIG(TAG, " Type: %s", eth_type);
}
@@ -611,10 +624,8 @@ void EthernetComponent::set_phy_addr(uint8_t phy_addr) { this->phy_addr_ = phy_a
void EthernetComponent::set_power_pin(int power_pin) { this->power_pin_ = power_pin; }
void EthernetComponent::set_mdc_pin(uint8_t mdc_pin) { this->mdc_pin_ = mdc_pin; }
void EthernetComponent::set_mdio_pin(uint8_t mdio_pin) { this->mdio_pin_ = mdio_pin; }
void EthernetComponent::set_clk_mode(emac_rmii_clock_mode_t clk_mode, emac_rmii_clock_gpio_t clk_gpio) {
this->clk_mode_ = clk_mode;
this->clk_gpio_ = clk_gpio;
}
void EthernetComponent::set_clk_pin(uint8_t clk_pin) { this->clk_pin_ = clk_pin; }
void EthernetComponent::set_clk_mode(emac_rmii_clock_mode_t clk_mode) { this->clk_mode_ = clk_mode; }
void EthernetComponent::add_phy_register(PHYRegister register_value) { this->phy_registers_.push_back(register_value); }
#endif
void EthernetComponent::set_type(EthernetType type) { this->type_ = type; }

5
esphome/components/ethernet/ethernet_component.h
View File

@@ -76,7 +76,8 @@ class EthernetComponent : public Component {
void set_power_pin(int power_pin);
void set_mdc_pin(uint8_t mdc_pin);
void set_mdio_pin(uint8_t mdio_pin);
void set_clk_mode(emac_rmii_clock_mode_t clk_mode, emac_rmii_clock_gpio_t clk_gpio);
void set_clk_pin(uint8_t clk_pin);
void set_clk_mode(emac_rmii_clock_mode_t clk_mode);
void add_phy_register(PHYRegister register_value);
#endif
void set_type(EthernetType type);
@@ -123,10 +124,10 @@ class EthernetComponent : public Component {
// Group all 32-bit members first
int power_pin_{-1};
emac_rmii_clock_mode_t clk_mode_{EMAC_CLK_EXT_IN};
emac_rmii_clock_gpio_t clk_gpio_{EMAC_CLK_IN_GPIO};
std::vector<PHYRegister> phy_registers_{};
// Group all 8-bit members together
uint8_t clk_pin_{0};
uint8_t phy_addr_{0};
uint8_t mdc_pin_{23};
uint8_t mdio_pin_{18};

2
esphome/components/http_request/update/http_request_update.cpp
View File

@@ -57,7 +57,7 @@ void HttpRequestUpdate::update_task(void *params) {
RAMAllocator<uint8_t> allocator;
uint8_t *data = allocator.allocate(container->content_length);
if (data == nullptr) {
std::string msg = str_sprintf("Failed to allocate %d bytes for manifest", container->content_length);
std::string msg = str_sprintf("Failed to allocate %zu bytes for manifest", container->content_length);
this_update->status_set_error(msg.c_str());
container->end();
UPDATE_RETURN;

11
esphome/components/i2c/__init__.py
View File

@@ -9,8 +9,6 @@ from esphome.const import (
CONF_FREQUENCY,
CONF_I2C_ID,
CONF_ID,
CONF_INPUT,
CONF_OUTPUT,
CONF_SCAN,
CONF_SCL,
CONF_SDA,
@@ -73,20 +71,15 @@ def validate_config(config):
return config
pin_with_input_and_output_support = pins.internal_gpio_pin_number(
{CONF_OUTPUT: True, CONF_INPUT: True}
)
CONFIG_SCHEMA = cv.All(
cv.Schema(
{
cv.GenerateID(): _bus_declare_type,
cv.Optional(CONF_SDA, default="SDA"): pin_with_input_and_output_support,
cv.Optional(CONF_SDA, default="SDA"): pins.internal_gpio_pin_number,
cv.SplitDefault(CONF_SDA_PULLUP_ENABLED, esp32_idf=True): cv.All(
cv.only_with_esp_idf, cv.boolean
),
cv.Optional(CONF_SCL, default="SCL"): pin_with_input_and_output_support,
cv.Optional(CONF_SCL, default="SCL"): pins.internal_gpio_pin_number,
cv.SplitDefault(CONF_SCL_PULLUP_ENABLED, esp32_idf=True): cv.All(
cv.only_with_esp_idf, cv.boolean
),

8
esphome/components/mqtt/mqtt_backend_esp32.cpp
View File

@@ -163,12 +163,20 @@ void MQTTBackendESP32::mqtt_event_handler_(const Event &event) {
case MQTT_EVENT_CONNECTED:
ESP_LOGV(TAG, "MQTT_EVENT_CONNECTED");
this->is_connected_ = true;
#if defined(USE_MQTT_IDF_ENQUEUE)
this->last_dropped_log_time_ = 0;
xTaskNotifyGive(this->task_handle_);
#endif
this->on_connect_.call(event.session_present);
break;
case MQTT_EVENT_DISCONNECTED:
ESP_LOGV(TAG, "MQTT_EVENT_DISCONNECTED");
// TODO is there a way to get the disconnect reason?
this->is_connected_ = false;
#if defined(USE_MQTT_IDF_ENQUEUE)
this->last_dropped_log_time_ = 0;
xTaskNotifyGive(this->task_handle_);
#endif
this->on_disconnect_.call(MQTTClientDisconnectReason::TCP_DISCONNECTED);
break;

2
esphome/components/mqtt/mqtt_backend_esp32.h
View File

@@ -116,7 +116,7 @@ struct QueueElement {
class MQTTBackendESP32 final : public MQTTBackend {
public:
static const size_t MQTT_BUFFER_SIZE = 4096;
static const size_t TASK_STACK_SIZE = 2048;
static const size_t TASK_STACK_SIZE = 3072;
static const size_t TASK_STACK_SIZE_TLS = 4096; // Larger stack for TLS operations
static const ssize_t TASK_PRIORITY = 5;
static const uint8_t MQTT_QUEUE_LENGTH = 30; // 30*12 bytes = 360

72
esphome/components/openthread/__init__.py
View File

@@ -22,7 +22,6 @@ from .const import (
CONF_SRP_ID,
CONF_TLV,
)
from .tlv import parse_tlv
CODEOWNERS = ["@mrene"]
@@ -43,29 +42,40 @@ def set_sdkconfig_options(config):
add_idf_sdkconfig_option("CONFIG_OPENTHREAD_CLI", False)
add_idf_sdkconfig_option("CONFIG_OPENTHREAD_ENABLED", True)
add_idf_sdkconfig_option("CONFIG_OPENTHREAD_NETWORK_PANID", config[CONF_PAN_ID])
add_idf_sdkconfig_option("CONFIG_OPENTHREAD_NETWORK_CHANNEL", config[CONF_CHANNEL])
add_idf_sdkconfig_option(
"CONFIG_OPENTHREAD_NETWORK_MASTERKEY", f"{config[CONF_NETWORK_KEY]:X}".lower()
)
if network_name := config.get(CONF_NETWORK_NAME):
add_idf_sdkconfig_option("CONFIG_OPENTHREAD_NETWORK_NAME", network_name)
if tlv := config.get(CONF_TLV):
cg.add_define("USE_OPENTHREAD_TLVS", tlv)
else:
if pan_id := config.get(CONF_PAN_ID):
add_idf_sdkconfig_option("CONFIG_OPENTHREAD_NETWORK_PANID", pan_id)
if (ext_pan_id := config.get(CONF_EXT_PAN_ID)) is not None:
add_idf_sdkconfig_option(
"CONFIG_OPENTHREAD_NETWORK_EXTPANID", f"{ext_pan_id:X}".lower()
)
if (mesh_local_prefix := config.get(CONF_MESH_LOCAL_PREFIX)) is not None:
add_idf_sdkconfig_option(
"CONFIG_OPENTHREAD_MESH_LOCAL_PREFIX", f"{mesh_local_prefix}".lower()
)
if (pskc := config.get(CONF_PSKC)) is not None:
add_idf_sdkconfig_option("CONFIG_OPENTHREAD_NETWORK_PSKC", f"{pskc:X}".lower())
if channel := config.get(CONF_CHANNEL):
add_idf_sdkconfig_option("CONFIG_OPENTHREAD_NETWORK_CHANNEL", channel)
if CONF_FORCE_DATASET in config:
if config[CONF_FORCE_DATASET]:
cg.add_define("CONFIG_OPENTHREAD_FORCE_DATASET")
if network_key := config.get(CONF_NETWORK_KEY):
add_idf_sdkconfig_option(
"CONFIG_OPENTHREAD_NETWORK_MASTERKEY", f"{network_key:X}".lower()
)
if network_name := config.get(CONF_NETWORK_NAME):
add_idf_sdkconfig_option("CONFIG_OPENTHREAD_NETWORK_NAME", network_name)
if (ext_pan_id := config.get(CONF_EXT_PAN_ID)) is not None:
add_idf_sdkconfig_option(
"CONFIG_OPENTHREAD_NETWORK_EXTPANID", f"{ext_pan_id:X}".lower()
)
if (mesh_local_prefix := config.get(CONF_MESH_LOCAL_PREFIX)) is not None:
add_idf_sdkconfig_option(
"CONFIG_OPENTHREAD_MESH_LOCAL_PREFIX", f"{mesh_local_prefix}".lower()
)
if (pskc := config.get(CONF_PSKC)) is not None:
add_idf_sdkconfig_option(
"CONFIG_OPENTHREAD_NETWORK_PSKC", f"{pskc:X}".lower()
)
if force_dataset := config.get(CONF_FORCE_DATASET):
if force_dataset:
cg.add_define("USE_OPENTHREAD_FORCE_DATASET")
add_idf_sdkconfig_option("CONFIG_OPENTHREAD_DNS64_CLIENT", True)
add_idf_sdkconfig_option("CONFIG_OPENTHREAD_SRP_CLIENT", True)
@@ -79,22 +89,11 @@ openthread_ns = cg.esphome_ns.namespace("openthread")
OpenThreadComponent = openthread_ns.class_("OpenThreadComponent", cg.Component)
OpenThreadSrpComponent = openthread_ns.class_("OpenThreadSrpComponent", cg.Component)
def _convert_tlv(config):
if tlv := config.get(CONF_TLV):
config = config.copy()
parsed_tlv = parse_tlv(tlv)
validated = _CONNECTION_SCHEMA(parsed_tlv)
config.update(validated)
del config[CONF_TLV]
return config
_CONNECTION_SCHEMA = cv.Schema(
{
cv.Inclusive(CONF_PAN_ID, "manual"): cv.hex_int,
cv.Inclusive(CONF_CHANNEL, "manual"): cv.int_,
cv.Inclusive(CONF_NETWORK_KEY, "manual"): cv.hex_int,
cv.Optional(CONF_PAN_ID): cv.hex_int,
cv.Optional(CONF_CHANNEL): cv.int_,
cv.Optional(CONF_NETWORK_KEY): cv.hex_int,
cv.Optional(CONF_EXT_PAN_ID): cv.hex_int,
cv.Optional(CONF_NETWORK_NAME): cv.string_strict,
cv.Optional(CONF_PSKC): cv.hex_int,
@@ -112,8 +111,7 @@ CONFIG_SCHEMA = cv.All(
cv.Optional(CONF_TLV): cv.string_strict,
}
).extend(_CONNECTION_SCHEMA),
cv.has_exactly_one_key(CONF_PAN_ID, CONF_TLV),
_convert_tlv,
cv.has_exactly_one_key(CONF_NETWORK_KEY, CONF_TLV),
cv.only_with_esp_idf,
only_on_variant(supported=[VARIANT_ESP32C6, VARIANT_ESP32H2]),
)

32
esphome/components/openthread/openthread_esp.cpp
View File

@@ -111,14 +111,36 @@ void OpenThreadComponent::ot_main() {
esp_openthread_cli_create_task();
#endif
ESP_LOGI(TAG, "Activating dataset...");
otOperationalDatasetTlvs dataset;
otOperationalDatasetTlvs dataset = {};
#ifdef CONFIG_OPENTHREAD_FORCE_DATASET
ESP_ERROR_CHECK(esp_openthread_auto_start(NULL));
#else
#ifndef USE_OPENTHREAD_FORCE_DATASET
// Check if openthread has a valid dataset from a previous execution
otError error = otDatasetGetActiveTlvs(esp_openthread_get_instance(), &dataset);
ESP_ERROR_CHECK(esp_openthread_auto_start((error == OT_ERROR_NONE) ? &dataset : NULL));
if (error != OT_ERROR_NONE) {
// Make sure the length is 0 so we fallback to the configuration
dataset.mLength = 0;
} else {
ESP_LOGI(TAG, "Found OpenThread-managed dataset, ignoring esphome configuration");
ESP_LOGI(TAG, "(set force_dataset: true to override)");
}
#endif
#ifdef USE_OPENTHREAD_TLVS
if (dataset.mLength == 0) {
// If we didn't have an active dataset, and we have tlvs, parse it and pass it to esp_openthread_auto_start
size_t len = (sizeof(USE_OPENTHREAD_TLVS) - 1) / 2;
if (len > sizeof(dataset.mTlvs)) {
ESP_LOGW(TAG, "TLV buffer too small, truncating");
len = sizeof(dataset.mTlvs);
}
parse_hex(USE_OPENTHREAD_TLVS, sizeof(USE_OPENTHREAD_TLVS) - 1, dataset.mTlvs, len);
dataset.mLength = len;
}
#endif
// Pass the existing dataset, or NULL which will use the preprocessor definitions
ESP_ERROR_CHECK(esp_openthread_auto_start(dataset.mLength > 0 ? &dataset : nullptr));
esp_openthread_launch_mainloop();
// Clean up

65
esphome/components/openthread/tlv.py
View File

@@ -1,65 +0,0 @@
# Sourced from https://gist.github.com/agners/0338576e0003318b63ec1ea75adc90f9
import binascii
import ipaddress
from esphome.const import CONF_CHANNEL
from . import (
CONF_EXT_PAN_ID,
CONF_MESH_LOCAL_PREFIX,
CONF_NETWORK_KEY,
CONF_NETWORK_NAME,
CONF_PAN_ID,
CONF_PSKC,
)
TLV_TYPES = {
0: CONF_CHANNEL,
1: CONF_PAN_ID,
2: CONF_EXT_PAN_ID,
3: CONF_NETWORK_NAME,
4: CONF_PSKC,
5: CONF_NETWORK_KEY,
7: CONF_MESH_LOCAL_PREFIX,
}
def parse_tlv(tlv) -> dict:
data = binascii.a2b_hex(tlv)
output = {}
pos = 0
while pos < len(data):
tag = data[pos]
pos += 1
_len = data[pos]
pos += 1
val = data[pos : pos + _len]
pos += _len
if tag in TLV_TYPES:
if tag == 3:
output[TLV_TYPES[tag]] = val.decode("utf-8")
elif tag == 7:
mesh_local_prefix = binascii.hexlify(val).decode("utf-8")
mesh_local_prefix_str = f"{mesh_local_prefix}0000000000000000"
ipv6_bytes = bytes.fromhex(mesh_local_prefix_str)
ipv6_address = ipaddress.IPv6Address(ipv6_bytes)
output[TLV_TYPES[tag]] = f"{ipv6_address}/64"
else:
output[TLV_TYPES[tag]] = int.from_bytes(val)
return output
def main():
import sys
args = sys.argv[1:]
parsed = parse_tlv(args[0])
# print the parsed TLV data
for key, value in parsed.items():
if isinstance(value, bytes):
value = value.hex()
print(f"{key}: {value}")
if __name__ == "__main__":
main()

12
esphome/components/smt100/sensor.py
View File

@@ -6,6 +6,7 @@ from esphome.const import (
CONF_DIELECTRIC_CONSTANT,
CONF_ID,
CONF_MOISTURE,
CONF_PERMITTIVITY,
CONF_TEMPERATURE,
CONF_VOLTAGE,
DEVICE_CLASS_TEMPERATURE,
@@ -33,7 +34,10 @@ CONFIG_SCHEMA = (
accuracy_decimals=0,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_DIELECTRIC_CONSTANT): sensor.sensor_schema(
cv.Optional(CONF_DIELECTRIC_CONSTANT): cv.invalid(
"Use 'permittivity' instead"
),
cv.Optional(CONF_PERMITTIVITY): sensor.sensor_schema(
unit_of_measurement=UNIT_EMPTY,
accuracy_decimals=2,
state_class=STATE_CLASS_MEASUREMENT,
@@ -76,9 +80,9 @@ async def to_code(config):
sens = await sensor.new_sensor(config[CONF_COUNTS])
cg.add(var.set_counts_sensor(sens))
if CONF_DIELECTRIC_CONSTANT in config:
sens = await sensor.new_sensor(config[CONF_DIELECTRIC_CONSTANT])
cg.add(var.set_dielectric_constant_sensor(sens))
if CONF_PERMITTIVITY in config:
sens = await sensor.new_sensor(config[CONF_PERMITTIVITY])
cg.add(var.set_permittivity_sensor(sens))
if CONF_TEMPERATURE in config:
sens = await sensor.new_sensor(config[CONF_TEMPERATURE])

10
esphome/components/smt100/smt100.cpp
View File

@@ -16,7 +16,7 @@ void SMT100Component::loop() {
while (this->available() != 0) {
if (readline_(read(), buffer, MAX_LINE_LENGTH) > 0) {
int counts = (int) strtol((strtok(buffer, ",")), nullptr, 10);
float dielectric_constant = (float) strtod((strtok(nullptr, ",")), nullptr);
float permittivity = (float) strtod((strtok(nullptr, ",")), nullptr);
float moisture = (float) strtod((strtok(nullptr, ",")), nullptr);
float temperature = (float) strtod((strtok(nullptr, ",")), nullptr);
float voltage = (float) strtod((strtok(nullptr, ",")), nullptr);
@@ -25,8 +25,8 @@ void SMT100Component::loop() {
counts_sensor_->publish_state(counts);
}
if (this->dielectric_constant_sensor_ != nullptr) {
dielectric_constant_sensor_->publish_state(dielectric_constant);
if (this->permittivity_sensor_ != nullptr) {
permittivity_sensor_->publish_state(permittivity);
}
if (this->moisture_sensor_ != nullptr) {
@@ -49,8 +49,8 @@ float SMT100Component::get_setup_priority() const { return setup_priority::DATA;
void SMT100Component::dump_config() {
ESP_LOGCONFIG(TAG, "SMT100:");
LOG_SENSOR(TAG, "Counts", this->temperature_sensor_);
LOG_SENSOR(TAG, "Dielectric Constant", this->temperature_sensor_);
LOG_SENSOR(TAG, "Counts", this->counts_sensor_);
LOG_SENSOR(TAG, "Permittivity", this->permittivity_sensor_);
LOG_SENSOR(TAG, "Temperature", this->temperature_sensor_);
LOG_SENSOR(TAG, "Moisture", this->moisture_sensor_);
LOG_UPDATE_INTERVAL(this);

6
esphome/components/smt100/smt100.h
View File

@@ -20,8 +20,8 @@ class SMT100Component : public PollingComponent, public uart::UARTDevice {
float get_setup_priority() const override;
void set_counts_sensor(sensor::Sensor *counts_sensor) { this->counts_sensor_ = counts_sensor; }
void set_dielectric_constant_sensor(sensor::Sensor *dielectric_constant_sensor) {
this->dielectric_constant_sensor_ = dielectric_constant_sensor;
void set_permittivity_sensor(sensor::Sensor *permittivity_sensor) {
this->permittivity_sensor_ = permittivity_sensor;
}
void set_temperature_sensor(sensor::Sensor *temperature_sensor) { this->temperature_sensor_ = temperature_sensor; }
void set_moisture_sensor(sensor::Sensor *moisture_sensor) { this->moisture_sensor_ = moisture_sensor; }
@@ -31,7 +31,7 @@ class SMT100Component : public PollingComponent, public uart::UARTDevice {
int readline_(int readch, char *buffer, int len);
sensor::Sensor *counts_sensor_{nullptr};
sensor::Sensor *dielectric_constant_sensor_{nullptr};
sensor::Sensor *permittivity_sensor_{nullptr};
sensor::Sensor *moisture_sensor_{nullptr};
sensor::Sensor *temperature_sensor_{nullptr};
sensor::Sensor *voltage_sensor_{nullptr};

1
esphome/const.py
View File

@@ -654,6 +654,7 @@ CONF_PAYLOAD = "payload"
CONF_PAYLOAD_AVAILABLE = "payload_available"
CONF_PAYLOAD_NOT_AVAILABLE = "payload_not_available"
CONF_PERIOD = "period"
CONF_PERMITTIVITY = "permittivity"
CONF_PH = "ph"
CONF_PHASE_A = "phase_a"
CONF_PHASE_ANGLE = "phase_angle"

15
esphome/core/entity_helpers.py
View File

@@ -184,25 +184,18 @@ def entity_duplicate_validator(platform: str) -> Callable[[ConfigType], ConfigTy
# No name to validate
return config
# Get the entity name and device info
# Get the entity name
entity_name = config[CONF_NAME]
device_id = "" # Empty string for main device
if CONF_DEVICE_ID in config:
device_id_obj = config[CONF_DEVICE_ID]
# Use the device ID string directly for uniqueness
device_id = device_id_obj.id
# For duplicate detection, just use the sanitized name
name_key = sanitize(snake_case(entity_name))
# Check for duplicates
unique_key = (device_id, platform, name_key)
unique_key = (platform, name_key)
if unique_key in CORE.unique_ids:
device_prefix = f" on device '{device_id}'" if device_id else ""
raise cv.Invalid(
f"Duplicate {platform} entity with name '{entity_name}' found{device_prefix}. "
f"Each entity on a device must have a unique name within its platform."
f"Duplicate {platform} entity with name '{entity_name}' found. "
f"Each entity must have a unique name within its platform across all devices."
)
# Add to tracking set

4
esphome/pins.py
View File

@@ -220,7 +220,9 @@ def gpio_flags_expr(mode):
gpio_pin_schema = _schema_creator
internal_gpio_pin_number = _internal_number_creator
internal_gpio_pin_number = _internal_number_creator(
{CONF_OUTPUT: True, CONF_INPUT: True}
)
gpio_output_pin_schema = _schema_creator(
{
CONF_OUTPUT: True,