PIDController.h

Go to the documentation of this file.

/**********************************************************************************************************************
This file is part of the Control Toolbox (https://github.com/ethz-adrl/control-toolbox), copyright by ETH Zurich.
Licensed under the BSD-2 license (see LICENSE file in main directory)
**********************************************************************************************************************/

#pragma once

#include <limits>

namespace ct {
namespace core {


template <typename SCALAR = double>
class PIDController
{
public:

    struct parameters_t
    {
        parameters_t(SCALAR kp = SCALAR(0.0),
            SCALAR ki = SCALAR(0.0),
            SCALAR kd = SCALAR(0.0),
            Time dt_ = 0.01,
            SCALAR Imax_ = std::numeric_limits<SCALAR>::max(),
            SCALAR uMax_ = std::numeric_limits<SCALAR>::max(),
            SCALAR uMin_ = -std::numeric_limits<SCALAR>::max())
            : k_p(kp), k_i(ki), k_d(kd), dt(dt_), Imax(Imax_), uMax(uMax_), uMin(uMin_)
        {
        }
        SCALAR k_p;   
        SCALAR k_i;   
        SCALAR k_d;   
        SCALAR dt;    
        SCALAR Imax;  
        SCALAR uMax;  
        SCALAR uMin;  
    };


    struct setpoint_t
    {
        setpoint_t(SCALAR stateDes = SCALAR(0.0), SCALAR stateDevDes = SCALAR(0.0))
            : stateDesired_(stateDes), stateDerivativeDesired_(stateDevDes)
        {
        }

        SCALAR stateDesired_;            
        SCALAR stateDerivativeDesired_;  
    };


    PIDController(const parameters_t& parameters = parameters_t(), const setpoint_t& setpoint = setpoint_t());

    PIDController(const PIDController& other);

    virtual ~PIDController();

    PIDController* clone() const;

    void setInitialState(const SCALAR& state);

    void setDesiredState(const SCALAR& state);

    void setDesiredState(const SCALAR& state, const SCALAR& stateDerivative);


    SCALAR computeControl(const SCALAR& state, const Time& t);


    SCALAR computeControl(const SCALAR& state, const SCALAR& stateDerivative, const Time& t);


    void changeParameters(const parameters_t& parameters);

    parameters_t& Parameters();

    void reset();

protected:
    SCALAR statePrevious_;  
    SCALAR I_;              

    parameters_t parameters_;  
    setpoint_t setpoint_;      

private:
    void saturateControl(SCALAR& u);

    void computeI(const SCALAR& error);
};

}  // namespace core
}  // namespace ct