SimWheelTypes.hpp

Go to the documentation of this file.

 
#pragma once
 
//-------------------------------------------------------------------
// Global macros
//-------------------------------------------------------------------
 
#if CD_CI
 
 
#define GPIO_IS_VALID_GPIO(pin) (pin < 100)
#define TEST_NO_OUTPUT_GPIO 80
#define GPIO_IS_VALID_OUTPUT_GPIO(pin) (pin < TEST_NO_OUTPUT_GPIO)
#define TEST_RTC_GPIO1 40
#define TEST_RTC_GPIO2 49
#define GPIO_IS_VALID_RTC_GPIO(pin) ((pin >= TEST_RTC_GPIO1) && (pin <= TEST_RTC_GPIO2))
#define TEST_RESERVED_GPIO 50
 
 
#else
 
#define GPIO_IS_VALID_RTC_GPIO(pin) rtc_gpio_is_valid_gpio(static_cast<gpio_num_t>(pin))
 
#endif
 
//-------------------------------------------------------------------
// Imports
//-------------------------------------------------------------------
 
#include <cstdint>
#include <string>
#include <stdexcept>
#include <set>
#include <vector>
#include <initializer_list>
#include <map>
#include <algorithm>
 
#if !CD_CI
#include "driver/rtc_io.h"   // For rtc_gpio_is_valid_gpio()
#include "hal/gpio_types.h"  // For gpio_num_t
#include "driver/gpio.h"     // For GPIO_IS_VALID... and others
#include "esp32-hal-psram.h" // For psramFound()
#endif
 
//-------------------------------------------------------------------
// Exceptions
//-------------------------------------------------------------------
 
class invalid_input_number : public std::runtime_error
{
public:
    invalid_input_number(uint8_t value)
        : std::runtime_error(
              "The input number " +
              std::to_string(value) +
              " is out of range [0,127]") {}
    invalid_input_number()
        : std::runtime_error(
              "Trying to use an unspecified input number.") {}
 
    virtual ~invalid_input_number() noexcept {}
};
 
class gpio_error : public std::runtime_error
{
public:
    gpio_error(uint8_t value, const std::string &reason)
        : std::runtime_error(
              "Invalid GPIO number " +
              std::to_string(value) +
              ". Reason: " +
              reason) {}
};
 
class empty_input_number_set : public std::runtime_error
{
public:
    empty_input_number_set(const std::string &hardware)
        : std::runtime_error(
              "No input numbers were given to: " + hardware) {}
 
    virtual ~empty_input_number_set() noexcept {}
};
 
class unknown_input_number : public std::runtime_error
{
public:
    unknown_input_number(const std::string &usage)
        : std::runtime_error(
              "There is an input number not assigned to a hardware input. Usage: " +
              usage) {}
 
    virtual ~unknown_input_number() noexcept {}
};
 
//-------------------------------------------------------------------
// Utility functions
//-------------------------------------------------------------------
 
inline int map_value(int x, int in_min, int in_max, int out_min, int out_max)
{
    const int run = in_max - in_min;
    if (run == 0)
        return 0;
    const int rise = out_max - out_min;
    const int delta = x - in_min;
    return (delta * rise) / run + out_min;
}
 
//-------------------------------------------------------------------
// Unspecified values
//-------------------------------------------------------------------
 
enum class UNSPECIFIED
{
    VALUE = 0xFF
};
 
//-------------------------------------------------------------------
// Input Bitmap
//-------------------------------------------------------------------
 
// Note: fucking Arduino macro
#undef bit
 
struct uint128_t
{
    uint64_t low{0ULL};
    uint64_t high{0ULL};
 
    explicit constexpr operator bool()
    {
        return low || high;
    }
 
    constexpr bool bit(uint8_t n) const noexcept
    {
        if (n < 64)
            return (1ULL << n) & low;
        else if (n < 128)
            return (1ULL << (n - 64) & high);
        else
            return false;
    }
 
