Pedro Pathing

Feedforward controllers provide output based on the target or error without waiting for a feedback loop.

Available types:

• staticFeedforward(double kS): Constant output in the direction of the error: kS * signum(error).
• staticTargetFeedforward(double kS): Constant output in the direction of the target: kS * signum(target).
• proportionalFeedforward(double kV): Output proportional to the target: kV * target.

All these methods accept either a double or a Supplier<Double> for the gain/constant.

Controller ff = Controller.staticFeedforward(0.5);
Controller targetFf = Controller.proportionalFeedforward(0.2);

Use Controller.piecewise(Controller baseline) to wrap a baseline controller. This is typically used to implement logic that changes behavior based on specific conditions (implementation details depend on the PiecewiseController class).

Controller base = Controller.proportional(1.0);
Controller piecewise = Controller.piecewise(base);

You can combine multiple Controller instances using arithmetic-like methods to build complex control laws from simple components. These operations return new Controller instances that manage the lifecycle (resetting) of their constituents.

Available operations:

• plus(Controller other): Sums the outputs of two controllers.
• minus(Controller other): Subtracts the output of the second controller from the first.
• times(double scalar): Scales the output of the controller by a constant factor.
• Controller.sum(Controller... controllers): A static utility to sum an arbitrary number of controllers.

Controller p = Controller.proportional(1.0);
Controller feedforward = Controller.staticFeedforward(0.5);

// Combine them into a single controller
Controller combined = p.plus(feedforward);

The Controller interface is the core abstraction for all control algorithms in the library. It is a @FunctionalInterface that defines how to calculate a control output based on a target value and the current error.

Key methods:

• calculate(double target, double error): Computes the control output.
• calculate(double target, double error, double derivative): A specialized version that accepts a pre-calculated derivative.
• reset(): Resets the internal state of the controller (e.g., clearing integral accumulation or time tracking).

Controller myController = (target, error) -> error * 0.5;
double output = myController.calculate(10.0, 2.0);

Use Controller.derivative(Supplier<Double> kD) to create a controller that provides output based on the rate of change of the error. It uses an internal TimedController to track the time delta (dt) between calls.

Controller dTerm = Controller.derivative(() -> 0.01);

Use the Controller.pid static factory method to create a standard Proportional-Integral-Derivative controller using the provided gains.

// kP, kI, kD
Controller pid = Controller.pid(1.0, 0.1, 0.01);

For more advanced integral control, use the overloaded integral method. This version allows you to prevent integral windup and manage accumulation more precisely using an 'iZone', a decay factor, and a maximum cap.

Parameters:

• kI: Supplier for the integral gain.
• iZone: Supplier for the error threshold; accumulation only occurs when |error| < iZone.
• decay: Supplier for a decay factor applied to the integral when within the zone.
• maxI: Supplier for the maximum absolute value the integral can reach (clamping).

Controller advancedIntegral = Controller.integral(
    () -> 0.5,   // kI
    () -> 0.1,   // iZone
    () -> 0.9,   // decay
    () -> 10.0   // maxI
);