Struct PidController

pub struct PidController {
    pub pd: PdController,
    pub lin_integral: Vector<f32>,
    pub ang_integral: AngVector<f32>,
    pub lin_ki: Vector<f32>,
    pub ang_ki: AngVector<f32>,
}

A Proportional-Integral-Derivative (PID) controller.

For video games, the Proportional-Derivative PdController is generally sufficient and offers an immutable API.

Fields

pd: PdController

The Proportional-Derivative (PD) part of this PID controller.

lin_integral: Vector<f32>

The translational error accumulated through time for the Integral part of the PID controller.

ang_integral: AngVector<f32>

The angular error accumulated through time for the Integral part of the PID controller.

lin_ki: Vector<f32>

The linear gain applied to the Integral part of the PID controller.

ang_ki: AngVector<f32>

The angular gain applied to the Integral part of the PID controller.

Implementations

impl PidController

pub fn new(kp: f32, ki: f32, kd: f32, axes: AxesMask) -> PidController

Initialized the PDI controller with uniform gain.

The same gain are applied on all axes. To configure per-axes gains, construct the PidController by setting its fields explicitly instead.

Only the axes specified in axes will be enabled (but the gain values are set on all axes regardless).

pub fn set_axes(&mut self, axes: AxesMask)

Set the axes errors and corrections are computed for.

This doesn’t modify any of the gains.

pub fn axes(&self) -> AxesMask

Get the axes errors and corrections are computed for.

pub fn reset_integrals(&mut self)

Resets to zero the accumulated linear and angular errors used by the Integral part of the controller.

pub fn linear_rigid_body_correction( &mut self, dt: f32, rb: &RigidBody, target_pos: Point<f32>, target_linvel: Vector<f32>, ) -> Vector<f32>

Calculates the linear correction from positional and velocity errors calculated automatically from a rigid-body and the desired positions/velocities.

The unit of the returned value depends on the gain values. In general, kd is proportional to the inverse of the simulation step so the returned value is a linear rigid-body velocity change.

This method is mutable because of the need to update the accumulated positional errors for the Integral part of this controller. Prefer the PdController instead if an immutable API is needed.

pub fn angular_rigid_body_correction( &mut self, dt: f32, rb: &RigidBody, target_rot: Rotation<f32>, target_angvel: AngVector<f32>, ) -> AngVector<f32>

Calculates the angular correction from positional and velocity errors calculated automatically from a rigid-body and the desired positions/velocities.

The unit of the returned value depends on the gain values. In general, kd is proportional to the inverse of the simulation step so the returned value is an angular rigid-body velocity change.

This method is mutable because of the need to update the accumulated positional errors for the Integral part of this controller. Prefer the PdController instead if an immutable API is needed.

pub fn rigid_body_correction( &mut self, dt: f32, rb: &RigidBody, target_pose: Isometry<f32>, target_vels: RigidBodyVelocity, ) -> RigidBodyVelocity

Calculates the linear and angular correction from positional and velocity errors calculated automatically from a rigid-body and the desired poses/velocities.

The unit of the returned value depends on the gain values. In general, kd is proportional to the inverse of the simulation step so the returned value is a rigid-body velocity change.

This method is mutable because of the need to update the accumulated positional errors for the Integral part of this controller. Prefer the PdController instead if an immutable API is needed.

pub fn correction( &mut self, dt: f32, pose_errors: &PdErrors, vel_errors: &PdErrors, ) -> RigidBodyVelocity

Calculates the linear and angular correction from the given positional and velocity errors.

The unit of the returned value depends on the gain values. In general, kd is proportional to the inverse of the simulation step so the returned value is a rigid-body velocity change.

This method is mutable because of the need to update the accumulated positional errors for the Integral part of this controller. Prefer the PdController instead if an immutable API is needed.

Trait Implementations

impl Clone for PidController

fn clone(&self) -> PidController

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PidController

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PidController

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for PidController

fn eq(&self, other: &PidController) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for PidController

impl StructuralPartialEq for PidController