pid_gs.h

Go to the documentation of this file.

 * @details
 * This file defines the @ref control_system::pid::PID_GS class, which
 * implements a discrete-time proportional-integral-derivative (PID)
 * controller with gain scheduling.
 *
 * The controller supports configurable proportional, integral, and
 * derivative gains, integral and output limits, optional derivative
 * filtering, and feed-forward control.
 *
 * The PID gains can be scheduled according to an operating condition
 * using user-provided lookup tables. The controller interpolates the
 * gain values between lookup-table points.
 *
 * @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_GS_H
#define CONTROL_SYSTEM_PID_PID_GS_H
 
#include <cstdint>
#include "filters.h"
#include "../utility/utility.h"
 
namespace control_system
{
 
    namespace pid
    {

         * @brief Contains proportional-integral-derivative controller implementations.
         */


         *     Kd,
         *     I_max,
         *     u_max
         * );
         *
         * controller.set_gain_lookup_table(
         *     op_cond_arr,
         *     Kp_arr,
         *     Ki_arr,
         *     Kd_arr,
         *     len
         * );
         *
         * double output = controller.update(
         *     reference,
         *     measurement,
         *     feed_forward,
         *     operating_condition
         * );
         * @endcode
         */
        template <typename T>
        class PID_GS
        {
        public:
             * @details
             * Constructs the controller with its parameters and internal
             * state initialized to their default values.
             */
            PID_GS();

            void init(T dt_, T Kp_, T Ki_, T Kd_, T I_max_, T u_max_, bool d_filter_ = false, T fc_ = 10.0);


             * Updates the controller parameters and derivative filter
             * configuration.
             */
            void set_param(T dt_, T Kp_, T Ki_, T Kd_, T I_max_, T u_max_, bool d_filter_ = false, T fc_ = 10.0);


             *
             * @param[in] x_0 Reference or desired value.
             * @param[in] x Current or measured value.
             * @param[in] u_ff_ Feed-forward control input.
             * @param[in] op_cond_ Current operating condition used for
             * gain scheduling.
             *
             * @return PID controller output.
             *
             * @details
             * Updates the PID gains according to the supplied operating
             * condition, calculates the proportional, integral, derivative,
             * and feed-forward contributions, and produces the controller
             * output.
             *
             * The integral contribution and final controller output are
             * subject to their configured limits.
             */
            T update(T x_0, T x, T u_ff_ = 0.0, T op_cond_ = 0.0);


             * Resets the stored control error, proportional, integral,
             * derivative, controller output, and startup state.
             */
            void reset();

             * @brief Merges an external controller output into the PID state.
             *
             * @param[in] u_k_1_ Previous or externally provided controller
             * output.
             *
             * @details
             * Updates the internal controller state using the specified
             * previous controller output.
             */
            void merge(T u_k_1_);


             *
             * @param[in] op_cond_arr_ Array containing operating-condition
             * values.
             * @param[in] Kp_arr_ Array containing proportional gain values.
             * @param[in] Ki_arr_ Array containing integral gain values.
             * @param[in] Kd_arr_ Array containing derivative gain values.
             * @param[in] len_arr_ Number of elements in each lookup table.
             *
             * @details
             * Configures the lookup tables used to determine the
             * proportional, integral, and derivative gains as a function
             * of the operating condition.
             */
            void set_gain_lookup_table(T *op_cond_arr_, T *Kp_arr_, T *Ki_arr_, T *Kd_arr_, uint16_t len_arr_);


             * @param[in] dt_ Sampling time in seconds.
             */
            void set_dt(T dt_);


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

             * @brief Sets the integral gain.
             *
             * @param[in] Ki_ Integral gain.
             */
            void set_Ki(T Ki_);

            /**
             * @brief Sets the derivative gain.
             *
             * @param[in] Kd_ Derivative gain.
             */
            void set_Kd(T Kd_);


            void set_I_max(T I_max_);


             */
            void set_u_max(T u_max_);


             * @param[in] d_filter_ Derivative filter enable state.
             */
            void set_d_filter(bool d_filter_);


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

             * @brief Sets the feed-forward control input.
             *
             * @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_Ki();

            T get_Kd();

            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;

            void update_gain(T op_cond_);

            T interpolate(T x, T x1, T y1, T x2, T y2);

            T dt = 0.0;

            T Kp = 0.0;

            T Ki = 0.0;

            T Kd = 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;

            T *op_cond_arr;

            T *Kp_arr;

            T *Ki_arr;

            T *Kd_arr;

            uint16_t len_arr;

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