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 <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,63]") {}
    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(std::string usage)
        : std::runtime_error(
              "There is an input number not assigned to a hardware input. Usage: " +
              usage) {}
 
    virtual ~unknown_input_number() noexcept {}
};
 
class invalid_user_input_number : public std::runtime_error
{
public:
    invalid_user_input_number(uint8_t value)
        : std::runtime_error(
              "The user-defined input number " +
              std::to_string(value) +
              " is out of range [0,127]") {}
    invalid_user_input_number()
        : std::runtime_error(
              "Trying to use an unspecified input number.") {}
 
    virtual ~invalid_user_input_number() noexcept {}
};
 
//-------------------------------------------------------------------
// Utility functions
//-------------------------------------------------------------------
 
template <typename T>
bool addIfNotExists(T item, std::vector<T> &vector)
{
    for (size_t i = 0; i < vector.size(); i++)
        if (vector.at(i) == item)
            return false;
    vector.push_back(item);
    return true;
}
 
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 numbers
//-------------------------------------------------------------------
 
struct InputNumber
{
public:
    InputNumber()
    {
        _value = 0xFF;
    }
 
    InputNumber(uint8_t value)
    {
        if (value >= 64)
            throw invalid_input_number(value);
        _value = value;
    }
 
    InputNumber(UNSPECIFIED value)
    {
        _value = 0xFF;
    }
 
    InputNumber(const InputNumber &number)
    {
        _value = number._value;
    }
 
    explicit operator uint64_t() const
    {
        if (_value < 64)
            return (1ULL << _value);
        else
            return 0ULL;
    }
 
    operator uint8_t() const
    {
        if (_value > 63)
            throw std::bad_cast();
        else
            return _value;
    }
 
    bool operator==(const UNSPECIFIED value) const { return (_value > 63); }
 
    bool operator!=(const UNSPECIFIED value) const { return (_value < 64); }
 
 
    inline bool operator==(const InputNumber value) const { return (_value == value._value); }
    inline bool operator!=(const InputNumber value) const { return (_value != value._value); }
    inline bool operator<(const InputNumber value) const { return (_value < value._value); }
 
    constexpr InputNumber &operator=(const InputNumber &other)
    {
        _value = other._value;
        return *this;
    }
 
    constexpr InputNumber &operator=(uint8_t value)
    {
        if (value >= 64)
            throw invalid_input_number(value);
        _value = value;
        return *this;
    }
 
 
    void book() const
    {
        if (_value < 64)
            _registered |= (1ULL << _value);
    }
 
    void unbook() const
    {
        if (_value < 64)
            _registered &= ~(1ULL << _value);
    }
 
    static void bookAll()
    {
        _registered = ~(0ULL);
    }
 
    static bool booked(InputNumber inputNumber)
    {
        return _registered & (uint64_t)inputNumber;
    }
 
    static bool booked(uint8_t inputNumber)
    {
        // Avoid two implicit typecasts
        if (inputNumber < 64)
            return _registered & (1ULL << inputNumber);
        else
            return false;
    }
 
    static uint64_t booked() { return _registered; }
 
#if CD_CI
    static void clearBook()
    {
        _registered = 0ULL;
    };
#endif
 
private:
    uint8_t _value;
    inline static uint64_t _registered = 0ULL;
};
 
class InputNumberCombination : public std::vector<InputNumber>
{
public:
    operator std::vector<uint8_t>()
    {
        std::vector<uint8_t> result = {};
        for (InputNumber inputNumber : *this)
        {
            if (inputNumber == UNSPECIFIED::VALUE)
                throw invalid_input_number();
            else
                result.push_back((uint8_t)inputNumber);
        }
        return result;
    }
 
    InputNumberCombination(std::initializer_list<uint8_t> items)
    {
        this->clear();
        for (auto item = items.begin(); item != items.end(); ++item)
        {
            if (*item > 63)
                throw invalid_input_number(*item);
            else
                this->push_back(static_cast<InputNumber>(*item));
        }
    }
 
    explicit operator uint64_t()
    {
        uint64_t bitmap = 0ULL;
        for (size_t i = 0; i < this->size(); i++)
            bitmap = bitmap | (uint64_t)this->at(i);
        return bitmap;
    }
};
 
// 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 
 
//-------------------------------------------------------------------
// User-defined input numbers
//-------------------------------------------------------------------
 
struct UserInputNumber
{
public:
    UserInputNumber()
    {
        _value = 0;
    }
 
    UserInputNumber(uint8_t value)
    {
        if (value >= 128)
            throw invalid_user_input_number(value);
        _value = value;
    }
 
    UserInputNumber(const UserInputNumber &number)
    {
        _value = number._value;
    }
 
    uint64_t getHigh() const
    {
        if (_value < 64)
            return (1ULL << _value);
        else
            return 0ULL;
    }
 
    uint64_t getLow() const
    {
        if (_value >= 64)
            return 0ULL;
        else
            return (1ULL << _value);
    }
 
    operator uint8_t() const
    {
        if (_value > 127)
            throw std::bad_cast();
        else
            return _value;
    }
 
 
    inline bool operator==(const UserInputNumber value) const { return (_value == value._value); }
    inline bool operator!=(const UserInputNumber value) const { return (_value != value._value); }
    inline bool operator<(const UserInputNumber value) const { return (_value < value._value); }
 
 
private:
    uint8_t _value;
};
 
//-------------------------------------------------------------------
// 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 ((_pin >= 0) && !addIfNotExists<int>(_pin, reservedPins))
            throw gpio_error(_pin, "Already in use");
    }
 
    void grant() const
    {
        abortIfUnspecified();
        if (_pin >= 0)
            reservedPins.erase(
                std::find(
                    reservedPins.begin(),
                    reservedPins.end(),
                    _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::vector<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::vector<GPIO> GPIOCollection;
typedef std::vector<InputGPIO> InputGPIOCollection;
typedef std::vector<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
};
 
enum class PixelFormat
{
    AUTO = 0,
    RGB,
    RBG,
    GRB,
    GBR,
    BRG,
    BGR
};
 
//-------------------------------------------------------------------
// 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;
} TelemetryData;
 
//-------------------------------------------------------------------
// 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;
 
    // Non copyable
 
    AbstractUserInterface() = default;
    AbstractUserInterface(const AbstractUserInterface &) = delete;
    AbstractUserInterface &operator=(const AbstractUserInterface &) = delete;
 
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 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() {}
    virtual ~PixelControlNotification() {}
 
    // For descendant classes
 
    bool notConnectedYet = true;
 
    uint8_t getPixelCount(PixelGroup group);
 
    void set(PixelGroup group,
             uint8_t pixelIndex,
             uint8_t red,
             uint8_t green,
             uint8_t blue);
 
    void setAll(
        PixelGroup group,
        uint8_t red,
        uint8_t green,
        uint8_t blue);
 
    void shiftToNext(PixelGroup group);
 
    void shiftToPrevious(PixelGroup group);
 
    virtual bool renderBatteryLevel(
        PixelGroup group,
        bool colorGradientOrPercentage,
        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();
};
 
//-------------------------------------------------------------------