CoreTalonFX.hpp

Go to the documentation of this file.

/*
 * Copyright (C) Cross The Road Electronics.  All rights reserved.
 * License information can be found in CTRE_LICENSE.txt
 * For support and suggestions contact support@ctr-electronics.com or file
 * an issue tracker at https://github.com/CrossTheRoadElec/Phoenix-Releases
 */
#pragma once
 
#include "ctre/phoenixpro/hardware/ParentDevice.hpp"
#include "ctre/phoenixpro/spns/SpnValue.hpp"
#include "ctre/phoenixpro/Utils.hpp"
#include "ctre/phoenixpro/controls/DutyCycleOut.hpp"
#include "ctre/phoenixpro/controls/TorqueCurrentFOC.hpp"
#include "ctre/phoenixpro/controls/VoltageOut.hpp"
#include "ctre/phoenixpro/controls/PositionDutyCycle.hpp"
#include "ctre/phoenixpro/controls/PositionVoltage.hpp"
#include "ctre/phoenixpro/controls/PositionTorqueCurrentFOC.hpp"
#include "ctre/phoenixpro/controls/VelocityDutyCycle.hpp"
#include "ctre/phoenixpro/controls/VelocityVoltage.hpp"
#include "ctre/phoenixpro/controls/VelocityTorqueCurrentFOC.hpp"
#include "ctre/phoenixpro/controls/MotionMagicDutyCycle.hpp"
#include "ctre/phoenixpro/controls/MotionMagicVoltage.hpp"
#include "ctre/phoenixpro/controls/MotionMagicTorqueCurrentFOC.hpp"
#include "ctre/phoenixpro/controls/Follower.hpp"
#include "ctre/phoenixpro/controls/StrictFollower.hpp"
#include "ctre/phoenixpro/controls/NeutralOut.hpp"
#include "ctre/phoenixpro/controls/CoastOut.hpp"
#include "ctre/phoenixpro/controls/StaticBrake.hpp"
#include "ctre/phoenixpro/sim/TalonFXSimState.hpp"
#include <units/angle.h>
#include <units/angular_acceleration.h>
#include <units/angular_velocity.h>
#include <units/current.h>
#include <units/dimensionless.h>
#include <units/temperature.h>
#include <units/voltage.h>
 
namespace ctre {
namespace phoenixpro {
 
namespace hardware {
namespace core {
    class CoreTalonFX;
}
}
 
namespace configs {
 
/**
 * Class description for the Talon FX integrated motor controller that runs on
 * associated Falcon motors.
 *
 * This handles the configurations for the hardware#TalonFX
 */
class TalonFXConfiguration : public ParentConfiguration
{
public:
    /**
     * \brief True if we should factory default newer unsupported configs,
     *        false to leave newer unsupported configs alone.
     *
     * \details This flag addresses a corner case where the device may have
     *          firmware with newer configs that didn't exist when this
     *          version of the API was built. If this occurs and this
     *          flag is true, unsupported new configs will be factory
     *          defaulted to avoid unexpected behavior.
     *
     *          This is also the behavior in Phoenix 5, so this flag
     *          is defaulted to true to match.
     */
    bool FutureProofConfigs{true};
 
    
    /**
     * \brief  What the gains for slot 0 are
     *
     * \details  If this slot is selected, these gains are used in closed
     *           loop control requests.
     */
    Slot0Configs Slot0;
    
    /**
     * \brief  What the gains for slot 1 are
     *
     * \details  If this slot is selected, these gains are used in closed
     *           loop control requests.
     */
    Slot1Configs Slot1;
    
    /**
     * \brief  What the gains for slot 2 are
     *
     * \details  If this slot is selected, these gains are used in closed
     *           loop control requests.
     */
    Slot2Configs Slot2;
    
    /**
     * \brief  Configs that directly affect motor-output.
     *
     * \details  Includes Motor Invert and various limit features.
     */
    MotorOutputConfigs MotorOutput;
    
    /**
     * \brief  Configs that directly affect current limiting features.
     *
     * \details  Includes Motor Invert and various limit features.
     */
    CurrentLimitsConfigs CurrentLimits;
    
    /**
     * \brief  Voltage-specific configs
     *
     * \details  Voltage-specific configs
     */
    VoltageConfigs Voltage;
    
    /**
     * \brief  Configs that directly affect motor-output.
     *
     * \details  Includes Motor Invert and various limit features.
     */
    TorqueCurrentConfigs TorqueCurrent;
    
    /**
     * \brief  Configs that directly affect motor-output.
     *
     * \details  Includes Motor Invert and various limit features.
     */
    FeedbackConfigs Feedback;
    
    /**
     * \brief  Configs that directly affect motor-output.
     *
     * \details  Includes Motor Invert and various limit features.
     */
    OpenLoopRampsConfigs OpenLoopRamps;
    
    /**
     * \brief  Configs that directly affect motor-output.
     *
     * \details  Includes Motor Invert and various limit features.
     */
    ClosedLoopRampsConfigs ClosedLoopRamps;
    
    /**
     * \brief  Configs that directly affect motor-output.
     *
     * \details  Includes Motor Invert and various limit features.
     */
    HardwareLimitSwitchConfigs HardwareLimitSwitch;
    
    /**
     * \brief  Configs that directly affect motor-output.
     *
     * \details  Includes Motor Invert and various limit features.
     */
    AudioConfigs Audio;
    
    /**
     * \brief  Configs that directly affect motor-output.
     *
     * \details  Includes Motor Invert and various limit features.
     */
    SoftwareLimitSwitchConfigs SoftwareLimitSwitch;
    
    /**
     * \brief  Configs that directly affect motor-output.
     *
     * \details  Includes Motor Invert and various limit features.
     */
    MotionMagicConfigs MotionMagic;
    
    /**
     * \brief  Configs that directly affect motor-output.
     *
     * \details  Includes Motor Invert and various limit features.
     */
    CustomParamsConfigs CustomParams;
    
    /**
     * \brief  Configs that affect general behavior during closed-looping.
     *
     * \details  Includes Continuous Wrap features.
     */
    ClosedLoopGeneralConfigs ClosedLoopGeneral;
 
    /**
     * \brief Get the string representation of this configuration
     */
    std::string ToString() const
    {
        std::stringstream ss;
        ss << Slot0.ToString();
        ss << Slot1.ToString();
        ss << Slot2.ToString();
        ss << MotorOutput.ToString();
        ss << CurrentLimits.ToString();
        ss << Voltage.ToString();
        ss << TorqueCurrent.ToString();
        ss << Feedback.ToString();
        ss << OpenLoopRamps.ToString();
        ss << ClosedLoopRamps.ToString();
        ss << HardwareLimitSwitch.ToString();
        ss << Audio.ToString();
        ss << SoftwareLimitSwitch.ToString();
        ss << MotionMagic.ToString();
        ss << CustomParams.ToString();
        ss << ClosedLoopGeneral.ToString();
        return ss.str();
    }
 
    /**
     * \brief Get the serialized form of this configuration
     */
    std::string Serialize() const
    {
        std::stringstream ss;
        ss << Slot0.Serialize();
        ss << Slot1.Serialize();
        ss << Slot2.Serialize();
        ss << MotorOutput.Serialize();
        ss << CurrentLimits.Serialize();
        ss << Voltage.Serialize();
        ss << TorqueCurrent.Serialize();
        ss << Feedback.Serialize();
        ss << OpenLoopRamps.Serialize();
        ss << ClosedLoopRamps.Serialize();
        ss << HardwareLimitSwitch.Serialize();
        ss << Audio.Serialize();
        ss << SoftwareLimitSwitch.Serialize();
        ss << MotionMagic.Serialize();
        ss << CustomParams.Serialize();
        ss << ClosedLoopGeneral.Serialize();
        return ss.str();
    }
 
    /**
     * \brief Take a string and deserialize it to this configuration
     */
    ctre::phoenix::StatusCode Deserialize(const std::string& string)
    {
        ctre::phoenix::StatusCode err = ctre::phoenix::StatusCode::OK;
        err = Slot0.Deserialize(string);
        err = Slot1.Deserialize(string);
        err = Slot2.Deserialize(string);
        err = MotorOutput.Deserialize(string);
        err = CurrentLimits.Deserialize(string);
        err = Voltage.Deserialize(string);
        err = TorqueCurrent.Deserialize(string);
        err = Feedback.Deserialize(string);
        err = OpenLoopRamps.Deserialize(string);
        err = ClosedLoopRamps.Deserialize(string);
        err = HardwareLimitSwitch.Deserialize(string);
        err = Audio.Deserialize(string);
        err = SoftwareLimitSwitch.Deserialize(string);
        err = MotionMagic.Deserialize(string);
        err = CustomParams.Deserialize(string);
        err = ClosedLoopGeneral.Deserialize(string);
        return err;
    }
};
 
/**
 * Class description for the Talon FX integrated motor controller that runs on
 * associated Falcon motors.
 *
 * This handles the configurations for the hardware#TalonFX
 */
class TalonFXConfigurator : public ParentConfigurator
{
    TalonFXConfigurator (hardware::DeviceIdentifier id):
        ParentConfigurator{std::move(id)}
    {}
 
