This class encapsulates the fundamental principles of Proportional-Integral-Derivative (PID) control with an additional feedforward component. It provides a versatile control mechanism for various systems, enabling precise control of processes by adjusting an output in response to the error between a desired setpoint and a measured process variable. More...

#include <PIDController.h>

Public Member Functions
	PIDController (const double dKp, const double dKi, const double dKd, const double dKff=0.0)
	Construct a new PIDController::PIDController object.

double	Calculate (const double dActual, const double dSetpoint)
	Calculate the next control output given the current actual and a setpoint.

double	Calculate (const double dActual)
	Calculate the next control output given the current actual and using the previously set setpoint.

double	Calculate ()
	Calculates the control output using the last provided setpoint and actual.

void	EnableContinuousInput (const double dMinimumInput, const double dMaximumInput)
	Enables continuous wraparound of PID controller input. Use for setpoints that exists on a circle. For example, if using degrees for setpoint and actual calling this method with 0, 360 will treat 0 and 360 as the same number. This prevents the controller from going the long way around the circle when the setpoint and actual are near the wraparound point.

void	DisableContinuousInput ()
	Disable continuous input wraparound of the PID controller.

void	Reset ()
	Resets the controller. This erases the integral term buildup, and removes derivative term on the next iteration.

void	SetProportional (const double dKp)
	Configure the proportional gain parameter. This quickly responds to changes in setpoint, and provides most of the initial driving force to make corrections. Some systems can be used with only a P gain, and many can be operated with only PI. For position based controllers, Proportional gain the first parameter to tune, with integral gain second. For rate controlled systems, Proportional is often the second after feedforward.

void	SetIntegral (const double dKi)
	Configure the integral gain parameter. This is used for overcoming disturbances, and ensuring that the controller always minimizes error, when the control actual is close to the setpoint. Typically tuned second for "Position" based modes, and third for "Rate" or continuous based modes.

void	SetDerivative (const double dKd)
	Configure the derivative gain parameter. This acts as a brake or dampener on the control effort. The more the controller tries to change the value, the more it counteracts the effort. Typically this Parameter is tuned last and only used to reduce overshoot in systems. When using derivative gain, you can usually get a more responsive controller by over-tuning proportional gain so that small oscillations are visible and then bringing derivative gain up until the oscillations disappear.

void	SetFeedforward (const double dKff)
	Configure the feedforward gain parameter. This is excellent for velocity, rate, and other continuous control modes where you can expect a rough output value based solely on the setpoint. This should not be used in "position" based control modes.

void	SetPID (const double dKp, const double dKi, const double dKd)
	Mutator for PID gains of the controller.

void	SetPID (const double dKp, const double dKi, const double dKd, const double dKff)
	Mutator for PID and Feedforward gains of the controller.

void	SetSetpoint (const double dSetpoint)
	Mutator for the setpoint for the PID controller.

void	SetMaxSetpointDifference (const double dMaxSetpointDifference)
	Mutator for the maximum allowable distance of the setpoint from the actual value. This doesn't limit the setable value of the setpoint. It only limits the value that the controller is given specify the error from the setpoint.

void	SetMaxIntegralEffort (const double dMaxIEffort)
	Mutator for the max value of the integral term during PID calculation. This is useful for preventing integral wind-up runaways.

void	SetOutputLimits (const double dMinEffort, const double dMaxEffort)
	Mutator for setting the minimum and maximum allowable values of the control output from the controller.

void	SetOutputLimits (const double dMaxMin)
	Mutator for setting the minimum and maximum allowable values of the control output from the controller.

void	SetOutputRampRate (const double dOutputRampRate)
	Mutator for the maximum rate that the output can change per iteration.

void	SetOutputFilter (const double dStrength)
	Set a filter on the output to reduce sharp oscillations. 0.1 is likely a good starting point.

void	SetDirection (const bool bReversed=false)
	Set the operating direction of the PID controller. Set true to reverse PID output.

double	GetProportional () const
	Accessor for proportional gain of the PID controller.

double	GetIntegral () const
	Accessor for integral gain of the PID controller.

