ksConstants.h

/*
 *  Copyright (c) 2021-2023, Krzysztof Strehlau
 *
 *  This file is a part of the ksIotFramework library.
 *  All licensing information can be found inside LICENSE.md file.
 *
 *  https://github.com/cziter15/ksIotFrameworkLib/blob/master/LICENSE
 */
 
#pragma once
 
#include <stdint.h>
#include <limits>
#include <string>
#include <charconv>
#include "stdlib_noniso.h"
 
#include "Arduino.h"
 
#define KSF_ONE_SEC_MS 1000UL
 
#define KSF_SEC_TO_MS(seconds) (seconds*1000UL)
 
#ifndef KSF_MQTT_RECONNECT_DELAY_MS
#define KSF_MQTT_RECONNECT_DELAY_MS 10000UL
#endif
 
#ifndef KSF_MQTT_TIMEOUT_MS
#define KSF_MQTT_TIMEOUT_MS 4000UL
#endif
 
#ifndef KSF_WIFI_TIMEOUT_MS
#define KSF_WIFI_TIMEOUT_MS 120000UL
#endif
 
#ifndef KSF_WIFI_RECONNECT_TIME_MS
#define KSF_WIFI_RECONNECT_TIME_MS 5000UL
#endif
 
#ifndef KSF_WATCHDOG_TIMEOUT_SECS
#define KSF_WATCHDOG_TIMEOUT_SECS 10UL
#endif
 
#define KSF_FRAMEWORK_INIT() ksf::initializeFramework();
 
namespace ksf
{
    namespace EOTAType
    {
        enum Type
        {
            NO_OTA,
            OTA_GENERIC,
            OTA_PORTAL,
        };
    }
 
    extern const char* getNvsDirectory();
 
    extern void initializeFramework();
 
    extern bool removeDirectory(const char* path);
 
    extern bool eraseConfigData();
 
    extern void updateDeviceUptime();
 
    extern uint64_t millis64();
 
    extern std::string to_string(double value, const int base);
 
    extern std::string to_string(float value, const int base);
 
    template <typename _Type>
    inline std::string to_string(const _Type& input)
    {
        return std::to_string(input);
    }
 
    inline std::string to_hex(int value)
    {
        if (value == 0)
            return {"0"};
 
        char buffer[8];
        unsigned int uvalue{static_cast<unsigned int>(value)}, pos{8};
        
        while (uvalue != 0) 
        {
            unsigned int nibble{uvalue & 0xf};
            buffer[--pos] = (nibble < 10) ? ('0' + nibble) : ('a' + (nibble - 10));
            uvalue >>= 4;
        }
 
        return std::string(buffer + pos, 8 - pos);
    }
 
    template <typename _In, typename _Out>
    bool from_chars(const _In& input, _Out& out)
    {
        const auto& result{std::from_chars(input.data(), input.data() + input.size(), out)};
        return result.ec == std::errc();
    }
 
    std::string getDeviceUuidHex();
 
    extern EOTAType::Type getOtaBootType();
 
    extern void saveOtaBootIndicator(EOTAType::Type type = EOTAType::OTA_GENERIC);
 
    template<class _Type1, class _Type2>
    inline bool starts_with(const _Type1& input, const _Type2& match)
    {
        return input.size() >= match.size() && std::equal(match.begin(), match.end(), input.begin());
    }
 
    extern const std::string getResetReason();
 
    extern const std::string getUptimeFromSeconds(uint32_t seconds);
 
    extern const std::string getUptimeString();
 
    extern void loadCredentials(std::string& ssid, std::string& password);
 
    extern void saveCredentials(std::string ssid, std::string password);
}