ESPHome 2026.11.0b6
Loading...
Searching...
No Matches
mopeka_pro_check.cpp
Go to the documentation of this file.
1#include "mopeka_pro_check.h"
2#include "esphome/core/log.h"
3
5
6ESPHOME_LOG_TAG(TAG, "mopeka_pro_check");
7static const uint8_t MANUFACTURER_DATA_LENGTH = 10;
8static const uint16_t MANUFACTURER_ID = 0x0059;
9static const double MOPEKA_LPG_COEF[] = {0.573045, -0.002822, -0.00000535}; // Magic numbers provided by Mopeka
10
11void MopekaProCheck::dump_config() {
12 ESP_LOGCONFIG(TAG, "Mopeka Pro Check");
13 LOG_SENSOR(" ", "Level", this->level_sensor_);
14 LOG_SENSOR(" ", "Temperature", this->temperature_sensor_);
15 LOG_SENSOR(" ", "Battery Level", this->battery_level_sensor_);
16 LOG_SENSOR(" ", "Reading Distance", this->distance_sensor_);
17 LOG_SENSOR(" ", "Read Quality", this->signal_quality_sensor_);
18 LOG_SENSOR(" ", "Ignored Reads", this->ignored_reads_sensor_);
19}
20
26bool MopekaProCheck::parse_device(const ble_device_base::ESPBTDevice &device) {
27 if (device.address_uint64() != this->address_) {
28 return false;
29 }
30
31 char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
32 ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", device.address_str_to(addr_buf));
33
34 const auto &manu_datas = device.get_manufacturer_datas();
35
36 if (manu_datas.size() != 1) {
37 ESP_LOGE(TAG, "Unexpected manu_datas size (%d)", manu_datas.size());
38 return false;
39 }
40
41 const auto &manu_data = manu_datas[0];
42
43 ESP_LOGVV(TAG, "Manufacturer data:");
44 for (const uint8_t byte : manu_data.data) {
45 ESP_LOGVV(TAG, "0x%02x", byte);
46 }
47
48 if (manu_data.data.size() != MANUFACTURER_DATA_LENGTH) {
49 ESP_LOGE(TAG, "Unexpected manu_data size (%d)", manu_data.data.size());
50 return false;
51 }
52
53 // Now parse the data - See Datasheet for definition
54
55 if (static_cast<SensorType>(manu_data.data[0]) != STANDARD_BOTTOM_UP &&
56 static_cast<SensorType>(manu_data.data[0]) != LIPPERT_BOTTOM_UP &&
57 static_cast<SensorType>(manu_data.data[0]) != PLUS_BOTTOM_UP &&
58 static_cast<SensorType>(manu_data.data[0]) != PRO_UNIVERSAL) {
59 ESP_LOGE(TAG, "Unsupported Sensor Type (0x%X)", manu_data.data[0]);
60 return false;
61 }
62
63 // Get battery level first
64 PUBLISH_STATE(this->battery_level_sensor_, this->parse_battery_level_(manu_data.data));
65
66 // Get the quality value
67 SensorReadQuality quality_value = this->parse_read_quality_(manu_data.data);
68 PUBLISH_STATE(this->signal_quality_sensor_, static_cast<int>(quality_value));
69
70 // Determine if we have a good enough quality of read to report level and distance
71 // sensors. This sensor is reported regardless of distance or level sensors being enabled
72 if (quality_value < this->min_signal_quality_) {
73 ESP_LOGW(TAG, "Read Quality too low to report distance or level");
74 this->ignored_read_count_++;
75 } else {
76 // reset to zero since read quality was sufficient
77 this->ignored_read_count_ = 0;
78 }
79 // Report number of contiguous ignored reads if sensor defined
80 PUBLISH_STATE(this->ignored_reads_sensor_, this->ignored_read_count_);
81
82 // Get distance and level if either are sensors
83 if ((this->distance_sensor_ != nullptr) || (this->level_sensor_ != nullptr)) {
84 uint32_t distance_value = this->parse_distance_(manu_data.data);
85 ESP_LOGD(TAG, "Distance Sensor: Quality (0x%X) Distance (%" PRId32 "mm)", quality_value, distance_value);
86
87 // only update distance and level sensors if read quality was sufficient. This can be determined by
88 // if the ignored_read_count is zero.
89 if (this->ignored_read_count_ == 0) {
90 // update distance sensor
91 PUBLISH_STATE(this->distance_sensor_, distance_value);
92
93 // update level sensor
94 if (this->level_sensor_ != nullptr) {
95 uint8_t tank_level = 0;
96 if (distance_value >= this->full_mm_) {
97 tank_level = 100; // cap at 100%
98 } else if (distance_value > this->empty_mm_) {
99 tank_level = ((100.0f / (this->full_mm_ - this->empty_mm_)) * (distance_value - this->empty_mm_));
100 }
101 this->level_sensor_->publish_state(tank_level);
102 }
103 }
104 }
105
106 // Get temperature of sensor
107 PUBLISH_STATE(this->temperature_sensor_, this->parse_temperature_(manu_data.data));
108
109 return true;
110}
111
112uint8_t MopekaProCheck::parse_battery_level_(const std::vector<uint8_t> &message) {
113 float v = (float) ((message[1] & 0x7F) / 32.0f);
114 // convert voltage and scale for CR2032
115 float percent = (v - 2.2f) / 0.65f * 100.0f;
116 if (percent < 0.0f) {
117 return 0;
118 }
119 if (percent > 100.0f) {
120 return 100;
121 }
122 return (uint8_t) percent;
123}
124
126 uint16_t raw = (message[4] * 256) + message[3];
127 double raw_level = raw & 0x3FFF;
128 double raw_t = (message[2] & 0x7F);
129
130 return (uint32_t) (raw_level *
131 (MOPEKA_LPG_COEF[0] + MOPEKA_LPG_COEF[1] * raw_t + MOPEKA_LPG_COEF[2] * raw_t * raw_t));
132}
133
134int8_t MopekaProCheck::parse_temperature_(const std::vector<uint8_t> &message) { return (message[2] & 0x7F) - 40; }
135
137 // Since a 8 bit value is being shifted and truncated to 2 bits all possible values are defined as enumeration
138 // value and the static cast is safe.
139 return static_cast<SensorReadQuality>(message[4] >> 6);
140}
141
142} // namespace esphome::mopeka_pro_check
uint8_t raw[35]
Definition bl0939.h:0
SensorReadQuality parse_read_quality_(const std::vector< uint8_t > &message)
int8_t parse_temperature_(const std::vector< uint8_t > &message)
uint8_t parse_battery_level_(const std::vector< uint8_t > &message)
uint32_t parse_distance_(const std::vector< uint8_t > &message)
const LogString * message
Definition component.cpp:35
ESPHOME_LOG_TAG(TAG, "mopeka_pro_check")
static void uint32_t