double	GetDerivative () const
	Accessor for derivative gain of the PID controller.

double	GetFeedforward () const
	Accessor for feedforward gain of the PID controller.

double	GetSetpoint () const
	Accessor for the current setpoint that the controller is trying to reach.

double	GetMaxSetpointDifference () const
	Accessor for the maximum allowable difference the setpoint can be from the actual. Doesn't limit the setpoint, just the max error. 0 = disabled.

double	GetMaxIntegralEffort () const
	Accessor for the maximum contribution of the integral term within the controller. 0 = disabled.

double	GetOutputRampRate () const
	Accessor the the maximum allowed output ramp rate of the PID controller.

double	GetOutputFilter () const
	Accessor for the exponential rolling sum filter strength. Used to reduce sharp output oscillations or jumps.

double	GetContinuousInputEnabled () const

bool	GetReversed () const
	Accessor for if the controller outputs are set to be negated or reversed.

Private Member Functions
void	CheckGainSigns ()
	To operate correctly, all PID parameters require the same sign.

Private Attributes
double	m_dKp

double	m_dKi

double	m_dKd

double	m_dKff

double	m_dSetpoint

double	m_dErrorSum

double	m_dMaxError

double	m_dMaxIEffort

double	m_dMinEffort

double	m_dMaxEffort

double	m_dLastActual

double	m_dOutputRampRate

double	m_dLastControlOutput

double	m_dOutputFilter

double	m_dMaxSetpointDifference

double	m_dMinimumContinuousInput

double	m_dMaximumContinuousInput

bool	m_bControllerIsContinuous

bool	m_bFirstCalculation

bool	m_bReversed

Detailed Description

This class encapsulates the fundamental principles of Proportional-Integral-Derivative (PID) control with an additional feedforward component. It provides a versatile control mechanism for various systems, enabling precise control of processes by adjusting an output in response to the error between a desired setpoint and a measured process variable.

The key features of this class include:

Proportional Control: The proportional gain (Kp) component adjusts the control output in proportion to the current error.
Integral Control: The integral gain (Ki) component accumulates past errors to eliminate steady-state error.
Derivative Control: The derivative gain (Kd) component anticipates future error by considering the rate of change of the error.
Feedforward Control: The feedforward gain (Kff) allows for predictive control, improving response time and minimizing overshoot. See https://blog.opticontrols.com/archives/297 for a better explanation on feedforward controller.

Additionally, this PID controller offers an optional wraparound feature. When enabled, it can be used for systems with non-linear, circular, or cyclic setpoints, effectively managing control in such scenarios.

This class is a valuable tool for control engineering, robotics, and automation, allowing you to fine-tune the control behavior of various processes and systems.

For specific details on class attributes and methods, please refer to the class documentation.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-16

Constructor & Destructor Documentation

◆ PIDController()

controllers::PIDController::PIDController	(	const double	dKp,
		const double	dKi,
		const double	dKd,
		const double	dKff = `0.0`
	)

Construct a new PIDController::PIDController object.

Parameters

dKp	- The proportional gain (Kp) component adjusts the control output in proportion to the current error.
dKi	- The integral gain (Ki) component accumulates past errors to eliminate steady-state error.
dKd	- The derivative gain (Kd) component anticipates future error by considering the rate of change of the error.
dKff	- The feedforward gain (Kff) allows for predictive control, improving response time and minimizing overshoot.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Initialize member variable.
        m_dKp                     = dKp;
        m_dKi                     = dKi;
        m_dKd                     = dKd;
        m_dKff                    = dKff;
        m_dSetpoint               = 0.0;
        m_dErrorSum               = 0.0;
        m_dMaxError               = 0.0;
        m_dMaxIEffort             = 0.0;
        m_dMinEffort              = 0.0;
        m_dMaxEffort              = 0.0;
        m_dLastActual             = 0.0;
        m_dOutputRampRate         = 0.0;
        m_dLastControlOutput      = 0.0;
        m_dOutputFilter           = 0.0;
        m_dMaxSetpointDifference  = 0.0;
        m_dMinimumContinuousInput = 0.0;
        m_dMaximumContinuousInput = 360.0;
        m_bControllerIsContinuous = false;
        m_bFirstCalculation       = true;
        m_bReversed               = false;
    }

