TalonFX.h

#pragma once
#if defined(WIN32) || defined(_WIN32) || defined(_WIN64)
#pragma warning (push)
#pragma warning (disable : 4250)
#endif
 
#include "ctre/phoenix/motorcontrol/can/BaseTalon.h"
#include "ctre/phoenix/motorcontrol/IMotorControllerEnhanced.h"
#include "ctre/phoenix/motorcontrol/MotorCommutation.h"
#include "ctre/phoenix/motorcontrol/StatorCurrentLimitConfiguration.h"
#include "ctre/phoenix/CustomParamConfiguration.h"
#include "ctre/phoenix/sensors/AbsoluteSensorRange.h"
#include "ctre/phoenix/sensors/SensorInitializationStrategy.h"
 
namespace ctre {
    namespace phoenix {
        namespace motorcontrol {
            namespace can {
 
                struct TalonFXPIDSetConfiguration : BaseTalonPIDSetConfiguration { };
 
                struct TalonFXConfiguration : BaseTalonConfiguration {
 
                    SupplyCurrentLimitConfiguration supplyCurrLimit;
                    StatorCurrentLimitConfiguration statorCurrLimit;
 
                    ctre::phoenix::motorcontrol::MotorCommutation motorCommutation = ctre::phoenix::motorcontrol::MotorCommutation::Trapezoidal;
 
                    ctre::phoenix::sensors::AbsoluteSensorRange absoluteSensorRange = ctre::phoenix::sensors::AbsoluteSensorRange::Unsigned_0_to_360;
                    double integratedSensorOffsetDegrees = 0;
                    ctre::phoenix::sensors::SensorInitializationStrategy initializationStrategy = ctre::phoenix::sensors::SensorInitializationStrategy::BootToZero;
 
 
                    TalonFXConfiguration() : BaseTalonConfiguration(FeedbackDevice::IntegratedSensor)
                    {
                    }
 
                    std::string toString() {
                        return toString("");
                    }
 
                    std::string toString(std::string prependString) {
 
                        std::string retstr;     
                        retstr += prependString + ".supplyCurrLimit = " + supplyCurrLimit.ToString() + ";\n";
                        retstr += prependString + ".statorCurrLimit = " + statorCurrLimit.ToString() + ";\n";
                        retstr += prependString + ".motorCommutation = " + std::to_string((int)motorCommutation) + ";\n";
                        retstr += prependString + ".absoluteSensorRange = " + std::to_string(absoluteSensorRange) + ";\n";
                        retstr += prependString + ".integratedSensorOffsetDegrees = " + std::to_string(integratedSensorOffsetDegrees) + ";\n";
                        retstr += prependString + ".initializationStrategy = " + std::to_string(initializationStrategy) + ";\n";
                        retstr += BaseTalonConfiguration::toString(prependString);
 
                        return retstr;
                    }
                 };// struct TalonFXConfiguration
 
                class TalonFXConfigUtil : BaseTalonConfigUtil { 
                private:
                    static struct TalonFXConfiguration _default;
                public:
                    static bool SupplyCurrentLimitDifferent(const TalonFXConfiguration& settings) { return (!settings.supplyCurrLimit.Equals(_default.supplyCurrLimit)) || !settings.enableOptimizations; }
                    static bool StatorCurrentDurationDifferent(const TalonFXConfiguration& settings) { return (!settings.statorCurrLimit.Equals(_default.statorCurrLimit)) || !settings.enableOptimizations; }
                    static bool MotorCommutationDifferent(const TalonFXConfiguration& settings) { return (settings.motorCommutation != _default.motorCommutation) || !settings.enableOptimizations; }
                    static bool AbsoluteSensorRangeDifferent(const TalonFXConfiguration& settings) { return (settings.absoluteSensorRange != _default.absoluteSensorRange) || !settings.enableOptimizations; }
                    static bool IntegratedSensorOffsetDegreesDifferent(const TalonFXConfiguration& settings) { return (settings.integratedSensorOffsetDegrees != _default.integratedSensorOffsetDegrees) || !settings.enableOptimizations; }
                    static bool InitializationStrategyDifferent(const TalonFXConfiguration& settings) { return (settings.initializationStrategy != _default.initializationStrategy) || !settings.enableOptimizations; }
                };
 
                class TalonFX : public virtual BaseTalon
                {
                private:
 