    constexpr void set_bit(uint8_t n, bool value = true) noexcept
    {
        if (n < 64)
        {
            if (value)
                low |= (1ULL << n);
            else
                low &= ~(1ULL << n);
        }
        else if (n < 128)
        {
            n -= 64;
            if (value)
                high |= (1ULL << n);
            else
                high &= ~(1ULL << n);
        }
    }
 
    constexpr uint128_t &operator|=(const uint128_t &rhs) noexcept
    {
        low |= rhs.low;
        high |= rhs.high;
        return *this;
    }
 
    constexpr uint128_t &operator&=(const uint128_t &rhs) noexcept
    {
        low &= rhs.low;
        high &= rhs.high;
        return *this;
    }
 
    constexpr uint128_t &operator^=(const uint128_t &rhs) noexcept
    {
        low ^= rhs.low;
        high ^= rhs.high;
        return *this;
    }
 
    static constexpr uint128_t bitmap(uint8_t n) noexcept
    {
        if (n < 64)
            return {
                .low = (1ULL << n),
                .high = 0ULL,
            };
        else if (n < 128)
            return {
                .low = 0ULL,
                .high = (1ULL << (n - 64)),
            };
        else
            return {};
    }
 
    static constexpr uint128_t neg() noexcept
    {
        return {
            .low = ~0ULL,
            .high = ~0ULL,
        };
    }
};
 
static_assert(
    sizeof(uint128_t) == 16,
    "Wrong size in the uint128_t data type. Check memory alignment.");
 
inline constexpr uint128_t operator<<(
    const uint128_t &source,
    ::std::size_t n) noexcept
{
    if (n == 0)
    {
        return source;
    }
    else
    {
        uint128_t result;
        if (n < 64)
        {
            result.low = (source.low << n);
            result.high = (source.high << n) | (source.low >> (64 - n));
        }
        else
        {
            result.low = 0ULL;
            result.high = source.low << (n - 64);
        }
        return result;
    }
}
 
inline constexpr uint128_t operator>>(
    const uint128_t &source,
    ::std::size_t n) noexcept
{
    if (n == 0)
    {
        return source;
    }
    else
    {
        uint128_t result;
        if (n < 64)
        {
            result.low = (source.low >> n) | (source.high << (64 - n));
            result.high = (source.high >> n);
        }
        else
        {
            result.high = 0ULL;
            result.low = source.high >> (n - 64);
        }
        return result;
    }
}
 
inline constexpr uint128_t operator|(uint128_t a, uint128_t b) noexcept
{
    return {
        .low = a.low | b.low,
        .high = a.high | b.high,
    };
}
 
inline constexpr uint128_t operator&(uint128_t a, uint128_t b) noexcept
{
    return {
        .low = a.low & b.low,
        .high = a.high & b.high,
    };
}
 
inline constexpr uint128_t operator^(uint128_t a, uint128_t b) noexcept
{
    return {
        .low = a.low ^ b.low,
        .high = a.high ^ b.high,
    };
}
 
inline constexpr uint128_t operator~(uint128_t a) noexcept
{
    return {
        .low = ~(a.low),
        .high = ~(a.high),
    };
}
 
inline constexpr bool operator==(uint128_t a, uint128_t b) noexcept
{
    return (a.low == b.low) && (a.high == b.high);
}
 
inline constexpr bool operator!=(uint128_t a, uint128_t b)
{
    return (a.low != b.low) || (a.high != b.high);
}
 
//-------------------------------------------------------------------
// Input numbers
//-------------------------------------------------------------------
 
struct InputNumber
{
public:
    constexpr InputNumber() noexcept
    {
        _value = 0xFF;
    }
 
    constexpr InputNumber(uint8_t value)
    {
        if (value >= 128)
            throw invalid_input_number(value);
        _value = value;
    }
 
    constexpr InputNumber(UNSPECIFIED value) noexcept
    {
        _value = 0xFF;
    }
 
    constexpr InputNumber(const InputNumber &number) = default;
 