Member Function Documentation

◆ Calculate() [1/3]

double controllers::PIDController::Calculate	(	const double	dActual,
		const double	dSetpoint
	)

Calculate the next control output given the current actual and a setpoint.

Parameters

dActual	- The current actual position of the system.
dSetpoint	- The desired setpoint of the controller.

Returns: double - The resultant PID controller output.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Create instance variables.
        double dPTermOutput;
        double dITermOutput;
        double dDTermOutput;
        double dFFTermOutput;
        double dOutput;
 
        // Update setpoint member variable.
        m_dSetpoint = dSetpoint;
 
        // Apply the sliding setpoint range adjust if necessary.
        if (m_dMaxSetpointDifference != 0)
        {
            // Clamp current setpoint value within a certain range of the current actual.
            m_dSetpoint = numops::Clamp(m_dSetpoint, dActual - m_dMaxSetpointDifference, dActual + m_dMaxSetpointDifference);
        }
 
        // Determine error from setpoint.
        double dError = dSetpoint - dActual;
 
        // Check if the input, and therefor controller is continuous.
        if (m_bControllerIsContinuous)
        {
            // Calculate error bounds.
            double dErrorBound = (m_dMaximumContinuousInput - m_dMinimumContinuousInput) / 2.0;
            // Wrap heading.
            dError = numops::InputAngleModulus(dError, -dErrorBound, dErrorBound);
        }
 
        // Calculate feedforward term.
        dFFTermOutput = m_dKff * dSetpoint;
        // Calculate proportional term.
        dPTermOutput = m_dKp * dError;
 
        // Check if this is the first time doing a calculation.
        if (m_bFirstCalculation)
        {
            // Assume the process variable hold same as previous.
            m_dLastActual = dActual;
            // Assume the last output is the current time-independent output.
            m_dLastControlOutput = dPTermOutput + dFFTermOutput;
 
            // Set first calculation toggle to false.
            m_bFirstCalculation = false;
        }
 
        // Calculate derivative term.
        // Note, derivative is actually negative and "slows" the system if it's doing
        // the correct thing. Small gain values help prevent output spikes and overshoot.
        dDTermOutput  = -m_dKd * (dActual - m_dLastActual);
        m_dLastActual = dActual;
 
        // Calculate integral term.
        // The integral term is more complex. There's several things to factor in to make it easier to deal with.
        // 1. m_dMaxIEffort restricts the amount of output contributed by the integral term.
        // 2. prevent windup by not increasing errorSum if we're already running against our max Ioutput
        // 3. prevent windup by not increasing errorSum if output is output=maxOutput
        dITermOutput = m_dKi * m_dErrorSum;
        // Apply integral term limits.
        if (m_dMaxIEffort != 0)
        {
            // Clamp current integral term output.
            dITermOutput = numops::Clamp(dITermOutput, -m_dMaxIEffort, m_dMaxIEffort);
        }
 
        // Here's PID!
        dOutput = dFFTermOutput + dPTermOutput + dITermOutput + dDTermOutput;
        // Check if error is at not at limits.
        if (m_dMinEffort != m_dMaxEffort && !numops::Bounded(dOutput, m_dMinEffort, m_dMaxEffort))
        {
            // Reset the error to a sane level. Settings to the current error ensures a smooth transition when the P term
            // decreases enough for the I term to start acting upon the controller properly.
            m_dErrorSum = dError;
        }
        // Check if the error is within the allowed ramp rate compared to the last output.
        else if (m_dOutputRampRate != 0 && !numops::Bounded(dOutput, m_dLastControlOutput - m_dOutputRampRate, m_dLastControlOutput + m_dOutputRampRate))
        {
            // Reset the error to a sane level. Settings to the current error ensures a smooth transition when the P term
            // decreases enough for the I term to start acting upon the controller properly.
            m_dErrorSum = dError;
        }
        // Check if integral term output should be limited.
        else if (m_dMaxIEffort != 0)
        {
            // In addition to output limiting directly, we also want to prevent integral term wind-up. Restrict directly.
            m_dErrorSum = numops::Clamp(m_dErrorSum + dError, -m_dMaxError, m_dMaxError);
        }
        else
        {
            // Accumulate error.
            m_dErrorSum += dError;
        }
 
        // Restrict output to our specified ramp limits.
        if (m_dOutputRampRate != 0)
        {
            // Clamp output to ramp rate.
            dOutput = numops::Clamp(dOutput, m_dLastControlOutput - m_dOutputRampRate, m_dLastControlOutput + m_dOutputRampRate);
        }
        // Restrict output to our specified effort limits.
        if (m_dMinEffort != m_dMaxEffort)
        {
            // Clamp output to effort limits.
            dOutput = numops::Clamp(dOutput, m_dMinEffort, m_dMaxEffort);
        }
        // Reduce jitters and output spikes with an exponential rolling sum filter.
        if (m_dOutputFilter != 0)
        {
            // Filter output effort.
            dOutput = (m_dLastControlOutput * m_dOutputFilter) + (dOutput * (1 - m_dOutputFilter));
        }
 
        // Update last output member variable.
        m_dLastControlOutput = dOutput;
 
        // Return the PID controller calculated output effort.
        return dOutput;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Calculate() [2/3]

