TalonSRX.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/CustomParamConfiguration.h"
 
/* forward proto's */
namespace ctre {
    namespace phoenix {
        namespace motorcontrol {
            class SensorCollection;
            class TalonSRXSimCollection;
        }
    }
}
 
namespace ctre {
    namespace phoenix {
        namespace motorcontrol {
            namespace can {
 
                struct TalonSRXPIDSetConfiguration : BaseTalonPIDSetConfiguration { };
                struct TalonSRXConfiguration : BaseTalonConfiguration {
 
                    int peakCurrentLimit;
                    int peakCurrentDuration;
                    int continuousCurrentLimit;
                    TalonSRXConfiguration() :
                        BaseTalonConfiguration(FeedbackDevice::QuadEncoder),
                        peakCurrentLimit(1),
                        peakCurrentDuration(1),
                        continuousCurrentLimit(1)
                    {
                    }
 
                    std::string toString() {
                        return toString("");
                    }
 
                    std::string toString(std::string prependString) {
 
                        std::string retstr;
                        retstr += prependString + ".peakCurrentLimit = " + std::to_string(peakCurrentLimit) + ";\n";
                        retstr += prependString + ".peakCurrentDuration = " + std::to_string(peakCurrentDuration) + ";\n";
                        retstr += prependString + ".continuousCurrentLimit = " + std::to_string(continuousCurrentLimit) + ";\n";
                        retstr += BaseTalonConfiguration::toString(prependString);
 
                        return retstr;
                    }
                 };// struct TalonSRXConfiguration
 
                class TalonSRXConfigUtil : BaseTalonConfigUtil { 
                private:
                    static struct TalonSRXConfiguration _default;
                public:
                    static bool PeakCurrentLimitDifferent(const TalonSRXConfiguration& settings) { return (!(settings.peakCurrentLimit == _default.peakCurrentLimit)) || !settings.enableOptimizations; }
                    static bool PeakCurrentDurationDifferent(const TalonSRXConfiguration& settings) { return (!(settings.peakCurrentDuration == _default.peakCurrentDuration)) || !settings.enableOptimizations; }
                    static bool ContinuousCurrentLimitDifferent(const TalonSRXConfiguration& settings) { return (!(settings.continuousCurrentLimit == _default.continuousCurrentLimit)) || !settings.enableOptimizations; }
 
                };
 
                class TalonSRX : public virtual BaseTalon
                {
                private:
 
                public:
                    TalonSRX(int deviceNumber);
                    ~TalonSRX();
                    TalonSRX() = delete;
                    TalonSRX(TalonSRX const&) = delete;
                    TalonSRX& operator=(TalonSRX const&) = delete;
                    // ------ Set output routines. ----------//
                    void Set(TalonSRXControlMode mode, double value);
                    void Set(TalonSRXControlMode mode, double demand0, DemandType demand1Type, double demand1);
                    //------ sensor selection ----------//
                    ctre::phoenix::ErrorCode ConfigSelectedFeedbackSensor(TalonSRXFeedbackDevice feedbackDevice, int pidIdx = 0, int timeoutMs = 0);
                    ctre::phoenix::ErrorCode ConfigSelectedFeedbackSensor(FeedbackDevice feedbackDevice, int pidIdx, int timeoutMs = 0);
 
                    ctre::phoenix::ErrorCode ConfigSelectedFeedbackSensor(RemoteFeedbackDevice feedbackDevice, int pidIdx, int timeoutMs);
 
                    //------ Current Limit ----------//
                    virtual ctre::phoenix::ErrorCode ConfigSupplyCurrentLimit(const SupplyCurrentLimitConfiguration& currLimitConfigs, int timeoutMs = 50);
                    ctre::phoenix::ErrorCode ConfigPeakCurrentLimit(int amps, int timeoutMs = 0);
                    ctre::phoenix::ErrorCode ConfigPeakCurrentDuration(int milliseconds,
                        int timeoutMs = 0);
                    ctre::phoenix::ErrorCode ConfigContinuousCurrentLimit(int amps, int timeoutMs = 0);
 
                    void EnableCurrentLimit(bool enable);
                    //------ RAW Sensor API ----------//
                    ctre::phoenix::motorcontrol::SensorCollection& GetSensorCollection();
 
                    //------ Simulation API ----------//
                    ctre::phoenix::motorcontrol::TalonSRXSimCollection& GetSimCollection();
 
                    //------ All Configs ----------//
 
                    ctre::phoenix::ErrorCode ConfigurePID(const TalonSRXPIDSetConfiguration& pid, int pidIdx = 0, int timeoutMs = 50);
                    void GetPIDConfigs(TalonSRXPIDSetConfiguration& pid, int pidIdx = 0, int timeoutMs = 50);
                    ctre::phoenix::ErrorCode ConfigAllSettings(const TalonSRXConfiguration& allConfigs, int timeoutMs = 50);
                    void GetAllConfigs(TalonSRXConfiguration& allConfigs, int timeoutMs = 50);
 
                    /* ----- virtual re-directs ------- */
                    virtual void Set(ControlMode mode, double value);
                    virtual void Set(ControlMode mode, double demand0, DemandType demand1Type, double demand1);
                };// class TalonSRX
 
            } // namespace can
        } // namespace motorcontrol
    } // namespace phoenix
} // namespace ctre
 
#if defined(WIN32) || defined(_WIN32) || defined(_WIN64)
#pragma warning (pop)
#endif