CasserolePID

java.lang.Object
- org.usfirst.frc.team1736.lib.CasserolePID.CasserolePID

Direct Known Subclasses:

AdvancedCasserolePID
```
public abstract class CasserolePID
extends java.lang.Object
```
DESCRIPTION:
PID Controller algorithm designed by FRC1736 Robot Casserole. The WPIlib PID library is pretty darn good, but we had some things we wanted done differently. Therefore, we did it ourselves.
This controller implements a "PIDFdFP2" controller, with a few selectable options. Execution runs at 10ms (2x speed of *periodic() loops from FRC), this will be made adjustable in the future. Output each loop is simply the sum of each term, with not memory of previous outputs (except in the integral term). Output can be capped to a specific range, and the integral term can turn itself off when the error is too big (prevents windup). More features to be added in the future!
TERMS IN CALCULATION:
- Proportional - The error, equal to "setpoint - actual", multiplied by a gain. The simplest form of feedback, should push a system toward the setpoint.
- Integral - The integral of the error over time, multiplied by a gain. Helps with correcting for small errors that exist over longer periods of time, when the P term alone is not sufficient.
- Derivative - The derivative of the error, or of the actual value(user selects), multiplied by a gain. Helps to rate-limit the P term's action to reduce overshoot and increase stability (to a point).
- Feed-Forward - The setpoint, multiplied by a gain. Helps get the system to a zero error state for systems where there is a linear relationship between setpoint and "ideal system" control value (Think shooter wheel - more motor command means more speed. For a speed-based setpoint, there is a linear relationship between control effort (motor command) and setpoint)
- Feed-Forward - The setpoint's derivative, multiplied by a gain. Helps in scenarios where when the setpoint changes, it's useful to give the system a single "knock". Think using a motor to control to a certain angle - you'll need lots of effort when the setpoint first changes, but ideally no effort once you've gotten to the right place.
- Proportional Squared - The error squared but with sign preserved, multiplied by a gain. Helpful in non-linear systems, and when you can afford to be very aggressive when error is large.
USAGE:
1. Create new class as a super of this one
2. Override methods to set PID output and return feedback to the algorithm.
3. Call start() method to begin background execution of algorithm.

Field Summary

Fields
Modifier and Type	Field and Description
`protected double`	`curError`
`protected double`	`integratorDisableThresh`
`protected boolean`	`invertActual`
`protected boolean`	`invertOutput`
`protected double`	`Kd`
`protected double`	`Kdf`
`protected double`	`Kf`
`protected double`	`Ki`
`protected double`	`Kp`
`protected double`	`Kp2`
`protected double`	`outputMax`
`protected double`	`outputMin`
`double`	`setpoint`
`java.lang.String`	`threadName`
`protected boolean`	`useErrForDerivTerm`
`protected long`	`watchdogCounter`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`CasserolePID(double Kp_in, double Ki_in, double Kd_in)` Simple Constructor
`protected`	`CasserolePID(double Kp_in, double Ki_in, double Kd_in, double Kf_in, double Kdf_in, double Kp2_in)` More-Complex Constructor

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`getCurError()`
`double`	`getKd()`
`double`	`getKdf()`
`double`	`getKf()`
`double`	`getKi()`
`double`	`getKp()`
`double`	`getKp2()`
`double`	`getSetpoint()`
`protected void`	`periodicUpdate()`
`void`	`resetIntegrators()` Reset all internal integrators back to zero.
`protected abstract double`	`returnPIDInput()` Override this method! This function must be implemented to return the present "actual" value of the system under control.
`void`	`setActualAsDerivTermSrc()` Call this method to set up the algorithm to utilize only the actual (sensor feedback) value for the derivative term calculation.
`void`	`setErrorAsDerivTermSrc()` Call this method to set up the algorithm to utilize the error between setpoint and actual for the derivative term calculation.
`void`	`setintegratorDisableThresh(double integratorDisableThresh_in)` Set the Integral term disable threshold.
`void`	`setKd(double kd)`
`void`	`setKdf(double kdf)`
`void`	`setKf(double kf)`
`void`	`setKi(double ki)`
`void`	`setKp(double kp)`
`void`	`setKp2(double kp2)`
`void`	`setOutputInverted(boolean inv)` Sets the control effort to be inverted from the normal calculation
`void`	`setOutputRange(double min, double max)` Set limits on what the control effort (output) can be commanded to.
`void`	`setSensorInverted(boolean inv)` Sets the sensor input (actual) to be inverted in the normal calculation
`void`	`setSetpoint(double setpoint_in)` Assign a new setpoint for the algorithm to control to.
`void`	`start()` Start the PID thread running.
`void`	`stop()` Stop whatever thread may or may not be running.
`protected abstract void`	`usePIDOutput(double pidOutput)` Override this method! This function will return the value calculated from the PID.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - Kp
```
protected double Kp
```
  - Ki