double controllers::PIDController::Calculate ( const double dActual )

Calculate the next control output given the current actual and using the previously set setpoint.

Parameters

dActual - The current actual position of the system.

Returns: double - The resultant PID controller output.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Calculate and return the output from the PIDController using the same setpoint.
        return this->Calculate(dActual, m_dSetpoint);
    }

Here is the call graph for this function:

◆ Calculate() [3/3]

double controllers::PIDController::Calculate ( )

Calculates the control output using the last provided setpoint and actual.

Returns: double - The resultant PID controller output.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Calculate and return the output from the PIDController using the previous actual and setpoint.
        return this->Calculate(m_dLastActual, m_dSetpoint);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EnableContinuousInput()

void controllers::PIDController::EnableContinuousInput	(	const double	dMinimumInput,
		const double	dMaximumInput
	)

Enables continuous wraparound of PID controller input. Use for setpoints that exists on a circle. For example, if using degrees for setpoint and actual calling this method with 0, 360 will treat 0 and 360 as the same number. This prevents the controller from going the long way around the circle when the setpoint and actual are near the wraparound point.

Parameters

dMinimumInput	- Minimum input before wraparound.
dMaximumInput	- Maximum input before wraparound.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Assign member variables.
        m_dMinimumContinuousInput = dMinimumInput;
        m_dMaximumContinuousInput = dMaximumInput;
 
        // Enable continuous input.
        m_bControllerIsContinuous = true;
    }

Here is the caller graph for this function:

◆ DisableContinuousInput()

void controllers::PIDController::DisableContinuousInput ( )

Disable continuous input wraparound of the PID controller.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Disable continuous input.
        m_bControllerIsContinuous = false;
    }

Here is the caller graph for this function:

◆ Reset()

void controllers::PIDController::Reset ( )

Resets the controller. This erases the integral term buildup, and removes derivative term on the next iteration.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Reset necessary values to reset the controller.
        m_bFirstCalculation = true;
        m_dErrorSum         = 0.0;
    }

Here is the caller graph for this function:

◆ SetProportional()

void controllers::PIDController::SetProportional ( const double dKp )

Configure the proportional gain parameter. This quickly responds to changes in setpoint, and provides most of the initial driving force to make corrections. Some systems can be used with only a P gain, and many can be operated with only PI. For position based controllers, Proportional gain the first parameter to tune, with integral gain second. For rate controlled systems, Proportional is often the second after feedforward.

Parameters

dKp	- The proportional gain for the controller to use for calculation.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Assign member variables.
        m_dKp = dKp;
 
        // Check signs of gains.
        this->CheckGainSigns();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetIntegral()

void controllers::PIDController::SetIntegral ( const double dKi )

Configure the integral gain parameter. This is used for overcoming disturbances, and ensuring that the controller always minimizes error, when the control actual is close to the setpoint. Typically tuned second for "Position" based modes, and third for "Rate" or continuous based modes.

