:py:mod:`phoenix6.configs.config_groups` ======================================== .. py:module:: phoenix6.configs.config_groups Module Contents --------------- .. py:class:: SupportsSerialization Bases: :py:obj:`Protocol` Base class for protocol classes. Protocol classes are defined as:: class Proto(Protocol): def meth(self) -> int: ... Such classes are primarily used with static type checkers that recognize structural subtyping (static duck-typing). For example:: class C: def meth(self) -> int: return 0 def func(x: Proto) -> int: return x.meth() func(C()) # Passes static type check See PEP 544 for details. Protocol classes decorated with @typing.runtime_checkable act as simple-minded runtime protocols that check only the presence of given attributes, ignoring their type signatures. Protocol classes can be generic, they are defined as:: class GenProto[T](Protocol): def meth(self) -> T: ... .. py:method:: serialize() -> str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode .. py:class:: MagnetSensorConfigs Configs that affect the magnet sensor and how to interpret it. Includes sensor direction, the sensor discontinuity point, and the magnet offset. .. py:attribute:: sensor_direction :type: SensorDirectionValue Direction of the sensor to determine positive rotation, as seen facing the LED side of the CANcoder. .. py:attribute:: magnet_offset :type: phoenix6.units.rotation :value: '0' This offset is added to the reported position, allowing the application to trim the zero position. When set to the default value of zero, position reports zero when magnet north pole aligns with the LED. - Minimum Value: -1 - Maximum Value: 1 - Default Value: 0 - Units: rotations .. py:attribute:: absolute_sensor_discontinuity_point :type: phoenix6.units.rotation :value: '0.5' The positive discontinuity point of the absolute sensor in rotations. This determines the point at which the absolute sensor wraps around, keeping the absolute position (after offset) in the range [x-1, x). - Setting this to 1 makes the absolute position unsigned [0, 1) - Setting this to 0.5 makes the absolute position signed [-0.5, 0.5) - Setting this to 0 makes the absolute position always negative [-1, 0) Many rotational mechanisms such as arms have a region of motion that is unreachable. This should be set to the center of that region of motion, in non-negative rotations. This affects the position of the device at bootup. For example, consider an arm which can travel from -0.2 to 0.6 rotations with a little leeway, where 0 is horizontally forward. Since -0.2 rotations has the same absolute position as 0.8 rotations, we can say that the arm typically does not travel in the range (0.6, 0.8) rotations. As a result, the discontinuity point would be the center of that range, which is 0.7 rotations. This results in an absolute sensor range of [-0.3, 0.7) rotations. Given a total range of motion less than 1 rotation, users can calculate the discontinuity point using mean(lowerLimit, upperLimit) + 0.5. If that results in a value outside the range [0, 1], either cap the value to [0, 1], or add/subtract 1.0 rotation from your lower and upper limits of motion. On a Talon motor controller, this is only supported when using the PulseWidth sensor source. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 0.5 - Units: rotations .. py:method:: with_sensor_direction(new_sensor_direction: SensorDirectionValue) -> MagnetSensorConfigs Modifies this configuration's sensor_direction parameter and returns itself for method-chaining and easier to use config API. Direction of the sensor to determine positive rotation, as seen facing the LED side of the CANcoder. :param new_sensor_direction: Parameter to modify :type new_sensor_direction: SensorDirectionValue :returns: Itself :rtype: MagnetSensorConfigs .. py:method:: with_magnet_offset(new_magnet_offset: phoenix6.units.rotation) -> MagnetSensorConfigs Modifies this configuration's magnet_offset parameter and returns itself for method-chaining and easier to use config API. This offset is added to the reported position, allowing the application to trim the zero position. When set to the default value of zero, position reports zero when magnet north pole aligns with the LED. - Minimum Value: -1 - Maximum Value: 1 - Default Value: 0 - Units: rotations :param new_magnet_offset: Parameter to modify :type new_magnet_offset: rotation :returns: Itself :rtype: MagnetSensorConfigs .. py:method:: with_absolute_sensor_discontinuity_point(new_absolute_sensor_discontinuity_point: phoenix6.units.rotation) -> MagnetSensorConfigs Modifies this configuration's absolute_sensor_discontinuity_point parameter and returns itself for method-chaining and easier to use config API. The positive discontinuity point of the absolute sensor in rotations. This determines the point at which the absolute sensor wraps around, keeping the absolute position (after offset) in the range [x-1, x). - Setting this to 1 makes the absolute position unsigned [0, 1) - Setting this to 0.5 makes the absolute position signed [-0.5, 0.5) - Setting this to 0 makes the absolute position always negative [-1, 0) Many rotational mechanisms such as arms have a region of motion that is unreachable. This should be set to the center of that region of motion, in non-negative rotations. This affects the position of the device at bootup. For example, consider an arm which can travel from -0.2 to 0.6 rotations with a little leeway, where 0 is horizontally forward. Since -0.2 rotations has the same absolute position as 0.8 rotations, we can say that the arm typically does not travel in the range (0.6, 0.8) rotations. As a result, the discontinuity point would be the center of that range, which is 0.7 rotations. This results in an absolute sensor range of [-0.3, 0.7) rotations. Given a total range of motion less than 1 rotation, users can calculate the discontinuity point using mean(lowerLimit, upperLimit) + 0.5. If that results in a value outside the range [0, 1], either cap the value to [0, 1], or add/subtract 1.0 rotation from your lower and upper limits of motion. On a Talon motor controller, this is only supported when using the PulseWidth sensor source. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 0.5 - Units: rotations :param new_absolute_sensor_discontinuity_point: Parameter to modify :type new_absolute_sensor_discontinuity_point: rotation :returns: Itself :rtype: MagnetSensorConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: MountPoseConfigs Configs for Pigeon 2's Mount Pose configuration. These configs allow the Pigeon2 to be mounted in whatever orientation that's desired and ensure the reported Yaw/Pitch/Roll is from the robot's reference. .. py:attribute:: mount_pose_yaw :type: phoenix6.units.degree :value: '0' The mounting calibration yaw-component. - Minimum Value: -360 - Maximum Value: 360 - Default Value: 0 - Units: deg .. py:attribute:: mount_pose_pitch :type: phoenix6.units.degree :value: '0' The mounting calibration pitch-component. - Minimum Value: -360 - Maximum Value: 360 - Default Value: 0 - Units: deg .. py:attribute:: mount_pose_roll :type: phoenix6.units.degree :value: '0' The mounting calibration roll-component. - Minimum Value: -360 - Maximum Value: 360 - Default Value: 0 - Units: deg .. py:method:: with_mount_pose_yaw(new_mount_pose_yaw: phoenix6.units.degree) -> MountPoseConfigs Modifies this configuration's mount_pose_yaw parameter and returns itself for method-chaining and easier to use config API. The mounting calibration yaw-component. - Minimum Value: -360 - Maximum Value: 360 - Default Value: 0 - Units: deg :param new_mount_pose_yaw: Parameter to modify :type new_mount_pose_yaw: degree :returns: Itself :rtype: MountPoseConfigs .. py:method:: with_mount_pose_pitch(new_mount_pose_pitch: phoenix6.units.degree) -> MountPoseConfigs Modifies this configuration's mount_pose_pitch parameter and returns itself for method-chaining and easier to use config API. The mounting calibration pitch-component. - Minimum Value: -360 - Maximum Value: 360 - Default Value: 0 - Units: deg :param new_mount_pose_pitch: Parameter to modify :type new_mount_pose_pitch: degree :returns: Itself :rtype: MountPoseConfigs .. py:method:: with_mount_pose_roll(new_mount_pose_roll: phoenix6.units.degree) -> MountPoseConfigs Modifies this configuration's mount_pose_roll parameter and returns itself for method-chaining and easier to use config API. The mounting calibration roll-component. - Minimum Value: -360 - Maximum Value: 360 - Default Value: 0 - Units: deg :param new_mount_pose_roll: Parameter to modify :type new_mount_pose_roll: degree :returns: Itself :rtype: MountPoseConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: GyroTrimConfigs Configs to trim the Pigeon2's gyroscope. Pigeon2 allows the user to trim the gyroscope's sensitivity. While this isn't necessary for the Pigeon2, as it comes calibrated out-of-the-box, users can make use of this to make the Pigeon2 even more accurate for their application. .. py:attribute:: gyro_scalar_x :type: float :value: '0' The gyro scalar component for the X axis. - Minimum Value: -180 - Maximum Value: 180 - Default Value: 0 - Units: deg per rotation .. py:attribute:: gyro_scalar_y :type: float :value: '0' The gyro scalar component for the Y axis. - Minimum Value: -180 - Maximum Value: 180 - Default Value: 0 - Units: deg per rotation .. py:attribute:: gyro_scalar_z :type: float :value: '0' The gyro scalar component for the Z axis. - Minimum Value: -180 - Maximum Value: 180 - Default Value: 0 - Units: deg per rotation .. py:method:: with_gyro_scalar_x(new_gyro_scalar_x: float) -> GyroTrimConfigs Modifies this configuration's gyro_scalar_x parameter and returns itself for method-chaining and easier to use config API. The gyro scalar component for the X axis. - Minimum Value: -180 - Maximum Value: 180 - Default Value: 0 - Units: deg per rotation :param new_gyro_scalar_x: Parameter to modify :type new_gyro_scalar_x: float :returns: Itself :rtype: GyroTrimConfigs .. py:method:: with_gyro_scalar_y(new_gyro_scalar_y: float) -> GyroTrimConfigs Modifies this configuration's gyro_scalar_y parameter and returns itself for method-chaining and easier to use config API. The gyro scalar component for the Y axis. - Minimum Value: -180 - Maximum Value: 180 - Default Value: 0 - Units: deg per rotation :param new_gyro_scalar_y: Parameter to modify :type new_gyro_scalar_y: float :returns: Itself :rtype: GyroTrimConfigs .. py:method:: with_gyro_scalar_z(new_gyro_scalar_z: float) -> GyroTrimConfigs Modifies this configuration's gyro_scalar_z parameter and returns itself for method-chaining and easier to use config API. The gyro scalar component for the Z axis. - Minimum Value: -180 - Maximum Value: 180 - Default Value: 0 - Units: deg per rotation :param new_gyro_scalar_z: Parameter to modify :type new_gyro_scalar_z: float :returns: Itself :rtype: GyroTrimConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: Pigeon2FeaturesConfigs Configs to enable/disable various features of the Pigeon2. These configs allow the user to enable or disable various aspects of the Pigeon2. .. py:attribute:: enable_compass :type: bool :value: 'False' Turns on or off the magnetometer fusing for 9-axis. FRC users are not recommended to turn this on, as the magnetic influence of the robot will likely negatively affect the performance of the Pigeon2. - Default Value: False .. py:attribute:: disable_temperature_compensation :type: bool :value: 'False' Disables using the temperature compensation feature. - Default Value: False .. py:attribute:: disable_no_motion_calibration :type: bool :value: 'False' Disables using the no-motion calibration feature. - Default Value: False .. py:method:: with_enable_compass(new_enable_compass: bool) -> Pigeon2FeaturesConfigs Modifies this configuration's enable_compass parameter and returns itself for method-chaining and easier to use config API. Turns on or off the magnetometer fusing for 9-axis. FRC users are not recommended to turn this on, as the magnetic influence of the robot will likely negatively affect the performance of the Pigeon2. - Default Value: False :param new_enable_compass: Parameter to modify :type new_enable_compass: bool :returns: Itself :rtype: Pigeon2FeaturesConfigs .. py:method:: with_disable_temperature_compensation(new_disable_temperature_compensation: bool) -> Pigeon2FeaturesConfigs Modifies this configuration's disable_temperature_compensation parameter and returns itself for method-chaining and easier to use config API. Disables using the temperature compensation feature. - Default Value: False :param new_disable_temperature_compensation: Parameter to modify :type new_disable_temperature_compensation: bool :returns: Itself :rtype: Pigeon2FeaturesConfigs .. py:method:: with_disable_no_motion_calibration(new_disable_no_motion_calibration: bool) -> Pigeon2FeaturesConfigs Modifies this configuration's disable_no_motion_calibration parameter and returns itself for method-chaining and easier to use config API. Disables using the no-motion calibration feature. - Default Value: False :param new_disable_no_motion_calibration: Parameter to modify :type new_disable_no_motion_calibration: bool :returns: Itself :rtype: Pigeon2FeaturesConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: MotorOutputConfigs Configs that directly affect motor output. Includes motor invert, neutral mode, and other features related to motor output. .. py:attribute:: inverted :type: InvertedValue Invert state of the device as seen from the front of the motor. .. py:attribute:: neutral_mode :type: NeutralModeValue The state of the motor controller bridge when output is neutral or disabled. .. py:attribute:: duty_cycle_neutral_deadband :type: float :value: '0' Configures the output deadband duty cycle during duty cycle and voltage based control modes. - Minimum Value: 0.0 - Maximum Value: 0.25 - Default Value: 0 - Units: fractional .. py:attribute:: peak_forward_duty_cycle :type: float :value: '1' Maximum (forward) output during duty cycle based control modes. - Minimum Value: -1.0 - Maximum Value: 1.0 - Default Value: 1 - Units: fractional .. py:attribute:: peak_reverse_duty_cycle :type: float :value: '-1' Minimum (reverse) output during duty cycle based control modes. - Minimum Value: -1.0 - Maximum Value: 1.0 - Default Value: -1 - Units: fractional .. py:attribute:: control_timesync_freq_hz :type: phoenix6.units.hertz :value: '0' When a control request UseTimesync is enabled, this determines the time-sychronized frequency at which control requests are applied. The application of the control request will be delayed until the next timesync boundary at the frequency defined by this config. When set to 0 Hz, timesync will never be used for control requests, regardless of the value of UseTimesync. - Minimum Value: 50 - Maximum Value: 500 - Default Value: 0 - Units: Hz .. py:method:: with_inverted(new_inverted: InvertedValue) -> MotorOutputConfigs Modifies this configuration's inverted parameter and returns itself for method-chaining and easier to use config API. Invert state of the device as seen from the front of the motor. :param new_inverted: Parameter to modify :type new_inverted: InvertedValue :returns: Itself :rtype: MotorOutputConfigs .. py:method:: with_neutral_mode(new_neutral_mode: NeutralModeValue) -> MotorOutputConfigs Modifies this configuration's neutral_mode parameter and returns itself for method-chaining and easier to use config API. The state of the motor controller bridge when output is neutral or disabled. :param new_neutral_mode: Parameter to modify :type new_neutral_mode: NeutralModeValue :returns: Itself :rtype: MotorOutputConfigs .. py:method:: with_duty_cycle_neutral_deadband(new_duty_cycle_neutral_deadband: float) -> MotorOutputConfigs Modifies this configuration's duty_cycle_neutral_deadband parameter and returns itself for method-chaining and easier to use config API. Configures the output deadband duty cycle during duty cycle and voltage based control modes. - Minimum Value: 0.0 - Maximum Value: 0.25 - Default Value: 0 - Units: fractional :param new_duty_cycle_neutral_deadband: Parameter to modify :type new_duty_cycle_neutral_deadband: float :returns: Itself :rtype: MotorOutputConfigs .. py:method:: with_peak_forward_duty_cycle(new_peak_forward_duty_cycle: float) -> MotorOutputConfigs Modifies this configuration's peak_forward_duty_cycle parameter and returns itself for method-chaining and easier to use config API. Maximum (forward) output during duty cycle based control modes. - Minimum Value: -1.0 - Maximum Value: 1.0 - Default Value: 1 - Units: fractional :param new_peak_forward_duty_cycle: Parameter to modify :type new_peak_forward_duty_cycle: float :returns: Itself :rtype: MotorOutputConfigs .. py:method:: with_peak_reverse_duty_cycle(new_peak_reverse_duty_cycle: float) -> MotorOutputConfigs Modifies this configuration's peak_reverse_duty_cycle parameter and returns itself for method-chaining and easier to use config API. Minimum (reverse) output during duty cycle based control modes. - Minimum Value: -1.0 - Maximum Value: 1.0 - Default Value: -1 - Units: fractional :param new_peak_reverse_duty_cycle: Parameter to modify :type new_peak_reverse_duty_cycle: float :returns: Itself :rtype: MotorOutputConfigs .. py:method:: with_control_timesync_freq_hz(new_control_timesync_freq_hz: phoenix6.units.hertz) -> MotorOutputConfigs Modifies this configuration's control_timesync_freq_hz parameter and returns itself for method-chaining and easier to use config API. When a control request UseTimesync is enabled, this determines the time-sychronized frequency at which control requests are applied. The application of the control request will be delayed until the next timesync boundary at the frequency defined by this config. When set to 0 Hz, timesync will never be used for control requests, regardless of the value of UseTimesync. - Minimum Value: 50 - Maximum Value: 500 - Default Value: 0 - Units: Hz :param new_control_timesync_freq_hz: Parameter to modify :type new_control_timesync_freq_hz: hertz :returns: Itself :rtype: MotorOutputConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: CurrentLimitsConfigs Configs that directly affect current limiting features. Contains the supply/stator current limit thresholds and whether to enable them. .. py:attribute:: stator_current_limit :type: phoenix6.units.ampere :value: '120' The amount of current allowed in the motor (motoring and regen current). Note this requires StatorCurrentLimitEnable to be true. For torque current control, this is applied in addition to the PeakForwardTorqueCurrent and PeakReverseTorqueCurrent in TorqueCurrentConfigs. Stator current is directly proportional to torque, so this limit can be used to restrict the torque output of the motor, such as preventing wheel slip for a drivetrain. Additionally, stator current limits can prevent brownouts during acceleration; supply current will never exceed the stator current limit and is often significantly lower than stator current. A reasonable starting point for a stator current limit is 120 A, with values commonly ranging from 80-160 A. Mechanisms with a hard stop may need a smaller limit to reduce the torque applied when running into the hard stop. - Minimum Value: 0.0 - Maximum Value: 800.0 - Default Value: 120 - Units: A .. py:attribute:: stator_current_limit_enable :type: bool :value: 'True' Enable motor stator current limiting. - Default Value: True .. py:attribute:: supply_current_limit :type: phoenix6.units.ampere :value: '70' The absolute maximum amount of supply current allowed. Note this requires SupplyCurrentLimitEnable to be true. Use SupplyCurrentLowerLimit and SupplyCurrentLowerTime to reduce the supply current limit after the time threshold is exceeded. Supply current is the current drawn from the battery, so this limit can be used to prevent breaker trips and improve battery longevity. Additionally, in scenarios where the robot experiences brownouts despite configuring stator current limits, a supply current limit can further help avoid brownouts. However, it is important to note that such brownouts may be caused by a bad battery or poor power wiring. A reasonable starting point for a supply current limit is 70 A with a lower limit of 40 A after 1.0 second. Supply current limits commonly range from 20-80 A depending on the breaker used. - Minimum Value: 0.0 - Maximum Value: 800.0 - Default Value: 70 - Units: A .. py:attribute:: supply_current_limit_enable :type: bool :value: 'True' Enable motor supply current limiting. - Default Value: True .. py:attribute:: supply_current_lower_limit :type: phoenix6.units.ampere :value: '40' The amount of supply current allowed after the regular SupplyCurrentLimit is active for longer than SupplyCurrentLowerTime. This allows higher current draws for a fixed period of time before reducing the current limit to protect breakers. This has no effect if SupplyCurrentLimit is lower than this value or SupplyCurrentLowerTime is 0. - Minimum Value: 0.0 - Maximum Value: 500 - Default Value: 40 - Units: A .. py:attribute:: supply_current_lower_time :type: phoenix6.units.second :value: '1.0' Reduces supply current to the SupplyCurrentLowerLimit after limiting to SupplyCurrentLimit for this period of time. If this is set to 0, SupplyCurrentLowerLimit will be ignored. - Minimum Value: 0.0 - Maximum Value: 5.0 - Default Value: 1.0 - Units: seconds .. py:method:: with_stator_current_limit(new_stator_current_limit: phoenix6.units.ampere) -> CurrentLimitsConfigs Modifies this configuration's stator_current_limit parameter and returns itself for method-chaining and easier to use config API. The amount of current allowed in the motor (motoring and regen current). Note this requires StatorCurrentLimitEnable to be true. For torque current control, this is applied in addition to the PeakForwardTorqueCurrent and PeakReverseTorqueCurrent in TorqueCurrentConfigs. Stator current is directly proportional to torque, so this limit can be used to restrict the torque output of the motor, such as preventing wheel slip for a drivetrain. Additionally, stator current limits can prevent brownouts during acceleration; supply current will never exceed the stator current limit and is often significantly lower than stator current. A reasonable starting point for a stator current limit is 120 A, with values commonly ranging from 80-160 A. Mechanisms with a hard stop may need a smaller limit to reduce the torque applied when running into the hard stop. - Minimum Value: 0.0 - Maximum Value: 800.0 - Default Value: 120 - Units: A :param new_stator_current_limit: Parameter to modify :type new_stator_current_limit: ampere :returns: Itself :rtype: CurrentLimitsConfigs .. py:method:: with_stator_current_limit_enable(new_stator_current_limit_enable: bool) -> CurrentLimitsConfigs Modifies this configuration's stator_current_limit_enable parameter and returns itself for method-chaining and easier to use config API. Enable motor stator current limiting. - Default Value: True :param new_stator_current_limit_enable: Parameter to modify :type new_stator_current_limit_enable: bool :returns: Itself :rtype: CurrentLimitsConfigs .. py:method:: with_supply_current_limit(new_supply_current_limit: phoenix6.units.ampere) -> CurrentLimitsConfigs Modifies this configuration's supply_current_limit parameter and returns itself for method-chaining and easier to use config API. The absolute maximum amount of supply current allowed. Note this requires SupplyCurrentLimitEnable to be true. Use SupplyCurrentLowerLimit and SupplyCurrentLowerTime to reduce the supply current limit after the time threshold is exceeded. Supply current is the current drawn from the battery, so this limit can be used to prevent breaker trips and improve battery longevity. Additionally, in scenarios where the robot experiences brownouts despite configuring stator current limits, a supply current limit can further help avoid brownouts. However, it is important to note that such brownouts may be caused by a bad battery or poor power wiring. A reasonable starting point for a supply current limit is 70 A with a lower limit of 40 A after 1.0 second. Supply current limits commonly range from 20-80 A depending on the breaker used. - Minimum Value: 0.0 - Maximum Value: 800.0 - Default Value: 70 - Units: A :param new_supply_current_limit: Parameter to modify :type new_supply_current_limit: ampere :returns: Itself :rtype: CurrentLimitsConfigs .. py:method:: with_supply_current_limit_enable(new_supply_current_limit_enable: bool) -> CurrentLimitsConfigs Modifies this configuration's supply_current_limit_enable parameter and returns itself for method-chaining and easier to use config API. Enable motor supply current limiting. - Default Value: True :param new_supply_current_limit_enable: Parameter to modify :type new_supply_current_limit_enable: bool :returns: Itself :rtype: CurrentLimitsConfigs .. py:method:: with_supply_current_lower_limit(new_supply_current_lower_limit: phoenix6.units.ampere) -> CurrentLimitsConfigs Modifies this configuration's supply_current_lower_limit parameter and returns itself for method-chaining and easier to use config API. The amount of supply current allowed after the regular SupplyCurrentLimit is active for longer than SupplyCurrentLowerTime. This allows higher current draws for a fixed period of time before reducing the current limit to protect breakers. This has no effect if SupplyCurrentLimit is lower than this value or SupplyCurrentLowerTime is 0. - Minimum Value: 0.0 - Maximum Value: 500 - Default Value: 40 - Units: A :param new_supply_current_lower_limit: Parameter to modify :type new_supply_current_lower_limit: ampere :returns: Itself :rtype: CurrentLimitsConfigs .. py:method:: with_supply_current_lower_time(new_supply_current_lower_time: phoenix6.units.second) -> CurrentLimitsConfigs Modifies this configuration's supply_current_lower_time parameter and returns itself for method-chaining and easier to use config API. Reduces supply current to the SupplyCurrentLowerLimit after limiting to SupplyCurrentLimit for this period of time. If this is set to 0, SupplyCurrentLowerLimit will be ignored. - Minimum Value: 0.0 - Maximum Value: 5.0 - Default Value: 1.0 - Units: seconds :param new_supply_current_lower_time: Parameter to modify :type new_supply_current_lower_time: second :returns: Itself :rtype: CurrentLimitsConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: VoltageConfigs Configs that affect Voltage control types. Includes peak output voltages and other configs affecting voltage measurements. .. py:attribute:: supply_voltage_time_constant :type: phoenix6.units.second :value: '0' The time constant (in seconds) of the low-pass filter for the supply voltage. This impacts the filtering for the reported supply voltage, and any control strategies that use the supply voltage (such as voltage control on a motor controller). - Minimum Value: 0.0 - Maximum Value: 0.1 - Default Value: 0 - Units: seconds .. py:attribute:: peak_forward_voltage :type: phoenix6.units.volt :value: '16' Maximum (forward) output during voltage based control modes. - Minimum Value: -32 - Maximum Value: 32 - Default Value: 16 - Units: V .. py:attribute:: peak_reverse_voltage :type: phoenix6.units.volt :value: '-16' Minimum (reverse) output during voltage based control modes. - Minimum Value: -32 - Maximum Value: 32 - Default Value: -16 - Units: V .. py:method:: with_supply_voltage_time_constant(new_supply_voltage_time_constant: phoenix6.units.second) -> VoltageConfigs Modifies this configuration's supply_voltage_time_constant parameter and returns itself for method-chaining and easier to use config API. The time constant (in seconds) of the low-pass filter for the supply voltage. This impacts the filtering for the reported supply voltage, and any control strategies that use the supply voltage (such as voltage control on a motor controller). - Minimum Value: 0.0 - Maximum Value: 0.1 - Default Value: 0 - Units: seconds :param new_supply_voltage_time_constant: Parameter to modify :type new_supply_voltage_time_constant: second :returns: Itself :rtype: VoltageConfigs .. py:method:: with_peak_forward_voltage(new_peak_forward_voltage: phoenix6.units.volt) -> VoltageConfigs Modifies this configuration's peak_forward_voltage parameter and returns itself for method-chaining and easier to use config API. Maximum (forward) output during voltage based control modes. - Minimum Value: -32 - Maximum Value: 32 - Default Value: 16 - Units: V :param new_peak_forward_voltage: Parameter to modify :type new_peak_forward_voltage: volt :returns: Itself :rtype: VoltageConfigs .. py:method:: with_peak_reverse_voltage(new_peak_reverse_voltage: phoenix6.units.volt) -> VoltageConfigs Modifies this configuration's peak_reverse_voltage parameter and returns itself for method-chaining and easier to use config API. Minimum (reverse) output during voltage based control modes. - Minimum Value: -32 - Maximum Value: 32 - Default Value: -16 - Units: V :param new_peak_reverse_voltage: Parameter to modify :type new_peak_reverse_voltage: volt :returns: Itself :rtype: VoltageConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: TorqueCurrentConfigs Configs that affect Torque Current control types. Includes the maximum and minimum applied torque output and the neutral deadband used during TorqueCurrentFOC requests. .. py:attribute:: peak_forward_torque_current :type: phoenix6.units.ampere :value: '800' Maximum (forward) output during torque current based control modes. - Minimum Value: -800 - Maximum Value: 800 - Default Value: 800 - Units: A .. py:attribute:: peak_reverse_torque_current :type: phoenix6.units.ampere :value: '-800' Minimum (reverse) output during torque current based control modes. - Minimum Value: -800 - Maximum Value: 800 - Default Value: -800 - Units: A .. py:attribute:: torque_neutral_deadband :type: phoenix6.units.ampere :value: '0.0' Configures the output deadband during torque current based control modes. - Minimum Value: 0 - Maximum Value: 25 - Default Value: 0.0 - Units: A .. py:method:: with_peak_forward_torque_current(new_peak_forward_torque_current: phoenix6.units.ampere) -> TorqueCurrentConfigs Modifies this configuration's peak_forward_torque_current parameter and returns itself for method-chaining and easier to use config API. Maximum (forward) output during torque current based control modes. - Minimum Value: -800 - Maximum Value: 800 - Default Value: 800 - Units: A :param new_peak_forward_torque_current: Parameter to modify :type new_peak_forward_torque_current: ampere :returns: Itself :rtype: TorqueCurrentConfigs .. py:method:: with_peak_reverse_torque_current(new_peak_reverse_torque_current: phoenix6.units.ampere) -> TorqueCurrentConfigs Modifies this configuration's peak_reverse_torque_current parameter and returns itself for method-chaining and easier to use config API. Minimum (reverse) output during torque current based control modes. - Minimum Value: -800 - Maximum Value: 800 - Default Value: -800 - Units: A :param new_peak_reverse_torque_current: Parameter to modify :type new_peak_reverse_torque_current: ampere :returns: Itself :rtype: TorqueCurrentConfigs .. py:method:: with_torque_neutral_deadband(new_torque_neutral_deadband: phoenix6.units.ampere) -> TorqueCurrentConfigs Modifies this configuration's torque_neutral_deadband parameter and returns itself for method-chaining and easier to use config API. Configures the output deadband during torque current based control modes. - Minimum Value: 0 - Maximum Value: 25 - Default Value: 0.0 - Units: A :param new_torque_neutral_deadband: Parameter to modify :type new_torque_neutral_deadband: ampere :returns: Itself :rtype: TorqueCurrentConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: FeedbackConfigs Configs that affect the feedback of this motor controller. Includes feedback sensor source, any offsets for the feedback sensor, and various ratios to describe the relationship between the sensor and the mechanism for closed looping. .. py:attribute:: feedback_rotor_offset :type: phoenix6.units.rotation :value: '0.0' The offset added to the absolute integrated rotor sensor. This can be used to zero the rotor in applications that are within one rotor rotation. - Minimum Value: -1 - Maximum Value: 1 - Default Value: 0.0 - Units: rotations .. py:attribute:: sensor_to_mechanism_ratio :type: float :value: '1.0' The ratio of sensor rotations to the mechanism's output, where a ratio greater than 1 is a reduction. This is equivalent to the mechanism's gear ratio if the sensor is located on the input of a gearbox. If sensor is on the output of a gearbox, then this is typically set to 1. We recommend against using this config to perform onboard unit conversions. Instead, unit conversions should be performed in robot code using the units library. If this is set to zero, the device will reset back to one. - Minimum Value: -1000 - Maximum Value: 1000 - Default Value: 1.0 - Units: scalar .. py:attribute:: rotor_to_sensor_ratio :type: float :value: '1.0' The ratio of motor rotor rotations to remote sensor rotations, where a ratio greater than 1 is a reduction. The Talon FX is capable of fusing a remote CANcoder with its rotor sensor to produce a high-bandwidth sensor source. This feature requires specifying the ratio between the motor rotor and the remote sensor. If this is set to zero, the device will reset back to one. - Minimum Value: -1000 - Maximum Value: 1000 - Default Value: 1.0 - Units: scalar .. py:attribute:: feedback_sensor_source :type: FeedbackSensorSourceValue Choose what sensor source is reported via API and used by closed-loop and limit features. The default is RotorSensor, which uses the internal rotor sensor in the Talon. Choose Remote* to use another sensor on the same CAN bus (this also requires setting FeedbackRemoteSensorID). Talon will update its position and velocity whenever the remote sensor publishes its information on CAN bus, and the Talon internal rotor will not be used. Choose Fused* (requires Phoenix Pro) and Talon will fuse another sensor's information with the internal rotor, which provides the best possible position and velocity for accuracy and bandwidth (this also requires setting FeedbackRemoteSensorID). This was developed for applications such as swerve-azimuth. Choose Sync* (requires Phoenix Pro) and Talon will synchronize its internal rotor position against another sensor, then continue to use the rotor sensor for closed loop control (this also requires setting FeedbackRemoteSensorID). The Talon will report if its internal position differs significantly from the reported remote sensor position. This was developed for mechanisms where there is a risk of the sensor failing in such a way that it reports a position that does not match the mechanism, such as the sensor mounting assembly breaking off. Choose RemotePigeon2Yaw, RemotePigeon2Pitch, and RemotePigeon2Roll to use another Pigeon2 on the same CAN bus (this also requires setting FeedbackRemoteSensorID). Talon will update its position to match the selected value whenever Pigeon2 publishes its information on CAN bus. Note that the Talon position will be in rotations and not degrees. Note: When the feedback source is changed to Fused* or Sync*, the Talon needs a period of time to fuse before sensor-based (soft-limit, closed loop, etc.) features are used. This period of time is determined by the update frequency of the remote sensor's Position signal. .. py:attribute:: feedback_remote_sensor_id :type: int :value: '0' Device ID of which remote device to use. This is not used if the Sensor Source is the internal rotor sensor. - Minimum Value: 0 - Maximum Value: 62 - Default Value: 0 - Units: .. py:attribute:: velocity_filter_time_constant :type: phoenix6.units.second :value: '0' The configurable time constant of the Kalman velocity filter. The velocity Kalman filter will adjust to act as a low-pass with this value as its time constant. If the user is aiming for an expected cutoff frequency, the frequency is calculated as 1 / (2 * π * τ) with τ being the time constant. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0 - Units: seconds .. py:method:: with_feedback_rotor_offset(new_feedback_rotor_offset: phoenix6.units.rotation) -> FeedbackConfigs Modifies this configuration's feedback_rotor_offset parameter and returns itself for method-chaining and easier to use config API. The offset added to the absolute integrated rotor sensor. This can be used to zero the rotor in applications that are within one rotor rotation. - Minimum Value: -1 - Maximum Value: 1 - Default Value: 0.0 - Units: rotations :param new_feedback_rotor_offset: Parameter to modify :type new_feedback_rotor_offset: rotation :returns: Itself :rtype: FeedbackConfigs .. py:method:: with_sensor_to_mechanism_ratio(new_sensor_to_mechanism_ratio: float) -> FeedbackConfigs Modifies this configuration's sensor_to_mechanism_ratio parameter and returns itself for method-chaining and easier to use config API. The ratio of sensor rotations to the mechanism's output, where a ratio greater than 1 is a reduction. This is equivalent to the mechanism's gear ratio if the sensor is located on the input of a gearbox. If sensor is on the output of a gearbox, then this is typically set to 1. We recommend against using this config to perform onboard unit conversions. Instead, unit conversions should be performed in robot code using the units library. If this is set to zero, the device will reset back to one. - Minimum Value: -1000 - Maximum Value: 1000 - Default Value: 1.0 - Units: scalar :param new_sensor_to_mechanism_ratio: Parameter to modify :type new_sensor_to_mechanism_ratio: float :returns: Itself :rtype: FeedbackConfigs .. py:method:: with_rotor_to_sensor_ratio(new_rotor_to_sensor_ratio: float) -> FeedbackConfigs Modifies this configuration's rotor_to_sensor_ratio parameter and returns itself for method-chaining and easier to use config API. The ratio of motor rotor rotations to remote sensor rotations, where a ratio greater than 1 is a reduction. The Talon FX is capable of fusing a remote CANcoder with its rotor sensor to produce a high-bandwidth sensor source. This feature requires specifying the ratio between the motor rotor and the remote sensor. If this is set to zero, the device will reset back to one. - Minimum Value: -1000 - Maximum Value: 1000 - Default Value: 1.0 - Units: scalar :param new_rotor_to_sensor_ratio: Parameter to modify :type new_rotor_to_sensor_ratio: float :returns: Itself :rtype: FeedbackConfigs .. py:method:: with_feedback_sensor_source(new_feedback_sensor_source: FeedbackSensorSourceValue) -> FeedbackConfigs Modifies this configuration's feedback_sensor_source parameter and returns itself for method-chaining and easier to use config API. Choose what sensor source is reported via API and used by closed-loop and limit features. The default is RotorSensor, which uses the internal rotor sensor in the Talon. Choose Remote* to use another sensor on the same CAN bus (this also requires setting FeedbackRemoteSensorID). Talon will update its position and velocity whenever the remote sensor publishes its information on CAN bus, and the Talon internal rotor will not be used. Choose Fused* (requires Phoenix Pro) and Talon will fuse another sensor's information with the internal rotor, which provides the best possible position and velocity for accuracy and bandwidth (this also requires setting FeedbackRemoteSensorID). This was developed for applications such as swerve-azimuth. Choose Sync* (requires Phoenix Pro) and Talon will synchronize its internal rotor position against another sensor, then continue to use the rotor sensor for closed loop control (this also requires setting FeedbackRemoteSensorID). The Talon will report if its internal position differs significantly from the reported remote sensor position. This was developed for mechanisms where there is a risk of the sensor failing in such a way that it reports a position that does not match the mechanism, such as the sensor mounting assembly breaking off. Choose RemotePigeon2Yaw, RemotePigeon2Pitch, and RemotePigeon2Roll to use another Pigeon2 on the same CAN bus (this also requires setting FeedbackRemoteSensorID). Talon will update its position to match the selected value whenever Pigeon2 publishes its information on CAN bus. Note that the Talon position will be in rotations and not degrees. Note: When the feedback source is changed to Fused* or Sync*, the Talon needs a period of time to fuse before sensor-based (soft-limit, closed loop, etc.) features are used. This period of time is determined by the update frequency of the remote sensor's Position signal. :param new_feedback_sensor_source: Parameter to modify :type new_feedback_sensor_source: FeedbackSensorSourceValue :returns: Itself :rtype: FeedbackConfigs .. py:method:: with_feedback_remote_sensor_id(new_feedback_remote_sensor_id: int) -> FeedbackConfigs Modifies this configuration's feedback_remote_sensor_id parameter and returns itself for method-chaining and easier to use config API. Device ID of which remote device to use. This is not used if the Sensor Source is the internal rotor sensor. - Minimum Value: 0 - Maximum Value: 62 - Default Value: 0 - Units: :param new_feedback_remote_sensor_id: Parameter to modify :type new_feedback_remote_sensor_id: int :returns: Itself :rtype: FeedbackConfigs .. py:method:: with_velocity_filter_time_constant(new_velocity_filter_time_constant: phoenix6.units.second) -> FeedbackConfigs Modifies this configuration's velocity_filter_time_constant parameter and returns itself for method-chaining and easier to use config API. The configurable time constant of the Kalman velocity filter. The velocity Kalman filter will adjust to act as a low-pass with this value as its time constant. If the user is aiming for an expected cutoff frequency, the frequency is calculated as 1 / (2 * π * τ) with τ being the time constant. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0 - Units: seconds :param new_velocity_filter_time_constant: Parameter to modify :type new_velocity_filter_time_constant: second :returns: Itself :rtype: FeedbackConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: ExternalFeedbackConfigs Configs that affect the external feedback sensor of this motor controller. Includes feedback sensor source, offsets and sensor phase for the feedback sensor, and various ratios to describe the relationship between the sensor and the mechanism for closed looping. .. py:attribute:: sensor_to_mechanism_ratio :type: float :value: '1.0' The ratio of sensor rotations to the mechanism's output, where a ratio greater than 1 is a reduction. This is equivalent to the mechanism's gear ratio if the sensor is located on the input of a gearbox. If sensor is on the output of a gearbox, then this is typically set to 1. We recommend against using this config to perform onboard unit conversions. Instead, unit conversions should be performed in robot code using the units library. If this is set to zero, the device will reset back to one. - Minimum Value: -1000 - Maximum Value: 1000 - Default Value: 1.0 - Units: scalar .. py:attribute:: rotor_to_sensor_ratio :type: float :value: '1.0' The ratio of motor rotor rotations to remote sensor rotations, where a ratio greater than 1 is a reduction. The Talon FX is capable of fusing a remote CANcoder with its rotor sensor to produce a high-bandwidth sensor source. This feature requires specifying the ratio between the motor rotor and the remote sensor. If this is set to zero, the device will reset back to one. - Minimum Value: -1000 - Maximum Value: 1000 - Default Value: 1.0 - Units: scalar .. py:attribute:: feedback_remote_sensor_id :type: int :value: '0' Device ID of which remote device to use. This is not used if the Sensor Source is the internal rotor sensor. - Minimum Value: 0 - Maximum Value: 62 - Default Value: 0 - Units: .. py:attribute:: velocity_filter_time_constant :type: phoenix6.units.second :value: '0' The configurable time constant of the Kalman velocity filter. The velocity Kalman filter will adjust to act as a low-pass with this value as its time constant. If the user is aiming for an expected cutoff frequency, the frequency is calculated as 1 / (2 * π * τ) with τ being the time constant. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0 - Units: seconds .. py:attribute:: absolute_sensor_offset :type: phoenix6.units.rotation :value: '0.0' The offset added to any absolute sensor connected to the Talon data port. This is only supported when using the PulseWidth sensor source. This can be used to zero the sensor position in applications where the sensor is 1:1 with the mechanism. - Minimum Value: -1 - Maximum Value: 1 - Default Value: 0.0 - Units: rotations .. py:attribute:: external_feedback_sensor_source :type: ExternalFeedbackSensorSourceValue Choose what sensor source is reported via API and used by closed-loop and limit features. The default is Commutation, which uses the external sensor used for motor commutation. Choose Remote* to use another sensor on the same CAN bus (this also requires setting FeedbackRemoteSensorID). Talon will update its position and velocity whenever the remote sensor publishes its information on CAN bus, and the Talon commutation sensor will not be used. Choose Fused* (requires Phoenix Pro) and Talon will fuse another sensor's information with the commutation sensor, which provides the best possible position and velocity for accuracy and bandwidth (this also requires setting FeedbackRemoteSensorID). This was developed for applications such as swerve-azimuth. Choose Sync* (requires Phoenix Pro) and Talon will synchronize its commutation sensor position against another sensor, then continue to use the rotor sensor for closed loop control (this also requires setting FeedbackRemoteSensorID). The Talon will report if its internal position differs significantly from the reported remote sensor position. This was developed for mechanisms where there is a risk of the sensor failing in such a way that it reports a position that does not match the mechanism, such as the sensor mounting assembly breaking off. Choose RemotePigeon2Yaw, RemotePigeon2Pitch, and RemotePigeon2Roll to use another Pigeon2 on the same CAN bus (this also requires setting FeedbackRemoteSensorID). Talon will update its position to match the selected value whenever Pigeon2 publishes its information on CAN bus. Note that the Talon position will be in rotations and not degrees. Choose Quadrature to use a quadrature encoder directly attached to the Talon data port. This provides velocity and relative position measurements. Choose PulseWidth to use a pulse-width encoder directly attached to the Talon data port. This provides velocity and absolute position measurements. Note: When the feedback source is changed to Fused* or Sync*, the Talon needs a period of time to fuse before sensor-based (soft-limit, closed loop, etc.) features are used. This period of time is determined by the update frequency of the remote sensor's Position signal. .. py:attribute:: sensor_phase :type: SensorPhaseValue The relationship between the motor controlled by a Talon and the external sensor connected to the data port. This does not affect the commutation sensor or remote sensors. To determine the sensor phase, set this config to Aligned and drive the motor with positive output. If the reported sensor velocity is positive, then the phase is Aligned. If the reported sensor velocity is negative, then the phase is Opposed. The sensor direction is automatically inverted along with motor invert, so the sensor phase does not need to be changed when motor invert changes. .. py:attribute:: quadrature_edges_per_rotation :type: int :value: '4096' The number of quadrature edges in one rotation for the quadrature sensor connected to the Talon data port. This is the total number of transitions from high-to-low or low-to-high across both channels per rotation of the sensor. This is also equivalent to the Counts Per Revolution when using 4x decoding. For example, the SRX Mag Encoder has 4096 edges per rotation, and a US Digital 1024 CPR (Cycles Per Revolution) quadrature encoder has 4096 edges per rotation. On the Talon FXS, this can be at most 2,000,000,000 / Peak RPM. - Minimum Value: 1 - Maximum Value: 1000000 - Default Value: 4096 - Units: .. py:attribute:: absolute_sensor_discontinuity_point :type: phoenix6.units.rotation :value: '0.5' The positive discontinuity point of the absolute sensor in rotations. This determines the point at which the absolute sensor wraps around, keeping the absolute position (after offset) in the range [x-1, x). - Setting this to 1 makes the absolute position unsigned [0, 1) - Setting this to 0.5 makes the absolute position signed [-0.5, 0.5) - Setting this to 0 makes the absolute position always negative [-1, 0) Many rotational mechanisms such as arms have a region of motion that is unreachable. This should be set to the center of that region of motion, in non-negative rotations. This affects the position of the device at bootup. For example, consider an arm which can travel from -0.2 to 0.6 rotations with a little leeway, where 0 is horizontally forward. Since -0.2 rotations has the same absolute position as 0.8 rotations, we can say that the arm typically does not travel in the range (0.6, 0.8) rotations. As a result, the discontinuity point would be the center of that range, which is 0.7 rotations. This results in an absolute sensor range of [-0.3, 0.7) rotations. Given a total range of motion less than 1 rotation, users can calculate the discontinuity point using mean(lowerLimit, upperLimit) + 0.5. If that results in a value outside the range [0, 1], either cap the value to [0, 1], or add/subtract 1.0 rotation from your lower and upper limits of motion. On a Talon motor controller, this is only supported when using the PulseWidth sensor source. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 0.5 - Units: rotations .. py:method:: with_sensor_to_mechanism_ratio(new_sensor_to_mechanism_ratio: float) -> ExternalFeedbackConfigs Modifies this configuration's sensor_to_mechanism_ratio parameter and returns itself for method-chaining and easier to use config API. The ratio of sensor rotations to the mechanism's output, where a ratio greater than 1 is a reduction. This is equivalent to the mechanism's gear ratio if the sensor is located on the input of a gearbox. If sensor is on the output of a gearbox, then this is typically set to 1. We recommend against using this config to perform onboard unit conversions. Instead, unit conversions should be performed in robot code using the units library. If this is set to zero, the device will reset back to one. - Minimum Value: -1000 - Maximum Value: 1000 - Default Value: 1.0 - Units: scalar :param new_sensor_to_mechanism_ratio: Parameter to modify :type new_sensor_to_mechanism_ratio: float :returns: Itself :rtype: ExternalFeedbackConfigs .. py:method:: with_rotor_to_sensor_ratio(new_rotor_to_sensor_ratio: float) -> ExternalFeedbackConfigs Modifies this configuration's rotor_to_sensor_ratio parameter and returns itself for method-chaining and easier to use config API. The ratio of motor rotor rotations to remote sensor rotations, where a ratio greater than 1 is a reduction. The Talon FX is capable of fusing a remote CANcoder with its rotor sensor to produce a high-bandwidth sensor source. This feature requires specifying the ratio between the motor rotor and the remote sensor. If this is set to zero, the device will reset back to one. - Minimum Value: -1000 - Maximum Value: 1000 - Default Value: 1.0 - Units: scalar :param new_rotor_to_sensor_ratio: Parameter to modify :type new_rotor_to_sensor_ratio: float :returns: Itself :rtype: ExternalFeedbackConfigs .. py:method:: with_feedback_remote_sensor_id(new_feedback_remote_sensor_id: int) -> ExternalFeedbackConfigs Modifies this configuration's feedback_remote_sensor_id parameter and returns itself for method-chaining and easier to use config API. Device ID of which remote device to use. This is not used if the Sensor Source is the internal rotor sensor. - Minimum Value: 0 - Maximum Value: 62 - Default Value: 0 - Units: :param new_feedback_remote_sensor_id: Parameter to modify :type new_feedback_remote_sensor_id: int :returns: Itself :rtype: ExternalFeedbackConfigs .. py:method:: with_velocity_filter_time_constant(new_velocity_filter_time_constant: phoenix6.units.second) -> ExternalFeedbackConfigs Modifies this configuration's velocity_filter_time_constant parameter and returns itself for method-chaining and easier to use config API. The configurable time constant of the Kalman velocity filter. The velocity Kalman filter will adjust to act as a low-pass with this value as its time constant. If the user is aiming for an expected cutoff frequency, the frequency is calculated as 1 / (2 * π * τ) with τ being the time constant. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0 - Units: seconds :param new_velocity_filter_time_constant: Parameter to modify :type new_velocity_filter_time_constant: second :returns: Itself :rtype: ExternalFeedbackConfigs .. py:method:: with_absolute_sensor_offset(new_absolute_sensor_offset: phoenix6.units.rotation) -> ExternalFeedbackConfigs Modifies this configuration's absolute_sensor_offset parameter and returns itself for method-chaining and easier to use config API. The offset added to any absolute sensor connected to the Talon data port. This is only supported when using the PulseWidth sensor source. This can be used to zero the sensor position in applications where the sensor is 1:1 with the mechanism. - Minimum Value: -1 - Maximum Value: 1 - Default Value: 0.0 - Units: rotations :param new_absolute_sensor_offset: Parameter to modify :type new_absolute_sensor_offset: rotation :returns: Itself :rtype: ExternalFeedbackConfigs .. py:method:: with_external_feedback_sensor_source(new_external_feedback_sensor_source: ExternalFeedbackSensorSourceValue) -> ExternalFeedbackConfigs Modifies this configuration's external_feedback_sensor_source parameter and returns itself for method-chaining and easier to use config API. Choose what sensor source is reported via API and used by closed-loop and limit features. The default is Commutation, which uses the external sensor used for motor commutation. Choose Remote* to use another sensor on the same CAN bus (this also requires setting FeedbackRemoteSensorID). Talon will update its position and velocity whenever the remote sensor publishes its information on CAN bus, and the Talon commutation sensor will not be used. Choose Fused* (requires Phoenix Pro) and Talon will fuse another sensor's information with the commutation sensor, which provides the best possible position and velocity for accuracy and bandwidth (this also requires setting FeedbackRemoteSensorID). This was developed for applications such as swerve-azimuth. Choose Sync* (requires Phoenix Pro) and Talon will synchronize its commutation sensor position against another sensor, then continue to use the rotor sensor for closed loop control (this also requires setting FeedbackRemoteSensorID). The Talon will report if its internal position differs significantly from the reported remote sensor position. This was developed for mechanisms where there is a risk of the sensor failing in such a way that it reports a position that does not match the mechanism, such as the sensor mounting assembly breaking off. Choose RemotePigeon2Yaw, RemotePigeon2Pitch, and RemotePigeon2Roll to use another Pigeon2 on the same CAN bus (this also requires setting FeedbackRemoteSensorID). Talon will update its position to match the selected value whenever Pigeon2 publishes its information on CAN bus. Note that the Talon position will be in rotations and not degrees. Choose Quadrature to use a quadrature encoder directly attached to the Talon data port. This provides velocity and relative position measurements. Choose PulseWidth to use a pulse-width encoder directly attached to the Talon data port. This provides velocity and absolute position measurements. Note: When the feedback source is changed to Fused* or Sync*, the Talon needs a period of time to fuse before sensor-based (soft-limit, closed loop, etc.) features are used. This period of time is determined by the update frequency of the remote sensor's Position signal. :param new_external_feedback_sensor_source: Parameter to modify :type new_external_feedback_sensor_source: ExternalFeedbackSensorSourceValue :returns: Itself :rtype: ExternalFeedbackConfigs .. py:method:: with_sensor_phase(new_sensor_phase: SensorPhaseValue) -> ExternalFeedbackConfigs Modifies this configuration's sensor_phase parameter and returns itself for method-chaining and easier to use config API. The relationship between the motor controlled by a Talon and the external sensor connected to the data port. This does not affect the commutation sensor or remote sensors. To determine the sensor phase, set this config to Aligned and drive the motor with positive output. If the reported sensor velocity is positive, then the phase is Aligned. If the reported sensor velocity is negative, then the phase is Opposed. The sensor direction is automatically inverted along with motor invert, so the sensor phase does not need to be changed when motor invert changes. :param new_sensor_phase: Parameter to modify :type new_sensor_phase: SensorPhaseValue :returns: Itself :rtype: ExternalFeedbackConfigs .. py:method:: with_quadrature_edges_per_rotation(new_quadrature_edges_per_rotation: int) -> ExternalFeedbackConfigs Modifies this configuration's quadrature_edges_per_rotation parameter and returns itself for method-chaining and easier to use config API. The number of quadrature edges in one rotation for the quadrature sensor connected to the Talon data port. This is the total number of transitions from high-to-low or low-to-high across both channels per rotation of the sensor. This is also equivalent to the Counts Per Revolution when using 4x decoding. For example, the SRX Mag Encoder has 4096 edges per rotation, and a US Digital 1024 CPR (Cycles Per Revolution) quadrature encoder has 4096 edges per rotation. On the Talon FXS, this can be at most 2,000,000,000 / Peak RPM. - Minimum Value: 1 - Maximum Value: 1000000 - Default Value: 4096 - Units: :param new_quadrature_edges_per_rotation: Parameter to modify :type new_quadrature_edges_per_rotation: int :returns: Itself :rtype: ExternalFeedbackConfigs .. py:method:: with_absolute_sensor_discontinuity_point(new_absolute_sensor_discontinuity_point: phoenix6.units.rotation) -> ExternalFeedbackConfigs Modifies this configuration's absolute_sensor_discontinuity_point parameter and returns itself for method-chaining and easier to use config API. The positive discontinuity point of the absolute sensor in rotations. This determines the point at which the absolute sensor wraps around, keeping the absolute position (after offset) in the range [x-1, x). - Setting this to 1 makes the absolute position unsigned [0, 1) - Setting this to 0.5 makes the absolute position signed [-0.5, 0.5) - Setting this to 0 makes the absolute position always negative [-1, 0) Many rotational mechanisms such as arms have a region of motion that is unreachable. This should be set to the center of that region of motion, in non-negative rotations. This affects the position of the device at bootup. For example, consider an arm which can travel from -0.2 to 0.6 rotations with a little leeway, where 0 is horizontally forward. Since -0.2 rotations has the same absolute position as 0.8 rotations, we can say that the arm typically does not travel in the range (0.6, 0.8) rotations. As a result, the discontinuity point would be the center of that range, which is 0.7 rotations. This results in an absolute sensor range of [-0.3, 0.7) rotations. Given a total range of motion less than 1 rotation, users can calculate the discontinuity point using mean(lowerLimit, upperLimit) + 0.5. If that results in a value outside the range [0, 1], either cap the value to [0, 1], or add/subtract 1.0 rotation from your lower and upper limits of motion. On a Talon motor controller, this is only supported when using the PulseWidth sensor source. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 0.5 - Units: rotations :param new_absolute_sensor_discontinuity_point: Parameter to modify :type new_absolute_sensor_discontinuity_point: rotation :returns: Itself :rtype: ExternalFeedbackConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: DifferentialSensorsConfigs Configs related to sensors used for differential control of a mechanism. Includes the differential sensor sources and IDs. .. py:attribute:: differential_sensor_source :type: DifferentialSensorSourceValue Choose what sensor source is used for differential control of a mechanism. The default is Disabled. All other options require setting the DifferentialTalonFXSensorID, as the average of this Talon FX's sensor and the remote TalonFX's sensor is used for the differential controller's primary targets. Choose RemoteTalonFX_HalfDiff to use another TalonFX on the same CAN bus. Talon FX will update its differential position and velocity whenever the remote TalonFX publishes its information on CAN bus. The differential controller will use half of the difference between this TalonFX's sensor and the remote Talon FX's sensor for the differential component of the output. Choose RemotePigeon2Yaw, RemotePigeon2Pitch, and RemotePigeon2Roll to use another Pigeon2 on the same CAN bus (this also requires setting DifferentialRemoteSensorID). Talon FX will update its differential position to match the selected value whenever Pigeon2 publishes its information on CAN bus. Note that the Talon FX differential position will be in rotations and not degrees. Choose RemoteCANcoder to use another CANcoder on the same CAN bus (this also requires setting DifferentialRemoteSensorID). Talon FX will update its differential position and velocity to match the CANcoder whenever CANcoder publishes its information on CAN bus. .. py:attribute:: differential_talon_fx_sensor_id :type: int :value: '0' Device ID of which remote Talon FX to use. This is used whenever the Differential Sensor Source is not disabled. The differential Talon FX must enable its Position and Velocity status signals. The update rate of the status signals determines the update rate of differential control. - Minimum Value: 0 - Maximum Value: 62 - Default Value: 0 - Units: .. py:attribute:: differential_remote_sensor_id :type: int :value: '0' Device ID of which remote sensor to use on the differential axis. This is used when the Differential Sensor Source is not Disabled or RemoteTalonFX_HalfDiff. - Minimum Value: 0 - Maximum Value: 62 - Default Value: 0 - Units: .. py:attribute:: sensor_to_differential_ratio :type: float :value: '1.0' The ratio of sensor rotations to the differential mechanism's difference output, where a ratio greater than 1 is a reduction. When using RemoteTalonFX_HalfDiff, the sensor is considered half of the difference between the two devices' mechanism positions/velocities. As a result, this should be set to the gear ratio on the difference axis when using RemoteTalonFX_HalfDiff, or any gear ratio between the sensor and the mechanism differential when using another sensor source. We recommend against using this config to perform onboard unit conversions. Instead, unit conversions should be performed in robot code using the units library. If this is set to zero, the device will reset back to one. - Minimum Value: -1000 - Maximum Value: 1000 - Default Value: 1.0 - Units: scalar .. py:method:: with_differential_sensor_source(new_differential_sensor_source: DifferentialSensorSourceValue) -> DifferentialSensorsConfigs Modifies this configuration's differential_sensor_source parameter and returns itself for method-chaining and easier to use config API. Choose what sensor source is used for differential control of a mechanism. The default is Disabled. All other options require setting the DifferentialTalonFXSensorID, as the average of this Talon FX's sensor and the remote TalonFX's sensor is used for the differential controller's primary targets. Choose RemoteTalonFX_HalfDiff to use another TalonFX on the same CAN bus. Talon FX will update its differential position and velocity whenever the remote TalonFX publishes its information on CAN bus. The differential controller will use half of the difference between this TalonFX's sensor and the remote Talon FX's sensor for the differential component of the output. Choose RemotePigeon2Yaw, RemotePigeon2Pitch, and RemotePigeon2Roll to use another Pigeon2 on the same CAN bus (this also requires setting DifferentialRemoteSensorID). Talon FX will update its differential position to match the selected value whenever Pigeon2 publishes its information on CAN bus. Note that the Talon FX differential position will be in rotations and not degrees. Choose RemoteCANcoder to use another CANcoder on the same CAN bus (this also requires setting DifferentialRemoteSensorID). Talon FX will update its differential position and velocity to match the CANcoder whenever CANcoder publishes its information on CAN bus. :param new_differential_sensor_source: Parameter to modify :type new_differential_sensor_source: DifferentialSensorSourceValue :returns: Itself :rtype: DifferentialSensorsConfigs .. py:method:: with_differential_talon_fx_sensor_id(new_differential_talon_fx_sensor_id: int) -> DifferentialSensorsConfigs Modifies this configuration's differential_talon_fx_sensor_id parameter and returns itself for method-chaining and easier to use config API. Device ID of which remote Talon FX to use. This is used whenever the Differential Sensor Source is not disabled. The differential Talon FX must enable its Position and Velocity status signals. The update rate of the status signals determines the update rate of differential control. - Minimum Value: 0 - Maximum Value: 62 - Default Value: 0 - Units: :param new_differential_talon_fx_sensor_id: Parameter to modify :type new_differential_talon_fx_sensor_id: int :returns: Itself :rtype: DifferentialSensorsConfigs .. py:method:: with_differential_remote_sensor_id(new_differential_remote_sensor_id: int) -> DifferentialSensorsConfigs Modifies this configuration's differential_remote_sensor_id parameter and returns itself for method-chaining and easier to use config API. Device ID of which remote sensor to use on the differential axis. This is used when the Differential Sensor Source is not Disabled or RemoteTalonFX_HalfDiff. - Minimum Value: 0 - Maximum Value: 62 - Default Value: 0 - Units: :param new_differential_remote_sensor_id: Parameter to modify :type new_differential_remote_sensor_id: int :returns: Itself :rtype: DifferentialSensorsConfigs .. py:method:: with_sensor_to_differential_ratio(new_sensor_to_differential_ratio: float) -> DifferentialSensorsConfigs Modifies this configuration's sensor_to_differential_ratio parameter and returns itself for method-chaining and easier to use config API. The ratio of sensor rotations to the differential mechanism's difference output, where a ratio greater than 1 is a reduction. When using RemoteTalonFX_HalfDiff, the sensor is considered half of the difference between the two devices' mechanism positions/velocities. As a result, this should be set to the gear ratio on the difference axis when using RemoteTalonFX_HalfDiff, or any gear ratio between the sensor and the mechanism differential when using another sensor source. We recommend against using this config to perform onboard unit conversions. Instead, unit conversions should be performed in robot code using the units library. If this is set to zero, the device will reset back to one. - Minimum Value: -1000 - Maximum Value: 1000 - Default Value: 1.0 - Units: scalar :param new_sensor_to_differential_ratio: Parameter to modify :type new_sensor_to_differential_ratio: float :returns: Itself :rtype: DifferentialSensorsConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: DifferentialConstantsConfigs Configs related to constants used for differential control of a mechanism. Includes the differential peak outputs. .. py:attribute:: peak_differential_duty_cycle :type: float :value: '1.0' Maximum differential output during duty cycle based differential control modes. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 1.0 - Units: fractional .. py:attribute:: peak_differential_voltage :type: phoenix6.units.volt :value: '16' Maximum differential output during voltage based differential control modes. - Minimum Value: 0.0 - Maximum Value: 32 - Default Value: 16 - Units: V .. py:attribute:: peak_differential_torque_current :type: phoenix6.units.ampere :value: '800' Maximum differential output during torque current based differential control modes. - Minimum Value: 0.0 - Maximum Value: 800 - Default Value: 800 - Units: A .. py:method:: with_peak_differential_duty_cycle(new_peak_differential_duty_cycle: float) -> DifferentialConstantsConfigs Modifies this configuration's peak_differential_duty_cycle parameter and returns itself for method-chaining and easier to use config API. Maximum differential output during duty cycle based differential control modes. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 1.0 - Units: fractional :param new_peak_differential_duty_cycle: Parameter to modify :type new_peak_differential_duty_cycle: float :returns: Itself :rtype: DifferentialConstantsConfigs .. py:method:: with_peak_differential_voltage(new_peak_differential_voltage: phoenix6.units.volt) -> DifferentialConstantsConfigs Modifies this configuration's peak_differential_voltage parameter and returns itself for method-chaining and easier to use config API. Maximum differential output during voltage based differential control modes. - Minimum Value: 0.0 - Maximum Value: 32 - Default Value: 16 - Units: V :param new_peak_differential_voltage: Parameter to modify :type new_peak_differential_voltage: volt :returns: Itself :rtype: DifferentialConstantsConfigs .. py:method:: with_peak_differential_torque_current(new_peak_differential_torque_current: phoenix6.units.ampere) -> DifferentialConstantsConfigs Modifies this configuration's peak_differential_torque_current parameter and returns itself for method-chaining and easier to use config API. Maximum differential output during torque current based differential control modes. - Minimum Value: 0.0 - Maximum Value: 800 - Default Value: 800 - Units: A :param new_peak_differential_torque_current: Parameter to modify :type new_peak_differential_torque_current: ampere :returns: Itself :rtype: DifferentialConstantsConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: OpenLoopRampsConfigs Configs that affect the open-loop control of this motor controller. Open-loop ramp rates for the various control types. .. py:attribute:: duty_cycle_open_loop_ramp_period :type: phoenix6.units.second :value: '0' If non-zero, this determines how much time to ramp from 0% output to 100% during the open-loop DutyCycleOut control mode. This provides an easy way to limit the acceleration of the motor. However, the acceleration and current draw of the motor can be better restricted using current limits instead of a ramp rate. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0 - Units: seconds .. py:attribute:: voltage_open_loop_ramp_period :type: phoenix6.units.second :value: '0' If non-zero, this determines how much time to ramp from 0V output to 12V during the open-loop VoltageOut control mode. This provides an easy way to limit the acceleration of the motor. However, the acceleration and current draw of the motor can be better restricted using current limits instead of a ramp rate. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0 - Units: seconds .. py:attribute:: torque_open_loop_ramp_period :type: phoenix6.units.second :value: '0' If non-zero, this determines how much time to ramp from 0A output to 300A during the open-loop TorqueCurrent control mode. Since TorqueCurrent is directly proportional to acceleration, this ramp limits jerk instead of acceleration. - Minimum Value: 0 - Maximum Value: 10 - Default Value: 0 - Units: seconds .. py:method:: with_duty_cycle_open_loop_ramp_period(new_duty_cycle_open_loop_ramp_period: phoenix6.units.second) -> OpenLoopRampsConfigs Modifies this configuration's duty_cycle_open_loop_ramp_period parameter and returns itself for method-chaining and easier to use config API. If non-zero, this determines how much time to ramp from 0% output to 100% during the open-loop DutyCycleOut control mode. This provides an easy way to limit the acceleration of the motor. However, the acceleration and current draw of the motor can be better restricted using current limits instead of a ramp rate. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0 - Units: seconds :param new_duty_cycle_open_loop_ramp_period: Parameter to modify :type new_duty_cycle_open_loop_ramp_period: second :returns: Itself :rtype: OpenLoopRampsConfigs .. py:method:: with_voltage_open_loop_ramp_period(new_voltage_open_loop_ramp_period: phoenix6.units.second) -> OpenLoopRampsConfigs Modifies this configuration's voltage_open_loop_ramp_period parameter and returns itself for method-chaining and easier to use config API. If non-zero, this determines how much time to ramp from 0V output to 12V during the open-loop VoltageOut control mode. This provides an easy way to limit the acceleration of the motor. However, the acceleration and current draw of the motor can be better restricted using current limits instead of a ramp rate. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0 - Units: seconds :param new_voltage_open_loop_ramp_period: Parameter to modify :type new_voltage_open_loop_ramp_period: second :returns: Itself :rtype: OpenLoopRampsConfigs .. py:method:: with_torque_open_loop_ramp_period(new_torque_open_loop_ramp_period: phoenix6.units.second) -> OpenLoopRampsConfigs Modifies this configuration's torque_open_loop_ramp_period parameter and returns itself for method-chaining and easier to use config API. If non-zero, this determines how much time to ramp from 0A output to 300A during the open-loop TorqueCurrent control mode. Since TorqueCurrent is directly proportional to acceleration, this ramp limits jerk instead of acceleration. - Minimum Value: 0 - Maximum Value: 10 - Default Value: 0 - Units: seconds :param new_torque_open_loop_ramp_period: Parameter to modify :type new_torque_open_loop_ramp_period: second :returns: Itself :rtype: OpenLoopRampsConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: ClosedLoopRampsConfigs Configs that affect the closed-loop control of this motor controller. Closed-loop ramp rates for the various control types. .. py:attribute:: duty_cycle_closed_loop_ramp_period :type: phoenix6.units.second :value: '0' If non-zero, this determines how much time to ramp from 0% output to 100% during the closed-loop DutyCycle control modes. If the goal is to limit acceleration, it is more useful to ramp the closed-loop setpoint instead of the output. This can be achieved using Motion Magic® controls. The acceleration and current draw of the motor can also be better restricted using current limits instead of a ramp rate. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0 - Units: seconds .. py:attribute:: voltage_closed_loop_ramp_period :type: phoenix6.units.second :value: '0' If non-zero, this determines how much time to ramp from 0V output to 12V during the closed-loop Voltage control modes. If the goal is to limit acceleration, it is more useful to ramp the closed-loop setpoint instead of the output. This can be achieved using Motion Magic® controls. The acceleration and current draw of the motor can also be better restricted using current limits instead of a ramp rate. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0 - Units: seconds .. py:attribute:: torque_closed_loop_ramp_period :type: phoenix6.units.second :value: '0' If non-zero, this determines how much time to ramp from 0A output to 300A during the closed-loop TorqueCurrent control modes. Since TorqueCurrent is directly proportional to acceleration, this ramp limits jerk instead of acceleration. If the goal is to limit acceleration or jerk, it is more useful to ramp the closed-loop setpoint instead of the output. This can be achieved using Motion Magic® controls. The acceleration and current draw of the motor can also be better restricted using current limits instead of a ramp rate. - Minimum Value: 0 - Maximum Value: 10 - Default Value: 0 - Units: seconds .. py:method:: with_duty_cycle_closed_loop_ramp_period(new_duty_cycle_closed_loop_ramp_period: phoenix6.units.second) -> ClosedLoopRampsConfigs Modifies this configuration's duty_cycle_closed_loop_ramp_period parameter and returns itself for method-chaining and easier to use config API. If non-zero, this determines how much time to ramp from 0% output to 100% during the closed-loop DutyCycle control modes. If the goal is to limit acceleration, it is more useful to ramp the closed-loop setpoint instead of the output. This can be achieved using Motion Magic® controls. The acceleration and current draw of the motor can also be better restricted using current limits instead of a ramp rate. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0 - Units: seconds :param new_duty_cycle_closed_loop_ramp_period: Parameter to modify :type new_duty_cycle_closed_loop_ramp_period: second :returns: Itself :rtype: ClosedLoopRampsConfigs .. py:method:: with_voltage_closed_loop_ramp_period(new_voltage_closed_loop_ramp_period: phoenix6.units.second) -> ClosedLoopRampsConfigs Modifies this configuration's voltage_closed_loop_ramp_period parameter and returns itself for method-chaining and easier to use config API. If non-zero, this determines how much time to ramp from 0V output to 12V during the closed-loop Voltage control modes. If the goal is to limit acceleration, it is more useful to ramp the closed-loop setpoint instead of the output. This can be achieved using Motion Magic® controls. The acceleration and current draw of the motor can also be better restricted using current limits instead of a ramp rate. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0 - Units: seconds :param new_voltage_closed_loop_ramp_period: Parameter to modify :type new_voltage_closed_loop_ramp_period: second :returns: Itself :rtype: ClosedLoopRampsConfigs .. py:method:: with_torque_closed_loop_ramp_period(new_torque_closed_loop_ramp_period: phoenix6.units.second) -> ClosedLoopRampsConfigs Modifies this configuration's torque_closed_loop_ramp_period parameter and returns itself for method-chaining and easier to use config API. If non-zero, this determines how much time to ramp from 0A output to 300A during the closed-loop TorqueCurrent control modes. Since TorqueCurrent is directly proportional to acceleration, this ramp limits jerk instead of acceleration. If the goal is to limit acceleration or jerk, it is more useful to ramp the closed-loop setpoint instead of the output. This can be achieved using Motion Magic® controls. The acceleration and current draw of the motor can also be better restricted using current limits instead of a ramp rate. - Minimum Value: 0 - Maximum Value: 10 - Default Value: 0 - Units: seconds :param new_torque_closed_loop_ramp_period: Parameter to modify :type new_torque_closed_loop_ramp_period: second :returns: Itself :rtype: ClosedLoopRampsConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: HardwareLimitSwitchConfigs Configs that change how the motor controller behaves under different limit switch states. Includes configs such as enabling limit switches, configuring the remote sensor ID, the source, and the position to set on limit. .. py:attribute:: forward_limit_type :type: ForwardLimitTypeValue Determines if the forward limit switch is normally-open (default) or normally-closed. .. py:attribute:: forward_limit_autoset_position_enable :type: bool :value: 'False' If enabled, the position is automatically set to a specific value, specified by ForwardLimitAutosetPositionValue, when the forward limit switch is asserted. - Default Value: False .. py:attribute:: forward_limit_autoset_position_value :type: phoenix6.units.rotation :value: '0' The value to automatically set the position to when the forward limit switch is asserted. This has no effect if ForwardLimitAutosetPositionEnable is false. - Minimum Value: -3.4e+38 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: rotations .. py:attribute:: forward_limit_enable :type: bool :value: 'True' If enabled, motor output is set to neutral when the forward limit switch is asserted and positive output is requested. - Default Value: True .. py:attribute:: forward_limit_source :type: ForwardLimitSourceValue Determines where to poll the forward limit switch. This defaults to the forward limit switch pin on the limit switch connector. Choose RemoteTalonFX to use the forward limit switch attached to another Talon FX on the same CAN bus (this also requires setting ForwardLimitRemoteSensorID). Choose RemoteCANifier to use the forward limit switch attached to another CANifier on the same CAN bus (this also requires setting ForwardLimitRemoteSensorID). Choose RemoteCANcoder to use another CANcoder on the same CAN bus (this also requires setting ForwardLimitRemoteSensorID). The forward limit will assert when the CANcoder magnet strength changes from BAD (red) to ADEQUATE (orange) or GOOD (green). .. py:attribute:: forward_limit_remote_sensor_id :type: int :value: '0' Device ID of the remote device if using remote limit switch features for the forward limit switch. - Minimum Value: 0 - Maximum Value: 62 - Default Value: 0 - Units: .. py:attribute:: reverse_limit_type :type: ReverseLimitTypeValue Determines if the reverse limit switch is normally-open (default) or normally-closed. .. py:attribute:: reverse_limit_autoset_position_enable :type: bool :value: 'False' If enabled, the position is automatically set to a specific value, specified by ReverseLimitAutosetPositionValue, when the reverse limit switch is asserted. - Default Value: False .. py:attribute:: reverse_limit_autoset_position_value :type: phoenix6.units.rotation :value: '0' The value to automatically set the position to when the reverse limit switch is asserted. This has no effect if ReverseLimitAutosetPositionEnable is false. - Minimum Value: -3.4e+38 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: rotations .. py:attribute:: reverse_limit_enable :type: bool :value: 'True' If enabled, motor output is set to neutral when reverse limit switch is asseted and negative output is requested. - Default Value: True .. py:attribute:: reverse_limit_source :type: ReverseLimitSourceValue Determines where to poll the reverse limit switch. This defaults to the reverse limit switch pin on the limit switch connector. Choose RemoteTalonFX to use the reverse limit switch attached to another Talon FX on the same CAN bus (this also requires setting ReverseLimitRemoteSensorID). Choose RemoteCANifier to use the reverse limit switch attached to another CANifier on the same CAN bus (this also requires setting ReverseLimitRemoteSensorID). Choose RemoteCANcoder to use another CANcoder on the same CAN bus (this also requires setting ReverseLimitRemoteSensorID). The reverse limit will assert when the CANcoder magnet strength changes from BAD (red) to ADEQUATE (orange) or GOOD (green). .. py:attribute:: reverse_limit_remote_sensor_id :type: int :value: '0' Device ID of the remote device if using remote limit switch features for the reverse limit switch. - Minimum Value: 0 - Maximum Value: 62 - Default Value: 0 - Units: .. py:method:: with_forward_limit_type(new_forward_limit_type: ForwardLimitTypeValue) -> HardwareLimitSwitchConfigs Modifies this configuration's forward_limit_type parameter and returns itself for method-chaining and easier to use config API. Determines if the forward limit switch is normally-open (default) or normally-closed. :param new_forward_limit_type: Parameter to modify :type new_forward_limit_type: ForwardLimitTypeValue :returns: Itself :rtype: HardwareLimitSwitchConfigs .. py:method:: with_forward_limit_autoset_position_enable(new_forward_limit_autoset_position_enable: bool) -> HardwareLimitSwitchConfigs Modifies this configuration's forward_limit_autoset_position_enable parameter and returns itself for method-chaining and easier to use config API. If enabled, the position is automatically set to a specific value, specified by ForwardLimitAutosetPositionValue, when the forward limit switch is asserted. - Default Value: False :param new_forward_limit_autoset_position_enable: Parameter to modify :type new_forward_limit_autoset_position_enable: bool :returns: Itself :rtype: HardwareLimitSwitchConfigs .. py:method:: with_forward_limit_autoset_position_value(new_forward_limit_autoset_position_value: phoenix6.units.rotation) -> HardwareLimitSwitchConfigs Modifies this configuration's forward_limit_autoset_position_value parameter and returns itself for method-chaining and easier to use config API. The value to automatically set the position to when the forward limit switch is asserted. This has no effect if ForwardLimitAutosetPositionEnable is false. - Minimum Value: -3.4e+38 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: rotations :param new_forward_limit_autoset_position_value: Parameter to modify :type new_forward_limit_autoset_position_value: rotation :returns: Itself :rtype: HardwareLimitSwitchConfigs .. py:method:: with_forward_limit_enable(new_forward_limit_enable: bool) -> HardwareLimitSwitchConfigs Modifies this configuration's forward_limit_enable parameter and returns itself for method-chaining and easier to use config API. If enabled, motor output is set to neutral when the forward limit switch is asserted and positive output is requested. - Default Value: True :param new_forward_limit_enable: Parameter to modify :type new_forward_limit_enable: bool :returns: Itself :rtype: HardwareLimitSwitchConfigs .. py:method:: with_forward_limit_source(new_forward_limit_source: ForwardLimitSourceValue) -> HardwareLimitSwitchConfigs Modifies this configuration's forward_limit_source parameter and returns itself for method-chaining and easier to use config API. Determines where to poll the forward limit switch. This defaults to the forward limit switch pin on the limit switch connector. Choose RemoteTalonFX to use the forward limit switch attached to another Talon FX on the same CAN bus (this also requires setting ForwardLimitRemoteSensorID). Choose RemoteCANifier to use the forward limit switch attached to another CANifier on the same CAN bus (this also requires setting ForwardLimitRemoteSensorID). Choose RemoteCANcoder to use another CANcoder on the same CAN bus (this also requires setting ForwardLimitRemoteSensorID). The forward limit will assert when the CANcoder magnet strength changes from BAD (red) to ADEQUATE (orange) or GOOD (green). :param new_forward_limit_source: Parameter to modify :type new_forward_limit_source: ForwardLimitSourceValue :returns: Itself :rtype: HardwareLimitSwitchConfigs .. py:method:: with_forward_limit_remote_sensor_id(new_forward_limit_remote_sensor_id: int) -> HardwareLimitSwitchConfigs Modifies this configuration's forward_limit_remote_sensor_id parameter and returns itself for method-chaining and easier to use config API. Device ID of the remote device if using remote limit switch features for the forward limit switch. - Minimum Value: 0 - Maximum Value: 62 - Default Value: 0 - Units: :param new_forward_limit_remote_sensor_id: Parameter to modify :type new_forward_limit_remote_sensor_id: int :returns: Itself :rtype: HardwareLimitSwitchConfigs .. py:method:: with_reverse_limit_type(new_reverse_limit_type: ReverseLimitTypeValue) -> HardwareLimitSwitchConfigs Modifies this configuration's reverse_limit_type parameter and returns itself for method-chaining and easier to use config API. Determines if the reverse limit switch is normally-open (default) or normally-closed. :param new_reverse_limit_type: Parameter to modify :type new_reverse_limit_type: ReverseLimitTypeValue :returns: Itself :rtype: HardwareLimitSwitchConfigs .. py:method:: with_reverse_limit_autoset_position_enable(new_reverse_limit_autoset_position_enable: bool) -> HardwareLimitSwitchConfigs Modifies this configuration's reverse_limit_autoset_position_enable parameter and returns itself for method-chaining and easier to use config API. If enabled, the position is automatically set to a specific value, specified by ReverseLimitAutosetPositionValue, when the reverse limit switch is asserted. - Default Value: False :param new_reverse_limit_autoset_position_enable: Parameter to modify :type new_reverse_limit_autoset_position_enable: bool :returns: Itself :rtype: HardwareLimitSwitchConfigs .. py:method:: with_reverse_limit_autoset_position_value(new_reverse_limit_autoset_position_value: phoenix6.units.rotation) -> HardwareLimitSwitchConfigs Modifies this configuration's reverse_limit_autoset_position_value parameter and returns itself for method-chaining and easier to use config API. The value to automatically set the position to when the reverse limit switch is asserted. This has no effect if ReverseLimitAutosetPositionEnable is false. - Minimum Value: -3.4e+38 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: rotations :param new_reverse_limit_autoset_position_value: Parameter to modify :type new_reverse_limit_autoset_position_value: rotation :returns: Itself :rtype: HardwareLimitSwitchConfigs .. py:method:: with_reverse_limit_enable(new_reverse_limit_enable: bool) -> HardwareLimitSwitchConfigs Modifies this configuration's reverse_limit_enable parameter and returns itself for method-chaining and easier to use config API. If enabled, motor output is set to neutral when reverse limit switch is asseted and negative output is requested. - Default Value: True :param new_reverse_limit_enable: Parameter to modify :type new_reverse_limit_enable: bool :returns: Itself :rtype: HardwareLimitSwitchConfigs .. py:method:: with_reverse_limit_source(new_reverse_limit_source: ReverseLimitSourceValue) -> HardwareLimitSwitchConfigs Modifies this configuration's reverse_limit_source parameter and returns itself for method-chaining and easier to use config API. Determines where to poll the reverse limit switch. This defaults to the reverse limit switch pin on the limit switch connector. Choose RemoteTalonFX to use the reverse limit switch attached to another Talon FX on the same CAN bus (this also requires setting ReverseLimitRemoteSensorID). Choose RemoteCANifier to use the reverse limit switch attached to another CANifier on the same CAN bus (this also requires setting ReverseLimitRemoteSensorID). Choose RemoteCANcoder to use another CANcoder on the same CAN bus (this also requires setting ReverseLimitRemoteSensorID). The reverse limit will assert when the CANcoder magnet strength changes from BAD (red) to ADEQUATE (orange) or GOOD (green). :param new_reverse_limit_source: Parameter to modify :type new_reverse_limit_source: ReverseLimitSourceValue :returns: Itself :rtype: HardwareLimitSwitchConfigs .. py:method:: with_reverse_limit_remote_sensor_id(new_reverse_limit_remote_sensor_id: int) -> HardwareLimitSwitchConfigs Modifies this configuration's reverse_limit_remote_sensor_id parameter and returns itself for method-chaining and easier to use config API. Device ID of the remote device if using remote limit switch features for the reverse limit switch. - Minimum Value: 0 - Maximum Value: 62 - Default Value: 0 - Units: :param new_reverse_limit_remote_sensor_id: Parameter to modify :type new_reverse_limit_remote_sensor_id: int :returns: Itself :rtype: HardwareLimitSwitchConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: AudioConfigs Configs that affect audible components of the device. Includes configuration for the beep on boot. .. py:attribute:: beep_on_boot :type: bool :value: 'True' If true, the TalonFX will beep during boot-up. This is useful for general debugging, and defaults to true. If rotor is moving during boot-up, the beep will not occur regardless of this setting. - Default Value: True .. py:attribute:: beep_on_config :type: bool :value: 'True' If true, the TalonFX will beep during configuration API calls if device is disabled. This is useful for general debugging, and defaults to true. Note that if the rotor is moving, the beep will not occur regardless of this setting. - Default Value: True .. py:attribute:: allow_music_dur_disable :type: bool :value: 'False' If true, the TalonFX will allow Orchestra and MusicTone requests during disabled state. This can be used to address corner cases when music features are needed when disabled. This setting defaults to false. Note that if the rotor is moving, music features are always disabled regardless of this setting. - Default Value: False .. py:method:: with_beep_on_boot(new_beep_on_boot: bool) -> AudioConfigs Modifies this configuration's beep_on_boot parameter and returns itself for method-chaining and easier to use config API. If true, the TalonFX will beep during boot-up. This is useful for general debugging, and defaults to true. If rotor is moving during boot-up, the beep will not occur regardless of this setting. - Default Value: True :param new_beep_on_boot: Parameter to modify :type new_beep_on_boot: bool :returns: Itself :rtype: AudioConfigs .. py:method:: with_beep_on_config(new_beep_on_config: bool) -> AudioConfigs Modifies this configuration's beep_on_config parameter and returns itself for method-chaining and easier to use config API. If true, the TalonFX will beep during configuration API calls if device is disabled. This is useful for general debugging, and defaults to true. Note that if the rotor is moving, the beep will not occur regardless of this setting. - Default Value: True :param new_beep_on_config: Parameter to modify :type new_beep_on_config: bool :returns: Itself :rtype: AudioConfigs .. py:method:: with_allow_music_dur_disable(new_allow_music_dur_disable: bool) -> AudioConfigs Modifies this configuration's allow_music_dur_disable parameter and returns itself for method-chaining and easier to use config API. If true, the TalonFX will allow Orchestra and MusicTone requests during disabled state. This can be used to address corner cases when music features are needed when disabled. This setting defaults to false. Note that if the rotor is moving, music features are always disabled regardless of this setting. - Default Value: False :param new_allow_music_dur_disable: Parameter to modify :type new_allow_music_dur_disable: bool :returns: Itself :rtype: AudioConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: SoftwareLimitSwitchConfigs Configs that affect how software-limit switches behave. Includes enabling software-limit switches and the threshold at which they are tripped. .. py:attribute:: forward_soft_limit_enable :type: bool :value: 'False' If enabled, the motor output is set to neutral if position exceeds ForwardSoftLimitThreshold and forward output is requested. - Default Value: False .. py:attribute:: reverse_soft_limit_enable :type: bool :value: 'False' If enabled, the motor output is set to neutral if position exceeds ReverseSoftLimitThreshold and reverse output is requested. - Default Value: False .. py:attribute:: forward_soft_limit_threshold :type: phoenix6.units.rotation :value: '0' Position threshold for forward soft limit features. ForwardSoftLimitEnable must be enabled for this to take effect. - Minimum Value: -3.4e+38 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: rotations .. py:attribute:: reverse_soft_limit_threshold :type: phoenix6.units.rotation :value: '0' Position threshold for reverse soft limit features. ReverseSoftLimitEnable must be enabled for this to take effect. - Minimum Value: -3.4e+38 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: rotations .. py:method:: with_forward_soft_limit_enable(new_forward_soft_limit_enable: bool) -> SoftwareLimitSwitchConfigs Modifies this configuration's forward_soft_limit_enable parameter and returns itself for method-chaining and easier to use config API. If enabled, the motor output is set to neutral if position exceeds ForwardSoftLimitThreshold and forward output is requested. - Default Value: False :param new_forward_soft_limit_enable: Parameter to modify :type new_forward_soft_limit_enable: bool :returns: Itself :rtype: SoftwareLimitSwitchConfigs .. py:method:: with_reverse_soft_limit_enable(new_reverse_soft_limit_enable: bool) -> SoftwareLimitSwitchConfigs Modifies this configuration's reverse_soft_limit_enable parameter and returns itself for method-chaining and easier to use config API. If enabled, the motor output is set to neutral if position exceeds ReverseSoftLimitThreshold and reverse output is requested. - Default Value: False :param new_reverse_soft_limit_enable: Parameter to modify :type new_reverse_soft_limit_enable: bool :returns: Itself :rtype: SoftwareLimitSwitchConfigs .. py:method:: with_forward_soft_limit_threshold(new_forward_soft_limit_threshold: phoenix6.units.rotation) -> SoftwareLimitSwitchConfigs Modifies this configuration's forward_soft_limit_threshold parameter and returns itself for method-chaining and easier to use config API. Position threshold for forward soft limit features. ForwardSoftLimitEnable must be enabled for this to take effect. - Minimum Value: -3.4e+38 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: rotations :param new_forward_soft_limit_threshold: Parameter to modify :type new_forward_soft_limit_threshold: rotation :returns: Itself :rtype: SoftwareLimitSwitchConfigs .. py:method:: with_reverse_soft_limit_threshold(new_reverse_soft_limit_threshold: phoenix6.units.rotation) -> SoftwareLimitSwitchConfigs Modifies this configuration's reverse_soft_limit_threshold parameter and returns itself for method-chaining and easier to use config API. Position threshold for reverse soft limit features. ReverseSoftLimitEnable must be enabled for this to take effect. - Minimum Value: -3.4e+38 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: rotations :param new_reverse_soft_limit_threshold: Parameter to modify :type new_reverse_soft_limit_threshold: rotation :returns: Itself :rtype: SoftwareLimitSwitchConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: MotionMagicConfigs Configs for Motion Magic®. Includes Velocity, Acceleration, Jerk, and Expo parameters. .. py:attribute:: motion_magic_cruise_velocity :type: phoenix6.units.rotations_per_second :value: '0' This is the maximum velocity Motion Magic® based control modes are allowed to use. Motion Magic® Velocity control modes do not use this config. When using Motion Magic® Expo control modes, setting this to 0 will allow the profile to run to the max possible velocity based on Expo_kV. - Minimum Value: 0 - Maximum Value: 9999 - Default Value: 0 - Units: rot per sec .. py:attribute:: motion_magic_acceleration :type: phoenix6.units.rotations_per_second_squared :value: '0' This is the target acceleration Motion Magic® based control modes are allowed to use. Motion Magic® Expo control modes do not use this config. - Minimum Value: 0 - Maximum Value: 9999 - Default Value: 0 - Units: rot per sec² .. py:attribute:: motion_magic_jerk :type: phoenix6.units.rotations_per_second_cubed :value: '0' This is the target jerk (acceleration derivative) Motion Magic® based control modes are allowed to use. Motion Magic® Expo control modes do not use this config. This allows Motion Magic® to generate S-Curve profiles. Jerk is optional; if this is set to zero, then Motion Magic® will not apply a Jerk limit. - Minimum Value: 0 - Maximum Value: 9999 - Default Value: 0 - Units: rot per sec³ .. py:attribute:: motion_magic_expo_k_v :type: phoenix6.units.volts_per_rotation_per_second :value: '0.12' This is the target kV used only by Motion Magic® Expo control modes. Unlike the kV slot gain, this is always in units of V/rps. This represents the amount of voltage necessary to hold a velocity. In terms of the Motion Magic® Expo profile, a higher kV results in a slower maximum velocity. - Minimum Value: 0.001 - Maximum Value: 100 - Default Value: 0.12 - Units: V/rps .. py:attribute:: motion_magic_expo_k_a :type: phoenix6.units.volts_per_rotation_per_second_squared :value: '0.1' This is the target kA used only by Motion Magic® Expo control modes. Unlike the kA slot gain, this is always in units of V/rps². This represents the amount of voltage necessary to achieve an acceleration. In terms of the Motion Magic® Expo profile, a higher kA results in a slower acceleration. - Minimum Value: 1e-05 - Maximum Value: 100 - Default Value: 0.1 - Units: V/rps² .. py:method:: with_motion_magic_cruise_velocity(new_motion_magic_cruise_velocity: phoenix6.units.rotations_per_second) -> MotionMagicConfigs Modifies this configuration's motion_magic_cruise_velocity parameter and returns itself for method-chaining and easier to use config API. This is the maximum velocity Motion Magic® based control modes are allowed to use. Motion Magic® Velocity control modes do not use this config. When using Motion Magic® Expo control modes, setting this to 0 will allow the profile to run to the max possible velocity based on Expo_kV. - Minimum Value: 0 - Maximum Value: 9999 - Default Value: 0 - Units: rot per sec :param new_motion_magic_cruise_velocity: Parameter to modify :type new_motion_magic_cruise_velocity: rotations_per_second :returns: Itself :rtype: MotionMagicConfigs .. py:method:: with_motion_magic_acceleration(new_motion_magic_acceleration: phoenix6.units.rotations_per_second_squared) -> MotionMagicConfigs Modifies this configuration's motion_magic_acceleration parameter and returns itself for method-chaining and easier to use config API. This is the target acceleration Motion Magic® based control modes are allowed to use. Motion Magic® Expo control modes do not use this config. - Minimum Value: 0 - Maximum Value: 9999 - Default Value: 0 - Units: rot per sec² :param new_motion_magic_acceleration: Parameter to modify :type new_motion_magic_acceleration: rotations_per_second_squared :returns: Itself :rtype: MotionMagicConfigs .. py:method:: with_motion_magic_jerk(new_motion_magic_jerk: phoenix6.units.rotations_per_second_cubed) -> MotionMagicConfigs Modifies this configuration's motion_magic_jerk parameter and returns itself for method-chaining and easier to use config API. This is the target jerk (acceleration derivative) Motion Magic® based control modes are allowed to use. Motion Magic® Expo control modes do not use this config. This allows Motion Magic® to generate S-Curve profiles. Jerk is optional; if this is set to zero, then Motion Magic® will not apply a Jerk limit. - Minimum Value: 0 - Maximum Value: 9999 - Default Value: 0 - Units: rot per sec³ :param new_motion_magic_jerk: Parameter to modify :type new_motion_magic_jerk: rotations_per_second_cubed :returns: Itself :rtype: MotionMagicConfigs .. py:method:: with_motion_magic_expo_k_v(new_motion_magic_expo_k_v: phoenix6.units.volts_per_rotation_per_second) -> MotionMagicConfigs Modifies this configuration's motion_magic_expo_k_v parameter and returns itself for method-chaining and easier to use config API. This is the target kV used only by Motion Magic® Expo control modes. Unlike the kV slot gain, this is always in units of V/rps. This represents the amount of voltage necessary to hold a velocity. In terms of the Motion Magic® Expo profile, a higher kV results in a slower maximum velocity. - Minimum Value: 0.001 - Maximum Value: 100 - Default Value: 0.12 - Units: V/rps :param new_motion_magic_expo_k_v: Parameter to modify :type new_motion_magic_expo_k_v: volts_per_rotation_per_second :returns: Itself :rtype: MotionMagicConfigs .. py:method:: with_motion_magic_expo_k_a(new_motion_magic_expo_k_a: phoenix6.units.volts_per_rotation_per_second_squared) -> MotionMagicConfigs Modifies this configuration's motion_magic_expo_k_a parameter and returns itself for method-chaining and easier to use config API. This is the target kA used only by Motion Magic® Expo control modes. Unlike the kA slot gain, this is always in units of V/rps². This represents the amount of voltage necessary to achieve an acceleration. In terms of the Motion Magic® Expo profile, a higher kA results in a slower acceleration. - Minimum Value: 1e-05 - Maximum Value: 100 - Default Value: 0.1 - Units: V/rps² :param new_motion_magic_expo_k_a: Parameter to modify :type new_motion_magic_expo_k_a: volts_per_rotation_per_second_squared :returns: Itself :rtype: MotionMagicConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: CustomParamsConfigs Custom Params. Custom paramaters that have no real impact on controller. .. py:attribute:: custom_param0 :type: int :value: '0' Custom parameter 0. This is provided to allow end-applications to store persistent information in the device. - Minimum Value: -32768 - Maximum Value: 32767 - Default Value: 0 - Units: .. py:attribute:: custom_param1 :type: int :value: '0' Custom parameter 1. This is provided to allow end-applications to store persistent information in the device. - Minimum Value: -32768 - Maximum Value: 32767 - Default Value: 0 - Units: .. py:method:: with_custom_param0(new_custom_param0: int) -> CustomParamsConfigs Modifies this configuration's custom_param0 parameter and returns itself for method-chaining and easier to use config API. Custom parameter 0. This is provided to allow end-applications to store persistent information in the device. - Minimum Value: -32768 - Maximum Value: 32767 - Default Value: 0 - Units: :param new_custom_param0: Parameter to modify :type new_custom_param0: int :returns: Itself :rtype: CustomParamsConfigs .. py:method:: with_custom_param1(new_custom_param1: int) -> CustomParamsConfigs Modifies this configuration's custom_param1 parameter and returns itself for method-chaining and easier to use config API. Custom parameter 1. This is provided to allow end-applications to store persistent information in the device. - Minimum Value: -32768 - Maximum Value: 32767 - Default Value: 0 - Units: :param new_custom_param1: Parameter to modify :type new_custom_param1: int :returns: Itself :rtype: CustomParamsConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: ClosedLoopGeneralConfigs Configs that affect general behavior during closed-looping. Includes Continuous Wrap features. .. py:attribute:: continuous_wrap :type: bool :value: 'False' Wrap position error within [-0.5, +0.5) mechanism rotations. Typically used for continuous position closed-loops like swerve azimuth. This uses the mechanism rotation value. If there is a gear ratio between the sensor and the mechanism, make sure to apply a SensorToMechanismRatio so the closed loop operates on the full rotation. - Default Value: False .. py:attribute:: differential_continuous_wrap :type: bool :value: 'False' Wrap differential difference position error within [-0.5, +0.5) mechanism rotations. Typically used for continuous position closed-loops like a differential wrist. This uses the differential difference rotation value. If there is a gear ratio on the difference axis, make sure to apply a SensorToDifferentialRatio so the closed loop operates on the full rotation. - Default Value: False .. py:attribute:: gain_sched_error_threshold :type: phoenix6.units.rotation :value: '0.0' The position closed-loop error threshold for gain scheduling. When the absolute value of the closed-loop error is within the threshold (inclusive), the PID controller will automatically switch gains according to the configured GainSchedBehavior of the slot. When this is zero (default), no gain scheduling will occur. Additionally, this does not take effect for velocity closed-loop controls. This can be used to implement a closed-loop deadband or, less commonly, to switch to weaker gains when close to the target. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 0.0 - Units: rotations .. py:attribute:: gain_sched_kp_behavior :type: GainSchedKpBehaviorValue The behavior of kP output as the error crosses the GainSchedErrorThreshold during gain scheduling. The output of kP can be adjusted to maintain continuity in output, or it can be left discontinuous. .. py:method:: with_continuous_wrap(new_continuous_wrap: bool) -> ClosedLoopGeneralConfigs Modifies this configuration's continuous_wrap parameter and returns itself for method-chaining and easier to use config API. Wrap position error within [-0.5, +0.5) mechanism rotations. Typically used for continuous position closed-loops like swerve azimuth. This uses the mechanism rotation value. If there is a gear ratio between the sensor and the mechanism, make sure to apply a SensorToMechanismRatio so the closed loop operates on the full rotation. - Default Value: False :param new_continuous_wrap: Parameter to modify :type new_continuous_wrap: bool :returns: Itself :rtype: ClosedLoopGeneralConfigs .. py:method:: with_differential_continuous_wrap(new_differential_continuous_wrap: bool) -> ClosedLoopGeneralConfigs Modifies this configuration's differential_continuous_wrap parameter and returns itself for method-chaining and easier to use config API. Wrap differential difference position error within [-0.5, +0.5) mechanism rotations. Typically used for continuous position closed-loops like a differential wrist. This uses the differential difference rotation value. If there is a gear ratio on the difference axis, make sure to apply a SensorToDifferentialRatio so the closed loop operates on the full rotation. - Default Value: False :param new_differential_continuous_wrap: Parameter to modify :type new_differential_continuous_wrap: bool :returns: Itself :rtype: ClosedLoopGeneralConfigs .. py:method:: with_gain_sched_error_threshold(new_gain_sched_error_threshold: phoenix6.units.rotation) -> ClosedLoopGeneralConfigs Modifies this configuration's gain_sched_error_threshold parameter and returns itself for method-chaining and easier to use config API. The position closed-loop error threshold for gain scheduling. When the absolute value of the closed-loop error is within the threshold (inclusive), the PID controller will automatically switch gains according to the configured GainSchedBehavior of the slot. When this is zero (default), no gain scheduling will occur. Additionally, this does not take effect for velocity closed-loop controls. This can be used to implement a closed-loop deadband or, less commonly, to switch to weaker gains when close to the target. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 0.0 - Units: rotations :param new_gain_sched_error_threshold: Parameter to modify :type new_gain_sched_error_threshold: rotation :returns: Itself :rtype: ClosedLoopGeneralConfigs .. py:method:: with_gain_sched_kp_behavior(new_gain_sched_kp_behavior: GainSchedKpBehaviorValue) -> ClosedLoopGeneralConfigs Modifies this configuration's gain_sched_kp_behavior parameter and returns itself for method-chaining and easier to use config API. The behavior of kP output as the error crosses the GainSchedErrorThreshold during gain scheduling. The output of kP can be adjusted to maintain continuity in output, or it can be left discontinuous. :param new_gain_sched_kp_behavior: Parameter to modify :type new_gain_sched_kp_behavior: GainSchedKpBehaviorValue :returns: Itself :rtype: ClosedLoopGeneralConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: ToFParamsConfigs Configs that affect the ToF sensor Includes Update mode and frequency .. py:attribute:: update_mode :type: UpdateModeValue Update mode of the CANrange. The CANrange supports short-range and long-range detection at various update frequencies. .. py:attribute:: update_frequency :type: phoenix6.units.hertz :value: '50' Rate at which the CANrange will take measurements. A lower frequency may provide more stable readings but will reduce the data rate of the sensor. - Minimum Value: 5 - Maximum Value: 50 - Default Value: 50 - Units: Hz .. py:method:: with_update_mode(new_update_mode: UpdateModeValue) -> ToFParamsConfigs Modifies this configuration's update_mode parameter and returns itself for method-chaining and easier to use config API. Update mode of the CANrange. The CANrange supports short-range and long-range detection at various update frequencies. :param new_update_mode: Parameter to modify :type new_update_mode: UpdateModeValue :returns: Itself :rtype: ToFParamsConfigs .. py:method:: with_update_frequency(new_update_frequency: phoenix6.units.hertz) -> ToFParamsConfigs Modifies this configuration's update_frequency parameter and returns itself for method-chaining and easier to use config API. Rate at which the CANrange will take measurements. A lower frequency may provide more stable readings but will reduce the data rate of the sensor. - Minimum Value: 5 - Maximum Value: 50 - Default Value: 50 - Units: Hz :param new_update_frequency: Parameter to modify :type new_update_frequency: hertz :returns: Itself :rtype: ToFParamsConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: ProximityParamsConfigs Configs that affect the ToF Proximity detection Includes proximity mode and the threshold for simple detection .. py:attribute:: proximity_threshold :type: phoenix6.units.meter :value: '0.4' Threshold for object detection. - Minimum Value: 0 - Maximum Value: 4 - Default Value: 0.4 - Units: m .. py:attribute:: proximity_hysteresis :type: phoenix6.units.meter :value: '0.01' How far above and below the threshold the distance needs to be to trigger undetected and detected, respectively. This is used to prevent bouncing between the detected and undetected states for objects on the threshold. If the threshold is set to 0.1 meters, and the hysteresis is 0.01 meters, then an object needs to be within 0.09 meters to be detected. After the object is first detected, the distance then needs to exceed 0.11 meters to become undetected again. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0.01 - Units: m .. py:attribute:: min_signal_strength_for_valid_measurement :type: float :value: '2500' The minimum allowable signal strength before determining the measurement is valid. If the signal strength is particularly low, this typically means the object is far away and there's fewer total samples to derive the distance from. Set this value to be below the lowest strength you see when you're detecting an object with the CANrange; the default of 2500 is typically acceptable in most cases. - Minimum Value: 1 - Maximum Value: 15000 - Default Value: 2500 - Units: .. py:method:: with_proximity_threshold(new_proximity_threshold: phoenix6.units.meter) -> ProximityParamsConfigs Modifies this configuration's proximity_threshold parameter and returns itself for method-chaining and easier to use config API. Threshold for object detection. - Minimum Value: 0 - Maximum Value: 4 - Default Value: 0.4 - Units: m :param new_proximity_threshold: Parameter to modify :type new_proximity_threshold: meter :returns: Itself :rtype: ProximityParamsConfigs .. py:method:: with_proximity_hysteresis(new_proximity_hysteresis: phoenix6.units.meter) -> ProximityParamsConfigs Modifies this configuration's proximity_hysteresis parameter and returns itself for method-chaining and easier to use config API. How far above and below the threshold the distance needs to be to trigger undetected and detected, respectively. This is used to prevent bouncing between the detected and undetected states for objects on the threshold. If the threshold is set to 0.1 meters, and the hysteresis is 0.01 meters, then an object needs to be within 0.09 meters to be detected. After the object is first detected, the distance then needs to exceed 0.11 meters to become undetected again. - Minimum Value: 0 - Maximum Value: 1 - Default Value: 0.01 - Units: m :param new_proximity_hysteresis: Parameter to modify :type new_proximity_hysteresis: meter :returns: Itself :rtype: ProximityParamsConfigs .. py:method:: with_min_signal_strength_for_valid_measurement(new_min_signal_strength_for_valid_measurement: float) -> ProximityParamsConfigs Modifies this configuration's min_signal_strength_for_valid_measurement parameter and returns itself for method-chaining and easier to use config API. The minimum allowable signal strength before determining the measurement is valid. If the signal strength is particularly low, this typically means the object is far away and there's fewer total samples to derive the distance from. Set this value to be below the lowest strength you see when you're detecting an object with the CANrange; the default of 2500 is typically acceptable in most cases. - Minimum Value: 1 - Maximum Value: 15000 - Default Value: 2500 - Units: :param new_min_signal_strength_for_valid_measurement: Parameter to modify :type new_min_signal_strength_for_valid_measurement: float :returns: Itself :rtype: ProximityParamsConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: FovParamsConfigs Configs that affect the ToF Field of View Includes range and center configs .. py:attribute:: fov_center_x :type: phoenix6.units.degree :value: '0' Specifies the target center of the Field of View in the X direction. The exact value may be different for different CANrange devices due to imperfections in the sensing silicon. - Minimum Value: -11.8 - Maximum Value: 11.8 - Default Value: 0 - Units: deg .. py:attribute:: fov_center_y :type: phoenix6.units.degree :value: '0' Specifies the target center of the Field of View in the Y direction. The exact value may be different for different CANrange devices due to imperfections in the sensing silicon. - Minimum Value: -11.8 - Maximum Value: 11.8 - Default Value: 0 - Units: deg .. py:attribute:: fov_range_x :type: phoenix6.units.degree :value: '27' Specifies the target range of the Field of View in the X direction. This is the full range of the FOV. The magnitude of this is capped to abs(27 - 2*FOVCenterX). The exact value may be different for different CANrange devices due to imperfections in the sensing silicon. - Minimum Value: 6.75 - Maximum Value: 27 - Default Value: 27 - Units: deg .. py:attribute:: fov_range_y :type: phoenix6.units.degree :value: '27' Specifies the target range of the Field of View in the Y direction. This is the full range of the FOV. The magnitude of this is capped to abs(27 - 2*FOVCenterY). The exact value may be different for different CANrange devices due to imperfections in the sensing silicon. - Minimum Value: 6.75 - Maximum Value: 27 - Default Value: 27 - Units: deg .. py:method:: with_fov_center_x(new_fov_center_x: phoenix6.units.degree) -> FovParamsConfigs Modifies this configuration's fov_center_x parameter and returns itself for method-chaining and easier to use config API. Specifies the target center of the Field of View in the X direction. The exact value may be different for different CANrange devices due to imperfections in the sensing silicon. - Minimum Value: -11.8 - Maximum Value: 11.8 - Default Value: 0 - Units: deg :param new_fov_center_x: Parameter to modify :type new_fov_center_x: degree :returns: Itself :rtype: FovParamsConfigs .. py:method:: with_fov_center_y(new_fov_center_y: phoenix6.units.degree) -> FovParamsConfigs Modifies this configuration's fov_center_y parameter and returns itself for method-chaining and easier to use config API. Specifies the target center of the Field of View in the Y direction. The exact value may be different for different CANrange devices due to imperfections in the sensing silicon. - Minimum Value: -11.8 - Maximum Value: 11.8 - Default Value: 0 - Units: deg :param new_fov_center_y: Parameter to modify :type new_fov_center_y: degree :returns: Itself :rtype: FovParamsConfigs .. py:method:: with_fov_range_x(new_fov_range_x: phoenix6.units.degree) -> FovParamsConfigs Modifies this configuration's fov_range_x parameter and returns itself for method-chaining and easier to use config API. Specifies the target range of the Field of View in the X direction. This is the full range of the FOV. The magnitude of this is capped to abs(27 - 2*FOVCenterX). The exact value may be different for different CANrange devices due to imperfections in the sensing silicon. - Minimum Value: 6.75 - Maximum Value: 27 - Default Value: 27 - Units: deg :param new_fov_range_x: Parameter to modify :type new_fov_range_x: degree :returns: Itself :rtype: FovParamsConfigs .. py:method:: with_fov_range_y(new_fov_range_y: phoenix6.units.degree) -> FovParamsConfigs Modifies this configuration's fov_range_y parameter and returns itself for method-chaining and easier to use config API. Specifies the target range of the Field of View in the Y direction. This is the full range of the FOV. The magnitude of this is capped to abs(27 - 2*FOVCenterY). The exact value may be different for different CANrange devices due to imperfections in the sensing silicon. - Minimum Value: 6.75 - Maximum Value: 27 - Default Value: 27 - Units: deg :param new_fov_range_y: Parameter to modify :type new_fov_range_y: degree :returns: Itself :rtype: FovParamsConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: CommutationConfigs Configs that determine motor selection and commutation. Set these configs to match your motor setup before commanding motor output. .. py:attribute:: advanced_hall_support :type: AdvancedHallSupportValue Requires Phoenix Pro; Improves commutation and velocity measurement for motors with hall sensors. Talon can use advanced features to improve commutation and velocity measurement when using a motor with hall sensors. This can improve peak efficiency by as high as 2% and reduce noise in the measured velocity. .. py:attribute:: motor_arrangement :type: MotorArrangementValue Selects the motor and motor connections used with Talon. This setting determines what kind of motor and sensors are used with the Talon. This also determines what signals are used on the JST and Gadgeteer port. Motor drive will not function correctly if this setting does not match the physical setup. .. py:attribute:: brushed_motor_wiring :type: BrushedMotorWiringValue If a brushed motor is selected with Motor Arrangement, this config determines which of three leads to use. .. py:method:: with_advanced_hall_support(new_advanced_hall_support: AdvancedHallSupportValue) -> CommutationConfigs Modifies this configuration's advanced_hall_support parameter and returns itself for method-chaining and easier to use config API. Requires Phoenix Pro; Improves commutation and velocity measurement for motors with hall sensors. Talon can use advanced features to improve commutation and velocity measurement when using a motor with hall sensors. This can improve peak efficiency by as high as 2% and reduce noise in the measured velocity. :param new_advanced_hall_support: Parameter to modify :type new_advanced_hall_support: AdvancedHallSupportValue :returns: Itself :rtype: CommutationConfigs .. py:method:: with_motor_arrangement(new_motor_arrangement: MotorArrangementValue) -> CommutationConfigs Modifies this configuration's motor_arrangement parameter and returns itself for method-chaining and easier to use config API. Selects the motor and motor connections used with Talon. This setting determines what kind of motor and sensors are used with the Talon. This also determines what signals are used on the JST and Gadgeteer port. Motor drive will not function correctly if this setting does not match the physical setup. :param new_motor_arrangement: Parameter to modify :type new_motor_arrangement: MotorArrangementValue :returns: Itself :rtype: CommutationConfigs .. py:method:: with_brushed_motor_wiring(new_brushed_motor_wiring: BrushedMotorWiringValue) -> CommutationConfigs Modifies this configuration's brushed_motor_wiring parameter and returns itself for method-chaining and easier to use config API. If a brushed motor is selected with Motor Arrangement, this config determines which of three leads to use. :param new_brushed_motor_wiring: Parameter to modify :type new_brushed_motor_wiring: BrushedMotorWiringValue :returns: Itself :rtype: CommutationConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: DigitalInputsConfigs Configs related to the CANdi™ branded device's digital I/O settings Contains float-state settings and when to assert the S1/S2 inputs. .. py:attribute:: s1_float_state :type: S1FloatStateValue The floating state of the Signal 1 input (S1IN). .. py:attribute:: s2_float_state :type: S2FloatStateValue The floating state of the Signal 2 input (S2IN). .. py:attribute:: s1_close_state :type: S1CloseStateValue What value the Signal 1 input (S1IN) needs to be for the CTR Electronics' CANdi™ to detect as Closed. Devices using the S1 input as a remote limit switch will treat the switch as closed when the S1 input is this state. .. py:attribute:: s2_close_state :type: S2CloseStateValue What value the Signal 2 input (S2IN) needs to be for the CTR Electronics' CANdi™ to detect as Closed. Devices using the S2 input as a remote limit switch will treat the switch as closed when the S2 input is this state. .. py:method:: with_s1_float_state(new_s1_float_state: S1FloatStateValue) -> DigitalInputsConfigs Modifies this configuration's s1_float_state parameter and returns itself for method-chaining and easier to use config API. The floating state of the Signal 1 input (S1IN). :param new_s1_float_state: Parameter to modify :type new_s1_float_state: S1FloatStateValue :returns: Itself :rtype: DigitalInputsConfigs .. py:method:: with_s2_float_state(new_s2_float_state: S2FloatStateValue) -> DigitalInputsConfigs Modifies this configuration's s2_float_state parameter and returns itself for method-chaining and easier to use config API. The floating state of the Signal 2 input (S2IN). :param new_s2_float_state: Parameter to modify :type new_s2_float_state: S2FloatStateValue :returns: Itself :rtype: DigitalInputsConfigs .. py:method:: with_s1_close_state(new_s1_close_state: S1CloseStateValue) -> DigitalInputsConfigs Modifies this configuration's s1_close_state parameter and returns itself for method-chaining and easier to use config API. What value the Signal 1 input (S1IN) needs to be for the CTR Electronics' CANdi™ to detect as Closed. Devices using the S1 input as a remote limit switch will treat the switch as closed when the S1 input is this state. :param new_s1_close_state: Parameter to modify :type new_s1_close_state: S1CloseStateValue :returns: Itself :rtype: DigitalInputsConfigs .. py:method:: with_s2_close_state(new_s2_close_state: S2CloseStateValue) -> DigitalInputsConfigs Modifies this configuration's s2_close_state parameter and returns itself for method-chaining and easier to use config API. What value the Signal 2 input (S2IN) needs to be for the CTR Electronics' CANdi™ to detect as Closed. Devices using the S2 input as a remote limit switch will treat the switch as closed when the S2 input is this state. :param new_s2_close_state: Parameter to modify :type new_s2_close_state: S2CloseStateValue :returns: Itself :rtype: DigitalInputsConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: QuadratureConfigs Configs related to the CANdi™ branded device's quadrature interface using both the S1IN and S2IN inputs All the configs related to the quadrature interface for the CANdi™ branded device , including encoder edges per revolution and sensor direction. .. py:attribute:: quadrature_edges_per_rotation :type: int :value: '4096' The number of quadrature edges in one rotation for the quadrature sensor connected to the Talon data port. This is the total number of transitions from high-to-low or low-to-high across both channels per rotation of the sensor. This is also equivalent to the Counts Per Revolution when using 4x decoding. For example, the SRX Mag Encoder has 4096 edges per rotation, and a US Digital 1024 CPR (Cycles Per Revolution) quadrature encoder has 4096 edges per rotation. On the Talon FXS, this can be at most 2,000,000,000 / Peak RPM. - Minimum Value: 1 - Maximum Value: 1000000 - Default Value: 4096 - Units: .. py:attribute:: sensor_direction :type: bool :value: 'False' Direction of the quadrature sensor to determine positive rotation. Invert this so that forward motion on the mechanism results in an increase in quadrature position. - Default Value: False .. py:method:: with_quadrature_edges_per_rotation(new_quadrature_edges_per_rotation: int) -> QuadratureConfigs Modifies this configuration's quadrature_edges_per_rotation parameter and returns itself for method-chaining and easier to use config API. The number of quadrature edges in one rotation for the quadrature sensor connected to the Talon data port. This is the total number of transitions from high-to-low or low-to-high across both channels per rotation of the sensor. This is also equivalent to the Counts Per Revolution when using 4x decoding. For example, the SRX Mag Encoder has 4096 edges per rotation, and a US Digital 1024 CPR (Cycles Per Revolution) quadrature encoder has 4096 edges per rotation. On the Talon FXS, this can be at most 2,000,000,000 / Peak RPM. - Minimum Value: 1 - Maximum Value: 1000000 - Default Value: 4096 - Units: :param new_quadrature_edges_per_rotation: Parameter to modify :type new_quadrature_edges_per_rotation: int :returns: Itself :rtype: QuadratureConfigs .. py:method:: with_sensor_direction(new_sensor_direction: bool) -> QuadratureConfigs Modifies this configuration's sensor_direction parameter and returns itself for method-chaining and easier to use config API. Direction of the quadrature sensor to determine positive rotation. Invert this so that forward motion on the mechanism results in an increase in quadrature position. - Default Value: False :param new_sensor_direction: Parameter to modify :type new_sensor_direction: bool :returns: Itself :rtype: QuadratureConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: PWM1Configs Configs related to the CANdi™ branded device's PWM interface on the Signal 1 input (S1IN) All the configs related to the PWM interface for the CANdi™ branded device on S1, including absolute sensor offset, absolute sensor discontinuity point and sensor direction. .. py:attribute:: absolute_sensor_offset :type: phoenix6.units.rotation :value: '0.0' The offset applied to the PWM sensor. This offset is added to the reported sensor position. This can be used to zero the sensor position in applications where the sensor is 1:1 with the mechanism. - Minimum Value: -1 - Maximum Value: 1 - Default Value: 0.0 - Units: rotations .. py:attribute:: absolute_sensor_discontinuity_point :type: phoenix6.units.rotation :value: '0.5' The positive discontinuity point of the absolute sensor in rotations. This determines the point at which the absolute sensor wraps around, keeping the absolute position (after offset) in the range [x-1, x). - Setting this to 1 makes the absolute position unsigned [0, 1) - Setting this to 0.5 makes the absolute position signed [-0.5, 0.5) - Setting this to 0 makes the absolute position always negative [-1, 0) Many rotational mechanisms such as arms have a region of motion that is unreachable. This should be set to the center of that region of motion, in non-negative rotations. This affects the position of the device at bootup. For example, consider an arm which can travel from -0.2 to 0.6 rotations with a little leeway, where 0 is horizontally forward. Since -0.2 rotations has the same absolute position as 0.8 rotations, we can say that the arm typically does not travel in the range (0.6, 0.8) rotations. As a result, the discontinuity point would be the center of that range, which is 0.7 rotations. This results in an absolute sensor range of [-0.3, 0.7) rotations. Given a total range of motion less than 1 rotation, users can calculate the discontinuity point using mean(lowerLimit, upperLimit) + 0.5. If that results in a value outside the range [0, 1], either cap the value to [0, 1], or add/subtract 1.0 rotation from your lower and upper limits of motion. On a Talon motor controller, this is only supported when using the PulseWidth sensor source. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 0.5 - Units: rotations .. py:attribute:: sensor_direction :type: bool :value: 'False' Direction of the PWM sensor to determine positive rotation. Invert this so that forward motion on the mechanism results in an increase in PWM position. - Default Value: False .. py:method:: with_absolute_sensor_offset(new_absolute_sensor_offset: phoenix6.units.rotation) -> PWM1Configs Modifies this configuration's absolute_sensor_offset parameter and returns itself for method-chaining and easier to use config API. The offset applied to the PWM sensor. This offset is added to the reported sensor position. This can be used to zero the sensor position in applications where the sensor is 1:1 with the mechanism. - Minimum Value: -1 - Maximum Value: 1 - Default Value: 0.0 - Units: rotations :param new_absolute_sensor_offset: Parameter to modify :type new_absolute_sensor_offset: rotation :returns: Itself :rtype: PWM1Configs .. py:method:: with_absolute_sensor_discontinuity_point(new_absolute_sensor_discontinuity_point: phoenix6.units.rotation) -> PWM1Configs Modifies this configuration's absolute_sensor_discontinuity_point parameter and returns itself for method-chaining and easier to use config API. The positive discontinuity point of the absolute sensor in rotations. This determines the point at which the absolute sensor wraps around, keeping the absolute position (after offset) in the range [x-1, x). - Setting this to 1 makes the absolute position unsigned [0, 1) - Setting this to 0.5 makes the absolute position signed [-0.5, 0.5) - Setting this to 0 makes the absolute position always negative [-1, 0) Many rotational mechanisms such as arms have a region of motion that is unreachable. This should be set to the center of that region of motion, in non-negative rotations. This affects the position of the device at bootup. For example, consider an arm which can travel from -0.2 to 0.6 rotations with a little leeway, where 0 is horizontally forward. Since -0.2 rotations has the same absolute position as 0.8 rotations, we can say that the arm typically does not travel in the range (0.6, 0.8) rotations. As a result, the discontinuity point would be the center of that range, which is 0.7 rotations. This results in an absolute sensor range of [-0.3, 0.7) rotations. Given a total range of motion less than 1 rotation, users can calculate the discontinuity point using mean(lowerLimit, upperLimit) + 0.5. If that results in a value outside the range [0, 1], either cap the value to [0, 1], or add/subtract 1.0 rotation from your lower and upper limits of motion. On a Talon motor controller, this is only supported when using the PulseWidth sensor source. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 0.5 - Units: rotations :param new_absolute_sensor_discontinuity_point: Parameter to modify :type new_absolute_sensor_discontinuity_point: rotation :returns: Itself :rtype: PWM1Configs .. py:method:: with_sensor_direction(new_sensor_direction: bool) -> PWM1Configs Modifies this configuration's sensor_direction parameter and returns itself for method-chaining and easier to use config API. Direction of the PWM sensor to determine positive rotation. Invert this so that forward motion on the mechanism results in an increase in PWM position. - Default Value: False :param new_sensor_direction: Parameter to modify :type new_sensor_direction: bool :returns: Itself :rtype: PWM1Configs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: PWM2Configs Configs related to the CANdi™ branded device's PWM interface on the Signal 2 input (S2IN) All the configs related to the PWM interface for the CANdi™ branded device on S1, including absolute sensor offset, absolute sensor discontinuity point and sensor direction. .. py:attribute:: absolute_sensor_offset :type: phoenix6.units.rotation :value: '0.0' The offset applied to the PWM sensor. This offset is added to the reported sensor position. This can be used to zero the sensor position in applications where the sensor is 1:1 with the mechanism. - Minimum Value: -1 - Maximum Value: 1 - Default Value: 0.0 - Units: rotations .. py:attribute:: absolute_sensor_discontinuity_point :type: phoenix6.units.rotation :value: '0.5' The positive discontinuity point of the absolute sensor in rotations. This determines the point at which the absolute sensor wraps around, keeping the absolute position (after offset) in the range [x-1, x). - Setting this to 1 makes the absolute position unsigned [0, 1) - Setting this to 0.5 makes the absolute position signed [-0.5, 0.5) - Setting this to 0 makes the absolute position always negative [-1, 0) Many rotational mechanisms such as arms have a region of motion that is unreachable. This should be set to the center of that region of motion, in non-negative rotations. This affects the position of the device at bootup. For example, consider an arm which can travel from -0.2 to 0.6 rotations with a little leeway, where 0 is horizontally forward. Since -0.2 rotations has the same absolute position as 0.8 rotations, we can say that the arm typically does not travel in the range (0.6, 0.8) rotations. As a result, the discontinuity point would be the center of that range, which is 0.7 rotations. This results in an absolute sensor range of [-0.3, 0.7) rotations. Given a total range of motion less than 1 rotation, users can calculate the discontinuity point using mean(lowerLimit, upperLimit) + 0.5. If that results in a value outside the range [0, 1], either cap the value to [0, 1], or add/subtract 1.0 rotation from your lower and upper limits of motion. On a Talon motor controller, this is only supported when using the PulseWidth sensor source. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 0.5 - Units: rotations .. py:attribute:: sensor_direction :type: bool :value: 'False' Direction of the PWM sensor to determine positive rotation. Invert this so that forward motion on the mechanism results in an increase in PWM position. - Default Value: False .. py:method:: with_absolute_sensor_offset(new_absolute_sensor_offset: phoenix6.units.rotation) -> PWM2Configs Modifies this configuration's absolute_sensor_offset parameter and returns itself for method-chaining and easier to use config API. The offset applied to the PWM sensor. This offset is added to the reported sensor position. This can be used to zero the sensor position in applications where the sensor is 1:1 with the mechanism. - Minimum Value: -1 - Maximum Value: 1 - Default Value: 0.0 - Units: rotations :param new_absolute_sensor_offset: Parameter to modify :type new_absolute_sensor_offset: rotation :returns: Itself :rtype: PWM2Configs .. py:method:: with_absolute_sensor_discontinuity_point(new_absolute_sensor_discontinuity_point: phoenix6.units.rotation) -> PWM2Configs Modifies this configuration's absolute_sensor_discontinuity_point parameter and returns itself for method-chaining and easier to use config API. The positive discontinuity point of the absolute sensor in rotations. This determines the point at which the absolute sensor wraps around, keeping the absolute position (after offset) in the range [x-1, x). - Setting this to 1 makes the absolute position unsigned [0, 1) - Setting this to 0.5 makes the absolute position signed [-0.5, 0.5) - Setting this to 0 makes the absolute position always negative [-1, 0) Many rotational mechanisms such as arms have a region of motion that is unreachable. This should be set to the center of that region of motion, in non-negative rotations. This affects the position of the device at bootup. For example, consider an arm which can travel from -0.2 to 0.6 rotations with a little leeway, where 0 is horizontally forward. Since -0.2 rotations has the same absolute position as 0.8 rotations, we can say that the arm typically does not travel in the range (0.6, 0.8) rotations. As a result, the discontinuity point would be the center of that range, which is 0.7 rotations. This results in an absolute sensor range of [-0.3, 0.7) rotations. Given a total range of motion less than 1 rotation, users can calculate the discontinuity point using mean(lowerLimit, upperLimit) + 0.5. If that results in a value outside the range [0, 1], either cap the value to [0, 1], or add/subtract 1.0 rotation from your lower and upper limits of motion. On a Talon motor controller, this is only supported when using the PulseWidth sensor source. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 0.5 - Units: rotations :param new_absolute_sensor_discontinuity_point: Parameter to modify :type new_absolute_sensor_discontinuity_point: rotation :returns: Itself :rtype: PWM2Configs .. py:method:: with_sensor_direction(new_sensor_direction: bool) -> PWM2Configs Modifies this configuration's sensor_direction parameter and returns itself for method-chaining and easier to use config API. Direction of the PWM sensor to determine positive rotation. Invert this so that forward motion on the mechanism results in an increase in PWM position. - Default Value: False :param new_sensor_direction: Parameter to modify :type new_sensor_direction: bool :returns: Itself :rtype: PWM2Configs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: LEDConfigs Configs related to CANdle LED control. All the configs related to controlling LEDs with the CANdle, including LED strip type and brightness. .. py:attribute:: strip_type :type: StripTypeValue The type of LEDs that are being controlled. .. py:attribute:: brightness_scalar :type: float :value: '1.0' The brightness scalar for all LEDs controlled. All LED values sent to the CANdle will be scaled by this config. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 1.0 - Units: scalar .. py:attribute:: loss_of_signal_behavior :type: LossOfSignalBehaviorValue The behavior of the LEDs when the control signal is lost. .. py:method:: with_strip_type(new_strip_type: StripTypeValue) -> LEDConfigs Modifies this configuration's strip_type parameter and returns itself for method-chaining and easier to use config API. The type of LEDs that are being controlled. :param new_strip_type: Parameter to modify :type new_strip_type: StripTypeValue :returns: Itself :rtype: LEDConfigs .. py:method:: with_brightness_scalar(new_brightness_scalar: float) -> LEDConfigs Modifies this configuration's brightness_scalar parameter and returns itself for method-chaining and easier to use config API. The brightness scalar for all LEDs controlled. All LED values sent to the CANdle will be scaled by this config. - Minimum Value: 0.0 - Maximum Value: 1.0 - Default Value: 1.0 - Units: scalar :param new_brightness_scalar: Parameter to modify :type new_brightness_scalar: float :returns: Itself :rtype: LEDConfigs .. py:method:: with_loss_of_signal_behavior(new_loss_of_signal_behavior: LossOfSignalBehaviorValue) -> LEDConfigs Modifies this configuration's loss_of_signal_behavior parameter and returns itself for method-chaining and easier to use config API. The behavior of the LEDs when the control signal is lost. :param new_loss_of_signal_behavior: Parameter to modify :type new_loss_of_signal_behavior: LossOfSignalBehaviorValue :returns: Itself :rtype: LEDConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: CANdleFeaturesConfigs Configs related to general CANdle features. This includes configs such as disabling the 5V rail and the behavior of VBat output. .. py:attribute:: enable5_v_rail :type: Enable5VRailValue Whether the 5V rail is enabled. Disabling the 5V rail will also turn off the onboard LEDs. .. py:attribute:: v_bat_output_mode :type: VBatOutputModeValue The behavior of the VBat output. CANdle supports modulating VBat output for single-color LED strips. .. py:attribute:: status_led_when_active :type: StatusLedWhenActiveValue Whether the Status LED is enabled when the CANdle is actively being controlled. .. py:method:: with_enable5_v_rail(new_enable5_v_rail: Enable5VRailValue) -> CANdleFeaturesConfigs Modifies this configuration's enable5_v_rail parameter and returns itself for method-chaining and easier to use config API. Whether the 5V rail is enabled. Disabling the 5V rail will also turn off the onboard LEDs. :param new_enable5_v_rail: Parameter to modify :type new_enable5_v_rail: Enable5VRailValue :returns: Itself :rtype: CANdleFeaturesConfigs .. py:method:: with_v_bat_output_mode(new_v_bat_output_mode: VBatOutputModeValue) -> CANdleFeaturesConfigs Modifies this configuration's v_bat_output_mode parameter and returns itself for method-chaining and easier to use config API. The behavior of the VBat output. CANdle supports modulating VBat output for single-color LED strips. :param new_v_bat_output_mode: Parameter to modify :type new_v_bat_output_mode: VBatOutputModeValue :returns: Itself :rtype: CANdleFeaturesConfigs .. py:method:: with_status_led_when_active(new_status_led_when_active: StatusLedWhenActiveValue) -> CANdleFeaturesConfigs Modifies this configuration's status_led_when_active parameter and returns itself for method-chaining and easier to use config API. Whether the Status LED is enabled when the CANdle is actively being controlled. :param new_status_led_when_active: Parameter to modify :type new_status_led_when_active: StatusLedWhenActiveValue :returns: Itself :rtype: CANdleFeaturesConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: CustomBrushlessMotorConfigs Configs related to using a custom brushless motor that is not formally supported by Talon FXS. Configs are only used when Motor Arrangement is set to Custom Brushless Motor. Note this feature will only work device is not FRC-Locked. Users are responsible for ensuring that these configs are accurate to the motor. CTR Electronics is not responsible for damage caused by an incorrect custom motor configuration. .. py:attribute:: motor_kv :type: phoenix6.units.rpm_per_volt :value: '500' Kv constant of the connected custom brushless motor. This can usually be determined by consulting the motor manufacturer data sheet. - Minimum Value: 0 - Maximum Value: 2047 - Default Value: 500 - Units: RPM/V .. py:attribute:: pole_pair_count :type: int :value: '1' Number of pole pairs in the connected custom brushless motor (number of poles divided by 2). This can usually be determined by consulting the motor manufacturer data sheet. For example, if motor has ten poles, then specify five pole pairs. - Minimum Value: 1 - Maximum Value: 8 - Default Value: 1 - Units: .. py:attribute:: hall_during_ab :type: int :value: '0' Expected Hall Value when motor controller applies A+ and B-. Hall Values are little endian [CBA]. For example, if halls report: HA=0, HB=0, HC=1, then the Hall Value is 4. - Minimum Value: 0 - Maximum Value: 6 - Default Value: 0 - Units: .. py:attribute:: hall_during_ac :type: int :value: '0' Expected Hall Value when motor controller applies A+ and C-. Hall Values are little endian [CBA]. For example, if halls report: HA=0, HB=0, HC=1, then the Hall Value is 4. - Minimum Value: 0 - Maximum Value: 6 - Default Value: 0 - Units: .. py:attribute:: hall_ccw_select :type: bool :value: 'False' Optional configuration to correct clockwise versus counter-clockwise rotor spin. Depending on the mechanical design of the motor, rotor may spin clockwise during positive output when Inverted is set to counterclockwise. This configuration can be toggled so that the rest of the API is canonically true. - Default Value: False .. py:attribute:: hall_direction :type: bool :value: 'False' Determines expected Hall direction for rotor velocity signage. If RotorVelocity is signed opposite of applied voltage, flip this configuration. - Default Value: False .. py:method:: with_motor_kv(new_motor_kv: phoenix6.units.rpm_per_volt) -> CustomBrushlessMotorConfigs Modifies this configuration's motor_kv parameter and returns itself for method-chaining and easier to use config API. Kv constant of the connected custom brushless motor. This can usually be determined by consulting the motor manufacturer data sheet. - Minimum Value: 0 - Maximum Value: 2047 - Default Value: 500 - Units: RPM/V :param new_motor_kv: Parameter to modify :type new_motor_kv: rpm_per_volt :returns: Itself :rtype: CustomBrushlessMotorConfigs .. py:method:: with_pole_pair_count(new_pole_pair_count: int) -> CustomBrushlessMotorConfigs Modifies this configuration's pole_pair_count parameter and returns itself for method-chaining and easier to use config API. Number of pole pairs in the connected custom brushless motor (number of poles divided by 2). This can usually be determined by consulting the motor manufacturer data sheet. For example, if motor has ten poles, then specify five pole pairs. - Minimum Value: 1 - Maximum Value: 8 - Default Value: 1 - Units: :param new_pole_pair_count: Parameter to modify :type new_pole_pair_count: int :returns: Itself :rtype: CustomBrushlessMotorConfigs .. py:method:: with_hall_during_ab(new_hall_during_ab: int) -> CustomBrushlessMotorConfigs Modifies this configuration's hall_during_ab parameter and returns itself for method-chaining and easier to use config API. Expected Hall Value when motor controller applies A+ and B-. Hall Values are little endian [CBA]. For example, if halls report: HA=0, HB=0, HC=1, then the Hall Value is 4. - Minimum Value: 0 - Maximum Value: 6 - Default Value: 0 - Units: :param new_hall_during_ab: Parameter to modify :type new_hall_during_ab: int :returns: Itself :rtype: CustomBrushlessMotorConfigs .. py:method:: with_hall_during_ac(new_hall_during_ac: int) -> CustomBrushlessMotorConfigs Modifies this configuration's hall_during_ac parameter and returns itself for method-chaining and easier to use config API. Expected Hall Value when motor controller applies A+ and C-. Hall Values are little endian [CBA]. For example, if halls report: HA=0, HB=0, HC=1, then the Hall Value is 4. - Minimum Value: 0 - Maximum Value: 6 - Default Value: 0 - Units: :param new_hall_during_ac: Parameter to modify :type new_hall_during_ac: int :returns: Itself :rtype: CustomBrushlessMotorConfigs .. py:method:: with_hall_ccw_select(new_hall_ccw_select: bool) -> CustomBrushlessMotorConfigs Modifies this configuration's hall_ccw_select parameter and returns itself for method-chaining and easier to use config API. Optional configuration to correct clockwise versus counter-clockwise rotor spin. Depending on the mechanical design of the motor, rotor may spin clockwise during positive output when Inverted is set to counterclockwise. This configuration can be toggled so that the rest of the API is canonically true. - Default Value: False :param new_hall_ccw_select: Parameter to modify :type new_hall_ccw_select: bool :returns: Itself :rtype: CustomBrushlessMotorConfigs .. py:method:: with_hall_direction(new_hall_direction: bool) -> CustomBrushlessMotorConfigs Modifies this configuration's hall_direction parameter and returns itself for method-chaining and easier to use config API. Determines expected Hall direction for rotor velocity signage. If RotorVelocity is signed opposite of applied voltage, flip this configuration. - Default Value: False :param new_hall_direction: Parameter to modify :type new_hall_direction: bool :returns: Itself :rtype: CustomBrushlessMotorConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: ExternalTempConfigs Configs related to using an independent thermister for automatically disabling a motor when a threshold has been reached. Configs are only used when Motor Arrangement is set to Custom Brushless Motor or Brushed. Note this feature will only work device is not FRC-Locked. Users are responsible for ensuring that these configs are accurate to the motor. CTR Electronics is not responsible for damage caused by an incorrect custom motor configuration. .. py:attribute:: thermistor_max_temperature :type: phoenix6.units.celsius :value: '0' Threshold for thermal faulting a custom motor. The motor controller will fault if the connected motor thermistor exceeds this value. - Minimum Value: 0 - Maximum Value: 150 - Default Value: 0 - Units: ℃ .. py:attribute:: thermistor_beta :type: phoenix6.units.kelvin :value: '0' Beta K value for the connected NTC thermistor. This can usually be determined by consulting the motor manufacturer data sheet. - Minimum Value: 0 - Maximum Value: 8000 - Default Value: 0 - Units: K .. py:attribute:: thermistor_r0 :type: phoenix6.units.kiloohm :value: '0' The thermistor resistance for the connected NTC thermistor as measured at 25'C. This can usually be determined by consulting the motor manufacturer data sheet. - Minimum Value: 0 - Maximum Value: 400 - Default Value: 0 - Units: kOhm .. py:attribute:: temp_sensor_required :type: TempSensorRequiredValue Whether a temperature sensor should be required for motor control. This configuration is ignored in FRC environments and defaults to Required. .. py:method:: with_thermistor_max_temperature(new_thermistor_max_temperature: phoenix6.units.celsius) -> ExternalTempConfigs Modifies this configuration's thermistor_max_temperature parameter and returns itself for method-chaining and easier to use config API. Threshold for thermal faulting a custom motor. The motor controller will fault if the connected motor thermistor exceeds this value. - Minimum Value: 0 - Maximum Value: 150 - Default Value: 0 - Units: ℃ :param new_thermistor_max_temperature: Parameter to modify :type new_thermistor_max_temperature: celsius :returns: Itself :rtype: ExternalTempConfigs .. py:method:: with_thermistor_beta(new_thermistor_beta: phoenix6.units.kelvin) -> ExternalTempConfigs Modifies this configuration's thermistor_beta parameter and returns itself for method-chaining and easier to use config API. Beta K value for the connected NTC thermistor. This can usually be determined by consulting the motor manufacturer data sheet. - Minimum Value: 0 - Maximum Value: 8000 - Default Value: 0 - Units: K :param new_thermistor_beta: Parameter to modify :type new_thermistor_beta: kelvin :returns: Itself :rtype: ExternalTempConfigs .. py:method:: with_thermistor_r0(new_thermistor_r0: phoenix6.units.kiloohm) -> ExternalTempConfigs Modifies this configuration's thermistor_r0 parameter and returns itself for method-chaining and easier to use config API. The thermistor resistance for the connected NTC thermistor as measured at 25'C. This can usually be determined by consulting the motor manufacturer data sheet. - Minimum Value: 0 - Maximum Value: 400 - Default Value: 0 - Units: kOhm :param new_thermistor_r0: Parameter to modify :type new_thermistor_r0: kiloohm :returns: Itself :rtype: ExternalTempConfigs .. py:method:: with_temp_sensor_required(new_temp_sensor_required: TempSensorRequiredValue) -> ExternalTempConfigs Modifies this configuration's temp_sensor_required parameter and returns itself for method-chaining and easier to use config API. Whether a temperature sensor should be required for motor control. This configuration is ignored in FRC environments and defaults to Required. :param new_temp_sensor_required: Parameter to modify :type new_temp_sensor_required: TempSensorRequiredValue :returns: Itself :rtype: ExternalTempConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: Slot0Configs Gains for the specified slot. If this slot is selected, these gains are used in closed loop control requests. .. py:attribute:: k_p :type: float :value: '0' Proportional gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input, the units should be defined as units of output per unit of input error. For example, when controlling velocity using a duty cycle closed loop, the units for the proportional gain will be duty cycle per rps of error, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_i :type: float :value: '0' Integral gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input integrated over time (in units of seconds), the units should be defined as units of output per unit of integrated input error. For example, when controlling velocity using a duty cycle closed loop, integrating velocity over time results in rps * s = rotations. Therefore, the units for the integral gain will be duty cycle per rotation of accumulated error, or 1/rot. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_d :type: float :value: '0' Derivative gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the derivative of error in the input with respect to time (in units of seconds), the units should be defined as units of output per unit of the differentiated input error. For example, when controlling velocity using a duty cycle closed loop, the derivative of velocity with respect to time is rot per sec², which is acceleration. Therefore, the units for the derivative gain will be duty cycle per unit of acceleration error, or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_s :type: float :value: '0' Static feedforward gain. This is added to the closed loop output. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. The sign is typically determined by reference velocity when using position, velocity, and Motion Magic® closed loop modes. However, when using position closed loop with zero velocity reference (no motion profiling), the application can instead use the position closed loop error by setting the Static Feedforward Sign configuration parameter. When doing so, we recommend the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: .. py:attribute:: k_v :type: float :value: '0' Velocity feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested velocity, the units should be defined as units of output per unit of requested input velocity. For example, when controlling velocity using a duty cycle closed loop, the units for the velocity feedfoward gain will be duty cycle per requested rps, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_a :type: float :value: '0' Acceleration feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested acceleration, the units should be defined as units of output per unit of requested input acceleration. For example, when controlling velocity using a duty cycle closed loop, the units for the acceleration feedfoward gain will be duty cycle per requested rot per sec², or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_g :type: float :value: '0' Gravity feedforward/feedback gain. The type of gravity compensation is selected by self.gravity_type. This is added to the closed loop output. The sign is determined by the gravity type. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: .. py:attribute:: gravity_type :type: GravityTypeValue Gravity feedforward/feedback type. This determines the type of the gravity feedforward/feedback. Choose Elevator_Static for systems where the gravity feedforward is constant, such as an elevator. The gravity feedforward output will always have the same sign. Choose Arm_Cosine for systems where the gravity feedback is dependent on the angular position of the mechanism, such as an arm. The gravity feedback output will vary depending on the mechanism angular position. Note that the sensor offset and ratios must be configured so that the sensor reports a position of 0 when the mechanism is horizonal (parallel to the ground), and the reported sensor position is 1:1 with the mechanism. .. py:attribute:: static_feedforward_sign :type: StaticFeedforwardSignValue Static feedforward sign during position closed loop. This determines the sign of the applied kS during position closed-loop modes. The default behavior uses the velocity reference sign. This works well with velocity closed loop, Motion Magic® controls, and position closed loop when velocity reference is specified (motion profiling). However, when using position closed loop with zero velocity reference (no motion profiling), the application may want to apply static feedforward based on the sign of closed loop error instead. When doing so, we recommend using the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. .. py:attribute:: gravity_arm_position_offset :type: phoenix6.units.rotation :value: '0' Gravity feedback position offset when using the Arm/Cosine gravity type. This is an offset applied to the position of the arm, within (-0.25, 0.25) rot, before calculating the output of kG. This is useful when the center of gravity of the arm is offset from the actual zero point of the arm, such as when the arm and intake form an L shape. - Minimum Value: -0.25 - Maximum Value: 0.25 - Default Value: 0 - Units: rotations .. py:attribute:: gain_sched_behavior :type: GainSchedBehaviorValue The behavior of the gain scheduler on this slot. This specifies which gains to use while within the configured GainSchedErrorThreshold. The default is to continue using the specified slot. Gain scheduling will not take effect when running velocity closed-loop controls. .. py:method:: with_k_p(new_k_p: float) -> Slot0Configs Modifies this configuration's k_p parameter and returns itself for method-chaining and easier to use config API. Proportional gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input, the units should be defined as units of output per unit of input error. For example, when controlling velocity using a duty cycle closed loop, the units for the proportional gain will be duty cycle per rps of error, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_p: Parameter to modify :type new_k_p: float :returns: Itself :rtype: Slot0Configs .. py:method:: with_k_i(new_k_i: float) -> Slot0Configs Modifies this configuration's k_i parameter and returns itself for method-chaining and easier to use config API. Integral gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input integrated over time (in units of seconds), the units should be defined as units of output per unit of integrated input error. For example, when controlling velocity using a duty cycle closed loop, integrating velocity over time results in rps * s = rotations. Therefore, the units for the integral gain will be duty cycle per rotation of accumulated error, or 1/rot. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_i: Parameter to modify :type new_k_i: float :returns: Itself :rtype: Slot0Configs .. py:method:: with_k_d(new_k_d: float) -> Slot0Configs Modifies this configuration's k_d parameter and returns itself for method-chaining and easier to use config API. Derivative gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the derivative of error in the input with respect to time (in units of seconds), the units should be defined as units of output per unit of the differentiated input error. For example, when controlling velocity using a duty cycle closed loop, the derivative of velocity with respect to time is rot per sec², which is acceleration. Therefore, the units for the derivative gain will be duty cycle per unit of acceleration error, or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_d: Parameter to modify :type new_k_d: float :returns: Itself :rtype: Slot0Configs .. py:method:: with_k_s(new_k_s: float) -> Slot0Configs Modifies this configuration's k_s parameter and returns itself for method-chaining and easier to use config API. Static feedforward gain. This is added to the closed loop output. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. The sign is typically determined by reference velocity when using position, velocity, and Motion Magic® closed loop modes. However, when using position closed loop with zero velocity reference (no motion profiling), the application can instead use the position closed loop error by setting the Static Feedforward Sign configuration parameter. When doing so, we recommend the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: :param new_k_s: Parameter to modify :type new_k_s: float :returns: Itself :rtype: Slot0Configs .. py:method:: with_k_v(new_k_v: float) -> Slot0Configs Modifies this configuration's k_v parameter and returns itself for method-chaining and easier to use config API. Velocity feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested velocity, the units should be defined as units of output per unit of requested input velocity. For example, when controlling velocity using a duty cycle closed loop, the units for the velocity feedfoward gain will be duty cycle per requested rps, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_v: Parameter to modify :type new_k_v: float :returns: Itself :rtype: Slot0Configs .. py:method:: with_k_a(new_k_a: float) -> Slot0Configs Modifies this configuration's k_a parameter and returns itself for method-chaining and easier to use config API. Acceleration feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested acceleration, the units should be defined as units of output per unit of requested input acceleration. For example, when controlling velocity using a duty cycle closed loop, the units for the acceleration feedfoward gain will be duty cycle per requested rot per sec², or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_a: Parameter to modify :type new_k_a: float :returns: Itself :rtype: Slot0Configs .. py:method:: with_k_g(new_k_g: float) -> Slot0Configs Modifies this configuration's k_g parameter and returns itself for method-chaining and easier to use config API. Gravity feedforward/feedback gain. The type of gravity compensation is selected by self.gravity_type. This is added to the closed loop output. The sign is determined by the gravity type. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: :param new_k_g: Parameter to modify :type new_k_g: float :returns: Itself :rtype: Slot0Configs .. py:method:: with_gravity_type(new_gravity_type: GravityTypeValue) -> Slot0Configs Modifies this configuration's gravity_type parameter and returns itself for method-chaining and easier to use config API. Gravity feedforward/feedback type. This determines the type of the gravity feedforward/feedback. Choose Elevator_Static for systems where the gravity feedforward is constant, such as an elevator. The gravity feedforward output will always have the same sign. Choose Arm_Cosine for systems where the gravity feedback is dependent on the angular position of the mechanism, such as an arm. The gravity feedback output will vary depending on the mechanism angular position. Note that the sensor offset and ratios must be configured so that the sensor reports a position of 0 when the mechanism is horizonal (parallel to the ground), and the reported sensor position is 1:1 with the mechanism. :param new_gravity_type: Parameter to modify :type new_gravity_type: GravityTypeValue :returns: Itself :rtype: Slot0Configs .. py:method:: with_static_feedforward_sign(new_static_feedforward_sign: StaticFeedforwardSignValue) -> Slot0Configs Modifies this configuration's static_feedforward_sign parameter and returns itself for method-chaining and easier to use config API. Static feedforward sign during position closed loop. This determines the sign of the applied kS during position closed-loop modes. The default behavior uses the velocity reference sign. This works well with velocity closed loop, Motion Magic® controls, and position closed loop when velocity reference is specified (motion profiling). However, when using position closed loop with zero velocity reference (no motion profiling), the application may want to apply static feedforward based on the sign of closed loop error instead. When doing so, we recommend using the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. :param new_static_feedforward_sign: Parameter to modify :type new_static_feedforward_sign: StaticFeedforwardSignValue :returns: Itself :rtype: Slot0Configs .. py:method:: with_gravity_arm_position_offset(new_gravity_arm_position_offset: phoenix6.units.rotation) -> Slot0Configs Modifies this configuration's gravity_arm_position_offset parameter and returns itself for method-chaining and easier to use config API. Gravity feedback position offset when using the Arm/Cosine gravity type. This is an offset applied to the position of the arm, within (-0.25, 0.25) rot, before calculating the output of kG. This is useful when the center of gravity of the arm is offset from the actual zero point of the arm, such as when the arm and intake form an L shape. - Minimum Value: -0.25 - Maximum Value: 0.25 - Default Value: 0 - Units: rotations :param new_gravity_arm_position_offset: Parameter to modify :type new_gravity_arm_position_offset: rotation :returns: Itself :rtype: Slot0Configs .. py:method:: with_gain_sched_behavior(new_gain_sched_behavior: GainSchedBehaviorValue) -> Slot0Configs Modifies this configuration's gain_sched_behavior parameter and returns itself for method-chaining and easier to use config API. The behavior of the gain scheduler on this slot. This specifies which gains to use while within the configured GainSchedErrorThreshold. The default is to continue using the specified slot. Gain scheduling will not take effect when running velocity closed-loop controls. :param new_gain_sched_behavior: Parameter to modify :type new_gain_sched_behavior: GainSchedBehaviorValue :returns: Itself :rtype: Slot0Configs .. py:method:: from_other(value) -> Slot0Configs :classmethod: .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: Slot1Configs Gains for the specified slot. If this slot is selected, these gains are used in closed loop control requests. .. py:attribute:: k_p :type: float :value: '0' Proportional gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input, the units should be defined as units of output per unit of input error. For example, when controlling velocity using a duty cycle closed loop, the units for the proportional gain will be duty cycle per rps, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_i :type: float :value: '0' Integral gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input integrated over time (in units of seconds), the units should be defined as units of output per unit of integrated input error. For example, when controlling velocity using a duty cycle closed loop, integrating velocity over time results in rps * s = rotations. Therefore, the units for the integral gain will be duty cycle per rotation of accumulated error, or 1/rot. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_d :type: float :value: '0' Derivative gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the derivative of error in the input with respect to time (in units of seconds), the units should be defined as units of output per unit of the differentiated input error. For example, when controlling velocity using a duty cycle closed loop, the derivative of velocity with respect to time is rot per sec², which is acceleration. Therefore, the units for the derivative gain will be duty cycle per unit of acceleration error, or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_s :type: float :value: '0' Static feedforward gain. This is added to the closed loop output. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. The sign is typically determined by reference velocity when using position, velocity, and Motion Magic® closed loop modes. However, when using position closed loop with zero velocity reference (no motion profiling), the application can instead use the position closed loop error by setting the Static Feedforward Sign configuration parameter. When doing so, we recommend the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: .. py:attribute:: k_v :type: float :value: '0' Velocity feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested velocity, the units should be defined as units of output per unit of requested input velocity. For example, when controlling velocity using a duty cycle closed loop, the units for the velocity feedfoward gain will be duty cycle per requested rps, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_a :type: float :value: '0' Acceleration feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested acceleration, the units should be defined as units of output per unit of requested input acceleration. For example, when controlling velocity using a duty cycle closed loop, the units for the acceleration feedfoward gain will be duty cycle per requested rot per sec², or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_g :type: float :value: '0' Gravity feedforward/feedback gain. The type of gravity compensation is selected by self.gravity_type. This is added to the closed loop output. The sign is determined by the gravity type. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: .. py:attribute:: gravity_type :type: GravityTypeValue Gravity feedforward/feedback type. This determines the type of the gravity feedforward/feedback. Choose Elevator_Static for systems where the gravity feedforward is constant, such as an elevator. The gravity feedforward output will always be positive. Choose Arm_Cosine for systems where the gravity feedback is dependent on the angular position of the mechanism, such as an arm. The gravity feedback output will vary depending on the mechanism angular position. Note that the sensor offset and ratios must be configured so that the sensor position is 0 when the mechanism is horizonal, and one rotation of the mechanism corresponds to one rotation of the sensor position. .. py:attribute:: static_feedforward_sign :type: StaticFeedforwardSignValue Static feedforward sign during position closed loop. This determines the sign of the applied kS during position closed-loop modes. The default behavior uses the velocity reference sign. This works well with velocity closed loop, Motion Magic® controls, and position closed loop when velocity reference is specified (motion profiling). However, when using position closed loop with zero velocity reference (no motion profiling), the application may want to apply static feedforward based on the closed loop error sign instead. When doing so, we recommend using the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. .. py:attribute:: gravity_arm_position_offset :type: phoenix6.units.rotation :value: '0' Gravity feedback position offset when using the Arm/Cosine gravity type. This is an offset applied to the position of the arm, within (-0.25, 0.25) rot, before calculating the output of kG. This is useful when the center of gravity of the arm is offset from the actual zero point of the arm, such as when the arm and intake form an L shape. - Minimum Value: -0.25 - Maximum Value: 0.25 - Default Value: 0 - Units: rotations .. py:attribute:: gain_sched_behavior :type: GainSchedBehaviorValue The behavior of the gain scheduler on this slot. This specifies which gains to use while within the configured GainSchedErrorThreshold. The default is to continue using the specified slot. Gain scheduling will not take effect when running velocity closed-loop controls. .. py:method:: with_k_p(new_k_p: float) -> Slot1Configs Modifies this configuration's k_p parameter and returns itself for method-chaining and easier to use config API. Proportional gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input, the units should be defined as units of output per unit of input error. For example, when controlling velocity using a duty cycle closed loop, the units for the proportional gain will be duty cycle per rps, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_p: Parameter to modify :type new_k_p: float :returns: Itself :rtype: Slot1Configs .. py:method:: with_k_i(new_k_i: float) -> Slot1Configs Modifies this configuration's k_i parameter and returns itself for method-chaining and easier to use config API. Integral gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input integrated over time (in units of seconds), the units should be defined as units of output per unit of integrated input error. For example, when controlling velocity using a duty cycle closed loop, integrating velocity over time results in rps * s = rotations. Therefore, the units for the integral gain will be duty cycle per rotation of accumulated error, or 1/rot. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_i: Parameter to modify :type new_k_i: float :returns: Itself :rtype: Slot1Configs .. py:method:: with_k_d(new_k_d: float) -> Slot1Configs Modifies this configuration's k_d parameter and returns itself for method-chaining and easier to use config API. Derivative gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the derivative of error in the input with respect to time (in units of seconds), the units should be defined as units of output per unit of the differentiated input error. For example, when controlling velocity using a duty cycle closed loop, the derivative of velocity with respect to time is rot per sec², which is acceleration. Therefore, the units for the derivative gain will be duty cycle per unit of acceleration error, or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_d: Parameter to modify :type new_k_d: float :returns: Itself :rtype: Slot1Configs .. py:method:: with_k_s(new_k_s: float) -> Slot1Configs Modifies this configuration's k_s parameter and returns itself for method-chaining and easier to use config API. Static feedforward gain. This is added to the closed loop output. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. The sign is typically determined by reference velocity when using position, velocity, and Motion Magic® closed loop modes. However, when using position closed loop with zero velocity reference (no motion profiling), the application can instead use the position closed loop error by setting the Static Feedforward Sign configuration parameter. When doing so, we recommend the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: :param new_k_s: Parameter to modify :type new_k_s: float :returns: Itself :rtype: Slot1Configs .. py:method:: with_k_v(new_k_v: float) -> Slot1Configs Modifies this configuration's k_v parameter and returns itself for method-chaining and easier to use config API. Velocity feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested velocity, the units should be defined as units of output per unit of requested input velocity. For example, when controlling velocity using a duty cycle closed loop, the units for the velocity feedfoward gain will be duty cycle per requested rps, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_v: Parameter to modify :type new_k_v: float :returns: Itself :rtype: Slot1Configs .. py:method:: with_k_a(new_k_a: float) -> Slot1Configs Modifies this configuration's k_a parameter and returns itself for method-chaining and easier to use config API. Acceleration feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested acceleration, the units should be defined as units of output per unit of requested input acceleration. For example, when controlling velocity using a duty cycle closed loop, the units for the acceleration feedfoward gain will be duty cycle per requested rot per sec², or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_a: Parameter to modify :type new_k_a: float :returns: Itself :rtype: Slot1Configs .. py:method:: with_k_g(new_k_g: float) -> Slot1Configs Modifies this configuration's k_g parameter and returns itself for method-chaining and easier to use config API. Gravity feedforward/feedback gain. The type of gravity compensation is selected by self.gravity_type. This is added to the closed loop output. The sign is determined by the gravity type. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: :param new_k_g: Parameter to modify :type new_k_g: float :returns: Itself :rtype: Slot1Configs .. py:method:: with_gravity_type(new_gravity_type: GravityTypeValue) -> Slot1Configs Modifies this configuration's gravity_type parameter and returns itself for method-chaining and easier to use config API. Gravity feedforward/feedback type. This determines the type of the gravity feedforward/feedback. Choose Elevator_Static for systems where the gravity feedforward is constant, such as an elevator. The gravity feedforward output will always be positive. Choose Arm_Cosine for systems where the gravity feedback is dependent on the angular position of the mechanism, such as an arm. The gravity feedback output will vary depending on the mechanism angular position. Note that the sensor offset and ratios must be configured so that the sensor position is 0 when the mechanism is horizonal, and one rotation of the mechanism corresponds to one rotation of the sensor position. :param new_gravity_type: Parameter to modify :type new_gravity_type: GravityTypeValue :returns: Itself :rtype: Slot1Configs .. py:method:: with_static_feedforward_sign(new_static_feedforward_sign: StaticFeedforwardSignValue) -> Slot1Configs Modifies this configuration's static_feedforward_sign parameter and returns itself for method-chaining and easier to use config API. Static feedforward sign during position closed loop. This determines the sign of the applied kS during position closed-loop modes. The default behavior uses the velocity reference sign. This works well with velocity closed loop, Motion Magic® controls, and position closed loop when velocity reference is specified (motion profiling). However, when using position closed loop with zero velocity reference (no motion profiling), the application may want to apply static feedforward based on the closed loop error sign instead. When doing so, we recommend using the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. :param new_static_feedforward_sign: Parameter to modify :type new_static_feedforward_sign: StaticFeedforwardSignValue :returns: Itself :rtype: Slot1Configs .. py:method:: with_gravity_arm_position_offset(new_gravity_arm_position_offset: phoenix6.units.rotation) -> Slot1Configs Modifies this configuration's gravity_arm_position_offset parameter and returns itself for method-chaining and easier to use config API. Gravity feedback position offset when using the Arm/Cosine gravity type. This is an offset applied to the position of the arm, within (-0.25, 0.25) rot, before calculating the output of kG. This is useful when the center of gravity of the arm is offset from the actual zero point of the arm, such as when the arm and intake form an L shape. - Minimum Value: -0.25 - Maximum Value: 0.25 - Default Value: 0 - Units: rotations :param new_gravity_arm_position_offset: Parameter to modify :type new_gravity_arm_position_offset: rotation :returns: Itself :rtype: Slot1Configs .. py:method:: with_gain_sched_behavior(new_gain_sched_behavior: GainSchedBehaviorValue) -> Slot1Configs Modifies this configuration's gain_sched_behavior parameter and returns itself for method-chaining and easier to use config API. The behavior of the gain scheduler on this slot. This specifies which gains to use while within the configured GainSchedErrorThreshold. The default is to continue using the specified slot. Gain scheduling will not take effect when running velocity closed-loop controls. :param new_gain_sched_behavior: Parameter to modify :type new_gain_sched_behavior: GainSchedBehaviorValue :returns: Itself :rtype: Slot1Configs .. py:method:: from_other(value) -> Slot1Configs :classmethod: .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: Slot2Configs Gains for the specified slot. If this slot is selected, these gains are used in closed loop control requests. .. py:attribute:: k_p :type: float :value: '0' Proportional gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input, the units should be defined as units of output per unit of input error. For example, when controlling velocity using a duty cycle closed loop, the units for the proportional gain will be duty cycle per rps, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_i :type: float :value: '0' Integral gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input integrated over time (in units of seconds), the units should be defined as units of output per unit of integrated input error. For example, when controlling velocity using a duty cycle closed loop, integrating velocity over time results in rps * s = rotations. Therefore, the units for the integral gain will be duty cycle per rotation of accumulated error, or 1/rot. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_d :type: float :value: '0' Derivative gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the derivative of error in the input with respect to time (in units of seconds), the units should be defined as units of output per unit of the differentiated input error. For example, when controlling velocity using a duty cycle closed loop, the derivative of velocity with respect to time is rot per sec², which is acceleration. Therefore, the units for the derivative gain will be duty cycle per unit of acceleration error, or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_s :type: float :value: '0' Static feedforward gain. This is added to the closed loop output. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. The sign is typically determined by reference velocity when using position, velocity, and Motion Magic® closed loop modes. However, when using position closed loop with zero velocity reference (no motion profiling), the application can instead use the position closed loop error by setting the Static Feedforward Sign configuration parameter. When doing so, we recommend the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: .. py:attribute:: k_v :type: float :value: '0' Velocity feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested velocity, the units should be defined as units of output per unit of requested input velocity. For example, when controlling velocity using a duty cycle closed loop, the units for the velocity feedfoward gain will be duty cycle per requested rps, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_a :type: float :value: '0' Acceleration feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested acceleration, the units should be defined as units of output per unit of requested input acceleration. For example, when controlling velocity using a duty cycle closed loop, the units for the acceleration feedfoward gain will be duty cycle per requested rot per sec², or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_g :type: float :value: '0' Gravity feedforward/feedback gain. The type of gravity compensation is selected by self.gravity_type. This is added to the closed loop output. The sign is determined by the gravity type. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: .. py:attribute:: gravity_type :type: GravityTypeValue Gravity feedforward/feedback type. This determines the type of the gravity feedforward/feedback. Choose Elevator_Static for systems where the gravity feedforward is constant, such as an elevator. The gravity feedforward output will always be positive. Choose Arm_Cosine for systems where the gravity feedback is dependent on the angular position of the mechanism, such as an arm. The gravity feedback output will vary depending on the mechanism angular position. Note that the sensor offset and ratios must be configured so that the sensor position is 0 when the mechanism is horizonal, and one rotation of the mechanism corresponds to one rotation of the sensor position. .. py:attribute:: static_feedforward_sign :type: StaticFeedforwardSignValue Static feedforward sign during position closed loop. This determines the sign of the applied kS during position closed-loop modes. The default behavior uses the velocity reference sign. This works well with velocity closed loop, Motion Magic® controls, and position closed loop when velocity reference is specified (motion profiling). However, when using position closed loop with zero velocity reference (no motion profiling), the application may want to apply static feedforward based on the closed loop error sign instead. When doing so, we recommend using the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. .. py:attribute:: gravity_arm_position_offset :type: phoenix6.units.rotation :value: '0' Gravity feedback position offset when using the Arm/Cosine gravity type. This is an offset applied to the position of the arm, within (-0.25, 0.25) rot, before calculating the output of kG. This is useful when the center of gravity of the arm is offset from the actual zero point of the arm, such as when the arm and intake form an L shape. - Minimum Value: -0.25 - Maximum Value: 0.25 - Default Value: 0 - Units: rotations .. py:attribute:: gain_sched_behavior :type: GainSchedBehaviorValue The behavior of the gain scheduler on this slot. This specifies which gains to use while within the configured GainSchedErrorThreshold. The default is to continue using the specified slot. Gain scheduling will not take effect when running velocity closed-loop controls. .. py:method:: with_k_p(new_k_p: float) -> Slot2Configs Modifies this configuration's k_p parameter and returns itself for method-chaining and easier to use config API. Proportional gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input, the units should be defined as units of output per unit of input error. For example, when controlling velocity using a duty cycle closed loop, the units for the proportional gain will be duty cycle per rps, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_p: Parameter to modify :type new_k_p: float :returns: Itself :rtype: Slot2Configs .. py:method:: with_k_i(new_k_i: float) -> Slot2Configs Modifies this configuration's k_i parameter and returns itself for method-chaining and easier to use config API. Integral gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input integrated over time (in units of seconds), the units should be defined as units of output per unit of integrated input error. For example, when controlling velocity using a duty cycle closed loop, integrating velocity over time results in rps * s = rotations. Therefore, the units for the integral gain will be duty cycle per rotation of accumulated error, or 1/rot. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_i: Parameter to modify :type new_k_i: float :returns: Itself :rtype: Slot2Configs .. py:method:: with_k_d(new_k_d: float) -> Slot2Configs Modifies this configuration's k_d parameter and returns itself for method-chaining and easier to use config API. Derivative gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the derivative of error in the input with respect to time (in units of seconds), the units should be defined as units of output per unit of the differentiated input error. For example, when controlling velocity using a duty cycle closed loop, the derivative of velocity with respect to time is rot per sec², which is acceleration. Therefore, the units for the derivative gain will be duty cycle per unit of acceleration error, or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_d: Parameter to modify :type new_k_d: float :returns: Itself :rtype: Slot2Configs .. py:method:: with_k_s(new_k_s: float) -> Slot2Configs Modifies this configuration's k_s parameter and returns itself for method-chaining and easier to use config API. Static feedforward gain. This is added to the closed loop output. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. The sign is typically determined by reference velocity when using position, velocity, and Motion Magic® closed loop modes. However, when using position closed loop with zero velocity reference (no motion profiling), the application can instead use the position closed loop error by setting the Static Feedforward Sign configuration parameter. When doing so, we recommend the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: :param new_k_s: Parameter to modify :type new_k_s: float :returns: Itself :rtype: Slot2Configs .. py:method:: with_k_v(new_k_v: float) -> Slot2Configs Modifies this configuration's k_v parameter and returns itself for method-chaining and easier to use config API. Velocity feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested velocity, the units should be defined as units of output per unit of requested input velocity. For example, when controlling velocity using a duty cycle closed loop, the units for the velocity feedfoward gain will be duty cycle per requested rps, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_v: Parameter to modify :type new_k_v: float :returns: Itself :rtype: Slot2Configs .. py:method:: with_k_a(new_k_a: float) -> Slot2Configs Modifies this configuration's k_a parameter and returns itself for method-chaining and easier to use config API. Acceleration feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested acceleration, the units should be defined as units of output per unit of requested input acceleration. For example, when controlling velocity using a duty cycle closed loop, the units for the acceleration feedfoward gain will be duty cycle per requested rot per sec², or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_a: Parameter to modify :type new_k_a: float :returns: Itself :rtype: Slot2Configs .. py:method:: with_k_g(new_k_g: float) -> Slot2Configs Modifies this configuration's k_g parameter and returns itself for method-chaining and easier to use config API. Gravity feedforward/feedback gain. The type of gravity compensation is selected by self.gravity_type. This is added to the closed loop output. The sign is determined by the gravity type. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: :param new_k_g: Parameter to modify :type new_k_g: float :returns: Itself :rtype: Slot2Configs .. py:method:: with_gravity_type(new_gravity_type: GravityTypeValue) -> Slot2Configs Modifies this configuration's gravity_type parameter and returns itself for method-chaining and easier to use config API. Gravity feedforward/feedback type. This determines the type of the gravity feedforward/feedback. Choose Elevator_Static for systems where the gravity feedforward is constant, such as an elevator. The gravity feedforward output will always be positive. Choose Arm_Cosine for systems where the gravity feedback is dependent on the angular position of the mechanism, such as an arm. The gravity feedback output will vary depending on the mechanism angular position. Note that the sensor offset and ratios must be configured so that the sensor position is 0 when the mechanism is horizonal, and one rotation of the mechanism corresponds to one rotation of the sensor position. :param new_gravity_type: Parameter to modify :type new_gravity_type: GravityTypeValue :returns: Itself :rtype: Slot2Configs .. py:method:: with_static_feedforward_sign(new_static_feedforward_sign: StaticFeedforwardSignValue) -> Slot2Configs Modifies this configuration's static_feedforward_sign parameter and returns itself for method-chaining and easier to use config API. Static feedforward sign during position closed loop. This determines the sign of the applied kS during position closed-loop modes. The default behavior uses the velocity reference sign. This works well with velocity closed loop, Motion Magic® controls, and position closed loop when velocity reference is specified (motion profiling). However, when using position closed loop with zero velocity reference (no motion profiling), the application may want to apply static feedforward based on the closed loop error sign instead. When doing so, we recommend using the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. :param new_static_feedforward_sign: Parameter to modify :type new_static_feedforward_sign: StaticFeedforwardSignValue :returns: Itself :rtype: Slot2Configs .. py:method:: with_gravity_arm_position_offset(new_gravity_arm_position_offset: phoenix6.units.rotation) -> Slot2Configs Modifies this configuration's gravity_arm_position_offset parameter and returns itself for method-chaining and easier to use config API. Gravity feedback position offset when using the Arm/Cosine gravity type. This is an offset applied to the position of the arm, within (-0.25, 0.25) rot, before calculating the output of kG. This is useful when the center of gravity of the arm is offset from the actual zero point of the arm, such as when the arm and intake form an L shape. - Minimum Value: -0.25 - Maximum Value: 0.25 - Default Value: 0 - Units: rotations :param new_gravity_arm_position_offset: Parameter to modify :type new_gravity_arm_position_offset: rotation :returns: Itself :rtype: Slot2Configs .. py:method:: with_gain_sched_behavior(new_gain_sched_behavior: GainSchedBehaviorValue) -> Slot2Configs Modifies this configuration's gain_sched_behavior parameter and returns itself for method-chaining and easier to use config API. The behavior of the gain scheduler on this slot. This specifies which gains to use while within the configured GainSchedErrorThreshold. The default is to continue using the specified slot. Gain scheduling will not take effect when running velocity closed-loop controls. :param new_gain_sched_behavior: Parameter to modify :type new_gain_sched_behavior: GainSchedBehaviorValue :returns: Itself :rtype: Slot2Configs .. py:method:: from_other(value) -> Slot2Configs :classmethod: .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:class:: SlotConfigs Gains for the specified slot. If this slot is selected, these gains are used in closed loop control requests. .. py:attribute:: slot_number :value: '0' Chooses which slot these configs are for. .. py:attribute:: k_p :type: float :value: '0' Proportional gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input, the units should be defined as units of output per unit of input error. For example, when controlling velocity using a duty cycle closed loop, the units for the proportional gain will be duty cycle per rps of error, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_i :type: float :value: '0' Integral gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input integrated over time (in units of seconds), the units should be defined as units of output per unit of integrated input error. For example, when controlling velocity using a duty cycle closed loop, integrating velocity over time results in rps * s = rotations. Therefore, the units for the integral gain will be duty cycle per rotation of accumulated error, or 1/rot. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_d :type: float :value: '0' Derivative gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the derivative of error in the input with respect to time (in units of seconds), the units should be defined as units of output per unit of the differentiated input error. For example, when controlling velocity using a duty cycle closed loop, the derivative of velocity with respect to time is rot per sec², which is acceleration. Therefore, the units for the derivative gain will be duty cycle per unit of acceleration error, or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_s :type: float :value: '0' Static feedforward gain. This is added to the closed loop output. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. The sign is typically determined by reference velocity when using position, velocity, and Motion Magic® closed loop modes. However, when using position closed loop with zero velocity reference (no motion profiling), the application can instead use the position closed loop error by setting the Static Feedforward Sign configuration parameter. When doing so, we recommend the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: .. py:attribute:: k_v :type: float :value: '0' Velocity feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested velocity, the units should be defined as units of output per unit of requested input velocity. For example, when controlling velocity using a duty cycle closed loop, the units for the velocity feedfoward gain will be duty cycle per requested rps, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_a :type: float :value: '0' Acceleration feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested acceleration, the units should be defined as units of output per unit of requested input acceleration. For example, when controlling velocity using a duty cycle closed loop, the units for the acceleration feedfoward gain will be duty cycle per requested rot per sec², or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: .. py:attribute:: k_g :type: float :value: '0' Gravity feedforward/feedback gain. The type of gravity compensation is selected by self.gravity_type. This is added to the closed loop output. The sign is determined by the gravity type. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: .. py:attribute:: gravity_type :type: GravityTypeValue Gravity feedforward/feedback type. This determines the type of the gravity feedforward/feedback. Choose Elevator_Static for systems where the gravity feedforward is constant, such as an elevator. The gravity feedforward output will always have the same sign. Choose Arm_Cosine for systems where the gravity feedback is dependent on the angular position of the mechanism, such as an arm. The gravity feedback output will vary depending on the mechanism angular position. Note that the sensor offset and ratios must be configured so that the sensor reports a position of 0 when the mechanism is horizonal (parallel to the ground), and the reported sensor position is 1:1 with the mechanism. .. py:attribute:: static_feedforward_sign :type: StaticFeedforwardSignValue Static feedforward sign during position closed loop. This determines the sign of the applied kS during position closed-loop modes. The default behavior uses the velocity reference sign. This works well with velocity closed loop, Motion Magic® controls, and position closed loop when velocity reference is specified (motion profiling). However, when using position closed loop with zero velocity reference (no motion profiling), the application may want to apply static feedforward based on the sign of closed loop error instead. When doing so, we recommend using the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. .. py:attribute:: gravity_arm_position_offset :type: phoenix6.units.rotation :value: '0' Gravity feedback position offset when using the Arm/Cosine gravity type. This is an offset applied to the position of the arm, within (-0.25, 0.25) rot, before calculating the output of kG. This is useful when the center of gravity of the arm is offset from the actual zero point of the arm, such as when the arm and intake form an L shape. - Minimum Value: -0.25 - Maximum Value: 0.25 - Default Value: 0 - Units: rotations .. py:attribute:: gain_sched_behavior :type: GainSchedBehaviorValue The behavior of the gain scheduler on this slot. This specifies which gains to use while within the configured GainSchedErrorThreshold. The default is to continue using the specified slot. Gain scheduling will not take effect when running velocity closed-loop controls. .. py:method:: with_k_p(new_k_p: float) -> SlotConfigs Modifies this configuration's k_p parameter and returns itself for method-chaining and easier to use config API. Proportional gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input, the units should be defined as units of output per unit of input error. For example, when controlling velocity using a duty cycle closed loop, the units for the proportional gain will be duty cycle per rps of error, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_p: Parameter to modify :type new_k_p: float :returns: Itself :rtype: SlotConfigs .. py:method:: with_k_i(new_k_i: float) -> SlotConfigs Modifies this configuration's k_i parameter and returns itself for method-chaining and easier to use config API. Integral gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by error in the input integrated over time (in units of seconds), the units should be defined as units of output per unit of integrated input error. For example, when controlling velocity using a duty cycle closed loop, integrating velocity over time results in rps * s = rotations. Therefore, the units for the integral gain will be duty cycle per rotation of accumulated error, or 1/rot. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_i: Parameter to modify :type new_k_i: float :returns: Itself :rtype: SlotConfigs .. py:method:: with_k_d(new_k_d: float) -> SlotConfigs Modifies this configuration's k_d parameter and returns itself for method-chaining and easier to use config API. Derivative gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the derivative of error in the input with respect to time (in units of seconds), the units should be defined as units of output per unit of the differentiated input error. For example, when controlling velocity using a duty cycle closed loop, the derivative of velocity with respect to time is rot per sec², which is acceleration. Therefore, the units for the derivative gain will be duty cycle per unit of acceleration error, or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_d: Parameter to modify :type new_k_d: float :returns: Itself :rtype: SlotConfigs .. py:method:: with_k_s(new_k_s: float) -> SlotConfigs Modifies this configuration's k_s parameter and returns itself for method-chaining and easier to use config API. Static feedforward gain. This is added to the closed loop output. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. The sign is typically determined by reference velocity when using position, velocity, and Motion Magic® closed loop modes. However, when using position closed loop with zero velocity reference (no motion profiling), the application can instead use the position closed loop error by setting the Static Feedforward Sign configuration parameter. When doing so, we recommend the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: :param new_k_s: Parameter to modify :type new_k_s: float :returns: Itself :rtype: SlotConfigs .. py:method:: with_k_v(new_k_v: float) -> SlotConfigs Modifies this configuration's k_v parameter and returns itself for method-chaining and easier to use config API. Velocity feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested velocity, the units should be defined as units of output per unit of requested input velocity. For example, when controlling velocity using a duty cycle closed loop, the units for the velocity feedfoward gain will be duty cycle per requested rps, or 1/rps. - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_v: Parameter to modify :type new_k_v: float :returns: Itself :rtype: SlotConfigs .. py:method:: with_k_a(new_k_a: float) -> SlotConfigs Modifies this configuration's k_a parameter and returns itself for method-chaining and easier to use config API. Acceleration feedforward gain. The units for this gain is dependent on the control mode. Since this gain is multiplied by the requested acceleration, the units should be defined as units of output per unit of requested input acceleration. For example, when controlling velocity using a duty cycle closed loop, the units for the acceleration feedfoward gain will be duty cycle per requested rot per sec², or 1/(rot per sec²). - Minimum Value: 0 - Maximum Value: 3.4e+38 - Default Value: 0 - Units: :param new_k_a: Parameter to modify :type new_k_a: float :returns: Itself :rtype: SlotConfigs .. py:method:: with_k_g(new_k_g: float) -> SlotConfigs Modifies this configuration's k_g parameter and returns itself for method-chaining and easier to use config API. Gravity feedforward/feedback gain. The type of gravity compensation is selected by self.gravity_type. This is added to the closed loop output. The sign is determined by the gravity type. The unit for this constant is dependent on the control mode, typically fractional duty cycle, voltage, or torque current. - Minimum Value: -128 - Maximum Value: 127 - Default Value: 0 - Units: :param new_k_g: Parameter to modify :type new_k_g: float :returns: Itself :rtype: SlotConfigs .. py:method:: with_gravity_type(new_gravity_type: GravityTypeValue) -> SlotConfigs Modifies this configuration's gravity_type parameter and returns itself for method-chaining and easier to use config API. Gravity feedforward/feedback type. This determines the type of the gravity feedforward/feedback. Choose Elevator_Static for systems where the gravity feedforward is constant, such as an elevator. The gravity feedforward output will always have the same sign. Choose Arm_Cosine for systems where the gravity feedback is dependent on the angular position of the mechanism, such as an arm. The gravity feedback output will vary depending on the mechanism angular position. Note that the sensor offset and ratios must be configured so that the sensor reports a position of 0 when the mechanism is horizonal (parallel to the ground), and the reported sensor position is 1:1 with the mechanism. :param new_gravity_type: Parameter to modify :type new_gravity_type: GravityTypeValue :returns: Itself :rtype: SlotConfigs .. py:method:: with_static_feedforward_sign(new_static_feedforward_sign: StaticFeedforwardSignValue) -> SlotConfigs Modifies this configuration's static_feedforward_sign parameter and returns itself for method-chaining and easier to use config API. Static feedforward sign during position closed loop. This determines the sign of the applied kS during position closed-loop modes. The default behavior uses the velocity reference sign. This works well with velocity closed loop, Motion Magic® controls, and position closed loop when velocity reference is specified (motion profiling). However, when using position closed loop with zero velocity reference (no motion profiling), the application may want to apply static feedforward based on the sign of closed loop error instead. When doing so, we recommend using the minimal amount of kS, otherwise the motor output may dither when closed loop error is near zero. :param new_static_feedforward_sign: Parameter to modify :type new_static_feedforward_sign: StaticFeedforwardSignValue :returns: Itself :rtype: SlotConfigs .. py:method:: with_gravity_arm_position_offset(new_gravity_arm_position_offset: phoenix6.units.rotation) -> SlotConfigs Modifies this configuration's gravity_arm_position_offset parameter and returns itself for method-chaining and easier to use config API. Gravity feedback position offset when using the Arm/Cosine gravity type. This is an offset applied to the position of the arm, within (-0.25, 0.25) rot, before calculating the output of kG. This is useful when the center of gravity of the arm is offset from the actual zero point of the arm, such as when the arm and intake form an L shape. - Minimum Value: -0.25 - Maximum Value: 0.25 - Default Value: 0 - Units: rotations :param new_gravity_arm_position_offset: Parameter to modify :type new_gravity_arm_position_offset: rotation :returns: Itself :rtype: SlotConfigs .. py:method:: with_gain_sched_behavior(new_gain_sched_behavior: GainSchedBehaviorValue) -> SlotConfigs Modifies this configuration's gain_sched_behavior parameter and returns itself for method-chaining and easier to use config API. The behavior of the gain scheduler on this slot. This specifies which gains to use while within the configured GainSchedErrorThreshold. The default is to continue using the specified slot. Gain scheduling will not take effect when running velocity closed-loop controls. :param new_gain_sched_behavior: Parameter to modify :type new_gain_sched_behavior: GainSchedBehaviorValue :returns: Itself :rtype: SlotConfigs .. py:method:: serialize() -> str Serialize this object into a string :returns: This object's data serialized into a string :rtype: str .. py:method:: deserialize(to_deserialize: str) -> phoenix6.status_code.StatusCode Deserialize string and put values into this object :param to_deserialize: String to deserialize :type to_deserialize: str :returns: OK if deserialization is OK :rtype: StatusCode .. py:method:: from_other(value) -> SlotConfigs :classmethod: Converts the provided value to an instance of this type. :param value: The value to convert :returns: Converted value :rtype: SlotConfigs