```
protected double Ki
```
  - Kd
```
protected double Kd
```
  - Kf
```
protected double Kf
```
  - Kdf
```
protected double Kdf
```
  - Kp2
```
protected double Kp2
```
  - curError
```
protected double curError
```
  - useErrForDerivTerm
```
protected boolean useErrForDerivTerm
```
  - invertOutput
```
protected boolean invertOutput
```
  - invertActual
```
protected boolean invertActual
```
  - setpoint
```
public volatile double setpoint
```
  - outputMin
```
protected double outputMin
```
  - outputMax
```
protected double outputMax
```
  - integratorDisableThresh
```
protected double integratorDisableThresh
```
  - watchdogCounter
```
protected volatile long watchdogCounter
```
  - threadName
```
public java.lang.String threadName
```
- Constructor Detail
  - CasserolePID
```
protected CasserolePID(double Kp_in,
                       double Ki_in,
                       double Kd_in)
```
    Simple Constructor
    
    Parameters:
    
    Kp_in - Proportional Term Gain
    
    Ki_in - Integral Term Gain
    
    Kd_in - Derivative Term Gain
  - CasserolePID
```
protected CasserolePID(double Kp_in,
                       double Ki_in,
                       double Kd_in,
                       double Kf_in,
                       double Kdf_in,
                       double Kp2_in)
```
    More-Complex Constructor
    
    Parameters:
    
    Kp_in - Proportional Term Gain
    
    Ki_in - Integral Term Gain
    
    Kd_in - Derivative Term Gain
    
    Kf_in - Setpoint Feed-Forward Term Gain
    
    Kdf_in - Setpoint Derivative Feed-Forward Term Gain
    
    Kp2_in - Proportional Squared Term Gain
- Method Detail
  - start
```
public void start()
```
    Start the PID thread running. Will begin to call the returnPIDInput and usePIDOutput methods asynchronously.
  - stop
```
public void stop()
```
    Stop whatever thread may or may not be running. Will finish the current calculation loop, so returnPIDInput and usePIDOutput might get called one more time after this function gets called.
  - resetIntegrators
```
public void resetIntegrators()
```
    Reset all internal integrators back to zero. Useful for returning to init-state conditions.
  - setSetpoint
```
public void setSetpoint(double setpoint_in)
```
    Assign a new setpoint for the algorithm to control to.
  - setOutputInverted
```
public void setOutputInverted(boolean inv)
```
    Sets the control effort to be inverted from the normal calculation
    
    Parameters:
    
    inv -
  - setSensorInverted
```
public void setSensorInverted(boolean inv)
```
    Sets the sensor input (actual) to be inverted in the normal calculation
    
    Parameters:
    
    inv -
  - getCurError
```
public double getCurError()
```
  - returnPIDInput
```
protected abstract double returnPIDInput()
```
    Override this method! This function must be implemented to return the present "actual" value of the system under control. For example, when controlling a motor to turn a certain number of rotations, this should return the encoder count or number of degrees or something like that. You must implement this! Expect it to be called frequently and asynchronously by the underlying PID algorithm. Make sure it runs fast!
    
    Returns:
    
    The sensor feedback value for the PID algorithm to use.
  - usePIDOutput
