/*
 * 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
 */
package com.ctre.phoenix6.hardware.core;

import com.ctre.phoenix6.hardware.ParentDevice;
import com.ctre.phoenix6.controls.*;
import com.ctre.phoenix6.controls.compound.*;
import com.ctre.phoenix6.configs.*;
import com.ctre.phoenix6.StatusCode;
import com.ctre.phoenix6.jni.PlatformJNI;
import com.ctre.phoenix6.sim.DeviceType;
import com.ctre.phoenix6.sim.TalonFXSimState;
import com.ctre.phoenix6.*;
import com.ctre.phoenix6.spns.*;
import com.ctre.phoenix6.signals.*;
import java.util.HashMap;
import java.util.Map;

/**
 * Class description for the Talon FX integrated motor controller.
 * 
 * <pre>
 * // Constants used in TalonFX construction
 * final int kTalonFXId = 0;
 * final String kTalonFXCANbus = "canivore";
 * 
 * // Construct the TalonFX
 * TalonFX talonfx = new TalonFX(kTalonFXId, kTalonFXCANbus);
 * 
 * // Configure the TalonFX for basic use
 * TalonFXConfiguration configs = new TalonFXConfiguration();
 * // This TalonFX should be configured with a kP of 1, a kI of 0, a kD of 10, and a kV of 2 on slot 0
 * configs.Slot0.kP = 1;
 * configs.Slot0.kI = 0;
 * configs.Slot0.kD = 10;
 * configs.Slot0.kV = 2;
 * 
 * // Write these configs to the TalonFX
 * talonfx.getConfigurator().apply(configs);
 * 
 * // Set the position to 0 rotations for initial use
 * talonfx.setPosition(0);
 * 
 * // Get Position and Velocity
 * var position = talonfx.getPosition();
 * var velocity = talonfx.getVelocity();
 * 
 * // Refresh and print these values
 * System.out.println("Position is " + position.refresh().toString());
 * System.out.println("Velocity is " + velocity.refresh().toString());
 * </pre>
 */
