InternalTypes.hpp

Go to the documentation of this file.

 
#pragma once
 
//-------------------------------------------------------------------
// Imports
//-------------------------------------------------------------------
 
#include <cstdint>
#include <cassert>
#include <array>
#include <vector>
#include <stdexcept>
#include <semaphore>
#include <chrono>
#include <optional>
 
#if !CD_CI
#define PRIVATE private
#include "esp_task_wdt.h" // For  esp_task_wdt_reset()
#define PROTECTED protected
#else
#define PRIVATE public
#define PROTECTED public
#endif
 
//-------------------------------------------------------------------
// Testing
//-------------------------------------------------------------------
 
struct FakeInput
{
    uint64_t state = 0ULL;
    uint64_t mask = ~(0ULL);
    uint8_t leftAxis = 0;
    uint8_t rightAxis = 0;
    size_t recalibrationRequestCount = 0;
 
    void press(uint8_t n)
    {
        uint64_t bmp = (1ULL << n);
        state = state | bmp;
    }
 
    void release(uint8_t n)
    {
        uint64_t bmp = (1ULL << n);
        state = state & ~bmp;
    }
 
    void clear()
    {
        state = 0ULL;
        leftAxis = 0;
        rightAxis = 0;
    }
 
    FakeInput() {}
    ~FakeInput() {}
};
 
//-------------------------------------------------------------------
// Input bitmaps
//-------------------------------------------------------------------
 
#define BITMASK(count, first)                         \
    ~(((1ULL << static_cast<uint64_t>(count)) - 1ULL) \
      << static_cast<uint64_t>(first))
 
#define NBITMASK(count, first)                       \
    (((1ULL << static_cast<uint64_t>(count)) - 1ULL) \
     << static_cast<uint64_t>(first))
 
//-------------------------------------------------------------------
// 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,
    _MAX_VALUE = ROTARY_ENCODERS
};
 
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
{
    uint64_t rawInputBitmap;
    uint64_t rawInputChanges;
    uint8_t leftAxisValue;
    uint8_t rightAxisValue;
};
 
#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 InternalEventType : uint8_t
{
    Start,
    Shutdown,
    Disconnected,
    Connected,
    BitePoint,
    ClutchWorkingMode,
    AltButtonsWorkingMode,
    DPadWorkingMode,
    SettingsSaved,
    PulseWidthMultiplier,
    LowBattery,
    SaveSetting,
    LoadSetting,
    NewBatteryStatus
};
 
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 <InternalEventType eventType, typename... _Args>
struct InternalEvent
{
    typedef void (*Callback)(_Args...);
 
    static void subscribe(Callback callback)
    {
        if (callback != nullptr)
            _callbacks.push_back(callback);
    }
 
    static void notify(_Args... __args)
    {
        for (auto callback : _callbacks)
        {
#if !CD_CI
            esp_task_wdt_reset();
#endif
            callback(std::forward<_Args>(__args)...);
        }
    }
 
private:
    inline static std::vector<Callback> _callbacks = {};
};
 
template <InternalEventType eventType>
struct InternalEvent<eventType, void>
{
    typedef void (*Callback)();
 
    static void subscribe(Callback callback)
    {
        if (callback != nullptr)
            _callbacks.push_back(callback);
    }
 
    static void notify()
    {
        for (auto callback : _callbacks)
            callback();
    }
 
    static void clearSubscriptions()
    {
        _callbacks.clear();
    }
 
private:
    inline static std::vector<Callback> _callbacks = {};
};
 
typedef InternalEvent<InternalEventType::Start, void> OnStart;
 
typedef InternalEvent<InternalEventType::Shutdown, void> OnShutdown;
 
typedef InternalEvent<InternalEventType::Disconnected, void> OnDisconnected;
 
typedef InternalEvent<InternalEventType::Connected, void> OnConnected;
 
typedef InternalEvent<InternalEventType::BitePoint, uint8_t> OnBitePoint;
 
typedef InternalEvent<InternalEventType::ClutchWorkingMode, ClutchWorkingMode>
    OnClutchWorkingMode;
 
typedef InternalEvent<
    InternalEventType::AltButtonsWorkingMode,
    AltButtonsWorkingMode>
    OnAltButtonsWorkingMode;
 
typedef InternalEvent<InternalEventType::DPadWorkingMode, void>
    OnDPadWorkingMode;
 
typedef InternalEvent<InternalEventType::SettingsSaved, void>
    OnSettingsSaved;
 
typedef InternalEvent<
    InternalEventType::PulseWidthMultiplier,
    PulseWidthMultiplier>
    OnPulseWidthMultiplier;
 
typedef InternalEvent<InternalEventType::LowBattery, void> OnLowBattery;
 
typedef InternalEvent<
    InternalEventType::NewBatteryStatus,
    const BatteryStatus &>
    OnBatteryStatus;
 
typedef InternalEvent<InternalEventType::LoadSetting, UserSetting>
    LoadSetting;
 
typedef InternalEvent<InternalEventType::SaveSetting, 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;