:py:mod:`phoenix6.controls.compound` ==================================== .. py:module:: phoenix6.controls.compound Submodules ---------- .. toctree:: :titlesonly: :maxdepth: 1 diff_duty_cycle_out_open/index.rst diff_duty_cycle_out_position/index.rst diff_duty_cycle_out_velocity/index.rst diff_motion_magic_duty_cycle_open/index.rst diff_motion_magic_duty_cycle_position/index.rst diff_motion_magic_duty_cycle_velocity/index.rst diff_motion_magic_expo_duty_cycle_open/index.rst diff_motion_magic_expo_duty_cycle_position/index.rst diff_motion_magic_expo_duty_cycle_velocity/index.rst diff_motion_magic_expo_torque_current_foc_open/index.rst diff_motion_magic_expo_torque_current_foc_position/index.rst diff_motion_magic_expo_torque_current_foc_velocity/index.rst diff_motion_magic_expo_voltage_open/index.rst diff_motion_magic_expo_voltage_position/index.rst diff_motion_magic_expo_voltage_velocity/index.rst diff_motion_magic_torque_current_foc_open/index.rst diff_motion_magic_torque_current_foc_position/index.rst diff_motion_magic_torque_current_foc_velocity/index.rst diff_motion_magic_velocity_duty_cycle_open/index.rst diff_motion_magic_velocity_duty_cycle_position/index.rst diff_motion_magic_velocity_duty_cycle_velocity/index.rst diff_motion_magic_velocity_torque_current_foc_open/index.rst diff_motion_magic_velocity_torque_current_foc_position/index.rst diff_motion_magic_velocity_torque_current_foc_velocity/index.rst diff_motion_magic_velocity_voltage_open/index.rst diff_motion_magic_velocity_voltage_position/index.rst diff_motion_magic_velocity_voltage_velocity/index.rst diff_motion_magic_voltage_open/index.rst diff_motion_magic_voltage_position/index.rst diff_motion_magic_voltage_velocity/index.rst diff_position_duty_cycle_open/index.rst diff_position_duty_cycle_position/index.rst diff_position_duty_cycle_velocity/index.rst diff_position_torque_current_foc_open/index.rst diff_position_torque_current_foc_position/index.rst diff_position_torque_current_foc_velocity/index.rst diff_position_voltage_open/index.rst diff_position_voltage_position/index.rst diff_position_voltage_velocity/index.rst diff_torque_current_foc_open/index.rst diff_torque_current_foc_position/index.rst diff_torque_current_foc_velocity/index.rst diff_velocity_duty_cycle_open/index.rst diff_velocity_duty_cycle_position/index.rst diff_velocity_duty_cycle_velocity/index.rst diff_velocity_torque_current_foc_open/index.rst diff_velocity_torque_current_foc_position/index.rst diff_velocity_torque_current_foc_velocity/index.rst diff_velocity_voltage_open/index.rst diff_velocity_voltage_position/index.rst diff_velocity_voltage_velocity/index.rst diff_voltage_out_open/index.rst diff_voltage_out_position/index.rst diff_voltage_out_velocity/index.rst Package Contents ---------------- .. py:class:: Diff_DutyCycleOut_Position(average_request: phoenix6.controls.duty_cycle_out.DutyCycleOut, differential_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) Requires Phoenix Pro and CANivore; Differential control with duty cycle average target and position difference target. :param average_request: Average DutyCycleOut request of the mechanism. :type average_request: DutyCycleOut :param differential_request: Differential PositionDutyCycle request of the mechanism. :type differential_request: PositionDutyCycle .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average DutyCycleOut request of the mechanism. .. py:attribute:: differential_request Differential PositionDutyCycle request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) -> Diff_DutyCycleOut_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average DutyCycleOut request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: DutyCycleOut :returns: Itself :rtype: Diff_DutyCycleOut_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) -> Diff_DutyCycleOut_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionDutyCycle request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionDutyCycle :returns: Itself :rtype: Diff_DutyCycleOut_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_DutyCycleOut_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_DutyCycleOut_Position .. py:class:: Diff_PositionDutyCycle_Position(average_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle, differential_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) Requires Phoenix Pro and CANivore; Differential control with position average target and position difference target using duty cycle control. :param average_request: Average PositionDutyCycle request of the mechanism. :type average_request: PositionDutyCycle :param differential_request: Differential PositionDutyCycle request of the mechanism. :type differential_request: PositionDutyCycle .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average PositionDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential PositionDutyCycle request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) -> Diff_PositionDutyCycle_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average PositionDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: PositionDutyCycle :returns: Itself :rtype: Diff_PositionDutyCycle_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) -> Diff_PositionDutyCycle_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionDutyCycle request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionDutyCycle :returns: Itself :rtype: Diff_PositionDutyCycle_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_PositionDutyCycle_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_PositionDutyCycle_Position .. py:class:: Diff_VelocityDutyCycle_Position(average_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle, differential_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) Requires Phoenix Pro and CANivore; Differential control with velocity average target and position difference target using duty cycle control. :param average_request: Average VelocityDutyCYcle request of the mechanism. :type average_request: VelocityDutyCycle :param differential_request: Differential PositionDutyCycle request of the mechanism. :type differential_request: PositionDutyCycle .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average VelocityDutyCYcle request of the mechanism. .. py:attribute:: differential_request Differential PositionDutyCycle request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) -> Diff_VelocityDutyCycle_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average VelocityDutyCYcle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: VelocityDutyCycle :returns: Itself :rtype: Diff_VelocityDutyCycle_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) -> Diff_VelocityDutyCycle_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionDutyCycle request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionDutyCycle :returns: Itself :rtype: Diff_VelocityDutyCycle_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_VelocityDutyCycle_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_VelocityDutyCycle_Position .. py:class:: Diff_MotionMagicDutyCycle_Position(average_request: phoenix6.controls.motion_magic_duty_cycle.MotionMagicDutyCycle, differential_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® average target and position difference target using duty cycle control. :param average_request: Average MotionMagicDutyCycle request of the mechanism. :type average_request: MotionMagicDutyCycle :param differential_request: Differential PositionDutyCycle request of the mechanism. :type differential_request: PositionDutyCycle .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential PositionDutyCycle request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_duty_cycle.MotionMagicDutyCycle) -> Diff_MotionMagicDutyCycle_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicDutyCycle :returns: Itself :rtype: Diff_MotionMagicDutyCycle_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) -> Diff_MotionMagicDutyCycle_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionDutyCycle request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionDutyCycle :returns: Itself :rtype: Diff_MotionMagicDutyCycle_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicDutyCycle_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicDutyCycle_Position .. py:class:: Diff_MotionMagicExpoDutyCycle_Position(average_request: phoenix6.controls.motion_magic_expo_duty_cycle.MotionMagicExpoDutyCycle, differential_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Expo average target and position difference target using duty cycle control. :param average_request: Average MotionMagicExpoDutyCycle request of the mechanism. :type average_request: MotionMagicExpoDutyCycle :param differential_request: Differential PositionDutyCycle request of the mechanism. :type differential_request: PositionDutyCycle .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicExpoDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential PositionDutyCycle request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_expo_duty_cycle.MotionMagicExpoDutyCycle) -> Diff_MotionMagicExpoDutyCycle_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicExpoDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicExpoDutyCycle :returns: Itself :rtype: Diff_MotionMagicExpoDutyCycle_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) -> Diff_MotionMagicExpoDutyCycle_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionDutyCycle request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionDutyCycle :returns: Itself :rtype: Diff_MotionMagicExpoDutyCycle_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicExpoDutyCycle_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicExpoDutyCycle_Position .. py:class:: Diff_MotionMagicVelocityDutyCycle_Position(average_request: phoenix6.controls.motion_magic_velocity_duty_cycle.MotionMagicVelocityDutyCycle, differential_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Velocity average target and position difference target using duty cycle control. :param average_request: Average MotionMagicVelocityDutyCycle request of the mechanism. :type average_request: MotionMagicVelocityDutyCycle :param differential_request: Differential PositionDutyCycle request of the mechanism. :type differential_request: PositionDutyCycle .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicVelocityDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential PositionDutyCycle request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_velocity_duty_cycle.MotionMagicVelocityDutyCycle) -> Diff_MotionMagicVelocityDutyCycle_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicVelocityDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicVelocityDutyCycle :returns: Itself :rtype: Diff_MotionMagicVelocityDutyCycle_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) -> Diff_MotionMagicVelocityDutyCycle_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionDutyCycle request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionDutyCycle :returns: Itself :rtype: Diff_MotionMagicVelocityDutyCycle_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicVelocityDutyCycle_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicVelocityDutyCycle_Position .. py:class:: Diff_DutyCycleOut_Velocity(average_request: phoenix6.controls.duty_cycle_out.DutyCycleOut, differential_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) Requires Phoenix Pro and CANivore; Differential control with duty cycle average target and velocity difference target. :param average_request: Average DutyCycleOut request of the mechanism. :type average_request: DutyCycleOut :param differential_request: Differential VelocityDutyCycle request of the mechanism. :type differential_request: VelocityDutyCycle .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average DutyCycleOut request of the mechanism. .. py:attribute:: differential_request Differential VelocityDutyCycle request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) -> Diff_DutyCycleOut_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average DutyCycleOut request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: DutyCycleOut :returns: Itself :rtype: Diff_DutyCycleOut_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) -> Diff_DutyCycleOut_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityDutyCycle request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityDutyCycle :returns: Itself :rtype: Diff_DutyCycleOut_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_DutyCycleOut_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_DutyCycleOut_Velocity .. py:class:: Diff_PositionDutyCycle_Velocity(average_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle, differential_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) Requires Phoenix Pro and CANivore; Differential control with position average target and velocity difference target using duty cycle control. :param average_request: Average PositionDutyCycle request of the mechanism. :type average_request: PositionDutyCycle :param differential_request: Differential VelocityDutyCycle request of the mechanism. :type differential_request: VelocityDutyCycle .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average PositionDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential VelocityDutyCycle request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) -> Diff_PositionDutyCycle_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average PositionDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: PositionDutyCycle :returns: Itself :rtype: Diff_PositionDutyCycle_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) -> Diff_PositionDutyCycle_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityDutyCycle request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityDutyCycle :returns: Itself :rtype: Diff_PositionDutyCycle_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_PositionDutyCycle_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_PositionDutyCycle_Velocity .. py:class:: Diff_VelocityDutyCycle_Velocity(average_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle, differential_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) Requires Phoenix Pro and CANivore; Differential control with velocity average target and velocity difference target using duty cycle control. :param average_request: Average VelocityDutyCycle request of the mechanism. :type average_request: VelocityDutyCycle :param differential_request: Differential VelocityDutyCycle request of the mechanism. :type differential_request: VelocityDutyCycle .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average VelocityDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential VelocityDutyCycle request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) -> Diff_VelocityDutyCycle_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average VelocityDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: VelocityDutyCycle :returns: Itself :rtype: Diff_VelocityDutyCycle_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) -> Diff_VelocityDutyCycle_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityDutyCycle request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityDutyCycle :returns: Itself :rtype: Diff_VelocityDutyCycle_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_VelocityDutyCycle_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_VelocityDutyCycle_Velocity .. py:class:: Diff_MotionMagicDutyCycle_Velocity(average_request: phoenix6.controls.motion_magic_duty_cycle.MotionMagicDutyCycle, differential_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® average target and velocity difference target using duty cycle control. :param average_request: Average MotionMagicDutyCycle request of the mechanism. :type average_request: MotionMagicDutyCycle :param differential_request: Differential VelocityDutyCycle request of the mechanism. :type differential_request: VelocityDutyCycle .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential VelocityDutyCycle request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_duty_cycle.MotionMagicDutyCycle) -> Diff_MotionMagicDutyCycle_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicDutyCycle :returns: Itself :rtype: Diff_MotionMagicDutyCycle_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) -> Diff_MotionMagicDutyCycle_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityDutyCycle request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityDutyCycle :returns: Itself :rtype: Diff_MotionMagicDutyCycle_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicDutyCycle_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicDutyCycle_Velocity .. py:class:: Diff_MotionMagicExpoDutyCycle_Velocity(average_request: phoenix6.controls.motion_magic_expo_duty_cycle.MotionMagicExpoDutyCycle, differential_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Expo average target and velocity difference target using duty cycle control. :param average_request: Average MotionMagicExpoDutyCycle request of the mechanism. :type average_request: MotionMagicExpoDutyCycle :param differential_request: Differential VelocityDutyCycle request of the mechanism. :type differential_request: VelocityDutyCycle .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicExpoDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential VelocityDutyCycle request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_expo_duty_cycle.MotionMagicExpoDutyCycle) -> Diff_MotionMagicExpoDutyCycle_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicExpoDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicExpoDutyCycle :returns: Itself :rtype: Diff_MotionMagicExpoDutyCycle_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) -> Diff_MotionMagicExpoDutyCycle_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityDutyCycle request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityDutyCycle :returns: Itself :rtype: Diff_MotionMagicExpoDutyCycle_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicExpoDutyCycle_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicExpoDutyCycle_Velocity .. py:class:: Diff_MotionMagicVelocityDutyCycle_Velocity(average_request: phoenix6.controls.motion_magic_velocity_duty_cycle.MotionMagicVelocityDutyCycle, differential_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Velocity average target and velocity difference target using duty cycle control. :param average_request: Average MotionMagicVelocityDutyCycle request of the mechanism. :type average_request: MotionMagicVelocityDutyCycle :param differential_request: Differential VelocityDutyCycle request of the mechanism. :type differential_request: VelocityDutyCycle .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicVelocityDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential VelocityDutyCycle request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_velocity_duty_cycle.MotionMagicVelocityDutyCycle) -> Diff_MotionMagicVelocityDutyCycle_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicVelocityDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicVelocityDutyCycle :returns: Itself :rtype: Diff_MotionMagicVelocityDutyCycle_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) -> Diff_MotionMagicVelocityDutyCycle_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityDutyCycle request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityDutyCycle :returns: Itself :rtype: Diff_MotionMagicVelocityDutyCycle_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicVelocityDutyCycle_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicVelocityDutyCycle_Velocity .. py:class:: Diff_DutyCycleOut_Open(average_request: phoenix6.controls.duty_cycle_out.DutyCycleOut, differential_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) Requires Phoenix Pro and CANivore; Differential control with duty cycle average target and duty cycle difference target. :param average_request: Average DutyCycleOut request of the mechanism. :type average_request: DutyCycleOut :param differential_request: Differential DutyCycleOut request of the mechanism. :type differential_request: DutyCycleOut .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average DutyCycleOut request of the mechanism. .. py:attribute:: differential_request Differential DutyCycleOut request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) -> Diff_DutyCycleOut_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average DutyCycleOut request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: DutyCycleOut :returns: Itself :rtype: Diff_DutyCycleOut_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) -> Diff_DutyCycleOut_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential DutyCycleOut request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: DutyCycleOut :returns: Itself :rtype: Diff_DutyCycleOut_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_DutyCycleOut_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_DutyCycleOut_Open .. py:class:: Diff_PositionDutyCycle_Open(average_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle, differential_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) Requires Phoenix Pro and CANivore; Differential control with position average target and duty cycle difference target. :param average_request: Average PositionDutyCycle request of the mechanism. :type average_request: PositionDutyCycle :param differential_request: Differential DutyCycleOut request of the mechanism. :type differential_request: DutyCycleOut .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average PositionDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential DutyCycleOut request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.position_duty_cycle.PositionDutyCycle) -> Diff_PositionDutyCycle_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average PositionDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: PositionDutyCycle :returns: Itself :rtype: Diff_PositionDutyCycle_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) -> Diff_PositionDutyCycle_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential DutyCycleOut request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: DutyCycleOut :returns: Itself :rtype: Diff_PositionDutyCycle_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_PositionDutyCycle_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_PositionDutyCycle_Open .. py:class:: Diff_VelocityDutyCycle_Open(average_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle, differential_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) Requires Phoenix Pro and CANivore; Differential control with velocity average target and duty cycle difference target. :param average_request: Average VelocityDutyCYcle request of the mechanism. :type average_request: VelocityDutyCycle :param differential_request: Differential DutyCycleOut request of the mechanism. :type differential_request: DutyCycleOut .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average VelocityDutyCYcle request of the mechanism. .. py:attribute:: differential_request Differential DutyCycleOut request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.velocity_duty_cycle.VelocityDutyCycle) -> Diff_VelocityDutyCycle_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average VelocityDutyCYcle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: VelocityDutyCycle :returns: Itself :rtype: Diff_VelocityDutyCycle_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) -> Diff_VelocityDutyCycle_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential DutyCycleOut request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: DutyCycleOut :returns: Itself :rtype: Diff_VelocityDutyCycle_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_VelocityDutyCycle_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_VelocityDutyCycle_Open .. py:class:: Diff_MotionMagicDutyCycle_Open(average_request: phoenix6.controls.motion_magic_duty_cycle.MotionMagicDutyCycle, differential_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® average target and duty cycle difference target. :param average_request: Average MotionMagicDutyCycle request of the mechanism. :type average_request: MotionMagicDutyCycle :param differential_request: Differential DutyCycleOut request of the mechanism. :type differential_request: DutyCycleOut .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential DutyCycleOut request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_duty_cycle.MotionMagicDutyCycle) -> Diff_MotionMagicDutyCycle_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicDutyCycle :returns: Itself :rtype: Diff_MotionMagicDutyCycle_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) -> Diff_MotionMagicDutyCycle_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential DutyCycleOut request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: DutyCycleOut :returns: Itself :rtype: Diff_MotionMagicDutyCycle_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicDutyCycle_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicDutyCycle_Open .. py:class:: Diff_MotionMagicExpoDutyCycle_Open(average_request: phoenix6.controls.motion_magic_expo_duty_cycle.MotionMagicExpoDutyCycle, differential_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Expo average target and duty cycle difference target. :param average_request: Average MotionMagicExpoDutyCycle request of the mechanism. :type average_request: MotionMagicExpoDutyCycle :param differential_request: Differential DutyCycleOut request of the mechanism. :type differential_request: DutyCycleOut .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicExpoDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential DutyCycleOut request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_expo_duty_cycle.MotionMagicExpoDutyCycle) -> Diff_MotionMagicExpoDutyCycle_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicExpoDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicExpoDutyCycle :returns: Itself :rtype: Diff_MotionMagicExpoDutyCycle_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) -> Diff_MotionMagicExpoDutyCycle_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential DutyCycleOut request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: DutyCycleOut :returns: Itself :rtype: Diff_MotionMagicExpoDutyCycle_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicExpoDutyCycle_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicExpoDutyCycle_Open .. py:class:: Diff_MotionMagicVelocityDutyCycle_Open(average_request: phoenix6.controls.motion_magic_velocity_duty_cycle.MotionMagicVelocityDutyCycle, differential_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Velocity average target and duty cycle difference target. :param average_request: Average MotionMagicVelocityDutyCycle request of the mechanism. :type average_request: MotionMagicVelocityDutyCycle :param differential_request: Differential DutyCycleOut request of the mechanism. :type differential_request: DutyCycleOut .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicVelocityDutyCycle request of the mechanism. .. py:attribute:: differential_request Differential DutyCycleOut request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_velocity_duty_cycle.MotionMagicVelocityDutyCycle) -> Diff_MotionMagicVelocityDutyCycle_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicVelocityDutyCycle request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicVelocityDutyCycle :returns: Itself :rtype: Diff_MotionMagicVelocityDutyCycle_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.duty_cycle_out.DutyCycleOut) -> Diff_MotionMagicVelocityDutyCycle_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential DutyCycleOut request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: DutyCycleOut :returns: Itself :rtype: Diff_MotionMagicVelocityDutyCycle_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicVelocityDutyCycle_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicVelocityDutyCycle_Open .. py:class:: Diff_VoltageOut_Position(average_request: phoenix6.controls.voltage_out.VoltageOut, differential_request: phoenix6.controls.position_voltage.PositionVoltage) Requires Phoenix Pro and CANivore; Differential control with voltage average target and position difference target. :param average_request: Average VoltageOut request of the mechanism. :type average_request: VoltageOut :param differential_request: Differential PositionVoltage request of the mechanism. :type differential_request: PositionVoltage .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average VoltageOut request of the mechanism. .. py:attribute:: differential_request Differential PositionVoltage request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.voltage_out.VoltageOut) -> Diff_VoltageOut_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average VoltageOut request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: VoltageOut :returns: Itself :rtype: Diff_VoltageOut_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_voltage.PositionVoltage) -> Diff_VoltageOut_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionVoltage request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionVoltage :returns: Itself :rtype: Diff_VoltageOut_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_VoltageOut_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_VoltageOut_Position .. py:class:: Diff_PositionVoltage_Position(average_request: phoenix6.controls.position_voltage.PositionVoltage, differential_request: phoenix6.controls.position_voltage.PositionVoltage) Requires Phoenix Pro and CANivore; Differential control with position average target and position difference target using voltage control. :param average_request: Average PositionVoltage request of the mechanism. :type average_request: PositionVoltage :param differential_request: Differential PositionVoltage request of the mechanism. :type differential_request: PositionVoltage .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average PositionVoltage request of the mechanism. .. py:attribute:: differential_request Differential PositionVoltage request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.position_voltage.PositionVoltage) -> Diff_PositionVoltage_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average PositionVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: PositionVoltage :returns: Itself :rtype: Diff_PositionVoltage_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_voltage.PositionVoltage) -> Diff_PositionVoltage_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionVoltage request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionVoltage :returns: Itself :rtype: Diff_PositionVoltage_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_PositionVoltage_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_PositionVoltage_Position .. py:class:: Diff_VelocityVoltage_Position(average_request: phoenix6.controls.velocity_voltage.VelocityVoltage, differential_request: phoenix6.controls.position_voltage.PositionVoltage) Requires Phoenix Pro and CANivore; Differential control with velocity average target and position difference target using voltage control. :param average_request: Average VelocityVoltage request of the mechanism. :type average_request: VelocityVoltage :param differential_request: Differential PositionVoltage request of the mechanism. :type differential_request: PositionVoltage .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average VelocityVoltage request of the mechanism. .. py:attribute:: differential_request Differential PositionVoltage request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.velocity_voltage.VelocityVoltage) -> Diff_VelocityVoltage_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average VelocityVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: VelocityVoltage :returns: Itself :rtype: Diff_VelocityVoltage_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_voltage.PositionVoltage) -> Diff_VelocityVoltage_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionVoltage request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionVoltage :returns: Itself :rtype: Diff_VelocityVoltage_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_VelocityVoltage_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_VelocityVoltage_Position .. py:class:: Diff_MotionMagicVoltage_Position(average_request: phoenix6.controls.motion_magic_voltage.MotionMagicVoltage, differential_request: phoenix6.controls.position_voltage.PositionVoltage) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® average target and position difference target using voltage control. :param average_request: Average MotionMagicVoltage request of the mechanism. :type average_request: MotionMagicVoltage :param differential_request: Differential PositionVoltage request of the mechanism. :type differential_request: PositionVoltage .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicVoltage request of the mechanism. .. py:attribute:: differential_request Differential PositionVoltage request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_voltage.MotionMagicVoltage) -> Diff_MotionMagicVoltage_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicVoltage :returns: Itself :rtype: Diff_MotionMagicVoltage_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_voltage.PositionVoltage) -> Diff_MotionMagicVoltage_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionVoltage request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionVoltage :returns: Itself :rtype: Diff_MotionMagicVoltage_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicVoltage_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicVoltage_Position .. py:class:: Diff_MotionMagicExpoVoltage_Position(average_request: phoenix6.controls.motion_magic_expo_voltage.MotionMagicExpoVoltage, differential_request: phoenix6.controls.position_voltage.PositionVoltage) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Expo average target and position difference target using voltage control. :param average_request: Average MotionMagicExpoVoltage request of the mechanism. :type average_request: MotionMagicExpoVoltage :param differential_request: Differential PositionVoltage request of the mechanism. :type differential_request: PositionVoltage .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicExpoVoltage request of the mechanism. .. py:attribute:: differential_request Differential PositionVoltage request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_expo_voltage.MotionMagicExpoVoltage) -> Diff_MotionMagicExpoVoltage_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicExpoVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicExpoVoltage :returns: Itself :rtype: Diff_MotionMagicExpoVoltage_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_voltage.PositionVoltage) -> Diff_MotionMagicExpoVoltage_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionVoltage request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionVoltage :returns: Itself :rtype: Diff_MotionMagicExpoVoltage_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicExpoVoltage_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicExpoVoltage_Position .. py:class:: Diff_MotionMagicVelocityVoltage_Position(average_request: phoenix6.controls.motion_magic_velocity_voltage.MotionMagicVelocityVoltage, differential_request: phoenix6.controls.position_voltage.PositionVoltage) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Velocity average target and position difference target using voltage control. :param average_request: Average MotionMagicVelocityVoltage request of the mechanism. :type average_request: MotionMagicVelocityVoltage :param differential_request: Differential PositionVoltage request of the mechanism. :type differential_request: PositionVoltage .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicVelocityVoltage request of the mechanism. .. py:attribute:: differential_request Differential PositionVoltage request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_velocity_voltage.MotionMagicVelocityVoltage) -> Diff_MotionMagicVelocityVoltage_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicVelocityVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicVelocityVoltage :returns: Itself :rtype: Diff_MotionMagicVelocityVoltage_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_voltage.PositionVoltage) -> Diff_MotionMagicVelocityVoltage_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionVoltage request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionVoltage :returns: Itself :rtype: Diff_MotionMagicVelocityVoltage_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicVelocityVoltage_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicVelocityVoltage_Position .. py:class:: Diff_VoltageOut_Velocity(average_request: phoenix6.controls.voltage_out.VoltageOut, differential_request: phoenix6.controls.velocity_voltage.VelocityVoltage) Requires Phoenix Pro and CANivore; Differential control with voltage average target and velocity difference target. :param average_request: Average VoltageOut request of the mechanism. :type average_request: VoltageOut :param differential_request: Differential VelocityVoltage request of the mechanism. :type differential_request: VelocityVoltage .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average VoltageOut request of the mechanism. .. py:attribute:: differential_request Differential VelocityVoltage request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.voltage_out.VoltageOut) -> Diff_VoltageOut_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average VoltageOut request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: VoltageOut :returns: Itself :rtype: Diff_VoltageOut_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_voltage.VelocityVoltage) -> Diff_VoltageOut_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityVoltage request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityVoltage :returns: Itself :rtype: Diff_VoltageOut_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_VoltageOut_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_VoltageOut_Velocity .. py:class:: Diff_PositionVoltage_Velocity(average_request: phoenix6.controls.position_voltage.PositionVoltage, differential_request: phoenix6.controls.velocity_voltage.VelocityVoltage) Requires Phoenix Pro and CANivore; Differential control with position average target and velocity difference target using voltage control. :param average_request: Average PositionVoltage request of the mechanism. :type average_request: PositionVoltage :param differential_request: Differential VelocityVoltage request of the mechanism. :type differential_request: VelocityVoltage .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average PositionVoltage request of the mechanism. .. py:attribute:: differential_request Differential VelocityVoltage request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.position_voltage.PositionVoltage) -> Diff_PositionVoltage_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average PositionVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: PositionVoltage :returns: Itself :rtype: Diff_PositionVoltage_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_voltage.VelocityVoltage) -> Diff_PositionVoltage_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityVoltage request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityVoltage :returns: Itself :rtype: Diff_PositionVoltage_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_PositionVoltage_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_PositionVoltage_Velocity .. py:class:: Diff_VelocityVoltage_Velocity(average_request: phoenix6.controls.velocity_voltage.VelocityVoltage, differential_request: phoenix6.controls.velocity_voltage.VelocityVoltage) Requires Phoenix Pro and CANivore; Differential control with velocity average target and velocity difference target using voltage control. :param average_request: Average VelocityVoltage request of the mechanism. :type average_request: VelocityVoltage :param differential_request: Differential VelocityVoltage request of the mechanism. :type differential_request: VelocityVoltage .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average VelocityVoltage request of the mechanism. .. py:attribute:: differential_request Differential VelocityVoltage request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.velocity_voltage.VelocityVoltage) -> Diff_VelocityVoltage_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average VelocityVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: VelocityVoltage :returns: Itself :rtype: Diff_VelocityVoltage_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_voltage.VelocityVoltage) -> Diff_VelocityVoltage_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityVoltage request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityVoltage :returns: Itself :rtype: Diff_VelocityVoltage_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_VelocityVoltage_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_VelocityVoltage_Velocity .. py:class:: Diff_MotionMagicVoltage_Velocity(average_request: phoenix6.controls.motion_magic_voltage.MotionMagicVoltage, differential_request: phoenix6.controls.velocity_voltage.VelocityVoltage) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® average target and velocity difference target using voltage control. :param average_request: Average MotionMagicVoltage request of the mechanism. :type average_request: MotionMagicVoltage :param differential_request: Differential VelocityVoltage request of the mechanism. :type differential_request: VelocityVoltage .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicVoltage request of the mechanism. .. py:attribute:: differential_request Differential VelocityVoltage request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_voltage.MotionMagicVoltage) -> Diff_MotionMagicVoltage_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicVoltage :returns: Itself :rtype: Diff_MotionMagicVoltage_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_voltage.VelocityVoltage) -> Diff_MotionMagicVoltage_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityVoltage request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityVoltage :returns: Itself :rtype: Diff_MotionMagicVoltage_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicVoltage_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicVoltage_Velocity .. py:class:: Diff_MotionMagicExpoVoltage_Velocity(average_request: phoenix6.controls.motion_magic_expo_voltage.MotionMagicExpoVoltage, differential_request: phoenix6.controls.velocity_voltage.VelocityVoltage) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Expo average target and velocity difference target using voltage control. :param average_request: Average MotionMagicExpoVoltage request of the mechanism. :type average_request: MotionMagicExpoVoltage :param differential_request: Differential VelocityVoltage request of the mechanism. :type differential_request: VelocityVoltage .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicExpoVoltage request of the mechanism. .. py:attribute:: differential_request Differential VelocityVoltage request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_expo_voltage.MotionMagicExpoVoltage) -> Diff_MotionMagicExpoVoltage_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicExpoVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicExpoVoltage :returns: Itself :rtype: Diff_MotionMagicExpoVoltage_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_voltage.VelocityVoltage) -> Diff_MotionMagicExpoVoltage_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityVoltage request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityVoltage :returns: Itself :rtype: Diff_MotionMagicExpoVoltage_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicExpoVoltage_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicExpoVoltage_Velocity .. py:class:: Diff_MotionMagicVelocityVoltage_Velocity(average_request: phoenix6.controls.motion_magic_velocity_voltage.MotionMagicVelocityVoltage, differential_request: phoenix6.controls.velocity_voltage.VelocityVoltage) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Velocity average target and velocity difference target using voltage control. :param average_request: Average MotionMagicVelocityVoltage request of the mechanism. :type average_request: MotionMagicVelocityVoltage :param differential_request: Differential VelocityVoltage request of the mechanism. :type differential_request: VelocityVoltage .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicVelocityVoltage request of the mechanism. .. py:attribute:: differential_request Differential VelocityVoltage request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_velocity_voltage.MotionMagicVelocityVoltage) -> Diff_MotionMagicVelocityVoltage_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicVelocityVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicVelocityVoltage :returns: Itself :rtype: Diff_MotionMagicVelocityVoltage_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_voltage.VelocityVoltage) -> Diff_MotionMagicVelocityVoltage_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityVoltage request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityVoltage :returns: Itself :rtype: Diff_MotionMagicVelocityVoltage_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicVelocityVoltage_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicVelocityVoltage_Velocity .. py:class:: Diff_VoltageOut_Open(average_request: phoenix6.controls.voltage_out.VoltageOut, differential_request: phoenix6.controls.voltage_out.VoltageOut) Requires Phoenix Pro and CANivore; Differential control with voltage average target and voltage difference target. :param average_request: Average VoltageOut request of the mechanism. :type average_request: VoltageOut :param differential_request: Differential VoltageOut request of the mechanism. :type differential_request: VoltageOut .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average VoltageOut request of the mechanism. .. py:attribute:: differential_request Differential VoltageOut request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.voltage_out.VoltageOut) -> Diff_VoltageOut_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average VoltageOut request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: VoltageOut :returns: Itself :rtype: Diff_VoltageOut_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.voltage_out.VoltageOut) -> Diff_VoltageOut_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VoltageOut request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VoltageOut :returns: Itself :rtype: Diff_VoltageOut_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_VoltageOut_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_VoltageOut_Open .. py:class:: Diff_PositionVoltage_Open(average_request: phoenix6.controls.position_voltage.PositionVoltage, differential_request: phoenix6.controls.voltage_out.VoltageOut) Requires Phoenix Pro and CANivore; Differential control with position average target and voltage difference target. :param average_request: Average PositionVoltage request of the mechanism. :type average_request: PositionVoltage :param differential_request: Differential VoltageOut request of the mechanism. :type differential_request: VoltageOut .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average PositionVoltage request of the mechanism. .. py:attribute:: differential_request Differential VoltageOut request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.position_voltage.PositionVoltage) -> Diff_PositionVoltage_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average PositionVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: PositionVoltage :returns: Itself :rtype: Diff_PositionVoltage_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.voltage_out.VoltageOut) -> Diff_PositionVoltage_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VoltageOut request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VoltageOut :returns: Itself :rtype: Diff_PositionVoltage_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_PositionVoltage_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_PositionVoltage_Open .. py:class:: Diff_VelocityVoltage_Open(average_request: phoenix6.controls.velocity_voltage.VelocityVoltage, differential_request: phoenix6.controls.voltage_out.VoltageOut) Requires Phoenix Pro and CANivore; Differential control with velocity average target and voltage difference target. :param average_request: Average VelocityVoltage request of the mechanism. :type average_request: VelocityVoltage :param differential_request: Differential VoltageOut request of the mechanism. :type differential_request: VoltageOut .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average VelocityVoltage request of the mechanism. .. py:attribute:: differential_request Differential VoltageOut request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.velocity_voltage.VelocityVoltage) -> Diff_VelocityVoltage_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average VelocityVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: VelocityVoltage :returns: Itself :rtype: Diff_VelocityVoltage_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.voltage_out.VoltageOut) -> Diff_VelocityVoltage_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VoltageOut request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VoltageOut :returns: Itself :rtype: Diff_VelocityVoltage_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_VelocityVoltage_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_VelocityVoltage_Open .. py:class:: Diff_MotionMagicVoltage_Open(average_request: phoenix6.controls.motion_magic_voltage.MotionMagicVoltage, differential_request: phoenix6.controls.voltage_out.VoltageOut) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® average target and voltage difference target. :param average_request: Average MotionMagicVoltage request of the mechanism. :type average_request: MotionMagicVoltage :param differential_request: Differential VoltageOut request of the mechanism. :type differential_request: VoltageOut .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicVoltage request of the mechanism. .. py:attribute:: differential_request Differential VoltageOut request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_voltage.MotionMagicVoltage) -> Diff_MotionMagicVoltage_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicVoltage :returns: Itself :rtype: Diff_MotionMagicVoltage_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.voltage_out.VoltageOut) -> Diff_MotionMagicVoltage_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VoltageOut request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VoltageOut :returns: Itself :rtype: Diff_MotionMagicVoltage_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicVoltage_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicVoltage_Open .. py:class:: Diff_MotionMagicExpoVoltage_Open(average_request: phoenix6.controls.motion_magic_expo_voltage.MotionMagicExpoVoltage, differential_request: phoenix6.controls.voltage_out.VoltageOut) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Expo average target and voltage difference target. :param average_request: Average MotionMagicExpoVoltage request of the mechanism. :type average_request: MotionMagicExpoVoltage :param differential_request: Differential VoltageOut request of the mechanism. :type differential_request: VoltageOut .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicExpoVoltage request of the mechanism. .. py:attribute:: differential_request Differential VoltageOut request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_expo_voltage.MotionMagicExpoVoltage) -> Diff_MotionMagicExpoVoltage_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicExpoVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicExpoVoltage :returns: Itself :rtype: Diff_MotionMagicExpoVoltage_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.voltage_out.VoltageOut) -> Diff_MotionMagicExpoVoltage_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VoltageOut request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VoltageOut :returns: Itself :rtype: Diff_MotionMagicExpoVoltage_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicExpoVoltage_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicExpoVoltage_Open .. py:class:: Diff_MotionMagicVelocityVoltage_Open(average_request: phoenix6.controls.motion_magic_velocity_voltage.MotionMagicVelocityVoltage, differential_request: phoenix6.controls.voltage_out.VoltageOut) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Velocity average target and voltage difference target. :param average_request: Average MotionMagicVelocityVoltage request of the mechanism. :type average_request: MotionMagicVelocityVoltage :param differential_request: Differential VoltageOut request of the mechanism. :type differential_request: VoltageOut .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicVelocityVoltage request of the mechanism. .. py:attribute:: differential_request Differential VoltageOut request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_velocity_voltage.MotionMagicVelocityVoltage) -> Diff_MotionMagicVelocityVoltage_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicVelocityVoltage request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicVelocityVoltage :returns: Itself :rtype: Diff_MotionMagicVelocityVoltage_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.voltage_out.VoltageOut) -> Diff_MotionMagicVelocityVoltage_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VoltageOut request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VoltageOut :returns: Itself :rtype: Diff_MotionMagicVelocityVoltage_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicVelocityVoltage_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicVelocityVoltage_Open .. py:class:: Diff_TorqueCurrentFOC_Position(average_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC, differential_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with torque current average target and position difference target. :param average_request: Average TorqueCurrentFOC request of the mechanism. :type average_request: TorqueCurrentFOC :param differential_request: Differential PositionTorqueCurrentFOC request of the mechanism. :type differential_request: PositionTorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average TorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential PositionTorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) -> Diff_TorqueCurrentFOC_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average TorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: TorqueCurrentFOC :returns: Itself :rtype: Diff_TorqueCurrentFOC_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) -> Diff_TorqueCurrentFOC_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionTorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionTorqueCurrentFOC :returns: Itself :rtype: Diff_TorqueCurrentFOC_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_TorqueCurrentFOC_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_TorqueCurrentFOC_Position .. py:class:: Diff_PositionTorqueCurrentFOC_Position(average_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC, differential_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with position average target and position difference target using torque current control. :param average_request: Average PositionTorqueCurrentFOC request of the mechanism. :type average_request: PositionTorqueCurrentFOC :param differential_request: Differential PositionTorqueCurrentFOC request of the mechanism. :type differential_request: PositionTorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average PositionTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential PositionTorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) -> Diff_PositionTorqueCurrentFOC_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average PositionTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: PositionTorqueCurrentFOC :returns: Itself :rtype: Diff_PositionTorqueCurrentFOC_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) -> Diff_PositionTorqueCurrentFOC_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionTorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionTorqueCurrentFOC :returns: Itself :rtype: Diff_PositionTorqueCurrentFOC_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_PositionTorqueCurrentFOC_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_PositionTorqueCurrentFOC_Position .. py:class:: Diff_VelocityTorqueCurrentFOC_Position(average_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC, differential_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with velocity average target and position difference target using torque current control. :param average_request: Average VelocityTorqueCurrentFOC request of the mechanism. :type average_request: VelocityTorqueCurrentFOC :param differential_request: Differential PositionTorqueCurrentFOC request of the mechanism. :type differential_request: PositionTorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average VelocityTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential PositionTorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) -> Diff_VelocityTorqueCurrentFOC_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average VelocityTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: VelocityTorqueCurrentFOC :returns: Itself :rtype: Diff_VelocityTorqueCurrentFOC_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) -> Diff_VelocityTorqueCurrentFOC_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionTorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionTorqueCurrentFOC :returns: Itself :rtype: Diff_VelocityTorqueCurrentFOC_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_VelocityTorqueCurrentFOC_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_VelocityTorqueCurrentFOC_Position .. py:class:: Diff_MotionMagicTorqueCurrentFOC_Position(average_request: phoenix6.controls.motion_magic_torque_current_foc.MotionMagicTorqueCurrentFOC, differential_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® average target and position difference target using torque current control. :param average_request: Average MotionMagicTorqueCurrentFOC request of the mechanism. :type average_request: MotionMagicTorqueCurrentFOC :param differential_request: Differential PositionTorqueCurrentFOC request of the mechanism. :type differential_request: PositionTorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential PositionTorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_torque_current_foc.MotionMagicTorqueCurrentFOC) -> Diff_MotionMagicTorqueCurrentFOC_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicTorqueCurrentFOC_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) -> Diff_MotionMagicTorqueCurrentFOC_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionTorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicTorqueCurrentFOC_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicTorqueCurrentFOC_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicTorqueCurrentFOC_Position .. py:class:: Diff_MotionMagicExpoTorqueCurrentFOC_Position(average_request: phoenix6.controls.motion_magic_expo_torque_current_foc.MotionMagicExpoTorqueCurrentFOC, differential_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Expo average target and position difference target using torque current control. :param average_request: Average MotionMagicExpoTorqueCurrentFOC request of the mechanism. :type average_request: MotionMagicExpoTorqueCurrentFOC :param differential_request: Differential PositionTorqueCurrentFOC request of the mechanism. :type differential_request: PositionTorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicExpoTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential PositionTorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_expo_torque_current_foc.MotionMagicExpoTorqueCurrentFOC) -> Diff_MotionMagicExpoTorqueCurrentFOC_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicExpoTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicExpoTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicExpoTorqueCurrentFOC_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) -> Diff_MotionMagicExpoTorqueCurrentFOC_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionTorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicExpoTorqueCurrentFOC_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicExpoTorqueCurrentFOC_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicExpoTorqueCurrentFOC_Position .. py:class:: Diff_MotionMagicVelocityTorqueCurrentFOC_Position(average_request: phoenix6.controls.motion_magic_velocity_torque_current_foc.MotionMagicVelocityTorqueCurrentFOC, differential_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Velocity average target and position difference target using torque current control. :param average_request: Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism. :type average_request: MotionMagicVelocityTorqueCurrentFOC :param differential_request: Differential PositionTorqueCurrentFOC request of the mechanism. :type differential_request: PositionTorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential PositionTorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_velocity_torque_current_foc.MotionMagicVelocityTorqueCurrentFOC) -> Diff_MotionMagicVelocityTorqueCurrentFOC_Position Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicVelocityTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicVelocityTorqueCurrentFOC_Position .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) -> Diff_MotionMagicVelocityTorqueCurrentFOC_Position Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential PositionTorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: PositionTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicVelocityTorqueCurrentFOC_Position .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicVelocityTorqueCurrentFOC_Position Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicVelocityTorqueCurrentFOC_Position .. py:class:: Diff_TorqueCurrentFOC_Velocity(average_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC, differential_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with torque current average target and velocity difference target. :param average_request: Average TorqueCurrentFOC request of the mechanism. :type average_request: TorqueCurrentFOC :param differential_request: Differential VelocityTorqueCurrentFOC request of the mechanism. :type differential_request: VelocityTorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average TorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential VelocityTorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) -> Diff_TorqueCurrentFOC_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average TorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: TorqueCurrentFOC :returns: Itself :rtype: Diff_TorqueCurrentFOC_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) -> Diff_TorqueCurrentFOC_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityTorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityTorqueCurrentFOC :returns: Itself :rtype: Diff_TorqueCurrentFOC_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_TorqueCurrentFOC_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_TorqueCurrentFOC_Velocity .. py:class:: Diff_PositionTorqueCurrentFOC_Velocity(average_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC, differential_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with position average target and velocity difference target using torque current control. :param average_request: Average PositionTorqueCurrentFOC request of the mechanism. :type average_request: PositionTorqueCurrentFOC :param differential_request: Differential VelocityTorqueCurrentFOC request of the mechanism. :type differential_request: VelocityTorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average PositionTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential VelocityTorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) -> Diff_PositionTorqueCurrentFOC_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average PositionTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: PositionTorqueCurrentFOC :returns: Itself :rtype: Diff_PositionTorqueCurrentFOC_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) -> Diff_PositionTorqueCurrentFOC_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityTorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityTorqueCurrentFOC :returns: Itself :rtype: Diff_PositionTorqueCurrentFOC_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_PositionTorqueCurrentFOC_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_PositionTorqueCurrentFOC_Velocity .. py:class:: Diff_VelocityTorqueCurrentFOC_Velocity(average_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC, differential_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with velocity average target and velocity difference target using torque current control. :param average_request: Average VelocityTorqueCurrentFOC request of the mechanism. :type average_request: VelocityTorqueCurrentFOC :param differential_request: Differential VelocityTorqueCurrentFOC request of the mechanism. :type differential_request: VelocityTorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average VelocityTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential VelocityTorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) -> Diff_VelocityTorqueCurrentFOC_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average VelocityTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: VelocityTorqueCurrentFOC :returns: Itself :rtype: Diff_VelocityTorqueCurrentFOC_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) -> Diff_VelocityTorqueCurrentFOC_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityTorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityTorqueCurrentFOC :returns: Itself :rtype: Diff_VelocityTorqueCurrentFOC_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_VelocityTorqueCurrentFOC_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_VelocityTorqueCurrentFOC_Velocity .. py:class:: Diff_MotionMagicTorqueCurrentFOC_Velocity(average_request: phoenix6.controls.motion_magic_torque_current_foc.MotionMagicTorqueCurrentFOC, differential_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® average target and velocity difference target using torque current control. :param average_request: Average MotionMagicTorqueCurrentFOC request of the mechanism. :type average_request: MotionMagicTorqueCurrentFOC :param differential_request: Differential VelocityTorqueCurrentFOC request of the mechanism. :type differential_request: VelocityTorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential VelocityTorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_torque_current_foc.MotionMagicTorqueCurrentFOC) -> Diff_MotionMagicTorqueCurrentFOC_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicTorqueCurrentFOC_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) -> Diff_MotionMagicTorqueCurrentFOC_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityTorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicTorqueCurrentFOC_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicTorqueCurrentFOC_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicTorqueCurrentFOC_Velocity .. py:class:: Diff_MotionMagicExpoTorqueCurrentFOC_Velocity(average_request: phoenix6.controls.motion_magic_expo_torque_current_foc.MotionMagicExpoTorqueCurrentFOC, differential_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Expo average target and velocity difference target using torque current control. :param average_request: Average MotionMagicExpoTorqueCurrentFOC request of the mechanism. :type average_request: MotionMagicExpoTorqueCurrentFOC :param differential_request: Differential VelocityTorqueCurrentFOC request of the mechanism. :type differential_request: VelocityTorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicExpoTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential VelocityTorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_expo_torque_current_foc.MotionMagicExpoTorqueCurrentFOC) -> Diff_MotionMagicExpoTorqueCurrentFOC_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicExpoTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicExpoTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicExpoTorqueCurrentFOC_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) -> Diff_MotionMagicExpoTorqueCurrentFOC_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityTorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicExpoTorqueCurrentFOC_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicExpoTorqueCurrentFOC_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicExpoTorqueCurrentFOC_Velocity .. py:class:: Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity(average_request: phoenix6.controls.motion_magic_velocity_torque_current_foc.MotionMagicVelocityTorqueCurrentFOC, differential_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Velocity average target and velocity difference target using torque current control. :param average_request: Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism. :type average_request: MotionMagicVelocityTorqueCurrentFOC :param differential_request: Differential VelocityTorqueCurrentFOC request of the mechanism. :type differential_request: VelocityTorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential VelocityTorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_velocity_torque_current_foc.MotionMagicVelocityTorqueCurrentFOC) -> Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicVelocityTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) -> Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential VelocityTorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: VelocityTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity .. py:class:: Diff_TorqueCurrentFOC_Open(average_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC, differential_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with torque current average target and torque current difference target. :param average_request: Average TorqueCurrentFOC request of the mechanism. :type average_request: TorqueCurrentFOC :param differential_request: Differential TorqueCurrentFOC request of the mechanism. :type differential_request: TorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average TorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential TorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) -> Diff_TorqueCurrentFOC_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average TorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: TorqueCurrentFOC :returns: Itself :rtype: Diff_TorqueCurrentFOC_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) -> Diff_TorqueCurrentFOC_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential TorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: TorqueCurrentFOC :returns: Itself :rtype: Diff_TorqueCurrentFOC_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_TorqueCurrentFOC_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_TorqueCurrentFOC_Open .. py:class:: Diff_PositionTorqueCurrentFOC_Open(average_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC, differential_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with position average target and torque current difference target. :param average_request: Average PositionTorqueCurrentFOC request of the mechanism. :type average_request: PositionTorqueCurrentFOC :param differential_request: Differential TorqueCurrentFOC request of the mechanism. :type differential_request: TorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average PositionTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential TorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.position_torque_current_foc.PositionTorqueCurrentFOC) -> Diff_PositionTorqueCurrentFOC_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average PositionTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: PositionTorqueCurrentFOC :returns: Itself :rtype: Diff_PositionTorqueCurrentFOC_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) -> Diff_PositionTorqueCurrentFOC_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential TorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: TorqueCurrentFOC :returns: Itself :rtype: Diff_PositionTorqueCurrentFOC_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_PositionTorqueCurrentFOC_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_PositionTorqueCurrentFOC_Open .. py:class:: Diff_VelocityTorqueCurrentFOC_Open(average_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC, differential_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with velocity average target and torque current difference target. :param average_request: Average VelocityTorqueCurrentFOC request of the mechanism. :type average_request: VelocityTorqueCurrentFOC :param differential_request: Differential TorqueCurrentFOC request of the mechanism. :type differential_request: TorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average VelocityTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential TorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.velocity_torque_current_foc.VelocityTorqueCurrentFOC) -> Diff_VelocityTorqueCurrentFOC_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average VelocityTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: VelocityTorqueCurrentFOC :returns: Itself :rtype: Diff_VelocityTorqueCurrentFOC_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) -> Diff_VelocityTorqueCurrentFOC_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential TorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: TorqueCurrentFOC :returns: Itself :rtype: Diff_VelocityTorqueCurrentFOC_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_VelocityTorqueCurrentFOC_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_VelocityTorqueCurrentFOC_Open .. py:class:: Diff_MotionMagicTorqueCurrentFOC_Open(average_request: phoenix6.controls.motion_magic_torque_current_foc.MotionMagicTorqueCurrentFOC, differential_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® average target and torque current difference target. :param average_request: Average MotionMagicTorqueCurrentFOC request of the mechanism. :type average_request: MotionMagicTorqueCurrentFOC :param differential_request: Differential TorqueCurrentFOC request of the mechanism. :type differential_request: TorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential TorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_torque_current_foc.MotionMagicTorqueCurrentFOC) -> Diff_MotionMagicTorqueCurrentFOC_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicTorqueCurrentFOC_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) -> Diff_MotionMagicTorqueCurrentFOC_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential TorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: TorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicTorqueCurrentFOC_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicTorqueCurrentFOC_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicTorqueCurrentFOC_Open .. py:class:: Diff_MotionMagicExpoTorqueCurrentFOC_Open(average_request: phoenix6.controls.motion_magic_expo_torque_current_foc.MotionMagicExpoTorqueCurrentFOC, differential_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Expo average target and torque current difference target. :param average_request: Average MotionMagicExpoTorqueCurrentFOC request of the mechanism. :type average_request: MotionMagicExpoTorqueCurrentFOC :param differential_request: Differential TorqueCurrentFOC request of the mechanism. :type differential_request: TorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicExpoTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential TorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_expo_torque_current_foc.MotionMagicExpoTorqueCurrentFOC) -> Diff_MotionMagicExpoTorqueCurrentFOC_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicExpoTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicExpoTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicExpoTorqueCurrentFOC_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) -> Diff_MotionMagicExpoTorqueCurrentFOC_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential TorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: TorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicExpoTorqueCurrentFOC_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicExpoTorqueCurrentFOC_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicExpoTorqueCurrentFOC_Open .. py:class:: Diff_MotionMagicVelocityTorqueCurrentFOC_Open(average_request: phoenix6.controls.motion_magic_velocity_torque_current_foc.MotionMagicVelocityTorqueCurrentFOC, differential_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) Requires Phoenix Pro and CANivore; Differential control with Motion Magic® Velocity average target and torque current difference target. :param average_request: Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism. :type average_request: MotionMagicVelocityTorqueCurrentFOC :param differential_request: Differential TorqueCurrentFOC request of the mechanism. :type differential_request: TorqueCurrentFOC .. py:property:: name :type: str Gets the name of this control request. :returns: Name of the control request :rtype: str .. py:property:: control_info :type: dict Gets information about this control request. :returns: Dictonary of control parameter names and corresponding applied values :rtype: dict .. py:attribute:: update_freq_hz :type: phoenix6.units.hertz :value: '100' The frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. .. py:attribute:: average_request Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism. .. py:attribute:: differential_request Differential TorqueCurrentFOC request of the mechanism. .. py:method:: with_average_request(new_average_request: phoenix6.controls.motion_magic_velocity_torque_current_foc.MotionMagicVelocityTorqueCurrentFOC) -> Diff_MotionMagicVelocityTorqueCurrentFOC_Open Modifies this Control Request's average_request parameter and returns itself for method-chaining and easier to use request API. Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism. :param new_average_request: Parameter to modify :type new_average_request: MotionMagicVelocityTorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicVelocityTorqueCurrentFOC_Open .. py:method:: with_differential_request(new_differential_request: phoenix6.controls.torque_current_foc.TorqueCurrentFOC) -> Diff_MotionMagicVelocityTorqueCurrentFOC_Open Modifies this Control Request's differential_request parameter and returns itself for method-chaining and easier to use request API. Differential TorqueCurrentFOC request of the mechanism. :param new_differential_request: Parameter to modify :type new_differential_request: TorqueCurrentFOC :returns: Itself :rtype: Diff_MotionMagicVelocityTorqueCurrentFOC_Open .. py:method:: with_update_freq_hz(new_update_freq_hz: phoenix6.units.hertz) -> Diff_MotionMagicVelocityTorqueCurrentFOC_Open Sets the frequency at which this control will update. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms). Some update frequencies are not supported and will be promoted up to the next highest supported frequency. If this field is set to 0 Hz, the control request will be sent immediately as a one-shot frame. This may be useful for advanced applications that require outputs to be synchronized with data acquisition. In this case, we recommend not exceeding 50 ms between control calls. :param new_update_freq_hz: Parameter to modify :type new_update_freq_hz: hertz :returns: Itself :rtype: Diff_MotionMagicVelocityTorqueCurrentFOC_Open