ESPHome 2025.9.0-dev
Loading...
Searching...
No Matches
helpers.cpp
Go to the documentation of this file.
2
4#include "esphome/core/hal.h"
5#include "esphome/core/log.h"
6
7#include <strings.h>
8#include <algorithm>
9#include <cctype>
10#include <cmath>
11#include <cstdarg>
12#include <cstdio>
13#include <cstring>
14
15#ifdef USE_ESP32
16#include "rom/crc.h"
17#endif
18
19namespace esphome {
20
21static const char *const TAG = "helpers";
22
23static const uint16_t CRC16_A001_LE_LUT_L[] = {0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241,
24 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440};
25static const uint16_t CRC16_A001_LE_LUT_H[] = {0x0000, 0xcc01, 0xd801, 0x1400, 0xf001, 0x3c00, 0x2800, 0xe401,
26 0xa001, 0x6c00, 0x7800, 0xb401, 0x5000, 0x9c01, 0x8801, 0x4400};
27
28#ifndef USE_ESP32
29static const uint16_t CRC16_8408_LE_LUT_L[] = {0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
30 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7};
31static const uint16_t CRC16_8408_LE_LUT_H[] = {0x0000, 0x1081, 0x2102, 0x3183, 0x4204, 0x5285, 0x6306, 0x7387,
32 0x8408, 0x9489, 0xa50a, 0xb58b, 0xc60c, 0xd68d, 0xe70e, 0xf78f};
33#endif
34
35#if !defined(USE_ESP32) || defined(USE_ESP32_VARIANT_ESP32S2)
36static const uint16_t CRC16_1021_BE_LUT_L[] = {0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
37 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef};
38static const uint16_t CRC16_1021_BE_LUT_H[] = {0x0000, 0x1231, 0x2462, 0x3653, 0x48c4, 0x5af5, 0x6ca6, 0x7e97,
39 0x9188, 0x83b9, 0xb5ea, 0xa7db, 0xd94c, 0xcb7d, 0xfd2e, 0xef1f};
40#endif
41
42// Mathematics
43
44uint8_t crc8(const uint8_t *data, uint8_t len) {
45 uint8_t crc = 0;
46
47 while ((len--) != 0u) {
48 uint8_t inbyte = *data++;
49 for (uint8_t i = 8; i != 0u; i--) {
50 bool mix = (crc ^ inbyte) & 0x01;
51 crc >>= 1;
52 if (mix)
53 crc ^= 0x8C;
54 inbyte >>= 1;
55 }
56 }
57 return crc;
58}
59
60uint16_t crc16(const uint8_t *data, uint16_t len, uint16_t crc, uint16_t reverse_poly, bool refin, bool refout) {
61#ifdef USE_ESP32
62 if (reverse_poly == 0x8408) {
63 crc = crc16_le(refin ? crc : (crc ^ 0xffff), data, len);
64 return refout ? crc : (crc ^ 0xffff);
65 }
66#endif
67 if (refin) {
68 crc ^= 0xffff;
69 }
70#ifndef USE_ESP32
71 if (reverse_poly == 0x8408) {
72 while (len--) {
73 uint8_t combo = crc ^ (uint8_t) *data++;
74 crc = (crc >> 8) ^ CRC16_8408_LE_LUT_L[combo & 0x0F] ^ CRC16_8408_LE_LUT_H[combo >> 4];
75 }
76 } else
77#endif
78 {
79 if (reverse_poly == 0xa001) {
80 while (len--) {
81 uint8_t combo = crc ^ (uint8_t) *data++;
82 crc = (crc >> 8) ^ CRC16_A001_LE_LUT_L[combo & 0x0F] ^ CRC16_A001_LE_LUT_H[combo >> 4];
83 }
84 } else {
85 while (len--) {
86 crc ^= *data++;
87 for (uint8_t i = 0; i < 8; i++) {
88 if (crc & 0x0001) {
89 crc = (crc >> 1) ^ reverse_poly;
90 } else {
91 crc >>= 1;
92 }
93 }
94 }
95 }
96 }
97 return refout ? (crc ^ 0xffff) : crc;
98}
99
100uint16_t crc16be(const uint8_t *data, uint16_t len, uint16_t crc, uint16_t poly, bool refin, bool refout) {
101#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32S2)
102 if (poly == 0x1021) {
103 crc = crc16_be(refin ? crc : (crc ^ 0xffff), data, len);
104 return refout ? crc : (crc ^ 0xffff);
105 }
106#endif
107 if (refin) {
108 crc ^= 0xffff;
109 }
110#if !defined(USE_ESP32) || defined(USE_ESP32_VARIANT_ESP32S2)
111 if (poly == 0x1021) {
112 while (len--) {
113 uint8_t combo = (crc >> 8) ^ *data++;
114 crc = (crc << 8) ^ CRC16_1021_BE_LUT_L[combo & 0x0F] ^ CRC16_1021_BE_LUT_H[combo >> 4];
115 }
116 } else {
117#endif
118 while (len--) {
119 crc ^= (((uint16_t) *data++) << 8);
120 for (uint8_t i = 0; i < 8; i++) {
121 if (crc & 0x8000) {
122 crc = (crc << 1) ^ poly;
123 } else {
124 crc <<= 1;
125 }
126 }
127 }
128#if !defined(USE_ESP32) || defined(USE_ESP32_VARIANT_ESP32S2)
129 }
130#endif
131 return refout ? (crc ^ 0xffff) : crc;
132}
133
134uint32_t fnv1_hash(const std::string &str) {
135 uint32_t hash = 2166136261UL;
136 for (char c : str) {
137 hash *= 16777619UL;
138 hash ^= c;
139 }
140 return hash;
141}
142
143float random_float() { return static_cast<float>(random_uint32()) / static_cast<float>(UINT32_MAX); }
144
145// Strings
146
147bool str_equals_case_insensitive(const std::string &a, const std::string &b) {
148 return strcasecmp(a.c_str(), b.c_str()) == 0;
149}
150#if __cplusplus >= 202002L
151bool str_startswith(const std::string &str, const std::string &start) { return str.starts_with(start); }
152bool str_endswith(const std::string &str, const std::string &end) { return str.ends_with(end); }
153#else
154bool str_startswith(const std::string &str, const std::string &start) { return str.rfind(start, 0) == 0; }
155bool str_endswith(const std::string &str, const std::string &end) {
156 return str.rfind(end) == (str.size() - end.size());
157}
158#endif
159std::string str_truncate(const std::string &str, size_t length) {
160 return str.length() > length ? str.substr(0, length) : str;
161}
162std::string str_until(const char *str, char ch) {
163 const char *pos = strchr(str, ch);
164 return pos == nullptr ? std::string(str) : std::string(str, pos - str);
165}
166std::string str_until(const std::string &str, char ch) { return str.substr(0, str.find(ch)); }
167// wrapper around std::transform to run safely on functions from the ctype.h header
168// see https://en.cppreference.com/w/cpp/string/byte/toupper#Notes
169template<int (*fn)(int)> std::string str_ctype_transform(const std::string &str) {
170 std::string result;
171 result.resize(str.length());
172 std::transform(str.begin(), str.end(), result.begin(), [](unsigned char ch) { return fn(ch); });
173 return result;
174}
175std::string str_lower_case(const std::string &str) { return str_ctype_transform<std::tolower>(str); }
176std::string str_upper_case(const std::string &str) { return str_ctype_transform<std::toupper>(str); }
177std::string str_snake_case(const std::string &str) {
178 std::string result;
179 result.resize(str.length());
180 std::transform(str.begin(), str.end(), result.begin(), ::tolower);
181 std::replace(result.begin(), result.end(), ' ', '_');
182 return result;
183}
184std::string str_sanitize(const std::string &str) {
185 std::string out = str;
186 std::replace_if(
187 out.begin(), out.end(),
188 [](const char &c) {
189 return c != '-' && c != '_' && (c < '0' || c > '9') && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z');
190 },
191 '_');
192 return out;
193}
194std::string str_snprintf(const char *fmt, size_t len, ...) {
195 std::string str;
196 va_list args;
197
198 str.resize(len);
199 va_start(args, len);
200 size_t out_length = vsnprintf(&str[0], len + 1, fmt, args);
201 va_end(args);
202
203 if (out_length < len)
204 str.resize(out_length);
205
206 return str;
207}
208std::string str_sprintf(const char *fmt, ...) {
209 std::string str;
210 va_list args;
211
212 va_start(args, fmt);
213 size_t length = vsnprintf(nullptr, 0, fmt, args);
214 va_end(args);
215
216 str.resize(length);
217 va_start(args, fmt);
218 vsnprintf(&str[0], length + 1, fmt, args);
219 va_end(args);
220
221 return str;
222}
223
224// Parsing & formatting
225
226size_t parse_hex(const char *str, size_t length, uint8_t *data, size_t count) {
227 uint8_t val;
228 size_t chars = std::min(length, 2 * count);
229 for (size_t i = 2 * count - chars; i < 2 * count; i++, str++) {
230 if (*str >= '0' && *str <= '9') {
231 val = *str - '0';
232 } else if (*str >= 'A' && *str <= 'F') {
233 val = 10 + (*str - 'A');
234 } else if (*str >= 'a' && *str <= 'f') {
235 val = 10 + (*str - 'a');
236 } else {
237 return 0;
238 }
239 data[i >> 1] = !(i & 1) ? val << 4 : data[i >> 1] | val;
240 }
241 return chars;
242}
243
244std::string format_mac_address_pretty(const uint8_t *mac) {
245 return str_snprintf("%02X:%02X:%02X:%02X:%02X:%02X", 17, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
246}
247
248static char format_hex_char(uint8_t v) { return v >= 10 ? 'a' + (v - 10) : '0' + v; }
249std::string format_hex(const uint8_t *data, size_t length) {
250 std::string ret;
251 ret.resize(length * 2);
252 for (size_t i = 0; i < length; i++) {
253 ret[2 * i] = format_hex_char((data[i] & 0xF0) >> 4);
254 ret[2 * i + 1] = format_hex_char(data[i] & 0x0F);
255 }
256 return ret;
257}
258std::string format_hex(const std::vector<uint8_t> &data) { return format_hex(data.data(), data.size()); }
259
260static char format_hex_pretty_char(uint8_t v) { return v >= 10 ? 'A' + (v - 10) : '0' + v; }
261
262// Shared implementation for uint8_t and string hex formatting
263static std::string format_hex_pretty_uint8(const uint8_t *data, size_t length, char separator, bool show_length) {
264 if (data == nullptr || length == 0)
265 return "";
266 std::string ret;
267 uint8_t multiple = separator ? 3 : 2; // 3 if separator is not \0, 2 otherwise
268 ret.resize(multiple * length - (separator ? 1 : 0));
269 for (size_t i = 0; i < length; i++) {
270 ret[multiple * i] = format_hex_pretty_char((data[i] & 0xF0) >> 4);
271 ret[multiple * i + 1] = format_hex_pretty_char(data[i] & 0x0F);
272 if (separator && i != length - 1)
273 ret[multiple * i + 2] = separator;
274 }
275 if (show_length && length > 4)
276 return ret + " (" + std::to_string(length) + ")";
277 return ret;
278}
279
280std::string format_hex_pretty(const uint8_t *data, size_t length, char separator, bool show_length) {
281 return format_hex_pretty_uint8(data, length, separator, show_length);
282}
283std::string format_hex_pretty(const std::vector<uint8_t> &data, char separator, bool show_length) {
284 return format_hex_pretty(data.data(), data.size(), separator, show_length);
285}
286
287std::string format_hex_pretty(const uint16_t *data, size_t length, char separator, bool show_length) {
288 if (data == nullptr || length == 0)
289 return "";
290 std::string ret;
291 uint8_t multiple = separator ? 5 : 4; // 5 if separator is not \0, 4 otherwise
292 ret.resize(multiple * length - (separator ? 1 : 0));
293 for (size_t i = 0; i < length; i++) {
294 ret[multiple * i] = format_hex_pretty_char((data[i] & 0xF000) >> 12);
295 ret[multiple * i + 1] = format_hex_pretty_char((data[i] & 0x0F00) >> 8);
296 ret[multiple * i + 2] = format_hex_pretty_char((data[i] & 0x00F0) >> 4);
297 ret[multiple * i + 3] = format_hex_pretty_char(data[i] & 0x000F);
298 if (separator && i != length - 1)
299 ret[multiple * i + 4] = separator;
300 }
301 if (show_length && length > 4)
302 return ret + " (" + std::to_string(length) + ")";
303 return ret;
304}
305std::string format_hex_pretty(const std::vector<uint16_t> &data, char separator, bool show_length) {
306 return format_hex_pretty(data.data(), data.size(), separator, show_length);
307}
308std::string format_hex_pretty(const std::string &data, char separator, bool show_length) {
309 return format_hex_pretty_uint8(reinterpret_cast<const uint8_t *>(data.data()), data.length(), separator, show_length);
310}
311
312std::string format_bin(const uint8_t *data, size_t length) {
313 std::string result;
314 result.resize(length * 8);
315 for (size_t byte_idx = 0; byte_idx < length; byte_idx++) {
316 for (size_t bit_idx = 0; bit_idx < 8; bit_idx++) {
317 result[byte_idx * 8 + bit_idx] = ((data[byte_idx] >> (7 - bit_idx)) & 1) + '0';
318 }
319 }
320
321 return result;
322}
323
324ParseOnOffState parse_on_off(const char *str, const char *on, const char *off) {
325 if (on == nullptr && strcasecmp(str, "on") == 0)
326 return PARSE_ON;
327 if (on != nullptr && strcasecmp(str, on) == 0)
328 return PARSE_ON;
329 if (off == nullptr && strcasecmp(str, "off") == 0)
330 return PARSE_OFF;
331 if (off != nullptr && strcasecmp(str, off) == 0)
332 return PARSE_OFF;
333 if (strcasecmp(str, "toggle") == 0)
334 return PARSE_TOGGLE;
335
336 return PARSE_NONE;
337}
338
339std::string value_accuracy_to_string(float value, int8_t accuracy_decimals) {
340 if (accuracy_decimals < 0) {
341 auto multiplier = powf(10.0f, accuracy_decimals);
342 value = roundf(value * multiplier) / multiplier;
343 accuracy_decimals = 0;
344 }
345 char tmp[32]; // should be enough, but we should maybe improve this at some point.
346 snprintf(tmp, sizeof(tmp), "%.*f", accuracy_decimals, value);
347 return std::string(tmp);
348}
349
350int8_t step_to_accuracy_decimals(float step) {
351 // use printf %g to find number of digits based on temperature step
352 char buf[32];
353 snprintf(buf, sizeof buf, "%.5g", step);
354
355 std::string str{buf};
356 size_t dot_pos = str.find('.');
357 if (dot_pos == std::string::npos)
358 return 0;
359
360 return str.length() - dot_pos - 1;
361}
362
363// Use C-style string constant to store in ROM instead of RAM (saves 24 bytes)
364static constexpr const char *BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
365 "abcdefghijklmnopqrstuvwxyz"
366 "0123456789+/";
367
368// Helper function to find the index of a base64 character in the lookup table.
369// Returns the character's position (0-63) if found, or 0 if not found.
370// NOTE: This returns 0 for both 'A' (valid base64 char at index 0) and invalid characters.
371// This is safe because is_base64() is ALWAYS checked before calling this function,
372// preventing invalid characters from ever reaching here. The base64_decode function
373// stops processing at the first invalid character due to the is_base64() check in its
374// while loop condition, making this edge case harmless in practice.
375static inline uint8_t base64_find_char(char c) {
376 const char *pos = strchr(BASE64_CHARS, c);
377 return pos ? (pos - BASE64_CHARS) : 0;
378}
379
380static inline bool is_base64(char c) { return (isalnum(c) || (c == '+') || (c == '/')); }
381
382std::string base64_encode(const std::vector<uint8_t> &buf) { return base64_encode(buf.data(), buf.size()); }
383
384std::string base64_encode(const uint8_t *buf, size_t buf_len) {
385 std::string ret;
386 int i = 0;
387 int j = 0;
388 char char_array_3[3];
389 char char_array_4[4];
390
391 while (buf_len--) {
392 char_array_3[i++] = *(buf++);
393 if (i == 3) {
394 char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
395 char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
396 char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
397 char_array_4[3] = char_array_3[2] & 0x3f;
398
399 for (i = 0; (i < 4); i++)
400 ret += BASE64_CHARS[static_cast<uint8_t>(char_array_4[i])];
401 i = 0;
402 }
403 }
404
405 if (i) {
406 for (j = i; j < 3; j++)
407 char_array_3[j] = '\0';
408
409 char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
410 char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
411 char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
412 char_array_4[3] = char_array_3[2] & 0x3f;
413
414 for (j = 0; (j < i + 1); j++)
415 ret += BASE64_CHARS[static_cast<uint8_t>(char_array_4[j])];
416
417 while ((i++ < 3))
418 ret += '=';
419 }
420
421 return ret;
422}
423
424size_t base64_decode(const std::string &encoded_string, uint8_t *buf, size_t buf_len) {
425 std::vector<uint8_t> decoded = base64_decode(encoded_string);
426 if (decoded.size() > buf_len) {
427 ESP_LOGW(TAG, "Base64 decode: buffer too small, truncating");
428 decoded.resize(buf_len);
429 }
430 memcpy(buf, decoded.data(), decoded.size());
431 return decoded.size();
432}
433
434std::vector<uint8_t> base64_decode(const std::string &encoded_string) {
435 int in_len = encoded_string.size();
436 int i = 0;
437 int j = 0;
438 int in = 0;
439 uint8_t char_array_4[4], char_array_3[3];
440 std::vector<uint8_t> ret;
441
442 // SAFETY: The loop condition checks is_base64() before processing each character.
443 // This ensures base64_find_char() is only called on valid base64 characters,
444 // preventing the edge case where invalid chars would return 0 (same as 'A').
445 while (in_len-- && (encoded_string[in] != '=') && is_base64(encoded_string[in])) {
446 char_array_4[i++] = encoded_string[in];
447 in++;
448 if (i == 4) {
449 for (i = 0; i < 4; i++)
450 char_array_4[i] = base64_find_char(char_array_4[i]);
451
452 char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
453 char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
454 char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
455
456 for (i = 0; (i < 3); i++)
457 ret.push_back(char_array_3[i]);
458 i = 0;
459 }
460 }
461
462 if (i) {
463 for (j = i; j < 4; j++)
464 char_array_4[j] = 0;
465
466 for (j = 0; j < 4; j++)
467 char_array_4[j] = base64_find_char(char_array_4[j]);
468
469 char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
470 char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
471 char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
472
473 for (j = 0; (j < i - 1); j++)
474 ret.push_back(char_array_3[j]);
475 }
476
477 return ret;
478}
479
480// Colors
481
482float gamma_correct(float value, float gamma) {
483 if (value <= 0.0f)
484 return 0.0f;
485 if (gamma <= 0.0f)
486 return value;
487
488 return powf(value, gamma);
489}
490float gamma_uncorrect(float value, float gamma) {
491 if (value <= 0.0f)
492 return 0.0f;
493 if (gamma <= 0.0f)
494 return value;
495
496 return powf(value, 1 / gamma);
497}
498
499void rgb_to_hsv(float red, float green, float blue, int &hue, float &saturation, float &value) {
500 float max_color_value = std::max(std::max(red, green), blue);
501 float min_color_value = std::min(std::min(red, green), blue);
502 float delta = max_color_value - min_color_value;
503
504 if (delta == 0) {
505 hue = 0;
506 } else if (max_color_value == red) {
507 hue = int(fmod(((60 * ((green - blue) / delta)) + 360), 360));
508 } else if (max_color_value == green) {
509 hue = int(fmod(((60 * ((blue - red) / delta)) + 120), 360));
510 } else if (max_color_value == blue) {
511 hue = int(fmod(((60 * ((red - green) / delta)) + 240), 360));
512 }
513
514 if (max_color_value == 0) {
515 saturation = 0;
516 } else {
517 saturation = delta / max_color_value;
518 }
519
520 value = max_color_value;
521}
522void hsv_to_rgb(int hue, float saturation, float value, float &red, float &green, float &blue) {
523 float chroma = value * saturation;
524 float hue_prime = fmod(hue / 60.0, 6);
525 float intermediate = chroma * (1 - fabs(fmod(hue_prime, 2) - 1));
526 float delta = value - chroma;
527
528 if (0 <= hue_prime && hue_prime < 1) {
529 red = chroma;
530 green = intermediate;
531 blue = 0;
532 } else if (1 <= hue_prime && hue_prime < 2) {
533 red = intermediate;
534 green = chroma;
535 blue = 0;
536 } else if (2 <= hue_prime && hue_prime < 3) {
537 red = 0;
538 green = chroma;
539 blue = intermediate;
540 } else if (3 <= hue_prime && hue_prime < 4) {
541 red = 0;
542 green = intermediate;
543 blue = chroma;
544 } else if (4 <= hue_prime && hue_prime < 5) {
545 red = intermediate;
546 green = 0;
547 blue = chroma;
548 } else if (5 <= hue_prime && hue_prime < 6) {
549 red = chroma;
550 green = 0;
551 blue = intermediate;
552 } else {
553 red = 0;
554 green = 0;
555 blue = 0;
556 }
557
558 red += delta;
559 green += delta;
560 blue += delta;
561}
562
563uint8_t HighFrequencyLoopRequester::num_requests = 0; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
565 if (this->started_)
566 return;
567 num_requests++;
568 this->started_ = true;
569}
571 if (!this->started_)
572 return;
573 num_requests--;
574 this->started_ = false;
575}
577
578std::string get_mac_address() {
579 uint8_t mac[6];
581 return str_snprintf("%02x%02x%02x%02x%02x%02x", 12, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
582}
583
585 uint8_t mac[6];
587 return format_mac_address_pretty(mac);
588}
589
590#ifndef USE_ESP32
591bool has_custom_mac_address() { return false; }
592#endif
593
594bool mac_address_is_valid(const uint8_t *mac) {
595 bool is_all_zeros = true;
596 bool is_all_ones = true;
597
598 for (uint8_t i = 0; i < 6; i++) {
599 if (mac[i] != 0) {
600 is_all_zeros = false;
601 }
602 }
603 for (uint8_t i = 0; i < 6; i++) {
604 if (mac[i] != 0xFF) {
605 is_all_ones = false;
606 }
607 }
608 return !(is_all_zeros || is_all_ones);
609}
610
611void IRAM_ATTR HOT delay_microseconds_safe(uint32_t us) {
612 // avoids CPU locks that could trigger WDT or affect WiFi/BT stability
613 uint32_t start = micros();
614
615 const uint32_t lag = 5000; // microseconds, specifies the maximum time for a CPU busy-loop.
616 // it must be larger than the worst-case duration of a delay(1) call (hardware tasks)
617 // 5ms is conservative, it could be reduced when exact BT/WiFi stack delays are known
618 if (us > lag) {
619 delay((us - lag) / 1000UL); // note: in disabled-interrupt contexts delay() won't actually sleep
620 while (micros() - start < us - lag)
621 delay(1); // in those cases, this loop allows to yield for BT/WiFi stack tasks
622 }
623 while (micros() - start < us) // fine delay the remaining usecs
624 ;
625}
626
627} // namespace esphome
void stop()
Stop running the loop continuously.
Definition helpers.cpp:570
static bool is_high_frequency()
Check whether the loop is running continuously.
Definition helpers.cpp:576
void start()
Start running the loop continuously.
Definition helpers.cpp:564
mopeka_std_values val[4]
const char *const TAG
Definition spi.cpp:8
Providing packet encoding functions for exchanging data with a remote host.
Definition a01nyub.cpp:7
uint32_t fnv1_hash(const std::string &str)
Calculate a FNV-1 hash of str.
Definition helpers.cpp:134
uint8_t crc8(const uint8_t *data, uint8_t len)
Calculate a CRC-8 checksum of data with size len using the CRC-8-Dallas/Maxim polynomial.
Definition helpers.cpp:44
float random_float()
Return a random float between 0 and 1.
Definition helpers.cpp:143
float gamma_uncorrect(float value, float gamma)
Reverts gamma correction of gamma to value.
Definition helpers.cpp:490
uint16_t crc16(const uint8_t *data, uint16_t len, uint16_t crc, uint16_t reverse_poly, bool refin, bool refout)
Calculate a CRC-16 checksum of data with size len.
Definition helpers.cpp:60
std::string value_accuracy_to_string(float value, int8_t accuracy_decimals)
Create a string from a value and an accuracy in decimals.
Definition helpers.cpp:339
float gamma_correct(float value, float gamma)
Applies gamma correction of gamma to value.
Definition helpers.cpp:482
bool mac_address_is_valid(const uint8_t *mac)
Check if the MAC address is not all zeros or all ones.
Definition helpers.cpp:594
void rgb_to_hsv(float red, float green, float blue, int &hue, float &saturation, float &value)
Convert red, green and blue (all 0-1) values to hue (0-360), saturation (0-1) and value (0-1).
Definition helpers.cpp:499
std::string format_hex(const uint8_t *data, size_t length)
Format the byte array data of length len in lowercased hex.
Definition helpers.cpp:249
std::string str_lower_case(const std::string &str)
Convert the string to lower case.
Definition helpers.cpp:175
ParseOnOffState parse_on_off(const char *str, const char *on, const char *off)
Parse a string that contains either on, off or toggle.
Definition helpers.cpp:324
std::string format_bin(const uint8_t *data, size_t length)
Format the byte array data of length len in binary.
Definition helpers.cpp:312
std::string str_sanitize(const std::string &str)
Sanitizes the input string by removing all characters but alphanumerics, dashes and underscores.
Definition helpers.cpp:184
std::string size_t len
Definition helpers.h:279
bool has_custom_mac_address()
Check if a custom MAC address is set (ESP32 & variants)
Definition helpers.cpp:93
size_t parse_hex(const char *str, size_t length, uint8_t *data, size_t count)
Parse bytes from a hex-encoded string into a byte array.
Definition helpers.cpp:226
std::string get_mac_address_pretty()
Get the device MAC address as a string, in colon-separated uppercase hex notation.
Definition helpers.cpp:584
std::string str_snprintf(const char *fmt, size_t len,...)
Definition helpers.cpp:194
int8_t step_to_accuracy_decimals(float step)
Derive accuracy in decimals from an increment step.
Definition helpers.cpp:350
uint32_t IRAM_ATTR HOT micros()
Definition core.cpp:30
uint32_t random_uint32()
Return a random 32-bit unsigned integer.
Definition helpers.cpp:17
void IRAM_ATTR HOT delay_microseconds_safe(uint32_t us)
Delay for the given amount of microseconds, possibly yielding to other processes during the wait.
Definition helpers.cpp:611
std::string str_upper_case(const std::string &str)
Convert the string to upper case.
Definition helpers.cpp:176
std::string format_hex_pretty(const uint8_t *data, size_t length, char separator, bool show_length)
Format a byte array in pretty-printed, human-readable hex format.
Definition helpers.cpp:280
bool str_equals_case_insensitive(const std::string &a, const std::string &b)
Compare strings for equality in case-insensitive manner.
Definition helpers.cpp:147
std::string str_until(const char *str, char ch)
Extract the part of the string until either the first occurrence of the specified character,...
Definition helpers.cpp:162
std::string format_mac_address_pretty(const uint8_t *mac)
Definition helpers.cpp:244
std::string base64_encode(const std::vector< uint8_t > &buf)
Definition helpers.cpp:382
void hsv_to_rgb(int hue, float saturation, float value, float &red, float &green, float &blue)
Convert hue (0-360), saturation (0-1) and value (0-1) to red, green and blue (all 0-1).
Definition helpers.cpp:522
uint16_t crc16be(const uint8_t *data, uint16_t len, uint16_t crc, uint16_t poly, bool refin, bool refout)
Definition helpers.cpp:100
std::string str_sprintf(const char *fmt,...)
Definition helpers.cpp:208
void get_mac_address_raw(uint8_t *mac)
Get the device MAC address as raw bytes, written into the provided byte array (6 bytes).
Definition helpers.cpp:73
bool str_startswith(const std::string &str, const std::string &start)
Check whether a string starts with a value.
Definition helpers.cpp:151
void IRAM_ATTR HOT delay(uint32_t ms)
Definition core.cpp:29
std::string get_mac_address()
Get the device MAC address as a string, in lowercase hex notation.
Definition helpers.cpp:578
std::string str_snake_case(const std::string &str)
Convert the string to snake case (lowercase with underscores).
Definition helpers.cpp:177
bool str_endswith(const std::string &str, const std::string &end)
Check whether a string ends with a value.
Definition helpers.cpp:152
size_t base64_decode(const std::string &encoded_string, uint8_t *buf, size_t buf_len)
Definition helpers.cpp:424
ParseOnOffState
Return values for parse_on_off().
Definition helpers.h:551
@ PARSE_ON
Definition helpers.h:553
@ PARSE_TOGGLE
Definition helpers.h:555
@ PARSE_OFF
Definition helpers.h:554
@ PARSE_NONE
Definition helpers.h:552
std::string str_ctype_transform(const std::string &str)
Definition helpers.cpp:169
std::string str_truncate(const std::string &str, size_t length)
Truncate a string to a specific length.
Definition helpers.cpp:159
uint8_t end[39]
Definition sun_gtil2.cpp:17
uint16_t length
Definition tt21100.cpp:0