ESPHome 2026.11.0b6
Loading...
Searching...
No Matches
mopeka_std_check.cpp
Go to the documentation of this file.
1#include "mopeka_std_check.h"
2
4#include "esphome/core/log.h"
5
7
8ESPHOME_LOG_TAG(TAG, "mopeka_std_check");
9static const uint16_t SERVICE_UUID = 0xADA0;
10static const uint8_t MANUFACTURER_DATA_LENGTH = 23;
11static const uint16_t MANUFACTURER_ID = 0x000D;
12
13// Maximum bytes to log in very verbose hex output
14static constexpr size_t MOPEKA_MAX_LOG_BYTES = 32;
15
16void MopekaStdCheck::dump_config() {
17 ESP_LOGCONFIG(TAG,
18 "Mopeka Std Check\n"
19 " Propane Butane mix: %.0f%%\n"
20 " Tank distance empty: %" PRIi32 "mm\n"
21 " Tank distance full: %" PRIi32 "mm",
22 this->propane_butane_mix_ * 100, this->empty_mm_, this->full_mm_);
23 LOG_SENSOR(" ", "Level", this->level_sensor_);
24 LOG_SENSOR(" ", "Temperature", this->temperature_sensor_);
25 LOG_SENSOR(" ", "Battery Level", this->battery_level_sensor_);
26 LOG_SENSOR(" ", "Reading Distance", this->distance_sensor_);
27}
28
34bool MopekaStdCheck::parse_device(const ble_device_base::ESPBTDevice &device) {
35 // Validate address.
36 if (device.address_uint64() != this->address_) {
37 return false;
38 }
39
40 // Stack buffer for MAC address formatting - reused throughout function
41 char addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
42 const char *addr_str = device.address_str_to(addr_buf);
43
44 ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", addr_str);
45
46 {
47 // Validate service uuid
48 const auto &service_uuids = device.get_service_uuids();
49 if (service_uuids.size() != 1) {
50 return false;
51 }
52 const auto &service_uuid = service_uuids[0];
53 if (service_uuid != ble_device_base::ESPBTUUID::from_uint16(SERVICE_UUID)) {
54 return false;
55 }
56 }
57
58 const auto &manu_datas = device.get_manufacturer_datas();
59
60 if (manu_datas.size() != 1) {
61 ESP_LOGE(TAG, "[%s] Unexpected manu_datas size (%d)", addr_str, manu_datas.size());
62 return false;
63 }
64
65 const auto &manu_data = manu_datas[0];
66
67 ESP_LOGVV_HEX(TAG, manu_data.data.data(), manu_data.data.size(), MOPEKA_MAX_LOG_BYTES, "[%s] Manufacturer data: %s",
68 addr_str);
69
70 if (manu_data.data.size() != MANUFACTURER_DATA_LENGTH) {
71 ESP_LOGE(TAG, "[%s] Unexpected manu_data size (%d)", addr_str, manu_data.data.size());
72 return false;
73 }
74
75 // Now parse the data
76 const auto *mopeka_data = (const mopeka_std_package *) manu_data.data.data();
77
78 const u_int8_t hardware_id = mopeka_data->data_1 & 0xCF;
79 if (static_cast<SensorType>(hardware_id) != STANDARD && static_cast<SensorType>(hardware_id) != XL &&
80 static_cast<SensorType>(hardware_id) != ETRAILER && static_cast<SensorType>(hardware_id) != STANDARD_ALT) {
81 ESP_LOGE(TAG, "[%s] Unsupported Sensor Type (0x%X)", addr_str, hardware_id);
82 return false;
83 }
84
85 ESP_LOGVV(TAG, "[%s] Sensor slow update rate: %d", addr_str, mopeka_data->slow_update_rate);
86 ESP_LOGVV(TAG, "[%s] Sensor sync pressed: %d", addr_str, mopeka_data->sync_pressed);
87 for (u_int8_t i = 0; i < 3; i++) {
88 ESP_LOGVV(TAG, "[%s] %u. Sensor data %u time %u.", addr_str, (i * 4) + 1, mopeka_data->val[i].value_0,
89 mopeka_data->val[i].time_0);
90 ESP_LOGVV(TAG, "[%s] %u. Sensor data %u time %u.", addr_str, (i * 4) + 2, mopeka_data->val[i].value_1,
91 mopeka_data->val[i].time_1);
92 ESP_LOGVV(TAG, "[%s] %u. Sensor data %u time %u.", addr_str, (i * 4) + 3, mopeka_data->val[i].value_2,
93 mopeka_data->val[i].time_2);
94 ESP_LOGVV(TAG, "[%s] %u. Sensor data %u time %u.", addr_str, (i * 4) + 4, mopeka_data->val[i].value_3,
95 mopeka_data->val[i].time_3);
96 }
97
98 // Get battery level first
99 PUBLISH_STATE(this->battery_level_sensor_, this->parse_battery_level_(mopeka_data));
100
101 // Get temperature of sensor
102 int8_t temp_in_c = this->parse_temperature_(mopeka_data);
103 PUBLISH_STATE(this->temperature_sensor_, temp_in_c);
104
105 // Get distance and level if either are sensors
106 if ((this->distance_sensor_ != nullptr) || (this->level_sensor_ != nullptr)) {
107 // Message contains 12 sensor dataset each 10 bytes long.
108 // each sensor dataset contains 5 byte time and 5 byte value.
109
110 // time in 10us ticks.
111 // value is amplitude.
112
113 std::array<u_int8_t, 12> measurements_time = {};
114 std::array<u_int8_t, 12> measurements_value = {};
115 // Copy measurements over into my array.
116 {
117 u_int8_t measurements_index = 0;
118 for (const auto &val : mopeka_data->val) {
119 measurements_time[measurements_index] = val.time_0 + 1;
120 measurements_value[measurements_index] = val.value_0;
121 measurements_index++;
122 measurements_time[measurements_index] = val.time_1 + 1;
123 measurements_value[measurements_index] = val.value_1;
124 measurements_index++;
125 measurements_time[measurements_index] = val.time_2 + 1;
126 measurements_value[measurements_index] = val.value_2;
127 measurements_index++;
128 measurements_time[measurements_index] = val.time_3 + 1;
129 measurements_value[measurements_index] = val.value_3;
130 measurements_index++;
131 }
132 }
133
134 // Find best(strongest) value(amplitude) and it's belonging time in sensor dataset.
135 u_int8_t number_of_usable_values = 0;
136 u_int16_t best_value = 0;
137 u_int16_t best_time = 0;
138 {
139 u_int16_t measurement_time = 0;
140 for (u_int8_t i = 0; i < 12; i++) {
141 // Time is summed up until a value is reported. This allows time values larger than the 5 bits in transport.
142 measurement_time += measurements_time[i];
143 if (measurements_value[i] != 0) {
144 // I got a value
145 number_of_usable_values++;
146 if (measurements_value[i] > best_value) {
147 // This value is better than a previous one.
148 best_value = measurements_value[i];
149 best_time = measurement_time;
150 }
151 // Reset measurement_time or next values.
152 measurement_time = 0;
153 }
154 }
155 }
156
157 ESP_LOGV(TAG, "[%s] Found %u values with best data %u time %u.", addr_str, number_of_usable_values, best_value,
158 best_time);
159
160 if (number_of_usable_values < 1 || best_value < 2 || best_time < 2) {
161 // At least two measurement values must be present.
162 ESP_LOGW(TAG, "[%s] Poor read quality. Setting distance to 0.", addr_str);
163 PUBLISH_STATE(this->distance_sensor_, 0);
164 PUBLISH_STATE(this->level_sensor_, 0);
165 } else {
166 float lpg_speed_of_sound = this->get_lpg_speed_of_sound_(temp_in_c);
167 ESP_LOGV(TAG, "[%s] Speed of sound in current fluid %f m/s", addr_str, lpg_speed_of_sound);
168
169 uint32_t distance_value = lpg_speed_of_sound * best_time / 100.0f;
170
171 // update distance sensor
172 PUBLISH_STATE(this->distance_sensor_, distance_value);
173
174 // update level sensor
175 if (this->level_sensor_ != nullptr) {
176 uint8_t tank_level = 0;
177 if (distance_value >= this->full_mm_) {
178 tank_level = 100; // cap at 100%
179 } else if (distance_value > this->empty_mm_) {
180 tank_level = ((100.0f / (this->full_mm_ - this->empty_mm_)) * (distance_value - this->empty_mm_));
181 }
182 this->level_sensor_->publish_state(tank_level);
183 }
184 }
185 }
186
187 return true;
188}
189
191 return 1040.71f - 4.87f * temperature - 137.5f * this->propane_butane_mix_ - 0.0107f * temperature * temperature -
192 1.63f * temperature * this->propane_butane_mix_;
193}
194
196 const float voltage = (float) ((message->raw_voltage / 256.0f) * 2.0f + 1.5f);
197 ESP_LOGVV(TAG, "Sensor battery voltage: %f V", voltage);
198 // convert voltage and scale for CR2032
199 const float percent = (voltage - 2.2f) / 0.65f * 100.0f;
200 if (percent < 0.0f) {
201 return 0;
202 }
203 if (percent > 100.0f) {
204 return 100;
205 }
206 return (uint8_t) percent;
207}
208
210 uint8_t tmp = message->raw_temp;
211 if (tmp == 0x0) {
212 return -40;
213 } else {
214 return static_cast<int8_t>((tmp - 25.0f) * 1.776964f);
215 }
216}
217
218} // namespace esphome::mopeka_std_check
ESPDEPRECATED("Use address_str_to() instead. Removed in 2027.2.0.", "2026.8.0") std const char * address_str_to(char *buf) const
Return MAC as "XX:XX:XX:XX:XX:XX" string.
const std::vector< ESPBTUUID > & get_service_uuids() const
Definition ble_device.h:223
uint64_t address_uint64() const
Return MAC as packed uint64 (byte 0 in LSB — matches esp32's address_uint64).
const std::vector< ServiceData > & get_manufacturer_datas() const
Definition ble_device.h:224
static ESPBTUUID from_uint16(uint16_t uuid)
int8_t parse_temperature_(const mopeka_std_package *message)
uint8_t parse_battery_level_(const mopeka_std_package *message)
const LogString * message
Definition component.cpp:35
mopeka_std_values val[3]
ESPHOME_LOG_TAG(TAG, "mopeka_std_check")
static void uint32_t
uint16_t temperature
Definition sun_gtil2.cpp:12