InternalTypes.hpp

Go to the documentation of this file.

 
#pragma once
 
//-------------------------------------------------------------------
// Imports
//-------------------------------------------------------------------
 
#include <cstdint>
#include <vector>
#include <optional>
#include "SimWheelTypes.hpp" // For uint128_t
 
#if !CD_CI
#define PRIVATE private
#define PROTECTED protected
#else
#define PRIVATE public
#define PROTECTED public
#endif
 
//-------------------------------------------------------------------
// Testing
//-------------------------------------------------------------------
 
struct FakeInput
{
    uint128_t state{};
    uint128_t mask{};
    uint8_t leftAxis = 0;
    uint8_t rightAxis = 0;
    size_t recalibrationRequestCount = 0;
 
    void press(uint8_t n)
    {
        state.set_bit(n, true);
    }
 
    void release(uint8_t n)
    {
        state.set_bit(n, false);
    }
 
    void clear()
    {
        state = {};
        leftAxis = 0;
        rightAxis = 0;
    }
};
 
//-------------------------------------------------------------------
// Device capabilities
//-------------------------------------------------------------------
 
enum class DeviceCapability : uint8_t
{
    CLUTCH_BUTTON = 0,
    CLUTCH_ANALOG = 1,
    ALT = 2,
    DPAD = 3,
    BATTERY = 4,
    BATTERY_CALIBRATION_AVAILABLE = 5,
    TELEMETRY_POWERTRAIN = 6,
    TELEMETRY_ECU = 7,
    TELEMETRY_RACE_CONTROL = 8,
    TELEMETRY_GAUGES = 9,
    ROTARY_ENCODERS = 10,
    TELEMETRY_WHEELS = 11,
    _MAX_VALUE = TELEMETRY_WHEELS
};
 
struct DeviceCapabilities
{
public:
    static void setFlag(DeviceCapability capability, bool setOrClear = true)
    {
        if (setOrClear)
            _flags |= (1 << static_cast<uint8_t>(capability));
        else
            _flags &= ~(1 << static_cast<uint8_t>(capability));
    }
 
    static bool hasFlag(DeviceCapability capability)
    {
        return _flags & (1 << static_cast<uint8_t>(capability));
    }
 
    static uint16_t getFlags() { return _flags; }
 
private:
    inline static uint16_t _flags = 0;
};
 
//-------------------------------------------------------------------
// Clutch
//-------------------------------------------------------------------
 
enum class ClutchWorkingMode : uint8_t
{
    CLUTCH = 0,
    AXIS,
    ALT,
    BUTTON,
    LAUNCH_CONTROL_MASTER_LEFT,
    LAUNCH_CONTROL_MASTER_RIGHT,
    _MAX_VALUE = LAUNCH_CONTROL_MASTER_RIGHT,
    _DEFAULT_VALUE = CLUTCH
};
 
#define CLUTCH_NONE_VALUE 0
#define CLUTCH_FULL_VALUE 254
#define CLUTCH_DEFAULT_VALUE 127
#define CLUTCH_1_4_VALUE 64
#define CLUTCH_3_4_VALUE 192
#define CLUTCH_INVALID_VALUE 255
 
//-------------------------------------------------------------------
// ALT BUTTONS
//-------------------------------------------------------------------
 
enum class AltButtonsWorkingMode : uint8_t
{
    Regular = 0,
    ALT,
    _MAX_VALUE = ALT,
    _DEFAULT_VALUE = ALT
};
 
//-------------------------------------------------------------------
// Rotary encoder
//-------------------------------------------------------------------
 
enum class PulseWidthMultiplier : uint8_t
{
    X1 = 1,
    X2,
    X3,
    X4,
    X5,
    X6,
    _MAX_VALUE = X6,
    _DEFAULT_VALUE = X2
};
 
//-------------------------------------------------------------------
// DPAD
//-------------------------------------------------------------------
 
enum class DPadWorkingMode : uint8_t
{
    Regular = 0,
    Navigation,
    _MAX_VALUE = Navigation,
    _DEFAULT_VALUE = Navigation
};
 
