ESPHome 2025.6.0
Loading...
Searching...
No Matches
helpers.h
Go to the documentation of this file.
1#pragma once
2
3#include <cmath>
4#include <cstdint>
5#include <cstring>
6#include <functional>
7#include <limits>
8#include <memory>
9#include <string>
10#include <type_traits>
11#include <vector>
12
14
15#ifdef USE_ESP8266
16#include <Esp.h>
17#endif
18
19#ifdef USE_RP2040
20#include <Arduino.h>
21#endif
22
23#ifdef USE_ESP32
24#include <esp_heap_caps.h>
25#endif
26
27#if defined(USE_ESP32)
28#include <freertos/FreeRTOS.h>
29#include <freertos/semphr.h>
30#elif defined(USE_LIBRETINY)
31#include <FreeRTOS.h>
32#include <semphr.h>
33#endif
34
35#define HOT __attribute__((hot))
36#define ESPDEPRECATED(msg, when) __attribute__((deprecated(msg)))
37#define ESPHOME_ALWAYS_INLINE __attribute__((always_inline))
38#define PACKED __attribute__((packed))
39
40// Various functions can be constexpr in C++14, but not in C++11 (because their body isn't just a return statement).
41// Define a substitute constexpr keyword for those functions, until we can drop C++11 support.
42#if __cplusplus >= 201402L
43#define constexpr14 constexpr
44#else
45#define constexpr14 inline // constexpr implies inline
46#endif
47
48namespace esphome {
49
52
53// Backports for various STL features we like to use. Pull in the STL implementation wherever available, to avoid
54// ambiguity and to provide a uniform API.
55
56// std::to_string() from C++11, available from libstdc++/g++ 8
57// See https://github.com/espressif/esp-idf/issues/1445
58#if _GLIBCXX_RELEASE >= 8
59using std::to_string;
60#else
61std::string to_string(int value); // NOLINT
62std::string to_string(long value); // NOLINT
63std::string to_string(long long value); // NOLINT
64std::string to_string(unsigned value); // NOLINT
65std::string to_string(unsigned long value); // NOLINT
66std::string to_string(unsigned long long value); // NOLINT
67std::string to_string(float value);
68std::string to_string(double value);
69std::string to_string(long double value);
70#endif
71
72// std::is_trivially_copyable from C++11, implemented in libstdc++/g++ 5.1 (but minor releases can't be detected)
73#if _GLIBCXX_RELEASE >= 6
74using std::is_trivially_copyable;
75#else
76// Implementing this is impossible without compiler intrinsics, so don't bother. Invalid usage will be detected on
77// other variants that use a newer compiler anyway.
78// NOLINTNEXTLINE(readability-identifier-naming)
79template<typename T> struct is_trivially_copyable : public std::integral_constant<bool, true> {};
80#endif
81
82// std::make_unique() from C++14
83#if __cpp_lib_make_unique >= 201304
84using std::make_unique;
85#else
86template<typename T, typename... Args> std::unique_ptr<T> make_unique(Args &&...args) {
87 return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
88}
89#endif
90
91// std::enable_if_t from C++14
92#if __cplusplus >= 201402L
93using std::enable_if_t;
94#else
95template<bool B, class T = void> using enable_if_t = typename std::enable_if<B, T>::type;
96#endif
97
98// std::clamp from C++17
99#if __cpp_lib_clamp >= 201603
100using std::clamp;
101#else
102template<typename T, typename Compare> constexpr const T &clamp(const T &v, const T &lo, const T &hi, Compare comp) {
103 return comp(v, lo) ? lo : comp(hi, v) ? hi : v;
104}
105template<typename T> constexpr const T &clamp(const T &v, const T &lo, const T &hi) {
106 return clamp(v, lo, hi, std::less<T>{});
107}
108#endif
109
110// std::is_invocable from C++17
111#if __cpp_lib_is_invocable >= 201703
112using std::is_invocable;
113#else
114// https://stackoverflow.com/a/37161919/8924614
115template<class T, class... Args> struct is_invocable { // NOLINT(readability-identifier-naming)
116 template<class U> static auto test(U *p) -> decltype((*p)(std::declval<Args>()...), void(), std::true_type());
117 template<class U> static auto test(...) -> decltype(std::false_type());
118 static constexpr auto value = decltype(test<T>(nullptr))::value; // NOLINT
119};
120#endif
121
122// std::bit_cast from C++20
123#if __cpp_lib_bit_cast >= 201806
124using std::bit_cast;
125#else
127template<
128 typename To, typename From,
130 int> = 0>
131To bit_cast(const From &src) {
132 To dst;
133 memcpy(&dst, &src, sizeof(To));
134 return dst;
135}
136#endif
137
138// std::byteswap from C++23
139template<typename T> constexpr14 T byteswap(T n) {
140 T m;
141 for (size_t i = 0; i < sizeof(T); i++)
142 reinterpret_cast<uint8_t *>(&m)[i] = reinterpret_cast<uint8_t *>(&n)[sizeof(T) - 1 - i];
143 return m;
144}
145template<> constexpr14 uint8_t byteswap(uint8_t n) { return n; }
146template<> constexpr14 uint16_t byteswap(uint16_t n) { return __builtin_bswap16(n); }
147template<> constexpr14 uint32_t byteswap(uint32_t n) { return __builtin_bswap32(n); }
148template<> constexpr14 uint64_t byteswap(uint64_t n) { return __builtin_bswap64(n); }
149template<> constexpr14 int8_t byteswap(int8_t n) { return n; }
150template<> constexpr14 int16_t byteswap(int16_t n) { return __builtin_bswap16(n); }
151template<> constexpr14 int32_t byteswap(int32_t n) { return __builtin_bswap32(n); }
152template<> constexpr14 int64_t byteswap(int64_t n) { return __builtin_bswap64(n); }
153
155
158
160float lerp(float completion, float start, float end);
161
163template<typename T, typename U> T remap(U value, U min, U max, T min_out, T max_out) {
164 return (value - min) * (max_out - min_out) / (max - min) + min_out;
165}
166
168uint8_t crc8(const uint8_t *data, uint8_t len);
169
171uint16_t crc16(const uint8_t *data, uint16_t len, uint16_t crc = 0xffff, uint16_t reverse_poly = 0xa001,
172 bool refin = false, bool refout = false);
173uint16_t crc16be(const uint8_t *data, uint16_t len, uint16_t crc = 0, uint16_t poly = 0x1021, bool refin = false,
174 bool refout = false);
175
177uint32_t fnv1_hash(const std::string &str);
178
180uint32_t random_uint32();
182float random_float();
184bool random_bytes(uint8_t *data, size_t len);
185
187
190
192constexpr uint16_t encode_uint16(uint8_t msb, uint8_t lsb) {
193 return (static_cast<uint16_t>(msb) << 8) | (static_cast<uint16_t>(lsb));
194}
196constexpr uint32_t encode_uint24(uint8_t byte1, uint8_t byte2, uint8_t byte3) {
197 return (static_cast<uint32_t>(byte1) << 16) | (static_cast<uint32_t>(byte2) << 8) | (static_cast<uint32_t>(byte3));
198}
200constexpr uint32_t encode_uint32(uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4) {
201 return (static_cast<uint32_t>(byte1) << 24) | (static_cast<uint32_t>(byte2) << 16) |
202 (static_cast<uint32_t>(byte3) << 8) | (static_cast<uint32_t>(byte4));
203}
204
206template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
207constexpr14 T encode_value(const uint8_t *bytes) {
208 T val = 0;
209 for (size_t i = 0; i < sizeof(T); i++) {
210 val <<= 8;
211 val |= bytes[i];
212 }
213 return val;
214}
216template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
217constexpr14 T encode_value(const std::array<uint8_t, sizeof(T)> bytes) {
218 return encode_value<T>(bytes.data());
219}
221template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
222constexpr14 std::array<uint8_t, sizeof(T)> decode_value(T val) {
223 std::array<uint8_t, sizeof(T)> ret{};
224 for (size_t i = sizeof(T); i > 0; i--) {
225 ret[i - 1] = val & 0xFF;
226 val >>= 8;
227 }
228 return ret;
229}
230
232inline uint8_t reverse_bits(uint8_t x) {
233 x = ((x & 0xAA) >> 1) | ((x & 0x55) << 1);
234 x = ((x & 0xCC) >> 2) | ((x & 0x33) << 2);
235 x = ((x & 0xF0) >> 4) | ((x & 0x0F) << 4);
236 return x;
237}
239inline uint16_t reverse_bits(uint16_t x) {
240 return (reverse_bits(static_cast<uint8_t>(x & 0xFF)) << 8) | reverse_bits(static_cast<uint8_t>((x >> 8) & 0xFF));
241}
243inline uint32_t reverse_bits(uint32_t x) {
244 return (reverse_bits(static_cast<uint16_t>(x & 0xFFFF)) << 16) |
245 reverse_bits(static_cast<uint16_t>((x >> 16) & 0xFFFF));
246}
247
249template<typename T> constexpr14 T convert_big_endian(T val) {
250#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
251 return byteswap(val);
252#else
253 return val;
254#endif
255}
256
258template<typename T> constexpr14 T convert_little_endian(T val) {
259#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
260 return val;
261#else
262 return byteswap(val);
263#endif
264}
265
267
270
272bool str_equals_case_insensitive(const std::string &a, const std::string &b);
273
275bool str_startswith(const std::string &str, const std::string &start);
277bool str_endswith(const std::string &str, const std::string &end);
278
280inline std::string to_string(const std::string &val) { return val; }
281
283std::string str_truncate(const std::string &str, size_t length);
284
287std::string str_until(const char *str, char ch);
289std::string str_until(const std::string &str, char ch);
290
292std::string str_lower_case(const std::string &str);
294std::string str_upper_case(const std::string &str);
296std::string str_snake_case(const std::string &str);
297
299std::string str_sanitize(const std::string &str);
300
302std::string __attribute__((format(printf, 1, 3))) str_snprintf(const char *fmt, size_t len, ...);
303
305std::string __attribute__((format(printf, 1, 2))) str_sprintf(const char *fmt, ...);
306
308
311
313template<typename T, enable_if_t<(std::is_integral<T>::value && std::is_unsigned<T>::value), int> = 0>
314optional<T> parse_number(const char *str) {
315 char *end = nullptr;
316 unsigned long value = ::strtoul(str, &end, 10); // NOLINT(google-runtime-int)
317 if (end == str || *end != '\0' || value > std::numeric_limits<T>::max())
318 return {};
319 return value;
320}
322template<typename T, enable_if_t<(std::is_integral<T>::value && std::is_unsigned<T>::value), int> = 0>
323optional<T> parse_number(const std::string &str) {
324 return parse_number<T>(str.c_str());
325}
327template<typename T, enable_if_t<(std::is_integral<T>::value && std::is_signed<T>::value), int> = 0>
328optional<T> parse_number(const char *str) {
329 char *end = nullptr;
330 signed long value = ::strtol(str, &end, 10); // NOLINT(google-runtime-int)
331 if (end == str || *end != '\0' || value < std::numeric_limits<T>::min() || value > std::numeric_limits<T>::max())
332 return {};
333 return value;
334}
336template<typename T, enable_if_t<(std::is_integral<T>::value && std::is_signed<T>::value), int> = 0>
337optional<T> parse_number(const std::string &str) {
338 return parse_number<T>(str.c_str());
339}
341template<typename T, enable_if_t<(std::is_same<T, float>::value), int> = 0> optional<T> parse_number(const char *str) {
342 char *end = nullptr;
343 float value = ::strtof(str, &end);
344 if (end == str || *end != '\0' || value == HUGE_VALF)
345 return {};
346 return value;
347}
349template<typename T, enable_if_t<(std::is_same<T, float>::value), int> = 0>
350optional<T> parse_number(const std::string &str) {
351 return parse_number<T>(str.c_str());
352}
353
365size_t parse_hex(const char *str, size_t len, uint8_t *data, size_t count);
367inline bool parse_hex(const char *str, uint8_t *data, size_t count) {
368 return parse_hex(str, strlen(str), data, count) == 2 * count;
369}
371inline bool parse_hex(const std::string &str, uint8_t *data, size_t count) {
372 return parse_hex(str.c_str(), str.length(), data, count) == 2 * count;
373}
375inline bool parse_hex(const char *str, std::vector<uint8_t> &data, size_t count) {
376 data.resize(count);
377 return parse_hex(str, strlen(str), data.data(), count) == 2 * count;
378}
380inline bool parse_hex(const std::string &str, std::vector<uint8_t> &data, size_t count) {
381 data.resize(count);
382 return parse_hex(str.c_str(), str.length(), data.data(), count) == 2 * count;
383}
389template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
390optional<T> parse_hex(const char *str, size_t len) {
391 T val = 0;
392 if (len > 2 * sizeof(T) || parse_hex(str, len, reinterpret_cast<uint8_t *>(&val), sizeof(T)) == 0)
393 return {};
394 return convert_big_endian(val);
395}
397template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> optional<T> parse_hex(const char *str) {
398 return parse_hex<T>(str, strlen(str));
399}
401template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> optional<T> parse_hex(const std::string &str) {
402 return parse_hex<T>(str.c_str(), str.length());
403}
404
406std::string format_hex(const uint8_t *data, size_t length);
408std::string format_hex(const std::vector<uint8_t> &data);
410template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> std::string format_hex(T val) {
412 return format_hex(reinterpret_cast<uint8_t *>(&val), sizeof(T));
413}
414template<std::size_t N> std::string format_hex(const std::array<uint8_t, N> &data) {
415 return format_hex(data.data(), data.size());
416}
417
419std::string format_hex_pretty(const uint8_t *data, size_t length);
421std::string format_hex_pretty(const uint16_t *data, size_t length);
423std::string format_hex_pretty(const std::vector<uint8_t> &data);
425std::string format_hex_pretty(const std::vector<uint16_t> &data);
427template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> std::string format_hex_pretty(T val) {
429 return format_hex_pretty(reinterpret_cast<uint8_t *>(&val), sizeof(T));
430}
431
433std::string format_bin(const uint8_t *data, size_t length);
435template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> std::string format_bin(T val) {
437 return format_bin(reinterpret_cast<uint8_t *>(&val), sizeof(T));
438}
439
448ParseOnOffState parse_on_off(const char *str, const char *on = nullptr, const char *off = nullptr);
449
451std::string value_accuracy_to_string(float value, int8_t accuracy_decimals);
452
454int8_t step_to_accuracy_decimals(float step);
455
456std::string base64_encode(const uint8_t *buf, size_t buf_len);
457std::string base64_encode(const std::vector<uint8_t> &buf);
458
459std::vector<uint8_t> base64_decode(const std::string &encoded_string);
460size_t base64_decode(std::string const &encoded_string, uint8_t *buf, size_t buf_len);
461
463
466
468float gamma_correct(float value, float gamma);
470float gamma_uncorrect(float value, float gamma);
471
473void rgb_to_hsv(float red, float green, float blue, int &hue, float &saturation, float &value);
475void hsv_to_rgb(int hue, float saturation, float value, float &red, float &green, float &blue);
476
478
481
483constexpr float celsius_to_fahrenheit(float value) { return value * 1.8f + 32.0f; }
485constexpr float fahrenheit_to_celsius(float value) { return (value - 32.0f) / 1.8f; }
486
488
491
492template<typename... X> class CallbackManager;
493
498template<typename... Ts> class CallbackManager<void(Ts...)> {
499 public:
501 void add(std::function<void(Ts...)> &&callback) { this->callbacks_.push_back(std::move(callback)); }
502
504 void call(Ts... args) {
505 for (auto &cb : this->callbacks_)
506 cb(args...);
507 }
508 size_t size() const { return this->callbacks_.size(); }
509
511 void operator()(Ts... args) { call(args...); }
512
513 protected:
514 std::vector<std::function<void(Ts...)>> callbacks_;
515};
516
518template<typename T> class Deduplicator {
519 public:
521 bool next(T value) {
522 if (this->has_value_) {
523 if (this->last_value_ == value)
524 return false;
525 }
526 this->has_value_ = true;
527 this->last_value_ = value;
528 return true;
529 }
531 bool has_value() const { return this->has_value_; }
532
533 protected:
534 bool has_value_{false};
536};
537
539template<typename T> class Parented {
540 public:
542 Parented(T *parent) : parent_(parent) {}
543
545 T *get_parent() const { return parent_; }
547 void set_parent(T *parent) { parent_ = parent; }
548
549 protected:
550 T *parent_{nullptr};
551};
552
554
557
562class Mutex {
563 public:
564 Mutex();
565 Mutex(const Mutex &) = delete;
566 ~Mutex();
567 void lock();
568 bool try_lock();
569 void unlock();
570
571 Mutex &operator=(const Mutex &) = delete;
572
573 private:
574#if defined(USE_ESP32) || defined(USE_LIBRETINY)
575 SemaphoreHandle_t handle_;
576#else
577 // d-pointer to store private data on new platforms
578 void *handle_; // NOLINT(clang-diagnostic-unused-private-field)
579#endif
580};
581
587 public:
588 LockGuard(Mutex &mutex) : mutex_(mutex) { mutex_.lock(); }
589 ~LockGuard() { mutex_.unlock(); }
590
591 private:
592 Mutex &mutex_;
593};
594
616 public:
619
620 protected:
621#if defined(USE_ESP8266) || defined(USE_RP2040)
622 uint32_t state_;
623#endif
624};
625
632 public:
634 void start();
636 void stop();
637
639 static bool is_high_frequency();
640
641 protected:
642 bool started_{false};
643 static uint8_t num_requests; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
644};
645
647void get_mac_address_raw(uint8_t *mac); // NOLINT(readability-non-const-parameter)
648
650std::string get_mac_address();
651
653std::string get_mac_address_pretty();
654
655#ifdef USE_ESP32
657void set_mac_address(uint8_t *mac);
658#endif
659
663
666bool mac_address_is_valid(const uint8_t *mac);
667
669void delay_microseconds_safe(uint32_t us);
670
672
675
684template<class T> class RAMAllocator {
685 public:
686 using value_type = T;
687
688 enum Flags {
689 NONE = 0, // Perform external allocation and fall back to internal memory
690 ALLOC_EXTERNAL = 1 << 0, // Perform external allocation only.
691 ALLOC_INTERNAL = 1 << 1, // Perform internal allocation only.
692 ALLOW_FAILURE = 1 << 2, // Does nothing. Kept for compatibility.
693 };
694
695 RAMAllocator() = default;
696 RAMAllocator(uint8_t flags) {
697 // default is both external and internal
699 if (flags != 0)
700 this->flags_ = flags;
701 }
702 template<class U> constexpr RAMAllocator(const RAMAllocator<U> &other) : flags_{other.flags_} {}
703
704 T *allocate(size_t n) { return this->allocate(n, sizeof(T)); }
705
706 T *allocate(size_t n, size_t manual_size) {
707 size_t size = n * manual_size;
708 T *ptr = nullptr;
709#ifdef USE_ESP32
710 if (this->flags_ & Flags::ALLOC_EXTERNAL) {
711 ptr = static_cast<T *>(heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
712 }
713 if (ptr == nullptr && this->flags_ & Flags::ALLOC_INTERNAL) {
714 ptr = static_cast<T *>(heap_caps_malloc(size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT));
715 }
716#else
717 // Ignore ALLOC_EXTERNAL/ALLOC_INTERNAL flags if external allocation is not supported
718 ptr = static_cast<T *>(malloc(size)); // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
719#endif
720 return ptr;
721 }
722
723 T *reallocate(T *p, size_t n) { return this->reallocate(p, n, sizeof(T)); }
724
725 T *reallocate(T *p, size_t n, size_t manual_size) {
726 size_t size = n * sizeof(T);
727 T *ptr = nullptr;
728#ifdef USE_ESP32
729 if (this->flags_ & Flags::ALLOC_EXTERNAL) {
730 ptr = static_cast<T *>(heap_caps_realloc(p, size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
731 }
732 if (ptr == nullptr && this->flags_ & Flags::ALLOC_INTERNAL) {
733 ptr = static_cast<T *>(heap_caps_realloc(p, size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT));
734 }
735#else
736 // Ignore ALLOC_EXTERNAL/ALLOC_INTERNAL flags if external allocation is not supported
737 ptr = static_cast<T *>(realloc(p, size)); // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
738#endif
739 return ptr;
740 }
741
742 void deallocate(T *p, size_t n) {
743 free(p); // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
744 }
745
749 size_t get_free_heap_size() const {
750#ifdef USE_ESP8266
751 return ESP.getFreeHeap(); // NOLINT(readability-static-accessed-through-instance)
752#elif defined(USE_ESP32)
753 auto max_internal =
754 this->flags_ & ALLOC_INTERNAL ? heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL) : 0;
755 auto max_external =
756 this->flags_ & ALLOC_EXTERNAL ? heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM) : 0;
757 return max_internal + max_external;
758#elif defined(USE_RP2040)
759 return ::rp2040.getFreeHeap();
760#elif defined(USE_LIBRETINY)
761 return lt_heap_get_free();
762#else
763 return 100000;
764#endif
765 }
766
770 size_t get_max_free_block_size() const {
771#ifdef USE_ESP8266
772 return ESP.getMaxFreeBlockSize(); // NOLINT(readability-static-accessed-through-instance)
773#elif defined(USE_ESP32)
774 auto max_internal =
775 this->flags_ & ALLOC_INTERNAL ? heap_caps_get_largest_free_block(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL) : 0;
776 auto max_external =
777 this->flags_ & ALLOC_EXTERNAL ? heap_caps_get_largest_free_block(MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM) : 0;
778 return std::max(max_internal, max_external);
779#else
780 return this->get_free_heap_size();
781#endif
782 }
783
784 private:
785 uint8_t flags_{ALLOC_INTERNAL | ALLOC_EXTERNAL};
786};
787
788template<class T> using ExternalRAMAllocator = RAMAllocator<T>;
789
791
794
799template<typename T, enable_if_t<!std::is_pointer<T>::value, int> = 0> T id(T value) { return value; }
804template<typename T, enable_if_t<std::is_pointer<T *>::value, int> = 0> T &id(T *value) { return *value; }
805
807
810
811ESPDEPRECATED("hexencode() is deprecated, use format_hex_pretty() instead.", "2022.1")
812inline std::string hexencode(const uint8_t *data, uint32_t len) { return format_hex_pretty(data, len); }
813
814template<typename T>
815ESPDEPRECATED("hexencode() is deprecated, use format_hex_pretty() instead.", "2022.1")
816std::string hexencode(const T &data) {
817 return hexencode(data.data(), data.size());
818}
819
821
822} // namespace esphome
uint8_t m
Definition bl0906.h:1
void operator()(Ts... args)
Call all callbacks in this manager.
Definition helpers.h:511
std::vector< std::function< void(Ts...)> > callbacks_
Definition helpers.h:514
void call(Ts... args)
Call all callbacks in this manager.
Definition helpers.h:504
void add(std::function< void(Ts...)> &&callback)
Add a callback to the list.
Definition helpers.h:501
Helper class to deduplicate items in a series of values.
Definition helpers.h:518
bool next(T value)
Feeds the next item in the series to the deduplicator and returns whether this is a duplicate.
Definition helpers.h:521
bool has_value() const
Returns whether this deduplicator has processed any items so far.
Definition helpers.h:531
Helper class to request loop() to be called as fast as possible.
Definition helpers.h:631
void stop()
Stop running the loop continuously.
Definition helpers.cpp:679
static bool is_high_frequency()
Check whether the loop is running continuously.
Definition helpers.cpp:685
void start()
Start running the loop continuously.
Definition helpers.cpp:673
Helper class to disable interrupts.
Definition helpers.h:615
Helper class that wraps a mutex with a RAII-style API.
Definition helpers.h:586
LockGuard(Mutex &mutex)
Definition helpers.h:588
Mutex implementation, with API based on the unavailable std::mutex.
Definition helpers.h:562
bool try_lock()
Definition helpers.cpp:649
Mutex(const Mutex &)=delete
Mutex & operator=(const Mutex &)=delete
Helper class to easily give an object a parent of type T.
Definition helpers.h:539
T * get_parent() const
Get the parent of this object.
Definition helpers.h:545
Parented(T *parent)
Definition helpers.h:542
void set_parent(T *parent)
Set the parent of this object.
Definition helpers.h:547
An STL allocator that uses SPI or internal RAM.
Definition helpers.h:684
RAMAllocator(uint8_t flags)
Definition helpers.h:696
T * reallocate(T *p, size_t n, size_t manual_size)
Definition helpers.h:725
size_t get_free_heap_size() const
Return the total heap space available via this allocator.
Definition helpers.h:749
T * reallocate(T *p, size_t n)
Definition helpers.h:723
void deallocate(T *p, size_t n)
Definition helpers.h:742
size_t get_max_free_block_size() const
Return the maximum size block this allocator could allocate.
Definition helpers.h:770
T * allocate(size_t n)
Definition helpers.h:704
constexpr RAMAllocator(const RAMAllocator< U > &other)
Definition helpers.h:702
T * allocate(size_t n, size_t manual_size)
Definition helpers.h:706
struct @67::@68 __attribute__
mopeka_std_values val[4]
Providing packet encoding functions for exchanging data with a remote host.
Definition a01nyub.cpp:7
constexpr14 T encode_value(const uint8_t *bytes)
Encode a value from its constituent bytes (from most to least significant) in an array with length si...
Definition helpers.h:207
constexpr14 T convert_little_endian(T val)
Convert a value between host byte order and little endian (least significant byte first) order.
Definition helpers.h:258
uint32_t fnv1_hash(const std::string &str)
Calculate a FNV-1 hash of str.
Definition helpers.cpp:186
bool random_bytes(uint8_t *data, size_t len)
Generate len number of random bytes.
Definition helpers.cpp:220
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:96
ESPDEPRECATED("Use Color::BLACK instead of COLOR_BLACK", "v1.21") extern const Color COLOR_BLACK
float random_float()
Return a random float between 0 and 1.
Definition helpers.cpp:218
float gamma_uncorrect(float value, float gamma)
Reverts gamma correction of gamma to value.
Definition helpers.cpp:570
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:112
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:435
float gamma_correct(float value, float gamma)
Applies gamma correction of gamma to value.
Definition helpers.cpp:562
bool mac_address_is_valid(const uint8_t *mac)
Check if the MAC address is not all zeros or all ones.
Definition helpers.cpp:756
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:579
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:360
std::string str_lower_case(const std::string &str)
Convert the string to lower case.
Definition helpers.cpp:290
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:420
std::string format_bin(const uint8_t *data, size_t length)
Format the byte array data of length len in binary.
Definition helpers.cpp:408
std::string str_sanitize(const std::string &str)
Sanitizes the input string by removing all characters but alphanumerics, dashes and underscores.
Definition helpers.cpp:299
std::string size_t len
Definition helpers.h:302
constexpr uint32_t encode_uint24(uint8_t byte1, uint8_t byte2, uint8_t byte3)
Encode a 24-bit value given three bytes in most to least significant byte order.
Definition helpers.h:196
bool has_custom_mac_address()
Check if a custom MAC address is set (ESP32 & variants)
Definition helpers.cpp:742
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:341
std::unique_ptr< T > make_unique(Args &&...args)
Definition helpers.h:86
optional< T > parse_number(const char *str)
Parse an unsigned decimal number from a null-terminated string.
Definition helpers.h:314
std::string get_mac_address_pretty()
Get the device MAC address as a string, in colon-separated uppercase hex notation.
Definition helpers.cpp:732
std::string str_snprintf(const char *fmt, size_t len,...)
Definition helpers.cpp:309
void set_mac_address(uint8_t *mac)
Set the MAC address to use from the provided byte array (6 bytes).
Definition helpers.cpp:739
int8_t step_to_accuracy_decimals(float step)
Derive accuracy in decimals from an increment step.
Definition helpers.cpp:446
constexpr14 T convert_big_endian(T val)
Convert a value between host byte order and big endian (most significant byte first) order.
Definition helpers.h:249
uint32_t random_uint32()
Return a random 32-bit unsigned integer.
Definition helpers.cpp:196
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:773
std::string str_upper_case(const std::string &str)
Convert the string to upper case.
Definition helpers.cpp:291
bool str_equals_case_insensitive(const std::string &a, const std::string &b)
Compare strings for equality in case-insensitive manner.
Definition helpers.cpp:262
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:277
typename std::enable_if< B, T >::type enable_if_t
Definition helpers.h:95
std::string base64_encode(const std::vector< uint8_t > &buf)
Definition helpers.cpp:465
constexpr14 std::array< uint8_t, sizeof(T)> decode_value(T val)
Decode a value into its constituent bytes (from most to least significant).
Definition helpers.h:222
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:602
uint16_t crc16be(const uint8_t *data, uint16_t len, uint16_t crc, uint16_t poly, bool refin, bool refout)
Definition helpers.cpp:152
constexpr uint32_t encode_uint32(uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4)
Encode a 32-bit value given four bytes in most to least significant byte order.
Definition helpers.h:200
std::string to_string(int value)
Definition helpers.cpp:82
constexpr float celsius_to_fahrenheit(float value)
Convert degrees Celsius to degrees Fahrenheit.
Definition helpers.h:483
std::string str_sprintf(const char *fmt,...)
Definition helpers.cpp:323
constexpr uint16_t encode_uint16(uint8_t msb, uint8_t lsb)
Encode a 16-bit value given the most and least significant byte.
Definition helpers.h:192
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:688
bool str_startswith(const std::string &str, const std::string &start)
Check whether a string starts with a value.
Definition helpers.cpp:266
std::string get_mac_address()
Get the device MAC address as a string, in lowercase hex notation.
Definition helpers.cpp:726
To bit_cast(const From &src)
Convert data between types, without aliasing issues or undefined behaviour.
Definition helpers.h:131
constexpr float fahrenheit_to_celsius(float value)
Convert degrees Fahrenheit to degrees Celsius.
Definition helpers.h:485
uint8_t reverse_bits(uint8_t x)
Reverse the order of 8 bits.
Definition helpers.h:232
std::string str_snake_case(const std::string &str)
Convert the string to snake case (lowercase with underscores).
Definition helpers.cpp:292
T remap(U value, U min, U max, T min_out, T max_out)
Remap value from the range (min, max) to (min_out, max_out).
Definition helpers.h:163
bool str_endswith(const std::string &str, const std::string &end)
Check whether a string ends with a value.
Definition helpers.cpp:267
float lerp(float completion, float start, float end)
Linearly interpolate between start and end by completion (between 0 and 1).
Definition helpers.cpp:95
T id(T value)
Helper function to make id(var) known from lambdas work in custom components.
Definition helpers.h:799
size_t base64_decode(const std::string &encoded_string, uint8_t *buf, size_t buf_len)
Definition helpers.cpp:507
ParseOnOffState
Return values for parse_on_off().
Definition helpers.h:441
@ PARSE_ON
Definition helpers.h:443
@ PARSE_TOGGLE
Definition helpers.h:445
@ PARSE_OFF
Definition helpers.h:444
@ PARSE_NONE
Definition helpers.h:442
constexpr const T & clamp(const T &v, const T &lo, const T &hi, Compare comp)
Definition helpers.h:102
std::string format_hex_pretty(const uint8_t *data, size_t length)
Format the byte array data of length len in pretty-printed, human-readable hex.
Definition helpers.cpp:372
std::string str_truncate(const std::string &str, size_t length)
Truncate a string to a specific length.
Definition helpers.cpp:274
static constexpr auto value
Definition helpers.h:118
static auto test(...) -> decltype(std::false_type())
static auto test(U *p) -> decltype((*p)(std::declval< Args >()...), void(), std::true_type())
uint8_t end[39]
Definition sun_gtil2.cpp:17
void byteswap()
uint16_t length
Definition tt21100.cpp:0
uint16_t x
Definition tt21100.cpp:5