Parameters

dKi	- The integral gain for the controller to use for calculation.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Check if the current I gain is not zero and we need to scale our current error.
        if (m_dKi != 0)
        {
            // Scale the current error sum, to match the new integral gain.
            m_dErrorSum = m_dErrorSum * (m_dKi / dKi);
        }
        // Check if max integral term effort is enabled.
        if (m_dMaxIEffort != 0)
        {
            // Update max error from new integral and max effort.
            m_dMaxError = m_dMaxIEffort / dKi;
        }
 
        // Assign integral gain member variable.
        m_dKi = dKi;
 
        // Check the signs of the PID gains.
        this->CheckGainSigns();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetDerivative()

void controllers::PIDController::SetDerivative ( const double dKd )

Configure the derivative gain parameter. This acts as a brake or dampener on the control effort. The more the controller tries to change the value, the more it counteracts the effort. Typically this Parameter is tuned last and only used to reduce overshoot in systems. When using derivative gain, you can usually get a more responsive controller by over-tuning proportional gain so that small oscillations are visible and then bringing derivative gain up until the oscillations disappear.

Parameters

dKd	- The derivative gain for the controller to use for calculation.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Assign member variables.
        m_dKd = dKd;
 
        // Check signs of gains.
        this->CheckGainSigns();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetFeedforward()

void controllers::PIDController::SetFeedforward ( const double dKff )

Configure the feedforward gain parameter. This is excellent for velocity, rate, and other continuous control modes where you can expect a rough output value based solely on the setpoint. This should not be used in "position" based control modes.

Parameters

dKff	- The feedforward gain for the controller to use for calculation.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Assign member variables.
        m_dKff = dKff;
 
        // Check signs of gains.
        this->CheckGainSigns();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetPID() [1/2]

void controllers::PIDController::SetPID	(	const double	dKp,
		const double	dKi,
		const double	dKd
	)

Mutator for PID gains of the controller.

Parameters

dKp	- The proportional gain for the controller to use for calculation.
dKi	- The integral gain for the controller to use for calculation.
dKd	- The derivative gain for the controller to use for calculation.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Update member variables.
        m_dKp = dKp;
        m_dKd = dKd;
 
        // Call SetIntegral since is scales the accumulated error and checks signs.
        this->SetIntegral(dKi);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetPID() [2/2]

void controllers::PIDController::SetPID	(	const double	dKp,
		const double	dKi,
		const double	dKd,
		const double	dKff
	)

Mutator for PID and Feedforward gains of the controller.

Parameters

dKp	- The proportional gain for the controller to use for calculation.
dKi	- The integral gain for the controller to use for calculation.
dKd	- The derivative gain for the controller to use for calculation.
dKff	- The feedforward gain for the controller to use for calculation.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Update member variables.
        m_dKp  = dKp;
        m_dKd  = dKd;
        m_dKff = dKff;
 
        // Call SetIntegral since is scales the accumulated error and checks signs.
        this->SetIntegral(dKi);
    }

Here is the call graph for this function:

◆ SetSetpoint()

void controllers::PIDController::SetSetpoint ( const double dSetpoint )

Mutator for the setpoint for the PID controller.

Parameters

dSetpoint - The setpoint that the controller should aim to get the actual to.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Assign member variable.
        m_dSetpoint = dSetpoint;
    }

Here is the caller graph for this function:

◆ SetMaxSetpointDifference()

void controllers::PIDController::SetMaxSetpointDifference ( const double dMaxSetpointDifference )

Mutator for the maximum allowable distance of the setpoint from the actual value. This doesn't limit the setable value of the setpoint. It only limits the value that the controller is given specify the error from the setpoint.

Parameters

dMaxSetpointDifference - The allowable distance of the setpoint from the actual.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Assign member variables.
        m_dMaxSetpointDifference = dMaxSetpointDifference;
    }

Here is the caller graph for this function:

◆ SetMaxIntegralEffort()

void controllers::PIDController::SetMaxIntegralEffort ( const double dMaxIEffort )