public class CoreTalonFX extends ParentDevice
{
    private TalonFXConfigurator _configurator;

    
    /**
     * Proportional output of PID controller when PID'ing under a
     * DutyCycle Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -128.0
     *   <li> <b>Maximum Value:</b> 127.9990234375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> fractional
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDDutyCycle_ProportionalOutput Status Signal Object
     */
    private StatusSignal<Double> getPIDDutyCycle_ProportionalOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDOutput_ProportionalOutput_DC.value, Double.class, "PIDDutyCycle_ProportionalOutput", true);
    }
    
    /**
     * Proportional output of PID controller when PID'ing under a Voltage
     * Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -1310.72
     *   <li> <b>Maximum Value:</b> 1310.71
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> V
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDMotorVoltage_ProportionalOutput Status Signal Object
     */
    private StatusSignal<Double> getPIDMotorVoltage_ProportionalOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDOutput_ProportionalOutput_V.value, Double.class, "PIDMotorVoltage_ProportionalOutput", true);
    }
    
    /**
     * Proportional output of PID controller when PID'ing under a
     * TorqueCurrent Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -13107.2
     *   <li> <b>Maximum Value:</b> 13107.1
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDTorqueCurrent_ProportionalOutput Status Signal Object
     */
    private StatusSignal<Double> getPIDTorqueCurrent_ProportionalOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDOutput_ProportionalOutput_A.value, Double.class, "PIDTorqueCurrent_ProportionalOutput", true);
    }
    
    /**
     * Integrated Accumulator of PID controller when PID'ing under a
     * DutyCycle Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -128.0
     *   <li> <b>Maximum Value:</b> 127.9990234375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> fractional
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDDutyCycle_IntegratedAccum Status Signal Object
     */
    private StatusSignal<Double> getPIDDutyCycle_IntegratedAccum()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDStateEnables_IntegratedAccum_DC.value, Double.class, "PIDDutyCycle_IntegratedAccum", true);
    }
    
    /**
     * Integrated Accumulator of PID controller when PID'ing under a
     * Voltage Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -1310.72
     *   <li> <b>Maximum Value:</b> 1310.71
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> V
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDMotorVoltage_IntegratedAccum Status Signal Object
     */
    private StatusSignal<Double> getPIDMotorVoltage_IntegratedAccum()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDStateEnables_IntegratedAccum_V.value, Double.class, "PIDMotorVoltage_IntegratedAccum", true);
    }
    
    /**
     * Integrated Accumulator of PID controller when PID'ing under a
     * TorqueCurrent Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -13107.2
     *   <li> <b>Maximum Value:</b> 13107.1
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDTorqueCurrent_IntegratedAccum Status Signal Object
     */
    private StatusSignal<Double> getPIDTorqueCurrent_IntegratedAccum()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDStateEnables_IntegratedAccum_A.value, Double.class, "PIDTorqueCurrent_IntegratedAccum", true);
    }
    
    /**
     * Feedforward passed to PID controller
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -2.0
     *   <li> <b>Maximum Value:</b> 1.9990234375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> fractional
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDDutyCycle_FeedForward Status Signal Object
     */
    private StatusSignal<Double> getPIDDutyCycle_FeedForward()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDStateEnables_FeedForward_DC.value, Double.class, "PIDDutyCycle_FeedForward", true);
    }
    
    /**
     * Feedforward passed to PID controller
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -20.48
     *   <li> <b>Maximum Value:</b> 20.47
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> V
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDMotorVoltage_FeedForward Status Signal Object
     */
    private StatusSignal<Double> getPIDMotorVoltage_FeedForward()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDStateEnables_FeedForward_V.value, Double.class, "PIDMotorVoltage_FeedForward", true);
    }
    
    /**
     * Feedforward passed to PID controller
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -409.6
     *   <li> <b>Maximum Value:</b> 409.40000000000003
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDTorqueCurrent_FeedForward Status Signal Object
     */
    private StatusSignal<Double> getPIDTorqueCurrent_FeedForward()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDStateEnables_FeedForward_A.value, Double.class, "PIDTorqueCurrent_FeedForward", true);
    }
    
    /**
     * Derivative Output of PID controller when PID'ing under a DutyCycle
     * Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -128.0
     *   <li> <b>Maximum Value:</b> 127.9990234375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> fractional
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDDutyCycle_DerivativeOutput Status Signal Object
     */
    private StatusSignal<Double> getPIDDutyCycle_DerivativeOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDOutput_DerivativeOutput_DC.value, Double.class, "PIDDutyCycle_DerivativeOutput", true);
    }
    
    /**
     * Derivative Output of PID controller when PID'ing under a Voltage
     * Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -1310.72
     *   <li> <b>Maximum Value:</b> 1310.71
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> V
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDMotorVoltage_DerivativeOutput Status Signal Object
     */
    private StatusSignal<Double> getPIDMotorVoltage_DerivativeOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDOutput_DerivativeOutput_V.value, Double.class, "PIDMotorVoltage_DerivativeOutput", true);
    }
    
    /**
     * Derivative Output of PID controller when PID'ing under a
     * TorqueCurrent Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -13107.2
     *   <li> <b>Maximum Value:</b> 13107.1
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDTorqueCurrent_DerivativeOutput Status Signal Object
     */
    private StatusSignal<Double> getPIDTorqueCurrent_DerivativeOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDOutput_DerivativeOutput_A.value, Double.class, "PIDTorqueCurrent_DerivativeOutput", true);
    }
    
    /**
     * Output of PID controller when PID'ing under a DutyCycle Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -128.0
     *   <li> <b>Maximum Value:</b> 127.9990234375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> fractional
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDDutyCycle_Output Status Signal Object
     */
    private StatusSignal<Double> getPIDDutyCycle_Output()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDOutput_Output_DC.value, Double.class, "PIDDutyCycle_Output", true);
    }
    
    /**
     * Output of PID controller when PID'ing under a Voltage Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -1310.72
     *   <li> <b>Maximum Value:</b> 1310.71
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> V
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDMotorVoltage_Output Status Signal Object
     */
    private StatusSignal<Double> getPIDMotorVoltage_Output()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDOutput_Output_V.value, Double.class, "PIDMotorVoltage_Output", true);
    }
    
    /**
     * Output of PID controller when PID'ing under a TorqueCurrent Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -13107.2
     *   <li> <b>Maximum Value:</b> 13107.1
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDTorqueCurrent_Output Status Signal Object
     */
    private StatusSignal<Double> getPIDTorqueCurrent_Output()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDOutput_Output_A.value, Double.class, "PIDTorqueCurrent_Output", true);
    }
    
    /**
     * Input position of PID controller when PID'ing to a position
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -10000
     *   <li> <b>Maximum Value:</b> 10000
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDPosition_Reference Status Signal Object
     */
    private StatusSignal<Double> getPIDPosition_Reference()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDRefPIDErr_PIDRef_Position.value, Double.class, "PIDPosition_Reference", true);
    }
    
    /**
     * Input velocity of PID controller when PID'ing to a velocity
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -10000
     *   <li> <b>Maximum Value:</b> 10000
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDVelocity_Reference Status Signal Object
     */
    private StatusSignal<Double> getPIDVelocity_Reference()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDRefPIDErr_PIDRef_Velocity.value, Double.class, "PIDVelocity_Reference", true);
    }
    
    /**
     * Change in input (velocity) of PID controller when PID'ing to a
     * position
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -512.0
     *   <li> <b>Maximum Value:</b> 511.984375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDPosition_ReferenceSlope Status Signal Object
     */
    private StatusSignal<Double> getPIDPosition_ReferenceSlope()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDRefSlopeECUTime_ReferenceSlope_Position.value, Double.class, "PIDPosition_ReferenceSlope", true);
    }
    
    /**
     * Change in input (acceleration) of PID controller when PID'ing to a
     * velocity
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -512.0
     *   <li> <b>Maximum Value:</b> 511.984375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second²
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDVelocity_ReferenceSlope Status Signal Object
     */
    private StatusSignal<Double> getPIDVelocity_ReferenceSlope()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDRefSlopeECUTime_ReferenceSlope_Velocity.value, Double.class, "PIDVelocity_ReferenceSlope", true);
    }
    
    /**
     * The difference between target position and current position
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -10000
     *   <li> <b>Maximum Value:</b> 10000
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDPosition_ClosedLoopError Status Signal Object
     */
    private StatusSignal<Double> getPIDPosition_ClosedLoopError()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDRefPIDErr_PIDErr_Position.value, Double.class, "PIDPosition_ClosedLoopError", true);
    }
    
    /**
     * The difference between target velocity and current velocity
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -10000
     *   <li> <b>Maximum Value:</b> 10000
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return PIDVelocity_ClosedLoopError Status Signal Object
     */
    private StatusSignal<Double> getPIDVelocity_ClosedLoopError()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDRefPIDErr_PIDErr_Velocity.value, Double.class, "PIDVelocity_ClosedLoopError", true);
    }
    
    /**
     * The calculated motor duty cycle for differential followers.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -32.0
     *   <li> <b>Maximum Value:</b> 31.9990234375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> fractional
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialDutyCycle Status Signal Object
     */
    private StatusSignal<Double> getDifferentialDutyCycle()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_PIDState_Diff_DutyCycle.value, Double.class, "DifferentialDutyCycle", true);
    }
    
    /**
     * The calculated motor torque current for differential followers.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -327.68
     *   <li> <b>Maximum Value:</b> 327.67
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialTorqueCurrent Status Signal Object
     */
    private StatusSignal<Double> getDifferentialTorqueCurrent()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_PIDState_Diff_TorqueCurrent.value, Double.class, "DifferentialTorqueCurrent", true);
    }
    
    /**
     * Proportional output of differential PID controller when PID'ing
     * under a DutyCycle Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -128.0
     *   <li> <b>Maximum Value:</b> 127.9990234375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> fractional
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDDutyCycle_ProportionalOutput Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDDutyCycle_ProportionalOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDOutput_ProportionalOutput_DC.value, Double.class, "DifferentialPIDDutyCycle_ProportionalOutput", true);
    }
    
    /**
     * Proportional output of differential PID controller when PID'ing
     * under a Voltage Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -1310.72
     *   <li> <b>Maximum Value:</b> 1310.71
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> V
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDMotorVoltage_ProportionalOutput Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDMotorVoltage_ProportionalOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDOutput_ProportionalOutput_V.value, Double.class, "DifferentialPIDMotorVoltage_ProportionalOutput", true);
    }
    
    /**
     * Proportional output of differential PID controller when PID'ing
     * under a TorqueCurrent Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -13107.2
     *   <li> <b>Maximum Value:</b> 13107.1
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDTorqueCurrent_ProportionalOutput Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDTorqueCurrent_ProportionalOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDOutput_ProportionalOutput_A.value, Double.class, "DifferentialPIDTorqueCurrent_ProportionalOutput", true);
    }
    
    /**
     * Integrated Accumulator of differential PID controller when PID'ing
     * under a DutyCycle Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -128.0
     *   <li> <b>Maximum Value:</b> 127.9990234375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> fractional
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDDutyCycle_IntegratedAccum Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDDutyCycle_IntegratedAccum()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_PIDState_Diff_IntegratedAccum_DC.value, Double.class, "DifferentialPIDDutyCycle_IntegratedAccum", true);
    }
    
    /**
     * Integrated Accumulator of differential PID controller when PID'ing
     * under a Voltage Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -1310.72
     *   <li> <b>Maximum Value:</b> 1310.71
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> V
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDMotorVoltage_IntegratedAccum Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDMotorVoltage_IntegratedAccum()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_PIDState_Diff_IntegratedAccum_V.value, Double.class, "DifferentialPIDMotorVoltage_IntegratedAccum", true);
    }
    
    /**
     * Integrated Accumulator of differential PID controller when PID'ing
     * under a TorqueCurrent Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -13107.2
     *   <li> <b>Maximum Value:</b> 13107.1
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDTorqueCurrent_IntegratedAccum Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDTorqueCurrent_IntegratedAccum()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_PIDState_Diff_IntegratedAccum_A.value, Double.class, "DifferentialPIDTorqueCurrent_IntegratedAccum", true);
    }
    
    /**
     * Feedforward passed to differential PID controller
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -2.0
     *   <li> <b>Maximum Value:</b> 1.9990234375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> fractional
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDDutyCycle_FeedForward Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDDutyCycle_FeedForward()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_PIDState_Diff_FeedForward_DC.value, Double.class, "DifferentialPIDDutyCycle_FeedForward", true);
    }
    
    /**
     * Feedforward passed to differential PID controller
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -20.48
     *   <li> <b>Maximum Value:</b> 20.47
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> V
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDMotorVoltage_FeedForward Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDMotorVoltage_FeedForward()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_PIDState_Diff_FeedForward_V.value, Double.class, "DifferentialPIDMotorVoltage_FeedForward", true);
    }
    
    /**
     * Feedforward passed to differential PID controller
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -409.6
     *   <li> <b>Maximum Value:</b> 409.40000000000003
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDTorqueCurrent_FeedForward Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDTorqueCurrent_FeedForward()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_PIDState_Diff_FeedForward_A.value, Double.class, "DifferentialPIDTorqueCurrent_FeedForward", true);
    }
    
    /**
     * Derivative Output of differential PID controller when PID'ing under
     * a DutyCycle Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -128.0
     *   <li> <b>Maximum Value:</b> 127.9990234375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> fractional
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDDutyCycle_DerivativeOutput Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDDutyCycle_DerivativeOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDOutput_DerivativeOutput_DC.value, Double.class, "DifferentialPIDDutyCycle_DerivativeOutput", true);
    }
    
    /**
     * Derivative Output of differential PID controller when PID'ing under
     * a Voltage Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -1310.72
     *   <li> <b>Maximum Value:</b> 1310.71
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> V
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DiffPIDMotorVoltage_DerivativeOutput Status Signal Object
     */
    private StatusSignal<Double> getDiffPIDMotorVoltage_DerivativeOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDOutput_DerivativeOutput_V.value, Double.class, "DiffPIDMotorVoltage_DerivativeOutput", true);
    }
    
    /**
     * Derivative Output of differential PID controller when PID'ing under
     * a TorqueCurrent Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -13107.2
     *   <li> <b>Maximum Value:</b> 13107.1
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDTorqueCurrent_DerivativeOutput Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDTorqueCurrent_DerivativeOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDOutput_DerivativeOutput_A.value, Double.class, "DifferentialPIDTorqueCurrent_DerivativeOutput", true);
    }
    
    /**
     * Output of differential PID controller when PID'ing under a
     * DutyCycle Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -128.0
     *   <li> <b>Maximum Value:</b> 127.9990234375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> fractional
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDDutyCycle_Output Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDDutyCycle_Output()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDOutput_Output_DC.value, Double.class, "DifferentialPIDDutyCycle_Output", true);
    }
    
    /**
     * Output of differential PID controller when PID'ing under a Voltage
     * Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -1310.72
     *   <li> <b>Maximum Value:</b> 1310.71
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> V
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDMotorVoltage_Output Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDMotorVoltage_Output()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDOutput_Output_V.value, Double.class, "DifferentialPIDMotorVoltage_Output", true);
    }
    
    /**
     * Output of differential PID controller when PID'ing under a
     * TorqueCurrent Request
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -13107.2
     *   <li> <b>Maximum Value:</b> 13107.1
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDTorqueCurrent_Output Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDTorqueCurrent_Output()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDOutput_Output_A.value, Double.class, "DifferentialPIDTorqueCurrent_Output", true);
    }
    
    /**
     * Input position of differential PID controller when PID'ing to a
     * differential position
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -10000
     *   <li> <b>Maximum Value:</b> 10000
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDPosition_Reference Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDPosition_Reference()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDRefPIDErr_PIDRef_Position.value, Double.class, "DifferentialPIDPosition_Reference", true);
    }
    
    /**
     * Input velocity of differential PID controller when PID'ing to a
     * differential velocity
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -10000
     *   <li> <b>Maximum Value:</b> 10000
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDVelocity_Reference Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDVelocity_Reference()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDRefPIDErr_PIDRef_Velocity.value, Double.class, "DifferentialPIDVelocity_Reference", true);
    }
    
    /**
     * Change in input (velocity) of differential PID controller when
     * PID'ing to a differential position
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -512.0
     *   <li> <b>Maximum Value:</b> 511.984375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDPosition_ReferenceSlope Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDPosition_ReferenceSlope()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDRefSlopeECUTime_ReferenceSlope_Position.value, Double.class, "DifferentialPIDPosition_ReferenceSlope", true);
    }
    
    /**
     * Change in input (acceleration) of differential PID controller when
     * PID'ing to a differential velocity
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -512.0
     *   <li> <b>Maximum Value:</b> 511.984375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second²
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDVelocity_ReferenceSlope Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDVelocity_ReferenceSlope()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDRefSlopeECUTime_ReferenceSlope_Velocity.value, Double.class, "DifferentialPIDVelocity_ReferenceSlope", true);
    }
    
    /**
     * The difference between target differential position and current
     * differential position
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -10000
     *   <li> <b>Maximum Value:</b> 10000
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDPosition_ClosedLoopError Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDPosition_ClosedLoopError()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDRefPIDErr_PIDErr_Position.value, Double.class, "DifferentialPIDPosition_ClosedLoopError", true);
    }
    
    /**
     * The difference between target differential velocity and current
     * differential velocity
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -10000
     *   <li> <b>Maximum Value:</b> 10000
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialPIDVelocity_ClosedLoopError Status Signal Object
     */
    private StatusSignal<Double> getDifferentialPIDVelocity_ClosedLoopError()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDRefPIDErr_PIDErr_Velocity.value, Double.class, "DifferentialPIDVelocity_ClosedLoopError", true);
    }

    /**
     * Constructs a new Talon FX motor controller object.
     * <p>
     * Constructs the device using the default CAN bus for the system:
     * <ul>
     *   <li>"rio" on roboRIO
     *   <li>"can0" on Linux
     *   <li>"*" on Windows
     * </ul>
     *
     * @param deviceId    ID of the device, as configured in Phoenix Tuner.
     */
    public CoreTalonFX(int deviceId)
    {
        this(deviceId, "");
    }
    /**
     * 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:
     *                    <ul>
     *                      <li>"rio" for the native roboRIO CAN bus
     *                      <li>CANivore name or serial number
     *                      <li>SocketCAN interface (non-FRC Linux only)
     *                      <li>"*" for any CANivore seen by the program
     *                      <li>empty string (default) to select the default for the system:
     *                      <ul>
     *                        <li>"rio" on roboRIO
     *                        <li>"can0" on Linux
     *                        <li>"*" on Windows
     *                      </ul>
     *                    </ul>
     */
    public CoreTalonFX(int deviceId, String canbus)
    {
        super(deviceId, "talon fx", canbus);
        _configurator = new TalonFXConfigurator(this.deviceIdentifier);
        PlatformJNI.JNI_SimCreate(DeviceType.PRO_TalonFXType.value, deviceId);
    }

    /**
     * Gets the configurator to use with this device's configs
     *
     * @return Configurator for this object
     */
    public TalonFXConfigurator getConfigurator()
    {
        return this._configurator;
    }


    private TalonFXSimState _simState = null;
    /**
     * Get the simulation state for this device.
     * <p>
     * This function reuses an allocated simulation state
     * object, so it is safe to call this function multiple
     * times in a robot loop.
     *
     * @return Simulation state
     */
    public TalonFXSimState getSimState() {
        if (_simState == null)
            _simState = new TalonFXSimState(this);
        return _simState;
    }


        
    /**
     * App Major Version number.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 0
     *   <li> <b>Maximum Value:</b> 255
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> 
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return VersionMajor Status Signal Object
     */
    public StatusSignal<Integer> getVersionMajor()
    {
        return super.lookupStatusSignal(SpnValue.Version_Major.value, Integer.class, "VersionMajor", false);
    }
        
    /**
     * App Minor Version number.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 0
     *   <li> <b>Maximum Value:</b> 255
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> 
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return VersionMinor Status Signal Object
     */
    public StatusSignal<Integer> getVersionMinor()
    {
        return super.lookupStatusSignal(SpnValue.Version_Minor.value, Integer.class, "VersionMinor", false);
    }
        
    /**
     * App Bugfix Version number.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 0
     *   <li> <b>Maximum Value:</b> 255
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> 
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return VersionBugfix Status Signal Object
     */
    public StatusSignal<Integer> getVersionBugfix()
    {
        return super.lookupStatusSignal(SpnValue.Version_Bugfix.value, Integer.class, "VersionBugfix", false);
    }
        
    /**
     * App Build Version number.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 0
     *   <li> <b>Maximum Value:</b> 255
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> 
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return VersionBuild Status Signal Object
     */
    public StatusSignal<Integer> getVersionBuild()
    {
        return super.lookupStatusSignal(SpnValue.Version_Build.value, Integer.class, "VersionBuild", false);
    }
        
    /**
     * Full Version.  The format is a four byte value.
     * <p>
     * Full Version of firmware in device. The format is a four byte
     * value.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 0
     *   <li> <b>Maximum Value:</b> 4294967295
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> 
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Version Status Signal Object
     */
    public StatusSignal<Integer> getVersion()
    {
        return super.lookupStatusSignal(SpnValue.Version_Full.value, Integer.class, "Version", false);
    }
        
    /**
     * Integer representing all faults
     * <p>
     * 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.  
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 0
     *   <li> <b>Maximum Value:</b> 16777215
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> 
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return FaultField Status Signal Object
     */
    public StatusSignal<Integer> getFaultField()
    {
        return super.lookupStatusSignal(SpnValue.AllFaults.value, Integer.class, "FaultField", true);
    }
        
    /**
     * Integer representing all sticky faults
     * <p>
     * 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.  
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 0
     *   <li> <b>Maximum Value:</b> 16777215
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> 
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFaultField Status Signal Object
     */
    public StatusSignal<Integer> getStickyFaultField()
    {
        return super.lookupStatusSignal(SpnValue.AllStickyFaults.value, Integer.class, "StickyFaultField", true);
    }
        
    /**
     * The applied (output) motor voltage.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -40.96
     *   <li> <b>Maximum Value:</b> 40.95
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> V
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 100.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return MotorVoltage Status Signal Object
     */
    public StatusSignal<Double> getMotorVoltage()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_MotorVoltage.value, Double.class, "MotorVoltage", true);
    }
        
    /**
     * Forward Limit Pin.
     * 
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 100.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return ForwardLimit Status Signal Object
     */
    public StatusSignal<ForwardLimitValue> getForwardLimit()
    {
        return super.lookupStatusSignal(SpnValue.ForwardLimit.value, ForwardLimitValue.class, "ForwardLimit", true);
    }
        
    /**
     * Reverse Limit Pin.
     * 
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 100.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return ReverseLimit Status Signal Object
     */
    public StatusSignal<ReverseLimitValue> getReverseLimit()
    {
        return super.lookupStatusSignal(SpnValue.ReverseLimit.value, ReverseLimitValue.class, "ReverseLimit", true);
    }
        
    /**
     * The applied rotor polarity.  This typically is determined by the
     * Inverted config, but can be overridden if using Follower features.
     * 
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 100.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return AppliedRotorPolarity Status Signal Object
     */
    public StatusSignal<AppliedRotorPolarityValue> getAppliedRotorPolarity()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_RotorPolarity.value, AppliedRotorPolarityValue.class, "AppliedRotorPolarity", true);
    }
        
    /**
     * The applied motor duty cycle.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -2.0
     *   <li> <b>Maximum Value:</b> 1.9990234375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> fractional
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 100.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DutyCycle Status Signal Object
     */
    public StatusSignal<Double> getDutyCycle()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_DutyCycle.value, Double.class, "DutyCycle", true);
    }
        
    /**
     * 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.
     * <p>
     * Stator current where positive current means torque is applied in
     * the forward direction as determined by the Inverted setting
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -327.68
     *   <li> <b>Maximum Value:</b> 327.67
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 100.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return TorqueCurrent Status Signal Object
     */
    public StatusSignal<Double> getTorqueCurrent()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_TorqueCurrent.value, Double.class, "TorqueCurrent", true);
    }
        
    /**
     * Current corresponding to the stator windings. Similar to
     * TorqueCurrent. Users will likely prefer TorqueCurrent over
     * StatorCurrent.
     * <p>
     * Stator current where Positive current indicates motoring regardless
     * of direction. Negative current indicates regenerative braking
     * regardless of direction.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -327.68
     *   <li> <b>Maximum Value:</b> 327.66
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StatorCurrent Status Signal Object
     */
    public StatusSignal<Double> getStatorCurrent()
    {
        return super.lookupStatusSignal(SpnValue.PRO_SupplyAndTemp_StatorCurrent.value, Double.class, "StatorCurrent", true);
    }
        
    /**
     * Measured supply side current
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -327.68
     *   <li> <b>Maximum Value:</b> 327.66
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> A
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return SupplyCurrent Status Signal Object
     */
    public StatusSignal<Double> getSupplyCurrent()
    {
        return super.lookupStatusSignal(SpnValue.PRO_SupplyAndTemp_SupplyCurrent.value, Double.class, "SupplyCurrent", true);
    }
        
    /**
     * Measured supply voltage to the TalonFX.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 4
     *   <li> <b>Maximum Value:</b> 29.575
     *   <li> <b>Default Value:</b> 4
     *   <li> <b>Units:</b> V
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return SupplyVoltage Status Signal Object
     */
    public StatusSignal<Double> getSupplyVoltage()
    {
        return super.lookupStatusSignal(SpnValue.PRO_SupplyAndTemp_SupplyVoltage.value, Double.class, "SupplyVoltage", true);
    }
        
    /**
     * Temperature of device
     * <p>
     * This is the temperature that the device measures itself to be at.
     * Similar to Processor Temperature.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 0.0
     *   <li> <b>Maximum Value:</b> 255.0
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> ℃
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DeviceTemp Status Signal Object
     */
    public StatusSignal<Double> getDeviceTemp()
    {
        return super.lookupStatusSignal(SpnValue.PRO_SupplyAndTemp_DeviceTemp.value, Double.class, "DeviceTemp", true);
    }
        
    /**
     * Temperature of the processor
     * <p>
     * This is the temperature that the processor measures itself to be
     * at. Similar to Device Temperature.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 0.0
     *   <li> <b>Maximum Value:</b> 255.0
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> ℃
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return ProcessorTemp Status Signal Object
     */
    public StatusSignal<Double> getProcessorTemp()
    {
        return super.lookupStatusSignal(SpnValue.PRO_SupplyAndTemp_ProcessorTemp.value, Double.class, "ProcessorTemp", true);
    }
        
    /**
     * Velocity of the motor rotor. This velocity is not affected by any
     * feedback configs.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -512.0
     *   <li> <b>Maximum Value:</b> 511.998046875
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return RotorVelocity Status Signal Object
     */
    public StatusSignal<Double> getRotorVelocity()
    {
        return super.lookupStatusSignal(SpnValue.PRO_RotorPosAndVel_Velocity.value, Double.class, "RotorVelocity", true);
    }
        
    /**
     * Position of the motor rotor. This position is only affected by the
     * RotorOffset config and calls to setPosition.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -16384.0
     *   <li> <b>Maximum Value:</b> 16383.999755859375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return RotorPosition Status Signal Object
     */
    public StatusSignal<Double> getRotorPosition()
    {
        return super.lookupStatusSignal(SpnValue.PRO_RotorPosAndVel_Position.value, Double.class, "RotorPosition", true);
    }
        
    /**
     * Velocity of the device in mechanism rotations per second. This can
     * be the velocity of a remote sensor and is affected by the
     * RotorToSensorRatio and SensorToMechanismRatio configs.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -512.0
     *   <li> <b>Maximum Value:</b> 511.998046875
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 50.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Velocity Status Signal Object
     */
    public StatusSignal<Double> getVelocity()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PosAndVel_Velocity.value, Double.class, "Velocity", true);
    }
        
    /**
     * Position of the device in mechanism rotations. This can be the
     * position of a remote sensor and is affected by the
     * RotorToSensorRatio and SensorToMechanismRatio configs, as well as
     * calls to setPosition.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -16384.0
     *   <li> <b>Maximum Value:</b> 16383.999755859375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 50.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Position Status Signal Object
     */
    public StatusSignal<Double> getPosition()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PosAndVel_Position.value, Double.class, "Position", true);
    }
        
    /**
     * Acceleration of the device in mechanism rotations per second². This
     * can be the acceleration of a remote sensor and is affected by the
     * RotorToSensorRatio and SensorToMechanismRatio configs.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -2048.0
     *   <li> <b>Maximum Value:</b> 2047.75
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second²
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 50.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Acceleration Status Signal Object
     */
    public StatusSignal<Double> getAcceleration()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PosAndVel_Acceleration.value, Double.class, "Acceleration", true);
    }
        
    /**
     * The active control mode of the motor controller
     * 
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return ControlMode Status Signal Object
     */
    public StatusSignal<ControlModeValue> getControlMode()
    {
        return super.lookupStatusSignal(SpnValue.TalonFX_ControlMode.value, ControlModeValue.class, "ControlMode", true);
    }
        
    /**
     * Check if Motion Magic® is running.  This is equivalent to checking
     * that the reported control mode is a Motion Magic® based mode.
     * 
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return MotionMagicIsRunning Status Signal Object
     */
    public StatusSignal<MotionMagicIsRunningValue> getMotionMagicIsRunning()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDStateEnables_IsMotionMagicRunning.value, MotionMagicIsRunningValue.class, "MotionMagicIsRunning", true);
    }
        
    /**
     * Indicates if device is actuator enabled.
     * 
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DeviceEnable Status Signal Object
     */
    public StatusSignal<DeviceEnableValue> getDeviceEnable()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDStateEnables_DeviceEnable.value, DeviceEnableValue.class, "DeviceEnable", true);
    }
        
    /**
     * Closed loop slot in use
     * <p>
     * This is the slot that the closed loop PID is using.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 0
     *   <li> <b>Maximum Value:</b> 2
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> 
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return ClosedLoopSlot Status Signal Object
     */
    public StatusSignal<Integer> getClosedLoopSlot()
    {
        return super.lookupStatusSignal(SpnValue.PRO_PIDOutput_Slot.value, Integer.class, "ClosedLoopSlot", true);
    }
        
    /**
     * The active control mode of the differential controller
     * 
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 100.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialControlMode Status Signal Object
     */
    public StatusSignal<DifferentialControlModeValue> getDifferentialControlMode()
    {
        return super.lookupStatusSignal(SpnValue.TalonFX_DifferentialControlMode.value, DifferentialControlModeValue.class, "DifferentialControlMode", true);
    }
        
    /**
     * Average component of the differential velocity of device.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -512.0
     *   <li> <b>Maximum Value:</b> 511.998046875
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialAverageVelocity Status Signal Object
     */
    public StatusSignal<Double> getDifferentialAverageVelocity()
    {
        return super.lookupStatusSignal(SpnValue.PRO_AvgPosAndVel_Velocity.value, Double.class, "DifferentialAverageVelocity", true);
    }
        
    /**
     * Average component of the differential position of device.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -16384.0
     *   <li> <b>Maximum Value:</b> 16383.999755859375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialAveragePosition Status Signal Object
     */
    public StatusSignal<Double> getDifferentialAveragePosition()
    {
        return super.lookupStatusSignal(SpnValue.PRO_AvgPosAndVel_Position.value, Double.class, "DifferentialAveragePosition", true);
    }
        
    /**
     * Difference component of the differential velocity of device.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -512.0
     *   <li> <b>Maximum Value:</b> 511.998046875
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations per second
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialDifferenceVelocity Status Signal Object
     */
    public StatusSignal<Double> getDifferentialDifferenceVelocity()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPosAndVel_Velocity.value, Double.class, "DifferentialDifferenceVelocity", true);
    }
        
    /**
     * Difference component of the differential position of device.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> -16384.0
     *   <li> <b>Maximum Value:</b> 16383.999755859375
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> rotations
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialDifferencePosition Status Signal Object
     */
    public StatusSignal<Double> getDifferentialDifferencePosition()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPosAndVel_Position.value, Double.class, "DifferentialDifferencePosition", true);
    }
        
    /**
     * Differential Closed loop slot in use
     * <p>
     * This is the slot that the closed loop differential PID is using.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 0
     *   <li> <b>Maximum Value:</b> 2
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> 
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return DifferentialClosedLoopSlot Status Signal Object
     */
    public StatusSignal<Integer> getDifferentialClosedLoopSlot()
    {
        return super.lookupStatusSignal(SpnValue.PRO_DiffPIDOutput_Slot.value, Integer.class, "DifferentialClosedLoopSlot", true);
    }
        
    /**
     * The applied output of the bridge.
     * 
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 100.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return BridgeOutput Status Signal Object
     */
    public StatusSignal<BridgeOutputValue> getBridgeOutput()
    {
        return super.lookupStatusSignal(SpnValue.PRO_MotorOutput_BridgeType_Public.value, BridgeOutputValue.class, "BridgeOutput", true);
    }
        
    /**
     * Whether the device is Phoenix Pro licensed.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return IsProLicensed Status Signal Object
     */
    public StatusSignal<Boolean> getIsProLicensed()
    {
        return super.lookupStatusSignal(SpnValue.Version_IsProLicensed.value, Boolean.class, "IsProLicensed", true);
    }
        
    /**
     * Temperature of device from second sensor
     * <p>
     * Newer versions of Talon FX have multiple temperature measurement
     * methods.
     * 
     * <ul>
     *   <li> <b>Minimum Value:</b> 0.0
     *   <li> <b>Maximum Value:</b> 255.0
     *   <li> <b>Default Value:</b> 0
     *   <li> <b>Units:</b> ℃
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return AncillaryDeviceTemp Status Signal Object
     */
    public StatusSignal<Double> getAncillaryDeviceTemp()
    {
        return super.lookupStatusSignal(SpnValue.PRO_SupplyAndTemp_DeviceTemp2.value, Double.class, "AncillaryDeviceTemp", true);
    }
        
    /**
     * The type of motor attached to the Talon FX
     * <p>
     * This can be used to determine what motor is attached to the Talon
     * FX.  Return will be "Unknown" if firmware is too old or device is
     * not present.
     * 
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return MotorType Status Signal Object
     */
    public StatusSignal<MotorTypeValue> getMotorType()
    {
        return super.lookupStatusSignal(SpnValue.TalonFX_MotorType.value, MotorTypeValue.class, "MotorType", true);
    }
        
    /**
     * Assess the status of the motor output with respect to load and
     * supply.
     * <p>
     * This routine can be used to determine the general status of motor
     * commutation.  Off means that motor output is disabled. 
     * StaticBraking typically means the motor is in neutral-brake. 
     * Motoring means motor is loaded in a typical fashion, drawing
     * current from the supply, and successfully turning the rotor in the
     * direction of applied voltage.  Discordant Motoring is the same as
     * Motoring, expect the rotor is being backdriven as the motor output
     * is not enough to defeat load forces.  RegenBraking means the motor
     * is braking in such a way where motor current is traveling back to
     * the supply (typically a battery).
     * 
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return MotorOutputStatus Status Signal Object
     */
    public StatusSignal<MotorOutputStatusValue> getMotorOutputStatus()
    {
        return super.lookupStatusSignal(SpnValue.TalonFX_MotorOutputStatus.value, MotorOutputStatusValue.class, "MotorOutputStatus", true);
    }
        
    /**
     * Hardware fault occurred
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_Hardware Status Signal Object
     */
    public StatusSignal<Boolean> getFault_Hardware()
    {
        return super.lookupStatusSignal(SpnValue.Fault_Hardware.value, Boolean.class, "Fault_Hardware", true);
    }
        
    /**
     * Hardware fault occurred
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_Hardware Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_Hardware()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_Hardware.value, Boolean.class, "StickyFault_Hardware", true);
    }
        
    /**
     * Processor temperature exceeded limit
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_ProcTemp Status Signal Object
     */
    public StatusSignal<Boolean> getFault_ProcTemp()
    {
        return super.lookupStatusSignal(SpnValue.Fault_ProcTemp.value, Boolean.class, "Fault_ProcTemp", true);
    }
        
    /**
     * Processor temperature exceeded limit
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_ProcTemp Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_ProcTemp()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_ProcTemp.value, Boolean.class, "StickyFault_ProcTemp", true);
    }
        
    /**
     * Device temperature exceeded limit
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_DeviceTemp Status Signal Object
     */
    public StatusSignal<Boolean> getFault_DeviceTemp()
    {
        return super.lookupStatusSignal(SpnValue.Fault_DeviceTemp.value, Boolean.class, "Fault_DeviceTemp", true);
    }
        
    /**
     * Device temperature exceeded limit
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_DeviceTemp Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_DeviceTemp()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_DeviceTemp.value, Boolean.class, "StickyFault_DeviceTemp", true);
    }
        
    /**
     * Device supply voltage dropped to near brownout levels
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_Undervoltage Status Signal Object
     */
    public StatusSignal<Boolean> getFault_Undervoltage()
    {
        return super.lookupStatusSignal(SpnValue.Fault_Undervoltage.value, Boolean.class, "Fault_Undervoltage", true);
    }
        
    /**
     * Device supply voltage dropped to near brownout levels
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_Undervoltage Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_Undervoltage()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_Undervoltage.value, Boolean.class, "StickyFault_Undervoltage", true);
    }
        
    /**
     * Device boot while detecting the enable signal
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_BootDuringEnable Status Signal Object
     */
    public StatusSignal<Boolean> getFault_BootDuringEnable()
    {
        return super.lookupStatusSignal(SpnValue.Fault_BootDuringEnable.value, Boolean.class, "Fault_BootDuringEnable", true);
    }
        
    /**
     * Device boot while detecting the enable signal
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_BootDuringEnable Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_BootDuringEnable()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_BootDuringEnable.value, Boolean.class, "StickyFault_BootDuringEnable", true);
    }
        
    /**
     * An unlicensed feature is in use, device may not behave as expected.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_UnlicensedFeatureInUse Status Signal Object
     */
    public StatusSignal<Boolean> getFault_UnlicensedFeatureInUse()
    {
        return super.lookupStatusSignal(SpnValue.Fault_UnlicensedFeatureInUse.value, Boolean.class, "Fault_UnlicensedFeatureInUse", true);
    }
        
    /**
     * An unlicensed feature is in use, device may not behave as expected.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_UnlicensedFeatureInUse Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_UnlicensedFeatureInUse()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_UnlicensedFeatureInUse.value, Boolean.class, "StickyFault_UnlicensedFeatureInUse", true);
    }
        
    /**
     * Bridge was disabled most likely due to supply voltage dropping too
     * low.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_BridgeBrownout Status Signal Object
     */
    public StatusSignal<Boolean> getFault_BridgeBrownout()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_BridgeBrownout.value, Boolean.class, "Fault_BridgeBrownout", true);
    }
        
    /**
     * Bridge was disabled most likely due to supply voltage dropping too
     * low.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_BridgeBrownout Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_BridgeBrownout()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_BridgeBrownout.value, Boolean.class, "StickyFault_BridgeBrownout", true);
    }
        
    /**
     * The remote sensor has reset.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_RemoteSensorReset Status Signal Object
     */
    public StatusSignal<Boolean> getFault_RemoteSensorReset()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_RemoteSensorReset.value, Boolean.class, "Fault_RemoteSensorReset", true);
    }
        
    /**
     * The remote sensor has reset.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_RemoteSensorReset Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_RemoteSensorReset()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_RemoteSensorReset.value, Boolean.class, "StickyFault_RemoteSensorReset", true);
    }
        
    /**
     * The remote Talon FX used for differential control is not present on
     * CAN Bus.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_MissingDifferentialFX Status Signal Object
     */
    public StatusSignal<Boolean> getFault_MissingDifferentialFX()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_MissingDifferentialFX.value, Boolean.class, "Fault_MissingDifferentialFX", true);
    }
        
    /**
     * The remote Talon FX used for differential control is not present on
     * CAN Bus.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_MissingDifferentialFX Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_MissingDifferentialFX()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_MissingDifferentialFX.value, Boolean.class, "StickyFault_MissingDifferentialFX", true);
    }
        
    /**
     * The remote sensor position has overflowed. Because of the nature of
     * remote sensors, it is possible for the remote sensor position to
     * overflow beyond what is supported by the status signal frame.
     * However, this is rare and cannot occur over the course of an FRC
     * match under normal use.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_RemoteSensorPosOverflow Status Signal Object
     */
    public StatusSignal<Boolean> getFault_RemoteSensorPosOverflow()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_RemoteSensorPosOverflow.value, Boolean.class, "Fault_RemoteSensorPosOverflow", true);
    }
        
    /**
     * The remote sensor position has overflowed. Because of the nature of
     * remote sensors, it is possible for the remote sensor position to
     * overflow beyond what is supported by the status signal frame.
     * However, this is rare and cannot occur over the course of an FRC
     * match under normal use.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_RemoteSensorPosOverflow Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_RemoteSensorPosOverflow()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_RemoteSensorPosOverflow.value, Boolean.class, "StickyFault_RemoteSensorPosOverflow", true);
    }
        
    /**
     * Supply Voltage has exceeded the maximum voltage rating of device.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_OverSupplyV Status Signal Object
     */
    public StatusSignal<Boolean> getFault_OverSupplyV()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_OverSupplyV.value, Boolean.class, "Fault_OverSupplyV", true);
    }
        
    /**
     * Supply Voltage has exceeded the maximum voltage rating of device.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_OverSupplyV Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_OverSupplyV()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_OverSupplyV.value, Boolean.class, "StickyFault_OverSupplyV", true);
    }
        
    /**
     * Supply Voltage is unstable.  Ensure you are using a battery and
     * current limited power supply.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_UnstableSupplyV Status Signal Object
     */
    public StatusSignal<Boolean> getFault_UnstableSupplyV()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_UnstableSupplyV.value, Boolean.class, "Fault_UnstableSupplyV", true);
    }
        
    /**
     * Supply Voltage is unstable.  Ensure you are using a battery and
     * current limited power supply.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_UnstableSupplyV Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_UnstableSupplyV()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_UnstableSupplyV.value, Boolean.class, "StickyFault_UnstableSupplyV", true);
    }
        
    /**
     * Reverse limit switch has been asserted.  Output is set to neutral.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_ReverseHardLimit Status Signal Object
     */
    public StatusSignal<Boolean> getFault_ReverseHardLimit()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_ReverseHardLimit.value, Boolean.class, "Fault_ReverseHardLimit", true);
    }
        
    /**
     * Reverse limit switch has been asserted.  Output is set to neutral.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_ReverseHardLimit Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_ReverseHardLimit()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_ReverseHardLimit.value, Boolean.class, "StickyFault_ReverseHardLimit", true);
    }
        
    /**
     * Forward limit switch has been asserted.  Output is set to neutral.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_ForwardHardLimit Status Signal Object
     */
    public StatusSignal<Boolean> getFault_ForwardHardLimit()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_ForwardHardLimit.value, Boolean.class, "Fault_ForwardHardLimit", true);
    }
        
    /**
     * Forward limit switch has been asserted.  Output is set to neutral.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_ForwardHardLimit Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_ForwardHardLimit()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_ForwardHardLimit.value, Boolean.class, "StickyFault_ForwardHardLimit", true);
    }
        
    /**
     * Reverse soft limit has been asserted.  Output is set to neutral.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_ReverseSoftLimit Status Signal Object
     */
    public StatusSignal<Boolean> getFault_ReverseSoftLimit()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_ReverseSoftLimit.value, Boolean.class, "Fault_ReverseSoftLimit", true);
    }
        
    /**
     * Reverse soft limit has been asserted.  Output is set to neutral.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_ReverseSoftLimit Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_ReverseSoftLimit()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_ReverseSoftLimit.value, Boolean.class, "StickyFault_ReverseSoftLimit", true);
    }
        
    /**
     * Forward soft limit has been asserted.  Output is set to neutral.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_ForwardSoftLimit Status Signal Object
     */
    public StatusSignal<Boolean> getFault_ForwardSoftLimit()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_ForwardSoftLimit.value, Boolean.class, "Fault_ForwardSoftLimit", true);
    }
        
    /**
     * Forward soft limit has been asserted.  Output is set to neutral.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_ForwardSoftLimit Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_ForwardSoftLimit()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_ForwardSoftLimit.value, Boolean.class, "StickyFault_ForwardSoftLimit", true);
    }
        
    /**
     * The remote sensor's data is no longer trusted. This can happen if
     * the remote sensor disappears from the CAN bus or if the remote
     * sensor indicates its data is no longer valid, such as when a
     * CANcoder's magnet strength falls into the "red" range.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_RemoteSensorDataInvalid Status Signal Object
     */
    public StatusSignal<Boolean> getFault_RemoteSensorDataInvalid()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_MissingRemoteSensor.value, Boolean.class, "Fault_RemoteSensorDataInvalid", true);
    }
        
    /**
     * The remote sensor's data is no longer trusted. This can happen if
     * the remote sensor disappears from the CAN bus or if the remote
     * sensor indicates its data is no longer valid, such as when a
     * CANcoder's magnet strength falls into the "red" range.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_RemoteSensorDataInvalid Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_RemoteSensorDataInvalid()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_MissingRemoteSensor.value, Boolean.class, "StickyFault_RemoteSensorDataInvalid", true);
    }
        
    /**
     * 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.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_FusedSensorOutOfSync Status Signal Object
     */
    public StatusSignal<Boolean> getFault_FusedSensorOutOfSync()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_FusedSensorOutOfSync.value, Boolean.class, "Fault_FusedSensorOutOfSync", true);
    }
        
    /**
     * 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.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_FusedSensorOutOfSync Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_FusedSensorOutOfSync()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_FusedSensorOutOfSync.value, Boolean.class, "StickyFault_FusedSensorOutOfSync", true);
    }
        
    /**
     * Stator current limit occured.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_StatorCurrLimit Status Signal Object
     */
    public StatusSignal<Boolean> getFault_StatorCurrLimit()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_StatorCurrLimit.value, Boolean.class, "Fault_StatorCurrLimit", true);
    }
        
    /**
     * Stator current limit occured.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_StatorCurrLimit Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_StatorCurrLimit()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_StatorCurrLimit.value, Boolean.class, "StickyFault_StatorCurrLimit", true);
    }
        
    /**
     * Supply current limit occured.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_SupplyCurrLimit Status Signal Object
     */
    public StatusSignal<Boolean> getFault_SupplyCurrLimit()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_SupplyCurrLimit.value, Boolean.class, "Fault_SupplyCurrLimit", true);
    }
        
    /**
     * Supply current limit occured.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_SupplyCurrLimit Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_SupplyCurrLimit()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_SupplyCurrLimit.value, Boolean.class, "StickyFault_SupplyCurrLimit", true);
    }
        
    /**
     * Using Fused CANcoder feature while unlicensed. Device has fallen
     * back to remote CANcoder.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_UsingFusedCANcoderWhileUnlicensed Status Signal Object
     */
    public StatusSignal<Boolean> getFault_UsingFusedCANcoderWhileUnlicensed()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_UsingFusedCCWhileUnlicensed.value, Boolean.class, "Fault_UsingFusedCANcoderWhileUnlicensed", true);
    }
        
    /**
     * Using Fused CANcoder feature while unlicensed. Device has fallen
     * back to remote CANcoder.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_UsingFusedCANcoderWhileUnlicensed Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_UsingFusedCANcoderWhileUnlicensed()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_UsingFusedCCWhileUnlicensed.value, Boolean.class, "StickyFault_UsingFusedCANcoderWhileUnlicensed", true);
    }
        
    /**
     * Static brake was momentarily disabled due to excessive braking
     * current while disabled.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return Fault_StaticBrakeDisabled Status Signal Object
     */
    public StatusSignal<Boolean> getFault_StaticBrakeDisabled()
    {
        return super.lookupStatusSignal(SpnValue.Fault_TALONFX_StaticBrakeDisabled.value, Boolean.class, "Fault_StaticBrakeDisabled", true);
    }
        
    /**
     * Static brake was momentarily disabled due to excessive braking
     * current while disabled.
     * 
     * <ul>
     *   <li> <b>Default Value:</b> False
     * </ul>
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN:</b> 4.0 Hz
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return StickyFault_StaticBrakeDisabled Status Signal Object
     */
    public StatusSignal<Boolean> getStickyFault_StaticBrakeDisabled()
    {
        return super.lookupStatusSignal(SpnValue.StickyFault_TALONFX_StaticBrakeDisabled.value, Boolean.class, "StickyFault_StaticBrakeDisabled", true);
    }
    
    /**
     * Closed loop proportional component
     * <p>
     * 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:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  ClosedLoopProportionalOutput Status Signal object
     */
    public StatusSignal<Double> getClosedLoopProportionalOutput()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(ControlModeValue.PositionDutyCycle.value, getPIDDutyCycle_ProportionalOutput());
            toAdd.put(ControlModeValue.PositionDutyCycleFOC.value, getPIDDutyCycle_ProportionalOutput());
            toAdd.put(ControlModeValue.VelocityDutyCycle.value, getPIDDutyCycle_ProportionalOutput());
            toAdd.put(ControlModeValue.VelocityDutyCycleFOC.value, getPIDDutyCycle_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicDutyCycle.value, getPIDDutyCycle_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicDutyCycleFOC.value, getPIDDutyCycle_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycle.value, getPIDDutyCycle_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycleFOC.value, getPIDDutyCycle_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycle.value, getPIDDutyCycle_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycleFOC.value, getPIDDutyCycle_ProportionalOutput());
            toAdd.put(ControlModeValue.PositionVoltage.value, getPIDMotorVoltage_ProportionalOutput());
            toAdd.put(ControlModeValue.PositionVoltageFOC.value, getPIDMotorVoltage_ProportionalOutput());
            toAdd.put(ControlModeValue.VelocityVoltage.value, getPIDMotorVoltage_ProportionalOutput());
            toAdd.put(ControlModeValue.VelocityVoltageFOC.value, getPIDMotorVoltage_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicVoltage.value, getPIDMotorVoltage_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicVoltageFOC.value, getPIDMotorVoltage_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltage.value, getPIDMotorVoltage_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltageFOC.value, getPIDMotorVoltage_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltage.value, getPIDMotorVoltage_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltageFOC.value, getPIDMotorVoltage_ProportionalOutput());
            toAdd.put(ControlModeValue.PositionTorqueCurrentFOC.value, getPIDTorqueCurrent_ProportionalOutput());
            toAdd.put(ControlModeValue.VelocityTorqueCurrentFOC.value, getPIDTorqueCurrent_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicTorqueCurrentFOC.value, getPIDTorqueCurrent_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicVelocityTorqueCurrentFOC.value, getPIDTorqueCurrent_ProportionalOutput());
            toAdd.put(ControlModeValue.MotionMagicExpoTorqueCurrentFOC.value, getPIDTorqueCurrent_ProportionalOutput());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_ControlMode.value, Double.class, 1, mapFiller, "ClosedLoopProportionalOutput", true);
    }
    
    /**
     * Closed loop integrated component
     * <p>
     * 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:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  ClosedLoopIntegratedOutput Status Signal object
     */
    public StatusSignal<Double> getClosedLoopIntegratedOutput()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(ControlModeValue.PositionDutyCycle.value, getPIDDutyCycle_IntegratedAccum());
            toAdd.put(ControlModeValue.PositionDutyCycleFOC.value, getPIDDutyCycle_IntegratedAccum());
            toAdd.put(ControlModeValue.VelocityDutyCycle.value, getPIDDutyCycle_IntegratedAccum());
            toAdd.put(ControlModeValue.VelocityDutyCycleFOC.value, getPIDDutyCycle_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicDutyCycle.value, getPIDDutyCycle_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicDutyCycleFOC.value, getPIDDutyCycle_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycle.value, getPIDDutyCycle_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycleFOC.value, getPIDDutyCycle_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycle.value, getPIDDutyCycle_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycleFOC.value, getPIDDutyCycle_IntegratedAccum());
            toAdd.put(ControlModeValue.PositionVoltage.value, getPIDMotorVoltage_IntegratedAccum());
            toAdd.put(ControlModeValue.PositionVoltageFOC.value, getPIDMotorVoltage_IntegratedAccum());
            toAdd.put(ControlModeValue.VelocityVoltage.value, getPIDMotorVoltage_IntegratedAccum());
            toAdd.put(ControlModeValue.VelocityVoltageFOC.value, getPIDMotorVoltage_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicVoltage.value, getPIDMotorVoltage_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicVoltageFOC.value, getPIDMotorVoltage_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltage.value, getPIDMotorVoltage_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltageFOC.value, getPIDMotorVoltage_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltage.value, getPIDMotorVoltage_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltageFOC.value, getPIDMotorVoltage_IntegratedAccum());
            toAdd.put(ControlModeValue.PositionTorqueCurrentFOC.value, getPIDTorqueCurrent_IntegratedAccum());
            toAdd.put(ControlModeValue.VelocityTorqueCurrentFOC.value, getPIDTorqueCurrent_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicTorqueCurrentFOC.value, getPIDTorqueCurrent_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicVelocityTorqueCurrentFOC.value, getPIDTorqueCurrent_IntegratedAccum());
            toAdd.put(ControlModeValue.MotionMagicExpoTorqueCurrentFOC.value, getPIDTorqueCurrent_IntegratedAccum());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_ControlMode.value, Double.class, 2, mapFiller, "ClosedLoopIntegratedOutput", true);
    }
    
    /**
     * Feedforward passed by the user
     * <p>
     * This is the general feedforward that the user provides for the
     * closed loop.
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  ClosedLoopFeedForward Status Signal object
     */
    public StatusSignal<Double> getClosedLoopFeedForward()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(ControlModeValue.PositionDutyCycle.value, getPIDDutyCycle_FeedForward());
            toAdd.put(ControlModeValue.PositionDutyCycleFOC.value, getPIDDutyCycle_FeedForward());
            toAdd.put(ControlModeValue.VelocityDutyCycle.value, getPIDDutyCycle_FeedForward());
            toAdd.put(ControlModeValue.VelocityDutyCycleFOC.value, getPIDDutyCycle_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicDutyCycle.value, getPIDDutyCycle_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicDutyCycleFOC.value, getPIDDutyCycle_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycle.value, getPIDDutyCycle_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycleFOC.value, getPIDDutyCycle_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycle.value, getPIDDutyCycle_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycleFOC.value, getPIDDutyCycle_FeedForward());
            toAdd.put(ControlModeValue.PositionVoltage.value, getPIDMotorVoltage_FeedForward());
            toAdd.put(ControlModeValue.PositionVoltageFOC.value, getPIDMotorVoltage_FeedForward());
            toAdd.put(ControlModeValue.VelocityVoltage.value, getPIDMotorVoltage_FeedForward());
            toAdd.put(ControlModeValue.VelocityVoltageFOC.value, getPIDMotorVoltage_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicVoltage.value, getPIDMotorVoltage_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicVoltageFOC.value, getPIDMotorVoltage_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltage.value, getPIDMotorVoltage_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltageFOC.value, getPIDMotorVoltage_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltage.value, getPIDMotorVoltage_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltageFOC.value, getPIDMotorVoltage_FeedForward());
            toAdd.put(ControlModeValue.PositionTorqueCurrentFOC.value, getPIDTorqueCurrent_FeedForward());
            toAdd.put(ControlModeValue.VelocityTorqueCurrentFOC.value, getPIDTorqueCurrent_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicTorqueCurrentFOC.value, getPIDTorqueCurrent_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicVelocityTorqueCurrentFOC.value, getPIDTorqueCurrent_FeedForward());
            toAdd.put(ControlModeValue.MotionMagicExpoTorqueCurrentFOC.value, getPIDTorqueCurrent_FeedForward());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_ControlMode.value, Double.class, 3, mapFiller, "ClosedLoopFeedForward", true);
    }
    
    /**
     * Closed loop derivative component
     * <p>
     * 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:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  ClosedLoopDerivativeOutput Status Signal object
     */
    public StatusSignal<Double> getClosedLoopDerivativeOutput()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(ControlModeValue.PositionDutyCycle.value, getPIDDutyCycle_DerivativeOutput());
            toAdd.put(ControlModeValue.PositionDutyCycleFOC.value, getPIDDutyCycle_DerivativeOutput());
            toAdd.put(ControlModeValue.VelocityDutyCycle.value, getPIDDutyCycle_DerivativeOutput());
            toAdd.put(ControlModeValue.VelocityDutyCycleFOC.value, getPIDDutyCycle_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicDutyCycle.value, getPIDDutyCycle_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicDutyCycleFOC.value, getPIDDutyCycle_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycle.value, getPIDDutyCycle_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycleFOC.value, getPIDDutyCycle_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycle.value, getPIDDutyCycle_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycleFOC.value, getPIDDutyCycle_DerivativeOutput());
            toAdd.put(ControlModeValue.PositionVoltage.value, getPIDMotorVoltage_DerivativeOutput());
            toAdd.put(ControlModeValue.PositionVoltageFOC.value, getPIDMotorVoltage_DerivativeOutput());
            toAdd.put(ControlModeValue.VelocityVoltage.value, getPIDMotorVoltage_DerivativeOutput());
            toAdd.put(ControlModeValue.VelocityVoltageFOC.value, getPIDMotorVoltage_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicVoltage.value, getPIDMotorVoltage_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicVoltageFOC.value, getPIDMotorVoltage_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltage.value, getPIDMotorVoltage_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltageFOC.value, getPIDMotorVoltage_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltage.value, getPIDMotorVoltage_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltageFOC.value, getPIDMotorVoltage_DerivativeOutput());
            toAdd.put(ControlModeValue.PositionTorqueCurrentFOC.value, getPIDTorqueCurrent_DerivativeOutput());
            toAdd.put(ControlModeValue.VelocityTorqueCurrentFOC.value, getPIDTorqueCurrent_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicTorqueCurrentFOC.value, getPIDTorqueCurrent_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicVelocityTorqueCurrentFOC.value, getPIDTorqueCurrent_DerivativeOutput());
            toAdd.put(ControlModeValue.MotionMagicExpoTorqueCurrentFOC.value, getPIDTorqueCurrent_DerivativeOutput());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_ControlMode.value, Double.class, 4, mapFiller, "ClosedLoopDerivativeOutput", true);
    }
    
    /**
     * Closed loop total output
     * <p>
     * The total output of the closed loop output.
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  ClosedLoopOutput Status Signal object
     */
    public StatusSignal<Double> getClosedLoopOutput()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(ControlModeValue.PositionDutyCycle.value, getPIDDutyCycle_Output());
            toAdd.put(ControlModeValue.PositionDutyCycleFOC.value, getPIDDutyCycle_Output());
            toAdd.put(ControlModeValue.VelocityDutyCycle.value, getPIDDutyCycle_Output());
            toAdd.put(ControlModeValue.VelocityDutyCycleFOC.value, getPIDDutyCycle_Output());
            toAdd.put(ControlModeValue.MotionMagicDutyCycle.value, getPIDDutyCycle_Output());
            toAdd.put(ControlModeValue.MotionMagicDutyCycleFOC.value, getPIDDutyCycle_Output());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycle.value, getPIDDutyCycle_Output());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycleFOC.value, getPIDDutyCycle_Output());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycle.value, getPIDDutyCycle_Output());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycleFOC.value, getPIDDutyCycle_Output());
            toAdd.put(ControlModeValue.PositionVoltage.value, getPIDMotorVoltage_Output());
            toAdd.put(ControlModeValue.PositionVoltageFOC.value, getPIDMotorVoltage_Output());
            toAdd.put(ControlModeValue.VelocityVoltage.value, getPIDMotorVoltage_Output());
            toAdd.put(ControlModeValue.VelocityVoltageFOC.value, getPIDMotorVoltage_Output());
            toAdd.put(ControlModeValue.MotionMagicVoltage.value, getPIDMotorVoltage_Output());
            toAdd.put(ControlModeValue.MotionMagicVoltageFOC.value, getPIDMotorVoltage_Output());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltage.value, getPIDMotorVoltage_Output());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltageFOC.value, getPIDMotorVoltage_Output());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltage.value, getPIDMotorVoltage_Output());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltageFOC.value, getPIDMotorVoltage_Output());
            toAdd.put(ControlModeValue.PositionTorqueCurrentFOC.value, getPIDTorqueCurrent_Output());
            toAdd.put(ControlModeValue.VelocityTorqueCurrentFOC.value, getPIDTorqueCurrent_Output());
            toAdd.put(ControlModeValue.MotionMagicTorqueCurrentFOC.value, getPIDTorqueCurrent_Output());
            toAdd.put(ControlModeValue.MotionMagicVelocityTorqueCurrentFOC.value, getPIDTorqueCurrent_Output());
            toAdd.put(ControlModeValue.MotionMagicExpoTorqueCurrentFOC.value, getPIDTorqueCurrent_Output());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_ControlMode.value, Double.class, 5, mapFiller, "ClosedLoopOutput", true);
    }
    
    /**
     * Value that the closed loop is targeting
     * <p>
     * This is the value that the closed loop PID controller targets.
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  ClosedLoopReference Status Signal object
     */
    public StatusSignal<Double> getClosedLoopReference()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(ControlModeValue.PositionDutyCycle.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.PositionDutyCycleFOC.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.MotionMagicDutyCycle.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.MotionMagicDutyCycleFOC.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.PositionVoltage.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.PositionVoltageFOC.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.MotionMagicVoltage.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.MotionMagicVoltageFOC.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.PositionTorqueCurrentFOC.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.MotionMagicTorqueCurrentFOC.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycle.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycleFOC.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltage.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltageFOC.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.MotionMagicExpoTorqueCurrentFOC.value, getPIDPosition_Reference());
            toAdd.put(ControlModeValue.VelocityDutyCycle.value, getPIDVelocity_Reference());
            toAdd.put(ControlModeValue.VelocityDutyCycleFOC.value, getPIDVelocity_Reference());
            toAdd.put(ControlModeValue.VelocityVoltage.value, getPIDVelocity_Reference());
            toAdd.put(ControlModeValue.VelocityVoltageFOC.value, getPIDVelocity_Reference());
            toAdd.put(ControlModeValue.VelocityTorqueCurrentFOC.value, getPIDVelocity_Reference());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycle.value, getPIDVelocity_Reference());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycleFOC.value, getPIDVelocity_Reference());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltage.value, getPIDVelocity_Reference());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltageFOC.value, getPIDVelocity_Reference());
            toAdd.put(ControlModeValue.MotionMagicVelocityTorqueCurrentFOC.value, getPIDVelocity_Reference());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_ControlMode.value, Double.class, 6, mapFiller, "ClosedLoopReference", true);
    }
    
    /**
     * Derivative of the target that the closed loop is targeting
     * <p>
     * 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:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  ClosedLoopReferenceSlope Status Signal object
     */
    public StatusSignal<Double> getClosedLoopReferenceSlope()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(ControlModeValue.PositionDutyCycle.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.PositionDutyCycleFOC.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicDutyCycle.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicDutyCycleFOC.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.PositionVoltage.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.PositionVoltageFOC.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicVoltage.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicVoltageFOC.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.PositionTorqueCurrentFOC.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicTorqueCurrentFOC.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycle.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycleFOC.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltage.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltageFOC.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicExpoTorqueCurrentFOC.value, getPIDPosition_ReferenceSlope());
            toAdd.put(ControlModeValue.VelocityDutyCycle.value, getPIDVelocity_ReferenceSlope());
            toAdd.put(ControlModeValue.VelocityDutyCycleFOC.value, getPIDVelocity_ReferenceSlope());
            toAdd.put(ControlModeValue.VelocityVoltage.value, getPIDVelocity_ReferenceSlope());
            toAdd.put(ControlModeValue.VelocityVoltageFOC.value, getPIDVelocity_ReferenceSlope());
            toAdd.put(ControlModeValue.VelocityTorqueCurrentFOC.value, getPIDVelocity_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycle.value, getPIDVelocity_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycleFOC.value, getPIDVelocity_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltage.value, getPIDVelocity_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltageFOC.value, getPIDVelocity_ReferenceSlope());
            toAdd.put(ControlModeValue.MotionMagicVelocityTorqueCurrentFOC.value, getPIDVelocity_ReferenceSlope());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_ControlMode.value, Double.class, 7, mapFiller, "ClosedLoopReferenceSlope", true);
    }
    
    /**
     * The difference between target reference and current measurement
     * <p>
     * This is the value that is treated as the error in the PID loop.
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  ClosedLoopError Status Signal object
     */
    public StatusSignal<Double> getClosedLoopError()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(ControlModeValue.PositionDutyCycle.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.PositionDutyCycleFOC.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicDutyCycle.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicDutyCycleFOC.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.PositionVoltage.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.PositionVoltageFOC.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicVoltage.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicVoltageFOC.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.PositionTorqueCurrentFOC.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicTorqueCurrentFOC.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycle.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicExpoDutyCycleFOC.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltage.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicExpoVoltageFOC.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicExpoTorqueCurrentFOC.value, getPIDPosition_ClosedLoopError());
            toAdd.put(ControlModeValue.VelocityDutyCycle.value, getPIDVelocity_ClosedLoopError());
            toAdd.put(ControlModeValue.VelocityDutyCycleFOC.value, getPIDVelocity_ClosedLoopError());
            toAdd.put(ControlModeValue.VelocityVoltage.value, getPIDVelocity_ClosedLoopError());
            toAdd.put(ControlModeValue.VelocityVoltageFOC.value, getPIDVelocity_ClosedLoopError());
            toAdd.put(ControlModeValue.VelocityTorqueCurrentFOC.value, getPIDVelocity_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycle.value, getPIDVelocity_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicVelocityDutyCycleFOC.value, getPIDVelocity_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltage.value, getPIDVelocity_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicVelocityVoltageFOC.value, getPIDVelocity_ClosedLoopError());
            toAdd.put(ControlModeValue.MotionMagicVelocityTorqueCurrentFOC.value, getPIDVelocity_ClosedLoopError());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_ControlMode.value, Double.class, 8, mapFiller, "ClosedLoopError", true);
    }
    
    /**
     * The calculated motor output for differential followers.
     * <p>
     * This is a torque request when using the TorqueCurrentFOC control
     * output type, and a duty cycle in all other control types.
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 100.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  DifferentialOutput Status Signal object
     */
    public StatusSignal<Double> getDifferentialOutput()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(DifferentialControlModeValue.PositionDutyCycle.value, getDifferentialDutyCycle());
            toAdd.put(DifferentialControlModeValue.PositionDutyCycleFOC.value, getDifferentialDutyCycle());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycle.value, getDifferentialDutyCycle());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycleFOC.value, getDifferentialDutyCycle());
            toAdd.put(DifferentialControlModeValue.PositionVoltage.value, getDifferentialDutyCycle());
            toAdd.put(DifferentialControlModeValue.PositionVoltageFOC.value, getDifferentialDutyCycle());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltage.value, getDifferentialDutyCycle());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltageFOC.value, getDifferentialDutyCycle());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycle.value, getDifferentialDutyCycle());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycleFOC.value, getDifferentialDutyCycle());
            toAdd.put(DifferentialControlModeValue.VelocityVoltage.value, getDifferentialDutyCycle());
            toAdd.put(DifferentialControlModeValue.VelocityVoltageFOC.value, getDifferentialDutyCycle());
            toAdd.put(DifferentialControlModeValue.PositionTorqueCurrentFOC.value, getDifferentialTorqueCurrent());
            toAdd.put(DifferentialControlModeValue.MotionMagicTorqueCurrentFOC.value, getDifferentialTorqueCurrent());
            toAdd.put(DifferentialControlModeValue.VelocityTorqueCurrentFOC.value, getDifferentialTorqueCurrent());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_DifferentialControlMode.value, Double.class, 9, mapFiller, "DifferentialOutput", true);
    }
    
    /**
     * Differential closed loop proportional component
     * <p>
     * The portion of the differential closed loop output that is the
     * proportional to the error. Alternatively, the p-Contribution of the
     * closed loop output.
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  DifferentialClosedLoopProportionalOutput Status Signal object
     */
    public StatusSignal<Double> getDifferentialClosedLoopProportionalOutput()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(DifferentialControlModeValue.PositionDutyCycle.value, getDifferentialPIDDutyCycle_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.PositionDutyCycleFOC.value, getDifferentialPIDDutyCycle_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycle.value, getDifferentialPIDDutyCycle_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycleFOC.value, getDifferentialPIDDutyCycle_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycle.value, getDifferentialPIDDutyCycle_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycleFOC.value, getDifferentialPIDDutyCycle_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.PositionVoltage.value, getDifferentialPIDMotorVoltage_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.PositionVoltageFOC.value, getDifferentialPIDMotorVoltage_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.VelocityVoltage.value, getDifferentialPIDMotorVoltage_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.VelocityVoltageFOC.value, getDifferentialPIDMotorVoltage_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltage.value, getDifferentialPIDMotorVoltage_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltageFOC.value, getDifferentialPIDMotorVoltage_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.PositionTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.VelocityTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_ProportionalOutput());
            toAdd.put(DifferentialControlModeValue.MotionMagicTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_ProportionalOutput());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_DifferentialControlMode.value, Double.class, 10, mapFiller, "DifferentialClosedLoopProportionalOutput", true);
    }
    
    /**
     * Differential closed loop integrated component
     * <p>
     * The portion of the differential closed loop output that is
     * proportional to the integrated error. Alternatively, the
     * i-Contribution of the closed loop output.
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 100.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  DifferentialClosedLoopIntegratedOutput Status Signal object
     */
    public StatusSignal<Double> getDifferentialClosedLoopIntegratedOutput()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(DifferentialControlModeValue.PositionDutyCycle.value, getDifferentialPIDDutyCycle_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.PositionDutyCycleFOC.value, getDifferentialPIDDutyCycle_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycle.value, getDifferentialPIDDutyCycle_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycleFOC.value, getDifferentialPIDDutyCycle_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycle.value, getDifferentialPIDDutyCycle_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycleFOC.value, getDifferentialPIDDutyCycle_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.PositionVoltage.value, getDifferentialPIDMotorVoltage_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.PositionVoltageFOC.value, getDifferentialPIDMotorVoltage_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.VelocityVoltage.value, getDifferentialPIDMotorVoltage_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.VelocityVoltageFOC.value, getDifferentialPIDMotorVoltage_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltage.value, getDifferentialPIDMotorVoltage_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltageFOC.value, getDifferentialPIDMotorVoltage_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.PositionTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.VelocityTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_IntegratedAccum());
            toAdd.put(DifferentialControlModeValue.MotionMagicTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_IntegratedAccum());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_DifferentialControlMode.value, Double.class, 11, mapFiller, "DifferentialClosedLoopIntegratedOutput", true);
    }
    
    /**
     * Differential Feedforward passed by the user
     * <p>
     * This is the general feedforward that the user provides for the
     * differential closed loop.
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 100.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  DifferentialClosedLoopFeedForward Status Signal object
     */
    public StatusSignal<Double> getDifferentialClosedLoopFeedForward()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(DifferentialControlModeValue.PositionDutyCycle.value, getDifferentialPIDDutyCycle_FeedForward());
            toAdd.put(DifferentialControlModeValue.PositionDutyCycleFOC.value, getDifferentialPIDDutyCycle_FeedForward());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycle.value, getDifferentialPIDDutyCycle_FeedForward());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycleFOC.value, getDifferentialPIDDutyCycle_FeedForward());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycle.value, getDifferentialPIDDutyCycle_FeedForward());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycleFOC.value, getDifferentialPIDDutyCycle_FeedForward());
            toAdd.put(DifferentialControlModeValue.PositionVoltage.value, getDifferentialPIDMotorVoltage_FeedForward());
            toAdd.put(DifferentialControlModeValue.PositionVoltageFOC.value, getDifferentialPIDMotorVoltage_FeedForward());
            toAdd.put(DifferentialControlModeValue.VelocityVoltage.value, getDifferentialPIDMotorVoltage_FeedForward());
            toAdd.put(DifferentialControlModeValue.VelocityVoltageFOC.value, getDifferentialPIDMotorVoltage_FeedForward());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltage.value, getDifferentialPIDMotorVoltage_FeedForward());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltageFOC.value, getDifferentialPIDMotorVoltage_FeedForward());
            toAdd.put(DifferentialControlModeValue.PositionTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_FeedForward());
            toAdd.put(DifferentialControlModeValue.VelocityTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_FeedForward());
            toAdd.put(DifferentialControlModeValue.MotionMagicTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_FeedForward());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_DifferentialControlMode.value, Double.class, 12, mapFiller, "DifferentialClosedLoopFeedForward", true);
    }
    
    /**
     * Differential closed loop derivative component
     * <p>
     * The portion of the differential closed loop output that is the
     * proportional to the deriviative the error. Alternatively, the
     * d-Contribution of the closed loop output.
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  DifferentialClosedLoopDerivativeOutput Status Signal object
     */
    public StatusSignal<Double> getDifferentialClosedLoopDerivativeOutput()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(DifferentialControlModeValue.PositionDutyCycle.value, getDifferentialPIDDutyCycle_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.PositionDutyCycleFOC.value, getDifferentialPIDDutyCycle_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycle.value, getDifferentialPIDDutyCycle_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycleFOC.value, getDifferentialPIDDutyCycle_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycle.value, getDifferentialPIDDutyCycle_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycleFOC.value, getDifferentialPIDDutyCycle_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.PositionVoltage.value, getDiffPIDMotorVoltage_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.PositionVoltageFOC.value, getDiffPIDMotorVoltage_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.VelocityVoltage.value, getDiffPIDMotorVoltage_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.VelocityVoltageFOC.value, getDiffPIDMotorVoltage_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltage.value, getDiffPIDMotorVoltage_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltageFOC.value, getDiffPIDMotorVoltage_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.PositionTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.VelocityTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_DerivativeOutput());
            toAdd.put(DifferentialControlModeValue.MotionMagicTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_DerivativeOutput());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_DifferentialControlMode.value, Double.class, 13, mapFiller, "DifferentialClosedLoopDerivativeOutput", true);
    }
    
    /**
     * Differential closed loop total output
     * <p>
     * The total output of the differential closed loop output.
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  DifferentialClosedLoopOutput Status Signal object
     */
    public StatusSignal<Double> getDifferentialClosedLoopOutput()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(DifferentialControlModeValue.PositionDutyCycle.value, getDifferentialPIDDutyCycle_Output());
            toAdd.put(DifferentialControlModeValue.PositionDutyCycleFOC.value, getDifferentialPIDDutyCycle_Output());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycle.value, getDifferentialPIDDutyCycle_Output());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycleFOC.value, getDifferentialPIDDutyCycle_Output());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycle.value, getDifferentialPIDDutyCycle_Output());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycleFOC.value, getDifferentialPIDDutyCycle_Output());
            toAdd.put(DifferentialControlModeValue.PositionVoltage.value, getDifferentialPIDMotorVoltage_Output());
            toAdd.put(DifferentialControlModeValue.PositionVoltageFOC.value, getDifferentialPIDMotorVoltage_Output());
            toAdd.put(DifferentialControlModeValue.VelocityVoltage.value, getDifferentialPIDMotorVoltage_Output());
            toAdd.put(DifferentialControlModeValue.VelocityVoltageFOC.value, getDifferentialPIDMotorVoltage_Output());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltage.value, getDifferentialPIDMotorVoltage_Output());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltageFOC.value, getDifferentialPIDMotorVoltage_Output());
            toAdd.put(DifferentialControlModeValue.PositionTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_Output());
            toAdd.put(DifferentialControlModeValue.VelocityTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_Output());
            toAdd.put(DifferentialControlModeValue.MotionMagicTorqueCurrentFOC.value, getDifferentialPIDTorqueCurrent_Output());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_DifferentialControlMode.value, Double.class, 14, mapFiller, "DifferentialClosedLoopOutput", true);
    }
    
    /**
     * Value that the differential closed loop is targeting
     * <p>
     * This is the value that the differential closed loop PID controller
     * targets.
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  DifferentialClosedLoopReference Status Signal object
     */
    public StatusSignal<Double> getDifferentialClosedLoopReference()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(DifferentialControlModeValue.PositionDutyCycle.value, getDifferentialPIDPosition_Reference());
            toAdd.put(DifferentialControlModeValue.PositionDutyCycleFOC.value, getDifferentialPIDPosition_Reference());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycle.value, getDifferentialPIDPosition_Reference());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycleFOC.value, getDifferentialPIDPosition_Reference());
            toAdd.put(DifferentialControlModeValue.PositionVoltage.value, getDifferentialPIDPosition_Reference());
            toAdd.put(DifferentialControlModeValue.PositionVoltageFOC.value, getDifferentialPIDPosition_Reference());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltage.value, getDifferentialPIDPosition_Reference());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltageFOC.value, getDifferentialPIDPosition_Reference());
            toAdd.put(DifferentialControlModeValue.PositionTorqueCurrentFOC.value, getDifferentialPIDPosition_Reference());
            toAdd.put(DifferentialControlModeValue.MotionMagicTorqueCurrentFOC.value, getDifferentialPIDPosition_Reference());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycle.value, getDifferentialPIDVelocity_Reference());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycleFOC.value, getDifferentialPIDVelocity_Reference());
            toAdd.put(DifferentialControlModeValue.VelocityVoltage.value, getDifferentialPIDVelocity_Reference());
            toAdd.put(DifferentialControlModeValue.VelocityVoltageFOC.value, getDifferentialPIDVelocity_Reference());
            toAdd.put(DifferentialControlModeValue.VelocityTorqueCurrentFOC.value, getDifferentialPIDVelocity_Reference());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_DifferentialControlMode.value, Double.class, 15, mapFiller, "DifferentialClosedLoopReference", true);
    }
    
    /**
     * Derivative of the target that the differential closed loop is
     * targeting
     * <p>
     * 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:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  DifferentialClosedLoopReferenceSlope Status Signal object
     */
    public StatusSignal<Double> getDifferentialClosedLoopReferenceSlope()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(DifferentialControlModeValue.PositionDutyCycle.value, getDifferentialPIDPosition_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.PositionDutyCycleFOC.value, getDifferentialPIDPosition_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycle.value, getDifferentialPIDPosition_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycleFOC.value, getDifferentialPIDPosition_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.PositionVoltage.value, getDifferentialPIDPosition_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.PositionVoltageFOC.value, getDifferentialPIDPosition_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltage.value, getDifferentialPIDPosition_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltageFOC.value, getDifferentialPIDPosition_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.PositionTorqueCurrentFOC.value, getDifferentialPIDPosition_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.MotionMagicTorqueCurrentFOC.value, getDifferentialPIDPosition_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycle.value, getDifferentialPIDVelocity_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycleFOC.value, getDifferentialPIDVelocity_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.VelocityVoltage.value, getDifferentialPIDVelocity_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.VelocityVoltageFOC.value, getDifferentialPIDVelocity_ReferenceSlope());
            toAdd.put(DifferentialControlModeValue.VelocityTorqueCurrentFOC.value, getDifferentialPIDVelocity_ReferenceSlope());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_DifferentialControlMode.value, Double.class, 16, mapFiller, "DifferentialClosedLoopReferenceSlope", true);
    }
    
    /**
     * The difference between target differential reference and current
     * measurement
     * <p>
     * This is the value that is treated as the error in the differential
     * PID loop.
     * 
     * Default Rates:
     * <ul>
     *   <li> <b>CAN 2.0:</b> 4.0 Hz
     *   <li> <b>CAN FD:</b> 100.0 Hz (TimeSynced with Pro)
     * </ul>
     * 
     * This refreshes and returns a cached StatusSignal object.
     * 
     * @return  DifferentialClosedLoopError Status Signal object
     */
    public StatusSignal<Double> getDifferentialClosedLoopError()
    {
        MapGenerator<Double> mapFiller = ()->{
            Map<Integer, StatusSignal<Double>> toAdd = new HashMap<Integer, StatusSignal<Double>>();
            toAdd.put(DifferentialControlModeValue.PositionDutyCycle.value, getDifferentialPIDPosition_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.PositionDutyCycleFOC.value, getDifferentialPIDPosition_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycle.value, getDifferentialPIDPosition_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.MotionMagicDutyCycleFOC.value, getDifferentialPIDPosition_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.PositionVoltage.value, getDifferentialPIDPosition_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.PositionVoltageFOC.value, getDifferentialPIDPosition_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltage.value, getDifferentialPIDPosition_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.MotionMagicVoltageFOC.value, getDifferentialPIDPosition_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.PositionTorqueCurrentFOC.value, getDifferentialPIDPosition_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.MotionMagicTorqueCurrentFOC.value, getDifferentialPIDPosition_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycle.value, getDifferentialPIDVelocity_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.VelocityDutyCycleFOC.value, getDifferentialPIDVelocity_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.VelocityVoltage.value, getDifferentialPIDVelocity_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.VelocityVoltageFOC.value, getDifferentialPIDVelocity_ClosedLoopError());
            toAdd.put(DifferentialControlModeValue.VelocityTorqueCurrentFOC.value, getDifferentialPIDVelocity_ClosedLoopError());
            return toAdd;
        };
        return super.lookupStatusSignal(SpnValue.TalonFX_DifferentialControlMode.value, Double.class, 17, mapFiller, "DifferentialClosedLoopError", true);
    }

    
    /**
     * Request a specified motor duty cycle.
     * <p>
     * This control mode will output a proportion of the supplied voltage
     * which is supplied by the user.
     * <ul>
     *   <li> <b>DutyCycleOut Parameters:</b> 
     *   <ul>
     *     <li> <b>Output:</b> Proportion of supply voltage to apply in fractional
     *                      units between -1 and +1
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DutyCycleOut request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request a specified motor current (field oriented control).
     * <p>
     * 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.
     * <ul>
     *   <li> <b>TorqueCurrentFOC Parameters:</b> 
     *   <ul>
     *     <li> <b>Output:</b> Amount of motor current in Amperes
     *     <li> <b>MaxAbsDutyCycle:</b> 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.
     *     <li> <b>Deadband:</b> 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.
     *     <li> <b>OverrideCoastDurNeutral:</b> 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).
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(TorqueCurrentFOC request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request a specified voltage.
     * <p>
     * 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.
     * <ul>
     *   <li> <b>VoltageOut Parameters:</b> 
     *   <ul>
     *     <li> <b>Output:</b> Voltage to attempt to drive at
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(VoltageOut request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request PID to target position with duty cycle feedforward.
     * <p>
     * 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.
     * <ul>
     *   <li> <b>PositionDutyCycle Parameters:</b> 
     *   <ul>
     *     <li> <b>Position:</b> Position to drive toward in rotations.
     *     <li> <b>Velocity:</b> Velocity to drive toward in rotations per second. This
     *                        is typically used for motion profiles generated by the
     *                        robot program.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in fractional units between -1
     *                           and +1.
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(PositionDutyCycle request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request PID to target position with voltage feedforward
     * <p>
     * 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.
     * <ul>
     *   <li> <b>PositionVoltage Parameters:</b> 
     *   <ul>
     *     <li> <b>Position:</b> Position to drive toward in rotations.
     *     <li> <b>Velocity:</b> Velocity to drive toward in rotations per second. This
     *                        is typically used for motion profiles generated by the
     *                        robot program.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in volts
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(PositionVoltage request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request PID to target position with torque current feedforward.
     * <p>
     * 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.
     * <ul>
     *   <li> <b>PositionTorqueCurrentFOC Parameters:</b> 
     *   <ul>
     *     <li> <b>Position:</b> Position to drive toward in rotations.
     *     <li> <b>Velocity:</b> Velocity to drive toward in rotations per second. This
     *                        is typically used for motion profiles generated by the
     *                        robot program.
     *     <li> <b>FeedForward:</b> Feedforward to apply in torque current in Amperes. 
     *                           User can use motor's kT to scale Newton-meter to
     *                           Amperes.
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideCoastDurNeutral:</b> 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).
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(PositionTorqueCurrentFOC request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request PID to target velocity with duty cycle feedforward.
     * <p>
     * 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.
     * <ul>
     *   <li> <b>VelocityDutyCycle Parameters:</b> 
     *   <ul>
     *     <li> <b>Velocity:</b> Velocity to drive toward in rotations per second.
     *     <li> <b>Acceleration:</b> Acceleration to drive toward in rotations per
     *                            second squared. This is typically used for motion
     *                            profiles generated by the robot program.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in fractional units between -1
     *                           and +1.
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(VelocityDutyCycle request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request PID to target velocity with voltage feedforward.
     * <p>
     * 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.
     * <ul>
     *   <li> <b>VelocityVoltage Parameters:</b> 
     *   <ul>
     *     <li> <b>Velocity:</b> Velocity to drive toward in rotations per second.
     *     <li> <b>Acceleration:</b> Acceleration to drive toward in rotations per
     *                            second squared. This is typically used for motion
     *                            profiles generated by the robot program.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in volts
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(VelocityVoltage request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request PID to target velocity with torque current feedforward.
     * <p>
     * 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.
     * <ul>
     *   <li> <b>VelocityTorqueCurrentFOC Parameters:</b> 
     *   <ul>
     *     <li> <b>Velocity:</b> Velocity to drive toward in rotations per second.
     *     <li> <b>Acceleration:</b> Acceleration to drive toward in rotations per
     *                            second squared. This is typically used for motion
     *                            profiles generated by the robot program.
     *     <li> <b>FeedForward:</b> Feedforward to apply in torque current in Amperes. 
     *                           User can use motor's kT to scale Newton-meter to
     *                           Amperes.
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideCoastDurNeutral:</b> 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).
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(VelocityTorqueCurrentFOC request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final position using a motion
     * profile.  Users can optionally provide a duty cycle feedforward.
     * <p>
     * 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.  This
     * control mode does not use the Expo_kV or Expo_kA configs.  Target
     * position can be changed on-the-fly and Motion Magic® will do its
     * best to adjust the profile.  This control mode is duty cycle based,
     * so relevant closed-loop gains will use fractional duty cycle for
     * the numerator:  +1.0 represents full forward output.
     * <ul>
     *   <li> <b>MotionMagicDutyCycle Parameters:</b> 
     *   <ul>
     *     <li> <b>Position:</b> Position to drive toward in rotations.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in fractional units between -1
     *                           and +1.
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(MotionMagicDutyCycle request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final position using a motion
     * profile.  Users can optionally provide a voltage feedforward.
     * <p>
     * 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.  This
     * control mode does not use the Expo_kV or Expo_kA configs.  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.
     * <ul>
     *   <li> <b>MotionMagicVoltage Parameters:</b> 
     *   <ul>
     *     <li> <b>Position:</b> Position to drive toward in rotations.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in volts
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(MotionMagicVoltage request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final position using a motion
     * profile.  Users can optionally provide a torque current
     * feedforward.
     * <p>
     * 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.  This
     * control mode does not use the Expo_kV or Expo_kA configs.  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.
     * <ul>
     *   <li> <b>MotionMagicTorqueCurrentFOC Parameters:</b> 
     *   <ul>
     *     <li> <b>Position:</b> Position to drive toward in rotations.
     *     <li> <b>FeedForward:</b> Feedforward to apply in torque current in Amperes. 
     *                           User can use motor's kT to scale Newton-meter to
     *                           Amperes.
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideCoastDurNeutral:</b> 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).
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(MotionMagicTorqueCurrentFOC request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request a specified motor duty cycle with a differential position
     * closed-loop.
     * <p>
     * This control mode will output a proportion of the supplied voltage
     * which is supplied by the user. It will also set the motor's
     * differential position setpoint to the specified position.
     * <ul>
     *   <li> <b>DifferentialDutyCycle Parameters:</b> 
     *   <ul>
     *     <li> <b>TargetOutput:</b> Proportion of supply voltage to apply in
     *                            fractional units between -1 and +1
     *     <li> <b>DifferentialPosition:</b> Differential position to drive towards in
     *                                    rotations
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>DifferentialSlot:</b> Select which gains are applied to the
     *                                differential controller 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DifferentialDutyCycle request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request a specified voltage with a differential position
     * closed-loop.
     * <p>
     * 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. It will also
     * set the motor's differential position setpoint to the specified
     * position.
     * <ul>
     *   <li> <b>DifferentialVoltage Parameters:</b> 
     *   <ul>
     *     <li> <b>TargetOutput:</b> Voltage to attempt to drive at
     *     <li> <b>DifferentialPosition:</b> Differential position to drive towards in
     *                                    rotations
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>DifferentialSlot:</b> Select which gains are applied to the
     *                                differential controller 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DifferentialVoltage request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request PID to target position with a differential position
     * setpoint.
     * <p>
     * This control mode will set the motor's position setpoint to the
     * position specified by the user. It will also set the motor's
     * differential position setpoint to the specified position.
     * <ul>
     *   <li> <b>DifferentialPositionDutyCycle Parameters:</b> 
     *   <ul>
     *     <li> <b>TargetPosition:</b> Average position to drive toward in rotations.
     *     <li> <b>DifferentialPosition:</b> Differential position to drive toward in
     *                                    rotations.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>TargetSlot:</b> Select which gains are applied to the primary
     *                          controller 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].
     *     <li> <b>DifferentialSlot:</b> Select which gains are applied to the
     *                                differential controller 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DifferentialPositionDutyCycle request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request PID to target position with a differential position
     * setpoint
     * <p>
     * This control mode will set the motor's position setpoint to the
     * position specified by the user. It will also set the motor's
     * differential position setpoint to the specified position.
     * <ul>
     *   <li> <b>DifferentialPositionVoltage Parameters:</b> 
     *   <ul>
     *     <li> <b>TargetPosition:</b> Average position to drive toward in rotations.
     *     <li> <b>DifferentialPosition:</b> Differential position to drive toward in
     *                                    rotations.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>TargetSlot:</b> Select which gains are applied to the primary
     *                          controller 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].
     *     <li> <b>DifferentialSlot:</b> Select which gains are applied to the
     *                                differential controller 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DifferentialPositionVoltage request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request PID to target velocity with a differential position
     * setpoint.
     * <p>
     * This control mode will set the motor's velocity setpoint to the
     * velocity specified by the user. It will also set the motor's
     * differential position setpoint to the specified position.
     * <ul>
     *   <li> <b>DifferentialVelocityDutyCycle Parameters:</b> 
     *   <ul>
     *     <li> <b>TargetVelocity:</b> Average velocity to drive toward in rotations
     *                              per second.
     *     <li> <b>DifferentialPosition:</b> Differential position to drive toward in
     *                                    rotations.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>TargetSlot:</b> Select which gains are applied to the primary
     *                          controller 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].
     *     <li> <b>DifferentialSlot:</b> Select which gains are applied to the
     *                                differential controller 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DifferentialVelocityDutyCycle request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request PID to target velocity with a differential position
     * setpoint.
     * <p>
     * This control mode will set the motor's velocity setpoint to the
     * velocity specified by the user. It will also set the motor's
     * differential position setpoint to the specified position.
     * <ul>
     *   <li> <b>DifferentialVelocityVoltage Parameters:</b> 
     *   <ul>
     *     <li> <b>TargetVelocity:</b> Average velocity to drive toward in rotations
     *                              per second.
     *     <li> <b>DifferentialPosition:</b> Differential position to drive toward in
     *                                    rotations.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>TargetSlot:</b> Select which gains are applied to the primary
     *                          controller 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].
     *     <li> <b>DifferentialSlot:</b> Select which gains are applied to the
     *                                differential controller 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DifferentialVelocityVoltage request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final position using a motion
     * profile, and PID to a differential position setpoint.
     * <p>
     * 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.  This
     * control mode does not use the Expo_kV or Expo_kA configs.  Target
     * position can be changed on-the-fly and Motion Magic® will do its
     * best to adjust the profile.  This control mode is duty cycle based,
     * so relevant closed-loop gains will use fractional duty cycle for
     * the numerator:  +1.0 represents full forward output.
     * <ul>
     *   <li> <b>DifferentialMotionMagicDutyCycle Parameters:</b> 
     *   <ul>
     *     <li> <b>TargetPosition:</b> Average position to drive toward in rotations.
     *     <li> <b>DifferentialPosition:</b> Differential position to drive toward in
     *                                    rotations.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>TargetSlot:</b> Select which gains are applied to the primary
     *                          controller 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].
     *     <li> <b>DifferentialSlot:</b> Select which gains are applied to the
     *                                differential controller 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DifferentialMotionMagicDutyCycle request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final position using a motion
     * profile, and PID to a differential position setpoint.
     * <p>
     * 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.  This
     * control mode does not use the Expo_kV or Expo_kA configs.  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.
     * <ul>
     *   <li> <b>DifferentialMotionMagicVoltage Parameters:</b> 
     *   <ul>
     *     <li> <b>TargetPosition:</b> Average position to drive toward in rotations.
     *     <li> <b>DifferentialPosition:</b> Differential position to drive toward in
     *                                    rotations.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>TargetSlot:</b> Select which gains are applied to the primary
     *                          controller 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].
     *     <li> <b>DifferentialSlot:</b> Select which gains are applied to the
     *                                differential controller 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DifferentialMotionMagicVoltage request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Follow the motor output of another Talon.
     * <p>
     * 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.
     * <ul>
     *   <li> <b>Follower Parameters:</b> 
     *   <ul>
     *     <li> <b>MasterID:</b> Device ID of the master to follow.
     *     <li> <b>OpposeMasterDirection:</b> 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.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Follower request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Follow the motor output of another Talon while ignoring the
     * master's invert setting.
     * <p>
     * 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.
     * <ul>
     *   <li> <b>StrictFollower Parameters:</b> 
     *   <ul>
     *     <li> <b>MasterID:</b> Device ID of the master to follow.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(StrictFollower request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Follow the differential motor output of another Talon.
     * <p>
     * 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.
     * <ul>
     *   <li> <b>DifferentialFollower Parameters:</b> 
     *   <ul>
     *     <li> <b>MasterID:</b> Device ID of the differential master to follow.
     *     <li> <b>OpposeMasterDirection:</b> 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.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DifferentialFollower request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Follow the differential motor output of another Talon while
     * ignoring the master's invert setting.
     * <p>
     * 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.
     * <ul>
     *   <li> <b>DifferentialStrictFollower Parameters:</b> 
     *   <ul>
     *     <li> <b>MasterID:</b> Device ID of the differential master to follow.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DifferentialStrictFollower request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request neutral output of actuator. The applied brake type is
     * determined by the NeutralMode configuration.
     * <ul>
     *   <li> <b>NeutralOut Parameters:</b> 
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(NeutralOut request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Request coast neutral output of actuator.  The bridge is disabled
     * and the rotor is allowed to coast.
     * <ul>
     *   <li> <b>CoastOut Parameters:</b> 
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(CoastOut request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Applies full neutral-brake by shorting motor leads together.
     * <ul>
     *   <li> <b>StaticBrake Parameters:</b> 
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(StaticBrake request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Plays a single tone at the user specified frequency.
     * <ul>
     *   <li> <b>MusicTone Parameters:</b> 
     *   <ul>
     *     <li> <b>AudioFrequency:</b> Sound frequency to play.  A value of zero will
     *                              silence the device. The effective frequency
     *                              range is 10-20000Hz.  Any nonzero frequency less
     *                              than 10 Hz will be capped to 10Hz.  Any
     *                              frequency above 20Khz will be capped to 20KHz.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(MusicTone request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final velocity using a motion
     * profile.  This allows smooth transitions between velocity set
     * points.  Users can optionally provide a duty cycle feedforward.
     * <p>
     * Motion Magic® Velocity produces a motion profile in real-time while
     * attempting to honor the specified Acceleration and Jerk value. This
     * control mode does not use the CruiseVelocity, Expo_kV, or Expo_kA
     * configs. If the specified acceleration is zero, the Acceleration
     * under Motion Magic® configuration parameter is used instead. This
     * allows for runtime adjustment of acceleration for advanced users. 
     * Jerk is also specified in the Motion Magic® persistent
     * configuration values.  If Jerk is set to zero, Motion Magic® will
     * produce a trapezoidal acceleration profile.  Target velocity can
     * also be changed on-the-fly and Motion Magic® will do its best to
     * adjust the profile.  This control mode is duty cycle based, so
     * relevant closed-loop gains will use fractional duty cycle for the
     * numerator:  +1.0 represents full forward output.
     * <ul>
     *   <li> <b>MotionMagicVelocityDutyCycle Parameters:</b> 
     *   <ul>
     *     <li> <b>Velocity:</b> Target velocity to drive toward in rotations per
     *                        second.  This can be changed on-the fly.
     *     <li> <b>Acceleration:</b> This is the absolute Acceleration to use
     *                            generating the profile.  If this parameter is
     *                            zero, the Acceleration persistent configuration
     *                            parameter is used instead. Acceleration is in
     *                            rotations per second squared.  If nonzero, the
     *                            signage does not matter as the absolute value is
     *                            used.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in fractional units between -1
     *                           and +1.
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(MotionMagicVelocityDutyCycle request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final velocity using a motion
     * profile.  This allows smooth transitions between velocity set
     * points.  Users can optionally provide a torque feedforward.
     * <p>
     * Motion Magic® Velocity produces a motion profile in real-time while
     * attempting to honor the specified Acceleration and Jerk value. This
     * control mode does not use the CruiseVelocity, Expo_kV, or Expo_kA
     * configs. If the specified acceleration is zero, the Acceleration
     * under Motion Magic® configuration parameter is used instead. This
     * allows for runtime adjustment of acceleration for advanced users. 
     * Jerk is also specified in the Motion Magic® persistent
     * configuration values.  If Jerk is set to zero, Motion Magic® will
     * produce a trapezoidal acceleration profile.  Target velocity can
     * also 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.
     * <ul>
     *   <li> <b>MotionMagicVelocityTorqueCurrentFOC Parameters:</b> 
     *   <ul>
     *     <li> <b>Velocity:</b> Target velocity to drive toward in rotations per
     *                        second.  This can be changed on-the fly.
     *     <li> <b>Acceleration:</b> This is the absolute Acceleration to use
     *                            generating the profile.  If this parameter is
     *                            zero, the Acceleration persistent configuration
     *                            parameter is used instead. Acceleration is in
     *                            rotations per second squared.  If nonzero, the
     *                            signage does not matter as the absolute value is
     *                            used.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in torque current in Amperes. 
     *                           User can use motor's kT to scale Newton-meter to
     *                           Amperes.
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideCoastDurNeutral:</b> 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).
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(MotionMagicVelocityTorqueCurrentFOC request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final velocity using a motion
     * profile.  This allows smooth transitions between velocity set
     * points.  Users can optionally provide a voltage feedforward.
     * <p>
     * Motion Magic® Velocity produces a motion profile in real-time while
     * attempting to honor the specified Acceleration and Jerk value. This
     * control mode does not use the CruiseVelocity, Expo_kV, or Expo_kA
     * configs. If the specified acceleration is zero, the Acceleration
     * under Motion Magic® configuration parameter is used instead. This
     * allows for runtime adjustment of acceleration for advanced users. 
     * Jerk is also specified in the Motion Magic® persistent
     * configuration values.  If Jerk is set to zero, Motion Magic® will
     * produce a trapezoidal acceleration profile.  Target velocity can
     * also 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.
     * <ul>
     *   <li> <b>MotionMagicVelocityVoltage Parameters:</b> 
     *   <ul>
     *     <li> <b>Velocity:</b> Target velocity to drive toward in rotations per
     *                        second.  This can be changed on-the fly.
     *     <li> <b>Acceleration:</b> This is the absolute Acceleration to use
     *                            generating the profile.  If this parameter is
     *                            zero, the Acceleration persistent configuration
     *                            parameter is used instead. Acceleration is in
     *                            rotations per second squared.  If nonzero, the
     *                            signage does not matter as the absolute value is
     *                            used.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in volts
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(MotionMagicVelocityVoltage request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final position using an
     * exponential motion profile.  Users can optionally provide a duty
     * cycle feedforward.
     * <p>
     * Motion Magic® Expo produces a motion profile in real-time while
     * attempting to honor the Cruise Velocity (optional) and the
     * mechanism kV and kA, specified via the Motion Magic® configuration
     * values.  Setting Cruise Velocity to 0 will allow the profile to run
     * to the max possible velocity based on Expo_kV.  This control mode
     * does not use the Acceleration or Jerk configs.  Target position can
     * be changed on-the-fly and Motion Magic® will do its best to adjust
     * the profile.  This control mode is duty cycle based, so relevant
     * closed-loop gains will use fractional duty cycle for the numerator:
     *  +1.0 represents full forward output.
     * <ul>
     *   <li> <b>MotionMagicExpoDutyCycle Parameters:</b> 
     *   <ul>
     *     <li> <b>Position:</b> Position to drive toward in rotations.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in fractional units between -1
     *                           and +1.
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(MotionMagicExpoDutyCycle request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final position using an
     * exponential motion profile.  Users can optionally provide a voltage
     * feedforward.
     * <p>
     * Motion Magic® Expo produces a motion profile in real-time while
     * attempting to honor the Cruise Velocity (optional) and the
     * mechanism kV and kA, specified via the Motion Magic® configuration
     * values.  Setting Cruise Velocity to 0 will allow the profile to run
     * to the max possible velocity based on Expo_kV.  This control mode
     * does not use the Acceleration or Jerk configs.  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.
     * <ul>
     *   <li> <b>MotionMagicExpoVoltage Parameters:</b> 
     *   <ul>
     *     <li> <b>Position:</b> Position to drive toward in rotations.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in volts
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(MotionMagicExpoVoltage request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final position using an
     * exponential motion profile.  Users can optionally provide a torque
     * current feedforward.
     * <p>
     * Motion Magic® Expo produces a motion profile in real-time while
     * attempting to honor the Cruise Velocity (optional) and the
     * mechanism kV and kA, specified via the Motion Magic® configuration
     * values.  Setting Cruise Velocity to 0 will allow the profile to run
     * to the max possible velocity based on Expo_kV.  This control mode
     * does not use the Acceleration or Jerk configs.  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.
     * <ul>
     *   <li> <b>MotionMagicExpoTorqueCurrentFOC Parameters:</b> 
     *   <ul>
     *     <li> <b>Position:</b> Position to drive toward in rotations.
     *     <li> <b>FeedForward:</b> Feedforward to apply in torque current in Amperes. 
     *                           User can use motor's kT to scale Newton-meter to
     *                           Amperes.
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideCoastDurNeutral:</b> 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).
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(MotionMagicExpoTorqueCurrentFOC request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final position using a motion
     * profile.  This dynamic request allows runtime changes to Cruise
     * Velocity, Acceleration, and Jerk.  Users can optionally provide a
     * duty cycle feedforward.  This control requires use of a CANivore.
     * <p>
     * Motion Magic® produces a motion profile in real-time while
     * attempting to honor the specified Cruise Velocity, Acceleration,
     * and Jerk value.  This control mode does not use the Expo_kV or
     * Expo_kA configs.  Target position can be changed on-the-fly and
     * Motion Magic® will do its best to adjust the profile. This control
     * mode is duty cycle based, so relevant closed-loop gains will use
     * fractional duty cycle for the numerator:  +1.0 represents full
     * forward output.
     * <ul>
     *   <li> <b>DynamicMotionMagicDutyCycle Parameters:</b> 
     *   <ul>
     *     <li> <b>Position:</b> Position to drive toward in rotations.
     *     <li> <b>Velocity:</b> Cruise velocity for profiling.  The signage does not
     *                        matter as the device will use the absolute value for
     *                        profile generation.
     *     <li> <b>Acceleration:</b> Acceleration for profiling.  The signage does not
     *                            matter as the device will use the absolute value
     *                            for profile generation
     *     <li> <b>Jerk:</b> Jerk for profiling.  The signage does not matter as the
     *                    device will use the absolute value for profile generation
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in fractional units between -1
     *                           and +1.
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DynamicMotionMagicDutyCycle request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final position using a motion
     * profile.  This dynamic request allows runtime changes to Cruise
     * Velocity, Acceleration, and Jerk.  Users can optionally provide a
     * voltage feedforward.  This control requires use of a CANivore.
     * <p>
     * Motion Magic® produces a motion profile in real-time while
     * attempting to honor the specified Cruise Velocity, Acceleration,
     * and Jerk value.  This control mode does not use the Expo_kV or
     * Expo_kA configs.  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.
     * <ul>
     *   <li> <b>DynamicMotionMagicVoltage Parameters:</b> 
     *   <ul>
     *     <li> <b>Position:</b> Position to drive toward in rotations.
     *     <li> <b>Velocity:</b> Cruise velocity for profiling.  The signage does not
     *                        matter as the device will use the absolute value for
     *                        profile generation.
     *     <li> <b>Acceleration:</b> Acceleration for profiling.  The signage does not
     *                            matter as the device will use the absolute value
     *                            for profile generation.
     *     <li> <b>Jerk:</b> Jerk for profiling.  The signage does not matter as the
     *                    device will use the absolute value for profile generation.
     *     <li> <b>EnableFOC:</b> Set to true to use FOC commutation (requires Phoenix
     *                         Pro), which increases peak power by ~15%. Set to
     *                         false to use trapezoidal commutation.
     *                         <p>
     *                         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.
     *     <li> <b>FeedForward:</b> Feedforward to apply in volts
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideBrakeDurNeutral:</b> 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.
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DynamicMotionMagicVoltage request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Requests Motion Magic® to target a final position using a motion
     * profile.  This dynamic request allows runtime changes to Cruise
     * Velocity, Acceleration, and Jerk.  Users can optionally provide a
     * torque current feedforward.  This control requires use of a
     * CANivore.
     * <p>
     * Motion Magic® produces a motion profile in real-time while
     * attempting to honor the specified Cruise Velocity, Acceleration,
     * and Jerk value.  This control mode does not use the Expo_kV or
     * Expo_kA configs.  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.
     * <ul>
     *   <li> <b>DynamicMotionMagicTorqueCurrentFOC Parameters:</b> 
     *   <ul>
     *     <li> <b>Position:</b> Position to drive toward in rotations.
     *     <li> <b>Velocity:</b> Cruise velocity for profiling.  The signage does not
     *                        matter as the device will use the absolute value for
     *                        profile generation.
     *     <li> <b>Acceleration:</b> Acceleration for profiling.  The signage does not
     *                            matter as the device will use the absolute value
     *                            for profile generation.
     *     <li> <b>Jerk:</b> Jerk for profiling.  The signage does not matter as the
     *                    device will use the absolute value for profile generation.
     *     <li> <b>FeedForward:</b> Feedforward to apply in torque current in Amperes. 
     *                           User can use motor's kT to scale Newton-meter to
     *                           Amperes.
     *     <li> <b>Slot:</b> 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].
     *     <li> <b>OverrideCoastDurNeutral:</b> 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).
     *     <li> <b>LimitForwardMotion:</b> Set to true to force forward limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *     <li> <b>LimitReverseMotion:</b> Set to true to force reverse limiting.  This
     *                                  allows users to use other limit switch
     *                                  sensors connected to robot controller.  This
     *                                  also allows use of active sensors that
     *                                  require external power.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(DynamicMotionMagicTorqueCurrentFOC request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with duty cycle average target and position
     * difference target.
     * 
     * <ul>
     *   <li> <b>Diff_DutyCycleOut_Position Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average DutyCycleOut request of the mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential PositionDutyCycle request of
     *                                   the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_DutyCycleOut_Position request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with position average target and position
     * difference target using dutycycle control.
     * 
     * <ul>
     *   <li> <b>Diff_PositionDutyCycle_Position Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average PositionDutyCycle request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential PositionDutyCycle request of
     *                                   the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_PositionDutyCycle_Position request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with velocity average target and position
     * difference target using dutycycle control.
     * 
     * <ul>
     *   <li> <b>Diff_VelocityDutyCycle_Position Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average VelocityDutyCYcle request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential PositionDutyCycle request of
     *                                   the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_VelocityDutyCycle_Position request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with Motion Magic® average target and position
     * difference target using dutycycle control.
     * 
     * <ul>
     *   <li> <b>Diff_MotionMagicDutyCycle_Position Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average MotionMagicDutyCycle request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential PositionDutyCycle request of
     *                                   the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_MotionMagicDutyCycle_Position request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with duty cycle average target and velocity
     * difference target.
     * 
     * <ul>
     *   <li> <b>Diff_DutyCycleOut_Velocity Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average DutyCycleOut request of the mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential VelocityDutyCycle request of
     *                                   the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_DutyCycleOut_Velocity request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with position average target and velocity
     * difference target using dutycycle control.
     * 
     * <ul>
     *   <li> <b>Diff_PositionDutyCycle_Velocity Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average PositionDutyCycle request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential VelocityDutyCycle request of
     *                                   the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_PositionDutyCycle_Velocity request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with velocity average target and velocity
     * difference target using dutycycle control.
     * 
     * <ul>
     *   <li> <b>Diff_VelocityDutyCycle_Velocity Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average VelocityDutyCycle request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential VelocityDutyCycle request of
     *                                   the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_VelocityDutyCycle_Velocity request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with Motion Magic® average target and velocity
     * difference target using dutycycle control.
     * 
     * <ul>
     *   <li> <b>Diff_MotionMagicDutyCycle_Velocity Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average MotionMagicDutyCycle request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential VelocityDutyCycle request of
     *                                   the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_MotionMagicDutyCycle_Velocity request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with voltage average target and position
     * difference target.
     * 
     * <ul>
     *   <li> <b>Diff_VoltageOut_Position Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average VoltageOut request of the mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential PositionVoltage request of the
     *                                   mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_VoltageOut_Position request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with position average target and position
     * difference target using voltage control.
     * 
     * <ul>
     *   <li> <b>Diff_PositionVoltage_Position Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average PositionVoltage request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential PositionVoltage request of the
     *                                   mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_PositionVoltage_Position request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with velocity average target and position
     * difference target using voltage control.
     * 
     * <ul>
     *   <li> <b>Diff_VelocityVoltage_Position Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average VelocityVoltage request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential PositionVoltage request of the
     *                                   mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_VelocityVoltage_Position request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with Motion Magic® average target and position
     * difference target using voltage control.
     * 
     * <ul>
     *   <li> <b>Diff_MotionMagicVoltage_Position Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average MotionMagicVoltage request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential PositionVoltage request of the
     *                                   mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_MotionMagicVoltage_Position request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with voltage average target and velocity
     * difference target.
     * 
     * <ul>
     *   <li> <b>Diff_VoltageOut_Velocity Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average VoltageOut request of the mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential VelocityVoltage request of the
     *                                   mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_VoltageOut_Velocity request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with position average target and velocity
     * difference target using voltage control.
     * 
     * <ul>
     *   <li> <b>Diff_PositionVoltage_Velocity Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average PositionVoltage request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential VelocityVoltage request of the
     *                                   mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_PositionVoltage_Velocity request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with velocity average target and velocity
     * difference target using voltage control.
     * 
     * <ul>
     *   <li> <b>Diff_VelocityVoltage_Velocity Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average VelocityVoltage request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential VelocityVoltage request of the
     *                                   mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_VelocityVoltage_Velocity request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with Motion Magic® average target and velocity
     * difference target using voltage control.
     * 
     * <ul>
     *   <li> <b>Diff_MotionMagicVoltage_Velocity Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average MotionMagicVoltage request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential VelocityVoltage request of the
     *                                   mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_MotionMagicVoltage_Velocity request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with torque current average target and
     * position difference target.
     * 
     * <ul>
     *   <li> <b>Diff_TorqueCurrentFOC_Position Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average TorqueCurrentFOC request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential PositionTorqueCurrentFOC
     *                                   request of the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_TorqueCurrentFOC_Position request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with position average target and position
     * difference target using torque current control.
     * 
     * <ul>
     *   <li> <b>Diff_PositionTorqueCurrentFOC_Position Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average PositionTorqueCurrentFOC request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential PositionTorqueCurrentFOC
     *                                   request of the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_PositionTorqueCurrentFOC_Position request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with velocity average target and position
     * difference target using torque current control.
     * 
     * <ul>
     *   <li> <b>Diff_VelocityTorqueCurrentFOC_Position Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average VelocityTorqueCurrentFOC request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential PositionTorqueCurrentFOC
     *                                   request of the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_VelocityTorqueCurrentFOC_Position request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with Motion Magic® average target and position
     * difference target using torque current control.
     * 
     * <ul>
     *   <li> <b>Diff_MotionMagicTorqueCurrentFOC_Position Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average MotionMagicTorqueCurrentFOC request of
     *                              the mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential PositionTorqueCurrentFOC
     *                                   request of the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_MotionMagicTorqueCurrentFOC_Position request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with torque current average target and
     * velocity difference target.
     * 
     * <ul>
     *   <li> <b>Diff_TorqueCurrentFOC_Velocity Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average TorqueCurrentFOC request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential VelocityTorqueCurrentFOC
     *                                   request of the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_TorqueCurrentFOC_Velocity request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with position average target and velocity
     * difference target using torque current control.
     * 
     * <ul>
     *   <li> <b>Diff_PositionTorqueCurrentFOC_Velocity Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average PositionTorqueCurrentFOC request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential VelocityTorqueCurrentFOC
     *                                   request of the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_PositionTorqueCurrentFOC_Velocity request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with velocity average target and velocity
     * difference target using torque current control.
     * 
     * <ul>
     *   <li> <b>Diff_VelocityTorqueCurrentFOC_Velocity Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average VelocityTorqueCurrentFOC request of the
     *                              mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential VelocityTorqueCurrentFOC
     *                                   request of the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_VelocityTorqueCurrentFOC_Velocity request)
    {
        return setControlPrivate(request);
    }
    
    /**
     * Differential control with Motion Magic® average target and velocity
     * difference target using torque current control.
     * 
     * <ul>
     *   <li> <b>Diff_MotionMagicTorqueCurrentFOC_Velocity Parameters:</b> 
     *   <ul>
     *     <li> <b>AverageRequest:</b> Average MotionMagicTorqueCurrentFOC request of
     *                              the mechanism.
     *     <li> <b>DifferentialRequest:</b> Differential VelocityTorqueCurrentFOC
     *                                   request of the mechanism.
     *   </ul>
     * </ul>
     *
     * @param request                Control object to request of the device
     * @return Code response of the request
     */
    public StatusCode setControl(Diff_MotionMagicTorqueCurrentFOC_Velocity request)
    {
        return setControlPrivate(request);
    }

    /**
     * Control motor with generic control request object.
     * <p>
     * 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
     * @return Status Code of the request, 0 is OK
     */
    public StatusCode setControl(ControlRequest request)
    {
        if (request instanceof DutyCycleOut)
            return setControl((DutyCycleOut)request);
        if (request instanceof TorqueCurrentFOC)
            return setControl((TorqueCurrentFOC)request);
        if (request instanceof VoltageOut)
            return setControl((VoltageOut)request);
        if (request instanceof PositionDutyCycle)
            return setControl((PositionDutyCycle)request);
        if (request instanceof PositionVoltage)
            return setControl((PositionVoltage)request);
        if (request instanceof PositionTorqueCurrentFOC)
            return setControl((PositionTorqueCurrentFOC)request);
        if (request instanceof VelocityDutyCycle)
            return setControl((VelocityDutyCycle)request);
        if (request instanceof VelocityVoltage)
            return setControl((VelocityVoltage)request);
        if (request instanceof VelocityTorqueCurrentFOC)
            return setControl((VelocityTorqueCurrentFOC)request);
        if (request instanceof MotionMagicDutyCycle)
            return setControl((MotionMagicDutyCycle)request);
        if (request instanceof MotionMagicVoltage)
            return setControl((MotionMagicVoltage)request);
        if (request instanceof MotionMagicTorqueCurrentFOC)
            return setControl((MotionMagicTorqueCurrentFOC)request);
        if (request instanceof DifferentialDutyCycle)
            return setControl((DifferentialDutyCycle)request);
        if (request instanceof DifferentialVoltage)
            return setControl((DifferentialVoltage)request);
        if (request instanceof DifferentialPositionDutyCycle)
            return setControl((DifferentialPositionDutyCycle)request);
        if (request instanceof DifferentialPositionVoltage)
            return setControl((DifferentialPositionVoltage)request);
        if (request instanceof DifferentialVelocityDutyCycle)
            return setControl((DifferentialVelocityDutyCycle)request);
        if (request instanceof DifferentialVelocityVoltage)
            return setControl((DifferentialVelocityVoltage)request);
        if (request instanceof DifferentialMotionMagicDutyCycle)
            return setControl((DifferentialMotionMagicDutyCycle)request);
        if (request instanceof DifferentialMotionMagicVoltage)
            return setControl((DifferentialMotionMagicVoltage)request);
        if (request instanceof Follower)
            return setControl((Follower)request);
        if (request instanceof StrictFollower)
            return setControl((StrictFollower)request);
        if (request instanceof DifferentialFollower)
            return setControl((DifferentialFollower)request);
        if (request instanceof DifferentialStrictFollower)
            return setControl((DifferentialStrictFollower)request);
        if (request instanceof NeutralOut)
            return setControl((NeutralOut)request);
        if (request instanceof CoastOut)
            return setControl((CoastOut)request);
        if (request instanceof StaticBrake)
            return setControl((StaticBrake)request);
        if (request instanceof MusicTone)
            return setControl((MusicTone)request);
        if (request instanceof MotionMagicVelocityDutyCycle)
            return setControl((MotionMagicVelocityDutyCycle)request);
        if (request instanceof MotionMagicVelocityTorqueCurrentFOC)
            return setControl((MotionMagicVelocityTorqueCurrentFOC)request);
        if (request instanceof MotionMagicVelocityVoltage)
            return setControl((MotionMagicVelocityVoltage)request);
        if (request instanceof MotionMagicExpoDutyCycle)
            return setControl((MotionMagicExpoDutyCycle)request);
        if (request instanceof MotionMagicExpoVoltage)
            return setControl((MotionMagicExpoVoltage)request);
        if (request instanceof MotionMagicExpoTorqueCurrentFOC)
            return setControl((MotionMagicExpoTorqueCurrentFOC)request);
        if (request instanceof DynamicMotionMagicDutyCycle)
            return setControl((DynamicMotionMagicDutyCycle)request);
        if (request instanceof DynamicMotionMagicVoltage)
            return setControl((DynamicMotionMagicVoltage)request);
        if (request instanceof DynamicMotionMagicTorqueCurrentFOC)
            return setControl((DynamicMotionMagicTorqueCurrentFOC)request);
        if (request instanceof Diff_DutyCycleOut_Position)
            return setControl((Diff_DutyCycleOut_Position)request);
        if (request instanceof Diff_PositionDutyCycle_Position)
            return setControl((Diff_PositionDutyCycle_Position)request);
        if (request instanceof Diff_VelocityDutyCycle_Position)
            return setControl((Diff_VelocityDutyCycle_Position)request);
        if (request instanceof Diff_MotionMagicDutyCycle_Position)
            return setControl((Diff_MotionMagicDutyCycle_Position)request);
        if (request instanceof Diff_DutyCycleOut_Velocity)
            return setControl((Diff_DutyCycleOut_Velocity)request);
        if (request instanceof Diff_PositionDutyCycle_Velocity)
            return setControl((Diff_PositionDutyCycle_Velocity)request);
        if (request instanceof Diff_VelocityDutyCycle_Velocity)
            return setControl((Diff_VelocityDutyCycle_Velocity)request);
        if (request instanceof Diff_MotionMagicDutyCycle_Velocity)
            return setControl((Diff_MotionMagicDutyCycle_Velocity)request);
        if (request instanceof Diff_VoltageOut_Position)
            return setControl((Diff_VoltageOut_Position)request);
        if (request instanceof Diff_PositionVoltage_Position)
            return setControl((Diff_PositionVoltage_Position)request);
        if (request instanceof Diff_VelocityVoltage_Position)
            return setControl((Diff_VelocityVoltage_Position)request);
        if (request instanceof Diff_MotionMagicVoltage_Position)
            return setControl((Diff_MotionMagicVoltage_Position)request);
        if (request instanceof Diff_VoltageOut_Velocity)
            return setControl((Diff_VoltageOut_Velocity)request);
        if (request instanceof Diff_PositionVoltage_Velocity)
            return setControl((Diff_PositionVoltage_Velocity)request);
        if (request instanceof Diff_VelocityVoltage_Velocity)
            return setControl((Diff_VelocityVoltage_Velocity)request);
        if (request instanceof Diff_MotionMagicVoltage_Velocity)
            return setControl((Diff_MotionMagicVoltage_Velocity)request);
        if (request instanceof Diff_TorqueCurrentFOC_Position)
            return setControl((Diff_TorqueCurrentFOC_Position)request);
        if (request instanceof Diff_PositionTorqueCurrentFOC_Position)
            return setControl((Diff_PositionTorqueCurrentFOC_Position)request);
        if (request instanceof Diff_VelocityTorqueCurrentFOC_Position)
            return setControl((Diff_VelocityTorqueCurrentFOC_Position)request);
        if (request instanceof Diff_MotionMagicTorqueCurrentFOC_Position)
            return setControl((Diff_MotionMagicTorqueCurrentFOC_Position)request);
        if (request instanceof Diff_TorqueCurrentFOC_Velocity)
            return setControl((Diff_TorqueCurrentFOC_Velocity)request);
        if (request instanceof Diff_PositionTorqueCurrentFOC_Velocity)
            return setControl((Diff_PositionTorqueCurrentFOC_Velocity)request);
        if (request instanceof Diff_VelocityTorqueCurrentFOC_Velocity)
            return setControl((Diff_VelocityTorqueCurrentFOC_Velocity)request);
        if (request instanceof Diff_MotionMagicTorqueCurrentFOC_Velocity)
            return setControl((Diff_MotionMagicTorqueCurrentFOC_Velocity)request);
        return StatusCode.NotSupported;
    }

    
    /**
     * Sets the mechanism position of the device in mechanism rotations.
     * 
     * @param newValue Value to set to. Units are in rotations.
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode setPosition(double newValue, double timeoutSeconds) {
        return getConfigurator().setPosition(newValue, timeoutSeconds);
    }
    /**
     * Sets the mechanism position of the device in mechanism rotations.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @param newValue Value to set to. Units are in rotations.
     * @return StatusCode of the set command
     */
    public StatusCode setPosition(double newValue) {
        return setPosition(newValue, 0.050);
    }
    
    /**
     * Clear the sticky faults in the device.
     * <p>
     * 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.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFaults(double timeoutSeconds) {
        return getConfigurator().clearStickyFaults(timeoutSeconds);
    }
    /**
     * Clear the sticky faults in the device.
     * <p>
     * This typically has no impact on the device functionality.  Instead,
     * it just clears telemetry faults that are accessible via API and
     * Tuner Self-Test.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFaults() {
        return clearStickyFaults(0.050);
    }
    
    /**
     * Clear sticky fault: Hardware fault occurred
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_Hardware(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_Hardware(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Hardware fault occurred
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_Hardware() {
        return clearStickyFault_Hardware(0.050);
    }
    
    /**
     * Clear sticky fault: Processor temperature exceeded limit
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_ProcTemp(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_ProcTemp(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Processor temperature exceeded limit
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_ProcTemp() {
        return clearStickyFault_ProcTemp(0.050);
    }
    
    /**
     * Clear sticky fault: Device temperature exceeded limit
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_DeviceTemp(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_DeviceTemp(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Device temperature exceeded limit
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_DeviceTemp() {
        return clearStickyFault_DeviceTemp(0.050);
    }
    
    /**
     * Clear sticky fault: Device supply voltage dropped to near brownout
     * levels
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_Undervoltage(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_Undervoltage(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Device supply voltage dropped to near brownout
     * levels
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_Undervoltage() {
        return clearStickyFault_Undervoltage(0.050);
    }
    
    /**
     * Clear sticky fault: Device boot while detecting the enable signal
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_BootDuringEnable(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_BootDuringEnable(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Device boot while detecting the enable signal
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_BootDuringEnable() {
        return clearStickyFault_BootDuringEnable(0.050);
    }
    
    /**
     * Clear sticky fault: Bridge was disabled most likely due to supply
     * voltage dropping too low.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_BridgeBrownout(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_BridgeBrownout(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Bridge was disabled most likely due to supply
     * voltage dropping too low.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_BridgeBrownout() {
        return clearStickyFault_BridgeBrownout(0.050);
    }
    
    /**
     * Clear sticky fault: The remote sensor has reset.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_RemoteSensorReset(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_RemoteSensorReset(timeoutSeconds);
    }
    /**
     * Clear sticky fault: The remote sensor has reset.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_RemoteSensorReset() {
        return clearStickyFault_RemoteSensorReset(0.050);
    }
    
    /**
     * Clear sticky fault: The remote Talon FX used for differential
     * control is not present on CAN Bus.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_MissingDifferentialFX(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_MissingDifferentialFX(timeoutSeconds);
    }
    /**
     * Clear sticky fault: The remote Talon FX used for differential
     * control is not present on CAN Bus.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_MissingDifferentialFX() {
        return clearStickyFault_MissingDifferentialFX(0.050);
    }
    
    /**
     * Clear sticky fault: The remote sensor position has overflowed.
     * Because of the nature of remote sensors, it is possible for the
     * remote sensor position to overflow beyond what is supported by the
     * status signal frame. However, this is rare and cannot occur over
     * the course of an FRC match under normal use.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_RemoteSensorPosOverflow(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_RemoteSensorPosOverflow(timeoutSeconds);
    }
    /**
     * Clear sticky fault: The remote sensor position has overflowed.
     * Because of the nature of remote sensors, it is possible for the
     * remote sensor position to overflow beyond what is supported by the
     * status signal frame. However, this is rare and cannot occur over
     * the course of an FRC match under normal use.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_RemoteSensorPosOverflow() {
        return clearStickyFault_RemoteSensorPosOverflow(0.050);
    }
    
    /**
     * Clear sticky fault: Supply Voltage has exceeded the maximum voltage
     * rating of device.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_OverSupplyV(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_OverSupplyV(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Supply Voltage has exceeded the maximum voltage
     * rating of device.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_OverSupplyV() {
        return clearStickyFault_OverSupplyV(0.050);
    }
    
    /**
     * Clear sticky fault: Supply Voltage is unstable.  Ensure you are
     * using a battery and current limited power supply.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_UnstableSupplyV(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_UnstableSupplyV(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Supply Voltage is unstable.  Ensure you are
     * using a battery and current limited power supply.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_UnstableSupplyV() {
        return clearStickyFault_UnstableSupplyV(0.050);
    }
    
    /**
     * Clear sticky fault: Reverse limit switch has been asserted.  Output
     * is set to neutral.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_ReverseHardLimit(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_ReverseHardLimit(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Reverse limit switch has been asserted.  Output
     * is set to neutral.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_ReverseHardLimit() {
        return clearStickyFault_ReverseHardLimit(0.050);
    }
    
    /**
     * Clear sticky fault: Forward limit switch has been asserted.  Output
     * is set to neutral.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_ForwardHardLimit(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_ForwardHardLimit(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Forward limit switch has been asserted.  Output
     * is set to neutral.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_ForwardHardLimit() {
        return clearStickyFault_ForwardHardLimit(0.050);
    }
    
    /**
     * Clear sticky fault: Reverse soft limit has been asserted.  Output
     * is set to neutral.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_ReverseSoftLimit(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_ReverseSoftLimit(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Reverse soft limit has been asserted.  Output
     * is set to neutral.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_ReverseSoftLimit() {
        return clearStickyFault_ReverseSoftLimit(0.050);
    }
    
    /**
     * Clear sticky fault: Forward soft limit has been asserted.  Output
     * is set to neutral.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_ForwardSoftLimit(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_ForwardSoftLimit(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Forward soft limit has been asserted.  Output
     * is set to neutral.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_ForwardSoftLimit() {
        return clearStickyFault_ForwardSoftLimit(0.050);
    }
    
    /**
     * Clear sticky fault: The remote sensor's data is no longer trusted.
     * This can happen if the remote sensor disappears from the CAN bus or
     * if the remote sensor indicates its data is no longer valid, such as
     * when a CANcoder's magnet strength falls into the "red" range.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_RemoteSensorDataInvalid(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_RemoteSensorDataInvalid(timeoutSeconds);
    }
    /**
     * Clear sticky fault: The remote sensor's data is no longer trusted.
     * This can happen if the remote sensor disappears from the CAN bus or
     * if the remote sensor indicates its data is no longer valid, such as
     * when a CANcoder's magnet strength falls into the "red" range.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_RemoteSensorDataInvalid() {
        return clearStickyFault_RemoteSensorDataInvalid(0.050);
    }
    
    /**
     * Clear sticky fault: 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.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_FusedSensorOutOfSync(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_FusedSensorOutOfSync(timeoutSeconds);
    }
    /**
     * Clear sticky fault: 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.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_FusedSensorOutOfSync() {
        return clearStickyFault_FusedSensorOutOfSync(0.050);
    }
    
    /**
     * Clear sticky fault: Stator current limit occured.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_StatorCurrLimit(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_StatorCurrLimit(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Stator current limit occured.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_StatorCurrLimit() {
        return clearStickyFault_StatorCurrLimit(0.050);
    }
    
    /**
     * Clear sticky fault: Supply current limit occured.
     * 
     * @param timeoutSeconds Maximum time to wait up to in seconds.
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_SupplyCurrLimit(double timeoutSeconds) {
        return getConfigurator().clearStickyFault_SupplyCurrLimit(timeoutSeconds);
    }
    /**
     * Clear sticky fault: Supply current limit occured.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     * 
     * @return StatusCode of the set command
     */
    public StatusCode clearStickyFault_SupplyCurrLimit() {
        return clearStickyFault_SupplyCurrLimit(0.050);
    }
}