    constexpr InputNumber(InputNumber &&number) = default;
 
    constexpr InputNumber &operator=(const InputNumber &number) = default;
 
    constexpr InputNumber &operator=(InputNumber &&number) = default;
 
    explicit constexpr operator uint128_t() const
    {
        return uint128_t::bitmap(_value);
    }
 
    constexpr operator uint8_t() const
    {
        return _value;
    }
 
    bool constexpr operator==(const UNSPECIFIED value) const
    {
        return (_value > 127);
    }
 
    bool constexpr operator!=(const UNSPECIFIED value) const noexcept
    {
        return (_value < 128);
    }
 
 
    inline constexpr bool operator==(const InputNumber value) const noexcept
    {
        return (_value == value._value);
    }
    inline constexpr bool operator!=(const InputNumber value) const noexcept
    {
        return (_value != value._value);
    }
    inline constexpr bool operator<(const InputNumber value) const noexcept
    {
        return (_value < value._value);
    }
    inline constexpr bool operator<=(const InputNumber value) const noexcept
    {
        return (_value <= value._value);
    }
    inline constexpr bool operator>(const InputNumber value) const noexcept
    {
        return (_value > value._value);
    }
    inline constexpr bool operator>=(const InputNumber value) const noexcept
    {
        return (_value >= value._value);
    }
 
 
    void book() const
    {
        _registered.set_bit(_value, true);
    }
 
    void unbook() const
    {
        _registered.set_bit(_value, false);
    }
 
    static void bookAll()
    {
        _registered = uint128_t::neg();
    }
 
    static bool booked(InputNumber inputNumber)
    {
        return _registered.bit(inputNumber._value);
    }
 
    static bool booked(uint8_t inputNumber)
    {
        return _registered.bit(inputNumber);
    }
 
    static uint128_t booked() { return _registered; }
 
    static void unbook(uint8_t inputNumber)
    {
        _registered.set_bit(inputNumber, false);
    }
 
    static void book(uint8_t inputNumber)
    {
        _registered.set_bit(inputNumber, true);
    }
 
#if CD_CI
    static void clearBook()
    {
        _registered.low = 0ULL;
        _registered.high = 0ULL;
    };
#endif
 
private:
    uint8_t _value;
    inline static uint128_t _registered{};
};
 
struct InputNumberCombination : public uint128_t
{
    constexpr InputNumberCombination() : uint128_t{} {};
 
    constexpr InputNumberCombination(
        std::initializer_list<InputNumber> items) noexcept : uint128_t{}
    {
        for (auto n : items)
            set_bit(n);
    }
 
    constexpr InputNumberCombination(const uint128_t &from)
        : uint128_t{from} {};
 
    constexpr InputNumberCombination(uint128_t &&from)
        : uint128_t{from} {};
 
    constexpr uint8_t size() const noexcept
    {
        uint8_t result = 0;
        for (uint8_t i = 0; i < 128; i++)
            if (bit(i))
                result++;
        return result;
    }
 
    constexpr InputNumberCombination(
        const InputNumberCombination &) noexcept = default;
 
    constexpr InputNumberCombination(
        InputNumberCombination &&) noexcept = default;
 
    constexpr InputNumberCombination &operator=(
        const InputNumberCombination &) noexcept = default;
 
    constexpr InputNumberCombination &operator=(
        InputNumberCombination &&) = default;
 
    // NEEDED???
    // /**
    //  * @brief Typecast to vector
    //  *
    //  * @return std::vector<uint8_t> Vector of input numbers
    //  */
    // operator std::vector<uint8_t>()
    // {
    //     std::vector<uint8_t> result = {};
    //     for (uint8_t n = 0; n < 128; n++)
    //     {
    //         if (bit(n))
    //             result.push_back(n);
    //     }
    //     return result;
    // }
};
 