Mutator for the max value of the integral term during PID calculation. This is useful for preventing integral wind-up runaways.

Parameters

dMaxIEffort - The max allowable value of the integral term.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Assign member variable.
        m_dMaxIEffort = dMaxIEffort;
    }

Here is the caller graph for this function:

◆ SetOutputLimits() [1/2]

void controllers::PIDController::SetOutputLimits	(	const double	dMinEffort,
		const double	dMaxEffort
	)

Mutator for setting the minimum and maximum allowable values of the control output from the controller.

Parameters

dMinEffort	- The minimum allowable output from the PID controller.
dMaxEffort	- The maximum allowable output from the PID controller.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Check if the maximum is greater than the minimum.
        if (dMaxEffort > dMinEffort)
        {
            // Assign member variables.
            m_dMinEffort = dMinEffort;
            m_dMaxEffort = dMaxEffort;
 
            // Ensure the bounds of the integral term are within the bounds of the allowable output range.
            if (m_dMaxIEffort == 0 || m_dMaxIEffort > (dMaxEffort - dMinEffort))
            {
                // Set new integral max output.
                this->SetMaxIntegralEffort(dMaxEffort - dMinEffort);
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetOutputLimits() [2/2]

void controllers::PIDController::SetOutputLimits ( const double dMinMax )

Mutator for setting the minimum and maximum allowable values of the control output from the controller.

Parameters

dMinMax - The overall output range of the controller. Must be positive.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Set output limits with the same max and min.
        this->SetOutputLimits(-dMinMax, dMinMax);
    }

Here is the call graph for this function:

◆ SetOutputRampRate()

void controllers::PIDController::SetOutputRampRate ( const double dOutputRampRate )

Mutator for the maximum rate that the output can change per iteration.

Parameters

dOutputRampRate - The maximum ramp rate of the output for the controller.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Assign member variable.
        m_dOutputRampRate = dOutputRampRate;
    }

Here is the caller graph for this function:

◆ SetOutputFilter()

void controllers::PIDController::SetOutputFilter ( const double dStrength )

Set a filter on the output to reduce sharp oscillations. 0.1 is likely a good starting point.

Parameters

dStrength - The output filtering strength.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Check if the strength is valid.
        if (dStrength == 0 || numops::Bounded(dStrength, 0.0, 1.0))
        {
            // Assign member variable.
            m_dOutputFilter = dStrength;
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetDirection()

void controllers::PIDController::SetDirection ( const bool bReversed = false )

Set the operating direction of the PID controller. Set true to reverse PID output.

Parameters

bReversed - Whether or not eh PID output should be negated.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Assign member variable.
        m_bReversed = bReversed;
    }

Here is the caller graph for this function:

◆ GetProportional()

double controllers::PIDController::GetProportional ( ) const

Accessor for proportional gain of the PID controller.

Returns: double - dKp proportional gain of the controller.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Return the member variable.
        return m_dKp;
    }

Here is the caller graph for this function:

◆ GetIntegral()

double controllers::PIDController::GetIntegral ( ) const

Accessor for integral gain of the PID controller.

Returns: double - dKi integral gain of the controller.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Return the member variable.
        return m_dKi;
    }

Here is the caller graph for this function:

◆ GetDerivative()

double controllers::PIDController::GetDerivative ( ) const

Accessor for derivative gain of the PID controller.

Returns: double - dKd derivative gain of the controller.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Return the member variable.
        return m_dKd;
    }

Here is the caller graph for this function:

◆ GetFeedforward()

double controllers::PIDController::GetFeedforward ( ) const

Accessor for feedforward gain of the PID controller.

Returns: double - dKff feedforward gain of the controller.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Return the member variable.
        return m_dKff;
    }

Here is the caller graph for this function:

◆ GetSetpoint()

double controllers::PIDController::GetSetpoint ( ) const

Accessor for the current setpoint that the controller is trying to reach.

Returns: double - The current setpoint.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Return the member variable.
        return m_dSetpoint;
    }

Here is the caller graph for this function:

◆ GetMaxSetpointDifference()

double controllers::PIDController::GetMaxSetpointDifference ( ) const

