15static constexpr uint8_t COMMAND_ACK = 0xE5;
16static constexpr uint32_t COMMAND_ACK_TIMEOUT_MS = 500;
17static constexpr uint32_t CLEAR_QUEUE_TIMEOUT_MS = 15000;
18static constexpr uint32_t STARTUP_DELAY_MS = 2000;
19static constexpr uint32_t POST_RESET_DELAY_MS = 2000;
20static constexpr uint32_t RESET_RETRY_DELAY_MS = 800;
21static constexpr uint32_t STARTUP_RETRY_MS = 3000;
22static constexpr uint32_t PASSIVE_POLL_INTERVAL_MS = 1000;
23static constexpr uint32_t ACTIVE_STALE_MS = 5000;
24static constexpr uint32_t PASSIVE_READ_TIMEOUT_MS = 1000;
25static constexpr uint32_t SOFTWARE_VERSION_READ_TIMEOUT_MS = 2000;
26static constexpr uint32_t SOFTWARE_VERSION_RETRY_MS = 30000;
27static constexpr uint8_t SOFTWARE_VERSION_MAX_ATTEMPTS = 3;
28static constexpr uint32_t ACTIVE_FRAME_TIMEOUT_MS = 3000;
30static constexpr uint8_t PASSIVE_FAIL_ESCALATE_COUNT = 8;
32static constexpr float L_PER_M3 = 1000.0f;
33static constexpr float M3_PER_L = 1.0f / L_PER_M3;
35static constexpr std::array<uint8_t, 7> ACTIVE_MODE = {0xFE, 0xFE, 0x11, 0x5C, 0x00, 0x5C, 0x16};
36static constexpr std::array<uint8_t, 7> PASSIVE_MODE = {0xFE, 0xFE, 0x11, 0x5C, 0x01, 0x5D, 0x16};
37static constexpr std::array<uint8_t, 7> CLEAR_ACCUMULATED_FLOW = {0xFE, 0xFE, 0x11, 0x5A, 0xFD, 0x57, 0x16};
38static constexpr std::array<uint8_t, 7> RESET_DEVICE = {0xFE, 0xFE, 0x11, 0x5D, 0xCB, 0x28, 0x16};
39static constexpr std::array<uint8_t, 7> READ_SENSOR_DATA_NO_ID = {0xFE, 0xFE, 0x11, 0x5B, 0x0F, 0x6A, 0x16};
40static constexpr std::array<uint8_t, 7> READ_SENSOR_DATA_WITH_ID = {0xFE, 0xFE, 0x11, 0x5B, 0xCB, 0x26, 0x16};
41static constexpr std::array<uint8_t, 7> GET_SOFTWARE_VERSION = {0xFE, 0xFE, 0x11, 0x5E, 0x62, 0xC0, 0x16};
44static constexpr size_t FRAME_DEVICE_ID_INDEX = 2;
45static constexpr size_t FRAME_CHECKSUM_INDEX = 30;
46static constexpr size_t FRAME_STOP_INDEX = 31;
47static constexpr uint8_t PASSIVE_START_BYTE_2 = 0x64;
48static constexpr uint8_t PASSIVE_START_BYTE_2_WITH_ID = 0x96;
49static constexpr uint8_t FRAME_STOP_BYTE = 0x16;
50static constexpr size_t PASSIVE_WITH_ID_DEVICE_ID_INDEX = 2;
51static constexpr uint8_t PASSIVE_WITH_ID_ACC_FLOW_FLAG_INDEX = 8;
52static constexpr uint8_t PASSIVE_WITH_ID_INSTANT_FLOW_FLAG_INDEX = 22;
53static constexpr uint8_t PASSIVE_WITH_ID_TEMP_FLAG_INDEX = 31;
54static constexpr uint8_t PASSIVE_WITH_ID_ST1_INDEX = 35;
55static constexpr size_t PASSIVE_WITH_ID_CHECKSUM_INDEX = 37;
56static constexpr size_t PASSIVE_WITH_ID_STOP_INDEX = 38;
57static constexpr uint8_t FRAME_INDEX_INSTANT_FLOW_FLAG = 15;
58static constexpr uint8_t FRAME_INDEX_RESERVED_SECTION = 21;
59static constexpr uint8_t FRAME_INDEX_TEMP_FLAG = 24;
60static constexpr uint8_t FRAME_FLAG_INSTANT_FLOW = 0x0B;
61static constexpr uint8_t FRAME_FLAG_RESERVED_SECTION = 0x0C;
62static constexpr uint8_t FRAME_FLAG_TEMP = 0x0D;
65static constexpr uint8_t FRAME_ACC_FLOW_FLAG_INDEX = 8;
66static constexpr uint8_t ACC_FLOW_M3_FLAG = 0x1A;
67static constexpr uint8_t FRAME_FLOW_SIGN_INDEX = 20;
68static constexpr uint8_t FLOW_NEGATIVE_SIGN = 0x80;
71static constexpr uint8_t FRAME_ST1_INDEX = 28;
72static constexpr uint8_t FRAME_ST2_INDEX = 29;
73static constexpr uint8_t ST1_EMPTY_TUBE_MASK = 0x20;
74static constexpr uint8_t ST2_UFC_ERROR_MASK = 0x20;
75static constexpr uint8_t ST2_FLOW_DIRECTION_WRONG_MASK = 0x08;
76static constexpr uint8_t ST2_FLOW_RATE_OUT_OF_RANGE_MASK = 0x04;
78static_assert(SOFTWARE_VERSION_RESPONSE_SIZE <= PASSIVE_FRAME_MAX_SIZE,
"software version read reuses passive_frame_");
79static constexpr size_t SOFTWARE_VERSION_CHECKSUM_INDEX = 5;
80static constexpr size_t SOFTWARE_VERSION_STOP_INDEX = 6;
82static float to_float(uint8_t data) {
return bcd_to_uint8(data); }
84static bool bcd_to_digits(
const uint8_t *data,
size_t len,
char *
out) {
86 for (
size_t i = 0; i <
len; ++i) {
87 const uint8_t lo =
data[i] & 0x0F;
88 const uint8_t hi =
data[i] >> 4;
91 const size_t pos = (
len - 1 - i) * 2;
94 out[
pos] =
static_cast<char>(
'0' + hi);
97 out[
pos + 1] =
static_cast<char>(
'0' + lo);
103static bool validate_software_version_response(
const uint8_t data[SOFTWARE_VERSION_RESPONSE_SIZE]) {
104 if (data[0] != COMMAND_ACK || data[SOFTWARE_VERSION_STOP_INDEX] != FRAME_STOP_BYTE)
106 return data[SOFTWARE_VERSION_CHECKSUM_INDEX] ==
sum_bytes(data + 1, SOFTWARE_VERSION_CHECKSUM_INDEX - 1);
109static bool check_byte(
const uint8_t data[FRAME_SIZE],
size_t index, uint8_t expected,
const char *name) {
110 if (data[index] == expected)
112 ESP_LOGW(TAG,
"%s (byte %zu) - expected 0x%02X, but was 0x%02X", name, index, expected, data[index]);
116static bool validate_active_frame(
const uint8_t data[FRAME_SIZE]) {
117 const uint8_t sum =
sum_bytes(data, FRAME_CHECKSUM_INDEX);
119 return check_byte(data, FRAME_INDEX_INSTANT_FLOW_FLAG, FRAME_FLAG_INSTANT_FLOW,
"instant flow flag") &&
120 check_byte(data, FRAME_INDEX_RESERVED_SECTION, FRAME_FLAG_RESERVED_SECTION,
"reserved section flag") &&
121 check_byte(data, FRAME_INDEX_TEMP_FLAG, FRAME_FLAG_TEMP,
"temperature flag") &&
122 check_byte(data, FRAME_CHECKSUM_INDEX, sum,
"checksum") &&
123 check_byte(data, FRAME_STOP_INDEX, FRAME_STOP_BYTE,
"stop byte");
126static bool validate_passive_frame(
const uint8_t data[PASSIVE_FRAME_SIZE]) {
127 if (data[0] != FRAME_START_BYTE_1 || data[1] != PASSIVE_START_BYTE_2 || data[22] != FRAME_STOP_BYTE)
132#ifdef USE_UFM01_METER_ID
133static bool validate_passive_with_id_frame(
const uint8_t data[PASSIVE_FRAME_WITH_ID_SIZE]) {
134 if (data[0] != FRAME_START_BYTE_1 || data[1] != PASSIVE_START_BYTE_2_WITH_ID ||
135 data[PASSIVE_WITH_ID_STOP_INDEX] != FRAME_STOP_BYTE)
137 return data[PASSIVE_WITH_ID_CHECKSUM_INDEX] ==
sum_bytes(data, PASSIVE_WITH_ID_CHECKSUM_INDEX);
142struct PassiveLayout {
144 uint8_t instant_flow;
148static constexpr PassiveLayout PASSIVE_NO_ID_LAYOUT{2, 9, 15, 19};
149#ifdef USE_UFM01_METER_ID
150static constexpr PassiveLayout PASSIVE_WITH_ID_LAYOUT{PASSIVE_WITH_ID_ACC_FLOW_FLAG_INDEX,
151 PASSIVE_WITH_ID_INSTANT_FLOW_FLAG_INDEX,
152 PASSIVE_WITH_ID_TEMP_FLAG_INDEX, PASSIVE_WITH_ID_ST1_INDEX};
155static void passive_to_active_frame(
const uint8_t *passive,
const PassiveLayout &layout, uint8_t active[FRAME_SIZE]) {
156 std::memset(active, 0, FRAME_SIZE);
157 active[0] = FRAME_START_BYTE_1;
158 active[1] = FRAME_START_BYTE_2;
159 std::copy_n(&passive[layout.acc_flow], 7, &active[FRAME_ACC_FLOW_FLAG_INDEX]);
160 std::copy_n(&passive[layout.instant_flow], 6, &active[FRAME_INDEX_INSTANT_FLOW_FLAG]);
161 active[FRAME_INDEX_RESERVED_SECTION] = FRAME_FLAG_RESERVED_SECTION;
162 std::copy_n(&passive[layout.temperature], 4, &active[FRAME_INDEX_TEMP_FLAG]);
163 std::copy_n(&passive[layout.status], 3, &active[FRAME_ST1_INDEX]);
164 active[FRAME_STOP_INDEX] = FRAME_STOP_BYTE;
167static float read_accumulated_flow(
const uint8_t data[FRAME_SIZE]) {
168 return (data[FRAME_ACC_FLOW_FLAG_INDEX] == ACC_FLOW_M3_FLAG ? L_PER_M3 : 1.0f) *
169 (to_float(data[14]) * 10000000.0f + to_float(data[13]) * 100000.0f + to_float(data[12]) * 1000.0f +
170 to_float(data[11]) * 10.0f + to_float(data[10]) * 0.1f + to_float(data[9]) * 0.001f);
173static float read_flow(
const uint8_t data[FRAME_SIZE]) {
174 return (data[FRAME_FLOW_SIGN_INDEX] == FLOW_NEGATIVE_SIGN ? -1.0f : 1.0f) *
175 (to_float(data[19]) * 10000.0f + to_float(data[18]) * 100.0f + to_float(data[17]) +
176 to_float(data[16]) * 0.01f) *
180static constexpr size_t LOG_HEX_MAX_SIZE = std::max(FRAME_SIZE, PASSIVE_FRAME_MAX_SIZE);
182static void log_hex(
const uint8_t *data,
size_t len) {
187static float read_temperature(
const uint8_t data[FRAME_SIZE]) {
189 if (data[27] == 0x00 && (data[26] == 0x00 || data[26] == 0x70) && data[25] == 0x00) {
192 return to_float(data[27]) * 100.0f + to_float(data[26]) + to_float(data[25]) * 0.01f;
195static bool read_ufc_chip_error(
const uint8_t data[FRAME_SIZE]) {
return data[FRAME_ST2_INDEX] & ST2_UFC_ERROR_MASK; }
197static bool read_flow_direction_wrong(
const uint8_t data[FRAME_SIZE]) {
198 return data[FRAME_ST2_INDEX] & ST2_FLOW_DIRECTION_WRONG_MASK;
201static bool read_empty_tube(
const uint8_t data[FRAME_SIZE]) {
return data[FRAME_ST1_INDEX] & ST1_EMPTY_TUBE_MASK; }
203static bool read_flow_rate_out_of_range(
const uint8_t data[FRAME_SIZE]) {
204 return data[FRAME_ST2_INDEX] & ST2_FLOW_RATE_OUT_OF_RANGE_MASK;
207void UFM01Component::flush_rx_() {
209 this->active_reader_.
reset();
212void UFM01Component::send_command_no_wait_(
const std::array<uint8_t, 7> &command) {
218bool UFM01Component::consume_ack_() {
223 if (
byte == COMMAND_ACK)
225 ESP_LOGV(TAG,
"Unexpected byte while waiting for command ACK: 0x%02X",
byte);
230#ifdef USE_UFM01_CLEAR_ACCUMULATED_FLOW_ACTION
231bool UFM01Component::can_start_clear_action_()
const {
233#ifdef USE_UFM01_SOFTWARE_VERSION
234 !this->software_version_read_pending_ &&
240void UFM01Component::request_clear_accumulated_flow() {
241 if (this->clear_pending_) {
242 ESP_LOGD(TAG,
"Clear accumulated flow already pending");
245 this->clear_pending_ =
true;
246 this->pending_clear_sent_ =
false;
250void UFM01Component::finish_pending_clear_() {
251 this->clear_pending_ =
false;
252 this->pending_clear_sent_ =
false;
255void UFM01Component::loop_pending_clear_action_(
uint32_t now) {
256 if (!this->clear_pending_)
258 if (!this->pending_clear_sent_) {
259 if (!this->can_start_clear_action_()) {
260 if (now - this->pending_clear_start_ms_ < CLEAR_QUEUE_TIMEOUT_MS)
262 ESP_LOGW(TAG,
"Clear accumulated flow timed out waiting for an idle UART");
263 this->finish_pending_clear_();
266 this->pending_clear_start_ms_ = now;
267 this->pending_clear_sent_ =
true;
268 this->send_command_no_wait_(CLEAR_ACCUMULATED_FLOW);
271 if (this->consume_ack_()) {
272 ESP_LOGI(TAG,
"Clear accumulated flow acknowledged");
273 this->finish_pending_clear_();
276 if (now - this->pending_clear_start_ms_ < COMMAND_ACK_TIMEOUT_MS)
278 ESP_LOGW(TAG,
"Clear accumulated flow not acknowledged");
279 this->finish_pending_clear_();
286 ESP_LOGI(TAG,
"Setting up UFM-01...");
287 this->startup_wait_ms_ = STARTUP_DELAY_MS;
291void UFM01Component::dump_config() {
292 ESP_LOGCONFIG(TAG,
"UFM-01:");
294 LOG_SENSOR(
" ",
"Accumulated Flow", this->accumulated_flow_sensor_);
295 LOG_SENSOR(
" ",
"Flow", this->flow_sensor_);
296 LOG_SENSOR(
" ",
"Temperature", this->temperature_sensor_);
298#ifdef USE_BINARY_SENSOR
299 LOG_BINARY_SENSOR(
" ",
"UFC Chip Error", this->ufc_chip_error_binary_sensor_);
300 LOG_BINARY_SENSOR(
" ",
"Flow Direction Wrong", this->flow_direction_wrong_binary_sensor_);
301 LOG_BINARY_SENSOR(
" ",
"Empty Tube", this->empty_tube_binary_sensor_);
302 LOG_BINARY_SENSOR(
" ",
"Flow Rate Out Of Range", this->flow_rate_out_of_range_binary_sensor_);
304#ifdef USE_UFM01_METER_ID
305 LOG_TEXT_SENSOR(
" ",
"Meter ID", this->meter_id_text_sensor_);
307#ifdef USE_UFM01_SOFTWARE_VERSION
308 LOG_TEXT_SENSOR(
" ",
"Software Version", this->software_version_text_sensor_);
313void UFM01Component::publish_stale_flow_and_temperature_() {
315 PUBLISH_STATE(this->flow_sensor_, NAN);
316 PUBLISH_STATE(this->temperature_sensor_, NAN);
320#ifdef USE_UFM01_METER_ID
321void UFM01Component::publish_meter_id_from_frame_(
const uint8_t data[FRAME_SIZE]) {
322 if (this->meter_id_text_sensor_ ==
nullptr || this->meter_id_published_)
325 char meter_id_str[DEVICE_ID_STRING_LENGTH + 1];
326 if (!bcd_to_digits(&data[FRAME_DEVICE_ID_INDEX], DEVICE_ID_LENGTH, meter_id_str)) {
327 if (!this->meter_id_invalid_logged_) {
328 ESP_LOGW(TAG,
"Meter ID in frame is zero or not BCD, leaving the sensor unknown");
329 this->meter_id_invalid_logged_ =
true;
334 this->meter_id_text_sensor_->publish_state(meter_id_str);
335 this->meter_id_published_ =
true;
336 ESP_LOGI(TAG,
"UFM-01 meter ID: %s", meter_id_str);
340#ifdef USE_UFM01_SOFTWARE_VERSION
341void UFM01Component::start_software_version_read_(
uint32_t now) {
342 this->send_command_no_wait_(GET_SOFTWARE_VERSION);
343 this->passive_index_ = 0;
344 this->passive_start_ms_ = now;
345 this->software_version_read_pending_ =
true;
349 while (this->
available() && this->passive_index_ < SOFTWARE_VERSION_RESPONSE_SIZE) {
354 if (this->passive_index_ == 0 &&
byte != COMMAND_ACK)
356 this->passive_frame_[this->passive_index_++] = byte;
359 if (this->passive_index_ < SOFTWARE_VERSION_RESPONSE_SIZE) {
360 if (now - this->passive_start_ms_ < SOFTWARE_VERSION_READ_TIMEOUT_MS)
362 ESP_LOGD(TAG,
"software version read timeout (%u/%u bytes)", this->passive_index_,
363 static_cast<unsigned>(SOFTWARE_VERSION_RESPONSE_SIZE));
367 if (!validate_software_version_response(this->passive_frame_)) {
368 log_hex(this->passive_frame_, SOFTWARE_VERSION_RESPONSE_SIZE);
369 ESP_LOGW(TAG,
"invalid software version response");
373 if (this->software_version_text_sensor_ !=
nullptr && !this->software_version_published_) {
374 char version_str[SOFTWARE_VERSION_STRING_LENGTH + 1];
375 if (!bcd_to_digits(&this->passive_frame_[1], SOFTWARE_VERSION_LENGTH, version_str)) {
376 ESP_LOGW(TAG,
"invalid BCD data in software version response");
379 this->software_version_text_sensor_->publish_state(version_str);
380 this->software_version_published_ =
true;
381 ESP_LOGI(TAG,
"UFM-01 software version: %s", version_str);
388 this->software_version_read_pending_ =
false;
389 this->last_software_version_attempt_ms_ = now;
391 ++this->software_version_failures_ == SOFTWARE_VERSION_MAX_ATTEMPTS) {
392 ESP_LOGW(TAG,
"Software version not read after %u attempts, giving up", SOFTWARE_VERSION_MAX_ATTEMPTS);
397bool UFM01Component::service_software_version_(
uint32_t now) {
398 if (this->software_version_read_pending_) {
399 const ReadResult result = this->continue_software_version_read_(now);
401 this->finish_software_version_read_(result, now);
404 if (this->software_version_text_sensor_ ==
nullptr || this->software_version_published_ ||
405 this->software_version_failures_ >= SOFTWARE_VERSION_MAX_ATTEMPTS || this->passive_read_pending_)
407 if (this->last_software_version_attempt_ms_ != 0 &&
408 now - this->last_software_version_attempt_ms_ < SOFTWARE_VERSION_RETRY_MS)
410 this->start_software_version_read_(now);
415void UFM01Component::on_active_frame_(
const uint8_t data[FRAME_SIZE],
uint32_t now) {
416#ifdef USE_UFM01_METER_ID
417 this->publish_meter_id_from_frame_(data);
419 bool empty_tube = read_empty_tube(data);
420#ifdef USE_BINARY_SENSOR
421 PUBLISH_STATE(this->ufc_chip_error_binary_sensor_, read_ufc_chip_error(data));
422 PUBLISH_STATE(this->flow_direction_wrong_binary_sensor_, read_flow_direction_wrong(data));
423 PUBLISH_STATE(this->empty_tube_binary_sensor_, empty_tube);
424 PUBLISH_STATE(this->flow_rate_out_of_range_binary_sensor_, read_flow_rate_out_of_range(data));
429 PUBLISH_STATE(this->accumulated_flow_sensor_, read_accumulated_flow(data));
432 this->publish_stale_flow_and_temperature_();
434 PUBLISH_STATE(this->flow_sensor_, read_flow(data));
435 PUBLISH_STATE(this->temperature_sensor_, read_temperature(data));
438 this->last_valid_frame_ms_ = now;
443bool UFM01Component::process_active_stream_(
uint32_t now) {
444 bool got_valid_frame =
false;
446 const bool read_ok = this->
read_available([
this, now, &got_valid_frame](uint8_t
byte) {
447 const uint8_t *frame = this->active_reader_.
feed(
byte);
448 if (frame ==
nullptr) {
449 if (this->active_reader_.
length() == 0) {
450 ESP_LOGD(TAG,
"not start of data (is 0x%02X)",
byte);
454 if (validate_active_frame(frame)) {
455 this->on_active_frame_(frame, now);
456 got_valid_frame =
true;
459 log_hex(frame, FRAME_SIZE);
460 ESP_LOGW(TAG,
"unable to read data");
461 this->active_reader_.
resync();
464 ESP_LOGW(TAG,
"unable to read byte");
465 this->active_reader_.
reset();
468 return got_valid_frame;
472 this->operating_mode_ =
mode;
473 this->phase_start_ms_ = now;
474 this->passive_read_pending_ =
false;
475#ifdef USE_UFM01_SOFTWARE_VERSION
476 this->software_version_read_pending_ =
false;
478 this->consecutive_passive_failures_ = 0;
482 this->startup_phase_ = phase;
483 this->phase_start_ms_ = now;
486void UFM01Component::send_reset_(
const LogString *status,
uint32_t now) {
488 this->reset_retried_ =
false;
489 this->send_command_no_wait_(RESET_DEVICE);
493void UFM01Component::enter_active_stream_(
const LogString *reason,
uint32_t now) {
494 ESP_LOGI(TAG,
"UFM-01 active stream %s", LOG_STR_ARG(reason));
498void UFM01Component::enter_passive_from_stale_(
uint32_t now) {
499 ESP_LOGW(TAG,
"Active stream stale, switching to passive polling");
500 this->publish_stale_flow_and_temperature_();
502 this->send_command_no_wait_(PASSIVE_MODE);
504 this->last_poll_ms_ = now;
508void UFM01Component::restart_startup_(
const LogString *reason,
uint32_t now) {
509 ESP_LOGW(TAG,
"%s, re-initializing UFM-01", LOG_STR_ARG(reason));
510 this->publish_stale_flow_and_temperature_();
512 this->send_reset_(LOG_STR(
"re-initializing UFM-01"), now);
515void UFM01Component::note_passive_poll_result_(
bool success,
uint32_t now) {
517 this->consecutive_passive_failures_ = 0;
521 if (++this->consecutive_passive_failures_ < PASSIVE_FAIL_ESCALATE_COUNT)
523 this->restart_startup_(LOG_STR(
"Passive poll failed repeatedly"), now);
526void UFM01Component::start_passive_read_(
uint32_t now) {
527#ifdef USE_UFM01_METER_ID
528 if (this->meter_id_text_sensor_ !=
nullptr && !this->meter_id_published_) {
529 this->passive_expected_size_ = PASSIVE_FRAME_WITH_ID_SIZE;
530 this->passive_start_byte_2_ = PASSIVE_START_BYTE_2_WITH_ID;
531 this->send_command_no_wait_(READ_SENSOR_DATA_WITH_ID);
535 this->passive_expected_size_ = PASSIVE_FRAME_SIZE;
536 this->passive_start_byte_2_ = PASSIVE_START_BYTE_2;
537 this->send_command_no_wait_(READ_SENSOR_DATA_NO_ID);
539 this->passive_index_ = 0;
540 this->passive_start_ms_ = now;
544 const uint8_t expected_size = this->passive_expected_size_;
546 while (this->
available() && this->passive_index_ < expected_size) {
551 if (this->passive_index_ == 0 &&
byte != FRAME_START_BYTE_1)
553 if (this->passive_index_ == 1 &&
byte != this->passive_start_byte_2_) {
555 this->passive_index_ = (
byte == FRAME_START_BYTE_1) ? 1 : 0;
558 this->passive_frame_[this->passive_index_++] = byte;
561 if (this->passive_index_ < expected_size) {
562 if (now - this->passive_start_ms_ < PASSIVE_READ_TIMEOUT_MS)
564 ESP_LOGD(TAG,
"passive read timeout (%u/%u bytes)", this->passive_index_, expected_size);
568 uint8_t active_frame[FRAME_SIZE];
569#ifdef USE_UFM01_METER_ID
570 if (expected_size == PASSIVE_FRAME_WITH_ID_SIZE) {
571 if (!validate_passive_with_id_frame(this->passive_frame_)) {
572 log_hex(this->passive_frame_, PASSIVE_FRAME_WITH_ID_SIZE);
573 ESP_LOGW(TAG,
"invalid passive frame with ID");
576 passive_to_active_frame(this->passive_frame_, PASSIVE_WITH_ID_LAYOUT, active_frame);
578 std::copy_n(&this->passive_frame_[PASSIVE_WITH_ID_DEVICE_ID_INDEX], DEVICE_ID_LENGTH + 1,
579 &active_frame[FRAME_DEVICE_ID_INDEX]);
583 if (!validate_passive_frame(this->passive_frame_)) {
584 log_hex(this->passive_frame_, PASSIVE_FRAME_SIZE);
585 ESP_LOGW(TAG,
"invalid passive frame");
588 passive_to_active_frame(this->passive_frame_, PASSIVE_NO_ID_LAYOUT, active_frame);
589 active_frame[FRAME_DEVICE_ID_INDEX + DEVICE_ID_LENGTH] = 0x01;
591 this->on_active_frame_(active_frame, now);
595void UFM01Component::loop_startup_(
uint32_t now) {
596 const uint32_t elapsed = now - this->phase_start_ms_;
598 switch (this->startup_phase_) {
601 if (this->process_active_stream_(now)) {
602 this->enter_active_stream_(LOG_STR(
"started"), now);
605 if (elapsed < this->startup_wait_ms_)
607 ESP_LOGD(TAG,
"Running startup sequence");
608 this->send_reset_(LOG_STR(
"initializing UFM-01"), now);
612 if (this->consume_ack_()) {
616 if (elapsed < COMMAND_ACK_TIMEOUT_MS)
618 if (!this->reset_retried_) {
619 ESP_LOGW(TAG,
"Reset not acknowledged, retrying in %" PRIu32
" ms", RESET_RETRY_DELAY_MS);
622 ESP_LOGW(TAG,
"Reset failed during startup");
628 if (elapsed < RESET_RETRY_DELAY_MS)
630 this->reset_retried_ =
true;
631 this->send_command_no_wait_(RESET_DEVICE);
636 if (elapsed < POST_RESET_DELAY_MS)
638#ifdef USE_UFM01_SOFTWARE_VERSION
639 if (this->software_version_text_sensor_ !=
nullptr && !this->software_version_published_ &&
640 this->software_version_failures_ < SOFTWARE_VERSION_MAX_ATTEMPTS) {
641 this->start_software_version_read_(now);
646 this->send_command_no_wait_(ACTIVE_MODE);
650#ifdef USE_UFM01_SOFTWARE_VERSION
652 const ReadResult result = this->continue_software_version_read_(now);
656 ESP_LOGD(TAG,
"Software version read during startup");
658 ESP_LOGW(TAG,
"Software version read failed during startup, continuing");
660 this->finish_software_version_read_(result, now);
661 this->send_command_no_wait_(ACTIVE_MODE);
669 if (this->process_active_stream_(now)) {
670 this->enter_active_stream_(LOG_STR(
"started"), now);
673 if (elapsed < ACTIVE_FRAME_TIMEOUT_MS)
675 this->send_command_no_wait_(PASSIVE_MODE);
680 if (this->consume_ack_()) {
681 ESP_LOGD(TAG,
"Passive mode acknowledged during startup");
682 }
else if (elapsed < COMMAND_ACK_TIMEOUT_MS) {
685 ESP_LOGW(TAG,
"SET_PASSIVE_MODE not acknowledged during startup, continuing");
687 this->start_passive_read_(now);
692 switch (this->continue_passive_read_(now)) {
696 ESP_LOGI(TAG,
"UFM-01 using passive polling");
698 this->last_poll_ms_ = now;
701 ESP_LOGW(TAG,
"Startup failed, retrying in %" PRIu32
" ms", STARTUP_RETRY_MS);
702 this->startup_wait_ms_ = STARTUP_RETRY_MS;
709void UFM01Component::loop_active_stream_(
uint32_t now) {
710#ifdef USE_UFM01_SOFTWARE_VERSION
711 if (this->service_software_version_(now))
715 this->process_active_stream_(now);
717 if (this->last_valid_frame_ms_ != 0 && now - this->last_valid_frame_ms_ > ACTIVE_STALE_MS)
718 this->enter_passive_from_stale_(now);
721void UFM01Component::loop_passive_poll_(
uint32_t now) {
722#ifdef USE_UFM01_SOFTWARE_VERSION
723 if (this->service_software_version_(now))
727 if (this->passive_read_pending_) {
728 const ReadResult result = this->continue_passive_read_(now);
731 this->passive_read_pending_ =
false;
736 if (this->process_active_stream_(now)) {
737 this->enter_active_stream_(LOG_STR(
"resumed"), now);
741 if (now - this->last_poll_ms_ >= PASSIVE_POLL_INTERVAL_MS) {
742 this->last_poll_ms_ = now;
743 this->start_passive_read_(now);
744 this->passive_read_pending_ =
true;
748void UFM01Component::loop() {
750#ifdef USE_UFM01_CLEAR_ACCUMULATED_FLOW_ACTION
751 this->loop_pending_clear_action_(now);
752 if (this->clear_pending_ && this->pending_clear_sent_)
755 switch (this->operating_mode_) {
757 this->loop_startup_(now);
760 this->loop_active_stream_(now);
763 this->loop_passive_poll_(now);