utils.h

Go to the documentation of this file.

 
#ifndef UTILS_H
#define UTILS_H
 
#include <cassert>
#include <cmath>
#include <cstdint>
#include <limits>
 
#include "constants.h"
 
namespace lampda {
 
#define SQR(x)    ((x) * (x))               
#define POW2(x)   SQR(x)                    
#define POW3(x)   ((x) * (x) * (x))         
#define POW4(x)   (POW2(x) * POW2(x))       
#define POW7(x)   (POW3(x) * POW3(x) * (x)) 
#define FADE16(x) scale16(x, x)             
#define FADE8(x)  scale8(x, x)              
 
#ifndef Arduino_h
 
template<typename N> static constexpr N min(const N a, const N b)
{
#ifdef LMBD_CPP17
  assert(not std::isnan(a) && "invalid param a");
  assert(not std::isnan(b) && "invalid param b");
#endif
  return a < b ? a : b;
}
template<typename N> static constexpr N max(const N a, const N b)
{
#ifdef LMBD_CPP17
  assert(not std::isnan(a) && "invalid param a");
  assert(not std::isnan(b) && "invalid param b");
#endif
  return a > b ? a : b;
}
template<typename N> static constexpr N abs(const N a) { return std::abs(N(a)); }
 
#endif
 
template<typename T> static constexpr T lmpd_constrain(const T& a, const T& mini, const T& maxi)
{
#ifdef LMBD_CPP17
  assert(static_cast<float>(mini) <= static_cast<float>(maxi) && "invalid parameters");
#endif
  // prevent invalid values
  return std::isnan(a) ? static_cast<T>(mini) :
                         // constrain the value
                 (static_cast<float>(a) <= static_cast<float>(mini)) ? static_cast<T>(mini) :
         (static_cast<float>(a) >= static_cast<float>(maxi))         ? static_cast<T>(maxi) :
                                                                       static_cast<T>(a);
}
 
template<typename T = float>
static inline T lmpd_map(float x, const float in_min, const float in_max, const float out_min, const float out_max)
{
  using numeric_limits_T = std::numeric_limits<T>;
  assert(not(std::isnan(in_min) or std::isinf(in_min)) && "in_min invalid");
  assert(not(std::isnan(in_max) or std::isinf(in_max)) && "in_max invalid");
  assert(out_min >= numeric_limits_T::lowest() && out_min <= numeric_limits_T::max() && "out_min invalid");
  assert(not(std::isnan(out_min) or std::isinf(out_min)) && "out_min invalid");
  assert(out_max >= numeric_limits_T::lowest() && out_max <= numeric_limits_T::max() && "out_max invalid");
  assert(not(std::isnan(out_max) or std::isinf(out_max)) && "out_max invalid");
 
  if (std::isnan(x))
    return out_min;
  if (x > 0 && std::isinf(x))
    return out_max;
  if (std::isinf(x))
    return out_min;
  const float res = (out_max - out_min) * (x - in_min) / (in_max - in_min) + out_min;
  if (res > numeric_limits_T::max())
    return numeric_limits_T::max();
  if (res < numeric_limits_T::lowest())
    return numeric_limits_T::lowest();
 
  return static_cast<T>(res);
}
 
static constexpr inline float to_radians(float degrees)
{
#ifdef LMBD_CPP17
  assert(not(std::isnan(degrees) or std::isinf(degrees)) && "invalid value");
#endif
  return degrees * M_PI / 180.f;
}
 
static constexpr inline float wrap_angle(const float angle_rad)
{
#ifdef LMBD_CPP17
  if (angle_rad >= 0 and angle_rad < c_TWO_PI)
    return angle_rad;
#endif
  return angle_rad - c_TWO_PI * floor(angle_rad / c_TWO_PI);
}
 
union COLOR
{
  uint32_t color;
 
  struct
  {
    uint8_t blue;
    uint8_t green;
    uint8_t red;
    uint8_t white;
  };
};
 
namespace utils {
 
uint32_t get_random_complementary_color(const uint32_t color, const float tolerance);
 
uint32_t get_gradient(const uint32_t colorStart, const uint32_t colorEnd, const float level);
 
COLOR color_fade(COLOR c1, uint8_t amount, bool video = false);
COLOR color_add(COLOR c1, COLOR c2, bool fast = false);
 
uint32_t hue_to_rgb_sinus(const uint16_t angle);
 
template<typename T> static constexpr uint32_t hash(const T s, const uint16_t maxSize = 14, const uint16_t off = 0)
{
#ifdef LMBD_CPP17
  uint32_t hashAcc = 5381;
  for (uint16_t I = 0; I < maxSize; ++I)
  {
    if (s[I + off] == '\0')
    {
      return hashAcc;
    }
 
    hashAcc = ((hashAcc << 5) + hashAcc) ^ s[I + off];
  }
  return hashAcc;
#else
  return !s[off] ? 5381 : (hash(s, maxSize, off + 1) * 33) ^ s[off];
#endif
}
 
template<int16_t N> static constexpr uint32_t hash(const char (&s)[N])
{
  static_assert((N - 1 <= 14) && "Use hash(s, maxSize) to hash strings longer than 14 bytes!");
  return hash(s, 14);
}
 
// Convert a read on an analog pin to a voltage value
constexpr double analogReadToVoltage(const uint16_t analogVal)
{
  return analogVal * internalReferenceVoltage / (float)ADC_MAX_VALUE;
}
constexpr uint16_t voltageToAnalogRead(const float voltage)
{
  return lmpd_constrain<uint16_t>(voltage, 0, internalReferenceVoltage) * ADC_MAX_VALUE / internalReferenceVoltage;
}
 
} // namespace utils
} // namespace lampda
 
#endif