17 #include <netinet/in.h> 18 #include <sys/ioctl.h> 22 #if defined(USE_ESP8266) 24 #include <user_interface.h> 27 #elif defined(USE_ESP32_FRAMEWORK_ARDUINO) 29 #elif defined(USE_ESP_IDF) 30 #include <freertos/FreeRTOS.h> 31 #include <freertos/portmacro.h> 33 #include "esp_random.h" 34 #include "esp_system.h" 35 #elif defined(USE_RP2040) 39 #include <hardware/structs/rosc.h> 40 #include <hardware/sync.h> 41 #elif defined(USE_HOST) 46 #include "esp32/rom/crc.h" 49 #if defined(CONFIG_SOC_IEEE802154_SUPPORTED) || defined(USE_ESP32_IGNORE_EFUSE_MAC_CRC) 50 #include "esp_efuse.h" 51 #include "esp_efuse_table.h" 60 static const char *
const TAG =
"helpers";
62 static const uint16_t CRC16_A001_LE_LUT_L[] = {0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241,
63 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440};
64 static const uint16_t CRC16_A001_LE_LUT_H[] = {0x0000, 0xcc01, 0xd801, 0x1400, 0xf001, 0x3c00, 0x2800, 0xe401,
65 0xa001, 0x6c00, 0x7800, 0xb401, 0x5000, 0x9c01, 0x8801, 0x4400};
68 static const uint16_t CRC16_8408_LE_LUT_L[] = {0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
69 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7};
70 static const uint16_t CRC16_8408_LE_LUT_H[] = {0x0000, 0x1081, 0x2102, 0x3183, 0x4204, 0x5285, 0x6306, 0x7387,
71 0x8408, 0x9489, 0xa50a, 0xb58b, 0xc60c, 0xd68d, 0xe70e, 0xf78f};
73 static const uint16_t CRC16_1021_BE_LUT_L[] = {0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
74 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef};
75 static const uint16_t CRC16_1021_BE_LUT_H[] = {0x0000, 0x1231, 0x2462, 0x3653, 0x48c4, 0x5af5, 0x6ca6, 0x7e97,
76 0x9188, 0x83b9, 0xb5ea, 0xa7db, 0xd94c, 0xcb7d, 0xfd2e, 0xef1f};
81 #if _GLIBCXX_RELEASE < 8 95 float lerp(
float completion,
float start,
float end) {
return start + (end - start) * completion; }
96 uint8_t
crc8(
const uint8_t *data, uint8_t
len) {
99 while ((len--) != 0u) {
100 uint8_t inbyte = *data++;
101 for (uint8_t i = 8; i != 0u; i--) {
102 bool mix = (crc ^ inbyte) & 0x01;
112 uint16_t
crc16(
const uint8_t *data, uint16_t
len, uint16_t
crc, uint16_t reverse_poly,
bool refin,
bool refout) {
114 if (reverse_poly == 0x8408) {
115 crc = crc16_le(refin ? crc : (crc ^ 0xffff), data, len);
116 return refout ?
crc : (crc ^ 0xffff);
123 if (reverse_poly == 0x8408) {
125 uint8_t combo = crc ^ (uint8_t) *data++;
126 crc = (crc >> 8) ^ CRC16_8408_LE_LUT_L[combo & 0x0F] ^ CRC16_8408_LE_LUT_H[combo >> 4];
130 if (reverse_poly == 0xa001) {
132 uint8_t combo = crc ^ (uint8_t) *data++;
133 crc = (crc >> 8) ^ CRC16_A001_LE_LUT_L[combo & 0x0F] ^ CRC16_A001_LE_LUT_H[combo >> 4];
138 for (uint8_t i = 0; i < 8; i++) {
140 crc = (crc >> 1) ^ reverse_poly;
147 return refout ? (crc ^ 0xffff) : crc;
150 uint16_t
crc16be(
const uint8_t *data, uint16_t
len, uint16_t
crc, uint16_t poly,
bool refin,
bool refout) {
152 if (poly == 0x1021) {
153 crc = crc16_be(refin ? crc : (crc ^ 0xffff), data, len);
154 return refout ?
crc : (crc ^ 0xffff);
161 if (poly == 0x1021) {
163 uint8_t combo = (crc >> 8) ^ *data++;
164 crc = (crc << 8) ^ CRC16_1021_BE_LUT_L[combo & 0x0F] ^ CRC16_1021_BE_LUT_H[combo >> 4];
169 crc ^= (((uint16_t) *data++) << 8);
170 for (uint8_t i = 0; i < 8; i++) {
172 crc = (crc << 1) ^ poly;
181 return refout ? (crc ^ 0xffff) : crc;
185 uint32_t hash = 2166136261UL;
196 #elif defined(USE_ESP8266) 198 #elif defined(USE_RP2040) 200 for (uint8_t i = 0; i < 32; i++) {
202 result |= rosc_hw->randombit;
205 #elif defined(USE_LIBRETINY) 207 #elif defined(USE_HOST) 208 std::random_device
dev;
209 std::mt19937 rng(
dev());
210 std::uniform_int_distribution<uint32_t> dist(0, std::numeric_limits<uint32_t>::max());
213 #error "No random source available for this configuration." 219 esp_fill_random(data, len);
221 #elif defined(USE_ESP8266) 222 return os_get_random(data, len) == 0;
223 #elif defined(USE_RP2040) 226 for (uint8_t i = 0; i < 8; i++) {
228 result |= rosc_hw->randombit;
233 #elif defined(USE_LIBRETINY) 234 lt_rand_bytes(data, len);
236 #elif defined(USE_HOST) 237 FILE *fp = fopen(
"/dev/urandom",
"r");
239 ESP_LOGW(TAG,
"Could not open /dev/urandom, errno=%d", errno);
242 size_t read = fread(data, 1, len, fp);
244 ESP_LOGW(TAG,
"Not enough data from /dev/urandom");
250 #error "No random source available for this configuration." 257 return strcasecmp(a.c_str(), b.c_str()) == 0;
259 bool str_startswith(
const std::string &str,
const std::string &start) {
return str.rfind(start, 0) == 0; }
261 return str.rfind(end) == (str.size() - end.size());
264 return str.length() > length ? str.substr(0, length) : str;
267 const char *pos = strchr(str, ch);
268 return pos ==
nullptr ? std::string(str) : std::string(str, pos - str);
270 std::string
str_until(
const std::string &str,
char ch) {
return str.substr(0, str.find(ch)); }
275 result.resize(str.length());
276 std::transform(str.begin(), str.end(), result.begin(), [](
unsigned char ch) {
return fn(ch); });
279 std::string
str_lower_case(
const std::string &str) {
return str_ctype_transform<std::tolower>(str); }
280 std::string
str_upper_case(
const std::string &str) {
return str_ctype_transform<std::toupper>(str); }
283 result.resize(str.length());
284 std::transform(str.begin(), str.end(), result.begin(), ::tolower);
285 std::replace(result.begin(), result.end(),
' ',
'_');
289 std::string out = str;
291 out.begin(), out.end(),
293 return !(c ==
'-' || c ==
'_' || (c >=
'0' && c <= '9') || (c >=
'a' && c <= 'z') || (c >=
'A' && c <=
'Z'));
304 size_t out_length = vsnprintf(&str[0], len + 1, fmt, args);
307 if (out_length < len)
308 str.resize(out_length);
317 size_t length = vsnprintf(
nullptr, 0, fmt, args);
322 vsnprintf(&str[0], length + 1, fmt, args);
332 size_t chars = std::min(length, 2 * count);
333 for (
size_t i = 2 * count - chars; i < 2 * count; i++, str++) {
334 if (*str >=
'0' && *str <=
'9') {
336 }
else if (*str >=
'A' && *str <=
'F') {
337 val = 10 + (*str -
'A');
338 }
else if (*str >=
'a' && *str <=
'f') {
339 val = 10 + (*str -
'a');
343 data[i >> 1] = !(i & 1) ? val << 4 : data[i >> 1] | val;
348 static char format_hex_char(uint8_t v) {
return v >= 10 ?
'a' + (v - 10) :
'0' + v; }
351 ret.resize(length * 2);
352 for (
size_t i = 0; i <
length; i++) {
353 ret[2 * i] = format_hex_char((data[i] & 0xF0) >> 4);
354 ret[2 * i + 1] = format_hex_char(data[i] & 0x0F);
360 static char format_hex_pretty_char(uint8_t v) {
return v >= 10 ?
'A' + (v - 10) :
'0' + v; }
365 ret.resize(3 * length - 1);
366 for (
size_t i = 0; i <
length; i++) {
367 ret[3 * i] = format_hex_pretty_char((data[i] & 0xF0) >> 4);
368 ret[3 * i + 1] = format_hex_pretty_char(data[i] & 0x0F);
370 ret[3 * i + 2] =
'.';
373 return ret +
" (" +
to_string(length) +
")";
382 ret.resize(5 * length - 1);
383 for (
size_t i = 0; i <
length; i++) {
384 ret[5 * i] = format_hex_pretty_char((data[i] & 0xF000) >> 12);
385 ret[5 * i + 1] = format_hex_pretty_char((data[i] & 0x0F00) >> 8);
386 ret[5 * i + 2] = format_hex_pretty_char((data[i] & 0x00F0) >> 4);
387 ret[5 * i + 3] = format_hex_pretty_char(data[i] & 0x000F);
389 ret[5 * i + 2] =
'.';
392 return ret +
" (" +
to_string(length) +
")";
398 if (on ==
nullptr && strcasecmp(str,
"on") == 0)
400 if (on !=
nullptr && strcasecmp(str, on) == 0)
402 if (off ==
nullptr && strcasecmp(str,
"off") == 0)
404 if (off !=
nullptr && strcasecmp(str, off) == 0)
406 if (strcasecmp(str,
"toggle") == 0)
413 if (accuracy_decimals < 0) {
414 auto multiplier = powf(10.0f, accuracy_decimals);
415 value = roundf(value * multiplier) / multiplier;
416 accuracy_decimals = 0;
419 snprintf(tmp,
sizeof(tmp),
"%.*f", accuracy_decimals, value);
420 return std::string(tmp);
426 snprintf(buf,
sizeof buf,
"%.5g", step);
428 std::string str{buf};
429 size_t dot_pos = str.find(
'.');
430 if (dot_pos == std::string::npos)
433 return str.length() - dot_pos - 1;
436 static const std::string BASE64_CHARS =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" 437 "abcdefghijklmnopqrstuvwxyz" 440 static inline bool is_base64(
char c) {
return (isalnum(c) || (c ==
'+') || (c ==
'/')); }
448 char char_array_3[3];
449 char char_array_4[4];
452 char_array_3[i++] = *(buf++);
454 char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
455 char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
456 char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
457 char_array_4[3] = char_array_3[2] & 0x3f;
459 for (i = 0; (i < 4); i++)
460 ret += BASE64_CHARS[char_array_4[i]];
466 for (j = i; j < 3; j++)
467 char_array_3[j] =
'\0';
469 char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
470 char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
471 char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
472 char_array_4[3] = char_array_3[2] & 0x3f;
474 for (j = 0; (j < i + 1); j++)
475 ret += BASE64_CHARS[char_array_4[j]];
484 size_t base64_decode(
const std::string &encoded_string, uint8_t *buf,
size_t buf_len) {
485 std::vector<uint8_t> decoded =
base64_decode(encoded_string);
486 if (decoded.size() > buf_len) {
487 ESP_LOGW(TAG,
"Base64 decode: buffer too small, truncating");
488 decoded.resize(buf_len);
490 memcpy(buf, decoded.data(), decoded.size());
491 return decoded.size();
495 int in_len = encoded_string.size();
499 uint8_t char_array_4[4], char_array_3[3];
500 std::vector<uint8_t> ret;
502 while (in_len-- && (encoded_string[in] !=
'=') && is_base64(encoded_string[in])) {
503 char_array_4[i++] = encoded_string[in];
506 for (i = 0; i < 4; i++)
507 char_array_4[i] = BASE64_CHARS.find(char_array_4[i]);
509 char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
510 char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
511 char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
513 for (i = 0; (i < 3); i++)
514 ret.push_back(char_array_3[i]);
520 for (j = i; j < 4; j++)
523 for (j = 0; j < 4; j++)
524 char_array_4[j] = BASE64_CHARS.find(char_array_4[j]);
526 char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
527 char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
528 char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
530 for (j = 0; (j < i - 1); j++)
531 ret.push_back(char_array_3[j]);
545 return powf(value, gamma);
553 return powf(value, 1 / gamma);
556 void rgb_to_hsv(
float red,
float green,
float blue,
int &hue,
float &saturation,
float &value) {
557 float max_color_value = std::max(std::max(red, green), blue);
558 float min_color_value = std::min(std::min(red, green), blue);
559 float delta = max_color_value - min_color_value;
563 }
else if (max_color_value == red) {
564 hue = int(fmod(((60 * ((green - blue) / delta)) + 360), 360));
565 }
else if (max_color_value == green) {
566 hue = int(fmod(((60 * ((blue - red) / delta)) + 120), 360));
567 }
else if (max_color_value == blue) {
568 hue = int(fmod(((60 * ((red - green) / delta)) + 240), 360));
571 if (max_color_value == 0) {
574 saturation = delta / max_color_value;
577 value = max_color_value;
579 void hsv_to_rgb(
int hue,
float saturation,
float value,
float &red,
float &green,
float &blue) {
580 float chroma = value * saturation;
581 float hue_prime = fmod(hue / 60.0, 6);
582 float intermediate = chroma * (1 - fabs(fmod(hue_prime, 2) - 1));
583 float delta = value - chroma;
585 if (0 <= hue_prime && hue_prime < 1) {
587 green = intermediate;
589 }
else if (1 <= hue_prime && hue_prime < 2) {
593 }
else if (2 <= hue_prime && hue_prime < 3) {
597 }
else if (3 <= hue_prime && hue_prime < 4) {
599 green = intermediate;
601 }
else if (4 <= hue_prime && hue_prime < 5) {
605 }
else if (5 <= hue_prime && hue_prime < 6) {
621 #if defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_HOST) 627 #elif defined(USE_ESP32) || defined(USE_LIBRETINY) 629 void Mutex::lock() { xSemaphoreTake(this->handle_, portMAX_DELAY); }
630 bool Mutex::try_lock() {
return xSemaphoreTake(this->handle_, 0) == pdTRUE; }
634 #if defined(USE_ESP8266) 637 #elif defined(USE_ESP32) || defined(USE_LIBRETINY) 642 #elif defined(USE_RP2040) 652 this->started_ =
true;
658 this->started_ =
false;
663 #if defined(USE_HOST) 664 static const uint8_t esphome_host_mac_address[6] = USE_ESPHOME_HOST_MAC_ADDRESS;
665 memcpy(mac, esphome_host_mac_address,
sizeof(esphome_host_mac_address));
666 #elif defined(USE_ESP32) 667 #if defined(CONFIG_SOC_IEEE802154_SUPPORTED) || defined(USE_ESP32_IGNORE_EFUSE_MAC_CRC) 674 esp_efuse_read_field_blob(ESP_EFUSE_MAC_FACTORY, mac, 48);
676 esp_efuse_mac_get_default(mac);
678 #elif defined(USE_ESP8266) 679 wifi_get_macaddr(STATION_IF, mac);
680 #elif defined(USE_RP2040) && defined(USE_WIFI) 681 WiFi.macAddress(mac);
682 #elif defined(USE_LIBRETINY) 683 WiFi.macAddress(mac);
691 return str_snprintf(
"%02x%02x%02x%02x%02x%02x", 12, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
696 return str_snprintf(
"%02X:%02X:%02X:%02X:%02X:%02X", 17, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
703 uint32_t start =
micros();
705 const uint32_t lag = 5000;
709 delay((us - lag) / 1000UL);
710 while (
micros() - start < us - lag)
713 while (
micros() - start < us)
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)...
std::string str_snake_case(const std::string &str)
Convert the string to snake case (lowercase with underscores).
std::string str_truncate(const std::string &str, size_t length)
Truncate a string to a specific length.
uint16_t crc16be(const uint8_t *data, uint16_t len, uint16_t crc, uint16_t poly, bool refin, bool refout)
std::string value_accuracy_to_string(float value, int8_t accuracy_decimals)
Create a string from a value and an accuracy in decimals.
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.
static bool is_high_frequency()
Check whether the loop is running continuously.
std::string str_upper_case(const std::string &str)
Convert the string to upper case.
std::string format_hex(const uint8_t *data, size_t length)
Format the byte array data of length len in lowercased hex.
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.
uint32_t random_uint32()
Return a random 32-bit unsigned integer.
std::string str_until(const char *str, char ch)
Extract the part of the string until either the first occurrence of the specified character...
size_t base64_decode(const std::string &encoded_string, uint8_t *buf, size_t buf_len)
std::string str_ctype_transform(const std::string &str)
float lerp(float completion, float start, float end)
Linearly interpolate between start and end by completion (between 0 and 1).
void delay_microseconds_safe(uint32_t us)
Delay for the given amount of microseconds, possibly yielding to other processes during the wait...
uint32_t IRAM_ATTR HOT micros()
bool random_bytes(uint8_t *data, size_t len)
Generate len number of random bytes.
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.
ParseOnOffState parse_on_off(const char *str, const char *on, const char *off)
Parse a string that contains either on, off or toggle.
ParseOnOffState
Return values for parse_on_off().
float gamma_correct(float value, float gamma)
Applies gamma correction of gamma to value.
bool str_startswith(const std::string &str, const std::string &start)
Check whether a string starts with a value.
std::string base64_encode(const std::vector< uint8_t > &buf)
void start()
Start running the loop continuously.
uint8_t crc8(const uint8_t *data, uint8_t len)
Calculate a CRC-8 checksum of data with size len.
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)...
std::string str_lower_case(const std::string &str)
Convert the string to lower case.
std::string str_sprintf(const char *fmt,...)
std::string get_mac_address()
Get the device MAC address as a string, in lowercase hex notation.
bool str_endswith(const std::string &str, const std::string &end)
Check whether a string ends with a value.
void stop()
Stop running the loop continuously.
void set_mac_address(uint8_t *mac)
Set the MAC address to use from the provided byte array (6 bytes).
int8_t step_to_accuracy_decimals(float step)
Derive accuracy in decimals from an increment step.
std::string str_sanitize(const std::string &str)
Sanitizes the input string by removing all characters but alphanumerics, dashes and underscores...
std::string to_string(int value)
uint32_t fnv1_hash(const std::string &str)
Calculate a FNV-1 hash of str.
Implementation of SPI Controller mode.
std::string get_mac_address_pretty()
Get the device MAC address as a string, in colon-separated uppercase hex notation.
static uint8_t num_requests
std::string str_snprintf(const char *fmt, size_t len,...)
float random_float()
Return a random float between 0 and 1.
bool str_equals_case_insensitive(const std::string &a, const std::string &b)
Compare strings for equality in case-insensitive manner.
void IRAM_ATTR HOT delay(uint32_t ms)
void get_mac_address_raw(uint8_t *mac)
Get the device MAC address as raw bytes, written into the provided byte array (6 bytes).
float gamma_uncorrect(float value, float gamma)
Reverts gamma correction of gamma to value.