SimWheel.hpp

Go to the documentation of this file.

 
#pragma once
 
//-------------------------------------------------------------------
// Imports
//-------------------------------------------------------------------
 
#include "InputSpecification.hpp"
 
#include <type_traits>
 
//-------------------------------------------------------------------
// Inputs
//-------------------------------------------------------------------
 
namespace inputs
{
    void addButton(InputGPIO pin, InputNumber inputNumber);
 
    void addRotaryEncoder(
        InputGPIO clkPin,
        InputGPIO dtPin,
        InputNumber cwInputNumber,
        InputNumber ccwInputNumber,
        bool useAlternateEncoding = false);
 
    void addButtonMatrix(
        const ButtonMatrix &matrix,
        bool negativeLogic = false);
 
    void addAnalogMultiplexerGroup(
        OutputGPIO selectorPin1,
        OutputGPIO selectorPin2,
        OutputGPIO selectorPin3,
        const AnalogMultiplexerGroup<Mux8Pin> &chips);
 
    void addAnalogMultiplexerGroup(
        OutputGPIO selectorPin1,
        OutputGPIO selectorPin2,
        OutputGPIO selectorPin3,
        OutputGPIO selectorPin4,
        const AnalogMultiplexerGroup<Mux16Pin> &chips);
 
    void addAnalogMultiplexerGroup(
        OutputGPIO selectorPin1,
        OutputGPIO selectorPin2,
        OutputGPIO selectorPin3,
        OutputGPIO selectorPin4,
        OutputGPIO selectorPin5,
        const AnalogMultiplexerGroup<Mux32Pin> &chips);
 
    void addMCP23017Expander(
        const MCP23017Expander &chip,
        uint8_t address,
        bool isFullAddress = false,
        I2CBus bus = I2CBus::PRIMARY);
 
    void addPCF8574Expander(
        const PCF8574Expander &chip,
        uint8_t address,
        bool isFullAddress = false,
        I2CBus bus = I2CBus::PRIMARY);
 
    void add74HC165NChain(
        OutputGPIO loadPin,
        OutputGPIO nextPin,
        InputGPIO inputPin,
        const ShiftRegisterChain &chain,
        InputNumber SER_inputNumber = UNSPECIFIED::VALUE,
        const bool negativeLogic = true);
 
    void addRotaryCodedSwitch(
        const RotaryCodedSwitch &spec,
        InputGPIO pin0,
        InputGPIO pin1,
        InputGPIO pin2,
        bool complementaryCode = true);
 
    void addRotaryCodedSwitch(
        const RotaryCodedSwitch &spec,
        InputGPIO pin0,
        InputGPIO pin1,
        InputGPIO pin2,
        InputGPIO pin3,
        bool complementaryCode = true);
 
    void addRotaryCodedSwitch(
        const RotaryCodedSwitch &spec,
        InputGPIO pin0,
        InputGPIO pin1,
        InputGPIO pin2,
        InputGPIO pin3,
        InputGPIO pin4,
        bool complementaryCode = true);
 
    void initializeI2C(
        GPIO sclPin,
        GPIO sdaPin,
        I2CBus bus = I2CBus::PRIMARY,
        bool enableInternalPullup = true);
 
    void setAnalogClutchPaddles(
        ADC_GPIO leftClutchPin,
        ADC_GPIO rightClutchPin);
 
} // namespace inputs
 
//-------------------------------------------------------------------
// Input Hub
//-------------------------------------------------------------------
 
namespace inputHub
{
    namespace clutch
    {
        void inputs(
            InputNumber leftInputNumber,
            InputNumber rightInputNumber);
 
        void bitePointInputs(
            InputNumber increase,
            InputNumber decrease);
 
        void cycleWorkingModeInputs(InputNumberCombination inputNumbers);
 
        void cmdRecalibrateAxisInputs(InputNumberCombination inputNumbers);
 
    } // namespace Clutch
 
    namespace dpad
    {
        void inputs(
            InputNumber padUpNumber,
            InputNumber padDownNumber,
            InputNumber padLeftNumber,
            InputNumber padRightNumber);
 
        void cycleWorkingModeInputs(InputNumberCombination inputNumbers);
    } // namespace DPAD
 
    namespace altButtons
    {
        void inputs(InputNumberCombination inputNumbers);
 
        void cycleWorkingModeInputs(InputNumberCombination inputNumbers);
    } // namespace ALTButtons
 