```
protected abstract void usePIDOutput(double pidOutput)
```
    Override this method! This function will return the value calculated from the PID. Expect it to be called frequently and asynchronously by the underlying PID algorithm. When it is called, you should utilize the value given to do something useful. For example, when controlling a motor to turn a certain number of rotations, your implementation of this function should send the output of the PID to one of the motor controllers. Make sure it runs fast!
    
    Parameters:
    
    pidOutput - The control effort output calculated by the PID algorithm
  - periodicUpdate
```
protected void periodicUpdate()
```
  - setErrorAsDerivTermSrc
```
public void setErrorAsDerivTermSrc()
```
    Call this method to set up the algorithm to utilize the error between setpoint and actual for the derivative term calculation.
  - setActualAsDerivTermSrc
```
public void setActualAsDerivTermSrc()
```
    Call this method to set up the algorithm to utilize only the actual (sensor feedback) value for the derivative term calculation.
  - getKp
```
public double getKp()
```
    Returns:
    
    The present Proportional term gain
  - setKp
```
public void setKp(double kp)
```
    Parameters:
    
    kp - the kp to set
  - getKi
```
public double getKi()
```
    Returns:
    
    The present Integral term gain
  - setKi
```
public void setKi(double ki)
```
    Parameters:
    
    ki - the ki to set
  - getKd
```
public double getKd()
```
    Returns:
    
    The present Derivative term gain
  - setKd
```
public void setKd(double kd)
```
    Parameters:
    
    kd - the kd to set
  - getKf
```
public double getKf()
```
    Returns:
    
    The present feed-forward term gain
  - setKf
```
public void setKf(double kf)
```
    Parameters:
    
    kf - the kf to set
  - getKdf
```
public double getKdf()
```
    Returns:
    
    The present derivative feed-forward term gain
  - setKdf
```
public void setKdf(double kdf)
```
    Parameters:
    
    kdf - the kdf to set
  - getKp2
```
public double getKp2()
```
    Returns:
    
    The present Proportional-squared term gain
  - setKp2
```
public void setKp2(double kp2)
```
    Parameters:
    
    kp2 - the kp2 to set
  - setOutputRange
```
public void setOutputRange(double min,
                           double max)
```
    Set limits on what the control effort (output) can be commanded to.
    
    Parameters:
    
    min - Smallest allowed control effort
    
    max - Largest allowed control effort
  - getSetpoint
```
public double getSetpoint()
```
    Returns:
    
    The present setpoint
  - setintegratorDisableThresh
```
public void setintegratorDisableThresh(double integratorDisableThresh_in)
```
    Set the Integral term disable threshold. If the absolute value of the error goes above this threshold, the integral term will be set to zero AND the integrators will internally reset their accumulators to zero. Once the error gets below this threshold, the integrators will resume integrating and contributing to the control effort. This is a mechanism to help prevent integrator windup in high-error conditions. By default it is disabled (threshold = positive infinity).
    
    Parameters:
    
    integratorDisableThresh_in - The new threshold to use.

Class CasserolePID

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

Kp

Ki

Kd

Kf

Kdf

Kp2

curError

useErrForDerivTerm

invertOutput

invertActual

setpoint

outputMin

outputMax

integratorDisableThresh

watchdogCounter

threadName

Constructor Detail

CasserolePID

CasserolePID

Method Detail

start

stop

resetIntegrators

setSetpoint

setOutputInverted

setSensorInverted

getCurError

returnPIDInput

usePIDOutput

periodicUpdate

setErrorAsDerivTermSrc

setActualAsDerivTermSrc

getKp

setKp

getKi

setKi

getKd

setKd

getKf

setKf

getKdf

setKdf

getKp2

setKp2

setOutputRange

getSetpoint

setintegratorDisableThresh