pid_lpf_1_ff.h

Go to the documentation of this file.

 * @details
 * This file defines the @ref control_system::pid::PID_LPF_1_FF class,
 * which implements a discrete-time proportional-integral-derivative
 * (PID) controller with a first-order low-pass filtered derivative
 * contribution and feed-forward control.
 *
 * The controller uses configurable proportional, integral, and
 * derivative gains together with a derivative filter cutoff frequency.
 * A feed-forward contribution can be added to the PID controller output.
 *
 * Previous controller outputs and control errors are maintained as
 * internal state variables.
 *
 * The controller output is constrained by a configurable maximum
 * output limit.
 *
 * @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_LPF_1_FF_H
#define CONTROL_SYSTEM_PID_PID_LPF_1_FF_H
 
#include <cstdint>
#include "../utility/utility.h"
 
namespace control_system
{
     * @namespace control_system
     * @brief Contains control-system algorithms and controllers.
     */
 
    namespace pid
    {


         * The controller is configured using the sampling time,
         * proportional gain, integral gain, derivative gain, derivative
         * filter cutoff frequency, previous controller outputs, and
         * maximum output limit.
         *
         * @tparam T Numeric data type used for the controller.
         *
         * @par Example
         * @code{.cpp}
         * control_system::pid::PID_LPF_1_FF<double> controller;
         *
         * controller.init(
         *     0.001,
         *     Kp,
         *     Ki,
         *     Kd,
         *     10.0,
         *     0.0,
         *     0.0,
         *     100.0
         * );
         *
         * double output = controller.update(reference, measurement, feed_forward);
         * @endcode
         */
        template <typename T>
        class PID_LPF_1_FF
        {
        public:
            /**
             * @brief Constructs a PID controller with filtered derivative
             * and feed-forward support.
             *
             * @details
             * Constructs the controller with its parameters and internal
             * state initialized to their default values.
             */
            PID_LPF_1_FF();


             *
             * @param[in] dt_ Controller sampling time in seconds.
             * @param[in] Kp_ Proportional gain.
             * @param[in] Ki_ Integral gain.
             * @param[in] Kd_ Derivative gain.
             * @param[in] fc_ Derivative filter cutoff frequency in Hz.
             * @param[in] u_k_1_ Previous controller output.
             * @param[in] u_k_2_ Controller output from two iterations ago.
             * @param[in] u_max_ Maximum allowed controller output.
             *
             * @details
             * Initializes the PID controller parameters, derivative filter
             * parameters, previous controller outputs, and output limit.
             */
            void init(T dt_, T Kp_, T Ki_, T Kd_, T fc_, T u_k_1_, T u_k_2_, T u_max_);


             *
             * @param[in] dt_ Controller sampling time in seconds.
             * @param[in] Kp_ Proportional gain.
             * @param[in] Ki_ Integral gain.
             * @param[in] Kd_ Derivative gain.
             * @param[in] fc_ Derivative filter cutoff frequency in Hz.
             * @param[in] u_k_1_ Previous controller output.
             * @param[in] u_k_2_ Controller output from two iterations ago.
             * @param[in] u_max_ Maximum allowed controller output.
             *
             * @details
             * Updates the PID gains, sampling time, derivative filter
             * cutoff frequency, previous controller outputs, and output
             * limit.
             */
            void set_param(T dt_, T Kp_, T Ki_, T Kd_, T fc_, T u_k_1_, T u_k_2_, T u_max_);

             * @brief Computes the PID control output with feed-forward.
             *
             * @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 including the feed-forward
             * contribution and limited by the configured maximum output.
             *
             * @details
             * Calculates the proportional, integral, and derivative
             * contributions. The derivative contribution is filtered
             * using the configured first-order low-pass filter, and the
             * feed-forward contribution is incorporated into the final
             * controller output.
             */
            T update(T x_0, T x, T u_ff_ = 0.0);

            /**
             * @brief Resets the PID controller state.
             *
             * @details
             * Resets the stored controller outputs, control errors,
             * feed-forward value, and startup state.
             */
            void reset();


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


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


            void set_Kp(T Kp_);

            void set_Ki(T Ki_);

            void set_Kd(T Kd_);

            void set_fc(T fc_);

            void set_ff(T u_ff_);

            void set_u_0(T u_k_1_);

            void set_u_max(T u_max_);

            T get_dt();

            T get_Kp();

            T get_Ki();

            T get_Kd();

            T get_fc();

            T get_ff();

            T get_u_k_1();

            T get_e_k_1();

            T get_e_k_2();

            T get_u_max();
 
        private:
            T dt = 0.0;

            T u_k_1 = 0.0;

            T u_k_2 = 0.0;

            T e_k_1 = 0.0;

            T e_k_2 = 0.0;

            T Kp = 0.0;

            T Ki = 0.0;

            T Kd = 0.0;

            T tau = 0.0;

            T u_ff = 0.0;

            T u_max = 9999999999;

            uint8_t start = 0;
        };
 
#include "../../src/pid/pid_lpf_1_ff.tpp"
    }
}
 
#endif