pid_s.h

Go to the documentation of this file.

 * @details
 * This file defines the @ref control_system::pid::PID_S class, which
 * implements a proportional-integral-derivative (PID) controller with
 * configurable derivative filtering and feed-forward control.
 *
 * The controller provides access to the individual proportional,
 * integral, and derivative contributions as well as the final control
 * output.
 *
 * @tparam T Numeric data type used for the controller calculations.
 *
 * @author Abhinay Kumar
 * @version 1.0.0
 * @date 2026-08-11
 *
 * @copyright
 * Copyright (c) 2026 Abhinay Kumar
 */
 
#ifndef CONTROL_SYSTEM_PID_PID_S_H
#define CONTROL_SYSTEM_PID_PID_S_H
 
#include "filters.h"
#include "../utility/utility.h"
 
namespace control_system
{
    /**
     * @namespace control_system
     * @brief Contains control-system algorithms and controllers.
     */
 
    namespace pid
    {


         * @brief PID controller with configurable derivative filtering.
         *
         * @details
         * The PID_S class implements a PID controller with configurable
         * proportional, integral, and derivative time constants.
         *
         * The derivative term can optionally be filtered using a first-order
         * low-pass filter. A feed-forward term can also be included in the
         * controller output.
         *
         * The controller provides configurable integral and output limits
         * and maintains its control state between successive updates.
         *
         * @tparam T Numeric data type used for the controller.
         *
         * @par Example
         * @code{.cpp}
         * control_system::pid::PID_S<double> controller;
         *
         * controller.init(
         *     0.001,
         *     Kp,
         *     Ti,
         *     Td,
         *     I_max,
         *     u_max
         * );
         *
         * double output = controller.update(reference, measurement);
         * @endcode
         */
        template <typename T>
        class PID_S
        {
        public:
            PID_S();

             * @brief Initializes the PID controller.
             *
             * @param[in] dt_ Controller sampling time in seconds.
             * @param[in] Kp_ Proportional gain.
             * @param[in] T_i_ Integral time constant.
             * @param[in] T_d_ Derivative time constant.
             * @param[in] I_max_ Maximum allowed integral contribution.
             * @param[in] u_max_ Maximum allowed controller output.
             * @param[in] d_filter_ Enables or disables derivative filtering.
             * @param[in] fc_ Cutoff frequency of the derivative filter in Hz.
             *
             * @details
             * Initializes the PID controller parameters and optionally
             * configures the derivative low-pass filter.
             */
            void init(T dt_, T Kp_, T T_i_, T T_d_, T I_max_, T u_max_, bool d_filter_ = false, T fc_ = 10.0);

             * @brief Sets the PID controller parameters.
             *
             * @param[in] dt_ Controller sampling time in seconds.
             * @param[in] Kp_ Proportional gain.
             * @param[in] T_i_ Integral time constant.
             * @param[in] T_d_ Derivative time constant.
             * @param[in] I_max_ Maximum allowed integral contribution.
             * @param[in] u_max_ Maximum allowed controller output.
             * @param[in] d_filter_ Enables or disables derivative filtering.
             * @param[in] fc_ Cutoff frequency of the derivative filter in Hz.
             *
             * @details
             * Updates the PID controller parameters and derivative filter
             * configuration.
             */
            void set_param(T dt_, T Kp_, T T_i_, T T_d_, T I_max_, T u_max_, bool d_filter_ = false, T fc_ = 10.0);

             * @brief Computes the PID control output.
             *
             * @param[in] x_0 Reference or desired value.
             * @param[in] x Current or measured value.
             * @param[in] u_ff_ Feed-forward control input.
             *
             * @return PID controller output.
             *
             * @details
             * Calculates the proportional, integral, derivative, and
             * feed-forward contributions and combines them to produce
             * the controller output.
             *
             * The integral contribution and controller output are subject
             * to their configured limits.
             */
            T update(T x_0, T x, T u_ff_ = 0.0);

             * @brief Resets the PID controller state.
             *
             * @details
             * Resets the stored control error, proportional, integral,
             * derivative, and controller output states.
             */
            void reset();


             * output.
             *
             * @details
             * Updates the controller state using an externally provided
             * previous controller output.
             */
            void merge(T u_k_1_);


             */
            void set_dt(T dt_);


             * @param[in] Kp_ Proportional gain.
             */
            void set_Kp(T Kp_);


             *
             * @param[in] T_i_ Integral time constant.
             */
            void set_Ti(T T_i_);

             * @brief Sets the derivative time constant.
             *
             * @param[in] T_d_ Derivative time constant.
             */
            void set_Td(T T_d_);

            /**
             * @brief Sets the maximum integral contribution.
             *
             * @param[in] I_max_ Maximum allowed integral contribution.
             */
            void set_I_max(T I_max_);


            void set_u_max(T u_max_);


             */
            void set_d_filter(bool d_filter_);


             * @param[in] fc_ Cutoff frequency in Hz.
             */
            void set_fc(T fc_);


             *
             * @param[in] u_ff_ Feed-forward control input.
             */
            void set_ff(T u_ff_);

             * @brief Gets the controller sampling time.
             *
             * @return Sampling time in seconds.
             */
            T get_dt();

            T get_Kp();

            T get_T_i();

            T get_T_d();

            T get_I_max();

            T get_u_max();

            bool get_d_filter();

            T get_fc();

            T get_ff();

            T get_P();

            T get_I();

            T get_D();

            T get_u();

            T get_e_k_1();
 
        private:
            LPF_1<T> lpf;

            T dt = 0.0;

            T Kp = 0.0;

            T T_i = 0.0;

            T T_d = 0.0;

            T I_max = 0.0;

            T u_max = 0.0;

            bool d_filter = false;

            T fc = 0.0;

            T e_k_1 = 0.0;

            T P = 0.0;

            T I = 0.0;

            T D = 0.0;

            T u = 0.0;

            T u_ff = 0.0;

            bool start = true;
        };
 
#include "../../src/pid/pid_s.tpp"
    }
}
 
#endif