//-------------------------------------------------------------------
// Global firmware parameters
//-------------------------------------------------------------------
 
#define INPUT_TASK_PRIORITY (tskIDLE_PRIORITY + 2)
 
//-------------------------------------------------------------------
// Queues
//-------------------------------------------------------------------
 
class BitQueue
{
public:
    void enqueue(bool value)
    {
        uint8_t bqTailNext = bqTail;
        incDataPointer(bqTailNext);
        if (bqTailNext != bqHead)
        {
            // Queue not full
            uint64_t aux = (1ULL << bqTail);
            bitsQueue &= (~aux);
            if (value)
                bitsQueue |= aux;
            bqTail = bqTailNext;
        } // else queue full, overflow
    }
 
    bool dequeue(bool &value)
    {
        bool isNotEmpty = (bqHead != bqTail);
        if (isNotEmpty)
        {
            uint64_t bitState = (1ULL << bqHead) & bitsQueue;
            value = (bitState != 0ULL);
            incDataPointer(bqHead);
        }
        return isNotEmpty;
    }
 
 
    PRIVATE : uint64_t bitsQueue = 0ULL;
    uint8_t bqHead = 0; // "pointer" (short of) to head
    uint8_t bqTail = 0; // "pointer" to tail
 
    inline static void incDataPointer(uint8_t &pointer)
    {
        pointer = (pointer + 1) % 64;
    };
 
};
 
//-------------------------------------------------------------------
// Inputs-InputHub decoupling
//-------------------------------------------------------------------
 
struct DecouplingEvent
{
    uint128_t rawInputBitmap{};
    uint8_t leftAxisValue{CLUTCH_NONE_VALUE};
    uint8_t rightAxisValue{CLUTCH_NONE_VALUE};
};
 
#define MAX_DECOUPLING_EVENT_COUNT 64
 
//-------------------------------------------------------------------
// Battery Management
//-------------------------------------------------------------------
 
struct BatteryStatus
{
public:
    std::optional<uint8_t> stateOfCharge{};
    std::optional<bool> isCharging{};
    std::optional<bool> isBatteryPresent{};
    std::optional<bool> usingExternalPower{};
 
    constexpr bool operator==(const BatteryStatus &other) const noexcept
    {
        return (stateOfCharge == other.stateOfCharge) &&
               (isCharging == other.isCharging) &&
               (isBatteryPresent == other.isBatteryPresent) &&
               (usingExternalPower == other.usingExternalPower);
    }
 
    inline void reset() noexcept
    {
        stateOfCharge.reset();
        isCharging.reset();
        isBatteryPresent.reset();
        usingExternalPower.reset();
    }
};
 
#pragma pack(push, 1)
 
struct BatteryStatusChrData
{
    unsigned int flag_id_present : 1 = 1;
    unsigned int flag_battery_level_present : 1 = 1;
    unsigned int flag_additional_status_present : 1 = 1;
    unsigned int flag_reserved : 5 = 0;
 
    // End of byte 0
 
    unsigned int ps_battery_present : 1 = 0;
    unsigned int ps_wired_ext_power : 2 = 1;
    unsigned int ps_wireless_ext_power : 2 = 0;
    unsigned int ps_battery_charge_state : 2 = 0;
    unsigned int ps_battery_charge_level : 2 = 1;
    unsigned int ps_charging_type : 3 = 0;
    unsigned int ps_fault_reason : 3 = 0;
    unsigned int ps_reserved : 1 = 0;
 
    // End of bytes 1-2
 
    uint16_t id = 0x106;
 
    // End of bytes 3-4
 
    uint8_t battery_level = 100;
 
    // End of byte 5
 
    unsigned int as_service_required : 1 = 0;
    unsigned int as_battery_fault : 2 = 0;
    unsigned int as_reserved : 5 = 0;
 
    // End of byte 6
};
 
