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:

AverageRequest – Average DutyCycleOut request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 dutycycle control.

Parameters:

AverageRequest – Average PositionDutyCycle request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 dutycycle control.

Parameters:

AverageRequest – Average VelocityDutyCYcle request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 dutycycle control.

Parameters:

AverageRequest – Average MotionMagicDutyCycle request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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_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:

AverageRequest – Average DutyCycleOut request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 dutycycle control.

Parameters:

AverageRequest – Average PositionDutyCycle request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 dutycycle control.

Parameters:

AverageRequest – Average VelocityDutyCycle request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 dutycycle control.

Parameters:

AverageRequest – Average MotionMagicDutyCycle request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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_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:

AverageRequest – Average VoltageOut request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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:

AverageRequest – Average PositionVoltage request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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:

AverageRequest – Average VelocityVoltage request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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:

AverageRequest – Average MotionMagicVoltage request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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_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:

AverageRequest – Average VoltageOut request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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:

AverageRequest – Average PositionVoltage request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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:

AverageRequest – Average VelocityVoltage request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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:

AverageRequest – Average MotionMagicVoltage request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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_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:

AverageRequest – Average TorqueCurrentFOC request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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:

AverageRequest – Average PositionTorqueCurrentFOC request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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:

AverageRequest – Average VelocityTorqueCurrentFOC request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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:

AverageRequest – Average MotionMagicTorqueCurrentFOC request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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_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:

AverageRequest – Average TorqueCurrentFOC request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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:

AverageRequest – Average PositionTorqueCurrentFOC request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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:

AverageRequest – Average VelocityTorqueCurrentFOC request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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:

AverageRequest – Average MotionMagicTorqueCurrentFOC request of the mechanism.
DifferentialRequest – 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.0¶

The period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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 period at which this control will update at. This is designated in Hertz, with a minimum of 20 Hz (every 50 ms) and a maximum of 1000 Hz (every 1 ms).

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

`phoenix6.controls.compound`¶

Submodules¶

Package Contents¶

phoenix6.controls.compound¶

Submodules¶

Package Contents¶

`phoenix6.controls.compound`¶