    namespace securityLock
    {
        void cycleWorkingModeInputs(InputNumberCombination inputNumbers);
    } // namespace SecurityLock
 
    namespace neutralGear
    {
        void set(
            InputNumber neutral,
            InputNumberCombination combination =
                {JOY_LSHIFT_PADDLE, JOY_RSHIFT_PADDLE});
    } // namespace neutral
 
    namespace codedSwitch
    {
        void add(
            InputNumber bit1,
            InputNumber bit2,
            InputNumber bit4,
            CodedSwitch8 spec);
 
        void add(
            InputNumber bit1,
            InputNumber bit2,
            InputNumber bit4,
            InputNumber bit8,
            CodedSwitch16 spec);
 
        void add(
            InputNumber bit1,
            InputNumber bit2,
            InputNumber bit4,
            InputNumber bit8,
            InputNumber bit16,
            CodedSwitch32 spec);
    } // namespace codedSwitch
 
} // namespace inputHub
 
//-------------------------------------------------------------------
// Input map
//-------------------------------------------------------------------
 
namespace inputMap
{
    void set(
        InputNumber firmware_defined,
        UserInputNumber user_defined,
        UserInputNumber user_defined_alt_engaged);
 
    inline void set(
        InputNumber firmware_defined,
        UserInputNumber user_defined_alt_engaged)
    {
        inputMap::set(
            firmware_defined,
            static_cast<UserInputNumber>(firmware_defined),
            user_defined_alt_engaged);
    }
 
    void setOptimal();
 
} // namespace inputMap
 
namespace hid
{
    void configure(
        std::string deviceName,
        std::string deviceManufacturer,
        bool enableAutoPowerOff = true,
        uint16_t vendorID = 0,
        uint16_t productID = 0);
 
    void connectivity(Connectivity option);
} // namespace hid
 
//-------------------------------------------------------------------
// Power management
//-------------------------------------------------------------------
 
namespace power
{
    void configureWakeUp(RTC_GPIO wakeUpPin);
 
    void configurePowerLatch(
        OutputGPIO latchPin,
        PowerLatchMode mode = PowerLatchMode::POWER_OPEN_DRAIN,
        uint32_t waitMs = 5000);
}
 
//-------------------------------------------------------------------
// Battery
//-------------------------------------------------------------------
 
namespace batteryMonitor
{
    void configure(ADC_GPIO battREADPin, OutputGPIO battENPin = UNSPECIFIED::VALUE);
 
    void configure(I2CBus bus = I2CBus::PRIMARY, uint8_t i2c_address = 0xFF);
 
    void setPeriod(uint32_t seconds);
 
    void setWarningSoC(uint8_t percentage);
 
    void setPowerOffSoC(uint8_t percentage);
 
    void setExternalPowerWitness(InputGPIO sensePin);
 
    void setChargingWitness(
        InputGPIO sensePin,
        bool negativeLogic = true,
        bool enableInternalPullResistor = true);
} // namespace batteryMonitor
 
//-------------------------------------------------------------------
// Pixel control
//-------------------------------------------------------------------
 
namespace pixels
{
    void configure(
        PixelGroup group,
        OutputGPIO dataPin,
        uint8_t pixelCount,
        bool useLevelShift,
        PixelDriver pixelType = PixelDriver::WS2812,
        PixelFormat pixelFormat = PixelFormat::AUTO,
        uint8_t globalBrightness = 0xFF);
} // namespace pixels
 
//-------------------------------------------------------------------
// Telemetry
//-------------------------------------------------------------------
 
namespace telemetry
{
    extern TelemetryData data;
}
 
//-------------------------------------------------------------------
// User interface
//-------------------------------------------------------------------
 
namespace ui
{
    void add(AbstractUserInterface *instance);
 
    template <typename UIClass, typename... _Args>
    inline void add(_Args... __args)
    {
        static_assert(
            std::is_base_of<AbstractUserInterface, UIClass>::value,
            "Given user interface class is not derived from AbstractUserInterface");
        ui::add(new UIClass(std::forward<_Args>(__args)...));
    }
 
    inline void addPixelControlNotifications()
    {
        ui::add(PixelControlNotification::getInstance());
    }
}
 
//-------------------------------------------------------------------
// Firmware
//-------------------------------------------------------------------
 
namespace firmware
{
    void run();
    void run(void (*func)());
}