ESPHome 2026.11.0b6
Loading...
Searching...
No Matches
ezo_pmp.cpp
Go to the documentation of this file.
1#include "ezo_pmp.h"
2#include "esphome/core/log.h"
3#include "esphome/core/hal.h"
5
6namespace esphome::ezo_pmp {
7
8ESPHOME_LOG_TAG(TAG, "ezo-pmp");
9
10static const uint16_t EZO_PMP_COMMAND_NONE = 0;
11static const uint16_t EZO_PMP_COMMAND_TYPE_READ = 1;
12
13static const uint16_t EZO_PMP_COMMAND_FIND = 2;
14static const uint16_t EZO_PMP_COMMAND_DOSE_CONTINUOUSLY = 4;
15static const uint16_t EZO_PMP_COMMAND_DOSE_VOLUME = 8;
16static const uint16_t EZO_PMP_COMMAND_DOSE_VOLUME_OVER_TIME = 16;
17static const uint16_t EZO_PMP_COMMAND_DOSE_WITH_CONSTANT_FLOW_RATE = 32;
18static const uint16_t EZO_PMP_COMMAND_SET_CALIBRATION_VOLUME = 64;
19static const uint16_t EZO_PMP_COMMAND_CLEAR_TOTAL_VOLUME_DOSED = 128;
20static const uint16_t EZO_PMP_COMMAND_CLEAR_CALIBRATION = 256;
21static const uint16_t EZO_PMP_COMMAND_PAUSE_DOSING = 512;
22static const uint16_t EZO_PMP_COMMAND_STOP_DOSING = 1024;
23static const uint16_t EZO_PMP_COMMAND_CHANGE_I2C_ADDRESS = 2048;
24static const uint16_t EZO_PMP_COMMAND_EXEC_ARBITRARY_COMMAND_ADDRESS = 4096;
25
26static const uint16_t EZO_PMP_COMMAND_READ_DOSING = 3;
27static const uint16_t EZO_PMP_COMMAND_READ_SINGLE_REPORT = 5;
28static const uint16_t EZO_PMP_COMMAND_READ_MAX_FLOW_RATE = 9;
29static const uint16_t EZO_PMP_COMMAND_READ_PAUSE_STATUS = 17;
30static const uint16_t EZO_PMP_COMMAND_READ_TOTAL_VOLUME_DOSED = 33;
31static const uint16_t EZO_PMP_COMMAND_READ_ABSOLUTE_TOTAL_VOLUME_DOSED = 65;
32static const uint16_t EZO_PMP_COMMAND_READ_CALIBRATION_STATUS = 129;
33static const uint16_t EZO_PMP_COMMAND_READ_PUMP_VOLTAGE = 257;
34
35#ifdef USE_TEXT_SENSOR
43PROGMEM_STRING_TABLE(DosingModeStrings, "None", "Volume", "Volume/Time", "Constant Flow Rate", "Continuous");
44
45static void publish_dosing_mode(text_sensor::TextSensor *sensor, DosingMode mode) {
46 if (sensor == nullptr)
47 return;
48 const ProgmemStr name = DosingModeStrings::get_progmem_str(mode, DOSING_MODE_NONE);
49 if (ESPHOME_strcmp_P(sensor->state.c_str(), reinterpret_cast<ESPHOME_PGM_P>(name)) != 0)
50 sensor->publish_state(name);
51}
52#endif
53
55 LOG_I2C_DEVICE(this);
56 LOG_UPDATE_INTERVAL(this);
57}
58
60 if (this->is_waiting_) {
61 return;
62 }
63
64 if (this->is_first_read_) {
65#ifdef USE_TEXT_SENSOR
66 this->queue_command_(EZO_PMP_COMMAND_READ_CALIBRATION_STATUS, 0, 0, (bool) this->calibration_status_text_sensor_);
67#endif
68#ifdef USE_SENSOR
69 this->queue_command_(EZO_PMP_COMMAND_READ_MAX_FLOW_RATE, 0, 0, (bool) this->max_flow_rate_sensor_);
70 this->queue_command_(EZO_PMP_COMMAND_READ_SINGLE_REPORT, 0, 0, (bool) this->current_volume_dosed_sensor_);
71 this->queue_command_(EZO_PMP_COMMAND_READ_TOTAL_VOLUME_DOSED, 0, 0, (bool) this->total_volume_dosed_sensor_);
72 this->queue_command_(EZO_PMP_COMMAND_READ_ABSOLUTE_TOTAL_VOLUME_DOSED, 0, 0,
73 (bool) this->absolute_total_volume_dosed_sensor_);
74#endif
75 this->queue_command_(EZO_PMP_COMMAND_READ_PAUSE_STATUS, 0, 0, true);
76 this->is_first_read_ = false;
77 }
78
79 if (!this->is_waiting_ && this->peek_next_command_() == EZO_PMP_COMMAND_NONE) {
80 this->queue_command_(EZO_PMP_COMMAND_READ_DOSING, 0, 0, true);
81
82#ifdef USE_SENSOR
83 if (this->is_dosing_flag_) {
84 this->queue_command_(EZO_PMP_COMMAND_READ_SINGLE_REPORT, 0, 0, (bool) this->current_volume_dosed_sensor_);
85 this->queue_command_(EZO_PMP_COMMAND_READ_TOTAL_VOLUME_DOSED, 0, 0, (bool) this->total_volume_dosed_sensor_);
86 this->queue_command_(EZO_PMP_COMMAND_READ_ABSOLUTE_TOTAL_VOLUME_DOSED, 0, 0,
87 (bool) this->absolute_total_volume_dosed_sensor_);
88 }
89
90 this->queue_command_(EZO_PMP_COMMAND_READ_PUMP_VOLTAGE, 0, 0, (bool) this->pump_voltage_sensor_);
91#endif
92 } else {
93 ESP_LOGV(TAG, "Not Scheduling new Command during update()");
94 }
95}
96
98 // If we are not waiting for anything and there is no command to be sent, return
99 if (!this->is_waiting_ && this->peek_next_command_() == EZO_PMP_COMMAND_NONE) {
100 return;
101 }
102
103 // If we are not waiting for anything and there IS a command to be sent, do it.
104 if (!this->is_waiting_ && this->peek_next_command_() != EZO_PMP_COMMAND_NONE) {
105 this->send_next_command_();
106 }
107
108 // If we are waiting for something but it isn't ready yet, then return
109 if (this->is_waiting_ && millis() - this->start_time_ < this->wait_time_) {
110 return;
111 }
112
113 // We are waiting for something and it should be ready.
114 this->read_command_result_();
115}
116
118 this->current_command_ = EZO_PMP_COMMAND_NONE;
119 this->is_waiting_ = false;
120}
121
123 uint8_t response_buffer[21] = {'\0'};
124
125 response_buffer[0] = 0;
126 if (!this->read_bytes_raw(response_buffer, 20)) {
127 ESP_LOGE(TAG, "read error");
129 return;
130 }
131
132 switch (response_buffer[0]) {
133 case 254:
134 return; // keep waiting
135 case 1:
136 break;
137 case 2:
138 ESP_LOGE(TAG, "device returned a syntax error");
140 return;
141 case 255:
142 ESP_LOGE(TAG, "device returned no data");
144 return;
145 default:
146 ESP_LOGE(TAG, "device returned an unknown response: %d", response_buffer[0]);
148 return;
149 }
150
151 char first_parameter_buffer[10] = {'\0'};
152 char second_parameter_buffer[10] = {'\0'};
153 char third_parameter_buffer[10] = {'\0'};
154
155 first_parameter_buffer[0] = '\0';
156 second_parameter_buffer[0] = '\0';
157 third_parameter_buffer[0] = '\0';
158
159 int current_parameter = 1;
160
161 size_t position_in_parameter_buffer = 0;
162 // some sensors return multiple comma-separated values, terminate string after first one
163 for (size_t i = 1; i < sizeof(response_buffer) - 1; i++) {
164 char current_char = response_buffer[i];
165
166 if (current_char == '\0') {
167 ESP_LOGV(TAG,
168 "Read Response from device: %s\n"
169 " First Component: %s\n"
170 " Second Component: %s\n"
171 " Third Component: %s",
172 (char *) response_buffer, (char *) first_parameter_buffer, (char *) second_parameter_buffer,
173 (char *) third_parameter_buffer);
174
175 break;
176 }
177
178 if (current_char == ',') {
179 current_parameter++;
180 position_in_parameter_buffer = 0;
181 continue;
182 }
183
184 if (position_in_parameter_buffer < sizeof(first_parameter_buffer) - 1) {
185 switch (current_parameter) {
186 case 1:
187 first_parameter_buffer[position_in_parameter_buffer] = current_char;
188 first_parameter_buffer[position_in_parameter_buffer + 1] = '\0';
189 break;
190 case 2:
191 second_parameter_buffer[position_in_parameter_buffer] = current_char;
192 second_parameter_buffer[position_in_parameter_buffer + 1] = '\0';
193 break;
194 case 3:
195 third_parameter_buffer[position_in_parameter_buffer] = current_char;
196 third_parameter_buffer[position_in_parameter_buffer + 1] = '\0';
197 break;
198 default:
199 break;
200 }
201 position_in_parameter_buffer++;
202 }
203 }
204
205 auto parsed_first_parameter = parse_number<float>(first_parameter_buffer);
206 auto parsed_second_parameter = parse_number<float>(second_parameter_buffer);
207 auto parsed_third_parameter = parse_number<float>(third_parameter_buffer);
208
209 switch (this->current_command_) {
210 // Read Commands
211 case EZO_PMP_COMMAND_READ_DOSING: // Page 54
212 if (parsed_third_parameter.has_value())
213 this->is_dosing_flag_ = parsed_third_parameter.value_or(0) == 1;
214
215#ifdef USE_BINARY_SENSOR
216 PUBLISH_STATE(this->is_dosing_binary_sensor_, this->is_dosing_flag_);
217#endif
218
219#ifdef USE_SENSOR
220 if (parsed_second_parameter.has_value() && this->last_volume_requested_sensor_) {
221 this->last_volume_requested_sensor_->publish_state(parsed_second_parameter.value_or(0));
222 }
223#endif
224
225#ifdef USE_TEXT_SENSOR
226 if (!this->is_dosing_flag_ && !this->is_paused_flag_) {
227 // If pump is not paused and not dispensing
228 publish_dosing_mode(this->dosing_mode_text_sensor_, DOSING_MODE_NONE);
229 }
230#endif
231
232 break;
233
234 case EZO_PMP_COMMAND_READ_SINGLE_REPORT: // Single Report (page 53)
235#ifdef USE_SENSOR
236 if (parsed_first_parameter.has_value() && (bool) this->current_volume_dosed_sensor_) {
237 this->current_volume_dosed_sensor_->publish_state(parsed_first_parameter.value_or(0));
238 }
239#endif
240 break;
241
242 case EZO_PMP_COMMAND_READ_MAX_FLOW_RATE: // Constant Flow Rate (page 57)
243#ifdef USE_SENSOR
244 if (parsed_second_parameter.has_value() && this->max_flow_rate_sensor_)
245 this->max_flow_rate_sensor_->publish_state(parsed_second_parameter.value_or(0));
246#endif
247 break;
248
249 case EZO_PMP_COMMAND_READ_PAUSE_STATUS: // Pause (page 61)
250 if (parsed_second_parameter.has_value())
251 this->is_paused_flag_ = parsed_second_parameter.value_or(0) == 1;
252
253#ifdef USE_BINARY_SENSOR
254 PUBLISH_STATE(this->is_paused_binary_sensor_, this->is_paused_flag_);
255#endif
256 break;
257
258 case EZO_PMP_COMMAND_READ_TOTAL_VOLUME_DOSED: // Total Volume Dispensed (page 64)
259#ifdef USE_SENSOR
260 if (parsed_second_parameter.has_value() && this->total_volume_dosed_sensor_)
261 this->total_volume_dosed_sensor_->publish_state(parsed_second_parameter.value_or(0));
262#endif
263 break;
264
265 case EZO_PMP_COMMAND_READ_ABSOLUTE_TOTAL_VOLUME_DOSED: // Total Volume Dispensed (page 64)
266#ifdef USE_SENSOR
267 if (parsed_second_parameter.has_value() && this->absolute_total_volume_dosed_sensor_)
268 this->absolute_total_volume_dosed_sensor_->publish_state(parsed_second_parameter.value_or(0));
269#endif
270 break;
271
272 case EZO_PMP_COMMAND_READ_CALIBRATION_STATUS: // Calibration (page 65)
273#ifdef USE_TEXT_SENSOR
274 if (parsed_second_parameter.has_value() && this->calibration_status_text_sensor_) {
275 if (parsed_second_parameter.value_or(0) == 1) {
276 this->calibration_status_text_sensor_->publish_state("Fixed Volume");
277 } else if (parsed_second_parameter.value_or(0) == 2) {
278 this->calibration_status_text_sensor_->publish_state("Volume/Time");
279 } else if (parsed_second_parameter.value_or(0) == 3) {
280 this->calibration_status_text_sensor_->publish_state("Fixed Volume & Volume/Time");
281 } else {
282 this->calibration_status_text_sensor_->publish_state("Uncalibrated");
283 }
284 }
285#endif
286 break;
287
288 case EZO_PMP_COMMAND_READ_PUMP_VOLTAGE: // Pump Voltage (page 67)
289#ifdef USE_SENSOR
290 if (parsed_second_parameter.has_value() && this->pump_voltage_sensor_)
291 this->pump_voltage_sensor_->publish_state(parsed_second_parameter.value_or(0));
292#endif
293 break;
294
295 // Non-Read Commands
296
297 case EZO_PMP_COMMAND_DOSE_VOLUME: // Volume Dispensing (page 55)
298#ifdef USE_TEXT_SENSOR
299 publish_dosing_mode(this->dosing_mode_text_sensor_, DOSING_MODE_VOLUME);
300#endif
301 break;
302
303 case EZO_PMP_COMMAND_DOSE_VOLUME_OVER_TIME: // Dose over time (page 56)
304#ifdef USE_TEXT_SENSOR
305 publish_dosing_mode(this->dosing_mode_text_sensor_, DOSING_MODE_VOLUME_OVER_TIME);
306#endif
307 break;
308
309 case EZO_PMP_COMMAND_DOSE_WITH_CONSTANT_FLOW_RATE: // Constant Flow Rate (page 57)
310#ifdef USE_TEXT_SENSOR
311 publish_dosing_mode(this->dosing_mode_text_sensor_, DOSING_MODE_CONSTANT_FLOW_RATE);
312#endif
313 break;
314
315 case EZO_PMP_COMMAND_DOSE_CONTINUOUSLY: // Continuous Dispensing (page 54)
316#ifdef USE_TEXT_SENSOR
317 publish_dosing_mode(this->dosing_mode_text_sensor_, DOSING_MODE_CONTINUOUS);
318#endif
319 break;
320
321 case EZO_PMP_COMMAND_STOP_DOSING: // Stop (page 62)
322 this->is_paused_flag_ = false;
323#ifdef USE_BINARY_SENSOR
324 PUBLISH_STATE(this->is_paused_binary_sensor_, this->is_paused_flag_);
325#endif
326#ifdef USE_TEXT_SENSOR
327 publish_dosing_mode(this->dosing_mode_text_sensor_, DOSING_MODE_NONE);
328#endif
329 break;
330
331 case EZO_PMP_COMMAND_EXEC_ARBITRARY_COMMAND_ADDRESS:
332 ESP_LOGI(TAG, "Arbitrary Command Response: %s", (char *) response_buffer);
333 break;
334
335 case EZO_PMP_COMMAND_CLEAR_CALIBRATION: // Clear Calibration (page 65)
336 case EZO_PMP_COMMAND_PAUSE_DOSING: // Pause (page 61)
337 case EZO_PMP_COMMAND_SET_CALIBRATION_VOLUME: // Set Calibration Volume (page 65)
338 case EZO_PMP_COMMAND_CLEAR_TOTAL_VOLUME_DOSED: // Clear Total Volume Dosed (page 64)
339 case EZO_PMP_COMMAND_FIND: // Find (page 52)
340 // Nothing to do here
341 break;
342
343 case EZO_PMP_COMMAND_TYPE_READ:
344 case EZO_PMP_COMMAND_NONE:
345 default:
346 ESP_LOGE(TAG, "Unsupported command received: %d", this->current_command_);
347 return;
348 }
349
351}
352
354 int wait_time_for_command = 400; // milliseconds
355 uint8_t command_buffer[21];
356 int command_buffer_length = 0;
357
358 this->pop_next_command_(); // this->next_command will be updated.
359
360 switch (this->next_command_) {
361 // Read Commands
362 case EZO_PMP_COMMAND_READ_DOSING: // Page 54
363 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "D,?");
364 break;
365
366 case EZO_PMP_COMMAND_READ_SINGLE_REPORT: // Single Report (page 53)
367 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "R");
368 break;
369
370 case EZO_PMP_COMMAND_READ_MAX_FLOW_RATE:
371 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "DC,?");
372 break;
373
374 case EZO_PMP_COMMAND_READ_PAUSE_STATUS:
375 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "P,?");
376 break;
377
378 case EZO_PMP_COMMAND_READ_TOTAL_VOLUME_DOSED:
379 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "TV,?");
380 break;
381
382 case EZO_PMP_COMMAND_READ_ABSOLUTE_TOTAL_VOLUME_DOSED:
383 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "ATV,?");
384 break;
385
386 case EZO_PMP_COMMAND_READ_CALIBRATION_STATUS:
387 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "Cal,?");
388 break;
389
390 case EZO_PMP_COMMAND_READ_PUMP_VOLTAGE:
391 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "PV,?");
392 break;
393
394 // Non-Read Commands
395
396 case EZO_PMP_COMMAND_FIND: // Find (page 52)
397 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "Find");
398 wait_time_for_command = 60000; // This command will block all updates for a minute
399 break;
400
401 case EZO_PMP_COMMAND_DOSE_CONTINUOUSLY: // Continuous Dispensing (page 54)
402 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "D,*");
403 break;
404
405 case EZO_PMP_COMMAND_CLEAR_TOTAL_VOLUME_DOSED: // Clear Total Volume Dosed (page 64)
406 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "Clear");
407 break;
408
409 case EZO_PMP_COMMAND_CLEAR_CALIBRATION: // Clear Calibration (page 65)
410 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "Cal,clear");
411 break;
412
413 case EZO_PMP_COMMAND_PAUSE_DOSING: // Pause (page 61)
414 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "P");
415 break;
416
417 case EZO_PMP_COMMAND_STOP_DOSING: // Stop (page 62)
418 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "X");
419 break;
420
421 // Non-Read commands with parameters
422
423 case EZO_PMP_COMMAND_DOSE_VOLUME: // Volume Dispensing (page 55)
424 command_buffer_length =
425 snprintf((char *) command_buffer, sizeof(command_buffer), "D,%0.1f", this->next_command_volume_);
426 break;
427
428 case EZO_PMP_COMMAND_DOSE_VOLUME_OVER_TIME: // Dose over time (page 56)
429 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "D,%0.1f,%i",
431 break;
432
433 case EZO_PMP_COMMAND_DOSE_WITH_CONSTANT_FLOW_RATE: // Constant Flow Rate (page 57)
434 command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "DC,%0.1f,%i",
436 break;
437
438 case EZO_PMP_COMMAND_SET_CALIBRATION_VOLUME: // Set Calibration Volume (page 65)
439 command_buffer_length =
440 snprintf((char *) command_buffer, sizeof(command_buffer), "Cal,%0.2f", this->next_command_volume_);
441 break;
442
443 case EZO_PMP_COMMAND_CHANGE_I2C_ADDRESS: // Change I2C Address (page 73)
444 command_buffer_length =
445 snprintf((char *) command_buffer, sizeof(command_buffer), "I2C,%i", this->next_command_duration_);
446 break;
447
448 case EZO_PMP_COMMAND_EXEC_ARBITRARY_COMMAND_ADDRESS: // Run an arbitrary command
449 command_buffer_length =
450 snprintf((char *) command_buffer, sizeof(command_buffer), "%s", this->arbitrary_command_.c_str());
451 ESP_LOGI(TAG, "Sending arbitrary command: %s", (char *) command_buffer);
452 break;
453
454 case EZO_PMP_COMMAND_TYPE_READ:
455 case EZO_PMP_COMMAND_NONE:
456 default:
457 ESP_LOGE(TAG, "Unsupported command received: %d", this->next_command_);
458 return;
459 }
460
461 // Send command
462 ESP_LOGV(TAG, "Sending command to device: %s", (char *) command_buffer);
463 this->write(command_buffer, command_buffer_length);
464
465 this->current_command_ = this->next_command_;
466 this->next_command_ = EZO_PMP_COMMAND_NONE;
467 this->is_waiting_ = true;
468 this->start_time_ = millis();
469 this->wait_time_ = wait_time_for_command;
470}
471
473 if (this->next_command_queue_length_ <= 0) {
474 ESP_LOGE(TAG, "Tried to dequeue command from empty queue");
475 this->next_command_ = EZO_PMP_COMMAND_NONE;
476 this->next_command_volume_ = 0;
477 this->next_command_duration_ = 0;
478 return;
479 }
480
481 // Read from Head
485
486 // Move positions
488 if (next_command_queue_head_ >= 10) {
490 }
491
493}
494
496 if (this->next_command_queue_length_ <= 0) {
497 return EZO_PMP_COMMAND_NONE;
498 }
499
501}
502
503void EzoPMP::queue_command_(uint16_t command, double volume, int duration, bool should_schedule) {
504 if (!should_schedule) {
505 return;
506 }
507
508 if (this->next_command_queue_length_ >= 10) {
509 ESP_LOGE(TAG, "Tried to queue command '%d' but queue is full", command);
510 return;
511 }
512
513 this->next_command_queue_[this->next_command_queue_last_] = command;
516
517 ESP_LOGV(TAG, "Queue command '%d' in position '%d'", command, next_command_queue_last_);
518
519 // Move positions
521 if (next_command_queue_last_ >= 10) {
523 }
524
526}
527
528// Actions
529
530void EzoPMP::find() { this->queue_command_(EZO_PMP_COMMAND_FIND, 0, 0, true); }
531
533 this->queue_command_(EZO_PMP_COMMAND_DOSE_CONTINUOUSLY, 0, 0, true);
534 this->queue_command_(EZO_PMP_COMMAND_READ_DOSING, 0, 0, true);
535#ifdef USE_SENSOR
536 this->queue_command_(EZO_PMP_COMMAND_READ_SINGLE_REPORT, 0, 0, (bool) this->current_volume_dosed_sensor_);
537#endif
538}
539
540void EzoPMP::dose_volume(double volume) {
541 this->queue_command_(EZO_PMP_COMMAND_DOSE_VOLUME, volume, 0, true);
542 this->queue_command_(EZO_PMP_COMMAND_READ_DOSING, 0, 0, true);
543#ifdef USE_SENSOR
544 this->queue_command_(EZO_PMP_COMMAND_READ_SINGLE_REPORT, 0, 0, (bool) this->current_volume_dosed_sensor_);
545#endif
546}
547
548void EzoPMP::dose_volume_over_time(double volume, int duration) {
549 this->queue_command_(EZO_PMP_COMMAND_DOSE_VOLUME_OVER_TIME, volume, duration, true);
550 this->queue_command_(EZO_PMP_COMMAND_READ_DOSING, 0, 0, true);
551#ifdef USE_SENSOR
552 this->queue_command_(EZO_PMP_COMMAND_READ_SINGLE_REPORT, 0, 0, (bool) this->current_volume_dosed_sensor_);
553#endif
554}
555
557 this->queue_command_(EZO_PMP_COMMAND_DOSE_WITH_CONSTANT_FLOW_RATE, volume, duration, true);
558 this->queue_command_(EZO_PMP_COMMAND_READ_DOSING, 0, 0, true);
559#ifdef USE_SENSOR
560 this->queue_command_(EZO_PMP_COMMAND_READ_SINGLE_REPORT, 0, 0, (bool) this->current_volume_dosed_sensor_);
561#endif
562}
563
565 this->queue_command_(EZO_PMP_COMMAND_SET_CALIBRATION_VOLUME, volume, 0, true);
566 this->queue_command_(EZO_PMP_COMMAND_READ_CALIBRATION_STATUS, 0, 0, true);
567 this->queue_command_(EZO_PMP_COMMAND_READ_MAX_FLOW_RATE, 0, 0, true);
568}
569
571 this->queue_command_(EZO_PMP_COMMAND_CLEAR_TOTAL_VOLUME_DOSED, 0, 0, true);
572 this->queue_command_(EZO_PMP_COMMAND_READ_SINGLE_REPORT, 0, 0, true);
573 this->queue_command_(EZO_PMP_COMMAND_READ_TOTAL_VOLUME_DOSED, 0, 0, true);
574 this->queue_command_(EZO_PMP_COMMAND_READ_ABSOLUTE_TOTAL_VOLUME_DOSED, 0, 0, true);
575}
576
578 this->queue_command_(EZO_PMP_COMMAND_CLEAR_CALIBRATION, 0, 0, true);
579 this->queue_command_(EZO_PMP_COMMAND_READ_CALIBRATION_STATUS, 0, 0, true);
580 this->queue_command_(EZO_PMP_COMMAND_READ_MAX_FLOW_RATE, 0, 0, true);
581}
582
584 this->queue_command_(EZO_PMP_COMMAND_PAUSE_DOSING, 0, 0, true);
585 this->queue_command_(EZO_PMP_COMMAND_READ_PAUSE_STATUS, 0, 0, true);
586}
587
588void EzoPMP::stop_dosing() { this->queue_command_(EZO_PMP_COMMAND_STOP_DOSING, 0, 0, true); }
589
591 this->queue_command_(EZO_PMP_COMMAND_CHANGE_I2C_ADDRESS, 0, address, true);
592}
593
594void EzoPMP::exec_arbitrary_command(const std::basic_string<char> &command) {
595 this->arbitrary_command_ = command;
596 this->queue_command_(EZO_PMP_COMMAND_EXEC_ARBITRARY_COMMAND_ADDRESS, 0, 0, true);
597}
598
599} // namespace esphome::ezo_pmp
BedjetMode mode
BedJet operating mode.
void exec_arbitrary_command(const std::basic_string< char > &command)
Definition ezo_pmp.cpp:594
void dose_volume(double volume)
Definition ezo_pmp.cpp:540
uint16_t current_command_
Definition ezo_pmp.h:59
int next_command_duration_queue_[10]
Definition ezo_pmp.h:54
uint16_t next_command_queue_[10]
Definition ezo_pmp.h:52
std::string arbitrary_command_
Definition ezo_pmp.h:63
void dump_config() override
Definition ezo_pmp.cpp:54
double next_command_volume_queue_[10]
Definition ezo_pmp.h:53
void set_calibration_volume(double volume)
Definition ezo_pmp.cpp:564
void change_i2c_address(int address)
Definition ezo_pmp.cpp:590
void queue_command_(uint16_t command, double volume, int duration, bool should_schedule)
Definition ezo_pmp.cpp:503
void loop() override
Definition ezo_pmp.cpp:97
void dose_volume_over_time(double volume, int duration)
Definition ezo_pmp.cpp:548
uint16_t peek_next_command_()
Definition ezo_pmp.cpp:495
void dose_with_constant_flow_rate(double volume, int duration)
Definition ezo_pmp.cpp:556
void update() override
Definition ezo_pmp.cpp:59
ErrorCode write(const uint8_t *data, size_t len) const
writes an array of bytes to a device using an I2CBus
Definition i2c.h:195
optional< std::array< uint8_t, N > > read_bytes_raw()
Definition i2c.h:262
void publish_state(const std::string &state)
Definition text_sensor.h:42
uint8_t duration
Definition msa3xx.h:0
PROGMEM_STRING_TABLE(DosingModeStrings, "None", "Volume", "Volume/Time", "Constant Flow Rate", "Continuous")
ESPHOME_LOG_TAG(TAG, "ezo-pmp")
@ DOSING_MODE_CONSTANT_FLOW_RATE
Definition ezo_pmp.cpp:40
@ DOSING_MODE_VOLUME_OVER_TIME
Definition ezo_pmp.cpp:39
optional< T > parse_number(const char *str)
Parse an unsigned decimal number from a null-terminated string.
Definition helpers.h:1430
uint32_t IRAM_ATTR HOT millis()
Definition hal.cpp:25
const __FlashStringHelper * ProgmemStr
Definition progmem.h:31