// Well-known input numbers for PC game controllers
#define JOY_A 0                 
#define JOY_B 1                 
#define JOY_X 2                 
#define JOY_Y 3                 
#define JOY_LB 4                
#define JOY_RB 5                
#define JOY_LSHIFT_PADDLE 4     
#define JOY_RSHIFT_PADDLE 5     
#define JOY_BACK 6              
#define JOY_START 7             
#define JOY_LTHUMBSTICK_CLICK 8 
#define JOY_RTHUMBSTICK_CLICK 9 
 
//-------------------------------------------------------------------
// GPIO PINS
//-------------------------------------------------------------------
// Implemented in GPIO.cpp
//-------------------------------------------------------------------
 
struct GPIO
{
public:
    GPIO(int pin)
    {
        if (pin < 0)
        {
            // Unspecified
            _pin = -1;
            return;
        }
 
        if (!GPIO_IS_VALID_GPIO(pin))
            throw gpio_error(pin, "Does not exist");
        bool reserved = false;
#if defined(CONFIG_IDF_TARGET_ESP32)
        reserved = (pin >= GPIO_NUM_6) && (pin <= GPIO_NUM_11); // Flash
        reserved = reserved ||
                   ((pin >= GPIO_NUM_16) && (pin <= GPIO_NUM_17) && psramFound()); // PSRAM
 
        // reserved = reserved || (pin == GPIO_NUM_1) || (pin == GPIO_NUM_3);         // Serial port
#elif defined(CONFIG_IDF_TARGET_ESP32S2)
// Not sure:
//        reserved = (pin >= GPIO_NUM_22) && (pin <= GPIO_NUM_32) && (pin != GPIO_NUM_26);
#elif defined(CONFIG_IDF_TARGET_ESP32S3)
        reserved = ((pin >= GPIO_NUM_26) && (pin <= GPIO_NUM_32)); // Flash
        reserved = reserved ||
                   ((pin >= GPIO_NUM_35) && (pin <= GPIO_NUM_37) && psramFound()); // PSRAM
 
        // reserved = reserved || (pin == GPIO_NUM_43) || (pin == GPIO_NUM_44);       // Serial port
#elif defined(CONFIG_IDF_TARGET_ESP32C3)
        reserved = (pin >= GPIO_NUM_11) && (pin <= GPIO_NUM_17);
 
        // reserved = reserved || (pin == GPIO_NUM_20) || (pin == GPIO_NUM_21); // Serial port
#elif CD_CI
        reserved = (pin == TEST_RESERVED_GPIO);
#endif
        if (reserved)
            throw gpio_error(pin, "Reserved for SPI FLASH, PSRAM or otherwise NOT USABLE");
        _pin = pin;
    }
 
    GPIO() { _pin = -1; }
 
    GPIO(UNSPECIFIED value) : GPIO() {}
 
    operator int() const { return _pin; }
 
    GPIO(const GPIO &instance) { _pin = instance._pin; }
 
    inline bool operator==(const UNSPECIFIED value) const { return _pin < 0; }
 
    inline bool operator!=(const UNSPECIFIED value) const { return _pin >= 0; }
 
 
    inline bool operator!=(const GPIO value) const { return (_pin != value._pin); }
    inline bool operator==(const GPIO value) const { return (_pin == value._pin); }
    inline bool operator<(const GPIO value) const { return (_pin < value._pin); }
 
 
    void reserve() const
    {
        abortIfUnspecified();
        if (reservedPins.find(_pin) != reservedPins.end())
            throw gpio_error(_pin, "Already in use");
        else
            reservedPins.insert(_pin);
    }
 
    void grant() const
    {
        abortIfUnspecified();
        reservedPins.insert(_pin);
    }
 
    void abortIfUnspecified() const
    {
        if (_pin < 0)
            throw gpio_error(_pin, "Is unspecified but required");
    }
 
#if CD_CI
    static void clearReservations()
    {
        reservedPins.clear();
    }
#endif
 
private:
    inline static ::std::set<int> reservedPins{};
 
protected:
    int _pin;
};
 