// For unknown reasons, the x86 compiler ignores the pragma pack directive
#if !CD_CI
static_assert(
    sizeof(BatteryStatusChrData) == 7,
    "Wrong size of BatteryStatusChrData (check struct packaging)");
#endif
 
#pragma pack(pop)
 
//-------------------------------------------------------------------
// Internal events
//-------------------------------------------------------------------
 
enum class UserSetting : uint8_t
{
    ALL = 0,
    AXIS_CALIBRATION,
    AXIS_POLARITY,
    PULSE_WIDTH,
    SECURITY_LOCK,
    BITE_POINT,
    CLUTCH_WORKING_MODE,
    ALT_WORKING_MODE,
    DPAD_WORKING_MODE,
    INPUT_MAP,
    CUSTOM_HARDWARE_ID,
    BATTERY_AUTO_CALIBRATION,
    BATTERY_CALIBRATION_DATA,
    _MAX_VALUE = BATTERY_CALIBRATION_DATA
};
 
//------------------------------------------------------------------------------
 
template <class... Args>
class static_event
{
public:
    using type = static_event<Args...>;
    using callback_type = typename ::std::add_pointer<void(Args...)>::type;
 
    void subscribe(callback_type callback) noexcept
    {
        if (!callback)
            return;
        _subscriptions.push_back(callback);
    }
 
    void clear() noexcept
    {
        _subscriptions.clear();
    }
 
    void operator()(const Args &...args)
    {
        for (const auto &entry : _subscriptions)
        {
            entry(args...);
        }
    }
 
    void operator()(const Args &...args) const
    {
        for (const auto &entry : _subscriptions)
        {
            entry(args...);
        }
    }
 
    ::std::size_t subscribed()
    {
        return _subscriptions.size();
    }
 
    type &operator=(type &&source) noexcept
    {
        _subscriptions.swap(source._subscriptions);
        return *this;
    }
 
    type &operator=(const type &source) noexcept
    {
        _subscriptions = source._subscriptions;
        return *this;
    }
 
    constexpr static_event() noexcept = default;
 
    static_event(const type &source)
    {
        _subscriptions = source._subscriptions;
    }
 
    static_event(type &&source)
    {
        _subscriptions.swap(source._subscriptions);
    }
 
    constexpr bool operator==(const type &other) const noexcept
    {
        return (_subscriptions == other._subscriptions);
    }
 
private:
    ::std::vector<callback_type> _subscriptions{};
};
 
inline static_event<> OnStart;
 
inline static_event<> OnShutdown;
 
inline static_event<> OnDisconnected;
 
inline static_event<> OnConnected;
 
inline static_event<uint8_t> OnBitePoint;
 
inline static_event<ClutchWorkingMode> OnClutchWorkingMode;
 
inline static_event<AltButtonsWorkingMode> OnAltButtonsWorkingMode;
 
inline static_event<> OnDPadWorkingMode;
 
inline static_event<> OnSettingsSaved;
 
inline static_event<PulseWidthMultiplier> OnPulseWidthMultiplier;
 
inline static_event<> OnLowBattery;
 
inline static_event<const BatteryStatus &> OnBatteryStatus;
 
inline static_event<UserSetting> LoadSetting;
 
inline static_event<UserSetting> SaveSetting;
 
//-------------------------------------------------------------------
// Automatic shutdown
//-------------------------------------------------------------------
 
#define AUTO_POWER_OFF_DELAY_SECS 60
 
//-------------------------------------------------------------------
// Simple commands
//-------------------------------------------------------------------
 
typedef enum
{
    CMD_RESERVED = 0,
    CMD_AXIS_RECALIBRATE = 1,
    CMD_BATT_RECALIBRATE = 2,
    CMD_RESET_BUTTONS_MAP = 3,
    CMD_SAVE_NOW = 4,
    CMD_REVERSE_LEFT_AXIS = 5,
    CMD_REVERSE_RIGHT_AXIS = 6,
    CMD_SHOW_PIXELS = 7,
    CMD_RESET_PIXELS = 8,
    _MAX_VALUE = 8
} SimpleCommand;