Common.h

Go to the documentation of this file.

/*
 * This is a part of the Uniot project.
 * Copyright (C) 2016-2024 Uniot <contact@uniot.io>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <memory>
#include <utility>


#define UNIOT_SEMVER_TO_INT(major, minor, patch) ((major * 10000) + (minor * 100) + patch)

#define UNIOT_CORE_VERSION UNIOT_SEMVER_TO_INT(0, 9, 0)

#ifndef UNIOT_MQTT_HOST
#define UNIOT_MQTT_HOST "mqtt.uniot.io"
#endif

#ifndef UNIOT_MQTT_PORT
#define UNIOT_MQTT_PORT 1883
#endif

#ifndef UNIOT_WIFI_AP_PREFIX
#define UNIOT_WIFI_AP_PREFIX "UNIOT"
#endif

#ifndef UNIOT_WIFI_AP_PASSWORD
#define UNIOT_WIFI_AP_PASSWORD ""
#endif

#ifndef UNIOT_WIFI_REBOOT_RESET_COUNT
#define UNIOT_WIFI_REBOOT_RESET_COUNT 5
#endif

#ifndef UNIOT_WIFI_REBOOT_WINDOW_MS
#define UNIOT_WIFI_REBOOT_WINDOW_MS 10000
#endif

#ifndef UNIOT_LISP_HEAP
// Not split by ESP32 variant: object sizes are identical on both parts.
#if defined(ESP32)
#define UNIOT_LISP_HEAP 24576
#elif defined(ESP8266)
#define UNIOT_LISP_HEAP 12288
#else
#define UNIOT_LISP_HEAP 8192
#endif
#endif

#ifndef UNIOT_LISP_MAX_EVAL_STACK
#if defined(ESP8266)
#define UNIOT_LISP_MAX_EVAL_STACK 1280
#elif defined(CONFIG_IDF_TARGET_ESP32C3)
#define UNIOT_LISP_MAX_EVAL_STACK 3072
#elif defined(ESP32)
#define UNIOT_LISP_MAX_EVAL_STACK 3072
#else
// An unknown platform is assumed to be a small MCU, not a host: too little heap raises a
// clean error, too much stack resets the device, so the fallbacks lean small. A host build
// with room to spare should set both explicitly rather than inherit these.
#define UNIOT_LISP_MAX_EVAL_STACK 2048
#endif
#endif

#ifndef UNIOT_WIFI_NO_SLEEP
#define UNIOT_WIFI_NO_SLEEP 0
#endif

template <int a, int b, int c, int d>
struct FourCC {
  static const uint32_t Value = (((((d << 8) | c) << 8) | b) << 8) | a;
};

template <typename... Args>
inline void UNUSED(Args &&...args) {
  (void)(sizeof...(args));
}

inline uint32_t CRC32(const void *data, size_t length, uint32_t crc = 0) {
  const uint8_t *ldata = (const uint8_t *)data;
 
  crc = ~crc;
  while (length--) {
    crc ^= *ldata++;
    for (uint8_t k = 0; k < 8; k++)
      crc = crc & 1 ? (crc >> 1) ^ 0x82f63b78 : crc >> 1;  // CRC-32C (iSCSI) polynomial in reversed bit order.
  }
  return ~crc;
}

#define COUNT_OF(arr) (sizeof(arr) / sizeof(arr[0]))

#define ARRAY_ELEMENT_SAFE(arr, index) ((arr)[(((index) < COUNT_OF(arr)) ? (index) : (COUNT_OF(arr) - 1))])

#define FOURCC(name) FourCC<ARRAY_ELEMENT_SAFE(#name, 0), ARRAY_ELEMENT_SAFE(#name, 1), ARRAY_ELEMENT_SAFE(#name, 2), ARRAY_ELEMENT_SAFE(#name, 3)>::Value

#define ALIAS_IMPLICIT_FUNCTION(high, low)                                         \
  template <typename... Args>                                                      \
  inline auto high(Args &&...args) -> decltype(low(std::forward<Args>(args)...)) { \
    return low(std::forward<Args>(args)...);                                       \
  }

#define ALIAS_EXPLICIT_FUNCTION(high, low)                                            \
  template <typename T, typename... Args>                                             \
  inline auto high(Args &&...args) -> decltype(low<T>(std::forward<Args>(args)...)) { \
    return low<T>(std::forward<Args>(args)...);                                       \
  }
 
namespace uniot {

template <typename T>
using UniquePointer = std::unique_ptr<T>;

template <typename T>
using SharedPointer = std::shared_ptr<T>;

template <typename T_First, typename T_Second>
using Pair = std::pair<T_First, T_Second>;

ALIAS_EXPLICIT_FUNCTION(MakeShared, std::make_shared)
 

ALIAS_EXPLICIT_FUNCTION(MakeUnique, std::make_unique)

ALIAS_IMPLICIT_FUNCTION(MakePair, std::make_pair)

}  // namespace uniot