struct OutputGPIO : public GPIO
{
public:
    OutputGPIO(int pin) : GPIO(pin)
    {
        if ((pin >= 0) && !GPIO_IS_VALID_OUTPUT_GPIO(pin))
            throw gpio_error(pin, "Not output-capable");
    }
    OutputGPIO() : GPIO() {};
    OutputGPIO(UNSPECIFIED value) : GPIO(value) {}
};
 
struct InputGPIO : public GPIO
{
public:
    InputGPIO() : GPIO() {};
    InputGPIO(int pin) : GPIO(pin) {}
    InputGPIO(UNSPECIFIED value) : GPIO(value) {}
};
 
struct ADC_GPIO : public InputGPIO
{
public:
    ADC_GPIO() : InputGPIO() {}
 
    ADC_GPIO(int pin) : InputGPIO(pin) {}
 
    ADC_GPIO(UNSPECIFIED value) : InputGPIO(value) {}
};
 
struct RTC_GPIO : public InputGPIO
{
public:
    RTC_GPIO(int pin) : InputGPIO(pin)
    {
        if ((pin >= 0) && !GPIO_IS_VALID_RTC_GPIO(pin))
            throw gpio_error(pin, "Not RTC-capable");
    }
};
 
//-------------------------------------------------------------------
// GPIO pin collections
//-------------------------------------------------------------------
 
typedef std::set<GPIO> GPIOCollection;
typedef std::set<InputGPIO> InputGPIOCollection;
typedef std::set<OutputGPIO> OutputGPIOCollection;
 
//-------------------------------------------------------------------
// I2C
//-------------------------------------------------------------------
 
#if CONFIG_IDF_TARGET_ESP32C3
// The ESP32-C3 does not have a secondary bus
enum class I2CBus
{
    PRIMARY = 0,
    SECONDARY = 0
};
#else
enum class I2CBus
{
    PRIMARY = 0,
    SECONDARY
};
#endif
 
//-------------------------------------------------------------------
// Power latch
//-------------------------------------------------------------------
 
enum class PowerLatchMode : uint8_t
{
    POWER_OPEN_DRAIN,
    POWER_OFF_HIGH,
    POWER_OFF_LOW
};
 
//-------------------------------------------------------------------
// Connectivity
//-------------------------------------------------------------------
 
enum class Connectivity : uint8_t
{
    USB_BLE = 0,
    USB_BLE_EXCLUSIVE = 1,
    USB = 2,
    BLE = 3,
    DUMMY = 4,
    _DEFAULT = USB_BLE
};
 
//-------------------------------------------------------------------
// LED strips
//-------------------------------------------------------------------
 
enum class PixelGroup
{
    GRP_TELEMETRY = 0,
    GRP_BUTTONS,
    GRP_INDIVIDUAL
};
 
enum class PixelDriver
{
    WS2811 = 0,
    WS2812,
    WS2815,
    SK6812,
    UCS1903,
    APA106
};
 
//-------------------------------------------------------------------
// Telemetry data
//-------------------------------------------------------------------
 
typedef struct
{
    uint32_t frameID;
    struct
    {
        char gear = ' ';
        uint16_t rpm = 0;
        uint8_t rpmPercent = 0;
        uint8_t shiftLight1 = 0;
        uint8_t shiftLight2 = 0;
        bool revLimiter = false;
        bool engineStarted = false;
        uint16_t speed = 0;
    } powertrain;
    struct
    {
        bool absEngaged = false;
        bool tcEngaged = false;
        bool drsEngaged = false;
        bool pitLimiter = false;
        bool lowFuelAlert = false;
        uint8_t absLevel = 0;
        uint8_t tcLevel = 0;
        uint8_t tcCut = 0;
        uint8_t brakeBias = 0;
    } ecu;
    struct
    {
        bool blackFlag = false;
        bool blueFlag = false;
        bool checkeredFlag = false;
        bool greenFlag = false;
        bool orangeFlag = false;
        bool whiteFlag = false;
        bool yellowFlag = false;
        uint16_t remainingLaps = 0;
        uint16_t remainingMinutes = 0;
    } raceControl;
    struct
    {
        uint8_t relativeTurboPressure = 0;
        float absoluteTurboPressure = 0.0;
        uint16_t waterTemperature = 0;
        float oilPressure = 0.0;
        uint16_t oilTemperature = 0;
        uint8_t relativeRemainingFuel = 0;
        uint16_t absoluteRemainingFuel = 0;
    } gauges;
    struct
    {
        uint16_t tireTemp[4];
        float tirePressure[4];
        uint16_t brakeTemp[4];
        uint8_t wearPercentage[4];
    } wheels;
} TelemetryData;
 
