phoenix6.controls.compound

class phoenix6.controls.compound.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.

Parameters:

average_request (DutyCycleOut) – Average DutyCycleOut request of the mechanism.
differential_request (PositionDutyCycle) – Differential PositionDutyCycle request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average DutyCycleOut request of the mechanism.

differential_request¶: Differential PositionDutyCycle request of the mechanism.

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.

Parameters:: new_average_request (DutyCycleOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_DutyCycleOut_Position

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.

Parameters:: new_differential_request (PositionDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_DutyCycleOut_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_DutyCycleOut_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (PositionDutyCycle) – Average PositionDutyCycle request of the mechanism.
differential_request (PositionDutyCycle) – Differential PositionDutyCycle request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average PositionDutyCycle request of the mechanism.

differential_request¶: Differential PositionDutyCycle request of the mechanism.

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.

Parameters:: new_average_request (PositionDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionDutyCycle_Position

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.

Parameters:: new_differential_request (PositionDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionDutyCycle_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionDutyCycle_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (VelocityDutyCycle) – Average VelocityDutyCYcle request of the mechanism.
differential_request (PositionDutyCycle) – Differential PositionDutyCycle request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average VelocityDutyCYcle request of the mechanism.

differential_request¶: Differential PositionDutyCycle request of the mechanism.

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.

Parameters:: new_average_request (VelocityDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityDutyCycle_Position

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.

Parameters:: new_differential_request (PositionDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityDutyCycle_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityDutyCycle_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicDutyCycle) – Average MotionMagicDutyCycle request of the mechanism.
differential_request (PositionDutyCycle) – Differential PositionDutyCycle request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicDutyCycle request of the mechanism.

differential_request¶: Differential PositionDutyCycle request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicDutyCycle_Position

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.

Parameters:: new_differential_request (PositionDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicDutyCycle_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicDutyCycle_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicExpoDutyCycle) – Average MotionMagicExpoDutyCycle request of the mechanism.
differential_request (PositionDutyCycle) – Differential PositionDutyCycle request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicExpoDutyCycle request of the mechanism.

differential_request¶: Differential PositionDutyCycle request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicExpoDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoDutyCycle_Position

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.

Parameters:: new_differential_request (PositionDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoDutyCycle_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoDutyCycle_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicVelocityDutyCycle) – Average MotionMagicVelocityDutyCycle request of the mechanism.
differential_request (PositionDutyCycle) – Differential PositionDutyCycle request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicVelocityDutyCycle request of the mechanism.

differential_request¶: Differential PositionDutyCycle request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicVelocityDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityDutyCycle_Position

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.

Parameters:: new_differential_request (PositionDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityDutyCycle_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityDutyCycle_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (DutyCycleOut) – Average DutyCycleOut request of the mechanism.
differential_request (VelocityDutyCycle) – Differential VelocityDutyCycle request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average DutyCycleOut request of the mechanism.

differential_request¶: Differential VelocityDutyCycle request of the mechanism.

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.

Parameters:: new_average_request (DutyCycleOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_DutyCycleOut_Velocity

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.

Parameters:: new_differential_request (VelocityDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_DutyCycleOut_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_DutyCycleOut_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (PositionDutyCycle) – Average PositionDutyCycle request of the mechanism.
differential_request (VelocityDutyCycle) – Differential VelocityDutyCycle request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average PositionDutyCycle request of the mechanism.

differential_request¶: Differential VelocityDutyCycle request of the mechanism.

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.

Parameters:: new_average_request (PositionDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionDutyCycle_Velocity

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.

Parameters:: new_differential_request (VelocityDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionDutyCycle_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionDutyCycle_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (VelocityDutyCycle) – Average VelocityDutyCycle request of the mechanism.
differential_request (VelocityDutyCycle) – Differential VelocityDutyCycle request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average VelocityDutyCycle request of the mechanism.

differential_request¶: Differential VelocityDutyCycle request of the mechanism.

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.

Parameters:: new_average_request (VelocityDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityDutyCycle_Velocity

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.

Parameters:: new_differential_request (VelocityDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityDutyCycle_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityDutyCycle_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicDutyCycle) – Average MotionMagicDutyCycle request of the mechanism.
differential_request (VelocityDutyCycle) – Differential VelocityDutyCycle request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicDutyCycle request of the mechanism.

differential_request¶: Differential VelocityDutyCycle request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicDutyCycle_Velocity

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.

Parameters:: new_differential_request (VelocityDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicDutyCycle_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicDutyCycle_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicExpoDutyCycle) – Average MotionMagicExpoDutyCycle request of the mechanism.
differential_request (VelocityDutyCycle) – Differential VelocityDutyCycle request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicExpoDutyCycle request of the mechanism.

differential_request¶: Differential VelocityDutyCycle request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicExpoDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoDutyCycle_Velocity

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.

Parameters:: new_differential_request (VelocityDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoDutyCycle_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoDutyCycle_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicVelocityDutyCycle) – Average MotionMagicVelocityDutyCycle request of the mechanism.
differential_request (VelocityDutyCycle) – Differential VelocityDutyCycle request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicVelocityDutyCycle request of the mechanism.

differential_request¶: Differential VelocityDutyCycle request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicVelocityDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityDutyCycle_Velocity

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.

Parameters:: new_differential_request (VelocityDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityDutyCycle_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityDutyCycle_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (DutyCycleOut) – Average DutyCycleOut request of the mechanism.
differential_request (DutyCycleOut) – Differential DutyCycleOut request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average DutyCycleOut request of the mechanism.

differential_request¶: Differential DutyCycleOut request of the mechanism.

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.

Parameters:: new_average_request (DutyCycleOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_DutyCycleOut_Open

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.

Parameters:: new_differential_request (DutyCycleOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_DutyCycleOut_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_DutyCycleOut_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (PositionDutyCycle) – Average PositionDutyCycle request of the mechanism.
differential_request (DutyCycleOut) – Differential DutyCycleOut request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average PositionDutyCycle request of the mechanism.

differential_request¶: Differential DutyCycleOut request of the mechanism.

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.

Parameters:: new_average_request (PositionDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionDutyCycle_Open

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.

Parameters:: new_differential_request (DutyCycleOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionDutyCycle_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionDutyCycle_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (VelocityDutyCycle) – Average VelocityDutyCYcle request of the mechanism.
differential_request (DutyCycleOut) – Differential DutyCycleOut request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average VelocityDutyCYcle request of the mechanism.

differential_request¶: Differential DutyCycleOut request of the mechanism.

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.

Parameters:: new_average_request (VelocityDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityDutyCycle_Open

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.

Parameters:: new_differential_request (DutyCycleOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityDutyCycle_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityDutyCycle_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicDutyCycle) – Average MotionMagicDutyCycle request of the mechanism.
differential_request (DutyCycleOut) – Differential DutyCycleOut request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicDutyCycle request of the mechanism.

differential_request¶: Differential DutyCycleOut request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicDutyCycle_Open

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.

Parameters:: new_differential_request (DutyCycleOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicDutyCycle_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicDutyCycle_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicExpoDutyCycle) – Average MotionMagicExpoDutyCycle request of the mechanism.
differential_request (DutyCycleOut) – Differential DutyCycleOut request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicExpoDutyCycle request of the mechanism.

differential_request¶: Differential DutyCycleOut request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicExpoDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoDutyCycle_Open

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.

Parameters:: new_differential_request (DutyCycleOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoDutyCycle_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoDutyCycle_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicVelocityDutyCycle) – Average MotionMagicVelocityDutyCycle request of the mechanism.
differential_request (DutyCycleOut) – Differential DutyCycleOut request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicVelocityDutyCycle request of the mechanism.

differential_request¶: Differential DutyCycleOut request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicVelocityDutyCycle) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityDutyCycle_Open

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.

Parameters:: new_differential_request (DutyCycleOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityDutyCycle_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityDutyCycle_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (VoltageOut) – Average VoltageOut request of the mechanism.
differential_request (PositionVoltage) – Differential PositionVoltage request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average VoltageOut request of the mechanism.

differential_request¶: Differential PositionVoltage request of the mechanism.

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.

Parameters:: new_average_request (VoltageOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_VoltageOut_Position

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.

Parameters:: new_differential_request (PositionVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_VoltageOut_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_VoltageOut_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (PositionVoltage) – Average PositionVoltage request of the mechanism.
differential_request (PositionVoltage) – Differential PositionVoltage request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average PositionVoltage request of the mechanism.

differential_request¶: Differential PositionVoltage request of the mechanism.

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.

Parameters:: new_average_request (PositionVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionVoltage_Position

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.

Parameters:: new_differential_request (PositionVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionVoltage_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionVoltage_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (VelocityVoltage) – Average VelocityVoltage request of the mechanism.
differential_request (PositionVoltage) – Differential PositionVoltage request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average VelocityVoltage request of the mechanism.

differential_request¶: Differential PositionVoltage request of the mechanism.

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.

Parameters:: new_average_request (VelocityVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityVoltage_Position

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.

Parameters:: new_differential_request (PositionVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityVoltage_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityVoltage_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicVoltage) – Average MotionMagicVoltage request of the mechanism.
differential_request (PositionVoltage) – Differential PositionVoltage request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicVoltage request of the mechanism.

differential_request¶: Differential PositionVoltage request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVoltage_Position

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.

Parameters:: new_differential_request (PositionVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVoltage_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVoltage_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicExpoVoltage) – Average MotionMagicExpoVoltage request of the mechanism.
differential_request (PositionVoltage) – Differential PositionVoltage request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicExpoVoltage request of the mechanism.

differential_request¶: Differential PositionVoltage request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicExpoVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoVoltage_Position

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.

Parameters:: new_differential_request (PositionVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoVoltage_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoVoltage_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicVelocityVoltage) – Average MotionMagicVelocityVoltage request of the mechanism.
differential_request (PositionVoltage) – Differential PositionVoltage request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicVelocityVoltage request of the mechanism.

differential_request¶: Differential PositionVoltage request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicVelocityVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityVoltage_Position

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.

Parameters:: new_differential_request (PositionVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityVoltage_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityVoltage_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (VoltageOut) – Average VoltageOut request of the mechanism.
differential_request (VelocityVoltage) – Differential VelocityVoltage request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average VoltageOut request of the mechanism.

differential_request¶: Differential VelocityVoltage request of the mechanism.

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.

Parameters:: new_average_request (VoltageOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_VoltageOut_Velocity

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.

Parameters:: new_differential_request (VelocityVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_VoltageOut_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_VoltageOut_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (PositionVoltage) – Average PositionVoltage request of the mechanism.
differential_request (VelocityVoltage) – Differential VelocityVoltage request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average PositionVoltage request of the mechanism.

differential_request¶: Differential VelocityVoltage request of the mechanism.

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.

Parameters:: new_average_request (PositionVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionVoltage_Velocity

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.

Parameters:: new_differential_request (VelocityVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionVoltage_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionVoltage_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (VelocityVoltage) – Average VelocityVoltage request of the mechanism.
differential_request (VelocityVoltage) – Differential VelocityVoltage request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average VelocityVoltage request of the mechanism.

differential_request¶: Differential VelocityVoltage request of the mechanism.

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.

Parameters:: new_average_request (VelocityVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityVoltage_Velocity

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.

Parameters:: new_differential_request (VelocityVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityVoltage_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityVoltage_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicVoltage) – Average MotionMagicVoltage request of the mechanism.
differential_request (VelocityVoltage) – Differential VelocityVoltage request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicVoltage request of the mechanism.

differential_request¶: Differential VelocityVoltage request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVoltage_Velocity

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.

Parameters:: new_differential_request (VelocityVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVoltage_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVoltage_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicExpoVoltage) – Average MotionMagicExpoVoltage request of the mechanism.
differential_request (VelocityVoltage) – Differential VelocityVoltage request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicExpoVoltage request of the mechanism.

differential_request¶: Differential VelocityVoltage request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicExpoVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoVoltage_Velocity

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.

Parameters:: new_differential_request (VelocityVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoVoltage_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoVoltage_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicVelocityVoltage) – Average MotionMagicVelocityVoltage request of the mechanism.
differential_request (VelocityVoltage) – Differential VelocityVoltage request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicVelocityVoltage request of the mechanism.

differential_request¶: Differential VelocityVoltage request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicVelocityVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityVoltage_Velocity

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.

Parameters:: new_differential_request (VelocityVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityVoltage_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityVoltage_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (VoltageOut) – Average VoltageOut request of the mechanism.
differential_request (VoltageOut) – Differential VoltageOut request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average VoltageOut request of the mechanism.

differential_request¶: Differential VoltageOut request of the mechanism.

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.

Parameters:: new_average_request (VoltageOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_VoltageOut_Open

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.

Parameters:: new_differential_request (VoltageOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_VoltageOut_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_VoltageOut_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (PositionVoltage) – Average PositionVoltage request of the mechanism.
differential_request (VoltageOut) – Differential VoltageOut request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average PositionVoltage request of the mechanism.

differential_request¶: Differential VoltageOut request of the mechanism.

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.

Parameters:: new_average_request (PositionVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionVoltage_Open

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.

Parameters:: new_differential_request (VoltageOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionVoltage_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionVoltage_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (VelocityVoltage) – Average VelocityVoltage request of the mechanism.
differential_request (VoltageOut) – Differential VoltageOut request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average VelocityVoltage request of the mechanism.

differential_request¶: Differential VoltageOut request of the mechanism.

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.

Parameters:: new_average_request (VelocityVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityVoltage_Open

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.

Parameters:: new_differential_request (VoltageOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityVoltage_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityVoltage_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicVoltage) – Average MotionMagicVoltage request of the mechanism.
differential_request (VoltageOut) – Differential VoltageOut request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicVoltage request of the mechanism.

differential_request¶: Differential VoltageOut request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVoltage_Open

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.

Parameters:: new_differential_request (VoltageOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVoltage_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVoltage_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicExpoVoltage) – Average MotionMagicExpoVoltage request of the mechanism.
differential_request (VoltageOut) – Differential VoltageOut request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicExpoVoltage request of the mechanism.

differential_request¶: Differential VoltageOut request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicExpoVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoVoltage_Open

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.

Parameters:: new_differential_request (VoltageOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoVoltage_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoVoltage_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicVelocityVoltage) – Average MotionMagicVelocityVoltage request of the mechanism.
differential_request (VoltageOut) – Differential VoltageOut request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicVelocityVoltage request of the mechanism.

differential_request¶: Differential VoltageOut request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicVelocityVoltage) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityVoltage_Open

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.

Parameters:: new_differential_request (VoltageOut) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityVoltage_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityVoltage_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (TorqueCurrentFOC) – Average TorqueCurrentFOC request of the mechanism.
differential_request (PositionTorqueCurrentFOC) – Differential PositionTorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average TorqueCurrentFOC request of the mechanism.

differential_request¶: Differential PositionTorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (TorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_TorqueCurrentFOC_Position

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.

Parameters:: new_differential_request (PositionTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_TorqueCurrentFOC_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_TorqueCurrentFOC_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (PositionTorqueCurrentFOC) – Average PositionTorqueCurrentFOC request of the mechanism.
differential_request (PositionTorqueCurrentFOC) – Differential PositionTorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average PositionTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential PositionTorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (PositionTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionTorqueCurrentFOC_Position

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.

Parameters:: new_differential_request (PositionTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionTorqueCurrentFOC_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionTorqueCurrentFOC_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (VelocityTorqueCurrentFOC) – Average VelocityTorqueCurrentFOC request of the mechanism.
differential_request (PositionTorqueCurrentFOC) – Differential PositionTorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average VelocityTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential PositionTorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (VelocityTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityTorqueCurrentFOC_Position

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.

Parameters:: new_differential_request (PositionTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityTorqueCurrentFOC_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityTorqueCurrentFOC_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicTorqueCurrentFOC) – Average MotionMagicTorqueCurrentFOC request of the mechanism.
differential_request (PositionTorqueCurrentFOC) – Differential PositionTorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential PositionTorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicTorqueCurrentFOC_Position

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.

Parameters:: new_differential_request (PositionTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicTorqueCurrentFOC_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicTorqueCurrentFOC_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicExpoTorqueCurrentFOC) – Average MotionMagicExpoTorqueCurrentFOC request of the mechanism.
differential_request (PositionTorqueCurrentFOC) – Differential PositionTorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicExpoTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential PositionTorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicExpoTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoTorqueCurrentFOC_Position

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.

Parameters:: new_differential_request (PositionTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoTorqueCurrentFOC_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoTorqueCurrentFOC_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicVelocityTorqueCurrentFOC) – Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism.
differential_request (PositionTorqueCurrentFOC) – Differential PositionTorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential PositionTorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicVelocityTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityTorqueCurrentFOC_Position

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.

Parameters:: new_differential_request (PositionTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityTorqueCurrentFOC_Position

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityTorqueCurrentFOC_Position

class phoenix6.controls.compound.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.

Parameters:

average_request (TorqueCurrentFOC) – Average TorqueCurrentFOC request of the mechanism.
differential_request (VelocityTorqueCurrentFOC) – Differential VelocityTorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average TorqueCurrentFOC request of the mechanism.

differential_request¶: Differential VelocityTorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (TorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_TorqueCurrentFOC_Velocity

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.

Parameters:: new_differential_request (VelocityTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_TorqueCurrentFOC_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_TorqueCurrentFOC_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (PositionTorqueCurrentFOC) – Average PositionTorqueCurrentFOC request of the mechanism.
differential_request (VelocityTorqueCurrentFOC) – Differential VelocityTorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average PositionTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential VelocityTorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (PositionTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionTorqueCurrentFOC_Velocity

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.

Parameters:: new_differential_request (VelocityTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionTorqueCurrentFOC_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionTorqueCurrentFOC_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (VelocityTorqueCurrentFOC) – Average VelocityTorqueCurrentFOC request of the mechanism.
differential_request (VelocityTorqueCurrentFOC) – Differential VelocityTorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average VelocityTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential VelocityTorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (VelocityTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityTorqueCurrentFOC_Velocity

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.

Parameters:: new_differential_request (VelocityTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityTorqueCurrentFOC_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityTorqueCurrentFOC_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicTorqueCurrentFOC) – Average MotionMagicTorqueCurrentFOC request of the mechanism.
differential_request (VelocityTorqueCurrentFOC) – Differential VelocityTorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential VelocityTorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicTorqueCurrentFOC_Velocity

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.

Parameters:: new_differential_request (VelocityTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicTorqueCurrentFOC_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicTorqueCurrentFOC_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicExpoTorqueCurrentFOC) – Average MotionMagicExpoTorqueCurrentFOC request of the mechanism.
differential_request (VelocityTorqueCurrentFOC) – Differential VelocityTorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicExpoTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential VelocityTorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicExpoTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoTorqueCurrentFOC_Velocity

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.

Parameters:: new_differential_request (VelocityTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoTorqueCurrentFOC_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoTorqueCurrentFOC_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicVelocityTorqueCurrentFOC) – Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism.
differential_request (VelocityTorqueCurrentFOC) – Differential VelocityTorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential VelocityTorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicVelocityTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity

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.

Parameters:: new_differential_request (VelocityTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity

class phoenix6.controls.compound.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.

Parameters:

average_request (TorqueCurrentFOC) – Average TorqueCurrentFOC request of the mechanism.
differential_request (TorqueCurrentFOC) – Differential TorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average TorqueCurrentFOC request of the mechanism.

differential_request¶: Differential TorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (TorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_TorqueCurrentFOC_Open

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.

Parameters:: new_differential_request (TorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_TorqueCurrentFOC_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_TorqueCurrentFOC_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (PositionTorqueCurrentFOC) – Average PositionTorqueCurrentFOC request of the mechanism.
differential_request (TorqueCurrentFOC) – Differential TorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average PositionTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential TorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (PositionTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionTorqueCurrentFOC_Open

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.

Parameters:: new_differential_request (TorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionTorqueCurrentFOC_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_PositionTorqueCurrentFOC_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (VelocityTorqueCurrentFOC) – Average VelocityTorqueCurrentFOC request of the mechanism.
differential_request (TorqueCurrentFOC) – Differential TorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average VelocityTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential TorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (VelocityTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityTorqueCurrentFOC_Open

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.

Parameters:: new_differential_request (TorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityTorqueCurrentFOC_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_VelocityTorqueCurrentFOC_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicTorqueCurrentFOC) – Average MotionMagicTorqueCurrentFOC request of the mechanism.
differential_request (TorqueCurrentFOC) – Differential TorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential TorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicTorqueCurrentFOC_Open

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.

Parameters:: new_differential_request (TorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicTorqueCurrentFOC_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicTorqueCurrentFOC_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicExpoTorqueCurrentFOC) – Average MotionMagicExpoTorqueCurrentFOC request of the mechanism.
differential_request (TorqueCurrentFOC) – Differential TorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicExpoTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential TorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicExpoTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoTorqueCurrentFOC_Open

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.

Parameters:: new_differential_request (TorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoTorqueCurrentFOC_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicExpoTorqueCurrentFOC_Open

class phoenix6.controls.compound.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.

Parameters:

average_request (MotionMagicVelocityTorqueCurrentFOC) – Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism.
differential_request (TorqueCurrentFOC) – Differential TorqueCurrentFOC request of the mechanism.

property name: str¶

Gets the name of this control request.

Returns:: Name of the control request
Return type:: str

property control_info: dict¶

Gets information about this control request.

Returns:: Dictonary of control parameter names and corresponding applied values
Return type:: dict

update_freq_hz: phoenix6.units.hertz = '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.

average_request¶: Average MotionMagicVelocityTorqueCurrentFOC request of the mechanism.

differential_request¶: Differential TorqueCurrentFOC request of the mechanism.

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.

Parameters:: new_average_request (MotionMagicVelocityTorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityTorqueCurrentFOC_Open

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.

Parameters:: new_differential_request (TorqueCurrentFOC) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityTorqueCurrentFOC_Open

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.

Parameters:: new_update_freq_hz (hertz) – Parameter to modify
Returns:: Itself
Return type:: Diff_MotionMagicVelocityTorqueCurrentFOC_Open

`phoenix6.controls.compound`¶

Submodules¶

Package Contents¶

phoenix6.controls.compound¶

Submodules¶

Package Contents¶

`phoenix6.controls.compound`¶