ESPHome 2026.11.0b6
Loading...
Searching...
No Matches
seeed_mr24hpc1.cpp
Go to the documentation of this file.
1#include "seeed_mr24hpc1.h"
2
4#include "esphome/core/log.h"
6
7#include <utility>
8
10
11ESPHOME_LOG_TAG(TAG, "seeed_mr24hpc1");
12
13static constexpr uint32_t STARTUP_DELAY_MS = 1000;
14
15#ifdef USE_TEXT_SENSOR
16PROGMEM_STRING_TABLE(MotionStatusStrings, "None", "Motionless", "Active");
17PROGMEM_STRING_TABLE(KeepAwayStrings, "None", "Close", "Away");
18#endif
19
20// Prints the component's configuration data. dump_config() prints all of the component's configuration
21// items in an easy-to-read format, including the configuration key-value pairs.
23 ESP_LOGCONFIG(TAG, "MR24HPC1:");
24#ifdef USE_TEXT_SENSOR
25 LOG_TEXT_SENSOR(" ", "Heartbeat Text Sensor", this->heartbeat_state_text_sensor_);
26 LOG_TEXT_SENSOR(" ", "Product Model Text Sensor", this->product_model_text_sensor_);
27 LOG_TEXT_SENSOR(" ", "Product ID Text Sensor", this->product_id_text_sensor_);
28 LOG_TEXT_SENSOR(" ", "Hardware Model Text Sensor", this->hardware_model_text_sensor_);
29 LOG_TEXT_SENSOR(" ", "Firware Verison Text Sensor", this->firware_version_text_sensor_);
30 LOG_TEXT_SENSOR(" ", "Keep Away Text Sensor", this->keep_away_text_sensor_);
31 LOG_TEXT_SENSOR(" ", "Motion Status Text Sensor", this->motion_status_text_sensor_);
32 LOG_TEXT_SENSOR(" ", "Custom Mode End Text Sensor", this->custom_mode_end_text_sensor_);
33#endif
34#ifdef USE_BINARY_SENSOR
35 LOG_BINARY_SENSOR(" ", "Has Target Binary Sensor", this->has_target_binary_sensor_);
36#endif
37#ifdef USE_SENSOR
38 LOG_SENSOR(" ", "Custom Presence Of Detection Sensor", this->custom_presence_of_detection_sensor_);
39 LOG_SENSOR(" ", "Movement Signs Sensor", this->movement_signs_sensor_);
40 LOG_SENSOR(" ", "Custom Motion Distance Sensor", this->custom_motion_distance_sensor_);
41 LOG_SENSOR(" ", "Custom Spatial Static Sensor", this->custom_spatial_static_value_sensor_);
42 LOG_SENSOR(" ", "Custom Spatial Motion Sensor", this->custom_spatial_motion_value_sensor_);
43 LOG_SENSOR(" ", "Custom Motion Speed Sensor", this->custom_motion_speed_sensor_);
44 LOG_SENSOR(" ", "Custom Mode Num Sensor", this->custom_mode_num_sensor_);
45#endif
46#ifdef USE_SWITCH
47 LOG_SWITCH(" ", "Underly Open Function Switch", this->underlying_open_function_switch_);
48#endif
49#ifdef USE_BUTTON
50 LOG_BUTTON(" ", "Restart Button", this->restart_button_);
51 LOG_BUTTON(" ", "Custom Set End Button", this->custom_set_end_button_);
52#endif
53#ifdef USE_SELECT
54 LOG_SELECT(" ", "Scene Mode Select", this->scene_mode_select_);
55 LOG_SELECT(" ", "Unman Time Select", this->unman_time_select_);
56 LOG_SELECT(" ", "Existence Boundary Select", this->existence_boundary_select_);
57 LOG_SELECT(" ", "Motion Boundary Select", this->motion_boundary_select_);
58#endif
59#ifdef USE_NUMBER
60 LOG_NUMBER(" ", "Sensitivity Number", this->sensitivity_number_);
61 LOG_NUMBER(" ", "Custom Mode Number", this->custom_mode_number_);
62 LOG_NUMBER(" ", "Existence Threshold Number", this->existence_threshold_number_);
63 LOG_NUMBER(" ", "Motion Threshold Number", this->motion_threshold_number_);
64 LOG_NUMBER(" ", "Motion Trigger Time Number", this->motion_trigger_number_);
65 LOG_NUMBER(" ", "Motion To Rest Time Number", this->motion_to_rest_number_);
66 LOG_NUMBER(" ", "Custom Unman Time Number", this->custom_unman_time_number_);
67#endif
68}
69
70// Initialisation functions
72#ifdef USE_NUMBER
73 // Zero out the custom mode
74 PUBLISH_STATE(this->custom_mode_number_, 0);
75#endif
76#ifdef USE_SENSOR
77 PUBLISH_STATE(this->custom_mode_num_sensor_, 0);
78#endif
79#ifdef USE_TEXT_SENSOR
80 PUBLISH_STATE(this->custom_mode_end_text_sensor_, "Not in custom mode");
81#endif
82 this->poll_time_base_func_check_ = false;
83 this->check_dev_inf_sign_ = true;
84 this->sg_start_query_data_ = STANDARD_FUNCTION_QUERY_PRODUCT_MODE;
85 this->sg_data_len_ = 0;
86 this->sg_frame_len_ = 0;
87 this->sg_recv_data_state_ = FRAME_IDLE;
88 this->s_output_info_switch_flag_ = OUTPUT_SWITCH_INIT;
89
90 memset(this->c_product_mode_, 0, PRODUCT_BUF_MAX_SIZE);
91 memset(this->c_product_id_, 0, PRODUCT_BUF_MAX_SIZE);
92 memset(this->c_firmware_version_, 0, PRODUCT_BUF_MAX_SIZE);
93 memset(this->c_hardware_model_, 0, PRODUCT_BUF_MAX_SIZE);
94 memset(this->sg_frame_prase_buf_, 0, FRAME_BUF_MAX_SIZE);
95 memset(this->sg_frame_buf_, 0, FRAME_BUF_MAX_SIZE);
96
97 // The module locks up when queried during its own boot, so hold all TX for a second
98 this->set_timeout(STARTUP_DELAY_MS, [this]() {
99 this->module_ready_ = true;
100 this->set_custom_end_mode();
101 this->poll_time_base_func_check_ = true;
102 this->set_interval(8000, [this]() { this->update_(); });
103 });
104}
105
106// Timed polling of radar data
107void MR24HPC1Component::update_() {
108 this->get_radar_output_information_switch(); // Query the key status every so often
109 this->poll_time_base_func_check_ = true; // Query the base functionality information at regular intervals
110}
111
112// main loop
114 this->read_available([this](uint8_t b) { this->r24_split_data_frame_(b); });
115
116 if ((this->s_output_info_switch_flag_ == OUTPUT_SWTICH_OFF) &&
117 (this->sg_start_query_data_ > CUSTOM_FUNCTION_QUERY_TIME_OF_ENTER_UNMANNED) && (!this->check_dev_inf_sign_)) {
118 this->sg_start_query_data_ = STANDARD_FUNCTION_QUERY_SCENE_MODE;
119 } else if ((this->s_output_info_switch_flag_ == OUTPUT_SWITCH_ON) &&
120 (this->sg_start_query_data_ < CUSTOM_FUNCTION_QUERY_EXISTENCE_BOUNDARY) && (!this->check_dev_inf_sign_)) {
121 this->sg_start_query_data_ = CUSTOM_FUNCTION_QUERY_EXISTENCE_BOUNDARY;
122 } else if (this->check_dev_inf_sign_ && (this->sg_start_query_data_ > STANDARD_FUNCTION_QUERY_HARDWARE_MODE)) {
123 // First time power up information polling
124 this->sg_start_query_data_ = STANDARD_FUNCTION_QUERY_PRODUCT_MODE;
125 }
126
127 // Polling Functions
128 if (this->poll_time_base_func_check_) {
129 switch (this->sg_start_query_data_) {
131 this->get_product_mode();
132 this->sg_start_query_data_++;
133 break;
135 this->get_product_id();
136 this->sg_start_query_data_++;
137 break;
139 this->get_product_mode();
140 this->get_product_id();
141 this->get_firmware_version();
142 this->sg_start_query_data_++;
143 break;
144 case STANDARD_FUNCTION_QUERY_HARDWARE_MODE: // Above is the equipment information
145 this->get_product_mode();
146 this->get_product_id();
147 this->get_hardware_model();
148 this->sg_start_query_data_++;
149 this->check_dev_inf_sign_ = false;
150 break;
152 this->get_scene_mode();
153 this->sg_start_query_data_++;
154 break;
156 this->get_sensitivity();
157 this->sg_start_query_data_++;
158 break;
160 this->get_unmanned_time();
161 this->sg_start_query_data_++;
162 break;
164 this->get_human_status();
165 this->sg_start_query_data_++;
166 break;
168 this->get_human_motion_info();
169 this->sg_start_query_data_++;
170 break;
173 this->sg_start_query_data_++;
174 break;
175 case STANDARD_FUNCTION_QUERY_KEEPAWAY_STATUS: // The above is the basic functional information
176 this->get_keep_away();
177 this->sg_start_query_data_++;
178 break;
180 this->get_custom_mode();
181 this->sg_start_query_data_++;
182 break;
184 this->get_heartbeat_packet();
185 this->sg_start_query_data_++;
186 break;
189 this->sg_start_query_data_++;
190 break;
192 this->get_motion_boundary();
193 this->sg_start_query_data_++;
194 break;
197 this->sg_start_query_data_++;
198 break;
200 this->get_motion_threshold();
201 this->sg_start_query_data_++;
202 break;
205 this->sg_start_query_data_++;
206 break;
209 this->sg_start_query_data_++;
210 break;
212 this->get_custom_unman_time();
213 this->sg_start_query_data_++;
214 if (this->s_output_info_switch_flag_ == OUTPUT_SWTICH_OFF) {
215 this->poll_time_base_func_check_ = false; // Avoiding high-speed polling that can cause the device to jam
216 }
217 break;
219 this->get_human_status();
220 this->sg_start_query_data_++;
221 break;
224 this->sg_start_query_data_++;
225 break;
228 this->sg_start_query_data_++;
229 break;
232 this->sg_start_query_data_++;
233 break;
236 this->sg_start_query_data_++;
237 break;
240 this->sg_start_query_data_++;
241 this->poll_time_base_func_check_ = false; // Avoiding high-speed polling that can cause the device to jam
242 break;
243 default:
244 break;
245 }
246 }
247}
248
249// Frames are at least 10 bytes, so the three trailing bytes can always be left out
250static uint8_t get_frame_crc_sum(const uint8_t *data, size_t len) { return sum_bytes(data, len - 3); }
251
252// Check that the check digit is correct
253static int get_frame_check_status(const uint8_t *data, size_t len) {
254 uint8_t crc_sum = get_frame_crc_sum(data, len);
255 uint8_t verified = data[len - 3];
256 return (verified == crc_sum) ? 1 : 0;
257}
258
259// split data frame
260void MR24HPC1Component::r24_split_data_frame_(uint8_t value) {
261 switch (this->sg_recv_data_state_) {
262 case FRAME_IDLE: // starting value
263 if (FRAME_HEADER1_VALUE == value) {
264 this->sg_recv_data_state_ = FRAME_HEADER2;
265 }
266 break;
267 case FRAME_HEADER2:
268 if (FRAME_HEADER2_VALUE == value) {
269 this->sg_frame_buf_[0] = FRAME_HEADER1_VALUE;
270 this->sg_frame_buf_[1] = FRAME_HEADER2_VALUE;
271 this->sg_recv_data_state_ = FRAME_CTL_WORD;
272 } else {
273 this->sg_recv_data_state_ = FRAME_IDLE;
274 ESP_LOGD(TAG, "FRAME_IDLE ERROR value:%x", value);
275 }
276 break;
277 case FRAME_CTL_WORD:
278 this->sg_frame_buf_[2] = value;
279 this->sg_recv_data_state_ = FRAME_CMD_WORD;
280 break;
281 case FRAME_CMD_WORD:
282 this->sg_frame_buf_[3] = value;
283 this->sg_recv_data_state_ = FRAME_DATA_LEN_H;
284 break;
285 case FRAME_DATA_LEN_H:
286 if (value == 0) {
287 this->sg_frame_buf_[4] = value;
288 this->sg_recv_data_state_ = FRAME_DATA_LEN_L;
289 } else {
290 this->sg_recv_data_state_ = FRAME_IDLE;
291 ESP_LOGD(TAG, "FRAME_DATA_LEN_H ERROR value:%x", value);
292 }
293 break;
294 case FRAME_DATA_LEN_L:
295 this->sg_data_len_ = value;
296 if (this->sg_data_len_ == 0 || this->sg_data_len_ > 32) {
297 ESP_LOGD(TAG, "len=%d, FRAME_DATA_LEN_L ERROR value:%x", this->sg_data_len_, value);
298 this->sg_data_len_ = 0;
299 this->sg_recv_data_state_ = FRAME_IDLE;
300 } else {
301 this->sg_frame_buf_[5] = value;
302 this->sg_frame_len_ = 6;
303 this->sg_recv_data_state_ = FRAME_DATA_BYTES;
304 }
305 break;
306 case FRAME_DATA_BYTES:
307 this->sg_frame_buf_[this->sg_frame_len_++] = value;
308 if (--this->sg_data_len_ == 0) {
309 this->sg_recv_data_state_ = FRAME_DATA_CRC;
310 }
311 break;
312 case FRAME_DATA_CRC:
313 this->sg_frame_buf_[this->sg_frame_len_++] = value;
314 this->sg_recv_data_state_ = FRAME_TAIL1;
315 break;
316 case FRAME_TAIL1:
317 if (FRAME_TAIL1_VALUE == value) {
318 this->sg_recv_data_state_ = FRAME_TAIL2;
319 } else {
320 this->sg_recv_data_state_ = FRAME_IDLE;
321 this->sg_frame_len_ = 0;
322 this->sg_data_len_ = 0;
323 ESP_LOGD(TAG, "FRAME_TAIL1 ERROR value:%x", value);
324 }
325 break;
326 case FRAME_TAIL2:
327 if (FRAME_TAIL2_VALUE == value) {
328 this->sg_frame_buf_[this->sg_frame_len_++] = FRAME_TAIL1_VALUE;
329 this->sg_frame_buf_[this->sg_frame_len_++] = FRAME_TAIL2_VALUE;
330 memcpy(this->sg_frame_prase_buf_, this->sg_frame_buf_, this->sg_frame_len_);
331 if (get_frame_check_status(this->sg_frame_prase_buf_, this->sg_frame_len_)) {
332 this->r24_parse_data_frame_(this->sg_frame_prase_buf_, this->sg_frame_len_);
333 } else {
334 ESP_LOGD(TAG, "frame check failer!");
335 }
336 } else {
337 ESP_LOGD(TAG, "FRAME_TAIL2 ERROR value:%x", value);
338 }
339 memset(this->sg_frame_prase_buf_, 0, FRAME_BUF_MAX_SIZE);
340 memset(this->sg_frame_buf_, 0, FRAME_BUF_MAX_SIZE);
341 this->sg_frame_len_ = 0;
342 this->sg_data_len_ = 0;
343 this->sg_recv_data_state_ = FRAME_IDLE;
344 break;
345 default:
346 this->sg_recv_data_state_ = FRAME_IDLE;
347 }
348}
349
350// Parses data frames related to product information
351void MR24HPC1Component::r24_frame_parse_product_information_(uint8_t *data) {
352#ifdef USE_TEXT_SENSOR
353 uint16_t product_len = encode_uint16(data[FRAME_COMMAND_WORD_INDEX + 1], data[FRAME_COMMAND_WORD_INDEX + 2]);
354 if (data[FRAME_COMMAND_WORD_INDEX] == COMMAND_PRODUCT_MODE) {
355 if ((this->product_model_text_sensor_ != nullptr) && (product_len < PRODUCT_BUF_MAX_SIZE)) {
356 memset(this->c_product_mode_, 0, PRODUCT_BUF_MAX_SIZE);
357 memcpy(this->c_product_mode_, &data[FRAME_DATA_INDEX], product_len);
358 this->product_model_text_sensor_->publish_state(this->c_product_mode_);
359 } else {
360 ESP_LOGD(TAG, "Reply: get product_mode error!");
361 }
362 } else if (data[FRAME_COMMAND_WORD_INDEX] == COMMAND_PRODUCT_ID) {
363 if ((this->product_id_text_sensor_ != nullptr) && (product_len < PRODUCT_BUF_MAX_SIZE)) {
364 memset(this->c_product_id_, 0, PRODUCT_BUF_MAX_SIZE);
365 memcpy(this->c_product_id_, &data[FRAME_DATA_INDEX], product_len);
366 this->product_id_text_sensor_->publish_state(this->c_product_id_);
367 } else {
368 ESP_LOGD(TAG, "Reply: get productId error!");
369 }
370 } else if (data[FRAME_COMMAND_WORD_INDEX] == COMMAND_HARDWARE_MODEL) {
371 if ((this->hardware_model_text_sensor_ != nullptr) && (product_len < PRODUCT_BUF_MAX_SIZE)) {
372 memset(this->c_hardware_model_, 0, PRODUCT_BUF_MAX_SIZE);
373 memcpy(this->c_hardware_model_, &data[FRAME_DATA_INDEX], product_len);
374 this->hardware_model_text_sensor_->publish_state(this->c_hardware_model_);
375 ESP_LOGD(TAG, "Reply: get hardware_model :%s", this->c_hardware_model_);
376 } else {
377 ESP_LOGD(TAG, "Reply: get hardwareModel error!");
378 }
379 } else if (data[FRAME_COMMAND_WORD_INDEX] == COMMAND_FIRMWARE_VERSION) {
380 if ((this->firware_version_text_sensor_ != nullptr) && (product_len < PRODUCT_BUF_MAX_SIZE)) {
381 memset(this->c_firmware_version_, 0, PRODUCT_BUF_MAX_SIZE);
382 memcpy(this->c_firmware_version_, &data[FRAME_DATA_INDEX], product_len);
383 this->firware_version_text_sensor_->publish_state(this->c_firmware_version_);
384 } else {
385 ESP_LOGD(TAG, "Reply: get firmwareVersion error!");
386 }
387 }
388#endif
389}
390
391// Parsing the underlying open parameters
392void MR24HPC1Component::r24_frame_parse_open_underlying_information_(uint8_t *data) {
393 switch (data[FRAME_COMMAND_WORD_INDEX]) {
394 case 0x00:
395 case 0x80:
396#ifdef USE_SWITCH
397 PUBLISH_STATE(this->underlying_open_function_switch_, data[FRAME_DATA_INDEX]);
398#endif
399 this->s_output_info_switch_flag_ = data[FRAME_DATA_INDEX] ? OUTPUT_SWITCH_ON : OUTPUT_SWTICH_OFF;
400 break;
401#ifdef USE_SENSOR
402 case 0x01:
403 PUBLISH_STATE(this->custom_spatial_static_value_sensor_, data[FRAME_DATA_INDEX]);
404 PUBLISH_STATE(this->custom_presence_of_detection_sensor_, data[FRAME_DATA_INDEX + 1] * 0.5f);
405 PUBLISH_STATE(this->custom_spatial_motion_value_sensor_, data[FRAME_DATA_INDEX + 2]);
406 PUBLISH_STATE(this->custom_motion_distance_sensor_, data[FRAME_DATA_INDEX + 3] * 0.5f);
407 PUBLISH_STATE(this->custom_motion_speed_sensor_, (data[FRAME_DATA_INDEX + 4] - 10) * 0.5f);
408 break;
409 case 0x07:
410 case 0x87:
411 PUBLISH_STATE(this->movement_signs_sensor_, data[FRAME_DATA_INDEX]);
412 break;
413 case 0x81:
414 PUBLISH_STATE(this->custom_spatial_static_value_sensor_, data[FRAME_DATA_INDEX]);
415 break;
416 case 0x82:
417 PUBLISH_STATE(this->custom_spatial_motion_value_sensor_, data[FRAME_DATA_INDEX]);
418 break;
419 case 0x83:
420 // 0 to 3 m in steps of 0.5 m
421 if (this->custom_presence_of_detection_sensor_ != nullptr && data[FRAME_DATA_INDEX] <= 6) {
422 this->custom_presence_of_detection_sensor_->publish_state(data[FRAME_DATA_INDEX] * 0.5f);
423 }
424 break;
425 case 0x84:
426 PUBLISH_STATE(this->custom_motion_distance_sensor_, data[FRAME_DATA_INDEX] * 0.5f);
427 break;
428 case 0x85:
429 PUBLISH_STATE(this->custom_motion_speed_sensor_, (data[FRAME_DATA_INDEX] - 10) * 0.5f);
430 break;
431#endif
432#ifdef USE_TEXT_SENSOR
433 case 0x06:
434 case 0x86:
435 // none:0x00 close_to:0x01 far_away:0x02
436 if ((this->keep_away_text_sensor_ != nullptr) && (data[FRAME_DATA_INDEX] < KeepAwayStrings::COUNT)) {
437 this->keep_away_text_sensor_->publish_state(
438 KeepAwayStrings::get_progmem_str(data[FRAME_DATA_INDEX], KeepAwayStrings::LAST_INDEX));
439 }
440 break;
441#endif
442#ifdef USE_NUMBER
443 case 0x08:
444 case 0x88:
445 PUBLISH_STATE(this->existence_threshold_number_, data[FRAME_DATA_INDEX]);
446 break;
447 case 0x09:
448 case 0x89:
449 PUBLISH_STATE(this->motion_threshold_number_, data[FRAME_DATA_INDEX]);
450 break;
451 case 0x0c:
452 case 0x8c:
453 PUBLISH_STATE(this->motion_trigger_number_, encode_value<uint32_t>(&data[FRAME_DATA_INDEX]));
454 break;
455 case 0x0d:
456 case 0x8d:
457 PUBLISH_STATE(this->motion_to_rest_number_, encode_value<uint32_t>(&data[FRAME_DATA_INDEX]));
458 break;
459 case 0x0e:
460 case 0x8e:
461 PUBLISH_STATE(this->custom_unman_time_number_, encode_value<uint32_t>(&data[FRAME_DATA_INDEX]) / 1000.0f);
462 break;
463#endif
464#ifdef USE_SELECT
465 case 0x0a:
466 case 0x8a:
467 if (this->existence_boundary_select_ != nullptr) {
468 if (this->existence_boundary_select_->has_index(data[FRAME_DATA_INDEX] - 1)) {
469 this->existence_boundary_select_->publish_state(data[FRAME_DATA_INDEX] - 1);
470 }
471 }
472 break;
473 case 0x0b:
474 case 0x8b:
475 if (this->motion_boundary_select_ != nullptr) {
476 if (this->motion_boundary_select_->has_index(data[FRAME_DATA_INDEX] - 1)) {
477 this->motion_boundary_select_->publish_state(data[FRAME_DATA_INDEX] - 1);
478 }
479 }
480 break;
481#endif
482 }
483}
484
485void MR24HPC1Component::r24_parse_data_frame_(uint8_t *data, uint8_t len) {
486 switch (data[FRAME_CONTROL_WORD_INDEX]) {
487 case 0x01: {
488 if (data[FRAME_COMMAND_WORD_INDEX] == 0x02) {
489 ESP_LOGD(TAG, "Reply: query restart packet");
490 break;
491 }
492#ifdef USE_TEXT_SENSOR
493 PUBLISH_STATE(this->heartbeat_state_text_sensor_,
494 data[FRAME_COMMAND_WORD_INDEX] == 0x01 ? "Equipment Normal" : "Equipment Abnormal");
495#endif
496 } break;
497 case 0x02: {
498 this->r24_frame_parse_product_information_(data);
499 } break;
500 case 0x05: {
501 this->r24_frame_parse_work_status_(data);
502 } break;
503 case 0x08: {
504 this->r24_frame_parse_open_underlying_information_(data);
505 } break;
506 case 0x80: {
507 this->r24_frame_parse_human_information_(data);
508 } break;
509 default:
510 ESP_LOGD(TAG, "control word:0x%02X not found", data[FRAME_CONTROL_WORD_INDEX]);
511 break;
512 }
513}
514
515void MR24HPC1Component::r24_frame_parse_work_status_(uint8_t *data) {
516 switch (data[FRAME_COMMAND_WORD_INDEX]) {
517 case 0x01:
518 case 0x81:
519 ESP_LOGD(TAG, "Reply: get radar init status 0x%02X", data[FRAME_DATA_INDEX]);
520 break;
521 case 0x09:
522#ifdef USE_SENSOR
523 PUBLISH_STATE(this->custom_mode_num_sensor_, data[FRAME_DATA_INDEX]);
524#endif
525#ifdef USE_NUMBER
526 PUBLISH_STATE(this->custom_mode_number_, 0);
527#endif
528#ifdef USE_TEXT_SENSOR
529 PUBLISH_STATE(this->custom_mode_end_text_sensor_, "Setup in progress");
530#endif
531 break;
532 case 0x89:
533#ifdef USE_SENSOR
534 PUBLISH_STATE(this->custom_mode_num_sensor_, data[FRAME_DATA_INDEX]);
535#endif
536 if (data[FRAME_DATA_INDEX] == 0) {
537#ifdef USE_TEXT_SENSOR
538 PUBLISH_STATE(this->custom_mode_end_text_sensor_, "Not in custom mode");
539#endif
540#ifdef USE_NUMBER
541 PUBLISH_STATE(this->custom_mode_number_, 0);
542#endif
543 }
544 break;
545#ifdef USE_SELECT
546 case 0x07:
547 case 0x87:
548 if ((this->scene_mode_select_ != nullptr) && (this->scene_mode_select_->has_index(data[FRAME_DATA_INDEX]))) {
549 this->scene_mode_select_->publish_state(data[FRAME_DATA_INDEX]);
550 } else {
551 ESP_LOGD(TAG, "Select has index offset %d Error", data[FRAME_DATA_INDEX]);
552 }
553 break;
554#endif
555#ifdef USE_NUMBER
556 case 0x08:
557 case 0x88:
558 PUBLISH_STATE(this->sensitivity_number_, data[FRAME_DATA_INDEX]);
559 break;
560#endif
561#ifdef USE_TEXT_SENSOR
562 case 0x0A:
563 PUBLISH_STATE(this->custom_mode_end_text_sensor_, "Set Success!");
564 break;
565#endif
566 default:
567 ESP_LOGD(TAG, "[%s] No found COMMAND_WORD(%02X) in Frame", __FUNCTION__, data[FRAME_COMMAND_WORD_INDEX]);
568 break;
569 }
570}
571
572void MR24HPC1Component::r24_frame_parse_human_information_(uint8_t *data) {
573 switch (data[FRAME_COMMAND_WORD_INDEX]) {
574#ifdef USE_BINARY_SENSOR
575 case 0x01:
576 case 0x81:
577 if (this->has_target_binary_sensor_ != nullptr && data[FRAME_DATA_INDEX] <= 1) {
578 this->has_target_binary_sensor_->publish_state(data[FRAME_DATA_INDEX] == 1);
579 }
580 break;
581#endif
582#ifdef USE_SENSOR
583 case 0x03:
584 case 0x83:
585 PUBLISH_STATE(this->movement_signs_sensor_, data[FRAME_DATA_INDEX]);
586 break;
587#endif
588#ifdef USE_TEXT_SENSOR
589 case 0x02:
590 case 0x82:
591 if ((this->motion_status_text_sensor_ != nullptr) && (data[FRAME_DATA_INDEX] < MotionStatusStrings::COUNT)) {
592 this->motion_status_text_sensor_->publish_state(
593 MotionStatusStrings::get_progmem_str(data[FRAME_DATA_INDEX], MotionStatusStrings::LAST_INDEX));
594 }
595 break;
596 case 0x0B:
597 case 0x8B:
598 // none:0x00 close_to:0x01 far_away:0x02
599 if ((this->keep_away_text_sensor_ != nullptr) && (data[FRAME_DATA_INDEX] < KeepAwayStrings::COUNT)) {
600 this->keep_away_text_sensor_->publish_state(
601 KeepAwayStrings::get_progmem_str(data[FRAME_DATA_INDEX], KeepAwayStrings::LAST_INDEX));
602 }
603 break;
604#endif
605#ifdef USE_SELECT
606 case 0x0A:
607 case 0x8A:
608 // none:0x00 1s:0x01 30s:0x02 1min:0x03 2min:0x04 5min:0x05 10min:0x06 30min:0x07 1hour:0x08
609 if ((this->unman_time_select_ != nullptr) && (data[FRAME_DATA_INDEX] < 9)) {
610 this->unman_time_select_->publish_state(data[FRAME_DATA_INDEX]);
611 }
612 break;
613#endif
614 default:
615 ESP_LOGD(TAG, "[%s] No found COMMAND_WORD(%02X) in Frame", __FUNCTION__, data[FRAME_COMMAND_WORD_INDEX]);
616 break;
617 }
618}
619
620// Sending data frames
621void MR24HPC1Component::send_query_(const uint8_t *query, size_t string_length) {
622 if (!this->module_ready_)
623 return;
624 this->write_array(query, string_length);
625}
626
627// Send Heartbeat Packet Command
628void MR24HPC1Component::get_heartbeat_packet() { this->send_query_(GET_HEARTBEAT, sizeof(GET_HEARTBEAT)); }
629
630// Issuance of the underlying open parameter query command
632 this->send_query_(GET_RADAR_OUTPUT_INFORMATION_SWITCH, sizeof(GET_RADAR_OUTPUT_INFORMATION_SWITCH));
633}
634
635// Issuance of product model orders
636void MR24HPC1Component::get_product_mode() { this->send_query_(GET_PRODUCT_MODE, sizeof(GET_PRODUCT_MODE)); }
637
638// Issuing the Get Product ID command
639void MR24HPC1Component::get_product_id() { this->send_query_(GET_PRODUCT_ID, sizeof(GET_PRODUCT_ID)); }
640
641// Issuing hardware model commands
642void MR24HPC1Component::get_hardware_model() { this->send_query_(GET_HARDWARE_MODEL, sizeof(GET_HARDWARE_MODEL)); }
643
644// Issuing software version commands
646 this->send_query_(GET_FIRMWARE_VERSION, sizeof(GET_FIRMWARE_VERSION));
647}
648
649void MR24HPC1Component::get_human_status() { this->send_query_(GET_HUMAN_STATUS, sizeof(GET_HUMAN_STATUS)); }
650
652 this->send_query_(GET_HUMAN_MOTION_INFORMATION, sizeof(GET_HUMAN_MOTION_INFORMATION));
653}
654
656 this->send_query_(GET_BODY_MOTION_PARAMETERS, sizeof(GET_BODY_MOTION_PARAMETERS));
657}
658
659void MR24HPC1Component::get_keep_away() { this->send_query_(GET_KEEP_AWAY, sizeof(GET_KEEP_AWAY)); }
660
661void MR24HPC1Component::get_scene_mode() { this->send_query_(GET_SCENE_MODE, sizeof(GET_SCENE_MODE)); }
662
663void MR24HPC1Component::get_sensitivity() { this->send_query_(GET_SENSITIVITY, sizeof(GET_SENSITIVITY)); }
664
665void MR24HPC1Component::get_unmanned_time() { this->send_query_(GET_UNMANNED_TIME, sizeof(GET_UNMANNED_TIME)); }
666
667void MR24HPC1Component::get_custom_mode() { this->send_query_(GET_CUSTOM_MODE, sizeof(GET_CUSTOM_MODE)); }
668
670 this->send_query_(GET_EXISTENCE_BOUNDARY, sizeof(GET_EXISTENCE_BOUNDARY));
671}
672
673void MR24HPC1Component::get_motion_boundary() { this->send_query_(GET_MOTION_BOUNDARY, sizeof(GET_MOTION_BOUNDARY)); }
674
676 this->send_query_(GET_SPATIAL_STATIC_VALUE, sizeof(GET_SPATIAL_STATIC_VALUE));
677}
678
680 this->send_query_(GET_SPATIAL_MOTION_VALUE, sizeof(GET_SPATIAL_MOTION_VALUE));
681}
682
684 this->send_query_(GET_DISTANCE_OF_STATIC_OBJECT, sizeof(GET_DISTANCE_OF_STATIC_OBJECT));
685}
686
688 this->send_query_(GET_DISTANCE_OF_MOVING_OBJECT, sizeof(GET_DISTANCE_OF_MOVING_OBJECT));
689}
690
692 this->send_query_(GET_TARGET_MOVEMENT_SPEED, sizeof(GET_TARGET_MOVEMENT_SPEED));
693}
694
696 this->send_query_(GET_EXISTENCE_THRESHOLD, sizeof(GET_EXISTENCE_THRESHOLD));
697}
698
700 this->send_query_(GET_MOTION_THRESHOLD, sizeof(GET_MOTION_THRESHOLD));
701}
702
704 this->send_query_(GET_MOTION_TRIGGER_TIME, sizeof(GET_MOTION_TRIGGER_TIME));
705}
706
708 this->send_query_(GET_MOTION_TO_REST_TIME, sizeof(GET_MOTION_TO_REST_TIME));
709}
710
712 this->send_query_(GET_CUSTOM_UNMAN_TIME, sizeof(GET_CUSTOM_UNMAN_TIME));
713}
714
715// Logic of setting: After setting, query whether the setting is successful or not!
716
718 if (enable) {
719 this->send_query_(UNDERLYING_SWITCH_ON, sizeof(UNDERLYING_SWITCH_ON));
720 } else {
721 this->send_query_(UNDERLYING_SWITCH_OFF, sizeof(UNDERLYING_SWITCH_OFF));
722 }
723#ifdef USE_TEXT_SENSOR
724 PUBLISH_STATE(this->keep_away_text_sensor_, "");
725 PUBLISH_STATE(this->motion_status_text_sensor_, "");
726#endif
727#ifdef USE_SENSOR
728 PUBLISH_STATE(this->custom_spatial_static_value_sensor_, NAN);
729 PUBLISH_STATE(this->custom_spatial_motion_value_sensor_, NAN);
730 PUBLISH_STATE(this->custom_motion_distance_sensor_, NAN);
731 PUBLISH_STATE(this->custom_presence_of_detection_sensor_, NAN);
732 PUBLISH_STATE(this->custom_motion_speed_sensor_, NAN);
733#endif
734}
735
737 uint8_t send_data_len = 10;
738 uint8_t send_data[10] = {0x53, 0x59, 0x05, 0x07, 0x00, 0x01, value, 0x00, 0x54, 0x43};
739 send_data[7] = get_frame_crc_sum(send_data, send_data_len);
740 this->send_query_(send_data, send_data_len);
741#ifdef USE_NUMBER
742 PUBLISH_STATE(this->custom_mode_number_, 0);
743#endif
744#ifdef USE_SENSOR
745 PUBLISH_STATE(this->custom_mode_num_sensor_, 0);
746#endif
747 this->get_scene_mode();
748 this->get_sensitivity();
749 this->get_custom_mode();
751 this->get_motion_boundary();
753 this->get_motion_threshold();
756 this->get_custom_unman_time();
757}
758
760 if (value == 0x00)
761 return;
762 uint8_t send_data_len = 10;
763 uint8_t send_data[10] = {0x53, 0x59, 0x05, 0x08, 0x00, 0x01, value, 0x00, 0x54, 0x43};
764 send_data[7] = get_frame_crc_sum(send_data, send_data_len);
765 this->send_query_(send_data, send_data_len);
766 this->get_scene_mode();
767 this->get_sensitivity();
768}
769
771 this->send_query_(SET_RESTART, sizeof(SET_RESTART));
772 this->check_dev_inf_sign_ = true;
773}
774
776 uint8_t send_data_len = 10;
777 uint8_t send_data[10] = {0x53, 0x59, 0x80, 0x0a, 0x00, 0x01, value, 0x00, 0x54, 0x43};
778 send_data[7] = get_frame_crc_sum(send_data, send_data_len);
779 this->send_query_(send_data, send_data_len);
780 this->get_unmanned_time();
781}
782
784 if (mode == 0) {
785 this->set_custom_end_mode(); // Equivalent to end setting
786#ifdef USE_NUMBER
787 PUBLISH_STATE(this->custom_mode_number_, 0);
788#endif
789 return;
790 }
791 uint8_t send_data_len = 10;
792 uint8_t send_data[10] = {0x53, 0x59, 0x05, 0x09, 0x00, 0x01, mode, 0x00, 0x54, 0x43};
793 send_data[7] = get_frame_crc_sum(send_data, send_data_len);
794 this->send_query_(send_data, send_data_len);
796 this->get_motion_boundary();
798 this->get_motion_threshold();
801 this->get_custom_unman_time();
802 this->get_custom_mode();
803 this->get_scene_mode();
804 this->get_sensitivity();
805}
806
808 uint8_t send_data_len = 10;
809 uint8_t send_data[10] = {0x53, 0x59, 0x05, 0x0a, 0x00, 0x01, 0x0F, 0xCB, 0x54, 0x43};
810 this->send_query_(send_data, send_data_len);
811#ifdef USE_NUMBER
812 // Clear setpoints
813 PUBLISH_STATE(this->custom_mode_number_, 0);
814#endif
816 this->get_motion_boundary();
818 this->get_motion_threshold();
821 this->get_custom_unman_time();
822 this->get_custom_mode();
823 this->get_scene_mode();
824 this->get_sensitivity();
825}
826
828#ifdef USE_SENSOR
829 if ((this->custom_mode_num_sensor_ != nullptr) && (this->custom_mode_num_sensor_->state == 0))
830 return; // You'll have to check that you're in custom mode to set it up
831#endif
832 uint8_t send_data_len = 10;
833 uint8_t send_data[10] = {0x53, 0x59, 0x08, 0x0A, 0x00, 0x01, (uint8_t) (value + 1), 0x00, 0x54, 0x43};
834 send_data[7] = get_frame_crc_sum(send_data, send_data_len);
835 this->send_query_(send_data, send_data_len);
837}
838
840#ifdef USE_SENSOR
841 if ((this->custom_mode_num_sensor_ != nullptr) && (this->custom_mode_num_sensor_->state == 0))
842 return; // You'll have to check that you're in custom mode to set it up
843#endif
844 uint8_t send_data_len = 10;
845 uint8_t send_data[10] = {0x53, 0x59, 0x08, 0x0B, 0x00, 0x01, (uint8_t) (value + 1), 0x00, 0x54, 0x43};
846 send_data[7] = get_frame_crc_sum(send_data, send_data_len);
847 this->send_query_(send_data, send_data_len);
848 this->get_motion_boundary();
849}
850
852#ifdef USE_SENSOR
853 if ((this->custom_mode_num_sensor_ != nullptr) && (this->custom_mode_num_sensor_->state == 0))
854 return; // You'll have to check that you're in custom mode to set it up
855#endif
856 uint8_t send_data_len = 10;
857 uint8_t send_data[10] = {0x53, 0x59, 0x08, 0x08, 0x00, 0x01, value, 0x00, 0x54, 0x43};
858 send_data[7] = get_frame_crc_sum(send_data, send_data_len);
859 this->send_query_(send_data, send_data_len);
861}
862
864#ifdef USE_SENSOR
865 if ((this->custom_mode_num_sensor_ != nullptr) && (this->custom_mode_num_sensor_->state == 0))
866 return; // You'll have to check that you're in custom mode to set it up
867#endif
868 uint8_t send_data_len = 10;
869 uint8_t send_data[10] = {0x53, 0x59, 0x08, 0x09, 0x00, 0x01, value, 0x00, 0x54, 0x43};
870 send_data[7] = get_frame_crc_sum(send_data, send_data_len);
871 this->send_query_(send_data, send_data_len);
872 this->get_motion_threshold();
873}
874
876#ifdef USE_SENSOR
877 if ((this->custom_mode_num_sensor_ != nullptr) && (this->custom_mode_num_sensor_->state == 0))
878 return; // You'll have to check that you're in custom mode to set it up
879#endif
880 uint8_t send_data_len = 13;
881 uint8_t send_data[13] = {0x53, 0x59, 0x08, 0x0C, 0x00, 0x04, 0x00, 0x00, 0x00, value, 0x00, 0x54, 0x43};
882 send_data[10] = get_frame_crc_sum(send_data, send_data_len);
883 this->send_query_(send_data, send_data_len);
885}
886
888#ifdef USE_SENSOR
889 if ((this->custom_mode_num_sensor_ != nullptr) && (this->custom_mode_num_sensor_->state == 0))
890 return; // You'll have to check that you're in custom mode to set it up
891#endif
892 uint8_t h8_num = (value >> 8) & 0xff;
893 uint8_t l8_num = value & 0xff;
894 uint8_t send_data_len = 13;
895 uint8_t send_data[13] = {0x53, 0x59, 0x08, 0x0D, 0x00, 0x04, 0x00, 0x00, h8_num, l8_num, 0x00, 0x54, 0x43};
896 send_data[10] = get_frame_crc_sum(send_data, send_data_len);
897 this->send_query_(send_data, send_data_len);
899}
900
902#ifdef USE_SENSOR
903 if ((this->custom_mode_num_sensor_ != nullptr) && (this->custom_mode_num_sensor_->state == 0))
904 return; // You'll have to check that you're in custom mode to set it up
905#endif
906 uint32_t value_ms = value * 1000;
907 uint8_t h24_num = (value_ms >> 24) & 0xff;
908 uint8_t h16_num = (value_ms >> 16) & 0xff;
909 uint8_t h8_num = (value_ms >> 8) & 0xff;
910 uint8_t l8_num = value_ms & 0xff;
911 uint8_t send_data_len = 13;
912 uint8_t send_data[13] = {0x53, 0x59, 0x08, 0x0E, 0x00, 0x04, h24_num, h16_num, h8_num, l8_num, 0x00, 0x54, 0x43};
913 send_data[10] = get_frame_crc_sum(send_data, send_data_len);
914 this->send_query_(send_data, send_data_len);
915 this->get_custom_unman_time();
916}
917
918} // namespace esphome::seeed_mr24hpc1
BedjetMode mode
BedJet operating mode.
void set_timeout(const char *name, uint32_t timeout, std::function< void()> &&f)
Set a timeout function with a const char* name.
Definition component.cpp:96
void set_interval(const char *name, uint32_t interval, std::function< void()> &&f)
Set an interval function with a const char* name.
Definition component.cpp:88
bool read_available(F &&on_byte)
Same as read_available_chunks(), calling on_byte(uint8_t) once per byte.
Definition uart.h:77
void write_array(const uint8_t *data, size_t len)
Definition uart.h:30
std::span< const uint8_t > data
ESPHOME_LOG_TAG(TAG, "seeed_mr24hpc1")
PROGMEM_STRING_TABLE(MotionStatusStrings, "None", "Motionless", "Active")
constexpr uint8_t sum_bytes(const uint8_t *data, size_t len, uint8_t sum=0)
Add up the bytes of data with size len, truncated to 8 bits: the checksum many serial and IR protocol...
Definition helpers.h:939
uint32_t value
Definition hal.cpp:41
const void size_t len
Definition hal.h:68
constexpr T encode_value(const uint8_t *bytes)
Encode a value from its constituent bytes (from most to least significant) in an array with length si...
Definition helpers.h:1064
constexpr uint16_t encode_uint16(uint8_t msb, uint8_t lsb)
Encode a 16-bit value given the most and least significant byte.
Definition helpers.h:1043
static void uint32_t