//-------------------------------------------------------------------
// Pixel format
//-------------------------------------------------------------------
 
enum class PixelFormat : unsigned char
{
    RGB = 0,
    RBG,
    GRB,
    GBR,
    BRG,
    BGR
};
 
//-------------------------------------------------------------------
// Pixels
//-------------------------------------------------------------------
 
struct Pixel
{
    uint8_t blue;
    uint8_t green;
    uint8_t red;
 
    operator uint32_t() const noexcept
    {
        return (blue) | (green << 8) | (red << 16);
    }
 
    operator int() const noexcept
    {
        return (blue) | (green << 8) | (red << 16);
    }
 
    Pixel(uint32_t packedRGB) noexcept
    {
        red = packedRGB >> 16;
        green = packedRGB >> 8;
        blue = packedRGB;
    }
 
    Pixel() noexcept
    {
        red = 0;
        green = 0;
        blue = 0;
    }
 
    Pixel(const Pixel &source) = default;
 
    Pixel(Pixel &&source) = default;
 
    Pixel &operator=(uint32_t packedRGB) noexcept
    {
        red = packedRGB >> 16;
        green = packedRGB >> 8;
        blue = packedRGB;
        return *this;
    }
 
    Pixel &operator=(const Pixel &source) = default;
 
    Pixel &operator=(Pixel &&source) = default;
 
    bool operator==(uint32_t packedRGB) const noexcept
    {
        return (packedRGB == static_cast<uint32_t>(*this));
    }
 
    bool operator==(int packedRGB) const noexcept
    {
        return (packedRGB == static_cast<int>(*this));
    }
 
    bool operator==(const Pixel &other) const noexcept
    {
        return (red == other.red) &&
               (blue == other.blue) &&
               (green == other.green);
    }
 
    bool operator!=(uint32_t packedRGB) const noexcept
    {
        return (packedRGB != static_cast<uint32_t>(*this));
    }
 
    bool operator!=(int packedRGB) const noexcept
    {
        return (packedRGB != static_cast<int>(*this));
    }
 
    bool operator!=(const Pixel &other) const noexcept
    {
        return (red != other.red) ||
               (blue != other.blue) ||
               (green != other.green);
    }
 
    uint8_t byte0(PixelFormat format) const noexcept
    {
        switch (format)
        {
        case PixelFormat::BGR:
            [[fallthrough]];
        case PixelFormat::BRG:
            return blue;
        case PixelFormat::GBR:
            [[fallthrough]];
        case PixelFormat::GRB:
            return green;
        case PixelFormat::RBG:
            [[fallthrough]];
        case PixelFormat::RGB:
            return red;
        }
        return 0;
    }
 
    uint8_t byte1(PixelFormat format) const noexcept
    {
        switch (format)
        {
        case PixelFormat::RBG:
            [[fallthrough]];
        case PixelFormat::GBR:
            return blue;
        case PixelFormat::BGR:
            [[fallthrough]];
        case PixelFormat::RGB:
            return green;
        case PixelFormat::BRG:
            [[fallthrough]];
        case PixelFormat::GRB:
            return red;
        }
        return 0;
    }
 
