mirror of
https://github.com/esphome/esphome.git
synced 2024-11-09 16:57:47 +01:00
Add configuration flow abilites to the ld2410 component (#4434)
This commit is contained in:
parent
87629191b3
commit
5cb5594288
35 changed files with 1621 additions and 327 deletions
|
@ -144,7 +144,7 @@ esphome/components/key_collector/* @ssieb
|
|||
esphome/components/key_provider/* @ssieb
|
||||
esphome/components/kuntze/* @ssieb
|
||||
esphome/components/lcd_menu/* @numo68
|
||||
esphome/components/ld2410/* @sebcaps
|
||||
esphome/components/ld2410/* @regevbr @sebcaps
|
||||
esphome/components/ledc/* @OttoWinter
|
||||
esphome/components/light/* @esphome/core
|
||||
esphome/components/lilygo_t5_47/touchscreen/* @jesserockz
|
||||
|
|
|
@ -1,113 +1,64 @@
|
|||
import esphome.codegen as cg
|
||||
import esphome.config_validation as cv
|
||||
from esphome.components import uart
|
||||
from esphome.const import CONF_ID, CONF_TIMEOUT
|
||||
from esphome.const import CONF_ID, CONF_THROTTLE, CONF_TIMEOUT, CONF_PASSWORD
|
||||
from esphome import automation
|
||||
from esphome.automation import maybe_simple_id
|
||||
|
||||
DEPENDENCIES = ["uart"]
|
||||
CODEOWNERS = ["@sebcaps"]
|
||||
CODEOWNERS = ["@sebcaps", "@regevbr"]
|
||||
MULTI_CONF = True
|
||||
|
||||
ld2410_ns = cg.esphome_ns.namespace("ld2410")
|
||||
LD2410Component = ld2410_ns.class_("LD2410Component", cg.Component, uart.UARTDevice)
|
||||
LD2410Restart = ld2410_ns.class_("LD2410Restart", automation.Action)
|
||||
|
||||
CONF_LD2410_ID = "ld2410_id"
|
||||
|
||||
CONF_MAX_MOVE_DISTANCE = "max_move_distance"
|
||||
CONF_MAX_STILL_DISTANCE = "max_still_distance"
|
||||
CONF_G0_MOVE_THRESHOLD = "g0_move_threshold"
|
||||
CONF_G0_STILL_THRESHOLD = "g0_still_threshold"
|
||||
CONF_G1_MOVE_THRESHOLD = "g1_move_threshold"
|
||||
CONF_G1_STILL_THRESHOLD = "g1_still_threshold"
|
||||
CONF_G2_MOVE_THRESHOLD = "g2_move_threshold"
|
||||
CONF_G2_STILL_THRESHOLD = "g2_still_threshold"
|
||||
CONF_G3_MOVE_THRESHOLD = "g3_move_threshold"
|
||||
CONF_G3_STILL_THRESHOLD = "g3_still_threshold"
|
||||
CONF_G4_MOVE_THRESHOLD = "g4_move_threshold"
|
||||
CONF_G4_STILL_THRESHOLD = "g4_still_threshold"
|
||||
CONF_G5_MOVE_THRESHOLD = "g5_move_threshold"
|
||||
CONF_G5_STILL_THRESHOLD = "g5_still_threshold"
|
||||
CONF_G6_MOVE_THRESHOLD = "g6_move_threshold"
|
||||
CONF_G6_STILL_THRESHOLD = "g6_still_threshold"
|
||||
CONF_G7_MOVE_THRESHOLD = "g7_move_threshold"
|
||||
CONF_G7_STILL_THRESHOLD = "g7_still_threshold"
|
||||
CONF_G8_MOVE_THRESHOLD = "g8_move_threshold"
|
||||
CONF_G8_STILL_THRESHOLD = "g8_still_threshold"
|
||||
CONF_STILL_THRESHOLDS = [f"g{x}_still_threshold" for x in range(9)]
|
||||
CONF_MOVE_THRESHOLDS = [f"g{x}_move_threshold" for x in range(9)]
|
||||
|
||||
DISTANCES = [0.75, 1.5, 2.25, 3, 3.75, 4.5, 5.25, 6]
|
||||
CONFIG_SCHEMA = cv.Schema(
|
||||
{
|
||||
cv.GenerateID(): cv.declare_id(LD2410Component),
|
||||
cv.Optional(CONF_THROTTLE, default="1000ms"): cv.All(
|
||||
cv.positive_time_period_milliseconds,
|
||||
cv.Range(min=cv.TimePeriod(milliseconds=1)),
|
||||
),
|
||||
cv.Optional(CONF_MAX_MOVE_DISTANCE): cv.invalid(
|
||||
f"The '{CONF_MAX_MOVE_DISTANCE}' option has been moved to the '{CONF_MAX_MOVE_DISTANCE}'"
|
||||
f" number component"
|
||||
),
|
||||
cv.Optional(CONF_MAX_STILL_DISTANCE): cv.invalid(
|
||||
f"The '{CONF_MAX_STILL_DISTANCE}' option has been moved to the '{CONF_MAX_STILL_DISTANCE}'"
|
||||
f" number component"
|
||||
),
|
||||
cv.Optional(CONF_TIMEOUT): cv.invalid(
|
||||
f"The '{CONF_TIMEOUT}' option has been moved to the '{CONF_TIMEOUT}'"
|
||||
f" number component"
|
||||
),
|
||||
}
|
||||
)
|
||||
|
||||
for i in range(9):
|
||||
CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
|
||||
cv.Schema(
|
||||
{
|
||||
cv.Optional(CONF_MOVE_THRESHOLDS[i]): cv.invalid(
|
||||
f"The '{CONF_MOVE_THRESHOLDS[i]}' option has been moved to the '{CONF_MOVE_THRESHOLDS[i]}'"
|
||||
f" number component"
|
||||
),
|
||||
cv.Optional(CONF_STILL_THRESHOLDS[i]): cv.invalid(
|
||||
f"The '{CONF_STILL_THRESHOLDS[i]}' option has been moved to the '{CONF_STILL_THRESHOLDS[i]}'"
|
||||
f" number component"
|
||||
),
|
||||
}
|
||||
)
|
||||
)
|
||||
|
||||
CONFIG_SCHEMA = cv.All(
|
||||
cv.Schema(
|
||||
{
|
||||
cv.GenerateID(): cv.declare_id(LD2410Component),
|
||||
cv.Optional(CONF_MAX_MOVE_DISTANCE, default="4.5m"): cv.All(
|
||||
cv.distance, cv.one_of(*DISTANCES, float=True)
|
||||
),
|
||||
cv.Optional(CONF_MAX_STILL_DISTANCE, default="4.5m"): cv.All(
|
||||
cv.distance, cv.one_of(*DISTANCES, float=True)
|
||||
),
|
||||
cv.Optional(CONF_TIMEOUT, default="5s"): cv.All(
|
||||
cv.positive_time_period_seconds,
|
||||
cv.Range(max=cv.TimePeriod(seconds=32767)),
|
||||
),
|
||||
cv.Optional(CONF_G0_MOVE_THRESHOLD, default=50): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G0_STILL_THRESHOLD, default=0): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G1_MOVE_THRESHOLD, default=50): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G1_STILL_THRESHOLD, default=0): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G2_MOVE_THRESHOLD, default=40): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G2_STILL_THRESHOLD, default=40): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G3_MOVE_THRESHOLD, default=40): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G3_STILL_THRESHOLD, default=40): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G4_MOVE_THRESHOLD, default=40): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G4_STILL_THRESHOLD, default=40): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G5_MOVE_THRESHOLD, default=40): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G5_STILL_THRESHOLD, default=40): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G6_MOVE_THRESHOLD, default=30): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G6_STILL_THRESHOLD, default=15): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G7_MOVE_THRESHOLD, default=30): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G7_STILL_THRESHOLD, default=15): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G8_MOVE_THRESHOLD, default=30): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
cv.Optional(CONF_G8_STILL_THRESHOLD, default=15): cv.int_range(
|
||||
min=0, max=100
|
||||
),
|
||||
}
|
||||
)
|
||||
.extend(uart.UART_DEVICE_SCHEMA)
|
||||
.extend(cv.COMPONENT_SCHEMA)
|
||||
CONFIG_SCHEMA.extend(uart.UART_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA)
|
||||
)
|
||||
|
||||
FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
|
||||
|
@ -123,31 +74,7 @@ async def to_code(config):
|
|||
var = cg.new_Pvariable(config[CONF_ID])
|
||||
await cg.register_component(var, config)
|
||||
await uart.register_uart_device(var, config)
|
||||
cg.add(var.set_timeout(config[CONF_TIMEOUT]))
|
||||
cg.add(var.set_max_move_distance(int(config[CONF_MAX_MOVE_DISTANCE] / 0.75)))
|
||||
cg.add(var.set_max_still_distance(int(config[CONF_MAX_STILL_DISTANCE] / 0.75)))
|
||||
cg.add(
|
||||
var.set_range_config(
|
||||
config[CONF_G0_MOVE_THRESHOLD],
|
||||
config[CONF_G0_STILL_THRESHOLD],
|
||||
config[CONF_G1_MOVE_THRESHOLD],
|
||||
config[CONF_G1_STILL_THRESHOLD],
|
||||
config[CONF_G2_MOVE_THRESHOLD],
|
||||
config[CONF_G2_STILL_THRESHOLD],
|
||||
config[CONF_G3_MOVE_THRESHOLD],
|
||||
config[CONF_G3_STILL_THRESHOLD],
|
||||
config[CONF_G4_MOVE_THRESHOLD],
|
||||
config[CONF_G4_STILL_THRESHOLD],
|
||||
config[CONF_G5_MOVE_THRESHOLD],
|
||||
config[CONF_G5_STILL_THRESHOLD],
|
||||
config[CONF_G6_MOVE_THRESHOLD],
|
||||
config[CONF_G6_STILL_THRESHOLD],
|
||||
config[CONF_G7_MOVE_THRESHOLD],
|
||||
config[CONF_G7_STILL_THRESHOLD],
|
||||
config[CONF_G8_MOVE_THRESHOLD],
|
||||
config[CONF_G8_STILL_THRESHOLD],
|
||||
)
|
||||
)
|
||||
cg.add(var.set_throttle(config[CONF_THROTTLE]))
|
||||
|
||||
|
||||
CALIBRATION_ACTION_SCHEMA = maybe_simple_id(
|
||||
|
@ -155,3 +82,28 @@ CALIBRATION_ACTION_SCHEMA = maybe_simple_id(
|
|||
cv.Required(CONF_ID): cv.use_id(LD2410Component),
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
# Actions
|
||||
BluetoothPasswordSetAction = ld2410_ns.class_(
|
||||
"BluetoothPasswordSetAction", automation.Action
|
||||
)
|
||||
|
||||
|
||||
BLUETOOTH_PASSWORD_SET_SCHEMA = cv.Schema(
|
||||
{
|
||||
cv.Required(CONF_ID): cv.use_id(LD2410Component),
|
||||
cv.Required(CONF_PASSWORD): cv.templatable(cv.string_strict),
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@automation.register_action(
|
||||
"bluetooth_password.set", BluetoothPasswordSetAction, BLUETOOTH_PASSWORD_SET_SCHEMA
|
||||
)
|
||||
async def bluetooth_password_set_to_code(config, action_id, template_arg, args):
|
||||
paren = await cg.get_variable(config[CONF_ID])
|
||||
var = cg.new_Pvariable(action_id, template_arg, paren)
|
||||
template_ = await cg.templatable(config[CONF_PASSWORD], args, cg.std_string)
|
||||
cg.add(var.set_password(template_))
|
||||
return var
|
||||
|
|
22
esphome/components/ld2410/automation.h
Normal file
22
esphome/components/ld2410/automation.h
Normal file
|
@ -0,0 +1,22 @@
|
|||
#pragma once
|
||||
|
||||
#include "esphome/core/automation.h"
|
||||
#include "esphome/core/component.h"
|
||||
#include "ld2410.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
template<typename... Ts> class BluetoothPasswordSetAction : public Action<Ts...> {
|
||||
public:
|
||||
explicit BluetoothPasswordSetAction(LD2410Component *ld2410_comp) : ld2410_comp_(ld2410_comp) {}
|
||||
TEMPLATABLE_VALUE(std::string, password)
|
||||
|
||||
void play(Ts... x) override { this->ld2410_comp_->set_bluetooth_password(this->password_.value(x...)); }
|
||||
|
||||
protected:
|
||||
LD2410Component *ld2410_comp_;
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
|
@ -1,36 +1,55 @@
|
|||
import esphome.codegen as cg
|
||||
from esphome.components import binary_sensor
|
||||
import esphome.config_validation as cv
|
||||
from esphome.const import DEVICE_CLASS_MOTION, DEVICE_CLASS_OCCUPANCY
|
||||
from esphome.const import (
|
||||
DEVICE_CLASS_MOTION,
|
||||
DEVICE_CLASS_OCCUPANCY,
|
||||
DEVICE_CLASS_PRESENCE,
|
||||
ENTITY_CATEGORY_DIAGNOSTIC,
|
||||
ICON_MOTION_SENSOR,
|
||||
ICON_ACCOUNT,
|
||||
)
|
||||
from . import CONF_LD2410_ID, LD2410Component
|
||||
|
||||
DEPENDENCIES = ["ld2410"]
|
||||
CONF_HAS_TARGET = "has_target"
|
||||
CONF_HAS_MOVING_TARGET = "has_moving_target"
|
||||
CONF_HAS_STILL_TARGET = "has_still_target"
|
||||
CONF_OUT_PIN_PRESENCE_STATUS = "out_pin_presence_status"
|
||||
|
||||
CONFIG_SCHEMA = {
|
||||
cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
|
||||
cv.Optional(CONF_HAS_TARGET): binary_sensor.binary_sensor_schema(
|
||||
device_class=DEVICE_CLASS_OCCUPANCY
|
||||
device_class=DEVICE_CLASS_OCCUPANCY,
|
||||
icon=ICON_ACCOUNT,
|
||||
),
|
||||
cv.Optional(CONF_HAS_MOVING_TARGET): binary_sensor.binary_sensor_schema(
|
||||
device_class=DEVICE_CLASS_MOTION
|
||||
device_class=DEVICE_CLASS_MOTION,
|
||||
icon=ICON_MOTION_SENSOR,
|
||||
),
|
||||
cv.Optional(CONF_HAS_STILL_TARGET): binary_sensor.binary_sensor_schema(
|
||||
device_class=DEVICE_CLASS_OCCUPANCY
|
||||
device_class=DEVICE_CLASS_OCCUPANCY,
|
||||
icon=ICON_MOTION_SENSOR,
|
||||
),
|
||||
cv.Optional(CONF_OUT_PIN_PRESENCE_STATUS): binary_sensor.binary_sensor_schema(
|
||||
device_class=DEVICE_CLASS_PRESENCE,
|
||||
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
|
||||
icon=ICON_ACCOUNT,
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
async def to_code(config):
|
||||
ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
|
||||
if CONF_HAS_TARGET in config:
|
||||
sens = await binary_sensor.new_binary_sensor(config[CONF_HAS_TARGET])
|
||||
cg.add(ld2410_component.set_target_sensor(sens))
|
||||
if CONF_HAS_MOVING_TARGET in config:
|
||||
sens = await binary_sensor.new_binary_sensor(config[CONF_HAS_MOVING_TARGET])
|
||||
cg.add(ld2410_component.set_moving_target_sensor(sens))
|
||||
if CONF_HAS_STILL_TARGET in config:
|
||||
sens = await binary_sensor.new_binary_sensor(config[CONF_HAS_STILL_TARGET])
|
||||
cg.add(ld2410_component.set_still_target_sensor(sens))
|
||||
if has_target_config := config.get(CONF_HAS_TARGET):
|
||||
sens = await binary_sensor.new_binary_sensor(has_target_config)
|
||||
cg.add(ld2410_component.set_target_binary_sensor(sens))
|
||||
if has_moving_target_config := config.get(CONF_HAS_MOVING_TARGET):
|
||||
sens = await binary_sensor.new_binary_sensor(has_moving_target_config)
|
||||
cg.add(ld2410_component.set_moving_target_binary_sensor(sens))
|
||||
if has_still_target_config := config.get(CONF_HAS_STILL_TARGET):
|
||||
sens = await binary_sensor.new_binary_sensor(has_still_target_config)
|
||||
cg.add(ld2410_component.set_still_target_binary_sensor(sens))
|
||||
if out_pin_presence_status_config := config.get(CONF_OUT_PIN_PRESENCE_STATUS):
|
||||
sens = await binary_sensor.new_binary_sensor(out_pin_presence_status_config)
|
||||
cg.add(ld2410_component.set_out_pin_presence_status_binary_sensor(sens))
|
||||
|
|
57
esphome/components/ld2410/button/__init__.py
Normal file
57
esphome/components/ld2410/button/__init__.py
Normal file
|
@ -0,0 +1,57 @@
|
|||
import esphome.codegen as cg
|
||||
from esphome.components import button
|
||||
import esphome.config_validation as cv
|
||||
from esphome.const import (
|
||||
DEVICE_CLASS_RESTART,
|
||||
ENTITY_CATEGORY_DIAGNOSTIC,
|
||||
ENTITY_CATEGORY_CONFIG,
|
||||
ICON_RESTART,
|
||||
ICON_RESTART_ALERT,
|
||||
ICON_DATABASE,
|
||||
)
|
||||
from .. import CONF_LD2410_ID, LD2410Component, ld2410_ns
|
||||
|
||||
QueryButton = ld2410_ns.class_("QueryButton", button.Button)
|
||||
ResetButton = ld2410_ns.class_("ResetButton", button.Button)
|
||||
RestartButton = ld2410_ns.class_("RestartButton", button.Button)
|
||||
|
||||
CONF_FACTORY_RESET = "factory_reset"
|
||||
CONF_RESTART = "restart"
|
||||
CONF_QUERY_PARAMS = "query_params"
|
||||
|
||||
CONFIG_SCHEMA = {
|
||||
cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
|
||||
cv.Optional(CONF_FACTORY_RESET): button.button_schema(
|
||||
ResetButton,
|
||||
device_class=DEVICE_CLASS_RESTART,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_RESTART_ALERT,
|
||||
),
|
||||
cv.Optional(CONF_RESTART): button.button_schema(
|
||||
RestartButton,
|
||||
device_class=DEVICE_CLASS_RESTART,
|
||||
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
|
||||
icon=ICON_RESTART,
|
||||
),
|
||||
cv.Optional(CONF_QUERY_PARAMS): button.button_schema(
|
||||
QueryButton,
|
||||
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
|
||||
icon=ICON_DATABASE,
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
async def to_code(config):
|
||||
ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
|
||||
if factory_reset_config := config.get(CONF_FACTORY_RESET):
|
||||
b = await button.new_button(factory_reset_config)
|
||||
await cg.register_parented(b, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_reset_button(b))
|
||||
if restart_config := config.get(CONF_RESTART):
|
||||
b = await button.new_button(restart_config)
|
||||
await cg.register_parented(b, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_restart_button(b))
|
||||
if query_params_config := config.get(CONF_QUERY_PARAMS):
|
||||
b = await button.new_button(query_params_config)
|
||||
await cg.register_parented(b, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_query_button(b))
|
9
esphome/components/ld2410/button/query_button.cpp
Normal file
9
esphome/components/ld2410/button/query_button.cpp
Normal file
|
@ -0,0 +1,9 @@
|
|||
#include "query_button.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
void QueryButton::press_action() { this->parent_->read_all_info(); }
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
18
esphome/components/ld2410/button/query_button.h
Normal file
18
esphome/components/ld2410/button/query_button.h
Normal file
|
@ -0,0 +1,18 @@
|
|||
#pragma once
|
||||
|
||||
#include "esphome/components/button/button.h"
|
||||
#include "../ld2410.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
class QueryButton : public button::Button, public Parented<LD2410Component> {
|
||||
public:
|
||||
QueryButton() = default;
|
||||
|
||||
protected:
|
||||
void press_action() override;
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
9
esphome/components/ld2410/button/reset_button.cpp
Normal file
9
esphome/components/ld2410/button/reset_button.cpp
Normal file
|
@ -0,0 +1,9 @@
|
|||
#include "reset_button.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
void ResetButton::press_action() { this->parent_->factory_reset(); }
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
18
esphome/components/ld2410/button/reset_button.h
Normal file
18
esphome/components/ld2410/button/reset_button.h
Normal file
|
@ -0,0 +1,18 @@
|
|||
#pragma once
|
||||
|
||||
#include "esphome/components/button/button.h"
|
||||
#include "../ld2410.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
class ResetButton : public button::Button, public Parented<LD2410Component> {
|
||||
public:
|
||||
ResetButton() = default;
|
||||
|
||||
protected:
|
||||
void press_action() override;
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
9
esphome/components/ld2410/button/restart_button.cpp
Normal file
9
esphome/components/ld2410/button/restart_button.cpp
Normal file
|
@ -0,0 +1,9 @@
|
|||
#include "restart_button.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
void RestartButton::press_action() { this->parent_->restart_and_read_all_info(); }
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
18
esphome/components/ld2410/button/restart_button.h
Normal file
18
esphome/components/ld2410/button/restart_button.h
Normal file
|
@ -0,0 +1,18 @@
|
|||
#pragma once
|
||||
|
||||
#include "esphome/components/button/button.h"
|
||||
#include "../ld2410.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
class RestartButton : public button::Button, public Parented<LD2410Component> {
|
||||
public:
|
||||
RestartButton() = default;
|
||||
|
||||
protected:
|
||||
void press_action() override;
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
|
@ -1,5 +1,13 @@
|
|||
#include "ld2410.h"
|
||||
|
||||
#include <utility>
|
||||
#ifdef USE_NUMBER
|
||||
#include "esphome/components/number/number.h"
|
||||
#endif
|
||||
#ifdef USE_SENSOR
|
||||
#include "esphome/components/sensor/sensor.h"
|
||||
#endif
|
||||
|
||||
#define highbyte(val) (uint8_t)((val) >> 8)
|
||||
#define lowbyte(val) (uint8_t)((val) &0xff)
|
||||
|
||||
|
@ -8,48 +16,97 @@ namespace ld2410 {
|
|||
|
||||
static const char *const TAG = "ld2410";
|
||||
|
||||
LD2410Component::LD2410Component() {}
|
||||
|
||||
void LD2410Component::dump_config() {
|
||||
ESP_LOGCONFIG(TAG, "LD2410:");
|
||||
#ifdef USE_BINARY_SENSOR
|
||||
LOG_BINARY_SENSOR(" ", "HasTargetSensor", this->target_binary_sensor_);
|
||||
LOG_BINARY_SENSOR(" ", "MovingSensor", this->moving_binary_sensor_);
|
||||
LOG_BINARY_SENSOR(" ", "StillSensor", this->still_binary_sensor_);
|
||||
LOG_BINARY_SENSOR(" ", "TargetBinarySensor", this->target_binary_sensor_);
|
||||
LOG_BINARY_SENSOR(" ", "MovingTargetBinarySensor", this->moving_target_binary_sensor_);
|
||||
LOG_BINARY_SENSOR(" ", "StillTargetBinarySensor", this->still_target_binary_sensor_);
|
||||
LOG_BINARY_SENSOR(" ", "OutPinPresenceStatusBinarySensor", this->out_pin_presence_status_binary_sensor_);
|
||||
#endif
|
||||
#ifdef USE_SWITCH
|
||||
LOG_SWITCH(" ", "EngineeringModeSwitch", this->engineering_mode_switch_);
|
||||
LOG_SWITCH(" ", "BluetoothSwitch", this->bluetooth_switch_);
|
||||
#endif
|
||||
#ifdef USE_BUTTON
|
||||
LOG_BUTTON(" ", "ResetButton", this->reset_button_);
|
||||
LOG_BUTTON(" ", "RestartButton", this->restart_button_);
|
||||
LOG_BUTTON(" ", "QueryButton", this->query_button_);
|
||||
#endif
|
||||
#ifdef USE_SENSOR
|
||||
LOG_SENSOR(" ", "Moving Distance", this->moving_target_distance_sensor_);
|
||||
LOG_SENSOR(" ", "Still Distance", this->still_target_distance_sensor_);
|
||||
LOG_SENSOR(" ", "Moving Energy", this->moving_target_energy_sensor_);
|
||||
LOG_SENSOR(" ", "Still Energy", this->still_target_energy_sensor_);
|
||||
LOG_SENSOR(" ", "Detection Distance", this->detection_distance_sensor_);
|
||||
LOG_SENSOR(" ", "LightSensor", this->light_sensor_);
|
||||
LOG_SENSOR(" ", "MovingTargetDistanceSensor", this->moving_target_distance_sensor_);
|
||||
LOG_SENSOR(" ", "StillTargetDistanceSensor", this->still_target_distance_sensor_);
|
||||
LOG_SENSOR(" ", "MovingTargetEnergySensor", this->moving_target_energy_sensor_);
|
||||
LOG_SENSOR(" ", "StillTargetEnergySensor", this->still_target_energy_sensor_);
|
||||
LOG_SENSOR(" ", "DetectionDistanceSensor", this->detection_distance_sensor_);
|
||||
for (sensor::Sensor *s : this->gate_still_sensors_) {
|
||||
LOG_SENSOR(" ", "NthGateStillSesnsor", s);
|
||||
}
|
||||
for (sensor::Sensor *s : this->gate_move_sensors_) {
|
||||
LOG_SENSOR(" ", "NthGateMoveSesnsor", s);
|
||||
}
|
||||
#endif
|
||||
this->set_config_mode_(true);
|
||||
this->get_version_();
|
||||
this->set_config_mode_(false);
|
||||
ESP_LOGCONFIG(TAG, " Firmware Version : %u.%u.%u%u%u%u", this->version_[0], this->version_[1], this->version_[2],
|
||||
this->version_[3], this->version_[4], this->version_[5]);
|
||||
#ifdef USE_TEXT_SENSOR
|
||||
LOG_TEXT_SENSOR(" ", "VersionTextSensor", this->version_text_sensor_);
|
||||
LOG_TEXT_SENSOR(" ", "MacTextSensor", this->mac_text_sensor_);
|
||||
#endif
|
||||
#ifdef USE_SELECT
|
||||
LOG_SELECT(" ", "LightFunctionSelect", this->light_function_select_);
|
||||
LOG_SELECT(" ", "OutPinLevelSelect", this->out_pin_level_select_);
|
||||
LOG_SELECT(" ", "DistanceResolutionSelect", this->distance_resolution_select_);
|
||||
LOG_SELECT(" ", "BaudRateSelect", this->baud_rate_select_);
|
||||
#endif
|
||||
#ifdef USE_NUMBER
|
||||
LOG_NUMBER(" ", "LightThresholdNumber", this->light_threshold_number_);
|
||||
LOG_NUMBER(" ", "MaxStillDistanceGateNumber", this->max_still_distance_gate_number_);
|
||||
LOG_NUMBER(" ", "MaxMoveDistanceGateNumber", this->max_move_distance_gate_number_);
|
||||
LOG_NUMBER(" ", "TimeoutNumber", this->timeout_number_);
|
||||
for (number::Number *n : this->gate_still_threshold_numbers_) {
|
||||
LOG_NUMBER(" ", "Still Thresholds Number", n);
|
||||
}
|
||||
for (number::Number *n : this->gate_move_threshold_numbers_) {
|
||||
LOG_NUMBER(" ", "Move Thresholds Number", n);
|
||||
}
|
||||
#endif
|
||||
this->read_all_info();
|
||||
ESP_LOGCONFIG(TAG, " Throttle_ : %ums", this->throttle_);
|
||||
ESP_LOGCONFIG(TAG, " MAC Address : %s", const_cast<char *>(this->mac_.c_str()));
|
||||
ESP_LOGCONFIG(TAG, " Firmware Version : %s", const_cast<char *>(this->version_.c_str()));
|
||||
}
|
||||
|
||||
void LD2410Component::setup() {
|
||||
ESP_LOGCONFIG(TAG, "Setting up LD2410...");
|
||||
this->set_config_mode_(true);
|
||||
this->set_max_distances_timeout_(this->max_move_distance_, this->max_still_distance_, this->timeout_);
|
||||
// Configure Gates sensitivity
|
||||
this->set_gate_threshold_(0, this->rg0_move_threshold_, this->rg0_still_threshold_);
|
||||
this->set_gate_threshold_(1, this->rg1_move_threshold_, this->rg1_still_threshold_);
|
||||
this->set_gate_threshold_(2, this->rg2_move_threshold_, this->rg2_still_threshold_);
|
||||
this->set_gate_threshold_(3, this->rg3_move_threshold_, this->rg3_still_threshold_);
|
||||
this->set_gate_threshold_(4, this->rg4_move_threshold_, this->rg4_still_threshold_);
|
||||
this->set_gate_threshold_(5, this->rg5_move_threshold_, this->rg5_still_threshold_);
|
||||
this->set_gate_threshold_(6, this->rg6_move_threshold_, this->rg6_still_threshold_);
|
||||
this->set_gate_threshold_(7, this->rg7_move_threshold_, this->rg7_still_threshold_);
|
||||
this->set_gate_threshold_(8, this->rg8_move_threshold_, this->rg8_still_threshold_);
|
||||
this->get_version_();
|
||||
this->set_config_mode_(false);
|
||||
ESP_LOGCONFIG(TAG, "Firmware Version : %u.%u.%u%u%u%u", this->version_[0], this->version_[1], this->version_[2],
|
||||
this->version_[3], this->version_[4], this->version_[5]);
|
||||
this->read_all_info();
|
||||
ESP_LOGCONFIG(TAG, "Mac Address : %s", const_cast<char *>(this->mac_.c_str()));
|
||||
ESP_LOGCONFIG(TAG, "Firmware Version : %s", const_cast<char *>(this->version_.c_str()));
|
||||
ESP_LOGCONFIG(TAG, "LD2410 setup complete.");
|
||||
}
|
||||
|
||||
void LD2410Component::read_all_info() {
|
||||
this->set_config_mode_(true);
|
||||
this->get_version_();
|
||||
this->get_mac_();
|
||||
this->get_distance_resolution_();
|
||||
this->get_light_control_();
|
||||
this->query_parameters_();
|
||||
this->set_config_mode_(false);
|
||||
#ifdef USE_SELECT
|
||||
const auto baud_rate = std::to_string(this->parent_->get_baud_rate());
|
||||
if (this->baud_rate_select_ != nullptr && this->baud_rate_select_->state != baud_rate) {
|
||||
this->baud_rate_select_->publish_state(baud_rate);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void LD2410Component::restart_and_read_all_info() {
|
||||
this->set_config_mode_(true);
|
||||
this->restart_();
|
||||
this->set_timeout(1000, [this]() { this->read_all_info(); });
|
||||
}
|
||||
|
||||
void LD2410Component::loop() {
|
||||
const int max_line_length = 80;
|
||||
static uint8_t buffer[max_line_length];
|
||||
|
@ -59,9 +116,8 @@ void LD2410Component::loop() {
|
|||
}
|
||||
}
|
||||
|
||||
void LD2410Component::send_command_(uint8_t command, uint8_t *command_value, int command_value_len) {
|
||||
// lastCommandSuccess->publish_state(false);
|
||||
|
||||
void LD2410Component::send_command_(uint8_t command, const uint8_t *command_value, int command_value_len) {
|
||||
ESP_LOGV(TAG, "Sending COMMAND %02X", command);
|
||||
// frame start bytes
|
||||
this->write_array(CMD_FRAME_HEADER, 4);
|
||||
// length bytes
|
||||
|
@ -95,40 +151,43 @@ void LD2410Component::handle_periodic_data_(uint8_t *buffer, int len) {
|
|||
if (buffer[7] != HEAD || buffer[len - 6] != END || buffer[len - 5] != CHECK) // Check constant values
|
||||
return; // data head=0xAA, data end=0x55, crc=0x00
|
||||
|
||||
/*
|
||||
Data Type: 6th
|
||||
0x01: Engineering mode
|
||||
0x02: Normal mode
|
||||
*/
|
||||
// char data_type = buffer[DATA_TYPES];
|
||||
/*
|
||||
Target states: 9th
|
||||
0x00 = No target
|
||||
0x01 = Moving targets
|
||||
0x02 = Still targets
|
||||
0x03 = Moving+Still targets
|
||||
*/
|
||||
#ifdef USE_BINARY_SENSOR
|
||||
char target_state = buffer[TARGET_STATES];
|
||||
if (this->target_binary_sensor_ != nullptr) {
|
||||
this->target_binary_sensor_->publish_state(target_state != 0x00);
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
Reduce data update rate to prevent home assistant database size grow fast
|
||||
*/
|
||||
int32_t current_millis = millis();
|
||||
if (current_millis - last_periodic_millis < 1000)
|
||||
if (current_millis - last_periodic_millis_ < this->throttle_)
|
||||
return;
|
||||
last_periodic_millis = current_millis;
|
||||
last_periodic_millis_ = current_millis;
|
||||
|
||||
#ifdef USE_BINARY_SENSOR
|
||||
if (this->moving_binary_sensor_ != nullptr) {
|
||||
this->moving_binary_sensor_->publish_state(CHECK_BIT(target_state, 0));
|
||||
/*
|
||||
Data Type: 7th
|
||||
0x01: Engineering mode
|
||||
0x02: Normal mode
|
||||
*/
|
||||
bool engineering_mode = buffer[DATA_TYPES] == 0x01;
|
||||
#ifdef USE_SWITCH
|
||||
if (this->engineering_mode_switch_ != nullptr &&
|
||||
current_millis - last_engineering_mode_change_millis_ > this->throttle_) {
|
||||
this->engineering_mode_switch_->publish_state(engineering_mode);
|
||||
}
|
||||
if (this->still_binary_sensor_ != nullptr) {
|
||||
this->still_binary_sensor_->publish_state(CHECK_BIT(target_state, 1));
|
||||
#endif
|
||||
#ifdef USE_BINARY_SENSOR
|
||||
/*
|
||||
Target states: 9th
|
||||
0x00 = No target
|
||||
0x01 = Moving targets
|
||||
0x02 = Still targets
|
||||
0x03 = Moving+Still targets
|
||||
*/
|
||||
char target_state = buffer[TARGET_STATES];
|
||||
if (this->target_binary_sensor_ != nullptr) {
|
||||
this->target_binary_sensor_->publish_state(target_state != 0x00);
|
||||
}
|
||||
if (this->moving_target_binary_sensor_ != nullptr) {
|
||||
this->moving_target_binary_sensor_->publish_state(CHECK_BIT(target_state, 0));
|
||||
}
|
||||
if (this->still_target_binary_sensor_ != nullptr) {
|
||||
this->still_target_binary_sensor_->publish_state(CHECK_BIT(target_state, 1));
|
||||
}
|
||||
#endif
|
||||
/*
|
||||
|
@ -164,26 +223,126 @@ void LD2410Component::handle_periodic_data_(uint8_t *buffer, int len) {
|
|||
if (this->detection_distance_sensor_->get_state() != new_detect_distance)
|
||||
this->detection_distance_sensor_->publish_state(new_detect_distance);
|
||||
}
|
||||
if (engineering_mode) {
|
||||
/*
|
||||
Moving distance range: 18th byte
|
||||
Still distance range: 19th byte
|
||||
Moving enery: 20~28th bytes
|
||||
*/
|
||||
for (std::vector<sensor::Sensor *>::size_type i = 0; i != this->gate_move_sensors_.size(); i++) {
|
||||
sensor::Sensor *s = this->gate_move_sensors_[i];
|
||||
if (s != nullptr) {
|
||||
s->publish_state(buffer[MOVING_SENSOR_START + i]);
|
||||
}
|
||||
}
|
||||
/*
|
||||
Still energy: 29~37th bytes
|
||||
*/
|
||||
for (std::vector<sensor::Sensor *>::size_type i = 0; i != this->gate_still_sensors_.size(); i++) {
|
||||
sensor::Sensor *s = this->gate_still_sensors_[i];
|
||||
if (s != nullptr) {
|
||||
s->publish_state(buffer[STILL_SENSOR_START + i]);
|
||||
}
|
||||
}
|
||||
/*
|
||||
Light sensor: 38th bytes
|
||||
*/
|
||||
if (this->light_sensor_ != nullptr) {
|
||||
int new_light_sensor = buffer[LIGHT_SENSOR];
|
||||
if (this->light_sensor_->get_state() != new_light_sensor)
|
||||
this->light_sensor_->publish_state(new_light_sensor);
|
||||
}
|
||||
} else {
|
||||
for (auto *s : this->gate_move_sensors_) {
|
||||
if (s != nullptr && !std::isnan(s->get_state())) {
|
||||
s->publish_state(NAN);
|
||||
}
|
||||
}
|
||||
for (auto *s : this->gate_still_sensors_) {
|
||||
if (s != nullptr && !std::isnan(s->get_state())) {
|
||||
s->publish_state(NAN);
|
||||
}
|
||||
}
|
||||
if (this->light_sensor_ != nullptr && !std::isnan(this->light_sensor_->get_state())) {
|
||||
this->light_sensor_->publish_state(NAN);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef USE_BINARY_SENSOR
|
||||
if (engineering_mode) {
|
||||
if (this->out_pin_presence_status_binary_sensor_ != nullptr) {
|
||||
this->out_pin_presence_status_binary_sensor_->publish_state(buffer[OUT_PIN_SENSOR] == 0x01);
|
||||
}
|
||||
} else {
|
||||
if (this->out_pin_presence_status_binary_sensor_ != nullptr) {
|
||||
this->out_pin_presence_status_binary_sensor_->publish_state(false);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
|
||||
ESP_LOGV(TAG, "Handling ACK DATA for COMMAND");
|
||||
const char VERSION_FMT[] = "%u.%02X.%02X%02X%02X%02X";
|
||||
|
||||
std::string format_version(uint8_t *buffer) {
|
||||
std::string::size_type version_size = 256;
|
||||
std::string version;
|
||||
do {
|
||||
version.resize(version_size + 1);
|
||||
version_size = std::snprintf(&version[0], version.size(), VERSION_FMT, buffer[13], buffer[12], buffer[17],
|
||||
buffer[16], buffer[15], buffer[14]);
|
||||
} while (version_size + 1 > version.size());
|
||||
version.resize(version_size);
|
||||
return version;
|
||||
}
|
||||
|
||||
const char MAC_FMT[] = "%02X:%02X:%02X:%02X:%02X:%02X";
|
||||
|
||||
const std::string UNKNOWN_MAC("unknown");
|
||||
const std::string NO_MAC("08:05:04:03:02:01");
|
||||
|
||||
std::string format_mac(uint8_t *buffer) {
|
||||
std::string::size_type mac_size = 256;
|
||||
std::string mac;
|
||||
do {
|
||||
mac.resize(mac_size + 1);
|
||||
mac_size = std::snprintf(&mac[0], mac.size(), MAC_FMT, buffer[10], buffer[11], buffer[12], buffer[13], buffer[14],
|
||||
buffer[15]);
|
||||
} while (mac_size + 1 > mac.size());
|
||||
mac.resize(mac_size);
|
||||
if (mac == NO_MAC) {
|
||||
return UNKNOWN_MAC;
|
||||
}
|
||||
return mac;
|
||||
}
|
||||
|
||||
#ifdef USE_NUMBER
|
||||
std::function<void(void)> set_number_value(number::Number *n, float value) {
|
||||
float normalized_value = value * 1.0;
|
||||
if (n != nullptr && (!n->has_state() || n->state != normalized_value)) {
|
||||
n->state = normalized_value;
|
||||
return [n, normalized_value]() { n->publish_state(normalized_value); };
|
||||
}
|
||||
return []() {};
|
||||
}
|
||||
#endif
|
||||
|
||||
bool LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
|
||||
ESP_LOGV(TAG, "Handling ACK DATA for COMMAND %02X", buffer[COMMAND]);
|
||||
if (len < 10) {
|
||||
ESP_LOGE(TAG, "Error with last command : incorrect length");
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
if (buffer[0] != 0xFD || buffer[1] != 0xFC || buffer[2] != 0xFB || buffer[3] != 0xFA) { // check 4 frame start bytes
|
||||
ESP_LOGE(TAG, "Error with last command : incorrect Header");
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
if (buffer[COMMAND_STATUS] != 0x01) {
|
||||
ESP_LOGE(TAG, "Error with last command : status != 0x01");
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
if (this->two_byte_to_int_(buffer[8], buffer[9]) != 0x00) {
|
||||
ESP_LOGE(TAG, "Error with last command , last buffer was: %u , %u", buffer[8], buffer[9]);
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
|
||||
switch (buffer[COMMAND]) {
|
||||
|
@ -193,49 +352,127 @@ void LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
|
|||
case lowbyte(CMD_DISABLE_CONF):
|
||||
ESP_LOGV(TAG, "Handled Disabled conf command");
|
||||
break;
|
||||
case lowbyte(CMD_SET_BAUD_RATE):
|
||||
ESP_LOGV(TAG, "Handled baud rate change command");
|
||||
#ifdef USE_SELECT
|
||||
if (this->baud_rate_select_ != nullptr) {
|
||||
ESP_LOGE(TAG, "Change baud rate component config to %s and reinstall", this->baud_rate_select_->state.c_str());
|
||||
}
|
||||
#endif
|
||||
break;
|
||||
case lowbyte(CMD_VERSION):
|
||||
ESP_LOGV(TAG, "FW Version is: %u.%u.%u%u%u%u", buffer[13], buffer[12], buffer[17], buffer[16], buffer[15],
|
||||
buffer[14]);
|
||||
this->version_[0] = buffer[13];
|
||||
this->version_[1] = buffer[12];
|
||||
this->version_[2] = buffer[17];
|
||||
this->version_[3] = buffer[16];
|
||||
this->version_[4] = buffer[15];
|
||||
this->version_[5] = buffer[14];
|
||||
|
||||
this->version_ = format_version(buffer);
|
||||
ESP_LOGV(TAG, "FW Version is: %s", const_cast<char *>(this->version_.c_str()));
|
||||
#ifdef USE_TEXT_SENSOR
|
||||
if (this->version_text_sensor_ != nullptr) {
|
||||
this->version_text_sensor_->publish_state(this->version_);
|
||||
}
|
||||
#endif
|
||||
break;
|
||||
case lowbyte(CMD_QUERY_DISTANCE_RESOLUTION): {
|
||||
std::string distance_resolution =
|
||||
DISTANCE_RESOLUTION_INT_TO_ENUM.at(this->two_byte_to_int_(buffer[10], buffer[11]));
|
||||
ESP_LOGV(TAG, "Distance resolution is: %s", const_cast<char *>(distance_resolution.c_str()));
|
||||
#ifdef USE_SELECT
|
||||
if (this->distance_resolution_select_ != nullptr &&
|
||||
this->distance_resolution_select_->state != distance_resolution) {
|
||||
this->distance_resolution_select_->publish_state(distance_resolution);
|
||||
}
|
||||
#endif
|
||||
} break;
|
||||
case lowbyte(CMD_QUERY_LIGHT_CONTROL): {
|
||||
this->light_function_ = LIGHT_FUNCTION_INT_TO_ENUM.at(buffer[10]);
|
||||
this->light_threshold_ = buffer[11] * 1.0;
|
||||
this->out_pin_level_ = OUT_PIN_LEVEL_INT_TO_ENUM.at(buffer[12]);
|
||||
ESP_LOGV(TAG, "Light function is: %s", const_cast<char *>(this->light_function_.c_str()));
|
||||
ESP_LOGV(TAG, "Light threshold is: %f", this->light_threshold_);
|
||||
ESP_LOGV(TAG, "Out pin level is: %s", const_cast<char *>(this->out_pin_level_.c_str()));
|
||||
#ifdef USE_SELECT
|
||||
if (this->light_function_select_ != nullptr && this->light_function_select_->state != this->light_function_) {
|
||||
this->light_function_select_->publish_state(this->light_function_);
|
||||
}
|
||||
if (this->out_pin_level_select_ != nullptr && this->out_pin_level_select_->state != this->out_pin_level_) {
|
||||
this->out_pin_level_select_->publish_state(this->out_pin_level_);
|
||||
}
|
||||
#endif
|
||||
#ifdef USE_NUMBER
|
||||
if (this->light_threshold_number_ != nullptr &&
|
||||
(!this->light_threshold_number_->has_state() ||
|
||||
this->light_threshold_number_->state != this->light_threshold_)) {
|
||||
this->light_threshold_number_->publish_state(this->light_threshold_);
|
||||
}
|
||||
#endif
|
||||
} break;
|
||||
case lowbyte(CMD_MAC):
|
||||
if (len < 20) {
|
||||
return false;
|
||||
}
|
||||
this->mac_ = format_mac(buffer);
|
||||
ESP_LOGV(TAG, "MAC Address is: %s", const_cast<char *>(this->mac_.c_str()));
|
||||
#ifdef USE_TEXT_SENSOR
|
||||
if (this->mac_text_sensor_ != nullptr) {
|
||||
this->mac_text_sensor_->publish_state(this->mac_);
|
||||
}
|
||||
#endif
|
||||
#ifdef USE_SWITCH
|
||||
if (this->bluetooth_switch_ != nullptr) {
|
||||
this->bluetooth_switch_->publish_state(this->mac_ != UNKNOWN_MAC);
|
||||
}
|
||||
#endif
|
||||
break;
|
||||
case lowbyte(CMD_GATE_SENS):
|
||||
ESP_LOGV(TAG, "Handled sensitivity command");
|
||||
break;
|
||||
case lowbyte(CMD_BLUETOOTH):
|
||||
ESP_LOGV(TAG, "Handled bluetooth command");
|
||||
break;
|
||||
case lowbyte(CMD_SET_DISTANCE_RESOLUTION):
|
||||
ESP_LOGV(TAG, "Handled set distance resolution command");
|
||||
break;
|
||||
case lowbyte(CMD_SET_LIGHT_CONTROL):
|
||||
ESP_LOGV(TAG, "Handled set light control command");
|
||||
break;
|
||||
case lowbyte(CMD_BT_PASSWORD):
|
||||
ESP_LOGV(TAG, "Handled set bluetooth password command");
|
||||
break;
|
||||
case lowbyte(CMD_QUERY): // Query parameters response
|
||||
{
|
||||
if (buffer[10] != 0xAA)
|
||||
return; // value head=0xAA
|
||||
return true; // value head=0xAA
|
||||
#ifdef USE_NUMBER
|
||||
/*
|
||||
Moving distance range: 13th byte
|
||||
Still distance range: 14th byte
|
||||
*/
|
||||
// TODO
|
||||
// maxMovingDistanceRange->publish_state(buffer[12]);
|
||||
// maxStillDistanceRange->publish_state(buffer[13]);
|
||||
std::vector<std::function<void(void)>> updates;
|
||||
updates.push_back(set_number_value(this->max_move_distance_gate_number_, buffer[12]));
|
||||
updates.push_back(set_number_value(this->max_still_distance_gate_number_, buffer[13]));
|
||||
/*
|
||||
Moving Sensitivities: 15~23th bytes
|
||||
*/
|
||||
for (std::vector<number::Number *>::size_type i = 0; i != this->gate_move_threshold_numbers_.size(); i++) {
|
||||
updates.push_back(set_number_value(this->gate_move_threshold_numbers_[i], buffer[14 + i]));
|
||||
}
|
||||
/*
|
||||
Still Sensitivities: 24~32th bytes
|
||||
*/
|
||||
for (int i = 0; i < 9; i++) {
|
||||
moving_sensitivities[i] = buffer[14 + i];
|
||||
}
|
||||
for (int i = 0; i < 9; i++) {
|
||||
still_sensitivities[i] = buffer[23 + i];
|
||||
for (std::vector<number::Number *>::size_type i = 0; i != this->gate_still_threshold_numbers_.size(); i++) {
|
||||
updates.push_back(set_number_value(this->gate_still_threshold_numbers_[i], buffer[23 + i]));
|
||||
}
|
||||
/*
|
||||
None Duration: 33~34th bytes
|
||||
*/
|
||||
// noneDuration->publish_state(this->two_byte_to_int_(buffer[32], buffer[33]));
|
||||
updates.push_back(set_number_value(this->timeout_number_, this->two_byte_to_int_(buffer[32], buffer[33])));
|
||||
for (auto &update : updates) {
|
||||
update();
|
||||
}
|
||||
#endif
|
||||
} break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void LD2410Component::readline_(int readch, uint8_t *buffer, int len) {
|
||||
|
@ -256,8 +493,11 @@ void LD2410Component::readline_(int readch, uint8_t *buffer, int len) {
|
|||
} else if (buffer[pos - 4] == 0x04 && buffer[pos - 3] == 0x03 && buffer[pos - 2] == 0x02 &&
|
||||
buffer[pos - 1] == 0x01) {
|
||||
ESP_LOGV(TAG, "Will handle ACK Data");
|
||||
this->handle_ack_data_(buffer, pos);
|
||||
pos = 0; // Reset position index ready for next time
|
||||
if (this->handle_ack_data_(buffer, pos)) {
|
||||
pos = 0; // Reset position index ready for next time
|
||||
} else {
|
||||
ESP_LOGV(TAG, "ACK Data incomplete");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -269,21 +509,85 @@ void LD2410Component::set_config_mode_(bool enable) {
|
|||
this->send_command_(cmd, enable ? cmd_value : nullptr, 2);
|
||||
}
|
||||
|
||||
void LD2410Component::set_bluetooth(bool enable) {
|
||||
this->set_config_mode_(true);
|
||||
uint8_t enable_cmd_value[2] = {0x01, 0x00};
|
||||
uint8_t disable_cmd_value[2] = {0x00, 0x00};
|
||||
this->send_command_(CMD_BLUETOOTH, enable ? enable_cmd_value : disable_cmd_value, 2);
|
||||
this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
|
||||
}
|
||||
|
||||
void LD2410Component::set_distance_resolution(const std::string &state) {
|
||||
this->set_config_mode_(true);
|
||||
uint8_t cmd_value[2] = {DISTANCE_RESOLUTION_ENUM_TO_INT.at(state), 0x00};
|
||||
this->send_command_(CMD_SET_DISTANCE_RESOLUTION, cmd_value, 2);
|
||||
this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
|
||||
}
|
||||
|
||||
void LD2410Component::set_baud_rate(const std::string &state) {
|
||||
this->set_config_mode_(true);
|
||||
uint8_t cmd_value[2] = {BAUD_RATE_ENUM_TO_INT.at(state), 0x00};
|
||||
this->send_command_(CMD_SET_BAUD_RATE, cmd_value, 2);
|
||||
this->set_timeout(200, [this]() { this->restart_(); });
|
||||
}
|
||||
|
||||
void LD2410Component::set_bluetooth_password(const std::string &password) {
|
||||
if (password.length() != 6) {
|
||||
ESP_LOGE(TAG, "set_bluetooth_password(): invalid password length, must be exactly 6 chars '%s'", password.c_str());
|
||||
return;
|
||||
}
|
||||
this->set_config_mode_(true);
|
||||
uint8_t cmd_value[6];
|
||||
std::copy(password.begin(), password.end(), std::begin(cmd_value));
|
||||
this->send_command_(CMD_BT_PASSWORD, cmd_value, 6);
|
||||
this->set_config_mode_(false);
|
||||
}
|
||||
|
||||
void LD2410Component::set_engineering_mode(bool enable) {
|
||||
this->set_config_mode_(true);
|
||||
last_engineering_mode_change_millis_ = millis();
|
||||
uint8_t cmd = enable ? CMD_ENABLE_ENG : CMD_DISABLE_ENG;
|
||||
this->send_command_(cmd, nullptr, 0);
|
||||
this->set_config_mode_(false);
|
||||
}
|
||||
|
||||
void LD2410Component::factory_reset() {
|
||||
this->set_config_mode_(true);
|
||||
this->send_command_(CMD_RESET, nullptr, 0);
|
||||
this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
|
||||
}
|
||||
|
||||
void LD2410Component::restart_() { this->send_command_(CMD_RESTART, nullptr, 0); }
|
||||
|
||||
void LD2410Component::query_parameters_() { this->send_command_(CMD_QUERY, nullptr, 0); }
|
||||
void LD2410Component::get_version_() { this->send_command_(CMD_VERSION, nullptr, 0); }
|
||||
void LD2410Component::get_mac_() {
|
||||
uint8_t cmd_value[2] = {0x01, 0x00};
|
||||
this->send_command_(CMD_MAC, cmd_value, 2);
|
||||
}
|
||||
void LD2410Component::get_distance_resolution_() { this->send_command_(CMD_QUERY_DISTANCE_RESOLUTION, nullptr, 0); }
|
||||
|
||||
void LD2410Component::set_max_distances_timeout_(uint8_t max_moving_distance_range, uint8_t max_still_distance_range,
|
||||
uint16_t timeout) {
|
||||
void LD2410Component::get_light_control_() { this->send_command_(CMD_QUERY_LIGHT_CONTROL, nullptr, 0); }
|
||||
|
||||
#ifdef USE_NUMBER
|
||||
void LD2410Component::set_max_distances_timeout() {
|
||||
if (!this->max_move_distance_gate_number_->has_state() || !this->max_still_distance_gate_number_->has_state() ||
|
||||
!this->timeout_number_->has_state()) {
|
||||
return;
|
||||
}
|
||||
int max_moving_distance_gate_range = static_cast<int>(this->max_move_distance_gate_number_->state);
|
||||
int max_still_distance_gate_range = static_cast<int>(this->max_still_distance_gate_number_->state);
|
||||
int timeout = static_cast<int>(this->timeout_number_->state);
|
||||
uint8_t value[18] = {0x00,
|
||||
0x00,
|
||||
lowbyte(max_moving_distance_range),
|
||||
highbyte(max_moving_distance_range),
|
||||
lowbyte(max_moving_distance_gate_range),
|
||||
highbyte(max_moving_distance_gate_range),
|
||||
0x00,
|
||||
0x00,
|
||||
0x01,
|
||||
0x00,
|
||||
lowbyte(max_still_distance_range),
|
||||
highbyte(max_still_distance_range),
|
||||
lowbyte(max_still_distance_gate_range),
|
||||
highbyte(max_still_distance_gate_range),
|
||||
0x00,
|
||||
0x00,
|
||||
0x02,
|
||||
|
@ -292,10 +596,25 @@ void LD2410Component::set_max_distances_timeout_(uint8_t max_moving_distance_ran
|
|||
highbyte(timeout),
|
||||
0x00,
|
||||
0x00};
|
||||
this->set_config_mode_(true);
|
||||
this->send_command_(CMD_MAXDIST_DURATION, value, 18);
|
||||
delay(50); // NOLINT
|
||||
this->query_parameters_();
|
||||
this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
|
||||
this->set_config_mode_(false);
|
||||
}
|
||||
void LD2410Component::set_gate_threshold_(uint8_t gate, uint8_t motionsens, uint8_t stillsens) {
|
||||
|
||||
void LD2410Component::set_gate_threshold(uint8_t gate) {
|
||||
number::Number *motionsens = this->gate_move_threshold_numbers_[gate];
|
||||
number::Number *stillsens = this->gate_still_threshold_numbers_[gate];
|
||||
|
||||
if (!motionsens->has_state() || !stillsens->has_state()) {
|
||||
return;
|
||||
}
|
||||
int motion = static_cast<int>(motionsens->state);
|
||||
int still = static_cast<int>(stillsens->state);
|
||||
|
||||
this->set_config_mode_(true);
|
||||
// reference
|
||||
// https://drive.google.com/drive/folders/1p4dhbEJA3YubyIjIIC7wwVsSo8x29Fq-?spm=a2g0o.detail.1000023.17.93465697yFwVxH
|
||||
// Send data: configure the motion sensitivity of distance gate 3 to 40, and the static sensitivity of 40
|
||||
|
@ -305,11 +624,57 @@ void LD2410Component::set_gate_threshold_(uint8_t gate, uint8_t motionsens, uint
|
|||
// 28 00 00 00 (value)
|
||||
// 02 00 (still sensitivtiy)
|
||||
// 28 00 00 00 (value)
|
||||
uint8_t value[18] = {0x00, 0x00, lowbyte(gate), highbyte(gate), 0x00, 0x00,
|
||||
0x01, 0x00, lowbyte(motionsens), highbyte(motionsens), 0x00, 0x00,
|
||||
0x02, 0x00, lowbyte(stillsens), highbyte(stillsens), 0x00, 0x00};
|
||||
uint8_t value[18] = {0x00, 0x00, lowbyte(gate), highbyte(gate), 0x00, 0x00,
|
||||
0x01, 0x00, lowbyte(motion), highbyte(motion), 0x00, 0x00,
|
||||
0x02, 0x00, lowbyte(still), highbyte(still), 0x00, 0x00};
|
||||
this->send_command_(CMD_GATE_SENS, value, 18);
|
||||
delay(50); // NOLINT
|
||||
this->query_parameters_();
|
||||
this->set_config_mode_(false);
|
||||
}
|
||||
|
||||
void LD2410Component::set_gate_still_threshold_number(int gate, number::Number *n) {
|
||||
this->gate_still_threshold_numbers_[gate] = n;
|
||||
}
|
||||
|
||||
void LD2410Component::set_gate_move_threshold_number(int gate, number::Number *n) {
|
||||
this->gate_move_threshold_numbers_[gate] = n;
|
||||
}
|
||||
#endif
|
||||
|
||||
void LD2410Component::set_light_out_control() {
|
||||
#ifdef USE_NUMBER
|
||||
if (this->light_threshold_number_ != nullptr && this->light_threshold_number_->has_state()) {
|
||||
this->light_threshold_ = this->light_threshold_number_->state;
|
||||
}
|
||||
#endif
|
||||
#ifdef USE_SELECT
|
||||
if (this->light_function_select_ != nullptr && this->light_function_select_->has_state()) {
|
||||
this->light_function_ = this->light_function_select_->state;
|
||||
}
|
||||
if (this->out_pin_level_select_ != nullptr && this->out_pin_level_select_->has_state()) {
|
||||
this->out_pin_level_ = this->out_pin_level_select_->state;
|
||||
}
|
||||
#endif
|
||||
if (this->light_function_.empty() || this->out_pin_level_.empty() || this->light_threshold_ < 0) {
|
||||
return;
|
||||
}
|
||||
this->set_config_mode_(true);
|
||||
uint8_t light_function = LIGHT_FUNCTION_ENUM_TO_INT.at(this->light_function_);
|
||||
uint8_t light_threshold = static_cast<uint8_t>(this->light_threshold_);
|
||||
uint8_t out_pin_level = OUT_PIN_LEVEL_ENUM_TO_INT.at(this->out_pin_level_);
|
||||
uint8_t value[4] = {light_function, light_threshold, out_pin_level, 0x00};
|
||||
this->send_command_(CMD_SET_LIGHT_CONTROL, value, 4);
|
||||
delay(50); // NOLINT
|
||||
this->get_light_control_();
|
||||
this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
|
||||
this->set_config_mode_(false);
|
||||
}
|
||||
|
||||
#ifdef USE_SENSOR
|
||||
void LD2410Component::set_gate_move_sensor(int gate, sensor::Sensor *s) { this->gate_move_sensors_[gate] = s; }
|
||||
void LD2410Component::set_gate_still_sensor(int gate, sensor::Sensor *s) { this->gate_still_sensors_[gate] = s; }
|
||||
#endif
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
||||
|
|
|
@ -7,10 +7,27 @@
|
|||
#ifdef USE_SENSOR
|
||||
#include "esphome/components/sensor/sensor.h"
|
||||
#endif
|
||||
#ifdef USE_NUMBER
|
||||
#include "esphome/components/number/number.h"
|
||||
#endif
|
||||
#ifdef USE_SWITCH
|
||||
#include "esphome/components/switch/switch.h"
|
||||
#endif
|
||||
#ifdef USE_BUTTON
|
||||
#include "esphome/components/button/button.h"
|
||||
#endif
|
||||
#ifdef USE_SELECT
|
||||
#include "esphome/components/select/select.h"
|
||||
#endif
|
||||
#ifdef USE_TEXT_SENSOR
|
||||
#include "esphome/components/text_sensor/text_sensor.h"
|
||||
#endif
|
||||
#include "esphome/components/uart/uart.h"
|
||||
#include "esphome/core/automation.h"
|
||||
#include "esphome/core/helpers.h"
|
||||
|
||||
#include <map>
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
|
@ -19,10 +36,63 @@ namespace ld2410 {
|
|||
// Commands
|
||||
static const uint8_t CMD_ENABLE_CONF = 0x00FF;
|
||||
static const uint8_t CMD_DISABLE_CONF = 0x00FE;
|
||||
static const uint8_t CMD_ENABLE_ENG = 0x0062;
|
||||
static const uint8_t CMD_DISABLE_ENG = 0x0063;
|
||||
static const uint8_t CMD_MAXDIST_DURATION = 0x0060;
|
||||
static const uint8_t CMD_QUERY = 0x0061;
|
||||
static const uint8_t CMD_GATE_SENS = 0x0064;
|
||||
static const uint8_t CMD_VERSION = 0x00A0;
|
||||
static const uint8_t CMD_QUERY_DISTANCE_RESOLUTION = 0x00AB;
|
||||
static const uint8_t CMD_SET_DISTANCE_RESOLUTION = 0x00AA;
|
||||
static const uint8_t CMD_QUERY_LIGHT_CONTROL = 0x00AE;
|
||||
static const uint8_t CMD_SET_LIGHT_CONTROL = 0x00AD;
|
||||
static const uint8_t CMD_SET_BAUD_RATE = 0x00A1;
|
||||
static const uint8_t CMD_BT_PASSWORD = 0x00A9;
|
||||
static const uint8_t CMD_MAC = 0x00A5;
|
||||
static const uint8_t CMD_RESET = 0x00A2;
|
||||
static const uint8_t CMD_RESTART = 0x00A3;
|
||||
static const uint8_t CMD_BLUETOOTH = 0x00A4;
|
||||
|
||||
enum BaudRateStructure : uint8_t {
|
||||
BAUD_RATE_9600 = 1,
|
||||
BAUD_RATE_19200 = 2,
|
||||
BAUD_RATE_38400 = 3,
|
||||
BAUD_RATE_57600 = 4,
|
||||
BAUD_RATE_115200 = 5,
|
||||
BAUD_RATE_230400 = 6,
|
||||
BAUD_RATE_256000 = 7,
|
||||
BAUD_RATE_460800 = 8
|
||||
};
|
||||
|
||||
static const std::map<std::string, uint8_t> BAUD_RATE_ENUM_TO_INT{
|
||||
{"9600", BAUD_RATE_9600}, {"19200", BAUD_RATE_19200}, {"38400", BAUD_RATE_38400},
|
||||
{"57600", BAUD_RATE_57600}, {"115200", BAUD_RATE_115200}, {"230400", BAUD_RATE_230400},
|
||||
{"256000", BAUD_RATE_256000}, {"460800", BAUD_RATE_460800}};
|
||||
|
||||
enum DistanceResolutionStructure : uint8_t { DISTANCE_RESOLUTION_0_2 = 0x01, DISTANCE_RESOLUTION_0_75 = 0x00 };
|
||||
|
||||
static const std::map<std::string, uint8_t> DISTANCE_RESOLUTION_ENUM_TO_INT{{"0.2m", DISTANCE_RESOLUTION_0_2},
|
||||
{"0.75m", DISTANCE_RESOLUTION_0_75}};
|
||||
static const std::map<uint8_t, std::string> DISTANCE_RESOLUTION_INT_TO_ENUM{{DISTANCE_RESOLUTION_0_2, "0.2m"},
|
||||
{DISTANCE_RESOLUTION_0_75, "0.75m"}};
|
||||
|
||||
enum LightFunctionStructure : uint8_t {
|
||||
LIGHT_FUNCTION_OFF = 0x00,
|
||||
LIGHT_FUNCTION_BELOW = 0x01,
|
||||
LIGHT_FUNCTION_ABOVE = 0x02
|
||||
};
|
||||
|
||||
static const std::map<std::string, uint8_t> LIGHT_FUNCTION_ENUM_TO_INT{
|
||||
{"off", LIGHT_FUNCTION_OFF}, {"below", LIGHT_FUNCTION_BELOW}, {"above", LIGHT_FUNCTION_ABOVE}};
|
||||
static const std::map<uint8_t, std::string> LIGHT_FUNCTION_INT_TO_ENUM{
|
||||
{LIGHT_FUNCTION_OFF, "off"}, {LIGHT_FUNCTION_BELOW, "below"}, {LIGHT_FUNCTION_ABOVE, "above"}};
|
||||
|
||||
enum OutPinLevelStructure : uint8_t { OUT_PIN_LEVEL_LOW = 0x00, OUT_PIN_LEVEL_HIGH = 0x01 };
|
||||
|
||||
static const std::map<std::string, uint8_t> OUT_PIN_LEVEL_ENUM_TO_INT{{"low", OUT_PIN_LEVEL_LOW},
|
||||
{"high", OUT_PIN_LEVEL_HIGH}};
|
||||
static const std::map<uint8_t, std::string> OUT_PIN_LEVEL_INT_TO_ENUM{{OUT_PIN_LEVEL_LOW, "low"},
|
||||
{OUT_PIN_LEVEL_HIGH, "high"}};
|
||||
|
||||
// Commands values
|
||||
static const uint8_t CMD_MAX_MOVE_VALUE = 0x0000;
|
||||
|
@ -44,7 +114,7 @@ Target states: 9th byte
|
|||
Detect distance: 16~17th bytes
|
||||
*/
|
||||
enum PeriodicDataStructure : uint8_t {
|
||||
DATA_TYPES = 5,
|
||||
DATA_TYPES = 6,
|
||||
TARGET_STATES = 8,
|
||||
MOVING_TARGET_LOW = 9,
|
||||
MOVING_TARGET_HIGH = 10,
|
||||
|
@ -54,6 +124,10 @@ enum PeriodicDataStructure : uint8_t {
|
|||
STILL_ENERGY = 14,
|
||||
DETECT_DISTANCE_LOW = 15,
|
||||
DETECT_DISTANCE_HIGH = 16,
|
||||
MOVING_SENSOR_START = 19,
|
||||
STILL_SENSOR_START = 28,
|
||||
LIGHT_SENSOR = 37,
|
||||
OUT_PIN_SENSOR = 38,
|
||||
};
|
||||
enum PeriodicDataValue : uint8_t { HEAD = 0XAA, END = 0x55, CHECK = 0x00 };
|
||||
|
||||
|
@ -66,80 +140,97 @@ class LD2410Component : public Component, public uart::UARTDevice {
|
|||
SUB_SENSOR(still_target_distance)
|
||||
SUB_SENSOR(moving_target_energy)
|
||||
SUB_SENSOR(still_target_energy)
|
||||
SUB_SENSOR(light)
|
||||
SUB_SENSOR(detection_distance)
|
||||
#endif
|
||||
#ifdef USE_BINARY_SENSOR
|
||||
SUB_BINARY_SENSOR(target)
|
||||
SUB_BINARY_SENSOR(moving_target)
|
||||
SUB_BINARY_SENSOR(still_target)
|
||||
SUB_BINARY_SENSOR(out_pin_presence_status)
|
||||
#endif
|
||||
#ifdef USE_TEXT_SENSOR
|
||||
SUB_TEXT_SENSOR(version)
|
||||
SUB_TEXT_SENSOR(mac)
|
||||
#endif
|
||||
#ifdef USE_SELECT
|
||||
SUB_SELECT(distance_resolution)
|
||||
SUB_SELECT(baud_rate)
|
||||
SUB_SELECT(light_function)
|
||||
SUB_SELECT(out_pin_level)
|
||||
#endif
|
||||
#ifdef USE_SWITCH
|
||||
SUB_SWITCH(engineering_mode)
|
||||
SUB_SWITCH(bluetooth)
|
||||
#endif
|
||||
#ifdef USE_BUTTON
|
||||
SUB_BUTTON(reset)
|
||||
SUB_BUTTON(restart)
|
||||
SUB_BUTTON(query)
|
||||
#endif
|
||||
#ifdef USE_NUMBER
|
||||
SUB_NUMBER(max_still_distance_gate)
|
||||
SUB_NUMBER(max_move_distance_gate)
|
||||
SUB_NUMBER(timeout)
|
||||
SUB_NUMBER(light_threshold)
|
||||
#endif
|
||||
|
||||
public:
|
||||
LD2410Component();
|
||||
void setup() override;
|
||||
void dump_config() override;
|
||||
void loop() override;
|
||||
|
||||
#ifdef USE_BINARY_SENSOR
|
||||
void set_target_sensor(binary_sensor::BinarySensor *sens) { this->target_binary_sensor_ = sens; };
|
||||
void set_moving_target_sensor(binary_sensor::BinarySensor *sens) { this->moving_binary_sensor_ = sens; };
|
||||
void set_still_target_sensor(binary_sensor::BinarySensor *sens) { this->still_binary_sensor_ = sens; };
|
||||
void set_light_out_control();
|
||||
#ifdef USE_NUMBER
|
||||
void set_gate_still_threshold_number(int gate, number::Number *n);
|
||||
void set_gate_move_threshold_number(int gate, number::Number *n);
|
||||
void set_max_distances_timeout();
|
||||
void set_gate_threshold(uint8_t gate);
|
||||
#endif
|
||||
|
||||
void set_timeout(uint16_t value) { this->timeout_ = value; };
|
||||
void set_max_move_distance(uint8_t value) { this->max_move_distance_ = value; };
|
||||
void set_max_still_distance(uint8_t value) { this->max_still_distance_ = value; };
|
||||
void set_range_config(int rg0_move, int rg0_still, int rg1_move, int rg1_still, int rg2_move, int rg2_still,
|
||||
int rg3_move, int rg3_still, int rg4_move, int rg4_still, int rg5_move, int rg5_still,
|
||||
int rg6_move, int rg6_still, int rg7_move, int rg7_still, int rg8_move, int rg8_still) {
|
||||
this->rg0_move_threshold_ = rg0_move;
|
||||
this->rg0_still_threshold_ = rg0_still;
|
||||
this->rg1_move_threshold_ = rg1_move;
|
||||
this->rg1_still_threshold_ = rg1_still;
|
||||
this->rg2_move_threshold_ = rg2_move;
|
||||
this->rg2_still_threshold_ = rg2_still;
|
||||
this->rg3_move_threshold_ = rg3_move;
|
||||
this->rg3_still_threshold_ = rg3_still;
|
||||
this->rg4_move_threshold_ = rg4_move;
|
||||
this->rg4_still_threshold_ = rg4_still;
|
||||
this->rg5_move_threshold_ = rg5_move;
|
||||
this->rg5_still_threshold_ = rg5_still;
|
||||
this->rg6_move_threshold_ = rg6_move;
|
||||
this->rg6_still_threshold_ = rg6_still;
|
||||
this->rg7_move_threshold_ = rg7_move;
|
||||
this->rg7_still_threshold_ = rg7_still;
|
||||
this->rg8_move_threshold_ = rg8_move;
|
||||
this->rg8_still_threshold_ = rg8_still;
|
||||
};
|
||||
int moving_sensitivities[9] = {0};
|
||||
int still_sensitivities[9] = {0};
|
||||
|
||||
int32_t last_periodic_millis = millis();
|
||||
#ifdef USE_SENSOR
|
||||
void set_gate_move_sensor(int gate, sensor::Sensor *s);
|
||||
void set_gate_still_sensor(int gate, sensor::Sensor *s);
|
||||
#endif
|
||||
void set_throttle(uint16_t value) { this->throttle_ = value; };
|
||||
void set_bluetooth_password(const std::string &password);
|
||||
void set_engineering_mode(bool enable);
|
||||
void read_all_info();
|
||||
void restart_and_read_all_info();
|
||||
void set_bluetooth(bool enable);
|
||||
void set_distance_resolution(const std::string &state);
|
||||
void set_baud_rate(const std::string &state);
|
||||
void factory_reset();
|
||||
|
||||
protected:
|
||||
#ifdef USE_BINARY_SENSOR
|
||||
binary_sensor::BinarySensor *target_binary_sensor_{nullptr};
|
||||
binary_sensor::BinarySensor *moving_binary_sensor_{nullptr};
|
||||
binary_sensor::BinarySensor *still_binary_sensor_{nullptr};
|
||||
#endif
|
||||
|
||||
std::vector<uint8_t> rx_buffer_;
|
||||
int two_byte_to_int_(char firstbyte, char secondbyte) { return (int16_t) (secondbyte << 8) + firstbyte; }
|
||||
void send_command_(uint8_t command_str, uint8_t *command_value, int command_value_len);
|
||||
|
||||
void set_max_distances_timeout_(uint8_t max_moving_distance_range, uint8_t max_still_distance_range,
|
||||
uint16_t timeout);
|
||||
void set_gate_threshold_(uint8_t gate, uint8_t motionsens, uint8_t stillsens);
|
||||
void send_command_(uint8_t command_str, const uint8_t *command_value, int command_value_len);
|
||||
void set_config_mode_(bool enable);
|
||||
void handle_periodic_data_(uint8_t *buffer, int len);
|
||||
void handle_ack_data_(uint8_t *buffer, int len);
|
||||
bool handle_ack_data_(uint8_t *buffer, int len);
|
||||
void readline_(int readch, uint8_t *buffer, int len);
|
||||
void query_parameters_();
|
||||
void get_version_();
|
||||
void get_mac_();
|
||||
void get_distance_resolution_();
|
||||
void get_light_control_();
|
||||
void restart_();
|
||||
|
||||
uint16_t timeout_;
|
||||
uint8_t max_move_distance_;
|
||||
uint8_t max_still_distance_;
|
||||
|
||||
uint8_t version_[6];
|
||||
uint8_t rg0_move_threshold_, rg0_still_threshold_, rg1_move_threshold_, rg1_still_threshold_, rg2_move_threshold_,
|
||||
rg2_still_threshold_, rg3_move_threshold_, rg3_still_threshold_, rg4_move_threshold_, rg4_still_threshold_,
|
||||
rg5_move_threshold_, rg5_still_threshold_, rg6_move_threshold_, rg6_still_threshold_, rg7_move_threshold_,
|
||||
rg7_still_threshold_, rg8_move_threshold_, rg8_still_threshold_;
|
||||
int32_t last_periodic_millis_ = millis();
|
||||
int32_t last_engineering_mode_change_millis_ = millis();
|
||||
uint16_t throttle_;
|
||||
std::string version_;
|
||||
std::string mac_;
|
||||
std::string out_pin_level_;
|
||||
std::string light_function_;
|
||||
float light_threshold_ = -1;
|
||||
#ifdef USE_NUMBER
|
||||
std::vector<number::Number *> gate_still_threshold_numbers_ = std::vector<number::Number *>(9);
|
||||
std::vector<number::Number *> gate_move_threshold_numbers_ = std::vector<number::Number *>(9);
|
||||
#endif
|
||||
#ifdef USE_SENSOR
|
||||
std::vector<sensor::Sensor *> gate_still_sensors_ = std::vector<sensor::Sensor *>(9);
|
||||
std::vector<sensor::Sensor *> gate_move_sensors_ = std::vector<sensor::Sensor *>(9);
|
||||
#endif
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
|
|
128
esphome/components/ld2410/number/__init__.py
Normal file
128
esphome/components/ld2410/number/__init__.py
Normal file
|
@ -0,0 +1,128 @@
|
|||
import esphome.codegen as cg
|
||||
from esphome.components import number
|
||||
import esphome.config_validation as cv
|
||||
from esphome.const import (
|
||||
CONF_ID,
|
||||
CONF_TIMEOUT,
|
||||
DEVICE_CLASS_DISTANCE,
|
||||
DEVICE_CLASS_SIGNAL_STRENGTH,
|
||||
DEVICE_CLASS_ILLUMINANCE,
|
||||
UNIT_SECOND,
|
||||
UNIT_PERCENT,
|
||||
ENTITY_CATEGORY_CONFIG,
|
||||
ICON_MOTION_SENSOR,
|
||||
ICON_TIMELAPSE,
|
||||
ICON_LIGHTBULB,
|
||||
)
|
||||
from .. import CONF_LD2410_ID, LD2410Component, ld2410_ns
|
||||
|
||||
GateThresholdNumber = ld2410_ns.class_("GateThresholdNumber", number.Number)
|
||||
LightThresholdNumber = ld2410_ns.class_("LightThresholdNumber", number.Number)
|
||||
MaxDistanceTimeoutNumber = ld2410_ns.class_("MaxDistanceTimeoutNumber", number.Number)
|
||||
|
||||
CONF_MAX_MOVE_DISTANCE_GATE = "max_move_distance_gate"
|
||||
CONF_MAX_STILL_DISTANCE_GATE = "max_still_distance_gate"
|
||||
CONF_LIGHT_THRESHOLD = "light_threshold"
|
||||
CONF_STILL_THRESHOLD = "still_threshold"
|
||||
CONF_MOVE_THRESHOLD = "move_threshold"
|
||||
|
||||
TIMEOUT_GROUP = "timeout"
|
||||
|
||||
CONFIG_SCHEMA = cv.Schema(
|
||||
{
|
||||
cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
|
||||
cv.Inclusive(CONF_TIMEOUT, TIMEOUT_GROUP): number.number_schema(
|
||||
MaxDistanceTimeoutNumber,
|
||||
unit_of_measurement=UNIT_SECOND,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_TIMELAPSE,
|
||||
),
|
||||
cv.Inclusive(CONF_MAX_MOVE_DISTANCE_GATE, TIMEOUT_GROUP): number.number_schema(
|
||||
MaxDistanceTimeoutNumber,
|
||||
device_class=DEVICE_CLASS_DISTANCE,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_MOTION_SENSOR,
|
||||
),
|
||||
cv.Inclusive(CONF_MAX_STILL_DISTANCE_GATE, TIMEOUT_GROUP): number.number_schema(
|
||||
MaxDistanceTimeoutNumber,
|
||||
device_class=DEVICE_CLASS_DISTANCE,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_MOTION_SENSOR,
|
||||
),
|
||||
cv.Optional(CONF_LIGHT_THRESHOLD): number.number_schema(
|
||||
LightThresholdNumber,
|
||||
device_class=DEVICE_CLASS_ILLUMINANCE,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_LIGHTBULB,
|
||||
),
|
||||
}
|
||||
)
|
||||
|
||||
CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
|
||||
{
|
||||
cv.Optional(f"g{x}"): cv.Schema(
|
||||
{
|
||||
cv.Required(CONF_MOVE_THRESHOLD): number.number_schema(
|
||||
GateThresholdNumber,
|
||||
device_class=DEVICE_CLASS_SIGNAL_STRENGTH,
|
||||
unit_of_measurement=UNIT_PERCENT,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_MOTION_SENSOR,
|
||||
),
|
||||
cv.Required(CONF_STILL_THRESHOLD): number.number_schema(
|
||||
GateThresholdNumber,
|
||||
device_class=DEVICE_CLASS_SIGNAL_STRENGTH,
|
||||
unit_of_measurement=UNIT_PERCENT,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_MOTION_SENSOR,
|
||||
),
|
||||
}
|
||||
)
|
||||
for x in range(9)
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
async def to_code(config):
|
||||
ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
|
||||
if timeout_config := config.get(CONF_TIMEOUT):
|
||||
n = await number.new_number(
|
||||
timeout_config, min_value=0, max_value=65535, step=1
|
||||
)
|
||||
await cg.register_parented(n, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_timeout_number(n))
|
||||
if max_move_distance_gate_config := config.get(CONF_MAX_MOVE_DISTANCE_GATE):
|
||||
n = await number.new_number(
|
||||
max_move_distance_gate_config, min_value=2, max_value=8, step=1
|
||||
)
|
||||
await cg.register_parented(n, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_max_move_distance_gate_number(n))
|
||||
if max_still_distance_gate_config := config.get(CONF_MAX_STILL_DISTANCE_GATE):
|
||||
n = await number.new_number(
|
||||
max_still_distance_gate_config, min_value=2, max_value=8, step=1
|
||||
)
|
||||
await cg.register_parented(n, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_max_still_distance_gate_number(n))
|
||||
if light_threshold_config := config.get(CONF_LIGHT_THRESHOLD):
|
||||
n = await number.new_number(
|
||||
light_threshold_config, min_value=0, max_value=255, step=1
|
||||
)
|
||||
await cg.register_parented(n, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_light_threshold_number(n))
|
||||
for x in range(9):
|
||||
if gate_conf := config.get(f"g{x}"):
|
||||
move_config = gate_conf[CONF_MOVE_THRESHOLD]
|
||||
n = cg.new_Pvariable(move_config[CONF_ID], x)
|
||||
await number.register_number(
|
||||
n, move_config, min_value=0, max_value=100, step=1
|
||||
)
|
||||
await cg.register_parented(n, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_gate_move_threshold_number(x, n))
|
||||
|
||||
still_config = gate_conf[CONF_STILL_THRESHOLD]
|
||||
n = cg.new_Pvariable(still_config[CONF_ID], x)
|
||||
await number.register_number(
|
||||
n, still_config, min_value=0, max_value=100, step=1
|
||||
)
|
||||
await cg.register_parented(n, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_gate_still_threshold_number(x, n))
|
14
esphome/components/ld2410/number/gate_threshold_number.cpp
Normal file
14
esphome/components/ld2410/number/gate_threshold_number.cpp
Normal file
|
@ -0,0 +1,14 @@
|
|||
#include "gate_threshold_number.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
GateThresholdNumber::GateThresholdNumber(uint8_t gate) : gate_(gate) {}
|
||||
|
||||
void GateThresholdNumber::control(float value) {
|
||||
this->publish_state(value);
|
||||
this->parent_->set_gate_threshold(this->gate_);
|
||||
}
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
19
esphome/components/ld2410/number/gate_threshold_number.h
Normal file
19
esphome/components/ld2410/number/gate_threshold_number.h
Normal file
|
@ -0,0 +1,19 @@
|
|||
#pragma once
|
||||
|
||||
#include "esphome/components/number/number.h"
|
||||
#include "../ld2410.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
class GateThresholdNumber : public number::Number, public Parented<LD2410Component> {
|
||||
public:
|
||||
GateThresholdNumber(uint8_t gate);
|
||||
|
||||
protected:
|
||||
uint8_t gate_;
|
||||
void control(float value) override;
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
12
esphome/components/ld2410/number/light_threshold_number.cpp
Normal file
12
esphome/components/ld2410/number/light_threshold_number.cpp
Normal file
|
@ -0,0 +1,12 @@
|
|||
#include "light_threshold_number.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
void LightThresholdNumber::control(float value) {
|
||||
this->publish_state(value);
|
||||
this->parent_->set_light_out_control();
|
||||
}
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
18
esphome/components/ld2410/number/light_threshold_number.h
Normal file
18
esphome/components/ld2410/number/light_threshold_number.h
Normal file
|
@ -0,0 +1,18 @@
|
|||
#pragma once
|
||||
|
||||
#include "esphome/components/number/number.h"
|
||||
#include "../ld2410.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
class LightThresholdNumber : public number::Number, public Parented<LD2410Component> {
|
||||
public:
|
||||
LightThresholdNumber() = default;
|
||||
|
||||
protected:
|
||||
void control(float value) override;
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
|
@ -0,0 +1,12 @@
|
|||
#include "max_distance_timeout_number.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
void MaxDistanceTimeoutNumber::control(float value) {
|
||||
this->publish_state(value);
|
||||
this->parent_->set_max_distances_timeout();
|
||||
}
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
|
@ -0,0 +1,18 @@
|
|||
#pragma once
|
||||
|
||||
#include "esphome/components/number/number.h"
|
||||
#include "../ld2410.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
class MaxDistanceTimeoutNumber : public number::Number, public Parented<LD2410Component> {
|
||||
public:
|
||||
MaxDistanceTimeoutNumber() = default;
|
||||
|
||||
protected:
|
||||
void control(float value) override;
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
81
esphome/components/ld2410/select/__init__.py
Normal file
81
esphome/components/ld2410/select/__init__.py
Normal file
|
@ -0,0 +1,81 @@
|
|||
import esphome.codegen as cg
|
||||
from esphome.components import select
|
||||
import esphome.config_validation as cv
|
||||
from esphome.const import (
|
||||
ENTITY_CATEGORY_CONFIG,
|
||||
CONF_BAUD_RATE,
|
||||
ICON_THERMOMETER,
|
||||
ICON_SCALE,
|
||||
ICON_LIGHTBULB,
|
||||
ICON_RULER,
|
||||
)
|
||||
from .. import CONF_LD2410_ID, LD2410Component, ld2410_ns
|
||||
|
||||
BaudRateSelect = ld2410_ns.class_("BaudRateSelect", select.Select)
|
||||
DistanceResolutionSelect = ld2410_ns.class_("DistanceResolutionSelect", select.Select)
|
||||
LightOutControlSelect = ld2410_ns.class_("LightOutControlSelect", select.Select)
|
||||
|
||||
CONF_DISTANCE_RESOLUTION = "distance_resolution"
|
||||
CONF_LIGHT_FUNCTION = "light_function"
|
||||
CONF_OUT_PIN_LEVEL = "out_pin_level"
|
||||
|
||||
|
||||
CONFIG_SCHEMA = {
|
||||
cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
|
||||
cv.Optional(CONF_DISTANCE_RESOLUTION): select.select_schema(
|
||||
DistanceResolutionSelect,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_RULER,
|
||||
),
|
||||
cv.Optional(CONF_LIGHT_FUNCTION): select.select_schema(
|
||||
LightOutControlSelect,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_LIGHTBULB,
|
||||
),
|
||||
cv.Optional(CONF_OUT_PIN_LEVEL): select.select_schema(
|
||||
LightOutControlSelect,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_SCALE,
|
||||
),
|
||||
cv.Optional(CONF_BAUD_RATE): select.select_schema(
|
||||
BaudRateSelect,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_THERMOMETER,
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
async def to_code(config):
|
||||
ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
|
||||
if distance_resolution_config := config.get(CONF_DISTANCE_RESOLUTION):
|
||||
s = await select.new_select(
|
||||
distance_resolution_config, options=["0.2m", "0.75m"]
|
||||
)
|
||||
await cg.register_parented(s, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_distance_resolution_select(s))
|
||||
if out_pin_level_config := config.get(CONF_OUT_PIN_LEVEL):
|
||||
s = await select.new_select(out_pin_level_config, options=["low", "high"])
|
||||
await cg.register_parented(s, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_out_pin_level_select(s))
|
||||
if light_function_config := config.get(CONF_LIGHT_FUNCTION):
|
||||
s = await select.new_select(
|
||||
light_function_config, options=["off", "below", "above"]
|
||||
)
|
||||
await cg.register_parented(s, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_light_function_select(s))
|
||||
if baud_rate_config := config.get(CONF_BAUD_RATE):
|
||||
s = await select.new_select(
|
||||
baud_rate_config,
|
||||
options=[
|
||||
"9600",
|
||||
"19200",
|
||||
"38400",
|
||||
"57600",
|
||||
"115200",
|
||||
"230400",
|
||||
"256000",
|
||||
"460800",
|
||||
],
|
||||
)
|
||||
await cg.register_parented(s, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_baud_rate_select(s))
|
12
esphome/components/ld2410/select/baud_rate_select.cpp
Normal file
12
esphome/components/ld2410/select/baud_rate_select.cpp
Normal file
|
@ -0,0 +1,12 @@
|
|||
#include "baud_rate_select.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
void BaudRateSelect::control(const std::string &value) {
|
||||
this->publish_state(value);
|
||||
this->parent_->set_baud_rate(state);
|
||||
}
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
18
esphome/components/ld2410/select/baud_rate_select.h
Normal file
18
esphome/components/ld2410/select/baud_rate_select.h
Normal file
|
@ -0,0 +1,18 @@
|
|||
#pragma once
|
||||
|
||||
#include "esphome/components/select/select.h"
|
||||
#include "../ld2410.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
class BaudRateSelect : public select::Select, public Parented<LD2410Component> {
|
||||
public:
|
||||
BaudRateSelect() = default;
|
||||
|
||||
protected:
|
||||
void control(const std::string &value) override;
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
|
@ -0,0 +1,12 @@
|
|||
#include "distance_resolution_select.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
void DistanceResolutionSelect::control(const std::string &value) {
|
||||
this->publish_state(value);
|
||||
this->parent_->set_distance_resolution(state);
|
||||
}
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
|
@ -0,0 +1,18 @@
|
|||
#pragma once
|
||||
|
||||
#include "esphome/components/select/select.h"
|
||||
#include "../ld2410.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
class DistanceResolutionSelect : public select::Select, public Parented<LD2410Component> {
|
||||
public:
|
||||
DistanceResolutionSelect() = default;
|
||||
|
||||
protected:
|
||||
void control(const std::string &value) override;
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
|
@ -0,0 +1,12 @@
|
|||
#include "light_out_control_select.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
void LightOutControlSelect::control(const std::string &value) {
|
||||
this->publish_state(value);
|
||||
this->parent_->set_light_out_control();
|
||||
}
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
18
esphome/components/ld2410/select/light_out_control_select.h
Normal file
18
esphome/components/ld2410/select/light_out_control_select.h
Normal file
|
@ -0,0 +1,18 @@
|
|||
#pragma once
|
||||
|
||||
#include "esphome/components/select/select.h"
|
||||
#include "../ld2410.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
class LightOutControlSelect : public select::Select, public Parented<LD2410Component> {
|
||||
public:
|
||||
LightOutControlSelect() = default;
|
||||
|
||||
protected:
|
||||
void control(const std::string &value) override;
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
|
@ -3,9 +3,15 @@ from esphome.components import sensor
|
|||
import esphome.config_validation as cv
|
||||
from esphome.const import (
|
||||
DEVICE_CLASS_DISTANCE,
|
||||
DEVICE_CLASS_ENERGY,
|
||||
UNIT_CENTIMETER,
|
||||
UNIT_PERCENT,
|
||||
CONF_LIGHT,
|
||||
DEVICE_CLASS_ILLUMINANCE,
|
||||
ENTITY_CATEGORY_DIAGNOSTIC,
|
||||
ICON_SIGNAL,
|
||||
ICON_FLASH,
|
||||
ICON_MOTION_SENSOR,
|
||||
ICON_LIGHTBULB,
|
||||
)
|
||||
from . import CONF_LD2410_ID, LD2410Component
|
||||
|
||||
|
@ -15,41 +21,88 @@ CONF_STILL_DISTANCE = "still_distance"
|
|||
CONF_MOVING_ENERGY = "moving_energy"
|
||||
CONF_STILL_ENERGY = "still_energy"
|
||||
CONF_DETECTION_DISTANCE = "detection_distance"
|
||||
CONF_MOVE_ENERGY = "move_energy"
|
||||
|
||||
CONFIG_SCHEMA = {
|
||||
cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
|
||||
cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
|
||||
device_class=DEVICE_CLASS_DISTANCE, unit_of_measurement=UNIT_CENTIMETER
|
||||
),
|
||||
cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
|
||||
device_class=DEVICE_CLASS_DISTANCE, unit_of_measurement=UNIT_CENTIMETER
|
||||
),
|
||||
cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
|
||||
device_class=DEVICE_CLASS_ENERGY, unit_of_measurement=UNIT_PERCENT
|
||||
),
|
||||
cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
|
||||
device_class=DEVICE_CLASS_ENERGY, unit_of_measurement=UNIT_PERCENT
|
||||
),
|
||||
cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
|
||||
device_class=DEVICE_CLASS_DISTANCE, unit_of_measurement=UNIT_CENTIMETER
|
||||
),
|
||||
}
|
||||
CONFIG_SCHEMA = cv.Schema(
|
||||
{
|
||||
cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
|
||||
cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
|
||||
device_class=DEVICE_CLASS_DISTANCE,
|
||||
unit_of_measurement=UNIT_CENTIMETER,
|
||||
icon=ICON_SIGNAL,
|
||||
),
|
||||
cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
|
||||
device_class=DEVICE_CLASS_DISTANCE,
|
||||
unit_of_measurement=UNIT_CENTIMETER,
|
||||
icon=ICON_SIGNAL,
|
||||
),
|
||||
cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
|
||||
unit_of_measurement=UNIT_PERCENT,
|
||||
icon=ICON_MOTION_SENSOR,
|
||||
),
|
||||
cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
|
||||
unit_of_measurement=UNIT_PERCENT,
|
||||
icon=ICON_FLASH,
|
||||
),
|
||||
cv.Optional(CONF_LIGHT): sensor.sensor_schema(
|
||||
device_class=DEVICE_CLASS_ILLUMINANCE,
|
||||
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
|
||||
icon=ICON_LIGHTBULB,
|
||||
),
|
||||
cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
|
||||
device_class=DEVICE_CLASS_DISTANCE,
|
||||
unit_of_measurement=UNIT_CENTIMETER,
|
||||
icon=ICON_SIGNAL,
|
||||
),
|
||||
}
|
||||
)
|
||||
|
||||
CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
|
||||
{
|
||||
cv.Optional(f"g{x}"): cv.Schema(
|
||||
{
|
||||
cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
|
||||
unit_of_measurement=UNIT_PERCENT,
|
||||
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
|
||||
icon=ICON_MOTION_SENSOR,
|
||||
),
|
||||
cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
|
||||
unit_of_measurement=UNIT_PERCENT,
|
||||
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
|
||||
icon=ICON_FLASH,
|
||||
),
|
||||
}
|
||||
)
|
||||
for x in range(9)
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
async def to_code(config):
|
||||
ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
|
||||
if CONF_MOVING_DISTANCE in config:
|
||||
sens = await sensor.new_sensor(config[CONF_MOVING_DISTANCE])
|
||||
if moving_distance_config := config.get(CONF_MOVING_DISTANCE):
|
||||
sens = await sensor.new_sensor(moving_distance_config)
|
||||
cg.add(ld2410_component.set_moving_target_distance_sensor(sens))
|
||||
if CONF_STILL_DISTANCE in config:
|
||||
sens = await sensor.new_sensor(config[CONF_STILL_DISTANCE])
|
||||
if still_distance_config := config.get(CONF_STILL_DISTANCE):
|
||||
sens = await sensor.new_sensor(still_distance_config)
|
||||
cg.add(ld2410_component.set_still_target_distance_sensor(sens))
|
||||
if CONF_MOVING_ENERGY in config:
|
||||
sens = await sensor.new_sensor(config[CONF_MOVING_ENERGY])
|
||||
if moving_energy_config := config.get(CONF_MOVING_ENERGY):
|
||||
sens = await sensor.new_sensor(moving_energy_config)
|
||||
cg.add(ld2410_component.set_moving_target_energy_sensor(sens))
|
||||
if CONF_STILL_ENERGY in config:
|
||||
sens = await sensor.new_sensor(config[CONF_STILL_ENERGY])
|
||||
if still_energy_config := config.get(CONF_STILL_ENERGY):
|
||||
sens = await sensor.new_sensor(still_energy_config)
|
||||
cg.add(ld2410_component.set_still_target_energy_sensor(sens))
|
||||
if CONF_DETECTION_DISTANCE in config:
|
||||
sens = await sensor.new_sensor(config[CONF_DETECTION_DISTANCE])
|
||||
if light_config := config.get(CONF_LIGHT):
|
||||
sens = await sensor.new_sensor(light_config)
|
||||
cg.add(ld2410_component.set_light_sensor(sens))
|
||||
if detection_distance_config := config.get(CONF_DETECTION_DISTANCE):
|
||||
sens = await sensor.new_sensor(detection_distance_config)
|
||||
cg.add(ld2410_component.set_detection_distance_sensor(sens))
|
||||
for x in range(9):
|
||||
if gate_conf := config.get(f"g{x}"):
|
||||
if move_config := gate_conf.get(CONF_MOVE_ENERGY):
|
||||
sens = await sensor.new_sensor(move_config)
|
||||
cg.add(ld2410_component.set_gate_move_sensor(x, sens))
|
||||
if still_config := gate_conf.get(CONF_STILL_ENERGY):
|
||||
sens = await sensor.new_sensor(still_config)
|
||||
cg.add(ld2410_component.set_gate_still_sensor(x, sens))
|
||||
|
|
44
esphome/components/ld2410/switch/__init__.py
Normal file
44
esphome/components/ld2410/switch/__init__.py
Normal file
|
@ -0,0 +1,44 @@
|
|||
import esphome.codegen as cg
|
||||
from esphome.components import switch
|
||||
import esphome.config_validation as cv
|
||||
from esphome.const import (
|
||||
DEVICE_CLASS_SWITCH,
|
||||
ICON_BLUETOOTH,
|
||||
ENTITY_CATEGORY_CONFIG,
|
||||
ICON_PULSE,
|
||||
)
|
||||
from .. import CONF_LD2410_ID, LD2410Component, ld2410_ns
|
||||
|
||||
BluetoothSwitch = ld2410_ns.class_("BluetoothSwitch", switch.Switch)
|
||||
EngineeringModeSwitch = ld2410_ns.class_("EngineeringModeSwitch", switch.Switch)
|
||||
|
||||
CONF_ENGINEERING_MODE = "engineering_mode"
|
||||
CONF_BLUETOOTH = "bluetooth"
|
||||
|
||||
CONFIG_SCHEMA = {
|
||||
cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
|
||||
cv.Optional(CONF_ENGINEERING_MODE): switch.switch_schema(
|
||||
EngineeringModeSwitch,
|
||||
device_class=DEVICE_CLASS_SWITCH,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_PULSE,
|
||||
),
|
||||
cv.Optional(CONF_BLUETOOTH): switch.switch_schema(
|
||||
BluetoothSwitch,
|
||||
device_class=DEVICE_CLASS_SWITCH,
|
||||
entity_category=ENTITY_CATEGORY_CONFIG,
|
||||
icon=ICON_BLUETOOTH,
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
async def to_code(config):
|
||||
ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
|
||||
if engineering_mode_config := config.get(CONF_ENGINEERING_MODE):
|
||||
s = await switch.new_switch(engineering_mode_config)
|
||||
await cg.register_parented(s, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_engineering_mode_switch(s))
|
||||
if bluetooth_config := config.get(CONF_BLUETOOTH):
|
||||
s = await switch.new_switch(bluetooth_config)
|
||||
await cg.register_parented(s, config[CONF_LD2410_ID])
|
||||
cg.add(ld2410_component.set_bluetooth_switch(s))
|
12
esphome/components/ld2410/switch/bluetooth_switch.cpp
Normal file
12
esphome/components/ld2410/switch/bluetooth_switch.cpp
Normal file
|
@ -0,0 +1,12 @@
|
|||
#include "bluetooth_switch.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
void BluetoothSwitch::write_state(bool state) {
|
||||
this->publish_state(state);
|
||||
this->parent_->set_bluetooth(state);
|
||||
}
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
18
esphome/components/ld2410/switch/bluetooth_switch.h
Normal file
18
esphome/components/ld2410/switch/bluetooth_switch.h
Normal file
|
@ -0,0 +1,18 @@
|
|||
#pragma once
|
||||
|
||||
#include "esphome/components/switch/switch.h"
|
||||
#include "../ld2410.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
class BluetoothSwitch : public switch_::Switch, public Parented<LD2410Component> {
|
||||
public:
|
||||
BluetoothSwitch() = default;
|
||||
|
||||
protected:
|
||||
void write_state(bool state) override;
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
12
esphome/components/ld2410/switch/engineering_mode_switch.cpp
Normal file
12
esphome/components/ld2410/switch/engineering_mode_switch.cpp
Normal file
|
@ -0,0 +1,12 @@
|
|||
#include "engineering_mode_switch.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
void EngineeringModeSwitch::write_state(bool state) {
|
||||
this->publish_state(state);
|
||||
this->parent_->set_engineering_mode(state);
|
||||
}
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
18
esphome/components/ld2410/switch/engineering_mode_switch.h
Normal file
18
esphome/components/ld2410/switch/engineering_mode_switch.h
Normal file
|
@ -0,0 +1,18 @@
|
|||
#pragma once
|
||||
|
||||
#include "esphome/components/switch/switch.h"
|
||||
#include "../ld2410.h"
|
||||
|
||||
namespace esphome {
|
||||
namespace ld2410 {
|
||||
|
||||
class EngineeringModeSwitch : public switch_::Switch, public Parented<LD2410Component> {
|
||||
public:
|
||||
EngineeringModeSwitch() = default;
|
||||
|
||||
protected:
|
||||
void write_state(bool state) override;
|
||||
};
|
||||
|
||||
} // namespace ld2410
|
||||
} // namespace esphome
|
33
esphome/components/ld2410/text_sensor.py
Normal file
33
esphome/components/ld2410/text_sensor.py
Normal file
|
@ -0,0 +1,33 @@
|
|||
import esphome.codegen as cg
|
||||
from esphome.components import text_sensor
|
||||
import esphome.config_validation as cv
|
||||
from esphome.const import (
|
||||
ENTITY_CATEGORY_DIAGNOSTIC,
|
||||
CONF_VERSION,
|
||||
CONF_MAC_ADDRESS,
|
||||
ICON_BLUETOOTH,
|
||||
ICON_CHIP,
|
||||
)
|
||||
from . import CONF_LD2410_ID, LD2410Component
|
||||
|
||||
DEPENDENCIES = ["ld2410"]
|
||||
|
||||
CONFIG_SCHEMA = {
|
||||
cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
|
||||
cv.Optional(CONF_VERSION): text_sensor.text_sensor_schema(
|
||||
entity_category=ENTITY_CATEGORY_DIAGNOSTIC, icon=ICON_CHIP
|
||||
),
|
||||
cv.Optional(CONF_MAC_ADDRESS): text_sensor.text_sensor_schema(
|
||||
entity_category=ENTITY_CATEGORY_DIAGNOSTIC, icon=ICON_BLUETOOTH
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
async def to_code(config):
|
||||
ld2410_component = await cg.get_variable(config[CONF_LD2410_ID])
|
||||
if version_config := config.get(CONF_VERSION):
|
||||
sens = await text_sensor.new_text_sensor(version_config)
|
||||
cg.add(ld2410_component.set_version_text_sensor(sens))
|
||||
if mac_address_config := config.get(CONF_MAC_ADDRESS):
|
||||
sens = await text_sensor.new_text_sensor(mac_address_config)
|
||||
cg.add(ld2410_component.set_mac_text_sensor(sens))
|
149
tests/test1.yaml
149
tests/test1.yaml
|
@ -170,6 +170,9 @@ mqtt:
|
|||
id: uart_0
|
||||
data: !lambda |-
|
||||
return {};
|
||||
- bluetooth_password.set:
|
||||
id: my_ld2410
|
||||
password: abcdef
|
||||
on_connect:
|
||||
- light.turn_on: ${roomname}_lights
|
||||
- mqtt.publish:
|
||||
|
@ -1333,16 +1336,64 @@ sensor:
|
|||
speed:
|
||||
name: "Radiator Pump Speed"
|
||||
- platform: ld2410
|
||||
light:
|
||||
name: light
|
||||
moving_distance:
|
||||
name: "Moving distance (cm)"
|
||||
still_distance:
|
||||
name: "Still Distance (cm)"
|
||||
moving_energy:
|
||||
name: "Move Energy"
|
||||
name: "Move Energy (%)"
|
||||
still_energy:
|
||||
name: "Still Energy"
|
||||
name: "Still Energy (%)"
|
||||
detection_distance:
|
||||
name: "Distance Detection"
|
||||
name: "Distance Detection (cm)"
|
||||
g0:
|
||||
move_energy:
|
||||
name: g0 move energy
|
||||
still_energy:
|
||||
name: g0 still energy
|
||||
g1:
|
||||
move_energy:
|
||||
name: g1 move energy
|
||||
still_energy:
|
||||
name: g1 still energy
|
||||
g2:
|
||||
move_energy:
|
||||
name: g2 move energy
|
||||
still_energy:
|
||||
name: g2 still energy
|
||||
g3:
|
||||
move_energy:
|
||||
name: g3 move energy
|
||||
still_energy:
|
||||
name: g3 still energy
|
||||
g4:
|
||||
move_energy:
|
||||
name: g4 move energy
|
||||
still_energy:
|
||||
name: g4 still energy
|
||||
g5:
|
||||
move_energy:
|
||||
name: g5 move energy
|
||||
still_energy:
|
||||
name: g5 still energy
|
||||
g6:
|
||||
move_energy:
|
||||
name: g6 move energy
|
||||
still_energy:
|
||||
name: g6 still energy
|
||||
g7:
|
||||
move_energy:
|
||||
name: g7 move energy
|
||||
still_energy:
|
||||
name: g7 still energy
|
||||
g8:
|
||||
move_energy:
|
||||
name: g8 move energy
|
||||
still_energy:
|
||||
name: g8 still energy
|
||||
|
||||
- platform: sen21231
|
||||
name: "Person Sensor"
|
||||
i2c_id: i2c_bus
|
||||
|
@ -1684,6 +1735,8 @@ binary_sensor:
|
|||
name: movement
|
||||
has_still_target:
|
||||
name: still
|
||||
out_pin_presence_status:
|
||||
name: out pin presence status
|
||||
|
||||
pca9685:
|
||||
frequency: 500
|
||||
|
@ -2626,6 +2679,11 @@ switch:
|
|||
id: outlet_switch
|
||||
optimistic: true
|
||||
device_class: outlet
|
||||
- platform: ld2410
|
||||
engineering_mode:
|
||||
name: "control ld2410 engineering mode"
|
||||
bluetooth:
|
||||
name: "control ld2410 bluetooth"
|
||||
|
||||
fan:
|
||||
- platform: binary
|
||||
|
@ -3207,6 +3265,11 @@ text_sensor:
|
|||
tag_name: OPTARIF
|
||||
name: optarif
|
||||
teleinfo_id: myteleinfo
|
||||
- platform: ld2410
|
||||
version:
|
||||
name: "presenece sensor version"
|
||||
mac_address:
|
||||
name: "presenece sensor mac address"
|
||||
|
||||
sn74hc595:
|
||||
- id: sn74hc595_hub
|
||||
|
@ -3311,6 +3374,61 @@ number:
|
|||
step: 1
|
||||
max_value: 10
|
||||
optimistic: true
|
||||
- platform: ld2410
|
||||
light_threshold:
|
||||
name: light threshold
|
||||
timeout:
|
||||
name: timeout
|
||||
max_move_distance_gate:
|
||||
name: max move distance gate
|
||||
max_still_distance_gate:
|
||||
name: max still distance gate
|
||||
g0:
|
||||
move_threshold:
|
||||
name: g0 move threshold
|
||||
still_threshold:
|
||||
name: g0 still threshold
|
||||
g1:
|
||||
move_threshold:
|
||||
name: g1 move threshold
|
||||
still_threshold:
|
||||
name: g1 still threshold
|
||||
g2:
|
||||
move_threshold:
|
||||
name: g2 move threshold
|
||||
still_threshold:
|
||||
name: g2 still threshold
|
||||
g3:
|
||||
move_threshold:
|
||||
name: g3 move threshold
|
||||
still_threshold:
|
||||
name: g3 still threshold
|
||||
g4:
|
||||
move_threshold:
|
||||
name: g4 move threshold
|
||||
still_threshold:
|
||||
name: g4 still threshold
|
||||
g5:
|
||||
move_threshold:
|
||||
name: g5 move threshold
|
||||
still_threshold:
|
||||
name: g5 still threshold
|
||||
g6:
|
||||
move_threshold:
|
||||
name: g6 move threshold
|
||||
still_threshold:
|
||||
name: g6 still threshold
|
||||
g7:
|
||||
move_threshold:
|
||||
name: g7 move threshold
|
||||
still_threshold:
|
||||
name: g7 still threshold
|
||||
g8:
|
||||
move_threshold:
|
||||
name: g8 move threshold
|
||||
still_threshold:
|
||||
name: g8 still threshold
|
||||
|
||||
|
||||
select:
|
||||
- platform: template
|
||||
|
@ -3324,6 +3442,15 @@ select:
|
|||
- platform: copy
|
||||
source_id: test_select
|
||||
name: Test Select Copy
|
||||
- platform: ld2410
|
||||
distance_resolution:
|
||||
name: distance resolution
|
||||
baud_rate:
|
||||
name: baud rate
|
||||
light_function:
|
||||
name: light function
|
||||
out_pin_level:
|
||||
name: out ping level
|
||||
|
||||
qr_code:
|
||||
- id: homepage_qr
|
||||
|
@ -3386,19 +3513,17 @@ button:
|
|||
name: Midea Power Inverse
|
||||
on_press:
|
||||
midea_ac.power_toggle:
|
||||
- platform: ld2410
|
||||
factory_reset:
|
||||
name: "factory reset"
|
||||
restart:
|
||||
name: "restart"
|
||||
query_params:
|
||||
name: query params
|
||||
|
||||
ld2410:
|
||||
id: my_ld2410
|
||||
uart_id: ld2410_uart
|
||||
timeout: 150s
|
||||
max_move_distance: 6m
|
||||
max_still_distance: 0.75m
|
||||
g0_move_threshold: 10
|
||||
g0_still_threshold: 20
|
||||
g2_move_threshold: 20
|
||||
g2_still_threshold: 21
|
||||
g8_move_threshold: 80
|
||||
g8_still_threshold: 81
|
||||
|
||||
lcd_menu:
|
||||
display_id: my_lcd_gpio
|
||||
|
|
Loading…
Reference in a new issue