BaseTalon.h

#pragma once
#if defined(WIN32) || defined(_WIN32) || defined(_WIN64)
#pragma warning (push)
#pragma warning (disable : 4250)
#endif
 
#include "ctre/phoenix/motorcontrol/can/BaseMotorController.h"
#include "ctre/phoenix/motorcontrol/IMotorControllerEnhanced.h"
#include "ctre/phoenix/motorcontrol/SupplyCurrentLimitConfiguration.h"
#include "ctre/phoenix/CustomParamConfiguration.h"
#include "ctre/phoenix/motorcontrol/SensorCollection.h"
#include "ctre/phoenix/motorcontrol/TalonFXSensorCollection.h"
#include "ctre/phoenix/motorcontrol/TalonSRXSimCollection.h"
#include "ctre/phoenix/motorcontrol/TalonFXSimCollection.h"
 
/* forward proto's */
namespace ctre {
    namespace phoenix {
        namespace motorcontrol {
            class SensorCollection;
        }
    }
}
 
namespace ctre {
    namespace phoenix {
        namespace motorcontrol {
            namespace can {
 
                struct BaseTalonPIDSetConfiguration : BasePIDSetConfiguration {
                    FeedbackDevice selectedFeedbackSensor;
 
                    BaseTalonPIDSetConfiguration(FeedbackDevice defaultFeedbackDevice) :
                        selectedFeedbackSensor(defaultFeedbackDevice)
                    {
                    }
 
                    std::string toString() {
                        return toString("");
                    }
 
                    std::string toString(std::string prependString) {
 
                        std::string retstr = prependString + ".selectedFeedbackSensor = " + FeedbackDeviceRoutines::toString(selectedFeedbackSensor) + ";\n";
                        retstr += BasePIDSetConfiguration::toString(prependString);
                        return retstr;
                    }
                };
 
                struct BaseTalonPIDSetConfigUtil {
                private:
                    static BaseTalonPIDSetConfiguration _default;
                public:
                    /* Default feedback sensor is product specific. In order to ensure user always gets what they expect when selecting feedback sensor,
                       SelectedFeedbackSensorDifferent will always return true */
 
                    static bool SelectedFeedbackSensorDifferent(const BaseTalonPIDSetConfiguration& settings) { (void) settings; return true; } //{ return (!(settings.selectedFeedbackSensor == _default.selectedFeedbackSensor)); }
                    static bool SelectedFeedbackCoefficientDifferent(const BaseTalonPIDSetConfiguration& settings) { return (!(settings.selectedFeedbackCoefficient == _default.selectedFeedbackCoefficient)); }
                };
 
 
                struct BaseTalonConfiguration : BaseMotorControllerConfiguration {
                    BaseTalonPIDSetConfiguration primaryPID;
                    BaseTalonPIDSetConfiguration auxiliaryPID;
                    LimitSwitchSource forwardLimitSwitchSource;
                    LimitSwitchSource reverseLimitSwitchSource;
                    int forwardLimitSwitchDeviceID;
                    int reverseLimitSwitchDeviceID;
                    LimitSwitchNormal forwardLimitSwitchNormal;
                    LimitSwitchNormal reverseLimitSwitchNormal;
                    FeedbackDevice sum0Term;
                    FeedbackDevice sum1Term;
                    FeedbackDevice diff0Term;
                    FeedbackDevice diff1Term;
 
                    BaseTalonConfiguration(FeedbackDevice defaultFeedbackDevice) :
                        primaryPID(defaultFeedbackDevice),
                        auxiliaryPID(defaultFeedbackDevice),
                        forwardLimitSwitchSource(LimitSwitchSource_FeedbackConnector),
                        reverseLimitSwitchSource(LimitSwitchSource_FeedbackConnector),
                        forwardLimitSwitchDeviceID(0),
                        reverseLimitSwitchDeviceID(0),
                        forwardLimitSwitchNormal(LimitSwitchNormal_NormallyOpen),
                        reverseLimitSwitchNormal(LimitSwitchNormal_NormallyOpen),
                        sum0Term(defaultFeedbackDevice),
                        sum1Term(defaultFeedbackDevice),
                        diff0Term(defaultFeedbackDevice),
                        diff1Term(defaultFeedbackDevice)
                    {
                    }
 
                    std::string toString() {
                        return toString("");
                    }
 