    friend hardware::core::CoreTalonFX;
public:
 
    /**
     * Delete the copy constructor, we can only pass by reference
     */
    TalonFXConfigurator(const TalonFXConfigurator&) = delete;
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(TalonFXConfiguration& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(TalonFXConfiguration& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const TalonFXConfiguration& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const TalonFXConfiguration& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, configs.FutureProofConfigs, false);
    }
 
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(Slot0Configs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(Slot0Configs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const Slot0Configs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const Slot0Configs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(Slot1Configs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(Slot1Configs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const Slot1Configs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const Slot1Configs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(Slot2Configs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(Slot2Configs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const Slot2Configs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const Slot2Configs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(MotorOutputConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(MotorOutputConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const MotorOutputConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const MotorOutputConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(CurrentLimitsConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(CurrentLimitsConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const CurrentLimitsConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const CurrentLimitsConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(VoltageConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(VoltageConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const VoltageConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const VoltageConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(TorqueCurrentConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(TorqueCurrentConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const TorqueCurrentConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const TorqueCurrentConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(FeedbackConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(FeedbackConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const FeedbackConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const FeedbackConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(OpenLoopRampsConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(OpenLoopRampsConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const OpenLoopRampsConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const OpenLoopRampsConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(ClosedLoopRampsConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(ClosedLoopRampsConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const ClosedLoopRampsConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const ClosedLoopRampsConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(HardwareLimitSwitchConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(HardwareLimitSwitchConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const HardwareLimitSwitchConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const HardwareLimitSwitchConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(AudioConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(AudioConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const AudioConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const AudioConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(SoftwareLimitSwitchConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(SoftwareLimitSwitchConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const SoftwareLimitSwitchConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const SoftwareLimitSwitchConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(MotionMagicConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(MotionMagicConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const MotionMagicConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const MotionMagicConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(CustomParamsConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(CustomParamsConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const CustomParamsConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const CustomParamsConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(ClosedLoopGeneralConfigs& configs) const
    {
        return Refresh(configs, defaultTimeoutSeconds);
    }
    /**
     * \brief Refreshes the values of the specified config group.
     *
     * \details Call to refresh the selected configs from the device.
     *
     * \param configs The configs to refresh
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of refreshing the configs
     */
    ctre::phoenix::StatusCode Refresh(ClosedLoopGeneralConfigs& configs, units::time::second_t timeoutSeconds) const
    {
        std::string ref;
        ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
        configs.Deserialize(ref);
        return ret;
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const ClosedLoopGeneralConfigs& configs)
    {
        return Apply(configs, defaultTimeoutSeconds);
    }
 
    /**
     * \brief Applies the contents of the specified config to the device.
     *
     * \details Call to apply the selected configs.
     *
     * \param configs Configs to apply against.
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode Apply(const ClosedLoopGeneralConfigs& configs, units::time::second_t timeoutSeconds)
    {
        return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
    }
 
    
    /**
     * \brief The position to set the rotor position to right now.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * This is available in the configurator in case the user wants
     * to initialize their device entirely without passing a device
     * reference down to the code that performs the initialization.
     * In this case, the user passes down the configurator object
     * and performs all the initialization code on the object.
     *
     * \param newValue Value to set to.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode SetRotorPosition(units::angle::turn_t newValue)
    {
        return SetRotorPosition(newValue, defaultTimeoutSeconds);
    }
    /**
     * \brief The position to set the rotor position to right now.
     *
     * This is available in the configurator in case the user wants
     * to initialize their device entirely without passing a device
     * reference down to the code that performs the initialization.
     * In this case, the user passes down the configurator object
     * and performs all the initialization code on the object.
     *
     * \param newValue Value to set to.
     * \param timeoutSeconds Maximum time to wait up to in seconds.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode SetRotorPosition(units::angle::turn_t newValue, units::time::second_t timeoutSeconds)
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(1008, newValue.to<double>(), &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return SetConfigsPrivate(ss.str(), timeoutSeconds, false, true);
    }
    
    /**
     * \brief Clear the sticky faults in the device.
     *
     * \details This typically has no impact on the device functionality. 
     * Instead, it just clears telemetry faults that are accessible via
     * API and Tuner Self-Test.
     *
     * This will wait up to #defaultTimeoutSeconds.
     *
     * This is available in the configurator in case the user wants
     * to initialize their device entirely without passing a device
     * reference down to the code that performs the initialization.
     * In this case, the user passes down the configurator object
     * and performs all the initialization code on the object.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode ClearStickyFaults()
    {
        return ClearStickyFaults(defaultTimeoutSeconds);
    }
    /**
     * \brief Clear the sticky faults in the device.
     *
     * \details This typically has no impact on the device functionality. 
     * Instead, it just clears telemetry faults that are accessible via
     * API and Tuner Self-Test.
     *
     * This is available in the configurator in case the user wants
     * to initialize their device entirely without passing a device
     * reference down to the code that performs the initialization.
     * In this case, the user passes down the configurator object
     * and performs all the initialization code on the object.
     * \param timeoutSeconds Maximum time to wait up to in seconds.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode ClearStickyFaults(units::time::second_t timeoutSeconds)
    {
        std::stringstream ss;
        char *ref;
        c_ctre_phoenixpro_serialize_double(1476, 0, &ref); if(ref != nullptr) { ss << ref; free(ref); }
        return SetConfigsPrivate(ss.str(), timeoutSeconds, false, true);
    }
};
 
}
 
namespace hardware {
namespace core {
 
/**
 * Class description for the Talon FX integrated motor controller that runs on
 * associated Falcon motors.
 */
class CoreTalonFX : public ParentDevice
{
private:
    configs::TalonFXConfigurator _configs;
 
    bool _isInitialized = false;
    bool _isVersionOk = false;
    StatusSignalValue<int> &_version = GetVersion();
    double _timeToRefreshVersion = GetCurrentTimeSeconds();
 
    StatusSignalValue<int> &_resetFlags = LookupStatusSignalValue<int>(ctre::phoenixpro::spns::SpnValue::Startup_ResetFlags, "ResetFlags", false);
    units::time::second_t _resetTimestamp{0_s};
 
    double _creationTime = GetCurrentTimeSeconds();
 
    void ReportIfTooOld();
 
    
    /**
     * \brief Proportional output of PID controller when PID'ing under a
     * DutyCycle Request
     *
     *  Minimum Value: -128.0
     *  Maximum Value: 127.9990234375
     *  Default Value: 0
     *  Units: fractional
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDDutyCycle_ProportionalOutput Status Signal Value object
     */
    StatusSignalValue<units::dimensionless::scalar_t> &GetPIDDutyCycle_ProportionalOutput();
    
    /**
     * \brief Proportional output of PID controller when PID'ing under a
     * Voltage Request
     *
     *  Minimum Value: -1310.72
     *  Maximum Value: 1310.71
     *  Default Value: 0
     *  Units: V
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDMotorVoltage_ProportionalOutput Status Signal Value object
     */
    StatusSignalValue<units::voltage::volt_t> &GetPIDMotorVoltage_ProportionalOutput();
    
    /**
     * \brief Proportional output of PID controller when PID'ing under a
     * TorqueCurrent Request
     *
     *  Minimum Value: -13107.2
     *  Maximum Value: 13107.1
     *  Default Value: 0
     *  Units: A
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDTorqueCurrent_ProportionalOutput Status Signal Value object
     */
    StatusSignalValue<units::current::ampere_t> &GetPIDTorqueCurrent_ProportionalOutput();
    
    /**
     * \brief Integrated Accumulator of PID controller when PID'ing under
     * a DutyCycle Request
     *
     *  Minimum Value: -128.0
     *  Maximum Value: 127.9990234375
     *  Default Value: 0
     *  Units: fractional
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDDutyCycle_IntegratedAccum Status Signal Value object
     */
    StatusSignalValue<units::dimensionless::scalar_t> &GetPIDDutyCycle_IntegratedAccum();
    
    /**
     * \brief Integrated Accumulator of PID controller when PID'ing under
     * a Voltage Request
     *
     *  Minimum Value: -1310.72
     *  Maximum Value: 1310.71
     *  Default Value: 0
     *  Units: V
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDMotorVoltage_IntegratedAccum Status Signal Value object
     */
    StatusSignalValue<units::voltage::volt_t> &GetPIDMotorVoltage_IntegratedAccum();
    
    /**
     * \brief Integrated Accumulator of PID controller when PID'ing under
     * a TorqueCurrent Request
     *
     *  Minimum Value: -13107.2
     *  Maximum Value: 13107.1
     *  Default Value: 0
     *  Units: A
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDTorqueCurrent_IntegratedAccum Status Signal Value object
     */
    StatusSignalValue<units::current::ampere_t> &GetPIDTorqueCurrent_IntegratedAccum();
    
    /**
     * \brief Feedforward passed to PID controller
     *
     *  Minimum Value: -2.0
     *  Maximum Value: 1.9990234375
     *  Default Value: 0
     *  Units: fractional
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDDutyCycle_FeedForward Status Signal Value object
     */
    StatusSignalValue<units::dimensionless::scalar_t> &GetPIDDutyCycle_FeedForward();
    
    /**
     * \brief Feedforward passed to PID controller
     *
     *  Minimum Value: -20.48
     *  Maximum Value: 20.47
     *  Default Value: 0
     *  Units: V
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDMotorVoltage_FeedForward Status Signal Value object
     */
    StatusSignalValue<units::voltage::volt_t> &GetPIDMotorVoltage_FeedForward();
    
    /**
     * \brief Feedforward passed to PID controller
     *
     *  Minimum Value: -409.6
     *  Maximum Value: 409.40000000000003
     *  Default Value: 0
     *  Units: A
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDTorqueCurrent_FeedForward Status Signal Value object
     */
    StatusSignalValue<units::current::ampere_t> &GetPIDTorqueCurrent_FeedForward();
    
    /**
     * \brief Derivative Output of PID controller when PID'ing under a
     * DutyCycle Request
     *
     *  Minimum Value: -128.0
     *  Maximum Value: 127.9990234375
     *  Default Value: 0
     *  Units: fractional
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDDutyCycle_DerivativeOutput Status Signal Value object
     */
    StatusSignalValue<units::dimensionless::scalar_t> &GetPIDDutyCycle_DerivativeOutput();
    
    /**
     * \brief Derivative Output of PID controller when PID'ing under a
     * Voltage Request
     *
     *  Minimum Value: -1310.72
     *  Maximum Value: 1310.71
     *  Default Value: 0
     *  Units: V
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDMotorVoltage_DerivativeOutput Status Signal Value object
     */
    StatusSignalValue<units::voltage::volt_t> &GetPIDMotorVoltage_DerivativeOutput();
    
    /**
     * \brief Derivative Output of PID controller when PID'ing under a
     * TorqueCurrent Request
     *
     *  Minimum Value: -13107.2
     *  Maximum Value: 13107.1
     *  Default Value: 0
     *  Units: A
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDTorqueCurrent_DerivativeOutput Status Signal Value object
     */
    StatusSignalValue<units::current::ampere_t> &GetPIDTorqueCurrent_DerivativeOutput();
    
    /**
     * \brief Output of PID controller when PID'ing under a DutyCycle
     * Request
     *
     *  Minimum Value: -128.0
     *  Maximum Value: 127.9990234375
     *  Default Value: 0
     *  Units: fractional
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDDutyCycle_Output Status Signal Value object
     */
    StatusSignalValue<units::dimensionless::scalar_t> &GetPIDDutyCycle_Output();
    
    /**
     * \brief Output of PID controller when PID'ing under a Voltage
     * Request
     *
     *  Minimum Value: -1310.72
     *  Maximum Value: 1310.71
     *  Default Value: 0
     *  Units: V
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDMotorVoltage_Output Status Signal Value object
     */
    StatusSignalValue<units::voltage::volt_t> &GetPIDMotorVoltage_Output();
    
    /**
     * \brief Output of PID controller when PID'ing under a TorqueCurrent
     * Request
     *
     *  Minimum Value: -13107.2
     *  Maximum Value: 13107.1
     *  Default Value: 0
     *  Units: A
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDTorqueCurrent_Output Status Signal Value object
     */
    StatusSignalValue<units::current::ampere_t> &GetPIDTorqueCurrent_Output();
    
    /**
     * \brief Input position of PID controller when PID'ing to a position
     *
     *  Minimum Value: -10000
     *  Maximum Value: 10000
     *  Default Value: 0
     *  Units: rotations
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDPosition_Reference Status Signal Value object
     */
    StatusSignalValue<units::angle::turn_t> &GetPIDPosition_Reference();
    
    /**
     * \brief Input velocity of PID controller when PID'ing to a velocity
     *
     *  Minimum Value: -10000
     *  Maximum Value: 10000
     *  Default Value: 0
     *  Units: rotations per second
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDVelocity_Reference Status Signal Value object
     */
    StatusSignalValue<units::angular_velocity::turns_per_second_t> &GetPIDVelocity_Reference();
    
    /**
     * \brief Change in input (velocity) of PID controller when PID'ing to
     * a position
     *
     *  Minimum Value: -512.0
     *  Maximum Value: 511.984375
     *  Default Value: 0
     *  Units: rotations per second
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDPosition_ReferenceSlope Status Signal Value object
     */
    StatusSignalValue<units::angular_velocity::turns_per_second_t> &GetPIDPosition_ReferenceSlope();
    
    /**
     * \brief Change in input (acceleration) of PID controller when
     * PID'ing to a velocity
     *
     *  Minimum Value: -512.0
     *  Maximum Value: 511.984375
     *  Default Value: 0
     *  Units: rotations per second²
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDVelocity_ReferenceSlope Status Signal Value object
     */
    StatusSignalValue<units::angular_acceleration::turns_per_second_squared_t> &GetPIDVelocity_ReferenceSlope();
    
    /**
     * \brief The difference between target position and current position
     *
     *  Minimum Value: -10000
     *  Maximum Value: 10000
     *  Default Value: 0
     *  Units: rotations
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDPosition_ClosedLoopError Status Signal Value object
     */
    StatusSignalValue<units::angle::turn_t> &GetPIDPosition_ClosedLoopError();
    
    /**
     * \brief The difference between target velocity and current velocity
     *
     *  Minimum Value: -10000
     *  Maximum Value: 10000
     *  Default Value: 0
     *  Units: rotations per second
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  PIDVelocity_ClosedLoopError Status Signal Value object
     */
    StatusSignalValue<units::angular_velocity::turns_per_second_t> &GetPIDVelocity_ClosedLoopError();
public:
    /**
     * Constructs a new Talon FX motor controller object.
     *
     * \param deviceId    ID of the device, as configured in Phoenix Tuner.
     * \param canbus      Name of the CAN bus this device is on. Possible CAN bus strings are:
     *                    - "rio" for the native roboRIO CAN bus
     *                    - CANivore name or serial number
     *                    - SocketCAN interface (non-FRC Linux only)
     *                    - "*" for any CANivore seen by the program
     *                    - empty string (default) to select the default for the system:
     *                      - "rio" on roboRIO
     *                      - "can0" on Linux
     *                      - "*" on Windows
     */
    CoreTalonFX(int deviceId, std::string canbus = "");
 
    CoreTalonFX(CoreTalonFX const &) = delete;
    CoreTalonFX &operator=(CoreTalonFX const &) = delete;
 
    /**
     * \returns true if device has reset since the previous call of this routine.
     */
    bool HasResetOccurred();
 
    /**
     * \brief Gets the configurator for this TalonFX
     *
     * \details Gets the configurator for this TalonFX
     *
     * \returns Configurator for this TalonFX
     */
    configs::TalonFXConfigurator &GetConfigurator()
    {
        return _configs;
    }
 
    /**
     * \brief Gets the configurator for this TalonFX
     *
     * \details Gets the configurator for this TalonFX
     *
     * \returns Configurator for this TalonFX
     */
    configs::TalonFXConfigurator const &GetConfigurator() const
    {
        return _configs;
    }
 
 
private:
    std::unique_ptr<sim::TalonFXSimState> _simState{};
public:
    /**
     * \brief Get the simulation state for this device.
     *
     * \details This function reuses an allocated simulation
     * state object, so it is safe to call this function multiple
     * times in a robot loop.
     *
     * \returns Simulation state
     */
    sim::TalonFXSimState &GetSimState()
    {
        if (_simState == nullptr)
            _simState = std::make_unique<sim::TalonFXSimState>(*this);
        return *_simState;
    }
 
 
    
    /**
     * \brief App Major Version number.
     *
     *  Minimum Value: 0
     *  Maximum Value: 255
     *  Default Value: 0
     *  Units: 
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  VersionMajor Status Signal Value object
     */
    StatusSignalValue<int> &GetVersionMajor();
    
    /**
     * \brief App Minor Version number.
     *
     *  Minimum Value: 0
     *  Maximum Value: 255
     *  Default Value: 0
     *  Units: 
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  VersionMinor Status Signal Value object
     */
    StatusSignalValue<int> &GetVersionMinor();
    
    /**
     * \brief App Bugfix Version number.
     *
     *  Minimum Value: 0
     *  Maximum Value: 255
     *  Default Value: 0
     *  Units: 
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  VersionBugfix Status Signal Value object
     */
    StatusSignalValue<int> &GetVersionBugfix();
    
    /**
     * \brief App Build Version number.
     *
     *  Minimum Value: 0
     *  Maximum Value: 255
     *  Default Value: 0
     *  Units: 
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  VersionBuild Status Signal Value object
     */
    StatusSignalValue<int> &GetVersionBuild();
    
    /**
     * \brief Full Version.  The format is a four byte value.
     *
     * \details Full Version of firmware in device. The format is a four
     * byte value.
     *
     *  Minimum Value: 0
     *  Maximum Value: 4294967295
     *  Default Value: 0
     *  Units: 
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Version Status Signal Value object
     */
    StatusSignalValue<int> &GetVersion();
    
    /**
     * \brief Integer representing all faults
     *
     * \details This returns the fault flags reported by the device. These
     * are device specific and are not used directly in typical
     * applications. Use the signal specific GetFault_*() methods instead.
     *  
     *
     *  Minimum Value: 0
     *  Maximum Value: 1048575
     *  Default Value: 0
     *  Units: 
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  FaultField Status Signal Value object
     */
    StatusSignalValue<int> &GetFaultField();
    
    /**
     * \brief Integer representing all sticky faults
     *
     * \details This returns the persistent "sticky" fault flags reported
     * by the device. These are device specific and are not used directly
     * in typical applications. Use the signal specific GetStickyFault_*()
     * methods instead.  
     *
     *  Minimum Value: 0
     *  Maximum Value: 1048575
     *  Default Value: 0
     *  Units: 
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFaultField Status Signal Value object
     */
    StatusSignalValue<int> &GetStickyFaultField();
    
    /**
     * \brief Forward Limit Pin.
     *
     *
     * Default Rates:
     *  CAN: 100.0 Hz
     *
     * \returns  ForwardLimit Status Signal Value object
     */
    StatusSignalValue<signals::ForwardLimitValue> &GetForwardLimit();
    
    /**
     * \brief Reverse Limit Pin.
     *
     *
     * Default Rates:
     *  CAN: 100.0 Hz
     *
     * \returns  ReverseLimit Status Signal Value object
     */
    StatusSignalValue<signals::ReverseLimitValue> &GetReverseLimit();
    
    /**
     * \brief The applied rotor polarity.  This typically is determined by
     * the Inverted config, but can be overridden if using Follower
     * features.
     *
     *
     * Default Rates:
     *  CAN: 100.0 Hz
     *
     * \returns  AppliedRotorPolarity Status Signal Value object
     */
    StatusSignalValue<signals::AppliedRotorPolarityValue> &GetAppliedRotorPolarity();
    
    /**
     * \brief The applied motor duty cycle.
     *
     *  Minimum Value: -2.0
     *  Maximum Value: 1.9990234375
     *  Default Value: 0
     *  Units: fractional
     *
     * Default Rates:
     *  CAN: 100.0 Hz
     *
     * \returns  DutyCycle Status Signal Value object
     */
    StatusSignalValue<units::dimensionless::scalar_t> &GetDutyCycle();
    
    /**
     * \brief Current corresponding to the torque output by the motor.
     * Similar to StatorCurrent. Users will likely prefer this current to
     * calculate the applied torque to the rotor.
     *
     * \details Stator current where positive current means torque is
     * applied in the forward direction as determined by the Inverted
     * setting
     *
     *  Minimum Value: -327.68
     *  Maximum Value: 327.67
     *  Default Value: 0
     *  Units: A
     *
     * Default Rates:
     *  CAN: 100.0 Hz
     *
     * \returns  TorqueCurrent Status Signal Value object
     */
    StatusSignalValue<units::current::ampere_t> &GetTorqueCurrent();
    
    /**
     * \brief Current corresponding to the stator windings. Similar to
     * TorqueCurrent. Users will likely prefer TorqueCurrent over
     * StatorCurrent.
     *
     * \details Stator current where Positive current indicates motoring
     * regardless of direction. Negative current indicates regenerative
     * braking regardless of direction.
     *
     *  Minimum Value: -327.68
     *  Maximum Value: 327.67
     *  Default Value: 0
     *  Units: A
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  StatorCurrent Status Signal Value object
     */
    StatusSignalValue<units::current::ampere_t> &GetStatorCurrent();
    
    /**
     * \brief Measured supply side current
     *
     *  Minimum Value: -327.68
     *  Maximum Value: 327.67
     *  Default Value: 0
     *  Units: A
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  SupplyCurrent Status Signal Value object
     */
    StatusSignalValue<units::current::ampere_t> &GetSupplyCurrent();
    
    /**
     * \brief Measured supply voltage to the TalonFX.
     *
     *  Minimum Value: 4.0
     *  Maximum Value: 16.75
     *  Default Value: 4
     *  Units: V
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  SupplyVoltage Status Signal Value object
     */
    StatusSignalValue<units::voltage::volt_t> &GetSupplyVoltage();
    
    /**
     * \brief Temperature of device
     *
     * \details This is the temperature that the device measures itself to
     * be at. Similar to Processor Temperature.
     *
     *  Minimum Value: 0.0
     *  Maximum Value: 255.0
     *  Default Value: 0
     *  Units: ℃
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  DeviceTemp Status Signal Value object
     */
    StatusSignalValue<units::temperature::celsius_t> &GetDeviceTemp();
    
    /**
     * \brief Temperature of the processor
     *
     * \details This is the temperature that the processor measures itself
     * to be at. Similar to Device Temperature.
     *
     *  Minimum Value: 0.0
     *  Maximum Value: 255.0
     *  Default Value: 0
     *  Units: ℃
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  ProcessorTemp Status Signal Value object
     */
    StatusSignalValue<units::temperature::celsius_t> &GetProcessorTemp();
    
    /**
     * \brief Velocity of motor rotor.
     *
     *  Minimum Value: -512.0
     *  Maximum Value: 511.998046875
     *  Default Value: 0
     *  Units: rotations per second
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  RotorVelocity Status Signal Value object
     */
    StatusSignalValue<units::angular_velocity::turns_per_second_t> &GetRotorVelocity();
    
    /**
     * \brief Position of motor rotor.
     *
     *  Minimum Value: -16384.0
     *  Maximum Value: 16383.999755859375
     *  Default Value: 0
     *  Units: rotations
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  RotorPosition Status Signal Value object
     */
    StatusSignalValue<units::angle::turn_t> &GetRotorPosition();
    
    /**
     * \brief Velocity of device.
     *
     *  Minimum Value: -512.0
     *  Maximum Value: 511.998046875
     *  Default Value: 0
     *  Units: rotations per second
     *
     * Default Rates:
     *  CAN 2.0: 50.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  Velocity Status Signal Value object
     */
    StatusSignalValue<units::angular_velocity::turns_per_second_t> &GetVelocity();
    
    /**
     * \brief Position of device.
     *
     *  Minimum Value: -16384.0
     *  Maximum Value: 16383.999755859375
     *  Default Value: 0
     *  Units: rotations
     *
     * Default Rates:
     *  CAN 2.0: 50.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  Position Status Signal Value object
     */
    StatusSignalValue<units::angle::turn_t> &GetPosition();
    
    /**
     * \brief The active control mode of the motor controller
     *
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  ControlMode Status Signal Value object
     */
    StatusSignalValue<signals::ControlModeValue> &GetControlMode();
    
    /**
     * \brief Check if Motion Magic® is running.  This is equivalent to
     * checking that the reported control mode is a Motion Magic® based
     * mode.
     *
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  MotionMagicIsRunning Status Signal Value object
     */
    StatusSignalValue<signals::MotionMagicIsRunningValue> &GetMotionMagicIsRunning();
    
    /**
     * \brief Indicates if device is actuator enabled.
     *
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  DeviceEnable Status Signal Value object
     */
    StatusSignalValue<signals::DeviceEnableValue> &GetDeviceEnable();
    
    /**
     * \brief Closed loop slot in use
     *
     * \details This is the slot that the closed loop PID is using.
     *
     *  Minimum Value: 0
     *  Maximum Value: 2
     *  Default Value: 0
     *  Units: 
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  ClosedLoopSlot Status Signal Value object
     */
    StatusSignalValue<int> &GetClosedLoopSlot();
    
    /**
     * \brief The applied output of the bridge.
     *
     *
     * Default Rates:
     *  CAN: 100.0 Hz
     *
     * \returns  BridgeOuput Status Signal Value object
     */
    StatusSignalValue<signals::BridgeOuputValue> &GetBridgeOuput();
    
    /**
     * \brief Hardware fault occurred
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_Hardware Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_Hardware();
    
    /**
     * \brief Hardware fault occurred
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_Hardware Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_Hardware();
    
    /**
     * \brief Processor temperature exceeded limit
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_ProcTemp Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_ProcTemp();
    
    /**
     * \brief Processor temperature exceeded limit
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_ProcTemp Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_ProcTemp();
    
    /**
     * \brief Device temperature exceeded limit
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_DeviceTemp Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_DeviceTemp();
    
    /**
     * \brief Device temperature exceeded limit
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_DeviceTemp Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_DeviceTemp();
    
    /**
     * \brief Device supply voltage dropped to near brownout levels
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_Undervoltage Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_Undervoltage();
    
    /**
     * \brief Device supply voltage dropped to near brownout levels
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_Undervoltage Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_Undervoltage();
    
    /**
     * \brief Device boot while detecting the enable signal
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_BootDuringEnable Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_BootDuringEnable();
    
    /**
     * \brief Device boot while detecting the enable signal
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_BootDuringEnable Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_BootDuringEnable();
    
    /**
     * \brief Supply Voltage has exceeded the maximum voltage rating of
     * device.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_OverSupplyV Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_OverSupplyV();
    
    /**
     * \brief Supply Voltage has exceeded the maximum voltage rating of
     * device.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_OverSupplyV Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_OverSupplyV();
    
    /**
     * \brief Supply Voltage is unstable.  Ensure you are using a battery
     * and current limited power supply.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_UnstableSupplyV Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_UnstableSupplyV();
    
    /**
     * \brief Supply Voltage is unstable.  Ensure you are using a battery
     * and current limited power supply.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_UnstableSupplyV Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_UnstableSupplyV();
    
    /**
     * \brief Reverse limit switch has been asserted.  Output is set to
     * neutral.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_ReverseHardLimit Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_ReverseHardLimit();
    
    /**
     * \brief Reverse limit switch has been asserted.  Output is set to
     * neutral.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_ReverseHardLimit Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_ReverseHardLimit();
    
    /**
     * \brief Forward limit switch has been asserted.  Output is set to
     * neutral.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_ForwardHardLimit Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_ForwardHardLimit();
    
    /**
     * \brief Forward limit switch has been asserted.  Output is set to
     * neutral.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_ForwardHardLimit Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_ForwardHardLimit();
    
    /**
     * \brief Reverse soft limit has been asserted.  Output is set to
     * neutral.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_ReverseSoftLimit Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_ReverseSoftLimit();
    
    /**
     * \brief Reverse soft limit has been asserted.  Output is set to
     * neutral.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_ReverseSoftLimit Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_ReverseSoftLimit();
    
    /**
     * \brief Forward soft limit has been asserted.  Output is set to
     * neutral.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_ForwardSoftLimit Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_ForwardSoftLimit();
    
    /**
     * \brief Forward soft limit has been asserted.  Output is set to
     * neutral.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_ForwardSoftLimit Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_ForwardSoftLimit();
    
    /**
     * \brief The remote sensor is not present on CAN Bus.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_MissingRemoteSensor Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_MissingRemoteSensor();
    
    /**
     * \brief The remote sensor is not present on CAN Bus.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_MissingRemoteSensor Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_MissingRemoteSensor();
    
    /**
     * \brief The remote sensor used for fusion has fallen out of sync to
     * the local sensor. A re-synchronization has occurred, which may
     * cause a discontinuity. This typically happens if there is
     * significant slop in the mechanism, or if the RotorToSensorRatio
     * configuration parameter is incorrect.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_FusedSensorOutOfSync Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_FusedSensorOutOfSync();
    
    /**
     * \brief The remote sensor used for fusion has fallen out of sync to
     * the local sensor. A re-synchronization has occurred, which may
     * cause a discontinuity. This typically happens if there is
     * significant slop in the mechanism, or if the RotorToSensorRatio
     * configuration parameter is incorrect.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_FusedSensorOutOfSync Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_FusedSensorOutOfSync();
    
    /**
     * \brief Stator current limit occured.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_StatorCurrLimit Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_StatorCurrLimit();
    
    /**
     * \brief Stator current limit occured.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_StatorCurrLimit Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_StatorCurrLimit();
    
    /**
     * \brief Supply current limit occured.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  Fault_SupplyCurrLimit Status Signal Value object
     */
    StatusSignalValue<bool> &GetFault_SupplyCurrLimit();
    
    /**
     * \brief Supply current limit occured.
     *
     *  Default Value: False
     *
     * Default Rates:
     *  CAN: 4.0 Hz
     *
     * \returns  StickyFault_SupplyCurrLimit Status Signal Value object
     */
    StatusSignalValue<bool> &GetStickyFault_SupplyCurrLimit();
    
    /**
     * \brief Closed loop proportional component
     *
     * \details The portion of the closed loop output that is the
     * proportional to the error. Alternatively, the p-Contribution of the
     * closed loop output.
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  ClosedLoopProportionalOutput Status Signal Value object
     */
    StatusSignalValue<double> &GetClosedLoopProportionalOutput();
    
    /**
     * \brief Closed loop integrated component
     *
     * \details The portion of the closed loop output that is proportional
     * to the integrated error. Alternatively, the i-Contribution of the
     * closed loop output.
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  ClosedLoopIntegratedOutput Status Signal Value object
     */
    StatusSignalValue<double> &GetClosedLoopIntegratedOutput();
    
    /**
     * \brief Feed Forward passed by the user
     *
     * \details This is the general feed forward that the user provides
     * for the closed loop.
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  ClosedLoopFeedForward Status Signal Value object
     */
    StatusSignalValue<double> &GetClosedLoopFeedForward();
    
    /**
     * \brief Closed loop derivative component
     *
     * \details The portion of the closed loop output that is the
     * proportional to the deriviative the error. Alternatively, the
     * d-Contribution of the closed loop output.
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  ClosedLoopDerivativeOutput Status Signal Value object
     */
    StatusSignalValue<double> &GetClosedLoopDerivativeOutput();
    
    /**
     * \brief Closed loop total output
     *
     * \details The total output of the closed loop output.
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  ClosedLoopOutput Status Signal Value object
     */
    StatusSignalValue<double> &GetClosedLoopOutput();
    
    /**
     * \brief Value that the closed loop is targeting
     *
     * \details This is the value that the closed loop PID controller
     * targets.
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  ClosedLoopReference Status Signal Value object
     */
    StatusSignalValue<double> &GetClosedLoopReference();
    
    /**
     * \brief Derivative of the target that the closed loop is targeting
     *
     * \details This is the change in the closed loop reference. This may
     * be used in the feed-forward calculation, the derivative-error, or
     * in application of the signage for kS. Typically, this represents
     * the target velocity during Motion Magic®.
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  ClosedLoopReferenceSlope Status Signal Value object
     */
    StatusSignalValue<double> &GetClosedLoopReferenceSlope();
    
    /**
     * \brief The difference between target reference and current
     * measurement
     *
     * \details This is the value that is treated as the error in the PID
     * loop.
     *
     * Default Rates:
     *  CAN 2.0: 5.0 Hz
     *  CAN FD: 100.0 Hz
     *
     * \returns  ClosedLoopError Status Signal Value object
     */
    StatusSignalValue<double> &GetClosedLoopError();
 
    
    /**
     * \brief Request a specified motor duty cycle.
     *
     * \details This control mode will output a proportion of the supplied
     * voltage which is supplied by the user.
     *
     * DutyCycleOut Parameters: 
     *  Output: Proportion of supply voltage to apply in fractional units between -1
     *        and +1
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::DutyCycleOut& request);
    /**
     * \brief Request a specified motor duty cycle.
     *
     * \details This control mode will output a proportion of the supplied
     * voltage which is supplied by the user.
     *
     * DutyCycleOut Parameters: 
     *  Output: Proportion of supply voltage to apply in fractional units between -1
     *        and +1
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::DutyCycleOut&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Request a specified motor current (field oriented control).
     *
     * \details This control request will drive the motor to the requested
     * motor (stator) current value.  This leverages field oriented
     * control (FOC), which means greater peak power than what is
     * documented.  This scales to torque based on Motor's kT constant.
     *
     * TorqueCurrentFOC Parameters: 
     *  Output: Amount of motor current in Amperes
     *  MaxAbsDutyCycle: The maximum absolute motor output that can be applied, which
     *                 effectively limits the velocity. For example, 0.50 means no
     *                 more than 50% output in either direction.  This is useful for
     *                 preventing the motor from spinning to its terminal velocity
     *                 when there is no external torque applied unto the rotor. 
     *                 Note this is absolute maximum, so the value should be between
     *                 zero and one.
     *  Deadband: Deadband in Amperes.  If torque request is within deadband, the
     *          bridge output is neutral. If deadband is set to zero then there is
     *          effectively no deadband. Note if deadband is zero, a free spinning
     *          motor will spin for quite a while as the firmware attempts to hold
     *          the motor's bemf. If user expects motor to cease spinning quickly
     *          with a demand of zero, we recommend a deadband of one Ampere. This
     *          value will be converted to an integral value of amps.
     *  OverrideCoastDurNeutral: Set to true to coast the rotor when output is zero
     *                         (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0A (zero torque).
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::TorqueCurrentFOC& request);
    /**
     * \brief Request a specified motor current (field oriented control).
     *
     * \details This control request will drive the motor to the requested
     * motor (stator) current value.  This leverages field oriented
     * control (FOC), which means greater peak power than what is
     * documented.  This scales to torque based on Motor's kT constant.
     *
     * TorqueCurrentFOC Parameters: 
     *  Output: Amount of motor current in Amperes
     *  MaxAbsDutyCycle: The maximum absolute motor output that can be applied, which
     *                 effectively limits the velocity. For example, 0.50 means no
     *                 more than 50% output in either direction.  This is useful for
     *                 preventing the motor from spinning to its terminal velocity
     *                 when there is no external torque applied unto the rotor. 
     *                 Note this is absolute maximum, so the value should be between
     *                 zero and one.
     *  Deadband: Deadband in Amperes.  If torque request is within deadband, the
     *          bridge output is neutral. If deadband is set to zero then there is
     *          effectively no deadband. Note if deadband is zero, a free spinning
     *          motor will spin for quite a while as the firmware attempts to hold
     *          the motor's bemf. If user expects motor to cease spinning quickly
     *          with a demand of zero, we recommend a deadband of one Ampere. This
     *          value will be converted to an integral value of amps.
     *  OverrideCoastDurNeutral: Set to true to coast the rotor when output is zero
     *                         (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0A (zero torque).
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::TorqueCurrentFOC&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Request a specified voltage.
     *
     * \details This control mode will attempt to apply the specified
     * voltage to the motor. If the supply voltage is below the requested
     * voltage, the motor controller will output the supply voltage.
     *
     * VoltageOut Parameters: 
     *  Output: Voltage to attempt to drive at
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::VoltageOut& request);
    /**
     * \brief Request a specified voltage.
     *
     * \details This control mode will attempt to apply the specified
     * voltage to the motor. If the supply voltage is below the requested
     * voltage, the motor controller will output the supply voltage.
     *
     * VoltageOut Parameters: 
     *  Output: Voltage to attempt to drive at
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::VoltageOut&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Request PID to target position with duty cycle feedforward.
     *
     * \details This control mode will set the motor's position setpoint
     * to the position specified by the user. In addition, it will apply
     * an additional duty cycle as an arbitrary feedforward value.
     *
     * PositionDutyCycle Parameters: 
     *  Position: Position to drive toward in rotations.
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  FeedForward: Feedforward to apply in fractional units between -1 and +1.
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::PositionDutyCycle& request);
    /**
     * \brief Request PID to target position with duty cycle feedforward.
     *
     * \details This control mode will set the motor's position setpoint
     * to the position specified by the user. In addition, it will apply
     * an additional duty cycle as an arbitrary feedforward value.
     *
     * PositionDutyCycle Parameters: 
     *  Position: Position to drive toward in rotations.
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  FeedForward: Feedforward to apply in fractional units between -1 and +1.
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::PositionDutyCycle&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Request PID to target position with voltage feedforward
     *
     * \details This control mode will set the motor's position setpoint
     * to the position specified by the user. In addition, it will apply
     * an additional voltage as an arbitrary feedforward value.
     *
     * PositionVoltage Parameters: 
     *  Position: Position to drive toward in rotations.
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  FeedForward: Feedforward to apply in volts
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::PositionVoltage& request);
    /**
     * \brief Request PID to target position with voltage feedforward
     *
     * \details This control mode will set the motor's position setpoint
     * to the position specified by the user. In addition, it will apply
     * an additional voltage as an arbitrary feedforward value.
     *
     * PositionVoltage Parameters: 
     *  Position: Position to drive toward in rotations.
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  FeedForward: Feedforward to apply in volts
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::PositionVoltage&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Request PID to target position with torque current
     * feedforward.
     *
     * \details This control mode will set the motor's position setpoint
     * to the position specified by the user. In addition, it will apply
     * an additional torque current as an arbitrary feedforward value.
     *
     * PositionTorqueCurrentFOC Parameters: 
     *  Position: Position to drive toward in rotations.
     *  FeedForward: Feedforward to apply in torque current in Amperes.  User can use
     *             motor's kT to scale Newton-meter to Amperes.
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideCoastDurNeutral: Set to true to coast the rotor when output is zero
     *                         (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0A (zero torque).
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::PositionTorqueCurrentFOC& request);
    /**
     * \brief Request PID to target position with torque current
     * feedforward.
     *
     * \details This control mode will set the motor's position setpoint
     * to the position specified by the user. In addition, it will apply
     * an additional torque current as an arbitrary feedforward value.
     *
     * PositionTorqueCurrentFOC Parameters: 
     *  Position: Position to drive toward in rotations.
     *  FeedForward: Feedforward to apply in torque current in Amperes.  User can use
     *             motor's kT to scale Newton-meter to Amperes.
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideCoastDurNeutral: Set to true to coast the rotor when output is zero
     *                         (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0A (zero torque).
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::PositionTorqueCurrentFOC&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Request PID to target velocity with duty cycle feedforward.
     *
     * \details This control mode will set the motor's velocity setpoint
     * to the velocity specified by the user. In addition, it will apply
     * an additional voltage as an arbitrary feedforward value.
     *
     * VelocityDutyCycle Parameters: 
     *  Velocity: Velocity to drive toward in rotations per second.
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  FeedForward: Feedforward to apply in fractional units between -1 and +1.
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::VelocityDutyCycle& request);
    /**
     * \brief Request PID to target velocity with duty cycle feedforward.
     *
     * \details This control mode will set the motor's velocity setpoint
     * to the velocity specified by the user. In addition, it will apply
     * an additional voltage as an arbitrary feedforward value.
     *
     * VelocityDutyCycle Parameters: 
     *  Velocity: Velocity to drive toward in rotations per second.
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  FeedForward: Feedforward to apply in fractional units between -1 and +1.
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::VelocityDutyCycle&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Request PID to target velocity with voltage feedforward.
     *
     * \details This control mode will set the motor's velocity setpoint
     * to the velocity specified by the user. In addition, it will apply
     * an additional voltage as an arbitrary feedforward value.
     *
     * VelocityVoltage Parameters: 
     *  Velocity: Velocity to drive toward in rotations per second.
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  FeedForward: Feedforward to apply in volts
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::VelocityVoltage& request);
    /**
     * \brief Request PID to target velocity with voltage feedforward.
     *
     * \details This control mode will set the motor's velocity setpoint
     * to the velocity specified by the user. In addition, it will apply
     * an additional voltage as an arbitrary feedforward value.
     *
     * VelocityVoltage Parameters: 
     *  Velocity: Velocity to drive toward in rotations per second.
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  FeedForward: Feedforward to apply in volts
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::VelocityVoltage&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Request PID to target velocity with torque current
     * feedforward.
     *
     * \details This control mode will set the motor's velocity setpoint
     * to the velocity specified by the user. In addition, it will apply
     * an additional torque current as an arbitrary feedforward value.
     *
     * VelocityTorqueCurrentFOC Parameters: 
     *  Velocity: Velocity to drive toward in rotations per second.
     *  FeedForward: Feedforward to apply in torque current in Amperes.  User can use
     *             motor's kT to scale Newton-meter to Amperes.
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideCoastDurNeutral: Set to true to coast the rotor when output is zero
     *                         (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0A (zero torque).
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::VelocityTorqueCurrentFOC& request);
    /**
     * \brief Request PID to target velocity with torque current
     * feedforward.
     *
     * \details This control mode will set the motor's velocity setpoint
     * to the velocity specified by the user. In addition, it will apply
     * an additional torque current as an arbitrary feedforward value.
     *
     * VelocityTorqueCurrentFOC Parameters: 
     *  Velocity: Velocity to drive toward in rotations per second.
     *  FeedForward: Feedforward to apply in torque current in Amperes.  User can use
     *             motor's kT to scale Newton-meter to Amperes.
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideCoastDurNeutral: Set to true to coast the rotor when output is zero
     *                         (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0A (zero torque).
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::VelocityTorqueCurrentFOC&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Requests Motion Magic® to target a final position using a
     * motion profile.  Users can optionally provide a duty cycle
     * feedforward.
     *
     * \details Motion Magic® produces a motion profile in real-time while
     * attempting to honor the Cruise Velocity, Acceleration, and Jerk
     * value specified via the Motion Magic® configuration values.  Target
     * position can be changed on-the-fly and Motion Magic® will do its
     * best to adjust the profile.  This control mode is duty cycled
     * based, so relevant closed-loop gains will use fractional duty cycle
     * for the numerator:  +1.0 represents full forward output.
     *
     * MotionMagicDutyCycle Parameters: 
     *  Position: Position to drive toward in rotations.
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  FeedForward: Feedforward to apply in fractional units between -1 and +1.
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::MotionMagicDutyCycle& request);
    /**
     * \brief Requests Motion Magic® to target a final position using a
     * motion profile.  Users can optionally provide a duty cycle
     * feedforward.
     *
     * \details Motion Magic® produces a motion profile in real-time while
     * attempting to honor the Cruise Velocity, Acceleration, and Jerk
     * value specified via the Motion Magic® configuration values.  Target
     * position can be changed on-the-fly and Motion Magic® will do its
     * best to adjust the profile.  This control mode is duty cycled
     * based, so relevant closed-loop gains will use fractional duty cycle
     * for the numerator:  +1.0 represents full forward output.
     *
     * MotionMagicDutyCycle Parameters: 
     *  Position: Position to drive toward in rotations.
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  FeedForward: Feedforward to apply in fractional units between -1 and +1.
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::MotionMagicDutyCycle&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Requests Motion Magic® to target a final position using a
     * motion profile.  Users can optionally provide a voltage
     * feedforward.
     *
     * \details Motion Magic® produces a motion profile in real-time while
     * attempting to honor the Cruise Velocity, Acceleration, and Jerk
     * value specified via the Motion Magic® configuration values.  Target
     * position can be changed on-the-fly and Motion Magic® will do its
     * best to adjust the profile.  This control mode is voltage-based, so
     * relevant closed-loop gains will use Volts for the numerator.
     *
     * MotionMagicVoltage Parameters: 
     *  Position: Position to drive toward in rotations.
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  FeedForward: Feedforward to apply in volts
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::MotionMagicVoltage& request);
    /**
     * \brief Requests Motion Magic® to target a final position using a
     * motion profile.  Users can optionally provide a voltage
     * feedforward.
     *
     * \details Motion Magic® produces a motion profile in real-time while
     * attempting to honor the Cruise Velocity, Acceleration, and Jerk
     * value specified via the Motion Magic® configuration values.  Target
     * position can be changed on-the-fly and Motion Magic® will do its
     * best to adjust the profile.  This control mode is voltage-based, so
     * relevant closed-loop gains will use Volts for the numerator.
     *
     * MotionMagicVoltage Parameters: 
     *  Position: Position to drive toward in rotations.
     *  EnableFOC: Set to true to use FOC commutation, which increases peak power by
     *           ~15%. Set to false to use trapezoidal commutation.  FOC improves
     *           motor performance by leveraging torque (current) control.  However,
     *           this may be inconvenient for applications that require specifying
     *           duty cycle or voltage.  CTR-Electronics has developed a hybrid
     *           method that combines the performances gains of FOC while still
     *           allowing applications to provide duty cycle or voltage demand. 
     *           This not to be confused with simple sinusoidal control or phase
     *           voltage control which lacks the performance gains.
     *  FeedForward: Feedforward to apply in volts
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideBrakeDurNeutral: Set to true to static-brake the rotor when output is
     *                         zero (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0V to the motor.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::MotionMagicVoltage&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Requests Motion Magic® to target a final position using a
     * motion profile.  Users can optionally provide a torque current
     * feedforward.
     *
     * \details Motion Magic® produces a motion profile in real-time while
     * attempting to honor the Cruise Velocity, Acceleration, and Jerk
     * value specified via the Motion Magic® configuration values.  Target
     * position can be changed on-the-fly and Motion Magic® will do its
     * best to adjust the profile.  This control mode is based on torque
     * current, so relevant closed-loop gains will use Amperes for the
     * numerator.
     *
     * MotionMagicTorqueCurrentFOC Parameters: 
     *  Position: Position to drive toward in rotations.
     *  FeedForward: Feedforward to apply in torque current in Amperes.  User can use
     *             motor's kT to scale Newton-meter to Amperes.
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideCoastDurNeutral: Set to true to coast the rotor when output is zero
     *                         (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0A (zero torque).
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::MotionMagicTorqueCurrentFOC& request);
    /**
     * \brief Requests Motion Magic® to target a final position using a
     * motion profile.  Users can optionally provide a torque current
     * feedforward.
     *
     * \details Motion Magic® produces a motion profile in real-time while
     * attempting to honor the Cruise Velocity, Acceleration, and Jerk
     * value specified via the Motion Magic® configuration values.  Target
     * position can be changed on-the-fly and Motion Magic® will do its
     * best to adjust the profile.  This control mode is based on torque
     * current, so relevant closed-loop gains will use Amperes for the
     * numerator.
     *
     * MotionMagicTorqueCurrentFOC Parameters: 
     *  Position: Position to drive toward in rotations.
     *  FeedForward: Feedforward to apply in torque current in Amperes.  User can use
     *             motor's kT to scale Newton-meter to Amperes.
     *  Slot: Select which gains are applied by selecting the slot.  Use the
     *      configuration api to set the gain values for the selected slot before
     *      enabling this feature. Slot must be within [0,2].
     *  OverrideCoastDurNeutral: Set to true to coast the rotor when output is zero
     *                         (or within deadband).  Set to false to use the
     *                         NeutralMode configuration setting (default). This
     *                         flag exists to provide the fundamental behavior of
     *                         this control when output is zero, which is to provide
     *                         0A (zero torque).
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::MotionMagicTorqueCurrentFOC&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Follow the motor output of another Talon.
     *
     * \details If Talon is in torque control, the torque is copied -
     * which will increase the total torque applied. If Talon is in
     * percent supply output control, the duty cycle is matched.  Motor
     * direction either matches master's configured direction or opposes
     * it based on OpposeMasterDirection.
     *
     * Follower Parameters: 
     *  MasterID: Device ID of the master to follow.
     *  OpposeMasterDirection: Set to false for motor invert to match the master's
     *                       configured Invert - which is typical when master and
     *                       follower are mechanically linked and spin in the same
     *                       direction.  Set to true for motor invert to oppose the
     *                       master's configured Invert - this is typical where the
     *                       the master and follower mechanically spin in opposite
     *                       directions.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::Follower& request);
    /**
     * \brief Follow the motor output of another Talon.
     *
     * \details If Talon is in torque control, the torque is copied -
     * which will increase the total torque applied. If Talon is in
     * percent supply output control, the duty cycle is matched.  Motor
     * direction either matches master's configured direction or opposes
     * it based on OpposeMasterDirection.
     *
     * Follower Parameters: 
     *  MasterID: Device ID of the master to follow.
     *  OpposeMasterDirection: Set to false for motor invert to match the master's
     *                       configured Invert - which is typical when master and
     *                       follower are mechanically linked and spin in the same
     *                       direction.  Set to true for motor invert to oppose the
     *                       master's configured Invert - this is typical where the
     *                       the master and follower mechanically spin in opposite
     *                       directions.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::Follower&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Follow the motor output of another Talon while ignoring the
     * master's invert setting.
     *
     * \details If Talon is in torque control, the torque is copied -
     * which will increase the total torque applied. If Talon is in
     * percent supply output control, the duty cycle is matched.  Motor
     * direction is strictly determined by the configured invert and not
     * the master.  If you want motor direction to match or oppose the
     * master, use FollowerRequest instead.
     *
     * StrictFollower Parameters: 
     *  MasterID: Device ID of the master to follow.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::StrictFollower& request);
    /**
     * \brief Follow the motor output of another Talon while ignoring the
     * master's invert setting.
     *
     * \details If Talon is in torque control, the torque is copied -
     * which will increase the total torque applied. If Talon is in
     * percent supply output control, the duty cycle is matched.  Motor
     * direction is strictly determined by the configured invert and not
     * the master.  If you want motor direction to match or oppose the
     * master, use FollowerRequest instead.
     *
     * StrictFollower Parameters: 
     *  MasterID: Device ID of the master to follow.
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::StrictFollower&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Request neutral output of actuator. The applied brake type
     * is determined by the NeutralMode configuration.
     *
     * NeutralOut Parameters: 
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::NeutralOut& request);
    /**
     * \brief Request neutral output of actuator. The applied brake type
     * is determined by the NeutralMode configuration.
     *
     * NeutralOut Parameters: 
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::NeutralOut&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Request coast neutral output of actuator.  The bridge is
     * disabled and the rotor is allowed to coast.
     *
     * CoastOut Parameters: 
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::CoastOut& request);
    /**
     * \brief Request coast neutral output of actuator.  The bridge is
     * disabled and the rotor is allowed to coast.
     *
     * CoastOut Parameters: 
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::CoastOut&& request)
    {
        return SetControl(request);
    }
    
    /**
     * \brief Applies full neutral-brake by shorting motor leads together.
     *
     * StaticBrake Parameters: 
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::StaticBrake& request);
    /**
     * \brief Applies full neutral-brake by shorting motor leads together.
     *
     * StaticBrake Parameters: 
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::StaticBrake&& request)
    {
        return SetControl(request);
    }
 
    /**
     * \brief Control motor with generic control request object. User must make
     *        sure the specified object is castable to a valid control request,
     *        otherwise this function will fail at run-time and return the NotSupported
     *        StatusCode
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::ControlRequest& request)
    {
        controls::ControlRequest *ptr = &request;
        (void)ptr;
        auto *DutyCycleOutValue = dynamic_cast<controls::DutyCycleOut *>(ptr);
        if (DutyCycleOutValue != nullptr)
            return SetControl(*DutyCycleOutValue);
        auto *TorqueCurrentFOCValue = dynamic_cast<controls::TorqueCurrentFOC *>(ptr);
        if (TorqueCurrentFOCValue != nullptr)
            return SetControl(*TorqueCurrentFOCValue);
        auto *VoltageOutValue = dynamic_cast<controls::VoltageOut *>(ptr);
        if (VoltageOutValue != nullptr)
            return SetControl(*VoltageOutValue);
        auto *PositionDutyCycleValue = dynamic_cast<controls::PositionDutyCycle *>(ptr);
        if (PositionDutyCycleValue != nullptr)
            return SetControl(*PositionDutyCycleValue);
        auto *PositionVoltageValue = dynamic_cast<controls::PositionVoltage *>(ptr);
        if (PositionVoltageValue != nullptr)
            return SetControl(*PositionVoltageValue);
        auto *PositionTorqueCurrentFOCValue = dynamic_cast<controls::PositionTorqueCurrentFOC *>(ptr);
        if (PositionTorqueCurrentFOCValue != nullptr)
            return SetControl(*PositionTorqueCurrentFOCValue);
        auto *VelocityDutyCycleValue = dynamic_cast<controls::VelocityDutyCycle *>(ptr);
        if (VelocityDutyCycleValue != nullptr)
            return SetControl(*VelocityDutyCycleValue);
        auto *VelocityVoltageValue = dynamic_cast<controls::VelocityVoltage *>(ptr);
        if (VelocityVoltageValue != nullptr)
            return SetControl(*VelocityVoltageValue);
        auto *VelocityTorqueCurrentFOCValue = dynamic_cast<controls::VelocityTorqueCurrentFOC *>(ptr);
        if (VelocityTorqueCurrentFOCValue != nullptr)
            return SetControl(*VelocityTorqueCurrentFOCValue);
        auto *MotionMagicDutyCycleValue = dynamic_cast<controls::MotionMagicDutyCycle *>(ptr);
        if (MotionMagicDutyCycleValue != nullptr)
            return SetControl(*MotionMagicDutyCycleValue);
        auto *MotionMagicVoltageValue = dynamic_cast<controls::MotionMagicVoltage *>(ptr);
        if (MotionMagicVoltageValue != nullptr)
            return SetControl(*MotionMagicVoltageValue);
        auto *MotionMagicTorqueCurrentFOCValue = dynamic_cast<controls::MotionMagicTorqueCurrentFOC *>(ptr);
        if (MotionMagicTorqueCurrentFOCValue != nullptr)
            return SetControl(*MotionMagicTorqueCurrentFOCValue);
        auto *FollowerValue = dynamic_cast<controls::Follower *>(ptr);
        if (FollowerValue != nullptr)
            return SetControl(*FollowerValue);
        auto *StrictFollowerValue = dynamic_cast<controls::StrictFollower *>(ptr);
        if (StrictFollowerValue != nullptr)
            return SetControl(*StrictFollowerValue);
        auto *NeutralOutValue = dynamic_cast<controls::NeutralOut *>(ptr);
        if (NeutralOutValue != nullptr)
            return SetControl(*NeutralOutValue);
        auto *CoastOutValue = dynamic_cast<controls::CoastOut *>(ptr);
        if (CoastOutValue != nullptr)
            return SetControl(*CoastOutValue);
        auto *StaticBrakeValue = dynamic_cast<controls::StaticBrake *>(ptr);
        if (StaticBrakeValue != nullptr)
            return SetControl(*StaticBrakeValue);
        return ctre::phoenix::StatusCode::NotSupported;
    }
    /**
     * \brief Control motor with generic control request object. User must make
     *        sure the specified object is castable to a valid control request,
     *        otherwise this function will fail at run-time and return the corresponding
     *        StatusCode
     *
     * \param request                Control object to request of the device
     * \returns Status Code of the request, 0 is OK
     */
    ctre::phoenix::StatusCode SetControl(controls::ControlRequest&& request)
    {
        return SetControl(request);
    }
 
    
    /**
     * \brief The position to set the rotor position to right now.
     *
     * \param newValue Value to set to.
     * \param timeoutSeconds Maximum time to wait up to in seconds.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode SetRotorPosition(units::angle::turn_t newValue, units::time::second_t timeoutSeconds)
    {
        return GetConfigurator().SetRotorPosition(newValue, timeoutSeconds);
    }
    /**
     * \brief The position to set the rotor position to right now.
     *
     * This will wait up to 0.050 seconds (50ms) by default.
     *
     * \param newValue Value to set to.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode SetRotorPosition(units::angle::turn_t newValue)
    {
        return SetRotorPosition(newValue, 0.050_s);
    }
    
    /**
     * \brief Clear the sticky faults in the device.
     *
     * \details This typically has no impact on the device functionality. 
     * Instead, it just clears telemetry faults that are accessible via
     * API and Tuner Self-Test.
     * \param timeoutSeconds Maximum time to wait up to in seconds.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode ClearStickyFaults(units::time::second_t timeoutSeconds)
    {
        return GetConfigurator().ClearStickyFaults(timeoutSeconds);
    }
    /**
     * \brief Clear the sticky faults in the device.
     *
     * \details This typically has no impact on the device functionality. 
     * Instead, it just clears telemetry faults that are accessible via
     * API and Tuner Self-Test.
     *
     * This will wait up to 0.050 seconds (50ms) by default.
     * \returns StatusCode of the set command
     */
    ctre::phoenix::StatusCode ClearStickyFaults()
    {
        return ClearStickyFaults(0.050_s);
    }
};
 
}
}
 
}
}