Accessor for the maximum allowable difference the setpoint can be from the actual. Doesn't limit the setpoint, just the max error. 0 = disabled.

Returns: double - The maximum setpoint difference from the actual.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Return the member variable.
        return m_dMaxSetpointDifference;
    }

Here is the caller graph for this function:

◆ GetMaxIntegralEffort()

double controllers::PIDController::GetMaxIntegralEffort ( ) const

Accessor for the maximum contribution of the integral term within the controller. 0 = disabled.

Returns: double - The maximum allowed integral value.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Return the member variable.
        return m_dMaxIEffort;
    }

Here is the caller graph for this function:

◆ GetOutputRampRate()

double controllers::PIDController::GetOutputRampRate ( ) const

Accessor the the maximum allowed output ramp rate of the PID controller.

Returns: double - The max ramp rate of the controller output.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Return the member variable.
        return m_dOutputRampRate;
    }

Here is the caller graph for this function:

◆ GetOutputFilter()

double controllers::PIDController::GetOutputFilter ( ) const

Accessor for the exponential rolling sum filter strength. Used to reduce sharp output oscillations or jumps.

Returns: double - Strength of the output filtering.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Return the member variable.
        return m_dOutputFilter;
    }

Here is the caller graph for this function:

◆ GetReversed()

bool controllers::PIDController::GetReversed ( ) const

Accessor for if the controller outputs are set to be negated or reversed.

Returns: true - The output is negated.; false - The output is not negated.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-19

    {
        // Return the member variable.
        return m_bReversed;
    }

Here is the caller graph for this function:

◆ CheckGainSigns()

void controllers::PIDController::CheckGainSigns ( )

private

To operate correctly, all PID parameters require the same sign.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-10-17

    {
        // Check if the gains are supposed to be reversed.
        if (m_bReversed)
        {
            // All values should be below zero.
            if (m_dKp > 0)
            {
                // Flip sign sign for proportional gain.
                m_dKi *= -1;
            }
            if (m_dKi > 0)
            {
                // Flip sign for integral gain.
                m_dKi *= -1;
            }
            if (m_dKd > 0)
            {
                // Flip sign for derivative gain.
                m_dKd *= -1;
            }
            if (m_dKff > 0)
            {
                // Flip sign for feedforward gain.
                m_dKff *= -1;
            }
        }
        else
        {
            // All values should be above zero.
            if (m_dKp < 0)
            {
                // Flip sign sign for proportional gain.
                m_dKi *= -1;
            }
            if (m_dKi < 0)
            {
                // Flip sign for integral gain.
                m_dKi *= -1;
            }
            if (m_dKd < 0)
            {
                // Flip sign for derivative gain.
                m_dKd *= -1;
            }
            if (m_dKff < 0)
            {
                // Flip sign for feedforward gain.
                m_dKff *= -1;
            }
        }
    }

Here is the caller graph for this function:

The documentation for this class was generated from the following files:

src/algorithms/controllers/PIDController.h
src/algorithms/controllers/PIDController.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PIDController()

Member Function Documentation

◆ Calculate() [1/3]

◆ Calculate() [2/3]

◆ Calculate() [3/3]

◆ EnableContinuousInput()

◆ DisableContinuousInput()

◆ Reset()

◆ SetProportional()

◆ SetIntegral()

◆ SetDerivative()

◆ SetFeedforward()

◆ SetPID() [1/2]

◆ SetPID() [2/2]

◆ SetSetpoint()

◆ SetMaxSetpointDifference()

◆ SetMaxIntegralEffort()

◆ SetOutputLimits() [1/2]

◆ SetOutputLimits() [2/2]

◆ SetOutputRampRate()

◆ SetOutputFilter()

◆ SetDirection()

◆ GetProportional()

◆ GetIntegral()

◆ GetDerivative()

◆ GetFeedforward()

◆ GetSetpoint()

◆ GetMaxSetpointDifference()

◆ GetMaxIntegralEffort()

◆ GetOutputRampRate()

◆ GetOutputFilter()

◆ GetReversed()

◆ CheckGainSigns()