    uint8_t byte2(PixelFormat format) const noexcept
    {
        switch (format)
        {
        case PixelFormat::GRB:
            [[fallthrough]];
        case PixelFormat::RGB:
            return blue;
        case PixelFormat::BRG:
            [[fallthrough]];
        case PixelFormat::RBG:
            return green;
        case PixelFormat::GBR:
            [[fallthrough]];
        case PixelFormat::BGR:
            return red;
        }
        return 0;
    }
}; // Pixel
 
static_assert(sizeof(Pixel) == 3);
 
//-------------------------------------------------------------------
// User interface
//-------------------------------------------------------------------
 
class AbstractUserInterface
{
protected:
    uint32_t frameTimer(
        uint32_t &timerVariable,
        uint32_t elapsedTimeMs,
        uint32_t timeLimitMs)
    {
        timerVariable += elapsedTimeMs;
        uint32_t result = timerVariable / timeLimitMs;
        timerVariable %= timeLimitMs;
        return result;
    };
 
public:
    bool requiresPowertrainTelemetry = false;
    bool requiresECUTelemetry = false;
    bool requiresRaceControlTelemetry = false;
    bool requiresGaugeTelemetry = false;
    bool requiresWheelTelemetry = false;
 
    // Non copyable
 
    AbstractUserInterface() = default;
    AbstractUserInterface(const AbstractUserInterface &) = delete;
    AbstractUserInterface &operator=(const AbstractUserInterface &) = delete;
 
    virtual ~AbstractUserInterface() {}
 
public:
    virtual uint8_t getMaxFPS() { return 0; }
 
    virtual uint16_t getStackSize() { return 0; }
 
    virtual void onStart() {};
 
    virtual void onTelemetryData(const TelemetryData *pTelemetryData) {};
 
    virtual void serveSingleFrame(uint32_t elapsedMs) {};
 
    virtual void onBitePoint(uint8_t bitePoint) {};
 
    virtual void onConnected() {};
 
    virtual void onBLEdiscovering() {};
 
    virtual void onLowBattery() {};
 
    virtual void onSaveSettings() {};
 
    virtual void onUserInput(uint8_t inputNumber) {};
 
    virtual void shutdown() {};
};
 
//-------------------------------------------------------------------
 
class PixelControlNotification : public AbstractUserInterface
{
private:
    virtual void onStart() override;
    virtual void onBitePoint(uint8_t bitePoint) override;
    virtual void onConnected() override;
    virtual void onBLEdiscovering() override;
    virtual void onLowBattery() override;
    virtual void onSaveSettings() override;
    virtual void serveSingleFrame(uint32_t elapsedMs) override {};
    virtual uint8_t getMaxFPS() override { return 0; }
    virtual void shutdown() override {};
 
protected:
    // Singleton pattern
 
    PixelControlNotification() : AbstractUserInterface() {}
 
    // For descendant classes
 
    ::std::vector<Pixel> telemetry_pixel{};
 
    ::std::vector<Pixel> backlit_button_pixel{};
 
    ::std::vector<Pixel> individual_pixel{};
 
    bool notConnectedYet = true;
 
    void show(PixelGroup group) noexcept;
 
    void show() noexcept;
 
    static void reset() noexcept;
 
    static uint8_t getPixelCount(PixelGroup group) noexcept;
 
    bool renderBatteryLevel(uint32_t barColor = 0x00ACFA70);
 
public:
    static PixelControlNotification *getInstance()
    {
        static PixelControlNotification *_instance = nullptr;
        if (!_instance)
            _instance = new PixelControlNotification();
        return _instance;
    }
 
public:
    PixelControlNotification(PixelControlNotification &other) = delete;
    void operator=(const PixelControlNotification &) = delete;
 
    virtual void pixelControl_OnStart();
 
    virtual void pixelControl_OnBitePoint(uint8_t bitePoint);
 
    virtual void pixelControl_OnConnected();
 
    virtual void pixelControl_OnBLEdiscovering();
 
    virtual void pixelControl_OnSaveSettings();
 
    virtual void pixelControl_OnLowBattery();
};