                public:
                    TalonFX(int deviceNumber, std::string const &canbus = "");
                    ~TalonFX();
                    TalonFX() = delete;
                    TalonFX(TalonFX const&) = delete;
                    TalonFX& operator=(TalonFX const&) = delete;
                    // ------ Set output routines. ----------//
                    void Set(TalonFXControlMode mode, double value);
                    void Set(TalonFXControlMode mode, double demand0, DemandType demand1Type, double demand1);
                    //------ Invert behavior ----------//
                    void SetInverted(TalonFXInvertType invertType);
                    //------ sensor selection ----------//
                    ctre::phoenix::ErrorCode ConfigSelectedFeedbackSensor(TalonFXFeedbackDevice feedbackDevice, int pidIdx = 0, int timeoutMs = 0);
                    //------ Current Limit ----------//
                    ctre::phoenix::ErrorCode ConfigSupplyCurrentLimit(const ctre::phoenix::motorcontrol::SupplyCurrentLimitConfiguration& currLimitConfigs, int timeoutMs = 50);
                    ctre::phoenix::ErrorCode ConfigStatorCurrentLimit(const ctre::phoenix::motorcontrol::StatorCurrentLimitConfiguration& currLimitConfigs, int timeoutMs = 50);
                    ctre::phoenix::ErrorCode ConfigGetSupplyCurrentLimit(ctre::phoenix::motorcontrol::SupplyCurrentLimitConfiguration& currLimitConfigsToFill, int timeoutMs = 50);
                    ctre::phoenix::ErrorCode ConfigGetStatorCurrentLimit(ctre::phoenix::motorcontrol::StatorCurrentLimitConfiguration& currLimitConfigsToFill, int timeoutMs = 50);
 
                    //------ RAW Sensor API ----------//
                    ctre::phoenix::motorcontrol::TalonFXSensorCollection& GetSensorCollection();
 
                    //------ Simulation API ----------//
                    ctre::phoenix::motorcontrol::TalonFXSimCollection& GetSimCollection();
 
                    //------ All Configs ----------//
 
                    ctre::phoenix::ErrorCode ConfigurePID(const TalonFXPIDSetConfiguration& pid, int pidIdx = 0, int timeoutMs = 50);
                    void GetPIDConfigs(TalonFXPIDSetConfiguration& pid, int pidIdx = 0, int timeoutMs = 50);
 
                    ctre::phoenix::ErrorCode ConfigAllSettings(const TalonFXConfiguration& allConfigs, int timeoutMs = 50);
                    void GetAllConfigs(TalonFXConfiguration& allConfigs, int timeoutMs = 50);
                    ctre::phoenix::ErrorCode ConfigMotorCommutation(ctre::phoenix::motorcontrol::MotorCommutation motorCommutation, int timeoutMs = 0);
                    ctre::phoenix::ErrorCode ConfigGetMotorCommutation(ctre::phoenix::motorcontrol::MotorCommutation & motorCommutation, int timeoutMs = 0);
 
                    ErrorCode ConfigIntegratedSensorAbsoluteRange(ctre::phoenix::sensors::AbsoluteSensorRange absoluteSensorRange, int timeoutMs = 0);
                    ErrorCode ConfigIntegratedSensorOffset(double offsetDegrees, int timeoutMs = 0);
                    ErrorCode ConfigIntegratedSensorInitializationStrategy(ctre::phoenix::sensors::SensorInitializationStrategy initializationStrategy, int timeoutMs = 0);
 
                    /* ----- virtual re-directs ------- */
                    virtual void Set(ControlMode mode, double value);
                    virtual void Set(ControlMode mode, double demand0, DemandType demand1Type, double demand1);
                    virtual void SetInverted(InvertType invertType);
                    virtual void SetInverted(bool bInvert);
                    virtual ctre::phoenix::ErrorCode ConfigSelectedFeedbackSensor(FeedbackDevice feedbackDevice, int pidIdx = 0, int timeoutMs = 0);
                    virtual ctre::phoenix::ErrorCode ConfigSelectedFeedbackSensor(RemoteFeedbackDevice feedbackDevice, int pidIdx = 0, int timeoutMs = 0);
 
                };// class TalonFX
 
            } // namespace can
        } // namespace motorcontrol
    } // namespace phoenix
} // namespace ctre
 
#if defined(WIN32) || defined(_WIN32) || defined(_WIN64)
#pragma warning (pop)
#endif