12static constexpr uint8_t SHORT_DATA_FRAME_HEADER = 0x6E;
13static constexpr uint8_t SHORT_DATA_FRAME_FOOTER[] PROGMEM = {0x62};
14static constexpr uint8_t SHORT_DATA_FRAME_SIZE = 5;
15static constexpr uint8_t STD_DATA_FRAME_HEADER[] PROGMEM = {0xF4, 0xF3, 0xF2, 0xF1};
16static constexpr uint8_t STD_DATA_FRAME_FOOTER[] PROGMEM = {0xF8, 0xF7, 0xF6, 0xF5};
17static constexpr uint8_t CMD_FRAME_HEADER[]
PROGMEM = {0xFD, 0xFC, 0xFB, 0xFA};
18static constexpr uint8_t CMD_FRAME_FOOTER[]
PROGMEM = {0x04, 0x03, 0x02, 0x01};
19static constexpr uint8_t LONG_HEADER_SIZE = 4;
20static constexpr uint8_t LENGTH_FIELD_SIZE = 2;
21static constexpr uint8_t LONG_PAYLOAD_POS = LONG_HEADER_SIZE + LENGTH_FIELD_SIZE;
23static constexpr uint16_t CMD_CONFIRMATION = 0x0100;
24static constexpr uint16_t CONFIG_MODE_START_CMD = 0x00FF;
25static constexpr uint16_t CONFIG_MODE_START_VALUE = 0x0001;
26static constexpr uint16_t CONFIG_MODE_END_CMD = 0x00FE;
27static constexpr uint16_t VERSION_READ_CMD = 0x0000;
28static constexpr uint16_t PARAMETERS_WRITE_CMD = 0x0070;
29static constexpr uint16_t PARAMETERS_READ_CMD = 0x0071;
30static constexpr uint16_t OUTPUT_MODE_SWITCH_CMD = 0x007A;
32static constexpr uint8_t OUTPUT_MODE_MINIMAL_SIZE = 6;
34static constexpr uint8_t PARAMETER_KEY_SIZE = 2;
35static constexpr uint8_t PARAMETER_VALUE_SIZE = 4;
36static constexpr uint8_t PARAMETERS_WRITE_SIZE =
PARAMETER_COUNT * (PARAMETER_KEY_SIZE + PARAMETER_VALUE_SIZE);
37static constexpr uint8_t CMD_FRAME_MAX_SIZE = LONG_PAYLOAD_POS + 2 + PARAMETERS_WRITE_SIZE +
sizeof(CMD_FRAME_FOOTER);
39#ifdef USE_LD2410S_PARAMETERS
40static constexpr uint16_t PARAMETER_KEYS[]
PROGMEM = {0x0005, 0x000A, 0x0006, 0x0002, 0x000C, 0x000B};
41static_assert(
sizeof(PARAMETER_KEYS) /
sizeof(PARAMETER_KEYS[0]) ==
PARAMETER_COUNT,
"one key per parameter");
44static constexpr float PARAMETER_SCALES[]
PROGMEM = {0.7f, 0.7f, 1.0f, 0.1f, 0.1f, 1.0f};
45static_assert(
sizeof(PARAMETER_SCALES) /
sizeof(PARAMETER_SCALES[0]) ==
PARAMETER_COUNT,
"one scale per parameter");
49static constexpr uint8_t VERSION_TYPE_SIZE = 4;
50static constexpr uint8_t VERSION_SIZE = VERSION_TYPE_SIZE + 3 * 2;
54static constexpr uint16_t INIT_SEQUENCE[]
PROGMEM = {
55 CONFIG_MODE_START_CMD,
56#ifdef USE_LD2410S_VERSION
59#ifdef USE_LD2410S_PARAMETERS
62 OUTPUT_MODE_SWITCH_CMD, CONFIG_MODE_END_CMD,
64#ifdef USE_LD2410S_PARAMETERS
65static constexpr uint16_t WRITE_SEQUENCE[]
PROGMEM = {CONFIG_MODE_START_CMD, PARAMETERS_WRITE_CMD, CONFIG_MODE_END_CMD};
67static constexpr uint8_t INIT_SEQUENCE_LENGTH =
sizeof(INIT_SEQUENCE) /
sizeof(INIT_SEQUENCE[0]);
68#ifdef USE_LD2410S_PARAMETERS
69static constexpr uint8_t WRITE_SEQUENCE_LENGTH =
sizeof(WRITE_SEQUENCE) /
sizeof(WRITE_SEQUENCE[0]);
71static constexpr uint8_t STEP_MAX_TIMEOUTS = 2;
72static constexpr uint32_t ACK_TIMEOUT_MS = 300;
73static constexpr uint32_t COMMAND_GAP_MS = 300;
74static constexpr uint32_t REINIT_PAUSE_MS = 15000;
75static constexpr uint32_t LINK_TIMEOUT_MS = 5000;
77static constexpr uint8_t DATA_TYPE_STANDARD = 0x01;
79void LD2410SComponent::dump_config() {
80 ESP_LOGCONFIG(TAG,
"LD2410S:");
81#ifdef USE_BINARY_SENSOR
82 LOG_BINARY_SENSOR(
" ",
"Has Target", this->target_binary_sensor_);
85 LOG_SENSOR_WITH_DEDUP(
" ",
"Distance", this->distance_sensor_);
87#ifdef USE_LD2410S_VERSION
88 LOG_TEXT_SENSOR(
" ",
"Version", this->version_text_sensor_);
90#if defined(USE_NUMBER) && defined(USE_LD2410S_PARAMETERS)
91 for (
auto *number : this->
numbers_) {
92 LOG_NUMBER(
" ",
"Setting", number);
95#if defined(USE_SELECT) && defined(USE_LD2410S_PARAMETERS)
96 LOG_SELECT(
" ",
"Response Speed", this->response_speed_select_);
102 ESP_LOGV(TAG,
"UART read failed");
108#ifdef USE_LD2410S_PARAMETERS
113 const bool in_gap = this->
next_send_at_ - now <= COMMAND_GAP_MS;
121 ESP_LOGW(TAG,
"No data for %" PRIu32
" s (%u frames dropped), starting over", LINK_TIMEOUT_MS / 1000,
128#ifdef USE_LD2410S_PARAMETERS
129bool LD2410SComponent::set_parameter(
Parameter parameter, uint8_t
value) {
132 ESP_LOGW(TAG,
"Parameters not read yet, change ignored");
136 ESP_LOGW(TAG,
"The module reported a parameter out of range, changes are disabled");
145void LD2410SComponent::control_number(number::Number *number,
float value) {
150 const uint8_t
raw = lroundf(
value / PARAMETER_SCALES[i]);
151 if (this->set_parameter(
static_cast<Parameter>(i),
raw))
152 number->publish_state(
raw * PARAMETER_SCALES[i]);
159void LD2410SComponent::control_response_speed(select::Select *select,
size_t index) {
161 select->publish_state(index);
169#ifdef USE_LD2410S_PARAMETERS
172 ESP_LOGW(TAG,
"Dropping the pending parameter change, the module's values are read back");
198 ESP_LOGW(TAG,
"No acknowledgement for command %04X, starting over in %" PRIu32
" s", command,
199 REINIT_PAUSE_MS / 1000);
205 ESP_LOGD(TAG,
"No acknowledgement for command %04X, resending", command);
213 uint8_t frame[CMD_FRAME_MAX_SIZE];
215 uint8_t
pos = LONG_PAYLOAD_POS;
216 frame[
pos++] = command & 0xFF;
217 frame[
pos++] = command >> 8;
219 case OUTPUT_MODE_SWITCH_CMD:
220 memset(&frame[
pos], 0, OUTPUT_MODE_MINIMAL_SIZE);
221 pos += OUTPUT_MODE_MINIMAL_SIZE;
223 case CONFIG_MODE_START_CMD:
224 frame[
pos++] = CONFIG_MODE_START_VALUE & 0xFF;
225 frame[
pos++] = CONFIG_MODE_START_VALUE >> 8;
227#ifdef USE_LD2410S_PARAMETERS
228 case PARAMETERS_READ_CMD:
229 case PARAMETERS_WRITE_CMD:
232 frame[
pos++] =
key & 0xFF;
234 if (command == PARAMETERS_WRITE_CMD) {
236 for (uint8_t shift = 0; shift < 32; shift += 8) {
237 frame[
pos++] = (
value >> shift) & 0xFF;
246 frame[LONG_HEADER_SIZE] =
pos - LONG_PAYLOAD_POS;
247 frame[LONG_HEADER_SIZE + 1] = 0;
249 pos +=
sizeof(CMD_FRAME_FOOTER);
251#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
258 if (this->
rx_len_ >= RX_BUFFER_SIZE) {
264 if (this->
rx_len_ == 1 &&
byte == SHORT_DATA_FRAME_HEADER) {
270 uint8_t std_header[LONG_HEADER_SIZE];
271 uint8_t cmd_header[LONG_HEADER_SIZE];
272 progmem_memcpy(std_header, STD_DATA_FRAME_HEADER, LONG_HEADER_SIZE);
274 const bool std_prefix = memcmp(this->
rx_buffer_, std_header, this->
rx_len_) == 0;
275 const bool cmd_prefix = memcmp(this->
rx_buffer_, cmd_header, this->
rx_len_) == 0;
276 if (std_prefix || cmd_prefix) {
277 if (this->
rx_len_ == LONG_HEADER_SIZE) {
283 const bool retry = this->
rx_len_ > 1;
292 if (this->
rx_len_ < LONG_PAYLOAD_POS) {
296 const uint16_t payload_len =
298 if (payload_len > RX_BUFFER_SIZE - LONG_PAYLOAD_POS -
sizeof(CMD_FRAME_FOOTER)) {
299 ESP_LOGV(TAG,
"Dropping frame with a %u byte payload, larger than the receive buffer", payload_len);
304 this->
expected_len_ = LONG_PAYLOAD_POS + payload_len +
sizeof(CMD_FRAME_FOOTER);
316 uint8_t rest[RX_BUFFER_SIZE];
317 const uint8_t rest_len = this->
rx_len_ - 1;
321 for (uint8_t i = 0; i < rest_len; i++) {
328 const uint8_t *footer_src;
329 uint8_t footer_size =
sizeof(CMD_FRAME_FOOTER);
330 uint8_t payload_pos = LONG_PAYLOAD_POS;
333 footer_src = SHORT_DATA_FRAME_FOOTER;
334 footer_size =
sizeof(SHORT_DATA_FRAME_FOOTER);
338 footer_src = STD_DATA_FRAME_FOOTER;
341 footer_src = CMD_FRAME_FOOTER;
344 uint8_t footer[
sizeof(CMD_FRAME_FOOTER)];
346 if (memcmp(&this->
rx_buffer_[this->
rx_len_ - footer_size], footer, footer_size) != 0) {
347#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
349 ESP_LOGV(TAG,
"Footer does not match header: %s",
355 const uint8_t *payload = &this->
rx_buffer_[payload_pos];
356 const uint16_t payload_len = this->
rx_len_ - payload_pos - footer_size;
377 const uint8_t *data = payload;
379 if (len < 4 || payload[0] != DATA_TYPE_STANDARD) {
381 ESP_LOGV(TAG,
"Ignoring data frame type %02X", payload[0]);
387 const uint8_t
state = data[0];
392 ESP_LOGV(TAG,
"Dropping frame with impossible state %u",
state);
401 ESP_LOGV(TAG,
"Acknowledgement too short (%u bytes)",
len);
404 const uint16_t command_word =
encode_uint16(payload[1], payload[0]);
407 ESP_LOGV(TAG,
"Unexpected acknowledgement %04X", command_word);
411 if (command_word != (command | CMD_CONFIRMATION)) {
412 ESP_LOGV(TAG,
"Unexpected acknowledgement %04X", command_word);
415#ifdef USE_LD2410S_PARAMETERS
416 if (
ack != 0 && command == PARAMETERS_WRITE_CMD) {
419 ESP_LOGW(TAG,
"Module rejected the parameters, ack %04X",
ack);
427 ESP_LOGW(TAG,
"Module rejected command %04X, ack %04X", command,
ack);
431#ifdef USE_LD2410S_PARAMETERS
435#ifdef USE_LD2410S_VERSION
446 const bool was_init = this->
sequence_ == INIT_SEQUENCE;
449 ESP_LOGD(TAG,
"Setup done");
456#ifdef USE_LD2410S_PARAMETERS
460 ESP_LOGW(TAG,
"Parameter answer too short (%u bytes)",
len);
466 const uint8_t *v = &values[i * PARAMETER_VALUE_SIZE];
467 if ((v[1] | v[2] | v[3]) != 0) {
468 ESP_LOGW(TAG,
"Parameter %u out of range: %" PRIu32
", changes stay disabled", i,
473 for (
auto *number : this->
numbers_) {
474 PUBLISH_STATE(number, NAN);
481 this->
parameters_[i] = values[i * PARAMETER_VALUE_SIZE];
485 ESP_LOGD(TAG,
"Parameters: gates %u to %u, no delay %u s, frequencies %u/%u dHz, response speed %u",
492#ifdef USE_LD2410S_VERSION
495 if (
len < VERSION_SIZE) {
496 ESP_LOGW(TAG,
"Version answer too short (%u bytes)",
len);
499 const uint8_t *v = &values[VERSION_TYPE_SIZE];
503 ESP_LOGD(TAG,
"Firmware %s", version);
504 PUBLISH_STATE(this->version_text_sensor_, version);
510#ifdef USE_BINARY_SENSOR
511 PUBLISH_STATE(this->target_binary_sensor_, target);
515 SAFE_PUBLISH_SENSOR(this->distance_sensor_, target ? distance : 0);
519#ifdef USE_LD2410S_PARAMETERS
527 if (this->response_speed_select_ !=
nullptr) {
529 for (uint8_t i = 0; i < RESPONSE_SPEED_COUNT; i++) {
531 this->response_speed_select_->publish_state(i);
535 ESP_LOGV(TAG,
"Unknown response speed %u",
speed);