                    std::string toString(std::string prependString) {
 
 
                        std::string retstr = primaryPID.toString(prependString + ".primaryPID");
                        retstr += auxiliaryPID.toString(prependString + ".auxiliaryPID");
                        retstr += prependString + ".forwardLimitSwitchSource = " + LimitSwitchRoutines::toString(forwardLimitSwitchSource) + ";\n";
                        retstr += prependString + ".reverseLimitSwitchSource = " + LimitSwitchRoutines::toString(reverseLimitSwitchSource) + ";\n";
                        retstr += prependString + ".forwardLimitSwitchDeviceID = " + std::to_string(forwardLimitSwitchDeviceID) + ";\n";
                        retstr += prependString + ".reverseLimitSwitchDeviceID = " + std::to_string(reverseLimitSwitchDeviceID) + ";\n";
                        retstr += prependString + ".forwardLimitSwitchNormal = " + LimitSwitchRoutines::toString(forwardLimitSwitchNormal) + ";\n";
                        retstr += prependString + ".reverseLimitSwitchNormal = " + LimitSwitchRoutines::toString(reverseLimitSwitchNormal) + ";\n";
                        retstr += prependString + ".sum0Term = " + FeedbackDeviceRoutines::toString(sum0Term) + ";\n";
                        retstr += prependString + ".sum1Term = " + FeedbackDeviceRoutines::toString(sum1Term) + ";\n";
                        retstr += prependString + ".diff0Term = " + FeedbackDeviceRoutines::toString(diff0Term) + ";\n";
                        retstr += prependString + ".diff1Term = " + FeedbackDeviceRoutines::toString(diff1Term) + ";\n";
                        retstr += BaseMotorControllerConfiguration::toString(prependString);
 
                        return retstr;
                    }
                };// struct BaseTalonConfiguration
 
                class BaseTalonConfigUtil {
                private:
                    static struct BaseTalonConfiguration _default;
                public:
                    /* Default feedback sensor is product specific. In order to ensure user always gets what they expect when selecting feedback sensor,
                       (Sum/Diff)(0/1)TermDifferent will always return true */
 
                    static bool ForwardLimitSwitchSourceDifferent(const BaseTalonConfiguration& settings) { return (!(settings.forwardLimitSwitchSource == _default.forwardLimitSwitchSource)) || !settings.enableOptimizations; }
                    static bool ReverseLimitSwitchSourceDifferent(const BaseTalonConfiguration& settings) { return (!(settings.reverseLimitSwitchSource == _default.reverseLimitSwitchSource)) || !settings.enableOptimizations; }
                    static bool ForwardLimitSwitchDeviceIDDifferent(const BaseTalonConfiguration& settings) { return (!(settings.forwardLimitSwitchDeviceID == _default.forwardLimitSwitchDeviceID)) || !settings.enableOptimizations; }
                    static bool ReverseLimitSwitchDeviceIDDifferent(const BaseTalonConfiguration& settings) { return (!(settings.reverseLimitSwitchDeviceID == _default.reverseLimitSwitchDeviceID)) || !settings.enableOptimizations; }
                    static bool ForwardLimitSwitchNormalDifferent(const BaseTalonConfiguration& settings) { return (!(settings.forwardLimitSwitchNormal == _default.forwardLimitSwitchNormal)) || !settings.enableOptimizations; }
                    static bool ReverseLimitSwitchNormalDifferent(const BaseTalonConfiguration& settings) { return (!(settings.reverseLimitSwitchNormal == _default.reverseLimitSwitchNormal)) || !settings.enableOptimizations; }
                    static bool Sum0TermDifferent(const BaseTalonConfiguration& settings) { (void) settings; return true; } //{ return (!(settings.sum0Term == _default.sum0Term)) || !settings.enableOptimizations; }
                    static bool Sum1TermDifferent(const BaseTalonConfiguration& settings) { (void) settings; return true; } //{ return (!(settings.sum1Term == _default.sum1Term)) || !settings.enableOptimizations; }
                    static bool Diff0TermDifferent(const BaseTalonConfiguration& settings) { (void) settings; return true; } //{ return (!(settings.diff0Term == _default.diff0Term)) || !settings.enableOptimizations; }
                    static bool Diff1TermDifferent(const BaseTalonConfiguration& settings) { (void) settings; return true; } //{ return (!(settings.diff1Term == _default.diff1Term)) || !settings.enableOptimizations; }
 
                    static bool ForwardLimitSwitchDifferent(const BaseTalonConfiguration& settings) {
                        return ForwardLimitSwitchDeviceIDDifferent(settings) || ForwardLimitSwitchNormalDifferent(settings) || ForwardLimitSwitchSourceDifferent(settings);
                    }
                    static bool ReverseLimitSwitchDifferent(const BaseTalonConfiguration& settings) {
                        return ReverseLimitSwitchDeviceIDDifferent(settings) || ReverseLimitSwitchNormalDifferent(settings) || ReverseLimitSwitchSourceDifferent(settings);
                    }
                };
 
                class BaseTalon : public virtual BaseMotorController, public virtual IMotorControllerEnhanced
                {
                private:
                    ctre::phoenix::motorcontrol::SensorCollection* _sensorCollSrx;
                    ctre::phoenix::motorcontrol::TalonFXSensorCollection* _sensorCollFx;
 
                    ctre::phoenix::motorcontrol::TalonSRXSimCollection* _simCollSrx;
                    ctre::phoenix::motorcontrol::TalonFXSimCollection* _simCollFx;
 
                protected:
                    ctre::phoenix::motorcontrol::SensorCollection& GetTalonSRXSensorCollection() { return *_sensorCollSrx; }
                    ctre::phoenix::motorcontrol::TalonFXSensorCollection& GetTalonFXSensorCollection() { return *_sensorCollFx; }
 
                    ctre::phoenix::motorcontrol::TalonSRXSimCollection& GetTalonSRXSimCollection() { return *_simCollSrx; }
                    ctre::phoenix::motorcontrol::TalonFXSimCollection& GetTalonFXSimCollection() { return *_simCollFx; }
 
                    ctre::phoenix::ErrorCode ConfigurePID(const BaseTalonPIDSetConfiguration& pid, int pidIdx, int timeoutMs, bool enableOptimizations);
 
 
                    //------ All Configs ----------//
                    void GetPIDConfigs(BaseTalonPIDSetConfiguration& pid, int pidIdx = 0, int timeoutMs = 50);
                    ctre::phoenix::ErrorCode BaseTalonConfigAllSettings(const BaseTalonConfiguration& allConfigs, int timeoutMs = 50);
                    void BaseTalonGetAllConfigs(BaseTalonConfiguration& allConfigs, int timeoutMs = 50);
                public:
                    BaseTalon(int deviceNumber, const char* model, std::string const &canbus = "");
                    virtual ~BaseTalon();
                    BaseTalon() = delete;
                    BaseTalon(BaseTalon const&) = delete;
                    BaseTalon& operator=(BaseTalon const&) = delete;
 
                    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);
 
                    virtual ctre::phoenix::ErrorCode SetStatusFramePeriod(StatusFrameEnhanced frame, uint8_t periodMs, int timeoutMs = 0);
                    virtual ctre::phoenix::ErrorCode SetStatusFramePeriod(StatusFrame frame, uint8_t periodMs, int timeoutMs = 0);
 
                    virtual int GetStatusFramePeriod(StatusFrameEnhanced frame, int timeoutMs = 0);
                    virtual int GetStatusFramePeriod(StatusFrame frame, int timeoutMs = 0);
 
                    //------ General Status ----------//
                    virtual double GetOutputCurrent();
 
                    double GetStatorCurrent();
 
                    double GetSupplyCurrent();
 
                    //------ Velocity measurement ----------//
                    virtual ctre::phoenix::ErrorCode ConfigVelocityMeasurementPeriod(ctre::phoenix::sensors::SensorVelocityMeasPeriod period,
                        int timeoutMs = 0);
 
                    [[deprecated("Use the overload with SensorVelocityMeasPeriod instead.")]]
                    virtual ctre::phoenix::ErrorCode ConfigVelocityMeasurementPeriod(VelocityMeasPeriod period,
                        int timeoutMs = 0);
                    virtual ctre::phoenix::ErrorCode ConfigVelocityMeasurementWindow(int windowSize,
                        int timeoutMs = 0);
 
                    //------ limit switch ----------//
                    virtual ctre::phoenix::ErrorCode ConfigForwardLimitSwitchSource(
                        LimitSwitchSource limitSwitchSource,
                        LimitSwitchNormal normalOpenOrClose, int timeoutMs = 0);
                    virtual ctre::phoenix::ErrorCode ConfigForwardLimitSwitchSource(
                        RemoteLimitSwitchSource limitSwitchSource,
                        LimitSwitchNormal normalOpenOrClose, int deviceID, int timeoutMs = 0);
                    virtual ctre::phoenix::ErrorCode ConfigReverseLimitSwitchSource(
                        LimitSwitchSource limitSwitchSource,
                        LimitSwitchNormal normalOpenOrClose, int timeoutMs = 0);
                    virtual ctre::phoenix::ErrorCode ConfigReverseLimitSwitchSource(
                        RemoteLimitSwitchSource limitSwitchSource,
                        LimitSwitchNormal normalOpenOrClose, int deviceID, int timeoutMs = 0);
 
                    //------ Current Limit ----------//
                    virtual ctre::phoenix::ErrorCode ConfigSupplyCurrentLimit(const SupplyCurrentLimitConfiguration& currLimitConfigs, int timeoutMs = 50);
 
                    //------ RAW Sensor API ----------//
                    int IsFwdLimitSwitchClosed();
 
                    int IsRevLimitSwitchClosed();
                };// class BaseTalon
 
            } // namespace can
        } // namespace motorcontrol
    } // namespace phoenix
} // namespace ctre
 
#if defined(WIN32) || defined(_WIN32) || defined(_WIN64)
#pragma warning (pop)
#endif